tools/wrk/deps/luajit/src/lj_cconv.c
/*
** C type conversions.
** Copyright (C) 2005-2013 Mike Pall. See Copyright Notice in luajit.h
*/
#include "lj_obj.h"
#if LJ_HASFFI
#include "lj_err.h"
#include "lj_tab.h"
#include "lj_ctype.h"
#include "lj_cdata.h"
#include "lj_cconv.h"
#include "lj_ccallback.h"
/* -- Conversion errors --------------------------------------------------- */
/* Bad conversion. */
LJ_NORET static void cconv_err_conv(CTState *cts, CType *d, CType *s,
CTInfo flags)
{
const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
const char *src;
if ((flags & CCF_FROMTV))
src = lj_obj_typename[1+(ctype_isnum(s->info) ? LUA_TNUMBER :
ctype_isarray(s->info) ? LUA_TSTRING : LUA_TNIL)];
else
src = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, s), NULL));
if (CCF_GETARG(flags))
lj_err_argv(cts->L, CCF_GETARG(flags), LJ_ERR_FFI_BADCONV, src, dst);
else
lj_err_callerv(cts->L, LJ_ERR_FFI_BADCONV, src, dst);
}
/* Bad conversion from TValue. */
LJ_NORET static void cconv_err_convtv(CTState *cts, CType *d, TValue *o,
CTInfo flags)
{
const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
const char *src = lj_typename(o);
if (CCF_GETARG(flags))
lj_err_argv(cts->L, CCF_GETARG(flags), LJ_ERR_FFI_BADCONV, src, dst);
else
lj_err_callerv(cts->L, LJ_ERR_FFI_BADCONV, src, dst);
}
/* Initializer overflow. */
LJ_NORET static void cconv_err_initov(CTState *cts, CType *d)
{
const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
lj_err_callerv(cts->L, LJ_ERR_FFI_INITOV, dst);
}
/* -- C type compatibility checks ----------------------------------------- */
/* Get raw type and qualifiers for a child type. Resolves enums, too. */
static CType *cconv_childqual(CTState *cts, CType *ct, CTInfo *qual)
{
ct = ctype_child(cts, ct);
for (;;) {
if (ctype_isattrib(ct->info)) {
if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
} else if (!ctype_isenum(ct->info)) {
break;
}
ct = ctype_child(cts, ct);
}
*qual |= (ct->info & CTF_QUAL);
return ct;
}
/* Check for compatible types when converting to a pointer.
** Note: these checks are more relaxed than what C99 mandates.
*/
int lj_cconv_compatptr(CTState *cts, CType *d, CType *s, CTInfo flags)
{
if (!((flags & CCF_CAST) || d == s)) {
CTInfo dqual = 0, squal = 0;
d = cconv_childqual(cts, d, &dqual);
if (!ctype_isstruct(s->info))
s = cconv_childqual(cts, s, &squal);
if ((flags & CCF_SAME)) {
if (dqual != squal)
return 0; /* Different qualifiers. */
} else if (!(flags & CCF_IGNQUAL)) {
if ((dqual & squal) != squal)
return 0; /* Discarded qualifiers. */
if (ctype_isvoid(d->info) || ctype_isvoid(s->info))
return 1; /* Converting to/from void * is always ok. */
}
if (ctype_type(d->info) != ctype_type(s->info) ||
d->size != s->size)
return 0; /* Different type or different size. */
if (ctype_isnum(d->info)) {
if (((d->info ^ s->info) & (CTF_BOOL|CTF_FP)))
return 0; /* Different numeric types. */
} else if (ctype_ispointer(d->info)) {
/* Check child types for compatibility. */
return lj_cconv_compatptr(cts, d, s, flags|CCF_SAME);
} else if (ctype_isstruct(d->info)) {
if (d != s)
return 0; /* Must be exact same type for struct/union. */
} else if (ctype_isfunc(d->info)) {
/* NYI: structural equality of functions. */
}
}
return 1; /* Types are compatible. */
}
/* -- C type to C type conversion ----------------------------------------- */
/* Convert C type to C type. Caveat: expects to get the raw CType!
**
** Note: This is only used by the interpreter and not optimized at all.
** The JIT compiler will do a much better job specializing for each case.
*/
void lj_cconv_ct_ct(CTState *cts, CType *d, CType *s,
uint8_t *dp, uint8_t *sp, CTInfo flags)
{
CTSize dsize = d->size, ssize = s->size;
CTInfo dinfo = d->info, sinfo = s->info;
void *tmpptr;
lua_assert(!ctype_isenum(dinfo) && !ctype_isenum(sinfo));
lua_assert(!ctype_isattrib(dinfo) && !ctype_isattrib(sinfo));
if (ctype_type(dinfo) > CT_MAYCONVERT || ctype_type(sinfo) > CT_MAYCONVERT)
goto err_conv;
/* Some basic sanity checks. */
lua_assert(!ctype_isnum(dinfo) || dsize > 0);
lua_assert(!ctype_isnum(sinfo) || ssize > 0);
lua_assert(!ctype_isbool(dinfo) || dsize == 1 || dsize == 4);
lua_assert(!ctype_isbool(sinfo) || ssize == 1 || ssize == 4);
lua_assert(!ctype_isinteger(dinfo) || (1u<<lj_fls(dsize)) == dsize);
lua_assert(!ctype_isinteger(sinfo) || (1u<<lj_fls(ssize)) == ssize);
switch (cconv_idx2(dinfo, sinfo)) {
/* Destination is a bool. */
case CCX(B, B):
/* Source operand is already normalized. */
if (dsize == 1) *dp = *sp; else *(int *)dp = *sp;
break;
case CCX(B, I): {
MSize i;
uint8_t b = 0;
for (i = 0; i < ssize; i++) b |= sp[i];
b = (b != 0);
if (dsize == 1) *dp = b; else *(int *)dp = b;
break;
}
case CCX(B, F): {
uint8_t b;
if (ssize == sizeof(double)) b = (*(double *)sp != 0);
else if (ssize == sizeof(float)) b = (*(float *)sp != 0);
else goto err_conv; /* NYI: long double. */
if (dsize == 1) *dp = b; else *(int *)dp = b;
break;
}
/* Destination is an integer. */
case CCX(I, B):
case CCX(I, I):
conv_I_I:
if (dsize > ssize) { /* Zero-extend or sign-extend LSB. */
#if LJ_LE
uint8_t fill = (!(sinfo & CTF_UNSIGNED) && (sp[ssize-1]&0x80)) ? 0xff : 0;
memcpy(dp, sp, ssize);
memset(dp + ssize, fill, dsize-ssize);
#else
uint8_t fill = (!(sinfo & CTF_UNSIGNED) && (sp[0]&0x80)) ? 0xff : 0;
memset(dp, fill, dsize-ssize);
memcpy(dp + (dsize-ssize), sp, ssize);
#endif
} else { /* Copy LSB. */
#if LJ_LE
memcpy(dp, sp, dsize);
#else
memcpy(dp, sp + (ssize-dsize), dsize);
#endif
}
break;
case CCX(I, F): {
double n; /* Always convert via double. */
conv_I_F:
/* Convert source to double. */
if (ssize == sizeof(double)) n = *(double *)sp;
else if (ssize == sizeof(float)) n = (double)*(float *)sp;
else goto err_conv; /* NYI: long double. */
/* Then convert double to integer. */
/* The conversion must exactly match the semantics of JIT-compiled code! */
if (dsize < 4 || (dsize == 4 && !(dinfo & CTF_UNSIGNED))) {
int32_t i = (int32_t)n;
if (dsize == 4) *(int32_t *)dp = i;
else if (dsize == 2) *(int16_t *)dp = (int16_t)i;
else *(int8_t *)dp = (int8_t)i;
} else if (dsize == 4) {
*(uint32_t *)dp = (uint32_t)n;
} else if (dsize == 8) {
if (!(dinfo & CTF_UNSIGNED))
*(int64_t *)dp = (int64_t)n;
else
*(uint64_t *)dp = lj_num2u64(n);
} else {
goto err_conv; /* NYI: conversion to >64 bit integers. */
}
break;
}
case CCX(I, C):
s = ctype_child(cts, s);
sinfo = s->info;
ssize = s->size;
goto conv_I_F; /* Just convert re. */
case CCX(I, P):
if (!(flags & CCF_CAST)) goto err_conv;
sinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
goto conv_I_I;
case CCX(I, A):
if (!(flags & CCF_CAST)) goto err_conv;
sinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
ssize = CTSIZE_PTR;
tmpptr = sp;
sp = (uint8_t *)&tmpptr;
goto conv_I_I;
/* Destination is a floating-point number. */
case CCX(F, B):
case CCX(F, I): {
double n; /* Always convert via double. */
conv_F_I:
/* First convert source to double. */
/* The conversion must exactly match the semantics of JIT-compiled code! */
if (ssize < 4 || (ssize == 4 && !(sinfo & CTF_UNSIGNED))) {
int32_t i;
if (ssize == 4) {
i = *(int32_t *)sp;
} else if (!(sinfo & CTF_UNSIGNED)) {
if (ssize == 2) i = *(int16_t *)sp;
else i = *(int8_t *)sp;
} else {
if (ssize == 2) i = *(uint16_t *)sp;
else i = *(uint8_t *)sp;
}
n = (double)i;
} else if (ssize == 4) {
n = (double)*(uint32_t *)sp;
} else if (ssize == 8) {
if (!(sinfo & CTF_UNSIGNED)) n = (double)*(int64_t *)sp;
else n = (double)*(uint64_t *)sp;
} else {
goto err_conv; /* NYI: conversion from >64 bit integers. */
}
/* Convert double to destination. */
if (dsize == sizeof(double)) *(double *)dp = n;
else if (dsize == sizeof(float)) *(float *)dp = (float)n;
else goto err_conv; /* NYI: long double. */
break;
}
case CCX(F, F): {
double n; /* Always convert via double. */
conv_F_F:
if (ssize == dsize) goto copyval;
/* Convert source to double. */
if (ssize == sizeof(double)) n = *(double *)sp;
else if (ssize == sizeof(float)) n = (double)*(float *)sp;
else goto err_conv; /* NYI: long double. */
/* Convert double to destination. */
if (dsize == sizeof(double)) *(double *)dp = n;
else if (dsize == sizeof(float)) *(float *)dp = (float)n;
else goto err_conv; /* NYI: long double. */
break;
}
case CCX(F, C):
s = ctype_child(cts, s);
sinfo = s->info;
ssize = s->size;
goto conv_F_F; /* Ignore im, and convert from re. */
/* Destination is a complex number. */
case CCX(C, I):
d = ctype_child(cts, d);
dinfo = d->info;
dsize = d->size;
memset(dp + dsize, 0, dsize); /* Clear im. */
goto conv_F_I; /* Convert to re. */
case CCX(C, F):
d = ctype_child(cts, d);
dinfo = d->info;
dsize = d->size;
memset(dp + dsize, 0, dsize); /* Clear im. */
goto conv_F_F; /* Convert to re. */
case CCX(C, C):
if (dsize != ssize) { /* Different types: convert re/im separately. */
CType *dc = ctype_child(cts, d);
CType *sc = ctype_child(cts, s);
lj_cconv_ct_ct(cts, dc, sc, dp, sp, flags);
lj_cconv_ct_ct(cts, dc, sc, dp + dc->size, sp + sc->size, flags);
return;
}
goto copyval; /* Otherwise this is easy. */
/* Destination is a vector. */
case CCX(V, I):
case CCX(V, F):
case CCX(V, C): {
CType *dc = ctype_child(cts, d);
CTSize esize;
/* First convert the scalar to the first element. */
lj_cconv_ct_ct(cts, dc, s, dp, sp, flags);
/* Then replicate it to the other elements (splat). */
for (sp = dp, esize = dc->size; dsize > esize; dsize -= esize) {
dp += esize;
memcpy(dp, sp, esize);
}
break;
}
case CCX(V, V):
/* Copy same-sized vectors, even for different lengths/element-types. */
if (dsize != ssize) goto err_conv;
goto copyval;
/* Destination is a pointer. */
case CCX(P, I):
if (!(flags & CCF_CAST)) goto err_conv;
dinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
goto conv_I_I;
case CCX(P, F):
if (!(flags & CCF_CAST) || !(flags & CCF_FROMTV)) goto err_conv;
/* The signed conversion is cheaper. x64 really has 47 bit pointers. */
dinfo = CTINFO(CT_NUM, (LJ_64 && dsize == 8) ? 0 : CTF_UNSIGNED);
goto conv_I_F;
case CCX(P, P):
if (!lj_cconv_compatptr(cts, d, s, flags)) goto err_conv;
cdata_setptr(dp, dsize, cdata_getptr(sp, ssize));
break;
case CCX(P, A):
case CCX(P, S):
if (!lj_cconv_compatptr(cts, d, s, flags)) goto err_conv;
cdata_setptr(dp, dsize, sp);
break;
/* Destination is an array. */
case CCX(A, A):
if ((flags & CCF_CAST) || (d->info & CTF_VLA) || dsize != ssize ||
d->size == CTSIZE_INVALID || !lj_cconv_compatptr(cts, d, s, flags))
goto err_conv;
goto copyval;
/* Destination is a struct/union. */
case CCX(S, S):
if ((flags & CCF_CAST) || (d->info & CTF_VLA) || d != s)
goto err_conv; /* Must be exact same type. */
copyval: /* Copy value. */
lua_assert(dsize == ssize);
memcpy(dp, sp, dsize);
break;
default:
err_conv:
cconv_err_conv(cts, d, s, flags);
}
}
/* -- C type to TValue conversion ----------------------------------------- */
/* 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;
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 = s->size == 1 ? (*sp != 0) : (*(int *)sp != 0);
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. */
}
}
/* Convert bitfield to TValue. */
int lj_cconv_tv_bf(CTState *cts, CType *s, TValue *o, uint8_t *sp)
{
CTInfo info = s->info;
CTSize pos, bsz;
uint32_t val;
lua_assert(ctype_isbitfield(info));
/* NYI: packed bitfields may cause misaligned reads. */
switch (ctype_bitcsz(info)) {
case 4: val = *(uint32_t *)sp; break;
case 2: val = *(uint16_t *)sp; break;
case 1: val = *(uint8_t *)sp; break;
default: lua_assert(0); val = 0; break;
}
/* Check if a packed bitfield crosses a container boundary. */
pos = ctype_bitpos(info);
bsz = ctype_bitbsz(info);
lua_assert(pos < 8*ctype_bitcsz(info));
lua_assert(bsz > 0 && bsz <= 8*ctype_bitcsz(info));
if (pos + bsz > 8*ctype_bitcsz(info))
lj_err_caller(cts->L, LJ_ERR_FFI_NYIPACKBIT);
if (!(info & CTF_BOOL)) {
CTSize shift = 32 - bsz;
if (!(info & CTF_UNSIGNED)) {
setintV(o, (int32_t)(val << (shift-pos)) >> shift);
} else {
val = (val << (shift-pos)) >> shift;
if (!LJ_DUALNUM || (int32_t)val < 0)
setnumV(o, (lua_Number)(uint32_t)val);
else
setintV(o, (int32_t)val);
}
} else {
lua_assert(bsz == 1);
setboolV(o, (val >> pos) & 1);
}
return 0; /* No GC step needed. */
}
/* -- TValue to C type conversion ----------------------------------------- */
/* Convert table to array. */
static void cconv_array_tab(CTState *cts, CType *d,
uint8_t *dp, GCtab *t, CTInfo flags)
{
int32_t i;
CType *dc = ctype_rawchild(cts, d); /* Array element type. */
CTSize size = d->size, esize = dc->size, ofs = 0;
for (i = 0; ; i++) {
TValue *tv = (TValue *)lj_tab_getint(t, i);
if (!tv || tvisnil(tv)) {
if (i == 0) continue; /* Try again for 1-based tables. */
break; /* Stop at first nil. */
}
if (ofs >= size)
cconv_err_initov(cts, d);
lj_cconv_ct_tv(cts, dc, dp + ofs, tv, flags);
ofs += esize;
}
if (size != CTSIZE_INVALID) { /* Only fill up arrays with known size. */
if (ofs == esize) { /* Replicate a single element. */
for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
} else { /* Otherwise fill the remainder with zero. */
memset(dp + ofs, 0, size - ofs);
}
}
}
/* Convert table to sub-struct/union. */
static void cconv_substruct_tab(CTState *cts, CType *d, uint8_t *dp,
GCtab *t, int32_t *ip, CTInfo flags)
{
CTypeID id = d->sib;
while (id) {
CType *df = ctype_get(cts, id);
id = df->sib;
if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
TValue *tv;
int32_t i = *ip, iz = i;
if (!gcref(df->name)) continue; /* Ignore unnamed fields. */
if (i >= 0) {
retry:
tv = (TValue *)lj_tab_getint(t, i);
if (!tv || tvisnil(tv)) {
if (i == 0) { i = 1; goto retry; } /* 1-based tables. */
if (iz == 0) { *ip = i = -1; goto tryname; } /* Init named fields. */
break; /* Stop at first nil. */
}
*ip = i + 1;
} else {
tryname:
tv = (TValue *)lj_tab_getstr(t, gco2str(gcref(df->name)));
if (!tv || tvisnil(tv)) continue;
}
if (ctype_isfield(df->info))
lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, tv, flags);
else
lj_cconv_bf_tv(cts, df, dp+df->size, tv);
if ((d->info & CTF_UNION)) break;
} else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
cconv_substruct_tab(cts, ctype_rawchild(cts, df),
dp+df->size, t, ip, flags);
} /* Ignore all other entries in the chain. */
}
}
/* Convert table to struct/union. */
static void cconv_struct_tab(CTState *cts, CType *d,
uint8_t *dp, GCtab *t, CTInfo flags)
{
int32_t i = 0;
memset(dp, 0, d->size); /* Much simpler to clear the struct first. */
cconv_substruct_tab(cts, d, dp, t, &i, flags);
}
/* Convert TValue to C type. Caveat: expects to get the raw CType! */
void lj_cconv_ct_tv(CTState *cts, CType *d,
uint8_t *dp, TValue *o, CTInfo flags)
{
CTypeID sid = CTID_P_VOID;
CType *s;
void *tmpptr;
uint8_t tmpbool, *sp = (uint8_t *)&tmpptr;
if (LJ_LIKELY(tvisint(o))) {
sp = (uint8_t *)&o->i;
sid = CTID_INT32;
flags |= CCF_FROMTV;
} else if (LJ_LIKELY(tvisnum(o))) {
sp = (uint8_t *)&o->n;
sid = CTID_DOUBLE;
flags |= CCF_FROMTV;
} else if (tviscdata(o)) {
sp = cdataptr(cdataV(o));
sid = cdataV(o)->ctypeid;
s = ctype_get(cts, sid);
if (ctype_isref(s->info)) { /* Resolve reference for value. */
lua_assert(s->size == CTSIZE_PTR);
sp = *(void **)sp;
sid = ctype_cid(s->info);
}
s = ctype_raw(cts, sid);
if (ctype_isfunc(s->info)) {
sid = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|sid), CTSIZE_PTR);
} else {
if (ctype_isenum(s->info)) s = ctype_child(cts, s);
goto doconv;
}
} else if (tvisstr(o)) {
GCstr *str = strV(o);
if (ctype_isenum(d->info)) { /* Match string against enum constant. */
CTSize ofs;
CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
if (!cct || !ctype_isconstval(cct->info))
goto err_conv;
lua_assert(d->size == 4);
sp = (uint8_t *)&cct->size;
sid = ctype_cid(cct->info);
} else if (ctype_isrefarray(d->info)) { /* Copy string to array. */
CType *dc = ctype_rawchild(cts, d);
CTSize sz = str->len+1;
if (!ctype_isinteger(dc->info) || dc->size != 1)
goto err_conv;
if (d->size != 0 && d->size < sz)
sz = d->size;
memcpy(dp, strdata(str), sz);
return;
} else { /* Otherwise pass it as a const char[]. */
sp = (uint8_t *)strdata(str);
sid = CTID_A_CCHAR;
flags |= CCF_FROMTV;
}
} else if (tvistab(o)) {
if (ctype_isarray(d->info)) {
cconv_array_tab(cts, d, dp, tabV(o), flags);
return;
} else if (ctype_isstruct(d->info)) {
cconv_struct_tab(cts, d, dp, tabV(o), flags);
return;
} else {
goto err_conv;
}
} else if (tvisbool(o)) {
tmpbool = boolV(o);
sp = &tmpbool;
sid = CTID_BOOL;
} else if (tvisnil(o)) {
tmpptr = (void *)0;
flags |= CCF_FROMTV;
} else if (tvisudata(o)) {
GCudata *ud = udataV(o);
tmpptr = uddata(ud);
if (ud->udtype == UDTYPE_IO_FILE)
tmpptr = *(void **)tmpptr;
} else if (tvislightud(o)) {
tmpptr = lightudV(o);
} else if (tvisfunc(o)) {
void *p = lj_ccallback_new(cts, d, funcV(o));
if (p) {
*(void **)dp = p;
return;
}
goto err_conv;
} else {
err_conv:
cconv_err_convtv(cts, d, o, flags);
}
s = ctype_get(cts, sid);
doconv:
if (ctype_isenum(d->info)) d = ctype_child(cts, d);
lj_cconv_ct_ct(cts, d, s, dp, sp, flags);
}
/* Convert TValue to bitfield. */
void lj_cconv_bf_tv(CTState *cts, CType *d, uint8_t *dp, TValue *o)
{
CTInfo info = d->info;
CTSize pos, bsz;
uint32_t val, mask;
lua_assert(ctype_isbitfield(info));
if ((info & CTF_BOOL)) {
uint8_t tmpbool;
lua_assert(ctype_bitbsz(info) == 1);
lj_cconv_ct_tv(cts, ctype_get(cts, CTID_BOOL), &tmpbool, o, 0);
val = tmpbool;
} else {
CTypeID did = (info & CTF_UNSIGNED) ? CTID_UINT32 : CTID_INT32;
lj_cconv_ct_tv(cts, ctype_get(cts, did), (uint8_t *)&val, o, 0);
}
pos = ctype_bitpos(info);
bsz = ctype_bitbsz(info);
lua_assert(pos < 8*ctype_bitcsz(info));
lua_assert(bsz > 0 && bsz <= 8*ctype_bitcsz(info));
/* Check if a packed bitfield crosses a container boundary. */
if (pos + bsz > 8*ctype_bitcsz(info))
lj_err_caller(cts->L, LJ_ERR_FFI_NYIPACKBIT);
mask = ((1u << bsz) - 1u) << pos;
val = (val << pos) & mask;
/* NYI: packed bitfields may cause misaligned reads/writes. */
switch (ctype_bitcsz(info)) {
case 4: *(uint32_t *)dp = (*(uint32_t *)dp & ~mask) | (uint32_t)val; break;
case 2: *(uint16_t *)dp = (*(uint16_t *)dp & ~mask) | (uint16_t)val; break;
case 1: *(uint8_t *)dp = (*(uint8_t *)dp & ~mask) | (uint8_t)val; break;
default: lua_assert(0); break;
}
}
/* -- Initialize C type with TValues -------------------------------------- */
/* Initialize an array with TValues. */
static void cconv_array_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
TValue *o, MSize len)
{
CType *dc = ctype_rawchild(cts, d); /* Array element type. */
CTSize ofs, esize = dc->size;
MSize i;
if (len*esize > sz)
cconv_err_initov(cts, d);
for (i = 0, ofs = 0; i < len; i++, ofs += esize)
lj_cconv_ct_tv(cts, dc, dp + ofs, o + i, 0);
if (ofs == esize) { /* Replicate a single element. */
for (; ofs < sz; ofs += esize) memcpy(dp + ofs, dp, esize);
} else { /* Otherwise fill the remainder with zero. */
memset(dp + ofs, 0, sz - ofs);
}
}
/* Initialize a sub-struct/union with TValues. */
static void cconv_substruct_init(CTState *cts, CType *d, uint8_t *dp,
TValue *o, MSize len, MSize *ip)
{
CTypeID id = d->sib;
while (id) {
CType *df = ctype_get(cts, id);
id = df->sib;
if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
MSize i = *ip;
if (!gcref(df->name)) continue; /* Ignore unnamed fields. */
if (i >= len) break;
*ip = i + 1;
if (ctype_isfield(df->info))
lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, o + i, 0);
else
lj_cconv_bf_tv(cts, df, dp+df->size, o + i);
if ((d->info & CTF_UNION)) break;
} else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
cconv_substruct_init(cts, ctype_rawchild(cts, df),
dp+df->size, o, len, ip);
} /* Ignore all other entries in the chain. */
}
}
/* Initialize a struct/union with TValues. */
static void cconv_struct_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
TValue *o, MSize len)
{
MSize i = 0;
memset(dp, 0, sz); /* Much simpler to clear the struct first. */
cconv_substruct_init(cts, d, dp, o, len, &i);
if (i < len)
cconv_err_initov(cts, d);
}
/* Check whether to use a multi-value initializer.
** This is true if an aggregate is to be initialized with a value.
** Valarrays are treated as values here so ct_tv handles (V|C, I|F).
*/
int lj_cconv_multi_init(CTState *cts, CType *d, TValue *o)
{
if (!(ctype_isrefarray(d->info) || ctype_isstruct(d->info)))
return 0; /* Destination is not an aggregate. */
if (tvistab(o) || (tvisstr(o) && !ctype_isstruct(d->info)))
return 0; /* Initializer is not a value. */
if (tviscdata(o) && lj_ctype_rawref(cts, cdataV(o)->ctypeid) == d)
return 0; /* Source and destination are identical aggregates. */
return 1; /* Otherwise the initializer is a value. */
}
/* Initialize C type with TValues. Caveat: expects to get the raw CType! */
void lj_cconv_ct_init(CTState *cts, CType *d, CTSize sz,
uint8_t *dp, TValue *o, MSize len)
{
if (len == 0)
memset(dp, 0, sz);
else if (len == 1 && !lj_cconv_multi_init(cts, d, o))
lj_cconv_ct_tv(cts, d, dp, o, 0);
else if (ctype_isarray(d->info)) /* Also handles valarray init with len>1. */
cconv_array_init(cts, d, sz, dp, o, len);
else if (ctype_isstruct(d->info))
cconv_struct_init(cts, d, sz, dp, o, len);
else
cconv_err_initov(cts, d);
}
#endif