X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=700115c4085cc685bdfb9469d299be640fb631b8;hb=70141f1b87d770fc18c98948f1049dec758ff020;hp=db457360de8a7ef408032ba2a69a132439bb3c83;hpb=8535fe8732b0acf822be252812a7158ce5b8134a;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index db457360d..700115c40 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -1,299 +1,254 @@ -/** - * Processor architecture specification. - * @author Sebastian Hack - * @date 11.2.2005 +/* + * 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. * - * $Id$ + * 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. */ -#ifdef HAVE_CONFIG_H -#include -#endif - -#ifdef HAVE_ALLOCA_H -#include -#endif -#ifdef HAVE_MALLOC_H -#include -#endif +/** + * @file + * @brief Processor architecture specification. + * @author Sebastian Hack + * @version $Id$ + */ +#include "config.h" #include -#include "bearch.h" +#include "bearch_t.h" +#include "benode_t.h" +#include "beinfo.h" #include "ircons_t.h" #include "irnode_t.h" #include "bitset.h" #include "pset.h" -#include "entity.h" #include "raw_bitset.h" #include "irprintf.h" /* Initialize the architecture environment struct. */ -arch_env_t *arch_env_init(arch_env_t *env, const arch_isa_if_t *isa_if, FILE *file_handle, be_main_env_t *main_env) -{ - memset(env, 0, sizeof(*env)); - env->isa = isa_if->init(file_handle); - env->isa->main_env = main_env; - return env; -} - -arch_env_t *arch_env_push_irn_handler(arch_env_t *env, - const arch_irn_handler_t *handler) +arch_env_t *arch_env_init(const arch_isa_if_t *isa_if, FILE *file_handle, be_main_env_t *main_env) { - assert(env->handlers_tos < ARCH_MAX_HANDLERS); - env->handlers[env->handlers_tos++] = handler; - return env; -} - -const arch_irn_handler_t *arch_env_pop_irn_handler(arch_env_t *env) -{ - assert(env->handlers_tos > 0 && env->handlers_tos <= ARCH_MAX_HANDLERS); - return env->handlers[--env->handlers_tos]; -} - -static const arch_irn_ops_t *fallback_irn_ops = NULL; - -int arch_register_class_put(const arch_register_class_t *cls, bitset_t *bs) -{ - if(bs) { - int i, n; - for(i = 0, n = cls->n_regs; i < n; ++i) - bitset_set(bs, i); - } - - return cls->n_regs; + arch_env_t *arch_env = isa_if->init(file_handle); + arch_env->main_env = main_env; + return arch_env; } /** * Get the isa responsible for a node. - * @param env The arch environment with the isa stack. * @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 arch_env_t *env, const ir_node *irn) +static inline const arch_irn_ops_t *get_irn_ops(const ir_node *irn) { - int i; - - for(i = env->handlers_tos - 1; i >= 0; --i) { - const arch_irn_handler_t *handler = env->handlers[i]; - const arch_irn_ops_t *ops = handler->get_irn_ops(handler, irn); + const ir_op *ops; + const arch_irn_ops_t *be_ops; - if(ops) - return ops; + if (is_Proj(irn)) { + irn = get_Proj_pred(irn); + assert(!is_Proj(irn)); } - return fallback_irn_ops; -} + ops = get_irn_op(irn); + be_ops = get_op_ops(ops)->be_ops; -const arch_irn_ops_t *arch_get_irn_ops(const arch_env_t *env, const ir_node *irn) { - return get_irn_ops(env, irn); + assert(be_ops); + return be_ops; } -const arch_register_req_t *arch_get_register_req(const arch_env_t *env, - const ir_node *irn, int pos) +const arch_register_req_t *arch_get_register_req(const ir_node *irn, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->get_irn_reg_req(ops, irn, pos); + const arch_irn_ops_t *ops = get_irn_ops(irn); + return ops->get_irn_reg_req(irn, pos); } -void arch_set_frame_offset(const arch_env_t *env, ir_node *irn, int offset) +void arch_set_frame_offset(ir_node *irn, int offset) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - ops->impl->set_frame_offset(ops, irn, offset); + const arch_irn_ops_t *ops = get_irn_ops(irn); + ops->set_frame_offset(irn, offset); } -ir_entity *arch_get_frame_entity(const arch_env_t *env, ir_node *irn) +ir_entity *arch_get_frame_entity(const ir_node *irn) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->get_frame_entity(ops, irn); + const arch_irn_ops_t *ops = get_irn_ops(irn); + return ops->get_frame_entity(irn); } -void arch_set_frame_entity(const arch_env_t *env, ir_node *irn, ir_entity *ent) +void arch_set_frame_entity(ir_node *irn, ir_entity *ent) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - ops->impl->set_frame_entity(ops, irn, ent); + const arch_irn_ops_t *ops = get_irn_ops(irn); + ops->set_frame_entity(irn, ent); } -int arch_get_sp_bias(const arch_env_t *env, ir_node *irn) +int arch_get_sp_bias(ir_node *irn) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->get_sp_bias(ops, irn); + const arch_irn_ops_t *ops = get_irn_ops(irn); + return ops->get_sp_bias(irn); } -arch_inverse_t *arch_get_inverse(const arch_env_t *env, const ir_node *irn, int i, arch_inverse_t *inverse, struct obstack *obstack) +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(env, irn); + const arch_irn_ops_t *ops = get_irn_ops(irn); - if(ops->impl->get_inverse) { - return ops->impl->get_inverse(ops, irn, i, inverse, obstack); + if(ops->get_inverse) { + return ops->get_inverse(irn, i, inverse, obstack); } else { return NULL; } } -int arch_possible_memory_operand(const arch_env_t *env, const ir_node *irn, unsigned int i) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); +int arch_possible_memory_operand(const ir_node *irn, unsigned int i) +{ + const arch_irn_ops_t *ops = get_irn_ops(irn); - if(ops->impl->possible_memory_operand) { - return ops->impl->possible_memory_operand(ops, irn, i); + if(ops->possible_memory_operand) { + return ops->possible_memory_operand(irn, i); } else { return 0; } } -void arch_perform_memory_operand(const arch_env_t *env, ir_node *irn, ir_node *spill, unsigned int i) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); +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->impl->perform_memory_operand) { - ops->impl->perform_memory_operand(ops, irn, spill, i); + if(ops->perform_memory_operand) { + ops->perform_memory_operand(irn, spill, i); } else { return; } } -int arch_get_op_estimated_cost(const arch_env_t *env, const ir_node *irn) +int arch_get_op_estimated_cost(const ir_node *irn) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); + const arch_irn_ops_t *ops = get_irn_ops(irn); - if(ops->impl->get_op_estimated_cost) { - return ops->impl->get_op_estimated_cost(ops, irn); + if(ops->get_op_estimated_cost) { + return ops->get_op_estimated_cost(irn); } else { return 1; } } -int arch_is_possible_memory_operand(const arch_env_t *env, const ir_node *irn, int i) +void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); + unsigned i; - if(ops->impl->possible_memory_operand) { - return ops->impl->possible_memory_operand(ops, irn, i); - } else { - return 0; + for(i = 0; i < cls->n_regs; ++i) { + if(!arch_register_type_is(&cls->regs[i], ignore)) + bitset_set(bs, i); } } -int arch_get_allocatable_regs(const arch_env_t *env, const ir_node *irn, int pos, bitset_t *bs) +int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t *reg) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - const arch_register_req_t *req = ops->impl->get_irn_reg_req(ops, irn, pos); + const arch_register_req_t *req = arch_get_register_req(irn, pos); - if(req->type == arch_register_req_type_none) { - bitset_clear_all(bs); + if(req->type == arch_register_req_type_none) return 0; - } if(arch_register_req_is(req, limited)) { - rbitset_copy_to_bitset(req->limited, bs); - return bitset_popcnt(bs); + assert(arch_register_get_class(reg) == req->cls); + return rbitset_is_set(req->limited, arch_register_get_index(reg)); } - arch_register_class_put(req->cls, bs); - return req->cls->n_regs; + return req->cls == reg->reg_class; } -void arch_put_non_ignore_regs(const arch_env_t *env, const arch_register_class_t *cls, bitset_t *bs) +const arch_register_class_t *arch_get_irn_reg_class(const ir_node *irn, int pos) { - int i; + const arch_register_req_t *req = arch_get_register_req(irn, pos); - for(i = 0; i < cls->n_regs; ++i) { - if(!arch_register_type_is(&cls->regs[i], ignore)) - bitset_set(bs, i); - } + assert(req->type != arch_register_req_type_none || req->cls == NULL); + + return req->cls; } -int arch_count_non_ignore_regs(const arch_env_t *env, const arch_register_class_t *cls) +static inline reg_out_info_t *get_out_info(const ir_node *node) { - int i; - int result = 0; + int pos = 0; + const backend_info_t *info; - for(i = 0; i < cls->n_regs; ++i) { - if(!arch_register_type_is(&cls->regs[i], ignore)) - result++; + assert(get_irn_mode(node) != mode_T); + if (is_Proj(node)) { + pos = get_Proj_proj(node); + node = get_Proj_pred(node); } - return result; + info = be_get_info(node); + assert(pos >= 0 && pos < ARR_LEN(info->out_infos)); + return &info->out_infos[pos]; } -int arch_is_register_operand(const arch_env_t *env, - const ir_node *irn, int pos) -{ - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - const arch_register_req_t *req = ops->impl->get_irn_reg_req(ops, irn, pos); - - return req != NULL; -} -int arch_reg_is_allocatable(const arch_env_t *env, const ir_node *irn, - int pos, const arch_register_t *reg) +static inline reg_out_info_t *get_out_info_n(const ir_node *node, int pos) { - const arch_register_req_t *req; - - req = arch_get_register_req(env, irn, pos); + 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]; +} - 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); - return rbitset_is_set(req->limited, arch_register_get_index(reg)); - } - - return req->cls == reg->reg_class; +const arch_register_t *arch_get_irn_register(const ir_node *node) +{ + const reg_out_info_t *out = get_out_info(node); + return out->reg; } -const arch_register_class_t * -arch_get_irn_reg_class(const arch_env_t *env, const ir_node *irn, int pos) +const arch_register_t *arch_irn_get_register(const ir_node *node, int pos) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - const arch_register_req_t *req = ops->impl->get_irn_reg_req(ops, irn, pos); - - assert(req->type != arch_register_req_type_none || req->cls == NULL); + const reg_out_info_t *out = get_out_info_n(node, pos); + return out->reg; +} - return req->cls; +void arch_irn_set_register(ir_node *node, int pos, const arch_register_t *reg) +{ + reg_out_info_t *out = get_out_info_n(node, pos); + out->reg = reg; } -extern const arch_register_t * -arch_get_irn_register(const arch_env_t *env, const ir_node *irn) +void arch_set_irn_register(ir_node *node, const arch_register_t *reg) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->get_irn_reg(ops, irn); + reg_out_info_t *out = get_out_info(node); + out->reg = reg; } -extern void arch_set_irn_register(const arch_env_t *env, - ir_node *irn, const arch_register_t *reg) +arch_irn_class_t arch_irn_classify(const ir_node *node) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - ops->impl->set_irn_reg(ops, irn, reg); + const arch_irn_ops_t *ops = get_irn_ops(node); + return ops->classify(node); } -extern arch_irn_class_t arch_irn_classify(const arch_env_t *env, const ir_node *irn) +arch_irn_flags_t arch_irn_get_flags(const ir_node *node) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->classify(ops, irn); + backend_info_t *info = be_get_info(node); + return info->flags; } -extern arch_irn_flags_t arch_irn_get_flags(const arch_env_t *env, const ir_node *irn) +void arch_irn_set_flags(ir_node *node, arch_irn_flags_t flags) { - const arch_irn_ops_t *ops = get_irn_ops(env, irn); - return ops->impl->get_flags(ops, irn); + backend_info_t *info = be_get_info(node); + info->flags = flags; } -extern const char *arch_irn_flag_str(arch_irn_flags_t fl) +void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags) { - switch(fl) { -#define XXX(x) case arch_irn_flags_ ## x: return #x; - XXX(dont_spill); - XXX(ignore); - XXX(rematerializable); - XXX(modify_sp); - XXX(none); -#undef XXX - } - return "n/a"; + backend_info_t *info = be_get_info(node); + info->flags |= flags; } extern char *arch_register_req_format(char *buf, size_t len, @@ -318,15 +273,36 @@ extern char *arch_register_req_format(char *buf, size_t len, } if(arch_register_req_is(req, should_be_same)) { - const ir_node *same = get_irn_n(node, req->other_same); - ir_snprintf(tmp, sizeof(tmp), " same to: %+F", same); - strncat(buf, tmp, len); + const unsigned other = req->other_same; + int i; + + ir_snprintf(tmp, sizeof(tmp), " same to:"); + 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); + } + } + } + + if (arch_register_req_is(req, must_be_different)) { + const unsigned other = req->other_different; + int i; + + ir_snprintf(tmp, sizeof(tmp), " 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); + } + } } - if(arch_register_req_is(req, should_be_different)) { - const ir_node *different = get_irn_n(node, req->other_different); - ir_snprintf(tmp, sizeof(tmp), " different to: %+F", different); - strncat(buf, tmp, len); + if (arch_register_req_is(req, ignore)) { + strncat(buf, " ignore", len); + } + if (arch_register_req_is(req, produces_sp)) { + strncat(buf, " produces_sp", len); } return buf; @@ -336,7 +312,7 @@ static const arch_register_req_t no_requirement = { arch_register_req_type_none, NULL, NULL, - -1, - -1 + 0, + 0 }; const arch_register_req_t *arch_no_register_req = &no_requirement;