X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Flower%2Flower_mode_b.c;h=7b89ff9940c8b50ac56e1562bc372773cb606504;hb=4d7f507c357a0bdb1433ef3973645ece971e3824;hp=7c1383dbfae7f3559d8cf4ea7bf6469fbcb176c9;hpb=1dd113bcc7c2cf25d83886605a07161914b941e0;p=libfirm diff --git a/ir/lower/lower_mode_b.c b/ir/lower/lower_mode_b.c index 7c1383dbf..7b89ff994 100644 --- a/ir/lower/lower_mode_b.c +++ b/ir/lower/lower_mode_b.c @@ -19,26 +19,14 @@ /** * @file - * @brief lowers operations with mode_b. The result is a graph which - * might still contains some convs from/to mode_b, but no - * operations are performed on them anymore, they are just there - * so modes match. A backend can safely skip all mode_b convs. + * @brief lower mode_b operations to something the backend can handle * @author Matthias Braun, Christoph Mallon * @version $Id$ - * - * After this pass the following should hold: - * - The only inputs with mode_b are for the Cond node or the - * Sel input of a Mux node. - * - The only nodes producing mode_b are: Proj(Cmp) and ConvB(X) (where X - * is some mode that can be converted to the lowered mode). - * ConvB will usually be implemented by a comparison with 0 producing some - * flags in the backends. It's debatable whether ConvB(X) is a good idea. - * Maybe we should rather introduce a Test node. - * All other former uses should be converted to manipulations with an integer - * mode that was specified in the pass configuration. */ #include "config.h" +#include "lower_mode_b.h" + #include #include @@ -58,40 +46,18 @@ #include "util.h" #include "array.h" -static const lower_mode_b_config_t *config; -static ir_type *lowered_type; -static ir_node **lowered_nodes; -static ir_node **check_later; +typedef struct needs_lowering_t { + ir_node *node; + int input; +} needs_lowering_t; -/** - * Removes a node if its out-edge count has reached 0. - * temporary hack until we have proper automatic dead code elimination. - */ -static void maybe_kill_node(ir_node *node) -{ - ir_graph *irg; - int i, arity; - - if (get_irn_n_edges(node) != 0) - return; - - irg = get_irn_irg(node); - - assert(!is_Bad(node)); - - arity = get_irn_arity(node); - for (i = 0; i < arity; ++i) { - set_irn_n(node, i, new_r_Bad(irg)); - } - set_nodes_block(node, new_r_Bad(irg)); - - edges_node_deleted(node); -} +static ir_mode *lowered_mode; +static needs_lowering_t *needs_lowering; static ir_node *create_not(dbg_info *dbgi, ir_node *node) { ir_node *block = get_nodes_block(node); - ir_mode *mode = config->lowered_mode; + ir_mode *mode = lowered_mode; ir_tarval *tv_one = get_mode_one(mode); ir_graph *irg = get_irn_irg(node); ir_node *one = new_rd_Const(dbgi, irg, tv_one); @@ -99,35 +65,22 @@ static ir_node *create_not(dbg_info *dbgi, ir_node *node) return new_rd_Eor(dbgi, block, node, one, mode); } -static ir_node *create_convb(ir_node *node) -{ - ir_node *block = get_nodes_block(node); - ir_node *conv = new_rd_Conv(NULL, block, node, mode_b); - - return conv; -} - -static ir_type *create_lowered_type(void) +static ir_node *convert_to_modeb(ir_node *node) { - if (lowered_type == NULL) { - lowered_type = new_type_primitive(config->lowered_mode); - } - return lowered_type; -} - -ir_node *ir_create_mux_set(ir_node *cond, ir_mode *dest_mode) -{ - ir_graph *irg = get_irn_irg(cond); - ir_node *block = get_nodes_block(cond); - ir_tarval *tv_one = get_mode_one(dest_mode); - ir_node *one = new_r_Const(irg, tv_one); - ir_tarval *tv_zero = get_mode_null(dest_mode); + ir_node *block = get_nodes_block(node); + ir_graph *irg = get_irn_irg(node); + ir_mode *mode = lowered_mode; + ir_tarval *tv_zero = get_mode_null(mode); ir_node *zero = new_r_Const(irg, tv_zero); - ir_node *set = new_r_Mux(block, cond, zero, one, dest_mode); - return set; + ir_node *cmp = new_r_Cmp(block, node, zero, ir_relation_less_greater); + return cmp; } -ir_node *ir_create_cond_set(ir_node *cond_value, ir_mode *dest_mode) +/** + * implementation of create_set_func which produces a cond with control + * flow + */ +static ir_node *create_cond_set(ir_node *cond_value, ir_mode *dest_mode) { ir_node *lower_block = part_block_edges(cond_value); ir_node *upper_block = get_nodes_block(cond_value); @@ -150,46 +103,22 @@ ir_node *ir_create_cond_set(ir_node *cond_value, ir_mode *dest_mode) set_irn_in(lower_block, ARRAY_SIZE(lower_in), lower_in); phi = new_r_Phi(lower_block, ARRAY_SIZE(phi_in), phi_in, dest_mode); - /* make sure we do visit the cond_value later... */ - ARR_APP1(ir_node*, check_later, cond_value); - return phi; } -static void adjust_method_type(ir_type *method_type) -{ - size_t i; - size_t n_params; - size_t n_res; - - n_params = get_method_n_params(method_type); - for (i = 0; i < n_params; ++i) { - ir_type *param = get_method_param_type(method_type, i); - if (get_type_mode(param) == mode_b) { - set_method_param_type(method_type, i, create_lowered_type()); - } - } - - n_res = get_method_n_ress(method_type); - for (i = 0; i < n_res; ++i) { - ir_type *res_type = get_method_res_type(method_type, i); - if (get_type_mode(res_type) == mode_b) { - set_method_res_type(method_type, i, create_lowered_type()); - } - } -} - static ir_node *lower_node(ir_node *node) { dbg_info *dbgi = get_irn_dbg_info(node); ir_node *block = get_nodes_block(node); - ir_mode *mode = config->lowered_mode; + ir_mode *mode = lowered_mode; ir_node *res = (ir_node*)get_irn_link(node); ir_graph *irg; if (res != NULL) return res; + node = skip_Tuple(node); + assert(get_irn_mode(node) == mode_b); irg = get_irn_irg(node); @@ -212,11 +141,10 @@ static ir_node *lower_node(ir_node *node) * nodes and this Phi might have them (indirectly) as operands, so they * would be replaced twice. */ set_irn_link(node, new_phi); - ARR_APP1(ir_node*, lowered_nodes, node); for (i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); - ir_node *lowered_in = is_Bad(in) ? in : lower_node(in); + ir_node *lowered_in = lower_node(in); set_irn_n(new_phi, i, lowered_in); } @@ -266,17 +194,6 @@ static ir_node *lower_node(ir_node *node) break; } - case iro_Conv: { - ir_node *pred = get_Conv_op(node); - ir_mode *mode = get_irn_mode(pred); - ir_tarval *tv_zeroc = get_mode_null(mode); - ir_node *zero_cmp = new_rd_Const(dbgi, irg, tv_zeroc); - - ir_node *cmp = new_rd_Cmp(dbgi, block, pred, zero_cmp, ir_relation_less_greater); - res = config->create_set(cmp); - break; - } - case iro_Cmp: { ir_node *left = get_Cmp_left(node); ir_node *right = get_Cmp_right(node); @@ -332,30 +249,7 @@ static ir_node *lower_node(ir_node *node) } else { /* synthesize the 0/1 value */ synth_zero_one: - res = config->create_set(node); - } - break; - } - - case iro_Proj: { - ir_node *pred = get_Proj_pred(node); - - if (is_Proj(pred) && is_Call(get_Proj_pred(pred))) { - ir_type *type = get_Call_type(get_Proj_pred(pred)); - adjust_method_type(type); - set_irn_mode(node, mode); - res = node; - goto own_replacement; - } else if (is_Proj(pred) && is_Start(get_Proj_pred(pred))) { - ir_graph *irg = get_irn_irg(node); - ir_entity *entity = get_irg_entity(irg); - ir_type *type = get_entity_type(entity); - adjust_method_type(type); - set_irn_mode(node, mode); - res = node; - goto own_replacement; - } else { - panic("unexpected projb: %+F (pred: %+F)", node, pred); + res = create_cond_set(node, mode); } break; } @@ -378,98 +272,95 @@ synth_zero_one: res = new_r_Unknown(irg, mode); break; + case iro_Bad: + res = new_r_Bad(irg, mode); + break; + default: - panic("didn't expect %+F to have mode_b", node); + panic("Don't know how to lower mode_b node %+F", node); } - ARR_APP1(ir_node*, lowered_nodes, node); -own_replacement: set_irn_link(node, res); return res; } -static void lower_mode_b_walker(ir_node *node, void *env) +static bool needs_mode_b_input(const ir_node *node, int input) { - int i, arity; - bool changed = false; + return (is_Cond(node) && input == n_Cond_selector) + || (is_Mux(node) && input == n_Mux_sel); +} + +/** + * Collects "roots" of a mode_b calculation. These are nodes which require a + * mode_b input (Cond, Mux, Conv(xxx_b)) + */ +static void collect_needs_lowering(ir_node *node, void *env) +{ + int arity = get_irn_arity(node); + int i; + (void) env; + + /* if the node produces mode_b then it is a not a root (but should be + * something our lower_node function can handle) */ + if (get_irn_mode(node) == mode_b) { + assert(is_And(node) || is_Or(node) || is_Eor(node) || is_Phi(node) + || is_Not(node) || is_Mux(node) || is_Cmp(node) + || is_Const(node) || is_Unknown(node) || is_Bad(node)); + return; + } - arity = get_irn_arity(node); for (i = 0; i < arity; ++i) { - ir_node *lowered_in; + needs_lowering_t entry; ir_node *in = get_irn_n(node, i); if (get_irn_mode(in) != mode_b) continue; + if (is_Cmp(in) && needs_mode_b_input(node, i)) + continue; - if (! config->lower_direct_cmp) { - /* Cmp as input for Cond and Mux nodes needs no changes. - (Mux with mode_b is an exception as it gets replaced by and/or - anyway so we still lower the inputs then) */ - if (is_Cond(node) || - (is_Mux(node) && get_irn_mode(node) != mode_b)) { - if (is_Cmp(in)) { - continue; - } - } - } - - lowered_in = lower_node(in); - - if (is_Call(node)) { - ir_type *type = get_Call_type(node); - adjust_method_type(type); - } else if (is_Cond(node) || (is_Mux(node) && i == 0)) { - lowered_in = create_convb(lowered_in); - } - set_irn_n(node, i, lowered_in); - changed = true; - } - if (changed) { - bool *global_changed = (bool*)env; - *global_changed = true; - add_identities(node); + entry.node = node; + entry.input = i; + ARR_APP1(needs_lowering_t, needs_lowering, entry); } } -void ir_lower_mode_b(ir_graph *irg, const lower_mode_b_config_t *nconfig) +void ir_lower_mode_b(ir_graph *const irg, ir_mode *const nlowered_mode) { - ir_entity *entity = get_irg_entity(irg); - ir_type *type = get_entity_type(entity); - bool changed = false; - size_t i; - size_t n; + size_t i; + size_t n; - config = nconfig; - lowered_nodes = NEW_ARR_F(ir_node*, 0); - check_later = NEW_ARR_F(ir_node*, 0); - lowered_type = NULL; + lowered_mode = nlowered_mode; + /* edges are used by part_block_edges in the ir_create_cond_set variant. */ edges_assure(irg); - /* ensure no optimisation touches muxes anymore */ - set_irg_state(irg, IR_GRAPH_STATE_KEEP_MUX | IR_GRAPH_STATE_BCONV_ALLOWED); - + set_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED); ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); - adjust_method_type(type); + needs_lowering = NEW_ARR_F(needs_lowering_t, 0); - irg_walk_graph(irg, firm_clear_link, NULL, NULL); - irg_walk_graph(irg, lower_mode_b_walker, NULL, &changed); + irg_walk_graph(irg, firm_clear_link, collect_needs_lowering, NULL); - for (i = 0, n = ARR_LEN(check_later); i < n; ++i) { - ir_node *node = check_later[i]; - irg_walk_core(node, lower_mode_b_walker, NULL, &changed); - } + n = ARR_LEN(needs_lowering); + for (i = 0; i < n; ++i) { + const needs_lowering_t *entry = &needs_lowering[i]; + ir_node *node = entry->node; + int input = entry->input; + ir_node *in = get_irn_n(node, input); + ir_node *lowered = lower_node(in); - for (i = 0, n = ARR_LEN(lowered_nodes); i < n; ++i) { - ir_node *node = lowered_nodes[i]; - maybe_kill_node(node); + if (needs_mode_b_input(node, input)) + lowered = convert_to_modeb(lowered); + set_irn_n(node, input, lowered); } - DEL_ARR_F(check_later); - DEL_ARR_F(lowered_nodes); ir_free_resources(irg, IR_RESOURCE_IRN_LINK); - if (changed) { - set_irg_outs_inconsistent(irg); + DEL_ARR_F(needs_lowering); + + if (n > 0) { + /* lowering might create new blocks, so be sure to handle this */ + clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE + | IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS); + edges_deactivate(irg); } }