| ------------------------------------------------------------------------------- |
| -- Copyright (c) 2005-2013 Kein-Hong Man, Fabien Fleutot and others. |
| -- |
| -- All rights reserved. |
| -- |
| -- This program and the accompanying materials are made available |
| -- under the terms of the Eclipse Public License v1.0 which |
| -- accompanies this distribution, and is available at |
| -- http://www.eclipse.org/legal/epl-v10.html |
| -- |
| -- This program and the accompanying materials are also made available |
| -- under the terms of the MIT public license which accompanies this |
| -- distribution, and is available at http://www.lua.org/license.html |
| -- |
| -- Contributors: |
| -- Kein-Hong Man - Initial implementation for Lua 5.0, part of Yueliang |
| -- Fabien Fleutot - Port to Lua 5.1, integration with Metalua |
| -- |
| ------------------------------------------------------------------------------- |
| |
| ---------------------------------------------------------------------- |
| -- |
| -- WARNING! You're entering a hackish area, proceed at your own risks! |
| -- |
| -- This code results from the borrowing, then ruthless abuse, of |
| -- Yueliang's implementation of Lua 5.0 compiler. I claim |
| -- responsibility for all of the ugly, dirty stuff that you might spot |
| -- in it. |
| -- |
| -- Eventually, this code will be rewritten, either in Lua or more |
| -- probably in C. Meanwhile, if you're interested into digging |
| -- metalua's sources, this is not the best part to invest your time |
| -- on. |
| -- |
| -- End of warning. |
| -- |
| ---------------------------------------------------------------------- |
| |
| --[[-------------------------------------------------------------------- |
| |
| $Id$ |
| |
| lopcodes.lua |
| Lua 5 virtual machine opcodes in Lua |
| This file is part of Yueliang. |
| |
| Copyright (c) 2005 Kein-Hong Man <khman@users.sf.net> |
| The COPYRIGHT file describes the conditions |
| under which this software may be distributed. |
| |
| See the ChangeLog for more information. |
| |
| ------------------------------------------------------------------------ |
| |
| [FF] Slightly modified, mainly to produce Lua 5.1 bytecode. |
| |
| ----------------------------------------------------------------------]] |
| |
| --[[-------------------------------------------------------------------- |
| -- Notes: |
| -- * an Instruction is a table with OP, A, B, C, Bx elements; this |
| -- should allow instruction handling to work with doubles and ints |
| -- * Added: |
| -- luaP:Instruction(i): convert field elements to a 4-char string |
| -- luaP:DecodeInst(x): convert 4-char string into field elements |
| -- * WARNING luaP:Instruction outputs instructions encoded in little- |
| -- endian form and field size and positions are hard-coded |
| ----------------------------------------------------------------------]] |
| |
| local function debugf() end |
| |
| local luaP = { } |
| |
| --[[ |
| =========================================================================== |
| We assume that instructions are unsigned numbers. |
| All instructions have an opcode in the first 6 bits. |
| Instructions can have the following fields: |
| 'A' : 8 bits |
| 'B' : 9 bits |
| 'C' : 9 bits |
| 'Bx' : 18 bits ('B' and 'C' together) |
| 'sBx' : signed Bx |
| |
| A signed argument is represented in excess K; that is, the number |
| value is the unsigned value minus K. K is exactly the maximum value |
| for that argument (so that -max is represented by 0, and +max is |
| represented by 2*max), which is half the maximum for the corresponding |
| unsigned argument. |
| =========================================================================== |
| --]] |
| |
| luaP.OpMode = {"iABC", "iABx", "iAsBx"} -- basic instruction format |
| |
| ------------------------------------------------------------------------ |
| -- size and position of opcode arguments. |
| -- * WARNING size and position is hard-coded elsewhere in this script |
| ------------------------------------------------------------------------ |
| luaP.SIZE_C = 9 |
| luaP.SIZE_B = 9 |
| luaP.SIZE_Bx = luaP.SIZE_C + luaP.SIZE_B |
| luaP.SIZE_A = 8 |
| |
| luaP.SIZE_OP = 6 |
| |
| luaP.POS_C = luaP.SIZE_OP |
| luaP.POS_B = luaP.POS_C + luaP.SIZE_C |
| luaP.POS_Bx = luaP.POS_C |
| luaP.POS_A = luaP.POS_B + luaP.SIZE_B |
| |
| --FF from 5.1 |
| luaP.BITRK = 2^(luaP.SIZE_B - 1) |
| function luaP:ISK(x) return x >= self.BITRK end |
| luaP.MAXINDEXRK = luaP.BITRK - 1 |
| function luaP:RKASK(x) |
| if x < self.BITRK then return x+self.BITRK else return x end |
| end |
| |
| |
| |
| ------------------------------------------------------------------------ |
| -- limits for opcode arguments. |
| -- we use (signed) int to manipulate most arguments, |
| -- so they must fit in BITS_INT-1 bits (-1 for sign) |
| ------------------------------------------------------------------------ |
| -- removed "#if SIZE_Bx < BITS_INT-1" test, assume this script is |
| -- running on a Lua VM with double or int as LUA_NUMBER |
| |
| luaP.MAXARG_Bx = math.ldexp(1, luaP.SIZE_Bx) - 1 |
| luaP.MAXARG_sBx = math.floor(luaP.MAXARG_Bx / 2) -- 'sBx' is signed |
| |
| luaP.MAXARG_A = math.ldexp(1, luaP.SIZE_A) - 1 |
| luaP.MAXARG_B = math.ldexp(1, luaP.SIZE_B) - 1 |
| luaP.MAXARG_C = math.ldexp(1, luaP.SIZE_C) - 1 |
| |
| -- creates a mask with 'n' 1 bits at position 'p' |
| -- MASK1(n,p) deleted |
| -- creates a mask with 'n' 0 bits at position 'p' |
| -- MASK0(n,p) deleted |
| |
| --[[-------------------------------------------------------------------- |
| Visual representation for reference: |
| |
| 31 | | | 0 bit position |
| +-----+-----+-----+----------+ |
| | B | C | A | Opcode | iABC format |
| +-----+-----+-----+----------+ |
| - 9 - 9 - 8 - 6 - field sizes |
| +-----+-----+-----+----------+ |
| | [s]Bx | A | Opcode | iABx | iAsBx format |
| +-----+-----+-----+----------+ |
| ----------------------------------------------------------------------]] |
| |
| ------------------------------------------------------------------------ |
| -- the following macros help to manipulate instructions |
| -- * changed to a table object representation, very clean compared to |
| -- the [nightmare] alternatives of using a number or a string |
| ------------------------------------------------------------------------ |
| |
| -- these accept or return opcodes in the form of string names |
| function luaP:GET_OPCODE(i) return self.ROpCode[i.OP] end |
| function luaP:SET_OPCODE(i, o) i.OP = self.OpCode[o] end |
| |
| function luaP:GETARG_A(i) return i.A end |
| function luaP:SETARG_A(i, u) i.A = u end |
| |
| function luaP:GETARG_B(i) return i.B end |
| function luaP:SETARG_B(i, b) i.B = b end |
| |
| function luaP:GETARG_C(i) return i.C end |
| function luaP:SETARG_C(i, b) i.C = b end |
| |
| function luaP:GETARG_Bx(i) return i.Bx end |
| function luaP:SETARG_Bx(i, b) i.Bx = b end |
| |
| function luaP:GETARG_sBx(i) return i.Bx - self.MAXARG_sBx end |
| function luaP:SETARG_sBx(i, b) i.Bx = b + self.MAXARG_sBx end |
| |
| function luaP:CREATE_ABC(o,a,b,c) |
| return {OP = self.OpCode[o], A = a, B = b, C = c} |
| end |
| |
| function luaP:CREATE_ABx(o,a,bc) |
| return {OP = self.OpCode[o], A = a, Bx = bc} |
| end |
| |
| ------------------------------------------------------------------------ |
| -- Bit shuffling stuffs |
| ------------------------------------------------------------------------ |
| |
| if false and pcall (require, 'bit') then |
| ------------------------------------------------------------------------ |
| -- Return a 4-char string little-endian encoded form of an instruction |
| ------------------------------------------------------------------------ |
| function luaP:Instruction(i) |
| --FIXME |
| end |
| else |
| ------------------------------------------------------------------------ |
| -- Version without bit manipulation library. |
| ------------------------------------------------------------------------ |
| local p2 = {1,2,4,8,16,32,64,128,256, 512, 1024, 2048, 4096} |
| -- keeps [n] bits from [x] |
| local function keep (x, n) return x % p2[n+1] end |
| -- shifts bits of [x] [n] places to the right |
| local function srb (x,n) return math.floor (x / p2[n+1]) end |
| -- shifts bits of [x] [n] places to the left |
| local function slb (x,n) return x * p2[n+1] end |
| |
| ------------------------------------------------------------------------ |
| -- Return a 4-char string little-endian encoded form of an instruction |
| ------------------------------------------------------------------------ |
| function luaP:Instruction(i) |
| -- printf("Instr->string: %s %s", self.opnames[i.OP], table.tostring(i)) |
| local c0, c1, c2, c3 |
| -- change to OP/A/B/C format if needed |
| if i.Bx then i.C = keep (i.Bx, 9); i.B = srb (i.Bx, 9) end |
| -- c0 = 6B from opcode + 2LSB from A (flushed to MSB) |
| c0 = i.OP + slb (keep (i.A, 2), 6) |
| -- c1 = 6MSB from A + 2LSB from C (flushed to MSB) |
| c1 = srb (i.A, 2) + slb (keep (i.C, 2), 6) |
| -- c2 = 7MSB from C + 1LSB from B (flushed to MSB) |
| c2 = srb (i.C, 2) + slb (keep (i.B, 1), 7) |
| -- c3 = 8MSB from B |
| c3 = srb (i.B, 1) |
| --printf ("Instruction: %s %s", self.opnames[i.OP], tostringv (i)) |
| --printf ("Bin encoding: %x %x %x %x", c0, c1, c2, c3) |
| return string.char(c0, c1, c2, c3) |
| end |
| end |
| ------------------------------------------------------------------------ |
| -- decodes a 4-char little-endian string into an instruction struct |
| ------------------------------------------------------------------------ |
| function luaP:DecodeInst(x) |
| error "Not implemented" |
| end |
| |
| ------------------------------------------------------------------------ |
| -- invalid register that fits in 8 bits |
| ------------------------------------------------------------------------ |
| luaP.NO_REG = luaP.MAXARG_A |
| |
| ------------------------------------------------------------------------ |
| -- R(x) - register |
| -- Kst(x) - constant (in constant table) |
| -- RK(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK) |
| ------------------------------------------------------------------------ |
| |
| ------------------------------------------------------------------------ |
| -- grep "ORDER OP" if you change these enums |
| ------------------------------------------------------------------------ |
| |
| --[[-------------------------------------------------------------------- |
| Lua virtual machine opcodes (enum OpCode): |
| ------------------------------------------------------------------------ |
| name args description |
| ------------------------------------------------------------------------ |
| OP_MOVE A B R(A) := R(B) |
| OP_LOADK A Bx R(A) := Kst(Bx) |
| OP_LOADBOOL A B C R(A) := (Bool)B; if (C) PC++ |
| OP_LOADNIL A B R(A) := ... := R(B) := nil |
| OP_GETUPVAL A B R(A) := UpValue[B] |
| OP_GETGLOBAL A Bx R(A) := Gbl[Kst(Bx)] |
| OP_GETTABLE A B C R(A) := R(B)[RK(C)] |
| OP_SETGLOBAL A Bx Gbl[Kst(Bx)] := R(A) |
| OP_SETUPVAL A B UpValue[B] := R(A) |
| OP_SETTABLE A B C R(A)[RK(B)] := RK(C) |
| OP_NEWTABLE A B C R(A) := {} (size = B,C) |
| OP_SELF A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] |
| OP_ADD A B C R(A) := RK(B) + RK(C) |
| OP_SUB A B C R(A) := RK(B) - RK(C) |
| OP_MUL A B C R(A) := RK(B) * RK(C) |
| OP_DIV A B C R(A) := RK(B) / RK(C) |
| OP_POW A B C R(A) := RK(B) ^ RK(C) |
| OP_UNM A B R(A) := -R(B) |
| OP_NOT A B R(A) := not R(B) |
| OP_CONCAT A B C R(A) := R(B).. ... ..R(C) |
| OP_JMP sBx PC += sBx |
| OP_EQ A B C if ((RK(B) == RK(C)) ~= A) then pc++ |
| OP_LT A B C if ((RK(B) < RK(C)) ~= A) then pc++ |
| OP_LE A B C if ((RK(B) <= RK(C)) ~= A) then pc++ |
| OP_TEST A B C if (R(B) <=> C) then R(A) := R(B) else pc++ |
| OP_CALL A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) |
| OP_TAILCALL A B C return R(A)(R(A+1), ... ,R(A+B-1)) |
| OP_RETURN A B return R(A), ... ,R(A+B-2) (see note) |
| OP_FORLOOP A sBx R(A)+=R(A+2); if R(A) <?= R(A+1) then PC+= sBx |
| OP_TFORLOOP A C R(A+2), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); |
| if R(A+2) ~= nil then pc++ |
| OP_TFORPREP A sBx if type(R(A)) == table then R(A+1):=R(A), R(A):=next; |
| PC += sBx |
| OP_SETLIST A Bx R(A)[Bx-Bx%FPF+i] := R(A+i), 1 <= i <= Bx%FPF+1 |
| OP_SETLISTO A Bx (see note) |
| OP_CLOSE A close all variables in the stack up to (>=) R(A) |
| OP_CLOSURE A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) |
| ----------------------------------------------------------------------]] |
| |
| luaP.opnames = {} -- opcode names |
| luaP.OpCode = {} -- lookup name -> number |
| luaP.ROpCode = {} -- lookup number -> name |
| |
| local i = 0 |
| for v in string.gfind([[ |
| MOVE -- 0 |
| LOADK |
| LOADBOOL |
| LOADNIL |
| GETUPVAL |
| GETGLOBAL -- 5 |
| GETTABLE |
| SETGLOBAL |
| SETUPVAL |
| SETTABLE |
| NEWTABLE -- 10 |
| SELF |
| ADD |
| SUB |
| MUL |
| DIV -- 15 |
| MOD |
| POW |
| UNM |
| NOT |
| LEN -- 20 |
| CONCAT |
| JMP |
| EQ |
| LT |
| LE -- 25 |
| TEST |
| TESTSET |
| CALL |
| TAILCALL |
| RETURN -- 30 |
| FORLOOP |
| FORPREP |
| TFORLOOP |
| SETLIST |
| CLOSE -- 35 |
| CLOSURE |
| VARARG |
| ]], "[%a]+") do |
| local n = "OP_"..v |
| luaP.opnames[i] = v |
| luaP.OpCode[n] = i |
| luaP.ROpCode[i] = n |
| i = i + 1 |
| end |
| luaP.NUM_OPCODES = i |
| |
| --[[ |
| =========================================================================== |
| Notes: |
| (1) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1, |
| and can be 0: OP_CALL then sets 'top' to last_result+1, so |
| next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use 'top'. |
| |
| (2) In OP_RETURN, if (B == 0) then return up to 'top' |
| |
| (3) For comparisons, B specifies what conditions the test should accept. |
| |
| (4) All 'skips' (pc++) assume that next instruction is a jump |
| |
| (5) OP_SETLISTO is used when the last item in a table constructor is a |
| function, so the number of elements set is up to top of stack |
| =========================================================================== |
| --]] |
| |
| ------------------------------------------------------------------------ |
| -- masks for instruction properties |
| ------------------------------------------------------------------------ |
| -- was enum OpModeMask: |
| luaP.OpModeBreg = 2 -- B is a register |
| luaP.OpModeBrk = 3 -- B is a register/constant |
| luaP.OpModeCrk = 4 -- C is a register/constant |
| luaP.OpModesetA = 5 -- instruction set register A |
| luaP.OpModeK = 6 -- Bx is a constant |
| luaP.OpModeT = 1 -- operator is a test |
| |
| ------------------------------------------------------------------------ |
| -- get opcode mode, e.g. "iABC" |
| ------------------------------------------------------------------------ |
| function luaP:getOpMode(m) |
| --printv(m) |
| --printv(self.OpCode[m]) |
| --printv(self.opmodes [self.OpCode[m]+1]) |
| return self.OpMode[tonumber(string.sub(self.opmodes[self.OpCode[m] + 1], 7, 7))] |
| end |
| |
| ------------------------------------------------------------------------ |
| -- test an instruction property flag |
| -- * b is a string, e.g. "OpModeBreg" |
| ------------------------------------------------------------------------ |
| function luaP:testOpMode(m, b) |
| return (string.sub(self.opmodes[self.OpCode[m] + 1], self[b], self[b]) == "1") |
| end |
| |
| -- number of list items to accumulate before a SETLIST instruction |
| -- (must be a power of 2) |
| -- * used in lparser, lvm, ldebug, ltests |
| luaP.LFIELDS_PER_FLUSH = 50 --FF updated to match 5.1 |
| |
| -- luaP_opnames[] is set above, as the luaP.opnames table |
| -- opmode(t,b,bk,ck,sa,k,m) deleted |
| |
| --[[-------------------------------------------------------------------- |
| Legend for luaP:opmodes: |
| 1 T -> T (is a test?) |
| 2 B -> B is a register |
| 3 b -> B is an RK register/constant combination |
| 4 C -> C is an RK register/constant combination |
| 5 A -> register A is set by the opcode |
| 6 K -> Bx is a constant |
| 7 m -> 1 if iABC layout, |
| 2 if iABx layout, |
| 3 if iAsBx layout |
| ----------------------------------------------------------------------]] |
| |
| luaP.opmodes = { |
| -- TBbCAKm opcode |
| "0100101", -- OP_MOVE 0 |
| "0000112", -- OP_LOADK |
| "0000101", -- OP_LOADBOOL |
| "0100101", -- OP_LOADNIL |
| "0000101", -- OP_GETUPVAL |
| "0000112", -- OP_GETGLOBAL 5 |
| "0101101", -- OP_GETTABLE |
| "0000012", -- OP_SETGLOBAL |
| "0000001", -- OP_SETUPVAL |
| "0011001", -- OP_SETTABLE |
| "0000101", -- OP_NEWTABLE 10 |
| "0101101", -- OP_SELF |
| "0011101", -- OP_ADD |
| "0011101", -- OP_SUB |
| "0011101", -- OP_MUL |
| "0011101", -- OP_DIV 15 |
| "0011101", -- OP_MOD |
| "0011101", -- OP_POW |
| "0100101", -- OP_UNM |
| "0100101", -- OP_NOT |
| "0100101", -- OP_LEN 20 |
| "0101101", -- OP_CONCAT |
| "0000003", -- OP_JMP |
| "1011001", -- OP_EQ |
| "1011001", -- OP_LT |
| "1011001", -- OP_LE 25 |
| "1000101", -- OP_TEST |
| "1100101", -- OP_TESTSET |
| "0000001", -- OP_CALL |
| "0000001", -- OP_TAILCALL |
| "0000001", -- OP_RETURN 30 |
| "0000003", -- OP_FORLOOP |
| "0000103", -- OP_FORPREP |
| "1000101", -- OP_TFORLOOP |
| "0000001", -- OP_SETLIST |
| "0000001", -- OP_CLOSE 35 |
| "0000102", -- OP_CLOSURE |
| "0000101" -- OP_VARARG |
| } |
| |
| return luaP |
