X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fdata_flow_scalar_replace.c;h=8d3f0882acae97fc3500bfab4b3a93437a50a154;hb=b4a3d8471ab4a2ad12041f4ef1cb2473d9b5fe4c;hp=7a7ee5e9cc6df581eda1fbec30525d7bab5d399d;hpb=863d31d7a5c8210432fef88b30fc3e8353131538;p=libfirm diff --git a/ir/opt/data_flow_scalar_replace.c b/ir/opt/data_flow_scalar_replace.c index 7a7ee5e9c..8d3f0882a 100644 --- a/ir/opt/data_flow_scalar_replace.c +++ b/ir/opt/data_flow_scalar_replace.c @@ -1,31 +1,36 @@ /* - * Project: libFIRM - * File name: ir/opt/data_flow_scalar_replace.c - * Purpose: scalar replacement of arrays and compounds - * Author: Beyhan Veliev - * Modified by: Michael Beck - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2005 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2008 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. + */ + +/** + * @file + * @brief scalar replacement of arrays and compounds + * @author Beyhan Veliev, Michael Beck + * @version $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#ifdef HAVE_ALLOCA_H -#include -#endif - -#ifdef HAVE_MALLOC_H -#include -#endif +#include "iroptimize.h" -#ifdef HAVE_STRING_H #include -#endif -#include "data_flow_scalar_replace.h" #include "irflag_t.h" #include "irouts.h" #include "pset.h" @@ -38,8 +43,8 @@ #include "irloop.h" #include "analyze_irg_args.h" #include "irprintf.h" -#include "compute_loop_info.h" #include "irgopt.h" +#include "xmalloc.h" #define SET_ENT_VNUM(ent, vnum) set_entity_link(ent, INT_TO_PTR(vnum)) #define GET_ENT_VNUM(ent) (unsigned)PTR_TO_INT(get_entity_link(ent)) @@ -129,6 +134,7 @@ static int ent_leaves_t_cmp(const void *elt, const void *key, size_t size) { const ent_leaves_t *c1 = elt; const ent_leaves_t *c2 = key; + (void) size; return c1->ent != c2->ent; } @@ -155,6 +161,7 @@ static int sels_cmp(const void *elt, const void *key, size_t size) { const sels_t *c1 = elt; const sels_t *c2 = key; + (void) size; return c1->sel != c2->sel; } @@ -181,6 +188,7 @@ static int call_cmp(const void *elt, const void *key, size_t size) { const call_access_t *c1 = elt; const call_access_t *c2 = key; + (void) size; return c1->call != c2->call; } @@ -194,6 +202,7 @@ static int path_cmp(const void *elt, const void *key, size_t size) { const path_t *p1 = elt; const path_t *p2 = key; + (void) size; /* we can use memcmp here, because identical tarvals should have identical addresses */ return memcmp(p1->path, p2->path, p1->path_len * sizeof(p1->path[0])); @@ -224,7 +233,7 @@ static int is_const_sel(ir_node *sel) { for (i = 0; i < n; ++i) { ir_node *idx = get_Sel_index(sel, i); - if (get_irn_op(idx) != op_Const) + if (!is_Const(idx)) return 0; } return 1; @@ -234,7 +243,7 @@ static int is_const_sel(ir_node *sel) { * Returns non-zero, if the address of an entity * represented by a Sel node (or it's successor Sels) is taken. */ -static int is_address_taken(ir_node *sel) +static int is_address_taken_2(ir_node *sel) { int i; @@ -257,7 +266,7 @@ static int is_address_taken(ir_node *sel) case iro_Sel: { /* Check the Sel successor of Sel */ - int res = is_address_taken(succ); + int res = is_address_taken_2(succ); if (res) return 1; @@ -293,9 +302,8 @@ static void link_all_leave_sels(ir_entity *ent, ir_node *sel) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(sel, i); - if (get_irn_op(succ) == op_Sel) + if (is_Sel(succ)) link_all_leave_sels(ent, succ); - } /* if Sel nodes with memory inputs are used, a entity can be @@ -352,7 +360,7 @@ static int find_possible_replacements(ir_graph *irg) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); set_entity_link(ent, NULL); } @@ -366,7 +374,7 @@ static int find_possible_replacements(ir_graph *irg) for (i = 0; i < n; ++i) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); ir_type *ent_type; @@ -388,7 +396,7 @@ static int find_possible_replacements(ir_graph *irg) /* we can handle arrays, structs and atomic types yet */ if (is_Array_type(ent_type) || is_Struct_type(ent_type) || is_atomic_type(ent_type)) { - if (is_address_taken(succ)) { + if (is_address_taken_2(succ)) { if (get_entity_link(ent)) /* killing one */ --res; set_entity_link(ent, ADDRESS_TAKEN); @@ -412,7 +420,7 @@ static int is_leave_sel(ir_node *sel) { for(i = get_irn_n_outs(sel) - 1; i >= 0; i--) { succ = get_irn_out(sel, i); - if(get_irn_op(succ) == op_Sel) + if (is_Sel(succ)) return 0; } @@ -435,7 +443,7 @@ static path_t *find_path(ir_node *sel, unsigned len) n = get_Sel_n_indexs(sel); len += n + 1; - if (get_irn_op(pred) != op_Sel) { + if (!is_Sel(pred)) { /* we found the root */ res = xmalloc(sizeof(*res) + (len - 1) * sizeof(res->path)); @@ -450,7 +458,7 @@ static path_t *find_path(ir_node *sel, unsigned len) for (i = 0; i < n; ++i) { ir_node *index = get_Sel_index(sel, i); - if(get_irn_op(index) == op_Const) + if (is_Const(index)) res->path[pos++].tv = get_Const_tarval(index); } return res; @@ -649,7 +657,7 @@ static void sync_stored_scalars(ir_node *blk, env_t *env) { /* We must check this, why it is possible to get a Bad node * form new_r_Sync(), when the node can be optimized. * In this case we must do nothing.*/ - if(get_irn_op(sync) == op_Sync) { + if (is_Sync(sync)) { val_arr[env->gl_mem_vnum].mem_edge_state = sync; /* We add this sync node to the sync's fix list.*/ add_sync_to_fixlist(val_arr[env->gl_mem_vnum].mem_edge_state, unk_vnum, env); @@ -797,9 +805,6 @@ static void split_call_mem_edge(env_t *env, ir_node *call, pset *accessed_entiti int *accessed_leaves_vnum = NULL; /**< An arraw, where are saved the value number, that are synced from call's sync node, if we need it.*/ - if(get_irn_node_nr(call) == 2763) - printf("\nHi\n"); - call_blk = get_nodes_block(call); val_arr = get_irn_link(call_blk); /* An array to save the memory edges, that must be @@ -879,8 +884,7 @@ static void split_call_mem_edge(env_t *env, ir_node *call, pset *accessed_entiti /* We must check this, why it is possible to get a Bad node * form new_r_Sync(), when the node can be optimized. * In this case we must do nothing.*/ - if(get_irn_op(sync) == op_Sync) { - + if (is_Sync(sync)) { set_Call_mem(call, sync); if(ARR_LEN(accessed_leaves_vnum)) /* We add this sync node to the sync's fix list.*/ @@ -915,7 +919,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) { else irn_blk = get_nodes_block(irn); - if (Block_not_block_visited(irn_blk)) { + if (!Block_block_visited(irn_blk)) { /* We sync first the stored scalar address in this block.*/ mark_Block_block_visited(irn_blk); sync_stored_scalars(irn_blk, env); @@ -937,7 +941,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) { /* Calls that have a NoMem input do neither read nor write memory. We can completely ignore them here. */ - if (get_irn_op(get_Call_mem(irn)) == op_NoMem) + if (is_NoMem(get_Call_mem(irn))) return; /* We save in this set all entities, @@ -949,7 +953,7 @@ static void split_memory_edge(ir_node *irn, void *ctx) { sel = get_Call_param(irn, i); value_sels = NULL; - if(get_irn_op(sel) == op_Sel) { + if (is_Sel(sel)) { key_sels.sel = sel; value_sels = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel)); @@ -982,7 +986,7 @@ static ir_node *find_vnum_value(ir_node *block, unsigned vnum) int i; ir_node *res; - if (Block_not_block_visited(block)) { + if (!Block_block_visited(block)) { mark_Block_block_visited(block); val_arr = get_irn_link(block); @@ -1094,7 +1098,7 @@ static void fix_syncs(env_t *env) pred = get_nodes_block(pred); /* We first repair the global memory edge at the first position of sync predecessors.*/ - if(get_irn_op(get_irn_n(sync, 0)) == op_Unknown) { + if (is_Unknown(get_irn_n(sync, 0))) { inc_irg_block_visited(current_ir_graph); val = find_vnum_value(pred, env->gl_mem_vnum); @@ -1106,7 +1110,7 @@ static void fix_syncs(env_t *env) /* We repair the leaves*/ assert(k <= ARR_LEN(l->accessed_vnum) && "The algorythm for sync repair is wron"); - if(get_irn_op(get_irn_n(sync, i)) == op_Unknown) { + if (is_Unknown(get_irn_n(sync, i))) { inc_irg_block_visited(current_ir_graph); val = find_vnum_value(pred, l->accessed_vnum[k++]); @@ -1212,7 +1216,6 @@ static void analyse_calls(ir_node *irn, void *ctx) { int i, vnum; unsigned int acces_type; ir_node *param, *call_ptr, *blk; - ir_op *op; ir_entity *meth_ent; sels_t key_sels, *value_sels; call_access_t key_call, *value_call; @@ -1220,18 +1223,18 @@ static void analyse_calls(ir_node *irn, void *ctx) { env_t *env; env = ctx; - if(get_irn_op(irn) != op_Call) + if (!is_Call(irn)) return; /* Calls that have a NoMem input do neither read nor write memory. We can completely ignore them here. */ - if (get_irn_op(get_Call_mem(irn)) == op_NoMem) + if (is_NoMem(get_Call_mem(irn))) return; /* We iterate over the parameters of this call nodes.*/ for ( i = get_Call_n_params(irn) - 1; i >= 0; i--) { param = get_Call_param(irn, i); - if(get_irn_op(param) == op_Sel) { + if (is_Sel(param)) { /* We have found a parameter with operation sel.*/ key_sels.sel = param; value_sels = set_find(env->set_sels, &key_sels, sizeof(key_sels), HASH_PTR(key_sels.sel)); @@ -1239,9 +1242,8 @@ static void analyse_calls(ir_node *irn, void *ctx) { /* We have found a call, that have as parameter a sel from our set_sels.*/ call_ptr = get_Call_ptr(irn); - op = get_irn_op(call_ptr); - if(op == op_SymConst && get_SymConst_kind(call_ptr) == symconst_addr_ent) { + if (is_SymConst(call_ptr) && get_SymConst_kind(call_ptr) == symconst_addr_ent) { meth_ent = get_SymConst_entity(call_ptr); /* we get the access type for our sel.*/ acces_type = get_method_param_access(meth_ent, i); @@ -1493,13 +1495,13 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) { remove_critical_cf_edges(irg); /* Call algorithm that computes the out edges.*/ - if (get_irg_outs_state(irg) != outs_consistent) - compute_irg_outs(irg); + assure_irg_outs(irg); /* Call algorithm that computes the loop information.*/ - compute_loop_info(irg); + construct_cf_backedges(irg); + /* Call algorithm that computes the dominance information.*/ - compute_doms(irg); + assure_doms(irg); /* Find possible scalar replacements */ if (find_possible_replacements(irg)) { @@ -1510,7 +1512,7 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) { for (i = 0 ; i < get_irn_n_outs(irg_frame); i++) { ir_node *succ = get_irn_out(irg_frame, i); - if (get_irn_op(succ) == op_Sel) { + if (is_Sel(succ)) { ir_entity *ent = get_Sel_entity(succ); if (get_entity_link(ent) == NULL || get_entity_link(ent) == ADDRESS_TAKEN) @@ -1525,9 +1527,6 @@ void data_flow_scalar_replacement_opt(ir_graph *irg) { } } - if(get_firm_verbosity()) - printf("vnumber in data flow= %i\n", vnum); - /* Allocate value number for the globule memory edge. * and a value number for the value numbers state.*/ vnum = vnum + 2;