1 files changed, 167 insertions, 59 deletions

diff --git a/src/lj_parse.c b/src/lj_parse.c
index 992034eb..bd9d9a7a 100644
--- a/src/lj_parse.c
+++ b/src/lj_parse.c
@@ -12,6 +12,7 @@
 #include "lj_obj.h"
 #include "lj_gc.h"
 #include "lj_err.h"
+#include "lj_debug.h"
 #include "lj_str.h"
 #include "lj_tab.h"
 #include "lj_func.h"
@@ -1021,7 +1022,8 @@ static void var_new(LexState *ls, BCReg n, GCstr *name)
       lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
     lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
   }
-  lua_assert(lj_tab_getstr(fs->kt, name) != NULL);
+  lua_assert((uintptr_t)name < VARNAME__MAX ||
+             lj_tab_getstr(fs->kt, name) != NULL);
   /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
   setgcref(ls->vstack[vtop].name, obj2gco(name));
   fs->varmap[fs->nactvar+n] = (uint16_t)vtop;
@@ -1031,6 +1033,9 @@ static void var_new(LexState *ls, BCReg n, GCstr *name)
 #define var_new_lit(ls, n, v) \
   var_new(ls, (n), lj_parse_keepstr(ls, "" v, sizeof(v)-1))
 
+#define var_new_fixed(ls, n, vn) \
+  var_new(ls, (n), (GCstr *)(uintptr_t)(vn))
+
 /* Add local variables. */
 static void var_add(LexState *ls, BCReg nvars)
 {
@@ -1053,7 +1058,7 @@ static BCReg var_lookup_local(FuncState *fs, GCstr *n)
 {
   int i;
   for (i = fs->nactvar-1; i >= 0; i--) {
-    if (n == gco2str(gcref(var_get(fs->ls, fs, i).name)))
+    if (n == strref(var_get(fs->ls, fs, i).name))
       return (BCReg)i;
   }
   return (BCReg)-1;  /* Not found. */
@@ -1109,23 +1114,16 @@ static MSize var_lookup_(FuncState *fs, GCstr *name, ExpDesc *e, int first)
 
 /* -- Function state management ------------------------------------------- */
 
-/* NYI: compress debug info. */
-
-/* Fixup bytecode and lineinfo for prototype. */
-static void fs_fixup_bc(FuncState *fs, GCproto *pt, BCIns *bc, BCLine *lineinfo)
+/* Fixup bytecode for prototype. */
+static void fs_fixup_bc(FuncState *fs, GCproto *pt, BCIns *bc, MSize n)
 {
-  MSize i, n = fs->pc;
   BCInsLine *base = fs->bcbase;
-  setmref(pt->lineinfo, lineinfo);
+  MSize i;
   pt->sizebc = n;
-  bc[n] = ~0u;  /* Close potentially uninitialized gap between bc and kgc. */
   bc[0] = BCINS_AD((fs->flags & PROTO_IS_VARARG) ? BC_FUNCV : BC_FUNCF,
                    fs->framesize, 0);
-  lineinfo[0] = fs->linedefined;
-  for (i = 1; i < n; i++) {
+  for (i = 1; i < n; i++)
     bc[i] = base[i].ins;
-    lineinfo[i] = base[i].line;
-  }
 }
 
 /* Fixup constants for prototype. */
@@ -1189,20 +1187,138 @@ static void fs_fixup_uv(FuncState *fs, GCproto *pt, uint16_t *uv)
     uv[i] = fs->uvloc[i].slot;
 }
 
-/* Fixup debug info for prototype. */
-static void fs_fixup_dbg(FuncState *fs, GCproto *pt, VarInfo *vi, MSize sizevi)
+#ifndef LUAJIT_DISABLE_DEBUGINFO
+/* Prepare lineinfo for prototype. */
+static size_t fs_prep_line(FuncState *fs, BCLine numline)
+{
+  return (fs->pc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
+}
+
+/* Fixup lineinfo for prototype. */
+static void fs_fixup_line(FuncState *fs, GCproto *pt,
+                          void *lineinfo, BCLine numline)
+{
+  BCInsLine *base = fs->bcbase + 1;
+  BCLine first = fs->linedefined;
+  MSize i = 0, n = fs->pc-1;
+  pt->firstline = fs->linedefined;
+  pt->numline = numline;
+  setmref(pt->lineinfo, lineinfo);
+  if (LJ_LIKELY(numline < 256)) {
+    uint8_t *li = (uint8_t *)lineinfo;
+    do {
+      BCLine delta = base[i].line - first;
+      lua_assert(delta >= 0 && delta < 256);
+      li[i] = (uint8_t)delta;
+    } while (++i < n);
+  } else if (LJ_LIKELY(numline < 65536)) {
+    uint16_t *li = (uint16_t *)lineinfo;
+    do {
+      BCLine delta = base[i].line - first;
+      lua_assert(delta >= 0 && delta < 65536);
+      li[i] = (uint16_t)delta;
+    } while (++i < n);
+  } else {
+    uint32_t *li = (uint32_t *)lineinfo;
+    do {
+      BCLine delta = base[i].line - first;
+      lua_assert(delta >= 0);
+      li[i] = (uint32_t)delta;
+    } while (++i < n);
+  }
+}
+
+/* Resize buffer if needed. */
+static LJ_NOINLINE void fs_buf_resize(LexState *ls, MSize len)
+{
+  MSize sz = ls->sb.sz * 2;
+  while (ls->sb.n + len > sz) sz = sz * 2;
+  lj_str_resizebuf(ls->L, &ls->sb, sz);
+}
+
+static LJ_AINLINE void fs_buf_need(LexState *ls, MSize len)
+{
+  if (LJ_UNLIKELY(ls->sb.n + len > ls->sb.sz))
+    fs_buf_resize(ls, len);
+}
+
+/* Add string to buffer. */
+static void fs_buf_str(LexState *ls, const char *str, MSize len)
+{
+  char *p = ls->sb.buf + ls->sb.n;
+  MSize i;
+  ls->sb.n += len;
+  for (i = 0; i < len; i++) p[i] = str[i];
+}
+
+/* Add ULEB128 value to buffer. */
+static void fs_buf_uleb128(LexState *ls, uint32_t v)
+{
+  MSize n = ls->sb.n;
+  uint8_t *p = (uint8_t *)ls->sb.buf;
+  for (; v >= 0x80; v >>= 7)
+    p[n++] = (uint8_t)((v & 0x7f) | 0x80);
+  p[n++] = (uint8_t)v;
+  ls->sb.n = n;
+}
+
+/* Prepare variable info for prototype. */
+static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
 {
-  MSize i, n = fs->nuv;
-  GCRef *uvname = (GCRef *)((char *)vi + sizevi*sizeof(VarInfo));
   VarInfo *vstack = fs->ls->vstack;
-  setmref(pt->varinfo, vi);
-  setmref(pt->uvname, uvname);
-  pt->sizevarinfo = sizevi;
-  memcpy(vi, &vstack[fs->vbase], sizevi*sizeof(VarInfo));
-  for (i = 0; i < n; i++)
-    setgcref(uvname[i], gcref(vstack[fs->uvloc[i].vidx].name));
+  MSize i, n;
+  BCPos lastpc;
+  lj_str_resetbuf(&ls->sb);  /* Copy to temp. string buffer. */
+  /* Store upvalue names. */
+  for (i = 0, n = fs->nuv; i < n; i++) {
+    GCstr *s = strref(vstack[fs->uvloc[i].vidx].name);
+    MSize len = s->len+1;
+    fs_buf_need(ls, len);
+    fs_buf_str(ls, strdata(s), len);
+  }
+  *ofsvar = ls->sb.n;
+  vstack += fs->vbase;
+  lastpc = 0;
+  /* Store local variable names and compressed ranges. */
+  for (i = 0, n = ls->vtop - fs->vbase; i < n; i++) {
+    GCstr *s = strref(vstack[i].name);
+    BCPos startpc = vstack[i].startpc, endpc = vstack[i].endpc;
+    if ((uintptr_t)s < VARNAME__MAX) {
+      fs_buf_need(ls, 1 + 2*5);
+      ls->sb.buf[ls->sb.n++] = (uint8_t)(uintptr_t)s;
+    } else {
+      MSize len = s->len+1;
+      fs_buf_need(ls, len + 2*5);
+      fs_buf_str(ls, strdata(s), len);
+    }
+    fs_buf_uleb128(ls, startpc-lastpc);
+    fs_buf_uleb128(ls, endpc-startpc);
+    lastpc = startpc;
+  }
+  fs_buf_need(ls, 1);
+  ls->sb.buf[ls->sb.n++] = '\0';  /* Terminator for varinfo. */
+  return ls->sb.n;
 }
 
+/* Fixup variable info for prototype. */
+static void fs_fixup_var(LexState *ls, GCproto *pt, uint8_t *p, size_t ofsvar)
+{
+  setmref(pt->uvinfo, p);
+  setmref(pt->varinfo, (char *)p + ofsvar);
+  memcpy(p, ls->sb.buf, ls->sb.n);  /* Copy from temp. string buffer. */
+}
+#else
+
+/* Initialize with empty debug info, if disabled. */
+#define fs_prep_line(fs, numline)               (UNUSED(numline), 0)
+#define fs_fixup_line(fs, pt, li, numline) \
+  pt->firstline = pt->numline = 0, setmref((pt)->lineinfo, NULL)
+#define fs_prep_var(ls, fs, ofsvar)             (UNUSED(ofsvar), 0)
+#define fs_fixup_var(ls, pt, p, ofsvar) \
+  setmref((pt)->uvinfo, NULL), setmref((pt)->varinfo, NULL)
+
+#endif
+
 /* Check if bytecode op returns. */
 static int bcopisret(BCOp op)
 {
@@ -1253,8 +1369,8 @@ static GCproto *fs_finish(LexState *ls, BCLine line)
 {
   lua_State *L = ls->L;
   FuncState *fs = ls->fs;
-  MSize sizevi;
-  size_t sizept, ofsk, ofsuv, ofsdbg, ofsli;
+  BCLine numline = line - fs->linedefined;
+  size_t sizept, ofsk, ofsuv, ofsli, ofsdbg, ofsvar;
   GCproto *pt;
 
   /* Apply final fixups. */
@@ -1264,33 +1380,29 @@ static GCproto *fs_finish(LexState *ls, BCLine line)
 
   /* Calculate total size of prototype including all colocated arrays. */
   sizept = sizeof(GCproto) + fs->pc*sizeof(BCIns) + fs->nkgc*sizeof(GCRef);
-  sizept = (sizept + sizeof(lua_Number)-1) & ~(sizeof(lua_Number)-1);
-  ofsk = sizept;
-  sizept += fs->nkn*sizeof(lua_Number);
-  ofsuv = sizept;
-  sizept += ((fs->nuv+1)&~1)*2;
-  ofsdbg = sizept;
-  sizevi = ls->vtop - fs->vbase;
-  sizept += sizevi*sizeof(VarInfo) + fs->nuv*sizeof(GCRef);
-  ofsli = sizept;
-  sizept += fs->pc*sizeof(BCLine);
+  sizept = (sizept + sizeof(TValue)-1) & ~(sizeof(TValue)-1);
+  ofsk = sizept; sizept += fs->nkn*sizeof(TValue);
+  ofsuv = sizept; sizept += ((fs->nuv+1)&~1)*2;
+  ofsli = sizept; sizept += fs_prep_line(fs, numline);
+  ofsdbg = sizept; sizept += fs_prep_var(ls, fs, &ofsvar);
 
   /* Allocate prototype and initialize its fields. */
   pt = (GCproto *)lj_mem_newgco(L, (MSize)sizept);
   pt->gct = ~LJ_TPROTO;
   pt->sizept = (MSize)sizept;
-  setgcref(pt->chunkname, obj2gco(ls->chunkname));
   pt->trace = 0;
   pt->flags = fs->flags;
   pt->numparams = fs->numparams;
   pt->framesize = fs->framesize;
-  pt->lastlinedefined = line;
+  setgcref(pt->chunkname, obj2gco(ls->chunkname));
 
-  fs_fixup_bc(fs, pt, (BCIns *)((char *)pt + sizeof(GCproto)),
-                      (BCLine *)((char *)pt + ofsli));
+  /* Close potentially uninitialized gap between bc and kgc. */
+  *(uint32_t *)((char *)pt + ofsk - sizeof(GCRef)*(fs->nkgc+1)) = 0;
+  fs_fixup_bc(fs, pt, (BCIns *)((char *)pt + sizeof(GCproto)), fs->pc);
   fs_fixup_k(fs, pt, (void *)((char *)pt + ofsk));
   fs_fixup_uv(fs, pt, (uint16_t *)((char *)pt + ofsuv));
-  fs_fixup_dbg(fs, pt, (VarInfo *)((char *)pt + ofsdbg), sizevi);
+  fs_fixup_line(fs, pt, (void *)((char *)pt + ofsli), numline);
+  fs_fixup_var(ls, pt, (uint8_t *)((char *)pt + ofsdbg), ofsvar);
 
   lj_vmevent_send(L, BC,
     setprotoV(L, L->top++, pt);
@@ -1300,12 +1412,6 @@ static GCproto *fs_finish(LexState *ls, BCLine line)
   ls->vtop = fs->vbase;  /* Reset variable stack. */
   ls->fs = fs->prev;
   lua_assert(ls->fs != NULL || ls->token == TK_eof);
-  /* Re-anchor last string token to avoid GC. */
-  if (ls->token == TK_name || ls->token == TK_string) {
-    /* NOBARRIER: the key is new or kept alive. */
-    TValue *tv = lj_tab_setstr(ls->L, ls->fs->kt, strV(&ls->tokenval));
-    if (tvisnil(tv)) setboolV(tv, 1);
-  }
   return pt;
 }
 
@@ -1530,8 +1636,6 @@ static void parse_chunk(LexState *ls);
 static void parse_body(LexState *ls, ExpDesc *e, int needself, BCLine line)
 {
   FuncState fs, *pfs = ls->fs;
-  BCReg kidx;
-  BCLine lastline;
   GCproto *pt;
   ptrdiff_t oldbase = pfs->bcbase - ls->bcstack;
   fs_init(ls, &fs);
@@ -1541,19 +1645,19 @@ static void parse_body(LexState *ls, ExpDesc *e, int needself, BCLine line)
   fs.bclim = pfs->bclim - pfs->pc;
   bcemit_AD(&fs, BC_FUNCF, 0, 0);  /* Placeholder. */
   parse_chunk(ls);
-  lastline = ls->linenumber;
-  lex_match(ls, TK_end, TK_function, line);
-  pt = fs_finish(ls, lastline);
+  if (ls->token != TK_end) lex_match(ls, TK_end, TK_function, line);
+  pt = fs_finish(ls, (ls->lastline = ls->linenumber));
   pfs->bcbase = ls->bcstack + oldbase;  /* May have been reallocated. */
   pfs->bclim = (BCPos)(ls->sizebcstack - oldbase);
   /* Store new prototype in the constant array of the parent. */
-  kidx = const_gc(pfs, obj2gco(pt), LJ_TPROTO);
-  expr_init(e, VRELOCABLE, bcemit_AD(pfs, BC_FNEW, 0, kidx));
+  expr_init(e, VRELOCABLE,
+            bcemit_AD(pfs, BC_FNEW, 0, const_gc(pfs, obj2gco(pt), LJ_TPROTO)));
   if (!(pfs->flags & PROTO_HAS_FNEW)) {
     if (pfs->flags & PROTO_HAS_RETURN)
       pfs->flags |= PROTO_FIXUP_RETURN;
     pfs->flags |= PROTO_HAS_FNEW;
   }
+  lj_lex_next(ls);
 }
 
 /* Parse expression list. Last expression is left open. */
@@ -2146,9 +2250,9 @@ static void parse_for_num(LexState *ls, GCstr *varname, BCLine line)
   FuncScope bl;
   BCPos loop, loopend;
   /* Hidden control variables. */
-  var_new_lit(ls, FORL_IDX, "(for index)");
-  var_new_lit(ls, FORL_STOP, "(for limit)");
-  var_new_lit(ls, FORL_STEP, "(for step)");
+  var_new_fixed(ls, FORL_IDX, VARNAME_FOR_IDX);
+  var_new_fixed(ls, FORL_STOP, VARNAME_FOR_STOP);
+  var_new_fixed(ls, FORL_STEP, VARNAME_FOR_STEP);
   /* Visible copy of index variable. */
   var_new(ls, FORL_EXT, varname);
   lex_check(ls, '=');
@@ -2220,9 +2324,9 @@ static void parse_for_iter(LexState *ls, GCstr *indexname)
   FuncScope bl;
   int isnext;
   /* Hidden control variables. */
-  var_new_lit(ls, nvars++, "(for generator)");
-  var_new_lit(ls, nvars++, "(for state)");
-  var_new_lit(ls, nvars++, "(for control)");
+  var_new_fixed(ls, nvars++, VARNAME_FOR_GEN);
+  var_new_fixed(ls, nvars++, VARNAME_FOR_STATE);
+  var_new_fixed(ls, nvars++, VARNAME_FOR_CTL);
   /* Visible variables returned from iterator. */
   var_new(ls, nvars++, indexname);
   while (lex_opt(ls, ','))
@@ -2374,7 +2478,11 @@ GCproto *lj_parse(LexState *ls)
   FuncState fs;
   GCproto *pt;
   lua_State *L = ls->L;
+#ifdef LUAJIT_DISABLE_DEBUGINFO
+  ls->chunkname = lj_str_newlit(L, "=");
+#else
   ls->chunkname = lj_str_newz(L, ls->chunkarg);
+#endif
   setstrV(L, L->top, ls->chunkname);  /* Anchor chunkname string. */
   incr_top(L);
   ls->level = 0;