;
;
;	Copyright (C) Microsoft Corporation, 1987
;
;	This Module contains Proprietary Information of Microsoft
;	Corporation and should be treated as Confidential.
;
subttl	em386.asm - Main Entry Point and Address Calculation Procedure
page
;*********************************************************************;
;								      ;
;	  Main Entry Point and Address Calculation Procedure	      ;
;								      ;
;		80386 version					      ;
;								      ;
;*********************************************************************;
;
; This routine fetches the 8087 instruction, calculates memory address
; if necessary into ES:ESI and calls a routine to emulate the instruction.
; Most of the dispatching is done through tables. (see comments in CONST)
;
; The instruction dispatching is designed to favor the 386 addressing modes

ifdef	XENIX

LDT_DATA=	02Fh		; emulator data LDT
STACK_ALIAS=	027h		; 32 bit alias for stack selector

endif	;XENIX

;------------------------------------------------------------------------------
;
;	emulation entry point
;
;------------------------------------------------------------------------------

pub	protemulation

	cld				; clear direction flag forever

ifdef	XENIX
	push	ss			; save ss
endif	;XENIX

	push	eax			; for common exit code (historical)

	push	ds			; save segment registers

ifdef	XENIX

	push	eax			; UNDONE - slow

	mov	ax,LDT_DATA		; load up emulator's data segment
	mov	ds,ax
	cmp	[Einstall],0		; check if emulator is initialized
	je	installemulator 	;   no - go install it

pub	protemcont

	pop	eax			; UNDONE - slow

endif	;XENIX

	push	es
	push	ss			;   save SegOvr (bp forces SS override)

	push	edi			; save registers
	push	esi			;   must be in this order for indexing
	push	ebp
	push	esp
	push	ebx
	push	edx
	push	ecx
	push	eax

ifdef	XENIX

	mov	ax,ss			; check for 286 using user SS
	lar	eax,ax			; load extended access bits
	test	eax,00400000h		; test BIG bit
	jnz	short prot386		;   386 - ok

	mov	ax,STACK_ALIAS		; setup stack with 32 bit alias segment
	mov	ss,ax
	movzx	esp,sp			; clean up ESP
;	mov	word ptr [esp].regEIP+2,0 ; clean up EIP

pub	prot386

endif	;XENIX

	mov	ebp,esp 		; set up frame pointer
	add	[ebp].regESP,regFlg-regESP	; adjust to original esp

	mov	eax,edi 		; may use original DI to calc address
	lds	edi,fword ptr [ebp].regEIP ; ds:edi = 287 instruction address
	mov	cx,[edi]		; cx = esc 0-7 and opcode

	cmp	cl,09Bh 		; UNDONE - check FWAIT's getting through
	je	sawFWAIT		; UNDONE -   and ignore it

	add	edi,2			; point to displacement
	add	cl,28h			; set carry if esc 0-7 (and cl = 0-7)
	jnc	short protSegOvr	;   no carry - must be segment override

	mov	es,[ebp].regDS		; es = user data segment
	mov	edx,ebx 		; may use original BX to calc address

pub	CommonDispatch
	rol	ch,2			; rotate MOD field next to r/m field


; UNDONE
; UNDONE  should check for instruction prefixes such as address size prefix
; UNDONE

	lar	ebx,[ebp].regCS 	; check if 286 or 386 segment
	test	ebx,00400000h		;
	mov	bl,ch			; get copy of operation
	jz	short Have286segment	;   286 segment - assume 286 addressing

	and	ebx,1FH 		; Mask to MOD and r/m fields
	jmp	EA386Tab[4*ebx]

pub	Have286segment
	and	ebx,1FH 		; Mask to MOD and r/m fields
	jmp	EA286Tab[4*ebx]


;	protect mode Segment override case

glb	<protSegOvrTab>

protSegOvrTab	label	word

	dd	DSSegOvr	; 11
	dd	ESSegOvr	; 00
	dd	CSSegOvr	; 01
	dd	SSSegOvr	; 10


pub	protSegOvr
	mov	edx,ebx 		; may use original BX to calc 286 address
	mov	bl,cl
	shr	bl,1
	and	ebx,0Ch 		; bl = (seg+1) and 0Ch
	inc	edi			; point to displacement
	mov	cx,[edi-2]		; cx = esc 0-7 and opcode
	jmp	protSegOvrTab[ebx]	; process appropriate segment override


