X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fsparc%2Fsparc_transform.c;h=62fd6b7c6d9c4587d493a09743a567302213b519;hb=b7a0d752833eb7fb294ce90a27cbe01d06bbbc50;hp=64dca2cc38d7ac4436394686aff2fd3567433966;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm

diff --git a/ir/be/sparc/sparc_transform.c b/ir/be/sparc/sparc_transform.c
index 64dca2cc3..62fd6b7c6 100644
--- a/ir/be/sparc/sparc_transform.c
+++ b/ir/be/sparc/sparc_transform.c
@@ -20,11 +20,13 @@
 /**
  * @file
  * @brief   code selection (transform FIRM into SPARC FIRM)
+ * @author  Hannes Rapp, Matthias Braun
  * @version $Id$
  */
 #include "config.h"
 
 #include <stdint.h>
+#include <stdbool.h>
 
 #include "irnode_t.h"
 #include "irgraph_t.h"
@@ -69,9 +71,14 @@ static ir_mode               *mode_fp2;
 //static ir_mode               *mode_fp4;
 static pmap                  *node_to_stack;
 
-static inline int mode_needs_gp_reg(ir_mode *mode)
+static inline bool mode_needs_gp_reg(ir_mode *mode)
 {
-	return mode_is_int(mode) || mode_is_reference(mode);
+	if (mode_is_int(mode) || mode_is_reference(mode)) {
+		/* we should only see 32bit code */
+		assert(get_mode_size_bits(mode) <= 32);
+		return true;
+	}
+	return false;
 }
 
 /**
@@ -163,11 +170,6 @@ typedef ir_node* (*new_binop_fp_func) (dbg_info *dbgi, ir_node *block, ir_node *
 typedef ir_node* (*new_binop_imm_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_entity *entity, int32_t immediate);
 typedef ir_node* (*new_unop_fp_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_mode *mode);
 
-static bool is_value_imm_encodeable(int32_t value)
-{
-	return -4096 <= value && value <= 4095;
-}
-
 /**
  * checks if a node's value can be encoded as a immediate
  */
@@ -178,7 +180,7 @@ static bool is_imm_encodeable(const ir_node *node)
 		return false;
 
 	value = get_tarval_long(get_Const_tarval(node));
-	return is_value_imm_encodeable(value);
+	return sparc_is_value_imm_encodeable(value);
 }
 
 static bool needs_extension(ir_mode *mode)
@@ -243,6 +245,9 @@ static ir_node *gen_helper_binop_args(ir_node *node,
 	}
 	mode1 = get_irn_mode(op1);
 	mode2 = get_irn_mode(op2);
