开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
AlphaOps.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：43k
源码类别：

模拟服务器

开发平台：

C/C++

AlphaOps.h：源码内容
  1. /*++
  3. Copyright (c) 1992-1999  Digital Equipment Corporation
  5. Module Name:
  7.     alphaops.h
  9. Abstract:
  11.     Alpha AXP instruction and floating constant definitions.
  13. Author:
  15. Revision History:
  17. --*/
  19. #ifndef _ALPHAOPS_
  20. #define _ALPHAOPS_
  22. #if _MSC_VER > 1000
  23. #pragma once
  24. #endif
  26. //
  27. // Instruction types.
  28. //      The Alpha architecture does not number the instruction types,
  29. //      this numbering is for software decoding only.
  30. //
  32. #define ALPHA_UNKNOWN           0       // Reserved or illegal
  33. #define ALPHA_MEMORY            1       // Memory (load/store)
  34. #define ALPHA_FP_MEMORY         2       // Floating point Memory
  35. #define ALPHA_MEMSPC            3       // Memory special
  36. #define ALPHA_JUMP              4       // Jump (memory formation)
  37. #define ALPHA_BRANCH            5       // Branch
  38. #define ALPHA_FP_BRANCH         6       // Floating Point Branch
  39. #define ALPHA_OPERATE           7       // Register-register operate
  40. #define ALPHA_LITERAL           8       // Literal-register operate
  41. #define ALPHA_FP_OPERATE        9       // Floating point operate
  42. #define ALPHA_FP_CONVERT        10      // Floating point convert
  43. #define ALPHA_CALLPAL           11      // Call to PAL
  44. #define ALPHA_EV4_PR            12      // EV4 MTPR/MFPR PAL mode instructions
  45. #define ALPHA_EV4_MEM           13      // EV4 special memory PAL mode access
  46. #define ALPHA_EV4_REI           14      // EV4 PAL mode switch
  48. //
  49. // Instruction Opcodes.
  50. //
  52. #define CALLPAL_OP      0x00    // ALPHA_CALLPAL
  53. #define _01_OP          0x01    // - reserved opcode
  54. #define _02_OP          0x02    // - reserved opcode
  55. #define _03_OP          0x03    // - reserved opcode
  56. #define _04_OP          0x04    // - reserved opcode
  57. #define _05_OP          0x05    // - reserved opcode
  58. #define _06_OP          0x06    // - reserved opcode
  59. #define _07_OP          0x07    // - reserved opcode
  60. #define _0A_OP                  0x0A    // - reserved opcode
  61. #define _0C_OP                  0x0C    // - reserved opcode
  62. #define _0D_OP                  0x0D    // - reserved opcode
  63. #define _0E_OP                  0x0E    // - reserved opcode
  64. #define _1C_OP                  0x1C    // - reserved opcode
  65. #define LDA_OP          0x08    // ALPHA_MEMORY
  66. #define LDAH_OP         0x09    // ALPHA_MEMORY
  67. #define LDBU_OP         0x0A    // ALPHA_MEMORY
  68. #define LDQ_U_OP        0x0B    // ALPHA_MEMORY
  69. #define LDWU_OP         0x0C    // ALPHA_MEMORY
  70. #define STW_OP          0x0D    // ALPHA_MEMORY
  71. #define STB_OP          0x0E    // ALPHA_MEMORY
  72. #define STQ_U_OP        0x0F    // ALPHA_MEMORY
  73. #define ARITH_OP        0x10    // ALPHA_OPERATE or ALPHA_LITERAL
  74. #define BIT_OP          0x11    // ALPHA_OPERATE or ALPHA_LITERAL
  75. #define BYTE_OP         0x12    // ALPHA_OPERATE or ALPHA_LITERAL
  76. #define MUL_OP          0x13    // ALPHA_OPERATE or ALPHA_LITERAL
  77. #define _14_OP          0x14    // - reserved opcode
  78. #define VAXFP_OP        0x15    // ALPHA_FP_OPERATE
  79. #define IEEEFP_OP       0x16    // ALPHA_FP_OPERATE
  80. #define FPOP_OP         0x17    // ALPHA_FP_OPERATE
  81. #define MEMSPC_OP       0x18    // ALPHA_MEMORY
  82. #define PAL19_OP        0x19    // - reserved for PAL mode
  83. //#define MFPR_OP         0x19    // ALPHA_MFPR
  84. #define JMP_OP          0x1A    // ALPHA_JUMP
  85. #define PAL1B_OP        0x1B    // - reserved for PAL mode
  86. #define SEXT_OP         0x1C    // ALPHA_OPERATE
  87. #define PAL1D_OP        0x1D    // - reserved for PAL mode
  88. //#define MTPR_OP         0x1D    // ALPHA_MTPR
  89. #define PAL1E_OP        0x1E    // - reserved for PAL mode
  90. #define PAL1F_OP        0x1F    // - reserved for PAL mode
  91. #define LDF_OP          0x20    // ALPHA_MEMORY
  92. #define LDG_OP          0x21    // ALPHA_MEMORY
  93. #define LDS_OP          0x22    // ALPHA_MEMORY
  94. #define LDT_OP          0x23    // ALPHA_MEMORY
  95. #define STF_OP          0x24    // ALPHA_MEMORY
  96. #define STG_OP          0x25    // ALPHA_MEMORY
  97. #define STS_OP          0x26    // ALPHA_MEMORY
  98. #define STT_OP          0x27    // ALPHA_MEMORY
  99. #define LDL_OP          0x28    // ALPHA_MEMORY
  100. #define LDQ_OP          0x29    // ALPHA_MEMORY
  101. #define LDL_L_OP        0x2A    // ALPHA_MEMORY
  102. #define LDQ_L_OP        0x2B    // ALPHA_MEMORY
  103. #define STL_OP          0x2C    // ALPHA_MEMORY
  104. #define STQ_OP          0x2D    // ALPHA_MEMORY
  105. #define STL_C_OP        0x2E    // ALPHA_MEMORY
  106. #define STQ_C_OP        0x2F    // ALPHA_MEMORY
  107. #define BR_OP           0x30    // ALPHA_BRANCH
  108. #define FBEQ_OP         0x31    // ALPHA_BRANCH
  109. #define FBLT_OP         0x32    // ALPHA_BRANCH
  110. #define FBLE_OP         0x33    // ALPHA_BRANCH
  111. #define BSR_OP          0x34    // ALPHA_BRANCH
  112. #define FBNE_OP         0x35    // ALPHA_BRANCH
  113. #define FBGE_OP         0x36    // ALPHA_BRANCH
  114. #define FBGT_OP         0x37    // ALPHA_BRANCH
  115. #define BLBC_OP         0x38    // ALPHA_BRANCH
  116. #define BEQ_OP          0x39    // ALPHA_BRANCH
  117. #define BLT_OP          0x3A    // ALPHA_BRANCH
  118. #define BLE_OP          0x3B    // ALPHA_BRANCH
  119. #define BLBS_OP         0x3C    // ALPHA_BRANCH
  120. #define BNE_OP          0x3D    // ALPHA_BRANCH
  121. #define BGE_OP          0x3E    // ALPHA_BRANCH
  122. #define BGT_OP          0x3F    // ALPHA_BRANCH
  124. #define LDA_OP_STR      "lda"
  125. #define LDAH_OP_STR     "ldah"
  126. #define LDBU_OP_STR     "ldbu"
  127. #define LDQ_U_OP_STR    "ldq_u"
  128. #define STQ_U_OP_STR    "stq_u"
  129. #define LDF_OP_STR      "ldf"
  130. #define LDG_OP_STR      "ldg"
  131. #define LDS_OP_STR      "lds"
  132. #define LDT_OP_STR      "ldt"
  133. #define LDWU_OP_STR     "ldwu"
  134. #define STF_OP_STR      "stf"
  135. #define STG_OP_STR      "stg"
  136. #define STS_OP_STR      "sts"
  137. #define STT_OP_STR      "stt"
  138. #define LDL_OP_STR      "ldl"
  139. #define LDQ_OP_STR      "ldq"
  140. #define LDL_L_OP_STR    "ldl_l"
  141. #define LDQ_L_OP_STR    "ldq_l"
  142. #define SEXT_OP_STR     "sext"
  143. #define STB_OP_STR      "stb"
  144. #define STL_OP_STR      "stl"
  145. #define STQ_OP_STR      "stq"
  146. #define STL_C_OP_STR    "stl_c"
  147. #define STQ_C_OP_STR    "stq_c"
  148. #define STW_OP_STR      "stw"
  149. #define BR_OP_STR       "br"
  150. #define FBEQ_OP_STR     "fbeq"
  151. #define FBLT_OP_STR     "fblt"
  152. #define FBLE_OP_STR     "fble"
  153. #define BSR_OP_STR      "bsr"
  154. #define FBNE_OP_STR     "fbne"
  155. #define FBGE_OP_STR     "fbge"
  156. #define FBGT_OP_STR     "fbgt"
  157. #define BLBC_OP_STR     "blbc"
  158. #define BEQ_OP_STR      "beq"
  159. #define BLT_OP_STR      "blt"
  160. #define BLE_OP_STR      "ble"
  161. #define BLBS_OP_STR     "blbs"
  162. #define BNE_OP_STR      "bne"
  163. #define BGE_OP_STR      "bge"
  164. #define BGT_OP_STR      "bgt"
  166. //
  167. // Type (1) Memory Instruction Format.
  168. // Type (2) Memory Special Instruction Format.
  169. //
  170. //  3         2 2       2 2       1 1
  171. //  1         6 5       1 0       6 5                             0
  172. // +-----------+---------+---------+-------------------------------+
  173. // |   opcode  |   Ra    |   Rb    |          Memory_disp          |
  174. // +-----------+---------+---------+-------------------------------+
  175. //
  176. //      LDAx    Ra.wq,disp.ab(Rb.ab)            x = (,H)
  177. //      LDx     Ra.wq,disp.ab(Rb.ab)            x = (L,Q,F,G,S,T)
  178. //      LDQ_U   Ra.wq,disp.ab(Rb.ab)
  179. //      LDx_L   Ra.wq,disp.ab(Rb.ab)            x = (L,Q)
  180. //      STx_C   Ra.mq,disp.ab(Rb.ab)            x = (L,Q)
  181. //      STx     Ra.rq,disp.ab(Rb.ab)            x = (L,Q,F,G,S,T)
  182. //      STQ_U   Ra.rq,disp.ab(Rb.ab)
  183. //
  185. typedef struct _Alpha_Memory_Format {
  186.         LONG MemDisp : 16;
  187.         ULONG Rb : 5;
  188.         ULONG Ra : 5;
  189.         ULONG Opcode : 6;
  190. } Alpha_Memory_Format;
  192. //
  193. // Special Memory instruction function codes (in Memdisp).
  194. //
  196. #define TRAPB_FUNC        0x0000
  197. #define EXCB_FUNC         0x0400
  198. #define MB_FUNC           0x4000
  199. #define WMB_FUNC          0x4400
  200. #define MB2_FUNC          0x4800
  201. #define MB3_FUNC          0x4C00
  202. #define FETCH_FUNC        0x8000
  203. #define FETCH_M_FUNC      0xA000
  204. #define RPCC_FUNC         0xC000
  205. #define RC_FUNC           0xE000
  206. #define RS_FUNC           0xF000
  208. #define TRAPB_FUNC_STR     "trapb"
  209. #define EXCB_FUNC_STR      "excb"
  210. #define MB_FUNC_STR        "mb"
  211. #define MB1_FUNC_STR       "wmb"
  212. #define MB2_FUNC_STR       "mb2"
  213. #define MB3_FUNC_STR       "mb3"
  214. #define FETCH_FUNC_STR     "fetch"
  215. #define FETCH_M_FUNC_STR   "fetch_m"
  216. #define RPCC_FUNC_STR      "rpcc"
  217. #define RC_FUNC_STR        "rc"
  218. #define RS_FUNC_STR        "rs"
  220. //
  221. // Type (3) Memory Format Jump Instructions.
  222. //
  223. //  3         2 2       2 2       1 1 1 1
  224. //  1         6 5       1 0       6 5 4 3                         0
  225. // +-----------+---------+---------+---+---------------------------+
  226. // |   opcode  |   Ra    |   Rb    |Fnc|            Hint           |
  227. // +-----------+---------+---------+---+---------------------------+
  228. //
  229. //      xxx     Ra.wq,(Rb.ab),hint      xxx = (JMP, JSR, RET, JSR_COROUTINE)
  230. //
  232. typedef struct _Alpha_Jump_Format {
  233.         LONG Hint : 14;
  234.         ULONG Function : 2;
  235.         ULONG Rb : 5;
  236.         ULONG Ra : 5;
  237.         ULONG Opcode : 6;
  238. } Alpha_Jump_Format;
  240. //
  241. // Jump function codes (in Function, opcode 1A, JMP_OP).
  242. //
  244. #define JMP_FUNC        0x0     // Jump
  245. #define JSR_FUNC        0x1     // Jump to Subroutine
  246. #define RET_FUNC        0x2     // Return from Subroutine
  247. #define JSR_CO_FUNC     0x3     // Jump to Subroutine Return
  249. #define JMP_FUNC_STR      "jmp"
  250. #define JSR_FUNC_STR      "jsr"
  251. #define RET_FUNC_STR      "ret"
  252. #define JSR_CO_FUNC_STR   "jsr_coroutine"
  254. //
  255. // The exception handling compatible return instruction has a hint value
  256. // of 0001. Define a macro that identifies these return instructions.
  257. // The Rb register field is masked out since it is normally, but not
  258. // required to be, RA_REG.
  259. //
  261. #define IS_RETURN_0001_INSTRUCTION(Instruction) 
  262.     (((Instruction) & 0xFFE0FFFF) == 0x6BE08001)
  264. //
  265. // Type (4) Branch Instruction Format.
  266. //
  267. //  3         2 2       2 2
  268. //  1         6 5       1 0                                       0
  269. // +-----------+---------+-----------------------------------------+
  270. // |   opcode  |   Ra    |             Branch_disp                 |
  271. // +-----------+---------+-----------------------------------------+
  272. //
  273. //      Bxx     Ra.rq,disp.al           x = (EQ,NE,LT,LE,GT,GE,LBC,LBS)
  274. //      BxR     Ra.wq,disp.al           x = (,S)
  275. //      FBxx    Ra.rq,disp.al           x = (EQ,NE,LT,LE,GT,GE)
  276. //
  278. typedef struct _Alpha_Branch_Format {
  279.         LONG BranchDisp : 21;
  280.         ULONG Ra : 5;
  281.         ULONG Opcode : 6;
  282. } Alpha_Branch_Format;
  284. //
  285. // Type (5) Operate Register Instruction Format.
  286. // Type (6) Operate Literal Instruction Format.
  287. //               bop = Rb.rq or #b.ib
  288. //
  289. //  3         2 2       2 2       1 1   1 1 1
  290. //  1         6 5       1 0       6 5   3 2 1           5 4       0
  291. // +-----------+---------+---------+-----+-+-------------+---------+
  292. // |   opcode  |   Ra    |   Rb    | SBZ |0|  function   |   Rc    |
  293. // +-----------+---------+---------+-----+-+-------------+---------+
  294. //  3         2 2       2 2             1 1 1
  295. //  1         6 5       1 0             3 2 1           5 4       0
  296. // +-----------+---------+---------------+-+-------------+---------+
  297. // |   opcode  |   Ra    |      LIT      |1|  function   |   Rc    |
  298. // +-----------+---------+---------------+-+-------------+---------+
  299. //
  300. //
  301. //      ADDx    Ra.rq,bop,Rc.wq /V      x = (Q,L)
  302. //      SxADDy  Ra.rq,bop,Rc.wq         x = (4,8), y = (Q, L)
  303. //      CMPx    Ra.rq,bop,Rc.wq         x = (EQ,LT,LE,ULT,ULE)
  304. //      MULx    Ra.rq,bop,Rc.wq /V      x = (Q,L)
  305. //      UMULH   Ra.rq,bop,Rc.wq
  306. //      SUBx    Ra.rq,bop,Rc.wq /V      x = (Q,L)
  307. //      SxSUBy  Ra.rq,bop,Rc.wq         x = (4,8), y = (Q, L)
  308. //      xxx     Ra.rq,bop,Rc.wq         xxx = (AND,BIS,XOR,BIC,ORNOT,EQV)
  309. //      CMOVxx  Ra.rq,bop,Rc.wq         xx = (EQ,NE,LT,LE,GT,GE,LBC,LBS)
  310. //      SxL     Ra.rq,bop,Rc.wq         x = (L,R)
  311. //      SRA     Ra.rq,bop,Rc.wq
  312. //      CMPBGE  Ra.rq,bop,Rc.wq
  313. //      EXTxx   Ra.rq,bop,Rc.wq         xx = (BL,WL,WH,LL,LH,WL,QH)
  314. //      INSxx   Ra.rq,bop,Rc.wq         xx = (BL,WL,WH,LL,LH,WL,QH)
  315. //      MSKxx   Ra.rq,bop,Rc.wq         xx = (BL,WL,WH,LL,LH,WL,QH)
  316. //      ZAPx    Ra.rq,bop,Rc.wq         x = (,NOT)
  317. //
  319. typedef struct _Alpha_OpReg_Format {
  320.         ULONG Rc : 5;
  321.         ULONG Function : 7;
  322.         ULONG RbvType : 1;              // 0 for register format
  323.         ULONG SBZ : 3;
  324.         ULONG Rb : 5;
  325.         ULONG Ra : 5;
  326.         ULONG Opcode : 6;
  327. } Alpha_OpReg_Format;
  329. typedef struct _Alpha_OpLit_Format {
  330.         ULONG Rc : 5;
  331.         ULONG Function : 7;
  332.         ULONG RbvType : 1;              // 1 for literal format
  333.         ULONG Literal : 8;
  334.         ULONG Ra : 5;
  335.         ULONG Opcode : 6;
  336. } Alpha_OpLit_Format;
  338. #define RBV_REGISTER_FORMAT 0
  339. #define RBV_LITERAL_FORMAT 1
  341. //
  342. // Arithmetic operate function codes (in Function, Opcode 10, ARITH_OP).
  343. //
  345. #define ADDL_FUNC       0x00    // Add Longword
  346. #define ADDLV_FUNC      0x40    // Add Longword, Integer Overflow Enable
  347. #define S4ADDL_FUNC     0x02    // Scaled Add Longword by 4
  348. #define S8ADDL_FUNC     0x12    // Scaled Add Longword by 8
  350. #define ADDQ_FUNC       0x20    // Add Quadword
  351. #define ADDQV_FUNC      0x60    // Add Quadword, Integer Overflow Enable
  352. #define S4ADDQ_FUNC     0x22    // Scaled Add Quadword by 4
  353. #define S8ADDQ_FUNC     0x32    // Scaled Add Quadword by 8
  355. #define SUBL_FUNC       0x09    // Subtract Longword
  356. #define SUBLV_FUNC      0x49    // Subtract Longword, Integer Overflow Enable
  357. #define S4SUBL_FUNC     0x0B    // Scaled Subtract Longword by 4
  358. #define S8SUBL_FUNC     0x1B    // Scaled Subtract Longword by 8
  360. #define SUBQ_FUNC       0x29    // Subtract Quadword
  361. #define SUBQV_FUNC      0x69    // Subtract Quadword, Integer Overflow Enable
  362. #define S4SUBQ_FUNC     0x2B    // Scaled Subtract Quadword by 4
  363. #define S8SUBQ_FUNC     0x3B    // Scaled Subtract Quadword by 8
  365. #define CMPEQ_FUNC      0x2D    // Compare Signed Quadword Equal
  366. #define CMPLT_FUNC      0x4D    // Compare Signed Quadword Less Than
  367. #define CMPLE_FUNC      0x6D    // Compare Signed Quadword Less Than or Equal
  368. #define CMPULT_FUNC     0x1D    // Compare Unsigned Quadword Less Than
  369. #define CMPULE_FUNC     0x3D    // Compare Unsigned Quadword Less Than or Equal
  370. #define CMPBGE_FUNC     0x0F    // Compare 8 Unsigned Bytes Greater Than or Equal
  372. #define ADDL_FUNC_STR     "addl"
  373. #define ADDLV_FUNC_STR    "addl/v"
  374. #define S4ADDL_FUNC_STR   "s4addl"
  375. #define S8ADDL_FUNC_STR   "s8addl"
  377. #define ADDQ_FUNC_STR     "addq"
  378. #define ADDQV_FUNC_STR    "addq/v"
  379. #define S4ADDQ_FUNC_STR   "s4addq"
  380. #define S8ADDQ_FUNC_STR   "s8addq"
  382. #define SUBL_FUNC_STR     "subl"
  383. #define SUBLV_FUNC_STR    "subl/v"
  384. #define S4SUBL_FUNC_STR   "s4subl"
  385. #define S8SUBL_FUNC_STR   "s8subl"
  387. #define SUBQ_FUNC_STR     "subq"
  388. #define SUBQV_FUNC_STR    "subq/v"
  389. #define S4SUBQ_FUNC_STR   "s4subq"
  390. #define S8SUBQ_FUNC_STR   "s8subq"
  392. #define CMPEQ_FUNC_STR    "cmpeq"
  393. #define CMPLT_FUNC_STR    "cmplt"
  394. #define CMPLE_FUNC_STR    "cmple"
  395. #define CMPULT_FUNC_STR   "cmpult"
  396. #define CMPULE_FUNC_STR   "cmpule"
  397. #define CMPBGE_FUNC_STR   "cmpbge"
  399. //
  400. // Bit and conditional operate function codes (in Function, Opcode 11, BIT_OP).
  401. //
  403. #define AND_FUNC        0x00    // Logical Product
  404. #define BIC_FUNC        0x08    // Logical Product with Complement
  405. #define BIS_FUNC        0x20    // Logical Sum (OR)
  406. #define EQV_FUNC        0x48    // Logical Equivalence (XORNOT)
  407. #define ORNOT_FUNC      0x28    // Logical Sum with Complement
  408. #define XOR_FUNC        0x40    // Logical Difference
  410. #define CMOVEQ_FUNC     0x24    // CMOVE if Register Equal to Zero
  411. #define CMOVGE_FUNC     0x46    // CMOVE if Register Greater Than or Equal to Zero
  412. #define CMOVGT_FUNC     0x66    // CMOVE if Register Greater Than Zero
  413. #define CMOVLBC_FUNC    0x16    // CMOVE if Register Low Bit Clear
  414. #define CMOVLBS_FUNC    0x14    // CMOVE if Register Low Bit Set
  415. #define CMOVLE_FUNC     0x64    // CMOVE if Register Less Than or Equal to Zero
  416. #define CMOVLT_FUNC     0x44    // CMOVE if Register Less Than Zero
  417. #define CMOVNE_FUNC     0x26    // CMOVE if Register Not Equal to Zero
  419. #define AND_FUNC_STR       "and"
  420. #define BIC_FUNC_STR       "bic"
  421. #define BIS_FUNC_STR       "bis"
  422. #define EQV_FUNC_STR       "eqv"
  423. #define ORNOT_FUNC_STR     "ornot"
  424. #define XOR_FUNC_STR       "xor"
  426. #define CMOVEQ_FUNC_STR    "cmoveq"
  427. #define CMOVGE_FUNC_STR    "cmovge"
  428. #define CMOVGT_FUNC_STR    "cmovgt"
  429. #define CMOVLBC_FUNC_STR   "cmovlbc"
  430. #define CMOVLBS_FUNC_STR   "cmovlbs"
  431. #define CMOVLE_FUNC_STR    "cmovle"
  432. #define CMOVLT_FUNC_STR    "cmovlt"
  433. #define CMOVNE_FUNC_STR    "cmovne"
  435. //
  436. // Shift and byte operate function codes (in Function, Opcode 12, BYTE_OP).
  437. //
  439. #define SLL_FUNC        0x39    // Shift Left Logical
  440. #define SRL_FUNC        0x34    // Shift Right Logical
  441. #define SRA_FUNC        0x3C    // Shift Right Arithmetic
  443. #define EXTBL_FUNC      0x06    // Extract Byte Low
  444. #define EXTWL_FUNC      0x16    // Extract Word Low
  445. #define EXTLL_FUNC      0x26    // Extract Longword Low
  446. #define EXTQL_FUNC      0x36    // Extract Quadword Low
  447. #define EXTWH_FUNC      0x5A    // Extract Word High
  448. #define EXTLH_FUNC      0x6A    // Extract Longword High
  449. #define EXTQH_FUNC      0x7A    // Extract Quadword High
  451. #define INSBL_FUNC      0x0B    // Insert Byte Low
  452. #define INSWL_FUNC      0x1B    // Insert Word Low
  453. #define INSLL_FUNC      0x2B    // Insert Longword Low
  454. #define INSQL_FUNC      0x3B    // Quadword Low
  455. #define INSWH_FUNC      0x57    // Insert Word High
  456. #define INSLH_FUNC      0x67    // Insert Longword High
  457. #define INSQH_FUNC      0x77    // Insert Quadword High
  459. #define MSKBL_FUNC      0x02    // Mask Byte Low
  460. #define MSKWL_FUNC      0x12    // Mask Word Low
  461. #define MSKLL_FUNC      0x22    // Mask Longword Low
  462. #define MSKQL_FUNC      0x32    // Mask Quadword Low
  463. #define MSKWH_FUNC      0x52    // Mask Word High
  464. #define MSKLH_FUNC      0x62    // Mask Longword High
  465. #define MSKQH_FUNC      0x72    // Mask Quadword High
  467. #define ZAP_FUNC        0x30    // Zero Bytes
  468. #define ZAPNOT_FUNC     0x31    // Zero Bytes Not
  470. #define SLL_FUNC_STR    "sll"
  471. #define SRL_FUNC_STR    "srl"
  472. #define SRA_FUNC_STR    "sra"
  474. #define EXTBL_FUNC_STR  "extbl"
  475. #define EXTWL_FUNC_STR  "extwl"
  476. #define EXTLL_FUNC_STR  "extll"
  477. #define EXTQL_FUNC_STR  "extql"
  478. #define EXTWH_FUNC_STR  "extwh"
  479. #define EXTLH_FUNC_STR  "extlh"
  480. #define EXTQH_FUNC_STR  "extqh"
  482. #define INSBL_FUNC_STR  "insbl"
  483. #define INSWL_FUNC_STR  "inswl"
  484. #define INSLL_FUNC_STR  "insll"
  485. #define INSQL_FUNC_STR  "insql"
  486. #define INSWH_FUNC_STR  "inswh"
  487. #define INSLH_FUNC_STR  "inslh"
  488. #define INSQH_FUNC_STR  "insqh"
  490. #define MSKBL_FUNC_STR  "mskbl"
  491. #define MSKWL_FUNC_STR  "mskwl"
  492. #define MSKLL_FUNC_STR  "mskll"
  493. #define MSKQL_FUNC_STR  "mskql"
  494. #define MSKWH_FUNC_STR  "mskwh"
  495. #define MSKLH_FUNC_STR  "msklh"
  496. #define MSKQH_FUNC_STR  "mskqh"
  498. #define ZAP_FUNC_STR    "zap"
  499. #define ZAPNOT_FUNC_STR "zapnot"
  501. //
  502. // Integer multiply operate function codes (in Function, Opcode 13, MUL_OP).
  503. //
  505. #define MULL_FUNC       0x00    // Multiply Longword
  506. #define MULLV_FUNC      0x40    // Multiply Longword, Integer Overflow Enable
  507. #define MULQ_FUNC       0x20    // Multiply Quadword
  508. #define MULQV_FUNC      0x60    // Multiply Quadword, Integer Overflow Enable
  509. #define UMULH_FUNC      0x30    // Unsinged Multiply Quadword High
  511. #define MULL_FUNC_STR   "mull"
  512. #define MULLV_FUNC_STR  "mull/v"
  513. #define MULQ_FUNC_STR   "mulq"
  514. #define MULQV_FUNC_STR  "mulq/v"
  515. #define UMULH_FUNC_STR  "umulh"
  517. //
  518. // Sign extend operate function codes (in Function, Opcode 1c, SEXT_OP).
  519. //
  521. #define SEXTB_FUNC      0x00    // sign extend byte
  522. #define SEXTW_FUNC      0x01    // sign extend word
  523. #define CTPOP_FUNC      0x30    // count population
  524. #define CTLZ_FUNC       0x32    // count leading zeros
  525. #define CTTZ_FUNC       0x33    // count trailing zeros
  527. #define SEXTB_FUNC_STR  "sextb"
  528. #define SEXTW_FUNC_STR  "sextw"
  529. #define CTPOP_FUNC_STR  "ctpop"
  530. #define CTLZ_FUNC_STR   "ctlz"
  531. #define CTTZ_FUNC_STR   "cttz"
  533. //
  534. // Type (7) Floating-point Operate Instruction Format.
  535. // Type (8) Floating-point Convert Instruction Format.
  536. //
  537. // Type 6 and 7 are the same, except for type 7
  538. //      Fc == F31 (1s) and Fb is the source.
  539. //
  540. //  3         2 2       2 2       1 1
  541. //  1         6 5       1 0       6 5                   5 4       0
  542. // +-----------+---------+---------+---------------------+---------+
  543. // |   opcode  |   Fa    |   Fb    |      function       |   Fc    |
  544. // +-----------+---------+---------+---------------------+---------+
  545. //
  547. typedef struct _Alpha_FpOp_Format {
  548.         ULONG Fc : 5;
  549.         ULONG Function : 11;
  550.         ULONG Fb : 5;
  551.         ULONG Fa : 5;
  552.         ULONG Opcode : 6;
  553. } Alpha_FpOp_Format;
  555. //
  556. // Format independent function codes (in Function, Opcode 17)
  557. //
  559. #define CVTLQ_FUNC      0x010
  560. #define CPYS_FUNC       0x020
  561. #define CPYSN_FUNC      0x021
  562. #define CPYSE_FUNC      0x022
  563. #define MT_FPCR_FUNC    0x024
  564. #define MF_FPCR_FUNC    0x025
  565. #define FCMOVEQ_FUNC    0x02A
  566. #define FCMOVNE_FUNC    0x02B
  567. #define FCMOVLT_FUNC    0x02C
  568. #define FCMOVGE_FUNC    0x02D
  569. #define FCMOVLE_FUNC    0x02E
  570. #define FCMOVGT_FUNC    0x02F
  571. #define CVTQL_FUNC      0x030
  572. #define CVTQLV_FUNC     0x130
  573. #define CVTQLSV_FUNC    0x530
  575. #define CVTLQ_FUNC_STR      "cvtlq"
  576. #define CPYS_FUNC_STR       "cpys"
  577. #define CPYSN_FUNC_STR      "cpysn"
  578. #define CPYSE_FUNC_STR      "cpyse"
  579. #define MT_FPCR_FUNC_STR    "mt_fpcr"
  580. #define MF_FPCR_FUNC_STR    "mf_fpcr"
  581. #define FCMOVEQ_FUNC_STR    "fcmoveq"
  582. #define FCMOVNE_FUNC_STR    "fcmovne"
  583. #define FCMOVLT_FUNC_STR    "fcmovlt"
  584. #define FCMOVGE_FUNC_STR    "fcmovge"
  585. #define FCMOVLE_FUNC_STR    "fcmovle"
  586. #define FCMOVGT_FUNC_STR    "fcmovgt"
  587. #define CVTQL_FUNC_STR      "cvtql"
  588. #define CVTQLV_FUNC_STR     "cvtql/v"
  589. #define CVTQLSV_FUNC_STR    "cvtql/sv"
  591. //
  592. // IEEE function codes without flags (in Function, Opcode 16).
  593. //
  595. #define MSK_FP_OP       0x03F
  597. #define ADDS_FUNC       0x000
  598. #define SUBS_FUNC       0x001
  599. #define MULS_FUNC       0x002
  600. #define DIVS_FUNC       0x003
  601. #define ADDT_FUNC       0x020
  602. #define SUBT_FUNC       0x021
  603. #define MULT_FUNC       0x022
  604. #define DIVT_FUNC       0x023
  605. #define CMPTUN_FUNC     0x024
  606. #define CMPTEQ_FUNC     0x025
  607. #define CMPTLT_FUNC     0x026
  608. #define CMPTLE_FUNC     0x027
  609. #define CVTTS_FUNC      0x02C
  610. #define CVTTQ_FUNC      0x02F
  611. #define CVTQS_FUNC      0x03C
  612. #define CVTQT_FUNC      0x03E
  614. #define ADDS_FUNC_STR       "adds"
  615. #define SUBS_FUNC_STR       "subs"
  616. #define MULS_FUNC_STR       "muls"
  617. #define DIVS_FUNC_STR       "divs"
  618. #define ADDT_FUNC_STR       "addt"
  619. #define SUBT_FUNC_STR       "subt"
  620. #define MULT_FUNC_STR       "mult"
  621. #define DIVT_FUNC_STR       "divt"
  622. #define CMPTUN_FUNC_STR     "cmptun"
  623. #define CMPTEQ_FUNC_STR     "cmpteq"
  624. #define CMPTLT_FUNC_STR     "cmptlt"
  625. #define CMPTLE_FUNC_STR     "cmptle"
  626. #define CVTTS_FUNC_STR      "cvtts"
  627. #define CVTTQ_FUNC_STR      "cvttq"
  628. #define CVTQS_FUNC_STR      "cvtqs"
  629. #define CVTQT_FUNC_STR      "cvtqt"
  631. //
  632. // CVTST is a little different.
  633. //
  635. #define CVTST_FUNC      0x2AC
  636. #define CVTST_S_FUNC    0x6AC
  638. #define CVTST_FUNC_STR      "cvtst"
  639. #define CVTST_S_FUNC_STR    "cvtst/s"
  641. //
  642. // VAX function codes without flags (in Function, Opcode 15).
  643. //
  645. #define ADDF_FUNC       0x000
  646. #define CVTDG_FUNC      0x01E
  647. #define ADDG_FUNC       0x020
  648. #define CMPGEQ_FUNC     0x025
  649. #define CMPGLT_FUNC     0x026
  650. #define CMPGLE_FUNC     0x027
  651. #define CVTGF_FUNC      0x02C
  652. #define CVTGD_FUNC      0x02D
  653. #define CVTQF_FUNC      0x03C
  654. #define CVTQG_FUNC      0x03E
  655. #define DIVF_FUNC       0x003
  656. #define DIVG_FUNC       0x023
  657. #define MULF_FUNC       0x002
  658. #define MULG_FUNC       0x022
  659. #define SUBF_FUNC       0x001
  660. #define SUBG_FUNC       0x021
  661. #define CVTGQ_FUNC      0x0AF
  663. #define ADDF_FUNC_STR       "addf"
  664. #define CVTDG_FUNC_STR      "cvtdg"
  665. #define ADDG_FUNC_STR       "addg"
  666. #define CMPGEQ_FUNC_STR     "cmpgeq"
  667. #define CMPGLT_FUNC_STR     "cmpglt"
  668. #define CMPGLE_FUNC_STR     "cmpgle"
  669. #define CVTGF_FUNC_STR      "cvtgf"
  670. #define CVTGD_FUNC_STR      "cvtgd"
  671. #define CVTQF_FUNC_STR      "cvtqf"
  672. #define CVTQG_FUNC_STR      "cvtqg"
  673. #define DIVF_FUNC_STR       "divf"
  674. #define DIVG_FUNC_STR       "divg"
  675. #define MULF_FUNC_STR       "mulf"
  676. #define MULG_FUNC_STR       "mulg"
  677. #define SUBF_FUNC_STR       "subf"
  678. #define SUBG_FUNC_STR       "subg"
  679. #define CVTGQ_FUNC_STR      "cvtgq"
  681. //
  682. // Define subfields within the 11 bit IEEE floating operate function field.
  683. //
  685. #define FP_FUNCTION_MASK      0x03F     // Function code including format
  687. //
  688. // Define the 2 bit format field.
  689. //
  691. #define FP_FORMAT_MASK        0x030
  692. #define FP_FORMAT_S           0x000     // Single (32 bit floating)
  693. #define FP_FORMAT_X           0x010     // Extended (128 bit floating)
  694. #define FP_FORMAT_T           0x020     // Double (64 bit floating)
  695. #define FP_FORMAT_Q           0x030     // Quad (64 bit integer)
  696. #define FP_FORMAT_SHIFT       4
  698. //
  699. // Define the 2 bit rounding mode field.
  700. //
  702. #define FP_ROUND_MASK         0x0C0
  703. #define FP_ROUND_C            0x000     // Chopped
  704. #define FP_ROUND_M            0x040     // Minus Infinity
  705. #define FP_ROUND_N            0x080     // Nearest
  706. #define FP_ROUND_D            0x0C0     // Dynamic
  707. #define FP_ROUND_SHIFT        6
  709. //
  710. // Define the 3 bit trap enable field.
  711. //
  713. #define FP_TRAP_ENABLE_MASK   0x700
  714. #define FP_TRAP_ENABLE_NONE   0x000
  715. #define FP_TRAP_ENABLE_U      0x100     // Underflow
  716. #define FP_TRAP_ENABLE_I      0x200     // Inexact
  718. #define FP_TRAP_ENABLE_S      0x400     // Software Completion
  719. #define FP_TRAP_ENABLE_SU     0x500
  720. #define FP_TRAP_ENABLE_SUI    0x700
  722. #define FP_TRAP_ENABLE_V      0x100     // Integer Overflow
  723. #define FP_TRAP_ENABLE_SV     0x500
  724. #define FP_TRAP_ENABLE_SVI    0x700
  726. #define FP_TRAP_ENABLE_SHIFT  8
  728. //
  729. // VAX and IEEE function flags (or'd with VAX and IEEE function code)
  730. //
  732. #define MSK_FP_FLAGS    0x7C0
  734. #define C_FLAGS         0x000
  735. #define M_FLAGS         0x040
  736. #define NONE_FLAGS      0x080
  737. #define D_FLAGS         0x0C0
  738. #define UC_FLAGS        0x100
  739. #define VC_FLAGS        0x100
  740. #define UM_FLAGS        0x140
  741. #define VM_FLAGS        0x140
  742. #define U_FLAGS         0x180
  743. #define V_FLAGS         0x180
  744. #define UD_FLAGS        0x1C0
  745. #define VD_FLAGS        0x1C0
  746. #define SC_FLAGS        0x400
  747. #define S_FLAGS         0x480
  748. #define SUC_FLAGS       0x500
  749. #define SVC_FLAGS       0x500
  750. #define SUM_FLAGS       0x540
  751. #define SVM_FLAGS       0x540
  752. #define SU_FLAGS        0x580
  753. #define SV_FLAGS        0x580
  754. #define SUD_FLAGS       0x5C0
  755. #define SVD_FLAGS       0x5C0
  756. #define SUIC_FLAGS      0x700
  757. #define SVIC_FLAGS      0x700
  758. #define SUIM_FLAGS      0x740
  759. #define SVIM_FLAGS      0x740
  760. #define SUI_FLAGS       0x780
  761. #define SVI_FLAGS       0x780
  762. #define SUID_FLAGS      0x7C0
  763. #define SVID_FLAGS      0x7C0
  765. #define C_FLAGS_STR       "/c"
  766. #define M_FLAGS_STR       "/m"
  767. #define NONE_FLAGS_STR    ""
  768. #define D_FLAGS_STR       "/d"
  769. #define UC_FLAGS_STR      "/uc"
  770. #define VC_FLAGS_STR      "/vc"
  771. #define UM_FLAGS_STR      "/um"
  772. #define VM_FLAGS_STR      "/vm"
  773. #define U_FLAGS_STR       "/u"
  774. #define V_FLAGS_STR       "/v"
  775. #define UD_FLAGS_STR      "/ud"
  776. #define VD_FLAGS_STR      "/vd"
  777. #define SC_FLAGS_STR      "/sc"
  778. #define S_FLAGS_STR       "/s"
  779. #define SUC_FLAGS_STR     "/suc"
  780. #define SVC_FLAGS_STR     "/svc"
  781. #define SUM_FLAGS_STR     "/sum"
  782. #define SVM_FLAGS_STR     "/svm"
  783. #define SU_FLAGS_STR      "/su"
  784. #define SV_FLAGS_STR      "/sv"
  785. #define SUD_FLAGS_STR     "/sud"
  786. #define SVD_FLAGS_STR     "/svd"
  787. #define SUIC_FLAGS_STR    "/suic"
  788. #define SVIC_FLAGS_STR    "/svic"
  789. #define SUIM_FLAGS_STR    "/suim"
  790. #define SVIM_FLAGS_STR    "/svim"
  791. #define SUI_FLAGS_STR     "/sui"
  792. #define SVI_FLAGS_STR     "/svi"
  793. #define SUID_FLAGS_STR    "/suid"
  794. #define SVID_FLAGS_STR    "/svid"
  796. //
  797. // Type (9) PALcode Instruction Format.
  798. //
  799. //  3         2 2
  800. //  1         6 5                                                 0
  801. // +-----------+---------------------------------------------------+
  802. // |   opcode  |                  PALcode func                     |
  803. // +-----------+---------------------------------------------------+
  804. //
  806. typedef struct _Alpha_PAL_Format {
  807.         ULONG Function : 26;
  808.         ULONG Opcode : 6;
  809. } Alpha_PAL_Format;
  811. //
  812. // Call to PAL function codes (in Function, Opcode 0, CALLPAL_OP).
  813. //
  814. // N.B. - if new call pal functions are added, they must also be added
  815. // in genalpha.c, genalpha.c will generate the include file for .s files
  816. // that will define the call pal mnemonics for assembly language use
  817. //
  819. #define PRIV_PAL_FUNC 0x0
  820. #define UNPRIV_PAL_FUNC 0x80
  823. //
  824. // Unprivileged call pal functions.
  825. //
  827. #define BPT_FUNC       (UNPRIV_PAL_FUNC | 0x00)
  828. #define CALLSYS_FUNC   (UNPRIV_PAL_FUNC | 0x03)
  829. #define IMB_FUNC       (UNPRIV_PAL_FUNC | 0x06)
  830. #define GENTRAP_FUNC   (UNPRIV_PAL_FUNC | 0xAA)
  831. #define RDTEB_FUNC     (UNPRIV_PAL_FUNC | 0xAB)
  832. #define KBPT_FUNC      (UNPRIV_PAL_FUNC | 0xAC)
  833. #define CALLKD_FUNC    (UNPRIV_PAL_FUNC | 0xAD)
  834. #define RDTEB64_FUNC   (UNPRIV_PAL_FUNC | 0xAE)
  836. #define BPT_FUNC_STR       "bpt"
  837. #define CALLSYS_FUNC_STR   "callsys"
  838. #define IMB_FUNC_STR       "imb"
  839. #define RDTEB_FUNC_STR     "rdteb"
  840. #define GENTRAP_FUNC_STR   "gentrap"
  841. #define KBPT_FUNC_STR      "kbpt"
  842. #define CALLKD_FUNC_STR    "callkd"
  843. #define RDTEB64_FUNC_STR   "rdteb64"
  845. //
  846. // Priveleged call pal functions.
  847. //
  849. #define HALT_FUNC       (PRIV_PAL_FUNC | 0x00)
  850. #define RESTART_FUNC    (PRIV_PAL_FUNC | 0x01)
  851. #define DRAINA_FUNC     (PRIV_PAL_FUNC | 0x02)
  852. #define REBOOT_FUNC     (PRIV_PAL_FUNC | 0x03)
  853. #define INITPAL_FUNC    (PRIV_PAL_FUNC | 0x04)
  854. #define WRENTRY_FUNC    (PRIV_PAL_FUNC | 0x05)
  855. #define SWPIRQL_FUNC    (PRIV_PAL_FUNC | 0x06)
  856. #define RDIRQL_FUNC     (PRIV_PAL_FUNC | 0x07)
  857. #define DI_FUNC         (PRIV_PAL_FUNC | 0X08)
  858. #define EI_FUNC         (PRIV_PAL_FUNC | 0x09)
  859. #define SWPPAL_FUNC     (PRIV_PAL_FUNC | 0x0A)
  860. #define SSIR_FUNC       (PRIV_PAL_FUNC | 0x0C)
  861. #define CSIR_FUNC       (PRIV_PAL_FUNC | 0x0D)
  862. #define RFE_FUNC        (PRIV_PAL_FUNC | 0x0E)
  863. #define RETSYS_FUNC     (PRIV_PAL_FUNC | 0x0F)
  864. #define SWPCTX_FUNC     (PRIV_PAL_FUNC | 0x10)
  865. #define SWPPROCESS_FUNC (PRIV_PAL_FUNC | 0x11)
  866. #define RDMCES_FUNC     (PRIV_PAL_FUNC | 0x12)
  867. #define WRMCES_FUNC     (PRIV_PAL_FUNC | 0x13)
  868. #define TBIA_FUNC       (PRIV_PAL_FUNC | 0x14)
  869. #define TBIS_FUNC       (PRIV_PAL_FUNC | 0x15)
  870. #define DTBIS_FUNC      (PRIV_PAL_FUNC | 0x16)
  871. #define TBISASN_FUNC    (PRIV_PAL_FUNC | 0x17)
  872. #define RDKSP_FUNC      (PRIV_PAL_FUNC | 0x18)
  873. #define SWPKSP_FUNC     (PRIV_PAL_FUNC | 0x19)
  874. #define RDPSR_FUNC      (PRIV_PAL_FUNC | 0x1A)
  875. #define RDPCR_FUNC      (PRIV_PAL_FUNC | 0x1C)
  876. #define RDTHREAD_FUNC   (PRIV_PAL_FUNC | 0x1E)
  877. #define TBIM_FUNC       (PRIV_PAL_FUNC | 0x20)
  878. #define TBIMASN_FUNC    (PRIV_PAL_FUNC | 0x21)
  879. #define TBIM64_FUNC     (PRIV_PAL_FUNC | 0x22)
  880. #define TBIS64_FUNC     (PRIV_PAL_FUNC | 0x23)
  881. #define EALNFIX_FUNC    (PRIV_PAL_FUNC | 0x24)
  882. #define DALNFIX_FUNC    (PRIV_PAL_FUNC | 0x25)
  883. #define RDCOUNTERS_FUNC (PRIV_PAL_FUNC | 0x30)
  884. #define RDSTATE_FUNC    (PRIV_PAL_FUNC | 0x31)
  885. #define WRPERFMON_FUNC  (PRIV_PAL_FUNC | 0x32)
  886. #define CP_SLEEP_FUNC   (PRIV_PAL_FUNC | 0x39)
  888. #define HALT_FUNC_STR       "halt"
  889. #define RESTART_FUNC_STR    "restart"
  890. #define DRAINA_FUNC_STR     "draina"
  891. #define REBOOT_FUNC_STR     "reboot"
  892. #define INITPAL_FUNC_STR    "initpal"
  893. #define WRENTRY_FUNC_STR    "wrentry"
  894. #define SWPIRQL_FUNC_STR    "swpirql"
  895. #define RDIRQL_FUNC_STR     "rdirql"
  896. #define DI_FUNC_STR         "di"
  897. #define EI_FUNC_STR         "ei"
  898. #define SWPPAL_FUNC_STR     "swppal"
  899. #define SSIR_FUNC_STR       "ssir"
  900. #define CSIR_FUNC_STR       "csir"
  901. #define RFE_FUNC_STR        "rfe"
  902. #define RETSYS_FUNC_STR     "retsys"
  903. #define SWPCTX_FUNC_STR     "swpctx"
  904. #define SWPPROCESS_FUNC_STR "swpprocess"
  905. #define RDMCES_FUNC_STR     "rdmces"
  906. #define WRMCES_FUNC_STR     "wrmces"
  907. #define TBIA_FUNC_STR       "tbia"
  908. #define TBIS_FUNC_STR       "tbis"
  909. #define DTBIS_FUNC_STR      "dtbis"
  910. #define TBISASN_FUNC_STR    "tbisasn"
  911. #define RDKSP_FUNC_STR      "rdksp"
  912. #define SWPKSP_FUNC_STR     "swpksp"
  913. #define RDPSR_FUNC_STR      "rdpsr"
  914. #define RDPCR_FUNC_STR      "rdpcr"
  915. #define RDTHREAD_FUNC_STR   "rdthread"
  916. #define TBIM_FUNC_STR       "tbim"
  917. #define TBIMASN_FUNC_STR    "tbimasn"
  918. #define TBIM64_FUNC_STR     "tbim64"
  919. #define TBIS64_FUNC_STR     "tbis64"
  920. #define EALNFIX_FUNC_STR    "ealnfix"
  921. #define DALNFIX_FUNC_STR    "dalnfix"
  922. #define RDCOUNTERS_FUNC_STR "rdcounters"
  923. #define RDSTATE_FUNC_STR    "rdstate"
  924. #define WRPERFMON_FUNC_STR  "wrperfmon"
  925. #define CP_SLEEP_FUNC_STR   "cp_sleep"
  927. //
  928. // 21064 (ev4) - specific call pal functions.
  929. //
  931. #define INITPCR_FUNC    (PRIV_PAL_FUNC | 0x38)
  933. #define INITPCR_FUNC_STR   "initpcr"
  935. //
  936. // Type (10) EV4 MTPR/MFPR PAL mode instructions.
  937. //
  938. //  3         2 2       2 2       1 1
  939. //  1         6 5       1 0       6 5             8 7 6 5 4       0
  940. // +-----------+---------+---------+---------------+-+-+-+---------+
  941. // |   opcode  |   Ra    |   Rb    |      IGN      |P|A|I|  Index  |
  942. // +-----------+---------+---------+---------------+-+-+-+---------+
  943. //
  945. typedef struct _Alpha_EV4_PR_Format {
  946.         ULONG Index : 5;
  947.         ULONG Ibox : 1;
  948.         ULONG Abox : 1;
  949.         ULONG PalTemp : 1;
  950.         ULONG IGN : 8;
  951.         ULONG Rb : 5;
  952.         ULONG Ra : 5;
  953.         ULONG Opcode : 6;
  954. } Alpha_EV4_PR_Format;
  956. //
  957. // Type (10) EV5 MTPR/MFPR PAL mode instructions.
  958. //
  959. //  3         2 2       2 2       1 1
  960. //  1         6 5       1 0       6 5                              0
  961. // +-----------+---------+---------+-------------------------------+
  962. // |   opcode  |   Ra    |   Rb    |            Index              |
  963. // +-----------+---------+---------+-------------------------------+
  964. //
  966. typedef struct _Alpha_EV5_PR_Format {
  967.         ULONG Index : 16;
  968.         ULONG Rb : 5;
  969.         ULONG Ra : 5;
  970.         ULONG Opcode : 6;
  971. } Alpha_EV5_PR_Format;
  973. #define MTPR_OP       0x1D
  974. #define MFPR_OP       0x19
  976. #define MTPR_OP_STR   "mt"
  977. #define MFPR_OP_STR   "mf"
  979. //
  980. // Type (11) EV4 special memory PAL mode access.
  981. //
  982. //  3         2 2       2 2       1 1 1 1 1 1
  983. //  1         6 5       1 0       6 5 4 3 2 1                     0
  984. // +-----------+---------+---------+-+-+-+-+-----------------------+
  985. // |   opcode  |   Ra    |   Rb    |P|A|R|Q|         Disp          |
  986. // +-----------+---------+---------+-+-+-+-+-----------------------+
  987. //
  989. typedef struct _Alpha_EV4_MEM_Format {
  990.         ULONG Disp : 12;
  991.         ULONG QuadWord : 1;
  992.         ULONG RWcheck : 1;
  993.         ULONG Alt : 1;
  994.         ULONG Physical : 1;
  995.         ULONG Rb : 5;
  996.         ULONG Ra : 5;
  997.         ULONG Opcode : 6;
  998. } Alpha_EV4_MEM_Format;
  1000. //
  1001. // Type (11) EV5 special memory PAL mode access.
  1002. //
  1003. //  3         2 2       2 2       1 1 1 1 1 1
  1004. //  1         6 5       1 0       6 5 4 3 2 1                     0
  1005. // +-----------+---------+---------+-+-+-+-+-----------------------+
  1006. // |   opcode  |   Ra    |   Rb    |P|A|R|Q|         Disp          |
  1007. // +-----------+---------+---------+-+-+-+-+-----------------------+
  1008. //
  1010. typedef struct _Alpha_EV5_MEM_Format {
  1011.         ULONG Disp : 10;
  1012.         ULONG Lock_Cond: 1;
  1013.         ULONG Vpte: 1;
  1014.         ULONG QuadWord : 1;
  1015.         ULONG RWcheck : 1;
  1016.         ULONG Alt : 1;
  1017.         ULONG Physical : 1;
  1018.         ULONG Rb : 5;
  1019.         ULONG Ra : 5;
  1020.         ULONG Opcode : 6;
  1021. } Alpha_EV5_MEM_Format;
  1023. #define HWLD_OP      0x1B
  1024. #define HWST_OP      0x1F
  1026. #define HWLD_OP_STR  "hwld"
  1027. #define HWST_OP_STR  "hwst"
  1029. // Type (12) EV4 PAL mode switch.
  1030. //
  1031. //  3         2 2       2 2       1 1 1 1
  1032. //  1         6 5       1 0       6 5 4 3                         0
  1033. // +-----------+---------+---------+-+-+---------------------------+
  1034. // |   opcode  |   Ra    |   Rb    |1|0|          IGN              |
  1035. // +-----------+---------+---------+-+-+---------------------------+
  1037. typedef struct _Alpha_EV4_REI_Format {
  1038.         ULONG IGN : 14;
  1039.         ULONG zero : 1;
  1040.         ULONG one : 1;
  1041.         ULONG Rb : 5;
  1042.         ULONG Ra : 5;
  1043.         ULONG Opcode : 6;
  1044. } Alpha_EV4_REI_Format;
  1046. // Type (12) EV5 PAL mode switch.
  1047. //
  1048. //  3         2 2       2 2       1 1 1 1
  1049. //  1         6 5       1 0       6 5 4 3                         0
  1050. // +-----------+---------+---------+-+-+---------------------------+
  1051. // |   opcode  |   Ra    |   Rb    |1|0|          IGN              |
  1052. // +-----------+---------+---------+-+-+---------------------------+
  1054. typedef struct _Alpha_EV5_REI_Format {
  1055.         ULONG IGN : 14;
  1056.         ULONG Type: 2;
  1057.         ULONG Rb : 5;
  1058.         ULONG Ra : 5;
  1059.         ULONG Opcode : 6;
  1060. } Alpha_EV5_REI_Format;
  1062. #define REI_OP    0x1E
  1064. #define REI_OP_STR  "rei"
  1066. //
  1067. //
  1068. //
  1069. typedef union _Alpha_Instruction {
  1070.         ULONG Long;
  1071.         UCHAR Byte[4];
  1073.         Alpha_Memory_Format Memory;
  1074.         Alpha_Jump_Format Jump;
  1075.         Alpha_Branch_Format Branch;
  1076.         Alpha_OpReg_Format OpReg;
  1077.         Alpha_OpLit_Format OpLit;
  1078.         Alpha_FpOp_Format FpOp;
  1079.         Alpha_PAL_Format Pal;
  1080.         Alpha_EV4_PR_Format EV4_PR;
  1081.         Alpha_EV4_MEM_Format EV4_MEM;
  1082.         Alpha_EV4_REI_Format EV4_REI;
  1083.         Alpha_EV5_PR_Format EV5_PR;
  1084.         Alpha_EV5_MEM_Format EV5_MEM;
  1085.         Alpha_EV5_REI_Format EV5_REI;
  1086. } ALPHA_INSTRUCTION, *PALPHA_INSTRUCTION;
  1088. //
  1089. // Define standard integer register assignments.
  1090. //
  1092. #define V0_REG      0       // v0 - return value register
  1094. #define T0_REG      1       // t0 - temporary register
  1095. #define T1_REG      2       // t1 - temporary register
  1096. #define T2_REG      3       // t2 - temporary register
  1097. #define T3_REG      4       // t3 - temporary register
  1098. #define T4_REG      5       // t4 - temporary register
  1099. #define T5_REG      6       // t5 - temporary register
  1100. #define T6_REG      7       // t6 - temporary register
  1101. #define T7_REG      8       // t7 - temporary register
  1103. #define S0_REG      9       // s0 - saved register
  1104. #define S1_REG      10      // s1 - saved register
  1105. #define S2_REG      11      // s2 - saved register
  1106. #define S3_REG      12      // s3 - saved register
  1107. #define S4_REG      13      // s4 - saved register
  1108. #define S5_REG      14      // s5 - saved register
  1110. #define S6_REG      15      // s6 - saved register, aka fp
  1111. #define FP_REG      15      // fp - frame pointer register
  1113. #define A0_REG      16      // a0 - argument register
  1114. #define A1_REG      17      // a1 - argument register
  1115. #define A2_REG      18      // a2 - argument register
  1116. #define A3_REG      19      // a3 - argument register
  1117. #define A4_REG      20      // a4 - argument register
  1118. #define A5_REG      21      // a5 - argument register
  1120. #define T8_REG      22      // t8 - temporary register
  1121. #define T9_REG      23      // t9 - temporary register
  1122. #define T10_REG     24      // t10 - temporary register
  1123. #define T11_REG     25      // t11 - temporary register
  1125. #define RA_REG      26      // ra - return address register
  1126. #define T12_REG     27      // t12 - temporary register
  1127. #define AT_REG      28      // at - assembler temporary register
  1128. #define GP_REG      29      // gp - global pointer register
  1129. #define SP_REG      30      // sp - stack pointer register
  1130. #define ZERO_REG    31      // zero - zero register
  1132. //
  1133. // Define standard floating point register assignments.
  1134. //
  1136. #define F0_REG      0       // floating return value register (real)
  1137. #define F1_REG      1       // floating return value register (imaginary)
  1138. #define F16_REG     16      // floating argument register
  1139. #define FZERO_REG   31      // floating zero register
  1141. //
  1142. //  Define standard integer register strings
  1143. //
  1145. #define V0_REG_STR      "v0"     // - return value register
  1147. #define T0_REG_STR      "t0"     // - temporary register
  1148. #define T1_REG_STR      "t1"     // - temporary register
  1149. #define T2_REG_STR      "t2"     // - temporary register
  1150. #define T3_REG_STR      "t3"     // - temporary register
  1151. #define T4_REG_STR      "t4"     // - temporary register
  1152. #define T5_REG_STR      "t5"     // - temporary register
  1153. #define T6_REG_STR      "t6"     // - temporary register
  1154. #define T7_REG_STR      "t7"     // - temporary register
  1156. #define S0_REG_STR      "s0"     // - saved register
  1157. #define S1_REG_STR      "s1"     // - saved register
  1158. #define S2_REG_STR      "s2"     // - saved register
  1159. #define S3_REG_STR      "s3"     // - saved register
  1160. #define S4_REG_STR      "s4"     // - saved register
  1161. #define S5_REG_STR      "s5"     // - saved register
  1163. #define S6_REG_STR      "s6"     // - saved register, aka fp
  1164. #define FP_REG_STR      "fp"     // - frame pointer register
  1166. #define A0_REG_STR      "a0"     // - argument register
  1167. #define A1_REG_STR      "a1"     // - argument register
  1168. #define A2_REG_STR      "a2"     // - argument register
  1169. #define A3_REG_STR      "a3"     // - argument register
  1170. #define A4_REG_STR      "a4"     // - argument register
  1171. #define A5_REG_STR      "a5"     // - argument register
  1173. #define T8_REG_STR      "t8"     // - temporary register
  1174. #define T9_REG_STR      "t9"     // - temporary register
  1175. #define T10_REG_STR     "t10"    // - temporary register
  1176. #define T11_REG_STR     "t11"    // - temporary register
  1178. #define RA_REG_STR      "ra"     // - return address register
  1179. #define T12_REG_STR     "t12"    // - temporary register
  1180. #define AT_REG_STR      "at"     // - assembler temporary register
  1181. #define GP_REG_STR      "gp"     // - global pointer register
  1182. #define SP_REG_STR      "sp"     // - stack pointer register
  1183. #define ZERO_REG_STR    "zero"   // - zero register
  1185. //
  1186. // Define maximum and minimum single and double exponent values.
  1187. //
  1189. #define DOUBLE_MAXIMUM_EXPONENT 2047
  1190. #define DOUBLE_MINIMUM_EXPONENT 0
  1192. #define SINGLE_MAXIMUM_EXPONENT 255
  1193. #define SINGLE_MINIMUM_EXPONENT 0
  1195. //
  1196. // Define single and double exponent bias values.
  1197. //
  1199. #define SINGLE_EXPONENT_BIAS 127
  1200. #define DOUBLE_EXPONENT_BIAS 1023
  1202. //
  1203. // Define the largest single and double values.
  1204. //
  1206. #define SINGLE_MAXIMUM_VALUE 0x7f7fffff
  1208. #define DOUBLE_MAXIMUM_VALUE_HIGH 0x7fefffff
  1209. #define DOUBLE_MAXIMUM_VALUE_LOW 0xffffffff
  1211. //
  1212. // Define single and double quiet and signaling Nan values
  1213. // (these are identical to X86 formats; Mips is different).
  1214. //
  1216. #define SINGLE_QUIET_NAN_PREFIX 0x7fc00000
  1217. #define SINGLE_SIGNAL_NAN_PREFIX 0x7f800000
  1218. #define SINGLE_QUIET_NAN_VALUE 0xffc00000
  1220. #define DOUBLE_QUIET_NAN_PREFIX_HIGH 0x7ff80000
  1221. #define DOUBLE_SIGNAL_NAN_PREFIX_HIGH 0x7ff00000
  1222. #define DOUBLE_QUIET_NAN_VALUE_HIGH 0xfff80000
  1223. #define DOUBLE_QUIET_NAN_VALUE_LOW 0x0
  1225. //
  1226. // Define positive single and double infinity values.
  1227. //
  1229. #define SINGLE_INFINITY_VALUE 0x7f800000
  1231. #define DOUBLE_INFINITY_VALUE_HIGH 0x7ff00000
  1232. #define DOUBLE_INFINITY_VALUE_LOW 0x0
  1234. //
  1235. // Quadword versions of the above.
  1236. //
  1238. #define DOUBLE_MAXIMUM_VALUE        ((ULONGLONG)0x7fefffffffffffff)
  1239. #define DOUBLE_INFINITY_VALUE       ((ULONGLONG)0x7ff0000000000000)
  1240. #define DOUBLE_QUIET_NAN_VALUE      ((ULONGLONG)0xfff8000000000000)
  1242. //
  1243. // Define result values for IEEE floating point comparison operations.
  1244. // True is 2.0 and False is 0.0.
  1245. //
  1247. #define FP_COMPARE_TRUE             ((ULONGLONG)0x4000000000000000)
  1248. #define FP_COMPARE_FALSE            ((ULONGLONG)0x0000000000000000)
  1250. //
  1251. // Define Alpha AXP rounding modes.
  1252. //
  1254. #define ROUND_TO_ZERO 0                 // round toward zero
  1255. #define ROUND_TO_MINUS_INFINITY 1       // round toward minus infinity
  1256. #define ROUND_TO_NEAREST 2              // round to nearest representable value
  1257. #define ROUND_TO_PLUS_INFINITY 3        // round toward plus infinity
  1259. #endif // _ALPHAOPS_