X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbenode.c;h=49e64e1e3d1ce7c23dc7af156bb7d40578c25316;hb=36e688467f3e9fed2b96e2d7f323edffa4268b53;hp=3d7c28557d7ea1f411d88e170d2feb03da4203c4;hpb=6b45fde8adadc605dfe4c3a181c7fd8f78ac227c;p=libfirm diff --git a/ir/be/benode.c b/ir/be/benode.c index 3d7c28557..49e64e1e3 100644 --- a/ir/be/benode.c +++ b/ir/be/benode.c @@ -283,7 +283,7 @@ ir_node *be_new_Spill(const arch_register_class_t *cls, */ be_set_constr_in(res, n_be_Spill_frame, arch_no_register_req); - arch_set_out_register_req(res, 0, arch_no_register_req); + arch_set_irn_register_req_out(res, 0, arch_no_register_req); return res; } @@ -305,7 +305,7 @@ ir_node *be_new_Reload(const arch_register_class_t *cls, be_node_set_reg_class_out(res, 0, cls); be_node_set_reg_class_in(res, n_be_Reload_frame, cls_frame); - arch_irn_set_flags(res, arch_irn_flags_rematerializable); + arch_set_irn_flags(res, arch_irn_flags_rematerializable); a = (be_frame_attr_t*) get_irn_generic_attr(res); a->ent = NULL; @@ -422,13 +422,15 @@ ir_node *be_new_MemPerm(ir_node *block, int n, ir_node *in[]) return irn; } -ir_node *be_new_Copy(const arch_register_class_t *cls, ir_node *bl, ir_node *op) +ir_node *be_new_Copy(ir_node *bl, ir_node *op) { ir_node *in[1]; ir_node *res; arch_register_req_t *req; be_node_attr_t *attr; ir_graph *irg = get_Block_irg(bl); + const arch_register_req_t *in_req = arch_get_irn_register_req(op); + const arch_register_class_t *cls = in_req->cls; in[0] = op; res = new_ir_node(NULL, irg, bl, op_be_Copy, get_irn_mode(op), 1, in); @@ -440,9 +442,10 @@ ir_node *be_new_Copy(const arch_register_class_t *cls, ir_node *bl, ir_node *op) req = allocate_reg_req(res); req->cls = cls; - req->type = arch_register_req_type_should_be_same; + req->type = arch_register_req_type_should_be_same + | (in_req->type & arch_register_req_type_aligned); req->other_same = 1U << 0; - req->width = 1; + req->width = in_req->width; be_set_constr_out(res, 0, req); return res; @@ -656,7 +659,7 @@ ir_node *be_new_AddSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, /* Set output constraint to stack register. */ be_set_constr_single_reg_in(irn, n_be_AddSP_old_sp, sp, arch_register_req_type_none); - be_node_set_reg_class_in(irn, n_be_AddSP_size, arch_register_get_class(sp)); + be_node_set_reg_class_in(irn, n_be_AddSP_size, sp->reg_class); be_set_constr_single_reg_out(irn, pn_be_AddSP_sp, sp, arch_register_req_type_produces_sp); @@ -682,7 +685,7 @@ ir_node *be_new_SubSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, i /* Set output constraint to stack register. */ be_set_constr_single_reg_in(irn, n_be_SubSP_old_sp, sp, arch_register_req_type_none); - be_node_set_reg_class_in(irn, n_be_SubSP_size, arch_register_get_class(sp)); + be_node_set_reg_class_in(irn, n_be_SubSP_size, sp->reg_class); be_set_constr_single_reg_out(irn, pn_be_SubSP_sp, sp, arch_register_req_type_produces_sp); return irn; @@ -738,11 +741,14 @@ ir_entity *be_get_FrameAddr_entity(const ir_node *node) return attr->ent; } -ir_node *be_new_CopyKeep(const arch_register_class_t *cls, ir_node *bl, ir_node *src, int n, ir_node *in_keep[], ir_mode *mode) +ir_node *be_new_CopyKeep(ir_node *bl, ir_node *src, int n, ir_node *in_keep[]) { ir_node *irn; ir_node **in = ALLOCAN(ir_node*, n + 1); ir_graph *irg = get_Block_irg(bl); + const arch_register_req_t *req = arch_get_irn_register_req(src); + const arch_register_class_t *cls = req->cls; + ir_mode *mode = get_irn_mode(src); be_node_attr_t *attr; in[0] = src; @@ -757,9 +763,9 @@ ir_node *be_new_CopyKeep(const arch_register_class_t *cls, ir_node *bl, ir_node return irn; } -ir_node *be_new_CopyKeep_single(const arch_register_class_t *cls, ir_node *bl, ir_node *src, ir_node *keep, ir_mode *mode) +ir_node *be_new_CopyKeep_single(ir_node *bl, ir_node *src, ir_node *keep) { - return be_new_CopyKeep(cls, bl, src, 1, &keep, mode); + return be_new_CopyKeep(bl, src, 1, &keep); } ir_node *be_get_CopyKeep_op(const ir_node *cpy) @@ -895,12 +901,11 @@ void be_set_constr_single_reg_out(ir_node *node, int pos, if (additional_types == 0) { req = reg->single_req; } else { - ir_graph *irg = get_irn_irg(node); struct obstack *obst = be_get_be_obst(irg); req = be_create_reg_req(obst, reg, additional_types); } - arch_irn_set_register(node, pos, reg); + arch_set_irn_register_out(node, pos, reg); be_set_constr_out(node, pos, req); } @@ -949,43 +954,6 @@ int be_get_IncSP_align(const ir_node *irn) return a->align; } -ir_node *be_spill(ir_node *block, ir_node *irn) -{ - ir_graph *irg = get_Block_irg(block); - ir_node *frame = get_irg_frame(irg); - const arch_register_class_t *cls = arch_get_irn_reg_class_out(irn); - const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame); - ir_node *spill; - - spill = be_new_Spill(cls, cls_frame, block, frame, irn); - return spill; -} - -ir_node *be_reload(const arch_register_class_t *cls, ir_node *insert, ir_mode *mode, ir_node *spill) -{ - ir_node *reload; - ir_node *bl = is_Block(insert) ? insert : get_nodes_block(insert); - ir_graph *irg = get_Block_irg(bl); - ir_node *frame = get_irg_frame(irg); - const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame); - - assert(be_is_Spill(spill) || (is_Phi(spill) && get_irn_mode(spill) == mode_M)); - - reload = be_new_Reload(cls, cls_frame, bl, frame, spill, mode); - - if (is_Block(insert)) { - do { - insert = sched_prev(insert); - } while (is_cfop(insert)); - sched_add_after(insert, reload); - } else { - sched_add_before(insert, reload); - } - - return reload; -} - - static arch_irn_class_t be_node_classify(const ir_node *irn) { switch (get_irn_opcode(irn)) { @@ -1050,13 +1018,13 @@ static const arch_irn_ops_t be_node_irn_ops = { static int get_start_reg_index(ir_graph *irg, const arch_register_t *reg) { ir_node *start = get_irg_start(irg); - unsigned n_outs = arch_irn_get_n_outs(start); + unsigned n_outs = arch_get_irn_n_outs(start); int i; /* do a naive linear search... */ for (i = 0; i < (int)n_outs; ++i) { const arch_register_req_t *out_req - = arch_get_out_register_req(start, i); + = arch_get_irn_register_req_out(start, i); if (! (out_req->type & arch_register_req_type_limited)) continue; if (out_req->cls != arch_register_get_class(reg)) @@ -1092,7 +1060,7 @@ int be_find_return_reg_input(ir_node *ret, const arch_register_t *reg) int i; /* do a naive linear search... */ for (i = 0; i < arity; ++i) { - const arch_register_req_t *req = arch_get_in_register_req(ret, i); + const arch_register_req_t *req = arch_get_irn_register_req_in(ret, i); if (! (req->type & arch_register_req_type_limited)) continue; if (req->cls != arch_register_get_class(reg))