Partially implement mangling of array types.
[cparser] / 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 mangle_class_enum_type(const entity_base_t *ent)
107 {
108         const symbol_t *sym = ent->symbol;
109         if (sym != NULL) {
110                 const char *name = sym->string;
111                 obstack_printf(&obst, "%zu%s", strlen(name), name);
112         } else {
113                 /* TODO need the first typedef name here */
114                 panic("mangling of unnamed class/enum types not implemented yet");
115         }
116 }
117
118 static void mangle_array_type(const array_type_t *type)
119 {
120         if (type->is_vla) {
121                 obstack_printf(&obst, "A_");
122         } else if (type->size_constant) {
123                 obstack_printf(&obst, "A%zu_", type->size);
124         } else {
125                 panic("mangling of non-constant sized arrray types not implemented yet");
126         }
127         mangle_type(type->element_type);
128 }
129
130 static void mangle_qualifiers(type_qualifiers_t qualifiers)
131 {
132         if (qualifiers & TYPE_QUALIFIER_RESTRICT)
133                 obstack_1grow(&obst, 'r');
134         if (qualifiers & TYPE_QUALIFIER_VOLATILE)
135                 obstack_1grow(&obst, 'V');
136         if (qualifiers & TYPE_QUALIFIER_CONST)
137                 obstack_1grow(&obst, 'K');
138
139         /* handle MS extended qualifiers? */
140 }
141
142 static void mangle_type(type_t *orig_type)
143 {
144         type_t *type = skip_typeref(orig_type);
145
146         mangle_qualifiers(type->base.qualifiers);
147
148         switch (type->kind) {
149         case TYPE_ATOMIC:
150                 mangle_atomic_type(&type->atomic);
151                 return;
152         case TYPE_POINTER:
153                 mangle_pointer_type(&type->pointer);
154                 return;
155         case TYPE_FUNCTION:
156                 mangle_function_type(&type->function);
157                 return;
158         case TYPE_COMPOUND_STRUCT:
159         case TYPE_COMPOUND_UNION:
160                 mangle_class_enum_type(&type->compound.compound->base);
161                 return;
162         case TYPE_ENUM:
163                 mangle_class_enum_type(&type->enumt.enume->base);
164                 return;
165         case TYPE_ARRAY:
166                 mangle_array_type(&type->array);
167                 return;
168         case TYPE_INVALID:
169                 panic("invalid type encountered while mangling");
170         case TYPE_ERROR:
171                 panic("error type encountered while mangling");
172         case TYPE_BUILTIN:
173         case TYPE_TYPEDEF:
174         case TYPE_TYPEOF:
175                 panic("typeref not resolved while manging?!?");
176
177         case TYPE_BITFIELD:
178         case TYPE_COMPLEX:
179         case TYPE_IMAGINARY:
180                 panic("no mangling for this type implemented yet");
181                 break;
182         }
183         panic("invalid type encountered while mangling");
184 }
185
186 static void mangle_entity(entity_t *entity)
187 {
188         obstack_1grow(&obst, '_');
189         obstack_1grow(&obst, 'Z');
190
191         /* TODO: mangle scope */
192
193         const char *name = entity->base.symbol->string;
194         obstack_printf(&obst, "%zu%s", strlen(name), name);
195
196         if (entity->kind == ENTITY_FUNCTION) {
197                 mangle_parameters(&entity->declaration.type->function);
198         }
199 }
200
201 static ident *make_id_from_obst(void)
202 {
203         size_t  size = obstack_object_size(&obst);
204         char   *str  = obstack_finish(&obst);
205         ident  *id   = new_id_from_chars(str, size);
206         obstack_free(&obst, str);
207         return id;
208 }
209
210 /**
211  * Mangles an entity linker (ld) name for win32 usage.
212  *
213  * @param ent          the entity to be mangled
214  * @param declaration  the declaration
215  */
216 ident *create_name_win32(entity_t *entity)
217 {
218         struct obstack *o = &obst;
219
220         assert(is_declaration(entity));
221
222         if (entity->declaration.modifiers & DM_DLLIMPORT) {
223                 /* add prefix for imported symbols */
224                 obstack_printf(o, "__imp_");
225         }
226
227         if (entity->kind == ENTITY_FUNCTION) {
228                 cc_kind_t cc = entity->declaration.type->function.calling_convention;
229
230                 /* calling convention prefix */
231                 switch (cc) {
232                         case CC_DEFAULT:
233                         case CC_CDECL:
234                         case CC_STDCALL:  obstack_1grow(o, '_'); break;
235                         case CC_FASTCALL: obstack_1grow(o, '@'); break;
236                         default:          panic("unhandled calling convention");
237                 }
238
239                 switch (entity->declaration.type->function.linkage) {
240                         case LINKAGE_INVALID:
241                                 break;
242
243                         case LINKAGE_C:
244                                 obstack_printf(o, "%s", entity->base.symbol->string);
245                                 break;
246
247                         case LINKAGE_CXX:
248                                 mangle_entity(entity);
249                                 break;
250                 }
251
252                 /* calling convention suffix */
253                 switch (cc) {
254                         case CC_DEFAULT:
255                         case CC_CDECL:
256                                 break;
257
258                         case CC_STDCALL:
259                         case CC_FASTCALL: {
260                                 ir_type *irtype = get_ir_type(entity->declaration.type);
261                                 size_t   size   = 0;
262                                 for (int i = get_method_n_params(irtype) - 1; i >= 0; --i) {
263                                         size += get_type_size_bytes(get_method_param_type(irtype, i));
264                                 }
265                                 obstack_printf(o, "@%zu", size);
266                                 break;
267                         }
268
269                         default:
270                                 panic("unhandled calling convention");
271                 }
272         } else {
273                 obstack_printf(o, "_%s", entity->base.symbol->string);
274         }
275
276         return make_id_from_obst();
277 }
278
279 /**
280  * Mangles an entity linker (ld) name for Linux ELF usage.
281  *
282  * @param ent          the entity to be mangled
283  * @param declaration  the declaration
284  */
285 ident *create_name_linux_elf(entity_t *entity)
286 {
287         bool needs_mangling = false;
288
289         if (entity->kind == ENTITY_FUNCTION) {
290                 switch (entity->declaration.type->function.linkage) {
291                         case LINKAGE_INVALID: break;
292                         case LINKAGE_C:       break;
293                         case LINKAGE_CXX:     needs_mangling = true; break;
294                 }
295         }
296
297         if (needs_mangling) {
298                 mangle_entity(entity);
299                 return make_id_from_obst();
300         }
301
302         return new_id_from_str(entity->base.symbol->string);
303 }
304
305 /**
306  * Mangles an entity linker (ld) name for Mach-O usage.
307  *
308  * @param ent          the entity to be mangled
309  * @param declaration  the declaration
310  */
311 ident *create_name_macho(entity_t *entity)
312 {
313         obstack_printf(&obst, "_%s", entity->base.symbol->string);
314         return make_id_from_obst();
315 }
316
317 void init_mangle(void)
318 {
319         obstack_init(&obst);
320 }
321
322 void exit_mangle(void)
323 {
324         obstack_free(&obst, NULL);
325 }