X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbenode.c;h=4e5a45aab1f625632c88fe814f9dc0011868b42b;hb=c4ff1c9959667db87996891435a12ae466563062;hp=95416e7d81d1bc94c471428eafc71c2231dd7f93;hpb=29681e70b073ec2ecf9d6dd8cd37f05439ada3cc;p=libfirm diff --git a/ir/be/benode.c b/ir/be/benode.c index 95416e7d8..4e5a45aab 100644 --- a/ir/be/benode.c +++ b/ir/be/benode.c @@ -7,7 +7,7 @@ * * This file provides Perm, Copy, Spill and Reload nodes. * - * Copyright (C) 2005 Universitaet Karlsruhe + * Copyright (C) 2005-2006 Universitaet Karlsruhe * Released under the GPL */ @@ -89,28 +89,27 @@ typedef struct { /** The be_Stack attribute type. */ typedef struct { be_node_attr_t node_attr; - int offset; /**< The offset by which the stack shall be increased/decreased. */ - be_stack_dir_t dir; /**< The direction in which the stack shall be modified (expand or shrink). */ + int offset; /**< The offset by which the stack shall be expanded/shrinked. */ } be_stack_attr_t; /** The be_Frame attribute type. */ typedef struct { be_node_attr_t node_attr; - entity *ent; + ir_entity *ent; int offset; } be_frame_attr_t; /** The be_Call attribute type. */ typedef struct { be_node_attr_t node_attr; - entity *ent; /**< The called entity if this is a static call. */ + ir_entity *ent; /**< The called entity if this is a static call. */ ir_type *call_tp; /**< The call type, copied from the original Call node. */ } be_call_attr_t; typedef struct { be_node_attr_t node_attr; - entity **in_entities; - entity **out_entities; + ir_entity **in_entities; + ir_entity **out_entities; } be_memperm_attr_t; ir_op *op_be_Spill; @@ -124,6 +123,7 @@ ir_op *op_be_Call; ir_op *op_be_Return; ir_op *op_be_IncSP; ir_op *op_be_AddSP; +ir_op *op_be_SubSP; ir_op *op_be_SetSP; ir_op *op_be_RegParams; ir_op *op_be_StackParam; @@ -201,9 +201,10 @@ void be_node_init(void) { op_be_Copy = new_ir_op(beo_base + beo_Copy, "be_Copy", op_pin_state_floats, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); op_be_Keep = new_ir_op(beo_base + beo_Keep, "be_Keep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); op_be_CopyKeep = new_ir_op(beo_base + beo_CopyKeep, "be_CopyKeep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_be_Call = new_ir_op(beo_base + beo_Call, "be_Call", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_call_attr_t), &be_node_op_ops); + op_be_Call = new_ir_op(beo_base + beo_Call, "be_Call", op_pin_state_pinned, F, oparity_variable, 0, sizeof(be_call_attr_t), &be_node_op_ops); op_be_Return = new_ir_op(beo_base + beo_Return, "be_Return", op_pin_state_pinned, X, oparity_variable, 0, sizeof(be_return_attr_t), &be_node_op_ops); op_be_AddSP = new_ir_op(beo_base + beo_AddSP, "be_AddSP", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_be_SubSP = new_ir_op(beo_base + beo_SubSP, "be_SubSP", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); op_be_SetSP = new_ir_op(beo_base + beo_SetSP, "be_SetSP", op_pin_state_pinned, N, oparity_binary, 0, sizeof(be_stack_attr_t), &be_node_op_ops); op_be_IncSP = new_ir_op(beo_base + beo_IncSP, "be_IncSP", op_pin_state_pinned, N, oparity_binary, 0, sizeof(be_stack_attr_t), &be_node_op_ops); op_be_RegParams = new_ir_op(beo_base + beo_RegParams, "be_RegParams", op_pin_state_pinned, N, oparity_zero, 0, sizeof(be_node_attr_t), &be_node_op_ops); @@ -223,6 +224,7 @@ void be_node_init(void) { set_op_tag(op_be_Call, &be_node_tag); set_op_tag(op_be_Return, &be_node_tag); set_op_tag(op_be_AddSP, &be_node_tag); + set_op_tag(op_be_SubSP, &be_node_tag); set_op_tag(op_be_SetSP, &be_node_tag); set_op_tag(op_be_IncSP, &be_node_tag); set_op_tag(op_be_RegParams, &be_node_tag); @@ -336,25 +338,27 @@ be_node_set_irn_reg(const void *_self, ir_node *irn, const arch_register_t *reg) } -ir_node *be_new_Spill(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *to_spill) +ir_node *be_new_Spill(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, + ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *to_spill) { be_frame_attr_t *a; - ir_node *in[2]; - ir_node *res; - - in[0] = frame; - in[1] = to_spill; - res = new_ir_node(NULL, irg, bl, op_be_Spill, mode_M, 2, in); - a = init_node_attr(res, 2); - a->ent = NULL; + ir_node *in[2]; + ir_node *res; + + in[0] = frame; + in[1] = to_spill; + res = new_ir_node(NULL, irg, bl, op_be_Spill, mode_M, 2, in); + a = init_node_attr(res, 2); + a->ent = NULL; a->offset = 0; - be_node_set_reg_class(res, 0, cls_frame); - be_node_set_reg_class(res, 1, cls); + be_node_set_reg_class(res, be_pos_Spill_frame, cls_frame); + be_node_set_reg_class(res, be_pos_Spill_val, cls); return res; } -ir_node *be_new_Reload(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *mem, ir_mode *mode) +ir_node *be_new_Reload(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, + ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *mem, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -362,9 +366,11 @@ ir_node *be_new_Reload(const arch_register_class_t *cls, const arch_register_cla in[0] = frame; in[1] = mem; res = new_ir_node(NULL, irg, bl, op_be_Reload, mode, 2, in); + init_node_attr(res, 2); - be_node_set_reg_class(res, 0, cls_frame); be_node_set_reg_class(res, -1, cls); + be_node_set_reg_class(res, be_pos_Reload_frame, cls_frame); + be_node_set_flags(res, -1, arch_irn_flags_rematerializable); return res; } @@ -380,6 +386,17 @@ ir_node *be_get_Reload_frame(const ir_node *irn) return get_irn_n(irn, be_pos_Reload_frame); } +ir_node *be_get_Spill_val(const ir_node *irn) +{ + assert(be_is_Spill(irn)); + return get_irn_n(irn, be_pos_Spill_val); +} +ir_node *be_get_Spill_frame(const ir_node *irn) +{ + assert(be_is_Spill(irn)); + return get_irn_n(irn, be_pos_Spill_frame); +} + ir_node *be_new_Perm(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int n, ir_node *in[]) { int i; @@ -484,14 +501,14 @@ ir_node *be_new_Call(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem, ir } /* Gets the call entity or NULL if this is no static call. */ -entity *be_Call_get_entity(const ir_node *call) { +ir_entity *be_Call_get_entity(const ir_node *call) { be_call_attr_t *a = get_irn_attr(call); assert(be_is_Call(call)); return a->ent; } /* Sets the call entity. */ -void be_Call_set_entity(ir_node *call, entity *ent) { +void be_Call_set_entity(ir_node *call, ir_entity *ent) { be_call_attr_t *a = get_irn_attr(call); assert(be_is_Call(call)); a->ent = ent; @@ -530,17 +547,15 @@ int be_Return_get_n_rets(ir_node *ret) return a->num_ret_vals; } -ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *mem, unsigned offset, be_stack_dir_t dir) +ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, int offset) { be_stack_attr_t *a; ir_node *irn; - ir_node *in[2]; + ir_node *in[1]; in[0] = old_sp; - in[1] = mem; - irn = new_ir_node(NULL, irg, bl, op_be_IncSP, sp->reg_class->mode, 2, in); + irn = new_ir_node(NULL, irg, bl, op_be_IncSP, sp->reg_class->mode, sizeof(in) / sizeof(in[0]), in); a = init_node_attr(irn, 1); - a->dir = dir; a->offset = offset; be_node_set_flags(irn, -1, arch_irn_flags_ignore | arch_irn_flags_modify_sp); @@ -576,6 +591,29 @@ ir_node *be_new_AddSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_ return irn; } +ir_node *be_new_SubSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *sz) +{ + be_node_attr_t *a; + ir_node *irn; + ir_node *in[be_pos_SubSP_last]; + + in[be_pos_SubSP_old_sp] = old_sp; + in[be_pos_SubSP_size] = sz; + + irn = new_ir_node(NULL, irg, bl, op_be_SubSP, mode_T, be_pos_SubSP_last, in); + a = init_node_attr(irn, be_pos_SubSP_last); + + be_node_set_flags(irn, OUT_POS(pn_be_SubSP_res), arch_irn_flags_ignore | arch_irn_flags_modify_sp); + + /* Set output constraint to stack register. */ + be_set_constr_single_reg(irn, be_pos_SubSP_old_sp, sp); + be_node_set_reg_class(irn, be_pos_SubSP_size, arch_register_get_class(sp)); + be_set_constr_single_reg(irn, OUT_POS(pn_be_SubSP_res), sp); + a->reg_data[pn_be_SubSP_res].reg = sp; + + return irn; +} + ir_node *be_new_SetSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *op, ir_node *mem) { be_node_attr_t *a; @@ -592,14 +630,13 @@ ir_node *be_new_SetSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_ /* Set output constraint to stack register. */ be_set_constr_single_reg(irn, OUT_POS(0), sp); - be_node_set_reg_class(irn, 1, sp->reg_class); - be_node_set_reg_class(irn, 2, sp->reg_class); - be_node_set_irn_reg(NULL, irn, sp); + be_node_set_reg_class(irn, be_pos_AddSP_size, sp->reg_class); + be_node_set_reg_class(irn, be_pos_AddSP_old_sp, sp->reg_class); return irn; } -ir_node *be_new_StackParam(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, entity *ent) +ir_node *be_new_StackParam(const arch_register_class_t *cls, const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, ir_entity *ent) { be_frame_attr_t *a; ir_node *irn; @@ -626,7 +663,7 @@ ir_node *be_new_RegParams(ir_graph *irg, ir_node *bl, int n_outs) } ir_node *be_new_FrameLoad(const arch_register_class_t *cls_frame, const arch_register_class_t *cls_data, - ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, entity *ent) + ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_entity *ent) { be_frame_attr_t *a; ir_node *irn; @@ -644,7 +681,7 @@ ir_node *be_new_FrameLoad(const arch_register_class_t *cls_frame, const arch_reg } ir_node *be_new_FrameStore(const arch_register_class_t *cls_frame, const arch_register_class_t *cls_data, - ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_node *data, entity *ent) + ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *frame, ir_node *data, ir_entity *ent) { be_frame_attr_t *a; ir_node *irn; @@ -662,7 +699,7 @@ ir_node *be_new_FrameStore(const arch_register_class_t *cls_frame, const arch_re return irn; } -ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, entity *ent) +ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_entity *ent) { be_frame_attr_t *a; ir_node *irn; @@ -753,26 +790,26 @@ int be_has_frame_entity(const ir_node *irn) } } -entity *be_get_frame_entity(const ir_node *irn) +ir_entity *be_get_frame_entity(const ir_node *irn) { - if(be_has_frame_entity(irn)) { + if (be_has_frame_entity(irn)) { be_frame_attr_t *a = get_irn_attr(irn); return a->ent; } return NULL; } -void be_set_frame_entity(const ir_node *irn, entity* ent) +int be_get_frame_offset(const ir_node *irn) { - be_frame_attr_t *a; - - assert(be_has_frame_entity(irn)); - - a = get_irn_attr(irn); - a->ent = ent; + assert(is_be_node(irn)); + if (be_has_frame_entity(irn)) { + be_frame_attr_t *a = get_irn_attr(irn); + return a->offset; + } + return 0; } -void be_set_MemPerm_in_entity(const ir_node *irn, int n, entity *ent) +void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity *ent) { be_memperm_attr_t *attr = get_irn_attr(irn); @@ -782,7 +819,7 @@ void be_set_MemPerm_in_entity(const ir_node *irn, int n, entity *ent) attr->in_entities[n] = ent; } -entity* be_get_MemPerm_in_entity(const ir_node* irn, int n) +ir_entity* be_get_MemPerm_in_entity(const ir_node* irn, int n) { be_memperm_attr_t *attr = get_irn_attr(irn); @@ -792,7 +829,7 @@ entity* be_get_MemPerm_in_entity(const ir_node* irn, int n) return attr->in_entities[n]; } -void be_set_MemPerm_out_entity(const ir_node *irn, int n, entity *ent) +void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity *ent) { be_memperm_attr_t *attr = get_irn_attr(irn); @@ -802,7 +839,7 @@ void be_set_MemPerm_out_entity(const ir_node *irn, int n, entity *ent) attr->out_entities[n] = ent; } -entity* be_get_MemPerm_out_entity(const ir_node* irn, int n) +ir_entity* be_get_MemPerm_out_entity(const ir_node* irn, int n) { be_memperm_attr_t *attr = get_irn_attr(irn); @@ -886,8 +923,12 @@ void be_node_set_flags(ir_node *irn, int pos, arch_irn_flags_t flags) void be_node_set_reg_class(ir_node *irn, int pos, const arch_register_class_t *cls) { be_req_t *r = get_req(irn, pos); + r->req.cls = cls; - if(r->req.type == arch_register_req_type_none) + + if (cls == NULL) + r->req.type = arch_register_req_type_none; + else if (r->req.type == arch_register_req_type_none) r->req.type = arch_register_req_type_normal; } @@ -912,43 +953,28 @@ ir_node *be_get_IncSP_mem(ir_node *irn) { return get_irn_n(irn, 1); } -void be_set_IncSP_offset(ir_node *irn, unsigned offset) +void be_set_IncSP_offset(ir_node *irn, int offset) { be_stack_attr_t *a = get_irn_attr(irn); assert(be_is_IncSP(irn)); a->offset = offset; } -unsigned be_get_IncSP_offset(const ir_node *irn) +int be_get_IncSP_offset(const ir_node *irn) { be_stack_attr_t *a = get_irn_attr(irn); assert(be_is_IncSP(irn)); return a->offset; } -void be_set_IncSP_direction(ir_node *irn, be_stack_dir_t dir) -{ - be_stack_attr_t *a = get_irn_attr(irn); - assert(be_is_IncSP(irn)); - a->dir = dir; -} - -be_stack_dir_t be_get_IncSP_direction(const ir_node *irn) -{ - be_stack_attr_t *a = get_irn_attr(irn); - assert(be_is_IncSP(irn)); - return a->dir; -} - ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn) { - ir_node *bl = get_nodes_block(irn); - ir_graph *irg = get_irn_irg(bl); - ir_node *frame = get_irg_frame(irg); - ir_node *spill; - + ir_node *bl = get_nodes_block(irn); + ir_graph *irg = get_irn_irg(bl); + ir_node *frame = get_irg_frame(irg); const arch_register_class_t *cls = arch_get_irn_reg_class(arch_env, irn, -1); const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1); + ir_node *spill; spill = be_new_Spill(cls, cls_frame, irg, bl, frame, irn); return spill; @@ -956,18 +982,17 @@ ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn) ir_node *be_reload(const arch_env_t *arch_env, 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_irn_irg(bl); - ir_node *frame = get_irg_frame(irg); + ir_node *reload; + ir_node *bl = is_Block(insert) ? insert : get_nodes_block(insert); + ir_graph *irg = get_irn_irg(bl); + ir_node *frame = get_irg_frame(irg); const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1); assert(be_is_Spill(spill) || (is_Phi(spill) && get_irn_mode(spill) == mode_M)); reload = be_new_Reload(cls, cls_frame, irg, bl, frame, spill, mode); - if(is_Block(insert)) { + if (is_Block(insert)) { insert = sched_skip(insert, 0, sched_skip_cf_predicator, (void *) arch_env); sched_add_after(insert, reload); } @@ -1028,17 +1053,29 @@ be_node_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_nod { int out_pos = pos; - if(pos < 0) { - if(get_irn_mode(irn) == mode_T) + if (pos < 0) { + if (get_irn_mode(irn) == mode_T) return NULL; - out_pos = redir_proj((const ir_node **) &irn, pos); + out_pos = redir_proj((const ir_node **)&irn, pos); assert(is_be_node(irn)); return put_out_reg_req(req, irn, out_pos); } else { - return is_be_node(irn) ? put_in_reg_req(req, irn, pos) : NULL; + if (is_be_node(irn)) { + /* + For spills and reloads, we return "none" as requirement for frame pointer, + so every input is ok. Some backends need this (e.g. STA). We use an arbitrary + large number as pos, so put_in_reg_req will return "none" as requirement. + */ + if ((be_is_Spill(irn) && pos == be_pos_Spill_frame) || + (be_is_Reload(irn) && pos == be_pos_Reload_frame)) + return put_in_reg_req(req, irn, INT_MAX); + else + return put_in_reg_req(req, irn, pos); + } + return NULL; } return req; @@ -1065,7 +1102,7 @@ static arch_irn_class_t be_node_classify(const void *_self, const ir_node *irn) XXX(StackParam, stackparam); #undef XXX default: - return 0; + return arch_irn_class_normal; } return 0; @@ -1077,11 +1114,21 @@ static arch_irn_flags_t be_node_get_flags(const void *_self, const ir_node *irn) return r ? r->req.flags : 0; } -static entity *be_node_get_frame_entity(const void *self, const ir_node *irn) +static ir_entity *be_node_get_frame_entity(const void *self, const ir_node *irn) { return be_get_frame_entity(irn); } +static void be_node_set_frame_entity(const void *self, ir_node *irn, ir_entity *ent) +{ + be_frame_attr_t *a; + + assert(be_has_frame_entity(irn)); + + a = get_irn_attr(irn); + a->ent = ent; +} + static void be_node_set_frame_offset(const void *self, ir_node *irn, int offset) { if(be_has_frame_entity(irn)) { @@ -1090,6 +1137,11 @@ static void be_node_set_frame_offset(const void *self, ir_node *irn, int offset) } } +static int be_node_get_sp_bias(const void *self, const ir_node *irn) +{ + return be_is_IncSP(irn) ? be_get_IncSP_offset(irn) : 0; +} + /* ___ ____ _ _ _ _ _ _ |_ _| _ \| \ | | | | | | __ _ _ __ __| | | ___ _ __ @@ -1106,7 +1158,13 @@ static const arch_irn_ops_if_t be_node_irn_ops_if = { be_node_classify, be_node_get_flags, be_node_get_frame_entity, - be_node_set_frame_offset + be_node_set_frame_entity, + be_node_set_frame_offset, + be_node_get_sp_bias, + NULL, /* get_inverse */ + NULL, /* get_op_estimated_cost */ + NULL, /* possible_memory_operand */ + NULL, /* perform_memory_operand */ }; static const arch_irn_ops_t be_node_irn_ops = { @@ -1221,15 +1279,24 @@ static arch_irn_flags_t phi_get_flags(const void *_self, const ir_node *irn) return arch_irn_flags_none; } -static entity *phi_get_frame_entity(const void *_self, const ir_node *irn) +static ir_entity *phi_get_frame_entity(const void *_self, const ir_node *irn) { return NULL; } +static void phi_set_frame_entity(const void *_self, ir_node *irn, ir_entity *ent) +{ +} + static void phi_set_frame_offset(const void *_self, ir_node *irn, int bias) { } +static int phi_get_sp_bias(const void* self, const ir_node *irn) +{ + return 0; +} + static const arch_irn_ops_if_t phi_irn_ops = { phi_get_irn_reg_req, phi_set_irn_reg, @@ -1237,7 +1304,13 @@ static const arch_irn_ops_if_t phi_irn_ops = { phi_classify, phi_get_flags, phi_get_frame_entity, - phi_set_frame_offset + phi_set_frame_entity, + phi_set_frame_offset, + phi_get_sp_bias, + NULL, /* get_inverse */ + NULL, /* get_op_estimated_cost */ + NULL, /* possible_memory_operand */ + NULL, /* perform_memory_operand */ }; static const arch_irn_handler_t phi_irn_handler = { @@ -1383,11 +1456,12 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) case beo_IncSP: { be_stack_attr_t *a = (be_stack_attr_t *) at; - if (a->offset == BE_STACK_FRAME_SIZE) + if (a->offset == BE_STACK_FRAME_SIZE_EXPAND) fprintf(f, "offset: FRAME_SIZE\n"); + else if(a->offset == BE_STACK_FRAME_SIZE_SHRINK) + fprintf(f, "offset: -FRAME SIZE\n"); else fprintf(f, "offset: %u\n", a->offset); - fprintf(f, "direction: %s\n", a->dir == be_stack_dir_expand ? "expand" : "shrink"); } break; case beo_Call: @@ -1402,7 +1476,7 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) { int i; for(i = 0; i < be_get_MemPerm_entity_arity(irn); ++i) { - entity *in, *out; + ir_entity *in, *out; in = be_get_MemPerm_in_entity(irn, i); out = be_get_MemPerm_out_entity(irn, i); if(in) {