From: Sebastian Hack Date: Thu, 23 Feb 2006 14:48:02 +0000 (+0000) Subject: Fixed some bugs X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=93587aaef8b19becb0c79f6c332238bcae3db1da;p=libfirm Fixed some bugs --- diff --git a/ir/be/beabi.c b/ir/be/beabi.c index d9a714240..08901297f 100644 --- a/ir/be/beabi.c +++ b/ir/be/beabi.c @@ -338,7 +338,6 @@ static void adjust_call_walker(ir_node *irn, void *data) adjust_call(data, irn); } -#if 0 /** * Walker to implement alloca-style allocations. * They are implemented using an add to the stack pointer @@ -358,7 +357,7 @@ static void implement_stack_alloc(be_abi_irg_t *env, ir_node *irn) res = be_new_Copy(isa->sp->reg_class, env->birg->irg, bl, res); res = be_new_AddSP(isa->sp, env->birg->irg, bl, res, size); - pset_insert_ptr(env->stack_ops); + pset_insert_ptr(env->stack_ops, res); if(isa->stack_dir < 0) res = be_new_Copy(isa->sp->reg_class, env->birg->irg, bl, res); @@ -388,7 +387,7 @@ static void modify_irg(be_abi_irg_t *env) ir_node *frame_pointer; ir_node *reg_params, *reg_params_bl; ir_node **args, **args_repl, **return_params; - ir_edge_t *edge; + const ir_edge_t *edge; /* Find the maximum proj number of the argument tuple proj */ @@ -445,11 +444,10 @@ static void modify_irg(be_abi_irg_t *env) return_params = obstack_finish(&env->obst); } - /* If we can omit the framepointer, the stack pointer will become the frame pointer */ - frame_pointer = be_new_IncSP(sp, irg, reg_params_bl, proj_sp, 0); - /* memorize this node for later fixup */ - if(!env->omit_framepointer) - frame_pointer = be_new_Copy(sp->reg_class, irg, reg_params_bl, proj_sp); + /* If we can omit the frame pointer, the stack pointer will become the frame pointer */ + env->init_sp = be_new_IncSP(sp, irg, reg_params_bl, proj_sp, 0, be_stack_dir_along); + /* memorize this node for later fix up */ + frame_pointer = env->omit_framepointer ? env->init_sp : be_new_Copy(sp->reg_class, irg, reg_params_bl, proj_sp); set_irg_frame(irg, frame_pointer); /* reroute the edges from the original argument projs to the RegParam ones. */ @@ -482,8 +480,9 @@ static void modify_irg(be_abi_irg_t *env) node representing the load of that parameter */ else if(is_Primitive_type(param_type)) { ir_mode *mode = get_type_mode(param_type); - const arch_register_class_t *cls = arch_isa_get_reg_class_for_mode(env->isa, mode); - args_repl[i] = be_new_StackParam(irg, cls, frame_pointer, XXX_offset); + const arch_register_class_t *cls = arch_isa_get_reg_class_for_mode(isa, mode); + // TODO: Correct offset computation! + args_repl[i] = be_new_StackParam(cls, irg, reg_params_bl, mode, frame_pointer, 0); } /* The stack parameter is not primitive (it is a struct or array), @@ -498,7 +497,6 @@ static void modify_irg(be_abi_irg_t *env) obstack_free(&env->obst, args); be_abi_call_free(call); } -#endif static void collect_alloca_walker(ir_node *irn, void *data) { @@ -511,6 +509,7 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) { be_abi_irg_t *env = malloc(sizeof(env[0])); + int i; ir_node **stack_allocs; env->birg = birg; @@ -523,16 +522,14 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) obstack_ptr_grow(&env->obst, NULL); stack_allocs = obstack_finish(&env->obst); - /* If there are stack allocations in the irg, we need a framepointer */ + /* If there are stack allocations in the irg, we need a frame pointer */ if(stack_allocs[0] != NULL) env->omit_framepointer = 0; -#if 0 - modify_irg(&env); + modify_irg(env); for(i = 0; stack_allocs[i] != NULL; ++i) - implement_stack_alloc(&env, stack_allocs[i]); -#endif + implement_stack_alloc(env, stack_allocs[i]); irg_walk_graph(env->birg->irg, NULL, adjust_call_walker, &env); return env; diff --git a/ir/be/benode.c b/ir/be/benode.c index 884970b9b..b87dcfd6c 100644 --- a/ir/be/benode.c +++ b/ir/be/benode.c @@ -85,7 +85,7 @@ typedef struct { } be_reg_data_t; typedef struct { - int n_outs; + int max_reg_data; arch_irn_flags_t flags; const arch_register_class_t *cls; be_reg_data_t *reg_data; @@ -151,7 +151,7 @@ void be_node_init(void) { op_AddSP = new_ir_op(beo_base + beo_Keep, "AddSP", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_stack_attr_t), &be_node_op_ops); op_IncSP = new_ir_op(beo_base + beo_Keep, "IncSP", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_stack_attr_t), &be_node_op_ops); op_RegParams = new_ir_op(beo_base + beo_Keep, "RegParams", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_StackParam = new_ir_op(beo_base + beo_Keep, "StackParam", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_StackParam = new_ir_op(beo_base + beo_Keep, "StackParam", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_stack_attr_t), &be_node_op_ops); set_op_tag(op_Spill, &be_node_tag); set_op_tag(op_Reload, &be_node_tag); @@ -166,21 +166,21 @@ void be_node_init(void) { set_op_tag(op_StackParam, &be_node_tag); } -static void *init_node_attr(ir_node* irn, const arch_register_class_t *cls, ir_graph *irg, int n_outs) +static void *init_node_attr(ir_node* irn, const arch_register_class_t *cls, ir_graph *irg, int max_reg_data) { be_node_attr_t *a = get_irn_attr(irn); - a->n_outs = n_outs; - a->flags = arch_irn_flags_none; - a->cls = cls; - a->reg_data = NULL; + a->max_reg_data = max_reg_data; + a->flags = arch_irn_flags_none; + a->cls = cls; + a->reg_data = NULL; - if(n_outs > 0) { + if(max_reg_data > 0) { int i; - 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 = NEW_ARR_D(be_reg_data_t, get_irg_obstack(irg), max_reg_data); + memset(a->reg_data, 0, max_reg_data * sizeof(a->reg_data[0])); + for(i = 0; i < max_reg_data; ++i) { a->reg_data[i].req.req.cls = cls; a->reg_data[i].req.req.type = arch_register_req_type_normal; } @@ -222,7 +222,7 @@ be_node_set_irn_reg(const void *_self, ir_node *irn, const arch_register_t *reg) a = get_irn_attr(irn); assert(is_be_node(irn)); - assert(out_pos < a->n_outs && "position too high"); + assert(out_pos < a->max_reg_data && "position too high"); a->reg_data[out_pos].reg = reg; } @@ -294,7 +294,7 @@ ir_node *be_new_Call(ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_n memcpy(&real_in[3], in, n * sizeof(in[0])); irn = new_ir_node(NULL, irg, bl, op_Call, mode_T, real_n, real_in); - init_node_attr(irn, NULL, irg, n_outs); + init_node_attr(irn, NULL, irg, (n_outs > real_n ? n_outs : real_n)); return irn; } @@ -352,6 +352,19 @@ ir_node *be_new_NoReg(const arch_register_t *reg, ir_graph *irg, ir_node *bl) return irn; } +ir_node *be_new_StackParam(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, unsigned offset) +{ + be_stack_attr_t *a; + ir_node *irn; + ir_node *in[1]; + + in[0] = frame_pointer; + irn = new_ir_node(NULL, irg, bl, op_StackParam, mode, 1, in); + a = init_node_attr(irn, cls, irg, 1); + a->offset = offset; + return irn; +} + int be_is_Spill (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Spill ; } int be_is_Reload (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Reload ; } int be_is_Copy (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Copy ; } @@ -391,7 +404,7 @@ void be_set_constr_single_reg(ir_node *irn, int pos, const arch_register_t *reg) assert(is_be_node(irn)); assert(!(pos >= 0) || pos < get_irn_arity(irn)); - assert(!(pos < 0) || -(pos + 1) <= a->n_outs); + assert(!(pos < 0) || -(pos + 1) <= a->max_reg_data); r->kind = be_req_kind_single_reg; r->x.single_reg = reg; @@ -410,7 +423,7 @@ void be_set_constr_limited(ir_node *irn, int pos, const arch_register_req_t *req assert(is_be_node(irn)); assert(!(pos >= 0) || pos < get_irn_arity(irn)); - assert(!(pos < 0) || -(pos + 1) <= a->n_outs); + assert(!(pos < 0) || -(pos + 1) <= a->max_reg_data); assert(arch_register_req_is(req, limited)); r->kind = be_req_kind_old_limited; @@ -564,7 +577,7 @@ static void *put_out_reg_req(arch_register_req_t *req, const ir_node *irn, int o { const be_node_attr_t *a = get_irn_attr(irn); - if(out_pos < a->n_outs) + if(out_pos < a->max_reg_data) memcpy(req, &a->reg_data[out_pos].req, sizeof(req[0])); else { req->type = arch_register_req_type_none; @@ -620,7 +633,7 @@ be_node_get_irn_reg(const void *_self, const ir_node *irn) a = get_irn_attr(irn); assert(is_be_node(irn)); - assert(out_pos < a->n_outs && "position too high"); + assert(out_pos < a->max_reg_data && "position too high"); return a->reg_data[out_pos].reg; } @@ -689,7 +702,7 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) break; case dump_node_info_txt: fprintf(f, "reg class: %s\n", at->cls->name); - for(i = 0; i < at->n_outs; ++i) { + for(i = 0; i < at->max_reg_data; ++i) { const arch_register_t *reg = at->reg_data[i].reg; fprintf(f, "reg #%d: %s\n", i, reg ? reg->name : "n/a"); } @@ -724,13 +737,27 @@ static int dump_node(ir_node *irn, FILE *f, dump_reason_t reason) return 0; } +void copy_attr(const ir_node *old_node, ir_node *new_node) +{ + be_node_attr_t *old_attr = get_irn_attr(old_attr); + be_node_attr_t *new_attr = get_irn_attr(new_node); + + assert(is_be_node(old_node)); + assert(is_be_node(new_node)); + + memcpy(new_attr, old_attr, old_node->op->attr_size); + + new_attr->reg_data = NEW_ARR_D(be_reg_data_t, get_irg_obstack(get_irn_irg(new_node)), new_attr->max_reg_data); + memcpy(new_attr->reg_data, old_attr->reg_data, new_attr->max_reg_data * sizeof(be_reg_data_t)); +} + static const ir_op_ops be_node_op_ops = { NULL, NULL, NULL, NULL, NULL, - NULL, + copy_attr, NULL, NULL, NULL, diff --git a/ir/be/benode_t.h b/ir/be/benode_t.h index d2d8f56fd..fa078f47b 100644 --- a/ir/be/benode_t.h +++ b/ir/be/benode_t.h @@ -76,7 +76,7 @@ void be_set_IncSP_direction(ir_node *irn, be_stack_dir_t dir); be_stack_dir_t be_get_IncSP_direction(ir_node *irn); ir_node *be_new_Call(ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_node *ptr, int n_outs, int n, ir_node *in[]); -ir_node *be_new_StackParam(ir_graph *irg); +ir_node *be_new_StackParam(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_mode *mode, ir_node *frame_pointer, unsigned offset); ir_node *be_new_RegParams(ir_graph *irg, int n_out); ir_node *be_new_NoReg(const arch_register_t *reg, ir_graph *irg, ir_node *bl);