X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=0abf634665254081aa4ae79b89513f447b7581cd;hb=233b4629181c4a07fbabe8566c10ce2bae9224de;hp=5de8dba2b7ab3977b73cc241da342814efa47c8d;hpb=3698e9c61caea4cd2e684505b1d6788dd5e248e8;p=cparser diff --git a/type.c b/type.c index 5de8dba..0abf634 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 @@ -34,6 +34,9 @@ #include "diagnostic.h" #include "driver/firm_cmdline.h" +/** The default calling convention. */ +cc_kind_t default_calling_convention = CC_CDECL; + static struct obstack _type_obst; static FILE *out; struct obstack *type_obst = &_type_obst; @@ -330,12 +333,20 @@ static void print_function_type_pre(const function_type_t *type) 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: 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: + if (default_calling_convention != CC_CDECL) { + /* show the default calling convention if its not cdecl */ + cc = default_calling_convention; + goto restart; + } + break; } } @@ -1096,16 +1107,24 @@ static bool function_types_compatible(const function_type_t *func1, if (func1->linkage != func2->linkage) return false; - if (func1->calling_convention != func2->calling_convention) - return false; + 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 */ @@ -1676,51 +1695,55 @@ 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 *size, bool packed, - type_t *type, size_t offset, - entity_t *first) +static entity_t *pack_bitfield_members(il_size_t *struct_offset, + il_alignment_t *struct_alignment, + bool packed, entity_t *first) { - type_t *base_type = skip_typeref(type->bitfield.base_type); - size_t remaining_bits = get_type_size(base_type) * BITS_PER_BYTE; - size_t bit_offset = 0; + 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; + break; - type_t *member_type = member->declaration.type; - if (member_type->kind != TYPE_BITFIELD) + type_t *type = member->declaration.type; + if (type->kind != TYPE_BITFIELD) break; - size_t bit_size = member_type->bitfield.bit_size; + + 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) { - if (base_type != NULL - && skip_typeref(member_type->bitfield.base_type) != base_type) - break; - if (bit_size > remaining_bits) - break; - } else { - offset += bit_offset / BITS_PER_BYTE; - *size += bit_offset / BITS_PER_BYTE; - bit_offset = bit_offset % BITS_PER_BYTE; + 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; + } } member->compound_member.offset = offset; member->compound_member.bit_offset = bit_offset; bit_offset += bit_size; - - /* 0-size members end current bucket. multiple 0-size buckets - * seem to not start-end multiple buckets */ - if (bit_size == 0) { - remaining_bits = 0; - } else { - remaining_bits -= bit_size; - } + offset += bit_offset / BITS_PER_BYTE; + bit_offset %= BITS_PER_BYTE; } - assert(member != first); - *size = offset + (bit_offset + (BITS_PER_BYTE-1)) / BITS_PER_BYTE; + if (bit_offset > 0) + offset += 1; + + *struct_offset = offset; + *struct_alignment = alignment; return member; } @@ -1739,8 +1762,7 @@ void layout_struct_type(compound_type_t *type) if (type->compound->layouted) return; - il_size_t offset; - il_size_t size = 0; + il_size_t offset = 0; il_alignment_t alignment = compound->alignment; bool need_pad = false; @@ -1758,42 +1780,37 @@ void layout_struct_type(compound_type_t *type) continue; } - type_t *base_type = m_type; if (skipped->kind == TYPE_BITFIELD) { - base_type = m_type->bitfield.base_type; + entry = pack_bitfield_members(&offset, &alignment, + compound->packed, entry); + continue; } - il_alignment_t m_alignment = get_type_alignment(base_type); - il_size_t m_size = get_type_size(base_type); + il_alignment_t m_alignment = get_type_alignment(m_type); if (m_alignment > alignment) alignment = m_alignment; - if (compound->packed) { - offset = size; - } else { - offset = (size + m_alignment - 1) & -m_alignment; - } + if (!compound->packed) { + il_size_t new_offset = (offset + m_alignment-1) & -m_alignment; - if (offset > size) - need_pad = true; + if (new_offset > offset) { + need_pad = true; + offset = new_offset; + } + } - if (skipped->kind == TYPE_BITFIELD) { - entry = pack_bitfield_members(&size, compound->packed, - m_type, offset, entry); - } else { - entry->compound_member.offset = offset; - size = offset + m_size; + entry->compound_member.offset = offset; + offset += get_type_size(m_type); - entry = entry->base.next; - } + entry = entry->base.next; } if (!compound->packed) { - offset = (size + alignment - 1) & -alignment; - if (offset > size) + il_size_t new_offset = (offset + alignment-1) & -alignment; + if (new_offset > offset) { need_pad = true; - } else { - offset = size; + offset = new_offset; + } } if (need_pad) {