source/libs/luajit/LuaJIT-src/src/lj_bcread.c

   1 /*
   2 ** Bytecode reader.
   3 ** Copyright (C) 2005-2015 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   lua_assert(len != 0);
  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 = sbufB(&ls->sb);
  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         lua_assert(ls->pe == sbufP(&ls->sb));
  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     setsbufP(&ls->sb, 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 (n) {  /* Append to buffer. */
  77       n += (MSize)sz;
  78       p = lj_buf_need(&ls->sb, n < len ? len : n);
  79       memcpy(sbufP(&ls->sb), buf, sz);
  80       setsbufP(&ls->sb, p + n);
  81       ls->p = p;
  82       ls->pe = p + n;
  83     } else {  /* Return buffer provided by reader. */
  84       ls->p = buf;
  85       ls->pe = buf + sz;
  86     }
  87   } while (ls->p + len > ls->pe);
  88 }
  89
  90 /* Need a certain number of bytes. */
  91 static LJ_AINLINE void bcread_need(LexState *ls, MSize len)
  92 {
  93   if (LJ_UNLIKELY(ls->p + len > ls->pe))
  94     bcread_fill(ls, len, 1);
  95 }
  96
  97 /* Want to read up to a certain number of bytes, but may need less. */
  98 static LJ_AINLINE void bcread_want(LexState *ls, MSize len)
  99 {
 100   if (LJ_UNLIKELY(ls->p + len > ls->pe))
 101     bcread_fill(ls, len, 0);
 102 }
 103
 104 /* Return memory block from buffer. */
 105 static LJ_AINLINE uint8_t *bcread_mem(LexState *ls, MSize len)
 106 {
 107   uint8_t *p = (uint8_t *)ls->p;
 108   ls->p += len;
 109   lua_assert(ls->p <= ls->pe);
 110   return p;
 111 }
 112
 113 /* Copy memory block from buffer. */
 114 static void bcread_block(LexState *ls, void *q, MSize len)
 115 {
 116   memcpy(q, bcread_mem(ls, len), len);
 117 }
 118
 119 /* Read byte from buffer. */
 120 static LJ_AINLINE uint32_t bcread_byte(LexState *ls)
 121 {
 122   lua_assert(ls->p < ls->pe);
 123   return (uint32_t)(uint8_t)*ls->p++;
 124 }
 125
 126 /* Read ULEB128 value from buffer. */
 127 static LJ_AINLINE uint32_t bcread_uleb128(LexState *ls)
 128 {
 129   uint32_t v = lj_buf_ruleb128(&ls->p);
 130   lua_assert(ls->p <= ls->pe);
 131   return v;
 132 }
 133
 134 /* Read top 32 bits of 33 bit ULEB128 value from buffer. */
 135 static uint32_t bcread_uleb128_33(LexState *ls)
 136 {
 137   const uint8_t *p = (const uint8_t *)ls->p;
 138   uint32_t v = (*p++ >> 1);
 139   if (LJ_UNLIKELY(v >= 0x40)) {
 140     int sh = -1;
 141     v &= 0x3f;
 142     do {
 143      v |= ((*p & 0x7f) << (sh += 7));
 144    } while (*p++ >= 0x80);
 145   }
 146   ls->p = (char *)p;
 147   lua_assert(ls->p <= ls->pe);
 148   return v;
 149 }
 150
 151 /* -- Bytecode reader ----------------------------------------------------- */
 152
 153 /* Read debug info of a prototype. */
 154 static void bcread_dbg(LexState *ls, GCproto *pt, MSize sizedbg)
 155 {
 156   void *lineinfo = (void *)proto_lineinfo(pt);
 157   bcread_block(ls, lineinfo, sizedbg);
 158   /* Swap lineinfo if the endianess differs. */
 159   if (bcread_swap(ls) && pt->numline >= 256) {
 160     MSize i, n = pt->sizebc-1;
 161     if (pt->numline < 65536) {
 162       uint16_t *p = (uint16_t *)lineinfo;
 163       for (i = 0; i < n; i++) p[i] = (uint16_t)((p[i] >> 8)|(p[i] << 8));
 164     } else {
 165       uint32_t *p = (uint32_t *)lineinfo;
 166       for (i = 0; i < n; i++) p[i] = lj_bswap(p[i]);
 167     }
 168   }
 169 }
 170
 171 /* Find pointer to varinfo. */
 172 static const void *bcread_varinfo(GCproto *pt)
 173 {
 174   const uint8_t *p = proto_uvinfo(pt);
 175   MSize n = pt->sizeuv;
 176   if (n) while (*p++ || --n) ;
 177   return p;
 178 }
 179
 180 /* Read a single constant key/value of a template table. */
 181 static void bcread_ktabk(LexState *ls, TValue *o)
 182 {
 183   MSize tp = bcread_uleb128(ls);
 184   if (tp >= BCDUMP_KTAB_STR) {
 185     MSize len = tp - BCDUMP_KTAB_STR;
 186     const char *p = (const char *)bcread_mem(ls, len);
 187     setstrV(ls->L, o, lj_str_new(ls->L, p, len));
 188   } else if (tp == BCDUMP_KTAB_INT) {
 189     setintV(o, (int32_t)bcread_uleb128(ls));
 190   } else if (tp == BCDUMP_KTAB_NUM) {
 191     o->u32.lo = bcread_uleb128(ls);
 192     o->u32.hi = bcread_uleb128(ls);
 193   } else {
 194     lua_assert(tp <= BCDUMP_KTAB_TRUE);
 195     setpriV(o, ~tp);
 196   }
 197 }
 198
 199 /* Read a template table. */
 200 static GCtab *bcread_ktab(LexState *ls)
 201 {
 202   MSize narray = bcread_uleb128(ls);
 203   MSize nhash = bcread_uleb128(ls);
 204   GCtab *t = lj_tab_new(ls->L, narray, hsize2hbits(nhash));
 205   if (narray) {  /* Read array entries. */
 206     MSize i;
 207     TValue *o = tvref(t->array);
 208     for (i = 0; i < narray; i++, o++)
 209       bcread_ktabk(ls, o);
 210   }
 211   if (nhash) {  /* Read hash entries. */
 212     MSize i;
 213     for (i = 0; i < nhash; i++) {
 214       TValue key;
 215       bcread_ktabk(ls, &key);
 216       lua_assert(!tvisnil(&key));
 217       bcread_ktabk(ls, lj_tab_set(ls->L, t, &key));
 218     }
 219   }
 220   return t;
 221 }
 222
 223 /* Read GC constants of a prototype. */
 224 static void bcread_kgc(LexState *ls, GCproto *pt, MSize sizekgc)
 225 {
 226   MSize i;
 227   GCRef *kr = mref(pt->k, GCRef) - (ptrdiff_t)sizekgc;
 228   for (i = 0; i < sizekgc; i++, kr++) {
 229     MSize tp = bcread_uleb128(ls);
 230     if (tp >= BCDUMP_KGC_STR) {
 231       MSize len = tp - BCDUMP_KGC_STR;
 232       const char *p = (const char *)bcread_mem(ls, len);
 233       setgcref(*kr, obj2gco(lj_str_new(ls->L, p, len)));
 234     } else if (tp == BCDUMP_KGC_TAB) {
 235       setgcref(*kr, obj2gco(bcread_ktab(ls)));
 236 #if LJ_HASFFI
 237     } else if (tp != BCDUMP_KGC_CHILD) {
 238       CTypeID id = tp == BCDUMP_KGC_COMPLEX ? CTID_COMPLEX_DOUBLE :
 239                    tp == BCDUMP_KGC_I64 ? CTID_INT64 : CTID_UINT64;
 240       CTSize sz = tp == BCDUMP_KGC_COMPLEX ? 16 : 8;
 241       GCcdata *cd = lj_cdata_new_(ls->L, id, sz);
 242       TValue *p = (TValue *)cdataptr(cd);
 243       setgcref(*kr, obj2gco(cd));
 244       p[0].u32.lo = bcread_uleb128(ls);
 245       p[0].u32.hi = bcread_uleb128(ls);
 246       if (tp == BCDUMP_KGC_COMPLEX) {
 247         p[1].u32.lo = bcread_uleb128(ls);
 248         p[1].u32.hi = bcread_uleb128(ls);
 249       }
 250 #endif
 251     } else {
 252       lua_State *L = ls->L;
 253       lua_assert(tp == BCDUMP_KGC_CHILD);
 254       if (L->top <= bcread_oldtop(L, ls))  /* Stack underflow? */
 255         bcread_error(ls, LJ_ERR_BCBAD);
 256       L->top--;
 257       setgcref(*kr, obj2gco(protoV(L->top)));
 258     }
 259   }
 260 }
 261
 262 /* Read number constants of a prototype. */
 263 static void bcread_knum(LexState *ls, GCproto *pt, MSize sizekn)
 264 {
 265   MSize i;
 266   TValue *o = mref(pt->k, TValue);
 267   for (i = 0; i < sizekn; i++, o++) {
 268     int isnum = (ls->p[0] & 1);
 269     uint32_t lo = bcread_uleb128_33(ls);
 270     if (isnum) {
 271       o->u32.lo = lo;
 272       o->u32.hi = bcread_uleb128(ls);
 273     } else {
 274       setintV(o, lo);
 275     }
 276   }
 277 }
 278
 279 /* Read bytecode instructions. */
 280 static void bcread_bytecode(LexState *ls, GCproto *pt, MSize sizebc)
 281 {
 282   BCIns *bc = proto_bc(pt);
 283   bc[0] = BCINS_AD((pt->flags & PROTO_VARARG) ? BC_FUNCV : BC_FUNCF,
 284                    pt->framesize, 0);
 285   bcread_block(ls, bc+1, (sizebc-1)*(MSize)sizeof(BCIns));
 286   /* Swap bytecode instructions if the endianess differs. */
 287   if (bcread_swap(ls)) {
 288     MSize i;
 289     for (i = 1; i < sizebc; i++) bc[i] = lj_bswap(bc[i]);
 290   }
 291 }
 292
 293 /* Read upvalue refs. */
 294 static void bcread_uv(LexState *ls, GCproto *pt, MSize sizeuv)
 295 {
 296   if (sizeuv) {
 297     uint16_t *uv = proto_uv(pt);
 298     bcread_block(ls, uv, sizeuv*2);
 299     /* Swap upvalue refs if the endianess differs. */
 300     if (bcread_swap(ls)) {
 301       MSize i;
 302       for (i = 0; i < sizeuv; i++)
 303         uv[i] = (uint16_t)((uv[i] >> 8)|(uv[i] << 8));
 304     }
 305   }
 306 }
 307
 308 /* Read a prototype. */
 309 GCproto *lj_bcread_proto(LexState *ls)
 310 {
 311   GCproto *pt;
 312   MSize framesize, numparams, flags, sizeuv, sizekgc, sizekn, sizebc, sizept;
 313   MSize ofsk, ofsuv, ofsdbg;
 314   MSize sizedbg = 0;
 315   BCLine firstline = 0, numline = 0;
 316
 317   /* Read prototype header. */
 318   flags = bcread_byte(ls);
 319   numparams = bcread_byte(ls);
 320   framesize = bcread_byte(ls);
 321   sizeuv = bcread_byte(ls);
 322   sizekgc = bcread_uleb128(ls);
 323   sizekn = bcread_uleb128(ls);
 324   sizebc = bcread_uleb128(ls) + 1;
 325   if (!(bcread_flags(ls) & BCDUMP_F_STRIP)) {
 326     sizedbg = bcread_uleb128(ls);
 327     if (sizedbg) {
 328       firstline = bcread_uleb128(ls);
 329       numline = bcread_uleb128(ls);
 330     }
 331   }
 332
 333   /* Calculate total size of prototype including all colocated arrays. */
 334   sizept = (MSize)sizeof(GCproto) +
 335            sizebc*(MSize)sizeof(BCIns) +
 336            sizekgc*(MSize)sizeof(GCRef);
 337   sizept = (sizept + (MSize)sizeof(TValue)-1) & ~((MSize)sizeof(TValue)-1);
 338   ofsk = sizept; sizept += sizekn*(MSize)sizeof(TValue);
 339   ofsuv = sizept; sizept += ((sizeuv+1)&~1)*2;
 340   ofsdbg = sizept; sizept += sizedbg;
 341
 342   /* Allocate prototype object and initialize its fields. */
 343   pt = (GCproto *)lj_mem_newgco(ls->L, (MSize)sizept);
 344   pt->gct = ~LJ_TPROTO;
 345   pt->numparams = (uint8_t)numparams;
 346   pt->framesize = (uint8_t)framesize;
 347   pt->sizebc = sizebc;
 348   setmref(pt->k, (char *)pt + ofsk);
 349   setmref(pt->uv, (char *)pt + ofsuv);
 350   pt->sizekgc = 0;  /* Set to zero until fully initialized. */
 351   pt->sizekn = sizekn;
 352   pt->sizept = sizept;
 353   pt->sizeuv = (uint8_t)sizeuv;
 354   pt->flags = (uint8_t)flags;
 355   pt->trace = 0;
 356   setgcref(pt->chunkname, obj2gco(ls->chunkname));
 357
 358   /* Close potentially uninitialized gap between bc and kgc. */
 359   *(uint32_t *)((char *)pt + ofsk - sizeof(GCRef)*(sizekgc+1)) = 0;
 360
 361   /* Read bytecode instructions and upvalue refs. */
 362   bcread_bytecode(ls, pt, sizebc);
 363   bcread_uv(ls, pt, sizeuv);
 364
 365   /* Read constants. */
 366   bcread_kgc(ls, pt, sizekgc);
 367   pt->sizekgc = sizekgc;
 368   bcread_knum(ls, pt, sizekn);
 369
 370   /* Read and initialize debug info. */
 371   pt->firstline = firstline;
 372   pt->numline = numline;
 373   if (sizedbg) {
 374     MSize sizeli = (sizebc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
 375     setmref(pt->lineinfo, (char *)pt + ofsdbg);
 376     setmref(pt->uvinfo, (char *)pt + ofsdbg + sizeli);
 377     bcread_dbg(ls, pt, sizedbg);
 378     setmref(pt->varinfo, bcread_varinfo(pt));
 379   } else {
 380     setmref(pt->lineinfo, NULL);
 381     setmref(pt->uvinfo, NULL);
 382     setmref(pt->varinfo, NULL);
 383   }
 384   return pt;
 385 }
 386
 387 /* Read and check header of bytecode dump. */
 388 static int bcread_header(LexState *ls)
 389 {
 390   uint32_t flags;
 391   bcread_want(ls, 3+5+5);
 392   if (bcread_byte(ls) != BCDUMP_HEAD2 ||
 393       bcread_byte(ls) != BCDUMP_HEAD3 ||
 394       bcread_byte(ls) != BCDUMP_VERSION) return 0;
 395   bcread_flags(ls) = flags = bcread_uleb128(ls);
 396   if ((flags & ~(BCDUMP_F_KNOWN)) != 0) return 0;
 397   if ((flags & BCDUMP_F_FR2) != LJ_FR2*BCDUMP_F_FR2) return 0;
 398   if ((flags & BCDUMP_F_FFI)) {
 399 #if LJ_HASFFI
 400     lua_State *L = ls->L;
 401     if (!ctype_ctsG(G(L))) {
 402       ptrdiff_t oldtop = savestack(L, L->top);
 403       luaopen_ffi(L);  /* Load FFI library on-demand. */
 404       L->top = restorestack(L, oldtop);
 405     }
 406 #else
 407     return 0;
 408 #endif
 409   }
 410   if ((flags & BCDUMP_F_STRIP)) {
 411     ls->chunkname = lj_str_newz(ls->L, ls->chunkarg);
 412   } else {
 413     MSize len = bcread_uleb128(ls);
 414     bcread_need(ls, len);
 415     ls->chunkname = lj_str_new(ls->L, (const char *)bcread_mem(ls, len), len);
 416   }
 417   return 1;  /* Ok. */
 418 }
 419
 420 /* Read a bytecode dump. */
 421 GCproto *lj_bcread(LexState *ls)
 422 {
 423   lua_State *L = ls->L;
 424   lua_assert(ls->c == BCDUMP_HEAD1);
 425   bcread_savetop(L, ls, L->top);
 426   lj_buf_reset(&ls->sb);
 427   /* Check for a valid bytecode dump header. */
 428   if (!bcread_header(ls))
 429     bcread_error(ls, LJ_ERR_BCFMT);
 430   for (;;) {  /* Process all prototypes in the bytecode dump. */
 431     GCproto *pt;
 432     MSize len;
 433     const char *startp;
 434     /* Read length. */
 435     if (ls->p < ls->pe && ls->p[0] == 0) {  /* Shortcut EOF. */
 436       ls->p++;
 437       break;
 438     }
 439     bcread_want(ls, 5);
 440     len = bcread_uleb128(ls);
 441     if (!len) break;  /* EOF */
 442     bcread_need(ls, len);
 443     startp = ls->p;
 444     pt = lj_bcread_proto(ls);
 445     if (ls->p != startp + len)
 446       bcread_error(ls, LJ_ERR_BCBAD);
 447     setprotoV(L, L->top, pt);
 448     incr_top(L);
 449   }
 450   if ((int32_t)(2*(uint32_t)(ls->pe - ls->p)) > 0 ||
 451       L->top-1 != bcread_oldtop(L, ls))
 452     bcread_error(ls, LJ_ERR_BCBAD);
 453   /* Pop off last prototype. */
 454   L->top--;
 455   return protoV(L->top);
 456 }
 457