X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=ec4aee0189b0856be3f0859b2d6fb113aebe6d87;hb=9e9c84725fd3fcfbcb819d6d6b88f8da91f121a9;hp=49a785214a203c8d034fd9100f4437f54808a635;hpb=c20b5f64ae62e0b0d1281cfd9a878ea5733d3da1;p=libfirm

diff --git a/ir/be/bearch.c b/ir/be/bearch.c
index 49a785214..ec4aee018 100644
--- a/ir/be/bearch.c
+++ b/ir/be/bearch.c
@@ -28,7 +28,7 @@
 #include <string.h>
 
 #include "bearch.h"
-#include "benode_t.h"
+#include "benode.h"
 #include "beinfo.h"
 #include "ircons_t.h"
 #include "irnode_t.h"
@@ -71,36 +71,20 @@ static inline const arch_irn_ops_t *get_irn_ops(const ir_node *irn)
 
 const arch_register_req_t *arch_get_register_req(const ir_node *irn, int pos)
 {
-	const arch_irn_ops_t *ops;
-
 	if (is_Proj(irn)) {
 		assert(pos == -1);
 		pos = -1-get_Proj_proj(irn);
 		irn = get_Proj_pred(irn);
 	}
-	ops = get_irn_ops_simple(irn);
+
 	if (pos < 0) {
-		return ops->get_irn_reg_req_out(irn, -pos-1);
+		return arch_get_out_register_req(irn, -pos-1);
 	} else {
+		const arch_irn_ops_t *ops = get_irn_ops_simple(irn);
 		return ops->get_irn_reg_req_in(irn, pos);
 	}
 }
 
-const arch_register_req_t *arch_get_register_req_out(const ir_node *irn)
-{
-	int                   pos = 0;
-	const arch_irn_ops_t *ops;
-
-	if (is_Proj(irn)) {
-		pos = get_Proj_proj(irn);
-		irn = get_Proj_pred(irn);
-	} else if (get_irn_mode(irn) == mode_T) {
-		return arch_no_register_req;
-	}
-	ops = get_irn_ops(irn);
-	return ops->get_irn_reg_req_out(irn, pos);
-}
-
 void arch_set_frame_offset(ir_node *irn, int offset)
 {
 	const arch_irn_ops_t *ops = get_irn_ops(irn);
@@ -129,7 +113,7 @@ arch_inverse_t *arch_get_inverse(const ir_node *irn, int i, arch_inverse_t *inve
 {
 	const arch_irn_ops_t *ops = get_irn_ops(irn);
 
-	if(ops->get_inverse) {
+	if (ops->get_inverse) {
 		return ops->get_inverse(irn, i, inverse, obstack);
 	} else {
 		return NULL;
@@ -140,7 +124,7 @@ int arch_possible_memory_operand(const ir_node *irn, unsigned int i)
 {
 	const arch_irn_ops_t *ops = get_irn_ops(irn);
 
-	if(ops->possible_memory_operand) {
+	if (ops->possible_memory_operand) {
 		return ops->possible_memory_operand(irn, i);
 	} else {
 		return 0;
@@ -151,7 +135,7 @@ void arch_perform_memory_operand(ir_node *irn, ir_node *spill, unsigned int i)
 {
 	const arch_irn_ops_t *ops = get_irn_ops(irn);
 
-	if(ops->perform_memory_operand) {
+	if (ops->perform_memory_operand) {
 		ops->perform_memory_operand(irn, spill, i);
 	} else {
 		return;
@@ -162,7 +146,7 @@ int arch_get_op_estimated_cost(const ir_node *irn)
 {
 	const arch_irn_ops_t *ops = get_irn_ops(irn);
 
-	if(ops->get_op_estimated_cost) {
+	if (ops->get_op_estimated_cost) {
 		return ops->get_op_estimated_cost(irn);
 	} else {
 		return 1;
@@ -173,8 +157,8 @@ void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs)
 {
 	unsigned i;
 
-	for(i = 0; i < cls->n_regs; ++i) {
-		if(!arch_register_type_is(&cls->regs[i], ignore))
+	for (i = 0; i < cls->n_regs; ++i) {
+		if (!arch_register_type_is(&cls->regs[i], ignore))
 			bitset_set(bs, i);
 	}
 }
@@ -184,10 +168,10 @@ int arch_reg_is_allocatable(const ir_node *irn, int pos,
 {
 	const arch_register_req_t *req = arch_get_register_req(irn, pos);
 
-	if(req->type == arch_register_req_type_none)
+	if (req->type == arch_register_req_type_none)
 		return 0;
 
-	if(arch_register_req_is(req, limited)) {
+	if (arch_register_req_is(req, limited)) {
 		if (arch_register_get_class(reg) != req->cls)
 			return 0;
 		return rbitset_is_set(req->limited, arch_register_get_index(reg));
@@ -289,20 +273,20 @@ void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
 
 	fprintf(F, "%s", req->cls->name);
 
-	if(arch_register_req_is(req, limited)) {
+	if (arch_register_req_is(req, limited)) {
 		unsigned n_regs = req->cls->n_regs;
 		unsigned i;
 
 		fprintf(F, " limited to");
-		for(i = 0; i < n_regs; ++i) {
-			if(rbitset_is_set(req->limited, i)) {
+		for (i = 0; i < n_regs; ++i) {
+			if (rbitset_is_set(req->limited, i)) {
 				const arch_register_t *reg = &req->cls->regs[i];
 				fprintf(F, " %s", reg->name);
 			}
 		}
 	}
 
-	if(arch_register_req_is(req, should_be_same)) {
+	if (arch_register_req_is(req, should_be_same)) {
 		const unsigned other = req->other_same;
 		int i;
 
@@ -334,6 +318,50 @@ void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
 	}
 }
 
+void arch_dump_reqs_and_registers(FILE *F, const ir_node *node)
+{
+	int              n_ins  = get_irn_arity(node);
+	int              n_outs = arch_irn_get_n_outs(node);
+	arch_irn_flags_t flags  = arch_irn_get_flags(node);
+	int              i;
+
+	for (i = 0; i < n_ins; ++i) {
+		const arch_register_req_t *req = arch_get_in_register_req(node, i);
+		fprintf(F, "inreq #%d = ", i);
+		arch_dump_register_req(F, req, node);
+		fputs("\n", F);
+	}
+	for (i = 0; i < n_outs; ++i) {
+		const arch_register_req_t *req = arch_get_out_register_req(node, i);
+		fprintf(F, "outreq #%d = ", i);
+		arch_dump_register_req(F, req, node);
+		fputs("\n", F);
+	}
+	for (i = 0; i < n_outs; ++i) {
+		const arch_register_t     *reg = arch_irn_get_register(node, i);
+		const arch_register_req_t *req = arch_get_out_register_req(node, i);
+		if (req->cls == NULL)
+			continue;
+		fprintf(F, "reg #%d = %s\n", i, reg != NULL ? reg->name : "n/a");
+	}
+
+	fprintf(F, "flags =");
+	if (flags == arch_irn_flags_none) {
+		fprintf(F, " none");
+	} else {
+		if (flags & arch_irn_flags_dont_spill) {
+			fprintf(F, " unspillable");
+		}
+		if (flags & arch_irn_flags_rematerializable) {
+			fprintf(F, " remat");
+		}
+		if (flags & arch_irn_flags_modify_flags) {
+			fprintf(F, " modify_flags");
+		}
+	}
+	fprintf(F, " (%d)\n", flags);
+}
+
 static const arch_register_req_t no_requirement = {
 	arch_register_req_type_none,
 	NULL,