opensources
/
lua
mirror of https://github.com/lua/lua.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

new opcode INCLOCAL.

v5-2
Roberto Ierusalimschy 25 years ago
parent
3e45496295
commit
4e7e9e8de5
4 changed files with 132 additions and 81 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 89
      lcode.c
  2. 6
      llimits.h
  3. 77
      lopcodes.h
  4. 41
      lvm.c

89
lcode.c
View File

@ -1,10 +1,12 @@
/*
** $Id: lcode.c,v 1.17 2000/03/24 12:18:30 roberto Exp roberto $
** $Id: lcode.c,v 1.18 2000/03/24 17:26:08 roberto Exp roberto $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
#include "stdlib.h"
#define LUA_REENTRANT
#include "lcode.h"
@ -73,11 +75,12 @@ static void setprevious (FuncState *fs, Instruction i) {
static void luaK_minus (FuncState *fs) {
/* PUSHINT s; MINUS -> PUSHINT -s (-k) */
/* PUSHNUM u; MINUS -> PUSHNEGNUM u (-k) */
Instruction previous = prepare(fs, CREATE_0(OP_MINUS), 0);
switch(GET_OPCODE(previous)) {
case OP_PUSHINT: SETARG_S(previous, -GETARG_S(previous)); break;
case OP_PUSHNUM: SET_OPCODE(previous, OP_PUSHNEGNUM); break;
case OP_PUSHNEGNUM: SET_OPCODE(previous, OP_PUSHNUM); break;
default: return;
}
setprevious(fs, previous);
@ -85,6 +88,7 @@ static void luaK_minus (FuncState *fs) {
static void luaK_gettable (FuncState *fs) {
/* PUSHSTRING u; GETTABLE -> GETDOTTED u (t.x) */
Instruction previous = prepare(fs, CREATE_0(OP_GETTABLE), -1);
switch(GET_OPCODE(previous)) {
case OP_PUSHSTRING: SET_OPCODE(previous, OP_GETDOTTED); break;
@ -95,6 +99,7 @@ static void luaK_gettable (FuncState *fs) {
static void luaK_add (FuncState *fs) {
/* PUSHINT s; ADD -> ADDI s (a+k) */
Instruction previous = prepare(fs, CREATE_0(OP_ADD), -1);
switch(GET_OPCODE(previous)) {
case OP_PUSHINT: SET_OPCODE(previous, OP_ADDI); break;
@ -105,6 +110,7 @@ static void luaK_add (FuncState *fs) {
static void luaK_sub (FuncState *fs) {
/* PUSHINT s; SUB -> ADDI -s (a-k) */
Instruction previous = prepare(fs, CREATE_0(OP_SUB), -1);
switch(GET_OPCODE(previous)) {
case OP_PUSHINT:
@ -118,6 +124,7 @@ static void luaK_sub (FuncState *fs) {
static void luaK_conc (FuncState *fs) {
/* CONC u; CONC 2 -> CONC u+1 (a..b..c) */
Instruction previous = prepare(fs, CREATE_U(OP_CONC, 2), -1);
switch(GET_OPCODE(previous)) {
case OP_CONC: SETARG_U(previous, GETARG_U(previous)+1); break;
@ -127,8 +134,27 @@ static void luaK_conc (FuncState *fs) {
}
static void luaK_setlocal (FuncState *fs, int l) {
/* PUSHLOCAL l; ADDI k, SETLOCAL l -> INCLOCAL k, l ((local)a=a+k) */
Instruction *code = fs->f->code;
int pc = fs->pc;
if (pc-1 > fs->lasttarget && /* no jumps in-between instructions? */
code[pc-2] == CREATE_U(OP_PUSHLOCAL, l) &&
GET_OPCODE(code[pc-1]) == OP_ADDI &&
abs(GETARG_S(code[pc-1])) <= MAXARG_sA) {
int inc = GETARG_S(code[pc-1]);
fs->pc = pc-1;
code[pc-2] = CREATE_sAB(OP_INCLOCAL, inc, l);
luaK_deltastack(fs, -1);
}
else
luaK_U(fs, OP_SETLOCAL, l, -1);
}
static void luaK_eq (FuncState *fs) {
Instruction previous = prepare(fs, CREATE_S(OP_IFEQJMP, 0), -2);
/* PUSHNIL 1; JMPEQ -> NOT (a==nil) */
Instruction previous = prepare(fs, CREATE_S(OP_JMPEQ, 0), -2);
if (previous == CREATE_U(OP_PUSHNIL, 1)) {
setprevious(fs, CREATE_0(OP_NOT));
luaK_deltastack(fs, 1); /* undo delta from `prepare' */
@ -137,9 +163,10 @@ static void luaK_eq (FuncState *fs) {
static void luaK_neq (FuncState *fs) {
Instruction previous = prepare(fs, CREATE_S(OP_IFNEQJMP, 0), -2);
/* PUSHNIL 1; JMPNEQ -> JMPT (a~=nil) */
Instruction previous = prepare(fs, CREATE_S(OP_JMPNEQ, 0), -2);
if (previous == CREATE_U(OP_PUSHNIL, 1)) {
setprevious(fs, CREATE_S(OP_IFTJMP, 0));
setprevious(fs, CREATE_S(OP_JMPT, 0));
}
}
@ -171,7 +198,7 @@ void luaK_fixjump (FuncState *fs, int pc, int dest) {
SETARG_S(*jmp, 0); /* absolute value to represent end of list */
else { /* jump is relative to position following jump instruction */
int offset = dest-(pc+1);
if (offset < -MAXARG_S || offset > MAXARG_S)
if (abs(offset) > MAXARG_S)
luaK_error(fs->ls, "control structure too long");
SETARG_S(*jmp, offset);
}
@ -298,7 +325,7 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
FuncState *fs = ls->fs;
switch (var->k) {
case VLOCAL:
luaK_U(fs, OP_SETLOCAL, var->u.index, -1);
luaK_setlocal(fs, var->u.index);
break;
case VGLOBAL:
luaK_U(fs, OP_SETGLOBAL, var->u.index, -1);
@ -315,14 +342,14 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
static OpCode invertjump (OpCode op) {
switch (op) {
case OP_IFNEQJMP: return OP_IFEQJMP;
case OP_IFEQJMP: return OP_IFNEQJMP;
case OP_IFLTJMP: return OP_IFGEJMP;
case OP_IFLEJMP: return OP_IFGTJMP;
case OP_IFGTJMP: return OP_IFLEJMP;
case OP_IFGEJMP: return OP_IFLTJMP;
case OP_IFTJMP: case OP_ONTJMP: return OP_IFFJMP;
case OP_IFFJMP: case OP_ONFJMP: return OP_IFTJMP;
case OP_JMPNEQ: return OP_JMPEQ;
case OP_JMPEQ: return OP_JMPNEQ;
case OP_JMPLT: return OP_JMPGE;
case OP_JMPLE: return OP_JMPGT;
case OP_JMPGT: return OP_JMPLE;
case OP_JMPGE: return OP_JMPLT;
case OP_JMPT: case OP_JMPONT: return OP_JMPF;
case OP_JMPF: case OP_JMPONF: return OP_JMPT;
default:
LUA_INTERNALERROR(NULL, "invalid jump instruction");
return OP_END; /* to avoid warnings */
@ -334,8 +361,8 @@ static void luaK_jump (FuncState *fs, OpCode jump) {
Instruction previous = prepare(fs, CREATE_S(jump, 0), -1);
switch (GET_OPCODE(previous)) {
case OP_NOT: previous = CREATE_S(invertjump(jump), 0); break;
case OP_PUSHINT:
if (jump == OP_IFTJMP) {
case OP_PUSHNIL: /* optimize `repeat until nil' */
if (GETARG_U(previous) == 1 && jump == OP_JMPF) {
previous = CREATE_S(OP_JMP, 0);
break;
}
@ -364,10 +391,10 @@ static void luaK_patchlistaux (FuncState *fs, int list, int target,
luaK_fixjump(fs, list, special_target);
else {
luaK_fixjump(fs, list, target); /* do the patch */
if (op == OP_ONTJMP) /* remove eventual values */
SET_OPCODE(*i, OP_IFTJMP);
else if (op == OP_ONFJMP)
SET_OPCODE(*i, OP_IFFJMP);
if (op == OP_JMPONT) /* remove eventual values */
SET_OPCODE(*i, OP_JMPT);
else if (op == OP_JMPONF)
SET_OPCODE(*i, OP_JMPF);
}
list = next;
}
@ -427,12 +454,12 @@ static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) {
void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue) {
luaK_testgo(fs, v, 1, keepvalue ? OP_ONFJMP : OP_IFFJMP);
luaK_testgo(fs, v, 1, keepvalue ? OP_JMPONF : OP_JMPF);
}
void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue) {
luaK_testgo(fs, v, 0, keepvalue ? OP_ONTJMP : OP_IFTJMP);
luaK_testgo(fs, v, 0, keepvalue ? OP_JMPONT : OP_JMPT);
}
@ -456,8 +483,8 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
p_1 = luaK_S(fs, OP_PUSHINT, 1, 1);
}
else { /* still may need a PUSHNIL or a PUSHINT */
int need_nil = need_value(fs, v->u.l.f, OP_ONFJMP);
int need_1 = need_value(fs, v->u.l.t, OP_ONTJMP);
int need_nil = need_value(fs, v->u.l.f, OP_JMPONF);
int need_1 = need_value(fs, v->u.l.t, OP_JMPONT);
if (need_nil && need_1) {
luaK_S(fs, OP_JMP, 2, 0); /* skip both pushes */
p_nil = luaK_0(fs, OP_PUSHNILJMP, 0);
@ -472,8 +499,8 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
}
}
final = luaK_getlabel(fs);
luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_ONFJMP, final);
luaK_patchlistaux(fs, v->u.l.t, p_1, OP_ONTJMP, final);
luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_JMPONF, final);
luaK_patchlistaux(fs, v->u.l.t, p_1, OP_JMPONT, final);
v->u.l.f = v->u.l.t = NO_JUMP;
}
}
@ -536,10 +563,10 @@ void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
case TK_CONC: luaK_conc(fs); break;
case TK_EQ: luaK_eq(fs); break;
case TK_NE: luaK_neq(fs); break;
case '>': luaK_S(fs, OP_IFGTJMP, 0, -2); break;
case '<': luaK_S(fs, OP_IFLTJMP, 0, -2); break;
case TK_GE: luaK_S(fs, OP_IFGEJMP, 0, -2); break;
case TK_LE: luaK_S(fs, OP_IFLEJMP, 0, -2); break;
case '>': luaK_S(fs, OP_JMPGT, 0, -2); break;
case '<': luaK_S(fs, OP_JMPLT, 0, -2); break;
case TK_GE: luaK_S(fs, OP_JMPGE, 0, -2); break;
case TK_LE: luaK_S(fs, OP_JMPLE, 0, -2); break;
}
}
}

6
llimits.h
View File

@ -1,5 +1,5 @@
/*
** $Id: llimits.h,v 1.3 2000/03/27 20:08:33 roberto Exp roberto $
** $Id: llimits.h,v 1.4 2000/03/31 16:28:45 roberto Exp roberto $
** Limits, basic types, and some other "instalation-dependent" definitions
** See Copyright Notice in lua.h
*/
@ -69,14 +69,12 @@ typedef unsigned long Instruction;
#define SIZE_U (SIZE_INSTRUCTION-SIZE_OP)
#define POS_U SIZE_OP
#define SIZE_S (SIZE_INSTRUCTION-SIZE_OP)
#define POS_S SIZE_OP
#define POS_B SIZE_OP
#define SIZE_A (SIZE_INSTRUCTION-(SIZE_OP+SIZE_B))
#define POS_A (SIZE_OP+SIZE_B)
#define MAXARG_U ((1<<SIZE_U)-1)
#define MAXARG_S ((1<<(SIZE_S-1))-1) /* `S' is signed */
#define MAXARG_S (MAXARG_U>>1) /* `S' is signed */
#define MAXARG_A ((1<<SIZE_A)-1)
#define MAXARG_B ((1<<SIZE_B)-1)

77
lopcodes.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lopcodes.h,v 1.52 2000/03/24 19:49:23 roberto Exp roberto $
** $Id: lopcodes.h,v 1.53 2000/03/27 14:31:12 roberto Exp roberto $
** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -13,26 +13,30 @@
/*===========================================================================
We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits. Moreover,
an instruction can have 0, 1, or 2 arguments. There are 4 types of
Instructions:
an instruction can have 0, 1, or 2 arguments. Instructions can
have the following types:
type 0: no arguments
type 1: 1 unsigned argument in the higher bits (called `U')
type 2: 1 signed argument in the higher bits (`S')
type 3: 1st unsigned argument in the higher bits (`A')
2nd unsigned argument in the middle bits (`B')
The signed argument is represented in excess 2^K; that is, the number
value is the usigned value minus 2^K.
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.
The size of each argument is defined in `llimits.h'. The usual is an
instruction with 32 bits, U and S arguments with 26 bits (32-6), B
argument with 9 bits, and A argument with 17 bits (32-6-9). For small
instalations, the instruction size can be 16, so U and S have 10 bits,
instruction with 32 bits, U arguments with 26 bits (32-6), B arguments
with 9 bits, and A arguments with 17 bits (32-6-9). For small
instalations, the instruction size can be 16, so U has 10 bits,
and A and B have 5 bits each.
===========================================================================*/
#define EXCESS_S (1<<(SIZE_S-1)) /* == 2^K */
#define MAXARG_sA (MAXARG_A>>1) /* max value for a signed A */
/* creates a mask with `n' 1 bits at position `p' */
@ -45,27 +49,33 @@
** the following macros help to manipulate instructions
*/
#define CREATE_0(o) ((Instruction)(o))
#define GET_OPCODE(i) ((OpCode)((i)&MASK1(SIZE_OP,0)))
#define GETARG_U(i) ((int)((i)>>POS_U))
#define GETARG_S(i) ((int)((i)>>POS_S)-EXCESS_S)
#define GETARG_A(i) ((int)((i)>>POS_A))
#define GETARG_B(i) ((int)(((i)>>POS_B) & MASK1(SIZE_B,0)))
#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,0)) | (Instruction)(o)))
#define CREATE_U(o,u) ((Instruction)(o) | (Instruction)(u)<<POS_U)
#define GETARG_U(i) ((int)((i)>>POS_U))
#define SETARG_U(i,u) ((i) = (((i)&MASK0(SIZE_U,POS_U)) | \
((Instruction)(u)<<POS_U)))
#define SETARG_S(i,s) ((i) = (((i)&MASK0(SIZE_S,POS_S)) | \
((Instruction)((s)+EXCESS_S)<<POS_S)))
#define CREATE_S(o,s) CREATE_U((o),(s)+MAXARG_S)
#define GETARG_S(i) (GETARG_U(i)-MAXARG_S)
#define SETARG_S(i,s) SETARG_U((i),(s)+MAXARG_S)
#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \
| ((Instruction)(b)<<POS_B))
#define GETARG_A(i) ((int)((i)>>POS_A))
#define SETARG_A(i,a) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
((Instruction)(a)<<POS_A)))
#define GETARG_B(i) ((int)(((i)>>POS_B) & MASK1(SIZE_B,0)))
#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
((Instruction)(b)<<POS_B)))
#define CREATE_0(o) ((Instruction)(o))
#define CREATE_U(o,u) ((Instruction)(o) | (Instruction)(u)<<POS_U)
#define CREATE_S(o,s) ((Instruction)(o) | ((Instruction)(s)+EXCESS_S)<<POS_S)
#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \
| ((Instruction)(b)<<POS_B))
#define CREATE_sAB(o,a,b) (CREATE_AB((o),(a)+MAXARG_sA,(b)))
#define GETARG_sA(i) (GETARG_A(i)-MAXARG_sA)
/*
@ -112,6 +122,7 @@ OP_SETTABLE,/* U v a_u-a_1 i t a_u-a_1 i t t[i]=v */
OP_SETLIST,/* A B v_b-v_0 t t t[i+a*FPF]=v_i */
OP_SETMAP,/* U v_u k_u - v_0 k_0 t t t[k_i]=v_i */
OP_INCLOCAL,/* sA B - - LOC[B]+=sA */
OP_ADD,/* - y x x+y */
OP_ADDI,/* S x x+s */
OP_SUB,/* - y x x-y */
@ -122,17 +133,17 @@ OP_CONC,/* U v_u-v_1 v1..-..v_u */
OP_MINUS,/* - x -x */
OP_NOT,/* - x (x==nil)? 1 : nil */
OP_IFNEQJMP,/* J y x - (x~=y)? PC+=s */
OP_IFEQJMP,/* J y x - (x==y)? PC+=s */
OP_IFLTJMP,/* J y x - (x<y)? PC+=s */
OP_IFLEJMP,/* J y x - (x<y)? PC+=s */
OP_IFGTJMP,/* J y x - (x>y)? PC+=s */
OP_IFGEJMP,/* J y x - (x>=y)? PC+=s */
OP_IFTJMP,/* J x - (x!=nil)? PC+=s */
OP_IFFJMP,/* J x - (x==nil)? PC+=s */
OP_ONTJMP,/* J x (x!=nil)? x : - (x!=nil)? PC+=s */
OP_ONFJMP,/* J x (x==nil)? x : - (x==nil)? PC+=s */
OP_JMPNEQ,/* J y x - (x~=y)? PC+=s */
OP_JMPEQ,/* J y x - (x==y)? PC+=s */
OP_JMPLT,/* J y x - (x<y)? PC+=s */
OP_JMPLE,/* J y x - (x<y)? PC+=s */
OP_JMPGT,/* J y x - (x>y)? PC+=s */
OP_JMPGE,/* J y x - (x>=y)? PC+=s */
OP_JMPT,/* J x - (x!=nil)? PC+=s */
OP_JMPF,/* J x - (x==nil)? PC+=s */
OP_JMPONT,/* J x (x!=nil)? x : - (x!=nil)? PC+=s */
OP_JMPONF,/* J x (x==nil)? x : - (x==nil)? PC+=s */
OP_JMP,/* J - - PC+=s */
OP_PUSHNILJMP,/* - - nil PC++; */
@ -145,7 +156,7 @@ OP_SETLINE/* U - - LINE=u */
#define ISJUMP(o) (OP_IFNEQJMP <= (o) && (o) <= OP_JMP)
#define ISJUMP(o) (OP_JMPNEQ <= (o) && (o) <= OP_JMP)
#endif

41
lvm.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lvm.c,v 1.97 2000/03/27 20:10:21 roberto Exp roberto $
** $Id: lvm.c,v 1.98 2000/03/29 20:19:20 roberto Exp roberto $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -365,9 +365,9 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
case OP_PUSHNIL: {
int n = GETARG_U(i);
LUA_ASSERT(L, n>0, "invalid argument");
do {
do {
ttype(top++) = TAG_NIL;
} while (--n > 0);
} while (--n > 0);
break;
}
@ -491,6 +491,21 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
top--;
break;
case OP_INCLOCAL: {
TObject *var = base+GETARG_B(i);
int n = GETARG_sA(i);
if (tonumber(var)) {
*top = *var; /* PUSHLOCAL */
ttype(top+1) = TAG_NUMBER;
nvalue(top+1) = (Number)n; /* PUSHINT */
call_arith(L, top+2, IM_ADD);
*var = *top; /* SETLOCAL */
}
else
nvalue(var) += (Number)n;
break;
}
case OP_ADDI:
if (tonumber(top-1)) {
ttype(top) = TAG_NUMBER;
@ -554,50 +569,50 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
nvalue(top-1) = 1;
break;
case OP_IFNEQJMP:
case OP_JMPNEQ:
top -= 2;
if (!luaO_equalObj(top, top+1)) pc += GETARG_S(i);
break;
case OP_IFEQJMP:
case OP_JMPEQ:
top -= 2;
if (luaO_equalObj(top, top+1)) pc += GETARG_S(i);
break;
case OP_IFLTJMP:
case OP_JMPLT:
top -= 2;
if (luaV_lessthan(L, top, top+1, top+2)) pc += GETARG_S(i);
break;
case OP_IFLEJMP: /* a <= b === !(b<a) */
case OP_JMPLE: /* a <= b === !(b<a) */
top -= 2;
if (!luaV_lessthan(L, top+1, top, top+2)) pc += GETARG_S(i);
break;
case OP_IFGTJMP: /* a > b === (b<a) */
case OP_JMPGT: /* a > b === (b<a) */
top -= 2;
if (luaV_lessthan(L, top+1, top, top+2)) pc += GETARG_S(i);
break;
case OP_IFGEJMP: /* a >= b === !(a<b) */
case OP_JMPGE: /* a >= b === !(a<b) */
top -= 2;
if (!luaV_lessthan(L, top, top+1, top+2)) pc += GETARG_S(i);
break;
case OP_IFTJMP:
case OP_JMPT:
if (ttype(--top) != TAG_NIL) pc += GETARG_S(i);
break;
case OP_IFFJMP:
case OP_JMPF:
if (ttype(--top) == TAG_NIL) pc += GETARG_S(i);
break;
case OP_ONTJMP:
case OP_JMPONT:
if (ttype(top-1) != TAG_NIL) pc += GETARG_S(i);
else top--;
break;
case OP_ONFJMP:
case OP_JMPONF:
if (ttype(top-1) == TAG_NIL) pc += GETARG_S(i);
else top--;
break;

Write Preview
Loading…
Cancel
Save