monotone

monotone Mtn Source Tree

Root/lua/lopcodes.h

1/*
2** $Id: lopcodes.h,v 1.125 2006/03/14 19:04:44 roberto Exp $
3** Opcodes for Lua virtual machine
4** See Copyright Notice in lua.h
5*/
6
7#ifndef lopcodes_h
8#define lopcodes_h
9
10#include "llimits.h"
11
12
13/*===========================================================================
14 We assume that instructions are unsigned numbers.
15 All instructions have an opcode in the first 6 bits.
16 Instructions can have the following fields:
17`A' : 8 bits
18`B' : 9 bits
19`C' : 9 bits
20`Bx' : 18 bits (`B' and `C' together)
21`sBx' : signed Bx
22
23 A signed argument is represented in excess K; that is, the number
24 value is the unsigned value minus K. K is exactly the maximum value
25 for that argument (so that -max is represented by 0, and +max is
26 represented by 2*max), which is half the maximum for the corresponding
27 unsigned argument.
28===========================================================================*/
29
30
31enum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */
32
33
34/*
35** size and position of opcode arguments.
36*/
37#define SIZE_C9
38#define SIZE_B9
39#define SIZE_Bx(SIZE_C + SIZE_B)
40#define SIZE_A8
41
42#define SIZE_OP6
43
44#define POS_OP0
45#define POS_A(POS_OP + SIZE_OP)
46#define POS_C(POS_A + SIZE_A)
47#define POS_B(POS_C + SIZE_C)
48#define POS_BxPOS_C
49
50
51/*
52** limits for opcode arguments.
53** we use (signed) int to manipulate most arguments,
54** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
55*/
56#if SIZE_Bx < LUAI_BITSINT-1
57#define MAXARG_Bx ((1<<SIZE_Bx)-1)
58#define MAXARG_sBx (MAXARG_Bx>>1) /* `sBx' is signed */
59#else
60#define MAXARG_Bx MAX_INT
61#define MAXARG_sBx MAX_INT
62#endif
63
64
65#define MAXARG_A ((1<<SIZE_A)-1)
66#define MAXARG_B ((1<<SIZE_B)-1)
67#define MAXARG_C ((1<<SIZE_C)-1)
68
69
70/* creates a mask with `n' 1 bits at position `p' */
71#define MASK1(n,p)((~((~(Instruction)0)<<n))<<p)
72
73/* creates a mask with `n' 0 bits at position `p' */
74#define MASK0(n,p)(~MASK1(n,p))
75
76/*
77** the following macros help to manipulate instructions
78*/
79
80#define GET_OPCODE(i)(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
81#define SET_OPCODE(i,o)((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
82((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
83
84#define GETARG_A(i)(cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
85#define SETARG_A(i,u)((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
86((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
87
88#define GETARG_B(i)(cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
89#define SETARG_B(i,b)((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
90((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
91
92#define GETARG_C(i)(cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
93#define SETARG_C(i,b)((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
94((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
95
96#define GETARG_Bx(i)(cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
97#define SETARG_Bx(i,b)((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
98((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
99
100#define GETARG_sBx(i)(GETARG_Bx(i)-MAXARG_sBx)
101#define SETARG_sBx(i,b)SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
102
103
104#define CREATE_ABC(o,a,b,c)((cast(Instruction, o)<<POS_OP) \
105| (cast(Instruction, a)<<POS_A) \
106| (cast(Instruction, b)<<POS_B) \
107| (cast(Instruction, c)<<POS_C))
108
109#define CREATE_ABx(o,a,bc)((cast(Instruction, o)<<POS_OP) \
110| (cast(Instruction, a)<<POS_A) \
111| (cast(Instruction, bc)<<POS_Bx))
112
113
114/*
115** Macros to operate RK indices
116*/
117
118/* this bit 1 means constant (0 means register) */
119#define BITRK(1 << (SIZE_B - 1))
120
121/* test whether value is a constant */
122#define ISK(x)((x) & BITRK)
123
124/* gets the index of the constant */
125#define INDEXK(r)((int)(r) & ~BITRK)
126
127#define MAXINDEXRK(BITRK - 1)
128
129/* code a constant index as a RK value */
130#define RKASK(x)((x) | BITRK)
131
132
133/*
134** invalid register that fits in 8 bits
135*/
136#define NO_REGMAXARG_A
137
138
139/*
140** R(x) - register
141** Kst(x) - constant (in constant table)
142** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
143*/
144
145
146/*
147** grep "ORDER OP" if you change these enums
148*/
149
150typedef enum {
151/*----------------------------------------------------------------------
152nameargsdescription
153------------------------------------------------------------------------*/
154OP_MOVE,/*A BR(A) := R(B)*/
155OP_LOADK,/*A BxR(A) := Kst(Bx)*/
156OP_LOADBOOL,/*A B CR(A) := (Bool)B; if (C) pc++*/
157OP_LOADNIL,/*A BR(A) := ... := R(B) := nil*/
158OP_GETUPVAL,/*A BR(A) := UpValue[B]*/
159
160OP_GETGLOBAL,/*A BxR(A) := Gbl[Kst(Bx)]*/
161OP_GETTABLE,/*A B CR(A) := R(B)[RK(C)]*/
162
163OP_SETGLOBAL,/*A BxGbl[Kst(Bx)] := R(A)*/
164OP_SETUPVAL,/*A BUpValue[B] := R(A)*/
165OP_SETTABLE,/*A B CR(A)[RK(B)] := RK(C)*/
166
167OP_NEWTABLE,/*A B CR(A) := {} (size = B,C)*/
168
169OP_SELF,/*A B CR(A+1) := R(B); R(A) := R(B)[RK(C)]*/
170
171OP_ADD,/*A B CR(A) := RK(B) + RK(C)*/
172OP_SUB,/*A B CR(A) := RK(B) - RK(C)*/
173OP_MUL,/*A B CR(A) := RK(B) * RK(C)*/
174OP_DIV,/*A B CR(A) := RK(B) / RK(C)*/
175OP_MOD,/*A B CR(A) := RK(B) % RK(C)*/
176OP_POW,/*A B CR(A) := RK(B) ^ RK(C)*/
177OP_UNM,/*A BR(A) := -R(B)*/
178OP_NOT,/*A BR(A) := not R(B)*/
179OP_LEN,/*A BR(A) := length of R(B)*/
180
181OP_CONCAT,/*A B CR(A) := R(B).. ... ..R(C)*/
182
183OP_JMP,/*sBxpc+=sBx*/
184
185OP_EQ,/*A B Cif ((RK(B) == RK(C)) ~= A) then pc++*/
186OP_LT,/*A B Cif ((RK(B) < RK(C)) ~= A) then pc++ */
187OP_LE,/*A B Cif ((RK(B) <= RK(C)) ~= A) then pc++ */
188
189OP_TEST,/*A Cif not (R(A) <=> C) then pc++*/
190OP_TESTSET,/*A B Cif (R(B) <=> C) then R(A) := R(B) else pc++*/
191
192OP_CALL,/*A B CR(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
193OP_TAILCALL,/*A B Creturn R(A)(R(A+1), ... ,R(A+B-1))*/
194OP_RETURN,/*A Breturn R(A), ... ,R(A+B-2)(see note)*/
195
196OP_FORLOOP,/*A sBxR(A)+=R(A+2);
197if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
198OP_FORPREP,/*A sBxR(A)-=R(A+2); pc+=sBx*/
199
200OP_TFORLOOP,/*A CR(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
201 if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++*/
202OP_SETLIST,/*A B CR(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B*/
203
204OP_CLOSE,/*A close all variables in the stack up to (>=) R(A)*/
205OP_CLOSURE,/*A BxR(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))*/
206
207OP_VARARG/*A BR(A), R(A+1), ..., R(A+B-1) = vararg*/
208} OpCode;
209
210
211#define NUM_OPCODES(cast(int, OP_VARARG) + 1)
212
213
214
215/*===========================================================================
216 Notes:
217 (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
218 and can be 0: OP_CALL then sets `top' to last_result+1, so
219 next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
220
221 (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
222 set top (like in OP_CALL with C == 0).
223
224 (*) In OP_RETURN, if (B == 0) then return up to `top'
225
226 (*) In OP_SETLIST, if (B == 0) then B = `top';
227 if (C == 0) then next `instruction' is real C
228
229 (*) For comparisons, A specifies what condition the test should accept
230 (true or false).
231
232 (*) All `skips' (pc++) assume that next instruction is a jump
233===========================================================================*/
234
235
236/*
237** masks for instruction properties. The format is:
238** bits 0-1: op mode
239** bits 2-3: C arg mode
240** bits 4-5: B arg mode
241** bit 6: instruction set register A
242** bit 7: operator is a test
243*/
244
245enum OpArgMask {
246 OpArgN, /* argument is not used */
247 OpArgU, /* argument is used */
248 OpArgR, /* argument is a register or a jump offset */
249 OpArgK /* argument is a constant or register/constant */
250};
251
252LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
253
254#define getOpMode(m)(cast(enum OpMode, luaP_opmodes[m] & 3))
255#define getBMode(m)(cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
256#define getCMode(m)(cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
257#define testAMode(m)(luaP_opmodes[m] & (1 << 6))
258#define testTMode(m)(luaP_opmodes[m] & (1 << 7))
259
260
261LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */
262
263
264/* number of list items to accumulate before a SETLIST instruction */
265#define LFIELDS_PER_FLUSH50
266
267
268#endif

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status