/* Parse a number literal. */
static void lex_number(LexState *ls)
{
StrScanFmt fmt;
TValue *tv = &ls->tokenval;
int c, xp = 'e';
if (ls->current == '-' || ls->current == '+') {
save_and_next(ls);
}
if ((c = ls->current) == '0') {
save_and_next(ls);
if ((ls->current | 0x20) == 'x') xp = 'p';
}
while (lj_char_isident(ls->current) || ls->current == '.' ||
((ls->current == '-' || ls->current == '+') && (c | 0x20) == xp)) {
c = ls->current;
save_and_next(ls);
}
save(ls, '\0');
fmt = lj_strscan_scan((const uint8_t *)ls->sb.buf, tv,
(LJ_DUALNUM ? STRSCAN_OPT_TOINT : STRSCAN_OPT_TONUM) |
(LJ_HASFFI ? (STRSCAN_OPT_LL|STRSCAN_OPT_IMAG) : 0));
ls->token = TK_number;
if (LJ_DUALNUM && fmt == STRSCAN_INT) {
setitype(tv, LJ_TISNUM);
} else if (fmt == STRSCAN_NUM) {
/* Already in correct format. */
#if LJ_HASFFI
} else if (fmt != STRSCAN_ERROR) {
lua_State *L = ls->L;
GCcdata *cd;
lua_assert(fmt == STRSCAN_I64 || fmt == STRSCAN_U64 || fmt == STRSCAN_IMAG);
if (!ctype_ctsG(G(L))) {
ptrdiff_t oldtop = savestack(L, L->top);
luaopen_ffi(L); /* Load FFI library on-demand. */
L->top = restorestack(L, oldtop);
}
if (fmt == STRSCAN_IMAG) {
cd = lj_cdata_new_(L, CTID_COMPLEX_DOUBLE, 2*sizeof(double));
((double *)cdataptr(cd))[0] = 0;
((double *)cdataptr(cd))[1] = numV(tv);
} else {
cd = lj_cdata_new_(L, fmt==STRSCAN_I64 ? CTID_INT64 : CTID_UINT64, 8);
*(uint64_t *)cdataptr(cd) = tv->u64;
}
lj_parse_keepcdata(ls, tv, cd);
#endif
} else {
lua_assert(fmt == STRSCAN_ERROR);
lj_lex_error(ls, TK_number, LJ_ERR_XNUMBER);
}
}
/* Check first argument for a C type and returns its ID. */
static CTypeID ffi_checkctype(lua_State *L, CTState *cts, TValue *param)
{
TValue *o = L->base;
if (!(o < L->top)) {
err_argtype:
lj_err_argtype(L, 1, "C type");
}
if (tvisstr(o)) { /* Parse an abstract C type declaration. */
GCstr *s = strV(o);
CPState cp;
int errcode;
cp.L = L;
cp.cts = cts;
cp.srcname = strdata(s);
cp.p = strdata(s);
cp.param = param;
cp.mode = CPARSE_MODE_ABSTRACT|CPARSE_MODE_NOIMPLICIT;
errcode = lj_cparse(&cp);
if (errcode) lj_err_throw(L, errcode); /* Propagate errors. */
return cp.val.id;
} else {
GCcdata *cd;
if (!tviscdata(o)) goto err_argtype;
if (param && param < L->top) lj_err_arg(L, 1, LJ_ERR_FFI_NUMPARAM);
cd = cdataV(o);
return cd->ctypeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) : cd->ctypeid;
}
}
static int bit_result64(lua_State *L, CTypeID id, uint64_t x)
{
GCcdata *cd = lj_cdata_new_(L, id, 8);
*(uint64_t *)cdataptr(cd) = x;
setcdataV(L, L->base-1, cd);
return FFH_RES(1);
}
/* Allocate a new C data object holding a reference to another object. */
GCcdata *lj_cdata_newref(CTState *cts, const void *p, CTypeID id)
{
CTypeID refid = lj_ctype_intern(cts, CTINFO_REF(id), CTSIZE_PTR);
GCcdata *cd = lj_cdata_new(cts, refid, CTSIZE_PTR);
*(const void **)cdataptr(cd) = p;
return cd;
}
/* Specialize to the CTypeID held by a cdata constructor. */
static CTypeID crec_constructor(jit_State *J, GCcdata *cd, TRef tr)
{
CTypeID id;
lua_assert(tref_iscdata(tr) && cd->typeid == CTID_CTYPEID);
id = *(CTypeID *)cdataptr(cd);
tr = emitir(IRT(IR_ADD, IRT_PTR), tr, lj_ir_kintp(J, sizeof(GCcdata)));
tr = emitir(IRT(IR_XLOAD, IRT_INT), tr, 0);
emitir(IRTG(IR_EQ, IRT_INT), tr, lj_ir_kint(J, (int32_t)id));
return id;
}
/* Parse a number literal. */
static void lex_number(LexState *ls, TValue *tv)
{
int c;
lua_assert(lj_char_isdigit(ls->current));
do {
c = ls->current;
save_and_next(ls);
} while (lj_char_isident(ls->current) || ls->current == '.' ||
((ls->current == '-' || ls->current == '+') &&
((c & ~0x20) == 'E' || (c & ~0x20) == 'P')));
#if LJ_HASFFI
c &= ~0x20;
if ((c == 'I' || c == 'L' || c == 'U') && !ctype_ctsG(G(ls->L)))
lex_loadffi(ls->L);
if (c == 'I') /* Parse imaginary part of complex number. */
ls->sb.n--;
#endif
save(ls, '\0');
#if LJ_HASFFI
if ((c == 'L' || c == 'U') && lex_number64(ls, tv)) { /* Parse 64 bit int. */
return;
} else
#endif
if (lj_str_numconv(ls->sb.buf, tv)) {
#if LJ_HASFFI
if (c == 'I') { /* Return cdata holding a complex number. */
GCcdata *cd = lj_cdata_new_(ls->L, CTID_COMPLEX_DOUBLE, 2*sizeof(double));
((double *)cdataptr(cd))[0] = 0;
((double *)cdataptr(cd))[1] = numberVnum(tv);
lj_parse_keepcdata(ls, tv, cd);
}
#endif
if (LJ_DUALNUM && tvisnum(tv)) {
int32_t k = lj_num2int(numV(tv));
if ((lua_Number)k == numV(tv)) /* -0 cannot end up here. */
setintV(tv, k);
}
return;
}
lj_lex_error(ls, TK_number, LJ_ERR_XNUMBER);
}
/* Return pointer to object or its object data. */
const void * LJ_FASTCALL lj_obj_ptr(cTValue *o)
{
if (tvisudata(o))
return uddata(udataV(o));
else if (tvislightud(o))
return lightudV(o);
else if (LJ_HASFFI && tviscdata(o))
return cdataptr(cdataV(o));
else if (tvisgcv(o))
return gcV(o);
else
return NULL;
}
/* Index a C library by name. */
TValue *lj_clib_index(lua_State *L, CLibrary *cl, GCstr *name)
{
TValue *tv = lj_tab_setstr(L, cl->cache, name);
if (LJ_UNLIKELY(tvisnil(tv))) {
CTState *cts = ctype_cts(L);
CType *ct;
CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
if (!id)
lj_err_callerv(L, LJ_ERR_FFI_NODECL, strdata(name));
if (ctype_isconstval(ct->info)) {
CType *ctt = ctype_child(cts, ct);
lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
setnumV(tv, (lua_Number)(uint32_t)ct->size);
else
setintV(tv, (int32_t)ct->size);
} else {
const char *sym = clib_extsym(cts, ct, name);
#if LJ_TARGET_WINDOWS
DWORD oldwerr = GetLastError();
#endif
void *p = clib_getsym(cl, sym);
GCcdata *cd;
lua_assert(ctype_isfunc(ct->info) || ctype_isextern(ct->info));
#if LJ_TARGET_X86 && LJ_ABI_WIN
/* Retry with decorated name for fastcall/stdcall functions. */
if (!p && ctype_isfunc(ct->info)) {
CTInfo cconv = ctype_cconv(ct->info);
if (cconv == CTCC_FASTCALL || cconv == CTCC_STDCALL) {
CTSize sz = clib_func_argsize(cts, ct);
const char *symd = lj_str_pushf(L,
cconv == CTCC_FASTCALL ? "@%s@%d" : "_%s@%d",
sym, sz);
L->top--;
p = clib_getsym(cl, symd);
}
}
#endif
if (!p)
clib_error(L, "cannot resolve symbol " LUA_QS ": %s", sym);
#if LJ_TARGET_WINDOWS
SetLastError(oldwerr);
#endif
cd = lj_cdata_new(cts, id, CTSIZE_PTR);
*(void **)cdataptr(cd) = p;
setcdataV(L, tv, cd);
}
}
return tv;
}
void *
luaL_checkcdata(struct lua_State *L, int idx, uint32_t *ctypeid)
{
/* Calculate absolute value in the stack. */
if (idx < 0)
idx = lua_gettop(L) + idx + 1;
if (lua_type(L, idx) != LUA_TCDATA) {
*ctypeid = 0;
luaL_error(L, "expected cdata as %d argument", idx);
return NULL;
}
GCcdata *cd = cdataV(L->base + idx - 1);
*ctypeid = cd->ctypeid;
return (void *)cdataptr(cd);
}
/* Convert C type to TValue. Caveat: expects to get the raw CType! */
int lj_cconv_tv_ct(CTState *cts, CType *s, CTypeID sid,
TValue *o, uint8_t *sp)
{
CTInfo sinfo = s->info;
lua_assert(!ctype_isenum(sinfo));
if (ctype_isnum(sinfo)) {
if (!ctype_isbool(sinfo)) {
if (ctype_isinteger(sinfo) && s->size > 4) goto copyval;
if (LJ_DUALNUM && ctype_isinteger(sinfo)) {
int32_t i;
lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT32), s,
(uint8_t *)&i, sp, 0);
if ((sinfo & CTF_UNSIGNED) && i < 0)
setnumV(o, (lua_Number)(uint32_t)i);
else
setintV(o, i);
} else {
lj_cconv_ct_ct(cts, ctype_get(cts, CTID_DOUBLE), s,
(uint8_t *)&o->n, sp, 0);
/* Numbers are NOT canonicalized here! Beware of uninitialized data. */
lua_assert(tvisnum(o));
}
} else {
uint32_t b = ((*sp) & 1);
setboolV(o, b);
setboolV(&cts->g->tmptv2, b); /* Remember for trace recorder. */
}
return 0;
} else if (ctype_isrefarray(sinfo) || ctype_isstruct(sinfo)) {
/* Create reference. */
setcdataV(cts->L, o, lj_cdata_newref(cts, sp, sid));
return 1; /* Need GC step. */
} else {
GCcdata *cd;
CTSize sz;
copyval: /* Copy value. */
sz = s->size;
lua_assert(sz != CTSIZE_INVALID);
/* Attributes are stripped, qualifiers are kept (but mostly ignored). */
cd = lj_cdata_new(cts, ctype_typeid(cts, s), sz);
setcdataV(cts->L, o, cd);
memcpy(cdataptr(cd), sp, sz);
return 1; /* Need GC step. */
}
}
void *
luaL_pushcdata(struct lua_State *L, uint32_t ctypeid)
{
/*
* ctypeid is actually has CTypeID type.
* CTypeId is defined somewhere inside luajit's internal
* headers.
*/
assert(sizeof(ctypeid) == sizeof(CTypeID));
/* Code below is based on ffi_new() from luajit/src/lib_ffi.c */
/* Get information about ctype */
CTSize size;
CTState *cts = ctype_cts(L);
CTInfo info = lj_ctype_info(cts, ctypeid, &size);
/* Only numbers and pointers are implemented */
assert(ctype_isnum(info) || ctype_isptr(info));
(void) info;
assert(size != CTSIZE_INVALID);
/* Allocate a new cdata */
GCcdata *cd = lj_cdata_new(cts, ctypeid, size);
/* Anchor the uninitialized cdata with the stack. */
TValue *o = L->top;
setcdataV(L, o, cd);
incr_top(L);
/*
* lj_cconv_ct_init is omitted because it actually does memset()
* Caveats: cdata memory is returned uninitialized
*/
/*
* __gc is omitted because it is only needed for structs.
* Caveats: struct are not supported by this function.
* Please set finalizer using luaL_setcdatagc() if you need.
*/
lj_gc_check(L);
return cdataptr(cd);
}
static CTypeID argv2ctype(jit_State *J, TRef tr, cTValue *o)
{
if (tref_isstr(tr)) {
GCstr *s = strV(o);
CPState cp;
CTypeID oldtop;
/* Specialize to the string containing the C type declaration. */
emitir(IRTG(IR_EQ, IRT_STR), tr, lj_ir_kstr(J, s));
cp.L = J->L;
cp.cts = ctype_ctsG(J2G(J));
oldtop = cp.cts->top;
cp.srcname = strdata(s);
cp.p = strdata(s);
cp.mode = CPARSE_MODE_ABSTRACT|CPARSE_MODE_NOIMPLICIT;
if (lj_cparse(&cp) || cp.cts->top > oldtop) /* Avoid new struct defs. */
lj_trace_err(J, LJ_TRERR_BADTYPE);
return cp.val.id;
} else {
GCcdata *cd = argv2cdata(J, tr, o);
return cd->typeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) : cd->typeid;
}
}
/* Parse 64 bit integer. */
static int lex_number64(LexState *ls, TValue *tv)
{
uint64_t n = 0;
uint8_t *p = (uint8_t *)ls->sb.buf;
CTypeID id = CTID_INT64;
GCcdata *cd;
int numl = 0;
if (p[0] == '0' && (p[1] & ~0x20) == 'X') { /* Hexadecimal. */
p += 2;
if (!lj_char_isxdigit(*p)) return 0;
do {
n = n*16 + (*p & 15);
if (!lj_char_isdigit(*p)) n += 9;
p++;
} while (lj_char_isxdigit(*p));
} else { /* Decimal. */
if (!lj_char_isdigit(*p)) return 0;
do {
n = n*10 + (*p - '0');
p++;
} while (lj_char_isdigit(*p));
}
for (;;) { /* Parse suffixes. */
if ((*p & ~0x20) == 'U')
id = CTID_UINT64;
else if ((*p & ~0x20) == 'L')
numl++;
else
break;
p++;
}
if (numl != 2 || *p != '\0') return 0;
/* Return cdata holding a 64 bit integer. */
cd = lj_cdata_new_(ls->L, id, 8);
*(uint64_t *)cdataptr(cd) = n;
lj_parse_keepcdata(ls, tv, cd);
return 1; /* Ok. */
}
/* Unsink allocation from the trace exit state. Unsink sunk stores. */
static void snap_unsink(jit_State *J, GCtrace *T, ExitState *ex,
SnapNo snapno, BloomFilter rfilt,
IRIns *ir, TValue *o)
{
lua_assert(ir->o == IR_TNEW || ir->o == IR_TDUP ||
ir->o == IR_CNEW || ir->o == IR_CNEWI);
#if LJ_HASFFI
if (ir->o == IR_CNEW || ir->o == IR_CNEWI) {
CTState *cts = ctype_cts(J->L);
CTypeID id = (CTypeID)T->ir[ir->op1].i;
CTSize sz;
CTInfo info = lj_ctype_info(cts, id, &sz);
GCcdata *cd = lj_cdata_newx(cts, id, sz, info);
setcdataV(J->L, o, cd);
if (ir->o == IR_CNEWI) {
uint8_t *p = (uint8_t *)cdataptr(cd);
lua_assert(sz == 4 || sz == 8);
if (LJ_32 && sz == 8 && ir+1 < T->ir + T->nins && (ir+1)->o == IR_HIOP) {
snap_restoredata(T, ex, snapno, rfilt, (ir+1)->op2, LJ_LE?p+4:p, 4);
if (LJ_BE) p += 4;
sz = 4;
}
snap_restoredata(T, ex, snapno, rfilt, ir->op2, p, sz);
} else {
IRIns *irs, *irlast = &T->ir[T->snap[snapno].ref];
for (irs = ir+1; irs < irlast; irs++)
if (irs->r == RID_SINK && snap_sunk_store(T, ir, irs)) {
IRIns *iro = &T->ir[T->ir[irs->op1].op2];
uint8_t *p = (uint8_t *)cd;
CTSize szs;
lua_assert(irs->o == IR_XSTORE && T->ir[irs->op1].o == IR_ADD);
lua_assert(iro->o == IR_KINT || iro->o == IR_KINT64);
if (irt_is64(irs->t)) szs = 8;
else if (irt_isi8(irs->t) || irt_isu8(irs->t)) szs = 1;
else if (irt_isi16(irs->t) || irt_isu16(irs->t)) szs = 2;
else szs = 4;
if (LJ_64 && iro->o == IR_KINT64)
p += (int64_t)ir_k64(iro)->u64;
else
p += iro->i;
lua_assert(p >= (uint8_t *)cdataptr(cd) &&
p + szs <= (uint8_t *)cdataptr(cd) + sz);
if (LJ_32 && irs+1 < T->ir + T->nins && (irs+1)->o == IR_HIOP) {
lua_assert(szs == 4);
snap_restoredata(T, ex, snapno, rfilt, (irs+1)->op2, LJ_LE?p+4:p,4);
if (LJ_BE) p += 4;
}
snap_restoredata(T, ex, snapno, rfilt, irs->op2, p, szs);
}
}
} else
#endif
{
IRIns *irs, *irlast;
GCtab *t = ir->o == IR_TNEW ? lj_tab_new(J->L, ir->op1, ir->op2) :
lj_tab_dup(J->L, ir_ktab(&T->ir[ir->op1]));
settabV(J->L, o, t);
irlast = &T->ir[T->snap[snapno].ref];
for (irs = ir+1; irs < irlast; irs++)
if (irs->r == RID_SINK && snap_sunk_store(T, ir, irs)) {
IRIns *irk = &T->ir[irs->op1];
TValue tmp, *val;
lua_assert(irs->o == IR_ASTORE || irs->o == IR_HSTORE ||
irs->o == IR_FSTORE);
if (irk->o == IR_FREF) {
lua_assert(irk->op2 == IRFL_TAB_META);
snap_restoreval(J, T, ex, snapno, rfilt, irs->op2, &tmp);
/* NOBARRIER: The table is new (marked white). */
setgcref(t->metatable, obj2gco(tabV(&tmp)));
} else {
irk = &T->ir[irk->op2];
if (irk->o == IR_KSLOT) irk = &T->ir[irk->op1];
lj_ir_kvalue(J->L, &tmp, irk);
val = lj_tab_set(J->L, t, &tmp);
/* NOBARRIER: The table is new (marked white). */
snap_restoreval(J, T, ex, snapno, rfilt, irs->op2, val);
if (LJ_SOFTFP && irs+1 < T->ir + T->nins && (irs+1)->o == IR_HIOP) {
snap_restoreval(J, T, ex, snapno, rfilt, (irs+1)->op2, &tmp);
val->u32.hi = tmp.u32.lo;
}
}
}
}
}
/* Index C data by a TValue. Return CType and pointer. */
CType *lj_cdata_index(CTState *cts, GCcdata *cd, cTValue *key, uint8_t **pp,
CTInfo *qual)
{
uint8_t *p = (uint8_t *)cdataptr(cd);
CType *ct = ctype_get(cts, cd->ctypeid);
ptrdiff_t idx;
/* Resolve reference for cdata object. */
if (ctype_isref(ct->info)) {
lua_assert(ct->size == CTSIZE_PTR);
p = *(uint8_t **)p;
ct = ctype_child(cts, ct);
}
collect_attrib:
/* Skip attributes and collect qualifiers. */
while (ctype_isattrib(ct->info)) {
if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
ct = ctype_child(cts, ct);
}
lua_assert(!ctype_isref(ct->info)); /* Interning rejects refs to refs. */
if (tvisint(key)) {
idx = (ptrdiff_t)intV(key);
goto integer_key;
} else if (tvisnum(key)) { /* Numeric key. */
#ifdef _MSC_VER
/* Workaround for MSVC bug. */
volatile
#endif
lua_Number n = numV(key);
idx = LJ_64 ? (ptrdiff_t)n : (ptrdiff_t)lj_num2int(n);
integer_key:
if (ctype_ispointer(ct->info)) {
CTSize sz = lj_ctype_size(cts, ctype_cid(ct->info)); /* Element size. */
if (sz == CTSIZE_INVALID)
lj_err_caller(cts->L, LJ_ERR_FFI_INVSIZE);
if (ctype_isptr(ct->info)) {
p = (uint8_t *)cdata_getptr(p, ct->size);
} else if ((ct->info & (CTF_VECTOR|CTF_COMPLEX))) {
if ((ct->info & CTF_COMPLEX)) idx &= 1;
*qual |= CTF_CONST; /* Valarray elements are constant. */
}
*pp = p + idx*(int32_t)sz;
return ct;
}
} else if (tviscdata(key)) { /* Integer cdata key. */
GCcdata *cdk = cdataV(key);
CType *ctk = ctype_raw(cts, cdk->ctypeid);
if (ctype_isenum(ctk->info)) ctk = ctype_child(cts, ctk);
if (ctype_isinteger(ctk->info)) {
lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT_PSZ), ctk,
(uint8_t *)&idx, cdataptr(cdk), 0);
goto integer_key;
}
} else if (tvisstr(key)) { /* String key. */
GCstr *name = strV(key);
if (ctype_isstruct(ct->info)) {
CTSize ofs;
CType *fct = lj_ctype_getfieldq(cts, ct, name, &ofs, qual);
if (fct) {
*pp = p + ofs;
return fct;
}
} else if (ctype_iscomplex(ct->info)) {
if (name->len == 2) {
*qual |= CTF_CONST; /* Complex fields are constant. */
if (strdata(name)[0] == 'r' && strdata(name)[1] == 'e') {
*pp = p;
return ct;
} else if (strdata(name)[0] == 'i' && strdata(name)[1] == 'm') {
*pp = p + (ct->size >> 1);
return ct;
}
}
} else if (cd->ctypeid == CTID_CTYPEID) {