X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=7b938a997f5c714af8f58730757d3175e465ac17;hb=779610287a11b207e958e31a29f0dd9ea5459e39;hp=da737e50492a98a359bffd8de5ea81bd589635e7;hpb=2e75b0923573fe37b5930d60067e202860e6ef3d;p=cparser diff --git a/type.c b/type.c index da737e5..7b938a9 100644 --- a/type.c +++ b/type.c @@ -1,27 +1,12 @@ /* * This file is part of cparser. - * 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 - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - * 02111-1307, USA. + * Copyright (C) 2012 Matthias Braun */ #include #include -#include +#include "adt/bitfiddle.h" #include "type_t.h" #include "types.h" #include "entity_t.h" @@ -33,6 +18,7 @@ #include "warning.h" #include "diagnostic.h" #include "printer.h" +#include "separator_t.h" /** The default calling convention. */ cc_kind_t default_calling_convention = CC_CDECL; @@ -52,6 +38,8 @@ static size_t get_type_struct_size(type_kind_t kind) { static const size_t sizes[] = { [TYPE_ATOMIC] = sizeof(atomic_type_t), + [TYPE_IMAGINARY] = sizeof(atomic_type_t), + [TYPE_COMPLEX] = sizeof(atomic_type_t), [TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t), [TYPE_COMPOUND_UNION] = sizeof(compound_type_t), [TYPE_ENUM] = sizeof(enum_type_t), @@ -62,8 +50,7 @@ static size_t get_type_struct_size(type_kind_t kind) [TYPE_TYPEDEF] = sizeof(typedef_type_t), [TYPE_TYPEOF] = sizeof(typeof_type_t), }; - assert(lengthof(sizes) == (int)TYPE_TYPEOF + 1); - assert(kind <= TYPE_TYPEOF); + assert((size_t)kind < lengthof(sizes)); assert(sizes[kind] != 0); return sizes[kind]; } @@ -192,11 +179,6 @@ atomic_type_properties_t pointer_properties = { .flags = ATOMIC_TYPE_FLAG_NONE, }; -static inline bool is_po2(unsigned x) -{ - return (x & (x-1)) == 0; -} - void init_types(unsigned machine_size) { obstack_init(&type_obst); @@ -239,15 +221,15 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato { size_t sep = q & QUAL_SEP_START ? 0 : 1; if (qualifiers & TYPE_QUALIFIER_CONST) { - print_string(" const" + sep); + print_string(&" const"[sep]); sep = 0; } if (qualifiers & TYPE_QUALIFIER_VOLATILE) { - print_string(" volatile" + sep); + print_string(&" volatile"[sep]); sep = 0; } if (qualifiers & TYPE_QUALIFIER_RESTRICT) { - print_string(" restrict" + sep); + print_string(&" restrict"[sep]); sep = 0; } if (sep == 0 && q & QUAL_SEP_END) @@ -256,8 +238,7 @@ void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparato const char *get_atomic_kind_name(atomic_type_kind_t kind) { - switch(kind) { - case ATOMIC_TYPE_INVALID: break; + switch (kind) { case ATOMIC_TYPE_VOID: return "void"; case ATOMIC_TYPE_WCHAR_T: return "wchar_t"; case ATOMIC_TYPE_BOOL: return c_mode & _CXX ? "bool" : "_Bool"; @@ -309,7 +290,7 @@ static void print_atomic_type(const atomic_type_t *type) static void print_complex_type(const atomic_type_t *type) { print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); - print_string("_Complex"); + print_string("_Complex "); print_atomic_kinds(type->akind); } @@ -374,15 +355,11 @@ static void print_function_type_post(const function_type_t *type, const scope_t *parameters) { print_char('('); - bool first = true; + separator_t sep = { "", ", " }; if (parameters == NULL) { function_parameter_t *parameter = type->parameters; - for( ; parameter != NULL; parameter = parameter->next) { - if (first) { - first = false; - } else { - print_string(", "); - } + for ( ; parameter != NULL; parameter = parameter->next) { + print_string(sep_next(&sep)); print_type(parameter->type); } } else { @@ -391,11 +368,7 @@ static void print_function_type_post(const function_type_t *type, if (parameter->kind != ENTITY_PARAMETER) continue; - if (first) { - first = false; - } else { - print_string(", "); - } + print_string(sep_next(&sep)); const type_t *const param_type = parameter->declaration.type; if (param_type == NULL) { print_string(parameter->base.symbol->string); @@ -405,14 +378,10 @@ static void print_function_type_post(const function_type_t *type, } } if (type->variadic) { - if (first) { - first = false; - } else { - print_string(", "); - } + print_string(sep_next(&sep)); print_string("..."); } - if (first && !type->unspecified_parameters) { + if (sep_at_first(&sep) && !type->unspecified_parameters) { print_string("void"); } print_char(')'); @@ -518,7 +487,7 @@ void print_enum_definition(const enum_t *enume) change_indent(1); entity_t *entry = enume->base.next; - for( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE; + for ( ; entry != NULL && entry->kind == ENTITY_ENUM_VALUE; entry = entry->base.next) { print_indent(); @@ -560,7 +529,7 @@ void print_compound_definition(const compound_t *compound) change_indent(1); entity_t *entity = compound->members.entities; - for( ; entity != NULL; entity = entity->base.next) { + for ( ; entity != NULL; entity = entity->base.next) { if (entity->kind != ENTITY_COMPOUND_MEMBER) continue; @@ -580,18 +549,13 @@ void print_compound_definition(const compound_t *compound) /** * Prints a compound type. * + * @param kind The name of the compound kind. * @param type The compound type. */ -static void print_compound_type(const compound_type_t *type) +static void print_compound_type(char const *const kind, compound_type_t const *const type) { print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END); - - if (type->base.kind == TYPE_COMPOUND_STRUCT) { - print_string("struct "); - } else { - assert(type->base.kind == TYPE_COMPOUND_UNION); - print_string("union "); - } + print_string(kind); compound_t *compound = type->compound; symbol_t *symbol = compound->base.symbol; @@ -636,44 +600,20 @@ static void print_typeof_type_pre(const typeof_type_t *const type) */ static void intern_print_type_pre(const type_t *const type) { - switch(type->kind) { - case TYPE_ERROR: - print_string(""); - return; - case TYPE_ENUM: - print_type_enum(&type->enumt); - return; - case TYPE_ATOMIC: - print_atomic_type(&type->atomic); - return; - case TYPE_COMPLEX: - print_complex_type(&type->atomic); - return; - case TYPE_IMAGINARY: - print_imaginary_type(&type->atomic); - return; - case TYPE_COMPOUND_STRUCT: - case TYPE_COMPOUND_UNION: - print_compound_type(&type->compound); - return; - case TYPE_FUNCTION: - print_function_type_pre(&type->function); - return; - case TYPE_POINTER: - print_pointer_type_pre(&type->pointer); - return; - case TYPE_REFERENCE: - print_reference_type_pre(&type->reference); - return; - case TYPE_ARRAY: - print_array_type_pre(&type->array); - return; - case TYPE_TYPEDEF: - print_typedef_type_pre(&type->typedeft); - return; - case TYPE_TYPEOF: - print_typeof_type_pre(&type->typeoft); - return; + switch (type->kind) { + case TYPE_ARRAY: print_array_type_pre( &type->array); return; + case TYPE_ATOMIC: print_atomic_type( &type->atomic); return; + case TYPE_COMPLEX: print_complex_type( &type->atomic); return; + case TYPE_COMPOUND_STRUCT: print_compound_type("struct ", &type->compound); return; + case TYPE_COMPOUND_UNION: print_compound_type("union ", &type->compound); return; + case TYPE_ENUM: print_type_enum( &type->enumt); return; + case TYPE_ERROR: print_string(""); return; + case TYPE_FUNCTION: print_function_type_pre( &type->function); return; + case TYPE_IMAGINARY: print_imaginary_type( &type->atomic); return; + case TYPE_POINTER: print_pointer_type_pre( &type->pointer); return; + case TYPE_REFERENCE: print_reference_type_pre( &type->reference); return; + case TYPE_TYPEDEF: print_typedef_type_pre( &type->typedeft); return; + case TYPE_TYPEOF: print_typeof_type_pre( &type->typeoft); return; } print_string("unknown"); } @@ -685,7 +625,7 @@ static void intern_print_type_pre(const type_t *const type) */ static void intern_print_type_post(const type_t *const type) { - switch(type->kind) { + switch (type->kind) { case TYPE_FUNCTION: print_function_type_post(&type->function, NULL); return; @@ -735,8 +675,7 @@ type_t *duplicate_type(const type_t *type) { size_t size = get_type_struct_size(type->kind); - type_t *const copy = obstack_alloc(&type_obst, size); - memcpy(copy, type, size); + type_t *const copy = obstack_copy(&type_obst, type, size); copy->base.firm_type = NULL; return copy; @@ -793,12 +732,8 @@ static bool test_atomic_type_flag(atomic_type_kind_t kind, bool is_type_integer(const type_t *type) { assert(!is_typeref(type)); - - if (type->kind == TYPE_ENUM) - return true; - if (type->kind != TYPE_ATOMIC) + if (!is_type_arithmetic(type)) return false; - return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_INTEGER); } @@ -821,23 +756,14 @@ bool is_type_float(const type_t *type) bool is_type_complex(const type_t *type) { assert(!is_typeref(type)); - - if (type->kind != TYPE_ATOMIC) - return false; - - return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_COMPLEX); + return type->kind == TYPE_COMPLEX; } bool is_type_signed(const type_t *type) { assert(!is_typeref(type)); - - /* enum types are int for now */ - if (type->kind == TYPE_ENUM) - return true; - if (type->kind != TYPE_ATOMIC) + if (!is_type_arithmetic(type)) return false; - return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_SIGNED); } @@ -845,7 +771,7 @@ bool is_type_arithmetic(const type_t *type) { assert(!is_typeref(type)); - switch(type->kind) { + switch (type->kind) { case TYPE_ENUM: return true; case TYPE_ATOMIC: @@ -867,17 +793,24 @@ bool is_type_scalar(const type_t *type) { assert(!is_typeref(type)); - if (type->kind == TYPE_POINTER) + switch (type->kind) { + case TYPE_POINTER: + case TYPE_ENUM: return true; - - return is_type_arithmetic(type); + case TYPE_ATOMIC: + case TYPE_COMPLEX: + case TYPE_IMAGINARY: + return test_atomic_type_flag(type->atomic.akind, ATOMIC_TYPE_FLAG_ARITHMETIC); + default: + return false; + } } bool is_type_incomplete(const type_t *type) { assert(!is_typeref(type)); - switch(type->kind) { + switch (type->kind) { case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: { const compound_type_t *compound_type = &type->compound; @@ -903,10 +836,10 @@ bool is_type_incomplete(const type_t *type) case TYPE_TYPEDEF: case TYPE_TYPEOF: - panic("is_type_incomplete called without typerefs skipped"); + panic("typedef not skipped"); } - panic("invalid type found"); + panic("invalid type"); } bool is_type_object(const type_t *type) @@ -995,53 +928,48 @@ bool types_compatible(const type_t *type1, const type_t *type2) if (type1 == type2) return true; - if (!is_type_valid(type1) || !is_type_valid(type2)) - return true; - - if (type1->base.qualifiers != type2->base.qualifiers) - return false; - if (type1->kind != type2->kind) - return false; + if (type1->base.qualifiers == type2->base.qualifiers && + type1->kind == type2->kind) { + switch (type1->kind) { + case TYPE_FUNCTION: + return function_types_compatible(&type1->function, &type2->function); + case TYPE_ATOMIC: + case TYPE_IMAGINARY: + case TYPE_COMPLEX: + return type1->atomic.akind == type2->atomic.akind; + case TYPE_ARRAY: + return array_types_compatible(&type1->array, &type2->array); - switch (type1->kind) { - case TYPE_FUNCTION: - return function_types_compatible(&type1->function, &type2->function); - case TYPE_ATOMIC: - case TYPE_IMAGINARY: - case TYPE_COMPLEX: - return type1->atomic.akind == type2->atomic.akind; - case TYPE_ARRAY: - return array_types_compatible(&type1->array, &type2->array); + case TYPE_POINTER: { + const type_t *const to1 = skip_typeref(type1->pointer.points_to); + const type_t *const to2 = skip_typeref(type2->pointer.points_to); + return types_compatible(to1, to2); + } - case TYPE_POINTER: { - const type_t *const to1 = skip_typeref(type1->pointer.points_to); - const type_t *const to2 = skip_typeref(type2->pointer.points_to); - return types_compatible(to1, to2); - } + case TYPE_REFERENCE: { + const type_t *const to1 = skip_typeref(type1->reference.refers_to); + const type_t *const to2 = skip_typeref(type2->reference.refers_to); + return types_compatible(to1, to2); + } - case TYPE_REFERENCE: { - const type_t *const to1 = skip_typeref(type1->reference.refers_to); - const type_t *const to2 = skip_typeref(type2->reference.refers_to); - return types_compatible(to1, to2); - } + case TYPE_COMPOUND_STRUCT: + case TYPE_COMPOUND_UNION: + break; - case TYPE_COMPOUND_STRUCT: - case TYPE_COMPOUND_UNION: { - break; - } - case TYPE_ENUM: - /* TODO: not implemented */ - break; + case TYPE_ENUM: + /* TODO: not implemented */ + break; - case TYPE_ERROR: - /* Hmm, the error type should be compatible to all other types */ - return true; - case TYPE_TYPEDEF: - case TYPE_TYPEOF: - panic("typerefs not skipped in compatible types?!?"); + case TYPE_ERROR: + /* Hmm, the error type should be compatible to all other types */ + return true; + case TYPE_TYPEDEF: + case TYPE_TYPEOF: + panic("typeref not skipped"); + } } - return false; + return !is_type_valid(type1) || !is_type_valid(type2); } /** @@ -1128,7 +1056,7 @@ unsigned get_type_size(type_t *type) case TYPE_TYPEOF: return get_type_size(type->typeoft.typeof_type); } - panic("invalid type in get_type_size"); + panic("invalid type"); } unsigned get_type_alignment(type_t *type) @@ -1156,17 +1084,13 @@ unsigned get_type_alignment(type_t *type) case TYPE_ARRAY: return get_type_alignment(type->array.element_type); case TYPE_TYPEDEF: { - il_alignment_t alignment - = get_type_alignment(type->typedeft.typedefe->type); - if (type->typedeft.typedefe->alignment > alignment) - alignment = type->typedeft.typedefe->alignment; - - return alignment; + il_alignment_t const alignment = get_type_alignment(type->typedeft.typedefe->type); + return MAX(alignment, type->typedeft.typedefe->alignment); } case TYPE_TYPEOF: return get_type_alignment(type->typeoft.typeof_type); } - panic("invalid type in get_type_alignment"); + panic("invalid type"); } /** @@ -1184,7 +1108,7 @@ static unsigned get_type_alignment_compound(type_t *const type) decl_modifiers_t get_type_modifiers(const type_t *type) { - switch(type->kind) { + switch (type->kind) { case TYPE_ERROR: break; case TYPE_COMPOUND_STRUCT: @@ -1208,7 +1132,7 @@ decl_modifiers_t get_type_modifiers(const type_t *type) case TYPE_TYPEOF: return get_type_modifiers(type->typeoft.typeof_type); } - panic("invalid type found in get_type_modifiers"); + panic("invalid type"); } type_qualifiers_t get_type_qualifier(const type_t *type, bool skip_array_type) @@ -1271,7 +1195,7 @@ atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size) assert(size < 32); atomic_type_kind_t kind = kinds[size]; - if (kind == ATOMIC_TYPE_INVALID) { + if (kind == (atomic_type_kind_t)0) { static const atomic_type_kind_t possible_kinds[] = { ATOMIC_TYPE_SCHAR, ATOMIC_TYPE_SHORT, @@ -1299,7 +1223,7 @@ atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size) assert(size < 32); atomic_type_kind_t kind = kinds[size]; - if (kind == ATOMIC_TYPE_INVALID) { + if (kind == (atomic_type_kind_t)0) { static const atomic_type_kind_t possible_kinds[] = { ATOMIC_TYPE_UCHAR, ATOMIC_TYPE_USHORT, @@ -1457,8 +1381,7 @@ static entity_t *pack_bitfield_members(il_size_t *struct_offset, type_t *const base_type = skip_typeref(member->declaration.type); il_alignment_t base_alignment = get_type_alignment_compound(base_type); il_alignment_t alignment_mask = base_alignment-1; - if (base_alignment > alignment) - alignment = base_alignment; + alignment = MAX(alignment, base_alignment); size_t bit_size = member->compound_member.bit_size; if (!packed) { @@ -1526,12 +1449,10 @@ void layout_struct_type(compound_type_t *type) } il_alignment_t m_alignment = get_type_alignment_compound(m_type); - if (m_alignment > alignment) - alignment = m_alignment; + alignment = MAX(alignment, m_alignment); if (!compound->packed) { - il_size_t new_offset = (offset + m_alignment-1) & -m_alignment; - + il_size_t const new_offset = round_up2(offset, m_alignment); if (new_offset > offset) { need_pad = true; offset = new_offset; @@ -1546,14 +1467,14 @@ next: } if (!compound->packed) { - il_size_t new_offset = (offset + alignment-1) & -alignment; + il_size_t const new_offset = round_up2(offset, alignment); if (new_offset > offset) { need_pad = true; offset = new_offset; } } - source_position_t const *const pos = &compound->base.source_position; + position_t const *const pos = &compound->base.pos; if (need_pad) { warningf(WARN_PADDED, pos, "'%T' needs padding", type); } else if (compound->packed) { @@ -1589,13 +1510,11 @@ void layout_union_type(compound_type_t *type) entry->compound_member.offset = 0; il_size_t m_size = get_type_size(m_type); - if (m_size > size) - size = m_size; + size = MAX(size, m_size); il_alignment_t m_alignment = get_type_alignment_compound(m_type); - if (m_alignment > alignment) - alignment = m_alignment; + alignment = MAX(alignment, m_alignment); } - size = (size + alignment - 1) & -alignment; + size = round_up2(size, alignment); compound->size = size; compound->alignment = alignment;