src/vm/jit/i386/codegen.h

   1 /* jit/i386/codegen.h - code generation macros and definitions for i386
   2
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   4    R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
   5    M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
   6    P. Tomsich, J. Wenninger
   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., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Andreas Krall
  28             Christian Thalinger
  29
  30    $Id: codegen.h 1139 2004-06-05 20:57:12Z twisti $
  31
  32 */
  33
  34
  35 #ifndef _CODEGEN_H
  36 #define _CODEGEN_H
  37
  38
  39 #include <ucontext.h>
  40 #include "jit/jit.h"
  41
  42
  43 /* define x86 register numbers */
  44 #define EAX    0
  45 #define ECX    1
  46 #define EDX    2
  47 #define EBX    3
  48 #define ESP    4
  49 #define EBP    5
  50 #define ESI    6
  51 #define EDI    7
  52
  53
  54 /* preallocated registers *****************************************************/
  55
  56 /* integer registers */
  57
  58 #define REG_RESULT      EAX      /* to deliver method results                 */
  59 #define REG_RESULT2     EDX      /* to deliver long method results            */
  60
  61 #define REG_ITMP1       EAX      /* temporary register                        */
  62 #define REG_ITMP2       ECX      /* temporary register                        */
  63 #define REG_ITMP3       EDX      /* temporary register                        */
  64
  65 #define REG_NULL        -1       /* used for reg_of_var where d is not needed */
  66
  67 #define REG_ITMP1_XPTR  EAX      /* exception pointer = temporary register 1  */
  68 #define REG_ITMP2_XPC   ECX      /* exception pc = temporary register 2       */
  69
  70 #define REG_SP          ESP      /* stack pointer                             */
  71
  72 /* floating point registers */
  73
  74 #define REG_FRESULT     0    /* to deliver floating point method results      */
  75 #define REG_FTMP1       6    /* temporary floating point register             */
  76 #define REG_FTMP2       7    /* temporary floating point register             */
  77 #define REG_FTMP3       7    /* temporary floating point register             */
  78
  79
  80 /* additional functions and macros to generate code ***************************/
  81
  82 #define BlockPtrOfPC(pc)  ((basicblock *) iptr->target)
  83
  84
  85 #ifdef STATISTICS
  86 #define COUNT_SPILLS count_spills++
  87 #else
  88 #define COUNT_SPILLS
  89 #endif
  90
  91
  92 #define CALCOFFSETBYTES(var, reg, val) \
  93     if ((s4) (val) < -128 || (s4) (val) > 127) (var) += 4; \
  94     else if ((s4) (val) != 0) (var) += 1; \
  95     else if ((reg) == EBP) (var) += 1;
  96
  97
  98 #define CALCIMMEDIATEBYTES(var, val) \
  99     if ((s4) (val) < -128 || (s4) (val) > 127) (var) += 4; \
 100     else (var) += 1;
 101
 102
 103 /* gen_nullptr_check(objreg) */
 104
 105 #define gen_nullptr_check(objreg) \
 106         if (checknull) { \
 107         i386_test_reg_reg((objreg), (objreg)); \
 108         i386_jcc(I386_CC_E, 0); \
 109             codegen_addxnullrefs(mcodeptr); \
 110         }
 111
 112 #define gen_bound_check \
 113     if (checkbounds) { \
 114         i386_alu_membase_reg(I386_CMP, s1, OFFSET(java_arrayheader, size), s2); \
 115         i386_jcc(I386_CC_AE, 0); \
 116         codegen_addxboundrefs(mcodeptr, s2); \
 117     }
 118
 119
 120 /* MCODECHECK(icnt) */
 121
 122 #define MCODECHECK(icnt) \
 123         if ((mcodeptr + (icnt)) > (u1*) mcodeend) mcodeptr = (u1*) codegen_increase((u1*) mcodeptr)
 124
 125 /* M_INTMOVE:
 126      generates an integer-move from register a to b.
 127      if a and b are the same int-register, no code will be generated.
 128 */
 129
 130 #define M_INTMOVE(reg,dreg) if ((reg) != (dreg)) { i386_mov_reg_reg((reg),(dreg)); }
 131
 132
 133 /* M_FLTMOVE:
 134     generates a floating-point-move from register a to b.
 135     if a and b are the same float-register, no code will be generated
 136 */
 137
 138 #define M_FLTMOVE(reg,dreg) panic("M_FLTMOVE");
 139
 140 #define M_LNGMEMMOVE(reg,dreg) \
 141     do { \
 142         i386_mov_membase_reg(REG_SP, (reg) * 8, REG_ITMP1); \
 143         i386_mov_reg_membase(REG_ITMP1, REG_SP, (dreg) * 8); \
 144         i386_mov_membase_reg(REG_SP, (reg) * 8 + 4, REG_ITMP1); \
 145         i386_mov_reg_membase(REG_ITMP1, REG_SP, (dreg) * 8 + 4); \
 146     } while (0)
 147
 148
 149 /* var_to_reg_xxx:
 150     this function generates code to fetch data from a pseudo-register
 151     into a real register.
 152     If the pseudo-register has actually been assigned to a real
 153     register, no code will be emitted, since following operations
 154     can use this register directly.
 155
 156     v: pseudoregister to be fetched from
 157     tempregnum: temporary register to be used if v is actually spilled to ram
 158
 159     return: the register number, where the operand can be found after
 160             fetching (this wil be either tempregnum or the register
 161             number allready given to v)
 162 */
 163
 164 #define var_to_reg_int(regnr,v,tempnr) \
 165     if ((v)->flags & INMEMORY) { \
 166         COUNT_SPILLS; \
 167         i386_mov_membase_reg(REG_SP, (v)->regoff * 8, tempnr); \
 168         regnr = tempnr; \
 169     } else { \
 170         regnr = (v)->regoff; \
 171     }
 172
 173
 174
 175 #define var_to_reg_flt(regnr,v,tempnr) \
 176     if ((v)->type == TYPE_FLT) { \
 177         if ((v)->flags & INMEMORY) { \
 178             COUNT_SPILLS; \
 179             i386_flds_membase(REG_SP, (v)->regoff * 8); \
 180             fpu_st_offset++; \
 181             regnr = tempnr; \
 182         } else { \
 183             i386_fld_reg((v)->regoff + fpu_st_offset); \
 184             fpu_st_offset++; \
 185             regnr = (v)->regoff; \
 186         } \
 187     } else { \
 188         if ((v)->flags & INMEMORY) { \
 189             COUNT_SPILLS; \
 190             i386_fldl_membase(REG_SP, (v)->regoff * 8); \
 191             fpu_st_offset++; \
 192             regnr = tempnr; \
 193         } else { \
 194             i386_fld_reg((v)->regoff + fpu_st_offset); \
 195             fpu_st_offset++; \
 196             regnr = (v)->regoff; \
 197         } \
 198     }
 199
 200 #define NEW_var_to_reg_flt(regnr,v,tempnr) \
 201     if ((v)->type == TYPE_FLT) { \
 202        if ((v)->flags & INMEMORY) { \
 203             COUNT_SPILLS; \
 204             i386_flds_membase(REG_SP, (v)->regoff * 8); \
 205             fpu_st_offset++; \
 206             regnr = tempnr; \
 207         } else { \
 208             regnr = (v)->regoff; \
 209         } \
 210     } else { \
 211         if ((v)->flags & INMEMORY) { \
 212             COUNT_SPILLS; \
 213             i386_fldl_membase(REG_SP, (v)->regoff * 8); \
 214             fpu_st_offset++; \
 215             regnr = tempnr; \
 216         } else { \
 217             regnr = (v)->regoff; \
 218         } \
 219     }
 220
 221
 222 /* store_reg_to_var_xxx:
 223     This function generates the code to store the result of an operation
 224     back into a spilled pseudo-variable.
 225     If the pseudo-variable has not been spilled in the first place, this
 226     function will generate nothing.
 227
 228     v ............ Pseudovariable
 229     tempregnum ... Number of the temporary registers as returned by
 230                    reg_of_var.
 231 */
 232
 233 #define store_reg_to_var_int(sptr, tempregnum) \
 234     if ((sptr)->flags & INMEMORY) { \
 235         COUNT_SPILLS; \
 236         i386_mov_reg_membase(tempregnum, REG_SP, (sptr)->regoff * 8); \
 237     }
 238
 239
 240 #define store_reg_to_var_flt(sptr, tempregnum) \
 241     if ((sptr)->type == TYPE_FLT) { \
 242         if ((sptr)->flags & INMEMORY) { \
 243              COUNT_SPILLS; \
 244              i386_fstps_membase(REG_SP, (sptr)->regoff * 8); \
 245              fpu_st_offset--; \
 246         } else { \
 247 /*                  i386_fxch_reg((sptr)->regoff);*/ \
 248              i386_fstp_reg((sptr)->regoff + fpu_st_offset); \
 249              fpu_st_offset--; \
 250         } \
 251     } else { \
 252         if ((sptr)->flags & INMEMORY) { \
 253             COUNT_SPILLS; \
 254             i386_fstpl_membase(REG_SP, (sptr)->regoff * 8); \
 255             fpu_st_offset--; \
 256         } else { \
 257 /*                  i386_fxch_reg((sptr)->regoff);*/ \
 258             i386_fstp_reg((sptr)->regoff + fpu_st_offset); \
 259             fpu_st_offset--; \
 260         } \
 261     }
 262
 263
 264 /* macros to create code ******************************************************/
 265
 266 typedef enum {
 267     I386_AL = 0,
 268     I386_CL = 1,
 269     I386_DL = 2,
 270     I386_BL = 3,
 271     I386_AH = 4,
 272     I386_CH = 5,
 273     I386_DH = 6,
 274     I386_BH = 7,
 275     I386_NREGB
 276 } I386_RegB_No;
 277
 278
 279 /* opcodes for alu instructions */
 280
 281 typedef enum {
 282     I386_ADD = 0,
 283     I386_OR  = 1,
 284     I386_ADC = 2,
 285     I386_SBB = 3,
 286     I386_AND = 4,
 287     I386_SUB = 5,
 288     I386_XOR = 6,
 289     I386_CMP = 7,
 290     I386_NALU
 291 } I386_ALU_Opcode;
 292
 293 typedef enum {
 294     I386_ROL = 0,
 295     I386_ROR = 1,
 296     I386_RCL = 2,
 297     I386_RCR = 3,
 298     I386_SHL = 4,
 299     I386_SHR = 5,
 300     I386_SAR = 7,
 301     I386_NSHIFT = 8
 302 } I386_Shift_Opcode;
 303
 304 typedef enum {
 305     I386_CC_O = 0,
 306     I386_CC_NO = 1,
 307     I386_CC_B = 2, I386_CC_C = 2, I386_CC_NAE = 2,
 308     I386_CC_BE = 6, I386_CC_NA = 6,
 309     I386_CC_AE = 3, I386_CC_NB = 3, I386_CC_NC = 3,
 310     I386_CC_E = 4, I386_CC_Z = 4,
 311     I386_CC_NE = 5, I386_CC_NZ = 5,
 312     I386_CC_A = 7, I386_CC_NBE = 7,
 313     I386_CC_S = 8, I386_CC_LZ = 8,
 314     I386_CC_NS = 9, I386_CC_GEZ = 9,
 315     I386_CC_P = 0x0a, I386_CC_PE = 0x0a,
 316     I386_CC_NP = 0x0b, I386_CC_PO = 0x0b,
 317     I386_CC_L = 0x0c, I386_CC_NGE = 0x0c,
 318     I386_CC_GE = 0x0d, I386_CC_NL = 0x0d,
 319     I386_CC_LE = 0x0e, I386_CC_NG = 0x0e,
 320     I386_CC_G = 0x0f, I386_CC_NLE = 0x0f,
 321     I386_NCC
 322 } I386_CC;
 323
 324
 325 /* modrm and stuff */
 326
 327 #define i386_address_byte(mod, reg, rm) \
 328     *(mcodeptr++) = ((((mod) & 0x03) << 6) | (((reg) & 0x07) << 3) | (((rm) & 0x07)));
 329
 330
 331 #define i386_emit_reg(reg,rm) \
 332     i386_address_byte(3,(reg),(rm));
 333
 334
 335 #define i386_is_imm8(imm) \
 336     (((int)(imm) >= -128 && (int)(imm) <= 127))
 337
 338
 339 #define i386_emit_imm8(imm) \
 340     *(mcodeptr++) = (u1) ((imm) & 0xff);
 341
 342
 343 #define i386_emit_imm16(imm) \
 344     do { \
 345         imm_union imb; \
 346         imb.i = (int) (imm); \
 347         *(mcodeptr++) = imb.b[0]; \
 348         *(mcodeptr++) = imb.b[1]; \
 349     } while (0)
 350
 351
 352 #define i386_emit_imm32(imm) \
 353     do { \
 354         imm_union imb; \
 355         imb.i = (int) (imm); \
 356         *(mcodeptr++) = imb.b[0]; \
 357         *(mcodeptr++) = imb.b[1]; \
 358         *(mcodeptr++) = imb.b[2]; \
 359         *(mcodeptr++) = imb.b[3]; \
 360     } while (0)
 361
 362
 363 #define i386_emit_mem(r,mem) \
 364     do { \
 365         i386_address_byte(0,(r),5); \
 366         i386_emit_imm32((mem)); \
 367     } while (0)
 368
 369
 370 #define i386_emit_membase(basereg,disp,dreg) \
 371     do { \
 372         if ((basereg) == ESP) { \
 373             if ((disp) == 0) { \
 374                 i386_address_byte(0, (dreg), ESP); \
 375                 i386_address_byte(0, ESP, ESP); \
 376             } else if (i386_is_imm8((disp))) { \
 377                 i386_address_byte(1, (dreg), ESP); \
 378                 i386_address_byte(0, ESP, ESP); \
 379                 i386_emit_imm8((disp)); \
 380             } else { \
 381                 i386_address_byte(2, (dreg), ESP); \
 382                 i386_address_byte(0, ESP, ESP); \
 383                 i386_emit_imm32((disp)); \
 384             } \
 385             break; \
 386         } \
 387         \
 388         if ((disp) == 0 && (basereg) != EBP) { \
 389             i386_address_byte(0, (dreg), (basereg)); \
 390             break; \
 391         } \
 392         \
 393         if (i386_is_imm8((disp))) { \
 394             i386_address_byte(1, (dreg), (basereg)); \
 395             i386_emit_imm8((disp)); \
 396         } else { \
 397             i386_address_byte(2, (dreg), (basereg)); \
 398             i386_emit_imm32((disp)); \
 399         } \
 400     } while (0)
 401
 402
 403 #define i386_emit_memindex(reg,disp,basereg,indexreg,scale) \
 404     do { \
 405         if ((basereg) == -1) { \
 406             i386_address_byte(0, (reg), 4); \
 407             i386_address_byte((scale), (indexreg), 5); \
 408             i386_emit_imm32((disp)); \
 409         \
 410         } else if ((disp) == 0 && (basereg) != EBP) { \
 411             i386_address_byte(0, (reg), 4); \
 412             i386_address_byte((scale), (indexreg), (basereg)); \
 413         \
 414         } else if (i386_is_imm8((disp))) { \
 415             i386_address_byte(1, (reg), 4); \
 416             i386_address_byte((scale), (indexreg), (basereg)); \
 417             i386_emit_imm8 ((disp)); \
 418         \
 419         } else { \
 420             i386_address_byte(2, (reg), 4); \
 421             i386_address_byte((scale), (indexreg), (basereg)); \
 422             i386_emit_imm32((disp)); \
 423         }    \
 424      } while (0)
 425
 426
 427 /* function gen_resolvebranch **************************************************
 428
 429     backpatches a branch instruction
 430
 431     parameters: ip ... pointer to instruction after branch (void*)
 432                 so ... offset of instruction after branch  (s4)
 433                 to ... offset of branch target             (s4)
 434
 435 *******************************************************************************/
 436
 437 #define gen_resolvebranch(ip,so,to) \
 438     *((void **) ((ip) - 4)) = (void **) ((to) - (so));
 439
 440
 441 /* function prototypes */
 442
 443 void codegen_init();
 444 void *codegen_findmethod(void *pc);
 445 void init_exceptions();
 446 void codegen();
 447 void codegen_close();
 448 void dseg_display(s4 *s4ptr);
 449 void thread_restartcriticalsection(ucontext_t*);
 450
 451 #endif /* _CODEGEN_H */
 452
 453
 454 /*
 455  * These are local overrides for various environment variables in Emacs.
 456  * Please do not remove this and leave it at the end of the file, where
 457  * Emacs will automagically detect them.
 458  * ---------------------------------------------------------------------
 459  * Local variables:
 460  * mode: c
 461  * indent-tabs-mode: t
 462  * c-basic-offset: 4
 463  * tab-width: 4
 464  * End:
 465  */