X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbenode.c;h=a60e01a18c79f084f29734f082fff5ff4550e9dc;hb=f804d333c7b5459c3c1a6bfc188ecdc54346be73;hp=673f9ade0bb175b5c4a85e1bf1d602614bb073d8;hpb=7507003420c69d2a84403d07daf26a305c631b43;p=libfirm diff --git a/ir/be/benode.c b/ir/be/benode.c index 673f9ade0..a60e01a18 100644 --- a/ir/be/benode.c +++ b/ir/be/benode.c @@ -59,9 +59,16 @@ typedef struct { int *pos; } be_op_t; +typedef struct { + arch_register_req_t req; + unsigned negate_limited : 1; + void (*old_limited)(void *ptr, bitset_t *bs); + void *old_limited_env; +} be_req_t; + typedef struct { const arch_register_t *reg; - arch_register_req_t req; + be_req_t req; } be_reg_data_t; typedef struct { @@ -73,8 +80,7 @@ typedef struct { typedef struct { be_node_attr_t node_attr; ir_node *spill_ctx; /**< The node in whose context this spill was introduced. */ - unsigned offset; /**< The offset of the memory location the spill writes to - in the spill area. */ + entity *ent; /**< The entity in the stack frame the spill writes to. */ } be_spill_attr_t; static ir_op *op_Spill; @@ -87,26 +93,33 @@ static int beo_base = -1; static const ir_op_ops be_node_op_ops; +#define N irop_flag_none +#define L irop_flag_labeled +#define C irop_flag_commutative +#define X irop_flag_cfopcode +#define I irop_flag_ip_cfopcode +#define F irop_flag_fragile +#define Y irop_flag_forking +#define H irop_flag_highlevel +#define c irop_flag_constlike +#define K irop_flag_keep + void be_node_init(void) { static int inited = 0; - int i; if(inited) return; inited = 1; - beo_base = get_next_ir_opcode(); + /* Acquire all needed opcodes. */ + beo_base = get_next_ir_opcodes(beo_Last - 1); - /* Acquire all needed opcodes. We assume that they are consecutive! */ - for(i = beo_Spill; i < beo_Last; ++i) - get_next_ir_opcode(); - - op_Spill = new_ir_op(beo_base + beo_Spill, "Spill", op_pin_state_mem_pinned, 0, oparity_unary, 0, sizeof(be_spill_attr_t), &be_node_op_ops); - op_Reload = new_ir_op(beo_base + beo_Reload, "Reload", op_pin_state_mem_pinned, 0, oparity_zero, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Perm = new_ir_op(beo_base + beo_Perm, "Perm", op_pin_state_pinned, 0, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Copy = new_ir_op(beo_base + beo_Copy, "Copy", op_pin_state_pinned, 0, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Keep = new_ir_op(beo_base + beo_Keep, "Keep", op_pin_state_pinned, 0, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Spill = new_ir_op(beo_base + beo_Spill, "Spill", op_pin_state_mem_pinned, N, oparity_unary, 0, sizeof(be_spill_attr_t), &be_node_op_ops); + op_Reload = new_ir_op(beo_base + beo_Reload, "Reload", op_pin_state_mem_pinned, N, oparity_zero, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Perm = new_ir_op(beo_base + beo_Perm, "Perm", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Copy = new_ir_op(beo_base + beo_Copy, "Copy", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Keep = new_ir_op(beo_base + beo_Keep, "Keep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); set_op_tag(op_Spill, &be_node_tag); set_op_tag(op_Reload, &be_node_tag); @@ -129,8 +142,8 @@ static void *init_node_attr(ir_node* irn, const arch_register_class_t *cls, ir_g a->reg_data = NEW_ARR_D(be_reg_data_t, get_irg_obstack(irg), n_outs); memset(a->reg_data, 0, n_outs * sizeof(a->reg_data[0])); for(i = 0; i < n_outs; ++i) { - a->reg_data[i].req.cls = cls; - a->reg_data[i].req.type = arch_register_req_type_normal; + a->reg_data[i].req.req.cls = cls; + a->reg_data[i].req.req.type = arch_register_req_type_normal; } } @@ -156,7 +169,7 @@ ir_node *be_new_Spill(const arch_register_class_t *cls, ir_graph *irg, ir_node * in[0] = to_spill; res = new_ir_node(NULL, irg, bl, op_Spill, mode_M, 1, in); a = init_node_attr(res, cls, irg, 0); - a->offset = BE_SPILL_NO_OFFSET; + a->ent = NULL; a->spill_ctx = ctx; return res; } @@ -225,20 +238,38 @@ int be_is_Keep(const ir_node *irn) return get_irn_be_opcode(irn) == beo_Keep; } -void be_set_Perm_out_req(ir_node *irn, int pos, const arch_register_req_t *req) +static void be_limited(void *data, bitset_t *bs) { - be_node_attr_t *a = get_irn_attr(irn); + be_req_t *req = data; + + req->old_limited(req->old_limited_env, bs); + if(req->negate_limited) + bitset_flip_all(bs); +} + +void be_set_Perm_out_req(ir_node *irn, int pos, const arch_register_req_t *req, unsigned negate_limited) +{ + be_node_attr_t *a = get_irn_attr(irn); + be_req_t *r = &a->reg_data[pos].req; assert(be_is_Perm(irn)); assert(pos >= 0 && pos < get_irn_arity(irn)); - memcpy(&a->reg_data[pos].req, req, sizeof(req[0])); + memcpy(&r->req, req, sizeof(req[0])); + + if(arch_register_req_is(req, limited)) { + r->old_limited = r->req.limited; + r->old_limited_env = r->req.limited_env; + r->req.limited = be_limited; + r->req.limited_env = r; + r->negate_limited = negate_limited; + } } -void be_set_Spill_offset(ir_node *irn, unsigned offset) +void be_set_Spill_entity(ir_node *irn, entity *ent) { be_spill_attr_t *a = get_irn_attr(irn); assert(be_is_Spill(irn)); - a->offset = offset; + a->ent = ent; } static ir_node *find_a_spill_walker(ir_node *irn, unsigned visited_nr) @@ -284,24 +315,23 @@ static INLINE ir_node *find_a_spill(ir_node *irn) return find_a_spill_walker(irn, visited_nr); } - -unsigned be_get_spill_offset(ir_node *irn) +entity *be_get_spill_entity(ir_node *irn) { int opc = get_irn_opcode(irn); switch(get_irn_be_opcode(irn)) { case beo_Reload: - return be_get_spill_offset(find_a_spill(irn)); + return be_get_spill_entity(find_a_spill(irn)); case beo_Spill: { be_spill_attr_t *a = get_irn_attr(irn); - return a->offset; + return a->ent; } default: assert(0 && "Must give spill/reload node"); } - return (unsigned) -1; + return NULL; } ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn, ir_node *ctx) @@ -399,28 +429,33 @@ static void *put_in_reg_req(arch_register_req_t *req, const ir_node *irn, int po } static const arch_register_req_t * -be_node_get_irn_reg_req(const arch_irn_ops_t *self, arch_register_req_t *req, const ir_node *irn, int pos) +be_node_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_node *irn, int pos) { - int out_pos = redir_proj((const ir_node **) &irn, pos); + int out_pos = pos; - if(pos < 0 && get_irn_mode(irn) == mode_T) - return NULL; + if(pos < 0) { + if(get_irn_mode(irn) == mode_T) + return NULL; - if(!is_be_node(irn)) - return NULL; + out_pos = redir_proj((const ir_node **) &irn, pos); + assert(is_be_node(irn)); + return put_out_reg_req(req, irn, out_pos); + } - req = pos >= 0 ? put_in_reg_req(req, irn, pos) : put_out_reg_req(req, irn, out_pos); + else { + return is_be_node(irn) ? put_in_reg_req(req, irn, pos) : NULL; + } return req; } static void -be_node_set_irn_reg(const arch_irn_ops_t *_self, ir_node *irn, const arch_register_t *reg) +be_node_set_irn_reg(const void *_self, ir_node *irn, const arch_register_t *reg) { int out_pos; be_node_attr_t *a; - out_pos = redir_proj(&irn, -1); + out_pos = redir_proj((const ir_node **) &irn, -1); a = get_irn_attr(irn); assert(is_be_node(irn)); @@ -429,12 +464,12 @@ be_node_set_irn_reg(const arch_irn_ops_t *_self, ir_node *irn, const arch_regist } const arch_register_t * -be_node_get_irn_reg(const arch_irn_ops_t *_self, const ir_node *irn) +be_node_get_irn_reg(const void *_self, const ir_node *irn) { int out_pos; be_node_attr_t *a; - out_pos = redir_proj(&irn, -1); + out_pos = redir_proj((const ir_node **) &irn, -1); a = get_irn_attr(irn); assert(is_be_node(irn)); @@ -443,9 +478,9 @@ be_node_get_irn_reg(const arch_irn_ops_t *_self, const ir_node *irn) return a->reg_data[out_pos].reg; } -arch_irn_class_t be_node_classify(const arch_irn_ops_t *_self, const ir_node *irn) +arch_irn_class_t be_node_classify(const void *_self, const ir_node *irn) { - redir_proj(&irn, -1); + redir_proj((const ir_node **) &irn, -1); switch(get_irn_be_opcode(irn)) { #define XXX(a,b) case beo_ ## a: return arch_irn_class_ ## b; @@ -461,12 +496,12 @@ arch_irn_class_t be_node_classify(const arch_irn_ops_t *_self, const ir_node *ir return 0; } -arch_irn_class_t be_node_get_flags(const arch_irn_ops_t *_self, const ir_node *irn) +arch_irn_class_t be_node_get_flags(const void *_self, const ir_node *irn) { return 0; } -static const arch_irn_ops_t be_node_irn_ops = { +static const arch_irn_ops_if_t be_node_irn_ops_if = { be_node_get_irn_reg_req, be_node_set_irn_reg, be_node_get_irn_reg, @@ -474,7 +509,11 @@ static const arch_irn_ops_t be_node_irn_ops = { be_node_get_flags, }; -const arch_irn_ops_t *be_node_get_arch_ops(const arch_irn_handler_t *self, const ir_node *irn) +static const arch_irn_ops_t be_node_irn_ops = { + &be_node_irn_ops_if +}; + +const void *be_node_get_arch_ops(const arch_irn_handler_t *self, const ir_node *irn) { redir_proj((const ir_node **) &irn, -1); return is_be_node(irn) ? &be_node_irn_ops : NULL; @@ -501,6 +540,7 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) case dump_node_nodeattr_txt: break; case dump_node_info_txt: + fprintf(f, "reg class: %s\n", at->cls->name); for(i = 0; i < at->n_outs; ++i) { const arch_register_t *reg = at->reg_data[i].reg; fprintf(f, "reg #%d: %s\n", i, reg ? reg->name : "n/a"); @@ -508,8 +548,9 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) if(get_irn_be_opcode(irn) == beo_Spill) { be_spill_attr_t *a = (be_spill_attr_t *) at; + unsigned ofs = get_entity_offset_bytes(a->ent); ir_fprintf(f, "spill context: %+F\n", a->spill_ctx); - ir_fprintf(f, "spill offset: %u\n", a->offset); + ir_fprintf(f, "spill entity: %+F offset %x (%d)\n", a->ent, ofs, ofs); } break; } @@ -533,38 +574,29 @@ static const ir_op_ops be_node_op_ops = { NULL }; -ir_node *insert_Perm_after(const arch_env_t *arch_env, - const arch_register_class_t *cls, - dom_front_info_t *dom_front, - ir_node *pos) +pset *nodes_live_at(const arch_env_t *arch_env, const arch_register_class_t *cls, const ir_node *pos, pset *live) { - ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos); - ir_graph *irg = get_irn_irg(bl); - pset *live = pset_new_ptr_default(); - firm_dbg_module_t *dbg = firm_dbg_register("be.node"); - + firm_dbg_module_t *dbg = firm_dbg_register("firm.be.node"); + ir_node *bl = get_nodes_block(pos); + ir_node *irn; irn_live_t *li; - ir_node *curr, *irn, *perm, **nodes; - int i, n; - - DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos)); - live_foreach(bl, li) { ir_node *irn = (ir_node *) li->irn; - if(live_is_end(li) && arch_irn_has_reg_class(arch_env, irn, -1, cls)) + if(live_is_end(li) && arch_irn_consider_in_reg_alloc(arch_env, cls, irn)) pset_insert_ptr(live, irn); } sched_foreach_reverse(bl, irn) { + int i, n; ir_node *x; - /* - * If we encounter the node we want to insert the Perm after, - * exit immediately, so that this node is still live - */ + /* + * If we encounter the node we want to insert the Perm after, + * exit immediately, so that this node is still live + */ if(irn == pos) - break; + return live; DBG((dbg, LEVEL_1, "%+F\n", irn)); for(x = pset_first(live); x; x = pset_next(live)) @@ -576,12 +608,37 @@ ir_node *insert_Perm_after(const arch_env_t *arch_env, for(i = 0, n = get_irn_arity(irn); i < n; ++i) { ir_node *op = get_irn_n(irn, i); - if(arch_irn_has_reg_class(arch_env, op, -1, cls)) + if(arch_irn_consider_in_reg_alloc(arch_env, cls, op)) pset_insert_ptr(live, op); } } + return NULL; +} + +ir_node *insert_Perm_after(const arch_env_t *arch_env, + const arch_register_class_t *cls, + dom_front_info_t *dom_front, + ir_node *pos) +{ + ir_node *bl = is_Block(pos) ? pos : get_nodes_block(pos); + ir_graph *irg = get_irn_irg(bl); + pset *live = pset_new_ptr_default(); + firm_dbg_module_t *dbg = firm_dbg_register("be.node"); + + ir_node *curr, *irn, *perm, **nodes; + int i, n; + + DBG((dbg, LEVEL_1, "Insert Perm after: %+F\n", pos)); + + if(!nodes_live_at(arch_env, cls, pos, live)) + assert(0 && "position not found"); + n = pset_count(live); + + if(n == 0) + return NULL; + nodes = malloc(n * sizeof(nodes[0])); DBG((dbg, LEVEL_1, "live:\n"));