mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
787 lines
18 KiB
787 lines
18 KiB
//----------------------------------------------------------------------------
|
|
//
|
|
// 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);
|
|
}
|