/* SCC value numbering for trees
|
/* SCC value numbering for trees
|
Copyright (C) 2006, 2007, 2008, 2009, 2010
|
Copyright (C) 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Daniel Berlin <dan@dberlin.org>
|
Contributed by Daniel Berlin <dan@dberlin.org>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "fibheap.h"
|
#include "fibheap.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "real.h"
|
#include "real.h"
|
#include "alloc-pool.h"
|
#include "alloc-pool.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "bitmap.h"
|
#include "bitmap.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "params.h"
|
#include "params.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-sccvn.h"
|
#include "tree-ssa-sccvn.h"
|
|
|
/* This algorithm is based on the SCC algorithm presented by Keith
|
/* This algorithm is based on the SCC algorithm presented by Keith
|
Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
|
Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
|
(http://citeseer.ist.psu.edu/41805.html). In
|
(http://citeseer.ist.psu.edu/41805.html). In
|
straight line code, it is equivalent to a regular hash based value
|
straight line code, it is equivalent to a regular hash based value
|
numbering that is performed in reverse postorder.
|
numbering that is performed in reverse postorder.
|
|
|
For code with cycles, there are two alternatives, both of which
|
For code with cycles, there are two alternatives, both of which
|
require keeping the hashtables separate from the actual list of
|
require keeping the hashtables separate from the actual list of
|
value numbers for SSA names.
|
value numbers for SSA names.
|
|
|
1. Iterate value numbering in an RPO walk of the blocks, removing
|
1. Iterate value numbering in an RPO walk of the blocks, removing
|
all the entries from the hashtable after each iteration (but
|
all the entries from the hashtable after each iteration (but
|
keeping the SSA name->value number mapping between iterations).
|
keeping the SSA name->value number mapping between iterations).
|
Iterate until it does not change.
|
Iterate until it does not change.
|
|
|
2. Perform value numbering as part of an SCC walk on the SSA graph,
|
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
|
iterating only the cycles in the SSA graph until they do not change
|
(using a separate, optimistic hashtable for value numbering the SCC
|
(using a separate, optimistic hashtable for value numbering the SCC
|
operands).
|
operands).
|
|
|
The second is not just faster in practice (because most SSA graph
|
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
|
cycles do not involve all the variables in the graph), it also has
|
some nice properties.
|
some nice properties.
|
|
|
One of these nice properties is that when we pop an SCC off the
|
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
|
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
|
*outside of that SCC*, so we do not need to do anything special to
|
ensure they have value numbers.
|
ensure they have value numbers.
|
|
|
Another nice property is that the SCC walk is done as part of a DFS
|
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
|
of the SSA graph, which makes it easy to perform combining and
|
simplifying operations at the same time.
|
simplifying operations at the same time.
|
|
|
The code below is deliberately written in a way that makes it easy
|
The code below is deliberately written in a way that makes it easy
|
to separate the SCC walk from the other work it does.
|
to separate the SCC walk from the other work it does.
|
|
|
In order to propagate constants through the code, we track which
|
In order to propagate constants through the code, we track which
|
expressions contain constants, and use those while folding. In
|
expressions contain constants, and use those while folding. In
|
theory, we could also track expressions whose value numbers are
|
theory, we could also track expressions whose value numbers are
|
replaced, in case we end up folding based on expression
|
replaced, in case we end up folding based on expression
|
identities.
|
identities.
|
|
|
In order to value number memory, we assign value numbers to vuses.
|
In order to value number memory, we assign value numbers to vuses.
|
This enables us to note that, for example, stores to the same
|
This enables us to note that, for example, stores to the same
|
address of the same value from the same starting memory states are
|
address of the same value from the same starting memory states are
|
equivalent.
|
equivalent.
|
TODO:
|
TODO:
|
|
|
1. We can iterate only the changing portions of the SCC's, but
|
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.
|
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
|
2. If you differentiate between phi nodes for loops and phi nodes
|
for if-then-else, you can properly consider phi nodes in different
|
for if-then-else, you can properly consider phi nodes in different
|
blocks for equivalence.
|
blocks for equivalence.
|
3. We could value number vuses in more cases, particularly, whole
|
3. We could value number vuses in more cases, particularly, whole
|
structure copies.
|
structure copies.
|
*/
|
*/
|
|
|
/* The set of hashtables and alloc_pool's for their items. */
|
/* The set of hashtables and alloc_pool's for their items. */
|
|
|
typedef struct vn_tables_s
|
typedef struct vn_tables_s
|
{
|
{
|
htab_t nary;
|
htab_t nary;
|
htab_t phis;
|
htab_t phis;
|
htab_t references;
|
htab_t references;
|
struct obstack nary_obstack;
|
struct obstack nary_obstack;
|
alloc_pool phis_pool;
|
alloc_pool phis_pool;
|
alloc_pool references_pool;
|
alloc_pool references_pool;
|
} *vn_tables_t;
|
} *vn_tables_t;
|
|
|
static htab_t constant_to_value_id;
|
static htab_t constant_to_value_id;
|
static bitmap constant_value_ids;
|
static bitmap constant_value_ids;
|
|
|
|
|
/* Valid hashtables storing information we have proven to be
|
/* Valid hashtables storing information we have proven to be
|
correct. */
|
correct. */
|
|
|
static vn_tables_t valid_info;
|
static vn_tables_t valid_info;
|
|
|
/* Optimistic hashtables storing information we are making assumptions about
|
/* Optimistic hashtables storing information we are making assumptions about
|
during iterations. */
|
during iterations. */
|
|
|
static vn_tables_t optimistic_info;
|
static vn_tables_t optimistic_info;
|
|
|
/* Pointer to the set of hashtables that is currently being used.
|
/* Pointer to the set of hashtables that is currently being used.
|
Should always point to either the optimistic_info, or the
|
Should always point to either the optimistic_info, or the
|
valid_info. */
|
valid_info. */
|
|
|
static vn_tables_t current_info;
|
static vn_tables_t current_info;
|
|
|
|
|
/* Reverse post order index for each basic block. */
|
/* Reverse post order index for each basic block. */
|
|
|
static int *rpo_numbers;
|
static int *rpo_numbers;
|
|
|
#define SSA_VAL(x) (VN_INFO ((x))->valnum)
|
#define SSA_VAL(x) (VN_INFO ((x))->valnum)
|
|
|
/* This represents the top of the VN lattice, which is the universal
|
/* This represents the top of the VN lattice, which is the universal
|
value. */
|
value. */
|
|
|
tree VN_TOP;
|
tree VN_TOP;
|
|
|
/* Unique counter for our value ids. */
|
/* Unique counter for our value ids. */
|
|
|
static unsigned int next_value_id;
|
static unsigned int next_value_id;
|
|
|
/* Next DFS number and the stack for strongly connected component
|
/* Next DFS number and the stack for strongly connected component
|
detection. */
|
detection. */
|
|
|
static unsigned int next_dfs_num;
|
static unsigned int next_dfs_num;
|
static VEC (tree, heap) *sccstack;
|
static VEC (tree, heap) *sccstack;
|
|
|
static bool may_insert;
|
static bool may_insert;
|
|
|
|
|
DEF_VEC_P(vn_ssa_aux_t);
|
DEF_VEC_P(vn_ssa_aux_t);
|
DEF_VEC_ALLOC_P(vn_ssa_aux_t, heap);
|
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
|
/* 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
|
are allocated on an obstack for locality reasons, and to free them
|
without looping over the VEC. */
|
without looping over the VEC. */
|
|
|
static VEC (vn_ssa_aux_t, heap) *vn_ssa_aux_table;
|
static VEC (vn_ssa_aux_t, heap) *vn_ssa_aux_table;
|
static struct obstack vn_ssa_aux_obstack;
|
static struct obstack vn_ssa_aux_obstack;
|
|
|
/* Return the value numbering information for a given SSA name. */
|
/* Return the value numbering information for a given SSA name. */
|
|
|
vn_ssa_aux_t
|
vn_ssa_aux_t
|
VN_INFO (tree name)
|
VN_INFO (tree name)
|
{
|
{
|
vn_ssa_aux_t res = VEC_index (vn_ssa_aux_t, vn_ssa_aux_table,
|
vn_ssa_aux_t res = VEC_index (vn_ssa_aux_t, vn_ssa_aux_table,
|
SSA_NAME_VERSION (name));
|
SSA_NAME_VERSION (name));
|
gcc_assert (res);
|
gcc_assert (res);
|
return res;
|
return res;
|
}
|
}
|
|
|
/* Set the value numbering info for a given SSA name to a given
|
/* Set the value numbering info for a given SSA name to a given
|
value. */
|
value. */
|
|
|
static inline void
|
static inline void
|
VN_INFO_SET (tree name, vn_ssa_aux_t value)
|
VN_INFO_SET (tree name, vn_ssa_aux_t value)
|
{
|
{
|
VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
|
VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
|
SSA_NAME_VERSION (name), value);
|
SSA_NAME_VERSION (name), value);
|
}
|
}
|
|
|
/* Initialize the value numbering info for a given SSA name.
|
/* Initialize the value numbering info for a given SSA name.
|
This should be called just once for every SSA name. */
|
This should be called just once for every SSA name. */
|
|
|
vn_ssa_aux_t
|
vn_ssa_aux_t
|
VN_INFO_GET (tree name)
|
VN_INFO_GET (tree name)
|
{
|
{
|
vn_ssa_aux_t newinfo;
|
vn_ssa_aux_t newinfo;
|
|
|
newinfo = XOBNEW (&vn_ssa_aux_obstack, struct vn_ssa_aux);
|
newinfo = XOBNEW (&vn_ssa_aux_obstack, struct vn_ssa_aux);
|
memset (newinfo, 0, sizeof (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))
|
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,
|
VEC_safe_grow (vn_ssa_aux_t, heap, vn_ssa_aux_table,
|
SSA_NAME_VERSION (name) + 1);
|
SSA_NAME_VERSION (name) + 1);
|
VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
|
VEC_replace (vn_ssa_aux_t, vn_ssa_aux_table,
|
SSA_NAME_VERSION (name), newinfo);
|
SSA_NAME_VERSION (name), newinfo);
|
return newinfo;
|
return newinfo;
|
}
|
}
|
|
|
|
|
/* Get the representative expression for the SSA_NAME NAME. Returns
|
/* Get the representative expression for the SSA_NAME NAME. Returns
|
the representative SSA_NAME if there is no expression associated with it. */
|
the representative SSA_NAME if there is no expression associated with it. */
|
|
|
tree
|
tree
|
vn_get_expr_for (tree name)
|
vn_get_expr_for (tree name)
|
{
|
{
|
vn_ssa_aux_t vn = VN_INFO (name);
|
vn_ssa_aux_t vn = VN_INFO (name);
|
gimple def_stmt;
|
gimple def_stmt;
|
tree expr = NULL_TREE;
|
tree expr = NULL_TREE;
|
|
|
if (vn->valnum == VN_TOP)
|
if (vn->valnum == VN_TOP)
|
return name;
|
return name;
|
|
|
/* If the value-number is a constant it is the representative
|
/* If the value-number is a constant it is the representative
|
expression. */
|
expression. */
|
if (TREE_CODE (vn->valnum) != SSA_NAME)
|
if (TREE_CODE (vn->valnum) != SSA_NAME)
|
return vn->valnum;
|
return vn->valnum;
|
|
|
/* Get to the information of the value of this SSA_NAME. */
|
/* Get to the information of the value of this SSA_NAME. */
|
vn = VN_INFO (vn->valnum);
|
vn = VN_INFO (vn->valnum);
|
|
|
/* If the value-number is a constant it is the representative
|
/* If the value-number is a constant it is the representative
|
expression. */
|
expression. */
|
if (TREE_CODE (vn->valnum) != SSA_NAME)
|
if (TREE_CODE (vn->valnum) != SSA_NAME)
|
return vn->valnum;
|
return vn->valnum;
|
|
|
/* Else if we have an expression, return it. */
|
/* Else if we have an expression, return it. */
|
if (vn->expr != NULL_TREE)
|
if (vn->expr != NULL_TREE)
|
return vn->expr;
|
return vn->expr;
|
|
|
/* Otherwise use the defining statement to build the expression. */
|
/* Otherwise use the defining statement to build the expression. */
|
def_stmt = SSA_NAME_DEF_STMT (vn->valnum);
|
def_stmt = SSA_NAME_DEF_STMT (vn->valnum);
|
|
|
/* If the value number is a default-definition or a PHI result
|
/* If the value number is a default-definition or a PHI result
|
use it directly. */
|
use it directly. */
|
if (gimple_nop_p (def_stmt)
|
if (gimple_nop_p (def_stmt)
|
|| gimple_code (def_stmt) == GIMPLE_PHI)
|
|| gimple_code (def_stmt) == GIMPLE_PHI)
|
return vn->valnum;
|
return vn->valnum;
|
|
|
if (!is_gimple_assign (def_stmt))
|
if (!is_gimple_assign (def_stmt))
|
return vn->valnum;
|
return vn->valnum;
|
|
|
/* FIXME tuples. This is incomplete and likely will miss some
|
/* FIXME tuples. This is incomplete and likely will miss some
|
simplifications. */
|
simplifications. */
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)))
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)))
|
{
|
{
|
case tcc_reference:
|
case tcc_reference:
|
if ((gimple_assign_rhs_code (def_stmt) == VIEW_CONVERT_EXPR
|
if ((gimple_assign_rhs_code (def_stmt) == VIEW_CONVERT_EXPR
|
|| gimple_assign_rhs_code (def_stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (def_stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (def_stmt) == IMAGPART_EXPR)
|
|| gimple_assign_rhs_code (def_stmt) == IMAGPART_EXPR)
|
&& TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
|
&& TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
|
expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
|
expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
|
gimple_expr_type (def_stmt),
|
gimple_expr_type (def_stmt),
|
TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0));
|
TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0));
|
break;
|
break;
|
|
|
case tcc_unary:
|
case tcc_unary:
|
expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
|
expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
|
gimple_expr_type (def_stmt),
|
gimple_expr_type (def_stmt),
|
gimple_assign_rhs1 (def_stmt));
|
gimple_assign_rhs1 (def_stmt));
|
break;
|
break;
|
|
|
case tcc_binary:
|
case tcc_binary:
|
expr = fold_build2 (gimple_assign_rhs_code (def_stmt),
|
expr = fold_build2 (gimple_assign_rhs_code (def_stmt),
|
gimple_expr_type (def_stmt),
|
gimple_expr_type (def_stmt),
|
gimple_assign_rhs1 (def_stmt),
|
gimple_assign_rhs1 (def_stmt),
|
gimple_assign_rhs2 (def_stmt));
|
gimple_assign_rhs2 (def_stmt));
|
break;
|
break;
|
|
|
default:;
|
default:;
|
}
|
}
|
if (expr == NULL_TREE)
|
if (expr == NULL_TREE)
|
return vn->valnum;
|
return vn->valnum;
|
|
|
/* Cache the expression. */
|
/* Cache the expression. */
|
vn->expr = expr;
|
vn->expr = expr;
|
|
|
return expr;
|
return expr;
|
}
|
}
|
|
|
|
|
/* Free a phi operation structure VP. */
|
/* Free a phi operation structure VP. */
|
|
|
static void
|
static void
|
free_phi (void *vp)
|
free_phi (void *vp)
|
{
|
{
|
vn_phi_t phi = (vn_phi_t) vp;
|
vn_phi_t phi = (vn_phi_t) vp;
|
VEC_free (tree, heap, phi->phiargs);
|
VEC_free (tree, heap, phi->phiargs);
|
}
|
}
|
|
|
/* Free a reference operation structure VP. */
|
/* Free a reference operation structure VP. */
|
|
|
static void
|
static void
|
free_reference (void *vp)
|
free_reference (void *vp)
|
{
|
{
|
vn_reference_t vr = (vn_reference_t) vp;
|
vn_reference_t vr = (vn_reference_t) vp;
|
VEC_free (vn_reference_op_s, heap, vr->operands);
|
VEC_free (vn_reference_op_s, heap, vr->operands);
|
}
|
}
|
|
|
/* Hash table equality function for vn_constant_t. */
|
/* Hash table equality function for vn_constant_t. */
|
|
|
static int
|
static int
|
vn_constant_eq (const void *p1, const void *p2)
|
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 *vc1 = (const struct vn_constant_s *) p1;
|
const struct vn_constant_s *vc2 = (const struct vn_constant_s *) p2;
|
const struct vn_constant_s *vc2 = (const struct vn_constant_s *) p2;
|
|
|
if (vc1->hashcode != vc2->hashcode)
|
if (vc1->hashcode != vc2->hashcode)
|
return false;
|
return false;
|
|
|
return vn_constant_eq_with_type (vc1->constant, vc2->constant);
|
return vn_constant_eq_with_type (vc1->constant, vc2->constant);
|
}
|
}
|
|
|
/* Hash table hash function for vn_constant_t. */
|
/* Hash table hash function for vn_constant_t. */
|
|
|
static hashval_t
|
static hashval_t
|
vn_constant_hash (const void *p1)
|
vn_constant_hash (const void *p1)
|
{
|
{
|
const struct vn_constant_s *vc1 = (const struct vn_constant_s *) p1;
|
const struct vn_constant_s *vc1 = (const struct vn_constant_s *) p1;
|
return vc1->hashcode;
|
return vc1->hashcode;
|
}
|
}
|
|
|
/* Lookup a value id for CONSTANT and return it. If it does not
|
/* Lookup a value id for CONSTANT and return it. If it does not
|
exist returns 0. */
|
exist returns 0. */
|
|
|
unsigned int
|
unsigned int
|
get_constant_value_id (tree constant)
|
get_constant_value_id (tree constant)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_constant_s vc;
|
struct vn_constant_s vc;
|
|
|
vc.hashcode = vn_hash_constant_with_type (constant);
|
vc.hashcode = vn_hash_constant_with_type (constant);
|
vc.constant = constant;
|
vc.constant = constant;
|
slot = htab_find_slot_with_hash (constant_to_value_id, &vc,
|
slot = htab_find_slot_with_hash (constant_to_value_id, &vc,
|
vc.hashcode, NO_INSERT);
|
vc.hashcode, NO_INSERT);
|
if (slot)
|
if (slot)
|
return ((vn_constant_t)*slot)->value_id;
|
return ((vn_constant_t)*slot)->value_id;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Lookup a value id for CONSTANT, and if it does not exist, create a
|
/* 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. */
|
new one and return it. If it does exist, return it. */
|
|
|
unsigned int
|
unsigned int
|
get_or_alloc_constant_value_id (tree constant)
|
get_or_alloc_constant_value_id (tree constant)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_constant_s vc;
|
struct vn_constant_s vc;
|
vn_constant_t vcp;
|
vn_constant_t vcp;
|
|
|
vc.hashcode = vn_hash_constant_with_type (constant);
|
vc.hashcode = vn_hash_constant_with_type (constant);
|
vc.constant = constant;
|
vc.constant = constant;
|
slot = htab_find_slot_with_hash (constant_to_value_id, &vc,
|
slot = htab_find_slot_with_hash (constant_to_value_id, &vc,
|
vc.hashcode, INSERT);
|
vc.hashcode, INSERT);
|
if (*slot)
|
if (*slot)
|
return ((vn_constant_t)*slot)->value_id;
|
return ((vn_constant_t)*slot)->value_id;
|
|
|
vcp = XNEW (struct vn_constant_s);
|
vcp = XNEW (struct vn_constant_s);
|
vcp->hashcode = vc.hashcode;
|
vcp->hashcode = vc.hashcode;
|
vcp->constant = constant;
|
vcp->constant = constant;
|
vcp->value_id = get_next_value_id ();
|
vcp->value_id = get_next_value_id ();
|
*slot = (void *) vcp;
|
*slot = (void *) vcp;
|
bitmap_set_bit (constant_value_ids, vcp->value_id);
|
bitmap_set_bit (constant_value_ids, vcp->value_id);
|
return vcp->value_id;
|
return vcp->value_id;
|
}
|
}
|
|
|
/* Return true if V is a value id for a constant. */
|
/* Return true if V is a value id for a constant. */
|
|
|
bool
|
bool
|
value_id_constant_p (unsigned int v)
|
value_id_constant_p (unsigned int v)
|
{
|
{
|
return bitmap_bit_p (constant_value_ids, v);
|
return bitmap_bit_p (constant_value_ids, v);
|
}
|
}
|
|
|
/* Compare two reference operands P1 and P2 for equality. Return true if
|
/* Compare two reference operands P1 and P2 for equality. Return true if
|
they are equal, and false otherwise. */
|
they are equal, and false otherwise. */
|
|
|
static int
|
static int
|
vn_reference_op_eq (const void *p1, const void *p2)
|
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 vro1 = (const_vn_reference_op_t) p1;
|
const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
|
const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
|
|
|
return vro1->opcode == vro2->opcode
|
return vro1->opcode == vro2->opcode
|
&& types_compatible_p (vro1->type, vro2->type)
|
&& types_compatible_p (vro1->type, vro2->type)
|
&& expressions_equal_p (vro1->op0, vro2->op0)
|
&& expressions_equal_p (vro1->op0, vro2->op0)
|
&& expressions_equal_p (vro1->op1, vro2->op1)
|
&& expressions_equal_p (vro1->op1, vro2->op1)
|
&& expressions_equal_p (vro1->op2, vro2->op2);
|
&& expressions_equal_p (vro1->op2, vro2->op2);
|
}
|
}
|
|
|
/* Compute the hash for a reference operand VRO1. */
|
/* Compute the hash for a reference operand VRO1. */
|
|
|
static hashval_t
|
static hashval_t
|
vn_reference_op_compute_hash (const vn_reference_op_t vro1, hashval_t result)
|
vn_reference_op_compute_hash (const vn_reference_op_t vro1, hashval_t result)
|
{
|
{
|
result = iterative_hash_hashval_t (vro1->opcode, result);
|
result = iterative_hash_hashval_t (vro1->opcode, result);
|
if (vro1->op0)
|
if (vro1->op0)
|
result = iterative_hash_expr (vro1->op0, result);
|
result = iterative_hash_expr (vro1->op0, result);
|
if (vro1->op1)
|
if (vro1->op1)
|
result = iterative_hash_expr (vro1->op1, result);
|
result = iterative_hash_expr (vro1->op1, result);
|
if (vro1->op2)
|
if (vro1->op2)
|
result = iterative_hash_expr (vro1->op2, result);
|
result = iterative_hash_expr (vro1->op2, result);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return the hashcode for a given reference operation P1. */
|
/* Return the hashcode for a given reference operation P1. */
|
|
|
static hashval_t
|
static hashval_t
|
vn_reference_hash (const void *p1)
|
vn_reference_hash (const void *p1)
|
{
|
{
|
const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
|
const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
|
return vr1->hashcode;
|
return vr1->hashcode;
|
}
|
}
|
|
|
/* Compute a hash for the reference operation VR1 and return it. */
|
/* Compute a hash for the reference operation VR1 and return it. */
|
|
|
hashval_t
|
hashval_t
|
vn_reference_compute_hash (const vn_reference_t vr1)
|
vn_reference_compute_hash (const vn_reference_t vr1)
|
{
|
{
|
hashval_t result = 0;
|
hashval_t result = 0;
|
int i;
|
int i;
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
|
|
for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
|
for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
|
result = vn_reference_op_compute_hash (vro, result);
|
result = vn_reference_op_compute_hash (vro, result);
|
if (vr1->vuse)
|
if (vr1->vuse)
|
result += SSA_NAME_VERSION (vr1->vuse);
|
result += SSA_NAME_VERSION (vr1->vuse);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return true if reference operations P1 and P2 are equivalent. This
|
/* Return true if reference operations P1 and P2 are equivalent. This
|
means they have the same set of operands and vuses. */
|
means they have the same set of operands and vuses. */
|
|
|
int
|
int
|
vn_reference_eq (const void *p1, const void *p2)
|
vn_reference_eq (const void *p1, const void *p2)
|
{
|
{
|
int i;
|
int i;
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
|
|
const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
|
const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
|
const_vn_reference_t const vr2 = (const_vn_reference_t) p2;
|
const_vn_reference_t const vr2 = (const_vn_reference_t) p2;
|
if (vr1->hashcode != vr2->hashcode)
|
if (vr1->hashcode != vr2->hashcode)
|
return false;
|
return false;
|
|
|
/* Early out if this is not a hash collision. */
|
/* Early out if this is not a hash collision. */
|
if (vr1->hashcode != vr2->hashcode)
|
if (vr1->hashcode != vr2->hashcode)
|
return false;
|
return false;
|
|
|
/* The VOP needs to be the same. */
|
/* The VOP needs to be the same. */
|
if (vr1->vuse != vr2->vuse)
|
if (vr1->vuse != vr2->vuse)
|
return false;
|
return false;
|
|
|
/* If the operands are the same we are done. */
|
/* If the operands are the same we are done. */
|
if (vr1->operands == vr2->operands)
|
if (vr1->operands == vr2->operands)
|
return true;
|
return true;
|
|
|
/* We require that address operands be canonicalized in a way that
|
/* We require that address operands be canonicalized in a way that
|
two memory references will have the same operands if they are
|
two memory references will have the same operands if they are
|
equivalent. */
|
equivalent. */
|
if (VEC_length (vn_reference_op_s, vr1->operands)
|
if (VEC_length (vn_reference_op_s, vr1->operands)
|
!= VEC_length (vn_reference_op_s, vr2->operands))
|
!= VEC_length (vn_reference_op_s, vr2->operands))
|
return false;
|
return false;
|
|
|
for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
|
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),
|
if (!vn_reference_op_eq (VEC_index (vn_reference_op_s, vr2->operands, i),
|
vro))
|
vro))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Copy the operations present in load/store REF into RESULT, a vector of
|
/* Copy the operations present in load/store REF into RESULT, a vector of
|
vn_reference_op_s's. */
|
vn_reference_op_s's. */
|
|
|
void
|
void
|
copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result)
|
copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result)
|
{
|
{
|
if (TREE_CODE (ref) == TARGET_MEM_REF)
|
if (TREE_CODE (ref) == TARGET_MEM_REF)
|
{
|
{
|
vn_reference_op_s temp;
|
vn_reference_op_s temp;
|
tree base;
|
tree base;
|
|
|
base = TMR_SYMBOL (ref) ? TMR_SYMBOL (ref) : TMR_BASE (ref);
|
base = TMR_SYMBOL (ref) ? TMR_SYMBOL (ref) : TMR_BASE (ref);
|
if (!base)
|
if (!base)
|
base = build_int_cst (ptr_type_node, 0);
|
base = build_int_cst (ptr_type_node, 0);
|
|
|
memset (&temp, 0, sizeof (temp));
|
memset (&temp, 0, sizeof (temp));
|
/* We do not care for spurious type qualifications. */
|
/* We do not care for spurious type qualifications. */
|
temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
|
temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
|
temp.opcode = TREE_CODE (ref);
|
temp.opcode = TREE_CODE (ref);
|
temp.op0 = TMR_INDEX (ref);
|
temp.op0 = TMR_INDEX (ref);
|
temp.op1 = TMR_STEP (ref);
|
temp.op1 = TMR_STEP (ref);
|
temp.op2 = TMR_OFFSET (ref);
|
temp.op2 = TMR_OFFSET (ref);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
|
|
memset (&temp, 0, sizeof (temp));
|
memset (&temp, 0, sizeof (temp));
|
temp.type = NULL_TREE;
|
temp.type = NULL_TREE;
|
temp.opcode = TREE_CODE (base);
|
temp.opcode = TREE_CODE (base);
|
temp.op0 = base;
|
temp.op0 = base;
|
temp.op1 = TMR_ORIGINAL (ref);
|
temp.op1 = TMR_ORIGINAL (ref);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
return;
|
return;
|
}
|
}
|
|
|
/* For non-calls, store the information that makes up the address. */
|
/* For non-calls, store the information that makes up the address. */
|
|
|
while (ref)
|
while (ref)
|
{
|
{
|
vn_reference_op_s temp;
|
vn_reference_op_s temp;
|
|
|
memset (&temp, 0, sizeof (temp));
|
memset (&temp, 0, sizeof (temp));
|
/* We do not care for spurious type qualifications. */
|
/* We do not care for spurious type qualifications. */
|
temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
|
temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
|
temp.opcode = TREE_CODE (ref);
|
temp.opcode = TREE_CODE (ref);
|
|
|
switch (temp.opcode)
|
switch (temp.opcode)
|
{
|
{
|
case ALIGN_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
/* The only operand is the address, which gets its own
|
/* The only operand is the address, which gets its own
|
vn_reference_op_s structure. */
|
vn_reference_op_s structure. */
|
break;
|
break;
|
case MISALIGNED_INDIRECT_REF:
|
case MISALIGNED_INDIRECT_REF:
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op0 = TREE_OPERAND (ref, 1);
|
break;
|
break;
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
/* Record bits and position. */
|
/* Record bits and position. */
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op1 = TREE_OPERAND (ref, 2);
|
temp.op1 = TREE_OPERAND (ref, 2);
|
break;
|
break;
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
/* The field decl is enough to unambiguously specify the field,
|
/* The field decl is enough to unambiguously specify the field,
|
a matching type is not necessary and a mismatching type
|
a matching type is not necessary and a mismatching type
|
is always a spurious difference. */
|
is always a spurious difference. */
|
temp.type = NULL_TREE;
|
temp.type = NULL_TREE;
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op1 = TREE_OPERAND (ref, 2);
|
temp.op1 = TREE_OPERAND (ref, 2);
|
/* If this is a reference to a union member, record the union
|
/* If this is a reference to a union member, record the union
|
member size as operand. Do so only if we are doing
|
member size as operand. Do so only if we are doing
|
expression insertion (during FRE), as PRE currently gets
|
expression insertion (during FRE), as PRE currently gets
|
confused with this. */
|
confused with this. */
|
if (may_insert
|
if (may_insert
|
&& temp.op1 == NULL_TREE
|
&& temp.op1 == NULL_TREE
|
&& TREE_CODE (DECL_CONTEXT (temp.op0)) == UNION_TYPE
|
&& TREE_CODE (DECL_CONTEXT (temp.op0)) == UNION_TYPE
|
&& integer_zerop (DECL_FIELD_OFFSET (temp.op0))
|
&& integer_zerop (DECL_FIELD_OFFSET (temp.op0))
|
&& integer_zerop (DECL_FIELD_BIT_OFFSET (temp.op0))
|
&& integer_zerop (DECL_FIELD_BIT_OFFSET (temp.op0))
|
&& host_integerp (DECL_SIZE (temp.op0), 0))
|
&& host_integerp (DECL_SIZE (temp.op0), 0))
|
temp.op0 = DECL_SIZE (temp.op0);
|
temp.op0 = DECL_SIZE (temp.op0);
|
break;
|
break;
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_REF:
|
case ARRAY_REF:
|
/* Record index as operand. */
|
/* Record index as operand. */
|
temp.op0 = TREE_OPERAND (ref, 1);
|
temp.op0 = TREE_OPERAND (ref, 1);
|
/* Always record lower bounds and element size. */
|
/* Always record lower bounds and element size. */
|
temp.op1 = array_ref_low_bound (ref);
|
temp.op1 = array_ref_low_bound (ref);
|
temp.op2 = array_ref_element_size (ref);
|
temp.op2 = array_ref_element_size (ref);
|
break;
|
break;
|
case STRING_CST:
|
case STRING_CST:
|
case INTEGER_CST:
|
case INTEGER_CST:
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
case VECTOR_CST:
|
case VECTOR_CST:
|
case REAL_CST:
|
case REAL_CST:
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
case SSA_NAME:
|
case SSA_NAME:
|
temp.op0 = ref;
|
temp.op0 = ref;
|
break;
|
break;
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
if (is_gimple_min_invariant (ref))
|
if (is_gimple_min_invariant (ref))
|
{
|
{
|
temp.op0 = ref;
|
temp.op0 = ref;
|
break;
|
break;
|
}
|
}
|
/* Fallthrough. */
|
/* Fallthrough. */
|
/* These are only interesting for their operands, their
|
/* These are only interesting for their operands, their
|
existence, and their type. They will never be the last
|
existence, and their type. They will never be the last
|
ref in the chain of references (IE they require an
|
ref in the chain of references (IE they require an
|
operand), so we don't have to put anything
|
operand), so we don't have to put anything
|
for op* as it will be handled by the iteration */
|
for op* as it will be handled by the iteration */
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
case VIEW_CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
|
|
if (REFERENCE_CLASS_P (ref)
|
if (REFERENCE_CLASS_P (ref)
|
|| (TREE_CODE (ref) == ADDR_EXPR
|
|| (TREE_CODE (ref) == ADDR_EXPR
|
&& !is_gimple_min_invariant (ref)))
|
&& !is_gimple_min_invariant (ref)))
|
ref = TREE_OPERAND (ref, 0);
|
ref = TREE_OPERAND (ref, 0);
|
else
|
else
|
ref = NULL_TREE;
|
ref = NULL_TREE;
|
}
|
}
|
}
|
}
|
|
|
/* Build a alias-oracle reference abstraction in *REF from the vn_reference
|
/* Build a alias-oracle reference abstraction in *REF from the vn_reference
|
operands in *OPS, the reference alias set SET and the reference type TYPE.
|
operands in *OPS, the reference alias set SET and the reference type TYPE.
|
Return true if something useful was produced. */
|
Return true if something useful was produced. */
|
|
|
bool
|
bool
|
ao_ref_init_from_vn_reference (ao_ref *ref,
|
ao_ref_init_from_vn_reference (ao_ref *ref,
|
alias_set_type set, tree type,
|
alias_set_type set, tree type,
|
VEC (vn_reference_op_s, heap) *ops)
|
VEC (vn_reference_op_s, heap) *ops)
|
{
|
{
|
vn_reference_op_t op;
|
vn_reference_op_t op;
|
unsigned i;
|
unsigned i;
|
tree base = NULL_TREE;
|
tree base = NULL_TREE;
|
tree *op0_p = &base;
|
tree *op0_p = &base;
|
HOST_WIDE_INT offset = 0;
|
HOST_WIDE_INT offset = 0;
|
HOST_WIDE_INT max_size;
|
HOST_WIDE_INT max_size;
|
HOST_WIDE_INT size = -1;
|
HOST_WIDE_INT size = -1;
|
tree size_tree = NULL_TREE;
|
tree size_tree = NULL_TREE;
|
|
|
/* First get the final access size from just the outermost expression. */
|
/* First get the final access size from just the outermost expression. */
|
op = VEC_index (vn_reference_op_s, ops, 0);
|
op = VEC_index (vn_reference_op_s, ops, 0);
|
if (op->opcode == COMPONENT_REF)
|
if (op->opcode == COMPONENT_REF)
|
{
|
{
|
if (TREE_CODE (op->op0) == INTEGER_CST)
|
if (TREE_CODE (op->op0) == INTEGER_CST)
|
size_tree = op->op0;
|
size_tree = op->op0;
|
else
|
else
|
size_tree = DECL_SIZE (op->op0);
|
size_tree = DECL_SIZE (op->op0);
|
}
|
}
|
else if (op->opcode == BIT_FIELD_REF)
|
else if (op->opcode == BIT_FIELD_REF)
|
size_tree = op->op0;
|
size_tree = op->op0;
|
else
|
else
|
{
|
{
|
enum machine_mode mode = TYPE_MODE (type);
|
enum machine_mode mode = TYPE_MODE (type);
|
if (mode == BLKmode)
|
if (mode == BLKmode)
|
size_tree = TYPE_SIZE (type);
|
size_tree = TYPE_SIZE (type);
|
else
|
else
|
size = GET_MODE_BITSIZE (mode);
|
size = GET_MODE_BITSIZE (mode);
|
}
|
}
|
if (size_tree != NULL_TREE)
|
if (size_tree != NULL_TREE)
|
{
|
{
|
if (!host_integerp (size_tree, 1))
|
if (!host_integerp (size_tree, 1))
|
size = -1;
|
size = -1;
|
else
|
else
|
size = TREE_INT_CST_LOW (size_tree);
|
size = TREE_INT_CST_LOW (size_tree);
|
}
|
}
|
|
|
/* Initially, maxsize is the same as the accessed element size.
|
/* Initially, maxsize is the same as the accessed element size.
|
In the following it will only grow (or become -1). */
|
In the following it will only grow (or become -1). */
|
max_size = size;
|
max_size = size;
|
|
|
/* Compute cumulative bit-offset for nested component-refs and array-refs,
|
/* Compute cumulative bit-offset for nested component-refs and array-refs,
|
and find the ultimate containing object. */
|
and find the ultimate containing object. */
|
for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i)
|
for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i)
|
{
|
{
|
switch (op->opcode)
|
switch (op->opcode)
|
{
|
{
|
/* These may be in the reference ops, but we cannot do anything
|
/* These may be in the reference ops, but we cannot do anything
|
sensible with them here. */
|
sensible with them here. */
|
case CALL_EXPR:
|
case CALL_EXPR:
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
return false;
|
return false;
|
|
|
/* Record the base objects. */
|
/* Record the base objects. */
|
case ALIGN_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
*op0_p = build1 (op->opcode, op->type, NULL_TREE);
|
*op0_p = build1 (op->opcode, op->type, NULL_TREE);
|
op0_p = &TREE_OPERAND (*op0_p, 0);
|
op0_p = &TREE_OPERAND (*op0_p, 0);
|
break;
|
break;
|
|
|
case MISALIGNED_INDIRECT_REF:
|
case MISALIGNED_INDIRECT_REF:
|
*op0_p = build2 (MISALIGNED_INDIRECT_REF, op->type,
|
*op0_p = build2 (MISALIGNED_INDIRECT_REF, op->type,
|
NULL_TREE, op->op0);
|
NULL_TREE, op->op0);
|
op0_p = &TREE_OPERAND (*op0_p, 0);
|
op0_p = &TREE_OPERAND (*op0_p, 0);
|
break;
|
break;
|
|
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
case SSA_NAME:
|
case SSA_NAME:
|
*op0_p = op->op0;
|
*op0_p = op->op0;
|
break;
|
break;
|
|
|
/* And now the usual component-reference style ops. */
|
/* And now the usual component-reference style ops. */
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
offset += tree_low_cst (op->op1, 0);
|
offset += tree_low_cst (op->op1, 0);
|
break;
|
break;
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
{
|
{
|
tree field = op->op0;
|
tree field = op->op0;
|
/* We do not have a complete COMPONENT_REF tree here so we
|
/* We do not have a complete COMPONENT_REF tree here so we
|
cannot use component_ref_field_offset. Do the interesting
|
cannot use component_ref_field_offset. Do the interesting
|
parts manually. */
|
parts manually. */
|
|
|
/* Our union trick, done for offset zero only. */
|
/* Our union trick, done for offset zero only. */
|
if (TREE_CODE (field) == INTEGER_CST)
|
if (TREE_CODE (field) == INTEGER_CST)
|
;
|
;
|
else if (op->op1
|
else if (op->op1
|
|| !host_integerp (DECL_FIELD_OFFSET (field), 1))
|
|| !host_integerp (DECL_FIELD_OFFSET (field), 1))
|
max_size = -1;
|
max_size = -1;
|
else
|
else
|
{
|
{
|
offset += (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
|
offset += (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
|
* BITS_PER_UNIT);
|
* BITS_PER_UNIT);
|
offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
|
offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_REF:
|
case ARRAY_REF:
|
/* We recorded the lower bound and the element size. */
|
/* We recorded the lower bound and the element size. */
|
if (!host_integerp (op->op0, 0)
|
if (!host_integerp (op->op0, 0)
|
|| !host_integerp (op->op1, 0)
|
|| !host_integerp (op->op1, 0)
|
|| !host_integerp (op->op2, 0))
|
|| !host_integerp (op->op2, 0))
|
max_size = -1;
|
max_size = -1;
|
else
|
else
|
{
|
{
|
HOST_WIDE_INT hindex = TREE_INT_CST_LOW (op->op0);
|
HOST_WIDE_INT hindex = TREE_INT_CST_LOW (op->op0);
|
hindex -= TREE_INT_CST_LOW (op->op1);
|
hindex -= TREE_INT_CST_LOW (op->op1);
|
hindex *= TREE_INT_CST_LOW (op->op2);
|
hindex *= TREE_INT_CST_LOW (op->op2);
|
hindex *= BITS_PER_UNIT;
|
hindex *= BITS_PER_UNIT;
|
offset += hindex;
|
offset += hindex;
|
}
|
}
|
break;
|
break;
|
|
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
break;
|
break;
|
|
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
offset += size;
|
offset += size;
|
break;
|
break;
|
|
|
case VIEW_CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
break;
|
break;
|
|
|
case STRING_CST:
|
case STRING_CST:
|
case INTEGER_CST:
|
case INTEGER_CST:
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
case VECTOR_CST:
|
case VECTOR_CST:
|
case REAL_CST:
|
case REAL_CST:
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
case CONST_DECL:
|
case CONST_DECL:
|
return false;
|
return false;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
if (base == NULL_TREE)
|
if (base == NULL_TREE)
|
return false;
|
return false;
|
|
|
ref->ref = NULL_TREE;
|
ref->ref = NULL_TREE;
|
ref->base = base;
|
ref->base = base;
|
ref->offset = offset;
|
ref->offset = offset;
|
ref->size = size;
|
ref->size = size;
|
ref->max_size = max_size;
|
ref->max_size = max_size;
|
ref->ref_alias_set = set;
|
ref->ref_alias_set = set;
|
ref->base_alias_set = -1;
|
ref->base_alias_set = -1;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Copy the operations present in load/store/call REF into RESULT, a vector of
|
/* Copy the operations present in load/store/call REF into RESULT, a vector of
|
vn_reference_op_s's. */
|
vn_reference_op_s's. */
|
|
|
void
|
void
|
copy_reference_ops_from_call (gimple call,
|
copy_reference_ops_from_call (gimple call,
|
VEC(vn_reference_op_s, heap) **result)
|
VEC(vn_reference_op_s, heap) **result)
|
{
|
{
|
vn_reference_op_s temp;
|
vn_reference_op_s temp;
|
unsigned i;
|
unsigned i;
|
|
|
/* Copy the type, opcode, function being called and static chain. */
|
/* Copy the type, opcode, function being called and static chain. */
|
memset (&temp, 0, sizeof (temp));
|
memset (&temp, 0, sizeof (temp));
|
temp.type = gimple_call_return_type (call);
|
temp.type = gimple_call_return_type (call);
|
temp.opcode = CALL_EXPR;
|
temp.opcode = CALL_EXPR;
|
temp.op0 = gimple_call_fn (call);
|
temp.op0 = gimple_call_fn (call);
|
temp.op1 = gimple_call_chain (call);
|
temp.op1 = gimple_call_chain (call);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
|
|
|
/* Copy the call arguments. As they can be references as well,
|
/* Copy the call arguments. As they can be references as well,
|
just chain them together. */
|
just chain them together. */
|
for (i = 0; i < gimple_call_num_args (call); ++i)
|
for (i = 0; i < gimple_call_num_args (call); ++i)
|
{
|
{
|
tree callarg = gimple_call_arg (call, i);
|
tree callarg = gimple_call_arg (call, i);
|
copy_reference_ops_from_ref (callarg, result);
|
copy_reference_ops_from_ref (callarg, result);
|
}
|
}
|
}
|
}
|
|
|
/* Create a vector of vn_reference_op_s structures from REF, a
|
/* Create a vector of vn_reference_op_s structures from REF, a
|
REFERENCE_CLASS_P tree. The vector is not shared. */
|
REFERENCE_CLASS_P tree. The vector is not shared. */
|
|
|
static VEC(vn_reference_op_s, heap) *
|
static VEC(vn_reference_op_s, heap) *
|
create_reference_ops_from_ref (tree ref)
|
create_reference_ops_from_ref (tree ref)
|
{
|
{
|
VEC (vn_reference_op_s, heap) *result = NULL;
|
VEC (vn_reference_op_s, heap) *result = NULL;
|
|
|
copy_reference_ops_from_ref (ref, &result);
|
copy_reference_ops_from_ref (ref, &result);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Create a vector of vn_reference_op_s structures from CALL, a
|
/* Create a vector of vn_reference_op_s structures from CALL, a
|
call statement. The vector is not shared. */
|
call statement. The vector is not shared. */
|
|
|
static VEC(vn_reference_op_s, heap) *
|
static VEC(vn_reference_op_s, heap) *
|
create_reference_ops_from_call (gimple call)
|
create_reference_ops_from_call (gimple call)
|
{
|
{
|
VEC (vn_reference_op_s, heap) *result = NULL;
|
VEC (vn_reference_op_s, heap) *result = NULL;
|
|
|
copy_reference_ops_from_call (call, &result);
|
copy_reference_ops_from_call (call, &result);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
|
/* Fold *& at position *I_P in a vn_reference_op_s vector *OPS. Updates
|
*I_P to point to the last element of the replacement. */
|
*I_P to point to the last element of the replacement. */
|
void
|
void
|
vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **ops,
|
vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **ops,
|
unsigned int *i_p)
|
unsigned int *i_p)
|
{
|
{
|
VEC(vn_reference_op_s, heap) *mem = NULL;
|
VEC(vn_reference_op_s, heap) *mem = NULL;
|
vn_reference_op_t op;
|
vn_reference_op_t op;
|
unsigned int i = *i_p;
|
unsigned int i = *i_p;
|
unsigned int j;
|
unsigned int j;
|
|
|
/* Get ops for the addressed object. */
|
/* Get ops for the addressed object. */
|
op = VEC_index (vn_reference_op_s, *ops, i);
|
op = VEC_index (vn_reference_op_s, *ops, i);
|
/* ??? If this is our usual typeof &ARRAY vs. &ARRAY[0] problem, work
|
/* ??? If this is our usual typeof &ARRAY vs. &ARRAY[0] problem, work
|
around it to avoid later ICEs. */
|
around it to avoid later ICEs. */
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op->op0, 0))) == ARRAY_TYPE
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op->op0, 0))) == ARRAY_TYPE
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (op->op0))) != ARRAY_TYPE)
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (op->op0))) != ARRAY_TYPE)
|
{
|
{
|
vn_reference_op_s aref;
|
vn_reference_op_s aref;
|
tree dom;
|
tree dom;
|
aref.type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (op->op0)));
|
aref.type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (op->op0)));
|
aref.opcode = ARRAY_REF;
|
aref.opcode = ARRAY_REF;
|
aref.op0 = integer_zero_node;
|
aref.op0 = integer_zero_node;
|
if ((dom = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (op->op0, 0))))
|
if ((dom = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (op->op0, 0))))
|
&& TYPE_MIN_VALUE (dom))
|
&& TYPE_MIN_VALUE (dom))
|
aref.op0 = TYPE_MIN_VALUE (dom);
|
aref.op0 = TYPE_MIN_VALUE (dom);
|
aref.op1 = aref.op0;
|
aref.op1 = aref.op0;
|
aref.op2 = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (op->op0)));
|
aref.op2 = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (op->op0)));
|
VEC_safe_push (vn_reference_op_s, heap, mem, &aref);
|
VEC_safe_push (vn_reference_op_s, heap, mem, &aref);
|
}
|
}
|
copy_reference_ops_from_ref (TREE_OPERAND (op->op0, 0), &mem);
|
copy_reference_ops_from_ref (TREE_OPERAND (op->op0, 0), &mem);
|
|
|
/* Do the replacement - we should have at least one op in mem now. */
|
/* Do the replacement - we should have at least one op in mem now. */
|
if (VEC_length (vn_reference_op_s, mem) == 1)
|
if (VEC_length (vn_reference_op_s, mem) == 1)
|
{
|
{
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_ordered_remove (vn_reference_op_s, *ops, i);
|
VEC_ordered_remove (vn_reference_op_s, *ops, i);
|
i--;
|
i--;
|
}
|
}
|
else if (VEC_length (vn_reference_op_s, mem) == 2)
|
else if (VEC_length (vn_reference_op_s, mem) == 2)
|
{
|
{
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_replace (vn_reference_op_s, *ops, i,
|
VEC_replace (vn_reference_op_s, *ops, i,
|
VEC_index (vn_reference_op_s, mem, 1));
|
VEC_index (vn_reference_op_s, mem, 1));
|
}
|
}
|
else if (VEC_length (vn_reference_op_s, mem) > 2)
|
else if (VEC_length (vn_reference_op_s, mem) > 2)
|
{
|
{
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_replace (vn_reference_op_s, *ops, i - 1,
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_index (vn_reference_op_s, mem, 0));
|
VEC_replace (vn_reference_op_s, *ops, i,
|
VEC_replace (vn_reference_op_s, *ops, i,
|
VEC_index (vn_reference_op_s, mem, 1));
|
VEC_index (vn_reference_op_s, mem, 1));
|
/* ??? There is no VEC_splice. */
|
/* ??? There is no VEC_splice. */
|
for (j = 2; VEC_iterate (vn_reference_op_s, mem, j, op); j++)
|
for (j = 2; VEC_iterate (vn_reference_op_s, mem, j, op); j++)
|
VEC_safe_insert (vn_reference_op_s, heap, *ops, ++i, op);
|
VEC_safe_insert (vn_reference_op_s, heap, *ops, ++i, op);
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
VEC_free (vn_reference_op_s, heap, mem);
|
VEC_free (vn_reference_op_s, heap, mem);
|
*i_p = i;
|
*i_p = i;
|
}
|
}
|
|
|
/* Transform any SSA_NAME's in a vector of vn_reference_op_s
|
/* Transform any SSA_NAME's in a vector of vn_reference_op_s
|
structures into their value numbers. This is done in-place, and
|
structures into their value numbers. This is done in-place, and
|
the vector passed in is returned. */
|
the vector passed in is returned. */
|
|
|
static VEC (vn_reference_op_s, heap) *
|
static VEC (vn_reference_op_s, heap) *
|
valueize_refs (VEC (vn_reference_op_s, heap) *orig)
|
valueize_refs (VEC (vn_reference_op_s, heap) *orig)
|
{
|
{
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = 0; VEC_iterate (vn_reference_op_s, orig, i, vro); i++)
|
for (i = 0; VEC_iterate (vn_reference_op_s, orig, i, vro); i++)
|
{
|
{
|
if (vro->opcode == SSA_NAME
|
if (vro->opcode == SSA_NAME
|
|| (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
|
|| (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
|
{
|
{
|
vro->op0 = SSA_VAL (vro->op0);
|
vro->op0 = SSA_VAL (vro->op0);
|
/* If it transforms from an SSA_NAME to a constant, update
|
/* If it transforms from an SSA_NAME to a constant, update
|
the opcode. */
|
the opcode. */
|
if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
|
if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
|
vro->opcode = TREE_CODE (vro->op0);
|
vro->opcode = TREE_CODE (vro->op0);
|
/* If it transforms from an SSA_NAME to an address, fold with
|
/* If it transforms from an SSA_NAME to an address, fold with
|
a preceding indirect reference. */
|
a preceding indirect reference. */
|
if (i > 0 && TREE_CODE (vro->op0) == ADDR_EXPR
|
if (i > 0 && TREE_CODE (vro->op0) == ADDR_EXPR
|
&& VEC_index (vn_reference_op_s,
|
&& VEC_index (vn_reference_op_s,
|
orig, i - 1)->opcode == INDIRECT_REF)
|
orig, i - 1)->opcode == INDIRECT_REF)
|
{
|
{
|
vn_reference_fold_indirect (&orig, &i);
|
vn_reference_fold_indirect (&orig, &i);
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
vro->op1 = SSA_VAL (vro->op1);
|
vro->op1 = SSA_VAL (vro->op1);
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
vro->op2 = SSA_VAL (vro->op2);
|
vro->op2 = SSA_VAL (vro->op2);
|
}
|
}
|
|
|
return orig;
|
return orig;
|
}
|
}
|
|
|
static VEC(vn_reference_op_s, heap) *shared_lookup_references;
|
static VEC(vn_reference_op_s, heap) *shared_lookup_references;
|
|
|
/* Create a vector of vn_reference_op_s structures from REF, a
|
/* Create a vector of vn_reference_op_s structures from REF, a
|
REFERENCE_CLASS_P tree. The vector is shared among all callers of
|
REFERENCE_CLASS_P tree. The vector is shared among all callers of
|
this function. */
|
this function. */
|
|
|
static VEC(vn_reference_op_s, heap) *
|
static VEC(vn_reference_op_s, heap) *
|
valueize_shared_reference_ops_from_ref (tree ref)
|
valueize_shared_reference_ops_from_ref (tree ref)
|
{
|
{
|
if (!ref)
|
if (!ref)
|
return NULL;
|
return NULL;
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
copy_reference_ops_from_ref (ref, &shared_lookup_references);
|
copy_reference_ops_from_ref (ref, &shared_lookup_references);
|
shared_lookup_references = valueize_refs (shared_lookup_references);
|
shared_lookup_references = valueize_refs (shared_lookup_references);
|
return shared_lookup_references;
|
return shared_lookup_references;
|
}
|
}
|
|
|
/* Create a vector of vn_reference_op_s structures from CALL, a
|
/* Create a vector of vn_reference_op_s structures from CALL, a
|
call statement. The vector is shared among all callers of
|
call statement. The vector is shared among all callers of
|
this function. */
|
this function. */
|
|
|
static VEC(vn_reference_op_s, heap) *
|
static VEC(vn_reference_op_s, heap) *
|
valueize_shared_reference_ops_from_call (gimple call)
|
valueize_shared_reference_ops_from_call (gimple call)
|
{
|
{
|
if (!call)
|
if (!call)
|
return NULL;
|
return NULL;
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
copy_reference_ops_from_call (call, &shared_lookup_references);
|
copy_reference_ops_from_call (call, &shared_lookup_references);
|
shared_lookup_references = valueize_refs (shared_lookup_references);
|
shared_lookup_references = valueize_refs (shared_lookup_references);
|
return shared_lookup_references;
|
return shared_lookup_references;
|
}
|
}
|
|
|
/* Lookup a SCCVN reference operation VR in the current hash table.
|
/* Lookup a SCCVN reference operation VR in the current hash table.
|
Returns the resulting value number if it exists in the 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
|
NULL_TREE otherwise. VNRESULT will be filled in with the actual
|
vn_reference_t stored in the hashtable if something is found. */
|
vn_reference_t stored in the hashtable if something is found. */
|
|
|
static tree
|
static tree
|
vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult)
|
vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult)
|
{
|
{
|
void **slot;
|
void **slot;
|
hashval_t hash;
|
hashval_t hash;
|
|
|
hash = vr->hashcode;
|
hash = vr->hashcode;
|
slot = htab_find_slot_with_hash (current_info->references, vr,
|
slot = htab_find_slot_with_hash (current_info->references, vr,
|
hash, NO_INSERT);
|
hash, NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->references, vr,
|
slot = htab_find_slot_with_hash (valid_info->references, vr,
|
hash, NO_INSERT);
|
hash, NO_INSERT);
|
if (slot)
|
if (slot)
|
{
|
{
|
if (vnresult)
|
if (vnresult)
|
*vnresult = (vn_reference_t)*slot;
|
*vnresult = (vn_reference_t)*slot;
|
return ((vn_reference_t)*slot)->result;
|
return ((vn_reference_t)*slot)->result;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
static tree *last_vuse_ptr;
|
static tree *last_vuse_ptr;
|
|
|
/* Callback for walk_non_aliased_vuses. Adjusts the vn_reference_t VR_
|
/* Callback for walk_non_aliased_vuses. Adjusts the vn_reference_t VR_
|
with the current VUSE and performs the expression lookup. */
|
with the current VUSE and performs the expression lookup. */
|
|
|
static void *
|
static void *
|
vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, void *vr_)
|
vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, void *vr_)
|
{
|
{
|
vn_reference_t vr = (vn_reference_t)vr_;
|
vn_reference_t vr = (vn_reference_t)vr_;
|
void **slot;
|
void **slot;
|
hashval_t hash;
|
hashval_t hash;
|
|
|
if (last_vuse_ptr)
|
if (last_vuse_ptr)
|
*last_vuse_ptr = vuse;
|
*last_vuse_ptr = vuse;
|
|
|
/* Fixup vuse and hash. */
|
/* Fixup vuse and hash. */
|
if (vr->vuse)
|
if (vr->vuse)
|
vr->hashcode = vr->hashcode - SSA_NAME_VERSION (vr->vuse);
|
vr->hashcode = vr->hashcode - SSA_NAME_VERSION (vr->vuse);
|
vr->vuse = SSA_VAL (vuse);
|
vr->vuse = SSA_VAL (vuse);
|
if (vr->vuse)
|
if (vr->vuse)
|
vr->hashcode = vr->hashcode + SSA_NAME_VERSION (vr->vuse);
|
vr->hashcode = vr->hashcode + SSA_NAME_VERSION (vr->vuse);
|
|
|
hash = vr->hashcode;
|
hash = vr->hashcode;
|
slot = htab_find_slot_with_hash (current_info->references, vr,
|
slot = htab_find_slot_with_hash (current_info->references, vr,
|
hash, NO_INSERT);
|
hash, NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->references, vr,
|
slot = htab_find_slot_with_hash (valid_info->references, vr,
|
hash, NO_INSERT);
|
hash, NO_INSERT);
|
if (slot)
|
if (slot)
|
return *slot;
|
return *slot;
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Callback for walk_non_aliased_vuses. Tries to perform a lookup
|
/* Callback for walk_non_aliased_vuses. Tries to perform a lookup
|
from the statement defining VUSE and if not successful tries to
|
from the statement defining VUSE and if not successful tries to
|
translate *REFP and VR_ through an aggregate copy at the defintion
|
translate *REFP and VR_ through an aggregate copy at the defintion
|
of VUSE. */
|
of VUSE. */
|
|
|
static void *
|
static void *
|
vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_)
|
vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_)
|
{
|
{
|
vn_reference_t vr = (vn_reference_t)vr_;
|
vn_reference_t vr = (vn_reference_t)vr_;
|
gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
|
gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
|
tree fndecl;
|
tree fndecl;
|
tree base;
|
tree base;
|
HOST_WIDE_INT offset, maxsize;
|
HOST_WIDE_INT offset, maxsize;
|
|
|
base = ao_ref_base (ref);
|
base = ao_ref_base (ref);
|
offset = ref->offset;
|
offset = ref->offset;
|
maxsize = ref->max_size;
|
maxsize = ref->max_size;
|
|
|
/* If we cannot constrain the size of the reference we cannot
|
/* If we cannot constrain the size of the reference we cannot
|
test if anything kills it. */
|
test if anything kills it. */
|
if (maxsize == -1)
|
if (maxsize == -1)
|
return (void *)-1;
|
return (void *)-1;
|
|
|
/* def_stmt may-defs *ref. See if we can derive a value for *ref
|
/* def_stmt may-defs *ref. See if we can derive a value for *ref
|
from that defintion.
|
from that defintion.
|
1) Memset. */
|
1) Memset. */
|
if (is_gimple_reg_type (vr->type)
|
if (is_gimple_reg_type (vr->type)
|
&& is_gimple_call (def_stmt)
|
&& is_gimple_call (def_stmt)
|
&& (fndecl = gimple_call_fndecl (def_stmt))
|
&& (fndecl = gimple_call_fndecl (def_stmt))
|
&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
|
&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
|
&& DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET
|
&& DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET
|
&& integer_zerop (gimple_call_arg (def_stmt, 1))
|
&& integer_zerop (gimple_call_arg (def_stmt, 1))
|
&& host_integerp (gimple_call_arg (def_stmt, 2), 1)
|
&& host_integerp (gimple_call_arg (def_stmt, 2), 1)
|
&& TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR)
|
&& TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR)
|
{
|
{
|
tree ref2 = TREE_OPERAND (gimple_call_arg (def_stmt, 0), 0);
|
tree ref2 = TREE_OPERAND (gimple_call_arg (def_stmt, 0), 0);
|
tree base2;
|
tree base2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2);
|
base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2);
|
size2 = TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2)) * 8;
|
size2 = TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2)) * 8;
|
if ((unsigned HOST_WIDE_INT)size2 / 8
|
if ((unsigned HOST_WIDE_INT)size2 / 8
|
== TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2))
|
== TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2))
|
&& operand_equal_p (base, base2, 0)
|
&& operand_equal_p (base, base2, 0)
|
&& offset2 <= offset
|
&& offset2 <= offset
|
&& offset2 + size2 >= offset + maxsize)
|
&& offset2 + size2 >= offset + maxsize)
|
{
|
{
|
tree val = fold_convert (vr->type, integer_zero_node);
|
tree val = fold_convert (vr->type, integer_zero_node);
|
unsigned int value_id = get_or_alloc_constant_value_id (val);
|
unsigned int value_id = get_or_alloc_constant_value_id (val);
|
return vn_reference_insert_pieces (vuse, vr->set, vr->type,
|
return vn_reference_insert_pieces (vuse, vr->set, vr->type,
|
VEC_copy (vn_reference_op_s,
|
VEC_copy (vn_reference_op_s,
|
heap, vr->operands),
|
heap, vr->operands),
|
val, value_id);
|
val, value_id);
|
}
|
}
|
}
|
}
|
|
|
/* 2) Assignment from an empty CONSTRUCTOR. */
|
/* 2) Assignment from an empty CONSTRUCTOR. */
|
else if (is_gimple_reg_type (vr->type)
|
else if (is_gimple_reg_type (vr->type)
|
&& gimple_assign_single_p (def_stmt)
|
&& gimple_assign_single_p (def_stmt)
|
&& gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR
|
&& gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR
|
&& CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt)) == 0)
|
&& CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt)) == 0)
|
{
|
{
|
tree base2;
|
tree base2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
|
base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
|
&offset2, &size2, &maxsize2);
|
&offset2, &size2, &maxsize2);
|
if (operand_equal_p (base, base2, 0)
|
if (operand_equal_p (base, base2, 0)
|
&& offset2 <= offset
|
&& offset2 <= offset
|
&& offset2 + size2 >= offset + maxsize)
|
&& offset2 + size2 >= offset + maxsize)
|
{
|
{
|
tree val = fold_convert (vr->type, integer_zero_node);
|
tree val = fold_convert (vr->type, integer_zero_node);
|
unsigned int value_id = get_or_alloc_constant_value_id (val);
|
unsigned int value_id = get_or_alloc_constant_value_id (val);
|
return vn_reference_insert_pieces (vuse, vr->set, vr->type,
|
return vn_reference_insert_pieces (vuse, vr->set, vr->type,
|
VEC_copy (vn_reference_op_s,
|
VEC_copy (vn_reference_op_s,
|
heap, vr->operands),
|
heap, vr->operands),
|
val, value_id);
|
val, value_id);
|
}
|
}
|
}
|
}
|
|
|
/* For aggregate copies translate the reference through them if
|
/* For aggregate copies translate the reference through them if
|
the copy kills ref. */
|
the copy kills ref. */
|
else if (gimple_assign_single_p (def_stmt)
|
else if (gimple_assign_single_p (def_stmt)
|
&& (DECL_P (gimple_assign_rhs1 (def_stmt))
|
&& (DECL_P (gimple_assign_rhs1 (def_stmt))
|
|| INDIRECT_REF_P (gimple_assign_rhs1 (def_stmt))
|
|| INDIRECT_REF_P (gimple_assign_rhs1 (def_stmt))
|
|| handled_component_p (gimple_assign_rhs1 (def_stmt))))
|
|| handled_component_p (gimple_assign_rhs1 (def_stmt))))
|
{
|
{
|
tree base2;
|
tree base2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
HOST_WIDE_INT offset2, size2, maxsize2;
|
int i, j;
|
int i, j;
|
VEC (vn_reference_op_s, heap) *lhs = NULL, *rhs = NULL;
|
VEC (vn_reference_op_s, heap) *lhs = NULL, *rhs = NULL;
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
ao_ref r;
|
ao_ref r;
|
|
|
/* See if the assignment kills REF. */
|
/* See if the assignment kills REF. */
|
base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
|
base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
|
&offset2, &size2, &maxsize2);
|
&offset2, &size2, &maxsize2);
|
if (!operand_equal_p (base, base2, 0)
|
if (!operand_equal_p (base, base2, 0)
|
|| offset2 > offset
|
|| offset2 > offset
|
|| offset2 + size2 < offset + maxsize)
|
|| offset2 + size2 < offset + maxsize)
|
return (void *)-1;
|
return (void *)-1;
|
|
|
/* Find the common base of ref and the lhs. */
|
/* Find the common base of ref and the lhs. */
|
copy_reference_ops_from_ref (gimple_assign_lhs (def_stmt), &lhs);
|
copy_reference_ops_from_ref (gimple_assign_lhs (def_stmt), &lhs);
|
i = VEC_length (vn_reference_op_s, vr->operands) - 1;
|
i = VEC_length (vn_reference_op_s, vr->operands) - 1;
|
j = VEC_length (vn_reference_op_s, lhs) - 1;
|
j = VEC_length (vn_reference_op_s, lhs) - 1;
|
while (j >= 0 && i >= 0
|
while (j >= 0 && i >= 0
|
&& vn_reference_op_eq (VEC_index (vn_reference_op_s,
|
&& vn_reference_op_eq (VEC_index (vn_reference_op_s,
|
vr->operands, i),
|
vr->operands, i),
|
VEC_index (vn_reference_op_s, lhs, j)))
|
VEC_index (vn_reference_op_s, lhs, j)))
|
{
|
{
|
i--;
|
i--;
|
j--;
|
j--;
|
}
|
}
|
|
|
VEC_free (vn_reference_op_s, heap, lhs);
|
VEC_free (vn_reference_op_s, heap, lhs);
|
/* i now points to the first additional op.
|
/* i now points to the first additional op.
|
??? LHS may not be completely contained in VR, one or more
|
??? LHS may not be completely contained in VR, one or more
|
VIEW_CONVERT_EXPRs could be in its way. We could at least
|
VIEW_CONVERT_EXPRs could be in its way. We could at least
|
try handling outermost VIEW_CONVERT_EXPRs. */
|
try handling outermost VIEW_CONVERT_EXPRs. */
|
if (j != -1)
|
if (j != -1)
|
return (void *)-1;
|
return (void *)-1;
|
|
|
/* Now re-write REF to be based on the rhs of the assignment. */
|
/* Now re-write REF to be based on the rhs of the assignment. */
|
copy_reference_ops_from_ref (gimple_assign_rhs1 (def_stmt), &rhs);
|
copy_reference_ops_from_ref (gimple_assign_rhs1 (def_stmt), &rhs);
|
/* We need to pre-pend vr->operands[0..i] to rhs. */
|
/* We need to pre-pend vr->operands[0..i] to rhs. */
|
if (i + 1 + VEC_length (vn_reference_op_s, rhs)
|
if (i + 1 + VEC_length (vn_reference_op_s, rhs)
|
> VEC_length (vn_reference_op_s, vr->operands))
|
> VEC_length (vn_reference_op_s, vr->operands))
|
{
|
{
|
VEC (vn_reference_op_s, heap) *old = vr->operands;
|
VEC (vn_reference_op_s, heap) *old = vr->operands;
|
VEC_safe_grow (vn_reference_op_s, heap, vr->operands,
|
VEC_safe_grow (vn_reference_op_s, heap, vr->operands,
|
i + 1 + VEC_length (vn_reference_op_s, rhs));
|
i + 1 + VEC_length (vn_reference_op_s, rhs));
|
if (old == shared_lookup_references
|
if (old == shared_lookup_references
|
&& vr->operands != old)
|
&& vr->operands != old)
|
shared_lookup_references = NULL;
|
shared_lookup_references = NULL;
|
}
|
}
|
else
|
else
|
VEC_truncate (vn_reference_op_s, vr->operands,
|
VEC_truncate (vn_reference_op_s, vr->operands,
|
i + 1 + VEC_length (vn_reference_op_s, rhs));
|
i + 1 + VEC_length (vn_reference_op_s, rhs));
|
for (j = 0; VEC_iterate (vn_reference_op_s, rhs, j, vro); ++j)
|
for (j = 0; VEC_iterate (vn_reference_op_s, rhs, j, vro); ++j)
|
VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, vro);
|
VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, vro);
|
VEC_free (vn_reference_op_s, heap, rhs);
|
VEC_free (vn_reference_op_s, heap, rhs);
|
vr->hashcode = vn_reference_compute_hash (vr);
|
vr->hashcode = vn_reference_compute_hash (vr);
|
|
|
/* Adjust *ref from the new operands. */
|
/* Adjust *ref from the new operands. */
|
if (!ao_ref_init_from_vn_reference (&r, vr->set, vr->type, vr->operands))
|
if (!ao_ref_init_from_vn_reference (&r, vr->set, vr->type, vr->operands))
|
return (void *)-1;
|
return (void *)-1;
|
/* This can happen with bitfields. */
|
/* This can happen with bitfields. */
|
if (ref->size != r.size)
|
if (ref->size != r.size)
|
return (void *)-1;
|
return (void *)-1;
|
*ref = r;
|
*ref = r;
|
|
|
/* Do not update last seen VUSE after translating. */
|
/* Do not update last seen VUSE after translating. */
|
last_vuse_ptr = NULL;
|
last_vuse_ptr = NULL;
|
|
|
/* Keep looking for the adjusted *REF / VR pair. */
|
/* Keep looking for the adjusted *REF / VR pair. */
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Bail out and stop walking. */
|
/* Bail out and stop walking. */
|
return (void *)-1;
|
return (void *)-1;
|
}
|
}
|
|
|
/* Lookup a reference operation by it's parts, in the current hash table.
|
/* 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,
|
Returns the resulting value number if it exists in the hash table,
|
NULL_TREE otherwise. VNRESULT will be filled in with the actual
|
NULL_TREE otherwise. VNRESULT will be filled in with the actual
|
vn_reference_t stored in the hashtable if something is found. */
|
vn_reference_t stored in the hashtable if something is found. */
|
|
|
tree
|
tree
|
vn_reference_lookup_pieces (tree vuse, alias_set_type set, tree type,
|
vn_reference_lookup_pieces (tree vuse, alias_set_type set, tree type,
|
VEC (vn_reference_op_s, heap) *operands,
|
VEC (vn_reference_op_s, heap) *operands,
|
vn_reference_t *vnresult, bool maywalk)
|
vn_reference_t *vnresult, bool maywalk)
|
{
|
{
|
struct vn_reference_s vr1;
|
struct vn_reference_s vr1;
|
vn_reference_t tmp;
|
vn_reference_t tmp;
|
|
|
if (!vnresult)
|
if (!vnresult)
|
vnresult = &tmp;
|
vnresult = &tmp;
|
*vnresult = NULL;
|
*vnresult = NULL;
|
|
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
|
VEC_safe_grow (vn_reference_op_s, heap, shared_lookup_references,
|
VEC_safe_grow (vn_reference_op_s, heap, shared_lookup_references,
|
VEC_length (vn_reference_op_s, operands));
|
VEC_length (vn_reference_op_s, operands));
|
memcpy (VEC_address (vn_reference_op_s, shared_lookup_references),
|
memcpy (VEC_address (vn_reference_op_s, shared_lookup_references),
|
VEC_address (vn_reference_op_s, operands),
|
VEC_address (vn_reference_op_s, operands),
|
sizeof (vn_reference_op_s)
|
sizeof (vn_reference_op_s)
|
* VEC_length (vn_reference_op_s, operands));
|
* VEC_length (vn_reference_op_s, operands));
|
vr1.operands = operands = shared_lookup_references
|
vr1.operands = operands = shared_lookup_references
|
= valueize_refs (shared_lookup_references);
|
= valueize_refs (shared_lookup_references);
|
vr1.type = type;
|
vr1.type = type;
|
vr1.set = set;
|
vr1.set = set;
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
vn_reference_lookup_1 (&vr1, vnresult);
|
vn_reference_lookup_1 (&vr1, vnresult);
|
|
|
if (!*vnresult
|
if (!*vnresult
|
&& maywalk
|
&& maywalk
|
&& vr1.vuse)
|
&& vr1.vuse)
|
{
|
{
|
ao_ref r;
|
ao_ref r;
|
if (ao_ref_init_from_vn_reference (&r, set, type, vr1.operands))
|
if (ao_ref_init_from_vn_reference (&r, set, type, vr1.operands))
|
*vnresult =
|
*vnresult =
|
(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
|
(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
|
vn_reference_lookup_2,
|
vn_reference_lookup_2,
|
vn_reference_lookup_3, &vr1);
|
vn_reference_lookup_3, &vr1);
|
if (vr1.operands != operands)
|
if (vr1.operands != operands)
|
VEC_free (vn_reference_op_s, heap, vr1.operands);
|
VEC_free (vn_reference_op_s, heap, vr1.operands);
|
}
|
}
|
|
|
if (*vnresult)
|
if (*vnresult)
|
return (*vnresult)->result;
|
return (*vnresult)->result;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Lookup OP in the current hash table, and return the resulting value
|
/* 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
|
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
|
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
|
was NULL.. VNRESULT will be filled in with the vn_reference_t
|
stored in the hashtable if one exists. */
|
stored in the hashtable if one exists. */
|
|
|
tree
|
tree
|
vn_reference_lookup (tree op, tree vuse, bool maywalk,
|
vn_reference_lookup (tree op, tree vuse, bool maywalk,
|
vn_reference_t *vnresult)
|
vn_reference_t *vnresult)
|
{
|
{
|
VEC (vn_reference_op_s, heap) *operands;
|
VEC (vn_reference_op_s, heap) *operands;
|
struct vn_reference_s vr1;
|
struct vn_reference_s vr1;
|
|
|
if (vnresult)
|
if (vnresult)
|
*vnresult = NULL;
|
*vnresult = NULL;
|
|
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1.operands = operands = valueize_shared_reference_ops_from_ref (op);
|
vr1.operands = operands = valueize_shared_reference_ops_from_ref (op);
|
vr1.type = TREE_TYPE (op);
|
vr1.type = TREE_TYPE (op);
|
vr1.set = get_alias_set (op);
|
vr1.set = get_alias_set (op);
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
|
|
if (maywalk
|
if (maywalk
|
&& vr1.vuse)
|
&& vr1.vuse)
|
{
|
{
|
vn_reference_t wvnresult;
|
vn_reference_t wvnresult;
|
ao_ref r;
|
ao_ref r;
|
ao_ref_init (&r, op);
|
ao_ref_init (&r, op);
|
wvnresult =
|
wvnresult =
|
(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
|
(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
|
vn_reference_lookup_2,
|
vn_reference_lookup_2,
|
vn_reference_lookup_3, &vr1);
|
vn_reference_lookup_3, &vr1);
|
if (vr1.operands != operands)
|
if (vr1.operands != operands)
|
VEC_free (vn_reference_op_s, heap, vr1.operands);
|
VEC_free (vn_reference_op_s, heap, vr1.operands);
|
if (wvnresult)
|
if (wvnresult)
|
{
|
{
|
if (vnresult)
|
if (vnresult)
|
*vnresult = wvnresult;
|
*vnresult = wvnresult;
|
return wvnresult->result;
|
return wvnresult->result;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
return vn_reference_lookup_1 (&vr1, vnresult);
|
return vn_reference_lookup_1 (&vr1, vnresult);
|
}
|
}
|
|
|
|
|
/* Insert OP into the current hash table with a value number of
|
/* Insert OP into the current hash table with a value number of
|
RESULT, and return the resulting reference structure we created. */
|
RESULT, and return the resulting reference structure we created. */
|
|
|
vn_reference_t
|
vn_reference_t
|
vn_reference_insert (tree op, tree result, tree vuse)
|
vn_reference_insert (tree op, tree result, tree vuse)
|
{
|
{
|
void **slot;
|
void **slot;
|
vn_reference_t vr1;
|
vn_reference_t vr1;
|
|
|
vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
if (TREE_CODE (result) == SSA_NAME)
|
if (TREE_CODE (result) == SSA_NAME)
|
vr1->value_id = VN_INFO (result)->value_id;
|
vr1->value_id = VN_INFO (result)->value_id;
|
else
|
else
|
vr1->value_id = get_or_alloc_constant_value_id (result);
|
vr1->value_id = get_or_alloc_constant_value_id (result);
|
vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1->operands = valueize_refs (create_reference_ops_from_ref (op));
|
vr1->operands = valueize_refs (create_reference_ops_from_ref (op));
|
vr1->type = TREE_TYPE (op);
|
vr1->type = TREE_TYPE (op);
|
vr1->set = get_alias_set (op);
|
vr1->set = get_alias_set (op);
|
vr1->hashcode = vn_reference_compute_hash (vr1);
|
vr1->hashcode = vn_reference_compute_hash (vr1);
|
vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
|
vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
|
|
|
slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
|
INSERT);
|
INSERT);
|
|
|
/* Because we lookup stores using vuses, and value number failures
|
/* Because we lookup stores using vuses, and value number failures
|
using the vdefs (see visit_reference_op_store for how and why),
|
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
|
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
|
inserted store. This is not wrong, there is no ssa name for a
|
store that we could use as a differentiator anyway. Thus, unlike
|
store that we could use as a differentiator anyway. Thus, unlike
|
the other lookup functions, you cannot gcc_assert (!*slot)
|
the other lookup functions, you cannot gcc_assert (!*slot)
|
here. */
|
here. */
|
|
|
/* But free the old slot in case of a collision. */
|
/* But free the old slot in case of a collision. */
|
if (*slot)
|
if (*slot)
|
free_reference (*slot);
|
free_reference (*slot);
|
|
|
*slot = vr1;
|
*slot = vr1;
|
return vr1;
|
return vr1;
|
}
|
}
|
|
|
/* Insert a reference by it's pieces into the current hash table with
|
/* Insert a reference by it's pieces into the current hash table with
|
a value number of RESULT. Return the resulting reference
|
a value number of RESULT. Return the resulting reference
|
structure we created. */
|
structure we created. */
|
|
|
vn_reference_t
|
vn_reference_t
|
vn_reference_insert_pieces (tree vuse, alias_set_type set, tree type,
|
vn_reference_insert_pieces (tree vuse, alias_set_type set, tree type,
|
VEC (vn_reference_op_s, heap) *operands,
|
VEC (vn_reference_op_s, heap) *operands,
|
tree result, unsigned int value_id)
|
tree result, unsigned int value_id)
|
|
|
{
|
{
|
void **slot;
|
void **slot;
|
vn_reference_t vr1;
|
vn_reference_t vr1;
|
|
|
vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
vr1->value_id = value_id;
|
vr1->value_id = value_id;
|
vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1->operands = valueize_refs (operands);
|
vr1->operands = valueize_refs (operands);
|
vr1->type = type;
|
vr1->type = type;
|
vr1->set = set;
|
vr1->set = set;
|
vr1->hashcode = vn_reference_compute_hash (vr1);
|
vr1->hashcode = vn_reference_compute_hash (vr1);
|
if (result && TREE_CODE (result) == SSA_NAME)
|
if (result && TREE_CODE (result) == SSA_NAME)
|
result = SSA_VAL (result);
|
result = SSA_VAL (result);
|
vr1->result = result;
|
vr1->result = result;
|
|
|
slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
|
INSERT);
|
INSERT);
|
|
|
/* At this point we should have all the things inserted that we have
|
/* At this point we should have all the things inserted that we have
|
seen before, and we should never try inserting something that
|
seen before, and we should never try inserting something that
|
already exists. */
|
already exists. */
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
if (*slot)
|
if (*slot)
|
free_reference (*slot);
|
free_reference (*slot);
|
|
|
*slot = vr1;
|
*slot = vr1;
|
return vr1;
|
return vr1;
|
}
|
}
|
|
|
/* Compute and return the hash value for nary operation VBO1. */
|
/* Compute and return the hash value for nary operation VBO1. */
|
|
|
hashval_t
|
hashval_t
|
vn_nary_op_compute_hash (const vn_nary_op_t vno1)
|
vn_nary_op_compute_hash (const vn_nary_op_t vno1)
|
{
|
{
|
hashval_t hash;
|
hashval_t hash;
|
unsigned i;
|
unsigned i;
|
|
|
for (i = 0; i < vno1->length; ++i)
|
for (i = 0; i < vno1->length; ++i)
|
if (TREE_CODE (vno1->op[i]) == SSA_NAME)
|
if (TREE_CODE (vno1->op[i]) == SSA_NAME)
|
vno1->op[i] = SSA_VAL (vno1->op[i]);
|
vno1->op[i] = SSA_VAL (vno1->op[i]);
|
|
|
if (vno1->length == 2
|
if (vno1->length == 2
|
&& commutative_tree_code (vno1->opcode)
|
&& commutative_tree_code (vno1->opcode)
|
&& tree_swap_operands_p (vno1->op[0], vno1->op[1], false))
|
&& tree_swap_operands_p (vno1->op[0], vno1->op[1], false))
|
{
|
{
|
tree temp = vno1->op[0];
|
tree temp = vno1->op[0];
|
vno1->op[0] = vno1->op[1];
|
vno1->op[0] = vno1->op[1];
|
vno1->op[1] = temp;
|
vno1->op[1] = temp;
|
}
|
}
|
|
|
hash = iterative_hash_hashval_t (vno1->opcode, 0);
|
hash = iterative_hash_hashval_t (vno1->opcode, 0);
|
for (i = 0; i < vno1->length; ++i)
|
for (i = 0; i < vno1->length; ++i)
|
hash = iterative_hash_expr (vno1->op[i], hash);
|
hash = iterative_hash_expr (vno1->op[i], hash);
|
|
|
return hash;
|
return hash;
|
}
|
}
|
|
|
/* Return the computed hashcode for nary operation P1. */
|
/* Return the computed hashcode for nary operation P1. */
|
|
|
static hashval_t
|
static hashval_t
|
vn_nary_op_hash (const void *p1)
|
vn_nary_op_hash (const void *p1)
|
{
|
{
|
const_vn_nary_op_t const vno1 = (const_vn_nary_op_t) p1;
|
const_vn_nary_op_t const vno1 = (const_vn_nary_op_t) p1;
|
return vno1->hashcode;
|
return vno1->hashcode;
|
}
|
}
|
|
|
/* Compare nary operations P1 and P2 and return true if they are
|
/* Compare nary operations P1 and P2 and return true if they are
|
equivalent. */
|
equivalent. */
|
|
|
int
|
int
|
vn_nary_op_eq (const void *p1, const void *p2)
|
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 vno1 = (const_vn_nary_op_t) p1;
|
const_vn_nary_op_t const vno2 = (const_vn_nary_op_t) p2;
|
const_vn_nary_op_t const vno2 = (const_vn_nary_op_t) p2;
|
unsigned i;
|
unsigned i;
|
|
|
if (vno1->hashcode != vno2->hashcode)
|
if (vno1->hashcode != vno2->hashcode)
|
return false;
|
return false;
|
|
|
if (vno1->opcode != vno2->opcode
|
if (vno1->opcode != vno2->opcode
|
|| !types_compatible_p (vno1->type, vno2->type))
|
|| !types_compatible_p (vno1->type, vno2->type))
|
return false;
|
return false;
|
|
|
for (i = 0; i < vno1->length; ++i)
|
for (i = 0; i < vno1->length; ++i)
|
if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
|
if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Lookup a n-ary operation by its pieces and return the resulting value
|
/* 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
|
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
|
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
|
is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
|
if it exists. */
|
if it exists. */
|
|
|
tree
|
tree
|
vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
|
vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
|
tree type, tree op0, tree op1, tree op2,
|
tree type, tree op0, tree op1, tree op2,
|
tree op3, vn_nary_op_t *vnresult)
|
tree op3, vn_nary_op_t *vnresult)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_nary_op_s vno1;
|
struct vn_nary_op_s vno1;
|
if (vnresult)
|
if (vnresult)
|
*vnresult = NULL;
|
*vnresult = NULL;
|
vno1.opcode = code;
|
vno1.opcode = code;
|
vno1.length = length;
|
vno1.length = length;
|
vno1.type = type;
|
vno1.type = type;
|
vno1.op[0] = op0;
|
vno1.op[0] = op0;
|
vno1.op[1] = op1;
|
vno1.op[1] = op1;
|
vno1.op[2] = op2;
|
vno1.op[2] = op2;
|
vno1.op[3] = op3;
|
vno1.op[3] = op3;
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (vnresult)
|
if (vnresult)
|
*vnresult = (vn_nary_op_t)*slot;
|
*vnresult = (vn_nary_op_t)*slot;
|
return ((vn_nary_op_t)*slot)->result;
|
return ((vn_nary_op_t)*slot)->result;
|
}
|
}
|
|
|
/* Lookup OP in the current hash table, and return the resulting value
|
/* 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
|
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
|
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
|
is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
|
if it exists. */
|
if it exists. */
|
|
|
tree
|
tree
|
vn_nary_op_lookup (tree op, vn_nary_op_t *vnresult)
|
vn_nary_op_lookup (tree op, vn_nary_op_t *vnresult)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_nary_op_s vno1;
|
struct vn_nary_op_s vno1;
|
unsigned i;
|
unsigned i;
|
|
|
if (vnresult)
|
if (vnresult)
|
*vnresult = NULL;
|
*vnresult = NULL;
|
vno1.opcode = TREE_CODE (op);
|
vno1.opcode = TREE_CODE (op);
|
vno1.length = TREE_CODE_LENGTH (TREE_CODE (op));
|
vno1.length = TREE_CODE_LENGTH (TREE_CODE (op));
|
vno1.type = TREE_TYPE (op);
|
vno1.type = TREE_TYPE (op);
|
for (i = 0; i < vno1.length; ++i)
|
for (i = 0; i < vno1.length; ++i)
|
vno1.op[i] = TREE_OPERAND (op, i);
|
vno1.op[i] = TREE_OPERAND (op, i);
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (vnresult)
|
if (vnresult)
|
*vnresult = (vn_nary_op_t)*slot;
|
*vnresult = (vn_nary_op_t)*slot;
|
return ((vn_nary_op_t)*slot)->result;
|
return ((vn_nary_op_t)*slot)->result;
|
}
|
}
|
|
|
/* Lookup the rhs of STMT in the current hash table, and return the resulting
|
/* 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
|
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
|
it does not exist in the hash table. VNRESULT will contain the
|
vn_nary_op_t from the hashtable if it exists. */
|
vn_nary_op_t from the hashtable if it exists. */
|
|
|
tree
|
tree
|
vn_nary_op_lookup_stmt (gimple stmt, vn_nary_op_t *vnresult)
|
vn_nary_op_lookup_stmt (gimple stmt, vn_nary_op_t *vnresult)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_nary_op_s vno1;
|
struct vn_nary_op_s vno1;
|
unsigned i;
|
unsigned i;
|
|
|
if (vnresult)
|
if (vnresult)
|
*vnresult = NULL;
|
*vnresult = NULL;
|
vno1.opcode = gimple_assign_rhs_code (stmt);
|
vno1.opcode = gimple_assign_rhs_code (stmt);
|
vno1.length = gimple_num_ops (stmt) - 1;
|
vno1.length = gimple_num_ops (stmt) - 1;
|
vno1.type = gimple_expr_type (stmt);
|
vno1.type = gimple_expr_type (stmt);
|
for (i = 0; i < vno1.length; ++i)
|
for (i = 0; i < vno1.length; ++i)
|
vno1.op[i] = gimple_op (stmt, i + 1);
|
vno1.op[i] = gimple_op (stmt, i + 1);
|
if (vno1.opcode == REALPART_EXPR
|
if (vno1.opcode == REALPART_EXPR
|
|| vno1.opcode == IMAGPART_EXPR
|
|| vno1.opcode == IMAGPART_EXPR
|
|| vno1.opcode == VIEW_CONVERT_EXPR)
|
|| vno1.opcode == VIEW_CONVERT_EXPR)
|
vno1.op[0] = TREE_OPERAND (vno1.op[0], 0);
|
vno1.op[0] = TREE_OPERAND (vno1.op[0], 0);
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
vno1.hashcode = vn_nary_op_compute_hash (&vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
slot = htab_find_slot_with_hash (valid_info->nary, &vno1, vno1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (vnresult)
|
if (vnresult)
|
*vnresult = (vn_nary_op_t)*slot;
|
*vnresult = (vn_nary_op_t)*slot;
|
return ((vn_nary_op_t)*slot)->result;
|
return ((vn_nary_op_t)*slot)->result;
|
}
|
}
|
|
|
/* Insert a n-ary operation into the current hash table using it's
|
/* 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
|
pieces. Return the vn_nary_op_t structure we created and put in
|
the hashtable. */
|
the hashtable. */
|
|
|
vn_nary_op_t
|
vn_nary_op_t
|
vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
|
vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
|
tree type, tree op0,
|
tree type, tree op0,
|
tree op1, tree op2, tree op3,
|
tree op1, tree op2, tree op3,
|
tree result,
|
tree result,
|
unsigned int value_id)
|
unsigned int value_id)
|
{
|
{
|
void **slot;
|
void **slot;
|
vn_nary_op_t vno1;
|
vn_nary_op_t vno1;
|
|
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
(sizeof (struct vn_nary_op_s)
|
(sizeof (struct vn_nary_op_s)
|
- sizeof (tree) * (4 - length)));
|
- sizeof (tree) * (4 - length)));
|
vno1->value_id = value_id;
|
vno1->value_id = value_id;
|
vno1->opcode = code;
|
vno1->opcode = code;
|
vno1->length = length;
|
vno1->length = length;
|
vno1->type = type;
|
vno1->type = type;
|
if (length >= 1)
|
if (length >= 1)
|
vno1->op[0] = op0;
|
vno1->op[0] = op0;
|
if (length >= 2)
|
if (length >= 2)
|
vno1->op[1] = op1;
|
vno1->op[1] = op1;
|
if (length >= 3)
|
if (length >= 3)
|
vno1->op[2] = op2;
|
vno1->op[2] = op2;
|
if (length >= 4)
|
if (length >= 4)
|
vno1->op[3] = op3;
|
vno1->op[3] = op3;
|
vno1->result = result;
|
vno1->result = result;
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
INSERT);
|
INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
|
|
*slot = vno1;
|
*slot = vno1;
|
return vno1;
|
return vno1;
|
|
|
}
|
}
|
|
|
/* Insert OP into the current hash table with a value number of
|
/* 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
|
RESULT. Return the vn_nary_op_t structure we created and put in
|
the hashtable. */
|
the hashtable. */
|
|
|
vn_nary_op_t
|
vn_nary_op_t
|
vn_nary_op_insert (tree op, tree result)
|
vn_nary_op_insert (tree op, tree result)
|
{
|
{
|
unsigned length = TREE_CODE_LENGTH (TREE_CODE (op));
|
unsigned length = TREE_CODE_LENGTH (TREE_CODE (op));
|
void **slot;
|
void **slot;
|
vn_nary_op_t vno1;
|
vn_nary_op_t vno1;
|
unsigned i;
|
unsigned i;
|
|
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
(sizeof (struct vn_nary_op_s)
|
(sizeof (struct vn_nary_op_s)
|
- sizeof (tree) * (4 - length)));
|
- sizeof (tree) * (4 - length)));
|
vno1->value_id = VN_INFO (result)->value_id;
|
vno1->value_id = VN_INFO (result)->value_id;
|
vno1->opcode = TREE_CODE (op);
|
vno1->opcode = TREE_CODE (op);
|
vno1->length = length;
|
vno1->length = length;
|
vno1->type = TREE_TYPE (op);
|
vno1->type = TREE_TYPE (op);
|
for (i = 0; i < vno1->length; ++i)
|
for (i = 0; i < vno1->length; ++i)
|
vno1->op[i] = TREE_OPERAND (op, i);
|
vno1->op[i] = TREE_OPERAND (op, i);
|
vno1->result = result;
|
vno1->result = result;
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
INSERT);
|
INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
|
|
*slot = vno1;
|
*slot = vno1;
|
return vno1;
|
return vno1;
|
}
|
}
|
|
|
/* Insert the rhs of STMT into the current hash table with a value number of
|
/* Insert the rhs of STMT into the current hash table with a value number of
|
RESULT. */
|
RESULT. */
|
|
|
vn_nary_op_t
|
vn_nary_op_t
|
vn_nary_op_insert_stmt (gimple stmt, tree result)
|
vn_nary_op_insert_stmt (gimple stmt, tree result)
|
{
|
{
|
unsigned length = gimple_num_ops (stmt) - 1;
|
unsigned length = gimple_num_ops (stmt) - 1;
|
void **slot;
|
void **slot;
|
vn_nary_op_t vno1;
|
vn_nary_op_t vno1;
|
unsigned i;
|
unsigned i;
|
|
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
vno1 = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
(sizeof (struct vn_nary_op_s)
|
(sizeof (struct vn_nary_op_s)
|
- sizeof (tree) * (4 - length)));
|
- sizeof (tree) * (4 - length)));
|
vno1->value_id = VN_INFO (result)->value_id;
|
vno1->value_id = VN_INFO (result)->value_id;
|
vno1->opcode = gimple_assign_rhs_code (stmt);
|
vno1->opcode = gimple_assign_rhs_code (stmt);
|
vno1->length = length;
|
vno1->length = length;
|
vno1->type = gimple_expr_type (stmt);
|
vno1->type = gimple_expr_type (stmt);
|
for (i = 0; i < vno1->length; ++i)
|
for (i = 0; i < vno1->length; ++i)
|
vno1->op[i] = gimple_op (stmt, i + 1);
|
vno1->op[i] = gimple_op (stmt, i + 1);
|
if (vno1->opcode == REALPART_EXPR
|
if (vno1->opcode == REALPART_EXPR
|
|| vno1->opcode == IMAGPART_EXPR
|
|| vno1->opcode == IMAGPART_EXPR
|
|| vno1->opcode == VIEW_CONVERT_EXPR)
|
|| vno1->opcode == VIEW_CONVERT_EXPR)
|
vno1->op[0] = TREE_OPERAND (vno1->op[0], 0);
|
vno1->op[0] = TREE_OPERAND (vno1->op[0], 0);
|
vno1->result = result;
|
vno1->result = result;
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
vno1->hashcode = vn_nary_op_compute_hash (vno1);
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, vno1, vno1->hashcode,
|
INSERT);
|
INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
|
|
*slot = vno1;
|
*slot = vno1;
|
return vno1;
|
return vno1;
|
}
|
}
|
|
|
/* Compute a hashcode for PHI operation VP1 and return it. */
|
/* Compute a hashcode for PHI operation VP1 and return it. */
|
|
|
static inline hashval_t
|
static inline hashval_t
|
vn_phi_compute_hash (vn_phi_t vp1)
|
vn_phi_compute_hash (vn_phi_t vp1)
|
{
|
{
|
hashval_t result;
|
hashval_t result;
|
int i;
|
int i;
|
tree phi1op;
|
tree phi1op;
|
tree type;
|
tree type;
|
|
|
result = vp1->block->index;
|
result = vp1->block->index;
|
|
|
/* If all PHI arguments are constants we need to distinguish
|
/* If all PHI arguments are constants we need to distinguish
|
the PHI node via its type. */
|
the PHI node via its type. */
|
type = TREE_TYPE (VEC_index (tree, vp1->phiargs, 0));
|
type = TREE_TYPE (VEC_index (tree, vp1->phiargs, 0));
|
result += (INTEGRAL_TYPE_P (type)
|
result += (INTEGRAL_TYPE_P (type)
|
+ (INTEGRAL_TYPE_P (type)
|
+ (INTEGRAL_TYPE_P (type)
|
? TYPE_PRECISION (type) + TYPE_UNSIGNED (type) : 0));
|
? TYPE_PRECISION (type) + TYPE_UNSIGNED (type) : 0));
|
|
|
for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
|
for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
|
{
|
{
|
if (phi1op == VN_TOP)
|
if (phi1op == VN_TOP)
|
continue;
|
continue;
|
result = iterative_hash_expr (phi1op, result);
|
result = iterative_hash_expr (phi1op, result);
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return the computed hashcode for phi operation P1. */
|
/* Return the computed hashcode for phi operation P1. */
|
|
|
static hashval_t
|
static hashval_t
|
vn_phi_hash (const void *p1)
|
vn_phi_hash (const void *p1)
|
{
|
{
|
const_vn_phi_t const vp1 = (const_vn_phi_t) p1;
|
const_vn_phi_t const vp1 = (const_vn_phi_t) p1;
|
return vp1->hashcode;
|
return vp1->hashcode;
|
}
|
}
|
|
|
/* Compare two phi entries for equality, ignoring VN_TOP arguments. */
|
/* Compare two phi entries for equality, ignoring VN_TOP arguments. */
|
|
|
static int
|
static int
|
vn_phi_eq (const void *p1, const void *p2)
|
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 vp1 = (const_vn_phi_t) p1;
|
const_vn_phi_t const vp2 = (const_vn_phi_t) p2;
|
const_vn_phi_t const vp2 = (const_vn_phi_t) p2;
|
|
|
if (vp1->hashcode != vp2->hashcode)
|
if (vp1->hashcode != vp2->hashcode)
|
return false;
|
return false;
|
|
|
if (vp1->block == vp2->block)
|
if (vp1->block == vp2->block)
|
{
|
{
|
int i;
|
int i;
|
tree phi1op;
|
tree phi1op;
|
|
|
/* If the PHI nodes do not have compatible types
|
/* If the PHI nodes do not have compatible types
|
they are not the same. */
|
they are not the same. */
|
if (!types_compatible_p (TREE_TYPE (VEC_index (tree, vp1->phiargs, 0)),
|
if (!types_compatible_p (TREE_TYPE (VEC_index (tree, vp1->phiargs, 0)),
|
TREE_TYPE (VEC_index (tree, vp2->phiargs, 0))))
|
TREE_TYPE (VEC_index (tree, vp2->phiargs, 0))))
|
return false;
|
return false;
|
|
|
/* Any phi in the same block will have it's arguments in the
|
/* Any phi in the same block will have it's arguments in the
|
same edge order, because of how we store phi nodes. */
|
same edge order, because of how we store phi nodes. */
|
for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
|
for (i = 0; VEC_iterate (tree, vp1->phiargs, i, phi1op); i++)
|
{
|
{
|
tree phi2op = VEC_index (tree, vp2->phiargs, i);
|
tree phi2op = VEC_index (tree, vp2->phiargs, i);
|
if (phi1op == VN_TOP || phi2op == VN_TOP)
|
if (phi1op == VN_TOP || phi2op == VN_TOP)
|
continue;
|
continue;
|
if (!expressions_equal_p (phi1op, phi2op))
|
if (!expressions_equal_p (phi1op, phi2op))
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
static VEC(tree, heap) *shared_lookup_phiargs;
|
static VEC(tree, heap) *shared_lookup_phiargs;
|
|
|
/* Lookup PHI in the current hash table, and return the resulting
|
/* Lookup PHI in the current hash table, and return the resulting
|
value number if it exists in the hash table. Return NULL_TREE if
|
value number if it exists in the hash table. Return NULL_TREE if
|
it does not exist in the hash table. */
|
it does not exist in the hash table. */
|
|
|
static tree
|
static tree
|
vn_phi_lookup (gimple phi)
|
vn_phi_lookup (gimple phi)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct vn_phi_s vp1;
|
struct vn_phi_s vp1;
|
unsigned i;
|
unsigned i;
|
|
|
VEC_truncate (tree, shared_lookup_phiargs, 0);
|
VEC_truncate (tree, shared_lookup_phiargs, 0);
|
|
|
/* Canonicalize the SSA_NAME's to their value number. */
|
/* Canonicalize the SSA_NAME's to their value number. */
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
{
|
{
|
tree def = PHI_ARG_DEF (phi, i);
|
tree def = PHI_ARG_DEF (phi, i);
|
def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
|
def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
|
VEC_safe_push (tree, heap, shared_lookup_phiargs, def);
|
VEC_safe_push (tree, heap, shared_lookup_phiargs, def);
|
}
|
}
|
vp1.phiargs = shared_lookup_phiargs;
|
vp1.phiargs = shared_lookup_phiargs;
|
vp1.block = gimple_bb (phi);
|
vp1.block = gimple_bb (phi);
|
vp1.hashcode = vn_phi_compute_hash (&vp1);
|
vp1.hashcode = vn_phi_compute_hash (&vp1);
|
slot = htab_find_slot_with_hash (current_info->phis, &vp1, vp1.hashcode,
|
slot = htab_find_slot_with_hash (current_info->phis, &vp1, vp1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot && current_info == optimistic_info)
|
if (!slot && current_info == optimistic_info)
|
slot = htab_find_slot_with_hash (valid_info->phis, &vp1, vp1.hashcode,
|
slot = htab_find_slot_with_hash (valid_info->phis, &vp1, vp1.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL_TREE;
|
return NULL_TREE;
|
return ((vn_phi_t)*slot)->result;
|
return ((vn_phi_t)*slot)->result;
|
}
|
}
|
|
|
/* Insert PHI into the current hash table with a value number of
|
/* Insert PHI into the current hash table with a value number of
|
RESULT. */
|
RESULT. */
|
|
|
static vn_phi_t
|
static vn_phi_t
|
vn_phi_insert (gimple phi, tree result)
|
vn_phi_insert (gimple phi, tree result)
|
{
|
{
|
void **slot;
|
void **slot;
|
vn_phi_t vp1 = (vn_phi_t) pool_alloc (current_info->phis_pool);
|
vn_phi_t vp1 = (vn_phi_t) pool_alloc (current_info->phis_pool);
|
unsigned i;
|
unsigned i;
|
VEC (tree, heap) *args = NULL;
|
VEC (tree, heap) *args = NULL;
|
|
|
/* Canonicalize the SSA_NAME's to their value number. */
|
/* Canonicalize the SSA_NAME's to their value number. */
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
{
|
{
|
tree def = PHI_ARG_DEF (phi, i);
|
tree def = PHI_ARG_DEF (phi, i);
|
def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
|
def = TREE_CODE (def) == SSA_NAME ? SSA_VAL (def) : def;
|
VEC_safe_push (tree, heap, args, def);
|
VEC_safe_push (tree, heap, args, def);
|
}
|
}
|
vp1->value_id = VN_INFO (result)->value_id;
|
vp1->value_id = VN_INFO (result)->value_id;
|
vp1->phiargs = args;
|
vp1->phiargs = args;
|
vp1->block = gimple_bb (phi);
|
vp1->block = gimple_bb (phi);
|
vp1->result = result;
|
vp1->result = result;
|
vp1->hashcode = vn_phi_compute_hash (vp1);
|
vp1->hashcode = vn_phi_compute_hash (vp1);
|
|
|
slot = htab_find_slot_with_hash (current_info->phis, vp1, vp1->hashcode,
|
slot = htab_find_slot_with_hash (current_info->phis, vp1, vp1->hashcode,
|
INSERT);
|
INSERT);
|
|
|
/* Because we iterate over phi operations more than once, it's
|
/* Because we iterate over phi operations more than once, it's
|
possible the slot might already exist here, hence no assert.*/
|
possible the slot might already exist here, hence no assert.*/
|
*slot = vp1;
|
*slot = vp1;
|
return vp1;
|
return vp1;
|
}
|
}
|
|
|
|
|
/* Print set of components in strongly connected component SCC to OUT. */
|
/* Print set of components in strongly connected component SCC to OUT. */
|
|
|
static void
|
static void
|
print_scc (FILE *out, VEC (tree, heap) *scc)
|
print_scc (FILE *out, VEC (tree, heap) *scc)
|
{
|
{
|
tree var;
|
tree var;
|
unsigned int i;
|
unsigned int i;
|
|
|
fprintf (out, "SCC consists of: ");
|
fprintf (out, "SCC consists of: ");
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
{
|
{
|
print_generic_expr (out, var, 0);
|
print_generic_expr (out, var, 0);
|
fprintf (out, " ");
|
fprintf (out, " ");
|
}
|
}
|
fprintf (out, "\n");
|
fprintf (out, "\n");
|
}
|
}
|
|
|
/* Set the value number of FROM to TO, return true if it has changed
|
/* Set the value number of FROM to TO, return true if it has changed
|
as a result. */
|
as a result. */
|
|
|
static inline bool
|
static inline bool
|
set_ssa_val_to (tree from, tree to)
|
set_ssa_val_to (tree from, tree to)
|
{
|
{
|
tree currval;
|
tree currval;
|
|
|
if (from != to
|
if (from != to
|
&& TREE_CODE (to) == SSA_NAME
|
&& TREE_CODE (to) == SSA_NAME
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to))
|
to = from;
|
to = from;
|
|
|
/* The only thing we allow as value numbers are VN_TOP, ssa_names
|
/* The only thing we allow as value numbers are VN_TOP, ssa_names
|
and invariants. So assert that here. */
|
and invariants. So assert that here. */
|
gcc_assert (to != NULL_TREE
|
gcc_assert (to != NULL_TREE
|
&& (to == VN_TOP
|
&& (to == VN_TOP
|
|| TREE_CODE (to) == SSA_NAME
|
|| TREE_CODE (to) == SSA_NAME
|
|| is_gimple_min_invariant (to)));
|
|| is_gimple_min_invariant (to)));
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Setting value number of ");
|
fprintf (dump_file, "Setting value number of ");
|
print_generic_expr (dump_file, from, 0);
|
print_generic_expr (dump_file, from, 0);
|
fprintf (dump_file, " to ");
|
fprintf (dump_file, " to ");
|
print_generic_expr (dump_file, to, 0);
|
print_generic_expr (dump_file, to, 0);
|
}
|
}
|
|
|
currval = SSA_VAL (from);
|
currval = SSA_VAL (from);
|
|
|
if (currval != to && !operand_equal_p (currval, to, OEP_PURE_SAME))
|
if (currval != to && !operand_equal_p (currval, to, OEP_PURE_SAME))
|
{
|
{
|
VN_INFO (from)->valnum = to;
|
VN_INFO (from)->valnum = to;
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " (changed)\n");
|
fprintf (dump_file, " (changed)\n");
|
return true;
|
return true;
|
}
|
}
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Set all definitions in STMT to value number to themselves.
|
/* Set all definitions in STMT to value number to themselves.
|
Return true if a value number changed. */
|
Return true if a value number changed. */
|
|
|
static bool
|
static bool
|
defs_to_varying (gimple stmt)
|
defs_to_varying (gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
def_operand_p defp;
|
def_operand_p defp;
|
|
|
FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_ALL_DEFS)
|
FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_ALL_DEFS)
|
{
|
{
|
tree def = DEF_FROM_PTR (defp);
|
tree def = DEF_FROM_PTR (defp);
|
|
|
VN_INFO (def)->use_processed = true;
|
VN_INFO (def)->use_processed = true;
|
changed |= set_ssa_val_to (def, def);
|
changed |= set_ssa_val_to (def, def);
|
}
|
}
|
return changed;
|
return changed;
|
}
|
}
|
|
|
static bool expr_has_constants (tree expr);
|
static bool expr_has_constants (tree expr);
|
static tree valueize_expr (tree expr);
|
static tree valueize_expr (tree expr);
|
|
|
/* Visit a copy between LHS and RHS, return true if the value number
|
/* Visit a copy between LHS and RHS, return true if the value number
|
changed. */
|
changed. */
|
|
|
static bool
|
static bool
|
visit_copy (tree lhs, tree rhs)
|
visit_copy (tree lhs, tree rhs)
|
{
|
{
|
/* Follow chains of copies to their destination. */
|
/* Follow chains of copies to their destination. */
|
while (TREE_CODE (rhs) == SSA_NAME
|
while (TREE_CODE (rhs) == SSA_NAME
|
&& SSA_VAL (rhs) != rhs)
|
&& SSA_VAL (rhs) != rhs)
|
rhs = SSA_VAL (rhs);
|
rhs = SSA_VAL (rhs);
|
|
|
/* The copy may have a more interesting constant filled expression
|
/* The copy may have a more interesting constant filled expression
|
(we don't, since we know our RHS is just an SSA name). */
|
(we don't, since we know our RHS is just an SSA name). */
|
if (TREE_CODE (rhs) == SSA_NAME)
|
if (TREE_CODE (rhs) == SSA_NAME)
|
{
|
{
|
VN_INFO (lhs)->has_constants = VN_INFO (rhs)->has_constants;
|
VN_INFO (lhs)->has_constants = VN_INFO (rhs)->has_constants;
|
VN_INFO (lhs)->expr = VN_INFO (rhs)->expr;
|
VN_INFO (lhs)->expr = VN_INFO (rhs)->expr;
|
}
|
}
|
|
|
return set_ssa_val_to (lhs, rhs);
|
return set_ssa_val_to (lhs, rhs);
|
}
|
}
|
|
|
/* Visit a unary operator RHS, value number it, and return true if the
|
/* Visit a unary operator RHS, value number it, and return true if the
|
value number of LHS has changed as a result. */
|
value number of LHS has changed as a result. */
|
|
|
static bool
|
static bool
|
visit_unary_op (tree lhs, gimple stmt)
|
visit_unary_op (tree lhs, gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
tree result = vn_nary_op_lookup_stmt (stmt, NULL);
|
tree result = vn_nary_op_lookup_stmt (stmt, NULL);
|
|
|
if (result)
|
if (result)
|
{
|
{
|
changed = set_ssa_val_to (lhs, result);
|
changed = set_ssa_val_to (lhs, result);
|
}
|
}
|
else
|
else
|
{
|
{
|
changed = set_ssa_val_to (lhs, lhs);
|
changed = set_ssa_val_to (lhs, lhs);
|
vn_nary_op_insert_stmt (stmt, lhs);
|
vn_nary_op_insert_stmt (stmt, lhs);
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Visit a binary operator RHS, value number it, and return true if the
|
/* Visit a binary operator RHS, value number it, and return true if the
|
value number of LHS has changed as a result. */
|
value number of LHS has changed as a result. */
|
|
|
static bool
|
static bool
|
visit_binary_op (tree lhs, gimple stmt)
|
visit_binary_op (tree lhs, gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
tree result = vn_nary_op_lookup_stmt (stmt, NULL);
|
tree result = vn_nary_op_lookup_stmt (stmt, NULL);
|
|
|
if (result)
|
if (result)
|
{
|
{
|
changed = set_ssa_val_to (lhs, result);
|
changed = set_ssa_val_to (lhs, result);
|
}
|
}
|
else
|
else
|
{
|
{
|
changed = set_ssa_val_to (lhs, lhs);
|
changed = set_ssa_val_to (lhs, lhs);
|
vn_nary_op_insert_stmt (stmt, lhs);
|
vn_nary_op_insert_stmt (stmt, lhs);
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Visit a call STMT storing into LHS. Return true if the value number
|
/* Visit a call STMT storing into LHS. Return true if the value number
|
of the LHS has changed as a result. */
|
of the LHS has changed as a result. */
|
|
|
static bool
|
static bool
|
visit_reference_op_call (tree lhs, gimple stmt)
|
visit_reference_op_call (tree lhs, gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
struct vn_reference_s vr1;
|
struct vn_reference_s vr1;
|
tree result;
|
tree result;
|
tree vuse = gimple_vuse (stmt);
|
tree vuse = gimple_vuse (stmt);
|
|
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
|
vr1.operands = valueize_shared_reference_ops_from_call (stmt);
|
vr1.operands = valueize_shared_reference_ops_from_call (stmt);
|
vr1.type = gimple_expr_type (stmt);
|
vr1.type = gimple_expr_type (stmt);
|
vr1.set = 0;
|
vr1.set = 0;
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
vr1.hashcode = vn_reference_compute_hash (&vr1);
|
result = vn_reference_lookup_1 (&vr1, NULL);
|
result = vn_reference_lookup_1 (&vr1, NULL);
|
if (result)
|
if (result)
|
{
|
{
|
changed = set_ssa_val_to (lhs, result);
|
changed = set_ssa_val_to (lhs, result);
|
if (TREE_CODE (result) == SSA_NAME
|
if (TREE_CODE (result) == SSA_NAME
|
&& VN_INFO (result)->has_constants)
|
&& VN_INFO (result)->has_constants)
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
void **slot;
|
void **slot;
|
vn_reference_t vr2;
|
vn_reference_t vr2;
|
changed = set_ssa_val_to (lhs, lhs);
|
changed = set_ssa_val_to (lhs, lhs);
|
vr2 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
vr2 = (vn_reference_t) pool_alloc (current_info->references_pool);
|
vr2->vuse = vr1.vuse;
|
vr2->vuse = vr1.vuse;
|
vr2->operands = valueize_refs (create_reference_ops_from_call (stmt));
|
vr2->operands = valueize_refs (create_reference_ops_from_call (stmt));
|
vr2->type = vr1.type;
|
vr2->type = vr1.type;
|
vr2->set = vr1.set;
|
vr2->set = vr1.set;
|
vr2->hashcode = vr1.hashcode;
|
vr2->hashcode = vr1.hashcode;
|
vr2->result = lhs;
|
vr2->result = lhs;
|
slot = htab_find_slot_with_hash (current_info->references,
|
slot = htab_find_slot_with_hash (current_info->references,
|
vr2, vr2->hashcode, INSERT);
|
vr2, vr2->hashcode, INSERT);
|
if (*slot)
|
if (*slot)
|
free_reference (*slot);
|
free_reference (*slot);
|
*slot = vr2;
|
*slot = vr2;
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Visit a load from a reference operator RHS, part of STMT, value number it,
|
/* 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. */
|
and return true if the value number of the LHS has changed as a result. */
|
|
|
static bool
|
static bool
|
visit_reference_op_load (tree lhs, tree op, gimple stmt)
|
visit_reference_op_load (tree lhs, tree op, gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
tree last_vuse;
|
tree last_vuse;
|
tree result;
|
tree result;
|
|
|
last_vuse = gimple_vuse (stmt);
|
last_vuse = gimple_vuse (stmt);
|
last_vuse_ptr = &last_vuse;
|
last_vuse_ptr = &last_vuse;
|
result = vn_reference_lookup (op, gimple_vuse (stmt), true, NULL);
|
result = vn_reference_lookup (op, gimple_vuse (stmt), true, NULL);
|
last_vuse_ptr = NULL;
|
last_vuse_ptr = NULL;
|
|
|
/* If we have a VCE, try looking up its operand as it might be stored in
|
/* If we have a VCE, try looking up its operand as it might be stored in
|
a different type. */
|
a different type. */
|
if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
|
if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
|
result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
|
result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
|
true, NULL);
|
true, NULL);
|
|
|
/* We handle type-punning through unions by value-numbering based
|
/* We handle type-punning through unions by value-numbering based
|
on offset and size of the access. Be prepared to handle a
|
on offset and size of the access. Be prepared to handle a
|
type-mismatch here via creating a VIEW_CONVERT_EXPR. */
|
type-mismatch here via creating a VIEW_CONVERT_EXPR. */
|
if (result
|
if (result
|
&& !useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (op)))
|
&& !useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (op)))
|
{
|
{
|
/* We will be setting the value number of lhs to the value number
|
/* We will be setting the value number of lhs to the value number
|
of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
|
of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
|
So first simplify and lookup this expression to see if it
|
So first simplify and lookup this expression to see if it
|
is already available. */
|
is already available. */
|
tree val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (op), result);
|
tree val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (op), result);
|
if ((CONVERT_EXPR_P (val)
|
if ((CONVERT_EXPR_P (val)
|
|| TREE_CODE (val) == VIEW_CONVERT_EXPR)
|
|| TREE_CODE (val) == VIEW_CONVERT_EXPR)
|
&& TREE_CODE (TREE_OPERAND (val, 0)) == SSA_NAME)
|
&& TREE_CODE (TREE_OPERAND (val, 0)) == SSA_NAME)
|
{
|
{
|
tree tem = valueize_expr (vn_get_expr_for (TREE_OPERAND (val, 0)));
|
tree tem = valueize_expr (vn_get_expr_for (TREE_OPERAND (val, 0)));
|
if ((CONVERT_EXPR_P (tem)
|
if ((CONVERT_EXPR_P (tem)
|
|| TREE_CODE (tem) == VIEW_CONVERT_EXPR)
|
|| TREE_CODE (tem) == VIEW_CONVERT_EXPR)
|
&& (tem = fold_unary_ignore_overflow (TREE_CODE (val),
|
&& (tem = fold_unary_ignore_overflow (TREE_CODE (val),
|
TREE_TYPE (val), tem)))
|
TREE_TYPE (val), tem)))
|
val = tem;
|
val = tem;
|
}
|
}
|
result = val;
|
result = val;
|
if (!is_gimple_min_invariant (val)
|
if (!is_gimple_min_invariant (val)
|
&& TREE_CODE (val) != SSA_NAME)
|
&& TREE_CODE (val) != SSA_NAME)
|
result = vn_nary_op_lookup (val, NULL);
|
result = vn_nary_op_lookup (val, NULL);
|
/* If the expression is not yet available, value-number lhs to
|
/* If the expression is not yet available, value-number lhs to
|
a new SSA_NAME we create. */
|
a new SSA_NAME we create. */
|
if (!result && may_insert)
|
if (!result && may_insert)
|
{
|
{
|
result = make_ssa_name (SSA_NAME_VAR (lhs), NULL);
|
result = make_ssa_name (SSA_NAME_VAR (lhs), NULL);
|
/* Initialize value-number information properly. */
|
/* Initialize value-number information properly. */
|
VN_INFO_GET (result)->valnum = result;
|
VN_INFO_GET (result)->valnum = result;
|
VN_INFO (result)->value_id = get_next_value_id ();
|
VN_INFO (result)->value_id = get_next_value_id ();
|
VN_INFO (result)->expr = val;
|
VN_INFO (result)->expr = val;
|
VN_INFO (result)->has_constants = expr_has_constants (val);
|
VN_INFO (result)->has_constants = expr_has_constants (val);
|
VN_INFO (result)->needs_insertion = true;
|
VN_INFO (result)->needs_insertion = true;
|
/* As all "inserted" statements are singleton SCCs, insert
|
/* As all "inserted" statements are singleton SCCs, insert
|
to the valid table. This is strictly needed to
|
to the valid table. This is strictly needed to
|
avoid re-generating new value SSA_NAMEs for the same
|
avoid re-generating new value SSA_NAMEs for the same
|
expression during SCC iteration over and over (the
|
expression during SCC iteration over and over (the
|
optimistic table gets cleared after each iteration).
|
optimistic table gets cleared after each iteration).
|
We do not need to insert into the optimistic table, as
|
We do not need to insert into the optimistic table, as
|
lookups there will fall back to the valid table. */
|
lookups there will fall back to the valid table. */
|
if (current_info == optimistic_info)
|
if (current_info == optimistic_info)
|
{
|
{
|
current_info = valid_info;
|
current_info = valid_info;
|
vn_nary_op_insert (val, result);
|
vn_nary_op_insert (val, result);
|
current_info = optimistic_info;
|
current_info = optimistic_info;
|
}
|
}
|
else
|
else
|
vn_nary_op_insert (val, result);
|
vn_nary_op_insert (val, result);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Inserting name ");
|
fprintf (dump_file, "Inserting name ");
|
print_generic_expr (dump_file, result, 0);
|
print_generic_expr (dump_file, result, 0);
|
fprintf (dump_file, " for expression ");
|
fprintf (dump_file, " for expression ");
|
print_generic_expr (dump_file, val, 0);
|
print_generic_expr (dump_file, val, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (result)
|
if (result)
|
{
|
{
|
changed = set_ssa_val_to (lhs, result);
|
changed = set_ssa_val_to (lhs, result);
|
if (TREE_CODE (result) == SSA_NAME
|
if (TREE_CODE (result) == SSA_NAME
|
&& VN_INFO (result)->has_constants)
|
&& VN_INFO (result)->has_constants)
|
{
|
{
|
VN_INFO (lhs)->expr = VN_INFO (result)->expr;
|
VN_INFO (lhs)->expr = VN_INFO (result)->expr;
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
changed = set_ssa_val_to (lhs, lhs);
|
changed = set_ssa_val_to (lhs, lhs);
|
vn_reference_insert (op, lhs, last_vuse);
|
vn_reference_insert (op, lhs, last_vuse);
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
|
|
/* Visit a store to a reference operator LHS, part of STMT, value number it,
|
/* 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. */
|
and return true if the value number of the LHS has changed as a result. */
|
|
|
static bool
|
static bool
|
visit_reference_op_store (tree lhs, tree op, gimple stmt)
|
visit_reference_op_store (tree lhs, tree op, gimple stmt)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
tree result;
|
tree result;
|
bool resultsame = false;
|
bool resultsame = false;
|
|
|
/* First we want to lookup using the *vuses* from the store and see
|
/* 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
|
if there the last store to this location with the same address
|
had the same value.
|
had the same value.
|
|
|
The vuses represent the memory state before the store. If the
|
The vuses represent the memory state before the store. If the
|
memory state, address, and value of the store is the same as 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
|
last store to this location, then this store will produce the
|
same memory state as that store.
|
same memory state as that store.
|
|
|
In this case the vdef versions for this store are value numbered to those
|
In this case the vdef versions for this store are value numbered to those
|
vuse versions, since they represent the same memory state after
|
vuse versions, since they represent the same memory state after
|
this store.
|
this store.
|
|
|
Otherwise, the vdefs for the store are used when inserting into
|
Otherwise, the vdefs for the store are used when inserting into
|
the table, since the store generates a new memory state. */
|
the table, since the store generates a new memory state. */
|
|
|
result = vn_reference_lookup (lhs, gimple_vuse (stmt), false, NULL);
|
result = vn_reference_lookup (lhs, gimple_vuse (stmt), false, NULL);
|
|
|
if (result)
|
if (result)
|
{
|
{
|
if (TREE_CODE (result) == SSA_NAME)
|
if (TREE_CODE (result) == SSA_NAME)
|
result = SSA_VAL (result);
|
result = SSA_VAL (result);
|
if (TREE_CODE (op) == SSA_NAME)
|
if (TREE_CODE (op) == SSA_NAME)
|
op = SSA_VAL (op);
|
op = SSA_VAL (op);
|
resultsame = expressions_equal_p (result, op);
|
resultsame = expressions_equal_p (result, op);
|
}
|
}
|
|
|
if (!result || !resultsame)
|
if (!result || !resultsame)
|
{
|
{
|
tree vdef;
|
tree vdef;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "No store match\n");
|
fprintf (dump_file, "No store match\n");
|
fprintf (dump_file, "Value numbering store ");
|
fprintf (dump_file, "Value numbering store ");
|
print_generic_expr (dump_file, lhs, 0);
|
print_generic_expr (dump_file, lhs, 0);
|
fprintf (dump_file, " to ");
|
fprintf (dump_file, " to ");
|
print_generic_expr (dump_file, op, 0);
|
print_generic_expr (dump_file, op, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
/* Have to set value numbers before insert, since insert is
|
/* Have to set value numbers before insert, since insert is
|
going to valueize the references in-place. */
|
going to valueize the references in-place. */
|
if ((vdef = gimple_vdef (stmt)))
|
if ((vdef = gimple_vdef (stmt)))
|
{
|
{
|
VN_INFO (vdef)->use_processed = true;
|
VN_INFO (vdef)->use_processed = true;
|
changed |= set_ssa_val_to (vdef, vdef);
|
changed |= set_ssa_val_to (vdef, vdef);
|
}
|
}
|
|
|
/* Do not insert structure copies into the tables. */
|
/* Do not insert structure copies into the tables. */
|
if (is_gimple_min_invariant (op)
|
if (is_gimple_min_invariant (op)
|
|| is_gimple_reg (op))
|
|| is_gimple_reg (op))
|
vn_reference_insert (lhs, op, vdef);
|
vn_reference_insert (lhs, op, vdef);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We had a match, so value number the vdef to have the value
|
/* We had a match, so value number the vdef to have the value
|
number of the vuse it came from. */
|
number of the vuse it came from. */
|
tree def, use;
|
tree def, use;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Store matched earlier value,"
|
fprintf (dump_file, "Store matched earlier value,"
|
"value numbering store vdefs to matching vuses.\n");
|
"value numbering store vdefs to matching vuses.\n");
|
|
|
def = gimple_vdef (stmt);
|
def = gimple_vdef (stmt);
|
use = gimple_vuse (stmt);
|
use = gimple_vuse (stmt);
|
|
|
VN_INFO (def)->use_processed = true;
|
VN_INFO (def)->use_processed = true;
|
changed |= set_ssa_val_to (def, SSA_VAL (use));
|
changed |= set_ssa_val_to (def, SSA_VAL (use));
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Visit and value number PHI, return true if the value number
|
/* Visit and value number PHI, return true if the value number
|
changed. */
|
changed. */
|
|
|
static bool
|
static bool
|
visit_phi (gimple phi)
|
visit_phi (gimple phi)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
tree result;
|
tree result;
|
tree sameval = VN_TOP;
|
tree sameval = VN_TOP;
|
bool allsame = true;
|
bool allsame = true;
|
unsigned i;
|
unsigned i;
|
|
|
/* TODO: We could check for this in init_sccvn, and replace this
|
/* TODO: We could check for this in init_sccvn, and replace this
|
with a gcc_assert. */
|
with a gcc_assert. */
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)))
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)))
|
return set_ssa_val_to (PHI_RESULT (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
|
/* See if all non-TOP arguments have the same value. TOP is
|
equivalent to everything, so we can ignore it. */
|
equivalent to everything, so we can ignore it. */
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
for (i = 0; i < gimple_phi_num_args (phi); i++)
|
{
|
{
|
tree def = PHI_ARG_DEF (phi, i);
|
tree def = PHI_ARG_DEF (phi, i);
|
|
|
if (TREE_CODE (def) == SSA_NAME)
|
if (TREE_CODE (def) == SSA_NAME)
|
def = SSA_VAL (def);
|
def = SSA_VAL (def);
|
if (def == VN_TOP)
|
if (def == VN_TOP)
|
continue;
|
continue;
|
if (sameval == VN_TOP)
|
if (sameval == VN_TOP)
|
{
|
{
|
sameval = def;
|
sameval = def;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (!expressions_equal_p (def, sameval))
|
if (!expressions_equal_p (def, sameval))
|
{
|
{
|
allsame = false;
|
allsame = false;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If all value numbered to the same value, the phi node has that
|
/* If all value numbered to the same value, the phi node has that
|
value. */
|
value. */
|
if (allsame)
|
if (allsame)
|
{
|
{
|
if (is_gimple_min_invariant (sameval))
|
if (is_gimple_min_invariant (sameval))
|
{
|
{
|
VN_INFO (PHI_RESULT (phi))->has_constants = true;
|
VN_INFO (PHI_RESULT (phi))->has_constants = true;
|
VN_INFO (PHI_RESULT (phi))->expr = sameval;
|
VN_INFO (PHI_RESULT (phi))->expr = sameval;
|
}
|
}
|
else
|
else
|
{
|
{
|
VN_INFO (PHI_RESULT (phi))->has_constants = false;
|
VN_INFO (PHI_RESULT (phi))->has_constants = false;
|
VN_INFO (PHI_RESULT (phi))->expr = sameval;
|
VN_INFO (PHI_RESULT (phi))->expr = sameval;
|
}
|
}
|
|
|
if (TREE_CODE (sameval) == SSA_NAME)
|
if (TREE_CODE (sameval) == SSA_NAME)
|
return visit_copy (PHI_RESULT (phi), sameval);
|
return visit_copy (PHI_RESULT (phi), sameval);
|
|
|
return set_ssa_val_to (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. */
|
/* Otherwise, see if it is equivalent to a phi node in this block. */
|
result = vn_phi_lookup (phi);
|
result = vn_phi_lookup (phi);
|
if (result)
|
if (result)
|
{
|
{
|
if (TREE_CODE (result) == SSA_NAME)
|
if (TREE_CODE (result) == SSA_NAME)
|
changed = visit_copy (PHI_RESULT (phi), result);
|
changed = visit_copy (PHI_RESULT (phi), result);
|
else
|
else
|
changed = set_ssa_val_to (PHI_RESULT (phi), result);
|
changed = set_ssa_val_to (PHI_RESULT (phi), result);
|
}
|
}
|
else
|
else
|
{
|
{
|
vn_phi_insert (phi, PHI_RESULT (phi));
|
vn_phi_insert (phi, PHI_RESULT (phi));
|
VN_INFO (PHI_RESULT (phi))->has_constants = false;
|
VN_INFO (PHI_RESULT (phi))->has_constants = false;
|
VN_INFO (PHI_RESULT (phi))->expr = PHI_RESULT (phi);
|
VN_INFO (PHI_RESULT (phi))->expr = PHI_RESULT (phi);
|
changed = set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
|
changed = set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
|
}
|
}
|
|
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Return true if EXPR contains constants. */
|
/* Return true if EXPR contains constants. */
|
|
|
static bool
|
static bool
|
expr_has_constants (tree expr)
|
expr_has_constants (tree expr)
|
{
|
{
|
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
|
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
|
{
|
{
|
case tcc_unary:
|
case tcc_unary:
|
return is_gimple_min_invariant (TREE_OPERAND (expr, 0));
|
return is_gimple_min_invariant (TREE_OPERAND (expr, 0));
|
|
|
case tcc_binary:
|
case tcc_binary:
|
return is_gimple_min_invariant (TREE_OPERAND (expr, 0))
|
return is_gimple_min_invariant (TREE_OPERAND (expr, 0))
|
|| is_gimple_min_invariant (TREE_OPERAND (expr, 1));
|
|| is_gimple_min_invariant (TREE_OPERAND (expr, 1));
|
/* Constants inside reference ops are rarely interesting, but
|
/* Constants inside reference ops are rarely interesting, but
|
it can take a lot of looking to find them. */
|
it can take a lot of looking to find them. */
|
case tcc_reference:
|
case tcc_reference:
|
case tcc_declaration:
|
case tcc_declaration:
|
return false;
|
return false;
|
default:
|
default:
|
return is_gimple_min_invariant (expr);
|
return is_gimple_min_invariant (expr);
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if STMT contains constants. */
|
/* Return true if STMT contains constants. */
|
|
|
static bool
|
static bool
|
stmt_has_constants (gimple stmt)
|
stmt_has_constants (gimple stmt)
|
{
|
{
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (stmt) != GIMPLE_ASSIGN)
|
return false;
|
return false;
|
|
|
switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
|
switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
|
{
|
{
|
case GIMPLE_UNARY_RHS:
|
case GIMPLE_UNARY_RHS:
|
return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
|
return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
|
|
|
case GIMPLE_BINARY_RHS:
|
case GIMPLE_BINARY_RHS:
|
return (is_gimple_min_invariant (gimple_assign_rhs1 (stmt))
|
return (is_gimple_min_invariant (gimple_assign_rhs1 (stmt))
|
|| is_gimple_min_invariant (gimple_assign_rhs2 (stmt)));
|
|| is_gimple_min_invariant (gimple_assign_rhs2 (stmt)));
|
case GIMPLE_SINGLE_RHS:
|
case GIMPLE_SINGLE_RHS:
|
/* Constants inside reference ops are rarely interesting, but
|
/* Constants inside reference ops are rarely interesting, but
|
it can take a lot of looking to find them. */
|
it can take a lot of looking to find them. */
|
return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
|
return is_gimple_min_invariant (gimple_assign_rhs1 (stmt));
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Replace SSA_NAMES in expr with their value numbers, and return the
|
/* Replace SSA_NAMES in expr with their value numbers, and return the
|
result.
|
result.
|
This is performed in place. */
|
This is performed in place. */
|
|
|
static tree
|
static tree
|
valueize_expr (tree expr)
|
valueize_expr (tree expr)
|
{
|
{
|
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
|
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
|
{
|
{
|
case tcc_unary:
|
case tcc_unary:
|
if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
&& SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
|
&& SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
|
TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
|
TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
|
break;
|
break;
|
case tcc_binary:
|
case tcc_binary:
|
if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
&& SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
|
&& SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
|
TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
|
TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
|
if (TREE_CODE (TREE_OPERAND (expr, 1)) == SSA_NAME
|
if (TREE_CODE (TREE_OPERAND (expr, 1)) == SSA_NAME
|
&& SSA_VAL (TREE_OPERAND (expr, 1)) != VN_TOP)
|
&& SSA_VAL (TREE_OPERAND (expr, 1)) != VN_TOP)
|
TREE_OPERAND (expr, 1) = SSA_VAL (TREE_OPERAND (expr, 1));
|
TREE_OPERAND (expr, 1) = SSA_VAL (TREE_OPERAND (expr, 1));
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return expr;
|
return expr;
|
}
|
}
|
|
|
/* Simplify the binary expression RHS, and return the result if
|
/* Simplify the binary expression RHS, and return the result if
|
simplified. */
|
simplified. */
|
|
|
static tree
|
static tree
|
simplify_binary_expression (gimple stmt)
|
simplify_binary_expression (gimple stmt)
|
{
|
{
|
tree result = NULL_TREE;
|
tree result = NULL_TREE;
|
tree op0 = gimple_assign_rhs1 (stmt);
|
tree op0 = gimple_assign_rhs1 (stmt);
|
tree op1 = gimple_assign_rhs2 (stmt);
|
tree op1 = gimple_assign_rhs2 (stmt);
|
|
|
/* This will not catch every single case we could combine, but will
|
/* This will not catch every single case we could combine, but will
|
catch those with constants. The goal here is to simultaneously
|
catch those with constants. The goal here is to simultaneously
|
combine constants between expressions, but avoid infinite
|
combine constants between expressions, but avoid infinite
|
expansion of expressions during simplification. */
|
expansion of expressions during simplification. */
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
{
|
{
|
if (VN_INFO (op0)->has_constants
|
if (VN_INFO (op0)->has_constants
|
|| TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
|
|| TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
|
op0 = valueize_expr (vn_get_expr_for (op0));
|
op0 = valueize_expr (vn_get_expr_for (op0));
|
else if (SSA_VAL (op0) != VN_TOP && SSA_VAL (op0) != op0)
|
else if (SSA_VAL (op0) != VN_TOP && SSA_VAL (op0) != op0)
|
op0 = SSA_VAL (op0);
|
op0 = SSA_VAL (op0);
|
}
|
}
|
|
|
if (TREE_CODE (op1) == SSA_NAME)
|
if (TREE_CODE (op1) == SSA_NAME)
|
{
|
{
|
if (VN_INFO (op1)->has_constants)
|
if (VN_INFO (op1)->has_constants)
|
op1 = valueize_expr (vn_get_expr_for (op1));
|
op1 = valueize_expr (vn_get_expr_for (op1));
|
else if (SSA_VAL (op1) != VN_TOP && SSA_VAL (op1) != op1)
|
else if (SSA_VAL (op1) != VN_TOP && SSA_VAL (op1) != op1)
|
op1 = SSA_VAL (op1);
|
op1 = SSA_VAL (op1);
|
}
|
}
|
|
|
/* Avoid folding if nothing changed. */
|
/* Avoid folding if nothing changed. */
|
if (op0 == gimple_assign_rhs1 (stmt)
|
if (op0 == gimple_assign_rhs1 (stmt)
|
&& op1 == gimple_assign_rhs2 (stmt))
|
&& op1 == gimple_assign_rhs2 (stmt))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
fold_defer_overflow_warnings ();
|
fold_defer_overflow_warnings ();
|
|
|
result = fold_binary (gimple_assign_rhs_code (stmt),
|
result = fold_binary (gimple_assign_rhs_code (stmt),
|
gimple_expr_type (stmt), op0, op1);
|
gimple_expr_type (stmt), op0, op1);
|
if (result)
|
if (result)
|
STRIP_USELESS_TYPE_CONVERSION (result);
|
STRIP_USELESS_TYPE_CONVERSION (result);
|
|
|
fold_undefer_overflow_warnings (result && valid_gimple_rhs_p (result),
|
fold_undefer_overflow_warnings (result && valid_gimple_rhs_p (result),
|
stmt, 0);
|
stmt, 0);
|
|
|
/* Make sure result is not a complex expression consisting
|
/* Make sure result is not a complex expression consisting
|
of operators of operators (IE (a + b) + (a + c))
|
of operators of operators (IE (a + b) + (a + c))
|
Otherwise, we will end up with unbounded expressions if
|
Otherwise, we will end up with unbounded expressions if
|
fold does anything at all. */
|
fold does anything at all. */
|
if (result && valid_gimple_rhs_p (result))
|
if (result && valid_gimple_rhs_p (result))
|
return result;
|
return result;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Simplify the unary expression RHS, and return the result if
|
/* Simplify the unary expression RHS, and return the result if
|
simplified. */
|
simplified. */
|
|
|
static tree
|
static tree
|
simplify_unary_expression (gimple stmt)
|
simplify_unary_expression (gimple stmt)
|
{
|
{
|
tree result = NULL_TREE;
|
tree result = NULL_TREE;
|
tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
|
tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
|
|
|
/* We handle some tcc_reference codes here that are all
|
/* We handle some tcc_reference codes here that are all
|
GIMPLE_ASSIGN_SINGLE codes. */
|
GIMPLE_ASSIGN_SINGLE codes. */
|
if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
|
op0 = TREE_OPERAND (op0, 0);
|
op0 = TREE_OPERAND (op0, 0);
|
|
|
if (TREE_CODE (op0) != SSA_NAME)
|
if (TREE_CODE (op0) != SSA_NAME)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
orig_op0 = op0;
|
orig_op0 = op0;
|
if (VN_INFO (op0)->has_constants)
|
if (VN_INFO (op0)->has_constants)
|
op0 = valueize_expr (vn_get_expr_for (op0));
|
op0 = valueize_expr (vn_get_expr_for (op0));
|
else if (gimple_assign_cast_p (stmt)
|
else if (gimple_assign_cast_p (stmt)
|
|| gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
|
{
|
{
|
/* We want to do tree-combining on conversion-like expressions.
|
/* We want to do tree-combining on conversion-like expressions.
|
Make sure we feed only SSA_NAMEs or constants to fold though. */
|
Make sure we feed only SSA_NAMEs or constants to fold though. */
|
tree tem = valueize_expr (vn_get_expr_for (op0));
|
tree tem = valueize_expr (vn_get_expr_for (op0));
|
if (UNARY_CLASS_P (tem)
|
if (UNARY_CLASS_P (tem)
|
|| BINARY_CLASS_P (tem)
|
|| BINARY_CLASS_P (tem)
|
|| TREE_CODE (tem) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (tem) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (tem) == SSA_NAME
|
|| TREE_CODE (tem) == SSA_NAME
|
|| is_gimple_min_invariant (tem))
|
|| is_gimple_min_invariant (tem))
|
op0 = tem;
|
op0 = tem;
|
}
|
}
|
|
|
/* Avoid folding if nothing changed, but remember the expression. */
|
/* Avoid folding if nothing changed, but remember the expression. */
|
if (op0 == orig_op0)
|
if (op0 == orig_op0)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
result = fold_unary_ignore_overflow (gimple_assign_rhs_code (stmt),
|
result = fold_unary_ignore_overflow (gimple_assign_rhs_code (stmt),
|
gimple_expr_type (stmt), op0);
|
gimple_expr_type (stmt), op0);
|
if (result)
|
if (result)
|
{
|
{
|
STRIP_USELESS_TYPE_CONVERSION (result);
|
STRIP_USELESS_TYPE_CONVERSION (result);
|
if (valid_gimple_rhs_p (result))
|
if (valid_gimple_rhs_p (result))
|
return result;
|
return result;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Try to simplify RHS using equivalences and constant folding. */
|
/* Try to simplify RHS using equivalences and constant folding. */
|
|
|
static tree
|
static tree
|
try_to_simplify (gimple stmt)
|
try_to_simplify (gimple stmt)
|
{
|
{
|
tree tem;
|
tree tem;
|
|
|
/* For stores we can end up simplifying a SSA_NAME rhs. Just return
|
/* For stores we can end up simplifying a SSA_NAME rhs. Just return
|
in this case, there is no point in doing extra work. */
|
in this case, there is no point in doing extra work. */
|
if (gimple_assign_copy_p (stmt)
|
if (gimple_assign_copy_p (stmt)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
{
|
{
|
case tcc_declaration:
|
case tcc_declaration:
|
tem = get_symbol_constant_value (gimple_assign_rhs1 (stmt));
|
tem = get_symbol_constant_value (gimple_assign_rhs1 (stmt));
|
if (tem)
|
if (tem)
|
return tem;
|
return tem;
|
break;
|
break;
|
|
|
case tcc_reference:
|
case tcc_reference:
|
/* Do not do full-blown reference lookup here, but simplify
|
/* Do not do full-blown reference lookup here, but simplify
|
reads from constant aggregates. */
|
reads from constant aggregates. */
|
tem = fold_const_aggregate_ref (gimple_assign_rhs1 (stmt));
|
tem = fold_const_aggregate_ref (gimple_assign_rhs1 (stmt));
|
if (tem)
|
if (tem)
|
return tem;
|
return tem;
|
|
|
/* Fallthrough for some codes that can operate on registers. */
|
/* Fallthrough for some codes that can operate on registers. */
|
if (!(TREE_CODE (gimple_assign_rhs1 (stmt)) == REALPART_EXPR
|
if (!(TREE_CODE (gimple_assign_rhs1 (stmt)) == REALPART_EXPR
|
|| TREE_CODE (gimple_assign_rhs1 (stmt)) == IMAGPART_EXPR
|
|| TREE_CODE (gimple_assign_rhs1 (stmt)) == IMAGPART_EXPR
|
|| TREE_CODE (gimple_assign_rhs1 (stmt)) == VIEW_CONVERT_EXPR))
|
|| TREE_CODE (gimple_assign_rhs1 (stmt)) == VIEW_CONVERT_EXPR))
|
break;
|
break;
|
/* We could do a little more with unary ops, if they expand
|
/* We could do a little more with unary ops, if they expand
|
into binary ops, but it's debatable whether it is worth it. */
|
into binary ops, but it's debatable whether it is worth it. */
|
case tcc_unary:
|
case tcc_unary:
|
return simplify_unary_expression (stmt);
|
return simplify_unary_expression (stmt);
|
break;
|
break;
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_binary:
|
case tcc_binary:
|
return simplify_binary_expression (stmt);
|
return simplify_binary_expression (stmt);
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Visit and value number USE, return true if the value number
|
/* Visit and value number USE, return true if the value number
|
changed. */
|
changed. */
|
|
|
static bool
|
static bool
|
visit_use (tree use)
|
visit_use (tree use)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
gimple stmt = SSA_NAME_DEF_STMT (use);
|
gimple stmt = SSA_NAME_DEF_STMT (use);
|
|
|
VN_INFO (use)->use_processed = true;
|
VN_INFO (use)->use_processed = true;
|
|
|
gcc_assert (!SSA_NAME_IN_FREE_LIST (use));
|
gcc_assert (!SSA_NAME_IN_FREE_LIST (use));
|
if (dump_file && (dump_flags & TDF_DETAILS)
|
if (dump_file && (dump_flags & TDF_DETAILS)
|
&& !SSA_NAME_IS_DEFAULT_DEF (use))
|
&& !SSA_NAME_IS_DEFAULT_DEF (use))
|
{
|
{
|
fprintf (dump_file, "Value numbering ");
|
fprintf (dump_file, "Value numbering ");
|
print_generic_expr (dump_file, use, 0);
|
print_generic_expr (dump_file, use, 0);
|
fprintf (dump_file, " stmt = ");
|
fprintf (dump_file, " stmt = ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
}
|
}
|
|
|
/* Handle uninitialized uses. */
|
/* Handle uninitialized uses. */
|
if (SSA_NAME_IS_DEFAULT_DEF (use))
|
if (SSA_NAME_IS_DEFAULT_DEF (use))
|
changed = set_ssa_val_to (use, use);
|
changed = set_ssa_val_to (use, use);
|
else
|
else
|
{
|
{
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
if (gimple_code (stmt) == GIMPLE_PHI)
|
changed = visit_phi (stmt);
|
changed = visit_phi (stmt);
|
else if (!gimple_has_lhs (stmt)
|
else if (!gimple_has_lhs (stmt)
|
|| gimple_has_volatile_ops (stmt)
|
|| gimple_has_volatile_ops (stmt)
|
|| stmt_could_throw_p (stmt))
|
|| stmt_could_throw_p (stmt))
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
else if (is_gimple_assign (stmt))
|
else if (is_gimple_assign (stmt))
|
{
|
{
|
tree lhs = gimple_assign_lhs (stmt);
|
tree lhs = gimple_assign_lhs (stmt);
|
tree simplified;
|
tree simplified;
|
|
|
/* Shortcut for copies. Simplifying copies is pointless,
|
/* Shortcut for copies. Simplifying copies is pointless,
|
since we copy the expression and value they represent. */
|
since we copy the expression and value they represent. */
|
if (gimple_assign_copy_p (stmt)
|
if (gimple_assign_copy_p (stmt)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
&& TREE_CODE (lhs) == SSA_NAME)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
changed = visit_copy (lhs, gimple_assign_rhs1 (stmt));
|
changed = visit_copy (lhs, gimple_assign_rhs1 (stmt));
|
goto done;
|
goto done;
|
}
|
}
|
simplified = try_to_simplify (stmt);
|
simplified = try_to_simplify (stmt);
|
if (simplified)
|
if (simplified)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "RHS ");
|
fprintf (dump_file, "RHS ");
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
fprintf (dump_file, " simplified to ");
|
fprintf (dump_file, " simplified to ");
|
print_generic_expr (dump_file, simplified, 0);
|
print_generic_expr (dump_file, simplified, 0);
|
if (TREE_CODE (lhs) == SSA_NAME)
|
if (TREE_CODE (lhs) == SSA_NAME)
|
fprintf (dump_file, " has constants %d\n",
|
fprintf (dump_file, " has constants %d\n",
|
expr_has_constants (simplified));
|
expr_has_constants (simplified));
|
else
|
else
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
/* Setting value numbers to constants will occasionally
|
/* Setting value numbers to constants will occasionally
|
screw up phi congruence because constants are not
|
screw up phi congruence because constants are not
|
uniquely associated with a single ssa name that can be
|
uniquely associated with a single ssa name that can be
|
looked up. */
|
looked up. */
|
if (simplified
|
if (simplified
|
&& is_gimple_min_invariant (simplified)
|
&& is_gimple_min_invariant (simplified)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
VN_INFO (lhs)->expr = simplified;
|
VN_INFO (lhs)->expr = simplified;
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
changed = set_ssa_val_to (lhs, simplified);
|
changed = set_ssa_val_to (lhs, simplified);
|
goto done;
|
goto done;
|
}
|
}
|
else if (simplified
|
else if (simplified
|
&& TREE_CODE (simplified) == SSA_NAME
|
&& TREE_CODE (simplified) == SSA_NAME
|
&& TREE_CODE (lhs) == SSA_NAME)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
changed = visit_copy (lhs, simplified);
|
changed = visit_copy (lhs, simplified);
|
goto done;
|
goto done;
|
}
|
}
|
else if (simplified)
|
else if (simplified)
|
{
|
{
|
if (TREE_CODE (lhs) == SSA_NAME)
|
if (TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
VN_INFO (lhs)->has_constants = expr_has_constants (simplified);
|
VN_INFO (lhs)->has_constants = expr_has_constants (simplified);
|
/* We have to unshare the expression or else
|
/* We have to unshare the expression or else
|
valuizing may change the IL stream. */
|
valuizing may change the IL stream. */
|
VN_INFO (lhs)->expr = unshare_expr (simplified);
|
VN_INFO (lhs)->expr = unshare_expr (simplified);
|
}
|
}
|
}
|
}
|
else if (stmt_has_constants (stmt)
|
else if (stmt_has_constants (stmt)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
/* We reset expr and constantness here because we may
|
/* We reset expr and constantness here because we may
|
have been value numbering optimistically, and
|
have been value numbering optimistically, and
|
iterating. They may become non-constant in this case,
|
iterating. They may become non-constant in this case,
|
even if they were optimistically constant. */
|
even if they were optimistically constant. */
|
|
|
VN_INFO (lhs)->has_constants = false;
|
VN_INFO (lhs)->has_constants = false;
|
VN_INFO (lhs)->expr = NULL_TREE;
|
VN_INFO (lhs)->expr = NULL_TREE;
|
}
|
}
|
|
|
if ((TREE_CODE (lhs) == SSA_NAME
|
if ((TREE_CODE (lhs) == SSA_NAME
|
/* We can substitute SSA_NAMEs that are live over
|
/* We can substitute SSA_NAMEs that are live over
|
abnormal edges with their constant value. */
|
abnormal edges with their constant value. */
|
&& !(gimple_assign_copy_p (stmt)
|
&& !(gimple_assign_copy_p (stmt)
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
|
&& !(simplified
|
&& !(simplified
|
&& is_gimple_min_invariant (simplified))
|
&& is_gimple_min_invariant (simplified))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
|
/* Stores or copies from SSA_NAMEs that are live over
|
/* Stores or copies from SSA_NAMEs that are live over
|
abnormal edges are a problem. */
|
abnormal edges are a problem. */
|
|| (gimple_assign_single_p (stmt)
|
|| (gimple_assign_single_p (stmt)
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))))
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
else if (REFERENCE_CLASS_P (lhs) || DECL_P (lhs))
|
else if (REFERENCE_CLASS_P (lhs) || DECL_P (lhs))
|
{
|
{
|
changed = visit_reference_op_store (lhs, gimple_assign_rhs1 (stmt), stmt);
|
changed = visit_reference_op_store (lhs, gimple_assign_rhs1 (stmt), stmt);
|
}
|
}
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
if ((gimple_assign_copy_p (stmt)
|
if ((gimple_assign_copy_p (stmt)
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
|
|| (simplified
|
|| (simplified
|
&& is_gimple_min_invariant (simplified)))
|
&& is_gimple_min_invariant (simplified)))
|
{
|
{
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
if (simplified)
|
if (simplified)
|
changed = set_ssa_val_to (lhs, simplified);
|
changed = set_ssa_val_to (lhs, simplified);
|
else
|
else
|
changed = set_ssa_val_to (lhs, gimple_assign_rhs1 (stmt));
|
changed = set_ssa_val_to (lhs, gimple_assign_rhs1 (stmt));
|
}
|
}
|
else
|
else
|
{
|
{
|
switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
|
switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
|
{
|
{
|
case GIMPLE_UNARY_RHS:
|
case GIMPLE_UNARY_RHS:
|
changed = visit_unary_op (lhs, stmt);
|
changed = visit_unary_op (lhs, stmt);
|
break;
|
break;
|
case GIMPLE_BINARY_RHS:
|
case GIMPLE_BINARY_RHS:
|
changed = visit_binary_op (lhs, stmt);
|
changed = visit_binary_op (lhs, stmt);
|
break;
|
break;
|
case GIMPLE_SINGLE_RHS:
|
case GIMPLE_SINGLE_RHS:
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
{
|
{
|
case tcc_reference:
|
case tcc_reference:
|
/* VOP-less references can go through unary case. */
|
/* VOP-less references can go through unary case. */
|
if ((gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
if ((gimple_assign_rhs_code (stmt) == REALPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR )
|
|| gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR )
|
&& TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == SSA_NAME)
|
&& TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == SSA_NAME)
|
{
|
{
|
changed = visit_unary_op (lhs, stmt);
|
changed = visit_unary_op (lhs, stmt);
|
break;
|
break;
|
}
|
}
|
/* Fallthrough. */
|
/* Fallthrough. */
|
case tcc_declaration:
|
case tcc_declaration:
|
changed = visit_reference_op_load
|
changed = visit_reference_op_load
|
(lhs, gimple_assign_rhs1 (stmt), stmt);
|
(lhs, gimple_assign_rhs1 (stmt), stmt);
|
break;
|
break;
|
case tcc_expression:
|
case tcc_expression:
|
if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
|
if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
|
{
|
{
|
changed = visit_unary_op (lhs, stmt);
|
changed = visit_unary_op (lhs, stmt);
|
break;
|
break;
|
}
|
}
|
/* Fallthrough. */
|
/* Fallthrough. */
|
default:
|
default:
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
}
|
}
|
else if (is_gimple_call (stmt))
|
else if (is_gimple_call (stmt))
|
{
|
{
|
tree lhs = gimple_call_lhs (stmt);
|
tree lhs = gimple_call_lhs (stmt);
|
|
|
/* ??? We could try to simplify calls. */
|
/* ??? We could try to simplify calls. */
|
|
|
if (stmt_has_constants (stmt)
|
if (stmt_has_constants (stmt)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
&& TREE_CODE (lhs) == SSA_NAME)
|
VN_INFO (lhs)->has_constants = true;
|
VN_INFO (lhs)->has_constants = true;
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
/* We reset expr and constantness here because we may
|
/* We reset expr and constantness here because we may
|
have been value numbering optimistically, and
|
have been value numbering optimistically, and
|
iterating. They may become non-constant in this case,
|
iterating. They may become non-constant in this case,
|
even if they were optimistically constant. */
|
even if they were optimistically constant. */
|
VN_INFO (lhs)->has_constants = false;
|
VN_INFO (lhs)->has_constants = false;
|
VN_INFO (lhs)->expr = NULL_TREE;
|
VN_INFO (lhs)->expr = NULL_TREE;
|
}
|
}
|
|
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
/* ??? We should handle stores from calls. */
|
/* ??? We should handle stores from calls. */
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
else if (TREE_CODE (lhs) == SSA_NAME)
|
{
|
{
|
if (gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST))
|
if (gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST))
|
changed = visit_reference_op_call (lhs, stmt);
|
changed = visit_reference_op_call (lhs, stmt);
|
else
|
else
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
}
|
}
|
else
|
else
|
changed = defs_to_varying (stmt);
|
changed = defs_to_varying (stmt);
|
}
|
}
|
}
|
}
|
done:
|
done:
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Compare two operands by reverse postorder index */
|
/* Compare two operands by reverse postorder index */
|
|
|
static int
|
static int
|
compare_ops (const void *pa, const void *pb)
|
compare_ops (const void *pa, const void *pb)
|
{
|
{
|
const tree opa = *((const tree *)pa);
|
const tree opa = *((const tree *)pa);
|
const tree opb = *((const tree *)pb);
|
const tree opb = *((const tree *)pb);
|
gimple opstmta = SSA_NAME_DEF_STMT (opa);
|
gimple opstmta = SSA_NAME_DEF_STMT (opa);
|
gimple opstmtb = SSA_NAME_DEF_STMT (opb);
|
gimple opstmtb = SSA_NAME_DEF_STMT (opb);
|
basic_block bba;
|
basic_block bba;
|
basic_block bbb;
|
basic_block bbb;
|
|
|
if (gimple_nop_p (opstmta) && gimple_nop_p (opstmtb))
|
if (gimple_nop_p (opstmta) && gimple_nop_p (opstmtb))
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
else if (gimple_nop_p (opstmta))
|
else if (gimple_nop_p (opstmta))
|
return -1;
|
return -1;
|
else if (gimple_nop_p (opstmtb))
|
else if (gimple_nop_p (opstmtb))
|
return 1;
|
return 1;
|
|
|
bba = gimple_bb (opstmta);
|
bba = gimple_bb (opstmta);
|
bbb = gimple_bb (opstmtb);
|
bbb = gimple_bb (opstmtb);
|
|
|
if (!bba && !bbb)
|
if (!bba && !bbb)
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
else if (!bba)
|
else if (!bba)
|
return -1;
|
return -1;
|
else if (!bbb)
|
else if (!bbb)
|
return 1;
|
return 1;
|
|
|
if (bba == bbb)
|
if (bba == bbb)
|
{
|
{
|
if (gimple_code (opstmta) == GIMPLE_PHI
|
if (gimple_code (opstmta) == GIMPLE_PHI
|
&& gimple_code (opstmtb) == GIMPLE_PHI)
|
&& gimple_code (opstmtb) == GIMPLE_PHI)
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
else if (gimple_code (opstmta) == GIMPLE_PHI)
|
else if (gimple_code (opstmta) == GIMPLE_PHI)
|
return -1;
|
return -1;
|
else if (gimple_code (opstmtb) == GIMPLE_PHI)
|
else if (gimple_code (opstmtb) == GIMPLE_PHI)
|
return 1;
|
return 1;
|
else if (gimple_uid (opstmta) != gimple_uid (opstmtb))
|
else if (gimple_uid (opstmta) != gimple_uid (opstmtb))
|
return gimple_uid (opstmta) - gimple_uid (opstmtb);
|
return gimple_uid (opstmta) - gimple_uid (opstmtb);
|
else
|
else
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
|
}
|
}
|
return rpo_numbers[bba->index] - rpo_numbers[bbb->index];
|
return rpo_numbers[bba->index] - rpo_numbers[bbb->index];
|
}
|
}
|
|
|
/* Sort an array containing members of a strongly connected component
|
/* Sort an array containing members of a strongly connected component
|
SCC so that the members are ordered by RPO number.
|
SCC so that the members are ordered by RPO number.
|
This means that when the sort is complete, iterating through the
|
This means that when the sort is complete, iterating through the
|
array will give you the members in RPO order. */
|
array will give you the members in RPO order. */
|
|
|
static void
|
static void
|
sort_scc (VEC (tree, heap) *scc)
|
sort_scc (VEC (tree, heap) *scc)
|
{
|
{
|
qsort (VEC_address (tree, scc),
|
qsort (VEC_address (tree, scc),
|
VEC_length (tree, scc),
|
VEC_length (tree, scc),
|
sizeof (tree),
|
sizeof (tree),
|
compare_ops);
|
compare_ops);
|
}
|
}
|
|
|
/* Insert the no longer used nary *ENTRY to the current hash. */
|
/* Insert the no longer used nary *ENTRY to the current hash. */
|
|
|
static int
|
static int
|
copy_nary (void **entry, void *data ATTRIBUTE_UNUSED)
|
copy_nary (void **entry, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
vn_nary_op_t onary = (vn_nary_op_t) *entry;
|
vn_nary_op_t onary = (vn_nary_op_t) *entry;
|
size_t size = (sizeof (struct vn_nary_op_s)
|
size_t size = (sizeof (struct vn_nary_op_s)
|
- sizeof (tree) * (4 - onary->length));
|
- sizeof (tree) * (4 - onary->length));
|
vn_nary_op_t nary = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
vn_nary_op_t nary = (vn_nary_op_t) obstack_alloc (¤t_info->nary_obstack,
|
size);
|
size);
|
void **slot;
|
void **slot;
|
memcpy (nary, onary, size);
|
memcpy (nary, onary, size);
|
slot = htab_find_slot_with_hash (current_info->nary, nary, nary->hashcode,
|
slot = htab_find_slot_with_hash (current_info->nary, nary, nary->hashcode,
|
INSERT);
|
INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
*slot = nary;
|
*slot = nary;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Insert the no longer used phi *ENTRY to the current hash. */
|
/* Insert the no longer used phi *ENTRY to the current hash. */
|
|
|
static int
|
static int
|
copy_phis (void **entry, void *data ATTRIBUTE_UNUSED)
|
copy_phis (void **entry, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
vn_phi_t ophi = (vn_phi_t) *entry;
|
vn_phi_t ophi = (vn_phi_t) *entry;
|
vn_phi_t phi = (vn_phi_t) pool_alloc (current_info->phis_pool);
|
vn_phi_t phi = (vn_phi_t) pool_alloc (current_info->phis_pool);
|
void **slot;
|
void **slot;
|
memcpy (phi, ophi, sizeof (*phi));
|
memcpy (phi, ophi, sizeof (*phi));
|
ophi->phiargs = NULL;
|
ophi->phiargs = NULL;
|
slot = htab_find_slot_with_hash (current_info->phis, phi, phi->hashcode,
|
slot = htab_find_slot_with_hash (current_info->phis, phi, phi->hashcode,
|
INSERT);
|
INSERT);
|
*slot = phi;
|
*slot = phi;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Insert the no longer used reference *ENTRY to the current hash. */
|
/* Insert the no longer used reference *ENTRY to the current hash. */
|
|
|
static int
|
static int
|
copy_references (void **entry, void *data ATTRIBUTE_UNUSED)
|
copy_references (void **entry, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
vn_reference_t oref = (vn_reference_t) *entry;
|
vn_reference_t oref = (vn_reference_t) *entry;
|
vn_reference_t ref;
|
vn_reference_t ref;
|
void **slot;
|
void **slot;
|
ref = (vn_reference_t) pool_alloc (current_info->references_pool);
|
ref = (vn_reference_t) pool_alloc (current_info->references_pool);
|
memcpy (ref, oref, sizeof (*ref));
|
memcpy (ref, oref, sizeof (*ref));
|
oref->operands = NULL;
|
oref->operands = NULL;
|
slot = htab_find_slot_with_hash (current_info->references, ref, ref->hashcode,
|
slot = htab_find_slot_with_hash (current_info->references, ref, ref->hashcode,
|
INSERT);
|
INSERT);
|
if (*slot)
|
if (*slot)
|
free_reference (*slot);
|
free_reference (*slot);
|
*slot = ref;
|
*slot = ref;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Process a strongly connected component in the SSA graph. */
|
/* Process a strongly connected component in the SSA graph. */
|
|
|
static void
|
static void
|
process_scc (VEC (tree, heap) *scc)
|
process_scc (VEC (tree, heap) *scc)
|
{
|
{
|
/* If the SCC has a single member, just visit it. */
|
/* If the SCC has a single member, just visit it. */
|
|
|
if (VEC_length (tree, scc) == 1)
|
if (VEC_length (tree, scc) == 1)
|
{
|
{
|
tree use = VEC_index (tree, scc, 0);
|
tree use = VEC_index (tree, scc, 0);
|
if (!VN_INFO (use)->use_processed)
|
if (!VN_INFO (use)->use_processed)
|
visit_use (use);
|
visit_use (use);
|
}
|
}
|
else
|
else
|
{
|
{
|
tree var;
|
tree var;
|
unsigned int i;
|
unsigned int i;
|
unsigned int iterations = 0;
|
unsigned int iterations = 0;
|
bool changed = true;
|
bool changed = true;
|
|
|
/* Iterate over the SCC with the optimistic table until it stops
|
/* Iterate over the SCC with the optimistic table until it stops
|
changing. */
|
changing. */
|
current_info = optimistic_info;
|
current_info = optimistic_info;
|
while (changed)
|
while (changed)
|
{
|
{
|
changed = false;
|
changed = false;
|
iterations++;
|
iterations++;
|
/* As we are value-numbering optimistically we have to
|
/* As we are value-numbering optimistically we have to
|
clear the expression tables and the simplified expressions
|
clear the expression tables and the simplified expressions
|
in each iteration until we converge. */
|
in each iteration until we converge. */
|
htab_empty (optimistic_info->nary);
|
htab_empty (optimistic_info->nary);
|
htab_empty (optimistic_info->phis);
|
htab_empty (optimistic_info->phis);
|
htab_empty (optimistic_info->references);
|
htab_empty (optimistic_info->references);
|
obstack_free (&optimistic_info->nary_obstack, NULL);
|
obstack_free (&optimistic_info->nary_obstack, NULL);
|
gcc_obstack_init (&optimistic_info->nary_obstack);
|
gcc_obstack_init (&optimistic_info->nary_obstack);
|
empty_alloc_pool (optimistic_info->phis_pool);
|
empty_alloc_pool (optimistic_info->phis_pool);
|
empty_alloc_pool (optimistic_info->references_pool);
|
empty_alloc_pool (optimistic_info->references_pool);
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
VN_INFO (var)->expr = NULL_TREE;
|
VN_INFO (var)->expr = NULL_TREE;
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
for (i = 0; VEC_iterate (tree, scc, i, var); i++)
|
changed |= visit_use (var);
|
changed |= visit_use (var);
|
}
|
}
|
|
|
statistics_histogram_event (cfun, "SCC iterations", iterations);
|
statistics_histogram_event (cfun, "SCC iterations", iterations);
|
|
|
/* Finally, copy the contents of the no longer used optimistic
|
/* Finally, copy the contents of the no longer used optimistic
|
table to the valid table. */
|
table to the valid table. */
|
current_info = valid_info;
|
current_info = valid_info;
|
htab_traverse (optimistic_info->nary, copy_nary, NULL);
|
htab_traverse (optimistic_info->nary, copy_nary, NULL);
|
htab_traverse (optimistic_info->phis, copy_phis, NULL);
|
htab_traverse (optimistic_info->phis, copy_phis, NULL);
|
htab_traverse (optimistic_info->references, copy_references, NULL);
|
htab_traverse (optimistic_info->references, copy_references, NULL);
|
}
|
}
|
}
|
}
|
|
|
DEF_VEC_O(ssa_op_iter);
|
DEF_VEC_O(ssa_op_iter);
|
DEF_VEC_ALLOC_O(ssa_op_iter,heap);
|
DEF_VEC_ALLOC_O(ssa_op_iter,heap);
|
|
|
/* Pop the components of the found SCC for NAME off the SCC stack
|
/* Pop the components of the found SCC for NAME off the SCC stack
|
and process them. Returns true if all went well, false if
|
and process them. Returns true if all went well, false if
|
we run into resource limits. */
|
we run into resource limits. */
|
|
|
static bool
|
static bool
|
extract_and_process_scc_for_name (tree name)
|
extract_and_process_scc_for_name (tree name)
|
{
|
{
|
VEC (tree, heap) *scc = NULL;
|
VEC (tree, heap) *scc = NULL;
|
tree x;
|
tree x;
|
|
|
/* Found an SCC, pop the components off the SCC stack and
|
/* Found an SCC, pop the components off the SCC stack and
|
process them. */
|
process them. */
|
do
|
do
|
{
|
{
|
x = VEC_pop (tree, sccstack);
|
x = VEC_pop (tree, sccstack);
|
|
|
VN_INFO (x)->on_sccstack = false;
|
VN_INFO (x)->on_sccstack = false;
|
VEC_safe_push (tree, heap, scc, x);
|
VEC_safe_push (tree, heap, scc, x);
|
} while (x != name);
|
} while (x != name);
|
|
|
/* Bail out of SCCVN in case a SCC turns out to be incredibly large. */
|
/* Bail out of SCCVN in case a SCC turns out to be incredibly large. */
|
if (VEC_length (tree, scc)
|
if (VEC_length (tree, scc)
|
> (unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE))
|
> (unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE))
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "WARNING: Giving up with SCCVN due to "
|
fprintf (dump_file, "WARNING: Giving up with SCCVN due to "
|
"SCC size %u exceeding %u\n", VEC_length (tree, scc),
|
"SCC size %u exceeding %u\n", VEC_length (tree, scc),
|
(unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE));
|
(unsigned)PARAM_VALUE (PARAM_SCCVN_MAX_SCC_SIZE));
|
return false;
|
return false;
|
}
|
}
|
|
|
if (VEC_length (tree, scc) > 1)
|
if (VEC_length (tree, scc) > 1)
|
sort_scc (scc);
|
sort_scc (scc);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
print_scc (dump_file, scc);
|
print_scc (dump_file, scc);
|
|
|
process_scc (scc);
|
process_scc (scc);
|
|
|
VEC_free (tree, heap, scc);
|
VEC_free (tree, heap, scc);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Depth first search on NAME to discover and process SCC's in the SSA
|
/* Depth first search on NAME to discover and process SCC's in the SSA
|
graph.
|
graph.
|
Execution of this algorithm relies on the fact that the SCC's are
|
Execution of this algorithm relies on the fact that the SCC's are
|
popped off the stack in topological order.
|
popped off the stack in topological order.
|
Returns true if successful, false if we stopped processing SCC's due
|
Returns true if successful, false if we stopped processing SCC's due
|
to resource constraints. */
|
to resource constraints. */
|
|
|
static bool
|
static bool
|
DFS (tree name)
|
DFS (tree name)
|
{
|
{
|
VEC(ssa_op_iter, heap) *itervec = NULL;
|
VEC(ssa_op_iter, heap) *itervec = NULL;
|
VEC(tree, heap) *namevec = NULL;
|
VEC(tree, heap) *namevec = NULL;
|
use_operand_p usep = NULL;
|
use_operand_p usep = NULL;
|
gimple defstmt;
|
gimple defstmt;
|
tree use;
|
tree use;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
|
|
start_over:
|
start_over:
|
/* SCC info */
|
/* SCC info */
|
VN_INFO (name)->dfsnum = next_dfs_num++;
|
VN_INFO (name)->dfsnum = next_dfs_num++;
|
VN_INFO (name)->visited = true;
|
VN_INFO (name)->visited = true;
|
VN_INFO (name)->low = VN_INFO (name)->dfsnum;
|
VN_INFO (name)->low = VN_INFO (name)->dfsnum;
|
|
|
VEC_safe_push (tree, heap, sccstack, name);
|
VEC_safe_push (tree, heap, sccstack, name);
|
VN_INFO (name)->on_sccstack = true;
|
VN_INFO (name)->on_sccstack = true;
|
defstmt = SSA_NAME_DEF_STMT (name);
|
defstmt = SSA_NAME_DEF_STMT (name);
|
|
|
/* Recursively DFS on our operands, looking for SCC's. */
|
/* Recursively DFS on our operands, looking for SCC's. */
|
if (!gimple_nop_p (defstmt))
|
if (!gimple_nop_p (defstmt))
|
{
|
{
|
/* Push a new iterator. */
|
/* Push a new iterator. */
|
if (gimple_code (defstmt) == GIMPLE_PHI)
|
if (gimple_code (defstmt) == GIMPLE_PHI)
|
usep = op_iter_init_phiuse (&iter, defstmt, SSA_OP_ALL_USES);
|
usep = op_iter_init_phiuse (&iter, defstmt, SSA_OP_ALL_USES);
|
else
|
else
|
usep = op_iter_init_use (&iter, defstmt, SSA_OP_ALL_USES);
|
usep = op_iter_init_use (&iter, defstmt, SSA_OP_ALL_USES);
|
}
|
}
|
else
|
else
|
clear_and_done_ssa_iter (&iter);
|
clear_and_done_ssa_iter (&iter);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
/* If we are done processing uses of a name, go up the stack
|
/* If we are done processing uses of a name, go up the stack
|
of iterators and process SCCs as we found them. */
|
of iterators and process SCCs as we found them. */
|
if (op_iter_done (&iter))
|
if (op_iter_done (&iter))
|
{
|
{
|
/* See if we found an SCC. */
|
/* See if we found an SCC. */
|
if (VN_INFO (name)->low == VN_INFO (name)->dfsnum)
|
if (VN_INFO (name)->low == VN_INFO (name)->dfsnum)
|
if (!extract_and_process_scc_for_name (name))
|
if (!extract_and_process_scc_for_name (name))
|
{
|
{
|
VEC_free (tree, heap, namevec);
|
VEC_free (tree, heap, namevec);
|
VEC_free (ssa_op_iter, heap, itervec);
|
VEC_free (ssa_op_iter, heap, itervec);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Check if we are done. */
|
/* Check if we are done. */
|
if (VEC_empty (tree, namevec))
|
if (VEC_empty (tree, namevec))
|
{
|
{
|
VEC_free (tree, heap, namevec);
|
VEC_free (tree, heap, namevec);
|
VEC_free (ssa_op_iter, heap, itervec);
|
VEC_free (ssa_op_iter, heap, itervec);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Restore the last use walker and continue walking there. */
|
/* Restore the last use walker and continue walking there. */
|
use = name;
|
use = name;
|
name = VEC_pop (tree, namevec);
|
name = VEC_pop (tree, namevec);
|
memcpy (&iter, VEC_last (ssa_op_iter, itervec),
|
memcpy (&iter, VEC_last (ssa_op_iter, itervec),
|
sizeof (ssa_op_iter));
|
sizeof (ssa_op_iter));
|
VEC_pop (ssa_op_iter, itervec);
|
VEC_pop (ssa_op_iter, itervec);
|
goto continue_walking;
|
goto continue_walking;
|
}
|
}
|
|
|
use = USE_FROM_PTR (usep);
|
use = USE_FROM_PTR (usep);
|
|
|
/* Since we handle phi nodes, we will sometimes get
|
/* Since we handle phi nodes, we will sometimes get
|
invariants in the use expression. */
|
invariants in the use expression. */
|
if (TREE_CODE (use) == SSA_NAME)
|
if (TREE_CODE (use) == SSA_NAME)
|
{
|
{
|
if (! (VN_INFO (use)->visited))
|
if (! (VN_INFO (use)->visited))
|
{
|
{
|
/* Recurse by pushing the current use walking state on
|
/* Recurse by pushing the current use walking state on
|
the stack and starting over. */
|
the stack and starting over. */
|
VEC_safe_push(ssa_op_iter, heap, itervec, &iter);
|
VEC_safe_push(ssa_op_iter, heap, itervec, &iter);
|
VEC_safe_push(tree, heap, namevec, name);
|
VEC_safe_push(tree, heap, namevec, name);
|
name = use;
|
name = use;
|
goto start_over;
|
goto start_over;
|
|
|
continue_walking:
|
continue_walking:
|
VN_INFO (name)->low = MIN (VN_INFO (name)->low,
|
VN_INFO (name)->low = MIN (VN_INFO (name)->low,
|
VN_INFO (use)->low);
|
VN_INFO (use)->low);
|
}
|
}
|
if (VN_INFO (use)->dfsnum < VN_INFO (name)->dfsnum
|
if (VN_INFO (use)->dfsnum < VN_INFO (name)->dfsnum
|
&& VN_INFO (use)->on_sccstack)
|
&& VN_INFO (use)->on_sccstack)
|
{
|
{
|
VN_INFO (name)->low = MIN (VN_INFO (use)->dfsnum,
|
VN_INFO (name)->low = MIN (VN_INFO (use)->dfsnum,
|
VN_INFO (name)->low);
|
VN_INFO (name)->low);
|
}
|
}
|
}
|
}
|
|
|
usep = op_iter_next_use (&iter);
|
usep = op_iter_next_use (&iter);
|
}
|
}
|
}
|
}
|
|
|
/* Allocate a value number table. */
|
/* Allocate a value number table. */
|
|
|
static void
|
static void
|
allocate_vn_table (vn_tables_t table)
|
allocate_vn_table (vn_tables_t table)
|
{
|
{
|
table->phis = htab_create (23, vn_phi_hash, vn_phi_eq, free_phi);
|
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->nary = htab_create (23, vn_nary_op_hash, vn_nary_op_eq, NULL);
|
table->references = htab_create (23, vn_reference_hash, vn_reference_eq,
|
table->references = htab_create (23, vn_reference_hash, vn_reference_eq,
|
free_reference);
|
free_reference);
|
|
|
gcc_obstack_init (&table->nary_obstack);
|
gcc_obstack_init (&table->nary_obstack);
|
table->phis_pool = create_alloc_pool ("VN phis",
|
table->phis_pool = create_alloc_pool ("VN phis",
|
sizeof (struct vn_phi_s),
|
sizeof (struct vn_phi_s),
|
30);
|
30);
|
table->references_pool = create_alloc_pool ("VN references",
|
table->references_pool = create_alloc_pool ("VN references",
|
sizeof (struct vn_reference_s),
|
sizeof (struct vn_reference_s),
|
30);
|
30);
|
}
|
}
|
|
|
/* Free a value number table. */
|
/* Free a value number table. */
|
|
|
static void
|
static void
|
free_vn_table (vn_tables_t table)
|
free_vn_table (vn_tables_t table)
|
{
|
{
|
htab_delete (table->phis);
|
htab_delete (table->phis);
|
htab_delete (table->nary);
|
htab_delete (table->nary);
|
htab_delete (table->references);
|
htab_delete (table->references);
|
obstack_free (&table->nary_obstack, NULL);
|
obstack_free (&table->nary_obstack, NULL);
|
free_alloc_pool (table->phis_pool);
|
free_alloc_pool (table->phis_pool);
|
free_alloc_pool (table->references_pool);
|
free_alloc_pool (table->references_pool);
|
}
|
}
|
|
|
static void
|
static void
|
init_scc_vn (void)
|
init_scc_vn (void)
|
{
|
{
|
size_t i;
|
size_t i;
|
int j;
|
int j;
|
int *rpo_numbers_temp;
|
int *rpo_numbers_temp;
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
sccstack = NULL;
|
sccstack = NULL;
|
constant_to_value_id = htab_create (23, vn_constant_hash, vn_constant_eq,
|
constant_to_value_id = htab_create (23, vn_constant_hash, vn_constant_eq,
|
free);
|
free);
|
|
|
constant_value_ids = BITMAP_ALLOC (NULL);
|
constant_value_ids = BITMAP_ALLOC (NULL);
|
|
|
next_dfs_num = 1;
|
next_dfs_num = 1;
|
next_value_id = 1;
|
next_value_id = 1;
|
|
|
vn_ssa_aux_table = VEC_alloc (vn_ssa_aux_t, heap, num_ssa_names + 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
|
/* VEC_alloc doesn't actually grow it to the right size, it just
|
preallocates the space to do so. */
|
preallocates the space to do so. */
|
VEC_safe_grow_cleared (vn_ssa_aux_t, heap, vn_ssa_aux_table, num_ssa_names + 1);
|
VEC_safe_grow_cleared (vn_ssa_aux_t, heap, vn_ssa_aux_table, num_ssa_names + 1);
|
gcc_obstack_init (&vn_ssa_aux_obstack);
|
gcc_obstack_init (&vn_ssa_aux_obstack);
|
|
|
shared_lookup_phiargs = NULL;
|
shared_lookup_phiargs = NULL;
|
shared_lookup_references = NULL;
|
shared_lookup_references = NULL;
|
rpo_numbers = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
|
rpo_numbers = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
|
rpo_numbers_temp = 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);
|
pre_and_rev_post_order_compute (NULL, rpo_numbers_temp, false);
|
|
|
/* RPO numbers is an array of rpo ordering, rpo[i] = bb means that
|
/* 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
|
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. */
|
numbers, so we need to rearrange this array. */
|
for (j = 0; j < n_basic_blocks - NUM_FIXED_BLOCKS; j++)
|
for (j = 0; j < n_basic_blocks - NUM_FIXED_BLOCKS; j++)
|
rpo_numbers[rpo_numbers_temp[j]] = j;
|
rpo_numbers[rpo_numbers_temp[j]] = j;
|
|
|
XDELETE (rpo_numbers_temp);
|
XDELETE (rpo_numbers_temp);
|
|
|
VN_TOP = create_tmp_var_raw (void_type_node, "vn_top");
|
VN_TOP = create_tmp_var_raw (void_type_node, "vn_top");
|
|
|
/* Create the VN_INFO structures, and initialize value numbers to
|
/* Create the VN_INFO structures, and initialize value numbers to
|
TOP. */
|
TOP. */
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
if (name)
|
if (name)
|
{
|
{
|
VN_INFO_GET (name)->valnum = VN_TOP;
|
VN_INFO_GET (name)->valnum = VN_TOP;
|
VN_INFO (name)->expr = NULL_TREE;
|
VN_INFO (name)->expr = NULL_TREE;
|
VN_INFO (name)->value_id = 0;
|
VN_INFO (name)->value_id = 0;
|
}
|
}
|
}
|
}
|
|
|
renumber_gimple_stmt_uids ();
|
renumber_gimple_stmt_uids ();
|
|
|
/* Create the valid and optimistic value numbering tables. */
|
/* Create the valid and optimistic value numbering tables. */
|
valid_info = XCNEW (struct vn_tables_s);
|
valid_info = XCNEW (struct vn_tables_s);
|
allocate_vn_table (valid_info);
|
allocate_vn_table (valid_info);
|
optimistic_info = XCNEW (struct vn_tables_s);
|
optimistic_info = XCNEW (struct vn_tables_s);
|
allocate_vn_table (optimistic_info);
|
allocate_vn_table (optimistic_info);
|
}
|
}
|
|
|
void
|
void
|
free_scc_vn (void)
|
free_scc_vn (void)
|
{
|
{
|
size_t i;
|
size_t i;
|
|
|
htab_delete (constant_to_value_id);
|
htab_delete (constant_to_value_id);
|
BITMAP_FREE (constant_value_ids);
|
BITMAP_FREE (constant_value_ids);
|
VEC_free (tree, heap, shared_lookup_phiargs);
|
VEC_free (tree, heap, shared_lookup_phiargs);
|
VEC_free (vn_reference_op_s, heap, shared_lookup_references);
|
VEC_free (vn_reference_op_s, heap, shared_lookup_references);
|
XDELETEVEC (rpo_numbers);
|
XDELETEVEC (rpo_numbers);
|
|
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
if (name
|
if (name
|
&& VN_INFO (name)->needs_insertion)
|
&& VN_INFO (name)->needs_insertion)
|
release_ssa_name (name);
|
release_ssa_name (name);
|
}
|
}
|
obstack_free (&vn_ssa_aux_obstack, NULL);
|
obstack_free (&vn_ssa_aux_obstack, NULL);
|
VEC_free (vn_ssa_aux_t, heap, vn_ssa_aux_table);
|
VEC_free (vn_ssa_aux_t, heap, vn_ssa_aux_table);
|
|
|
VEC_free (tree, heap, sccstack);
|
VEC_free (tree, heap, sccstack);
|
free_vn_table (valid_info);
|
free_vn_table (valid_info);
|
XDELETE (valid_info);
|
XDELETE (valid_info);
|
free_vn_table (optimistic_info);
|
free_vn_table (optimistic_info);
|
XDELETE (optimistic_info);
|
XDELETE (optimistic_info);
|
}
|
}
|
|
|
/* Set the value ids in the valid hash tables. */
|
/* Set the value ids in the valid hash tables. */
|
|
|
static void
|
static void
|
set_hashtable_value_ids (void)
|
set_hashtable_value_ids (void)
|
{
|
{
|
htab_iterator hi;
|
htab_iterator hi;
|
vn_nary_op_t vno;
|
vn_nary_op_t vno;
|
vn_reference_t vr;
|
vn_reference_t vr;
|
vn_phi_t vp;
|
vn_phi_t vp;
|
|
|
/* Now set the value ids of the things we had put in the hash
|
/* Now set the value ids of the things we had put in the hash
|
table. */
|
table. */
|
|
|
FOR_EACH_HTAB_ELEMENT (valid_info->nary,
|
FOR_EACH_HTAB_ELEMENT (valid_info->nary,
|
vno, vn_nary_op_t, hi)
|
vno, vn_nary_op_t, hi)
|
{
|
{
|
if (vno->result)
|
if (vno->result)
|
{
|
{
|
if (TREE_CODE (vno->result) == SSA_NAME)
|
if (TREE_CODE (vno->result) == SSA_NAME)
|
vno->value_id = VN_INFO (vno->result)->value_id;
|
vno->value_id = VN_INFO (vno->result)->value_id;
|
else if (is_gimple_min_invariant (vno->result))
|
else if (is_gimple_min_invariant (vno->result))
|
vno->value_id = get_or_alloc_constant_value_id (vno->result);
|
vno->value_id = get_or_alloc_constant_value_id (vno->result);
|
}
|
}
|
}
|
}
|
|
|
FOR_EACH_HTAB_ELEMENT (valid_info->phis,
|
FOR_EACH_HTAB_ELEMENT (valid_info->phis,
|
vp, vn_phi_t, hi)
|
vp, vn_phi_t, hi)
|
{
|
{
|
if (vp->result)
|
if (vp->result)
|
{
|
{
|
if (TREE_CODE (vp->result) == SSA_NAME)
|
if (TREE_CODE (vp->result) == SSA_NAME)
|
vp->value_id = VN_INFO (vp->result)->value_id;
|
vp->value_id = VN_INFO (vp->result)->value_id;
|
else if (is_gimple_min_invariant (vp->result))
|
else if (is_gimple_min_invariant (vp->result))
|
vp->value_id = get_or_alloc_constant_value_id (vp->result);
|
vp->value_id = get_or_alloc_constant_value_id (vp->result);
|
}
|
}
|
}
|
}
|
|
|
FOR_EACH_HTAB_ELEMENT (valid_info->references,
|
FOR_EACH_HTAB_ELEMENT (valid_info->references,
|
vr, vn_reference_t, hi)
|
vr, vn_reference_t, hi)
|
{
|
{
|
if (vr->result)
|
if (vr->result)
|
{
|
{
|
if (TREE_CODE (vr->result) == SSA_NAME)
|
if (TREE_CODE (vr->result) == SSA_NAME)
|
vr->value_id = VN_INFO (vr->result)->value_id;
|
vr->value_id = VN_INFO (vr->result)->value_id;
|
else if (is_gimple_min_invariant (vr->result))
|
else if (is_gimple_min_invariant (vr->result))
|
vr->value_id = get_or_alloc_constant_value_id (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
|
/* Do SCCVN. Returns true if it finished, false if we bailed out
|
due to resource constraints. */
|
due to resource constraints. */
|
|
|
bool
|
bool
|
run_scc_vn (bool may_insert_arg)
|
run_scc_vn (bool may_insert_arg)
|
{
|
{
|
size_t i;
|
size_t i;
|
tree param;
|
tree param;
|
bool changed = true;
|
bool changed = true;
|
|
|
may_insert = may_insert_arg;
|
may_insert = may_insert_arg;
|
|
|
init_scc_vn ();
|
init_scc_vn ();
|
current_info = valid_info;
|
current_info = valid_info;
|
|
|
for (param = DECL_ARGUMENTS (current_function_decl);
|
for (param = DECL_ARGUMENTS (current_function_decl);
|
param;
|
param;
|
param = TREE_CHAIN (param))
|
param = TREE_CHAIN (param))
|
{
|
{
|
if (gimple_default_def (cfun, param) != NULL)
|
if (gimple_default_def (cfun, param) != NULL)
|
{
|
{
|
tree def = gimple_default_def (cfun, param);
|
tree def = gimple_default_def (cfun, param);
|
VN_INFO (def)->valnum = def;
|
VN_INFO (def)->valnum = def;
|
}
|
}
|
}
|
}
|
|
|
for (i = 1; i < num_ssa_names; ++i)
|
for (i = 1; i < num_ssa_names; ++i)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
if (name
|
if (name
|
&& VN_INFO (name)->visited == false
|
&& VN_INFO (name)->visited == false
|
&& !has_zero_uses (name))
|
&& !has_zero_uses (name))
|
if (!DFS (name))
|
if (!DFS (name))
|
{
|
{
|
free_scc_vn ();
|
free_scc_vn ();
|
may_insert = false;
|
may_insert = false;
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Initialize the value ids. */
|
/* Initialize the value ids. */
|
|
|
for (i = 1; i < num_ssa_names; ++i)
|
for (i = 1; i < num_ssa_names; ++i)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
vn_ssa_aux_t info;
|
vn_ssa_aux_t info;
|
if (!name)
|
if (!name)
|
continue;
|
continue;
|
info = VN_INFO (name);
|
info = VN_INFO (name);
|
if (info->valnum == name
|
if (info->valnum == name
|
|| info->valnum == VN_TOP)
|
|| info->valnum == VN_TOP)
|
info->value_id = get_next_value_id ();
|
info->value_id = get_next_value_id ();
|
else if (is_gimple_min_invariant (info->valnum))
|
else if (is_gimple_min_invariant (info->valnum))
|
info->value_id = get_or_alloc_constant_value_id (info->valnum);
|
info->value_id = get_or_alloc_constant_value_id (info->valnum);
|
}
|
}
|
|
|
/* Propagate until they stop changing. */
|
/* Propagate until they stop changing. */
|
while (changed)
|
while (changed)
|
{
|
{
|
changed = false;
|
changed = false;
|
for (i = 1; i < num_ssa_names; ++i)
|
for (i = 1; i < num_ssa_names; ++i)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
vn_ssa_aux_t info;
|
vn_ssa_aux_t info;
|
if (!name)
|
if (!name)
|
continue;
|
continue;
|
info = VN_INFO (name);
|
info = VN_INFO (name);
|
if (TREE_CODE (info->valnum) == SSA_NAME
|
if (TREE_CODE (info->valnum) == SSA_NAME
|
&& info->valnum != name
|
&& info->valnum != name
|
&& info->value_id != VN_INFO (info->valnum)->value_id)
|
&& info->value_id != VN_INFO (info->valnum)->value_id)
|
{
|
{
|
changed = true;
|
changed = true;
|
info->value_id = VN_INFO (info->valnum)->value_id;
|
info->value_id = VN_INFO (info->valnum)->value_id;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
set_hashtable_value_ids ();
|
set_hashtable_value_ids ();
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Value numbers:\n");
|
fprintf (dump_file, "Value numbers:\n");
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
if (name
|
if (name
|
&& VN_INFO (name)->visited
|
&& VN_INFO (name)->visited
|
&& SSA_VAL (name) != name)
|
&& SSA_VAL (name) != name)
|
{
|
{
|
print_generic_expr (dump_file, name, 0);
|
print_generic_expr (dump_file, name, 0);
|
fprintf (dump_file, " = ");
|
fprintf (dump_file, " = ");
|
print_generic_expr (dump_file, SSA_VAL (name), 0);
|
print_generic_expr (dump_file, SSA_VAL (name), 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
may_insert = false;
|
may_insert = false;
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return the maximum value id we have ever seen. */
|
/* Return the maximum value id we have ever seen. */
|
|
|
unsigned int
|
unsigned int
|
get_max_value_id (void)
|
get_max_value_id (void)
|
{
|
{
|
return next_value_id;
|
return next_value_id;
|
}
|
}
|
|
|
/* Return the next unique value id. */
|
/* Return the next unique value id. */
|
|
|
unsigned int
|
unsigned int
|
get_next_value_id (void)
|
get_next_value_id (void)
|
{
|
{
|
return next_value_id++;
|
return next_value_id++;
|
}
|
}
|
|
|
|
|
/* Compare two expressions E1 and E2 and return true if they are equal. */
|
/* Compare two expressions E1 and E2 and return true if they are equal. */
|
|
|
bool
|
bool
|
expressions_equal_p (tree e1, tree e2)
|
expressions_equal_p (tree e1, tree e2)
|
{
|
{
|
/* The obvious case. */
|
/* The obvious case. */
|
if (e1 == e2)
|
if (e1 == e2)
|
return true;
|
return true;
|
|
|
/* If only one of them is null, they cannot be equal. */
|
/* If only one of them is null, they cannot be equal. */
|
if (!e1 || !e2)
|
if (!e1 || !e2)
|
return false;
|
return false;
|
|
|
/* Now perform the actual comparison. */
|
/* Now perform the actual comparison. */
|
if (TREE_CODE (e1) == TREE_CODE (e2)
|
if (TREE_CODE (e1) == TREE_CODE (e2)
|
&& operand_equal_p (e1, e2, OEP_PURE_SAME))
|
&& operand_equal_p (e1, e2, OEP_PURE_SAME))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Return true if the nary operation NARY may trap. This is a copy
|
/* Return true if the nary operation NARY may trap. This is a copy
|
of stmt_could_throw_1_p adjusted to the SCCVN IL. */
|
of stmt_could_throw_1_p adjusted to the SCCVN IL. */
|
|
|
bool
|
bool
|
vn_nary_may_trap (vn_nary_op_t nary)
|
vn_nary_may_trap (vn_nary_op_t nary)
|
{
|
{
|
tree type;
|
tree type;
|
tree rhs2 = NULL_TREE;
|
tree rhs2 = NULL_TREE;
|
bool honor_nans = false;
|
bool honor_nans = false;
|
bool honor_snans = false;
|
bool honor_snans = false;
|
bool fp_operation = false;
|
bool fp_operation = false;
|
bool honor_trapv = false;
|
bool honor_trapv = false;
|
bool handled, ret;
|
bool handled, ret;
|
unsigned i;
|
unsigned i;
|
|
|
if (TREE_CODE_CLASS (nary->opcode) == tcc_comparison
|
if (TREE_CODE_CLASS (nary->opcode) == tcc_comparison
|
|| TREE_CODE_CLASS (nary->opcode) == tcc_unary
|
|| TREE_CODE_CLASS (nary->opcode) == tcc_unary
|
|| TREE_CODE_CLASS (nary->opcode) == tcc_binary)
|
|| TREE_CODE_CLASS (nary->opcode) == tcc_binary)
|
{
|
{
|
type = nary->type;
|
type = nary->type;
|
fp_operation = FLOAT_TYPE_P (type);
|
fp_operation = FLOAT_TYPE_P (type);
|
if (fp_operation)
|
if (fp_operation)
|
{
|
{
|
honor_nans = flag_trapping_math && !flag_finite_math_only;
|
honor_nans = flag_trapping_math && !flag_finite_math_only;
|
honor_snans = flag_signaling_nans != 0;
|
honor_snans = flag_signaling_nans != 0;
|
}
|
}
|
else if (INTEGRAL_TYPE_P (type)
|
else if (INTEGRAL_TYPE_P (type)
|
&& TYPE_OVERFLOW_TRAPS (type))
|
&& TYPE_OVERFLOW_TRAPS (type))
|
honor_trapv = true;
|
honor_trapv = true;
|
}
|
}
|
if (nary->length >= 2)
|
if (nary->length >= 2)
|
rhs2 = nary->op[1];
|
rhs2 = nary->op[1];
|
ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
|
ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
|
honor_trapv,
|
honor_trapv,
|
honor_nans, honor_snans, rhs2,
|
honor_nans, honor_snans, rhs2,
|
&handled);
|
&handled);
|
if (handled
|
if (handled
|
&& ret)
|
&& ret)
|
return true;
|
return true;
|
|
|
for (i = 0; i < nary->length; ++i)
|
for (i = 0; i < nary->length; ++i)
|
if (tree_could_trap_p (nary->op[i]))
|
if (tree_could_trap_p (nary->op[i]))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
