aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.0
diff options
context:
space:
mode:
authorJing Yu <jingyu@google.com>2009-11-18 17:41:15 -0800
committerJing Yu <jingyu@google.com>2009-11-18 17:41:15 -0800
commit727407e24af9df776e77f6a5762a62869198bc09 (patch)
tree678cb9a9c09bc6de817a4469ce205c26fa741fd8 /gcc-4.4.0
parentdf62c1c110e8532b995b23540b7e3695729c0779 (diff)
downloadtoolchain_gcc-727407e24af9df776e77f6a5762a62869198bc09.zip
toolchain_gcc-727407e24af9df776e77f6a5762a62869198bc09.tar.gz
toolchain_gcc-727407e24af9df776e77f6a5762a62869198bc09.tar.bz2
Gcc source for prebuilt toolchains in Eclair-mr2.
The patch mainly fixes a unsafe floating point combination bug.
Diffstat (limited to 'gcc-4.4.0')
-rw-r--r--gcc-4.4.0/gcc/D.51890
-rw-r--r--gcc-4.4.0/gcc/D.5190_1190
-rw-r--r--gcc-4.4.0/gcc/D.5191_1180
-rw-r--r--gcc-4.4.0/gcc/D.5192_1170
-rw-r--r--gcc-4.4.0/gcc/D.5195_1140
-rw-r--r--gcc-4.4.0/gcc/D.5200_1090
-rw-r--r--gcc-4.4.0/gcc/D.5203_1060
-rw-r--r--gcc-4.4.0/gcc/D.5205_1040
-rw-r--r--gcc-4.4.0/gcc/GLfixed0
-rw-r--r--gcc-4.4.0/gcc/GLubyte0
-rw-r--r--gcc-4.4.0/gcc/colorArray0
-rw-r--r--gcc-4.4.0/gcc/combine.c6
-rw-r--r--gcc-4.4.0/gcc/long0
-rw-r--r--gcc-4.4.0/gcc/normalArray0
-rw-r--r--gcc-4.4.0/gcc/result_103-0
-rw-r--r--gcc-4.4.0/gcc/result_120
-rw-r--r--gcc-4.4.0/gcc/size_t0
-rw-r--r--gcc-4.4.0/gcc/struct0
-rw-r--r--gcc-4.4.0/gcc/tree-ssa-sccvn.c.orig3145
-rw-r--r--gcc-4.4.0/gcc/vertexArray0
-rw-r--r--gcc-4.4.0/gcc/void0
21 files changed, 6 insertions, 3145 deletions
diff --git a/gcc-4.4.0/gcc/D.5189 b/gcc-4.4.0/gcc/D.5189
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5189
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5190_119 b/gcc-4.4.0/gcc/D.5190_119
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5190_119
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5191_118 b/gcc-4.4.0/gcc/D.5191_118
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5191_118
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5192_117 b/gcc-4.4.0/gcc/D.5192_117
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5192_117
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5195_114 b/gcc-4.4.0/gcc/D.5195_114
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5195_114
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5200_109 b/gcc-4.4.0/gcc/D.5200_109
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5200_109
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5203_106 b/gcc-4.4.0/gcc/D.5203_106
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5203_106
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/D.5205_104 b/gcc-4.4.0/gcc/D.5205_104
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/D.5205_104
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/GLfixed b/gcc-4.4.0/gcc/GLfixed
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/GLfixed
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/GLubyte b/gcc-4.4.0/gcc/GLubyte
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/GLubyte
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/colorArray b/gcc-4.4.0/gcc/colorArray
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/colorArray
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/combine.c b/gcc-4.4.0/gcc/combine.c
index 70c1e5d..5bffb58 100644
--- a/gcc-4.4.0/gcc/combine.c
+++ b/gcc-4.4.0/gcc/combine.c
@@ -8512,6 +8512,12 @@ distribute_and_simplify_rtx (rtx x, int n)
enum rtx_code outer_code, inner_code;
rtx decomposed, distributed, inner_op0, inner_op1, new_op0, new_op1, tmp;
+ /* Distributivity is not true for floating point as it can change the
+ value. So we don't do it unless -funsafe-math-optimizations. */
+ if (FLOAT_MODE_P (GET_MODE (x))
+ && ! flag_unsafe_math_optimizations)
+ return NULL_RTX;
+
decomposed = XEXP (x, n);
if (!ARITHMETIC_P (decomposed))
return NULL_RTX;
diff --git a/gcc-4.4.0/gcc/long b/gcc-4.4.0/gcc/long
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/long
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/normalArray b/gcc-4.4.0/gcc/normalArray
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/normalArray
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/result_103- b/gcc-4.4.0/gcc/result_103-
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/result_103-
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/result_12 b/gcc-4.4.0/gcc/result_12
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/result_12
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/size_t b/gcc-4.4.0/gcc/size_t
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/size_t
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/struct b/gcc-4.4.0/gcc/struct
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/struct
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/tree-ssa-sccvn.c.orig b/gcc-4.4.0/gcc/tree-ssa-sccvn.c.orig
deleted file mode 100644
index 7d7236e..0000000
--- a/gcc-4.4.0/gcc/tree-ssa-sccvn.c.orig
+++ /dev/null
@@ -1,3145 +0,0 @@
-/* SCC value numbering for trees
- Copyright (C) 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
- Contributed by Daniel Berlin <dan@dberlin.org>
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3. If not see
-<http://www.gnu.org/licenses/>. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "ggc.h"
-#include "tree.h"
-#include "basic-block.h"
-#include "diagnostic.h"
-#include "tree-inline.h"
-#include "tree-flow.h"
-#include "gimple.h"
-#include "tree-dump.h"
-#include "timevar.h"
-#include "fibheap.h"
-#include "hashtab.h"
-#include "tree-iterator.h"
-#include "real.h"
-#include "alloc-pool.h"
-#include "tree-pass.h"
-#include "flags.h"
-#include "bitmap.h"
-#include "langhooks.h"
-#include "cfgloop.h"
-#include "params.h"
-#include "tree-ssa-propagate.h"
-#include "tree-ssa-sccvn.h"
-
-/* This algorithm is based on the SCC algorithm presented by Keith
- Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
- (http://citeseer.ist.psu.edu/41805.html). In
- straight line code, it is equivalent to a regular hash based value
- numbering that is performed in reverse postorder.
-
- For code with cycles, there are two alternatives, both of which
- require keeping the hashtables separate from the actual list of
- value numbers for SSA names.
-
- 1. Iterate value numbering in an RPO walk of the blocks, removing
- all the entries from the hashtable after each iteration (but
- keeping the SSA name->value number mapping between iterations).
- Iterate until it does not change.
-
- 2. Perform value numbering as part of an SCC walk on the SSA graph,
- iterating only the cycles in the SSA graph until they do not change
- (using a separate, optimistic hashtable for value numbering the SCC
- operands).
-
- The second is not just faster in practice (because most SSA graph
- cycles do not involve all the variables in the graph), it also has
- some nice properties.
-
- One of these nice properties is that when we pop an SCC off the
- stack, we are guaranteed to have processed all the operands coming from
- *outside of that SCC*, so we do not need to do anything special to
- ensure they have value numbers.
-
- Another nice property is that the SCC walk is done as part of a DFS
- of the SSA graph, which makes it easy to perform combining and
- simplifying operations at the same time.
-
- The code below is deliberately written in a way that makes it easy
- to separate the SCC walk from the other work it does.
-
- In order to propagate constants through the code, we track which
- expressions contain constants, and use those while folding. In
- theory, we could also track expressions whose value numbers are
- replaced, in case we end up folding based on expression
- identities.
-
- In order to value number memory, we assign value numbers to vuses.
- This enables us to note that, for example, stores to the same
- address of the same value from the same starting memory states are
- equivalent.
- TODO:
-
- 1. We can iterate only the changing portions of the SCC's, but
- I have not seen an SCC big enough for this to be a win.
- 2. If you differentiate between phi nodes for loops and phi nodes
- for if-then-else, you can properly consider phi nodes in different
- blocks for equivalence.
- 3. We could value number vuses in more cases, particularly, whole
- structure copies.
-*/
-
-/* The set of hashtables and alloc_pool's for their items. */
-
-typedef struct vn_tables_s
-{
- htab_t nary;
- htab_t phis;
- htab_t references;
- struct obstack nary_obstack;
- alloc_pool phis_pool;
- alloc_pool references_pool;
-} *vn_tables_t;
-
-static htab_t constant_to_value_id;
-static bitmap constant_value_ids;
-
-
-/* Valid hashtables storing information we have proven to be
- correct. */
-
-static vn_tables_t valid_info;
-
-/* Optimistic hashtables storing information we are making assumptions about
- during iterations. */
-
-static vn_tables_t optimistic_info;
-
-/* Pointer to the set of hashtables that is currently being used.
- Should always point to either the optimistic_info, or the
- valid_info. */
-
-static vn_tables_t current_info;
-
-
-/* Reverse post order index for each basic block. */
-
-static int *rpo_numbers;
-
-#define SSA_VAL(x) (VN_INFO ((x))->valnum)
-
-/* This represents the top of the VN lattice, which is the universal
- value. */
-
-tree VN_TOP;
-
-/* Unique counter for our value ids. */
-
-static unsigned int next_value_id;
-
-/* Next DFS number and the stack for strongly connected component
- detection. */
-
-static unsigned int next_dfs_num;
-static VEC (tree, heap) *sccstack;
-
-static bool may_insert;
-
-
-DEF_VEC_P(vn_ssa_aux_t);
-DEF_VEC_ALLOC_P(vn_ssa_aux_t, heap);
-
-/* Table of vn_ssa_aux_t's, one per ssa_name. The vn_ssa_aux_t objects
- are allocated on an obstack for locality reasons, and to free them
- without looping over the VEC. */
-
-static VEC (vn_ssa_aux_t, heap) *vn_ssa_aux_table;
-static struct obstack vn_ssa_aux_obstack;
-
-/* Return the value numbering information for a given SSA name. */
-
-vn_ssa_aux_t
-VN_INFO (tree name)
-{
- vn_ssa_aux_t res = VEC_index (vn_ssa_aux_t, vn_ssa_aux_table,
- SSA_NAME_VERSION (name));
- gcc_assert (res);
- return res;
-}
-
-/* Set the value numbering info for a given SSA name to a given
- value. */
-
-static inline void
-VN_INFO_SET (tree name, vn_ssa_aux_t value)
-{
- VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
- SSA_NAME_VERSION (name), value);
-}
-
-/* Initialize the value numbering info for a given SSA name.
- This should be called just once for every SSA name. */
-
-vn_ssa_aux_t
-VN_INFO_GET (tree name)
-{
- vn_ssa_aux_t newinfo;
-
- newinfo = XOBNEW (&vn_ssa_aux_obstack, struct vn_ssa_aux);
- memset (newinfo, 0, sizeof (struct vn_ssa_aux));
- if (SSA_NAME_VERSION (name) >= VEC_length (vn_ssa_aux_t, vn_ssa_aux_table))
- VEC_safe_grow (vn_ssa_aux_t, heap, vn_ssa_aux_table,
- SSA_NAME_VERSION (name) + 1);
- VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
- SSA_NAME_VERSION (name), newinfo);
- return newinfo;
-}
-
-
-/* Get the representative expression for the SSA_NAME NAME. Returns
- the representative SSA_NAME if there is no expression associated with it. */
-
-tree
-vn_get_expr_for (tree name)
-{
- vn_ssa_aux_t vn = VN_INFO (name);
- gimple def_stmt;
- tree expr = NULL_TREE;
-
- if (vn->valnum == VN_TOP)
- return name;
-
- /* If the value-number is a constant it is the representative
- expression. */
- if (TREE_CODE (vn->valnum) != SSA_NAME)
- return vn->valnum;
-
- /* Get to the information of the value of this SSA_NAME. */
- vn = VN_INFO (vn->valnum);
-
- /* If the value-number is a constant it is the representative
- expression. */
- if (TREE_CODE (vn->valnum) != SSA_NAME)
- return vn->valnum;
-
- /* Else if we have an expression, return it. */
- if (vn->expr != NULL_TREE)
- return vn->expr;
-
- /* Otherwise use the defining statement to build the expression. */
- def_stmt = SSA_NAME_DEF_STMT (vn->valnum);
-
- /* If the value number is a default-definition or a PHI result
- use it directly. */
- if (gimple_nop_p (def_stmt)
- || gimple_code (def_stmt) == GIMPLE_PHI)
- return vn->valnum;
-
- if (!is_gimple_assign (def_stmt))
- return vn->valnum;
-
- /* FIXME tuples. This is incomplete and likely will miss some
- simplifications. */
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)))
- {
- case tcc_reference:
- if ((gimple_assign_rhs_code (def_stmt) == VIEW_CONVERT_EXPR
- || gimple_assign_rhs_code (def_stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (def_stmt) == IMAGPART_EXPR)
- && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
- expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
- gimple_expr_type (def_stmt),
- TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0));
- break;
-
- case tcc_unary:
- expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
- gimple_expr_type (def_stmt),
- gimple_assign_rhs1 (def_stmt));
- break;
-
- case tcc_binary:
- expr = fold_build2 (gimple_assign_rhs_code (def_stmt),
- gimple_expr_type (def_stmt),
- gimple_assign_rhs1 (def_stmt),
- gimple_assign_rhs2 (def_stmt));
- break;
-
- default:;
- }
- if (expr == NULL_TREE)
- return vn->valnum;
-
- /* Cache the expression. */
- vn->expr = expr;
-
- return expr;
-}
-
-
-/* Free a phi operation structure VP. */
-
-static void
-free_phi (void *vp)
-{
- vn_phi_t phi = (vn_phi_t) vp;
- VEC_free (tree, heap, phi->phiargs);
-}
-
-/* Free a reference operation structure VP. */
-
-static void
-free_reference (void *vp)
-{
- vn_reference_t vr = (vn_reference_t) vp;
- VEC_free (vn_reference_op_s, heap, vr->operands);
-}
-
-/* Hash table equality function for vn_constant_t. */
-
-static int
-vn_constant_eq (const void *p1, const void *p2)
-{
- const struct vn_constant_s *vc1 = (const struct vn_constant_s *) p1;
- const struct vn_constant_s *vc2 = (const struct vn_constant_s *) p2;
-
- if (vc1->hashcode != vc2->hashcode)
- return false;
-
- return vn_constant_eq_with_type (vc1->constant, vc2->constant);
-}
-
-/* Hash table hash function for vn_constant_t. */
-
-static hashval_t
-vn_constant_hash (const void *p1)
-{
- const struct vn_constant_s *vc1 = (const struct vn_constant_s *) p1;
- return vc1->hashcode;
-}
-
-/* Lookup a value id for CONSTANT and return it. If it does not
- exist returns 0. */
-
-unsigned int
-get_constant_value_id (tree constant)
-{
- void **slot;
- struct vn_constant_s vc;
-
- vc.hashcode = vn_hash_constant_with_type (constant);
- vc.constant = constant;
- slot = htab_find_slot_with_hash (constant_to_value_id, &vc,
- vc.hashcode, NO_INSERT);
- if (slot)
- return ((vn_constant_t)*slot)->value_id;
- return 0;
-}
-
-/* Lookup a value id for CONSTANT, and if it does not exist, create a
- new one and return it. If it does exist, return it. */
-
-unsigned int
-get_or_alloc_constant_value_id (tree constant)
-{
- void **slot;
- vn_constant_t vc = XNEW (struct vn_constant_s);
-
- vc->hashcode = vn_hash_constant_with_type (constant);
- vc->constant = constant;
- slot = htab_find_slot_with_hash (constant_to_value_id, vc,
- vc->hashcode, INSERT);
- if (*slot)
- {
- free (vc);
- return ((vn_constant_t)*slot)->value_id;
- }
- vc->value_id = get_next_value_id ();
- *slot = vc;
- bitmap_set_bit (constant_value_ids, vc->value_id);
- return vc->value_id;
-}
-
-/* Return true if V is a value id for a constant. */
-
-bool
-value_id_constant_p (unsigned int v)
-{
- return bitmap_bit_p (constant_value_ids, v);
-}
-
-/* Compare two reference operands P1 and P2 for equality. Return true if
- they are equal, and false otherwise. */
-
-static int
-vn_reference_op_eq (const void *p1, const void *p2)
-{
- const_vn_reference_op_t const vro1 = (const_vn_reference_op_t) p1;
- const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
-
- return vro1->opcode == vro2->opcode
- && types_compatible_p (vro1->type, vro2->type)
- && expressions_equal_p (vro1->op0, vro2->op0)
- && expressions_equal_p (vro1->op1, vro2->op1)
- && expressions_equal_p (vro1->op2, vro2->op2);
-}
-
-/* Compute the hash for a reference operand VRO1. */
-
-static hashval_t
-vn_reference_op_compute_hash (const vn_reference_op_t vro1)
-{
- hashval_t result = 0;
- if (vro1->op0)
- result += iterative_hash_expr (vro1->op0, vro1->opcode);
- if (vro1->op1)
- result += iterative_hash_expr (vro1->op1, vro1->opcode);
- if (vro1->op2)
- result += iterative_hash_expr (vro1->op2, vro1->opcode);
- return result;
-}
-
-/* Return the hashcode for a given reference operation P1. */
-
-static hashval_t
-vn_reference_hash (const void *p1)
-{
- const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
- return vr1->hashcode;
-}
-
-/* Compute a hash for the reference operation VR1 and return it. */
-
-hashval_t
-vn_reference_compute_hash (const vn_reference_t vr1)
-{
- hashval_t result = 0;
- tree v;
- int i;
- vn_reference_op_t vro;
-
- for (i = 0; VEC_iterate (tree, vr1->vuses, i, v); i++)
- result += iterative_hash_expr (v, 0);
- for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
- result += vn_reference_op_compute_hash (vro);
-
- return result;
-}
-
-/* Return true if reference operations P1 and P2 are equivalent. This
- means they have the same set of operands and vuses. */
-
-int
-vn_reference_eq (const void *p1, const void *p2)
-{
- tree v;
- int i;
- vn_reference_op_t vro;
-
- const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
- const_vn_reference_t const vr2 = (const_vn_reference_t) p2;
- if (vr1->hashcode != vr2->hashcode)
- return false;
-
- if (vr1->vuses == vr2->vuses
- && vr1->operands == vr2->operands)
- return true;
-
- /* Impossible for them to be equivalent if they have different
- number of vuses. */
- if (VEC_length (tree, vr1->vuses) != VEC_length (tree, vr2->vuses))
- return false;
-
- /* We require that address operands be canonicalized in a way that
- two memory references will have the same operands if they are
- equivalent. */
- if (VEC_length (vn_reference_op_s, vr1->operands)
- != VEC_length (vn_reference_op_s, vr2->operands))
- return false;
-
- /* The memory state is more often different than the address of the
- store/load, so check it first. */
- for (i = 0; VEC_iterate (tree, vr1->vuses, i, v); i++)
- {
- if (VEC_index (tree, vr2->vuses, i) != v)
- return false;
- }
-
- for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
- {
- if (!vn_reference_op_eq (VEC_index (vn_reference_op_s, vr2->operands, i),
- vro))
- return false;
- }
- return true;
-}
-
-/* Place the vuses from STMT into *result. */
-
-static inline void
-vuses_to_vec (gimple stmt, VEC (tree, gc) **result)
-{
- ssa_op_iter iter;
- tree vuse;
-
- if (!stmt)
- return;
-
- VEC_reserve_exact (tree, gc, *result,
- num_ssa_operands (stmt, SSA_OP_VIRTUAL_USES));
-
- FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VIRTUAL_USES)
- VEC_quick_push (tree, *result, vuse);
-}
-
-
-/* Copy the VUSE names in STMT into a vector, and return
- the vector. */
-
-static VEC (tree, gc) *
-copy_vuses_from_stmt (gimple stmt)
-{
- VEC (tree, gc) *vuses = NULL;
-
- vuses_to_vec (stmt, &vuses);
-
- return vuses;
-}
-
-/* Place the vdefs from STMT into *result. */
-
-static inline void
-vdefs_to_vec (gimple stmt, VEC (tree, gc) **result)
-{
- ssa_op_iter iter;
- tree vdef;
-
- if (!stmt)
- return;
-
- *result = VEC_alloc (tree, gc, num_ssa_operands (stmt, SSA_OP_VIRTUAL_DEFS));
-
- FOR_EACH_SSA_TREE_OPERAND (vdef, stmt, iter, SSA_OP_VIRTUAL_DEFS)
- VEC_quick_push (tree, *result, vdef);
-}
-
-/* Copy the names of vdef results in STMT into a vector, and return
- the vector. */
-
-static VEC (tree, gc) *
-copy_vdefs_from_stmt (gimple stmt)
-{
- VEC (tree, gc) *vdefs = NULL;
-
- vdefs_to_vec (stmt, &vdefs);
-
- return vdefs;
-}
-
-/* Place for shared_v{uses/defs}_from_stmt to shove vuses/vdefs. */
-static VEC (tree, gc) *shared_lookup_vops;
-
-/* Copy the virtual uses from STMT into SHARED_LOOKUP_VOPS.
- This function will overwrite the current SHARED_LOOKUP_VOPS
- variable. */
-
-VEC (tree, gc) *
-shared_vuses_from_stmt (gimple stmt)
-{
- VEC_truncate (tree, shared_lookup_vops, 0);
- vuses_to_vec (stmt, &shared_lookup_vops);
-
- return shared_lookup_vops;
-}
-
-/* Copy the operations present in load/store REF into RESULT, a vector of
- vn_reference_op_s's. */
-
-void
-copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result)
-{
- if (TREE_CODE (ref) == TARGET_MEM_REF)
- {
- vn_reference_op_s temp;
-
- memset (&temp, 0, sizeof (temp));
- /* We do not care for spurious type qualifications. */
- temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
- temp.opcode = TREE_CODE (ref);
- temp.op0 = TMR_SYMBOL (ref) ? TMR_SYMBOL (ref) : TMR_BASE (ref);
- temp.op1 = TMR_INDEX (ref);
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
-
- memset (&temp, 0, sizeof (temp));
- temp.type = NULL_TREE;
- temp.opcode = TREE_CODE (ref);
- temp.op0 = TMR_STEP (ref);
- temp.op1 = TMR_OFFSET (ref);
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
- return;
- }
-
- /* For non-calls, store the information that makes up the address. */
-
- while (ref)
- {
- vn_reference_op_s temp;
-
- memset (&temp, 0, sizeof (temp));
- /* We do not care for spurious type qualifications. */
- temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
- temp.opcode = TREE_CODE (ref);
-
- switch (temp.opcode)
- {
- case ALIGN_INDIRECT_REF:
- case INDIRECT_REF:
- /* The only operand is the address, which gets its own
- vn_reference_op_s structure. */
- break;
- case MISALIGNED_INDIRECT_REF:
- temp.op0 = TREE_OPERAND (ref, 1);
- break;
- case BIT_FIELD_REF:
- /* Record bits and position. */
- temp.op0 = TREE_OPERAND (ref, 1);
- temp.op1 = TREE_OPERAND (ref, 2);
- break;
- case COMPONENT_REF:
- /* The field decl is enough to unambiguously specify the field,
- a matching type is not necessary and a mismatching type
- is always a spurious difference. */
- temp.type = NULL_TREE;
- /* If this is a reference to a union member, record the union
- member size as operand. Do so only if we are doing
- expression insertion (during FRE), as PRE currently gets
- confused with this. */
- if (may_insert
- && TREE_OPERAND (ref, 2) == NULL_TREE
- && TREE_CODE (DECL_CONTEXT (TREE_OPERAND (ref, 1))) == UNION_TYPE
- && integer_zerop (DECL_FIELD_OFFSET (TREE_OPERAND (ref, 1)))
- && integer_zerop (DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref, 1))))
- temp.op0 = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)));
- else
- {
- /* Record field as operand. */
- temp.op0 = TREE_OPERAND (ref, 1);
- temp.op1 = TREE_OPERAND (ref, 2);
- }
- break;
- case ARRAY_RANGE_REF:
- case ARRAY_REF:
- /* Record index as operand. */
- temp.op0 = TREE_OPERAND (ref, 1);
- temp.op1 = TREE_OPERAND (ref, 2);
- temp.op2 = TREE_OPERAND (ref, 3);
- break;
- case STRING_CST:
- case INTEGER_CST:
- case COMPLEX_CST:
- case VECTOR_CST:
- case REAL_CST:
- case CONSTRUCTOR:
- case VAR_DECL:
- case PARM_DECL:
- case CONST_DECL:
- case RESULT_DECL:
- case SSA_NAME:
- temp.op0 = ref;
- break;
- case ADDR_EXPR:
- if (is_gimple_min_invariant (ref))
- {
- temp.op0 = ref;
- break;
- }
- /* Fallthrough. */
- /* These are only interesting for their operands, their
- existence, and their type. They will never be the last
- ref in the chain of references (IE they require an
- operand), so we don't have to put anything
- for op* as it will be handled by the iteration */
- case IMAGPART_EXPR:
- case REALPART_EXPR:
- case VIEW_CONVERT_EXPR:
- break;
- default:
- gcc_unreachable ();
- }
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
-
- if (REFERENCE_CLASS_P (ref)
- || (TREE_CODE (ref) == ADDR_EXPR
- && !is_gimple_min_invariant (ref)))
- ref = TREE_OPERAND (ref, 0);
- else
- ref = NULL_TREE;
- }
-}
-
-/* Re-create a reference tree from the reference ops OPS.
- Returns NULL_TREE if the ops were not handled.
- This routine needs to be kept in sync with copy_reference_ops_from_ref. */
-
-static tree
-get_ref_from_reference_ops (VEC(vn_reference_op_s, heap) *ops)
-{
- vn_reference_op_t op;
- unsigned i;
- tree ref, *op0_p = &ref;
-
- for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i)
- {
- switch (op->opcode)
- {
- case CALL_EXPR:
- return NULL_TREE;
-
- case ALIGN_INDIRECT_REF:
- case INDIRECT_REF:
- *op0_p = build1 (op->opcode, op->type, NULL_TREE);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- case MISALIGNED_INDIRECT_REF:
- *op0_p = build2 (MISALIGNED_INDIRECT_REF, op->type,
- NULL_TREE, op->op0);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- case BIT_FIELD_REF:
- *op0_p = build3 (BIT_FIELD_REF, op->type, NULL_TREE,
- op->op0, op->op1);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- case COMPONENT_REF:
- *op0_p = build3 (COMPONENT_REF, TREE_TYPE (op->op0), NULL_TREE,
- op->op0, op->op1);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- case ARRAY_RANGE_REF:
- case ARRAY_REF:
- *op0_p = build4 (op->opcode, op->type, NULL_TREE,
- op->op0, op->op1, op->op2);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- case STRING_CST:
- case INTEGER_CST:
- case COMPLEX_CST:
- case VECTOR_CST:
- case REAL_CST:
- case CONSTRUCTOR:
- case VAR_DECL:
- case PARM_DECL:
- case CONST_DECL:
- case RESULT_DECL:
- case SSA_NAME:
- *op0_p = op->op0;
- break;
-
- case ADDR_EXPR:
- if (op->op0 != NULL_TREE)
- {
- gcc_assert (is_gimple_min_invariant (op->op0));
- *op0_p = op->op0;
- break;
- }
- /* Fallthrough. */
- case IMAGPART_EXPR:
- case REALPART_EXPR:
- case VIEW_CONVERT_EXPR:
- *op0_p = build1 (op->opcode, op->type, NULL_TREE);
- op0_p = &TREE_OPERAND (*op0_p, 0);
- break;
-
- default:
- return NULL_TREE;
- }
- }
-
- return ref;
-}
-
-/* Copy the operations present in load/store/call REF into RESULT, a vector of
- vn_reference_op_s's. */
-
-void
-copy_reference_ops_from_call (gimple call,
- VEC(vn_reference_op_s, heap) **result)
-{
- vn_reference_op_s temp;
- unsigned i;
-
- /* Copy the type, opcode, function being called and static chain. */
- memset (&temp, 0, sizeof (temp));
- temp.type = gimple_call_return_type (call);
- temp.opcode = CALL_EXPR;
- temp.op0 = gimple_call_fn (call);
- temp.op1 = gimple_call_chain (call);
- VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
-
- /* Copy the call arguments. As they can be references as well,
- just chain them together. */
- for (i = 0; i < gimple_call_num_args (call); ++i)
- {
- tree callarg = gimple_call_arg (call, i);
- copy_reference_ops_from_ref (callarg, result);
- }
-}
-
-/* Create a vector of vn_reference_op_s structures from REF, a
- REFERENCE_CLASS_P tree. The vector is not shared. */
-
-static VEC(vn_reference_op_s, heap) *
-create_reference_ops_from_ref (tree ref)
-{
- VEC (vn_reference_op_s, heap) *result = NULL;
-
- copy_reference_ops_from_ref (ref, &result);
- return result;
-}
-
-/* Create a vector of vn_reference_op_s structures from CALL, a
- call statement. The vector is not shared. */
-
-static VEC(vn_reference_op_s, heap) *
-create_reference_ops_from_call (gimple call)
-{
- VEC (vn_reference_op_s, heap) *result = NULL;
-
- copy_reference_ops_from_call (call, &result);
- return result;
-}
-
-static VEC(vn_reference_op_s, heap) *shared_lookup_references;
-
-/* Create a vector of vn_reference_op_s structures from REF, a
- REFERENCE_CLASS_P tree. The vector is shared among all callers of
- this function. */
-
-static VEC(vn_reference_op_s, heap) *
-shared_reference_ops_from_ref (tree ref)
-{
- if (!ref)
- return NULL;
- VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
- copy_reference_ops_from_ref (ref, &shared_lookup_references);
- return shared_lookup_references;
-}
-
-/* Create a vector of vn_reference_op_s structures from CALL, a
- call statement. The vector is shared among all callers of
- this function. */
-
-static VEC(vn_reference_op_s, heap) *
-shared_reference_ops_from_call (gimple call)
-{
- if (!call)
- return NULL;
- VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
- copy_reference_ops_from_call (call, &shared_lookup_references);
- return shared_lookup_references;
-}
-
-
-/* Transform any SSA_NAME's in a vector of vn_reference_op_s
- structures into their value numbers. This is done in-place, and
- the vector passed in is returned. */
-
-static VEC (vn_reference_op_s, heap) *
-valueize_refs (VEC (vn_reference_op_s, heap) *orig)
-{
- vn_reference_op_t vro;
- int i;
-
- for (i = 0; VEC_iterate (vn_reference_op_s, orig, i, vro); i++)
- {
- if (vro->opcode == SSA_NAME
- || (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
- {
- vro->op0 = SSA_VAL (vro->op0);
- /* If it transforms from an SSA_NAME to a constant, update
- the opcode. */
- if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
- vro->opcode = TREE_CODE (vro->op0);
- }
- /* TODO: Do we want to valueize op2 and op1 of
- ARRAY_REF/COMPONENT_REF for Ada */
-
- }
-
- return orig;
-}
-
-/* Transform any SSA_NAME's in ORIG, a vector of vuse trees, into
- their value numbers. This is done in-place, and the vector passed
- in is returned. */
-
-static VEC (tree, gc) *
-valueize_vuses (VEC (tree, gc) *orig)
-{
- bool made_replacement = false;
- tree vuse;
- int i;
-
- for (i = 0; VEC_iterate (tree, orig, i, vuse); i++)
- {
- if (vuse != SSA_VAL (vuse))
- {
- made_replacement = true;
- VEC_replace (tree, orig, i, SSA_VAL (vuse));
- }
- }
-
- if (made_replacement && VEC_length (tree, orig) > 1)
- sort_vuses (orig);
-
- return orig;
-}
-
-/* Return the single reference statement defining all virtual uses
- in VUSES or NULL_TREE, if there are multiple defining statements.
- Take into account only definitions that alias REF if following
- back-edges. */
-
-static gimple
-get_def_ref_stmt_vuses (tree ref, VEC (tree, gc) *vuses)
-{
- gimple def_stmt;
- tree vuse;
- unsigned int i;
-
- gcc_assert (VEC_length (tree, vuses) >= 1);
-
- def_stmt = SSA_NAME_DEF_STMT (VEC_index (tree, vuses, 0));
- if (gimple_code (def_stmt) == GIMPLE_PHI)
- {
- /* We can only handle lookups over PHI nodes for a single
- virtual operand. */
- if (VEC_length (tree, vuses) == 1)
- {
- def_stmt = get_single_def_stmt_from_phi (ref, def_stmt);
- goto cont;
- }
- else
- return NULL;
- }
-
- /* Verify each VUSE reaches the same defining stmt. */
- for (i = 1; VEC_iterate (tree, vuses, i, vuse); ++i)
- {
- gimple tmp = SSA_NAME_DEF_STMT (vuse);
- if (tmp != def_stmt)
- return NULL;
- }
-
- /* Now see if the definition aliases ref, and loop until it does. */
-cont:
- while (def_stmt
- && is_gimple_assign (def_stmt)
- && !refs_may_alias_p (ref, gimple_get_lhs (def_stmt)))
- def_stmt = get_single_def_stmt_with_phi (ref, def_stmt);
-
- return def_stmt;
-}
-
-/* Lookup a SCCVN reference operation VR in the current hash table.
- Returns the resulting value number if it exists in the hash table,
- NULL_TREE otherwise. VNRESULT will be filled in with the actual
- vn_reference_t stored in the hashtable if something is found. */
-
-static tree
-vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult)
-{
- void **slot;
- hashval_t hash;
-
- hash = vr->hashcode;
- slot = htab_find_slot_with_hash (current_info->references, vr,
- hash, NO_INSERT);
- if (!slot && current_info == optimistic_info)
- slot = htab_find_slot_with_hash (valid_info->references, vr,
- hash, NO_INSERT);
- if (slot)
- {
- if (vnresult)
- *vnresult = (vn_reference_t)*slot;
- return ((vn_reference_t)*slot)->result;
- }
-
- return NULL_TREE;
-}
-
-
-/* Lookup a reference operation by it's parts, in the current hash table.
- Returns the resulting value number if it exists in the hash table,
- NULL_TREE otherwise. VNRESULT will be filled in with the actual
- vn_reference_t stored in the hashtable if something is found. */
-
-tree
-vn_reference_lookup_pieces (VEC (tree, gc) *vuses,
- VEC (vn_reference_op_s, heap) *operands,
- vn_reference_t *vnresult, bool maywalk)
-{
- struct vn_reference_s vr1;
- tree result;
- if (vnresult)
- *vnresult = NULL;
-
- vr1.vuses = valueize_vuses (vuses);
- vr1.operands = valueize_refs (operands);
- vr1.hashcode = vn_reference_compute_hash (&vr1);
- result = vn_reference_lookup_1 (&vr1, vnresult);
-
- /* If there is a single defining statement for all virtual uses, we can
- use that, following virtual use-def chains. */
- if (!result
- && maywalk
- && vr1.vuses
- && VEC_length (tree, vr1.vuses) >= 1)
- {
- tree ref = get_ref_from_reference_ops (operands);
- gimple def_stmt;
- if (ref
- && (def_stmt = get_def_ref_stmt_vuses (ref, vr1.vuses))
- && is_gimple_assign (def_stmt))
- {
- /* We are now at an aliasing definition for the vuses we want to
- look up. Re-do the lookup with the vdefs for this stmt. */
- vdefs_to_vec (def_stmt, &vuses);
- vr1.vuses = valueize_vuses (vuses);
- vr1.hashcode = vn_reference_compute_hash (&vr1);
- result = vn_reference_lookup_1 (&vr1, vnresult);
- }
- }
-
- return result;
-}
-
-/* Lookup OP in the current hash table, and return the resulting value
- number if it exists in the hash table. Return NULL_TREE if it does
- not exist in the hash table or if the result field of the structure
- was NULL.. VNRESULT will be filled in with the vn_reference_t
- stored in the hashtable if one exists. */
-
-tree
-vn_reference_lookup (tree op, VEC (tree, gc) *vuses, bool maywalk,
- vn_reference_t *vnresult)
-{
- struct vn_reference_s vr1;
- tree result;
- gimple def_stmt;
- if (vnresult)
- *vnresult = NULL;
-
- vr1.vuses = valueize_vuses (vuses);
- vr1.operands = valueize_refs (shared_reference_ops_from_ref (op));
- vr1.hashcode = vn_reference_compute_hash (&vr1);
- result = vn_reference_lookup_1 (&vr1, vnresult);
-
- /* If there is a single defining statement for all virtual uses, we can
- use that, following virtual use-def chains. */
- if (!result
- && maywalk
- && vr1.vuses
- && VEC_length (tree, vr1.vuses) >= 1
- && (def_stmt = get_def_ref_stmt_vuses (op, vr1.vuses))
- && is_gimple_assign (def_stmt))
- {
- /* We are now at an aliasing definition for the vuses we want to
- look up. Re-do the lookup with the vdefs for this stmt. */
- vdefs_to_vec (def_stmt, &vuses);
- vr1.vuses = valueize_vuses (vuses);
- vr1.hashcode = vn_reference_compute_hash (&vr1);
- result = vn_reference_lookup_1 (&vr1, vnresult);
- }
-
- return result;
-}
-
-
-/* Insert OP into the current hash table with a value number of
- RESULT, and return the resulting reference structure we created. */
-
-vn_reference_t
-vn_reference_insert (tree op, tree result, VEC (tree, gc) *vuses)
-{
- void **slot;
- vn_reference_t vr1;
-
- vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
- if (TREE_CODE (result) == SSA_NAME)
- vr1->value_id = VN_INFO (result)->value_id;
- else
- vr1->value_id = get_or_alloc_constant_value_id (result);
- vr1->vuses = valueize_vuses (vuses);
- vr1->operands = valueize_refs (create_reference_ops_from_ref (op));
- vr1->hashcode = vn_reference_compute_hash (vr1);
- vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
-
- slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
- INSERT);
-
- /* Because we lookup stores using vuses, and value number failures
- using the vdefs (see visit_reference_op_store for how and why),
- it's possible that on failure we may try to insert an already
- inserted store. This is not wrong, there is no ssa name for a
- store that we could use as a differentiator anyway. Thus, unlike
- the other lookup functions, you cannot gcc_assert (!*slot)
- here. */
-
- /* But free the old slot in case of a collision. */
- if (*slot)
- free_reference (*slot);
-
- *slot = vr1;
- return vr1;
-}
-
-/* Insert a reference by it's pieces into the current hash table with
- a value number of RESULT. Return the resulting reference
- structure we created. */
-
-vn_reference_t
-vn_reference_insert_pieces (VEC (tree, gc) *vuses,
- VEC (vn_reference_op_s, heap) *operands,
- tree result, unsigned int value_id)
-
-{
- void **slot;
- vn_reference_t vr1;
-
- vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
- vr1->value_id = value_id;
- vr1->vuses = valueize_vuses (vuses);
- vr1->operands = valueize_refs (operands);
- vr1->hashcode = vn_reference_compute_hash (vr1);
- if (result && TREE_CODE (result) == SSA_NAME)
- result = SSA_VAL (result);
- vr1->result = result;
-
- slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
- INSERT);
-
- /* At this point we should have all the things inserted that we have
- seen before, and we should never try inserting something that
- already exists. */
- gcc_assert (!*slot);
- if (*slot)
- free_reference (*slot);
-
- *slot = vr1;
- return vr1;
-}
-
-/* Compute and return the hash value for nary operation VBO1. */
-
-inline hashval_t
-vn_nary_op_compute_hash (const vn_nary_op_t vno1)
-{
- hashval_t hash = 0;
- unsigned i;
-
- for (i = 0; i < vno1->length; ++i)
- if (TREE_CODE (vno1->op[i]) == SSA_NAME)
- vno1->op[i] = SSA_VAL (vno1->op[i]);
-
- if (vno1->length == 2
- && commutative_tree_code (vno1->opcode)
- && tree_swap_operands_p (vno1->op[0], vno1->op[1], false))
- {
- tree temp = vno1->op[0];
- vno1->op[0] = vno1->op[1];
- vno1->op[1] = temp;
- }
-
- for (i = 0; i < vno1->length; ++i)
- hash += iterative_hash_expr (vno1->op[i], vno1->opcode);
-
- return hash;
-}
-
-/* Return the computed hashcode for nary operation P1. */
-
-static hashval_t
-vn_nary_op_hash (const void *p1)
-{
- const_vn_nary_op_t const vno1 = (const_vn_nary_op_t) p1;
- return vno1->hashcode;
-}
-
-/* Compare nary operations P1 and P2 and return true if they are
- equivalent. */
-
-int
-vn_nary_op_eq (const void *p1, const void *p2)
-{
- const_vn_nary_op_t const vno1 = (const_vn_nary_op_t) p1;
- const_vn_nary_op_t const vno2 = (const_vn_nary_op_t) p2;
- unsigned i;
-
- if (vno1->hashcode != vno2->hashcode)
- return false;
-
- if (vno1->opcode != vno2->opcode
- || !types_compatible_p (vno1->type, vno2->type))
- return false;
-
- for (i = 0; i < vno1->length; ++i)
- if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
- return false;
-
- return true;
-}
-
-/* Lookup a n-ary operation by its pieces and return the resulting value
- number if it exists in the hash table. Return NULL_TREE if it does
- not exist in the hash table or if the result field of the operation
- is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
- if it exists. */
-
-tree
-vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
- tree type, tree op0, tree op1, tree op2,
- tree op3, vn_nary_op_t *vnresult)
-{
- void **slot;
- struct vn_nary_op_s vno1;
- if (vnresult)
- *vnresult = NULL;
- vno1.opcode = code;
- vno1.length = length;
- vno1.type = type;
- vno1.op[0] = op0;
- vno1.op[1] = op1;
- vno1.op[2] = op2;
- vno1.op[3] = op3;
- vno1.hashcode = vn_nary_op_compute_hash (&vno1);
- slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot && current_info == optimistic_info)
- slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot)
- return NULL_TREE;
- if (vnresult)
- *vnresult = (vn_nary_op_t)*slot;
- return ((vn_nary_op_t)*slot)->result;
-}
-
-/* Lookup OP in the current hash table, and return the resulting value
- number if it exists in the hash table. Return NULL_TREE if it does
- not exist in the hash table or if the result field of the operation
- is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
- if it exists. */
-
-tree
-vn_nary_op_lookup (tree op, vn_nary_op_t *vnresult)
-{
- void **slot;
- struct vn_nary_op_s vno1;
- unsigned i;
-
- if (vnresult)
- *vnresult = NULL;
- vno1.opcode = TREE_CODE (op);
- vno1.length = TREE_CODE_LENGTH (TREE_CODE (op));
- vno1.type = TREE_TYPE (op);
- for (i = 0; i < vno1.length; ++i)
- vno1.op[i] = TREE_OPERAND (op, i);
- vno1.hashcode = vn_nary_op_compute_hash (&vno1);
- slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot && current_info == optimistic_info)
- slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot)
- return NULL_TREE;
- if (vnresult)
- *vnresult = (vn_nary_op_t)*slot;
- return ((vn_nary_op_t)*slot)->result;
-}
-
-/* Lookup the rhs of STMT in the current hash table, and return the resulting
- value number if it exists in the hash table. Return NULL_TREE if
- it does not exist in the hash table. VNRESULT will contain the
- vn_nary_op_t from the hashtable if it exists. */
-
-tree
-vn_nary_op_lookup_stmt (gimple stmt, vn_nary_op_t *vnresult)
-{
- void **slot;
- struct vn_nary_op_s vno1;
- unsigned i;
-
- if (vnresult)
- *vnresult = NULL;
- vno1.opcode = gimple_assign_rhs_code (stmt);
- vno1.length = gimple_num_ops (stmt) - 1;
- vno1.type = TREE_TYPE (gimple_assign_lhs (stmt));
- for (i = 0; i < vno1.length; ++i)
- vno1.op[i] = gimple_op (stmt, i + 1);
- if (vno1.opcode == REALPART_EXPR
- || vno1.opcode == IMAGPART_EXPR
- || vno1.opcode == VIEW_CONVERT_EXPR)
- vno1.op[0] = TREE_OPERAND (vno1.op[0], 0);
- vno1.hashcode = vn_nary_op_compute_hash (&vno1);
- slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot && current_info == optimistic_info)
- slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
- NO_INSERT);
- if (!slot)
- return NULL_TREE;
- if (vnresult)
- *vnresult = (vn_nary_op_t)*slot;
- return ((vn_nary_op_t)*slot)->result;
-}
-
-/* Insert a n-ary operation into the current hash table using it's
- pieces. Return the vn_nary_op_t structure we created and put in
- the hashtable. */
-
-vn_nary_op_t
-vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
- tree type, tree op0,
- tree op1, tree op2, tree op3,
- tree result,
- unsigned int value_id)
-{
- void **slot;
- vn_nary_op_t vno1;
-
- vno1 = (vn_nary_op_t) obstack_alloc (&current_info->nary_obstack,
- (sizeof (struct vn_nary_op_s)
- - sizeof (tree) * (4 - length)));
- vno1->value_id = value_id;
- vno1->opcode = code;
- vno1->length = length;
- vno1->type = type;
- if (length >= 1)
- vno1->op[0] = op0;
- if (length >= 2)
- vno1->op[1] = op1;
- if (length >= 3)
- vno1->op[2] = op2;
- if (length >= 4)
- vno1->op[3] = op3;
- vno1->result = result;
- vno1->hashcode = vn_nary_op_compute_hash (vno1);
- slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
- INSERT);
- gcc_assert (!*slot);
-
- *slot = vno1;
- return vno1;
-
-}
-
-/* Insert OP into the current hash table with a value number of
- RESULT. Return the vn_nary_op_t structure we created and put in
- the hashtable. */
-
-vn_nary_op_t
-vn_nary_op_insert (tree op, tree result)
-{
- unsigned length = TREE_CODE_LENGTH (TREE_CODE (op));
- void **slot;
- vn_nary_op_t vno1;
- unsigned i;
-
- vno1 = (vn_nary_op_t) obstack_alloc (&current_info->nary_obstack,
- (sizeof (struct vn_nary_op_s)
- - sizeof (tree) * (4 - length)));
- vno1->value_id = VN_INFO (result)->value_id;
- vno1->opcode = TREE_CODE (op);
- vno1->length = length;
- vno1->type = TREE_TYPE (op);
- for (i = 0; i < vno1->length; ++i)
- vno1->op[i] = TREE_OPERAND (op, i);
- vno1->result = result;
- vno1->hashcode = vn_nary_op_compute_hash (vno1);
- slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
- INSERT);
- gcc_assert (!*slot);
-
- *slot = vno1;
- return vno1;
-}
-
-/* Insert the rhs of STMT into the current hash table with a value number of
- RESULT. */
-
-vn_nary_op_t
-vn_nary_op_insert_stmt (gimple stmt, tree result)
-{
- unsigned length = gimple_num_ops (stmt) - 1;
- void **slot;
- vn_nary_op_t vno1;
- unsigned i;
-
- vno1 = (vn_nary_op_t) obstack_alloc (&current_info->nary_obstack,
- (sizeof (struct vn_nary_op_s)
- - sizeof (tree) * (4 - length)));
- vno1->value_id = VN_INFO (result)->value_id;
- vno1->opcode = gimple_assign_rhs_code (stmt);
- vno1->length = length;
- vno1->type = TREE_TYPE (gimple_assign_lhs (stmt));
- for (i = 0; i < vno1->length; ++i)
- vno1->op[i] = gimple_op (stmt, i + 1);
- if (vno1->opcode == REALPART_EXPR
- || vno1->opcode == IMAGPART_EXPR
- || vno1->opcode == VIEW_CONVERT_EXPR)
- vno1->op[0] = TREE_OPERAND (vno1->op[0], 0);
- vno1->result = result;
- vno1->hashcode = vn_nary_op_compute_hash (vno1);
- slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
- INSERT);
- gcc_assert (!*slot);
-
- *slot = vno1;
- return vno1;
-}
-
-/* Compute a hashcode for PHI operation VP1 and return it. */
-
-static inline hashval_t
-vn_phi_compute_hash (vn_phi_t vp1)
-{
- hashval_t result = 0;
- int i;
- tree phi1op;
- tree type;
-
- result = vp1->block->index;
-
- /* If all PHI arguments are constants we need to distinguish
- the PHI node via its type. */
- type = TREE_TYPE (VEC_index (tree, vp1->phiargs, 0));
- result += (INTEGRAL_TYPE_P (type)
- + (INTEGRAL_TYPE_P (type)
- ? TYPE_PRECISION (type) + TYPE_UNSIGNED (type) : 0));
-
- for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
- {
- if (phi1op == VN_TOP)
- continue;
- result += iterative_hash_expr (phi1op, result);
- }
-
- return result;
-}
-
-/* Return the computed hashcode for phi operation P1. */
-
-static hashval_t
-vn_phi_hash (const void *p1)
-{
- const_vn_phi_t const vp1 = (const_vn_phi_t) p1;
- return vp1->hashcode;
-}
-
-/* Compare two phi entries for equality, ignoring VN_TOP arguments. */
-
-static int
-vn_phi_eq (const void *p1, const void *p2)
-{
- const_vn_phi_t const vp1 = (const_vn_phi_t) p1;
- const_vn_phi_t const vp2 = (const_vn_phi_t) p2;
-
- if (vp1->hashcode != vp2->hashcode)
- return false;
-
- if (vp1->block == vp2->block)
- {
- int i;
- tree phi1op;
-
- /* If the PHI nodes do not have compatible types
- they are not the same. */
- if (!types_compatible_p (TREE_TYPE (VEC_index (tree, vp1->phiargs, 0)),
- TREE_TYPE (VEC_index (tree, vp2->phiargs, 0))))
- return false;
-
- /* Any phi in the same block will have it's arguments in the
- same edge order, because of how we store phi nodes. */
- for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
- {
- tree phi2op = VEC_index (tree, vp2->phiargs, i);
- if (phi1op == VN_TOP || phi2op == VN_TOP)
- continue;
- if (!expressions_equal_p (phi1op, phi2op))
- return false;
- }
- return true;
- }
- return false;
-}
-
-static VEC(tree, heap) *shared_lookup_phiargs;
-
-/* Lookup PHI in the current hash table, and return the resulting
- value number if it exists in the hash table. Return NULL_TREE if
- it does not exist in the hash table. */
-
-static tree
-vn_phi_lookup (gimple phi)
-{
- void **slot;
- struct vn_phi_s vp1;
- unsigned i;
-
- VEC_truncate (tree, shared_lookup_phiargs, 0);
-
- /* Canonicalize the SSA_NAME's to their value number. */
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree def = PHI_ARG_DEF (phi, i);
- def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
- VEC_safe_push (tree, heap, shared_lookup_phiargs, def);
- }
- vp1.phiargs = shared_lookup_phiargs;
- vp1.block = gimple_bb (phi);
- vp1.hashcode = vn_phi_compute_hash (&vp1);
- slot = htab_find_slot_with_hash (current_info->phis, &vp1, vp1.hashcode,
- NO_INSERT);
- if (!slot && current_info == optimistic_info)
- slot = htab_find_slot_with_hash (valid_info->phis, &vp1, vp1.hashcode,
- NO_INSERT);
- if (!slot)
- return NULL_TREE;
- return ((vn_phi_t)*slot)->result;
-}
-
-/* Insert PHI into the current hash table with a value number of
- RESULT. */
-
-static vn_phi_t
-vn_phi_insert (gimple phi, tree result)
-{
- void **slot;
- vn_phi_t vp1 = (vn_phi_t) pool_alloc (current_info->phis_pool);
- unsigned i;
- VEC (tree, heap) *args = NULL;
-
- /* Canonicalize the SSA_NAME's to their value number. */
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree def = PHI_ARG_DEF (phi, i);
- def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
- VEC_safe_push (tree, heap, args, def);
- }
- vp1->value_id = VN_INFO (result)->value_id;
- vp1->phiargs = args;
- vp1->block = gimple_bb (phi);
- vp1->result = result;
- vp1->hashcode = vn_phi_compute_hash (vp1);
-
- slot = htab_find_slot_with_hash (current_info->phis, vp1, vp1->hashcode,
- INSERT);
-
- /* Because we iterate over phi operations more than once, it's
- possible the slot might already exist here, hence no assert.*/
- *slot = vp1;
- return vp1;
-}
-
-
-/* Print set of components in strongly connected component SCC to OUT. */
-
-static void
-print_scc (FILE *out, VEC (tree, heap) *scc)
-{
- tree var;
- unsigned int i;
-
- fprintf (out, "SCC consists of: ");
- for (i = 0; VEC_iterate (tree, scc, i, var); i++)
- {
- print_generic_expr (out, var, 0);
- fprintf (out, " ");
- }
- fprintf (out, "\n");
-}
-
-/* Set the value number of FROM to TO, return true if it has changed
- as a result. */
-
-static inline bool
-set_ssa_val_to (tree from, tree to)
-{
- tree currval;
-
- if (from != to
- && TREE_CODE (to) == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to))
- to = from;
-
- /* The only thing we allow as value numbers are VN_TOP, ssa_names
- and invariants. So assert that here. */
- gcc_assert (to != NULL_TREE
- && (to == VN_TOP
- || TREE_CODE (to) == SSA_NAME
- || is_gimple_min_invariant (to)));
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Setting value number of ");
- print_generic_expr (dump_file, from, 0);
- fprintf (dump_file, " to ");
- print_generic_expr (dump_file, to, 0);
- }
-
- currval = SSA_VAL (from);
-
- if (currval != to && !operand_equal_p (currval, to, OEP_PURE_SAME))
- {
- SSA_VAL (from) = to;
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, " (changed)\n");
- return true;
- }
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\n");
- return false;
-}
-
-/* Set all definitions in STMT to value number to themselves.
- Return true if a value number changed. */
-
-static bool
-defs_to_varying (gimple stmt)
-{
- bool changed = false;
- ssa_op_iter iter;
- def_operand_p defp;
-
- FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_ALL_DEFS)
- {
- tree def = DEF_FROM_PTR (defp);
-
- VN_INFO (def)->use_processed = true;
- changed |= set_ssa_val_to (def, def);
- }
- return changed;
-}
-
-static bool expr_has_constants (tree expr);
-static tree valueize_expr (tree expr);
-
-/* Visit a copy between LHS and RHS, return true if the value number
- changed. */
-
-static bool
-visit_copy (tree lhs, tree rhs)
-{
- /* Follow chains of copies to their destination. */
- while (TREE_CODE (rhs) == SSA_NAME
- && SSA_VAL (rhs) != rhs)
- rhs = SSA_VAL (rhs);
-
- /* The copy may have a more interesting constant filled expression
- (we don't, since we know our RHS is just an SSA name). */
- if (TREE_CODE (rhs) == SSA_NAME)
- {
- VN_INFO (lhs)->has_constants = VN_INFO (rhs)->has_constants;
- VN_INFO (lhs)->expr = VN_INFO (rhs)->expr;
- }
-
- return set_ssa_val_to (lhs, rhs);
-}
-
-/* Visit a unary operator RHS, value number it, and return true if the
- value number of LHS has changed as a result. */
-
-static bool
-visit_unary_op (tree lhs, gimple stmt)
-{
- bool changed = false;
- tree result = vn_nary_op_lookup_stmt (stmt, NULL);
-
- if (result)
- {
- changed = set_ssa_val_to (lhs, result);
- }
- else
- {
- changed = set_ssa_val_to (lhs, lhs);
- vn_nary_op_insert_stmt (stmt, lhs);
- }
-
- return changed;
-}
-
-/* Visit a binary operator RHS, value number it, and return true if the
- value number of LHS has changed as a result. */
-
-static bool
-visit_binary_op (tree lhs, gimple stmt)
-{
- bool changed = false;
- tree result = vn_nary_op_lookup_stmt (stmt, NULL);
-
- if (result)
- {
- changed = set_ssa_val_to (lhs, result);
- }
- else
- {
- changed = set_ssa_val_to (lhs, lhs);
- vn_nary_op_insert_stmt (stmt, lhs);
- }
-
- return changed;
-}
-
-/* Visit a call STMT storing into LHS. Return true if the value number
- of the LHS has changed as a result. */
-
-static bool
-visit_reference_op_call (tree lhs, gimple stmt)
-{
- bool changed = false;
- struct vn_reference_s vr1;
- tree result;
-
- vr1.vuses = valueize_vuses (shared_vuses_from_stmt (stmt));
- vr1.operands = valueize_refs (shared_reference_ops_from_call (stmt));
- vr1.hashcode = vn_reference_compute_hash (&vr1);
- result = vn_reference_lookup_1 (&vr1, NULL);
- if (result)
- {
- changed = set_ssa_val_to (lhs, result);
- if (TREE_CODE (result) == SSA_NAME
- && VN_INFO (result)->has_constants)
- VN_INFO (lhs)->has_constants = true;
- }
- else
- {
- void **slot;
- vn_reference_t vr2;
- changed = set_ssa_val_to (lhs, lhs);
- vr2 = (vn_reference_t) pool_alloc (current_info->references_pool);
- vr2->vuses = valueize_vuses (copy_vuses_from_stmt (stmt));
- vr2->operands = valueize_refs (create_reference_ops_from_call (stmt));
- vr2->hashcode = vr1.hashcode;
- vr2->result = lhs;
- slot = htab_find_slot_with_hash (current_info->references,
- vr2, vr2->hashcode, INSERT);
- if (*slot)
- free_reference (*slot);
- *slot = vr2;
- }
-
- return changed;
-}
-
-/* Visit a load from a reference operator RHS, part of STMT, value number it,
- and return true if the value number of the LHS has changed as a result. */
-
-static bool
-visit_reference_op_load (tree lhs, tree op, gimple stmt)
-{
- bool changed = false;
- tree result = vn_reference_lookup (op, shared_vuses_from_stmt (stmt), true,
- NULL);
-
- /* We handle type-punning through unions by value-numbering based
- on offset and size of the access. Be prepared to handle a
- type-mismatch here via creating a VIEW_CONVERT_EXPR. */
- if (result
- && !useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (op)))
- {
- /* We will be setting the value number of lhs to the value number
- of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
- So first simplify and lookup this expression to see if it
- is already available. */
- tree val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (op), result);
- if ((CONVERT_EXPR_P (val)
- || TREE_CODE (val) == VIEW_CONVERT_EXPR)
- && TREE_CODE (TREE_OPERAND (val, 0)) == SSA_NAME)
- {
- tree tem = valueize_expr (vn_get_expr_for (TREE_OPERAND (val, 0)));
- if ((CONVERT_EXPR_P (tem)
- || TREE_CODE (tem) == VIEW_CONVERT_EXPR)
- && (tem = fold_unary_ignore_overflow (TREE_CODE (val),
- TREE_TYPE (val), tem)))
- val = tem;
- }
- result = val;
- if (!is_gimple_min_invariant (val)
- && TREE_CODE (val) != SSA_NAME)
- result = vn_nary_op_lookup (val, NULL);
- /* If the expression is not yet available, value-number lhs to
- a new SSA_NAME we create. */
- if (!result && may_insert)
- {
- result = make_ssa_name (SSA_NAME_VAR (lhs), NULL);
- /* Initialize value-number information properly. */
- VN_INFO_GET (result)->valnum = result;
- VN_INFO (result)->value_id = get_next_value_id ();
- VN_INFO (result)->expr = val;
- VN_INFO (result)->has_constants = expr_has_constants (val);
- VN_INFO (result)->needs_insertion = true;
- /* As all "inserted" statements are singleton SCCs, insert
- to the valid table. This is strictly needed to
- avoid re-generating new value SSA_NAMEs for the same
- expression during SCC iteration over and over (the
- optimistic table gets cleared after each iteration).
- We do not need to insert into the optimistic table, as
- lookups there will fall back to the valid table. */
- if (current_info == optimistic_info)
- {
- current_info = valid_info;
- vn_nary_op_insert (val, result);
- current_info = optimistic_info;
- }
- else
- vn_nary_op_insert (val, result);
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Inserting name ");
- print_generic_expr (dump_file, result, 0);
- fprintf (dump_file, " for expression ");
- print_generic_expr (dump_file, val, 0);
- fprintf (dump_file, "\n");
- }
- }
- }
-
- if (result)
- {
- changed = set_ssa_val_to (lhs, result);
- if (TREE_CODE (result) == SSA_NAME
- && VN_INFO (result)->has_constants)
- {
- VN_INFO (lhs)->expr = VN_INFO (result)->expr;
- VN_INFO (lhs)->has_constants = true;
- }
- }
- else
- {
- changed = set_ssa_val_to (lhs, lhs);
- vn_reference_insert (op, lhs, copy_vuses_from_stmt (stmt));
- }
-
- return changed;
-}
-
-
-/* Visit a store to a reference operator LHS, part of STMT, value number it,
- and return true if the value number of the LHS has changed as a result. */
-
-static bool
-visit_reference_op_store (tree lhs, tree op, gimple stmt)
-{
- bool changed = false;
- tree result;
- bool resultsame = false;
-
- /* First we want to lookup using the *vuses* from the store and see
- if there the last store to this location with the same address
- had the same value.
-
- The vuses represent the memory state before the store. If the
- memory state, address, and value of the store is the same as the
- last store to this location, then this store will produce the
- same memory state as that store.
-
- In this case the vdef versions for this store are value numbered to those
- vuse versions, since they represent the same memory state after
- this store.
-
- Otherwise, the vdefs for the store are used when inserting into
- the table, since the store generates a new memory state. */
-
- result = vn_reference_lookup (lhs, shared_vuses_from_stmt (stmt), false,
- NULL);
-
- if (result)
- {
- if (TREE_CODE (result) == SSA_NAME)
- result = SSA_VAL (result);
- if (TREE_CODE (op) == SSA_NAME)
- op = SSA_VAL (op);
- resultsame = expressions_equal_p (result, op);
- }
-
- if (!result || !resultsame)
- {
- VEC(tree, gc) *vdefs = copy_vdefs_from_stmt (stmt);
- int i;
- tree vdef;
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "No store match\n");
- fprintf (dump_file, "Value numbering store ");
- print_generic_expr (dump_file, lhs, 0);
- fprintf (dump_file, " to ");
- print_generic_expr (dump_file, op, 0);
- fprintf (dump_file, "\n");
- }
- /* Have to set value numbers before insert, since insert is
- going to valueize the references in-place. */
- for (i = 0; VEC_iterate (tree, vdefs, i, vdef); i++)
- {
- VN_INFO (vdef)->use_processed = true;
- changed |= set_ssa_val_to (vdef, vdef);
- }
-
- /* Do not insert structure copies into the tables. */
- if (is_gimple_min_invariant (op)
- || is_gimple_reg (op))
- vn_reference_insert (lhs, op, vdefs);
- }
- else
- {
- /* We had a match, so value number the vdefs to have the value
- number of the vuses they came from. */
- ssa_op_iter op_iter;
- def_operand_p var;
- vuse_vec_p vv;
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "Store matched earlier value,"
- "value numbering store vdefs to matching vuses.\n");
-
- FOR_EACH_SSA_VDEF_OPERAND (var, vv, stmt, op_iter)
- {
- tree def = DEF_FROM_PTR (var);
- tree use;
-
- /* Uh, if the vuse is a multiuse, we can't really do much
- here, sadly, since we don't know which value number of
- which vuse to use. */
- if (VUSE_VECT_NUM_ELEM (*vv) != 1)
- use = def;
- else
- use = VUSE_ELEMENT_VAR (*vv, 0);
-
- VN_INFO (def)->use_processed = true;
- changed |= set_ssa_val_to (def, SSA_VAL (use));
- }
- }
-
- return changed;
-}
-
-/* Visit and value number PHI, return true if the value number
- changed. */
-
-static bool
-visit_phi (gimple phi)
-{
- bool changed = false;
- tree result;
- tree sameval = VN_TOP;
- bool allsame = true;
- unsigned i;
-
- /* TODO: We could check for this in init_sccvn, and replace this
- with a gcc_assert. */
- if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)))
- return set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
-
- /* See if all non-TOP arguments have the same value. TOP is
- equivalent to everything, so we can ignore it. */
- for (i = 0; i < gimple_phi_num_args (phi); i++)
- {
- tree def = PHI_ARG_DEF (phi, i);
-
- if (TREE_CODE (def) == SSA_NAME)
- def = SSA_VAL (def);
- if (def == VN_TOP)
- continue;
- if (sameval == VN_TOP)
- {
- sameval = def;
- }
- else
- {
- if (!expressions_equal_p (def, sameval))
- {
- allsame = false;
- break;
- }
- }
- }
-
- /* If all value numbered to the same value, the phi node has that
- value. */
- if (allsame)
- {
- if (is_gimple_min_invariant (sameval))
- {
- VN_INFO (PHI_RESULT (phi))->has_constants = true;
- VN_INFO (PHI_RESULT (phi))->expr = sameval;
- }
- else
- {
- VN_INFO (PHI_RESULT (phi))->has_constants = false;
- VN_INFO (PHI_RESULT (phi))->expr = sameval;
- }
-
- if (TREE_CODE (sameval) == SSA_NAME)
- return visit_copy (PHI_RESULT (phi), sameval);
-
- return set_ssa_val_to (PHI_RESULT (phi), sameval);
- }
-
- /* Otherwise, see if it is equivalent to a phi node in this block. */
- result = vn_phi_lookup (phi);
- if (result)
- {
- if (TREE_CODE (result) == SSA_NAME)
- changed = visit_copy (PHI_RESULT (phi), result);
- else
- changed = set_ssa_val_to (PHI_RESULT (phi), result);
- }
- else
- {
- vn_phi_insert (phi, PHI_RESULT (phi));
- VN_INFO (PHI_RESULT (phi))->has_constants = false;
- VN_INFO (PHI_RESULT (phi))->expr = PHI_RESULT (phi);
- changed = set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
- }
-
- return changed;
-}
-
-/* Return true if EXPR contains constants. */
-
-static bool
-expr_has_constants (tree expr)
-{
- switch (TREE_CODE_CLASS (TREE_CODE (expr)))
- {
- case tcc_unary:
- return is_gimple_min_invariant (TREE_OPERAND (expr, 0));
-
- case tcc_binary:
- return is_gimple_min_invariant (TREE_OPERAND (expr, 0))
- || is_gimple_min_invariant (TREE_OPERAND (expr, 1));
- /* Constants inside reference ops are rarely interesting, but
- it can take a lot of looking to find them. */
- case tcc_reference:
- case tcc_declaration:
- return false;
- default:
- return is_gimple_min_invariant (expr);
- }
- return false;
-}
-
-/* Return true if STMT contains constants. */
-
-static bool
-stmt_has_constants (gimple stmt)
-{
- if (gimple_code (stmt) != GIMPLE_ASSIGN)
- return false;
-
- switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
- {
- case GIMPLE_UNARY_RHS:
- return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
-
- case GIMPLE_BINARY_RHS:
- return (is_gimple_min_invariant (gimple_assign_rhs1 (stmt))
- || is_gimple_min_invariant (gimple_assign_rhs2 (stmt)));
- case GIMPLE_SINGLE_RHS:
- /* Constants inside reference ops are rarely interesting, but
- it can take a lot of looking to find them. */
- return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
- default:
- gcc_unreachable ();
- }
- return false;
-}
-
-/* Replace SSA_NAMES in expr with their value numbers, and return the
- result.
- This is performed in place. */
-
-static tree
-valueize_expr (tree expr)
-{
- switch (TREE_CODE_CLASS (TREE_CODE (expr)))
- {
- case tcc_unary:
- if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
- TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
- break;
- case tcc_binary:
- if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
- TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
- if (TREE_CODE (TREE_OPERAND (expr, 1)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 1)) != VN_TOP)
- TREE_OPERAND (expr, 1) = SSA_VAL (TREE_OPERAND (expr, 1));
- break;
- default:
- break;
- }
- return expr;
-}
-
-/* Simplify the binary expression RHS, and return the result if
- simplified. */
-
-static tree
-simplify_binary_expression (gimple stmt)
-{
- tree result = NULL_TREE;
- tree op0 = gimple_assign_rhs1 (stmt);
- tree op1 = gimple_assign_rhs2 (stmt);
-
- /* This will not catch every single case we could combine, but will
- catch those with constants. The goal here is to simultaneously
- combine constants between expressions, but avoid infinite
- expansion of expressions during simplification. */
- if (TREE_CODE (op0) == SSA_NAME)
- {
- if (VN_INFO (op0)->has_constants
- || TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
- op0 = valueize_expr (vn_get_expr_for (op0));
- else if (SSA_VAL (op0) != VN_TOP && SSA_VAL (op0) != op0)
- op0 = SSA_VAL (op0);
- }
-
- if (TREE_CODE (op1) == SSA_NAME)
- {
- if (VN_INFO (op1)->has_constants)
- op1 = valueize_expr (vn_get_expr_for (op1));
- else if (SSA_VAL (op1) != VN_TOP && SSA_VAL (op1) != op1)
- op1 = SSA_VAL (op1);
- }
-
- /* Avoid folding if nothing changed. */
- if (op0 == gimple_assign_rhs1 (stmt)
- && op1 == gimple_assign_rhs2 (stmt))
- return NULL_TREE;
-
- fold_defer_overflow_warnings ();
-
- result = fold_binary (gimple_assign_rhs_code (stmt),
- TREE_TYPE (gimple_get_lhs (stmt)), op0, op1);
- if (result)
- STRIP_USELESS_TYPE_CONVERSION (result);
-
- fold_undefer_overflow_warnings (result && valid_gimple_rhs_p (result),
- stmt, 0);
-
- /* Make sure result is not a complex expression consisting
- of operators of operators (IE (a + b) + (a + c))
- Otherwise, we will end up with unbounded expressions if
- fold does anything at all. */
- if (result && valid_gimple_rhs_p (result))
- return result;
-
- return NULL_TREE;
-}
-
-/* Simplify the unary expression RHS, and return the result if
- simplified. */
-
-static tree
-simplify_unary_expression (gimple stmt)
-{
- tree result = NULL_TREE;
- tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
-
- /* We handle some tcc_reference codes here that are all
- GIMPLE_ASSIGN_SINGLE codes. */
- if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
- op0 = TREE_OPERAND (op0, 0);
-
- if (TREE_CODE (op0) != SSA_NAME)
- return NULL_TREE;
-
- orig_op0 = op0;
- if (VN_INFO (op0)->has_constants)
- op0 = valueize_expr (vn_get_expr_for (op0));
- else if (gimple_assign_cast_p (stmt)
- || gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
- {
- /* We want to do tree-combining on conversion-like expressions.
- Make sure we feed only SSA_NAMEs or constants to fold though. */
- tree tem = valueize_expr (vn_get_expr_for (op0));
- if (UNARY_CLASS_P (tem)
- || BINARY_CLASS_P (tem)
- || TREE_CODE (tem) == VIEW_CONVERT_EXPR
- || TREE_CODE (tem) == SSA_NAME
- || is_gimple_min_invariant (tem))
- op0 = tem;
- }
-
- /* Avoid folding if nothing changed, but remember the expression. */
- if (op0 == orig_op0)
- return NULL_TREE;
-
- result = fold_unary_ignore_overflow (gimple_assign_rhs_code (stmt),
- gimple_expr_type (stmt), op0);
- if (result)
- {
- STRIP_USELESS_TYPE_CONVERSION (result);
- if (valid_gimple_rhs_p (result))
- return result;
- }
-
- return NULL_TREE;
-}
-
-/* Try to simplify RHS using equivalences and constant folding. */
-
-static tree
-try_to_simplify (gimple stmt)
-{
- tree tem;
-
- /* For stores we can end up simplifying a SSA_NAME rhs. Just return
- in this case, there is no point in doing extra work. */
- if (gimple_assign_copy_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
- return NULL_TREE;
-
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
- {
- case tcc_declaration:
- tem = get_symbol_constant_value (gimple_assign_rhs1 (stmt));
- if (tem)
- return tem;
- break;
-
- case tcc_reference:
- /* Do not do full-blown reference lookup here, but simplify
- reads from constant aggregates. */
- tem = fold_const_aggregate_ref (gimple_assign_rhs1 (stmt));
- if (tem)
- return tem;
-
- /* Fallthrough for some codes that can operate on registers. */
- if (!(TREE_CODE (gimple_assign_rhs1 (stmt)) == REALPART_EXPR
- || TREE_CODE (gimple_assign_rhs1 (stmt)) == IMAGPART_EXPR
- || TREE_CODE (gimple_assign_rhs1 (stmt)) == VIEW_CONVERT_EXPR))
- break;
- /* We could do a little more with unary ops, if they expand
- into binary ops, but it's debatable whether it is worth it. */
- case tcc_unary:
- return simplify_unary_expression (stmt);
- break;
- case tcc_comparison:
- case tcc_binary:
- return simplify_binary_expression (stmt);
- break;
- default:
- break;
- }
-
- return NULL_TREE;
-}
-
-/* Visit and value number USE, return true if the value number
- changed. */
-
-static bool
-visit_use (tree use)
-{
- bool changed = false;
- gimple stmt = SSA_NAME_DEF_STMT (use);
-
- VN_INFO (use)->use_processed = true;
-
- gcc_assert (!SSA_NAME_IN_FREE_LIST (use));
- if (dump_file && (dump_flags & TDF_DETAILS)
- && !SSA_NAME_IS_DEFAULT_DEF (use))
- {
- fprintf (dump_file, "Value numbering ");
- print_generic_expr (dump_file, use, 0);
- fprintf (dump_file, " stmt = ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
- }
-
- /* Handle uninitialized uses. */
- if (SSA_NAME_IS_DEFAULT_DEF (use))
- changed = set_ssa_val_to (use, use);
- else
- {
- if (gimple_code (stmt) == GIMPLE_PHI)
- changed = visit_phi (stmt);
- else if (!gimple_has_lhs (stmt)
- || gimple_has_volatile_ops (stmt)
- || stmt_could_throw_p (stmt))
- changed = defs_to_varying (stmt);
- else if (is_gimple_assign (stmt))
- {
- tree lhs = gimple_assign_lhs (stmt);
- tree simplified;
-
- /* Shortcut for copies. Simplifying copies is pointless,
- since we copy the expression and value they represent. */
- if (gimple_assign_copy_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
- && TREE_CODE (lhs) == SSA_NAME)
- {
- changed = visit_copy (lhs, gimple_assign_rhs1 (stmt));
- goto done;
- }
- simplified = try_to_simplify (stmt);
- if (simplified)
- {
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "RHS ");
- print_gimple_expr (dump_file, stmt, 0, 0);
- fprintf (dump_file, " simplified to ");
- print_generic_expr (dump_file, simplified, 0);
- if (TREE_CODE (lhs) == SSA_NAME)
- fprintf (dump_file, " has constants %d\n",
- expr_has_constants (simplified));
- else
- fprintf (dump_file, "\n");
- }
- }
- /* Setting value numbers to constants will occasionally
- screw up phi congruence because constants are not
- uniquely associated with a single ssa name that can be
- looked up. */
- if (simplified
- && is_gimple_min_invariant (simplified)
- && TREE_CODE (lhs) == SSA_NAME)
- {
- VN_INFO (lhs)->expr = simplified;
- VN_INFO (lhs)->has_constants = true;
- changed = set_ssa_val_to (lhs, simplified);
- goto done;
- }
- else if (simplified
- && TREE_CODE (simplified) == SSA_NAME
- && TREE_CODE (lhs) == SSA_NAME)
- {
- changed = visit_copy (lhs, simplified);
- goto done;
- }
- else if (simplified)
- {
- if (TREE_CODE (lhs) == SSA_NAME)
- {
- VN_INFO (lhs)->has_constants = expr_has_constants (simplified);
- /* We have to unshare the expression or else
- valuizing may change the IL stream. */
- VN_INFO (lhs)->expr = unshare_expr (simplified);
- }
- }
- else if (stmt_has_constants (stmt)
- && TREE_CODE (lhs) == SSA_NAME)
- VN_INFO (lhs)->has_constants = true;
- else if (TREE_CODE (lhs) == SSA_NAME)
- {
- /* We reset expr and constantness here because we may
- have been value numbering optimistically, and
- iterating. They may become non-constant in this case,
- even if they were optimistically constant. */
-
- VN_INFO (lhs)->has_constants = false;
- VN_INFO (lhs)->expr = NULL_TREE;
- }
-
- if ((TREE_CODE (lhs) == SSA_NAME
- /* We can substitute SSA_NAMEs that are live over
- abnormal edges with their constant value. */
- && !(gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
- && !(simplified
- && is_gimple_min_invariant (simplified))
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
- /* Stores or copies from SSA_NAMEs that are live over
- abnormal edges are a problem. */
- || (gimple_assign_single_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))))
- changed = defs_to_varying (stmt);
- else if (REFERENCE_CLASS_P (lhs) || DECL_P (lhs))
- {
- changed = visit_reference_op_store (lhs, gimple_assign_rhs1 (stmt), stmt);
- }
- else if (TREE_CODE (lhs) == SSA_NAME)
- {
- if ((gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
- || (simplified
- && is_gimple_min_invariant (simplified)))
- {
- VN_INFO (lhs)->has_constants = true;
- if (simplified)
- changed = set_ssa_val_to (lhs, simplified);
- else
- changed = set_ssa_val_to (lhs, gimple_assign_rhs1 (stmt));
- }
- else
- {
- switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
- {
- case GIMPLE_UNARY_RHS:
- changed = visit_unary_op (lhs, stmt);
- break;
- case GIMPLE_BINARY_RHS:
- changed = visit_binary_op (lhs, stmt);
- break;
- case GIMPLE_SINGLE_RHS:
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
- {
- case tcc_reference:
- /* VOP-less references can go through unary case. */
- if ((gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR )
- && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == SSA_NAME)
- {
- changed = visit_unary_op (lhs, stmt);
- break;
- }
- /* Fallthrough. */
- case tcc_declaration:
- changed = visit_reference_op_load
- (lhs, gimple_assign_rhs1 (stmt), stmt);
- break;
- case tcc_expression:
- if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
- {
- changed = visit_unary_op (lhs, stmt);
- break;
- }
- /* Fallthrough. */
- default:
- changed = defs_to_varying (stmt);
- }
- break;
- default:
- changed = defs_to_varying (stmt);
- break;
- }
- }
- }
- else
- changed = defs_to_varying (stmt);
- }
- else if (is_gimple_call (stmt))
- {
- tree lhs = gimple_call_lhs (stmt);
-
- /* ??? We could try to simplify calls. */
-
- if (stmt_has_constants (stmt)
- && TREE_CODE (lhs) == SSA_NAME)
- VN_INFO (lhs)->has_constants = true;
- else if (TREE_CODE (lhs) == SSA_NAME)
- {
- /* We reset expr and constantness here because we may
- have been value numbering optimistically, and
- iterating. They may become non-constant in this case,
- even if they were optimistically constant. */
- VN_INFO (lhs)->has_constants = false;
- VN_INFO (lhs)->expr = NULL_TREE;
- }
-
- if (TREE_CODE (lhs) == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
- changed = defs_to_varying (stmt);
- /* ??? We should handle stores from calls. */
- else if (TREE_CODE (lhs) == SSA_NAME)
- {
- if (gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST))
- changed = visit_reference_op_call (lhs, stmt);
- else
- changed = defs_to_varying (stmt);
- }
- else
- changed = defs_to_varying (stmt);
- }
- }
- done:
- return changed;
-}
-
-/* Compare two operands by reverse postorder index */
-
-static int
-compare_ops (const void *pa, const void *pb)
-{
- const tree opa = *((const tree *)pa);
- const tree opb = *((const tree *)pb);
- gimple opstmta = SSA_NAME_DEF_STMT (opa);
- gimple opstmtb = SSA_NAME_DEF_STMT (opb);
- basic_block bba;
- basic_block bbb;
-
- if (gimple_nop_p (opstmta) && gimple_nop_p (opstmtb))
- return 0;
- else if (gimple_nop_p (opstmta))
- return -1;
- else if (gimple_nop_p (opstmtb))
- return 1;
-
- bba = gimple_bb (opstmta);
- bbb = gimple_bb (opstmtb);
-
- if (!bba && !bbb)
- return 0;
- else if (!bba)
- return -1;
- else if (!bbb)
- return 1;
-
- if (bba == bbb)
- {
- if (gimple_code (opstmta) == GIMPLE_PHI
- && gimple_code (opstmtb) == GIMPLE_PHI)
- return 0;
- else if (gimple_code (opstmta) == GIMPLE_PHI)
- return -1;
- else if (gimple_code (opstmtb) == GIMPLE_PHI)
- return 1;
- return gimple_uid (opstmta) - gimple_uid (opstmtb);
- }
- return rpo_numbers[bba->index] - rpo_numbers[bbb->index];
-}
-
-/* Sort an array containing members of a strongly connected component
- SCC so that the members are ordered by RPO number.
- This means that when the sort is complete, iterating through the
- array will give you the members in RPO order. */
-
-static void
-sort_scc (VEC (tree, heap) *scc)
-{
- qsort (VEC_address (tree, scc),
- VEC_length (tree, scc),
- sizeof (tree),
- compare_ops);
-}
-
-/* Process a strongly connected component in the SSA graph. */
-
-static void
-process_scc (VEC (tree, heap) *scc)
-{
- /* If the SCC has a single member, just visit it. */
-
- if (VEC_length (tree, scc) == 1)
- {
- tree use = VEC_index (tree, scc, 0);
- if (!VN_INFO (use)->use_processed)
- visit_use (use);
- }
- else
- {
- tree var;
- unsigned int i;
- unsigned int iterations = 0;
- bool changed = true;
-
- /* Iterate over the SCC with the optimistic table until it stops
- changing. */
- current_info = optimistic_info;
- while (changed)
- {
- changed = false;
- iterations++;
- /* As we are value-numbering optimistically we have to
- clear the expression tables and the simplified expressions
- in each iteration until we converge. */
- htab_empty (optimistic_info->nary);
- htab_empty (optimistic_info->phis);
- htab_empty (optimistic_info->references);
- obstack_free (&optimistic_info->nary_obstack, NULL);
- gcc_obstack_init (&optimistic_info->nary_obstack);
- empty_alloc_pool (optimistic_info->phis_pool);
- empty_alloc_pool (optimistic_info->references_pool);
- for (i = 0; VEC_iterate (tree, scc, i, var); i++)
- VN_INFO (var)->expr = NULL_TREE;
- for (i = 0; VEC_iterate (tree, scc, i, var); i++)
- changed |= visit_use (var);
- }
-
- statistics_histogram_event (cfun, "SCC iterations", iterations);
-
- /* Finally, visit the SCC once using the valid table. */
- current_info = valid_info;
- for (i = 0; VEC_iterate (tree, scc, i, var); i++)
- visit_use (var);
- }
-}
-
-DEF_VEC_O(ssa_op_iter);
-DEF_VEC_ALLOC_O(ssa_op_iter,heap);
-
-/* Pop the components of the found SCC for NAME off the SCC stack
- and process them. Returns true if all went well, false if
- we run into resource limits. */
-
-static bool
-extract_and_process_scc_for_name (tree name)
-{
- VEC (tree, heap) *scc = NULL;
- tree x;
-
- /* Found an SCC, pop the components off the SCC stack and
- process them. */
- do
- {
- x = VEC_pop (tree, sccstack);
-
- VN_INFO (x)->on_sccstack = false;
- VEC_safe_push (tree, heap, scc, x);
- } while (x != name);
-
- /* Bail out of SCCVN in case a SCC turns out to be incredibly large. */
- if (VEC_length (tree, scc)
- > (unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE))
- {
- if (dump_file)
- fprintf (dump_file, "WARNING: Giving up with SCCVN due to "
- "SCC size %u exceeding %u\n", VEC_length (tree, scc),
- (unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE));
- return false;
- }
-
- if (VEC_length (tree, scc) > 1)
- sort_scc (scc);
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- print_scc (dump_file, scc);
-
- process_scc (scc);
-
- VEC_free (tree, heap, scc);
-
- return true;
-}
-
-/* Depth first search on NAME to discover and process SCC's in the SSA
- graph.
- Execution of this algorithm relies on the fact that the SCC's are
- popped off the stack in topological order.
- Returns true if successful, false if we stopped processing SCC's due
- to resource constraints. */
-
-static bool
-DFS (tree name)
-{
- VEC(ssa_op_iter, heap) *itervec = NULL;
- VEC(tree, heap) *namevec = NULL;
- use_operand_p usep = NULL;
- gimple defstmt;
- tree use;
- ssa_op_iter iter;
-
-start_over:
- /* SCC info */
- VN_INFO (name)->dfsnum = next_dfs_num++;
- VN_INFO (name)->visited = true;
- VN_INFO (name)->low = VN_INFO (name)->dfsnum;
-
- VEC_safe_push (tree, heap, sccstack, name);
- VN_INFO (name)->on_sccstack = true;
- defstmt = SSA_NAME_DEF_STMT (name);
-
- /* Recursively DFS on our operands, looking for SCC's. */
- if (!gimple_nop_p (defstmt))
- {
- /* Push a new iterator. */
- if (gimple_code (defstmt) == GIMPLE_PHI)
- usep = op_iter_init_phiuse (&iter, defstmt, SSA_OP_ALL_USES);
- else
- usep = op_iter_init_use (&iter, defstmt, SSA_OP_ALL_USES);
- }
- else
- clear_and_done_ssa_iter (&iter);
-
- while (1)
- {
- /* If we are done processing uses of a name, go up the stack
- of iterators and process SCCs as we found them. */
- if (op_iter_done (&iter))
- {
- /* See if we found an SCC. */
- if (VN_INFO (name)->low == VN_INFO (name)->dfsnum)
- if (!extract_and_process_scc_for_name (name))
- {
- VEC_free (tree, heap, namevec);
- VEC_free (ssa_op_iter, heap, itervec);
- return false;
- }
-
- /* Check if we are done. */
- if (VEC_empty (tree, namevec))
- {
- VEC_free (tree, heap, namevec);
- VEC_free (ssa_op_iter, heap, itervec);
- return true;
- }
-
- /* Restore the last use walker and continue walking there. */
- use = name;
- name = VEC_pop (tree, namevec);
- memcpy (&iter, VEC_last (ssa_op_iter, itervec),
- sizeof (ssa_op_iter));
- VEC_pop (ssa_op_iter, itervec);
- goto continue_walking;
- }
-
- use = USE_FROM_PTR (usep);
-
- /* Since we handle phi nodes, we will sometimes get
- invariants in the use expression. */
- if (TREE_CODE (use) == SSA_NAME)
- {
- if (! (VN_INFO (use)->visited))
- {
- /* Recurse by pushing the current use walking state on
- the stack and starting over. */
- VEC_safe_push(ssa_op_iter, heap, itervec, &iter);
- VEC_safe_push(tree, heap, namevec, name);
- name = use;
- goto start_over;
-
-continue_walking:
- VN_INFO (name)->low = MIN (VN_INFO (name)->low,
- VN_INFO (use)->low);
- }
- if (VN_INFO (use)->dfsnum < VN_INFO (name)->dfsnum
- && VN_INFO (use)->on_sccstack)
- {
- VN_INFO (name)->low = MIN (VN_INFO (use)->dfsnum,
- VN_INFO (name)->low);
- }
- }
-
- usep = op_iter_next_use (&iter);
- }
-}
-
-/* Allocate a value number table. */
-
-static void
-allocate_vn_table (vn_tables_t table)
-{
- table->phis = htab_create (23, vn_phi_hash, vn_phi_eq, free_phi);
- table->nary = htab_create (23, vn_nary_op_hash, vn_nary_op_eq, NULL);
- table->references = htab_create (23, vn_reference_hash, vn_reference_eq,
- free_reference);
-
- gcc_obstack_init (&table->nary_obstack);
- table->phis_pool = create_alloc_pool ("VN phis",
- sizeof (struct vn_phi_s),
- 30);
- table->references_pool = create_alloc_pool ("VN references",
- sizeof (struct vn_reference_s),
- 30);
-}
-
-/* Free a value number table. */
-
-static void
-free_vn_table (vn_tables_t table)
-{
- htab_delete (table->phis);
- htab_delete (table->nary);
- htab_delete (table->references);
- obstack_free (&table->nary_obstack, NULL);
- free_alloc_pool (table->phis_pool);
- free_alloc_pool (table->references_pool);
-}
-
-static void
-init_scc_vn (void)
-{
- size_t i;
- int j;
- int *rpo_numbers_temp;
-
- calculate_dominance_info (CDI_DOMINATORS);
- sccstack = NULL;
- constant_to_value_id = htab_create (23, vn_constant_hash, vn_constant_eq,
- free);
-
- constant_value_ids = BITMAP_ALLOC (NULL);
-
- next_dfs_num = 1;
- next_value_id = 1;
-
- vn_ssa_aux_table = VEC_alloc (vn_ssa_aux_t, heap, num_ssa_names + 1);
- /* VEC_alloc doesn't actually grow it to the right size, it just
- preallocates the space to do so. */
- VEC_safe_grow_cleared (vn_ssa_aux_t, heap, vn_ssa_aux_table, num_ssa_names + 1);
- gcc_obstack_init (&vn_ssa_aux_obstack);
-
- shared_lookup_phiargs = NULL;
- shared_lookup_vops = NULL;
- shared_lookup_references = NULL;
- rpo_numbers = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
- rpo_numbers_temp = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
- pre_and_rev_post_order_compute (NULL, rpo_numbers_temp, false);
-
- /* RPO numbers is an array of rpo ordering, rpo[i] = bb means that
- the i'th block in RPO order is bb. We want to map bb's to RPO
- numbers, so we need to rearrange this array. */
- for (j = 0; j < n_basic_blocks - NUM_FIXED_BLOCKS; j++)
- rpo_numbers[rpo_numbers_temp[j]] = j;
-
- XDELETE (rpo_numbers_temp);
-
- VN_TOP = create_tmp_var_raw (void_type_node, "vn_top");
-
- /* Create the VN_INFO structures, and initialize value numbers to
- TOP. */
- for (i = 0; i < num_ssa_names; i++)
- {
- tree name = ssa_name (i);
- if (name)
- {
- VN_INFO_GET (name)->valnum = VN_TOP;
- VN_INFO (name)->expr = NULL_TREE;
- VN_INFO (name)->value_id = 0;
- }
- }
-
- renumber_gimple_stmt_uids ();
-
- /* Create the valid and optimistic value numbering tables. */
- valid_info = XCNEW (struct vn_tables_s);
- allocate_vn_table (valid_info);
- optimistic_info = XCNEW (struct vn_tables_s);
- allocate_vn_table (optimistic_info);
-}
-
-void
-free_scc_vn (void)
-{
- size_t i;
-
- htab_delete (constant_to_value_id);
- BITMAP_FREE (constant_value_ids);
- VEC_free (tree, heap, shared_lookup_phiargs);
- VEC_free (tree, gc, shared_lookup_vops);
- VEC_free (vn_reference_op_s, heap, shared_lookup_references);
- XDELETEVEC (rpo_numbers);
-
- for (i = 0; i < num_ssa_names; i++)
- {
- tree name = ssa_name (i);
- if (name
- && VN_INFO (name)->needs_insertion)
- release_ssa_name (name);
- }
- obstack_free (&vn_ssa_aux_obstack, NULL);
- VEC_free (vn_ssa_aux_t, heap, vn_ssa_aux_table);
-
- VEC_free (tree, heap, sccstack);
- free_vn_table (valid_info);
- XDELETE (valid_info);
- free_vn_table (optimistic_info);
- XDELETE (optimistic_info);
-}
-
-/* Set the value ids in the valid hash tables. */
-
-static void
-set_hashtable_value_ids (void)
-{
- htab_iterator hi;
- vn_nary_op_t vno;
- vn_reference_t vr;
- vn_phi_t vp;
-
- /* Now set the value ids of the things we had put in the hash
- table. */
-
- FOR_EACH_HTAB_ELEMENT (valid_info->nary,
- vno, vn_nary_op_t, hi)
- {
- if (vno->result)
- {
- if (TREE_CODE (vno->result) == SSA_NAME)
- vno->value_id = VN_INFO (vno->result)->value_id;
- else if (is_gimple_min_invariant (vno->result))
- vno->value_id = get_or_alloc_constant_value_id (vno->result);
- }
- }
-
- FOR_EACH_HTAB_ELEMENT (valid_info->phis,
- vp, vn_phi_t, hi)
- {
- if (vp->result)
- {
- if (TREE_CODE (vp->result) == SSA_NAME)
- vp->value_id = VN_INFO (vp->result)->value_id;
- else if (is_gimple_min_invariant (vp->result))
- vp->value_id = get_or_alloc_constant_value_id (vp->result);
- }
- }
-
- FOR_EACH_HTAB_ELEMENT (valid_info->references,
- vr, vn_reference_t, hi)
- {
- if (vr->result)
- {
- if (TREE_CODE (vr->result) == SSA_NAME)
- vr->value_id = VN_INFO (vr->result)->value_id;
- else if (is_gimple_min_invariant (vr->result))
- vr->value_id = get_or_alloc_constant_value_id (vr->result);
- }
- }
-}
-
-/* Do SCCVN. Returns true if it finished, false if we bailed out
- due to resource constraints. */
-
-bool
-run_scc_vn (bool may_insert_arg)
-{
- size_t i;
- tree param;
- bool changed = true;
-
- may_insert = may_insert_arg;
-
- init_scc_vn ();
- current_info = valid_info;
-
- for (param = DECL_ARGUMENTS (current_function_decl);
- param;
- param = TREE_CHAIN (param))
- {
- if (gimple_default_def (cfun, param) != NULL)
- {
- tree def = gimple_default_def (cfun, param);
- SSA_VAL (def) = def;
- }
- }
-
- for (i = 1; i < num_ssa_names; ++i)
- {
- tree name = ssa_name (i);
- if (name
- && VN_INFO (name)->visited == false
- && !has_zero_uses (name))
- if (!DFS (name))
- {
- free_scc_vn ();
- may_insert = false;
- return false;
- }
- }
-
- /* Initialize the value ids. */
-
- for (i = 1; i < num_ssa_names; ++i)
- {
- tree name = ssa_name (i);
- vn_ssa_aux_t info;
- if (!name)
- continue;
- info = VN_INFO (name);
- if (info->valnum == name)
- info->value_id = get_next_value_id ();
- else if (is_gimple_min_invariant (info->valnum))
- info->value_id = get_or_alloc_constant_value_id (info->valnum);
- }
-
- /* Propagate until they stop changing. */
- while (changed)
- {
- changed = false;
- for (i = 1; i < num_ssa_names; ++i)
- {
- tree name = ssa_name (i);
- vn_ssa_aux_t info;
- if (!name)
- continue;
- info = VN_INFO (name);
- if (TREE_CODE (info->valnum) == SSA_NAME
- && info->valnum != name
- && info->value_id != VN_INFO (info->valnum)->value_id)
- {
- changed = true;
- info->value_id = VN_INFO (info->valnum)->value_id;
- }
- }
- }
-
- set_hashtable_value_ids ();
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Value numbers:\n");
- for (i = 0; i < num_ssa_names; i++)
- {
- tree name = ssa_name (i);
- if (name
- && VN_INFO (name)->visited
- && SSA_VAL (name) != name)
- {
- print_generic_expr (dump_file, name, 0);
- fprintf (dump_file, " = ");
- print_generic_expr (dump_file, SSA_VAL (name), 0);
- fprintf (dump_file, "\n");
- }
- }
- }
-
- may_insert = false;
- return true;
-}
-
-/* Return the maximum value id we have ever seen. */
-
-unsigned int
-get_max_value_id (void)
-{
- return next_value_id;
-}
-
-/* Return the next unique value id. */
-
-unsigned int
-get_next_value_id (void)
-{
- return next_value_id++;
-}
-
-
-/* Compare two expressions E1 and E2 and return true if they are equal. */
-
-bool
-expressions_equal_p (tree e1, tree e2)
-{
- /* The obvious case. */
- if (e1 == e2)
- return true;
-
- /* If only one of them is null, they cannot be equal. */
- if (!e1 || !e2)
- return false;
-
- /* Recurse on elements of lists. */
- if (TREE_CODE (e1) == TREE_LIST && TREE_CODE (e2) == TREE_LIST)
- {
- tree lop1 = e1;
- tree lop2 = e2;
- for (lop1 = e1, lop2 = e2;
- lop1 || lop2;
- lop1 = TREE_CHAIN (lop1), lop2 = TREE_CHAIN (lop2))
- {
- if (!lop1 || !lop2)
- return false;
- if (!expressions_equal_p (TREE_VALUE (lop1), TREE_VALUE (lop2)))
- return false;
- }
- return true;
- }
-
- /* Now perform the actual comparison. */
- if (TREE_CODE (e1) == TREE_CODE (e2)
- && operand_equal_p (e1, e2, OEP_PURE_SAME))
- return true;
-
- return false;
-}
-
-/* Sort the VUSE array so that we can do equality comparisons
- quicker on two vuse vecs. */
-
-void
-sort_vuses (VEC (tree,gc) *vuses)
-{
- if (VEC_length (tree, vuses) > 1)
- qsort (VEC_address (tree, vuses),
- VEC_length (tree, vuses),
- sizeof (tree),
- operand_build_cmp);
-}
-
-/* Sort the VUSE array so that we can do equality comparisons
- quicker on two vuse vecs. */
-
-void
-sort_vuses_heap (VEC (tree,heap) *vuses)
-{
- if (VEC_length (tree, vuses) > 1)
- qsort (VEC_address (tree, vuses),
- VEC_length (tree, vuses),
- sizeof (tree),
- operand_build_cmp);
-}
-
-
-/* Return true if the nary operation NARY may trap. This is a copy
- of stmt_could_throw_1_p adjusted to the SCCVN IL. */
-
-bool
-vn_nary_may_trap (vn_nary_op_t nary)
-{
- tree type;
- tree rhs2;
- bool honor_nans = false;
- bool honor_snans = false;
- bool fp_operation = false;
- bool honor_trapv = false;
- bool handled, ret;
- unsigned i;
-
- if (TREE_CODE_CLASS (nary->opcode) == tcc_comparison
- || TREE_CODE_CLASS (nary->opcode) == tcc_unary
- || TREE_CODE_CLASS (nary->opcode) == tcc_binary)
- {
- type = nary->type;
- fp_operation = FLOAT_TYPE_P (type);
- if (fp_operation)
- {
- honor_nans = flag_trapping_math && !flag_finite_math_only;
- honor_snans = flag_signaling_nans != 0;
- }
- else if (INTEGRAL_TYPE_P (type)
- && TYPE_OVERFLOW_TRAPS (type))
- honor_trapv = true;
- }
- rhs2 = nary->op[1];
- ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
- honor_trapv,
- honor_nans, honor_snans, rhs2,
- &handled);
- if (handled
- && ret)
- return true;
-
- for (i = 0; i < nary->length; ++i)
- if (tree_could_trap_p (nary->op[i]))
- return true;
-
- return false;
-}
diff --git a/gcc-4.4.0/gcc/vertexArray b/gcc-4.4.0/gcc/vertexArray
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/vertexArray
+++ /dev/null
diff --git a/gcc-4.4.0/gcc/void b/gcc-4.4.0/gcc/void
deleted file mode 100644
index e69de29..0000000
--- a/gcc-4.4.0/gcc/void
+++ /dev/null