![[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.