X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fsparc%2Fsparc_finish.c;h=30fd44c32cd8c5f70a5c959aeafbdbdb52d76074;hb=e8cf3d720aae749ac58d2da1c1f9aff3dccfa087;hp=6babba6501b26367c9340c6dbf417bd02ed8e142;hpb=f62bf2f3cfa38dd00bb4573ed4cf79c9f9d833bd;p=libfirm diff --git a/ir/be/sparc/sparc_finish.c b/ir/be/sparc/sparc_finish.c index 6babba650..30fd44c32 100644 --- a/ir/be/sparc/sparc_finish.c +++ b/ir/be/sparc/sparc_finish.c @@ -42,13 +42,18 @@ #include "bearch_sparc_t.h" #include "gen_sparc_regalloc_if.h" #include "sparc_new_nodes.h" +#include "sparc_transform.h" #include "irprog.h" #include "irgmod.h" #include "ircons.h" +#include "irgwalk.h" -#include "../bepeephole.h" -#include "../benode.h" -#include "../besched.h" +#include "bepeephole.h" +#include "benode.h" +#include "besched.h" +#include "bespillslots.h" +#include "bestack.h" +#include "beirgmod.h" static void kill_unused_stacknodes(ir_node *node) { @@ -92,7 +97,7 @@ static void introduce_epilog(ir_node *ret) kill_unused_stacknodes(sp); } else { - ir_node *incsp = be_new_IncSP(sp_reg, block, sp, frame_size, 0); + ir_node *incsp = be_new_IncSP(sp_reg, block, sp, -frame_size, 0); set_irn_n(ret, sp_idx, incsp); sched_add_before(ret, incsp); } @@ -127,26 +132,22 @@ void sparc_introduce_prolog_epilog(ir_graph *irg) schedpoint = sched_next(schedpoint); if (!layout->sp_relative) { - ir_node *incsp; ir_node *save = new_bd_sparc_Save_imm(NULL, block, sp, NULL, - -SPARC_MIN_STACKSIZE); + -SPARC_MIN_STACKSIZE-frame_size); arch_set_irn_register(save, sp_reg); sched_add_after(schedpoint, save); schedpoint = save; - incsp = be_new_IncSP(sp_reg, block, save, frame_size, 0); - edges_reroute(initial_sp, incsp); + edges_reroute(initial_sp, save); set_irn_n(save, n_sparc_Save_stack, initial_sp); - sched_add_after(schedpoint, incsp); - schedpoint = incsp; - /* we still need the IncSP even if noone is explicitely using the + /* we still need the Save even if noone is explicitely using the * value. (TODO: this isn't 100% correct yet, something at the end of - * the function should hold the IncSP, even if we use a restore + * the function should hold the Save, even if we use a restore * which just overrides it instead of using the value) */ - if (get_irn_n_edges(incsp) == 0) { - ir_node *in[] = { incsp }; + if (get_irn_n_edges(save) == 0) { + ir_node *in[] = { save }; ir_node *keep = be_new_Keep(block, 1, in); sched_add_after(schedpoint, keep); } @@ -158,158 +159,232 @@ void sparc_introduce_prolog_epilog(ir_graph *irg) } } +/** + * Creates a constant from an immediate value. + */ +static ir_node *create_constant_from_immediate(ir_node *node, int offset) +{ + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *high = new_bd_sparc_SetHi(dbgi, block, NULL, offset); + + sched_add_before(node, high); + arch_set_irn_register(high, &sparc_registers[REG_G4]); + + if ((offset & 0x3ff) != 0) { + ir_node *low = new_bd_sparc_Or_imm(dbgi, block, high, NULL, offset & 0x3ff); + + sched_add_before(node, low); + arch_set_irn_register(low, &sparc_registers[REG_G4]); + + return low; + } + + return high; +} + static void finish_sparc_Save(ir_node *node) { sparc_attr_t *attr = get_sparc_attr(node); int offset = attr->immediate_value; - ir_node *schedpoint = node; - dbg_info *dbgi; - ir_node *block; - ir_node *new_save; - ir_node *stack; - ir_entity *entity; - - if (sparc_is_value_imm_encodeable(offset)) - return; - /* uhh only works for the imm variant yet */ - assert(get_irn_arity(node) == 1); - - block = get_nodes_block(node); - dbgi = get_irn_dbg_info(node); - stack = get_irn_n(node, n_sparc_Save_stack); - entity = attr->immediate_value_entity; - new_save = new_bd_sparc_Save_imm(dbgi, block, stack, entity, 0); - arch_set_irn_register(new_save, &sparc_registers[REG_SP]); - stack = new_save; - - sched_add_after(node, new_save); - schedpoint = new_save; - while (offset > SPARC_IMMEDIATE_MAX || offset < SPARC_IMMEDIATE_MIN) { - if (offset > 0) { - stack = be_new_IncSP(&sparc_registers[REG_SP], block, stack, - SPARC_IMMEDIATE_MIN, 0); - offset -= -SPARC_IMMEDIATE_MIN; - } else { - stack = be_new_IncSP(&sparc_registers[REG_SP], block, stack, - -SPARC_IMMEDIATE_MIN, 0); - offset -= SPARC_IMMEDIATE_MIN; - } - sched_add_after(schedpoint, stack); - schedpoint = stack; + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *base = get_irn_n(node, n_sparc_Save_stack); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_save = new_bd_sparc_Save_reg(dbgi, block, base, constant); + const arch_register_t *reg = arch_get_irn_register(node); + + /* we have a Save with immediate */ + assert(get_irn_arity(node) == 1); + + sched_add_before(node, new_save); + arch_set_irn_register(new_save, reg); + be_peephole_exchange(node, new_save); } - attr = get_sparc_attr(new_save); - attr->immediate_value = offset; - be_peephole_exchange(node, stack); } /** - * sparc immediates are limited. Split IncSP with bigger immediates if + * SPARC immediates are limited. Split IncSP with bigger immediates if * necessary. */ static void finish_be_IncSP(ir_node *node) { - int sign = 1; - int offset = be_get_IncSP_offset(node); - ir_node *sp = be_get_IncSP_pred(node); - ir_node *block; - - /* we might have to break the IncSP apart if the constant has become too - * big */ - if (offset < 0) { - offset = -offset; - sign = -1; - } - - if (sparc_is_value_imm_encodeable(-offset)) - return; - - /* split incsp into multiple instructions */ - block = get_nodes_block(node); - while (offset > -SPARC_IMMEDIATE_MIN) { - sp = be_new_IncSP(&sparc_registers[REG_SP], block, sp, - sign * -SPARC_IMMEDIATE_MIN, 0); - sched_add_before(node, sp); - offset -= -SPARC_IMMEDIATE_MIN; + int offset = be_get_IncSP_offset(node); + + /* we might have to break the IncSP apart if the constant has become too big */ + if (! sparc_is_value_imm_encodeable(offset) && ! sparc_is_value_imm_encodeable(-offset)) { + ir_node *sp = be_get_IncSP_pred(node); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *sub = new_bd_sparc_Sub_reg(dbgi, block, sp, constant); + + sched_add_before(node, sub); + arch_set_irn_register(sub, &sparc_registers[REG_SP]); + be_peephole_exchange(node, sub); } - - be_set_IncSP_pred(node, sp); - be_set_IncSP_offset(node, sign*offset); } /** - * adjust sp-relative offsets. Split into multiple instructions if offset - * exceeds sparc immediate range. + * Adjust sp-relative offsets. + * + * Split into multiple instructions if offset exceeds SPARC immediate range. */ static void finish_sparc_FrameAddr(ir_node *node) { - /* adapt to sparc stack magic */ sparc_attr_t *attr = get_sparc_attr(node); int offset = attr->immediate_value; - ir_node *base = get_irn_n(node, n_sparc_FrameAddr_base); - dbg_info *dbgi = get_irn_dbg_info(node); - ir_node *block = get_nodes_block(node); - int sign = 1; - bool sp_relative - = arch_get_irn_register(base) == &sparc_registers[REG_SP]; - if (sp_relative) { - offset += SPARC_MIN_STACKSIZE; + + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *base = get_irn_n(node, n_sparc_FrameAddr_base); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_frameaddr = new_bd_sparc_Add_reg(dbgi, block, base, constant); + const arch_register_t *reg = arch_get_irn_register(node); + + sched_add_before(node, new_frameaddr); + arch_set_irn_register(new_frameaddr, reg); + exchange(node, new_frameaddr); } +} - if (offset < 0) { - sign = -1; - offset = -offset; +static void finish_sparc_Ld(ir_node *node) +{ + sparc_attr_t *attr = get_sparc_attr(node); + int offset = attr->immediate_value; + const sparc_load_store_attr_t *load_store_attr = get_sparc_load_store_attr_const(node); + + if (! load_store_attr->is_frame_entity) + return; + + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *ptr = get_irn_n(node, n_sparc_Ld_ptr); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *mem = get_irn_n(node, n_sparc_Ld_mem); + ir_mode *load_store_mode = load_store_attr->load_store_mode; + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_load = new_bd_sparc_Ld_reg(dbgi, block, ptr, constant, mem, load_store_mode); + sparc_load_store_attr_t *new_load_attr = get_sparc_load_store_attr(new_load); + unsigned n_outs = arch_get_irn_n_outs(node); + unsigned i; + + new_load_attr->is_frame_entity = load_store_attr->is_frame_entity; + new_load_attr->is_reg_reg = load_store_attr->is_reg_reg; + + sched_add_before(node, new_load); + for (i = 0; i < n_outs; i++) { + arch_set_irn_register_out(new_load, i, arch_get_irn_register_out(node, i)); + } + exchange(node, new_load); } - if (offset > -SPARC_IMMEDIATE_MIN) { - ir_entity *entity = attr->immediate_value_entity; - ir_node *new_frameaddr - = new_bd_sparc_FrameAddr(dbgi, block, base, entity, 0); - ir_node *schedpoint = node; - const arch_register_t *reg = arch_get_irn_register(node); +} - sched_add_after(schedpoint, new_frameaddr); - schedpoint = new_frameaddr; - arch_set_irn_register(new_frameaddr, reg); - base = new_frameaddr; - - while (offset > -SPARC_IMMEDIATE_MIN) { - if (sign > 0) { - base = new_bd_sparc_Sub_imm(dbgi, block, base, NULL, - SPARC_IMMEDIATE_MIN); - } else { - base = new_bd_sparc_Add_imm(dbgi, block, base, NULL, - SPARC_IMMEDIATE_MIN); - } - arch_set_irn_register(base, reg); - sched_add_after(schedpoint, base); - schedpoint = base; - - offset -= -SPARC_IMMEDIATE_MIN; +static void finish_sparc_Ldf(ir_node *node) +{ + sparc_attr_t *attr = get_sparc_attr(node); + int offset = attr->immediate_value; + const sparc_load_store_attr_t *load_store_attr = get_sparc_load_store_attr_const(node); + + if (! load_store_attr->is_frame_entity) + return; + + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *ptr = get_irn_n(node, n_sparc_Ldf_ptr); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *mem = get_irn_n(node, n_sparc_Ldf_mem); + ir_mode *load_store_mode = load_store_attr->load_store_mode; + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_ptr = new_bd_sparc_Add_reg(dbgi, block, ptr, constant); + ir_node *new_load = new_bd_sparc_Ldf_s(dbgi, block, new_ptr, mem, load_store_mode, NULL, 0, true); + sparc_load_store_attr_t *new_load_attr = get_sparc_load_store_attr(new_load); + unsigned n_outs = arch_get_irn_n_outs(node); + unsigned i; + + new_load_attr->is_frame_entity = load_store_attr->is_frame_entity; + new_load_attr->is_reg_reg = load_store_attr->is_reg_reg; + + sched_add_before(node, new_load); + for (i = 0; i < n_outs; i++) { + arch_set_irn_register_out(new_load, i, arch_get_irn_register_out(node, i)); } + exchange(node, new_load); + } - be_peephole_exchange(node, base); - attr = get_sparc_attr(new_frameaddr); +} + +static void finish_sparc_St(ir_node *node) +{ + sparc_attr_t *attr = get_sparc_attr(node); + int offset = attr->immediate_value; + const sparc_load_store_attr_t *load_store_attr = get_sparc_load_store_attr_const(node); + + if (! load_store_attr->is_frame_entity) + return; + + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *ptr = get_irn_n(node, n_sparc_St_ptr); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *mem = get_irn_n(node, n_sparc_St_mem); + ir_node *value = get_irn_n(node, n_sparc_St_val); + ir_mode *load_store_mode = load_store_attr->load_store_mode; + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_load = new_bd_sparc_St_reg(dbgi, block, value, ptr, constant, mem, load_store_mode); + sparc_load_store_attr_t *new_load_attr = get_sparc_load_store_attr(new_load); + unsigned n_outs = arch_get_irn_n_outs(node); + unsigned i; + + new_load_attr->is_frame_entity = load_store_attr->is_frame_entity; + new_load_attr->is_reg_reg = load_store_attr->is_reg_reg; + + sched_add_before(node, new_load); + for (i = 0; i < n_outs; i++) { + arch_set_irn_register_out(new_load, i, arch_get_irn_register_out(node, i)); + } + exchange(node, new_load); } - attr->immediate_value = sign*offset; + } -static void finish_sparc_LdSt(ir_node *node) +static void finish_sparc_Stf(ir_node *node) { - sparc_load_store_attr_t *attr = get_sparc_load_store_attr(node); - if (attr->is_frame_entity) { - ir_node *base; - bool sp_relative; - if (is_sparc_Ld(node) || is_sparc_Ldf(node)) { - base = get_irn_n(node, n_sparc_Ld_ptr); - } else { - assert(is_sparc_St(node) || is_sparc_Stf(node)); - base = get_irn_n(node, n_sparc_St_ptr); + sparc_attr_t *attr = get_sparc_attr(node); + int offset = attr->immediate_value; + const sparc_load_store_attr_t *load_store_attr = get_sparc_load_store_attr_const(node); + + if (! load_store_attr->is_frame_entity) + return; + + if (! sparc_is_value_imm_encodeable(offset)) { + ir_node *ptr = get_irn_n(node, n_sparc_Stf_ptr); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = get_nodes_block(node); + ir_node *mem = get_irn_n(node, n_sparc_Stf_mem); + ir_node *value = get_irn_n(node, n_sparc_Stf_val); + ir_mode *load_store_mode = load_store_attr->load_store_mode; + ir_node *constant = create_constant_from_immediate(node, offset); + ir_node *new_ptr = new_bd_sparc_Add_reg(dbgi, block, ptr, constant); + ir_node *new_load = new_bd_sparc_Stf_s(dbgi, block, value, new_ptr, mem, load_store_mode, NULL, 0, true); + sparc_load_store_attr_t *new_load_attr = get_sparc_load_store_attr(new_load); + unsigned n_outs = arch_get_irn_n_outs(node); + unsigned i; + + new_load_attr->is_frame_entity = load_store_attr->is_frame_entity; + new_load_attr->is_reg_reg = load_store_attr->is_reg_reg; + + sched_add_before(node, new_load); + for (i = 0; i < n_outs; i++) { + arch_set_irn_register_out(new_load, i, arch_get_irn_register_out(node, i)); } - sp_relative = arch_get_irn_register(base) == &sparc_registers[REG_SP]; - if (sp_relative) - attr->base.immediate_value += SPARC_MIN_STACKSIZE; + exchange(node, new_load); } + } static void peephole_be_IncSP(ir_node *node) @@ -372,8 +447,67 @@ static void register_peephole_optimisation(ir_op *op, peephole_opt_func func) op->ops.generic = (op_func) func; } +static void sparc_collect_frame_entity_nodes(ir_node *node, void *data) +{ + be_fec_env_t *env = (be_fec_env_t*)data; + const ir_mode *mode; + int align; + ir_entity *entity; + const sparc_load_store_attr_t *attr; + + if (be_is_Reload(node) && be_get_frame_entity(node) == NULL) { + mode = get_irn_mode(node); + align = get_mode_size_bytes(mode); + be_node_needs_frame_entity(env, node, mode, align); + return; + } + + if (!is_sparc_Ld(node) && !is_sparc_Ldf(node)) + return; + + attr = get_sparc_load_store_attr_const(node); + entity = attr->base.immediate_value_entity; + mode = attr->load_store_mode; + if (entity != NULL) + return; + if (!attr->is_frame_entity) + return; + if (arch_get_irn_flags(node) & sparc_arch_irn_flag_needs_64bit_spillslot) + mode = mode_Lu; + align = get_mode_size_bytes(mode); + be_node_needs_frame_entity(env, node, mode, align); +} + +static void sparc_set_frame_entity(ir_node *node, ir_entity *entity) +{ + if (is_be_node(node)) { + be_node_set_frame_entity(node, entity); + } else { + /* we only say be_node_needs_frame_entity on nodes with load_store + * attributes, so this should be fine */ + sparc_load_store_attr_t *attr = get_sparc_load_store_attr(node); + assert(attr->is_frame_entity); + assert(attr->base.immediate_value_entity == NULL); + attr->base.immediate_value_entity = entity; + } +} + void sparc_finish(ir_graph *irg) { + be_stack_layout_t *stack_layout = be_get_irg_stack_layout(irg); + bool at_begin = stack_layout->sp_relative ? true : false; + be_fec_env_t *fec_env = be_new_frame_entity_coalescer(irg); + + irg_walk_graph(irg, NULL, sparc_collect_frame_entity_nodes, fec_env); + be_assign_entities(fec_env, sparc_set_frame_entity, at_begin); + be_free_frame_entity_coalescer(fec_env); + + sparc_introduce_prolog_epilog(irg); + + /* fix stack entity offsets */ + be_abi_fix_stack_nodes(irg); + sparc_fix_stack_bias(irg); + /* perform peephole optimizations */ clear_irp_opcodes_generic_func(); register_peephole_optimisation(op_be_IncSP, peephole_be_IncSP); @@ -384,11 +518,13 @@ void sparc_finish(ir_graph *irg) clear_irp_opcodes_generic_func(); register_peephole_optimisation(op_be_IncSP, finish_be_IncSP); register_peephole_optimisation(op_sparc_FrameAddr, finish_sparc_FrameAddr); - register_peephole_optimisation(op_sparc_Ld, finish_sparc_LdSt); - register_peephole_optimisation(op_sparc_Ldf, finish_sparc_LdSt); + register_peephole_optimisation(op_sparc_Ld, finish_sparc_Ld); + register_peephole_optimisation(op_sparc_Ldf, finish_sparc_Ldf); register_peephole_optimisation(op_sparc_Return, finish_sparc_Return); register_peephole_optimisation(op_sparc_Save, finish_sparc_Save); - register_peephole_optimisation(op_sparc_St, finish_sparc_LdSt); - register_peephole_optimisation(op_sparc_Stf, finish_sparc_LdSt); + register_peephole_optimisation(op_sparc_St, finish_sparc_St); + register_peephole_optimisation(op_sparc_Stf, finish_sparc_Stf); be_peephole_opt(irg); + + be_remove_dead_nodes_from_schedule(irg); }