X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=da43b1ac6e5b525062c5c6fe1c1508fb05b8bdda;hb=d7384b0b065dd6195ac6649c4d48a06905bc8fe7;hp=a79d4e1d3c6853ce92fa70c672a5807e70af941a;hpb=8bd23e0c2c6bff177fa4a597a746eaf587f729e2;p=cparser diff --git a/mangle.c b/mangle.c index a79d4e1..da43b1a 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 @@ -38,8 +38,8 @@ static void mangle_type(type_t *type); 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'; @@ -56,7 +56,7 @@ static char get_atomic_type_mangle(atomic_type_kind_t kind) case ATOMIC_TYPE_FLOAT: return 'f'; case ATOMIC_TYPE_DOUBLE: return 'd'; } - panic("invalid atomic type in mangler"); + panic("invalid atomic type"); } static void mangle_atomic_type(const atomic_type_t *type) @@ -70,6 +70,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) @@ -103,44 +109,64 @@ static void mangle_function_type(const function_type_t *type) obstack_1grow(&obst, 'E'); } -static void mangle_class_enum_type(const entity_base_t *ent) +static void print_name(const char* name) { - const symbol_t *sym = ent->symbol; - if (sym != NULL) { - const char *name = sym->string; - obstack_printf(&obst, "%zu%s", strlen(name), name); - } else { - /* TODO need the first typedef name here */ - panic("mangling of unnamed class/enum types not implemented yet"); + obstack_printf(&obst, "%u%s", (unsigned)strlen(name), name); +} + +static void mangle_class_type(const compound_type_t *type) +{ + const symbol_t *sym = type->compound->base.symbol; + if (sym == NULL) { + if (type->compound->alias == NULL) + panic("mangling anonymous type"); + sym = type->compound->alias->base.symbol; } + print_name(sym->string); +} + +static void mangle_enum_type(const enum_type_t *type) +{ + const symbol_t *sym = type->enume->base.symbol; + if (sym == NULL) { + if (type->enume->alias == NULL) + panic("mangling anonymous type"); + sym = type->enume->alias->base.symbol; + } + print_name(sym->string); } static void mangle_array_type(const array_type_t *type) { if (type->is_vla) { - obstack_printf(&obst, "A_"); + obstack_1grow(&obst, 'A'); + obstack_1grow(&obst, '_'); } else if (type->size_constant) { - obstack_printf(&obst, "A%zu_", type->size); + obstack_printf(&obst, "A%u_", (unsigned) type->size); } else { - panic("mangling of non-constant sized arrray types not implemented yet"); + panic("mangling of non-constant sized array types not implemented yet"); } mangle_type(type->element_type); } -static void mangle_complex_type(const complex_type_t *type) +static void mangle_complex_type(const atomic_type_t *type) { - obstack_printf(&obst, "C%c", get_atomic_type_mangle(type->akind)); + obstack_1grow(&obst, 'C'); + obstack_1grow(&obst, get_atomic_type_mangle(type->akind)); } -static void mangle_imaginary_type(const imaginary_type_t *type) +static void mangle_imaginary_type(const atomic_type_t *type) { - obstack_printf(&obst, "G%c", get_atomic_type_mangle(type->akind)); + obstack_1grow(&obst, 'G'); + obstack_1grow(&obst, get_atomic_type_mangle(type->akind)); } 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) @@ -162,50 +188,61 @@ 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; case TYPE_COMPOUND_STRUCT: case TYPE_COMPOUND_UNION: - mangle_class_enum_type(&type->compound.compound->base); + mangle_class_type(&type->compound); return; case TYPE_ENUM: - mangle_class_enum_type(&type->enumt.enume->base); + mangle_enum_type(&type->enumt); return; case TYPE_ARRAY: mangle_array_type(&type->array); return; case TYPE_COMPLEX: - mangle_complex_type(&type->complex); + mangle_complex_type(&type->atomic); return; case TYPE_IMAGINARY: - mangle_imaginary_type(&type->imaginary); + mangle_imaginary_type(&type->atomic); return; - case TYPE_INVALID: - panic("invalid type encountered while mangling"); case TYPE_ERROR: panic("error type encountered while mangling"); - case TYPE_BUILTIN: case TYPE_TYPEDEF: case TYPE_TYPEOF: panic("typeref not resolved while manging?!?"); - - 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); + } - const char *name = entity->base.symbol->string; - obstack_printf(&obst, "%zu%s", strlen(name), name); + print_name(entity->base.symbol->string); if (entity->kind == ENTITY_FUNCTION) { mangle_parameters(&entity->declaration.type->function); @@ -233,55 +270,54 @@ 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; - - case LINKAGE_C: - obstack_printf(o, "%s", entity->base.symbol->string); - break; + switch (type->function.linkage) { + 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); - size_t 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, "@%zu", 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); @@ -298,22 +334,24 @@ ident *create_name_win32(entity_t *entity) */ ident *create_name_linux_elf(entity_t *entity) { - bool needs_mangling = false; + const char *name = entity->base.symbol->string; 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_C: + if (entity->function.actual_name != NULL) + name = entity->function.actual_name->string; + break; + case LINKAGE_CXX: + // TODO What about __REDIRECT/actual_name with mangling? + mangle_entity(entity); + return make_id_from_obst(); } } - if (needs_mangling) { - mangle_entity(entity); - return make_id_from_obst(); - } - - return new_id_from_str(entity->base.symbol->string); + return new_id_from_str(name); } /** @@ -324,6 +362,18 @@ 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)); + + switch (type->function.linkage) { + default: + if (entity->function.actual_name != NULL) + return new_id_from_str(entity->function.actual_name->string); + break; + } + } + obstack_printf(&obst, "_%s", entity->base.symbol->string); return make_id_from_obst(); }