X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbegnuas.c;h=22822e81ab8a2182297f62b2c8232e72078979f9;hb=15769c9f67d00b398ff43e013eddbe5269ba5787;hp=8efcb032182650cf025be2621ccd5fb4079e85c1;hpb=60258990cbbf12fc1ab4802fe4b2c7f9a99afbc2;p=libfirm

diff --git a/ir/be/begnuas.c b/ir/be/begnuas.c
index 8efcb0321..22822e81a 100644
--- a/ir/be/begnuas.c
+++ b/ir/be/begnuas.c
@@ -24,9 +24,7 @@
  * @date        04.11.2005
  * @version     $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include "begnuas.h"
 
@@ -69,7 +67,10 @@ static const char *get_section_name(be_gas_section_t section) {
 			".section\t.bss",
 			".section\t.tbss,\"awT\",@nobits",
 			".section\t.ctors,\"aw\",@progbits",
+			".section\t.dtors,\"aw\",@progbits",
+			NULL, /* no cstring section */
 			NULL,
+			NULL
 		},
 		{ /* GAS_FLAVOUR_MINGW */
 			".section\t.text",
@@ -77,8 +78,11 @@ static const char *get_section_name(be_gas_section_t section) {
 			".section .rdata,\"dr\"",
 			".section\t.bss",
 			".section\t.tbss,\"awT\",@nobits",
-			".section\t.ctors,\"aw\",@progbits",
+			".section\t.ctors,\"w\"",
+			".section\t.dtors,\"w\"",
+			NULL,
 			NULL,
+			NULL
 		},
 		{ /* GAS_FLAVOUR_YASM */
 			".section\t.text",
@@ -87,6 +91,9 @@ static const char *get_section_name(be_gas_section_t section) {
 			".section\t.bss",
 			".section\t.tbss,\"awT\",@nobits",
 			".section\t.ctors,\"aw\",@progbits",
+			".section\t.dtors,\"aw\",@progbits",
+			NULL,
+			NULL,
 			NULL
 		},
 		{ /* GAS_FLAVOUR_MACH_O */
@@ -96,7 +103,10 @@ static const char *get_section_name(be_gas_section_t section) {
 			".data",
 			NULL,             /* TLS is not supported on Mach-O */
 			".mod_init_func",
-			".cstring"
+			NULL,             /* TODO: how is this called? */
+			".cstring",
+			".section\t__IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5",
+			".section\t__IMPORT,__pointers,non_lazy_symbol_pointers"
 		}
 	};
 
@@ -106,7 +116,7 @@ static const char *get_section_name(be_gas_section_t section) {
 }
 
 void be_gas_emit_switch_section(be_gas_section_t section) {
-	if(current_section == section)
+	if (current_section == section)
 		return;
 
 	be_emit_char('\t');
@@ -119,6 +129,8 @@ void be_gas_emit_switch_section(be_gas_section_t section) {
 void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment)
 {
 	const char *name = get_entity_ld_name(entity);
+	const char *fill_byte = "";
+	unsigned maximum_skip;
 
 	be_gas_emit_switch_section(GAS_SECTION_TEXT);
 
@@ -129,17 +141,17 @@ void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment)
 	be_emit_char('\n');
 	be_emit_write_line();
 
-	const char *fill_byte = "";
 	/* gcc fills space between function with 0x90, no idea if this is needed */
-	if(be_gas_flavour == GAS_FLAVOUR_MACH_O) {
+	if (be_gas_flavour == GAS_FLAVOUR_MACH_O) {
 		fill_byte = "0x90";
 	}
 
-	unsigned maximum_skip = (1 << alignment) - 1;
-	be_emit_cstring("\t.p2align ");
-	be_emit_irprintf("%u,%s,%u\n", alignment, fill_byte, maximum_skip);
-	be_emit_write_line();
-
+	if (alignment > 0) {
+		maximum_skip = (1 << alignment) - 1;
+		be_emit_cstring("\t.p2align ");
+		be_emit_irprintf("%u,%s,%u\n", alignment, fill_byte, maximum_skip);
+		be_emit_write_line();
+	}
 	if (get_entity_visibility(entity) == visibility_external_visible) {
 		be_emit_cstring(".globl ");
 		be_emit_string(name);
@@ -157,7 +169,11 @@ void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment)
 	case GAS_FLAVOUR_MINGW:
 		be_emit_cstring("\t.def\t");
 		be_emit_string(name);
-		be_emit_cstring(";\t.scl\t2;\t.type\t32;\t.endef\n");
+		if (get_entity_visibility(entity) == visibility_external_visible) {
+			be_emit_cstring(";\t.scl\t2;\t.type\t32;\t.endef\n");
+		} else {
+			be_emit_cstring(";\t.scl\t3;\t.type\t32;\t.endef\n");
+		}
 		be_emit_write_line();
 		break;
 	case GAS_FLAVOUR_MACH_O:
@@ -195,9 +211,8 @@ void be_gas_emit_function_epilog(ir_entity *entity)
  * and even there NOT needed. So we might change it in the future.
  */
 typedef struct _be_gas_decl_env {
-	const be_main_env_t *main_env; /**< The main backend environment, used for it's debug handle. */
-	int                  dump_tls;
-	waitq     *worklist;           /**< A worklist we use to place not yet handled entities on. */
+	be_gas_section_t     section;
+	waitq               *worklist;           /**< A worklist we use to place not yet handled entities on. */
 } be_gas_decl_env_t;
 
 /************************************************************************/
@@ -213,59 +228,80 @@ static void dump_arith_tarval(tarval *tv, int bytes)
 	switch (bytes) {
 	case 1:
 		be_emit_irprintf("0x%02x", get_tarval_sub_bits(tv, 0));
-		break;
+		return;
 
 	case 2:
 		be_emit_irprintf("0x%02x%02x", get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0));
-		break;
+		return;
 
 	case 4:
 		be_emit_irprintf("0x%02x%02x%02x%02x",
 			get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0));
-		break;
+		return;
 
 	case 8:
 		be_emit_irprintf("0x%02x%02x%02x%02x%02x%02x%02x%02x",
 			get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6), get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4),
 			get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0));
