X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeschednormal.c;h=777bfe8586c460efe308fd7a178490301f7f7338;hb=36e688467f3e9fed2b96e2d7f323edffa4268b53;hp=e642435cf492e492662af3a9d741fcdd796cdd32;hpb=661e8c55444874a4b35d9802b02728576b98fb91;p=libfirm diff --git a/ir/be/beschednormal.c b/ir/be/beschednormal.c index e642435cf..777bfe858 100644 --- a/ir/be/beschednormal.c +++ b/ir/be/beschednormal.c @@ -26,14 +26,15 @@ #include -#include "besched_t.h" +#include "besched.h" #include "belistsched.h" #include "belive_t.h" #include "beutil.h" -#include "height.h" -#include "irtools.h" +#include "heights.h" #include "irgwalk.h" -#include "benode_t.h" +#include "benode.h" +#include "bemodule.h" +#include "util.h" #include "array_t.h" // XXX there is no one time init for schedulers @@ -42,8 +43,9 @@ /** An instance of the normal scheduler. */ typedef struct instance_t { - ir_graph* irg; /**< the IR graph of this instance */ - struct obstack obst; /**< obstack for temporary data */ + ir_graph* irg; /**< the IR graph of this instance */ + struct obstack obst; /**< obstack for temporary data */ + ir_node* curr_list; /**< current block schedule list */ } instance_t; static int must_be_scheduled(const ir_node* const irn) @@ -52,34 +54,30 @@ static int must_be_scheduled(const ir_node* const irn) } -static ir_node *normal_select(void *block_env, ir_nodeset_t *ready_set, - ir_nodeset_t *live_set) +static ir_node *normal_select(void *block_env, ir_nodeset_t *ready_set) { + instance_t* inst = (instance_t*)block_env; + ir_node* irn; + ir_node* next; + ir_node* last = NULL; ir_nodeset_iterator_t iter; - ir_node* block; - ir_node* irn; - ir_node** sched; - int sched_count; - (void)block_env; - (void)live_set; - - ir_nodeset_iterator_init(&iter, ready_set); - irn = ir_nodeset_iterator_next(&iter); - block = get_nodes_block(irn); - sched = get_irn_link(block); - sched_count = ARR_LEN(sched); - for (; sched_count-- != 0; ++sched) { - ir_node* irn = *sched; - if (ir_nodeset_contains(ready_set, irn) && - !arch_irn_class_is(irn, branch)) { + for (irn = inst->curr_list; irn != NULL; last = irn, irn = next) { + next = (ir_node*)get_irn_link(irn); + if (ir_nodeset_contains(ready_set, irn)) { #if defined NORMAL_DBG ir_fprintf(stderr, "scheduling %+F\n", irn); #endif + if (last == NULL) + inst->curr_list = next; + else + set_irn_link(last, next); return irn; } } + ir_nodeset_iterator_init(&iter, ready_set); + irn = ir_nodeset_iterator_next(&iter); return irn; } @@ -91,8 +89,8 @@ typedef struct irn_cost_pair { static int cost_cmp(const void* a, const void* b) { - const irn_cost_pair* const a1 = a; - const irn_cost_pair* const b1 = b; + const irn_cost_pair* const a1 = (const irn_cost_pair*)a; + const irn_cost_pair* const b1 = (const irn_cost_pair*)b; int ret = b1->cost - a1->cost; if (ret == 0) ret = (int)get_irn_idx(a1->irn) - (int)get_irn_idx(b1->irn); @@ -119,7 +117,10 @@ static int count_result(const ir_node* irn) if (mode == mode_M || mode == mode_X) return 0; - if (arch_get_register_req_out(irn)->type & arch_register_req_type_ignore) + if (mode == mode_T) + return 1; + + if (arch_get_irn_register_req(irn)->type & arch_register_req_type_ignore) return 0; return 1; @@ -151,16 +152,14 @@ static int normal_tree_cost(ir_node* irn, instance_t *inst) if (fc == NULL) { irn_cost_pair* costs; - int i; ir_node* block = get_nodes_block(irn); - fc = obstack_alloc(&inst->obst, sizeof(*fc) + sizeof(*fc->costs) * arity); + fc = OALLOCF(&inst->obst, flag_and_cost, costs, arity); fc->no_root = 0; costs = fc->costs; for (i = 0; i < arity; ++i) { ir_node* pred = get_irn_n(irn, i); - int cost; if (is_Phi(irn) || get_irn_mode(pred) == mode_M || is_Block(pred)) { cost = 0; @@ -171,7 +170,6 @@ static int normal_tree_cost(ir_node* irn, instance_t *inst) ir_node* real_pred; cost = normal_tree_cost(pred, inst); - if (be_is_Barrier(pred)) cost = 1; // XXX hack: the barrier causes all users to have a reguse of #regs if (!arch_irn_is_ignore(pred)) { real_pred = (is_Proj(pred) ? get_Proj_pred(pred) : pred); pred_fc = get_irn_fc(real_pred); @@ -194,9 +192,16 @@ static int normal_tree_cost(ir_node* irn, instance_t *inst) last = 0; for (i = 0; i < arity; ++i) { ir_node* op = fc->costs[i].irn; - if (op == last) continue; - if (get_irn_mode(op) == mode_M) continue; - if (arch_irn_is_ignore(op)) continue; + ir_mode* mode; + if (op == last) + continue; + mode = get_irn_mode(op); + if (mode == mode_M) + continue; + if (arch_get_irn_flags(op) & arch_irn_flags_not_scheduled) + continue; + if (mode != mode_T && arch_irn_is_ignore(op)) + continue; cost = MAX(fc->costs[i].cost + n_op_res, cost); last = op; ++n_op_res; @@ -214,7 +219,7 @@ static int normal_tree_cost(ir_node* irn, instance_t *inst) static void normal_cost_walker(ir_node* irn, void* env) { - instance_t *inst = env; + instance_t *inst = (instance_t*)env; #if defined NORMAL_DBG ir_fprintf(stderr, "cost walking node %+F\n", irn); @@ -242,7 +247,7 @@ static void collect_roots(ir_node* irn, void* env) if (is_root) { ir_node* block = get_nodes_block(irn); - ir_node** roots = get_irn_link(block); + ir_node** roots = (ir_node**)get_irn_link(block); if (roots == NULL) { roots = NEW_ARR_F(ir_node*, 0); } @@ -280,8 +285,8 @@ static ir_node** sched_node(ir_node** sched, ir_node* irn) static int root_cmp(const void* a, const void* b) { - const irn_cost_pair* const a1 = a; - const irn_cost_pair* const b1 = b; + const irn_cost_pair* const a1 = (const irn_cost_pair*)a; + const irn_cost_pair* const b1 = (const irn_cost_pair*)b; int ret; if (is_irn_forking(a1->irn)) { ret = 1; @@ -303,8 +308,8 @@ static int root_cmp(const void* a, const void* b) static void normal_sched_block(ir_node* block, void* env) { - heights_t* heights = env; - ir_node** roots = get_irn_link(block); + ir_node** roots = (ir_node**)get_irn_link(block); + ir_heights_t* heights = (ir_heights_t*)env; int root_count; irn_cost_pair* root_costs; int i; @@ -368,19 +373,15 @@ static void normal_sched_block(ir_node* block, void* env) } -static void *normal_init_graph(const list_sched_selector_t *vtab, - const be_irg_t *birg) +static void *normal_init_graph(ir_graph *irg) { - instance_t *inst = XMALLOC(instance_t); - ir_graph *irg = be_get_birg_irg(birg); - heights_t *heights; + instance_t *inst = XMALLOC(instance_t); + ir_heights_t *heights; - (void)vtab; + be_clear_links(irg); - inst->irg = irg; obstack_init(&inst->obst); - - be_clear_links(irg); + inst->irg = irg; heights = heights_new(irg); @@ -397,18 +398,33 @@ static void *normal_init_graph(const list_sched_selector_t *vtab, return inst; } - static void *normal_init_block(void *graph_env, ir_node *block) { - (void)graph_env; - (void)block; - - return NULL; + instance_t* inst = (instance_t*)graph_env; + ir_node** sched = (ir_node**)get_irn_link(block); + ir_node* first = NULL; + int i; + + /* turn into a list, so we can easily remove nodes. + The link field is used anyway. */ + for (i = ARR_LEN(sched) - 1; i >= 0; --i) { + ir_node* irn = sched[i]; + if (!is_cfop(irn)) { + set_irn_link(irn, first); + first = irn; + } + } + /* note: we can free sched here, there should be no attempt to schedule + a block twice */ + DEL_ARR_F(sched); + set_irn_link(block, sched); + inst->curr_list = first; + return inst; } -void normal_finish_graph(void *env) +static void normal_finish_graph(void *env) { - instance_t *inst = env; + instance_t *inst = (instance_t*)env; /* block uses the link field to store the schedule */ ir_free_resources(inst->irg, IR_RESOURCE_IRN_LINK); @@ -416,15 +432,22 @@ void normal_finish_graph(void *env) xfree(inst); } -const list_sched_selector_t normal_selector = { - normal_init_graph, - normal_init_block, - normal_select, - NULL, /* to_appear_in_schedule */ - NULL, /* node_ready */ - NULL, /* node_selected */ - NULL, /* exectime */ - NULL, /* latency */ - NULL, /* finish_block */ - normal_finish_graph -}; +static void sched_normal(ir_graph *irg) +{ + static const list_sched_selector_t normal_selector = { + normal_init_graph, + normal_init_block, + normal_select, + NULL, /* node_ready */ + NULL, /* node_selected */ + NULL, /* finish_block */ + normal_finish_graph + }; + be_list_sched_graph(irg, &normal_selector); +} + +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_sched_normal) +void be_init_sched_normal(void) +{ + be_register_scheduler("normal", sched_normal); +}