1/*
2** Bytecode writer.
3** Copyright (C) 2005-2014 Mike Pall. See Copyright Notice in luajit.h
4*/
5
6#define lj_bcwrite_c
7#define LUA_CORE
8
9#include "lj_obj.h"
10#include "lj_gc.h"
11#include "lj_str.h"
12#include "lj_bc.h"
13#if LJ_HASFFI
14#include "lj_ctype.h"
15#endif
16#if LJ_HASJIT
17#include "lj_dispatch.h"
18#include "lj_jit.h"
19#endif
20#include "lj_bcdump.h"
21#include "lj_vm.h"
22
23/* Context for bytecode writer. */
24typedef struct BCWriteCtx {
25 SBuf sb; /* Output buffer. */
26 lua_State *L; /* Lua state. */
27 GCproto *pt; /* Root prototype. */
28 lua_Writer wfunc; /* Writer callback. */
29 void *wdata; /* Writer callback data. */
30 int strip; /* Strip debug info. */
31 int status; /* Status from writer callback. */
32} BCWriteCtx;
33
34/* -- Output buffer handling ---------------------------------------------- */
35
36/* Resize buffer if needed. */
37static LJ_NOINLINE void bcwrite_resize(BCWriteCtx *ctx, MSize len)
38{
39 MSize sz = ctx->sb.sz * 2;
40 while (ctx->sb.n + len > sz) sz = sz * 2;
41 lj_str_resizebuf(ctx->L, &ctx->sb, sz);
42}
43
44/* Need a certain amount of buffer space. */
45static LJ_AINLINE void bcwrite_need(BCWriteCtx *ctx, MSize len)
46{
47 if (LJ_UNLIKELY(ctx->sb.n + len > ctx->sb.sz))
48 bcwrite_resize(ctx, len);
49}
50
51/* Add memory block to buffer. */
52static void bcwrite_block(BCWriteCtx *ctx, const void *p, MSize len)
53{
54 uint8_t *q = (uint8_t *)(ctx->sb.buf + ctx->sb.n);
55 MSize i;
56 ctx->sb.n += len;
57 for (i = 0; i < len; i++) q[i] = ((uint8_t *)p)[i];
58}
59
60/* Add byte to buffer. */
61static LJ_AINLINE void bcwrite_byte(BCWriteCtx *ctx, uint8_t b)
62{
63 ctx->sb.buf[ctx->sb.n++] = b;
64}
65
66/* Add ULEB128 value to buffer. */
67static void bcwrite_uleb128(BCWriteCtx *ctx, uint32_t v)
68{
69 MSize n = ctx->sb.n;
70 uint8_t *p = (uint8_t *)ctx->sb.buf;
71 for (; v >= 0x80; v >>= 7)
72 p[n++] = (uint8_t)((v & 0x7f) | 0x80);
73 p[n++] = (uint8_t)v;
74 ctx->sb.n = n;
75}
76
77/* -- Bytecode writer ----------------------------------------------------- */
78
79/* Write a single constant key/value of a template table. */
80static void bcwrite_ktabk(BCWriteCtx *ctx, cTValue *o, int narrow)
81{
82 bcwrite_need(ctx, 1+10);
83 if (tvisstr(o)) {
84 const GCstr *str = strV(o);
85 MSize len = str->len;
86 bcwrite_need(ctx, 5+len);
87 bcwrite_uleb128(ctx, BCDUMP_KTAB_STR+len);
88 bcwrite_block(ctx, strdata(str), len);
89 } else if (tvisint(o)) {
90 bcwrite_byte(ctx, BCDUMP_KTAB_INT);
91 bcwrite_uleb128(ctx, intV(o));
92 } else if (tvisnum(o)) {
93 if (!LJ_DUALNUM && narrow) { /* Narrow number constants to integers. */
94 lua_Number num = numV(o);
95 int32_t k = lj_num2int(num);
96 if (num == (lua_Number)k) { /* -0 is never a constant. */
97 bcwrite_byte(ctx, BCDUMP_KTAB_INT);
98 bcwrite_uleb128(ctx, k);
99 return;
100 }
101 }
102 bcwrite_byte(ctx, BCDUMP_KTAB_NUM);
103 bcwrite_uleb128(ctx, o->u32.lo);
104 bcwrite_uleb128(ctx, o->u32.hi);
105 } else {
106 lua_assert(tvispri(o));
107 bcwrite_byte(ctx, BCDUMP_KTAB_NIL+~itype(o));
108 }
109}
110
111/* Write a template table. */
112static void bcwrite_ktab(BCWriteCtx *ctx, const GCtab *t)
113{
114 MSize narray = 0, nhash = 0;
115 if (t->asize > 0) { /* Determine max. length of array part. */
116 ptrdiff_t i;
117 TValue *array = tvref(t->array);
118 for (i = (ptrdiff_t)t->asize-1; i >= 0; i--)
119 if (!tvisnil(&array[i]))
120 break;
121 narray = (MSize)(i+1);
122 }
123 if (t->hmask > 0) { /* Count number of used hash slots. */
124 MSize i, hmask = t->hmask;
125 Node *node = noderef(t->node);
126 for (i = 0; i <= hmask; i++)
127 nhash += !tvisnil(&node[i].val);
128 }
129 /* Write number of array slots and hash slots. */
130 bcwrite_uleb128(ctx, narray);
131 bcwrite_uleb128(ctx, nhash);
132 if (narray) { /* Write array entries (may contain nil). */
133 MSize i;
134 TValue *o = tvref(t->array);
135 for (i = 0; i < narray; i++, o++)
136 bcwrite_ktabk(ctx, o, 1);
137 }
138 if (nhash) { /* Write hash entries. */
139 MSize i = nhash;
140 Node *node = noderef(t->node) + t->hmask;
141 for (;; node--)
142 if (!tvisnil(&node->val)) {
143 bcwrite_ktabk(ctx, &node->key, 0);
144 bcwrite_ktabk(ctx, &node->val, 1);
145 if (--i == 0) break;
146 }
147 }
148}
149
150/* Write GC constants of a prototype. */
151static void bcwrite_kgc(BCWriteCtx *ctx, GCproto *pt)
152{
153 MSize i, sizekgc = pt->sizekgc;
154 GCRef *kr = mref(pt->k, GCRef) - (ptrdiff_t)sizekgc;
155 for (i = 0; i < sizekgc; i++, kr++) {
156 GCobj *o = gcref(*kr);
157 MSize tp, need = 1;
158 /* Determine constant type and needed size. */
159 if (o->gch.gct == ~LJ_TSTR) {
160 tp = BCDUMP_KGC_STR + gco2str(o)->len;
161 need = 5+gco2str(o)->len;
162 } else if (o->gch.gct == ~LJ_TPROTO) {
163 lua_assert((pt->flags & PROTO_CHILD));
164 tp = BCDUMP_KGC_CHILD;
165#if LJ_HASFFI
166 } else if (o->gch.gct == ~LJ_TCDATA) {
167 CTypeID id = gco2cd(o)->ctypeid;
168 need = 1+4*5;
169 if (id == CTID_INT64) {
170 tp = BCDUMP_KGC_I64;
171 } else if (id == CTID_UINT64) {
172 tp = BCDUMP_KGC_U64;
173 } else {
174 lua_assert(id == CTID_COMPLEX_DOUBLE);
175 tp = BCDUMP_KGC_COMPLEX;
176 }
177#endif
178 } else {
179 lua_assert(o->gch.gct == ~LJ_TTAB);
180 tp = BCDUMP_KGC_TAB;
181 need = 1+2*5;
182 }
183 /* Write constant type. */
184 bcwrite_need(ctx, need);
185 bcwrite_uleb128(ctx, tp);
186 /* Write constant data (if any). */
187 if (tp >= BCDUMP_KGC_STR) {
188 bcwrite_block(ctx, strdata(gco2str(o)), gco2str(o)->len);
189 } else if (tp == BCDUMP_KGC_TAB) {
190 bcwrite_ktab(ctx, gco2tab(o));
191#if LJ_HASFFI
192 } else if (tp != BCDUMP_KGC_CHILD) {
193 cTValue *p = (TValue *)cdataptr(gco2cd(o));
194 bcwrite_uleb128(ctx, p[0].u32.lo);
195 bcwrite_uleb128(ctx, p[0].u32.hi);
196 if (tp == BCDUMP_KGC_COMPLEX) {
197 bcwrite_uleb128(ctx, p[1].u32.lo);
198 bcwrite_uleb128(ctx, p[1].u32.hi);
199 }
200#endif
201 }
202 }
203}
204
205/* Write number constants of a prototype. */
206static void bcwrite_knum(BCWriteCtx *ctx, GCproto *pt)
207{
208 MSize i, sizekn = pt->sizekn;
209 cTValue *o = mref(pt->k, TValue);
210 bcwrite_need(ctx, 10*sizekn);
211 for (i = 0; i < sizekn; i++, o++) {
212 int32_t k;
213 if (tvisint(o)) {
214 k = intV(o);
215 goto save_int;
216 } else {
217 /* Write a 33 bit ULEB128 for the int (lsb=0) or loword (lsb=1). */
218 if (!LJ_DUALNUM) { /* Narrow number constants to integers. */
219 lua_Number num = numV(o);
220 k = lj_num2int(num);
221 if (num == (lua_Number)k) { /* -0 is never a constant. */
222 save_int:
223 bcwrite_uleb128(ctx, 2*(uint32_t)k | ((uint32_t)k & 0x80000000u));
224 if (k < 0) {
225 char *p = &ctx->sb.buf[ctx->sb.n-1];
226 *p = (*p & 7) | ((k>>27) & 0x18);
227 }
228 continue;
229 }
230 }
231 bcwrite_uleb128(ctx, 1+(2*o->u32.lo | (o->u32.lo & 0x80000000u)));
232 if (o->u32.lo >= 0x80000000u) {
233 char *p = &ctx->sb.buf[ctx->sb.n-1];
234 *p = (*p & 7) | ((o->u32.lo>>27) & 0x18);
235 }
236 bcwrite_uleb128(ctx, o->u32.hi);
237 }
238 }
239}
240
241/* Write bytecode instructions. */
242static void bcwrite_bytecode(BCWriteCtx *ctx, GCproto *pt)
243{
244 MSize nbc = pt->sizebc-1; /* Omit the [JI]FUNC* header. */
245#if LJ_HASJIT
246 uint8_t *p = (uint8_t *)&ctx->sb.buf[ctx->sb.n];
247#endif
248 bcwrite_block(ctx, proto_bc(pt)+1, nbc*(MSize)sizeof(BCIns));
249#if LJ_HASJIT
250 /* Unpatch modified bytecode containing ILOOP/JLOOP etc. */
251 if ((pt->flags & PROTO_ILOOP) || pt->trace) {
252 jit_State *J = L2J(ctx->L);
253 MSize i;
254 for (i = 0; i < nbc; i++, p += sizeof(BCIns)) {
255 BCOp op = (BCOp)p[LJ_ENDIAN_SELECT(0, 3)];
256 if (op == BC_IFORL || op == BC_IITERL || op == BC_ILOOP ||
257 op == BC_JFORI) {
258 p[LJ_ENDIAN_SELECT(0, 3)] = (uint8_t)(op-BC_IFORL+BC_FORL);
259 } else if (op == BC_JFORL || op == BC_JITERL || op == BC_JLOOP) {
260 BCReg rd = p[LJ_ENDIAN_SELECT(2, 1)] + (p[LJ_ENDIAN_SELECT(3, 0)] << 8);
261 BCIns ins = traceref(J, rd)->startins;
262 p[LJ_ENDIAN_SELECT(0, 3)] = (uint8_t)(op-BC_JFORL+BC_FORL);
263 p[LJ_ENDIAN_SELECT(2, 1)] = bc_c(ins);
264 p[LJ_ENDIAN_SELECT(3, 0)] = bc_b(ins);
265 }
266 }
267 }
268#endif
269}
270
271/* Write prototype. */
272static void bcwrite_proto(BCWriteCtx *ctx, GCproto *pt)
273{
274 MSize sizedbg = 0;
275
276 /* Recursively write children of prototype. */
277 if ((pt->flags & PROTO_CHILD)) {
278 ptrdiff_t i, n = pt->sizekgc;
279 GCRef *kr = mref(pt->k, GCRef) - 1;
280 for (i = 0; i < n; i++, kr--) {
281 GCobj *o = gcref(*kr);
282 if (o->gch.gct == ~LJ_TPROTO)
283 bcwrite_proto(ctx, gco2pt(o));
284 }
285 }
286
287 /* Start writing the prototype info to a buffer. */
288 lj_str_resetbuf(&ctx->sb);
289 ctx->sb.n = 5; /* Leave room for final size. */
290 bcwrite_need(ctx, 4+6*5+(pt->sizebc-1)*(MSize)sizeof(BCIns)+pt->sizeuv*2);
291
292 /* Write prototype header. */
293 bcwrite_byte(ctx, (pt->flags & (PROTO_CHILD|PROTO_VARARG|PROTO_FFI)));
294 bcwrite_byte(ctx, pt->numparams);
295 bcwrite_byte(ctx, pt->framesize);
296 bcwrite_byte(ctx, pt->sizeuv);
297 bcwrite_uleb128(ctx, pt->sizekgc);
298 bcwrite_uleb128(ctx, pt->sizekn);
299 bcwrite_uleb128(ctx, pt->sizebc-1);
300 if (!ctx->strip) {
301 if (proto_lineinfo(pt))
302 sizedbg = pt->sizept - (MSize)((char *)proto_lineinfo(pt) - (char *)pt);
303 bcwrite_uleb128(ctx, sizedbg);
304 if (sizedbg) {
305 bcwrite_uleb128(ctx, pt->firstline);
306 bcwrite_uleb128(ctx, pt->numline);
307 }
308 }
309
310 /* Write bytecode instructions and upvalue refs. */
311 bcwrite_bytecode(ctx, pt);
312 bcwrite_block(ctx, proto_uv(pt), pt->sizeuv*2);
313
314 /* Write constants. */
315 bcwrite_kgc(ctx, pt);
316 bcwrite_knum(ctx, pt);
317
318 /* Write debug info, if not stripped. */
319 if (sizedbg) {
320 bcwrite_need(ctx, sizedbg);
321 bcwrite_block(ctx, proto_lineinfo(pt), sizedbg);
322 }
323
324 /* Pass buffer to writer function. */
325 if (ctx->status == 0) {
326 MSize n = ctx->sb.n - 5;
327 MSize nn = (lj_fls(n)+8)*9 >> 6;
328 ctx->sb.n = 5 - nn;
329 bcwrite_uleb128(ctx, n); /* Fill in final size. */
330 lua_assert(ctx->sb.n == 5);
331 ctx->status = ctx->wfunc(ctx->L, ctx->sb.buf+5-nn, nn+n, ctx->wdata);
332 }
333}
334
335/* Write header of bytecode dump. */
336static void bcwrite_header(BCWriteCtx *ctx)
337{
338 GCstr *chunkname = proto_chunkname(ctx->pt);
339 const char *name = strdata(chunkname);
340 MSize len = chunkname->len;
341 lj_str_resetbuf(&ctx->sb);
342 bcwrite_need(ctx, 5+5+len);
343 bcwrite_byte(ctx, BCDUMP_HEAD1);
344 bcwrite_byte(ctx, BCDUMP_HEAD2);
345 bcwrite_byte(ctx, BCDUMP_HEAD3);
346 bcwrite_byte(ctx, BCDUMP_VERSION);
347 bcwrite_byte(ctx, (ctx->strip ? BCDUMP_F_STRIP : 0) +
348 (LJ_BE ? BCDUMP_F_BE : 0) +
349 ((ctx->pt->flags & PROTO_FFI) ? BCDUMP_F_FFI : 0));
350 if (!ctx->strip) {
351 bcwrite_uleb128(ctx, len);
352 bcwrite_block(ctx, name, len);
353 }
354 ctx->status = ctx->wfunc(ctx->L, ctx->sb.buf, ctx->sb.n, ctx->wdata);
355}
356
357/* Write footer of bytecode dump. */
358static void bcwrite_footer(BCWriteCtx *ctx)
359{
360 if (ctx->status == 0) {
361 uint8_t zero = 0;
362 ctx->status = ctx->wfunc(ctx->L, &zero, 1, ctx->wdata);
363 }
364}
365
366/* Protected callback for bytecode writer. */
367static TValue *cpwriter(lua_State *L, lua_CFunction dummy, void *ud)
368{
369 BCWriteCtx *ctx = (BCWriteCtx *)ud;
370 UNUSED(dummy);
371 lj_str_resizebuf(L, &ctx->sb, 1024); /* Avoids resize for most prototypes. */
372 bcwrite_header(ctx);
373 bcwrite_proto(ctx, ctx->pt);
374 bcwrite_footer(ctx);
375 return NULL;
376}
377
378/* Write bytecode for a prototype. */
379int lj_bcwrite(lua_State *L, GCproto *pt, lua_Writer writer, void *data,
380 int strip)
381{
382 BCWriteCtx ctx;
383 int status;
384 ctx.L = L;
385 ctx.pt = pt;
386 ctx.wfunc = writer;
387 ctx.wdata = data;
388 ctx.strip = strip;
389 ctx.status = 0;
390 lj_str_initbuf(&ctx.sb);
391 status = lj_vm_cpcall(L, NULL, &ctx, cpwriter);
392 if (status == 0) status = ctx.status;
393 lj_str_freebuf(G(ctx.L), &ctx.sb);
394 return status;
395}
396
397