X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbetranshlp.c;h=5158d4d1a5b360fd379989e0aa812b42c611bdc6;hb=0bddf6c31e2dc664e50eed6609ac36a1a86e1536;hp=0c098b53d22a4cb8d5341dc0800359e1c9fec5b7;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm diff --git a/ir/be/betranshlp.c b/ir/be/betranshlp.c index 0c098b53d..5158d4d1a 100644 --- a/ir/be/betranshlp.c +++ b/ir/be/betranshlp.c @@ -22,7 +22,6 @@ * @brief be transform helper extracted from the ia32 backend. * @author Matthias Braun, Michael Beck * @date 14.06.2007 - * @version $Id$ */ #include "config.h" @@ -40,6 +39,7 @@ #include "debug.h" #include "beirg.h" +#include "beabi.h" #include "betranshlp.h" #include "belive.h" #include "benode.h" @@ -56,8 +56,11 @@ 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) @@ -88,14 +91,6 @@ void be_duplicate_deps(ir_node *old_node, ir_node *new_node) } } -void be_dep_on_frame(ir_node* node) -{ - ir_graph *const irg = current_ir_graph; - - if (get_irg_start_block(irg) == get_nodes_block(node)) - add_irn_dep(node, get_irg_frame(irg)); -} - void be_set_transform_function(ir_op *op, be_transform_func func) { /* shouldn't be assigned twice (except for exchanging the default @@ -105,18 +100,66 @@ void be_set_transform_function(ir_op *op, be_transform_func func) op->ops.generic = (op_func) func; } +/** + * Transform helper for blocks. + */ +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); + copy_node_attr(irg, node, block); + block->node_nr = node->node_nr; + + /* put the preds in the worklist */ + be_enqueue_preds(node); + + return block; +} + +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); + copy_node_attr(irg, node, new_end); + be_duplicate_deps(node, new_end); + + set_irg_end(irg, new_end); + + /* 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) { + ir_node *in = get_irn_n(node, i); + add_End_keepalive(new_end, in); + } + be_enqueue_preds(node); + + return new_end; +} + void be_start_transform_setup(void) { - clear_irp_opcodes_generic_func(); + ir_clear_opcodes_generic_func(); be_set_transform_function(op_Bad, be_duplicate_node); - be_set_transform_function(op_be_Barrier, 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); @@ -167,7 +210,7 @@ ir_node *be_transform_node(ir_node *node) if (new_node != NULL) return new_node; - DEBUG_ONLY(be_set_transformed_node(node, NULL)); + DEBUG_ONLY(be_set_transformed_node(node, NULL);) op = get_irn_op(node); if (op->ops.generic == NULL) { @@ -179,7 +222,6 @@ ir_node *be_transform_node(ir_node *node) assert(new_node != NULL); be_set_transformed_node(node, new_node); - hook_dead_node_elim_subst(current_ir_graph, node, new_node); return new_node; } @@ -268,37 +310,11 @@ ir_node *be_pre_transform_node(ir_node *place) return be_transform_node(place); } -static void pre_transform_anchor(int anchor) +static void pre_transform_anchor(ir_graph *irg, int anchor) { ir_node *old_anchor_node = get_irn_n(env.old_anchor, anchor); ir_node *transformed = be_transform_node(old_anchor_node); - set_irg_anchor(current_ir_graph, anchor, transformed); -} - -static void kill_unused_anchor(int anchor) -{ - ir_node *old_anchor_node = get_irn_n(env.old_anchor, anchor); - ir_node *old_bad = get_irn_n(env.old_anchor, anchor_bad); - if (old_anchor_node != NULL && get_irn_n_edges(old_anchor_node) <= 1) { - set_irn_n(env.old_anchor, anchor, old_bad); - } -} - -static ir_node *new_be_Anchor(ir_graph *irg) -{ - struct obstack *obst = be_get_be_obst(irg); - backend_info_t *info; - ir_node *new_anchor; - - /* Hack: some places in the code ask the Anchor for its register - requirements */ - new_anchor = new_r_Anchor(irg); - info = be_get_info(new_anchor); - info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1); - memset(info->out_infos, 0, 1 * sizeof(info->out_infos[0])); - info->out_infos[0].req = arch_no_register_req; - - return new_anchor; + set_irg_anchor(irg, anchor, transformed); } /** @@ -313,9 +329,9 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) inc_irg_visited(irg); - env.irg = irg; - env.worklist = new_waitq(); - env.old_anchor = irg->anchor; + env.irg = irg; + env.worklist = new_waitq(); + env.old_anchor = irg->anchor; old_end = get_irg_end(irg); @@ -328,17 +344,17 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) waitq_put(env.worklist, anchor); } - new_anchor = new_be_Anchor(irg); + new_anchor = new_r_Anchor(irg); irg->anchor = new_anchor; /* pre transform some anchors (so they are available in the other transform * functions) */ - pre_transform_anchor(anchor_bad); - pre_transform_anchor(anchor_no_mem); - pre_transform_anchor(anchor_start_block); - pre_transform_anchor(anchor_start); - pre_transform_anchor(anchor_frame); - kill_unused_anchor(anchor_tls); + pre_transform_anchor(irg, anchor_no_mem); + pre_transform_anchor(irg, anchor_end_block); + pre_transform_anchor(irg, anchor_end); + pre_transform_anchor(irg, anchor_start_block); + pre_transform_anchor(irg, anchor_start); + pre_transform_anchor(irg, anchor_frame); if (pre_transform) pre_transform(); @@ -367,53 +383,6 @@ static void transform_nodes(ir_graph *irg, arch_pretrans_nodes *pre_transform) hook_dead_node_elim(irg, 0); } -/** - * Transform helper for blocks. - */ -static ir_node *gen_Block(ir_node *node) -{ - ir_graph *irg = current_ir_graph; - 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); - copy_node_attr(irg, node, block); - block->node_nr = node->node_nr; - - /* put the preds in the worklist */ - be_enqueue_preds(node); - - return block; -} - -static ir_node *gen_End(ir_node *node) -{ - /* end has to be duplicated manually because we need a dynamic in array */ - ir_graph *irg = current_ir_graph; - 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); - copy_node_attr(irg, node, new_end); - be_duplicate_deps(node, new_end); - - set_irg_end(irg, new_end); - - /* transform preds */ - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { - ir_node *in = get_irn_n(node, i); - ir_node *new_in = be_transform_node(in); - - add_End_keepalive(new_end, new_in); - } - - return new_end; -} - void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func) { ir_graph *old_current_ir_graph = current_ir_graph; @@ -429,18 +398,11 @@ void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func) irg->obst = new_obst; irg->last_node_idx = 0; - /* invalidate phase info as (at least vrp info) is used inside the - * equivalent/compute_value functions and might replace our newly - * created nodes with middleend nodes */ - irg_invalidate_phases(irg); + free_vrp_data(irg); /* create new value table for CSE */ new_identities(irg); - /* enter special helper */ - op_Block->ops.generic = (op_func)gen_Block; - op_End->ops.generic = (op_func)gen_End; - /* do the main transformation */ transform_nodes(irg, func); @@ -456,89 +418,12 @@ void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func) free_irg_outs(irg); free_trouts(); free_loop_information(irg); - set_irg_doms_inconsistent(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_live_chk(irg); be_invalidate_dom_front(irg); /* recalculate edges */ edges_deactivate(irg); edges_activate(irg); } - -int be_mux_is_abs(ir_node *sel, ir_node *mux_true, ir_node *mux_false) -{ - ir_node *cmp_left; - ir_node *cmp_right; - ir_node *cmp; - ir_mode *mode; - pn_Cmp pnc; - - if (!is_Proj(sel)) - return 0; - cmp = get_Proj_pred(sel); - if (!is_Cmp(cmp)) - return 0; - - /** - * Note further that these optimization work even for floating point - * with NaN's because -NaN == NaN. - * However, if +0 and -0 is handled differently, we cannot use the Abs/-Abs - * transformations. - */ - mode = get_irn_mode(mux_true); - if (mode_honor_signed_zeros(mode)) - return 0; - - /* must be <, <=, >=, > */ - pnc = get_Proj_pn_cmp(sel); - switch (pnc) { - case pn_Cmp_Ge: - case pn_Cmp_Gt: - case pn_Cmp_Le: - case pn_Cmp_Lt: - case pn_Cmp_Uge: - case pn_Cmp_Ug: - case pn_Cmp_Ul: - case pn_Cmp_Ule: - break; - default: - return 0; - } - - if (!is_negated_value(mux_true, mux_false)) - return 0; - - /* must be x cmp 0 */ - cmp_right = get_Cmp_right(cmp); - if (!is_Const(cmp_right) || !is_Const_null(cmp_right)) - return 0; - - cmp_left = get_Cmp_left(cmp); - if (cmp_left == mux_false) { - if (pnc & pn_Cmp_Lt) { - return 1; - } else { - assert(pnc & pn_Cmp_Gt); - return -1; - } - } else if (cmp_left == mux_true) { - if (pnc & pn_Cmp_Lt) { - return -1; - } else { - assert(pnc & pn_Cmp_Gt); - return 1; - } - } - - return 0; -} - -ir_node *be_get_abs_op(ir_node *sel) -{ - ir_node *cmp = get_Proj_pred(sel); - ir_node *cmp_left = get_Cmp_left(cmp); - return cmp_left; -}