able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/debuggers/ntsd64/alpha_asm.cpp

788 lines
18 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//----------------------------------------------------------------------------
//
// Assembe Alpha machine implementation.
//
// Copyright (C) Microsoft Corporation, 2000.
//
//----------------------------------------------------------------------------
#include "ntsdp.hpp"
#include "alpha_dis.h"
#include "alpha_optable.h"
#include "alpha_strings.h"
#define OPSIZE 16
BOOL TestCharacter (PSTR inString, PSTR *outString, CHAR ch);
ULONG GetIntReg(PSTR, PSTR *);
ULONG GetFltReg(PSTR, PSTR *);
LONG
GetValue (
PSTR inString,
PSTR *outString,
BOOL fSigned,
ULONG bitsize
);
PSTR SkipWhite(PSTR *);
ULONG GetToken(PSTR, PSTR *, PSTR, ULONG);
ULONG ParseIntMemory(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseFltMemory(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseMemSpec(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseJump(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseIntBranch(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseFltBranch(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseIntOp(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParsePal(PSTR, PSTR *, POPTBLENTRY, PULONG64);
ULONG ParseUnknown(PSTR, PSTR *, POPTBLENTRY, PULONG64);
/*** assem - assemble instruction
*
* Purpose:
* To assemble the instruction pointed by *poffset.
*
* Input:
* pchInput - pointer to string to assemble
*
* Output:
* *poffset - pointer to ADDR at which to assemble
*
* Exceptions:
* error exit:
* BADOPCODE - unknown or bad opcode
* OPERAND - bad operand
* ALIGNMENT - bad byte alignment in operand
* DISPLACEMENT - overflow in displacement computation
* BADREG - bad register name
* EXTRACHARS - extra characters after legal instruction
* MEMORY - write failure on assembled instruction
*
* Notes:
* errors are handled by the calling program by outputting
* the error string and reprompting the user for the same
* instruction.
*
*************************************************************************/
void
AlphaMachineInfo::Assemble (PADDR poffset, PSTR pchInput)
{
CHAR szOpcode[OPSIZE];
ULONG instruction;
POPTBLENTRY pEntry;
//
// Using the mnemonic token, find the entry in the assembler's
// table for the associated instruction.
//
if (GetToken(pchInput, &pchInput, szOpcode, OPSIZE) == 0)
error(BADOPCODE);
if ((pEntry = findStringEntry(szOpcode)) == (POPTBLENTRY) -1)
error(BADOPCODE);
if (pEntry->eType == INVALID_ETYPE) {
error(BADOPCODE);
}
//
// Use the instruction format specific parser to encode the
// instruction plus its operands.
//
instruction = (*pEntry->parsFunc)
(pchInput, &pchInput, pEntry, &(Flat(*poffset)));
//
// Store the instruction into the target memory location and
// increment the instruction pointer.
//
if (SetMemString(poffset, &instruction, 4) != 4) {
error(MEMORY);
}
Flat(*poffset) += sizeof(ULONG);
Off(*poffset) += sizeof(ULONG);
}
BOOL
TestCharacter (PSTR inString, PSTR *outString, CHAR ch)
{
inString = SkipWhite(&inString);
if (ch == *inString) {
*outString = inString+1;
return TRUE;
}
else {
*outString = inString;
return FALSE;
}
}
/*** GetIntReg - get integer register number
*** GetFltReg - get floating register number
*
* Purpose:
* From reading the input stream, return the register number.
*
* Input:
* inString - pointer to input string
*
* Output:
* *outString - pointer to character after register token in input stream
*
* Returns:
* register number
*
* Exceptions:
* error(BADREG) - bad register name
*
*************************************************************************/
PCHAR regNums[] = {
"$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
"$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
"$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
"$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31"
};
PCHAR intRegNames[] = {
g_R0, g_R1, g_R2, g_R3, g_R4, g_R5, g_R6, g_R7,
g_R8, g_R9, g_R10, g_R11, g_R12, g_R13, g_R14, g_R15,
g_R16, g_R17, g_R18, g_R19, g_R20, g_R21, g_R22, g_R23,
g_R24, g_R25, g_R26, g_R27, g_R28, g_R29, g_R30, g_R31
};
PCHAR fltRegNames[] = {
g_F0, g_F1, g_F2, g_F3, g_F4, g_F5, g_F6, g_F7,
g_F8, g_F9, g_F10, g_F11, g_F12, g_F13, g_F14, g_F15,
g_F16, g_F17, g_F18, g_F19, g_F20, g_F21, g_F22, g_F23,
g_F24, g_F25, g_F26, g_F27, g_F28, g_F29, g_F30, g_F31
};
ULONG
GetIntReg (PSTR inString, PSTR *outString)
{
CHAR szRegOp[5];
ULONG index;
if (!GetToken(inString, outString, szRegOp, sizeof(szRegOp)))
error(BADREG);
if (szRegOp[0] == '$') {
//
// use numbers
//
for (index = 0; index < 32; index++) {
if (!strcmp(szRegOp, regNums[index]))
return index;
}
} else {
//
// use names
//
for (index = 0; index < 32; index++) {
if (!strcmp(szRegOp, intRegNames[index]))
return index;
}
}
error(BADREG);
return 0;
}
ULONG
GetFltReg (PSTR inString, PSTR *outString)
{
CHAR szRegOp[5];
ULONG index;
if (!GetToken(inString, outString, szRegOp, sizeof(szRegOp)))
error(BADREG);
if (szRegOp[0] == '$') {
//
// use numbers
//
for (index = 0; index < 32; index++) {
if (!strcmp(szRegOp, regNums[index]))
return index;
}
} else {
//
// use names
//
for (index = 0; index < 32; index++) {
if (!strcmp(szRegOp, fltRegNames[index]))
return index;
}
}
error(BADREG);
return 0;
}
/*** GetValue - get value from command line
*
* Purpose:
* Use GetExpression to evaluate the next expression in the input
* stream.
*
* Input:
* inString - pointer to input stream
* fSigned - TRUE if signed value
* FALSE if unsigned value
* bitsize - size of value allowed
*
* Output:
* outString - character after the last character of the expression
*
* Returns:
* value computed from input stream
*
* Exceptions:
* error exit: OVERFLOW - value too large for bitsize
*
*************************************************************************/
LONG
GetValue (
PSTR inString,
PSTR *outString,
BOOL fSigned,
ULONG bitsize
)
{
ULONGLONG value;
inString = SkipWhite(&inString);
g_CurCmd = inString;
value = GetExpression();
*outString = g_CurCmd;
if ((value > (ULONG)(1L << bitsize) - 1) &&
(!fSigned || (value < (ULONG)(-1L << (bitsize - 1))))) {
error(OVERFLOW);
}
return (LONG)value;
}
/*** SkipWhite - skip white-space
*
* Purpose:
* To advance g_CurCmd over any spaces or tabs.
*
* Input:
* *g_CurCmd - present command line position
*
*************************************************************************/
PSTR
SkipWhite (PSTR * string)
{
while (**string == ' ' || **string == '\t')
(*string)++;
return(*string);
}
/*** GetToken - get token from command line
*
* Purpose:
* Build a lower-case mapped token of maximum size maxcnt
* at the string pointed by *psz. Token consist of the
* set of characters a-z, A-Z, 0-9, $, and underscore.
*
* Input:
* *inString - present command line position
* maxcnt - maximum size of token allowed
*
* Output:
* *outToken - token in lower case
* *outString - pointer to first character beyond token in input
*
* Returns:
* size of token if under maximum else 0
*
* Notes:
* if string exceeds maximum size, the extra characters
* are still processed, but ignored.
*
*************************************************************************/
ULONG
GetToken (PSTR inString, PSTR *outString, PSTR outToken, ULONG maxcnt)
{
CHAR ch;
ULONG count = 0;
inString = SkipWhite(&inString);
while (count < maxcnt) {
ch = (CHAR)tolower(*inString);
if (!((ch >= '0' && ch <= '9') ||
(ch >= 'a' && ch <= 'z') ||
(ch == '$') ||
(ch == '_') ||
(ch == '#')))
break;
count++;
*outToken++ = ch;
inString++;
}
*outToken = '\0';
*outString = inString;
return (count >= maxcnt ? 0 : count);
}
/*** ParseIntMemory - parse integer memory instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Ra, disp(Rb)
*
*************************************************************************/
ULONG
ParseIntMemory(
PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset
)
{
ULONG instruction;
ULONG Ra;
ULONG Rb;
ULONG disp;
Ra = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
disp = GetValue(inString, &inString, TRUE, WIDTH_MEM_DISP);
if (!TestCharacter(inString, &inString, '('))
error(OPERAND);
Rb = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ')'))
error(OPERAND);
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = OPCODE(pEntry->opCode) +
REG_A(Ra) +
REG_B(Rb) +
MEM_DISP(disp);
return(instruction);
}
/*** ParseFltMemory - parse floating point memory instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Fa, disp(Rb)
*
*************************************************************************/
ULONG
ParseFltMemory(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
ULONG instruction;
ULONG Fa;
ULONG Rb;
ULONG disp;
Fa = GetFltReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
disp = (ULONG)GetValue(inString, &inString, TRUE, WIDTH_MEM_DISP);
if (!TestCharacter(inString, &inString, '('))
error(OPERAND);
Rb = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ')'))
error(OPERAND);
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = OPCODE(pEntry->opCode) +
REG_A(Fa) +
REG_B(Rb) +
MEM_DISP(disp);
return(instruction);
}
/*** ParseMemSpec - parse special memory instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op
*
*************************************************************************/
ULONG ParseMemSpec(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
return(OPCODE(pEntry->opCode) +
MEM_FUNC(pEntry->funcCode));
}
/*** ParseJump - parse jump instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Ra,(Rb),hint
* op Ra,(Rb) - not really - we just support it in ntsd
*
*************************************************************************/
ULONG ParseJump(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
ULONG instruction;
ULONG Ra;
ULONG Rb;
ULONG hint;
Ra = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
if (!TestCharacter(inString, &inString, '('))
error(OPERAND);
Rb = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ')'))
error(OPERAND);
if (TestCharacter(inString, &inString, ',')) {
//
// User is giving us a hint
//
hint = GetValue(inString, &inString, TRUE, WIDTH_HINT);
} else {
hint = 0;
}
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = OPCODE(pEntry->opCode) +
JMP_FNC(pEntry->funcCode) +
REG_A(Ra) +
REG_B(Rb) +
HINT(hint);
return(instruction);
}
/*** ParseIntBranch - parse integer branch instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Ra,disp
*
*************************************************************************/
ULONG ParseIntBranch(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
ULONG instruction;
ULONG Ra;
LONG disp;
Ra = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
//
// the user gives an absolute address; we convert
// that to a displacement, which is computed as a
// difference off of (pc+1)
// GetValue handles both numerics and symbolics
//
disp = GetValue(inString, &inString, TRUE, 32);
// get the relative displacement from the updated pc
disp = disp - (LONG)((*poffset)+4);
// divide by four
disp = disp >> 2;
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = OPCODE(pEntry->opCode) +
REG_A(Ra) +
BR_DISP(disp);
return(instruction);
}
/*** ParseFltBranch - parse floating point branch instruction
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Fa,disp
*
*************************************************************************/
ULONG ParseFltBranch(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
ULONG instruction;
ULONG Ra;
LONG disp;
Ra = GetFltReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
//
// the user gives an absolute address; we convert
// that to a displacement, which is computed as a
// difference off of (pc+1)
// GetValue handles both numerics and symbolics
//
disp = GetValue(inString, &inString, TRUE, 32);
// get the relative displacement from the updated pc
disp = disp - (LONG)((*poffset)+4);
// divide by four
disp = disp >> 2;
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = OPCODE(pEntry->opCode) +
REG_A(Ra) +
BR_DISP(disp);
return(instruction);
}
/*** ParseIntOp - parse integer operation
*
* Purpose:
* Given the users input, create the memory instruction.
*
* Input:
* *inString - present input position
* pEntry - pointer into the asmTable for this instr type
*
* Output:
* *outstring - update input position
*
* Returns:
* the instruction.
*
* Format:
* op Ra, Rb, Rc
* op Ra, #lit, Rc
*
*************************************************************************/
ULONG ParseIntOp(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
ULONG instruction;
ULONG Ra, Rb, Rc;
ULONG lit;
ULONG Format; // Whether there is a literal or 3rd reg
instruction = OPCODE(pEntry->opCode) +
OP_FNC(pEntry->funcCode);
if (pEntry->opCode != SEXT_OP) {
Ra = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
} else {
Ra = 31;
}
if (TestCharacter(inString, &inString, '#')) {
//
// User is giving us a literal value
lit = GetValue(inString, &inString, TRUE, WIDTH_LIT);
Format = RBV_LITERAL_FORMAT;
} else {
//
// using a third register value
Rb = GetIntReg(inString, &inString);
Format = RBV_REGISTER_FORMAT;
}
if (!TestCharacter(inString, &inString, ','))
error(OPERAND);
Rc = GetIntReg(inString, &inString);
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
instruction = instruction +
REG_A(Ra) +
RBV_TYPE(Format) +
REG_C(Rc);
if (Format == RBV_REGISTER_FORMAT) {
instruction = instruction + REG_B(Rb);
} else {
instruction = instruction + LIT(lit);
}
return(instruction);
}
ULONG ParsePal(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
if (!TestCharacter(inString, &inString, '\0'))
error(EXTRACHARS);
return(OPCODE(pEntry->opCode) +
PAL_FNC(pEntry->funcCode));
}
ULONG ParseUnknown(PSTR inString,
PSTR *outString,
POPTBLENTRY pEntry,
PULONG64 poffset)
{
dprintf("Unable to assemble %s\n", inString);
error(BADOPCODE);
return(0);
}
Reference in a new issue Copy permalink