X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=636159fc93ea16d4d45771263eddcea18e5cdccb;hb=26aba71a371f0bbcc8afd213b4398d4e4e52a6f2;hp=c80ec3195d7a863d5e3d808964dee13ca03662bc;hpb=b7aee7a7ddee373437c04479c6ec00f14639d4da;p=cparser diff --git a/mangle.c b/mangle.c index c80ec31..636159f 100644 --- a/mangle.c +++ b/mangle.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 @@ -40,6 +40,7 @@ static char get_atomic_type_mangle(atomic_type_kind_t kind) switch (kind) { case ATOMIC_TYPE_INVALID: break; case ATOMIC_TYPE_VOID: return 'v'; + case ATOMIC_TYPE_WCHAR_T: return 'w'; case ATOMIC_TYPE_BOOL: return 'b'; case ATOMIC_TYPE_CHAR: return 'c'; case ATOMIC_TYPE_SCHAR: return 'a'; @@ -70,6 +71,12 @@ static void mangle_pointer_type(const pointer_type_t *type) mangle_type(type->points_to); } +static void mangle_reference_type(const reference_type_t *type) +{ + obstack_1grow(&obst, 'R'); + mangle_type(type->refers_to); +} + static void mangle_parameters(const function_type_t *type) { if (type->unspecified_parameters) @@ -157,8 +164,10 @@ static void mangle_imaginary_type(const imaginary_type_t *type) static void mangle_qualifiers(type_qualifiers_t qualifiers) { +#if 0 /* Do not mangle restrict qualifiers. GCC doesn't either */ if (qualifiers & TYPE_QUALIFIER_RESTRICT) obstack_1grow(&obst, 'r'); +#endif if (qualifiers & TYPE_QUALIFIER_VOLATILE) obstack_1grow(&obst, 'V'); if (qualifiers & TYPE_QUALIFIER_CONST) @@ -180,6 +189,9 @@ static void mangle_type(type_t *orig_type) case TYPE_POINTER: mangle_pointer_type(&type->pointer); return; + case TYPE_REFERENCE: + mangle_reference_type(&type->reference); + return; case TYPE_FUNCTION: mangle_function_type(&type->function); return; @@ -210,17 +222,32 @@ static void mangle_type(type_t *orig_type) case TYPE_BITFIELD: panic("no mangling for this type implemented yet"); - break; } panic("invalid type encountered while mangling"); } +static void mangle_namespace(entity_t *entity) +{ + for (entity_t *e = entity->base.parent_entity; e != NULL; + e = e->base.parent_entity) { + /* TODO: we need something similar (or the same?) for classes */ + if (e->kind == ENTITY_NAMESPACE) { + mangle_namespace(e); + print_name(e->base.symbol->string); + return; + } + } +} + static void mangle_entity(entity_t *entity) { obstack_1grow(&obst, '_'); obstack_1grow(&obst, 'Z'); - /* TODO: mangle scope */ + if (entity->base.parent_entity != NULL) { + obstack_1grow(&obst, 'N'); + mangle_namespace(entity); + } print_name(entity->base.symbol->string); @@ -250,55 +277,57 @@ ident *create_name_win32(entity_t *entity) assert(is_declaration(entity)); - if (entity->declaration.modifiers & DM_DLLIMPORT) { - /* add prefix for imported symbols */ - obstack_printf(o, "__imp_"); - } - if (entity->kind == ENTITY_FUNCTION) { - cc_kind_t cc = entity->declaration.type->function.calling_convention; + type_t *type = skip_typeref(entity->declaration.type); + assert(is_type_function(type)); + + if (entity->declaration.modifiers & DM_DLLIMPORT) + /* add prefix for imported symbols */ + obstack_printf(o, "__imp_"); + + cc_kind_t cc = type->function.calling_convention; /* calling convention prefix */ switch (cc) { - case CC_DEFAULT: - case CC_CDECL: - case CC_STDCALL: obstack_1grow(o, '_'); break; - case CC_FASTCALL: obstack_1grow(o, '@'); break; - default: panic("unhandled calling convention"); + case CC_DEFAULT: + case CC_CDECL: + case CC_STDCALL: obstack_1grow(o, '_'); break; + case CC_FASTCALL: obstack_1grow(o, '@'); break; + default: panic("unhandled calling convention"); } - switch (entity->declaration.type->function.linkage) { - case LINKAGE_INVALID: - break; + switch (type->function.linkage) { + case LINKAGE_INVALID: + panic("linkage type of function is invalid"); - case LINKAGE_C: - obstack_printf(o, "%s", entity->base.symbol->string); - break; + case LINKAGE_C: + obstack_printf(o, "%s", entity->base.symbol->string); + break; - case LINKAGE_CXX: - mangle_entity(entity); - break; + case LINKAGE_CXX: + mangle_entity(entity); + break; } /* calling convention suffix */ switch (cc) { - case CC_DEFAULT: - case CC_CDECL: - break; - - case CC_STDCALL: - case CC_FASTCALL: { - ir_type *irtype = get_ir_type(entity->declaration.type); - unsigned size = 0; - for (int i = get_method_n_params(irtype) - 1; i >= 0; --i) { - size += get_type_size_bytes(get_method_param_type(irtype, i)); - } - obstack_printf(o, "@%u", size); - break; + case CC_DEFAULT: + case CC_CDECL: + break; + + case CC_STDCALL: + case CC_FASTCALL: { + ir_type *irtype = get_ir_type(entity->declaration.type); + unsigned size = 0; + for (int i = get_method_n_params(irtype) - 1; i >= 0; --i) { + size += get_type_size_bytes(get_method_param_type(irtype, i)); } + obstack_printf(o, "@%u", size); + break; + } - default: - panic("unhandled calling convention"); + default: + panic("unhandled calling convention"); } } else { obstack_printf(o, "_%s", entity->base.symbol->string); @@ -318,10 +347,14 @@ ident *create_name_linux_elf(entity_t *entity) bool needs_mangling = false; if (entity->kind == ENTITY_FUNCTION) { - switch (entity->declaration.type->function.linkage) { - case LINKAGE_INVALID: break; - case LINKAGE_C: break; - case LINKAGE_CXX: needs_mangling = true; break; + type_t *type = skip_typeref(entity->declaration.type); + assert(is_type_function(type)); + switch (type->function.linkage) { + case LINKAGE_INVALID: + panic("linkage type of function is invalid"); + + case LINKAGE_C: break; + case LINKAGE_CXX: needs_mangling = true; break; } } @@ -341,6 +374,13 @@ ident *create_name_linux_elf(entity_t *entity) */ ident *create_name_macho(entity_t *entity) { + if (entity->kind == ENTITY_FUNCTION) { + type_t *type = skip_typeref(entity->declaration.type); + assert(is_type_function(type)); + if (type->function.linkage == LINKAGE_INVALID) + panic("linkage type of function is invalid"); + } + obstack_printf(&obst, "_%s", entity->base.symbol->string); return make_id_from_obst(); }