source/libs/luajit/LuaJIT-src/src/lj_ctype.h

   1 /*
   2 ** C type management.
   3 ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #ifndef _LJ_CTYPE_H
   7 #define _LJ_CTYPE_H
   8
   9 #include "lj_obj.h"
  10 #include "lj_gc.h"
  11
  12 #if LJ_HASFFI
  13
  14 /* -- C type definitions -------------------------------------------------- */
  15
  16 /* C type numbers. Highest 4 bits of C type info. ORDER CT. */
  17 enum {
  18   /* Externally visible types. */
  19   CT_NUM,               /* Integer or floating-point numbers. */
  20   CT_STRUCT,            /* Struct or union. */
  21   CT_PTR,               /* Pointer or reference. */
  22   CT_ARRAY,             /* Array or complex type. */
  23   CT_MAYCONVERT = CT_ARRAY,
  24   CT_VOID,              /* Void type. */
  25   CT_ENUM,              /* Enumeration. */
  26   CT_HASSIZE = CT_ENUM,  /* Last type where ct->size holds the actual size. */
  27   CT_FUNC,              /* Function. */
  28   CT_TYPEDEF,           /* Typedef. */
  29   CT_ATTRIB,            /* Miscellaneous attributes. */
  30   /* Internal element types. */
  31   CT_FIELD,             /* Struct/union field or function parameter. */
  32   CT_BITFIELD,          /* Struct/union bitfield. */
  33   CT_CONSTVAL,          /* Constant value. */
  34   CT_EXTERN,            /* External reference. */
  35   CT_KW                 /* Keyword. */
  36 };
  37
  38 LJ_STATIC_ASSERT(((int)CT_PTR & (int)CT_ARRAY) == CT_PTR);
  39 LJ_STATIC_ASSERT(((int)CT_STRUCT & (int)CT_ARRAY) == CT_STRUCT);
  40
  41 /*
  42 **  ---------- info ------------
  43 ** |type      flags...  A   cid | size   |  sib  | next  | name  |
  44 ** +----------------------------+--------+-------+-------+-------+--
  45 ** |NUM       BFvcUL..  A       | size   |       | type  |       |
  46 ** |STRUCT    ..vcU..V  A       | size   | field | name? | name? |
  47 ** |PTR       ..vcR...  A   cid | size   |       | type  |       |
  48 ** |ARRAY     VCvc...V  A   cid | size   |       | type  |       |
  49 ** |VOID      ..vc....  A       | size   |       | type  |       |
  50 ** |ENUM                A   cid | size   | const | name? | name? |
  51 ** |FUNC      ....VS.. cc   cid | nargs  | field | name? | name? |
  52 ** |TYPEDEF                 cid |        |       | name  | name  |
  53 ** |ATTRIB        attrnum   cid | attr   | sib?  | type? |       |
  54 ** |FIELD                   cid | offset | field |       | name? |
  55 ** |BITFIELD  B.vcU csz bsz pos | offset | field |       | name? |
  56 ** |CONSTVAL     c          cid | value  | const | name  | name  |
  57 ** |EXTERN                  cid |        | sib?  | name  | name  |
  58 ** |KW                      tok | size   |       | name  | name  |
  59 ** +----------------------------+--------+-------+-------+-------+--
  60 **        ^^  ^^--- bits used for C type conversion dispatch
  61 */
  62
  63 /* C type info flags.     TFFArrrr  */
  64 #define CTF_BOOL        0x08000000u     /* Boolean: NUM, BITFIELD. */
  65 #define CTF_FP          0x04000000u     /* Floating-point: NUM. */
  66 #define CTF_CONST       0x02000000u     /* Const qualifier. */
  67 #define CTF_VOLATILE    0x01000000u     /* Volatile qualifier. */
  68 #define CTF_UNSIGNED    0x00800000u     /* Unsigned: NUM, BITFIELD. */
  69 #define CTF_LONG        0x00400000u     /* Long: NUM. */
  70 #define CTF_VLA         0x00100000u     /* Variable-length: ARRAY, STRUCT. */
  71 #define CTF_REF         0x00800000u     /* Reference: PTR. */
  72 #define CTF_VECTOR      0x08000000u     /* Vector: ARRAY. */
  73 #define CTF_COMPLEX     0x04000000u     /* Complex: ARRAY. */
  74 #define CTF_UNION       0x00800000u     /* Union: STRUCT. */
  75 #define CTF_VARARG      0x00800000u     /* Vararg: FUNC. */
  76 #define CTF_SSEREGPARM  0x00400000u     /* SSE register parameters: FUNC. */
  77
  78 #define CTF_QUAL        (CTF_CONST|CTF_VOLATILE)
  79 #define CTF_ALIGN       (CTMASK_ALIGN<<CTSHIFT_ALIGN)
  80 #define CTF_UCHAR       ((char)-1 > 0 ? CTF_UNSIGNED : 0)
  81
  82 /* Flags used in parser.  .F.Ammvf   cp->attr  */
  83 #define CTFP_ALIGNED    0x00000001u     /* cp->attr + ALIGN */
  84 #define CTFP_PACKED     0x00000002u     /* cp->attr */
  85 /*                        ...C...f   cp->fattr */
  86 #define CTFP_CCONV      0x00000001u     /* cp->fattr + CCONV/[SSE]REGPARM */
  87
  88 /* C type info bitfields. */
  89 #define CTMASK_CID      0x0000ffffu     /* Max. 65536 type IDs. */
  90 #define CTMASK_NUM      0xf0000000u     /* Max. 16 type numbers. */
  91 #define CTSHIFT_NUM     28
  92 #define CTMASK_ALIGN    15              /* Max. alignment is 2^15. */
  93 #define CTSHIFT_ALIGN   16
  94 #define CTMASK_ATTRIB   255             /* Max. 256 attributes. */
  95 #define CTSHIFT_ATTRIB  16
  96 #define CTMASK_CCONV    3               /* Max. 4 calling conventions. */
  97 #define CTSHIFT_CCONV   16
  98 #define CTMASK_REGPARM  3               /* Max. 0-3 regparms. */
  99 #define CTSHIFT_REGPARM 18
 100 /* Bitfields only used in parser. */
 101 #define CTMASK_VSIZEP   15              /* Max. vector size is 2^15. */
 102 #define CTSHIFT_VSIZEP  4
 103 #define CTMASK_MSIZEP   255             /* Max. type size (via mode) is 128. */
 104 #define CTSHIFT_MSIZEP  8
 105
 106 /* Info bits for BITFIELD. Max. size of bitfield is 64 bits. */
 107 #define CTBSZ_MAX       32              /* Max. size of bitfield is 32 bit. */
 108 #define CTBSZ_FIELD     127             /* Temp. marker for regular field. */
 109 #define CTMASK_BITPOS   127
 110 #define CTMASK_BITBSZ   127
 111 #define CTMASK_BITCSZ   127
 112 #define CTSHIFT_BITPOS  0
 113 #define CTSHIFT_BITBSZ  8
 114 #define CTSHIFT_BITCSZ  16
 115
 116 #define CTF_INSERT(info, field, val) \
 117   info = (info & ~(CTMASK_##field<<CTSHIFT_##field)) | \
 118           (((CTSize)(val) & CTMASK_##field) << CTSHIFT_##field)
 119
 120 /* Calling conventions. ORDER CC */
 121 enum { CTCC_CDECL, CTCC_THISCALL, CTCC_FASTCALL, CTCC_STDCALL };
 122
 123 /* Attribute numbers. */
 124 enum {
 125   CTA_NONE,             /* Ignored attribute. Must be zero. */
 126   CTA_QUAL,             /* Unmerged qualifiers. */
 127   CTA_ALIGN,            /* Alignment override. */
 128   CTA_SUBTYPE,          /* Transparent sub-type. */
 129   CTA_REDIR,            /* Redirected symbol name. */
 130   CTA_BAD,              /* To catch bad IDs. */
 131   CTA__MAX
 132 };
 133
 134 /* Special sizes. */
 135 #define CTSIZE_INVALID  0xffffffffu
 136
 137 typedef uint32_t CTInfo;        /* Type info. */
 138 typedef uint32_t CTSize;        /* Type size. */
 139 typedef uint32_t CTypeID;       /* Type ID. */
 140 typedef uint16_t CTypeID1;      /* Minimum-sized type ID. */
 141
 142 /* C type table element. */
 143 typedef struct CType {
 144   CTInfo info;          /* Type info. */
 145   CTSize size;          /* Type size or other info. */
 146   CTypeID1 sib;         /* Sibling element. */
 147   CTypeID1 next;        /* Next element in hash chain. */
 148   GCRef name;           /* Element name (GCstr). */
 149 } CType;
 150
 151 #define CTHASH_SIZE     128     /* Number of hash anchors. */
 152 #define CTHASH_MASK     (CTHASH_SIZE-1)
 153
 154 /* Simplify target-specific configuration. Checked in lj_ccall.h. */
 155 #define CCALL_MAX_GPR           8
 156 #define CCALL_MAX_FPR           8
 157
 158 typedef LJ_ALIGN(8) union FPRCBArg { double d; float f[2]; } FPRCBArg;
 159
 160 /* C callback state. Defined here, to avoid dragging in lj_ccall.h. */
 161
 162 typedef LJ_ALIGN(8) struct CCallback {
 163   FPRCBArg fpr[CCALL_MAX_FPR];  /* Arguments/results in FPRs. */
 164   intptr_t gpr[CCALL_MAX_GPR];  /* Arguments/results in GPRs. */
 165   intptr_t *stack;              /* Pointer to arguments on stack. */
 166   void *mcode;                  /* Machine code for callback func. pointers. */
 167   CTypeID1 *cbid;               /* Callback type table. */
 168   MSize sizeid;                 /* Size of callback type table. */
 169   MSize topid;                  /* Highest unused callback type table slot. */
 170   MSize slot;                   /* Current callback slot. */
 171 } CCallback;
 172
 173 /* C type state. */
 174 typedef struct CTState {
 175   CType *tab;           /* C type table. */
 176   CTypeID top;          /* Current top of C type table. */
 177   MSize sizetab;        /* Size of C type table. */
 178   lua_State *L;         /* Lua state (needed for errors and allocations). */
 179   global_State *g;      /* Global state. */
 180   GCtab *finalizer;     /* Map of cdata to finalizer. */
 181   GCtab *miscmap;       /* Map of -CTypeID to metatable and cb slot to func. */
 182   CCallback cb;         /* Temporary callback state. */
 183   CTypeID1 hash[CTHASH_SIZE];  /* Hash anchors for C type table. */
 184 } CTState;
 185
 186 #define CTINFO(ct, flags)       (((CTInfo)(ct) << CTSHIFT_NUM) + (flags))
 187 #define CTALIGN(al)             ((CTSize)(al) << CTSHIFT_ALIGN)
 188 #define CTATTRIB(at)            ((CTInfo)(at) << CTSHIFT_ATTRIB)
 189
 190 #define ctype_type(info)        ((info) >> CTSHIFT_NUM)
 191 #define ctype_cid(info)         ((CTypeID)((info) & CTMASK_CID))
 192 #define ctype_align(info)       (((info) >> CTSHIFT_ALIGN) & CTMASK_ALIGN)
 193 #define ctype_attrib(info)      (((info) >> CTSHIFT_ATTRIB) & CTMASK_ATTRIB)
 194 #define ctype_bitpos(info)      (((info) >> CTSHIFT_BITPOS) & CTMASK_BITPOS)
 195 #define ctype_bitbsz(info)      (((info) >> CTSHIFT_BITBSZ) & CTMASK_BITBSZ)
 196 #define ctype_bitcsz(info)      (((info) >> CTSHIFT_BITCSZ) & CTMASK_BITCSZ)
 197 #define ctype_vsizeP(info)      (((info) >> CTSHIFT_VSIZEP) & CTMASK_VSIZEP)
 198 #define ctype_msizeP(info)      (((info) >> CTSHIFT_MSIZEP) & CTMASK_MSIZEP)
 199 #define ctype_cconv(info)       (((info) >> CTSHIFT_CCONV) & CTMASK_CCONV)
 200
 201 /* Simple type checks. */
 202 #define ctype_isnum(info)       (ctype_type((info)) == CT_NUM)
 203 #define ctype_isvoid(info)      (ctype_type((info)) == CT_VOID)
 204 #define ctype_isptr(info)       (ctype_type((info)) == CT_PTR)
 205 #define ctype_isarray(info)     (ctype_type((info)) == CT_ARRAY)
 206 #define ctype_isstruct(info)    (ctype_type((info)) == CT_STRUCT)
 207 #define ctype_isfunc(info)      (ctype_type((info)) == CT_FUNC)
 208 #define ctype_isenum(info)      (ctype_type((info)) == CT_ENUM)
 209 #define ctype_istypedef(info)   (ctype_type((info)) == CT_TYPEDEF)
 210 #define ctype_isattrib(info)    (ctype_type((info)) == CT_ATTRIB)
 211 #define ctype_isfield(info)     (ctype_type((info)) == CT_FIELD)
 212 #define ctype_isbitfield(info)  (ctype_type((info)) == CT_BITFIELD)
 213 #define ctype_isconstval(info)  (ctype_type((info)) == CT_CONSTVAL)
 214 #define ctype_isextern(info)    (ctype_type((info)) == CT_EXTERN)
 215 #define ctype_hassize(info)     (ctype_type((info)) <= CT_HASSIZE)
 216
 217 /* Combined type and flag checks. */
 218 #define ctype_isinteger(info) \
 219   (((info) & (CTMASK_NUM|CTF_BOOL|CTF_FP)) == CTINFO(CT_NUM, 0))
 220 #define ctype_isinteger_or_bool(info) \
 221   (((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, 0))
 222 #define ctype_isbool(info) \
 223   (((info) & (CTMASK_NUM|CTF_BOOL)) == CTINFO(CT_NUM, CTF_BOOL))
 224 #define ctype_isfp(info) \
 225   (((info) & (CTMASK_NUM|CTF_FP)) == CTINFO(CT_NUM, CTF_FP))
 226
 227 #define ctype_ispointer(info) \
 228   ((ctype_type(info) >> 1) == (CT_PTR >> 1))  /* Pointer or array. */
 229 #define ctype_isref(info) \
 230   (((info) & (CTMASK_NUM|CTF_REF)) == CTINFO(CT_PTR, CTF_REF))
 231
 232 #define ctype_isrefarray(info) \
 233   (((info) & (CTMASK_NUM|CTF_VECTOR|CTF_COMPLEX)) == CTINFO(CT_ARRAY, 0))
 234 #define ctype_isvector(info) \
 235   (((info) & (CTMASK_NUM|CTF_VECTOR)) == CTINFO(CT_ARRAY, CTF_VECTOR))
 236 #define ctype_iscomplex(info) \
 237   (((info) & (CTMASK_NUM|CTF_COMPLEX)) == CTINFO(CT_ARRAY, CTF_COMPLEX))
 238
 239 #define ctype_isvltype(info) \
 240   (((info) & ((CTMASK_NUM|CTF_VLA) - (2u<<CTSHIFT_NUM))) == \
 241    CTINFO(CT_STRUCT, CTF_VLA))  /* VL array or VL struct. */
 242 #define ctype_isvlarray(info) \
 243   (((info) & (CTMASK_NUM|CTF_VLA)) == CTINFO(CT_ARRAY, CTF_VLA))
 244
 245 #define ctype_isxattrib(info, at) \
 246   (((info) & (CTMASK_NUM|CTATTRIB(CTMASK_ATTRIB))) == \
 247    CTINFO(CT_ATTRIB, CTATTRIB(at)))
 248
 249 /* Target-dependent sizes and alignments. */
 250 #if LJ_64
 251 #define CTSIZE_PTR      8
 252 #define CTALIGN_PTR     CTALIGN(3)
 253 #else
 254 #define CTSIZE_PTR      4
 255 #define CTALIGN_PTR     CTALIGN(2)
 256 #endif
 257
 258 #define CTINFO_REF(ref) \
 259   CTINFO(CT_PTR, (CTF_CONST|CTF_REF|CTALIGN_PTR) + (ref))
 260
 261 #define CT_MEMALIGN     3       /* Alignment guaranteed by memory allocator. */
 262
 263 /* -- Predefined types ---------------------------------------------------- */
 264
 265 /* Target-dependent types. */
 266 #if LJ_TARGET_PPC
 267 #define CTTYDEFP(_) \
 268   _(LINT32,             4,      CT_NUM, CTF_LONG|CTALIGN(2))
 269 #else
 270 #define CTTYDEFP(_)
 271 #endif
 272
 273 /* Common types. */
 274 #define CTTYDEF(_) \
 275   _(NONE,               0,      CT_ATTRIB, CTATTRIB(CTA_BAD)) \
 276   _(VOID,               -1,     CT_VOID, CTALIGN(0)) \
 277   _(CVOID,              -1,     CT_VOID, CTF_CONST|CTALIGN(0)) \
 278   _(BOOL,               1,      CT_NUM, CTF_BOOL|CTF_UNSIGNED|CTALIGN(0)) \
 279   _(CCHAR,              1,      CT_NUM, CTF_CONST|CTF_UCHAR|CTALIGN(0)) \
 280   _(INT8,               1,      CT_NUM, CTALIGN(0)) \
 281   _(UINT8,              1,      CT_NUM, CTF_UNSIGNED|CTALIGN(0)) \
 282   _(INT16,              2,      CT_NUM, CTALIGN(1)) \
 283   _(UINT16,             2,      CT_NUM, CTF_UNSIGNED|CTALIGN(1)) \
 284   _(INT32,              4,      CT_NUM, CTALIGN(2)) \
 285   _(UINT32,             4,      CT_NUM, CTF_UNSIGNED|CTALIGN(2)) \
 286   _(INT64,              8,      CT_NUM, CTF_LONG|CTALIGN(3)) \
 287   _(UINT64,             8,      CT_NUM, CTF_UNSIGNED|CTF_LONG|CTALIGN(3)) \
 288   _(FLOAT,              4,      CT_NUM, CTF_FP|CTALIGN(2)) \
 289   _(DOUBLE,             8,      CT_NUM, CTF_FP|CTALIGN(3)) \
 290   _(COMPLEX_FLOAT,      8,      CT_ARRAY, CTF_COMPLEX|CTALIGN(2)|CTID_FLOAT) \
 291   _(COMPLEX_DOUBLE,     16,     CT_ARRAY, CTF_COMPLEX|CTALIGN(3)|CTID_DOUBLE) \
 292   _(P_VOID,     CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_VOID) \
 293   _(P_CVOID,    CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_CVOID) \
 294   _(P_CCHAR,    CTSIZE_PTR,     CT_PTR, CTALIGN_PTR|CTID_CCHAR) \
 295   _(A_CCHAR,            -1,     CT_ARRAY, CTF_CONST|CTALIGN(0)|CTID_CCHAR) \
 296   _(CTYPEID,            4,      CT_ENUM, CTALIGN(2)|CTID_INT32) \
 297   CTTYDEFP(_) \
 298   /* End of type list. */
 299
 300 /* Public predefined type IDs. */
 301 enum {
 302 #define CTTYIDDEF(id, sz, ct, info)     CTID_##id,
 303 CTTYDEF(CTTYIDDEF)
 304 #undef CTTYIDDEF
 305   /* Predefined typedefs and keywords follow. */
 306   CTID_MAX = 65536
 307 };
 308
 309 /* Target-dependent type IDs. */
 310 #if LJ_64
 311 #define CTID_INT_PSZ    CTID_INT64
 312 #define CTID_UINT_PSZ   CTID_UINT64
 313 #else
 314 #define CTID_INT_PSZ    CTID_INT32
 315 #define CTID_UINT_PSZ   CTID_UINT32
 316 #endif
 317
 318 #if LJ_ABI_WIN
 319 #define CTID_WCHAR      CTID_UINT16
 320 #elif LJ_TARGET_PPC
 321 #define CTID_WCHAR      CTID_LINT32
 322 #else
 323 #define CTID_WCHAR      CTID_INT32
 324 #endif
 325
 326 /* -- C tokens and keywords ----------------------------------------------- */
 327
 328 /* C lexer keywords. */
 329 #define CTOKDEF(_) \
 330   _(IDENT, "<identifier>") _(STRING, "<string>") \
 331   _(INTEGER, "<integer>") _(EOF, "<eof>") \
 332   _(OROR, "||") _(ANDAND, "&&") _(EQ, "==") _(NE, "!=") \
 333   _(LE, "<=") _(GE, ">=") _(SHL, "<<") _(SHR, ">>") _(DEREF, "->")
 334
 335 /* Simple declaration specifiers. */
 336 #define CDSDEF(_) \
 337   _(VOID) _(BOOL) _(CHAR) _(INT) _(FP) \
 338   _(LONG) _(LONGLONG) _(SHORT) _(COMPLEX) _(SIGNED) _(UNSIGNED) \
 339   _(CONST) _(VOLATILE) _(RESTRICT) _(INLINE) \
 340   _(TYPEDEF) _(EXTERN) _(STATIC) _(AUTO) _(REGISTER)
 341
 342 /* C keywords. */
 343 #define CKWDEF(_) \
 344   CDSDEF(_) _(EXTENSION) _(ASM) _(ATTRIBUTE) \
 345   _(DECLSPEC) _(CCDECL) _(PTRSZ) \
 346   _(STRUCT) _(UNION) _(ENUM) \
 347   _(SIZEOF) _(ALIGNOF)
 348
 349 /* C token numbers. */
 350 enum {
 351   CTOK_OFS = 255,
 352 #define CTOKNUM(name, sym)      CTOK_##name,
 353 #define CKWNUM(name)            CTOK_##name,
 354 CTOKDEF(CTOKNUM)
 355 CKWDEF(CKWNUM)
 356 #undef CTOKNUM
 357 #undef CKWNUM
 358   CTOK_FIRSTDECL = CTOK_VOID,
 359   CTOK_FIRSTSCL = CTOK_TYPEDEF,
 360   CTOK_LASTDECLFLAG = CTOK_REGISTER,
 361   CTOK_LASTDECL = CTOK_ENUM
 362 };
 363
 364 /* Declaration specifier flags. */
 365 enum {
 366 #define CDSFLAG(name)   CDF_##name = (1u << (CTOK_##name - CTOK_FIRSTDECL)),
 367 CDSDEF(CDSFLAG)
 368 #undef CDSFLAG
 369   CDF__END
 370 };
 371
 372 #define CDF_SCL  (CDF_TYPEDEF|CDF_EXTERN|CDF_STATIC|CDF_AUTO|CDF_REGISTER)
 373
 374 /* -- C type management --------------------------------------------------- */
 375
 376 #define ctype_ctsG(g)           (mref((g)->ctype_state, CTState))
 377
 378 /* Get C type state. */
 379 static LJ_AINLINE CTState *ctype_cts(lua_State *L)
 380 {
 381   CTState *cts = ctype_ctsG(G(L));
 382   cts->L = L;  /* Save L for errors and allocations. */
 383   return cts;
 384 }
 385
 386 /* Save and restore state of C type table. */
 387 #define LJ_CTYPE_SAVE(cts)      CTState savects_ = *(cts)
 388 #define LJ_CTYPE_RESTORE(cts) \
 389   ((cts)->top = savects_.top, \
 390    memcpy((cts)->hash, savects_.hash, sizeof(savects_.hash)))
 391
 392 /* Check C type ID for validity when assertions are enabled. */
 393 static LJ_AINLINE CTypeID ctype_check(CTState *cts, CTypeID id)
 394 {
 395   lua_assert(id > 0 && id < cts->top); UNUSED(cts);
 396   return id;
 397 }
 398
 399 /* Get C type for C type ID. */
 400 static LJ_AINLINE CType *ctype_get(CTState *cts, CTypeID id)
 401 {
 402   return &cts->tab[ctype_check(cts, id)];
 403 }
 404
 405 /* Get C type ID for a C type. */
 406 #define ctype_typeid(cts, ct)   ((CTypeID)((ct) - (cts)->tab))
 407
 408 /* Get child C type. */
 409 static LJ_AINLINE CType *ctype_child(CTState *cts, CType *ct)
 410 {
 411   lua_assert(!(ctype_isvoid(ct->info) || ctype_isstruct(ct->info) ||
 412              ctype_isbitfield(ct->info)));  /* These don't have children. */
 413   return ctype_get(cts, ctype_cid(ct->info));
 414 }
 415
 416 /* Get raw type for a C type ID. */
 417 static LJ_AINLINE CType *ctype_raw(CTState *cts, CTypeID id)
 418 {
 419   CType *ct = ctype_get(cts, id);
 420   while (ctype_isattrib(ct->info)) ct = ctype_child(cts, ct);
 421   return ct;
 422 }
 423
 424 /* Get raw type of the child of a C type. */
 425 static LJ_AINLINE CType *ctype_rawchild(CTState *cts, CType *ct)
 426 {
 427   do { ct = ctype_child(cts, ct); } while (ctype_isattrib(ct->info));
 428   return ct;
 429 }
 430
 431 /* Set the name of a C type table element. */
 432 static LJ_AINLINE void ctype_setname(CType *ct, GCstr *s)
 433 {
 434   /* NOBARRIER: mark string as fixed -- the C type table is never collected. */
 435   fixstring(s);
 436   setgcref(ct->name, obj2gco(s));
 437 }
 438
 439 LJ_FUNC CTypeID lj_ctype_new(CTState *cts, CType **ctp);
 440 LJ_FUNC CTypeID lj_ctype_intern(CTState *cts, CTInfo info, CTSize size);
 441 LJ_FUNC void lj_ctype_addname(CTState *cts, CType *ct, CTypeID id);
 442 LJ_FUNC CTypeID lj_ctype_getname(CTState *cts, CType **ctp, GCstr *name,
 443                                  uint32_t tmask);
 444 LJ_FUNC CType *lj_ctype_getfieldq(CTState *cts, CType *ct, GCstr *name,
 445                                   CTSize *ofs, CTInfo *qual);
 446 #define lj_ctype_getfield(cts, ct, name, ofs) \
 447   lj_ctype_getfieldq((cts), (ct), (name), (ofs), NULL)
 448 LJ_FUNC CType *lj_ctype_rawref(CTState *cts, CTypeID id);
 449 LJ_FUNC CTSize lj_ctype_size(CTState *cts, CTypeID id);
 450 LJ_FUNC CTSize lj_ctype_vlsize(CTState *cts, CType *ct, CTSize nelem);
 451 LJ_FUNC CTInfo lj_ctype_info(CTState *cts, CTypeID id, CTSize *szp);
 452 LJ_FUNC cTValue *lj_ctype_meta(CTState *cts, CTypeID id, MMS mm);
 453 LJ_FUNC GCstr *lj_ctype_repr(lua_State *L, CTypeID id, GCstr *name);
 454 LJ_FUNC GCstr *lj_ctype_repr_int64(lua_State *L, uint64_t n, int isunsigned);
 455 LJ_FUNC GCstr *lj_ctype_repr_complex(lua_State *L, void *sp, CTSize size);
 456 LJ_FUNC CTState *lj_ctype_init(lua_State *L);
 457 LJ_FUNC void lj_ctype_freestate(global_State *g);
 458
 459 #endif
 460
 461 #endif