Created
June 12, 2012 17:10
-
-
Save leegao/2918746 to your computer and use it in GitHub Desktop.
Lua Bytecode
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// from lopcodes.h | |
/* | |
** R(x) - register | |
** Kst(x) - constant (in constant table) | |
** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x) | |
*/ | |
// Here, x can be three things | |
// x can be a variable denoting a register (its 8th bit is 0), in which case R(x) returns the value of the x-th register | |
// x can be a variable index to a constant (string or something, its 8th bit is 1), in which case INDEXK(x) returns the actual index | |
// x can be the actual index itself | |
// Each instruction may have up to 3 arguments. They are | |
// A - 8 bits | |
// B - 9 bits | |
// C - 9 bits | |
// Occasionally, a larger integer container is needed for some operands, which is done by concatenating the B and C arguments together | |
// Bx - 18 bytes, = B<<9|C | |
// The above arguments are all unsigned. There is a single signed argument sBx, which is just Bx-bias | |
// UpValues are known variables that escape the scope of the current function but are not global (see escape analysis) | |
/* | |
** grep "ORDER OP" if you change these enums | |
*/ | |
typedef enum { | |
/*---------------------------------------------------------------------- | |
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++ Note that (Bool)B isn't the value of the register associated with B, but B itself */ | |
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_MOD,/* 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_LEN,/* A B R(A) := length of 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 C if not (R(A) <=> C) then pc++ */ | |
OP_TESTSET,/* 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; R(A+3)=R(A) }*/ | |
OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */ | |
OP_TFORLOOP,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); | |
if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++ */ | |
OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */ | |
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)) */ | |
OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */ | |
} OpCode; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment