X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=06819e7c60326906528d512fea752d320969338a;hb=f85d684391adac08d54c3fdcda868e6392de2ffb;hp=700115c4085cc685bdfb9469d299be640fb631b8;hpb=a824d376c1c37f80c7e1ebd6304665380d28fc5f;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index 700115c40..06819e7c6 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -27,11 +27,12 @@ #include -#include "bearch_t.h" -#include "benode_t.h" +#include "bearch.h" +#include "benode.h" #include "beinfo.h" #include "ircons_t.h" #include "irnode_t.h" +#include "irop_t.h" #include "bitset.h" #include "pset.h" @@ -65,14 +66,23 @@ static inline const arch_irn_ops_t *get_irn_ops(const ir_node *irn) ops = get_irn_op(irn); be_ops = get_op_ops(ops)->be_ops; - assert(be_ops); return be_ops; } const arch_register_req_t *arch_get_register_req(const ir_node *irn, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - return ops->get_irn_reg_req(irn, pos); + if (is_Proj(irn)) { + ir_node *pred = get_Proj_pred(irn); + long pn = get_Proj_proj(irn); + assert(pos == -1); + return arch_get_out_register_req(pred, pn); + } + + if (pos < 0) { + return arch_get_out_register_req(irn, -pos-1); + } else { + return arch_get_in_register_req(irn, pos); + } } void arch_set_frame_offset(ir_node *irn, int offset) @@ -87,12 +97,6 @@ ir_entity *arch_get_frame_entity(const ir_node *irn) return ops->get_frame_entity(irn); } -void arch_set_frame_entity(ir_node *irn, ir_entity *ent) -{ - const arch_irn_ops_t *ops = get_irn_ops(irn); - ops->set_frame_entity(irn, ent); -} - int arch_get_sp_bias(ir_node *irn) { const arch_irn_ops_t *ops = get_irn_ops(irn); @@ -103,7 +107,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; @@ -114,7 +118,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; @@ -125,7 +129,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; @@ -136,32 +140,24 @@ 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; } } -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)) - bitset_set(bs, i); - } -} - -int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t *reg) +int arch_reg_is_allocatable(const ir_node *irn, int pos, + const arch_register_t *reg) { 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)) { - assert(arch_register_get_class(reg) == req->cls); + 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)); } @@ -251,36 +247,37 @@ void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags) info->flags |= flags; } -extern char *arch_register_req_format(char *buf, size_t len, - const arch_register_req_t *req, - const ir_node *node) +void arch_dump_register_req(FILE *F, const arch_register_req_t *req, + const ir_node *node) { - char tmp[128]; - snprintf(buf, len, "class: %s", req->cls->name); + if (req == NULL || req->type == arch_register_req_type_none) { + fprintf(F, "n/a"); + return; + } + + 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; - strncat(buf, " limited:", len); - for(i = 0; i < n_regs; ++i) { - if(rbitset_is_set(req->limited, i)) { + fprintf(F, " limited to"); + for (i = 0; i < n_regs; ++i) { + if (rbitset_is_set(req->limited, i)) { const arch_register_t *reg = &req->cls->regs[i]; - strncat(buf, " ", len); - strncat(buf, reg->name, len); + 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; - ir_snprintf(tmp, sizeof(tmp), " same to:"); + fprintf(F, " same as"); for (i = 0; 1U << i <= other; ++i) { if (other & (1U << i)) { - ir_snprintf(tmp, sizeof(tmp), " %+F", get_irn_n(skip_Proj_const(node), i)); - strncat(buf, tmp, len); + ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i)); } } } @@ -289,23 +286,70 @@ extern char *arch_register_req_format(char *buf, size_t len, const unsigned other = req->other_different; int i; - ir_snprintf(tmp, sizeof(tmp), " different from:"); + fprintf(F, " different from"); for (i = 0; 1U << i <= other; ++i) { if (other & (1U << i)) { - ir_snprintf(tmp, sizeof(tmp), " %+F", get_irn_n(skip_Proj_const(node), i)); - strncat(buf, tmp, len); + ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i)); } } } + if (req->width != 1) { + fprintf(F, " width:%u", req->width); + } + if (arch_register_req_is(req, aligned)) { + fprintf(F, " aligned"); + } if (arch_register_req_is(req, ignore)) { - strncat(buf, " ignore", len); + fprintf(F, " ignore"); } if (arch_register_req_is(req, produces_sp)) { - strncat(buf, " produces_sp", len); + fprintf(F, " produces_sp"); + } +} + +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"); } - return buf; + 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 = { @@ -313,6 +357,7 @@ static const arch_register_req_t no_requirement = { NULL, NULL, 0, + 0, 0 }; const arch_register_req_t *arch_no_register_req = &no_requirement;