One Level Up Top Level

src/lj_cconv.c - luajit-2.0-src

Functions defined

Source code

  1. /*
  2. ** C type conversions.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. #include "lj_obj.h"

  8. #if LJ_HASFFI

  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"

  17. /* -- Conversion errors --------------------------------------------------- */

  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. }

  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. }

  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. }

  55. /* -- C type compatibility checks ----------------------------------------- */

  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. }

  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. }

  111. /* -- C type to C type conversion ----------------------------------------- */

  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;

  125.   lua_assert(!ctype_isenum(dinfo) && !ctype_isenum(sinfo));
  126.   lua_assert(!ctype_isattrib(dinfo) && !ctype_isattrib(sinfo));

  128.   if (ctype_type(dinfo) > CT_MAYCONVERT || ctype_type(sinfo) > CT_MAYCONVERT)
  129.     goto err_conv;

  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);

  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.     }

  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;

  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. */

  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. */

  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. */

  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.     }

  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;

  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;

  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;

  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;

  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;

  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;

  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;

  364.   default:
  365.   err_conv:
  366.     cconv_err_conv(cts, d, s, flags);
  367.   }
  368. }

  370. /* -- C type to TValue conversion ----------------------------------------- */

  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. }

  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. }

  457. /* -- TValue to C type conversion ----------------------------------------- */

  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. }

  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. }

  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. }

  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. }

  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. }

  664. /* -- Initialize C type with TValues -------------------------------------- */

  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. }

  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. }

  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. }

  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. }

  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. }

  752. #endif

One Level Up Top Level