-		break;
+		return;
 
-	case 10:
 	case 12:
-		break;
+		/* Beware: Mixed endian output!  One little endian number emitted as
+		 * three longs.  Each long initializer is written in big endian. */
+		be_emit_irprintf(
+			"\t.long\t0x%02x%02x%02x%02x\n"
+			"\t.long\t0x%02x%02x%02x%02x\n"
+			"\t.long\t0x%02x%02x%02x%02x",
+			get_tarval_sub_bits(tv,  3), get_tarval_sub_bits(tv,  2),
+			get_tarval_sub_bits(tv,  1), get_tarval_sub_bits(tv,  0),
+			get_tarval_sub_bits(tv,  7), get_tarval_sub_bits(tv,  6),
+			get_tarval_sub_bits(tv,  5), get_tarval_sub_bits(tv,  4),
+			get_tarval_sub_bits(tv, 11), get_tarval_sub_bits(tv, 10),
+			get_tarval_sub_bits(tv,  9), get_tarval_sub_bits(tv,  8)
+		);
+		return;
 
 	case 16:
-		be_emit_irprintf("0x%02x%02x%02x%02x%02x%02x%02x%02x"
-				               "%02x%02x%02x%02x%02x%02x%02x%02x",
+		be_emit_irprintf(
+			"\t.long\t0x%02x%02x%02x%02x0x%02x%02x%02x%02x0x%02x%02x%02x%02x0x%02x%02x%02x%02x",
 			get_tarval_sub_bits(tv, 15), get_tarval_sub_bits(tv, 16),
 			get_tarval_sub_bits(tv, 13), get_tarval_sub_bits(tv, 12),
 			get_tarval_sub_bits(tv, 11), get_tarval_sub_bits(tv, 10),
-			get_tarval_sub_bits(tv, 9), get_tarval_sub_bits(tv, 8),
-			get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6),
-			get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4),
-			get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2),
-			get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0));
-		break;
-
-
-	default:
-		fprintf(stderr, "Try to dump an tarval with %d bytes\n", bytes);
-		assert(0);
+			get_tarval_sub_bits(tv,  9), get_tarval_sub_bits(tv,  8),
+			get_tarval_sub_bits(tv,  7), get_tarval_sub_bits(tv,  6),
+			get_tarval_sub_bits(tv,  5), get_tarval_sub_bits(tv,  4),
+			get_tarval_sub_bits(tv,  3), get_tarval_sub_bits(tv,  2),
+			get_tarval_sub_bits(tv,  1), get_tarval_sub_bits(tv,  0)
+		);
+		return;
 	}
+
+	panic("Can't dump a tarval with %d bytes", bytes);
 }
 
 /**
  * Return the label prefix for labeled blocks.
  */
