rewrite of attribute handling

[cparser] / mangle.c

diff --git a/mangle.c b/mangle.c
index 467ca4e..98fc1d7 100644 (file)
--- a/mangle.c
+++ b/mangle.c
@@ -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)
@@ -103,22 +110,64 @@ static void mangle_function_type(const function_type_t *type)
        obstack_1grow(&obst, 'E');
 }
 
-static void mangle_compound_type(const compound_type_t *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) {
-               const char *name = sym->string;
-               obstack_printf(&obst, "%zu%s", strlen(name), name);
+       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 {
-               /* TODO need the first typedef name here */
-               panic("mangling of unnamed compound 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)
+{
+       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)
@@ -140,12 +189,27 @@ 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_compound_type(&type->compound);
+               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");
@@ -157,12 +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_ENUM:
-       case TYPE_ARRAY:
                panic("no mangling for this type implemented yet");
-               break;
        }
        panic("invalid type encountered while mangling");
 }
@@ -174,8 +233,7 @@ static void mangle_entity(entity_t *entity)
 
        /* TODO: mangle scope */
 
-       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);
@@ -203,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 */
@@ -222,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);
@@ -241,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", size);
+                               obstack_printf(o, "@%u", size);
                                break;
                        }
 
@@ -272,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;
                }
@@ -294,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();
 }