able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/hals/x86new/regmode.c

1242 lines
24 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
regmode.c
Abstract:
This module implements the code necessary to decode the address
mode specifier byte.
N.B. This routine could be probably be more tightly encoded with a
loss of clarity.
Author:
David N. Cutler (davec) 10-Sep-1994
Environment:
Kernel mode only.
Revision History:
--*/
#include "nthal.h"
#include "emulate.h"
//
// Define forward referenced function prototypes.
//
ULONG
XmEvaluateIndexSpecifier (
IN PRXM_CONTEXT P,
IN ULONG Mode
);
PVOID
XmEvaluateAddressSpecifier (
IN PRXM_CONTEXT P,
OUT PLONG Number
)
/*++
Routine Description:
This function decodes x86 operand specifiers.
Arguments:
P - Supplies a pointer to an emulator context structure.
Number - Supplies a pointer to a variable that receives the register
number selected by the reg field of the operand specifier.
Operand - Supplies a pointer to a variable that receives the address
of the operand specified by the mod-r/m field of the operand
specifier.
Return Value:
None.
--*/
{
ULONG DispatchIndex;
ULONG Mode;
ULONG Modifier;
ULONG Offset;
ULONG Register;
UCHAR SpecifierByte;
PVOID Address;
//
// Get the next byte from the instruction stream and isolate
// the fields. The format of an operand specifier byte is:
//
// <7:6> - Mode
// <5:3> - Operand Register
// <2:0> - Modifier
//
SpecifierByte = XmGetCodeByte(P);
XmTraceSpecifier(SpecifierByte);
Mode = (SpecifierByte >> 6) & 0x3;
Modifier = SpecifierByte & 0x7;
Register = (SpecifierByte >> 3) & 0x7;
DispatchIndex = (Mode << 3) | (Modifier);
P->RegisterOffsetAddress = FALSE;
//
// Set the segment base address and select between 16- and 32-bit
// addressing.
//
*Number = Register;
if (P->OpaddrPrefixActive != FALSE) {
//
// 32-bit addressing.
//
// Case on dispatch index.
//
switch (DispatchIndex) {
//
// 00-000 DS:[EAX]
//
case 0:
Offset = P->Gpr[EAX].Exx;
break;
//
// 00-001 DS:[ECX]
//
case 1:
Offset = P->Gpr[ECX].Exx;
break;
//
// 00-010 DS:[EDX]
//
case 2:
Offset = P->Gpr[EDX].Exx;
break;
//
// 00-011 DS:[EBX]
//
case 3:
Offset = P->Gpr[EBX].Exx;
break;
//
// 00-100 - scale index byte
//
case 4:
Offset = XmEvaluateIndexSpecifier(P, Mode);
break;
//
// 00-101 DS:d32
//
case 5:
Offset = XmGetLongImmediate(P);
break;
//
// 00-110 DS:[ESI]
//
case 6:
Offset = P->Gpr[ESI].Exx;
break;
//
// 00-111 DS:[EDI]
//
case 7:
Offset = P->Gpr[EDI].Exx;
break;
//
// 01-000 DS:[EAX + d8]
//
case 8:
Offset = P->Gpr[EAX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-001 DS:[ECX + d8]
//
case 9:
Offset = P->Gpr[ECX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-010 DS:[EDX + d8]
//
case 10:
Offset = P->Gpr[EDX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-011 DS:[EBX + d8]
//
case 11:
Offset = P->Gpr[EBX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-100 - scale index byte
//
case 12:
Offset = XmEvaluateIndexSpecifier(P, Mode);
break;
//
// 01-101 DS:[EBP + d8]
//
case 13:
Offset = P->Gpr[EBP].Exx + XmGetSignedByteImmediateToLong(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-110 DS:[ESI + d8]
//
case 14:
Offset = P->Gpr[ESI].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-111 DS:[EDI + d8]
//
case 15:
Offset = P->Gpr[EDI].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 10-000 DS:[EAX + d32]
//
case 16:
Offset = P->Gpr[EAX].Exx + XmGetLongImmediate(P);
break;
//
// 10-001 DS:[ECX + d32]
//
case 17:
Offset = P->Gpr[ECX].Exx + XmGetLongImmediate(P);
break;
//
// 10-010 DS:[EDX + d32]
//
case 18:
Offset = P->Gpr[EDX].Exx + XmGetLongImmediate(P);
break;
//
// 10-011 DS:[EBX + d32]
//
case 19:
Offset = P->Gpr[EBX].Exx + XmGetLongImmediate(P);
break;
//
// 10-100 - scale index byte
//
case 20:
Offset = XmEvaluateIndexSpecifier(P, Mode);
break;
//
// 10-101 DS:[EBP + d32]
//
case 21:
Offset = P->Gpr[EBP].Exx + XmGetLongImmediate(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-110 DS:[ESI + d32]
//
case 22:
Offset = P->Gpr[ESI].Exx + XmGetLongImmediate(P);
break;
//
// 10-111 DS:[EDI + d32]
//
case 23:
Offset = P->Gpr[EDI].Exx + XmGetLongImmediate(P);
break;
//
// 11-xxx - Register mode.
//
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
P->RegisterOffsetAddress = TRUE;
return XmGetRegisterAddress(P, Modifier);
}
} else {
//
// 16-bit addressing.
//
// Case on dispatch index.
//
switch (DispatchIndex) {
//
// 00-000 DS:[BX + SI]
//
case 0:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[SI].Xx);
break;
//
// 00-001 DS:[BX + DI]
//
case 1:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[DI].Xx);
break;
//
// 00-010 SS:[BP + SI]
//
case 2:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[SI].Xx);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 00-011 SS:[BP + DI]
//
case 3:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[DI].Xx);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 00-100 DS:[SI]
//
case 4:
Offset = (USHORT)(P->Gpr[SI].Xx);
break;
//
// 00-101 DS:[DI]
//
case 5:
Offset = (USHORT)(P->Gpr[DI].Xx);
break;
//
// 00-110 DS:d16
//
case 6:
Offset = XmGetWordImmediate(P);
break;
//
// 00-111 DS:[BX]
//
case 7:
Offset = (USHORT)(P->Gpr[BX].Xx);
break;
//
// 01-000 DS:[BX + SI + d8]
//
case 8:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[SI].Xx + XmGetSignedByteImmediateToWord(P));
break;
//
// 01-001 DS:[BX + DI + d8]
//
case 9:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[DI].Xx + XmGetSignedByteImmediateToWord(P));
break;
//
// 01-010 SS:[BP + SI + d8]
//
case 10:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[SI].Xx + XmGetSignedByteImmediateToWord(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-011 SS:[BP + DI + d8]
//
case 11:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[DI].Xx + XmGetSignedByteImmediateToWord(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-100 DS:[SI + d8]
//
case 12:
Offset = (USHORT)(P->Gpr[SI].Xx + XmGetSignedByteImmediateToWord(P));
break;
//
// 01-101 DS:[DI + d8]
//
case 13:
Offset = (USHORT)(P->Gpr[DI].Xx + XmGetSignedByteImmediateToWord(P));
break;
//
// 01-110 DS:[BP + d8]
//
case 14:
Offset = (USHORT)(P->Gpr[BP].Xx + XmGetSignedByteImmediateToWord(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-111 DS:[BX + d8]
//
case 15:
Offset = (USHORT)(P->Gpr[BX].Xx + XmGetSignedByteImmediateToWord(P));
break;
//
// 10-000 DS:[BX + SI + d16]
//
case 16:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[SI].Xx + XmGetWordImmediate(P));
break;
//
// 10-001 DS:[BX + DI + d16]
//
case 17:
Offset = (USHORT)(P->Gpr[BX].Xx + P->Gpr[DI].Xx + XmGetWordImmediate(P));
break;
//
// 10-010 SS:[BP + SI + d16]
//
case 18:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[SI].Xx + XmGetWordImmediate(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-011 SS:[BP + DI + d16]
//
case 19:
Offset = (USHORT)(P->Gpr[BP].Xx + P->Gpr[DI].Xx + XmGetWordImmediate(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-100 DS:[SI + d16]
//
case 20:
Offset = (USHORT)(P->Gpr[SI].Xx + XmGetWordImmediate(P));
break;
//
// 10-101 DS:[DI + d16]
//
case 21:
Offset = (USHORT)(P->Gpr[DI].Xx + XmGetWordImmediate(P));
break;
//
// 10-110 DS:[BP + d16]
//
case 22:
Offset = (USHORT)(P->Gpr[BP].Xx + XmGetWordImmediate(P));
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-111 DS:[BX + d16]
//
case 23:
Offset = (USHORT)(P->Gpr[BX].Xx + XmGetWordImmediate(P));
break;
//
// 11-xxx - Register mode.
//
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
P->RegisterOffsetAddress = TRUE;
return XmGetRegisterAddress(P, Modifier);
}
}
//
// If an effective offset is being calculated, then return the offset
// value. Otherwise, If the offset displacement value plus the datum
// size is not within the segment limits, then raise an exception.
// Otherwise, compute the operand address.
//
if (P->ComputeOffsetAddress != FALSE) {
if (P->DataType == WORD_DATA) {
Offset &= 0xffff;
}
P->Offset = Offset;
Address = UlongToPtr(Offset);
} else {
if ((Offset > P->SegmentLimit[P->DataSegment]) ||
((Offset + P->DataType) > P->SegmentLimit[P->DataSegment])) {
longjmp(&P->JumpBuffer[0], XM_SEGMENT_LIMIT_VIOLATION);
} else {
P->Offset = Offset;
Address = (PVOID)(ULONG_PTR)(P->TranslateAddress)(P->SegmentRegister[P->DataSegment],
(USHORT)Offset);
}
}
return Address;
}
ULONG
XmEvaluateIndexSpecifier (
IN PRXM_CONTEXT P,
IN ULONG Mode
)
/*++
Routine Description:
This function evaluates a index specifier byte.
Arguments:
P - Supplies a pointer to an emulator context structure.
Mode - Supplies the mode of the address specifier.
Return Value:
The offset value computes from the index specifier.
--*/
{
ULONG DispatchIndex;
ULONG Modifier;
ULONG Offset;
ULONG Register;
ULONG Scale;
UCHAR SpecifierByte;
//
// Get the next byte from the instruction stream and isolate the
// specifier fields. The format of an scale/index byte is:
//
// <7:6> - Scale
// <5:3> - Index register
// <2:0> - Modifier
//
SpecifierByte = XmGetCodeByte(P);
XmTraceInstruction(BYTE_DATA, (ULONG)SpecifierByte);
Scale = (SpecifierByte >> 6) & 0x3;
Modifier = SpecifierByte & 0x7;
Register = (SpecifierByte >> 3) & 0x7;
DispatchIndex = (Mode << 3) | (Modifier);
//
// Case of dispatch index.
//
switch (DispatchIndex) {
//
// 00-000 DS:[EAX + scaled index]
//
case 0:
Offset = P->Gpr[EAX].Exx;
break;
//
// 00-001 DS:[ECX + scaled index]
//
case 1:
Offset = P->Gpr[ECX].Exx;
break;
//
// 00-010 DS:[EDX + scaled index]
//
case 2:
Offset = P->Gpr[EDX].Exx;
break;
//
// 00-011 DS:[EBX + scaled index]
//
case 3:
Offset = P->Gpr[EBX].Exx;
break;
//
// 00-100 SS:[ESP + scaled index]
//
case 4:
Offset = P->Gpr[ESP].Exx;
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 00-101 DS:[d32 + scaled index]
//
case 5:
Offset = XmGetLongImmediate(P);
break;
//
// 00-110 DS:[ESI + scaled index]
//
case 6:
Offset = P->Gpr[ESI].Exx;
break;
//
// 00-111 DS:[EDI + scaled index]
//
case 7:
Offset = P->Gpr[EDI].Exx;
break;
//
// 01-000 DS:[EAX + scaled index + d8]
//
case 8:
Offset = P->Gpr[EAX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-001 DS:[ECX + scaled index + d8]
//
case 9:
Offset = P->Gpr[ECX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-010 DS:[EDX + scaled index + d8]
//
case 10:
Offset = P->Gpr[EDX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-011 DS:[EBX + scaled index + d8]
//
case 11:
Offset = P->Gpr[EBX].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-100 SS:[ESP + scaled index + d8]
//
case 12:
Offset = P->Gpr[ESP].Exx + XmGetSignedByteImmediateToLong(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-101 DS:[EBP + scaled index + d8]
//
case 13:
Offset = P->Gpr[EBP].Exx + XmGetSignedByteImmediateToLong(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 01-110 DS:[ESI + scaled index + d8]
//
case 14:
Offset = P->Gpr[ESI].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 01-111 DS:[EDI + scaled index + d8]
//
case 15:
Offset = P->Gpr[EDI].Exx + XmGetSignedByteImmediateToLong(P);
break;
//
// 10-000 DS:[EAX + scaled index + d32]
//
case 16:
Offset = P->Gpr[EAX].Exx + XmGetLongImmediate(P);
break;
//
// 10-001 DS:[ECX + scaled index + d32]
//
case 17:
Offset = P->Gpr[ECX].Exx + XmGetLongImmediate(P);
break;
//
// 10-010 DS:[EDX + scaled index + d32]
//
case 18:
Offset = P->Gpr[EDX].Exx + XmGetLongImmediate(P);
break;
//
// 10-011 DS:[EBX + scaled index + d32]
//
case 19:
Offset = P->Gpr[EBX].Exx + XmGetLongImmediate(P);
break;
//
// 10-100 SS:[ESP + scaled index + d32]
//
case 20:
Offset = P->Gpr[ESP].Exx + XmGetLongImmediate(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-101 DS:[EBP + scaled index + d32]
//
case 21:
Offset = P->Gpr[EBP].Exx + XmGetLongImmediate(P);
if (P->SegmentPrefixActive == FALSE) {
P->DataSegment = SS;
}
break;
//
// 10-110 DS:[ESI + scaled index + d32]
//
case 22:
Offset = P->Gpr[ESI].Exx + XmGetLongImmediate(P);
break;
//
// 10-111 DS:[EDI + scaled index + d32]
//
case 23:
Offset = P->Gpr[EDI].Exx + XmGetLongImmediate(P);
break;
//
// Illegal mode specifier.
//
default:
longjmp(&P->JumpBuffer[0], XM_ILLEGAL_INDEX_SPECIFIER);
}
//
// Compute the total offset value.
//
return Offset + (P->Gpr[Register].Exx << Scale);
}
PVOID
XmGetOffsetAddress (
IN PRXM_CONTEXT P,
IN ULONG Offset
)
/*++
Routine Description:
This function evaluates a data segment address given a specified
offset.
Arguments:
P - Supplies a pointer to an emulator context structure.
Offset - Supplies the offset value.
Return Value:
A pointer to the operand value.
--*/
{
//
// If the offset displacement value plus the datum size is not within
// the segment limits, then raise an exception. Otherwise, compute the
// operand address.
//
if ((Offset > P->SegmentLimit[P->DataSegment]) ||
((Offset + P->DataType) > P->SegmentLimit[P->DataSegment])) {
longjmp(&P->JumpBuffer[0], XM_SEGMENT_LIMIT_VIOLATION);
}
return (P->TranslateAddress)(P->SegmentRegister[P->DataSegment], (USHORT)Offset);
}
PVOID
XmGetRegisterAddress (
IN PRXM_CONTEXT P,
IN ULONG Number
)
/*++
Routine Description:
This function computes the address of a register value.
Arguments:
P - Supplies a pointer to an emulator context structure.
Number - Supplies the register number.
Return Value:
A pointer to the register value.
--*/
{
PVOID Value;
//
// If the operand width is a byte, then the register is a
// byte register. Otherwise, the register is a word register.
//
if (P->DataType == BYTE_DATA) {
if (Number < 4) {
Value = (PVOID)&P->Gpr[Number].Xl;
} else {
Value = (PVOID)&P->Gpr[Number - 4].Xh;
}
} else if (P->DataType == WORD_DATA) {
Value = (PVOID)&P->Gpr[Number].Xx;
} else {
Value = (PVOID)&P->Gpr[Number].Exx;
}
return Value;
}
PVOID
XmGetStringAddress (
IN PRXM_CONTEXT P,
IN ULONG Segment,
IN ULONG Register
)
/*++
Routine Description:
This function evaluates a string address.
Arguments:
P - Supplies a pointer to an emulator context structure.
Segment - Supplies the segment number of the string operand.
Register - Supplies the register number of the string operand.
Return Value:
A pointer to the string value.
--*/
{
ULONG Increment;
ULONG Offset;
//
// Get the offset of the specified address and increment the specified
// register.
//
Increment = P->DataType + 1;
if (P->Eflags.EFLAG_DF != 0) {
Increment = ~Increment + 1;
}
if (P->OpaddrPrefixActive != FALSE) {
Offset = P->Gpr[Register].Exx;
P->Gpr[Register].Exx += Increment;
} else {
Offset = P->Gpr[Register].Xx;
P->Gpr[Register].Xx += (USHORT)Increment;
}
//
// If the offset displacement value plus the datum size is not within
// the segment limits, then raise an exception. Otherwise, compute the
// operand address.
//
if ((Offset > P->SegmentLimit[Segment]) ||
((Offset + P->DataType) > P->SegmentLimit[Segment])) {
longjmp(&P->JumpBuffer[0], XM_SEGMENT_LIMIT_VIOLATION);
}
return (P->TranslateAddress)(P->SegmentRegister[Segment], (USHORT)Offset);
}
VOID
XmSetDestinationValue (
IN PRXM_CONTEXT P,
IN PVOID Destination
)
/*++
Routine Description:
This function stores the destination operand value in the emulator
context.
Arguments:
P - Supplies a pointer to an emulator context structure.
Destination - Supplies a pointer to the destination operand value.
Return Value:
None.
--*/
{
//
// Set address and value of destination.
//
P->DstLong = (ULONG UNALIGNED *)Destination;
if (P->DataType == BYTE_DATA) {
P->DstValue.Long = *(UCHAR *)Destination;
} else if (P->DataType == WORD_DATA) {
if (((ULONG_PTR)Destination & 0x1) == 0) {
P->DstValue.Long = *(USHORT *)Destination;
} else {
P->DstValue.Long = *(USHORT UNALIGNED *)Destination;
}
} else {
if (((ULONG_PTR)Destination & 0x3) == 0) {
P->DstValue.Long = *(ULONG *)Destination;
} else {
P->DstValue.Long = *(ULONG UNALIGNED *)Destination;
}
}
XmTraceDestination(P, P->DstValue.Long);
return;
}
VOID
XmSetSourceValue (
IN PRXM_CONTEXT P,
IN PVOID Source
)
/*++
Routine Description:
This function stores the source operand value in the emulator
context.
Arguments:
P - Supplies a pointer to an emulator context structure.
Source - Supplies a pointer to the source operand value.
Return Value:
None.
--*/
{
//
// Set address and value of source.
//
P->SrcLong = (ULONG UNALIGNED *)Source;
if (P->DataType == BYTE_DATA) {
P->SrcValue.Long = *(UCHAR UNALIGNED *)Source;
} else if (P->DataType == WORD_DATA) {
P->SrcValue.Long = *(USHORT UNALIGNED *)Source;
} else {
P->SrcValue.Long = *(ULONG UNALIGNED *)Source;
}
XmTraceSource(P, P->SrcValue.Long);
return;
}
ULONG
XmGetImmediateSourceValue (
IN PRXM_CONTEXT P,
IN ULONG ByteFlag
)
/*++
Routine Description:
This function gets an immediate source from the instruction stream.
Arguments:
P - Supplies a pointer to an emulator context structure.
ByteFlag - Supplies a flag value that determines whether the
immediate value is a sign extended byte.
Return Value:
None.
--*/
{
ULONG Value;
//
// Get source value.
//
if (P->DataType == BYTE_DATA) {
Value = XmGetByteImmediate(P);
} else if (P->DataType == WORD_DATA) {
if (ByteFlag == 0) {
Value = XmGetWordImmediate(P);
} else {
Value = XmGetSignedByteImmediateToWord(P);
}
} else {
if (ByteFlag == 0) {
Value = XmGetLongImmediate(P);
} else {
Value = XmGetSignedByteImmediateToLong(P);
}
}
return Value;
}
VOID
XmSetImmediateSourceValue (
IN PRXM_CONTEXT P,
IN ULONG Source
)
/*++
Routine Description:
This function stores the immediate source operand value in the
emulator context.
Arguments:
P - Supplies a pointer to an emulator context structure.
Source - Supplies the source value.
Return Value:
None.
--*/
{
//
// Set source value.
//
P->SrcValue.Long = Source;
XmTraceSource(P, Source);
return;
}
Reference in a new issue Copy permalink