pub	DSSegOvr			; 00
	mov	es,[ebp].regDS		; set ES to EA segment
	jmp	short ESSegOvr

pub	CSSegOvr			; 10
	push	ds			; DS = caller's CS
	pop	es			; set ES to EA segment
	jmp	short ESSegOvr

pub	SSSegOvr			; 01
	push	ss			; SS = caller's SS
	pop	es			; set ES to EA segment

pub	ESSegOvr			; 11
	mov	[ebp].regSegOvr,es	; save for bp rel EAs
	jmp	CommonDispatch


;	386 address modes

;	SIB does not handle SS overrides for ebp

SIB	macro	modval
	local	SIBindex,SIBbase

	xor	ebx,ebx
	mov	bl,[edi]		; ebx = SIB field
	inc	edi			; bump past SIB field
	mov	eax,ebx
	and	al,7			; mask down to base register

if	modval eq 0
	cmp	al,5			; base = ebp
	jne	short SIBbase		;   yes - get base register value
	mov	eax,[edi]		; eax = disp32
	add	edi,4			; bump past displacement
	jmp	short SIBindex
endif

SIBbase:
	mov	eax,[ebp+4*eax] 	; eax = base register value

SIBindex:
	mov	[ebp].regESP,0		; no esp indexing allowed
	push	ecx			; UNDONE - slow
	mov	cl,bl
	shr	cl,6			; cl = scale factor
	shr	bl,1
	and	bl,1Ch			; ebx = 4 * index register
	mov	esi,[ebp+ebx]		; esi = index register value
	shl	esi,cl			; esi = scaled index register value
	pop	ecx			; UNDONE - slow
	add	esi,eax 		; esi = SIB address value
	endm


pub	SIB00
	SIB	00			; decode SIB field
	jmp	CommonMemory

pub	SIB01
	SIB	01			; decode SIB field
	mov	al,[edi]
	inc	edi
	cbw				; ax = al
	cwde				; eax = ax
	add	esi,eax
	jmp	short CommonMemory

pub	SIB10
	SIB	10			; decode SIB field
	mov	eax,[edi]
	add	edi,4
	add	esi,eax
	jmp	short CommonMemory


;	386 single register addressing

pub	Exx00
	and	bl,1Ch			; mask off mod bits
	mov	esi,[ebp+ebx]
	jmp	short CommonMemory

pub	Exx01
	and	bl,1Ch			; mask off mod bits
	mov	esi,[ebp+ebx]
	mov	al,[edi]
	inc	edi
	cbw				; ax = al
	cwde				; eax = ax
	add	esi,eax
	jmp	short CommonMemory

pub	Exx10
	and	bl,1Ch			; mask off mod bits
	mov	esi,[ebp+ebx]
	mov	eax,[edi]
	add	edi,4
	add	esi,eax
	jmp	short CommonMemory


;	386 direct addressing

pub	Direct386
	mov	esi,[edi]
	add	edi,4

pub	CommonMemory
	MOV	[ebp].regEIP,edi	; final return offset
	mov	ax,LDT_DATA
	mov	ds,ax
	mov	[CURerr],MemoryOperand	; clear current error, set mem. op bit

; At this point ES:SI = memory address, CX = |Op|r/m|MOD|escape|MF|Arith|

	shr	ch,4			; Move Op field to BX for Table jump
	mov	bl,ch
	and	ebx,0EH

	test	cl,1			; Arith field set?
	JZ	short ArithmeticOpMem

pub	NonArithOpMem
	CALL	NonArithOpMemTab[2*ebx] ; is CH shl 4 needed?
	JMP	EMLFINISH

pub	ArithmeticOpMem
	PUSH	ebx			; Save Op while we load the argument
	CALL	eFLDsdri		; emulate proper load
	POP	ebx

	mov	ax,ds			; ES = DS = task data area
	mov	es,ax
	MOV	esi,[CURstk]		; address top of stack
	MOV	edi,esi
	ChangeDIfromTOStoNOS
	MOV	[RESULT],edi		; Set up destination Pointer

	JMP	short DoArithmeticOpPop


pub	NoEffectiveAddress		; Either Register op or Miscellaneous

	MOV	[ebp].regEIP,edi	; final return offset

	xor	eax,eax
	mov	di,LDT_DATA
	mov	ds,di
	mov	es,di
	mov	[CURerr],ax		; clear current error, memory op bit

