2 ** Lua parser (source code -> bytecode).
3 ** Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
5 ** Major portions taken verbatim or adapted from the Lua interpreter.
6 ** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
27 #include "lj_vmevent.h"
29 /* -- Parser structures and definitions ----------------------------------- */
31 /* Expression kinds. */
33 /* Constant expressions must be first and in this order: */
37 VKSTR
, /* sval = string value */
38 VKNUM
, /* nval = number value */
40 VKCDATA
, /* nval = cdata value, not treated as a constant expression */
41 /* Non-constant expressions follow: */
42 VLOCAL
, /* info = local register, aux = vstack index */
43 VUPVAL
, /* info = upvalue index, aux = vstack index */
44 VGLOBAL
, /* sval = string value */
45 VINDEXED
, /* info = table register, aux = index reg/byte/string const */
46 VJMP
, /* info = instruction PC */
47 VRELOCABLE
, /* info = instruction PC */
48 VNONRELOC
, /* info = result register */
49 VCALL
, /* info = instruction PC, aux = base */
53 /* Expression descriptor. */
54 typedef struct ExpDesc
{
57 uint32_t info
; /* Primary info. */
58 uint32_t aux
; /* Secondary info. */
60 TValue nval
; /* Number value. */
61 GCstr
*sval
; /* String value. */
64 BCPos t
; /* True condition jump list. */
65 BCPos f
; /* False condition jump list. */
68 /* Macros for expressions. */
69 #define expr_hasjump(e) ((e)->t != (e)->f)
71 #define expr_isk(e) ((e)->k <= VKLAST)
72 #define expr_isk_nojump(e) (expr_isk(e) && !expr_hasjump(e))
73 #define expr_isnumk(e) ((e)->k == VKNUM)
74 #define expr_isnumk_nojump(e) (expr_isnumk(e) && !expr_hasjump(e))
75 #define expr_isstrk(e) ((e)->k == VKSTR)
77 #define expr_numtv(e) check_exp(expr_isnumk((e)), &(e)->u.nval)
78 #define expr_numberV(e) numberVnum(expr_numtv((e)))
80 /* Initialize expression. */
81 static LJ_AINLINE
void expr_init(ExpDesc
*e
, ExpKind k
, uint32_t info
)
88 /* Check number constant for +-0. */
89 static int expr_numiszero(ExpDesc
*e
)
91 TValue
*o
= expr_numtv(e
);
92 return tvisint(o
) ? (intV(o
) == 0) : tviszero(o
);
95 /* Per-function linked list of scope blocks. */
96 typedef struct FuncScope
{
97 struct FuncScope
*prev
; /* Link to outer scope. */
98 MSize vstart
; /* Start of block-local variables. */
99 uint8_t nactvar
; /* Number of active vars outside the scope. */
100 uint8_t flags
; /* Scope flags. */
103 #define FSCOPE_LOOP 0x01 /* Scope is a (breakable) loop. */
104 #define FSCOPE_BREAK 0x02 /* Break used in scope. */
105 #define FSCOPE_GOLA 0x04 /* Goto or label used in scope. */
106 #define FSCOPE_UPVAL 0x08 /* Upvalue in scope. */
107 #define FSCOPE_NOCLOSE 0x10 /* Do not close upvalues. */
109 #define NAME_BREAK ((GCstr *)(uintptr_t)1)
111 /* Index into variable stack. */
112 typedef uint16_t VarIndex
;
113 #define LJ_MAX_VSTACK (65536 - LJ_MAX_UPVAL)
115 /* Variable/goto/label info. */
116 #define VSTACK_VAR_RW 0x01 /* R/W variable. */
117 #define VSTACK_GOTO 0x02 /* Pending goto. */
118 #define VSTACK_LABEL 0x04 /* Label. */
120 /* Per-function state. */
121 typedef struct FuncState
{
122 GCtab
*kt
; /* Hash table for constants. */
123 LexState
*ls
; /* Lexer state. */
124 lua_State
*L
; /* Lua state. */
125 FuncScope
*bl
; /* Current scope. */
126 struct FuncState
*prev
; /* Enclosing function. */
127 BCPos pc
; /* Next bytecode position. */
128 BCPos lasttarget
; /* Bytecode position of last jump target. */
129 BCPos jpc
; /* Pending jump list to next bytecode. */
130 BCReg freereg
; /* First free register. */
131 BCReg nactvar
; /* Number of active local variables. */
132 BCReg nkn
, nkgc
; /* Number of lua_Number/GCobj constants */
133 BCLine linedefined
; /* First line of the function definition. */
134 BCInsLine
*bcbase
; /* Base of bytecode stack. */
135 BCPos bclim
; /* Limit of bytecode stack. */
136 MSize vbase
; /* Base of variable stack for this function. */
137 uint8_t flags
; /* Prototype flags. */
138 uint8_t numparams
; /* Number of parameters. */
139 uint8_t framesize
; /* Fixed frame size. */
140 uint8_t nuv
; /* Number of upvalues */
141 VarIndex varmap
[LJ_MAX_LOCVAR
]; /* Map from register to variable idx. */
142 VarIndex uvmap
[LJ_MAX_UPVAL
]; /* Map from upvalue to variable idx. */
143 VarIndex uvtmp
[LJ_MAX_UPVAL
]; /* Temporary upvalue map. */
146 /* Binary and unary operators. ORDER OPR */
147 typedef enum BinOpr
{
148 OPR_ADD
, OPR_SUB
, OPR_MUL
, OPR_DIV
, OPR_MOD
, OPR_POW
, /* ORDER ARITH */
151 OPR_LT
, OPR_GE
, OPR_LE
, OPR_GT
,
156 LJ_STATIC_ASSERT((int)BC_ISGE
-(int)BC_ISLT
== (int)OPR_GE
-(int)OPR_LT
);
157 LJ_STATIC_ASSERT((int)BC_ISLE
-(int)BC_ISLT
== (int)OPR_LE
-(int)OPR_LT
);
158 LJ_STATIC_ASSERT((int)BC_ISGT
-(int)BC_ISLT
== (int)OPR_GT
-(int)OPR_LT
);
159 LJ_STATIC_ASSERT((int)BC_SUBVV
-(int)BC_ADDVV
== (int)OPR_SUB
-(int)OPR_ADD
);
160 LJ_STATIC_ASSERT((int)BC_MULVV
-(int)BC_ADDVV
== (int)OPR_MUL
-(int)OPR_ADD
);
161 LJ_STATIC_ASSERT((int)BC_DIVVV
-(int)BC_ADDVV
== (int)OPR_DIV
-(int)OPR_ADD
);
162 LJ_STATIC_ASSERT((int)BC_MODVV
-(int)BC_ADDVV
== (int)OPR_MOD
-(int)OPR_ADD
);
164 /* -- Error handling ------------------------------------------------------ */
166 LJ_NORET LJ_NOINLINE
static void err_syntax(LexState
*ls
, ErrMsg em
)
168 lj_lex_error(ls
, ls
->token
, em
);
171 LJ_NORET LJ_NOINLINE
static void err_token(LexState
*ls
, LexToken token
)
173 lj_lex_error(ls
, ls
->token
, LJ_ERR_XTOKEN
, lj_lex_token2str(ls
, token
));
176 LJ_NORET
static void err_limit(FuncState
*fs
, uint32_t limit
, const char *what
)
178 if (fs
->linedefined
== 0)
179 lj_lex_error(fs
->ls
, 0, LJ_ERR_XLIMM
, limit
, what
);
181 lj_lex_error(fs
->ls
, 0, LJ_ERR_XLIMF
, fs
->linedefined
, limit
, what
);
184 #define checklimit(fs, v, l, m) if ((v) >= (l)) err_limit(fs, l, m)
185 #define checklimitgt(fs, v, l, m) if ((v) > (l)) err_limit(fs, l, m)
186 #define checkcond(ls, c, em) { if (!(c)) err_syntax(ls, em); }
188 /* -- Management of constants --------------------------------------------- */
190 /* Return bytecode encoding for primitive constant. */
191 #define const_pri(e) check_exp((e)->k <= VKTRUE, (e)->k)
193 #define tvhaskslot(o) ((o)->u32.hi == 0)
194 #define tvkslot(o) ((o)->u32.lo)
196 /* Add a number constant. */
197 static BCReg
const_num(FuncState
*fs
, ExpDesc
*e
)
199 lua_State
*L
= fs
->L
;
201 lua_assert(expr_isnumk(e
));
202 o
= lj_tab_set(L
, fs
->kt
, &e
->u
.nval
);
209 /* Add a GC object constant. */
210 static BCReg
const_gc(FuncState
*fs
, GCobj
*gc
, uint32_t itype
)
212 lua_State
*L
= fs
->L
;
214 setgcV(L
, &key
, gc
, itype
);
215 /* NOBARRIER: the key is new or kept alive. */
216 o
= lj_tab_set(L
, fs
->kt
, &key
);
223 /* Add a string constant. */
224 static BCReg
const_str(FuncState
*fs
, ExpDesc
*e
)
226 lua_assert(expr_isstrk(e
) || e
->k
== VGLOBAL
);
227 return const_gc(fs
, obj2gco(e
->u
.sval
), LJ_TSTR
);
230 /* Anchor string constant to avoid GC. */
231 GCstr
*lj_parse_keepstr(LexState
*ls
, const char *str
, size_t len
)
233 /* NOBARRIER: the key is new or kept alive. */
234 lua_State
*L
= ls
->L
;
235 GCstr
*s
= lj_str_new(L
, str
, len
);
236 TValue
*tv
= lj_tab_setstr(L
, ls
->fs
->kt
, s
);
237 if (tvisnil(tv
)) setboolV(tv
, 1);
243 /* Anchor cdata to avoid GC. */
244 void lj_parse_keepcdata(LexState
*ls
, TValue
*tv
, GCcdata
*cd
)
246 /* NOBARRIER: the key is new or kept alive. */
247 lua_State
*L
= ls
->L
;
248 setcdataV(L
, tv
, cd
);
249 setboolV(lj_tab_set(L
, ls
->fs
->kt
, tv
), 1);
253 /* -- Jump list handling -------------------------------------------------- */
255 /* Get next element in jump list. */
256 static BCPos
jmp_next(FuncState
*fs
, BCPos pc
)
258 ptrdiff_t delta
= bc_j(fs
->bcbase
[pc
].ins
);
259 if ((BCPos
)delta
== NO_JMP
)
262 return (BCPos
)(((ptrdiff_t)pc
+1)+delta
);
265 /* Check if any of the instructions on the jump list produce no value. */
266 static int jmp_novalue(FuncState
*fs
, BCPos list
)
268 for (; list
!= NO_JMP
; list
= jmp_next(fs
, list
)) {
269 BCIns p
= fs
->bcbase
[list
>= 1 ? list
-1 : list
].ins
;
270 if (!(bc_op(p
) == BC_ISTC
|| bc_op(p
) == BC_ISFC
|| bc_a(p
) == NO_REG
))
276 /* Patch register of test instructions. */
277 static int jmp_patchtestreg(FuncState
*fs
, BCPos pc
, BCReg reg
)
279 BCInsLine
*ilp
= &fs
->bcbase
[pc
>= 1 ? pc
-1 : pc
];
280 BCOp op
= bc_op(ilp
->ins
);
281 if (op
== BC_ISTC
|| op
== BC_ISFC
) {
282 if (reg
!= NO_REG
&& reg
!= bc_d(ilp
->ins
)) {
283 setbc_a(&ilp
->ins
, reg
);
284 } else { /* Nothing to store or already in the right register. */
285 setbc_op(&ilp
->ins
, op
+(BC_IST
-BC_ISTC
));
286 setbc_a(&ilp
->ins
, 0);
288 } else if (bc_a(ilp
->ins
) == NO_REG
) {
290 ilp
->ins
= BCINS_AJ(BC_JMP
, bc_a(fs
->bcbase
[pc
].ins
), 0);
292 setbc_a(&ilp
->ins
, reg
);
293 if (reg
>= bc_a(ilp
[1].ins
))
294 setbc_a(&ilp
[1].ins
, reg
+1);
297 return 0; /* Cannot patch other instructions. */
302 /* Drop values for all instructions on jump list. */
303 static void jmp_dropval(FuncState
*fs
, BCPos list
)
305 for (; list
!= NO_JMP
; list
= jmp_next(fs
, list
))
306 jmp_patchtestreg(fs
, list
, NO_REG
);
309 /* Patch jump instruction to target. */
310 static void jmp_patchins(FuncState
*fs
, BCPos pc
, BCPos dest
)
312 BCIns
*jmp
= &fs
->bcbase
[pc
].ins
;
313 BCPos offset
= dest
-(pc
+1)+BCBIAS_J
;
314 lua_assert(dest
!= NO_JMP
);
315 if (offset
> BCMAX_D
)
316 err_syntax(fs
->ls
, LJ_ERR_XJUMP
);
317 setbc_d(jmp
, offset
);
320 /* Append to jump list. */
321 static void jmp_append(FuncState
*fs
, BCPos
*l1
, BCPos l2
)
325 } else if (*l1
== NO_JMP
) {
330 while ((next
= jmp_next(fs
, list
)) != NO_JMP
) /* Find last element. */
332 jmp_patchins(fs
, list
, l2
);
336 /* Patch jump list and preserve produced values. */
337 static void jmp_patchval(FuncState
*fs
, BCPos list
, BCPos vtarget
,
338 BCReg reg
, BCPos dtarget
)
340 while (list
!= NO_JMP
) {
341 BCPos next
= jmp_next(fs
, list
);
342 if (jmp_patchtestreg(fs
, list
, reg
))
343 jmp_patchins(fs
, list
, vtarget
); /* Jump to target with value. */
345 jmp_patchins(fs
, list
, dtarget
); /* Jump to default target. */
350 /* Jump to following instruction. Append to list of pending jumps. */
351 static void jmp_tohere(FuncState
*fs
, BCPos list
)
353 fs
->lasttarget
= fs
->pc
;
354 jmp_append(fs
, &fs
->jpc
, list
);
357 /* Patch jump list to target. */
358 static void jmp_patch(FuncState
*fs
, BCPos list
, BCPos target
)
360 if (target
== fs
->pc
) {
361 jmp_tohere(fs
, list
);
363 lua_assert(target
< fs
->pc
);
364 jmp_patchval(fs
, list
, target
, NO_REG
, target
);
368 /* -- Bytecode register allocator ----------------------------------------- */
370 /* Bump frame size. */
371 static void bcreg_bump(FuncState
*fs
, BCReg n
)
373 BCReg sz
= fs
->freereg
+ n
;
374 if (sz
> fs
->framesize
) {
375 if (sz
>= LJ_MAX_SLOTS
)
376 err_syntax(fs
->ls
, LJ_ERR_XSLOTS
);
377 fs
->framesize
= (uint8_t)sz
;
381 /* Reserve registers. */
382 static void bcreg_reserve(FuncState
*fs
, BCReg n
)
389 static void bcreg_free(FuncState
*fs
, BCReg reg
)
391 if (reg
>= fs
->nactvar
) {
393 lua_assert(reg
== fs
->freereg
);
397 /* Free register for expression. */
398 static void expr_free(FuncState
*fs
, ExpDesc
*e
)
400 if (e
->k
== VNONRELOC
)
401 bcreg_free(fs
, e
->u
.s
.info
);
404 /* -- Bytecode emitter ---------------------------------------------------- */
406 /* Emit bytecode instruction. */
407 static BCPos
bcemit_INS(FuncState
*fs
, BCIns ins
)
410 LexState
*ls
= fs
->ls
;
411 jmp_patchval(fs
, fs
->jpc
, pc
, NO_REG
, pc
);
413 if (LJ_UNLIKELY(pc
>= fs
->bclim
)) {
414 ptrdiff_t base
= fs
->bcbase
- ls
->bcstack
;
415 checklimit(fs
, ls
->sizebcstack
, LJ_MAX_BCINS
, "bytecode instructions");
416 lj_mem_growvec(fs
->L
, ls
->bcstack
, ls
->sizebcstack
, LJ_MAX_BCINS
,BCInsLine
);
417 fs
->bclim
= (BCPos
)(ls
->sizebcstack
- base
);
418 fs
->bcbase
= ls
->bcstack
+ base
;
420 fs
->bcbase
[pc
].ins
= ins
;
421 fs
->bcbase
[pc
].line
= ls
->lastline
;
426 #define bcemit_ABC(fs, o, a, b, c) bcemit_INS(fs, BCINS_ABC(o, a, b, c))
427 #define bcemit_AD(fs, o, a, d) bcemit_INS(fs, BCINS_AD(o, a, d))
428 #define bcemit_AJ(fs, o, a, j) bcemit_INS(fs, BCINS_AJ(o, a, j))
430 #define bcptr(fs, e) (&(fs)->bcbase[(e)->u.s.info].ins)
432 /* -- Bytecode emitter for expressions ------------------------------------ */
434 /* Discharge non-constant expression to any register. */
435 static void expr_discharge(FuncState
*fs
, ExpDesc
*e
)
438 if (e
->k
== VUPVAL
) {
439 ins
= BCINS_AD(BC_UGET
, 0, e
->u
.s
.info
);
440 } else if (e
->k
== VGLOBAL
) {
441 ins
= BCINS_AD(BC_GGET
, 0, const_str(fs
, e
));
442 } else if (e
->k
== VINDEXED
) {
443 BCReg rc
= e
->u
.s
.aux
;
444 if ((int32_t)rc
< 0) {
445 ins
= BCINS_ABC(BC_TGETS
, 0, e
->u
.s
.info
, ~rc
);
446 } else if (rc
> BCMAX_C
) {
447 ins
= BCINS_ABC(BC_TGETB
, 0, e
->u
.s
.info
, rc
-(BCMAX_C
+1));
450 ins
= BCINS_ABC(BC_TGETV
, 0, e
->u
.s
.info
, rc
);
452 bcreg_free(fs
, e
->u
.s
.info
);
453 } else if (e
->k
== VCALL
) {
454 e
->u
.s
.info
= e
->u
.s
.aux
;
457 } else if (e
->k
== VLOCAL
) {
463 e
->u
.s
.info
= bcemit_INS(fs
, ins
);
467 /* Emit bytecode to set a range of registers to nil. */
468 static void bcemit_nil(FuncState
*fs
, BCReg from
, BCReg n
)
470 if (fs
->pc
> fs
->lasttarget
) { /* No jumps to current position? */
471 BCIns
*ip
= &fs
->bcbase
[fs
->pc
-1].ins
;
472 BCReg pto
, pfrom
= bc_a(*ip
);
473 switch (bc_op(*ip
)) { /* Try to merge with the previous instruction. */
475 if (bc_d(*ip
) != ~LJ_TNIL
) break;
478 } else if (from
== pfrom
+1) {
484 *ip
= BCINS_AD(BC_KNIL
, from
, from
+n
-1); /* Replace KPRI. */
488 if (pfrom
<= from
&& from
<= pto
+1) { /* Can we connect both ranges? */
490 setbc_d(ip
, from
+n
-1); /* Patch previous instruction range. */
498 /* Emit new instruction or replace old instruction. */
499 bcemit_INS(fs
, n
== 1 ? BCINS_AD(BC_KPRI
, from
, VKNIL
) :
500 BCINS_AD(BC_KNIL
, from
, from
+n
-1));
503 /* Discharge an expression to a specific register. Ignore branches. */
504 static void expr_toreg_nobranch(FuncState
*fs
, ExpDesc
*e
, BCReg reg
)
507 expr_discharge(fs
, e
);
509 ins
= BCINS_AD(BC_KSTR
, reg
, const_str(fs
, e
));
510 } else if (e
->k
== VKNUM
) {
512 cTValue
*tv
= expr_numtv(e
);
513 if (tvisint(tv
) && checki16(intV(tv
)))
514 ins
= BCINS_AD(BC_KSHORT
, reg
, (BCReg
)(uint16_t)intV(tv
));
517 lua_Number n
= expr_numberV(e
);
518 int32_t k
= lj_num2int(n
);
519 if (checki16(k
) && n
== (lua_Number
)k
)
520 ins
= BCINS_AD(BC_KSHORT
, reg
, (BCReg
)(uint16_t)k
);
523 ins
= BCINS_AD(BC_KNUM
, reg
, const_num(fs
, e
));
525 } else if (e
->k
== VKCDATA
) {
526 fs
->flags
|= PROTO_FFI
;
527 ins
= BCINS_AD(BC_KCDATA
, reg
,
528 const_gc(fs
, obj2gco(cdataV(&e
->u
.nval
)), LJ_TCDATA
));
530 } else if (e
->k
== VRELOCABLE
) {
531 setbc_a(bcptr(fs
, e
), reg
);
533 } else if (e
->k
== VNONRELOC
) {
534 if (reg
== e
->u
.s
.info
)
536 ins
= BCINS_AD(BC_MOV
, reg
, e
->u
.s
.info
);
537 } else if (e
->k
== VKNIL
) {
538 bcemit_nil(fs
, reg
, 1);
540 } else if (e
->k
<= VKTRUE
) {
541 ins
= BCINS_AD(BC_KPRI
, reg
, const_pri(e
));
543 lua_assert(e
->k
== VVOID
|| e
->k
== VJMP
);
552 /* Forward declaration. */
553 static BCPos
bcemit_jmp(FuncState
*fs
);
555 /* Discharge an expression to a specific register. */
556 static void expr_toreg(FuncState
*fs
, ExpDesc
*e
, BCReg reg
)
558 expr_toreg_nobranch(fs
, e
, reg
);
560 jmp_append(fs
, &e
->t
, e
->u
.s
.info
); /* Add it to the true jump list. */
561 if (expr_hasjump(e
)) { /* Discharge expression with branches. */
562 BCPos jend
, jfalse
= NO_JMP
, jtrue
= NO_JMP
;
563 if (jmp_novalue(fs
, e
->t
) || jmp_novalue(fs
, e
->f
)) {
564 BCPos jval
= (e
->k
== VJMP
) ? NO_JMP
: bcemit_jmp(fs
);
565 jfalse
= bcemit_AD(fs
, BC_KPRI
, reg
, VKFALSE
);
566 bcemit_AJ(fs
, BC_JMP
, fs
->freereg
, 1);
567 jtrue
= bcemit_AD(fs
, BC_KPRI
, reg
, VKTRUE
);
568 jmp_tohere(fs
, jval
);
571 fs
->lasttarget
= jend
;
572 jmp_patchval(fs
, e
->f
, jend
, reg
, jfalse
);
573 jmp_patchval(fs
, e
->t
, jend
, reg
, jtrue
);
575 e
->f
= e
->t
= NO_JMP
;
580 /* Discharge an expression to the next free register. */
581 static void expr_tonextreg(FuncState
*fs
, ExpDesc
*e
)
583 expr_discharge(fs
, e
);
585 bcreg_reserve(fs
, 1);
586 expr_toreg(fs
, e
, fs
->freereg
- 1);
589 /* Discharge an expression to any register. */
590 static BCReg
expr_toanyreg(FuncState
*fs
, ExpDesc
*e
)
592 expr_discharge(fs
, e
);
593 if (e
->k
== VNONRELOC
) {
594 if (!expr_hasjump(e
)) return e
->u
.s
.info
; /* Already in a register. */
595 if (e
->u
.s
.info
>= fs
->nactvar
) {
596 expr_toreg(fs
, e
, e
->u
.s
.info
); /* Discharge to temp. register. */
600 expr_tonextreg(fs
, e
); /* Discharge to next register. */
604 /* Partially discharge expression to a value. */
605 static void expr_toval(FuncState
*fs
, ExpDesc
*e
)
608 expr_toanyreg(fs
, e
);
610 expr_discharge(fs
, e
);
613 /* Emit store for LHS expression. */
614 static void bcemit_store(FuncState
*fs
, ExpDesc
*var
, ExpDesc
*e
)
617 if (var
->k
== VLOCAL
) {
618 fs
->ls
->vstack
[var
->u
.s
.aux
].info
|= VSTACK_VAR_RW
;
620 expr_toreg(fs
, e
, var
->u
.s
.info
);
622 } else if (var
->k
== VUPVAL
) {
623 fs
->ls
->vstack
[var
->u
.s
.aux
].info
|= VSTACK_VAR_RW
;
626 ins
= BCINS_AD(BC_USETP
, var
->u
.s
.info
, const_pri(e
));
627 else if (e
->k
== VKSTR
)
628 ins
= BCINS_AD(BC_USETS
, var
->u
.s
.info
, const_str(fs
, e
));
629 else if (e
->k
== VKNUM
)
630 ins
= BCINS_AD(BC_USETN
, var
->u
.s
.info
, const_num(fs
, e
));
632 ins
= BCINS_AD(BC_USETV
, var
->u
.s
.info
, expr_toanyreg(fs
, e
));
633 } else if (var
->k
== VGLOBAL
) {
634 BCReg ra
= expr_toanyreg(fs
, e
);
635 ins
= BCINS_AD(BC_GSET
, ra
, const_str(fs
, var
));
638 lua_assert(var
->k
== VINDEXED
);
639 ra
= expr_toanyreg(fs
, e
);
641 if ((int32_t)rc
< 0) {
642 ins
= BCINS_ABC(BC_TSETS
, ra
, var
->u
.s
.info
, ~rc
);
643 } else if (rc
> BCMAX_C
) {
644 ins
= BCINS_ABC(BC_TSETB
, ra
, var
->u
.s
.info
, rc
-(BCMAX_C
+1));
646 /* Free late alloced key reg to avoid assert on free of value reg. */
647 /* This can only happen when called from expr_table(). */
648 lua_assert(e
->k
!= VNONRELOC
|| ra
< fs
->nactvar
||
649 rc
< ra
|| (bcreg_free(fs
, rc
),1));
650 ins
= BCINS_ABC(BC_TSETV
, ra
, var
->u
.s
.info
, rc
);
657 /* Emit method lookup expression. */
658 static void bcemit_method(FuncState
*fs
, ExpDesc
*e
, ExpDesc
*key
)
660 BCReg idx
, func
, obj
= expr_toanyreg(fs
, e
);
663 bcemit_AD(fs
, BC_MOV
, func
+1, obj
); /* Copy object to first argument. */
664 lua_assert(expr_isstrk(key
));
665 idx
= const_str(fs
, key
);
666 if (idx
<= BCMAX_C
) {
667 bcreg_reserve(fs
, 2);
668 bcemit_ABC(fs
, BC_TGETS
, func
, obj
, idx
);
670 bcreg_reserve(fs
, 3);
671 bcemit_AD(fs
, BC_KSTR
, func
+2, idx
);
672 bcemit_ABC(fs
, BC_TGETV
, func
, obj
, func
+2);
679 /* -- Bytecode emitter for branches --------------------------------------- */
681 /* Emit unconditional branch. */
682 static BCPos
bcemit_jmp(FuncState
*fs
)
685 BCPos j
= fs
->pc
- 1;
686 BCIns
*ip
= &fs
->bcbase
[j
].ins
;
688 if ((int32_t)j
>= (int32_t)fs
->lasttarget
&& bc_op(*ip
) == BC_UCLO
) {
690 fs
->lasttarget
= j
+1;
692 j
= bcemit_AJ(fs
, BC_JMP
, fs
->freereg
, NO_JMP
);
694 jmp_append(fs
, &j
, jpc
);
698 /* Invert branch condition of bytecode instruction. */
699 static void invertcond(FuncState
*fs
, ExpDesc
*e
)
701 BCIns
*ip
= &fs
->bcbase
[e
->u
.s
.info
- 1].ins
;
702 setbc_op(ip
, bc_op(*ip
)^1);
705 /* Emit conditional branch. */
706 static BCPos
bcemit_branch(FuncState
*fs
, ExpDesc
*e
, int cond
)
709 if (e
->k
== VRELOCABLE
) {
710 BCIns
*ip
= bcptr(fs
, e
);
711 if (bc_op(*ip
) == BC_NOT
) {
712 *ip
= BCINS_AD(cond
? BC_ISF
: BC_IST
, 0, bc_d(*ip
));
713 return bcemit_jmp(fs
);
716 if (e
->k
!= VNONRELOC
) {
717 bcreg_reserve(fs
, 1);
718 expr_toreg_nobranch(fs
, e
, fs
->freereg
-1);
720 bcemit_AD(fs
, cond
? BC_ISTC
: BC_ISFC
, NO_REG
, e
->u
.s
.info
);
726 /* Emit branch on true condition. */
727 static void bcemit_branch_t(FuncState
*fs
, ExpDesc
*e
)
730 expr_discharge(fs
, e
);
731 if (e
->k
== VKSTR
|| e
->k
== VKNUM
|| e
->k
== VKTRUE
)
732 pc
= NO_JMP
; /* Never jump. */
733 else if (e
->k
== VJMP
)
734 invertcond(fs
, e
), pc
= e
->u
.s
.info
;
735 else if (e
->k
== VKFALSE
|| e
->k
== VKNIL
)
736 expr_toreg_nobranch(fs
, e
, NO_REG
), pc
= bcemit_jmp(fs
);
738 pc
= bcemit_branch(fs
, e
, 0);
739 jmp_append(fs
, &e
->f
, pc
);
740 jmp_tohere(fs
, e
->t
);
744 /* Emit branch on false condition. */
745 static void bcemit_branch_f(FuncState
*fs
, ExpDesc
*e
)
748 expr_discharge(fs
, e
);
749 if (e
->k
== VKNIL
|| e
->k
== VKFALSE
)
750 pc
= NO_JMP
; /* Never jump. */
751 else if (e
->k
== VJMP
)
753 else if (e
->k
== VKSTR
|| e
->k
== VKNUM
|| e
->k
== VKTRUE
)
754 expr_toreg_nobranch(fs
, e
, NO_REG
), pc
= bcemit_jmp(fs
);
756 pc
= bcemit_branch(fs
, e
, 1);
757 jmp_append(fs
, &e
->t
, pc
);
758 jmp_tohere(fs
, e
->f
);
762 /* -- Bytecode emitter for operators -------------------------------------- */
764 /* Try constant-folding of arithmetic operators. */
765 static int foldarith(BinOpr opr
, ExpDesc
*e1
, ExpDesc
*e2
)
769 if (!expr_isnumk_nojump(e1
) || !expr_isnumk_nojump(e2
)) return 0;
770 n
= lj_vm_foldarith(expr_numberV(e1
), expr_numberV(e2
), (int)opr
-OPR_ADD
);
772 if (tvisnan(&o
) || tvismzero(&o
)) return 0; /* Avoid NaN and -0 as consts. */
774 int32_t k
= lj_num2int(n
);
775 if ((lua_Number
)k
== n
) {
776 setintV(&e1
->u
.nval
, k
);
780 setnumV(&e1
->u
.nval
, n
);
784 /* Emit arithmetic operator. */
785 static void bcemit_arith(FuncState
*fs
, BinOpr opr
, ExpDesc
*e1
, ExpDesc
*e2
)
789 if (foldarith(opr
, e1
, e2
))
791 if (opr
== OPR_POW
) {
793 rc
= expr_toanyreg(fs
, e2
);
794 rb
= expr_toanyreg(fs
, e1
);
796 op
= opr
-OPR_ADD
+BC_ADDVV
;
797 /* Must discharge 2nd operand first since VINDEXED might free regs. */
799 if (expr_isnumk(e2
) && (rc
= const_num(fs
, e2
)) <= BCMAX_C
)
800 op
-= BC_ADDVV
-BC_ADDVN
;
802 rc
= expr_toanyreg(fs
, e2
);
803 /* 1st operand discharged by bcemit_binop_left, but need KNUM/KSHORT. */
804 lua_assert(expr_isnumk(e1
) || e1
->k
== VNONRELOC
);
806 /* Avoid two consts to satisfy bytecode constraints. */
807 if (expr_isnumk(e1
) && !expr_isnumk(e2
) &&
808 (t
= const_num(fs
, e1
)) <= BCMAX_B
) {
809 rb
= rc
; rc
= t
; op
-= BC_ADDVV
-BC_ADDNV
;
811 rb
= expr_toanyreg(fs
, e1
);
814 /* Using expr_free might cause asserts if the order is wrong. */
815 if (e1
->k
== VNONRELOC
&& e1
->u
.s
.info
>= fs
->nactvar
) fs
->freereg
--;
816 if (e2
->k
== VNONRELOC
&& e2
->u
.s
.info
>= fs
->nactvar
) fs
->freereg
--;
817 e1
->u
.s
.info
= bcemit_ABC(fs
, op
, 0, rb
, rc
);
821 /* Emit comparison operator. */
822 static void bcemit_comp(FuncState
*fs
, BinOpr opr
, ExpDesc
*e1
, ExpDesc
*e2
)
827 if (opr
== OPR_EQ
|| opr
== OPR_NE
) {
828 BCOp op
= opr
== OPR_EQ
? BC_ISEQV
: BC_ISNEV
;
830 if (expr_isk(e1
)) { e1
= e2
; e2
= eret
; } /* Need constant in 2nd arg. */
831 ra
= expr_toanyreg(fs
, e1
); /* First arg must be in a reg. */
834 case VKNIL
: case VKFALSE
: case VKTRUE
:
835 ins
= BCINS_AD(op
+(BC_ISEQP
-BC_ISEQV
), ra
, const_pri(e2
));
838 ins
= BCINS_AD(op
+(BC_ISEQS
-BC_ISEQV
), ra
, const_str(fs
, e2
));
841 ins
= BCINS_AD(op
+(BC_ISEQN
-BC_ISEQV
), ra
, const_num(fs
, e2
));
844 ins
= BCINS_AD(op
, ra
, expr_toanyreg(fs
, e2
));
848 uint32_t op
= opr
-OPR_LT
+BC_ISLT
;
850 if ((op
-BC_ISLT
) & 1) { /* GT -> LT, GE -> LE */
851 e1
= e2
; e2
= eret
; /* Swap operands. */
852 op
= ((op
-BC_ISLT
)^3)+BC_ISLT
;
854 ra
= expr_toanyreg(fs
, e1
);
855 rd
= expr_toanyreg(fs
, e2
);
857 rd
= expr_toanyreg(fs
, e2
);
858 ra
= expr_toanyreg(fs
, e1
);
860 ins
= BCINS_AD(op
, ra
, rd
);
862 /* Using expr_free might cause asserts if the order is wrong. */
863 if (e1
->k
== VNONRELOC
&& e1
->u
.s
.info
>= fs
->nactvar
) fs
->freereg
--;
864 if (e2
->k
== VNONRELOC
&& e2
->u
.s
.info
>= fs
->nactvar
) fs
->freereg
--;
866 eret
->u
.s
.info
= bcemit_jmp(fs
);
870 /* Fixup left side of binary operator. */
871 static void bcemit_binop_left(FuncState
*fs
, BinOpr op
, ExpDesc
*e
)
874 bcemit_branch_t(fs
, e
);
875 } else if (op
== OPR_OR
) {
876 bcemit_branch_f(fs
, e
);
877 } else if (op
== OPR_CONCAT
) {
878 expr_tonextreg(fs
, e
);
879 } else if (op
== OPR_EQ
|| op
== OPR_NE
) {
880 if (!expr_isk_nojump(e
)) expr_toanyreg(fs
, e
);
882 if (!expr_isnumk_nojump(e
)) expr_toanyreg(fs
, e
);
886 /* Emit binary operator. */
887 static void bcemit_binop(FuncState
*fs
, BinOpr op
, ExpDesc
*e1
, ExpDesc
*e2
)
890 bcemit_arith(fs
, op
, e1
, e2
);
891 } else if (op
== OPR_AND
) {
892 lua_assert(e1
->t
== NO_JMP
); /* List must be closed. */
893 expr_discharge(fs
, e2
);
894 jmp_append(fs
, &e2
->f
, e1
->f
);
896 } else if (op
== OPR_OR
) {
897 lua_assert(e1
->f
== NO_JMP
); /* List must be closed. */
898 expr_discharge(fs
, e2
);
899 jmp_append(fs
, &e2
->t
, e1
->t
);
901 } else if (op
== OPR_CONCAT
) {
903 if (e2
->k
== VRELOCABLE
&& bc_op(*bcptr(fs
, e2
)) == BC_CAT
) {
904 lua_assert(e1
->u
.s
.info
== bc_b(*bcptr(fs
, e2
))-1);
906 setbc_b(bcptr(fs
, e2
), e1
->u
.s
.info
);
907 e1
->u
.s
.info
= e2
->u
.s
.info
;
909 expr_tonextreg(fs
, e2
);
912 e1
->u
.s
.info
= bcemit_ABC(fs
, BC_CAT
, 0, e1
->u
.s
.info
, e2
->u
.s
.info
);
916 lua_assert(op
== OPR_NE
|| op
== OPR_EQ
||
917 op
== OPR_LT
|| op
== OPR_GE
|| op
== OPR_LE
|| op
== OPR_GT
);
918 bcemit_comp(fs
, op
, e1
, e2
);
922 /* Emit unary operator. */
923 static void bcemit_unop(FuncState
*fs
, BCOp op
, ExpDesc
*e
)
926 /* Swap true and false lists. */
927 { BCPos temp
= e
->f
; e
->f
= e
->t
; e
->t
= temp
; }
928 jmp_dropval(fs
, e
->f
);
929 jmp_dropval(fs
, e
->t
);
930 expr_discharge(fs
, e
);
931 if (e
->k
== VKNIL
|| e
->k
== VKFALSE
) {
934 } else if (expr_isk(e
) || (LJ_HASFFI
&& e
->k
== VKCDATA
)) {
937 } else if (e
->k
== VJMP
) {
940 } else if (e
->k
== VRELOCABLE
) {
941 bcreg_reserve(fs
, 1);
942 setbc_a(bcptr(fs
, e
), fs
->freereg
-1);
943 e
->u
.s
.info
= fs
->freereg
-1;
946 lua_assert(e
->k
== VNONRELOC
);
949 lua_assert(op
== BC_UNM
|| op
== BC_LEN
);
950 if (op
== BC_UNM
&& !expr_hasjump(e
)) { /* Constant-fold negations. */
952 if (e
->k
== VKCDATA
) { /* Fold in-place since cdata is not interned. */
953 GCcdata
*cd
= cdataV(&e
->u
.nval
);
954 uint64_t *p
= (uint64_t *)cdataptr(cd
);
955 if (cd
->ctypeid
== CTID_COMPLEX_DOUBLE
)
956 p
[1] ^= U64x(80000000,00000000);
962 if (expr_isnumk(e
) && !expr_numiszero(e
)) { /* Avoid folding to -0. */
963 TValue
*o
= expr_numtv(e
);
965 int32_t k
= intV(o
), negk
= (int32_t)(~(uint32_t)k
+1u);
967 setnumV(o
, -(lua_Number
)k
);
972 o
->u64
^= U64x(80000000,00000000);
977 expr_toanyreg(fs
, e
);
980 e
->u
.s
.info
= bcemit_AD(fs
, op
, 0, e
->u
.s
.info
);
984 /* -- Lexer support ------------------------------------------------------- */
986 /* Check and consume optional token. */
987 static int lex_opt(LexState
*ls
, LexToken tok
)
989 if (ls
->token
== tok
) {
996 /* Check and consume token. */
997 static void lex_check(LexState
*ls
, LexToken tok
)
999 if (ls
->token
!= tok
)
1004 /* Check for matching token. */
1005 static void lex_match(LexState
*ls
, LexToken what
, LexToken who
, BCLine line
)
1007 if (!lex_opt(ls
, what
)) {
1008 if (line
== ls
->linenumber
) {
1009 err_token(ls
, what
);
1011 const char *swhat
= lj_lex_token2str(ls
, what
);
1012 const char *swho
= lj_lex_token2str(ls
, who
);
1013 lj_lex_error(ls
, ls
->token
, LJ_ERR_XMATCH
, swhat
, swho
, line
);
1018 /* Check for string token. */
1019 static GCstr
*lex_str(LexState
*ls
)
1022 if (ls
->token
!= TK_name
&& (LJ_52
|| ls
->token
!= TK_goto
))
1023 err_token(ls
, TK_name
);
1024 s
= strV(&ls
->tokenval
);
1029 /* -- Variable handling --------------------------------------------------- */
1031 #define var_get(ls, fs, i) ((ls)->vstack[(fs)->varmap[(i)]])
1033 /* Define a new local variable. */
1034 static void var_new(LexState
*ls
, BCReg n
, GCstr
*name
)
1036 FuncState
*fs
= ls
->fs
;
1037 MSize vtop
= ls
->vtop
;
1038 checklimit(fs
, fs
->nactvar
+n
, LJ_MAX_LOCVAR
, "local variables");
1039 if (LJ_UNLIKELY(vtop
>= ls
->sizevstack
)) {
1040 if (ls
->sizevstack
>= LJ_MAX_VSTACK
)
1041 lj_lex_error(ls
, 0, LJ_ERR_XLIMC
, LJ_MAX_VSTACK
);
1042 lj_mem_growvec(ls
->L
, ls
->vstack
, ls
->sizevstack
, LJ_MAX_VSTACK
, VarInfo
);
1044 lua_assert((uintptr_t)name
< VARNAME__MAX
||
1045 lj_tab_getstr(fs
->kt
, name
) != NULL
);
1046 /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1047 setgcref(ls
->vstack
[vtop
].name
, obj2gco(name
));
1048 fs
->varmap
[fs
->nactvar
+n
] = (uint16_t)vtop
;
1052 #define var_new_lit(ls, n, v) \
1053 var_new(ls, (n), lj_parse_keepstr(ls, "" v, sizeof(v)-1))
1055 #define var_new_fixed(ls, n, vn) \
1056 var_new(ls, (n), (GCstr *)(uintptr_t)(vn))
1058 /* Add local variables. */
1059 static void var_add(LexState
*ls
, BCReg nvars
)
1061 FuncState
*fs
= ls
->fs
;
1062 BCReg nactvar
= fs
->nactvar
;
1064 VarInfo
*v
= &var_get(ls
, fs
, nactvar
);
1065 v
->startpc
= fs
->pc
;
1066 v
->slot
= nactvar
++;
1069 fs
->nactvar
= nactvar
;
1072 /* Remove local variables. */
1073 static void var_remove(LexState
*ls
, BCReg tolevel
)
1075 FuncState
*fs
= ls
->fs
;
1076 while (fs
->nactvar
> tolevel
)
1077 var_get(ls
, fs
, --fs
->nactvar
).endpc
= fs
->pc
;
1080 /* Lookup local variable name. */
1081 static BCReg
var_lookup_local(FuncState
*fs
, GCstr
*n
)
1084 for (i
= fs
->nactvar
-1; i
>= 0; i
--) {
1085 if (n
== strref(var_get(fs
->ls
, fs
, i
).name
))
1088 return (BCReg
)-1; /* Not found. */
1091 /* Lookup or add upvalue index. */
1092 static MSize
var_lookup_uv(FuncState
*fs
, MSize vidx
, ExpDesc
*e
)
1094 MSize i
, n
= fs
->nuv
;
1095 for (i
= 0; i
< n
; i
++)
1096 if (fs
->uvmap
[i
] == vidx
)
1097 return i
; /* Already exists. */
1098 /* Otherwise create a new one. */
1099 checklimit(fs
, fs
->nuv
, LJ_MAX_UPVAL
, "upvalues");
1100 lua_assert(e
->k
== VLOCAL
|| e
->k
== VUPVAL
);
1101 fs
->uvmap
[n
] = (uint16_t)vidx
;
1102 fs
->uvtmp
[n
] = (uint16_t)(e
->k
== VLOCAL
? vidx
: LJ_MAX_VSTACK
+e
->u
.s
.info
);
1107 /* Forward declaration. */
1108 static void fscope_uvmark(FuncState
*fs
, BCReg level
);
1110 /* Recursively lookup variables in enclosing functions. */
1111 static MSize
var_lookup_(FuncState
*fs
, GCstr
*name
, ExpDesc
*e
, int first
)
1114 BCReg reg
= var_lookup_local(fs
, name
);
1115 if ((int32_t)reg
>= 0) { /* Local in this function? */
1116 expr_init(e
, VLOCAL
, reg
);
1118 fscope_uvmark(fs
, reg
); /* Scope now has an upvalue. */
1119 return (MSize
)(e
->u
.s
.aux
= (uint32_t)fs
->varmap
[reg
]);
1121 MSize vidx
= var_lookup_(fs
->prev
, name
, e
, 0); /* Var in outer func? */
1122 if ((int32_t)vidx
>= 0) { /* Yes, make it an upvalue here. */
1123 e
->u
.s
.info
= (uint8_t)var_lookup_uv(fs
, vidx
, e
);
1128 } else { /* Not found in any function, must be a global. */
1129 expr_init(e
, VGLOBAL
, 0);
1132 return (MSize
)-1; /* Global. */
1135 /* Lookup variable name. */
1136 #define var_lookup(ls, e) \
1137 var_lookup_((ls)->fs, lex_str(ls), (e), 1)
1139 /* -- Goto an label handling ---------------------------------------------- */
1141 /* Add a new goto or label. */
1142 static MSize
gola_new(LexState
*ls
, GCstr
*name
, uint8_t info
, BCPos pc
)
1144 FuncState
*fs
= ls
->fs
;
1145 MSize vtop
= ls
->vtop
;
1146 if (LJ_UNLIKELY(vtop
>= ls
->sizevstack
)) {
1147 if (ls
->sizevstack
>= LJ_MAX_VSTACK
)
1148 lj_lex_error(ls
, 0, LJ_ERR_XLIMC
, LJ_MAX_VSTACK
);
1149 lj_mem_growvec(ls
->L
, ls
->vstack
, ls
->sizevstack
, LJ_MAX_VSTACK
, VarInfo
);
1151 lua_assert(name
== NAME_BREAK
|| lj_tab_getstr(fs
->kt
, name
) != NULL
);
1152 /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1153 setgcref(ls
->vstack
[vtop
].name
, obj2gco(name
));
1154 ls
->vstack
[vtop
].startpc
= pc
;
1155 ls
->vstack
[vtop
].slot
= (uint8_t)fs
->nactvar
;
1156 ls
->vstack
[vtop
].info
= info
;
1161 #define gola_isgoto(v) ((v)->info & VSTACK_GOTO)
1162 #define gola_islabel(v) ((v)->info & VSTACK_LABEL)
1163 #define gola_isgotolabel(v) ((v)->info & (VSTACK_GOTO|VSTACK_LABEL))
1165 /* Patch goto to jump to label. */
1166 static void gola_patch(LexState
*ls
, VarInfo
*vg
, VarInfo
*vl
)
1168 FuncState
*fs
= ls
->fs
;
1169 BCPos pc
= vg
->startpc
;
1170 setgcrefnull(vg
->name
); /* Invalidate pending goto. */
1171 setbc_a(&fs
->bcbase
[pc
].ins
, vl
->slot
);
1172 jmp_patch(fs
, pc
, vl
->startpc
);
1175 /* Patch goto to close upvalues. */
1176 static void gola_close(LexState
*ls
, VarInfo
*vg
)
1178 FuncState
*fs
= ls
->fs
;
1179 BCPos pc
= vg
->startpc
;
1180 BCIns
*ip
= &fs
->bcbase
[pc
].ins
;
1181 lua_assert(gola_isgoto(vg
));
1182 lua_assert(bc_op(*ip
) == BC_JMP
|| bc_op(*ip
) == BC_UCLO
);
1183 setbc_a(ip
, vg
->slot
);
1184 if (bc_op(*ip
) == BC_JMP
) {
1185 BCPos next
= jmp_next(fs
, pc
);
1186 if (next
!= NO_JMP
) jmp_patch(fs
, next
, pc
); /* Jump to UCLO. */
1187 setbc_op(ip
, BC_UCLO
); /* Turn into UCLO. */
1188 setbc_j(ip
, NO_JMP
);
1192 /* Resolve pending forward gotos for label. */
1193 static void gola_resolve(LexState
*ls
, FuncScope
*bl
, MSize idx
)
1195 VarInfo
*vg
= ls
->vstack
+ bl
->vstart
;
1196 VarInfo
*vl
= ls
->vstack
+ idx
;
1197 for (; vg
< vl
; vg
++)
1198 if (gcrefeq(vg
->name
, vl
->name
) && gola_isgoto(vg
)) {
1199 if (vg
->slot
< vl
->slot
) {
1200 GCstr
*name
= strref(var_get(ls
, ls
->fs
, vg
->slot
).name
);
1201 lua_assert((uintptr_t)name
>= VARNAME__MAX
);
1202 ls
->linenumber
= ls
->fs
->bcbase
[vg
->startpc
].line
;
1203 lua_assert(strref(vg
->name
) != NAME_BREAK
);
1204 lj_lex_error(ls
, 0, LJ_ERR_XGSCOPE
,
1205 strdata(strref(vg
->name
)), strdata(name
));
1207 gola_patch(ls
, vg
, vl
);
1211 /* Fixup remaining gotos and labels for scope. */
1212 static void gola_fixup(LexState
*ls
, FuncScope
*bl
)
1214 VarInfo
*v
= ls
->vstack
+ bl
->vstart
;
1215 VarInfo
*ve
= ls
->vstack
+ ls
->vtop
;
1216 for (; v
< ve
; v
++) {
1217 GCstr
*name
= strref(v
->name
);
1218 if (name
!= NULL
) { /* Only consider remaining valid gotos/labels. */
1219 if (gola_islabel(v
)) {
1221 setgcrefnull(v
->name
); /* Invalidate label that goes out of scope. */
1222 for (vg
= v
+1; vg
< ve
; vg
++) /* Resolve pending backward gotos. */
1223 if (strref(vg
->name
) == name
&& gola_isgoto(vg
)) {
1224 if ((bl
->flags
&FSCOPE_UPVAL
) && vg
->slot
> v
->slot
)
1226 gola_patch(ls
, vg
, v
);
1228 } else if (gola_isgoto(v
)) {
1229 if (bl
->prev
) { /* Propagate goto or break to outer scope. */
1230 bl
->prev
->flags
|= name
== NAME_BREAK
? FSCOPE_BREAK
: FSCOPE_GOLA
;
1231 v
->slot
= bl
->nactvar
;
1232 if ((bl
->flags
& FSCOPE_UPVAL
))
1234 } else { /* No outer scope: undefined goto label or no loop. */
1235 ls
->linenumber
= ls
->fs
->bcbase
[v
->startpc
].line
;
1236 if (name
== NAME_BREAK
)
1237 lj_lex_error(ls
, 0, LJ_ERR_XBREAK
);
1239 lj_lex_error(ls
, 0, LJ_ERR_XLUNDEF
, strdata(name
));
1246 /* Find existing label. */
1247 static VarInfo
*gola_findlabel(LexState
*ls
, GCstr
*name
)
1249 VarInfo
*v
= ls
->vstack
+ ls
->fs
->bl
->vstart
;
1250 VarInfo
*ve
= ls
->vstack
+ ls
->vtop
;
1252 if (strref(v
->name
) == name
&& gola_islabel(v
))
1257 /* -- Scope handling ------------------------------------------------------ */
1259 /* Begin a scope. */
1260 static void fscope_begin(FuncState
*fs
, FuncScope
*bl
, int flags
)
1262 bl
->nactvar
= (uint8_t)fs
->nactvar
;
1264 bl
->vstart
= fs
->ls
->vtop
;
1267 lua_assert(fs
->freereg
== fs
->nactvar
);
1271 static void fscope_end(FuncState
*fs
)
1273 FuncScope
*bl
= fs
->bl
;
1274 LexState
*ls
= fs
->ls
;
1276 var_remove(ls
, bl
->nactvar
);
1277 fs
->freereg
= fs
->nactvar
;
1278 lua_assert(bl
->nactvar
== fs
->nactvar
);
1279 if ((bl
->flags
& (FSCOPE_UPVAL
|FSCOPE_NOCLOSE
)) == FSCOPE_UPVAL
)
1280 bcemit_AJ(fs
, BC_UCLO
, bl
->nactvar
, 0);
1281 if ((bl
->flags
& FSCOPE_BREAK
)) {
1282 if ((bl
->flags
& FSCOPE_LOOP
)) {
1283 MSize idx
= gola_new(ls
, NAME_BREAK
, VSTACK_LABEL
, fs
->pc
);
1284 ls
->vtop
= idx
; /* Drop break label immediately. */
1285 gola_resolve(ls
, bl
, idx
);
1286 } else { /* Need the fixup step to propagate the breaks. */
1291 if ((bl
->flags
& FSCOPE_GOLA
)) {
1296 /* Mark scope as having an upvalue. */
1297 static void fscope_uvmark(FuncState
*fs
, BCReg level
)
1300 for (bl
= fs
->bl
; bl
&& bl
->nactvar
> level
; bl
= bl
->prev
)
1303 bl
->flags
|= FSCOPE_UPVAL
;
1306 /* -- Function state management ------------------------------------------- */
1308 /* Fixup bytecode for prototype. */
1309 static void fs_fixup_bc(FuncState
*fs
, GCproto
*pt
, BCIns
*bc
, MSize n
)
1311 BCInsLine
*base
= fs
->bcbase
;
1314 bc
[0] = BCINS_AD((fs
->flags
& PROTO_VARARG
) ? BC_FUNCV
: BC_FUNCF
,
1316 for (i
= 1; i
< n
; i
++)
1317 bc
[i
] = base
[i
].ins
;
1320 /* Fixup upvalues for child prototype, step #2. */
1321 static void fs_fixup_uv2(FuncState
*fs
, GCproto
*pt
)
1323 VarInfo
*vstack
= fs
->ls
->vstack
;
1324 uint16_t *uv
= proto_uv(pt
);
1325 MSize i
, n
= pt
->sizeuv
;
1326 for (i
= 0; i
< n
; i
++) {
1327 VarIndex vidx
= uv
[i
];
1328 if (vidx
>= LJ_MAX_VSTACK
)
1329 uv
[i
] = vidx
- LJ_MAX_VSTACK
;
1330 else if ((vstack
[vidx
].info
& VSTACK_VAR_RW
))
1331 uv
[i
] = vstack
[vidx
].slot
| PROTO_UV_LOCAL
;
1333 uv
[i
] = vstack
[vidx
].slot
| PROTO_UV_LOCAL
| PROTO_UV_IMMUTABLE
;
1337 /* Fixup constants for prototype. */
1338 static void fs_fixup_k(FuncState
*fs
, GCproto
*pt
, void *kptr
)
1344 checklimitgt(fs
, fs
->nkn
, BCMAX_D
+1, "constants");
1345 checklimitgt(fs
, fs
->nkgc
, BCMAX_D
+1, "constants");
1346 setmref(pt
->k
, kptr
);
1347 pt
->sizekn
= fs
->nkn
;
1348 pt
->sizekgc
= fs
->nkgc
;
1350 array
= tvref(kt
->array
);
1351 for (i
= 0; i
< kt
->asize
; i
++)
1352 if (tvhaskslot(&array
[i
])) {
1353 TValue
*tv
= &((TValue
*)kptr
)[tvkslot(&array
[i
])];
1355 setintV(tv
, (int32_t)i
);
1357 setnumV(tv
, (lua_Number
)i
);
1359 node
= noderef(kt
->node
);
1361 for (i
= 0; i
<= hmask
; i
++) {
1363 if (tvhaskslot(&n
->val
)) {
1364 ptrdiff_t kidx
= (ptrdiff_t)tvkslot(&n
->val
);
1365 lua_assert(!tvisint(&n
->key
));
1366 if (tvisnum(&n
->key
)) {
1367 TValue
*tv
= &((TValue
*)kptr
)[kidx
];
1369 lua_Number nn
= numV(&n
->key
);
1370 int32_t k
= lj_num2int(nn
);
1371 lua_assert(!tvismzero(&n
->key
));
1372 if ((lua_Number
)k
== nn
)
1380 GCobj
*o
= gcV(&n
->key
);
1381 setgcref(((GCRef
*)kptr
)[~kidx
], o
);
1382 lj_gc_objbarrier(fs
->L
, pt
, o
);
1383 if (tvisproto(&n
->key
))
1384 fs_fixup_uv2(fs
, gco2pt(o
));
1390 /* Fixup upvalues for prototype, step #1. */
1391 static void fs_fixup_uv1(FuncState
*fs
, GCproto
*pt
, uint16_t *uv
)
1393 setmref(pt
->uv
, uv
);
1394 pt
->sizeuv
= fs
->nuv
;
1395 memcpy(uv
, fs
->uvtmp
, fs
->nuv
*sizeof(VarIndex
));
1398 #ifndef LUAJIT_DISABLE_DEBUGINFO
1399 /* Prepare lineinfo for prototype. */
1400 static size_t fs_prep_line(FuncState
*fs
, BCLine numline
)
1402 return (fs
->pc
-1) << (numline
< 256 ? 0 : numline
< 65536 ? 1 : 2);
1405 /* Fixup lineinfo for prototype. */
1406 static void fs_fixup_line(FuncState
*fs
, GCproto
*pt
,
1407 void *lineinfo
, BCLine numline
)
1409 BCInsLine
*base
= fs
->bcbase
+ 1;
1410 BCLine first
= fs
->linedefined
;
1411 MSize i
= 0, n
= fs
->pc
-1;
1412 pt
->firstline
= fs
->linedefined
;
1413 pt
->numline
= numline
;
1414 setmref(pt
->lineinfo
, lineinfo
);
1415 if (LJ_LIKELY(numline
< 256)) {
1416 uint8_t *li
= (uint8_t *)lineinfo
;
1418 BCLine delta
= base
[i
].line
- first
;
1419 lua_assert(delta
>= 0 && delta
< 256);
1420 li
[i
] = (uint8_t)delta
;
1422 } else if (LJ_LIKELY(numline
< 65536)) {
1423 uint16_t *li
= (uint16_t *)lineinfo
;
1425 BCLine delta
= base
[i
].line
- first
;
1426 lua_assert(delta
>= 0 && delta
< 65536);
1427 li
[i
] = (uint16_t)delta
;
1430 uint32_t *li
= (uint32_t *)lineinfo
;
1432 BCLine delta
= base
[i
].line
- first
;
1433 lua_assert(delta
>= 0);
1434 li
[i
] = (uint32_t)delta
;
1439 /* Resize buffer if needed. */
1440 static LJ_NOINLINE
void fs_buf_resize(LexState
*ls
, MSize len
)
1442 MSize sz
= ls
->sb
.sz
* 2;
1443 while (ls
->sb
.n
+ len
> sz
) sz
= sz
* 2;
1444 lj_str_resizebuf(ls
->L
, &ls
->sb
, sz
);
1447 static LJ_AINLINE
void fs_buf_need(LexState
*ls
, MSize len
)
1449 if (LJ_UNLIKELY(ls
->sb
.n
+ len
> ls
->sb
.sz
))
1450 fs_buf_resize(ls
, len
);
1453 /* Add string to buffer. */
1454 static void fs_buf_str(LexState
*ls
, const char *str
, MSize len
)
1456 char *p
= ls
->sb
.buf
+ ls
->sb
.n
;
1459 for (i
= 0; i
< len
; i
++) p
[i
] = str
[i
];
1462 /* Add ULEB128 value to buffer. */
1463 static void fs_buf_uleb128(LexState
*ls
, uint32_t v
)
1466 uint8_t *p
= (uint8_t *)ls
->sb
.buf
;
1467 for (; v
>= 0x80; v
>>= 7)
1468 p
[n
++] = (uint8_t)((v
& 0x7f) | 0x80);
1469 p
[n
++] = (uint8_t)v
;
1473 /* Prepare variable info for prototype. */
1474 static size_t fs_prep_var(LexState
*ls
, FuncState
*fs
, size_t *ofsvar
)
1476 VarInfo
*vs
=ls
->vstack
, *ve
;
1479 lj_str_resetbuf(&ls
->sb
); /* Copy to temp. string buffer. */
1480 /* Store upvalue names. */
1481 for (i
= 0, n
= fs
->nuv
; i
< n
; i
++) {
1482 GCstr
*s
= strref(vs
[fs
->uvmap
[i
]].name
);
1483 MSize len
= s
->len
+1;
1484 fs_buf_need(ls
, len
);
1485 fs_buf_str(ls
, strdata(s
), len
);
1489 /* Store local variable names and compressed ranges. */
1490 for (ve
= vs
+ ls
->vtop
, vs
+= fs
->vbase
; vs
< ve
; vs
++) {
1491 if (!gola_isgotolabel(vs
)) {
1492 GCstr
*s
= strref(vs
->name
);
1494 if ((uintptr_t)s
< VARNAME__MAX
) {
1495 fs_buf_need(ls
, 1 + 2*5);
1496 ls
->sb
.buf
[ls
->sb
.n
++] = (uint8_t)(uintptr_t)s
;
1498 MSize len
= s
->len
+1;
1499 fs_buf_need(ls
, len
+ 2*5);
1500 fs_buf_str(ls
, strdata(s
), len
);
1502 startpc
= vs
->startpc
;
1503 fs_buf_uleb128(ls
, startpc
-lastpc
);
1504 fs_buf_uleb128(ls
, vs
->endpc
-startpc
);
1509 ls
->sb
.buf
[ls
->sb
.n
++] = '\0'; /* Terminator for varinfo. */
1513 /* Fixup variable info for prototype. */
1514 static void fs_fixup_var(LexState
*ls
, GCproto
*pt
, uint8_t *p
, size_t ofsvar
)
1516 setmref(pt
->uvinfo
, p
);
1517 setmref(pt
->varinfo
, (char *)p
+ ofsvar
);
1518 memcpy(p
, ls
->sb
.buf
, ls
->sb
.n
); /* Copy from temp. string buffer. */
1522 /* Initialize with empty debug info, if disabled. */
1523 #define fs_prep_line(fs, numline) (UNUSED(numline), 0)
1524 #define fs_fixup_line(fs, pt, li, numline) \
1525 pt->firstline = pt->numline = 0, setmref((pt)->lineinfo, NULL)
1526 #define fs_prep_var(ls, fs, ofsvar) (UNUSED(ofsvar), 0)
1527 #define fs_fixup_var(ls, pt, p, ofsvar) \
1528 setmref((pt)->uvinfo, NULL), setmref((pt)->varinfo, NULL)
1532 /* Check if bytecode op returns. */
1533 static int bcopisret(BCOp op
)
1536 case BC_CALLMT
: case BC_CALLT
:
1537 case BC_RETM
: case BC_RET
: case BC_RET0
: case BC_RET1
:
1544 /* Fixup return instruction for prototype. */
1545 static void fs_fixup_ret(FuncState
*fs
)
1547 BCPos lastpc
= fs
->pc
;
1548 if (lastpc
<= fs
->lasttarget
|| !bcopisret(bc_op(fs
->bcbase
[lastpc
-1].ins
))) {
1549 if ((fs
->bl
->flags
& FSCOPE_UPVAL
))
1550 bcemit_AJ(fs
, BC_UCLO
, 0, 0);
1551 bcemit_AD(fs
, BC_RET0
, 0, 1); /* Need final return. */
1553 fs
->bl
->flags
|= FSCOPE_NOCLOSE
; /* Handled above. */
1555 lua_assert(fs
->bl
== NULL
);
1556 /* May need to fixup returns encoded before first function was created. */
1557 if (fs
->flags
& PROTO_FIXUP_RETURN
) {
1559 for (pc
= 1; pc
< lastpc
; pc
++) {
1560 BCIns ins
= fs
->bcbase
[pc
].ins
;
1562 switch (bc_op(ins
)) {
1563 case BC_CALLMT
: case BC_CALLT
:
1564 case BC_RETM
: case BC_RET
: case BC_RET0
: case BC_RET1
:
1565 offset
= bcemit_INS(fs
, ins
); /* Copy original instruction. */
1566 fs
->bcbase
[offset
].line
= fs
->bcbase
[pc
].line
;
1567 offset
= offset
-(pc
+1)+BCBIAS_J
;
1568 if (offset
> BCMAX_D
)
1569 err_syntax(fs
->ls
, LJ_ERR_XFIXUP
);
1570 /* Replace with UCLO plus branch. */
1571 fs
->bcbase
[pc
].ins
= BCINS_AD(BC_UCLO
, 0, offset
);
1574 return; /* We're done. */
1582 /* Finish a FuncState and return the new prototype. */
1583 static GCproto
*fs_finish(LexState
*ls
, BCLine line
)
1585 lua_State
*L
= ls
->L
;
1586 FuncState
*fs
= ls
->fs
;
1587 BCLine numline
= line
- fs
->linedefined
;
1588 size_t sizept
, ofsk
, ofsuv
, ofsli
, ofsdbg
, ofsvar
;
1591 /* Apply final fixups. */
1594 /* Calculate total size of prototype including all colocated arrays. */
1595 sizept
= sizeof(GCproto
) + fs
->pc
*sizeof(BCIns
) + fs
->nkgc
*sizeof(GCRef
);
1596 sizept
= (sizept
+ sizeof(TValue
)-1) & ~(sizeof(TValue
)-1);
1597 ofsk
= sizept
; sizept
+= fs
->nkn
*sizeof(TValue
);
1598 ofsuv
= sizept
; sizept
+= ((fs
->nuv
+1)&~1)*2;
1599 ofsli
= sizept
; sizept
+= fs_prep_line(fs
, numline
);
1600 ofsdbg
= sizept
; sizept
+= fs_prep_var(ls
, fs
, &ofsvar
);
1602 /* Allocate prototype and initialize its fields. */
1603 pt
= (GCproto
*)lj_mem_newgco(L
, (MSize
)sizept
);
1604 pt
->gct
= ~LJ_TPROTO
;
1605 pt
->sizept
= (MSize
)sizept
;
1607 pt
->flags
= (uint8_t)(fs
->flags
& ~(PROTO_HAS_RETURN
|PROTO_FIXUP_RETURN
));
1608 pt
->numparams
= fs
->numparams
;
1609 pt
->framesize
= fs
->framesize
;
1610 setgcref(pt
->chunkname
, obj2gco(ls
->chunkname
));
1612 /* Close potentially uninitialized gap between bc and kgc. */
1613 *(uint32_t *)((char *)pt
+ ofsk
- sizeof(GCRef
)*(fs
->nkgc
+1)) = 0;
1614 fs_fixup_bc(fs
, pt
, (BCIns
*)((char *)pt
+ sizeof(GCproto
)), fs
->pc
);
1615 fs_fixup_k(fs
, pt
, (void *)((char *)pt
+ ofsk
));
1616 fs_fixup_uv1(fs
, pt
, (uint16_t *)((char *)pt
+ ofsuv
));
1617 fs_fixup_line(fs
, pt
, (void *)((char *)pt
+ ofsli
), numline
);
1618 fs_fixup_var(ls
, pt
, (uint8_t *)((char *)pt
+ ofsdbg
), ofsvar
);
1620 lj_vmevent_send(L
, BC
,
1621 setprotoV(L
, L
->top
++, pt
);
1624 L
->top
--; /* Pop table of constants. */
1625 ls
->vtop
= fs
->vbase
; /* Reset variable stack. */
1627 lua_assert(ls
->fs
!= NULL
|| ls
->token
== TK_eof
);
1631 /* Initialize a new FuncState. */
1632 static void fs_init(LexState
*ls
, FuncState
*fs
)
1634 lua_State
*L
= ls
->L
;
1635 fs
->prev
= ls
->fs
; ls
->fs
= fs
; /* Append to list. */
1637 fs
->vbase
= ls
->vtop
;
1649 fs
->framesize
= 1; /* Minimum frame size. */
1650 fs
->kt
= lj_tab_new(L
, 0, 0);
1651 /* Anchor table of constants in stack to avoid being collected. */
1652 settabV(L
, L
->top
, fs
->kt
);
1656 /* -- Expressions --------------------------------------------------------- */
1658 /* Forward declaration. */
1659 static void expr(LexState
*ls
, ExpDesc
*v
);
1661 /* Return string expression. */
1662 static void expr_str(LexState
*ls
, ExpDesc
*e
)
1664 expr_init(e
, VKSTR
, 0);
1665 e
->u
.sval
= lex_str(ls
);
1668 /* Return index expression. */
1669 static void expr_index(FuncState
*fs
, ExpDesc
*t
, ExpDesc
*e
)
1671 /* Already called: expr_toval(fs, e). */
1673 if (expr_isnumk(e
)) {
1675 if (tvisint(expr_numtv(e
))) {
1676 int32_t k
= intV(expr_numtv(e
));
1678 t
->u
.s
.aux
= BCMAX_C
+1+(uint32_t)k
; /* 256..511: const byte key */
1683 lua_Number n
= expr_numberV(e
);
1684 int32_t k
= lj_num2int(n
);
1685 if (checku8(k
) && n
== (lua_Number
)k
) {
1686 t
->u
.s
.aux
= BCMAX_C
+1+(uint32_t)k
; /* 256..511: const byte key */
1690 } else if (expr_isstrk(e
)) {
1691 BCReg idx
= const_str(fs
, e
);
1692 if (idx
<= BCMAX_C
) {
1693 t
->u
.s
.aux
= ~idx
; /* -256..-1: const string key */
1697 t
->u
.s
.aux
= expr_toanyreg(fs
, e
); /* 0..255: register */
1700 /* Parse index expression with named field. */
1701 static void expr_field(LexState
*ls
, ExpDesc
*v
)
1703 FuncState
*fs
= ls
->fs
;
1705 expr_toanyreg(fs
, v
);
1706 lj_lex_next(ls
); /* Skip dot or colon. */
1708 expr_index(fs
, v
, &key
);
1711 /* Parse index expression with brackets. */
1712 static void expr_bracket(LexState
*ls
, ExpDesc
*v
)
1714 lj_lex_next(ls
); /* Skip '['. */
1716 expr_toval(ls
->fs
, v
);
1720 /* Get value of constant expression. */
1721 static void expr_kvalue(TValue
*v
, ExpDesc
*e
)
1723 if (e
->k
<= VKTRUE
) {
1724 setitype(v
, ~(uint32_t)e
->k
);
1725 } else if (e
->k
== VKSTR
) {
1726 setgcref(v
->gcr
, obj2gco(e
->u
.sval
));
1727 setitype(v
, LJ_TSTR
);
1729 lua_assert(tvisnumber(expr_numtv(e
)));
1730 *v
= *expr_numtv(e
);
1734 /* Parse table constructor expression. */
1735 static void expr_table(LexState
*ls
, ExpDesc
*e
)
1737 FuncState
*fs
= ls
->fs
;
1738 BCLine line
= ls
->linenumber
;
1740 int vcall
= 0, needarr
= 0, fixt
= 0;
1741 uint32_t narr
= 1; /* First array index. */
1742 uint32_t nhash
= 0; /* Number of hash entries. */
1743 BCReg freg
= fs
->freereg
;
1744 BCPos pc
= bcemit_AD(fs
, BC_TNEW
, freg
, 0);
1745 expr_init(e
, VNONRELOC
, freg
);
1746 bcreg_reserve(fs
, 1);
1749 while (ls
->token
!= '}') {
1752 if (ls
->token
== '[') {
1753 expr_bracket(ls
, &key
); /* Already calls expr_toval. */
1754 if (!expr_isk(&key
)) expr_index(fs
, e
, &key
);
1755 if (expr_isnumk(&key
) && expr_numiszero(&key
)) needarr
= 1; else nhash
++;
1757 } else if ((ls
->token
== TK_name
|| (!LJ_52
&& ls
->token
== TK_goto
)) &&
1758 lj_lex_lookahead(ls
) == '=') {
1763 expr_init(&key
, VKNUM
, 0);
1764 setintV(&key
.u
.nval
, (int)narr
);
1766 needarr
= vcall
= 1;
1769 if (expr_isk(&key
) && key
.k
!= VKNIL
&&
1770 (key
.k
== VKSTR
|| expr_isk_nojump(&val
))) {
1772 if (!t
) { /* Create template table on demand. */
1774 t
= lj_tab_new(fs
->L
, needarr
? narr
: 0, hsize2hbits(nhash
));
1775 kidx
= const_gc(fs
, obj2gco(t
), LJ_TTAB
);
1776 fs
->bcbase
[pc
].ins
= BCINS_AD(BC_TDUP
, freg
-1, kidx
);
1779 expr_kvalue(&k
, &key
);
1780 v
= lj_tab_set(fs
->L
, t
, &k
);
1781 lj_gc_anybarriert(fs
->L
, t
);
1782 if (expr_isk_nojump(&val
)) { /* Add const key/value to template table. */
1783 expr_kvalue(v
, &val
);
1784 } else { /* Otherwise create dummy string key (avoids lj_tab_newkey). */
1785 settabV(fs
->L
, v
, t
); /* Preserve key with table itself as value. */
1786 fixt
= 1; /* Fix this later, after all resizes. */
1791 if (val
.k
!= VCALL
) { expr_toanyreg(fs
, &val
); vcall
= 0; }
1792 if (expr_isk(&key
)) expr_index(fs
, e
, &key
);
1793 bcemit_store(fs
, e
, &val
);
1796 if (!lex_opt(ls
, ',') && !lex_opt(ls
, ';')) break;
1798 lex_match(ls
, '}', '{', line
);
1800 BCInsLine
*ilp
= &fs
->bcbase
[fs
->pc
-1];
1802 lua_assert(bc_a(ilp
->ins
) == freg
&&
1803 bc_op(ilp
->ins
) == (narr
> 256 ? BC_TSETV
: BC_TSETB
));
1804 expr_init(&en
, VKNUM
, 0);
1805 en
.u
.nval
.u32
.lo
= narr
-1;
1806 en
.u
.nval
.u32
.hi
= 0x43300000; /* Biased integer to avoid denormals. */
1807 if (narr
> 256) { fs
->pc
--; ilp
--; }
1808 ilp
->ins
= BCINS_AD(BC_TSETM
, freg
, const_num(fs
, &en
));
1809 setbc_b(&ilp
[-1].ins
, 0);
1811 if (pc
== fs
->pc
-1) { /* Make expr relocable if possible. */
1816 e
->k
= VNONRELOC
; /* May have been changed by expr_index. */
1818 if (!t
) { /* Construct TNEW RD: hhhhhaaaaaaaaaaa. */
1819 BCIns
*ip
= &fs
->bcbase
[pc
].ins
;
1820 if (!needarr
) narr
= 0;
1821 else if (narr
< 3) narr
= 3;
1822 else if (narr
> 0x7ff) narr
= 0x7ff;
1823 setbc_d(ip
, narr
|(hsize2hbits(nhash
)<<11));
1825 if (needarr
&& t
->asize
< narr
)
1826 lj_tab_reasize(fs
->L
, t
, narr
-1);
1827 if (fixt
) { /* Fix value for dummy keys in template table. */
1828 Node
*node
= noderef(t
->node
);
1829 uint32_t i
, hmask
= t
->hmask
;
1830 for (i
= 0; i
<= hmask
; i
++) {
1832 if (tvistab(&n
->val
)) {
1833 lua_assert(tabV(&n
->val
) == t
);
1834 setnilV(&n
->val
); /* Turn value into nil. */
1842 /* Parse function parameters. */
1843 static BCReg
parse_params(LexState
*ls
, int needself
)
1845 FuncState
*fs
= ls
->fs
;
1849 var_new_lit(ls
, nparams
++, "self");
1850 if (ls
->token
!= ')') {
1852 if (ls
->token
== TK_name
|| (!LJ_52
&& ls
->token
== TK_goto
)) {
1853 var_new(ls
, nparams
++, lex_str(ls
));
1854 } else if (ls
->token
== TK_dots
) {
1856 fs
->flags
|= PROTO_VARARG
;
1859 err_syntax(ls
, LJ_ERR_XPARAM
);
1861 } while (lex_opt(ls
, ','));
1863 var_add(ls
, nparams
);
1864 lua_assert(fs
->nactvar
== nparams
);
1865 bcreg_reserve(fs
, nparams
);
1870 /* Forward declaration. */
1871 static void parse_chunk(LexState
*ls
);
1873 /* Parse body of a function. */
1874 static void parse_body(LexState
*ls
, ExpDesc
*e
, int needself
, BCLine line
)
1876 FuncState fs
, *pfs
= ls
->fs
;
1879 ptrdiff_t oldbase
= pfs
->bcbase
- ls
->bcstack
;
1881 fscope_begin(&fs
, &bl
, 0);
1882 fs
.linedefined
= line
;
1883 fs
.numparams
= (uint8_t)parse_params(ls
, needself
);
1884 fs
.bcbase
= pfs
->bcbase
+ pfs
->pc
;
1885 fs
.bclim
= pfs
->bclim
- pfs
->pc
;
1886 bcemit_AD(&fs
, BC_FUNCF
, 0, 0); /* Placeholder. */
1888 if (ls
->token
!= TK_end
) lex_match(ls
, TK_end
, TK_function
, line
);
1889 pt
= fs_finish(ls
, (ls
->lastline
= ls
->linenumber
));
1890 pfs
->bcbase
= ls
->bcstack
+ oldbase
; /* May have been reallocated. */
1891 pfs
->bclim
= (BCPos
)(ls
->sizebcstack
- oldbase
);
1892 /* Store new prototype in the constant array of the parent. */
1893 expr_init(e
, VRELOCABLE
,
1894 bcemit_AD(pfs
, BC_FNEW
, 0, const_gc(pfs
, obj2gco(pt
), LJ_TPROTO
)));
1896 pfs
->flags
|= (fs
.flags
& PROTO_FFI
);
1898 if (!(pfs
->flags
& PROTO_CHILD
)) {
1899 if (pfs
->flags
& PROTO_HAS_RETURN
)
1900 pfs
->flags
|= PROTO_FIXUP_RETURN
;
1901 pfs
->flags
|= PROTO_CHILD
;
1906 /* Parse expression list. Last expression is left open. */
1907 static BCReg
expr_list(LexState
*ls
, ExpDesc
*v
)
1911 while (lex_opt(ls
, ',')) {
1912 expr_tonextreg(ls
->fs
, v
);
1919 /* Parse function argument list. */
1920 static void parse_args(LexState
*ls
, ExpDesc
*e
)
1922 FuncState
*fs
= ls
->fs
;
1926 BCLine line
= ls
->linenumber
;
1927 if (ls
->token
== '(') {
1929 if (line
!= ls
->lastline
)
1930 err_syntax(ls
, LJ_ERR_XAMBIG
);
1933 if (ls
->token
== ')') { /* f(). */
1936 expr_list(ls
, &args
);
1937 if (args
.k
== VCALL
) /* f(a, b, g()) or f(a, b, ...). */
1938 setbc_b(bcptr(fs
, &args
), 0); /* Pass on multiple results. */
1940 lex_match(ls
, ')', '(', line
);
1941 } else if (ls
->token
== '{') {
1942 expr_table(ls
, &args
);
1943 } else if (ls
->token
== TK_string
) {
1944 expr_init(&args
, VKSTR
, 0);
1945 args
.u
.sval
= strV(&ls
->tokenval
);
1948 err_syntax(ls
, LJ_ERR_XFUNARG
);
1949 return; /* Silence compiler. */
1951 lua_assert(e
->k
== VNONRELOC
);
1952 base
= e
->u
.s
.info
; /* Base register for call. */
1953 if (args
.k
== VCALL
) {
1954 ins
= BCINS_ABC(BC_CALLM
, base
, 2, args
.u
.s
.aux
- base
- 1);
1956 if (args
.k
!= VVOID
)
1957 expr_tonextreg(fs
, &args
);
1958 ins
= BCINS_ABC(BC_CALL
, base
, 2, fs
->freereg
- base
);
1960 expr_init(e
, VCALL
, bcemit_INS(fs
, ins
));
1962 fs
->bcbase
[fs
->pc
- 1].line
= line
;
1963 fs
->freereg
= base
+1; /* Leave one result by default. */
1966 /* Parse primary expression. */
1967 static void expr_primary(LexState
*ls
, ExpDesc
*v
)
1969 FuncState
*fs
= ls
->fs
;
1970 /* Parse prefix expression. */
1971 if (ls
->token
== '(') {
1972 BCLine line
= ls
->linenumber
;
1975 lex_match(ls
, ')', '(', line
);
1976 expr_discharge(ls
->fs
, v
);
1977 } else if (ls
->token
== TK_name
|| (!LJ_52
&& ls
->token
== TK_goto
)) {
1980 err_syntax(ls
, LJ_ERR_XSYMBOL
);
1982 for (;;) { /* Parse multiple expression suffixes. */
1983 if (ls
->token
== '.') {
1985 } else if (ls
->token
== '[') {
1987 expr_toanyreg(fs
, v
);
1988 expr_bracket(ls
, &key
);
1989 expr_index(fs
, v
, &key
);
1990 } else if (ls
->token
== ':') {
1994 bcemit_method(fs
, v
, &key
);
1996 } else if (ls
->token
== '(' || ls
->token
== TK_string
|| ls
->token
== '{') {
1997 expr_tonextreg(fs
, v
);
2005 /* Parse simple expression. */
2006 static void expr_simple(LexState
*ls
, ExpDesc
*v
)
2008 switch (ls
->token
) {
2010 expr_init(v
, (LJ_HASFFI
&& tviscdata(&ls
->tokenval
)) ? VKCDATA
: VKNUM
, 0);
2011 copyTV(ls
->L
, &v
->u
.nval
, &ls
->tokenval
);
2014 expr_init(v
, VKSTR
, 0);
2015 v
->u
.sval
= strV(&ls
->tokenval
);
2018 expr_init(v
, VKNIL
, 0);
2021 expr_init(v
, VKTRUE
, 0);
2024 expr_init(v
, VKFALSE
, 0);
2026 case TK_dots
: { /* Vararg. */
2027 FuncState
*fs
= ls
->fs
;
2029 checkcond(ls
, fs
->flags
& PROTO_VARARG
, LJ_ERR_XDOTS
);
2030 bcreg_reserve(fs
, 1);
2031 base
= fs
->freereg
-1;
2032 expr_init(v
, VCALL
, bcemit_ABC(fs
, BC_VARG
, base
, 2, fs
->numparams
));
2036 case '{': /* Table constructor. */
2041 parse_body(ls
, v
, 0, ls
->linenumber
);
2044 expr_primary(ls
, v
);
2050 /* Manage syntactic levels to avoid blowing up the stack. */
2051 static void synlevel_begin(LexState
*ls
)
2053 if (++ls
->level
>= LJ_MAX_XLEVEL
)
2054 lj_lex_error(ls
, 0, LJ_ERR_XLEVELS
);
2057 #define synlevel_end(ls) ((ls)->level--)
2059 /* Convert token to binary operator. */
2060 static BinOpr
token2binop(LexToken tok
)
2063 case '+': return OPR_ADD
;
2064 case '-': return OPR_SUB
;
2065 case '*': return OPR_MUL
;
2066 case '/': return OPR_DIV
;
2067 case '%': return OPR_MOD
;
2068 case '^': return OPR_POW
;
2069 case TK_concat
: return OPR_CONCAT
;
2070 case TK_ne
: return OPR_NE
;
2071 case TK_eq
: return OPR_EQ
;
2072 case '<': return OPR_LT
;
2073 case TK_le
: return OPR_LE
;
2074 case '>': return OPR_GT
;
2075 case TK_ge
: return OPR_GE
;
2076 case TK_and
: return OPR_AND
;
2077 case TK_or
: return OPR_OR
;
2078 default: return OPR_NOBINOPR
;
2082 /* Priorities for each binary operator. ORDER OPR. */
2083 static const struct {
2084 uint8_t left
; /* Left priority. */
2085 uint8_t right
; /* Right priority. */
2087 {6,6}, {6,6}, {7,7}, {7,7}, {7,7}, /* ADD SUB MUL DIV MOD */
2088 {10,9}, {5,4}, /* POW CONCAT (right associative) */
2089 {3,3}, {3,3}, /* EQ NE */
2090 {3,3}, {3,3}, {3,3}, {3,3}, /* LT GE GT LE */
2091 {2,2}, {1,1} /* AND OR */
2094 #define UNARY_PRIORITY 8 /* Priority for unary operators. */
2096 /* Forward declaration. */
2097 static BinOpr
expr_binop(LexState
*ls
, ExpDesc
*v
, uint32_t limit
);
2099 /* Parse unary expression. */
2100 static void expr_unop(LexState
*ls
, ExpDesc
*v
)
2103 if (ls
->token
== TK_not
) {
2105 } else if (ls
->token
== '-') {
2107 } else if (ls
->token
== '#') {
2114 expr_binop(ls
, v
, UNARY_PRIORITY
);
2115 bcemit_unop(ls
->fs
, op
, v
);
2118 /* Parse binary expressions with priority higher than the limit. */
2119 static BinOpr
expr_binop(LexState
*ls
, ExpDesc
*v
, uint32_t limit
)
2124 op
= token2binop(ls
->token
);
2125 while (op
!= OPR_NOBINOPR
&& priority
[op
].left
> limit
) {
2129 bcemit_binop_left(ls
->fs
, op
, v
);
2130 /* Parse binary expression with higher priority. */
2131 nextop
= expr_binop(ls
, &v2
, priority
[op
].right
);
2132 bcemit_binop(ls
->fs
, op
, v
, &v2
);
2136 return op
; /* Return unconsumed binary operator (if any). */
2139 /* Parse expression. */
2140 static void expr(LexState
*ls
, ExpDesc
*v
)
2142 expr_binop(ls
, v
, 0); /* Priority 0: parse whole expression. */
2145 /* Assign expression to the next register. */
2146 static void expr_next(LexState
*ls
)
2150 expr_tonextreg(ls
->fs
, &e
);
2153 /* Parse conditional expression. */
2154 static BCPos
expr_cond(LexState
*ls
)
2158 if (v
.k
== VKNIL
) v
.k
= VKFALSE
;
2159 bcemit_branch_t(ls
->fs
, &v
);
2163 /* -- Assignments --------------------------------------------------------- */
2165 /* List of LHS variables. */
2166 typedef struct LHSVarList
{
2167 ExpDesc v
; /* LHS variable. */
2168 struct LHSVarList
*prev
; /* Link to previous LHS variable. */
2171 /* Eliminate write-after-read hazards for local variable assignment. */
2172 static void assign_hazard(LexState
*ls
, LHSVarList
*lh
, const ExpDesc
*v
)
2174 FuncState
*fs
= ls
->fs
;
2175 BCReg reg
= v
->u
.s
.info
; /* Check against this variable. */
2176 BCReg tmp
= fs
->freereg
; /* Rename to this temp. register (if needed). */
2178 for (; lh
; lh
= lh
->prev
) {
2179 if (lh
->v
.k
== VINDEXED
) {
2180 if (lh
->v
.u
.s
.info
== reg
) { /* t[i], t = 1, 2 */
2182 lh
->v
.u
.s
.info
= tmp
;
2184 if (lh
->v
.u
.s
.aux
== reg
) { /* t[i], i = 1, 2 */
2186 lh
->v
.u
.s
.aux
= tmp
;
2191 bcemit_AD(fs
, BC_MOV
, tmp
, reg
); /* Rename conflicting variable. */
2192 bcreg_reserve(fs
, 1);
2196 /* Adjust LHS/RHS of an assignment. */
2197 static void assign_adjust(LexState
*ls
, BCReg nvars
, BCReg nexps
, ExpDesc
*e
)
2199 FuncState
*fs
= ls
->fs
;
2200 int32_t extra
= (int32_t)nvars
- (int32_t)nexps
;
2201 if (e
->k
== VCALL
) {
2202 extra
++; /* Compensate for the VCALL itself. */
2203 if (extra
< 0) extra
= 0;
2204 setbc_b(bcptr(fs
, e
), extra
+1); /* Fixup call results. */
2205 if (extra
> 1) bcreg_reserve(fs
, (BCReg
)extra
-1);
2208 expr_tonextreg(fs
, e
); /* Close last expression. */
2209 if (extra
> 0) { /* Leftover LHS are set to nil. */
2210 BCReg reg
= fs
->freereg
;
2211 bcreg_reserve(fs
, (BCReg
)extra
);
2212 bcemit_nil(fs
, reg
, (BCReg
)extra
);
2216 ls
->fs
->freereg
-= nexps
- nvars
; /* Drop leftover regs. */
2219 /* Recursively parse assignment statement. */
2220 static void parse_assignment(LexState
*ls
, LHSVarList
*lh
, BCReg nvars
)
2223 checkcond(ls
, VLOCAL
<= lh
->v
.k
&& lh
->v
.k
<= VINDEXED
, LJ_ERR_XSYNTAX
);
2224 if (lex_opt(ls
, ',')) { /* Collect LHS list and recurse upwards. */
2227 expr_primary(ls
, &vl
.v
);
2228 if (vl
.v
.k
== VLOCAL
)
2229 assign_hazard(ls
, lh
, &vl
.v
);
2230 checklimit(ls
->fs
, ls
->level
+ nvars
, LJ_MAX_XLEVEL
, "variable names");
2231 parse_assignment(ls
, &vl
, nvars
+1);
2232 } else { /* Parse RHS. */
2235 nexps
= expr_list(ls
, &e
);
2236 if (nexps
== nvars
) {
2238 if (bc_op(*bcptr(ls
->fs
, &e
)) == BC_VARG
) { /* Vararg assignment. */
2241 } else { /* Multiple call results. */
2242 e
.u
.s
.info
= e
.u
.s
.aux
; /* Base of call is not relocatable. */
2246 bcemit_store(ls
->fs
, &lh
->v
, &e
);
2249 assign_adjust(ls
, nvars
, nexps
, &e
);
2251 /* Assign RHS to LHS and recurse downwards. */
2252 expr_init(&e
, VNONRELOC
, ls
->fs
->freereg
-1);
2253 bcemit_store(ls
->fs
, &lh
->v
, &e
);
2256 /* Parse call statement or assignment. */
2257 static void parse_call_assign(LexState
*ls
)
2259 FuncState
*fs
= ls
->fs
;
2261 expr_primary(ls
, &vl
.v
);
2262 if (vl
.v
.k
== VCALL
) { /* Function call statement. */
2263 setbc_b(bcptr(fs
, &vl
.v
), 1); /* No results. */
2264 } else { /* Start of an assignment. */
2266 parse_assignment(ls
, &vl
, 1);
2270 /* Parse 'local' statement. */
2271 static void parse_local(LexState
*ls
)
2273 if (lex_opt(ls
, TK_function
)) { /* Local function declaration. */
2275 FuncState
*fs
= ls
->fs
;
2276 var_new(ls
, 0, lex_str(ls
));
2277 expr_init(&v
, VLOCAL
, fs
->freereg
);
2278 v
.u
.s
.aux
= fs
->varmap
[fs
->freereg
];
2279 bcreg_reserve(fs
, 1);
2281 parse_body(ls
, &b
, 0, ls
->linenumber
);
2282 /* bcemit_store(fs, &v, &b) without setting VSTACK_VAR_RW. */
2284 expr_toreg(fs
, &b
, v
.u
.s
.info
);
2285 /* The upvalue is in scope, but the local is only valid after the store. */
2286 var_get(ls
, fs
, fs
->nactvar
- 1).startpc
= fs
->pc
;
2287 } else { /* Local variable declaration. */
2289 BCReg nexps
, nvars
= 0;
2290 do { /* Collect LHS. */
2291 var_new(ls
, nvars
++, lex_str(ls
));
2292 } while (lex_opt(ls
, ','));
2293 if (lex_opt(ls
, '=')) { /* Optional RHS. */
2294 nexps
= expr_list(ls
, &e
);
2295 } else { /* Or implicitly set to nil. */
2299 assign_adjust(ls
, nvars
, nexps
, &e
);
2304 /* Parse 'function' statement. */
2305 static void parse_func(LexState
*ls
, BCLine line
)
2310 lj_lex_next(ls
); /* Skip 'function'. */
2311 /* Parse function name. */
2313 while (ls
->token
== '.') /* Multiple dot-separated fields. */
2315 if (ls
->token
== ':') { /* Optional colon to signify method call. */
2319 parse_body(ls
, &b
, needself
, line
);
2321 bcemit_store(fs
, &v
, &b
);
2322 fs
->bcbase
[fs
->pc
- 1].line
= line
; /* Set line for the store. */
2325 /* -- Control transfer statements ----------------------------------------- */
2327 /* Check for end of block. */
2328 static int endofblock(LexToken token
)
2331 case TK_else
: case TK_elseif
: case TK_end
: case TK_until
: case TK_eof
:
2338 /* Parse 'return' statement. */
2339 static void parse_return(LexState
*ls
)
2342 FuncState
*fs
= ls
->fs
;
2343 lj_lex_next(ls
); /* Skip 'return'. */
2344 fs
->flags
|= PROTO_HAS_RETURN
;
2345 if (endofblock(ls
->token
) || ls
->token
== ';') { /* Bare return. */
2346 ins
= BCINS_AD(BC_RET0
, 0, 1);
2347 } else { /* Return with one or more values. */
2348 ExpDesc e
; /* Receives the _last_ expression in the list. */
2349 BCReg nret
= expr_list(ls
, &e
);
2350 if (nret
== 1) { /* Return one result. */
2351 if (e
.k
== VCALL
) { /* Check for tail call. */
2352 BCIns
*ip
= bcptr(fs
, &e
);
2353 /* It doesn't pay off to add BC_VARGT just for 'return ...'. */
2354 if (bc_op(*ip
) == BC_VARG
) goto notailcall
;
2356 ins
= BCINS_AD(bc_op(*ip
)-BC_CALL
+BC_CALLT
, bc_a(*ip
), bc_c(*ip
));
2357 } else { /* Can return the result from any register. */
2358 ins
= BCINS_AD(BC_RET1
, expr_toanyreg(fs
, &e
), 2);
2361 if (e
.k
== VCALL
) { /* Append all results from a call. */
2363 setbc_b(bcptr(fs
, &e
), 0);
2364 ins
= BCINS_AD(BC_RETM
, fs
->nactvar
, e
.u
.s
.aux
- fs
->nactvar
);
2366 expr_tonextreg(fs
, &e
); /* Force contiguous registers. */
2367 ins
= BCINS_AD(BC_RET
, fs
->nactvar
, nret
+1);
2371 if (fs
->flags
& PROTO_CHILD
)
2372 bcemit_AJ(fs
, BC_UCLO
, 0, 0); /* May need to close upvalues first. */
2373 bcemit_INS(fs
, ins
);
2376 /* Parse 'break' statement. */
2377 static void parse_break(LexState
*ls
)
2379 ls
->fs
->bl
->flags
|= FSCOPE_BREAK
;
2380 gola_new(ls
, NAME_BREAK
, VSTACK_GOTO
, bcemit_jmp(ls
->fs
));
2383 /* Parse 'goto' statement. */
2384 static void parse_goto(LexState
*ls
)
2386 FuncState
*fs
= ls
->fs
;
2387 GCstr
*name
= lex_str(ls
);
2388 VarInfo
*vl
= gola_findlabel(ls
, name
);
2389 if (vl
) /* Treat backwards goto within same scope like a loop. */
2390 bcemit_AJ(fs
, BC_LOOP
, vl
->slot
, -1); /* No BC range check. */
2391 fs
->bl
->flags
|= FSCOPE_GOLA
;
2392 gola_new(ls
, name
, VSTACK_GOTO
, bcemit_jmp(fs
));
2396 static void parse_label(LexState
*ls
)
2398 FuncState
*fs
= ls
->fs
;
2401 fs
->lasttarget
= fs
->pc
;
2402 fs
->bl
->flags
|= FSCOPE_GOLA
;
2403 lj_lex_next(ls
); /* Skip '::'. */
2405 if (gola_findlabel(ls
, name
))
2406 lj_lex_error(ls
, 0, LJ_ERR_XLDUP
, strdata(name
));
2407 idx
= gola_new(ls
, name
, VSTACK_LABEL
, fs
->pc
);
2408 lex_check(ls
, TK_label
);
2409 /* Recursively parse trailing statements: labels and ';' (Lua 5.2 only). */
2411 if (ls
->token
== TK_label
) {
2415 } else if (LJ_52
&& ls
->token
== ';') {
2421 /* Trailing label is considered to be outside of scope. */
2422 if (endofblock(ls
->token
) && ls
->token
!= TK_until
)
2423 ls
->vstack
[idx
].slot
= fs
->bl
->nactvar
;
2424 gola_resolve(ls
, fs
->bl
, idx
);
2427 /* -- Blocks, loops and conditional statements ---------------------------- */
2429 /* Parse a block. */
2430 static void parse_block(LexState
*ls
)
2432 FuncState
*fs
= ls
->fs
;
2434 fscope_begin(fs
, &bl
, 0);
2439 /* Parse 'while' statement. */
2440 static void parse_while(LexState
*ls
, BCLine line
)
2442 FuncState
*fs
= ls
->fs
;
2443 BCPos start
, loop
, condexit
;
2445 lj_lex_next(ls
); /* Skip 'while'. */
2446 start
= fs
->lasttarget
= fs
->pc
;
2447 condexit
= expr_cond(ls
);
2448 fscope_begin(fs
, &bl
, FSCOPE_LOOP
);
2449 lex_check(ls
, TK_do
);
2450 loop
= bcemit_AD(fs
, BC_LOOP
, fs
->nactvar
, 0);
2452 jmp_patch(fs
, bcemit_jmp(fs
), start
);
2453 lex_match(ls
, TK_end
, TK_while
, line
);
2455 jmp_tohere(fs
, condexit
);
2456 jmp_patchins(fs
, loop
, fs
->pc
);
2459 /* Parse 'repeat' statement. */
2460 static void parse_repeat(LexState
*ls
, BCLine line
)
2462 FuncState
*fs
= ls
->fs
;
2463 BCPos loop
= fs
->lasttarget
= fs
->pc
;
2466 fscope_begin(fs
, &bl1
, FSCOPE_LOOP
); /* Breakable loop scope. */
2467 fscope_begin(fs
, &bl2
, 0); /* Inner scope. */
2468 lj_lex_next(ls
); /* Skip 'repeat'. */
2469 bcemit_AD(fs
, BC_LOOP
, fs
->nactvar
, 0);
2471 lex_match(ls
, TK_until
, TK_repeat
, line
);
2472 condexit
= expr_cond(ls
); /* Parse condition (still inside inner scope). */
2473 if (!(bl2
.flags
& FSCOPE_UPVAL
)) { /* No upvalues? Just end inner scope. */
2475 } else { /* Otherwise generate: cond: UCLO+JMP out, !cond: UCLO+JMP loop. */
2476 parse_break(ls
); /* Break from loop and close upvalues. */
2477 jmp_tohere(fs
, condexit
);
2478 fscope_end(fs
); /* End inner scope and close upvalues. */
2479 condexit
= bcemit_jmp(fs
);
2481 jmp_patch(fs
, condexit
, loop
); /* Jump backwards if !cond. */
2482 jmp_patchins(fs
, loop
, fs
->pc
);
2483 fscope_end(fs
); /* End loop scope. */
2486 /* Parse numeric 'for'. */
2487 static void parse_for_num(LexState
*ls
, GCstr
*varname
, BCLine line
)
2489 FuncState
*fs
= ls
->fs
;
2490 BCReg base
= fs
->freereg
;
2492 BCPos loop
, loopend
;
2493 /* Hidden control variables. */
2494 var_new_fixed(ls
, FORL_IDX
, VARNAME_FOR_IDX
);
2495 var_new_fixed(ls
, FORL_STOP
, VARNAME_FOR_STOP
);
2496 var_new_fixed(ls
, FORL_STEP
, VARNAME_FOR_STEP
);
2497 /* Visible copy of index variable. */
2498 var_new(ls
, FORL_EXT
, varname
);
2503 if (lex_opt(ls
, ',')) {
2506 bcemit_AD(fs
, BC_KSHORT
, fs
->freereg
, 1); /* Default step is 1. */
2507 bcreg_reserve(fs
, 1);
2509 var_add(ls
, 3); /* Hidden control variables. */
2510 lex_check(ls
, TK_do
);
2511 loop
= bcemit_AJ(fs
, BC_FORI
, base
, NO_JMP
);
2512 fscope_begin(fs
, &bl
, 0); /* Scope for visible variables. */
2514 bcreg_reserve(fs
, 1);
2517 /* Perform loop inversion. Loop control instructions are at the end. */
2518 loopend
= bcemit_AJ(fs
, BC_FORL
, base
, NO_JMP
);
2519 fs
->bcbase
[loopend
].line
= line
; /* Fix line for control ins. */
2520 jmp_patchins(fs
, loopend
, loop
+1);
2521 jmp_patchins(fs
, loop
, fs
->pc
);
2524 /* Try to predict whether the iterator is next() and specialize the bytecode.
2525 ** Detecting next() and pairs() by name is simplistic, but quite effective.
2526 ** The interpreter backs off if the check for the closure fails at runtime.
2528 static int predict_next(LexState
*ls
, FuncState
*fs
, BCPos pc
)
2533 if (pc
>= fs
->bclim
) return 0;
2534 ins
= fs
->bcbase
[pc
].ins
;
2535 switch (bc_op(ins
)) {
2537 if (bc_d(ins
) >= fs
->nactvar
) return 0;
2538 name
= gco2str(gcref(var_get(ls
, fs
, bc_d(ins
)).name
));
2541 name
= gco2str(gcref(ls
->vstack
[fs
->uvmap
[bc_d(ins
)]].name
));
2544 /* There's no inverse index (yet), so lookup the strings. */
2545 o
= lj_tab_getstr(fs
->kt
, lj_str_newlit(ls
->L
, "pairs"));
2546 if (o
&& tvhaskslot(o
) && tvkslot(o
) == bc_d(ins
))
2548 o
= lj_tab_getstr(fs
->kt
, lj_str_newlit(ls
->L
, "next"));
2549 if (o
&& tvhaskslot(o
) && tvkslot(o
) == bc_d(ins
))
2555 return (name
->len
== 5 && !strcmp(strdata(name
), "pairs")) ||
2556 (name
->len
== 4 && !strcmp(strdata(name
), "next"));
2559 /* Parse 'for' iterator. */
2560 static void parse_for_iter(LexState
*ls
, GCstr
*indexname
)
2562 FuncState
*fs
= ls
->fs
;
2566 BCReg base
= fs
->freereg
+ 3;
2567 BCPos loop
, loopend
, exprpc
= fs
->pc
;
2570 /* Hidden control variables. */
2571 var_new_fixed(ls
, nvars
++, VARNAME_FOR_GEN
);
2572 var_new_fixed(ls
, nvars
++, VARNAME_FOR_STATE
);
2573 var_new_fixed(ls
, nvars
++, VARNAME_FOR_CTL
);
2574 /* Visible variables returned from iterator. */
2575 var_new(ls
, nvars
++, indexname
);
2576 while (lex_opt(ls
, ','))
2577 var_new(ls
, nvars
++, lex_str(ls
));
2578 lex_check(ls
, TK_in
);
2579 line
= ls
->linenumber
;
2580 assign_adjust(ls
, 3, expr_list(ls
, &e
), &e
);
2581 bcreg_bump(fs
, 3); /* The iterator needs another 3 slots (func + 2 args). */
2582 isnext
= (nvars
<= 5 && predict_next(ls
, fs
, exprpc
));
2583 var_add(ls
, 3); /* Hidden control variables. */
2584 lex_check(ls
, TK_do
);
2585 loop
= bcemit_AJ(fs
, isnext
? BC_ISNEXT
: BC_JMP
, base
, NO_JMP
);
2586 fscope_begin(fs
, &bl
, 0); /* Scope for visible variables. */
2587 var_add(ls
, nvars
-3);
2588 bcreg_reserve(fs
, nvars
-3);
2591 /* Perform loop inversion. Loop control instructions are at the end. */
2592 jmp_patchins(fs
, loop
, fs
->pc
);
2593 bcemit_ABC(fs
, isnext
? BC_ITERN
: BC_ITERC
, base
, nvars
-3+1, 2+1);
2594 loopend
= bcemit_AJ(fs
, BC_ITERL
, base
, NO_JMP
);
2595 fs
->bcbase
[loopend
-1].line
= line
; /* Fix line for control ins. */
2596 fs
->bcbase
[loopend
].line
= line
;
2597 jmp_patchins(fs
, loopend
, loop
+1);
2600 /* Parse 'for' statement. */
2601 static void parse_for(LexState
*ls
, BCLine line
)
2603 FuncState
*fs
= ls
->fs
;
2606 fscope_begin(fs
, &bl
, FSCOPE_LOOP
);
2607 lj_lex_next(ls
); /* Skip 'for'. */
2608 varname
= lex_str(ls
); /* Get first variable name. */
2609 if (ls
->token
== '=')
2610 parse_for_num(ls
, varname
, line
);
2611 else if (ls
->token
== ',' || ls
->token
== TK_in
)
2612 parse_for_iter(ls
, varname
);
2614 err_syntax(ls
, LJ_ERR_XFOR
);
2615 lex_match(ls
, TK_end
, TK_for
, line
);
2616 fscope_end(fs
); /* Resolve break list. */
2619 /* Parse condition and 'then' block. */
2620 static BCPos
parse_then(LexState
*ls
)
2623 lj_lex_next(ls
); /* Skip 'if' or 'elseif'. */
2624 condexit
= expr_cond(ls
);
2625 lex_check(ls
, TK_then
);
2630 /* Parse 'if' statement. */
2631 static void parse_if(LexState
*ls
, BCLine line
)
2633 FuncState
*fs
= ls
->fs
;
2635 BCPos escapelist
= NO_JMP
;
2636 flist
= parse_then(ls
);
2637 while (ls
->token
== TK_elseif
) { /* Parse multiple 'elseif' blocks. */
2638 jmp_append(fs
, &escapelist
, bcemit_jmp(fs
));
2639 jmp_tohere(fs
, flist
);
2640 flist
= parse_then(ls
);
2642 if (ls
->token
== TK_else
) { /* Parse optional 'else' block. */
2643 jmp_append(fs
, &escapelist
, bcemit_jmp(fs
));
2644 jmp_tohere(fs
, flist
);
2645 lj_lex_next(ls
); /* Skip 'else'. */
2648 jmp_append(fs
, &escapelist
, flist
);
2650 jmp_tohere(fs
, escapelist
);
2651 lex_match(ls
, TK_end
, TK_if
, line
);
2654 /* -- Parse statements ---------------------------------------------------- */
2656 /* Parse a statement. Returns 1 if it must be the last one in a chunk. */
2657 static int parse_stmt(LexState
*ls
)
2659 BCLine line
= ls
->linenumber
;
2660 switch (ls
->token
) {
2665 parse_while(ls
, line
);
2670 lex_match(ls
, TK_end
, TK_do
, line
);
2673 parse_for(ls
, line
);
2676 parse_repeat(ls
, line
);
2679 parse_func(ls
, line
);
2687 return 1; /* Must be last. */
2691 return !LJ_52
; /* Must be last in Lua 5.1. */
2701 if (LJ_52
|| lj_lex_lookahead(ls
) == TK_name
) {
2708 parse_call_assign(ls
);
2714 /* A chunk is a list of statements optionally separated by semicolons. */
2715 static void parse_chunk(LexState
*ls
)
2719 while (!islast
&& !endofblock(ls
->token
)) {
2720 islast
= parse_stmt(ls
);
2722 lua_assert(ls
->fs
->framesize
>= ls
->fs
->freereg
&&
2723 ls
->fs
->freereg
>= ls
->fs
->nactvar
);
2724 ls
->fs
->freereg
= ls
->fs
->nactvar
; /* Free registers after each stmt. */
2729 /* Entry point of bytecode parser. */
2730 GCproto
*lj_parse(LexState
*ls
)
2735 lua_State
*L
= ls
->L
;
2736 #ifdef LUAJIT_DISABLE_DEBUGINFO
2737 ls
->chunkname
= lj_str_newlit(L
, "=");
2739 ls
->chunkname
= lj_str_newz(L
, ls
->chunkarg
);
2741 setstrV(L
, L
->top
, ls
->chunkname
); /* Anchor chunkname string. */
2749 fs
.flags
|= PROTO_VARARG
; /* Main chunk is always a vararg func. */
2750 fscope_begin(&fs
, &bl
, 0);
2751 bcemit_AD(&fs
, BC_FUNCV
, 0, 0); /* Placeholder. */
2752 lj_lex_next(ls
); /* Read-ahead first token. */
2754 if (ls
->token
!= TK_eof
)
2755 err_token(ls
, TK_eof
);
2756 pt
= fs_finish(ls
, ls
->linenumber
);
2757 L
->top
--; /* Drop chunkname. */
2758 lua_assert(fs
.prev
== NULL
);
2759 lua_assert(ls
->fs
== NULL
);
2760 lua_assert(pt
->sizeuv
== 0);