One Level Up Top Level

src/lj_ir.h - luajit-2.0-src

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** SSA IR (Intermediate Representation) format.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. #ifndef _LJ_IR_H
  7. ‌#define _LJ_IR_H

  9. #include "lj_obj.h"

  11. /* -- IR instructions ----------------------------------------------------- */

  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.   _(LREF,        L , ___, ___) \
  101.   \
  102.   /* Loads and Stores. These must be in the same order. */ \
  103.   _(ALOAD,        L , ref, ___) \
  104.   _(HLOAD,        L , ref, ___) \
  105.   _(ULOAD,        L , ref, ___) \
  106.   _(FLOAD,        L , ref, lit) \
  107.   _(XLOAD,        L , ref, lit) \
  108.   _(SLOAD,        L , lit, lit) \
  109.   _(VLOAD,        L , ref, ___) \
  110.   \
  111.   _(ASTORE,        S , ref, ref) \
  112.   _(HSTORE,        S , ref, ref) \
  113.   _(USTORE,        S , ref, ref) \
  114.   _(FSTORE,        S , ref, ref) \
  115.   _(XSTORE,        S , ref, ref) \
  116.   \
  117.   /* Allocations. */ \
  118.   _(SNEW,        N , ref, ref)  /* CSE is ok, not marked as A. */ \
  119.   _(XSNEW,        A , ref, ref) \
  120.   _(TNEW,        AW, lit, lit) \
  121.   _(TDUP,        AW, ref, ___) \
  122.   _(CNEW,        AW, ref, ref) \
  123.   _(CNEWI,        NW, ref, ref)  /* CSE is ok, not marked as A. */ \
  124.   \
  125.   /* Buffer operations. */ \
  126.   _(BUFHDR,        L , ref, lit) \
  127.   _(BUFPUT,        L , ref, ref) \
  128.   _(BUFSTR,        A , ref, ref) \
  129.   \
  130.   /* Barriers. */ \
  131.   _(TBAR,        S , ref, ___) \
  132.   _(OBAR,        S , ref, ref) \
  133.   _(XBAR,        S , ___, ___) \
  134.   \
  135.   /* Type conversions. */ \
  136.   _(CONV,        NW, ref, lit) \
  137.   _(TOBIT,        N , ref, ref) \
  138.   _(TOSTR,        N , ref, lit) \
  139.   _(STRTO,        N , ref, ___) \
  140.   \
  141.   /* Calls. */ \
  142.   _(CALLN,        N , ref, lit) \
  143.   _(CALLA,        A , ref, lit) \
  144.   _(CALLL,        L , ref, lit) \
  145.   _(CALLS,        S , ref, lit) \
  146.   _(CALLXS,        S , ref, ref) \
  147.   _(CARG,        N , ref, ref) \
  148.   \
  149.   /* End of list. */

  151. /* IR opcodes (max. 256). */
  152. typedef enum {
  153. ‌#define IRENUM(name, m, m1, m2)        IR_##name,
  154. IRDEF(IRENUM)
  155. ‌#undef IRENUM
  156.   IR__MAX
  157. ‌} IROp;

  159. /* Stored opcode. */
  160. ‌typedef uint8_t IROp1;

  162. LJ_STATIC_ASSERT(((int)IR_EQ^1) == (int)IR_NE);
  163. LJ_STATIC_ASSERT(((int)IR_LT^1) == (int)IR_GE);
  164. LJ_STATIC_ASSERT(((int)IR_LE^1) == (int)IR_GT);
  165. LJ_STATIC_ASSERT(((int)IR_LT^3) == (int)IR_GT);
  166. LJ_STATIC_ASSERT(((int)IR_LT^4) == (int)IR_ULT);

  168. /* Delta between xLOAD and xSTORE. */
  169. ‌#define IRDELTA_L2S                ((int)IR_ASTORE - (int)IR_ALOAD)

  171. LJ_STATIC_ASSERT((int)IR_HLOAD + IRDELTA_L2S == (int)IR_HSTORE);
  172. LJ_STATIC_ASSERT((int)IR_ULOAD + IRDELTA_L2S == (int)IR_USTORE);
  173. LJ_STATIC_ASSERT((int)IR_FLOAD + IRDELTA_L2S == (int)IR_FSTORE);
  174. LJ_STATIC_ASSERT((int)IR_XLOAD + IRDELTA_L2S == (int)IR_XSTORE);

  176. /* -- Named IR literals --------------------------------------------------- */

  178. /* FPMATH sub-functions. ORDER FPM. */
  179. ‌#define IRFPMDEF(_) \
  180.   _(FLOOR) _(CEIL) _(TRUNC)  /* Must be first and in this order. */ \
  181.   _(SQRT) _(EXP) _(EXP2) _(LOG) _(LOG2) _(LOG10) \
  182.   _(SIN) _(COS) _(TAN) \
  183.   _(OTHER)

  185. typedef enum {
  186. ‌#define FPMENUM(name)                IRFPM_##name,
  187. IRFPMDEF(FPMENUM)
  188. ‌#undef FPMENUM
  189.   IRFPM__MAX
  190. ‌} IRFPMathOp;

  192. /* FLOAD fields. */
  193. ‌#define IRFLDEF(_) \
  194.   _(STR_LEN,        offsetof(GCstr, len)) \
  195.   _(FUNC_ENV,        offsetof(GCfunc, l.env)) \
  196.   _(FUNC_PC,        offsetof(GCfunc, l.pc)) \
  197.   _(FUNC_FFID,        offsetof(GCfunc, l.ffid)) \
  198.   _(THREAD_ENV,        offsetof(lua_State, env)) \
  199.   _(TAB_META,        offsetof(GCtab, metatable)) \
  200.   _(TAB_ARRAY,        offsetof(GCtab, array)) \
  201.   _(TAB_NODE,        offsetof(GCtab, node)) \
  202.   _(TAB_ASIZE,        offsetof(GCtab, asize)) \
  203.   _(TAB_HMASK,        offsetof(GCtab, hmask)) \
  204.   _(TAB_NOMM,        offsetof(GCtab, nomm)) \
  205.   _(UDATA_META,        offsetof(GCudata, metatable)) \
  206.   _(UDATA_UDTYPE, offsetof(GCudata, udtype)) \
  207.   _(UDATA_FILE,        sizeof(GCudata)) \
  208.   _(CDATA_CTYPEID, offsetof(GCcdata, ctypeid)) \
  209.   _(CDATA_PTR,        sizeof(GCcdata)) \
  210.   _(CDATA_INT, sizeof(GCcdata)) \
  211.   _(CDATA_INT64, sizeof(GCcdata)) \
  212.   _(CDATA_INT64_4, sizeof(GCcdata) + 4)

  214. typedef enum {
  215. ‌#define FLENUM(name, ofs)        IRFL_##name,
  216. IRFLDEF(FLENUM)
  217. ‌#undef FLENUM
  218.   IRFL__MAX
  219. ‌} IRFieldID;

  221. /* SLOAD mode bits, stored in op2. */
  222. ‌#define IRSLOAD_PARENT                0x01        /* Coalesce with parent trace. */
  223. ‌#define IRSLOAD_FRAME                0x02        /* Load hiword of frame. */
  224. ‌#define IRSLOAD_TYPECHECK        0x04        /* Needs type check. */
  225. ‌#define IRSLOAD_CONVERT                0x08        /* Number to integer conversion. */
  226. ‌#define IRSLOAD_READONLY        0x10        /* Read-only, omit slot store. */
  227. ‌#define IRSLOAD_INHERIT                0x20        /* Inherited by exits/side traces. */

  229. /* XLOAD mode, stored in op2. */
  230. ‌#define IRXLOAD_READONLY        1        /* Load from read-only data. */
  231. ‌#define IRXLOAD_VOLATILE        2        /* Load from volatile data. */
  232. ‌#define IRXLOAD_UNALIGNED        4        /* Unaligned load. */

  234. /* BUFHDR mode, stored in op2. */
  235. ‌#define IRBUFHDR_RESET                0        /* Reset buffer. */
  236. ‌#define IRBUFHDR_APPEND                1        /* Append to buffer. */

  238. /* CONV mode, stored in op2. */
  239. ‌#define IRCONV_SRCMASK                0x001f        /* Source IRType. */
  240. ‌#define IRCONV_DSTMASK                0x03e0        /* Dest. IRType (also in ir->t). */
  241. ‌#define IRCONV_DSH                5
  242. ‌#define IRCONV_NUM_INT                ((IRT_NUM<<IRCONV_DSH)|IRT_INT)
  243. ‌#define IRCONV_INT_NUM                ((IRT_INT<<IRCONV_DSH)|IRT_NUM)
  244. ‌#define IRCONV_SEXT                0x0800        /* Sign-extend integer to integer. */
  245. ‌#define IRCONV_MODEMASK                0x0fff
  246. ‌#define IRCONV_CONVMASK                0xf000
  247. ‌#define IRCONV_CSH                12
  248. /* Number to integer conversion mode. Ordered by strength of the checks. */
  249. ‌#define IRCONV_TOBIT  (0<<IRCONV_CSH)        /* None. Cache only: TOBIT conv. */
  250. ‌#define IRCONV_ANY    (1<<IRCONV_CSH)        /* Any FP number is ok. */
  251. ‌#define IRCONV_INDEX  (2<<IRCONV_CSH)        /* Check + special backprop rules. */
  252. ‌#define IRCONV_CHECK  (3<<IRCONV_CSH)        /* Number checked for integerness. */

  254. /* TOSTR mode, stored in op2. */
  255. ‌#define IRTOSTR_INT                0        /* Convert integer to string. */
  256. ‌#define IRTOSTR_NUM                1        /* Convert number to string. */
  257. ‌#define IRTOSTR_CHAR                2        /* Convert char value to string. */

  259. /* -- IR operands --------------------------------------------------------- */

  261. /* IR operand mode (2 bit). */
  262. typedef enum {
  263.   IRMref,                /* IR reference. */
  264.   IRMlit,                /* 16 bit unsigned literal. */
  265.   IRMcst,                /* Constant literal: i, gcr or ptr. */
  266.   IRMnone                /* Unused operand. */
  267. ‌} IRMode;
  268. ‌#define IRM___                IRMnone

  270. /* Mode bits: Commutative, {Normal/Ref, Alloc, Load, Store}, Non-weak guard. */
  271. ‌#define IRM_C                        0x10

  273. ‌#define IRM_N                        0x00
  274. ‌#define IRM_R                        IRM_N
  275. ‌#define IRM_A                        0x20
  276. ‌#define IRM_L                        0x40
  277. ‌#define IRM_S                        0x60

  279. ‌#define IRM_W                        0x80

  281. ‌#define IRM_NW                        (IRM_N|IRM_W)
  282. ‌#define IRM_CW                        (IRM_C|IRM_W)
  283. ‌#define IRM_AW                        (IRM_A|IRM_W)
  284. ‌#define IRM_LW                        (IRM_L|IRM_W)

  286. ‌#define irm_op1(m)                ((IRMode)((m)&3))
  287. ‌#define irm_op2(m)                ((IRMode)(((m)>>2)&3))
  288. ‌#define irm_iscomm(m)                ((m) & IRM_C)
  289. ‌#define irm_kind(m)                ((m) & IRM_S)

  291. ‌#define IRMODE(name, m, m1, m2)        (((IRM##m1)|((IRM##m2)<<2)|(IRM_##m))^IRM_W),

  293. ‌LJ_DATA const uint8_t lj_ir_mode[IR__MAX+1];

  295. /* -- IR instruction types ------------------------------------------------ */

  297. /* Map of itypes to non-negative numbers. ORDER LJ_T.
  298. ** LJ_TUPVAL/LJ_TTRACE never appear in a TValue. Use these itypes for
  299. ** IRT_P32 and IRT_P64, which never escape the IR.
  300. ** The various integers are only used in the IR and can only escape to
  301. ** a TValue after implicit or explicit conversion. Their types must be
  302. ** contiguous and next to IRT_NUM (see the typerange macros below).
  303. */
  304. ‌#define IRTDEF(_) \
  305.   _(NIL, 4) _(FALSE, 4) _(TRUE, 4) _(LIGHTUD, LJ_64 ? 8 : 4) _(STR, 4) \
  306.   _(P32, 4) _(THREAD, 4) _(PROTO, 4) _(FUNC, 4) _(P64, 8) _(CDATA, 4) \
  307.   _(TAB, 4) _(UDATA, 4) \
  308.   _(FLOAT, 4) _(NUM, 8) _(I8, 1) _(U8, 1) _(I16, 2) _(U16, 2) \
  309.   _(INT, 4) _(U32, 4) _(I64, 8) _(U64, 8) \
  310.   _(SOFTFP, 4)  /* There is room for 9 more types. */

  312. /* IR result type and flags (8 bit). */
  313. typedef enum {
  314. ‌#define IRTENUM(name, size)        IRT_##name,
  315. IRTDEF(IRTENUM)
  316. ‌#undef IRTENUM
  317.   IRT__MAX,

  319.   /* Native pointer type and the corresponding integer type. */
  320.   IRT_PTR = LJ_64 ? IRT_P64 : IRT_P32,
  321.   IRT_INTP = LJ_64 ? IRT_I64 : IRT_INT,
  322.   IRT_UINTP = LJ_64 ? IRT_U64 : IRT_U32,
  323.   /* TODO_GC64: major changes required for all uses of IRT_P32. */

  325.   /* Additional flags. */
  326.   IRT_MARK = 0x20,        /* Marker for misc. purposes. */
  327.   IRT_ISPHI = 0x40,        /* Instruction is left or right PHI operand. */
  328.   IRT_GUARD = 0x80,        /* Instruction is a guard. */

  330.   /* Masks. */
  331.   IRT_TYPE = 0x1f,
  332.   IRT_T = 0xff
  333. ‌} IRType;

  335. ‌#define irtype_ispri(irt)        ((uint32_t)(irt) <= IRT_TRUE)

  337. /* Stored IRType. */
  338. ‌‌typedef struct IRType1 { uint8_t irt; } IRType1;

  340. ‌#define IRT(o, t)                ((uint32_t)(((o)<<8) | (t)))
  341. ‌#define IRTI(o)                        (IRT((o), IRT_INT))
  342. ‌#define IRTN(o)                        (IRT((o), IRT_NUM))
  343. ‌#define IRTG(o, t)                (IRT((o), IRT_GUARD|(t)))
  344. ‌#define IRTGI(o)                (IRT((o), IRT_GUARD|IRT_INT))

  346. ‌#define irt_t(t)                ((IRType)(t).irt)
  347. ‌#define irt_type(t)                ((IRType)((t).irt & IRT_TYPE))
  348. ‌#define irt_sametype(t1, t2)        ((((t1).irt ^ (t2).irt) & IRT_TYPE) == 0)
  349. ‌#define irt_typerange(t, first, last) \
  350.   ((uint32_t)((t).irt & IRT_TYPE) - (uint32_t)(first) <= (uint32_t)(last-first))

  352. ‌#define irt_isnil(t)                (irt_type(t) == IRT_NIL)
  353. ‌#define irt_ispri(t)                ((uint32_t)irt_type(t) <= IRT_TRUE)
  354. ‌#define irt_islightud(t)        (irt_type(t) == IRT_LIGHTUD)
  355. ‌#define irt_isstr(t)                (irt_type(t) == IRT_STR)
  356. ‌#define irt_istab(t)                (irt_type(t) == IRT_TAB)
  357. ‌#define irt_iscdata(t)                (irt_type(t) == IRT_CDATA)
  358. ‌#define irt_isfloat(t)                (irt_type(t) == IRT_FLOAT)
  359. ‌#define irt_isnum(t)                (irt_type(t) == IRT_NUM)
  360. ‌#define irt_isint(t)                (irt_type(t) == IRT_INT)
  361. ‌#define irt_isi8(t)                (irt_type(t) == IRT_I8)
  362. ‌#define irt_isu8(t)                (irt_type(t) == IRT_U8)
  363. ‌#define irt_isi16(t)                (irt_type(t) == IRT_I16)
  364. ‌#define irt_isu16(t)                (irt_type(t) == IRT_U16)
  365. ‌#define irt_isu32(t)                (irt_type(t) == IRT_U32)
  366. ‌#define irt_isi64(t)                (irt_type(t) == IRT_I64)
  367. ‌#define irt_isu64(t)                (irt_type(t) == IRT_U64)

  369. ‌#define irt_isfp(t)                (irt_isnum(t) || irt_isfloat(t))
  370. ‌#define irt_isinteger(t)        (irt_typerange((t), IRT_I8, IRT_INT))
  371. ‌#define irt_isgcv(t)                (irt_typerange((t), IRT_STR, IRT_UDATA))
  372. ‌#define irt_isaddr(t)                (irt_typerange((t), IRT_LIGHTUD, IRT_UDATA))
  373. ‌#define irt_isint64(t)                (irt_typerange((t), IRT_I64, IRT_U64))

  375. #if LJ_GC64
  376. ‌#define IRT_IS64 \
  377.   ((1u<<IRT_NUM)|(1u<<IRT_I64)|(1u<<IRT_U64)|(1u<<IRT_P64)|\
  378.    (1u<<IRT_LIGHTUD)|(1u<<IRT_STR)|(1u<<IRT_THREAD)|(1u<<IRT_PROTO)|\
  379.    (1u<<IRT_FUNC)|(1u<<IRT_CDATA)|(1u<<IRT_TAB)|(1u<<IRT_UDATA))
  380. #elif LJ_64
  381. ‌#define IRT_IS64 \
  382.   ((1u<<IRT_NUM)|(1u<<IRT_I64)|(1u<<IRT_U64)|(1u<<IRT_P64)|(1u<<IRT_LIGHTUD))
  383. #else
  384. ‌#define IRT_IS64 \
  385.   ((1u<<IRT_NUM)|(1u<<IRT_I64)|(1u<<IRT_U64))
  386. #endif

  388. ‌#define irt_is64(t)                ((IRT_IS64 >> irt_type(t)) & 1)
  389. ‌#define irt_is64orfp(t)                (((IRT_IS64|(1u<<IRT_FLOAT))>>irt_type(t)) & 1)

  391. ‌#define irt_size(t)                (lj_ir_type_size[irt_t((t))])

  393. ‌LJ_DATA const uint8_t lj_ir_type_size[];

  395. ‌static LJ_AINLINE IRType itype2irt(const TValue *tv)
  396. {
  397.   if (tvisint(tv))
  398.     return IRT_INT;
  399.   else if (tvisnum(tv))
  400.     return IRT_NUM;
  401. #if LJ_64 && !LJ_GC64
  402.   else if (tvislightud(tv))
  403.     return IRT_LIGHTUD;
  404. #endif
  405.   else
  406.     return (IRType)~itype(tv);
  407. }

  409. ‌static LJ_AINLINE uint32_t irt_toitype_(IRType t)
  410. {
  411.   lua_assert(!LJ_64 || t != IRT_LIGHTUD);
  412.   if (LJ_DUALNUM && t > IRT_NUM) {
  413.     return LJ_TISNUM;
  414.   } else {
  415.     lua_assert(t <= IRT_NUM);
  416.     return ~(uint32_t)t;
  417.   }
  418. }

  420. ‌#define irt_toitype(t)                irt_toitype_(irt_type((t)))

  422. ‌#define irt_isguard(t)                ((t).irt & IRT_GUARD)
  423. ‌#define irt_ismarked(t)                ((t).irt & IRT_MARK)
  424. ‌#define irt_setmark(t)                ((t).irt |= IRT_MARK)
  425. ‌#define irt_clearmark(t)        ((t).irt &= ~IRT_MARK)
  426. ‌#define irt_isphi(t)                ((t).irt & IRT_ISPHI)
  427. ‌#define irt_setphi(t)                ((t).irt |= IRT_ISPHI)
  428. ‌#define irt_clearphi(t)                ((t).irt &= ~IRT_ISPHI)

  430. /* Stored combined IR opcode and type. */
  431. ‌typedef uint16_t IROpT;

  433. /* -- IR references ------------------------------------------------------- */

  435. /* IR references. */
  436. ‌typedef uint16_t IRRef1;        /* One stored reference. */
  437. ‌typedef uint32_t IRRef2;        /* Two stored references. */
  438. ‌typedef uint32_t IRRef;                /* Used to pass around references. */

  440. /* Fixed references. */
  441. enum {
  442.   REF_BIAS =        0x8000,
  443.   REF_TRUE =        REF_BIAS-3,
  444.   REF_FALSE =        REF_BIAS-2,
  445.   REF_NIL =        REF_BIAS-1,        /* \--- Constants grow downwards. */
  446.   REF_BASE =        REF_BIAS,        /* /--- IR grows upwards. */
  447.   REF_FIRST =        REF_BIAS+1,
  448.   REF_DROP =        0xffff
  449. };

  451. /* Note: IRMlit operands must be < REF_BIAS, too!
  452. ** This allows for fast and uniform manipulation of all operands
  453. ** without looking up the operand mode in lj_ir_mode:
  454. ** - CSE calculates the maximum reference of two operands.
  455. **   This must work with mixed reference/literal operands, too.
  456. ** - DCE marking only checks for operand >= REF_BIAS.
  457. ** - LOOP needs to substitute reference operands.
  458. **   Constant references and literals must not be modified.
  459. */

  461. ‌#define IRREF2(lo, hi)                ((IRRef2)(lo) | ((IRRef2)(hi) << 16))

  463. ‌#define irref_isk(ref)                ((ref) < REF_BIAS)

  465. /* Tagged IR references (32 bit).
  466. **
  467. ** +-------+-------+---------------+
  468. ** |  irt  | flags |      ref      |
  469. ** +-------+-------+---------------+
  470. **
  471. ** The tag holds a copy of the IRType and speeds up IR type checks.
  472. */
  473. ‌typedef uint32_t TRef;

  475. ‌#define TREF_REFMASK                0x0000ffff
  476. ‌#define TREF_FRAME                0x00010000
  477. ‌#define TREF_CONT                0x00020000

  479. ‌#define TREF(ref, t)                ((TRef)((ref) + ((t)<<24)))

  481. ‌#define tref_ref(tr)                ((IRRef1)(tr))
  482. ‌#define tref_t(tr)                ((IRType)((tr)>>24))
  483. ‌#define tref_type(tr)                ((IRType)(((tr)>>24) & IRT_TYPE))
  484. ‌#define tref_typerange(tr, first, last) \
  485.   ((((tr)>>24) & IRT_TYPE) - (TRef)(first) <= (TRef)(last-first))

  487. ‌#define tref_istype(tr, t)        (((tr) & (IRT_TYPE<<24)) == ((t)<<24))
  488. ‌#define tref_isnil(tr)                (tref_istype((tr), IRT_NIL))
  489. ‌#define tref_isfalse(tr)        (tref_istype((tr), IRT_FALSE))
  490. ‌#define tref_istrue(tr)                (tref_istype((tr), IRT_TRUE))
  491. ‌#define tref_islightud(tr)        (tref_istype((tr), IRT_LIGHTUD))
  492. ‌#define tref_isstr(tr)                (tref_istype((tr), IRT_STR))
  493. ‌#define tref_isfunc(tr)                (tref_istype((tr), IRT_FUNC))
  494. ‌#define tref_iscdata(tr)        (tref_istype((tr), IRT_CDATA))
  495. ‌#define tref_istab(tr)                (tref_istype((tr), IRT_TAB))
  496. ‌#define tref_isudata(tr)        (tref_istype((tr), IRT_UDATA))
  497. ‌#define tref_isnum(tr)                (tref_istype((tr), IRT_NUM))
  498. ‌#define tref_isint(tr)                (tref_istype((tr), IRT_INT))

  500. ‌#define tref_isbool(tr)                (tref_typerange((tr), IRT_FALSE, IRT_TRUE))
  501. ‌#define tref_ispri(tr)                (tref_typerange((tr), IRT_NIL, IRT_TRUE))
  502. ‌#define tref_istruecond(tr)        (!tref_typerange((tr), IRT_NIL, IRT_FALSE))
  503. ‌#define tref_isinteger(tr)        (tref_typerange((tr), IRT_I8, IRT_INT))
  504. ‌#define tref_isnumber(tr)        (tref_typerange((tr), IRT_NUM, IRT_INT))
  505. ‌#define tref_isnumber_str(tr)        (tref_isnumber((tr)) || tref_isstr((tr)))
  506. ‌#define tref_isgcv(tr)                (tref_typerange((tr), IRT_STR, IRT_UDATA))

  508. ‌#define tref_isk(tr)                (irref_isk(tref_ref((tr))))
  509. ‌#define tref_isk2(tr1, tr2)        (irref_isk(tref_ref((tr1) | (tr2))))

  511. ‌#define TREF_PRI(t)                (TREF(REF_NIL-(t), (t)))
  512. ‌#define TREF_NIL                (TREF_PRI(IRT_NIL))
  513. ‌#define TREF_FALSE                (TREF_PRI(IRT_FALSE))
  514. ‌#define TREF_TRUE                (TREF_PRI(IRT_TRUE))

  516. /* -- IR format ----------------------------------------------------------- */

  518. /* IR instruction format (64 bit).
  519. **
  520. **    16      16     8   8   8   8
  521. ** +-------+-------+---+---+---+---+
  522. ** |  op1  |  op2  | t | o | r | s |
  523. ** +-------+-------+---+---+---+---+
  524. ** |  op12/i/gco   |   ot  | prev  | (alternative fields in union)
  525. ** +---------------+-------+-------+
  526. **        32           16      16
  527. **
  528. ** prev is only valid prior to register allocation and then reused for r + s.
  529. */

  531. ‌typedef union IRIns {
  532.   struct {
  533.     LJ_ENDIAN_LOHI(
  534.       IRRef1 op1;        /* IR operand 1. */
  535.     , IRRef1 op2;        /* IR operand 2. */
  536.     )
  537.     IROpT ot;                /* IR opcode and type (overlaps t and o). */
  538.     IRRef1 prev;        /* Previous ins in same chain (overlaps r and s). */
  539.   };
  540.   struct {
  541.     IRRef2 op12;        /* IR operand 1 and 2 (overlaps op1 and op2). */
  542.     LJ_ENDIAN_LOHI(
  543.       IRType1 t;        /* IR type. */
  544.     , IROp1 o;                /* IR opcode. */
  545.     )
  546.     LJ_ENDIAN_LOHI(
  547.       uint8_t r;        /* Register allocation (overlaps prev). */
  548.     , uint8_t s;        /* Spill slot allocation (overlaps prev). */
  549.     )
  550.   };
  551.   int32_t i;                /* 32 bit signed integer literal (overlaps op12). */
  552.   GCRef gcr;                /* GCobj constant (overlaps op12). */
  553.   MRef ptr;                /* Pointer constant (overlaps op12). */
  554. ‌} IRIns;

  556. /* TODO_GC64: major changes required. */
  557. ‌#define ir_kgc(ir)        check_exp((ir)->o == IR_KGC, gcref((ir)->gcr))
  558. ‌#define ir_kstr(ir)        (gco2str(ir_kgc((ir))))
  559. ‌#define ir_ktab(ir)        (gco2tab(ir_kgc((ir))))
  560. ‌#define ir_kfunc(ir)        (gco2func(ir_kgc((ir))))
  561. ‌#define ir_kcdata(ir)        (gco2cd(ir_kgc((ir))))
  562. ‌#define ir_knum(ir)        check_exp((ir)->o == IR_KNUM, mref((ir)->ptr, cTValue))
  563. ‌#define ir_kint64(ir)        check_exp((ir)->o == IR_KINT64, mref((ir)->ptr,cTValue))
  564. ‌#define ir_k64(ir) \
  565.   check_exp((ir)->o == IR_KNUM || (ir)->o == IR_KINT64, mref((ir)->ptr,cTValue))
  566. ‌#define ir_kptr(ir) \
  567.   check_exp((ir)->o == IR_KPTR || (ir)->o == IR_KKPTR, mref((ir)->ptr, void))

  569. /* A store or any other op with a non-weak guard has a side-effect. */
  570. ‌static LJ_AINLINE int ir_sideeff(IRIns *ir)
  571. {
  572.   return (((ir->t.irt | ~IRT_GUARD) & lj_ir_mode[ir->o]) >= IRM_S);
  573. }

  575. LJ_STATIC_ASSERT((int)IRT_GUARD == (int)IRM_W);

  577. #endif

One Level Up Top Level