update automake stuff for release

[libfirm] / ir / opt / opt_inline.c

diff --git a/ir/opt/opt_inline.c b/ir/opt/opt_inline.c
index 0f13218..edadecd 100644 (file)
--- a/ir/opt/opt_inline.c
+++ b/ir/opt/opt_inline.c
@@ -190,11 +190,11 @@ static bool can_inline(ir_node *call, ir_graph *called_graph)
        ir_entity          *called      = get_irg_entity(called_graph);
        ir_type            *called_type = get_entity_type(called);
        ir_type            *call_type   = get_Call_type(call);
-       int                 n_params    = get_method_n_params(called_type);
-       int                 n_arguments = get_method_n_params(call_type);
-       int                 n_res       = get_method_n_ress(called_type);
+       size_t              n_params    = get_method_n_params(called_type);
+       size_t              n_arguments = get_method_n_params(call_type);
+       size_t              n_res       = get_method_n_ress(called_type);
        irg_inline_property prop        = get_irg_inline_property(called_graph);
-       int                 i;
+       size_t              i;
        bool                res;
 
        if (prop == irg_inline_forbidden)
@@ -214,7 +214,7 @@ static bool can_inline(ir_node *call, ir_graph *called_graph)
         * It is implementation dependent what happens in that case.
         * We support inlining, if the bitsize of the types matches AND
         * the same arithmetic is used. */
-       for (i = n_params - 1; i >= 0; --i) {
+       for (i = 0; i < n_params; ++i) {
                ir_type *param_tp = get_method_param_type(called_type, i);
                ir_type *arg_tp   = get_method_param_type(call_type, i);
 
@@ -231,7 +231,7 @@ static bool can_inline(ir_node *call, ir_graph *called_graph)
                        /* otherwise we can simply "reinterpret" the bits */
                }
        }
