X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=driver%2Ffirm_opt.c;h=2d25c4c29913c5cac428f8140a7e46f1db26d217;hb=8100b4a9336172bceb7d67992aed642b26a4508e;hp=f48b09424e8e5ec3a5fa768bf6a48e558890cac5;hpb=26fdb217e247169f25717ce8331fd11feda9fada;p=cparser diff --git a/driver/firm_opt.c b/driver/firm_opt.c index f48b094..2d25c4c 100644 --- a/driver/firm_opt.c +++ b/driver/firm_opt.c @@ -22,12 +22,6 @@ #include "firm_timing.h" #include "ast2firm.h" -#if defined(_DEBUG) || defined(FIRM_DEBUG) -#define DBG(x) dbg_printf x -#else -#define DBG(x) ((void)0) -#endif /* _DEBUG || FIRM_DEBUG */ - static ir_timer_t *t_vcg_dump; static ir_timer_t *t_verify; static ir_timer_t *t_all_opt; @@ -35,17 +29,14 @@ static bool do_irg_opt(ir_graph *irg, const char *name); /** dump all the graphs depending on cond */ -static void dump_all(const char *suffix) { - if (firm_dump.ir_graph) { - timer_push(t_vcg_dump); - if (firm_dump.no_blocks) - dump_all_ir_graphs(dump_ir_graph, suffix); - else if (firm_dump.extbb) - dump_all_ir_graphs(dump_ir_extblock_graph, suffix); - else - dump_all_ir_graphs(dump_ir_block_graph, suffix); - timer_pop(t_vcg_dump); - } +static void dump_all(const char *suffix) +{ + if (!firm_dump.ir_graph) + return; + + timer_push(t_vcg_dump); + dump_all_ir_graphs(suffix); + timer_pop(t_vcg_dump); } /* set by the backend parameters */ @@ -79,7 +70,8 @@ static const ir_settings_arch_dep_t *arch_factory(void) /** * Map runtime functions. */ -static void rts_map(void) { +static void rts_map(void) +{ static const struct { ir_entity_ptr *ent; /**< address of the rts entity */ i_mapper_func func; /**< mapper function. */ @@ -183,23 +175,6 @@ static void rts_map(void) { } static int *irg_dump_no; - -static void dump_graph_count(ir_graph *const irg, const char *const suffix) -{ - char name[64]; - snprintf(name, sizeof(name), "-%02d_%s", irg_dump_no[get_irg_idx(irg)]++, - suffix); - - timer_push(t_vcg_dump); - if (firm_dump.no_blocks) - dump_ir_graph(irg, name); - else if (firm_dump.extbb) - dump_ir_extblock_graph(irg, name); - else - dump_ir_block_graph(irg, name); - timer_pop(t_vcg_dump); -} - static int firm_const_exists; static void do_optimize_funccalls(void) @@ -302,53 +277,60 @@ typedef enum opt_flags { typedef void (*transform_irg_func)(ir_graph *irg); typedef void (*transform_irp_func)(void); -typedef void (*func_ptr_t)(void); typedef struct { opt_target_t target; const char *name; - func_ptr_t func; + union { + transform_irg_func transform_irg; + transform_irp_func transform_irp; + } u; const char *description; opt_flags_t flags; } opt_config_t; static opt_config_t opts[] = { - { OPT_TARGET_IRP, "rts", (func_ptr_t) rts_map, "optimization of known library functions", OPT_FLAG_HIDE_OPTIONS }, - { OPT_TARGET_IRG, "combo", (func_ptr_t) combo, "combined CCE, UCE and GVN", OPT_FLAG_NONE}, - { OPT_TARGET_IRG, "control-flow", (func_ptr_t) optimize_cf, "optimization of control-flow", OPT_FLAG_HIDE_OPTIONS }, - { OPT_TARGET_IRG, "local", (func_ptr_t) optimize_graph_df, "local graph optimizations", OPT_FLAG_HIDE_OPTIONS }, - { OPT_TARGET_IRP, "remove-unused", (func_ptr_t) garbage_collect_entities,"removal of unused functions/variables", OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY }, - { OPT_TARGET_IRG, "opt-tail-rec", (func_ptr_t) opt_tail_rec_irg, "tail-recursion eliminiation", OPT_FLAG_NONE }, - { OPT_TARGET_IRP, "opt-func-call", (func_ptr_t) do_optimize_funccalls, "function call optimization", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "lower", (func_ptr_t) do_lower_highlevel, "lowering", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL }, - { OPT_TARGET_IRP, "lower-const", (func_ptr_t) lower_const_code, "lowering of constant code", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY | OPT_FLAG_ESSENTIAL }, - { OPT_TARGET_IRP, "lower-dw", (func_ptr_t) do_lower_dw_ops, "lowering of doubleword operations", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL }, - { OPT_TARGET_IRG, "lower-switch", (func_ptr_t) do_lower_switch, "switch lowering", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL }, - { OPT_TARGET_IRG, "one-return", (func_ptr_t) normalize_one_return, "normalisation to 1 return", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY }, - { OPT_TARGET_IRG, "scalar-replace", (func_ptr_t) scalar_replacement_opt, "scalar replacement", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "reassociation", (func_ptr_t) optimize_reassociation, "reassociation", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "gcse", (func_ptr_t) do_gcse, "global common subexpression elimination", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "place", (func_ptr_t) place_code, "code placement", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "confirm", (func_ptr_t) construct_confirms, "confirm optimisation", OPT_FLAG_HIDE_OPTIONS }, - { OPT_TARGET_IRG, "opt-load-store", (func_ptr_t) optimize_load_store, "load store optimization", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "parallelize-mem", (func_ptr_t) opt_parallelize_mem, "parallelize memory", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "deconv", (func_ptr_t) conv_opt, "conv node elimination", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "thread-jumps", (func_ptr_t) opt_jumpthreading, "path-sensitive jumpthreading", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "remove-confirms", (func_ptr_t) remove_confirms, "confirm removal", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY }, - { OPT_TARGET_IRG, "gvn-pre", (func_ptr_t) do_gvn_pre, "global value numbering partial redundancy elimination", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "if-conversion", (func_ptr_t) do_if_conv, "if-conversion", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "bool", (func_ptr_t) opt_bool, "bool simplification", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "shape-blocks", (func_ptr_t) shape_blocks, "block shaping", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "ivopts", (func_ptr_t) do_stred, "induction variable strength reduction", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "remove-phi-cycles", (func_ptr_t) remove_phi_cycles, "removal of phi cycles", OPT_FLAG_HIDE_OPTIONS }, - { OPT_TARGET_IRG, "dead", (func_ptr_t) dead_node_elimination, "dead node elimination", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY }, - { OPT_TARGET_IRP, "inline", (func_ptr_t) do_inline, "inlining", OPT_FLAG_NONE }, - { OPT_TARGET_IRP, "opt-proc-clone", (func_ptr_t) do_cloning, "procedure cloning", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "invert-loops", (func_ptr_t) do_loop_inversion, "loop inversion", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "unroll-loops", (func_ptr_t) do_loop_unrolling, "loop unrolling", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "lower-mux", (func_ptr_t) do_lower_mux, "mux lowering", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "vrp", (func_ptr_t) do_vrp, "value range propagation", OPT_FLAG_NONE }, - { OPT_TARGET_IRG, "frame", (func_ptr_t) opt_frame_irg, "remove unused frame entities", OPT_FLAG_NONE }, +#define IRG(a, b, c, d) { OPT_TARGET_IRG, a, .u.transform_irg = (transform_irg_func)b, c, d } +#define IRP(a, b, c, d) { OPT_TARGET_IRP, a, .u.transform_irp = b, c, d } + IRG("bool", opt_bool, "bool simplification", OPT_FLAG_NONE), + IRG("combo", combo, "combined CCE, UCE and GVN", OPT_FLAG_NONE), + IRG("confirm", construct_confirms, "confirm optimisation", OPT_FLAG_HIDE_OPTIONS), + IRG("control-flow", optimize_cf, "optimization of control-flow", OPT_FLAG_HIDE_OPTIONS), + IRG("dead", dead_node_elimination, "dead node elimination", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY), + IRG("deconv", conv_opt, "conv node elimination", OPT_FLAG_NONE), + IRG("fp-vrp", fixpoint_vrp, "fixpoint value range propagation", OPT_FLAG_NONE), + IRG("frame", opt_frame_irg, "remove unused frame entities", OPT_FLAG_NONE), + IRG("gcse", do_gcse, "global common subexpression elimination", OPT_FLAG_NONE), + IRG("gvn-pre", do_gvn_pre, "global value numbering partial redundancy elimination", OPT_FLAG_NONE), + IRG("if-conversion", do_if_conv, "if-conversion", OPT_FLAG_NONE), + IRG("invert-loops", do_loop_inversion, "loop inversion", OPT_FLAG_NONE), + IRG("ivopts", do_stred, "induction variable strength reduction", OPT_FLAG_NONE), + IRG("local", optimize_graph_df, "local graph optimizations", OPT_FLAG_HIDE_OPTIONS), + IRG("lower", do_lower_highlevel, "lowering", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL), + IRG("lower-mux", do_lower_mux, "mux lowering", OPT_FLAG_NONE), + IRG("lower-switch", do_lower_switch, "switch lowering", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL), + IRG("one-return", normalize_one_return, "normalisation to 1 return", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY), + IRG("opt-load-store", optimize_load_store, "load store optimization", OPT_FLAG_NONE), + IRG("opt-tail-rec", opt_tail_rec_irg, "tail-recursion eliminiation", OPT_FLAG_NONE), + IRG("parallelize-mem", opt_parallelize_mem, "parallelize memory", OPT_FLAG_NONE), + IRG("place", place_code, "code placement", OPT_FLAG_NONE), + IRG("reassociation", optimize_reassociation, "reassociation", OPT_FLAG_NONE), + IRG("remove-confirms", remove_confirms, "confirm removal", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY), + IRG("remove-phi-cycles", remove_phi_cycles, "removal of phi cycles", OPT_FLAG_HIDE_OPTIONS), + IRG("scalar-replace", scalar_replacement_opt, "scalar replacement", OPT_FLAG_NONE), + IRG("shape-blocks", shape_blocks, "block shaping", OPT_FLAG_NONE), + IRG("thread-jumps", opt_jumpthreading, "path-sensitive jumpthreading", OPT_FLAG_NONE), + IRG("unroll-loops", do_loop_unrolling, "loop unrolling", OPT_FLAG_NONE), + IRG("vrp", do_vrp, "value range propagation", OPT_FLAG_NONE), + IRP("inline", do_inline, "inlining", OPT_FLAG_NONE), + IRP("lower-const", lower_const_code, "lowering of constant code", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY | OPT_FLAG_ESSENTIAL), + IRP("lower-dw", do_lower_dw_ops, "lowering of doubleword operations", OPT_FLAG_HIDE_OPTIONS | OPT_FLAG_ESSENTIAL), + IRP("opt-func-call", do_optimize_funccalls, "function call optimization", OPT_FLAG_NONE), + IRP("opt-proc-clone", do_cloning, "procedure cloning", OPT_FLAG_NONE), + IRP("remove-unused", garbage_collect_entities, "removal of unused functions/variables", OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY), + IRP("rts", rts_map, "optimization of known library functions", OPT_FLAG_HIDE_OPTIONS), +#undef IRP +#undef IRG }; static const int n_opts = sizeof(opts) / sizeof(opts[0]); ir_timer_t *timers[sizeof(opts)/sizeof(opts[0])]; @@ -385,10 +367,9 @@ static bool get_opt_enabled(const char *name) */ static bool do_irg_opt(ir_graph *irg, const char *name) { - transform_irg_func func; - ir_graph *old_irg; - opt_config_t *config = get_opt(name); - size_t n = config - opts; + ir_graph *old_irg; + opt_config_t *config = get_opt(name); + size_t n = config - opts; assert(config != NULL); assert(config->target == OPT_TARGET_IRG); if (! (config->flags & OPT_FLAG_ENABLED)) @@ -397,19 +378,17 @@ static bool do_irg_opt(ir_graph *irg, const char *name) old_irg = current_ir_graph; current_ir_graph = irg; - func = (transform_irg_func) config->func; - timer_push(timers[n]); - func(irg); + config->u.transform_irg(irg); timer_pop(timers[n]); if (firm_dump.all_phases && firm_dump.ir_graph) { - dump_graph_count(irg, name); + dump_ir_graph(irg, name); } if (firm_opt.check_all) { timer_push(t_verify); - irg_verify(irg, VRFY_ENFORCE_SSA); + irg_verify(irg, VERIFY_ENFORCE_SSA); timer_pop(t_verify); } @@ -419,24 +398,21 @@ static bool do_irg_opt(ir_graph *irg, const char *name) static void do_irp_opt(const char *name) { - transform_irp_func func; - opt_config_t *config = get_opt(name); - size_t n = config - opts; + opt_config_t *config = get_opt(name); + size_t n = config - opts; assert(config->target == OPT_TARGET_IRP); if (! (config->flags & OPT_FLAG_ENABLED)) return; - func = (transform_irp_func) config->func; - timer_push(timers[n]); - func(); + config->u.transform_irp(); timer_pop(timers[n]); if (firm_dump.ir_graph && firm_dump.all_phases) { int i; for (i = get_irp_n_irgs() - 1; i >= 0; --i) { ir_graph *irg = get_irp_irg(i); - dump_graph_count(irg, name); + dump_ir_graph(irg, name); } } @@ -444,7 +420,7 @@ static void do_irp_opt(const char *name) int i; timer_push(t_verify); for (i = get_irp_n_irgs() - 1; i >= 0; --i) { - irg_verify(get_irp_irg(i), VRFY_ENFORCE_SSA); + irg_verify(get_irp_irg(i), VERIFY_ENFORCE_SSA); } timer_pop(t_verify); } @@ -474,6 +450,8 @@ static void enable_safe_defaults(void) set_opt_enabled("lower-switch", true); set_opt_enabled("remove-phi-cycles", true); set_opt_enabled("frame", true); + set_opt_enabled("combo", true); + set_opt_enabled("invert-loops", true); } /** @@ -551,6 +529,7 @@ static void do_firm_optimizations(const char *input_filename) do_irg_opt(irg, "control-flow"); do_irg_opt(irg, "opt-load-store"); + do_irg_opt(irg, "fp-vrp"); do_irg_opt(irg, "lower"); do_irg_opt(irg, "deconv"); do_irg_opt(irg, "thread-jumps"); @@ -600,7 +579,7 @@ static void do_firm_optimizations(const char *input_filename) construct_cf_backedges(get_irp_irg(i)); } - dump_all("-opt"); + dump_all("opt"); if (firm_dump.statistic & STAT_AFTER_OPT) stat_dump_snapshot(input_filename, "opt"); @@ -622,7 +601,7 @@ static void do_firm_lowering(const char *input_filename) if (firm_dump.statistic & STAT_AFTER_LOWER) stat_dump_snapshot(input_filename, "low"); - dump_all("-low"); + dump_all("low"); if (firm_opt.enabled) { timer_start(t_all_opt); @@ -668,17 +647,17 @@ static void do_firm_lowering(const char *input_filename) do_irp_opt("remove-unused"); - dump_all("-low-opt"); + dump_all("low-opt"); } if (firm_opt.cc_opt) mark_private_methods(); /* set the phase to low */ - for (i = get_irp_n_irgs() - 1; i >= 0; --i) - set_irg_phase_low(get_irp_irg(i)); - - /* all graphs are lowered, set the irp phase to low */ + for (i = get_irp_n_irgs() - 1; i >= 0; --i) { + ir_graph *irg = get_irp_irg(i); + set_irg_phase_state(irg, phase_low); + } set_irp_phase_state(phase_low); if (firm_dump.statistic & STAT_FINAL) { @@ -691,9 +670,8 @@ static void do_firm_lowering(const char *input_filename) */ void gen_firm_init(void) { - firm_parameter_t params; - unsigned pattern = 0; - int i; + unsigned pattern = 0; + int i; for (i = 0; i < n_opts; ++i) { timers[i] = ir_timer_new(); @@ -712,15 +690,10 @@ void gen_firm_init(void) if (firm_dump.stat_dag) pattern |= FIRMSTAT_COUNT_DAG; - memset(¶ms, 0, sizeof(params)); - params.size = sizeof(params); - params.enable_statistics = firm_dump.statistic == STAT_NONE ? 0 : - FIRMSTAT_ENABLED | FIRMSTAT_COUNT_STRONG_OP | FIRMSTAT_COUNT_CONSTS - | pattern; - params.initialize_local_func = uninitialized_local_var; - params.cc_mask = 0; /* no regparam, cdecl */ - - ir_init(¶ms); + ir_init(NULL); + firm_init_stat(firm_dump.statistic == STAT_NONE ? + 0 : FIRMSTAT_ENABLED | FIRMSTAT_COUNT_STRONG_OP + | FIRMSTAT_COUNT_CONSTS | pattern); if (firm_be_opt.selection == BE_FIRM_BE) { const backend_params *be_params = be_get_backend_param(); @@ -735,7 +708,7 @@ void gen_firm_init(void) if_conv_info = be_params->if_conv_info; } - edges_init_dbg(firm_opt.vrfy_edges); + edges_init_dbg(firm_opt.verify_edges); /* Sel node cannot produce NULL pointers */ set_opt_sel_based_null_check_elim(1); @@ -748,9 +721,13 @@ void gen_firm_init(void) /* do not run architecture dependent optimizations in building phase */ arch_dep_set_opts(arch_dep_none); - do_node_verification((firm_verification_t) firm_opt.vrfy); - if (firm_dump.filter) - only_dump_method_with_name(new_id_from_str(firm_dump.filter)); + do_node_verification((firm_verification_t) firm_opt.verify); + if (firm_dump.filter != NULL) + ir_set_dump_filter(firm_dump.filter); + if (firm_dump.extbb) + ir_add_dump_flags(ir_dump_flag_group_extbb); + if (firm_dump.no_blocks) + ir_remove_dump_flags(ir_dump_flag_blocks_as_subgraphs); if (firm_opt.enabled) { set_optimize(1); @@ -765,9 +742,6 @@ void gen_firm_init(void) } else { set_optimize(0); } - - /* do not dump entity ld names */ - dump_ld_names(0); } /** @@ -779,7 +753,7 @@ void gen_firm_init(void) * @param c_mode non-zero if "C" was compiled * @param new_firm_const_exists non-zero, if the const attribute was used on functions */ -void gen_firm_finish(FILE *out, const char *input_filename, int c_mode, +void gen_firm_finish(FILE *out, const char *input_filename, int new_firm_const_exists) { int i; @@ -799,23 +773,15 @@ void gen_firm_finish(FILE *out, const char *input_filename, int c_mode, firm_dump.ir_graph = (a_byte) (firm_dump.ir_graph | firm_dump.all_phases | firm_dump.extbb); - dump_keepalive_edges(1); - dump_consts_local(1); - dump_dominator_information(1); - dump_loop_information(0); - - if (!firm_dump.edge_labels) - turn_off_edge_labels(); + ir_add_dump_flags(ir_dump_flag_keepalive_edges + | ir_dump_flag_consts_local | ir_dump_flag_dominance); + ir_remove_dump_flags(ir_dump_flag_loops | ir_dump_flag_ld_names); /* FIXME: cloning might ADD new graphs. */ irg_dump_no = calloc(get_irp_last_idx(), sizeof(*irg_dump_no)); if (firm_dump.all_types) { - dump_all_types(""); - if (! c_mode) { - dump_class_hierarchy(0, ""); - dump_class_hierarchy(1, "-with-entities"); - } + dump_ir_prog_ext(dump_typegraph, "types.vcg"); } /* finalize all graphs */ @@ -826,7 +792,7 @@ void gen_firm_finish(FILE *out, const char *input_filename, int c_mode, dump_all(""); timer_push(t_verify); - tr_vrfy(); + tr_verify(); timer_pop(t_verify); /* all graphs are finalized, set the irp phase to high */ @@ -859,7 +825,7 @@ void gen_firm_finish(FILE *out, const char *input_filename, int c_mode, /* set the phase to low */ for (i = get_irp_n_irgs() - 1; i >= 0; --i) - set_irg_phase_low(get_irp_irg(i)); + set_irg_phase_state(get_irp_irg(i), phase_low); if (firm_dump.statistic & STAT_FINAL_IR) stat_dump_snapshot(input_filename, "final-ir");