X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Farm%2Farm_emitter.c;h=f67e5a67a0a483de0eb9ee9292327ee5e0fd8d8c;hb=8a5ac70896b18a522fa39aad29b3c7cf36d5941e;hp=b2480920c773d4d4d2709796c29b5b5c2cdd4d9f;hpb=65a52a96e8ab7ed601d7f98c516d37c46b674b4a;p=libfirm

diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index b2480920c..f67e5a67a 100644
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -21,11 +21,11 @@
  * @file
  * @brief   arm emitter
  * @author  Oliver Richter, Tobias Gneist, Michael Beck
- * @version $Id$
  */
 #include "config.h"
 
 #include <limits.h>
+#include <stdbool.h>
 
 #include "xmalloc.h"
 #include "tv.h"
@@ -41,11 +41,11 @@
 #include "raw_bitset.h"
 #include "dbginfo.h"
 
-#include "../besched.h"
-#include "../beblocksched.h"
-#include "../beirg.h"
-#include "../begnuas.h"
-#include "../be_dbgout.h"
+#include "besched.h"
+#include "beblocksched.h"
+#include "beirg.h"
+#include "begnuas.h"
+#include "bedwarf.h"
 
 #include "arm_emitter.h"
 #include "arm_optimize.h"
@@ -55,105 +55,30 @@
 #include "arm_map_regs.h"
 #include "gen_arm_regalloc_if.h"
 
-#include "../benode.h"
-
-#define SNPRINTF_BUF_LEN 128
+#include "benode.h"
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
-static const arm_code_gen_t *cg;
-static set                  *sym_or_tv;
+static set       *sym_or_tv;
+static arm_isa_t *isa;
 
-/**
- * Returns the register at in position pos.
- */
-static const arch_register_t *get_in_reg(const ir_node *irn, int pos)
+static void arm_emit_register(const arch_register_t *reg)
 {
-	ir_node                *op;
-	const arch_register_t  *reg = NULL;
-
-	assert(get_irn_arity(irn) > pos && "Invalid IN position");
-
-	/* The out register of the operator at position pos is the
-	   in register we need. */
-	op = get_irn_n(irn, pos);
-
-	reg = arch_get_irn_register(op);
-
-	assert(reg && "no in register found");
-
-	/* in case of a joker register: just return a valid register */
-	if (arch_register_type_is(reg, joker)) {
-		const arch_register_req_t *req = arch_get_register_req(irn, pos);
-
-		if (arch_register_req_is(req, limited)) {
-			/* in case of limited requirements: get the first allowed register */
-			unsigned idx = rbitset_next(req->limited, 0, 1);
-			reg = arch_register_for_index(req->cls, idx);
-		} else {
-			/* otherwise get first register in class */
-			reg = arch_register_for_index(req->cls, 0);
-		}
-	}
-	return reg;
-}
-
-
-/**
- * Returns the register at out position pos.
- */
-static const arch_register_t *get_out_reg(const ir_node *node, int pos)
-{
-    ir_node                *proj;
-    const arch_register_t  *reg = NULL;
-
-    /* 1st case: irn is not of mode_T, so it has only                 */
-    /*           one OUT register -> good                             */
-    /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
-    /*           Proj with the corresponding projnum for the register */
-
-    if (get_irn_mode(node) != mode_T) {
-        reg = arch_get_irn_register(node);
-    } else if (is_arm_irn(node)) {
-        reg = arch_irn_get_register(node, pos);
-    } else {
-        const ir_edge_t *edge;
-
-        foreach_out_edge(node, edge) {
-            proj = get_edge_src_irn(edge);
-            assert(is_Proj(proj) && "non-Proj from mode_T node");
-            if (get_Proj_proj(proj) == pos) {
-                reg = arch_get_irn_register(proj);
-                break;
-            }
-        }
-    }
-
-    assert(reg && "no out register found");
-    return reg;
+	be_emit_string(arch_register_get_name(reg));
 }
 
-/**
- * Emit the name of the source register at given input position.
- */
 void arm_emit_source_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg = get_in_reg(node, pos);
-	be_emit_string(arch_register_get_name(reg));
+	const arch_register_t *reg = arch_get_irn_register_in(node, pos);
+	arm_emit_register(reg);
 }
 
-/**
- * Emit the name of the destination register at given output position.
- */
 void arm_emit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg = get_out_reg(node, pos);
-	be_emit_string(arch_register_get_name(reg));
+	const arch_register_t *reg = arch_get_irn_register_out(node, pos);
+	arm_emit_register(reg);
 }
 
-/**
- * Emit a node's offset.
- */
 void arm_emit_offset(const ir_node *node)
 {
 	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
@@ -177,20 +102,26 @@ static void arm_emit_fpa_postfix(const ir_mode *mode)
 	be_emit_char(c);
 }
 
