src/lj_bcwrite.c

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