3 ** Copyright (C) 2005-2012 Mike Pall. See Copyright Notice in luajit.h
15 #include "lj_ccallback.h"
17 /* -- C type definitions -------------------------------------------------- */
19 /* Predefined typedefs. */
21 /* Vararg handling. */ \
22 _("va_list", P_VOID) \
23 _("__builtin_va_list", P_VOID) \
24 _("__gnuc_va_list", P_VOID) \
25 /* From stddef.h. */ \
26 _("ptrdiff_t", INT_PSZ) \
27 _("size_t", UINT_PSZ) \
29 /* Subset of stdint.h. */ \
35 _("uint16_t", UINT16) \
36 _("uint32_t", UINT32) \
37 _("uint64_t", UINT64) \
38 _("intptr_t", INT_PSZ) \
39 _("uintptr_t", UINT_PSZ) \
40 /* End of typedef list. */
42 /* Keywords (only the ones we actually care for). */
44 /* Type specifiers. */ \
45 _("void", -1, CTOK_VOID) \
46 _("_Bool", 0, CTOK_BOOL) \
47 _("bool", 1, CTOK_BOOL) \
48 _("char", 1, CTOK_CHAR) \
49 _("int", 4, CTOK_INT) \
50 _("__int8", 1, CTOK_INT) \
51 _("__int16", 2, CTOK_INT) \
52 _("__int32", 4, CTOK_INT) \
53 _("__int64", 8, CTOK_INT) \
54 _("float", 4, CTOK_FP) \
55 _("double", 8, CTOK_FP) \
56 _("long", 0, CTOK_LONG) \
57 _("short", 0, CTOK_SHORT) \
58 _("_Complex", 0, CTOK_COMPLEX) \
59 _("complex", 0, CTOK_COMPLEX) \
60 _("__complex", 0, CTOK_COMPLEX) \
61 _("__complex__", 0, CTOK_COMPLEX) \
62 _("signed", 0, CTOK_SIGNED) \
63 _("__signed", 0, CTOK_SIGNED) \
64 _("__signed__", 0, CTOK_SIGNED) \
65 _("unsigned", 0, CTOK_UNSIGNED) \
66 /* Type qualifiers. */ \
67 _("const", 0, CTOK_CONST) \
68 _("__const", 0, CTOK_CONST) \
69 _("__const__", 0, CTOK_CONST) \
70 _("volatile", 0, CTOK_VOLATILE) \
71 _("__volatile", 0, CTOK_VOLATILE) \
72 _("__volatile__", 0, CTOK_VOLATILE) \
73 _("restrict", 0, CTOK_RESTRICT) \
74 _("__restrict", 0, CTOK_RESTRICT) \
75 _("__restrict__", 0, CTOK_RESTRICT) \
76 _("inline", 0, CTOK_INLINE) \
77 _("__inline", 0, CTOK_INLINE) \
78 _("__inline__", 0, CTOK_INLINE) \
79 /* Storage class specifiers. */ \
80 _("typedef", 0, CTOK_TYPEDEF) \
81 _("extern", 0, CTOK_EXTERN) \
82 _("static", 0, CTOK_STATIC) \
83 _("auto", 0, CTOK_AUTO) \
84 _("register", 0, CTOK_REGISTER) \
85 /* GCC Attributes. */ \
86 _("__extension__", 0, CTOK_EXTENSION) \
87 _("__attribute", 0, CTOK_ATTRIBUTE) \
88 _("__attribute__", 0, CTOK_ATTRIBUTE) \
89 _("asm", 0, CTOK_ASM) \
90 _("__asm", 0, CTOK_ASM) \
91 _("__asm__", 0, CTOK_ASM) \
92 /* MSVC Attributes. */ \
93 _("__declspec", 0, CTOK_DECLSPEC) \
94 _("__cdecl", CTCC_CDECL, CTOK_CCDECL) \
95 _("__thiscall", CTCC_THISCALL, CTOK_CCDECL) \
96 _("__fastcall", CTCC_FASTCALL, CTOK_CCDECL) \
97 _("__stdcall", CTCC_STDCALL, CTOK_CCDECL) \
98 _("__ptr32", 4, CTOK_PTRSZ) \
99 _("__ptr64", 8, CTOK_PTRSZ) \
100 /* Other type specifiers. */ \
101 _("struct", 0, CTOK_STRUCT) \
102 _("union", 0, CTOK_UNION) \
103 _("enum", 0, CTOK_ENUM) \
105 _("sizeof", 0, CTOK_SIZEOF) \
106 _("__alignof", 0, CTOK_ALIGNOF) \
107 _("__alignof__", 0, CTOK_ALIGNOF) \
108 /* End of keyword list. */
110 /* Type info for predefined types. Size merged in. */
111 static CTInfo lj_ctype_typeinfo
[] = {
112 #define CTTYINFODEF(id, sz, ct, info) CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
113 #define CTTDINFODEF(name, id) CTINFO(CT_TYPEDEF, CTID_##id),
114 #define CTKWINFODEF(name, sz, kw) CTINFO(CT_KW,(((sz)&0x3fu)<<10)+(kw)),
124 /* Predefined type names collected in a single string. */
125 static const char * const lj_ctype_typenames
=
126 #define CTTDNAMEDEF(name, id) name "\0"
127 #define CTKWNAMEDEF(name, sz, cds) name "\0"
134 #define CTTYPEINFO_NUM (sizeof(lj_ctype_typeinfo)/sizeof(CTInfo)-1)
135 #define CTTYPETAB_MIN 128
137 /* -- C type interning ---------------------------------------------------- */
139 #define ct_hashtype(info, size) (hashrot(info, size) & CTHASH_MASK)
140 #define ct_hashname(name) \
141 (hashrot(u32ptr(name), u32ptr(name) + HASH_BIAS) & CTHASH_MASK)
143 /* Create new type element. */
144 CTypeID
lj_ctype_new(CTState
*cts
, CType
**ctp
)
146 CTypeID id
= cts
->top
;
149 if (LJ_UNLIKELY(id
>= cts
->sizetab
)) {
150 if (id
>= CTID_MAX
) lj_err_msg(cts
->L
, LJ_ERR_TABOV
);
151 lj_mem_growvec(cts
->L
, cts
->tab
, cts
->sizetab
, CTID_MAX
, CType
);
154 *ctp
= ct
= &cts
->tab
[id
];
159 setgcrefnull(ct
->name
);
163 /* Intern a type element. */
164 CTypeID
lj_ctype_intern(CTState
*cts
, CTInfo info
, CTSize size
)
166 uint32_t h
= ct_hashtype(info
, size
);
167 CTypeID id
= cts
->hash
[h
];
170 CType
*ct
= ctype_get(cts
, id
);
171 if (ct
->info
== info
&& ct
->size
== size
)
176 if (LJ_UNLIKELY(id
>= cts
->sizetab
)) {
177 if (id
>= CTID_MAX
) lj_err_msg(cts
->L
, LJ_ERR_TABOV
);
178 lj_mem_growvec(cts
->L
, cts
->tab
, cts
->sizetab
, CTID_MAX
, CType
);
181 cts
->tab
[id
].info
= info
;
182 cts
->tab
[id
].size
= size
;
183 cts
->tab
[id
].sib
= 0;
184 cts
->tab
[id
].next
= cts
->hash
[h
];
185 setgcrefnull(cts
->tab
[id
].name
);
186 cts
->hash
[h
] = (CTypeID1
)id
;
190 /* Add type element to hash table. */
191 static void ctype_addtype(CTState
*cts
, CType
*ct
, CTypeID id
)
193 uint32_t h
= ct_hashtype(ct
->info
, ct
->size
);
194 ct
->next
= cts
->hash
[h
];
195 cts
->hash
[h
] = (CTypeID1
)id
;
198 /* Add named element to hash table. */
199 void lj_ctype_addname(CTState
*cts
, CType
*ct
, CTypeID id
)
201 uint32_t h
= ct_hashname(gcref(ct
->name
));
202 ct
->next
= cts
->hash
[h
];
203 cts
->hash
[h
] = (CTypeID1
)id
;
206 /* Get a C type by name, matching the type mask. */
207 CTypeID
lj_ctype_getname(CTState
*cts
, CType
**ctp
, GCstr
*name
, uint32_t tmask
)
209 CTypeID id
= cts
->hash
[ct_hashname(name
)];
211 CType
*ct
= ctype_get(cts
, id
);
212 if (gcref(ct
->name
) == obj2gco(name
) &&
213 ((tmask
>> ctype_type(ct
->info
)) & 1)) {
219 *ctp
= &cts
->tab
[0]; /* Simplify caller logic. ctype_get() would assert. */
223 /* Get a struct/union/enum/function field by name. */
224 CType
*lj_ctype_getfield(CTState
*cts
, CType
*ct
, GCstr
*name
, CTSize
*ofs
)
227 ct
= ctype_get(cts
, ct
->sib
);
228 if (gcref(ct
->name
) == obj2gco(name
)) {
232 if (ctype_isxattrib(ct
->info
, CTA_SUBTYPE
)) {
233 CType
*fct
= lj_ctype_getfield(cts
, ctype_child(cts
, ct
), name
, ofs
);
240 return NULL
; /* Not found. */
243 /* -- C type information -------------------------------------------------- */
245 /* Follow references and get raw type for a C type ID. */
246 CType
*lj_ctype_rawref(CTState
*cts
, CTypeID id
)
248 CType
*ct
= ctype_get(cts
, id
);
249 while (ctype_isattrib(ct
->info
) || ctype_isref(ct
->info
))
250 ct
= ctype_child(cts
, ct
);
254 /* Get size for a C type ID. Does NOT support VLA/VLS. */
255 CTSize
lj_ctype_size(CTState
*cts
, CTypeID id
)
257 CType
*ct
= ctype_raw(cts
, id
);
258 return ctype_hassize(ct
->info
) ? ct
->size
: CTSIZE_INVALID
;
261 /* Get size for a variable-length C type. Does NOT support other C types. */
262 CTSize
lj_ctype_vlsize(CTState
*cts
, CType
*ct
, CTSize nelem
)
265 if (ctype_isstruct(ct
->info
)) {
266 CTypeID arrid
= 0, fid
= ct
->sib
;
267 xsz
= ct
->size
; /* Add the struct size. */
269 CType
*ctf
= ctype_get(cts
, fid
);
270 if (ctype_type(ctf
->info
) == CT_FIELD
)
271 arrid
= ctype_cid(ctf
->info
); /* Remember last field of VLS. */
274 ct
= ctype_raw(cts
, arrid
);
276 lua_assert(ctype_isvlarray(ct
->info
)); /* Must be a VLA. */
277 ct
= ctype_rawchild(cts
, ct
); /* Get array element. */
278 lua_assert(ctype_hassize(ct
->info
));
279 /* Calculate actual size of VLA and check for overflow. */
280 xsz
+= (uint64_t)ct
->size
* nelem
;
281 return xsz
< 0x80000000u
? (CTSize
)xsz
: CTSIZE_INVALID
;
284 /* Get type, qualifiers, size and alignment for a C type ID. */
285 CTInfo
lj_ctype_info(CTState
*cts
, CTypeID id
, CTSize
*szp
)
288 CType
*ct
= ctype_get(cts
, id
);
290 CTInfo info
= ct
->info
;
291 if (ctype_isenum(info
)) {
292 /* Follow child. Need to look at its attributes, too. */
293 } else if (ctype_isattrib(info
)) {
294 if (ctype_isxattrib(info
, CTA_QUAL
))
296 else if (ctype_isxattrib(info
, CTA_ALIGN
) && !(qual
& CTFP_ALIGNED
))
297 qual
|= CTFP_ALIGNED
+ CTALIGN(ct
->size
);
299 if (!(qual
& CTFP_ALIGNED
)) qual
|= (info
& CTF_ALIGN
);
300 qual
|= (info
& ~(CTF_ALIGN
|CTMASK_CID
));
301 lua_assert(ctype_hassize(info
) || ctype_isfunc(info
));
302 *szp
= ctype_isfunc(info
) ? CTSIZE_INVALID
: ct
->size
;
305 ct
= ctype_get(cts
, ctype_cid(info
));
310 /* Get ctype metamethod. */
311 cTValue
*lj_ctype_meta(CTState
*cts
, CTypeID id
, MMS mm
)
313 CType
*ct
= ctype_get(cts
, id
);
315 while (ctype_isattrib(ct
->info
) || ctype_isref(ct
->info
)) {
316 id
= ctype_cid(ct
->info
);
317 ct
= ctype_get(cts
, id
);
319 if (ctype_isptr(ct
->info
) &&
320 ctype_isfunc(ctype_get(cts
, ctype_cid(ct
->info
))->info
))
321 tv
= lj_tab_getstr(cts
->miscmap
, &cts
->g
->strempty
);
323 tv
= lj_tab_getinth(cts
->miscmap
, -(int32_t)id
);
324 if (tv
&& tvistab(tv
) &&
325 (tv
= lj_tab_getstr(tabV(tv
), mmname_str(cts
->g
, mm
))) && !tvisnil(tv
))
330 /* -- C type representation ----------------------------------------------- */
332 /* Fixed max. length of a C type representation. */
333 #define CTREPR_MAX 512
335 typedef struct CTRepr
{
341 char buf
[CTREPR_MAX
];
344 /* Prepend string. */
345 static void ctype_prepstr(CTRepr
*ctr
, const char *str
, MSize len
)
348 if (ctr
->buf
+ len
+1 > p
) { ctr
->ok
= 0; return; }
349 if (ctr
->needsp
) *--p
= ' ';
352 while (len
-- > 0) p
[len
] = str
[len
];
356 #define ctype_preplit(ctr, str) ctype_prepstr((ctr), "" str, sizeof(str)-1)
359 static void ctype_prepc(CTRepr
*ctr
, int c
)
361 if (ctr
->buf
>= ctr
->pb
) { ctr
->ok
= 0; return; }
365 /* Prepend number. */
366 static void ctype_prepnum(CTRepr
*ctr
, uint32_t n
)
369 if (ctr
->buf
+ 10+1 > p
) { ctr
->ok
= 0; return; }
370 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
376 static void ctype_appc(CTRepr
*ctr
, int c
)
378 if (ctr
->pe
>= ctr
->buf
+ CTREPR_MAX
) { ctr
->ok
= 0; return; }
383 static void ctype_appnum(CTRepr
*ctr
, uint32_t n
)
386 char *p
= buf
+sizeof(buf
);
388 if (q
> ctr
->buf
+ CTREPR_MAX
- 10) { ctr
->ok
= 0; return; }
389 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
390 do { *q
++ = *p
++; } while (p
< buf
+sizeof(buf
));
394 /* Prepend qualifiers. */
395 static void ctype_prepqual(CTRepr
*ctr
, CTInfo info
)
397 if ((info
& CTF_VOLATILE
)) ctype_preplit(ctr
, "volatile");
398 if ((info
& CTF_CONST
)) ctype_preplit(ctr
, "const");
401 /* Prepend named type. */
402 static void ctype_preptype(CTRepr
*ctr
, CType
*ct
, CTInfo qual
, const char *t
)
404 if (gcref(ct
->name
)) {
405 GCstr
*str
= gco2str(gcref(ct
->name
));
406 ctype_prepstr(ctr
, strdata(str
), str
->len
);
408 if (ctr
->needsp
) ctype_prepc(ctr
, ' ');
409 ctype_prepnum(ctr
, ctype_typeid(ctr
->cts
, ct
));
412 ctype_prepstr(ctr
, t
, (MSize
)strlen(t
));
413 ctype_prepqual(ctr
, qual
);
416 static void ctype_repr(CTRepr
*ctr
, CTypeID id
)
418 CType
*ct
= ctype_get(ctr
->cts
, id
);
422 CTInfo info
= ct
->info
;
423 CTSize size
= ct
->size
;
424 switch (ctype_type(info
)) {
426 if ((info
& CTF_BOOL
)) {
427 ctype_preplit(ctr
, "bool");
428 } else if ((info
& CTF_FP
)) {
429 if (size
== sizeof(double)) ctype_preplit(ctr
, "double");
430 else if (size
== sizeof(float)) ctype_preplit(ctr
, "float");
431 else ctype_preplit(ctr
, "long double");
432 } else if (size
== 1) {
433 if (!((info
^ CTF_UCHAR
) & CTF_UNSIGNED
)) ctype_preplit(ctr
, "char");
434 else if (CTF_UCHAR
) ctype_preplit(ctr
, "signed char");
435 else ctype_preplit(ctr
, "unsigned char");
436 } else if (size
< 8) {
437 if (size
== 4) ctype_preplit(ctr
, "int");
438 else ctype_preplit(ctr
, "short");
439 if ((info
& CTF_UNSIGNED
)) ctype_preplit(ctr
, "unsigned");
441 ctype_preplit(ctr
, "_t");
442 ctype_prepnum(ctr
, size
*8);
443 ctype_preplit(ctr
, "int");
444 if ((info
& CTF_UNSIGNED
)) ctype_prepc(ctr
, 'u');
446 ctype_prepqual(ctr
, (qual
|info
));
449 ctype_preplit(ctr
, "void");
450 ctype_prepqual(ctr
, (qual
|info
));
453 ctype_preptype(ctr
, ct
, qual
, (info
& CTF_UNION
) ? "union" : "struct");
456 if (id
== CTID_CTYPEID
) {
457 ctype_preplit(ctr
, "ctype");
460 ctype_preptype(ctr
, ct
, qual
, "enum");
463 if (ctype_attrib(info
) == CTA_QUAL
) qual
|= size
;
466 if ((info
& CTF_REF
)) {
467 ctype_prepc(ctr
, '&');
469 ctype_prepqual(ctr
, (qual
|info
));
470 if (LJ_64
&& size
== 4) ctype_preplit(ctr
, "__ptr32");
471 ctype_prepc(ctr
, '*');
478 if (ctype_isrefarray(info
)) {
480 if (ptrto
) { ptrto
= 0; ctype_prepc(ctr
, '('); ctype_appc(ctr
, ')'); }
481 ctype_appc(ctr
, '[');
482 if (size
!= CTSIZE_INVALID
) {
483 CTSize csize
= ctype_child(ctr
->cts
, ct
)->size
;
484 ctype_appnum(ctr
, csize
? size
/csize
: 0);
485 } else if ((info
& CTF_VLA
)) {
486 ctype_appc(ctr
, '?');
488 ctype_appc(ctr
, ']');
489 } else if ((info
& CTF_COMPLEX
)) {
490 if (size
== 2*sizeof(float)) ctype_preplit(ctr
, "float");
491 ctype_preplit(ctr
, "complex");
494 ctype_preplit(ctr
, ")))");
495 ctype_prepnum(ctr
, size
);
496 ctype_preplit(ctr
, "__attribute__((vector_size(");
501 if (ptrto
) { ptrto
= 0; ctype_prepc(ctr
, '('); ctype_appc(ctr
, ')'); }
502 ctype_appc(ctr
, '(');
503 ctype_appc(ctr
, ')');
509 ct
= ctype_get(ctr
->cts
, ctype_cid(info
));
513 /* Return a printable representation of a C type. */
514 GCstr
*lj_ctype_repr(lua_State
*L
, CTypeID id
, GCstr
*name
)
516 global_State
*g
= G(L
);
518 ctr
.pb
= ctr
.pe
= &ctr
.buf
[CTREPR_MAX
/2];
519 ctr
.cts
= ctype_ctsG(g
);
523 if (name
) ctype_prepstr(&ctr
, strdata(name
), name
->len
);
524 ctype_repr(&ctr
, id
);
525 if (LJ_UNLIKELY(!ctr
.ok
)) return lj_str_newlit(L
, "?");
526 return lj_str_new(L
, ctr
.pb
, ctr
.pe
- ctr
.pb
);
529 /* Convert int64_t/uint64_t to string with 'LL' or 'ULL' suffix. */
530 GCstr
*lj_ctype_repr_int64(lua_State
*L
, uint64_t n
, int isunsigned
)
533 char *p
= buf
+sizeof(buf
);
535 *--p
= 'L'; *--p
= 'L';
538 } else if ((int64_t)n
< 0) {
539 n
= (uint64_t)-(int64_t)n
;
542 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
543 if (sign
) *--p
= '-';
544 return lj_str_new(L
, p
, (size_t)(buf
+sizeof(buf
)-p
));
547 /* Convert complex to string with 'i' or 'I' suffix. */
548 GCstr
*lj_ctype_repr_complex(lua_State
*L
, void *sp
, CTSize size
)
550 char buf
[2*LJ_STR_NUMBUF
+2+1];
553 if (size
== 2*sizeof(double)) {
554 re
.n
= *(double *)sp
; im
.n
= ((double *)sp
)[1];
556 re
.n
= (double)*(float *)sp
; im
.n
= (double)((float *)sp
)[1];
558 len
= lj_str_bufnum(buf
, &re
);
559 if (!(im
.u32
.hi
& 0x80000000u
) || im
.n
!= im
.n
) buf
[len
++] = '+';
560 len
+= lj_str_bufnum(buf
+len
, &im
);
561 buf
[len
] = buf
[len
-1] >= 'a' ? 'I' : 'i';
562 return lj_str_new(L
, buf
, len
+1);
565 /* -- C type state -------------------------------------------------------- */
567 /* Initialize C type table and state. */
568 CTState
*lj_ctype_init(lua_State
*L
)
570 CTState
*cts
= lj_mem_newt(L
, sizeof(CTState
), CTState
);
571 CType
*ct
= lj_mem_newvec(L
, CTTYPETAB_MIN
, CType
);
572 const char *name
= lj_ctype_typenames
;
574 memset(cts
, 0, sizeof(CTState
));
576 cts
->sizetab
= CTTYPETAB_MIN
;
577 cts
->top
= CTTYPEINFO_NUM
;
580 for (id
= 0; id
< CTTYPEINFO_NUM
; id
++, ct
++) {
581 CTInfo info
= lj_ctype_typeinfo
[id
];
582 ct
->size
= (CTSize
)((int32_t)(info
<< 16) >> 26);
583 ct
->info
= info
& 0xffff03ffu
;
585 if (ctype_type(info
) == CT_KW
|| ctype_istypedef(info
)) {
586 size_t len
= strlen(name
);
587 GCstr
*str
= lj_str_new(L
, name
, len
);
588 ctype_setname(ct
, str
);
590 lj_ctype_addname(cts
, ct
, id
);
592 setgcrefnull(ct
->name
);
594 if (!ctype_isenum(info
)) ctype_addtype(cts
, ct
, id
);
597 setmref(G(L
)->ctype_state
, cts
);
601 /* Free C type table and state. */
602 void lj_ctype_freestate(global_State
*g
)
604 CTState
*cts
= ctype_ctsG(g
);
606 lj_ccallback_mcode_free(cts
);
607 lj_mem_freevec(g
, cts
->tab
, cts
->sizetab
, CType
);
608 lj_mem_freevec(g
, cts
->cb
.cbid
, cts
->cb
.sizeid
, CTypeID1
);
609 lj_mem_freet(g
, cts
);