FFI: Add C type management.

6 files changed, 1041 insertions, 12 deletions

diff --git a/src/Makefile b/src/Makefile
index 3b9d202a..563c6c08 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -327,6 +327,7 @@ LJCORE_O= lj_gc.o lj_err.o lj_char.o lj_bc.o lj_obj.o \
           lj_ir.o lj_opt_mem.o lj_opt_fold.o lj_opt_narrow.o \
           lj_opt_dce.o lj_opt_loop.o \
           lj_mcode.o lj_snap.o lj_record.o lj_asm.o lj_trace.o lj_gdbjit.o \
+          lj_ctype.o \
           lj_lib.o lj_alloc.o lib_aux.o \
           $(LJLIB_O) lib_init.o
 
diff --git a/src/Makefile.dep b/src/Makefile.dep
index b30086d9..761fd9fa 100644
--- a/src/Makefile.dep
+++ b/src/Makefile.dep
@@ -53,6 +53,8 @@ lj_asm.o: lj_asm.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
 lj_bc.o: lj_bc.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_bc.h \
  lj_bcdef.h
 lj_char.o: lj_char.c lj_char.h lj_def.h lua.h luaconf.h
+lj_ctype.o: lj_ctype.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
+ lj_gc.h lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_ctype.h
 lj_dispatch.o: lj_dispatch.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
  lj_err.h lj_errmsg.h lj_state.h lj_frame.h lj_bc.h lj_ff.h lj_ffdef.h \
  lj_jit.h lj_ir.h lj_trace.h lj_dispatch.h lj_traceerr.h lj_vm.h luajit.h
@@ -109,7 +111,7 @@ lj_snap.o: lj_snap.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
  lj_dispatch.h lj_traceerr.h lj_snap.h lj_target.h lj_target_*.h
 lj_state.o: lj_state.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h \
  lj_gc.h lj_err.h lj_errmsg.h lj_str.h lj_tab.h lj_func.h lj_meta.h \
- lj_state.h lj_frame.h lj_bc.h lj_mcode.h lj_jit.h lj_ir.h lj_trace.h \
+ lj_state.h lj_frame.h lj_bc.h lj_ctype.h lj_trace.h lj_jit.h lj_ir.h \
  lj_dispatch.h lj_traceerr.h lj_vm.h lj_lex.h lj_alloc.h
 lj_str.o: lj_str.c lj_obj.h lua.h luaconf.h lj_def.h lj_arch.h lj_gc.h \
  lj_err.h lj_errmsg.h lj_str.h lj_state.h lj_char.h
@@ -130,13 +132,14 @@ ljamalg.o: ljamalg.c lua.h luaconf.h lauxlib.h lj_gc.c lj_obj.h lj_def.h \
  lj_udata.h lj_meta.h lj_state.h lj_frame.h lj_bc.h lj_trace.h lj_jit.h \
  lj_ir.h lj_dispatch.h lj_traceerr.h lj_vm.h lj_err.c lj_char.c lj_char.h \
  lj_bc.c lj_bcdef.h lj_obj.c lj_str.c lj_tab.c lj_func.c lj_udata.c \
- lj_meta.c lj_state.c lj_mcode.h lj_lex.h lj_alloc.h lj_dispatch.c \
+ lj_meta.c lj_state.c lj_ctype.h lj_lex.h lj_alloc.h lj_dispatch.c \
  lj_ff.h lj_ffdef.h luajit.h lj_vmevent.c lj_vmevent.h lj_api.c \
