/** The default calling convention. */
cc_kind_t default_calling_convention = CC_CDECL;
-static struct obstack _type_obst;
-struct obstack *type_obst = &_type_obst;
-static bool print_implicit_array_size = false;
+static struct obstack type_obst;
+static bool print_implicit_array_size = false;
static void intern_print_type_pre(const type_t *type);
static void intern_print_type_post(const type_t *type);
[TYPE_ENUM] = sizeof(enum_type_t),
[TYPE_FUNCTION] = sizeof(function_type_t),
[TYPE_POINTER] = sizeof(pointer_type_t),
+ [TYPE_REFERENCE] = sizeof(reference_type_t),
[TYPE_ARRAY] = sizeof(array_type_t),
[TYPE_TYPEDEF] = sizeof(typedef_type_t),
[TYPE_TYPEOF] = sizeof(typeof_type_t),
type_t *allocate_type_zero(type_kind_t kind)
{
- size_t size = get_type_struct_size(kind);
- type_t *res = obstack_alloc(type_obst, size);
+ size_t const size = get_type_struct_size(kind);
+ type_t *const res = obstack_alloc(&type_obst, size);
memset(res, 0, size);
res->base.kind = kind;
void init_types(void)
{
- obstack_init(type_obst);
+ obstack_init(&type_obst);
atomic_type_properties_t *props = atomic_type_properties;
void exit_types(void)
{
- obstack_free(type_obst, NULL);
+ obstack_free(&type_obst, NULL);
}
void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparators const q)
/* skip the implicit cast */
expression_t *expression = entry->enum_value.value;
- if (expression->kind == EXPR_UNARY_CAST_IMPLICIT) {
- expression = expression->unary.value;
- }
print_expression(expression);
}
print_string(",\n");
{
size_t size = get_type_struct_size(type->kind);
- type_t *copy = obstack_alloc(type_obst, size);
+ type_t *const copy = obstack_alloc(&type_obst, size);
memcpy(copy, type, size);
copy->base.firm_type = NULL;
{
type_t *result = typehash_insert(type);
if (result != type) {
- obstack_free(type_obst, type);
+ obstack_free(&type_obst, type);
}
return result;
}
*/
type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(atomic_type_t));
- memset(type, 0, sizeof(atomic_type_t));
-
- type->kind = TYPE_ATOMIC;
+ type_t *const type = allocate_type_zero(TYPE_ATOMIC);
type->base.qualifiers = qualifiers;
type->atomic.akind = akind;
*/
type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(complex_type_t));
- memset(type, 0, sizeof(complex_type_t));
-
- type->kind = TYPE_COMPLEX;
+ type_t *const type = allocate_type_zero(TYPE_COMPLEX);
type->base.qualifiers = qualifiers;
type->complex.akind = akind;
*/
type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(imaginary_type_t));
- memset(type, 0, sizeof(imaginary_type_t));
-
- type->kind = TYPE_IMAGINARY;
+ type_t *const type = allocate_type_zero(TYPE_IMAGINARY);
type->base.qualifiers = qualifiers;
type->imaginary.akind = akind;
*/
type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
- memset(type, 0, sizeof(pointer_type_t));
-
- type->kind = TYPE_POINTER;
+ type_t *const type = allocate_type_zero(TYPE_POINTER);
type->base.qualifiers = qualifiers;
type->pointer.points_to = points_to;
type->pointer.base_variable = NULL;
*/
type_t *make_reference_type(type_t *refers_to)
{
- type_t *type = obstack_alloc(type_obst, sizeof(reference_type_t));
- memset(type, 0, sizeof(reference_type_t));
-
- type->kind = TYPE_REFERENCE;
- type->base.qualifiers = 0;
+ type_t *const type = allocate_type_zero(TYPE_REFERENCE);
+ type->base.qualifiers = TYPE_QUALIFIER_NONE;
type->reference.refers_to = refers_to;
return identify_new_type(type);
type_t *make_based_pointer_type(type_t *points_to,
type_qualifiers_t qualifiers, variable_t *variable)
{
- type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
- memset(type, 0, sizeof(pointer_type_t));
-
- type->kind = TYPE_POINTER;
+ type_t *const type = allocate_type_zero(TYPE_POINTER);
type->base.qualifiers = qualifiers;
type->pointer.points_to = points_to;
type->pointer.base_variable = variable;
type_t *make_array_type(type_t *element_type, size_t size,
type_qualifiers_t qualifiers)
{
- type_t *type = obstack_alloc(type_obst, sizeof(array_type_t));
- memset(type, 0, sizeof(array_type_t));
-
- type->kind = TYPE_ARRAY;
+ type_t *const type = allocate_type_zero(TYPE_ARRAY);
type->base.qualifiers = qualifiers;
type->array.element_type = element_type;
type->array.size = size;
compound->alignment = alignment;
}
-static function_parameter_t *allocate_parameter(type_t *const type)
+function_parameter_t *allocate_parameter(type_t *const type)
{
- function_parameter_t *const param
- = obstack_alloc(type_obst, sizeof(*param));
+ function_parameter_t *const param = obstack_alloc(&type_obst, sizeof(*param));
memset(param, 0, sizeof(*param));
param->type = type;
return param;
type->function.modifiers |= modifiers;
type->function.linkage = LINKAGE_C;
- function_parameter_t *last = NULL;
+ function_parameter_t **anchor = &type->function.parameters;
for (int i = 0; i < n_types; ++i) {
function_parameter_t *parameter = allocate_parameter(argument_types[i]);
- if (last == NULL) {
- type->function.parameters = parameter;
- } else {
- last->next = parameter;
- }
- last = parameter;
+ *anchor = parameter;
+ anchor = ¶meter->next;
}
return identify_new_type(type);