X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=711c3015ecd699807ff7c97875f95f31f136b56b;hb=2be6077d3c0d1cdc8fad965f1857ac3a08c632aa;hp=348f71933c37706a414386786c7f10799293bfa3;hpb=1a3b7d363474ab544c13093a2f0b578718d37c7a;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index 348f71933..711c3015e 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -1,27 +1,12 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. - * * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** * @file * @brief Processor architecture specification. * @author Sebastian Hack - * @version $Id$ */ #include "config.h" @@ -40,51 +25,28 @@ #include "irprintf.h" -/* Initialize the architecture environment struct. */ -arch_env_t *arch_env_init(const arch_isa_if_t *isa_if, FILE *file_handle, be_main_env_t *main_env) -{ - arch_env_t *arch_env = isa_if->init(file_handle); - arch_env->main_env = main_env; - return arch_env; -} +arch_register_req_t const arch_no_requirement = { + arch_register_req_type_none, + NULL, + NULL, + 0, + 0, + 0 +}; /** * Get the isa responsible for a node. * @param irn The node to get the responsible isa for. * @return The irn operations given by the responsible isa. */ -static inline const arch_irn_ops_t *get_irn_ops(const ir_node *irn) +static const arch_irn_ops_t *get_irn_ops(const ir_node *irn) { - const ir_op *ops; - const arch_irn_ops_t *be_ops; - - if (is_Proj(irn)) { - irn = get_Proj_pred(irn); - assert(!is_Proj(irn)); - } - - ops = get_irn_op(irn); - be_ops = get_op_ops(ops)->be_ops; - + ir_op const *const op = get_irn_op(irn); + arch_irn_ops_t const *const be_ops = get_op_ops(op)->be_ops; + assert(be_ops); return be_ops; } -const arch_register_req_t *arch_get_register_req(const ir_node *irn, int 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) { const arch_irn_ops_t *ops = get_irn_ops(irn); @@ -103,17 +65,6 @@ int arch_get_sp_bias(ir_node *irn) return ops->get_sp_bias(irn); } -arch_inverse_t *arch_get_inverse(const ir_node *irn, int i, arch_inverse_t *inverse, struct obstack *obstack) -{ - const arch_irn_ops_t *ops = get_irn_ops(irn); - - if (ops->get_inverse) { - return ops->get_inverse(irn, i, inverse, obstack); - } else { - return NULL; - } -} - int arch_possible_memory_operand(const ir_node *irn, unsigned int i) { const arch_irn_ops_t *ops = get_irn_ops(irn); @@ -128,12 +79,7 @@ int arch_possible_memory_operand(const ir_node *irn, unsigned int i) 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) { - ops->perform_memory_operand(irn, spill, i); - } else { - return; - } + ops->perform_memory_operand(irn, spill, i); } int arch_get_op_estimated_cost(const ir_node *irn) @@ -147,54 +93,10 @@ int arch_get_op_estimated_cost(const ir_node *irn) } } -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) - return 0; - - 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)); - } - - return req->cls == reg->reg_class; -} - -const arch_register_class_t *arch_get_irn_reg_class(const ir_node *irn, int 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; -} - -static inline reg_out_info_t *get_out_info(const ir_node *node) -{ - size_t 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 < ARR_LEN(info->out_infos)); - return &info->out_infos[pos]; -} - - -static inline reg_out_info_t *get_out_info_n(const ir_node *node, int pos) +static reg_out_info_t *get_out_info_n(const ir_node *node, unsigned pos) { const backend_info_t *info = be_get_info(node); - assert(!is_Proj(node)); - assert(pos >= 0 && pos < (int)ARR_LEN(info->out_infos)); + assert(pos < (unsigned)ARR_LEN(info->out_infos)); return &info->out_infos[pos]; } @@ -205,13 +107,21 @@ const arch_register_t *arch_get_irn_register(const ir_node *node) return out->reg; } -const arch_register_t *arch_irn_get_register(const ir_node *node, int pos) +const arch_register_t *arch_get_irn_register_out(const ir_node *node, + unsigned pos) { const reg_out_info_t *out = get_out_info_n(node, pos); return out->reg; } -void arch_irn_set_register(ir_node *node, int pos, const arch_register_t *reg) +const arch_register_t *arch_get_irn_register_in(const ir_node *node, int pos) +{ + ir_node *op = get_irn_n(node, pos); + return arch_get_irn_register(op); +} + +void arch_set_irn_register_out(ir_node *node, unsigned pos, + const arch_register_t *reg) { reg_out_info_t *out = get_out_info_n(node, pos); out->reg = reg; @@ -223,31 +133,37 @@ void arch_set_irn_register(ir_node *node, const arch_register_t *reg) out->reg = reg; } -arch_irn_class_t arch_irn_classify(const ir_node *node) +void arch_set_irn_flags(ir_node *node, arch_irn_flags_t flags) { - 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; + backend_info_t *const info = be_get_info(node); + info->flags = flags; } -void arch_irn_set_flags(ir_node *node, arch_irn_flags_t flags) +void arch_add_irn_flags(ir_node *node, arch_irn_flags_t flags) { - backend_info_t *info = be_get_info(node); - info->flags = flags; + backend_info_t *const info = be_get_info(node); + info->flags |= flags; } -void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags) +bool arch_reg_is_allocatable(const arch_register_req_t *req, + const arch_register_t *reg) { - backend_info_t *info = be_get_info(node); - info->flags |= flags; + assert(req->type != arch_register_req_type_none); + if (req->cls != reg->reg_class) + return false; + if (reg->type & arch_register_type_virtual) + return true; + if (arch_register_req_is(req, limited)) + return rbitset_is_set(req->limited, reg->index); + return true; } -void arch_dump_register_req(FILE *F, const arch_register_req_t *req, +/** + * Print information about a register requirement in human readable form + * @param F output stream/file + * @param req The requirements structure to format. + */ +static 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) { @@ -277,7 +193,7 @@ void arch_dump_register_req(FILE *F, const arch_register_req_t *req, fprintf(F, " same as"); for (i = 0; 1U << i <= other; ++i) { if (other & (1U << i)) { - ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i)); + ir_fprintf(F, " #%d (%+F)", i, get_irn_n(skip_Proj_const(node), i)); } } } @@ -289,13 +205,13 @@ void arch_dump_register_req(FILE *F, const arch_register_req_t *req, fprintf(F, " different from"); for (i = 0; 1U << i <= other; ++i) { if (other & (1U << i)) { - ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i)); + ir_fprintf(F, " #%d (%+F)", i, get_irn_n(skip_Proj_const(node), i)); } } } if (req->width != 1) { - fprintf(F, " width:%u", req->width); + fprintf(F, " width:%d", req->width); } if (arch_register_req_is(req, aligned)) { fprintf(F, " aligned"); @@ -310,32 +226,30 @@ 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; + backend_info_t *const info = be_get_info(node); + int const n_ins = get_irn_arity(node); + /* don't fail on invalid graphs */ + if (!info || (!info->in_reqs && n_ins != 0) || !info->out_infos) { + fprintf(F, "invalid register requirements!!!\n"); + return; + } - for (i = 0; i < n_ins; ++i) { - const arch_register_req_t *req = arch_get_in_register_req(node, i); + for (int i = 0; i < n_ins; ++i) { + const arch_register_req_t *req = arch_get_irn_register_req_in(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); + be_foreach_out(node, o) { + const arch_register_req_t *req = arch_get_irn_register_req_out(node, o); + fprintf(F, "outreq #%u = ", o); 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"); + const arch_register_t *reg = arch_get_irn_register_out(node, o); + fprintf(F, " [%s]\n", reg != NULL ? reg->name : "n/a"); } fprintf(F, "flags ="); + arch_irn_flags_t flags = arch_get_irn_flags(node); if (flags == arch_irn_flags_none) { fprintf(F, " none"); } else { @@ -354,22 +268,6 @@ void arch_dump_reqs_and_registers(FILE *F, const ir_node *node) if (flags & arch_irn_flags_not_scheduled) { fprintf(F, " not_scheduled"); } - if (flags & arch_irn_flags_prolog) { - fprintf(F, " prolog"); - } - if (flags & arch_irn_flags_epilog) { - fprintf(F, " epilog"); - } } - fprintf(F, " (%d)\n", flags); + fprintf(F, " (0x%x)\n", (unsigned)flags); } - -static const arch_register_req_t no_requirement = { - arch_register_req_type_none, - NULL, - NULL, - 0, - 0, - 0 -}; -const arch_register_req_t *arch_no_register_req = &no_requirement;