dis.asm

大量的汇编程序源代码

	add	si,cx
	push	si
ImmLp:
	dec	si
	mov	al,ds:[si]
	call	HexByteDis
	loop	ImmLp
	pop	si
	ret	

Group3:
	mov	bx,offset DGroup:tGrp3Ops
	call	IndexRm
	push	ax
	call	ModRmSize
	pop	ax
	and	al,7*8			;Mask to operation bits
	cmp	al,1			;Is it TEST?
	jbe	ShowImm			;Yes, has immediate value
	ret

MovImMem:
	mov	bx,offset DGroup:MovOp
	call	CopyMsgTab
	lodsb
	call	ModRm
	jmp	ShowImm

Coprocessor:
	mov	bx,offset DGroup:EscOp
	call	CopyMsgTab
	lodsb				;Get R/M byte
	push	ax
	and	ax,7*8+700H		;Get middle bits of al, low bits of ah
	shl	al,1			;Now in high nybble
	or	al,ah
	call	HexByteDis
	mov	al,","
	stosb
	pop	ax
	jmp	ModRm

Group4:
	mov	bx,offset DGroup:tGrp4Ops
	call	IndexRm
	push	ax
;Look for far call (3*8) and far jump (5*8)
	sub	al,3*8			;Now 0*8 or 2*8
	and	al,5*8			;Get middle bits
	jnz	@F
	or	[Prefix],fData32	;Set operand size to dword
@@:
	pop	ax
	call	ModRmSize
Ret1:
	ret

AamAad:
	mov	bx,[bx].AamAadOps
	call	CopyMsg
	lodsb				;Next byte "should" be 10
	cmp	al,10			;Standard instruction?
	jz	Ret1
	push	ax			;Save value
	mov	al,9
	stosb
	pop	ax
	jmp	HexByteDis

InOut:
	mov	bx,[bx].InOutOps
	call	CopyMsgTab
	test	ah,2			;IN instruction?
	jnz	ShowPort
AxInpOut:
	xor	al,al			;Select al/ax
	push	ax
	call	ShowReg
	pop	ax
	test	ah,2			;IN instruction?
	jnz	Ret1			;No, already did port
	mov	al,","
	stosb
ShowPort:
	push	ax
	test	ah,8			;Immediate port?
	jz	ImmedPort
	mov	ax,"xd"
	stosw
	jmp	short PortDone

ImmedPort:
	call	ByteImm
PortDone:
	pop	ax
	test	ah,2			;IN instruction?
	jz	Ret1			;Yes, already did register
	mov	al,","
	stosb
	jmp	AxInpOut

String:
	mov	bx,[bx].StringOps
	call	CopyMsg
	mov	al,"b"			;Assume byte version
	test	ah,1			;word/dword?
	jz	StrTyp
	mov	al,"d"
	test	[Prefix],fData32
	jnz	StrTyp
	mov	al,"w"
StrTyp:
	stosb
TabOverride:
	cmp	[Override],0		;Segment override present?
	jz	NoOver
	mov	al,9
	stosb
SegOverride:
	mov	bl,[Override]
	cmp	bl,0			;Segment override present?
	jz	NoOver
	mov	bh,0
	shl	bx,1
	mov	ax,[bx-2].tSegReg
	stosw
	mov	al,":"
	stosb
NoOver:
	ret

XlatInst:
	mov	bx,offset DGroup:XlatOp
	call	CopyMsg
	jmp	TabOverride

SegPush:
	mov	bx,[bx].SegPushOps
	call	CopyMsgTab
	mov	al,ah
	and	ax,18H			;Mask to seg reg bits
	shr	ax,1
	shr	ax,1
	xchg	bx,ax
	mov	ax,[bx].tSegReg
	stosw
	ret

OneReg:
	mov	bx,[bx].OneRegOps	;Point to opcode
	call	CopyMsgTab
	mov	al,ah
	mov	ah,1			;Indicate word operation
	jmp	ShowReg


XchgAx:
	mov	bx,offset DGroup:XchgOp
	call	CopyMsgTab
	mov	al,ah
	mov	ah,1			;Word reg
	push	ax
	mov	ax,"xa"
	stosw
	jmp	short SecondReg

