One Level Up Top Level

src/host/genlibbc.lua - luajit-2.0-src

Functions defined

Source code

  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-2015 Mike Pall. All rights reserved.
  6. -- Released under the MIT license. See Copyright Notice in luajit.h
  7. ----------------------------------------------------------------------------

  9. local ffi = require("ffi")
  10. local bit = require("bit")
  11. local vmdef = require("jit.vmdef")
  12. local bcnames = vmdef.bcnames

  14. local format = string.format

  16. ‌local isbe = (string.byte(string.dump(function() end), 5) % 2 == 1)

  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

  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

  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

  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

  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

  77. -- ORDER LJ_T
  78. local name2itype = {
  79.   str = 5, func = 9, tab = 12, int = 14, num = 15
  80. }

  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

  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

  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

  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

  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

  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)

One Level Up Top Level