X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fbe%2Fbedwarf.c;h=5476e16d9760097c0a79203d5e6981d7a79d0b2b;hb=ab85c635582eadf20abe4fca71c1a0ed214b60c6;hp=c270ff08686183e3bb63b7f2a2207aeff71dbfbc;hpb=dcff73b2cc34378750e2cc1979a4b120e19767a9;p=libfirm

diff --git a/ir/be/bedwarf.c b/ir/be/bedwarf.c
index c270ff086..5476e16d9 100644
--- a/ir/be/bedwarf.c
+++ b/ir/be/bedwarf.c
@@ -28,7 +28,9 @@
 #include <stdlib.h>
 #include <assert.h>
 
+#include "bearch.h"
 #include "bedwarf_t.h"
+#include "error.h"
 #include "obst.h"
 #include "irprog.h"
 #include "irgraph.h"
@@ -48,6 +50,7 @@
 #include "beemitter.h"
 #include "dbginfo.h"
 #include "begnuas.h"
+#include "typerep.h"
 
 enum {
 	LEVEL_NONE,
@@ -63,12 +66,25 @@ static int debug_level = LEVEL_NONE;
  * here
  */
 typedef enum custom_abbrevs {
-	abbrev_void_pointer_type = 100,
+	abbrev_void_subprogram = 1,
+	abbrev_subprogram,
+	abbrev_formal_parameter,
 	abbrev_unnamed_formal_parameter,
 	abbrev_formal_parameter_no_location,
-	abbrev_void_subroutine_type,
-	abbrev_void_subprogram,
+	abbrev_variable,
+	abbrev_compile_unit,
+	abbrev_base_type,
+	abbrev_pointer_type,
+	abbrev_void_pointer_type,
+	abbrev_array_type,
+	abbrev_subrange_type,
+	abbrev_structure_type,
+	abbrev_union_type,
+	abbrev_class_type,
+	abbrev_member,
 	abbrev_bitfield_member,
+	abbrev_subroutine_type,
+	abbrev_void_subroutine_type,
 } custom_abbrevs;
 
 /**
@@ -95,7 +111,7 @@ static char                 *comp_dir;
 static unsigned insert_file(const char *filename)
 {
 	unsigned num;
-	void    *entry = pmap_get(env.file_map, filename);
+	void    *entry = pmap_get(void, env.file_map, filename);
 	if (entry != NULL) {
 		return PTR_TO_INT(entry);
 	}
@@ -158,13 +174,6 @@ static unsigned get_sleb128_size(long value)
 	return size;
 }
 
-static void emit_string(const char *string)
-{
-	/* TODO: quote special chars */
-	be_emit_irprintf("\t.asciz \"%s\"\n", string);
-	be_emit_write_line();
-}
-
 static void emit_ref(const ir_entity *entity)
 {
 	be_emit_cstring("\t.long ");
@@ -220,7 +229,8 @@ static void register_attribute(dwarf_attribute attribute, dwarf_form form)
 	emit_uleb128(form);
 }
 
