1 | /* |
2 | ** $Id: lcode.c $ |
3 | ** Code generator for Lua |
4 | ** See Copyright Notice in lua.h |
5 | */ |
6 | |
7 | #define lcode_c |
8 | #define LUA_CORE |
9 | |
10 | #include "lprefix.h" |
11 | |
12 | |
13 | #include <float.h> |
14 | #include <limits.h> |
15 | #include <math.h> |
16 | #include <stdlib.h> |
17 | |
18 | #include "lua.h" |
19 | |
20 | #include "lcode.h" |
21 | #include "ldebug.h" |
22 | #include "ldo.h" |
23 | #include "lgc.h" |
24 | #include "llex.h" |
25 | #include "lmem.h" |
26 | #include "lobject.h" |
27 | #include "lopcodes.h" |
28 | #include "lparser.h" |
29 | #include "lstring.h" |
30 | #include "ltable.h" |
31 | #include "lvm.h" |
32 | |
33 | |
34 | /* Maximum number of registers in a Lua function (must fit in 8 bits) */ |
35 | #define MAXREGS 255 |
36 | |
37 | |
38 | #define hasjumps(e) ((e)->t != (e)->f) |
39 | |
40 | |
41 | static int codesJ (FuncState *fs, OpCode o, int sj, int k); |
42 | |
43 | |
44 | |
45 | /* semantic error */ |
46 | l_noret luaK_semerror (LexState *ls, const char *msg) { |
47 | ls->t.token = 0; /* remove "near <token>" from final message */ |
48 | luaX_syntaxerror(ls, msg); |
49 | } |
50 | |
51 | |
52 | /* |
53 | ** If expression is a numeric constant, fills 'v' with its value |
54 | ** and returns 1. Otherwise, returns 0. |
55 | */ |
56 | static int tonumeral (const expdesc *e, TValue *v) { |
57 | if (hasjumps(e)) |
58 | return 0; /* not a numeral */ |
59 | switch (e->k) { |
60 | case VKINT: |
61 | if (v) setivalue(v, e->u.ival); |
62 | return 1; |
63 | case VKFLT: |
64 | if (v) setfltvalue(v, e->u.nval); |
65 | return 1; |
66 | default: return 0; |
67 | } |
68 | } |
69 | |
70 | |
71 | /* |
72 | ** Get the constant value from a constant expression |
73 | */ |
74 | static TValue *const2val (FuncState *fs, const expdesc *e) { |
75 | lua_assert(e->k == VCONST); |
76 | return &fs->ls->dyd->actvar.arr[e->u.info].k; |
77 | } |
78 | |
79 | |
80 | /* |
81 | ** If expression is a constant, fills 'v' with its value |
82 | ** and returns 1. Otherwise, returns 0. |
83 | */ |
84 | int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { |
85 | if (hasjumps(e)) |
86 | return 0; /* not a constant */ |
87 | switch (e->k) { |
88 | case VFALSE: |
89 | setbfvalue(v); |
90 | return 1; |
91 | case VTRUE: |
92 | setbtvalue(v); |
93 | return 1; |
94 | case VNIL: |
95 | setnilvalue(v); |
96 | return 1; |
97 | case VKSTR: { |
98 | setsvalue(fs->ls->L, v, e->u.strval); |
99 | return 1; |
100 | } |
101 | case VCONST: { |
102 | setobj(fs->ls->L, v, const2val(fs, e)); |
103 | return 1; |
104 | } |
105 | default: return tonumeral(e, v); |
106 | } |
107 | } |
108 | |
109 | |
110 | /* |
111 | ** Return the previous instruction of the current code. If there |
112 | ** may be a jump target between the current instruction and the |
113 | ** previous one, return an invalid instruction (to avoid wrong |
114 | ** optimizations). |
115 | */ |
116 | static Instruction *previousinstruction (FuncState *fs) { |
117 | static const Instruction invalidinstruction = ~(Instruction)0; |
118 | if (fs->pc > fs->lasttarget) |
119 | return &fs->f->code[fs->pc - 1]; /* previous instruction */ |
120 | else |
121 | return cast(Instruction*, &invalidinstruction); |
122 | } |
123 | |
124 | |
125 | /* |
126 | ** Create a OP_LOADNIL instruction, but try to optimize: if the previous |
127 | ** instruction is also OP_LOADNIL and ranges are compatible, adjust |
128 | ** range of previous instruction instead of emitting a new one. (For |
129 | ** instance, 'local a; local b' will generate a single opcode.) |
130 | */ |
131 | void luaK_nil (FuncState *fs, int from, int n) { |
132 | int l = from + n - 1; /* last register to set nil */ |
133 | Instruction *previous = previousinstruction(fs); |
134 | if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ |
135 | int pfrom = GETARG_A(*previous); /* get previous range */ |
136 | int pl = pfrom + GETARG_B(*previous); |
137 | if ((pfrom <= from && from <= pl + 1) || |
138 | (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ |
139 | if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ |
140 | if (pl > l) l = pl; /* l = max(l, pl) */ |
141 | SETARG_A(*previous, from); |
142 | SETARG_B(*previous, l - from); |
143 | return; |
144 | } /* else go through */ |
145 | } |
146 | luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0); /* else no optimization */ |
147 | } |
148 | |
149 | |
150 | /* |
151 | ** Gets the destination address of a jump instruction. Used to traverse |
152 | ** a list of jumps. |
153 | */ |
154 | static int getjump (FuncState *fs, int pc) { |
155 | int offset = GETARG_sJ(fs->f->code[pc]); |
156 | if (offset == NO_JUMP) /* point to itself represents end of list */ |
157 | return NO_JUMP; /* end of list */ |
158 | else |
159 | return (pc+1)+offset; /* turn offset into absolute position */ |
160 | } |
161 | |
162 | |
163 | /* |
164 | ** Fix jump instruction at position 'pc' to jump to 'dest'. |
165 | ** (Jump addresses are relative in Lua) |
166 | */ |
167 | static void fixjump (FuncState *fs, int pc, int dest) { |
168 | Instruction *jmp = &fs->f->code[pc]; |
169 | int offset = dest - (pc + 1); |
170 | lua_assert(dest != NO_JUMP); |
171 | if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) |
172 | luaX_syntaxerror(fs->ls, "control structure too long" ); |
173 | lua_assert(GET_OPCODE(*jmp) == OP_JMP); |
174 | SETARG_sJ(*jmp, offset); |
175 | } |
176 | |
177 | |
178 | /* |
179 | ** Concatenate jump-list 'l2' into jump-list 'l1' |
180 | */ |
181 | void luaK_concat (FuncState *fs, int *l1, int l2) { |
182 | if (l2 == NO_JUMP) return; /* nothing to concatenate? */ |
183 | else if (*l1 == NO_JUMP) /* no original list? */ |
184 | *l1 = l2; /* 'l1' points to 'l2' */ |
185 | else { |
186 | int list = *l1; |
187 | int next; |
188 | while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ |
189 | list = next; |
190 | fixjump(fs, list, l2); /* last element links to 'l2' */ |
191 | } |
192 | } |
193 | |
194 | |
195 | /* |
196 | ** Create a jump instruction and return its position, so its destination |
197 | ** can be fixed later (with 'fixjump'). |
198 | */ |
199 | int luaK_jump (FuncState *fs) { |
200 | return codesJ(fs, OP_JMP, NO_JUMP, 0); |
201 | } |
202 | |
203 | |
204 | /* |
205 | ** Code a 'return' instruction |
206 | */ |
207 | void luaK_ret (FuncState *fs, int first, int nret) { |
208 | OpCode op; |
209 | switch (nret) { |
210 | case 0: op = OP_RETURN0; break; |
211 | case 1: op = OP_RETURN1; break; |
212 | default: op = OP_RETURN; break; |
213 | } |
214 | luaK_codeABC(fs, op, first, nret + 1, 0); |
215 | } |
216 | |
217 | |
218 | /* |
219 | ** Code a "conditional jump", that is, a test or comparison opcode |
220 | ** followed by a jump. Return jump position. |
221 | */ |
222 | static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { |
223 | luaK_codeABCk(fs, op, A, B, C, k); |
224 | return luaK_jump(fs); |
225 | } |
226 | |
227 | |
228 | /* |
229 | ** returns current 'pc' and marks it as a jump target (to avoid wrong |
230 | ** optimizations with consecutive instructions not in the same basic block). |
231 | */ |
232 | int luaK_getlabel (FuncState *fs) { |
233 | fs->lasttarget = fs->pc; |
234 | return fs->pc; |
235 | } |
236 | |
237 | |
238 | /* |
239 | ** Returns the position of the instruction "controlling" a given |
240 | ** jump (that is, its condition), or the jump itself if it is |
241 | ** unconditional. |
242 | */ |
243 | static Instruction *getjumpcontrol (FuncState *fs, int pc) { |
244 | Instruction *pi = &fs->f->code[pc]; |
245 | if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) |
246 | return pi-1; |
247 | else |
248 | return pi; |
249 | } |
250 | |
251 | |
252 | /* |
253 | ** Patch destination register for a TESTSET instruction. |
254 | ** If instruction in position 'node' is not a TESTSET, return 0 ("fails"). |
255 | ** Otherwise, if 'reg' is not 'NO_REG', set it as the destination |
256 | ** register. Otherwise, change instruction to a simple 'TEST' (produces |
257 | ** no register value) |
258 | */ |
259 | static int patchtestreg (FuncState *fs, int node, int reg) { |
260 | Instruction *i = getjumpcontrol(fs, node); |
261 | if (GET_OPCODE(*i) != OP_TESTSET) |
262 | return 0; /* cannot patch other instructions */ |
263 | if (reg != NO_REG && reg != GETARG_B(*i)) |
264 | SETARG_A(*i, reg); |
265 | else { |
266 | /* no register to put value or register already has the value; |
267 | change instruction to simple test */ |
268 | *i = CREATE_ABCk(OP_TEST, GETARG_B(*i), 0, 0, GETARG_k(*i)); |
269 | } |
270 | return 1; |
271 | } |
272 | |
273 | |
274 | /* |
275 | ** Traverse a list of tests ensuring no one produces a value |
276 | */ |
277 | static void removevalues (FuncState *fs, int list) { |
278 | for (; list != NO_JUMP; list = getjump(fs, list)) |
279 | patchtestreg(fs, list, NO_REG); |
280 | } |
281 | |
282 | |
283 | /* |
284 | ** Traverse a list of tests, patching their destination address and |
285 | ** registers: tests producing values jump to 'vtarget' (and put their |
286 | ** values in 'reg'), other tests jump to 'dtarget'. |
287 | */ |
288 | static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, |
289 | int dtarget) { |
290 | while (list != NO_JUMP) { |
291 | int next = getjump(fs, list); |
292 | if (patchtestreg(fs, list, reg)) |
293 | fixjump(fs, list, vtarget); |
294 | else |
295 | fixjump(fs, list, dtarget); /* jump to default target */ |
296 | list = next; |
297 | } |
298 | } |
299 | |
300 | |
301 | /* |
302 | ** Path all jumps in 'list' to jump to 'target'. |
303 | ** (The assert means that we cannot fix a jump to a forward address |
304 | ** because we only know addresses once code is generated.) |
305 | */ |
306 | void luaK_patchlist (FuncState *fs, int list, int target) { |
307 | lua_assert(target <= fs->pc); |
308 | patchlistaux(fs, list, target, NO_REG, target); |
309 | } |
310 | |
311 | |
312 | void luaK_patchtohere (FuncState *fs, int list) { |
313 | int hr = luaK_getlabel(fs); /* mark "here" as a jump target */ |
314 | luaK_patchlist(fs, list, hr); |
315 | } |
316 | |
317 | |
318 | /* limit for difference between lines in relative line info. */ |
319 | #define LIMLINEDIFF 0x80 |
320 | |
321 | |
322 | /* |
323 | ** Save line info for a new instruction. If difference from last line |
324 | ** does not fit in a byte, of after that many instructions, save a new |
325 | ** absolute line info; (in that case, the special value 'ABSLINEINFO' |
326 | ** in 'lineinfo' signals the existence of this absolute information.) |
327 | ** Otherwise, store the difference from last line in 'lineinfo'. |
328 | */ |
329 | static void savelineinfo (FuncState *fs, Proto *f, int line) { |
330 | int linedif = line - fs->previousline; |
331 | int pc = fs->pc - 1; /* last instruction coded */ |
332 | if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { |
333 | luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, |
334 | f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines" ); |
335 | f->abslineinfo[fs->nabslineinfo].pc = pc; |
336 | f->abslineinfo[fs->nabslineinfo++].line = line; |
337 | linedif = ABSLINEINFO; /* signal that there is absolute information */ |
338 | fs->iwthabs = 1; /* restart counter */ |
339 | } |
340 | luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, |
341 | MAX_INT, "opcodes" ); |
342 | f->lineinfo[pc] = linedif; |
343 | fs->previousline = line; /* last line saved */ |
344 | } |
345 | |
346 | |
347 | /* |
348 | ** Remove line information from the last instruction. |
349 | ** If line information for that instruction is absolute, set 'iwthabs' |
350 | ** above its max to force the new (replacing) instruction to have |
351 | ** absolute line info, too. |
352 | */ |
353 | static void removelastlineinfo (FuncState *fs) { |
354 | Proto *f = fs->f; |
355 | int pc = fs->pc - 1; /* last instruction coded */ |
356 | if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ |
357 | fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ |
358 | fs->iwthabs--; /* undo previous increment */ |
359 | } |
360 | else { /* absolute line information */ |
361 | lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); |
362 | fs->nabslineinfo--; /* remove it */ |
363 | fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ |
364 | } |
365 | } |
366 | |
367 | |
368 | /* |
369 | ** Remove the last instruction created, correcting line information |
370 | ** accordingly. |
371 | */ |
372 | static void removelastinstruction (FuncState *fs) { |
373 | removelastlineinfo(fs); |
374 | fs->pc--; |
375 | } |
376 | |
377 | |
378 | /* |
379 | ** Emit instruction 'i', checking for array sizes and saving also its |
380 | ** line information. Return 'i' position. |
381 | */ |
382 | int luaK_code (FuncState *fs, Instruction i) { |
383 | Proto *f = fs->f; |
384 | /* put new instruction in code array */ |
385 | luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, |
386 | MAX_INT, "opcodes" ); |
387 | f->code[fs->pc++] = i; |
388 | savelineinfo(fs, f, fs->ls->lastline); |
389 | return fs->pc - 1; /* index of new instruction */ |
390 | } |
391 | |
392 | |
393 | /* |
394 | ** Format and emit an 'iABC' instruction. (Assertions check consistency |
395 | ** of parameters versus opcode.) |
396 | */ |
397 | int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { |
398 | lua_assert(getOpMode(o) == iABC); |
399 | lua_assert(a <= MAXARG_A && b <= MAXARG_B && |
400 | c <= MAXARG_C && (k & ~1) == 0); |
401 | return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); |
402 | } |
403 | |
404 | |
405 | /* |
406 | ** Format and emit an 'iABx' instruction. |
407 | */ |
408 | int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) { |
409 | lua_assert(getOpMode(o) == iABx); |
410 | lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx); |
411 | return luaK_code(fs, CREATE_ABx(o, a, bc)); |
412 | } |
413 | |
414 | |
415 | /* |
416 | ** Format and emit an 'iAsBx' instruction. |
417 | */ |
418 | int luaK_codeAsBx (FuncState *fs, OpCode o, int a, int bc) { |
419 | unsigned int b = bc + OFFSET_sBx; |
420 | lua_assert(getOpMode(o) == iAsBx); |
421 | lua_assert(a <= MAXARG_A && b <= MAXARG_Bx); |
422 | return luaK_code(fs, CREATE_ABx(o, a, b)); |
423 | } |
424 | |
425 | |
426 | /* |
427 | ** Format and emit an 'isJ' instruction. |
428 | */ |
429 | static int codesJ (FuncState *fs, OpCode o, int sj, int k) { |
430 | unsigned int j = sj + OFFSET_sJ; |
431 | lua_assert(getOpMode(o) == isJ); |
432 | lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); |
433 | return luaK_code(fs, CREATE_sJ(o, j, k)); |
434 | } |
435 | |
436 | |
437 | /* |
438 | ** Emit an "extra argument" instruction (format 'iAx') |
439 | */ |
440 | static int (FuncState *fs, int a) { |
441 | lua_assert(a <= MAXARG_Ax); |
442 | return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a)); |
443 | } |
444 | |
445 | |
446 | /* |
447 | ** Emit a "load constant" instruction, using either 'OP_LOADK' |
448 | ** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX' |
449 | ** instruction with "extra argument". |
450 | */ |
451 | static int luaK_codek (FuncState *fs, int reg, int k) { |
452 | if (k <= MAXARG_Bx) |
453 | return luaK_codeABx(fs, OP_LOADK, reg, k); |
454 | else { |
455 | int p = luaK_codeABx(fs, OP_LOADKX, reg, 0); |
456 | codeextraarg(fs, k); |
457 | return p; |
458 | } |
459 | } |
460 | |
461 | |
462 | /* |
463 | ** Check register-stack level, keeping track of its maximum size |
464 | ** in field 'maxstacksize' |
465 | */ |
466 | void luaK_checkstack (FuncState *fs, int n) { |
467 | int newstack = fs->freereg + n; |
468 | if (newstack > fs->f->maxstacksize) { |
469 | if (newstack >= MAXREGS) |
470 | luaX_syntaxerror(fs->ls, |
471 | "function or expression needs too many registers" ); |
472 | fs->f->maxstacksize = cast_byte(newstack); |
473 | } |
474 | } |
475 | |
476 | |
477 | /* |
478 | ** Reserve 'n' registers in register stack |
479 | */ |
480 | void luaK_reserveregs (FuncState *fs, int n) { |
481 | luaK_checkstack(fs, n); |
482 | fs->freereg += n; |
483 | } |
484 | |
485 | |
486 | /* |
487 | ** Free register 'reg', if it is neither a constant index nor |
488 | ** a local variable. |
489 | ) |
490 | */ |
491 | static void freereg (FuncState *fs, int reg) { |
492 | if (reg >= luaY_nvarstack(fs)) { |
493 | fs->freereg--; |
494 | lua_assert(reg == fs->freereg); |
495 | } |
496 | } |
497 | |
498 | |
499 | /* |
500 | ** Free two registers in proper order |
501 | */ |
502 | static void freeregs (FuncState *fs, int r1, int r2) { |
503 | if (r1 > r2) { |
504 | freereg(fs, r1); |
505 | freereg(fs, r2); |
506 | } |
507 | else { |
508 | freereg(fs, r2); |
509 | freereg(fs, r1); |
510 | } |
511 | } |
512 | |
513 | |
514 | /* |
515 | ** Free register used by expression 'e' (if any) |
516 | */ |
517 | static void freeexp (FuncState *fs, expdesc *e) { |
518 | if (e->k == VNONRELOC) |
519 | freereg(fs, e->u.info); |
520 | } |
521 | |
522 | |
523 | /* |
524 | ** Free registers used by expressions 'e1' and 'e2' (if any) in proper |
525 | ** order. |
526 | */ |
527 | static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { |
528 | int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; |
529 | int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; |
530 | freeregs(fs, r1, r2); |
531 | } |
532 | |
533 | |
534 | /* |
535 | ** Add constant 'v' to prototype's list of constants (field 'k'). |
536 | ** Use scanner's table to cache position of constants in constant list |
537 | ** and try to reuse constants. Because some values should not be used |
538 | ** as keys (nil cannot be a key, integer keys can collapse with float |
539 | ** keys), the caller must provide a useful 'key' for indexing the cache. |
540 | ** Note that all functions share the same table, so entering or exiting |
541 | ** a function can make some indices wrong. |
542 | */ |
543 | static int addk (FuncState *fs, TValue *key, TValue *v) { |
544 | TValue val; |
545 | lua_State *L = fs->ls->L; |
546 | Proto *f = fs->f; |
547 | const TValue *idx = luaH_get(fs->ls->h, key); /* query scanner table */ |
548 | int k, oldsize; |
549 | if (ttisinteger(idx)) { /* is there an index there? */ |
550 | k = cast_int(ivalue(idx)); |
551 | /* correct value? (warning: must distinguish floats from integers!) */ |
552 | if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && |
553 | luaV_rawequalobj(&f->k[k], v)) |
554 | return k; /* reuse index */ |
555 | } |
556 | /* constant not found; create a new entry */ |
557 | oldsize = f->sizek; |
558 | k = fs->nk; |
559 | /* numerical value does not need GC barrier; |
560 | table has no metatable, so it does not need to invalidate cache */ |
561 | setivalue(&val, k); |
562 | luaH_finishset(L, fs->ls->h, key, idx, &val); |
563 | luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants" ); |
564 | while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); |
565 | setobj(L, &f->k[k], v); |
566 | fs->nk++; |
567 | luaC_barrier(L, f, v); |
568 | return k; |
569 | } |
570 | |
571 | |
572 | /* |
573 | ** Add a string to list of constants and return its index. |
574 | */ |
575 | static int stringK (FuncState *fs, TString *s) { |
576 | TValue o; |
577 | setsvalue(fs->ls->L, &o, s); |
578 | return addk(fs, &o, &o); /* use string itself as key */ |
579 | } |
580 | |
581 | |
582 | /* |
583 | ** Add an integer to list of constants and return its index. |
584 | */ |
585 | static int luaK_intK (FuncState *fs, lua_Integer n) { |
586 | TValue o; |
587 | setivalue(&o, n); |
588 | return addk(fs, &o, &o); /* use integer itself as key */ |
589 | } |
590 | |
591 | /* |
592 | ** Add a float to list of constants and return its index. Floats |
593 | ** with integral values need a different key, to avoid collision |
594 | ** with actual integers. To that, we add to the number its smaller |
595 | ** power-of-two fraction that is still significant in its scale. |
596 | ** For doubles, that would be 1/2^52. |
597 | ** (This method is not bulletproof: there may be another float |
598 | ** with that value, and for floats larger than 2^53 the result is |
599 | ** still an integer. At worst, this only wastes an entry with |
600 | ** a duplicate.) |
601 | */ |
602 | static int luaK_numberK (FuncState *fs, lua_Number r) { |
603 | TValue o; |
604 | lua_Integer ik; |
605 | setfltvalue(&o, r); |
606 | if (!luaV_flttointeger(r, &ik, F2Ieq)) /* not an integral value? */ |
607 | return addk(fs, &o, &o); /* use number itself as key */ |
608 | else { /* must build an alternative key */ |
609 | const int nbm = l_floatatt(MANT_DIG); |
610 | const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); |
611 | const lua_Number k = (ik == 0) ? q : r + r*q; /* new key */ |
612 | TValue kv; |
613 | setfltvalue(&kv, k); |
614 | /* result is not an integral value, unless value is too large */ |
615 | lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) || |
616 | l_mathop(fabs)(r) >= l_mathop(1e6)); |
617 | return addk(fs, &kv, &o); |
618 | } |
619 | } |
620 | |
621 | |
622 | /* |
623 | ** Add a false to list of constants and return its index. |
624 | */ |
625 | static int boolF (FuncState *fs) { |
626 | TValue o; |
627 | setbfvalue(&o); |
628 | return addk(fs, &o, &o); /* use boolean itself as key */ |
629 | } |
630 | |
631 | |
632 | /* |
633 | ** Add a true to list of constants and return its index. |
634 | */ |
635 | static int boolT (FuncState *fs) { |
636 | TValue o; |
637 | setbtvalue(&o); |
638 | return addk(fs, &o, &o); /* use boolean itself as key */ |
639 | } |
640 | |
641 | |
642 | /* |
643 | ** Add nil to list of constants and return its index. |
644 | */ |
645 | static int nilK (FuncState *fs) { |
646 | TValue k, v; |
647 | setnilvalue(&v); |
648 | /* cannot use nil as key; instead use table itself to represent nil */ |
649 | sethvalue(fs->ls->L, &k, fs->ls->h); |
650 | return addk(fs, &k, &v); |
651 | } |
652 | |
653 | |
654 | /* |
655 | ** Check whether 'i' can be stored in an 'sC' operand. Equivalent to |
656 | ** (0 <= int2sC(i) && int2sC(i) <= MAXARG_C) but without risk of |
657 | ** overflows in the hidden addition inside 'int2sC'. |
658 | */ |
659 | static int fitsC (lua_Integer i) { |
660 | return (l_castS2U(i) + OFFSET_sC <= cast_uint(MAXARG_C)); |
661 | } |
662 | |
663 | |
664 | /* |
665 | ** Check whether 'i' can be stored in an 'sBx' operand. |
666 | */ |
667 | static int fitsBx (lua_Integer i) { |
668 | return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); |
669 | } |
670 | |
671 | |
672 | void luaK_int (FuncState *fs, int reg, lua_Integer i) { |
673 | if (fitsBx(i)) |
674 | luaK_codeAsBx(fs, OP_LOADI, reg, cast_int(i)); |
675 | else |
676 | luaK_codek(fs, reg, luaK_intK(fs, i)); |
677 | } |
678 | |
679 | |
680 | static void luaK_float (FuncState *fs, int reg, lua_Number f) { |
681 | lua_Integer fi; |
682 | if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) |
683 | luaK_codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); |
684 | else |
685 | luaK_codek(fs, reg, luaK_numberK(fs, f)); |
686 | } |
687 | |
688 | |
689 | /* |
690 | ** Convert a constant in 'v' into an expression description 'e' |
691 | */ |
692 | static void const2exp (TValue *v, expdesc *e) { |
693 | switch (ttypetag(v)) { |
694 | case LUA_VNUMINT: |
695 | e->k = VKINT; e->u.ival = ivalue(v); |
696 | break; |
697 | case LUA_VNUMFLT: |
698 | e->k = VKFLT; e->u.nval = fltvalue(v); |
699 | break; |
700 | case LUA_VFALSE: |
701 | e->k = VFALSE; |
702 | break; |
703 | case LUA_VTRUE: |
704 | e->k = VTRUE; |
705 | break; |
706 | case LUA_VNIL: |
707 | e->k = VNIL; |
708 | break; |
709 | case LUA_VSHRSTR: case LUA_VLNGSTR: |
710 | e->k = VKSTR; e->u.strval = tsvalue(v); |
711 | break; |
712 | default: lua_assert(0); |
713 | } |
714 | } |
715 | |
716 | |
717 | /* |
718 | ** Fix an expression to return the number of results 'nresults'. |
719 | ** 'e' must be a multi-ret expression (function call or vararg). |
720 | */ |
721 | void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { |
722 | Instruction *pc = &getinstruction(fs, e); |
723 | if (e->k == VCALL) /* expression is an open function call? */ |
724 | SETARG_C(*pc, nresults + 1); |
725 | else { |
726 | lua_assert(e->k == VVARARG); |
727 | SETARG_C(*pc, nresults + 1); |
728 | SETARG_A(*pc, fs->freereg); |
729 | luaK_reserveregs(fs, 1); |
730 | } |
731 | } |
732 | |
733 | |
734 | /* |
735 | ** Convert a VKSTR to a VK |
736 | */ |
737 | static void str2K (FuncState *fs, expdesc *e) { |
738 | lua_assert(e->k == VKSTR); |
739 | e->u.info = stringK(fs, e->u.strval); |
740 | e->k = VK; |
741 | } |
742 | |
743 | |
744 | /* |
745 | ** Fix an expression to return one result. |
746 | ** If expression is not a multi-ret expression (function call or |
747 | ** vararg), it already returns one result, so nothing needs to be done. |
748 | ** Function calls become VNONRELOC expressions (as its result comes |
749 | ** fixed in the base register of the call), while vararg expressions |
750 | ** become VRELOC (as OP_VARARG puts its results where it wants). |
751 | ** (Calls are created returning one result, so that does not need |
752 | ** to be fixed.) |
753 | */ |
754 | void luaK_setoneret (FuncState *fs, expdesc *e) { |
755 | if (e->k == VCALL) { /* expression is an open function call? */ |
756 | /* already returns 1 value */ |
757 | lua_assert(GETARG_C(getinstruction(fs, e)) == 2); |
758 | e->k = VNONRELOC; /* result has fixed position */ |
759 | e->u.info = GETARG_A(getinstruction(fs, e)); |
760 | } |
761 | else if (e->k == VVARARG) { |
762 | SETARG_C(getinstruction(fs, e), 2); |
763 | e->k = VRELOC; /* can relocate its simple result */ |
764 | } |
765 | } |
766 | |
767 | |
768 | /* |
769 | ** Ensure that expression 'e' is not a variable (nor a <const>). |
770 | ** (Expression still may have jump lists.) |
771 | */ |
772 | void luaK_dischargevars (FuncState *fs, expdesc *e) { |
773 | switch (e->k) { |
774 | case VCONST: { |
775 | const2exp(const2val(fs, e), e); |
776 | break; |
777 | } |
778 | case VLOCAL: { /* already in a register */ |
779 | e->u.info = e->u.var.ridx; |
780 | e->k = VNONRELOC; /* becomes a non-relocatable value */ |
781 | break; |
782 | } |
783 | case VUPVAL: { /* move value to some (pending) register */ |
784 | e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); |
785 | e->k = VRELOC; |
786 | break; |
787 | } |
788 | case VINDEXUP: { |
789 | e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); |
790 | e->k = VRELOC; |
791 | break; |
792 | } |
793 | case VINDEXI: { |
794 | freereg(fs, e->u.ind.t); |
795 | e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); |
796 | e->k = VRELOC; |
797 | break; |
798 | } |
799 | case VINDEXSTR: { |
800 | freereg(fs, e->u.ind.t); |
801 | e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); |
802 | e->k = VRELOC; |
803 | break; |
804 | } |
805 | case VINDEXED: { |
806 | freeregs(fs, e->u.ind.t, e->u.ind.idx); |
807 | e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); |
808 | e->k = VRELOC; |
809 | break; |
810 | } |
811 | case VVARARG: case VCALL: { |
812 | luaK_setoneret(fs, e); |
813 | break; |
814 | } |
815 | default: break; /* there is one value available (somewhere) */ |
816 | } |
817 | } |
818 | |
819 | |
820 | /* |
821 | ** Ensure expression value is in register 'reg', making 'e' a |
822 | ** non-relocatable expression. |
823 | ** (Expression still may have jump lists.) |
824 | */ |
825 | static void discharge2reg (FuncState *fs, expdesc *e, int reg) { |
826 | luaK_dischargevars(fs, e); |
827 | switch (e->k) { |
828 | case VNIL: { |
829 | luaK_nil(fs, reg, 1); |
830 | break; |
831 | } |
832 | case VFALSE: { |
833 | luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); |
834 | break; |
835 | } |
836 | case VTRUE: { |
837 | luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); |
838 | break; |
839 | } |
840 | case VKSTR: { |
841 | str2K(fs, e); |
842 | } /* FALLTHROUGH */ |
843 | case VK: { |
844 | luaK_codek(fs, reg, e->u.info); |
845 | break; |
846 | } |
847 | case VKFLT: { |
848 | luaK_float(fs, reg, e->u.nval); |
849 | break; |
850 | } |
851 | case VKINT: { |
852 | luaK_int(fs, reg, e->u.ival); |
853 | break; |
854 | } |
855 | case VRELOC: { |
856 | Instruction *pc = &getinstruction(fs, e); |
857 | SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ |
858 | break; |
859 | } |
860 | case VNONRELOC: { |
861 | if (reg != e->u.info) |
862 | luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); |
863 | break; |
864 | } |
865 | default: { |
866 | lua_assert(e->k == VJMP); |
867 | return; /* nothing to do... */ |
868 | } |
869 | } |
870 | e->u.info = reg; |
871 | e->k = VNONRELOC; |
872 | } |
873 | |
874 | |
875 | /* |
876 | ** Ensure expression value is in a register, making 'e' a |
877 | ** non-relocatable expression. |
878 | ** (Expression still may have jump lists.) |
879 | */ |
880 | static void discharge2anyreg (FuncState *fs, expdesc *e) { |
881 | if (e->k != VNONRELOC) { /* no fixed register yet? */ |
882 | luaK_reserveregs(fs, 1); /* get a register */ |
883 | discharge2reg(fs, e, fs->freereg-1); /* put value there */ |
884 | } |
885 | } |
886 | |
887 | |
888 | static int code_loadbool (FuncState *fs, int A, OpCode op) { |
889 | luaK_getlabel(fs); /* those instructions may be jump targets */ |
890 | return luaK_codeABC(fs, op, A, 0, 0); |
891 | } |
892 | |
893 | |
894 | /* |
895 | ** check whether list has any jump that do not produce a value |
896 | ** or produce an inverted value |
897 | */ |
898 | static int need_value (FuncState *fs, int list) { |
899 | for (; list != NO_JUMP; list = getjump(fs, list)) { |
900 | Instruction i = *getjumpcontrol(fs, list); |
901 | if (GET_OPCODE(i) != OP_TESTSET) return 1; |
902 | } |
903 | return 0; /* not found */ |
904 | } |
905 | |
906 | |
907 | /* |
908 | ** Ensures final expression result (which includes results from its |
909 | ** jump lists) is in register 'reg'. |
910 | ** If expression has jumps, need to patch these jumps either to |
911 | ** its final position or to "load" instructions (for those tests |
912 | ** that do not produce values). |
913 | */ |
914 | static void exp2reg (FuncState *fs, expdesc *e, int reg) { |
915 | discharge2reg(fs, e, reg); |
916 | if (e->k == VJMP) /* expression itself is a test? */ |
917 | luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ |
918 | if (hasjumps(e)) { |
919 | int final; /* position after whole expression */ |
920 | int p_f = NO_JUMP; /* position of an eventual LOAD false */ |
921 | int p_t = NO_JUMP; /* position of an eventual LOAD true */ |
922 | if (need_value(fs, e->t) || need_value(fs, e->f)) { |
923 | int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); |
924 | p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ |
925 | p_t = code_loadbool(fs, reg, OP_LOADTRUE); |
926 | /* jump around these booleans if 'e' is not a test */ |
927 | luaK_patchtohere(fs, fj); |
928 | } |
929 | final = luaK_getlabel(fs); |
930 | patchlistaux(fs, e->f, final, reg, p_f); |
931 | patchlistaux(fs, e->t, final, reg, p_t); |
932 | } |
933 | e->f = e->t = NO_JUMP; |
934 | e->u.info = reg; |
935 | e->k = VNONRELOC; |
936 | } |
937 | |
938 | |
939 | /* |
940 | ** Ensures final expression result is in next available register. |
941 | */ |
942 | void luaK_exp2nextreg (FuncState *fs, expdesc *e) { |
943 | luaK_dischargevars(fs, e); |
944 | freeexp(fs, e); |
945 | luaK_reserveregs(fs, 1); |
946 | exp2reg(fs, e, fs->freereg - 1); |
947 | } |
948 | |
949 | |
950 | /* |
951 | ** Ensures final expression result is in some (any) register |
952 | ** and return that register. |
953 | */ |
954 | int luaK_exp2anyreg (FuncState *fs, expdesc *e) { |
955 | luaK_dischargevars(fs, e); |
956 | if (e->k == VNONRELOC) { /* expression already has a register? */ |
957 | if (!hasjumps(e)) /* no jumps? */ |
958 | return e->u.info; /* result is already in a register */ |
959 | if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ |
960 | exp2reg(fs, e, e->u.info); /* put final result in it */ |
961 | return e->u.info; |
962 | } |
963 | /* else expression has jumps and cannot change its register |
964 | to hold the jump values, because it is a local variable. |
965 | Go through to the default case. */ |
966 | } |
967 | luaK_exp2nextreg(fs, e); /* default: use next available register */ |
968 | return e->u.info; |
969 | } |
970 | |
971 | |
972 | /* |
973 | ** Ensures final expression result is either in a register |
974 | ** or in an upvalue. |
975 | */ |
976 | void luaK_exp2anyregup (FuncState *fs, expdesc *e) { |
977 | if (e->k != VUPVAL || hasjumps(e)) |
978 | luaK_exp2anyreg(fs, e); |
979 | } |
980 | |
981 | |
982 | /* |
983 | ** Ensures final expression result is either in a register |
984 | ** or it is a constant. |
985 | */ |
986 | void luaK_exp2val (FuncState *fs, expdesc *e) { |
987 | if (hasjumps(e)) |
988 | luaK_exp2anyreg(fs, e); |
989 | else |
990 | luaK_dischargevars(fs, e); |
991 | } |
992 | |
993 | |
994 | /* |
995 | ** Try to make 'e' a K expression with an index in the range of R/K |
996 | ** indices. Return true iff succeeded. |
997 | */ |
998 | static int luaK_exp2K (FuncState *fs, expdesc *e) { |
999 | if (!hasjumps(e)) { |
1000 | int info; |
1001 | switch (e->k) { /* move constants to 'k' */ |
1002 | case VTRUE: info = boolT(fs); break; |
1003 | case VFALSE: info = boolF(fs); break; |
1004 | case VNIL: info = nilK(fs); break; |
1005 | case VKINT: info = luaK_intK(fs, e->u.ival); break; |
1006 | case VKFLT: info = luaK_numberK(fs, e->u.nval); break; |
1007 | case VKSTR: info = stringK(fs, e->u.strval); break; |
1008 | case VK: info = e->u.info; break; |
1009 | default: return 0; /* not a constant */ |
1010 | } |
1011 | if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ |
1012 | e->k = VK; /* make expression a 'K' expression */ |
1013 | e->u.info = info; |
1014 | return 1; |
1015 | } |
1016 | } |
1017 | /* else, expression doesn't fit; leave it unchanged */ |
1018 | return 0; |
1019 | } |
1020 | |
1021 | |
1022 | /* |
1023 | ** Ensures final expression result is in a valid R/K index |
1024 | ** (that is, it is either in a register or in 'k' with an index |
1025 | ** in the range of R/K indices). |
1026 | ** Returns 1 iff expression is K. |
1027 | */ |
1028 | int luaK_exp2RK (FuncState *fs, expdesc *e) { |
1029 | if (luaK_exp2K(fs, e)) |
1030 | return 1; |
1031 | else { /* not a constant in the right range: put it in a register */ |
1032 | luaK_exp2anyreg(fs, e); |
1033 | return 0; |
1034 | } |
1035 | } |
1036 | |
1037 | |
1038 | static void codeABRK (FuncState *fs, OpCode o, int a, int b, |
1039 | expdesc *ec) { |
1040 | int k = luaK_exp2RK(fs, ec); |
1041 | luaK_codeABCk(fs, o, a, b, ec->u.info, k); |
1042 | } |
1043 | |
1044 | |
1045 | /* |
1046 | ** Generate code to store result of expression 'ex' into variable 'var'. |
1047 | */ |
1048 | void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { |
1049 | switch (var->k) { |
1050 | case VLOCAL: { |
1051 | freeexp(fs, ex); |
1052 | exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ |
1053 | return; |
1054 | } |
1055 | case VUPVAL: { |
1056 | int e = luaK_exp2anyreg(fs, ex); |
1057 | luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); |
1058 | break; |
1059 | } |
1060 | case VINDEXUP: { |
1061 | codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); |
1062 | break; |
1063 | } |
1064 | case VINDEXI: { |
1065 | codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); |
1066 | break; |
1067 | } |
1068 | case VINDEXSTR: { |
1069 | codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); |
1070 | break; |
1071 | } |
1072 | case VINDEXED: { |
1073 | codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); |
1074 | break; |
1075 | } |
1076 | default: lua_assert(0); /* invalid var kind to store */ |
1077 | } |
1078 | freeexp(fs, ex); |
1079 | } |
1080 | |
1081 | |
1082 | /* |
1083 | ** Emit SELF instruction (convert expression 'e' into 'e:key(e,'). |
1084 | */ |
1085 | void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { |
1086 | int ereg; |
1087 | luaK_exp2anyreg(fs, e); |
1088 | ereg = e->u.info; /* register where 'e' was placed */ |
1089 | freeexp(fs, e); |
1090 | e->u.info = fs->freereg; /* base register for op_self */ |
1091 | e->k = VNONRELOC; /* self expression has a fixed register */ |
1092 | luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ |
1093 | codeABRK(fs, OP_SELF, e->u.info, ereg, key); |
1094 | freeexp(fs, key); |
1095 | } |
1096 | |
1097 | |
1098 | /* |
1099 | ** Negate condition 'e' (where 'e' is a comparison). |
1100 | */ |
1101 | static void negatecondition (FuncState *fs, expdesc *e) { |
1102 | Instruction *pc = getjumpcontrol(fs, e->u.info); |
1103 | lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && |
1104 | GET_OPCODE(*pc) != OP_TEST); |
1105 | SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); |
1106 | } |
1107 | |
1108 | |
1109 | /* |
1110 | ** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond' |
1111 | ** is true, code will jump if 'e' is true.) Return jump position. |
1112 | ** Optimize when 'e' is 'not' something, inverting the condition |
1113 | ** and removing the 'not'. |
1114 | */ |
1115 | static int jumponcond (FuncState *fs, expdesc *e, int cond) { |
1116 | if (e->k == VRELOC) { |
1117 | Instruction ie = getinstruction(fs, e); |
1118 | if (GET_OPCODE(ie) == OP_NOT) { |
1119 | removelastinstruction(fs); /* remove previous OP_NOT */ |
1120 | return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); |
1121 | } |
1122 | /* else go through */ |
1123 | } |
1124 | discharge2anyreg(fs, e); |
1125 | freeexp(fs, e); |
1126 | return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); |
1127 | } |
1128 | |
1129 | |
1130 | /* |
1131 | ** Emit code to go through if 'e' is true, jump otherwise. |
1132 | */ |
1133 | void luaK_goiftrue (FuncState *fs, expdesc *e) { |
1134 | int pc; /* pc of new jump */ |
1135 | luaK_dischargevars(fs, e); |
1136 | switch (e->k) { |
1137 | case VJMP: { /* condition? */ |
1138 | negatecondition(fs, e); /* jump when it is false */ |
1139 | pc = e->u.info; /* save jump position */ |
1140 | break; |
1141 | } |
1142 | case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { |
1143 | pc = NO_JUMP; /* always true; do nothing */ |
1144 | break; |
1145 | } |
1146 | default: { |
1147 | pc = jumponcond(fs, e, 0); /* jump when false */ |
1148 | break; |
1149 | } |
1150 | } |
1151 | luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ |
1152 | luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ |
1153 | e->t = NO_JUMP; |
1154 | } |
1155 | |
1156 | |
1157 | /* |
1158 | ** Emit code to go through if 'e' is false, jump otherwise. |
1159 | */ |
1160 | void luaK_goiffalse (FuncState *fs, expdesc *e) { |
1161 | int pc; /* pc of new jump */ |
1162 | luaK_dischargevars(fs, e); |
1163 | switch (e->k) { |
1164 | case VJMP: { |
1165 | pc = e->u.info; /* already jump if true */ |
1166 | break; |
1167 | } |
1168 | case VNIL: case VFALSE: { |
1169 | pc = NO_JUMP; /* always false; do nothing */ |
1170 | break; |
1171 | } |
1172 | default: { |
1173 | pc = jumponcond(fs, e, 1); /* jump if true */ |
1174 | break; |
1175 | } |
1176 | } |
1177 | luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ |
1178 | luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ |
1179 | e->f = NO_JUMP; |
1180 | } |
1181 | |
1182 | |
1183 | /* |
1184 | ** Code 'not e', doing constant folding. |
1185 | */ |
1186 | static void codenot (FuncState *fs, expdesc *e) { |
1187 | switch (e->k) { |
1188 | case VNIL: case VFALSE: { |
1189 | e->k = VTRUE; /* true == not nil == not false */ |
1190 | break; |
1191 | } |
1192 | case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { |
1193 | e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ |
1194 | break; |
1195 | } |
1196 | case VJMP: { |
1197 | negatecondition(fs, e); |
1198 | break; |
1199 | } |
1200 | case VRELOC: |
1201 | case VNONRELOC: { |
1202 | discharge2anyreg(fs, e); |
1203 | freeexp(fs, e); |
1204 | e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); |
1205 | e->k = VRELOC; |
1206 | break; |
1207 | } |
1208 | default: lua_assert(0); /* cannot happen */ |
1209 | } |
1210 | /* interchange true and false lists */ |
1211 | { int temp = e->f; e->f = e->t; e->t = temp; } |
1212 | removevalues(fs, e->f); /* values are useless when negated */ |
1213 | removevalues(fs, e->t); |
1214 | } |
1215 | |
1216 | |
1217 | /* |
1218 | ** Check whether expression 'e' is a small literal string |
1219 | */ |
1220 | static int isKstr (FuncState *fs, expdesc *e) { |
1221 | return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && |
1222 | ttisshrstring(&fs->f->k[e->u.info])); |
1223 | } |
1224 | |
1225 | /* |
1226 | ** Check whether expression 'e' is a literal integer. |
1227 | */ |
1228 | int luaK_isKint (expdesc *e) { |
1229 | return (e->k == VKINT && !hasjumps(e)); |
1230 | } |
1231 | |
1232 | |
1233 | /* |
1234 | ** Check whether expression 'e' is a literal integer in |
1235 | ** proper range to fit in register C |
1236 | */ |
1237 | static int isCint (expdesc *e) { |
1238 | return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); |
1239 | } |
1240 | |
1241 | |
1242 | /* |
1243 | ** Check whether expression 'e' is a literal integer in |
1244 | ** proper range to fit in register sC |
1245 | */ |
1246 | static int isSCint (expdesc *e) { |
1247 | return luaK_isKint(e) && fitsC(e->u.ival); |
1248 | } |
1249 | |
1250 | |
1251 | /* |
1252 | ** Check whether expression 'e' is a literal integer or float in |
1253 | ** proper range to fit in a register (sB or sC). |
1254 | */ |
1255 | static int isSCnumber (expdesc *e, int *pi, int *isfloat) { |
1256 | lua_Integer i; |
1257 | if (e->k == VKINT) |
1258 | i = e->u.ival; |
1259 | else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) |
1260 | *isfloat = 1; |
1261 | else |
1262 | return 0; /* not a number */ |
1263 | if (!hasjumps(e) && fitsC(i)) { |
1264 | *pi = int2sC(cast_int(i)); |
1265 | return 1; |
1266 | } |
1267 | else |
1268 | return 0; |
1269 | } |
1270 | |
1271 | |
1272 | /* |
1273 | ** Create expression 't[k]'. 't' must have its final result already in a |
1274 | ** register or upvalue. Upvalues can only be indexed by literal strings. |
1275 | ** Keys can be literal strings in the constant table or arbitrary |
1276 | ** values in registers. |
1277 | */ |
1278 | void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { |
1279 | if (k->k == VKSTR) |
1280 | str2K(fs, k); |
1281 | lua_assert(!hasjumps(t) && |
1282 | (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); |
1283 | if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ |
1284 | luaK_exp2anyreg(fs, t); /* put it in a register */ |
1285 | if (t->k == VUPVAL) { |
1286 | t->u.ind.t = t->u.info; /* upvalue index */ |
1287 | t->u.ind.idx = k->u.info; /* literal string */ |
1288 | t->k = VINDEXUP; |
1289 | } |
1290 | else { |
1291 | /* register index of the table */ |
1292 | t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; |
1293 | if (isKstr(fs, k)) { |
1294 | t->u.ind.idx = k->u.info; /* literal string */ |
1295 | t->k = VINDEXSTR; |
1296 | } |
1297 | else if (isCint(k)) { |
1298 | t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ |
1299 | t->k = VINDEXI; |
1300 | } |
1301 | else { |
1302 | t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ |
1303 | t->k = VINDEXED; |
1304 | } |
1305 | } |
1306 | } |
1307 | |
1308 | |
1309 | /* |
1310 | ** Return false if folding can raise an error. |
1311 | ** Bitwise operations need operands convertible to integers; division |
1312 | ** operations cannot have 0 as divisor. |
1313 | */ |
1314 | static int validop (int op, TValue *v1, TValue *v2) { |
1315 | switch (op) { |
1316 | case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: |
1317 | case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ |
1318 | lua_Integer i; |
1319 | return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && |
1320 | luaV_tointegerns(v2, &i, LUA_FLOORN2I)); |
1321 | } |
1322 | case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ |
1323 | return (nvalue(v2) != 0); |
1324 | default: return 1; /* everything else is valid */ |
1325 | } |
1326 | } |
1327 | |
1328 | |
1329 | /* |
1330 | ** Try to "constant-fold" an operation; return 1 iff successful. |
1331 | ** (In this case, 'e1' has the final result.) |
1332 | */ |
1333 | static int constfolding (FuncState *fs, int op, expdesc *e1, |
1334 | const expdesc *e2) { |
1335 | TValue v1, v2, res; |
1336 | if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) |
1337 | return 0; /* non-numeric operands or not safe to fold */ |
1338 | luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ |
1339 | if (ttisinteger(&res)) { |
1340 | e1->k = VKINT; |
1341 | e1->u.ival = ivalue(&res); |
1342 | } |
1343 | else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ |
1344 | lua_Number n = fltvalue(&res); |
1345 | if (luai_numisnan(n) || n == 0) |
1346 | return 0; |
1347 | e1->k = VKFLT; |
1348 | e1->u.nval = n; |
1349 | } |
1350 | return 1; |
1351 | } |
1352 | |
1353 | |
1354 | /* |
1355 | ** Emit code for unary expressions that "produce values" |
1356 | ** (everything but 'not'). |
1357 | ** Expression to produce final result will be encoded in 'e'. |
1358 | */ |
1359 | static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { |
1360 | int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ |
1361 | freeexp(fs, e); |
1362 | e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ |
1363 | e->k = VRELOC; /* all those operations are relocatable */ |
1364 | luaK_fixline(fs, line); |
1365 | } |
1366 | |
1367 | |
1368 | /* |
1369 | ** Emit code for binary expressions that "produce values" |
1370 | ** (everything but logical operators 'and'/'or' and comparison |
1371 | ** operators). |
1372 | ** Expression to produce final result will be encoded in 'e1'. |
1373 | */ |
1374 | static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2, |
1375 | OpCode op, int v2, int flip, int line, |
1376 | OpCode mmop, TMS event) { |
1377 | int v1 = luaK_exp2anyreg(fs, e1); |
1378 | int pc = luaK_codeABCk(fs, op, 0, v1, v2, 0); |
1379 | freeexps(fs, e1, e2); |
1380 | e1->u.info = pc; |
1381 | e1->k = VRELOC; /* all those operations are relocatable */ |
1382 | luaK_fixline(fs, line); |
1383 | luaK_codeABCk(fs, mmop, v1, v2, event, flip); /* to call metamethod */ |
1384 | luaK_fixline(fs, line); |
1385 | } |
1386 | |
1387 | |
1388 | /* |
1389 | ** Emit code for binary expressions that "produce values" over |
1390 | ** two registers. |
1391 | */ |
1392 | static void codebinexpval (FuncState *fs, OpCode op, |
1393 | expdesc *e1, expdesc *e2, int line) { |
1394 | int v2 = luaK_exp2anyreg(fs, e2); /* both operands are in registers */ |
1395 | lua_assert(OP_ADD <= op && op <= OP_SHR); |
1396 | finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, |
1397 | cast(TMS, (op - OP_ADD) + TM_ADD)); |
1398 | } |
1399 | |
1400 | |
1401 | /* |
1402 | ** Code binary operators with immediate operands. |
1403 | */ |
1404 | static void codebini (FuncState *fs, OpCode op, |
1405 | expdesc *e1, expdesc *e2, int flip, int line, |
1406 | TMS event) { |
1407 | int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ |
1408 | lua_assert(e2->k == VKINT); |
1409 | finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); |
1410 | } |
1411 | |
1412 | |
1413 | /* Try to code a binary operator negating its second operand. |
1414 | ** For the metamethod, 2nd operand must keep its original value. |
1415 | */ |
1416 | static int finishbinexpneg (FuncState *fs, expdesc *e1, expdesc *e2, |
1417 | OpCode op, int line, TMS event) { |
1418 | if (!luaK_isKint(e2)) |
1419 | return 0; /* not an integer constant */ |
1420 | else { |
1421 | lua_Integer i2 = e2->u.ival; |
1422 | if (!(fitsC(i2) && fitsC(-i2))) |
1423 | return 0; /* not in the proper range */ |
1424 | else { /* operating a small integer constant */ |
1425 | int v2 = cast_int(i2); |
1426 | finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); |
1427 | /* correct metamethod argument */ |
1428 | SETARG_B(fs->f->code[fs->pc - 1], int2sC(v2)); |
1429 | return 1; /* successfully coded */ |
1430 | } |
1431 | } |
1432 | } |
1433 | |
1434 | |
1435 | static void swapexps (expdesc *e1, expdesc *e2) { |
1436 | expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ |
1437 | } |
1438 | |
1439 | |
1440 | /* |
1441 | ** Code arithmetic operators ('+', '-', ...). If second operand is a |
1442 | ** constant in the proper range, use variant opcodes with K operands. |
1443 | */ |
1444 | static void codearith (FuncState *fs, BinOpr opr, |
1445 | expdesc *e1, expdesc *e2, int flip, int line) { |
1446 | TMS event = cast(TMS, opr + TM_ADD); |
1447 | if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) { /* K operand? */ |
1448 | int v2 = e2->u.info; /* K index */ |
1449 | OpCode op = cast(OpCode, opr + OP_ADDK); |
1450 | finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); |
1451 | } |
1452 | else { /* 'e2' is neither an immediate nor a K operand */ |
1453 | OpCode op = cast(OpCode, opr + OP_ADD); |
1454 | if (flip) |
1455 | swapexps(e1, e2); /* back to original order */ |
1456 | codebinexpval(fs, op, e1, e2, line); /* use standard operators */ |
1457 | } |
1458 | } |
1459 | |
1460 | |
1461 | /* |
1462 | ** Code commutative operators ('+', '*'). If first operand is a |
1463 | ** numeric constant, change order of operands to try to use an |
1464 | ** immediate or K operator. |
1465 | */ |
1466 | static void codecommutative (FuncState *fs, BinOpr op, |
1467 | expdesc *e1, expdesc *e2, int line) { |
1468 | int flip = 0; |
1469 | if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ |
1470 | swapexps(e1, e2); /* change order */ |
1471 | flip = 1; |
1472 | } |
1473 | if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ |
1474 | codebini(fs, cast(OpCode, OP_ADDI), e1, e2, flip, line, TM_ADD); |
1475 | else |
1476 | codearith(fs, op, e1, e2, flip, line); |
1477 | } |
1478 | |
1479 | |
1480 | /* |
1481 | ** Code bitwise operations; they are all associative, so the function |
1482 | ** tries to put an integer constant as the 2nd operand (a K operand). |
1483 | */ |
1484 | static void codebitwise (FuncState *fs, BinOpr opr, |
1485 | expdesc *e1, expdesc *e2, int line) { |
1486 | int flip = 0; |
1487 | int v2; |
1488 | OpCode op; |
1489 | if (e1->k == VKINT && luaK_exp2RK(fs, e1)) { |
1490 | swapexps(e1, e2); /* 'e2' will be the constant operand */ |
1491 | flip = 1; |
1492 | } |
1493 | else if (!(e2->k == VKINT && luaK_exp2RK(fs, e2))) { /* no constants? */ |
1494 | op = cast(OpCode, opr + OP_ADD); |
1495 | codebinexpval(fs, op, e1, e2, line); /* all-register opcodes */ |
1496 | return; |
1497 | } |
1498 | v2 = e2->u.info; /* index in K array */ |
1499 | op = cast(OpCode, opr + OP_ADDK); |
1500 | lua_assert(ttisinteger(&fs->f->k[v2])); |
1501 | finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, |
1502 | cast(TMS, opr + TM_ADD)); |
1503 | } |
1504 | |
1505 | |
1506 | /* |
1507 | ** Emit code for order comparisons. When using an immediate operand, |
1508 | ** 'isfloat' tells whether the original value was a float. |
1509 | */ |
1510 | static void codeorder (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) { |
1511 | int r1, r2; |
1512 | int im; |
1513 | int isfloat = 0; |
1514 | if (isSCnumber(e2, &im, &isfloat)) { |
1515 | /* use immediate operand */ |
1516 | r1 = luaK_exp2anyreg(fs, e1); |
1517 | r2 = im; |
1518 | op = cast(OpCode, (op - OP_LT) + OP_LTI); |
1519 | } |
1520 | else if (isSCnumber(e1, &im, &isfloat)) { |
1521 | /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ |
1522 | r1 = luaK_exp2anyreg(fs, e2); |
1523 | r2 = im; |
1524 | op = (op == OP_LT) ? OP_GTI : OP_GEI; |
1525 | } |
1526 | else { /* regular case, compare two registers */ |
1527 | r1 = luaK_exp2anyreg(fs, e1); |
1528 | r2 = luaK_exp2anyreg(fs, e2); |
1529 | } |
1530 | freeexps(fs, e1, e2); |
1531 | e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); |
1532 | e1->k = VJMP; |
1533 | } |
1534 | |
1535 | |
1536 | /* |
1537 | ** Emit code for equality comparisons ('==', '~='). |
1538 | ** 'e1' was already put as RK by 'luaK_infix'. |
1539 | */ |
1540 | static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { |
1541 | int r1, r2; |
1542 | int im; |
1543 | int isfloat = 0; /* not needed here, but kept for symmetry */ |
1544 | OpCode op; |
1545 | if (e1->k != VNONRELOC) { |
1546 | lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); |
1547 | swapexps(e1, e2); |
1548 | } |
1549 | r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ |
1550 | if (isSCnumber(e2, &im, &isfloat)) { |
1551 | op = OP_EQI; |
1552 | r2 = im; /* immediate operand */ |
1553 | } |
1554 | else if (luaK_exp2RK(fs, e2)) { /* 1st expression is constant? */ |
1555 | op = OP_EQK; |
1556 | r2 = e2->u.info; /* constant index */ |
1557 | } |
1558 | else { |
1559 | op = OP_EQ; /* will compare two registers */ |
1560 | r2 = luaK_exp2anyreg(fs, e2); |
1561 | } |
1562 | freeexps(fs, e1, e2); |
1563 | e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); |
1564 | e1->k = VJMP; |
1565 | } |
1566 | |
1567 | |
1568 | /* |
1569 | ** Apply prefix operation 'op' to expression 'e'. |
1570 | */ |
1571 | void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) { |
1572 | static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; |
1573 | luaK_dischargevars(fs, e); |
1574 | switch (op) { |
1575 | case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ |
1576 | if (constfolding(fs, op + LUA_OPUNM, e, &ef)) |
1577 | break; |
1578 | /* else */ /* FALLTHROUGH */ |
1579 | case OPR_LEN: |
1580 | codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line); |
1581 | break; |
1582 | case OPR_NOT: codenot(fs, e); break; |
1583 | default: lua_assert(0); |
1584 | } |
1585 | } |
1586 | |
1587 | |
1588 | /* |
1589 | ** Process 1st operand 'v' of binary operation 'op' before reading |
1590 | ** 2nd operand. |
1591 | */ |
1592 | void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { |
1593 | luaK_dischargevars(fs, v); |
1594 | switch (op) { |
1595 | case OPR_AND: { |
1596 | luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ |
1597 | break; |
1598 | } |
1599 | case OPR_OR: { |
1600 | luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ |
1601 | break; |
1602 | } |
1603 | case OPR_CONCAT: { |
1604 | luaK_exp2nextreg(fs, v); /* operand must be on the stack */ |
1605 | break; |
1606 | } |
1607 | case OPR_ADD: case OPR_SUB: |
1608 | case OPR_MUL: case OPR_DIV: case OPR_IDIV: |
1609 | case OPR_MOD: case OPR_POW: |
1610 | case OPR_BAND: case OPR_BOR: case OPR_BXOR: |
1611 | case OPR_SHL: case OPR_SHR: { |
1612 | if (!tonumeral(v, NULL)) |
1613 | luaK_exp2anyreg(fs, v); |
1614 | /* else keep numeral, which may be folded with 2nd operand */ |
1615 | break; |
1616 | } |
1617 | case OPR_EQ: case OPR_NE: { |
1618 | if (!tonumeral(v, NULL)) |
1619 | luaK_exp2RK(fs, v); |
1620 | /* else keep numeral, which may be an immediate operand */ |
1621 | break; |
1622 | } |
1623 | case OPR_LT: case OPR_LE: |
1624 | case OPR_GT: case OPR_GE: { |
1625 | int dummy, dummy2; |
1626 | if (!isSCnumber(v, &dummy, &dummy2)) |
1627 | luaK_exp2anyreg(fs, v); |
1628 | /* else keep numeral, which may be an immediate operand */ |
1629 | break; |
1630 | } |
1631 | default: lua_assert(0); |
1632 | } |
1633 | } |
1634 | |
1635 | /* |
1636 | ** Create code for '(e1 .. e2)'. |
1637 | ** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))', |
1638 | ** because concatenation is right associative), merge both CONCATs. |
1639 | */ |
1640 | static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) { |
1641 | Instruction *ie2 = previousinstruction(fs); |
1642 | if (GET_OPCODE(*ie2) == OP_CONCAT) { /* is 'e2' a concatenation? */ |
1643 | int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ |
1644 | lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); |
1645 | freeexp(fs, e2); |
1646 | SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ |
1647 | SETARG_B(*ie2, n + 1); /* will concatenate one more element */ |
1648 | } |
1649 | else { /* 'e2' is not a concatenation */ |
1650 | luaK_codeABC(fs, OP_CONCAT, e1->u.info, 2, 0); /* new concat opcode */ |
1651 | freeexp(fs, e2); |
1652 | luaK_fixline(fs, line); |
1653 | } |
1654 | } |
1655 | |
1656 | |
1657 | /* |
1658 | ** Finalize code for binary operation, after reading 2nd operand. |
1659 | */ |
1660 | void luaK_posfix (FuncState *fs, BinOpr opr, |
1661 | expdesc *e1, expdesc *e2, int line) { |
1662 | luaK_dischargevars(fs, e2); |
1663 | if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) |
1664 | return; /* done by folding */ |
1665 | switch (opr) { |
1666 | case OPR_AND: { |
1667 | lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ |
1668 | luaK_concat(fs, &e2->f, e1->f); |
1669 | *e1 = *e2; |
1670 | break; |
1671 | } |
1672 | case OPR_OR: { |
1673 | lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ |
1674 | luaK_concat(fs, &e2->t, e1->t); |
1675 | *e1 = *e2; |
1676 | break; |
1677 | } |
1678 | case OPR_CONCAT: { /* e1 .. e2 */ |
1679 | luaK_exp2nextreg(fs, e2); |
1680 | codeconcat(fs, e1, e2, line); |
1681 | break; |
1682 | } |
1683 | case OPR_ADD: case OPR_MUL: { |
1684 | codecommutative(fs, opr, e1, e2, line); |
1685 | break; |
1686 | } |
1687 | case OPR_SUB: { |
1688 | if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) |
1689 | break; /* coded as (r1 + -I) */ |
1690 | /* ELSE */ |
1691 | } /* FALLTHROUGH */ |
1692 | case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { |
1693 | codearith(fs, opr, e1, e2, 0, line); |
1694 | break; |
1695 | } |
1696 | case OPR_BAND: case OPR_BOR: case OPR_BXOR: { |
1697 | codebitwise(fs, opr, e1, e2, line); |
1698 | break; |
1699 | } |
1700 | case OPR_SHL: { |
1701 | if (isSCint(e1)) { |
1702 | swapexps(e1, e2); |
1703 | codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ |
1704 | } |
1705 | else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { |
1706 | /* coded as (r1 >> -I) */; |
1707 | } |
1708 | else /* regular case (two registers) */ |
1709 | codebinexpval(fs, OP_SHL, e1, e2, line); |
1710 | break; |
1711 | } |
1712 | case OPR_SHR: { |
1713 | if (isSCint(e2)) |
1714 | codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ |
1715 | else /* regular case (two registers) */ |
1716 | codebinexpval(fs, OP_SHR, e1, e2, line); |
1717 | break; |
1718 | } |
1719 | case OPR_EQ: case OPR_NE: { |
1720 | codeeq(fs, opr, e1, e2); |
1721 | break; |
1722 | } |
1723 | case OPR_LT: case OPR_LE: { |
1724 | OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ); |
1725 | codeorder(fs, op, e1, e2); |
1726 | break; |
1727 | } |
1728 | case OPR_GT: case OPR_GE: { |
1729 | /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ |
1730 | OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ); |
1731 | swapexps(e1, e2); |
1732 | codeorder(fs, op, e1, e2); |
1733 | break; |
1734 | } |
1735 | default: lua_assert(0); |
1736 | } |
1737 | } |
1738 | |
1739 | |
1740 | /* |
1741 | ** Change line information associated with current position, by removing |
1742 | ** previous info and adding it again with new line. |
1743 | */ |
1744 | void luaK_fixline (FuncState *fs, int line) { |
1745 | removelastlineinfo(fs); |
1746 | savelineinfo(fs, fs->f, line); |
1747 | } |
1748 | |
1749 | |
1750 | void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { |
1751 | Instruction *inst = &fs->f->code[pc]; |
1752 | int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0; /* hash size */ |
1753 | int = asize / (MAXARG_C + 1); /* higher bits of array size */ |
1754 | int rc = asize % (MAXARG_C + 1); /* lower bits of array size */ |
1755 | int k = (extra > 0); /* true iff needs extra argument */ |
1756 | *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k); |
1757 | *(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra); |
1758 | } |
1759 | |
1760 | |
1761 | /* |
1762 | ** Emit a SETLIST instruction. |
1763 | ** 'base' is register that keeps table; |
1764 | ** 'nelems' is #table plus those to be stored now; |
1765 | ** 'tostore' is number of values (in registers 'base + 1',...) to add to |
1766 | ** table (or LUA_MULTRET to add up to stack top). |
1767 | */ |
1768 | void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { |
1769 | lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH); |
1770 | if (tostore == LUA_MULTRET) |
1771 | tostore = 0; |
1772 | if (nelems <= MAXARG_C) |
1773 | luaK_codeABC(fs, OP_SETLIST, base, tostore, nelems); |
1774 | else { |
1775 | int = nelems / (MAXARG_C + 1); |
1776 | nelems %= (MAXARG_C + 1); |
1777 | luaK_codeABCk(fs, OP_SETLIST, base, tostore, nelems, 1); |
1778 | codeextraarg(fs, extra); |
1779 | } |
1780 | fs->freereg = base + 1; /* free registers with list values */ |
1781 | } |
1782 | |
1783 | |
1784 | /* |
1785 | ** return the final target of a jump (skipping jumps to jumps) |
1786 | */ |
1787 | static int finaltarget (Instruction *code, int i) { |
1788 | int count; |
1789 | for (count = 0; count < 100; count++) { /* avoid infinite loops */ |
1790 | Instruction pc = code[i]; |
1791 | if (GET_OPCODE(pc) != OP_JMP) |
1792 | break; |
1793 | else |
1794 | i += GETARG_sJ(pc) + 1; |
1795 | } |
1796 | return i; |
1797 | } |
1798 | |
1799 | |
1800 | /* |
1801 | ** Do a final pass over the code of a function, doing small peephole |
1802 | ** optimizations and adjustments. |
1803 | */ |
1804 | void luaK_finish (FuncState *fs) { |
1805 | int i; |
1806 | Proto *p = fs->f; |
1807 | for (i = 0; i < fs->pc; i++) { |
1808 | Instruction *pc = &p->code[i]; |
1809 | lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); |
1810 | switch (GET_OPCODE(*pc)) { |
1811 | case OP_RETURN0: case OP_RETURN1: { |
1812 | if (!(fs->needclose || p->is_vararg)) |
1813 | break; /* no extra work */ |
1814 | /* else use OP_RETURN to do the extra work */ |
1815 | SET_OPCODE(*pc, OP_RETURN); |
1816 | } /* FALLTHROUGH */ |
1817 | case OP_RETURN: case OP_TAILCALL: { |
1818 | if (fs->needclose) |
1819 | SETARG_k(*pc, 1); /* signal that it needs to close */ |
1820 | if (p->is_vararg) |
1821 | SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */ |
1822 | break; |
1823 | } |
1824 | case OP_JMP: { |
1825 | int target = finaltarget(p->code, i); |
1826 | fixjump(fs, i, target); |
1827 | break; |
1828 | } |
1829 | default: break; |
1830 | } |
1831 | } |
1832 | } |
1833 | |