src/lj_cconv.c

   1 /*
   2 ** C type conversions.
   3 ** Copyright (C) 2005-2012 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #include "lj_obj.h"
   7
   8 #if LJ_HASFFI
   9
  10 #include "lj_err.h"
  11 #include "lj_tab.h"
  12 #include "lj_ctype.h"
  13 #include "lj_cdata.h"
  14 #include "lj_cconv.h"
  15 #include "lj_ccallback.h"
  16
  17 /* -- Conversion errors --------------------------------------------------- */
  18
  19 /* Bad conversion. */
  20 LJ_NORET static void cconv_err_conv(CTState *cts, CType *d, CType *s,
  21                                     CTInfo flags)
  22 {
  23   const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
  24   const char *src;
  25   if ((flags & CCF_FROMTV))
  26     src = lj_obj_typename[1+(ctype_isnum(s->info) ? LUA_TNUMBER :
  27                              ctype_isarray(s->info) ? LUA_TSTRING : LUA_TNIL)];
  28   else
  29     src = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, s), NULL));
  30   if (CCF_GETARG(flags))
  31     lj_err_argv(cts->L, CCF_GETARG(flags), LJ_ERR_FFI_BADCONV, src, dst);
  32   else
  33     lj_err_callerv(cts->L, LJ_ERR_FFI_BADCONV, src, dst);
  34 }
  35
  36 /* Bad conversion from TValue. */
  37 LJ_NORET static void cconv_err_convtv(CTState *cts, CType *d, TValue *o,
  38                                       CTInfo flags)
  39 {
  40   const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
  41   const char *src = lj_typename(o);
  42   if (CCF_GETARG(flags))
  43     lj_err_argv(cts->L, CCF_GETARG(flags), LJ_ERR_FFI_BADCONV, src, dst);
  44   else
  45     lj_err_callerv(cts->L, LJ_ERR_FFI_BADCONV, src, dst);
  46 }
  47
  48 /* Initializer overflow. */
  49 LJ_NORET static void cconv_err_initov(CTState *cts, CType *d)
  50 {
  51   const char *dst = strdata(lj_ctype_repr(cts->L, ctype_typeid(cts, d), NULL));
  52   lj_err_callerv(cts->L, LJ_ERR_FFI_INITOV, dst);
  53 }
  54
  55 /* -- C type compatibility checks ----------------------------------------- */
  56
  57 /* Get raw type and qualifiers for a child type. Resolves enums, too. */
  58 static CType *cconv_childqual(CTState *cts, CType *ct, CTInfo *qual)
  59 {
  60   ct = ctype_child(cts, ct);
  61   for (;;) {
  62     if (ctype_isattrib(ct->info)) {
  63       if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
  64     } else if (!ctype_isenum(ct->info)) {
  65       break;
  66     }
  67     ct = ctype_child(cts, ct);
  68   }
  69   *qual |= (ct->info & CTF_QUAL);
  70   return ct;
  71 }
  72
  73 /* Check for compatible types when converting to a pointer.
  74 ** Note: these checks are more relaxed than what C99 mandates.
  75 */
  76 int lj_cconv_compatptr(CTState *cts, CType *d, CType *s, CTInfo flags)
  77 {
  78   if (!((flags & CCF_CAST) || d == s)) {
  79     CTInfo dqual = 0, squal = 0;
  80     d = cconv_childqual(cts, d, &dqual);
  81     if (!ctype_isstruct(s->info))
  82       s = cconv_childqual(cts, s, &squal);
  83     if ((flags & CCF_SAME)) {
  84       if (dqual != squal)
  85         return 0;  /* Different qualifiers. */
  86     } else if (!(flags & CCF_IGNQUAL)) {
  87       if ((dqual & squal) != squal)
  88         return 0;  /* Discarded qualifiers. */
  89       if (ctype_isvoid(d->info) || ctype_isvoid(s->info))
  90         return 1;  /* Converting to/from void * is always ok. */
  91     }
  92     if (ctype_type(d->info) != ctype_type(s->info) ||
  93         d->size != s->size)
  94       return 0;  /* Different type or different size. */
  95     if (ctype_isnum(d->info)) {
  96       if (((d->info ^ s->info) & (CTF_BOOL|CTF_FP)))
  97         return 0;  /* Different numeric types. */
  98     } else if (ctype_ispointer(d->info)) {
  99       /* Check child types for compatibility. */
 100       return lj_cconv_compatptr(cts, d, s, flags|CCF_SAME);
 101     } else if (ctype_isstruct(d->info)) {
 102       if (d != s)
 103         return 0;  /* Must be exact same type for struct/union. */
 104     } else if (ctype_isfunc(d->info)) {
 105       /* NYI: structural equality of functions. */
 106     }
 107   }
 108   return 1;  /* Types are compatible. */
 109 }
 110
 111 /* -- C type to C type conversion ----------------------------------------- */
 112
 113 /* Convert C type to C type. Caveat: expects to get the raw CType!
 114 **
 115 ** Note: This is only used by the interpreter and not optimized at all.
 116 ** The JIT compiler will do a much better job specializing for each case.
 117 */
 118 void lj_cconv_ct_ct(CTState *cts, CType *d, CType *s,
 119                     uint8_t *dp, uint8_t *sp, CTInfo flags)
 120 {
 121   CTSize dsize = d->size, ssize = s->size;
 122   CTInfo dinfo = d->info, sinfo = s->info;
 123   void *tmpptr;
 124
 125   lua_assert(!ctype_isenum(dinfo) && !ctype_isenum(sinfo));
 126   lua_assert(!ctype_isattrib(dinfo) && !ctype_isattrib(sinfo));
 127
 128   if (ctype_type(dinfo) > CT_MAYCONVERT || ctype_type(sinfo) > CT_MAYCONVERT)
 129     goto err_conv;
 130
 131   /* Some basic sanity checks. */
 132   lua_assert(!ctype_isnum(dinfo) || dsize > 0);
 133   lua_assert(!ctype_isnum(sinfo) || ssize > 0);
 134   lua_assert(!ctype_isbool(dinfo) || dsize == 1 || dsize == 4);
 135   lua_assert(!ctype_isbool(sinfo) || ssize == 1 || ssize == 4);
 136   lua_assert(!ctype_isinteger(dinfo) || (1u<<lj_fls(dsize)) == dsize);
 137   lua_assert(!ctype_isinteger(sinfo) || (1u<<lj_fls(ssize)) == ssize);
 138
 139   switch (cconv_idx2(dinfo, sinfo)) {
 140   /* Destination is a bool. */
 141   case CCX(B, B):
 142     /* Source operand is already normalized. */
 143     if (dsize == 1) *dp = *sp; else *(int *)dp = *sp;
 144     break;
 145   case CCX(B, I): {
 146     MSize i;
 147     uint8_t b = 0;
 148     for (i = 0; i < ssize; i++) b |= sp[i];
 149     b = (b != 0);
 150     if (dsize == 1) *dp = b; else *(int *)dp = b;
 151     break;
 152     }
 153   case CCX(B, F): {
 154     uint8_t b;
 155     if (ssize == sizeof(double)) b = (*(double *)sp != 0);
 156     else if (ssize == sizeof(float)) b = (*(float *)sp != 0);
 157     else goto err_conv;  /* NYI: long double. */
 158     if (dsize == 1) *dp = b; else *(int *)dp = b;
 159     break;
 160     }
 161
 162   /* Destination is an integer. */
 163   case CCX(I, B):
 164   case CCX(I, I):
 165   conv_I_I:
 166     if (dsize > ssize) {  /* Zero-extend or sign-extend LSB. */
 167 #if LJ_LE
 168       uint8_t fill = (!(sinfo & CTF_UNSIGNED) && (sp[ssize-1]&0x80)) ? 0xff : 0;
 169       memcpy(dp, sp, ssize);
 170       memset(dp + ssize, fill, dsize-ssize);
 171 #else
 172       uint8_t fill = (!(sinfo & CTF_UNSIGNED) && (sp[0]&0x80)) ? 0xff : 0;
 173       memset(dp, fill, dsize-ssize);
 174       memcpy(dp + (dsize-ssize), sp, ssize);
 175 #endif
 176     } else {  /* Copy LSB. */
 177 #if LJ_LE
 178       memcpy(dp, sp, dsize);
 179 #else
 180       memcpy(dp, sp + (ssize-dsize), dsize);
 181 #endif
 182     }
 183     break;
 184   case CCX(I, F): {
 185     double n;  /* Always convert via double. */
 186   conv_I_F:
 187     /* Convert source to double. */
 188     if (ssize == sizeof(double)) n = *(double *)sp;
 189     else if (ssize == sizeof(float)) n = (double)*(float *)sp;
 190     else goto err_conv;  /* NYI: long double. */
 191     /* Then convert double to integer. */
 192     /* The conversion must exactly match the semantics of JIT-compiled code! */
 193     if (dsize < 4 || (dsize == 4 && !(dinfo & CTF_UNSIGNED))) {
 194       int32_t i = (int32_t)n;
 195       if (dsize == 4) *(int32_t *)dp = i;
 196       else if (dsize == 2) *(int16_t *)dp = (int16_t)i;
 197       else *(int8_t *)dp = (int8_t)i;
 198     } else if (dsize == 4) {
 199       *(uint32_t *)dp = (uint32_t)n;
 200     } else if (dsize == 8) {
 201       if (!(dinfo & CTF_UNSIGNED))
 202         *(int64_t *)dp = (int64_t)n;
 203       else
 204         *(uint64_t *)dp = lj_num2u64(n);
 205     } else {
 206       goto err_conv;  /* NYI: conversion to >64 bit integers. */
 207     }
 208     break;
 209     }
 210   case CCX(I, C):
 211     s = ctype_child(cts, s);
 212     sinfo = s->info;
 213     ssize = s->size;
 214     goto conv_I_F;  /* Just convert re. */
 215   case CCX(I, P):
 216     if (!(flags & CCF_CAST)) goto err_conv;
 217     sinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
 218     goto conv_I_I;
 219   case CCX(I, A):
 220     if (!(flags & CCF_CAST)) goto err_conv;
 221     sinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
 222     ssize = CTSIZE_PTR;
 223     tmpptr = sp;
 224     sp = (uint8_t *)&tmpptr;
 225     goto conv_I_I;
 226
 227   /* Destination is a floating-point number. */
 228   case CCX(F, B):
 229   case CCX(F, I): {
 230     double n;  /* Always convert via double. */
 231   conv_F_I:
 232     /* First convert source to double. */
 233     /* The conversion must exactly match the semantics of JIT-compiled code! */
 234     if (ssize < 4 || (ssize == 4 && !(sinfo & CTF_UNSIGNED))) {
 235       int32_t i;
 236       if (ssize == 4) {
 237         i = *(int32_t *)sp;
 238       } else if (!(sinfo & CTF_UNSIGNED)) {
 239         if (ssize == 2) i = *(int16_t *)sp;
 240         else i = *(int8_t *)sp;
 241       } else {
 242         if (ssize == 2) i = *(uint16_t *)sp;
 243         else i = *(uint8_t *)sp;
 244       }
 245       n = (double)i;
 246     } else if (ssize == 4) {
 247       n = (double)*(uint32_t *)sp;
 248     } else if (ssize == 8) {
 249       if (!(sinfo & CTF_UNSIGNED)) n = (double)*(int64_t *)sp;
 250       else n = (double)*(uint64_t *)sp;
 251     } else {
 252       goto err_conv;  /* NYI: conversion from >64 bit integers. */
 253     }
 254     /* Convert double to destination. */
 255     if (dsize == sizeof(double)) *(double *)dp = n;
 256     else if (dsize == sizeof(float)) *(float *)dp = (float)n;
 257     else goto err_conv;  /* NYI: long double. */
 258     break;
 259     }
 260   case CCX(F, F): {
 261     double n;  /* Always convert via double. */
 262   conv_F_F:
 263     if (ssize == dsize) goto copyval;
 264     /* Convert source to double. */
 265     if (ssize == sizeof(double)) n = *(double *)sp;
 266     else if (ssize == sizeof(float)) n = (double)*(float *)sp;
 267     else goto err_conv;  /* NYI: long double. */
 268     /* Convert double to destination. */
 269     if (dsize == sizeof(double)) *(double *)dp = n;
 270     else if (dsize == sizeof(float)) *(float *)dp = (float)n;
 271     else goto err_conv;  /* NYI: long double. */
 272     break;
 273     }
 274   case CCX(F, C):
 275     s = ctype_child(cts, s);
 276     sinfo = s->info;
 277     ssize = s->size;
 278     goto conv_F_F;  /* Ignore im, and convert from re. */
 279
 280   /* Destination is a complex number. */
 281   case CCX(C, I):
 282     d = ctype_child(cts, d);
 283     dinfo = d->info;
 284     dsize = d->size;
 285     memset(dp + dsize, 0, dsize);  /* Clear im. */
 286     goto conv_F_I;  /* Convert to re. */
 287   case CCX(C, F):
 288     d = ctype_child(cts, d);
 289     dinfo = d->info;
 290     dsize = d->size;
 291     memset(dp + dsize, 0, dsize);  /* Clear im. */
 292     goto conv_F_F;  /* Convert to re. */
 293
 294   case CCX(C, C):
 295     if (dsize != ssize) {  /* Different types: convert re/im separately. */
 296       CType *dc = ctype_child(cts, d);
 297       CType *sc = ctype_child(cts, s);
 298       lj_cconv_ct_ct(cts, dc, sc, dp, sp, flags);
 299       lj_cconv_ct_ct(cts, dc, sc, dp + dc->size, sp + sc->size, flags);
 300       return;
 301     }
 302     goto copyval;  /* Otherwise this is easy. */
 303
 304   /* Destination is a vector. */
 305   case CCX(V, I):
 306   case CCX(V, F):
 307   case CCX(V, C): {
 308     CType *dc = ctype_child(cts, d);
 309     CTSize esize;
 310     /* First convert the scalar to the first element. */
 311     lj_cconv_ct_ct(cts, dc, s, dp, sp, flags);
 312     /* Then replicate it to the other elements (splat). */
 313     for (sp = dp, esize = dc->size; dsize > esize; dsize -= esize) {
 314       dp += esize;
 315       memcpy(dp, sp, esize);
 316     }
 317     break;
 318     }
 319
 320   case CCX(V, V):
 321     /* Copy same-sized vectors, even for different lengths/element-types. */
 322     if (dsize != ssize) goto err_conv;
 323     goto copyval;
 324
 325   /* Destination is a pointer. */
 326   case CCX(P, I):
 327     if (!(flags & CCF_CAST)) goto err_conv;
 328     dinfo = CTINFO(CT_NUM, CTF_UNSIGNED);
 329     goto conv_I_I;
 330
 331   case CCX(P, F):
 332     if (!(flags & CCF_CAST) || !(flags & CCF_FROMTV)) goto err_conv;
 333     /* The signed conversion is cheaper. x64 really has 47 bit pointers. */
 334     dinfo = CTINFO(CT_NUM, (LJ_64 && dsize == 8) ? 0 : CTF_UNSIGNED);
 335     goto conv_I_F;
 336
 337   case CCX(P, P):
 338     if (!lj_cconv_compatptr(cts, d, s, flags)) goto err_conv;
 339     cdata_setptr(dp, dsize, cdata_getptr(sp, ssize));
 340     break;
 341
 342   case CCX(P, A):
 343   case CCX(P, S):
 344     if (!lj_cconv_compatptr(cts, d, s, flags)) goto err_conv;
 345     cdata_setptr(dp, dsize, sp);
 346     break;
 347
 348   /* Destination is an array. */
 349   case CCX(A, A):
 350     if ((flags & CCF_CAST) || (d->info & CTF_VLA) || dsize != ssize ||
 351         d->size == CTSIZE_INVALID || !lj_cconv_compatptr(cts, d, s, flags))
 352       goto err_conv;
 353     goto copyval;
 354
 355   /* Destination is a struct/union. */
 356   case CCX(S, S):
 357     if ((flags & CCF_CAST) || (d->info & CTF_VLA) || d != s)
 358       goto err_conv;  /* Must be exact same type. */
 359 copyval:  /* Copy value. */
 360     lua_assert(dsize == ssize);
 361     memcpy(dp, sp, dsize);
 362     break;
 363
 364   default:
 365   err_conv:
 366     cconv_err_conv(cts, d, s, flags);
 367   }
 368 }
 369
 370 /* -- C type to TValue conversion ----------------------------------------- */
 371
 372 /* Convert C type to TValue. Caveat: expects to get the raw CType! */
 373 int lj_cconv_tv_ct(CTState *cts, CType *s, CTypeID sid,
 374                    TValue *o, uint8_t *sp)
 375 {
 376   CTInfo sinfo = s->info;
 377   if (ctype_isnum(sinfo)) {
 378     if (!ctype_isbool(sinfo)) {
 379       if (ctype_isinteger(sinfo) && s->size > 4) goto copyval;
 380       if (LJ_DUALNUM && ctype_isinteger(sinfo)) {
 381         int32_t i;
 382         lj_cconv_ct_ct(cts, ctype_get(cts, CTID_INT32), s,
 383                        (uint8_t *)&i, sp, 0);
 384         if ((sinfo & CTF_UNSIGNED) && i < 0)
 385           setnumV(o, (lua_Number)(uint32_t)i);
 386         else
 387           setintV(o, i);
 388       } else {
 389         lj_cconv_ct_ct(cts, ctype_get(cts, CTID_DOUBLE), s,
 390                        (uint8_t *)&o->n, sp, 0);
 391         /* Numbers are NOT canonicalized here! Beware of uninitialized data. */
 392         lua_assert(tvisnum(o));
 393       }
 394     } else {
 395       uint32_t b = s->size == 1 ? (*sp != 0) : (*(int *)sp != 0);
 396       setboolV(o, b);
 397       setboolV(&cts->g->tmptv2, b);  /* Remember for trace recorder. */
 398     }
 399     return 0;
 400   } else if (ctype_isrefarray(sinfo) || ctype_isstruct(sinfo)) {
 401     /* Create reference. */
 402     setcdataV(cts->L, o, lj_cdata_newref(cts, sp, sid));
 403     return 1;  /* Need GC step. */
 404   } else {
 405     GCcdata *cd;
 406     CTSize sz;
 407   copyval:  /* Copy value. */
 408     sz = s->size;
 409     lua_assert(sz != CTSIZE_INVALID);
 410     /* Attributes are stripped, qualifiers are kept (but mostly ignored). */
 411     cd = lj_cdata_new(cts, ctype_typeid(cts, s), sz);
 412     setcdataV(cts->L, o, cd);
 413     memcpy(cdataptr(cd), sp, sz);
 414     return 1;  /* Need GC step. */
 415   }
 416 }
 417
 418 /* Convert bitfield to TValue. */
 419 int lj_cconv_tv_bf(CTState *cts, CType *s, TValue *o, uint8_t *sp)
 420 {
 421   CTInfo info = s->info;
 422   CTSize pos, bsz;
 423   uint32_t val;
 424   lua_assert(ctype_isbitfield(info));
 425   /* NYI: packed bitfields may cause misaligned reads. */
 426   switch (ctype_bitcsz(info)) {
 427   case 4: val = *(uint32_t *)sp; break;
 428   case 2: val = *(uint16_t *)sp; break;
 429   case 1: val = *(uint8_t *)sp; break;
 430   default: lua_assert(0); val = 0; break;
 431   }
 432   /* Check if a packed bitfield crosses a container boundary. */
 433   pos = ctype_bitpos(info);
 434   bsz = ctype_bitbsz(info);
 435   lua_assert(pos < 8*ctype_bitcsz(info));
 436   lua_assert(bsz > 0 && bsz <= 8*ctype_bitcsz(info));
 437   if (pos + bsz > 8*ctype_bitcsz(info))
 438     lj_err_caller(cts->L, LJ_ERR_FFI_NYIPACKBIT);
 439   if (!(info & CTF_BOOL)) {
 440     CTSize shift = 32 - bsz;
 441     if (!(info & CTF_UNSIGNED)) {
 442       setintV(o, (int32_t)(val << (shift-pos)) >> shift);
 443     } else {
 444       val = (val << (shift-pos)) >> shift;
 445       if (!LJ_DUALNUM || (int32_t)val < 0)
 446         setnumV(o, (lua_Number)(uint32_t)val);
 447       else
 448         setintV(o, (int32_t)val);
 449     }
 450   } else {
 451     lua_assert(bsz == 1);
 452     setboolV(o, (val >> pos) & 1);
 453   }
 454   return 0;  /* No GC step needed. */
 455 }
 456
 457 /* -- TValue to C type conversion ----------------------------------------- */
 458
 459 /* Convert table to array. */
 460 static void cconv_array_tab(CTState *cts, CType *d,
 461                             uint8_t *dp, GCtab *t, CTInfo flags)
 462 {
 463   int32_t i;
 464   CType *dc = ctype_rawchild(cts, d);  /* Array element type. */
 465   CTSize size = d->size, esize = dc->size, ofs = 0;
 466   for (i = 0; ; i++) {
 467     TValue *tv = (TValue *)lj_tab_getint(t, i);
 468     if (!tv || tvisnil(tv)) {
 469       if (i == 0) continue;  /* Try again for 1-based tables. */
 470       break;  /* Stop at first nil. */
 471     }
 472     if (ofs >= size)
 473       cconv_err_initov(cts, d);
 474     lj_cconv_ct_tv(cts, dc, dp + ofs, tv, flags);
 475     ofs += esize;
 476   }
 477   if (size != CTSIZE_INVALID) {  /* Only fill up arrays with known size. */
 478     if (ofs == esize) {  /* Replicate a single element. */
 479       for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
 480     } else {  /* Otherwise fill the remainder with zero. */
 481       memset(dp + ofs, 0, size - ofs);
 482     }
 483   }
 484 }
 485
 486 /* Convert table to sub-struct/union. */
 487 static void cconv_substruct_tab(CTState *cts, CType *d, uint8_t *dp,
 488                                 GCtab *t, int32_t *ip, CTInfo flags)
 489 {
 490   CTypeID id = d->sib;
 491   while (id) {
 492     CType *df = ctype_get(cts, id);
 493     id = df->sib;
 494     if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
 495       TValue *tv;
 496       int32_t i = *ip;
 497       if (!gcref(df->name)) continue;  /* Ignore unnamed fields. */
 498       if (i >= 0) {
 499       retry:
 500         tv = (TValue *)lj_tab_getint(t, i);
 501         if (!tv || tvisnil(tv)) {
 502           if (i == 0) { i = 1; goto retry; }  /* 1-based tables. */
 503           break;  /* Stop at first nil. */
 504         }
 505         *ip = i + 1;
 506       } else {
 507         tv = (TValue *)lj_tab_getstr(t, gco2str(gcref(df->name)));
 508         if (!tv || tvisnil(tv)) continue;
 509       }
 510       if (ctype_isfield(df->info))
 511         lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, tv, flags);
 512       else
 513         lj_cconv_bf_tv(cts, df, dp+df->size, tv);
 514       if ((d->info & CTF_UNION)) break;
 515     } else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
 516       cconv_substruct_tab(cts, ctype_child(cts, df), dp+df->size, t, ip, flags);
 517     }  /* Ignore all other entries in the chain. */
 518   }
 519 }
 520
 521 /* Convert table to struct/union. */
 522 static void cconv_struct_tab(CTState *cts, CType *d,
 523                              uint8_t *dp, GCtab *t, CTInfo flags)
 524 {
 525   int32_t i = 0;
 526   memset(dp, 0, d->size);  /* Much simpler to clear the struct first. */
 527   if (t->hmask) i = -1; else if (t->asize == 0) return;  /* Fast exit. */
 528   cconv_substruct_tab(cts, d, dp, t, &i, flags);
 529 }
 530
 531 /* Convert TValue to C type. Caveat: expects to get the raw CType! */
 532 void lj_cconv_ct_tv(CTState *cts, CType *d,
 533                     uint8_t *dp, TValue *o, CTInfo flags)
 534 {
 535   CTypeID sid = CTID_P_VOID;
 536   CType *s;
 537   void *tmpptr;
 538   uint8_t tmpbool, *sp = (uint8_t *)&tmpptr;
 539   if (LJ_LIKELY(tvisint(o))) {
 540     sp = (uint8_t *)&o->i;
 541     sid = CTID_INT32;
 542     flags |= CCF_FROMTV;
 543   } else if (LJ_LIKELY(tvisnum(o))) {
 544     sp = (uint8_t *)&o->n;
 545     sid = CTID_DOUBLE;
 546     flags |= CCF_FROMTV;
 547   } else if (tviscdata(o)) {
 548     sp = cdataptr(cdataV(o));
 549     sid = cdataV(o)->ctypeid;
 550     s = ctype_get(cts, sid);
 551     if (ctype_isref(s->info)) {  /* Resolve reference for value. */
 552       lua_assert(s->size == CTSIZE_PTR);
 553       sp = *(void **)sp;
 554       sid = ctype_cid(s->info);
 555     }
 556     s = ctype_raw(cts, sid);
 557     if (ctype_isfunc(s->info)) {
 558       sid = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|sid), CTSIZE_PTR);
 559     } else {
 560       if (ctype_isenum(s->info)) s = ctype_child(cts, s);
 561       goto doconv;
 562     }
 563   } else if (tvisstr(o)) {
 564     GCstr *str = strV(o);
 565     if (ctype_isenum(d->info)) {  /* Match string against enum constant. */
 566       CTSize ofs;
 567       CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
 568       if (!cct || !ctype_isconstval(cct->info))
 569         goto err_conv;
 570       lua_assert(d->size == 4);
 571       sp = (uint8_t *)&cct->size;
 572       sid = ctype_cid(cct->info);
 573     } else if (ctype_isrefarray(d->info)) {  /* Copy string to array. */
 574       CType *dc = ctype_rawchild(cts, d);
 575       CTSize sz = str->len+1;
 576       if (!ctype_isinteger(dc->info) || dc->size != 1)
 577         goto err_conv;
 578       if (d->size != 0 && d->size < sz)
 579         sz = d->size;
 580       memcpy(dp, strdata(str), sz);
 581       return;
 582     } else {  /* Otherwise pass it as a const char[]. */
 583       sp = (uint8_t *)strdata(str);
 584       sid = CTID_A_CCHAR;
 585       flags |= CCF_FROMTV;
 586     }
 587   } else if (tvistab(o)) {
 588     if (ctype_isarray(d->info)) {
 589       cconv_array_tab(cts, d, dp, tabV(o), flags);
 590       return;
 591     } else if (ctype_isstruct(d->info)) {
 592       cconv_struct_tab(cts, d, dp, tabV(o), flags);
 593       return;
 594     } else {
 595       goto err_conv;
 596     }
 597   } else if (tvisbool(o)) {
 598     tmpbool = boolV(o);
 599     sp = &tmpbool;
 600     sid = CTID_BOOL;
 601   } else if (tvisnil(o)) {
 602     tmpptr = (void *)0;
 603     flags |= CCF_FROMTV;
 604   } else if (tvisudata(o)) {
 605     GCudata *ud = udataV(o);
 606     tmpptr = uddata(ud);
 607     if (ud->udtype == UDTYPE_IO_FILE)
 608       tmpptr = *(void **)tmpptr;
 609   } else if (tvislightud(o)) {
 610     tmpptr = lightudV(o);
 611   } else if (tvisfunc(o)) {
 612     void *p = lj_ccallback_new(cts, d, funcV(o));
 613     if (p) {
 614       *(void **)dp = p;
 615       return;
 616     }
 617     goto err_conv;
 618   } else {
 619   err_conv:
 620     cconv_err_convtv(cts, d, o, flags);
 621   }
 622   s = ctype_get(cts, sid);
 623 doconv:
 624   if (ctype_isenum(d->info)) d = ctype_child(cts, d);
 625   lj_cconv_ct_ct(cts, d, s, dp, sp, flags);
 626 }
 627
 628 /* Convert TValue to bitfield. */
 629 void lj_cconv_bf_tv(CTState *cts, CType *d, uint8_t *dp, TValue *o)
 630 {
 631   CTInfo info = d->info;
 632   CTSize pos, bsz;
 633   uint32_t val, mask;
 634   lua_assert(ctype_isbitfield(info));
 635   if ((info & CTF_BOOL)) {
 636     uint8_t tmpbool;
 637     lua_assert(ctype_bitbsz(info) == 1);
 638     lj_cconv_ct_tv(cts, ctype_get(cts, CTID_BOOL), &tmpbool, o, 0);
 639     val = tmpbool;
 640   } else {
 641     CTypeID did = (info & CTF_UNSIGNED) ? CTID_UINT32 : CTID_INT32;
 642     lj_cconv_ct_tv(cts, ctype_get(cts, did), (uint8_t *)&val, o, 0);
 643   }
 644   pos = ctype_bitpos(info);
 645   bsz = ctype_bitbsz(info);
 646   lua_assert(pos < 8*ctype_bitcsz(info));
 647   lua_assert(bsz > 0 && bsz <= 8*ctype_bitcsz(info));
 648   /* Check if a packed bitfield crosses a container boundary. */
 649   if (pos + bsz > 8*ctype_bitcsz(info))
 650     lj_err_caller(cts->L, LJ_ERR_FFI_NYIPACKBIT);
 651   mask = ((1u << bsz) - 1u) << pos;
 652   val = (val << pos) & mask;
 653   /* NYI: packed bitfields may cause misaligned reads/writes. */
 654   switch (ctype_bitcsz(info)) {
 655   case 4: *(uint32_t *)dp = (*(uint32_t *)dp & ~mask) | (uint32_t)val; break;
 656   case 2: *(uint16_t *)dp = (*(uint16_t *)dp & ~mask) | (uint16_t)val; break;
 657   case 1: *(uint8_t *)dp = (*(uint8_t *)dp & ~mask) | (uint8_t)val; break;
 658   default: lua_assert(0); break;
 659   }
 660 }
 661
 662 /* -- Initialize C type with TValues -------------------------------------- */
 663
 664 /* Initialize an array with TValues. */
 665 static void cconv_array_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
 666                              TValue *o, MSize len)
 667 {
 668   CType *dc = ctype_rawchild(cts, d);  /* Array element type. */
 669   CTSize ofs, esize = dc->size;
 670   MSize i;
 671   if (len*esize > sz)
 672     cconv_err_initov(cts, d);
 673   for (i = 0, ofs = 0; i < len; i++, ofs += esize)
 674     lj_cconv_ct_tv(cts, dc, dp + ofs, o + i, 0);
 675   if (ofs == esize) {  /* Replicate a single element. */
 676     for (; ofs < sz; ofs += esize) memcpy(dp + ofs, dp, esize);
 677   } else {  /* Otherwise fill the remainder with zero. */
 678     memset(dp + ofs, 0, sz - ofs);
 679   }
 680 }
 681
 682 /* Initialize a sub-struct/union with TValues. */
 683 static void cconv_substruct_init(CTState *cts, CType *d, uint8_t *dp,
 684                                  TValue *o, MSize len, MSize *ip)
 685 {
 686   CTypeID id = d->sib;
 687   while (id) {
 688     CType *df = ctype_get(cts, id);
 689     id = df->sib;
 690     if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
 691       MSize i = *ip;
 692       if (!gcref(df->name)) continue;  /* Ignore unnamed fields. */
 693       if (i >= len) break;
 694       *ip = i + 1;
 695       if (ctype_isfield(df->info))
 696         lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, o + i, 0);
 697       else
 698         lj_cconv_bf_tv(cts, df, dp+df->size, o + i);
 699       if ((d->info & CTF_UNION)) break;
 700     } else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
 701       cconv_substruct_init(cts, ctype_child(cts, df), dp+df->size, o, len, ip);
 702     }  /* Ignore all other entries in the chain. */
 703   }
 704 }
 705
 706 /* Initialize a struct/union with TValues. */
 707 static void cconv_struct_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
 708                               TValue *o, MSize len)
 709 {
 710   MSize i = 0;
 711   memset(dp, 0, sz);  /* Much simpler to clear the struct first. */
 712   cconv_substruct_init(cts, d, dp, o, len, &i);
 713   if (i < len)
 714     cconv_err_initov(cts, d);
 715 }
 716
 717 /* Check whether to use a multi-value initializer.
 718 ** This is true if an aggregate is to be initialized with a value.
 719 ** Valarrays are treated as values here so ct_tv handles (V|C, I|F).
 720 */
 721 int lj_cconv_multi_init(CType *d, TValue *o)
 722 {
 723   if (!(ctype_isrefarray(d->info) || ctype_isstruct(d->info)))
 724     return 0;  /* Destination is not an aggregate. */
 725   if (tvistab(o) || (tvisstr(o) && !ctype_isstruct(d->info)))
 726     return 0;  /* Initializer is not a value. */
 727   return 1;  /* Otherwise the initializer is a value. */
 728 }
 729
 730 /* Initialize C type with TValues. Caveat: expects to get the raw CType! */
 731 void lj_cconv_ct_init(CTState *cts, CType *d, CTSize sz,
 732                       uint8_t *dp, TValue *o, MSize len)
 733 {
 734   if (len == 0)
 735     memset(dp, 0, sz);
 736   else if (len == 1 && !lj_cconv_multi_init(d, o))
 737     lj_cconv_ct_tv(cts, d, dp, o, 0);
 738   else if (ctype_isarray(d->info))  /* Also handles valarray init with len>1. */
 739     cconv_array_init(cts, d, sz, dp, o, len);
 740   else if (ctype_isstruct(d->info))
 741     cconv_struct_init(cts, d, sz, dp, o, len);
 742   else
 743     cconv_err_initov(cts, d);
 744 }
 745
 746 #endif