Make sure that get_type_alignment() is not passed a typedef.

[cparser] / type.c

diff --git a/type.c b/type.c
index 2626f1d..efa9583 100644 (file)
--- a/type.c
+++ b/type.c
@@ -152,6 +152,19 @@ atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
                .flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
                .rank       = 5,
        },
+       [ATOMIC_TYPE_LONGLONG] = {
+               .size       = 8,
+               .alignment  = 8,
+               .flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC
+                             | ATOMIC_TYPE_FLAG_SIGNED,
+               .rank       = 6,
+       },
+       [ATOMIC_TYPE_ULONGLONG] = {
+               .size       = 8,
+               .alignment  = 8,
+               .flags      = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC,
+               .rank       = 6,
+       },
        [ATOMIC_TYPE_FLOAT] = {
                .size       = 4,
                .alignment  = 4,
@@ -208,15 +221,11 @@ void init_types(unsigned machine_size)
        pointer_properties.alignment        = long_size;
        pointer_properties.struct_alignment = long_size;
 
-       props[ATOMIC_TYPE_LONGLONG]    = props[ATOMIC_TYPE_LONG];
-       props[ATOMIC_TYPE_ULONGLONG]   = props[ATOMIC_TYPE_ULONG];
        props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
        props[ATOMIC_TYPE_WCHAR_T]     = props[ATOMIC_TYPE_INT];
 
        /* set struct alignments to the same value as alignment */
-       for (size_t i = 0;
-            i < sizeof(atomic_type_properties)/sizeof(atomic_type_properties[0]);
-            ++i) {
+       for (size_t i = 0; i != lengthof(atomic_type_properties); ++i) {
                props[i].struct_alignment = props[i].alignment;
        }
 }
@@ -1257,6 +1266,7 @@ unsigned get_type_alignment(type_t *type)
 
 unsigned get_type_alignment_compound(type_t *type)
 {
+       assert(!is_typeref(type));
        if (type->kind == TYPE_ATOMIC)
                return atomic_type_properties[type->atomic.akind].struct_alignment;
        return get_type_alignment(type);
@@ -1538,7 +1548,7 @@ static entity_t *pack_bitfield_members(il_size_t *struct_offset,
                if (!member->compound_member.bitfield)
                        break;
 
-               type_t *base_type = member->declaration.type;
+               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)
@@ -1600,9 +1610,8 @@ void layout_struct_type(compound_type_t *type)
                        continue;
                }
 
-               type_t *m_type  = entry->declaration.type;
-               type_t *skipped = skip_typeref(m_type);
-               if (! is_type_valid(skipped)) {
+               type_t *const m_type  = skip_typeref(entry->declaration.type);
+               if (!is_type_valid(m_type)) {
                        entry = entry->base.next;
                        continue;
                }
@@ -1668,7 +1677,7 @@ void layout_union_type(compound_type_t *type)
                if (entry->kind != ENTITY_COMPOUND_MEMBER)
                        continue;
 
-               type_t *m_type = entry->declaration.type;
+               type_t *m_type = skip_typeref(entry->declaration.type);
                if (! is_type_valid(skip_typeref(m_type)))
                        continue;
 
@@ -1695,7 +1704,7 @@ function_parameter_t *allocate_parameter(type_t *const type)
 }
 
 type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
-                             type_t *argument_type2)
+                             type_t *argument_type2, decl_modifiers_t modifiers)
 {
        function_parameter_t *const parameter2 = allocate_parameter(argument_type2);
        function_parameter_t *const parameter1 = allocate_parameter(argument_type1);
@@ -1704,25 +1713,29 @@ type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
        type_t *type               = allocate_type_zero(TYPE_FUNCTION);
        type->function.return_type = return_type;
        type->function.parameters  = parameter1;
+       type->function.modifiers  |= modifiers;
        type->function.linkage     = LINKAGE_C;
 
        return identify_new_type(type);
 }
 
-type_t *make_function_1_type(type_t *return_type, type_t *argument_type)
+type_t *make_function_1_type(type_t *return_type, type_t *argument_type,
+                             decl_modifiers_t modifiers)
 {
        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.modifiers  |= modifiers;
        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)
+                                      type_t *argument_type,
+                                      decl_modifiers_t modifiers)
 {
        function_parameter_t *const parameter = allocate_parameter(argument_type);
 
@@ -1730,16 +1743,18 @@ type_t *make_function_1_type_variadic(type_t *return_type,
        type->function.return_type = return_type;
        type->function.parameters  = parameter;
        type->function.variadic    = true;
+       type->function.modifiers  |= modifiers;
        type->function.linkage     = LINKAGE_C;
 
        return identify_new_type(type);
 }
 
-type_t *make_function_0_type(type_t *return_type)
+type_t *make_function_0_type(type_t *return_type, decl_modifiers_t modifiers)
 {
        type_t *type               = allocate_type_zero(TYPE_FUNCTION);
        type->function.return_type = return_type;
        type->function.parameters  = NULL;
+       type->function.modifiers  |= modifiers;
        type->function.linkage     = LINKAGE_C;
 
        return identify_new_type(type);