X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbetranshlp.c;h=c6547b9fc4be0313adca9e05b643a330934f79f2;hb=0754bb717d5761ad49a36f0e29829ffac413d92e;hp=8b8e2ca902803d5b3bce907542da8b6ad36f2859;hpb=6bb28287b0f135a4dda410e2caa974997a5c6a21;p=libfirm diff --git a/ir/be/betranshlp.c b/ir/be/betranshlp.c index 8b8e2ca90..c6547b9fc 100644 --- a/ir/be/betranshlp.c +++ b/ir/be/betranshlp.c @@ -1,20 +1,6 @@ /* - * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved. - * * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** @@ -37,6 +23,7 @@ #include "trouts.h" #include "cgana.h" #include "debug.h" +#include "execfreq_t.h" #include "beirg.h" #include "beabi.h" @@ -56,11 +43,8 @@ static be_transform_env_t env; void be_set_transformed_node(ir_node *old_node, ir_node *new_node) { - ir_graph *irg = get_irn_irg(old_node); - set_irn_link(old_node, new_node); mark_irn_visited(old_node); - hook_dead_node_elim_subst(irg, old_node, new_node); } int be_is_transformed(const ir_node *node) @@ -80,10 +64,8 @@ static inline ir_node *be_get_transformed_node(ir_node *old_node) void be_duplicate_deps(ir_node *old_node, ir_node *new_node) { - int i; int deps = get_irn_deps(old_node); - - for (i = 0; i < deps; ++i) { + for (int i = 0; i < deps; ++i) { ir_node *dep = get_irn_dep(old_node, i); ir_node *new_dep = be_transform_node(dep); @@ -91,6 +73,34 @@ void be_duplicate_deps(ir_node *old_node, ir_node *new_node) } } +ir_node *be_transform_phi(ir_node *node, const arch_register_req_t *req) +{ + ir_node *block = be_transform_node(get_nodes_block(node)); + ir_graph *irg = get_Block_irg(block); + dbg_info *dbgi = get_irn_dbg_info(node); + + /* phi nodes allow loops, so we use the old arguments for now + * and fix this later */ + ir_node **ins = get_irn_in(node)+1; + int arity = get_irn_arity(node); + ir_mode *mode = req->cls != NULL ? req->cls->mode : get_irn_mode(node); + ir_node *phi = new_ir_node(dbgi, irg, block, op_Phi, mode, arity, ins); + copy_node_attr(irg, node, phi); + be_duplicate_deps(node, phi); + + backend_info_t *info = be_get_info(phi); + struct obstack *obst = be_get_be_obst(irg); + info->in_reqs = OALLOCN(obst, const arch_register_req_t*, arity); + for (int i = 0; i < arity; ++i) { + info->in_reqs[i] = req; + } + + arch_set_irn_register_req_out(phi, 0, req); + be_enqueue_preds(node); + + return phi; +} + void be_set_transform_function(ir_op *op, be_transform_func func) { /* shouldn't be assigned twice (except for exchanging the default @@ -105,15 +115,18 @@ void be_set_transform_function(ir_op *op, be_transform_func func) */ static ir_node *transform_block(ir_node *node) { - ir_graph *irg = get_irn_irg(node); - dbg_info *dbgi = get_irn_dbg_info(node); - ir_node *block; - - block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), get_irn_mode(node), - get_irn_arity(node), get_irn_in(node) + 1); + ir_graph *irg = get_irn_irg(node); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_mode *mode = get_irn_mode(node); + ir_node *block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), mode, + get_irn_arity(node), get_irn_in(node) + 1); copy_node_attr(irg, node, block); block->node_nr = node->node_nr; + /* transfer execfreq value */ + double execfreq = get_block_execfreq(node); + set_block_execfreq(block, execfreq); + /* put the preds in the worklist */ be_enqueue_preds(node); @@ -123,13 +136,10 @@ static ir_node *transform_block(ir_node *node) static ir_node *transform_end(ir_node *node) { /* end has to be duplicated manually because we need a dynamic in array */ - ir_graph *irg = get_irn_irg(node); - dbg_info *dbgi = get_irn_dbg_info(node); - ir_node *block = be_transform_node(get_nodes_block(node)); - int i, arity; - ir_node *new_end; - - new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL); + ir_graph *irg = get_irn_irg(node); + dbg_info *dbgi = get_irn_dbg_info(node); + ir_node *block = be_transform_node(get_nodes_block(node)); + ir_node *new_end = new_ir_node(dbgi, irg, block, op_End, mode_X, -1, NULL); copy_node_attr(irg, node, new_end); be_duplicate_deps(node, new_end); @@ -137,8 +147,8 @@ static ir_node *transform_end(ir_node *node) /* do not transform predecessors yet to keep the pre-transform * phase from visiting all the graph */ - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { + int arity = get_irn_arity(node); + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); add_End_keepalive(new_end, in); } @@ -147,25 +157,6 @@ static ir_node *transform_end(ir_node *node) return new_end; } -void be_start_transform_setup(void) -{ - ir_clear_opcodes_generic_func(); - - be_set_transform_function(op_Bad, be_duplicate_node); - be_set_transform_function(op_be_Copy, be_duplicate_node); - be_set_transform_function(op_be_CopyKeep, be_duplicate_node); - be_set_transform_function(op_be_IncSP, be_duplicate_node); - be_set_transform_function(op_be_Keep, be_duplicate_node); - be_set_transform_function(op_be_Return, be_duplicate_node); - be_set_transform_function(op_be_Start, be_duplicate_node); - be_set_transform_function(op_Block, transform_block); - be_set_transform_function(op_End, transform_end); - be_set_transform_function(op_NoMem, be_duplicate_node); - be_set_transform_function(op_Pin, be_duplicate_node); - be_set_transform_function(op_Start, be_duplicate_node); - be_set_transform_function(op_Sync, be_duplicate_node); -} - ir_node *be_duplicate_node(ir_node *node) { ir_node *block = be_transform_node(get_nodes_block(node)); @@ -173,20 +164,19 @@ ir_node *be_duplicate_node(ir_node *node) dbg_info *dbgi = get_irn_dbg_info(node); ir_mode *mode = get_irn_mode(node); ir_op *op = get_irn_op(node); - ir_node *new_node; - int i, arity; - arity = get_irn_arity(node); + ir_node *new_node; + int arity = get_irn_arity(node); if (op->opar == oparity_dynamic) { new_node = new_ir_node(dbgi, irg, block, op, mode, -1, NULL); - for (i = 0; i < arity; ++i) { + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); in = be_transform_node(in); add_irn_n(new_node, in); } } else { ir_node **ins = ALLOCAN(ir_node*, arity); - for (i = 0; i < arity; ++i) { + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); ins[i] = be_transform_node(in); } @@ -203,20 +193,14 @@ ir_node *be_duplicate_node(ir_node *node) ir_node *be_transform_node(ir_node *node) { - ir_op *op; - ir_node *new_node = be_get_transformed_node(node); - be_transform_func *transform; - + ir_node *new_node = be_get_transformed_node(node); if (new_node != NULL) return new_node; DEBUG_ONLY(be_set_transformed_node(node, NULL);) - op = get_irn_op(node); - if (op->ops.generic == NULL) { - panic("No transform function registered for node %+F.", node); - } - transform = (be_transform_func *)op->ops.generic; + ir_op *op = get_irn_op(node); + be_transform_func *transform = (be_transform_func *)op->ops.generic; new_node = transform(node); assert(new_node != NULL); @@ -227,11 +211,9 @@ ir_node *be_transform_node(ir_node *node) void be_enqueue_preds(ir_node *node) { - int i, arity; - /* put the preds in the worklist */ - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { + int arity = get_irn_arity(node); + for (int i = 0; i < arity; ++i) { ir_node *pred = get_irn_n(node, i); pdeq_putr(env.worklist, pred); } @@ -242,15 +224,12 @@ void be_enqueue_preds(ir_node *node) */ static void fix_loops(ir_node *node) { - int i, arity; - int changed; - assert(node_is_in_irgs_storage(env.irg, node)); if (irn_visited_else_mark(node)) return; - changed = 0; + bool changed = false; if (! is_Block(node)) { ir_node *block = get_nodes_block(node); ir_node *new_block = (ir_node*)get_irn_link(block); @@ -258,21 +237,21 @@ static void fix_loops(ir_node *node) if (new_block != NULL) { set_nodes_block(node, new_block); block = new_block; - changed = 1; + changed = true; } fix_loops(block); } - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { + int arity = get_irn_arity(node); + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); ir_node *nw = (ir_node*)get_irn_link(in); if (nw != NULL && nw != in) { set_irn_n(node, i, nw); in = nw; - changed = 1; + changed = true; } fix_loops(in); @@ -280,18 +259,18 @@ static void fix_loops(ir_node *node) /* fix proj block */ if (is_Proj(node)) { set_nodes_block(node, get_nodes_block(get_Proj_pred(node))); - changed = 1; + changed = true; } arity = get_irn_deps(node); - for (i = 0; i < arity; ++i) { + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_dep(node, i); ir_node *nw = (ir_node*)get_irn_link(in); if (nw != NULL && nw != in) { set_irn_dep(node, i, nw); in = nw; - changed = 1; + changed = true; } fix_loops(in); @@ -322,9 +301,6 @@ static void pre_transform_anchor(ir_graph *irg, int anchor) */ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) { - int i; - ir_node *old_end, *new_anchor; - hook_dead_node_elim(irg, 1); inc_irg_visited(irg); @@ -333,10 +309,10 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) env.worklist = new_waitq(); env.old_anchor = irg->anchor; - old_end = get_irg_end(irg); + ir_node *old_end = get_irg_end(irg); /* put all anchor nodes in the worklist */ - for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) { + for (int i = get_irg_n_anchors(irg) - 1; i >= 0; --i) { ir_node *anchor = get_irg_anchor(irg, i); if (anchor == NULL) @@ -344,7 +320,7 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) waitq_put(env.worklist, anchor); } - new_anchor = new_r_Anchor(irg); + ir_node *new_anchor = new_r_Anchor(irg); irg->anchor = new_anchor; /* pre transform some anchors (so they are available in the other transform @@ -367,7 +343,7 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) /* fix loops and set new anchors*/ inc_irg_visited(irg); - for (i = get_irg_n_anchors(irg) - 1; i >= 0; --i) { + for (int i = get_irg_n_anchors(irg) - 1; i >= 0; --i) { ir_node *anchor = get_irn_n(env.old_anchor, i); if (anchor == NULL) @@ -386,16 +362,11 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func) { ir_graph *old_current_ir_graph = current_ir_graph; - struct obstack *old_obst = NULL; - struct obstack *new_obst = NULL; - current_ir_graph = irg; /* create a new obstack */ - old_obst = irg->obst; - new_obst = XMALLOC(struct obstack); - obstack_init(new_obst); - irg->obst = new_obst; + struct obstack old_obst = irg->obst; + obstack_init(&irg->obst); irg->last_node_idx = 0; free_vrp_data(irg); @@ -407,25 +378,155 @@ void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func) transform_nodes(irg, func); /* free the old obstack */ - obstack_free(old_obst, 0); - xfree(old_obst); + obstack_free(&old_obst, 0); /* restore state */ current_ir_graph = old_current_ir_graph; /* most analysis info is wrong after transformation */ - free_callee_info(irg); - free_irg_outs(irg); - free_trouts(); - free_loop_information(irg); - clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE); - - be_liveness_invalidate(be_get_irg_liveness(irg)); - /* Hack for now, something is buggy with invalidate liveness... */ - be_birg_from_irg(irg)->lv = NULL; - be_invalidate_dom_front(irg); + be_invalidate_live_chk(irg); + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE); /* recalculate edges */ - edges_deactivate(irg); edges_activate(irg); } + +bool be_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + ir_op *op = get_irn_op(node); + if (op->ops.generic1 == NULL) + return false; + upper_bits_clean_func func = (upper_bits_clean_func)op->ops.generic1; + return func(node, mode); +} + +static bool bit_binop_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + return be_upper_bits_clean(get_binop_left(node), mode) + && be_upper_bits_clean(get_binop_right(node), mode); +} + +static bool mux_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + return be_upper_bits_clean(get_Mux_true(node), mode) + && be_upper_bits_clean(get_Mux_false(node), mode); +} + +static bool and_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + if (!mode_is_signed(mode)) { + return be_upper_bits_clean(get_And_left(node), mode) + || be_upper_bits_clean(get_And_right(node), mode); + } else { + return bit_binop_upper_bits_clean(node, mode); + } +} + +static bool shr_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + if (mode_is_signed(mode)) { + return false; + } else { + const ir_node *right = get_Shr_right(node); + if (is_Const(right)) { + ir_tarval *tv = get_Const_tarval(right); + long val = get_tarval_long(tv); + if (val >= 32 - (long)get_mode_size_bits(mode)) + return true; + } + return be_upper_bits_clean(get_Shr_left(node), mode); + } +} + +static bool shrs_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + return be_upper_bits_clean(get_Shrs_left(node), mode); +} + +static bool const_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + ir_tarval *tv = get_Const_tarval(node); + long val = get_tarval_long(tv); + if (mode_is_signed(mode)) { + long shifted = val >> (get_mode_size_bits(mode)-1); + return shifted == 0 || shifted == -1; + } else { + unsigned long shifted = (unsigned long)val; + shifted >>= get_mode_size_bits(mode)-1; + shifted >>= 1; + return shifted == 0; + } +} + +static bool conv_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + ir_mode *dest_mode = get_irn_mode(node); + const ir_node *op = get_Conv_op(node); + ir_mode *src_mode = get_irn_mode(op); + if (mode_is_float(src_mode)) + return true; + + unsigned src_bits = get_mode_size_bits(src_mode); + unsigned dest_bits = get_mode_size_bits(dest_mode); + /* downconvs are a nop */ + if (src_bits >= dest_bits) + return be_upper_bits_clean(op, mode); + /* upconvs are fine if src is big enough or if sign matches */ + if (src_bits <= get_mode_size_bits(mode) + && mode_is_signed(src_mode) == mode_is_signed(mode)) + return true; + return false; +} + +static bool proj_upper_bits_clean(const ir_node *node, ir_mode *mode) +{ + const ir_node *pred = get_Proj_pred(node); + switch (get_irn_opcode(pred)) { + case iro_Load: { + ir_mode *load_mode = get_Load_mode(pred); + unsigned load_bits = get_mode_size_bits(load_mode); + if (load_bits > get_mode_size_bits(mode)) + return false; + if (mode_is_signed(load_mode) != mode_is_signed(mode)) + return false; + return true; + } + default: + break; + } + return false; +} + +void be_set_upper_bits_clean_function(ir_op *op, upper_bits_clean_func func) +{ + op->ops.generic1 = (op_func)func; +} + +void be_start_transform_setup(void) +{ + ir_clear_opcodes_generic_func(); + + be_set_transform_function(op_Bad, be_duplicate_node); + be_set_transform_function(op_be_Copy, be_duplicate_node); + be_set_transform_function(op_be_CopyKeep, be_duplicate_node); + be_set_transform_function(op_be_IncSP, be_duplicate_node); + be_set_transform_function(op_be_Keep, be_duplicate_node); + be_set_transform_function(op_be_Return, be_duplicate_node); + be_set_transform_function(op_be_Start, be_duplicate_node); + be_set_transform_function(op_Block, transform_block); + be_set_transform_function(op_End, transform_end); + be_set_transform_function(op_NoMem, be_duplicate_node); + be_set_transform_function(op_Pin, be_duplicate_node); + be_set_transform_function(op_Start, be_duplicate_node); + be_set_transform_function(op_Sync, be_duplicate_node); + + be_set_upper_bits_clean_function(op_And, and_upper_bits_clean); + be_set_upper_bits_clean_function(op_Const, const_upper_bits_clean); + be_set_upper_bits_clean_function(op_Conv, conv_upper_bits_clean); + be_set_upper_bits_clean_function(op_Eor, bit_binop_upper_bits_clean); + be_set_upper_bits_clean_function(op_Mux, mux_upper_bits_clean); + be_set_upper_bits_clean_function(op_Or, bit_binop_upper_bits_clean); + be_set_upper_bits_clean_function(op_Proj, proj_upper_bits_clean); + be_set_upper_bits_clean_function(op_Shr, shr_upper_bits_clean); + be_set_upper_bits_clean_function(op_Shrs, shrs_upper_bits_clean); +}