X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=ec4aee0189b0856be3f0859b2d6fb113aebe6d87;hb=780d1704bdcc2332c68a5161cfaa0f15cee9c352;hp=3bb6a7b5f3d38708cfdd8a9af096d6f6b971a58c;hpb=0860cafaff791b93c568c77739bd7d9c7240ee2f;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index 3bb6a7b5f..ec4aee018 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -28,10 +28,11 @@ #include #include "bearch.h" -#include "benode_t.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,42 +66,25 @@ 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; - if (is_Proj(irn)) { assert(pos == -1); pos = -1-get_Proj_proj(irn); irn = get_Proj_pred(irn); } - ops = get_irn_ops(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,21 +157,23 @@ 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); } } -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)); } @@ -277,36 +263,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)); } } } @@ -315,23 +302,64 @@ 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 (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 = {