home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / Harvest C / Source Code / table.h < prev    next >
Encoding:
Text File  |  1992-01-02  |  9.0 KB  |  270 lines  |  [TEXT/ALFA]
  1. #
  2.  
  3. /*
  4.  * table.h --- basic definitions for the mnemonic table
  5.  * 
  6.  * Table.c is generated using a perl script.  The mnemonic table consists of a
  7.  * base mnemonic, the number of templates to match against the operand field,
  8.  * and a pointer to the list of templates.  The templates consist of the
  9.  * allowed sizes that follow the mnemonic, and up to 4 ea classes for the
  10.  * instruction.  A successful match must match the type and number of
  11.  * operands.  Some pseudo ops are different, since they have an open-ended
  12.  * number of operands (e.g. ds,dc) These are marked in the table with a first
  13.  * EA type of MULTI.
  14.  */
  15.  
  16. struct tmpl {            /* a template to match */
  17.     char                            sizes;    /* allowed sizes (bit map) */
  18.     char                            modes[4];    /* up to 4 EA fields may be
  19.                          * specified */
  20.     char                            class;    /* opcode class */
  21.     unsigned short                  op;    /* base opcode */
  22.     unsigned short                  op2;    /* second opcode (F-line,
  23.                          * etc) */
  24. };
  25.  
  26. struct mne {            /* a mnemonic */
  27.     char                           *mne_name;
  28.     Opcode_t                        OP;
  29.     char                            ntmpl;    /* number of templates to
  30.                          * test */
  31.     struct tmpl                    *ptmpl;    /* pointer to templates to
  32.                          * test */
  33. };
  34.  
  35. /* sizes */
  36. #define    B    0x01
  37. #define W    0x02
  38. #define L    0x04
  39. #define S    0x08
  40. #define D    0x10
  41. #define X    0x20
  42. #define P    0x40
  43. #define U    0x80
  44. /* composite sizes */
  45. #define    bwlu    (B|W|L|U)
  46. #define    bwlsdxp    (B|W|L|S|D|X|P)
  47. #define    wlu    (W|L|U)
  48. #define    bu    (B|U)
  49. #define wu    (W|U)
  50. #define    lu    (L|U)
  51. #define    wl    (W|L)
  52. #define xu      (X|U)
  53. #define bwlsdxpu (B|W|L|S|D|X|P|U)
  54. #define anysz    (B|W|L|S|D|X|P|U)
  55.  
  56. /* opcode classes */
  57. #define INH             0
  58. #define RXRY            1
  59. #define RXRYS           2
  60. #define RXRYR           3
  61. #define RXRYP           4
  62. #define EAREG           5
  63. #define EAREGS          6
  64. #define REGEA           7
  65. #define REGEAS          8
  66. #define IMMEAS          9
  67. #define QUKEA           10
  68. #define IMMB            11
  69. #define IMMW            12
  70. #define IMMWS           13
  71. #define IMM3            14
  72. #define IMM4            15
  73. #define RSHIFT          16
  74. #define QSHIFT          17
  75. #define EA              18
  76. #define EAREV           19
  77. #define EAS             20
  78. #define BCC             21
  79. #define BIT             22
  80. #define BITFLD          23
  81. #define BITFLD2         24
  82. #define CALLM           25
  83. #define CAS             26
  84. #define CAS2            27
  85. #define CHK             28
  86. #define CHK2            29
  87. #define DBCC            30
  88. #define MULDIV          40
  89. #define REG             41
  90. #define MOVEU           42    /* move to/from usp */
  91. #define REGIMM          43
  92. #define MOVE            44
  93. #define MOVEC           45
  94. #define MOVEQ           46
  95. #define MOVEMO          47
  96. #define MOVEMI          48
  97. #define MOVEPO          49
  98. #define MOVEPI          50
  99. #define MOVES           51
  100. #define TRAPCC          52
  101.  
  102. /* floating point classes */
  103. #define FEAREG          53
  104. #define FREGREG         54
  105. #define FMONAD          55
  106. #define FBCC            56
  107. #define FDBCC           57
  108. #define FINH            58
  109. #define FEA             59
  110. #define FSCC            60
  111. #define FEAPAIR         61
  112. #define FREGPAIR        62
  113. #define FTSTEA          63
  114. #define FTSTREG         64
  115. #define FMOVE           65
  116. #define FMOVECR         66
  117. #define FMOVEMI         67
  118. #define FMOVEMO         68
  119. #define FMOVEMCI        69
  120. #define FMOVEMCO        70
  121. #define FTRAPCC         71
  122.  
  123. /* PMMU classes */
  124. #define PINH            72
  125. #define PBCC            73
  126. #define PDBCC           74
  127. #define PFLUSH          75
  128. #define PEA             76
  129. #define PLOAD           77
  130. #define PMOVEI          78
  131. #define PMOVEO          79
  132. #define PSCC            80
  133. #define PTEST           81
  134. #define PTRAPCC         82
  135. #define PVALID          83
  136. #define PMOVEIF         84
  137.  
  138. /* generic co-processor classes */
  139. #define CPINH           85
  140. #define CPBCC           86
  141. #define CPDBCC          87
  142. #define CPGEN           88
  143. #define CPEA            89
  144. #define CPSCC           90
  145. #define CPTRAPCC        91
  146.  
  147. /* 68hc16 specific classes */
  148. #define    LPSTOP        92
  149. #define    TABEA        93
  150. #define    TABREG        94
  151.  
  152. /* pseudo op classes */
  153. #define EQU             100
  154. #define DC              101
  155. #define OPT             102
  156. #define ORG             103
  157. #define DS              104
  158. #define FEQU            105
  159. #define FOPT            106
  160. #define NULL_OP         107
  161. #define ALIGN           108
  162. #define INCLUDE         109
  163. #define RORG            110
  164. #define CODEW           111
  165.  
  166. struct ea {
  167.     char                            type;
  168.     char                            itype;    /* when INDEX or PCINDEX,
  169.                          * itype specifies sub-mode */
  170.     int                             reg;    /* An,Dn,Sp,FPn,Rc,FPc,Pn */
  171.     int                             reg2;    /* second register for reg.
  172.                          * pairs */
  173.     int                             konst;    /* #val, displacement, branch
  174.                          * dest */
  175.     int                             const2;    /* second constant (on static
  176.                          * bit field) */
  177.     char                            stat;    /* when type==FIELD, stat1==1
  178.                          * -> static */
  179.     char                            stat2;    /* when type==FIELD, stat2==1
  180.                          * -> static */
  181.     char                            br_sup;    /* supress An or PC when set */
  182.     char                            xn_sup;    /* supress Xn when set */
  183.     char                            bdsiz;    /* size and/or supress for
  184.                          * base displacement */
  185.     char                            odsiz;    /* size and/or supress for
  186.                          * outer displacement */
  187.     char                            siz;    /* size for indexed modes */
  188.     char                            scl;    /* scale for indexed modes */
  189.     char                            prepst;    /* 0=pre or mem indir, 1=post */
  190.     char                            force;    /* konst or bdsiz involved a
  191.                          * forward ref */
  192.     char                            force2;    /* const2 or odsiz involved a
  193.                          * forward ref */
  194.     SYM_t                          *MPWRef;
  195. };
  196.  
  197. /* Basic EA types */
  198. #define EMPTY   0        /* not used, must be defined as zero */
  199. #define DN      1        /* Dn */
  200. #define AN      2        /* An, SP */
  201. #define ANI     3        /* (An) */
  202. #define PSTINC  4        /* (An)+ */
  203. #define PREDEC  5        /* -(An) */
  204. #define INDEX   6        /* mode == 05n or 06n */
  205. #define EXPR    7        /* expression (labels, absolute addressing) */
  206. #define IMMED   8        /* #expression */
  207. #define PCINDEX 9        /* mode == 072 or 073 */
  208.  
  209. /* Other basic EA's, not used in general EA classes */
  210. #define DPAIR   10        /* Dn:Dn */
  211. #define RPAIR   11        /* (Rn):(Rn) */
  212. #define RLIST   12        /* e.g. A0-A3/D5/D7 */
  213. #define FIELD   13        /* {Dn/#:Dn/#} */
  214. #define CN      14        /* control reg (including USP) */
  215. #define CCR     15        /* condition code register */
  216. #define SR      16        /* status register */
  217. #define FN      17        /* FPn */
  218. #define FCN     18        /* FPCR,FPSR,FPIAR */
  219. #define FLIST   19        /* e.g. FP2-FP4/FP7 */
  220. #define FPAIR   20        /* FPm:FPn */
  221. #define FCLIST  21        /* FPCR/FPSR/FPIAR */
  222. #define DYNK    22        /* dynamic K factor {Dn} */
  223. #define STATK   23        /* static K factor {konst} */
  224. #define PN      24        /* PMMU register */
  225. #define STRING  25        /* ASCII string */
  226.  
  227. /* composite EA types. can be one or more of the basic types */
  228. #define RN      26        /* DN or AN */
  229. #define ANYEA   27        /* any EA */
  230. #define CONTROL 28        /* Control */
  231. #define ALTMEM  29        /* Alterable memory (does not include Dn) */
  232. #define DATALT  30        /* Data alterable */
  233. #define ALTER   31        /* alterable (An not allowed on byte
  234.                  * operations) */
  235. #define DATA    32        /* Data */
  236. #define CALTPR  33        /* Control Alterable, or predec */
  237. #define CTLPST  34        /* Control, or postinc */
  238. #define CTLALT  35        /* Control Alterable */
  239. #define MEMORY  36        /* Memory */
  240. #define PEA1    37        /* EXPR, DN or CN (Special for PMMU) */
  241. #define MULTI   38        /* up to EAMAX of EXPR's */
  242.  
  243. /* indexed addressing mode types (e->itype) */
  244. #define D16AN   1        /* d16 + (An) */
  245. #define BRIEF   2        /* d8 + (An) + (Xn.siz*scl) */
  246. #define FULL    3        /* full format */
  247.  
  248. /*
  249.  * For each basic EA type returned by scanea(), the remaining structure
  250.  * elements are set as follows:
  251.  * 
  252.  * Type    Sets
  253.  * 
  254.  * EMPTY   nothing DN      reg = 0-7 AN      reg = 0-7 ANI     reg = 0-7 PSTINC
  255.  * reg = 0-7 PREDEC  reg = 0-7 INDEX   see do_indexed() and/or .......() EXPR
  256.  * konst = result of expr. eval, csiz: 0=none, 1=.W, 2=.L IMMED   konst =
  257.  * immediate value PCINDEX see do_indexed() and/or .......() DPAIR   reg =
  258.  * 1st reg#, reg2 = 2nd reg# RPAIR   reg = 1st reg#, reg2 = 2nd reg#, stat1 ?
  259.  * reg is An : reg is Dn stat2 ? reg2 is An : reg2 is Dn RLIST   reg = bit
  260.  * map of registers, A7=msb, D0=lsb FIELD   reg = 1st reg, reg2 = 2nd reg,
  261.  * konst = 1st constant, const2 = 2nd constant, stat1 ? 1st is STATIC : 1st
  262.  * is Dynamic, stat2 ? 2nd is STATIC : 2nd is Dynamic CN      reg = control
  263.  * reg# as per movec encoding CCR     nothing SR      nothing FN      reg =
  264.  * 0-7 FCN     reg = Fp control reg# as per fmovec encoding FLIST   reg = bit
  265.  * map of FP regs, FP7=msb, FP0=lsb FPAIR   reg = 1st fp reg, reg2 = 2nd fp
  266.  * reg FCLIST  reg = bit map as per fmovem encoding DYNK    reg = 0-7 STATK
  267.  * konst = expression PN      reg = reg# as per second word on PMOVE STRING
  268.  * konst = ptr to character string
  269.  */
  270.