+	/* we shouldn't see 64bit code */
+	assert(get_mode_size_bits(mode1) <= 32);
+	assert(get_mode_size_bits(mode2) <= 32);
 
 	if (is_imm_encodeable(op2)) {
 		ir_node *new_op1   = be_transform_node(op1);
@@ -376,7 +381,7 @@ static void match_address(ir_node *ptr, address_t *address, bool use_ptr2)
 		ptr2 = be_transform_node(get_Add_right(base));
 		base = be_transform_node(get_Add_left(base));
 	} else {
-		if (is_value_imm_encodeable(offset)) {
+		if (sparc_is_value_imm_encodeable(offset)) {
 			base = be_transform_node(base);
 		} else {
 			base   = be_transform_node(ptr);
@@ -515,6 +520,10 @@ static ir_node *gen_Load(ir_node *node)
 	ir_node  *new_load = NULL;
 	address_t address;
 
+	if (get_Load_unaligned(node) == align_non_aligned) {
+		panic("sparc: transformation of unaligned Loads not implemented yet");
+	}
+
 	if (mode_is_float(mode)) {
 		match_address(ptr, &address, false);
 		new_load = create_ldf(dbgi, block, address.ptr, new_mem, mode,
@@ -555,12 +564,17 @@ static ir_node *gen_Store(ir_node *node)
 	ir_node  *new_store = NULL;
 	address_t address;
 
+	if (get_Store_unaligned(node) == align_non_aligned) {
+		panic("sparc: transformation of unaligned Stores not implemented yet");
+	}
+
 	if (mode_is_float(mode)) {
 		/* TODO: variants with reg+reg address mode */
 		match_address(ptr, &address, false);
 		new_store = create_stf(dbgi, block, new_val, address.ptr, new_mem,
 		                       mode, address.entity, address.offset, false);
 	} else {
+		assert(get_mode_size_bits(mode) <= 32);
 		match_address(ptr, &address, true);
 		if (address.ptr2 != NULL) {
 			assert(address.entity == NULL && address.offset == 0);
@@ -640,7 +654,11 @@ static ir_node *gen_Div(ir_node *node)
 	ir_node  *right     = get_Div_right(node);
 	ir_node  *res;
 
-	assert(!mode_is_float(mode));
+	if (mode_is_float(mode)) {
+		return gen_helper_binfpop(node, mode, new_bd_sparc_fdiv_s,
+								  new_bd_sparc_fdiv_d, new_bd_sparc_fdiv_q);
+	}
+
 	if (mode_is_signed(mode)) {
 		ir_node *left_high = gen_sign_extension_value(left);
 
@@ -669,14 +687,6 @@ static ir_node *gen_Div(ir_node *node)
 	return res;
 }
 
-static ir_node *gen_Quot(ir_node *node)
-{
-	ir_mode *mode = get_Quot_resmode(node);
-	assert(mode_is_float(mode));
-	return gen_helper_binfpop(node, mode, new_bd_sparc_fdiv_s,
-	                          new_bd_sparc_fdiv_d, new_bd_sparc_fdiv_q);
-}
-
 #if 0
 static ir_node *gen_Abs(ir_node *node)
 {
@@ -845,8 +855,7 @@ static ir_node *gen_float_const(dbg_info *dbgi, ir_node *block, ir_tarval *tv)
 	ir_mode   *mode   = get_tarval_mode(tv);
 	ir_node   *new_op
 		= create_ldf(dbgi, block, hi, mem, mode, entity, 0, false);
-	ir_node   *proj   = new_Proj(new_op, mode, pn_sparc_Ldf_res);
-	be_dep_on_frame(hi);
+	ir_node   *proj   = new_r_Proj(new_op, mode, pn_sparc_Ldf_res);
 
 	set_irn_pinned(new_op, op_pin_state_floats);
 	return proj;
@@ -867,11 +876,10 @@ static ir_node *gen_Const(ir_node *node)
 	value = get_tarval_long(tv);
 	if (value == 0) {
 		return get_g0();
-	} else if (-4096 <= value && value <= 4095) {
+	} else if (sparc_is_value_imm_encodeable(value)) {
 		return new_bd_sparc_Or_imm(dbgi, block, get_g0(), NULL, value);
 	} else {
 		ir_node *hi = new_bd_sparc_SetHi(dbgi, block, NULL, value);
-		be_dep_on_frame(hi);
 		if ((value & 0x3ff) != 0) {
 			return new_bd_sparc_Or_imm(dbgi, block, hi, NULL, value & 0x3ff);
 		} else {
@@ -882,15 +890,11 @@ static ir_node *gen_Const(ir_node *node)
 
 static ir_mode *get_cmp_mode(ir_node *b_value)
 {
-	ir_node *pred;
 	ir_node *op;
 
-	if (!is_Proj(b_value))
-		panic("can't determine cond signednes");
-	pred = get_Proj_pred(b_value);
-	if (!is_Cmp(pred))
+	if (!is_Cmp(b_value))
 		panic("can't determine cond signednes (no cmp)");
-	op = get_Cmp_left(pred);
+	op = get_Cmp_left(b_value);
 	return get_irn_mode(op);
 }
 
@@ -899,7 +903,6 @@ static ir_node *make_address(dbg_info *dbgi, ir_node *block, ir_entity *entity,
 {
 	ir_node *hi  = new_bd_sparc_SetHi(dbgi, block, entity, offset);
 	ir_node *low = new_bd_sparc_Or_imm(dbgi, block, hi, entity, offset);
-	be_dep_on_frame(hi);
 	return low;
 }
 
@@ -943,14 +946,14 @@ static ir_node *gen_SwitchJmp(ir_node *node)
 
 static ir_node *gen_Cond(ir_node *node)
 {
-	ir_node  *selector = get_Cond_selector(node);
-	ir_mode  *mode     = get_irn_mode(selector);
-	ir_mode  *cmp_mode;
-	ir_node  *block;
-	ir_node  *flag_node;
-	bool      is_unsigned;
-	pn_Cmp    pnc;
-	dbg_info *dbgi;
+	ir_node    *selector = get_Cond_selector(node);
+	ir_mode    *mode     = get_irn_mode(selector);
+	ir_mode    *cmp_mode;
+	ir_node    *block;
+	ir_node    *flag_node;
+	bool        is_unsigned;
+	ir_relation relation;
+	dbg_info   *dbgi;
 
 	// switch/case jumps
 	if (mode != mode_b) {
@@ -958,21 +961,20 @@ static ir_node *gen_Cond(ir_node *node)
 	}
 
 	// regular if/else jumps
-	assert(is_Proj(selector));
-	assert(is_Cmp(get_Proj_pred(selector)));
+	assert(is_Cmp(selector));
 
 	cmp_mode = get_cmp_mode(selector);
 
 	block       = be_transform_node(get_nodes_block(node));
 	dbgi        = get_irn_dbg_info(node);
-	flag_node   = be_transform_node(get_Proj_pred(selector));
-	pnc         = get_Proj_pn_cmp(selector);
+	flag_node   = be_transform_node(selector);
+	relation    = get_Cmp_relation(selector);
 	is_unsigned = !mode_is_signed(cmp_mode);
 	if (mode_is_float(cmp_mode)) {
 		assert(!is_unsigned);
-		return new_bd_sparc_fbfcc(dbgi, block, flag_node, pnc);
+		return new_bd_sparc_fbfcc(dbgi, block, flag_node, relation);
 	} else {
-		return new_bd_sparc_Bicc(dbgi, block, flag_node, pnc, is_unsigned);
+		return new_bd_sparc_Bicc(dbgi, block, flag_node, relation, is_unsigned);
 	}
 }
 
@@ -1287,7 +1289,7 @@ static void create_stacklayout(ir_graph *irg)
 }
 
 /**
- * transform the start node to the prolog code + initial barrier
+ * transform the start node to the prolog code
  */
 static ir_node *gen_Start(ir_node *node)
 {
@@ -1300,8 +1302,7 @@ static ir_node *gen_Start(ir_node *node)
 	ir_node   *mem;
 	ir_node   *start;
 	ir_node   *sp;
-	ir_node   *barrier;
-	int        i;
+	size_t     i;
 
 	/* stackpointer is important at function prolog */
 	be_prolog_add_reg(abihelper, sp_reg,
@@ -1334,23 +1335,24 @@ static ir_node *gen_Start(ir_node *node)
 	}
 
 	start = be_prolog_create_start(abihelper, dbgi, new_block);
-	mem  = be_prolog_get_memory(abihelper);
-	sp   = be_prolog_get_reg_value(abihelper, sp_reg);
+	mem   = be_prolog_get_memory(abihelper);
+	sp    = be_prolog_get_reg_value(abihelper, sp_reg);
 
 	if (!cconv->omit_fp) {
 		ir_node *save = new_bd_sparc_Save_imm(NULL, block, sp, NULL,
 		                                      -SPARC_MIN_STACKSIZE);
-		sp = new_r_Proj(save, mode_gp, pn_sparc_Save_stack);
-		arch_set_irn_register(sp, sp_reg);
+		arch_irn_add_flags(save, arch_irn_flags_prolog);
+		arch_set_irn_register(save, sp_reg);
+		sp = save;
+		keep_alive(save);
 	}
 
 	sp = be_new_IncSP(sp_reg, new_block, sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
+	arch_irn_add_flags(sp, arch_irn_flags_prolog);
 	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;
+	return start;
 }
 
 static ir_node *get_stack_pointer_for(ir_node *node)
@@ -1381,15 +1383,15 @@ static ir_node *get_stack_pointer_for(ir_node *node)
  */
 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             = get_stack_pointer_for(node);
-	int       n_res          = get_Return_n_ress(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        = get_stack_pointer_for(node);
+	size_t    n_res     = get_Return_n_ress(node);
 	ir_node  *bereturn;
-	int       i;
+	size_t    i;
 
 	be_epilog_begin(abihelper);
 	be_epilog_set_memory(abihelper, new_mem);
@@ -1422,22 +1424,24 @@ static ir_node *gen_Return(ir_node *node)
 		}
 	}
 
-	/* create the barrier before the epilog code */
-	be_epilog_create_barrier(abihelper, new_block);
-
-	/* epilog code: an incsp */
-	sp = be_epilog_get_reg_value(abihelper, sp_reg);
-	sp = be_new_IncSP(sp_reg, new_block, sp,
-	                  BE_STACK_FRAME_SIZE_SHRINK, 0);
-	be_epilog_set_reg_value(abihelper, sp_reg, sp);
-
 	/* we need a restore instruction */
 	if (!cconv->omit_fp) {
-		ir_node *restore = new_bd_sparc_RestoreZero(NULL, block);
-		keep_alive(restore);
+		ir_node *fp      = be_prolog_get_reg_value(abihelper, fp_reg);
+		ir_node *restore = new_bd_sparc_RestoreZero(NULL, block, fp);
+		arch_irn_add_flags(restore, arch_irn_flags_epilog);
+		arch_set_irn_register(restore, sp_reg);
+		be_epilog_set_reg_value(abihelper, sp_reg, restore);
+	} else {
+		/* epilog code: an incsp */
+		sp = be_epilog_get_reg_value(abihelper, sp_reg);
+		sp = be_new_IncSP(sp_reg, new_block, sp,
+						  BE_STACK_FRAME_SIZE_SHRINK, 0);
+		arch_irn_add_flags(sp, arch_irn_flags_epilog);
+		be_epilog_set_reg_value(abihelper, sp_reg, sp);
 	}
 
 	bereturn = be_epilog_create_return(abihelper, dbgi, new_block);
+	arch_irn_add_flags(bereturn, arch_irn_flags_epilog);
 
 	return bereturn;
 }
@@ -1515,8 +1519,8 @@ 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);
-	int              n_params     = get_Call_n_params(node);
-	int              n_param_regs = sizeof(param_regs)/sizeof(param_regs[0]);
+	size_t           n_params     = get_Call_n_params(node);
+	size_t           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);
@@ -1535,7 +1539,7 @@ static ir_node *gen_Call(ir_node *node)
 	ir_node         *incsp;
 	int              mem_pos;
 	ir_node         *res;
-	int              p;
+	size_t           p;
 	int              i;
 	int              o;
 	int              out_arity;
@@ -1841,9 +1845,12 @@ static ir_node *gen_Proj_Div(ir_node *node)
 	ir_node  *new_pred = be_transform_node(pred);
 	long      pn       = get_Proj_proj(node);
 
-	assert(is_sparc_SDiv(new_pred) || is_sparc_UDiv(new_pred));
+	assert(is_sparc_SDiv(new_pred) || is_sparc_UDiv(new_pred)
+	       || is_sparc_fdiv(new_pred));
 	assert((int)pn_sparc_SDiv_res == (int)pn_sparc_UDiv_res);
 	assert((int)pn_sparc_SDiv_M   == (int)pn_sparc_UDiv_M);
+	assert((int)pn_sparc_SDiv_res == (int)pn_sparc_fdiv_res);
+	assert((int)pn_sparc_SDiv_M   == (int)pn_sparc_fdiv_M);
 	switch (pn) {
 	case pn_Div_res:
 		return new_r_Proj(new_pred, mode_gp, pn_sparc_SDiv_res);
@@ -1855,24 +1862,6 @@ static ir_node *gen_Proj_Div(ir_node *node)
 	panic("Unsupported Proj from Div");
 }
 
-static ir_node *gen_Proj_Quot(ir_node *node)
-{
-	ir_node  *pred     = get_Proj_pred(node);
-	ir_node  *new_pred = be_transform_node(pred);
-	long      pn       = get_Proj_proj(node);
-
-	assert(is_sparc_fdiv(new_pred));
-	switch (pn) {
-	case pn_Quot_res:
-		return new_r_Proj(new_pred, mode_gp, pn_sparc_fdiv_res);
-	case pn_Quot_M:
-		return new_r_Proj(new_pred, mode_gp, pn_sparc_fdiv_M);
-	default:
-		break;
-	}
-	panic("Unsupported Proj from Quot");
-}
-
 static ir_node *get_frame_base(void)
 {
 	const arch_register_t *reg = cconv->omit_fp ? sp_reg : fp_reg;
@@ -1883,17 +1872,19 @@ 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);
+	/* make sure prolog is constructed */
+	be_transform_node(get_Proj_pred(node));
 
 	switch ((pn_Start) pn) {
 	case pn_Start_X_initial_exec:
 		/* exchange ProjX with a jump */
 		return new_bd_sparc_Ba(NULL, new_block);
 	case pn_Start_M:
-		return new_r_Proj(barrier, mode_M, 0);
+		return be_prolog_get_memory(abihelper);
 	case pn_Start_T_args:
-		return barrier;
+		/* we should never need this explicitely */
+		return new_r_Bad(get_irn_irg(block));
 	case pn_Start_P_frame_base:
 		return get_frame_base();
 	case pn_Start_P_tls:
@@ -1978,7 +1969,6 @@ static ir_node *gen_Proj_Call(ir_node *node)
 	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;
 	}
@@ -2047,8 +2037,6 @@ static ir_node *gen_Proj(ir_node *node)
 		return be_duplicate_node(node);
 	case iro_Div:
 		return gen_Proj_Div(node);
-	case iro_Quot:
-		return gen_Proj_Quot(node);
 	case iro_Start:
 		return gen_Proj_Start(node);
 	case iro_Proj: {
@@ -2102,7 +2090,6 @@ static 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_Quot,         gen_Quot);
 	be_set_transform_function(op_Return,       gen_Return);
 	be_set_transform_function(op_Sel,          gen_Sel);
 	be_set_transform_function(op_Shl,          gen_Shl);
@@ -2117,27 +2104,6 @@ static 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.
  */
@@ -2161,8 +2127,6 @@ void sparc_transform_graph(ir_graph *irg)
 	create_stacklayout(irg);
 
 	be_transform_graph(irg, NULL);
-	if (!cconv->omit_fp)
-		assure_fp_keep();
 
 	be_abihelper_finish(abihelper);
 	sparc_free_calling_convention(cconv);