X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fbe%2Farm%2Farm_emitter.c;h=4558bc5869f12190e15c98590c81797a0fb5813f;hb=808762e7935fe025e83507254156d8c7d1fc8b46;hp=868d349f9f1eb00db807661a6d4f7c64146dd495;hpb=de7f21234a9c73f72d516bc731aca617aef66317;p=libfirm

diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index 868d349f9..4558bc586 100644
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -20,16 +20,12 @@
 /**
  * @file
  * @brief   arm emitter
- * @author  Oliver Richter, Tobias Gneist
- * @version $Id$
+ * @author  Oliver Richter, Tobias Gneist, Michael Beck
  */
-#define SILENCER
-
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <limits.h>
+#include <stdbool.h>
 
 #include "xmalloc.h"
 #include "tv.h"
@@ -42,810 +38,702 @@
 #include "irprog_t.h"
 #include "irargs_t.h"
 #include "error.h"
+#include "raw_bitset.h"
+#include "dbginfo.h"
 
-#include "../besched.h"
-#include "../beblocksched.h"
-#include "../beirg_t.h"
-#include "../begnuas.h"
+#include "besched.h"
+#include "beblocksched.h"
+#include "beirg.h"
+#include "begnuas.h"
+#include "bedwarf.h"
 
 #include "arm_emitter.h"
+#include "arm_optimize.h"
 #include "gen_arm_emitter.h"
 #include "arm_nodes_attr.h"
 #include "arm_new_nodes.h"
 #include "arm_map_regs.h"
 #include "gen_arm_regalloc_if.h"
 
-#include "../benode_t.h"
+#include "benode.h"
 
-#define SNPRINTF_BUF_LEN 128
+DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
-static const arch_env_t *arch_env = NULL;
+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 arch_env_t *arch_env, const ir_node *irn, int pos) {
-	ir_node                *op;
-	const arch_register_t  *reg = NULL;
+static void arm_emit_register(const arch_register_t *reg)
+{
+	be_emit_string(reg->name);
+}
 
-	assert(get_irn_arity(irn) > pos && "Invalid IN position");
+static void arm_emit_source_register(const ir_node *node, int pos)
+{
+	const arch_register_t *reg = arch_get_irn_register_in(node, pos);
+	arm_emit_register(reg);
+}
 
-	/* The out register of the operator at position pos is the
-	   in register we need. */
-	op = get_irn_n(irn, pos);
+static void arm_emit_dest_register(const ir_node *node, int pos)
+{
+	const arch_register_t *reg = arch_get_irn_register_out(node, pos);
+	arm_emit_register(reg);
+}
 
-	reg = arch_get_irn_register(arch_env, op);
+static void arm_emit_offset(const ir_node *node)
+{
+	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
+	assert(attr->base.is_load_store);
 
-	assert(reg && "no in register found");
-	return reg;
+	be_emit_irprintf("0x%X", attr->offset);
 }
 
-
 /**
- * Returns the register at out position pos.
+ * Emit the arm fpa instruction suffix depending on the mode.
  */
-static const arch_register_t *get_out_reg(const arch_env_t *arch_env,
-                                          const ir_node *node, int pos)
+static void arm_emit_fpa_postfix(const ir_mode *mode)
 {
-    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(arch_env, node);
-    } else if (is_arm_irn(node)) {
-        reg = get_arm_out_reg(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(arch_env, proj);
-                break;
-            }
-        }
-    }
-
-    assert(reg && "no out register found");
-    return reg;
-}
+	int bits = get_mode_size_bits(mode);
+	char c = 'e';
 
-/*************************************************************
- *             _       _    __   _          _
- *            (_)     | |  / _| | |        | |
- *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
- * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
- * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
- * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
- * | |                                       | |
- * |_|                                       |_|
- *************************************************************/
+	if (bits == 32)
+		c = 's';
+	else if (bits == 64)
+		c = 'd';
+	be_emit_char(c);
+}
 
-/**
- * Emits a block label from the given block.
- */
-static void arm_emit_block_label(arm_emit_env_t *env, const ir_node *block) {
-	be_emit_irprintf(env->emit, "BLOCK_%u", get_irn_node_nr(block));
+static void arm_emit_float_load_store_mode(const ir_node *node)
+{
+	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
+	arm_emit_fpa_postfix(attr->load_store_mode);
 }
 
-/**
- * Emit the name of the source register at given input position.
- */
-void arm_emit_source_register(arm_emit_env_t *env, const ir_node *node, int pos) {
-	const arch_register_t *reg = get_in_reg(env->arch_env, node, pos);
-	be_emit_string(env->emit, arch_register_get_name(reg));
+static 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);
 }
 
-/**
- * Emit the name of the destination register at given output position.
- */
-void arm_emit_dest_register(arm_emit_env_t *env, const ir_node *node, int pos) {
-	const arch_register_t *reg = get_out_reg(env->arch_env, node, pos);
-	be_emit_string(env->emit, arch_register_get_name(reg));
+static 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 */
 }
 