-/**
- * Emit the instruction suffix depending on the mode.
- */
-void arm_emit_mode(const ir_node *node)
+void arm_emit_float_load_store_mode(const ir_node *node)
 {
-	ir_mode *mode;
+	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
+	arm_emit_fpa_postfix(attr->load_store_mode);
+}
 
-	if (is_arm_irn(node)) {
-		const arm_attr_t *attr = get_arm_attr_const(node);
-		mode = attr->op_mode ? attr->op_mode : get_irn_mode(node);
-	} else {
-		mode = get_irn_mode(node);
-	}
-	arm_emit_fpa_postfix(mode);
+void arm_emit_float_arithmetic_mode(const ir_node *node)
+{
+	const arm_farith_attr_t *attr = get_arm_farith_attr_const(node);
+	arm_emit_fpa_postfix(attr->mode);
+}
+
+void arm_emit_symconst(const ir_node *node)
+{
+	const arm_SymConst_attr_t *symconst = get_arm_SymConst_attr_const(node);
+	ir_entity                 *entity   = symconst->entity;
+
+	be_gas_emit_entity(entity);
+
+	/* TODO do something with offset */
 }
 
 void arm_emit_load_mode(const ir_node *node)
@@ -222,8 +153,7 @@ void arm_emit_store_mode(const ir_node *node)
 	}
 }
 
