diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/luajit-2.0/src/lj_target.h | 158 |
1 files changed, 0 insertions, 158 deletions
diff --git a/libraries/luajit-2.0/src/lj_target.h b/libraries/luajit-2.0/src/lj_target.h deleted file mode 100644 index c302d30..0000000 --- a/libraries/luajit-2.0/src/lj_target.h +++ /dev/null | |||
@@ -1,158 +0,0 @@ | |||
1 | /* | ||
2 | ** Definitions for target CPU. | ||
3 | ** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h | ||
4 | */ | ||
5 | |||
6 | #ifndef _LJ_TARGET_H | ||
7 | #define _LJ_TARGET_H | ||
8 | |||
9 | #include "lj_def.h" | ||
10 | #include "lj_arch.h" | ||
11 | |||
12 | /* -- Registers and spill slots ------------------------------------------- */ | ||
13 | |||
14 | /* Register type (uint8_t in ir->r). */ | ||
15 | typedef uint32_t Reg; | ||
16 | |||
17 | /* The hi-bit is NOT set for an allocated register. This means the value | ||
18 | ** can be directly used without masking. The hi-bit is set for a register | ||
19 | ** allocation hint or for RID_INIT. | ||
20 | */ | ||
21 | #define RID_NONE 0x80 | ||
22 | #define RID_MASK 0x7f | ||
23 | #define RID_INIT (RID_NONE|RID_MASK) | ||
24 | |||
25 | #define ra_noreg(r) ((r) & RID_NONE) | ||
26 | #define ra_hasreg(r) (!((r) & RID_NONE)) | ||
27 | |||
28 | /* The ra_hashint() macro assumes a previous test for ra_noreg(). */ | ||
29 | #define ra_hashint(r) ((r) != RID_INIT) | ||
30 | #define ra_gethint(r) ((Reg)((r) & RID_MASK)) | ||
31 | #define ra_sethint(rr, r) rr = (uint8_t)((r)|RID_NONE) | ||
32 | #define ra_samehint(r1, r2) (ra_gethint((r1)^(r2)) == 0) | ||
33 | |||
34 | /* Spill slot 0 means no spill slot has been allocated. */ | ||
35 | #define SPS_NONE 0 | ||
36 | |||
37 | #define ra_hasspill(s) ((s) != SPS_NONE) | ||
38 | |||
39 | /* Combined register and spill slot (uint16_t in ir->prev). */ | ||
40 | typedef uint32_t RegSP; | ||
41 | |||
42 | #define REGSP(r, s) ((r) + ((s) << 8)) | ||
43 | #define REGSP_HINT(r) ((r)|RID_NONE) | ||
44 | #define REGSP_INIT REGSP(RID_INIT, 0) | ||
45 | |||
46 | #define regsp_reg(rs) ((rs) & 255) | ||
47 | #define regsp_spill(rs) ((rs) >> 8) | ||
48 | #define regsp_used(rs) \ | ||
49 | (((rs) & ~REGSP(RID_MASK, 0)) != REGSP(RID_NONE, 0)) | ||
50 | |||
51 | /* -- Register sets ------------------------------------------------------- */ | ||
52 | |||
53 | /* Bitset for registers. 32 registers suffice for most architectures. | ||
54 | ** Note that one set holds bits for both GPRs and FPRs. | ||
55 | */ | ||
56 | #if LJ_TARGET_PPC | ||
57 | typedef uint64_t RegSet; | ||
58 | #else | ||
59 | typedef uint32_t RegSet; | ||
60 | #endif | ||
61 | |||
62 | #define RID2RSET(r) (((RegSet)1) << (r)) | ||
63 | #define RSET_EMPTY ((RegSet)0) | ||
64 | #define RSET_RANGE(lo, hi) ((RID2RSET((hi)-(lo))-1) << (lo)) | ||
65 | |||
66 | #define rset_test(rs, r) (((rs) >> (r)) & 1) | ||
67 | #define rset_set(rs, r) (rs |= RID2RSET(r)) | ||
68 | #define rset_clear(rs, r) (rs &= ~RID2RSET(r)) | ||
69 | #define rset_exclude(rs, r) (rs & ~RID2RSET(r)) | ||
70 | #if LJ_TARGET_PPC | ||
71 | #define rset_picktop(rs) ((Reg)(__builtin_clzll(rs)^63)) | ||
72 | #define rset_pickbot(rs) ((Reg)__builtin_ctzll(rs)) | ||
73 | #else | ||
74 | #define rset_picktop(rs) ((Reg)lj_fls(rs)) | ||
75 | #define rset_pickbot(rs) ((Reg)lj_ffs(rs)) | ||
76 | #endif | ||
77 | |||
78 | /* -- Register allocation cost -------------------------------------------- */ | ||
79 | |||
80 | /* The register allocation heuristic keeps track of the cost for allocating | ||
81 | ** a specific register: | ||
82 | ** | ||
83 | ** A free register (obviously) has a cost of 0 and a 1-bit in the free mask. | ||
84 | ** | ||
85 | ** An already allocated register has the (non-zero) IR reference in the lowest | ||
86 | ** bits and the result of a blended cost-model in the higher bits. | ||
87 | ** | ||
88 | ** The allocator first checks the free mask for a hit. Otherwise an (unrolled) | ||
89 | ** linear search for the minimum cost is used. The search doesn't need to | ||
90 | ** keep track of the position of the minimum, which makes it very fast. | ||
91 | ** The lowest bits of the minimum cost show the desired IR reference whose | ||
92 | ** register is the one to evict. | ||
93 | ** | ||
94 | ** Without the cost-model this degenerates to the standard heuristics for | ||
95 | ** (reverse) linear-scan register allocation. Since code generation is done | ||
96 | ** in reverse, a live interval extends from the last use to the first def. | ||
97 | ** For an SSA IR the IR reference is the first (and only) def and thus | ||
98 | ** trivially marks the end of the interval. The LSRA heuristics says to pick | ||
99 | ** the register whose live interval has the furthest extent, i.e. the lowest | ||
100 | ** IR reference in our case. | ||
101 | ** | ||
102 | ** A cost-model should take into account other factors, like spill-cost and | ||
103 | ** restore- or rematerialization-cost, which depend on the kind of instruction. | ||
104 | ** E.g. constants have zero spill costs, variant instructions have higher | ||
105 | ** costs than invariants and PHIs should preferably never be spilled. | ||
106 | ** | ||
107 | ** Here's a first cut at simple, but effective blended cost-model for R-LSRA: | ||
108 | ** - Due to careful design of the IR, constants already have lower IR | ||
109 | ** references than invariants and invariants have lower IR references | ||
110 | ** than variants. | ||
111 | ** - The cost in the upper 16 bits is the sum of the IR reference and a | ||
112 | ** weighted score. The score currently only takes into account whether | ||
113 | ** the IRT_ISPHI bit is set in the instruction type. | ||
114 | ** - The PHI weight is the minimum distance (in IR instructions) a PHI | ||
115 | ** reference has to be further apart from a non-PHI reference to be spilled. | ||
116 | ** - It should be a power of two (for speed) and must be between 2 and 32768. | ||
117 | ** Good values for the PHI weight seem to be between 40 and 150. | ||
118 | ** - Further study is required. | ||
119 | */ | ||
120 | #define REGCOST_PHI_WEIGHT 64 | ||
121 | |||
122 | /* Cost for allocating a specific register. */ | ||
123 | typedef uint32_t RegCost; | ||
124 | |||
125 | /* Note: assumes 16 bit IRRef1. */ | ||
126 | #define REGCOST(cost, ref) ((RegCost)(ref) + ((RegCost)(cost) << 16)) | ||
127 | #define regcost_ref(rc) ((IRRef1)(rc)) | ||
128 | |||
129 | #define REGCOST_T(t) \ | ||
130 | ((RegCost)((t)&IRT_ISPHI) * (((RegCost)(REGCOST_PHI_WEIGHT)<<16)/IRT_ISPHI)) | ||
131 | #define REGCOST_REF_T(ref, t) (REGCOST((ref), (ref)) + REGCOST_T((t))) | ||
132 | |||
133 | /* -- Target-specific definitions ----------------------------------------- */ | ||
134 | |||
135 | #if LJ_TARGET_X86ORX64 | ||
136 | #include "lj_target_x86.h" | ||
137 | #elif LJ_TARGET_ARM | ||
138 | #include "lj_target_arm.h" | ||
139 | #elif LJ_TARGET_PPC | ||
140 | #include "lj_target_ppc.h" | ||
141 | #else | ||
142 | #error "Missing include for target CPU" | ||
143 | #endif | ||
144 | |||
145 | #ifdef EXITSTUBS_PER_GROUP | ||
146 | /* Return the address of an exit stub. */ | ||
147 | static LJ_AINLINE char *exitstub_addr_(char **group, uint32_t exitno) | ||
148 | { | ||
149 | lua_assert(group[exitno / EXITSTUBS_PER_GROUP] != NULL); | ||
150 | return (char *)group[exitno / EXITSTUBS_PER_GROUP] + | ||
151 | EXITSTUB_SPACING*(exitno % EXITSTUBS_PER_GROUP); | ||
152 | } | ||
153 | /* Avoid dependence on lj_jit.h if only including lj_target.h. */ | ||
154 | #define exitstub_addr(J, exitno) \ | ||
155 | ((MCode *)exitstub_addr_((char **)((J)->exitstubgroup), (exitno))) | ||
156 | #endif | ||
157 | |||
158 | #endif | ||