- lj_parse.h lj_lex.c lj_parse.c lj_lib.c lj_lib.h lj_ir.c lj_iropt.h \
- lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c lj_opt_dce.c \
- lj_opt_loop.c lj_snap.h lj_mcode.c lj_snap.c lj_target.h lj_target_*.h \
- lj_record.c lj_record.h lj_asm.h lj_recdef.h lj_asm.c lj_trace.c \
- lj_gdbjit.h lj_gdbjit.c lj_alloc.c lib_aux.c lib_base.c lualib.h \
- lj_libdef.h lib_math.c lib_string.c lib_table.c lib_io.c lib_os.c \
- lib_package.c lib_debug.c lib_bit.c lib_jit.c lib_init.c
-luajit.o: luajit.c lua.h luaconf.h lauxlib.h lualib.h luajit.h
+ lj_parse.h lj_lex.c lj_parse.c lj_ctype.c lj_lib.c lj_lib.h lj_ir.c \
+ lj_iropt.h lj_opt_mem.c lj_opt_fold.c lj_folddef.h lj_opt_narrow.c \
+ lj_opt_dce.c lj_opt_loop.c lj_snap.h lj_mcode.c lj_mcode.h lj_snap.c \
+ lj_target.h lj_target_*.h lj_record.c lj_record.h lj_asm.h lj_recdef.h \
+ lj_asm.c lj_trace.c lj_gdbjit.h lj_gdbjit.c lj_alloc.c lib_aux.c \
+ lib_base.c lualib.h lj_libdef.h lib_math.c lib_string.c lib_table.c \
+ lib_io.c lib_os.c lib_package.c lib_debug.c lib_bit.c lib_jit.c \
+ lib_init.c
+luajit.o: luajit.c lua.h luaconf.h lauxlib.h lualib.h luajit.h lj_arch.h
diff --git a/src/lj_ctype.c b/src/lj_ctype.c
new file mode 100644
index 00000000..001d6f5a
--- /dev/null
+++ b/src/lj_ctype.c
@@ -0,0 +1,583 @@
+/*
+** C type 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_tab.h"
+#include "lj_ctype.h"
+
+/* -- C type definitions -------------------------------------------------- */
+
+/* Predefined typedefs. */
+#define CTTDDEF(_) \
+  /* Vararg handling. */ \
+  _("va_list",                  P_VOID) \
+  _("__builtin_va_list",        P_VOID) \
+  _("__gnuc_va_list",           P_VOID) \
+  /* From stddef.h. */ \
+  _("ptrdiff_t",                INT_PSZ) \
+  _("size_t",                   UINT_PSZ) \
+  _("wchar_t",                  WCHAR) \
+  /* Subset of stdint.h. */ \
+  _("int8_t",                   INT8) \
+  _("int16_t",                  INT16) \
+  _("int32_t",                  INT32) \
+  _("int64_t",                  INT64) \
+  _("uint8_t",                  UINT8) \
+  _("uint16_t",                 UINT16) \
+  _("uint32_t",                 UINT32) \
+  _("uint64_t",                 UINT64) \
+  _("intptr_t",                 INT_PSZ) \
+  _("uintptr_t",                UINT_PSZ) \
+  /* End of typedef list. */
+
+/* Keywords (only the ones we actually care for). */
+#define CTKWDEF(_) \
+  /* Type specifiers. */ \
+  _("void",             -1,     CTOK_VOID) \
+  _("_Bool",            1,      CTOK_BOOL) \
+  _("bool",             1,      CTOK_BOOL) \
+  _("char",             1,      CTOK_CHAR) \
+  _("int",              4,      CTOK_INT) \
+  _("__int8",           1,      CTOK_INT) \
+  _("__int16",          2,      CTOK_INT) \
+  _("__int32",          4,      CTOK_INT) \
+  _("__int64",          8,      CTOK_INT) \
+  _("float",            4,      CTOK_FP) \
+  _("double",           8,      CTOK_FP) \
+  _("long",             0,      CTOK_LONG) \
+  _("short",            0,      CTOK_SHORT) \
+  _("_Complex",         0,      CTOK_COMPLEX) \
+  _("complex",          0,      CTOK_COMPLEX) \
+  _("__complex",        0,      CTOK_COMPLEX) \
+  _("__complex__",      0,      CTOK_COMPLEX) \
+  _("signed",           0,      CTOK_SIGNED) \
+  _("__signed",         0,      CTOK_SIGNED) \
+  _("__signed__",       0,      CTOK_SIGNED) \
+  _("unsigned",         0,      CTOK_UNSIGNED) \
+  /* Type qualifiers. */ \
+  _("const",            0,      CTOK_CONST) \
+  _("__const",          0,      CTOK_CONST) \
+  _("__const__",        0,      CTOK_CONST) \
+  _("volatile",         0,      CTOK_VOLATILE) \
+  _("__volatile",       0,      CTOK_VOLATILE) \
+  _("__volatile__",     0,      CTOK_VOLATILE) \
+  _("restrict",         0,      CTOK_RESTRICT) \
+  _("__restrict",       0,      CTOK_RESTRICT) \
+  _("__restrict__",     0,      CTOK_RESTRICT) \
+  _("inline",           0,      CTOK_INLINE) \
+  _("__inline",         0,      CTOK_INLINE) \
+  _("__inline__",       0,      CTOK_INLINE) \
+  /* Storage class specifiers. */ \
+  _("typedef",          0,      CTOK_TYPEDEF) \
+  _("extern",           0,      CTOK_EXTERN) \
+  _("static",           0,      CTOK_STATIC) \
+  _("auto",             0,      CTOK_AUTO) \
+  _("register",         0,      CTOK_REGISTER) \
+  /* GCC Attributes. */ \
+  _("__extension__",    0,      CTOK_EXTENSION) \
+  _("__attribute",      0,      CTOK_ATTRIBUTE) \
+  _("__attribute__",    0,      CTOK_ATTRIBUTE) \
+  _("asm",              0,      CTOK_ASM) \
+  _("__asm",            0,      CTOK_ASM) \
+  _("__asm__",          0,      CTOK_ASM) \
+  /* MSVC Attributes. */ \
+  _("__declspec",       0,      CTOK_DECLSPEC) \
+  _("__cdecl",          CTCC_CDECL,     CTOK_CCDECL) \
+  _("__thiscall",       CTCC_THISCALL,  CTOK_CCDECL) \
+  _("__fastcall",       CTCC_FASTCALL,  CTOK_CCDECL) \
+  _("__stdcall",        CTCC_STDCALL,   CTOK_CCDECL) \
+  _("__ptr32",          4,      CTOK_PTRSZ) \
+  _("__ptr64",          8,      CTOK_PTRSZ) \
+  /* Other type specifiers. */ \
+  _("struct",           0,      CTOK_STRUCT) \
+  _("union",            0,      CTOK_UNION) \
+  _("enum",             0,      CTOK_ENUM) \
+  /* Operators. */ \
+  _("sizeof",           0,      CTOK_SIZEOF) \
+  _("__alignof",        0,      CTOK_ALIGNOF) \
+  _("__alignof__",      0,      CTOK_ALIGNOF) \
+  /* End of keyword list. */
+
+/* Type info for predefined types. Size merged in. */
+static CTInfo lj_ctype_typeinfo[] = {
+#define CTTYINFODEF(id, sz, ct, info)   CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
+#define CTTDINFODEF(name, id)           CTINFO(CT_TYPEDEF, CTID_##id),
+#define CTKWINFODEF(name, sz, kw)       CTINFO(CT_KW,(((sz)&0x3fu)<<10)+(kw)),
+CTTYDEF(CTTYINFODEF)
+CTTDDEF(CTTDINFODEF)
+CTKWDEF(CTKWINFODEF)
+#undef CTTYINFODEF
+#undef CTTDINFODEF
+#undef CTKWINFODEF
+  0
+};
+
+/* Predefined type names collected in a single string. */
+static const char * const lj_ctype_typenames =
+#define CTTDNAMEDEF(name, id)           name "\0"
+#define CTKWNAMEDEF(name, sz, cds)      name "\0"
+CTTDDEF(CTTDNAMEDEF)
+CTKWDEF(CTKWNAMEDEF)
+#undef CTTDNAMEDEF
+#undef CTKWNAMEDEF
+;
+
+#define CTTYPEINFO_NUM          (sizeof(lj_ctype_typeinfo)/sizeof(CTInfo)-1)
+#define CTTYPETAB_MIN           128
+
+/* -- C type interning ---------------------------------------------------- */
+
+#define ct_hashtype(info, size) (hashrot(info, size) & CTHASH_MASK)
+#define ct_hashname(name) \
+  (hashrot(u32ptr(name), u32ptr(name) + HASH_BIAS) & CTHASH_MASK)
+
+/* Create new type element. */
+CTypeID lj_ctype_new(CTState *cts, CType **ctp)
+{
+  CTypeID id = cts->top;
+  CType *ct;
+  lua_assert(cts->L);
+  if (LJ_UNLIKELY(id >= cts->sizetab)) {
+    if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
+    lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
+  }
+  cts->top = id+1;
+  *ctp = ct = &cts->tab[id];
+  ct->info = 0;
+  ct->size = 0;
+  ct->sib = 0;
+  ct->next = 0;
+  setgcrefnull(ct->name);
+  return id;
+}
+
+/* Intern a type element. */
+CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size)
+{
+  uint32_t h = ct_hashtype(info, size);
+  CTypeID id = cts->hash[h];
+  lua_assert(cts->L);
+  while (id) {
+    CType *ct = ctype_get(cts, id);
+    if (ct->info == info && ct->size == size)
+      return id;
+    id = ct->next;
+  }
+  id = cts->top;
+  if (LJ_UNLIKELY(id >= cts->sizetab)) {
+    if (id >= CTID_MAX) lj_err_msg(cts->L, LJ_ERR_TABOV);
+    lj_mem_growvec(cts->L, cts->tab, cts->sizetab, CTID_MAX, CType);
+  }
+  cts->top = id+1;
+  cts->tab[id].info = info;
+  cts->tab[id].size = size;
+  cts->tab[id].sib = 0;
+  cts->tab[id].next = cts->hash[h];
+  setgcrefnull(cts->tab[id].name);
+  cts->hash[h] = (CTypeID1)id;
+  return id;
+}
+
+/* Add type element to hash table. */
+static void ctype_addtype(CTState *cts, CType *ct, CTypeID id)
+{
+  uint32_t h = ct_hashtype(ct->info, ct->size);
+  ct->next = cts->hash[h];
+  cts->hash[h] = (CTypeID1)id;
+}
+
+/* Add named element to hash table. */
+void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id)
+{
+  uint32_t h = ct_hashname(gcref(ct->name));
+  ct->next = cts->hash[h];
+  cts->hash[h] = (CTypeID1)id;
+}
+
+/* Get a C type by name, matching the type mask. */
+CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name, uint32_t tmask)
+{
+  CTypeID id = cts->hash[ct_hashname(name)];
+  while (id) {
+    CType *ct = ctype_get(cts, id);
+    if (gcref(ct->name) == obj2gco(name) &&
+        ((tmask >> ctype_type(ct->info)) & 1)) {
+      *ctp = ct;
+      return id;
+    }
+    id = ct->next;
+  }
+  *ctp = &cts->tab[0];  /* Simplify caller logic. ctype_get() would assert. */
+  return 0;
+}
+
+/* Get a struct/union/enum/function field by name. */
+CType *lj_ctype_getfield(CTState *cts, CType *ct, GCstr *name, CTSize *ofs)
+{
+  while (ct->sib) {
+    ct = ctype_get(cts, ct->sib);
+    if (gcref(ct->name) == obj2gco(name)) {
+      *ofs = ct->size;
+      return ct;
+    }
+    if (ctype_isxattrib(ct->info, CTA_SUBTYPE)) {
+      CType *fct = lj_ctype_getfield(cts, ctype_child(cts, ct), name, ofs);
+      if (fct) {
+        *ofs += ct->size;
+        return fct;
+      }
+    }
+  }
+  return NULL;  /* Not found. */
+}
+
+/* -- C type information -------------------------------------------------- */
+
+/* Follow references and get raw type for a C type ID. */
+CType *lj_ctype_rawref(CTState *cts, CTypeID id)
+{
+  CType *ct = ctype_get(cts, id);
+  while (ctype_isattrib(ct->info) || ctype_isref(ct->info))
+    ct = ctype_child(cts, ct);
+  return ct;
+}
+
+/* Get size for a C type ID. Does NOT support VLA/VLS. */
+CTSize lj_ctype_size(CTState *cts, CTypeID id)
+{
+  CType *ct = ctype_raw(cts, id);
+  return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
+}
+
+/* Get size for a variable-length C type. Does NOT support other C types. */
+CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem)
+{
+  uint64_t xsz = 0;
+  if (ctype_isstruct(ct->info)) {
+    CTypeID arrid = 0, fid = ct->sib;
+    xsz = ct->size;  /* Add the struct size. */
+    while (fid) {
+      CType *ctf = ctype_get(cts, fid);
+      if (ctype_type(ctf->info) == CT_FIELD)
+        arrid = ctype_cid(ctf->info);  /* Remember last field of VLS. */
+      fid = ctf->sib;
+    }
+    ct = ctype_raw(cts, arrid);
+  }
+  lua_assert(ctype_isvlarray(ct->info));  /* Must be a VLA. */
+  ct = ctype_rawchild(cts, ct);  /* Get array element. */
+  lua_assert(ctype_hassize(ct->info));
+  /* Calculate actual size of VLA and check for overflow. */
+  xsz += (uint64_t)ct->size * nelem;
+  return xsz < 0x80000000u ? (CTSize)xsz : CTSIZE_INVALID;
+}
+
+/* Get type, qualifiers, size and alignment for a C type ID. */
+CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp)
+{
+  CTInfo qual = 0;
+  CType *ct = ctype_get(cts, id);
+  for (;;) {
+    CTInfo info = ct->info;
+    if (ctype_isenum(info)) {
+      /* Follow child. Need to look at its attributes, too. */
+    } else if (ctype_isattrib(info)) {
+      if (ctype_isxattrib(info, CTA_QUAL))
+        qual |= ct->size;
+      else if (ctype_isxattrib(info, CTA_ALIGN) && !(qual & CTFP_ALIGNED))
+        qual |= CTFP_ALIGNED + CTALIGN(ct->size);
+    } else {
+      if (!(qual & CTFP_ALIGNED)) qual |= (info & CTF_ALIGN);
+      qual |= (info & ~(CTF_ALIGN|CTMASK_CID));
+      lua_assert(ctype_hassize(info) || ctype_isfunc(info));
+      *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
+      break;
+    }
+    ct = ctype_get(cts, ctype_cid(info));
+  }
+  return qual;
+}
+
+/* -- C type representation ----------------------------------------------- */
+
+/* Fixed max. length of a C type representation. */
+#define CTREPR_MAX              512
+
+typedef struct CTRepr {
+  char *pb, *pe;
+  CTState *cts;
+  lua_State *L;
+  int needsp;
+  int ok;
+  char buf[CTREPR_MAX];
+} CTRepr;
+
+/* Prepend string. */
+static void ctype_prepstr(CTRepr *ctr, const char *str, MSize len)
+{
+  char *p = ctr->pb;
+  if (ctr->buf + len+1 > p) { ctr->ok = 0; return; }
+  if (ctr->needsp) *--p = ' ';
+  ctr->needsp = 1;
+  p -= len;
+  while (len-- > 0) p[len] = str[len];
+  ctr->pb = p;
+}
+
+#define ctype_preplit(ctr, str) ctype_prepstr((ctr), "" str, sizeof(str)-1)
+
+/* Prepend char. */
+static void ctype_prepc(CTRepr *ctr, int c)
+{
+  if (ctr->buf >= ctr->pb) { ctr->ok = 0; return; }
+  *--ctr->pb = c;
+}
+
+/* Prepend number. */
+static void ctype_prepnum(CTRepr *ctr, uint32_t n)
+{
+  char *p = ctr->pb;
+  if (ctr->buf + 10+1 > p) { ctr->ok = 0; return; }
+  do { *--p = (char)('0' + n % 10); } while (n /= 10);
+  ctr->pb = p;
+  ctr->needsp = 0;
+}
+
+/* Append char. */
+static void ctype_appc(CTRepr *ctr, int c)
+{
+  if (ctr->pe >= ctr->buf + CTREPR_MAX) { ctr->ok = 0; return; }
+  *ctr->pe++ = c;
+}
+
+/* Append number. */
+static void ctype_appnum(CTRepr *ctr, uint32_t n)
+{
+  char buf[10];
+  char *p = buf+sizeof(buf);
+  char *q = ctr->pe;
+  if (q > ctr->buf + CTREPR_MAX - 10) { ctr->ok = 0; return; }
+  do { *--p = (char)('0' + n % 10); } while (n /= 10);
+  do { *q++ = *p++; } while (p < buf+sizeof(buf));
+  ctr->pe = q;
+}
+
+/* Prepend qualifiers. */
+static void ctype_prepqual(CTRepr *ctr, CTInfo info)
+{
+  if ((info & CTF_VOLATILE)) ctype_preplit(ctr, "volatile");
+  if ((info & CTF_CONST)) ctype_preplit(ctr, "const");
+}
+
+/* Prepend named type. */
+static void ctype_preptype(CTRepr *ctr, CType *ct, CTInfo qual, const char *t)
+{
+  if (gcref(ct->name)) {
+    GCstr *str = gco2str(gcref(ct->name));
+    ctype_prepstr(ctr, strdata(str), str->len);
+  } else {
+    if (ctr->needsp) ctype_prepc(ctr, ' ');
+    ctype_prepnum(ctr, ctype_typeid(ctr->cts, ct));
+    ctr->needsp = 1;
+  }
+  ctype_prepstr(ctr, t, (MSize)strlen(t));
+  ctype_prepqual(ctr, qual);
+}
+
+void ctype_repr(CTRepr *ctr, CTypeID id)
+{
+  CType *ct = ctype_get(ctr->cts, id);
+  CTInfo qual = 0;
+  int ptrto = 0;
+  for (;;) {
+    CTInfo info = ct->info;
+    CTSize size = ct->size;
+    switch (ctype_type(info)) {
+    case CT_NUM:
+      if ((info & CTF_BOOL)) {
+        ctype_preplit(ctr, "bool");
+      } else if ((info & CTF_FP)) {
+        if (size == sizeof(double)) ctype_preplit(ctr, "double");
+        else if (size == sizeof(float)) ctype_preplit(ctr, "float");
+        else ctype_preplit(ctr, "long double");
+      } else if (size == 1) {
+        if (!((info ^ CTF_UCHAR) & CTF_UNSIGNED)) ctype_preplit(ctr, "char");
+        else if (CTF_UCHAR) ctype_preplit(ctr, "signed char");
+        else ctype_preplit(ctr, "unsigned char");
+      } else if (size < 8) {
+        if (size == 4) ctype_preplit(ctr, "int");
+        else ctype_preplit(ctr, "short");
+        if ((info & CTF_UNSIGNED)) ctype_preplit(ctr, "unsigned");
+      } else {
+        ctype_preplit(ctr, "_t");
+        ctype_prepnum(ctr, size*8);
+        ctype_preplit(ctr, "int");
+        if ((info & CTF_UNSIGNED)) ctype_prepc(ctr, 'u');
+      }
+      ctype_prepqual(ctr, (qual|info));
+      return;
+    case CT_VOID:
+      ctype_preplit(ctr, "void");
+      ctype_prepqual(ctr, (qual|info));
+      return;
+    case CT_STRUCT:
+      ctype_preptype(ctr, ct, qual, (info & CTF_UNION) ? "union" : "struct");
+      return;
+    case CT_ENUM:
+      ctype_preptype(ctr, ct, qual, "enum");
+      return;
+    case CT_ATTRIB:
+      if (ctype_attrib(info) == CTA_QUAL) qual |= size;
+      break;
+    case CT_PTR:
+      if ((info & CTF_REF)) {
+        ctype_prepc(ctr, '&');
+      } else {
+        ctype_prepqual(ctr, (qual|info));
+        if (LJ_64 && size == 4) ctype_preplit(ctr, "__ptr32");
+        ctype_prepc(ctr, '*');
+      }
+      qual = 0;
+      ptrto = 1;
+      ctr->needsp = 1;
+      break;
+    case CT_ARRAY:
+      ctr->needsp = 1;
+      if (ctype_isrefarray(info)) {
+        if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
+        ctype_appc(ctr, '[');
+        if (size != CTSIZE_INVALID) {
+          CTSize csize = ctype_child(ctr->cts, ct)->size;
+          ctype_appnum(ctr, csize ? size/csize : 0);
+        } else if ((info & CTF_VLA)) {
+          ctype_appc(ctr, '?');
+        }
+        ctype_appc(ctr, ']');
+      } else if ((info & CTF_COMPLEX)) {
+        if (size == 2*sizeof(float)) ctype_preplit(ctr, "float");
+        ctype_preplit(ctr, "complex");
+        return;
+      } else {
+        ctype_preplit(ctr, ")))");
+        ctype_prepnum(ctr, size);
+        ctype_preplit(ctr, "__attribute__((vector_size(");
+      }
+      break;
+    case CT_FUNC:
+      ctr->needsp = 1;
+      if (ptrto) { ptrto = 0; ctype_prepc(ctr, '('); ctype_appc(ctr, ')'); }
+      ctype_appc(ctr, '(');
+      ctype_appc(ctr, ')');
+      break;
+    default:
+      lua_assert(0);
+      break;
+    }
+    ct = ctype_get(ctr->cts, ctype_cid(info));
+  }
+}
+
+/* Return a printable representation of a C type. */
+GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name)
+{
+  global_State *g = G(L);
+  CTRepr ctr;
+  ctr.pb = ctr.pe = &ctr.buf[CTREPR_MAX/2];
+  ctr.cts = ctype_ctsG(g);
+  ctr.L = L;
+  ctr.ok = 1;
+  ctr.needsp = 0;
+  if (name) ctype_prepstr(&ctr, strdata(name), name->len);
+  ctype_repr(&ctr, id);
+  if (LJ_UNLIKELY(!ctr.ok)) return lj_str_newlit(L, "?");
+  return lj_str_new(L, ctr.pb, ctr.pe - ctr.pb);
+}
+
+/* Convert int64_t/uint64_t to string with 'LL' or 'ULL' suffix. */
+GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned)
+{
+  char buf[1+20+3];
+  char *p = buf+sizeof(buf);
+  int sign = 0;
+  *--p = 'L'; *--p = 'L';
+  if (isunsigned) {
+    *--p = 'U';
+  } else if ((int64_t)n < 0) {
+    n = (uint64_t)-(int64_t)n;
+    sign = 1;
+  }
+  do { *--p = (char)('0' + n % 10); } while (n /= 10);
+  if (sign) *--p = '-';
+  return lj_str_new(L, p, (size_t)(buf+sizeof(buf)-p));
+}
+
+/* Convert complex to string with 'i' or 'I' suffix. */
+GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size)
+{
+  char buf[2*LUAI_MAXNUMBER2STR+2+1];
+  TValue re, im;
+  size_t len;
+  if (size == 2*sizeof(double)) {
+    re.n = *(double *)sp; im.n = ((double *)sp)[1];
+  } else {
+    re.n = (double)*(float *)sp; im.n = (double)((float *)sp)[1];
+  }
+  len = lj_str_bufnum(buf, &re);
+  if (!(im.u32.hi & 0x80000000u) || im.n != im.n) buf[len++] = '+';
+  len += lj_str_bufnum(buf+len, &im);
+  buf[len] = buf[len-1] >= 'a' ? 'I' : 'i';
+  return lj_str_new(L, buf, len+1);
+}
+
+/* -- C type state -------------------------------------------------------- */
+
+/* Initialize C type table and state. */
+void lj_ctype_init(lua_State *L)
+{
+  CTState *cts = lj_mem_newt(L, sizeof(CTState), CTState);
+  CType *ct = lj_mem_newvec(L, CTTYPETAB_MIN, CType);
+  const char *name = lj_ctype_typenames;
+  CTypeID id;
+  memset(cts, 0, sizeof(CTState));
+  cts->tab = ct;
+  cts->sizetab = CTTYPETAB_MIN;
+  cts->top = CTTYPEINFO_NUM;
+  cts->L = NULL;
+  cts->g = G(L);
+  for (id = 0; id < CTTYPEINFO_NUM; id++, ct++) {
+    CTInfo info = lj_ctype_typeinfo[id];
+    ct->size = (CTSize)((int32_t)(info << 16) >> 26);
+    ct->info = info & 0xffff03ffu;
+    if (ctype_type(info) == CT_KW || ctype_istypedef(info)) {
+      size_t len = strlen(name);
+      GCstr *str = lj_str_new(L, name, len);
+      ctype_setname(ct, str);
+      name += len+1;
+      lj_ctype_addname(cts, ct, id);
+    } else {
+      setgcrefnull(ct->name);
+      if (!ctype_isenum(info)) ctype_addtype(cts, ct, id);
+    }
+  }
+  setmref(G(L)->ctype_state, cts);
+}
+
+/* Free C type table and state. */
+void lj_ctype_freestate(global_State *g)
+{
+  CTState *cts = ctype_ctsG(g);
+  if (cts) {
+    lj_mem_freevec(g, cts->tab, cts->sizetab, CType);
+    lj_mem_freet(g, cts);
+  }
+}
+
+#endif
diff --git a/src/lj_ctype.h b/src/lj_ctype.h
new file mode 100644
index 00000000..826f9785
--- /dev/null
+++ b/src/lj_ctype.h
@@ -0,0 +1,438 @@
+/*
+** C type management.
+** Copyright (C) 2005-2010 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifndef _LJ_CTYPE_H
+#define _LJ_CTYPE_H
+
+#include "lj_obj.h"
+#include "lj_gc.h"
+
+#if LJ_HASFFI
+
+/* -- C type definitions -------------------------------------------------- */
+
+/* C type numbers. Highest 4 bits of C type info. ORDER CT. */
+enum {
+  /* Externally visible types. */
+  CT_NUM,               /* Integer or floating-point numbers. */
+  CT_STRUCT,            /* Struct or union. */
+  CT_PTR,               /* Pointer or reference. */
+  CT_ARRAY,             /* Array or complex type. */
+  CT_MAYCONVERT = CT_ARRAY,
+  CT_VOID,              /* Void type. */
+  CT_ENUM,              /* Enumeration. */
+  CT_HASSIZE = CT_ENUM,  /* Last type where ct->size holds the actual size. */
+  CT_FUNC,              /* Function. */
+  CT_TYPEDEF,           /* Typedef. */
+  CT_ATTRIB,            /* Miscellaneous attributes. */
+  /* Internal element types. */
+  CT_FIELD,             /* Struct/union field or function parameter. */
+  CT_BITFIELD,          /* Struct/union bitfield. */
+  CT_CONSTVAL,          /* Constant value. */
+  CT_EXTERN,            /* External reference. */
+  CT_KW                 /* Keyword. */
+};
+
+/*
+**  ---------- info ------------
+** |type      flags...  A   cid | size   |  sib  | next  | name  |
+** +----------------------------+--------+-------+-------+-------+--
+** |NUM       BFvcUL..  A       | size   |       | type  |       |
+** |STRUCT    ..vcU..V  A       | size   | field | name? | name? |
+** |PTR       ..vcR...  A   cid | size   |       | type  |       |
+** |ARRAY     VCvc...V  A   cid | size   |       | type  |       |
+** |VOID      ..vc....  A       | size   |       | type  |       |
+** |ENUM                A   cid | size   | const | name? | name? |
+** |FUNC      ....VS.. cc   cid | nargs  | field | name? | name? |
+** |TYPEDEF                 cid |        |       | name  | name  |
+** |ATTRIB        attrnum   cid | attr   | sib?  | type? |       |
+** |FIELD                   cid | offset | field |       | name? |
+** |BITFIELD  B.vcU csz bsz pos | offset | field |       | name? |
+** |CONSTVAL     c          cid | value  | const | name  | name  |
+** |EXTERN                  cid |        |       | name  | name  |
+** |KW                      tok | size   |       | name  | name  |
+** +----------------------------+--------+-------+-------+-------+--
+**        ^^  ^^--- bits used for C type conversion dispatch
+*/
+
+/* C type info flags.     TFFArrrr  */
+#define CTF_BOOL        0x08000000u     /* Boolean: NUM, BITFIELD. */
+#define CTF_FP          0x04000000u     /* Floating-point: NUM. */
+#define CTF_CONST       0x02000000u     /* Const qualifier. */
+#define CTF_VOLATILE    0x01000000u     /* Volatile qualifier. */
+#define CTF_UNSIGNED    0x00800000u     /* Unsigned: NUM, BITFIELD. */
+#define CTF_LONG        0x00400000u     /* Long: NUM. */
+#define CTF_VLA         0x00100000u     /* Variable-length: ARRAY, STRUCT. */
+#define CTF_REF         0x00800000u     /* Reference: PTR. */
+#define CTF_VECTOR      0x08000000u     /* Vector: ARRAY. */
+#define CTF_COMPLEX     0x04000000u     /* Complex: ARRAY. */
+#define CTF_UNION       0x00800000u     /* Union: STRUCT. */
+#define CTF_VARARG      0x00800000u     /* Vararg: FUNC. */
+#define CTF_SSEREGPARM  0x00400000u     /* SSE register parameters: FUNC. */
+
+#define CTF_QUAL        (CTF_CONST|CTF_VOLATILE)
+#define CTF_ALIGN       (CTMASK_ALIGN<<CTSHIFT_ALIGN)
+#define CTF_UCHAR       ((char)-1 > 0 ? CTF_UNSIGNED : 0)
+
+/* Flags used in parser.  .F.Ammvf   cp->attr  */
+#define CTFP_ALIGNED    0x00000001u     /* cp->attr + ALIGN */
+#define CTFP_PACKED     0x00000002u     /* cp->attr */
+/*                        ...C...f   cp->fattr */
+#define CTFP_CCONV      0x00000001u     /* cp->fattr + CCONV/[SSE]REGPARM */
+
+/* C type info bitfields. */
+#define CTMASK_CID      0x0000ffffu     /* Max. 65536 type IDs. */
+#define CTMASK_NUM      0xf0000000u     /* Max. 16 type numbers. */
+#define CTSHIFT_NUM     28
+#define CTMASK_ALIGN    15              /* Max. alignment is 2^15. */
+#define CTSHIFT_ALIGN   16
+#define CTMASK_ATTRIB   255             /* Max. 256 attributes. */
+#define CTSHIFT_ATTRIB  16
+#define CTMASK_CCONV    3               /* Max. 4 calling conventions. */
+#define CTSHIFT_CCONV   16
+#define CTMASK_REGPARM  3               /* Max. 0-3 regparms. */
+#define CTSHIFT_REGPARM 18
+/* Bitfields only used in parser. */
+#define CTMASK_VSIZEP   15              /* Max. vector size is 2^15. */
+#define CTSHIFT_VSIZEP  4
+#define CTMASK_MSIZEP   255             /* Max. type size (via mode) is 128. */
+#define CTSHIFT_MSIZEP  8
+
+/* Info bits for BITFIELD. Max. size of bitfield is 64 bits. */
+#define CTBSZ_MAX       32              /* Max. size of bitfield is 32 bit. */
+#define CTBSZ_FIELD     127             /* Temp. marker for regular field. */
+#define CTMASK_BITPOS   127
+#define CTMASK_BITBSZ   127
+#define CTMASK_BITCSZ   127
+#define CTSHIFT_BITPOS  0
+#define CTSHIFT_BITBSZ  8
+#define CTSHIFT_BITCSZ  16
+
+#define CTF_INSERT(info, field, val) \
+  info = (info & ~(CTMASK_##field<<CTSHIFT_##field)) | \
+          (((CTSize)(val) & CTMASK_##field) << CTSHIFT_##field)
+
+/* Calling conventions. */
+enum { CTCC_CDECL, CTCC_THISCALL, CTCC_FASTCALL, CTCC_STDCALL };
+
+/* Attribute numbers. */
+enum {
+  CTA_NONE,             /* Ignored attribute. Must be zero. */
+  CTA_QUAL,             /* Unmerged qualifiers. */
+  CTA_ALIGN,            /* Alignment override. */
+  CTA_SUBTYPE,          /* Transparent sub-type. */
+  CTA_BAD,              /* To catch bad IDs. */
+  CTA__MAX
+};
+
+/* Special sizes. */
+#define CTSIZE_INVALID  0xffffffffu
+
+typedef uint32_t CTInfo;        /* Type info. */
+typedef uint32_t CTSize;        /* Type size. */
+typedef uint32_t CTypeID;       /* Type ID. */
+typedef uint16_t CTypeID1;      /* Minimum-sized type ID. */
+
+/* C type table element. */
+typedef struct CType {
+  CTInfo info;          /* Type info. */
+  CTSize size;          /* Type size or other info. */
+  CTypeID1 sib;         /* Sibling element. */
+  CTypeID1 next;        /* Next element in hash chain. */
+  GCRef name;           /* Element name (GCstr). */
+} CType;
+
+#define CTHASH_SIZE     128     /* Number of hash anchors. */
+#define CTHASH_MASK     (CTHASH_SIZE-1)
+
+/* C type state. */
+typedef struct CTState {
+  CType *tab;           /* C type table. */
+  CTypeID top;          /* Current top of C type table. */
+  MSize sizetab;        /* Size of C type table. */
+  lua_State *L;         /* Lua state (needed for errors and allocations). */
+  global_State *g;      /* Global state. */
+  CTypeID1 hash[CTHASH_SIZE];  /* Hash anchors for C type table. */
+} CTState;
+
+#define CTINFO(ct, flags)       (((CTInfo)(ct) << CTSHIFT_NUM) + (flags))
+#define CTALIGN(al)             ((CTSize)(al) << CTSHIFT_ALIGN)
+#define CTATTRIB(at)            ((CTInfo)(at) << CTSHIFT_ATTRIB)
+
+#define ctype_type(info)        ((info) >> CTSHIFT_NUM)
+#define ctype_cid(info)         ((CTypeID)((info) & CTMASK_CID))
+#define ctype_align(info)       (((info) >> CTSHIFT_ALIGN) & CTMASK_ALIGN)
+#define ctype_attrib(info)      (((info) >> CTSHIFT_ATTRIB) & CTMASK_ATTRIB)
+#define ctype_bitpos(info)      (((info) >> CTSHIFT_BITPOS) & CTMASK_BITPOS)
+#define ctype_bitbsz(info)      (((info) >> CTSHIFT_BITBSZ) & CTMASK_BITBSZ)
+#define ctype_bitcsz(info)      (((info) >> CTSHIFT_BITCSZ) & CTMASK_BITCSZ)
+#define ctype_vsizeP(info)      (((info) >> CTSHIFT_VSIZEP) & CTMASK_VSIZEP)
+#define ctype_msizeP(info)      (((info) >> CTSHIFT_MSIZEP) & CTMASK_MSIZEP)
+
+/* Simple type checks. */
+#define ctype_isnum(info)       (ctype_type((info)) == CT_NUM)
+#define ctype_isvoid(info)      (ctype_type((info)) == CT_VOID)
+#define ctype_isptr(info)       (ctype_type((info)) == CT_PTR)
+#define ctype_isarray(info)     (ctype_type((info)) == CT_ARRAY)
+#define ctype_isstruct(info)    (ctype_type((info)) == CT_STRUCT)
+#define ctype_isfunc(info)      (ctype_type((info)) == CT_FUNC)
+#define ctype_isenum(info)      (ctype_type((info)) == CT_ENUM)
+#define ctype_istypedef(info)   (ctype_type((info)) == CT_TYPEDEF)
+#define ctype_isattrib(info)    (ctype_type((info)) == CT_ATTRIB)
+#define ctype_isfield(info)     (ctype_type((info)) == CT_FIELD)
+#define ctype_isbitfield(info)  (ctype_type((info)) == CT_BITFIELD)
+#define ctype_isconstval(info)  (ctype_type((info)) == CT_CONSTVAL)
+#define ctype_hassize(info)     (ctype_type((info)) <= CT_HASSIZE)
+
+/* Combined type and flag checks. */
+#define ctype_isinteger(info) \
+  (((info) & (CTMASK_NUM|CTF_BOOL|CTF_FP)) == CTINFO(CT_NUM, 0))
+#define ctype_isinteger_or_bool(info) \
+  (((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, 0))
+#define ctype_isbool(info) \
+  (((info) & (CTMASK_NUM|CTF_BOOL)) == CTINFO(CT_NUM, CTF_BOOL))
+#define ctype_isconstchar(ct) \
+  (((ct)->info & (CTMASK_NUM|CTF_CONST|CTF_BOOL|CTF_FP)) == \
+   CTINFO(CT_NUM, CTF_CONST) && (ct)->size == 1)
+
+#define ctype_ispointer(info) \
+  ((ctype_type(info) >> 1) == (CT_PTR >> 1))  /* Pointer or array. */
+#define ctype_isref(info) \
+  (((info) & (CTMASK_NUM|CTF_REF)) == CTINFO(CT_PTR, CTF_REF))
+
+#define ctype_isrefarray(info) \
+  (((info) & (CTMASK_NUM|CTF_VECTOR|CTF_COMPLEX)) == CTINFO(CT_ARRAY, 0))
+#define ctype_isvalarray(info) \
+  (ctype_isarray(info) && (info & (CTF_VECTOR|CTF_COMPLEX)))
+#define ctype_isvector(info) \
+  (((info) & (CTMASK_NUM|CTF_VECTOR)) == CTINFO(CT_ARRAY, CTF_VECTOR))
+#define ctype_iscomplex(info) \
+  (((info) & (CTMASK_NUM|CTF_COMPLEX)) == CTINFO(CT_ARRAY, CTF_COMPLEX))
+
+#define ctype_isvltype(info) \
+  (((info) & ((CTMASK_NUM|CTF_VLA) - (2u<<CTSHIFT_NUM))) == \
+   CTINFO(CT_STRUCT, CTF_VLA))  /* VL array or VL struct. */
+#define ctype_isvlarray(info) \
+  (((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_ARRAY, CTF_VLA))
+#define ctype_isvlstruct(info) \
+  (((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_STRUCT, CTF_VLA))
+
+#define ctype_isxattrib(info, at) \
+  (((info) & (CTMASK_NUM|CTATTRIB(CTMASK_ATTRIB))) == \
+   CTINFO(CT_ATTRIB, CTATTRIB(at)))
+
+LJ_STATIC_ASSERT(((int)CT_PTR & (int)CT_ARRAY) == CT_PTR);
+LJ_STATIC_ASSERT(((int)CT_STRUCT & (int)CT_ARRAY) == CT_STRUCT);
+
+/* Target-dependent sizes and alignments. */
+#if LJ_64
+#define CTSIZE_PTR      8
+#define CTALIGN_PTR     CTALIGN(3)
+#else
+#define CTSIZE_PTR      4
+#define CTALIGN_PTR     CTALIGN(2)
+#endif
+
+#define CTINFO_REF(ref) \
+  CTINFO(CT_PTR, (CTF_CONST|CTF_REF|CTALIGN_PTR) + (ref))
+
+#define CT_MEMALIGN     3       /* Alignment guaranteed by memory allocator. */
+
+/* -- Predefined types ---------------------------------------------------- */
+
+/* Target-dependent types. */
+#if LJ_TARGET_PPC
+#define CTTYDEFP(_) \
+  _(LINT32,             4,      CT_NUM, CTF_LONG|CTALIGN(2))
+#else
+#define CTTYDEFP(_)
+#endif
+
+/* Common types. */
+#define CTTYDEF(_) \
+  _(NONE,               0,      CT_ATTRIB, CTATTRIB(CTA_BAD)) \
+  _(VOID,               -1,     CT_VOID, CTALIGN(0)) \
+  _(CVOID,              -1,     CT_VOID, CTF_CONST|CTALIGN(0)) \
+  _(BOOL,               1,      CT_NUM, CTF_BOOL|CTF_UNSIGNED|CTALIGN(0)) \
+  _(CCHAR,              1,      CT_NUM, CTF_CONST|CTF_UCHAR|CTALIGN(0)) \
+  _(INT8,               1,      CT_NUM, CTALIGN(0)) \
+  _(UINT8,              1,      CT_NUM, CTF_UNSIGNED|CTALIGN(0)) \
+  _(INT16,              2,      CT_NUM, CTALIGN(1)) \
+  _(UINT16,             2,      CT_NUM, CTF_UNSIGNED|CTALIGN(1)) \
+  _(INT32,              4,      CT_NUM, CTALIGN(2)) \
+  _(UINT32,             4,      CT_NUM, CTF_UNSIGNED|CTALIGN(2)) \
+  _(INT64,              8,      CT_NUM, CTF_LONG|CTALIGN(3)) \
+  _(UINT64,             8,      CT_NUM, CTF_UNSIGNED|CTF_LONG|CTALIGN(3)) \
+  _(FLOAT,              4,      CT_NUM, CTF_FP|CTALIGN(2)) \
+  _(DOUBLE,             8,      CT_NUM, CTF_FP|CTALIGN(3)) \
+  _(COMPLEX_FLOAT,      8,      CT_ARRAY, CTF_COMPLEX|CTALIGN(2)|CTID_FLOAT) \
+  _(COMPLEX_DOUBLE,     16,     CT_ARRAY, CTF_COMPLEX|CTALIGN(3)|CTID_DOUBLE) \
+  _(P_VOID,     CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_VOID) \
+  _(P_CVOID,    CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_CVOID) \
+  _(P_CCHAR,    CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_CCHAR) \
+  _(A_CCHAR,            -1,     CT_ARRAY, CTF_CONST|CTALIGN(0)|CTID_CCHAR) \
+  _(CTYPEID,            4,      CT_ENUM, CTALIGN(2)|CTID_INT32) \
+  CTTYDEFP(_) \
+  /* End of type list. */
+
+/* Public predefined type IDs. */
+enum {
+#define CTTYIDDEF(id, sz, ct, info)     CTID_##id,
+CTTYDEF(CTTYIDDEF)
+#undef CTTYIDDEF
+  /* Predefined typedefs and keywords follow. */
+  CTID_MAX = 65536
+};
+
+/* Target-dependent type IDs. */
+#if LJ_64
+#define CTID_INT_PSZ    CTID_INT64
+#define CTID_UINT_PSZ   CTID_UINT64
+#else
+#define CTID_INT_PSZ    CTID_INT32
+#define CTID_UINT_PSZ   CTID_UINT32
+#endif
+
+#if LJ_ABI_WIN
+#define CTID_WCHAR      CTID_UINT16
+#elif LJ_TARGET_PPC
+#define CTID_WCHAR      CTID_LINT32
+#else
+#define CTID_WCHAR      CTID_INT32
+#endif
+
+/* -- C tokens and keywords ----------------------------------------------- */
+
+/* C lexer keywords. */
+#define CTOKDEF(_) \
+  _(IDENT, "<identifier>") _(STRING, "<string>") \
+  _(INTEGER, "<integer>") _(EOF, "<eof>") \
+  _(OROR, "||") _(ANDAND, "&&") _(EQ, "==") _(NE, "!=") \
+  _(LE, "<=") _(GE, ">=") _(SHL, "<<") _(SHR, ">>") _(DEREF, "->")
+
+/* Simple declaration specifiers. */
+#define CDSDEF(_) \
+  _(VOID) _(BOOL) _(CHAR) _(INT) _(FP) \
+  _(LONG) _(LONGLONG) _(SHORT) _(COMPLEX) _(SIGNED) _(UNSIGNED) \
+  _(CONST) _(VOLATILE) _(RESTRICT) _(INLINE) \
+  _(TYPEDEF) _(EXTERN) _(STATIC) _(AUTO) _(REGISTER)
+
+/* C keywords. */
+#define CKWDEF(_) \
+  CDSDEF(_) _(EXTENSION) _(ASM) _(ATTRIBUTE) \
+  _(DECLSPEC) _(CCDECL) _(PTRSZ) \
+  _(STRUCT) _(UNION) _(ENUM) \
+  _(SIZEOF) _(ALIGNOF)
+
+/* C token numbers. */
+enum {
+  CTOK_OFS = 255,
+#define CTOKNUM(name, sym)      CTOK_##name,
+#define CKWNUM(name)            CTOK_##name,
+CTOKDEF(CTOKNUM)
+CKWDEF(CKWNUM)
+#undef CTOKNUM
+#undef CKWNUM
+  CTOK_FIRSTDECL = CTOK_VOID,
+  CTOK_FIRSTSCL = CTOK_TYPEDEF,
+  CTOK_LASTDECLFLAG = CTOK_REGISTER,
+  CTOK_LASTDECL = CTOK_ENUM
+};
+
+/* Declaration specifier flags. */
+enum {
+#define CDSFLAG(name)   CDF_##name = (1u << (CTOK_##name - CTOK_FIRSTDECL)),
+CDSDEF(CDSFLAG)
+#undef CDSFLAG
+  CDF__END
+};
+
+#define CDF_SCL  (CDF_TYPEDEF|CDF_EXTERN|CDF_STATIC|CDF_AUTO|CDF_REGISTER)
+
+/* -- C type management --------------------------------------------------- */
+
+#define ctype_ctsG(g)           (mref((g)->ctype_state, CTState))
+
+/* Get C type state. */
+static LJ_AINLINE CTState *ctype_cts(lua_State *L)
+{
+  CTState *cts = ctype_ctsG(G(L));
+  cts->L = L;  /* Save L for errors and allocations. */
+  return cts;
+}
+
+/* Save and restore state of C type table. */
+#define LJ_CTYPE_SAVE(cts)      CTState savects_ = *(cts)
+#define LJ_CTYPE_RESTORE(cts) \
+  ((cts)->top = savects_.top, \
+   memcpy((cts)->hash, savects_.hash, sizeof(savects_.hash)))
+
+/* Check C type ID for validity when assertions are enabled. */
+static LJ_AINLINE CTypeID ctype_check(CTState *cts, CTypeID id)
+{
+  lua_assert(id > 0 && id < cts->top); UNUSED(cts);
+  return id;
+}
+
+/* Get C type for C type ID. */
+static LJ_AINLINE CType *ctype_get(CTState *cts, CTypeID id)
+{
+  return &cts->tab[ctype_check(cts, id)];
+}
+
+/* Get C type ID for a C type. */
+#define ctype_typeid(cts, ct)   ((CTypeID)((ct) - (cts)->tab))
+
+/* Get child C type. */
+static LJ_AINLINE CType *ctype_child(CTState *cts, CType *ct)
+{
+  lua_assert(!(ctype_isvoid(ct->info) || ctype_isstruct(ct->info) ||
+             ctype_isbitfield(ct->info)));  /* These don't have children. */
+  return ctype_get(cts, ctype_cid(ct->info));
+}
+
+/* Get raw type for a C type ID. */
+static LJ_AINLINE CType *ctype_raw(CTState *cts, CTypeID id)
+{
+  CType *ct = ctype_get(cts, id);
+  while (ctype_isattrib(ct->info)) ct = ctype_child(cts, ct);
+  return ct;
+}
+
+/* Get raw type of the child of a C type. */
+static LJ_AINLINE CType *ctype_rawchild(CTState *cts, CType *ct)
+{
+  do { ct = ctype_child(cts, ct); } while (ctype_isattrib(ct->info));
+  return ct;
+}
+
+/* Set the name of a C type table element. */
+static LJ_AINLINE void ctype_setname(CType *ct, GCstr *s)
+{
+  /* NOBARRIER: mark string as fixed -- the C type table is never collected. */
+  fixstring(s);
+  setgcref(ct->name, obj2gco(s));
+}
+
+LJ_FUNC CTypeID lj_ctype_new(CTState *cts, CType **ctp);
+LJ_FUNC CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size);
+LJ_FUNC void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id);
+LJ_FUNC CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name,
+                                 uint32_t tmask);
+LJ_FUNC CType *lj_ctype_getfield(CTState *cts, CType *ct, GCstr *name,
+                                 CTSize *ofs);
+LJ_FUNC CType *lj_ctype_rawref(CTState *cts, CTypeID id);
+LJ_FUNC CTSize lj_ctype_size(CTState *cts, CTypeID id);
+LJ_FUNC CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem);
+LJ_FUNC CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp);
+LJ_FUNC GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name);
+LJ_FUNC GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned);
+LJ_FUNC GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size);
+LJ_FUNC void lj_ctype_init(lua_State *L);
+LJ_FUNC void lj_ctype_freestate(global_State *g);
+
+#endif
+
+#endif
diff --git a/src/lj_state.c b/src/lj_state.c
index 91f35638..79ab34e3 100644
--- a/src/lj_state.c
+++ b/src/lj_state.c
@@ -18,8 +18,8 @@
 #include "lj_meta.h"
 #include "lj_state.h"
 #include "lj_frame.h"
-#if LJ_HASJIT
-#include "lj_mcode.h"
+#if LJ_HASFFI
+#include "lj_ctype.h"
 #endif
 #include "lj_trace.h"
 #include "lj_dispatch.h"
@@ -160,6 +160,9 @@ static void close_state(lua_State *L)
   lua_assert(gcref(g->gc.root) == obj2gco(L));
   lua_assert(g->strnum == 0);
   lj_trace_freestate(g);
+#if LJ_HASFFI
+  lj_ctype_freestate(g);
+#endif
   lj_mem_freevec(g, g->strhash, g->strmask+1, GCRef);
   lj_str_freebuf(g, &g->tmpbuf);
   lj_mem_freevec(g, tvref(L->stack), L->stacksize, TValue);
diff --git a/src/ljamalg.c b/src/ljamalg.c
index 4f3b5025..d37daa2f 100644
--- a/src/ljamalg.c
+++ b/src/ljamalg.c
@@ -40,6 +40,7 @@
 #include "lj_api.c"
 #include "lj_lex.c"
 #include "lj_parse.c"
+#include "lj_ctype.c"
 #include "lj_lib.c"
 #include "lj_ir.c"
 #include "lj_opt_mem.c"