src/x86/jitcs_int_x86_xx_regs.lh

   1 #/bin/emblua LUAPREFIX=/*|
   2 /*| --VARDELIM=%
   3 /*| --CMTDELIM=//
   4 /*| --XDUMPSCRIPT=true
   5 /*| --*/
   6 /*| local N = $$$
   7 /*| function pred_ipairs(t, pred)
   8 /*|   return function(t,k)
   9 /*|       local v
  10 /*|       repeat
  11 /*|         k = k + 1
  12 /*|         v = t[k]
  13 /*|       until not v or pred(k, v)
  14 /*|       return v and k, v
  15 /*|     end, t, 0
  16 /*| end
  17 /*| function isaN(k,v) return not v[N==32 and "x64" or "x32"] end
  18 //===-- x86/x86_%(N)_regs.h C++ -----------------------------------------*-===//
  19 //
  20 // Register definitions for %(N)bit x86 code.
  21 //
  22 //===----------------------------------------------------------------------===//
  23
  24 #ifndef _JITCS_INT_X86_%(N)_REGS_H_
  25 #define _JITCS_INT_X86_%(N)_REGS_H_
  26
  27 #include "jitcs.h"
  28 #include "jitcs_ids.h"
  29 #include "jitcs_x86_%(N)_regs.h"
  30
  31 /*| local data= runfile("../data/x86_reglist.dat")
  32 /*| local function hex2(n) return string.format("0x%02x", n) end
  33 /*|  --*/
  34
  35 namespace jitcs {
  36 namespace x86_%(N) {
  37
  38 /*| local n2c = {}
  39 /*| for k,v in ipairs(data.classes) do
  40 /*|   n2c[v.name] = v
  41 /*| end
  42 /*| local c2r, c2ra, n2r = {}, {}, {}
  43 /*| for k,v in ipairs(data.registers) do
  44 /*|   n2r[v.name] = v
  45 /*|   local c = c2r[v.class] or {}
  46 /*|   c2r[v.class] = c
  47 /*|   c[#c+1] = v
  48 /*| end
  49 /*| for k,v2 in ipairs(data.registeraliases) do
  50 /*|   local v = n2r[v2.dest]
  51 /*|   local c = c2ra[v.class] or {}
  52 /*|   c2ra[v.class] = c
  53 /*|   c[#c+1] = v2
  54 /*| end
  55 /*| resc2resid = {x32 = {}, sizex32 = {}, x32cnt = 0, x64 = {}, sizex64 = {}, x64cnt = 0}
  56 /*| for k,v in ipairs(data.resources) do
  57 /*|   if not v.x64 then
  58 /*|     resc2resid.x32[v.name] = resc2resid.x32cnt;
  59 /*|     resc2resid.x32cnt = resc2resid.x32cnt + v.cnt
  60 /*|     resc2resid.sizex32[v.name] = v.cnt
  61 /*|   end
  62 /*|   if not v.x32 then
  63 /*|     resc2resid.x64[v.name] = resc2resid.x64cnt;
  64 /*|     resc2resid.x64cnt = resc2resid.x64cnt + v.cnt
  65 /*|     resc2resid.sizex64[v.name] = v.cnt
  66 /*|   end
  67 /*| end
  68 /*| resc2rescid, rescidcnt, rescid2resc = {}, 0, {}
  69 /*| regc2resc = {}
  70 /*| for k,v in ipairs(data.classes) do
  71 /*|   regc2resc[v.name] = v.resclass
  72 /*|   if not resc2rescid[v.resclass] then
  73 /*|     resc2rescid[v.resclass] = rescidcnt
  74 /*|     rescid2resc[rescidcnt] = v.resclass
  75 /*|     rescidcnt = rescidcnt + 1
  76 /*|   end
  77 /*| end
  78 /*| local rescnt = 0
  79 /*| for k,v in ipairs(data.resources) do
  80 /*|   if isaN(nil, v) then rescnt = rescnt + v.cnt end
  81 /*| end
  82 /*|  --*/
  83 static const ResId RES_Count = static_cast<ResId>(%(rescnt));
  84 static const ResClassId RESCL_Count = static_cast<ResClassId>(%(rescidcnt));
  85
  86 /*| for k = 1, rescidcnt do
  87 static const ResClassId RESCL_%(rescid2resc[k - 1]) = static_cast<ResClassId>(%(k - 1));
  88 /*| end
  89 /*| --*/
  90
  91 /*| local nn32, nn64, v2nn = 0, 0, {}
  92 /*| for z = 1,3 do
  93 /*|   for l,cl in ipairs(data.classes) do
  94 /*|     for k,v in ipairs(c2r[cl.name]) do
  95 /*|       local cond32 = (cl.x32 or not cl.x64) and (v.x32 or not v.x64)
  96 /*|       local cond64 = (not cl.x32 or cl.x64) and (not v.x32 or v.x64)
  97 /*|       if (z == 1 and cond32 and cond64) or (z == 2 and cond32 and not cond64) or (z == 3 and not cond32 and cond64) then
  98 /*|         v2nn[v.name] = {x32 = cond32 and nn32, x64 = cond64 and nn64}
  99 /*|         if (cond32) then nn32 = nn32 + 1 end
 100 /*|         if (cond64) then nn64 = nn64 + 1 end
 101 /*|       end
 102 /*|     end
 103 /*|   end
 104 /*| end
 105 /*|  --*/
 106
 107 template <uint N> struct RegInfoCT {};
 108 template <uint N> struct ResInfoCT {};
 109 template <uint N> struct RegClassInfoCT {};
 110 template <uint N> struct ResClassInfoCT {};
 111
 112 /*| for k = 1, rescidcnt do
 113 /*|   local i = resc2resid["x"..N][rescid2resc[k - 1]]
 114 /*|   local v = resc2resid["sizex"..N][rescid2resc[k - 1]]
 115 template<> struct ResClassInfoCT<RESCL_%(rescid2resc[k - 1])> {
 116   enum { RES_Idx = %(i), RES_PoolSize =  %(v) };
 117 };
 118 /*| end
 119 /*| --*/
 120
 121 /*| reg2resid = {x32 = {}, x64 = {}}
 122 /*| for k,v in ipairs(data.registers) do
 123 /*|   if not v.x64 then
 124 /*|     reg2resid.x32[v.name] = resc2resid.x32[regc2resc[v.class]] + v.resindex
 125 /*|   end
 126 /*|   if not v.x32 then
 127 /*|     reg2resid.x64[v.name] = resc2resid.x64[regc2resc[v.class]] + v.resindex
 128 /*|   end
 129 /*| end
 130 /*| local function sum(rlist, subtype)
 131 /*|   local s = 0
 132 /*|   for k,v in ipairs(rlist) do
 133 /*|     s = s + math.pow(2, reg2resid[subtype][v])
 134 /*|   end
 135 /*|   return string.format("0x%x", s)
 136 /*| end
 137 /*| local res2rescl = {}
 138 /*| for k,v in pred_ipairs(data.registers, isaN) do
 139 /*|   local vv = reg2resid["x"..N][v.name]
 140 /*|   if vv then
 141 /*|     if not res2rescl[vv] then
 142 /*|       res2rescl[vv] = { ["x"..N] = regc2resc[v.class] }
 143 /*|     else
 144 /*|       assert(not res2rescl[vv]["x"..N] or res2rescl[vv]["x"..N] == regc2resc[v.class])
 145 /*|       res2rescl[vv]["x"..N] = regc2resc[v.class]
 146 /*|     end
 147 /*|   end
 148 template <> struct RegInfoCT<R_%(v.name)> {
 149   static const ResId RES_Id = static_cast<ResId>(%(vv));
 150   static const ResClassId RESCL_Id = RESCL_%(regc2resc[v.class]);
 151   static const RegClassId RCL_Id = RCL_%(v.refclass or "Count");
 152   static const uint VR_Idx = %(v2nn[v.name]["x"..N]);
 153   typedef RegLookup<_fixedRegister%(v2nn[v.name]["x"..N]), RSC_%(v.class)> RegAccessorType;
 154 };
 155 /*| end
 156 /*| for k = 1, rescnt do
 157 /*|   local vv = res2rescl[k-1]["x"..N]
 158 template <> struct ResInfoCT<%(k-1)> {
 159   static const ResClassId RESCL_Id = RESCL_%(vv);
 160 };
 161 /*| end
 162
 163 /*| local LogTable = {[0] = 0, [1] = 0, [2] = 1, [4] = 2, [8] = 3, [16] = 4, [32] = 5, [64] = 6}
 164 /*| for l,cl in pred_ipairs(data.refclasses, isaN) do
 165 /*|   local da = 0
 166 /*|   if cl.dontalloc then
 167 /*|     local f,t = cl.dontalloc:match("^(%d+)%-(%d+)$")
 168 /*|     if f and t then da = 2 ^ (t+1) - 2 ^ f end
 169 /*|   end
 170 template <> struct RegClassInfoCT<RCL_%(cl.name)> {
 171   static const ResClassId RESCL_Id = RESCL_%(regc2resc[cl.classes[1]]);
 172   static const u16 MASK_DontAlloc = %(da);
 173   static const u8  SIZE = %(cl.defsz);
 174   static const u8  LOGSIZE = %(LogTable[cl.defsz]);
 175 };
 176 /*| end
 177 /*| --*/
 178
 179 /*| local minid, maxid = 255, 0
 180 /*| for k,v in pred_ipairs(data.registers, isaN) do
 181 /*|   if v.id > maxid then maxid = v.id end
 182 /*|   if v.id < minid then minid = v.id end
 183 /*| end
 184 extern const u8 ArrayReg2RegClass[%(maxid-minid+1)];
 185 extern const u8 ArrayReg2Res[%(maxid-minid+1)];
 186 extern const u8 ArrayRegClass2ResClass[RCL_Count];
 187 extern const u8 ArrayRegClass2LogSize[RCL_Count];
 188 extern const u16 ArrayRegClass2DontAlloc[RCL_Count];
 189 extern const u8 ArrayRes2ResClass[RES_Count];
 190 extern const u8 ArrayResClass2ResClassIndex[RESCL_Count];
 191 extern const u8 ArrayResClass2ResClassSize[RESCL_Count];
 192 static inline RegClassId GetRegClassOfReg(RegId r) {
 193   assert(r >= %(minid) && r <= %(maxid));
 194   return static_cast<RegClassId>(ArrayReg2RegClass[r-%(minid)]);
 195 }
 196 static inline ResId GetResOfReg(RegId r) {
 197   if (r >= R_HardwareLimit) return static_cast<ResId>(RES_Count + r - R_HardwareLimit);
 198   assert(r >= %(minid) && r <= %(maxid));
 199   return static_cast<ResId>(ArrayReg2Res[r-%(minid)]);
 200 }
 201 static inline ResClassId GetResClassOfRegClass(RegClassId rc) {
 202   assert(rc < RCL_Count);
 203   return static_cast<ResClassId>(ArrayRegClass2ResClass[rc]);
 204 }
 205 static inline ResClassId GetResClassOfReg(RegId r) {
 206   return GetResClassOfRegClass(GetRegClassOfReg(r));
 207 }
 208 static inline u8 GetLogSizeOfRegClass(RegClassId rc) {
 209   assert(rc < RCL_Count);
 210   return ArrayRegClass2LogSize[rc];
 211 }
 212 static inline u16 GetDontAllocOfRegClass(RegClassId rc) {
 213   assert(rc < RCL_Count);
 214   return ArrayRegClass2DontAlloc[rc];
 215 }
 216 static inline ResClassId GetResClassOfRes(ResId res) {
 217   assert(res < RES_Count);
 218   return static_cast<ResClassId>(ArrayRes2ResClass[res]);
 219 }
 220 static inline u8 GetResIndexOfResClass(ResClassId rescl) {
 221   assert(rescl < RESCL_Count);
 222   return ArrayResClass2ResClassIndex[rescl];
 223 }
 224 static inline u8 GetSizeOfResClass(ResClassId rescl) {
 225   assert(rescl < RESCL_Count);
 226   return ArrayResClass2ResClassSize[rescl];
 227 }
 228 RegId GetRegIdForRes(RegClassId rc, ResId res);
 229 //RefOrNull<const VirtualRegister>
 230 //  GetHardwareRegisterForRes(RegClassId rc, ResId res);
 231
 232 } // end of namespace jitcs::x86_%(N)
 233 } // end of namespace jitcs
 234 #endif
 235 // _JITCS_INT_X86_%(N)_REGS_H_