From 637450acaf2ef255b2841785a6c6e6b809c9ac27 Mon Sep 17 00:00:00 2001
From: Matthias Braun <matze@braunis.de>
Date: Thu, 22 Jul 2010 19:08:05 +0000
Subject: [PATCH] perform custom abi construction in sparc as well to handle
 floatingpoint

[r27788]
---
 ir/be/arm/arm_cconv.c                 |   4 +-
 ir/be/arm/arm_cconv.h                 |   4 +-
 ir/be/arm/arm_spec.pl                 |   5 +-
 ir/be/arm/arm_transform.c             |  12 +-
 ir/be/beabihelper.c                   |  22 +-
 ir/be/scripts/generate_new_opcodes.pl |   4 +-
 ir/be/sparc/bearch_sparc.c            | 220 +-------
 ir/be/sparc/sparc_cconv.c             | 151 ++++++
 ir/be/sparc/sparc_cconv.h             | 130 +++++
 ir/be/sparc/sparc_emitter.c           |  26 +-
 ir/be/sparc/sparc_new_nodes.c         |   6 +
 ir/be/sparc/sparc_new_nodes.h         |   2 +
 ir/be/sparc/sparc_nodes_attr.h        |   2 +
 ir/be/sparc/sparc_spec.pl             |  79 ++-
 ir/be/sparc/sparc_transform.c         | 731 ++++++++++++++++++++++----
 15 files changed, 1030 insertions(+), 368 deletions(-)
 create mode 100644 ir/be/sparc/sparc_cconv.c
 create mode 100644 ir/be/sparc/sparc_cconv.h

diff --git a/ir/be/arm/arm_cconv.c b/ir/be/arm/arm_cconv.c
index 6baa2da34..287a6ddf5 100644
--- a/ir/be/arm/arm_cconv.c
+++ b/ir/be/arm/arm_cconv.c
@@ -31,7 +31,7 @@
 #include "xmalloc.h"
 #include "error.h"
 
-calling_convention_t *decide_calling_convention(ir_type *function_type)
+calling_convention_t *arm_decide_calling_convention(ir_type *function_type)
 {
 	int                   stack_offset = 0;
 	reg_or_stackslot_t   *params;
@@ -128,7 +128,7 @@ calling_convention_t *decide_calling_convention(ir_type *function_type)
 	return cconv;
 }
 
-void free_calling_convention(calling_convention_t *cconv)
+void arm_free_calling_convention(calling_convention_t *cconv)
 {
 	free(cconv->parameters);
 	free(cconv->results);
diff --git a/ir/be/arm/arm_cconv.h b/ir/be/arm/arm_cconv.h
index 82c6ecc4f..bfc0202ff 100644
--- a/ir/be/arm/arm_cconv.h
+++ b/ir/be/arm/arm_cconv.h
@@ -102,11 +102,11 @@ typedef struct calling_convention_t
  * Decides what goes to register or to stack and what stack offsets/
  * datatypes are used.
  */
-calling_convention_t *decide_calling_convention(ir_type *function_type);
+calling_convention_t *arm_decide_calling_convention(ir_type *function_type);
 
 /**
  * free memory used by a calling_convention_t
  */
-void free_calling_convention(calling_convention_t *cconv);
+void arm_free_calling_convention(calling_convention_t *cconv);
 
 #endif
diff --git a/ir/be/arm/arm_spec.pl b/ir/be/arm/arm_spec.pl
index 8b8a8ca17..944059b42 100644
--- a/ir/be/arm/arm_spec.pl
+++ b/ir/be/arm/arm_spec.pl
@@ -316,7 +316,6 @@ LinkMovPC => {
 	                "\tarch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 	emit         => ". mov lr, pc\n".
 	                ". mov pc, %SO",
-	mode         => "mode_T",
 },
 
 # mov lr, pc\n ldr pc, XXX -- This combination is used for calls to function
@@ -330,7 +329,6 @@ LinkLdrPC => {
 	custominit   => "arch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 	emit         => ". mov lr, pc\n".
 	                ". ldr pc, %SO",
-	mode         => "mode_T",
 },
 
 Bl => {
@@ -341,7 +339,6 @@ Bl => {
 	attr       => "ir_entity *entity, int symconst_offset",
 	custominit => "arch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 	emit       => '. bl %SC',
-	mode       => "mode_T",
 },
 
 # this node produces ALWAYS an empty (tempary) gp reg and cannot be CSE'd
@@ -442,7 +439,7 @@ Str => {
 	op_flags  => [ "labeled", "fragile" ],
 	state     => "exc_pinned",
 	ins       => [ "ptr", "val", "mem" ],
-	outs      => [ "mem" ],
+	outs      => [ "M" ],
 	reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 	emit      => '. str%SM %S1, [%S0, #%O]',
 	mode      => "mode_M",
diff --git a/ir/be/arm/arm_transform.c b/ir/be/arm/arm_transform.c
index 59514e8dd..63ea34eb0 100644
--- a/ir/be/arm/arm_transform.c
+++ b/ir/be/arm/arm_transform.c
@@ -1299,7 +1299,7 @@ static ir_node *gen_Proj_Proj_Call(ir_node *node)
 	ir_node              *call          = get_Proj_pred(get_Proj_pred(node));
 	ir_node              *new_call      = be_transform_node(call);
 	ir_type              *function_type = get_Call_type(call);
-	calling_convention_t *cconv = decide_calling_convention(function_type);
+	calling_convention_t *cconv = arm_decide_calling_convention(function_type);
 	const reg_or_stackslot_t *res = &cconv->results[pn];
 	ir_mode              *mode;
 	int                   regn;
@@ -1312,7 +1312,7 @@ static ir_node *gen_Proj_Proj_Call(ir_node *node)
 	}
 	mode = res->reg0->reg_class->mode;
 
-	free_calling_convention(cconv);
+	arm_free_calling_convention(cconv);
 
 	return new_r_Proj(new_call, mode, regn);
 }
@@ -1616,7 +1616,7 @@ static ir_node *gen_Call(ir_node *node)
 	ir_node              *new_mem      = be_transform_node(mem);
 	dbg_info             *dbgi         = get_irn_dbg_info(node);
 	ir_type              *type         = get_Call_type(node);
-	calling_convention_t *cconv        = decide_calling_convention(type);
+	calling_convention_t *cconv        = arm_decide_calling_convention(type);
 	int                   n_params     = get_Call_n_params(node);
 	int                   n_param_regs = sizeof(param_regs)/sizeof(param_regs[0]);
 	/* max inputs: memory, callee, register arguments */
@@ -1782,7 +1782,7 @@ static ir_node *gen_Call(ir_node *node)
 	/* copy pinned attribute */
 	set_irn_pinned(res, get_irn_pinned(node));
 
-	free_calling_convention(cconv);
+	arm_free_calling_convention(cconv);
 	return res;
 }
 
@@ -1941,7 +1941,7 @@ void arm_transform_graph(arm_code_gen_t *cg)
 	abihelper = be_abihelper_prepare(irg);
 	be_collect_stacknodes(abihelper);
 	assert(cconv == NULL);
-	cconv = decide_calling_convention(get_entity_type(entity));
+	cconv = arm_decide_calling_convention(get_entity_type(entity));
 	create_stacklayout(irg);
 
 	be_transform_graph(cg->irg, NULL);
@@ -1949,7 +1949,7 @@ void arm_transform_graph(arm_code_gen_t *cg)
 	be_abihelper_finish(abihelper);
 	abihelper = NULL;
 
-	free_calling_convention(cconv);
+	arm_free_calling_convention(cconv);
 	cconv = NULL;
 
 	frame_type = get_irg_frame_type(irg);
diff --git a/ir/be/beabihelper.c b/ir/be/beabihelper.c
index 40890a639..0022c37f1 100644
--- a/ir/be/beabihelper.c
+++ b/ir/be/beabihelper.c
@@ -132,8 +132,8 @@ static void rsm_clear_regs(register_state_mapping_t *rsm,
 	}
 }
 
