src/lj_ir.h

   1 /*
   2 ** SSA IR (Intermediate Representation) format.
   3 ** Copyright (C) 2005-2013 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #ifndef _LJ_IR_H
   7 #define _LJ_IR_H
   8
   9 #include "lj_obj.h"
  10
  11 /* -- IR instructions ----------------------------------------------------- */
  12
  13 /* IR instruction definition. Order matters, see below. ORDER IR */
  14 #define IRDEF(_) \
  15   /* Guarded assertions. */ \
  16   /* Must be properly aligned to flip opposites (^1) and (un)ordered (^4). */ \
  17   _(LT,         N , ref, ref) \
  18   _(GE,         N , ref, ref) \
  19   _(LE,         N , ref, ref) \
  20   _(GT,         N , ref, ref) \
  21   \
  22   _(ULT,        N , ref, ref) \
  23   _(UGE,        N , ref, ref) \
  24   _(ULE,        N , ref, ref) \
  25   _(UGT,        N , ref, ref) \
  26   \
  27   _(EQ,         C , ref, ref) \
  28   _(NE,         C , ref, ref) \
  29   \
  30   _(ABC,        N , ref, ref) \
  31   _(RETF,       S , ref, ref) \
  32   \
  33   /* Miscellaneous ops. */ \
  34   _(NOP,        N , ___, ___) \
  35   _(BASE,       N , lit, lit) \
  36   _(PVAL,       N , lit, ___) \
  37   _(GCSTEP,     S , ___, ___) \
  38   _(HIOP,       S , ref, ref) \
  39   _(LOOP,       S , ___, ___) \
  40   _(USE,        S , ref, ___) \
  41   _(PHI,        S , ref, ref) \
  42   _(RENAME,     S , ref, lit) \
  43   _(PROF,       S , ___, ___) \
  44   \
  45   /* Constants. */ \
  46   _(KPRI,       N , ___, ___) \
  47   _(KINT,       N , cst, ___) \
  48   _(KGC,        N , cst, ___) \
  49   _(KPTR,       N , cst, ___) \
  50   _(KKPTR,      N , cst, ___) \
  51   _(KNULL,      N , cst, ___) \
  52   _(KNUM,       N , cst, ___) \
  53   _(KINT64,     N , cst, ___) \
  54   _(KSLOT,      N , ref, lit) \
  55   \
  56   /* Bit ops. */ \
  57   _(BNOT,       N , ref, ___) \
  58   _(BSWAP,      N , ref, ___) \
  59   _(BAND,       C , ref, ref) \
  60   _(BOR,        C , ref, ref) \
  61   _(BXOR,       C , ref, ref) \
  62   _(BSHL,       N , ref, ref) \
  63   _(BSHR,       N , ref, ref) \
  64   _(BSAR,       N , ref, ref) \
  65   _(BROL,       N , ref, ref) \
  66   _(BROR,       N , ref, ref) \
  67   \
  68   /* Arithmetic ops. ORDER ARITH */ \
  69   _(ADD,        C , ref, ref) \
  70   _(SUB,        N , ref, ref) \
  71   _(MUL,        C , ref, ref) \
  72   _(DIV,        N , ref, ref) \
  73   _(MOD,        N , ref, ref) \
  74   _(POW,        N , ref, ref) \
  75   _(NEG,        N , ref, ref) \
  76   \
  77   _(ABS,        N , ref, ref) \
  78   _(ATAN2,      N , ref, ref) \
  79   _(LDEXP,      N , ref, ref) \
  80   _(MIN,        C , ref, ref) \
  81   _(MAX,        C , ref, ref) \
  82   _(FPMATH,     N , ref, lit) \
  83   \
  84   /* Overflow-checking arithmetic ops. */ \
  85   _(ADDOV,      CW, ref, ref) \
  86   _(SUBOV,      NW, ref, ref) \
  87   _(MULOV,      CW, ref, ref) \
  88   \
  89   /* Memory ops. A = array, H = hash, U = upvalue, F = field, S = stack. */ \
  90   \
  91   /* Memory references. */ \
  92   _(AREF,       R , ref, ref) \
  93   _(HREFK,      R , ref, ref) \
  94   _(HREF,       L , ref, ref) \
  95   _(NEWREF,     S , ref, ref) \
  96   _(UREFO,      LW, ref, lit) \
  97   _(UREFC,      LW, ref, lit) \
  98   _(FREF,       R , ref, lit) \
  99   _(STRREF,     N , ref, ref) \
 100   \
 101   /* Loads and Stores. These must be in the same order. */ \
 102   _(ALOAD,      L , ref, ___) \
 103   _(HLOAD,      L , ref, ___) \
 104   _(ULOAD,      L , ref, ___) \
 105   _(FLOAD,      L , ref, lit) \
 106   _(XLOAD,      L , ref, lit) \
 107   _(SLOAD,      L , lit, lit) \
 108   _(VLOAD,      L , ref, ___) \
 109   \
 110   _(ASTORE,     S , ref, ref) \
 111   _(HSTORE,     S , ref, ref) \
 112   _(USTORE,     S , ref, ref) \
 113   _(FSTORE,     S , ref, ref) \
 114   _(XSTORE,     S , ref, ref) \
 115   \
 116   /* Allocations. */ \
 117   _(SNEW,       N , ref, ref)  /* CSE is ok, not marked as A. */ \
 118   _(XSNEW,      A , ref, ref) \
 119   _(TNEW,       AW, lit, lit) \
 120   _(TDUP,       AW, ref, ___) \
 121   _(CNEW,       AW, ref, ref) \
 122   _(CNEWI,      NW, ref, ref)  /* CSE is ok, not marked as A. */ \
 123   \
 124   /* Buffer operations. */ \
 125   _(BUFHDR,     L , ref, lit) \
 126   _(BUFPUT,     L , ref, ref) \
 127   _(BUFSTR,     A , ref, ref) \
 128   \
 129   /* Barriers. */ \
 130   _(TBAR,       S , ref, ___) \
 131   _(OBAR,       S , ref, ref) \
 132   _(XBAR,       S , ___, ___) \
 133   \
 134   /* Type conversions. */ \
 135   _(CONV,       NW, ref, lit) \
 136   _(TOBIT,      N , ref, ref) \
 137   _(TOSTR,      N , ref, lit) \
 138   _(STRTO,      N , ref, ___) \
 139   \
 140   /* Calls. */ \
 141   _(CALLN,      N , ref, lit) \
 142   _(CALLA,      A , ref, lit) \
 143   _(CALLL,      L , ref, lit) \
 144   _(CALLS,      S , ref, lit) \
 145   _(CALLXS,     S , ref, ref) \
 146   _(CARG,       N , ref, ref) \
 147   \
 148   /* End of list. */
 149
 150 /* IR opcodes (max. 256). */
 151 typedef enum {
 152 #define IRENUM(name, m, m1, m2) IR_##name,
 153 IRDEF(IRENUM)
 154 #undef IRENUM
 155   IR__MAX
 156 } IROp;
 157
 158 /* Stored opcode. */
 159 typedef uint8_t IROp1;
 160
 161 LJ_STATIC_ASSERT(((int)IR_EQ^1) == (int)IR_NE);
 162 LJ_STATIC_ASSERT(((int)IR_LT^1) == (int)IR_GE);
 163 LJ_STATIC_ASSERT(((int)IR_LE^1) == (int)IR_GT);
 164 LJ_STATIC_ASSERT(((int)IR_LT^3) == (int)IR_GT);
 165 LJ_STATIC_ASSERT(((int)IR_LT^4) == (int)IR_ULT);
 166
 167 /* Delta between xLOAD and xSTORE. */
 168 #define IRDELTA_L2S             ((int)IR_ASTORE - (int)IR_ALOAD)
 169
 170 LJ_STATIC_ASSERT((int)IR_HLOAD + IRDELTA_L2S == (int)IR_HSTORE);
 171 LJ_STATIC_ASSERT((int)IR_ULOAD + IRDELTA_L2S == (int)IR_USTORE);
 172 LJ_STATIC_ASSERT((int)IR_FLOAD + IRDELTA_L2S == (int)IR_FSTORE);
 173 LJ_STATIC_ASSERT((int)IR_XLOAD + IRDELTA_L2S == (int)IR_XSTORE);
 174
 175 /* -- Named IR literals --------------------------------------------------- */
 176
 177 /* FPMATH sub-functions. ORDER FPM. */
 178 #define IRFPMDEF(_) \
 179   _(FLOOR) _(CEIL) _(TRUNC)  /* Must be first and in this order. */ \
 180   _(SQRT) _(EXP) _(EXP2) _(LOG) _(LOG2) _(LOG10) \
 181   _(SIN) _(COS) _(TAN) \
 182   _(OTHER)
 183
 184 typedef enum {
 185 #define FPMENUM(name)           IRFPM_##name,
 186 IRFPMDEF(FPMENUM)
 187 #undef FPMENUM
 188   IRFPM__MAX
 189 } IRFPMathOp;
 190
 191 /* FLOAD fields. */
 192 #define IRFLDEF(_) \
 193   _(STR_LEN,    offsetof(GCstr, len)) \
 194   _(FUNC_ENV,   offsetof(GCfunc, l.env)) \
 195   _(FUNC_PC,    offsetof(GCfunc, l.pc)) \
 196   _(TAB_META,   offsetof(GCtab, metatable)) \
 197   _(TAB_ARRAY,  offsetof(GCtab, array)) \
 198   _(TAB_NODE,   offsetof(GCtab, node)) \
 199   _(TAB_ASIZE,  offsetof(GCtab, asize)) \
 200   _(TAB_HMASK,  offsetof(GCtab, hmask)) \
 201   _(TAB_NOMM,   offsetof(GCtab, nomm)) \
 202   _(UDATA_META, offsetof(GCudata, metatable)) \
 203   _(UDATA_UDTYPE, offsetof(GCudata, udtype)) \
 204   _(UDATA_FILE, sizeof(GCudata)) \
 205   _(CDATA_CTYPEID, offsetof(GCcdata, ctypeid)) \
 206   _(CDATA_PTR,  sizeof(GCcdata)) \
 207   _(CDATA_INT, sizeof(GCcdata)) \
 208   _(CDATA_INT64, sizeof(GCcdata)) \
 209   _(CDATA_INT64_4, sizeof(GCcdata) + 4)
 210
 211 typedef enum {
 212 #define FLENUM(name, ofs)       IRFL_##name,
 213 IRFLDEF(FLENUM)
 214 #undef FLENUM
 215   IRFL__MAX
 216 } IRFieldID;
 217
 218 /* SLOAD mode bits, stored in op2. */
 219 #define IRSLOAD_PARENT          0x01    /* Coalesce with parent trace. */
 220 #define IRSLOAD_FRAME           0x02    /* Load hiword of frame. */
 221 #define IRSLOAD_TYPECHECK       0x04    /* Needs type check. */
 222 #define IRSLOAD_CONVERT         0x08    /* Number to integer conversion. */
 223 #define IRSLOAD_READONLY        0x10    /* Read-only, omit slot store. */
 224 #define IRSLOAD_INHERIT         0x20    /* Inherited by exits/side traces. */
 225
 226 /* XLOAD mode, stored in op2. */
 227 #define IRXLOAD_READONLY        1       /* Load from read-only data. */
 228 #define IRXLOAD_VOLATILE        2       /* Load from volatile data. */
 229 #define IRXLOAD_UNALIGNED       4       /* Unaligned load. */
 230
 231 /* BUFHDR mode, stored in op2. */
 232 #define IRBUFHDR_RESET          0       /* Reset buffer. */
 233 #define IRBUFHDR_APPEND         1       /* Append to buffer. */
 234
 235 /* CONV mode, stored in op2. */
 236 #define IRCONV_SRCMASK          0x001f  /* Source IRType. */
 237 #define IRCONV_DSTMASK          0x03e0  /* Dest. IRType (also in ir->t). */
 238 #define IRCONV_DSH              5
 239 #define IRCONV_NUM_INT          ((IRT_NUM<<IRCONV_DSH)|IRT_INT)
 240 #define IRCONV_INT_NUM          ((IRT_INT<<IRCONV_DSH)|IRT_NUM)
 241 #define IRCONV_SEXT             0x0800  /* Sign-extend integer to integer. */
 242 #define IRCONV_MODEMASK         0x0fff
 243 #define IRCONV_CONVMASK         0xf000
 244 #define IRCONV_CSH              12
 245 /* Number to integer conversion mode. Ordered by strength of the checks. */
 246 #define IRCONV_TOBIT  (0<<IRCONV_CSH)   /* None. Cache only: TOBIT conv. */
 247 #define IRCONV_ANY    (1<<IRCONV_CSH)   /* Any FP number is ok. */
 248 #define IRCONV_INDEX  (2<<IRCONV_CSH)   /* Check + special backprop rules. */
 249 #define IRCONV_CHECK  (3<<IRCONV_CSH)   /* Number checked for integerness. */
 250
 251 /* TOSTR mode, stored in op2. */
 252 #define IRTOSTR_INT             0       /* Convert integer to string. */
 253 #define IRTOSTR_NUM             1       /* Convert number to string. */
 254 #define IRTOSTR_CHAR            2       /* Convert char value to string. */
 255
 256 /* -- IR operands --------------------------------------------------------- */
 257
 258 /* IR operand mode (2 bit). */
 259 typedef enum {
 260   IRMref,               /* IR reference. */
 261   IRMlit,               /* 16 bit unsigned literal. */
 262   IRMcst,               /* Constant literal: i, gcr or ptr. */
 263   IRMnone               /* Unused operand. */
 264 } IRMode;
 265 #define IRM___          IRMnone
 266
 267 /* Mode bits: Commutative, {Normal/Ref, Alloc, Load, Store}, Non-weak guard. */
 268 #define IRM_C                   0x10
 269
 270 #define IRM_N                   0x00
 271 #define IRM_R                   IRM_N
 272 #define IRM_A                   0x20
 273 #define IRM_L                   0x40
 274 #define IRM_S                   0x60
 275
 276 #define IRM_W                   0x80
 277
 278 #define IRM_NW                  (IRM_N|IRM_W)
 279 #define IRM_CW                  (IRM_C|IRM_W)
 280 #define IRM_AW                  (IRM_A|IRM_W)
 281 #define IRM_LW                  (IRM_L|IRM_W)
 282
 283 #define irm_op1(m)              ((IRMode)((m)&3))
 284 #define irm_op2(m)              ((IRMode)(((m)>>2)&3))
 285 #define irm_iscomm(m)           ((m) & IRM_C)
 286 #define irm_kind(m)             ((m) & IRM_S)
 287
 288 #define IRMODE(name, m, m1, m2) (((IRM##m1)|((IRM##m2)<<2)|(IRM_##m))^IRM_W),
 289
 290 LJ_DATA const uint8_t lj_ir_mode[IR__MAX+1];
 291
 292 /* -- IR instruction types ------------------------------------------------ */
 293
 294 /* Map of itypes to non-negative numbers. ORDER LJ_T.
 295 ** LJ_TUPVAL/LJ_TTRACE never appear in a TValue. Use these itypes for
 296 ** IRT_P32 and IRT_P64, which never escape the IR.
 297 ** The various integers are only used in the IR and can only escape to
 298 ** a TValue after implicit or explicit conversion. Their types must be
 299 ** contiguous and next to IRT_NUM (see the typerange macros below).
 300 */
 301 #define IRTDEF(_) \
 302   _(NIL, 4) _(FALSE, 4) _(TRUE, 4) _(LIGHTUD, LJ_64 ? 8 : 4) _(STR, 4) \
 303   _(P32, 4) _(THREAD, 4) _(PROTO, 4) _(FUNC, 4) _(P64, 8) _(CDATA, 4) \
 304   _(TAB, 4) _(UDATA, 4) \
 305   _(FLOAT, 4) _(NUM, 8) _(I8, 1) _(U8, 1) _(I16, 2) _(U16, 2) \
 306   _(INT, 4) _(U32, 4) _(I64, 8) _(U64, 8) \
 307   _(SOFTFP, 4)  /* There is room for 9 more types. */
 308
 309 /* IR result type and flags (8 bit). */
 310 typedef enum {
 311 #define IRTENUM(name, size)     IRT_##name,
 312 IRTDEF(IRTENUM)
 313 #undef IRTENUM
 314   IRT__MAX,
 315
 316   /* Native pointer type and the corresponding integer type. */
 317   IRT_PTR = LJ_64 ? IRT_P64 : IRT_P32,
 318   IRT_INTP = LJ_64 ? IRT_I64 : IRT_INT,
 319   IRT_UINTP = LJ_64 ? IRT_U64 : IRT_U32,
 320
 321   /* Additional flags. */
 322   IRT_MARK = 0x20,      /* Marker for misc. purposes. */
 323   IRT_ISPHI = 0x40,     /* Instruction is left or right PHI operand. */
 324   IRT_GUARD = 0x80,     /* Instruction is a guard. */
 325
 326   /* Masks. */
 327   IRT_TYPE = 0x1f,
 328   IRT_T = 0xff
 329 } IRType;
 330
 331 #define irtype_ispri(irt)       ((uint32_t)(irt) <= IRT_TRUE)
 332
 333 /* Stored IRType. */
 334 typedef struct IRType1 { uint8_t irt; } IRType1;
 335
 336 #define IRT(o, t)               ((uint32_t)(((o)<<8) | (t)))
 337 #define IRTI(o)                 (IRT((o), IRT_INT))
 338 #define IRTN(o)                 (IRT((o), IRT_NUM))
 339 #define IRTG(o, t)              (IRT((o), IRT_GUARD|(t)))
 340 #define IRTGI(o)                (IRT((o), IRT_GUARD|IRT_INT))
 341
 342 #define irt_t(t)                ((IRType)(t).irt)
 343 #define irt_type(t)             ((IRType)((t).irt & IRT_TYPE))
 344 #define irt_sametype(t1, t2)    ((((t1).irt ^ (t2).irt) & IRT_TYPE) == 0)
 345 #define irt_typerange(t, first, last) \
 346   ((uint32_t)((t).irt & IRT_TYPE) - (uint32_t)(first) <= (uint32_t)(last-first))
 347
 348 #define irt_isnil(t)            (irt_type(t) == IRT_NIL)
 349 #define irt_ispri(t)            ((uint32_t)irt_type(t) <= IRT_TRUE)
 350 #define irt_islightud(t)        (irt_type(t) == IRT_LIGHTUD)
 351 #define irt_isstr(t)            (irt_type(t) == IRT_STR)
 352 #define irt_istab(t)            (irt_type(t) == IRT_TAB)
 353 #define irt_iscdata(t)          (irt_type(t) == IRT_CDATA)
 354 #define irt_isfloat(t)          (irt_type(t) == IRT_FLOAT)
 355 #define irt_isnum(t)            (irt_type(t) == IRT_NUM)
 356 #define irt_isint(t)            (irt_type(t) == IRT_INT)
 357 #define irt_isi8(t)             (irt_type(t) == IRT_I8)
 358 #define irt_isu8(t)             (irt_type(t) == IRT_U8)
 359 #define irt_isi16(t)            (irt_type(t) == IRT_I16)
 360 #define irt_isu16(t)            (irt_type(t) == IRT_U16)
 361 #define irt_isu32(t)            (irt_type(t) == IRT_U32)
 362 #define irt_isi64(t)            (irt_type(t) == IRT_I64)
 363 #define irt_isu64(t)            (irt_type(t) == IRT_U64)
 364
 365 #define irt_isfp(t)             (irt_isnum(t) || irt_isfloat(t))
 366 #define irt_isinteger(t)        (irt_typerange((t), IRT_I8, IRT_INT))
 367 #define irt_isgcv(t)            (irt_typerange((t), IRT_STR, IRT_UDATA))
 368 #define irt_isaddr(t)           (irt_typerange((t), IRT_LIGHTUD, IRT_UDATA))
 369 #define irt_isint64(t)          (irt_typerange((t), IRT_I64, IRT_U64))
 370
 371 #if LJ_64
 372 #define IRT_IS64 \
 373   ((1u<<IRT_NUM)|(1u<<IRT_I64)|(1u<<IRT_U64)|(1u<<IRT_P64)|(1u<<IRT_LIGHTUD))
 374 #else
 375 #define IRT_IS64 \
 376   ((1u<<IRT_NUM)|(1u<<IRT_I64)|(1u<<IRT_U64))
 377 #endif
 378
 379 #define irt_is64(t)             ((IRT_IS64 >> irt_type(t)) & 1)
 380 #define irt_is64orfp(t)         (((IRT_IS64|(1u<<IRT_FLOAT))>>irt_type(t)) & 1)
 381
 382 #define irt_size(t)             (lj_ir_type_size[irt_t((t))])
 383
 384 LJ_DATA const uint8_t lj_ir_type_size[];
 385
 386 static LJ_AINLINE IRType itype2irt(const TValue *tv)
 387 {
 388   if (tvisint(tv))
 389     return IRT_INT;
 390   else if (tvisnum(tv))
 391     return IRT_NUM;
 392 #if LJ_64
 393   else if (tvislightud(tv))
 394     return IRT_LIGHTUD;
 395 #endif
 396   else
 397     return (IRType)~itype(tv);
 398 }
 399
 400 static LJ_AINLINE uint32_t irt_toitype_(IRType t)
 401 {
 402   lua_assert(!LJ_64 || t != IRT_LIGHTUD);
 403   if (LJ_DUALNUM && t > IRT_NUM) {
 404     return LJ_TISNUM;
 405   } else {
 406     lua_assert(t <= IRT_NUM);
 407     return ~(uint32_t)t;
 408   }
 409 }
 410
 411 #define irt_toitype(t)          irt_toitype_(irt_type((t)))
 412
 413 #define irt_isguard(t)          ((t).irt & IRT_GUARD)
 414 #define irt_ismarked(t)         ((t).irt & IRT_MARK)
 415 #define irt_setmark(t)          ((t).irt |= IRT_MARK)
 416 #define irt_clearmark(t)        ((t).irt &= ~IRT_MARK)
 417 #define irt_isphi(t)            ((t).irt & IRT_ISPHI)
 418 #define irt_setphi(t)           ((t).irt |= IRT_ISPHI)
 419 #define irt_clearphi(t)         ((t).irt &= ~IRT_ISPHI)
 420
 421 /* Stored combined IR opcode and type. */
 422 typedef uint16_t IROpT;
 423
 424 /* -- IR references ------------------------------------------------------- */
 425
 426 /* IR references. */
 427 typedef uint16_t IRRef1;        /* One stored reference. */
 428 typedef uint32_t IRRef2;        /* Two stored references. */
 429 typedef uint32_t IRRef;         /* Used to pass around references. */
 430
 431 /* Fixed references. */
 432 enum {
 433   REF_BIAS =    0x8000,
 434   REF_TRUE =    REF_BIAS-3,
 435   REF_FALSE =   REF_BIAS-2,
 436   REF_NIL =     REF_BIAS-1,     /* \--- Constants grow downwards. */
 437   REF_BASE =    REF_BIAS,       /* /--- IR grows upwards. */
 438   REF_FIRST =   REF_BIAS+1,
 439   REF_DROP =    0xffff
 440 };
 441
 442 /* Note: IRMlit operands must be < REF_BIAS, too!
 443 ** This allows for fast and uniform manipulation of all operands
 444 ** without looking up the operand mode in lj_ir_mode:
 445 ** - CSE calculates the maximum reference of two operands.
 446 **   This must work with mixed reference/literal operands, too.
 447 ** - DCE marking only checks for operand >= REF_BIAS.
 448 ** - LOOP needs to substitute reference operands.
 449 **   Constant references and literals must not be modified.
 450 */
 451
 452 #define IRREF2(lo, hi)          ((IRRef2)(lo) | ((IRRef2)(hi) << 16))
 453
 454 #define irref_isk(ref)          ((ref) < REF_BIAS)
 455
 456 /* Tagged IR references (32 bit).
 457 **
 458 ** +-------+-------+---------------+
 459 ** |  irt  | flags |      ref      |
 460 ** +-------+-------+---------------+
 461 **
 462 ** The tag holds a copy of the IRType and speeds up IR type checks.
 463 */
 464 typedef uint32_t TRef;
 465
 466 #define TREF_REFMASK            0x0000ffff
 467 #define TREF_FRAME              0x00010000
 468 #define TREF_CONT               0x00020000
 469
 470 #define TREF(ref, t)            ((TRef)((ref) + ((t)<<24)))
 471
 472 #define tref_ref(tr)            ((IRRef1)(tr))
 473 #define tref_t(tr)              ((IRType)((tr)>>24))
 474 #define tref_type(tr)           ((IRType)(((tr)>>24) & IRT_TYPE))
 475 #define tref_typerange(tr, first, last) \
 476   ((((tr)>>24) & IRT_TYPE) - (TRef)(first) <= (TRef)(last-first))
 477
 478 #define tref_istype(tr, t)      (((tr) & (IRT_TYPE<<24)) == ((t)<<24))
 479 #define tref_isnil(tr)          (tref_istype((tr), IRT_NIL))
 480 #define tref_isfalse(tr)        (tref_istype((tr), IRT_FALSE))
 481 #define tref_istrue(tr)         (tref_istype((tr), IRT_TRUE))
 482 #define tref_isstr(tr)          (tref_istype((tr), IRT_STR))
 483 #define tref_isfunc(tr)         (tref_istype((tr), IRT_FUNC))
 484 #define tref_iscdata(tr)        (tref_istype((tr), IRT_CDATA))
 485 #define tref_istab(tr)          (tref_istype((tr), IRT_TAB))
 486 #define tref_isudata(tr)        (tref_istype((tr), IRT_UDATA))
 487 #define tref_isnum(tr)          (tref_istype((tr), IRT_NUM))
 488 #define tref_isint(tr)          (tref_istype((tr), IRT_INT))
 489
 490 #define tref_isbool(tr)         (tref_typerange((tr), IRT_FALSE, IRT_TRUE))
 491 #define tref_ispri(tr)          (tref_typerange((tr), IRT_NIL, IRT_TRUE))
 492 #define tref_istruecond(tr)     (!tref_typerange((tr), IRT_NIL, IRT_FALSE))
 493 #define tref_isinteger(tr)      (tref_typerange((tr), IRT_I8, IRT_INT))
 494 #define tref_isnumber(tr)       (tref_typerange((tr), IRT_NUM, IRT_INT))
 495 #define tref_isnumber_str(tr)   (tref_isnumber((tr)) || tref_isstr((tr)))
 496 #define tref_isgcv(tr)          (tref_typerange((tr), IRT_STR, IRT_UDATA))
 497
 498 #define tref_isk(tr)            (irref_isk(tref_ref((tr))))
 499 #define tref_isk2(tr1, tr2)     (irref_isk(tref_ref((tr1) | (tr2))))
 500
 501 #define TREF_PRI(t)             (TREF(REF_NIL-(t), (t)))
 502 #define TREF_NIL                (TREF_PRI(IRT_NIL))
 503 #define TREF_FALSE              (TREF_PRI(IRT_FALSE))
 504 #define TREF_TRUE               (TREF_PRI(IRT_TRUE))
 505
 506 /* -- IR format ----------------------------------------------------------- */
 507
 508 /* IR instruction format (64 bit).
 509 **
 510 **    16      16     8   8   8   8
 511 ** +-------+-------+---+---+---+---+
 512 ** |  op1  |  op2  | t | o | r | s |
 513 ** +-------+-------+---+---+---+---+
 514 ** |  op12/i/gco   |   ot  | prev  | (alternative fields in union)
 515 ** +---------------+-------+-------+
 516 **        32           16      16
 517 **
 518 ** prev is only valid prior to register allocation and then reused for r + s.
 519 */
 520
 521 typedef union IRIns {
 522   struct {
 523     LJ_ENDIAN_LOHI(
 524       IRRef1 op1;       /* IR operand 1. */
 525     , IRRef1 op2;       /* IR operand 2. */
 526     )
 527     IROpT ot;           /* IR opcode and type (overlaps t and o). */
 528     IRRef1 prev;        /* Previous ins in same chain (overlaps r and s). */
 529   };
 530   struct {
 531     IRRef2 op12;        /* IR operand 1 and 2 (overlaps op1 and op2). */
 532     LJ_ENDIAN_LOHI(
 533       IRType1 t;        /* IR type. */
 534     , IROp1 o;          /* IR opcode. */
 535     )
 536     LJ_ENDIAN_LOHI(
 537       uint8_t r;        /* Register allocation (overlaps prev). */
 538     , uint8_t s;        /* Spill slot allocation (overlaps prev). */
 539     )
 540   };
 541   int32_t i;            /* 32 bit signed integer literal (overlaps op12). */
 542   GCRef gcr;            /* GCobj constant (overlaps op12). */
 543   MRef ptr;             /* Pointer constant (overlaps op12). */
 544 } IRIns;
 545
 546 #define ir_kgc(ir)      check_exp((ir)->o == IR_KGC, gcref((ir)->gcr))
 547 #define ir_kstr(ir)     (gco2str(ir_kgc((ir))))
 548 #define ir_ktab(ir)     (gco2tab(ir_kgc((ir))))
 549 #define ir_kfunc(ir)    (gco2func(ir_kgc((ir))))
 550 #define ir_kcdata(ir)   (gco2cd(ir_kgc((ir))))
 551 #define ir_knum(ir)     check_exp((ir)->o == IR_KNUM, mref((ir)->ptr, cTValue))
 552 #define ir_kint64(ir)   check_exp((ir)->o == IR_KINT64, mref((ir)->ptr,cTValue))
 553 #define ir_k64(ir) \
 554   check_exp((ir)->o == IR_KNUM || (ir)->o == IR_KINT64, mref((ir)->ptr,cTValue))
 555 #define ir_kptr(ir) \
 556   check_exp((ir)->o == IR_KPTR || (ir)->o == IR_KKPTR, mref((ir)->ptr, void))
 557
 558 /* A store or any other op with a non-weak guard has a side-effect. */
 559 static LJ_AINLINE int ir_sideeff(IRIns *ir)
 560 {
 561   return (((ir->t.irt | ~IRT_GUARD) & lj_ir_mode[ir->o]) >= IRM_S);
 562 }
 563
 564 LJ_STATIC_ASSERT((int)IRT_GUARD == (int)IRM_W);
 565
 566 #endif