Sparse’s Type System

struct symbol is used to represent symbols & types but most parts pertaining to the types are in the field ‘ctype’. For the purpose of this document, things can be simplified into:

struct symbol {
        enum type type; // SYM_...
        struct ctype {
                struct symbol *base_type;
                unsigned long modifiers;
                unsigned long alignment;
                struct context_list *contexts;
                struct indent *as;
Some bits, also related to the type, are in struct symbol itself:
  • type
  • size_bits
  • rank
  • variadic
  • string
  • designated_init
  • forced_arg
  • accessed
  • transparent_union
  • base_type is used for the associated base type.
  • modifiers is a bit mask for type specifiers (MOD_UNSIGNED, …), type qualifiers (MOD_CONST, MOD_VOLATILE), storage classes (MOD_STATIC, MOD_EXTERN, …), as well for various attributes. It’s also used internally to keep track of some states (MOD_ACCESS or MOD_ADDRESSABLE).
  • alignment is used for the alignment, in bytes.
  • contexts is used to store the informations associated with the attribute context().
  • as is used to hold the identifier of the attribute address_space().

Kind of types


Used by integer, floating-point, void, ‘type’, ‘incomplete’ & bad types.

For integer types:
  • .ctype.base_type points to int_ctype, the generic/abstract integer type
  • .ctype.modifiers has MOD_UNSIGNED/SIGNED/EXPLICITLY_SIGNED set accordingly.
For floating-point types:
  • .ctype.base_type points to fp_ctype, the generic/abstract float type
  • .ctype.modifiers is zero.
For the other base types:
  • .ctype.base_type is NULL
  • .ctype.modifiers is zero.


It’s used to make variants of existing types. For example, it’s used as a top node for all declarations which can then have their own modifiers, address_space, contexts or alignment as well as the declaration’s identifier.

  • .ctype.base_type points to the unmodified type (which must not be a SYM_NODE itself)
  • .ctype.modifiers, .as, .alignment, .contexts will contains the ‘variation’ (MOD_CONST, the attributes, …).


For pointers:
  • .ctype.base_type points to the pointee type
  • .ctype.modifiers & .as are about the pointee too!


For functions:
  • .ctype.base_type points to the return type
  • .ctype.modifiers & .as should be about the function itself but some return type’s modifiers creep here (for example, in int foo(void), MOD_SIGNED will be set for the function).


For arrays:
  • .ctype.base_type points to the underlying type
  • .ctype.modifiers & .as are a copy of the parent type (and unused)?
  • for literal strings, the modifier also contains MOD_STATIC
  • sym->array_size is expression for the array size.


For structs:
  • .ctype.base_type is NULL
  • .ctype.modifiers & .as are not used?
  • .ident is the name tag.


Same as for structs.


For enums:
  • .ctype.base_type points to the underlying type (integer)
  • .ctype.modifiers contains the enum signedness
  • .ident is the name tag.


For bitfields:
  • .ctype.base_type points to the underlying type (integer)
  • .ctype.modifiers & .as are a copy of the parent type (and unused)?
  • .bit_size is the size of the bitfield.


Used for bitwise types (aka ‘restricted’ types):
  • .ctype.base_type points to the underlying type (integer)
  • .ctype.modifiers & .as are like for SYM_NODE and the modifiers are inherited from the base type with MOD_SPECIFIER removed
  • .ident is the typedef name (if any).


Used for bitwise types when the negation op (~) is used and the bit_size is smaller than an int. There is a 1-to-1 mapping between a fouled type and its parent bitwise type.

  • .ctype.base_type points to the parent type
  • .ctype.modifiers & .as are the same as for the parent type
  • .bit_size is bits_in_int.


Should not be present after evaluation:
  • .initializer points to the expression representing the type
  • .ctype is not used.

Typeofs with a type as argument are directly evaluated during parsing.


Used for labels only.


Used for parsing only.


Should not be used.


Should not be used.