; CX = |Op|r/m|MOD|escape|MF|Arith|

	mov	bl,ch
	shr	bl,4			; Mov Op field to BX for jump
	and	ebx,0Eh

	TEST	CL,1			; Arith field set?
	JZ	short ArithmeticOpReg

pub	NonArithOpReg
	CALL	NonArithOpRegTab[2*ebx]
	JMP	EMLFINISH


; For register arithmetic operations, one operand is always the stack top.
; The r/m field of the instruction is used to determine the address of
; the other operand (ST(0) - ST(7))
; CX = xxxRRRxxxxxxxxxx (x is don't care, RRR is relative register # 0-7)

pub	ArithmeticOpReg

	call	RegAddr 		;di <= address of 2nd operand
					;carry set if invalid register
	jc	short InvalidOperand	;no, invalid operand, don't do operation

	MOV	[RESULT],esi		; Set destination to TOS
	TEST	CL,04H			; Unless Dest bit is set
	JZ	short DestIsSet 	; in which case
	MOV	[RESULT],edi		; Set destination to DI

pub	DestIsSet
					; Need to Toggle Reverse bit for DIV or SUB
	TEST	BL,08H			; OP = 1xx for DIV and SUB; BX = |0000|OP|O|
	JZ	short SetUpPop
	XOR	BL,02H			; Toggle Reverse bit

pub	SetUpPop
	TEST	CL,02H
	JZ	short DoArithmeticOpNoPop

pub	DoArithmeticOpPop
	CALL	ArithmeticOpTab[2*ebx]

	POPST
	JMP	short EMLFINISH

pub	DoArithmeticOpNoPop
	CALL	ArithmeticOpTab[2*ebx]
	JMP	short EMLFINISH


;***	InvalidOperand - register operand does not exist
;
;	RETURNS
;		sets Stack Underflow and Invalid bits in [CURerr]
;
;	DESCRIPTION
;		a reference was made to a register that does not
;		exist on the stack.  Set error bits and exit.

pub	InvalidOperand

	call	UnderStk		;indicate stack underflow error
	or	[CURerr],Invalid	;indicate invalid operand
	jmp	short EMLFINISH 	;don't execute instruction


;***	RegAddr - compute register address
;
;	ARGUMENTS
;		CX = |Op|r/m|MOD|esc|MF|Arith|
;		r/m = register whose address is to be computed
;
;	RETURNS
;		SI = address of top of stack
;		DI = address of requested register
;		PSW.C set if register is not valid
;		PSW.C reset if register is valid
;
;	DESCRIPTION
;		multiply register number by 12 and subtract this from
;		[CURstk] (the address of TOS) to compute address of
;		register referenced by r/m.
;
;	REGISTERS
;		modifies dx

pub	RegAddr
	mov	esi,[CURstk]		; address top of stack
	mov	edi,esi

;set up address of 2nd operand based on r/m field of instruction

	xor	edx,edx
	mov	dl,ch			; dl <== byte containing reg#
	and	dl,01ch 		; mask all but r/m field

; Since r/m field contains the relative reg # in bits 2-4 of dl,
; and bits 0-1 of dl are zero, dl now contains 4*(reg #).  To compute
; the memory location of this register, calculate 12*(reg #) and
; subtract this from di, which contains the address of the TOS.  reg #
; is multiplied by 12 because that is the number of bytes in each stack
; entry.

	lea	edx,[2*edx+edx] 	; edx = 3 * (4 * reg #)
	sub	edi,edx 		; di is address of second operand
	cmp	edi,[BASstk]		; is register in range?
	clc				; assume valid register
	jg	short RAclc		; valid - skip next instruction
	cmc				; set carry to indicate invalid register
pub RAclc
	ret


pub	CallUnused
	CALL	UNUSED			; Treat as unimpleminted
	jmp	short EMLFINISH


;	sawFWAIT - UNDONE - workaround for a 386 bug

pub	sawFWAIT
	inc	edi			; bump past FWAIT
	MOV	[ebp].regEIP,edi	; final return offset
	xor	eax,eax
	mov	di,LDT_DATA
	mov	ds,di
	mov	[CURerr],ax		; clear current error, memory op bit

; return from routine;	restore registers and return

pub	EMLFINISH
	pop	eax
	pop	ecx
	pop	edx
	pop	ebx
	add	esp,4			; toss esp value
	pop	ebp
	pop	esi
	pop	edi
	add	esp,4			; toss regSegOvr

;	check for errors

	MOV	AX,[CURerr]		; fetch errors
	or	[UserStatusWord],ax	; save all exception errors
	OR	[SWerr],AL		; set errors in sticky error flag
	NOT	AL			; make a zero mean an error
	MOV	AH,byte ptr [UserControlWord]  ; get user's IEEE control word
	OR	AH,0C2H 		; mask reserved, IEM and denormal bits
	AND	AH,03FH 		; unmask invalid instruction,
					;    stack overflow.
	OR	AL,AH			; mask for IEEE exceptions
	NOT	AL			; make a one mean an error
	MOV	AH,byte ptr (CURerr+1)	; get stack over/underflow flags
	TEST	AX,0FFFFh-MemoryOperand ; test for errors to report

	pop	es
	pop	ds


	jnz	short ExceptionsEmulator ;   goto error handler

pub	errret
        error_return    noerror          ; common exit sequence

pub	ExceptionsEmulator
	JMP	CommonExceptions


;------------------------------------------------------------------------------
;
;	286 address modes	(for XENIX only)
;
;------------------------------------------------------------------------------

ifdef	XENIX

; In the address calculations below:
;   DX has BX original value
;   AX has DI original value
;   SI has SI original value
;   BP has BP original value
;  [EDI] is address of displacement bytes

pub BXXI0D
	MOV	eax,edx 		; use original BX index value
pub DSDI0D
	MOV	esi,eax 		; use alternate index value
pub DSSI0D
	JMP	short ADRFIN		; have offset in SI

pub BPXI1D
	XOR	eax,eax 		; no index register
pub BPDI1D
	MOV	esi,eax 		; use alternate index value
pub BPSI1D
	ADD	esi,[ebp].regEBP	; add original BP value
	mov	es,[ebp].regSegOvr	; ES = override segment (or SS if none)
	JMP	short DSSI1D		; go get one byte displacement

pub BXSI1D
	MOV	eax,esi 		; really will want SI, not DI
pub BXDI1D
	ADD	edx,eax 		; now DX is original BX plus index
pub BXXI1D
	MOV	eax,edx 		; use original BX index value
pub DSDI1D
	MOV	esi,eax 		; use alternate index value
pub DSSI1D
	MOV	AL,[edi]		; get one byte displacement
	CBW				; sign extend displacement
	INC	edi			; get past displacement byte
	JMP	short DISPAD		; go add AX to SI (time w/ ADD)

pub BPXI2D
	XOR	eax,eax 		; no index register
pub BPDI2D
	MOV	esi,eax 		; use alternate index value
pub BPSI2D
	ADD	esi,[ebp].regEBP	; add original BP value
	mov	es,[ebp].regSegOvr	; ES = override segment (or SS if none)
	JMP	short DSSI2D		; go get two byte displacement

pub BXSI2D
	MOV	eax,esi 		; really will want SI, not DI
pub BXDI2D
	ADD	edx,eax 		; now DX is original BX plus index
pub BXXI2D
	MOV	eax,edx 		; use original BX index value
pub DSDI2D
	MOV	esi,eax 		; use alternate index value
pub DSSI2D
	MOV	AX,[edi]		; get two byte displacement
	INC	edi			; get past displacement byte
	INC	edi			; get past displacement byte
	JMP	short DISPAD		; go add AX to SI (time w/ ADD)

pub DSXI2D
	MOV	SI,[edi]		; get two byte displacement
	INC	edi			; get past displacement byte
	INC	edi			; get past displacement byte
	JMP	short ADRFIN		; have offset in AX

pub BPSI0D
	MOV	eax,esi 		; really will want SI, not DI
pub BPDI0D
	MOV	edx,[ebp].regEBP	; really will want BP, not BX
	mov	es,[ebp].regSegOvr	; ES = override segment (or SS if none)
pub BXDI0D
	MOV	esi,eax 		; use alternate index value
pub BXSI0D
	MOV	eax,edx 		; use original BX (or BP) as base

pub DISPAD
	ADD	esi,eax 		; add original index value

pub	ADRFIN
	movzx	esi,si			; ES:ESI = user memory address
	jmp	CommonMemory

endif	;XENIX