kit

type.h (6793B)

---

 #ifndef KIT_TYPE_H
 #define KIT_TYPE_H
 
 #include <kit/cg.h>
 
 #include "c_support.h"
 
 typedef enum TypeKind {
   TY_VOID,
   TY_BOOL,
   TY_CHAR,
   TY_SCHAR,
   TY_UCHAR,
   TY_SHORT,
   TY_USHORT,
   TY_INT,
   TY_UINT,
   TY_LONG,
   TY_ULONG,
   TY_LLONG,
   TY_ULLONG,
   TY_INT128,
   TY_UINT128,
   TY_FLOAT,
   TY_DOUBLE,
   TY_LDOUBLE,
   TY_PTR,
   TY_ARRAY,
   TY_FUNC,
   TY_STRUCT,
   TY_UNION,
   TY_ENUM,
 } TypeKind;
 
 /* C tag identity is scoped declaration identity, not the spelling. `Sym tag`
  * remains the diagnostic/debug name; TagId prevents two scoped `struct S`
  * declarations from collapsing under global Type interning. */
 typedef u32 TagId;
 #define TAG_NONE 0u
 
 typedef enum TagDeclKind {
   TAG_STRUCT,
   TAG_UNION,
   TAG_ENUM,
 } TagDeclKind;
 
 typedef struct TagDecl {
   TagId id;
   Sym spelling;
   SrcLoc loc;
   u8 kind; /* TagDeclKind */
   u8 complete;
   u16 pad;
 } TagDecl;
 
 typedef enum TypeQual {
   Q_CONST = 1u << 0,
   Q_VOLATILE = 1u << 1,
   Q_RESTRICT = 1u << 2,
   Q_ATOMIC = 1u << 3,
 } TypeQual;
 
 typedef struct Type Type;
 
 /* Defined in abi/c_abi.h (which includes this header), forward-declared here so
  * Type can cache a computed record layout pointer without a header cycle. */
 struct ABIRecordLayout;
 
 typedef enum FieldFlag {
   FIELD_NONE = 0,
   FIELD_BITFIELD = 1u << 0,
   FIELD_ZERO_WIDTH = 1u << 1,
   FIELD_ANON = 1u << 2,
   FIELD_FLEXIBLE_ARRAY = 1u << 3,
 } FieldFlag;
 
 typedef struct Field {
   Sym name;
   const Type* type;
   u16 bitfield_width; /* valid when FIELD_BITFIELD is set; may be 0 */
   u16 flags;          /* FieldFlag */
   /* Phase 2 attribute carriers — populated by the parser when the member
    * carries __attribute__((aligned(N))) / ((packed)). Zero means "no
    * override"; c_abi_record_layout interprets them. */
   u16 align_override;
   u16 max_align;
   u8 packed;
 } Field;
 
 /* One enumerator (name = value), collected by parse_enum and carried on the
  * enum Type so CG/debug lowering can emit DW_TAG_enumerator children. */
 typedef struct EnumConst {
   Sym name;
   i64 value;
 } EnumConst;
 
 struct Type {
   u16 kind;
   u16 qual;
   /* Memoized VALUE-mode CG lowering of this canonical node (0 = not yet
    * lowered). Sits in the alignment hole before the 8-aligned union, so the
    * node stays the same size. NOT part of type identity: the structural intern
    * set compares named fields and type_tagged_eq compares the rec/enm payload,
    * so this mutable cache never participates in interning. See type_cg_lower.
    */
   KitCgTypeId cg_id;
   /* Memoized record layout for TY_STRUCT/TY_UNION (NULL = not yet built). Like
    * the lowering caches this is mutable state, NOT part of type identity — the
    * interning comparisons never read it. Only c_abi_record_layout writes it,
    * and only for a complete record, whose layout is immutable + arena-lived for
    * the pool's lifetime, so sharing the pointer across qualified variants is
    * safe. */
   const struct ABIRecordLayout* abi_layout;
   union {
     struct {
       const Type* pointee;
     } ptr;
     struct {
       const Type* elem;
       u32 count;
       u8 incomplete;
     } arr;
     struct {
       const Type* ret;
       const Type** params;
       u16 nparams;
       u8 variadic;
     } fn;
     struct {
       TagId tag_id;
       Sym tag;
       const Field* fields;
       u16 nfields;
       u8 incomplete;
       /* Phase 2 attribute carriers — record-level
        * __attribute__((packed)) / ((aligned(N))). Both zero means
        * "natural layout". c_abi_record_layout honors them. */
       u8 packed;
       u16 max_align;
       u16 align_override;
     } rec; /* struct / union */
     struct {
       TagId tag_id;
       Sym tag;
       const Type* base;
       const EnumConst* consts; /* enumerators, NULL until the body is parsed */
       u16 nconsts;
     } enm;
   };
 };
 
 const Type* type_void(Pool*);
 const Type* type_prim(Pool*, TypeKind);
 const Type* type_ptr(Pool*, const Type*);
 const Type* type_array(Pool*, const Type* elem, u32 count, int incomplete);
 const Type* type_func(Pool*, const Type* ret, const Type** params, u16 n,
                       int variadic);
 const Type* type_qualified(Pool*, const Type*, u16 qual);
 
 /* Aggregate construction is mutable only through TypeRecordBuilder. The
  * committed Type is immutable and interned; field offsets, record
  * size/alignment, and bitfield storage are target ABI facts. */
 typedef struct TypeRecordBuilder TypeRecordBuilder;
 TagId type_tag_new(Pool*, TagDeclKind, Sym spelling, SrcLoc);
 TypeRecordBuilder* type_record_begin(Pool*, TypeKind kind, TagId,
                                      Sym tag); /* TY_STRUCT or TY_UNION */
 
 /* Phase 2 record options carried from __attribute__((packed))/aligned(N)).
  * Zero-initialized = natural layout. Fields kept as a struct so future
  * options (e.g. transparent_union) don't churn the call sites. */
 typedef struct TypeRecordOpts {
   u8 packed;
   u16 max_align;
   u16 align_override;
 } TypeRecordOpts;
 
 /* Variant of type_record_begin that records record-level attribute
  * options on the builder; type_record_end copies them to Type.rec. The
  * plain type_record_begin is equivalent to passing a zeroed
  * TypeRecordOpts. */
 TypeRecordBuilder* type_record_begin_ex(Pool*, TypeKind kind, TagId, Sym tag,
                                         TypeRecordOpts);
 void type_record_field(TypeRecordBuilder*, Field);
 const Type* type_record_end(Pool*, TypeRecordBuilder*);
 /* Forward-declared struct/union: returns a mutable, incomplete Type with the
  * given tag identity but no fields. Pointers to it are valid; sizeof/member
  * access are not until type_record_install is called. The same Type* identity
  * survives completion, so any TY_PTR(forward) pointer types remain valid. */
 Type* type_record_forward(Pool*, TypeKind kind, TagId, Sym tag);
 void type_record_install(Type* forward, const Field* fields, u16 nfields);
 const Type* type_enum(Pool*, TagId, Sym tag, const Type* base);
 
 const Type* type_unqual(Pool*, const Type*);
 const Type* type_promoted(Pool*, const Type*);
 int type_compatible(const Type*, const Type*);
 const Type* type_composite(Pool*, const Type*, const Type*);
 int type_is_arith(const Type*);
 int type_is_int(const Type*);
 int type_is_ptr(const Type*);
 int type_is_signed_integer(const Type*);
 
 /* Per-TypeKind scalar facts, backed by a single property table in type.c.
  * These take a bare TypeKind so callers that already have one (and the
  * Type* wrappers above) share the same source of truth. */
 int type_kind_is_int(TypeKind);
 int type_kind_is_fp(TypeKind);
 int type_kind_is_signed_integer(TypeKind);
 u32 type_kind_int_rank(TypeKind);
 TypeKind type_kind_unsigned_variant(TypeKind);
 
 KitCgTypeId type_cg_id_in_pool(KitCompiler*, Pool*, const Type*);
 KitCgDebugType type_cg_debug_in_pool(KitCg*, KitCompiler*, Pool*, const Type*);
 
 #endif