FFI: Add C data handling and C type conversions.

1 files changed, 235 insertions, 0 deletions

diff --git a/src/lj_cdata.c b/src/lj_cdata.c
new file mode 100644
index 00000000..15ba2dde
--- /dev/null
+++ b/src/lj_cdata.c
@@ -0,0 +1,235 @@
+/*
+** C data management.
+** Copyright (C) 2005-2010 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#include "lj_obj.h"
+
+#if LJ_HASFFI
+
+#include "lj_gc.h"
+#include "lj_err.h"
+#include "lj_str.h"
+#include "lj_ctype.h"
+#include "lj_cconv.h"
+#include "lj_cdata.h"
+
+/* -- C data allocation --------------------------------------------------- */
+
+/* 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;
+}
+
+/* Allocate variable-sized or specially aligned C data object. */
+GCcdata *lj_cdata_newv(CTState *cts, CTypeID id, CTSize sz, CTSize align)
+{
+  global_State *g;
+  MSize extra = sizeof(GCcdataVar) + sizeof(GCcdata) +
+                (align > CT_MEMALIGN ? (1u<<align) - (1u<<CT_MEMALIGN) : 0);
+  char *p = lj_mem_newt(cts->L, extra + sz, char);
+  uintptr_t adata = (uintptr_t)p + sizeof(GCcdataVar) + sizeof(GCcdata);
+  uintptr_t almask = (1u << align) - 1u;
+  GCcdata *cd = (GCcdata *)(((adata + almask) & ~almask) - sizeof(GCcdata));
+  lua_assert((char *)cd - p < 65536);
+  cdatav(cd)->offset = (uint16_t)((char *)cd - p);
+  cdatav(cd)->extra = extra;
+  cdatav(cd)->len = sz;
+  g = cts->g;
+  setgcrefr(cd->nextgc, g->gc.root);
+  setgcref(g->gc.root, obj2gco(cd));
+  newwhite(g, obj2gco(cd));
+  cd->marked |= 0x80;
+  cd->gct = ~LJ_TCDATA;
+  cd->typeid = id;
+  return cd;
+}
+
+/* Free a C data object. */
+void LJ_FASTCALL lj_cdata_free(global_State *g, GCcdata *cd)
+{
+  if (LJ_LIKELY(!cdataisv(cd))) {
+    CType *ct = ctype_raw(ctype_ctsG(g), cd->typeid);
+    CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
+    lua_assert(ctype_hassize(ct->info) || ctype_isfunc(ct->info));
+    lj_mem_free(g, cd, sizeof(GCcdata) + sz);
+  } else {
+    lj_mem_free(g, memcdatav(cd), sizecdatav(cd));
+  }
+}
+
+/* -- C data indexing ----------------------------------------------------- */
+
+/* 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->typeid);
+
+  /* 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);
+  }
+
+  /* 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 (tvisnum(key)) {  /* Numeric key. */
+    ptrdiff_t idx = LJ_64 ? (ptrdiff_t)numV(key) :
+                            (ptrdiff_t)lj_num2int(numV(key));
+    if (ctype_ispointer(ct->info)) {
+      CTSize sz = lj_ctype_size(cts, ctype_cid(ct->info));
+      if (sz != CTSIZE_INVALID) {
+        if (ctype_isptr(ct->info))
+          p = (uint8_t *)cdata_getptr(p, ct->size);
+        else if ((ct->info & (CTF_VECTOR|CTF_COMPLEX)))
+          *qual |= CTF_CONST;  /* Valarray elements are constant. */
+        *pp = p + idx*(int32_t)sz;
+        return ct;
+      }
+    }
+  } else if (tvisstr(key)) {  /* String key. */
+    GCstr *name = strV(key);
+    if (ctype_isptr(ct->info)) {  /* Automatically perform '->'. */
+      CType *cct = ctype_child(cts, ct);
+      if (ctype_isstruct(cct->info)) {
+        p = (uint8_t *)cdata_getptr(p, ct->size);
+        ct = cct;
+        goto index_struct;
+      }
+    } if (ctype_isstruct(ct->info)) {
+      CTSize ofs;
+      CType *fct;
+    index_struct:
+      fct = lj_ctype_getfield(cts, ct, name, &ofs);
+      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;
+        }
+      }
+    }
+    {
+      GCstr *s = lj_ctype_repr(cts->L, ctype_typeid(cts, ct), NULL);
+      lj_err_callerv(cts->L, LJ_ERR_FFI_BADMEMBER, strdata(s), strdata(name));
+    }
+  }
+  {
+    GCstr *s = lj_ctype_repr(cts->L, ctype_typeid(cts, ct), NULL);
+    lj_err_callerv(cts->L, LJ_ERR_FFI_BADIDX, strdata(s));
+  }
+  return NULL;  /* unreachable */
+}
+
+/* -- C data getters ------------------------------------------------------ */
+
+/* Get constant value and convert to TValue. */
+static void cdata_getconst(CTState *cts, TValue *o, CType *ct)
+{
+  CType *ctt = ctype_child(cts, ct);
+  lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
+  /* Constants are already zero-extended/sign-extended to 32 bits. */
+  if (!(ctt->info & CTF_UNSIGNED))
+    setintV(o, (int32_t)ct->size);
+  else
+    setnumV(o, (lua_Number)(uint32_t)ct->size);
+}
+
+/* Get C data value and convert to TValue. */
+void lj_cdata_get(CTState *cts, CType *s, TValue *o, uint8_t *sp)
+{
+  CTypeID sid;
+
+  if (ctype_isconstval(s->info)) {
+    cdata_getconst(cts, o, s);
+    return;
+  } else if (ctype_isbitfield(s->info)) {
+    lj_cconv_tv_bf(cts, s, o, sp);
+    return;
+  }
+
+  /* Get child type of pointer/array/field. */
+  lua_assert(ctype_ispointer(s->info) || ctype_isfield(s->info));
+  sid = ctype_cid(s->info);
+  s = ctype_get(cts, sid);
+
+  /* Resolve reference for field. */
+  if (ctype_isref(s->info)) {
+    lua_assert(s->size == CTSIZE_PTR);
+    sp = *(uint8_t **)sp;
+    sid = ctype_cid(s->info);
+    s = ctype_get(cts, sid);
+  }
+
+  /* Skip attributes and enums. */
+  while (ctype_isattrib(s->info) || ctype_isenum(s->info))
+    s = ctype_child(cts, s);
+
+  lj_cconv_tv_ct(cts, s, sid, o, sp);
+}
+
+/* -- C data setters ------------------------------------------------------ */
+
+/* Convert TValue and set C data value. */
+void lj_cdata_set(CTState *cts, CType *d, uint8_t *dp, TValue *o, CTInfo qual)
+{
+  if (ctype_isconstval(d->info)) {
+    goto err_const;
+  } else if (ctype_isbitfield(d->info)) {
+    if (((d->info|qual) & CTF_CONST)) goto err_const;
+    lj_cconv_bf_tv(cts, d, dp, o);
+    return;
+  }
+
+  /* Get child type of pointer/array/field. */
+  lua_assert(ctype_ispointer(d->info) || ctype_isfield(d->info));
+  d = ctype_child(cts, d);
+
+  /* Resolve reference for field. */
+  if (ctype_isref(d->info)) {
+    lua_assert(d->size == CTSIZE_PTR);
+    dp = *(uint8_t **)dp;
+    d = ctype_child(cts, d);
+  }
+
+  /* Skip attributes and collect qualifiers. */
+  for (;;) {
+    if (ctype_isattrib(d->info)) {
+      if (ctype_attrib(d->info) == CTA_QUAL) qual |= d->size;
+    } else {
+      break;
+    }
+    d = ctype_child(cts, d);
+  }
+
+  lua_assert(ctype_hassize(d->info) && !ctype_isvoid(d->info));
+
+  if (((d->info|qual) & CTF_CONST)) {
+  err_const:
+    lj_err_caller(cts->L, LJ_ERR_FFI_WRCONST);
+  }
+
+  lj_cconv_ct_tv(cts, d, dp, o, 0);
+}
+
+#endif