-static void rsm_add_reg(register_state_mapping_t *rsm,
-                        const arch_register_t *reg, arch_irn_flags_t flags)
+static int rsm_add_reg(register_state_mapping_t *rsm,
+                       const arch_register_t *reg, arch_irn_flags_t flags)
 {
 	int        input_idx = ARR_LEN(rsm->regs);
 	int        cls_idx   = reg->reg_class->index;
@@ -144,6 +144,12 @@ static void rsm_add_reg(register_state_mapping_t *rsm,
 	assert(rsm->reg_index_map[cls_idx][reg_idx] == -1);
 	rsm->reg_index_map[cls_idx][reg_idx] = input_idx;
 	ARR_APP1(reg_flag_t, rsm->regs, regflag);
+
+	if (rsm->value_map != NULL) {
+		ARR_APP1(ir_node*, rsm->value_map, NULL);
+		assert(ARR_LEN(rsm->value_map) == ARR_LEN(rsm->regs));
+	}
+	return input_idx;
 }
 
 
@@ -317,8 +323,8 @@ void be_epilog_begin(beabi_helper_env_t *env)
 void be_epilog_add_reg(beabi_helper_env_t *env, const arch_register_t *reg,
                        arch_irn_flags_t flags, ir_node *value)
 {
-	rsm_add_reg(&env->epilog, reg, flags);
-	ARR_APP1(ir_node*, env->epilog.value_map, value);
+	int index = rsm_add_reg(&env->epilog, reg, flags);
+	rsm_set_value(&env->epilog, index, value);
 }
 
 void be_epilog_set_reg_value(beabi_helper_env_t *env,
@@ -379,7 +385,7 @@ ir_node *be_epilog_create_return(beabi_helper_env_t *env, dbg_info *dbgi,
 static void add_missing_keep_walker(ir_node *node, void *data)
 {
 	int              n_outs, i;
-	unsigned         found_projs = 0;
+	unsigned        *found_projs;
 	const ir_edge_t *edge;
 	ir_mode         *mode = get_irn_mode(node);
 	ir_node         *last_keep;
@@ -391,7 +397,7 @@ static void add_missing_keep_walker(ir_node *node, void *data)
 	if (n_outs <= 0)
 		return;
 
-	assert(n_outs < (int) sizeof(unsigned) * 8);
+	rbitset_alloca(found_projs, n_outs);
 	foreach_out_edge(node, edge) {
 		ir_node *succ = get_edge_src_irn(edge);
 		int      pn;
@@ -405,7 +411,7 @@ static void add_missing_keep_walker(ir_node *node, void *data)
 
 		pn = get_Proj_proj(succ);
 		assert(pn < n_outs);
-		found_projs |= 1 << pn;
+		rbitset_set(found_projs, pn);
 	}
 
 
@@ -417,7 +423,7 @@ static void add_missing_keep_walker(ir_node *node, void *data)
 		const arch_register_req_t   *req;
 		const arch_register_class_t *cls;
 
-		if (found_projs & (1 << i)) {
+		if (rbitset_is_set(found_projs, i)) {
 			continue;
 		}
 
diff --git a/ir/be/scripts/generate_new_opcodes.pl b/ir/be/scripts/generate_new_opcodes.pl
index 648608638..4e35413fe 100755
--- a/ir/be/scripts/generate_new_opcodes.pl
+++ b/ir/be/scripts/generate_new_opcodes.pl
@@ -206,7 +206,9 @@ sub create_constructor {
 	} elsif($out_arity eq "dynamic") {
 		$out_arity = $ARITY_DYNAMIC;
 	}
-
+	if ($out_arity != 0 && $out_arity != 1 && !defined($known_mode)) {
+		$known_mode = "mode_T";
+	}
 
 	my $comment = $n->{"comment"};
 	if(!exists($n->{"comment"})) {
diff --git a/ir/be/sparc/bearch_sparc.c b/ir/be/sparc/bearch_sparc.c
index c9a6c1a09..e96fbf963 100644
--- a/ir/be/sparc/bearch_sparc.c
+++ b/ir/be/sparc/bearch_sparc.c
@@ -48,7 +48,6 @@
 #include "../belower.h"
 #include "../besched.h"
 #include "be.h"
-#include "../beabi.h"
 #include "../bemachine.h"
 #include "../beilpsched.h"
 #include "../bemodule.h"
@@ -182,10 +181,9 @@ static void sparc_before_ra(void *self)
  */
 static void transform_Reload(ir_node *node)
 {
-	ir_graph  *irg    = get_irn_irg(node);
 	ir_node   *block  = get_nodes_block(node);
 	dbg_info  *dbgi   = get_irn_dbg_info(node);
-	ir_node   *ptr    = get_irg_frame(irg);
+	ir_node   *ptr    = get_irn_n(node, be_pos_Spill_frame);
 	ir_node   *mem    = get_irn_n(node, be_pos_Reload_mem);
 	ir_mode   *mode   = get_irn_mode(node);
 	ir_entity *entity = be_get_frame_entity(node);
@@ -212,10 +210,9 @@ static void transform_Reload(ir_node *node)
  */
 static void transform_Spill(ir_node *node)
 {
-	ir_graph  *irg    = get_irn_irg(node);
 	ir_node   *block  = get_nodes_block(node);
 	dbg_info  *dbgi   = get_irn_dbg_info(node);
-	ir_node   *ptr    = get_irg_frame(irg);
+	ir_node   *ptr    = get_irn_n(node, be_pos_Spill_frame);
 	ir_node   *mem    = new_NoMem();
 	ir_node   *val    = get_irn_n(node, be_pos_Spill_val);
 	ir_mode   *mode   = get_irn_mode(val);
@@ -313,16 +310,17 @@ static void *sparc_cg_init(ir_graph *irg)
 const arch_isa_if_t sparc_isa_if;
 static sparc_isa_t sparc_isa_template = {
 	{
-		&sparc_isa_if,           /* isa interface implementation */
-		&sparc_gp_regs[REG_SP],  /* stack pointer register */
-		&sparc_gp_regs[REG_FP],  /* base pointer register */
-		&sparc_reg_classes[CLASS_sparc_gp],  /* link pointer register class */
-		-1,                          /* stack direction */
-		3,                           /* power of two stack alignment for calls, 2^2 == 4 */
-		NULL,                        /* main environment */
-		7,                           /* costs for a spill instruction */
-		5,                           /* costs for a reload instruction */
-		false,                       /* no custom abi handling */
+		&sparc_isa_if,                      /* isa interface implementation */
+		&sparc_gp_regs[REG_SP],             /* stack pointer register */
+		&sparc_gp_regs[REG_FRAME_POINTER],  /* base pointer register */
+		&sparc_reg_classes[CLASS_sparc_gp], /* link pointer register class */
+		-1,                                 /* stack direction */
+		3,                                  /* power of two stack alignment
+		                                       for calls */
+		NULL,                               /* main environment */
+		7,                                  /* costs for a spill instruction */
+		5,                                  /* costs for a reload instruction */
+		true,                               /* custom abi handling */
 	},
 	NULL						/* current code generator */
 };
@@ -468,196 +466,6 @@ static const arch_register_class_t *sparc_get_reg_class_for_mode(const ir_mode *
 		return &sparc_reg_classes[CLASS_sparc_gp];
 }
 
-
-
-typedef struct {
-	be_abi_call_flags_bits_t flags;
-	ir_graph                *irg;
-} sparc_abi_env_t;
-
-static void *sparc_abi_init(const be_abi_call_t *call, ir_graph *irg)
-{
-	sparc_abi_env_t *env = XMALLOC(sparc_abi_env_t);
-	be_abi_call_flags_t fl = be_abi_call_get_flags(call);
-	env->flags    = fl.bits;
-	env->irg      = irg;
-	return env;
-}
-
-/**
- * Get the between type for that call.
- * @param self The callback object.
- * @return The between type of for that call.
- */
-static ir_type *sparc_get_between_type(void *self)
-{
-	static ir_type *between_type = NULL;
-	(void) self;
-
-	if (between_type == NULL) {
-		between_type = new_type_class(new_id_from_str("sparc_between_type"));
-		set_type_size_bytes(between_type, SPARC_MIN_STACKSIZE);
-	}
-
-	return between_type;
-}
-
-
-/**
- * Build the prolog, return the BASE POINTER register
- */
-static const arch_register_t *sparc_abi_prologue(void *self, ir_node **mem,
-                                                 pmap *reg_map, int *stack_bias)
-{
-	sparc_abi_env_t *env = self;
-	ir_node *block = get_irg_start_block(env->irg);
-	const arch_register_t *fp = &sparc_gp_regs[REG_FP];
-	const arch_register_t *sp = &sparc_gp_regs[REG_SP];
-
-	// sp
-	ir_node *sp_proj = be_abi_reg_map_get(reg_map, sp);
-
-
-	//ir_type *frame_type = get_irg_frame_type(env->irg);
-	//frame_alloc_area(frame_type, reserved_stack_size, 1, 1);
-
-	// alloc min required stack space
-	// TODO: the min stacksize depends on wether this is a leaf procedure or not
-	ir_node *save = new_bd_sparc_Save(NULL, block, sp_proj, *mem, SPARC_MIN_STACKSIZE);
-
-	(void) reg_map;
-	(void) mem;
-	(void) stack_bias;
-
-	sp_proj = new_r_Proj(save, sp->reg_class->mode, pn_sparc_Save_stack);
-	*mem    = new_r_Proj(save, mode_M, pn_sparc_Save_mem);
-
-	arch_set_irn_register(sp_proj, sp);
-	be_abi_reg_map_set(reg_map, sp, sp_proj);
-
-	// we always have a framepointer
-	return fp;
-}
-
-/* Build the epilog */
-static void sparc_abi_epilogue(void *self, ir_node *bl, ir_node **mem,
-                               pmap *reg_map)
-{
-	(void) self;
-	(void) bl;
-	(void) mem;
-	(void) reg_map;
-}
-
-static const be_abi_callbacks_t sparc_abi_callbacks = {
-	sparc_abi_init,
-	free,
-	sparc_get_between_type,
-	sparc_abi_prologue,
-	sparc_abi_epilogue,
-};
-
-static const arch_register_t *gp_param_out_regs[] = {
-	&sparc_gp_regs[REG_O0],
-	&sparc_gp_regs[REG_O1],
-	&sparc_gp_regs[REG_O2],
-	&sparc_gp_regs[REG_O3],
-	&sparc_gp_regs[REG_O4],
-	&sparc_gp_regs[REG_O5],
-};
-
-static const arch_register_t *gp_param_in_regs[] = {
-	&sparc_gp_regs[REG_I0],
-	&sparc_gp_regs[REG_I1],
-	&sparc_gp_regs[REG_I2],
-	&sparc_gp_regs[REG_I3],
-	&sparc_gp_regs[REG_I4],
-	&sparc_gp_regs[REG_I5],
-};
-
-/**
- * get register for outgoing parameters 1-6
- */
-static const arch_register_t *sparc_get_RegParamOut_reg(int n)
-{
-	assert(n < 6 && n >=0 && "trying to get (out) register for param >= 6");
-	return gp_param_out_regs[n];
-}
-
-/**
- * get register for incoming parameters 1-6
- */
-static const arch_register_t *sparc_get_RegParamIn_reg(int n)
-{
-	assert(n < 6 && n >=0 && "trying to get (in) register for param >= 6");
-	return gp_param_in_regs[n];
-}
-
-/**
- * Get the ABI restrictions for procedure calls.
- * @param self        The this pointer.
- * @param method_type The type of the method (procedure) in question.
- * @param abi         The abi object to be modified
- */
-static void sparc_get_call_abi(const void *self, ir_type *method_type,
-                               be_abi_call_t *abi)
-{
-	ir_type  *tp;
-	ir_mode  *mode;
-	int       i, n = get_method_n_params(method_type);
-	be_abi_call_flags_t call_flags;
-	(void) self;
-
-	/* set abi flags for calls */
-	call_flags.bits.left_to_right         = 0;
-	call_flags.bits.store_args_sequential = 1;
-	call_flags.bits.try_omit_fp           = 0;
-	call_flags.bits.fp_free               = 0;
-	call_flags.bits.call_has_imm          = 1;
-
-	/* set stack parameter passing style */
-	be_abi_call_set_flags(abi, call_flags, &sparc_abi_callbacks);
-
-	for (i = 0; i < n; i++) {
-		ir_type *type = get_method_param_type(method_type, i);
-		ir_mode *mode = get_type_mode(type);
-
-		if (mode_is_float(mode) || i >= 6) {
-			unsigned align = get_type_size_bytes(type);
-			be_abi_call_param_stack(abi, i, mode, align, 0, 0,
-			                        ABI_CONTEXT_BOTH);
-			continue;
-		}
-
-		/* pass integer params 0-5 via registers.
-		 * On sparc we need to set the ABI context since register names of
-		 * parameters change to i0-i5 if we are the callee */
-		be_abi_call_param_reg(abi, i, sparc_get_RegParamOut_reg(i),
-		                      ABI_CONTEXT_CALLER);
-		be_abi_call_param_reg(abi, i, sparc_get_RegParamIn_reg(i),
-		                      ABI_CONTEXT_CALLEE);
-	}
-
-	n = get_method_n_ress(method_type);
-	/* more than 1 result not supported */
-	assert(n <= 1);
-	for (i = 0; i < n; ++i) {
-		tp   = get_method_res_type(method_type, i);
-		mode = get_type_mode(tp);
-
-		/* set return value register: return value is in i0 resp. f0 */
-		if (mode_is_float(mode)) {
-			be_abi_call_res_reg(abi, i, &sparc_fp_regs[REG_F0],
-			                    ABI_CONTEXT_BOTH);
-		} else {
-			be_abi_call_res_reg(abi, i, &sparc_gp_regs[REG_I0],
-			                    ABI_CONTEXT_CALLEE);
-			be_abi_call_res_reg(abi, i, &sparc_gp_regs[REG_O0],
-			                    ABI_CONTEXT_CALLER);
-		}
-	}
-}
-
 static int sparc_to_appear_in_schedule(void *block_env, const ir_node *irn)
 {
 	(void) block_env;
@@ -773,7 +581,7 @@ const arch_isa_if_t sparc_isa_if = {
 	sparc_get_n_reg_class,
 	sparc_get_reg_class,
 	sparc_get_reg_class_for_mode,
-	sparc_get_call_abi,
+	NULL,
 	sparc_get_code_generator_if,
 	sparc_get_list_sched_selector,
 	sparc_get_ilp_sched_selector,
diff --git a/ir/be/sparc/sparc_cconv.c b/ir/be/sparc/sparc_cconv.c
new file mode 100644
index 000000000..8554227af
--- /dev/null
+++ b/ir/be/sparc/sparc_cconv.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief   calling convention helpers
+ * @author  Matthias Braun
+ * @version $Id$
+ */
+#include "config.h"
+
+#include "sparc_cconv.h"
+#include "irmode.h"
+#include "typerep.h"
+#include "xmalloc.h"
+#include "error.h"
+
+static const arch_register_t *map_i_to_o_reg(const arch_register_t *reg)
+{
+	unsigned idx = arch_register_get_index(reg);
+	assert(REG_I0 <= idx && idx <= REG_I7);
+	idx += REG_O0 - REG_I0;
+	assert(REG_O0 <= idx && idx <= REG_O7);
+	return &sparc_gp_regs[idx];
+}
+
+calling_convention_t *sparc_decide_calling_convention(ir_type *function_type,
+                                                      bool caller)
+{
+	int                   stack_offset = 0;
+	reg_or_stackslot_t   *params;
+	reg_or_stackslot_t   *results;
+	int                   n_param_regs
+		= sizeof(param_regs)/sizeof(param_regs[0]);
+	int                   n_float_result_regs
+		= sizeof(float_result_regs)/sizeof(float_result_regs[0]);
+	int                   n_params;
+	int                   n_results;
+	int                   i;
+	int                   regnum;
+	int                   float_regnum;
+	calling_convention_t *cconv;
+
+	/* determine how parameters are passed */
+	n_params = get_method_n_params(function_type);
+	regnum   = 0;
+	params   = XMALLOCNZ(reg_or_stackslot_t, n_params);
+
+	for (i = 0; i < n_params; ++i) {
+		ir_type            *param_type = get_method_param_type(function_type,i);
+		ir_mode            *mode       = get_type_mode(param_type);
+		int                 bits       = get_mode_size_bits(mode);
+		reg_or_stackslot_t *param      = &params[i];
+		param->type = param_type;
+
+		if (regnum < n_param_regs) {
+			const arch_register_t *reg = param_regs[regnum++];
+			if (caller)
+				reg = map_i_to_o_reg(reg);
+			param->reg0 = reg;
+		} else {
+			param->offset = stack_offset;
+			/* increase offset 4 bytes so everything is aligned */
+			stack_offset += bits > 32 ? bits/8 : 4;
+			continue;
+		}
+
+		/* we might need a 2nd 32bit component (for 64bit or double values) */
+		if (bits > 32) {
+			if (bits > 64)
+				panic("only 32 and 64bit modes supported in sparc backend");
+
+			if (regnum < n_param_regs) {
+				const arch_register_t *reg = param_regs[regnum++];
+				if (caller)
+					reg = map_i_to_o_reg(reg);
+				param->reg1 = reg;
+			} else {
+				ir_mode *mode = param_regs[0]->reg_class->mode;
+				ir_type *type = get_type_for_mode(mode);
+				param->type   = type;
+				param->offset = stack_offset;
+				assert(get_mode_size_bits(mode) == 32);
+				stack_offset += 4;
+			}
+		}
+	}
+
+	/* determine how results are passed */
+	n_results    = get_method_n_ress(function_type);
+	regnum       = 0;
+	float_regnum = 0;
+	results      = XMALLOCNZ(reg_or_stackslot_t, n_results);
+	for (i = 0; i < n_results; ++i) {
+		ir_type            *result_type = get_method_res_type(function_type, i);
+		ir_mode            *result_mode = get_type_mode(result_type);
+		reg_or_stackslot_t *result      = &results[i];
+
+		if (mode_is_float(result_mode)) {
+			if (float_regnum >= n_float_result_regs) {
+				panic("Too many float results for sparc backend");
+			} else {
+				const arch_register_t *reg = float_result_regs[float_regnum++];
+				result->reg0 = reg;
+			}
+		} else {
+			if (get_mode_size_bits(result_mode) > 32) {
+				panic("Results with more than 32bits not supported by sparc backend yet");
+			}
+
+			if (regnum >= n_param_regs) {
+				panic("Too many results for sparc backend");
+			} else {
+				const arch_register_t *reg = param_regs[regnum++];
+				if (caller)
+					reg = map_i_to_o_reg(reg);
+				result->reg0 = reg;
+			}
+		}
+	}
+
+	cconv                   = XMALLOCZ(calling_convention_t);
+	cconv->parameters       = params;
+	cconv->param_stack_size = stack_offset;
+	cconv->results          = results;
+
+	return cconv;
+}
+
+void sparc_free_calling_convention(calling_convention_t *cconv)
+{
+	free(cconv->parameters);
+	free(cconv->results);
+	free(cconv);
+}
diff --git a/ir/be/sparc/sparc_cconv.h b/ir/be/sparc/sparc_cconv.h
new file mode 100644
index 000000000..c8a31d089
--- /dev/null
+++ b/ir/be/sparc/sparc_cconv.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief   support functions for calling conventions
+ * @author  Matthias Braun
+ * @version $Id$
+ */
+#ifndef FIRM_BE_SPARC_SPARC_CCONV_H
+#define FIRM_BE_SPARC_SPARC_CCONV_H
+
+#include "firm_types.h"
+#include "../be_types.h"
+#include "gen_sparc_regalloc_if.h"
+
+static const arch_register_t *const caller_saves[] = {
+	&sparc_gp_regs[REG_G1],
+	&sparc_gp_regs[REG_G2],
+	&sparc_gp_regs[REG_G3],
+	&sparc_gp_regs[REG_G4],
+	&sparc_gp_regs[REG_O0],
+	&sparc_gp_regs[REG_O1],
+	&sparc_gp_regs[REG_O2],
+	&sparc_gp_regs[REG_O3],
+	&sparc_gp_regs[REG_O4],
+	&sparc_gp_regs[REG_O5],
+
+	&sparc_fp_regs[REG_F0],
+	&sparc_fp_regs[REG_F1],
+	&sparc_fp_regs[REG_F2],
+	&sparc_fp_regs[REG_F3],
+	&sparc_fp_regs[REG_F4],
+	&sparc_fp_regs[REG_F5],
+	&sparc_fp_regs[REG_F6],
+	&sparc_fp_regs[REG_F7],
+	&sparc_fp_regs[REG_F8],
+	&sparc_fp_regs[REG_F9],
+	&sparc_fp_regs[REG_F10],
+	&sparc_fp_regs[REG_F11],
+	&sparc_fp_regs[REG_F12],
+	&sparc_fp_regs[REG_F13],
+	&sparc_fp_regs[REG_F14],
+	&sparc_fp_regs[REG_F15],
+	&sparc_fp_regs[REG_F16],
+	&sparc_fp_regs[REG_F17],
+	&sparc_fp_regs[REG_F18],
+	&sparc_fp_regs[REG_F19],
+	&sparc_fp_regs[REG_F20],
+	&sparc_fp_regs[REG_F21],
+	&sparc_fp_regs[REG_F22],
+	&sparc_fp_regs[REG_F23],
+	&sparc_fp_regs[REG_F24],
+	&sparc_fp_regs[REG_F25],
+	&sparc_fp_regs[REG_F26],
+	&sparc_fp_regs[REG_F27],
+	&sparc_fp_regs[REG_F28],
+	&sparc_fp_regs[REG_F29],
+	&sparc_fp_regs[REG_F30],
+	&sparc_fp_regs[REG_F31],
+};
+
+static const arch_register_t* const param_regs[] = {
+	&sparc_gp_regs[REG_I0],
+	&sparc_gp_regs[REG_I1],
+	&sparc_gp_regs[REG_I2],
+	&sparc_gp_regs[REG_I3],
+	&sparc_gp_regs[REG_I4],
+	&sparc_gp_regs[REG_I5],
+};
+
+static const arch_register_t* const float_result_regs[] = {
+	&sparc_fp_regs[REG_F0],
+	&sparc_fp_regs[REG_F1],
+	&sparc_fp_regs[REG_F2],
+	&sparc_fp_regs[REG_F3],
+};
+
+/** information about a single parameter or result */
+typedef struct reg_or_stackslot_t
+{
+	const arch_register_t *reg0;   /**< if != NULL, the first register used for
+	                                    this parameter. */
+	const arch_register_t *reg1;   /**< if != NULL, the second register used. */
+	ir_type               *type;   /**< indicates that an entity of the specific
+									    type is needed */
+	int                    offset; /**< if transmitted via stack, the offset for
+	                                    this parameter. */
+	ir_entity             *entity; /**< entity in frame type */
+} reg_or_stackslot_t;
+
+/** The calling convention info for one call site. */
+typedef struct calling_convention_t
+{
+	reg_or_stackslot_t *parameters;       /**< parameter info. */
+	int                 param_stack_size; /**< stack size for parameters */
+	reg_or_stackslot_t *results;          /**< result info. */
+} calling_convention_t;
+
+/**
+ * determine how function parameters and return values are passed.
+ * Decides what goes to register or to stack and what stack offsets/
+ * datatypes are used.
+ * @param caller   true for convention for the caller, false for callee
+ */
+calling_convention_t *sparc_decide_calling_convention(ir_type *function_type,
+                                                      bool caller);
+
+/**
+ * free memory used by a calling_convention_t
+ */
+void sparc_free_calling_convention(calling_convention_t *cconv);
+
+#endif
diff --git a/ir/be/sparc/sparc_emitter.c b/ir/be/sparc/sparc_emitter.c
index d7e9579eb..d9544a195 100644
--- a/ir/be/sparc/sparc_emitter.c
+++ b/ir/be/sparc/sparc_emitter.c
@@ -53,8 +53,6 @@
 #include "sparc_new_nodes.h"
 #include "gen_sparc_regalloc_if.h"
 
-
-#define SNPRINTF_BUF_LEN 128
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
 /**
@@ -438,24 +436,24 @@ static void emit_be_Return(const ir_node *irn)
 /**
  * Emits code for Call node
  */
-static void emit_be_Call(const ir_node *irn)
+static void emit_sparc_Call(const ir_node *node)
 {
-	ir_entity *entity = be_Call_get_entity(irn);
+	const sparc_attr_t *attr   = get_sparc_attr_const(node);
+	ir_entity          *entity = attr->immediate_value_entity;
 
+	be_emit_cstring("\tcall ");
 	if (entity != NULL) {
-		be_emit_cstring("\tcall ");
 	    sparc_emit_entity(entity);
 		be_emit_cstring(", 0");
-		be_emit_finish_line_gas(irn);
-		be_emit_cstring("\tnop");
-		be_emit_pad_comment();
-		be_emit_cstring("/* TODO: use delay slot */\n");
 	} else {
-		be_emit_cstring("\tnop\n");
-		be_emit_pad_comment();
-		be_emit_cstring("/* TODO: Entity == NULL */\n");
-		be_emit_finish_line_gas(irn);
+		int last = get_irn_arity(node);
+		sparc_emit_source_register(node, last-1);
 	}
+	be_emit_finish_line_gas(node);
+
+	/* fill delay slot */
+	be_emit_cstring("\tnop");
+	be_emit_finish_line_gas(node);
 }
 
 /**
@@ -764,7 +762,6 @@ static void sparc_register_emitters(void)
 	sparc_register_spec_emitters();
 
 	/* custom emitter */
-	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);
@@ -772,6 +769,7 @@ static void sparc_register_emitters(void)
 	set_emitter(op_be_Perm,         emit_be_Perm);
 	set_emitter(op_be_Return,       emit_be_Return);
 	set_emitter(op_sparc_BXX,       emit_sparc_BXX);
+	set_emitter(op_sparc_Call,      emit_sparc_Call);
 	set_emitter(op_sparc_Div,       emit_sparc_Div);
 	set_emitter(op_sparc_FrameAddr, emit_sparc_FrameAddr);
 	set_emitter(op_sparc_HiImm,     emit_sparc_HiImm);
diff --git a/ir/be/sparc/sparc_new_nodes.c b/ir/be/sparc/sparc_new_nodes.c
index 3feb19341..9e387ab16 100644
--- a/ir/be/sparc/sparc_new_nodes.c
+++ b/ir/be/sparc/sparc_new_nodes.c
@@ -225,6 +225,12 @@ const arch_register_req_t **get_sparc_in_req_all(const ir_node *node)
 	return attr->in_req;
 }
 
+void set_sparc_in_req_all(ir_node *node, const arch_register_req_t **reqs)
+{
+	sparc_attr_t *attr = get_sparc_attr(node);
+	attr->in_req = reqs;
+}
+
 /**
  * Returns the argument register requirement at position pos of an sparc node.
  */
diff --git a/ir/be/sparc/sparc_new_nodes.h b/ir/be/sparc/sparc_new_nodes.h
index 28c2bd07b..93d073c85 100644
--- a/ir/be/sparc/sparc_new_nodes.h
+++ b/ir/be/sparc/sparc_new_nodes.h
@@ -53,6 +53,8 @@ const sparc_save_attr_t *get_sparc_save_attr_const(const ir_node *node);
  */
 const arch_register_req_t **get_sparc_in_req_all(const ir_node *node);
 
+void set_sparc_in_req_all(ir_node *node, const arch_register_req_t **reqs);
+
 /**
  * Returns the argument register requirements of an sparc node.
  */
diff --git a/ir/be/sparc/sparc_nodes_attr.h b/ir/be/sparc/sparc_nodes_attr.h
index ca40638ee..c48f313ef 100644
--- a/ir/be/sparc/sparc_nodes_attr.h
+++ b/ir/be/sparc/sparc_nodes_attr.h
@@ -38,6 +38,8 @@ struct sparc_attr_t
 	const arch_register_req_t **in_req;             /**< register requirements for arguments */
 	int                         immediate_value;    /* immediate values */
 	bool                        is_load_store;
+
+	ir_entity                  *immediate_value_entity; /* hack for now */
 };
 
 /**
diff --git a/ir/be/sparc/sparc_spec.pl b/ir/be/sparc/sparc_spec.pl
index 1442e8ccd..1f3713c91 100644
--- a/ir/be/sparc/sparc_spec.pl
+++ b/ir/be/sparc/sparc_spec.pl
@@ -54,7 +54,7 @@ $state       = 32; # register represents a state
 		{ name => "i3", realname => "i3", type => 0 }, # param 4
 		{ name => "i4", realname => "i4", type => 0 }, # param 5
 		{ name => "i5", realname => "i5", type => 0 }, # param 6
-		{ name => "fp", realname => "fp", type => $ignore }, # our framepointer
+		{ name => "frame_pointer", realname => "fp", type => $ignore }, # our framepointer
 		{ name => "i7", realname => "i7", type => $ignore }, # return address - 8
 		{ mode => $mode_gp }
 	],
@@ -63,7 +63,7 @@ $state       = 32; # register represents a state
 		{ mode => $mode_flags, flags => "manual_ra" }
 	],
 	# fp registers can be accessed any time
-	fp  => [
+	fp => [
 		{ name => "f0",  type => $caller_save },
 		{ name => "f1",  type => $caller_save },
 		{ name => "f2",  type => $caller_save },
@@ -102,32 +102,30 @@ $state       = 32; # register represents a state
 
 %emit_templates = (
 # emit source reg or imm dep. on node's arity
-	RI => "${arch}_emit_reg_or_imm(node, -1);",
+	RI  => "${arch}_emit_reg_or_imm(node, -1);",
 	R1I => "${arch}_emit_reg_or_imm(node, 0);",
 	R2I => "${arch}_emit_reg_or_imm(node, 1);",
 	R3I => "${arch}_emit_reg_or_imm(node, 2);",
-# simple reg emitters
-	S1 => "${arch}_emit_source_register(node, 0);",
-	S2 => "${arch}_emit_source_register(node, 1);",
-	S3 => "${arch}_emit_source_register(node, 2);",
-	S4 => "${arch}_emit_source_register(node, 3);",
-	S5 => "${arch}_emit_source_register(node, 4);",
-	S6 => "${arch}_emit_source_register(node, 5);",
-	D1 => "${arch}_emit_dest_register(node, 0);",
-	D2 => "${arch}_emit_dest_register(node, 1);",
-	D3 => "${arch}_emit_dest_register(node, 2);",
-	D4 => "${arch}_emit_dest_register(node, 3);",
-	D5 => "${arch}_emit_dest_register(node, 4);",
-	D6 => "${arch}_emit_dest_register(node, 5);",
-# more custom emitters
-	C  => "${arch}_emit_immediate(node);",
+	S1  => "${arch}_emit_source_register(node, 0);",
+	S2  => "${arch}_emit_source_register(node, 1);",
+	S3  => "${arch}_emit_source_register(node, 2);",
+	S4  => "${arch}_emit_source_register(node, 3);",
+	S5  => "${arch}_emit_source_register(node, 4);",
+	S6  => "${arch}_emit_source_register(node, 5);",
+	D1  => "${arch}_emit_dest_register(node, 0);",
+	D2  => "${arch}_emit_dest_register(node, 1);",
+	D3  => "${arch}_emit_dest_register(node, 2);",
+	D4  => "${arch}_emit_dest_register(node, 3);",
+	D5  => "${arch}_emit_dest_register(node, 4);",
+	D6  => "${arch}_emit_dest_register(node, 5);",
+	IM  => "${arch}_emit_immediate(node);",
 	LM  => "${arch}_emit_load_mode(node);",
 	SM  => "${arch}_emit_store_mode(node);",
-	EXTPREF  => "${arch}_emit_mode_sign_prefix(node);",
+	EXTPREF => "${arch}_emit_mode_sign_prefix(node);",
 	FPM  => "${arch}_emit_fp_mode_suffix(node);",
-	FPLM  => "${arch}_emit_fp_load_mode(node);",
-	FPSM  => "${arch}_emit_fp_store_mode(node);",
-	O  => "${arch}_emit_offset(node);",
+	FPLM => "${arch}_emit_fp_load_mode(node);",
+	FPSM => "${arch}_emit_fp_store_mode(node);",
+	O    => "${arch}_emit_offset(node);",
 );
 
 $default_attr_type = "sparc_attr_t";
@@ -251,7 +249,7 @@ St => {
 	mode 		=> "mode_M",
 	state     => "exc_pinned",
 	ins       => [ "ptr", "val", "mem" ],
-	outs      => [ "mem" ],
+	outs      => [ "M" ],
 	reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 	attr_type => "sparc_load_store_attr_t",
 	attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
@@ -269,10 +267,10 @@ Mov => {
 Save => {
 	reg_req   => {
 		in => [ "sp", "none"],
-		out => [ "sp:I|S","none" ]
+		out => [ "sp:I|S", "frame_pointer:I", "none" ]
 	},
 	ins       => [ "stack", "mem" ],
-	outs      => [ "stack", "mem" ],
+	outs      => [ "stack", "frame", "mem" ],
 	attr      => "int initial_stacksize",
 	attr_type => "sparc_save_attr_t",
 	init_attr => "\tinit_sparc_save_attr(res, initial_stacksize);",
@@ -329,6 +327,25 @@ Ba => {
 	mode      => "mode_X",
 },
 
+Call => {
+	irn_flags => [ "modify_flags" ],
+	state     => "exc_pinned",
+	arity     => "variable",
+	out_arity => "variable",
+	constructors => {
+		imm => {
+			attr       => "ir_entity *entity, long offset",
+			custominit => "get_sparc_attr(res)->immediate_value_entity = entity;",
+			arity     => "variable",
+			out_arity => "variable",
+		},
+		reg => {
+			arity     => "variable",
+			out_arity => "variable",
+		}
+	},
+},
+
 Cmp => {
 	irn_flags    => [ "rematerializable", "modify_flags" ],
 	emit         => '. cmp %S1, %R2I',
@@ -514,4 +531,16 @@ Ldf => {
 	emit      => '. ld [%S1%O], %D1'
 },
 
+Stf => {
+	op_flags  => [ "labeled", "fragile" ],
+	state     => "exc_pinned",
+	ins       => [ "ptr", "val", "mem" ],
+	outs      => [ "M" ],
+	reg_req   => { in => [ "gp", "fp", "none" ], out => [ "none" ] },
+	attr_type => "sparc_load_store_attr_t",
+	attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
+	emit      => '. st %S2, [%S1%O]',
+	mode      => 'mode_M',
+},
+
 ); # end of %nodes
diff --git a/ir/be/sparc/sparc_transform.c b/ir/be/sparc/sparc_transform.c
index de66fc358..636c7fc37 100644
--- a/ir/be/sparc/sparc_transform.c
+++ b/ir/be/sparc/sparc_transform.c
@@ -22,7 +22,6 @@
  * @brief   code selection (transform FIRM into SPARC FIRM)
  * @version $Id$
  */
-
 #include "config.h"
 
 #include "irnode_t.h"
@@ -42,6 +41,7 @@
 #include "../beirg.h"
 #include "../beutil.h"
 #include "../betranshlp.h"
+#include "../beabihelper.h"
 #include "bearch_sparc_t.h"
 
 #include "sparc_nodes_attr.h"
@@ -50,12 +50,20 @@
 #include "gen_sparc_new_nodes.h"
 
 #include "gen_sparc_regalloc_if.h"
+#include "sparc_cconv.h"
 
 #include <limits.h>
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
-static sparc_code_gen_t *env_cg;
+static sparc_code_gen_t      *env_cg;
+static beabi_helper_env_t    *abihelper;
+static const arch_register_t *sp_reg = &sparc_gp_regs[REG_SP];
+static const arch_register_t *fp_reg = &sparc_gp_regs[REG_FRAME_POINTER];
+static calling_convention_t  *cconv  = NULL;
+static ir_mode               *mode_gp;
+static ir_mode               *mode_fp;
+static pmap                  *node_to_stack;
 
 static ir_node *gen_SymConst(ir_node *node);
 
@@ -165,8 +173,8 @@ static ir_node *create_const_graph(ir_node *irn, ir_node *block)
 
 	if (mode_is_reference(mode)) {
 		/* SPARC V8 is 32bit, so we can safely convert a reference tarval into Iu */
-		assert(get_mode_size_bits(mode) == get_mode_size_bits(mode_Iu));
-		tv = tarval_convert_to(tv, mode_Iu);
+		assert(get_mode_size_bits(mode) == get_mode_size_bits(mode_gp));
+		tv = tarval_convert_to(tv, mode_gp);
 	}
 
 	value = get_tarval_long(tv);
@@ -371,7 +379,7 @@ static ir_node *gen_Mul(ir_node *node) {
 	mul = gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_SIZE_NEUTRAL, new_bd_sparc_Mul_reg, new_bd_sparc_Mul_imm);
 	arch_irn_add_flags(mul, arch_irn_flags_modify_flags);
 
-	proj_res_low = new_rd_Proj(dbgi, mul, mode_Iu, pn_sparc_Mul_low);
+	proj_res_low = new_rd_Proj(dbgi, mul, mode_gp, pn_sparc_Mul_low);
 	return proj_res_low;
 }
 
@@ -395,7 +403,7 @@ static ir_node *gen_Mulh(ir_node *node) {
 	assert(mode_is_data(mode));
 	mul = gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_SIZE_NEUTRAL, new_bd_sparc_Mulh_reg, new_bd_sparc_Mulh_imm);
 	//arch_irn_add_flags(mul, arch_irn_flags_modify_flags);
-	proj_res_hi = new_rd_Proj(dbgi, mul, mode_Iu, pn_sparc_Mulh_low);
+	proj_res_hi = new_rd_Proj(dbgi, mul, mode_gp, pn_sparc_Mulh_low);
 	return proj_res_hi;
 }
 
@@ -677,7 +685,7 @@ static ir_node *gen_be_Copy(ir_node *node)
 	ir_mode *mode   = get_irn_mode(result);
 
 	if (mode_needs_gp_reg(mode)) {
-		set_irn_mode(node, mode_Iu);
+		set_irn_mode(node, mode_gp);
 	}
 
 	return result;
@@ -943,6 +951,407 @@ static ir_node *gen_Unknown(ir_node *node)
 	panic("Unexpected Unknown mode");
 }
 
+/**
+ * Produces the type which sits between the stack args and the locals on the
+ * stack.
+ */
+static ir_type *sparc_get_between_type(void)
+{
+	static ir_type *between_type = NULL;
+
+	if (between_type == NULL) {
+		between_type = new_type_class(new_id_from_str("sparc_between_type"));
+		set_type_size_bytes(between_type, SPARC_MIN_STACKSIZE);
+	}
+
+	return between_type;
+}
+
+static void create_stacklayout(ir_graph *irg)
+{
+	ir_entity         *entity        = get_irg_entity(irg);
+	ir_type           *function_type = get_entity_type(entity);
+	be_stack_layout_t *layout        = be_get_irg_stack_layout(irg);
+	ir_type           *arg_type;
+	int                p;
+	int                n_params;
+
+	/* calling conventions must be decided by now */
+	assert(cconv != NULL);
+
+	/* construct argument type */
+	arg_type = new_type_struct(id_mangle_u(get_entity_ident(entity), new_id_from_chars("arg_type", 8)));
+	n_params = get_method_n_params(function_type);
+	for (p = 0; p < n_params; ++p) {
+		reg_or_stackslot_t *param = &cconv->parameters[p];
+		char                buf[128];
+		ident              *id;
+
+		if (param->type == NULL)
+			continue;
+
+		snprintf(buf, sizeof(buf), "param_%d", p);
+		id            = new_id_from_str(buf);
+		param->entity = new_entity(arg_type, id, param->type);
+		set_entity_offset(param->entity, param->offset);
+	}
+
+	memset(layout, 0, sizeof(*layout));
+
+	layout->frame_type     = get_irg_frame_type(irg);
+	layout->between_type   = sparc_get_between_type();
+	layout->arg_type       = arg_type;
+	layout->initial_offset = 0;
+	layout->initial_bias   = 0;
+	layout->stack_dir      = -1;
+	layout->sp_relative    = false;
+
+	assert(N_FRAME_TYPES == 3);
+	layout->order[0] = layout->frame_type;
+	layout->order[1] = layout->between_type;
+	layout->order[2] = layout->arg_type;
+}
+
+/**
+ * transform the start node to the prolog code + initial barrier
+ */
+static ir_node *gen_Start(ir_node *node)
+{
+	ir_graph  *irg           = get_irn_irg(node);
+	ir_entity *entity        = get_irg_entity(irg);
+	ir_type   *function_type = get_entity_type(entity);
+	ir_node   *block         = get_nodes_block(node);
+	ir_node   *new_block     = be_transform_node(block);
+	dbg_info  *dbgi          = get_irn_dbg_info(node);
+	ir_node   *mem;
+	ir_node   *start;
+	ir_node   *sp;
+	ir_node   *fp;
+	ir_node   *barrier;
+	ir_node   *save;
+	int        i;
+
+	/* stackpointer is important at function prolog */
+	be_prolog_add_reg(abihelper, sp_reg,
+			arch_register_req_type_produces_sp | arch_register_req_type_ignore);
+	/* function parameters in registers */
+	for (i = 0; i < get_method_n_params(function_type); ++i) {
+		const reg_or_stackslot_t *param = &cconv->parameters[i];
+		if (param->reg0 != NULL)
+			be_prolog_add_reg(abihelper, param->reg0, 0);
+		if (param->reg1 != NULL)
+			be_prolog_add_reg(abihelper, param->reg1, 0);
+	}
+
+	start = be_prolog_create_start(abihelper, dbgi, new_block);
+
+	mem  = be_prolog_get_memory(abihelper);
+	sp   = be_prolog_get_reg_value(abihelper, sp_reg);
+	save = new_bd_sparc_Save(NULL, block, sp, mem, SPARC_MIN_STACKSIZE);
+	fp   = new_r_Proj(save, mode_gp, pn_sparc_Save_frame);
+	sp   = new_r_Proj(save, mode_gp, pn_sparc_Save_stack);
+	mem  = new_r_Proj(save, mode_M, pn_sparc_Save_mem);
+	arch_set_irn_register(fp, fp_reg);
+	arch_set_irn_register(sp, sp_reg);
+
+	be_prolog_add_reg(abihelper, fp_reg, arch_register_req_type_ignore);
+	be_prolog_set_reg_value(abihelper, fp_reg, fp);
+
+	sp = be_new_IncSP(sp_reg, new_block, sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
+	be_prolog_set_reg_value(abihelper, sp_reg, sp);
+	be_prolog_set_memory(abihelper, mem);
+
+	barrier = be_prolog_create_barrier(abihelper, new_block);
+
+	return barrier;
+}
+
+static ir_node *get_stack_pointer_for(ir_node *node)
+{
+	/* get predecessor in stack_order list */
+	ir_node *stack_pred = be_get_stack_pred(abihelper, node);
+	ir_node *stack_pred_transformed;
+	ir_node *stack;
+
+	if (stack_pred == NULL) {
+		/* first stack user in the current block. We can simply use the
+		 * initial sp_proj for it */
+		ir_node *sp_proj = be_prolog_get_reg_value(abihelper, sp_reg);
+		return sp_proj;
+	}
+
+	stack_pred_transformed = be_transform_node(stack_pred);
+	stack                  = pmap_get(node_to_stack, stack_pred);
+	if (stack == NULL) {
+		return get_stack_pointer_for(stack_pred);
+	}
+
+	return stack;
+}
+
+/**
+ * transform a Return node into epilogue code + return statement
+ */
+static ir_node *gen_Return(ir_node *node)
+{
+	ir_node  *block          = get_nodes_block(node);
+	ir_node  *new_block      = be_transform_node(block);
+	dbg_info *dbgi           = get_irn_dbg_info(node);
+	ir_node  *mem            = get_Return_mem(node);
+	ir_node  *new_mem        = be_transform_node(mem);
+	ir_node  *sp_proj        = get_stack_pointer_for(node);
+	int       n_res          = get_Return_n_ress(node);
+	ir_node  *bereturn;
+	ir_node  *incsp;
+	int       i;
+
+	be_epilog_begin(abihelper);
+	be_epilog_set_memory(abihelper, new_mem);
+	/* connect stack pointer with initial stack pointer. fix_stack phase
+	   will later serialize all stack pointer adjusting nodes */
+	be_epilog_add_reg(abihelper, sp_reg,
+			arch_register_req_type_produces_sp | arch_register_req_type_ignore,
+			sp_proj);
+
+	/* result values */
+	for (i = 0; i < n_res; ++i) {
+		ir_node                  *res_value     = get_Return_res(node, i);
+		ir_node                  *new_res_value = be_transform_node(res_value);
+		const reg_or_stackslot_t *slot          = &cconv->results[i];
+		const arch_register_t    *reg           = slot->reg0;
+		assert(slot->reg1 == NULL);
+		be_epilog_add_reg(abihelper, reg, 0, new_res_value);
+	}
+
+	/* create the barrier before the epilog code */
+	be_epilog_create_barrier(abihelper, new_block);
+
+	/* epilog code: an incsp */
+	sp_proj = be_epilog_get_reg_value(abihelper, sp_reg);
+	incsp   = be_new_IncSP(sp_reg, new_block, sp_proj,
+	                       BE_STACK_FRAME_SIZE_SHRINK, 0);
+	be_epilog_set_reg_value(abihelper, sp_reg, incsp);
+
+	bereturn = be_epilog_create_return(abihelper, dbgi, new_block);
+
+	return bereturn;
+}
+
+static ir_node *bitcast_int_to_float(dbg_info *dbgi, ir_node *block,
+                                     ir_node *node)
+{
+	ir_graph *irg   = current_ir_graph;
+	ir_node  *stack = get_irg_frame(irg);
+	ir_node  *nomem = new_NoMem();
+	ir_node  *st    = new_bd_sparc_St(dbgi, block, stack, node, nomem, mode_gp,
+	                                  NULL, 0, 0, true);
+	ir_node  *ldf;
+	set_irn_pinned(st, op_pin_state_floats);
+
+	ldf = new_bd_sparc_Ldf(dbgi, block, stack, st, mode_fp, NULL, 0, 0, true);
+	set_irn_pinned(ldf, op_pin_state_floats);
+
+	return new_Proj(ldf, mode_fp, pn_sparc_Ldf_res);
+}
+
+static ir_node *bitcast_float_to_int(dbg_info *dbgi, ir_node *block,
+                                     ir_node *node)
+{
+	ir_graph *irg   = current_ir_graph;
+	ir_node  *stack = get_irg_frame(irg);
+	ir_node  *nomem = new_NoMem();
+	ir_node  *stf   = new_bd_sparc_Stf(dbgi, block, stack, node, nomem, mode_fp,
+	                                   NULL, 0, 0, true);
+	ir_node  *ld;
+	set_irn_pinned(stf, op_pin_state_floats);
+
+	ld = new_bd_sparc_Ld(dbgi, block, stack, stf, mode_gp, NULL, 0, 0, true);
+	set_irn_pinned(ld, op_pin_state_floats);
+
+	return new_Proj(ld, mode_fp, pn_sparc_Ld_res);
+}
+
+static ir_node *gen_Call(ir_node *node)
+{
+	ir_graph        *irg          = get_irn_irg(node);
+	ir_node         *callee       = get_Call_ptr(node);
+	ir_node         *block        = get_nodes_block(node);
+	ir_node         *new_block    = be_transform_node(block);
+	ir_node         *mem          = get_Call_mem(node);
+	ir_node         *new_mem      = be_transform_node(mem);
+	dbg_info        *dbgi         = get_irn_dbg_info(node);
+	ir_type         *type         = get_Call_type(node);
+	int              n_params     = get_Call_n_params(node);
+	int              n_param_regs = sizeof(param_regs)/sizeof(param_regs[0]);
+	/* max inputs: memory, callee, register arguments */
+	int              max_inputs   = 2 + n_param_regs;
+	ir_node        **in           = ALLOCAN(ir_node*, max_inputs);
+	ir_node        **sync_ins     = ALLOCAN(ir_node*, max_inputs);
+	struct obstack  *obst         = be_get_be_obst(irg);
+	const arch_register_req_t **in_req
+		= OALLOCNZ(obst, const arch_register_req_t*, max_inputs);
+	calling_convention_t *cconv
+		= sparc_decide_calling_convention(type, true);
+	int              in_arity     = 0;
+	int              sync_arity   = 0;
+	int              n_caller_saves
+		= sizeof(caller_saves)/sizeof(caller_saves[0]);
+	ir_entity       *entity       = NULL;
+	ir_node         *new_frame    = get_stack_pointer_for(node);
+	ir_node         *incsp;
+	int              mem_pos;
+	ir_node         *res;
+	int              p;
+	int              i;
+	int              o;
+	int              out_arity;
+
+	assert(n_params == get_method_n_params(type));
+
+	/* construct arguments */
+
+	/* memory input */
+	in_req[in_arity] = arch_no_register_req;
+	mem_pos          = in_arity;
+	++in_arity;
+
+	/* stack pointer input */
+	/* construct an IncSP -> we have to always be sure that the stack is
+	 * aligned even if we don't push arguments on it */
+	incsp = be_new_IncSP(sp_reg, new_block, new_frame,
+	                     cconv->param_stack_size, 1);
+	in_req[in_arity] = sp_reg->single_req;
+	in[in_arity]     = incsp;
+	++in_arity;
+
+	/* parameters */
+	for (p = 0; p < n_params; ++p) {
+		ir_node                  *value      = get_Call_param(node, p);
+		ir_node                  *new_value  = be_transform_node(value);
+		ir_node                  *new_value1 = NULL;
+		const reg_or_stackslot_t *param      = &cconv->parameters[p];
+		ir_type                  *param_type = get_method_param_type(type, p);
+		ir_mode                  *mode       = get_type_mode(param_type);
+		ir_node                  *str;
+
+		if (mode_is_float(mode) && param->reg0 != NULL) {
+			unsigned size_bits = get_mode_size_bits(mode);
+			assert(size_bits == 32);
+			new_value = bitcast_float_to_int(dbgi, new_block, new_value);
+		}
+
+		/* put value into registers */
+		if (param->reg0 != NULL) {
+			in[in_arity]     = new_value;
+			in_req[in_arity] = param->reg0->single_req;
+			++in_arity;
+			if (new_value1 == NULL)
+				continue;
+		}
+		if (param->reg1 != NULL) {
+			assert(new_value1 != NULL);
+			in[in_arity]     = new_value1;
+			in_req[in_arity] = param->reg1->single_req;
+			++in_arity;
+			continue;
+		}
+
+		/* we need a store if we're here */
+		if (new_value1 != NULL) {
+			new_value = new_value1;
+			mode      = mode_gp;
+		}
+
+		/* create a parameter frame if necessary */
+		if (mode_is_float(mode)) {
+			str = new_bd_sparc_Stf(dbgi, new_block, incsp, new_value, new_mem,
+			                       mode, NULL, 0, param->offset, true);
+		} else {
+			str = new_bd_sparc_St(dbgi, new_block, incsp, new_value, new_mem,
+								  mode, NULL, 0, param->offset, true);
+		}
+		sync_ins[sync_arity++] = str;
+	}
+	assert(in_arity <= max_inputs);
+
+	/* construct memory input */
+	if (sync_arity == 0) {
+		in[mem_pos] = new_mem;
+	} else if (sync_arity == 1) {
+		in[mem_pos] = sync_ins[0];
+	} else {
+		in[mem_pos] = new_rd_Sync(NULL, new_block, sync_arity, sync_ins);
+	}
+
+	if (is_SymConst(callee)) {
+		entity = get_SymConst_entity(callee);
+	} else {
+		in[in_arity]     = be_transform_node(callee);
+		in_req[in_arity] = sparc_reg_classes[CLASS_sparc_gp].class_req;
+		++in_arity;
+	}
+
+	/* outputs:
+	 *  - memory
+	 *  - caller saves
+	 */
+	out_arity = 1 + n_caller_saves;
+
+	/* create call node */
+	if (entity != NULL) {
+		res = new_bd_sparc_Call_imm(dbgi, new_block, in_arity, in, out_arity,
+		                            entity, 0);
+	} else {
+		res = new_bd_sparc_Call_reg(dbgi, new_block, in_arity, in, out_arity);
+	}
+	set_sparc_in_req_all(res, in_req);
+
+	/* create output register reqs */
+	o = 0;
+	arch_set_out_register_req(res, o++, arch_no_register_req);
+	for (i = 0; i < n_caller_saves; ++i) {
+		const arch_register_t *reg = caller_saves[i];
+		arch_set_out_register_req(res, o++, reg->single_req);
+	}
+	assert(o == out_arity);
+
+	/* copy pinned attribute */
+	set_irn_pinned(res, get_irn_pinned(node));
+
+	/* IncSP to destroy the call stackframe */
+	incsp = be_new_IncSP(sp_reg, new_block, incsp, -cconv->param_stack_size, 0);
+	/* if we are the last IncSP producer in a block then we have to keep
+	 * the stack value.
+	 * Note: This here keeps all producers which is more than necessary */
+	add_irn_dep(incsp, res);
+	keep_alive(incsp);
+
+	pmap_insert(node_to_stack, node, incsp);
+
+	sparc_free_calling_convention(cconv);
+	return res;
+}
+
+static ir_node *gen_Sel(ir_node *node)
+{
+	dbg_info  *dbgi      = get_irn_dbg_info(node);
+	ir_node   *block     = get_nodes_block(node);
+	ir_node   *new_block = be_transform_node(block);
+	ir_node   *ptr       = get_Sel_ptr(node);
+	ir_node   *new_ptr   = be_transform_node(ptr);
+	ir_entity *entity    = get_Sel_entity(node);
+
+	/* must be the frame pointer all other sels must have been lowered
+	 * already */
+	assert(is_Proj(ptr) && is_Start(get_Proj_pred(ptr)));
+	/* we should not have value types from parameters anymore - they should be
+	   lowered */
+	assert(get_entity_owner(entity) !=
+			get_method_value_param_type(get_entity_type(get_irg_entity(get_irn_irg(node)))));
+
+	return new_bd_sparc_FrameAddr(dbgi, new_block, new_ptr, entity);
+}
+
 /**
  * Transform some Phi nodes
  */
@@ -959,7 +1368,7 @@ static ir_node *gen_Phi(ir_node *node)
 		/* we shouldn't have any 64bit stuff around anymore */
 		assert(get_mode_size_bits(mode) <= 32);
 		/* all integer operations are on 32bit registers now */
-		mode = mode_Iu;
+		mode = mode_gp;
 		req  = sparc_reg_classes[CLASS_sparc_gp].class_req;
 	} else {
 		req = arch_no_register_req;
@@ -991,7 +1400,7 @@ static ir_node *gen_Proj_Load(ir_node *node)
 		case iro_sparc_Ld:
 			/* handle all gp loads equal: they have the same proj numbers. */
 			if (proj == pn_Load_res) {
-				return new_rd_Proj(dbgi, new_load, mode_Iu, pn_sparc_Ld_res);
+				return new_rd_Proj(dbgi, new_load, mode_gp, pn_sparc_Ld_res);
 			} else if (proj == pn_Load_M) {
 				return new_rd_Proj(dbgi, new_load, mode_M, pn_sparc_Ld_M);
 			}
@@ -1003,52 +1412,6 @@ static ir_node *gen_Proj_Load(ir_node *node)
 	return be_duplicate_node(node);
 }
 
-/**
- * Transform the Projs of a be_AddSP.
- */
-static ir_node *gen_Proj_be_AddSP(ir_node *node)
-{
-	ir_node  *pred     = get_Proj_pred(node);
-	ir_node  *new_pred = be_transform_node(pred);
-	dbg_info *dbgi     = get_irn_dbg_info(node);
-	long     proj      = get_Proj_proj(node);
-
-	if (proj == pn_be_AddSP_sp) {
-		ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
-		                           pn_sparc_SubSP_stack);
-		arch_set_irn_register(res, &sparc_gp_regs[REG_SP]);
-		return res;
-	} else if (proj == pn_be_AddSP_res) {
-		return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_sparc_SubSP_stack);
-	} else if (proj == pn_be_AddSP_M) {
-		return new_rd_Proj(dbgi, new_pred, mode_M, pn_sparc_SubSP_M);
-	}
-
-	panic("Unsupported Proj from AddSP");
-}
-
-/**
- * Transform the Projs of a be_SubSP.
- */
-static ir_node *gen_Proj_be_SubSP(ir_node *node)
-{
-	ir_node  *pred     = get_Proj_pred(node);
-	ir_node  *new_pred = be_transform_node(pred);
-	dbg_info *dbgi     = get_irn_dbg_info(node);
-	long     proj      = get_Proj_proj(node);
-
-	if (proj == pn_be_SubSP_sp) {
-		ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
-		                           pn_sparc_AddSP_stack);
-		arch_set_irn_register(res, &sparc_gp_regs[REG_SP]);
-		return res;
-	} else if (proj == pn_be_SubSP_M) {
-		return new_rd_Proj(dbgi,  new_pred, mode_M, pn_sparc_AddSP_M);
-	}
-
-	panic("Unsupported Proj from SubSP");
-}
-
 /**
  * Transform the Projs from a Cmp.
  */
@@ -1071,7 +1434,7 @@ static ir_node *gen_Proj_Div(ir_node *node)
 	switch (proj) {
 	case pn_Div_res:
 		if (is_sparc_Div(new_pred)) {
-			return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_sparc_Div_res);
+			return new_rd_Proj(dbgi, new_pred, mode_gp, pn_sparc_Div_res);
 		}
 		break;
 	default:
@@ -1080,66 +1443,181 @@ static ir_node *gen_Proj_Div(ir_node *node)
 	panic("Unsupported Proj from Div");
 }
 
