luna - luajit/src/lj

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