X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbenode.c;h=4e5a45aab1f625632c88fe814f9dc0011868b42b;hb=c4ff1c9959667db87996891435a12ae466563062;hp=3afb9c14ec0f6408a68d947252f39385d30484b3;hpb=0b0d25482de3d3bb4b980936984e7a4e3458804f;p=libfirm

diff --git a/ir/be/benode.c b/ir/be/benode.c
index 3afb9c14e..4e5a45aab 100644
--- a/ir/be/benode.c
+++ b/ir/be/benode.c
@@ -95,21 +95,21 @@ typedef struct {
 /** The be_Frame attribute type. */
 typedef struct {
 	be_node_attr_t node_attr;
-	entity *ent;
+	ir_entity *ent;
 	int offset;
 } be_frame_attr_t;
 
 /** The be_Call attribute type. */
 typedef struct {
 	be_node_attr_t node_attr;
-	entity *ent;         /**< The called entity if this is a static call. */
+	ir_entity *ent;      /**< The called entity if this is a static call. */
 	ir_type *call_tp;    /**< The call type, copied from the original Call node. */
 } be_call_attr_t;
 
 typedef struct {
 	be_node_attr_t node_attr;
-	entity **in_entities;
-	entity **out_entities;
+	ir_entity **in_entities;
+	ir_entity **out_entities;
 } be_memperm_attr_t;
 
 ir_op *op_be_Spill;
@@ -338,25 +338,38 @@ be_node_set_irn_reg(const void *_self, ir_node *irn, const arch_register_t *reg)
 }
 
 
-ir_node *be_new_Spill(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *to_spill)
+ir_node *be_new_Spill(const arch_register_class_t *cls, const arch_register_class_t *cls_frame,
+	ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *to_spill)
 {
 	be_frame_attr_t *a;
+	ir_node         *in[2];
 	ir_node         *res;
 
-	res       = new_ir_node(NULL, irg, bl, op_be_Spill, mode_M, 1, &to_spill);
+	in[0]     = frame;
+	in[1]     = to_spill;
+	res       = new_ir_node(NULL, irg, bl, op_be_Spill, mode_M, 2, in);
 	a         = init_node_attr(res, 2);
 	a->ent    = NULL;
 	a->offset = 0;
 
+	be_node_set_reg_class(res, be_pos_Spill_frame, cls_frame);
 	be_node_set_reg_class(res, be_pos_Spill_val, cls);
 	return res;
 }
 
-ir_node *be_new_Reload(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *mem, ir_mode *mode)
+ir_node *be_new_Reload(const arch_register_class_t *cls, const arch_register_class_t *cls_frame,
+	ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *mem, ir_mode *mode)
 {
-	ir_node *res = new_ir_node(NULL, irg, bl, op_be_Reload, mode, 1, &mem);
+	ir_node *in[2];
+	ir_node *res;
+
+	in[0] = frame;
+	in[1] = mem;
+	res   = new_ir_node(NULL, irg, bl, op_be_Reload, mode, 2, in);
+
 	init_node_attr(res, 2);
 	be_node_set_reg_class(res, -1, cls);
+	be_node_set_reg_class(res, be_pos_Reload_frame, cls_frame);
 	be_node_set_flags(res, -1, arch_irn_flags_rematerializable);
 	return res;
 }
@@ -367,11 +380,22 @@ ir_node *be_get_Reload_mem(const ir_node *irn)
 	return get_irn_n(irn, be_pos_Reload_mem);
 }
 
+ir_node *be_get_Reload_frame(const ir_node *irn)
+{
+	assert(be_is_Reload(irn));
+	return get_irn_n(irn, be_pos_Reload_frame);
+}
+
 ir_node *be_get_Spill_val(const ir_node *irn)
 {
 	assert(be_is_Spill(irn));
 	return get_irn_n(irn, be_pos_Spill_val);
 }
