Mercurial

comparison third_party/luajit/src/lj_bcread.c @ 186:8cf4ec5e2191 hg-web

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed merge conflict.
author MrJuneJune <me@mrjunejune.com>
date Fri, 23 Jan 2026 22:38:59 -0800
parents 94705b5986b3
children
comparison
equal deleted inserted replaced
176:fed99fc04e12 186:8cf4ec5e2191
1 /*
2 ** Bytecode reader.
3 ** Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
4 */
5
6 #define lj_bcread_c
7 #define LUA_CORE
8
9 #include "lj_obj.h"
10 #include "lj_gc.h"
11 #include "lj_err.h"
12 #include "lj_buf.h"
13 #include "lj_str.h"
14 #include "lj_tab.h"
15 #include "lj_bc.h"
16 #if LJ_HASFFI
17 #include "lj_ctype.h"
18 #include "lj_cdata.h"
19 #include "lualib.h"
20 #endif
21 #include "lj_lex.h"
22 #include "lj_bcdump.h"
23 #include "lj_state.h"
24 #include "lj_strfmt.h"
25
26 /* Reuse some lexer fields for our own purposes. */
27 #define bcread_flags(ls) ls->level
28 #define bcread_swap(ls) \
29 ((bcread_flags(ls) & BCDUMP_F_BE) != LJ_BE*BCDUMP_F_BE)
30 #define bcread_oldtop(L, ls) restorestack(L, ls->lastline)
31 #define bcread_savetop(L, ls, top) \
32 ls->lastline = (BCLine)savestack(L, (top))
33
34 /* -- Input buffer handling ----------------------------------------------- */
35
36 /* Throw reader error. */
37 static LJ_NOINLINE void bcread_error(LexState *ls, ErrMsg em)
38 {
39 lua_State *L = ls->L;
40 const char *name = ls->chunkarg;
41 if (*name == BCDUMP_HEAD1) name = "(binary)";
42 else if (*name == '@' || *name == '=') name++;
43 lj_strfmt_pushf(L, "%s: %s", name, err2msg(em));
44 lj_err_throw(L, LUA_ERRSYNTAX);
45 }
46
47 /* Refill buffer. */
48 static LJ_NOINLINE void bcread_fill(LexState *ls, MSize len, int need)
49 {
50 lj_assertLS(len != 0, "empty refill");
51 if (len > LJ_MAX_BUF || ls->c < 0)
52 bcread_error(ls, LJ_ERR_BCBAD);
53 do {
54 const char *buf;
55 size_t sz;
56 char *p = ls->sb.b;
57 MSize n = (MSize)(ls->pe - ls->p);
58 if (n) { /* Copy remainder to buffer. */
59 if (sbuflen(&ls->sb)) { /* Move down in buffer. */
60 lj_assertLS(ls->pe == ls->sb.w, "bad buffer pointer");
61 if (ls->p != p) memmove(p, ls->p, n);
62 } else { /* Copy from buffer provided by reader. */
63 p = lj_buf_need(&ls->sb, len);
64 memcpy(p, ls->p, n);
65 }
66 ls->p = p;
67 ls->pe = p + n;
68 }
69 ls->sb.w = p + n;
70 buf = ls->rfunc(ls->L, ls->rdata, &sz); /* Get more data from reader. */
71 if (buf == NULL || sz == 0) { /* EOF? */
72 if (need) bcread_error(ls, LJ_ERR_BCBAD);
73 ls->c = -1; /* Only bad if we get called again. */
74 break;
75 }
76 if (sz >= LJ_MAX_BUF - n) lj_err_mem(ls->L);
77 if (n) { /* Append to buffer. */
78 n += (MSize)sz;
79 p = lj_buf_need(&ls->sb, n < len ? len : n);
80 memcpy(ls->sb.w, buf, sz);
81 ls->sb.w = p + n;
82 ls->p = p;
83 ls->pe = p + n;
84 } else { /* Return buffer provided by reader. */
85 ls->p = buf;
86 ls->pe = buf + sz;
87 }
88 } while ((MSize)(ls->pe - ls->p) < len);
89 }
90
91 /* Need a certain number of bytes. */
92 static LJ_AINLINE void bcread_need(LexState *ls, MSize len)
93 {
94 if (LJ_UNLIKELY((MSize)(ls->pe - ls->p) < len))
95 bcread_fill(ls, len, 1);
96 }
97
98 /* Want to read up to a certain number of bytes, but may need less. */
99 static LJ_AINLINE void bcread_want(LexState *ls, MSize len)
100 {
101 if (LJ_UNLIKELY((MSize)(ls->pe - ls->p) < len))
102 bcread_fill(ls, len, 0);
103 }
104
105 /* Return memory block from buffer. */
106 static LJ_AINLINE uint8_t *bcread_mem(LexState *ls, MSize len)
107 {
108 uint8_t *p = (uint8_t *)ls->p;
109 ls->p += len;
110 lj_assertLS(ls->p <= ls->pe, "buffer read overflow");
111 return p;
112 }
113
114 /* Copy memory block from buffer. */
115 static void bcread_block(LexState *ls, void *q, MSize len)
116 {
117 memcpy(q, bcread_mem(ls, len), len);
118 }
119
120 /* Read byte from buffer. */
121 static LJ_AINLINE uint32_t bcread_byte(LexState *ls)
122 {
123 lj_assertLS(ls->p < ls->pe, "buffer read overflow");
124 return (uint32_t)(uint8_t)*ls->p++;
125 }
126
127 /* Read ULEB128 value from buffer. */
128 static LJ_AINLINE uint32_t bcread_uleb128(LexState *ls)
129 {
130 uint32_t v = lj_buf_ruleb128(&ls->p);
131 lj_assertLS(ls->p <= ls->pe, "buffer read overflow");
132 return v;
133 }
134
135 /* Read top 32 bits of 33 bit ULEB128 value from buffer. */
136 static uint32_t bcread_uleb128_33(LexState *ls)
137 {
138 const uint8_t *p = (const uint8_t *)ls->p;
139 uint32_t v = (*p++ >> 1);
140 if (LJ_UNLIKELY(v >= 0x40)) {
141 int sh = -1;
142 v &= 0x3f;
143 do {
144 v |= ((*p & 0x7f) << (sh += 7));
145 } while (*p++ >= 0x80);
146 }
147 ls->p = (char *)p;
148 lj_assertLS(ls->p <= ls->pe, "buffer read overflow");
149 return v;
150 }
151
152 /* -- Bytecode reader ----------------------------------------------------- */
153
154 /* Read debug info of a prototype. */
155 static void bcread_dbg(LexState *ls, GCproto *pt, MSize sizedbg)
156 {
157 void *lineinfo = (void *)proto_lineinfo(pt);
158 bcread_block(ls, lineinfo, sizedbg);
159 /* Swap lineinfo if the endianess differs. */
160 if (bcread_swap(ls) && pt->numline >= 256) {
161 MSize i, n = pt->sizebc-1;
162 if (pt->numline < 65536) {
163 uint16_t *p = (uint16_t *)lineinfo;
164 for (i = 0; i < n; i++) p[i] = (uint16_t)((p[i] >> 8)|(p[i] << 8));
165 } else {
166 uint32_t *p = (uint32_t *)lineinfo;
167 for (i = 0; i < n; i++) p[i] = lj_bswap(p[i]);
168 }
169 }
170 }
171
172 /* Find pointer to varinfo. */
173 static const void *bcread_varinfo(GCproto *pt)
174 {
175 const uint8_t *p = proto_uvinfo(pt);
176 MSize n = pt->sizeuv;
177 if (n) while (*p++ || --n) ;
178 return p;
179 }
180
181 /* Read a single constant key/value of a template table. */
182 static void bcread_ktabk(LexState *ls, TValue *o)
183 {
184 MSize tp = bcread_uleb128(ls);
185 if (tp >= BCDUMP_KTAB_STR) {
186 MSize len = tp - BCDUMP_KTAB_STR;
187 const char *p = (const char *)bcread_mem(ls, len);
188 setstrV(ls->L, o, lj_str_new(ls->L, p, len));
189 } else if (tp == BCDUMP_KTAB_INT) {
190 setintV(o, (int32_t)bcread_uleb128(ls));
191 } else if (tp == BCDUMP_KTAB_NUM) {
192 o->u32.lo = bcread_uleb128(ls);
193 o->u32.hi = bcread_uleb128(ls);
194 } else {
195 lj_assertLS(tp <= BCDUMP_KTAB_TRUE, "bad constant type %d", tp);
196 setpriV(o, ~tp);
197 }
198 }
199
200 /* Read a template table. */
201 static GCtab *bcread_ktab(LexState *ls)
202 {
203 MSize narray = bcread_uleb128(ls);
204 MSize nhash = bcread_uleb128(ls);
205 GCtab *t = lj_tab_new(ls->L, narray, hsize2hbits(nhash));
206 if (narray) { /* Read array entries. */
207 MSize i;
208 TValue *o = tvref(t->array);
209 for (i = 0; i < narray; i++, o++)
210 bcread_ktabk(ls, o);
211 }
212 if (nhash) { /* Read hash entries. */
213 MSize i;
214 for (i = 0; i < nhash; i++) {
215 TValue key;
216 bcread_ktabk(ls, &key);
217 lj_assertLS(!tvisnil(&key), "nil key");
218 bcread_ktabk(ls, lj_tab_set(ls->L, t, &key));
219 }
220 }
221 return t;
222 }
223
224 /* Read GC constants of a prototype. */
225 static void bcread_kgc(LexState *ls, GCproto *pt, MSize sizekgc)
226 {
227 MSize i;
228 GCRef *kr = mref(pt->k, GCRef) - (ptrdiff_t)sizekgc;
229 for (i = 0; i < sizekgc; i++, kr++) {
230 MSize tp = bcread_uleb128(ls);
231 if (tp >= BCDUMP_KGC_STR) {
232 MSize len = tp - BCDUMP_KGC_STR;
233 const char *p = (const char *)bcread_mem(ls, len);
234 setgcref(*kr, obj2gco(lj_str_new(ls->L, p, len)));
235 } else if (tp == BCDUMP_KGC_TAB) {
236 setgcref(*kr, obj2gco(bcread_ktab(ls)));
237 #if LJ_HASFFI
238 } else if (tp != BCDUMP_KGC_CHILD) {
239 CTypeID id = tp == BCDUMP_KGC_COMPLEX ? CTID_COMPLEX_DOUBLE :
240 tp == BCDUMP_KGC_I64 ? CTID_INT64 : CTID_UINT64;
241 CTSize sz = tp == BCDUMP_KGC_COMPLEX ? 16 : 8;
242 GCcdata *cd = lj_cdata_new_(ls->L, id, sz);
243 TValue *p = (TValue *)cdataptr(cd);
244 setgcref(*kr, obj2gco(cd));
245 p[0].u32.lo = bcread_uleb128(ls);
246 p[0].u32.hi = bcread_uleb128(ls);
247 if (tp == BCDUMP_KGC_COMPLEX) {
248 p[1].u32.lo = bcread_uleb128(ls);
249 p[1].u32.hi = bcread_uleb128(ls);
250 }
251 #endif
252 } else {
253 lua_State *L = ls->L;
254 lj_assertLS(tp == BCDUMP_KGC_CHILD, "bad constant type %d", tp);
255 if (L->top <= bcread_oldtop(L, ls)) /* Stack underflow? */
256 bcread_error(ls, LJ_ERR_BCBAD);
257 L->top--;
258 setgcref(*kr, obj2gco(protoV(L->top)));
259 }
260 }
261 }
262
263 /* Read number constants of a prototype. */
264 static void bcread_knum(LexState *ls, GCproto *pt, MSize sizekn)
265 {
266 MSize i;
267 TValue *o = mref(pt->k, TValue);
268 for (i = 0; i < sizekn; i++, o++) {
269 int isnum = (ls->p[0] & 1);
270 uint32_t lo = bcread_uleb128_33(ls);
271 if (isnum) {
272 o->u32.lo = lo;
273 o->u32.hi = bcread_uleb128(ls);
274 } else {
275 setintV(o, lo);
276 }
277 }
278 }
279
280 /* Read bytecode instructions. */
281 static void bcread_bytecode(LexState *ls, GCproto *pt, MSize sizebc)
282 {
283 BCIns *bc = proto_bc(pt);
284 bc[0] = BCINS_AD((pt->flags & PROTO_VARARG) ? BC_FUNCV : BC_FUNCF,
285 pt->framesize, 0);
286 bcread_block(ls, bc+1, (sizebc-1)*(MSize)sizeof(BCIns));
287 /* Swap bytecode instructions if the endianess differs. */
288 if (bcread_swap(ls)) {
289 MSize i;
290 for (i = 1; i < sizebc; i++) bc[i] = lj_bswap(bc[i]);
291 }
292 }
293
294 /* Read upvalue refs. */
295 static void bcread_uv(LexState *ls, GCproto *pt, MSize sizeuv)
296 {
297 if (sizeuv) {
298 uint16_t *uv = proto_uv(pt);
299 bcread_block(ls, uv, sizeuv*2);
300 /* Swap upvalue refs if the endianess differs. */
301 if (bcread_swap(ls)) {
302 MSize i;
303 for (i = 0; i < sizeuv; i++)
304 uv[i] = (uint16_t)((uv[i] >> 8)|(uv[i] << 8));
305 }
306 }
307 }
308
309 /* Read a prototype. */
310 GCproto *lj_bcread_proto(LexState *ls)
311 {
312 GCproto *pt;
313 MSize framesize, numparams, flags, sizeuv, sizekgc, sizekn, sizebc, sizept;
314 MSize ofsk, ofsuv, ofsdbg;
315 MSize sizedbg = 0;
316 BCLine firstline = 0, numline = 0;
317
318 /* Read prototype header. */
319 flags = bcread_byte(ls);
320 numparams = bcread_byte(ls);
321 framesize = bcread_byte(ls);
322 sizeuv = bcread_byte(ls);
323 sizekgc = bcread_uleb128(ls);
324 sizekn = bcread_uleb128(ls);
325 sizebc = bcread_uleb128(ls) + 1;
326 if (!(bcread_flags(ls) & BCDUMP_F_STRIP)) {
327 sizedbg = bcread_uleb128(ls);
328 if (sizedbg) {
329 firstline = bcread_uleb128(ls);
330 numline = bcread_uleb128(ls);
331 }
332 }
333
334 /* Calculate total size of prototype including all colocated arrays. */
335 sizept = (MSize)sizeof(GCproto) +
336 sizebc*(MSize)sizeof(BCIns) +
337 sizekgc*(MSize)sizeof(GCRef);
338 sizept = (sizept + (MSize)sizeof(TValue)-1) & ~((MSize)sizeof(TValue)-1);
339 ofsk = sizept; sizept += sizekn*(MSize)sizeof(TValue);
340 ofsuv = sizept; sizept += ((sizeuv+1)&~1)*2;
341 ofsdbg = sizept; sizept += sizedbg;
342
343 /* Allocate prototype object and initialize its fields. */
344 pt = (GCproto *)lj_mem_newgco(ls->L, (MSize)sizept);
345 pt->gct = ~LJ_TPROTO;
346 pt->numparams = (uint8_t)numparams;
347 pt->framesize = (uint8_t)framesize;
348 pt->sizebc = sizebc;
349 setmref(pt->k, (char *)pt + ofsk);
350 setmref(pt->uv, (char *)pt + ofsuv);
351 pt->sizekgc = 0; /* Set to zero until fully initialized. */
352 pt->sizekn = sizekn;
353 pt->sizept = sizept;
354 pt->sizeuv = (uint8_t)sizeuv;
355 pt->flags = (uint8_t)flags;
356 pt->trace = 0;
357 setgcref(pt->chunkname, obj2gco(ls->chunkname));
358
359 /* Close potentially uninitialized gap between bc and kgc. */
360 *(uint32_t *)((char *)pt + ofsk - sizeof(GCRef)*(sizekgc+1)) = 0;
361
362 /* Read bytecode instructions and upvalue refs. */
363 bcread_bytecode(ls, pt, sizebc);
364 bcread_uv(ls, pt, sizeuv);
365
366 /* Read constants. */
367 bcread_kgc(ls, pt, sizekgc);
368 pt->sizekgc = sizekgc;
369 bcread_knum(ls, pt, sizekn);
370
371 /* Read and initialize debug info. */
372 pt->firstline = firstline;
373 pt->numline = numline;
374 if (sizedbg) {
375 MSize sizeli = (sizebc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
376 setmref(pt->lineinfo, (char *)pt + ofsdbg);
377 setmref(pt->uvinfo, (char *)pt + ofsdbg + sizeli);
378 bcread_dbg(ls, pt, sizedbg);
379 setmref(pt->varinfo, bcread_varinfo(pt));
380 } else {
381 setmref(pt->lineinfo, NULL);
382 setmref(pt->uvinfo, NULL);
383 setmref(pt->varinfo, NULL);
384 }
385 return pt;
386 }
387
388 /* Read and check header of bytecode dump. */
389 static int bcread_header(LexState *ls)
390 {
391 uint32_t flags;
392 bcread_want(ls, 3+5+5);
393 if (bcread_byte(ls) != BCDUMP_HEAD2 ||
394 bcread_byte(ls) != BCDUMP_HEAD3 ||
395 bcread_byte(ls) != BCDUMP_VERSION) return 0;
396 bcread_flags(ls) = flags = bcread_uleb128(ls);
397 if ((flags & ~(BCDUMP_F_KNOWN)) != 0) return 0;
398 if ((flags & BCDUMP_F_FR2) != LJ_FR2*BCDUMP_F_FR2) return 0;
399 if ((flags & BCDUMP_F_FFI)) {
400 #if LJ_HASFFI
401 lua_State *L = ls->L;
402 ctype_loadffi(L);
403 #else
404 return 0;
405 #endif
406 }
407 if ((flags & BCDUMP_F_STRIP)) {
408 ls->chunkname = lj_str_newz(ls->L, ls->chunkarg);
409 } else {
410 MSize len = bcread_uleb128(ls);
411 bcread_need(ls, len);
412 ls->chunkname = lj_str_new(ls->L, (const char *)bcread_mem(ls, len), len);
413 }
414 return 1; /* Ok. */
415 }
416
417 /* Read a bytecode dump. */
418 GCproto *lj_bcread(LexState *ls)
419 {
420 lua_State *L = ls->L;
421 lj_assertLS(ls->c == BCDUMP_HEAD1, "bad bytecode header");
422 bcread_savetop(L, ls, L->top);
423 lj_buf_reset(&ls->sb);
424 /* Check for a valid bytecode dump header. */
425 if (!bcread_header(ls))
426 bcread_error(ls, LJ_ERR_BCFMT);
427 for (;;) { /* Process all prototypes in the bytecode dump. */
428 GCproto *pt;
429 MSize len;
430 const char *startp;
431 /* Read length. */
432 if (ls->p < ls->pe && ls->p[0] == 0) { /* Shortcut EOF. */
433 ls->p++;
434 break;
435 }
436 bcread_want(ls, 5);
437 len = bcread_uleb128(ls);
438 if (!len) break; /* EOF */
439 bcread_need(ls, len);
440 startp = ls->p;
441 pt = lj_bcread_proto(ls);
442 if (ls->p != startp + len)
443 bcread_error(ls, LJ_ERR_BCBAD);
444 setprotoV(L, L->top, pt);
445 incr_top(L);
446 }
447 if ((ls->pe != ls->p && !ls->endmark) || L->top-1 != bcread_oldtop(L, ls))
448 bcread_error(ls, LJ_ERR_BCBAD);
449 /* Pop off last prototype. */
450 L->top--;
451 return protoV(L->top);
452 }
453