X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=include%2Flibfirm%2Firoptimize.h;h=00afa3ec39c065946b1c52d0591ee89e03bb568c;hb=04cfeae3916eaf9225ec519eabdbf42c49dcf38b;hp=4fae6e983957d37f356679bff8429ea9a3bcfc7a;hpb=acbdf295cc01d5b69b1cb8ea2c7764dca1e7b8ac;p=libfirm diff --git a/include/libfirm/iroptimize.h b/include/libfirm/iroptimize.h index 4fae6e983..00afa3ec3 100644 --- a/include/libfirm/iroptimize.h +++ b/include/libfirm/iroptimize.h @@ -69,6 +69,16 @@ void opt_jumpthreading(ir_graph* irg); */ ir_graph_pass_t *opt_jumpthreading_pass(const char *name); +/** + * Creates an ir_graph pass for opt_loopunroll(). + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *opt_loopunroll_pass(const char *name); + + /** * Try to simplify boolean expression in the given ir graph. * eg. x < 5 && x < 6 becomes x < 5 @@ -227,16 +237,18 @@ void do_gvn_pre(ir_graph *irg); ir_graph_pass_t *do_gvn_pre_pass(const char *name); /** - * This function is called to evaluate, if a mux can build - * of the current architecture. + * This function is called to evaluate, if a + * mux(@p sel, @p mux_false, @p mux_true) should be built for the current + * architecture. * If it returns non-zero, a mux is created, else the code * is not modified. * @param sel A selector of a Cond. - * @param phi_list List of Phi nodes about to be converted (linked via get_Phi_next() field) + * @param phi_list phi node to be converted * @param i First data predecessor involved in if conversion * @param j Second data predecessor involved in if conversion */ -typedef int (*arch_allow_ifconv_func)(ir_node *sel, ir_node* phi_list, int i, int j); +typedef int (*arch_allow_ifconv_func)(ir_node *sel, ir_node *mux_false, + ir_node *mux_true); /** * The parameters structure. @@ -271,7 +283,12 @@ void opt_if_conv(ir_graph *irg, const ir_settings_if_conv_t *params); ir_graph_pass_t *opt_if_conv_pass( const char *name, const ir_settings_if_conv_t *params); -void opt_sync(ir_graph *irg); +/** + * Tries to reduce dependencies for memory nodes where possible by parllelizing + * them and synchronising with Sync nodes + * @param irg the graph where memory operations should be parallelised + */ +void opt_parallelize_mem(ir_graph *irg); /** * Creates an ir_graph pass for opt_sync(). @@ -280,7 +297,7 @@ void opt_sync(ir_graph *irg); * * @return the newly created ir_graph pass */ -ir_graph_pass_t *opt_sync_pass(const char *name); +ir_graph_pass_t *opt_parallelize_mem_pass(const char *name); /* * Check if we can replace the load by a given const from @@ -350,18 +367,15 @@ int opt_ldst(ir_graph *irg); ir_graph_pass_t *opt_ldst_pass(const char *name); /** - * Do Loop unrolling in the given graph. - */ -void optimize_loop_unrolling(ir_graph *irg); - -/** - * Creates an ir_graph pass for optimize_loop_unrolling(). + * Optimize loops by peeling or unrolling them if beneficial. * - * @param name the name of this pass or NULL + * @param irg The graph whose loops will be processed * - * @return the newly created ir_graph pass + * This function did not change the graph, only it's frame type. + * The layout state of the frame type will be set to layout_undefined + * if entities were removed. */ -ir_graph_pass_t *optimize_loop_unrolling_pass(const char *name); +void loop_optimization(ir_graph *irg); /** * Optimize the frame type of an irg by removing @@ -492,7 +506,7 @@ ir_graph_pass_t *remove_phi_cycles_pass(const char *name); /** A default threshold. */ -#define DEFAULT_CLONE_THRESHOLD 300 +#define DEFAULT_CLONE_THRESHOLD 20 /** * Do procedure cloning. Evaluate a heuristic weight for every @@ -741,10 +755,11 @@ void normalize_irg_class_casts(ir_graph *irg, gen_pointer_type_to_func gppt_fct) void optimize_class_casts(void); /** - * CLiff Click's combo algorithm from "Combining Analyses, combining Optimizations". + * CLiff Click's combo algorithm from + * "Combining Analyses, combining Optimizations". * - * Does conditional constant propagation, unreachable code elimination and optimistic - * global value numbering at once. + * Does conditional constant propagation, unreachable code elimination and + * optimistic global value numbering at once. * * @param irg the graph to run on */ @@ -835,6 +850,8 @@ ir_prog_pass_t *inline_leave_functions_pass( const char *name, unsigned maxsize, unsigned leavesize, unsigned size, int ignore_runtime); +typedef void (*opt_ptr)(ir_graph *irg); + /** * Heuristic inliner. Calculates a benefice value for every call and inlines * those calls with a value higher than the threshold. @@ -843,8 +860,11 @@ ir_prog_pass_t *inline_leave_functions_pass( * maxsize firm nodes. It may reach this limit by * inlining. * @param inline_threshold inlining threshold + * @param after_inline_opt optimizations performed immediately after inlining + * some calls */ -void inline_functions(unsigned maxsize, int inline_threshold); +void inline_functions(unsigned maxsize, int inline_threshold, + opt_ptr after_inline_opt); /** * Creates an ir_prog pass for inline_functions(). @@ -852,13 +872,18 @@ void inline_functions(unsigned maxsize, int inline_threshold); * @param name the name of this pass or NULL * @param maxsize Do not inline any calls if a method has more than * maxsize firm nodes. It may reach this limit by - * inlineing. + * inlineing. * @param inline_threshold inlining threshold + * @param after_inline_opt a function that is called after inlining a + * procedure. You should run fast local optimisations + * here which cleanup the graph before further + * inlining * * @return the newly created ir_prog pass */ ir_prog_pass_t *inline_functions_pass( - const char *name, unsigned maxsize, int inline_threshold); + const char *name, unsigned maxsize, int inline_threshold, + opt_ptr after_inline_opt); /** * Combines congruent blocks into one. @@ -878,4 +903,190 @@ int shape_blocks(ir_graph *irg); */ ir_graph_pass_t *shape_blocks_pass(const char *name); +/** + * Perform loop inversion on a given graph. + * Loop inversion transforms a head controlled loop (like while(...) {} and + * for(...) {}) into a foot controlled loop (do {} while(...)). + */ +void do_loop_inversion(ir_graph *irg); + +/** + * Perform loop unrolling on a given graph. + * Loop unrolling multiplies the number loop completely by a number found + * through a heuristic. + */ +void do_loop_unrolling(ir_graph *irg); + +/** + * Perform loop peeling on a given graph. + */ +void do_loop_peeling(ir_graph *irg); + +/** + * Creates an ir_graph pass for loop inversion. + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *loop_inversion_pass(const char *name); + +/** + * Creates an ir_graph pass for loop unrolling. + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *loop_unroll_pass(const char *name); + +/** + * Creates an ir_graph pass for loop peeling. + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *loop_peeling_pass(const char *name); + +typedef ir_type *(*get_Alloc_func)(ir_node *n); +/** Set a new get_Alloc_func and returns the old one. */ +get_Alloc_func firm_set_Alloc_func(get_Alloc_func newf); + +/** + * Creates an ir_graph pass for set_vrp_data() + * + * @param name The name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *set_vrp_pass(const char *name); + +/** + * Removes all entities which are unused. + * + * Unused entities have ir_visibility_local and are not used directly or + * indirectly through entities/code visible outside the compilation unit. + * This is usually conservative than gc_irgs, but does not respect properties + * of object-oriented programs. + */ +void garbage_collect_entities(void); + +/** Pass for garbage_collect_entities */ +ir_prog_pass_t *garbage_collect_entities_pass(const char *name); + +/** Performs dead node elimination by copying the ir graph to a new obstack. + * + * The major intention of this pass is to free memory occupied by + * dead nodes and outdated analyzes information. Further this + * function removes Bad predecessors from Blocks and the corresponding + * inputs to Phi nodes. This opens optimization potential for other + * optimizations. Further this phase reduces dead Block<->Jmp + * self-cycles to Bad nodes. + * + * Dead_node_elimination is only performed if options `optimize' and + * `opt_dead_node_elimination' are set. The graph may + * not be in state phase_building. The outs datasturcture is freed, + * the outs state set to outs_none. Backedge information is conserved. + * Removes old attributes of nodes. Sets link field to NULL. + * Callee information must be freed (irg_callee_info_none). + * + * @param irg The graph to be optimized. + */ +void dead_node_elimination(ir_graph *irg); + +/** + * Creates an ir_graph pass for dead_node_elimination(). + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *dead_node_elimination_pass(const char *name); + +/** Inlines a method at the given call site. + * + * Removes the call node and splits the basic block the call node + * belongs to. Inserts a copy of the called graph between these nodes. + * Assumes that call is a Call node in current_ir_graph and that + * the type in the Call nodes type attribute is the same as the + * type of the called graph. + * Further it assumes that all Phi nodes in a block of current_ir_graph + * are assembled in a "link" list in the link field of the corresponding + * block nodes. Further assumes that all Proj nodes are in a "link" list + * in the nodes producing the tuple. (This is only an optical feature + * for the graph.) Conserves this feature for the old + * nodes of the graph. This precondition can be established by a call to + * collect_phisprojs(), see irgmod.h. + * As dead_node_elimination this function reduces dead Block<->Jmp + * self-cycles to Bad nodes. + * + * Called_graph must be unequal to current_ir_graph. Will not inline + * if they are equal. + * Sets visited masterflag in current_ir_graph to the max of the flag in + * current and called graph. + * Assumes that both, the called and the calling graph are in state + * "op_pin_state_pinned". + * It is recommended to call local_optimize_graph() after inlining as this + * function leaves a set of obscure Tuple nodes, e.g. a Proj-Tuple-Jmp + * combination as control flow operation. + * + * @param call the call node that should be inlined + * @param called_graph the IR-graph that is called at call + * + * @return zero if method could not be inlined (recursion for instance), + * non-zero if all went ok + */ +int inline_method(ir_node *call, ir_graph *called_graph); + +/** Code Placement. + * + * Pins all floating nodes to a block where they + * will be executed only if needed. Depends on the flag opt_global_cse. + * Graph may not be in phase_building. Does not schedule control dead + * code. Uses dominator information which it computes if the irg is not + * in state dom_consistent. Destroys the out information as it moves nodes + * to other blocks. Optimizes Tuples in Control edges. + * @todo This is not tested! + * + * Call remove_critical_cf_edges() before place_code(). This normalizes + * the control flow graph so that for all operations a basic block exists + * where they can be optimally placed. + * + * @todo A more powerful code placement would move operations past Phi nodes + * out of loops. + */ +void place_code(ir_graph *irg); + +/** + * Creates an ir_graph pass for place_code(). + * This pass enables GCSE, runs optimize_graph_df() and finally + * place_code(); + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *place_code_pass(const char *name); + +/** + * Determine information about the values of nodes and perform simplications + * using this information. This optimization performs a data-flow analysis to + * find the minimal fixpoint. + */ +void fixpoint_vrp(ir_graph*); + +/** + * Creates an ir_graph pass for fixpoint_vrp(). + * This pass dDetermines information about the values of nodes + * and perform simplications using this information. + * This optimization performs a data-flow analysis to + * find the minimal fixpoint. + * + * @param name the name of this pass or NULL + * + * @return the newly created ir_graph pass + */ +ir_graph_pass_t *fixpoint_vrp_irg_pass(const char *name); + #endif