+ir_node *be_get_Spill_frame(const ir_node *irn)
+{
+	assert(be_is_Spill(irn));
+	return get_irn_n(irn, be_pos_Spill_frame);
+}
 
 ir_node *be_new_Perm(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int n, ir_node *in[])
 {
@@ -477,14 +501,14 @@ ir_node *be_new_Call(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem, ir
 }
 
 /* Gets the call entity or NULL if this is no static call. */
-entity *be_Call_get_entity(const ir_node *call) {
+ir_entity *be_Call_get_entity(const ir_node *call) {
 	be_call_attr_t *a = get_irn_attr(call);
 	assert(be_is_Call(call));
 	return a->ent;
 }
 
 /* Sets the call entity. */
-void be_Call_set_entity(ir_node *call, entity *ent) {
+void be_Call_set_entity(ir_node *call, ir_entity *ent) {
 	be_call_attr_t *a = get_irn_attr(call);
 	assert(be_is_Call(call));
 	a->ent = ent;
@@ -612,7 +636,7 @@ ir_node *be_new_SetSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_
 	return irn;
 }
 
-ir_node *be_new_StackParam(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, entity *ent)
+ir_node *be_new_StackParam(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, ir_entity *ent)
 {
 	be_frame_attr_t *a;
 	ir_node *irn;
@@ -639,7 +663,7 @@ ir_node *be_new_RegParams(ir_graph *irg, ir_node *bl, int n_outs)
 }
 
 ir_node *be_new_FrameLoad(const arch_register_class_t *cls_frame, const arch_register_class_t *cls_data,
-						  ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, entity *ent)
+						  ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_entity *ent)
 {
 	be_frame_attr_t *a;
 	ir_node *irn;
@@ -657,7 +681,7 @@ ir_node *be_new_FrameLoad(const arch_register_class_t *cls_frame, const arch_reg
 }
 
 ir_node *be_new_FrameStore(const arch_register_class_t *cls_frame, const arch_register_class_t *cls_data,
-						   ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_node *data, entity *ent)
+						   ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_node *data, ir_entity *ent)
 {
 	be_frame_attr_t *a;
 	ir_node *irn;
@@ -675,7 +699,7 @@ ir_node *be_new_FrameStore(const arch_register_class_t *cls_frame, const arch_re
 	return irn;
 }
 
-ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, entity *ent)
+ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_entity *ent)
 {
 	be_frame_attr_t *a;
 	ir_node *irn;
@@ -766,16 +790,26 @@ int be_has_frame_entity(const ir_node *irn)
 	}
 }
 
-entity* be_get_frame_entity(const ir_node *irn)
+ir_entity *be_get_frame_entity(const ir_node *irn)
 {
-	if(be_has_frame_entity(irn)) {
+	if (be_has_frame_entity(irn)) {
 		be_frame_attr_t *a = get_irn_attr(irn);
 		return a->ent;
 	}
 	return NULL;
 }
 
-void be_set_MemPerm_in_entity(const ir_node *irn, int n, entity *ent)
+int be_get_frame_offset(const ir_node *irn)
+{
+	assert(is_be_node(irn));
+	if (be_has_frame_entity(irn)) {
+		be_frame_attr_t *a = get_irn_attr(irn);
+		return a->offset;
+	}
+	return 0;
+}
+
+void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity *ent)
 {
 	be_memperm_attr_t *attr = get_irn_attr(irn);
 
@@ -785,7 +819,7 @@ void be_set_MemPerm_in_entity(const ir_node *irn, int n, entity *ent)
 	attr->in_entities[n] = ent;
 }
 
-entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
+ir_entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
 {
 	be_memperm_attr_t *attr = get_irn_attr(irn);
 
@@ -795,7 +829,7 @@ entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
 	return attr->in_entities[n];
 }
 
-void be_set_MemPerm_out_entity(const ir_node *irn, int n, entity *ent)
+void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity *ent)
 {
 	be_memperm_attr_t *attr = get_irn_attr(irn);
 
@@ -805,7 +839,7 @@ void be_set_MemPerm_out_entity(const ir_node *irn, int n, entity *ent)
 	attr->out_entities[n] = ent;
 }
 
-entity* be_get_MemPerm_out_entity(const ir_node* irn, int n)
+ir_entity* be_get_MemPerm_out_entity(const ir_node* irn, int n)
 {
 	be_memperm_attr_t *attr = get_irn_attr(irn);
 
@@ -889,8 +923,12 @@ void be_node_set_flags(ir_node *irn, int pos, arch_irn_flags_t flags)
 void be_node_set_reg_class(ir_node *irn, int pos, const arch_register_class_t *cls)
 {
 	be_req_t *r = get_req(irn, pos);
+
 	r->req.cls = cls;
-	if(r->req.type == arch_register_req_type_none)
+
+	if (cls == NULL)
+		r->req.type = arch_register_req_type_none;
+	else if (r->req.type == arch_register_req_type_none)
 		r->req.type = arch_register_req_type_normal;
 }
 
@@ -931,27 +969,30 @@ int be_get_IncSP_offset(const ir_node *irn)
 
 ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn)
 {
-	ir_node                     *bl  = get_nodes_block(irn);
-	ir_graph                    *irg = get_irn_irg(bl);
-	const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, irn, -1);
+	ir_node                     *bl        = get_nodes_block(irn);
+	ir_graph                    *irg       = get_irn_irg(bl);
+	ir_node                     *frame     = get_irg_frame(irg);
+	const arch_register_class_t *cls       = arch_get_irn_reg_class(arch_env, irn, -1);
+	const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1);
 	ir_node                     *spill;
 
