src/vm/jit/x86_64/codegen.h

   1 /* src/vm/jit/x86_64/codegen.h - code generation macros for x86_64
   2
   3    Copyright (C) 1996-2005, 2006 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    Contact: cacao@cacaojvm.org
  26
  27    Authors: Andreas Krall
  28             Christian Thalinger
  29
  30    Changes:
  31
  32    $Id: codegen.h 4789 2006-04-18 20:34:52Z twisti $
  33
  34 */
  35
  36
  37 #ifndef _CODEGEN_H
  38 #define _CODEGEN_H
  39
  40 #include "config.h"
  41
  42 #include <ucontext.h>
  43
  44 #include "vm/types.h"
  45
  46 #include "vm/jit/jit.h"
  47
  48
  49 /* some defines ***************************************************************/
  50
  51 #define PATCHER_CALL_SIZE    5          /* size in bytes of a patcher call    */
  52
  53
  54 /* macros to create code ******************************************************/
  55
  56 /* immediate data union */
  57
  58 typedef union {
  59     s4 i;
  60     s8 l;
  61     float f;
  62     double d;
  63     void *a;
  64     u1 b[8];
  65 } x86_64_imm_buf;
  66
  67
  68 /* opcodes for alu instructions */
  69
  70 typedef enum {
  71     X86_64_ADD = 0,
  72     X86_64_OR  = 1,
  73     X86_64_ADC = 2,
  74     X86_64_SBB = 3,
  75     X86_64_AND = 4,
  76     X86_64_SUB = 5,
  77     X86_64_XOR = 6,
  78     X86_64_CMP = 7,
  79     X86_64_NALU
  80 } X86_64_ALU_Opcode;
  81
  82
  83 typedef enum {
  84     X86_64_ROL = 0,
  85     X86_64_ROR = 1,
  86     X86_64_RCL = 2,
  87     X86_64_RCR = 3,
  88     X86_64_SHL = 4,
  89     X86_64_SHR = 5,
  90     X86_64_SAR = 7,
  91     X86_64_NSHIFT = 8
  92 } X86_64_Shift_Opcode;
  93
  94
  95 typedef enum {
  96     X86_64_CC_O = 0,
  97     X86_64_CC_NO = 1,
  98     X86_64_CC_B = 2, X86_64_CC_C = 2, X86_64_CC_NAE = 2,
  99     X86_64_CC_BE = 6, X86_64_CC_NA = 6,
 100     X86_64_CC_AE = 3, X86_64_CC_NB = 3, X86_64_CC_NC = 3,
 101     X86_64_CC_E = 4, X86_64_CC_Z = 4,
 102     X86_64_CC_NE = 5, X86_64_CC_NZ = 5,
 103     X86_64_CC_A = 7, X86_64_CC_NBE = 7,
 104     X86_64_CC_S = 8, X86_64_CC_LZ = 8,
 105     X86_64_CC_NS = 9, X86_64_CC_GEZ = 9,
 106     X86_64_CC_P = 0x0a, X86_64_CC_PE = 0x0a,
 107     X86_64_CC_NP = 0x0b, X86_64_CC_PO = 0x0b,
 108     X86_64_CC_L = 0x0c, X86_64_CC_NGE = 0x0c,
 109     X86_64_CC_GE = 0x0d, X86_64_CC_NL = 0x0d,
 110     X86_64_CC_LE = 0x0e, X86_64_CC_NG = 0x0e,
 111     X86_64_CC_G = 0x0f, X86_64_CC_NLE = 0x0f,
 112     X86_64_NCC
 113 } X86_64_CC;
 114
 115
 116 #define IS_IMM8(imm) \
 117     (((long) (imm) >= -128) && ((long) (imm) <= 127))
 118
 119
 120 #define IS_IMM32(imm) \
 121     (((long) (imm) >= (-2147483647-1)) && ((long) (imm) <= 2147483647))
 122
 123
 124 /* modrm and stuff */
 125
 126 #define x86_64_address_byte(mod,reg,rm) \
 127     *(cd->mcodeptr++) = ((((mod) & 0x03) << 6) | (((reg) & 0x07) << 3) | ((rm) & 0x07));
 128
 129
 130 #define x86_64_emit_reg(reg,rm) \
 131     x86_64_address_byte(3,(reg),(rm));
 132
 133
 134 #define x86_64_emit_rex(size,reg,index,rm) \
 135     if (((size) == 1) || ((reg) > 7) || ((index) > 7) || ((rm) > 7)) { \
 136         *(cd->mcodeptr++) = (0x40 | (((size) & 0x01) << 3) | ((((reg) >> 3) & 0x01) << 2) | ((((index) >> 3) & 0x01) << 1) | (((rm) >> 3) & 0x01)); \
 137     }
 138
 139
 140 #define x86_64_emit_byte_rex(reg,index,rm) \
 141     *(cd->mcodeptr++) = (0x40 | ((((reg) >> 3) & 0x01) << 2) | ((((index) >> 3) & 0x01) << 1) | (((rm) >> 3) & 0x01));
 142
 143
 144 #define x86_64_emit_mem(r,disp) \
 145     do { \
 146         x86_64_address_byte(0,(r),5); \
 147         x86_64_emit_imm32((disp)); \
 148     } while (0)
 149
 150
 151 #define x86_64_emit_membase(basereg,disp,dreg) \
 152     do { \
 153         if ((basereg) == REG_SP || (basereg) == R12) { \
 154             if ((disp) == 0) { \
 155                 x86_64_address_byte(0,(dreg),REG_SP); \
 156                 x86_64_address_byte(0,REG_SP,REG_SP); \
 157             } else if (IS_IMM8((disp))) { \
 158                 x86_64_address_byte(1,(dreg),REG_SP); \
 159                 x86_64_address_byte(0,REG_SP,REG_SP); \
 160                 x86_64_emit_imm8((disp)); \
 161             } else { \
 162                 x86_64_address_byte(2,(dreg),REG_SP); \
 163                 x86_64_address_byte(0,REG_SP,REG_SP); \
 164                 x86_64_emit_imm32((disp)); \
 165             } \
 166             break; \
 167         } \
 168         if ((disp) == 0 && (basereg) != RBP && (basereg) != R13) { \
 169             x86_64_address_byte(0,(dreg),(basereg)); \
 170             break; \
 171         } \
 172         \
 173         if ((basereg) == RIP) { \
 174             x86_64_address_byte(0,(dreg),RBP); \
 175             x86_64_emit_imm32((disp)); \
 176             break; \
 177         } \
 178         \
 179         if (IS_IMM8((disp))) { \
 180             x86_64_address_byte(1,(dreg),(basereg)); \
 181             x86_64_emit_imm8((disp)); \
 182         } else { \
 183             x86_64_address_byte(2,(dreg),(basereg)); \
 184             x86_64_emit_imm32((disp)); \
 185         } \
 186     } while (0)
 187
 188
 189 #define x86_64_emit_membase32(basereg,disp,dreg) \
 190     do { \
 191         if ((basereg) == REG_SP || (basereg) == R12) { \
 192             x86_64_address_byte(2,(dreg),REG_SP); \
 193             x86_64_address_byte(0,REG_SP,REG_SP); \
 194             x86_64_emit_imm32((disp)); \
 195         } else {\
 196             x86_64_address_byte(2,(dreg),(basereg)); \
 197             x86_64_emit_imm32((disp)); \
 198         } \
 199     } while (0)
 200
 201
 202 #define x86_64_emit_memindex(reg,disp,basereg,indexreg,scale) \
 203     do { \
 204         if ((basereg) == -1) { \
 205             x86_64_address_byte(0,(reg),4); \
 206             x86_64_address_byte((scale),(indexreg),5); \
 207             x86_64_emit_imm32((disp)); \
 208         \
 209         } else if ((disp) == 0 && (basereg) != RBP && (basereg) != R13) { \
 210             x86_64_address_byte(0,(reg),4); \
 211             x86_64_address_byte((scale),(indexreg),(basereg)); \
 212         \
 213         } else if (IS_IMM8((disp))) { \
 214             x86_64_address_byte(1,(reg),4); \
 215             x86_64_address_byte((scale),(indexreg),(basereg)); \
 216             x86_64_emit_imm8 ((disp)); \
 217         \
 218         } else { \
 219             x86_64_address_byte(2,(reg),4); \
 220             x86_64_address_byte((scale),(indexreg),(basereg)); \
 221             x86_64_emit_imm32((disp)); \
 222         }    \
 223      } while (0)
 224
 225
 226 #define x86_64_emit_imm8(imm) \
 227     *(cd->mcodeptr++) = (u1) ((imm) & 0xff);
 228
 229
 230 #define x86_64_emit_imm16(imm) \
 231     do { \
 232         x86_64_imm_buf imb; \
 233         imb.i = (s4) (imm); \
 234         *(cd->mcodeptr++) = imb.b[0]; \
 235         *(cd->mcodeptr++) = imb.b[1]; \
 236     } while (0)
 237
 238
 239 #define x86_64_emit_imm32(imm) \
 240     do { \
 241         x86_64_imm_buf imb; \
 242         imb.i = (s4) (imm); \
 243         *(cd->mcodeptr++) = imb.b[0]; \
 244         *(cd->mcodeptr++) = imb.b[1]; \
 245         *(cd->mcodeptr++) = imb.b[2]; \
 246         *(cd->mcodeptr++) = imb.b[3]; \
 247     } while (0)
 248
 249
 250 #define x86_64_emit_imm64(imm) \
 251     do { \
 252         x86_64_imm_buf imb; \
 253         imb.l = (s8) (imm); \
 254         *(cd->mcodeptr++) = imb.b[0]; \
 255         *(cd->mcodeptr++) = imb.b[1]; \
 256         *(cd->mcodeptr++) = imb.b[2]; \
 257         *(cd->mcodeptr++) = imb.b[3]; \
 258         *(cd->mcodeptr++) = imb.b[4]; \
 259         *(cd->mcodeptr++) = imb.b[5]; \
 260         *(cd->mcodeptr++) = imb.b[6]; \
 261         *(cd->mcodeptr++) = imb.b[7]; \
 262     } while (0)
 263
 264
 265 /* additional functions and macros to generate code ***************************/
 266
 267 #define CALCOFFSETBYTES(var, reg, val) \
 268     if ((s4) (val) < -128 || (s4) (val) > 127) (var) += 4; \
 269     else if ((s4) (val) != 0) (var) += 1; \
 270     else if ((reg) == RBP || (reg) == RSP || (reg) == R12 || (reg) == R13) (var) += 1;
 271
 272
 273 #define CALCIMMEDIATEBYTES(var, val) \
 274     if ((s4) (val) < -128 || (s4) (val) > 127) (var) += 4; \
 275     else (var) += 1;
 276
 277
 278 /* gen_nullptr_check(objreg) */
 279
 280 #define gen_nullptr_check(objreg) \
 281         if (checknull) { \
 282         M_TEST(objreg); \
 283         M_BEQ(0); \
 284             codegen_add_nullpointerexception_ref(cd, cd->mcodeptr); \
 285         }
 286
 287
 288 #define gen_bound_check \
 289     if (checkbounds) { \
 290         M_CMP_MEMBASE(s1, OFFSET(java_arrayheader, size), s2); \
 291         M_BAE(0); \
 292         codegen_add_arrayindexoutofboundsexception_ref(cd, cd->mcodeptr, s2); \
 293     }
 294
 295
 296 #define gen_div_check(v) \
 297     if (checknull) { \
 298         if ((v)->flags & INMEMORY) { \
 299             M_CMP_IMM_MEMBASE(0, REG_SP, src->regoff * 8); \
 300         } else { \
 301             M_TEST(src->regoff); \
 302         } \
 303         M_BEQ(0); \
 304         codegen_add_arithmeticexception_ref(cd, cd->mcodeptr); \
 305     }
 306
 307
 308 /* MCODECHECK(icnt) */
 309
 310 #define MCODECHECK(icnt) \
 311         if ((cd->mcodeptr + (icnt)) > (u1 *) cd->mcodeend) \
 312         cd->mcodeptr = (u1 *) codegen_increase(cd, cd->mcodeptr)
 313
 314
 315 #define ALIGNCODENOP \
 316     if ((s4) (((ptrint) cd->mcodeptr) & 7)) { \
 317         M_NOP; \
 318     }
 319
 320
 321 /* M_INTMOVE:
 322     generates an integer-move from register a to b.
 323     if a and b are the same int-register, no code will be generated.
 324 */
 325
 326 #define M_INTMOVE(reg,dreg) \
 327     do { \
 328         if ((reg) != (dreg)) { \
 329             M_MOV(reg, dreg); \
 330         } \
 331     } while (0)
 332
 333
 334 /* M_FLTMOVE:
 335     generates a floating-point-move from register a to b.
 336     if a and b are the same float-register, no code will be generated
 337 */
 338
 339 #define M_FLTMOVE(reg,dreg) \
 340     do { \
 341         if ((reg) != (dreg)) { \
 342             M_FMOV(reg, dreg); \
 343         } \
 344     } while (0)
 345
 346
 347 #define M_COPY(s,d)                     emit_copy(jd, iptr, (s), (d))
 348
 349 #define ICONST(r,c) \
 350     do { \
 351         if (iptr->val.i == 0) \
 352             M_CLR(d); \
 353         else \
 354             M_IMOV_IMM(iptr->val.i, d); \
 355     } while (0)
 356 /*     do { \ */
 357 /*        M_IMOV_IMM(iptr->val.i, d); \ */
 358 /*     } while (0) */
 359
 360
 361 #define LCONST(r,c) \
 362     do { \
 363         if (iptr->val.l == 0) \
 364             M_CLR(d); \
 365         else \
 366             M_MOV_IMM(iptr->val.l, d); \
 367     } while (0)
 368
 369
 370 /* macros to create code ******************************************************/
 371
 372 #define M_MOV(a,b)              x86_64_mov_reg_reg(cd, (a), (b))
 373 #define M_MOV_IMM(a,b)          x86_64_mov_imm_reg(cd, (u8) (a), (b))
 374
 375 #define M_FMOV(a,b)             x86_64_movq_reg_reg(cd, (a), (b))
 376
 377 #define M_IMOV_IMM(a,b)         x86_64_movl_imm_reg(cd, (u4) (a), (b))
 378
 379 #define M_ILD(a,b,disp)         x86_64_movl_membase_reg(cd, (b), (disp), (a))
 380 #define M_LLD(a,b,disp)         x86_64_mov_membase_reg(cd, (b), (disp), (a))
 381
 382 #define M_ILD32(a,b,disp)       x86_64_movl_membase32_reg(cd, (b), (disp), (a))
 383 #define M_LLD32(a,b,disp)       x86_64_mov_membase32_reg(cd, (b), (disp), (a))
 384
 385 #define M_IST(a,b,disp)         x86_64_movl_reg_membase(cd, (a), (b), (disp))
 386 #define M_LST(a,b,disp)         x86_64_mov_reg_membase(cd, (a), (b), (disp))
 387
 388 #define M_IST_IMM(a,b,disp)     x86_64_movl_imm_membase(cd, (a), (b), (disp))
 389 #define M_LST_IMM32(a,b,disp)   x86_64_mov_imm_membase(cd, (a), (b), (disp))
 390
 391 #define M_IST32(a,b,disp)       x86_64_movl_reg_membase32(cd, (a), (b), (disp))
 392 #define M_LST32(a,b,disp)       x86_64_mov_reg_membase32(cd, (a), (b), (disp))
 393
 394 #define M_IST32_IMM(a,b,disp)   x86_64_movl_imm_membase32(cd, (a), (b), (disp))
 395 #define M_LST32_IMM32(a,b,disp) x86_64_mov_imm_membase32(cd, (a), (b), (disp))
 396
 397 #define M_LADD(a,b)             x86_64_alu_reg_reg(cd, X86_64_ADD, (a), (b))
 398 #define M_LADD_IMM(a,b)         x86_64_alu_imm_reg(cd, X86_64_ADD, (a), (b))
 399 #define M_LSUB(a,b)             x86_64_alu_reg_reg(cd, X86_64_SUB, (a), (b))
 400 #define M_LSUB_IMM(a,b)         x86_64_alu_imm_reg(cd, X86_64_SUB, (a), (b))
 401
 402 #define M_IINC_MEMBASE(a,b)     x86_64_incl_membase(cd, (a), (b))
 403
 404 #define M_IADD_MEMBASE(a,b,c)   x86_64_alul_reg_membase(cd, X86_64_ADD, (a), (b), (c))
 405 #define M_IADC_MEMBASE(a,b,c)   x86_64_alul_reg_membase(cd, X86_64_ADC, (a), (b), (c))
 406 #define M_ISUB_MEMBASE(a,b,c)   x86_64_alul_reg_membase(cd, X86_64_SUB, (a), (b), (c))
 407 #define M_ISBB_MEMBASE(a,b,c)   x86_64_alul_reg_membase(cd, X86_64_SBB, (a), (b), (c))
 408
 409 #define M_ALD(a,b,c)            M_LLD(a,b,c)
 410 #define M_AST(a,b,c)            M_LST(a,b,c)
 411 #define M_AST_IMM32(a,b,c)      M_LST_IMM32(a,b,c)
 412 #define M_AADD(a,b)             M_LADD(a,b)
 413 #define M_AADD_IMM(a,b)         M_LADD_IMM(a,b)
 414 #define M_ASUB_IMM(a,b)         M_LSUB_IMM(a,b)
 415
 416 #define M_LADD_IMM32(a,b)       x86_64_alu_imm32_reg(cd, X86_64_ADD, (a), (b))
 417 #define M_AADD_IMM32(a,b)       M_LADD_IMM32(a,b)
 418 #define M_LSUB_IMM32(a,b)       x86_64_alu_imm32_reg(cd, X86_64_SUB, (a), (b))
 419
 420 #define M_ILEA(a,b,c)           x86_64_leal_membase_reg(cd, (a), (b), (c))
 421 #define M_LLEA(a,b,c)           x86_64_lea_membase_reg(cd, (a), (b), (c))
 422 #define M_ALEA(a,b,c)           M_LLEA(a,b,c)
 423
 424 #define M_INEG(a)               x86_64_negl_reg(cd, (a))
 425 #define M_LNEG(a)               x86_64_neg_reg(cd, (a))
 426
 427 #define M_INEG_MEMBASE(a,b)     x86_64_negl_membase(cd, (a), (b))
 428 #define M_LNEG_MEMBASE(a,b)     x86_64_neg_membase(cd, (a), (b))
 429
 430 #define M_AND(a,b)              x86_64_alu_reg_reg(cd, X86_64_AND, (a), (b))
 431 #define M_XOR(a,b)              x86_64_alu_reg_reg(cd, X86_64_XOR, (a), (b))
 432
 433 #define M_IAND(a,b)             x86_64_alul_reg_reg(cd, X86_64_AND, (a), (b))
 434 #define M_IAND_IMM(a,b)         x86_64_alul_imm_reg(cd, X86_64_AND, (a), (b))
 435 #define M_IXOR(a,b)             x86_64_alul_reg_reg(cd, X86_64_XOR, (a), (b))
 436
 437 #define M_TEST(a)               x86_64_test_reg_reg(cd, (a), (a))
 438 #define M_ITEST(a)              x86_64_testl_reg_reg(cd, (a), (a))
 439
 440 #define M_CMP(a,b)              x86_64_alu_reg_reg(cd, X86_64_CMP, (a), (b))
 441 #define M_CMP_IMM(a,b)          x86_64_alu_imm_reg(cd, X86_64_CMP, (a), (b))
 442 #define M_CMP_IMM_MEMBASE(a,b,c) x86_64_alu_imm_membase(cd, X86_64_CMP, (a), (b), (c))
 443 #define M_CMP_MEMBASE(a,b,c)    x86_64_alu_membase_reg(cd, X86_64_CMP, (a), (b), (c))
 444
 445 #define M_ICMP(a,b)             x86_64_alul_reg_reg(cd, X86_64_CMP, (a), (b))
 446 #define M_ICMP_IMM(a,b)         x86_64_alul_imm_reg(cd, X86_64_CMP, (a), (b))
 447 #define M_ICMP_IMM_MEMBASE(a,b,c) x86_64_alul_imm_membase(cd, X86_64_CMP, (a), (b), (c))
 448
 449 #define M_BEQ(disp)             x86_64_jcc(cd, X86_64_CC_E, (disp))
 450 #define M_BNE(disp)             x86_64_jcc(cd, X86_64_CC_NE, (disp))
 451 #define M_BLE(disp)             x86_64_jcc(cd, X86_64_CC_LE, (disp))
 452 #define M_BAE(disp)             x86_64_jcc(cd, X86_64_CC_AE, (disp))
 453 #define M_BA(disp)              x86_64_jcc(cd, X86_64_CC_A, (disp))
 454
 455 #define M_CMOVEQ(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_E, (a), (b))
 456 #define M_CMOVNE(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_NE, (a), (b))
 457 #define M_CMOVLT(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_L, (a), (b))
 458 #define M_CMOVLE(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_LE, (a), (b))
 459 #define M_CMOVGE(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_GE, (a), (b))
 460 #define M_CMOVGT(a,b)           x86_64_cmovcc_reg_reg(cd, X86_64_CC_G, (a), (b))
 461
 462 #define M_CMOVEQ_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_E, (a), (b))
 463 #define M_CMOVNE_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_NE, (a), (b))
 464 #define M_CMOVLT_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_L, (a), (b))
 465 #define M_CMOVLE_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_LE, (a), (b))
 466 #define M_CMOVGE_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_GE, (a), (b))
 467 #define M_CMOVGT_MEMBASE(a,b,c) x86_64_cmovcc_reg_membase(cd, X86_64_CC_G, (a), (b))
 468
 469 #define M_CMOVB(a,b)            x86_64_cmovcc_reg_reg(cd, X86_64_CC_B, (a), (b))
 470 #define M_CMOVA(a,b)            x86_64_cmovcc_reg_reg(cd, X86_64_CC_A, (a), (b))
 471 #define M_CMOVP(a,b)            x86_64_cmovcc_reg_reg(cd, X86_64_CC_P, (a), (b))
 472
 473 #define M_PUSH(a)               x86_64_push_reg(cd, (a))
 474 #define M_PUSH_IMM(a)           x86_64_push_imm(cd, (a))
 475 #define M_POP(a)                x86_64_pop_reg(cd, (a))
 476
 477 #define M_JMP(a)                x86_64_jmp_reg(cd, (a))
 478 #define M_JMP_IMM(a)            x86_64_jmp_imm(cd, (a))
 479 #define M_CALL(a)               x86_64_call_reg(cd, (a))
 480 #define M_CALL_IMM(a)           x86_64_call_imm(cd, (a))
 481 #define M_RET                   x86_64_ret(cd)
 482
 483 #define M_NOP                   x86_64_nop(cd)
 484
 485 #define M_CLR(a)                M_XOR(a,a)
 486
 487
 488 #if 0
 489 #define M_FLD(a,b,c)            x86_64_movlps_membase_reg(cd, (a), (b), (c))
 490 #define M_DLD(a,b,c)            x86_64_movlpd_membase_reg(cd, (a), (b), (c))
 491
 492 #define M_FST(a,b,c)            x86_64_movlps_reg_membase(cd, (a), (b), (c))
 493 #define M_DST(a,b,c)            x86_64_movlpd_reg_membase(cd, (a), (b), (c))
 494 #endif
 495
 496 #define M_DLD(a,b,disp)         x86_64_movq_membase_reg(cd, (b), (disp), (a))
 497 #define M_DST(a,b,disp)         x86_64_movq_reg_membase(cd, (a), (b), (disp))
 498
 499
 500 /* system instructions ********************************************************/
 501
 502 #define M_RDTSC                 emit_rdtsc(cd)
 503
 504 #define PROFILE_CYCLE_START \
 505     do { \
 506         if (opt_prof) { \
 507             M_PUSH(RAX); \
 508             M_PUSH(RDX); \
 509             \
 510             M_MOV_IMM((ptrint) m, REG_ITMP3); \
 511             M_RDTSC; \
 512             M_ISUB_MEMBASE(RAX, REG_ITMP3, OFFSET(methodinfo, cycles)); \
 513             M_ISBB_MEMBASE(RDX, REG_ITMP3, OFFSET(methodinfo, cycles) + 4); \
 514             \
 515             M_POP(RDX); \
 516             M_POP(RAX); \
 517         } \
 518     } while (0)
 519
 520 #define PROFILE_CYCLE_STOP \
 521     do { \
 522         if (opt_prof) { \
 523             M_PUSH(RAX); \
 524             M_PUSH(RDX); \
 525             \
 526             M_MOV_IMM((ptrint) m, REG_ITMP3); \
 527             M_RDTSC; \
 528             M_IADD_MEMBASE(RAX, REG_ITMP3, OFFSET(methodinfo, cycles)); \
 529             M_IADC_MEMBASE(RDX, REG_ITMP3, OFFSET(methodinfo, cycles) + 4); \
 530             \
 531             M_POP(RDX); \
 532             M_POP(RAX); \
 533         } \
 534     } while (0)
 535
 536
 537 /* function gen_resolvebranch **************************************************
 538
 539     backpatches a branch instruction
 540
 541     parameters: ip ... pointer to instruction after branch (void*)
 542                 so ... offset of instruction after branch  (s8)
 543                 to ... offset of branch target             (s8)
 544
 545 *******************************************************************************/
 546
 547 #define gen_resolvebranch(ip,so,to) \
 548     *((s4*) ((ip) - 4)) = (s4) ((to) - (so));
 549
 550 #endif /* _CODEGEN_H */
 551
 552
 553 /*
 554  * These are local overrides for various environment variables in Emacs.
 555  * Please do not remove this and leave it at the end of the file, where
 556  * Emacs will automagically detect them.
 557  * ---------------------------------------------------------------------
 558  * Local variables:
 559  * mode: c
 560  * indent-tabs-mode: t
 561  * c-basic-offset: 4
 562  * tab-width: 4
 563  * End:
 564  */