X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbemain.c;h=82ed7e44a2c2ffe6172b2b176715e3c20e90579f;hb=ad8368234bf59eb46fbc0cfff5b7322a7efac964;hp=079785d5f1e974741d69db329761b91aa34068c1;hpb=8e0086dfdf3c7706b8bc4ee0e54097b4ed63d1e7;p=libfirm diff --git a/ir/be/bemain.c b/ir/be/bemain.c index 079785d5f..82ed7e44a 100644 --- a/ir/be/bemain.c +++ b/ir/be/bemain.c @@ -8,144 +8,253 @@ #endif #include +#include #include "obst.h" #include "bitset.h" #include "irprog.h" +#include "irgopt.h" #include "irgraph.h" #include "irdump.h" +#include "phiclass.h" +#include "irdom_t.h" +#include "iredges_t.h" +#include "irloop_t.h" #include "be_t.h" -#include "bera_t.h" +#include "bechordal_t.h" #include "benumb_t.h" #include "besched_t.h" #include "belistsched.h" #include "belive_t.h" #include "beutil.h" #include "bechordal.h" -#include "bechordal.h" -#include "bephiopt.h" -#include "phistat.h" +#include "bearch.h" +#include "becopyoptmain.h" +#include "becopystat.h" +#include "bessadestr.h" +#include "bearch_firm.h" +#include "benode_t.h" +#include "beirgmod.h" +#include "bespillilp.h" +#include "bespillbelady.h" #include "beasm_dump_globals.h" #include "beasm_asm_gnu.h" -#define DUMP_ALLOCATED -#undef DUMP_LOCALIZED +#include "firm2arch.h" + +#undef DUMP_BEGIN +#undef DUMP_PREPARED +#define DUMP_TRANSFORM +#define DUMP_SCHED +#define DUMP_SPILL +#undef DUMP_ALLOCATED +#undef DUMP_COPYMIN +#undef DUMP_SSADESTR +#undef DUMP_END #define N_PHASES 256 -typedef struct _be_graph_info_t { - bitset_t *applied_phases; -} be_graph_info_t; +void be_init(void) +{ + be_sched_init(); + be_liveness_init(); + be_numbering_init(); + be_ra_chordal_init(); + be_copy_opt_init(); + copystat_init(); + phi_class_init(); +} + +static be_main_env_t *be_init_env(be_main_env_t *env) +{ + const arch_isa_if_t *isa = &firm_isa; -static size_t be_info_offset = 0; + obstack_init(&env->obst); + env->dbg = firm_dbg_register("be.main"); + firm_dbg_set_mask(env->dbg, SET_LEVEL_1); -#define get_irg_be_info(irg) get_irg_data(irg, be_graph_info_t, be_info_offset) + env->arch_env = obstack_alloc(&env->obst, sizeof(env->arch_env[0])); + arch_env_init(env->arch_env, isa); + env->arch_env->isa->init(); -static int phase_ids = 1; -static struct obstack obst; + env->node_factory = obstack_alloc(&env->obst, sizeof(*env->node_factory)); + be_node_factory_init(env->node_factory, isa); -int phase_register(phase_t *phase) -{ - phase->id = phase_ids; - return phase_ids++; + arch_env_add_irn_handler(env->arch_env, &firm_irn_handler); + arch_env_add_irn_handler(env->arch_env, + be_node_get_irn_handler(env->node_factory)); + + return env; } -void phase_applied(const ir_graph *irg, const phase_t *phase) +static be_main_session_env_t * +be_init_session_env(be_main_session_env_t *env, + be_main_env_t *main_env, ir_graph *irg) { - be_graph_info_t *info = get_irg_be_info(irg); + env->main_env = main_env; + env->irg = irg; - if(!info->applied_phases) - info->applied_phases = bitset_obstack_alloc(&obst, N_PHASES); - - bitset_set(info->applied_phases, phase->id); + return env; } -int phase_depends_on(const ir_graph *irg, const phase_t *phase, int n, ...) +static void prepare_graph(be_main_session_env_t *s) { - int errors = 0; - int i; - va_list args; + /* set the current graph (this is important for several firm functions) */ + current_ir_graph = s->irg; - if(n > 0) { - const be_graph_info_t *info = get_irg_be_info(irg); - const bitset_t *applied_phases = info->applied_phases; + /* Let the isa prepare the graph. */ + s->main_env->arch_env->isa->prepare_graph(s->irg); - va_start(args, n); + /* Normalize proj nodes. */ + normalize_proj_nodes(s->irg); - for(i = 0; i < n; ++i) { - const phase_t *dep_phase = va_arg(args, const phase_t *); + /* Remove critical edges */ + remove_critical_cf_edges(s->irg); - if(!applied_phases || !bitset_is_set(applied_phases, dep_phase->id)) { - errors++; - fprintf(stderr, "phase dependency unfulfilled: \"%s\" depends on \"%s\"\n", - phase->name, dep_phase->name); - } - } + /* Compute the dominance information. */ + free_dom_and_peace(s->irg); + compute_doms(s->irg); - va_end(args); + /* Compute the dominance frontiers */ + s->dom_front = be_compute_dominance_frontiers(s->irg); - assert(errors > 0 && "There were phase dependency errors"); - } + /* Ensure, that the ir_edges are computed. */ + edges_activate(s->irg); - return errors; -} + /* Compute loop nesting information (for weighting copies) */ + if (get_irg_loopinfo_state(s->irg) != (loopinfo_valid & loopinfo_cf_consistent)) + construct_cf_backedges(s->irg); -void be_init(void) -{ - obstack_init(&obst); - be_info_offset = register_additional_graph_data(sizeof(be_graph_info_t)); - - be_sched_init(); - be_liveness_init(); - be_numbering_init(); - be_ra_init(); - be_ra_chordal_init(); - be_phi_opt_init(); + be_check_dominance(s->irg); } -extern void be_ra_chordal(ir_graph *irg); - static void be_main_loop(void) { int i, n; + be_main_env_t env; + const arch_isa_if_t *isa; + be_init_env(&env); + isa = arch_env_get_isa(env.arch_env); + + /* create required irop's */ + create_bearch_asm_opcodes(); + + /* For all graphs */ for(i = 0, n = get_irp_n_irgs(); i < n; ++i) { + int j, m; ir_graph *irg = get_irp_irg(i); + be_main_session_env_t session; + + DBG((env.dbg, LEVEL_2, "====> IRG: %F\n", irg)); +#ifdef DUMP_BEGIN + dump_ir_block_graph(irg, "-begin"); +#endif + + /* Init the session. */ + be_init_session_env(&session, &env, irg); + + /* Compute some analyses and prepare the graph for backend use. */ + prepare_graph(&session); + + transform_firm(irg); - localize_consts(irg); -#ifdef DUMP_LOCALIZED - dump_consts_local(0); - dump_ir_block_graph(irg, "-local-const"); +#ifdef DUMP_TRANSFORM + dump_ir_block_graph(irg, "-transformed"); #endif - be_numbering(irg); + + +#if 0 +#ifdef DUMP_PREPARED + dump_dominator_information(true); + dump_ir_block_graph(irg, "-prepared"); + dump_dominator_information(false); +#endif + + /* Schedule the graphs. */ list_sched(irg, trivial_selector); + be_sched_imm(irg); + +#ifdef DUMP_SCHED + dump_ir_block_graph_sched(irg, "-sched"); +#endif + + /* Verify the schedule */ + sched_verify_irg(irg); + + /* Build liveness information */ be_liveness(irg); - be_ra_chordal(irg); + /* Perform the following for each register class. */ + for(j = 0, m = isa->get_n_reg_class(); j < m; ++j) { + be_chordal_env_t *chordal_env; + const arch_register_class_t *cls = isa->get_reg_class(j); + DBG((env.dbg, LEVEL_1, "----> Reg class: %s\n", cls->name)); + + /* spilling */ + //be_spill_ilp(&session, cls); + be_spill_belady(&session, cls); +#ifdef DUMP_SPILL + dump_ir_block_graph_sched(session.irg, "-spill"); +#endif + be_liveness(irg); + be_numbering(irg); + be_check_pressure(&session, cls); + +#if 0 + { + FILE *f; + char buf[128]; + ir_snprintf(buf, sizeof(buf), "%F_%s-live.txt", irg, cls->name); + if((f = fopen(buf, "wt")) != NULL) { + be_liveness_dump(session.irg, f); + fclose(f); + } + } +#endif + + /* allocation */ + chordal_env = be_ra_chordal(&session, cls); #ifdef DUMP_ALLOCATED - dump_allocated_irg(irg, ""); + dump_allocated_irg(env.arch_env, irg, ""); #endif - //be_phi_opt(irg); - be_ra_chordal_done(irg); - be_numbering_done(irg); + /* copy minimization */ + copystat_collect_cls(chordal_env); + be_copy_opt(chordal_env); +#ifdef DUMP_COPYMIN + dump_allocated_irg(env.arch_env, irg, "-copymin"); +#endif + + /* ssa destruction */ + be_ssa_destruction(chordal_env); + be_ssa_destruction_check(chordal_env); + be_ra_chordal_check(chordal_env); +#ifdef DUMP_SSADESTR + dump_allocated_irg(env.arch_env, irg, "-ssadestr"); +#endif + + be_ra_chordal_done(chordal_env); + be_numbering_done(irg); + } +#ifdef DUMP_END + dump_ir_block_graph_sched(session.irg, "-end"); +#endif + copystat_dump(irg); +#endif /* if 0 */ } } void be_main(int argc, const char *argv[]) { - assembler_t *gnu_assembler; FILE *asm_output_file; - be_main_loop(); - gnu_assembler = gnuasm_create_assembler(); - asm_output_file = fopen("asm_output.asm", "w"); + be_main_loop(); - asm_dump_globals ( gnu_assembler ); - gnuasm_dump ( gnu_assembler, asm_output_file ); - gnuasm_delete_assembler ( gnu_assembler ); - fclose(asm_output_file); + asm_output_file = fopen(argv[0], "w"); + firmbe_gen_code(asm_output_file); + fclose(asm_output_file); }