X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fanalyze_irg_args.c;h=830898d02f82bdd5d97cf596e0e0f9916df7eca1;hb=3da5ed2598245b896255bc444aaa1768f6098cfe;hp=bb1c80b80718b21c309ab764f4deb930e4ee9933;hpb=4377f9bab6b511699c50ba4e8eaf1b5abcf30a68;p=libfirm diff --git a/ir/ana/analyze_irg_args.c b/ir/ana/analyze_irg_args.c index bb1c80b80..830898d02 100644 --- a/ir/ana/analyze_irg_args.c +++ b/ir/ana/analyze_irg_args.c @@ -23,21 +23,16 @@ * @author Beyhan Veliev * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif -#ifdef HAVE_STDLIB_H -# include -#endif +#include #include "irouts.h" #include "irnode_t.h" #include "irmode_t.h" -#include "array.h" +#include "array_t.h" #include "irprog.h" #include "entity_t.h" -#include "xmalloc.h" #include "analyze_irg_args.h" @@ -52,7 +47,8 @@ static void *VISITED = &v; * @param arg The graph argument with mode reference, * that must be checked. */ -static unsigned analyze_arg(ir_node *arg, unsigned bits) { +static unsigned analyze_arg(ir_node *arg, unsigned bits) +{ int i, p; ir_node *succ; @@ -181,7 +177,8 @@ static unsigned analyze_arg(ir_node *arg, unsigned bits) { * * @param irg The ir graph to analyze. */ -static void analyze_ent_args(ir_entity *ent) { +static void analyze_ent_args(ir_entity *ent) +{ ir_graph *irg; ir_node *irg_args, *arg; ir_mode *arg_mode; @@ -265,7 +262,8 @@ static void analyze_ent_args(ir_entity *ent) { * * @param irg The ir graph to analyze. */ -void analyze_irg_args(ir_graph *irg) { +void analyze_irg_args(ir_graph *irg) +{ ir_entity *ent; if (irg == get_const_code_irg()) @@ -322,8 +320,9 @@ enum args_weight { * * @param arg The parameter them weight muss be computed. */ -static unsigned calc_method_param_weight(ir_node *arg) { - int i; +static unsigned calc_method_param_weight(ir_node *arg) +{ + int i, j, k; ir_node *succ, *op; unsigned weight = null_weight; @@ -341,11 +340,15 @@ static unsigned calc_method_param_weight(ir_node *arg) { if (get_irn_mode(succ) == mode_M) continue; - if (is_Call(succ) && get_Call_ptr(succ) == arg) { - /* the arguments is used as an pointer input for a call, - we can probably change an indirect Call into a direct one. */ - weight += indirect_call_weight; - } else if (is_Cmp(succ)) { + switch (get_irn_opcode(succ)) { + case iro_Call: + if (get_Call_ptr(succ) == arg) { + /* the arguments is used as an pointer input for a call, + we can probably change an indirect Call into a direct one. */ + weight += indirect_call_weight; + } + break; + case iro_Cmp: /* We have reached a cmp and we must increase the weight with the cmp_weight. */ if (get_Cmp_left(succ) == arg) @@ -357,30 +360,59 @@ static unsigned calc_method_param_weight(ir_node *arg) { weight += const_cmp_weight; } else weight += cmp_weight; - } else if (is_Cond(succ)) { + break; + case iro_Cond: /* the argument is used for a SwitchCond, a big win */ weight += const_cmp_weight * get_irn_n_outs(succ); - } else if (is_binop(succ)) { - /* We have reached a BinOp and we must increase the - weight with the binop_weight. If the other operand of the - BinOp is a constant we increase the weight with const_binop_weight - and call the function recursive. - */ - if (get_binop_left(succ) == arg) - op = get_binop_right(succ); - else - op = get_binop_left(succ); - - if (is_irn_constlike(op)) { + break; + case iro_Id: + /* when looking backward we might find Id nodes */ + weight += calc_method_param_weight(succ); + break; + case iro_Tuple: + /* unoptimized tuple */ + for (j = get_Tuple_n_preds(succ) - 1; j >= 0; --j) { + ir_node *pred = get_Tuple_pred(succ, j); + if (pred == arg) { + /* look for Proj(j) */ + for (k = get_irn_n_outs(succ) - 1; k >= 0; --k) { + ir_node *succ_succ = get_irn_out(succ, k); + if (is_Proj(succ_succ)) { + if (get_Proj_proj(succ_succ) == j) { + /* found */ + weight += calc_method_param_weight(succ_succ); + } + } else { + /* this should NOT happen */ + } + } + } + } + break; + default: + if (is_binop(succ)) { + /* We have reached a BinOp and we must increase the + weight with the binop_weight. If the other operand of the + BinOp is a constant we increase the weight with const_binop_weight + and call the function recursive. + */ + if (get_binop_left(succ) == arg) + op = get_binop_right(succ); + else + op = get_binop_left(succ); + + if (is_irn_constlike(op)) { + weight += const_binop_weight; + weight += calc_method_param_weight(succ); + } else + weight += binop_weight; + } else if (is_unop(succ)) { + /* We have reached a binop and we must increase the + weight with the const_binop_weight and call the function recursive.*/ weight += const_binop_weight; weight += calc_method_param_weight(succ); - } else - weight += binop_weight; - } else if (is_unop(succ)) { - /* We have reached a binop and we must increase the - weight with the const_binop_weight and call the function recursive.*/ - weight += const_binop_weight; - weight += calc_method_param_weight(succ); + } + break; } } set_irn_link(arg, NULL); @@ -392,7 +424,8 @@ static unsigned calc_method_param_weight(ir_node *arg) { * * @param ent The entity of the ir_graph. */ -static void analyze_method_params_weight(ir_entity *ent) { +static void analyze_method_params_weight(ir_entity *ent) +{ ir_type *mtp; ir_graph *irg; int nparams, i, proj_nr; @@ -422,11 +455,10 @@ static void analyze_method_params_weight(ir_entity *ent) { assure_irg_outs(irg); irg_args = get_irg_args(irg); - for (i = get_irn_n_outs(irg_args) - 1; i >= 0; --i) { arg = get_irn_out(irg_args, i); proj_nr = get_Proj_proj(arg); - ent->attr.mtd_attr.param_weight[proj_nr] += calc_method_param_weight(arg); + ent->attr.mtd_attr.param_weight[proj_nr] += calc_method_param_weight(arg); } #if 0 @@ -442,15 +474,15 @@ static void analyze_method_params_weight(ir_entity *ent) { * higher optimization with procedure cloning. * * The values are calculation on demand only. + * + * @param ent the entity to analyze + * @param pos the argument number + * + * @return the parameter weight or null_weight if pos is greater + * than the number of arguments. */ unsigned get_method_param_weight(ir_entity *ent, int pos) { -#ifndef NDEBUG - ir_type *mtp = get_entity_type(ent); - int is_variadic = get_method_variadicity(mtp) == variadicity_variadic; - assert(0 <= pos && (is_variadic || pos < get_method_n_params(mtp))); -#endif - if (ent->attr.mtd_attr.param_weight) { if (pos < ARR_LEN(ent->attr.mtd_attr.param_weight)) return ent->attr.mtd_attr.param_weight[pos]; @@ -472,7 +504,8 @@ unsigned get_method_param_weight(ir_entity *ent, int pos) * * @param irg The ir graph to analyze. */ -void analyze_irg_args_weight(ir_graph *irg) { +void analyze_irg_args_weight(ir_graph *irg) +{ ir_entity *ent; ent = get_irg_entity(irg);