551 lines
11 KiB
C
551 lines
11 KiB
C
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Stack.c
|
|
|
|
Abstract:
|
|
|
|
This module implements routines for manipulating the 16 bit stack
|
|
|
|
Author:
|
|
|
|
Dave Hastings (daveh) 24-Nov-1992
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include "softpc.h"
|
|
|
|
#if 0 // Disable the code for now
|
|
VOID
|
|
FreePMStack(
|
|
USHORT Sel
|
|
);
|
|
|
|
USHORT
|
|
AllocatePMStack(
|
|
USHORT MemSize
|
|
);
|
|
|
|
#endif
|
|
|
|
VOID
|
|
DpmiPushRmInt(
|
|
USHORT InterruptNumber
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine pushes an interrupt frame on the stack and sets up cs:ip
|
|
for the specified interrupt.
|
|
|
|
Arguments:
|
|
|
|
InterruptNumber -- Specifies the index of the interrupt
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
PWORD16 StackPointer;
|
|
ULONG IntHandler;
|
|
|
|
// bugbug stack wrap???
|
|
|
|
ASSERT((getSP() > 6));
|
|
ASSERT((!(getMSW() & MSW_PE)));
|
|
|
|
StackPointer = (PWORD16)VdmMapFlat(getSS(), getSP(), VDM_V86);
|
|
|
|
*(StackPointer - 3) = (USHORT)(RmBopFe & 0x0000FFFF);
|
|
*(StackPointer - 2) = (USHORT)(RmBopFe >> 16);
|
|
*(StackPointer - 1) = getSTATUS();
|
|
|
|
setSP(getSP() - 6);
|
|
|
|
IntHandler = *(PDWORD16) (IntelBase + InterruptNumber*4);
|
|
setIP(LOWORD(IntHandler));
|
|
setCS(HIWORD(IntHandler));
|
|
}
|
|
|
|
VOID
|
|
BeginUseLockedPMStack(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine switches to the protected DPMI stack as specified by
|
|
the DPMI spec. We remember the original values of EIP and ESP in
|
|
global variables if we are at level zero. This allows us to correctly
|
|
return to a 32 bit routine if we are dispatching a 16-bit interrupt
|
|
frame.
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
#if 0 // Disabled for now
|
|
if (LockedPMStackSel == 0) {
|
|
LockedPMStackSel = AllocatePMStack(LockedPMStackOffset); // LockedPMStackOffset is acturally the size
|
|
LockedPMStackCount = 0;
|
|
|
|
//
|
|
// Note the stack allocation may still fail. In this case, the setSS() will set SS selector
|
|
// to zero and the error will be catched during BuildStackFrame() call
|
|
//
|
|
|
|
}
|
|
#endif
|
|
if (!LockedPMStackCount++) {
|
|
|
|
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_SWITCH_STACKS, (USHORT)LockedPMStackSel, LockedPMStackOffset);
|
|
|
|
PMLockOrigEIP = getEIP();
|
|
PMLockOrigSS = getSS();
|
|
PMLockOrigESP = getESP();
|
|
setSS(LockedPMStackSel);
|
|
setESP(LockedPMStackOffset);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
EndUseLockedPMStack(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine switches the stack back off the protected DPMI stack,
|
|
if we are popping off the last frame on the stack.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the stack was switched back, FALSE otherwise
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
|
|
if (!--LockedPMStackCount) {
|
|
|
|
//
|
|
// We probably should free the PM stack except the one passed from DOSX??
|
|
//
|
|
|
|
DBGTRACE(VDMTR_TYPE_DPMI | DPMI_SWITCH_STACKS, (USHORT)PMLockOrigSS, PMLockOrigESP);
|
|
|
|
setEIP(PMLockOrigEIP);
|
|
setSS((WORD)PMLockOrigSS);
|
|
setESP(PMLockOrigESP);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
BuildStackFrame(
|
|
ULONG StackUnits,
|
|
PUCHAR *pVdmStackPointer,
|
|
ULONG *pNewSP
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine builds stack frames for the caller. It figures if it needs
|
|
to use a 16 or 32-bit frame, and adjusts SP or ESP appropriately based
|
|
on the number of "stack units". It also returns a flat pointer to the
|
|
top of the frame to the caller.
|
|
|
|
Arguments:
|
|
|
|
StackUnits = number of registers needed to be saved on the frame. For
|
|
example, 3 is how many elements there are on an iret frame
|
|
(flags, cs, ip)
|
|
|
|
Return Value:
|
|
|
|
This function returns TRUE on success, FALSE on failure
|
|
|
|
VdmStackPointer - flat address pointing to the "top" of the frame
|
|
|
|
Notes:
|
|
|
|
BUGBUG This routine doesn't check for stack faults or 'UP' direction
|
|
stacks
|
|
--*/
|
|
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
USHORT SegSs;
|
|
ULONG VdmSp;
|
|
PUCHAR VdmStackPointer;
|
|
ULONG StackOffset;
|
|
ULONG Limit;
|
|
ULONG SelIndex;
|
|
ULONG NewSP;
|
|
BOOL bExpandDown;
|
|
BOOL rc;
|
|
|
|
rc = TRUE;
|
|
SegSs = getSS();
|
|
SelIndex = (SegSs & ~0x7)/sizeof(LDT_ENTRY);
|
|
|
|
Limit = (ULONG) (Ldt[SelIndex].HighWord.Bits.LimitHi << 16) |
|
|
Ldt[SelIndex].LimitLow;
|
|
|
|
//
|
|
// Make it paged aligned if not 4G size stack.
|
|
//
|
|
if (Ldt[SelIndex].HighWord.Bits.Granularity) {
|
|
Limit = (Limit << 12) | 0xfff;
|
|
}
|
|
if (Limit != 0xffffffff) Limit++;
|
|
|
|
|
|
if (Ldt[SelIndex].HighWord.Bits.Default_Big) {
|
|
VdmSp = getESP();
|
|
} else {
|
|
VdmSp = getSP();
|
|
}
|
|
|
|
if (CurrentAppFlags) {
|
|
StackOffset = StackUnits*sizeof(DWORD);
|
|
} else {
|
|
StackOffset = StackUnits*sizeof(WORD);
|
|
}
|
|
|
|
NewSP = VdmSp - StackOffset;
|
|
bExpandDown = (BOOL) (Ldt[SelIndex].HighWord.Bits.Type & 4);
|
|
if ((StackOffset > VdmSp) ||
|
|
(!bExpandDown && (VdmSp > Limit)) ||
|
|
(bExpandDown && (NewSP < Limit))) {
|
|
// failed limit check
|
|
ASSERT(0);
|
|
rc = FALSE;
|
|
}
|
|
|
|
*pNewSP = NewSP;
|
|
VdmStackPointer = VdmMapFlat(SegSs, VdmSp, VDM_PM);
|
|
*pVdmStackPointer = VdmStackPointer;
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
EmulateV86Int(
|
|
UCHAR InterruptNumber
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is responsible for simulating a real mode interrupt. It
|
|
uses the real mode IVT at 0:0.
|
|
|
|
Arguments:
|
|
|
|
IntNumber - interrupt vector number
|
|
Eflags - client flags to save on the stack
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
PVDM_INTERRUPTHANDLER Handlers = DpmiInterruptHandlers;
|
|
PUCHAR VdmStackPointer;
|
|
PWORD16 pIVT;
|
|
USHORT VdmSP;
|
|
USHORT NewCS;
|
|
USHORT NewIP;
|
|
ULONG Eflags = getEFLAGS();
|
|
|
|
VdmStackPointer = VdmMapFlat(getSS(), 0, VDM_V86);
|
|
VdmSP = getSP() - 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) Eflags;
|
|
VdmSP -= 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getCS();
|
|
VdmSP -= 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getIP();
|
|
setSP(VdmSP);
|
|
|
|
//
|
|
// See if this interrupt is hooked in protect mode, and if we should
|
|
// reflect there instead.
|
|
//
|
|
if (Handlers[InterruptNumber].Flags & VDM_INT_HOOKED) {
|
|
NewCS = (USHORT) (DosxRMReflector >> 16);
|
|
NewIP = (USHORT) DosxRMReflector;
|
|
//
|
|
// now encode the interrupt number into CS
|
|
//
|
|
NewCS -= (USHORT) InterruptNumber;
|
|
NewIP += (USHORT) (InterruptNumber*16);
|
|
} else {
|
|
PWORD16 pIvtEntry = (PWORD16) (IntelBase + InterruptNumber*4);
|
|
|
|
NewIP = *pIvtEntry++;
|
|
NewCS = *pIvtEntry;
|
|
}
|
|
|
|
setIP(NewIP);
|
|
setCS(NewCS);
|
|
//
|
|
// Turn off flags like the hardware would
|
|
//
|
|
setEFLAGS(Eflags & ~(EFLAGS_TF_MASK | EFLAGS_IF_MASK));
|
|
}
|
|
|
|
|
|
VOID
|
|
SimulateFarCall(
|
|
USHORT Seg,
|
|
ULONG Offset
|
|
)
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
PUCHAR VdmStackPointer;
|
|
USHORT VdmSP;
|
|
|
|
if (getMODE() == VDM_V86) {
|
|
|
|
VdmStackPointer = VdmMapFlat(getSS(), 0, VDM_V86);
|
|
VdmSP = getSP() - 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getCS();
|
|
VdmSP -= 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getIP();
|
|
setSP(VdmSP);
|
|
setCS(Seg);
|
|
setIP((USHORT)Offset);
|
|
|
|
} else {
|
|
DbgBreakPoint();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SimulateCallWithIretFrame(
|
|
USHORT Seg,
|
|
ULONG Offset
|
|
)
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
PUCHAR VdmStackPointer;
|
|
USHORT VdmSP;
|
|
|
|
if (getMODE() == VDM_V86) {
|
|
|
|
VdmStackPointer = VdmMapFlat(getSS(), 0, VDM_V86);
|
|
VdmSP = getSP() - 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getEFLAGS();
|
|
VdmSP -= 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getCS();
|
|
VdmSP -= 2;
|
|
*(PWORD16)(VdmStackPointer+VdmSP) = (WORD) getIP();
|
|
setSP(VdmSP);
|
|
setCS(Seg);
|
|
setIP((USHORT)Offset);
|
|
|
|
} else {
|
|
DbgBreakPoint();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SimulateIret(
|
|
IRET_BEHAVIOR fdsp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine simulates an IRET. The passed parameter specifies
|
|
how the flags are to be treated. In many situations, we pass the
|
|
value of the flags along, thus throwing away the flags on the stack.
|
|
|
|
In the case of PASS_FLAGS, we:
|
|
- clear all but the interrupt and trace flags in the caller's
|
|
original flags
|
|
- combine in the flags returned by the interrupt service routine.
|
|
This will cause us to return to the original routine with
|
|
interrupts on if they were on when the interrupt occured, or
|
|
if the ISR returned with them on.
|
|
|
|
|
|
Arguments:
|
|
|
|
fdsp - takes the value RESTORE_FLAGS, PASS_FLAGS or PASS_CARRY_FLAG
|
|
|
|
PASS_CARRY_FLAG_16 is a special value to indicate that this
|
|
iret will always be on a 16-bit iret frame.
|
|
|
|
|
|
--*/
|
|
{
|
|
DECLARE_LocalVdmContext;
|
|
USHORT SegSs;
|
|
ULONG VdmSp;
|
|
ULONG VdmStackPointer;
|
|
USHORT Flags;
|
|
|
|
SegSs = getSS();
|
|
|
|
if (getMODE() == VDM_V86) {
|
|
VdmSp = getSP() + 6;
|
|
VdmStackPointer = (ULONG) VdmMapFlat(SegSs, VdmSp, VDM_V86);
|
|
|
|
setCS(*(PWORD16)(VdmStackPointer - 4));
|
|
setIP(*(PWORD16)(VdmStackPointer - 6));
|
|
Flags = *(PWORD16)(VdmStackPointer - 2);
|
|
|
|
} else {
|
|
if (Frame32 && (fdsp!=PASS_CARRY_FLAG_16)) {
|
|
if (SEGMENT_IS_BIG(SegSs)) {
|
|
VdmSp = getESP();
|
|
} else {
|
|
VdmSp = getSP();
|
|
}
|
|
VdmSp += 12;
|
|
VdmStackPointer = (ULONG) VdmMapFlat(SegSs, VdmSp, VDM_PM);
|
|
|
|
setCS(*(PWORD16)(VdmStackPointer - 8));
|
|
setEIP(*(PDWORD16)(VdmStackPointer - 12));
|
|
Flags = *(PWORD16)(VdmStackPointer - 4);
|
|
|
|
} else {
|
|
|
|
VdmSp = getSP() + 6;
|
|
VdmStackPointer = (ULONG) VdmMapFlat(SegSs, VdmSp, VDM_PM);
|
|
|
|
setCS(*(PWORD16)(VdmStackPointer - 4));
|
|
setIP(*(PWORD16)(VdmStackPointer - 6));
|
|
Flags = *(PWORD16)(VdmStackPointer - 2);
|
|
|
|
}
|
|
}
|
|
|
|
switch(fdsp) {
|
|
|
|
case RESTORE_FLAGS:
|
|
break;
|
|
|
|
case PASS_FLAGS:
|
|
Flags = (Flags & 0x300) | getSTATUS();
|
|
break;
|
|
|
|
case PASS_CARRY_FLAG:
|
|
case PASS_CARRY_FLAG_16:
|
|
Flags = (Flags & ~1) | (getSTATUS() & 1);
|
|
break;
|
|
}
|
|
|
|
setSTATUS(Flags);
|
|
setESP(VdmSp);
|
|
}
|
|
|
|
#if 0 // Disable the code for now
|
|
|
|
USHORT
|
|
AllocatePMStack(
|
|
USHORT MemSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allocates PM stack.
|
|
|
|
Arguments:
|
|
|
|
MemSize - Must be less than 64k
|
|
|
|
Return Value:
|
|
|
|
if successful, selector of the PM stack
|
|
otherwise 0
|
|
|
|
--*/
|
|
{
|
|
PMEM_DPMI pMem;
|
|
|
|
pMem = DpmiAllocateXmem(MemSize);
|
|
|
|
if (pMem) {
|
|
|
|
pMem->SelCount = 1;
|
|
pMem->Sel = ALLOCATE_SELECTORS(1);
|
|
|
|
if (!pMem->Sel) {
|
|
pMem->SelCount = 0;
|
|
DpmiFreeXmem(pMem);
|
|
pMem = NULL;
|
|
} else {
|
|
|
|
SetDescriptorArray(pMem->Sel, (ULONG)pMem->Address, MemSize);
|
|
|
|
}
|
|
}
|
|
if (pMem) {
|
|
return pMem->Sel;
|
|
} else {
|
|
return (USHORT)0;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
FreePMStack(
|
|
USHORT Sel
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine releases PM stack
|
|
|
|
Arguments:
|
|
|
|
Sel - Selector of the PM stack to be freed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PMEM_DPMI pMem;
|
|
|
|
if (pMem = DpmiFindXmem(Sel)) {
|
|
|
|
while(pMem->SelCount--) {
|
|
FreeSelector(Sel);
|
|
Sel+=8;
|
|
}
|
|
|
|
DpmiFreeXmem(pMem);
|
|
}
|
|
}
|
|
#endif
|