X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=fb02128081361579fae097fbed487eb4b5ed21eb;hb=ef3b0164cbb6c9d616c3fdad92fb8da669e4b5d7;hp=eac5d04b89c0aee8acc56743e73708e73db4b9ec;hpb=75655e2cb65edb7a4d8e6b112f6182db9d1c1483;p=cparser diff --git a/mangle.c b/mangle.c index eac5d04..fb02128 100644 --- a/mangle.c +++ b/mangle.c @@ -1,33 +1,17 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2008 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/obst.h" #include "entity_t.h" #include "type_t.h" #include "symbol_t.h" #include "mangle.h" -#include "diagnostic.h" -#include "ast2firm.h" #include "lang_features.h" #include "adt/error.h" @@ -38,8 +22,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 +40,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,16 +54,20 @@ static void mangle_pointer_type(const pointer_type_t *type) mangle_type(type->points_to); } -static void mangle_function_type(const function_type_t *type) +static void mangle_reference_type(const reference_type_t *type) { - obstack_1grow(&obst, 'F'); - if (type->linkage == LINKAGE_C) { - obstack_1grow(&obst, 'Y'); - } + obstack_1grow(&obst, 'R'); + mangle_type(type->refers_to); +} - mangle_type(type->return_type); +static void mangle_parameters(const function_type_t *type) +{ + if (type->unspecified_parameters) + panic("can't mangle unspecified parameter types"); + if (type->kr_style_parameters) + panic("can't mangle kr_style_parameters type"); - function_parameter_t *parameter = type->parameters; + const function_parameter_t *parameter = type->parameters; if (parameter != NULL) { for ( ; parameter != NULL; parameter = parameter->next) { mangle_type(parameter->type); @@ -90,18 +78,79 @@ static void mangle_function_type(const function_type_t *type) } else { obstack_1grow(&obst, 'v'); } - if (type->unspecified_parameters) - panic("can't mangle unspecified parameter types"); - if (type->kr_style_parameters) - panic("can't mangle kr_style_parameters type"); +} + +static void mangle_function_type(const function_type_t *type) +{ + obstack_1grow(&obst, 'F'); + if (type->linkage == LINKAGE_C) { + obstack_1grow(&obst, 'Y'); + } + + mangle_type(type->return_type); + mangle_parameters(type); obstack_1grow(&obst, 'E'); } +static void print_name(const char* name) +{ + 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_1grow(&obst, 'A'); + obstack_1grow(&obst, '_'); + } else if (type->size_constant) { + obstack_printf(&obst, "A%u_", (unsigned) type->size); + } else { + panic("mangling of non-constant sized array types not implemented yet"); + } + mangle_type(type->element_type); +} + +static void mangle_complex_type(const atomic_type_t *type) +{ + obstack_1grow(&obst, 'C'); + obstack_1grow(&obst, get_atomic_type_mangle(type->akind)); +} + +static void mangle_imaginary_type(const atomic_type_t *type) +{ + 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) @@ -123,43 +172,64 @@ 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_INVALID: - panic("invalid type encountered while mangling"); + case TYPE_COMPOUND_STRUCT: + case TYPE_COMPOUND_UNION: + mangle_class_type(&type->compound); + return; + case TYPE_ENUM: + mangle_enum_type(&type->enumt); + return; + case TYPE_ARRAY: + mangle_array_type(&type->array); + return; + case TYPE_COMPLEX: + mangle_complex_type(&type->atomic); + return; + case TYPE_IMAGINARY: + mangle_imaginary_type(&type->atomic); + return; 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: - case TYPE_COMPLEX: - case TYPE_IMAGINARY: - case TYPE_COMPOUND_STRUCT: - case TYPE_COMPOUND_UNION: - case TYPE_ENUM: - case TYPE_ARRAY: - 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); + } - symbol_t *symbol = entity->base.symbol; - obstack_printf(&obst, "%u%s", strlen(symbol->string), symbol->string); + print_name(entity->base.symbol->string); if (entity->kind == ENTITY_FUNCTION) { - mangle_type(entity->declaration.type); + mangle_parameters(&entity->declaration.type->function); } } @@ -184,55 +254,53 @@ 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_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); - 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\n", size); - break; + case CC_DEFAULT: + case CC_CDECL: + break; + + case CC_STDCALL: + case CC_FASTCALL: { + unsigned size = 0; + for (function_parameter_t const* i = type->function.parameters; i; i = i->next) { + size += get_type_size(i->type); } + 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); @@ -249,22 +317,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); } /** @@ -275,6 +345,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(); }