-static void begin_abbrev(unsigned code, dwarf_tag tag, dw_children children)
+static void begin_abbrev(custom_abbrevs code, dwarf_tag tag,
+                         dw_children children)
 {
 	emit_uleb128(code);
 	emit_uleb128(tag);
@@ -265,12 +275,12 @@ static void emit_line_info(void)
 		emit_uleb128(1);
 
 		/* include directory list */
-		emit_string("/foo/bar");
+		be_gas_emit_cstring("/foo/bar");
 		emit_int8(0);
 
 		/* file list */
 		for (i = 0; i < ARR_LEN(env.file_list); ++i) {
-			emit_string(env.file_list[i]);
+			be_gas_emit_cstring(env.file_list[i]);
 			emit_uleb128(1); /* directory */
 			emit_uleb128(0); /* modification time */
 			emit_uleb128(0); /* file length */
@@ -303,7 +313,7 @@ static void emit_pubnames(void)
 		be_emit_irprintf("\t.long %sE%ld - %sinfo_begin\n",
 		                 be_gas_get_private_prefix(),
 		                 get_entity_nr(entity), be_gas_get_private_prefix());
-		emit_string(get_entity_name(entity));
+		be_gas_emit_cstring(get_entity_name(entity));
 	}
 	emit_int32(0);
 
@@ -392,7 +402,7 @@ static void emit_type_address(const ir_type *type)
 
 static void emit_subprogram_abbrev(void)
 {
-	begin_abbrev(DW_TAG_subprogram, DW_TAG_subprogram, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_subprogram, DW_TAG_subprogram, DW_CHILDREN_yes);
 	register_attribute(DW_AT_name,      DW_FORM_string);
 	register_dbginfo_attributes();
 	register_attribute(DW_AT_type,       DW_FORM_ref4);
@@ -415,7 +425,7 @@ static void emit_subprogram_abbrev(void)
 		register_attribute(DW_AT_frame_base, DW_FORM_block1);
 	end_abbrev();
 
-	begin_abbrev(DW_TAG_formal_parameter, DW_TAG_formal_parameter,
+	begin_abbrev(abbrev_formal_parameter, DW_TAG_formal_parameter,
 	             DW_CHILDREN_no);
 	register_attribute(DW_AT_name,      DW_FORM_string);
 	register_dbginfo_attributes();
@@ -453,7 +463,7 @@ static void emit_function_parameters(const ir_entity *entity,
 
 		if (infos != NULL && infos[i].entity != NULL) {
 			long const offset = get_entity_offset(infos[i].entity);
-			emit_uleb128(DW_TAG_formal_parameter);
+			emit_uleb128(abbrev_formal_parameter);
 			emit_string_printf("arg%u", (unsigned)i);
 			emit_dbginfo(dbgi);
 			emit_type_address(param_type);
@@ -490,8 +500,8 @@ void be_dwarf_method_before(const ir_entity *entity,
 	}
 
 	emit_entity_label(entity);
-	emit_uleb128(n_ress == 0 ? abbrev_void_subprogram : DW_TAG_subprogram);
-	emit_string(get_entity_ld_name(entity));
+	emit_uleb128(n_ress == 0 ? abbrev_void_subprogram : abbrev_subprogram);
+	be_gas_emit_cstring(get_entity_ld_name(entity));
 	emit_dbginfo(get_entity_dbg_info(entity));
 	if (n_ress > 0) {
 		ir_type *res = get_method_res_type(type, 0);
@@ -538,7 +548,7 @@ void be_dwarf_method_end(void)
 
 static void emit_base_type_abbrev(void)
 {
-	begin_abbrev(DW_TAG_base_type, DW_TAG_base_type, DW_CHILDREN_no);
+	begin_abbrev(abbrev_base_type, DW_TAG_base_type, DW_CHILDREN_no);
 	register_attribute(DW_AT_encoding,  DW_FORM_data1);
 	register_attribute(DW_AT_byte_size, DW_FORM_data1);
 	register_attribute(DW_AT_name,      DW_FORM_string);
@@ -558,7 +568,7 @@ static void emit_base_type(const ir_type *type)
 	ir_print_type(buf, sizeof(buf), type);
 
 	emit_type_label(type);
-	emit_uleb128(DW_TAG_base_type);
+	emit_uleb128(abbrev_base_type);
 	if (mode_is_int(mode)) {
 		/* bool hack */
 		if (strcmp(buf, "_Bool")==0 || strcmp(buf, "bool")==0) {
@@ -574,12 +584,12 @@ static void emit_base_type(const ir_type *type)
 		panic("mode not implemented yet");
 	}
 	emit_int8(get_mode_size_bytes(mode));
-	emit_string(buf);
+	be_gas_emit_cstring(buf);
 }
 
 static void emit_pointer_type_abbrev(void)
 {
-	begin_abbrev(DW_TAG_pointer_type, DW_TAG_pointer_type, DW_CHILDREN_no);
+	begin_abbrev(abbrev_pointer_type, DW_TAG_pointer_type, DW_CHILDREN_no);
 	register_attribute(DW_AT_type,      DW_FORM_ref4);
 	register_attribute(DW_AT_byte_size, DW_FORM_data1);
 	end_abbrev();
@@ -600,7 +610,7 @@ static void emit_pointer_type(const ir_type *type)
 		emit_type(points_to);
 
 		emit_type_label(type);
-		emit_uleb128(DW_TAG_pointer_type);
+		emit_uleb128(abbrev_pointer_type);
 		emit_type_address(points_to);
 	} else {
 		emit_type_label(type);
@@ -611,11 +621,11 @@ static void emit_pointer_type(const ir_type *type)
 
 static void emit_array_type_abbrev(void)
 {
-	begin_abbrev(DW_TAG_array_type, DW_TAG_array_type, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_array_type, DW_TAG_array_type, DW_CHILDREN_yes);
 	register_attribute(DW_AT_type, DW_FORM_ref4);
 	end_abbrev();
 
-	begin_abbrev(DW_TAG_subrange_type, DW_TAG_subrange_type, DW_CHILDREN_no);
+	begin_abbrev(abbrev_subrange_type, DW_TAG_subrange_type, DW_CHILDREN_no);
 	register_attribute(DW_AT_upper_bound, DW_FORM_udata);
 	end_abbrev();
 }
@@ -625,17 +635,17 @@ static void emit_array_type(const ir_type *type)
 	ir_type *element_type = get_array_element_type(type);
 
 	if (get_array_n_dimensions(type) != 1)
-		panic("dwarf: multidimensional arrays no supported yet");
+		panic("multidimensional arrays no supported yet");
 
 	emit_type(element_type);
 
 	emit_type_label(type);
-	emit_uleb128(DW_TAG_array_type);
+	emit_uleb128(abbrev_array_type);
 	emit_type_address(element_type);
 
 	if (has_array_upper_bound(type, 0)) {
 		int bound = get_array_upper_bound_int(type, 0);
-		emit_uleb128(DW_TAG_subrange_type);
+		emit_uleb128(abbrev_subrange_type);
 		emit_uleb128(bound);
 	}
 
@@ -644,22 +654,22 @@ static void emit_array_type(const ir_type *type)
 
 static void emit_compound_type_abbrev(void)
 {
-	begin_abbrev(DW_TAG_structure_type, DW_TAG_structure_type, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_structure_type, DW_TAG_structure_type, DW_CHILDREN_yes);
 	register_attribute(DW_AT_byte_size,  DW_FORM_udata);
 	// TODO register_dbginfo_attributes();
 	end_abbrev();
 
-	begin_abbrev(DW_TAG_union_type, DW_TAG_union_type, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_union_type, DW_TAG_union_type, DW_CHILDREN_yes);
 	register_attribute(DW_AT_byte_size,  DW_FORM_udata);
 	// TODO register_dbginfo_attributes();
 	end_abbrev();
 
-	begin_abbrev(DW_TAG_class_type, DW_TAG_class_type, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_class_type, DW_TAG_class_type, DW_CHILDREN_yes);
 	register_attribute(DW_AT_byte_size,  DW_FORM_udata);
 	// TODO register_dbginfo_attributes();
 	end_abbrev();
 
-	begin_abbrev(DW_TAG_member, DW_TAG_member, DW_CHILDREN_no);
+	begin_abbrev(abbrev_member, DW_TAG_member, DW_CHILDREN_no);
 	register_attribute(DW_AT_type,                 DW_FORM_ref4);
 	register_attribute(DW_AT_name,                 DW_FORM_string);
 	register_dbginfo_attributes();
@@ -701,12 +711,12 @@ static void emit_compound_type(const ir_type *type)
 
 	emit_type_label(type);
 	if (is_Struct_type(type)) {
-		emit_uleb128(DW_TAG_structure_type);
+		emit_uleb128(abbrev_structure_type);
 	} else if (is_Union_type(type)) {
-		emit_uleb128(DW_TAG_union_type);
+		emit_uleb128(abbrev_union_type);
 	} else {
 		assert(is_Class_type(type));
-		emit_uleb128(DW_TAG_class_type);
+		emit_uleb128(abbrev_class_type);
 	}
 	emit_uleb128(get_type_size_bytes(type));
 	for (i = 0; i < n_members; ++i) {
@@ -730,11 +740,11 @@ static void emit_compound_type(const ir_type *type)
 			emit_uleb128(bit_offset);
 			member_type = base;
 		} else {
-			emit_uleb128(DW_TAG_member);
+			emit_uleb128(abbrev_member);
 		}
 
 		emit_type_address(member_type);
-		emit_string(get_entity_name(member));
+		be_gas_emit_cstring(get_entity_name(member));
 		emit_dbginfo(get_entity_dbg_info(member));
 		assert(offset >= 0);
 		emit_int8(1 + get_uleb128_size(offset));
@@ -746,7 +756,7 @@ static void emit_compound_type(const ir_type *type)
 
 static void emit_subroutine_type_abbrev(void)
 {
-	begin_abbrev(DW_TAG_subroutine_type,
+	begin_abbrev(abbrev_subroutine_type,
 	             DW_TAG_subroutine_type, DW_CHILDREN_yes);
 	register_attribute(DW_AT_prototyped,   DW_FORM_flag);
 	register_attribute(DW_AT_type,         DW_FORM_ref4);
@@ -778,7 +788,7 @@ static void emit_subroutine_type(const ir_type *type)
 	}
 
 	emit_type_label(type);
-	emit_uleb128(n_ress == 0 ? abbrev_void_subroutine_type : DW_TAG_subroutine_type);
+	emit_uleb128(n_ress == 0 ? abbrev_void_subroutine_type : abbrev_subroutine_type);
 	emit_int8(1); /* prototyped */
 	if (n_ress > 0) {
 		/* dwarf only supports 1 return type */
@@ -796,7 +806,7 @@ static void emit_subroutine_type(const ir_type *type)
 
 static void emit_type(ir_type *type)
 {
-	if (pset_new_insert(&env.emitted_types, type))
+	if (!pset_new_insert(&env.emitted_types, type))
 		return;
 
 	switch (get_type_tpop_code(type)) {
@@ -808,7 +818,7 @@ static void emit_type(ir_type *type)
 	case tpo_union:     emit_compound_type(type);   break;
 	case tpo_method:    emit_subroutine_type(type); break;
 	default:
-		panic("bedwarf: type %+F not implemented yet", type);
+		panic("type %+F not implemented yet", type);
 	}
 }
 
@@ -823,7 +833,7 @@ static void emit_op_addr(const ir_entity *entity)
 
 static void emit_variable_abbrev(void)
 {
-	begin_abbrev(DW_TAG_variable, DW_TAG_variable, DW_CHILDREN_no);
+	begin_abbrev(abbrev_variable, DW_TAG_variable, DW_CHILDREN_no);
 	register_attribute(DW_AT_name,      DW_FORM_string);
 	register_attribute(DW_AT_type,      DW_FORM_ref4);
 	register_attribute(DW_AT_external,  DW_FORM_flag);
@@ -848,8 +858,8 @@ void be_dwarf_variable(const ir_entity *entity)
 	emit_type(type);
 
 	emit_entity_label(entity);
-	emit_uleb128(DW_TAG_variable);
-	emit_string(get_entity_ld_name(entity));
+	emit_uleb128(abbrev_variable);
+	be_gas_emit_cstring(get_entity_ld_name(entity));
 	emit_type_address(type);
 	emit_int8(is_extern_entity(entity));
 	emit_dbginfo(get_entity_dbg_info(entity));
@@ -862,7 +872,7 @@ void be_dwarf_variable(const ir_entity *entity)
 
 static void emit_compile_unit_abbrev(void)
 {
-	begin_abbrev(DW_TAG_compile_unit, DW_TAG_compile_unit, DW_CHILDREN_yes);
+	begin_abbrev(abbrev_compile_unit, DW_TAG_compile_unit, DW_CHILDREN_yes);
 	register_attribute(DW_AT_stmt_list, DW_FORM_data4);
 	register_attribute(DW_AT_producer,  DW_FORM_string);
 	register_attribute(DW_AT_name,      DW_FORM_string);
@@ -901,24 +911,25 @@ void be_dwarf_unit_begin(const char *filename)
 	emit_label("info_section_begin");
 	emit_label("info_begin");
 
+	const backend_params *be_params = be_get_backend_param();
+
 	/* length of compilation unit info */
 	emit_size("compile_unit_begin", "compile_unit_end");
 	emit_label("compile_unit_begin");
 	emit_int16(3);   /* dwarf version */
 	emit_address("abbrev_begin");
-	emit_int8(4);    /* pointer size, TODO: query backend */
+	emit_int8(be_params->machine_size / 8); /* pointer size */
 
 	/* compile_unit die */
-	emit_uleb128(DW_TAG_compile_unit);
+	emit_uleb128(abbrev_compile_unit);
 	emit_address("line_section_begin");
 	emit_string_printf("libFirm (%u.%u %s)", ir_get_version_major(),
-	                   ir_get_version_minor(),
-	                   ir_get_version_revision());
-	emit_string(filename);
+	                   ir_get_version_minor(), ir_get_version_revision());
+	be_gas_emit_cstring(filename);
 	if (language != 0)
 		emit_int16(language);
 	if (comp_dir != NULL)
-		emit_string(comp_dir);
+		be_gas_emit_cstring(comp_dir);
 
 	/* tell gas to emit cfi in debug_frame
 	 * TODO: if we produce exception handling code then this should be
@@ -972,8 +983,7 @@ void be_dwarf_set_source_language(dwarf_source_language new_language)
 
 void be_dwarf_set_compilation_directory(const char *new_comp_dir)
 {
-	if (comp_dir != NULL)
-		xfree(comp_dir);
+	xfree(comp_dir);
 	comp_dir = xstrdup(new_comp_dir);
 }