root/lj_bcwrite.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. bcwrite_ktabk
  2. bcwrite_ktab
  3. bcwrite_kgc
  4. bcwrite_knum
  5. bcwrite_bytecode
  6. bcwrite_proto
  7. bcwrite_header
  8. bcwrite_footer
  9. cpwriter
  10. lj_bcwrite

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

/* [<][>][^][v][top][bottom][index][help] */