![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optable.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson / alpha|
Return to optable.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson / alpha |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1993 Digital Equipment Corporation ! 4: ! 5: Module Name: ! 6: ! 7: optable.c ! 8: ! 9: Abstract: ! 10: ! 11: Declaration for - ! 12: Table of operations, their names and charactersitics ! 13: Used by ntsd, windbg and acc's dissassembler ! 14: ! 15: Author: ! 16: ! 17: Miche Baker-Harvey (mbh) 10-Jan-1993 ! 18: ! 19: Revision History: ! 20: ! 21: --*/ ! 22: #include <excpt.h> ! 23: #include <windows.h> ! 24: #include "alphaops.h" ! 25: #define DEFINE_STRINGS ! 26: #include "strings.h" ! 27: #include "optable.h" ! 28: ! 29: // ! 30: // and DbgPrint be defined ! 31: // ! 32: ! 33: #ifndef _DBGNT_ ! 34: #ifndef _M_ALPHA ! 35: #ifndef _M_MRX000 ! 36: DbgPrint( ! 37: PCH Format, ! 38: ... ! 39: ); ! 40: #endif ! 41: #endif ! 42: #endif ! 43: ! 44: ! 45: // for strcmp ! 46: #include <string.h> ! 47: ! 48: // for fVerboseOutput ! 49: BOOLEAN fVerboseOutput = FALSE; ! 50: ! 51: // ! 52: // These are the parsing functions. In ntsd, they are defined ! 53: // in ntasm.c. In windbg, they are defined in MBH - WHERE???? ! 54: // ! 55: ! 56: ULONG ParseIntMemory (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 57: ULONG ParseFltMemory (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 58: ULONG ParseMemSpec (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 59: ULONG ParseJump (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 60: ULONG ParseIntBranch (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 61: ULONG ParseFltBranch (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 62: ULONG ParseIntOp (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 63: ULONG ParsePal (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 64: ULONG ParseUnknown (PUCHAR, PUCHAR *, POPTBLENTRY, PULONG); ! 65: ! 66: ! 67: #define NOFNCTBL NULL ! 68: #define NOSIZE (ULONG)0 ! 69: ! 70: ! 71: // ! 72: // These fields are used to find the beginning of the sections ! 73: // containing different "ENTRY_TYPE"s ! 74: // ! 75: ! 76: POPTBLENTRY InvalidTab; ! 77: POPTBLENTRY NonTerminalTab; ! 78: POPTBLENTRY TerminalTab; ! 79: POPTBLENTRY FunctionTab; ! 80: ! 81: ULONG InvalidTabSize; ! 82: ULONG NonTerminalTabSize; ! 83: ULONG TerminalTabSize; ! 84: ULONG FunctionTabSize; ! 85: ! 86: ! 87: // ! 88: // THE OPCODE TABLE ITSELF ! 89: // ! 90: // The opcode table "opTable" describes each opcode and function. ! 91: // There is an entry for each opcode, and for each function. ! 92: // ! 93: // The table is organized as follows: ! 94: // invalid-ops, ! 95: // non-terminal-ops, ! 96: // terminal-ops, ! 97: // functions, ! 98: // ! 99: // This organization is NOT required: ! 100: // no assumptions are made on it. ! 101: // ! 102: // Searches based on opcode must search ! 103: // INVALID, TERMINAL and NON_TERMINAL ! 104: // ! 105: // Searches based on instruction name must search ! 106: // TERMINAL and FUNCTION ! 107: // ! 108: // ! 109: ! 110: OPTBLENTRY opTable[] = { ! 111: ! 112: ! 113: // ! 114: // First, the INVALID_ETYPE section. ! 115: // (opcode searches begin here) ! 116: // ! 117: ! 118: ! 119: { "?Opc01", ParseUnknown, _01_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 120: { "?Opc02", ParseUnknown, _02_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 121: { "?Opc03", ParseUnknown, _03_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 122: { "?Opc04", ParseUnknown, _04_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 123: { "?Opc05", ParseUnknown, _05_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 124: { "?Opc06", ParseUnknown, _06_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 125: { "?Opc07", ParseUnknown, _07_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 126: { "?Opc0A", ParseUnknown, _0A_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 127: { "?Opc0C", ParseUnknown, _0C_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 128: { "?Opc0D", ParseUnknown, _0D_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 129: { "?Opc0E", ParseUnknown, _0E_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 130: { "?Opc14", ParseUnknown, _14_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 131: { "?Opc1C", ParseUnknown, _1C_OP, NO_FUNC, ALPHA_UNKNOWN, INVALID_ETYPE}, ! 132: ! 133: ! 134: // ! 135: // This is what hasn't been done yet - ! 136: // the EV4 stuff - there are no names for it ! 137: // in the alphaops.h header file. Should we ! 138: // put them there? Should they be elsewhere? ! 139: // Do we want to assemble them? ! 140: // ! 141: // For the moment, just pretend they are invalid. They never ! 142: // come up for all practical purposes, anyway. ! 143: // ! 144: ! 145: ! 146: { "MFPR", ParseUnknown, MFPR_OP, NO_FUNC, ! 147: ALPHA_EV4_PR, INVALID_ETYPE }, ! 148: { "MTPR", ParseUnknown, MTPR_OP, NO_FUNC, ! 149: ALPHA_EV4_PR, INVALID_ETYPE }, ! 150: ! 151: ! 152: ! 153: // ! 154: // Secondly, the NON_TERMINAL_ETYPE section ! 155: // ! 156: ! 157: ! 158: ! 159: { NOFNCTBL, NOSIZE, CALLPAL_OP, NO_FUNC, ! 160: ALPHA_CALLPAL, NON_TERMINAL_ETYPE }, ! 161: { NOFNCTBL, NOSIZE, ARITH_OP, NO_FUNC, ! 162: ALPHA_OPERATE, NON_TERMINAL_ETYPE }, ! 163: { NOFNCTBL, NOSIZE, BIT_OP, NO_FUNC, ! 164: ALPHA_OPERATE, NON_TERMINAL_ETYPE }, ! 165: { NOFNCTBL, NOSIZE, BYTE_OP, NO_FUNC, ! 166: ALPHA_OPERATE, NON_TERMINAL_ETYPE }, ! 167: { NOFNCTBL, NOSIZE, MUL_OP, NO_FUNC, ! 168: ALPHA_OPERATE, NON_TERMINAL_ETYPE }, ! 169: { NOFNCTBL, NOSIZE, MEMSPC_OP, NO_FUNC, ! 170: ALPHA_MEMSPC, NON_TERMINAL_ETYPE }, ! 171: { NOFNCTBL, NOSIZE, JMP_OP, NO_FUNC, ! 172: ALPHA_JUMP, NON_TERMINAL_ETYPE }, ! 173: { NOFNCTBL, NOSIZE, VAXFP_OP, NO_FUNC, ! 174: ALPHA_FP_OPERATE, NON_TERMINAL_ETYPE }, ! 175: { NOFNCTBL, NOSIZE, IEEEFP_OP, NO_FUNC, ! 176: ALPHA_FP_OPERATE, NON_TERMINAL_ETYPE }, ! 177: { NOFNCTBL, NOSIZE, FPOP_OP, NO_FUNC, ! 178: ALPHA_FP_OPERATE, NON_TERMINAL_ETYPE }, ! 179: ! 180: ! 181: ! 182: // ! 183: // Thirdly, the TERMINAL_ETYPE section ! 184: // (everything from here on has an instruction name) ! 185: // ! 186: ! 187: ! 188: ! 189: { szLda, ParseIntMemory, LDA_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 190: { szLdah, ParseIntMemory, LDAH_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 191: { szLdl, ParseIntMemory, LDL_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 192: { szLdq, ParseIntMemory, LDQ_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 193: { szLdf, ParseFltMemory, LDF_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 194: { szLdg, ParseFltMemory, LDG_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 195: { szLds, ParseFltMemory, LDS_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 196: { szLdt, ParseFltMemory, LDT_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 197: { szLdq_u, ParseIntMemory, LDQ_U_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 198: { szLdl_l, ParseIntMemory, LDL_L_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 199: { szLdq_l, ParseIntMemory, LDQ_L_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 200: ! 201: { szStl, ParseIntMemory, STL_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 202: { szStq, ParseIntMemory, STQ_OP, NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 203: { szStf, ParseFltMemory, STF_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 204: { szStg, ParseFltMemory, STG_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 205: { szSts, ParseFltMemory, STS_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 206: { szStt, ParseFltMemory, STT_OP, NO_FUNC, ALPHA_FP_MEMORY, TERMINAL_ETYPE }, ! 207: { szStq_u, ParseIntMemory, STQ_U_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 208: { szStl_c, ParseIntMemory, STL_C_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 209: { szStq_c, ParseIntMemory, STQ_C_OP,NO_FUNC, ALPHA_MEMORY, TERMINAL_ETYPE }, ! 210: ! 211: { szBeq, ParseIntBranch, BEQ_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 212: { szBne, ParseIntBranch, BNE_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 213: { szBlt, ParseIntBranch, BLT_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 214: { szBle, ParseIntBranch, BLE_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 215: { szBgt, ParseIntBranch, BGT_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 216: { szBge, ParseIntBranch, BGE_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 217: { szBlbc, ParseIntBranch, BLBC_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 218: { szBlbs, ParseIntBranch, BLBS_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 219: { szBr, ParseIntBranch, BR_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 220: { szBsr, ParseIntBranch, BSR_OP, NO_FUNC, ALPHA_BRANCH, TERMINAL_ETYPE }, ! 221: ! 222: { szFbeq, ParseFltBranch, FBEQ_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 223: { szFbne, ParseFltBranch, FBNE_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 224: { szFblt, ParseFltBranch, FBLT_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 225: { szFble, ParseFltBranch, FBLE_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 226: { szFbgt, ParseFltBranch, FBGT_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 227: { szFbge, ParseFltBranch, FBGE_OP, NO_FUNC, ALPHA_FP_BRANCH, TERMINAL_ETYPE }, ! 228: ! 229: ! 230: { "REI", ParseUnknown, PAL1B_OP, NO_FUNC, ALPHA_EV4_REI, TERMINAL_ETYPE}, ! 231: { "HW_LD", ParseUnknown, PAL1E_OP, NO_FUNC, ALPHA_EV4_MEM, TERMINAL_ETYPE}, ! 232: { "HW_ST", ParseUnknown, PAL1F_OP, NO_FUNC, ALPHA_EV4_MEM, TERMINAL_ETYPE}, ! 233: ! 234: ! 235: // ! 236: // Fourthly, (and finally) the FUNCTION_ETYPE section ! 237: // (opcode searches needn't include this section) ! 238: // ! 239: ! 240: // ! 241: // The memory-special functions ! 242: // ! 243: ! 244: { szMb, ParseMemSpec, MEMSPC_OP, MB_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 245: { szWmb, ParseMemSpec, MEMSPC_OP, WMB_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 246: { szMb2, ParseMemSpec, MEMSPC_OP, MB2_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 247: { szMb3, ParseMemSpec, MEMSPC_OP, MB3_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 248: { szFetch,ParseMemSpec, MEMSPC_OP, FETCH_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 249: { szFetch_m,ParseMemSpec,MEMSPC_OP,FETCH_M_FUNC,ALPHA_MEMSPC,FUNCTION_ETYPE }, ! 250: { szRs, ParseMemSpec, MEMSPC_OP, RS_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 251: { szTrapb,ParseMemSpec, MEMSPC_OP, TRAPB_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 252: { szRpcc, ParseMemSpec, MEMSPC_OP, RPCC_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 253: { szRc, ParseMemSpec, MEMSPC_OP, RC_FUNC, ALPHA_MEMSPC, FUNCTION_ETYPE }, ! 254: ! 255: // ! 256: // The jump functions ! 257: // ! 258: ! 259: { szJmp, ParseJump, JMP_OP, JMP_FUNC, ALPHA_JUMP, FUNCTION_ETYPE }, ! 260: { szJsr, ParseJump, JMP_OP, JSR_FUNC, ALPHA_JUMP, FUNCTION_ETYPE }, ! 261: { szRet, ParseJump, JMP_OP, RET_FUNC, ALPHA_JUMP, FUNCTION_ETYPE }, ! 262: { szJsr_co, ParseJump, JMP_OP, JSR_CO_FUNC, ALPHA_JUMP, FUNCTION_ETYPE }, ! 263: ! 264: // ! 265: // The arithmetic ops, which are ALPHA_OPERATE ! 266: // ! 267: ! 268: { szAddl, ParseIntOp, ARITH_OP, ADDL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 269: { szAddlv, ParseIntOp, ARITH_OP, ADDLV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 270: { szAddq, ParseIntOp, ARITH_OP, ADDQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 271: { szAddqv, ParseIntOp, ARITH_OP, ADDQV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 272: { szSubl, ParseIntOp, ARITH_OP, SUBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 273: { szSublv, ParseIntOp, ARITH_OP, SUBLV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 274: { szSubq, ParseIntOp, ARITH_OP, SUBQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 275: { szSubqv, ParseIntOp, ARITH_OP, SUBQV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 276: ! 277: ! 278: { szCmpeq, ParseIntOp, ARITH_OP, CMPEQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 279: { szCmplt, ParseIntOp, ARITH_OP, CMPLT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 280: { szCmple, ParseIntOp, ARITH_OP, CMPLE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 281: { szCmpult, ParseIntOp, ARITH_OP, CMPULT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 282: { szCmpule, ParseIntOp, ARITH_OP, CMPULE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 283: { szCmpbge, ParseIntOp, ARITH_OP, CMPBGE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 284: ! 285: ! 286: { szS4addl, ParseIntOp, ARITH_OP, S4ADDL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 287: { szS4addq, ParseIntOp, ARITH_OP, S4ADDQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 288: { szS4subl, ParseIntOp, ARITH_OP, S4SUBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 289: { szS4subq, ParseIntOp, ARITH_OP, S4SUBQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 290: { szS8addl, ParseIntOp, ARITH_OP, S8ADDL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 291: { szS8addq, ParseIntOp, ARITH_OP, S8ADDQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 292: { szS8subl, ParseIntOp, ARITH_OP, S8SUBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 293: { szS8subq, ParseIntOp, ARITH_OP, S8SUBQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 294: ! 295: // ! 296: // The bit ops, which are ALPHA_OPERATE ! 297: // ! 298: ! 299: { szAnd, ParseIntOp, BIT_OP, AND_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 300: { szBic, ParseIntOp, BIT_OP, BIC_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 301: { szBis, ParseIntOp, BIT_OP, BIS_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 302: { szOrnot, ParseIntOp, BIT_OP, ORNOT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 303: { szXor, ParseIntOp, BIT_OP, XOR_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 304: { szEqv, ParseIntOp, BIT_OP, EQV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 305: ! 306: { szCmoveq, ParseIntOp, BIT_OP, CMOVEQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 307: { szCmovne, ParseIntOp, BIT_OP, CMOVNE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 308: { szCmovlbs, ParseIntOp, BIT_OP, CMOVLBS_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 309: { szCmovlt, ParseIntOp, BIT_OP, CMOVLT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 310: { szCmovge, ParseIntOp, BIT_OP, CMOVGE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 311: { szCmovlbc, ParseIntOp, BIT_OP, CMOVLBC_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 312: { szCmovle, ParseIntOp, BIT_OP, CMOVLE_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 313: { szCmovgt, ParseIntOp, BIT_OP, CMOVGT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 314: ! 315: // ! 316: // The byte ops, which are ALPHA_OPERATE ! 317: // ! 318: ! 319: { szSll, ParseIntOp, BYTE_OP, SLL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 320: { szSra, ParseIntOp, BYTE_OP, SRA_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 321: { szSrl, ParseIntOp, BYTE_OP, SRL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 322: { szExtbl, ParseIntOp, BYTE_OP, EXTBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 323: { szExtwl, ParseIntOp, BYTE_OP, EXTWL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 324: { szExtll, ParseIntOp, BYTE_OP, EXTLL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 325: { szExtql, ParseIntOp, BYTE_OP, EXTQL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 326: { szExtwh, ParseIntOp, BYTE_OP, EXTWH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 327: { szExtlh, ParseIntOp, BYTE_OP, EXTLH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 328: { szExtqh, ParseIntOp, BYTE_OP, EXTQH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 329: { szInsbl, ParseIntOp, BYTE_OP, INSBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 330: { szInswl, ParseIntOp, BYTE_OP, INSWL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 331: { szInsll, ParseIntOp, BYTE_OP, INSLL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 332: { szInsql, ParseIntOp, BYTE_OP, INSQL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 333: { szInswh, ParseIntOp, BYTE_OP, INSWH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 334: { szInslh, ParseIntOp, BYTE_OP, INSLH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 335: { szInsqh, ParseIntOp, BYTE_OP, INSQH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 336: { szMskbl, ParseIntOp, BYTE_OP, MSKBL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 337: { szMskwl, ParseIntOp, BYTE_OP, MSKWL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 338: { szMskll, ParseIntOp, BYTE_OP, MSKLL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 339: { szMskql, ParseIntOp, BYTE_OP, MSKQL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 340: { szMskwh, ParseIntOp, BYTE_OP, MSKWH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 341: { szMsklh, ParseIntOp, BYTE_OP, MSKLH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 342: { szMskqh, ParseIntOp, BYTE_OP, MSKQH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 343: { szZap, ParseIntOp, BYTE_OP, ZAP_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 344: { szZapnot, ParseIntOp, BYTE_OP, ZAPNOT_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 345: ! 346: // ! 347: // The multiply ops, which are ALPHA_OPERATE ! 348: // ! 349: ! 350: { szMull, ParseIntOp, MUL_OP, MULL_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 351: { szMulqv, ParseIntOp, MUL_OP, MULQV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 352: { szMullv, ParseIntOp, MUL_OP, MULLV_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 353: { szUmulh, ParseIntOp, MUL_OP, UMULH_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 354: { szMulq, ParseIntOp, MUL_OP, MULQ_FUNC, ALPHA_OPERATE, FUNCTION_ETYPE }, ! 355: ! 356: // ! 357: // The call pal functions ! 358: // ! 359: ! 360: ! 361: { szBpt, ParsePal, CALLPAL_OP, BPT_FUNC, ! 362: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 363: { szCallsys, ParsePal, CALLPAL_OP, CALLSYS_FUNC, ! 364: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 365: { szImb, ParsePal, CALLPAL_OP, IMB_FUNC, ! 366: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 367: { szRdteb, ParsePal, CALLPAL_OP, RDTEB_FUNC, ! 368: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 369: { szGentrap, ParsePal, CALLPAL_OP, GENTRAP_FUNC, ! 370: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 371: { szKbpt, ParsePal, CALLPAL_OP, KBPT_FUNC, ! 372: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 373: { szCallKD, ParsePal, CALLPAL_OP, CALLKD_FUNC, ! 374: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 375: { szHalt, ParsePal, CALLPAL_OP, HALT_FUNC, ! 376: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 377: { szRestart, ParsePal, CALLPAL_OP, RESTART_FUNC, ! 378: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 379: { szDraina, ParsePal, CALLPAL_OP, DRAINA_FUNC, ! 380: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 381: { szInitpal, ParsePal, CALLPAL_OP, INITPAL_FUNC, ! 382: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 383: { szWrentry, ParsePal, CALLPAL_OP, WRENTRY_FUNC, ! 384: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 385: { szSwpirql, ParsePal, CALLPAL_OP, SWPIRQL_FUNC, ! 386: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 387: { szRdirql, ParsePal, CALLPAL_OP, RDIRQL_FUNC, ! 388: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 389: { szDi, ParsePal, CALLPAL_OP, DI_FUNC, ! 390: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 391: { szEi, ParsePal, CALLPAL_OP, EI_FUNC, ! 392: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 393: { szSwppal, ParsePal, CALLPAL_OP, SWPPAL_FUNC, ! 394: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 395: { szSsir, ParsePal, CALLPAL_OP, SSIR_FUNC, ! 396: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 397: { szCsir, ParsePal, CALLPAL_OP, CSIR_FUNC, ! 398: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 399: { szRfe, ParsePal, CALLPAL_OP, RFE_FUNC, ! 400: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 401: { szRetsys, ParsePal, CALLPAL_OP, RETSYS_FUNC, ! 402: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 403: { szSwpctx, ParsePal, CALLPAL_OP, SWPCTX_FUNC, ! 404: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 405: { szSwpprocess, ParsePal, CALLPAL_OP, SWPPROCESS_FUNC, ! 406: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 407: { szRdmces, ParsePal, CALLPAL_OP, RDMCES_FUNC, ! 408: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 409: { szWrmces, ParsePal, CALLPAL_OP, WRMCES_FUNC, ! 410: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 411: { szTbia, ParsePal, CALLPAL_OP, TBIA_FUNC, ! 412: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 413: { szTbis, ParsePal, CALLPAL_OP, TBIS_FUNC, ! 414: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 415: { szDtbis, ParsePal, CALLPAL_OP, DTBIS_FUNC, ! 416: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 417: { szRdksp, ParsePal, CALLPAL_OP, RDKSP_FUNC, ! 418: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 419: { szSwpksp, ParsePal, CALLPAL_OP, SWPKSP_FUNC, ! 420: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 421: { szRdpsr, ParsePal, CALLPAL_OP, RDPSR_FUNC, ! 422: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 423: { szRdpcr, ParsePal, CALLPAL_OP, RDPCR_FUNC, ! 424: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 425: { szRdthread, ParsePal, CALLPAL_OP, RDTHREAD_FUNC, ! 426: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 427: { szRdcounters, ParsePal, CALLPAL_OP, RDCOUNTERS_FUNC, ! 428: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 429: { szRdstate, ParsePal, CALLPAL_OP, RDSTATE_FUNC, ! 430: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 431: { szInitpcr, ParsePal, CALLPAL_OP, INITPCR_FUNC, ! 432: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 433: { szWrperfmon, ParsePal, CALLPAL_OP, WRPERFMON_FUNC, ! 434: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 435: { szMt, ParsePal, CALLPAL_OP, MTPR_OP, ! 436: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 437: { szMf, ParsePal, CALLPAL_OP, MFPR_OP, ! 438: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 439: { szHwld, ParsePal, CALLPAL_OP, HWLD_OP, ! 440: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 441: { szHwst, ParsePal, CALLPAL_OP, HWST_OP, ! 442: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 443: { szRei, ParsePal, CALLPAL_OP, REI_OP, ! 444: ALPHA_CALLPAL, FUNCTION_ETYPE }, ! 445: ! 446: ! 447: // ! 448: // The VAX Floating point functions ! 449: // ! 450: ! 451: ! 452: { szAddf, ParseUnknown, VAXFP_OP, ADDF_FUNC, ! 453: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 454: { szCvtdg, ParseUnknown, VAXFP_OP, CVTDG_FUNC, ! 455: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 456: { szAddg, ParseUnknown, VAXFP_OP, ADDG_FUNC, ! 457: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 458: { szCmpgeq, ParseUnknown, VAXFP_OP, CMPGEQ_FUNC, ! 459: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 460: { szCmpglt, ParseUnknown, VAXFP_OP, CMPGLT_FUNC, ! 461: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 462: { szCmpgle, ParseUnknown, VAXFP_OP, CMPGLE_FUNC, ! 463: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 464: { szCvtgf, ParseUnknown, VAXFP_OP, CVTGF_FUNC, ! 465: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 466: { szCvtgd, ParseUnknown, VAXFP_OP, CVTGD_FUNC, ! 467: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 468: { szCvtqf, ParseUnknown, VAXFP_OP, CVTQF_FUNC, ! 469: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 470: { szCvtqg, ParseUnknown, VAXFP_OP, CVTQG_FUNC, ! 471: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 472: { szDivf, ParseUnknown, VAXFP_OP, DIVF_FUNC, ! 473: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 474: { szDivg, ParseUnknown, VAXFP_OP, DIVG_FUNC, ! 475: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 476: { szMulf, ParseUnknown, VAXFP_OP, MULF_FUNC, ! 477: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 478: { szMulg, ParseUnknown, VAXFP_OP, MULG_FUNC, ! 479: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 480: { szSubf, ParseUnknown, VAXFP_OP, SUBF_FUNC, ! 481: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 482: { szSubg, ParseUnknown, VAXFP_OP, SUBG_FUNC, ! 483: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 484: { szCvtgq, ParseUnknown, VAXFP_OP, CVTGQ_FUNC, ! 485: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 486: // ! 487: // The IEEE Floating point functions ! 488: // ! 489: ! 490: { szAdds, ParseUnknown, IEEEFP_OP, ADDS_FUNC, ! 491: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 492: { szSubs, ParseUnknown, IEEEFP_OP, SUBS_FUNC, ! 493: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 494: { szMuls, ParseUnknown, IEEEFP_OP, MULS_FUNC, ! 495: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 496: { szDivs, ParseUnknown, IEEEFP_OP, DIVS_FUNC, ! 497: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 498: { szAddt, ParseUnknown, IEEEFP_OP, ADDT_FUNC, ! 499: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 500: { szSubt, ParseUnknown, IEEEFP_OP, SUBT_FUNC, ! 501: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 502: { szMult, ParseUnknown, IEEEFP_OP, MULT_FUNC, ! 503: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 504: { szDivt, ParseUnknown, IEEEFP_OP, DIVT_FUNC, ! 505: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 506: { szCmptun, ParseUnknown, IEEEFP_OP, CMPTUN_FUNC, ! 507: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 508: { szCmpteq, ParseUnknown, IEEEFP_OP, CMPTEQ_FUNC, ! 509: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 510: { szCmptlt, ParseUnknown, IEEEFP_OP, CMPTLT_FUNC, ! 511: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 512: { szCmptle, ParseUnknown, IEEEFP_OP, CMPTLE_FUNC, ! 513: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 514: { szCvtts, ParseUnknown, IEEEFP_OP, CVTTS_FUNC, ! 515: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 516: { szCvttq, ParseUnknown, IEEEFP_OP, CVTTQ_FUNC, ! 517: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 518: { szCvtqs, ParseUnknown, IEEEFP_OP, CVTQS_FUNC, ! 519: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 520: { szCvtqt, ParseUnknown, IEEEFP_OP, CVTQT_FUNC, ! 521: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 522: ! 523: // ! 524: // The Common Floating point functions ! 525: // ! 526: ! 527: ! 528: { szCvtlq, ParseUnknown, FPOP_OP, CVTLQ_FUNC, ! 529: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 530: { szCpys, ParseUnknown, FPOP_OP, CPYS_FUNC, ! 531: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 532: { szCpysn, ParseUnknown, FPOP_OP, CPYSN_FUNC, ! 533: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 534: { szCpyse, ParseUnknown, FPOP_OP, CPYSE_FUNC, ! 535: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 536: { szMt_fpcr, ParseUnknown, FPOP_OP, MT_FPCR_FUNC, ! 537: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 538: { szMf_fpcr, ParseUnknown, FPOP_OP, MF_FPCR_FUNC, ! 539: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 540: { szFcmoveq, ParseUnknown, FPOP_OP, FCMOVEQ_FUNC, ! 541: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 542: { szFcmovne, ParseUnknown, FPOP_OP, FCMOVNE_FUNC, ! 543: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 544: { szFcmovlt, ParseUnknown, FPOP_OP, FCMOVLT_FUNC, ! 545: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 546: { szFcmovge, ParseUnknown, FPOP_OP, FCMOVGE_FUNC, ! 547: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 548: { szFcmovle, ParseUnknown, FPOP_OP, FCMOVLE_FUNC, ! 549: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 550: { szFcmovgt, ParseUnknown, FPOP_OP, FCMOVGT_FUNC, ! 551: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 552: { szCvtql, ParseUnknown, FPOP_OP, CVTQL_FUNC, ! 553: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 554: { szCvtqlv, ParseUnknown, FPOP_OP, CVTQLV_FUNC, ! 555: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 556: { szCvtqlsv, ParseUnknown, FPOP_OP, CVTQLSV_FUNC, ! 557: ALPHA_FP_OPERATE, FUNCTION_ETYPE }, ! 558: ! 559: }; // end of opTable ! 560: ! 561: ! 562: #define SEARCHNUM sizeof(opTable) / sizeof(OPTBLENTRY) ! 563: ! 564: ! 565: ! 566: // ! 567: // Here are the tables of Floating Point flags. ! 568: // ! 569: ! 570: FPFLAGS ConvertFlags[] = { ! 571: { NONE_FLAGS, NONE_FLAGS_STR }, ! 572: { C_FLAGS, C_FLAGS_STR }, ! 573: { V_FLAGS, V_FLAGS_STR }, ! 574: { VC_FLAGS, VC_FLAGS_STR }, ! 575: { SV_FLAGS, SV_FLAGS_STR }, ! 576: { SVC_FLAGS, SVC_FLAGS_STR }, ! 577: { SVI_FLAGS, SVI_FLAGS_STR }, ! 578: { SVIC_FLAGS, SVIC_FLAGS_STR }, ! 579: ! 580: { D_FLAGS, D_FLAGS_STR }, ! 581: { VD_FLAGS, VD_FLAGS_STR }, ! 582: { SVD_FLAGS, SVD_FLAGS_STR }, ! 583: { SVID_FLAGS, SVID_FLAGS_STR }, ! 584: { M_FLAGS, M_FLAGS_STR }, ! 585: { VM_FLAGS, VM_FLAGS_STR }, ! 586: { SVM_FLAGS, SVM_FLAGS_STR }, ! 587: { SVIM_FLAGS, SVIM_FLAGS_STR }, ! 588: ! 589: { S_FLAGS, S_FLAGS_STR }, ! 590: { SC_FLAGS, SC_FLAGS_STR }, ! 591: { FPFLAGS_NOT_AN_ENTRY, "" } ! 592: }; ! 593: ! 594: FPFLAGS FloatOpFlags[] = { ! 595: { C_FLAGS, C_FLAGS_STR }, ! 596: { M_FLAGS, M_FLAGS_STR }, ! 597: { NONE_FLAGS, NONE_FLAGS_STR }, ! 598: { D_FLAGS, D_FLAGS_STR }, ! 599: { UC_FLAGS, UC_FLAGS_STR }, ! 600: { UM_FLAGS, UM_FLAGS_STR }, ! 601: { U_FLAGS, U_FLAGS_STR }, ! 602: { UD_FLAGS, UD_FLAGS_STR }, ! 603: { SC_FLAGS, SC_FLAGS_STR }, ! 604: { S_FLAGS, S_FLAGS_STR }, ! 605: { SUC_FLAGS, SUC_FLAGS_STR }, ! 606: { SUM_FLAGS, SUM_FLAGS_STR }, ! 607: { SU_FLAGS, SU_FLAGS_STR }, ! 608: { SUD_FLAGS, SUD_FLAGS_STR }, ! 609: { SUIC_FLAGS, SUIC_FLAGS_STR }, ! 610: { SUIM_FLAGS, SUIM_FLAGS_STR }, ! 611: { SUI_FLAGS, SUI_FLAGS_STR }, ! 612: { SUID_FLAGS, SUID_FLAGS_STR }, ! 613: { FPFLAGS_NOT_AN_ENTRY, "" } ! 614: }; ! 615: ! 616: ! 617: ! 618: /*** findNameEntry - find POPTBLENTRY based on name ! 619: * ! 620: * Purpose: ! 621: * Search the opTable for a match with the token ! 622: * pointed by *pszOp. Must search through the ! 623: * TERMINAL and the FUNCTION tables ! 624: * ! 625: * Input: ! 626: * *pszOp - string to search as mnemonic ! 627: * ! 628: * Returns: ! 629: * Pointer to entry in the opTable ! 630: * ! 631: *************************************************************************/ ! 632: ! 633: POPTBLENTRY ! 634: findStringEntry (PUCHAR pszOp) ! 635: { ! 636: ! 637: POPTBLENTRY pEntry; ! 638: ! 639: for (pEntry = TerminalTab; ! 640: pEntry < &TerminalTab[TerminalTabSize]; ! 641: pEntry++) { ! 642: ! 643: if (!strcmp(pszOp, pEntry->pszAlphaName)) ! 644: return(pEntry); ! 645: } ! 646: ! 647: for (pEntry = FunctionTab; ! 648: pEntry < &FunctionTab[FunctionTabSize]; ! 649: pEntry++) { ! 650: ! 651: if (!strcmp(pszOp, pEntry->pszAlphaName)) ! 652: return(pEntry); ! 653: } ! 654: ! 655: return((POPTBLENTRY)-1); ! 656: } ! 657: ! 658: ! 659: /* findOpCodeEntry - find POPTBLENTRY based on opcode ! 660: * ! 661: * Purpose: ! 662: * Search the opTable for a match with the opcode ! 663: * Must search through the ! 664: * INVALID, TERMINAL and NON_TERMINAL tables ! 665: * ! 666: * Input: ! 667: * pOpEntry - pointer to NON_TERMINAL_ETYPE in opTable ! 668: * function - the function value to be looked up ! 669: * ! 670: * Output: ! 671: * pointer to string mnemonic for the function ! 672: * ! 673: ***********************************************************************/ ! 674: ! 675: POPTBLENTRY ! 676: findOpCodeEntry(ULONG opcode) ! 677: { ! 678: POPTBLENTRY pEntry; ! 679: ! 680: for (pEntry = TerminalTab; ! 681: pEntry < &TerminalTab[TerminalTabSize]; ! 682: pEntry++) { ! 683: ! 684: if (pEntry->opCode == opcode) ! 685: return(pEntry); ! 686: } ! 687: ! 688: for (pEntry = NonTerminalTab; ! 689: pEntry < &NonTerminalTab[NonTerminalTabSize]; ! 690: pEntry++) { ! 691: ! 692: if (pEntry->opCode == opcode) ! 693: return(pEntry); ! 694: } ! 695: ! 696: for (pEntry = InvalidTab; ! 697: pEntry < &InvalidTab[InvalidTabSize]; ! 698: pEntry++) { ! 699: ! 700: if (pEntry->opCode == opcode) ! 701: return(pEntry); ! 702: } ! 703: ! 704: return((POPTBLENTRY)-1); ! 705: } ! 706: ! 707: ! 708: /*** findTypeFromOpcode - find the instruction type ! 709: * ! 710: * Purpose: ! 711: * This routine finds the type of the instruction (ALPHA_*) ! 712: * from the opcode. It returns a single value so that it ! 713: * can be called from other dll's without passing storage. ! 714: * ! 715: * Input: ! 716: * the opcode number. ! 717: * ! 718: * Output: ! 719: * the type of the opcode (ALPHA_* in alphaops.h) ! 720: * ! 721: * Errors: ! 722: * returns ALPHA_UNKNOWN for an invalid opcode ! 723: * ! 724: * Exceptions: ! 725: * None. ! 726: * ! 727: * ! 728: *************************************************************************/ ! 729: ! 730: ULONG ! 731: findTypeFromOpcode(ULONG opcode) ! 732: { ! 733: POPTBLENTRY pEntry; ! 734: ! 735: pEntry = findOpCodeEntry(opcode); ! 736: ! 737: if (pEntry != (POPTBLENTRY)(-1)) { ! 738: return(pEntry->iType); ! 739: } else { ! 740: return(ALPHA_UNKNOWN); ! 741: } ! 742: } ! 743: ! 744: ! 745: /*** findNonTerminalEntry - find pointer to set of functions ! 746: * ! 747: * Purpose: ! 748: * This routine finds the entry in the table which the is ! 749: * nonterminal entry for an opcode. ! 750: * ! 751: * Input: ! 752: * The type of function that is interesting ! 753: * ! 754: * Output: ! 755: * Pointer to the nonterminal entry in opTable ! 756: * ! 757: * Errors: ! 758: * If the entry is not found, a message is printed, and the ! 759: * routine exits. ! 760: * ! 761: * Exceptions: ! 762: * None. ! 763: * ! 764: * Note: ! 765: * This routine is called BEFORE NonTerminalTable is established! ! 766: * (it's used to set up these tables, in fact). ! 767: * ! 768: *************************************************************************/ ! 769: ! 770: POPTBLENTRY ! 771: findNonTerminalEntry(ULONG opCode) ! 772: { ! 773: ULONG index; ! 774: ! 775: for ( index = 0 ; index < SEARCHNUM; index++ ) { ! 776: ! 777: if ( ( opTable[index].eType == NON_TERMINAL_ETYPE ) && ! 778: ( opTable[index].opCode == opCode ) ) { ! 779: ! 780: return(&opTable[index]); ! 781: } ! 782: } ! 783: ! 784: // assert(0); ! 785: } ! 786: ! 787: ! 788: ! 789: /* findFuncName - get string name for a function ! 790: * ! 791: * Purpose: ! 792: * to get function name, given the function number, and a ! 793: * pointer to the opTable entry for the NON_TERMINAL_ETYPE ! 794: * opcode associated with the function ! 795: * ! 796: * Input: ! 797: * pOpEntry - pointer to NON_TERMINAL_ETYPE in opTable ! 798: * function - the function value to be looked up ! 799: * ! 800: * Output: ! 801: * pointer to string mnemonic for the function ! 802: * ! 803: ***********************************************************************/ ! 804: ! 805: char * ! 806: findFuncName(POPTBLENTRY pEntry, ULONG function) ! 807: { ! 808: int cIndex; ! 809: POPTBLENTRY pFncEntry; ! 810: ! 811: pFncEntry = pEntry->funcTable; ! 812: cIndex = (int)pEntry->funcTableSize; ! 813: ! 814: // ! 815: // make sure that this entry pts to a function table ! 816: // ! 817: ! 818: ! 819: while(cIndex-- > 0) { ! 820: if (function == pFncEntry->funcCode) ! 821: return(pFncEntry->pszAlphaName); ! 822: pFncEntry++; ! 823: }; ! 824: ! 825: return("???"); ! 826: } ! 827: ! 828: ! 829: /** findFlagName - get the string associated with a flag ! 830: * ! 831: * Purpose - return a string associated with the flags for a ! 832: * floating point instruction ! 833: * ! 834: * Input: ! 835: * flag - the flags on the opcode ! 836: * opcode - the opcode; if it's Cvt*, we use different flags ! 837: * ! 838: * Output: ! 839: * pointer to string describing flags, or "/???" ! 840: * ! 841: ***************/ ! 842: ! 843: char * ! 844: findFlagName(ULONG flag, ULONG function) ! 845: { ! 846: ! 847: PFPFLAGS table; ! 848: ! 849: if ((function == CVTTQ_FUNC) || (function == CVTGQ_FUNC)) { ! 850: table = ConvertFlags; ! 851: } else { ! 852: table = FloatOpFlags; ! 853: } ! 854: ! 855: while (table->flags != FPFLAGS_NOT_AN_ENTRY) { ! 856: ! 857: if (table->flags == flag) { ! 858: return(table->flagname); ! 859: } ! 860: table++; ! 861: } ! 862: ! 863: // no match found ! 864: // ! 865: ! 866: return("/???"); ! 867: } ! 868: ! 869: ! 870: /*** opTableInit - initialize fields used in and with the opTable ! 871: * ! 872: * Purpose: ! 873: * This routine is called once, and sets up pointers to the ! 874: * subtables embedded in the opTable, such as AddOpTab, and ! 875: * sizes for these subtables. It also checks that all like ! 876: * instructions are grouped together in the table, which is ! 877: * the only requirement on it. ! 878: * ! 879: * Input: ! 880: * None. ! 881: * ! 882: * Output: ! 883: * None. ! 884: * ! 885: * Errors: ! 886: * If the table is not properly organized (four types separated, ! 887: * and the functions for a single opcode grouped), this prints a ! 888: * messages and fails ! 889: * ! 890: * Exceptions: ! 891: * None. ! 892: * ! 893: *************************************************************************/ ! 894: ! 895: void ! 896: opTableInit() ! 897: { ! 898: ! 899: ULONG typesDone[4] = {0,0,0,0}; ! 900: ! 901: ULONG palDone, arithDone, bitDone, byteDone, jmpDone; ! 902: ULONG fpopDone, vaxDone, IEEEDone, mulDone, memSpcDone; ! 903: ! 904: ULONG index; ! 905: ! 906: POPTBLENTRY entry; ! 907: ! 908: ENTRY_TYPE curType = NOT_AN_ETYPE; ! 909: ULONG curFunc = NO_FUNC; // OPCODE field in func entry ! 910: ! 911: // ! 912: // To set the end of the table, and its size, without having ! 913: // nested case statements, maintain pointers to the entry and ! 914: // function tables we are currently walking through ! 915: // ! 916: ! 917: PULONG curTypeSize, curFuncSize; ! 918: POPTBLENTRY * curTypeTable, * curFuncTable; ! 919: ! 920: ! 921: // ! 922: // these will be reset before they are needed, but not before ! 923: // they are used. ! 924: // ! 925: ! 926: curTypeTable = (POPTBLENTRY *)&curTypeTable; ! 927: curTypeSize = (PULONG)&curTypeSize; ! 928: curFuncTable = (POPTBLENTRY *)&curFuncTable; ! 929: curFuncSize = (PULONG)&curFuncSize; ! 930: ! 931: palDone = arithDone = bitDone = byteDone = jmpDone = 0; ! 932: fpopDone = vaxDone = IEEEDone = mulDone = memSpcDone = 0; ! 933: ! 934: for (index = 0 ; index < SEARCHNUM; index++) { ! 935: ! 936: entry = &opTable[index]; ! 937: ! 938: switch(entry->eType) { ! 939: ! 940: case INVALID_ETYPE: ! 941: ! 942: if (curType == entry->eType) ! 943: continue; ! 944: ! 945: // ! 946: // The entries must be together; if this is a ! 947: // new type, we must never have seen it before ! 948: // ! 949: ! 950: // ! 951: // Finish off the old tables ! 952: // ! 953: ! 954: *curTypeSize = entry - *curTypeTable; ! 955: if (curType == FUNCTION_ETYPE) { ! 956: *curFuncSize = entry - *curFuncTable; ! 957: } ! 958: ! 959: // ! 960: // Set up the new table ! 961: // ! 962: ! 963: InvalidTab = entry; ! 964: curTypeSize = &InvalidTabSize; ! 965: curTypeTable = &InvalidTab; ! 966: curType = INVALID_ETYPE; ! 967: typesDone[INVALID_ETYPE] = 1; ! 968: break; ! 969: ! 970: case NON_TERMINAL_ETYPE: ! 971: ! 972: if (curType == entry->eType) ! 973: continue; ! 974: ! 975: *curTypeSize = entry - *curTypeTable; ! 976: if (curType == FUNCTION_ETYPE) { ! 977: *curFuncSize = entry - *curFuncTable; ! 978: } ! 979: ! 980: NonTerminalTab = entry; ! 981: curTypeSize = &NonTerminalTabSize; ! 982: curTypeTable = &NonTerminalTab; ! 983: curType = NON_TERMINAL_ETYPE; ! 984: typesDone[NON_TERMINAL_ETYPE] = 1; ! 985: break; ! 986: ! 987: case TERMINAL_ETYPE: ! 988: ! 989: if (curType == entry->eType) ! 990: continue; ! 991: ! 992: *curTypeSize = entry - *curTypeTable; ! 993: if (curType == FUNCTION_ETYPE) { ! 994: *curFuncSize = entry - *curFuncTable; ! 995: } ! 996: ! 997: TerminalTab = entry; ! 998: curTypeSize = &TerminalTabSize; ! 999: curTypeTable = &TerminalTab; ! 1000: curType = TERMINAL_ETYPE; ! 1001: typesDone[TERMINAL_ETYPE] = 1; ! 1002: break; ! 1003: ! 1004: ! 1005: case FUNCTION_ETYPE: ! 1006: ! 1007: if (entry->opCode == curFunc) ! 1008: continue; ! 1009: ! 1010: // ! 1011: // Take care of a new eType table; this exactly ! 1012: // parallels the three cases above (*_ETYPE) ! 1013: // ! 1014: ! 1015: if (curType != FUNCTION_ETYPE) { ! 1016: ! 1017: *curTypeSize = entry - *curTypeTable; ! 1018: ! 1019: FunctionTab = entry; ! 1020: curTypeSize = &FunctionTabSize; ! 1021: curTypeTable = &FunctionTab; ! 1022: curType = FUNCTION_ETYPE; ! 1023: typesDone[FUNCTION_ETYPE] = 1; ! 1024: ! 1025: } ! 1026: ! 1027: // ! 1028: // Next, handle a new function table when this is a new ! 1029: // function (==> when this is the first entry in the ! 1030: // FunctionTab) ! 1031: // ! 1032: ! 1033: ! 1034: switch(entry->opCode) { ! 1035: ! 1036: POPTBLENTRY e; ! 1037: ! 1038: case CALLPAL_OP: ! 1039: ! 1040: *curFuncSize = entry - *curFuncTable; ! 1041: ! 1042: e = findNonTerminalEntry(CALLPAL_OP); ! 1043: e->funcTable = entry; ! 1044: curFuncSize = &(e->funcTableSize); ! 1045: curFuncTable = &(e->funcTable); ! 1046: ! 1047: curFunc = CALLPAL_OP; ! 1048: palDone = 1; ! 1049: ! 1050: break; ! 1051: ! 1052: case ARITH_OP: ! 1053: ! 1054: *curFuncSize = entry - *curFuncTable; ! 1055: ! 1056: e = findNonTerminalEntry(ARITH_OP); ! 1057: e->funcTable = entry; ! 1058: curFuncSize = &(e->funcTableSize); ! 1059: curFuncTable = &(e->funcTable); ! 1060: ! 1061: curFunc = ARITH_OP; ! 1062: arithDone = 1; ! 1063: ! 1064: break; ! 1065: ! 1066: case BIT_OP: ! 1067: ! 1068: *curFuncSize = entry - *curFuncTable; ! 1069: ! 1070: e = findNonTerminalEntry(BIT_OP); ! 1071: e->funcTable = entry; ! 1072: curFuncSize = &(e->funcTableSize); ! 1073: curFuncTable = &(e->funcTable); ! 1074: ! 1075: curFunc = BIT_OP; ! 1076: bitDone = 1; ! 1077: ! 1078: break; ! 1079: ! 1080: case BYTE_OP: ! 1081: ! 1082: *curFuncSize = entry - *curFuncTable; ! 1083: ! 1084: e = findNonTerminalEntry(BYTE_OP); ! 1085: e->funcTable = entry; ! 1086: curFuncSize = &(e->funcTableSize); ! 1087: curFuncTable = &(e->funcTable); ! 1088: ! 1089: curFunc = BYTE_OP; ! 1090: byteDone = 1; ! 1091: ! 1092: break; ! 1093: ! 1094: case MUL_OP: ! 1095: ! 1096: *curFuncSize = entry - *curFuncTable; ! 1097: ! 1098: e = findNonTerminalEntry(MUL_OP); ! 1099: e->funcTable = entry; ! 1100: curFuncSize = &(e->funcTableSize); ! 1101: curFuncTable = &(e->funcTable); ! 1102: ! 1103: curFunc = MUL_OP; ! 1104: mulDone = 1; ! 1105: ! 1106: break; ! 1107: ! 1108: case MEMSPC_OP: ! 1109: ! 1110: *curFuncSize = entry - *curFuncTable; ! 1111: ! 1112: e = findNonTerminalEntry(MEMSPC_OP); ! 1113: e->funcTable = entry; ! 1114: curFuncSize = &(e->funcTableSize); ! 1115: curFuncTable = &(e->funcTable); ! 1116: ! 1117: curFunc = MEMSPC_OP; ! 1118: memSpcDone = 1; ! 1119: ! 1120: break; ! 1121: ! 1122: case JMP_OP: ! 1123: ! 1124: *curFuncSize = entry - *curFuncTable; ! 1125: ! 1126: e = findNonTerminalEntry(JMP_OP); ! 1127: e->funcTable = entry; ! 1128: curFuncSize = &(e->funcTableSize); ! 1129: curFuncTable = &(e->funcTable); ! 1130: ! 1131: curFunc = JMP_OP; ! 1132: jmpDone = 1; ! 1133: ! 1134: break; ! 1135: ! 1136: case VAXFP_OP: ! 1137: ! 1138: *curFuncSize = entry - *curFuncTable; ! 1139: ! 1140: e = findNonTerminalEntry(VAXFP_OP); ! 1141: e->funcTable = entry; ! 1142: curFuncSize = &(e->funcTableSize); ! 1143: curFuncTable = &(e->funcTable); ! 1144: ! 1145: curFunc = VAXFP_OP; ! 1146: vaxDone = 1; ! 1147: ! 1148: break; ! 1149: ! 1150: case IEEEFP_OP: ! 1151: ! 1152: *curFuncSize = entry - *curFuncTable; ! 1153: ! 1154: e = findNonTerminalEntry(IEEEFP_OP); ! 1155: e->funcTable = entry; ! 1156: curFuncSize = &(e->funcTableSize); ! 1157: curFuncTable = &(e->funcTable); ! 1158: ! 1159: curFunc = IEEEFP_OP; ! 1160: IEEEDone = 1; ! 1161: ! 1162: break; ! 1163: ! 1164: case FPOP_OP: ! 1165: ! 1166: *curFuncSize = entry - *curFuncTable; ! 1167: ! 1168: e = findNonTerminalEntry(FPOP_OP); ! 1169: e->funcTable = entry; ! 1170: curFuncSize = &(e->funcTableSize); ! 1171: curFuncTable = &(e->funcTable); ! 1172: ! 1173: curFunc = FPOP_OP; ! 1174: fpopDone = 1; ! 1175: ! 1176: break; ! 1177: ! 1178: default: ! 1179: ! 1180: break; ! 1181: ! 1182: } // end of Function table switch ! 1183: ! 1184: break; ! 1185: ! 1186: default: ! 1187: ! 1188: break; ! 1189: ! 1190: } // end of etype table switch ! 1191: } // end of For switch ! 1192: ! 1193: // ! 1194: // close out the size of the last tables ! 1195: // ! 1196: ! 1197: if (curType == FUNCTION_ETYPE) { ! 1198: *curFuncSize = &opTable[SEARCHNUM] - *curFuncTable; ! 1199: } ! 1200: *curTypeSize = &opTable[SEARCHNUM] - *curTypeTable; ! 1201: ! 1202: if (fVerboseOutput) { ! 1203: printTable(); ! 1204: } ! 1205: ! 1206: } // end of opTableInit ! 1207: ! 1208: void ! 1209: printTable() ! 1210: { ! 1211: ULONG i; ! 1212: POPTBLENTRY e; ! 1213: ! 1214: for (i = 0 ; i < SEARCHNUM; i++) { ! 1215: e = &opTable[i]; ! 1216: switch (e->eType) { ! 1217: case INVALID_ETYPE: ! 1218: break; ! 1219: ! 1220: case TERMINAL_ETYPE: ! 1221: break; ! 1222: ! 1223: case FUNCTION_ETYPE: ! 1224: break; ! 1225: ! 1226: case NON_TERMINAL_ETYPE: ! 1227: break; ! 1228: } ! 1229: } ! 1230: ! 1231: } ! 1232: ! 1233: ! 1234: // ! 1235: // These routines are part of the assembler, which is not ! 1236: // yet referenced in windbg, so these are place holders till then ! 1237: // ! 1238: ! 1239: ! 1240: ULONG ParseIntMemory (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1241: { ! 1242: return(0); ! 1243: } ! 1244: ULONG ParseFltMemory (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1245: { ! 1246: return(0); ! 1247: } ! 1248: ULONG ParseMemSpec (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1249: { ! 1250: return(0); ! 1251: } ! 1252: ULONG ParseJump (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1253: { ! 1254: return(0); ! 1255: } ! 1256: ULONG ParseIntBranch (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1257: { ! 1258: return(0); ! 1259: } ! 1260: ULONG ParseFltBranch (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1261: { ! 1262: return(0); ! 1263: } ! 1264: ULONG ParseIntOp (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1265: { ! 1266: return(0); ! 1267: } ! 1268: ULONG ParsePal (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1269: { ! 1270: return(0); ! 1271: } ! 1272: ULONG ParseUnknown (PUCHAR a, PUCHAR * b, POPTBLENTRY c, PULONG d) ! 1273: { ! 1274: return(0); ! 1275: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.