X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=mangle.c;h=e4f1092bcbce9222c9335627e7bfc8e9356ea01a;hb=070ce965198effd91ca08112df7f41b0e0b5049d;hp=b4149c6402bc65c4fd715c9ad004f5c6e1b9b1b8;hpb=02f47f268839c472e23095ac0025e5ccbb5ed70a;p=cparser

diff --git a/mangle.c b/mangle.c
index b4149c6..e4f1092 100644
--- a/mangle.c
+++ b/mangle.c
@@ -31,81 +31,123 @@
 #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 const char *get_atomic_type_mangle(atomic_type_kind_t kind)
+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_BOOL:        return "b";
-	case ATOMIC_TYPE_CHAR:        return "c";
-	case ATOMIC_TYPE_SCHAR:       return "a";
-	case ATOMIC_TYPE_UCHAR:       return "h";
-	case ATOMIC_TYPE_INT:         return "i";
-	case ATOMIC_TYPE_UINT:        return "j";
-	case ATOMIC_TYPE_SHORT:       return "s";
-	case ATOMIC_TYPE_USHORT:      return "t";
-	case ATOMIC_TYPE_LONG:        return "l";
-	case ATOMIC_TYPE_ULONG:       return "m";
-	case ATOMIC_TYPE_LONGLONG:    return "x";
-	case ATOMIC_TYPE_ULONGLONG:   return "y";
-	case ATOMIC_TYPE_LONG_DOUBLE: return "e";
-	case ATOMIC_TYPE_FLOAT:       return "f";
-	case ATOMIC_TYPE_DOUBLE:      return "d";
+	case ATOMIC_TYPE_VOID:        return 'v';
+	case ATOMIC_TYPE_BOOL:        return 'b';
+	case ATOMIC_TYPE_CHAR:        return 'c';
+	case ATOMIC_TYPE_SCHAR:       return 'a';
+	case ATOMIC_TYPE_UCHAR:       return 'h';
+	case ATOMIC_TYPE_INT:         return 'i';
+	case ATOMIC_TYPE_UINT:        return 'j';
+	case ATOMIC_TYPE_SHORT:       return 's';
+	case ATOMIC_TYPE_USHORT:      return 't';
+	case ATOMIC_TYPE_LONG:        return 'l';
+	case ATOMIC_TYPE_ULONG:       return 'm';
+	case ATOMIC_TYPE_LONGLONG:    return 'x';
+	case ATOMIC_TYPE_ULONGLONG:   return 'y';
+	case ATOMIC_TYPE_LONG_DOUBLE: return 'e';
+	case ATOMIC_TYPE_FLOAT:       return 'f';
+	case ATOMIC_TYPE_DOUBLE:      return 'd';
 	}
 	panic("invalid atomic type in mangler");
 }
 
 static void mangle_atomic_type(const atomic_type_t *type)
 {
-	obstack_printf(&obst, "%s", get_atomic_type_mangle(type->akind));
+	obstack_1grow(&obst, get_atomic_type_mangle(type->akind));
 }
 
 static void mangle_pointer_type(const pointer_type_t *type)
 {
-	obstack_printf(&obst, "P");
+	obstack_1grow(&obst, 'P');
 	mangle_type(type->points_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_printf(&obst, "F");
-	if (type->linkage == sym_C) {
-		obstack_printf(&obst, "Y");
+	obstack_1grow(&obst, 'F');
+	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 mangle_class_enum_type(const entity_base_t *ent)
+{
+	const symbol_t *sym = ent->symbol;
+	if (sym != NULL) {
+		const char *name = sym->string;
+		obstack_printf(&obst, "%u%s", (unsigned) strlen(name), name);
+	} else {
+		/* TODO need the first typedef name here */
+		panic("mangling of unnamed class/enum types not implemented yet");
 	}
-	if (type->variadic) {
-		obstack_printf(&obst, "z");
+}
+
+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");
 	}
-	if (type->unspecified_parameters)
-		panic("can't mangle unspecified parameter types");
-	if (type->kr_style_parameters)
-		panic("can't mangle kr_style_parameters type");
+	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));
+}
 
