X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firoptimize.h;h=00afa3ec39c065946b1c52d0591ee89e03bb568c;hb=04cfeae3916eaf9225ec519eabdbf42c49dcf38b;hp=4bfdfefee121574ee7c012f2f5d5cf9e909aab23;hpb=86c66a17beb4bdf09924135e6caf817960ef648c;p=libfirm diff --git a/include/libfirm/iroptimize.h b/include/libfirm/iroptimize.h index 4bfdfefee..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 @@ -357,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 @@ -499,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 @@ -865,8 +872,12 @@ 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 */ @@ -894,18 +905,188 @@ ir_graph_pass_t *shape_blocks_pass(const char *name); /** * Perform loop inversion on a given graph. - * Loop inversion transform a head controlled loop (like while(...) {} and + * 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