src/lj_ir.h

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