This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] SSA operand cache build process.
- From: Andrew MacLeod <amacleod at redhat dot com>
- To: gcc-patches <gcc-patches at gcc dot gnu dot org>
- Date: 04 Aug 2004 20:03:27 -0400
- Subject: [patch] SSA operand cache build process.
This patch does a couple of things, primarily in preparation for
integrating imemdiate_uses into the operands. It should be virtual
transparent to everyone.
First, it restructures the way we build operands in tree-ssa-operands.c.
Previously, we kept a copy of the old virtual operands, free'd the real
operand vectors, passed the old operands around while we build up the
new operand vectors, then free'd the old virtual operands.
It turns out that there is a significant percentage of times that most
these vectors are actually completely unchanged. (ie, perhaps one of the
5 vectors is all that has changed.) Its also possible that
modify_stmt() is called in places where it doesnt need to be and all 5
vectors could be the same. Those I'll track down later.
This patch changes the process slightly. First, when we are building up
the initial vectors from the stmt tree, we simply add them the the list,
avoiding duplicates where appropriate. Prev_vops is no longer passed
around everywhere. Then the finalize_* routines do all the work that
use to be done when we were byuilding vectors, looking for ssa_name
resuse, and now checking to see if the new vecotr would be different
than the old one. If there would be no change, we simply use the old
vector instead of allocating a new one, setting it up, and freeing the
old one. Lots of waste is eliminated this way.
A side benefit is that actually does speed up operand processing a tad.
Operand processing isnt a huge expense to start with, but in tramp3d for
instance, its dropped from 3.5 to 2.8 seconds of user time on my machine
the last time I checked. Typically you are unlikely to notice much
difference, but it is there. I dont count the gain as significant since
I intend to claim it back when the immediate uses code goes in. It will
cause a marginal slowdown in all likelyhood, this is going to be used to
offset that :-)
All external uses of the operand building process have been removed as
well. DOM was building its own operands cache for certain stmts, this
has been moved into the operands file. Furthermore, stmt operands are
now built seperate from the stmt annotaion, and added to the annotation
if the stmt is a real stmt. The usage in DOM was for stmts which were
entered into hash tables but didn't occur in the program. We arent
going to want to build immediate use information for stmts which are not
in the program....
Same as with the modify_stmt patch, these changes bootstrap on
i686-pc-linux-gnu and cause no new failures in the testsuites.
The bootstrap/make-check process is currently running on todays
toolchain. I should have the results later tonight, and probably check
it in tomorrow morning.
Issues?
Andrew
2004-08-05 Andrew MacLeod <amacleod@redhat.com>
* tree-flow-inline.h (get_def_ops, get_use_ops, get_v_may_def_ops,
get_vuse_ops,get_v_must_def_ops): Add operand structure reference.
(get_v_may_def_result_ptr, get_v_may_def_op_ptr): New access struct.
(start_ssa_stmt_operands): Delete.
* tree-flow.h (struct stmt_ann_d): Replace operand vectors with new
struct stmt_operands_d.
(build_ssa_operands): New extern entry point.
* tree-ssa-dom.c (record_equivalences_from_stmt): Remove operand
building code, replace with create_ssa_artficial_load_stmt().
* tree-ssa-operands.c (struct voperands_d): Delete.
(allocate_v_may_def_optype): Allocate v_may_def_operand_type_t vector.
(allocate_v_must_def_optype): Use sizeof (tree), not sizeof (tree *).
(free_uses, free_defs, free_vuses, free_v_may_defs,
free_v_must_defs): Remove dealloc parameter.
(remove_vuses, remove_v_may_def, remove_v_must_defs): Delete.
(finalize_ssa_defs, finalize_ssa_uses, finalize_ssa_v_may_defs,
finalize_ssa_vuses, finalize_ssa_v_must_defs): Perform all operand
vector comparisons, ssa_name reuse, and allocations here.
(verify_start_operands): Delete.
(finalize_ssa_stmt_operands): Set new operands by calling finalize
routines.
(start_ssa_stmt_operands): Move from tree-flow-inline.h.
(append_def, append_usei): Simplify to simple accumulation.
(append_v_may_def, append_vuse, append_v_must_def): Simplify to avoiding
duplicates and simple accumulation.
(free_ssa_operands): Free vectors in a stmt_operand structure.
(build_ssa_operands): New. Create a new stmt_operand structure from
a stmt and an old set of stmt_operands.
(get_stmt_operands): Simplify and call build_ssa_operands.
(get_expr_operands, get_asm_expr_operands, get_indirect_ref_operands,
get_call_expr_operands, add_stmt_operand, add_call_clobber_ops,
add_call_read_ops): Don't pass prev_vops around anymore.
(note_addressable): Return if no stmt annotation.
(copy_virtual_operands): Access v_may_def operands through a struct.
(create_ssa_artficial_load_stmt): New. Create a load stmt for DOM's
hash tables without treating the stmt as a real stmt.
* tree-ssa-operands.h (struct v_may_def_operand_type): New. Access
v_may_def def and use through a struct instead of 2 array elements.
(struct v_may_def_optype_d): Use v_may_def_operand_type.
(struct stmt_operands_d): New. Struct for storing all operand vectors.
Index: tree-flow-inline.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-flow-inline.h,v
retrieving revision 2.18
diff -c -p -r2.18 tree-flow-inline.h
*** tree-flow-inline.h 23 Jul 2004 22:37:23 -0000 2.18
--- tree-flow-inline.h 4 Aug 2004 15:42:13 -0000
*************** stmt_modified_p (tree t)
*** 169,175 ****
static inline def_optype
get_def_ops (stmt_ann_t ann)
{
! return ann ? ann->def_ops : NULL;
}
/* Return the uses present in ANN, a statement annotation.
--- 169,175 ----
static inline def_optype
get_def_ops (stmt_ann_t ann)
{
! return ann ? ann->operands.def_ops : NULL;
}
/* Return the uses present in ANN, a statement annotation.
*************** get_def_ops (stmt_ann_t ann)
*** 177,183 ****
static inline use_optype
get_use_ops (stmt_ann_t ann)
{
! return ann ? ann->use_ops : NULL;
}
/* Return the virtual may-defs present in ANN, a statement
--- 177,183 ----
static inline use_optype
get_use_ops (stmt_ann_t ann)
{
! return ann ? ann->operands.use_ops : NULL;
}
/* Return the virtual may-defs present in ANN, a statement
*************** get_use_ops (stmt_ann_t ann)
*** 186,192 ****
static inline v_may_def_optype
get_v_may_def_ops (stmt_ann_t ann)
{
! return ann ? ann->v_may_def_ops : NULL;
}
/* Return the virtual uses present in ANN, a statement annotation.
--- 186,192 ----
static inline v_may_def_optype
get_v_may_def_ops (stmt_ann_t ann)
{
! return ann ? ann->operands.v_may_def_ops : NULL;
}
/* Return the virtual uses present in ANN, a statement annotation.
*************** get_v_may_def_ops (stmt_ann_t ann)
*** 194,200 ****
static inline vuse_optype
get_vuse_ops (stmt_ann_t ann)
{
! return ann ? ann->vuse_ops : NULL;
}
/* Return the virtual must-defs present in ANN, a statement
--- 194,200 ----
static inline vuse_optype
get_vuse_ops (stmt_ann_t ann)
{
! return ann ? ann->operands.vuse_ops : NULL;
}
/* Return the virtual must-defs present in ANN, a statement
*************** get_vuse_ops (stmt_ann_t ann)
*** 202,208 ****
static inline v_must_def_optype
get_v_must_def_ops (stmt_ann_t ann)
{
! return ann ? ann->v_must_def_ops : NULL;
}
/* Return the tree pointer to by USE. */
--- 202,208 ----
static inline v_must_def_optype
get_v_must_def_ops (stmt_ann_t ann)
{
! return ann ? ann->operands.v_must_def_ops : NULL;
}
/* Return the tree pointer to by USE. */
*************** get_v_may_def_result_ptr(v_may_def_optyp
*** 252,258 ****
if (index >= v_may_defs->num_v_may_defs)
abort();
#endif
! op.def = &(v_may_defs->v_may_defs[index * 2]);
return op;
}
--- 252,258 ----
if (index >= v_may_defs->num_v_may_defs)
abort();
#endif
! op.def = &(v_may_defs->v_may_defs[index].def);
return op;
}
*************** get_v_may_def_op_ptr(v_may_def_optype v_
*** 266,272 ****
if (index >= v_may_defs->num_v_may_defs)
abort();
#endif
! op.use = &(v_may_defs->v_may_defs[index * 2 + 1]);
return op;
}
--- 266,272 ----
if (index >= v_may_defs->num_v_may_defs)
abort();
#endif
! op.use = &(v_may_defs->v_may_defs[index].use);
return op;
}
*************** get_phi_arg_def_ptr (tree phi, int i)
*** 315,329 ****
return op;
}
- /* Mark the beginning of changes to the SSA operands for STMT. */
- static inline void
- start_ssa_stmt_operands (tree stmt ATTRIBUTE_UNUSED)
- {
- #ifdef ENABLE_CHECKING
- verify_start_operands (stmt);
- #endif
- }
-
/* Return the bitmap of addresses taken by STMT, or NULL if it takes
no addresses. */
static inline bitmap
--- 315,320 ----
Index: tree-flow.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-flow.h,v
retrieving revision 2.29
diff -c -p -r2.29 tree-flow.h
*** tree-flow.h 23 Jul 2004 22:37:23 -0000 2.29
--- tree-flow.h 4 Aug 2004 15:42:13 -0000
*************** struct stmt_ann_d GTY(())
*** 266,279 ****
/* Basic block that contains this statement. */
basic_block GTY ((skip (""))) bb;
! /* Statement operands. */
! struct def_optype_d * GTY (()) def_ops;
! struct use_optype_d * GTY (()) use_ops;
!
! /* Virtual operands (V_MAY_DEF, VUSE, and V_MUST_DEF). */
! struct v_may_def_optype_d * GTY (()) v_may_def_ops;
! struct vuse_optype_d * GTY (()) vuse_ops;
! struct v_must_def_optype_d * GTY (()) v_must_def_ops;
/* Dataflow information. */
dataflow_t df;
--- 266,272 ----
/* Basic block that contains this statement. */
basic_block GTY ((skip (""))) bb;
! struct stmt_operands_d operands;
/* Dataflow information. */
dataflow_t df;
*************** void vn_delete (void);
*** 685,690 ****
--- 678,687 ----
/* In tree-sra.c */
void insert_edge_copies (tree stmt, basic_block bb);
+ /* In tree-ssa-operands.c */
+ extern void build_ssa_operands (tree, stmt_ann_t, stmt_operands_p,
+ stmt_operands_p);
+
#include "tree-flow-inline.h"
#endif /* _TREE_FLOW_H */
Index: tree-ssa-dom.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-dom.c,v
retrieving revision 2.28
diff -c -p -r2.28 tree-ssa-dom.c
*** tree-ssa-dom.c 28 Jul 2004 05:13:08 -0000 2.28
--- tree-ssa-dom.c 4 Aug 2004 15:42:14 -0000
*************** record_equivalences_from_stmt (tree stmt
*** 2872,2910 ****
if (rhs)
{
- v_may_def_optype v_may_defs = V_MAY_DEF_OPS (ann);
- v_must_def_optype v_must_defs = V_MUST_DEF_OPS (ann);
-
/* Build a new statement with the RHS and LHS exchanged. */
new = build (MODIFY_EXPR, TREE_TYPE (stmt), rhs, lhs);
! /* Get an annotation and set up the real operands. */
! get_stmt_ann (new);
! get_stmt_operands (new);
!
! /* Clear out the virtual operands on the new statement, we are
! going to set them explicitly below. */
! remove_vuses (new);
! remove_v_may_defs (new);
! remove_v_must_defs (new);
!
! start_ssa_stmt_operands (new);
! /* For each VDEF on the original statement, we want to create a
! VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new
! statement. */
! for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
! {
! tree op = V_MAY_DEF_RESULT (v_may_defs, j);
! add_vuse (op, new);
! }
!
! for (j = 0; j < NUM_V_MUST_DEFS (v_must_defs); j++)
! {
! tree op = V_MUST_DEF_OP (v_must_defs, j);
! add_vuse (op, new);
! }
!
! finalize_ssa_stmt_operands (new);
/* Finally enter the statement into the available expression
table. */
--- 2863,2872 ----
if (rhs)
{
/* Build a new statement with the RHS and LHS exchanged. */
new = build (MODIFY_EXPR, TREE_TYPE (stmt), rhs, lhs);
! create_ssa_artficial_load_stmt (&(ann->operands), new);
/* Finally enter the statement into the available expression
table. */
Index: tree-ssa-operands.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.c,v
retrieving revision 2.27
diff -c -p -r2.27 tree-ssa-operands.c
*** tree-ssa-operands.c 29 Jul 2004 17:15:35 -0000 2.27
--- tree-ssa-operands.c 4 Aug 2004 15:42:15 -0000
*************** Boston, MA 02111-1307, USA. */
*** 32,37 ****
--- 32,84 ----
#include "ggc.h"
#include "timevar.h"
+
+ /* This file contains the code required to mnage the operands cache of the
+ SSA optimizer. For every stmt, we maintain an operand cache in the stmt
+ annotation. This cache contains operands that will be of interets to
+ optimizers and other passes wishing to manipulate the IL.
+
+ The operand type are broken up into REAL and VIRTUAL operands. The real
+ operands are represented as pointers into the stmt's operand tree. Thus
+ any manipulation of the real operands will be reflected in the actual tree.
+ Virtual operands are represented solely in the cache, although the base
+ variable for the SSA_NAME may, or may not occur in the stmt's tree.
+ Manipulation of the virtual operands will not be reflected in the stmt tree.
+
+ The routines in this file are concerned with creating this operand cache
+ from a stmt tree.
+
+ get_stmt_operands() in the primary entry point.
+
+ The operand tree is the parsed by the various get_* routines which look
+ through the stmt tree for the occurence of operands which may be of
+ interest, and calls are made to the append_* routines whenever one is
+ found. There are 5 of these routines, each representing one of the
+ 5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and
+ Virtual Must Defs.
+
+ The append_* routines check for duplication, and simply keep a list of
+ unique objects for each operand type in the build_* extendable vectors.
+
+ Once the stmt tree is completely parsed, the finalize_ssa_operands()
+ routine is called, which proceeds to perform the finalization routine
+ on each of the 5 operand vectors which have been built up.
+
+ If the stmt had a previous operand cache, the finalization routines
+ attempt to match up the new operands with the old ones. If its a perfect
+ match, the old vector is simply reused. If it isn't a perfect match, then
+ a new vector is created and the new operands are placed there. For
+ virtual operands, if the previous cache had SSA_NAME version of a
+ variable, and that same variable occurs in the same operands cache, then
+ the new cache vector will also get the same SSA_NAME.
+
+ ie, if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
+ vector for VUSE, then the new vector will also be modified such that
+ it contains 'a_5' rather than 'a'.
+
+ */
+
+
/* Flags to describe operand properties in get_stmt_operands and helpers. */
/* By default, operands are loaded. */
*************** static GTY (()) varray_type build_vuses;
*** 68,97 ****
static GTY (()) varray_type build_v_must_defs;
#ifdef ENABLE_CHECKING
tree check_build_stmt;
#endif
- typedef struct voperands_d
- {
- v_may_def_optype v_may_def_ops;
- vuse_optype vuse_ops;
- v_must_def_optype v_must_def_ops;
- } *voperands_t;
-
static void note_addressable (tree, stmt_ann_t);
! static void get_expr_operands (tree, tree *, int, voperands_t);
! static void get_asm_expr_operands (tree, voperands_t);
! static void get_indirect_ref_operands (tree, tree, int, voperands_t);
! static void get_call_expr_operands (tree, tree, voperands_t);
! static inline void append_def (tree *, tree);
! static inline void append_use (tree *, tree);
! static void append_v_may_def (tree, tree, voperands_t);
! static void append_v_must_def (tree, tree, voperands_t);
! static void add_call_clobber_ops (tree, voperands_t);
! static void add_call_read_ops (tree, voperands_t);
! static void add_stmt_operand (tree *, tree, int, voperands_t);
! /* Return a vector of contiguous memory of a specified size. */
static inline def_optype
allocate_def_optype (unsigned num)
--- 115,138 ----
static GTY (()) varray_type build_v_must_defs;
#ifdef ENABLE_CHECKING
+ /* Used to make sure operand construction is working on the proper stmt. */
tree check_build_stmt;
#endif
static void note_addressable (tree, stmt_ann_t);
! static void get_expr_operands (tree, tree *, int);
! static void get_asm_expr_operands (tree);
! static void get_indirect_ref_operands (tree, tree, int);
! static void get_call_expr_operands (tree, tree);
! static inline void append_def (tree *);
! static inline void append_use (tree *);
! static void append_v_may_def (tree);
! static void append_v_must_def (tree);
! static void add_call_clobber_ops (tree);
! static void add_call_read_ops (tree);
! static void add_stmt_operand (tree *, tree, int);
! /* Return a vector of contiguous memory for NUM def operands. */
static inline def_optype
allocate_def_optype (unsigned num)
*************** allocate_def_optype (unsigned num)
*** 104,109 ****
--- 145,153 ----
return def_ops;
}
+
+ /* Return a vector of contiguous memory for NUM use operands. */
+
static inline use_optype
allocate_use_optype (unsigned num)
{
*************** allocate_use_optype (unsigned num)
*** 115,131 ****
return use_ops;
}
static inline v_may_def_optype
allocate_v_may_def_optype (unsigned num)
{
v_may_def_optype v_may_def_ops;
unsigned size;
! size = sizeof (struct v_may_def_optype_d) + sizeof (tree) * ((num * 2) - 1);
v_may_def_ops = ggc_alloc (size);
v_may_def_ops->num_v_may_defs = num;
return v_may_def_ops;
}
static inline vuse_optype
allocate_vuse_optype (unsigned num)
{
--- 159,182 ----
return use_ops;
}
+
+ /* Return a vector of contiguous memory for NUM v_may_def operands. */
+
static inline v_may_def_optype
allocate_v_may_def_optype (unsigned num)
{
v_may_def_optype v_may_def_ops;
unsigned size;
! size = sizeof (struct v_may_def_optype_d)
! + sizeof (v_may_def_operand_type_t) * (num - 1);
v_may_def_ops = ggc_alloc (size);
v_may_def_ops->num_v_may_defs = num;
return v_may_def_ops;
}
+
+ /* Return a vector of contiguous memory for NUM v_use operands. */
+
static inline vuse_optype
allocate_vuse_optype (unsigned num)
{
*************** allocate_vuse_optype (unsigned num)
*** 137,237 ****
return vuse_ops;
}
static inline v_must_def_optype
allocate_v_must_def_optype (unsigned num)
{
v_must_def_optype v_must_def_ops;
unsigned size;
! size = sizeof (struct v_must_def_optype_d) + sizeof (tree *) * (num - 1);
v_must_def_ops = ggc_alloc (size);
v_must_def_ops->num_v_must_defs = num;
return v_must_def_ops;
}
static inline void
! free_uses (use_optype *uses, bool dealloc)
{
if (*uses)
{
! if (dealloc)
! ggc_free (*uses);
*uses = NULL;
}
}
static inline void
! free_defs (def_optype *defs, bool dealloc)
{
if (*defs)
{
! if (dealloc)
! ggc_free (*defs);
*defs = NULL;
}
}
static inline void
! free_vuses (vuse_optype *vuses, bool dealloc)
{
if (*vuses)
{
! if (dealloc)
! ggc_free (*vuses);
*vuses = NULL;
}
}
static inline void
! free_v_may_defs (v_may_def_optype *v_may_defs, bool dealloc)
{
if (*v_may_defs)
{
! if (dealloc)
! ggc_free (*v_may_defs);
*v_may_defs = NULL;
}
}
static inline void
! free_v_must_defs (v_must_def_optype *v_must_defs, bool dealloc)
{
if (*v_must_defs)
{
! if (dealloc)
! ggc_free (*v_must_defs);
*v_must_defs = NULL;
}
}
- void
- remove_vuses (tree stmt)
- {
- stmt_ann_t ann;
-
- ann = stmt_ann (stmt);
- if (ann)
- free_vuses (&(ann->vuse_ops), true);
- }
! void
! remove_v_may_defs (tree stmt)
! {
! stmt_ann_t ann;
!
! ann = stmt_ann (stmt);
! if (ann)
! free_v_may_defs (&(ann->v_may_def_ops), true);
! }
!
! void
! remove_v_must_defs (tree stmt)
! {
! stmt_ann_t ann;
!
! ann = stmt_ann (stmt);
! if (ann)
! free_v_must_defs (&(ann->v_must_def_ops), true);
! }
void
init_ssa_operands (void)
--- 188,274 ----
return vuse_ops;
}
+
+ /* Return a vector of contiguous memory for NUM v_must_def operands. */
+
static inline v_must_def_optype
allocate_v_must_def_optype (unsigned num)
{
v_must_def_optype v_must_def_ops;
unsigned size;
! size = sizeof (struct v_must_def_optype_d) + sizeof (tree) * (num - 1);
v_must_def_ops = ggc_alloc (size);
v_must_def_ops->num_v_must_defs = num;
return v_must_def_ops;
}
+
+ /* Free memory for USES. */
+
static inline void
! free_uses (use_optype *uses)
{
if (*uses)
{
! ggc_free (*uses);
*uses = NULL;
}
}
+
+ /* Free memory for DEFS. */
+
static inline void
! free_defs (def_optype *defs)
{
if (*defs)
{
! ggc_free (*defs);
*defs = NULL;
}
}
+
+ /* Free memory for VUSES. */
+
static inline void
! free_vuses (vuse_optype *vuses)
{
if (*vuses)
{
! ggc_free (*vuses);
*vuses = NULL;
}
}
+
+ /* Free memory for V_MAY_DEFS. */
+
static inline void
! free_v_may_defs (v_may_def_optype *v_may_defs)
{
if (*v_may_defs)
{
! ggc_free (*v_may_defs);
*v_may_defs = NULL;
}
}
+
+ /* Free memory for V_MUST_DEFS. */
+
static inline void
! free_v_must_defs (v_must_def_optype *v_must_defs)
{
if (*v_must_defs)
{
! ggc_free (*v_must_defs);
*v_must_defs = NULL;
}
}
! /* Initialize the operand cache routines. */
void
init_ssa_operands (void)
*************** init_ssa_operands (void)
*** 243,263 ****
VARRAY_TREE_INIT (build_v_must_defs, 10, "build v_must_defs");
}
void
fini_ssa_operands (void)
{
}
! static void
! finalize_ssa_defs (tree stmt)
{
unsigned num, x;
! stmt_ann_t ann;
! def_optype def_ops;
num = VARRAY_ACTIVE_SIZE (build_defs);
if (num == 0)
! return;
#ifdef ENABLE_CHECKING
/* There should only be a single real definition per assignment. */
--- 280,312 ----
VARRAY_TREE_INIT (build_v_must_defs, 10, "build v_must_defs");
}
+
+ /* Dispose of anything required by the operand routines. */
+
void
fini_ssa_operands (void)
{
}
!
! /* All the finalize_ssa_* routines do the work required to turn the build_
! VARRAY into an operand_vector of the appropriate type. The original vector,
! if any, is passed in for comparison and virtual SSA_NAME reuse. If the
! old vector is reused, the pointer passed in is set to NULL so that
! the memory is not freed when the old operands are freed. */
!
! /* Return a new def operand vector for STMT, comparing to OLD_OPS_P. */
!
! static def_optype
! finalize_ssa_defs (def_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
{
unsigned num, x;
! def_optype def_ops, old_ops;
! bool build_diff;
num = VARRAY_ACTIVE_SIZE (build_defs);
if (num == 0)
! return NULL;
#ifdef ENABLE_CHECKING
/* There should only be a single real definition per assignment. */
*************** finalize_ssa_defs (tree stmt)
*** 265,289 ****
abort ();
#endif
! def_ops = allocate_def_optype (num);
! for (x = 0; x < num ; x++)
! def_ops->defs[x].def = VARRAY_TREE_PTR (build_defs, x);
VARRAY_POP_ALL (build_defs);
! ann = stmt_ann (stmt);
! ann->def_ops = def_ops;
}
! static void
! finalize_ssa_uses (tree stmt)
{
unsigned num, x;
! use_optype use_ops;
! stmt_ann_t ann;
num = VARRAY_ACTIVE_SIZE (build_uses);
if (num == 0)
! return;
#ifdef ENABLE_CHECKING
{
--- 314,364 ----
abort ();
#endif
! old_ops = *old_ops_p;
!
! /* Compare old vector and new array. */
! build_diff = true;
! if (old_ops && old_ops->num_defs == num)
! {
! build_diff = false;
! for (x = 0; x < num; x++)
! if (old_ops->defs[x].def != VARRAY_TREE_PTR (build_defs, x))
! {
! build_diff = true;
! break;
! }
! }
!
! if (!build_diff)
! {
! def_ops = old_ops;
! *old_ops_p = NULL;
! }
! else
! {
! def_ops = allocate_def_optype (num);
! for (x = 0; x < num ; x++)
! def_ops->defs[x].def = VARRAY_TREE_PTR (build_defs, x);
! }
!
VARRAY_POP_ALL (build_defs);
! return def_ops;
}
!
! /* Return a new use operand vector for STMT, comparing to OLD_OPS_P. */
!
! static use_optype
! finalize_ssa_uses (use_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
{
unsigned num, x;
! use_optype use_ops, old_ops;
! bool build_diff;
num = VARRAY_ACTIVE_SIZE (build_uses);
if (num == 0)
! return NULL;
#ifdef ENABLE_CHECKING
{
*************** finalize_ssa_uses (tree stmt)
*** 297,357 ****
abort ();
}
#endif
! use_ops = allocate_use_optype (num);
! for (x = 0; x < num ; x++)
! use_ops->uses[x].use = VARRAY_TREE_PTR (build_uses, x);
VARRAY_POP_ALL (build_uses);
! ann = stmt_ann (stmt);
! ann->use_ops = use_ops;
}
! static void
! finalize_ssa_v_may_defs (tree stmt)
{
! unsigned num, x;
! v_may_def_optype v_may_def_ops;
! stmt_ann_t ann;
num = VARRAY_ACTIVE_SIZE (build_v_may_defs);
if (num == 0)
! return;
! #ifdef ENABLE_CHECKING
! /* V_MAY_DEFs must be entered in pairs of result/uses. */
! if (num % 2 != 0)
! abort();
! #endif
! v_may_def_ops = allocate_v_may_def_optype (num / 2);
! for (x = 0; x < num; x++)
! v_may_def_ops->v_may_defs[x] = VARRAY_TREE (build_v_may_defs, x);
! VARRAY_CLEAR (build_v_may_defs);
! ann = stmt_ann (stmt);
! ann->v_may_def_ops = v_may_def_ops;
}
- static inline void
- finalize_ssa_vuses (tree stmt)
- {
- unsigned num, x;
- stmt_ann_t ann;
- vuse_optype vuse_ops;
- v_may_def_optype v_may_defs;
! #ifdef ENABLE_CHECKING
! if (VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0)
! {
! fprintf (stderr, "Please finalize V_MAY_DEFs before finalize VUSES.\n");
! abort ();
! }
! #endif
num = VARRAY_ACTIVE_SIZE (build_vuses);
if (num == 0)
! return;
/* Remove superfluous VUSE operands. If the statement already has a
V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
--- 372,498 ----
abort ();
}
#endif
+ old_ops = *old_ops_p;
! /* Check if the old vector and the new array are the same. */
! build_diff = true;
! if (old_ops && old_ops->num_uses == num)
! {
! build_diff = false;
! for (x = 0; x < num; x++)
! if (old_ops->uses[x].use != VARRAY_TREE_PTR (build_uses, x))
! {
! build_diff = true;
! break;
! }
! }
!
! if (!build_diff)
! {
! use_ops = old_ops;
! *old_ops_p = NULL;
! }
! else
! {
! use_ops = allocate_use_optype (num);
! for (x = 0; x < num ; x++)
! use_ops->uses[x].use = VARRAY_TREE_PTR (build_uses, x);
! }
VARRAY_POP_ALL (build_uses);
! return use_ops;
}
!
! /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P. */
!
! static v_may_def_optype
! finalize_ssa_v_may_defs (v_may_def_optype *old_ops_p)
{
! unsigned num, x, i, old_num;
! v_may_def_optype v_may_def_ops, old_ops;
! tree result, var;
! bool build_diff;
num = VARRAY_ACTIVE_SIZE (build_v_may_defs);
if (num == 0)
! return NULL;
! old_ops = *old_ops_p;
! /* Check if the old vector and the new array are the same. */
! build_diff = true;
! if (old_ops && old_ops->num_v_may_defs == num)
! {
! old_num = num;
! build_diff = false;
! for (x = 0; x < num; x++)
! {
! var = old_ops->v_may_defs[x].def;
! if (TREE_CODE (var) == SSA_NAME)
! var = SSA_NAME_VAR (var);
! if (var != VARRAY_TREE (build_v_may_defs, x))
! {
! build_diff = true;
! break;
! }
! }
! }
! else
! old_num = (old_ops ? old_ops->num_v_may_defs : 0);
! if (!build_diff)
! {
! v_may_def_ops = old_ops;
! *old_ops_p = NULL;
! }
! else
! {
! v_may_def_ops = allocate_v_may_def_optype (num);
! for (x = 0; x < num; x++)
! {
! var = VARRAY_TREE (build_v_may_defs, x);
! /* Look for VAR in the old operands vector. */
! for (i = 0; i < old_num; i++)
! {
! result = old_ops->v_may_defs[i].def;
! if (TREE_CODE (result) == SSA_NAME)
! result = SSA_NAME_VAR (result);
! if (result == var)
! {
! v_may_def_ops->v_may_defs[x] = old_ops->v_may_defs[i];
! break;
! }
! }
! if (i == old_num)
! {
! v_may_def_ops->v_may_defs[x].def = var;
! v_may_def_ops->v_may_defs[x].use = var;
! }
! }
! }
!
! /* Empty the V_MAY_DEF build vector after VUSES have been processed. */
!
! return v_may_def_ops;
}
! /* Return a new vuse operand vector, comparing to OLD_OPS_P. */
!
! static vuse_optype
! finalize_ssa_vuses (vuse_optype *old_ops_p)
! {
! unsigned num, x, i, num_v_may_defs, old_num;
! vuse_optype vuse_ops, old_ops;
! bool build_diff;
num = VARRAY_ACTIVE_SIZE (build_vuses);
if (num == 0)
! {
! VARRAY_POP_ALL (build_v_may_defs);
! return NULL;
! }
/* Remove superfluous VUSE operands. If the statement already has a
V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
*************** finalize_ssa_vuses (tree stmt)
*** 365,406 ****
The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
operation. */
! ann = stmt_ann (stmt);
! v_may_defs = V_MAY_DEF_OPS (ann);
! if (NUM_V_MAY_DEFS (v_may_defs) > 0)
{
size_t i, j;
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
{
! bool found = false;
! for (j = 0; j < NUM_V_MAY_DEFS (v_may_defs); j++)
{
! tree vuse_var, v_may_def_var;
! tree vuse = VARRAY_TREE (build_vuses, i);
! tree v_may_def = V_MAY_DEF_OP (v_may_defs, j);
!
! if (TREE_CODE (vuse) == SSA_NAME)
! vuse_var = SSA_NAME_VAR (vuse);
! else
! vuse_var = vuse;
!
! if (TREE_CODE (v_may_def) == SSA_NAME)
! v_may_def_var = SSA_NAME_VAR (v_may_def);
! else
! v_may_def_var = v_may_def;
!
! if (vuse_var == v_may_def_var)
! {
! found = true;
break;
- }
}
/* If we found a useless VUSE operand, remove it from the
operand array by replacing it with the last active element
in the operand array (unless the useless VUSE was the
last operand, in which case we simply remove it. */
! if (found)
{
if (i != VARRAY_ACTIVE_SIZE (build_vuses) - 1)
{
--- 506,531 ----
The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
operation. */
! num_v_may_defs = VARRAY_ACTIVE_SIZE (build_v_may_defs);
!
! if (num_v_may_defs > 0)
{
size_t i, j;
+ tree vuse;
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
{
! vuse = VARRAY_TREE (build_vuses, i);
! for (j = 0; j < num_v_may_defs; j++)
{
! if (vuse == VARRAY_TREE (build_v_may_defs, j))
break;
}
/* If we found a useless VUSE operand, remove it from the
operand array by replacing it with the last active element
in the operand array (unless the useless VUSE was the
last operand, in which case we simply remove it. */
! if (j != num_v_may_defs)
{
if (i != VARRAY_ACTIVE_SIZE (build_vuses) - 1)
{
*************** finalize_ssa_vuses (tree stmt)
*** 421,445 ****
num = VARRAY_ACTIVE_SIZE (build_vuses);
/* We could have reduced the size to zero now, however. */
if (num == 0)
! return;
! vuse_ops = allocate_vuse_optype (num);
! for (x = 0; x < num; x++)
! vuse_ops->vuses[x] = VARRAY_TREE (build_vuses, x);
! VARRAY_CLEAR (build_vuses);
! ann->vuse_ops = vuse_ops;
}
! static void
! finalize_ssa_v_must_defs (tree stmt)
! {
! unsigned num, x;
! stmt_ann_t ann;
! v_must_def_optype v_must_def_ops;
num = VARRAY_ACTIVE_SIZE (build_v_must_defs);
if (num == 0)
! return;
#ifdef ENABLE_CHECKING
/* There should only be a single V_MUST_DEF per assignment. */
--- 546,630 ----
num = VARRAY_ACTIVE_SIZE (build_vuses);
/* We could have reduced the size to zero now, however. */
if (num == 0)
! {
! VARRAY_POP_ALL (build_v_may_defs);
! return NULL;
! }
!
! old_ops = *old_ops_p;
!
! /* Determine whether vuses is the same as the old vector. */
! build_diff = true;
! if (old_ops && old_ops->num_vuses == num)
! {
! old_num = num;
! build_diff = false;
! for (x = 0; x < num ; x++)
! {
! tree v;
! v = old_ops->vuses[x];
! if (TREE_CODE (v) == SSA_NAME)
! v = SSA_NAME_VAR (v);
! if (v != VARRAY_TREE (build_vuses, x))
! {
! build_diff = true;
! break;
! }
! }
! }
! else
! old_num = (old_ops ? old_ops->num_vuses : 0);
! if (!build_diff)
! {
! vuse_ops = old_ops;
! *old_ops_p = NULL;
! }
! else
! {
! vuse_ops = allocate_vuse_optype (num);
! for (x = 0; x < num; x++)
! {
! tree result, var = VARRAY_TREE (build_vuses, x);
! /* Look for VAR in the old vector, and use that SSA_NAME. */
! for (i = 0; i < old_num; i++)
! {
! result = old_ops->vuses[i];
! if (TREE_CODE (result) == SSA_NAME)
! result = SSA_NAME_VAR (result);
! if (result == var)
! {
! vuse_ops->vuses[x] = old_ops->vuses[i];
! break;
! }
! }
! if (i == old_num)
! vuse_ops->vuses[x] = var;
! }
! }
!
! /* The v_may_def build vector wasn't freed because we needed it here.
! Free it now with the vuses build vector. */
! VARRAY_POP_ALL (build_vuses);
! VARRAY_POP_ALL (build_v_may_defs);
!
! return vuse_ops;
}
!
! /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P. */
!
! static v_must_def_optype
! finalize_ssa_v_must_defs (v_must_def_optype *old_ops_p,
! tree stmt ATTRIBUTE_UNUSED)
! {
! unsigned num, x, i, old_num = 0;
! v_must_def_optype v_must_def_ops, old_ops;
! bool build_diff;
num = VARRAY_ACTIVE_SIZE (build_v_must_defs);
if (num == 0)
! return NULL;
#ifdef ENABLE_CHECKING
/* There should only be a single V_MUST_DEF per assignment. */
*************** finalize_ssa_v_must_defs (tree stmt)
*** 447,483 ****
abort ();
#endif
! v_must_def_ops = allocate_v_must_def_optype (num);
! for (x = 0; x < num ; x++)
! v_must_def_ops->v_must_defs[x] = VARRAY_TREE (build_v_must_defs, x);
VARRAY_POP_ALL (build_v_must_defs);
! ann = stmt_ann (stmt);
! ann->v_must_def_ops = v_must_def_ops;
}
- extern void
- finalize_ssa_stmt_operands (tree stmt)
- {
- #ifdef ENABLE_CHECKING
- if (check_build_stmt == NULL)
- abort();
- #endif
! finalize_ssa_defs (stmt);
! finalize_ssa_uses (stmt);
! finalize_ssa_v_must_defs (stmt);
! finalize_ssa_v_may_defs (stmt);
! finalize_ssa_vuses (stmt);
! #ifdef ENABLE_CHECKING
! check_build_stmt = NULL;
! #endif
}
! extern void
! verify_start_operands (tree stmt ATTRIBUTE_UNUSED)
{
#ifdef ENABLE_CHECKING
if (VARRAY_ACTIVE_SIZE (build_defs) > 0
--- 632,712 ----
abort ();
#endif
! old_ops = *old_ops_p;
!
! /* Check if the old vector and the new array are the same. */
! build_diff = true;
! if (old_ops && old_ops->num_v_must_defs == num)
! {
! old_num = num;
! build_diff = false;
! for (x = 0; x < num; x++)
! {
! tree var = old_ops->v_must_defs[x];
! if (TREE_CODE (var) == SSA_NAME)
! var = SSA_NAME_VAR (var);
! if (var != VARRAY_TREE (build_v_must_defs, x))
! {
! build_diff = true;
! break;
! }
! }
! }
! else
! old_num = (old_ops ? old_ops->num_v_must_defs : 0);
!
! if (!build_diff)
! {
! v_must_def_ops = old_ops;
! *old_ops_p = NULL;
! }
! else
! {
! v_must_def_ops = allocate_v_must_def_optype (num);
! for (x = 0; x < num ; x++)
! {
! tree result, var = VARRAY_TREE (build_v_must_defs, x);
! /* Look for VAR in the original vector. */
! for (i = 0; i < old_num; i++)
! {
! result = old_ops->v_must_defs[i];
! if (TREE_CODE (result) == SSA_NAME)
! result = SSA_NAME_VAR (result);
! if (result == var)
! {
! v_must_def_ops->v_must_defs[x] = old_ops->v_must_defs[i];
! break;
! }
! }
! if (i == old_num)
! v_must_def_ops->v_must_defs[x] = var;
! }
! }
VARRAY_POP_ALL (build_v_must_defs);
! return v_must_def_ops;
}
! /* Finalize all the build vectors, fill the new ones into INFO. */
! static inline void
! finalize_ssa_stmt_operands (tree stmt, stmt_operands_p old_ops,
! stmt_operands_p new_ops)
! {
! new_ops->def_ops = finalize_ssa_defs (&(old_ops->def_ops), stmt);
! new_ops->use_ops = finalize_ssa_uses (&(old_ops->use_ops), stmt);
! new_ops->v_must_def_ops
! = finalize_ssa_v_must_defs (&(old_ops->v_must_def_ops), stmt);
! new_ops->v_may_def_ops = finalize_ssa_v_may_defs (&(old_ops->v_may_def_ops));
! new_ops->vuse_ops = finalize_ssa_vuses (&(old_ops->vuse_ops));
}
! /* Start the process of building up operands vectors in INFO. */
!
! static inline void
! start_ssa_stmt_operands (void)
{
#ifdef ENABLE_CHECKING
if (VARRAY_ACTIVE_SIZE (build_defs) > 0
*************** verify_start_operands (tree stmt ATTRIBU
*** 486,761 ****
|| VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0
|| VARRAY_ACTIVE_SIZE (build_v_must_defs) > 0)
abort ();
- if (check_build_stmt != NULL)
- abort();
- check_build_stmt = stmt;
#endif
}
! /* Add DEF_P to the list of pointers to operands defined by STMT. */
static inline void
! append_def (tree *def_p, tree stmt ATTRIBUTE_UNUSED)
{
- #ifdef ENABLE_CHECKING
- if (check_build_stmt != stmt)
- abort();
- #endif
VARRAY_PUSH_TREE_PTR (build_defs, def_p);
}
! /* Add USE_P to the list of pointers to operands used by STMT. */
static inline void
! append_use (tree *use_p, tree stmt ATTRIBUTE_UNUSED)
{
- #ifdef ENABLE_CHECKING
- if (check_build_stmt != stmt)
- abort();
- #endif
VARRAY_PUSH_TREE_PTR (build_uses, use_p);
}
! /* Add a new virtual def for variable VAR to statement STMT. If PREV_VOPS
! is not NULL, the existing entries are preserved and no new entries are
! added here. This is done to preserve the SSA numbering of virtual
! operands. */
! static void
! append_v_may_def (tree var, tree stmt, voperands_t prev_vops)
{
! stmt_ann_t ann;
! size_t i;
! tree result, source;
!
! #ifdef ENABLE_CHECKING
! if (check_build_stmt != stmt)
! abort();
! #endif
!
! ann = stmt_ann (stmt);
/* Don't allow duplicate entries. */
! for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_may_defs); i += 2)
! {
! tree result = VARRAY_TREE (build_v_may_defs, i);
! if (var == result
! || (TREE_CODE (result) == SSA_NAME
! && var == SSA_NAME_VAR (result)))
! return;
! }
!
! /* If the statement already had virtual definitions, see if any of the
! existing V_MAY_DEFs matches VAR. If so, re-use it, otherwise add a new
! V_MAY_DEF for VAR. */
! result = NULL_TREE;
! source = NULL_TREE;
! if (prev_vops)
! for (i = 0; i < NUM_V_MAY_DEFS (prev_vops->v_may_def_ops); i++)
! {
! result = V_MAY_DEF_RESULT (prev_vops->v_may_def_ops, i);
! if (result == var
! || (TREE_CODE (result) == SSA_NAME
! && SSA_NAME_VAR (result) == var))
! {
! source = V_MAY_DEF_OP (prev_vops->v_may_def_ops, i);
! break;
! }
! }
!
! /* If no previous V_MAY_DEF operand was found for VAR, create one now. */
! if (source == NULL_TREE)
! {
! result = var;
! source = var;
! }
!
! VARRAY_PUSH_TREE (build_v_may_defs, result);
! VARRAY_PUSH_TREE (build_v_may_defs, source);
}
! /* Add VAR to the list of virtual uses for STMT. If PREV_VOPS
! is not NULL, the existing entries are preserved and no new entries are
! added here. This is done to preserve the SSA numbering of virtual
! operands. */
! static void
! append_vuse (tree var, tree stmt, voperands_t prev_vops)
{
- stmt_ann_t ann;
size_t i;
- bool found;
- tree vuse;
-
- #ifdef ENABLE_CHECKING
- if (check_build_stmt != stmt)
- abort();
- #endif
-
- ann = stmt_ann (stmt);
/* Don't allow duplicate entries. */
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
! {
! tree vuse_var = VARRAY_TREE (build_vuses, i);
! if (var == vuse_var
! || (TREE_CODE (vuse_var) == SSA_NAME
! && var == SSA_NAME_VAR (vuse_var)))
! return;
! }
!
! /* If the statement already had virtual uses, see if any of the
! existing VUSEs matches VAR. If so, re-use it, otherwise add a new
! VUSE for VAR. */
! found = false;
! vuse = NULL_TREE;
! if (prev_vops)
! for (i = 0; i < NUM_VUSES (prev_vops->vuse_ops); i++)
! {
! vuse = VUSE_OP (prev_vops->vuse_ops, i);
! if (vuse == var
! || (TREE_CODE (vuse) == SSA_NAME
! && SSA_NAME_VAR (vuse) == var))
! {
! found = true;
! break;
! }
! }
!
! /* If VAR existed already in PREV_VOPS, re-use it. */
! if (found)
! var = vuse;
VARRAY_PUSH_TREE (build_vuses, var);
}
- /* Add VAR to the list of virtual must definitions for STMT. If PREV_VOPS
- is not NULL, the existing entries are preserved and no new entries are
- added here. This is done to preserve the SSA numbering of virtual
- operands. */
! static void
! append_v_must_def (tree var, tree stmt, voperands_t prev_vops)
! {
! stmt_ann_t ann;
! size_t i;
! bool found;
! tree v_must_def;
! #ifdef ENABLE_CHECKING
! if (check_build_stmt != stmt)
! abort();
! #endif
!
! ann = stmt_ann (stmt);
/* Don't allow duplicate entries. */
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_must_defs); i++)
! {
! tree v_must_def_var = VARRAY_TREE (build_v_must_defs, i);
! if (var == v_must_def_var
! || (TREE_CODE (v_must_def_var) == SSA_NAME
! && var == SSA_NAME_VAR (v_must_def_var)))
! return;
! }
!
! /* If the statement already had virtual must defs, see if any of the
! existing V_MUST_DEFs matches VAR. If so, re-use it, otherwise add a new
! V_MUST_DEF for VAR. */
! found = false;
! v_must_def = NULL_TREE;
! if (prev_vops)
! for (i = 0; i < NUM_V_MUST_DEFS (prev_vops->v_must_def_ops); i++)
! {
! v_must_def = V_MUST_DEF_OP (prev_vops->v_must_def_ops, i);
! if (v_must_def == var
! || (TREE_CODE (v_must_def) == SSA_NAME
! && SSA_NAME_VAR (v_must_def) == var))
! {
! found = true;
! break;
! }
! }
!
! /* If VAR existed already in PREV_VOPS, re-use it. */
! if (found)
! var = v_must_def;
VARRAY_PUSH_TREE (build_v_must_defs, var);
}
!
! /* External entry point which by-passes the previous vops mechanism. */
! void
! add_vuse (tree var, tree stmt)
! {
! append_vuse (var, stmt, NULL);
! }
!
!
! /* Get the operands of statement STMT. Note that repeated calls to
! get_stmt_operands for the same statement will do nothing until the
! statement is marked modified by a call to modify_stmt(). */
void
! get_stmt_operands (tree stmt)
{
enum tree_code code;
! stmt_ann_t ann;
! struct voperands_d prev_vops;
!
! #if defined ENABLE_CHECKING
! /* The optimizers cannot handle statements that are nothing but a
! _DECL. This indicates a bug in the gimplifier. */
! if (SSA_VAR_P (stmt))
! abort ();
! #endif
!
! /* Ignore error statements. */
! if (TREE_CODE (stmt) == ERROR_MARK)
! return;
!
! ann = get_stmt_ann (stmt);
!
! /* If the statement has not been modified, the operands are still valid. */
! if (!ann->modified)
! return;
!
! timevar_push (TV_TREE_OPS);
!
/* Initially assume that the statement has no volatile operands, nor
makes aliased loads or stores. */
! ann->has_volatile_ops = false;
! ann->makes_aliased_stores = false;
! ann->makes_aliased_loads = false;
!
! /* Remove any existing operands as they will be scanned again. */
! free_defs (&(ann->def_ops), true);
! free_uses (&(ann->use_ops), true);
!
! /* Before removing existing virtual operands, save them in PREV_VOPS so
! that we can re-use their SSA versions. */
! prev_vops.v_may_def_ops = V_MAY_DEF_OPS (ann);
! prev_vops.vuse_ops = VUSE_OPS (ann);
! prev_vops.v_must_def_ops = V_MUST_DEF_OPS (ann);
!
! /* Don't free the previous values to memory since we're still using them. */
! free_v_may_defs (&(ann->v_may_def_ops), false);
! free_vuses (&(ann->vuse_ops), false);
! free_v_must_defs (&(ann->v_must_def_ops), false);
! start_ssa_stmt_operands (stmt);
code = TREE_CODE (stmt);
switch (code)
{
case MODIFY_EXPR:
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none, &prev_vops);
if (TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_RANGE_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == COMPONENT_REF
--- 715,835 ----
|| VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0
|| VARRAY_ACTIVE_SIZE (build_v_must_defs) > 0)
abort ();
#endif
}
! /* Add DEF_P to the list of pointers to operands. */
static inline void
! append_def (tree *def_p)
{
VARRAY_PUSH_TREE_PTR (build_defs, def_p);
}
! /* Add USE_P to the list of pointers to operands. */
static inline void
! append_use (tree *use_p)
{
VARRAY_PUSH_TREE_PTR (build_uses, use_p);
}
! /* Add a new virtual may def for variable VAR to the build array. */
! static inline void
! append_v_may_def (tree var)
{
! unsigned i;
/* Don't allow duplicate entries. */
+ for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_may_defs); i++)
+ if (var == VARRAY_TREE (build_v_may_defs, i))
+ return;
! VARRAY_PUSH_TREE (build_v_may_defs, var);
}
! /* Add VAR to the list of virtual uses. */
! static inline void
! append_vuse (tree var)
{
size_t i;
/* Don't allow duplicate entries. */
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
! if (var == VARRAY_TREE (build_vuses, i))
! return;
VARRAY_PUSH_TREE (build_vuses, var);
}
! /* Add VAR to the list of virtual must definitions for INFO. */
! static inline void
! append_v_must_def (tree var)
! {
! unsigned i;
/* Don't allow duplicate entries. */
for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_must_defs); i++)
! if (var == VARRAY_TREE (build_v_must_defs, i))
! return;
VARRAY_PUSH_TREE (build_v_must_defs, var);
}
! /* Create an operands cache for STMT, returning it in NEW_OPS. OLD_OPS are the
! original operands, and if ANN is non-null, appropriate stmt flags are set
! in the stmt's annotation. Note that some fields in old_ops may
! change to NULL, although none of the memory they originally pointed to
! will be destroyed. It is appropriate to call free_stmt_operands() on
! the value returned in old_ops.
!
! The rationale for this: Certain optimizations wish to exmaine the difference
! between new_ops and old_ops after processing. If a set of operands don't
! change, new_ops will simply assume the pointer in old_ops, and the old_ops
! pointer will be set to NULL, indicating no memory needs to be cleared.
! Usage might appear something like:
!
! old_ops_copy = old_ops = stmt_ann(stmt)->operands;
! build_ssa_operands (stmt, NULL, &old_ops, &new_ops);
! <* compare old_ops_copy and new_ops *>
! free_ssa_operands (old_ops); */
void
! build_ssa_operands (tree stmt, stmt_ann_t ann, stmt_operands_p old_ops,
! stmt_operands_p new_ops)
{
enum tree_code code;
! tree_ann_t saved_ann = stmt->common.ann;
!
! /* Replace stmt's annotation with the one passed in for the duration
! of the operand building process. This allows "fake" stmts to be built
! and not be included in other data structures which can be built here. */
! stmt->common.ann = (tree_ann_t) ann;
!
/* Initially assume that the statement has no volatile operands, nor
makes aliased loads or stores. */
! if (ann)
! {
! ann->has_volatile_ops = false;
! ann->makes_aliased_stores = false;
! ann->makes_aliased_loads = false;
! }
! start_ssa_stmt_operands ();
code = TREE_CODE (stmt);
switch (code)
{
case MODIFY_EXPR:
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
if (TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_RANGE_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == COMPONENT_REF
*************** get_stmt_operands (tree stmt)
*** 765,799 ****
modified in that case. FIXME we should represent somehow
that it is killed on the fallthrough path. */
|| tree_could_throw_p (TREE_OPERAND (stmt, 1)))
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_is_def,
! &prev_vops);
else
get_expr_operands (stmt, &TREE_OPERAND (stmt, 0),
! opf_is_def | opf_kill_def, &prev_vops);
break;
case COND_EXPR:
! get_expr_operands (stmt, &COND_EXPR_COND (stmt), opf_none, &prev_vops);
break;
case SWITCH_EXPR:
! get_expr_operands (stmt, &SWITCH_COND (stmt), opf_none, &prev_vops);
break;
case ASM_EXPR:
! get_asm_expr_operands (stmt, &prev_vops);
break;
case RETURN_EXPR:
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_none, &prev_vops);
break;
case GOTO_EXPR:
! get_expr_operands (stmt, &GOTO_DESTINATION (stmt), opf_none, &prev_vops);
break;
case LABEL_EXPR:
! get_expr_operands (stmt, &LABEL_EXPR_LABEL (stmt), opf_none, &prev_vops);
break;
/* These nodes contain no variable references. */
--- 839,872 ----
modified in that case. FIXME we should represent somehow
that it is killed on the fallthrough path. */
|| tree_could_throw_p (TREE_OPERAND (stmt, 1)))
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_is_def);
else
get_expr_operands (stmt, &TREE_OPERAND (stmt, 0),
! opf_is_def | opf_kill_def);
break;
case COND_EXPR:
! get_expr_operands (stmt, &COND_EXPR_COND (stmt), opf_none);
break;
case SWITCH_EXPR:
! get_expr_operands (stmt, &SWITCH_COND (stmt), opf_none);
break;
case ASM_EXPR:
! get_asm_expr_operands (stmt);
break;
case RETURN_EXPR:
! get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_none);
break;
case GOTO_EXPR:
! get_expr_operands (stmt, &GOTO_DESTINATION (stmt), opf_none);
break;
case LABEL_EXPR:
! get_expr_operands (stmt, &LABEL_EXPR_LABEL (stmt), opf_none);
break;
/* These nodes contain no variable references. */
*************** get_stmt_operands (tree stmt)
*** 812,827 ****
append_use. This default will handle statements like empty
statements, or CALL_EXPRs that may appear on the RHS of a statement
or as statements themselves. */
! get_expr_operands (stmt, &stmt, opf_none, &prev_vops);
break;
}
! finalize_ssa_stmt_operands (stmt);
! /* Now free the previous virtual ops to memory. */
! free_v_may_defs (&(prev_vops.v_may_def_ops), true);
! free_vuses (&(prev_vops.vuse_ops), true);
! free_v_must_defs (&(prev_vops.v_must_def_ops), true);
/* Clear the modified bit for STMT. Subsequent calls to
get_stmt_operands for this statement will do nothing until the
--- 885,951 ----
append_use. This default will handle statements like empty
statements, or CALL_EXPRs that may appear on the RHS of a statement
or as statements themselves. */
! get_expr_operands (stmt, &stmt, opf_none);
break;
}
! finalize_ssa_stmt_operands (stmt, old_ops, new_ops);
! stmt->common.ann = saved_ann;
! }
!
!
! /* Free any operands vectors in OPS. */
!
! static void
! free_ssa_operands (stmt_operands_p ops)
! {
! if (ops->def_ops)
! free_defs (&(ops->def_ops));
! if (ops->use_ops)
! free_uses (&(ops->use_ops));
! if (ops->vuse_ops)
! free_vuses (&(ops->vuse_ops));
! if (ops->v_may_def_ops)
! free_v_may_defs (&(ops->v_may_def_ops));
! if (ops->v_must_def_ops)
! free_v_must_defs (&(ops->v_must_def_ops));
! }
!
!
! /* Get the operands of statement STMT. Note that repeated calls to
! get_stmt_operands for the same statement will do nothing until the
! statement is marked modified by a call to modify_stmt(). */
! void
! get_stmt_operands (tree stmt)
! {
! stmt_ann_t ann;
! stmt_operands_t old_operands;
!
! #if defined ENABLE_CHECKING
! /* The optimizers cannot handle statements that are nothing but a
! _DECL. This indicates a bug in the gimplifier. */
! if (SSA_VAR_P (stmt))
! abort ();
! #endif
!
! /* Ignore error statements. */
! if (TREE_CODE (stmt) == ERROR_MARK)
! return;
!
! ann = get_stmt_ann (stmt);
!
! /* If the statement has not been modified, the operands are still valid. */
! if (!ann->modified)
! return;
!
! timevar_push (TV_TREE_OPS);
!
! old_operands = ann->operands;
! memset (&(ann->operands), 0, sizeof (stmt_operands_t));
!
! build_ssa_operands (stmt, ann, &old_operands, &(ann->operands));
! free_ssa_operands (&old_operands);
/* Clear the modified bit for STMT. Subsequent calls to
get_stmt_operands for this statement will do nothing until the
*************** get_stmt_operands (tree stmt)
*** 832,843 ****
}
! /* Recursively scan the expression pointed by EXPR_P in statement STMT.
! FLAGS is one of the OPF_* constants modifying how to interpret the
! operands found. PREV_VOPS is as in append_v_may_def and append_vuse. */
static void
! get_expr_operands (tree stmt, tree *expr_p, int flags, voperands_t prev_vops)
{
enum tree_code code;
char class;
--- 956,967 ----
}
! /* Recursively scan the expression pointed by EXPR_P in statement referred to
! by INFO. FLAGS is one of the OPF_* constants modifying how to interpret the
! operands found. */
static void
! get_expr_operands (tree stmt, tree *expr_p, int flags)
{
enum tree_code code;
char class;
*************** get_expr_operands (tree stmt, tree *expr
*** 855,863 ****
/* We could have the address of a component, array member,
etc which has interesting variable references. */
/* Taking the address of a variable does not represent a
! reference to it, but the fact that STMT takes its address will be
of interest to some passes (e.g. alias resolution). */
! add_stmt_operand (expr_p, stmt, 0, NULL);
/* If the address is invariant, there may be no interesting variable
references inside. */
--- 979,987 ----
/* We could have the address of a component, array member,
etc which has interesting variable references. */
/* Taking the address of a variable does not represent a
! reference to it, but the fact that the stmt takes its address will be
of interest to some passes (e.g. alias resolution). */
! add_stmt_operand (expr_p, stmt, 0);
/* If the address is invariant, there may be no interesting variable
references inside. */
*************** get_expr_operands (tree stmt, tree *expr
*** 870,876 ****
does not allow non-registers as array indices). */
flags |= opf_no_vops;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
return;
case SSA_NAME:
--- 994,1000 ----
does not allow non-registers as array indices). */
flags |= opf_no_vops;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
return;
case SSA_NAME:
*************** get_expr_operands (tree stmt, tree *expr
*** 879,889 ****
case RESULT_DECL:
/* If we found a variable, add it to DEFS or USES depending
on the operand flags. */
! add_stmt_operand (expr_p, stmt, flags, prev_vops);
return;
case INDIRECT_REF:
! get_indirect_ref_operands (stmt, expr, flags, prev_vops);
return;
case ARRAY_REF:
--- 1003,1013 ----
case RESULT_DECL:
/* If we found a variable, add it to DEFS or USES depending
on the operand flags. */
! add_stmt_operand (expr_p, stmt, flags);
return;
case INDIRECT_REF:
! get_indirect_ref_operands (stmt, expr, flags);
return;
case ARRAY_REF:
*************** get_expr_operands (tree stmt, tree *expr
*** 896,908 ****
according to the value of IS_DEF. Recurse if the LHS of the
ARRAY_REF node is not a regular variable. */
if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
! add_stmt_operand (expr_p, stmt, flags, prev_vops);
else
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none, prev_vops);
return;
case COMPONENT_REF:
--- 1020,1032 ----
according to the value of IS_DEF. Recurse if the LHS of the
ARRAY_REF node is not a regular variable. */
if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
! add_stmt_operand (expr_p, stmt, flags);
else
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none);
return;
case COMPONENT_REF:
*************** get_expr_operands (tree stmt, tree *expr
*** 924,946 ****
/* If the LHS of the compound reference is not a regular variable,
recurse to keep looking for more operands in the subexpression. */
if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
! add_stmt_operand (expr_p, stmt, flags, prev_vops);
else
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
if (code == COMPONENT_REF)
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none, prev_vops);
return;
case WITH_SIZE_EXPR:
/* WITH_SIZE_EXPR is a pass-through reference to its first argument,
and an rvalue reference to its second argument. */
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
return;
case CALL_EXPR:
! get_call_expr_operands (stmt, expr, prev_vops);
return;
case MODIFY_EXPR:
--- 1048,1070 ----
/* If the LHS of the compound reference is not a regular variable,
recurse to keep looking for more operands in the subexpression. */
if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
! add_stmt_operand (expr_p, stmt, flags);
else
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
if (code == COMPONENT_REF)
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
return;
case WITH_SIZE_EXPR:
/* WITH_SIZE_EXPR is a pass-through reference to its first argument,
and an rvalue reference to its second argument. */
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
return;
case CALL_EXPR:
! get_call_expr_operands (stmt, expr);
return;
case MODIFY_EXPR:
*************** get_expr_operands (tree stmt, tree *expr
*** 948,954 ****
int subflags;
tree op;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none, prev_vops);
op = TREE_OPERAND (expr, 0);
if (TREE_CODE (op) == WITH_SIZE_EXPR)
--- 1072,1078 ----
int subflags;
tree op;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
op = TREE_OPERAND (expr, 0);
if (TREE_CODE (op) == WITH_SIZE_EXPR)
*************** get_expr_operands (tree stmt, tree *expr
*** 962,968 ****
else
subflags = opf_is_def | opf_kill_def;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), subflags, prev_vops);
return;
}
--- 1086,1092 ----
else
subflags = opf_is_def | opf_kill_def;
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), subflags);
return;
}
*************** get_expr_operands (tree stmt, tree *expr
*** 973,979 ****
tree t;
for (t = TREE_OPERAND (expr, 0); t ; t = TREE_CHAIN (t))
! get_expr_operands (stmt, &TREE_VALUE (t), opf_none, prev_vops);
return;
}
--- 1097,1103 ----
tree t;
for (t = TREE_OPERAND (expr, 0); t ; t = TREE_CHAIN (t))
! get_expr_operands (stmt, &TREE_VALUE (t), opf_none);
return;
}
*************** get_expr_operands (tree stmt, tree *expr
*** 982,988 ****
case BIT_FIELD_REF:
case VIEW_CONVERT_EXPR:
do_unary:
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
return;
case TRUTH_AND_EXPR:
--- 1106,1112 ----
case BIT_FIELD_REF:
case VIEW_CONVERT_EXPR:
do_unary:
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
return;
case TRUTH_AND_EXPR:
*************** get_expr_operands (tree stmt, tree *expr
*** 1023,1030 ****
}
}
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags, prev_vops);
return;
}
--- 1147,1154 ----
}
}
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
return;
}
*************** get_expr_operands (tree stmt, tree *expr
*** 1053,1064 ****
}
! /* Scan operands in ASM_EXPR STMT. PREV_VOPS is as in append_v_may_def and
! append_vuse. */
static void
! get_asm_expr_operands (tree stmt, voperands_t prev_vops)
{
int noutputs = list_length (ASM_OUTPUTS (stmt));
const char **oconstraints
= (const char **) alloca ((noutputs) * sizeof (const char *));
--- 1177,1188 ----
}
! /* Scan operands in the ASM_EXPR stmt refered to in INFO. */
static void
! get_asm_expr_operands (tree stmt)
{
+ stmt_ann_t s_ann = stmt_ann (stmt);
int noutputs = list_length (ASM_OUTPUTS (stmt));
const char **oconstraints
= (const char **) alloca ((noutputs) * sizeof (const char *));
*************** get_asm_expr_operands (tree stmt, vopera
*** 1066,1072 ****
tree link;
const char *constraint;
bool allows_mem, allows_reg, is_inout;
- stmt_ann_t s_ann = stmt_ann (stmt);
for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
{
--- 1190,1195 ----
*************** get_asm_expr_operands (tree stmt, vopera
*** 1090,1096 ****
note_addressable (t, s_ann);
}
! get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def, prev_vops);
}
for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
--- 1213,1219 ----
note_addressable (t, s_ann);
}
! get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def);
}
for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
*************** get_asm_expr_operands (tree stmt, vopera
*** 1109,1115 ****
note_addressable (t, s_ann);
}
! get_expr_operands (stmt, &TREE_VALUE (link), 0, prev_vops);
}
--- 1232,1238 ----
note_addressable (t, s_ann);
}
! get_expr_operands (stmt, &TREE_VALUE (link), 0);
}
*************** get_asm_expr_operands (tree stmt, vopera
*** 1122,1140 ****
/* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
decided to group them). */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_is_def, prev_vops);
else
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_is_def, prev_vops);
});
/* Now clobber all addressables. */
EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_is_def, prev_vops);
});
break;
--- 1245,1263 ----
/* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
decided to group them). */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_is_def);
else
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_is_def);
});
/* Now clobber all addressables. */
EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_is_def);
});
break;
*************** get_asm_expr_operands (tree stmt, vopera
*** 1144,1154 ****
/* A subroutine of get_expr_operands to handle INDIRECT_REF. */
static void
! get_indirect_ref_operands (tree stmt, tree expr, int flags,
! voperands_t prev_vops)
{
tree *pptr = &TREE_OPERAND (expr, 0);
tree ptr = *pptr;
if (SSA_VAR_P (ptr))
{
--- 1267,1278 ----
/* A subroutine of get_expr_operands to handle INDIRECT_REF. */
static void
! get_indirect_ref_operands (tree stmt, tree expr, int flags)
{
tree *pptr = &TREE_OPERAND (expr, 0);
tree ptr = *pptr;
+ stmt_ann_t ann = stmt_ann (stmt);
+
if (SSA_VAR_P (ptr))
{
*************** get_indirect_ref_operands (tree stmt, tr
*** 1160,1166 ****
&& pi->name_mem_tag)
{
/* PTR has its own memory tag. Use it. */
! add_stmt_operand (&pi->name_mem_tag, stmt, flags, prev_vops);
}
else
{
--- 1284,1290 ----
&& pi->name_mem_tag)
{
/* PTR has its own memory tag. Use it. */
! add_stmt_operand (&pi->name_mem_tag, stmt, flags);
}
else
{
*************** get_indirect_ref_operands (tree stmt, tr
*** 1187,1193 ****
ptr = SSA_NAME_VAR (ptr);
ann = var_ann (ptr);
if (ann->type_mem_tag)
! add_stmt_operand (&ann->type_mem_tag, stmt, flags, prev_vops);
}
}
--- 1311,1317 ----
ptr = SSA_NAME_VAR (ptr);
ann = var_ann (ptr);
if (ann->type_mem_tag)
! add_stmt_operand (&ann->type_mem_tag, stmt, flags);
}
}
*************** get_indirect_ref_operands (tree stmt, tr
*** 1196,1202 ****
optimizations from messing things up. */
else if (TREE_CODE (ptr) == INTEGER_CST)
{
! stmt_ann (stmt)->has_volatile_ops = true;
return;
}
--- 1320,1327 ----
optimizations from messing things up. */
else if (TREE_CODE (ptr) == INTEGER_CST)
{
! if (ann)
! ann->has_volatile_ops = true;
return;
}
*************** get_indirect_ref_operands (tree stmt, tr
*** 1211,1221 ****
{
/* Make sure we know the object is addressable. */
pptr = &TREE_OPERAND (ptr, 0);
! add_stmt_operand (pptr, stmt, 0, NULL);
/* Mark the object itself with a VUSE. */
pptr = &TREE_OPERAND (*pptr, 0);
! get_expr_operands (stmt, pptr, flags, prev_vops);
return;
}
--- 1336,1346 ----
{
/* Make sure we know the object is addressable. */
pptr = &TREE_OPERAND (ptr, 0);
! add_stmt_operand (pptr, stmt, 0);
/* Mark the object itself with a VUSE. */
pptr = &TREE_OPERAND (*pptr, 0);
! get_expr_operands (stmt, pptr, flags);
return;
}
*************** get_indirect_ref_operands (tree stmt, tr
*** 1224,1247 ****
abort ();
/* Add a USE operand for the base pointer. */
! get_expr_operands (stmt, pptr, opf_none, prev_vops);
}
/* A subroutine of get_expr_operands to handle CALL_EXPR. */
static void
! get_call_expr_operands (tree stmt, tree expr, voperands_t prev_vops)
{
tree op;
int call_flags = call_expr_flags (expr);
/* Find uses in the called function. */
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none, prev_vops);
for (op = TREE_OPERAND (expr, 1); op; op = TREE_CHAIN (op))
! get_expr_operands (stmt, &TREE_VALUE (op), opf_none, prev_vops);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none, prev_vops);
if (bitmap_first_set_bit (call_clobbered_vars) >= 0)
{
--- 1349,1372 ----
abort ();
/* Add a USE operand for the base pointer. */
! get_expr_operands (stmt, pptr, opf_none);
}
/* A subroutine of get_expr_operands to handle CALL_EXPR. */
static void
! get_call_expr_operands (tree stmt, tree expr)
{
tree op;
int call_flags = call_expr_flags (expr);
/* Find uses in the called function. */
! get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
for (op = TREE_OPERAND (expr, 1); op; op = TREE_CHAIN (op))
! get_expr_operands (stmt, &TREE_VALUE (op), opf_none);
! get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
if (bitmap_first_set_bit (call_clobbered_vars) >= 0)
{
*************** get_call_expr_operands (tree stmt, tree
*** 1250,1283 ****
there is no point in recording that. */
if (!(call_flags
& (ECF_PURE | ECF_CONST | ECF_NORETURN)))
! add_call_clobber_ops (stmt, prev_vops);
else if (!(call_flags & (ECF_CONST | ECF_NORETURN)))
! add_call_read_ops (stmt, prev_vops);
}
}
! /* Add *VAR_P to the appropriate operand array of STMT. FLAGS is as in
get_expr_operands. If *VAR_P is a GIMPLE register, it will be added to
the statement's real operands, otherwise it is added to virtual
! operands.
!
! PREV_VOPS is used when adding virtual operands to statements that
! already had them (See append_v_may_def and append_vuse). */
static void
! add_stmt_operand (tree *var_p, tree stmt, int flags, voperands_t prev_vops)
{
bool is_real_op;
tree var, sym;
! stmt_ann_t s_ann;
var_ann_t v_ann;
var = *var_p;
STRIP_NOPS (var);
- s_ann = stmt_ann (stmt);
-
/* If the operand is an ADDR_EXPR, add its operand to the list of
variables that have had their address taken in this statement. */
if (TREE_CODE (var) == ADDR_EXPR)
--- 1375,1403 ----
there is no point in recording that. */
if (!(call_flags
& (ECF_PURE | ECF_CONST | ECF_NORETURN)))
! add_call_clobber_ops (stmt);
else if (!(call_flags & (ECF_CONST | ECF_NORETURN)))
! add_call_read_ops (stmt);
}
}
! /* Add *VAR_P to the appropriate operand array for INFO. FLAGS is as in
get_expr_operands. If *VAR_P is a GIMPLE register, it will be added to
the statement's real operands, otherwise it is added to virtual
! operands. */
static void
! add_stmt_operand (tree *var_p, tree stmt, int flags)
{
bool is_real_op;
tree var, sym;
! stmt_ann_t s_ann = stmt_ann (stmt);
var_ann_t v_ann;
var = *var_p;
STRIP_NOPS (var);
/* If the operand is an ADDR_EXPR, add its operand to the list of
variables that have had their address taken in this statement. */
if (TREE_CODE (var) == ADDR_EXPR)
*************** add_stmt_operand (tree *var_p, tree stmt
*** 1303,1309 ****
/* Don't expose volatile variables to the optimizers. */
if (TREE_THIS_VOLATILE (sym))
{
! s_ann->has_volatile_ops = true;
return;
}
--- 1423,1430 ----
/* Don't expose volatile variables to the optimizers. */
if (TREE_THIS_VOLATILE (sym))
{
! if (s_ann)
! s_ann->has_volatile_ops = true;
return;
}
*************** add_stmt_operand (tree *var_p, tree stmt
*** 1311,1319 ****
{
/* The variable is a GIMPLE register. Add it to real operands. */
if (flags & opf_is_def)
! append_def (var_p, stmt);
else
! append_use (var_p, stmt);
}
else
{
--- 1432,1440 ----
{
/* The variable is a GIMPLE register. Add it to real operands. */
if (flags & opf_is_def)
! append_def (var_p);
else
! append_use (var_p);
}
else
{
*************** add_stmt_operand (tree *var_p, tree stmt
*** 1336,1358 ****
if (v_ann->is_alias_tag)
{
/* Alias tagged vars get regular V_MAY_DEF */
! s_ann->makes_aliased_stores = 1;
! append_v_may_def (var, stmt, prev_vops);
}
else if ((flags & opf_kill_def)
&& v_ann->mem_tag_kind == NOT_A_TAG)
/* V_MUST_DEF for non-aliased non-GIMPLE register
variable definitions. Avoid memory tags. */
! append_v_must_def (var, stmt, prev_vops);
else
/* Call-clobbered variables & memory tags get
V_MAY_DEF */
! append_v_may_def (var, stmt, prev_vops);
}
else
{
! append_vuse (var, stmt, prev_vops);
! if (v_ann->is_alias_tag)
s_ann->makes_aliased_loads = 1;
}
}
--- 1457,1480 ----
if (v_ann->is_alias_tag)
{
/* Alias tagged vars get regular V_MAY_DEF */
! if (s_ann)
! s_ann->makes_aliased_stores = 1;
! append_v_may_def (var);
}
else if ((flags & opf_kill_def)
&& v_ann->mem_tag_kind == NOT_A_TAG)
/* V_MUST_DEF for non-aliased non-GIMPLE register
variable definitions. Avoid memory tags. */
! append_v_must_def (var);
else
/* Call-clobbered variables & memory tags get
V_MAY_DEF */
! append_v_may_def (var);
}
else
{
! append_vuse (var);
! if (s_ann && v_ann->is_alias_tag)
s_ann->makes_aliased_loads = 1;
}
}
*************** add_stmt_operand (tree *var_p, tree stmt
*** 1374,1406 ****
references to the members of the variable's alias set.
This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
if (v_ann->is_alias_tag)
! append_v_may_def (var, stmt, prev_vops);
for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
! append_v_may_def (VARRAY_TREE (aliases, i), stmt, prev_vops);
! s_ann->makes_aliased_stores = 1;
}
else
{
if (v_ann->is_alias_tag)
! append_vuse (var, stmt, prev_vops);
for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
! append_vuse (VARRAY_TREE (aliases, i), stmt, prev_vops);
! s_ann->makes_aliased_loads = 1;
}
}
}
}
/* Record that VAR had its address taken in the statement with annotations
S_ANN. */
static void
note_addressable (tree var, stmt_ann_t s_ann)
{
var = get_base_address (var);
if (var && SSA_VAR_P (var))
{
--- 1496,1534 ----
references to the members of the variable's alias set.
This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
if (v_ann->is_alias_tag)
! append_v_may_def (var);
for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
! append_v_may_def (VARRAY_TREE (aliases, i));
! if (s_ann)
! s_ann->makes_aliased_stores = 1;
}
else
{
if (v_ann->is_alias_tag)
! append_vuse (var);
for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
! append_vuse (VARRAY_TREE (aliases, i));
! if (s_ann)
! s_ann->makes_aliased_loads = 1;
}
}
}
}
+
/* Record that VAR had its address taken in the statement with annotations
S_ANN. */
static void
note_addressable (tree var, stmt_ann_t s_ann)
{
+ if (!s_ann)
+ return;
+
var = get_base_address (var);
if (var && SSA_VAR_P (var))
{
*************** note_addressable (tree var, stmt_ann_t s
*** 1415,1432 ****
clobbered variables in the function. */
static void
! add_call_clobber_ops (tree stmt, voperands_t prev_vops)
{
/* Functions that are not const, pure or never return may clobber
call-clobbered variables. */
! stmt_ann (stmt)->makes_clobbering_call = true;
/* If we had created .GLOBAL_VAR earlier, use it. Otherwise, add
a V_MAY_DEF operand for every call clobbered variable. See
compute_may_aliases for the heuristic used to decide whether
to create .GLOBAL_VAR or not. */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_is_def, prev_vops);
else
{
size_t i;
--- 1543,1561 ----
clobbered variables in the function. */
static void
! add_call_clobber_ops (tree stmt)
{
/* Functions that are not const, pure or never return may clobber
call-clobbered variables. */
! if (stmt_ann (stmt))
! stmt_ann (stmt)->makes_clobbering_call = true;
/* If we had created .GLOBAL_VAR earlier, use it. Otherwise, add
a V_MAY_DEF operand for every call clobbered variable. See
compute_may_aliases for the heuristic used to decide whether
to create .GLOBAL_VAR or not. */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_is_def);
else
{
size_t i;
*************** add_call_clobber_ops (tree stmt, voperan
*** 1438,1446 ****
/* If VAR is read-only, don't add a V_MAY_DEF, just a
VUSE operand. */
if (!TREE_READONLY (var))
! add_stmt_operand (&var, stmt, opf_is_def, prev_vops);
else
! add_stmt_operand (&var, stmt, opf_none, prev_vops);
});
}
}
--- 1567,1575 ----
/* If VAR is read-only, don't add a V_MAY_DEF, just a
VUSE operand. */
if (!TREE_READONLY (var))
! add_stmt_operand (&var, stmt, opf_is_def);
else
! add_stmt_operand (&var, stmt, opf_none);
});
}
}
*************** add_call_clobber_ops (tree stmt, voperan
*** 1450,1463 ****
function. */
static void
! add_call_read_ops (tree stmt, voperands_t prev_vops)
{
/* Otherwise, if the function is not pure, it may reference memory. Add
a VUSE for .GLOBAL_VAR if it has been created. Otherwise, add a VUSE
for each call-clobbered variable. See add_referenced_var for the
heuristic used to decide whether to create .GLOBAL_VAR. */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_none, prev_vops);
else
{
size_t i;
--- 1579,1592 ----
function. */
static void
! add_call_read_ops (tree stmt)
{
/* Otherwise, if the function is not pure, it may reference memory. Add
a VUSE for .GLOBAL_VAR if it has been created. Otherwise, add a VUSE
for each call-clobbered variable. See add_referenced_var for the
heuristic used to decide whether to create .GLOBAL_VAR. */
if (global_var)
! add_stmt_operand (&global_var, stmt, opf_none);
else
{
size_t i;
*************** add_call_read_ops (tree stmt, voperands_
*** 1465,1471 ****
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_none, prev_vops);
});
}
}
--- 1594,1600 ----
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i,
{
tree var = referenced_var (i);
! add_stmt_operand (&var, stmt, opf_none);
});
}
}
*************** add_call_read_ops (tree stmt, voperands_
*** 1475,1487 ****
void
copy_virtual_operands (tree dst, tree src)
{
vuse_optype vuses = STMT_VUSE_OPS (src);
v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (src);
v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (src);
! vuse_optype *vuses_new = &stmt_ann (dst)->vuse_ops;
! v_may_def_optype *v_may_defs_new = &stmt_ann (dst)->v_may_def_ops;
! v_must_def_optype *v_must_defs_new = &stmt_ann (dst)->v_must_def_ops;
! unsigned i;
if (vuses)
{
--- 1604,1616 ----
void
copy_virtual_operands (tree dst, tree src)
{
+ unsigned i;
vuse_optype vuses = STMT_VUSE_OPS (src);
v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (src);
v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (src);
! vuse_optype *vuses_new = &stmt_ann (dst)->operands.vuse_ops;
! v_may_def_optype *v_may_defs_new = &stmt_ann (dst)->operands.v_may_def_ops;
! v_must_def_optype *v_must_defs_new = &stmt_ann (dst)->operands.v_must_def_ops;
if (vuses)
{
*************** copy_virtual_operands (tree dst, tree sr
*** 1509,1512 ****
--- 1638,1685 ----
}
}
+
+ /* Specifically for use in DOM's expression analysis. Given a store, we
+ create an artifical stmt which looks like a load from the store, this can
+ be used to eliminate redundant loads. OLD_OPS are the operands from the
+ store stmt, and NEW_STMT is the new load which reperesent a load of the
+ values stored. */
+
+ void
+ create_ssa_artficial_load_stmt (stmt_operands_p old_ops, tree new_stmt)
+ {
+ stmt_ann_t ann;
+ tree op;
+ stmt_operands_t tmp;
+ unsigned j;
+
+ memset (&tmp, 0, sizeof (stmt_operands_t));
+ ann = get_stmt_ann (new_stmt);
+
+ /* Free operands just in case is was an existing stmt. */
+ free_ssa_operands (&(ann->operands));
+
+ build_ssa_operands (new_stmt, ann, &tmp, &(ann->operands));
+ free_vuses (&(ann->operands.vuse_ops));
+ free_v_may_defs (&(ann->operands.v_may_def_ops));
+ free_v_must_defs (&(ann->operands.v_must_def_ops));
+
+ /* For each VDEF on the original statement, we want to create a
+ VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new
+ statement. */
+ for (j = 0; j < NUM_V_MAY_DEFS (old_ops->v_may_def_ops); j++)
+ {
+ op = V_MAY_DEF_RESULT (old_ops->v_may_def_ops, j);
+ append_vuse (op);
+ }
+
+ for (j = 0; j < NUM_V_MUST_DEFS (old_ops->v_must_def_ops); j++)
+ {
+ op = V_MUST_DEF_OP (old_ops->v_must_def_ops, j);
+ append_vuse (op);
+ }
+
+ finalize_ssa_vuses (&(tmp.vuse_ops));
+ }
+
#include "gt-tree-ssa-operands.h"
Index: tree-ssa-operands.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.h,v
retrieving revision 2.4
diff -c -p -r2.4 tree-ssa-operands.h
*** tree-ssa-operands.h 30 Jun 2004 21:11:28 -0000 2.4
--- tree-ssa-operands.h 4 Aug 2004 15:42:15 -0000
*************** typedef struct use_optype_d GTY(())
*** 55,65 ****
typedef use_optype_t *use_optype;
/* This represents the MAY_DEFS for a stmt. */
typedef struct v_may_def_optype_d GTY(())
{
unsigned num_v_may_defs;
! tree GTY((length ("%h.num_v_may_defs * 2"))) v_may_defs[1];
} v_may_def_optype_t;
typedef v_may_def_optype_t *v_may_def_optype;
--- 55,73 ----
typedef use_optype_t *use_optype;
+ /* Operand type which stores a def and a use tree. */
+ typedef struct v_may_def_operand_type GTY(())
+ {
+ tree def;
+ tree use;
+ } v_may_def_operand_type_t;
+
/* This represents the MAY_DEFS for a stmt. */
typedef struct v_may_def_optype_d GTY(())
{
unsigned num_v_may_defs;
! struct v_may_def_operand_type GTY((length ("%h.num_v_may_defs")))
! v_may_defs[1];
} v_may_def_optype_t;
typedef v_may_def_optype_t *v_may_def_optype;
*************** typedef struct v_must_def_optype_d GTY((
*** 82,87 ****
--- 90,110 ----
typedef v_must_def_optype_t *v_must_def_optype;
+ /* This represents the operand cache fora stmt. */
+ typedef struct stmt_operands_d GTY(())
+ {
+ /* Statement operands. */
+ struct def_optype_d * GTY (()) def_ops;
+ struct use_optype_d * GTY (()) use_ops;
+
+ /* Virtual operands (V_MAY_DEF, VUSE, and V_MUST_DEF). */
+ struct v_may_def_optype_d * GTY (()) v_may_def_ops;
+ struct vuse_optype_d * GTY (()) vuse_ops;
+ struct v_must_def_optype_d * GTY (()) v_must_def_ops;
+ } stmt_operands_t;
+
+ typedef stmt_operands_t *stmt_operands_p;
+
#define USE_FROM_PTR(OP) get_use_from_ptr (OP)
#define DEF_FROM_PTR(OP) get_def_from_ptr (OP)
#define SET_USE(OP, V) ((*((OP).use)) = (V))
*************** typedef v_must_def_optype_t *v_must_def_
*** 157,169 ****
extern void init_ssa_operands (void);
extern void fini_ssa_operands (void);
- extern void verify_start_operands (tree);
- extern void finalize_ssa_stmt_operands (tree);
- void add_vuse (tree, tree);
extern void get_stmt_operands (tree);
- extern void remove_vuses (tree);
- extern void remove_v_may_defs (tree);
- extern void remove_v_must_defs (tree);
extern void copy_virtual_operands (tree, tree);
#endif /* GCC_TREE_SSA_OPERANDS_H */
--- 180,187 ----
extern void init_ssa_operands (void);
extern void fini_ssa_operands (void);
extern void get_stmt_operands (tree);
extern void copy_virtual_operands (tree, tree);
+ extern void create_ssa_artficial_load_stmt (stmt_operands_p, tree);
#endif /* GCC_TREE_SSA_OPERANDS_H */