X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=f8f32b154c441455af19c196da25ab83d3303971;hb=d9c2f28d8ca23867f292a952b0543807d35e672f;hp=83bbb65a1d8e591ccf002256129b1a8dfb73f986;hpb=d198edf1c3dac15f1e8c6456cb4fc15114ffc6e0;p=cparser diff --git a/mangle.c b/mangle.c index 83bbb65..f8f32b1 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,32 @@ 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) + panic("can't mangle unspecified parameter types"); + if (type->kr_style_parameters) + panic("can't mangle kr_style_parameters type"); + + const function_parameter_t *parameter = type->parameters; + if (parameter != NULL) { + for ( ; parameter != NULL; parameter = parameter->next) { + mangle_type(parameter->type); + } + if (type->variadic) { + obstack_1grow(&obst, 'z'); + } + } else { + obstack_1grow(&obst, 'v'); + } +} + static void mangle_function_type(const function_type_t *type) { obstack_1grow(&obst, 'F'); @@ -78,26 +105,69 @@ static void mangle_function_type(const function_type_t *type) } mangle_type(type->return_type); + mangle_parameters(type); + + obstack_1grow(&obst, 'E'); +} - function_parameter_t *parameter = type->parameters; - for ( ; parameter != NULL; parameter = parameter->next) { - mangle_type(parameter->type); +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; } - if (type->variadic) { - obstack_1grow(&obst, 'z'); + 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; } - if (type->unspecified_parameters) - panic("can't mangle unspecified parameter types"); - if (type->kr_style_parameters) - panic("can't mangle kr_style_parameters type"); + print_name(sym->string); +} - obstack_1grow(&obst, 'E'); +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 complex_type_t *type) +{ + obstack_1grow(&obst, 'C'); + obstack_1grow(&obst, get_atomic_type_mangle(type->akind)); +} + +static void mangle_imaginary_type(const imaginary_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) @@ -119,9 +189,28 @@ 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_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->complex); + return; + case TYPE_IMAGINARY: + mangle_imaginary_type(&type->imaginary); + return; case TYPE_INVALID: panic("invalid type encountered while mangling"); case TYPE_ERROR: @@ -132,14 +221,7 @@ static void mangle_type(type_t *orig_type) 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"); } @@ -151,11 +233,10 @@ static void mangle_entity(entity_t *entity) /* TODO: mangle scope */ - 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); } } @@ -180,12 +261,11 @@ 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) { + if (entity->declaration.modifiers & DM_DLLIMPORT) + /* add prefix for imported symbols */ + obstack_printf(o, "__imp_"); + cc_kind_t cc = entity->declaration.type->function.calling_convention; /* calling convention prefix */ @@ -199,7 +279,7 @@ ident *create_name_win32(entity_t *entity) switch (entity->declaration.type->function.linkage) { case LINKAGE_INVALID: - break; + panic("linkage type of function is invalid"); case LINKAGE_C: obstack_printf(o, "%s", entity->base.symbol->string); @@ -218,12 +298,12 @@ ident *create_name_win32(entity_t *entity) case CC_STDCALL: case CC_FASTCALL: { - ir_type *irtype = get_ir_type(entity->declaration.type); - size_t size = 0; + 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, "@%zu\n", size); + obstack_printf(o, "@%u", size); break; } @@ -249,7 +329,9 @@ ident *create_name_linux_elf(entity_t *entity) if (entity->kind == ENTITY_FUNCTION) { switch (entity->declaration.type->function.linkage) { - case LINKAGE_INVALID: break; + case LINKAGE_INVALID: + panic("linkage type of function is invalid"); + case LINKAGE_C: break; case LINKAGE_CXX: needs_mangling = true; break; } @@ -271,6 +353,9 @@ ident *create_name_linux_elf(entity_t *entity) */ ident *create_name_macho(entity_t *entity) { + if (entity->kind == ENTITY_FUNCTION && entity->declaration.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(); }