src/vm/jit/s390/codegen.h

   1 /* src/vm/jit/s390/codegen.h - code generation macros for s390
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: codegen.h 8123 2007-06-20 23:50:55Z michi $
  26
  27 */
  28
  29
  30 #ifndef _CODEGEN_H
  31 #define _CODEGEN_H
  32
  33 #include "config.h"
  34
  35 #include <ucontext.h>
  36
  37 #include "vm/types.h"
  38
  39 #include "vm/jit/jit.h"
  40
  41
  42 /* MCODECHECK(icnt) */
  43
  44 #define MCODECHECK(icnt) \
  45     do { \
  46         if ((cd->mcodeptr + (icnt)) > cd->mcodeend) \
  47             codegen_increase(cd); \
  48     } while (0)
  49
  50 #define ALIGNCODENOP \
  51     if ((s4) (((ptrint) cd->mcodeptr) & 7)) { \
  52         M_NOP; \
  53     }
  54
  55 /* some patcher defines *******************************************************/
  56
  57 #define PATCHER_CALL_SIZE    4          /* size in bytes of a patcher call    */
  58
  59 #define PATCHER_NOPS \
  60     do { \
  61                 /* do not generate additonal nops for long patcher branches */ \
  62                 if (! CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) { \
  63                 M_NOP; \
  64                         M_NOP; \
  65                         M_NOP; \
  66                 } \
  67     } while (0)
  68
  69 #define PATCHER_LONGBRANCHES_NOPS \
  70         do { \
  71                 M_BR(SZ_BRC + (10 * 2)); \
  72                 M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; /* ild */ \
  73                 M_NOP2; /* aadd */ \
  74                 M_NOP2; /* jmp */ \
  75         } while (0)
  76
  77 #define PATCHER_NOPS_SKIP   12
  78 #define PATCHER_LONGBRANCHES_NOPS_SKIP 24
  79
  80 /* branch defines ************************************************************/
  81
  82 #define BRANCH_NOPS \
  83         do { \
  84                 if (CODEGENDATA_HAS_FLAG_LONGBRANCHES(cd)) { \
  85                         M_NOP2; M_NOP2; /* brc */ \
  86                         M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; M_NOP2; /* ild */ \
  87                         M_NOP2; /* ar, bcr */ \
  88                 } else { \
  89                         M_NOP; /* brc */ \
  90                 } \
  91         } while (0)
  92
  93 /* stub defines **************************************************************/
  94
  95 #define COMPILERSTUB_CODESIZE    (SZ_AHI + SZ_L + SZ_L + SZ_BCR)
  96
  97 /* *** BIG TODO ***
  98  * Make all this inline functions !!!!!!!!!!
  99  */
 100
 101 /* macros to create code ******************************************************/
 102
 103 /* Conventions:
 104  * N_foo:   defines the instrucition foo as in `ESA/390 Principles of operations'
 105  * SZ_foo:  defines the size of the instruction N_foo
 106  * DD_foo:  defines a condition code as used by s390 GCC
 107  * M_foo:   defines the alpha like instruction used in cacao
 108  *          the instruction is defined by an equivalent N_ instruction
 109  * CC_foo:  defines a condition code as used
 110  *          the instruction is defined as an equivalent DD_ condition code
 111  */
 112
 113 /* S390 specific code */
 114
 115 /* Argument checks for debug mode */
 116
 117 /* Some instructions with register arguments treat %r0 as "value not given".
 118  * To prevent bugs, in debug mode we use a special value RN (reg none) with
 119  * the meaning "value not given".
 120  * In debug mode, the instructions assert that %r0 was not given as argument.
 121  */
 122
 123 #if 1
 124 #       include <stdlib.h>
 125         /* register none */
 126 #       define RN 16
 127         /* Optional register.
 128          * Check that value given is %r1 - %r15 or RN
 129          */
 130 #       define _WITH_LINE(f, ...) f(__FILE__, __LINE__, __VA_ARGS__)
 131         static inline int _OR_IMPL(const char *file, int line, int r) {
 132                 if(!(
 133                         ((0 < r) && (r < 16)) ||
 134                         (r == RN)
 135                 )) {
 136                         fprintf(stdout, "%d is not a valid register at %s:%d.\n", r, file, line);
 137                         abort();
 138                 }
 139                 return ((r == RN) ? 0 : r);
 140         }
 141 #       define _OR(r) _WITH_LINE(_OR_IMPL, r)
 142
 143 #       define _SMIN(b) (-(1 << (bits - 1)))
 144 #       define _SMAX(b) ((1 << (b - 1)) - 1)
 145 #       define _UMIN(b) 0
 146 #       define _UMAX(b) ((1 << b) - 1)
 147
 148         static inline int _UBITS_IMPL(const char *file, int line, int i, int bits) {
 149                 if (!((_UMIN(bits) <= i) && (i <= _UMAX(bits)))) {
 150                         fprintf(stdout, "%d (0x%X) is not an unsigned %d bit integer at %s:%d.\n", i, i, bits, file, line);
 151                         abort();
 152                 }
 153                 return i;
 154         }
 155 #       define _UBITS(i, bits) _WITH_LINE(_UBITS_IMPL, i, bits)
 156         static inline int _SBITS_IMPL(const char *file, int line, int i, int bits) {
 157                 if(!((_SMIN(bits) <= i) && (i <= _SMAX(bits)))) {
 158                         fprintf(stdout, "%d (0x%X) is not an signed %d bit integer at %s:%d.\n", i, i, bits, file, line);
 159                         abort();
 160                 }
 161                 return i;
 162         }
 163 #       define _SBITS(i, bits) _WITH_LINE(_SBITS_IMPL, i, bits)
 164         static inline int _BITS_IMPL(const char *file, int line, int i, int bits) {
 165                 if (!(
 166                         ((_UMIN(bits) <= i) && (i <= _UMAX(bits))) ||
 167                         ((_SMIN(bits) <= i) && (i <= _SMAX(bits)))
 168                 )) {
 169                         fprintf(stdout, "%d (0x%X) is not an %d bit integer at %s:%d.\n", i, i, bits, file, line);
 170                         abort();
 171                 }
 172                 return i;
 173         }
 174 #       define _BITS(i, bits) _WITH_LINE(_BITS_IMPL, i, bits)
 175 #else
 176 #       define RN 0
 177 #       define _OR(x) (x)
 178 #       define _BITS(x, b) (x)
 179 #       define _UBITS(x, b) (x)
 180 #       define _SBITS(x, b) (x)
 181 #endif
 182
 183 /* Register */
 184 #define _R(x) _UBITS((x), 4)
 185 /* Displacement */
 186 #define _D(x) _UBITS((x), 12)
 187 /* 4 bit Immediate */
 188 #define _I4(x) _BITS((x), 4)
 189 #define _UI4(x) _UBITS((x), 4)
 190 #define _SI4(x) _SBITS((x), 4)
 191 /* 8 bit Immediate */
 192 #define _I8(x) _BITS((x), 8)
 193 #define _UI8(x) _UBITS((x), 8)
 194 #define _SI8(x) _SBITS((x), 8)
 195 /* 12 bit Immediate */
 196 #define _I12(x) _BITS((x), 12)
 197 #define _UI12(x) _UBITS((x), 12)
 198 #define _SI12(x) _SBITS((x), 12)
 199 /* 16 bit Immediate */
 200 #define _I16(x) _BITS((x), 16)
 201 #define _UI16(x) _UBITS((x), 16)
 202 #define _SI16(x) _SBITS((x), 16)
 203 /* Opcode */
 204 #define _OP(x) _UBITS((x), 8)
 205 /* Second part of opcode */
 206 #define _OP4(x) _UBITS((x), 4)
 207 /* Extended opcode */
 208 #define _OP16(x) _UBITS((x), 16)
 209
 210 /* Instruction formats */
 211
 212 #define _CODE(t, code) \
 213         do { \
 214                 *((t *) cd->mcodeptr) = (code); \
 215                 cd->mcodeptr += sizeof(t); \
 216         } while (0)
 217
 218 #define _CODE2(code) _CODE(u2, code)
 219 #define _CODE4(code) _CODE(u4, code)
 220
 221 #define _IF(cond, t, f) \
 222         do { if (cond) { t ; } else { f ; } } while (0)
 223
 224 #define _IFNEG(val, neg, pos) _IF((val) < 0, neg, pos)
 225
 226 #define N_RR(op, r1, r2) \
 227         _CODE2( (_OP(op) << 8) | (_R(r1) << 4) | _R(r2) )
 228
 229 #define SZ_RR 2
 230
 231 #define N_RR2(op, i) \
 232         _CODE2( (_OP(op) << 8) | _I8(i) )
 233
 234 #define N_RX(op, r1, d2, x2, b2) \
 235         _CODE4( (_OP(op) << 24) | (_R(r1) << 20) | (_OR(x2) << 16) | (_OR(b2) << 12) | (_D(d2) << 0) )
 236
 237 #define SZ_RX 4
 238
 239 #define N_RI(op1, op2, r1, i2) \
 240         _CODE4( (_OP(op1) << 24) | (_R(r1) << 20) | (_OP4(op2) << 16) | (u2)_SI16(i2) )
 241
 242 #define N_RI2(op1, op2, r1, i2) \
 243         _CODE4( (_OP(op1) << 24) | (_R(r1) << 20) | (_OP4(op2) << 16) | (u2)_UI16(i2) )
 244
 245 #define SZ_RI 4
 246
 247 #define N_SI(op, d1, b1, i2) \
 248         _CODE4( (_OP(op) << 24) | (_OR(i2) << 16) | (_OR(b1) << 12) | _D(d1) )
 249
 250 #define SZ_SI 4
 251
 252 #define N_SS(op, d1, l, b1, d2, b2) \
 253         do { \
 254                 _CODE4( (_OP(op) << 24) | (_I8(l) << 16) | (_OR(b1) << 12) | _D(d1) ); \
 255                 _CODE2( (_OR(b2) << 12) | _D(d2) ); \
 256         } while (0)
 257
 258 #define SZ_SS 6
 259
 260 #define N_SS2(op, d1, l1, b1, d2, l2, b2) \
 261         N_SS(op, d1, (_I4(l1) << 4) | _I4(l2), b1, d2, l2)
 262
 263 #define N_RS(op, r1, r3, d2, b2) \
 264         _CODE4( (_OP(op) << 24) | (_R(r1) << 20) | (_R(r3) << 16) | (_OR(b2) << 12) | _D(d2) )
 265
 266 #define SZ_RS 4
 267
 268 #define N_RSI(op, r1, r2, i2) \
 269         _CODE4( ((op) << 24) | (_R(r1) << 20) | (_R(r3) << 16) | (u2)_16(i2) )
 270
 271 #define SZ_RSI 4
 272
 273 #define N_RRE(op, r1, r2) \
 274         _CODE4( (_OP16(op) << 16) | (_R(r1) << 4) | _R(r2) )
 275
 276 #define SZ_RRE 4
 277
 278 #define N_S2(d2, b2) \
 279         _CODE4( (_OP16(op) << 16) | (_OR(b2) << 12) | _D(d2)  )
 280
 281 #define SZ_S2 4
 282
 283 #define N_E(op) \
 284         _CODE2( _OP16(op) )
 285
 286 #define SZ_E 2
 287
 288 #define N_RXE(op, r1, d2, x2, b2) \
 289         do { \
 290                 _CODE4( ((_OP16(op) >> 8) << 24) | (_R(r1) << 20) | \
 291                         (_R(x2) << 16) | (_R(b2) << 12) | _UI12(d2) ); \
 292                 _CODE2( _OP16(op) & 0xFF ); \
 293         } while (0)
 294
 295 #define S_RXE 6
 296
 297 #define N_RRF(op, r1, m3, r2) \
 298         _CODE4( (_OP16(op) << 16) | (_R(m3) << 12) | (_R(r1) << 4) | _R(r2) )
 299
 300 #define S_RRF 4
 301
 302 #define N_IMM_MIN -32768
 303 #define N_IMM_MAX 32767
 304 #define N_VALID_IMM(x) ((N_IMM_MIN <= (x)) && ((x) <= N_IMM_MAX))
 305 #define ASSERT_VALID_IMM(x) assert(N_VALID_IMM(x))
 306
 307 #define N_DISP_MIN 0
 308 #define N_DISP_MAX 0xFFF
 309 #define N_VALID_DISP(x) ((N_DISP_MIN <= (x)) && ((x) <= N_DISP_MAX))
 310 #define ASSERT_VALID_DISP(x) assert(N_VALID_DISP(x))
 311
 312 #define N_PV_OFFSET (-0xFFC)
 313 #define N_DSEG_DISP(x) ((x) - N_PV_OFFSET)
 314 #define N_VALID_DSEG_DISP(x) N_VALID_DISP(N_DSEG_DISP(x))
 315
 316 #define N_BRANCH_MIN -32768
 317 #define N_BRANCH_MAX 32767
 318 #define N_VALID_BRANCH(x) ((N_BRANCH_MIN <= (x)) && ((x) <= N_BRANCH_MAX))
 319 #define ASSERT_VALID_BRANCH(x) assert(N_VALID_BRANCH(x))
 320
 321 /* Condition codes */
 322
 323 #define DD_O 1
 324 #define DD_H 2
 325 #define DD_NLE 3
 326 #define DD_L 4
 327 #define DD_NHE 5
 328 #define DD_LH 6
 329 #define DD_NE 7
 330 #define DD_E 8
 331 #define DD_NLH 9
 332 #define DD_HE 10
 333 #define DD_NL 11
 334 #define DD_LE 12
 335 #define DD_NH 13
 336 #define DD_NO 14
 337 #define DD_ANY 15
 338
 339 #define DD_0 8
 340 #define DD_1 4
 341 #define DD_2 2
 342 #define DD_3 1
 343
 344 /* Misc */
 345
 346 /* Trap instruction.
 347  * If most significant bits of first opcode byte are 00, then
 348  * format is RR (1 byte opcode) or E (2 bytes opcode).
 349  * There seems to be no opcode 0x02 or 0x02**, so we'll define
 350  * our trap instruction as:
 351  * +--------+--------+
 352  * |  0x02  |  data  |
 353  * +--------+--------+
 354  * 0                 15
 355  */
 356 #define N_ILL(data) _CODE2(0x0200 | _UBITS(data, 8))
 357 #define SZ_ILL 2
 358
 359 #define N_LONG(l) _CODE4(l)
 360 #define SZ_LONG 4
 361
 362 /* Chapter 7. General instructions */
 363
 364 #define N_AR(r1, r2) N_RR(0x1A, r1, r2)
 365 #define N_A(r1, d2, x2, b2) N_RX(0x5A, r1, d2, x2, b2)
 366 #define N_AH(r1, d2, x2, b2) N_RX(0x4A, r1, d2, x2, b2)
 367 #define N_AHI(r1, i2) N_RI(0xA7, 0xA, r1, i2)
 368 #       define SZ_AHI SZ_RI
 369 #define N_ALR(r1, r2) N_RR(0x1E, r1, r2)
 370 #define N_AL(r1, d2, x2, b2) N_RX(0x5E, r1, d2, x2, b2)
 371 #define N_NR(r1, r2) N_RR(0x14, r1, r2)
 372 #       define SZ_NR SZ_RR
 373 #define N_N(r1, d2, x2, b2) N_RX(0x54, r1, d2, x2, b2)
 374 #define N_NI(d1, b1, i2) N_SI(0x94, d1, b1, i2)
 375 #define N_NC(d1, l, b1, d2, b2) N_SS(0xD4, (l - 1), b1, d1, b2, d2)
 376 #define N_BALR(r1, r2) N_RR(0x05, r1, _OR(r2))
 377 #define N_BAL(r1, d2, x2, b2) N_RX(0x45, r1, d2, x2, b2)
 378 #define N_BASR(r1, r2) N_RR(0x0D, r1, _OR(r2))
 379 #       define SZ_BASR SZ_RR
 380 #define N_BAS(r1, d2, x2, b2) N_RX(0x4D, r1, d2, x2, b2)
 381 #define N_BASSM(r1, r2) N_RR(0x0C, r1, _OR(r2))
 382 #define N_BSM(r1, r2) N_RR(0x0B, r1, _OR(r2))
 383 #define N_BCR(m1, r2) N_RR(0x07, m1, _OR(r2))
 384 #       define SZ_BCR SZ_RR
 385 #       define N_BR(r2) N_BCR(DD_ANY, r2)
 386 #define N_BC(m1, d2, x2, b2) N_RX(0x47, m1, d2, x2, b2)
 387 #       define SZ_BC SZ_RS
 388 #define N_BCTR(r1, r2) N_RR(0x06, r1, _OR(r2))
 389 #define N_BCT(r1, d2, x2, b2) N_RX(0x46, r1, d2, x2, b2)
 390 #define N_BHX(r1, r2, d2, b2) N_RS(0xB6, r1, r3, d2, b2)
 391 #define N_BXLE(r1, r3, d2, b2) N_RS(0xB7, r1, r3, d2, b2)
 392 #define N_BRAS(r1, i2) N_RI(0xA7, 0x5, r1, (i2) / 2)
 393 #       define SZ_BRAS SZ_RI
 394 #define N_BRC(m1, i2) N_RI(0xA7, 0x4, m1, (i2) / 2)
 395 #       define N_J(i2) N_BRC(DD_ANY, i2)
 396 #       define SZ_BRC SZ_RI
 397 #       define SZ_J SZ_RI
 398 #       define N_BRC_BACK_PATCH(brc_pos) \
 399                 do { \
 400                         *(u4 *)(brc_pos) |= (u4)(cd->mcodeptr - (brc_pos)) / 2; \
 401                 } while (0)
 402 #define N_BRCT(r1, i2) N_RI(0xA7, 0x6, r1, (i2) / 2)
 403 #define N_BRXH(r1, r3, i2) N_RSI(0x84, r1, r3, (i2) / 2)
 404 #define N_BRXLE(r1, r3, i2) N_RSI(0x85, r1, r2, (i2) / 2)
 405 #define N_CKSM(r1, r2) N_RRE(0xB241, r1, r2)
 406 #define N_CR(r1, r2) N_RR(0x19, r1, r2)
 407 #       define SZ_CR SZ_RR
 408 #define N_C(r1, d2, x2, b2) N_RX(0x59, r1, d2, x2, b2)
 409 #define N_CFC(d2, b2) N_S2(0xB21A, d2, b2)
 410 #define N_CS(r1, r3, d2, b2) N_RS(0xBA, r1, r3, d2, b2)
 411 #define N_CDS(r1, r3, d2, b2) N_RS(0xBB, r1, r3, d2, b2)
 412 #define N_CH(r1, d2, x2, b2) N_CH(0x49, r1, d2, x2, b2)
 413 #define N_CHI(r1, i2) N_RI(0xA7, 0xE, r1, i2)
 414 #define N_CLR(r1, r2) N_RR(0x15, r1, r2)
 415 #define N_CL(r1, d2, x2, b2) N_RX(0x55, r1, d2, x2, b2)
 416 #define N_CLI(d1, b1, i2) N_SI(0x95, d1, b1, i2)
 417 #define N_CLC(d1, l, b1, d2, b2) N_SS(0xD5, d1, (l - 1), b1, d2, b2)
 418 #define N_CLM(r1, m3, d2, b2) N_RS(0xBD, r1, m3, d2, b2)
 419 #define N_CLCL(r1, r2) N_RR(0x0F, r1, r2)
 420 #define N_CLCLE(r1, r3, d2, b2) N_RS(0xA9, r1, r3, d2, b2)
 421 #define N_CLST(r1, r2) N_RRE(0xB25D, r1, r2)
 422 #define N_CUSE(r1, r2) N_RRE(0xB257, r1, r2)
 423 #define N_CVB(r1, d2, x2, b2) N_RX(0x4F, r1, r2, x2, b2)
 424 #define N_CVD(r1, d2, x2, b2) N_RX(0x4E, r1, d2, x2, b2)
 425 #define N_CUUTF(r1, r2) N_RRE(0xB2A6, r1, r2)
 426 #define N_CUTFU(r1, r2) N_RRE(0xB2A7, r1, r2)
 427 #define N_CPYA(r1, r2) N_RRE(0xB240, r1, r2)
 428 #define N_DR(r1, r2) N_RR(0x1D, r1, r2)
 429 #define N_D(r1, d2, x2, b2) N_RX(0x5D, r1, d2, x2, b2)
 430 #define N_XR(r1, r2) N_RR(0x17, r1, r2)
 431 #define N_X(r1, d2, x2, b2) N_RX(0x57, r1, d2, x2, b2)
 432 #define N_XI(d1, b1, i2) N_SI(0x97, d1, b1, i2)
 433 #define N_XC(d1, l, b1, d2, b2) N_SS(0xD7, d1, (l - 1), b1, d2, b2)
 434 #define N_EX(r1, d2, x2, b2) N_RX(0x44, r1, d2, x2, b2)
 435 #define N_EAR(r1, r2) N_RRE(0xB24F, r1, r2)
 436 #define N_IC(r1, d2, x2, b2) N_RX(0x43, r1, d2, x2, b2)
 437 #define N_ICM(r1, m3, d2, b2) N_RS(0xBF, r1, m3, d2, b2)
 438 #define N_IPM(r1) N_RRE(0xB222, r1, 0)
 439 #define N_LR(r1, r2) N_RR(0x18, r1, r2)
 440 #define N_L(r1, d2, x2, b2) N_RX(0x58, r1, d2, x2, b2)
 441 #       define SZ_L SZ_RX
 442 #define N_LAM(r1, r3, d2, b2) N_RS(0x9A, r1, r3, d2, b2)
 443 #define N_LA(r1, d2, x2, b2) N_RX(0x41, r1, d2, x2, b2)
 444 #define N_LAE(r1, d2, x2, b2) N_RX(0x51, r1, d2, x2, b2)
 445 #define N_LTR(r1, r2) N_RR(0x12, r1, r2)
 446 #define N_LCR(r1, r2) N_RR(0x13, r1, r2)
 447 #       define SZ_LCR SZ_RR
 448 #define N_LH(r1, d2, x2, b2) N_RX(0x48, r1, d2, x2, b2)
 449 #define N_LHI(r1, i2) N_RI(0xA7, 0x8, r1, i2)
 450 #       define SZ_LHI SZ_RI
 451 #define N_LM(r1, r3, d2, b2) N_RS(0x98, r1, r3, d2, b2)
 452 #define N_LNR(r1, r2) N_RR(0x11, r1, r2)
 453 #define N_LPR(r1, r2) N_RR(0x10, r1, r2)
 454 #define N_MC(d1, b1, i2) N_SI(0xAF, d1, b1, i2)
 455 #define N_MVI(d1, b1, i2) N_SI(0x92, d1, b1, i2)
 456 #define N_MVC(d1, l, b1, d2, b2) N_SS(0xD2, d1, (l - 1), b1, d2, b2)
 457 #define N_MVCIN(d1, l, b1, d2, b2) N_SS(0xEB, d1, (l - 1), b1, d2, b2)
 458 #define N_MVCL(r1, r2) N_RR(0x0E, r1, r2)
 459 #define N_MVCLE(r1, r3, d2, b2)  N_RS(0xAB, r1, r3, d2, b2)
 460 #define N_MVN(d1, l, b1, d2, b2) N_SS(0xD1, d1, (l - 1), b1, d2, b2)
 461 #define N_MVPG(r1, r2) N_RRE(0xB254, r1, r2)
 462 #define N_MVST(r1, r2) N_RRE(0xB255, r1, r2)
 463 #define N_MVO(d1, l1, b1, d2, l2, b2) N_SS2(0xF1, d1, (l1 - 1), b1, d2, (l2 - 1), b2)
 464 #define N_MVZ(d1, l, b1, d2, b2) N_SS(0xD3, d1, (l - 1), b1, d2, b2)
 465 #define N_MR(r1, r2) N_RR(0x1C, r1, r2)
 466 #define N_M(r1, d2, x2, b2) N_RX(0x5C, r1, d2, x2, b2)
 467 #define N_MH(r1, d2, x2, b2) N_RX(0x4C, r1, d2, x2, b2)
 468 #define N_MHI(r1, i2) N_RI(0xA7, 0xC, r1, i2)
 469 #define N_MSR(r1, r2) N_RRE(0xB252, r1, r2)
 470 #define N_MS(r1, d2, x2, b2) N_RX(0x71, r1, d2, x2, b2)
 471 #define N_OR(r1, r2) N_RR(0x16, r1, r2)
 472 #define N_O(r1, d2, x2, b2) N_RX(0x56, r1, d2, x2, b2)
 473 #define N_OI(d1, b1, i2) N_SI(0x96, d1, b1, i2)
 474 #define N_OC(d1, l, b1, d2, b2) N_SS(0xD6, d1, (l - 1), b1, d2, b2)
 475 #define N_PACK(d1, l1, b1, d2, l2, b2) N_SS2(0xF2, d1, (l1 - 1), b1, d2, (l2 - 1), b2)
 476 #define N_PLO(r1, d2, b2, r3, d4, b4) N_SS2(0xEE, d2, r1, b2, d4, r3, b4)
 477 #define N_SRST(r1, r2) N_RRE(0xB25E, r1, r2)
 478 #define N_SAR(r1, r2) N_RRE(0xB24E, r1, r2)
 479 #define N_SPM(r1) N_RR(0x04, r1, 0x00)
 480 #define N_SLDA(r1, d2, b2) N_RS(0x8F, r1, 0x00, d2, b2)
 481 #define N_SLDL(r1, d2, b2) N_RS(0x8D, r1, 0x00, d2, b2)
 482 #define N_SLA(r1, d2, b2) N_RS(0x8B, r1, 0x00, d2, b2)
 483 #define N_SLL(r1, d2, b2) N_RS(0x89, r1, 0x00, d2, b2)
 484 #define N_SRDA(r1, d2, b2) N_RS(0x8E, r1, 0x00, d2, b2)
 485 #define N_SRDL(r1, d2, b2) N_RS(0x8C, r1, 0x00, d2, b2)
 486 #define N_SRA(r1, d2, b2) N_RS(0x8A, r1, 0x00, d2, b2)
 487 #define N_SRL(r1, d2, b2) N_RS(0x88, r1, 0x00, d2, b2)
 488 #define N_ST(r1, d2, x2, b2) N_RX(0x50, r1, d2, x2, b2)
 489 #define N_STAM(r1, r3, d2, b2) N_RS(0x9B, r1, r3, d2, b2)
 490 #define N_STC(r1, d2, x2, b2) N_RX(0x42, r1, d2, x2, b2)
 491 #define N_STCM(r1, m3, d2, b2) N_RS(0xBE, r1, m3, d2, b2)
 492 #define N_STCK(d2, b2) N_S2(0xB205, d2, b2)
 493 #define N_STCKE(d2, b2) N_S2(0xB278, d2, b2)
 494 #define N_STH(r1, d2, x2, b2) N_RX(0x40, r1, d2, x2, b2)
 495 #define N_STM(r1, r3, d2, b2) N_RS(0x90, r1, r3, d2, b2)
 496 #define N_SR(r1, r2) N_RR(0x1B, r1, r2)
 497 #define N_S(r1, d2, x2, b2) N_RX(0x5B, r1, d2, x2, b2)
 498 #define N_SH(r1, d2, x2, b2) N_RX(0x4B, r1, d2, x2, b2)
 499 #define N_SLR(r1, r2) N_RR(0x1F, r1, r2)
 500 #define N_SL(r1, d2, x2, b2) N_RX(0x5F, r1, d2, x2, b2)
 501 #define N_SVC(i) N_RR2(0x0A, i)
 502 #define N_TS(d2, b2) N_S2(0x93, d2, b2)
 503 #define N_TM(d1, b1, i2) N_SI(0x91, d1, b1, i2)
 504 #define N_TMH(r1, i2) N_RI2(0xA7, 0x00, r1, i2)
 505 #define N_TML(r1, i2) N_RI2(0xA7, 0x01, r1, i2)
 506 #define N_TR(d1, l, b1, d2, b2) N_SS(0xDC, d1, (l - 1), b1, d2, b2)
 507 #define N_TRT(d1, l, b1, d2, b2) N_SS(0xDD, d1, (l - 1), b1, d2, b2)
 508 #define N_TRE(r1, r2) N_RRE(0xB2A5, r1, r2)
 509 #define N_UNPK(d1, l1, b1, d2, l2, b2) N_SS2(0xF3, d1, (l1 - 1), b1, d2, (l2 - 2), b2)
 510 #define N_UPT() N_E(0x0102)
 511
 512 /* Chapter 9. Floating point instructions */
 513
 514 #define N_LER(r1, r2) N_RR(0x38, r1, r2)
 515 #define N_LDR(r1, r2) N_RR(0x28, r1, r2)
 516 #define N_LXR(r1, r2) N_RRE(0xB365, r1, r2)
 517 #define N_LE(r1, d2, x2, b2) N_RX(0x78, r1, d2, x2, b2)
 518 #define N_LD(r1, d2, x2, b2) N_RX(0x68, r1, d2, x2, b2)
 519 #define N_LZER(r1) N_RRE(0xB374, r1, 0x0)
 520 #define N_LZDR(r1) N_RRE(0xB375, r1, 0x0)
 521 #define N_LZXR(r1) N_RRE(0xB376, r1, 0x0)
 522 #define N_STE(r1, d2, x2, b2) N_RX(0x70, r1, d2, x2, b2)
 523 #define N_STD(r1, d2, x2, b2) N_RX(0x60, r1, d2, x2, b2)
 524
 525 /* chapter 19. Binary floating point instructions */
 526
 527 #define N_AEBR(r1, r2) N_RRE(0xB30A, r1, r2)
 528 #define N_ADBR(r1, r2) N_RRE(0xB31A, r1, r2)
 529 #define N_AXBR(r1, r2) N_RRE(0xB34A, r1, r2)
 530 #define N_AEB(r1, d2, x2, b2) N_RXE(0xED0A, r1, d2, x2, b2)
 531 #define N_ADB(r1, d2, x2, b2) N_RXE(0xED1A, r1, d2, x2, b2)
 532
 533 #define N_CEBR(r1, r2) N_RRE(0xB309, r1, r2)
 534 #define N_CDBR(r1, r2) N_RRE(0xB319, r1, r2)
 535 #define N_CXBR(r1, r2) N_RRE(0xB349, r1, r2)
 536 #define N_CEB(r1, d2, x2, b2) N_RXE(0xED09, r1, d2, x2, b2)
 537 #define N_CDB(r1, d2, x2, b2) N_RXE(0xED19, r1, d2, x2, b2)
 538
 539 #define N_CEFBR(r1, r2) N_RRE(0xB394, r1, r2)
 540 #define N_CDFBR(r1, r2) N_RRE(0xB395, r1, r2)
 541 #define N_CXFBR(r1, r2) N_RRE(0xB396, r1, r2)
 542
 543 #define N_CFEBR(r1, m3, r2) N_RRF(0xB398, r1, m3, r2)
 544 #define N_CFDBR(r1, m3, r2) N_RRF(0xB399, r1, m3, r2)
 545 #define N_CFXBR(r1, m3, r2) N_RRF(0xB39A, r1, m3, r2)
 546
 547 #define N_DEBR(r1, r2) N_RRE(0xB30D, r1, r2)
 548 #define N_DDBR(r1, r2) N_RRE(0xB31D, r1, r2)
 549 #define N_DXBR(r1, r2) N_RRE(0xB34D, r1, r2)
 550 #define N_DEB(r1, d2, x2, b2) N_RXE(0xED0D, r1, d2, x2, b2)
 551 #define N_DDB(r1, d2, x2, b2) N_RXE(0xED1D, r1, d2, x2, b2)
 552
 553 #define N_LCEBR(r1, r2) N_RRE(0xB303, r1, r2)
 554 #define N_LCDBR(r1, r2) N_RRE(0xB313, r1, r2)
 555 #define N_LCXBR(r1, r2) N_RRE(0xB343, r1, r2)
 556
 557 #define N_LDEBR(r1, r2) N_RRE(0xB304, r1, r2)
 558 #       define SZ_LDEBR SZ_RRE
 559 #define N_LXDBR(r1, r2) N_RRE(0xB305, r1, r2)
 560 #define N_LXEBR(r1, r2) N_RRE(0xB306, r1, r2)
 561
 562 #define N_LEDBR(r1, r2) N_RRE(0xB344, r1, r2)
 563 #define N_LDXBR(r1, r2) N_RRE(0xB345, r1, r2)
 564 #define N_LEXBR(r1, r2) N_RRE(0xB346, r1, r2)
 565
 566 #define N_LTEBR(r1, r2) N_RRE(0xB302, r1, r2)
 567 #define N_LTDBR(r1, r2) N_RRE(0xB312, r1, r2)
 568 #define N_LTXBR(r1, r2) N_RRE(0xB342, r1, r2)
 569
 570 #define N_MEEBR(r1, r2) N_RRE(0xB317, r1, r2)
 571 #define N_MDBR(r1, r2) N_RRE(0xB31C, r1, r2)
 572 #define N_MXBR(r1, r2) N_RRE(0xB34C, r1, r2)
 573 #define N_MDEBR(r1, r2) N_RRE(0xB30C, r1, r2)
 574 #define N_MXDBR(r1, r2) N_RRE(0xB307, r1, r2)
 575
 576 #define N_SEBR(r1, r2) N_RRE(0xB30B, r1, r2)
 577 #define N_SDBR(r1, r2) N_RRE(0xB31B, r1, r2)
 578 #define N_SXBR(r1, r2) N_RRE(0xB34B, r1, r2)
 579 #define N_SEB(r1, d2, x2, b2) N_RXE(0xED0B, r1, d2, x2, b2)
 580 #define N_SDB(r1, d2, x2, b2) N_RXE(0xED1B, r1, d2, x2, b2)
 581
 582 /* Alpha like instructions */
 583
 584 #define M_CALL(r2) N_BASR(R14, r2)
 585 #define M_ILL(data) N_ILL(data)
 586 #define M_ILL2(data1, data2) N_ILL((_UBITS(data1, 4) << 4) | _UBITS(data2, 4))
 587 #define M_LONG(l) N_LONG(l)
 588
 589 #define M_ILD(r, b, d) \
 590         do { \
 591                 if (N_VALID_DISP(d)) { \
 592                         N_L(r, d, RN, b); \
 593                 } else if ((r == R0) && N_VALID_IMM(d)) { \
 594                         N_LR(R0, R1); \
 595                         N_LHI(R1, d); \
 596                         N_L(R1, 0, R1, b); \
 597                         N_XR(R1, R0); \
 598                         N_XR(R0, R1); \
 599                         N_XR(R1, R0); \
 600                 } else if ((r != R0) && N_VALID_IMM(d)) { \
 601                         N_LHI(r, d); N_L(r, 0, r, b); \
 602                 } else { \
 603                         N_BRAS(r, SZ_BRAS + SZ_LONG); \
 604                         N_LONG(d); \
 605                         N_L(r, 0, RN, r); \
 606                         N_L(r, 0, r, b); \
 607                 } \
 608         } while (0)
 609
 610 #define M_ILD_DSEG(r, d) M_ILD(r, REG_PV, N_DSEG_DISP(d))
 611
 612 #define M_ALD(r, b, d) M_ILD(r, b, d)
 613 #define M_ALD_DSEG(r, d) M_ALD(r, REG_PV, N_DSEG_DISP(d))
 614
 615 #define M_LDA(r, b, d) \
 616         do { \
 617                 if (N_VALID_DISP(d)) { \
 618                         N_LA(r, d, RN, b); \
 619                 } else if (N_VALID_IMM(d)) { \
 620                         N_LHI(r, d); \
 621                         N_LA(r, 0, r, b); \
 622                 } else { \
 623                         N_BRAS(r, SZ_BRAS + SZ_LONG); \
 624                         N_LONG(d); \
 625                         N_L(r, 0, RN, r); \
 626                         N_LA(r, 0, r, b); \
 627                 } \
 628         } while (0)
 629 #define M_LDA_DSEG(r, d) M_LDA(r, REG_PV, N_DSEG_DISP(d))
 630
 631 #define M_FLD(r, b, d) N_LE(r, d, RN, b)
 632 #define M_FLDN(r, b, d, t) _IFNEG( \
 633         d, \
 634         N_LHI(t, d); N_LE(r, 0, t, b), \
 635         N_LE(r, d, RN, b) \
 636 )
 637 #define M_FLD_DSEG(r, d, t) M_FLDN(r, REG_PV, N_DSEG_DISP(d), t)
 638
 639 #define M_DLD(r, b, d) N_LD(r, d, RN, b)
 640 #define M_DLDN(r, b, d, t) _IFNEG( \
 641         d, \
 642         N_LHI(t, d); N_LD(r, 0, t, b), \
 643         N_LD(r, d, RN, b) \
 644 )
 645 #define M_DLD_DSEG(r, d, t) M_DLDN(r, REG_PV, N_DSEG_DISP(d), t)
 646
 647 #define M_LLD(r, b, d) _IFNEG( \
 648         d, \
 649         N_LHI(GET_LOW_REG(r), d); \
 650                 N_L(GET_HIGH_REG(r), 0, GET_LOW_REG(r), b); \
 651                 N_L(GET_LOW_REG(r), 4, GET_LOW_REG(r), b), \
 652         N_L(GET_HIGH_REG(r), (d) + 0, RN, b); N_L(GET_LOW_REG(r), (d) + 4, RN, b) \
 653 )
 654 #define M_LLD_DSEG(r, d) M_LLD(r, REG_PV, N_DSEG_DISP(d)
 655
 656 /* MOV(a, b) -> mov from A to B */
 657
 658 #define M_MOV(a, b) N_LR(b, a)
 659 #define M_FMOV(a, b) N_LDR(b, a)
 660 #define M_DST(r, b, d) _IFNEG(d, assert(0), N_STD(r, d, RN, b))
 661 #define M_FST(r, b, d) _IFNEG(d, assert(0), N_STE(r, d, RN, b))
 662 #define M_IST(r, b, d) _IFNEG( \
 663         d, \
 664         assert(0), \
 665         N_ST(r, d, RN, b) \
 666 )
 667 #define M_AST(r, b, d) M_IST(r, b, d)
 668 #define M_LST(r, b, d) _IFNEG( \
 669         d, \
 670         assert(0), \
 671         N_ST(GET_HIGH_REG(r), (d) + 0, RN, b); N_ST(GET_LOW_REG(r), (d) + 4, RN, b) \
 672 )
 673 #define M_TEST(r) N_LTR(r, r)
 674 #define M_BEQ(off) N_BRC(DD_E, off)
 675 #define M_BNE(off) N_BRC(DD_NE, off)
 676 #define M_BLE(off) N_BRC(DD_LE, off)
 677 #define M_BGT(off) N_BRC(DD_H, off)
 678 #define M_BLT(off) N_BRC(DD_L, off)
 679 #define M_BGE(off) N_BRC(DD_HE, off)
 680 #define M_BO(off) N_BRC(DD_O, off)
 681
 682 #define M_CMP(r1, r2) N_CR(r1, r2)
 683 #define M_CMPU(r1, r2) N_CLR(r1, r2)
 684 #define M_CLR(r) N_LHI(r, 0)
 685 #define M_AADD_IMM(val, reg) N_AHI(reg, val)
 686 #define M_IADD_IMM(val, reg) N_AHI(reg, val)
 687 #define M_ISUB_IMM(val, reg) N_AHI(reg, -(val))
 688 #define M_ASUB_IMM(val, reg) N_AHI(reg, -(val))
 689 #define M_RET N_BCR(DD_ANY, R14)
 690 #define M_BSR(ret_reg, disp) N_BRAS(ret_reg, disp)
 691 #define M_BR(disp) N_BRC(DD_ANY, disp)
 692 #define M_JMP(rs, rd) _IF(rs == RN, N_BCR(DD_ANY, rd), N_BASR(rs, rd))
 693 #define M_NOP N_BC(0, 0, RN, RN)
 694 #define M_NOP2 N_BCR(0, RN)
 695 #define M_JSR(reg_ret, reg_addr) N_BASR(reg_ret, reg_addr)
 696 #define M_ICMP(a, b) N_CR(a, b)
 697 #define M_ICMPU(a, b) N_CLR(a, b)
 698 #define M_ICMP_IMM(a, b) N_CHI(a, b)
 699 #define M_CVTIF(src, dst) N_CEFBR(dst, src)
 700 #define M_CVTID(src, dst) N_CDFBR(dst, src)
 701 #define M_FMUL(a, dest) N_MEEBR(dest, a)
 702 #define M_FSUB(a, dest) N_SEBR(dest, a)
 703 #define M_FADD(a, dest) N_AEBR(dest, a)
 704 #define M_FDIV(a, dest) N_DEBR(dest, a)
 705 #define M_DMUL(a, dest) N_MDBR(dest, a)
 706 #define M_DSUB(a, dest) N_SDBR(dest, a)
 707 #define M_DADD(a, dest) N_ADBR(dest, a)
 708 #define M_DDIV(a, dest) N_DDBR(dest, a)
 709 #define M_CVTFI(src, dst) N_CFEBR(dst, 4, src)
 710 #define M_CVTDI(src, dst) N_CFDBR(dst, 4, src)
 711 #define M_IADD(a, dest) N_AR(dest, a)
 712 #define M_AADD(a, dest) N_AR(dest, a)
 713 #define M_ISUB(a, dest) N_SR(dest, a)
 714 #define M_ASUB(a, dest) N_SR(dest, a)
 715 #define M_IAND(a, dest) N_NR(dest, a)
 716 #define M_IOR(a, dest) N_OR(dest, a)
 717 #define M_IXOR(a, dest) N_XR(dest, a)
 718 #define M_CVTFD(src,dst) N_LDEBR(dst, src)
 719 #define M_CVTDF(src,dst) N_LEDBR(dst, src)
 720
 721 #define M_SLL_IMM(imm, reg) N_SLL(reg, imm, RN)
 722 #define M_SLA_IMM(imm, reg) N_SLA(reg, imm, RN)
 723
 724 #define M_SLDL_IMM(imm, reg) N_SLDL(reg, imm, RN)
 725 #define M_SLDA_IMM(imm, reg) N_SLDA(reg, imm, RN)
 726
 727 #define M_SRL_IMM(imm, reg) N_SRL(reg, imm, RN)
 728 #define M_SRA_IMM(imm, reg) N_SRA(reg, imm, RN)
 729
 730 #define M_SRDL_IMM(imm, reg) N_SRDL(reg, imm, RN)
 731 #define M_SRDA_IMM(imm, reg) N_SRDA(reg, imm, RN)
 732
 733 #define M_SLL(op, dst) N_SLL(dst, 0, op)
 734 #define M_SLA(op, dst) N_SLA(dst, 0, op)
 735
 736 #define M_SLDL(op, dst) N_SLDL(dst, 0, op)
 737 #define M_SLDA(op, dst) N_SLDA(dst, 0, op)
 738
 739 #define M_SRL(op, dst) N_SRL(dst, 0, op)
 740 #define M_SRA(op, dst) N_SRA(dst, 0, op)
 741
 742 #define M_SRDL(op, dst) N_SRDL(dst, 0, op)
 743 #define M_SRDA(op, dst) N_SRDA(dst, 0, op)
 744
 745 #define M_IMUL_IMM(val, reg) N_MHI(reg, val)
 746 #define M_IMUL(a, dest) N_MSR(dest, a)
 747
 748 #define M_INEG(a, dest) N_LCR(dest, a)
 749
 750 #define M_FCMP(a, b) N_CEBR(a, b)
 751 #define M_DCMP(a, b) N_CDBR(a, b)
 752
 753 #define M_FMOVN(r, dst) N_LCEBR(dst, r)
 754 #define M_DMOVN(r, dst) N_LCDBR(dst, r)
 755
 756 #define ICONST(reg, i) \
 757         do { \
 758                 if (N_VALID_IMM(i)) { \
 759                         N_LHI(reg, i); \
 760                 } else { \
 761                         disp = dseg_add_s4(cd, (i)); \
 762                         M_ILD_DSEG(reg, disp); \
 763                 } \
 764         } while (0)
 765
 766 #define LCONST(reg,c) \
 767         do { \
 768             ICONST(GET_HIGH_REG((reg)), (s4) ((s8) (c) >> 32)); \
 769             ICONST(GET_LOW_REG((reg)), (s4) ((s8) (c))); \
 770         } while (0)
 771
 772 /* M_INTMOVE:
 773     generates an integer-move from register a to b.
 774     if a and b are the same int-register, no code will be generated.
 775 */
 776
 777 #define M_INTMOVE(reg,dreg) \
 778     do { \
 779         if ((reg) != (dreg)) { \
 780             M_MOV(reg, dreg); \
 781         } \
 782     } while (0)
 783
 784 #define M_LNGMOVE(a, b) \
 785     do { \
 786         if (GET_HIGH_REG(a) == GET_LOW_REG(b)) { \
 787             assert((GET_LOW_REG(a) != GET_HIGH_REG(b))); \
 788             M_INTMOVE(GET_HIGH_REG(a), GET_HIGH_REG(b)); \
 789             M_INTMOVE(GET_LOW_REG(a), GET_LOW_REG(b)); \
 790         } else { \
 791             M_INTMOVE(GET_LOW_REG(a), GET_LOW_REG(b)); \
 792             M_INTMOVE(GET_HIGH_REG(a), GET_HIGH_REG(b)); \
 793         } \
 794     } while (0)
 795
 796 /* M_FLTMOVE:
 797     generates a floating-point-move from register a to b.
 798     if a and b are the same float-register, no code will be generated
 799 */
 800
 801 #define M_FLTMOVE(reg,dreg) \
 802     do { \
 803         if ((reg) != (dreg)) { \
 804             M_FMOV(reg, dreg); \
 805         } \
 806     } while (0)
 807
 808 #define M_ISUB_IMM32(imm, tmpreg, reg) \
 809         do { \
 810                 if (N_VALID_IMM(imm)) { \
 811                         M_ISUB_IMM(imm, reg); \
 812                 } else { \
 813                         ICONST(tmpreg, imm); \
 814                         M_ISUB(tmpreg, reg); \
 815                 } \
 816         } while (0)
 817
 818 #define M_ASUB_IMM32(imm, tmpreg, reg) M_ISUB_IMM32(imm, tmpreg, reg)
 819
 820 /* ----------------------------------------------- */
 821
 822 #define _DEPR(x) \
 823         do { \
 824                 fprintf(stdout, \
 825                         "Using old x86_64 instruction %s at %s (%s:%d), fix this.\n", \
 826                         #x, __FUNCTION__, __FILE__, __LINE__); \
 827         } while (0)
 828
 829 #define M_MOV_IMM(a,b) _DEPR( M_MOV_IMM(a,b) )
 830
 831 #define M_IMOV(a,b) _DEPR( M_IMOV(a,b) )
 832 #define M_IMOV_IMM(a,b) _DEPR( M_IMOV_IMM(a,b) )
 833
 834
 835 #define M_ILD32(a,b,disp) _DEPR( M_ILD32(a,b,disp) )
 836 #define M_LLD32(a,b,disp) _DEPR( M_LLD32(a,b,disp) )
 837
 838
 839 #define M_IST_IMM(a,b,disp) _DEPR( M_IST_IMM(a,b,disp) )
 840 #define M_LST_IMM32(a,b,disp) _DEPR( M_LST_IMM32(a,b,disp) )
 841
 842 #define M_IST32(a,b,disp) _DEPR( M_IST32(a,b,disp) )
 843 #define M_LST32(a,b,disp) _DEPR( M_LST32(a,b,disp) )
 844
 845 #define M_IST32_IMM(a,b,disp) _DEPR( M_IST32_IMM(a,b,disp) )
 846 #define M_LST32_IMM32(a,b,disp) _DEPR( M_LST32_IMM32(a,b,disp) )
 847
 848
 849 #define M_LADD(a,b) _DEPR( M_LADD(a,b) )
 850 #define M_LSUB(a,b) _DEPR( M_LSUB(a,b) )
 851 #define M_LMUL(a,b) _DEPR( M_LMUL(a,b) )
 852
 853 #define M_LADD_IMM(a,b) _DEPR( M_LADD_IMM(a,b) )
 854 #define M_LSUB_IMM(a,b) _DEPR( M_LSUB_IMM(a,b) )
 855 #define M_LMUL_IMM(a,b,c) _DEPR( M_LMUL_IMM(a,b,c) )
 856
 857 #define M_IINC(a) _DEPR( M_IINC(a) )
 858 #define M_IDEC(a) _DEPR( M_IDEC(a) )
 859
 860 #define M_ALD32(a,b,disp) _DEPR( M_ALD32(a,b,disp) )
 861
 862 #define M_AST_IMM32(a,b,c) _DEPR( M_AST_IMM32(a,b,c) )
 863
 864 #define M_LADD_IMM32(a,b) _DEPR( M_LADD_IMM32(a,b) )
 865 #define M_AADD_IMM32(a,b) _DEPR( M_AADD_IMM32(a,b) )
 866 #define M_LSUB_IMM32(a,b) _DEPR( M_LSUB_IMM32(a,b) )
 867
 868 #define M_ILEA(a,b,c) _DEPR( M_ILEA(a,b,c) )
 869 #define M_LLEA(a,b,c) _DEPR( M_LLEA(a,b,c) )
 870 #define M_ALEA(a,b,c) _DEPR( M_ALEA(a,b,c) )
 871
 872 #define M_LNEG(a) _DEPR( M_LNEG(a) )
 873
 874 #define M_IAND_IMM(a,b) _DEPR( M_IAND_IMM(a,b) )
 875 #define M_IOR_IMM(a,b) _DEPR( M_IOR_IMM(a,b) )
 876 #define M_IXOR_IMM(a,b) _DEPR( M_IXOR_IMM(a,b) )
 877
 878 #define M_LAND(a,b) _DEPR( M_LAND(a,b) )
 879 #define M_LOR(a,b) _DEPR( M_LOR(a,b) )
 880 #define M_LXOR(a,b) _DEPR( M_LXOR(a,b) )
 881
 882 #define M_LAND_IMM(a,b) _DEPR( M_LAND_IMM(a,b) )
 883 #define M_LOR_IMM(a,b) _DEPR( M_LOR_IMM(a,b) )
 884 #define M_LXOR_IMM(a,b) _DEPR( M_LXOR_IMM(a,b) )
 885
 886 #define M_SSEXT(a,b) _DEPR( M_SSEXT(a,b) )
 887 #define M_ISEXT(a,b) _DEPR( M_ISEXT(a,b) )
 888
 889 #define M_CZEXT(a,b) _DEPR( M_CZEXT(a,b) )
 890
 891 #define M_ISRA_IMM(a,b) _DEPR( M_ISRA_IMM(a,b) )
 892
 893 #define M_LSLL_IMM(a,b) _DEPR( M_LSLL_IMM(a,b) )
 894 #define M_LSRA_IMM(a,b) _DEPR( M_LSRA_IMM(a,b) )
 895 #define M_LSRL_IMM(a,b) _DEPR( M_LSRL_IMM(a,b) )
 896
 897 #define M_LCMP(a,b) _DEPR( M_LCMP(a,b) )
 898 #define M_LCMP_IMM(a,b) _DEPR( M_LCMP_IMM(a,b) )
 899 #define M_LCMP_IMM_MEMBASE(a,b,c) _DEPR( M_LCMP_IMM_MEMBASE(a,b,c) )
 900 #define M_LCMP_MEMBASE(a,b,c) _DEPR( M_LCMP_MEMBASE(a,b,c) )
 901
 902 #define M_ICMP_IMM_MEMBASE(a,b,c) _DEPR( M_ICMP_IMM_MEMBASE(a,b,c) )
 903 #define M_ICMP_MEMBASE(a,b,c) _DEPR( M_ICMP_MEMBASE(a,b,c) )
 904
 905 #define M_BAE(disp) _DEPR( M_BAE(disp) )
 906 #define M_BA(disp) _DEPR( M_BA(disp) )
 907
 908 #define M_CMOVEQ(a,b) _DEPR( M_CMOVEQ(a,b) )
 909 #define M_CMOVNE(a,b) _DEPR( M_CMOVNE(a,b) )
 910 #define M_CMOVLT(a,b) _DEPR( M_CMOVLT(a,b) )
 911 #define M_CMOVLE(a,b) _DEPR( M_CMOVLE(a,b) )
 912 #define M_CMOVGE(a,b) _DEPR( M_CMOVGE(a,b) )
 913 #define M_CMOVGT(a,b) _DEPR( M_CMOVGT(a,b) )
 914
 915 #define M_CMOVEQ_MEMBASE(a,b,c) _DEPR( M_CMOVEQ_MEMBASE(a,b,c) )
 916 #define M_CMOVNE_MEMBASE(a,b,c) _DEPR( M_CMOVNE_MEMBASE(a,b,c) )
 917 #define M_CMOVLT_MEMBASE(a,b,c) _DEPR( M_CMOVLT_MEMBASE(a,b,c) )
 918 #define M_CMOVLE_MEMBASE(a,b,c) _DEPR( M_CMOVLE_MEMBASE(a,b,c) )
 919 #define M_CMOVGE_MEMBASE(a,b,c) _DEPR( M_CMOVGE_MEMBASE(a,b,c) )
 920 #define M_CMOVGT_MEMBASE(a,b,c) _DEPR( M_CMOVGT_MEMBASE(a,b,c) )
 921
 922 #define M_CMOVB(a,b) _DEPR( M_CMOVB(a,b) )
 923 #define M_CMOVA(a,b) _DEPR( M_CMOVA(a,b) )
 924 #define M_CMOVP(a,b) _DEPR( M_CMOVP(a,b) )
 925
 926 #define M_PUSH(a) _DEPR( M_PUSH(a) )
 927 #define M_PUSH_IMM(a) _DEPR( M_PUSH_IMM(a) )
 928 #define M_POP(a) _DEPR( M_POP(a) )
 929
 930 #define M_JMP_IMM(a) _DEPR( M_JMP_IMM(a) )
 931 #define M_CALL_IMM(a) _DEPR( M_CALL_IMM(a) )
 932
 933 #define M_FLD32(a,b,disp) _DEPR( M_FLD32(a,b,disp) )
 934 #define M_DLD32(a,b,disp) _DEPR( M_DLD32(a,b,disp) )
 935
 936 #define M_FST32(a,b,disp) _DEPR( M_FST32(a,b,disp) )
 937 #define M_DST32(a,b,disp) _DEPR( M_DST32(a,b,disp) )
 938
 939
 940 /* system instructions ********************************************************/
 941
 942 #define M_RDTSC _DEPR( M_RDTSC )
 943
 944 #define M_IINC_MEMBASE(a,b) _DEPR( M_IINC_MEMBASE(a,b) )
 945
 946 #define M_IADD_MEMBASE(a,b,c) _DEPR( M_IADD_MEMBASE(a,b,c) )
 947 #define M_IADC_MEMBASE(a,b,c) _DEPR( M_IADC_MEMBASE(a,b,c) )
 948 #define M_ISUB_MEMBASE(a,b,c) _DEPR( M_ISUB_MEMBASE(a,b,c) )
 949 #define M_ISBB_MEMBASE(a,b,c) _DEPR( M_ISBB_MEMBASE(a,b,c) )
 950
 951 #define PROFILE_CYCLE_START
 952 #define __PROFILE_CYCLE_START _DEPR( __PROFILE_CYCLE_START )
 953
 954 #define PROFILE_CYCLE_STOP
 955 #define __PROFILE_CYCLE_STOP _DEPR( __PROFILE_CYCLE_STOP )
 956
 957 #endif /* _CODEGEN_H */
 958
 959
 960 s4 codegen_reg_of_dst_notzero(jitdata *jd, instruction *iptr, s4 tempregnum);
 961
 962
 963 /*
 964  * These are local overrides for various environment variables in Emacs.
 965  * Please do not remove this and leave it at the end of the file, where
 966  * Emacs will automagically detect them.
 967  * ---------------------------------------------------------------------
 968  * Local variables:
 969  * mode: c
 970  * indent-tabs-mode: t
 971  * c-basic-offset: 4
 972  * tab-width: 4
 973  * End:
 974  */