-/**
- * Emit a node's offset.
- */
-void arm_emit_offset(arm_emit_env_t *env, const ir_node *node) {
-	int offset = 0;
-	ir_op *irn_op = get_irn_op(node);
-
-	if (irn_op == op_be_StackParam) {
-		ir_entity *ent = be_get_frame_entity(node);
-		offset = get_entity_offset(ent);
-	} else if (irn_op == op_be_Reload || irn_op == op_be_Spill) {
-		ir_entity *ent = be_get_frame_entity(node);
-		offset = get_entity_offset(ent);
-	} else if (irn_op == op_be_IncSP) {
-		offset = - be_get_IncSP_offset(node);
+static void arm_emit_load_mode(const ir_node *node)
+{
+	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
+	ir_mode *mode      = attr->load_store_mode;
+	int      bits      = get_mode_size_bits(mode);
+	bool     is_signed = mode_is_signed(mode);
+	if (bits == 16) {
+		be_emit_string(is_signed ? "sh" : "h");
+	} else if (bits == 8) {
+		be_emit_string(is_signed ? "sb" : "b");
 	} else {
-		assert(!"unimplemented arm_emit_offset for this node type");
-		panic("unimplemented arm_emit_offset for this node type");
+		assert(bits == 32);
 	}
-	be_emit_irprintf(env->emit, "%d", offset);
 }
 
-/**
- * Emit the arm fpa instruction suffix depending on the mode.
- */
-static void arm_emit_fpa_postfix(arm_emit_env_t *env, ir_mode *mode) {
-	int bits = get_mode_size_bits(mode);
-	if (bits == 32)
-		be_emit_char(env->emit, 's');
-	else if (bits == 64)
-		be_emit_char(env->emit, 'd');
-	else
-		be_emit_char(env->emit, 'e');
-}
-
-/**
- * Emit the instruction suffix depending on the mode.
- */
-void arm_emit_mode(arm_emit_env_t *env, const ir_node *node) {
-	ir_mode *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);
+static void arm_emit_store_mode(const ir_node *node)
+{
+	const arm_load_store_attr_t *attr = get_arm_load_store_attr_const(node);
+	ir_mode *mode      = attr->load_store_mode;
+	int      bits      = get_mode_size_bits(mode);
+	if (bits == 16) {
+		be_emit_cstring("h");
+	} else if (bits == 8) {
+		be_emit_cstring("b");
 	} else {
-		mode = get_irn_mode(node);
+		assert(bits == 32);
 	}
-	arm_emit_fpa_postfix(env, mode);
 }
 
-
-/**
- * Returns non-zero if a mode has a Immediate attribute.
- */
-int is_immediate_node(const ir_node *irn) {
-	const arm_attr_t *attr = get_arm_attr_const(irn);
-	return ARM_GET_SHF_MOD(attr) == ARM_SHF_IMM;
+static void emit_shf_mod_name(arm_shift_modifier_t mod)
+{
+	switch (mod) {
+	case ARM_SHF_ASR_REG:
+	case ARM_SHF_ASR_IMM:
+		be_emit_cstring("asr");
+		return;
+	case ARM_SHF_LSL_REG:
+	case ARM_SHF_LSL_IMM:
+		be_emit_cstring("lsl");
+		return;
+	case ARM_SHF_LSR_REG:
+	case ARM_SHF_LSR_IMM:
+		be_emit_cstring("lsr");
+		return;
+	case ARM_SHF_ROR_REG:
+	case ARM_SHF_ROR_IMM:
+		be_emit_cstring("ror");
+		return;
+	default:
+		break;
+	}
+	panic("can't emit this shf_mod_name %d", (int) mod);
 }
 
-/**
- * Emit a const or SymConst value.
- */
-void arm_emit_immediate(arm_emit_env_t *env, const ir_node *node) {
-	if (is_immediate_node(node)) {
-		be_emit_irprintf(env->emit, "#0x%X", arm_decode_imm_w_shift(get_arm_value(node)));
-	} else if (is_arm_SymConst(node))
-		be_emit_ident(env->emit, get_arm_symconst_id(node));
-	else {
-		assert(!"not a Constant");
+static void arm_emit_shifter_operand(const ir_node *node)
+{
+	const arm_shifter_operand_t *attr = get_arm_shifter_operand_attr_const(node);
+
+	switch (attr->shift_modifier) {
+	case ARM_SHF_REG:
+		arm_emit_source_register(node, get_irn_arity(node) - 1);
+		return;
+	case ARM_SHF_IMM: {
+		unsigned val = attr->immediate_value;
+		val = (val >> attr->shift_immediate)
+			| (val << (32-attr->shift_immediate));
+		val &= 0xFFFFFFFF;
+		be_emit_irprintf("#0x%X", val);
+		return;
 	}
-}
+	case ARM_SHF_ASR_IMM:
+	case ARM_SHF_LSL_IMM:
+	case ARM_SHF_LSR_IMM:
+	case ARM_SHF_ROR_IMM:
+		arm_emit_source_register(node, get_irn_arity(node) - 1);
+		be_emit_cstring(", ");
+		emit_shf_mod_name(attr->shift_modifier);
+		be_emit_irprintf(" #0x%X", attr->shift_immediate);
+		return;
 
-/**
- * Returns the tarval or offset of an arm node as a string.
- */
-void arm_emit_shift(arm_emit_env_t *env, const ir_node *node) {
-	arm_shift_modifier mod;
+	case ARM_SHF_ASR_REG:
+	case ARM_SHF_LSL_REG:
+	case ARM_SHF_LSR_REG:
+	case ARM_SHF_ROR_REG:
+		arm_emit_source_register(node, get_irn_arity(node) - 2);
+		be_emit_cstring(", ");
+		emit_shf_mod_name(attr->shift_modifier);
+		be_emit_cstring(" ");
+		arm_emit_source_register(node, get_irn_arity(node) - 1);
+		return;
 
-	mod = get_arm_shift_modifier(node);
-	if (ARM_HAS_SHIFT(mod)) {
-		long v = get_tarval_long(get_arm_value(node));
+	case ARM_SHF_RRX:
+		arm_emit_source_register(node, get_irn_arity(node) - 1);
+		panic("RRX shifter emitter TODO");
 
-		be_emit_irprintf(env->emit, ", %s #%ld", arm_shf_mod_name(mod), v);
+	case ARM_SHF_INVALID:
+		break;
 	}
+	panic("Invalid shift_modifier while emitting %+F", node);
 }
 
 /** An entry in the sym_or_tv set. */
-typedef struct sym_or_tv {
+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. */
-} sym_or_tv;
+	bool     is_entity;  /**< true if an entity is stored. */
+} sym_or_tv_t;
 
 /**
  * Returns a unique label. This number will not be used a second time.
  */
-static unsigned get_unique_label(void) {
+static unsigned get_unique_label(void)
+{
 	static unsigned id = 0;
 	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);
+}
+
+/**
+ * Returns the target block for a control flow node.
+ */
+static ir_node *get_cfop_target_block(const ir_node *irn)
+{
+	return (ir_node*)get_irn_link(irn);
+}
+
+/**
+ * Emit the target label for a control flow node.
+ */
+static void arm_emit_cfop_target(const ir_node *irn)
+{
+	ir_node *block = get_cfop_target_block(irn);
+
+	be_gas_emit_block_name(block);
+}
+
+void arm_emitf(const ir_node *node, const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	be_emit_char('\t');
+	for (;;) {
+		const char *start = format;
+		while (*format != '%' && *format != '\n'  && *format != '\0')
+			++format;
+		be_emit_string_len(start, format - start);
+
+		if (*format == '\0')
+			break;
+
+		if (*format == '\n') {
+			++format;
+			be_emit_char('\n');
+			be_emit_write_line();
+			be_emit_char('\t');
+			continue;
+		}
+
+		++format;
+
+		switch (*format++) {
+		case '%':
+			be_emit_char('%');
+			break;
+
+		case 'S': {
+			if (*format < '0' || '9' <= *format)
+				goto unknown;
+			unsigned const pos = *format++ - '0';
+			arm_emit_source_register(node, pos);
+			break;
+		}
+
+		case 'D': {
+			if (*format < '0' || '9' <= *format)
+				goto unknown;
+			unsigned const pos = *format++ - '0';
+			arm_emit_dest_register(node, pos);
+			break;
+		}
+
+		case 'I':
+			arm_emit_symconst(node);
+			break;
+
+		case 'o':
+			arm_emit_offset(node);
+			break;
+
+		case 'O':
+			arm_emit_shifter_operand(node);
+			break;
+
+		case 'C': {
+			const sym_or_tv_t *name = va_arg(ap, const sym_or_tv_t*);
+			emit_constant_name(name);
+			break;
+		}
+
+		case 'm': {
+			ir_mode *mode = va_arg(ap, ir_mode*);
+			arm_emit_fpa_postfix(mode);
+			break;
+		}
+
+		case 'M':
+			switch (*format++) {
+			case 'L': arm_emit_load_mode(node);             break;
+			case 'S': arm_emit_store_mode(node);            break;
+			case 'A': arm_emit_float_arithmetic_mode(node); break;
+			case 'F': arm_emit_float_load_store_mode(node); break;
+			default:
+				--format;
+				goto unknown;
+			}
+			break;
+
+		case 'X': {
+			int num = va_arg(ap, int);
+			be_emit_irprintf("%X", num);
+			break;
+		}
+
+		case 'u': {
+			unsigned num = va_arg(ap, unsigned);
+			be_emit_irprintf("%u", num);
+			break;
+		}
+
+		case 'd': {
+			int num = va_arg(ap, int);
+			be_emit_irprintf("%d", num);
+			break;
+		}
+
+		case 's': {
+			const char *string = va_arg(ap, const char *);
+			be_emit_string(string);
+			break;
+		}
+
+		case 'r': {
+			arch_register_t *reg = va_arg(ap, arch_register_t*);
+			arm_emit_register(reg);
+			break;
+		}
+
+		case 't': {
+			const ir_node *n = va_arg(ap, const ir_node*);
+			arm_emit_cfop_target(n);
+			break;
+		}
+
+		default:
+unknown:
+			panic("unknown format conversion");
+		}
+	}
+	va_end(ap);
+	be_emit_finish_line_gas(node);
+}
+
 /**
  * Emit a SymConst.
  */
-static void emit_arm_SymConst(arm_emit_env_t *env, const ir_node *irn) {
-	sym_or_tv key, *entry;
-	unsigned label;
-
-	key.u.id     = get_arm_symconst_id(irn);
-	key.is_ident = 1;
-	key.label    = 0;
-	entry = (sym_or_tv *)set_insert(env->sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
+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;
+
+	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(env->emit, "\tldr ");
-	arm_emit_dest_register(env, irn, 0);
-	be_emit_irprintf(env->emit, ", .L%u", label);
-	be_emit_finish_line_gas(env->emit, irn);
+	arm_emitf(irn, "ldr %D0, %C", entry);
+}
+
+static void emit_arm_FrameAddr(const ir_node *irn)
+{
+	const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(irn);
+	arm_emitf(irn, "add %D0, %S0, #0x%X", attr->fp_offset);
 }
 
 /**
  * Emit a floating point fpa constant.
  */
-static void emit_arm_fpaConst(arm_emit_env_t *env, const ir_node *irn) {
-	sym_or_tv key, *entry;
-	unsigned label;
-	ir_mode *mode;
-
-	key.u.tv     = get_arm_value(irn);
-	key.is_ident = 0;
-	key.label    = 0;
-	entry = (sym_or_tv *)set_insert(env->sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
+static void emit_arm_fConst(const ir_node *irn)
+{
+	sym_or_tv_t key;
+
+	key.u.tv      = get_fConst_value(irn);
+	key.is_entity = false;
+	key.label     = 0;
+	sym_or_tv_t *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);
-	be_emit_cstring(env->emit, "\tldf");
-	arm_emit_fpa_postfix(env, mode);
-	be_emit_char(env->emit, ' ');
-
-	arm_emit_dest_register(env, irn, 0);
-	be_emit_irprintf(env->emit, ", .L%u", label);
-	be_emit_finish_line_gas(env->emit, irn);
+	ir_mode *mode = get_irn_mode(irn);
+	arm_emitf(irn, "ldf%m %D0, %C", mode, entry);
 }
 
 /**
  * Returns the next block in a block schedule.
  */
-static ir_node *sched_next_block(ir_node *block) {
-    return get_irn_link(block);
+static ir_node *sched_next_block(const ir_node *block)
+{
+    return (ir_node*)get_irn_link(block);
 }
 
 /**
- * Emit a conditional jump.
+ * Emit a Compare with conditional branch.
  */
-static void emit_arm_CondJmp(arm_emit_env_t *env, const ir_node *irn) {
-	const ir_edge_t *edge;
-	ir_node *true_block = NULL;
-	ir_node *false_block = NULL;
+static void emit_arm_B(const ir_node *irn)
+{
+	const ir_node *proj_true  = NULL;
+	const ir_node *proj_false = NULL;
+	const ir_node *block;
+	const ir_node *next_block;
 	ir_node *op1 = get_irn_n(irn, 0);
-	ir_mode *opmode = get_irn_mode(op1);
 	const char *suffix;
-	int proj_num = get_arm_CondJmp_proj_num(irn);
+	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));
 
 	foreach_out_edge(irn, edge) {
 		ir_node *proj = get_edge_src_irn(edge);
 		long nr = get_Proj_proj(proj);
-		ir_node *block = get_irn_link(proj);
 		if (nr == pn_Cond_true) {
-			true_block = block;
+			proj_true = proj;
 		} else {
-			false_block = block;
+			proj_false = proj;
 		}
 	}
 
-	if (proj_num == pn_Cmp_False) {
-		/* always false: should not happen */
-		be_emit_cstring(env->emit, "\tb ");
-		arm_emit_block_label(env, false_block);
-		be_emit_finish_line_gas(env->emit, irn);
-	} else if (proj_num == pn_Cmp_True) {
-		/* always true: should not happen */
-		be_emit_cstring(env->emit, "\tb ");
-		arm_emit_block_label(env, true_block);
-		be_emit_finish_line_gas(env->emit, irn);
-	} else {
-		ir_node *block = get_nodes_block(irn);
+	if (cmp_attr->ins_permuted) {
+		relation = get_inversed_relation(relation);
+	}
 
-		if (mode_is_float(opmode)) {
-			suffix = "ICHWILLIMPLEMENTIERTWERDEN";
+	/* for now, the code works for scheduled and non-schedules blocks */
+	block = get_nodes_block(irn);
 
-			be_emit_cstring(env->emit, "\tfcmp ");
-			arm_emit_source_register(env, irn, 0);
-			be_emit_cstring(env->emit, ", ");
-			arm_emit_source_register(env, irn, 1);
-			be_emit_finish_line_gas(env->emit, irn);
+	/* we have a block schedule */
+	next_block = sched_next_block(block);
 
-			be_emit_cstring(env->emit, "\tfmstat");
-			be_emit_pad_comment(env->emit);
-			be_emit_cstring(env->emit, "/* FCSPR -> CPSR */");
-			be_emit_finish_line_gas(env->emit, NULL);
-		} else {
-			if (true_block == sched_next_block(block)) {
-				/* negate it */
-				proj_num = get_negated_pnc(proj_num, opmode);
-			}
-			switch (proj_num) {
-				case pn_Cmp_Eq:  suffix = "eq"; break;
-				case pn_Cmp_Lt:  suffix = "lt"; break;
-				case pn_Cmp_Le:  suffix = "le"; break;
-				case pn_Cmp_Gt:  suffix = "gt"; break;
-				case pn_Cmp_Ge:  suffix = "ge"; break;
-				case pn_Cmp_Lg:  suffix = "ne"; break;
-				case pn_Cmp_Leg: suffix = "al"; break;
-				default: assert(!"Cmp unsupported"); suffix = "al";
-			}
-			be_emit_cstring(env->emit, "\tcmp ");
-			arm_emit_source_register(env, irn, 0);
-			be_emit_cstring(env->emit, ", ");
-			arm_emit_source_register(env, irn, 1);
-			be_emit_finish_line_gas(env->emit, irn);
-		}
+	assert(relation != ir_relation_false);
+	assert(relation != ir_relation_true);
 
-		if (true_block == sched_next_block(block)) {
-			be_emit_irprintf(env->emit, "\tb%s ", suffix);
-			arm_emit_block_label(env, true_block);
-			be_emit_pad_comment(env->emit);
-			be_emit_cstring(env->emit, "/* false case */");
-			be_emit_finish_line_gas(env->emit, NULL);
-
-			be_emit_pad_comment(env->emit);
-			be_emit_cstring(env->emit, "/* fallthrough ");
-			arm_emit_block_label(env, false_block);
-			be_emit_cstring(env->emit, " */");
-			be_emit_finish_line_gas(env->emit, NULL);
-		} else {
-			be_emit_irprintf(env->emit, "\tb%s ", suffix);
-			arm_emit_block_label(env, true_block);
-			be_emit_pad_comment(env->emit);
-			be_emit_cstring(env->emit, "/* true case */");
-			be_emit_finish_line_gas(env->emit, NULL);
-
-			if (false_block == sched_next_block(block)) {
-				be_emit_pad_comment(env->emit);
-				be_emit_cstring(env->emit, "/* fallthrough ");
-				arm_emit_block_label(env, false_block);
-				be_emit_cstring(env->emit, " */");
-				be_emit_finish_line_gas(env->emit, NULL);
-			} else {
-				be_emit_cstring(env->emit, "b ");
-				arm_emit_block_label(env, false_block);
-				be_emit_pad_comment(env->emit);
-				be_emit_cstring(env->emit, "/* false case */");
-				be_emit_finish_line_gas(env->emit, NULL);
-			}
+	if (get_cfop_target_block(proj_true) == next_block) {
+		/* exchange both proj's so the second one can be omitted */
+		const ir_node *t = proj_true;
+
+		proj_true  = proj_false;
+		proj_false = t;
+		relation   = get_negated_relation(relation);
+	}
+
+	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 */
+	arm_emitf(irn, "b%s %t", suffix, proj_true);
+
+	if (get_cfop_target_block(proj_false) == next_block) {
+		if (be_options.verbose_asm) {
+			arm_emitf(irn, "/* fallthrough to %t */", proj_false);
 		}
+	} else {
+		arm_emitf(irn, "b %t", proj_false);
 	}
 }
 
+/** Sort register in ascending order. */
+static int reg_cmp(const void *a, const void *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);
+}
+
 /**
  * Create the CopyB instruction sequence.
  */
-static void emit_arm_CopyB(arm_emit_env_t *env, const ir_node *irn) {
-	unsigned int size = get_tarval_long(get_arm_value(irn));
-
-	be_emit_cstring(env->emit, "/* MemCopy (");
-	arm_emit_source_register(env, irn, 1);
-	be_emit_cstring(env->emit, ")->(");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_irprintf(env->emit, " [%d bytes], Uses ", size);
-	arm_emit_source_register(env, irn, 2);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 3);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 4);
-	be_emit_cstring(env->emit, ", and %r12 */");
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	assert ( size > 0 && "CopyB needs size > 0" );
-	if (size & 3)
+static void emit_arm_CopyB(const ir_node *irn)
+{
+	const arm_CopyB_attr_t *attr = get_arm_CopyB_attr_const(irn);
+	unsigned size = attr->size;
+	const arch_register_t *tmpregs[4];
+
+	/* collect the temporary registers and sort them, we need ascending order */
+	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);
+
+	if (be_options.verbose_asm) {
+		arm_emitf(irn, "/* MemCopy (%S1)->(%S0) [%u bytes], Uses %r, %r, %r and %r */",
+		          size, tmpregs[0], tmpregs[1], tmpregs[2], tmpregs[3]);
+	}
+
+	assert(size > 0 && "CopyB needs size > 0" );
+
+	if (size & 3) {
+		fprintf(stderr, "strange hack enabled: copy more bytes than needed!");
 		size += 4;
+	}
+
 	size >>= 2;
-	switch(size & 3) {
+	switch (size & 3) {
 	case 0:
 		break;
 	case 1:
-		be_emit_cstring(env->emit, "\tldr %%r12, [");
-		arm_emit_source_register(env, irn, 1);
-		be_emit_cstring(env->emit, ", #0]!");
-		be_emit_finish_line_gas(env->emit, NULL);
-
-		be_emit_cstring(env->emit, "\tstr %%r12, [");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, ", #0]!");
-		be_emit_finish_line_gas(env->emit, irn);
+		arm_emitf(irn, "ldr %r, [%S1, #0]", tmpregs[3]);
+		arm_emitf(irn, "str %r, [%S0, #0]", tmpregs[3]);
 		break;
 	case 2:
-		be_emit_cstring(env->emit, "\tldmia ");
-		arm_emit_source_register(env, irn, 1);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, NULL);
-
-		be_emit_cstring(env->emit, "\tstmia ");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, irn);
+		arm_emitf(irn, "ldmia %S1!, {%r, %r}", tmpregs[0], tmpregs[1]);
+		arm_emitf(irn, "stmia %S0!, {%r, %r}", tmpregs[0], tmpregs[1]);
 		break;
 	case 3:
-		be_emit_cstring(env->emit, "\tldmia ");
-		arm_emit_source_register(env, irn, 1);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 3);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, NULL);
-
-		be_emit_cstring(env->emit, "\tstmia ");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 3);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, irn);
+		arm_emitf(irn, "ldmia %S1!, {%r, %r, %r}", tmpregs[0], tmpregs[1], tmpregs[2]);
+		arm_emitf(irn, "stmia %S0!, {%r, %r, %r}", tmpregs[0], tmpregs[1], tmpregs[2]);
 		break;
 	}
 	size >>= 2;
 	while (size) {
-		be_emit_cstring(env->emit, "\tldmia ");
-		arm_emit_source_register(env, irn, 1);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 3);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 4);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, NULL);
-
-		be_emit_cstring(env->emit, "\tstmia ");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, "!, {%r12, ");
-		arm_emit_source_register(env, irn, 2);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 3);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 4);
-		be_emit_char(env->emit, '}');
-		be_emit_finish_line_gas(env->emit, irn);
+		arm_emitf(irn, "ldmia %S1!, {%r, %r, %r}", tmpregs[0], tmpregs[1], tmpregs[2], tmpregs[3]);
+		arm_emitf(irn, "stmia %S0!, {%r, %r, %r}", tmpregs[0], tmpregs[1], tmpregs[2], tmpregs[3]);
 		--size;
 	}
 }
 