+static ir_node *gen_Proj_Start(ir_node *node)
+{
+	ir_node *block     = get_nodes_block(node);
+	ir_node *new_block = be_transform_node(block);
+	ir_node *barrier   = be_transform_node(get_Proj_pred(node));
+	long     pn        = get_Proj_proj(node);
+
+	switch ((pn_Start) pn) {
+	case pn_Start_X_initial_exec:
+		/* excahnge ProjX with a jump */
+		return new_bd_sparc_Ba(NULL, new_block);
+	case pn_Start_M:
+		return new_r_Proj(barrier, mode_M, 0);
+	case pn_Start_T_args:
+		return barrier;
+	case pn_Start_P_frame_base:
+		return be_prolog_get_reg_value(abihelper, fp_reg);
+	case pn_Start_P_tls:
+		return new_Bad();
+	case pn_Start_max:
+		break;
+	}
+	panic("Unexpected start proj: %ld\n", pn);
+}
+
+static ir_node *gen_Proj_Proj_Start(ir_node *node)
+{
+	long       pn          = get_Proj_proj(node);
+	ir_node   *block       = get_nodes_block(node);
+	ir_node   *new_block   = be_transform_node(block);
+	ir_entity *entity      = get_irg_entity(current_ir_graph);
+	ir_type   *method_type = get_entity_type(entity);
+	ir_type   *param_type  = get_method_param_type(method_type, pn);
+	const reg_or_stackslot_t *param;
+
+	/* Proj->Proj->Start must be a method argument */
+	assert(get_Proj_proj(get_Proj_pred(node)) == pn_Start_T_args);
+
+	param = &cconv->parameters[pn];
+
+	if (param->reg0 != NULL) {
+		/* argument transmitted in register */
+		ir_mode               *mode  = get_type_mode(param_type);
+		const arch_register_t *reg   = param->reg0;
+		ir_node               *value = be_prolog_get_reg_value(abihelper, reg);
+
+		if (mode_is_float(mode)) {
+			/* convert integer value to float */
+			value = bitcast_int_to_float(NULL, new_block, value);
+		}
+		return value;
+	} else {
+		/* argument transmitted on stack */
+		ir_node  *fp   = be_prolog_get_reg_value(abihelper, fp_reg);
+		ir_node  *mem  = be_prolog_get_memory(abihelper);
+		ir_mode  *mode = get_type_mode(param->type);
+		ir_node  *load;
+		ir_node  *value;
+
+		if (mode_is_float(mode)) {
+			load  = new_bd_sparc_Ldf(NULL, new_block, fp, mem, mode,
+			                         param->entity, 0, 0, true);
+			value = new_r_Proj(load, mode_fp, pn_sparc_Ldf_res);
+		} else {
+			load  = new_bd_sparc_Ld(NULL, new_block, fp, mem, mode,
+			                        param->entity, 0, 0, true);
+			value = new_r_Proj(load, mode_gp, pn_sparc_Ld_res);
+		}
+		set_irn_pinned(load, op_pin_state_floats);
+
+		return value;
+	}
+}
+
+static ir_node *gen_Proj_Call(ir_node *node)
+{
+	long     pn        = get_Proj_proj(node);
+	ir_node *call      = get_Proj_pred(node);
+	ir_node *new_call  = be_transform_node(call);
+
+	switch ((pn_Call) pn) {
+	case pn_Call_M:
+		return new_r_Proj(new_call, mode_M, 0);
+	case pn_Call_X_regular:
+	case pn_Call_X_except:
+	case pn_Call_T_result:
+	case pn_Call_P_value_res_base:
+	case pn_Call_max:
+		break;
+	}
+	panic("Unexpected Call proj %ld\n", pn);
+}
+
+/**
+ * Finds number of output value of a mode_T node which is constrained to
+ * a single specific register.
+ */
+static int find_out_for_reg(ir_node *node, const arch_register_t *reg)
+{
+	int n_outs = arch_irn_get_n_outs(node);
+	int o;
+
+	for (o = 0; o < n_outs; ++o) {
+		const arch_register_req_t *req = arch_get_out_register_req(node, o);
+		if (req == reg->single_req)
+			return o;
+	}
+	return -1;
+}
+
+static ir_node *gen_Proj_Proj_Call(ir_node *node)
+{
+	long                  pn            = get_Proj_proj(node);
+	ir_node              *call          = get_Proj_pred(get_Proj_pred(node));
+	ir_node              *new_call      = be_transform_node(call);
+	ir_type              *function_type = get_Call_type(call);
+	calling_convention_t *cconv
+		= sparc_decide_calling_convention(function_type, true);
+	const reg_or_stackslot_t *res = &cconv->results[pn];
+	const arch_register_t    *reg = res->reg0;
+	ir_mode                  *mode;
+	int                       regn;
+
+	assert(res->reg0 != NULL && res->reg1 == NULL);
+	regn = find_out_for_reg(new_call, reg);
+	if (regn < 0) {
+		panic("Internal error in calling convention for return %+F", node);
+	}
+	mode = res->reg0->reg_class->mode;
+
+	sparc_free_calling_convention(cconv);
+
+	return new_r_Proj(new_call, mode, regn);
+}
 
 /**
  * Transform a Proj node.
  */
 static ir_node *gen_Proj(ir_node *node)
 {
-	ir_graph *irg  = current_ir_graph;
-	dbg_info *dbgi = get_irn_dbg_info(node);
-	ir_node  *pred = get_Proj_pred(node);
-	long     proj  = get_Proj_proj(node);
-
-	(void) irg;
-	(void) dbgi;
+	ir_node *pred = get_Proj_pred(node);
+	long     pn   = get_Proj_proj(node);
 
-	if (is_Store(pred)) {
-		if (proj == pn_Store_M) {
+	switch (get_irn_opcode(pred)) {
+	case iro_Store:
+		if (pn == pn_Store_M) {
 			return be_transform_node(pred);
 		} else {
 			panic("Unsupported Proj from Store");
 		}
-	} else if (is_Load(pred)) {
+		break;
+	case iro_Load:
 		return gen_Proj_Load(node);
-	} else if (be_is_SubSP(pred)) {
-		//panic("gen_Proj not implemented for SubSP");
-		return gen_Proj_be_SubSP(node);
-	} else if (be_is_AddSP(pred)) {
-		//panic("gen_Proj not implemented for AddSP");
-		return gen_Proj_be_AddSP(node);
-	} else if (is_Cmp(pred)) {
-		//panic("gen_Proj not implemented for Cmp");
+	case iro_Call:
+		return gen_Proj_Call(node);
+	case iro_Cmp:
 		return gen_Proj_Cmp(node);
-	} else if (is_Div(pred)) {
+	case iro_Cond:
+		return be_duplicate_node(node);
+	case iro_Div:
 		return gen_Proj_Div(node);
-	} else if (is_Start(pred)) {
-	/*
-		if (proj == pn_Start_X_initial_exec) {
-			ir_node *block = get_nodes_block(pred);
-			ir_node *jump;
-
-			// we exchange the ProjX with a jump
-			block = be_transform_node(block);
-			jump  = new_rd_Jmp(dbgi, block);
-			return jump;
-		}
-
-		if (node == get_irg_anchor(irg, anchor_tls)) {
-			return gen_Proj_tls(node);
-		}
-	*/
-	} else {
-		ir_node *new_pred = be_transform_node(pred);
-		ir_mode *mode     = get_irn_mode(node);
-		if (mode_needs_gp_reg(mode)) {
-			ir_node *new_proj = new_r_Proj(new_pred, mode_Iu, get_Proj_proj(node));
-			new_proj->node_nr = node->node_nr;
-			return new_proj;
+	case iro_Start:
+		return gen_Proj_Start(node);
+	case iro_Proj: {
+		ir_node *pred_pred = get_Proj_pred(pred);
+		if (is_Call(pred_pred)) {
+			return gen_Proj_Proj_Call(node);
+		} else if (is_Start(pred_pred)) {
+			return gen_Proj_Proj_Start(node);
 		}
+		/* FALLTHROUGH */
+	}
+	default:
+		panic("code selection didn't expect Proj after %+F\n", pred);
 	}
-
-	return be_duplicate_node(node);
 }
 
 
@@ -1170,6 +1648,7 @@ void sparc_register_transformers(void)
 	be_set_transform_function(op_be_Copy,      gen_be_Copy);
 	be_set_transform_function(op_be_FrameAddr, gen_be_FrameAddr);
 	be_set_transform_function(op_be_SubSP,     gen_be_SubSP);
+	be_set_transform_function(op_Call,         gen_Call);
 	be_set_transform_function(op_Cmp,          gen_Cmp);
 	be_set_transform_function(op_Cond,         gen_Cond);
 	be_set_transform_function(op_Const,        gen_Const);
@@ -1185,9 +1664,12 @@ void sparc_register_transformers(void)
 	be_set_transform_function(op_Or,           gen_Or);
 	be_set_transform_function(op_Phi,          gen_Phi);
 	be_set_transform_function(op_Proj,         gen_Proj);
+	be_set_transform_function(op_Return,       gen_Return);
+	be_set_transform_function(op_Sel,          gen_Sel);
 	be_set_transform_function(op_Shl,          gen_Shl);
 	be_set_transform_function(op_Shr,          gen_Shr);
 	be_set_transform_function(op_Shrs,         gen_Shrs);
+	be_set_transform_function(op_Start,        gen_Start);
 	be_set_transform_function(op_Store,        gen_Store);
 	be_set_transform_function(op_Sub,          gen_Sub);
 	be_set_transform_function(op_SymConst,     gen_SymConst);
@@ -1196,14 +1678,63 @@ void sparc_register_transformers(void)
 	be_set_transform_function(op_sparc_Save,   be_duplicate_node);
 }
 
+/* hack to avoid unused fp proj at start barrier */
+static void assure_fp_keep(void)
+{
+	unsigned         n_users = 0;
+	const ir_edge_t *edge;
+	ir_node         *fp_proj = be_prolog_get_reg_value(abihelper, fp_reg);
+
+	foreach_out_edge(fp_proj, edge) {
+		ir_node *succ = get_edge_src_irn(edge);
+		if (is_End(succ) || is_Anchor(succ))
+			continue;
+		++n_users;
+	}
+
+	if (n_users == 0) {
+		ir_node *block = get_nodes_block(fp_proj);
+		ir_node *in[1] = { fp_proj };
+		be_new_Keep(block, 1, in);
+	}
+}
+
 /**
  * Transform a Firm graph into a SPARC graph.
  */
 void sparc_transform_graph(sparc_code_gen_t *cg)
 {
+	ir_graph  *irg    = cg->irg;
+	ir_entity *entity = get_irg_entity(irg);
+	ir_type   *frame_type;
+
 	sparc_register_transformers();
 	env_cg = cg;
+
+	node_to_stack = pmap_create();
+
+	mode_gp = mode_Iu;
+	mode_fp = mode_F;
+
+	abihelper = be_abihelper_prepare(irg);
+	be_collect_stacknodes(abihelper);
+	cconv = sparc_decide_calling_convention(get_entity_type(entity), false);
+	create_stacklayout(irg);
+
 	be_transform_graph(cg->irg, NULL);
+	assure_fp_keep();
+
+	be_abihelper_finish(abihelper);
+	sparc_free_calling_convention(cconv);
+
+	frame_type = get_irg_frame_type(irg);
+	if (get_type_state(frame_type) == layout_undefined)
+		default_layout_compound_type(frame_type);
+
+	pmap_destroy(node_to_stack);
+	node_to_stack = NULL;
+
+	be_add_missing_keeps(irg);
 }
 
 void sparc_init_transform(void)
-- 
2.20.1