Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
alphaopt.c
Package: win2ksrc.rar　[view]
Upload User: caisha3
Upload Date: 2013-09-21
Package Size: 208739k
Code Size: 45k
Category:

Windows Develop

Development Platform:

Visual C++

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