-       for (i = n_res - 1; i >= 0; --i) {
+       for (i = 0; i < n_res; ++i) {
                ir_type *decl_res_tp = get_method_res_type(called_type, i);
                ir_type *used_res_tp = get_method_res_type(call_type, i);
 
@@ -283,8 +283,8 @@ static void copy_frame_entities(ir_graph *from, ir_graph *to)
 {
        ir_type *from_frame = get_irg_frame_type(from);
        ir_type *to_frame   = get_irg_frame_type(to);
-       int      n_members  = get_class_n_members(from_frame);
-       int      i;
+       size_t   n_members  = get_class_n_members(from_frame);
+       size_t   i;
        assert(from_frame != to_frame);
 
        for (i = 0; i < n_members; ++i) {
@@ -393,7 +393,6 @@ int inline_method(ir_node *call, ir_graph *called_graph)
        in[pn_Start_M]              = get_Call_mem(call);
        in[pn_Start_X_initial_exec] = new_r_Jmp(post_bl);
        in[pn_Start_P_frame_base]   = get_irg_frame(irg);
-       in[pn_Start_P_tls]          = get_irg_tls(irg);
        in[pn_Start_T_args]         = new_r_Tuple(post_bl, n_params, args_in);
        pre_call = new_r_Tuple(post_bl, pn_Start_max, in);
        post_call = call;
@@ -558,9 +557,6 @@ int inline_method(ir_node *call, ir_graph *called_graph)
        /* handle the regular call */
        set_Tuple_pred(call, pn_Call_X_regular, new_r_Jmp(post_bl));
 
-       /* For now, we cannot inline calls with value_base */
-       set_Tuple_pred(call, pn_Call_P_value_res_base, new_r_Bad(irg));
-
        /* Finally the exception control flow.
           We have two possible situations:
           First if the Call branches to an exception handler:
@@ -968,7 +964,7 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
 {
        inline_irg_env   *env;
        ir_graph         *irg;
-       int              i, n_irgs;
+       size_t           i, n_irgs;
        ir_graph         *rem;
        int              did_inline;
        wenv_t           wenv;
@@ -1154,7 +1150,7 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
                                        /* call was inlined, Phi/Projs for current graph must be recomputed */
                                        phiproj_computed = 0;
 
-                                       /* callee was inline. Append it's call list. */
+                                       /* callee was inline. Append its call list. */
                                        env->got_inline = 1;
                                        --env->n_call_nodes;
                                        append_call_list(env, callee_env, entry->loop_depth);
@@ -1318,7 +1314,9 @@ static void analyze_irg_local_weights(inline_irg_env *env, ir_graph *irg)
 {
        ir_entity *ent = get_irg_entity(irg);
        ir_type  *mtp;
-       int      nparams, i, proj_nr;
+       size_t   nparams;
+       int      i;
+       long     proj_nr;
        ir_node  *irg_args, *arg;
 
        mtp      = get_entity_type(ent);
@@ -1345,17 +1343,12 @@ static void analyze_irg_local_weights(inline_irg_env *env, ir_graph *irg)
  * After inlining, the local variable might be transformed into a
  * SSA variable by scalar_replacement().
  */
-static unsigned get_method_local_adress_weight(ir_graph *callee, int pos)
+static unsigned get_method_local_adress_weight(ir_graph *callee, size_t pos)
 {
        inline_irg_env *env = (inline_irg_env*)get_irg_link(callee);
 
-       if (env->local_weights != NULL) {
-               if (pos < ARR_LEN(env->local_weights))
-                       return env->local_weights[pos];
-               return 0;
-       }
-
-       analyze_irg_local_weights(env, callee);
+       if (env->local_weights == NULL)
+               analyze_irg_local_weights(env, callee);
 
        if (pos < ARR_LEN(env->local_weights))
                return env->local_weights[pos];
@@ -1473,16 +1466,18 @@ static int calc_inline_benefice(call_entry *entry, ir_graph *callee)
        return entry->benefice = weight;
 }
 
-static ir_graph **irgs;
-static int      last_irg;
+typedef struct walk_env_t {
+       ir_graph **irgs;
+       size_t   last_irg;
+} walk_env_t;
 
 /**
  * Callgraph walker, collect all visited graphs.
  */
 static void callgraph_walker(ir_graph *irg, void *data)
 {
-       (void) data;
-       irgs[last_irg++] = irg;
+       walk_env_t *env = (walk_env_t *)data;
+       env->irgs[env->last_irg++] = irg;
 }
 
 /**
@@ -1492,21 +1487,22 @@ static void callgraph_walker(ir_graph *irg, void *data)
  */
 static ir_graph **create_irg_list(void)
 {
-       ir_entity **free_methods;
-       int       n_irgs = get_irp_n_irgs();
+       ir_entity  **free_methods;
+       size_t     n_irgs = get_irp_n_irgs();
+       walk_env_t env;
 
        cgana(&free_methods);
        xfree(free_methods);
 
        compute_callgraph();
 
-       last_irg = 0;
-       irgs     = XMALLOCNZ(ir_graph*, n_irgs);
+       env.irgs     = XMALLOCNZ(ir_graph*, n_irgs);
+       env.last_irg = 0;
 
-       callgraph_walk(NULL, callgraph_walker, NULL);
-       assert(n_irgs == last_irg);
+       callgraph_walk(NULL, callgraph_walker, &env);
+       assert(n_irgs == env.last_irg);
 
-       return irgs;
+       return env.irgs;
 }
 
 /**
@@ -1679,7 +1675,7 @@ static void inline_into(ir_graph *irg, unsigned maxsize,
                /* remove it from the caller list */
                list_del(&curr_call->list);
 
-               /* callee was inline. Append it's call list. */
+               /* callee was inline. Append its call list. */
                env->got_inline = 1;
                --env->n_call_nodes;
 
@@ -1721,7 +1717,7 @@ void inline_functions(unsigned maxsize, int inline_threshold,
                       opt_ptr after_inline_opt)
 {
        inline_irg_env   *env;
-       int              i, n_irgs;
+       size_t           i, n_irgs;
        ir_graph         *rem;
        wenv_t           wenv;
        pmap             *copied_graphs;