fix cases where compoundlits are constant/get an entity
[cparser] / mangle.c
index a845a6a..da43b1a 100644 (file)
--- a/mangle.c
+++ b/mangle.c
@@ -1,6 +1,6 @@
 /*
  * This file is part of cparser.
- * Copyright (C) 2007-2008 Matthias Braun <matze@braunis.de>
+ * Copyright (C) 2007-2009 Matthias Braun <matze@braunis.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
 #include "lang_features.h"
 #include "adt/error.h"
 
-static ident          *id_underscore;
-static ident          *id_imp;
-static symbol_t       *sym_C;
-static symbol_t       *sym_stdcall;
-static struct obstack  obst;
+static struct obstack obst;
 
 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';
@@ -60,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)
@@ -74,38 +70,107 @@ 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');
-       if (type->linkage == sym_C) {
+       if (type->linkage == LINKAGE_C) {
                obstack_1grow(&obst, 'Y');
        }
 
        mangle_type(type->return_type);
+       mangle_parameters(type);
 
-       function_parameter_t *parameter = type->parameters;
-       for ( ; parameter != NULL; parameter = parameter->next) {
-               mangle_type(parameter->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;
        }
-       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 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 (qualifiers & TYPE_QUALIFIER_CONST)
-               obstack_1grow(&obst, 'K');
-       if (qualifiers & TYPE_QUALIFIER_VOLATILE)
-               obstack_1grow(&obst, 'V');
+#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)
+               obstack_1grow(&obst, 'K');
 
        /* handle MS extended qualifiers? */
 }
@@ -123,31 +188,75 @@ 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');
+
+       if (entity->base.parent_entity != NULL) {
+               obstack_1grow(&obst, 'N');
+               mangle_namespace(entity);
+       }
+
+       print_name(entity->base.symbol->string);
+
+       if (entity->kind == ENTITY_FUNCTION) {
+               mangle_parameters(&entity->declaration.type->function);
+       }
+}
+
+static ident *make_id_from_obst(void)
+{
+       size_t  size = obstack_object_size(&obst);
+       char   *str  = obstack_finish(&obst);
+       ident  *id   = new_id_from_chars(str, size);
+       obstack_free(&obst, str);
+       return id;
+}
 
 /**
  * Mangles an entity linker (ld) name for win32 usage.
@@ -157,48 +266,64 @@ static void mangle_type(type_t *orig_type)
  */
 ident *create_name_win32(entity_t *entity)
 {
-       ident *id = new_id_from_str(entity->base.symbol->string);
+       struct obstack *o = &obst;
+
+       assert(is_declaration(entity));
 
        if (entity->kind == ENTITY_FUNCTION) {
-               if (entity->declaration.type->function.linkage == sym_stdcall) {
-                       char     buf[16];
-                       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) {
+               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");
+               }
+
+               switch (type->function.linkage) {
+               case LINKAGE_C:
+                       obstack_printf(o, "%s", entity->base.symbol->string);
+                       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;
+               }
 
-                       snprintf(buf, sizeof(buf), "@%d", size);
-                       return id_mangle3("_", id, buf);
+               default:
+                       panic("unhandled calling convention");
                }
        } else {
-               /* always add an underscore in win32 */
-               id = id_mangle(id_underscore, id);
-       }
-
-       assert(is_declaration(entity));
-       decl_modifiers_t decl_modifiers = entity->declaration.modifiers;
-       if (decl_modifiers & DM_DLLIMPORT) {
-               /* add prefix for imported symbols */
-               id = id_mangle(id_imp, id);
+               obstack_printf(o, "_%s", entity->base.symbol->string);
        }
-       return id;
-}
-
-static void mangle_entity(entity_t *entity)
-{
-       assert(obstack_object_size(&obst) == 0);
-       obstack_1grow(&obst, '_');
-       obstack_1grow(&obst, 'Z');
 
-       /* TODO: mangle scope */
-
-       symbol_t *symbol = entity->base.symbol;
-       obstack_printf(&obst, "%u%s", strlen(symbol->string), symbol->string);
-
-       if (entity->kind == ENTITY_FUNCTION) {
-               mangle_type(entity->declaration.type);
-       }
+       return make_id_from_obst();
 }
 
 /**
@@ -209,31 +334,24 @@ static void mangle_entity(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 && (c_mode & _CXX)) {
-               symbol_t *linkage = entity->declaration.type->function.linkage;
-
-               if (linkage == NULL) {
-                       needs_mangling = true;
-               } else if (linkage != sym_C) {
-                       errorf(&entity->base.source_position,
-                              "Unknown linkage type \"%Y\" found\n", linkage);
+       if (entity->kind == ENTITY_FUNCTION) {
+               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);
-               obstack_1grow(&obst, '\0');
-               char *str = obstack_finish(&obst);
-
-               ident *id = new_id_from_str(str);
-               obstack_free(&obst, str);
-
-               return id;
-       }
-
-       return new_id_from_str(entity->base.symbol->string);
+       return new_id_from_str(name);
 }
 
 /**
@@ -244,17 +362,24 @@ ident *create_name_linux_elf(entity_t *entity)
  */
 ident *create_name_macho(entity_t *entity)
 {
-       ident *id = new_id_from_str(entity->base.symbol->string);
-       return id_mangle(id_underscore, id);
+       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();
 }
 
 void init_mangle(void)
 {
-       id_underscore = new_id_from_chars("_", 1);
-       id_imp        = new_id_from_chars("__imp_", 6);
-       sym_C         = symbol_table_insert("C");
-       sym_stdcall   = symbol_table_insert("stdcall");
-
        obstack_init(&obst);
 }