alpha/ngen.h

   1 /* alpha/ngen.h ****************************************************************
   2
   3         Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
   4
   5         See file COPYRIGHT for information on usage and disclaimer of warranties
   6
   7         Contains the machine dependent code generator definitions and macros for an
   8         Alpha processor.
   9
  10         Authors: Andreas  Krall      EMAIL: cacao@complang.tuwien.ac.at
  11                  Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
  12
  13         Last Change: 1998/11/04
  14
  15 *******************************************************************************/
  16
  17 /* see also file calling.doc for explanation of calling conventions           */
  18
  19 /* preallocated registers *****************************************************/
  20
  21 /* integer registers */
  22
  23 #define REG_RESULT      0    /* to deliver method results                     */
  24
  25 #define REG_RA          26   /* return address                                */
  26 #define REG_PV          27   /* procedure vector, must be provided by caller  */
  27 #define REG_METHODPTR   28   /* pointer to the place from where the procedure */
  28                              /* vector has been fetched                       */
  29 #define REG_ITMP1       25   /* temporary register                            */
  30 #define REG_ITMP2       28   /* temporary register and method pointer         */
  31 #define REG_ITMP3       29   /* temporary register                            */
  32
  33 #define REG_ITMP1_XPTR  25   /* exception pointer = temporary register 1      */
  34 #define REG_ITMP2_XPC   28   /* exception pc = temporary register 2           */
  35
  36 #define REG_SP          30   /* stack pointer                                 */
  37 #define REG_ZERO        31   /* allways zero                                  */
  38
  39 /* floating point registers */
  40
  41 #define REG_FRESULT     0    /* to deliver floating point method results      */
  42 #define REG_FTMP1       28   /* temporary floating point register             */
  43 #define REG_FTMP2       29   /* temporary floating point register             */
  44 #define REG_FTMP3       30   /* temporary floating point register             */
  45
  46 #define REG_IFTMP       28   /* temporary integer and floating point register */
  47
  48 /* register descripton - array ************************************************/
  49
  50 /* #define REG_RES   0         reserved register for OS or code generator     */
  51 /* #define REG_RET   1         return value register                          */
  52 /* #define REG_EXC   2         exception value register (only old jit)        */
  53 /* #define REG_SAV   3         (callee) saved register                        */
  54 /* #define REG_TMP   4         scratch temporary register (caller saved)      */
  55 /* #define REG_ARG   5         argument register (caller saved)               */
  56
  57 /* #define REG_END   -1        last entry in tables */
  58
  59 int nregdescint[] = {
  60         REG_RET, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
  61         REG_TMP, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
  62         REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP,
  63         REG_TMP, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES,
  64         REG_END };
  65
  66 #define INT_SAV_CNT      7   /* number of int callee saved registers          */
  67 #define INT_ARG_CNT      6   /* number of int argument registers              */
  68
  69 /* for use of reserved registers, see comment above */
  70
  71 int nregdescfloat[] = {
  72         REG_RET, REG_TMP, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
  73         REG_SAV, REG_SAV, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
  74         REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP,
  75         REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_RES, REG_RES, REG_RES, REG_RES,
  76         REG_END };
  77
  78 #define FLT_SAV_CNT      8   /* number of flt callee saved registers          */
  79 #define FLT_ARG_CNT      6   /* number of flt argument registers              */
  80
  81 /* for use of reserved registers, see comment above */
  82
  83
  84 /* parameter allocation mode */
  85
  86 int nreg_parammode = PARAMMODE_NUMBERED;
  87
  88    /* parameter-registers will be allocated by assigning the
  89       1. parameter:   int/float-reg 16
  90       2. parameter:   int/float-reg 17
  91       3. parameter:   int/float-reg 18 ....
  92    */
  93
  94
  95 /* stackframe-infos ***********************************************************/
  96
  97 int parentargs_base; /* offset in stackframe for the parameter from the caller*/
  98
  99 /* -> see file 'calling.doc' */
 100
 101
 102 /* macros to create code ******************************************************/
 103
 104 #define REG   0
 105 #define CONST 1
 106
 107 /* 3-address-operations: M_OP3
 108       op ..... opcode
 109       fu ..... function-number
 110       a  ..... register number source 1
 111       b  ..... register number or constant integer source 2
 112       c  ..... register number destination
 113       const .. switch to use b as constant integer
 114                  (REG means: use b as register number)
 115                  (CONST means: use b as constant 8-bit-integer)
 116 */
 117 #define M_OP3(op,fu,a,b,c,const) \
 118         *(mcodeptr++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<(16-3*(const)))| \
 119         ((const)<<12)|((fu)<<5)|((c)) )
 120
 121 /* 3-address-floating-point-operation: M_FOP3
 122      op .... opcode
 123      fu .... function-number
 124      a,b ... source floating-point registers
 125      c ..... destination register
 126 */
 127 #define M_FOP3(op,fu,a,b,c) \
 128         *(mcodeptr++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<16)|((fu)<<5)|(c) )
 129
 130 /* branch instructions: M_BRA
 131       op ..... opcode
 132       a ...... register to be tested
 133       disp ... relative address to be jumped to (divided by 4)
 134 */
 135 #define M_BRA(op,a,disp) \
 136         *(mcodeptr++) = ( (((s4)(op))<<26)|((a)<<21)|((disp)&0x1fffff) )
 137
 138
 139 /* memory operations: M_MEM
 140       op ..... opcode
 141       a ...... source/target register for memory access
 142       b ...... base register
 143       disp ... displacement (16 bit signed) to be added to b
 144 */
 145 #define M_MEM(op,a,b,disp) \
 146         *(mcodeptr++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<16)|((disp)&0xffff) )
 147
 148
 149 /* macros for all used commands (see an Alpha-manual for description) *********/
 150
 151 #define M_LDA(a,b,disp)         M_MEM (0x08,a,b,disp)           /* low const  */
 152 #define M_LDAH(a,b,disp)        M_MEM (0x09,a,b,disp)           /* high const */
 153 #define M_BLDU(a,b,disp)        M_MEM (0x0a,a,b,disp)           /*  8 load    */
 154 #define M_SLDU(a,b,disp)        M_MEM (0x0c,a,b,disp)           /* 16 load    */
 155 #define M_ILD(a,b,disp)         M_MEM (0x28,a,b,disp)           /* 32 load    */
 156 #define M_LLD(a,b,disp)         M_MEM (0x29,a,b,disp)           /* 64 load    */
 157 #define M_ALD(a,b,disp)         M_MEM (0x29,a,b,disp)           /* addr load  */
 158 #define M_BST(a,b,disp)         M_MEM (0x0e,a,b,disp)           /*  8 store   */
 159 #define M_SST(a,b,disp)         M_MEM (0x0d,a,b,disp)           /* 16 store   */
 160 #define M_IST(a,b,disp)         M_MEM (0x2c,a,b,disp)           /* 32 store   */
 161 #define M_LST(a,b,disp)         M_MEM (0x2d,a,b,disp)           /* 64 store   */
 162 #define M_AST(a,b,disp)         M_MEM (0x2d,a,b,disp)           /* addr store */
 163
 164 #define M_BSEXT(b,c)            M_OP3 (0x1c,0x0,REG_ZERO,b,c,0) /*  8 signext */
 165 #define M_SSEXT(b,c)            M_OP3 (0x1c,0x1,REG_ZERO,b,c,0) /* 16 signext */
 166
 167 #define M_BR(disp)              M_BRA (0x30,REG_ZERO,disp)      /* branch     */
 168 #define M_BSR(ra,disp)          M_BRA (0x34,ra,disp)            /* branch sbr */
 169 #define M_BEQZ(a,disp)          M_BRA (0x39,a,disp)             /* br a == 0  */
 170 #define M_BLTZ(a,disp)          M_BRA (0x3a,a,disp)             /* br a <  0  */
 171 #define M_BLEZ(a,disp)          M_BRA (0x3b,a,disp)             /* br a <= 0  */
 172 #define M_BNEZ(a,disp)          M_BRA (0x3d,a,disp)             /* br a != 0  */
 173 #define M_BGEZ(a,disp)          M_BRA (0x3e,a,disp)             /* br a >= 0  */
 174 #define M_BGTZ(a,disp)          M_BRA (0x3f,a,disp)             /* br a >  0  */
 175
 176 #define M_JMP(a,b)              M_MEM (0x1a,a,b,0x0000)         /* jump       */
 177 #define M_JSR(a,b)              M_MEM (0x1a,a,b,0x4000)         /* call sbr   */
 178 #define M_RET(a,b)              M_MEM (0x1a,a,b,0x8000)         /* return     */
 179
 180 #define M_IADD(a,b,c)           M_OP3 (0x10,0x0,  a,b,c,0)      /* 32 add     */
 181 #define M_LADD(a,b,c)           M_OP3 (0x10,0x20, a,b,c,0)      /* 64 add     */
 182 #define M_ISUB(a,b,c)           M_OP3 (0x10,0x09, a,b,c,0)      /* 32 sub     */
 183 #define M_LSUB(a,b,c)           M_OP3 (0x10,0x29, a,b,c,0)      /* 64 sub     */
 184 #define M_IMUL(a,b,c)           M_OP3 (0x13,0x00, a,b,c,0)      /* 32 mul     */
 185 #define M_LMUL(a,b,c)           M_OP3 (0x13,0x20, a,b,c,0)      /* 64 mul     */
 186
 187 #define M_IADD_IMM(a,b,c)       M_OP3 (0x10,0x0,  a,b,c,1)      /* 32 add     */
 188 #define M_LADD_IMM(a,b,c)       M_OP3 (0x10,0x20, a,b,c,1)      /* 64 add     */
 189 #define M_ISUB_IMM(a,b,c)       M_OP3 (0x10,0x09, a,b,c,1)      /* 32 sub     */
 190 #define M_LSUB_IMM(a,b,c)       M_OP3 (0x10,0x29, a,b,c,1)      /* 64 sub     */
 191 #define M_IMUL_IMM(a,b,c)       M_OP3 (0x13,0x00, a,b,c,1)      /* 32 mul     */
 192 #define M_LMUL_IMM(a,b,c)       M_OP3 (0x13,0x20, a,b,c,1)      /* 64 mul     */
 193
 194 #define M_CMPEQ(a,b,c)          M_OP3 (0x10,0x2d, a,b,c,0)      /* c = a == b */
 195 #define M_CMPLT(a,b,c)          M_OP3 (0x10,0x4d, a,b,c,0)      /* c = a <  b */
 196 #define M_CMPLE(a,b,c)          M_OP3 (0x10,0x6d, a,b,c,0)      /* c = a <= b */
 197
 198 #define M_CMPULE(a,b,c)         M_OP3 (0x10,0x3d, a,b,c,0)      /* c = a <= b */
 199 #define M_CMPULT(a,b,c)         M_OP3 (0x10,0x1d, a,b,c,0)      /* c = a <= b */
 200
 201 #define M_CMPEQ_IMM(a,b,c)      M_OP3 (0x10,0x2d, a,b,c,1)      /* c = a == b */
 202 #define M_CMPLT_IMM(a,b,c)      M_OP3 (0x10,0x4d, a,b,c,1)      /* c = a <  b */
 203 #define M_CMPLE_IMM(a,b,c)      M_OP3 (0x10,0x6d, a,b,c,1)      /* c = a <= b */
 204
 205 #define M_CMPULE_IMM(a,b,c)     M_OP3 (0x10,0x3d, a,b,c,1)      /* c = a <= b */
 206 #define M_CMPULT_IMM(a,b,c)     M_OP3 (0x10,0x1d, a,b,c,1)      /* c = a <= b */
 207
 208 #define M_AND(a,b,c)            M_OP3 (0x11,0x00, a,b,c,0)      /* c = a &  b */
 209 #define M_OR( a,b,c)            M_OP3 (0x11,0x20, a,b,c,0)      /* c = a |  b */
 210 #define M_XOR(a,b,c)            M_OP3 (0x11,0x40, a,b,c,0)      /* c = a ^  b */
 211
 212 #define M_AND_IMM(a,b,c)        M_OP3 (0x11,0x00, a,b,c,1)      /* c = a &  b */
 213 #define M_OR_IMM( a,b,c)        M_OP3 (0x11,0x20, a,b,c,1)      /* c = a |  b */
 214 #define M_XOR_IMM(a,b,c)        M_OP3 (0x11,0x40, a,b,c,1)      /* c = a ^  b */
 215
 216 #define M_MOV(a,c)              M_OR (a,a,c)                    /* c = a      */
 217 #define M_CLR(c)                M_OR (31,31,c)                  /* c = 0      */
 218 #define M_NOP                   M_OR (31,31,31)                 /* ;          */
 219
 220 #define M_SLL(a,b,c)            M_OP3 (0x12,0x39, a,b,c,0)      /* c = a << b */
 221 #define M_SRA(a,b,c)            M_OP3 (0x12,0x3c, a,b,c,0)      /* c = a >> b */
 222 #define M_SRL(a,b,c)            M_OP3 (0x12,0x34, a,b,c,0)      /* c = a >>>b */
 223
 224 #define M_SLL_IMM(a,b,c)        M_OP3 (0x12,0x39, a,b,c,1)      /* c = a << b */
 225 #define M_SRA_IMM(a,b,c)        M_OP3 (0x12,0x3c, a,b,c,1)      /* c = a >> b */
 226 #define M_SRL_IMM(a,b,c)        M_OP3 (0x12,0x34, a,b,c,1)      /* c = a >>>b */
 227
 228 #define M_FLD(a,b,disp)         M_MEM (0x22,a,b,disp)           /* load flt   */
 229 #define M_DLD(a,b,disp)         M_MEM (0x23,a,b,disp)           /* load dbl   */
 230 #define M_FST(a,b,disp)         M_MEM (0x26,a,b,disp)           /* store flt  */
 231 #define M_DST(a,b,disp)         M_MEM (0x27,a,b,disp)           /* store dbl  */
 232
 233 #define M_FADD(a,b,c)           M_FOP3 (0x16, 0x080, a,b,c)     /* flt add    */
 234 #define M_DADD(a,b,c)           M_FOP3 (0x16, 0x0a0, a,b,c)     /* dbl add    */
 235 #define M_FSUB(a,b,c)           M_FOP3 (0x16, 0x081, a,b,c)     /* flt sub    */
 236 #define M_DSUB(a,b,c)           M_FOP3 (0x16, 0x0a1, a,b,c)     /* dbl sub    */
 237 #define M_FMUL(a,b,c)           M_FOP3 (0x16, 0x082, a,b,c)     /* flt mul    */
 238 #define M_DMUL(a,b,c)           M_FOP3 (0x16, 0x0a2, a,b,c)     /* dbl mul    */
 239 #define M_FDIV(a,b,c)           M_FOP3 (0x16, 0x083, a,b,c)     /* flt div    */
 240 #define M_DDIV(a,b,c)           M_FOP3 (0x16, 0x0a3, a,b,c)     /* dbl div    */
 241
 242 #define M_FADDS(a,b,c)          M_FOP3 (0x16, 0x580, a,b,c)     /* flt add    */
 243 #define M_DADDS(a,b,c)          M_FOP3 (0x16, 0x5a0, a,b,c)     /* dbl add    */
 244 #define M_FSUBS(a,b,c)          M_FOP3 (0x16, 0x581, a,b,c)     /* flt sub    */
 245 #define M_DSUBS(a,b,c)          M_FOP3 (0x16, 0x5a1, a,b,c)     /* dbl sub    */
 246 #define M_FMULS(a,b,c)          M_FOP3 (0x16, 0x582, a,b,c)     /* flt mul    */
 247 #define M_DMULS(a,b,c)          M_FOP3 (0x16, 0x5a2, a,b,c)     /* dbl mul    */
 248 #define M_FDIVS(a,b,c)          M_FOP3 (0x16, 0x583, a,b,c)     /* flt div    */
 249 #define M_DDIVS(a,b,c)          M_FOP3 (0x16, 0x5a3, a,b,c)     /* dbl div    */
 250
 251 #define M_CVTDF(b,c)            M_FOP3 (0x16, 0x0ac, 31,b,c)    /* dbl2long   */
 252 #define M_CVTLF(b,c)            M_FOP3 (0x16, 0x0bc, 31,b,c)    /* long2flt   */
 253 #define M_CVTLD(b,c)            M_FOP3 (0x16, 0x0be, 31,b,c)    /* long2dbl   */
 254 #define M_CVTDL(b,c)            M_FOP3 (0x16, 0x1af, 31,b,c)    /* dbl2long   */
 255 #define M_CVTDL_C(b,c)          M_FOP3 (0x16, 0x12f, 31,b,c)    /* dbl2long   */
 256 #define M_CVTLI(b,c)            M_FOP3 (0x17, 0x130, 31,b,c)    /* long2int   */
 257
 258 #define M_CVTDFS(b,c)           M_FOP3 (0x16, 0x5ac, 31,b,c)    /* dbl2long   */
 259 #define M_CVTDLS(b,c)           M_FOP3 (0x16, 0x5af, 31,b,c)    /* dbl2long   */
 260 #define M_CVTDL_CS(b,c)         M_FOP3 (0x16, 0x52f, 31,b,c)    /* dbl2long   */
 261 #define M_CVTLIS(b,c)           M_FOP3 (0x17, 0x530, 31,b,c)    /* long2int   */
 262
 263 #define M_FCMPEQ(a,b,c)         M_FOP3 (0x16, 0x0a5, a,b,c)     /* c = a==b   */
 264 #define M_FCMPLT(a,b,c)         M_FOP3 (0x16, 0x0a6, a,b,c)     /* c = a<b    */
 265
 266 #define M_FCMPEQS(a,b,c)        M_FOP3 (0x16, 0x5a5, a,b,c)     /* c = a==b   */
 267 #define M_FCMPLTS(a,b,c)        M_FOP3 (0x16, 0x5a6, a,b,c)     /* c = a<b    */
 268
 269 #define M_FMOV(fa,fb)           M_FOP3 (0x17, 0x020, fa,fa,fb)  /* b = a      */
 270 #define M_FMOVN(fa,fb)          M_FOP3 (0x17, 0x021, fa,fa,fb)  /* b = -a     */
 271
 272 #define M_FNOP                  M_FMOV (31,31)
 273
 274 #define M_FBEQZ(fa,disp)        M_BRA (0x31,fa,disp)            /* br a == 0.0*/
 275
 276 /* macros for special commands (see an Alpha-manual for description) **********/
 277
 278 #define M_TRAPB                 M_MEM (0x18,0,0,0x0000)        /* trap barrier*/
 279
 280 #define M_S4ADDL(a,b,c)         M_OP3 (0x10,0x02, a,b,c,0)     /* c = a*4 + b */
 281 #define M_S4ADDQ(a,b,c)         M_OP3 (0x10,0x22, a,b,c,0)     /* c = a*4 + b */
 282 #define M_S4SUBL(a,b,c)         M_OP3 (0x10,0x0b, a,b,c,0)     /* c = a*4 - b */
 283 #define M_S4SUBQ(a,b,c)         M_OP3 (0x10,0x2b, a,b,c,0)     /* c = a*4 - b */
 284 #define M_S8ADDL(a,b,c)         M_OP3 (0x10,0x12, a,b,c,0)     /* c = a*8 + b */
 285 #define M_S8ADDQ(a,b,c)         M_OP3 (0x10,0x32, a,b,c,0)     /* c = a*8 + b */
 286 #define M_S8SUBL(a,b,c)         M_OP3 (0x10,0x1b, a,b,c,0)     /* c = a*8 - b */
 287 #define M_S8SUBQ(a,b,c)         M_OP3 (0x10,0x3b, a,b,c,0)     /* c = a*8 - b */
 288 #define M_SAADDQ(a,b,c)         M_S8ADDQ(a,b,c)                /* c = a*8 + b */
 289
 290 #define M_S4ADDL_IMM(a,b,c)     M_OP3 (0x10,0x02, a,b,c,1)     /* c = a*4 + b */
 291 #define M_S4ADDQ_IMM(a,b,c)     M_OP3 (0x10,0x22, a,b,c,1)     /* c = a*4 + b */
 292 #define M_S4SUBL_IMM(a,b,c)     M_OP3 (0x10,0x0b, a,b,c,1)     /* c = a*4 - b */
 293 #define M_S4SUBQ_IMM(a,b,c)     M_OP3 (0x10,0x2b, a,b,c,1)     /* c = a*4 - b */
 294 #define M_S8ADDL_IMM(a,b,c)     M_OP3 (0x10,0x12, a,b,c,1)     /* c = a*8 + b */
 295 #define M_S8ADDQ_IMM(a,b,c)     M_OP3 (0x10,0x32, a,b,c,1)     /* c = a*8 + b */
 296 #define M_S8SUBL_IMM(a,b,c)     M_OP3 (0x10,0x1b, a,b,c,1)     /* c = a*8 - b */
 297 #define M_S8SUBQ_IMM(a,b,c)     M_OP3 (0x10,0x3b, a,b,c,1)     /* c = a*8 - b */
 298
 299 #define M_LLD_U(a,b,disp)       M_MEM (0x0b,a,b,disp)          /* unalign ld  */
 300 #define M_LST_U(a,b,disp)       M_MEM (0x0f,a,b,disp)          /* unalign st  */
 301
 302 #define M_ZAP(a,b,c)            M_OP3 (0x12,0x30, a,b,c,0)
 303 #define M_ZAPNOT(a,b,c)         M_OP3 (0x12,0x31, a,b,c,0)
 304
 305 #define M_ZAP_IMM(a,b,c)        M_OP3 (0x12,0x30, a,b,c,1)
 306 #define M_ZAPNOT_IMM(a,b,c)     M_OP3 (0x12,0x31, a,b,c,1)
 307
 308 #define M_BZEXT(a,b)            M_ZAPNOT_IMM(a, 0x01, b)       /*  8 zeroext  */
 309 #define M_CZEXT(a,b)            M_ZAPNOT_IMM(a, 0x03, b)       /* 16 zeroext  */
 310 #define M_IZEXT(a,b)            M_ZAPNOT_IMM(a, 0x0f, b)       /* 32 zeroext  */
 311
 312 #define M_EXTBL(a,b,c)          M_OP3 (0x12,0x06, a,b,c,0)
 313 #define M_EXTWL(a,b,c)          M_OP3 (0x12,0x16, a,b,c,0)
 314 #define M_EXTLL(a,b,c)          M_OP3 (0x12,0x26, a,b,c,0)
 315 #define M_EXTQL(a,b,c)          M_OP3 (0x12,0x36, a,b,c,0)
 316 #define M_EXTWH(a,b,c)          M_OP3 (0x12,0x5a, a,b,c,0)
 317 #define M_EXTLH(a,b,c)          M_OP3 (0x12,0x6a, a,b,c,0)
 318 #define M_EXTQH(a,b,c)          M_OP3 (0x12,0x7a, a,b,c,0)
 319 #define M_INSBL(a,b,c)          M_OP3 (0x12,0x0b, a,b,c,0)
 320 #define M_INSWL(a,b,c)          M_OP3 (0x12,0x1b, a,b,c,0)
 321 #define M_INSLL(a,b,c)          M_OP3 (0x12,0x2b, a,b,c,0)
 322 #define M_INSQL(a,b,c)          M_OP3 (0x12,0x3b, a,b,c,0)
 323 #define M_INSWH(a,b,c)          M_OP3 (0x12,0x57, a,b,c,0)
 324 #define M_INSLH(a,b,c)          M_OP3 (0x12,0x67, a,b,c,0)
 325 #define M_INSQH(a,b,c)          M_OP3 (0x12,0x77, a,b,c,0)
 326 #define M_MSKBL(a,b,c)          M_OP3 (0x12,0x02, a,b,c,0)
 327 #define M_MSKWL(a,b,c)          M_OP3 (0x12,0x12, a,b,c,0)
 328 #define M_MSKLL(a,b,c)          M_OP3 (0x12,0x22, a,b,c,0)
 329 #define M_MSKQL(a,b,c)          M_OP3 (0x12,0x32, a,b,c,0)
 330 #define M_MSKWH(a,b,c)          M_OP3 (0x12,0x52, a,b,c,0)
 331 #define M_MSKLH(a,b,c)          M_OP3 (0x12,0x62, a,b,c,0)
 332 #define M_MSKQH(a,b,c)          M_OP3 (0x12,0x72, a,b,c,0)
 333
 334 #define M_EXTBL_IMM(a,b,c)      M_OP3 (0x12,0x06, a,b,c,1)
 335 #define M_EXTWL_IMM(a,b,c)      M_OP3 (0x12,0x16, a,b,c,1)
 336 #define M_EXTLL_IMM(a,b,c)      M_OP3 (0x12,0x26, a,b,c,1)
 337 #define M_EXTQL_IMM(a,b,c)      M_OP3 (0x12,0x36, a,b,c,1)
 338 #define M_EXTWH_IMM(a,b,c)      M_OP3 (0x12,0x5a, a,b,c,1)
 339 #define M_EXTLH_IMM(a,b,c)      M_OP3 (0x12,0x6a, a,b,c,1)
 340 #define M_EXTQH_IMM(a,b,c)      M_OP3 (0x12,0x7a, a,b,c,1)
 341 #define M_INSBL_IMM(a,b,c)      M_OP3 (0x12,0x0b, a,b,c,1)
 342 #define M_INSWL_IMM(a,b,c)      M_OP3 (0x12,0x1b, a,b,c,1)
 343 #define M_INSLL_IMM(a,b,c)      M_OP3 (0x12,0x2b, a,b,c,1)
 344 #define M_INSQL_IMM(a,b,c)      M_OP3 (0x12,0x3b, a,b,c,1)
 345 #define M_INSWH_IMM(a,b,c)      M_OP3 (0x12,0x57, a,b,c,1)
 346 #define M_INSLH_IMM(a,b,c)      M_OP3 (0x12,0x67, a,b,c,1)
 347 #define M_INSQH_IMM(a,b,c)      M_OP3 (0x12,0x77, a,b,c,1)
 348 #define M_MSKBL_IMM(a,b,c)      M_OP3 (0x12,0x02, a,b,c,1)
 349 #define M_MSKWL_IMM(a,b,c)      M_OP3 (0x12,0x12, a,b,c,1)
 350 #define M_MSKLL_IMM(a,b,c)      M_OP3 (0x12,0x22, a,b,c,1)
 351 #define M_MSKQL_IMM(a,b,c)      M_OP3 (0x12,0x32, a,b,c,1)
 352 #define M_MSKWH_IMM(a,b,c)      M_OP3 (0x12,0x52, a,b,c,1)
 353 #define M_MSKLH_IMM(a,b,c)      M_OP3 (0x12,0x62, a,b,c,1)
 354 #define M_MSKQH_IMM(a,b,c)      M_OP3 (0x12,0x72, a,b,c,1)
 355
 356 #define M_UMULH(a,b,c)          M_OP3 (0x13,0x30, a,b,c,0)     /* 64 umulh    */
 357
 358 #define M_UMULH_IMM(a,b,c)      M_OP3 (0x13,0x30, a,b,c,1)     /* 64 umulh    */
 359
 360 #define M_CMOVEQ(a,b,c)         M_OP3 (0x11,0x24, a,b,c,0)     /* a==0 ? c=b  */
 361 #define M_CMOVNE(a,b,c)         M_OP3 (0x11,0x26, a,b,c,0)     /* a!=0 ? c=b  */
 362 #define M_CMOVLT(a,b,c)         M_OP3 (0x11,0x44, a,b,c,0)     /* a< 0 ? c=b  */
 363 #define M_CMOVGE(a,b,c)         M_OP3 (0x11,0x46, a,b,c,0)     /* a>=0 ? c=b  */
 364 #define M_CMOVLE(a,b,c)         M_OP3 (0x11,0x64, a,b,c,0)     /* a<=0 ? c=b  */
 365 #define M_CMOVGT(a,b,c)         M_OP3 (0x11,0x66, a,b,c,0)     /* a> 0 ? c=b  */
 366
 367 #define M_CMOVEQ_IMM(a,b,c)     M_OP3 (0x11,0x24, a,b,c,1)     /* a==0 ? c=b  */
 368 #define M_CMOVNE_IMM(a,b,c)     M_OP3 (0x11,0x26, a,b,c,1)     /* a!=0 ? c=b  */
 369 #define M_CMOVLT_IMM(a,b,c)     M_OP3 (0x11,0x44, a,b,c,1)     /* a< 0 ? c=b  */
 370 #define M_CMOVGE_IMM(a,b,c)     M_OP3 (0x11,0x46, a,b,c,1)     /* a>=0 ? c=b  */
 371 #define M_CMOVLE_IMM(a,b,c)     M_OP3 (0x11,0x64, a,b,c,1)     /* a<=0 ? c=b  */
 372 #define M_CMOVGT_IMM(a,b,c)     M_OP3 (0x11,0x66, a,b,c,1)     /* a> 0 ? c=b  */
 373
 374 /* macros for unused commands (see an Alpha-manual for description) ***********/
 375
 376 #define M_ANDNOT(a,b,c,const)   M_OP3 (0x11,0x08, a,b,c,const) /* c = a &~ b  */
 377 #define M_ORNOT(a,b,c,const)    M_OP3 (0x11,0x28, a,b,c,const) /* c = a |~ b  */
 378 #define M_XORNOT(a,b,c,const)   M_OP3 (0x11,0x48, a,b,c,const) /* c = a ^~ b  */
 379
 380 #define M_CMPBGE(a,b,c,const)   M_OP3 (0x10,0x0f, a,b,c,const)
 381
 382 #define M_FCMPUN(a,b,c)         M_FOP3 (0x16, 0x0a4, a,b,c)    /* unordered   */
 383 #define M_FCMPLE(a,b,c)         M_FOP3 (0x16, 0x0a7, a,b,c)    /* c = a<=b    */
 384
 385 #define M_FCMPUNS(a,b,c)        M_FOP3 (0x16, 0x5a4, a,b,c)    /* unordered   */
 386 #define M_FCMPLES(a,b,c)        M_FOP3 (0x16, 0x5a7, a,b,c)    /* c = a<=b    */
 387
 388 #define M_FBNEZ(fa,disp)        M_BRA (0x35,fa,disp)
 389 #define M_FBLEZ(fa,disp)        M_BRA (0x33,fa,disp)
 390
 391 #define M_JMP_CO(a,b)           M_MEM (0x1a,a,b,0xc000)        /* call cosub  */
 392
 393
 394 /* function gen_resolvebranch **************************************************
 395
 396         backpatches a branch instruction; Alpha branch instructions are very
 397         regular, so it is only necessary to overwrite some fixed bits in the
 398         instruction.
 399
 400         parameters: ip ... pointer to instruction after branch (void*)
 401                     so ... offset of instruction after branch  (s4)
 402                     to ... offset of branch target             (s4)
 403
 404 *******************************************************************************/
 405
 406 #define gen_resolvebranch(ip,so,to) ((s4*)(ip))[-1]|=((s4)(to)-(so))>>2&0x1fffff
 407
 408 #define SOFTNULLPTRCHECK       /* soft null pointer check supportet as option */