-static void emit_arm_SwitchJmp(arm_emit_env_t *env, 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_block = NULL;
-
-	block_nr = get_irn_node_nr(irn);
-	n_projs = get_arm_SwitchJmp_n_projs(irn);
-
-	projs = xcalloc(n_projs , sizeof(ir_node*));
-
-	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_block = get_irn_link(proj);
+static void emit_arm_SwitchJmp(const ir_node *irn)
+{
+	const arm_SwitchJmp_attr_t *attr = get_arm_SwitchJmp_attr_const(irn);
+	arm_emitf(irn, "ldrls pc, [pc, %S0, asl #2]");
 
-		projs[get_Proj_proj(proj)] = proj;
-	}
-	assert(default_block != NULL);
-
-	/*
-	   CMP %1S, n_projs - 1
-	   BHI default
-	*/
-
-	be_emit_cstring(env->emit, "\tcmp ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_irprintf(env->emit, ", #%u", n_projs - 1);
-	be_emit_finish_line_gas(env->emit, irn);
-
-	be_emit_cstring(env->emit, "\tbhi ");
-	arm_emit_block_label(env, default_block);
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	/*
-	   LDR %r12, .TABLE_X_START
-	   ADD %r12, %r12, [%1S, LSL #2]
-	   LDR %r15, %r12
-	 */
-
-	be_emit_irprintf(env->emit, "\tldr %%r12, TABLE_%d_START", block_nr);
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_irprintf(env->emit, "\tadd %%r12, %%r12, ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", LSL #2");
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_cstring(env->emit, "\tldr %r15, [%r12, #0]");
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_irprintf(env->emit, "TABLE_%d_START:\n\t.word\tTABLE_%d", block_nr, block_nr);
-	be_emit_finish_line_gas(env->emit, NULL);
-	be_emit_irprintf(env->emit, "\t.align 2");
-	be_emit_finish_line_gas(env->emit, NULL);
-	be_emit_irprintf(env->emit, "TABLE_%d:", block_nr);
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	for (i = 0; i < n_projs; ++i) {
-		ir_node *block;
-		proj = projs[i];
-		if ( proj ) {
-			block = get_irn_link(proj);
-		} else {
-			block = get_irn_link(projs[get_arm_SwitchJmp_default_proj_num(irn)]);
-		}
-		be_emit_cstring(env->emit, "\t.word\t");
-		arm_emit_block_label(env, block);
-		be_emit_finish_line_gas(env->emit, NULL);
-	}
-	be_emit_irprintf(env->emit, "\t.align 2\n");
-	be_emit_finish_line_gas(env->emit, NULL);
-	xfree(projs);
+	be_emit_jump_table(irn, attr->table, NULL, get_cfop_target_block);
 }
 
-/************************************************************************/
-/* emit_be                                                              */
-/************************************************************************/
-
-static void emit_be_Call(arm_emit_env_t *env, const ir_node *irn) {
-	ir_entity *ent = be_Call_get_entity(irn);
+/** Emit an IncSP node */
+static void emit_be_IncSP(const ir_node *irn)
+{
+	int offs = -be_get_IncSP_offset(irn);
 
-	be_emit_cstring(env->emit, "\tbl ");
-	if (ent) {
-		mark_entity_visited(ent);
-		be_emit_ident(env->emit, get_entity_ld_ident(ent));
-	} else {
-		arm_emit_source_register(env, irn, be_pos_Call_ptr);
-	}
-	be_emit_finish_line_gas(env->emit, irn);
-}
+	if (offs == 0)
+		return;
 
-/** Emit an IncSP node */
-static void emit_be_IncSP(arm_emit_env_t *env, const ir_node *irn) {
-	int offs = be_get_IncSP_offset(irn);
-
-	if (offs != 0) {
-		be_emit_cstring(env->emit, "\tadd ");
-		arm_emit_dest_register(env, irn, 0);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, ", #");
-		arm_emit_offset(env, irn);
-	} else {
-		be_emit_cstring(env->emit, "\t/* omitted IncSP(");
-		arm_emit_offset(env, irn);
-		be_emit_cstring(env->emit,") */");
+	const char *op = "add";
+	if (offs < 0) {
+		op   = "sub";
+		offs = -offs;
 	}
-	be_emit_finish_line_gas(env->emit, irn);
+	arm_emitf(irn, "%s %D0, %S0, #0x%X", op, offs);
 }
 
-static void emit_be_Copy(arm_emit_env_t *env, const ir_node *irn) {
+static void emit_be_Copy(const ir_node *irn)
+{
 	ir_mode *mode = get_irn_mode(irn);
 
-	if (get_in_reg(env->arch_env, irn, 0) == get_out_reg(env->arch_env, irn, 0)) {
-		be_emit_cstring(env->emit, "\t/* omitted Copy: ");
-		arm_emit_source_register(env, irn, 0);
-		be_emit_cstring(env->emit, " -> ");
-		arm_emit_dest_register(env, irn, 0);
-		be_emit_finish_line_gas(env->emit, irn);
+	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(env->cg->isa)) {
-			be_emit_cstring(env->emit, "\tmvf");
-			arm_emit_mode(env, irn);
-			be_emit_char(env->emit, ' ');
-			arm_emit_dest_register(env, irn, 0);
-			be_emit_cstring(env->emit, ", ");
-			arm_emit_source_register(env, irn, 0);
-			be_emit_finish_line_gas(env->emit, irn);
+		if (USE_FPA(isa)) {
+			arm_emitf(irn, "mvf %D0, %S0");
 		} else {
-			assert(0 && "move not supported for this mode");
-			panic("emit_be_Copy: move not supported for this mode");
+			panic("move not supported for this mode");
 		}
-	} else if (mode_is_numP(mode)) {
-		be_emit_cstring(env->emit, "\tmov ");
-		arm_emit_dest_register(env, irn, 0);
-		be_emit_cstring(env->emit, ", ");
-		arm_emit_source_register(env, irn, 0);
-			be_emit_finish_line_gas(env->emit, irn);
+	} else if (mode_is_data(mode)) {
+		arm_emitf(irn, "mov %D0, %S0");
 	} else {
-		assert(0 && "move not supported for this mode");
-		panic("emit_be_Copy: move not supported for this mode");
+		panic("move not supported for this mode");
 	}
 }
 
-/**
- * Emit code for a Spill.
- */
-static void emit_be_Spill(arm_emit_env_t *env, const ir_node *irn) {
-	ir_mode *mode = get_irn_mode(be_get_Spill_val(irn));
-
-	if (mode_is_float(mode)) {
-		if (USE_FPA(env->cg->isa)) {
-			be_emit_cstring(env->emit, "\tstf");
-			arm_emit_fpa_postfix(env, mode);
-			be_emit_char(env->emit, ' ');
-		} else {
-			assert(0 && "spill not supported for this mode");
-			panic("emit_be_Spill: spill not supported for this mode");
-		}
-	} else if (mode_is_dataM(mode)) {
-		be_emit_cstring(env->emit, "\tstr ");
-	} else {
-		assert(0 && "spill not supported for this mode");
-		panic("emit_be_Spill: spill not supported for this mode");
-	}
-	arm_emit_source_register(env, irn, 1);
-	be_emit_cstring(env->emit, ", [");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", #");
-	arm_emit_offset(env, irn);
-	be_emit_char(env->emit, ']');
-	be_emit_finish_line_gas(env->emit, irn);
+static void emit_be_Perm(const ir_node *irn)
+{
+	arm_emitf(irn,
+		"eor %S0, %S0, %S1\n"
+		"eor %S1, %S0, %S1\n"
+		"eor %S0, %S0, %S1");
 }
 
-/**
- * Emit code for a Reload.
- */
-static void emit_be_Reload(arm_emit_env_t *env, const ir_node *irn) {
-	ir_mode *mode = get_irn_mode(irn);
+static void emit_be_MemPerm(const ir_node *node)
+{
+	int i;
+	int memperm_arity;
+	int sp_change = 0;
+
+	/* TODO: this implementation is slower than necessary.
+	   The longterm goal is however to avoid the memperm node completely */
+
+	memperm_arity = be_get_MemPerm_entity_arity(node);
+	if (memperm_arity > 12)
+		panic("memperm with more than 12 inputs not supported yet");
+
+	for (i = 0; i < memperm_arity; ++i) {
+		/* spill register */
+		arm_emitf(node, "str r%d, [sp, #-4]!", i);
+		sp_change += 4;
+		/* load from entity */
+		ir_entity *entity = be_get_MemPerm_in_entity(node, i);
+		int        offset = get_entity_offset(entity) + sp_change;
+		arm_emitf(node, "ldr r%d, [sp, #%d]", i, offset);
+	}
 
-	if (mode_is_float(mode)) {
-		if (USE_FPA(env->cg->isa)) {
-			be_emit_cstring(env->emit, "\tldf");
-			arm_emit_fpa_postfix(env, mode);
-			be_emit_char(env->emit, ' ');
-		} else {
-			assert(0 && "reload not supported for this mode");
-			panic("emit_be_Reload: reload not supported for this mode");
-		}
-	} else if (mode_is_dataM(mode)) {
-		be_emit_cstring(env->emit, "\tldr ");
-	} else {
-		assert(0 && "reload not supported for this mode");
-		panic("emit_be_Reload: reload not supported for this mode");
+	for (i = memperm_arity-1; i >= 0; --i) {
+		/* store to new entity */
+		ir_entity *entity = be_get_MemPerm_out_entity(node, i);
+		int        offset = get_entity_offset(entity) + sp_change;
+		arm_emitf(node, "str r%d, [sp, #%d]", i, offset);
+		/* restore register */
+		arm_emitf(node, "ldr r%d, [sp], #4", i);
+		sp_change -= 4;
 	}
-	arm_emit_dest_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", [");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", #");
-	arm_emit_offset(env, irn);
-	be_emit_char(env->emit, ']');
-	be_emit_finish_line_gas(env->emit, irn);
+	assert(sp_change == 0);
 }
 
-static void emit_be_Perm(arm_emit_env_t *env, const ir_node *irn) {
-	be_emit_cstring(env->emit, "\teor ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 1);
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_cstring(env->emit, "\teor ");
-	arm_emit_source_register(env, irn, 1);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 1);
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_cstring(env->emit, "\teor ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_source_register(env, irn, 1);
-	be_emit_finish_line_gas(env->emit, irn);
+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) {
+		arm_emitf(node, "sub sp, sp, #0x%X", size);
+	}
 }
 
-static void emit_be_StackParam(arm_emit_env_t *env, const ir_node *irn) {
-	ir_mode *mode = get_irn_mode(irn);
+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);
 
-	if (mode_is_float(mode)) {
-		if (USE_FPA(env->cg->isa)) {
-			be_emit_cstring(env->emit,"\tldf");
-			arm_emit_fpa_postfix(env, mode);
-			be_emit_char(env->emit, ' ');
-		} else {
-			assert(0 && "stackparam not supported for this mode");
-			panic("emit_be_StackParam: stackparam not supported for this mode");
-		}
-	} else {
-		be_emit_cstring(env->emit,"\tldr ");
+	/* deallocate stackframe */
+	if (size > 0) {
+		arm_emitf(node, "add sp, sp, #0x%X", size);
 	}
-	arm_emit_dest_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", [");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit,", #");
-	arm_emit_offset(env, irn);
-	be_emit_finish_line_gas(env->emit, irn);
+	arm_emitf(node, "mov pc, lr");
 }
 
-/************************************************************************/
-/* emit                                                                 */
-/************************************************************************/
-
-static void emit_Jmp(arm_emit_env_t *env, const ir_node *irn) {
-	const ir_edge_t *edge = get_irn_out_edge_first(irn);
-	ir_node *target_block = get_edge_src_irn(edge);
-	ir_node *block = get_nodes_block(irn);
-
-	if (target_block == sched_next_block(block)) {
-		be_emit_pad_comment(env->emit);
-		be_emit_cstring(env->emit, "/* fallthrough ");
-		arm_emit_block_label(env, target_block);
-		be_emit_cstring(env->emit, " */");
-		be_emit_finish_line_gas(env->emit, NULL);
+
+static void emit_arm_Jmp(const ir_node *node)
+{
+	ir_node *block, *next_block;
+
+	/* for now, the code works for scheduled and non-schedules blocks */
+	block = get_nodes_block(node);
+
+	/* we have a block schedule */
+	next_block = sched_next_block(block);
+	if (get_cfop_target_block(node) != next_block) {
+		arm_emitf(node, "b %t", node);
 	} else {
-		be_emit_cstring(env->emit, "\tb ");
-		arm_emit_block_label(env, target_block);
-		be_emit_finish_line_gas(env->emit, irn);
+		if (be_options.verbose_asm) {
+			arm_emitf(node, "/* fallthrough to %t */", node);
+		}
 	}
 }
 
-static void emit_arm_fpaDbl2GP(arm_emit_env_t *env, const ir_node *irn) {
-	be_emit_cstring(env->emit, "\tstfd ");
-	arm_emit_source_register(env, irn, 0);
-	be_emit_cstring(env->emit, ", [sp, #-8]!");
-	be_emit_pad_comment(env->emit);
-	be_emit_cstring(env->emit, "/* Push fp to stack */");
-	be_emit_finish_line_gas(env->emit, NULL);
-
-	be_emit_cstring(env->emit, "\tldmfd sp!, {");
-	arm_emit_dest_register(env, irn, 1);
-	be_emit_cstring(env->emit, ", ");
-	arm_emit_dest_register(env, irn, 0);
-	be_emit_char(env->emit, '}');
-	be_emit_pad_comment(env->emit);
-	be_emit_cstring(env->emit, "/* Pop destination */");
-	be_emit_finish_line_gas(env->emit, irn);
-}
-
-/***********************************************************************************
- *                  _          __                                             _
- *                 (_)        / _|                                           | |
- *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
- * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
- * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
- * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
- *
- ***********************************************************************************/
-
-static void emit_silence(arm_emit_env_t *env, const ir_node *irn) {
-	/* Do nothing. */
+static void emit_nothing(const ir_node *irn)
+{
+	(void) irn;
 }
 
 /**
  * The type of a emitter function.
  */
-typedef void (emit_func)(arm_emit_env_t *env, const ir_node *irn);
+typedef void (emit_func)(const ir_node *irn);
 
 /**
  * Set a node emitter. Make it a bit more type safe.
  */
-static INLINE void set_emitter(ir_op *op, emit_func arm_emit_node) {
+static inline void set_emitter(ir_op *op, emit_func arm_emit_node)
+{
 	op->ops.generic = (op_func)arm_emit_node;
 }
 
@@ -853,124 +741,102 @@ static INLINE void set_emitter(ir_op *op, emit_func arm_emit_node) {
  * Enters the emitter functions for handled nodes into the generic
  * pointer of an opcode.
  */
-static void arm_register_emitters(void) {
-
-#define ARM_EMIT(a)  set_emitter(op_arm_##a, emit_arm_##a)
-#define EMIT(a)      set_emitter(op_##a, emit_##a)
-#define BE_EMIT(a)   set_emitter(op_be_##a, emit_be_##a)
-#define SILENCE(a)   set_emitter(op_##a, emit_silence)
-
+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();
 
-	/* other emitter functions */
-	ARM_EMIT(CondJmp);
-	ARM_EMIT(CopyB);
-// 	ARM_EMIT(CopyB_i);
-//	ARM_EMIT(Const);
-	ARM_EMIT(SymConst);
-	ARM_EMIT(SwitchJmp);
-	ARM_EMIT(fpaDbl2GP);
-	ARM_EMIT(fpaConst);
-
-	/* benode emitter */
- 	BE_EMIT(Call);
- 	BE_EMIT(IncSP);
-// 	BE_EMIT(AddSP);
-	BE_EMIT(Copy);
-	BE_EMIT(Spill);
-	BE_EMIT(Reload);
-	BE_EMIT(Perm);
-	BE_EMIT(StackParam);
-
-	/* firm emitter */
-	EMIT(Jmp);
-
-	/* noisy stuff */
-#ifdef SILENCER
-	SILENCE(Start);
-	SILENCE(Proj);
-	SILENCE(Phi);
-	SILENCE(be_Keep);
-	SILENCE(be_CopyKeep);
-	SILENCE(be_RegParams);
-	SILENCE(be_Barrier);
-	SILENCE(be_Return);
-#endif
-
-#undef ARM_EMIT
-#undef BE_EMIT
-#undef EMIT
-#undef SILENCE
+	/* custom emitter */
+	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);
 }
 
 /**
  * Emits code for a node.
  */
-static void arm_emit_node(arm_emit_env_t *env, const ir_node *irn) {
+static void arm_emit_node(const ir_node *irn)
+{
 	ir_op *op = get_irn_op(irn);
 
 	if (op->ops.generic) {
 		emit_func *emit = (emit_func *)op->ops.generic;
-		(*emit)(env, irn);
+		be_dwarf_location(get_irn_dbg_info(irn));
+		(*emit)(irn);
 	} else {
-		be_emit_cstring(env->emit, "\t/* TODO */");
-		be_emit_finish_line_gas(env->emit, irn);
+		panic("Error: No emit handler for node %+F (graph %+F)\n",
+		      irn, get_irn_irg(irn));
 	}
 }
 
 /**
- * Walks over the nodes in a block connected by scheduling edges
- * and emits code for each node.
+ * emit the block label if needed.
  */
-void arm_gen_block(ir_node *block, void *ctx) {
-	arm_emit_env_t *env = ctx;
-	ir_node *irn;
-
-	arm_emit_block_label(env, block);
-	be_emit_cstring(env->emit, ":\n");
-	be_emit_write_line(env->emit);
-
-	sched_foreach(block, irn) {
-		arm_emit_node(env, irn);
+static void arm_emit_block_header(ir_node *block, ir_node *prev)
+{
+	bool need_label = false;
+	int  n_cfgpreds;
+
+	n_cfgpreds = get_Block_n_cfgpreds(block);
+	if (n_cfgpreds == 1) {
+		ir_node *pred       = get_Block_cfgpred(block, 0);
+		ir_node *pred_block = get_nodes_block(pred);
+
+		/* we don't need labels for fallthrough blocks, however switch-jmps
+		 * are no fallthroughs */
+		if (pred_block == prev &&
+				!(is_Proj(pred) && is_arm_SwitchJmp(get_Proj_pred(pred)))) {
+			need_label = false;
+		} else {
+			need_label = true;
+		}
+	} else {
+		need_label = true;
 	}
-}
 
-
-/**
- * Emits code for function start.
- */
-void arm_func_prolog(arm_emit_env_t *env, ir_graph *irg) {
-	be_emit_env_t *eenv = env->emit;
-	ir_entity *ent = get_irg_entity(irg);
-	const char *irg_name = get_entity_ld_name(ent);
-
-	be_emit_write_line(eenv);
-	be_gas_emit_switch_section(eenv, GAS_SECTION_TEXT);
-	be_emit_cstring(eenv, "\t.align  2\n");
-
-	if (get_entity_visibility(ent) == visibility_external_visible)
-		be_emit_irprintf(eenv, "\t.global %s\n", irg_name);
-	be_emit_irprintf(eenv, "%s:\n", irg_name);
+	be_gas_begin_block(block, need_label);
 }
 
 /**
- * Emits code for function end
+ * Walks over the nodes in a block connected by scheduling edges
+ * and emits code for each node.
  */
-void arm_emit_end(FILE *F, ir_graph *irg) {
-	fprintf(F, "\t.ident \"firmcc\"\n");
+static void arm_gen_block(ir_node *block, ir_node *prev_block)
+{
+	arm_emit_block_header(block, prev_block);
+	be_dwarf_location(get_irn_dbg_info(block));
+	sched_foreach(block, irn) {
+		arm_emit_node(irn);
+	}
 }
 
 /**
+ * Block-walker:
  * Sets labels for control flow nodes (jump target)
- * TODO: Jump optimization
  */
-void arm_gen_labels(ir_node *block, void *env) {
+static void arm_gen_labels(ir_node *block, void *env)
+{
 	ir_node *pred;
 	int n = get_Block_n_cfgpreds(block);
+	(void)env;
 
 	for (n--; n >= 0; n--) {
 		pred = get_Block_cfgpred(block, n);
@@ -981,40 +847,38 @@ void arm_gen_labels(ir_node *block, void *env) {
 /**
  * Compare two entries of the symbol or tarval set.
  */
-static int cmp_sym_or_tv(const void *elt, const void *key, size_t size) {
-	const sym_or_tv *p1 = elt;
-	const sym_or_tv *p2 = key;
+static int cmp_sym_or_tv(const void *elt, const void *key, size_t size)
+{
+	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
 	   to compare it this way */
 	return p1->u.generic != p2->u.generic;
 }
 
-/**
- * Main driver. Emits the code for one routine.
- */
-void arm_gen_routine(const arm_code_gen_t *cg, ir_graph *irg)
+void arm_gen_routine(ir_graph *irg)
 {
-	arm_emit_env_t emit_env;
-	ir_node **blk_sched;
-	int i, n;
+	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;
 
-	emit_env.emit      = &cg->isa->emit;
-	emit_env.arch_env  = cg->arch_env;
-	emit_env.cg        = cg;
-	emit_env.sym_or_tv = new_set(cmp_sym_or_tv, 8);
-	FIRM_DBG_REGISTER(emit_env.mod, "firm.be.arm.emit");
+	isa = (arm_isa_t*) arch_env;
+	sym_or_tv = new_set(cmp_sym_or_tv, 8);
 
-	/* set the global arch_env (needed by print hooks) */
-	arch_env = cg->arch_env;
+	be_gas_elf_type_char = '%';
 
 	arm_register_emitters();
 
-	/* create the block schedule. For now, we don't need it earlier. */
-	blk_sched = be_create_block_schedule(cg->irg, cg->birg->exec_freq);
+	/* create the block schedule */
+	blk_sched = be_create_block_schedule(irg);
+
+	be_gas_emit_function_prolog(entity, 4, NULL);
 
-	arm_func_prolog(&emit_env, irg);
-	irg_block_walk_graph(irg, arm_gen_labels, NULL, &emit_env);
+	irg_block_walk_graph(irg, arm_gen_labels, NULL, NULL);
 
 	n = ARR_LEN(blk_sched);
 	for (i = 0; i < n;) {
@@ -1026,42 +890,51 @@ void arm_gen_routine(const arm_code_gen_t *cg, ir_graph *irg)
 
 		/* set here the link. the emitter expects to find the next block here */
 		set_irn_link(block, next_bl);
-		arm_gen_block(block, &emit_env);
+		arm_gen_block(block, last_block);
+		last_block = block;
 	}
 
 	/* emit SymConst values */
-	if (set_count(emit_env.sym_or_tv) > 0) {
-		sym_or_tv *entry;
-
-		be_emit_cstring(emit_env.emit, "\t.align 2\n");
-
-		foreach_set(emit_env.sym_or_tv, entry) {
-			be_emit_irprintf(emit_env.emit, ".L%u:\n", entry->label);
-
-			if (entry->is_ident) {
-				be_emit_cstring(emit_env.emit, "\t.word\t");
-				be_emit_ident(emit_env.emit, entry->u.id);
-				be_emit_char(emit_env.emit, '\n');
-				be_emit_write_line(emit_env.emit);
+	if (set_count(sym_or_tv) > 0) {
+		be_emit_cstring("\t.align 2\n");
+
+		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_entity) {
+				be_emit_cstring("\t.word\t");
+				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 bigendian format */
-				for (i = ((size + 3) & ~3) - 4; i >= 0; i -= 4) {
+				/* beware: ARM fpa uses big endian format */
+				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);
-					be_emit_irprintf(emit_env.emit, "\t.word\t%u\n", v);
-					be_emit_write_line(emit_env.emit);
+					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();
 				}
 			}
 		}
-		be_emit_char(emit_env.emit, '\n');
-		be_emit_write_line(emit_env.emit);
+		be_emit_char('\n');
+		be_emit_write_line();
 	}
-	del_set(emit_env.sym_or_tv);
+	del_set(sym_or_tv);
+
+	be_gas_emit_function_epilog(entity);
+}
+
+void arm_init_emitter(void)
+{
+	FIRM_DBG_REGISTER(dbg, "firm.be.arm.emit");
 }