-
-static void emit_shf_mod_name(arm_shift_modifier mod)
+static void emit_shf_mod_name(arm_shift_modifier_t mod)
 {
 	switch (mod) {
 	case ARM_SHF_ASR_REG:
@@ -250,7 +180,7 @@ static void emit_shf_mod_name(arm_shift_modifier mod)
 
 void arm_emit_shifter_operand(const ir_node *node)
 {
-	const arm_shifter_operand_t *attr = get_irn_generic_attr_const(node);
+	const arm_shifter_operand_t *attr = get_arm_shifter_operand_attr_const(node);
 
 	switch (attr->shift_modifier) {
 	case ARM_SHF_REG:
@@ -298,12 +228,12 @@ void arm_emit_shifter_operand(const ir_node *node)
 /** An entry in the sym_or_tv set. */
 typedef struct sym_or_tv_t {
 	union {
-		ident  *id;          /**< An ident. */
-		tarval *tv;          /**< A tarval. */
+		ir_entity  *entity;  /**< An entity. */
+		ir_tarval  *tv;      /**< A tarval. */
 		const void *generic; /**< For generic compare. */
 	} u;
 	unsigned label;      /**< the associated label. */
-	char is_ident;       /**< Non-zero if an ident is stored. */
+	bool     is_entity;  /**< true if an entity is stored. */
 } sym_or_tv_t;
 
 /**
@@ -315,6 +245,11 @@ static unsigned get_unique_label(void)
 	return ++id;
 }
 
+static void emit_constant_name(const sym_or_tv_t *entry)
+{
+	be_emit_irprintf("%sC%u", be_gas_get_private_prefix(), entry->label);
+}
+
 /**
  * Emit a SymConst.
  */
@@ -322,28 +257,27 @@ static void emit_arm_SymConst(const ir_node *irn)
 {
 	const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(irn);
 	sym_or_tv_t key, *entry;
-	unsigned label;
 
-	key.u.id     = get_entity_ld_ident(attr->entity);
-	key.is_ident = 1;
-	key.label    = 0;
-	entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
+	key.u.entity  = attr->entity;
+	key.is_entity = true;
+	key.label     = 0;
+	entry = set_insert(sym_or_tv_t, sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
 	if (entry->label == 0) {
 		/* allocate a label */
 		entry->label = get_unique_label();
 	}
-	label = entry->label;
 
 	/* load the symbol indirect */
 	be_emit_cstring("\tldr ");
 	arm_emit_dest_register(irn, 0);
-	be_emit_irprintf(", .L%u", label);
+	be_emit_cstring(", ");
+	emit_constant_name(entry);
 	be_emit_finish_line_gas(irn);
 }
 
 static void emit_arm_FrameAddr(const ir_node *irn)
 {
-	const arm_SymConst_attr_t *attr = get_irn_generic_attr_const(irn);
+	const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(irn);
 
 	be_emit_cstring("\tadd ");
 	arm_emit_dest_register(irn, 0);
@@ -357,21 +291,19 @@ static void emit_arm_FrameAddr(const ir_node *irn)
 /**
  * Emit a floating point fpa constant.
  */
-static void emit_arm_fpaConst(const ir_node *irn)
+static void emit_arm_fConst(const ir_node *irn)
 {
 	sym_or_tv_t key, *entry;
-	unsigned label;
 	ir_mode *mode;
 
-	key.u.tv     = get_fpaConst_value(irn);
-	key.is_ident = 0;
-	key.label    = 0;
-	entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
+	key.u.tv      = get_fConst_value(irn);
+	key.is_entity = false;
+	key.label     = 0;
+	entry = set_insert(sym_or_tv_t, sym_or_tv, &key, sizeof(key), hash_ptr(key.u.generic));
 	if (entry->label == 0) {
 		/* allocate a label */
 		entry->label = get_unique_label();
 	}
-	label = entry->label;
 
 	/* load the tarval indirect */
 	mode = get_irn_mode(irn);
@@ -380,7 +312,8 @@ static void emit_arm_fpaConst(const ir_node *irn)
 	be_emit_char(' ');
 
 	arm_emit_dest_register(irn, 0);
-	be_emit_irprintf(", .L%u", label);
+	be_emit_cstring(", ");
+	emit_constant_name(entry);
 	be_emit_finish_line_gas(irn);
 }
 
@@ -389,7 +322,7 @@ static void emit_arm_fpaConst(const ir_node *irn)
  */
 static ir_node *sched_next_block(const ir_node *block)
 {
-    return get_irn_link(block);
+    return (ir_node*)get_irn_link(block);
 }
 
 /**
@@ -397,7 +330,7 @@ static ir_node *sched_next_block(const ir_node *block)
  */
 static ir_node *get_cfop_target_block(const ir_node *irn)
 {
-	return get_irn_link(irn);
+	return (ir_node*)get_irn_link(irn);
 }
 
 /**
@@ -422,8 +355,8 @@ static void emit_arm_B(const ir_node *irn)
 	const ir_node *next_block;
 	ir_node *op1 = get_irn_n(irn, 0);
 	const char *suffix;
-	int proj_num = get_arm_CondJmp_proj_num(irn);
-	const arm_cmp_attr_t *cmp_attr = get_irn_generic_attr_const(op1);
+	ir_relation relation = get_arm_CondJmp_relation(irn);
+	const arm_cmp_attr_t *cmp_attr = get_arm_cmp_attr_const(op1);
 	bool is_signed = !cmp_attr->is_unsigned;
 
 	assert(is_arm_Cmp(op1) || is_arm_Tst(op1));
@@ -439,7 +372,7 @@ static void emit_arm_B(const ir_node *irn)
 	}
 
 	if (cmp_attr->ins_permuted) {
-		proj_num = get_mirrored_pnc(proj_num);
+		relation = get_inversed_relation(relation);
 	}
 
 	/* for now, the code works for scheduled and non-schedules blocks */
@@ -448,8 +381,8 @@ static void emit_arm_B(const ir_node *irn)
 	/* we have a block schedule */
 	next_block = sched_next_block(block);
 
-	assert(proj_num != pn_Cmp_False);
-	assert(proj_num != pn_Cmp_True);
+	assert(relation != ir_relation_false);
+	assert(relation != ir_relation_true);
 
 	if (get_cfop_target_block(proj_true) == next_block) {
 		/* exchange both proj's so the second one can be omitted */
@@ -457,18 +390,18 @@ static void emit_arm_B(const ir_node *irn)
 
 		proj_true  = proj_false;
 		proj_false = t;
-		proj_num   = get_negated_pnc(proj_num, mode_Iu);
+		relation   = get_negated_relation(relation);
 	}
 
-	switch (proj_num) {
-		case pn_Cmp_Eq:  suffix = "eq"; break;
-		case pn_Cmp_Lt:  suffix = is_signed ? "lt" : "lo"; break;
-		case pn_Cmp_Le:  suffix = is_signed ? "le" : "ls"; break;
-		case pn_Cmp_Gt:  suffix = is_signed ? "gt" : "hi"; break;
-		case pn_Cmp_Ge:  suffix = is_signed ? "ge" : "hs"; break;
-		case pn_Cmp_Lg:  suffix = "ne"; break;
-		case pn_Cmp_Leg: suffix = "al"; break;
-		default: panic("Cmp has unsupported pnc");
+	switch (relation & (ir_relation_less_equal_greater)) {
+		case ir_relation_equal:         suffix = "eq"; break;
+		case ir_relation_less:          suffix = is_signed ? "lt" : "lo"; break;
+		case ir_relation_less_equal:    suffix = is_signed ? "le" : "ls"; break;
+		case ir_relation_greater:       suffix = is_signed ? "gt" : "hi"; break;
+		case ir_relation_greater_equal: suffix = is_signed ? "ge" : "hs"; break;
+		case ir_relation_less_greater:  suffix = "ne"; break;
+		case ir_relation_less_equal_greater: suffix = "al"; break;
+		default: panic("Cmp has unsupported relation");
 	}
 
 	/* emit the true proj */
@@ -477,10 +410,12 @@ static void emit_arm_B(const ir_node *irn)
 	be_emit_finish_line_gas(proj_true);
 
 	if (get_cfop_target_block(proj_false) == next_block) {
-		be_emit_cstring("\t/* fallthrough to ");
-		arm_emit_cfop_target(proj_false);
-		be_emit_cstring(" */");
-		be_emit_finish_line_gas(proj_false);
+		if (be_options.verbose_asm) {
+			be_emit_cstring("\t/* fallthrough to ");
+			arm_emit_cfop_target(proj_false);
+			be_emit_cstring(" */");
+			be_emit_finish_line_gas(proj_false);
+		}
 	} else {
 		be_emit_cstring("\tb ");
 		arm_emit_cfop_target(proj_false);
@@ -491,8 +426,8 @@ static void emit_arm_B(const ir_node *irn)
 /** Sort register in ascending order. */
 static int reg_cmp(const void *a, const void *b)
 {
-	const arch_register_t * const *ra = a;
-	const arch_register_t * const *rb = b;
+	const arch_register_t * const *ra = (const arch_register_t**)a;
+	const arch_register_t * const *rb = (const arch_register_t**)b;
 
 	return *ra < *rb ? -1 : (*ra != *rb);
 }
@@ -502,20 +437,20 @@ static int reg_cmp(const void *a, const void *b)
  */
 static void emit_arm_CopyB(const ir_node *irn)
 {
-	const arm_CopyB_attr_t *attr = get_irn_generic_attr_const(irn);
+	const arm_CopyB_attr_t *attr = get_arm_CopyB_attr_const(irn);
 	unsigned size = attr->size;
 
-	const char *tgt = arch_register_get_name(get_in_reg(irn, 0));
-	const char *src = arch_register_get_name(get_in_reg(irn, 1));
+	const char *tgt = arch_register_get_name(arch_get_irn_register_in(irn, 0));
+	const char *src = arch_register_get_name(arch_get_irn_register_in(irn, 1));
 	const char *t0, *t1, *t2, *t3;
 
 	const arch_register_t *tmpregs[4];
 
 	/* collect the temporary registers and sort them, we need ascending order */
-	tmpregs[0] = get_in_reg(irn, 2);
-	tmpregs[1] = get_in_reg(irn, 3);
-	tmpregs[2] = get_in_reg(irn, 4);
-	tmpregs[3] = &arm_gp_regs[REG_R12];
+	tmpregs[0] = arch_get_irn_register_in(irn, 2);
+	tmpregs[1] = arch_get_irn_register_in(irn, 3);
+	tmpregs[2] = arch_get_irn_register_in(irn, 4);
+	tmpregs[3] = &arm_registers[REG_R12];
 
 	/* Note: R12 is always the last register because the RA did not assign higher ones */
 	qsort((void *)tmpregs, 3, sizeof(tmpregs[0]), reg_cmp);
@@ -526,20 +461,22 @@ static void emit_arm_CopyB(const ir_node *irn)
 	t2 = arch_register_get_name(tmpregs[2]);
 	t3 = arch_register_get_name(tmpregs[3]);
 
-	be_emit_cstring("/* MemCopy (");
-	be_emit_string(src);
-	be_emit_cstring(")->(");
-	arm_emit_source_register(irn, 0);
-	be_emit_irprintf(" [%u bytes], Uses ", size);
-	be_emit_string(t0);
-	be_emit_cstring(", ");
-	be_emit_string(t1);
-	be_emit_cstring(", ");
-	be_emit_string(t2);
-	be_emit_cstring(", and ");
-	be_emit_string(t3);
-	be_emit_cstring("*/");
-	be_emit_finish_line_gas(NULL);
+	if (be_options.verbose_asm) {
+		be_emit_cstring("/* MemCopy (");
+		be_emit_string(src);
+		be_emit_cstring(")->(");
+		arm_emit_source_register(irn, 0);
+		be_emit_irprintf(" [%u bytes], Uses ", size);
+		be_emit_string(t0);
+		be_emit_cstring(", ");
+		be_emit_string(t1);
+		be_emit_cstring(", ");
+		be_emit_string(t2);
+		be_emit_cstring(", and ");
+		be_emit_string(t3);
+		be_emit_cstring("*/");
+		be_emit_finish_line_gas(NULL);
+	}
 
 	assert(size > 0 && "CopyB needs size > 0" );
 
@@ -643,106 +580,13 @@ static void emit_arm_CopyB(const ir_node *irn)
 
 static void emit_arm_SwitchJmp(const ir_node *irn)
 {
-	const ir_edge_t    *edge;
-	ir_node            *proj;
-	int i;
-	ir_node **projs;
-	int n_projs;
-	int block_nr;
-	ir_node *default_proj = NULL;
-
-	block_nr = get_irn_node_nr(irn);
-	n_projs = get_arm_SwitchJmp_n_projs(irn);
-
-	projs = XMALLOCNZ(ir_node*, n_projs);
-
-	foreach_out_edge(irn, edge) {
-		proj = get_edge_src_irn(edge);
-		assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
-
-		if (get_Proj_proj(proj) == get_arm_SwitchJmp_default_proj_num(irn))
-			default_proj = proj;
-
-		projs[get_Proj_proj(proj)] = proj;
-	}
-	assert(default_proj != NULL && "SwitchJmp should have a Default Proj");
-
-	/*
-	   CMP %1S, n_projs - 1
-	   BHI default
-	*/
-
-	be_emit_cstring("\tcmp ");
+	const arm_SwitchJmp_attr_t *attr = get_arm_SwitchJmp_attr_const(irn);
+	be_emit_cstring("\tldrls pc, [pc, ");
 	arm_emit_source_register(irn, 0);
-	be_emit_irprintf(", #%u", n_projs - 1);
+	be_emit_cstring(", asl #2]");
 	be_emit_finish_line_gas(irn);
 
-	be_emit_cstring("\tbhi ");
-	arm_emit_cfop_target(default_proj);
-	be_emit_finish_line_gas(default_proj);
-
-	/*
-	   LDR %r12, .TABLE_X_START
-	   ADD %r12, %r12, [%1S, LSL #2]
-	   LDR %r15, %r12
-	 */
-
-	be_emit_irprintf("\tldr %%r12, TABLE_%d_START", block_nr);
-	be_emit_finish_line_gas(NULL);
-
-	be_emit_irprintf("\tadd %%r12, %%r12, ");
-	arm_emit_source_register(irn, 0);
-	be_emit_cstring(", LSL #2");
-	be_emit_finish_line_gas(NULL);
-
-	be_emit_cstring("\tldr %r15, [%r12, #0]");
-	be_emit_finish_line_gas(NULL);
-
-	be_emit_irprintf("TABLE_%d_START:\n\t.word\tTABLE_%d", block_nr, block_nr);
-	be_emit_finish_line_gas(NULL);
-	be_emit_irprintf("\t.align 2");
-	be_emit_finish_line_gas(NULL);
-	be_emit_irprintf("TABLE_%d:", block_nr);
-	be_emit_finish_line_gas(NULL);
-
-	for (i = 0; i < n_projs; ++i) {
-		proj = projs[i];
-		if (proj == NULL) {
-			proj = projs[get_arm_SwitchJmp_default_proj_num(irn)];
-		}
-		be_emit_cstring("\t.word\t");
-		arm_emit_cfop_target(proj);
-		be_emit_finish_line_gas(proj);
-	}
-	be_emit_irprintf("\t.align 2\n");
-	be_emit_finish_line_gas(NULL);
-	xfree(projs);
-}
-
-/************************************************************************/
-/* emit_be                                                              */
-/************************************************************************/
-
-static void arm_emit_entity(ir_entity *entity)
-{
-	be_emit_ident(get_entity_ld_ident(entity));
-}
-
-static void emit_be_Call(const ir_node *irn)
-{
-	ir_entity *entity = be_Call_get_entity(irn);
-
-	if (entity != NULL) {
-		be_emit_cstring("\tbl ");
-		arm_emit_entity(entity);
-		be_emit_finish_line_gas(irn);
-	} else {
-		be_emit_cstring("\tmov lr, pc");
-		be_emit_finish_line_gas(irn);
-		be_emit_cstring("\tmov pc, ");
-		arm_emit_source_register(irn, be_pos_Call_ptr);
-		be_emit_finish_line_gas(irn);
-	}
+	be_emit_jump_table(irn, attr->table, NULL, get_cfop_target_block);
 }
 
 /** Emit an IncSP node */
@@ -761,26 +605,25 @@ static void emit_be_IncSP(const ir_node *irn)
 		be_emit_cstring(", ");
 		arm_emit_source_register(irn, 0);
 		be_emit_irprintf(", #0x%X", offs);
+		be_emit_finish_line_gas(irn);
 	} else {
 		/* omitted IncSP(0) */
 		return;
 	}
-	be_emit_finish_line_gas(irn);
 }
 
 static void emit_be_Copy(const ir_node *irn)
 {
 	ir_mode *mode = get_irn_mode(irn);
 
-	if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
+	if (arch_get_irn_register_in(irn, 0) == arch_get_irn_register_out(irn, 0)) {
 		/* omitted Copy */
 		return;
 	}
 
 	if (mode_is_float(mode)) {
-		if (USE_FPA(cg->isa)) {
+		if (USE_FPA(isa)) {
 			be_emit_cstring("\tmvf");
-			arm_emit_mode(irn);
 			be_emit_char(' ');
 			arm_emit_dest_register(irn, 0);
 			be_emit_cstring(", ");
@@ -870,15 +713,43 @@ static void emit_be_MemPerm(const ir_node *node)
 	assert(sp_change == 0);
 }
 
+static void emit_be_Start(const ir_node *node)
+{
+	ir_graph *irg        = get_irn_irg(node);
+	ir_type  *frame_type = get_irg_frame_type(irg);
+	unsigned  size       = get_type_size_bytes(frame_type);
+
+	/* allocate stackframe */
+	if (size > 0) {
+		be_emit_cstring("\tsub ");
+		arm_emit_register(&arm_registers[REG_SP]);
+		be_emit_cstring(", ");
+		arm_emit_register(&arm_registers[REG_SP]);
+		be_emit_irprintf(", #0x%X", size);
+		be_emit_finish_line_gas(node);
+	}
+}
+
 static void emit_be_Return(const ir_node *node)
 {
+	ir_graph *irg        = get_irn_irg(node);
+	ir_type  *frame_type = get_irg_frame_type(irg);
+	unsigned  size       = get_type_size_bytes(frame_type);
+
+	/* deallocate stackframe */
+	if (size > 0) {
+		be_emit_cstring("\tadd ");
+		arm_emit_register(&arm_registers[REG_SP]);
+		be_emit_cstring(", ");
+		arm_emit_register(&arm_registers[REG_SP]);
+		be_emit_irprintf(", #0x%X", size);
+		be_emit_finish_line_gas(node);
+	}
+
 	be_emit_cstring("\tmov pc, lr");
 	be_emit_finish_line_gas(node);
 }
 
-/************************************************************************/
-/* emit                                                                 */
-/************************************************************************/
 
 static void emit_arm_Jmp(const ir_node *node)
 {
@@ -892,38 +763,15 @@ static void emit_arm_Jmp(const ir_node *node)
 	if (get_cfop_target_block(node) != next_block) {
 		be_emit_cstring("\tb ");
 		arm_emit_cfop_target(node);
+		be_emit_finish_line_gas(node);
 	} else {
-		be_emit_cstring("\t/* fallthrough to ");
-		arm_emit_cfop_target(node);
-		be_emit_cstring(" */");
+		if (be_options.verbose_asm) {
+			be_emit_cstring("\t/* fallthrough to ");
+			arm_emit_cfop_target(node);
+			be_emit_cstring(" */");
+			be_emit_finish_line_gas(node);
+		}
 	}
-	be_emit_finish_line_gas(node);
-}
-
-static void emit_arm_fpaDbl2GP(const ir_node *irn)
-{
-	be_emit_cstring("\tstfd ");
-	arm_emit_source_register(irn, 0);
-	be_emit_cstring(", [sp, #-8]!");
-	be_emit_pad_comment();
-	be_emit_cstring("/* Push fp to stack */");
-	be_emit_finish_line_gas(NULL);
-
-	be_emit_cstring("\tldmfd sp!, {");
-	arm_emit_dest_register(irn, 1);
-	be_emit_cstring(", ");
-	arm_emit_dest_register(irn, 0);
-	be_emit_char('}');
-	be_emit_pad_comment();
-	be_emit_cstring("/* Pop destination */");
-	be_emit_finish_line_gas(irn);
-}
-
-static void emit_arm_LdTls(const ir_node *irn)
-{
-	(void) irn;
-	panic("TLS not supported for this target");
-	/* Er... our gcc does not support it... Install a newer toolchain. */
 }
 
 static void emit_nothing(const ir_node *irn)
@@ -951,34 +799,30 @@ static inline void set_emitter(ir_op *op, emit_func arm_emit_node)
 static void arm_register_emitters(void)
 {
 	/* first clear the generic function pointer for all ops */
-	clear_irp_opcodes_generic_func();
+	ir_clear_opcodes_generic_func();
 
 	/* register all emitter functions defined in spec */
 	arm_register_spec_emitters();
 
 	/* custom emitter */
-	set_emitter(op_arm_B,          emit_arm_B);
-	set_emitter(op_arm_CopyB,      emit_arm_CopyB);
-	set_emitter(op_arm_fpaConst,   emit_arm_fpaConst);
-	set_emitter(op_arm_fpaDbl2GP,  emit_arm_fpaDbl2GP);
-	set_emitter(op_arm_FrameAddr,  emit_arm_FrameAddr);
-	set_emitter(op_arm_Jmp,        emit_arm_Jmp);
-	set_emitter(op_arm_LdTls,      emit_arm_LdTls);
-	set_emitter(op_arm_SwitchJmp,  emit_arm_SwitchJmp);
-	set_emitter(op_arm_SymConst,   emit_arm_SymConst);
-	set_emitter(op_be_Call,        emit_be_Call);
-	set_emitter(op_be_Copy,        emit_be_Copy);
-	set_emitter(op_be_CopyKeep,    emit_be_Copy);
-	set_emitter(op_be_IncSP,       emit_be_IncSP);
-	set_emitter(op_be_MemPerm,     emit_be_MemPerm);
-	set_emitter(op_be_Perm,        emit_be_Perm);
-	set_emitter(op_be_Return,      emit_be_Return);
+	set_emitter(op_arm_B,         emit_arm_B);
+	set_emitter(op_arm_CopyB,     emit_arm_CopyB);
+	set_emitter(op_arm_fConst,    emit_arm_fConst);
+	set_emitter(op_arm_FrameAddr, emit_arm_FrameAddr);
+	set_emitter(op_arm_Jmp,       emit_arm_Jmp);
+	set_emitter(op_arm_SwitchJmp, emit_arm_SwitchJmp);
+	set_emitter(op_arm_SymConst,  emit_arm_SymConst);
+	set_emitter(op_be_Copy,       emit_be_Copy);
+	set_emitter(op_be_CopyKeep,   emit_be_Copy);
+	set_emitter(op_be_IncSP,      emit_be_IncSP);
+	set_emitter(op_be_MemPerm,    emit_be_MemPerm);
+	set_emitter(op_be_Perm,       emit_be_Perm);
+	set_emitter(op_be_Return,     emit_be_Return);
+	set_emitter(op_be_Start,      emit_be_Start);
 
 	/* no need to emit anything for the following nodes */
-	set_emitter(op_Phi,            emit_nothing);
-	set_emitter(op_be_Keep,        emit_nothing);
-	set_emitter(op_be_Start,       emit_nothing);
-	set_emitter(op_be_Barrier,     emit_nothing);
+	set_emitter(op_Phi,           emit_nothing);
+	set_emitter(op_be_Keep,       emit_nothing);
 }
 
 /**
@@ -990,11 +834,11 @@ static void arm_emit_node(const ir_node *irn)
 
 	if (op->ops.generic) {
 		emit_func *emit = (emit_func *)op->ops.generic;
-		be_dbg_set_dbg_info(get_irn_dbg_info(irn));
+		be_dwarf_location(get_irn_dbg_info(irn));
 		(*emit)(irn);
 	} else {
 		panic("Error: No emit handler for node %+F (graph %+F)\n",
-		      irn, current_ir_graph);
+		      irn, get_irn_irg(irn));
 	}
 }
 
@@ -1003,12 +847,9 @@ static void arm_emit_node(const ir_node *irn)
  */
 static void arm_emit_block_header(ir_node *block, ir_node *prev)
 {
-	int           n_cfgpreds;
-	int           need_label;
-	int           i, arity;
-	ir_exec_freq  *exec_freq = be_get_irg_exec_freq(cg->irg);
+	bool need_label = false;
+	int  n_cfgpreds;
 
-	need_label = 0;
 	n_cfgpreds = get_Block_n_cfgpreds(block);
 	if (n_cfgpreds == 1) {
 		ir_node *pred       = get_Block_cfgpred(block, 0);
@@ -1018,38 +859,15 @@ static void arm_emit_block_header(ir_node *block, ir_node *prev)
 		 * are no fallthroughs */
 		if (pred_block == prev &&
 				!(is_Proj(pred) && is_arm_SwitchJmp(get_Proj_pred(pred)))) {
-			need_label = 0;
+			need_label = false;
 		} else {
-			need_label = 1;
+			need_label = true;
 		}
 	} else {
-		need_label = 1;
+		need_label = true;
 	}
 
-	if (need_label) {
-		be_gas_emit_block_name(block);
-		be_emit_char(':');
-
-		be_emit_pad_comment();
-		be_emit_cstring("   /* preds:");
-
-		/* emit list of pred blocks in comment */
-		arity = get_irn_arity(block);
-		for (i = 0; i < arity; ++i) {
-			ir_node *predblock = get_Block_cfgpred_block(block, i);
-			be_emit_irprintf(" %d", get_irn_node_nr(predblock));
-		}
-	} else {
-		be_emit_cstring("\t/* ");
-		be_gas_emit_block_name(block);
-		be_emit_cstring(": ");
-	}
-	if (exec_freq != NULL) {
-		be_emit_irprintf(" freq: %f",
-		                 get_block_execfreq(exec_freq, block));
-	}
-	be_emit_cstring(" */\n");
-	be_emit_write_line();
+	be_gas_begin_block(block, need_label);
 }
 
 /**
@@ -1061,7 +879,7 @@ static void arm_gen_block(ir_node *block, ir_node *prev_block)
 	ir_node *irn;
 
 	arm_emit_block_header(block, prev_block);
-	be_dbg_set_dbg_info(get_irn_dbg_info(block));
+	be_dwarf_location(get_irn_dbg_info(block));
 	sched_foreach(block, irn) {
 		arm_emit_node(irn);
 	}
@@ -1088,8 +906,8 @@ static void arm_gen_labels(ir_node *block, void *env)
  */
 static int cmp_sym_or_tv(const void *elt, const void *key, size_t size)
 {
-	const sym_or_tv_t *p1 = elt;
-	const sym_or_tv_t *p2 = key;
+	const sym_or_tv_t *p1 = (const sym_or_tv_t*)elt;
+	const sym_or_tv_t *p2 = (const sym_or_tv_t*)key;
 	(void) size;
 
 	/* as an identifier NEVER can point to a tarval, it's enough
@@ -1097,29 +915,25 @@ static int cmp_sym_or_tv(const void *elt, const void *key, size_t size)
 	return p1->u.generic != p2->u.generic;
 }
 
-/**
- * Main driver. Emits the code for one routine.
- */
-void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg)
+void arm_gen_routine(ir_graph *irg)
 {
-	ir_node   **blk_sched;
-	int       i, n;
-	ir_node   *last_block = NULL;
-	ir_entity *entity     = get_irg_entity(irg);
+	ir_node          *last_block = NULL;
+	ir_entity        *entity     = get_irg_entity(irg);
+	const arch_env_t *arch_env   = be_get_irg_arch_env(irg);
+	ir_node          **blk_sched;
+	size_t           i, n;
 
-	cg        = arm_cg;
+	isa = (arm_isa_t*) arch_env;
 	sym_or_tv = new_set(cmp_sym_or_tv, 8);
 
 	be_gas_elf_type_char = '%';
 
 	arm_register_emitters();
 
-	be_dbg_method_begin(entity, be_abi_get_stack_layout(be_get_irg_abi(cg->irg)));
-
 	/* create the block schedule */
 	blk_sched = be_create_block_schedule(irg);
 
-	be_gas_emit_function_prolog(entity, 4);
+	be_gas_emit_function_prolog(entity, 4, NULL);
 
 	irg_block_walk_graph(irg, arm_gen_labels, NULL, NULL);
 
@@ -1137,35 +951,33 @@ void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg)
 		last_block = block;
 	}
 
-	be_gas_emit_function_epilog(entity);
-	be_dbg_method_end();
-
 	/* emit SymConst values */
 	if (set_count(sym_or_tv) > 0) {
-		sym_or_tv_t *entry;
-
 		be_emit_cstring("\t.align 2\n");
 
-		foreach_set(sym_or_tv, entry) {
-			be_emit_irprintf(".L%u:\n", entry->label);
+		foreach_set(sym_or_tv, sym_or_tv_t, entry) {
+			emit_constant_name(entry);
+			be_emit_cstring(":\n");
+			be_emit_write_line();
 
-			if (entry->is_ident) {
+			if (entry->is_entity) {
 				be_emit_cstring("\t.word\t");
-				be_emit_ident(entry->u.id);
+				be_gas_emit_entity(entry->u.entity);
 				be_emit_char('\n');
 				be_emit_write_line();
 			} else {
-				tarval *tv = entry->u.tv;
-				int i, size = get_mode_size_bytes(get_tarval_mode(tv));
-				unsigned v;
+				ir_tarval *tv = entry->u.tv;
+				int vi;
+				int size = get_mode_size_bytes(get_tarval_mode(tv));
 
 				/* beware: ARM fpa uses big endian format */
-				for (i = ((size + 3) & ~3) - 4; i >= 0; i -= 4) {
+				for (vi = ((size + 3) & ~3) - 4; vi >= 0; vi -= 4) {
 					/* get 32 bits */
-					v =            get_tarval_sub_bits(tv, i+3);
-					v = (v << 8) | get_tarval_sub_bits(tv, i+2);
-					v = (v << 8) | get_tarval_sub_bits(tv, i+1);
-					v = (v << 8) | get_tarval_sub_bits(tv, i+0);
+					unsigned v;
+					v =            get_tarval_sub_bits(tv, vi+3);
+					v = (v << 8) | get_tarval_sub_bits(tv, vi+2);
+					v = (v << 8) | get_tarval_sub_bits(tv, vi+1);
+					v = (v << 8) | get_tarval_sub_bits(tv, vi+0);
 					be_emit_irprintf("\t.word\t%u\n", v);
 					be_emit_write_line();
 				}
@@ -1175,6 +987,8 @@ void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg)
 		be_emit_write_line();
 	}
 	del_set(sym_or_tv);
+
+	be_gas_emit_function_epilog(entity);
 }
 
 void arm_init_emitter(void)