commit 1c40ff9faafed620aa0458b397bcbfbe19e0f663
parent 7538f3886dfa091d661c56e48ebb1578ced8e467
Author: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date: Tue, 17 Dec 2024 11:22:55 -0300
Scanner and parser use different tables for constants
Moreover, each function being parsed has its own table.
The code is cleaner when each table is used for one specific purpose:
The scanner uses its table to anchor and unify strings, mapping strings
to themselves; the parser uses it to reuse constants in the code,
mapping constants to their indices in the constant table. A different
table for each task avoids false collisions.
Diffstat:
6 files changed, 20 insertions(+), 28 deletions(-)
diff --git a/lcode.c b/lcode.c
@@ -563,13 +563,13 @@ static int addk (FuncState *fs, Proto *f, TValue *v) {
static int k2proto (FuncState *fs, TValue *key, TValue *v) {
TValue val;
Proto *f = fs->f;
- int tag = luaH_get(fs->ls->h, key, &val); /* query scanner table */
+ int tag = luaH_get(fs->kcache, key, &val); /* query scanner table */
int k;
- if (tag == LUA_VNUMINT) { /* is there an index there? */
+ if (!tagisempty(tag)) { /* is there an index there? */
k = cast_int(ivalue(&val));
+ lua_assert(k < fs->nk);
/* correct value? (warning: must distinguish floats from integers!) */
- if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) &&
- luaV_rawequalobj(&f->k[k], v))
+ if (ttypetag(&f->k[k]) == ttypetag(v) && luaV_rawequalobj(&f->k[k], v))
return k; /* reuse index */
}
/* constant not found; create a new entry */
@@ -577,7 +577,7 @@ static int k2proto (FuncState *fs, TValue *key, TValue *v) {
/* cache for reuse; numerical value does not need GC barrier;
table has no metatable, so it does not need to invalidate cache */
setivalue(&val, k);
- luaH_set(fs->ls->L, fs->ls->h, key, &val);
+ luaH_set(fs->ls->L, fs->kcache, key, &val);
return k;
}
@@ -659,7 +659,7 @@ static int nilK (FuncState *fs) {
TValue k, v;
setnilvalue(&v);
/* cannot use nil as key; instead use table itself to represent nil */
- sethvalue(fs->ls->L, &k, fs->ls->h);
+ sethvalue(fs->ls->L, &k, fs->kcache);
return k2proto(fs, &k, &v);
}
diff --git a/llex.c b/llex.c
@@ -130,18 +130,15 @@ l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
** Creates a new string and anchors it in scanner's table so that it
** will not be collected until the end of the compilation; by that time
** it should be anchored somewhere. It also internalizes long strings,
-** ensuring there is only one copy of each unique string. The table
-** here is used as a set: the string enters as the key, while its value
-** is irrelevant. We use the string itself as the value only because it
-** is a TValue readily available. Later, the code generation can change
-** this value.
+** ensuring there is only one copy of each unique string.
*/
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
lua_State *L = ls->L;
TString *ts = luaS_newlstr(L, str, l); /* create new string */
- TString *oldts = luaH_getstrkey(ls->h, ts);
- if (oldts != NULL) /* string already present? */
- return oldts; /* use it */
+ TValue oldts;
+ int tag = luaH_getstr(ls->h, ts, &oldts);
+ if (!tagisempty(tag)) /* string already present? */
+ return tsvalue(&oldts); /* use stored value */
else { /* create a new entry */
TValue *stv = s2v(L->top.p++); /* reserve stack space for string */
setsvalue(L, stv, ts); /* temporarily anchor the string */
@@ -149,8 +146,8 @@ TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
/* table is not a metatable, so it does not need to invalidate cache */
luaC_checkGC(L);
L->top.p--; /* remove string from stack */
+ return ts;
}
- return ts;
}
diff --git a/lparser.c b/lparser.c
@@ -737,6 +737,7 @@ static void codeclosure (LexState *ls, expdesc *v) {
static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
+ lua_State *L = ls->L;
Proto *f = fs->f;
fs->prev = ls->fs; /* linked list of funcstates */
fs->ls = ls;
@@ -757,8 +758,11 @@ static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
fs->firstlabel = ls->dyd->label.n;
fs->bl = NULL;
f->source = ls->source;
- luaC_objbarrier(ls->L, f, f->source);
+ luaC_objbarrier(L, f, f->source);
f->maxstacksize = 2; /* registers 0/1 are always valid */
+ fs->kcache = luaH_new(L); /* create table for function */
+ sethvalue2s(L, L->top.p, fs->kcache); /* anchor it */
+ luaD_inctop(L);
enterblock(fs, bl, 0);
}
@@ -780,6 +784,7 @@ static void close_func (LexState *ls) {
luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar);
luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
ls->fs = fs->prev;
+ L->top.p--; /* pop kcache table */
luaC_checkGC(L);
}
diff --git a/lparser.h b/lparser.h
@@ -146,6 +146,7 @@ typedef struct FuncState {
struct FuncState *prev; /* enclosing function */
struct LexState *ls; /* lexical state */
struct BlockCnt *bl; /* chain of current blocks */
+ Table *kcache; /* cache for reusing constants */
int pc; /* next position to code (equivalent to 'ncode') */
int lasttarget; /* 'label' of last 'jump label' */
int previousline; /* last line that was saved in 'lineinfo' */
diff --git a/ltable.c b/ltable.c
@@ -962,7 +962,7 @@ lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res) {
*/
const TValue *luaH_Hgetshortstr (Table *t, TString *key) {
Node *n = hashstr(t, key);
- lua_assert(key->tt == LUA_VSHRSTR);
+ lua_assert(strisshr(key));
for (;;) { /* check whether 'key' is somewhere in the chain */
if (keyisshrstr(n) && eqshrstr(keystrval(n), key))
return gval(n); /* that's it */
@@ -997,15 +997,6 @@ lu_byte luaH_getstr (Table *t, TString *key, TValue *res) {
}
-TString *luaH_getstrkey (Table *t, TString *key) {
- const TValue *o = Hgetstr(t, key);
- if (!isabstkey(o)) /* string already present? */
- return keystrval(nodefromval(o)); /* get saved copy */
- else
- return NULL;
-}
-
-
/*
** main search function
*/
diff --git a/ltable.h b/ltable.h
@@ -154,8 +154,6 @@ LUAI_FUNC lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res);
/* Special get for metamethods */
LUAI_FUNC const TValue *luaH_Hgetshortstr (Table *t, TString *key);
-LUAI_FUNC TString *luaH_getstrkey (Table *t, TString *key);
-
LUAI_FUNC int luaH_psetint (Table *t, lua_Integer key, TValue *val);
LUAI_FUNC int luaH_psetshortstr (Table *t, TString *key, TValue *val);
LUAI_FUNC int luaH_psetstr (Table *t, TString *key, TValue *val);
