X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbearch.c;h=c7b0ad36fe193282994c53bb1552d01c87408493;hb=0f3e3e5388cf02a125924f2743c90e55f63ddede;hp=86d176b00c924258f6029c18ab24092b403406f6;hpb=f69787e3b55dfd3dc0f8beaf3cd1144e6dd6312b;p=libfirm diff --git a/ir/be/bearch.c b/ir/be/bearch.c index 86d176b00..c7b0ad36f 100644 --- a/ir/be/bearch.c +++ b/ir/be/bearch.c @@ -1,440 +1,359 @@ -/** - * 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. * - * $Id$ + * 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. + */ + +/** + * @file + * @brief Processor architecture specification. + * @author Sebastian Hack + * @version $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#ifdef HAVE_ALLOCA_H -#include -#endif -#ifdef HAVE_MALLOC_H -#include -#endif - #include -#include "bearch.h" - -#include "pset.h" - -#include "entity.h" +#include "bearch_t.h" +#include "benode_t.h" #include "ircons_t.h" +#include "irnode_t.h" -/* Needed for obstack copy */ -#define bcopy(src,dst,n) memcpy(dst,src,n) - -#define INIT_HEADER(tgt, kind_suffix, a_isa, str) \ - do { \ - arch_header_t *h = (arch_header_t *) (tgt); \ - memset(tgt, 0, sizeof(*(tgt))); \ - h->kind = arch_kind_ ## kind_suffix; \ - h->name = new_id_from_str(str); \ - h->isa = a_isa; \ - } while(0) +#include "bitset.h" +#include "pset.h" +#include "raw_bitset.h" -static INLINE int hash_header(const arch_header_t *header) -{ - int res = HASH_PTR(header->isa); - res = 37 * res + HASH_STR(header->name, strlen(header->name)); - res = 37 * res + header->kind; - return res; -} +#include "irprintf.h" -static int cmp_header(const void *a, const void *b) +/* 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) { - const arch_header_t *h1 = a; - const arch_header_t *h2 = b; - - return !(h1->kind == h2->kind && h1->isa == h2->isa && strcmp(h1->name, h2->name) == 0); + arch_env_t *arch_env = isa_if->init(file_handle); + arch_env->main_env = main_env; + return arch_env; } /** - * The obstack and pset where the arch data is stored. - */ -typedef struct _arch_data_t { - struct obstack obst; /**< Here is the data allocated. */ - pset *header_set; /**< Here reside copies of the headers. */ -} arch_data_t; - -/** - * Get the storage (obstack and pset) for the arch objects. - * @return A struct containing both, the obst and pset where - * the objects are allocated and their pointer are recorded. + * 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 INLINE arch_data_t *get_arch_data(void) +static int arch_register_class_put(const arch_register_class_t *cls, bitset_t *bs) { - static arch_data_t arch_data; - static int inited = 0; - - if(!inited) { - obstack_init(&arch_data.obst); - arch_data.header_set = new_pset(cmp_header, 512); - inited = 1; - } - - return &arch_data; + int i, n = cls->n_regs; + for (i = n - 1; i >= 0; --i) + bitset_set(bs, i); + return n; } /** - * Dump all arch objects in the arch_data collection. + * 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 void dump_arch_data(void) +static INLINE const arch_irn_ops_t *get_irn_ops(const ir_node *irn) { - void *p; - arch_data_t *d = get_arch_data(); - static const char *kind_names[] = { -#define ARCH_OBJ(name,in_list) #name, -#include "bearch_obj.def" -#undef ARCH_OBJ - "" - }; - - printf("arch set:\n"); - for(p = pset_first(d->header_set); p; p = pset_next(d->header_set)) { - arch_header_t *header = p; - printf("%20s %10s %10s\n", kind_names[header->kind], header->name, - header->isa ? header->isa->header.name : ""); - } -} + const ir_op *ops; + const arch_irn_ops_t *be_ops; -typedef struct _obj_info_t { - const char *name; - int listed_in_isa; - size_t size; -} obj_info_t; - -static const obj_info_t obj_info[] = { -#define ARCH_OBJ(name,listed_in_isa) { #name, listed_in_isa, sizeof(arch_ ## name ## _t) }, -#include "bearch_obj.def" -#undef ARCH_OBJ - { 0 } -}; - -/** - * Insert an arch object to the global arch obj storage. - * - * If the object has already been created there, nothing is done and - * the old object is created. - * - * @param kind The kind of the arch object. - * @param isa The isa the object belongs to or NULL if it is the isa - * itself. - * @param name The name of the object. - * @return A pointer to the object. - */ -static INLINE void *_arch_data_insert(arch_kind_t kind, arch_isa_t *isa, - const char *name, size_t size) -{ - arch_data_t *ad = get_arch_data(); - const obj_info_t *info = &obj_info[kind]; - arch_header_t *header = obstack_alloc(&ad->obst, size); - arch_header_t *res = NULL; - - memset(header, 0, size); - header->name = name; - header->kind = kind; - header->isa = isa; - header->is_new = 1; - - res = pset_insert(ad->header_set, header, hash_header(header)); - - /* - * If the object is newly created and thus not yet present - * in the set, add it to the isa - * The inserted object was no isa, list it in the isa if this is - * desired. - */ - if(res->is_new && isa && info->listed_in_isa) { - list_add(&res->list, &isa->heads[kind]); + if (is_Proj(irn)) { + irn = get_Proj_pred(irn); + assert(!is_Proj(irn)); } - /* if it was in the set, remove it from the obstack */ - if(!res->is_new) - obstack_free(&ad->obst, header); - - /* Mark the object as NOT new. */ - res->is_new = 0; + ops = get_irn_op(irn); + be_ops = get_op_ops(ops)->be_ops; - return res; + assert(be_ops); + return be_ops; } -#define arch_data_insert(type_suffix, isa, name) \ - _arch_data_insert(arch_kind_ ## type_suffix, isa, name, sizeof(arch_ ## type_suffix ## _t)) - -static INLINE void *_arch_data_find(arch_kind_t kind, const arch_isa_t *isa, const char *name) +const arch_irn_ops_t *arch_get_irn_ops(const arch_env_t *env, const ir_node *irn) { - arch_header_t header; - - header.kind = kind; - header.isa = (arch_isa_t *) isa; - header.name = name; - - return pset_find(get_arch_data()->header_set, &header, hash_header(&header)); + (void)env; // TODO remove parameter + return get_irn_ops(irn); } -#define arch_data_find(type_suffix, isa, name) \ - _arch_data_find(arch_kind_ ## type_suffix, isa, name) - -arch_isa_t *arch_add_isa(const char *name) +const arch_register_req_t *arch_get_register_req(const arch_env_t *env, + const ir_node *irn, int pos) { - arch_isa_t *isa; - int i; - - isa = arch_data_insert(isa, NULL, name); - for(i = 0; i < arch_kind_last; ++i) - INIT_LIST_HEAD(&isa->heads[i]); - - return isa; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->get_irn_reg_req(irn, pos); } -arch_register_set_t *arch_add_register_set(arch_isa_t *isa, - const arch_register_class_t *cls, const char *name) +void arch_set_frame_offset(const arch_env_t *env, ir_node *irn, int offset) { - arch_register_set_t *set = - _arch_data_insert(arch_kind_register_set, isa, name, - sizeof(arch_register_set_t) + cls->n_regs * sizeof(set->regs[0])); - - set->reg_class = cls; - memset(set->regs, 0, sizeof(set->regs[0]) * cls->n_regs); - - return set; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + ops->set_frame_offset(irn, offset); } -arch_register_class_t *arch_add_register_class(arch_isa_t *isa, const char *name, int n_regs) +ir_entity *arch_get_frame_entity(const arch_env_t *env, const ir_node *irn) { - char buf[64]; - char *set_name; - int i, n; - - arch_register_class_t *cls = - _arch_data_insert(arch_kind_register_class, isa, name, - sizeof(arch_register_class_t) + n_regs * sizeof(arch_register_t *)); - - /* Make a name for the set contianing all regs in this class. */ - n = snprintf(buf, sizeof(buf), "%s$set", name); - set_name = obstack_copy(&get_arch_data()->obst, buf, n); - - cls->n_regs = n_regs; - - /* make the set of all registers in this class */ - cls->set = arch_add_register_set(isa, cls, name); - - /* Add each register in this class to the set */ - for(i = 0; i < n_regs; ++i) - cls->set->regs[i] = 1; - - return cls; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->get_frame_entity(irn); } -void arch_register_set_add_register(arch_register_set_t *set, int index) +void arch_set_frame_entity(const arch_env_t *env, ir_node *irn, ir_entity *ent) { - assert(index >= 0 && index < set->reg_class->n_regs); - set->regs[index] = 1; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + ops->set_frame_entity(irn, ent); } -arch_register_t *arch_add_register(arch_register_class_t *cls, int index, const char *name) +int arch_get_sp_bias(const arch_env_t *env, ir_node *irn) { - arch_register_t *reg = NULL; - - assert(index >= 0 && index < cls->n_regs); - reg = _arch_data_insert(arch_kind_register, arch_obj_get_isa(cls), name, - sizeof(arch_register_t)); - cls->regs[index] = reg; - - reg->index = index; - reg->reg_class = cls; - reg->flags = arch_register_flag_none; - - return reg; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->get_sp_bias(irn); } -arch_immediate_t *arch_add_immediate(arch_isa_t *isa, const char *name, ir_mode *mode) +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_immediate_t *imm = arch_data_insert(immediate, isa, name); - imm->mode = mode; - return imm; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + + if(ops->get_inverse) { + return ops->get_inverse(irn, i, inverse, obstack); + } else { + return NULL; + } } -/* - * Size of each operand type which should be allocated in an irn. - * Keep this list up to date with the arch_operand_type_t enum. - */ -static const size_t operand_sizes[] = { -#define ARCH_OPERAND_TYPE(name,size_in_irn) size_in_irn, -#include "bearch_operand_types.def" -#undef ARCH_OPERAND_TYPE - 0 -}; +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(irn); + (void)env; // TODO remove parameter -/** - * Determine the amount of bytes which has to be extra allocated when a - * new ir node is made from a insn format. - * This size depends on the operands specified in the insn format. - * @param fmt The instruction format. - * @return The number of bytes which the operands of an instruction - * will need in an ir node. - */ -static INLINE int arch_get_operands_size(const arch_insn_format_t *fmt) -{ - int i, res = 0; + if(ops->possible_memory_operand) { + return ops->possible_memory_operand(irn, i); + } else { + return 0; + } +} - for(i = 0; i < fmt->n_in + fmt->n_out; ++i) { - arch_operand_type_t type = fmt->operands[i].type; +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(irn); + (void)env; // TODO remove parameter - assert(type > arch_operand_type_invalid && type < arch_operand_type_last); - res += operand_sizes[type]; + if(ops->perform_memory_operand) { + ops->perform_memory_operand(irn, spill, i); + } else { + return; } - - return res; } -arch_insn_format_t *arch_add_insn_format(arch_isa_t *isa, const char *name, int n_in, int n_out) +int arch_get_op_estimated_cost(const arch_env_t *env, const ir_node *irn) { - int i; - - arch_insn_format_t *fmt = - _arch_data_insert(arch_kind_insn_format, isa, name, - sizeof(arch_insn_format_t) + (n_in + n_out) * sizeof(arch_operand_t)); + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter - fmt->n_in = n_in; - fmt->n_out = n_out; + if(ops->get_op_estimated_cost) { + return ops->get_op_estimated_cost(irn); + } else { + return 1; + } +} - /* initialize each operand with invalid. */ - for(i = 0; i < n_in + n_out; ++i) - fmt->operands[i].type = arch_operand_type_invalid; +int arch_is_possible_memory_operand(const arch_env_t *env, const ir_node *irn, int i) +{ + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter - return fmt; + if(ops->possible_memory_operand) { + return ops->possible_memory_operand(irn, i); + } else { + return 0; + } } -arch_insn_t *arch_add_insn(arch_insn_format_t *fmt, const char *name) +int arch_get_allocatable_regs(const arch_env_t *env, const ir_node *irn, int pos, bitset_t *bs) { - /* Get the size the operands will need in the irn. */ - int operands_size = arch_get_operands_size(fmt); + const arch_irn_ops_t *ops = get_irn_ops(irn); + const arch_register_req_t *req = ops->get_irn_reg_req(irn, pos); + (void)env; // TODO remove parameter - /* Insert the insn into the isa. */ - arch_insn_t *insn = arch_data_insert(insn, arch_obj_get_isa(fmt), name); + if(req->type == arch_register_req_type_none) { + bitset_clear_all(bs); + return 0; + } - insn->format = fmt; - insn->op = new_ir_op(get_next_ir_opcode(), name, op_pin_state_pinned, 0, - oparity_dynamic, 0, sizeof(arch_irn_data_t) + operands_size); + if(arch_register_req_is(req, limited)) { + rbitset_copy_to_bitset(req->limited, bs); + return bitset_popcnt(bs); + } - return insn; + arch_register_class_put(req->cls, bs); + return req->cls->n_regs; } -arch_insn_format_t *arch_find_insn_format(const arch_isa_t *isa, const char *name) +void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs) { - return arch_data_find(insn_format, isa, name); -} + unsigned i; -arch_isa_t *arch_find_isa(const char *name) -{ - return arch_data_find(isa, NULL, name); + for(i = 0; i < cls->n_regs; ++i) { + if(!arch_register_type_is(&cls->regs[i], ignore)) + bitset_set(bs, i); + } } -arch_insn_t *arch_find_insn(const arch_isa_t *isa, const char *name) +int arch_is_register_operand(const arch_env_t *env, + const ir_node *irn, int pos) { - return arch_data_find(insn, isa, name); -} + const arch_irn_ops_t *ops = get_irn_ops(irn); + const arch_register_req_t *req = ops->get_irn_reg_req(irn, pos); + (void)env; // TODO remove parameter -arch_immediate_t *arch_find_immediate(const arch_isa_t *isa, const char *name) -{ - return arch_data_find(immediate, isa, name); + return req != NULL; } -arch_register_class_t *arch_find_register_class(const arch_isa_t *isa, const char *name) +int arch_reg_is_allocatable(const arch_env_t *env, const ir_node *irn, + int pos, const arch_register_t *reg) { - return arch_data_find(register_class, isa, name); -} + const arch_register_req_t *req; -arch_register_set_t *arch_find_register_set(const arch_isa_t *isa, const char *name) -{ - return arch_data_find(register_set, isa, name); -} + req = arch_get_register_req(env, irn, pos); -arch_register_set_t *arch_get_register_set_for_class(arch_register_class_t *cls) -{ - return _arch_get_register_set_for_class(cls); + 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; } -static INLINE arch_operand_t *_arch_set_operand(arch_insn_format_t *fmt, int pos, - arch_operand_type_t type) +const arch_register_class_t * +arch_get_irn_reg_class(const arch_env_t *env, const ir_node *irn, int pos) { - arch_operand_t *operand; - int ofs = arch_inout_to_index(fmt, pos); + const arch_irn_ops_t *ops = get_irn_ops(irn); + const arch_register_req_t *req = ops->get_irn_reg_req(irn, pos); + (void)env; // TODO remove parameter - assert(ofs < fmt->n_in + fmt->n_out); + assert(req->type != arch_register_req_type_none || req->cls == NULL); - operand = &fmt->operands[ofs]; - operand->type = type; - return operand; + return req->cls; } -arch_operand_t *arch_set_operand_register_set(arch_insn_format_t *fmt, - int pos, const arch_register_set_t *set) +extern const arch_register_t * +arch_get_irn_register(const arch_env_t *env, const ir_node *irn) { - arch_operand_t *op = _arch_set_operand(fmt, pos, arch_operand_type_register_set); - op->data.set = set; - return op; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->get_irn_reg(irn); } -arch_operand_t *arch_set_operand_callback(arch_insn_format_t *fmt, - int pos, arch_register_callback_t *cb) +extern void arch_set_irn_register(const arch_env_t *env, + ir_node *irn, const arch_register_t *reg) { - arch_operand_t *op = _arch_set_operand(fmt, pos, arch_operand_type_callback); - op->data.callback = cb; - return op; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + ops->set_irn_reg(irn, reg); } -arch_operand_t *arch_set_operand_immediate(arch_insn_format_t *fmt, - int pos, const arch_immediate_t *imm) +extern arch_irn_class_t arch_irn_classify(const arch_env_t *env, const ir_node *irn) { - arch_operand_t *op = _arch_set_operand(fmt, pos, arch_operand_type_immediate); - op->data.imm = imm; - return op; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->classify(irn); } -arch_operand_t *arch_set_operand_memory(arch_insn_format_t *fmt, int pos) +extern arch_irn_flags_t arch_irn_get_flags(const arch_env_t *env, const ir_node *irn) { - arch_operand_t *op = _arch_set_operand(fmt, pos, arch_operand_type_memory); - return op; + const arch_irn_ops_t *ops = get_irn_ops(irn); + (void)env; // TODO remove parameter + return ops->get_flags(irn); } -arch_operand_t *arch_set_operand_equals(arch_insn_format_t *fmt, int pos, int same_as_pos) +extern const char *arch_irn_flag_str(arch_irn_flags_t fl) { - arch_operand_t *op = _arch_set_operand(fmt, pos, arch_operand_type_equals); - op->data.same_as_pos = same_as_pos; - return op; + switch(fl) { +#define XXX(x) case arch_irn_flags_ ## x: return #x; + XXX(dont_spill); + XXX(ignore); + XXX(rematerializable); + XXX(modify_sp); + XXX(modify_flags); + XXX(none); +#undef XXX + } + return "n/a"; } -ir_node *arch_new_node(const arch_insn_t *insn, ir_graph *irg, ir_node *block, - ir_mode *mode, int arity, ir_node **in) +extern char *arch_register_req_format(char *buf, size_t len, + const arch_register_req_t *req, + const ir_node *node) { - ir_node *irn = new_ir_node(NULL, irg, block, insn->op, mode, arity, in); - arch_irn_data_t *data = (void *) &irn->attr; - - data->magic = ARCH_IRN_FOURCC; - data->insn = insn; - - return irn; -} + char tmp[128]; + snprintf(buf, len, "class: %s", req->cls->name); + + 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)) { + const arch_register_t *reg = &req->cls->regs[i]; + strncat(buf, " ", len); + strncat(buf, reg->name, len); + } + } + } -ir_node *arch_new_node_bare(const arch_insn_t *insn, ir_graph *irg, int arity) -{ - int i; - ir_node **in = alloca(sizeof(in[0]) * arity); + if(arch_register_req_is(req, should_be_same)) { + 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); + } + } + } - for(i = 0; i < arity; ++i) - in[i] = new_Unknown(mode_Is); + 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); + } + } + } - return arch_new_node(insn, irg, new_Unknown(mode_BB), mode_Is, arity, in); + return buf; } -ir_mode *arch_get_unknown_mode(void) -{ - return mode_Is; -} +static const arch_register_req_t no_requirement = { + arch_register_req_type_none, + NULL, + NULL, + 0, + 0 +}; +const arch_register_req_t *arch_no_register_req = &no_requirement;