X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=df0b7593944535f6257e7171ff578f7903631bff;hb=b00408fc909b04714fcbfbc79985c70b5bedeb66;hp=0c736829ad22e58099e3a12c617d00f5bd8281c4;hpb=6a7adde8512cf76b6cc5c67bece168b43c913c26;p=cparser diff --git a/type.c b/type.c index 0c73682..df0b759 100644 --- a/type.c +++ b/type.c @@ -1,6 +1,6 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2008 Matthias Braun + * Copyright (C) 2007-2009 Matthias Braun * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -30,12 +30,15 @@ #include "adt/error.h" #include "adt/util.h" #include "lang_features.h" +#include "warning.h" +#include "diagnostic.h" +#include "printer.h" -static struct obstack _type_obst; -static FILE *out; -struct obstack *type_obst = &_type_obst; -static int type_visited = 0; -static bool print_implicit_array_size = false; +/** The default calling convention. */ +cc_kind_t default_calling_convention = CC_CDECL; + +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); @@ -47,6 +50,44 @@ struct atomic_type_properties_t { unsigned flags; /**< type flags from atomic_type_flag_t */ }; +/** + * Returns the size of a type node. + * + * @param kind the type kind + */ +static size_t get_type_struct_size(type_kind_t kind) +{ + static const size_t sizes[] = { + [TYPE_ATOMIC] = sizeof(atomic_type_t), + [TYPE_COMPLEX] = sizeof(complex_type_t), + [TYPE_IMAGINARY] = sizeof(imaginary_type_t), + [TYPE_BITFIELD] = sizeof(bitfield_type_t), + [TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t), + [TYPE_COMPOUND_UNION] = sizeof(compound_type_t), + [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), + }; + assert(lengthof(sizes) == (int)TYPE_TYPEOF + 1); + assert(kind <= TYPE_TYPEOF); + assert(sizes[kind] != 0); + return sizes[kind]; +} + +type_t *allocate_type_zero(type_kind_t kind) +{ + 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; + + return res; +} + /** * Properties of atomic types. */ @@ -142,7 +183,7 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = { | ATOMIC_TYPE_FLAG_SIGNED, }, [ATOMIC_TYPE_LONG_DOUBLE] = { - .size = 12, + .size = (unsigned) -1, /* will be filled in later */ .alignment = (unsigned) -1, .flags = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC | ATOMIC_TYPE_FLAG_SIGNED, @@ -150,9 +191,14 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = { /* complex and imaginary types are set in init_types */ }; +static inline bool is_po2(unsigned x) +{ + return (x & (x-1)) == 0; +} + void init_types(void) { - obstack_init(type_obst); + obstack_init(&type_obst); atomic_type_properties_t *props = atomic_type_properties; @@ -161,7 +207,8 @@ void init_types(void) } unsigned int_size = machine_size < 32 ? 2 : 4; - unsigned long_size = machine_size < 64 ? 4 : 8; + /* long is always 32bit on windows */ + unsigned long_size = c_mode & _MS ? 4 : (machine_size < 64 ? 4 : 8); unsigned llong_size = machine_size < 32 ? 4 : 8; props[ATOMIC_TYPE_INT].size = int_size; @@ -179,11 +226,28 @@ void init_types(void) /* TODO: backend specific, need a way to query the backend for this. * The following are good settings for x86 */ - props[ATOMIC_TYPE_FLOAT].alignment = 4; - props[ATOMIC_TYPE_DOUBLE].alignment = 4; - props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4; - props[ATOMIC_TYPE_LONGLONG].alignment = 4; - props[ATOMIC_TYPE_ULONGLONG].alignment = 4; + if (machine_size <= 32) { + props[ATOMIC_TYPE_FLOAT].alignment = 4; + props[ATOMIC_TYPE_DOUBLE].alignment = 4; + props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4; + props[ATOMIC_TYPE_LONGLONG].alignment = 4; + props[ATOMIC_TYPE_ULONGLONG].alignment = 4; + } else { + props[ATOMIC_TYPE_FLOAT].alignment = 4; + props[ATOMIC_TYPE_DOUBLE].alignment = 8; + props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 8; + props[ATOMIC_TYPE_LONGLONG].alignment = 8; + props[ATOMIC_TYPE_ULONGLONG].alignment = 8; + } + + if (long_double_size > 0) { + props[ATOMIC_TYPE_LONG_DOUBLE].size = long_double_size; + if (is_po2(long_double_size)) { + props[ATOMIC_TYPE_LONG_DOUBLE].alignment = long_double_size; + } + } else { + props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE]; + } /* TODO: make this configurable for platforms which do not use byte sized * bools. */ @@ -194,34 +258,26 @@ void init_types(void) void exit_types(void) { - obstack_free(type_obst, NULL); + obstack_free(&type_obst, NULL); } -void type_set_output(FILE *stream) +void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparators const q) { - out = stream; -} - -void inc_type_visited(void) -{ - type_visited++; -} - -void print_type_qualifiers(type_qualifiers_t qualifiers) -{ - int first = 1; + size_t sep = q & QUAL_SEP_START ? 0 : 1; if (qualifiers & TYPE_QUALIFIER_CONST) { - fputs(" const" + first, out); - first = 0; + print_string(" const" + sep); + sep = 0; } if (qualifiers & TYPE_QUALIFIER_VOLATILE) { - fputs(" volatile" + first, out); - first = 0; + print_string(" volatile" + sep); + sep = 0; } if (qualifiers & TYPE_QUALIFIER_RESTRICT) { - fputs(" restrict" + first, out); - first = 0; + print_string(" restrict" + sep); + sep = 0; } + if (sep == 0 && q & QUAL_SEP_END) + print_char(' '); } const char *get_atomic_kind_name(atomic_type_kind_t kind) @@ -257,7 +313,7 @@ const char *get_atomic_kind_name(atomic_type_kind_t kind) static void print_atomic_kinds(atomic_type_kind_t kind) { const char *s = get_atomic_kind_name(kind); - fputs(s, out); + print_string(s); } /** @@ -267,9 +323,7 @@ static void print_atomic_kinds(atomic_type_kind_t kind) */ static void print_atomic_type(const atomic_type_t *type) { - print_type_qualifiers(type->base.qualifiers); - if (type->base.qualifiers != 0) - fputc(' ', out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); print_atomic_kinds(type->akind); } @@ -278,12 +332,10 @@ static void print_atomic_type(const atomic_type_t *type) * * @param type The type. */ -static -void print_complex_type(const complex_type_t *type) +static void print_complex_type(const complex_type_t *type) { - int empty = type->base.qualifiers == 0; - print_type_qualifiers(type->base.qualifiers); - fputs(" _Complex " + empty, out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); + print_string("_Complex"); print_atomic_kinds(type->akind); } @@ -292,12 +344,10 @@ void print_complex_type(const complex_type_t *type) * * @param type The type. */ -static -void print_imaginary_type(const imaginary_type_t *type) +static void print_imaginary_type(const imaginary_type_t *type) { - int empty = type->base.qualifiers == 0; - print_type_qualifiers(type->base.qualifiers); - fputs(" _Imaginary " + empty, out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); + print_string("_Imaginary "); print_atomic_kinds(type->akind); } @@ -314,27 +364,33 @@ static void print_function_type_pre(const function_type_t *type) case LINKAGE_C: if (c_mode & _CXX) - fputs("extern \"C\" ", out); + print_string("extern \"C\" "); break; case LINKAGE_CXX: if (!(c_mode & _CXX)) - fputs("extern \"C++\" ", out); + print_string("extern \"C++\" "); break; } - print_type_qualifiers(type->base.qualifiers); - if (type->base.qualifiers != 0) - fputc(' ', out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); intern_print_type_pre(type->return_type); - switch (type->calling_convention) { - case CC_CDECL: fputs("__cdecl ", out); break; - case CC_STDCALL: fputs("__stdcall ", out); break; - case CC_FASTCALL: fputs("__fastcall ", out); break; - case CC_THISCALL: fputs("__thiscall ", out); break; - case CC_DEFAULT: break; + cc_kind_t cc = type->calling_convention; +restart: + switch (cc) { + case CC_CDECL: print_string(" __cdecl"); break; + case CC_STDCALL: print_string(" __stdcall"); break; + case CC_FASTCALL: print_string(" __fastcall"); break; + case CC_THISCALL: print_string(" __thiscall"); break; + case CC_DEFAULT: + if (default_calling_convention != CC_CDECL) { + /* show the default calling convention if its not cdecl */ + cc = default_calling_convention; + goto restart; + } + break; } } @@ -346,7 +402,7 @@ static void print_function_type_pre(const function_type_t *type) static void print_function_type_post(const function_type_t *type, const scope_t *parameters) { - fputc('(', out); + print_string("("); bool first = true; if (parameters == NULL) { function_parameter_t *parameter = type->parameters; @@ -354,7 +410,7 @@ static void print_function_type_post(const function_type_t *type, if (first) { first = false; } else { - fputs(", ", out); + print_string(", "); } print_type(parameter->type); } @@ -367,13 +423,13 @@ static void print_function_type_post(const function_type_t *type, if (first) { first = false; } else { - fputs(", ", out); + print_string(", "); } - const type_t *const type = parameter->declaration.type; - if (type == NULL) { - fputs(parameter->base.symbol->string, out); + const type_t *const param_type = parameter->declaration.type; + if (param_type == NULL) { + print_string(parameter->base.symbol->string); } else { - print_type_ext(type, parameter->base.symbol, NULL); + print_type_ext(param_type, parameter->base.symbol, NULL); } } } @@ -381,14 +437,14 @@ static void print_function_type_post(const function_type_t *type, if (first) { first = false; } else { - fputs(", ", out); + print_string(", "); } - fputs("...", out); + print_string("..."); } if (first && !type->unspecified_parameters) { - fputs("void", out); + print_string("void"); } - fputc(')', out); + print_string(")"); intern_print_type_post(type->return_type); } @@ -403,18 +459,15 @@ static void print_pointer_type_pre(const pointer_type_t *type) type_t const *const points_to = type->points_to; intern_print_type_pre(points_to); if (points_to->kind == TYPE_ARRAY || points_to->kind == TYPE_FUNCTION) - fputs(" (", out); + print_string(" ("); variable_t *const variable = type->base_variable; if (variable != NULL) { - fputs(" __based(", out); - fputs(variable->base.base.symbol->string, out); - fputs(") ", out); + print_string(" __based("); + print_string(variable->base.base.symbol->string); + print_string(") "); } - fputc('*', out); - type_qualifiers_t const qual = type->base.qualifiers; - if (qual != 0) - fputc(' ', out); - print_type_qualifiers(qual); + print_string("*"); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_START); } /** @@ -426,7 +479,7 @@ static void print_pointer_type_post(const pointer_type_t *type) { type_t const *const points_to = type->points_to; if (points_to->kind == TYPE_ARRAY || points_to->kind == TYPE_FUNCTION) - fputc(')', out); + print_string(")"); intern_print_type_post(points_to); } @@ -440,8 +493,8 @@ static void print_reference_type_pre(const reference_type_t *type) type_t const *const refers_to = type->refers_to; intern_print_type_pre(refers_to); if (refers_to->kind == TYPE_ARRAY || refers_to->kind == TYPE_FUNCTION) - fputs(" (", out); - fputc('&', out); + print_string(" ("); + print_string("&"); } /** @@ -453,7 +506,7 @@ static void print_reference_type_post(const reference_type_t *type) { type_t const *const refers_to = type->refers_to; if (refers_to->kind == TYPE_ARRAY || refers_to->kind == TYPE_FUNCTION) - fputc(')', out); + print_string(")"); intern_print_type_post(refers_to); } @@ -474,18 +527,16 @@ static void print_array_type_pre(const array_type_t *type) */ static void print_array_type_post(const array_type_t *type) { - fputc('[', out); + print_string("["); if (type->is_static) { - fputs("static ", out); + print_string("static "); } - print_type_qualifiers(type->base.qualifiers); - if (type->base.qualifiers != 0) - fputc(' ', out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); if (type->size_expression != NULL && (print_implicit_array_size || !type->has_implicit_size)) { print_expression(type->size_expression); } - fputc(']', out); + print_string("]"); intern_print_type_post(type->element_type); } @@ -496,7 +547,7 @@ static void print_array_type_post(const array_type_t *type) */ static void print_bitfield_type_post(const bitfield_type_t *type) { - fputs(" : ", out); + print_string(" : "); print_expression(type->size_expression); intern_print_type_post(type->base_type); } @@ -508,7 +559,7 @@ static void print_bitfield_type_post(const bitfield_type_t *type) */ void print_enum_definition(const enum_t *enume) { - fputs("{\n", out); + print_string("{\n"); change_indent(1); @@ -517,23 +568,20 @@ void print_enum_definition(const enum_t *enume) entry = entry->base.next) { print_indent(); - fputs(entry->base.symbol->string, out); + print_string(entry->base.symbol->string); if (entry->enum_value.value != NULL) { - fputs(" = ", out); + print_string(" = "); /* 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); } - fputs(",\n", out); + print_string(",\n"); } change_indent(-1); print_indent(); - fputc('}', out); + print_string("}"); } /** @@ -543,14 +591,13 @@ void print_enum_definition(const enum_t *enume) */ static void print_type_enum(const enum_type_t *type) { - int empty = type->base.qualifiers == 0; - print_type_qualifiers(type->base.qualifiers); - fputs(" enum " + empty, out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); + print_string("enum "); enum_t *enume = type->enume; symbol_t *symbol = enume->base.symbol; if (symbol != NULL) { - fputs(symbol->string, out); + print_string(symbol->string); } else { print_enum_definition(enume); } @@ -561,7 +608,7 @@ static void print_type_enum(const enum_type_t *type) */ void print_compound_definition(const compound_t *compound) { - fputs("{\n", out); + print_string("{\n"); change_indent(1); entity_t *entity = compound->members.entities; @@ -571,14 +618,14 @@ void print_compound_definition(const compound_t *compound) print_indent(); print_entity(entity); - fputc('\n', out); + print_string("\n"); } change_indent(-1); print_indent(); - fputc('}', out); + print_string("}"); if (compound->modifiers & DM_TRANSPARENT_UNION) { - fputs("__attribute__((__transparent_union__))", out); + print_string("__attribute__((__transparent_union__))"); } } @@ -589,20 +636,19 @@ void print_compound_definition(const compound_t *compound) */ static void print_compound_type(const compound_type_t *type) { - int empty = type->base.qualifiers == 0; - print_type_qualifiers(type->base.qualifiers); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); if (type->base.kind == TYPE_COMPOUND_STRUCT) { - fputs(" struct " + empty, out); + print_string("struct "); } else { assert(type->base.kind == TYPE_COMPOUND_UNION); - fputs(" union " + empty, out); + print_string("union "); } compound_t *compound = type->compound; symbol_t *symbol = compound->base.symbol; if (symbol != NULL) { - fputs(symbol->string, out); + print_string(symbol->string); } else { print_compound_definition(compound); } @@ -615,10 +661,8 @@ static void print_compound_type(const compound_type_t *type) */ static void print_typedef_type_pre(const typedef_type_t *const type) { - print_type_qualifiers(type->base.qualifiers); - if (type->base.qualifiers != 0) - fputc(' ', out); - fputs(type->typedefe->base.symbol->string, out); + print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); + print_string(type->typedefe->base.symbol->string); } /** @@ -628,13 +672,13 @@ static void print_typedef_type_pre(const typedef_type_t *const type) */ static void print_typeof_type_pre(const typeof_type_t *const type) { - fputs("typeof(", out); + print_string("typeof("); if (type->expression != NULL) { print_expression(type->expression); } else { print_type(type->typeof_type); } - fputc(')', out); + print_string(")"); } /** @@ -646,10 +690,10 @@ static void intern_print_type_pre(const type_t *const type) { switch(type->kind) { case TYPE_ERROR: - fputs("", out); + print_string(""); return; case TYPE_INVALID: - fputs("", out); + print_string(""); return; case TYPE_ENUM: print_type_enum(&type->enumt); @@ -667,9 +711,6 @@ static void intern_print_type_pre(const type_t *const type) case TYPE_COMPOUND_UNION: print_compound_type(&type->compound); return; - case TYPE_BUILTIN: - fputs(type->builtin.symbol->string, out); - return; case TYPE_FUNCTION: print_function_type_pre(&type->function); return; @@ -692,7 +733,7 @@ static void intern_print_type_pre(const type_t *const type) print_typeof_type_pre(&type->typeoft); return; } - fputs("unknown", out); + print_string("unknown"); } /** @@ -726,7 +767,6 @@ static void intern_print_type_post(const type_t *const type) case TYPE_ENUM: case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: - case TYPE_BUILTIN: case TYPE_TYPEOF: case TYPE_TYPEDEF: break; @@ -746,15 +786,10 @@ void print_type(const type_t *const type) void print_type_ext(const type_t *const type, const symbol_t *symbol, const scope_t *parameters) { - if (type == NULL) { - fputs("nil type", out); - return; - } - intern_print_type_pre(type); if (symbol != NULL) { - fputc(' ', out); - fputs(symbol->string, out); + print_string(" "); + print_string(symbol->string); } if (type->kind == TYPE_FUNCTION) { print_function_type_post(&type->function, parameters); @@ -763,34 +798,6 @@ void print_type_ext(const type_t *const type, const symbol_t *symbol, } } -/** - * Return the size of a type AST node. - * - * @param type The type. - */ -static size_t get_type_struct_size(const type_t *type) -{ - switch(type->kind) { - case TYPE_ATOMIC: return sizeof(atomic_type_t); - case TYPE_COMPLEX: return sizeof(complex_type_t); - case TYPE_IMAGINARY: return sizeof(imaginary_type_t); - case TYPE_COMPOUND_STRUCT: - case TYPE_COMPOUND_UNION: return sizeof(compound_type_t); - case TYPE_ENUM: return sizeof(enum_type_t); - case TYPE_FUNCTION: return sizeof(function_type_t); - case TYPE_POINTER: return sizeof(pointer_type_t); - case TYPE_REFERENCE: return sizeof(reference_type_t); - case TYPE_ARRAY: return sizeof(array_type_t); - case TYPE_BUILTIN: return sizeof(builtin_type_t); - case TYPE_TYPEDEF: return sizeof(typedef_type_t); - case TYPE_TYPEOF: return sizeof(typeof_type_t); - case TYPE_BITFIELD: return sizeof(bitfield_type_t); - case TYPE_ERROR: panic("error type found"); - case TYPE_INVALID: panic("invalid type found"); - } - panic("unknown type found"); -} - /** * Duplicates a type. * @@ -801,9 +808,9 @@ static size_t get_type_struct_size(const type_t *type) */ type_t *duplicate_type(const type_t *type) { - size_t size = get_type_struct_size(type); + 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; @@ -845,7 +852,7 @@ type_t *get_qualified_type(type_t *orig_type, type_qualifiers_t const qual) copy = duplicate_type(type); copy->array.element_type = qual_element_type; } else if (is_type_valid(type)) { - if ((type->base.qualifiers & qual) == qual) + if ((type->base.qualifiers & qual) == (int)qual) return orig_type; copy = duplicate_type(type); @@ -1009,11 +1016,8 @@ bool is_type_scalar(const type_t *type) { assert(!is_typeref(type)); - switch (type->kind) { - case TYPE_POINTER: return true; - case TYPE_BUILTIN: return is_type_scalar(type->builtin.real_type); - default: break; - } + if (type->kind == TYPE_POINTER) + return true; return is_type_arithmetic(type); } @@ -1054,7 +1058,6 @@ bool is_type_incomplete(const type_t *type) case TYPE_FUNCTION: case TYPE_POINTER: case TYPE_REFERENCE: - case TYPE_BUILTIN: case TYPE_ERROR: return false; @@ -1073,14 +1076,6 @@ bool is_type_object(const type_t *type) return !is_type_function(type) && !is_type_incomplete(type); } -bool is_builtin_va_list(type_t *type) -{ - type_t *tp = skip_typeref(type); - - return tp->kind == type_valist->kind && - tp->builtin.symbol == type_valist->builtin.symbol; -} - /** * Check if two function types are compatible. */ @@ -1095,19 +1090,24 @@ static bool function_types_compatible(const function_type_t *func1, if (func1->linkage != func2->linkage) return false; - /* this would make alot of sense, but gcc doesn't seem to do this */ -#if 0 - if (func1->calling_convention != func2->calling_convention) - return false; -#endif + cc_kind_t cc1 = func1->calling_convention; + if (cc1 == CC_DEFAULT) + cc1 = default_calling_convention; + cc_kind_t cc2 = func2->calling_convention; + if (cc2 == CC_DEFAULT) + cc2 = default_calling_convention; - /* can parameters be compared? */ - if (func1->unspecified_parameters || func2->unspecified_parameters) - return true; + if (cc1 != cc2) + return false; if (func1->variadic != func2->variadic) return false; + /* can parameters be compared? */ + if ((func1->unspecified_parameters && !func1->kr_style_parameters) + || (func2->unspecified_parameters && !func2->kr_style_parameters)) + return true; + /* TODO: handling of unspecified parameters not correct yet */ /* all argument types must be compatible */ @@ -1199,7 +1199,6 @@ bool types_compatible(const type_t *type1, const type_t *type2) break; } case TYPE_ENUM: - case TYPE_BUILTIN: /* TODO: not implemented */ break; @@ -1274,7 +1273,7 @@ type_t *skip_typeref(type_t *type) return type; } -unsigned get_type_size(const type_t *type) +unsigned get_type_size(type_t *type) { switch (type->kind) { case TYPE_INVALID: @@ -1288,7 +1287,10 @@ unsigned get_type_size(const type_t *type) case TYPE_IMAGINARY: return get_atomic_type_size(type->imaginary.akind); case TYPE_COMPOUND_UNION: + layout_union_type(&type->compound); + return type->compound.compound->size; case TYPE_COMPOUND_STRUCT: + layout_struct_type(&type->compound); return type->compound.compound->size; case TYPE_ENUM: return get_atomic_type_size(type->enumt.akind); @@ -1305,8 +1307,6 @@ unsigned get_type_size(const type_t *type) } case TYPE_BITFIELD: return 0; - case TYPE_BUILTIN: - return get_type_size(type->builtin.real_type); case TYPE_TYPEDEF: return get_type_size(type->typedeft.typedefe->type); case TYPE_TYPEOF: @@ -1319,7 +1319,7 @@ unsigned get_type_size(const type_t *type) panic("invalid type in get_type_size"); } -unsigned get_type_alignment(const type_t *type) +unsigned get_type_alignment(type_t *type) { switch (type->kind) { case TYPE_INVALID: @@ -1333,7 +1333,10 @@ unsigned get_type_alignment(const type_t *type) case TYPE_IMAGINARY: return get_atomic_type_alignment(type->imaginary.akind); case TYPE_COMPOUND_UNION: + layout_union_type(&type->compound); + return type->compound.compound->alignment; case TYPE_COMPOUND_STRUCT: + layout_struct_type(&type->compound); return type->compound.compound->alignment; case TYPE_ENUM: return get_atomic_type_alignment(type->enumt.akind); @@ -1348,8 +1351,6 @@ unsigned get_type_alignment(const type_t *type) return get_type_alignment(type->array.element_type); case TYPE_BITFIELD: return 0; - case TYPE_BUILTIN: - return get_type_alignment(type->builtin.real_type); case TYPE_TYPEDEF: { il_alignment_t alignment = get_type_alignment(type->typedeft.typedefe->type); @@ -1388,8 +1389,6 @@ decl_modifiers_t get_type_modifiers(const type_t *type) case TYPE_BITFIELD: case TYPE_ARRAY: return 0; - case TYPE_BUILTIN: - return get_type_modifiers(type->builtin.real_type); case TYPE_TYPEDEF: { decl_modifiers_t modifiers = type->typedeft.typedefe->modifiers; modifiers |= get_type_modifiers(type->typedeft.typedefe->type); @@ -1540,7 +1539,7 @@ type_t *identify_new_type(type_t *type) { type_t *result = typehash_insert(type); if (result != type) { - obstack_free(type_obst, type); + obstack_free(&type_obst, type); } return result; } @@ -1553,10 +1552,7 @@ type_t *identify_new_type(type_t *type) */ 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; @@ -1571,10 +1567,7 @@ type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers) */ 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; @@ -1589,10 +1582,7 @@ type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers */ 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; @@ -1607,10 +1597,7 @@ type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifie */ 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; @@ -1625,11 +1612,8 @@ type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers) */ 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); @@ -1645,10 +1629,7 @@ type_t *make_reference_type(type_t *refers_to) 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; @@ -1660,10 +1641,7 @@ type_t *make_based_pointer_type(type_t *points_to, 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; @@ -1672,16 +1650,257 @@ type_t *make_array_type(type_t *element_type, size_t size, return identify_new_type(type); } +static entity_t *pack_bitfield_members(il_size_t *struct_offset, + il_alignment_t *struct_alignment, + bool packed, entity_t *first) +{ + il_size_t offset = *struct_offset; + il_alignment_t alignment = *struct_alignment; + size_t bit_offset = 0; + + entity_t *member; + for (member = first; member != NULL; member = member->base.next) { + if (member->kind != ENTITY_COMPOUND_MEMBER) + continue; + + type_t *type = member->declaration.type; + if (type->kind != TYPE_BITFIELD) + break; + + type_t *base_type = skip_typeref(type->bitfield.base_type); + il_alignment_t base_alignment = get_type_alignment(base_type); + il_alignment_t alignment_mask = base_alignment-1; + if (base_alignment > alignment) + alignment = base_alignment; + + size_t bit_size = type->bitfield.bit_size; + if (!packed) { + bit_offset += (offset & alignment_mask) * BITS_PER_BYTE; + offset &= ~alignment_mask; + size_t base_size = get_type_size(base_type) * BITS_PER_BYTE; + + if (bit_offset + bit_size > base_size || bit_size == 0) { + offset += (bit_offset+BITS_PER_BYTE-1) / BITS_PER_BYTE; + offset = (offset + base_alignment-1) & ~alignment_mask; + bit_offset = 0; + } + } + + if (byte_order_big_endian) { + size_t base_size = get_type_size(base_type) * BITS_PER_BYTE; + member->compound_member.offset = offset & ~alignment_mask; + member->compound_member.bit_offset = base_size - bit_offset - bit_size; + } else { + member->compound_member.offset = offset; + member->compound_member.bit_offset = bit_offset; + } + + bit_offset += bit_size; + offset += bit_offset / BITS_PER_BYTE; + bit_offset %= BITS_PER_BYTE; + } + + if (bit_offset > 0) + offset += 1; + + *struct_offset = offset; + *struct_alignment = alignment; + return member; +} + +void layout_struct_type(compound_type_t *type) +{ + assert(type->compound != NULL); + + compound_t *compound = type->compound; + if (!compound->complete) + return; + if (type->compound->layouted) + return; + + il_size_t offset = 0; + il_alignment_t alignment = compound->alignment; + bool need_pad = false; + + entity_t *entry = compound->members.entities; + while (entry != NULL) { + if (entry->kind != ENTITY_COMPOUND_MEMBER) { + entry = entry->base.next; + continue; + } + + type_t *m_type = entry->declaration.type; + type_t *skipped = skip_typeref(m_type); + if (! is_type_valid(skipped)) { + entry = entry->base.next; + continue; + } + + if (skipped->kind == TYPE_BITFIELD) { + entry = pack_bitfield_members(&offset, &alignment, + compound->packed, entry); + continue; + } + + il_alignment_t m_alignment = get_type_alignment(m_type); + if (m_alignment > alignment) + alignment = m_alignment; + + if (!compound->packed) { + il_size_t new_offset = (offset + m_alignment-1) & -m_alignment; + + if (new_offset > offset) { + need_pad = true; + offset = new_offset; + } + } + + entry->compound_member.offset = offset; + offset += get_type_size(m_type); + + entry = entry->base.next; + } + + if (!compound->packed) { + il_size_t new_offset = (offset + alignment-1) & -alignment; + if (new_offset > offset) { + need_pad = true; + offset = new_offset; + } + } + + source_position_t const *const pos = &compound->base.source_position; + if (need_pad) { + warningf(WARN_PADDED, pos, "'%T' needs padding", type); + } else if (compound->packed) { + warningf(WARN_PACKED, pos, "superfluous packed attribute on '%T'", type); + } + + compound->size = offset; + compound->alignment = alignment; + compound->layouted = true; +} + +void layout_union_type(compound_type_t *type) +{ + assert(type->compound != NULL); + + compound_t *compound = type->compound; + if (! compound->complete) + return; + + il_size_t size = 0; + il_alignment_t alignment = compound->alignment; + + entity_t *entry = compound->members.entities; + for (; entry != NULL; entry = entry->base.next) { + if (entry->kind != ENTITY_COMPOUND_MEMBER) + continue; + + type_t *m_type = entry->declaration.type; + if (! is_type_valid(skip_typeref(m_type))) + continue; + + entry->compound_member.offset = 0; + il_size_t m_size = get_type_size(m_type); + if (m_size > size) + size = m_size; + il_alignment_t m_alignment = get_type_alignment(m_type); + if (m_alignment > alignment) + alignment = m_alignment; + } + size = (size + alignment - 1) & -alignment; + + compound->size = size; + compound->alignment = alignment; +} + +function_parameter_t *allocate_parameter(type_t *const type) +{ + function_parameter_t *const param = obstack_alloc(&type_obst, sizeof(*param)); + memset(param, 0, sizeof(*param)); + param->type = type; + return param; +} + +type_t *make_function_2_type(type_t *return_type, type_t *argument_type1, + type_t *argument_type2) +{ + function_parameter_t *const parameter2 = allocate_parameter(argument_type2); + function_parameter_t *const parameter1 = allocate_parameter(argument_type1); + parameter1->next = parameter2; + + type_t *type = allocate_type_zero(TYPE_FUNCTION); + type->function.return_type = return_type; + type->function.parameters = parameter1; + type->function.linkage = LINKAGE_C; + + return identify_new_type(type); +} + +type_t *make_function_1_type(type_t *return_type, type_t *argument_type) +{ + function_parameter_t *const parameter = allocate_parameter(argument_type); + + type_t *type = allocate_type_zero(TYPE_FUNCTION); + type->function.return_type = return_type; + type->function.parameters = parameter; + type->function.linkage = LINKAGE_C; + + return identify_new_type(type); +} + +type_t *make_function_1_type_variadic(type_t *return_type, + type_t *argument_type) +{ + function_parameter_t *const parameter = allocate_parameter(argument_type); + + type_t *type = allocate_type_zero(TYPE_FUNCTION); + type->function.return_type = return_type; + type->function.parameters = parameter; + type->function.variadic = true; + type->function.linkage = LINKAGE_C; + + return identify_new_type(type); +} + +type_t *make_function_0_type(type_t *return_type) +{ + type_t *type = allocate_type_zero(TYPE_FUNCTION); + type->function.return_type = return_type; + type->function.parameters = NULL; + type->function.linkage = LINKAGE_C; + + return identify_new_type(type); +} + +type_t *make_function_type(type_t *return_type, int n_types, + type_t *const *argument_types, + decl_modifiers_t modifiers) +{ + type_t *type = allocate_type_zero(TYPE_FUNCTION); + type->function.return_type = return_type; + type->function.modifiers |= modifiers; + type->function.linkage = LINKAGE_C; + + function_parameter_t **anchor = &type->function.parameters; + for (int i = 0; i < n_types; ++i) { + function_parameter_t *parameter = allocate_parameter(argument_types[i]); + *anchor = parameter; + anchor = ¶meter->next; + } + + return identify_new_type(type); +} + /** * Debug helper. Prints the given type to stdout. */ static __attribute__((unused)) void dbg_type(const type_t *type) { - FILE *old_out = out; - out = stderr; + print_to_file(stderr); print_type(type); - puts("\n"); + print_string("\n"); fflush(stderr); - out = old_out; }