root/lj_cconv.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. cconv_err_conv
  2. cconv_err_convtv
  3. cconv_err_initov
  4. cconv_childqual
  5. lj_cconv_compatptr
  6. lj_cconv_ct_ct
  7. lj_cconv_tv_ct
  8. lj_cconv_tv_bf
  9. cconv_array_tab
  10. cconv_substruct_tab
  11. cconv_struct_tab
  12. lj_cconv_ct_tv
  13. lj_cconv_bf_tv
  14. cconv_array_init
  15. cconv_substruct_init
  16. cconv_struct_init
  17. lj_cconv_multi_init
  18. lj_cconv_ct_init

   1 /*
   2 ** C type conversions.
   3 ** Copyright (C) 2005-2017 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, iz = i;
 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           if (iz == 0) { *ip = i = -1; goto tryname; }  /* Init named fields. */
 504           break;  /* Stop at first nil. */
 505         }
 506         *ip = i + 1;
 507       } else {
 508       tryname:
 509         tv = (TValue *)lj_tab_getstr(t, gco2str(gcref(df->name)));
 510         if (!tv || tvisnil(tv)) continue;
 511       }
 512       if (ctype_isfield(df->info))
 513         lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, tv, flags);
 514       else
 515         lj_cconv_bf_tv(cts, df, dp+df->size, tv);
 516       if ((d->info & CTF_UNION)) break;
 517     } else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
 518       cconv_substruct_tab(cts, ctype_rawchild(cts, df),
 519                           dp+df->size, t, ip, flags);
 520     }  /* Ignore all other entries in the chain. */
 521   }
 522 }
 523 
 524 /* Convert table to struct/union. */
 525 static void cconv_struct_tab(CTState *cts, CType *d,
 526                              uint8_t *dp, GCtab *t, CTInfo flags)
 527 {
 528   int32_t i = 0;
 529   memset(dp, 0, d->size);  /* Much simpler to clear the struct first. */
 530   cconv_substruct_tab(cts, d, dp, t, &i, flags);
 531 }
 532 
 533 /* Convert TValue to C type. Caveat: expects to get the raw CType! */
 534 void lj_cconv_ct_tv(CTState *cts, CType *d,
 535                     uint8_t *dp, TValue *o, CTInfo flags)
 536 {
 537   CTypeID sid = CTID_P_VOID;
 538   CType *s;
 539   void *tmpptr;
 540   uint8_t tmpbool, *sp = (uint8_t *)&tmpptr;
 541   if (LJ_LIKELY(tvisint(o))) {
 542     sp = (uint8_t *)&o->i;
 543     sid = CTID_INT32;
 544     flags |= CCF_FROMTV;
 545   } else if (LJ_LIKELY(tvisnum(o))) {
 546     sp = (uint8_t *)&o->n;
 547     sid = CTID_DOUBLE;
 548     flags |= CCF_FROMTV;
 549   } else if (tviscdata(o)) {
 550     sp = cdataptr(cdataV(o));
 551     sid = cdataV(o)->ctypeid;
 552     s = ctype_get(cts, sid);
 553     if (ctype_isref(s->info)) {  /* Resolve reference for value. */
 554       lua_assert(s->size == CTSIZE_PTR);
 555       sp = *(void **)sp;
 556       sid = ctype_cid(s->info);
 557     }
 558     s = ctype_raw(cts, sid);
 559     if (ctype_isfunc(s->info)) {
 560       sid = lj_ctype_intern(cts, CTINFO(CT_PTR, CTALIGN_PTR|sid), CTSIZE_PTR);
 561     } else {
 562       if (ctype_isenum(s->info)) s = ctype_child(cts, s);
 563       goto doconv;
 564     }
 565   } else if (tvisstr(o)) {
 566     GCstr *str = strV(o);
 567     if (ctype_isenum(d->info)) {  /* Match string against enum constant. */
 568       CTSize ofs;
 569       CType *cct = lj_ctype_getfield(cts, d, str, &ofs);
 570       if (!cct || !ctype_isconstval(cct->info))
 571         goto err_conv;
 572       lua_assert(d->size == 4);
 573       sp = (uint8_t *)&cct->size;
 574       sid = ctype_cid(cct->info);
 575     } else if (ctype_isrefarray(d->info)) {  /* Copy string to array. */
 576       CType *dc = ctype_rawchild(cts, d);
 577       CTSize sz = str->len+1;
 578       if (!ctype_isinteger(dc->info) || dc->size != 1)
 579         goto err_conv;
 580       if (d->size != 0 && d->size < sz)
 581         sz = d->size;
 582       memcpy(dp, strdata(str), sz);
 583       return;
 584     } else {  /* Otherwise pass it as a const char[]. */
 585       sp = (uint8_t *)strdata(str);
 586       sid = CTID_A_CCHAR;
 587       flags |= CCF_FROMTV;
 588     }
 589   } else if (tvistab(o)) {
 590     if (ctype_isarray(d->info)) {
 591       cconv_array_tab(cts, d, dp, tabV(o), flags);
 592       return;
 593     } else if (ctype_isstruct(d->info)) {
 594       cconv_struct_tab(cts, d, dp, tabV(o), flags);
 595       return;
 596     } else {
 597       goto err_conv;
 598     }
 599   } else if (tvisbool(o)) {
 600     tmpbool = boolV(o);
 601     sp = &tmpbool;
 602     sid = CTID_BOOL;
 603   } else if (tvisnil(o)) {
 604     tmpptr = (void *)0;
 605     flags |= CCF_FROMTV;
 606   } else if (tvisudata(o)) {
 607     GCudata *ud = udataV(o);
 608     tmpptr = uddata(ud);
 609     if (ud->udtype == UDTYPE_IO_FILE)
 610       tmpptr = *(void **)tmpptr;
 611   } else if (tvislightud(o)) {
 612     tmpptr = lightudV(o);
 613   } else if (tvisfunc(o)) {
 614     void *p = lj_ccallback_new(cts, d, funcV(o));
 615     if (p) {
 616       *(void **)dp = p;
 617       return;
 618     }
 619     goto err_conv;
 620   } else {
 621   err_conv:
 622     cconv_err_convtv(cts, d, o, flags);
 623   }
 624   s = ctype_get(cts, sid);
 625 doconv:
 626   if (ctype_isenum(d->info)) d = ctype_child(cts, d);
 627   lj_cconv_ct_ct(cts, d, s, dp, sp, flags);
 628 }
 629 
 630 /* Convert TValue to bitfield. */
 631 void lj_cconv_bf_tv(CTState *cts, CType *d, uint8_t *dp, TValue *o)
 632 {
 633   CTInfo info = d->info;
 634   CTSize pos, bsz;
 635   uint32_t val, mask;
 636   lua_assert(ctype_isbitfield(info));
 637   if ((info & CTF_BOOL)) {
 638     uint8_t tmpbool;
 639     lua_assert(ctype_bitbsz(info) == 1);
 640     lj_cconv_ct_tv(cts, ctype_get(cts, CTID_BOOL), &tmpbool, o, 0);
 641     val = tmpbool;
 642   } else {
 643     CTypeID did = (info & CTF_UNSIGNED) ? CTID_UINT32 : CTID_INT32;
 644     lj_cconv_ct_tv(cts, ctype_get(cts, did), (uint8_t *)&val, o, 0);
 645   }
 646   pos = ctype_bitpos(info);
 647   bsz = ctype_bitbsz(info);
 648   lua_assert(pos < 8*ctype_bitcsz(info));
 649   lua_assert(bsz > 0 && bsz <= 8*ctype_bitcsz(info));
 650   /* Check if a packed bitfield crosses a container boundary. */
 651   if (pos + bsz > 8*ctype_bitcsz(info))
 652     lj_err_caller(cts->L, LJ_ERR_FFI_NYIPACKBIT);
 653   mask = ((1u << bsz) - 1u) << pos;
 654   val = (val << pos) & mask;
 655   /* NYI: packed bitfields may cause misaligned reads/writes. */
 656   switch (ctype_bitcsz(info)) {
 657   case 4: *(uint32_t *)dp = (*(uint32_t *)dp & ~mask) | (uint32_t)val; break;
 658   case 2: *(uint16_t *)dp = (*(uint16_t *)dp & ~mask) | (uint16_t)val; break;
 659   case 1: *(uint8_t *)dp = (*(uint8_t *)dp & ~mask) | (uint8_t)val; break;
 660   default: lua_assert(0); break;
 661   }
 662 }
 663 
 664 /* -- Initialize C type with TValues -------------------------------------- */
 665 
 666 /* Initialize an array with TValues. */
 667 static void cconv_array_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
 668                              TValue *o, MSize len)
 669 {
 670   CType *dc = ctype_rawchild(cts, d);  /* Array element type. */
 671   CTSize ofs, esize = dc->size;
 672   MSize i;
 673   if (len*esize > sz)
 674     cconv_err_initov(cts, d);
 675   for (i = 0, ofs = 0; i < len; i++, ofs += esize)
 676     lj_cconv_ct_tv(cts, dc, dp + ofs, o + i, 0);
 677   if (ofs == esize) {  /* Replicate a single element. */
 678     for (; ofs < sz; ofs += esize) memcpy(dp + ofs, dp, esize);
 679   } else {  /* Otherwise fill the remainder with zero. */
 680     memset(dp + ofs, 0, sz - ofs);
 681   }
 682 }
 683 
 684 /* Initialize a sub-struct/union with TValues. */
 685 static void cconv_substruct_init(CTState *cts, CType *d, uint8_t *dp,
 686                                  TValue *o, MSize len, MSize *ip)
 687 {
 688   CTypeID id = d->sib;
 689   while (id) {
 690     CType *df = ctype_get(cts, id);
 691     id = df->sib;
 692     if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
 693       MSize i = *ip;
 694       if (!gcref(df->name)) continue;  /* Ignore unnamed fields. */
 695       if (i >= len) break;
 696       *ip = i + 1;
 697       if (ctype_isfield(df->info))
 698         lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, o + i, 0);
 699       else
 700         lj_cconv_bf_tv(cts, df, dp+df->size, o + i);
 701       if ((d->info & CTF_UNION)) break;
 702     } else if (ctype_isxattrib(df->info, CTA_SUBTYPE)) {
 703       cconv_substruct_init(cts, ctype_rawchild(cts, df),
 704                            dp+df->size, o, len, ip);
 705       if ((d->info & CTF_UNION)) break;
 706     }  /* Ignore all other entries in the chain. */
 707   }
 708 }
 709 
 710 /* Initialize a struct/union with TValues. */
 711 static void cconv_struct_init(CTState *cts, CType *d, CTSize sz, uint8_t *dp,
 712                               TValue *o, MSize len)
 713 {
 714   MSize i = 0;
 715   memset(dp, 0, sz);  /* Much simpler to clear the struct first. */
 716   cconv_substruct_init(cts, d, dp, o, len, &i);
 717   if (i < len)
 718     cconv_err_initov(cts, d);
 719 }
 720 
 721 /* Check whether to use a multi-value initializer.
 722 ** This is true if an aggregate is to be initialized with a value.
 723 ** Valarrays are treated as values here so ct_tv handles (V|C, I|F).
 724 */
 725 int lj_cconv_multi_init(CTState *cts, CType *d, TValue *o)
 726 {
 727   if (!(ctype_isrefarray(d->info) || ctype_isstruct(d->info)))
 728     return 0;  /* Destination is not an aggregate. */
 729   if (tvistab(o) || (tvisstr(o) && !ctype_isstruct(d->info)))
 730     return 0;  /* Initializer is not a value. */
 731   if (tviscdata(o) && lj_ctype_rawref(cts, cdataV(o)->ctypeid) == d)
 732     return 0;  /* Source and destination are identical aggregates. */
 733   return 1;  /* Otherwise the initializer is a value. */
 734 }
 735 
 736 /* Initialize C type with TValues. Caveat: expects to get the raw CType! */
 737 void lj_cconv_ct_init(CTState *cts, CType *d, CTSize sz,
 738                       uint8_t *dp, TValue *o, MSize len)
 739 {
 740   if (len == 0)
 741     memset(dp, 0, sz);
 742   else if (len == 1 && !lj_cconv_multi_init(cts, d, o))
 743     lj_cconv_ct_tv(cts, d, dp, o, 0);
 744   else if (ctype_isarray(d->info))  /* Also handles valarray init with len>1. */
 745     cconv_array_init(cts, d, sz, dp, o, len);
 746   else if (ctype_isstruct(d->info))
 747     cconv_struct_init(cts, d, sz, dp, o, len);
 748   else
 749     cconv_err_initov(cts, d);
 750 }
 751 
 752 #endif

/* [<][>][^][v][top][bottom][index][help] */