X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=d8dafd90a5284baa7b207c227d95e2bf9e3a4ed7;hb=964aebaae5f9bf41d57592e1cfdc878410c6297e;hp=ac788c4a4c20ebcd00d781a964dc26ad54fe431e;hpb=90fdd7fbc3366139584adecc65c3efe3b5f9fa27;p=libfirm diff --git a/ir/be/beabi.c b/ir/be/beabi.c index ac788c4a4..d8dafd90a 100644 --- a/ir/be/beabi.c +++ b/ir/be/beabi.c @@ -108,14 +108,13 @@ struct _be_abi_irg_t { arch_register_req_t sp_req; arch_register_req_t sp_cls_req; - DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */ + DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */ }; static heights_t *ir_heights; /* Flag: if set, try to omit the frame pointer if called by the backend */ static int be_omit_fp = 1; -static int be_pic = 0; /* _ ____ ___ ____ _ _ _ _ @@ -271,7 +270,8 @@ static void be_abi_call_free(be_abi_call_t *call) and the spills. */ -static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent, int bias) +static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent, + int bias) { ir_type *t = get_entity_owner(ent); int ofs = get_entity_offset(ent); @@ -409,7 +409,7 @@ static INLINE int is_on_stack(be_abi_call_t *call, int pos) static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) { ir_graph *irg = env->birg->irg; - const arch_env_t *arch_env = env->birg->main_env->arch_env; + const arch_env_t *arch_env = &env->birg->main_env->arch_env; const arch_isa_t *isa = arch_env->isa; ir_type *call_tp = get_Call_type(irn); ir_node *call_ptr = get_Call_ptr(irn); @@ -427,6 +427,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) struct obstack *obst = &env->obst; int no_alloc = call->flags.bits.frame_is_setup_on_call; int n_res = get_method_n_ress(call_tp); + int do_seq = call->flags.bits.store_args_sequential && !no_alloc; ir_node *res_proj = NULL; int n_reg_params = 0; @@ -473,10 +474,22 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) } reg_param_idxs = obstack_finish(obst); + /* + * If the stack is decreasing and we do not want to store sequentially, + * or someone else allocated the call frame + * we allocate as much space on the stack all parameters need, by + * moving the stack pointer along the stack's direction. + * + * Note: we also have to do this for stack_size == 0, because we may have + * to adjust stack alignment for the call. + */ + if (stack_dir < 0 && !do_seq && !no_alloc) { + curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size, 1); + } + /* If there are some parameters which shall be passed on the stack. */ if (n_stack_params > 0) { int curr_ofs = 0; - int do_seq = call->flags.bits.store_args_sequential && !no_alloc; /* * Reverse list of stack parameters if call arguments are from left to right. @@ -492,16 +505,6 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) } } - /* - * If the stack is decreasing and we do not want to store sequentially, - * or someone else allocated the call frame - * we allocate as much space on the stack all parameters need, by - * moving the stack pointer along the stack's direction. - */ - if (stack_dir < 0 && !do_seq && !no_alloc) { - curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size); - } - curr_mem = get_Call_mem(irn); if (! do_seq) { obstack_ptr_grow(obst, curr_mem); @@ -523,7 +526,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) */ if (do_seq) { curr_ofs = 0; - addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before); + addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before, 0); add_irn_dep(curr_sp, curr_mem); } else { @@ -805,11 +808,10 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp) mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_be_Call_M_regular); keep_alive(mem_proj); } - - /* Clean up the stack frame if we allocated it */ - if (! no_alloc) { - curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size); - } + } + /* Clean up the stack frame or revert alignment fixes if we allocated it */ + if (! no_alloc) { + curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size, 0); } be_abi_call_free(call); @@ -836,10 +838,15 @@ static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size, ir_graph *irg, ir_node *block, dbg_info *dbg) { if (stack_alignment > 1) { - ir_mode *mode = get_irn_mode(size); - tarval *tv = new_tarval_from_long(stack_alignment-1, mode); - ir_node *mask = new_r_Const(irg, block, mode, tv); + ir_mode *mode; + tarval *tv; + ir_node *mask; + + assert(is_po2(stack_alignment)); + mode = get_irn_mode(size); + tv = new_tarval_from_long(stack_alignment-1, mode); + mask = new_r_Const(irg, block, mode, tv); size = new_rd_Add(dbg, irg, block, size, mask, mode); tv = new_tarval_from_long(-(long)stack_alignment, mode); @@ -918,9 +925,7 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp We cannot omit it. */ env->call->flags.bits.try_omit_fp = 0; - /* FIXME: size must be here round up for the stack alignment, but - this must be transmitted from the backend. */ - stack_alignment = 4; + stack_alignment = env->isa->stack_alignment; size = adjust_alloc_size(stack_alignment, size, irg, block, dbg); new_alloc = be_new_AddSP(env->isa->sp, irg, block, curr_sp, size); set_irn_dbg_info(new_alloc, dbg); @@ -989,10 +994,8 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp) size = get_Free_size(free); } - /* FIXME: size must be here round up for the stack alignment, but - this must be transmitted from the backend. */ - stack_alignment = 4; - size = adjust_alloc_size(stack_alignment, size, irg, block, dbg); + stack_alignment = env->isa->stack_alignment; + size = adjust_alloc_size(stack_alignment, size, irg, block, dbg); /* The stack pointer will be modified in an unknown manner. We cannot omit it. */ @@ -1198,7 +1201,7 @@ static void process_calls(be_abi_irg_t *env) static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type, ir_entity ***param_map) { int dir = env->call->flags.bits.left_to_right ? 1 : -1; - int inc = env->birg->main_env->arch_env->isa->stack_dir * dir; + int inc = env->birg->main_env->arch_env.isa->stack_dir * dir; int n = get_method_n_params(method_type); int curr = inc > 0 ? 0 : n - 1; int ofs = 0; @@ -1359,13 +1362,13 @@ static ir_node *create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pm be_set_constr_single_reg(irn, n, reg); be_set_constr_single_reg(irn, pos, reg); be_node_set_reg_class(irn, pos, reg->reg_class); - arch_set_irn_register(env->birg->main_env->arch_env, proj, reg); + arch_set_irn_register(&env->birg->main_env->arch_env, proj, reg); /* if the proj projects a ignore register or a node which is set to ignore, propagate this property. */ - if(arch_register_type_is(reg, ignore) || arch_irn_is(env->birg->main_env->arch_env, in[n], ignore)) + if(arch_register_type_is(reg, ignore) || arch_irn_is(&env->birg->main_env->arch_env, in[n], ignore)) flags |= arch_irn_flags_ignore; - if(arch_irn_is(env->birg->main_env->arch_env, in[n], modify_sp)) + if(arch_irn_is(&env->birg->main_env->arch_env, in[n], modify_sp)) flags |= arch_irn_flags_modify_sp; be_node_set_flags(irn, pos, flags); @@ -1393,8 +1396,8 @@ static ir_node *create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pm static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, ir_node *mem, int n_res) { - be_abi_call_t *call = env->call; - const arch_isa_t *isa = env->birg->main_env->arch_env->isa; + be_abi_call_t *call = env->call; + const arch_isa_t *isa = env->birg->main_env->arch_env.isa; dbg_info *dbgi; pmap *reg_map = pmap_create(); ir_node *keep = pmap_get(env->keep_map, bl); @@ -1692,7 +1695,7 @@ static void fix_start_block(ir_node *block, void *env) { static void modify_irg(be_abi_irg_t *env) { be_abi_call_t *call = env->call; - const arch_isa_t *isa = env->birg->main_env->arch_env->isa; + const arch_isa_t *isa = env->birg->main_env->arch_env.isa; const arch_register_t *sp = arch_isa_sp(isa); ir_graph *irg = env->birg->irg; ir_node *bl = get_irg_start_block(irg); @@ -1833,7 +1836,7 @@ static void modify_irg(be_abi_irg_t *env) proj = new_r_Proj(irg, reg_params_bl, env->reg_params, mode, nr); pmap_insert(env->regs, (void *) reg, proj); be_set_constr_single_reg(env->reg_params, pos, reg); - arch_set_irn_register(env->birg->main_env->arch_env, proj, reg); + arch_set_irn_register(&env->birg->main_env->arch_env, proj, reg); /* * If the register is an ignore register, @@ -1864,13 +1867,13 @@ static void modify_irg(be_abi_irg_t *env) /* do the stack allocation BEFORE the barrier, or spill code might be added before it */ env->init_sp = be_abi_reg_map_get(env->regs, sp); - env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND); + env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND, 0); be_abi_reg_map_set(env->regs, sp, env->init_sp); create_barrier(env, bl, &mem, env->regs, 0); env->init_sp = be_abi_reg_map_get(env->regs, sp); - arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp); + arch_set_irn_register(&env->birg->main_env->arch_env, env->init_sp, sp); frame_pointer = be_abi_reg_map_get(env->regs, fp_reg); set_irg_frame(irg, frame_pointer); @@ -1990,7 +1993,7 @@ void fix_call_state_inputs(be_abi_irg_t *env) arity = get_irn_arity(call); - /* the statereg inputs are the last n inputs of the calls */ + /* the state reg inputs are the last n inputs of the calls */ for(s = 0; s < n_states; ++s) { int inp = arity - n_states + s; const arch_register_t *reg = stateregs[s]; @@ -2001,6 +2004,9 @@ void fix_call_state_inputs(be_abi_irg_t *env) } } +/** + * Create a trampoline entity for the given method. + */ static ir_entity *create_trampoline(be_main_env_t *be, ir_entity *method) { ir_type *type = get_entity_type(method); @@ -2015,6 +2021,23 @@ static ir_entity *create_trampoline(be_main_env_t *be, ir_entity *method) return ent; } +/** + * Returns the trampoline entity for the given method. + */ +static ir_entity *get_trampoline(be_main_env_t *env, ir_entity *method) +{ + ir_entity *result = pmap_get(env->ent_trampoline_map, method); + if (result == NULL) { + result = create_trampoline(env, method); + pmap_insert(env->ent_trampoline_map, method, result); + } + + return result; +} + +/** + * Returns non-zero if a given entity can be accessed using a relative address. + */ static int can_address_relative(ir_entity *entity) { return get_entity_variability(entity) == variability_initialized @@ -2058,7 +2081,7 @@ static void fix_pic_symconsts(ir_node *node, void *data) continue; dbgi = get_irn_dbg_info(pred); - trampoline = create_trampoline(be, entity); + trampoline = get_trampoline(be, entity); trampoline_const = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code, trampoline, NULL); set_irn_n(node, i, trampoline_const); continue; @@ -2102,11 +2125,10 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) unsigned *limited_bitset; be_omit_fp = birg->main_env->options->omit_fp; - be_pic = birg->main_env->options->pic; obstack_init(&env->obst); - env->isa = birg->main_env->arch_env->isa; + env->isa = birg->main_env->arch_env.isa; env->method_type = get_entity_type(get_irg_entity(irg)); env->call = be_abi_call_new(env->isa->sp->reg_class); arch_isa_get_call_abi(env->isa, env->method_type, env->call); @@ -2135,7 +2157,7 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) env->calls = NEW_ARR_F(ir_node*, 0); - if (be_pic) { + if (birg->main_env->options->pic) { irg_walk_graph(irg, fix_pic_symconsts, NULL, env); } @@ -2146,7 +2168,7 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) Beware: init backend abi call object after processing calls, otherwise some information might be not yet available. */ - env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg); + env->cb = env->call->cb->init(env->call, &birg->main_env->arch_env, irg); /* Process the IRG */ modify_irg(env); @@ -2242,7 +2264,7 @@ void be_abi_fix_stack_nodes(be_abi_irg_t *env) arch_isa_t *isa; walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0); - walker_env.arch_env = birg->main_env->arch_env; + walker_env.arch_env = &birg->main_env->arch_env; isa = walker_env.arch_env->isa; irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env); @@ -2286,11 +2308,12 @@ void be_abi_fix_stack_nodes(be_abi_irg_t *env) DEL_ARR_F(walker_env.sp_nodes); } -static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias) +static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int real_bias) { - const arch_env_t *arch_env = env->birg->main_env->arch_env; - int omit_fp = env->call->flags.bits.try_omit_fp; - ir_node *irn; + const arch_env_t *arch_env = &env->birg->main_env->arch_env; + int omit_fp = env->call->flags.bits.try_omit_fp; + ir_node *irn; + int wanted_bias = real_bias; sched_foreach(bl, irn) { int ofs; @@ -2302,34 +2325,59 @@ static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias) */ ir_entity *ent = arch_get_frame_entity(arch_env, irn); if(ent) { + int bias = omit_fp ? real_bias : 0; int offset = get_stack_entity_offset(env->frame, ent, bias); arch_set_frame_offset(arch_env, irn, offset); - DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n", ent, offset, bias)); + DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n", + ent, offset, bias)); } - if(omit_fp || be_is_IncSP(irn)) { - /* - * If the node modifies the stack pointer by a constant offset, - * record that in the bias. - */ - ofs = arch_get_sp_bias(arch_env, irn); - - if(be_is_IncSP(irn)) { - if(ofs == BE_STACK_FRAME_SIZE_EXPAND) { - ofs = (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg)); - be_set_IncSP_offset(irn, ofs); - } else if(ofs == BE_STACK_FRAME_SIZE_SHRINK) { - ofs = - (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg)); - be_set_IncSP_offset(irn, ofs); + /* + * If the node modifies the stack pointer by a constant offset, + * record that in the bias. + */ + ofs = arch_get_sp_bias(arch_env, irn); + + if(be_is_IncSP(irn)) { + /* fill in real stack frame size */ + if(ofs == BE_STACK_FRAME_SIZE_EXPAND) { + ir_type *frame_type = get_irg_frame_type(env->birg->irg); + ofs = (int) get_type_size_bytes(frame_type); + be_set_IncSP_offset(irn, ofs); + } else if(ofs == BE_STACK_FRAME_SIZE_SHRINK) { + ir_type *frame_type = get_irg_frame_type(env->birg->irg); + ofs = - (int)get_type_size_bytes(frame_type); + be_set_IncSP_offset(irn, ofs); + } else { + if (be_get_IncSP_align(irn)) { + /* patch IncSP to produce an aligned stack pointer */ + ir_type *between_type = env->frame->between_type; + int between_size = get_type_size_bytes(between_type); + int alignment = env->isa->stack_alignment; + int delta = (real_bias + ofs + between_size) % env->isa->stack_alignment; + assert(ofs >= 0); + if (delta > 0) { + be_set_IncSP_offset(irn, ofs + alignment - delta); + real_bias += alignment - delta; + } + } else { + /* adjust so real_bias corresponds with wanted_bias */ + int delta = wanted_bias - real_bias; + assert(delta <= 0); + if(delta != 0) { + be_set_IncSP_offset(irn, ofs + delta); + real_bias += delta; + } } } - - if(omit_fp) - bias += ofs; } + + real_bias += ofs; + wanted_bias += ofs; } - return bias; + assert(real_bias == wanted_bias); + return real_bias; } /** @@ -2337,8 +2385,9 @@ static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias) */ struct bias_walk { be_abi_irg_t *env; /**< The ABI irg environment. */ - int start_block_bias; /**< The bias at the end of the start block. */ - ir_node *start_block; /**< The start block of the current graph. */ + int start_block_bias; /**< The bias at the end of the start block. */ + int between_size; + ir_node *start_block; /**< The start block of the current graph. */ }; /** @@ -2362,6 +2411,7 @@ void be_abi_fix_stack_bias(be_abi_irg_t *env) /* Determine the stack bias at the end of the start block. */ bw.start_block_bias = process_stack_bias(env, get_irg_start_block(irg), 0); + bw.between_size = get_type_size_bytes(env->frame->between_type); /* fix the bias is all other blocks */ bw.env = env;