libfirm/iroptimize.h

Go to the documentation of this file.

/*
 * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

#ifndef FIRM_IROPTIMIZE_H
#define FIRM_IROPTIMIZE_H

#include "firm_types.h"
#include "nodeops.h"
#include "begin.h"

FIRM_API void optimize_cf(ir_graph *irg);

FIRM_API ir_graph_pass_t *optimize_cf_pass(const char *name);

FIRM_API void opt_jumpthreading(ir_graph* irg);

FIRM_API ir_graph_pass_t *opt_jumpthreading_pass(const char *name);

FIRM_API void opt_bool(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_bool_pass(const char *name);

FIRM_API int conv_opt(ir_graph *irg);

FIRM_API ir_graph_pass_t *conv_opt_pass(const char *name);

typedef int (*check_alloc_entity_func)(ir_entity *ent);

FIRM_API void escape_enalysis_irg(ir_graph *irg,
                                  check_alloc_entity_func callback);

FIRM_API void escape_analysis(int run_scalar_replace,
                              check_alloc_entity_func callback);

FIRM_API void optimize_funccalls(void);

FIRM_API ir_prog_pass_t *optimize_funccalls_pass(const char *name);

FIRM_API void do_gvn_pre(ir_graph *irg);

FIRM_API ir_graph_pass_t *do_gvn_pre_pass(const char *name);

typedef int (*arch_allow_ifconv_func)(ir_node *sel, ir_node *mux_false,
                                      ir_node *mux_true);

FIRM_API void opt_if_conv(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_if_conv_pass(const char *name);

FIRM_API void opt_parallelize_mem(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_parallelize_mem_pass(const char *name);

FIRM_API ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c);

FIRM_API int optimize_load_store(ir_graph *irg);

FIRM_API ir_graph_pass_t *optimize_load_store_pass(const char *name);

FIRM_API int opt_ldst(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_ldst_pass(const char *name);

FIRM_API void loop_optimization(ir_graph *irg);

FIRM_API void opt_frame_irg(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_frame_irg_pass(const char *name);

typedef enum osr_flags {
    osr_flag_none               = 0,  
    osr_flag_lftr_with_ov_check = 1,  
    osr_flag_ignore_x86_shift   = 2,  
    osr_flag_keep_reg_pressure  = 4   
} osr_flags;

#define osr_flag_default osr_flag_lftr_with_ov_check

FIRM_API void opt_osr(ir_graph *irg, unsigned flags);

FIRM_API ir_graph_pass_t *opt_osr_pass(const char *name, unsigned flags);

FIRM_API void remove_phi_cycles(ir_graph *irg);

FIRM_API ir_graph_pass_t *remove_phi_cycles_pass(const char *name);


#define DEFAULT_CLONE_THRESHOLD 20

FIRM_API void proc_cloning(float threshold);

FIRM_API ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold);

FIRM_API int optimize_reassociation(ir_graph *irg);

FIRM_API ir_graph_pass_t *optimize_reassociation_pass(const char *name);

FIRM_API void normalize_one_return(ir_graph *irg);

FIRM_API ir_graph_pass_t *normalize_one_return_pass(const char *name);

FIRM_API void normalize_n_returns(ir_graph *irg);

FIRM_API ir_graph_pass_t *normalize_n_returns_pass(const char *name);

FIRM_API int scalar_replacement_opt(ir_graph *irg);

FIRM_API ir_graph_pass_t *scalar_replacement_opt_pass(const char *name);

FIRM_API int opt_tail_rec_irg(ir_graph *irg);

FIRM_API ir_graph_pass_t *opt_tail_rec_irg_pass(const char *name);

FIRM_API void opt_tail_recursion(void);

FIRM_API ir_prog_pass_t *opt_tail_recursion_pass(const char *name);

typedef ir_type *(*gen_pointer_type_to_func)(ir_type *tp);

FIRM_API void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct);

FIRM_API void normalize_irg_class_casts(ir_graph *irg,
                                        gen_pointer_type_to_func gppt_fct);

FIRM_API void optimize_class_casts(void);

FIRM_API void combo(ir_graph *irg);

FIRM_API ir_graph_pass_t *combo_pass(const char *name);

FIRM_API void inline_small_irgs(ir_graph *irg, int size);

FIRM_API ir_graph_pass_t *inline_small_irgs_pass(const char *name, int size);

FIRM_API void inline_leave_functions(unsigned maxsize, unsigned leavesize,
                                     unsigned size, int ignore_runtime);

FIRM_API 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);

FIRM_API void inline_functions(unsigned maxsize, int inline_threshold,
                               opt_ptr after_inline_opt);

FIRM_API ir_prog_pass_t *inline_functions_pass(const char *name,
        unsigned maxsize, int inline_threshold, opt_ptr after_inline_opt);

FIRM_API int shape_blocks(ir_graph *irg);

FIRM_API ir_graph_pass_t *shape_blocks_pass(const char *name);

FIRM_API void do_loop_inversion(ir_graph *irg);

FIRM_API void do_loop_unrolling(ir_graph *irg);

FIRM_API void do_loop_peeling(ir_graph *irg);

FIRM_API ir_graph_pass_t *loop_inversion_pass(const char *name);

FIRM_API ir_graph_pass_t *loop_unroll_pass(const char *name);

FIRM_API ir_graph_pass_t *loop_peeling_pass(const char *name);

FIRM_API ir_graph_pass_t *set_vrp_pass(const char *name);

FIRM_API void garbage_collect_entities(void);

FIRM_API ir_prog_pass_t *garbage_collect_entities_pass(const char *name);

FIRM_API void dead_node_elimination(ir_graph *irg);

FIRM_API ir_graph_pass_t *dead_node_elimination_pass(const char *name);

FIRM_API int inline_method(ir_node *call, ir_graph *called_graph);

FIRM_API void place_code(ir_graph *irg);

FIRM_API ir_graph_pass_t *place_code_pass(const char *name);

FIRM_API void fixpoint_vrp(ir_graph*);

FIRM_API ir_graph_pass_t *fixpoint_vrp_irg_pass(const char *name);

FIRM_API int value_not_zero(const ir_node *n, const ir_node **confirm);

FIRM_API int value_not_null(const ir_node *n, const ir_node **confirm);

FIRM_API ir_value_classify_sign classify_value_sign(ir_node *n);

FIRM_API ir_tarval *computed_value_Cmp_Confirm(
    const ir_node *cmp, ir_node *left, ir_node *right, ir_relation relation);

typedef ir_entity *(*compilerlib_entity_creator_t)(ident *id, ir_type *mt);

FIRM_API void set_compilerlib_entity_creator(compilerlib_entity_creator_t cb);

FIRM_API compilerlib_entity_creator_t get_compilerlib_entity_creator(void);

FIRM_API ir_entity *create_compilerlib_entity(ident *id, ir_type *mt);

#include "end.h"

#endif