X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fscalar_replace.c;h=99c0a709b6d8a587aabe1a267313c50acd2f9b6e;hb=6dc7084e6820b27a75a82d03341cff0f05ba67ba;hp=d432b4b197bf030480168ba8ffcbcd64ba494ede;hpb=32ea6ea0320f551448bb66e534e3351977464d42;p=libfirm diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c index d432b4b19..99c0a709b 100644 --- a/ir/opt/scalar_replace.c +++ b/ir/opt/scalar_replace.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -57,25 +57,24 @@ */ typedef union { ir_entity *ent; - tarval *tv; + ir_tarval *tv; } path_elem_t; /** * An access path, used to assign value numbers * to variables that will be scalar replaced. */ -typedef struct _path_t { +typedef struct path_t { unsigned vnum; /**< The value number. */ - unsigned path_len; /**< The length of the access path. */ + size_t path_len; /**< The length of the access path. */ path_elem_t path[1]; /**< The path. */ } path_t; /** The size of a path in bytes. */ #define PATH_SIZE(p) (sizeof(*(p)) + sizeof((p)->path[0]) * ((p)->path_len - 1)) -typedef struct _scalars_t { +typedef struct scalars_t { ir_entity *ent; /**< A entity for scalar replacement. */ - ir_type *ent_owner; /**< The owner of this entity. */ } scalars_t; DEBUG_ONLY(static firm_dbg_module_t *dbg;) @@ -87,8 +86,8 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;) */ static int path_cmp(const void *elt, const void *key, size_t size) { - const path_t *p1 = elt; - const path_t *p2 = key; + const path_t *p1 = (const path_t*)elt; + const path_t *p2 = (const path_t*)key; (void) size; /* we can use memcmp here, because identical tarvals should have identical addresses */ @@ -102,8 +101,8 @@ static int path_cmp(const void *elt, const void *key, size_t size) */ static int ent_cmp(const void *elt, const void *key, size_t size) { - const scalars_t *c1 = elt; - const scalars_t *c2 = key; + const scalars_t *c1 = (const scalars_t*)elt; + const scalars_t *c2 = (const scalars_t*)key; (void) size; return c1->ent != c2->ent; @@ -437,9 +436,10 @@ static int find_possible_replacements(ir_graph *irg) * @param sel the Sel node * @param len the length of the path so far */ -static path_t *find_path(ir_node *sel, unsigned len) +static path_t *find_path(ir_node *sel, size_t len) { - int pos, i, n; + size_t pos; + int i, n; path_t *res; ir_node *pred = get_Sel_ptr(sel); @@ -454,6 +454,7 @@ static path_t *find_path(ir_node *sel, unsigned len) } else res = find_path(pred, len); + assert(len <= res->path_len); pos = res->path_len - len; res->path[pos++].ent = get_Sel_entity(sel); @@ -486,14 +487,15 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum DB((dbg, SET_LEVEL_3, " Visiting Sel nodes of entity %+F\n", ent)); /* visit all Sel nodes in the chain of the entity */ - for (sel = get_entity_link(ent); sel; sel = next) { - next = get_irn_link(sel); + for (sel = (ir_node*)get_entity_link(ent); sel != NULL; + sel = next) { + next = (ir_node*)get_irn_link(sel); /* we must mark this sel for later */ pset_insert_ptr(sels, sel); key = find_path(sel, 0); - path = set_find(pathes, key, PATH_SIZE(key), path_hash(key)); + path = (path_t*)set_find(pathes, key, PATH_SIZE(key), path_hash(key)); if (path) { SET_VNUM(sel, path->vnum); @@ -506,7 +508,7 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum SET_VNUM(sel, key->vnum); DB((dbg, SET_LEVEL_3, " %+F represents value %u\n", sel, key->vnum)); - ARR_EXTO(ir_mode *, *modes, (int)((key->vnum + 15) & ~15)); + ARR_EXTO(ir_mode *, *modes, (key->vnum + 15) & ~15); (*modes)[key->vnum] = get_type_mode(get_entity_type(get_Sel_entity(sel))); @@ -538,7 +540,7 @@ static unsigned allocate_value_numbers(pset *sels, ir_entity *ent, unsigned vnum /** * A list entry for the fixing lists */ -typedef struct _list_entry_t { +typedef struct list_entry_t { ir_node *node; /**< the node that must be fixed */ unsigned vnum; /**< the value number of this node */ } list_entry_t; @@ -546,7 +548,7 @@ typedef struct _list_entry_t { /** * environment for memory walker */ -typedef struct _env_t { +typedef struct env_t { int nvals; /**< number of values */ ir_mode **modes; /**< the modes of the values */ pset *sels; /**< A set of all Sel nodes that have a value number */ @@ -557,10 +559,11 @@ typedef struct _env_t { */ static void topologic_walker(ir_node *node, void *ctx) { - env_t *env = ctx; - ir_node *adr, *block, *mem, *val; - ir_mode *mode; - unsigned vnum; + env_t *env = (env_t*)ctx; + ir_graph *irg = get_irn_irg(node); + ir_node *adr, *block, *mem, *val; + ir_mode *mode; + unsigned vnum; if (is_Load(node)) { /* a load, check if we can resolve it */ @@ -598,14 +601,14 @@ static void topologic_walker(ir_node *node, void *ctx) Handle this here. */ mode = get_Load_mode(node); if (mode != get_irn_mode(val)) - val = new_d_Conv(get_irn_dbg_info(node), val, mode); + val = new_rd_Conv(get_irn_dbg_info(node), block, val, mode); mem = get_Load_mem(node); turn_into_tuple(node, pn_Load_max); set_Tuple_pred(node, pn_Load_M, mem); set_Tuple_pred(node, pn_Load_res, val); - set_Tuple_pred(node, pn_Load_X_regular, new_Jmp()); - set_Tuple_pred(node, pn_Load_X_except, new_Bad()); + set_Tuple_pred(node, pn_Load_X_regular, new_r_Jmp(block)); + set_Tuple_pred(node, pn_Load_X_except, new_r_Bad(irg)); } else if (is_Store(node)) { DB((dbg, SET_LEVEL_3, " checking %+F for replacement ", node)); @@ -633,15 +636,15 @@ static void topologic_walker(ir_node *node, void *ctx) /* Beware: A Store can contain a hidden conversion in Firm. */ val = get_Store_value(node); if (get_irn_mode(val) != env->modes[vnum]) - val = new_d_Conv(get_irn_dbg_info(node), val, env->modes[vnum]); + val = new_rd_Conv(get_irn_dbg_info(node), block, val, env->modes[vnum]); set_value(vnum, val); mem = get_Store_mem(node); turn_into_tuple(node, pn_Store_max); set_Tuple_pred(node, pn_Store_M, mem); - set_Tuple_pred(node, pn_Store_X_regular, new_Jmp()); - set_Tuple_pred(node, pn_Store_X_except, new_Bad()); + set_Tuple_pred(node, pn_Store_X_regular, new_r_Jmp(block)); + set_Tuple_pred(node, pn_Store_X_except, new_r_Bad(irg)); } } @@ -653,24 +656,25 @@ static void topologic_walker(ir_node *node, void *ctx) * @param modes A flexible array, containing all the modes of * the value numbers. */ -static void do_scalar_replacements(pset *sels, int nvals, ir_mode **modes) +static void do_scalar_replacements(ir_graph *irg, pset *sels, int nvals, + ir_mode **modes) { env_t env; - ssa_cons_start(current_ir_graph, nvals); + ssa_cons_start(irg, nvals); - env.nvals = nvals; - env.modes = modes; - env.sels = sels; + env.nvals = nvals; + env.modes = modes; + env.sels = sels; /* * second step: walk over the graph blockwise in topological order * and fill the array as much as possible. */ - DB((dbg, SET_LEVEL_3, "Substituting Loads and Stores in %+F\n", current_ir_graph)); - irg_walk_blkwise_graph(current_ir_graph, NULL, topologic_walker, &env); + DB((dbg, SET_LEVEL_3, "Substituting Loads and Stores in %+F\n", irg)); + irg_walk_blkwise_graph(irg, NULL, topologic_walker, &env); - ssa_cons_finish(current_ir_graph); + ssa_cons_finish(irg); } /* @@ -688,12 +692,8 @@ int scalar_replacement_opt(ir_graph *irg) set *set_ent; pset *sels; ir_type *ent_type, *frame_tp; - ir_graph *rem; int res = 0; - rem = current_ir_graph; - current_ir_graph = irg; - /* Call algorithm that computes the out edges */ assure_irg_outs(irg); @@ -730,7 +730,6 @@ int scalar_replacement_opt(ir_graph *irg) ent_type = get_entity_type(ent); key.ent = ent; - key.ent_owner = get_entity_owner(ent); set_insert(set_ent, &key, sizeof(key), HASH_PTR(key.ent)); #ifdef DEBUG_libfirm @@ -753,10 +752,10 @@ int scalar_replacement_opt(ir_graph *irg) /* If scalars were found. */ if (nvals > 0) { - do_scalar_replacements(sels, nvals, modes); + do_scalar_replacements(irg, sels, nvals, modes); - foreach_set(set_ent, value) { - remove_class_member(value->ent_owner, value->ent); + foreach_set(set_ent, scalars_t*, value) { + free_entity(value->ent); } /* @@ -777,7 +776,6 @@ int scalar_replacement_opt(ir_graph *irg) ir_free_resources(irg, IR_RESOURCE_IRN_LINK); irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK); - current_ir_graph = rem; return res; }