X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbessaconstr.c;h=768280ad6c456dacfe3bdd20bcefd840a5bdbef5;hb=0ac0b440ce2d239c5e7e7db56b8273559d9a7741;hp=257ea7238aaf1a010d6fb85f52d15610bf5fad99;hpb=b9e024a7134d3f7483b792027dbf7392b928b4da;p=libfirm diff --git a/ir/be/bessaconstr.c b/ir/be/bessaconstr.c index 257ea7238..768280ad6 100644 --- a/ir/be/bessaconstr.c +++ b/ir/be/bessaconstr.c @@ -1,35 +1,21 @@ /* - * Copyright (C) 1995-2008 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. */ /** * @file * @brief SSA construction for a set of nodes - * @author Sebastian Hack, Daniel Grund, Matthias Braun, Christian Wuerdig + * @author Sebastian Hack, Daniel Grund, Matthias Braun, Christian Wuerdig, + * Sebastian Buchwald * @date 04.05.2005 - * @version $Id$ * * The problem: Given a value and a set of "copies" that are known to * represent the same abstract value, rewire all usages of the original value * to their closest copy while introducing phis as necessary. * * Algorithm: Mark all blocks in the iterated dominance frontiers of the value - * and it's copies. Link the copies ordered by dominance to the blocks. Then + * and its copies. Link the copies ordered by dominance to the blocks. Then * we search for each use all definitions in the current block, if none is * found, then we search one in the immediate dominator. If we are in a block * of the dominance frontier, create a phi and do the same search for all @@ -46,34 +32,134 @@ * This function reroutes all uses of the original value to the copies in the * corresponding dominance subtrees and creates Phi functions where necessary. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif + +/* statev in this file is extensive, so only enable if needed */ +#define DISABLE_STATEV #include "bessaconstr.h" #include "bemodule.h" -#include "besched_t.h" +#include "besched.h" #include "beintlive_t.h" -#include "beirg_t.h" +#include "beirg.h" #include "be_t.h" +#include "benode.h" #include "debug.h" #include "error.h" #include "pdeq.h" #include "array.h" #include "irdom.h" +#include "irnodeset.h" #include "ircons.h" #include "iredges_t.h" +#include "statev_t.h" DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) +static ir_node *search_def_end_of_block(be_ssa_construction_env_t *env, + ir_node *block); + +struct constr_info { + bool is_definition : 1; + bool is_use : 1; + bool already_processed : 1; + union { + /* Since we only consider scheduled nodes, + * this points to the real definition (e.g. a Proj). */ + ir_node *definition; + + /* Last definition of a block. */ + ir_node *last_definition; + } u; +}; + +typedef struct constr_info constr_info; + /** - * Checks that low <= what < hi. + * @return Whether the block contains a definition. */ -static INLINE int is_inside(unsigned what, unsigned low, unsigned hi) +static bool has_definition(const ir_node *block) { - return what - low < hi; + return irn_visited(block); +} + +static constr_info *get_or_set_info(be_ssa_construction_env_t *env, + const ir_node *node) +{ + constr_info *info = ir_nodemap_get(constr_info, &env->infos, node); + if (info == NULL) { + info = OALLOCZ(&env->obst, constr_info); + ir_nodemap_insert(&env->infos, node, info); + } + return info; +} + +static constr_info *get_info(const be_ssa_construction_env_t *env, + const ir_node *node) +{ + return ir_nodemap_get(constr_info, &env->infos, node); +} + +/** + * @return Whether the block contains a use. + */ +static inline bool has_use(be_ssa_construction_env_t *env, ir_node *block) +{ + constr_info *info = get_or_set_info(env, block); + return info->is_use; +} + +/** + * @return Whether the node is a definition. + */ +static bool is_definition(be_ssa_construction_env_t *env, ir_node *node) +{ + constr_info *info = get_info(env, node); + return info != NULL && info->is_definition; +} + +/** + * Introduces a definition at the corresponding block. + */ +static void introduce_definition(be_ssa_construction_env_t *env, ir_node *def) +{ + ir_node *block = get_nodes_block(def); + constr_info *def_info = get_or_set_info(env, def); + ir_node *skip = skip_Proj(def); + constr_info *skip_info = get_or_set_info(env, skip); + constr_info *block_info = get_or_set_info(env, block); + + DBG((dbg, LEVEL_2, "\tintroducing definition %+F in %+F\n", def, block)); + + def_info->is_definition = true; + + skip_info->is_definition = true; + skip_info->u.definition = def; + + // Set the last definition if we only introduce one definition for the block + if (has_definition(block)) { + assert(!block_info->already_processed); + block_info->u.last_definition = NULL; + } else { + mark_irn_visited(block); + block_info->u.last_definition = def; + } +} + +static void introduce_use(be_ssa_construction_env_t *env, ir_node *use) +{ + ir_node *block = get_nodes_block(use); + constr_info *info = get_or_set_info(env, use); + constr_info *block_info = get_or_set_info(env, block); + + DBG((dbg, LEVEL_2, "\tintroducing use %+F in %+F\n", use, block)); + + info->is_use = true; + block_info->is_use = true; + + waitq_put(env->worklist, use); } /** @@ -81,16 +167,16 @@ static INLINE int is_inside(unsigned what, unsigned low, unsigned hi) * blocks as visited. Sets the link fields of the blocks in the dominance * frontier to the block itself. */ -static -void mark_iterated_dominance_frontiers(const be_ssa_construction_env_t *env) +static void mark_iterated_dominance_frontiers( + const be_ssa_construction_env_t *env) { stat_ev_cnt_decl(blocks); DBG((dbg, LEVEL_3, "Dominance Frontier:")); stat_ev_tim_push(); while (!waitq_empty(env->worklist)) { int i; - ir_node *block = waitq_get(env->worklist); - ir_node **domfront = be_get_dominance_frontier(env->domfronts, block); + ir_node *block = (ir_node*)waitq_get(env->worklist); + ir_node **domfront = ir_get_dominance_frontier(block); int domfront_len = ARR_LEN(domfront); for (i = 0; i < domfront_len; ++i) { @@ -98,16 +184,6 @@ void mark_iterated_dominance_frontiers(const be_ssa_construction_env_t *env) if (Block_block_visited(y)) continue; - /* - * It makes no sense to add phi-functions to blocks - * that are not dominated by any definition; - * all uses are dominated, hence the paths reaching the uses - * have to stay in the dominance subtrees of the given definitions. - */ - - if (!is_inside(get_Block_dom_tree_pre_num(y), env->min_dom, env->max_dom)) - continue; - if (!irn_visited(y)) { set_irn_link(y, NULL); waitq_put(env->worklist, y); @@ -123,181 +199,202 @@ void mark_iterated_dominance_frontiers(const be_ssa_construction_env_t *env) DBG((dbg, LEVEL_3, "\n")); } -static -ir_node *search_def_end_of_block(be_ssa_construction_env_t *env, - ir_node *block); - -static -ir_node *create_phi(be_ssa_construction_env_t *env, ir_node *block, - ir_node *link_with) +/** + * Inserts a new phi at the given block. + * + * The constructed phi has only Dummy operands, + * but can be used as definition for other nodes. + * + * @see fix_phi_arguments + */ +static ir_node *insert_dummy_phi(be_ssa_construction_env_t *env, ir_node *block) { int i, n_preds = get_Block_n_cfgpreds(block); - ir_graph *irg = get_irn_irg(block); - ir_node *phi; - ir_node **ins = alloca(n_preds * sizeof(ins[0])); + ir_graph *irg = get_Block_irg(block); + ir_node **ins = ALLOCAN(ir_node*, n_preds); + ir_node *dummy; + ir_node *phi; - assert(n_preds > 1); + DBG((dbg, LEVEL_3, "\t...create phi at block %+F\n", block)); - for(i = 0; i < n_preds; ++i) { - ins[i] = new_r_Unknown(irg, env->mode); - } - phi = new_r_Phi(irg, block, n_preds, ins, env->mode); - if(env->new_phis != NULL) { - ARR_APP1(ir_node*, env->new_phis, phi); - } + assert(n_preds > 1); - if(env->mode != mode_M) { - sched_add_after(block, phi); + dummy = new_r_Dummy(irg, env->mode); + for (i = 0; i < n_preds; ++i) { + ins[i] = dummy; } + phi = be_new_Phi(block, n_preds, ins, env->mode, env->phi_req); + sched_add_after(block, phi); + ARR_APP1(ir_node*, env->new_phis, phi); DBG((dbg, LEVEL_2, "\tcreating phi %+F in %+F\n", phi, block)); - set_irn_link(link_with, phi); - mark_irn_visited(block); + introduce_definition(env, phi); - for(i = 0; i < n_preds; ++i) { - ir_node *pred_block = get_Block_cfgpred_block(block, i); - ir_node *pred_def = search_def_end_of_block(env, pred_block); - - set_irn_n(phi, i, pred_def); - } + waitq_put(env->worklist, phi); return phi; } -static -ir_node *get_def_at_idom(be_ssa_construction_env_t *env, ir_node *block) +/** + * @return Last definition of the immediate dominator. + */ +static ir_node *get_def_at_idom(be_ssa_construction_env_t *env, ir_node *block) { ir_node *dom = get_Block_idom(block); assert(dom != NULL); + DBG((dbg, LEVEL_3, "\t...continue at idom %+F\n", dom)); return search_def_end_of_block(env, dom); } -static -ir_node *search_def_end_of_block(be_ssa_construction_env_t *env, ir_node *block) +static ir_node *get_def_from_preds(be_ssa_construction_env_t *const env, ir_node *const block) { - if(irn_visited(block)) { - assert(get_irn_link(block) != NULL); - return get_irn_link(block); - } else if(Block_block_visited(block)) { - return create_phi(env, block, block); + /* Create a phi if the block is in the dominance frontier. */ + if (Block_block_visited(block)) { + return insert_dummy_phi(env, block); } else { - ir_node *def = get_def_at_idom(env, block); - mark_irn_visited(block); - set_irn_link(block, def); - return def; + return get_def_at_idom(env, block); } } -static -ir_node *search_def(be_ssa_construction_env_t *env, ir_node *at) +/** + * Fixes all operands of a use. + * + * If an operand of the use is a (original) definition, + * it will be replaced by the given definition. + */ +static void set_operands(be_ssa_construction_env_t *env, ir_node *use, ir_node *def, constr_info *const use_info) { - ir_node *block = get_nodes_block(at); - ir_node *node; - ir_node *def; - - DBG((dbg, LEVEL_3, "\t...searching def at %+F\n", at)); + int arity = get_irn_arity(use); + for (int i = 0; i < arity; ++i) { + ir_node *op = get_irn_n(use, i); - /* no defs in the current block we can do the normal searching */ - if(!irn_visited(block) && !Block_block_visited(block)) { - DBG((dbg, LEVEL_3, "\t...continue at idom\n")); - return get_def_at_idom(env, block); - } - - /* there are defs in the current block, walk the linked list to find - the one immediately dominating us - */ - node = block; - def = get_irn_link(node); - while(def != NULL) { - if(!value_dominates(at, def)) { - DBG((dbg, LEVEL_3, "\t...found dominating def %+F\n", def)); - return def; + if (is_definition(env, op)) { + DBG((dbg, LEVEL_1, "\t...%+F(%d) -> %+F\n", use, i, def)); + set_irn_n(use, i, def); } - - node = def; - def = get_irn_link(node); } - /* block in dominance frontier? create a phi then */ - if(Block_block_visited(block)) { - DBG((dbg, LEVEL_3, "\t...create phi at block %+F\n", block)); - assert(!is_Phi(node)); - return create_phi(env, block, node); - } - - DBG((dbg, LEVEL_3, "\t...continue at idom (after checking block)\n")); - return get_def_at_idom(env, block); + use_info->already_processed = true; } -static -void update_domzone(be_ssa_construction_env_t *env, const ir_node *bl) +/** + * Fixes all uses of the given block. + */ +static void process_block(be_ssa_construction_env_t *env, ir_node *block) { - int start = get_Block_dom_tree_pre_num(bl); - int end = get_Block_dom_max_subtree_pre_num(bl) + 1; + ir_node *def = NULL; + constr_info *block_info = get_or_set_info(env, block); + + assert(has_definition(block)); + assert(!block_info->already_processed && "Block already processed"); + + DBG((dbg, LEVEL_3, "\tprocessing block %+F\n", block)); + + sched_foreach(block, node) { + constr_info *const info = get_info(env, node); + if (!info) + continue; + + if (info->is_use && !is_Phi(node)) { + DBG((dbg, LEVEL_3, "\t...found use %+F\n", node)); + + if (def == NULL) { + /* Create a phi if the block is in the dominance frontier. */ + def = get_def_from_preds(env, block); + } + + set_operands(env, node, def, info); + } + + if (info->is_definition) { + def = info->u.definition; + DBG((dbg, LEVEL_3, "\t...found definition %+F\n", def)); + } + } - env->min_dom = MIN(env->min_dom, start); - env->max_dom = MAX(env->max_dom, end); + block_info->already_processed = true; + block_info->u.last_definition = def; } /** - * Adds a definition into the link field of the block. The definitions are - * sorted by dominance. A non-visited block means no definition has been - * inserted yet. + * @return Last definition of the given block. */ -static -void introduce_def_at_block(ir_node *block, ir_node *def) +static ir_node *search_def_end_of_block(be_ssa_construction_env_t *env, + ir_node *block) { - if(irn_visited(block)) { - ir_node *node = block; - ir_node *current_def; - - while(1) { - current_def = get_irn_link(node); - if(current_def == def) { - /* already in block */ - return; + constr_info *block_info = get_or_set_info(env, block); + ir_node *last_definition = block_info->u.last_definition; + + if (last_definition != NULL) + return last_definition; + + if (has_definition(block)) { + if (has_use(env, block)) { + if (!block_info->already_processed) { + process_block(env, block); } - if(current_def == NULL) - break; - if(value_dominates(current_def, def)) - break; - node = current_def; + } + else { + /* Search the last definition of the block. */ + sched_foreach_reverse(block, def) { + constr_info const *const info = get_info(env, def); + if (info && info->is_definition) { + DBG((dbg, LEVEL_3, "\t...found definition %+F\n", info->u.definition)); + block_info->u.last_definition = info->u.definition; + break; + } + } + + assert(block_info->u.last_definition && "No definition found"); } - set_irn_link(node, def); - set_irn_link(def, current_def); + return block_info->u.last_definition; } else { - set_irn_link(block, def); - set_irn_link(def, NULL); - mark_irn_visited(block); + ir_node *const def = get_def_from_preds(env, block); + block_info->u.last_definition = def; + return def; } } -void be_ssa_construction_init(be_ssa_construction_env_t *env, be_irg_t *birg) +/** + * Fixes all operands of the given use. + */ +static void search_def_at_block(be_ssa_construction_env_t *const env, ir_node *const use, constr_info *const info) { - ir_graph *irg = be_get_birg_irg(birg); - ir_node *sb = get_irg_start_block(irg); - int n_blocks = get_Block_dom_max_subtree_pre_num(sb); + ir_node *block = get_nodes_block(use); + constr_info *block_info = get_or_set_info(env, block); - stat_ev_ctx_push_fobj("bessaconstr", irg); + if (block_info->already_processed) + return; + + if (has_definition(block)) { + process_block(env, block); + } else { + ir_node *const def = get_def_from_preds(env, block); + set_operands(env, use, def, info); + } +} + +void be_ssa_construction_init(be_ssa_construction_env_t *env, ir_graph *irg) +{ + stat_ev_ctx_push_fmt("bessaconstr", "%+F", irg); stat_ev_tim_push(); - (void) n_blocks; - stat_ev_dbl("bessaconstr_n_blocks", n_blocks); + stat_ev_dbl("bessaconstr_n_blocks", get_Block_dom_max_subtree_pre_num(get_irg_start_block(irg))); memset(env, 0, sizeof(env[0])); - be_assure_dom_front(birg); env->irg = irg; - env->domfronts = be_get_birg_dom_front(birg); env->new_phis = NEW_ARR_F(ir_node*, 0); env->worklist = new_waitq(); - env->min_dom = INT_MAX; - env->max_dom = 0; + ir_nodemap_init(&env->infos, irg); + obstack_init(&env->obst); - set_using_irn_visited(irg); - set_using_block_visited(irg); - set_using_irn_link(irg); + assure_irg_properties(env->irg, + IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS); + + ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED + | IR_RESOURCE_BLOCK_VISITED | IR_RESOURCE_IRN_LINK); /* we use the visited flag to indicate blocks in the dominance frontier * and blocks that already have the relevant value at the end calculated */ @@ -310,17 +407,36 @@ void be_ssa_construction_init(be_ssa_construction_env_t *env, be_irg_t *birg) void be_ssa_construction_destroy(be_ssa_construction_env_t *env) { stat_ev_int("bessaconstr_phis", ARR_LEN(env->new_phis)); + obstack_free(&env->obst, NULL); + ir_nodemap_destroy(&env->infos); del_waitq(env->worklist); DEL_ARR_F(env->new_phis); - clear_using_irn_visited(env->irg); - clear_using_block_visited(env->irg); - clear_using_irn_link(env->irg); + ir_free_resources(env->irg, IR_RESOURCE_IRN_VISITED + | IR_RESOURCE_BLOCK_VISITED | IR_RESOURCE_IRN_LINK); stat_ev_tim_pop("bessaconstr_total_time"); stat_ev_ctx_pop("bessaconstr"); } +static void determine_phi_req(be_ssa_construction_env_t *env, ir_node *value) +{ + const arch_register_req_t *req = arch_get_irn_register_req(value); + env->mode = get_irn_mode(value); + if (req->width == 1) { + env->phi_req = req->cls->class_req; + } else { + /* construct a new register req... */ + ir_graph *irg = get_irn_irg(value); + struct obstack *obst = be_get_be_obst(irg); + arch_register_req_t *new_req = OALLOCZ(obst, arch_register_req_t); + new_req->cls = req->cls; + new_req->type = req->type & arch_register_req_type_aligned; + new_req->width = req->width; + env->phi_req = new_req; + } +} + void be_ssa_construction_add_copy(be_ssa_construction_env_t *env, ir_node *copy) { @@ -328,19 +444,18 @@ void be_ssa_construction_add_copy(be_ssa_construction_env_t *env, assert(env->iterated_domfront_calculated == 0); - if(env->mode == NULL) { - env->mode = get_irn_mode(copy); + if (env->mode == NULL) { + determine_phi_req(env, copy); } else { assert(env->mode == get_irn_mode(copy)); } block = get_nodes_block(copy); - if(!irn_visited(block)) { + if (!has_definition(block)) { waitq_put(env->worklist, block); } - introduce_def_at_block(block, copy); - update_domzone(env, block); + introduce_definition(env, copy); } void be_ssa_construction_add_copies(be_ssa_construction_env_t *env, @@ -350,86 +465,108 @@ void be_ssa_construction_add_copies(be_ssa_construction_env_t *env, assert(env->iterated_domfront_calculated == 0); - if(env->mode == NULL) { - env->mode = get_irn_mode(copies[0]); + if (env->mode == NULL) { + determine_phi_req(env, copies[0]); } - for(i = 0; i < copies_len; ++i) { - ir_node *copy = copies[i]; + for (i = 0; i < copies_len; ++i) { + ir_node *copy = copies[i]; ir_node *block = get_nodes_block(copy); assert(env->mode == get_irn_mode(copy)); - if(!irn_visited(block)) { + if (!has_definition(block)) { waitq_put(env->worklist, block); } - introduce_def_at_block(block, copy); - update_domzone(env, block); + introduce_definition(env, copy); } } -void be_ssa_construction_set_ignore_uses(be_ssa_construction_env_t *env, - const ir_nodeset_t *ignore_uses) +ir_node **be_ssa_construction_get_new_phis(be_ssa_construction_env_t *env) { - env->ignore_uses = ignore_uses; + return env->new_phis; } -ir_node **be_ssa_construction_get_new_phis(be_ssa_construction_env_t *env) +/** + * Fixes all arguments of a newly constructed phi. + * + * @see insert_dummy_phi + */ +static void fix_phi_arguments(be_ssa_construction_env_t *const env, ir_node *const phi, constr_info *const info) { - return env->new_phis; + ir_node *block = get_nodes_block(phi); + int n_preds = get_Block_n_cfgpreds(block); + + DBG((dbg, LEVEL_3, "\tfixing phi arguments %+F\n", phi)); + + for (int i = 0; i < n_preds; ++i) { + ir_node *op = get_irn_n(phi, i); + + if (is_definition(env, op) || is_Dummy(op)) { + ir_node *pred_block = get_Block_cfgpred_block(block, i); + ir_node *pred_def = search_def_end_of_block(env, pred_block); + + DBG((dbg, LEVEL_1, "\t...%+F(%d) -> %+F\n", phi, i, pred_def)); + set_irn_n(phi, i, pred_def); + } + } + + info->already_processed = true; } void be_ssa_construction_fix_users_array(be_ssa_construction_env_t *env, ir_node **nodes, size_t nodes_len) { - stat_ev_cnt_decl(uses); - const ir_edge_t *edge, *next; size_t i; + stat_ev_cnt_decl(uses); - BE_TIMER_PUSH(t_ssa_constr); + be_timer_push(T_SSA_CONSTR); - if(!env->iterated_domfront_calculated) { + if (!env->iterated_domfront_calculated) { mark_iterated_dominance_frontiers(env); env->iterated_domfront_calculated = 1; } - stat_ev_int("bessaconstr_domzone", env->max_dom - env->min_dom); + DBG((dbg, LEVEL_1, "\tfixing users array\n")); + + assert(waitq_empty(env->worklist)); + stat_ev_tim_push(); - for(i = 0; i < nodes_len; ++i) { + + for (i = 0; i < nodes_len; ++i) { ir_node *value = nodes[i]; + DBG((dbg, LEVEL_3, "\tfixing users of %+F\n", value)); + introduce_definition(env, value); - /* - * Search the valid def for each use and set it. - */ - foreach_out_edge_safe(value, edge, next) { - ir_node *use = get_edge_src_irn(edge); - ir_node *at = use; - int pos = get_edge_src_pos(edge); - ir_node *def; - - if(env->ignore_uses != NULL && - ir_nodeset_contains(env->ignore_uses, use)) - continue; - if(is_Anchor(use)) + foreach_out_edge_safe(value, edge) { + ir_node *const use = get_edge_src_irn(edge); + if (is_Anchor(use) || is_End(use)) continue; - if(is_Phi(use)) { - ir_node *block = get_nodes_block(use); - ir_node *predblock = get_Block_cfgpred_block(block, pos); - at = sched_last(predblock); - } + introduce_use(env, use); + } + } - def = search_def(env, at); + assert(!waitq_empty(env->worklist)); - if(def == NULL) { - panic("no definition found for %+F at position %d\n", use, pos); - } + while (!waitq_empty(env->worklist)) { + ir_node *use = (ir_node *)waitq_get(env->worklist); + constr_info *info = get_info(env, use); + + if (info->already_processed) + continue; - DBG((dbg, LEVEL_2, "\t%+F(%d) -> %+F\n", use, pos, def)); - set_irn_n(use, pos, def); - stat_ev_cnt_inc(uses); + if (is_Phi(use)) { + fix_phi_arguments(env, use, info); } + else { + DBG((dbg, LEVEL_3, "\tsearching def for %+F at %+F\n", use, get_nodes_block(use))); + search_def_at_block(env, use, info); + } + + stat_ev_cnt_inc(uses); } - BE_TIMER_POP(t_ssa_constr); + + be_timer_pop(T_SSA_CONSTR); stat_ev_tim_pop("bessaconstr_fix_time"); stat_ev_cnt_done(uses, "bessaconstr_uses"); @@ -446,20 +583,19 @@ void be_ssa_construction_update_liveness_phis(be_ssa_construction_env_t *env, { int i, n; - BE_TIMER_PUSH(t_ssa_constr); + be_timer_push(T_SSA_CONSTR); n = ARR_LEN(env->new_phis); - for(i = 0; i < n; ++i) { + for (i = 0; i < n; ++i) { ir_node *phi = env->new_phis[i]; be_liveness_introduce(lv, phi); } - BE_TIMER_POP(t_ssa_constr); + be_timer_pop(T_SSA_CONSTR); } +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_ssaconstr) void be_init_ssaconstr(void) { FIRM_DBG_REGISTER(dbg, "firm.be.ssaconstr"); } - -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_ssaconstr);