X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=83c066154679c13fb8778f4edc4b801ee7626d37;hb=705e29fe8d95b03ee01f4cbe4a519b0b0f72eec0;hp=ebab47f16302c19fecb758e6184d31c0060345aa;hpb=bb9f2e36362333c6635b89f5258171b06c786608;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index ebab47f16..83c066154 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -27,10 +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" @@ -46,20 +48,6 @@ arch_env_t *arch_env_init(const arch_isa_if_t *isa_if, FILE *file_handle, be_mai return arch_env; } -/** - * Put all registers in a class into a bitset. - * @param cls The class. - * @param bs The bitset. - * @return The number of registers in the class. - */ -static int arch_register_class_put(const arch_register_class_t *cls, bitset_t *bs) -{ - int i, n = cls->n_regs; - for (i = n - 1; i >= 0; --i) - bitset_set(bs, i); - return n; -} - /** * Get the isa responsible for a node. * @param irn The node to get the responsible isa for. @@ -78,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)) { + assert(pos == -1); + pos = -1-get_Proj_proj(irn); + irn = get_Proj_pred(irn); + } + + if (pos < 0) { + 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); + } } void arch_set_frame_offset(ir_node *irn, int offset) @@ -156,25 +153,6 @@ int arch_get_op_estimated_cost(const ir_node *irn) } } -int arch_get_allocatable_regs(const ir_node *irn, int pos, bitset_t *bs) -{ - const arch_irn_ops_t *ops = get_irn_ops(irn); - const arch_register_req_t *req = ops->get_irn_reg_req(irn, pos); - - if(req->type == arch_register_req_type_none) { - bitset_clear_all(bs); - return 0; - } - - if(arch_register_req_is(req, limited)) { - rbitset_copy_to_bitset(req->limited, bs); - return bitset_popcnt(bs); - } - - arch_register_class_put(req->cls, bs); - return req->cls->n_regs; -} - void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs) { unsigned i; @@ -185,7 +163,8 @@ void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs) } } -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); @@ -193,7 +172,8 @@ int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t * return 0; if(arch_register_req_is(req, limited)) { - assert(arch_register_get_class(reg) == req->cls); + if (arch_register_get_class(reg) != req->cls) + return 0; return rbitset_is_set(req->limited, arch_register_get_index(reg)); } @@ -202,55 +182,106 @@ int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t * const arch_register_class_t *arch_get_irn_reg_class(const ir_node *irn, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - const arch_register_req_t *req = ops->get_irn_reg_req(irn, pos); + const arch_register_req_t *req = arch_get_register_req(irn, pos); assert(req->type != arch_register_req_type_none || req->cls == NULL); return req->cls; } -const arch_register_t *arch_get_irn_register(const ir_node *irn) +static inline reg_out_info_t *get_out_info(const ir_node *node) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - return ops->get_irn_reg(irn); + int pos = 0; + const backend_info_t *info; + + assert(get_irn_mode(node) != mode_T); + if (is_Proj(node)) { + pos = get_Proj_proj(node); + node = get_Proj_pred(node); + } + + info = be_get_info(node); + assert(pos >= 0 && pos < ARR_LEN(info->out_infos)); + return &info->out_infos[pos]; } -void arch_set_irn_register(ir_node *irn, const arch_register_t *reg) + +static inline reg_out_info_t *get_out_info_n(const ir_node *node, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - ops->set_irn_reg(irn, reg); + const backend_info_t *info = be_get_info(node); + assert(!is_Proj(node)); + assert(pos >= 0 && pos < ARR_LEN(info->out_infos)); + return &info->out_infos[pos]; } -arch_irn_class_t arch_irn_classify(const ir_node *irn) + +const arch_register_t *arch_get_irn_register(const ir_node *node) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - return ops->classify(irn); + const reg_out_info_t *out = get_out_info(node); + return out->reg; } -arch_irn_flags_t arch_irn_get_flags(const ir_node *irn) +const arch_register_t *arch_irn_get_register(const ir_node *node, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(irn); - return ops->get_flags(irn); + const reg_out_info_t *out = get_out_info_n(node, pos); + return out->reg; } -extern char *arch_register_req_format(char *buf, size_t len, - const arch_register_req_t *req, - const ir_node *node) +void arch_irn_set_register(ir_node *node, int pos, const arch_register_t *reg) { - char tmp[128]; - snprintf(buf, len, "class: %s", req->cls->name); + reg_out_info_t *out = get_out_info_n(node, pos); + out->reg = reg; +} + +void arch_set_irn_register(ir_node *node, const arch_register_t *reg) +{ + reg_out_info_t *out = get_out_info(node); + out->reg = reg; +} + +arch_irn_class_t arch_irn_classify(const ir_node *node) +{ + const arch_irn_ops_t *ops = get_irn_ops(node); + return ops->classify(node); +} + +arch_irn_flags_t arch_irn_get_flags(const ir_node *node) +{ + backend_info_t *info = be_get_info(node); + return info->flags; +} + +void arch_irn_set_flags(ir_node *node, arch_irn_flags_t flags) +{ + backend_info_t *info = be_get_info(node); + info->flags = flags; +} + +void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags) +{ + backend_info_t *info = be_get_info(node); + info->flags |= flags; +} + +void arch_dump_register_req(FILE *F, const arch_register_req_t *req, + const ir_node *node) +{ + 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)) { unsigned n_regs = req->cls->n_regs; unsigned i; - strncat(buf, " limited:", len); + 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); } } } @@ -259,11 +290,10 @@ extern char *arch_register_req_format(char *buf, size_t len, 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)); } } } @@ -272,16 +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)); } } } - return buf; + if (arch_register_req_is(req, ignore)) { + fprintf(F, " ignore"); + } + if (arch_register_req_is(req, produces_sp)) { + 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"); + } + + 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 = {