From b7bdf7d5d36825a1a750a74641f6d374dec5d67a Mon Sep 17 00:00:00 2001 From: Li Jin Date: Wed, 21 Apr 2021 09:36:25 +0800 Subject: adjust some folder levels. --- src/lua/lopcodes.h | 392 ----------------------------------------------------- 1 file changed, 392 deletions(-) delete mode 100644 src/lua/lopcodes.h (limited to 'src/lua/lopcodes.h') diff --git a/src/lua/lopcodes.h b/src/lua/lopcodes.h deleted file mode 100644 index d6a47e5..0000000 --- a/src/lua/lopcodes.h +++ /dev/null @@ -1,392 +0,0 @@ -/* -** $Id: lopcodes.h $ -** Opcodes for Lua virtual machine -** See Copyright Notice in lua.h -*/ - -#ifndef lopcodes_h -#define lopcodes_h - -#include "llimits.h" - - -/*=========================================================================== - We assume that instructions are unsigned 32-bit integers. - All instructions have an opcode in the first 7 bits. - Instructions can have the following formats: - - 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 - 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 -iABC C(8) | B(8) |k| A(8) | Op(7) | -iABx Bx(17) | A(8) | Op(7) | -iAsBx sBx (signed)(17) | A(8) | Op(7) | -iAx Ax(25) | Op(7) | -isJ sJ(25) | Op(7) | - - A signed argument is represented in excess K: the represented value is - the written unsigned value minus K, where K is half the maximum for the - corresponding unsigned argument. -===========================================================================*/ - - -enum OpMode {iABC, iABx, iAsBx, iAx, isJ}; /* basic instruction formats */ - - -/* -** size and position of opcode arguments. -*/ -#define SIZE_C 8 -#define SIZE_B 8 -#define SIZE_Bx (SIZE_C + SIZE_B + 1) -#define SIZE_A 8 -#define SIZE_Ax (SIZE_Bx + SIZE_A) -#define SIZE_sJ (SIZE_Bx + SIZE_A) - -#define SIZE_OP 7 - -#define POS_OP 0 - -#define POS_A (POS_OP + SIZE_OP) -#define POS_k (POS_A + SIZE_A) -#define POS_B (POS_k + 1) -#define POS_C (POS_B + SIZE_B) - -#define POS_Bx POS_k - -#define POS_Ax POS_A - -#define POS_sJ POS_A - - -/* -** limits for opcode arguments. -** we use (signed) 'int' to manipulate most arguments, -** so they must fit in ints. -*/ - -/* Check whether type 'int' has at least 'b' bits ('b' < 32) */ -#define L_INTHASBITS(b) ((UINT_MAX >> ((b) - 1)) >= 1) - - -#if L_INTHASBITS(SIZE_Bx) -#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ - - -#if L_INTHASBITS(SIZE_Ax) -#define MAXARG_Ax ((1<> 1) - - -#define MAXARG_A ((1<> 1) - -#define int2sC(i) ((i) + OFFSET_sC) -#define sC2int(i) ((i) - OFFSET_sC) - - -/* creates a mask with 'n' 1 bits at position 'p' */ -#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) - -/* creates a mask with 'n' 0 bits at position 'p' */ -#define MASK0(n,p) (~MASK1(n,p)) - -/* -** the following macros help to manipulate instructions -*/ - -#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) -#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ - ((cast(Instruction, o)<>(pos)) & MASK1(size,0))) -#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ - ((cast(Instruction, v)<> sC */ -OP_SHLI,/* A B sC R[A] := sC << R[B] */ - -OP_ADD,/* A B C R[A] := R[B] + R[C] */ -OP_SUB,/* A B C R[A] := R[B] - R[C] */ -OP_MUL,/* A B C R[A] := R[B] * R[C] */ -OP_MOD,/* A B C R[A] := R[B] % R[C] */ -OP_POW,/* A B C R[A] := R[B] ^ R[C] */ -OP_DIV,/* A B C R[A] := R[B] / R[C] */ -OP_IDIV,/* A B C R[A] := R[B] // R[C] */ - -OP_BAND,/* A B C R[A] := R[B] & R[C] */ -OP_BOR,/* A B C R[A] := R[B] | R[C] */ -OP_BXOR,/* A B C R[A] := R[B] ~ R[C] */ -OP_SHL,/* A B C R[A] := R[B] << R[C] */ -OP_SHR,/* A B C R[A] := R[B] >> R[C] */ - -OP_MMBIN,/* A B C call C metamethod over R[A] and R[B] */ -OP_MMBINI,/* A sB C k call C metamethod over R[A] and sB */ -OP_MMBINK,/* A B C k call C metamethod over R[A] and K[B] */ - -OP_UNM,/* A B R[A] := -R[B] */ -OP_BNOT,/* A B R[A] := ~R[B] */ -OP_NOT,/* A B R[A] := not R[B] */ -OP_LEN,/* A B R[A] := #R[B] (length operator) */ - -OP_CONCAT,/* A B R[A] := R[A].. ... ..R[A + B - 1] */ - -OP_CLOSE,/* A close all upvalues >= R[A] */ -OP_TBC,/* A mark variable A "to be closed" */ -OP_JMP,/* sJ pc += sJ */ -OP_EQ,/* A B k if ((R[A] == R[B]) ~= k) then pc++ */ -OP_LT,/* A B k if ((R[A] < R[B]) ~= k) then pc++ */ -OP_LE,/* A B k if ((R[A] <= R[B]) ~= k) then pc++ */ - -OP_EQK,/* A B k if ((R[A] == K[B]) ~= k) then pc++ */ -OP_EQI,/* A sB k if ((R[A] == sB) ~= k) then pc++ */ -OP_LTI,/* A sB k if ((R[A] < sB) ~= k) then pc++ */ -OP_LEI,/* A sB k if ((R[A] <= sB) ~= k) then pc++ */ -OP_GTI,/* A sB k if ((R[A] > sB) ~= k) then pc++ */ -OP_GEI,/* A sB k if ((R[A] >= sB) ~= k) then pc++ */ - -OP_TEST,/* A k if (not R[A] == k) then pc++ */ -OP_TESTSET,/* A B k if (not R[B] == k) then pc++ else R[A] := R[B] */ - -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 k return R[A](R[A+1], ... ,R[A+B-1]) */ - -OP_RETURN,/* A B C k return R[A], ... ,R[A+B-2] (see note) */ -OP_RETURN0,/* return */ -OP_RETURN1,/* A return R[A] */ - -OP_FORLOOP,/* A Bx update counters; if loop continues then pc-=Bx; */ -OP_FORPREP,/* A Bx ; - if not to run then pc+=Bx+1; */ - -OP_TFORPREP,/* A Bx create upvalue for R[A + 3]; pc+=Bx */ -OP_TFORCALL,/* A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]); */ -OP_TFORLOOP,/* A Bx if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */ - -OP_SETLIST,/* A B C k R[A][C+i] := R[A+i], 1 <= i <= B */ - -OP_CLOSURE,/* A Bx R[A] := closure(KPROTO[Bx]) */ - -OP_VARARG,/* A C R[A], R[A+1], ..., R[A+C-2] = vararg */ - -OP_VARARGPREP,/*A (adjust vararg parameters) */ - -OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */ -} OpCode; - - -#define NUM_OPCODES ((int)(OP_EXTRAARG) + 1) - - - -/*=========================================================================== - Notes: - (*) In OP_CALL, if (B == 0) then B = top - A. If (C == 0), then - 'top' is set to last_result+1, so next open instruction (OP_CALL, - OP_RETURN*, OP_SETLIST) may use 'top'. - - (*) In OP_VARARG, if (C == 0) then use actual number of varargs and - set top (like in OP_CALL with C == 0). - - (*) In OP_RETURN, if (B == 0) then return up to 'top'. - - (*) In OP_LOADKX and OP_NEWTABLE, the next instruction is always - OP_EXTRAARG. - - (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if k, then - real C = EXTRAARG _ C (the bits of EXTRAARG concatenated with the - bits of C). - - (*) In OP_NEWTABLE, B is log2 of the hash size (which is always a - power of 2) plus 1, or zero for size zero. If not k, the array size - is C. Otherwise, the array size is EXTRAARG _ C. - - (*) For comparisons, k specifies what condition the test should accept - (true or false). - - (*) In OP_MMBINI/OP_MMBINK, k means the arguments were flipped - (the constant is the first operand). - - (*) All 'skips' (pc++) assume that next instruction is a jump. - - (*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the - function builds upvalues, which may need to be closed. C > 0 means - the function is vararg, so that its 'func' must be corrected before - returning; in this case, (C - 1) is its number of fixed parameters. - - (*) In comparisons with an immediate operand, C signals whether the - original operand was a float. (It must be corrected in case of - metamethods.) - -===========================================================================*/ - - -/* -** masks for instruction properties. The format is: -** bits 0-2: op mode -** bit 3: instruction set register A -** bit 4: operator is a test (next instruction must be a jump) -** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0) -** bit 6: instruction sets 'L->top' for next instruction (when C == 0) -** bit 7: instruction is an MM instruction (call a metamethod) -*/ - -LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];) - -#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 7)) -#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) -#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) -#define testITMode(m) (luaP_opmodes[m] & (1 << 5)) -#define testOTMode(m) (luaP_opmodes[m] & (1 << 6)) -#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) - -/* "out top" (set top for next instruction) */ -#define isOT(i) \ - ((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \ - GET_OPCODE(i) == OP_TAILCALL) - -/* "in top" (uses top from previous instruction) */ -#define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0) - -#define opmode(mm,ot,it,t,a,m) \ - (((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m)) - - -/* number of list items to accumulate before a SETLIST instruction */ -#define LFIELDS_PER_FLUSH 50 - -#endif -- cgit v1.2.3-55-g6feb