LdPointer:
	mov	bx,[bx].LdPointerOps	;Point to opcode
	or	ah,3			;Set WORD, to CPU
	jmp	short RegMem

Arith:
	mov	bx,[bx].ArithOps	;Point to opcode
RegMem:
	call	CopyMsgTab
	lodsb				;Get R/M byte
	mov	dl,al
	mov	cl,3
	shr	al,cl			;Put register in low end
	test	ah,2			;Check direction
	jnz	ToCpu
	push	ax
	xchg	al,dl
	call	ModRm
SecondReg:
	mov	al,","
	stosb
	pop	ax
	jmp	ShowReg

ToCpu:
;List register in R/M byte first
	mov	dh,ah
	push	dx
	call	ShowReg
	mov	al,","
	stosb
	pop	ax
	jmp	ModRm

Jump:
	mov	bx,[bx].JumpOps
	call	CopyMsgTab
	test	ah,2			;Is it far?
	lodsw				;Get offset
	jz	RelJump
	xchg	dx,ax
	call	WordImm			;Print segment
	mov	al,":"
	stosb
	xchg	ax,dx			;Offset back to ax
	jmp	short HexWordDis

Group2:
;Shifts
	mov	bx,offset DGroup:tShiftOps
	call	IndexRm
	push	ax
	call	ModRmSize
	pop	ax
	mov	al,","
	stosb
	test	ah,10H			;Immediate count of shifts?
	jz	ByteImm
	mov	al,"1"
	test	ah,2			;One bit shift?
	jz	OneChar
	mov	ax,"lc"
	stosw
	ret

Group1:
;Arithmetic immediate
	mov	bx,offset DGroup:ArithOps
	call	IndexRm
	push	ax
	call	ModRmSize
	pop	ax
	mov	al,","
	stosb
	test	ah,1
	jz	ByteImm
	test	ah,2
	jz	WordImm
	lodsb				;Get 8-bit displacement
SignedByte:
	mov	ah,al
	or	al,al			;Check sign
	mov	al,"+"
	jns	@F
	mov	al,"-"
	neg	ah
@@:
	stosb				;Store sign
	xchg	al,ah
	jmp	short HexByteDis

ByteImm:
	lodsb
	jmp	short HexByteDis

RetImm:
	mov	bx,[bx].RetImmOps
	call	CopyMsgTab
WordImm:
	lodsw
	jmp	short HexWordDis

CondJump2:
	mov	bx,[bx].CondJump2Ops	;Point to opcode
	jmp	short AllCondJump

CondJump:
	mov	bx,[bx].CondJumpOps	;Point to opcode
AllCondJump:
	call	CopyMsgTab
	lodsb				;Get displacement
	cbw
RelJump:
	add	ax,si			;Compute target address
HexWordDis:
;Convert word in ax to ASCII hex and store
	mov	cl,al
	mov	al,ah
	call	HexByteDis
	mov	al,cl
HexByteDis:
;Convert byte in al to ASCII hex and store
	mov	ah,al
	shr	al,1
	shr	al,1
	shr	al,1
	shr	al,1
	call	Nybble
	mov	al,ah
Nybble:
;Convert low nybble in AL to hex and stosb
	and	al,0FH
	cmp	al,10
	sbb	al,69H
	das
OneChar:
	stosb
	ret

Interrupt:
	mov	bx,offset DGroup:IntOp
	call	CopyMsgTab
	test	ah,1			;With immediate byte?
	jnz	ByteImm
	mov	al,"3"
	stosb
	ret

CopyMsgTab:
	call	CopyMsg
	mov	al,9
	stosb
	ret

OneByte2:
	mov	bx,[bx].OneByte2Ops	;Point to opcode
	jmp	short CopyMsg

OneByte:
	mov	bx,[bx].OneByteOps	;Point to opcode
	jmp	short CopyMsg

CopyMore:
	stosb
CopyMsg:
	mov	al,DGroup:[bx]
	inc	bx
	or	al,al			;End of string?
	jns	CopyMore
	and	al,7FH
	stosb
	ret

IndexRm:
	lodsb				;Get R/M byte
	mov	dl,al
	and	al,7*8			;Mask to operation field
	shr	al,1
	shr	al,1
	add	bl,al
	adc	bh,0
	mov	bx,cs:[bx]
	call	CopyMsgTab
	mov	al,dl			;R/M byte back to al
	ret

;****************************************************************************
	subttl	ModRm, ModRmSize, and ShowReg
	page

;ModRm displays a memory or register operand.
;
;ModRmSize includes a leading "byte ptr" (or whatever) to indicate size
;if the operand is not a register.
;
;ShowReg looks up a register.
;
;As always, ds:si points to code to disassemble, es:di points to destination
;buffer.  These pointers will be updated as appropriate.


ModRmSize:
	mov	cl,1			;Indicate a size is needed
	jmp	short ModRmCommon

ModRm:
;Inputs:
;	al = R/M byte
;	ah bit 1 has word flag (0 = byte)
;Outputs:
;	cx = no. of bytes in operand

	xor	cx,cx			;Operand size not needed
ModRmCommon:
	and	al,0C7H			;Mask out middle bits
	cmp	al,0C0H			;Register mode?
	jb	MemOp

ShowReg:
;Display general register
;Inputs:
;	al bits 0 - 2 have register number
;	ah bit 1 has word flag (0 = byte)
;Outputs:
;	cx = no. of bytes in register

	and	al,7			;Get register
	mov	bl,al
	mov	bh,0
	shl	bx,1			;Word index into register
	and	ah,1			;Byte size?
	mov	cl,ah
	mov	ch,0
	jz	RegIndex
	add	bx,offset tWordReg - offset tByteReg
	test	[Prefix],fData32
	jz	RegIndex
	mov	al,"e"
	stosb
	mov	cl,3
RegIndex:
	inc	cx
	mov	ax,[bx].tByteReg
	stosw
	ret

MemOp:
	push	ax
	mov	bx,offset DGroup:ByteMsg
	mov	dx,1
	test	ah,1			;Check word bit
	jz	ShowMemSize
	mov	bx,offset DGroup:WordMsg
	inc	dx
	test	[Prefix],fData32	;32-bit data mode?
	jz	ShowMemSize
	mov	bx,offset DGroup:DwordMsg
	inc	dx
	inc	dx
ShowMemSize:
	jcxz	NoMemSize
	call	CopyMsg
	mov	bx,offset DGroup:PtrMsg
	call	CopyMsg
NoMemSize:
	call	SegOverride
	mov	al,"["
	stosb
	pop	ax
	test	[Prefix],fAddr32	;32-bit address mode?
	jnz	Addr32
	cmp	al,6			;Direct address mode?
	jz	Disp16
	mov	ch,al
	and	al,7
	mov	bx,offset DGroup:AddrMod16
	xlat	AddrMod16		;Get address registers
	mov	cl,al
	test	cl,AddrBp
	jnz	UseBp
	test	cl,AddrBx
	jz	TestAddrSi
	mov	ax,"xb"
	stosw
TestPlus:
	test	cl,AddrPlus
	jz	DispTest
	mov	al,"+"
	stosb
TestAddrSi:
	test	cl,AddrSi
	jnz	UseSi
	test	cl,AddrDi
	jz	DispTest
	mov	ax,"id"
	stosw
DispTest:
	and	ch,0C0H			;Displacement?
	jz	EndMem
	mov	al,"+"
	js	AddDisp16
	lodsb
	cbw
	call	SignedByte
EndMem:
	mov	cx,dx			;Operand size to cx
	mov	al,"]"
	stosb
	ret

UseBp:
	mov	ax,"pb"
	stosw
	jmp	TestPlus

UseSi:
	mov	ax,"is"
	stosw
	jmp	DispTest

Addr32:
;UNDONE

AddDisp16:
	stosb
Disp16:
	lodsw				;Get 16-bit displacement
	call	HexWordDis
	jmp	EndMem


	end