src/host/genlibbc.lua

   1 ----------------------------------------------------------------------------
   2 -- Lua script to dump the bytecode of the library functions written in Lua.
   3 -- The resulting 'buildvm_libbc.h' is used for the build process of LuaJIT.
   4 ----------------------------------------------------------------------------
   5 -- Copyright (C) 2005-2014 Mike Pall. All rights reserved.
   6 -- Released under the MIT license. See Copyright Notice in luajit.h
   7 ----------------------------------------------------------------------------
   8
   9 local ffi = require("ffi")
  10 local bit = require("bit")
  11 local vmdef = require("jit.vmdef")
  12 local bcnames = vmdef.bcnames
  13
  14 local format = string.format
  15
  16 local isbe = (string.byte(string.dump(function() end), 5) % 2 == 1)
  17
  18 local function usage(arg)
  19   io.stderr:write("Usage: ", arg and arg[0] or "genlibbc",
  20                   " [-o buildvm_libbc.h] lib_*.c\n")
  21   os.exit(1)
  22 end
  23
  24 local function parse_arg(arg)
  25   local outfile = "-"
  26   if not (arg and arg[1]) then
  27     usage(arg)
  28   end
  29   if arg[1] == "-o" then
  30     outfile = arg[2]
  31     if not outfile then usage(arg) end
  32     table.remove(arg, 1)
  33     table.remove(arg, 1)
  34   end
  35   return outfile
  36 end
  37
  38 local function read_files(names)
  39   local src = ""
  40   for _,name in ipairs(names) do
  41     local fp = assert(io.open(name))
  42     src = src .. fp:read("*a")
  43     fp:close()
  44   end
  45   return src
  46 end
  47
  48 local function transform_lua(code)
  49   local fixup = {}
  50   local n = -30000
  51   code = string.gsub(code, "CHECK_(%w*)%((.-)%)", function(tp, var)
  52     n = n + 1
  53     fixup[n] = { "CHECK", tp }
  54     return format("%s=%d", var, n)
  55   end)
  56   code = string.gsub(code, "PAIRS%((.-)%)", function(var)
  57     fixup.PAIRS = true
  58     return format("nil, %s, 0", var)
  59   end)
  60   return "return "..code, fixup
  61 end
  62
  63 local function read_uleb128(p)
  64   local v = p[0]; p = p + 1
  65   if v >= 128 then
  66     local sh = 7; v = v - 128
  67     repeat
  68       local r = p[0]
  69       v = v + bit.lshift(bit.band(r, 127), sh)
  70       sh = sh + 7
  71       p = p + 1
  72     until r < 128
  73   end
  74   return p, v
  75 end
  76
  77 -- ORDER LJ_T
  78 local name2itype = {
  79   str = 5, func = 9, tab = 12, int = 14, num = 15
  80 }
  81
  82 local BC = {}
  83 for i=0,#bcnames/6-1 do
  84   BC[string.gsub(string.sub(bcnames, i*6+1, i*6+6), " ", "")] = i
  85 end
  86 local xop, xra = isbe and 3 or 0, isbe and 2 or 1
  87 local xrc, xrb = isbe and 1 or 2, isbe and 0 or 3
  88
  89 local function fixup_dump(dump, fixup)
  90   local buf = ffi.new("uint8_t[?]", #dump+1, dump)
  91   local p = buf+5
  92   local n, sizebc
  93   p, n = read_uleb128(p)
  94   local start = p
  95   p = p + 4
  96   p = read_uleb128(p)
  97   p = read_uleb128(p)
  98   p, sizebc = read_uleb128(p)
  99   local rawtab = {}
 100   for i=0,sizebc-1 do
 101     local op = p[xop]
 102     if op == BC.KSHORT then
 103       local rd = p[xrc] + 256*p[xrb]
 104       rd = bit.arshift(bit.lshift(rd, 16), 16)
 105       local f = fixup[rd]
 106       if f then
 107         if f[1] == "CHECK" then
 108           local tp = f[2]
 109           if tp == "tab" then rawtab[p[xra]] = true end
 110           p[xop] = tp == "num" and BC.ISNUM or BC.ISTYPE
 111           p[xrb] = 0
 112           p[xrc] = name2itype[tp]
 113         else
 114           error("unhandled fixup type: "..f[1])
 115         end
 116       end
 117     elseif op == BC.TGETV then
 118       if rawtab[p[xrb]] then
 119         p[xop] = BC.TGETR
 120       end
 121     elseif op == BC.TSETV then
 122       if rawtab[p[xrb]] then
 123         p[xop] = BC.TSETR
 124       end
 125     elseif op == BC.ITERC then
 126       if fixup.PAIRS then
 127         p[xop] = BC.ITERN
 128       end
 129     end
 130     p = p + 4
 131   end
 132   return ffi.string(start, n)
 133 end
 134
 135 local function find_defs(src)
 136   local defs = {}
 137   for name, code in string.gmatch(src, "LJLIB_LUA%(([^)]*)%)%s*/%*(.-)%*/") do
 138     local env = {}
 139     local tcode, fixup = transform_lua(code)
 140     local func = assert(load(tcode, "", nil, env))()
 141     defs[name] = fixup_dump(string.dump(func, true), fixup)
 142     defs[#defs+1] = name
 143   end
 144   return defs
 145 end
 146
 147 local function gen_header(defs)
 148   local t = {}
 149   local function w(x) t[#t+1] = x end
 150   w("/* This is a generated file. DO NOT EDIT! */\n\n")
 151   w("static const int libbc_endian = ") w(isbe and 1 or 0) w(";\n\n")
 152   local s = ""
 153   for _,name in ipairs(defs) do
 154     s = s .. defs[name]
 155   end
 156   w("static const uint8_t libbc_code[] = {\n")
 157   local n = 0
 158   for i=1,#s do
 159     local x = string.byte(s, i)
 160     w(x); w(",")
 161     n = n + (x < 10 and 2 or (x < 100 and 3 or 4))
 162     if n >= 75 then n = 0; w("\n") end
 163   end
 164   w("0\n};\n\n")
 165   w("static const struct { const char *name; int ofs; } libbc_map[] = {\n")
 166   local m = 0
 167   for _,name in ipairs(defs) do
 168     w('{"'); w(name); w('",'); w(m) w('},\n')
 169     m = m + #defs[name]
 170   end
 171   w("{NULL,"); w(m); w("}\n};\n\n")
 172   return table.concat(t)
 173 end
 174
 175 local function write_file(name, data)
 176   if name == "-" then
 177     assert(io.write(data))
 178     assert(io.flush())
 179   else
 180     local fp = io.open(name)
 181     if fp then
 182       local old = fp:read("*a")
 183       fp:close()
 184       if data == old then return end
 185     end
 186     fp = assert(io.open(name, "w"))
 187     assert(fp:write(data))
 188     assert(fp:close())
 189   end
 190 end
 191
 192 local outfile = parse_arg(arg)
 193 local src = read_files(arg)
 194 local defs = find_defs(src)
 195 local hdr = gen_header(defs)
 196 write_file(outfile, hdr)
 197