3 ** Copyright (C) 2005-2014 Mike Pall. See Copyright Notice in luajit.h
14 #include "lj_strfmt.h"
16 #include "lj_ccallback.h"
18 /* -- C type definitions -------------------------------------------------- */
20 /* Predefined typedefs. */
22 /* Vararg handling. */ \
23 _("va_list", P_VOID) \
24 _("__builtin_va_list", P_VOID) \
25 _("__gnuc_va_list", P_VOID) \
26 /* From stddef.h. */ \
27 _("ptrdiff_t", INT_PSZ) \
28 _("size_t", UINT_PSZ) \
30 /* Subset of stdint.h. */ \
36 _("uint16_t", UINT16) \
37 _("uint32_t", UINT32) \
38 _("uint64_t", UINT64) \
39 _("intptr_t", INT_PSZ) \
40 _("uintptr_t", UINT_PSZ) \
41 /* End of typedef list. */
43 /* Keywords (only the ones we actually care for). */
45 /* Type specifiers. */ \
46 _("void", -1, CTOK_VOID) \
47 _("_Bool", 0, CTOK_BOOL) \
48 _("bool", 1, CTOK_BOOL) \
49 _("char", 1, CTOK_CHAR) \
50 _("int", 4, CTOK_INT) \
51 _("__int8", 1, CTOK_INT) \
52 _("__int16", 2, CTOK_INT) \
53 _("__int32", 4, CTOK_INT) \
54 _("__int64", 8, CTOK_INT) \
55 _("float", 4, CTOK_FP) \
56 _("double", 8, CTOK_FP) \
57 _("long", 0, CTOK_LONG) \
58 _("short", 0, CTOK_SHORT) \
59 _("_Complex", 0, CTOK_COMPLEX) \
60 _("complex", 0, CTOK_COMPLEX) \
61 _("__complex", 0, CTOK_COMPLEX) \
62 _("__complex__", 0, CTOK_COMPLEX) \
63 _("signed", 0, CTOK_SIGNED) \
64 _("__signed", 0, CTOK_SIGNED) \
65 _("__signed__", 0, CTOK_SIGNED) \
66 _("unsigned", 0, CTOK_UNSIGNED) \
67 /* Type qualifiers. */ \
68 _("const", 0, CTOK_CONST) \
69 _("__const", 0, CTOK_CONST) \
70 _("__const__", 0, CTOK_CONST) \
71 _("volatile", 0, CTOK_VOLATILE) \
72 _("__volatile", 0, CTOK_VOLATILE) \
73 _("__volatile__", 0, CTOK_VOLATILE) \
74 _("restrict", 0, CTOK_RESTRICT) \
75 _("__restrict", 0, CTOK_RESTRICT) \
76 _("__restrict__", 0, CTOK_RESTRICT) \
77 _("inline", 0, CTOK_INLINE) \
78 _("__inline", 0, CTOK_INLINE) \
79 _("__inline__", 0, CTOK_INLINE) \
80 /* Storage class specifiers. */ \
81 _("typedef", 0, CTOK_TYPEDEF) \
82 _("extern", 0, CTOK_EXTERN) \
83 _("static", 0, CTOK_STATIC) \
84 _("auto", 0, CTOK_AUTO) \
85 _("register", 0, CTOK_REGISTER) \
86 /* GCC Attributes. */ \
87 _("__extension__", 0, CTOK_EXTENSION) \
88 _("__attribute", 0, CTOK_ATTRIBUTE) \
89 _("__attribute__", 0, CTOK_ATTRIBUTE) \
90 _("asm", 0, CTOK_ASM) \
91 _("__asm", 0, CTOK_ASM) \
92 _("__asm__", 0, CTOK_ASM) \
93 /* MSVC Attributes. */ \
94 _("__declspec", 0, CTOK_DECLSPEC) \
95 _("__cdecl", CTCC_CDECL, CTOK_CCDECL) \
96 _("__thiscall", CTCC_THISCALL, CTOK_CCDECL) \
97 _("__fastcall", CTCC_FASTCALL, CTOK_CCDECL) \
98 _("__stdcall", CTCC_STDCALL, CTOK_CCDECL) \
99 _("__ptr32", 4, CTOK_PTRSZ) \
100 _("__ptr64", 8, CTOK_PTRSZ) \
101 /* Other type specifiers. */ \
102 _("struct", 0, CTOK_STRUCT) \
103 _("union", 0, CTOK_UNION) \
104 _("enum", 0, CTOK_ENUM) \
106 _("sizeof", 0, CTOK_SIZEOF) \
107 _("__alignof", 0, CTOK_ALIGNOF) \
108 _("__alignof__", 0, CTOK_ALIGNOF) \
109 /* End of keyword list. */
111 /* Type info for predefined types. Size merged in. */
112 static CTInfo lj_ctype_typeinfo
[] = {
113 #define CTTYINFODEF(id, sz, ct, info) CTINFO((ct),(((sz)&0x3fu)<<10)+(info)),
114 #define CTTDINFODEF(name, id) CTINFO(CT_TYPEDEF, CTID_##id),
115 #define CTKWINFODEF(name, sz, kw) CTINFO(CT_KW,(((sz)&0x3fu)<<10)+(kw)),
125 /* Predefined type names collected in a single string. */
126 static const char * const lj_ctype_typenames
=
127 #define CTTDNAMEDEF(name, id) name "\0"
128 #define CTKWNAMEDEF(name, sz, cds) name "\0"
135 #define CTTYPEINFO_NUM (sizeof(lj_ctype_typeinfo)/sizeof(CTInfo)-1)
136 #ifdef LUAJIT_CTYPE_CHECK_ANCHOR
137 #define CTTYPETAB_MIN CTTYPEINFO_NUM
139 #define CTTYPETAB_MIN 128
142 /* -- C type interning ---------------------------------------------------- */
144 #define ct_hashtype(info, size) (hashrot(info, size) & CTHASH_MASK)
145 #define ct_hashname(name) \
146 (hashrot(u32ptr(name), u32ptr(name) + HASH_BIAS) & CTHASH_MASK)
148 /* Create new type element. */
149 CTypeID
lj_ctype_new(CTState
*cts
, CType
**ctp
)
151 CTypeID id
= cts
->top
;
154 if (LJ_UNLIKELY(id
>= cts
->sizetab
)) {
155 if (id
>= CTID_MAX
) lj_err_msg(cts
->L
, LJ_ERR_TABOV
);
156 #ifdef LUAJIT_CTYPE_CHECK_ANCHOR
157 ct
= lj_mem_newvec(cts
->L
, id
+1, CType
);
158 memcpy(ct
, cts
->tab
, id
*sizeof(CType
));
159 memset(cts
->tab
, 0, id
*sizeof(CType
));
160 lj_mem_freevec(cts
->g
, cts
->tab
, cts
->sizetab
, CType
);
164 lj_mem_growvec(cts
->L
, cts
->tab
, cts
->sizetab
, CTID_MAX
, CType
);
168 *ctp
= ct
= &cts
->tab
[id
];
173 setgcrefnull(ct
->name
);
177 /* Intern a type element. */
178 CTypeID
lj_ctype_intern(CTState
*cts
, CTInfo info
, CTSize size
)
180 uint32_t h
= ct_hashtype(info
, size
);
181 CTypeID id
= cts
->hash
[h
];
184 CType
*ct
= ctype_get(cts
, id
);
185 if (ct
->info
== info
&& ct
->size
== size
)
190 if (LJ_UNLIKELY(id
>= cts
->sizetab
)) {
191 if (id
>= CTID_MAX
) lj_err_msg(cts
->L
, LJ_ERR_TABOV
);
192 lj_mem_growvec(cts
->L
, cts
->tab
, cts
->sizetab
, CTID_MAX
, CType
);
195 cts
->tab
[id
].info
= info
;
196 cts
->tab
[id
].size
= size
;
197 cts
->tab
[id
].sib
= 0;
198 cts
->tab
[id
].next
= cts
->hash
[h
];
199 setgcrefnull(cts
->tab
[id
].name
);
200 cts
->hash
[h
] = (CTypeID1
)id
;
204 /* Add type element to hash table. */
205 static void ctype_addtype(CTState
*cts
, CType
*ct
, CTypeID id
)
207 uint32_t h
= ct_hashtype(ct
->info
, ct
->size
);
208 ct
->next
= cts
->hash
[h
];
209 cts
->hash
[h
] = (CTypeID1
)id
;
212 /* Add named element to hash table. */
213 void lj_ctype_addname(CTState
*cts
, CType
*ct
, CTypeID id
)
215 uint32_t h
= ct_hashname(gcref(ct
->name
));
216 ct
->next
= cts
->hash
[h
];
217 cts
->hash
[h
] = (CTypeID1
)id
;
220 /* Get a C type by name, matching the type mask. */
221 CTypeID
lj_ctype_getname(CTState
*cts
, CType
**ctp
, GCstr
*name
, uint32_t tmask
)
223 CTypeID id
= cts
->hash
[ct_hashname(name
)];
225 CType
*ct
= ctype_get(cts
, id
);
226 if (gcref(ct
->name
) == obj2gco(name
) &&
227 ((tmask
>> ctype_type(ct
->info
)) & 1)) {
233 *ctp
= &cts
->tab
[0]; /* Simplify caller logic. ctype_get() would assert. */
237 /* Get a struct/union/enum/function field by name. */
238 CType
*lj_ctype_getfieldq(CTState
*cts
, CType
*ct
, GCstr
*name
, CTSize
*ofs
,
242 ct
= ctype_get(cts
, ct
->sib
);
243 if (gcref(ct
->name
) == obj2gco(name
)) {
247 if (ctype_isxattrib(ct
->info
, CTA_SUBTYPE
)) {
248 CType
*fct
, *cct
= ctype_child(cts
, ct
);
250 while (ctype_isattrib(cct
->info
)) {
251 if (ctype_attrib(cct
->info
) == CTA_QUAL
) q
|= cct
->size
;
252 cct
= ctype_child(cts
, cct
);
254 fct
= lj_ctype_getfieldq(cts
, cct
, name
, ofs
, qual
);
256 if (qual
) *qual
|= q
;
262 return NULL
; /* Not found. */
265 /* -- C type information -------------------------------------------------- */
267 /* Follow references and get raw type for a C type ID. */
268 CType
*lj_ctype_rawref(CTState
*cts
, CTypeID id
)
270 CType
*ct
= ctype_get(cts
, id
);
271 while (ctype_isattrib(ct
->info
) || ctype_isref(ct
->info
))
272 ct
= ctype_child(cts
, ct
);
276 /* Get size for a C type ID. Does NOT support VLA/VLS. */
277 CTSize
lj_ctype_size(CTState
*cts
, CTypeID id
)
279 CType
*ct
= ctype_raw(cts
, id
);
280 return ctype_hassize(ct
->info
) ? ct
->size
: CTSIZE_INVALID
;
283 /* Get size for a variable-length C type. Does NOT support other C types. */
284 CTSize
lj_ctype_vlsize(CTState
*cts
, CType
*ct
, CTSize nelem
)
287 if (ctype_isstruct(ct
->info
)) {
288 CTypeID arrid
= 0, fid
= ct
->sib
;
289 xsz
= ct
->size
; /* Add the struct size. */
291 CType
*ctf
= ctype_get(cts
, fid
);
292 if (ctype_type(ctf
->info
) == CT_FIELD
)
293 arrid
= ctype_cid(ctf
->info
); /* Remember last field of VLS. */
296 ct
= ctype_raw(cts
, arrid
);
298 lua_assert(ctype_isvlarray(ct
->info
)); /* Must be a VLA. */
299 ct
= ctype_rawchild(cts
, ct
); /* Get array element. */
300 lua_assert(ctype_hassize(ct
->info
));
301 /* Calculate actual size of VLA and check for overflow. */
302 xsz
+= (uint64_t)ct
->size
* nelem
;
303 return xsz
< 0x80000000u
? (CTSize
)xsz
: CTSIZE_INVALID
;
306 /* Get type, qualifiers, size and alignment for a C type ID. */
307 CTInfo
lj_ctype_info(CTState
*cts
, CTypeID id
, CTSize
*szp
)
310 CType
*ct
= ctype_get(cts
, id
);
312 CTInfo info
= ct
->info
;
313 if (ctype_isenum(info
)) {
314 /* Follow child. Need to look at its attributes, too. */
315 } else if (ctype_isattrib(info
)) {
316 if (ctype_isxattrib(info
, CTA_QUAL
))
318 else if (ctype_isxattrib(info
, CTA_ALIGN
) && !(qual
& CTFP_ALIGNED
))
319 qual
|= CTFP_ALIGNED
+ CTALIGN(ct
->size
);
321 if (!(qual
& CTFP_ALIGNED
)) qual
|= (info
& CTF_ALIGN
);
322 qual
|= (info
& ~(CTF_ALIGN
|CTMASK_CID
));
323 lua_assert(ctype_hassize(info
) || ctype_isfunc(info
));
324 *szp
= ctype_isfunc(info
) ? CTSIZE_INVALID
: ct
->size
;
327 ct
= ctype_get(cts
, ctype_cid(info
));
332 /* Get ctype metamethod. */
333 cTValue
*lj_ctype_meta(CTState
*cts
, CTypeID id
, MMS mm
)
335 CType
*ct
= ctype_get(cts
, id
);
337 while (ctype_isattrib(ct
->info
) || ctype_isref(ct
->info
)) {
338 id
= ctype_cid(ct
->info
);
339 ct
= ctype_get(cts
, id
);
341 if (ctype_isptr(ct
->info
) &&
342 ctype_isfunc(ctype_get(cts
, ctype_cid(ct
->info
))->info
))
343 tv
= lj_tab_getstr(cts
->miscmap
, &cts
->g
->strempty
);
345 tv
= lj_tab_getinth(cts
->miscmap
, -(int32_t)id
);
346 if (tv
&& tvistab(tv
) &&
347 (tv
= lj_tab_getstr(tabV(tv
), mmname_str(cts
->g
, mm
))) && !tvisnil(tv
))
352 /* -- C type representation ----------------------------------------------- */
354 /* Fixed max. length of a C type representation. */
355 #define CTREPR_MAX 512
357 typedef struct CTRepr
{
363 char buf
[CTREPR_MAX
];
366 /* Prepend string. */
367 static void ctype_prepstr(CTRepr
*ctr
, const char *str
, MSize len
)
370 if (ctr
->buf
+ len
+1 > p
) { ctr
->ok
= 0; return; }
371 if (ctr
->needsp
) *--p
= ' ';
374 while (len
-- > 0) p
[len
] = str
[len
];
378 #define ctype_preplit(ctr, str) ctype_prepstr((ctr), "" str, sizeof(str)-1)
381 static void ctype_prepc(CTRepr
*ctr
, int c
)
383 if (ctr
->buf
>= ctr
->pb
) { ctr
->ok
= 0; return; }
387 /* Prepend number. */
388 static void ctype_prepnum(CTRepr
*ctr
, uint32_t n
)
391 if (ctr
->buf
+ 10+1 > p
) { ctr
->ok
= 0; return; }
392 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
398 static void ctype_appc(CTRepr
*ctr
, int c
)
400 if (ctr
->pe
>= ctr
->buf
+ CTREPR_MAX
) { ctr
->ok
= 0; return; }
405 static void ctype_appnum(CTRepr
*ctr
, uint32_t n
)
408 char *p
= buf
+sizeof(buf
);
410 if (q
> ctr
->buf
+ CTREPR_MAX
- 10) { ctr
->ok
= 0; return; }
411 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
412 do { *q
++ = *p
++; } while (p
< buf
+sizeof(buf
));
416 /* Prepend qualifiers. */
417 static void ctype_prepqual(CTRepr
*ctr
, CTInfo info
)
419 if ((info
& CTF_VOLATILE
)) ctype_preplit(ctr
, "volatile");
420 if ((info
& CTF_CONST
)) ctype_preplit(ctr
, "const");
423 /* Prepend named type. */
424 static void ctype_preptype(CTRepr
*ctr
, CType
*ct
, CTInfo qual
, const char *t
)
426 if (gcref(ct
->name
)) {
427 GCstr
*str
= gco2str(gcref(ct
->name
));
428 ctype_prepstr(ctr
, strdata(str
), str
->len
);
430 if (ctr
->needsp
) ctype_prepc(ctr
, ' ');
431 ctype_prepnum(ctr
, ctype_typeid(ctr
->cts
, ct
));
434 ctype_prepstr(ctr
, t
, (MSize
)strlen(t
));
435 ctype_prepqual(ctr
, qual
);
438 static void ctype_repr(CTRepr
*ctr
, CTypeID id
)
440 CType
*ct
= ctype_get(ctr
->cts
, id
);
444 CTInfo info
= ct
->info
;
445 CTSize size
= ct
->size
;
446 switch (ctype_type(info
)) {
448 if ((info
& CTF_BOOL
)) {
449 ctype_preplit(ctr
, "bool");
450 } else if ((info
& CTF_FP
)) {
451 if (size
== sizeof(double)) ctype_preplit(ctr
, "double");
452 else if (size
== sizeof(float)) ctype_preplit(ctr
, "float");
453 else ctype_preplit(ctr
, "long double");
454 } else if (size
== 1) {
455 if (!((info
^ CTF_UCHAR
) & CTF_UNSIGNED
)) ctype_preplit(ctr
, "char");
456 else if (CTF_UCHAR
) ctype_preplit(ctr
, "signed char");
457 else ctype_preplit(ctr
, "unsigned char");
458 } else if (size
< 8) {
459 if (size
== 4) ctype_preplit(ctr
, "int");
460 else ctype_preplit(ctr
, "short");
461 if ((info
& CTF_UNSIGNED
)) ctype_preplit(ctr
, "unsigned");
463 ctype_preplit(ctr
, "_t");
464 ctype_prepnum(ctr
, size
*8);
465 ctype_preplit(ctr
, "int");
466 if ((info
& CTF_UNSIGNED
)) ctype_prepc(ctr
, 'u');
468 ctype_prepqual(ctr
, (qual
|info
));
471 ctype_preplit(ctr
, "void");
472 ctype_prepqual(ctr
, (qual
|info
));
475 ctype_preptype(ctr
, ct
, qual
, (info
& CTF_UNION
) ? "union" : "struct");
478 if (id
== CTID_CTYPEID
) {
479 ctype_preplit(ctr
, "ctype");
482 ctype_preptype(ctr
, ct
, qual
, "enum");
485 if (ctype_attrib(info
) == CTA_QUAL
) qual
|= size
;
488 if ((info
& CTF_REF
)) {
489 ctype_prepc(ctr
, '&');
491 ctype_prepqual(ctr
, (qual
|info
));
492 if (LJ_64
&& size
== 4) ctype_preplit(ctr
, "__ptr32");
493 ctype_prepc(ctr
, '*');
500 if (ctype_isrefarray(info
)) {
502 if (ptrto
) { ptrto
= 0; ctype_prepc(ctr
, '('); ctype_appc(ctr
, ')'); }
503 ctype_appc(ctr
, '[');
504 if (size
!= CTSIZE_INVALID
) {
505 CTSize csize
= ctype_child(ctr
->cts
, ct
)->size
;
506 ctype_appnum(ctr
, csize
? size
/csize
: 0);
507 } else if ((info
& CTF_VLA
)) {
508 ctype_appc(ctr
, '?');
510 ctype_appc(ctr
, ']');
511 } else if ((info
& CTF_COMPLEX
)) {
512 if (size
== 2*sizeof(float)) ctype_preplit(ctr
, "float");
513 ctype_preplit(ctr
, "complex");
516 ctype_preplit(ctr
, ")))");
517 ctype_prepnum(ctr
, size
);
518 ctype_preplit(ctr
, "__attribute__((vector_size(");
523 if (ptrto
) { ptrto
= 0; ctype_prepc(ctr
, '('); ctype_appc(ctr
, ')'); }
524 ctype_appc(ctr
, '(');
525 ctype_appc(ctr
, ')');
531 ct
= ctype_get(ctr
->cts
, ctype_cid(info
));
535 /* Return a printable representation of a C type. */
536 GCstr
*lj_ctype_repr(lua_State
*L
, CTypeID id
, GCstr
*name
)
538 global_State
*g
= G(L
);
540 ctr
.pb
= ctr
.pe
= &ctr
.buf
[CTREPR_MAX
/2];
541 ctr
.cts
= ctype_ctsG(g
);
545 if (name
) ctype_prepstr(&ctr
, strdata(name
), name
->len
);
546 ctype_repr(&ctr
, id
);
547 if (LJ_UNLIKELY(!ctr
.ok
)) return lj_str_newlit(L
, "?");
548 return lj_str_new(L
, ctr
.pb
, ctr
.pe
- ctr
.pb
);
551 /* Convert int64_t/uint64_t to string with 'LL' or 'ULL' suffix. */
552 GCstr
*lj_ctype_repr_int64(lua_State
*L
, uint64_t n
, int isunsigned
)
555 char *p
= buf
+sizeof(buf
);
557 *--p
= 'L'; *--p
= 'L';
560 } else if ((int64_t)n
< 0) {
561 n
= (uint64_t)-(int64_t)n
;
564 do { *--p
= (char)('0' + n
% 10); } while (n
/= 10);
565 if (sign
) *--p
= '-';
566 return lj_str_new(L
, p
, (size_t)(buf
+sizeof(buf
)-p
));
569 /* Convert complex to string with 'i' or 'I' suffix. */
570 GCstr
*lj_ctype_repr_complex(lua_State
*L
, void *sp
, CTSize size
)
572 char buf
[2*STRFMT_MAXBUF_NUM
+2+1], *p
= buf
;
574 if (size
== 2*sizeof(double)) {
575 re
.n
= *(double *)sp
; im
.n
= ((double *)sp
)[1];
577 re
.n
= (double)*(float *)sp
; im
.n
= (double)((float *)sp
)[1];
579 p
= lj_strfmt_wnum(p
, &re
);
580 if (!(im
.u32
.hi
& 0x80000000u
) || im
.n
!= im
.n
) *p
++ = '+';
581 p
= lj_strfmt_wnum(p
, &im
);
582 *p
= *(p
-1) >= 'a' ? 'I' : 'i';
584 return lj_str_new(L
, buf
, p
-buf
);
587 /* -- C type state -------------------------------------------------------- */
589 /* Initialize C type table and state. */
590 CTState
*lj_ctype_init(lua_State
*L
)
592 CTState
*cts
= lj_mem_newt(L
, sizeof(CTState
), CTState
);
593 CType
*ct
= lj_mem_newvec(L
, CTTYPETAB_MIN
, CType
);
594 const char *name
= lj_ctype_typenames
;
596 memset(cts
, 0, sizeof(CTState
));
598 cts
->sizetab
= CTTYPETAB_MIN
;
599 cts
->top
= CTTYPEINFO_NUM
;
602 for (id
= 0; id
< CTTYPEINFO_NUM
; id
++, ct
++) {
603 CTInfo info
= lj_ctype_typeinfo
[id
];
604 ct
->size
= (CTSize
)((int32_t)(info
<< 16) >> 26);
605 ct
->info
= info
& 0xffff03ffu
;
607 if (ctype_type(info
) == CT_KW
|| ctype_istypedef(info
)) {
608 size_t len
= strlen(name
);
609 GCstr
*str
= lj_str_new(L
, name
, len
);
610 ctype_setname(ct
, str
);
612 lj_ctype_addname(cts
, ct
, id
);
614 setgcrefnull(ct
->name
);
616 if (!ctype_isenum(info
)) ctype_addtype(cts
, ct
, id
);
619 setmref(G(L
)->ctype_state
, cts
);
623 /* Free C type table and state. */
624 void lj_ctype_freestate(global_State
*g
)
626 CTState
*cts
= ctype_ctsG(g
);
628 lj_ccallback_mcode_free(cts
);
629 lj_mem_freevec(g
, cts
->tab
, cts
->sizetab
, CType
);
630 lj_mem_freevec(g
, cts
->cb
.cbid
, cts
->cb
.sizeid
, CTypeID1
);
631 lj_mem_freet(g
, cts
);