-const char *be_gas_label_prefix(void) {
+const char *be_gas_block_label_prefix(void) {
 	return ".LG";
 }
 
 /**
- * Dump a label.
+ * Return the label prefix for labeled instructions.
  */
-static void dump_label(ir_label_t label) {
-	be_emit_irprintf("%s%ld", be_gas_label_prefix(), label);
+const char *be_gas_insn_label_prefix(void) {
+	return ".LE";
+}
+
+void be_gas_emit_entity(ir_entity *entity)
+{
+	if (entity->type == firm_code_type) {
+		ir_label_t label = get_entity_label(entity);
+		be_emit_string(be_gas_block_label_prefix());
+		be_emit_irprintf("%lu", label);
+	} else {
+		be_emit_ident(get_entity_ld_ident(entity));
+	}
 }
 
 /**
@@ -307,9 +343,6 @@ static tarval *get_atomic_init_tv(ir_node *init)
 			case symconst_enum_const:
 				return get_enumeration_value(get_SymConst_enum(init));
 
-			case symconst_label:
-				return NULL;
-
 			default:
 				return NULL;
 			}
@@ -331,7 +364,6 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init)
 	ir_mode *mode = get_irn_mode(init);
 	int bytes     = get_mode_size_bytes(mode);
 	tarval *tv;
-	ir_label_t label;
 	ir_entity *ent;
 
 	init = skip_Id(init);
@@ -360,21 +392,15 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init)
 
 		case symconst_addr_ent:
 			ent = get_SymConst_entity(init);
-			if(!is_entity_backend_marked(ent)) {
+			if (!is_entity_backend_marked(ent)) {
 				waitq_put(env->worklist, ent);
 				set_entity_backend_marked(ent, 1);
 			}
-			be_emit_ident(get_entity_ld_ident(ent));
+			be_gas_emit_entity(ent);
 			break;
 
 		case symconst_ofs_ent:
 			ent = get_SymConst_entity(init);
-#if 0       /* not needed, is it? */
-			if(!is_entity_backend_marked(ent)) {
-				waitq_put(env->worklist, ent);
-				set_entity_backend_marked(ent, 1);
-			}
-#endif
 			be_emit_irprintf("%d", get_entity_offset(ent));
 			break;
 
@@ -391,36 +417,40 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init)
 			dump_arith_tarval(tv, bytes);
 			break;
 
-		case symconst_label:
-			label = get_SymConst_label(init);
-			dump_label(label);
-			break;
-
 		default:
 			assert(!"dump_atomic_init(): don't know how to init from this SymConst");
 		}
 		return;
 
-		case iro_Add:
-			do_dump_atomic_init(env, get_Add_left(init));
-			be_emit_cstring(" + ");
-			do_dump_atomic_init(env, get_Add_right(init));
-			return;
+	case iro_Add:
+		if (!mode_is_int(mode) && !mode_is_reference(mode)) {
+			panic("Constant must be int or pointer for '+' to work");
+		}
+		do_dump_atomic_init(env, get_Add_left(init));
+		be_emit_cstring(" + ");
+		do_dump_atomic_init(env, get_Add_right(init));
+		return;
 
-		case iro_Sub:
-			do_dump_atomic_init(env, get_Sub_left(init));
-			be_emit_cstring(" - ");
-			do_dump_atomic_init(env, get_Sub_right(init));
-			return;
+	case iro_Sub:
+		if (!mode_is_int(mode) && !mode_is_reference(mode)) {
+			panic("Constant must be int or pointer for '-' to work");
+		}
+		do_dump_atomic_init(env, get_Sub_left(init));
+		be_emit_cstring(" - ");
+		do_dump_atomic_init(env, get_Sub_right(init));
+		return;
 
-		case iro_Mul:
-			do_dump_atomic_init(env, get_Mul_left(init));
-			be_emit_cstring(" * ");
-			do_dump_atomic_init(env, get_Mul_right(init));
-			return;
+	case iro_Mul:
+		if (!mode_is_int(mode) && !mode_is_reference(mode)) {
+			panic("Constant must be int or pointer for '*' to work");
+		}
+		do_dump_atomic_init(env, get_Mul_left(init));
+		be_emit_cstring(" * ");
+		do_dump_atomic_init(env, get_Mul_right(init));
+		return;
 
-		default:
-			assert(0 && "dump_atomic_init(): unknown IR-node");
+	default:
+		panic("dump_atomic_init(): unsupported IR-node %+F", init);
 	}
 }
 
@@ -457,7 +487,7 @@ static void dump_size_type(size_t size) {
 		break;
 
 	default:
-		panic("Try to dump a type with %u bytes\n", (unsigned) size);
+		panic("Try to dump a type with %u bytes", (unsigned)size);
 	}
 }
 
@@ -487,33 +517,32 @@ static int initializer_is_string_const(const ir_initializer_t *initializer)
 	size_t i, len;
 	int found_printable = 0;
 
-	if(initializer->kind != IR_INITIALIZER_COMPOUND)
+	if (initializer->kind != IR_INITIALIZER_COMPOUND)
 		return 0;
 
 	len = initializer->compound.n_initializers;
 	if (len < 1)
 		return 0;