-
-	spill = be_new_Spill(cls, irg, bl, irn);
+	spill = be_new_Spill(cls, cls_frame, irg, bl, frame, irn);
 	return spill;
 }
 
 ir_node *be_reload(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_node *insert, ir_mode *mode, ir_node *spill)
 {
 	ir_node  *reload;
-	ir_node  *bl  = is_Block(insert) ? insert : get_nodes_block(insert);
-	ir_graph *irg = get_irn_irg(bl);
+	ir_node  *bl    = is_Block(insert) ? insert : get_nodes_block(insert);
+	ir_graph *irg   = get_irn_irg(bl);
+	ir_node  *frame = get_irg_frame(irg);
+	const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1);
 
 	assert(be_is_Spill(spill) || (is_Phi(spill) && get_irn_mode(spill) == mode_M));
 
-	reload = be_new_Reload(cls, irg, bl, spill, mode);
+	reload = be_new_Reload(cls, cls_frame, irg, bl, frame, spill, mode);
 
-	if(is_Block(insert)) {
+	if (is_Block(insert)) {
 		insert = sched_skip(insert, 0, sched_skip_cf_predicator, (void *) arch_env);
 		sched_add_after(insert, reload);
 	}
@@ -1012,17 +1053,29 @@ be_node_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_nod
 {
 	int out_pos = pos;
 
-	if(pos < 0) {
-		if(get_irn_mode(irn) == mode_T)
+	if (pos < 0) {
+		if (get_irn_mode(irn) == mode_T)
 			return NULL;
 
-		out_pos = redir_proj((const ir_node **) &irn, pos);
+		out_pos = redir_proj((const ir_node **)&irn, pos);
 		assert(is_be_node(irn));
 		return put_out_reg_req(req, irn, out_pos);
 	}
 
 	else {
-		return is_be_node(irn) ? put_in_reg_req(req, irn, pos) : NULL;
+		if (is_be_node(irn)) {
+			/*
+				For spills and reloads, we return "none" as requirement for frame pointer,
+				so every input is ok. Some backends need this (e.g. STA). We use an arbitrary
+				large number as pos, so put_in_reg_req will return "none" as requirement.
+			*/
+			if ((be_is_Spill(irn)  && pos == be_pos_Spill_frame) ||
+				(be_is_Reload(irn) && pos == be_pos_Reload_frame))
+				return put_in_reg_req(req, irn, INT_MAX);
+			else
+				return put_in_reg_req(req, irn, pos);
+		}
+		return NULL;
 	}
 
 	return req;
@@ -1061,12 +1114,12 @@ static arch_irn_flags_t be_node_get_flags(const void *_self, const ir_node *irn)
 	return r ? r->req.flags : 0;
 }
 
-static entity *be_node_get_frame_entity(const void *self, const ir_node *irn)
+static ir_entity *be_node_get_frame_entity(const void *self, const ir_node *irn)
 {
 	return be_get_frame_entity(irn);
 }
 
-static void be_node_set_frame_entity(const void *self, ir_node *irn, entity *ent)
+static void be_node_set_frame_entity(const void *self, ir_node *irn, ir_entity *ent)
 {
 	be_frame_attr_t *a;
 
@@ -1086,13 +1139,7 @@ static void be_node_set_frame_offset(const void *self, ir_node *irn, int offset)
 
 static int be_node_get_sp_bias(const void *self, const ir_node *irn)
 {
-	int result = 0;
-
-	if(be_is_IncSP(irn)) {
-		result = be_get_IncSP_offset(irn);
-	}
-
-	return result;
+	return be_is_IncSP(irn) ? be_get_IncSP_offset(irn) : 0;
 }
 
 /*
@@ -1232,12 +1279,12 @@ static arch_irn_flags_t phi_get_flags(const void *_self, const ir_node *irn)
 	return arch_irn_flags_none;
 }
 
-static entity *phi_get_frame_entity(const void *_self, const ir_node *irn)
+static ir_entity *phi_get_frame_entity(const void *_self, const ir_node *irn)
 {
 	return NULL;
 }
 
-static void phi_set_frame_entity(const void *_self, ir_node *irn, entity *ent)
+static void phi_set_frame_entity(const void *_self, ir_node *irn, ir_entity *ent)
 {
 }
 
@@ -1429,7 +1476,7 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason)
 				{
 					int i;
 					for(i = 0; i < be_get_MemPerm_entity_arity(irn); ++i) {
-						entity *in, *out;
+						ir_entity *in, *out;
 						in = be_get_MemPerm_in_entity(irn, i);
 						out = be_get_MemPerm_out_entity(irn, i);
 						if(in) {