aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gcc/ChangeLog73
-rw-r--r--gcc/tree-ssa-alias-warnings.c4
-rw-r--r--gcc/tree-ssa-ccp.c10
-rw-r--r--gcc/tree-ssa-coalesce.c4
-rw-r--r--gcc/tree-ssa-copy.c24
-rw-r--r--gcc/tree-ssa-dom.c32
-rw-r--r--gcc/tree-ssa-dse.c23
-rw-r--r--gcc/tree-ssa-loop-im.c36
-rw-r--r--gcc/tree-ssa-loop-ivopts.c23
-rw-r--r--gcc/tree-ssa-loop-niter.c10
-rw-r--r--gcc/tree-ssa-loop-prefetch.c2
-rw-r--r--gcc/tree-ssa-math-opts.c2
-rw-r--r--gcc/tree-ssa-operands.c69
-rw-r--r--gcc/tree-ssa-phiopt.c48
-rw-r--r--gcc/tree-ssa-pre.c20
-rw-r--r--gcc/tree-ssa-reassoc.c2
-rw-r--r--gcc/tree-ssa-structalias.c11
-rw-r--r--gcc/tree-ssa-threadupdate.c14
-rw-r--r--gcc/tree-ssa.c2
-rw-r--r--gcc/tree-ssanames.c2
20 files changed, 246 insertions, 165 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c493244..c4a7680 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,76 @@
+2007-06-06 Thomas Neumann <tneumann@users.sourceforge.net>
+
+ * tree-ssa-alias-warnings.c (maybe_add_match): Cast according to the
+ coding conventions.
+ (add_key): Likewise.
+ * tree-ssa.c (init_tree_ssa): Use type safe memory macros.
+ * tree-ssa-ccp.c (ccp_fold_builtin): Avoid using C++ keywords as
+ variable names.
+ * tree-ssa-coalesce.c (find_coalesce_pair): Use type safe memory macros.
+ (add_cost_one_coalesce): Likewise.
+ * tree-ssa-copy.c (merge_alias_info): Avoid using C++ keywords as
+ variable names. Rename orig to orig_name for consistency.
+ * tree-ssa-dom.c (dom_thread_across_edge): Cast according to the coding
+ conventions.
+ (cprop_into_successor_phis): Avoid using C++ keywords as variable names.
+ (record_equivalences_from_stmt): Likewise.
+ * tree-ssa-dse.c (dse_initialize_block_local_data): Cast according to
+ the coding conventions.
+ (memory_ssa_name_same): Likewise.
+ (dse_optimize_stmt): Likewise.
+ (dse_record_phis): Likewise.
+ (dse_finalize_block): Likewise.
+ * tree-ssa-loop-im.c (outermost_invariant_loop_expr): Avoid using C++
+ keywords as variable names.
+ (may_move_till): Cast according to the coding conventions.
+ (force_move_till_expr): Avoid using C++ keywords as variable names.
+ (force_move_till): Cast according to the coding conventions.
+ (memref_hash): Likewise.
+ (memref_eq): Likewise.
+ (gather_mem_refs_stmt): Likewise.
+ * tree-ssa-loop-ivopts.c (contains_abnormal_ssa_name_p): Avoid using C++
+ keywords as variable names.
+ (idx_find_step): Cast according to the coding conventions.
+ (idx_record_use): Likewise.
+ (find_depends): Likewise.
+ (prepare_decl_rtl): Likewise.
+ (mbc_entry_hash): Likewise.
+ (mbc_entry_eq): Likewise.
+ * tree-ssa-loop-niter.c (SWAP): Use the correct the type for tmp.
+ (simplify_replace_tree): Avoid using C++ keywords as variable names.
+ (idx_infer_loop_bounds): Cast according to the coding conventions.
+ * tree-ssa-loop-prefetch.c (idx_analyze_ref): Likewise.
+ * tree-ssa-math-opts.c (occ_new ): Likwise.
+ * tree-ssanames.c (duplicate_ssa_name_ptr_info): Use type safe memory
+ macros.
+ * tree-ssa-operands.c (add_def_op): Avoid using C++ keywords as variable
+ names.
+ (add_use_op): Likewise.
+ (add_vop): Likewise.
+ (add_vuse_op): Likewise.
+ (add_vdef_op): Likewise.
+ (get_expr_operands): Likewise.
+ (push_stmt_changes): Use type safe memory macros.
+ * tree-ssa-phiopt.c (replace_phi_edge_with_variable): Avoid using C++
+ keywords as variable names.
+ (conditional_replacement): Likewise.
+ (minmax_replacement): Likewise.
+ (abs_replacement): Likewise.
+ * tree-ssa-pre.c (create_expression_by_pieces): Cast according to the
+ coding conventions.
+ (insert_fake_stores): Avoid using C++ keywords as variable names.
+ * tree-ssa-reassoc.c (add_to_ops_vec): Cast according to the coding
+ conventions.
+ * tree-ssa-structalias.c (heapvar_lookup): Likewise.
+ (heapvar_insert): Use type safe memory macros.
+ (new_var_info): Cast according to the coding conventions.
+ (new_constraint): Likewise.
+ (remove_preds_and_fake_succs): Use type safe memory macros.
+ * tree-ssa-threadupdate.c (thread_block): Cast according to the coding
+ conventions.
+ (thread_single_edge): Likewise.
+ (thread_through_loop_header): Likewise.
+
2007-06-06 Eric Christopher <echristo@apple.com>
* config/i386/i386.c (override_options): Move handling
diff --git a/gcc/tree-ssa-alias-warnings.c b/gcc/tree-ssa-alias-warnings.c
index 8bd5388..4f83de4 100644
--- a/gcc/tree-ssa-alias-warnings.c
+++ b/gcc/tree-ssa-alias-warnings.c
@@ -379,7 +379,7 @@ match (htab_t ref_map, tree key)
static inline void
maybe_add_match (htab_t ref_map, struct tree_map *key)
{
- struct tree_map *found = htab_find (ref_map, key);
+ struct tree_map *found = (struct tree_map *) htab_find (ref_map, key);
if (found && !found->to)
found->to = key->to;
@@ -392,7 +392,7 @@ static void
add_key (htab_t ht, tree t, alloc_pool references_pool)
{
void **slot;
- struct tree_map *tp = pool_alloc (references_pool);
+ struct tree_map *tp = (struct tree_map *) pool_alloc (references_pool);
tp->base.from = t;
tp->to = NULL_TREE;
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 6c94755..3b275ba 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -2395,14 +2395,14 @@ ccp_fold_builtin (tree stmt, tree fn)
case BUILT_IN_STRLEN:
if (val[0])
{
- tree new = fold_convert (TREE_TYPE (fn), val[0]);
+ tree new_val = fold_convert (TREE_TYPE (fn), val[0]);
/* If the result is not a valid gimple value, or not a cast
of a valid gimple value, then we can not use the result. */
- if (is_gimple_val (new)
- || (is_gimple_cast (new)
- && is_gimple_val (TREE_OPERAND (new, 0))))
- return new;
+ if (is_gimple_val (new_val)
+ || (is_gimple_cast (new_val)
+ && is_gimple_val (TREE_OPERAND (new_val, 0))))
+ return new_val;
}
break;
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index 5953fec..04f97cf 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -260,7 +260,7 @@ find_coalesce_pair (coalesce_list_p cl, int p1, int p2, bool create)
if (create && !pair)
{
gcc_assert (cl->sorted == NULL);
- pair = xmalloc (sizeof (struct coalesce_pair));
+ pair = XNEW (struct coalesce_pair);
pair->first_element = p.first_element;
pair->second_element = p.second_element;
pair->cost = 0;
@@ -276,7 +276,7 @@ add_cost_one_coalesce (coalesce_list_p cl, int p1, int p2)
{
cost_one_pair_p pair;
- pair = xmalloc (sizeof (struct cost_one_pair_d));
+ pair = XNEW (struct cost_one_pair_d);
pair->first_element = p1;
pair->second_element = p2;
pair->next = cl->cost_one_list;
diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index 0bf85e5..97c4c03 100644
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -199,31 +199,31 @@ may_propagate_copy_into_asm (tree dest)
they both share the same memory tags. */
void
-merge_alias_info (tree orig, tree new)
+merge_alias_info (tree orig_name, tree new_name)
{
- tree new_sym = SSA_NAME_VAR (new);
- tree orig_sym = SSA_NAME_VAR (orig);
+ tree new_sym = SSA_NAME_VAR (new_name);
+ tree orig_sym = SSA_NAME_VAR (orig_name);
var_ann_t new_ann = var_ann (new_sym);
var_ann_t orig_ann = var_ann (orig_sym);
/* No merging necessary when memory partitions are involved. */
- if (factoring_name_p (new))
+ if (factoring_name_p (new_name))
{
gcc_assert (!is_gimple_reg (orig_sym));
return;
}
- else if (factoring_name_p (orig))
+ else if (factoring_name_p (orig_name))
{
gcc_assert (!is_gimple_reg (new_sym));
return;
}
- gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig)));
- gcc_assert (POINTER_TYPE_P (TREE_TYPE (new)));
+ gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig_name)));
+ gcc_assert (POINTER_TYPE_P (TREE_TYPE (new_name)));
#if defined ENABLE_CHECKING
- gcc_assert (lang_hooks.types_compatible_p (TREE_TYPE (orig),
- TREE_TYPE (new)));
+ gcc_assert (lang_hooks.types_compatible_p (TREE_TYPE (orig_name),
+ TREE_TYPE (new_name)));
/* If the pointed-to alias sets are different, these two pointers
would never have the same memory tag. In this case, NEW should
@@ -259,10 +259,10 @@ merge_alias_info (tree orig, tree new)
Since we cannot distinguish one case from another in this
function, we can only make sure that if P_i and Q_j have
flow-sensitive information, they should be compatible. */
- if (SSA_NAME_PTR_INFO (orig) && SSA_NAME_PTR_INFO (new))
+ if (SSA_NAME_PTR_INFO (orig_name) && SSA_NAME_PTR_INFO (new_name))
{
- struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig);
- struct ptr_info_def *new_ptr_info = SSA_NAME_PTR_INFO (new);
+ struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig_name);
+ struct ptr_info_def *new_ptr_info = SSA_NAME_PTR_INFO (new_name);
/* Note that pointer NEW and ORIG may actually have different
pointed-to variables (e.g., PR 18291 represented in
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 87270fc..0241155 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -569,7 +569,7 @@ dom_thread_across_edge (struct dom_walk_data *walk_data, edge e)
walk_data->global_data = dummy_cond;
}
- thread_across_edge (walk_data->global_data, e, false,
+ thread_across_edge ((tree) walk_data->global_data, e, false,
&const_and_copies_stack,
simplify_stmt_for_jump_threading);
}
@@ -1239,26 +1239,26 @@ cprop_into_successor_phis (basic_block bb)
indx = e->dest_idx;
for ( ; phi; phi = PHI_CHAIN (phi))
{
- tree new;
+ tree new_val;
use_operand_p orig_p;
- tree orig;
+ tree orig_val;
/* The alternative may be associated with a constant, so verify
it is an SSA_NAME before doing anything with it. */
orig_p = PHI_ARG_DEF_PTR (phi, indx);
- orig = USE_FROM_PTR (orig_p);
- if (TREE_CODE (orig) != SSA_NAME)
+ orig_val = USE_FROM_PTR (orig_p);
+ if (TREE_CODE (orig_val) != SSA_NAME)
continue;
/* If we have *ORIG_P in our constant/copy table, then replace
ORIG_P with its value in our constant/copy table. */
- new = SSA_NAME_VALUE (orig);
- if (new
- && new != orig
- && (TREE_CODE (new) == SSA_NAME
- || is_gimple_min_invariant (new))
- && may_propagate_copy (orig, new))
- propagate_value (orig_p, new);
+ new_val = SSA_NAME_VALUE (orig_val);
+ if (new_val
+ && new_val != orig_val
+ && (TREE_CODE (new_val) == SSA_NAME
+ || is_gimple_min_invariant (new_val))
+ && may_propagate_copy (orig_val, new_val))
+ propagate_value (orig_p, new_val);
}
}
}
@@ -1591,7 +1591,7 @@ record_equivalences_from_stmt (tree stmt, int may_optimize_p, stmt_ann_t ann)
&& !is_gimple_reg (lhs))
{
tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
- tree new;
+ tree new_stmt;
/* FIXME: If the LHS of the assignment is a bitfield and the RHS
is a constant, we need to adjust the constant to fit into the
@@ -1617,13 +1617,13 @@ record_equivalences_from_stmt (tree stmt, int may_optimize_p, stmt_ann_t ann)
if (rhs)
{
/* Build a new statement with the RHS and LHS exchanged. */
- new = build_gimple_modify_stmt (rhs, lhs);
+ new_stmt = build_gimple_modify_stmt (rhs, lhs);
- create_ssa_artificial_load_stmt (new, stmt);
+ create_ssa_artificial_load_stmt (new_stmt, stmt);
/* Finally enter the statement into the available expression
table. */
- lookup_avail_expr (new, true);
+ lookup_avail_expr (new_stmt, true);
}
}
}
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 596d4a8..1be4127 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -168,7 +168,8 @@ dse_initialize_block_local_data (struct dom_walk_data *walk_data,
bool recycled)
{
struct dse_block_local_data *bd
- = VEC_last (void_p, walk_data->block_data_stack);
+ = (struct dse_block_local_data *)
+ VEC_last (void_p, walk_data->block_data_stack);
/* If we are given a recycled block local data structure, ensure any
bitmap associated with the block is cleared. */
@@ -190,7 +191,7 @@ static tree
memory_ssa_name_same (tree *expr_p, int *walk_subtrees ATTRIBUTE_UNUSED,
void *data)
{
- struct address_walk_data *walk_data = data;
+ struct address_walk_data *walk_data = (struct address_walk_data *) data;
tree expr = *expr_p;
tree def_stmt;
basic_block def_bb;
@@ -615,8 +616,10 @@ dse_optimize_stmt (struct dom_walk_data *walk_data,
block_stmt_iterator bsi)
{
struct dse_block_local_data *bd
- = VEC_last (void_p, walk_data->block_data_stack);
- struct dse_global_data *dse_gd = walk_data->global_data;
+ = (struct dse_block_local_data *)
+ VEC_last (void_p, walk_data->block_data_stack);
+ struct dse_global_data *dse_gd
+ = (struct dse_global_data *) walk_data->global_data;
tree stmt = bsi_stmt (bsi);
stmt_ann_t ann = stmt_ann (stmt);
@@ -722,8 +725,10 @@ static void
dse_record_phis (struct dom_walk_data *walk_data, basic_block bb)
{
struct dse_block_local_data *bd
- = VEC_last (void_p, walk_data->block_data_stack);
- struct dse_global_data *dse_gd = walk_data->global_data;
+ = (struct dse_block_local_data *)
+ VEC_last (void_p, walk_data->block_data_stack);
+ struct dse_global_data *dse_gd
+ = (struct dse_global_data *) walk_data->global_data;
tree phi;
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
@@ -738,8 +743,10 @@ dse_finalize_block (struct dom_walk_data *walk_data,
basic_block bb ATTRIBUTE_UNUSED)
{
struct dse_block_local_data *bd
- = VEC_last (void_p, walk_data->block_data_stack);
- struct dse_global_data *dse_gd = walk_data->global_data;
+ = (struct dse_block_local_data *)
+ VEC_last (void_p, walk_data->block_data_stack);
+ struct dse_global_data *dse_gd
+ = (struct dse_global_data *) walk_data->global_data;
bitmap stores = dse_gd->stores;
unsigned int i;
bitmap_iterator bi;
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index 4bed167..5b00cf6 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -330,7 +330,7 @@ outermost_invariant_loop (tree def, struct loop *loop)
static struct loop *
outermost_invariant_loop_expr (tree expr, struct loop *loop)
{
- enum tree_code_class class = TREE_CODE_CLASS (TREE_CODE (expr));
+ enum tree_code_class codeclass = TREE_CODE_CLASS (TREE_CODE (expr));
unsigned i, nops;
struct loop *max_loop = superloop_at_depth (loop, 1), *aloop;
@@ -339,11 +339,11 @@ outermost_invariant_loop_expr (tree expr, struct loop *loop)
|| is_gimple_min_invariant (expr))
return outermost_invariant_loop (expr, loop);
- if (class != tcc_unary
- && class != tcc_binary
- && class != tcc_expression
- && class != tcc_vl_exp
- && class != tcc_comparison)
+ if (codeclass != tcc_unary
+ && codeclass != tcc_binary
+ && codeclass != tcc_expression
+ && codeclass != tcc_vl_exp
+ && codeclass != tcc_comparison)
return NULL;
nops = TREE_OPERAND_LENGTH (expr);
@@ -883,7 +883,7 @@ move_computations (void)
static bool
may_move_till (tree ref, tree *index, void *data)
{
- struct loop *loop = data, *max_loop;
+ struct loop *loop = (struct loop*) data, *max_loop;
/* If REF is an array reference, check also that the step and the lower
bound is invariant in LOOP. */
@@ -914,7 +914,7 @@ may_move_till (tree ref, tree *index, void *data)
static void
force_move_till_expr (tree expr, struct loop *orig_loop, struct loop *loop)
{
- enum tree_code_class class = TREE_CODE_CLASS (TREE_CODE (expr));
+ enum tree_code_class codeclass = TREE_CODE_CLASS (TREE_CODE (expr));
unsigned i, nops;
if (TREE_CODE (expr) == SSA_NAME)
@@ -927,11 +927,11 @@ force_move_till_expr (tree expr, struct loop *orig_loop, struct loop *loop)
return;
}
- if (class != tcc_unary
- && class != tcc_binary
- && class != tcc_expression
- && class != tcc_vl_exp
- && class != tcc_comparison)
+ if (codeclass != tcc_unary
+ && codeclass != tcc_binary
+ && codeclass != tcc_expression
+ && codeclass != tcc_vl_exp
+ && codeclass != tcc_comparison)
return;
nops = TREE_OPERAND_LENGTH (expr);
@@ -953,7 +953,7 @@ static bool
force_move_till (tree ref, tree *index, void *data)
{
tree stmt;
- struct fmt_data *fmt_data = data;
+ struct fmt_data *fmt_data = (struct fmt_data *) data;
if (TREE_CODE (ref) == ARRAY_REF)
{
@@ -1285,9 +1285,7 @@ loop_suitable_for_sm (struct loop *loop ATTRIBUTE_UNUSED,
static hashval_t
memref_hash (const void *obj)
{
- const struct mem_ref *mem = obj;
-
- return mem->hash;
+ return ((const struct mem_ref *) obj)->hash;
}
/* An equality function for struct mem_ref object OBJ1 with
@@ -1296,7 +1294,7 @@ memref_hash (const void *obj)
static int
memref_eq (const void *obj1, const void *obj2)
{
- const struct mem_ref *mem1 = obj1;
+ const struct mem_ref *mem1 = (const struct mem_ref *) obj1;
return operand_equal_p (mem1->mem, (tree) obj2, 0);
}
@@ -1359,7 +1357,7 @@ gather_mem_refs_stmt (struct loop *loop, htab_t mem_refs,
slot = htab_find_slot_with_hash (mem_refs, *mem, hash, INSERT);
if (*slot)
- ref = *slot;
+ ref = (struct mem_ref *) *slot;
else
{
ref = XNEW (struct mem_ref);
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 1e5c503..326c4db 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -634,13 +634,13 @@ bool
contains_abnormal_ssa_name_p (tree expr)
{
enum tree_code code;
- enum tree_code_class class;
+ enum tree_code_class codeclass;
if (!expr)
return false;
code = TREE_CODE (expr);
- class = TREE_CODE_CLASS (code);
+ codeclass = TREE_CODE_CLASS (code);
if (code == SSA_NAME)
return SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr) != 0;
@@ -654,7 +654,7 @@ contains_abnormal_ssa_name_p (tree expr)
idx_contains_abnormal_ssa_name_p,
NULL);
- switch (class)
+ switch (codeclass)
{
case tcc_binary:
case tcc_comparison:
@@ -711,7 +711,7 @@ niter_for_exit (struct ivopts_data *data, edge exit)
*pointer_map_insert (data->niters, exit) = niter;
}
else
- niter = *slot;
+ niter = (tree) *slot;
return niter;
}
@@ -1295,7 +1295,7 @@ struct ifs_ivopts_data
static bool
idx_find_step (tree base, tree *idx, void *data)
{
- struct ifs_ivopts_data *dta = data;
+ struct ifs_ivopts_data *dta = (struct ifs_ivopts_data *) data;
struct iv *iv;
tree step, iv_base, iv_step, lbound, off;
struct loop *loop = dta->ivopts_data->current_loop;
@@ -1374,8 +1374,9 @@ idx_find_step (tree base, tree *idx, void *data)
static bool
idx_record_use (tree base, tree *idx,
- void *data)
+ void *vdata)
{
+ struct ivopts_data *data = (struct ivopts_data *) vdata;
find_interesting_uses_op (data, *idx);
if (TREE_CODE (base) == ARRAY_REF)
{
@@ -1905,7 +1906,7 @@ static struct ivopts_data *fd_ivopts_data;
static tree
find_depends (tree *expr_p, int *ws ATTRIBUTE_UNUSED, void *data)
{
- bitmap *depends_on = data;
+ bitmap *depends_on = (bitmap *) data;
struct version_info *info;
if (TREE_CODE (*expr_p) != SSA_NAME)
@@ -2402,7 +2403,7 @@ prepare_decl_rtl (tree *expr_p, int *ws, void *data)
{
tree obj = NULL_TREE;
rtx x = NULL_RTX;
- int *regno = data;
+ int *regno = (int *) data;
switch (TREE_CODE (*expr_p))
{
@@ -2756,7 +2757,7 @@ struct mbc_entry
static hashval_t
mbc_entry_hash (const void *entry)
{
- const struct mbc_entry *e = entry;
+ const struct mbc_entry *e = (const struct mbc_entry *) entry;
return 57 * (hashval_t) e->mode + (hashval_t) (e->cst % 877);
}
@@ -2766,8 +2767,8 @@ mbc_entry_hash (const void *entry)
static int
mbc_entry_eq (const void *entry1, const void *entry2)
{
- const struct mbc_entry *e1 = entry1;
- const struct mbc_entry *e2 = entry2;
+ const struct mbc_entry *e1 = (const struct mbc_entry *) entry1;
+ const struct mbc_entry *e2 = (const struct mbc_entry *) entry2;
return (e1->mode == e2->mode
&& e1->cst == e2->cst);
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 0462e4e..11e90a7 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -44,7 +44,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#include "tree-inline.h"
#include "gmp.h"
-#define SWAP(X, Y) do { void *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
+#define SWAP(X, Y) do { affine_iv *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
/* The maximum number of dominator BBs we search for conditions
of loop header copies we use for simplifying a conditional
@@ -1324,7 +1324,7 @@ number_of_iterations_cond (struct loop *loop,
/* Substitute NEW for OLD in EXPR and fold the result. */
static tree
-simplify_replace_tree (tree expr, tree old, tree new)
+simplify_replace_tree (tree expr, tree old, tree new_tree)
{
unsigned i, n;
tree ret = NULL_TREE, e, se;
@@ -1334,7 +1334,7 @@ simplify_replace_tree (tree expr, tree old, tree new)
if (expr == old
|| operand_equal_p (expr, old, 0))
- return unshare_expr (new);
+ return unshare_expr (new_tree);
if (!EXPR_P (expr) && !GIMPLE_STMT_P (expr))
return expr;
@@ -1343,7 +1343,7 @@ simplify_replace_tree (tree expr, tree old, tree new)
for (i = 0; i < n; i++)
{
e = TREE_OPERAND (expr, i);
- se = simplify_replace_tree (e, old, new);
+ se = simplify_replace_tree (e, old, new_tree);
if (e == se)
continue;
@@ -2509,7 +2509,7 @@ struct ilb_data
static bool
idx_infer_loop_bounds (tree base, tree *idx, void *dta)
{
- struct ilb_data *data = dta;
+ struct ilb_data *data = (struct ilb_data *) dta;
tree ev, init, step;
tree low, high, type, next;
bool sign, upper = data->reliable, at_end = false;
diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c
index 3159748..64f45a8 100644
--- a/gcc/tree-ssa-loop-prefetch.c
+++ b/gcc/tree-ssa-loop-prefetch.c
@@ -343,7 +343,7 @@ struct ar_data
static bool
idx_analyze_ref (tree base, tree *index, void *data)
{
- struct ar_data *ar_data = data;
+ struct ar_data *ar_data = (struct ar_data *) data;
tree ibase, step, stepsize;
HOST_WIDE_INT istep, idelta = 0, imult = 1;
affine_iv iv;
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index 0bb999c..fe67993 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -151,7 +151,7 @@ occ_new (basic_block bb, struct occurrence *children)
{
struct occurrence *occ;
- occ = bb->aux = pool_alloc (occ_pool);
+ bb->aux = occ = (struct occurrence *) pool_alloc (occ_pool);
memset (occ, 0, sizeof (struct occurrence));
occ->bb = bb;
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 7ced6a8..d015a56 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -592,13 +592,13 @@ set_virtual_use_link (use_operand_p ptr, tree stmt)
static inline def_optype_p
add_def_op (tree *op, def_optype_p last)
{
- def_optype_p new;
+ def_optype_p new_def;
- new = alloc_def ();
- DEF_OP_PTR (new) = op;
- last->next = new;
- new->next = NULL;
- return new;
+ new_def = alloc_def ();
+ DEF_OP_PTR (new_def) = op;
+ last->next = new_def;
+ new_def->next = NULL;
+ return new_def;
}
@@ -607,14 +607,14 @@ add_def_op (tree *op, def_optype_p last)
static inline use_optype_p
add_use_op (tree stmt, tree *op, use_optype_p last)
{
- use_optype_p new;
+ use_optype_p new_use;
- new = alloc_use ();
- USE_OP_PTR (new)->use = op;
- link_imm_use_stmt (USE_OP_PTR (new), *op, stmt);
- last->next = new;
- new->next = NULL;
- return new;
+ new_use = alloc_use ();
+ USE_OP_PTR (new_use)->use = op;
+ link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
+ last->next = new_use;
+ new_use->next = NULL;
+ return new_use;
}
@@ -625,22 +625,23 @@ add_use_op (tree stmt, tree *op, use_optype_p last)
static inline voptype_p
add_vop (tree stmt, tree op, int num, voptype_p prev)
{
- voptype_p new;
+ voptype_p new_vop;
int x;
- new = alloc_vop (num);
+ new_vop = alloc_vop (num);
for (x = 0; x < num; x++)
{
- VUSE_OP_PTR (new, x)->prev = NULL;
- SET_VUSE_OP (new, x, op);
- VUSE_OP_PTR (new, x)->use = &new->usev.uses[x].use_var;
- link_imm_use_stmt (VUSE_OP_PTR (new, x), new->usev.uses[x].use_var, stmt);
+ VUSE_OP_PTR (new_vop, x)->prev = NULL;
+ SET_VUSE_OP (new_vop, x, op);
+ VUSE_OP_PTR (new_vop, x)->use = &new_vop->usev.uses[x].use_var;
+ link_imm_use_stmt (VUSE_OP_PTR (new_vop, x),
+ new_vop->usev.uses[x].use_var, stmt);
}
if (prev)
- prev->next = new;
- new->next = NULL;
- return new;
+ prev->next = new_vop;
+ new_vop->next = NULL;
+ return new_vop;
}
@@ -650,9 +651,9 @@ add_vop (tree stmt, tree op, int num, voptype_p prev)
static inline voptype_p
add_vuse_op (tree stmt, tree op, int num, voptype_p last)
{
- voptype_p new = add_vop (stmt, op, num, last);
- VDEF_RESULT (new) = NULL_TREE;
- return new;
+ voptype_p new_vop = add_vop (stmt, op, num, last);
+ VDEF_RESULT (new_vop) = NULL_TREE;
+ return new_vop;
}
@@ -662,9 +663,9 @@ add_vuse_op (tree stmt, tree op, int num, voptype_p last)
static inline voptype_p
add_vdef_op (tree stmt, tree op, int num, voptype_p last)
{
- voptype_p new = add_vop (stmt, op, num, last);
- VDEF_RESULT (new) = op;
- return new;
+ voptype_p new_vop = add_vop (stmt, op, num, last);
+ VDEF_RESULT (new_vop) = op;
+ return new_vop;
}
@@ -2059,7 +2060,7 @@ static void
get_expr_operands (tree stmt, tree *expr_p, int flags)
{
enum tree_code code;
- enum tree_code_class class;
+ enum tree_code_class codeclass;
tree expr = *expr_p;
stmt_ann_t s_ann = stmt_ann (stmt);
@@ -2067,7 +2068,7 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
return;
code = TREE_CODE (expr);
- class = TREE_CODE_CLASS (code);
+ codeclass = TREE_CODE_CLASS (code);
switch (code)
{
@@ -2284,11 +2285,11 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
return;
default:
- if (class == tcc_unary)
+ if (codeclass == tcc_unary)
goto do_unary;
- if (class == tcc_binary || class == tcc_comparison)
+ if (codeclass == tcc_binary || codeclass == tcc_comparison)
goto do_binary;
- if (class == tcc_constant || class == tcc_type)
+ if (codeclass == tcc_constant || codeclass == tcc_type)
return;
}
@@ -2794,7 +2795,7 @@ push_stmt_changes (tree *stmt_p)
if (TREE_CODE (stmt) == PHI_NODE)
return;
- buf = xmalloc (sizeof *buf);
+ buf = XNEW (struct scb_d);
memset (buf, 0, sizeof *buf);
buf->stmt_p = stmt_p;
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index f8e96bd..0c756d9 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -322,14 +322,14 @@ empty_block_p (basic_block bb)
static void
replace_phi_edge_with_variable (basic_block cond_block,
- edge e, tree phi, tree new)
+ edge e, tree phi, tree new_tree)
{
basic_block bb = bb_for_stmt (phi);
basic_block block_to_remove;
block_stmt_iterator bsi;
/* Change the PHI argument to new. */
- SET_USE (PHI_ARG_DEF_PTR (phi, e->dest_idx), new);
+ SET_USE (PHI_ARG_DEF_PTR (phi, e->dest_idx), new_tree);
/* Remove the empty basic block. */
if (EDGE_SUCC (cond_block, 0)->dest == bb)
@@ -377,7 +377,7 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
{
tree result;
tree old_result = NULL;
- tree new, cond;
+ tree new_stmt, cond;
block_stmt_iterator bsi;
edge true_edge, false_edge;
tree new_var = NULL;
@@ -470,7 +470,7 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
|| (e1 == true_edge && integer_onep (arg1))
|| (e1 == false_edge && integer_zerop (arg1)))
{
- new = build_gimple_modify_stmt (new_var1, cond);
+ new_stmt = build_gimple_modify_stmt (new_var1, cond);
}
else
{
@@ -514,19 +514,19 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
tmp = create_tmp_var (TREE_TYPE (op0), NULL);
add_referenced_var (tmp);
cond_tmp = make_ssa_name (tmp, NULL);
- new = build_gimple_modify_stmt (cond_tmp, op0);
- SSA_NAME_DEF_STMT (cond_tmp) = new;
+ new_stmt = build_gimple_modify_stmt (cond_tmp, op0);
+ SSA_NAME_DEF_STMT (cond_tmp) = new_stmt;
- bsi_insert_after (&bsi, new, BSI_NEW_STMT);
+ bsi_insert_after (&bsi, new_stmt, BSI_NEW_STMT);
cond = fold_convert (TREE_TYPE (result), cond_tmp);
}
- new = build_gimple_modify_stmt (new_var1, cond);
+ new_stmt = build_gimple_modify_stmt (new_var1, cond);
}
- bsi_insert_after (&bsi, new, BSI_NEW_STMT);
+ bsi_insert_after (&bsi, new_stmt, BSI_NEW_STMT);
- SSA_NAME_DEF_STMT (new_var1) = new;
+ SSA_NAME_DEF_STMT (new_var1) = new_stmt;
replace_phi_edge_with_variable (cond_bb, e1, phi, new_var1);
@@ -624,7 +624,7 @@ minmax_replacement (basic_block cond_bb, basic_block middle_bb,
tree arg0, tree arg1)
{
tree result, type;
- tree cond, new;
+ tree cond, new_stmt;
edge true_edge, false_edge;
enum tree_code cmp, minmax, ass_code;
tree smaller, larger, arg_true, arg_false;
@@ -853,10 +853,10 @@ minmax_replacement (basic_block cond_bb, basic_block middle_bb,
/* Emit the statement to compute min/max. */
result = duplicate_ssa_name (PHI_RESULT (phi), NULL);
- new = build_gimple_modify_stmt (result, build2 (minmax, type, arg0, arg1));
- SSA_NAME_DEF_STMT (result) = new;
+ new_stmt = build_gimple_modify_stmt (result, build2 (minmax, type, arg0, arg1));
+ SSA_NAME_DEF_STMT (result) = new_stmt;
bsi = bsi_last (cond_bb);
- bsi_insert_before (&bsi, new, BSI_NEW_STMT);
+ bsi_insert_before (&bsi, new_stmt, BSI_NEW_STMT);
replace_phi_edge_with_variable (cond_bb, e1, phi, result);
return true;
@@ -874,7 +874,7 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
tree phi, tree arg0, tree arg1)
{
tree result;
- tree new, cond;
+ tree new_stmt, cond;
block_stmt_iterator bsi;
edge true_edge, false_edge;
tree assign;
@@ -965,24 +965,24 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
lhs = result;
/* Build the modify expression with abs expression. */
- new = build_gimple_modify_stmt (lhs,
- build1 (ABS_EXPR, TREE_TYPE (lhs), rhs));
- SSA_NAME_DEF_STMT (lhs) = new;
+ new_stmt = build_gimple_modify_stmt (lhs,
+ build1 (ABS_EXPR, TREE_TYPE (lhs), rhs));
+ SSA_NAME_DEF_STMT (lhs) = new_stmt;
bsi = bsi_last (cond_bb);
- bsi_insert_before (&bsi, new, BSI_NEW_STMT);
+ bsi_insert_before (&bsi, new_stmt, BSI_NEW_STMT);
if (negate)
{
/* Get the right BSI. We want to insert after the recently
added ABS_EXPR statement (which we know is the first statement
in the block. */
- new = build_gimple_modify_stmt (result,
- build1 (NEGATE_EXPR, TREE_TYPE (lhs),
- lhs));
- SSA_NAME_DEF_STMT (result) = new;
+ new_stmt = build_gimple_modify_stmt (result,
+ build1 (NEGATE_EXPR, TREE_TYPE (lhs),
+ lhs));
+ SSA_NAME_DEF_STMT (result) = new_stmt;
- bsi_insert_after (&bsi, new, BSI_NEW_STMT);
+ bsi_insert_after (&bsi, new_stmt, BSI_NEW_STMT);
}
replace_phi_edge_with_variable (cond_bb, e1, phi, result);
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index cdb6aa8..72af731 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2290,7 +2290,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
genfn = find_or_generate_expression (block, fn, stmts);
nargs = call_expr_nargs (expr);
- buffer = alloca (nargs * sizeof (tree));
+ buffer = (tree*) alloca (nargs * sizeof (tree));
for (i = 0; i < nargs; i++)
{
@@ -3196,7 +3196,7 @@ insert_fake_stores (void)
def_operand_p defp;
tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
- tree new;
+ tree new_tree;
bool notokay = false;
FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_VIRTUAL_DEFS)
@@ -3220,16 +3220,16 @@ insert_fake_stores (void)
get_var_ann (storetemp);
}
- new = poolify_modify_stmt (storetemp, lhs);
+ new_tree = poolify_modify_stmt (storetemp, lhs);
- lhs = make_ssa_name (storetemp, new);
- GIMPLE_STMT_OPERAND (new, 0) = lhs;
- create_ssa_artificial_load_stmt (new, stmt);
+ lhs = make_ssa_name (storetemp, new_tree);
+ GIMPLE_STMT_OPERAND (new_tree, 0) = lhs;
+ create_ssa_artificial_load_stmt (new_tree, stmt);
- NECESSARY (new) = 0;
- VEC_safe_push (tree, heap, inserted_exprs, new);
- VEC_safe_push (tree, heap, need_creation, new);
- bsi_insert_after (&bsi, new, BSI_NEW_STMT);
+ NECESSARY (new_tree) = 0;
+ VEC_safe_push (tree, heap, inserted_exprs, new_tree);
+ VEC_safe_push (tree, heap, need_creation, new_tree);
+ bsi_insert_after (&bsi, new_tree, BSI_NEW_STMT);
}
}
}
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 32a66eb..bc0de6d 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -337,7 +337,7 @@ sort_by_operand_rank (const void *pa, const void *pb)
static void
add_to_ops_vec (VEC(operand_entry_t, heap) **ops, tree op)
{
- operand_entry_t oe = pool_alloc (operand_entry_pool);
+ operand_entry_t oe = (operand_entry_t) pool_alloc (operand_entry_pool);
oe->op = op;
oe->rank = get_rank (op);
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index a935ca2..48f85b7 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -328,7 +328,8 @@ heapvar_lookup (tree from)
struct tree_map *h, in;
in.base.from = from;
- h = htab_find_with_hash (heapvar_for_stmt, &in, htab_hash_pointer (from));
+ h = (struct tree_map *) htab_find_with_hash (heapvar_for_stmt, &in,
+ htab_hash_pointer (from));
if (h)
return h->to;
return NULL_TREE;
@@ -343,7 +344,7 @@ heapvar_insert (tree from, tree to)
struct tree_map *h;
void **loc;
- h = ggc_alloc (sizeof (struct tree_map));
+ h = GGC_NEW (struct tree_map);
h->hash = htab_hash_pointer (from);
h->base.from = from;
h->to = to;
@@ -357,7 +358,7 @@ heapvar_insert (tree from, tree to)
static varinfo_t
new_var_info (tree t, unsigned int id, const char *name)
{
- varinfo_t ret = pool_alloc (variable_info_pool);
+ varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool);
ret->id = id;
ret->name = name;
@@ -513,7 +514,7 @@ static constraint_t
new_constraint (const struct constraint_expr lhs,
const struct constraint_expr rhs)
{
- constraint_t ret = pool_alloc (constraint_pool);
+ constraint_t ret = (constraint_t) pool_alloc (constraint_pool);
ret->lhs = lhs;
ret->rhs = rhs;
return ret;
@@ -4762,7 +4763,7 @@ remove_preds_and_fake_succs (constraint_graph_t graph)
/* Now reallocate the size of the successor list as, and blow away
the predecessor bitmaps. */
graph->size = VEC_length (varinfo_t, varmap);
- graph->succs = xrealloc (graph->succs, graph->size * sizeof (bitmap));
+ graph->succs = XRESIZEVEC (bitmap, graph->succs, graph->size);
free (graph->implicit_preds);
graph->implicit_preds = NULL;
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index e8a05ed..f5a524a 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -533,7 +533,7 @@ thread_block (basic_block bb, bool noloop_only)
if (loop->header == bb)
{
e = loop_latch_edge (loop);
- e2 = e->aux;
+ e2 = (edge) e->aux;
if (e2 && loop_exit_edge_p (loop, e2))
{
@@ -546,7 +546,7 @@ thread_block (basic_block bb, bool noloop_only)
efficient lookups. */
FOR_EACH_EDGE (e, ei, bb->preds)
{
- e2 = e->aux;
+ e2 = (edge) e->aux;
if (!e2
/* If NOLOOP_ONLY is true, we only allow threading through the
@@ -560,7 +560,7 @@ thread_block (basic_block bb, bool noloop_only)
}
update_bb_profile_for_threading (e->dest, EDGE_FREQUENCY (e),
- e->count, e->aux);
+ e->count, (edge) e->aux);
/* Insert the outgoing edge into the hash table if it is not
already in the hash table. */
@@ -573,7 +573,7 @@ thread_block (basic_block bb, bool noloop_only)
DO_NOT_DUPLICATE attribute. */
if (all)
{
- edge e = EDGE_PRED (bb, 0)->aux;
+ edge e = (edge) EDGE_PRED (bb, 0)->aux;
lookup_redirection_data (e, NULL, NO_INSERT)->do_not_duplicate = true;
}
@@ -623,7 +623,7 @@ static basic_block
thread_single_edge (edge e)
{
basic_block bb = e->dest;
- edge eto = e->aux;
+ edge eto = (edge) e->aux;
struct redirection_data rd;
struct local_info local_info;
@@ -822,7 +822,7 @@ thread_through_loop_header (struct loop *loop, bool may_peel_loop_headers)
if (latch->aux)
{
- tgt_edge = latch->aux;
+ tgt_edge = (edge) latch->aux;
tgt_bb = tgt_edge->dest;
}
else if (!may_peel_loop_headers
@@ -845,7 +845,7 @@ thread_through_loop_header (struct loop *loop, bool may_peel_loop_headers)
goto fail;
}
- tgt_edge = e->aux;
+ tgt_edge = (edge) e->aux;
atgt_bb = tgt_edge->dest;
if (!tgt_bb)
tgt_bb = atgt_bb;
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 3dfc34f..821440d 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -799,7 +799,7 @@ var_ann_hash (const void *item)
void
init_tree_ssa (void)
{
- cfun->gimple_df = ggc_alloc_cleared (sizeof (struct gimple_df));
+ cfun->gimple_df = GGC_CNEW (struct gimple_df);
cfun->gimple_df->referenced_vars = htab_create_ggc (20, int_tree_map_hash,
int_tree_map_eq, NULL);
cfun->gimple_df->default_defs = htab_create_ggc (20, int_tree_map_hash,
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index 9c61a3f..899ac82 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -266,7 +266,7 @@ duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
if (!ptr_info)
return;
- new_ptr_info = ggc_alloc (sizeof (struct ptr_info_def));
+ new_ptr_info = GGC_NEW (struct ptr_info_def);
*new_ptr_info = *ptr_info;
if (ptr_info->pt_vars)
generated by cgit v1.1 at 2024-11-05 03:36:42 +0000