-	obstack_printf(&obst, "E");
+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 (qualifiers & TYPE_QUALIFIER_CONST)
-		obstack_printf(&obst, "K");
-	if (qualifiers & TYPE_QUALIFIER_VOLATILE)
-		obstack_printf(&obst, "V");
 	if (qualifiers & TYPE_QUALIFIER_RESTRICT)
-		obstack_printf(&obst, "r");
+		obstack_1grow(&obst, 'r');
+	if (qualifiers & TYPE_QUALIFIER_VOLATILE)
+		obstack_1grow(&obst, 'V');
+	if (qualifiers & TYPE_QUALIFIER_CONST)
+		obstack_1grow(&obst, 'K');
 
 	/* handle MS extended qualifiers? */
 }
@@ -126,6 +168,22 @@ static void mangle_type(type_t *orig_type)
 	case TYPE_FUNCTION:
 		mangle_function_type(&type->function);
 		return;
+	case TYPE_COMPOUND_STRUCT:
+	case TYPE_COMPOUND_UNION:
+		mangle_class_enum_type(&type->compound.compound->base);
+		return;
+	case TYPE_ENUM:
+		mangle_class_enum_type(&type->enumt.enume->base);
+		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:
@@ -136,18 +194,35 @@ 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");
 }
 
+static void mangle_entity(entity_t *entity)
+{
+	obstack_1grow(&obst, '_');
+	obstack_1grow(&obst, 'Z');
+
+	/* TODO: mangle scope */
+
+	const char *name = entity->base.symbol->string;
+	obstack_printf(&obst, "%u%s", (unsigned) strlen(name), name);
+
+	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,47 +232,65 @@ 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);
-
-	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) {
-				size += get_type_size_bytes(get_method_param_type(irtype, i));
-			}
-
-			snprintf(buf, sizeof(buf), "@%d", size);
-			return id_mangle3("_", id, buf);
-		}
-	} else {
-		/* always add an underscore in win32 */
-		id = id_mangle(id_underscore, id);
-	}
+	struct obstack *o = &obst;
 
 	assert(is_declaration(entity));
-	decl_modifiers_t decl_modifiers = entity->declaration.modifiers;
-	if (decl_modifiers & DM_DLLIMPORT) {
+
+	if (entity->declaration.modifiers & DM_DLLIMPORT) {
 		/* add prefix for imported symbols */
-		id = id_mangle(id_imp, id);
+		obstack_printf(o, "__imp_");
 	}
-	return id;
-}
 
-static void mangle_entity(entity_t *entity)
-{
-	assert(obstack_object_size(&obst) == 0);
-	obstack_printf(&obst, "_Z");
+	if (entity->kind == ENTITY_FUNCTION) {
+		cc_kind_t cc = entity->declaration.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");
+		}
 
-	/* TODO: mangle scope */
+		switch (entity->declaration.type->function.linkage) {
+			case LINKAGE_INVALID:
+				break;
 
-	symbol_t *symbol = entity->base.symbol;
-	obstack_printf(&obst, "%u%s", strlen(symbol->string), symbol->string);
+			case LINKAGE_C:
+				obstack_printf(o, "%s", entity->base.symbol->string);
+				break;
 
-	if (entity->kind == ENTITY_FUNCTION) {
-		mangle_type(entity->declaration.type);
+			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;
+			}
+
+			default:
+				panic("unhandled calling convention");
+		}
+	} else {
+		obstack_printf(o, "_%s", entity->base.symbol->string);
 	}
+
+	return make_id_from_obst();
 }
 
 /**
@@ -210,26 +303,17 @@ ident *create_name_linux_elf(entity_t *entity)
 {
 	bool needs_mangling = false;
 
-	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) {
+		switch (entity->declaration.type->function.linkage) {
+			case LINKAGE_INVALID: break;
+			case LINKAGE_C:       break;
+			case LINKAGE_CXX:     needs_mangling = true; break;
 		}
 	}
 
 	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 make_id_from_obst();
 	}
 
 	return new_id_from_str(entity->base.symbol->string);
@@ -243,17 +327,12 @@ 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);
+	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);
 }