nsz Git - cparser/blob - mangle.c

   1 /*
   2  * This file is part of cparser.
   3  * Copyright (C) 2007-2008 Matthias Braun <matze@braunis.de>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20 #include <config.h>
  21
  22 #include <libfirm/firm.h>
  23 #include <string.h>
  24
  25 #include "entity_t.h"
  26 #include "type_t.h"
  27 #include "symbol_t.h"
  28 #include "mangle.h"
  29 #include "diagnostic.h"
  30 #include "ast2firm.h"
  31 #include "lang_features.h"
  32 #include "adt/error.h"
  33
  34 static struct obstack obst;
  35
  36 static void mangle_type(type_t *type);
  37
  38 static char get_atomic_type_mangle(atomic_type_kind_t kind)
  39 {
  40         switch (kind) {
  41         case ATOMIC_TYPE_INVALID: break;
  42         case ATOMIC_TYPE_VOID:        return 'v';
  43         case ATOMIC_TYPE_BOOL:        return 'b';
  44         case ATOMIC_TYPE_CHAR:        return 'c';
  45         case ATOMIC_TYPE_SCHAR:       return 'a';
  46         case ATOMIC_TYPE_UCHAR:       return 'h';
  47         case ATOMIC_TYPE_INT:         return 'i';
  48         case ATOMIC_TYPE_UINT:        return 'j';
  49         case ATOMIC_TYPE_SHORT:       return 's';
  50         case ATOMIC_TYPE_USHORT:      return 't';
  51         case ATOMIC_TYPE_LONG:        return 'l';
  52         case ATOMIC_TYPE_ULONG:       return 'm';
  53         case ATOMIC_TYPE_LONGLONG:    return 'x';
  54         case ATOMIC_TYPE_ULONGLONG:   return 'y';
  55         case ATOMIC_TYPE_LONG_DOUBLE: return 'e';
  56         case ATOMIC_TYPE_FLOAT:       return 'f';
  57         case ATOMIC_TYPE_DOUBLE:      return 'd';
  58         }
  59         panic("invalid atomic type in mangler");
  60 }
  61
  62 static void mangle_atomic_type(const atomic_type_t *type)
  63 {
  64         obstack_1grow(&obst, get_atomic_type_mangle(type->akind));
  65 }
  66
  67 static void mangle_pointer_type(const pointer_type_t *type)
  68 {
  69         obstack_1grow(&obst, 'P');
  70         mangle_type(type->points_to);
  71 }
  72
  73 static void mangle_parameters(const function_type_t *type)
  74 {
  75         if (type->unspecified_parameters)
  76                 panic("can't mangle unspecified parameter types");
  77         if (type->kr_style_parameters)
  78                 panic("can't mangle kr_style_parameters type");
  79
  80         const function_parameter_t *parameter = type->parameters;
  81         if (parameter != NULL) {
  82                 for ( ; parameter != NULL; parameter = parameter->next) {
  83                         mangle_type(parameter->type);
  84                 }
  85                 if (type->variadic) {
  86                         obstack_1grow(&obst, 'z');
  87                 }
  88         } else {
  89                 obstack_1grow(&obst, 'v');
  90         }
  91 }
  92
  93 static void mangle_function_type(const function_type_t *type)
  94 {
  95         obstack_1grow(&obst, 'F');
  96         if (type->linkage == LINKAGE_C) {
  97                 obstack_1grow(&obst, 'Y');
  98         }
  99
 100         mangle_type(type->return_type);
 101         mangle_parameters(type);
 102
 103         obstack_1grow(&obst, 'E');
 104 }
 105
 106 static void print_name(const char* name)
 107 {
 108         obstack_printf(&obst, "%u%s", (unsigned)strlen(name), name);
 109 }
 110
 111 static void mangle_class_type(const compound_type_t *type)
 112 {
 113         const symbol_t *sym = type->compound->base.symbol;
 114         if (sym == NULL) {
 115                 if (type->compound->alias == NULL)
 116                         panic("mangling anonymous type");
 117                 sym = type->compound->alias->base.symbol;
 118         }
 119         print_name(sym->string);
 120 }
 121
 122 static void mangle_enum_type(const enum_type_t *type)
 123 {
 124         const symbol_t *sym = type->enume->base.symbol;
 125         if (sym == NULL) {
 126                 if (type->enume->alias == NULL)
 127                         panic("mangling anonymous type");
 128                 sym = type->enume->alias->base.symbol;
 129         }
 130         print_name(sym->string);
 131 }
 132
 133 static void mangle_array_type(const array_type_t *type)
 134 {
 135         if (type->is_vla) {
 136                 obstack_1grow(&obst, 'A');
 137                 obstack_1grow(&obst, '_');
 138         } else if (type->size_constant) {
 139                 obstack_printf(&obst, "A%u_", (unsigned) type->size);
 140         } else {
 141                 panic("mangling of non-constant sized array types not implemented yet");
 142         }
 143         mangle_type(type->element_type);
 144 }
 145
 146 static void mangle_complex_type(const complex_type_t *type)
 147 {
 148         obstack_1grow(&obst, 'C');
 149         obstack_1grow(&obst, get_atomic_type_mangle(type->akind));
 150 }
 151
 152 static void mangle_imaginary_type(const imaginary_type_t *type)
 153 {
 154         obstack_1grow(&obst, 'G');
 155         obstack_1grow(&obst, get_atomic_type_mangle(type->akind));
 156 }
 157
 158 static void mangle_qualifiers(type_qualifiers_t qualifiers)
 159 {
 160 #if 0 /* Do not mangle restrict qualifiers.  GCC doesn't either */
 161         if (qualifiers & TYPE_QUALIFIER_RESTRICT)
 162                 obstack_1grow(&obst, 'r');
 163 #endif
 164         if (qualifiers & TYPE_QUALIFIER_VOLATILE)
 165                 obstack_1grow(&obst, 'V');
 166         if (qualifiers & TYPE_QUALIFIER_CONST)
 167                 obstack_1grow(&obst, 'K');
 168
 169         /* handle MS extended qualifiers? */
 170 }
 171
 172 static void mangle_type(type_t *orig_type)
 173 {
 174         type_t *type = skip_typeref(orig_type);
 175
 176         mangle_qualifiers(type->base.qualifiers);
 177
 178         switch (type->kind) {
 179         case TYPE_ATOMIC:
 180                 mangle_atomic_type(&type->atomic);
 181                 return;
 182         case TYPE_POINTER:
 183                 mangle_pointer_type(&type->pointer);
 184                 return;
 185         case TYPE_FUNCTION:
 186                 mangle_function_type(&type->function);
 187                 return;
 188         case TYPE_COMPOUND_STRUCT:
 189         case TYPE_COMPOUND_UNION:
 190                 mangle_class_type(&type->compound);
 191                 return;
 192         case TYPE_ENUM:
 193                 mangle_enum_type(&type->enumt);
 194                 return;
 195         case TYPE_ARRAY:
 196                 mangle_array_type(&type->array);
 197                 return;
 198         case TYPE_COMPLEX:
 199                 mangle_complex_type(&type->complex);
 200                 return;
 201         case TYPE_IMAGINARY:
 202                 mangle_imaginary_type(&type->imaginary);
 203                 return;
 204         case TYPE_INVALID:
 205                 panic("invalid type encountered while mangling");
 206         case TYPE_ERROR:
 207                 panic("error type encountered while mangling");
 208         case TYPE_BUILTIN:
 209         case TYPE_TYPEDEF:
 210         case TYPE_TYPEOF:
 211                 panic("typeref not resolved while manging?!?");
 212
 213         case TYPE_BITFIELD:
 214                 panic("no mangling for this type implemented yet");
 215                 break;
 216         }
 217         panic("invalid type encountered while mangling");
 218 }
 219
 220 static void mangle_entity(entity_t *entity)
 221 {
 222         obstack_1grow(&obst, '_');
 223         obstack_1grow(&obst, 'Z');
 224
 225         /* TODO: mangle scope */
 226
 227         print_name(entity->base.symbol->string);
 228
 229         if (entity->kind == ENTITY_FUNCTION) {
 230                 mangle_parameters(&entity->declaration.type->function);
 231         }
 232 }
 233
 234 static ident *make_id_from_obst(void)
 235 {
 236         size_t  size = obstack_object_size(&obst);
 237         char   *str  = obstack_finish(&obst);
 238         ident  *id   = new_id_from_chars(str, size);
 239         obstack_free(&obst, str);
 240         return id;
 241 }
 242
 243 /**
 244  * Mangles an entity linker (ld) name for win32 usage.
 245  *
 246  * @param ent          the entity to be mangled
 247  * @param declaration  the declaration
 248  */
 249 ident *create_name_win32(entity_t *entity)
 250 {
 251         struct obstack *o = &obst;
 252
 253         assert(is_declaration(entity));
 254
 255         if (entity->declaration.modifiers & DM_DLLIMPORT) {
 256                 /* add prefix for imported symbols */
 257                 obstack_printf(o, "__imp_");
 258         }
 259
 260         if (entity->kind == ENTITY_FUNCTION) {
 261                 cc_kind_t cc = entity->declaration.type->function.calling_convention;
 262
 263                 /* calling convention prefix */
 264                 switch (cc) {
 265                         case CC_DEFAULT:
 266                         case CC_CDECL:
 267                         case CC_STDCALL:  obstack_1grow(o, '_'); break;
 268                         case CC_FASTCALL: obstack_1grow(o, '@'); break;
 269                         default:          panic("unhandled calling convention");
 270                 }
 271
 272                 switch (entity->declaration.type->function.linkage) {
 273                         case LINKAGE_INVALID:
 274                                 break;
 275
 276                         case LINKAGE_C:
 277                                 obstack_printf(o, "%s", entity->base.symbol->string);
 278                                 break;
 279
 280                         case LINKAGE_CXX:
 281                                 mangle_entity(entity);
 282                                 break;
 283                 }
 284
 285                 /* calling convention suffix */
 286                 switch (cc) {
 287                         case CC_DEFAULT:
 288                         case CC_CDECL:
 289                                 break;
 290
 291                         case CC_STDCALL:
 292                         case CC_FASTCALL: {
 293                                 ir_type  *irtype = get_ir_type(entity->declaration.type);
 294                                 unsigned size    = 0;
 295                                 for (int i = get_method_n_params(irtype) - 1; i >= 0; --i) {
 296                                         size += get_type_size_bytes(get_method_param_type(irtype, i));
 297                                 }
 298                                 obstack_printf(o, "@%u", size);
 299                                 break;
 300                         }
 301
 302                         default:
 303                                 panic("unhandled calling convention");
 304                 }
 305         } else {
 306                 obstack_printf(o, "_%s", entity->base.symbol->string);
 307         }
 308
 309         return make_id_from_obst();
 310 }
 311
 312 /**
 313  * Mangles an entity linker (ld) name for Linux ELF usage.
 314  *
 315  * @param ent          the entity to be mangled
 316  * @param declaration  the declaration
 317  */
 318 ident *create_name_linux_elf(entity_t *entity)
 319 {
 320         bool needs_mangling = false;
 321
 322         if (entity->kind == ENTITY_FUNCTION) {
 323                 switch (entity->declaration.type->function.linkage) {
 324                         case LINKAGE_INVALID: break;
 325                         case LINKAGE_C:       break;
 326                         case LINKAGE_CXX:     needs_mangling = true; break;
 327                 }
 328         }
 329
 330         if (needs_mangling) {
 331                 mangle_entity(entity);
 332                 return make_id_from_obst();
 333         }
 334
 335         return new_id_from_str(entity->base.symbol->string);
 336 }
 337
 338 /**
 339  * Mangles an entity linker (ld) name for Mach-O usage.
 340  *
 341  * @param ent          the entity to be mangled
 342  * @param declaration  the declaration
 343  */
 344 ident *create_name_macho(entity_t *entity)
 345 {
 346         obstack_printf(&obst, "_%s", entity->base.symbol->string);
 347         return make_id_from_obst();
 348 }
 349
 350 void init_mangle(void)
 351 {
 352         obstack_init(&obst);
 353 }
 354
 355 void exit_mangle(void)
 356 {
 357         obstack_free(&obst, NULL);
 358 }