X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fanalyze_irg_args.c;h=7b6a98907a3a8cd94f5aa977c7c773c6208c3b5d;hb=6ccff2965d94c272f71df2a1655336af47bb7753;hp=30547564170af8d69904134890d0098f8ef1a320;hpb=ba4016c7aa0437c72ef7323ecea585828bdc038b;p=libfirm diff --git a/ir/ana/analyze_irg_args.c b/ir/ana/analyze_irg_args.c index 305475641..7b6a98907 100644 --- a/ir/ana/analyze_irg_args.c +++ b/ir/ana/analyze_irg_args.c @@ -21,7 +21,6 @@ * @file * @brief read/write analyze of graph argument, which have mode reference. * @author Beyhan Veliev - * @version $Id$ */ #include "config.h" @@ -36,9 +35,6 @@ #include "analyze_irg_args.h" -static char v; -static void *VISITED = &v; - /** * Walk recursive the successors of a graph argument * with mode reference and mark if it will be read, @@ -47,18 +43,19 @@ 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 ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits) +{ int i, p; ir_node *succ; /* We must visit a node once to avoid endless recursion.*/ - set_irn_link(arg, VISITED); + mark_irn_visited(arg); for (i = get_irn_n_outs(arg) - 1; i >= 0; --i) { succ = get_irn_out(arg, i); /* We was here.*/ - if (get_irn_link(succ) == VISITED) + if (irn_visited(succ)) continue; /* We should not walk over the memory edge.*/ @@ -82,8 +79,8 @@ static unsigned analyze_arg(ir_node *arg, unsigned bits) { } else { ir_entity *meth_ent; - if (is_Global(ptr)) { - meth_ent = get_Global_entity(ptr); + if (is_SymConst_addr_ent(ptr)) { + meth_ent = get_SymConst_entity(ptr); for (p = get_Call_n_params(succ) - 1; p >= 0; --p) { if (get_Call_param(succ, p) == arg) { @@ -93,11 +90,12 @@ static unsigned analyze_arg(ir_node *arg, unsigned bits) { } } else if (is_Sel(ptr) && get_irp_callee_info_state() == irg_callee_info_consistent) { /* is be a polymorphic call but callee information is available */ - int i, n_params = get_Call_n_params(succ); + int n_params = get_Call_n_params(succ); + int c; /* simply look into ALL possible callees */ - for (i = get_Call_n_callees(succ) - 1; i >= 0; --i) { - meth_ent = get_Call_callee(succ, i); + for (c = get_Call_n_callees(succ) - 1; c >= 0; --c) { + meth_ent = get_Call_callee(succ, c); /* unknown_entity is used to signal that we don't know what is called */ if (meth_ent == unknown_entity) { @@ -176,7 +174,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; @@ -260,7 +259,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()) @@ -278,13 +278,13 @@ void analyze_irg_args(ir_graph *irg) { * Compute for a method with pointer parameter(s) * if they will be read or written. */ -ptr_access_kind get_method_param_access(ir_entity *ent, int pos) +ptr_access_kind get_method_param_access(ir_entity *ent, size_t 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))); + assert(is_variadic || pos < get_method_n_params(mtp)); #endif if (ent->attr.mtd_attr.param_access) { @@ -317,19 +317,20 @@ enum args_weight { * * @param arg The parameter them weight muss be computed. */ -static unsigned calc_method_param_weight(ir_node *arg) { +static unsigned calc_method_param_weight(ir_node *arg) +{ int i, j, k; ir_node *succ, *op; unsigned weight = null_weight; /* We mark the nodes to avoid endless recursion */ - set_irn_link(arg, VISITED); + mark_irn_visited(arg); for (i = get_irn_n_outs(arg) - 1; i >= 0; i--) { succ = get_irn_out(arg, i); /* We was here.*/ - if (get_irn_link(succ) == VISITED) + if (irn_visited(succ)) continue; /* We should not walk over the memory edge.*/ @@ -420,7 +421,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; @@ -455,12 +457,6 @@ static void analyze_method_params_weight(ir_entity *ent) { proj_nr = get_Proj_proj(arg); ent->attr.mtd_attr.param_weight[proj_nr] += calc_method_param_weight(arg); } - -#if 0 - printf("\n%s:\n", get_entity_name(ent)); - for (i = nparams - 1; i >= 0; --i) - printf("The weight of argument %i is %f \n", i, ent->param_weight[i]); -#endif } /* @@ -476,7 +472,7 @@ static void analyze_method_params_weight(ir_entity *ent) { * @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) +unsigned get_method_param_weight(ir_entity *ent, size_t pos) { if (ent->attr.mtd_attr.param_weight) { if (pos < ARR_LEN(ent->attr.mtd_attr.param_weight)) @@ -499,13 +495,18 @@ 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) { - ir_entity *ent; +void analyze_irg_args_weight(ir_graph *irg) +{ + ir_entity *entity = get_irg_entity(irg); + if (entity == NULL) + return; - ent = get_irg_entity(irg); - if (ent == NULL) + assert(is_method_entity(entity)); + if (entity->attr.mtd_attr.param_weight != NULL) return; - if (! ent->attr.mtd_attr.param_weight) - analyze_method_params_weight(ent); + ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED); + inc_irg_visited(irg); + analyze_method_params_weight(entity); + ir_free_resources(irg, IR_RESOURCE_IRN_VISITED); }