src/lj_iropt.h - luajit-2.0-src

Functions defined

Macros defined

Source code

  1. /*
  2. ** Common header for IR emitter and optimizations.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  5. #ifndef _LJ_IROPT_H
  6. #define _LJ_IROPT_H

  7. #include <stdarg.h>

  8. #include "lj_obj.h"
  9. #include "lj_jit.h"

  10. #if LJ_HASJIT
  11. /* IR emitter. */
  12. LJ_FUNC void LJ_FASTCALL lj_ir_growtop(jit_State *J);
  13. LJ_FUNC TRef LJ_FASTCALL lj_ir_emit(jit_State *J);

  14. /* Save current IR in J->fold.ins, but do not emit it (yet). */
  15. static LJ_AINLINE void lj_ir_set_(jit_State *J, uint16_t ot, IRRef1 a, IRRef1 b)
  16. {
  17.   J->fold.ins.ot = ot; J->fold.ins.op1 = a; J->fold.ins.op2 = b;
  18. }

  19. #define lj_ir_set(J, ot, a, b) \
  20.   lj_ir_set_(J, (uint16_t)(ot), (IRRef1)(a), (IRRef1)(b))

  21. /* Get ref of next IR instruction and optionally grow IR.
  22. ** Note: this may invalidate all IRIns*!
  23. */
  24. static LJ_AINLINE IRRef lj_ir_nextins(jit_State *J)
  25. {
  26.   IRRef ref = J->cur.nins;
  27.   if (LJ_UNLIKELY(ref >= J->irtoplim)) lj_ir_growtop(J);
  28.   J->cur.nins = ref + 1;
  29.   return ref;
  30. }

  31. /* Interning of constants. */
  32. LJ_FUNC TRef LJ_FASTCALL lj_ir_kint(jit_State *J, int32_t k);
  33. LJ_FUNC void lj_ir_k64_freeall(jit_State *J);
  34. LJ_FUNC TRef lj_ir_k64(jit_State *J, IROp op, cTValue *tv);
  35. LJ_FUNC cTValue *lj_ir_k64_find(jit_State *J, uint64_t u64);
  36. LJ_FUNC TRef lj_ir_knum_u64(jit_State *J, uint64_t u64);
  37. LJ_FUNC TRef lj_ir_knumint(jit_State *J, lua_Number n);
  38. LJ_FUNC TRef lj_ir_kint64(jit_State *J, uint64_t u64);
  39. LJ_FUNC TRef lj_ir_kgc(jit_State *J, GCobj *o, IRType t);
  40. LJ_FUNC TRef lj_ir_kptr_(jit_State *J, IROp op, void *ptr);
  41. LJ_FUNC TRef lj_ir_knull(jit_State *J, IRType t);
  42. LJ_FUNC TRef lj_ir_kslot(jit_State *J, TRef key, IRRef slot);

  43. #if LJ_64
  44. #define lj_ir_kintp(J, k)        lj_ir_kint64(J, (uint64_t)(k))
  45. #else
  46. #define lj_ir_kintp(J, k)        lj_ir_kint(J, (int32_t)(k))
  47. #endif

  48. static LJ_AINLINE TRef lj_ir_knum(jit_State *J, lua_Number n)
  49. {
  50.   TValue tv;
  51.   tv.n = n;
  52.   return lj_ir_knum_u64(J, tv.u64);
  53. }

  54. #define lj_ir_kstr(J, str)        lj_ir_kgc(J, obj2gco((str)), IRT_STR)
  55. #define lj_ir_ktab(J, tab)        lj_ir_kgc(J, obj2gco((tab)), IRT_TAB)
  56. #define lj_ir_kfunc(J, func)        lj_ir_kgc(J, obj2gco((func)), IRT_FUNC)
  57. #define lj_ir_kptr(J, ptr)        lj_ir_kptr_(J, IR_KPTR, (ptr))
  58. #define lj_ir_kkptr(J, ptr)        lj_ir_kptr_(J, IR_KKPTR, (ptr))

  59. /* Special FP constants. */
  60. #define lj_ir_knum_zero(J)        lj_ir_knum_u64(J, U64x(00000000,00000000))
  61. #define lj_ir_knum_one(J)        lj_ir_knum_u64(J, U64x(3ff00000,00000000))
  62. #define lj_ir_knum_tobit(J)        lj_ir_knum_u64(J, U64x(43380000,00000000))

  63. /* Special 128 bit SIMD constants. */
  64. #define lj_ir_knum_abs(J)        lj_ir_k64(J, IR_KNUM, LJ_KSIMD(J, LJ_KSIMD_ABS))
  65. #define lj_ir_knum_neg(J)        lj_ir_k64(J, IR_KNUM, LJ_KSIMD(J, LJ_KSIMD_NEG))

  66. /* Access to constants. */
  67. LJ_FUNC void lj_ir_kvalue(lua_State *L, TValue *tv, const IRIns *ir);

  68. /* Convert IR operand types. */
  69. LJ_FUNC TRef LJ_FASTCALL lj_ir_tonumber(jit_State *J, TRef tr);
  70. LJ_FUNC TRef LJ_FASTCALL lj_ir_tonum(jit_State *J, TRef tr);
  71. LJ_FUNC TRef LJ_FASTCALL lj_ir_tostr(jit_State *J, TRef tr);

  72. /* Miscellaneous IR ops. */
  73. LJ_FUNC int lj_ir_numcmp(lua_Number a, lua_Number b, IROp op);
  74. LJ_FUNC int lj_ir_strcmp(GCstr *a, GCstr *b, IROp op);
  75. LJ_FUNC void lj_ir_rollback(jit_State *J, IRRef ref);

  76. /* Emit IR instructions with on-the-fly optimizations. */
  77. LJ_FUNC TRef LJ_FASTCALL lj_opt_fold(jit_State *J);
  78. LJ_FUNC TRef LJ_FASTCALL lj_opt_cse(jit_State *J);
  79. LJ_FUNC TRef LJ_FASTCALL lj_opt_cselim(jit_State *J, IRRef lim);

  80. /* Special return values for the fold functions. */
  81. enum {
  82.   NEXTFOLD,                /* Couldn't fold, pass on. */
  83.   RETRYFOLD,                /* Retry fold with modified fins. */
  84.   KINTFOLD,                /* Return ref for int constant in fins->i. */
  85.   FAILFOLD,                /* Guard would always fail. */
  86.   DROPFOLD,                /* Guard eliminated. */
  87.   MAX_FOLD
  88. };

  89. #define INTFOLD(k)        ((J->fold.ins.i = (k)), (TRef)KINTFOLD)
  90. #define INT64FOLD(k)        (lj_ir_kint64(J, (k)))
  91. #define CONDFOLD(cond)        ((TRef)FAILFOLD + (TRef)(cond))
  92. #define LEFTFOLD        (J->fold.ins.op1)
  93. #define RIGHTFOLD        (J->fold.ins.op2)
  94. #define CSEFOLD                (lj_opt_cse(J))
  95. #define EMITFOLD        (lj_ir_emit(J))

  96. /* Load/store forwarding. */
  97. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_aload(jit_State *J);
  98. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_hload(jit_State *J);
  99. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_uload(jit_State *J);
  100. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_fload(jit_State *J);
  101. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_xload(jit_State *J);
  102. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_tab_len(jit_State *J);
  103. LJ_FUNC TRef LJ_FASTCALL lj_opt_fwd_hrefk(jit_State *J);
  104. LJ_FUNC int LJ_FASTCALL lj_opt_fwd_href_nokey(jit_State *J);
  105. LJ_FUNC int LJ_FASTCALL lj_opt_fwd_tptr(jit_State *J, IRRef lim);
  106. LJ_FUNC int lj_opt_fwd_wasnonnil(jit_State *J, IROpT loadop, IRRef xref);

  107. /* Dead-store elimination. */
  108. LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_ahstore(jit_State *J);
  109. LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_ustore(jit_State *J);
  110. LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_fstore(jit_State *J);
  111. LJ_FUNC TRef LJ_FASTCALL lj_opt_dse_xstore(jit_State *J);

  112. /* Narrowing. */
  113. LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_convert(jit_State *J);
  114. LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_index(jit_State *J, TRef key);
  115. LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_toint(jit_State *J, TRef tr);
  116. LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_tobit(jit_State *J, TRef tr);
  117. #if LJ_HASFFI
  118. LJ_FUNC TRef LJ_FASTCALL lj_opt_narrow_cindex(jit_State *J, TRef key);
  119. #endif
  120. LJ_FUNC TRef lj_opt_narrow_arith(jit_State *J, TRef rb, TRef rc,
  121.                                  TValue *vb, TValue *vc, IROp op);
  122. LJ_FUNC TRef lj_opt_narrow_unm(jit_State *J, TRef rc, TValue *vc);
  123. LJ_FUNC TRef lj_opt_narrow_mod(jit_State *J, TRef rb, TRef rc, TValue *vc);
  124. LJ_FUNC TRef lj_opt_narrow_pow(jit_State *J, TRef rb, TRef rc, TValue *vc);
  125. LJ_FUNC IRType lj_opt_narrow_forl(jit_State *J, cTValue *forbase);

  126. /* Optimization passes. */
  127. LJ_FUNC void lj_opt_dce(jit_State *J);
  128. LJ_FUNC int lj_opt_loop(jit_State *J);
  129. #if LJ_SOFTFP || (LJ_32 && LJ_HASFFI)
  130. LJ_FUNC void lj_opt_split(jit_State *J);
  131. #else
  132. #define lj_opt_split(J)                UNUSED(J)
  133. #endif
  134. LJ_FUNC void lj_opt_sink(jit_State *J);

  135. #endif

  136. #endif