-	for(i = 0; i < len; ++i) {
+	for (i = 0; i < len; ++i) {
 		int               c;
 		tarval           *tv;
 		ir_mode          *mode;
 		ir_initializer_t *sub_initializer
 			= initializer->compound.initializers[i];
 
-		if(sub_initializer->kind != IR_INITIALIZER_TARVAL)
+		if (sub_initializer->kind != IR_INITIALIZER_TARVAL)
 			return 0;
 
 		tv   = sub_initializer->tarval.value;
 		mode = get_tarval_mode(tv);
 
-		if (!mode_is_int(mode)
-				|| get_mode_size_bits(mode) != get_mode_size_bits(mode_Bs))
+		if (!mode_is_int(mode) || get_mode_size_bits(mode) != 8)
 			return 0;
 
 		c = get_tarval_long(tv);
 		if (isgraph(c) || isspace(c))
 			found_printable = 1;
-		else if(c != 0)
+		else if (c != 0)
 			return 0;
 
 		if (i == len - 1 && c != '\0')
@@ -550,11 +579,10 @@ static int ent_is_string_const(ir_entity *ent)
 	/* and the mode of the element type is an int of
 	 * the same size as the byte mode */
 	mode = get_type_mode(element_type);
-	if (!mode_is_int(mode)
-		|| get_mode_size_bits(mode) != get_mode_size_bits(mode_Bs))
+	if (!mode_is_int(mode) || get_mode_size_bits(mode) != 8)
 		return 0;
 
-	if(ent->has_initializer) {
+	if (ent->has_initializer) {
 		/* TODO */
 		return 0;
 	} else {
@@ -569,7 +597,7 @@ static int ent_is_string_const(ir_entity *ent)
 
 			if (isgraph(c) || isspace(c))
 				found_printable = 1;
-			else if(c != 0)
+			else if (c != 0)
 				return 0;
 
 			if (i == n - 1 && c != '\0')
@@ -590,19 +618,21 @@ static int ent_is_string_const(ir_entity *ent)
 static void dump_string_cst(ir_entity *ent)
 {
 	int      i, len;
+	int      output_len;
 	ir_type *type;
 	int      type_size;
 	int      remaining_space;
 
-	len = get_compound_ent_n_values(ent);
+	len        = get_compound_ent_n_values(ent);
+	output_len = len;
 	if (be_gas_flavour == GAS_FLAVOUR_MACH_O) {
 		be_emit_cstring("\t.ascii \"");
 	} else {
 		be_emit_cstring("\t.string \"");
-		len -= 1;
+		output_len -= 1;
 	}
 
-	for (i = 0; i < len; ++i) {
+	for (i = 0; i < output_len; ++i) {
 		ir_node *irn;
 		int c;
 
@@ -630,8 +660,8 @@ static void dump_string_cst(ir_entity *ent)
 	type_size       = get_type_size_bytes(type);
 	remaining_space = type_size - len;
 	assert(remaining_space >= 0);
-	if(remaining_space > 0) {
-		be_emit_irprintf("\t.skip\t%d\n", remaining_space);
+	if (remaining_space > 0) {
+		be_emit_irprintf("\t.space\t%d\n", remaining_space);
 	}
 }
 
@@ -640,14 +670,14 @@ static void dump_string_initializer(const ir_initializer_t *initializer)
 	size_t i, len;
 
 	len = initializer->compound.n_initializers;
-	if(be_gas_flavour == GAS_FLAVOUR_MACH_O) {
+	if (be_gas_flavour == GAS_FLAVOUR_MACH_O) {
 		be_emit_cstring("\t.ascii \"");
 	} else {
 		be_emit_cstring("\t.string \"");
 		len -= 1;
 	}
 
-	for(i = 0; i < len; ++i) {
+	for (i = 0; i < len; ++i) {
 		const ir_initializer_t *sub_initializer
 			= get_initializer_compound_value(initializer, i);
 
@@ -697,7 +727,7 @@ static int is_type_variable_size(ir_type *type)
 static size_t get_initializer_size(const ir_initializer_t *initializer,
                                    ir_type *type)
 {
-	switch(get_initializer_kind(initializer)) {
+	switch (get_initializer_kind(initializer)) {
 	case IR_INITIALIZER_TARVAL: {
 		assert(get_tarval_mode(get_initializer_tarval_value(initializer)) == get_type_mode(type));
 		return get_type_size_bytes(type);
@@ -706,14 +736,14 @@ static size_t get_initializer_size(const ir_initializer_t *initializer,
 	case IR_INITIALIZER_NULL:
 		return get_type_size_bytes(type);
 	case IR_INITIALIZER_COMPOUND: {
-		if(!is_type_variable_size(type)) {
+		if (!is_type_variable_size(type)) {
 			return get_type_size_bytes(type);
 		} else {
 			unsigned n_entries
 				= get_initializer_compound_n_entries(initializer);
 			unsigned i;
 			unsigned initializer_size = get_type_size_bytes(type);
-			for(i = 0; i < n_entries; ++i) {
+			for (i = 0; i < n_entries; ++i) {
 				ir_entity *entity = get_compound_member(type, i);
 				ir_type   *type   = get_entity_type(entity);
 
@@ -723,7 +753,7 @@ static size_t get_initializer_size(const ir_initializer_t *initializer,
 				unsigned offset = get_entity_offset(entity);
 				unsigned size   = get_initializer_size(sub_initializer, type);
 
-				if(offset + size > initializer_size) {
+				if (offset + size > initializer_size) {
 					initializer_size = offset + size;
 				}
 			}
@@ -750,7 +780,7 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits,
 	int            value_len;
 	int            j;
 
-	switch(get_initializer_kind(initializer)) {
+	switch (get_initializer_kind(initializer)) {
 	case IR_INITIALIZER_NULL:
 		return;
 	case IR_INITIALIZER_TARVAL:
@@ -758,7 +788,7 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits,
 		break;
 	case IR_INITIALIZER_CONST: {
 		ir_node *node = get_initializer_const_value(initializer);
-		if(!is_Const(node)) {
+		if (!is_Const(node)) {
 			panic("bitfield initializer not a Const node");
 		}
 		tv = get_Const_tarval(node);
@@ -768,8 +798,9 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits,
 		panic("bitfield initializer is compound");
 	}
 	if (tv == NULL) {
-		panic("Couldn't get numeric value for bitfield initializer\n");
+		panic("Couldn't get numeric value for bitfield initializer");
 	}
+	tv = tarval_convert_to(tv, get_type_mode(type));
 
 	/* normalize offset */
 	vals        += offset_bits >> 3;
@@ -796,7 +827,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 {
 	assert((size_t) (vals - glob_vals) < max_vals);
 
-	switch(get_initializer_kind(initializer)) {
+	switch (get_initializer_kind(initializer)) {
 	case IR_INITIALIZER_NULL:
 		return;
 	case IR_INITIALIZER_TARVAL: {
@@ -806,7 +837,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 		vals->kind     = TARVAL;
 		vals->v.tarval = get_initializer_tarval_value(initializer);
 		assert(get_type_mode(type) == get_tarval_mode(vals->v.tarval));
-		for(i = 1; i < get_type_size_bytes(type); ++i) {
+		for (i = 1; i < get_type_size_bytes(type); ++i) {
 			vals[i].kind    = NORMAL;
 			vals[i].v.value = NULL;
 		}
@@ -818,7 +849,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 		assert(vals->kind != BITFIELD);
 		vals->kind    = NORMAL;
 		vals->v.value = get_initializer_const_value(initializer);
-		for(i = 1; i < get_type_size_bytes(type); ++i) {
+		for (i = 1; i < get_type_size_bytes(type); ++i) {
 			vals[i].kind    = NORMAL;
 			vals[i].v.value = NULL;
 		}
@@ -828,16 +859,16 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 		size_t i = 0;
 		size_t n = get_initializer_compound_n_entries(initializer);
 
-		if(is_Array_type(type)) {
+		if (is_Array_type(type)) {
 			ir_type *element_type = get_array_element_type(type);
 			size_t   skip         = get_type_size_bytes(element_type);
 			size_t   alignment    = get_type_alignment_bytes(element_type);
 			size_t   misalign     = skip % alignment;
-			if(misalign != 0) {
+			if (misalign != 0) {
 				skip += alignment - misalign;
 			}
 
-			for(i = 0; i < n; ++i) {
+			for (i = 0; i < n; ++i) {
 				ir_initializer_t *sub_initializer
 					= get_initializer_compound_value(initializer, i);
 
@@ -849,7 +880,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 			size_t n_members, i;
 			assert(is_compound_type(type));
 			n_members = get_compound_n_members(type);
-			for(i = 0; i < n_members; ++i) {
+			for (i = 0; i < n_members; ++i) {
 				ir_entity        *member    = get_compound_member(type, i);
 				size_t            offset    = get_entity_offset(member);
 				ir_type          *subtype   = get_entity_type(member);
@@ -860,12 +891,12 @@ static void dump_ir_initializer(normal_or_bitfield *vals,
 				sub_initializer
 					= get_initializer_compound_value(initializer, i);
 
-				if(mode != NULL) {
+				if (mode != NULL) {
 					size_t offset_bits
 						= get_entity_offset_bits_remainder(member);
 					size_t value_len   = get_mode_size_bits(mode);
 
-					if(offset_bits != 0 ||
+					if (offset_bits != 0 ||
 						(value_len != 8 && value_len != 16 && value_len != 32
 						 && value_len != 64)) {
 						dump_bitfield(&vals[offset], offset_bits,
@@ -892,7 +923,7 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity)
 	size_t                  size;
 	size_t                  k;
 
-	if(initializer_is_string_const(initializer)) {
+	if (initializer_is_string_const(initializer)) {
 		dump_string_initializer(initializer);
 		return;
 	}
@@ -907,7 +938,7 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity)
 	 * In the worst case, every initializer allocates one byte.
 	 * Moreover, initializer might be big, do not allocate on stack.
 	 */
-	vals = xcalloc(size, sizeof(vals[0]));
+	vals = XMALLOCNZ(normal_or_bitfield, size);
 
 #ifndef NDEBUG
 	glob_vals = vals;
@@ -918,21 +949,22 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity)
 
 	/* now write values sorted */
 	for (k = 0; k < size; ) {
-		int space = 0, skip = 0;
+		int space     = 0;
+		int elem_size = 1;
 		if (vals[k].kind == NORMAL) {
-			if(vals[k].v.value != NULL) {
+			if (vals[k].v.value != NULL) {
 				dump_atomic_init(env, vals[k].v.value);
-				skip = get_mode_size_bytes(get_irn_mode(vals[k].v.value)) - 1;
+				elem_size = get_mode_size_bytes(get_irn_mode(vals[k].v.value));
 	 		} else {
-	 			space = 1;
+	 			elem_size = 0;
 	 		}
-		} else if(vals[k].kind == TARVAL) {
+		} else if (vals[k].kind == TARVAL) {
 			tarval *tv   = vals[k].v.tarval;
 			size_t  size = get_mode_size_bytes(get_tarval_mode(tv));
 
 			assert(tv != NULL);
 
-			skip = size - 1;
+			elem_size = size;
 			dump_size_type(size);
 			dump_arith_tarval(tv, size);
 			be_emit_char('\n');
@@ -943,17 +975,15 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity)
 			be_emit_write_line();
 		}
 
-		++k;
+		k += elem_size;
 		while (k < size && vals[k].kind == NORMAL && vals[k].v.value == NULL) {
 			++space;
 			++k;
 		}
-		space -= skip;
-		assert(space >= 0);
 
 		/* a gap */
 		if (space > 0) {
-			be_emit_irprintf("\t.skip\t%d\n", space);
+			be_emit_irprintf("\t.space\t%d\n", space);
 			be_emit_write_line();
 		}
 	}
@@ -969,7 +999,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent)
 	int i, j, n;
 	unsigned k, last_ofs;
 
-	if(ent->has_initializer) {
+	if (ent->has_initializer) {
 		dump_initializer(env, ent);
 		return;
 	}
@@ -997,7 +1027,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent)
 	 * In the worst case, every initializer allocates one byte.
 	 * Moreover, initializer might be big, do not allocate on stack.
 	 */
-	vals = xcalloc(last_ofs, sizeof(vals[0]));
+	vals = XMALLOCNZ(normal_or_bitfield, last_ofs);
 
 	/* collect the values and store them at the offsets */
 	for (i = 0; i < n; ++i) {
@@ -1013,7 +1043,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent)
 			tarval *tv = get_atomic_init_tv(value);
 			unsigned char curr_bits, last_bits = 0;
 			if (tv == NULL) {
-				panic("Couldn't get numeric value for bitfield initializer '%s'\n",
+				panic("Couldn't get numeric value for bitfield initializer '%s'",
 				      get_entity_ld_name(ent));
 			}
 			/* normalize offset */
@@ -1045,7 +1075,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent)
 	for (k = 0; k < last_ofs; ) {
 		int space = 0, skip = 0;
 		if (vals[k].kind == NORMAL) {
-			if(vals[k].v.value != NULL) {
+			if (vals[k].v.value != NULL) {
 				dump_atomic_init(env, vals[k].v.value);
 				skip = get_mode_size_bytes(get_irn_mode(vals[k].v.value)) - 1;
 	 		} else {
@@ -1066,58 +1096,54 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent)
 
 		/* a gap */
 		if (space > 0) {
-			be_emit_irprintf("\t.skip\t%d\n", space);
+			be_emit_irprintf("\t.space\t%d\n", space);
 			be_emit_write_line();
 		}
 	}
 	xfree(vals);
 }
 
-static void emit_align(unsigned alignment)
+static void emit_align(unsigned p2alignment)
 {
-	if (!is_po2(alignment))
-		panic("alignment not a power of 2");
-
-	be_emit_irprintf(".p2align\t%u\n", log2_floor(alignment));
+	be_emit_irprintf("\t.p2align\t%u\n", log2_floor(p2alignment));
 	be_emit_write_line();
 }
 
+static unsigned get_effective_entity_alignment(ir_entity *entity)
+{
+	unsigned alignment = get_entity_alignment(entity);
+	if (alignment == 0) {
+		ir_type *type = get_entity_type(entity);
+		alignment     = get_type_alignment_bytes(type);
+	}
+	return alignment;
+}
+
+
 /**
  * Dump a global entity.
  *
  * @param env           the gas output environment
  * @param ent           the entity to be dumped
- * @param emit_commons  if non-zero, emit commons (non-local uninitialized entities)
  */
-static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons)
+static void dump_global(be_gas_decl_env_t *env, ir_entity *ent)
 {
 	ir_type          *type           = get_entity_type(ent);
 	ident            *ld_ident       = get_entity_ld_ident(ent);
-	unsigned          align          = get_type_alignment_bytes(type);
+	unsigned          alignment      = get_effective_entity_alignment(ent);
 	int               emit_as_common = 0;
-	be_gas_section_t  section;
-	ir_variability    variability;
-	ir_visibility     visibility;
-
-	if (is_Method_type(type)) {
-		if (be_gas_flavour != GAS_FLAVOUR_MACH_O
-				&& get_method_img_section(ent) == section_constructors) {
-			be_gas_emit_switch_section(GAS_SECTION_CTOR);
-			emit_align(align);
-			dump_size_type(align);
-			be_emit_ident(ld_ident);
-			be_emit_char('\n');
-			be_emit_write_line();
-		}
+	be_gas_section_t  section        = env->section;
+	ir_variability    variability    = get_entity_variability(ent);
+	ir_visibility     visibility     = get_entity_visibility(ent);
 
+	if (is_Method_type(type) && section != GAS_SECTION_PIC_TRAMPOLINES) {
+		return;
+	}
+	if (type == firm_code_type) {
 		return;
 	}
 
-	variability = get_entity_variability(ent);
-	visibility  = get_entity_visibility(ent);
-	section     = GAS_SECTION_DATA;
-	if (env->dump_tls) {
-		section = GAS_SECTION_TLS;
+	if (section != (be_gas_section_t) -1) {
 		emit_as_common = 0;
 	} else if (variability == variability_constant) {
 		/* a constant entity, put it on the rdata */
@@ -1129,11 +1155,13 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
 	} else if (variability == variability_uninitialized) {
 		/* uninitialized entity put it in bss segment */
 		section = GAS_SECTION_COMMON;
-		if (emit_commons && visibility != visibility_local)
+		if (visibility != visibility_local)
 			emit_as_common = 1;
+	} else {
+		section = GAS_SECTION_DATA;
 	}
 
-	if(!emit_as_common) {
+	if (!emit_as_common) {
 		be_gas_emit_switch_section(section);
 	}
 
@@ -1145,7 +1173,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
 		be_emit_ident(ld_ident);
 		be_emit_char('\n');
 		be_emit_write_line();
-	} else if(visibility == visibility_external_allocated) {
+	} else if (visibility == visibility_external_allocated) {
 		be_emit_cstring(".globl\t");
 		be_emit_ident(ld_ident);
 		be_emit_char('\n');
@@ -1153,9 +1181,21 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
 		/* we can return now... */
 		return;
 	}
+	if (!is_po2(alignment))
+		panic("alignment not a power of 2");
 	/* alignment */
-	if (align > 1 && !emit_as_common) {
-		emit_align(align);
+	if (alignment > 1 && !emit_as_common && section != GAS_SECTION_PIC_TRAMPOLINES
+			&& section != GAS_SECTION_PIC_SYMBOLS) {
+		emit_align(alignment);
+	}
+
+	if (visibility != visibility_external_allocated && !emit_as_common
+			&& be_gas_flavour == GAS_FLAVOUR_ELF) {
+		be_emit_cstring("\t.type\t");
+		be_emit_ident(ld_ident);
+		be_emit_cstring(", @object\n\t.size\t");
+		be_emit_ident(ld_ident);
+		be_emit_irprintf(", %u\n", get_type_size_bytes(type));
 	}
 
 	if (!emit_as_common) {
@@ -1167,19 +1207,41 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
 	if (variability == variability_uninitialized) {
 		if (emit_as_common) {
 			switch (be_gas_flavour) {
-			case GAS_FLAVOUR_ELF:
 			case GAS_FLAVOUR_MACH_O:
+				be_emit_irprintf("\t.comm %s,%u,%u\n",
+					get_id_str(ld_ident), get_type_size_bytes(type),
+					log2_floor(alignment));
+				break;
+			case GAS_FLAVOUR_ELF:
 			case GAS_FLAVOUR_YASM:
 				be_emit_irprintf("\t.comm %s,%u,%u\n",
-					get_id_str(ld_ident), get_type_size_bytes(type), align);
+					get_id_str(ld_ident), get_type_size_bytes(type), alignment);
 				be_emit_write_line();
 				break;
 			case GAS_FLAVOUR_MINGW:
 				be_emit_irprintf("\t.comm %s,%u # %u\n",
-					get_id_str(ld_ident), get_type_size_bytes(type), align);
+					get_id_str(ld_ident), get_type_size_bytes(type), alignment);
 				be_emit_write_line();
 				break;
 			}
+		} else if (section == GAS_SECTION_PIC_TRAMPOLINES
+				|| section == GAS_SECTION_PIC_SYMBOLS) {
+			if (be_gas_flavour == GAS_FLAVOUR_MACH_O) {
+				be_emit_cstring("\t.indirect_symbol ");
+				be_emit_ident(get_entity_ident(ent));
+				be_emit_char('\n');
+				be_emit_write_line();
+				if (section == GAS_SECTION_PIC_TRAMPOLINES) {
+					be_emit_cstring("\thlt ; hlt ; hlt ; hlt ; hlt\n");
+					be_emit_write_line();
+				} else {
+					assert(section == GAS_SECTION_PIC_SYMBOLS);
+					be_emit_cstring("\t.long 0\n");
+					be_emit_write_line();
+				}
+			} else {
+				panic("PIC trampolines not yet supported in this gas mode");
+			}
 		} else {
 			be_emit_irprintf("\t.space %u\n", get_type_size_bytes(type));
 			be_emit_write_line();
@@ -1203,7 +1265,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
 				dump_compound_init(env, ent);
 				break;
 			default:
-				assert(0);
+				panic("Unimplemented type kind in dump_global()");
 			}
 		}
 	}
@@ -1214,12 +1276,11 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons
  *
  * @param gt                a global like type, either the global or the TLS one
  * @param env               an environment
- * @param emit_commons      if non-zero, emit commons (non-local uninitialized entities)
  * @param only_emit_marked  if non-zero, external allocated entities that do not have
  *                          its visited flag set are ignored
  */
 static void be_gas_dump_globals(ir_type *gt, be_gas_decl_env_t *env,
-                              int emit_commons, int only_emit_marked)
+                                int only_emit_marked)
 {
 	int i, n = get_compound_n_members(gt);
 	waitq *worklist = new_waitq();
@@ -1246,7 +1307,7 @@ static void be_gas_dump_globals(ir_type *gt, be_gas_decl_env_t *env,
 	while (!waitq_empty(worklist)) {
 		ir_entity *ent = waitq_get(worklist);
 
-		dump_global(env, ent, emit_commons);
+		dump_global(env, ent);
 	}
 
 	del_waitq(worklist);
@@ -1262,13 +1323,29 @@ void be_gas_emit_decls(const be_main_env_t *main_env,
 	be_gas_decl_env_t env;
 	memset(&env, 0, sizeof(env));
 
-	env.main_env = main_env;
-
 	/* dump global type */
-	be_gas_dump_globals(get_glob_type(), &env, 1, only_emit_marked_entities);
-
-	/* dump the Thread Local Storage */
-	env.dump_tls = 1;
-	be_gas_dump_globals(get_tls_type(), &env, 0, only_emit_marked_entities);
-	env.dump_tls = 0;
+	env.section = (be_gas_section_t) -1;
+	be_gas_dump_globals(get_glob_type(), &env, only_emit_marked_entities);
+	env.section = GAS_SECTION_TLS;
+	be_gas_dump_globals(get_tls_type(), &env, only_emit_marked_entities);
+	env.section = GAS_SECTION_CONSTRUCTORS;
+	be_gas_dump_globals(get_segment_type(IR_SEGMENT_CONSTRUCTORS), &env,
+	                    only_emit_marked_entities);
+	env.section = GAS_SECTION_DESTRUCTORS;
+	be_gas_dump_globals(get_segment_type(IR_SEGMENT_DESTRUCTORS), &env,
+	                    only_emit_marked_entities);
+
+	env.section = GAS_SECTION_PIC_SYMBOLS;
+	be_gas_dump_globals(main_env->pic_symbols_type, &env,
+	                    only_emit_marked_entities);
+
+	if (get_compound_n_members(main_env->pic_trampolines_type) > 0) {
+		env.section = GAS_SECTION_PIC_TRAMPOLINES;
+		be_gas_dump_globals(main_env->pic_trampolines_type, &env,
+		                    only_emit_marked_entities);
+		if (be_gas_flavour == GAS_FLAVOUR_MACH_O) {
+			be_emit_cstring("\t.subsections_via_symbols\n");
+			be_emit_write_line();
+		}
+	}
 }