X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=inline;f=ir%2Fbe%2Fbeilpsched.c;h=dd8fc9a17f4a6b8089c2819c3982b59aeb06a0d0;hb=5bb8cd35a8074112fa2da8b8f68d7c77918119e5;hp=aada7763172b2c5bdbec1c88d70c1597939cb4cc;hpb=44dd4365d606bc60bbbf97200b89c903d788ce45;p=libfirm diff --git a/ir/be/beilpsched.c b/ir/be/beilpsched.c index aada77631..dd8fc9a17 100644 --- a/ir/be/beilpsched.c +++ b/ir/be/beilpsched.c @@ -69,6 +69,7 @@ #include "beirg.h" #include "bemachine.h" #include "belistsched.h" +#include "bemodule.h" typedef struct _ilpsched_options_t { unsigned regpress; @@ -191,10 +192,6 @@ typedef struct { /* check if a double value is within an epsilon environment of 0 */ #define LPP_VALUE_IS_0(dbl) (fabs((dbl)) <= 1e-10) -#define ilp_timer_push(t) ir_timer_push((t)) -#define ilp_timer_pop() ir_timer_pop() -#define ilp_timer_elapsed_usec(t) ir_timer_elapsed_usec((t)) - /* option variable */ static ilpsched_options_t ilp_opts = { 1, /* default is with register pressure constraints */ @@ -220,7 +217,8 @@ static heights_t *glob_heights; * Check if irn is a Proj, which has no execution units assigned. * @return 1 if irn is a Proj having no execution units assigned, 0 otherwise */ -static inline int is_normal_Proj(const arch_env_t *env, const ir_node *irn) { +static inline int is_normal_Proj(const arch_env_t *env, const ir_node *irn) +{ return is_Proj(irn) && (arch_env_get_allowed_execution_units(env, irn) == NULL); } @@ -228,20 +226,23 @@ static inline int is_normal_Proj(const arch_env_t *env, const ir_node *irn) { * Skips normal Projs. * @return predecessor if irn is a normal Proj, otherwise irn. */ -static inline ir_node *skip_normal_Proj(const arch_env_t *env, ir_node *irn) { +static inline ir_node *skip_normal_Proj(const arch_env_t *env, ir_node *irn) +{ if (is_normal_Proj(env, irn)) return get_Proj_pred(irn); return irn; } -static inline int fixed_latency(const ilp_sched_selector_t *sel, ir_node *irn, void *env) { +static inline int fixed_latency(const ilp_sched_selector_t *sel, ir_node *irn, void *env) +{ unsigned lat = be_ilp_sched_latency(sel, irn, env); if (lat == 0 && ! is_Proj(irn) && ! be_is_Keep(irn)) lat = 1; return lat; } -static int cmp_live_in_nodes(const void *a, const void *b) { +static int cmp_live_in_nodes(const void *a, const void *b) +{ const ilp_livein_node_t *n1 = a; const ilp_livein_node_t *n2 = b; @@ -251,7 +252,8 @@ static int cmp_live_in_nodes(const void *a, const void *b) { /** * Compare scheduling time steps of two be_ilpsched_irn's. */ -static int cmp_ilpsched_irn(const void *a, const void *b) { +static int cmp_ilpsched_irn(const void *a, const void *b) +{ be_ilpsched_irn_t *n1 = *(be_ilpsched_irn_t **)a; be_ilpsched_irn_t *n2 = *(be_ilpsched_irn_t **)b; ilpsched_node_attr_t *n1_a = get_ilpsched_node_attr(n1); @@ -279,7 +281,8 @@ static int cmp_ilpsched_irn(const void *a, const void *b) { /** * In case there is no phase information for irn, initialize it. */ -static void *init_ilpsched_irn(ir_phase *ph, const ir_node *irn, void *old) { +static void *init_ilpsched_irn(ir_phase *ph, const ir_node *irn, void *old) +{ be_ilpsched_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0])); if (res == old) { @@ -330,7 +333,8 @@ static void *init_ilpsched_irn(ir_phase *ph, const ir_node *irn, void *old) { /** * Assign a per block unique number to each node. */ -static void build_block_idx(ir_node *irn, void *walk_env) { +static void build_block_idx(ir_node *irn, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; be_ilpsched_irn_t *node, *block_node; ilpsched_node_attr_t *na; @@ -362,7 +366,8 @@ static void build_block_idx(ir_node *irn, void *walk_env) { /** * Add all nodes having no user in current block to last_nodes list. */ -static void collect_alap_root_nodes(ir_node *irn, void *walk_env) { +static void collect_alap_root_nodes(ir_node *irn, void *walk_env) +{ ir_node *block; const ir_edge_t *edge; be_ilpsched_irn_t *block_node, *node; @@ -483,7 +488,8 @@ static void collect_alap_root_nodes(ir_node *irn, void *walk_env) { /** * Calculate the ASAP scheduling step for current irn. */ -static void calculate_irn_asap(ir_node *irn, void *walk_env) { +static void calculate_irn_asap(ir_node *irn, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; int i; ir_node *block; @@ -532,7 +538,8 @@ static void calculate_irn_asap(ir_node *irn, void *walk_env) { * Calculate the ALAP scheduling step of all irns in current block. * Depends on max_steps being calculated. */ -static void calculate_block_alap(ir_node *block, void *walk_env) { +static void calculate_block_alap(ir_node *block, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; be_ilpsched_irn_t *block_node = get_ilpsched_irn(env, block); ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); @@ -625,7 +632,8 @@ static void calculate_block_alap(ir_node *block, void *walk_env) { /** * Free list of root nodes and the set of live-in nodes. */ -static void clear_unwanted_data(ir_node *block, void *walk_env) { +static void clear_unwanted_data(ir_node *block, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; be_ilpsched_irn_t *block_node = get_ilpsched_irn(env, block); ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); @@ -640,7 +648,8 @@ static void clear_unwanted_data(ir_node *block, void *walk_env) { * Refine the {ASAP(n), ALAP(n)} interval for the nodes. * Set the ASAP/ALAP times of Projs and Keeps to their ancestor ones. */ -static void refine_asap_alap_times(ir_node *irn, void *walk_env) { +static void refine_asap_alap_times(ir_node *irn, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; ir_node *pred = irn; be_ilpsched_irn_t *node, *pred_node; @@ -683,7 +692,8 @@ static void refine_asap_alap_times(ir_node *irn, void *walk_env) { * *******************************************/ -static inline void check_for_keeps(waitq *keeps, const ir_node *block, const ir_node *irn) { +static inline void check_for_keeps(waitq *keeps, const ir_node *block, const ir_node *irn) +{ const ir_edge_t *edge; (void) block; @@ -711,7 +721,8 @@ static inline void notified_sched_add_before(be_ilpsched_env_t *env, * Adds a node, it's Projs (in case of mode_T nodes) and * it's Keeps to schedule. */ -static void add_to_sched(be_ilpsched_env_t *env, const ir_node *block, const ir_node *irn, unsigned cycle) { +static void add_to_sched(be_ilpsched_env_t *env, const ir_node *block, const ir_node *irn, unsigned cycle) +{ const ir_edge_t *edge; waitq *keeps = new_waitq(); @@ -753,7 +764,8 @@ static void add_to_sched(be_ilpsched_env_t *env, const ir_node *block, const ir_ /** * Schedule all nodes in the given block, according to the ILP solution. */ -static void apply_solution(be_ilpsched_env_t *env, lpp_t *lpp, ir_node *block) { +static void apply_solution(be_ilpsched_env_t *env, lpp_t *lpp, ir_node *block) +{ be_ilpsched_irn_t *block_node = get_ilpsched_irn(env, block); ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); be_ilpsched_irn_t **sched_nodes; @@ -875,7 +887,8 @@ static void apply_solution(be_ilpsched_env_t *env, lpp_t *lpp, ir_node *block) { /** * Check if node can be executed on given unit type. */ -static inline int is_valid_unit_type_for_node(const be_execution_unit_type_t *tp, be_ilpsched_irn_t *node) { +static inline int is_valid_unit_type_for_node(const be_execution_unit_type_t *tp, be_ilpsched_irn_t *node) +{ int i; ilpsched_node_attr_t *na = get_ilpsched_node_attr(node); @@ -897,7 +910,8 @@ static inline int is_valid_unit_type_for_node(const be_execution_unit_type_t *tp * ************************************************/ -static int be_ilpsched_set_type_info(be_ilpsched_env_t *env, ir_node *irn, struct obstack *obst) { +static int be_ilpsched_set_type_info(be_ilpsched_env_t *env, ir_node *irn, struct obstack *obst) +{ const be_execution_unit_t ***execunits = arch_env_get_allowed_execution_units(env->arch_env, irn); unsigned n_unit_types = 0; be_ilpsched_irn_t *node; @@ -935,7 +949,8 @@ static int be_ilpsched_set_type_info(be_ilpsched_env_t *env, ir_node *irn, struc * Returns the largest alap time of a user of @p irn. * The user must be in block @p block. */ -static unsigned be_ilpsched_get_max_alap_user(be_ilpsched_env_t *env, const ir_node *irn, const ir_node *block) { +static unsigned be_ilpsched_get_max_alap_user(be_ilpsched_env_t *env, const ir_node *irn, const ir_node *block) +{ const ir_edge_t *edge; unsigned max_alap = 0; @@ -968,16 +983,17 @@ static unsigned be_ilpsched_get_max_alap_user(be_ilpsched_env_t *env, const ir_n * ==>> These variables represent the register pressure * */ -static void create_variables(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node, struct obstack *var_obst) { +static void create_variables(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node, struct obstack *var_obst) +{ char buf[1024]; ir_node *irn; unsigned num_block_var, num_nodes; ilp_livein_node_t *livein; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); unsigned weigth_y = ba->n_interesting_nodes * ba->n_interesting_nodes; - ir_timer_t *t_var = ir_timer_register("beilpsched_var", "create ilp variables"); - ilp_timer_push(t_var); + stat_ev_tim_push(); + num_block_var = num_nodes = 0; foreach_linked_irns(ba->head_ilp_nodes, irn) { be_ilpsched_irn_t *node; @@ -1102,9 +1118,7 @@ static void create_variables(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "... %u variables for %u nodes created (%g sec)\n", - num_block_var, num_nodes, ilp_timer_elapsed_usec(t_var) / 1000000.0)); + stat_ev_tim_pop("beilpsched_var"); } /******************************************************* @@ -1121,7 +1135,8 @@ static void create_variables(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn * Collect all operands and nodes @p irn depends on. * If there is a Proj within the dependencies, all other Projs of the parent node are added as well. */ -static void sta_collect_in_deps(ir_node *irn, ir_nodeset_t *deps) { +static void sta_collect_in_deps(ir_node *irn, ir_nodeset_t *deps) +{ int i; for (i = get_irn_ins_or_deps(irn) - 1; i >= 0; --i) { @@ -1151,14 +1166,13 @@ static void sta_collect_in_deps(ir_node *irn, ir_nodeset_t *deps) { * - the precedence constraints: * assure that no data dependencies are violated */ -static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ unsigned num_cst_assign, num_cst_prec, num_cst_dead; char buf[1024]; ir_node *irn; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); bitset_t *bs_block_irns = bitset_alloca(ba->block_last_idx); - ir_timer_t *t_cst_assign = ir_timer_register("beilpsched_cst_assign", "create assignment constraints"); - ir_timer_t *t_cst_prec = ir_timer_register("beilpsched_cst_prec", "create precedence constraints"); num_cst_assign = num_cst_prec = num_cst_dead = 0; foreach_linked_irns(ba->head_ilp_nodes, irn) { @@ -1177,14 +1191,14 @@ static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, cur_var = 0; /* the assignment constraint */ - ilp_timer_push(t_cst_assign); + stat_ev_tim_push(); snprintf(buf, sizeof(buf), "assignment_cst_n%u", get_irn_idx(irn)); cst = lpp_add_cst_uniq(lpp, buf, lpp_equal, 1.0); DBG((env->dbg, LEVEL_2, "added constraint %s\n", buf)); num_cst_assign++; lpp_set_factor_fast_bulk(lpp, cst, na->ilp_vars.x, ARR_LEN(na->ilp_vars.x), 1.0); - ilp_timer_pop(); + stat_ev_tim_pop("beilpsched_cst_assign"); /* We have separate constraints for Projs and Keeps */ // ILP becomes infeasible ?!? @@ -1192,8 +1206,8 @@ static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, // continue; /* the precedence constraints */ - ilp_timer_push(t_cst_prec); - bs_block_irns = bitset_clear_all(bs_block_irns); + stat_ev_tim_push(); + bitset_clear_all(bs_block_irns); sta_collect_in_deps(irn, &deps); foreach_ir_nodeset(&deps, pred, iter) { @@ -1270,12 +1284,8 @@ static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, } } ir_nodeset_destroy(&deps); - ilp_timer_pop(); + stat_ev_tim_pop("beilpsched_cst_prec"); } - DBG((env->dbg, LEVEL_1, "\t%u assignement constraints (%g sec)\n", - num_cst_assign, ilp_timer_elapsed_usec(t_cst_assign) / 1000000.0)); - DBG((env->dbg, LEVEL_1, "\t%u precedence constraints (%g sec)\n", - num_cst_prec, ilp_timer_elapsed_usec(t_cst_prec) / 1000000.0)); } /** @@ -1283,14 +1293,14 @@ static void create_assignment_and_precedence_constraints(be_ilpsched_env_t *env, * - assure that for each time step not more instructions are scheduled * to the same unit types as units of this type are available */ -static void create_ressource_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_ressource_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ int glob_type_idx; char buf[1024]; unsigned num_cst_resrc = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst_rsrc = ir_timer_register("beilpsched_cst_rsrc", "create resource constraints"); - ilp_timer_push(t_cst_rsrc); + stat_ev_tim_push(); for (glob_type_idx = env->cpu->n_unit_types - 1; glob_type_idx >= 0; --glob_type_idx) { unsigned t; be_execution_unit_type_t *cur_tp = &env->cpu->unit_types[glob_type_idx]; @@ -1328,9 +1338,7 @@ static void create_ressource_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ DEL_ARR_F(tmp_var_idx); } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u resource constraints (%g sec)\n", - num_cst_resrc, ilp_timer_elapsed_usec(t_cst_rsrc) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_rsrc"); } /** @@ -1338,15 +1346,15 @@ static void create_ressource_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ * - assure, at most bundle_size * bundles_per_cycle instructions * can be started at a certain point. */ -static void create_bundle_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_bundle_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; unsigned t; unsigned num_cst_bundle = 0; unsigned n_instr_max = env->cpu->bundle_size * env->cpu->bundels_per_cycle; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst_bundle = ir_timer_register("beilpsched_cst_bundle", "create bundle constraints"); - ilp_timer_push(t_cst_bundle); + stat_ev_tim_push(); for (t = 0; t < ba->max_steps; ++t) { ir_node *irn; int cst; @@ -1386,23 +1394,21 @@ static void create_bundle_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilp DEL_ARR_F(tmp_var_idx); } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u bundle constraints (%g sec)\n", - num_cst_bundle, ilp_timer_elapsed_usec(t_cst_bundle) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_bundle"); } /** * Create ILP alive nodes constraints: * - set variable a_{nt}^k to 1 if nodes n is alive at step t on unit k */ -static void create_alive_nodes_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_alive_nodes_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; ir_node *irn; unsigned num_cst = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst = ir_timer_register("beilpsched_cst_alive_nodes", "create alive nodes constraints"); - ilp_timer_push(t_cst); + stat_ev_tim_push(); /* for each node */ foreach_linked_irns(ba->head_ilp_nodes, irn) { be_ilpsched_irn_t *node = get_ilpsched_irn(env, irn); @@ -1468,23 +1474,21 @@ static void create_alive_nodes_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be } } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u alive nodes constraints (%g sec)\n", - num_cst, ilp_timer_elapsed_usec(t_cst) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_alive_nodes"); } /** * Create ILP alive nodes constraints for live-in nodes: * - set variable a_{nt}^k to 1 if nodes n is alive at step t on unit k */ -static void create_alive_livein_nodes_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_alive_livein_nodes_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; ilp_livein_node_t *livein; unsigned num_cst = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst = ir_timer_register("beilpsched_cst_alive_livein_nodes", "create alive livein nodes constraints"); - ilp_timer_push(t_cst); + stat_ev_tim_push(); /* for each node */ foreach_pset(ba->livein_nodes, livein) { ir_node *irn = livein->irn; @@ -1546,9 +1550,7 @@ static void create_alive_livein_nodes_constraint(be_ilpsched_env_t *env, lpp_t * } } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u alive livein nodes constraints (%g sec)\n", - num_cst, ilp_timer_elapsed_usec(t_cst) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_alive_livein_nodes"); } /** @@ -1556,14 +1558,14 @@ static void create_alive_livein_nodes_constraint(be_ilpsched_env_t *env, lpp_t * * - add additional costs to objective function if a node is scheduled * on a unit although all units of this type are currently occupied */ -static void create_pressure_alive_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_pressure_alive_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; ir_node *cur_irn; unsigned num_cst = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst = ir_timer_register("beilpsched_cst_pressure", "create pressure constraints"); - ilp_timer_push(t_cst); + stat_ev_tim_push(); /* y_{nt}^k is set for each node and timestep and unit type */ foreach_linked_irns(ba->head_ilp_nodes, cur_irn) { unsigned cur_idx = get_irn_idx(cur_irn); @@ -1649,24 +1651,22 @@ static void create_pressure_alive_constraint(be_ilpsched_env_t *env, lpp_t *lpp, } } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u pressure constraints (%g sec)\n", - num_cst, ilp_timer_elapsed_usec(t_cst) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_pressure"); } /** * Create ILP branch constraints: * Assure, alle nodes are scheduled prior to cfg op. */ -static void create_branch_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_branch_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; ir_node *cur_irn, *cfop; unsigned num_cst = 0; unsigned num_non_branches = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst = ir_timer_register("beilpsched_cst_branch", "create branch constraints"); - ilp_timer_push(t_cst); + stat_ev_tim_push(); cfop = NULL; /* determine number of non-branch nodes and the one and only branch node */ foreach_linked_irns(ba->head_ilp_nodes, cur_irn) { @@ -1745,20 +1745,18 @@ static void create_branch_constraint(be_ilpsched_env_t *env, lpp_t *lpp, be_ilps DEL_ARR_F(non_branch_vars); } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u branch constraints (%g sec)\n", - num_cst, ilp_timer_elapsed_usec(t_cst) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_branch"); } #if 0 -static void create_proj_keep_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) { +static void create_proj_keep_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ilpsched_irn_t *block_node) +{ char buf[1024]; ir_node *irn; unsigned num_cst = 0; ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); - ir_timer_t *t_cst = ir_timer_register("beilpsched_cst_projkeep", "create proj and keep constraints"); - ilp_timer_push(t_cst); + stat_ev_tim_push(); /* check all nodes */ foreach_linked_irns(ba->head_ilp_nodes, irn) { be_ilpsched_irn_t *node; @@ -1818,9 +1816,7 @@ static void create_proj_keep_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ } } } - ilp_timer_pop(); - DBG((env->dbg, LEVEL_1, "\t%u Proj and Keep constraints (%g sec)\n", - num_cst, ilp_timer_elapsed_usec(t_cst) / 1000000.0)); + stat_ev_tim_pop("beilpsched_cst_projkeep"); } #endif /* if 0 */ @@ -1837,7 +1833,8 @@ static void create_proj_keep_constraints(be_ilpsched_env_t *env, lpp_t *lpp, be_ /** * Create the ilp (add variables, build constraints, solve, build schedule from solution). */ -static void create_ilp(ir_node *block, void *walk_env) { +static void create_ilp(ir_node *block, void *walk_env) +{ be_ilpsched_env_t *env = walk_env; be_ilpsched_irn_t *block_node = get_ilpsched_irn(env, block); ilpsched_block_attr_t *ba = get_ilpsched_block_attr(block_node); @@ -2003,9 +2000,9 @@ static void create_ilp(ir_node *block, void *walk_env) { /** * Perform ILP scheduling on the given irg. */ -void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts) { +void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts) +{ be_ilpsched_env_t env; - const char *name = "be ilp scheduling"; ir_graph *irg = be_get_birg_irg(birg); const arch_env_t *arch_env = be_get_birg_arch_env(birg); const ilp_sched_selector_t *sel = arch_env->impl->get_ilp_sched_selector(arch_env); @@ -2026,7 +2023,7 @@ void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts) { env.opts = &ilp_opts; env.birg = birg; env.be_opts = be_opts; - phase_init(&env.ph, name, env.irg, PHASE_DEFAULT_GROWTH, init_ilpsched_irn, NULL); + phase_init(&env.ph, env.irg, init_ilpsched_irn); /* assign a unique per block number to all interesting nodes */ irg_walk_in_or_dep_graph(env.irg, NULL, build_block_idx, &env); @@ -2063,7 +2060,7 @@ void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts) { irg_block_walk_graph(env.irg, NULL, clear_unwanted_data, &env); /* free all allocated object */ - phase_free(&env.ph); + phase_deinit(&env.ph); heights_free(env.height); /* notify backend */ @@ -2075,6 +2072,7 @@ void be_ilp_sched(const be_irg_t *birg, be_options_t *be_opts) { /** * Register ILP scheduler options. */ +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_ilpsched); void be_init_ilpsched(void) { lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");