src/lib_ffi.c

   1 /*
   2 ** FFI library.
   3 ** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #define lib_ffi_c
   7 #define LUA_LIB
   8
   9 #include <errno.h>
  10
  11 #include "lua.h"
  12 #include "lauxlib.h"
  13 #include "lualib.h"
  14
  15 #include "lj_obj.h"
  16
  17 #if LJ_HASFFI
  18
  19 #include "lj_gc.h"
  20 #include "lj_err.h"
  21 #include "lj_str.h"
  22 #include "lj_tab.h"
  23 #include "lj_meta.h"
  24 #include "lj_ctype.h"
  25 #include "lj_cparse.h"
  26 #include "lj_cdata.h"
  27 #include "lj_cconv.h"
  28 #include "lj_carith.h"
  29 #include "lj_ccall.h"
  30 #include "lj_ccallback.h"
  31 #include "lj_clib.h"
  32 #include "lj_ff.h"
  33 #include "lj_lib.h"
  34
  35 /* -- C type checks ------------------------------------------------------- */
  36
  37 /* Check first argument for a C type and returns its ID. */
  38 static CTypeID ffi_checkctype(lua_State *L, CTState *cts)
  39 {
  40   TValue *o = L->base;
  41   if (!(o < L->top)) {
  42   err_argtype:
  43     lj_err_argtype(L, 1, "C type");
  44   }
  45   if (tvisstr(o)) {  /* Parse an abstract C type declaration. */
  46     GCstr *s = strV(o);
  47     CPState cp;
  48     int errcode;
  49     cp.L = L;
  50     cp.cts = cts;
  51     cp.srcname = strdata(s);
  52     cp.p = strdata(s);
  53     cp.mode = CPARSE_MODE_ABSTRACT|CPARSE_MODE_NOIMPLICIT;
  54     errcode = lj_cparse(&cp);
  55     if (errcode) lj_err_throw(L, errcode);  /* Propagate errors. */
  56     return cp.val.id;
  57   } else {
  58     GCcdata *cd;
  59     if (!tviscdata(o)) goto err_argtype;
  60     cd = cdataV(o);
  61     return cd->typeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) : cd->typeid;
  62   }
  63 }
  64
  65 /* Check argument for C data and return it. */
  66 static GCcdata *ffi_checkcdata(lua_State *L, int narg)
  67 {
  68   TValue *o = L->base + narg-1;
  69   if (!(o < L->top && tviscdata(o)))
  70     lj_err_argt(L, narg, LUA_TCDATA);
  71   return cdataV(o);
  72 }
  73
  74 /* Convert argument to C pointer. */
  75 static void *ffi_checkptr(lua_State *L, int narg, CTypeID id)
  76 {
  77   CTState *cts = ctype_cts(L);
  78   TValue *o = L->base + narg-1;
  79   void *p;
  80   if (o >= L->top)
  81     lj_err_arg(L, narg, LJ_ERR_NOVAL);
  82   lj_cconv_ct_tv(cts, ctype_get(cts, id), (uint8_t *)&p, o, CCF_ARG(narg));
  83   return p;
  84 }
  85
  86 /* Convert argument to int32_t. */
  87 static int32_t ffi_checkint(lua_State *L, int narg)
  88 {
  89   CTState *cts = ctype_cts(L);
  90   TValue *o = L->base + narg-1;
  91   int32_t i;
  92   if (o >= L->top)
  93     lj_err_arg(L, narg, LJ_ERR_NOVAL);
  94   lj_cconv_ct_tv(cts, ctype_get(cts, CTID_INT32), (uint8_t *)&i, o,
  95                  CCF_ARG(narg));
  96   return i;
  97 }
  98
  99 /* -- C type metamethods -------------------------------------------------- */
 100
 101 #define LJLIB_MODULE_ffi_meta
 102
 103 /* Handle ctype __index/__newindex metamethods. */
 104 static int ffi_index_meta(lua_State *L, CTState *cts, CType *ct, MMS mm)
 105 {
 106   CTypeID id = ctype_typeid(cts, ct);
 107   cTValue *tv = lj_ctype_meta(cts, id, mm);
 108   TValue *base = L->base;
 109   if (!tv) {
 110     const char *s;
 111   err_index:
 112     s = strdata(lj_ctype_repr(L, id, NULL));
 113     if (tvisstr(L->base+1))
 114       lj_err_callerv(L, LJ_ERR_FFI_BADMEMBER, s, strVdata(L->base+1));
 115     else
 116       lj_err_callerv(L, LJ_ERR_FFI_BADIDX, s);
 117   }
 118   if (!tvisfunc(tv)) {
 119     if (mm == MM_index) {
 120       cTValue *o = lj_meta_tget(L, tv, base+1);
 121       if (o) {
 122         if (tvisnil(o)) goto err_index;
 123         copyTV(L, L->top-1, o);
 124         return 1;
 125       }
 126     } else {
 127       TValue *o = lj_meta_tset(L, tv, base+1);
 128       if (o) {
 129         copyTV(L, o, base+2);
 130         return 0;
 131       }
 132     }
 133     tv = L->top-1;
 134   }
 135   return lj_meta_tailcall(L, tv);
 136 }
 137
 138 LJLIB_CF(ffi_meta___index)      LJLIB_REC(cdata_index 0)
 139 {
 140   CTState *cts = ctype_cts(L);
 141   CTInfo qual = 0;
 142   CType *ct;
 143   uint8_t *p;
 144   TValue *o = L->base;
 145   if (!(o+1 < L->top && tviscdata(o)))  /* Also checks for presence of key. */
 146     lj_err_argt(L, 1, LUA_TCDATA);
 147   ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
 148   if ((qual & 1))
 149     return ffi_index_meta(L, cts, ct, MM_index);
 150   if (lj_cdata_get(cts, ct, L->top-1, p))
 151     lj_gc_check(L);
 152   return 1;
 153 }
 154
 155 LJLIB_CF(ffi_meta___newindex)   LJLIB_REC(cdata_index 1)
 156 {
 157   CTState *cts = ctype_cts(L);
 158   CTInfo qual = 0;
 159   CType *ct;
 160   uint8_t *p;
 161   TValue *o = L->base;
 162   if (!(o+2 < L->top && tviscdata(o)))  /* Also checks for key and value. */
 163     lj_err_argt(L, 1, LUA_TCDATA);
 164   ct = lj_cdata_index(cts, cdataV(o), o+1, &p, &qual);
 165   if ((qual & 1)) {
 166     if ((qual & CTF_CONST))
 167       lj_err_caller(L, LJ_ERR_FFI_WRCONST);
 168     return ffi_index_meta(L, cts, ct, MM_newindex);
 169   }
 170   lj_cdata_set(cts, ct, p, o+2, qual);
 171   return 0;
 172 }
 173
 174 /* Common handler for cdata arithmetic. */
 175 static int ffi_arith(lua_State *L)
 176 {
 177   MMS mm = (MMS)(curr_func(L)->c.ffid - (int)FF_ffi_meta___eq + (int)MM_eq);
 178   return lj_carith_op(L, mm);
 179 }
 180
 181 /* The following functions must be in contiguous ORDER MM. */
 182 LJLIB_CF(ffi_meta___eq)         LJLIB_REC(cdata_arith MM_eq)
 183 {
 184   return ffi_arith(L);
 185 }
 186
 187 LJLIB_CF(ffi_meta___len)        LJLIB_REC(cdata_arith MM_len)
 188 {
 189   return ffi_arith(L);
 190 }
 191
 192 LJLIB_CF(ffi_meta___lt)         LJLIB_REC(cdata_arith MM_lt)
 193 {
 194   return ffi_arith(L);
 195 }
 196
 197 LJLIB_CF(ffi_meta___le)         LJLIB_REC(cdata_arith MM_le)
 198 {
 199   return ffi_arith(L);
 200 }
 201
 202 LJLIB_CF(ffi_meta___concat)     LJLIB_REC(cdata_arith MM_concat)
 203 {
 204   return ffi_arith(L);
 205 }
 206
 207 /* Handle ctype __call metamethod. */
 208 static int ffi_call_meta(lua_State *L, CTypeID id)
 209 {
 210   CTState *cts = ctype_cts(L);
 211   CType *ct = ctype_raw(cts, id);
 212   cTValue *tv;
 213   if (ctype_isptr(ct->info)) id = ctype_cid(ct->info);
 214   tv = lj_ctype_meta(cts, id, MM_call);
 215   if (!tv)
 216     lj_err_callerv(L, LJ_ERR_FFI_BADCALL, strdata(lj_ctype_repr(L, id, NULL)));
 217   return lj_meta_tailcall(L, tv);
 218 }
 219
 220 /* Forward declaration. */
 221 static int lj_cf_ffi_new(lua_State *L);
 222
 223 LJLIB_CF(ffi_meta___call)       LJLIB_REC(cdata_call)
 224 {
 225   GCcdata *cd = ffi_checkcdata(L, 1);
 226   int ret;
 227   if (cd->typeid == CTID_CTYPEID)
 228     return lj_cf_ffi_new(L);
 229   if ((ret = lj_ccall_func(L, cd)) < 0)
 230     return ffi_call_meta(L, cd->typeid);
 231   return ret;
 232 }
 233
 234 LJLIB_CF(ffi_meta___add)        LJLIB_REC(cdata_arith MM_add)
 235 {
 236   return ffi_arith(L);
 237 }
 238
 239 LJLIB_CF(ffi_meta___sub)        LJLIB_REC(cdata_arith MM_sub)
 240 {
 241   return ffi_arith(L);
 242 }
 243
 244 LJLIB_CF(ffi_meta___mul)        LJLIB_REC(cdata_arith MM_mul)
 245 {
 246   return ffi_arith(L);
 247 }
 248
 249 LJLIB_CF(ffi_meta___div)        LJLIB_REC(cdata_arith MM_div)
 250 {
 251   return ffi_arith(L);
 252 }
 253
 254 LJLIB_CF(ffi_meta___mod)        LJLIB_REC(cdata_arith MM_mod)
 255 {
 256   return ffi_arith(L);
 257 }
 258
 259 LJLIB_CF(ffi_meta___pow)        LJLIB_REC(cdata_arith MM_pow)
 260 {
 261   return ffi_arith(L);
 262 }
 263
 264 LJLIB_CF(ffi_meta___unm)        LJLIB_REC(cdata_arith MM_unm)
 265 {
 266   return ffi_arith(L);
 267 }
 268 /* End of contiguous ORDER MM. */
 269
 270 LJLIB_CF(ffi_meta___tostring)
 271 {
 272   GCcdata *cd = ffi_checkcdata(L, 1);
 273   const char *msg = "cdata<%s>: %p";
 274   CTypeID id = cd->typeid;
 275   void *p = cdataptr(cd);
 276   if (id == CTID_CTYPEID) {
 277     msg = "ctype<%s>";
 278     id = *(CTypeID *)p;
 279   } else {
 280     CTState *cts = ctype_cts(L);
 281     CType *ct = ctype_raw(cts, id);
 282     if (ctype_isref(ct->info)) ct = ctype_rawchild(cts, ct);
 283     if (ctype_iscomplex(ct->info)) {
 284       setstrV(L, L->top-1, lj_ctype_repr_complex(L, cdataptr(cd), ct->size));
 285       goto checkgc;
 286     } else if (ct->size == 8 && ctype_isinteger(ct->info)) {
 287       setstrV(L, L->top-1, lj_ctype_repr_int64(L, *(uint64_t *)cdataptr(cd),
 288                                                (ct->info & CTF_UNSIGNED)));
 289       goto checkgc;
 290     } else if (ctype_isfunc(ct->info)) {
 291       p = *(void **)p;
 292     } else {
 293       if (ctype_isptr(ct->info)) {
 294         p = cdata_getptr(p, ct->size);
 295         ct = ctype_rawchild(cts, ct);
 296       }
 297       if (ctype_isstruct(ct->info) || ctype_isvector(ct->info)) {
 298         /* Handle ctype __tostring metamethod. */
 299         cTValue *tv = lj_ctype_meta(cts, ctype_typeid(cts, ct), MM_tostring);
 300         if (tv)
 301           return lj_meta_tailcall(L, tv);
 302       }
 303     }
 304   }
 305   lj_str_pushf(L, msg, strdata(lj_ctype_repr(L, id, NULL)), p);
 306 checkgc:
 307   lj_gc_check(L);
 308   return 1;
 309 }
 310
 311 LJLIB_PUSH("ffi") LJLIB_SET(__metatable)
 312
 313 #include "lj_libdef.h"
 314
 315 /* -- C library metamethods ----------------------------------------------- */
 316
 317 #define LJLIB_MODULE_ffi_clib
 318
 319 /* Index C library by a name. */
 320 static TValue *ffi_clib_index(lua_State *L)
 321 {
 322   TValue *o = L->base;
 323   CLibrary *cl;
 324   if (!(o < L->top && tvisudata(o) && udataV(o)->udtype == UDTYPE_FFI_CLIB))
 325     lj_err_argt(L, 1, LUA_TUSERDATA);
 326   cl = (CLibrary *)uddata(udataV(o));
 327   if (!(o+1 < L->top && tvisstr(o+1)))
 328     lj_err_argt(L, 2, LUA_TSTRING);
 329   return lj_clib_index(L, cl, strV(o+1));
 330 }
 331
 332 LJLIB_CF(ffi_clib___index)      LJLIB_REC(clib_index 1)
 333 {
 334   TValue *tv = ffi_clib_index(L);
 335   if (tviscdata(tv)) {
 336     CTState *cts = ctype_cts(L);
 337     GCcdata *cd = cdataV(tv);
 338     CType *s = ctype_get(cts, cd->typeid);
 339     if (ctype_isextern(s->info)) {
 340       CTypeID sid = ctype_cid(s->info);
 341       void *sp = *(void **)cdataptr(cd);
 342       CType *ct = ctype_raw(cts, sid);
 343       if (ctype_isenum(ct->info)) ct = ctype_child(cts, ct);
 344       if (lj_cconv_tv_ct(cts, ct, sid, L->top-1, sp))
 345         lj_gc_check(L);
 346       return 1;
 347     }
 348   }
 349   copyTV(L, L->top-1, tv);
 350   return 1;
 351 }
 352
 353 LJLIB_CF(ffi_clib___newindex)   LJLIB_REC(clib_index 0)
 354 {
 355   TValue *tv = ffi_clib_index(L);
 356   TValue *o = L->base+2;
 357   if (o < L->top && tviscdata(tv)) {
 358     CTState *cts = ctype_cts(L);
 359     GCcdata *cd = cdataV(tv);
 360     CType *d = ctype_get(cts, cd->typeid);
 361     if (ctype_isextern(d->info)) {
 362       CTInfo qual = 0;
 363       for (;;) {  /* Skip attributes and collect qualifiers. */
 364         d = ctype_child(cts, d);
 365         if (!ctype_isattrib(d->info)) break;
 366         if (ctype_attrib(d->info) == CTA_QUAL) qual |= d->size;
 367       }
 368       if (!((d->info|qual) & CTF_CONST)) {
 369         lj_cconv_ct_tv(cts, d, *(void **)cdataptr(cd), o, 0);
 370         return 0;
 371       }
 372     }
 373   }
 374   lj_err_caller(L, LJ_ERR_FFI_WRCONST);
 375   return 0;  /* unreachable */
 376 }
 377
 378 LJLIB_CF(ffi_clib___gc)
 379 {
 380   TValue *o = L->base;
 381   if (o < L->top && tvisudata(o) && udataV(o)->udtype == UDTYPE_FFI_CLIB)
 382     lj_clib_unload((CLibrary *)uddata(udataV(o)));
 383   return 0;
 384 }
 385
 386 #include "lj_libdef.h"
 387
 388 /* -- Callback function metamethods --------------------------------------- */
 389
 390 #define LJLIB_MODULE_ffi_callback
 391
 392 static int ffi_callback_set(lua_State *L, GCfunc *fn)
 393 {
 394   GCcdata *cd = ffi_checkcdata(L, 1);
 395   CTState *cts = ctype_cts(L);
 396   CType *ct = ctype_raw(cts, cd->typeid);
 397   if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
 398     MSize slot = lj_ccallback_ptr2slot(cts, *(void **)cdataptr(cd));
 399     if (slot < cts->cb.sizeid && cts->cb.cbid[slot] != 0) {
 400       GCtab *t = cts->miscmap;
 401       TValue *tv = lj_tab_setint(L, t, (int32_t)slot);
 402       if (fn) {
 403         setfuncV(L, tv, fn);
 404         lj_gc_anybarriert(L, t);
 405       } else {
 406         setnilV(tv);
 407         cts->cb.cbid[slot] = 0;
 408         cts->cb.topid = slot < cts->cb.topid ? slot : cts->cb.topid;
 409       }
 410       return 0;
 411     }
 412   }
 413   lj_err_caller(L, LJ_ERR_FFI_BADCBACK);
 414   return 0;
 415 }
 416
 417 LJLIB_CF(ffi_callback_free)
 418 {
 419   return ffi_callback_set(L, NULL);
 420 }
 421
 422 LJLIB_CF(ffi_callback_set)
 423 {
 424   GCfunc *fn = lj_lib_checkfunc(L, 2);
 425   return ffi_callback_set(L, fn);
 426 }
 427
 428 LJLIB_PUSH(top-1) LJLIB_SET(__index)
 429
 430 #include "lj_libdef.h"
 431
 432 /* -- FFI library functions ----------------------------------------------- */
 433
 434 #define LJLIB_MODULE_ffi
 435
 436 LJLIB_CF(ffi_cdef)
 437 {
 438   GCstr *s = lj_lib_checkstr(L, 1);
 439   CPState cp;
 440   int errcode;
 441   cp.L = L;
 442   cp.cts = ctype_cts(L);
 443   cp.srcname = strdata(s);
 444   cp.p = strdata(s);
 445   cp.mode = CPARSE_MODE_MULTI|CPARSE_MODE_DIRECT;
 446   errcode = lj_cparse(&cp);
 447   if (errcode) lj_err_throw(L, errcode);  /* Propagate errors. */
 448   lj_gc_check(L);
 449   return 0;
 450 }
 451
 452 LJLIB_CF(ffi_new)       LJLIB_REC(.)
 453 {
 454   CTState *cts = ctype_cts(L);
 455   CTypeID id = ffi_checkctype(L, cts);
 456   CType *ct = ctype_raw(cts, id);
 457   CTSize sz;
 458   CTInfo info = lj_ctype_info(cts, id, &sz);
 459   TValue *o = L->base+1;
 460   GCcdata *cd;
 461   if ((info & CTF_VLA)) {
 462     o++;
 463     sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
 464   }
 465   if (sz == CTSIZE_INVALID)
 466     lj_err_arg(L, 1, LJ_ERR_FFI_INVSIZE);
 467   if (!(info & CTF_VLA) && ctype_align(info) <= CT_MEMALIGN)
 468     cd = lj_cdata_new(cts, id, sz);
 469   else
 470     cd = lj_cdata_newv(cts, id, sz, ctype_align(info));
 471   setcdataV(L, o-1, cd);  /* Anchor the uninitialized cdata. */
 472   lj_cconv_ct_init(cts, ct, sz, cdataptr(cd),
 473                    o, (MSize)(L->top - o));  /* Initialize cdata. */
 474   if (ctype_isstruct(ct->info)) {
 475     /* Handle ctype __gc metamethod. Use the fast lookup here. */
 476     cTValue *tv = lj_tab_getinth(cts->miscmap, -(int32_t)id);
 477     if (tv && tvistab(tv) && (tv = lj_meta_fast(L, tabV(tv), MM_gc))) {
 478       GCtab *t = cts->finalizer;
 479       if (gcref(t->metatable)) {
 480         /* Add to finalizer table, if still enabled. */
 481         copyTV(L, lj_tab_set(L, t, o-1), tv);
 482         lj_gc_anybarriert(L, t);
 483         cd->marked |= LJ_GC_CDATA_FIN;
 484       }
 485     }
 486   }
 487   L->top = o;  /* Only return the cdata itself. */
 488   lj_gc_check(L);
 489   return 1;
 490 }
 491
 492 LJLIB_CF(ffi_cast)      LJLIB_REC(ffi_new)
 493 {
 494   CTState *cts = ctype_cts(L);
 495   CTypeID id = ffi_checkctype(L, cts);
 496   CType *d = ctype_raw(cts, id);
 497   TValue *o = lj_lib_checkany(L, 2);
 498   L->top = o+1;  /* Make sure this is the last item on the stack. */
 499   if (!(ctype_isnum(d->info) || ctype_isptr(d->info) || ctype_isenum(d->info)))
 500     lj_err_arg(L, 1, LJ_ERR_FFI_INVTYPE);
 501   if (!(tviscdata(o) && cdataV(o)->typeid == id)) {
 502     GCcdata *cd = lj_cdata_new(cts, id, d->size);
 503     lj_cconv_ct_tv(cts, d, cdataptr(cd), o, CCF_CAST);
 504     setcdataV(L, o, cd);
 505     lj_gc_check(L);
 506   }
 507   return 1;
 508 }
 509
 510 LJLIB_CF(ffi_typeof)
 511 {
 512   CTState *cts = ctype_cts(L);
 513   CTypeID id = ffi_checkctype(L, cts);
 514   GCcdata *cd = lj_cdata_new(cts, CTID_CTYPEID, 4);
 515   *(CTypeID *)cdataptr(cd) = id;
 516   setcdataV(L, L->top-1, cd);
 517   lj_gc_check(L);
 518   return 1;
 519 }
 520
 521 LJLIB_CF(ffi_istype)    LJLIB_REC(ffi_istype)
 522 {
 523   CTState *cts = ctype_cts(L);
 524   CTypeID id1 = ffi_checkctype(L, cts);
 525   TValue *o = lj_lib_checkany(L, 2);
 526   int b = 0;
 527   if (tviscdata(o)) {
 528     GCcdata *cd = cdataV(o);
 529     CTypeID id2 = cd->typeid == CTID_CTYPEID ? *(CTypeID *)cdataptr(cd) :
 530                                                cd->typeid;
 531     CType *ct1 = lj_ctype_rawref(cts, id1);
 532     CType *ct2 = lj_ctype_rawref(cts, id2);
 533     if (ct1 == ct2) {
 534       b = 1;
 535     } else if (ctype_type(ct1->info) == ctype_type(ct2->info) &&
 536                ct1->size == ct2->size) {
 537       if (ctype_ispointer(ct1->info))
 538         b = lj_cconv_compatptr(cts, ct1, ct2, CCF_IGNQUAL);
 539       else if (ctype_isnum(ct1->info) || ctype_isvoid(ct1->info))
 540         b = (((ct1->info ^ ct2->info) & ~CTF_QUAL) == 0);
 541     } else if (ctype_isstruct(ct1->info) && ctype_isptr(ct2->info) &&
 542                ct1 == ctype_rawchild(cts, ct2)) {
 543       b = 1;
 544     }
 545   }
 546   setboolV(L->top-1, b);
 547   setboolV(&G(L)->tmptv2, b);  /* Remember for trace recorder. */
 548   return 1;
 549 }
 550
 551 LJLIB_CF(ffi_sizeof)
 552 {
 553   CTState *cts = ctype_cts(L);
 554   CTypeID id = ffi_checkctype(L, cts);
 555   CTSize sz;
 556   if (LJ_UNLIKELY(tviscdata(L->base) && cdataisv(cdataV(L->base)))) {
 557     sz = cdatavlen(cdataV(L->base));
 558   } else {
 559     CType *ct = lj_ctype_rawref(cts, id);
 560     if (ctype_isvltype(ct->info))
 561       sz = lj_ctype_vlsize(cts, ct, (CTSize)ffi_checkint(L, 2));
 562     else
 563       sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
 564     if (LJ_UNLIKELY(sz == CTSIZE_INVALID)) {
 565       setnilV(L->top-1);
 566       return 1;
 567     }
 568   }
 569   setintV(L->top-1, (int32_t)sz);
 570   return 1;
 571 }
 572
 573 LJLIB_CF(ffi_alignof)
 574 {
 575   CTState *cts = ctype_cts(L);
 576   CTypeID id = ffi_checkctype(L, cts);
 577   CTSize sz = 0;
 578   CTInfo info = lj_ctype_info(cts, id, &sz);
 579   setintV(L->top-1, 1 << ctype_align(info));
 580   return 1;
 581 }
 582
 583 LJLIB_CF(ffi_offsetof)
 584 {
 585   CTState *cts = ctype_cts(L);
 586   CTypeID id = ffi_checkctype(L, cts);
 587   GCstr *name = lj_lib_checkstr(L, 2);
 588   CType *ct = lj_ctype_rawref(cts, id);
 589   CTSize ofs;
 590   if (ctype_isstruct(ct->info) && ct->size != CTSIZE_INVALID) {
 591     CType *fct = lj_ctype_getfield(cts, ct, name, &ofs);
 592     if (fct) {
 593       setintV(L->top-1, ofs);
 594       if (ctype_isfield(fct->info)) {
 595         return 1;
 596       } else if (ctype_isbitfield(fct->info)) {
 597         setintV(L->top++, ctype_bitpos(fct->info));
 598         setintV(L->top++, ctype_bitbsz(fct->info));
 599         return 3;
 600       }
 601     }
 602   }
 603   return 0;
 604 }
 605
 606 LJLIB_CF(ffi_errno)     LJLIB_REC(.)
 607 {
 608   int err = errno;
 609   if (L->top > L->base)
 610     errno = ffi_checkint(L, 1);
 611   setintV(L->top++, err);
 612   return 1;
 613 }
 614
 615 LJLIB_CF(ffi_string)    LJLIB_REC(.)
 616 {
 617   CTState *cts = ctype_cts(L);
 618   TValue *o = lj_lib_checkany(L, 1);
 619   const char *p;
 620   size_t len;
 621   if (o+1 < L->top) {
 622     len = (size_t)ffi_checkint(L, 2);
 623     lj_cconv_ct_tv(cts, ctype_get(cts, CTID_P_CVOID), (uint8_t *)&p, o,
 624                    CCF_ARG(1));
 625   } else {
 626     lj_cconv_ct_tv(cts, ctype_get(cts, CTID_P_CCHAR), (uint8_t *)&p, o,
 627                    CCF_ARG(1));
 628     len = strlen(p);
 629   }
 630   L->top = o+1;  /* Make sure this is the last item on the stack. */
 631   setstrV(L, o, lj_str_new(L, p, len));
 632   lj_gc_check(L);
 633   return 1;
 634 }
 635
 636 LJLIB_CF(ffi_copy)      LJLIB_REC(.)
 637 {
 638   void *dp = ffi_checkptr(L, 1, CTID_P_VOID);
 639   void *sp = ffi_checkptr(L, 2, CTID_P_CVOID);
 640   TValue *o = L->base+1;
 641   CTSize len;
 642   if (tvisstr(o) && o+1 >= L->top)
 643     len = strV(o)->len+1;  /* Copy Lua string including trailing '\0'. */
 644   else
 645     len = (CTSize)ffi_checkint(L, 3);
 646   memcpy(dp, sp, len);
 647   return 0;
 648 }
 649
 650 LJLIB_CF(ffi_fill)      LJLIB_REC(.)
 651 {
 652   void *dp = ffi_checkptr(L, 1, CTID_P_VOID);
 653   CTSize len = (CTSize)ffi_checkint(L, 2);
 654   int32_t fill = 0;
 655   if (L->base+2 < L->top && !tvisnil(L->base+2)) fill = ffi_checkint(L, 3);
 656   memset(dp, fill, len);
 657   return 0;
 658 }
 659
 660 #define H_(le, be)      LJ_ENDIAN_SELECT(0x##le, 0x##be)
 661
 662 /* Test ABI string. */
 663 LJLIB_CF(ffi_abi)       LJLIB_REC(.)
 664 {
 665   GCstr *s = lj_lib_checkstr(L, 1);
 666   int b = 0;
 667   switch (s->hash) {
 668 #if LJ_64
 669   case H_(849858eb,ad35fd06): b = 1; break;  /* 64bit */
 670 #else
 671   case H_(662d3c79,d0e22477): b = 1; break;  /* 32bit */
 672 #endif
 673 #if LJ_ARCH_HASFPU
 674   case H_(e33ee463,e33ee463): b = 1; break;  /* fpu */
 675 #endif
 676 #if LJ_ABI_SOFTFP
 677   case H_(61211a23,c2e8c81c): b = 1; break;  /* softfp */
 678 #else
 679   case H_(539417a8,8ce0812f): b = 1; break;  /* hardfp */
 680 #endif
 681 #if LJ_ABI_EABI
 682   case H_(2182df8f,f2ed1152): b = 1; break;  /* eabi */
 683 #endif
 684 #if LJ_ABI_WIN
 685   case H_(4ab624a8,4ab624a8): b = 1; break;  /* win */
 686 #endif
 687   case H_(3af93066,1f001464): b = 1; break;  /* le/be */
 688   default:
 689     break;
 690   }
 691   setboolV(L->top-1, b);
 692   setboolV(&G(L)->tmptv2, b);  /* Remember for trace recorder. */
 693   return 1;
 694 }
 695
 696 #undef H_
 697
 698 LJLIB_PUSH(top-8) LJLIB_SET(!)  /* Store reference to miscmap table. */
 699
 700 LJLIB_CF(ffi_metatype)
 701 {
 702   CTState *cts = ctype_cts(L);
 703   CTypeID id = ffi_checkctype(L, cts);
 704   GCtab *mt = lj_lib_checktab(L, 2);
 705   GCtab *t = cts->miscmap;
 706   CType *ct = ctype_get(cts, id);  /* Only allow raw types. */
 707   TValue *tv;
 708   GCcdata *cd;
 709   if (!(ctype_isstruct(ct->info) || ctype_iscomplex(ct->info) ||
 710         ctype_isvector(ct->info)))
 711     lj_err_arg(L, 1, LJ_ERR_FFI_INVTYPE);
 712   tv = lj_tab_setinth(L, t, -(int32_t)id);
 713   if (!tvisnil(tv))
 714     lj_err_caller(L, LJ_ERR_PROTMT);
 715   settabV(L, tv, mt);
 716   lj_gc_anybarriert(L, t);
 717   cd = lj_cdata_new(cts, CTID_CTYPEID, 4);
 718   *(CTypeID *)cdataptr(cd) = id;
 719   setcdataV(L, L->top-1, cd);
 720   lj_gc_check(L);
 721   return 1;
 722 }
 723
 724 LJLIB_PUSH(top-7) LJLIB_SET(!)  /* Store reference to finalizer table. */
 725
 726 LJLIB_CF(ffi_gc)
 727 {
 728   GCcdata *cd = ffi_checkcdata(L, 1);
 729   TValue *fin = lj_lib_checkany(L, 2);
 730   CTState *cts = ctype_cts(L);
 731   GCtab *t = cts->finalizer;
 732   CType *ct = ctype_raw(cts, cd->typeid);
 733   if (!(ctype_isptr(ct->info) || ctype_isstruct(ct->info) ||
 734         ctype_isrefarray(ct->info)))
 735     lj_err_arg(L, 1, LJ_ERR_FFI_INVTYPE);
 736   if (gcref(t->metatable)) {  /* Update finalizer table, if still enabled. */
 737     copyTV(L, lj_tab_set(L, t, L->base), fin);
 738     lj_gc_anybarriert(L, t);
 739     if (!tvisnil(fin))
 740       cd->marked |= LJ_GC_CDATA_FIN;
 741     else
 742       cd->marked &= ~LJ_GC_CDATA_FIN;
 743   }
 744   L->top = L->base+1;  /* Pass through the cdata object. */
 745   return 1;
 746 }
 747
 748 LJLIB_PUSH(top-5) LJLIB_SET(!)  /* Store clib metatable in func environment. */
 749
 750 LJLIB_CF(ffi_load)
 751 {
 752   GCstr *name = lj_lib_checkstr(L, 1);
 753   int global = (L->base+1 < L->top && tvistruecond(L->base+1));
 754   lj_clib_load(L, tabref(curr_func(L)->c.env), name, global);
 755   return 1;
 756 }
 757
 758 LJLIB_PUSH(top-4) LJLIB_SET(C)
 759 LJLIB_PUSH(top-3) LJLIB_SET(os)
 760 LJLIB_PUSH(top-2) LJLIB_SET(arch)
 761
 762 #include "lj_libdef.h"
 763
 764 /* ------------------------------------------------------------------------ */
 765
 766 /* Create special weak-keyed finalizer table. */
 767 static GCtab *ffi_finalizer(lua_State *L)
 768 {
 769   /* NOBARRIER: The table is new (marked white). */
 770   GCtab *t = lj_tab_new(L, 0, 1);
 771   settabV(L, L->top++, t);
 772   setgcref(t->metatable, obj2gco(t));
 773   setstrV(L, lj_tab_setstr(L, t, lj_str_newlit(L, "__mode")),
 774           lj_str_newlit(L, "K"));
 775   t->nomm = (uint8_t)(~(1u<<MM_mode));
 776   return t;
 777 }
 778
 779 /* Register FFI module as loaded. */
 780 static void ffi_register_module(lua_State *L)
 781 {
 782   cTValue *tmp = lj_tab_getstr(tabV(registry(L)), lj_str_newlit(L, "_LOADED"));
 783   if (tmp && tvistab(tmp)) {
 784     GCtab *t = tabV(tmp);
 785     copyTV(L, lj_tab_setstr(L, t, lj_str_newlit(L, LUA_FFILIBNAME)), L->top-1);
 786     lj_gc_anybarriert(L, t);
 787   }
 788 }
 789
 790 LUALIB_API int luaopen_ffi(lua_State *L)
 791 {
 792   CTState *cts = lj_ctype_init(L);
 793   settabV(L, L->top++, (cts->miscmap = lj_tab_new(L, 0, 1)));
 794   cts->finalizer = ffi_finalizer(L);
 795   LJ_LIB_REG(L, NULL, ffi_meta);
 796   /* NOBARRIER: basemt is a GC root. */
 797   setgcref(basemt_it(G(L), LJ_TCDATA), obj2gco(tabV(L->top-1)));
 798   LJ_LIB_REG(L, NULL, ffi_clib);
 799   LJ_LIB_REG(L, NULL, ffi_callback);
 800   /* NOBARRIER: the key is new and lj_tab_newkey() handles the barrier. */
 801   settabV(L, lj_tab_setstr(L, cts->miscmap, &cts->g->strempty), tabV(L->top-1));
 802   L->top--;
 803   lj_clib_default(L, tabV(L->top-1));  /* Create ffi.C default namespace. */
 804   lua_pushliteral(L, LJ_OS_NAME);
 805   lua_pushliteral(L, LJ_ARCH_NAME);
 806   LJ_LIB_REG(L, NULL, ffi);  /* Note: no global "ffi" created! */
 807   ffi_register_module(L);
 808   return 1;
 809 }
 810
 811 #endif