* New SRA implementation
@ 2004-06-29 18:58 Richard Henderson
2004-06-29 20:03 ` Paolo Carlini
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Richard Henderson @ 2004-06-29 18:58 UTC (permalink / raw)
To: gcc-patches
[-- Attachment #1: Type: text/plain, Size: 2125 bytes --]
The previous SRA implementation had two unfortunate restrictions.
First, it couldn't handle nested aggregates, which severely limited
its usefullness when it comes to real-world code. Including that
within gcc itself, e.g. block_stmt_iterator.
Second, it had a hard-coded limit of five fields per aggregate.
This is a complete rewrite to address both of these issues. Nested
structures are handled. Arrays are handled. Arbitrary numbers of
fields are handled.
Extending to arbitrary numbers of fields means that we have to have
a good deal more smarts in deciding whether or not to instantiate
the fields. I've come up with some preliminary heuristics that seem
to be not unreasonable, at least for the code within gcc and its
testsuites. Surely more work is required here.
I havn't been able to measure a speed difference between the new and
old implementation that wasn't less than 1%, but for the record,
bootstrap with the new implementation was u+s 175 out of 19181 seconds
faster to bootstrap.
r~
* tree-sra.c: Rewrite from scratch. Handle nested aggregates.
* gcc.dg/tree-ssa/20040430-1.c: Expect zero if's.
Index: testsuite/gcc.dg/tree-ssa/20040430-1.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/testsuite/gcc.dg/tree-ssa/20040430-1.c,v
retrieving revision 1.2
diff -u -p -r1.2 20040430-1.c
--- testsuite/gcc.dg/tree-ssa/20040430-1.c 13 May 2004 06:40:52 -0000 1.2
+++ testsuite/gcc.dg/tree-ssa/20040430-1.c 29 Jun 2004 16:17:10 -0000
@@ -1,7 +1,7 @@
/* PR middle-end/14470. Similar to
gcc.c-torture/execute/20040313-1.c, but with a compile time test to
- make sure the second if() is removed. We should actually get rid
- of the first if() too, but we're not that smart yet. */
+ make sure the second if() is removed. */
+/* Update: We now remove both ifs. Whee. */
/* { dg-do run } */
/* { dg-options "-O2 -fdump-tree-optimized" } */
@@ -22,4 +22,4 @@ int main()
return 0;
}
-/* { dg-final { scan-tree-dump-times "if " 1 "optimized"} } */
+/* { dg-final { scan-tree-dump-times "if " 0 "optimized"} } */
[-- Attachment #2: tree-sra.c --]
[-- Type: text/plain, Size: 54630 bytes --]
/* Scalar Replacement of Aggregates (SRA) converts some structure
references into scalar references, exposing them to the scalar
optimizers.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "errors.h"
#include "ggc.h"
#include "tree.h"
/* These RTL headers are needed for basic-block.h. */
#include "rtl.h"
#include "tm_p.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "diagnostic.h"
#include "langhooks.h"
#include "tree-inline.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-dump.h"
#include "tree-pass.h"
#include "timevar.h"
#include "flags.h"
#include "bitmap.h"
#include "obstack.h"
#include "target.h"
/* This object of this pass is to replace a non-addressable aggregate with a
set of independent variables. Most of the time, all of these variables
will be scalars. But a secondary objective is to break up larger
aggregates into smaller aggregates. In the process we may find that some
bits of the larger aggregate can be deleted as unreferenced.
This substitution is done globally. More localized substitutions would
be the purvey of a load-store motion pass.
The optimization proceeds in phases:
(1) Identify variables that have types that are candidates for
decomposition.
(2) Scan the function looking for the ways these variables are used.
In particular we're interested in the number of times a variable
(or member) is needed as a complete unit, and the number of times
a variable (or member) is copied.
(3) Based on the usage profile, instantiate substitution variables.
(4) Scan the function making replacements.
*/
/* The set of aggregate variables that are candidates for scalarization. */
static bitmap sra_candidates;
/* Set of scalarizable PARM_DECLs that need copy-in operations at the
beginning of the function. */
static bitmap needs_copy_in;
/* Sets of bit pairs that cache type decomposition and instantiation. */
static bitmap sra_type_decomp_cache;
static bitmap sra_type_inst_cache;
/* One of these structures is created for each candidate aggregate
and each (accessed) member of such an aggregate. */
struct sra_elt
{
/* A tree of the elements. Used when we want to traverse everything. */
struct sra_elt *parent;
struct sra_elt *children;
struct sra_elt *sibling;
/* If this element is a root, then this is the VAR_DECL. If this is
a sub-element, this is some token used to identify the reference.
In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
of an ARRAY_REF, this is the (constant) index. In the case of a
complex number, this is a zero or one. */
tree element;
/* The type of the element. */
tree type;
/* A VAR_DECL, for any sub-element we've decided to replace. */
tree replacement;
/* The number of times the element is referenced as a whole. I.e.
given "a.b.c", this would be incremented for C, but not for A or B. */
unsigned int n_uses;
/* The number of times the element is copied to or from another
scalarizable element. */
unsigned int n_copies;
/* True if TYPE is scalar. */
bool is_scalar;
/* True if we saw something about this element that prevents scalarization,
such as non-constant indexing. */
bool cannot_scalarize;
/* True if we've decided that structure-to-structure assignment
should happen via memcpy and not per-element. */
bool use_block_copy;
/* A flag for use with/after random access traversals. */
bool visited;
};
/* Random access to the child of a parent is performed by hashing.
This prevents quadratic behaviour, and allows SRA to function
reasonably on larger records. */
static htab_t sra_map;
/* All structures are allocated out of the following obstack. */
static struct obstack sra_obstack;
/* Debugging functions. */
static void dump_sra_elt_name (FILE *, struct sra_elt *);
extern void debug_sra_elt_name (struct sra_elt *);
\f
/* Return true if DECL is an SRA candidate. */
static bool
is_sra_candidate_decl (tree decl)
{
return DECL_P (decl) && bitmap_bit_p (sra_candidates, var_ann (decl)->uid);
}
/* Return true if TYPE is a scalar type. */
static bool
is_sra_scalar_type (tree type)
{
enum tree_code code = TREE_CODE (type);
return (code == INTEGER_TYPE || code == REAL_TYPE || code == VECTOR_TYPE
|| code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
|| code == CHAR_TYPE || code == POINTER_TYPE || code == OFFSET_TYPE
|| code == REFERENCE_TYPE);
}
/* Return true if TYPE can be decomposed into a set of independent variables.
Note that this doesn't imply that all elements of TYPE can be
instantiated, just that if we decide to break up the type into
separate pieces that it can be done. */
static bool
type_can_be_decomposed_p (tree type)
{
unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
tree t;
/* Avoid searching the same type twice. */
if (bitmap_bit_p (sra_type_decomp_cache, cache+0))
return true;
if (bitmap_bit_p (sra_type_decomp_cache, cache+1))
return false;
/* The type must have a definite non-zero size. */
if (TYPE_SIZE (type) == NULL || integer_zerop (TYPE_SIZE (type)))
goto fail;
/* The type must be a non-union aggregate. */
switch (TREE_CODE (type))
{
case RECORD_TYPE:
{
bool saw_one_field = false;
for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
if (TREE_CODE (t) == FIELD_DECL)
{
/* Reject incorrectly represented bit fields. */
if (DECL_BIT_FIELD (t)
&& (tree_low_cst (DECL_SIZE (t), 1)
!= TYPE_PRECISION (TREE_TYPE (t))))
goto fail;
saw_one_field = true;
}
/* Record types must have at least one field. */
if (!saw_one_field)
goto fail;
}
break;
case ARRAY_TYPE:
/* Array types must have a fixed lower and upper bound. */
t = TYPE_DOMAIN (type);
if (t == NULL)
goto fail;
if (TYPE_MIN_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MIN_VALUE (t)))
goto fail;
if (TYPE_MAX_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MAX_VALUE (t)))
goto fail;
break;
case COMPLEX_TYPE:
break;
default:
goto fail;
}
bitmap_set_bit (sra_type_decomp_cache, cache+0);
return true;
fail:
bitmap_set_bit (sra_type_decomp_cache, cache+1);
return false;
}
/* Return true if DECL can be decomposed into a set of independent
(though not necessarily scalar) variables. */
static bool
decl_can_be_decomposed_p (tree var)
{
/* Early out for scalars. */
if (is_sra_scalar_type (TREE_TYPE (var)))
return false;
/* The variable must not be aliased. */
if (!is_gimple_non_addressable (var))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Cannot scalarize variable ");
print_generic_expr (dump_file, var, dump_flags);
fprintf (dump_file, " because it must live in memory\n");
}
return false;
}
/* The variable must not be volatile. */
if (TREE_THIS_VOLATILE (var))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Cannot scalarize variable ");
print_generic_expr (dump_file, var, dump_flags);
fprintf (dump_file, " because it is declared volatile\n");
}
return false;
}
/* We must be able to decompose the variable's type. */
if (!type_can_be_decomposed_p (TREE_TYPE (var)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Cannot scalarize variable ");
print_generic_expr (dump_file, var, dump_flags);
fprintf (dump_file, " because its type cannot be decomposed\n");
}
return false;
}
return true;
}
/* Return true if TYPE can be *completely* decomposed into scalars. */
static bool
type_can_instantiate_all_elements (tree type)
{
if (is_sra_scalar_type (type))
return true;
if (!type_can_be_decomposed_p (type))
return false;
switch (TREE_CODE (type))
{
case RECORD_TYPE:
{
unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
tree f;
if (bitmap_bit_p (sra_type_inst_cache, cache+0))
return true;
if (bitmap_bit_p (sra_type_inst_cache, cache+1))
return false;
for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
if (TREE_CODE (f) == FIELD_DECL)
{
if (!type_can_instantiate_all_elements (TREE_TYPE (f)))
{
bitmap_set_bit (sra_type_inst_cache, cache+1);
return false;
}
}
bitmap_set_bit (sra_type_inst_cache, cache+0);
return true;
}
case ARRAY_TYPE:
return type_can_instantiate_all_elements (TREE_TYPE (type));
case COMPLEX_TYPE:
return true;
default:
abort ();
}
}
/* Test whether ELT or some sub-element cannot be scalarized. */
static bool
can_completely_scalarize_p (struct sra_elt *elt)
{
struct sra_elt *c;
if (elt->cannot_scalarize)
return false;
for (c = elt->children; c ; c = c->sibling)
if (!can_completely_scalarize_p (c))
return false;
return true;
}
\f
/* A simplified tree hashing algorithm that only handles the types of
trees we expect to find in sra_elt->element. */
static hashval_t
sra_hash_tree (tree t)
{
switch (TREE_CODE (t))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
case FIELD_DECL:
return DECL_UID (t);
case INTEGER_CST:
return TREE_INT_CST_LOW (t) ^ TREE_INT_CST_HIGH (t);
default:
abort ();
}
}
/* Hash function for type SRA_PAIR. */
static hashval_t
sra_elt_hash (const void *x)
{
const struct sra_elt *e = x;
const struct sra_elt *p;
hashval_t h;
h = sra_hash_tree (e->element);
/* Take into account everything back up the chain. Given that chain
lengths are rarely very long, this should be acceptable. If we
truely identify this as a performance problem, it should work to
hash the pointer value "e->parent". */
for (p = e->parent; p ; p = p->parent)
h = (h * 65521) ^ sra_hash_tree (p->element);
return h;
}
/* Equality function for type SRA_PAIR. */
static int
sra_elt_eq (const void *x, const void *y)
{
const struct sra_elt *a = x;
const struct sra_elt *b = y;
if (a->parent != b->parent)
return false;
/* All the field/decl stuff is unique. */
if (a->element == b->element)
return true;
/* The only thing left is integer equality. */
if (TREE_CODE (a->element) == INTEGER_CST
&& TREE_CODE (b->element) == INTEGER_CST)
return tree_int_cst_equal (a->element, b->element);
else
return false;
}
/* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
may be null, in which case CHILD must be a DECL. */
static struct sra_elt *
lookup_element (struct sra_elt *parent, tree child, tree type,
enum insert_option insert)
{
struct sra_elt dummy;
struct sra_elt **slot;
struct sra_elt *elt;
dummy.parent = parent;
dummy.element = child;
slot = (struct sra_elt **) htab_find_slot (sra_map, &dummy, insert);
if (!slot && insert == NO_INSERT)
return NULL;
elt = *slot;
if (!elt && insert == INSERT)
{
*slot = elt = obstack_alloc (&sra_obstack, sizeof (*elt));
memset (elt, 0, sizeof (*elt));
elt->parent = parent;
elt->element = child;
elt->type = type;
elt->is_scalar = is_sra_scalar_type (type);
if (parent)
{
elt->sibling = parent->children;
parent->children = elt;
}
/* If this is a parameter, then if we want to scalarize, we have
one copy from the true function parameter. Count it now. */
if (TREE_CODE (child) == PARM_DECL)
{
elt->n_copies = 1;
bitmap_set_bit (needs_copy_in, var_ann (child)->uid);
}
}
return elt;
}
/* Return true if the ARRAY_REF in EXPR is a constant, in bounds access. */
static bool
is_valid_const_index (tree expr)
{
tree dom, t, index = TREE_OPERAND (expr, 1);
if (TREE_CODE (index) != INTEGER_CST)
return false;
/* Watch out for stupid user tricks, indexing outside the array.
Careful, we're not called only on scalarizable types, so do not
assume constant array bounds. We needn't do anything with such
cases, since they'll be referring to objects that we should have
already rejected for scalarization, so returning false is fine. */
dom = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (expr, 0)));
if (dom == NULL)
return false;
t = TYPE_MIN_VALUE (dom);
if (!t || TREE_CODE (t) != INTEGER_CST)
return false;
if (tree_int_cst_lt (index, t))
return false;
t = TYPE_MAX_VALUE (dom);
if (!t || TREE_CODE (t) != INTEGER_CST)
return false;
if (tree_int_cst_lt (t, index))
return false;
return true;
}
/* Create or return the SRA_ELT structure for EXPR if the expression
refers to a scalarizable variable. */
static struct sra_elt *
maybe_lookup_element_for_expr (tree expr)
{
struct sra_elt *elt;
tree child;
switch (TREE_CODE (expr))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
if (is_sra_candidate_decl (expr))
return lookup_element (NULL, expr, TREE_TYPE (expr), INSERT);
return NULL;
case ARRAY_REF:
/* We can't scalarize variable array indicies. */
if (is_valid_const_index (expr))
child = TREE_OPERAND (expr, 1);
else
return NULL;
break;
case COMPONENT_REF:
/* Don't look through unions. */
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) != RECORD_TYPE)
return NULL;
child = TREE_OPERAND (expr, 1);
break;
case REALPART_EXPR:
child = integer_zero_node;
break;
case IMAGPART_EXPR:
child = integer_one_node;
break;
default:
return NULL;
}
elt = maybe_lookup_element_for_expr (TREE_OPERAND (expr, 0));
if (elt)
return lookup_element (elt, child, TREE_TYPE (expr), INSERT);
return NULL;
}
\f
/* Functions to walk just enough of the tree to see all scalarizable
references, and categorize them. */
/* A set of callbacks for phases 2 and 4. They'll be invoked for the
various kinds of references seen. In all cases, *BSI is an iterator
pointing to the statement being processed. */
struct sra_walk_fns
{
/* Invoked when ELT is required as a unit. Note that ELT might refer to
a leaf node, in which case this is a simple scalar reference. *EXPR_P
points to the location of the expression. IS_OUTPUT is true if this
is a left-hand-side reference. */
void (*use) (struct sra_elt *elt, tree *expr_p,
block_stmt_iterator *bsi, bool is_output);
/* Invoked when we have a copy between two scalarizable references. */
void (*copy) (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
block_stmt_iterator *bsi);
/* Invoked when ELT is initialized from a constant. VALUE may be NULL,
in which case it should be treated as an empty CONSTRUCTOR. */
void (*init) (struct sra_elt *elt, tree value, block_stmt_iterator *bsi);
/* Invoked when we have a copy between one scalarizable reference ELT
and one non-scalarizable reference OTHER. IS_OUTPUT is true if ELT
is on the left-hand side. */
void (*ldst) (struct sra_elt *elt, tree other,
block_stmt_iterator *bsi, bool is_output);
/* True during phase 2, false during phase 4. */
/* ??? This is a hack. */
bool initial_scan;
};
#ifdef ENABLE_CHECKING
/* Invoked via walk_tree, if *TP contains an candidate decl, return it. */
static tree
sra_find_candidate_decl (tree *tp, int *walk_subtrees,
void *data ATTRIBUTE_UNUSED)
{
tree t = *tp;
enum tree_code code = TREE_CODE (t);
if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
{
*walk_subtrees = 0;
if (is_sra_candidate_decl (t))
return t;
}
else if (TYPE_P (t))
*walk_subtrees = 0;
return NULL;
}
#endif
/* Walk most expressions looking for a scalarizable aggregate.
If we find one, invoke FNS->USE. */
static void
sra_walk_expr (tree *expr_p, block_stmt_iterator *bsi, bool is_output,
const struct sra_walk_fns *fns)
{
tree expr = *expr_p;
tree inner = expr;
/* We're looking to collect a reference expression between EXPR and INNER,
such that INNER is a scalarizable decl and all other nodes through EXPR
are references that we can scalarize. If we come across something that
we can't scalarize, we reset EXPR. This has the effect of making it
appear that we're referring to the larger expression as a whole. */
while (1)
switch (TREE_CODE (inner))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
/* If there is a scalarizable decl at the bottom, then process it. */
if (is_sra_candidate_decl (inner))
{
struct sra_elt *elt = maybe_lookup_element_for_expr (expr);
fns->use (elt, expr_p, bsi, is_output);
}
return;
case ARRAY_REF:
/* Non-constant index means any member may be accessed. Prevent the
expression from being scalarized. If we were to treat this as a
reference to the whole array, we can wind up with a single dynamic
index reference inside a loop being overridden by several constant
index references during loop setup. It's possible that this could
be avoided by using dynamic usage counts based on BB trip counts
(based on loop analysis or profiling), but that hardly seems worth
the effort. */
/* ??? Hack. Figure out how to push this into the scan routines
without duplicating too much code. */
if (!is_valid_const_index (inner))
{
if (fns->initial_scan)
{
struct sra_elt *elt
= maybe_lookup_element_for_expr (TREE_OPERAND (inner, 0));
if (elt)
elt->cannot_scalarize = true;
}
return;
}
/* ??? Are we assured that non-constant bounds and stride will have
the same value everywhere? I don't think Fortran will... */
if (TREE_OPERAND (inner, 2) || TREE_OPERAND (inner, 3))
goto use_all;
inner = TREE_OPERAND (inner, 0);
break;
case COMPONENT_REF:
/* A reference to a union member constitutes a reference to the
entire union. */
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner, 0))) != RECORD_TYPE)
goto use_all;
/* ??? See above re non-constant stride. */
if (TREE_OPERAND (inner, 2))
goto use_all;
inner = TREE_OPERAND (inner, 0);
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
inner = TREE_OPERAND (inner, 0);
break;
case BIT_FIELD_REF:
/* A bit field reference (access to *multiple* fields simultaneously)
is not currently scalarized. Consider this an access to the
complete outer element, to which walk_tree will bring us next. */
goto use_all;
case ARRAY_RANGE_REF:
/* Similarly, an subrange reference is used to modify indexing. Which
means that the canonical element names that we have won't work. */
goto use_all;
case VIEW_CONVERT_EXPR:
case NOP_EXPR:
/* Similarly, a view/nop explicitly wants to look at an object in a
type other than the one we've scalarized. */
goto use_all;
use_all:
expr_p = &TREE_OPERAND (inner, 0);
inner = expr = *expr_p;
break;
default:
#ifdef ENABLE_CHECKING
/* Validate that we're not missing any references. */
if (walk_tree (&inner, sra_find_candidate_decl, NULL, NULL))
abort ();
#endif
return;
}
}
/* Walk a TREE_LIST of values looking for scalarizable aggregates.
If we find one, invoke FNS->USE. */
static void
sra_walk_tree_list (tree list, block_stmt_iterator *bsi, bool is_output,
const struct sra_walk_fns *fns)
{
tree op;
for (op = list; op ; op = TREE_CHAIN (op))
sra_walk_expr (&TREE_VALUE (op), bsi, is_output, fns);
}
/* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
If we find one, invoke FNS->USE. */
static void
sra_walk_call_expr (tree expr, block_stmt_iterator *bsi,
const struct sra_walk_fns *fns)
{
sra_walk_tree_list (TREE_OPERAND (expr, 1), bsi, false, fns);
}
/* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
aggregates. If we find one, invoke FNS->USE. */
static void
sra_walk_asm_expr (tree expr, block_stmt_iterator *bsi,
const struct sra_walk_fns *fns)
{
sra_walk_tree_list (ASM_INPUTS (expr), bsi, false, fns);
sra_walk_tree_list (ASM_OUTPUTS (expr), bsi, true, fns);
}
/* Walk a MODIFY_EXPR and categorize the assignment appropriately. */
static void
sra_walk_modify_expr (tree expr, block_stmt_iterator *bsi,
const struct sra_walk_fns *fns)
{
struct sra_elt *lhs_elt, *rhs_elt;
tree lhs, rhs;
lhs = TREE_OPERAND (expr, 0);
rhs = TREE_OPERAND (expr, 1);
lhs_elt = maybe_lookup_element_for_expr (lhs);
rhs_elt = maybe_lookup_element_for_expr (rhs);
/* If both sides are scalarizable, this is a COPY operation. */
if (lhs_elt && rhs_elt)
{
fns->copy (lhs_elt, rhs_elt, bsi);
return;
}
if (lhs_elt)
{
/* If this is an assignment from a constant, or constructor, then
we have access to all of the elements individually. Invoke INIT. */
if (TREE_CODE (rhs) == COMPLEX_EXPR
|| TREE_CODE (rhs) == COMPLEX_CST
|| TREE_CODE (rhs) == CONSTRUCTOR)
fns->init (lhs_elt, rhs, bsi);
/* If this is an assignment from read-only memory, treat this as if
we'd been passed the constructor directly. Invoke INIT. */
else if (TREE_CODE (rhs) == VAR_DECL
&& TREE_STATIC (rhs)
&& TREE_READONLY (rhs)
&& targetm.binds_local_p (rhs))
{
if (DECL_INITIAL (rhs) != error_mark_node)
fns->init (lhs_elt, DECL_INITIAL (rhs), bsi);
}
/* If this is a copy from a non-scalarizable lvalue, invoke LDST.
The lvalue requirement prevents us from trying to directly scalarize
the result of a function call. Which would result in trying to call
the function multiple times, and other evil things. */
else if (!lhs_elt->is_scalar && is_gimple_addr_expr_arg (rhs))
fns->ldst (lhs_elt, rhs, bsi, true);
/* Otherwise we're being used in some context that requires the
aggregate to be seen as a whole. Invoke USE. */
else
fns->use (lhs_elt, &TREE_OPERAND (expr, 0), bsi, true);
}
else
{
/* LHS_ELT being null only means that the LHS as a whole is not a
scalarizable reference. There may be occurrences of scalarizable
variables within, which implies a USE. */
sra_walk_expr (&TREE_OPERAND (expr, 0), bsi, true, fns);
}
/* Likewise for the right-hand side. The only difference here is that
we don't have to handle constants, and the RHS may be a call. */
if (rhs_elt)
{
if (!rhs_elt->is_scalar)
fns->ldst (rhs_elt, lhs, bsi, false);
else
fns->use (rhs_elt, &TREE_OPERAND (expr, 1), bsi, false);
}
else if (TREE_CODE (rhs) == CALL_EXPR)
sra_walk_call_expr (rhs, bsi, fns);
else
sra_walk_expr (&TREE_OPERAND (expr, 1), bsi, false, fns);
}
/* Entry point to the walk functions. Search the entire function,
invoking the callbacks in FNS on each of the references to
scalarizable variables. */
static void
sra_walk_function (const struct sra_walk_fns *fns)
{
basic_block bb;
block_stmt_iterator si;
/* ??? Phase 4 could derive some benefit to walking the function in
dominator tree order. */
FOR_EACH_BB (bb)
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{
tree stmt, t;
stmt_ann_t ann;
stmt = bsi_stmt (si);
ann = stmt_ann (stmt);
/* If the statement has no virtual operands, then it doesn't
make any structure references that we care about. */
if (NUM_V_MAY_DEFS (V_MAY_DEF_OPS (ann)) == 0
&& NUM_VUSES (VUSE_OPS (ann)) == 0
&& NUM_V_MUST_DEFS (V_MUST_DEF_OPS (ann)) == 0)
continue;
switch (TREE_CODE (stmt))
{
case RETURN_EXPR:
/* If we have "return <retval>" then the return value is
already exposed for our pleasure. Walk it as a USE to
force all the components back in place for the return.
If we have an embedded assignment, then <retval> is of
a type that gets returned in registers in this ABI, and
we do not wish to extend their lifetimes. Treat this
as a USE of the variable on the RHS of this assignment. */
t = TREE_OPERAND (stmt, 0);
if (TREE_CODE (t) == MODIFY_EXPR)
sra_walk_expr (&TREE_OPERAND (t, 1), &si, false, fns);
else
sra_walk_expr (&TREE_OPERAND (stmt, 0), &si, false, fns);
break;
case MODIFY_EXPR:
sra_walk_modify_expr (stmt, &si, fns);
break;
case CALL_EXPR:
sra_walk_call_expr (stmt, &si, fns);
break;
case ASM_EXPR:
sra_walk_asm_expr (stmt, &si, fns);
break;
default:
break;
}
}
}
\f
/* Phase One: Scan all referenced variables in the program looking for
structures that could be decomposed. */
static bool
find_candidates_for_sra (void)
{
size_t i;
bool any_set = false;
for (i = 0; i < num_referenced_vars; i++)
{
tree var = referenced_var (i);
if (decl_can_be_decomposed_p (var))
{
bitmap_set_bit (sra_candidates, var_ann (var)->uid);
any_set = true;
}
}
return any_set;
}
\f
/* Phase Two: Scan all references to scalarizable variables. Count the
number of times they are used or copied respectively. */
/* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
considered a copy, because we can decompose the reference such that
the sub-elements needn't be contiguous. */
static void
scan_use (struct sra_elt *elt, tree *expr_p ATTRIBUTE_UNUSED,
block_stmt_iterator *bsi ATTRIBUTE_UNUSED,
bool is_output ATTRIBUTE_UNUSED)
{
elt->n_uses += 1;
}
static void
scan_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
block_stmt_iterator *bsi ATTRIBUTE_UNUSED)
{
lhs_elt->n_copies += 1;
rhs_elt->n_copies += 1;
}
static void
scan_init (struct sra_elt *lhs_elt, tree rhs ATTRIBUTE_UNUSED,
block_stmt_iterator *bsi ATTRIBUTE_UNUSED)
{
lhs_elt->n_copies += 1;
}
static void
scan_ldst (struct sra_elt *elt, tree other ATTRIBUTE_UNUSED,
block_stmt_iterator *bsi ATTRIBUTE_UNUSED,
bool is_output ATTRIBUTE_UNUSED)
{
elt->n_copies += 1;
}
/* Dump the values we collected during the scanning phase. */
static void
scan_dump (struct sra_elt *elt)
{
struct sra_elt *c;
dump_sra_elt_name (dump_file, elt);
fprintf (dump_file, ": n_uses=%u n_copies=%u\n", elt->n_uses, elt->n_copies);
for (c = elt->children; c ; c = c->sibling)
scan_dump (c);
}
/* Entry point to phase 2. Scan the entire function, building up
scalarization data structures, recording copies and uses. */
static void
scan_function (void)
{
static const struct sra_walk_fns fns = {
scan_use, scan_copy, scan_init, scan_ldst, true
};
sra_walk_function (&fns);
if (dump_file && (dump_flags & TDF_DETAILS))
{
size_t i;
fputs ("\nScan results:\n", dump_file);
EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i,
{
tree var = referenced_var (i);
struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
if (elt)
scan_dump (elt);
});
fputc ('\n', dump_file);
}
}
\f
/* Phase Three: Make decisions about which variables to scalarize, if any.
All elements to be scalarized have replacement variables made for them. */
/* A subroutine of build_element_name. Recursively build the element
name on the obstack. */
static void
build_element_name_1 (struct sra_elt *elt)
{
tree t;
char buffer[32];
if (elt->parent)
{
build_element_name_1 (elt->parent);
obstack_1grow (&sra_obstack, '$');
if (TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
{
if (elt->element == integer_zero_node)
obstack_grow (&sra_obstack, "real", 4);
else
obstack_grow (&sra_obstack, "imag", 4);
return;
}
}
t = elt->element;
if (TREE_CODE (t) == INTEGER_CST)
{
/* ??? Eh. Don't bother doing double-wide printing. */
sprintf (buffer, HOST_WIDE_INT_PRINT_DEC, TREE_INT_CST_LOW (t));
obstack_grow (&sra_obstack, buffer, strlen (buffer));
}
else
{
tree name = DECL_NAME (t);
if (name)
obstack_grow (&sra_obstack, IDENTIFIER_POINTER (name),
IDENTIFIER_LENGTH (name));
else
{
sprintf (buffer, "D%u", DECL_UID (t));
obstack_grow (&sra_obstack, buffer, strlen (buffer));
}
}
}
/* Construct a pretty variable name for an element's replacement variable.
The name is built on the obstack. */
static char *
build_element_name (struct sra_elt *elt)
{
build_element_name_1 (elt);
obstack_1grow (&sra_obstack, '\0');
return obstack_finish (&sra_obstack);
}
/* Instantiate an element as an independent variable. */
static void
instantiate_element (struct sra_elt *elt)
{
struct sra_elt *base_elt;
tree var, base;
for (base_elt = elt; base_elt->parent; base_elt = base_elt->parent)
continue;
base = base_elt->element;
elt->replacement = var = make_rename_temp (elt->type, "SR");
DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (base);
TREE_NO_WARNING (var) = TREE_NO_WARNING (base);
DECL_ARTIFICIAL (var) = DECL_ARTIFICIAL (base);
if (DECL_NAME (base) && !DECL_IGNORED_P (base))
{
char *pretty_name = build_element_name (elt);
DECL_NAME (var) = get_identifier (pretty_name);
obstack_free (&sra_obstack, pretty_name);
}
if (dump_file)
{
fputs (" ", dump_file);
dump_sra_elt_name (dump_file, elt);
fputs (" -> ", dump_file);
print_generic_expr (dump_file, var, dump_flags);
fputc ('\n', dump_file);
}
}
/* Make one pass across an element tree deciding whether or not it's
profitable to instantiate individual leaf scalars.
PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
fields all the way up the tree. */
static void
decide_instantiation_1 (struct sra_elt *elt, unsigned int parent_uses,
unsigned int parent_copies)
{
if (dump_file && !elt->parent)
{
fputs ("Initial instantiation for ", dump_file);
dump_sra_elt_name (dump_file, elt);
fputc ('\n', dump_file);
}
if (elt->cannot_scalarize)
return;
if (elt->is_scalar)
{
/* The decision is simple: instantiate if we're used more frequently
than the parent needs to be seen as a complete unit. */
if (elt->n_uses + elt->n_copies + parent_copies > parent_uses)
instantiate_element (elt);
}
else
{
struct sra_elt *c;
unsigned int this_uses = elt->n_uses + parent_uses;
unsigned int this_copies = elt->n_copies + parent_copies;
for (c = elt->children; c ; c = c->sibling)
decide_instantiation_1 (c, this_uses, this_copies);
}
}
/* Compute the size and number of all instantiated elements below ELT.
We will only care about this if the size of the complete structure
fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
static unsigned int
sum_instantiated_sizes (struct sra_elt *elt, unsigned HOST_WIDE_INT *sizep)
{
if (elt->replacement)
{
*sizep += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt->type));
return 1;
}
else
{
struct sra_elt *c;
unsigned int count = 0;
for (c = elt->children; c ; c = c->sibling)
count += sum_instantiated_sizes (c, sizep);
return count;
}
}
/* Instantiate fields in ELT->TYPE that are not currently present as
children of ELT. */
static void instantiate_missing_elements (struct sra_elt *elt);
static void
instantiate_missing_elements_1 (struct sra_elt *elt, tree child, tree type)
{
struct sra_elt *sub = lookup_element (elt, child, type, INSERT);
if (sub->is_scalar)
{
if (sub->replacement == NULL)
instantiate_element (sub);
}
else
instantiate_missing_elements (sub);
}
static void
instantiate_missing_elements (struct sra_elt *elt)
{
tree type = elt->type;
switch (TREE_CODE (type))
{
case RECORD_TYPE:
{
tree f;
for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
if (TREE_CODE (f) == FIELD_DECL)
instantiate_missing_elements_1 (elt, f, TREE_TYPE (f));
break;
}
case ARRAY_TYPE:
{
tree i, max, subtype;
i = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
max = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
subtype = TREE_TYPE (type);
while (1)
{
instantiate_missing_elements_1 (elt, i, subtype);
if (tree_int_cst_equal (i, max))
break;
i = int_const_binop (PLUS_EXPR, i, integer_one_node, true);
}
break;
}
case COMPLEX_TYPE:
type = TREE_TYPE (type);
instantiate_missing_elements_1 (elt, integer_zero_node, type);
instantiate_missing_elements_1 (elt, integer_one_node, type);
break;
default:
abort ();
}
}
/* Make one pass across an element tree deciding whether to perform block
or element copies. If we decide on element copies, instantiate all
elements. Return true if there are any instantiated sub-elements. */
static bool
decide_block_copy (struct sra_elt *elt)
{
struct sra_elt *c;
bool any_inst;
/* If scalarization is disabled, respect it. */
if (elt->cannot_scalarize)
{
elt->use_block_copy = 1;
if (dump_file)
{
fputs ("Scalarization disabled for ", dump_file);
dump_sra_elt_name (dump_file, elt);
fputc ('\n', dump_file);
}
return false;
}
/* Don't decide if we've no uses. */
if (elt->n_uses == 0 && elt->n_copies == 0)
;
else if (!elt->is_scalar)
{
tree size_tree = TYPE_SIZE_UNIT (elt->type);
bool use_block_copy = true;
/* Don't bother trying to figure out the rest if the structure is
so large we can't do easy arithmetic. This also forces block
copies for variable sized structures. */
if (host_integerp (size_tree, 1))
{
unsigned HOST_WIDE_INT full_size, inst_size = 0;
unsigned int inst_count;
full_size = tree_low_cst (size_tree, 1);
/* ??? What to do here. If there are two fields, and we've only
instantiated one, then instantiating the other is clearly a win.
If there are a large number of fields then the size of the copy
is much more of a factor. */
/* If the structure is small, and we've made copies, go ahead
and instantiate, hoping that the copies will go away. */
if (full_size <= (unsigned) MOVE_RATIO * UNITS_PER_WORD
&& elt->n_copies > elt->n_uses)
use_block_copy = false;
else
{
inst_count = sum_instantiated_sizes (elt, &inst_size);
if (inst_size * 4 >= full_size * 3)
use_block_copy = false;
}
/* In order to avoid block copy, we have to be able to instantiate
all elements of the type. See if this is possible. */
if (!use_block_copy
&& (!can_completely_scalarize_p (elt)
|| !type_can_instantiate_all_elements (elt->type)))
use_block_copy = true;
}
elt->use_block_copy = use_block_copy;
if (dump_file)
{
fprintf (dump_file, "Using %s for ",
use_block_copy ? "block-copy" : "element-copy");
dump_sra_elt_name (dump_file, elt);
fputc ('\n', dump_file);
}
if (!use_block_copy)
{
instantiate_missing_elements (elt);
return true;
}
}
any_inst = elt->replacement != NULL;
for (c = elt->children; c ; c = c->sibling)
any_inst |= decide_block_copy (c);
return any_inst;
}
/* Entry point to phase 3. Instantiate scalar replacement variables. */
static void
decide_instantiations (void)
{
unsigned int i;
bool cleared_any;
struct bitmap_head_def done_head;
/* We cannot clear bits from a bitmap we're iterating over,
so save up all the bits to clear until the end. */
bitmap_initialize (&done_head, 1);
cleared_any = false;
EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i,
{
tree var = referenced_var (i);
struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
if (elt)
{
decide_instantiation_1 (elt, 0, 0);
if (!decide_block_copy (elt))
elt = NULL;
}
if (!elt)
{
bitmap_set_bit (&done_head, i);
cleared_any = true;
}
});
if (cleared_any)
{
bitmap_operation (sra_candidates, sra_candidates, &done_head,
BITMAP_AND_COMPL);
bitmap_operation (needs_copy_in, needs_copy_in, &done_head,
BITMAP_AND_COMPL);
}
bitmap_clear (&done_head);
if (dump_file)
fputc ('\n', dump_file);
}
\f
/* Phase Four: Update the function to match the replacements created. */
/* Mark all the variables in V_MAY_DEF or V_MUST_DEF operands for STMT for
renaming. This becomes necessary when we modify all of a non-scalar. */
static void
mark_all_v_defs (tree stmt)
{
v_may_def_optype v_may_defs;
v_must_def_optype v_must_defs;
size_t i, n;
get_stmt_operands (stmt);
v_may_defs = V_MAY_DEF_OPS (stmt_ann (stmt));
n = NUM_V_MAY_DEFS (v_may_defs);
for (i = 0; i < n; i++)
{
tree sym = V_MAY_DEF_RESULT (v_may_defs, i);
if (TREE_CODE (sym) == SSA_NAME)
sym = SSA_NAME_VAR (sym);
bitmap_set_bit (vars_to_rename, var_ann (sym)->uid);
}
v_must_defs = V_MUST_DEF_OPS (stmt_ann (stmt));
n = NUM_V_MUST_DEFS (v_must_defs);
for (i = 0; i < n; i++)
{
tree sym = V_MUST_DEF_OP (v_must_defs, i);
if (TREE_CODE (sym) == SSA_NAME)
sym = SSA_NAME_VAR (sym);
bitmap_set_bit (vars_to_rename, var_ann (sym)->uid);
}
}
/* Build a single level component reference to ELT rooted at BASE. */
static tree
generate_one_element_ref (struct sra_elt *elt, tree base)
{
switch (TREE_CODE (TREE_TYPE (base)))
{
case RECORD_TYPE:
return build (COMPONENT_REF, elt->type, base, elt->element, NULL);
case ARRAY_TYPE:
return build (ARRAY_REF, elt->type, base, elt->element, NULL, NULL);
case COMPLEX_TYPE:
if (elt->element == integer_zero_node)
return build (REALPART_EXPR, elt->type, base);
else
return build (IMAGPART_EXPR, elt->type, base);
default:
abort ();
}
}
/* Build a full component reference to ELT rooted at its native variable. */
static tree
generate_element_ref (struct sra_elt *elt)
{
if (elt->parent)
return generate_one_element_ref (elt, generate_element_ref (elt->parent));
else
return elt->element;
}
/* Generate a set of assignment statements in *LIST_P to copy all
instantiated elements under ELT to or from the equivalent structure
rooted at EXPR. COPY_OUT controls the direction of the copy, with
true meaning to copy out of EXPR into ELT. */
static void
generate_copy_inout (struct sra_elt *elt, bool copy_out, tree expr,
tree *list_p)
{
struct sra_elt *c;
tree t;
if (elt->replacement)
{
if (copy_out)
t = build (MODIFY_EXPR, void_type_node, elt->replacement, expr);
else
t = build (MODIFY_EXPR, void_type_node, expr, elt->replacement);
append_to_statement_list (t, list_p);
}
else
{
for (c = elt->children; c ; c = c->sibling)
{
t = generate_one_element_ref (c, unshare_expr (expr));
generate_copy_inout (c, copy_out, t, list_p);
}
}
}
/* Generate a set of assignment statements in *LIST_P to copy all instantiated
elements under SRC to their counterparts under DST. There must be a 1-1
correspondence of instantiated elements. */
static void
generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
{
struct sra_elt *dc, *sc;
for (dc = dst->children; dc ; dc = dc->sibling)
{
sc = lookup_element (src, dc->element, NULL, NO_INSERT);
if (sc == NULL)
abort ();
generate_element_copy (dc, sc, list_p);
}
if (dst->replacement)
{
tree t;
if (src->replacement == NULL)
abort ();
t = build (MODIFY_EXPR, void_type_node, dst->replacement,
src->replacement);
append_to_statement_list (t, list_p);
}
}
/* Generate a set of assignment statements in *LIST_P to zero all instantiated
elements under ELT. In addition, do not assign to elements that have been
marked VISITED but do reset the visited flag; this allows easy coordination
with generate_element_init. */
static void
generate_element_zero (struct sra_elt *elt, tree *list_p)
{
struct sra_elt *c;
for (c = elt->children; c ; c = c->sibling)
generate_element_zero (c, list_p);
if (elt->visited)
elt->visited = false;
else if (elt->replacement)
{
tree t;
if (elt->is_scalar)
t = fold_convert (elt->type, integer_zero_node);
else
/* We generated a replacement for a non-scalar? */
abort ();
t = build (MODIFY_EXPR, void_type_node, elt->replacement, t);
append_to_statement_list (t, list_p);
}
}
/* Generate a set of assignment statements in *LIST_P to set all instantiated
elements under ELT with the contents of the initializer INIT. In addition,
mark all assigned elements VISITED; this allows easy coordination with
generate_element_zero. */
static void
generate_element_init (struct sra_elt *elt, tree init, tree *list_p)
{
enum tree_code init_code = TREE_CODE (init);
struct sra_elt *sub;
tree t;
if (elt->is_scalar)
{
if (elt->replacement)
{
t = build (MODIFY_EXPR, void_type_node, elt->replacement, init);
append_to_statement_list (t, list_p);
elt->visited = true;
}
return;
}
switch (init_code)
{
case COMPLEX_CST:
case COMPLEX_EXPR:
for (sub = elt->children; sub ; sub = sub->sibling)
{
if (sub->element == integer_zero_node)
t = (init_code == COMPLEX_EXPR
? TREE_OPERAND (init, 0) : TREE_REALPART (init));
else
t = (init_code == COMPLEX_EXPR
? TREE_OPERAND (init, 1) : TREE_IMAGPART (init));
generate_element_init (sub, t, list_p);
}
break;
case CONSTRUCTOR:
for (t = CONSTRUCTOR_ELTS (init); t ; t = TREE_CHAIN (t))
{
sub = lookup_element (elt, TREE_PURPOSE (t), NULL, NO_INSERT);
if (sub == NULL)
continue;
generate_element_init (sub, TREE_VALUE (t), list_p);
}
break;
default:
abort ();
}
}
/* Insert STMT on all the outgoing edges out of BB. Note that if BB
has more than one edge, STMT will be replicated for each edge. Also,
abnormal edges will be ignored. */
void
insert_edge_copies (tree stmt, basic_block bb)
{
edge e;
bool first_copy;
first_copy = true;
for (e = bb->succ; e; e = e->succ_next)
{
/* We don't need to insert copies on abnormal edges. The
value of the scalar replacement is not guaranteed to
be valid through an abnormal edge. */
if (!(e->flags & EDGE_ABNORMAL))
{
if (first_copy)
{
bsi_insert_on_edge (e, stmt);
first_copy = false;
}
else
bsi_insert_on_edge (e, lhd_unsave_expr_now (stmt));
}
}
}
/* Helper function to insert LIST before BSI, and set up line number info. */
static void
sra_insert_before (block_stmt_iterator *bsi, tree list)
{
tree stmt = bsi_stmt (*bsi);
if (EXPR_HAS_LOCATION (stmt))
annotate_all_with_locus (&list, EXPR_LOCATION (stmt));
bsi_insert_before (bsi, list, BSI_SAME_STMT);
}
/* Similarly, but insert after BSI. Handles insertion onto edges as well. */
static void
sra_insert_after (block_stmt_iterator *bsi, tree list)
{
tree stmt = bsi_stmt (*bsi);
if (EXPR_HAS_LOCATION (stmt))
annotate_all_with_locus (&list, EXPR_LOCATION (stmt));
if (stmt_ends_bb_p (stmt))
insert_edge_copies (list, bsi->bb);
else
bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
}
/* Similarly, but replace the statement at BSI. */
static void
sra_replace (block_stmt_iterator *bsi, tree list)
{
sra_insert_before (bsi, list);
bsi_remove (bsi);
if (bsi_end_p (*bsi))
*bsi = bsi_last (bsi->bb);
else
bsi_prev (bsi);
}
/* Scalarize a USE. To recap, this is either a simple reference to ELT,
if elt is scalar, or some ocurrence of ELT that requires a complete
aggregate. IS_OUTPUT is true if ELT is being modified. */
static void
scalarize_use (struct sra_elt *elt, tree *expr_p, block_stmt_iterator *bsi,
bool is_output)
{
tree list = NULL, stmt = bsi_stmt (*bsi);
if (elt->replacement)
{
/* If we have a replacement, then updating the reference is as
simple as modifying the existing statement in place. */
if (is_output)
mark_all_v_defs (stmt);
*expr_p = elt->replacement;
modify_stmt (stmt);
}
else
{
/* Otherwise we need some copies. If ELT is being read, then we want
to store all (modified) sub-elements back into the structure before
the reference takes place. If ELT is being written, then we want to
load the changed values back into our shadow variables. */
/* ??? We don't check modified for reads, we just always write all of
the values. We should be able to record the SSA number of the VOP
for which the values were last read. If that number matches the
SSA number of the VOP in the current statement, then we needn't
emit an assignment. This would also eliminate double writes when
a structure is passed as more than one argument to a function call.
This optimization would be most effective if sra_walk_function
processed the blocks in dominator order. */
generate_copy_inout (elt, is_output, generate_element_ref (elt), &list);
if (list == NULL)
return;
if (is_output)
{
mark_all_v_defs (expr_first (list));
sra_insert_after (bsi, list);
}
else
sra_insert_before (bsi, list);
}
}
/* Scalarize a COPY. To recap, this is an assignment statement between
two scalarizable references, LHS_ELT and RHS_ELT. */
static void
scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
block_stmt_iterator *bsi)
{
tree list, stmt;
if (lhs_elt->replacement && rhs_elt->replacement)
{
/* If we have two scalar operands, modify the existing statement. */
stmt = bsi_stmt (*bsi);
#ifdef ENABLE_CHECKING
/* See the commentary in sra_walk_function concerning
RETURN_EXPR, and why we should never see one here. */
if (TREE_CODE (stmt) != MODIFY_EXPR)
abort ();
#endif
TREE_OPERAND (stmt, 0) = lhs_elt->replacement;
TREE_OPERAND (stmt, 1) = rhs_elt->replacement;
modify_stmt (stmt);
}
else if (lhs_elt->use_block_copy || rhs_elt->use_block_copy)
{
/* If either side requires a block copy, then sync the RHS back
to the original structure, leave the original assignment
statement (which will perform the block copy), then load the
LHS values out of its now-updated original structure. */
/* ??? Could perform a modified pair-wise element copy. That
would at least allow those elements that are instantiated in
both structures to be optimized well. */
list = NULL;
generate_copy_inout (rhs_elt, false,
generate_element_ref (rhs_elt), &list);
if (list)
{
mark_all_v_defs (expr_first (list));
sra_insert_before (bsi, list);
}
list = NULL;
generate_copy_inout (lhs_elt, true,
generate_element_ref (lhs_elt), &list);
if (list)
sra_insert_after (bsi, list);
}
else
{
/* Otherwise both sides must be fully instantiated. In which
case perform pair-wise element assignments and replace the
original block copy statement. */
stmt = bsi_stmt (*bsi);
mark_all_v_defs (stmt);
list = NULL;
generate_element_copy (lhs_elt, rhs_elt, &list);
if (list == NULL)
abort ();
sra_replace (bsi, list);
}
}
/* Scalarize an INIT. To recap, this is an assignment to a scalarizable
reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
CONSTRUCTOR. */
static void
scalarize_init (struct sra_elt *lhs_elt, tree rhs, block_stmt_iterator *bsi)
{
tree list = NULL;
/* Generate initialization statements for all members extant in the RHS. */
if (rhs)
generate_element_init (lhs_elt, rhs, &list);
/* CONSTRUCTOR is defined such that any member not mentioned is assigned
a zero value. Initialize the rest of the instantiated elements. */
generate_element_zero (lhs_elt, &list);
if (list == NULL)
return;
if (lhs_elt->use_block_copy)
{
/* Since LHS is not fully instantiated, we must leave the structure
assignment in place. Treating this case differently from a USE
exposes constants to later optimizations. */
mark_all_v_defs (expr_first (list));
sra_insert_after (bsi, list);
}
else
{
/* The LHS is fully instantiated. The list of initializations
replaces the original structure assignment. */
mark_all_v_defs (bsi_stmt (*bsi));
sra_replace (bsi, list);
}
}
/* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
on all INDIRECT_REFs. */
static tree
mark_notrap (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
tree t = *tp;
if (TREE_CODE (t) == INDIRECT_REF)
{
TREE_THIS_NOTRAP (t) = 1;
*walk_subtrees = 0;
}
else if (DECL_P (t) || TYPE_P (t))
*walk_subtrees = 0;
return NULL;
}
/* Scalarize a LDST. To recap, this is an assignment between one scalarizable
reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
if ELT is on the left-hand side. */
static void
scalarize_ldst (struct sra_elt *elt, tree other,
block_stmt_iterator *bsi, bool is_output)
{
/* Shouldn't have gotten called for a scalar. */
if (elt->replacement)
abort ();
if (elt->use_block_copy)
{
/* Since ELT is not fully instantiated, we have to leave the
block copy in place. Treat this as a USE. */
scalarize_use (elt, NULL, bsi, is_output);
}
else
{
/* The interesting case is when ELT is fully instantiated. In this
case we can have each element stored/loaded directly to/from the
corresponding slot in OTHER. This avoids a block copy. */
tree list = NULL, stmt = bsi_stmt (*bsi);
mark_all_v_defs (stmt);
generate_copy_inout (elt, is_output, other, &list);
if (list == NULL)
abort ();
/* Preserve EH semantics. */
if (stmt_ends_bb_p (stmt))
{
tree_stmt_iterator tsi;
tree first;
/* Extract the first statement from LIST. */
tsi = tsi_start (list);
first = tsi_stmt (tsi);
tsi_delink (&tsi);
/* Replace the old statement with this new representative. */
bsi_replace (bsi, first, true);
if (!tsi_end_p (tsi))
{
/* If any reference would trap, then they all would. And more
to the point, the first would. Therefore none of the rest
will trap since the first didn't. Indicate this by
iterating over the remaining statements and set
TREE_THIS_NOTRAP in all INDIRECT_REFs. */
do
{
walk_tree (tsi_stmt_ptr (tsi), mark_notrap, NULL, NULL);
tsi_next (&tsi);
}
while (!tsi_end_p (tsi));
insert_edge_copies (list, bsi->bb);
}
}
else
sra_replace (bsi, list);
}
}
/* Generate initializations for all scalarizable parameters. */
static void
scalarize_parms (void)
{
tree list = NULL;
size_t i;
EXECUTE_IF_SET_IN_BITMAP (needs_copy_in, 0, i,
{
tree var = referenced_var (i);
struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
generate_copy_inout (elt, true, var, &list);
});
if (list)
insert_edge_copies (list, ENTRY_BLOCK_PTR);
}
/* Entry point to phase 4. Update the function to match replacements. */
static void
scalarize_function (void)
{
static const struct sra_walk_fns fns = {
scalarize_use, scalarize_copy, scalarize_init, scalarize_ldst, false
};
sra_walk_function (&fns);
scalarize_parms ();
bsi_commit_edge_inserts (NULL);
}
\f
/* Debug helper function. Print ELT in a nice human-readable format. */
static void
dump_sra_elt_name (FILE *f, struct sra_elt *elt)
{
if (elt->parent && TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
{
fputs (elt->element == integer_zero_node ? "__real__ " : "__imag__ ", f);
dump_sra_elt_name (f, elt->parent);
}
else
{
if (elt->parent)
dump_sra_elt_name (f, elt->parent);
if (DECL_P (elt->element))
{
if (TREE_CODE (elt->element) == FIELD_DECL)
fputc ('.', f);
print_generic_expr (f, elt->element, dump_flags);
}
else
fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]",
TREE_INT_CST_LOW (elt->element));
}
}
/* Likewise, but callable from the debugger. */
void
debug_sra_elt_name (struct sra_elt *elt)
{
dump_sra_elt_name (stderr, elt);
fputc ('\n', stderr);
}
/* Main entry point. */
static void
tree_sra (void)
{
/* Initialize local variables. */
gcc_obstack_init (&sra_obstack);
sra_candidates = BITMAP_XMALLOC ();
needs_copy_in = BITMAP_XMALLOC ();
sra_type_decomp_cache = BITMAP_XMALLOC ();
sra_type_inst_cache = BITMAP_XMALLOC ();
sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL);
/* Scan. If we find anything, instantiate and scalarize. */
if (find_candidates_for_sra ())
{
scan_function ();
decide_instantiations ();
scalarize_function ();
}
/* Free allocated memory. */
htab_delete (sra_map);
sra_map = NULL;
BITMAP_XFREE (sra_candidates);
BITMAP_XFREE (needs_copy_in);
BITMAP_XFREE (sra_type_decomp_cache);
BITMAP_XFREE (sra_type_inst_cache);
obstack_free (&sra_obstack, NULL);
}
static bool
gate_sra (void)
{
return flag_tree_sra != 0;
}
struct tree_opt_pass pass_sra =
{
"sra", /* name */
gate_sra, /* gate */
tree_sra, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
TV_TREE_SRA, /* tv_id */
PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
TODO_dump_func | TODO_rename_vars
| TODO_ggc_collect | TODO_verify_ssa /* todo_flags_finish */
};
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: New SRA implementation
2004-06-29 18:58 New SRA implementation Richard Henderson
@ 2004-06-29 20:03 ` Paolo Carlini
2004-06-29 20:12 ` Richard Henderson
2004-06-29 20:51 ` Andrew Pinski
2004-07-10 17:17 ` Roman Zippel
2 siblings, 1 reply; 6+ messages in thread
From: Paolo Carlini @ 2004-06-29 20:03 UTC (permalink / raw)
To: Richard Henderson; +Cc: gcc-patches
Richard Henderson wrote:
>This is a complete rewrite to address both of these issues. Nested
>structures are handled. Arrays are handled. Arbitrary numbers of
>fields are handled.
>
>
Yeah!
> * tree-sra.c: Rewrite from scratch. Handle nested aggregates.
>
>/* Scalar Replacement of Aggregates (SRA) converts some structure
> references into scalar references, exposing them to the scalar
> optimizers.
> Copyright (C) 2003, 2004 Free Software Foundation, Inc.
> Contributed by Diego Novillo <dnovillo@redhat.com>
>
>
Now, sorry for the stupid question (my excuses in advance to Diego):
if we are talking about a "Rewrite from scratch", why Rth doesn't appear
in the header?
Paolo.
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: New SRA implementation
2004-06-29 20:03 ` Paolo Carlini
@ 2004-06-29 20:12 ` Richard Henderson
0 siblings, 0 replies; 6+ messages in thread
From: Richard Henderson @ 2004-06-29 20:12 UTC (permalink / raw)
To: Paolo Carlini; +Cc: gcc-patches
On Tue, Jun 29, 2004 at 06:50:51PM +0200, Paolo Carlini wrote:
> Now, sorry for the stupid question (my excuses in advance to Diego):
> if we are talking about a "Rewrite from scratch", why Rth doesn't appear
> in the header?
*shrug* Didn't seem important.
r~
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: New SRA implementation
2004-06-29 18:58 New SRA implementation Richard Henderson
2004-06-29 20:03 ` Paolo Carlini
@ 2004-06-29 20:51 ` Andrew Pinski
2004-07-10 17:17 ` Roman Zippel
2 siblings, 0 replies; 6+ messages in thread
From: Andrew Pinski @ 2004-06-29 20:51 UTC (permalink / raw)
To: Richard Henderson; +Cc: gcc-patches
>
>
> The previous SRA implementation had two unfortunate restrictions.
>
> First, it couldn't handle nested aggregates, which severely limited
> its usefullness when it comes to real-world code. Including that
> within gcc itself, e.g. block_stmt_iterator.
>
> Second, it had a hard-coded limit of five fields per aggregate.
>
> This is a complete rewrite to address both of these issues. Nested
> structures are handled. Arrays are handled. Arbitrary numbers of
> fields are handled.
>
> Extending to arbitrary numbers of fields means that we have to have
> a good deal more smarts in deciding whether or not to instantiate
> the fields. I've come up with some preliminary heuristics that seem
> to be not unreasonable, at least for the code within gcc and its
> testsuites. Surely more work is required here.
>
> I havn't been able to measure a speed difference between the new and
> old implementation that wasn't less than 1%, but for the record,
> bootstrap with the new implementation was u+s 175 out of 19181 seconds
> faster to bootstrap.
MOVE_RATIO is not defined for many targets except when including expr.h.
This patch fixes this bootstrap failure.
Committed as obvious as it gets me passed this failure.
Thanks,
Andrew Pinski
2004-06-29 Andrew Pinski <apinski@apple.com>
* tree-sra.c: Include expr.h for definition of MOVE_RATIO.
* Makefile.in (tree-sra.c): Update dependencies.
Index: Makefile.in
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Makefile.in,v
retrieving revision 1.1309
diff -u -p -r1.1309 Makefile.in
--- Makefile.in 28 Jun 2004 18:27:02 -0000 1.1309
+++ Makefile.in 29 Jun 2004 17:02:09 -0000
@@ -1890,7 +1890,7 @@ tree-ssa-ccp.o : tree-ssa-ccp.c $(CONFIG
tree-sra.o : tree-sra.c $(CONFIG_H) system.h errors.h $(TREE_H) $(RTL_H) \
$(TM_P_H) $(TREE_FLOW_H) diagnostic.h tree-inline.h \
$(TIMEVAR_H) $(TM_H) coretypes.h $(TREE_DUMP_H) $(TREE_GIMPLE_H) \
- langhooks.h tree-pass.h $(FLAGS_H)
+ langhooks.h tree-pass.h $(FLAGS_H) $(EXPR_H)
tree-complex.o : tree-complex.c $(CONFIG_H) system.h $(TREE_H) \
$(TM_H) $(TREE_FLOW_H) $(TREE_GIMPLE_H) tree-iterator.h tree-pass.h \
$(FLAGS_H)
Index: tree-sra.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-sra.c,v
retrieving revision 2.10
diff -u -p -r2.10 tree-sra.c
--- tree-sra.c 29 Jun 2004 16:25:27 -0000 2.10
+++ tree-sra.c 29 Jun 2004 17:02:09 -0000
@@ -46,6 +46,8 @@ Software Foundation, 59 Temple Place - S
#include "bitmap.h"
#include "obstack.h"
#include "target.h"
+/* expr.h is needed for MOVE_RATIO. */
+#include "expr.h"
/* This object of this pass is to replace a non-addressable aggregate with a
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: New SRA implementation
2004-06-29 18:58 New SRA implementation Richard Henderson
2004-06-29 20:03 ` Paolo Carlini
2004-06-29 20:51 ` Andrew Pinski
@ 2004-07-10 17:17 ` Roman Zippel
2 siblings, 0 replies; 6+ messages in thread
From: Roman Zippel @ 2004-07-10 17:17 UTC (permalink / raw)
To: Richard Henderson; +Cc: gcc-patches
Hi,
Richard Henderson wrote:
> * tree-sra.c: Rewrite from scratch. Handle nested aggregates.
> * gcc.dg/tree-ssa/20040430-1.c: Expect zero if's.
This patch seems to break the testcase 980223.c at -O3 for
mips/m68k/ppc. I reduced it to this patch with a cross compiler on m68k.
According to the posted testresults on ppc this test starts failing
around the same time.
bye, Roman
^ permalink raw reply [flat|nested] 6+ messages in thread
* New SRA Implementation
@ 2008-08-30 20:53 Jakub Staszak
0 siblings, 0 replies; 6+ messages in thread
From: Jakub Staszak @ 2008-08-30 20:53 UTC (permalink / raw)
To: GCC
[-- Attachment #1: Type: text/plain, Size: 402 bytes --]
Hello,
During my internship in Novell I have been doing new SRA
implementation based on flat memory. It's very simple and have to be
improved in many places, however in some cases generates better code
that the current one (e.g. it can scalarize unions).
It bootstraps trunk before IRA. After IRA there are some problems,
Richi will write something more about this bug soon.
--
Jakub Staszak
[-- Attachment #2: sra-patch.diff --]
[-- Type: application/octet-stream, Size: 146593 bytes --]
Index: tree.h
===================================================================
--- tree.h (revision 139372)
+++ tree.h (working copy)
@@ -4704,6 +4704,8 @@ extern void using_eh_for_cleanups (void)
/* In fold-const.c */
+tree build_bit_mask (tree type, unsigned int, unsigned int);
+
/* Non-zero if we are folding constants inside an initializer; zero
otherwise. */
extern int folding_initializer;
Index: fold-const.c
===================================================================
--- fold-const.c (revision 139372)
+++ fold-const.c (working copy)
@@ -2006,6 +2006,19 @@ const_binop (enum tree_code code, tree a
return NULL_TREE;
}
+/* Builds and returns a mask of integral type TYPE for masking out
+ * BITSIZE bits at bit position BITPOS in a word of type TYPE.
+ * The mask has the bits set from bit BITPOS to BITPOS + BITSIZE - 1. */
+
+tree
+build_bit_mask (tree type, unsigned int bitsize, unsigned int bitpos)
+{
+ tree mask = double_int_to_tree (type, double_int_mask (bitsize));
+ mask = const_binop (LSHIFT_EXPR, mask, size_int (bitpos), 0);
+
+ return mask;
+}
+
/* Create a size type INT_CST node with NUMBER sign extended. KIND
indicates which particular sizetype to create. */
Index: tree-ssa-loop-ivopts.c
===================================================================
--- tree-ssa-loop-ivopts.c (revision 139372)
+++ tree-ssa-loop-ivopts.c (working copy)
@@ -1731,6 +1731,7 @@ find_interesting_uses_stmt (struct ivopt
code = gimple_assign_rhs_code (stmt);
if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS
+ && (TREE_CODE (*rhs) != VIEW_CONVERT_EXPR)
&& (REFERENCE_CLASS_P (*rhs)
|| is_gimple_val (*rhs)))
{
Index: tree-sra.c
===================================================================
--- tree-sra.c (revision 139372)
+++ tree-sra.c (working copy)
@@ -1,21 +1,22 @@
/* Scalar Replacement of Aggregates (SRA) converts some structure
references into scalar references, exposing them to the scalar
optimizers.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
- Contributed by Diego Novillo <dnovillo@redhat.com>
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008 Free Software
+ Foundation, Inc.
+ Contributed by Richard Guenther <rguenther@suse.de>, Michael Matz
+ <matz@suse.de> and Jakub Staszak <kuba@gcc.gnu.org>.
This file is part of GCC.
-GCC is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 3, or (at your option) any
-later version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
@@ -48,3666 +49,1306 @@ along with GCC; see the file COPYING3.
/* expr.h is needed for MOVE_RATIO. */
#include "expr.h"
#include "params.h"
+#include "pointer-set.h"
+/* Basic algorithm.
-/* This object of this pass is to replace a non-addressable aggregate with a
- set of independent variables. Most of the time, all of these variables
- will be scalars. But a secondary objective is to break up larger
- aggregates into smaller aggregates. In the process we may find that some
- bits of the larger aggregate can be deleted as unreferenced.
+ Algorithm has four main stages.
- This substitution is done globally. More localized substitutions would
- be the purvey of a load-store motion pass.
+ 1. `find_base_candidates':
+ We iterate over all variables and look for candidates for scalarization.
+ We set them in BASE_MAP.
- The optimization proceeds in phases:
+ 2. `scan_function':
+ We visit every statement and look for component references (or base
+ varibable references) of candidates from BASE_MAP. Then we mark
+ interesting statements (gimple_stmt_iterator) in DECOMOSED_GSIS vector.
- (1) Identify variables that have types that are candidates for
- decomposition.
+ 3. `analyze_accesses':
+ We iterate over all access and try to make a decision which of them are
+ suitable for scalarization. We build replacements for these accesses.
- (2) Scan the function looking for the ways these variables are used.
- In particular we're interested in the number of times a variable
- (or member) is needed as a complete unit, and the number of times
- a variable (or member) is copied.
+ 4, `scalarize_function':
+ We iterate ovar all candidates and scalarize them. Every access is
+ replaced by it's REPLACEMENT field. Some new statements (e.g. for a
+ VIEW_CONVERT_EXPR) are added. */
- (3) Based on the usage profile, instantiate substitution variables.
- (4) Scan the function making replacements.
-*/
+/* ACCESS represents each access to aggregate variable (base or component). */
+struct access
+{
+ /* Values returned by `get_ref_base_and_extent' for each COMPONENT_REF
+ If EXPR isn't a COMPONENT_REF just set `BASE = EXPR', `OFFEST = 0',
+ `SIZE = MAXSIZE = TREE_SIZE (TREE_TYPE (expr))'. */
+ tree base;
-/* True if this is the "early" pass, before inlining. */
-static bool early_sra;
-
-/* The set of todo flags to return from tree_sra. */
-static unsigned int todoflags;
-
-/* The set of aggregate variables that are candidates for scalarization. */
-static bitmap sra_candidates;
+ HOST_WIDE_INT offset;
-/* Set of scalarizable PARM_DECLs that need copy-in operations at the
- beginning of the function. */
-static bitmap needs_copy_in;
+ HOST_WIDE_INT size;
-/* Sets of bit pairs that cache type decomposition and instantiation. */
-static bitmap sra_type_decomp_cache;
-static bitmap sra_type_inst_cache;
+ HOST_WIDE_INT maxsize;
-/* One of these structures is created for each candidate aggregate and
- each (accessed) member or group of members of such an aggregate. */
-struct sra_elt
-{
- /* A tree of the elements. Used when we want to traverse everything. */
- struct sra_elt *parent;
- struct sra_elt *groups;
- struct sra_elt *children;
- struct sra_elt *sibling;
- /* If this element is a root, then this is the VAR_DECL. If this is
- a sub-element, this is some token used to identify the reference.
- In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
- of an ARRAY_REF, this is the (constant) index. In the case of an
- ARRAY_RANGE_REF, this is the (constant) RANGE_EXPR. In the case
- of a complex number, this is a zero or one. */
- tree element;
+ /* Expression. */
+ tree expr;
- /* The type of the element. */
+ /* Type. */
tree type;
- /* A VAR_DECL, for any sub-element we've decided to replace. */
+ /* Replacement of this EXPR. */
tree replacement;
- /* The number of times the element is referenced as a whole. I.e.
- given "a.b.c", this would be incremented for C, but not for A or B. */
- unsigned int n_uses;
+ /* If expression is an ARRAY_REF (i.e. `foo.bar[i]') then:
+ `EXPR = "foo.bar"', `INDEX = "i"'. Otherwhise `INDEX = NULL_TREE'. */
+ tree index;
- /* The number of times the element is copied to or from another
- scalarizable element. */
- unsigned int n_copies;
+ /* If TYPE_MODE(TYPE) != BLKmode. */
+ bool non_blk;
- /* True if TYPE is scalar. */
- bool is_scalar;
+ bool maybe_hot;
+};
- /* True if this element is a group of members of its parent. */
- bool is_group;
+typedef struct access *access_p;
- /* True if we saw something about this element that prevents scalarization,
- such as non-constant indexing. */
- bool cannot_scalarize;
+DEF_VEC_P (access_p);
+DEF_VEC_ALLOC_P (access_p, heap);
- /* True if we've decided that structure-to-structure assignment
- should happen via memcpy and not per-element. */
- bool use_block_copy;
- /* True if everything under this element has been marked TREE_NO_WARNING. */
- bool all_no_warning;
+/* DECOMPOSED_GSI describes every statement with candidate(s) for
+ scalarization. */
- /* A flag for use with/after random access traversals. */
- bool visited;
+typedef struct {
+ /* Statement with candidate. */
+ gimple_stmt_iterator gsi;
- /* True if there is BIT_FIELD_REF on the lhs with a vector. */
- bool is_vector_lhs;
+ /* Probably some others fields are going to be here. */
+} decomposed_gsi;
- /* 1 if the element is a field that is part of a block, 2 if the field
- is the block itself, 0 if it's neither. */
- char in_bitfld_block;
-};
+DEF_VEC_O (decomposed_gsi);
+DEF_VEC_ALLOC_O (decomposed_gsi, heap);
-#define IS_ELEMENT_FOR_GROUP(ELEMENT) (TREE_CODE (ELEMENT) == RANGE_EXPR)
-#define FOR_EACH_ACTUAL_CHILD(CHILD, ELT) \
- for ((CHILD) = (ELT)->is_group \
- ? next_child_for_group (NULL, (ELT)) \
- : (ELT)->children; \
- (CHILD); \
- (CHILD) = (ELT)->is_group \
- ? next_child_for_group ((CHILD), (ELT)) \
- : (CHILD)->sibling)
-
-/* Helper function for above macro. Return next child in group. */
-static struct sra_elt *
-next_child_for_group (struct sra_elt *child, struct sra_elt *group)
-{
- gcc_assert (group->is_group);
-
- /* Find the next child in the parent. */
- if (child)
- child = child->sibling;
- else
- child = group->parent->children;
+/* Vector of gimple statements which _CAN_ be scalarated. */
+static VEC(decomposed_gsi, heap) *decomposed_gsis;
- /* Skip siblings that do not belong to the group. */
- while (child)
- {
- tree g_elt = group->element;
- if (TREE_CODE (g_elt) == RANGE_EXPR)
- {
- if (!tree_int_cst_lt (child->element, TREE_OPERAND (g_elt, 0))
- && !tree_int_cst_lt (TREE_OPERAND (g_elt, 1), child->element))
- break;
- }
- else
- gcc_unreachable ();
+/* Obstack for ACCESS. */
+static struct obstack access_obstack;
- child = child->sibling;
- }
+/* Expression (tree) -> Field (access_p) map for each access to some component.
+ (TODO: move it to htab) */
+static struct pointer_map_t *access_map;
- return child;
-}
+/* Base (tree) -> Vector (VEC(access_p,heap) *) map. */
+static struct pointer_map_t *base_access_vec;
-/* Random access to the child of a parent is performed by hashing.
- This prevents quadratic behavior, and allows SRA to function
- reasonably on larger records. */
-static htab_t sra_map;
+/* Bitmap of bases (candidates). */
+static bitmap base_map;
-/* All structures are allocated out of the following obstack. */
-static struct obstack sra_obstack;
-/* Debugging functions. */
-static void dump_sra_elt_name (FILE *, struct sra_elt *);
-extern void debug_sra_elt_name (struct sra_elt *);
+/* This is not mine. I think we should move it somewhere. */
-/* Forward declarations. */
-static tree generate_element_ref (struct sra_elt *);
-static gimple_seq sra_build_assignment (tree dst, tree src);
-static void mark_all_v_defs_seq (gimple_seq);
-static void mark_all_v_defs_stmt (gimple);
+void
+insert_edge_copies_seq (gimple_seq seq, basic_block bb)
+{
+ edge e;
+ edge_iterator ei;
+ unsigned n_copies = -1;
-\f
-/* Return true if DECL is an SRA candidate. */
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (!(e->flags & EDGE_ABNORMAL))
+ n_copies++;
-static bool
-is_sra_candidate_decl (tree decl)
-{
- return DECL_P (decl) && bitmap_bit_p (sra_candidates, DECL_UID (decl));
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (!(e->flags & EDGE_ABNORMAL))
+ gsi_insert_seq_on_edge (e, n_copies-- > 0 ? gimple_seq_copy (seq) : seq);
}
-/* Return true if TYPE is a scalar type. */
-static bool
-is_sra_scalar_type (tree type)
+/* Dump access. */
+
+static void
+dump_access (struct access *access)
{
- enum tree_code code = TREE_CODE (type);
- return (code == INTEGER_TYPE || code == REAL_TYPE || code == VECTOR_TYPE
- || code == FIXED_POINT_TYPE
- || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
- || code == POINTER_TYPE || code == OFFSET_TYPE
- || code == REFERENCE_TYPE);
+ if (!dump_file)
+ return;
+
+ fprintf (dump_file, "access { ");
+ fprintf (dump_file, "base = (%d)'", DECL_UID (access->base));
+ print_generic_expr (dump_file, access->base, 0);
+ fprintf (dump_file, "', offset = %d", (int) access->offset);
+ fprintf (dump_file, ", size = %d", (int) access->size);
+ fprintf (dump_file, ", maxsize = %d", (int) access->maxsize);
+ fprintf (dump_file, ", expr = ");
+ print_generic_expr (dump_file, access->expr, 0);
+ fprintf (dump_file, ", type = '");
+ print_generic_expr (dump_file, access->type, 0);
+ fprintf (dump_file, ", repl = '");
+
+ if (access->replacement)
+ print_generic_expr (dump_file, access->replacement, 0);
+ else
+ fprintf (dump_file, "@");
+
+ fprintf (dump_file, "', array_ref = %d", (int) (access->index != NULL_TREE));
+ fprintf (dump_file, ", hot = %d }\n", (int) (access->maybe_hot));
}
-/* Return true if TYPE can be decomposed into a set of independent variables.
- Note that this doesn't imply that all elements of TYPE can be
- instantiated, just that if we decide to break up the type into
- separate pieces that it can be done. */
+/* Dump all accesses from VEC. */
-bool
-sra_type_can_be_decomposed_p (tree type)
+static void
+dump_vec_accesses (VEC(access_p, heap) *vec)
{
- unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
- tree t;
-
- /* Avoid searching the same type twice. */
- if (bitmap_bit_p (sra_type_decomp_cache, cache+0))
- return true;
- if (bitmap_bit_p (sra_type_decomp_cache, cache+1))
- return false;
+ struct access *access;
+ unsigned i;
- /* The type must have a definite nonzero size. */
- if (TYPE_SIZE (type) == NULL || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
- || integer_zerop (TYPE_SIZE (type)))
- goto fail;
-
- /* The type must be a non-union aggregate. */
- switch (TREE_CODE (type))
- {
- case RECORD_TYPE:
- {
- bool saw_one_field = false;
+ for (i = 0; VEC_iterate (access_p, vec, i, access); i++)
+ dump_access (access);
+}
- for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
- if (TREE_CODE (t) == FIELD_DECL)
- {
- /* Reject incorrectly represented bit fields. */
- if (DECL_BIT_FIELD (t)
- && INTEGRAL_TYPE_P (TREE_TYPE (t))
- && (tree_low_cst (DECL_SIZE (t), 1)
- != TYPE_PRECISION (TREE_TYPE (t))))
- goto fail;
- saw_one_field = true;
- }
+/* Init all data structures. */
- /* Record types must have at least one field. */
- if (!saw_one_field)
- goto fail;
- }
- break;
+static void
+sra_init (void)
+{
+ base_map = BITMAP_ALLOC (NULL);
+ decomposed_gsis = VEC_alloc (decomposed_gsi, heap, 32);
+ gcc_obstack_init (&access_obstack);
+ access_map = pointer_map_create ();
+ base_access_vec = pointer_map_create ();
+}
- case ARRAY_TYPE:
- /* Array types must have a fixed lower and upper bound. */
- t = TYPE_DOMAIN (type);
- if (t == NULL)
- goto fail;
- if (TYPE_MIN_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MIN_VALUE (t)))
- goto fail;
- if (TYPE_MAX_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MAX_VALUE (t)))
- goto fail;
- break;
- case COMPLEX_TYPE:
- break;
+/* Mother's little helper. */
- default:
- goto fail;
- }
+static bool
+delete_base_accesses (const void *key ATTRIBUTE_UNUSED, void **value,
+ void *data ATTRIBUTE_UNUSED)
+{
+ VEC(access_p, heap) *access_vec;
+ access_vec = (VEC(access_p, heap) *) *value;
+ VEC_free (access_p, heap, access_vec);
- bitmap_set_bit (sra_type_decomp_cache, cache+0);
return true;
-
- fail:
- bitmap_set_bit (sra_type_decomp_cache, cache+1);
- return false;
}
-/* Returns true if the TYPE is one of the available va_list types.
- Otherwise it returns false.
- Note, that for multiple calling conventions there can be more
- than just one va_list type present. */
-static bool
-is_va_list_type (tree type)
+/* Deinit everything. */
+
+static void
+sra_deinit (void)
{
- tree h;
+ BITMAP_FREE (base_map);
+ VEC_free (decomposed_gsi, heap, decomposed_gsis);
+ obstack_free (&access_obstack, NULL);
+ pointer_map_destroy (access_map);
- if (type == NULL_TREE)
- return false;
- h = targetm.canonical_va_list_type (type);
- if (h == NULL_TREE)
- return false;
- if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (h))
- return true;
- return false;
+ pointer_map_traverse (base_access_vec, delete_base_accesses, NULL);
+ pointer_map_destroy (base_access_vec);
}
-/* Return true if DECL can be decomposed into a set of independent
- (though not necessarily scalar) variables. */
+
+/* Find decomposed variables. Return true if any candidate has been found. */
static bool
-decl_can_be_decomposed_p (tree var)
+find_base_candidates (void)
{
- /* Early out for scalars. */
- if (is_sra_scalar_type (TREE_TYPE (var)))
- return false;
+ tree var, type;
+ referenced_var_iterator rvi;
+ bool ret;
- /* The variable must not be aliased. */
- if (!is_gimple_non_addressable (var))
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- if (dump_file && (dump_flags & TDF_DETAILS))
+ if (TREE_CODE (var) != VAR_DECL)
+ continue;
+ type = TREE_TYPE (var);
+
+ if (TREE_CODE (type) == COMPLEX_TYPE)
+ ret = false;
+ else if (TREE_THIS_VOLATILE (var))
+ ret = false;
+ else if (needs_to_live_in_memory (var))
+ ret = false;
+ else if TREE_ADDRESSABLE (type)
+ ret = false;
+ else if (TREE_CODE (var) == FIELD_DECL && DECL_BIT_FIELD (var))
+ ret = false;
+ else if (TREE_CODE (type) != UNION_TYPE && TREE_CODE (type) != RECORD_TYPE)
+ ret = false;
+ else
+ ret = true;
+
+ if (ret)
{
- fprintf (dump_file, "Cannot scalarize variable ");
- print_generic_expr (dump_file, var, dump_flags);
- fprintf (dump_file, " because it must live in memory\n");
+ mark_sym_for_renaming (var);
+
+ bitmap_set_bit (base_map, DECL_UID (var));
+
+ if (dump_file)
+ {
+ fprintf (dump_file, "Candidate (%d): ", DECL_UID (var));
+ print_generic_expr (dump_file, var, 0);
+ fprintf (dump_file, "\n");
+ }
}
- return false;
}
- /* The variable must not be volatile. */
- if (TREE_THIS_VOLATILE (var))
+ return !bitmap_empty_p (base_map);
+}
+
+
+/* Create and insert access for EXPR. Return created access, or NULL if it is not
+ possible. */
+
+static struct access *
+insert_access (tree expr)
+{
+ struct access *access;
+ void **slot;
+ VEC(access_p,heap) *vec;
+ tree base;
+ HOST_WIDE_INT offset, size, max_size;
+
+ if (handled_component_p (expr))
+ base = get_ref_base_and_extent (expr, &offset, &size, &max_size);
+ else
{
- if (dump_file && (dump_flags & TDF_DETAILS))
+ tree tree_size, tree_max_size;
+
+ base = expr;
+
+ tree_size = TYPE_SIZE (TREE_TYPE (base));
+ if (tree_size && host_integerp (tree_size, 1))
{
- fprintf (dump_file, "Cannot scalarize variable ");
- print_generic_expr (dump_file, var, dump_flags);
- fprintf (dump_file, " because it is declared volatile\n");
- }
- return false;
- }
+ tree_max_size = tree_size;
- /* We must be able to decompose the variable's type. */
- if (!sra_type_can_be_decomposed_p (TREE_TYPE (var)))
- {
- if (dump_file && (dump_flags & TDF_DETAILS))
+ size = TREE_INT_CST_LOW (tree_size);
+ max_size = TREE_INT_CST_LOW (tree_max_size);
+ }
+ else
{
- fprintf (dump_file, "Cannot scalarize variable ");
- print_generic_expr (dump_file, var, dump_flags);
- fprintf (dump_file, " because its type cannot be decomposed\n");
+ size = max_size = -1;
}
- return false;
+
+ offset = 0;
}
- /* HACK: if we decompose a va_list_type_node before inlining, then we'll
- confuse tree-stdarg.c, and we won't be able to figure out which and
- how many arguments are accessed. This really should be improved in
- tree-stdarg.c, as the decomposition is truly a win. This could also
- be fixed if the stdarg pass ran early, but this can't be done until
- we've aliasing information early too. See PR 30791. */
- if (early_sra && is_va_list_type (TREE_TYPE (var)))
- return false;
+ if (!DECL_P (base) || !bitmap_bit_p (base_map, DECL_UID (base)))
+ return NULL;
- return true;
-}
+ access = XOBNEW (&access_obstack, struct access);
+ memset (access, 0, sizeof (struct access));
-/* Return true if TYPE can be *completely* decomposed into scalars. */
+ access->base = base;
+ access->offset = offset;
+ access->size = size;
+ access->maxsize = max_size;
+ access->expr = expr;
+ access->type = TREE_TYPE (expr);
-static bool
-type_can_instantiate_all_elements (tree type)
-{
- if (is_sra_scalar_type (type))
- return true;
- if (!sra_type_can_be_decomposed_p (type))
- return false;
+ *((struct access **) pointer_map_insert (access_map, expr)) = access;
- switch (TREE_CODE (type))
- {
- case RECORD_TYPE:
- {
- unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
- tree f;
-
- if (bitmap_bit_p (sra_type_inst_cache, cache+0))
- return true;
- if (bitmap_bit_p (sra_type_inst_cache, cache+1))
- return false;
+ slot = pointer_map_contains (base_access_vec, base);
+ if (slot)
+ vec = (VEC(access_p,heap) *) *slot;
+ else
+ vec = VEC_alloc (access_p, heap, 32);
- for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
- if (TREE_CODE (f) == FIELD_DECL)
- {
- if (!type_can_instantiate_all_elements (TREE_TYPE (f)))
- {
- bitmap_set_bit (sra_type_inst_cache, cache+1);
- return false;
- }
- }
+ VEC_safe_push (access_p, heap, vec, access);
- bitmap_set_bit (sra_type_inst_cache, cache+0);
- return true;
- }
+ *((struct VEC(access_p,heap) **)
+ pointer_map_insert (base_access_vec, base)) = vec;
+ return access;
+}
- case ARRAY_TYPE:
- return type_can_instantiate_all_elements (TREE_TYPE (type));
- case COMPLEX_TYPE:
- return true;
+/* Get access for EXPR. */
- default:
- gcc_unreachable ();
- }
+static struct access *
+get_access (tree expr)
+{
+ void **slot;
+ slot = pointer_map_contains (access_map, expr);
+ if (slot == NULL)
+ return NULL;
+ return (struct access *) *slot;
}
-/* Test whether ELT or some sub-element cannot be scalarized. */
-static bool
-can_completely_scalarize_p (struct sra_elt *elt)
+/* Look for base candidates and remove them from the candidates map. */
+
+static tree
+set_base_unscalarizable (tree *tp, int *walk_subtrees,
+ void *data ATTRIBUTE_UNUSED)
{
- struct sra_elt *c;
+ tree base;
+ HOST_WIDE_INT offset, size, max_size;
- if (elt->cannot_scalarize)
- return false;
+ *walk_subtrees = 1;
- for (c = elt->children; c; c = c->sibling)
- if (!can_completely_scalarize_p (c))
- return false;
+ if (handled_component_p (*tp))
+ base = get_ref_base_and_extent (*tp, &offset, &size, &max_size);
+ else if (DECL_P (*tp))
+ base = *tp;
+ else
+ base = NULL_TREE;
- for (c = elt->groups; c; c = c->sibling)
- if (!can_completely_scalarize_p (c))
- return false;
+ if (base)
+ {
+ if (TREE_CODE (base) == SSA_NAME)
+ base = SSA_NAME_VAR (base);
- return true;
+ if (DECL_P (base))
+ bitmap_clear_bit (base_map, DECL_UID (base));
+ }
+
+ return NULL_TREE;
}
-\f
-/* A simplified tree hashing algorithm that only handles the types of
- trees we expect to find in sra_elt->element. */
-static hashval_t
-sra_hash_tree (tree t)
+/* Scan expression EXPR. Insert access if needed. Return true if any access has
+ been inserted. */
+
+static bool
+scan_expr (tree expr, basic_block bb)
{
- hashval_t h;
+ struct access *ret = NULL;
+ tree safe_expr = expr;
+ tree type = TREE_TYPE (expr);
- switch (TREE_CODE (t))
+ if (TREE_CODE (type) == COMPLEX_TYPE)
+ {
+ walk_tree (&safe_expr, set_base_unscalarizable, NULL, NULL);
+ return false;
+ }
+
+ switch (TREE_CODE (expr))
{
- case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
- h = DECL_UID (t);
- break;
-
- case INTEGER_CST:
- h = TREE_INT_CST_LOW (t) ^ TREE_INT_CST_HIGH (t);
- break;
-
- case RANGE_EXPR:
- h = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
- h = iterative_hash_expr (TREE_OPERAND (t, 1), h);
+ case VAR_DECL:
+ case COMPONENT_REF:
+ case BIT_FIELD_REF:
+ /* It happens when we have base variable. We need htab, TODO. */
+ ret = get_access (expr);
+ if (ret)
+ break;
+ ret = insert_access (expr);
break;
- case FIELD_DECL:
- /* We can have types that are compatible, but have different member
- lists, so we can't hash fields by ID. Use offsets instead. */
- h = iterative_hash_expr (DECL_FIELD_OFFSET (t), 0);
- h = iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t), h);
+ case ARRAY_REF:
+ /* If we have expression like `x.y[i]', insert `x.y', and set INDEX
+ to `i'. */
+ expr = TREE_OPERAND (expr, 0);
+ ret = insert_access (expr);
+ if (ret)
+ ret->index = TREE_OPERAND (safe_expr, 1);
break;
- case BIT_FIELD_REF:
- /* Don't take operand 0 into account, that's our parent. */
- h = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
- h = iterative_hash_expr (TREE_OPERAND (t, 2), h);
- break;
+ case ARRAY_RANGE_REF:
+ case VIEW_CONVERT_EXPR:
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ /* TODO */
default:
- gcc_unreachable ();
+ walk_tree (&safe_expr, set_base_unscalarizable, NULL, NULL);
+ break;
}
- return h;
-}
-
-/* Hash function for type SRA_PAIR. */
+ if (ret)
+ {
+ /* Add some sophisticated optimalization for that eventually.
+ Consider situtation like:
+
+ union { int a; float b; };
+ union foo[N];
+ x = foo[i].a;
+
+ int should be replaced by:
+
+ int sra.1[N];
+ x = sra.1[i];
+ */
+ if (ret->size == -1 || (ret->maxsize != ret->size))
+ {
+ bitmap_clear_bit (base_map, DECL_UID (ret->base));
+ return false;
+ }
-static hashval_t
-sra_elt_hash (const void *x)
-{
- const struct sra_elt *const e = (const struct sra_elt *) x;
- const struct sra_elt *p;
- hashval_t h;
+ /* You are so hot.. ;-) */
+ if (maybe_hot_bb_p (bb))
+ ret->maybe_hot = true;
- h = sra_hash_tree (e->element);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Decompose expr '");
+ print_generic_expr (dump_file, safe_expr, 0);
+ fprintf (dump_file, "'\n");
+ }
- /* Take into account everything except bitfield blocks back up the
- chain. Given that chain lengths are rarely very long, this
- should be acceptable. If we truly identify this as a performance
- problem, it should work to hash the pointer value
- "e->parent". */
- for (p = e->parent; p ; p = p->parent)
- if (!p->in_bitfld_block)
- h = (h * 65521) ^ sra_hash_tree (p->element);
+ return true;
+ }
- return h;
+ return false;
}
-/* Equality function for type SRA_PAIR. */
-static int
-sra_elt_eq (const void *x, const void *y)
-{
- const struct sra_elt *const a = (const struct sra_elt *) x;
- const struct sra_elt *const b = (const struct sra_elt *) y;
- tree ae, be;
- const struct sra_elt *ap = a->parent;
- const struct sra_elt *bp = b->parent;
-
- if (ap)
- while (ap->in_bitfld_block)
- ap = ap->parent;
- if (bp)
- while (bp->in_bitfld_block)
- bp = bp->parent;
-
- if (ap != bp)
- return false;
+/* Scan function and look for interesting statements. Return true if any has
+ been found. */
- ae = a->element;
- be = b->element;
-
- if (ae == be)
- return true;
- if (TREE_CODE (ae) != TREE_CODE (be))
- return false;
+static bool
+scan_function (void)
+{
+ basic_block bb;
+ gimple_stmt_iterator gsi;
+ unsigned i;
+ tree t;
- switch (TREE_CODE (ae))
+ FOR_EACH_BB (bb)
{
- case VAR_DECL:
- case PARM_DECL:
- case RESULT_DECL:
- /* These are all pointer unique. */
- return false;
-
- case INTEGER_CST:
- /* Integers are not pointer unique, so compare their values. */
- return tree_int_cst_equal (ae, be);
-
- case RANGE_EXPR:
- return
- tree_int_cst_equal (TREE_OPERAND (ae, 0), TREE_OPERAND (be, 0))
- && tree_int_cst_equal (TREE_OPERAND (ae, 1), TREE_OPERAND (be, 1));
-
- case FIELD_DECL:
- /* Fields are unique within a record, but not between
- compatible records. */
- if (DECL_FIELD_CONTEXT (ae) == DECL_FIELD_CONTEXT (be))
- return false;
- return fields_compatible_p (ae, be);
-
- case BIT_FIELD_REF:
- return
- tree_int_cst_equal (TREE_OPERAND (ae, 1), TREE_OPERAND (be, 1))
- && tree_int_cst_equal (TREE_OPERAND (ae, 2), TREE_OPERAND (be, 2));
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
- may be null, in which case CHILD must be a DECL. */
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple stmt = gsi_stmt (gsi);
+ bool any = false;
-static struct sra_elt *
-lookup_element (struct sra_elt *parent, tree child, tree type,
- enum insert_option insert)
-{
- struct sra_elt dummy;
- struct sra_elt **slot;
- struct sra_elt *elt;
+ switch (gimple_code (stmt))
+ {
+ case GIMPLE_RETURN:
+ t = gimple_return_retval (stmt);
+ if (t != NULL_TREE)
+ any |= scan_expr (t, bb);
+ break;
- if (parent)
- dummy.parent = parent->is_group ? parent->parent : parent;
- else
- dummy.parent = NULL;
- dummy.element = child;
+ case GIMPLE_ASSIGN:
+ any |= scan_expr (gimple_assign_lhs (stmt), bb);
+ any |= scan_expr (gimple_assign_rhs1 (stmt), bb);
+ if (gimple_assign_rhs2 (stmt))
+ any |= scan_expr (gimple_assign_rhs2 (stmt), bb);
+ else if (TREE_CODE (gimple_assign_rhs1 (stmt)) == CONSTRUCTOR)
+ {
+ walk_tree (gimple_assign_lhs_ptr (stmt),
+ set_base_unscalarizable, NULL, NULL);
+ any = false;
+ }
+ break;
- slot = (struct sra_elt **) htab_find_slot (sra_map, &dummy, insert);
- if (!slot && insert == NO_INSERT)
- return NULL;
+ case GIMPLE_CALL:
+ if (stmt_can_throw_internal (stmt) /* libstdc++ */
+ || stmt_ends_bb_p (stmt) /* ada */ )
+ {
+ walk_gimple_op (stmt, set_base_unscalarizable, NULL);
+ }
+ else
+ {
+ if (gimple_call_lhs (stmt))
+ any |= scan_expr (gimple_call_lhs (stmt), bb);
- elt = *slot;
- if (!elt && insert == INSERT)
- {
- *slot = elt = XOBNEW (&sra_obstack, struct sra_elt);
- memset (elt, 0, sizeof (*elt));
+ for (i = 0; i < gimple_call_num_args (stmt); i++)
+ any |= scan_expr (gimple_call_arg (stmt, i), bb);
+ }
+ break;
- elt->parent = parent;
- elt->element = child;
- elt->type = type;
- elt->is_scalar = is_sra_scalar_type (type);
+#if 0
+ case GIMPLE_ASM:
+ for (i = 0; i < gimple_asm_ninputs (stmt); i++)
+ any |= scan_expr (TREE_VALUE (gimple_asm_input_op (stmt, i)),
+ bb);
+ for (i = 0; i < gimple_asm_noutputs (stmt); i++)
+ any |= scan_expr (TREE_VALUE (gimple_asm_output_op (stmt, i)),
+ bb);
+#endif
- if (parent)
- {
- if (IS_ELEMENT_FOR_GROUP (elt->element))
- {
- elt->is_group = true;
- elt->sibling = parent->groups;
- parent->groups = elt;
+ default:
+ walk_gimple_op (stmt, set_base_unscalarizable, NULL);
+ break;
}
- else
+
+ if (any)
{
- elt->sibling = parent->children;
- parent->children = elt;
+ decomposed_gsi dgsi;
+ dgsi.gsi = gsi;
+ VEC_safe_push (decomposed_gsi, heap, decomposed_gsis, &dgsi);
}
}
-
- /* If this is a parameter, then if we want to scalarize, we have
- one copy from the true function parameter. Count it now. */
- if (TREE_CODE (child) == PARM_DECL)
- {
- elt->n_copies = 1;
- bitmap_set_bit (needs_copy_in, DECL_UID (child));
- }
}
- return elt;
+ return !VEC_empty (decomposed_gsi, decomposed_gsis);
}
-/* Create or return the SRA_ELT structure for EXPR if the expression
- refers to a scalarizable variable. */
-static struct sra_elt *
-maybe_lookup_element_for_expr (tree expr)
+/* Helper of QSORT function. There are _pointers_ to accesses in the array. */
+
+static int
+fld_cmp (const void *a, const void *b)
{
- struct sra_elt *elt;
- tree child;
+ const access_p *fp1 = (const access_p *) a;
+ const access_p *fp2 = (const access_p *) b;
+ const access_p f1 = *fp1;
+ const access_p f2 = *fp2;
- switch (TREE_CODE (expr))
- {
- case VAR_DECL:
- case PARM_DECL:
- case RESULT_DECL:
- if (is_sra_candidate_decl (expr))
- return lookup_element (NULL, expr, TREE_TYPE (expr), INSERT);
- return NULL;
+ if ((int) f1->offset != (int) f2->offset)
+ return (int) f1->offset - (int) f2->offset;
+ return (int) f1->size - (int) f2->size;
+}
- case ARRAY_REF:
- /* We can't scalarize variable array indices. */
- if (in_array_bounds_p (expr))
- child = TREE_OPERAND (expr, 1);
- else
- return NULL;
- break;
- case ARRAY_RANGE_REF:
- /* We can't scalarize variable array indices. */
- if (range_in_array_bounds_p (expr))
- {
- tree domain = TYPE_DOMAIN (TREE_TYPE (expr));
- child = build2 (RANGE_EXPR, integer_type_node,
- TYPE_MIN_VALUE (domain), TYPE_MAX_VALUE (domain));
- }
- else
- return NULL;
- break;
+/* Offer keeps accesses that are going be replaced by one variable. */
- case COMPONENT_REF:
- {
- tree type = TREE_TYPE (TREE_OPERAND (expr, 0));
- /* Don't look through unions. */
- if (TREE_CODE (type) != RECORD_TYPE)
- return NULL;
- /* Neither through variable-sized records. */
- if (TYPE_SIZE (type) == NULL_TREE
- || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
- return NULL;
- child = TREE_OPERAND (expr, 1);
- }
- break;
+struct offer
+{
+ /* Base address + offset. */
+ HOST_WIDE_INT begin;
- case REALPART_EXPR:
- child = integer_zero_node;
- break;
- case IMAGPART_EXPR:
- child = integer_one_node;
- break;
+ /* Base address + offset + size. */
+ HOST_WIDE_INT end;
- default:
- return NULL;
- }
+ /* Does any access has MAYBE_HOT == true. */
+ bool have_hot_bb;
+
+ /* Offers keeps accesess from FROM to TO numbers
+ (number is an index in a _sorted_ access's vector). */
+ int from, to;
- elt = maybe_lookup_element_for_expr (TREE_OPERAND (expr, 0));
- if (elt)
- return lookup_element (elt, child, TREE_TYPE (expr), INSERT);
- return NULL;
-}
-
-\f
-/* Functions to walk just enough of the tree to see all scalarizable
- references, and categorize them. */
-
-/* A set of callbacks for phases 2 and 4. They'll be invoked for the
- various kinds of references seen. In all cases, *GSI is an iterator
- pointing to the statement being processed. */
-struct sra_walk_fns
-{
- /* Invoked when ELT is required as a unit. Note that ELT might refer to
- a leaf node, in which case this is a simple scalar reference. *EXPR_P
- points to the location of the expression. IS_OUTPUT is true if this
- is a left-hand-side reference. USE_ALL is true if we saw something we
- couldn't quite identify and had to force the use of the entire object. */
- void (*use) (struct sra_elt *elt, tree *expr_p,
- gimple_stmt_iterator *gsi, bool is_output, bool use_all);
-
- /* Invoked when we have a copy between two scalarizable references. */
- void (*copy) (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
- gimple_stmt_iterator *gsi);
-
- /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
- in which case it should be treated as an empty CONSTRUCTOR. */
- void (*init) (struct sra_elt *elt, tree value, gimple_stmt_iterator *gsi);
-
- /* Invoked when we have a copy between one scalarizable reference ELT
- and one non-scalarizable reference OTHER without side-effects.
- IS_OUTPUT is true if ELT is on the left-hand side. */
- void (*ldst) (struct sra_elt *elt, tree other,
- gimple_stmt_iterator *gsi, bool is_output);
-
- /* True during phase 2, false during phase 4. */
- /* ??? This is a hack. */
- bool initial_scan;
+ /* Sometimes we would like to omit some accesess, not used yet. */
+ bitmap without;
};
-#ifdef ENABLE_CHECKING
-/* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
+
+/* Return a proper type for accesses from OFFER. NOTE: It's good idea to choose
+ ARRAY_REF accesses. Look at `check_blk_accesses' function. */
static tree
-sra_find_candidate_decl (tree *tp, int *walk_subtrees,
- void *data ATTRIBUTE_UNUSED)
+find_proper_type (struct offer *offer, access_p *accesses)
{
- tree t = *tp;
- enum tree_code code = TREE_CODE (t);
+ access_p access;
+ int i;
- if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
+ for (i = offer->from; i <= offer->to; i++)
{
- *walk_subtrees = 0;
- if (is_sra_candidate_decl (t))
- return t;
+ access = accesses[i];
+
+ if (access->index)
+ break;
}
- else if (TYPE_P (t))
- *walk_subtrees = 0;
- return NULL;
+ return TREE_TYPE (access->expr);
}
-#endif
-/* Walk most expressions looking for a scalarizable aggregate.
- If we find one, invoke FNS->USE. */
-static void
-sra_walk_expr (tree *expr_p, gimple_stmt_iterator *gsi, bool is_output,
- const struct sra_walk_fns *fns)
+/* Build and return the replacement for accesses from the OFFER. */
+
+static tree
+build_replacement (struct offer *offer, access_p *accesses)
{
- tree expr = *expr_p;
- tree inner = expr;
- bool disable_scalarization = false;
- bool use_all_p = false;
-
- /* We're looking to collect a reference expression between EXPR and INNER,
- such that INNER is a scalarizable decl and all other nodes through EXPR
- are references that we can scalarize. If we come across something that
- we can't scalarize, we reset EXPR. This has the effect of making it
- appear that we're referring to the larger expression as a whole. */
-
- while (1)
- switch (TREE_CODE (inner))
- {
- case VAR_DECL:
- case PARM_DECL:
- case RESULT_DECL:
- /* If there is a scalarizable decl at the bottom, then process it. */
- if (is_sra_candidate_decl (inner))
- {
- struct sra_elt *elt = maybe_lookup_element_for_expr (expr);
- if (disable_scalarization)
- elt->cannot_scalarize = true;
- else
- fns->use (elt, expr_p, gsi, is_output, use_all_p);
- }
- return;
-
- case ARRAY_REF:
- /* Non-constant index means any member may be accessed. Prevent the
- expression from being scalarized. If we were to treat this as a
- reference to the whole array, we can wind up with a single dynamic
- index reference inside a loop being overridden by several constant
- index references during loop setup. It's possible that this could
- be avoided by using dynamic usage counts based on BB trip counts
- (based on loop analysis or profiling), but that hardly seems worth
- the effort. */
- /* ??? Hack. Figure out how to push this into the scan routines
- without duplicating too much code. */
- if (!in_array_bounds_p (inner))
- {
- disable_scalarization = true;
- goto use_all;
- }
- /* ??? Are we assured that non-constant bounds and stride will have
- the same value everywhere? I don't think Fortran will... */
- if (TREE_OPERAND (inner, 2) || TREE_OPERAND (inner, 3))
- goto use_all;
- inner = TREE_OPERAND (inner, 0);
- break;
+ tree proper_type, repl;
+ /* tree base; */
+ int i;
- case ARRAY_RANGE_REF:
- if (!range_in_array_bounds_p (inner))
- {
- disable_scalarization = true;
- goto use_all;
- }
- /* ??? See above non-constant bounds and stride . */
- if (TREE_OPERAND (inner, 2) || TREE_OPERAND (inner, 3))
- goto use_all;
- inner = TREE_OPERAND (inner, 0);
- break;
+ proper_type = find_proper_type (offer, accesses);
+ gcc_assert (proper_type);
- case COMPONENT_REF:
- {
- tree type = TREE_TYPE (TREE_OPERAND (inner, 0));
- /* Don't look through unions. */
- if (TREE_CODE (type) != RECORD_TYPE)
- goto use_all;
- /* Neither through variable-sized records. */
- if (TYPE_SIZE (type) == NULL_TREE
- || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
- goto use_all;
- inner = TREE_OPERAND (inner, 0);
- }
- break;
+ repl = make_rename_temp (proper_type, "sra");
- case REALPART_EXPR:
- case IMAGPART_EXPR:
- inner = TREE_OPERAND (inner, 0);
- break;
+ for (i = offer->from; i <= offer->to; i++)
+ {
+ accesses[i]->replacement = repl;
+ accesses[i]->non_blk = (TYPE_MODE (proper_type) != BLKmode);
+ }
- case BIT_FIELD_REF:
- /* A bit field reference to a specific vector is scalarized but for
- ones for inputs need to be marked as used on the left hand size so
- when we scalarize it, we can mark that variable as non renamable. */
- if (is_output
- && TREE_CODE (TREE_TYPE (TREE_OPERAND (inner, 0))) == VECTOR_TYPE)
- {
- struct sra_elt *elt
- = maybe_lookup_element_for_expr (TREE_OPERAND (inner, 0));
- if (elt)
- elt->is_vector_lhs = true;
- }
-
- /* A bit field reference (access to *multiple* fields simultaneously)
- is not currently scalarized. Consider this an access to the full
- outer element, to which walk_tree will bring us next. */
- goto use_all;
-
- CASE_CONVERT:
- /* Similarly, a nop explicitly wants to look at an object in a
- type other than the one we've scalarized. */
- goto use_all;
-
- case VIEW_CONVERT_EXPR:
- /* Likewise for a view conversion, but with an additional twist:
- it can be on the LHS and, in this case, an access to the full
- outer element would mean a killing def. So we need to punt
- if we haven't already a full access to the current element,
- because we cannot pretend to have a killing def if we only
- have a partial access at some level. */
- if (is_output && !use_all_p && inner != expr)
- disable_scalarization = true;
- goto use_all;
-
- case WITH_SIZE_EXPR:
- /* This is a transparent wrapper. The entire inner expression really
- is being used. */
- goto use_all;
-
- use_all:
- expr_p = &TREE_OPERAND (inner, 0);
- inner = expr = *expr_p;
- use_all_p = true;
- break;
+ /* It works, it's just easier to work with oryginal names. */
+#if 0
+ base = accesses[offer->from]->base;
- default:
-#ifdef ENABLE_CHECKING
- /* Validate that we're not missing any references. */
- gcc_assert (!walk_tree (&inner, sra_find_candidate_decl, NULL, NULL));
-#endif
- return;
- }
-}
-
-/* Walk the arguments of a GIMPLE_CALL looking for scalarizable aggregates.
- If we find one, invoke FNS->USE. */
-
-static void
-sra_walk_gimple_call (gimple stmt, gimple_stmt_iterator *gsi,
- const struct sra_walk_fns *fns)
-{
- int i;
- int nargs = gimple_call_num_args (stmt);
-
- for (i = 0; i < nargs; i++)
- sra_walk_expr (gimple_call_arg_ptr (stmt, i), gsi, false, fns);
-
- if (gimple_call_lhs (stmt))
- sra_walk_expr (gimple_call_lhs_ptr (stmt), gsi, true, fns);
-}
-
-/* Walk the inputs and outputs of a GIMPLE_ASM looking for scalarizable
- aggregates. If we find one, invoke FNS->USE. */
-
-static void
-sra_walk_gimple_asm (gimple stmt, gimple_stmt_iterator *gsi,
- const struct sra_walk_fns *fns)
-{
- size_t i;
- for (i = 0; i < gimple_asm_ninputs (stmt); i++)
- sra_walk_expr (&TREE_VALUE (gimple_asm_input_op (stmt, i)), gsi, false, fns);
- for (i = 0; i < gimple_asm_noutputs (stmt); i++)
- sra_walk_expr (&TREE_VALUE (gimple_asm_output_op (stmt, i)), gsi, true, fns);
-}
-
-/* Walk a GIMPLE_ASSIGN and categorize the assignment appropriately. */
-
-static void
-sra_walk_gimple_assign (gimple stmt, gimple_stmt_iterator *gsi,
- const struct sra_walk_fns *fns)
-{
- struct sra_elt *lhs_elt = NULL, *rhs_elt = NULL;
- tree lhs, rhs;
-
- /* If there is more than 1 element on the RHS, only walk the lhs. */
- if (!gimple_assign_single_p (stmt))
- {
- sra_walk_expr (gimple_assign_lhs_ptr (stmt), gsi, true, fns);
- return;
- }
-
- lhs = gimple_assign_lhs (stmt);
- rhs = gimple_assign_rhs1 (stmt);
- lhs_elt = maybe_lookup_element_for_expr (lhs);
- rhs_elt = maybe_lookup_element_for_expr (rhs);
-
- /* If both sides are scalarizable, this is a COPY operation. */
- if (lhs_elt && rhs_elt)
- {
- fns->copy (lhs_elt, rhs_elt, gsi);
- return;
- }
-
- /* If the RHS is scalarizable, handle it. There are only two cases. */
- if (rhs_elt)
- {
- if (!rhs_elt->is_scalar && !TREE_SIDE_EFFECTS (lhs))
- fns->ldst (rhs_elt, lhs, gsi, false);
- else
- fns->use (rhs_elt, gimple_assign_rhs1_ptr (stmt), gsi, false, false);
- }
-
- /* If it isn't scalarizable, there may be scalarizable variables within, so
- check for a call or else walk the RHS to see if we need to do any
- copy-in operations. We need to do it before the LHS is scalarized so
- that the statements get inserted in the proper place, before any
- copy-out operations. */
- else
- sra_walk_expr (gimple_assign_rhs1_ptr (stmt), gsi, false, fns);
-
- /* Likewise, handle the LHS being scalarizable. We have cases similar
- to those above, but also want to handle RHS being constant. */
- if (lhs_elt)
- {
- /* If this is an assignment from a constant, or constructor, then
- we have access to all of the elements individually. Invoke INIT. */
- if (TREE_CODE (rhs) == COMPLEX_EXPR
- || TREE_CODE (rhs) == COMPLEX_CST
- || TREE_CODE (rhs) == CONSTRUCTOR)
- fns->init (lhs_elt, rhs, gsi);
-
- /* If this is an assignment from read-only memory, treat this as if
- we'd been passed the constructor directly. Invoke INIT. */
- else if (TREE_CODE (rhs) == VAR_DECL
- && TREE_STATIC (rhs)
- && TREE_READONLY (rhs)
- && targetm.binds_local_p (rhs))
- fns->init (lhs_elt, DECL_INITIAL (rhs), gsi);
-
- /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
- The lvalue requirement prevents us from trying to directly scalarize
- the result of a function call. Which would result in trying to call
- the function multiple times, and other evil things. */
- else if (!lhs_elt->is_scalar
- && !TREE_SIDE_EFFECTS (rhs) && is_gimple_addressable (rhs))
- fns->ldst (lhs_elt, rhs, gsi, true);
-
- /* Otherwise we're being used in some context that requires the
- aggregate to be seen as a whole. Invoke USE. */
- else
- fns->use (lhs_elt, gimple_assign_lhs_ptr (stmt), gsi, true, false);
- }
-
- /* Similarly to above, LHS_ELT being null only means that the LHS as a
- whole is not a scalarizable reference. There may be occurrences of
- scalarizable variables within, which implies a USE. */
- else
- sra_walk_expr (gimple_assign_lhs_ptr (stmt), gsi, true, fns);
-}
-
-/* Entry point to the walk functions. Search the entire function,
- invoking the callbacks in FNS on each of the references to
- scalarizable variables. */
-
-static void
-sra_walk_function (const struct sra_walk_fns *fns)
-{
- basic_block bb;
- gimple_stmt_iterator si, ni;
-
- /* ??? Phase 4 could derive some benefit to walking the function in
- dominator tree order. */
-
- FOR_EACH_BB (bb)
- for (si = gsi_start_bb (bb); !gsi_end_p (si); si = ni)
- {
- gimple stmt;
-
- stmt = gsi_stmt (si);
-
- ni = si;
- gsi_next (&ni);
-
- /* If the statement has no virtual operands, then it doesn't
- make any structure references that we care about. */
- if (gimple_aliases_computed_p (cfun)
- && ZERO_SSA_OPERANDS (stmt, (SSA_OP_VIRTUAL_DEFS | SSA_OP_VUSE)))
- continue;
-
- switch (gimple_code (stmt))
- {
- case GIMPLE_RETURN:
- /* If we have "return <retval>" then the return value is
- already exposed for our pleasure. Walk it as a USE to
- force all the components back in place for the return.
- */
- if (gimple_return_retval (stmt) == NULL_TREE)
- ;
- else
- sra_walk_expr (gimple_return_retval_ptr (stmt), &si, false,
- fns);
- break;
-
- case GIMPLE_ASSIGN:
- sra_walk_gimple_assign (stmt, &si, fns);
- break;
- case GIMPLE_CALL:
- sra_walk_gimple_call (stmt, &si, fns);
- break;
- case GIMPLE_ASM:
- sra_walk_gimple_asm (stmt, &si, fns);
- break;
-
- default:
- break;
- }
- }
-}
-\f
-/* Phase One: Scan all referenced variables in the program looking for
- structures that could be decomposed. */
-
-static bool
-find_candidates_for_sra (void)
-{
- bool any_set = false;
- tree var;
- referenced_var_iterator rvi;
-
- FOR_EACH_REFERENCED_VAR (var, rvi)
- {
- if (decl_can_be_decomposed_p (var))
- {
- bitmap_set_bit (sra_candidates, DECL_UID (var));
- any_set = true;
- }
- }
-
- return any_set;
-}
-
-\f
-/* Phase Two: Scan all references to scalarizable variables. Count the
- number of times they are used or copied respectively. */
-
-/* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
- considered a copy, because we can decompose the reference such that
- the sub-elements needn't be contiguous. */
-
-static void
-scan_use (struct sra_elt *elt, tree *expr_p ATTRIBUTE_UNUSED,
- gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
- bool is_output ATTRIBUTE_UNUSED, bool use_all ATTRIBUTE_UNUSED)
-{
- elt->n_uses += 1;
-}
-
-static void
-scan_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
- gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED)
-{
- lhs_elt->n_copies += 1;
- rhs_elt->n_copies += 1;
-}
-
-static void
-scan_init (struct sra_elt *lhs_elt, tree rhs ATTRIBUTE_UNUSED,
- gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED)
-{
- lhs_elt->n_copies += 1;
-}
-
-static void
-scan_ldst (struct sra_elt *elt, tree other ATTRIBUTE_UNUSED,
- gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
- bool is_output ATTRIBUTE_UNUSED)
-{
- elt->n_copies += 1;
-}
-
-/* Dump the values we collected during the scanning phase. */
-
-static void
-scan_dump (struct sra_elt *elt)
-{
- struct sra_elt *c;
-
- dump_sra_elt_name (dump_file, elt);
- fprintf (dump_file, ": n_uses=%u n_copies=%u\n", elt->n_uses, elt->n_copies);
-
- for (c = elt->children; c ; c = c->sibling)
- scan_dump (c);
-
- for (c = elt->groups; c ; c = c->sibling)
- scan_dump (c);
-}
-
-/* Entry point to phase 2. Scan the entire function, building up
- scalarization data structures, recording copies and uses. */
-
-static void
-scan_function (void)
-{
- static const struct sra_walk_fns fns = {
- scan_use, scan_copy, scan_init, scan_ldst, true
- };
- bitmap_iterator bi;
-
- sra_walk_function (&fns);
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- unsigned i;
-
- fputs ("\nScan results:\n", dump_file);
- EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
- {
- tree var = referenced_var (i);
- struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
- if (elt)
- scan_dump (elt);
- }
- fputc ('\n', dump_file);
- }
-}
-\f
-/* Phase Three: Make decisions about which variables to scalarize, if any.
- All elements to be scalarized have replacement variables made for them. */
-
-/* A subroutine of build_element_name. Recursively build the element
- name on the obstack. */
-
-static void
-build_element_name_1 (struct sra_elt *elt)
-{
- tree t;
- char buffer[32];
-
- if (elt->parent)
- {
- build_element_name_1 (elt->parent);
- obstack_1grow (&sra_obstack, '$');
-
- if (TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
- {
- if (elt->element == integer_zero_node)
- obstack_grow (&sra_obstack, "real", 4);
- else
- obstack_grow (&sra_obstack, "imag", 4);
- return;
- }
- }
-
- t = elt->element;
- if (TREE_CODE (t) == INTEGER_CST)
- {
- /* ??? Eh. Don't bother doing double-wide printing. */
- sprintf (buffer, HOST_WIDE_INT_PRINT_DEC, TREE_INT_CST_LOW (t));
- obstack_grow (&sra_obstack, buffer, strlen (buffer));
- }
- else if (TREE_CODE (t) == BIT_FIELD_REF)
- {
- sprintf (buffer, "B" HOST_WIDE_INT_PRINT_DEC,
- tree_low_cst (TREE_OPERAND (t, 2), 1));
- obstack_grow (&sra_obstack, buffer, strlen (buffer));
- sprintf (buffer, "F" HOST_WIDE_INT_PRINT_DEC,
- tree_low_cst (TREE_OPERAND (t, 1), 1));
- obstack_grow (&sra_obstack, buffer, strlen (buffer));
- }
- else
- {
- tree name = DECL_NAME (t);
- if (name)
- obstack_grow (&sra_obstack, IDENTIFIER_POINTER (name),
- IDENTIFIER_LENGTH (name));
- else
- {
- sprintf (buffer, "D%u", DECL_UID (t));
- obstack_grow (&sra_obstack, buffer, strlen (buffer));
- }
- }
-}
-
-/* Construct a pretty variable name for an element's replacement variable.
- The name is built on the obstack. */
-
-static char *
-build_element_name (struct sra_elt *elt)
-{
- build_element_name_1 (elt);
- obstack_1grow (&sra_obstack, '\0');
- return XOBFINISH (&sra_obstack, char *);
-}
-
-/* Instantiate an element as an independent variable. */
-
-static void
-instantiate_element (struct sra_elt *elt)
-{
- struct sra_elt *base_elt;
- tree var, base;
- bool nowarn = TREE_NO_WARNING (elt->element);
-
- for (base_elt = elt; base_elt->parent; base_elt = base_elt->parent)
- if (!nowarn)
- nowarn = TREE_NO_WARNING (base_elt->parent->element);
- base = base_elt->element;
-
- elt->replacement = var = make_rename_temp (elt->type, "SR");
-
- if (DECL_P (elt->element)
- && !tree_int_cst_equal (DECL_SIZE (var), DECL_SIZE (elt->element)))
- {
- DECL_SIZE (var) = DECL_SIZE (elt->element);
- DECL_SIZE_UNIT (var) = DECL_SIZE_UNIT (elt->element);
-
- elt->in_bitfld_block = 1;
- elt->replacement = fold_build3 (BIT_FIELD_REF, elt->type, var,
- DECL_SIZE (var),
- BYTES_BIG_ENDIAN
- ? size_binop (MINUS_EXPR,
- TYPE_SIZE (elt->type),
- DECL_SIZE (var))
- : bitsize_int (0));
- }
-
- /* For vectors, if used on the left hand side with BIT_FIELD_REF,
- they are not a gimple register. */
- if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE && elt->is_vector_lhs)
- DECL_GIMPLE_REG_P (var) = 0;
-
- DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (base);
- DECL_ARTIFICIAL (var) = 1;
-
- if (TREE_THIS_VOLATILE (elt->type))
- {
- TREE_THIS_VOLATILE (var) = 1;
- TREE_SIDE_EFFECTS (var) = 1;
- }
-
- if (DECL_NAME (base) && !DECL_IGNORED_P (base))
- {
- char *pretty_name = build_element_name (elt);
- DECL_NAME (var) = get_identifier (pretty_name);
- obstack_free (&sra_obstack, pretty_name);
-
- SET_DECL_DEBUG_EXPR (var, generate_element_ref (elt));
- DECL_DEBUG_EXPR_IS_FROM (var) = 1;
-
- DECL_IGNORED_P (var) = 0;
- TREE_NO_WARNING (var) = nowarn;
- }
- else
- {
- DECL_IGNORED_P (var) = 1;
- /* ??? We can't generate any warning that would be meaningful. */
- TREE_NO_WARNING (var) = 1;
- }
-
- /* Zero-initialize bit-field scalarization variables, to avoid
- triggering undefined behavior. */
- if (TREE_CODE (elt->element) == BIT_FIELD_REF
- || (var != elt->replacement
- && TREE_CODE (elt->replacement) == BIT_FIELD_REF))
- {
- gimple_seq init = sra_build_assignment (var,
- fold_convert (TREE_TYPE (var),
- integer_zero_node)
- );
- insert_edge_copies_seq (init, ENTRY_BLOCK_PTR);
- mark_all_v_defs_seq (init);
- }
-
- if (dump_file)
- {
- fputs (" ", dump_file);
- dump_sra_elt_name (dump_file, elt);
- fputs (" -> ", dump_file);
- print_generic_expr (dump_file, var, dump_flags);
- fputc ('\n', dump_file);
- }
-}
-
-/* Make one pass across an element tree deciding whether or not it's
- profitable to instantiate individual leaf scalars.
-
- PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
- fields all the way up the tree. */
-
-static void
-decide_instantiation_1 (struct sra_elt *elt, unsigned int parent_uses,
- unsigned int parent_copies)
-{
- if (dump_file && !elt->parent)
- {
- fputs ("Initial instantiation for ", dump_file);
- dump_sra_elt_name (dump_file, elt);
- fputc ('\n', dump_file);
- }
-
- if (elt->cannot_scalarize)
- return;
-
- if (elt->is_scalar)
- {
- /* The decision is simple: instantiate if we're used more frequently
- than the parent needs to be seen as a complete unit. */
- if (elt->n_uses + elt->n_copies + parent_copies > parent_uses)
- instantiate_element (elt);
- }
- else
- {
- struct sra_elt *c, *group;
- unsigned int this_uses = elt->n_uses + parent_uses;
- unsigned int this_copies = elt->n_copies + parent_copies;
-
- /* Consider groups of sub-elements as weighing in favour of
- instantiation whatever their size. */
- for (group = elt->groups; group ; group = group->sibling)
- FOR_EACH_ACTUAL_CHILD (c, group)
- {
- c->n_uses += group->n_uses;
- c->n_copies += group->n_copies;
- }
-
- for (c = elt->children; c ; c = c->sibling)
- decide_instantiation_1 (c, this_uses, this_copies);
- }
-}
-
-/* Compute the size and number of all instantiated elements below ELT.
- We will only care about this if the size of the complete structure
- fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
-
-static unsigned int
-sum_instantiated_sizes (struct sra_elt *elt, unsigned HOST_WIDE_INT *sizep)
-{
- if (elt->replacement)
- {
- *sizep += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt->type));
- return 1;
- }
- else
- {
- struct sra_elt *c;
- unsigned int count = 0;
-
- for (c = elt->children; c ; c = c->sibling)
- count += sum_instantiated_sizes (c, sizep);
-
- return count;
- }
-}
-
-/* Instantiate fields in ELT->TYPE that are not currently present as
- children of ELT. */
-
-static void instantiate_missing_elements (struct sra_elt *elt);
-
-static struct sra_elt *
-instantiate_missing_elements_1 (struct sra_elt *elt, tree child, tree type)
-{
- struct sra_elt *sub = lookup_element (elt, child, type, INSERT);
- if (sub->is_scalar)
- {
- if (sub->replacement == NULL)
- instantiate_element (sub);
- }
- else
- instantiate_missing_elements (sub);
- return sub;
-}
-
-/* Obtain the canonical type for field F of ELEMENT. */
-
-static tree
-canon_type_for_field (tree f, tree element)
-{
- tree field_type = TREE_TYPE (f);
-
- /* canonicalize_component_ref() unwidens some bit-field types (not
- marked as DECL_BIT_FIELD in C++), so we must do the same, lest we
- may introduce type mismatches. */
- if (INTEGRAL_TYPE_P (field_type)
- && DECL_MODE (f) != TYPE_MODE (field_type))
- field_type = TREE_TYPE (get_unwidened (build3 (COMPONENT_REF,
- field_type,
- element,
- f, NULL_TREE),
- NULL_TREE));
-
- return field_type;
-}
-
-/* Look for adjacent fields of ELT starting at F that we'd like to
- scalarize as a single variable. Return the last field of the
- group. */
-
-static tree
-try_instantiate_multiple_fields (struct sra_elt *elt, tree f)
-{
- int count;
- unsigned HOST_WIDE_INT align, bit, size, alchk;
- enum machine_mode mode;
- tree first = f, prev;
- tree type, var;
- struct sra_elt *block;
-
- /* Point fields are typically best handled as standalone entities. */
- if (POINTER_TYPE_P (TREE_TYPE (f)))
- return f;
-
- if (!is_sra_scalar_type (TREE_TYPE (f))
- || !host_integerp (DECL_FIELD_OFFSET (f), 1)
- || !host_integerp (DECL_FIELD_BIT_OFFSET (f), 1)
- || !host_integerp (DECL_SIZE (f), 1)
- || lookup_element (elt, f, NULL, NO_INSERT))
- return f;
-
- block = elt;
-
- /* For complex and array objects, there are going to be integer
- literals as child elements. In this case, we can't just take the
- alignment and mode of the decl, so we instead rely on the element
- type.
-
- ??? We could try to infer additional alignment from the full
- object declaration and the location of the sub-elements we're
- accessing. */
- for (count = 0; !DECL_P (block->element); count++)
- block = block->parent;
-
- align = DECL_ALIGN (block->element);
- alchk = GET_MODE_BITSIZE (DECL_MODE (block->element));
-
- if (count)
- {
- type = TREE_TYPE (block->element);
- while (count--)
- type = TREE_TYPE (type);
-
- align = TYPE_ALIGN (type);
- alchk = GET_MODE_BITSIZE (TYPE_MODE (type));
- }
-
- if (align < alchk)
- align = alchk;
-
- /* Coalescing wider fields is probably pointless and
- inefficient. */
- if (align > BITS_PER_WORD)
- align = BITS_PER_WORD;
-
- bit = tree_low_cst (DECL_FIELD_OFFSET (f), 1) * BITS_PER_UNIT
- + tree_low_cst (DECL_FIELD_BIT_OFFSET (f), 1);
- size = tree_low_cst (DECL_SIZE (f), 1);
-
- alchk = align - 1;
- alchk = ~alchk;
-
- if ((bit & alchk) != ((bit + size - 1) & alchk))
- return f;
-
- /* Find adjacent fields in the same alignment word. */
-
- for (prev = f, f = TREE_CHAIN (f);
- f && TREE_CODE (f) == FIELD_DECL
- && is_sra_scalar_type (TREE_TYPE (f))
- && host_integerp (DECL_FIELD_OFFSET (f), 1)
- && host_integerp (DECL_FIELD_BIT_OFFSET (f), 1)
- && host_integerp (DECL_SIZE (f), 1)
- && !lookup_element (elt, f, NULL, NO_INSERT);
- prev = f, f = TREE_CHAIN (f))
- {
- unsigned HOST_WIDE_INT nbit, nsize;
-
- nbit = tree_low_cst (DECL_FIELD_OFFSET (f), 1) * BITS_PER_UNIT
- + tree_low_cst (DECL_FIELD_BIT_OFFSET (f), 1);
- nsize = tree_low_cst (DECL_SIZE (f), 1);
-
- if (bit + size == nbit)
- {
- if ((bit & alchk) != ((nbit + nsize - 1) & alchk))
- {
- /* If we're at an alignment boundary, don't bother
- growing alignment such that we can include this next
- field. */
- if ((nbit & alchk)
- || GET_MODE_BITSIZE (DECL_MODE (f)) <= align)
- break;
-
- align = GET_MODE_BITSIZE (DECL_MODE (f));
- alchk = align - 1;
- alchk = ~alchk;
-
- if ((bit & alchk) != ((nbit + nsize - 1) & alchk))
- break;
- }
- size += nsize;
- }
- else if (nbit + nsize == bit)
- {
- if ((nbit & alchk) != ((bit + size - 1) & alchk))
- {
- if ((bit & alchk)
- || GET_MODE_BITSIZE (DECL_MODE (f)) <= align)
- break;
-
- align = GET_MODE_BITSIZE (DECL_MODE (f));
- alchk = align - 1;
- alchk = ~alchk;
-
- if ((nbit & alchk) != ((bit + size - 1) & alchk))
- break;
- }
- bit = nbit;
- size += nsize;
- }
- else
- break;
- }
-
- f = prev;
-
- if (f == first)
- return f;
-
- gcc_assert ((bit & alchk) == ((bit + size - 1) & alchk));
-
- /* Try to widen the bit range so as to cover padding bits as well. */
-
- if ((bit & ~alchk) || size != align)
- {
- unsigned HOST_WIDE_INT mbit = bit & alchk;
- unsigned HOST_WIDE_INT msize = align;
-
- for (f = TYPE_FIELDS (elt->type);
- f; f = TREE_CHAIN (f))
- {
- unsigned HOST_WIDE_INT fbit, fsize;
-
- /* Skip the fields from first to prev. */
- if (f == first)
- {
- f = prev;
- continue;
- }
-
- if (!(TREE_CODE (f) == FIELD_DECL
- && host_integerp (DECL_FIELD_OFFSET (f), 1)
- && host_integerp (DECL_FIELD_BIT_OFFSET (f), 1)))
- continue;
-
- fbit = tree_low_cst (DECL_FIELD_OFFSET (f), 1) * BITS_PER_UNIT
- + tree_low_cst (DECL_FIELD_BIT_OFFSET (f), 1);
-
- /* If we're past the selected word, we're fine. */
- if ((bit & alchk) < (fbit & alchk))
- continue;
-
- if (host_integerp (DECL_SIZE (f), 1))
- fsize = tree_low_cst (DECL_SIZE (f), 1);
- else
- /* Assume a variable-sized field takes up all space till
- the end of the word. ??? Endianness issues? */
- fsize = align - (fbit & alchk);
-
- if ((fbit & alchk) < (bit & alchk))
- {
- /* A large field might start at a previous word and
- extend into the selected word. Exclude those
- bits. ??? Endianness issues? */
- HOST_WIDE_INT diff = fbit + fsize - mbit;
-
- if (diff <= 0)
- continue;
-
- mbit += diff;
- msize -= diff;
- }
- else
- {
- /* Non-overlapping, great. */
- if (fbit + fsize <= mbit
- || mbit + msize <= fbit)
- continue;
-
- if (fbit <= mbit)
- {
- unsigned HOST_WIDE_INT diff = fbit + fsize - mbit;
- mbit += diff;
- msize -= diff;
- }
- else if (fbit > mbit)
- msize -= (mbit + msize - fbit);
- else
- gcc_unreachable ();
- }
- }
-
- bit = mbit;
- size = msize;
- }
-
- /* Now we know the bit range we're interested in. Find the smallest
- machine mode we can use to access it. */
-
- for (mode = smallest_mode_for_size (size, MODE_INT);
- ;
- mode = GET_MODE_WIDER_MODE (mode))
- {
- gcc_assert (mode != VOIDmode);
-
- alchk = GET_MODE_PRECISION (mode) - 1;
- alchk = ~alchk;
-
- if ((bit & alchk) == ((bit + size - 1) & alchk))
- break;
- }
-
- gcc_assert (~alchk < align);
-
- /* Create the field group as a single variable. */
-
- /* We used to create a type for the mode above, but size turns
- to be out not of mode-size. As we need a matching type
- to build a BIT_FIELD_REF, use a nonstandard integer type as
- fallback. */
- type = lang_hooks.types.type_for_size (size, 1);
- if (!type || TYPE_PRECISION (type) != size)
- type = build_nonstandard_integer_type (size, 1);
- gcc_assert (type);
- var = build3 (BIT_FIELD_REF, type, NULL_TREE,
- bitsize_int (size), bitsize_int (bit));
-
- block = instantiate_missing_elements_1 (elt, var, type);
- gcc_assert (block && block->is_scalar);
-
- var = block->replacement;
-
- if ((bit & ~alchk)
- || (HOST_WIDE_INT)size != tree_low_cst (DECL_SIZE (var), 1))
- {
- block->replacement = fold_build3 (BIT_FIELD_REF,
- TREE_TYPE (block->element), var,
- bitsize_int (size),
- bitsize_int (bit & ~alchk));
- }
-
- block->in_bitfld_block = 2;
-
- /* Add the member fields to the group, such that they access
- portions of the group variable. */
-
- for (f = first; f != TREE_CHAIN (prev); f = TREE_CHAIN (f))
- {
- tree field_type = canon_type_for_field (f, elt->element);
- struct sra_elt *fld = lookup_element (block, f, field_type, INSERT);
-
- gcc_assert (fld && fld->is_scalar && !fld->replacement);
-
- fld->replacement = fold_build3 (BIT_FIELD_REF, field_type, var,
- DECL_SIZE (f),
- bitsize_int
- ((TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f))
- * BITS_PER_UNIT
- + (TREE_INT_CST_LOW
- (DECL_FIELD_BIT_OFFSET (f))))
- & ~alchk));
- fld->in_bitfld_block = 1;
- }
-
- return prev;
-}
-
-static void
-instantiate_missing_elements (struct sra_elt *elt)
-{
- tree type = elt->type;
-
- switch (TREE_CODE (type))
- {
- case RECORD_TYPE:
- {
- tree f;
- for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
- if (TREE_CODE (f) == FIELD_DECL)
- {
- tree last = try_instantiate_multiple_fields (elt, f);
-
- if (last != f)
- {
- f = last;
- continue;
- }
-
- instantiate_missing_elements_1 (elt, f,
- canon_type_for_field
- (f, elt->element));
- }
- break;
- }
-
- case ARRAY_TYPE:
- {
- tree i, max, subtype;
-
- i = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
- max = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
- subtype = TREE_TYPE (type);
-
- while (1)
- {
- instantiate_missing_elements_1 (elt, i, subtype);
- if (tree_int_cst_equal (i, max))
- break;
- i = int_const_binop (PLUS_EXPR, i, integer_one_node, true);
- }
-
- break;
- }
-
- case COMPLEX_TYPE:
- type = TREE_TYPE (type);
- instantiate_missing_elements_1 (elt, integer_zero_node, type);
- instantiate_missing_elements_1 (elt, integer_one_node, type);
- break;
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Return true if there is only one non aggregate field in the record, TYPE.
- Return false otherwise. */
-
-static bool
-single_scalar_field_in_record_p (tree type)
-{
- int num_fields = 0;
- tree field;
- if (TREE_CODE (type) != RECORD_TYPE)
- return false;
-
- for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
- if (TREE_CODE (field) == FIELD_DECL)
- {
- num_fields++;
-
- if (num_fields == 2)
- return false;
-
- if (AGGREGATE_TYPE_P (TREE_TYPE (field)))
- return false;
- }
-
- return true;
-}
-
-/* Make one pass across an element tree deciding whether to perform block
- or element copies. If we decide on element copies, instantiate all
- elements. Return true if there are any instantiated sub-elements. */
-
-static bool
-decide_block_copy (struct sra_elt *elt)
-{
- struct sra_elt *c;
- bool any_inst;
-
- /* We shouldn't be invoked on groups of sub-elements as they must
- behave like their parent as far as block copy is concerned. */
- gcc_assert (!elt->is_group);
-
- /* If scalarization is disabled, respect it. */
- if (elt->cannot_scalarize)
- {
- elt->use_block_copy = 1;
-
- if (dump_file)
- {
- fputs ("Scalarization disabled for ", dump_file);
- dump_sra_elt_name (dump_file, elt);
- fputc ('\n', dump_file);
- }
-
- /* Disable scalarization of sub-elements */
- for (c = elt->children; c; c = c->sibling)
- {
- c->cannot_scalarize = 1;
- decide_block_copy (c);
- }
-
- /* Groups behave like their parent. */
- for (c = elt->groups; c; c = c->sibling)
- {
- c->cannot_scalarize = 1;
- c->use_block_copy = 1;
- }
-
- return false;
- }
-
- /* Don't decide if we've no uses and no groups. */
- if (elt->n_uses == 0 && elt->n_copies == 0 && elt->groups == NULL)
- ;
-
- else if (!elt->is_scalar)
- {
- tree size_tree = TYPE_SIZE_UNIT (elt->type);
- bool use_block_copy = true;
-
- /* Tradeoffs for COMPLEX types pretty much always make it better
- to go ahead and split the components. */
- if (TREE_CODE (elt->type) == COMPLEX_TYPE)
- use_block_copy = false;
-
- /* Don't bother trying to figure out the rest if the structure is
- so large we can't do easy arithmetic. This also forces block
- copies for variable sized structures. */
- else if (host_integerp (size_tree, 1))
- {
- unsigned HOST_WIDE_INT full_size, inst_size = 0;
- unsigned int max_size, max_count, inst_count, full_count;
-
- /* If the sra-max-structure-size parameter is 0, then the
- user has not overridden the parameter and we can choose a
- sensible default. */
- max_size = SRA_MAX_STRUCTURE_SIZE
- ? SRA_MAX_STRUCTURE_SIZE
- : MOVE_RATIO * UNITS_PER_WORD;
- max_count = SRA_MAX_STRUCTURE_COUNT
- ? SRA_MAX_STRUCTURE_COUNT
- : MOVE_RATIO;
-
- full_size = tree_low_cst (size_tree, 1);
- full_count = count_type_elements (elt->type, false);
- inst_count = sum_instantiated_sizes (elt, &inst_size);
-
- /* If there is only one scalar field in the record, don't block copy. */
- if (single_scalar_field_in_record_p (elt->type))
- use_block_copy = false;
-
- /* ??? What to do here. If there are two fields, and we've only
- instantiated one, then instantiating the other is clearly a win.
- If there are a large number of fields then the size of the copy
- is much more of a factor. */
-
- /* If the structure is small, and we've made copies, go ahead
- and instantiate, hoping that the copies will go away. */
- if (full_size <= max_size
- && (full_count - inst_count) <= max_count
- && elt->n_copies > elt->n_uses)
- use_block_copy = false;
- else if (inst_count * 100 >= full_count * SRA_FIELD_STRUCTURE_RATIO
- && inst_size * 100 >= full_size * SRA_FIELD_STRUCTURE_RATIO)
- use_block_copy = false;
-
- /* In order to avoid block copy, we have to be able to instantiate
- all elements of the type. See if this is possible. */
- if (!use_block_copy
- && (!can_completely_scalarize_p (elt)
- || !type_can_instantiate_all_elements (elt->type)))
- use_block_copy = true;
- }
-
- elt->use_block_copy = use_block_copy;
-
- /* Groups behave like their parent. */
- for (c = elt->groups; c; c = c->sibling)
- c->use_block_copy = use_block_copy;
-
- if (dump_file)
- {
- fprintf (dump_file, "Using %s for ",
- use_block_copy ? "block-copy" : "element-copy");
- dump_sra_elt_name (dump_file, elt);
- fputc ('\n', dump_file);
- }
-
- if (!use_block_copy)
- {
- instantiate_missing_elements (elt);
- return true;
- }
- }
-
- any_inst = elt->replacement != NULL;
-
- for (c = elt->children; c ; c = c->sibling)
- any_inst |= decide_block_copy (c);
-
- return any_inst;
-}
-
-/* Entry point to phase 3. Instantiate scalar replacement variables. */
-
-static void
-decide_instantiations (void)
-{
- unsigned int i;
- bool cleared_any;
- bitmap_head done_head;
- bitmap_iterator bi;
-
- /* We cannot clear bits from a bitmap we're iterating over,
- so save up all the bits to clear until the end. */
- bitmap_initialize (&done_head, &bitmap_default_obstack);
- cleared_any = false;
-
- EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
- {
- tree var = referenced_var (i);
- struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
- if (elt)
- {
- decide_instantiation_1 (elt, 0, 0);
- if (!decide_block_copy (elt))
- elt = NULL;
- }
- if (!elt)
- {
- bitmap_set_bit (&done_head, i);
- cleared_any = true;
- }
- }
-
- if (cleared_any)
- {
- bitmap_and_compl_into (sra_candidates, &done_head);
- bitmap_and_compl_into (needs_copy_in, &done_head);
- }
- bitmap_clear (&done_head);
-
- mark_set_for_renaming (sra_candidates);
-
- if (dump_file)
- fputc ('\n', dump_file);
-}
-
-\f
-/* Phase Four: Update the function to match the replacements created. */
-
-/* Mark all the variables in VDEF/VUSE operators for STMT for
- renaming. This becomes necessary when we modify all of a
- non-scalar. */
-
-static void
-mark_all_v_defs_stmt (gimple stmt)
-{
- tree sym;
- ssa_op_iter iter;
-
- update_stmt_if_modified (stmt);
-
- FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
- {
- if (TREE_CODE (sym) == SSA_NAME)
- sym = SSA_NAME_VAR (sym);
- mark_sym_for_renaming (sym);
- }
-}
-
-
-/* Mark all the variables in virtual operands in all the statements in
- LIST for renaming. */
-
-static void
-mark_all_v_defs_seq (gimple_seq seq)
-{
- gimple_stmt_iterator gsi;
-
- for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
- mark_all_v_defs_stmt (gsi_stmt (gsi));
-}
-
-/* Mark every replacement under ELT with TREE_NO_WARNING. */
-
-static void
-mark_no_warning (struct sra_elt *elt)
-{
- if (!elt->all_no_warning)
- {
- if (elt->replacement)
- TREE_NO_WARNING (elt->replacement) = 1;
- else
- {
- struct sra_elt *c;
- FOR_EACH_ACTUAL_CHILD (c, elt)
- mark_no_warning (c);
- }
- elt->all_no_warning = true;
- }
-}
-
-/* Build a single level component reference to ELT rooted at BASE. */
-
-static tree
-generate_one_element_ref (struct sra_elt *elt, tree base)
-{
- switch (TREE_CODE (TREE_TYPE (base)))
- {
- case RECORD_TYPE:
- {
- tree field = elt->element;
-
- /* We can't test elt->in_bitfld_block here because, when this is
- called from instantiate_element, we haven't set this field
- yet. */
- if (TREE_CODE (field) == BIT_FIELD_REF)
- {
- tree ret = unshare_expr (field);
- TREE_OPERAND (ret, 0) = base;
- return ret;
- }
-
- /* Watch out for compatible records with differing field lists. */
- if (DECL_FIELD_CONTEXT (field) != TYPE_MAIN_VARIANT (TREE_TYPE (base)))
- field = find_compatible_field (TREE_TYPE (base), field);
-
- return build3 (COMPONENT_REF, elt->type, base, field, NULL);
- }
-
- case ARRAY_TYPE:
- if (TREE_CODE (elt->element) == RANGE_EXPR)
- return build4 (ARRAY_RANGE_REF, elt->type, base,
- TREE_OPERAND (elt->element, 0), NULL, NULL);
- else
- return build4 (ARRAY_REF, elt->type, base, elt->element, NULL, NULL);
-
- case COMPLEX_TYPE:
- if (elt->element == integer_zero_node)
- return build1 (REALPART_EXPR, elt->type, base);
- else
- return build1 (IMAGPART_EXPR, elt->type, base);
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Build a full component reference to ELT rooted at its native variable. */
-
-static tree
-generate_element_ref (struct sra_elt *elt)
-{
- if (elt->parent)
- return generate_one_element_ref (elt, generate_element_ref (elt->parent));
- else
- return elt->element;
-}
-
-/* Return true if BF is a bit-field that we can handle like a scalar. */
-
-static bool
-scalar_bitfield_p (tree bf)
-{
- return (TREE_CODE (bf) == BIT_FIELD_REF
- && (is_gimple_reg (TREE_OPERAND (bf, 0))
- || (TYPE_MODE (TREE_TYPE (TREE_OPERAND (bf, 0))) != BLKmode
- && (!TREE_SIDE_EFFECTS (TREE_OPERAND (bf, 0))
- || (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE
- (TREE_OPERAND (bf, 0))))
- <= BITS_PER_WORD)))));
-}
-
-/* Create an assignment statement from SRC to DST. */
-
-static gimple_seq
-sra_build_assignment (tree dst, tree src)
-{
- gimple stmt;
- gimple_seq seq = NULL;
- /* Turning BIT_FIELD_REFs into bit operations enables other passes
- to do a much better job at optimizing the code.
- From dst = BIT_FIELD_REF <var, sz, off> we produce
-
- SR.1 = (scalar type) var;
- SR.2 = SR.1 >> off;
- SR.3 = SR.2 & ((1 << sz) - 1);
- ... possible sign extension of SR.3 ...
- dst = (destination type) SR.3;
- */
- if (scalar_bitfield_p (src))
- {
- tree var, shift, width;
- tree utype, stype, stmp, utmp, dtmp;
- bool unsignedp = (INTEGRAL_TYPE_P (TREE_TYPE (src))
- ? TYPE_UNSIGNED (TREE_TYPE (src)) : true);
-
- var = TREE_OPERAND (src, 0);
- width = TREE_OPERAND (src, 1);
- /* The offset needs to be adjusted to a right shift quantity
- depending on the endianness. */
- if (BYTES_BIG_ENDIAN)
- {
- tree tmp = size_binop (PLUS_EXPR, width, TREE_OPERAND (src, 2));
- shift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), tmp);
- }
- else
- shift = TREE_OPERAND (src, 2);
-
- /* In weird cases we have non-integral types for the source or
- destination object.
- ??? For unknown reasons we also want an unsigned scalar type. */
- stype = TREE_TYPE (var);
- if (!INTEGRAL_TYPE_P (stype))
- stype = lang_hooks.types.type_for_size (TREE_INT_CST_LOW
- (TYPE_SIZE (stype)), 1);
- else if (!TYPE_UNSIGNED (stype))
- stype = unsigned_type_for (stype);
-
- utype = TREE_TYPE (dst);
- if (!INTEGRAL_TYPE_P (utype))
- utype = lang_hooks.types.type_for_size (TREE_INT_CST_LOW
- (TYPE_SIZE (utype)), 1);
- else if (!TYPE_UNSIGNED (utype))
- utype = unsigned_type_for (utype);
-
- stmp = make_rename_temp (stype, "SR");
-
- /* Convert the base var of the BIT_FIELD_REF to the scalar type
- we use for computation if we cannot use it directly. */
- if (!useless_type_conversion_p (stype, TREE_TYPE (var)))
- {
- if (INTEGRAL_TYPE_P (TREE_TYPE (var)))
- stmt = gimple_build_assign (stmp, fold_convert (stype, var));
- else
- stmt = gimple_build_assign (stmp, fold_build1 (VIEW_CONVERT_EXPR,
- stype, var));
- gimple_seq_add_stmt (&seq, stmt);
- var = stmp;
- }
-
- if (!integer_zerop (shift))
- {
- stmt = gimple_build_assign (stmp, fold_build2 (RSHIFT_EXPR, stype,
- var, shift));
- gimple_seq_add_stmt (&seq, stmt);
- var = stmp;
- }
-
- /* If we need a masking operation, produce one. */
- if (TREE_INT_CST_LOW (width) == TYPE_PRECISION (stype))
- unsignedp = true;
- else
- {
- tree one = build_int_cst_wide (stype, 1, 0);
- tree mask = int_const_binop (LSHIFT_EXPR, one, width, 0);
- mask = int_const_binop (MINUS_EXPR, mask, one, 0);
-
- stmt = gimple_build_assign (stmp, fold_build2 (BIT_AND_EXPR, stype,
- var, mask));
- gimple_seq_add_stmt (&seq, stmt);
- var = stmp;
- }
-
- /* After shifting and masking, convert to the target type. */
- utmp = stmp;
- if (!useless_type_conversion_p (utype, stype))
- {
- utmp = make_rename_temp (utype, "SR");
-
- stmt = gimple_build_assign (utmp, fold_convert (utype, var));
- gimple_seq_add_stmt (&seq, stmt);
-
- var = utmp;
- }
-
- /* Perform sign extension, if required.
- ??? This should never be necessary. */
- if (!unsignedp)
- {
- tree signbit = int_const_binop (LSHIFT_EXPR,
- build_int_cst_wide (utype, 1, 0),
- size_binop (MINUS_EXPR, width,
- bitsize_int (1)), 0);
-
- stmt = gimple_build_assign (utmp, fold_build2 (BIT_XOR_EXPR, utype,
- var, signbit));
- gimple_seq_add_stmt (&seq, stmt);
-
- stmt = gimple_build_assign (utmp, fold_build2 (MINUS_EXPR, utype,
- utmp, signbit));
- gimple_seq_add_stmt (&seq, stmt);
-
- var = utmp;
- }
-
- /* fold_build3 (BIT_FIELD_REF, ...) sometimes returns a cast. */
- STRIP_NOPS (dst);
-
- /* Finally, move and convert to the destination. */
- if (!useless_type_conversion_p (TREE_TYPE (dst), TREE_TYPE (var)))
- {
- if (INTEGRAL_TYPE_P (TREE_TYPE (dst)))
- var = fold_convert (TREE_TYPE (dst), var);
- else
- var = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (dst), var);
-
- /* If the destination is not a register the conversion needs
- to be a separate statement. */
- if (!is_gimple_reg (dst))
- {
- dtmp = make_rename_temp (TREE_TYPE (dst), "SR");
- stmt = gimple_build_assign (dtmp, var);
- gimple_seq_add_stmt (&seq, stmt);
- var = dtmp;
- }
- }
- stmt = gimple_build_assign (dst, var);
- gimple_seq_add_stmt (&seq, stmt);
-
- return seq;
- }
-
- /* fold_build3 (BIT_FIELD_REF, ..) sometimes returns a cast. */
- if (CONVERT_EXPR_P (dst))
- {
- STRIP_NOPS (dst);
- src = fold_convert (TREE_TYPE (dst), src);
- }
- /* It was hoped that we could perform some type sanity checking
- here, but since front-ends can emit accesses of fields in types
- different from their nominal types and copy structures containing
- them as a whole, we'd have to handle such differences here.
- Since such accesses under different types require compatibility
- anyway, there's little point in making tests and/or adding
- conversions to ensure the types of src and dst are the same.
- So we just assume type differences at this point are ok.
- The only exception we make here are pointer types, which can be different
- in e.g. structurally equal, but non-identical RECORD_TYPEs. */
- else if (POINTER_TYPE_P (TREE_TYPE (dst))
- && !useless_type_conversion_p (TREE_TYPE (dst), TREE_TYPE (src)))
- src = fold_convert (TREE_TYPE (dst), src);
-
- stmt = gimple_build_assign (dst, src);
- gimple_seq_add_stmt (&seq, stmt);
- return seq;
-}
-
-/* BIT_FIELD_REFs must not be shared. sra_build_elt_assignment()
- takes care of assignments, but we must create copies for uses. */
-#define REPLDUP(t) (TREE_CODE (t) != BIT_FIELD_REF ? (t) : unshare_expr (t))
-
-/* Emit an assignment from SRC to DST, but if DST is a scalarizable
- BIT_FIELD_REF, turn it into bit operations. */
-
-static gimple_seq
-sra_build_bf_assignment (tree dst, tree src)
-{
- tree var, type, utype, tmp, tmp2, tmp3;
- gimple_seq seq;
- gimple stmt;
- tree cst, cst2, mask;
- tree minshift, maxshift;
-
- if (TREE_CODE (dst) != BIT_FIELD_REF)
- return sra_build_assignment (dst, src);
-
- var = TREE_OPERAND (dst, 0);
-
- if (!scalar_bitfield_p (dst))
- return sra_build_assignment (REPLDUP (dst), src);
-
- seq = NULL;
-
- cst = fold_convert (bitsizetype, TREE_OPERAND (dst, 2));
- cst2 = size_binop (PLUS_EXPR,
- fold_convert (bitsizetype, TREE_OPERAND (dst, 1)),
- cst);
-
- if (BYTES_BIG_ENDIAN)
- {
- maxshift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), cst);
- minshift = size_binop (MINUS_EXPR, TYPE_SIZE (TREE_TYPE (var)), cst2);
- }
- else
- {
- maxshift = cst2;
- minshift = cst;
- }
-
- type = TREE_TYPE (var);
- if (!INTEGRAL_TYPE_P (type))
- type = lang_hooks.types.type_for_size
- (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (var))), 1);
- if (TYPE_UNSIGNED (type))
- utype = type;
- else
- utype = unsigned_type_for (type);
-
- mask = build_int_cst_wide (utype, 1, 0);
- if (TREE_INT_CST_LOW (maxshift) == TYPE_PRECISION (utype))
- cst = build_int_cst_wide (utype, 0, 0);
- else
- cst = int_const_binop (LSHIFT_EXPR, mask, maxshift, true);
- if (integer_zerop (minshift))
- cst2 = mask;
- else
- cst2 = int_const_binop (LSHIFT_EXPR, mask, minshift, true);
- mask = int_const_binop (MINUS_EXPR, cst, cst2, true);
- mask = fold_build1 (BIT_NOT_EXPR, utype, mask);
-
- if (TYPE_MAIN_VARIANT (utype) != TYPE_MAIN_VARIANT (TREE_TYPE (var))
- && !integer_zerop (mask))
- {
- tmp = var;
- if (!is_gimple_variable (tmp))
- tmp = unshare_expr (var);
-
- tmp2 = make_rename_temp (utype, "SR");
-
- if (INTEGRAL_TYPE_P (TREE_TYPE (var)))
- stmt = gimple_build_assign (tmp2, fold_convert (utype, tmp));
- else
- stmt = gimple_build_assign (tmp2, fold_build1 (VIEW_CONVERT_EXPR,
- utype, tmp));
- gimple_seq_add_stmt (&seq, stmt);
- }
- else
- tmp2 = var;
+ DECL_ARTIFICIAL (repl) = 1;
+ DECL_SOURCE_LOCATION (repl) = DECL_SOURCE_LOCATION (base);
- if (!integer_zerop (mask))
- {
- tmp = make_rename_temp (utype, "SR");
- stmt = gimple_build_assign (tmp, fold_build2 (BIT_AND_EXPR, utype,
- tmp2, mask));
- gimple_seq_add_stmt (&seq, stmt);
- }
- else
- tmp = mask;
-
- if (is_gimple_reg (src) && INTEGRAL_TYPE_P (TREE_TYPE (src)))
- tmp2 = src;
- else if (INTEGRAL_TYPE_P (TREE_TYPE (src)))
- {
- gimple_seq tmp_seq;
- tmp2 = make_rename_temp (TREE_TYPE (src), "SR");
- tmp_seq = sra_build_assignment (tmp2, src);
- gimple_seq_add_seq (&seq, tmp_seq);
- }
- else
- {
- gimple_seq tmp_seq;
- tmp2 = make_rename_temp
- (lang_hooks.types.type_for_size
- (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (src))),
- 1), "SR");
- tmp_seq = sra_build_assignment (tmp2, fold_build1 (VIEW_CONVERT_EXPR,
- TREE_TYPE (tmp2), src));
- gimple_seq_add_seq (&seq, tmp_seq);
- }
-
- if (!TYPE_UNSIGNED (TREE_TYPE (tmp2)))
- {
- gimple_seq tmp_seq;
- tree ut = unsigned_type_for (TREE_TYPE (tmp2));
- tmp3 = make_rename_temp (ut, "SR");
- tmp2 = fold_convert (ut, tmp2);
- tmp_seq = sra_build_assignment (tmp3, tmp2);
- gimple_seq_add_seq (&seq, tmp_seq);
-
- tmp2 = fold_build1 (BIT_NOT_EXPR, utype, mask);
- tmp2 = int_const_binop (RSHIFT_EXPR, tmp2, minshift, true);
- tmp2 = fold_convert (ut, tmp2);
- tmp2 = fold_build2 (BIT_AND_EXPR, ut, tmp3, tmp2);
-
- if (tmp3 != tmp2)
- {
- tmp3 = make_rename_temp (ut, "SR");
- tmp_seq = sra_build_assignment (tmp3, tmp2);
- gimple_seq_add_seq (&seq, tmp_seq);
- }
-
- tmp2 = tmp3;
- }
-
- if (TYPE_MAIN_VARIANT (TREE_TYPE (tmp2)) != TYPE_MAIN_VARIANT (utype))
- {
- gimple_seq tmp_seq;
- tmp3 = make_rename_temp (utype, "SR");
- tmp2 = fold_convert (utype, tmp2);
- tmp_seq = sra_build_assignment (tmp3, tmp2);
- gimple_seq_add_seq (&seq, tmp_seq);
- tmp2 = tmp3;
- }
-
- if (!integer_zerop (minshift))
- {
- tmp3 = make_rename_temp (utype, "SR");
- stmt = gimple_build_assign (tmp3, fold_build2 (LSHIFT_EXPR, utype,
- tmp2, minshift));
- gimple_seq_add_stmt (&seq, stmt);
- tmp2 = tmp3;
- }
-
- if (utype != TREE_TYPE (var))
- tmp3 = make_rename_temp (utype, "SR");
- else
- tmp3 = var;
- stmt = gimple_build_assign (tmp3, fold_build2 (BIT_IOR_EXPR, utype,
- tmp, tmp2));
- gimple_seq_add_stmt (&seq, stmt);
-
- if (tmp3 != var)
- {
- if (TREE_TYPE (var) == type)
- stmt = gimple_build_assign (var, fold_convert (type, tmp3));
- else
- stmt = gimple_build_assign (var, fold_build1 (VIEW_CONVERT_EXPR,
- TREE_TYPE (var), tmp3));
- gimple_seq_add_stmt (&seq, stmt);
- }
-
- return seq;
-}
-
-/* Expand an assignment of SRC to the scalarized representation of
- ELT. If it is a field group, try to widen the assignment to cover
- the full variable. */
-
-static gimple_seq
-sra_build_elt_assignment (struct sra_elt *elt, tree src)
-{
- tree dst = elt->replacement;
- tree var, tmp, cst, cst2;
- gimple stmt;
- gimple_seq seq;
-
- if (TREE_CODE (dst) != BIT_FIELD_REF
- || !elt->in_bitfld_block)
- return sra_build_assignment (REPLDUP (dst), src);
-
- var = TREE_OPERAND (dst, 0);
-
- /* Try to widen the assignment to the entire variable.
- We need the source to be a BIT_FIELD_REF as well, such that, for
- BIT_FIELD_REF<d,sz,dp> = BIT_FIELD_REF<s,sz,sp>,
- by design, conditions are met such that we can turn it into
- d = BIT_FIELD_REF<s,dw,sp-dp>. */
- if (elt->in_bitfld_block == 2
- && TREE_CODE (src) == BIT_FIELD_REF)
- {
- tmp = src;
- cst = TYPE_SIZE (TREE_TYPE (var));
- cst2 = size_binop (MINUS_EXPR, TREE_OPERAND (src, 2),
- TREE_OPERAND (dst, 2));
-
- src = TREE_OPERAND (src, 0);
-
- /* Avoid full-width bit-fields. */
- if (integer_zerop (cst2)
- && tree_int_cst_equal (cst, TYPE_SIZE (TREE_TYPE (src))))
- {
- if (INTEGRAL_TYPE_P (TREE_TYPE (src))
- && !TYPE_UNSIGNED (TREE_TYPE (src)))
- src = fold_convert (unsigned_type_for (TREE_TYPE (src)), src);
-
- /* If a single conversion won't do, we'll need a statement
- list. */
- if (TYPE_MAIN_VARIANT (TREE_TYPE (var))
- != TYPE_MAIN_VARIANT (TREE_TYPE (src)))
- {
- gimple_seq tmp_seq;
- seq = NULL;
-
- if (!INTEGRAL_TYPE_P (TREE_TYPE (src)))
- src = fold_build1 (VIEW_CONVERT_EXPR,
- lang_hooks.types.type_for_size
- (TREE_INT_CST_LOW
- (TYPE_SIZE (TREE_TYPE (src))),
- 1), src);
- gcc_assert (TYPE_UNSIGNED (TREE_TYPE (src)));
-
- tmp = make_rename_temp (TREE_TYPE (src), "SR");
- stmt = gimple_build_assign (tmp, src);
- gimple_seq_add_stmt (&seq, stmt);
-
- tmp_seq = sra_build_assignment (var,
- fold_convert (TREE_TYPE (var),
- tmp));
- gimple_seq_add_seq (&seq, tmp_seq);
-
- return seq;
- }
-
- src = fold_convert (TREE_TYPE (var), src);
- }
- else
- {
- src = fold_convert (TREE_TYPE (var), tmp);
- }
-
- return sra_build_assignment (var, src);
- }
-
- return sra_build_bf_assignment (dst, src);
-}
-
-/* Generate a set of assignment statements in *LIST_P to copy all
- instantiated elements under ELT to or from the equivalent structure
- rooted at EXPR. COPY_OUT controls the direction of the copy, with
- true meaning to copy out of EXPR into ELT. */
-
-static void
-generate_copy_inout (struct sra_elt *elt, bool copy_out, tree expr,
- gimple_seq *seq_p)
-{
- struct sra_elt *c;
- gimple_seq tmp_seq;
- tree t;
-
- if (!copy_out && TREE_CODE (expr) == SSA_NAME
- && TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
- {
- tree r, i;
-
- c = lookup_element (elt, integer_zero_node, NULL, NO_INSERT);
- r = c->replacement;
- c = lookup_element (elt, integer_one_node, NULL, NO_INSERT);
- i = c->replacement;
-
- t = build2 (COMPLEX_EXPR, elt->type, r, i);
- tmp_seq = sra_build_bf_assignment (expr, t);
- gcc_assert (gimple_seq_singleton_p (tmp_seq));
- SSA_NAME_DEF_STMT (expr) = gimple_seq_first_stmt (tmp_seq);
- gimple_seq_add_seq (seq_p, tmp_seq);
- }
- else if (elt->replacement)
+ if (DECL_NAME (base) && !DECL_IGNORED_P (base))
{
- if (copy_out)
- tmp_seq = sra_build_elt_assignment (elt, expr);
- else
- tmp_seq = sra_build_bf_assignment (expr, REPLDUP (elt->replacement));
- gimple_seq_add_seq (seq_p, tmp_seq);
+ DECL_IGNORED_P (repl) = 0;
+ DECL_NAME (repl) = DECL_NAME (base);
+ TREE_NO_WARNING (repl) = TREE_NO_WARNING (base);
}
else
{
- FOR_EACH_ACTUAL_CHILD (c, elt)
- {
- t = generate_one_element_ref (c, unshare_expr (expr));
- generate_copy_inout (c, copy_out, t, seq_p);
- }
- }
-}
-
-/* Generate a set of assignment statements in *LIST_P to copy all instantiated
- elements under SRC to their counterparts under DST. There must be a 1-1
- correspondence of instantiated elements. */
-
-static void
-generate_element_copy (struct sra_elt *dst, struct sra_elt *src, gimple_seq *seq_p)
-{
- struct sra_elt *dc, *sc;
-
- FOR_EACH_ACTUAL_CHILD (dc, dst)
- {
- sc = lookup_element (src, dc->element, NULL, NO_INSERT);
- if (!sc && dc->in_bitfld_block == 2)
- {
- struct sra_elt *dcs;
-
- FOR_EACH_ACTUAL_CHILD (dcs, dc)
- {
- sc = lookup_element (src, dcs->element, NULL, NO_INSERT);
- gcc_assert (sc);
- generate_element_copy (dcs, sc, seq_p);
- }
-
- continue;
- }
-
- /* If DST and SRC are structs with the same elements, but do not have
- the same TYPE_MAIN_VARIANT, then lookup of DST FIELD_DECL in SRC
- will fail. Try harder by finding the corresponding FIELD_DECL
- in SRC. */
- if (!sc)
- {
- tree f;
-
- gcc_assert (useless_type_conversion_p (dst->type, src->type));
- gcc_assert (TREE_CODE (dc->element) == FIELD_DECL);
- for (f = TYPE_FIELDS (src->type); f ; f = TREE_CHAIN (f))
- if (simple_cst_equal (DECL_FIELD_OFFSET (f),
- DECL_FIELD_OFFSET (dc->element)) > 0
- && simple_cst_equal (DECL_FIELD_BIT_OFFSET (f),
- DECL_FIELD_BIT_OFFSET (dc->element)) > 0
- && simple_cst_equal (DECL_SIZE (f),
- DECL_SIZE (dc->element)) > 0
- && (useless_type_conversion_p (TREE_TYPE (dc->element),
- TREE_TYPE (f))
- || (POINTER_TYPE_P (TREE_TYPE (dc->element))
- && POINTER_TYPE_P (TREE_TYPE (f)))))
- break;
- gcc_assert (f != NULL_TREE);
- sc = lookup_element (src, f, NULL, NO_INSERT);
- }
-
- generate_element_copy (dc, sc, seq_p);
- }
-
- if (dst->replacement)
- {
- gimple_seq tmp_seq;
-
- gcc_assert (src->replacement);
-
- tmp_seq = sra_build_elt_assignment (dst, REPLDUP (src->replacement));
- gimple_seq_add_seq (seq_p, tmp_seq);
- }
-}
-
-/* Generate a set of assignment statements in *LIST_P to zero all instantiated
- elements under ELT. In addition, do not assign to elements that have been
- marked VISITED but do reset the visited flag; this allows easy coordination
- with generate_element_init. */
-
-static void
-generate_element_zero (struct sra_elt *elt, gimple_seq *seq_p)
-{
- struct sra_elt *c;
-
- if (elt->visited)
- {
- elt->visited = false;
- return;
+ DECL_IGNORED_P (repl) = 1;
+ TREE_NO_WARNING (repl) = 1;
}
+#endif
- if (!elt->in_bitfld_block)
- FOR_EACH_ACTUAL_CHILD (c, elt)
- generate_element_zero (c, seq_p);
-
- if (elt->replacement)
- {
- tree t;
- gimple_seq tmp_seq;
-
- gcc_assert (elt->is_scalar);
- t = fold_convert (elt->type, integer_zero_node);
-
- tmp_seq = sra_build_elt_assignment (elt, t);
- gimple_seq_add_seq (seq_p, tmp_seq);
- }
+ return repl;
}
-/* Generate an assignment VAR = INIT, where INIT may need gimplification.
- Add the result to *LIST_P. */
-
-static void
-generate_one_element_init (struct sra_elt *elt, tree init, gimple_seq *seq_p)
-{
- gimple_seq tmp_seq = sra_build_elt_assignment (elt, init);
- gimple_seq_add_seq (seq_p, tmp_seq);
-}
-/* Generate a set of assignment statements in *LIST_P to set all instantiated
- elements under ELT with the contents of the initializer INIT. In addition,
- mark all assigned elements VISITED; this allows easy coordination with
- generate_element_zero. Return false if we found a case we couldn't
- handle. */
+/* Check propriety of BLKmode OFFER. */
static bool
-generate_element_init_1 (struct sra_elt *elt, tree init, gimple_seq *seq_p)
+check_blk_accesses (struct offer *offer, VEC(access_p, heap) *access_vec)
{
- bool result = true;
- enum tree_code init_code;
- struct sra_elt *sub;
- tree t;
- unsigned HOST_WIDE_INT idx;
- tree value, purpose;
-
- /* We can be passed DECL_INITIAL of a static variable. It might have a
- conversion, which we strip off here. */
- STRIP_USELESS_TYPE_CONVERSION (init);
- init_code = TREE_CODE (init);
-
- if (elt->is_scalar)
- {
- if (elt->replacement)
- {
- generate_one_element_init (elt, init, seq_p);
- elt->visited = true;
- }
- return result;
- }
+ bool can_scalarize = true;
+ access_p access;
+ int i;
+ int array_ref = -1;
- switch (init_code)
+ for (i = offer->from; i <= offer->to; i++)
{
- case COMPLEX_CST:
- case COMPLEX_EXPR:
- FOR_EACH_ACTUAL_CHILD (sub, elt)
- {
- if (sub->element == integer_zero_node)
- t = (init_code == COMPLEX_EXPR
- ? TREE_OPERAND (init, 0) : TREE_REALPART (init));
- else
- t = (init_code == COMPLEX_EXPR
- ? TREE_OPERAND (init, 1) : TREE_IMAGPART (init));
- result &= generate_element_init_1 (sub, t, seq_p);
- }
- break;
-
- case CONSTRUCTOR:
- FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, purpose, value)
+ access = VEC_index (access_p, access_vec, i);
+ if (array_ref == -1)
+ array_ref = (access->index != NULL_TREE);
+ else if (array_ref != (access->index != NULL_TREE))
{
- /* Array constructors are routinely created with NULL indices. */
- if (purpose == NULL_TREE)
- {
- result = false;
- break;
- }
- if (TREE_CODE (purpose) == RANGE_EXPR)
- {
- tree lower = TREE_OPERAND (purpose, 0);
- tree upper = TREE_OPERAND (purpose, 1);
-
- while (1)
- {
- sub = lookup_element (elt, lower, NULL, NO_INSERT);
- if (sub != NULL)
- result &= generate_element_init_1 (sub, value, seq_p);
- if (tree_int_cst_equal (lower, upper))
- break;
- lower = int_const_binop (PLUS_EXPR, lower,
- integer_one_node, true);
- }
- }
- else
- {
- sub = lookup_element (elt, purpose, NULL, NO_INSERT);
- if (sub != NULL)
- result &= generate_element_init_1 (sub, value, seq_p);
- }
+ can_scalarize = false;
+ break;
}
- break;
-
- default:
- elt->visited = true;
- result = false;
}
- return result;
+ return can_scalarize;
}
-/* A wrapper function for generate_element_init_1 that handles cleanup after
- gimplification. */
-static bool
-generate_element_init (struct sra_elt *elt, tree init, gimple_seq *seq_p)
-{
- bool ret;
- struct gimplify_ctx gctx;
-
- push_gimplify_context (&gctx);
- ret = generate_element_init_1 (elt, init, seq_p);
- pop_gimplify_context (NULL);
-
- /* The replacement can expose previously unreferenced variables. */
- if (ret && *seq_p)
- {
- gimple_stmt_iterator i;
-
- for (i = gsi_start (*seq_p); !gsi_end_p (i); gsi_next (&i))
- find_new_referenced_vars (gsi_stmt (i));
- }
-
- return ret;
-}
-
-/* Insert a gimple_seq SEQ on all the outgoing edges out of BB. Note that
- if BB has more than one edge, STMT will be replicated for each edge.
- Also, abnormal edges will be ignored. */
-
-void
-insert_edge_copies_seq (gimple_seq seq, basic_block bb)
-{
- edge e;
- edge_iterator ei;
- unsigned n_copies = -1;
-
- FOR_EACH_EDGE (e, ei, bb->succs)
- if (!(e->flags & EDGE_ABNORMAL))
- n_copies++;
-
- FOR_EACH_EDGE (e, ei, bb->succs)
- if (!(e->flags & EDGE_ABNORMAL))
- gsi_insert_seq_on_edge (e, n_copies-- > 0 ? gimple_seq_copy (seq) : seq);
-}
-
-/* Helper function to insert LIST before GSI, and set up line number info. */
-
-void
-sra_insert_before (gimple_stmt_iterator *gsi, gimple_seq seq)
-{
- gimple stmt = gsi_stmt (*gsi);
-
- if (gimple_has_location (stmt))
- annotate_all_with_location (seq, gimple_location (stmt));
- gsi_insert_seq_before (gsi, seq, GSI_SAME_STMT);
-}
-
-/* Similarly, but insert after GSI. Handles insertion onto edges as well. */
-
-void
-sra_insert_after (gimple_stmt_iterator *gsi, gimple_seq seq)
-{
- gimple stmt = gsi_stmt (*gsi);
-
- if (gimple_has_location (stmt))
- annotate_all_with_location (seq, gimple_location (stmt));
-
- if (stmt_ends_bb_p (stmt))
- insert_edge_copies_seq (seq, gsi_bb (*gsi));
- else
- gsi_insert_seq_after (gsi, seq, GSI_SAME_STMT);
-}
-
-/* Similarly, but replace the statement at GSI. */
-
-static void
-sra_replace (gimple_stmt_iterator *gsi, gimple_seq seq)
-{
- sra_insert_before (gsi, seq);
- gsi_remove (gsi, false);
- if (gsi_end_p (*gsi))
- *gsi = gsi_last (gsi_seq (*gsi));
- else
- gsi_prev (gsi);
-}
-
-/* Data structure that bitfield_overlaps_p fills in with information
- about the element passed in and how much of it overlaps with the
- bit-range passed it to. */
-
-struct bitfield_overlap_info
-{
- /* The bit-length of an element. */
- tree field_len;
-
- /* The bit-position of the element in its parent. */
- tree field_pos;
-
- /* The number of bits of the element that overlap with the incoming
- bit range. */
- tree overlap_len;
-
- /* The first bit of the element that overlaps with the incoming bit
- range. */
- tree overlap_pos;
-};
-
-/* Return true if a BIT_FIELD_REF<(FLD->parent), BLEN, BPOS>
- expression (referenced as BF below) accesses any of the bits in FLD,
- false if it doesn't. If DATA is non-null, its field_len and
- field_pos are filled in such that BIT_FIELD_REF<(FLD->parent),
- field_len, field_pos> (referenced as BFLD below) represents the
- entire field FLD->element, and BIT_FIELD_REF<BFLD, overlap_len,
- overlap_pos> represents the portion of the entire field that
- overlaps with BF. */
+/* Check propriety of OFFER. Note, that result depends on (non)BLKmode. */
static bool
-bitfield_overlaps_p (tree blen, tree bpos, struct sra_elt *fld,
- struct bitfield_overlap_info *data)
+check_offer_accesses (struct offer *offer, VEC(access_p, heap) *access_vec)
{
- tree flen, fpos;
- bool ret;
+ access_p access = VEC_index (access_p, access_vec, offer->from);
- if (TREE_CODE (fld->element) == FIELD_DECL)
- {
- flen = fold_convert (bitsizetype, DECL_SIZE (fld->element));
- fpos = fold_convert (bitsizetype, DECL_FIELD_OFFSET (fld->element));
- fpos = size_binop (MULT_EXPR, fpos, bitsize_int (BITS_PER_UNIT));
- fpos = size_binop (PLUS_EXPR, fpos, DECL_FIELD_BIT_OFFSET (fld->element));
- }
- else if (TREE_CODE (fld->element) == BIT_FIELD_REF)
- {
- flen = fold_convert (bitsizetype, TREE_OPERAND (fld->element, 1));
- fpos = fold_convert (bitsizetype, TREE_OPERAND (fld->element, 2));
- }
- else if (TREE_CODE (fld->element) == INTEGER_CST)
- {
- flen = fold_convert (bitsizetype, TYPE_SIZE (fld->type));
- fpos = fold_convert (bitsizetype, fld->element);
- fpos = size_binop (MULT_EXPR, flen, fpos);
- }
+ if (access->non_blk)
+ return true;
else
- gcc_unreachable ();
+ return check_blk_accesses (offer, access_vec);
+}
- gcc_assert (host_integerp (blen, 1)
- && host_integerp (bpos, 1)
- && host_integerp (flen, 1)
- && host_integerp (fpos, 1));
- ret = ((!tree_int_cst_lt (fpos, bpos)
- && tree_int_cst_lt (size_binop (MINUS_EXPR, fpos, bpos),
- blen))
- || (!tree_int_cst_lt (bpos, fpos)
- && tree_int_cst_lt (size_binop (MINUS_EXPR, bpos, fpos),
- flen)));
+/* Analyze the accesses of one BASE. */
- if (!ret)
- return ret;
+static bool
+analyze_base_access (tree base)
+{
+ struct access *access;
+ int i, j, n;
+ struct offer *offer_stack;
+ int offer_sp, offer_bot;
+ VEC(access_p, heap) *access_vec;
+ struct offer *o;
+ bool can_scalarize = true;
+ void **slot;
- if (data)
- {
- tree bend, fend;
+ slot = pointer_map_contains (base_access_vec, base);
+ if (!slot)
+ return false;
- data->field_len = flen;
- data->field_pos = fpos;
+ access_vec = *(VEC(access_p, heap) **) slot;
- fend = size_binop (PLUS_EXPR, fpos, flen);
- bend = size_binop (PLUS_EXPR, bpos, blen);
+ n = VEC_length(access_p, access_vec);
- if (tree_int_cst_lt (bend, fend))
- data->overlap_len = size_binop (MINUS_EXPR, bend, fpos);
- else
- data->overlap_len = NULL;
+ if (dump_file)
+ fprintf (dump_file, "\n\nn = %d\n", n);
- if (tree_int_cst_lt (fpos, bpos))
- {
- data->overlap_pos = size_binop (MINUS_EXPR, bpos, fpos);
- data->overlap_len = size_binop (MINUS_EXPR,
- data->overlap_len
- ? data->overlap_len
- : data->field_len,
- data->overlap_pos);
- }
- else
- data->overlap_pos = NULL;
- }
+ /* TODO: Use VEC eventually. */
+ offer_stack = XNEWVEC (struct offer, n);
+ memset (offer_stack, 0, sizeof (struct offer) * n);
- return ret;
-}
+ /* Sort by <OFFSET, SIZE>. */
+ qsort (VEC_address (access_p, access_vec), n, sizeof (access_p), fld_cmp);
-/* Add to LISTP a sequence of statements that copies BLEN bits between
- VAR and the scalarized elements of ELT, starting a bit VPOS of VAR
- and at bit BPOS of ELT. The direction of the copy is given by
- TO_VAR. */
+ /* Show Time! */
+ access = VEC_index (access_p, access_vec, 0);
+ offer_stack[0].from = 0;
+ offer_stack[0].begin = access->offset;
+ offer_stack[0].end = access->offset + access->size;
+ offer_bot = offer_sp = 0;
-static void
-sra_explode_bitfield_assignment (tree var, tree vpos, bool to_var,
- gimple_seq *seq_p, tree blen, tree bpos,
- struct sra_elt *elt)
-{
- struct sra_elt *fld;
- struct bitfield_overlap_info flp;
+ gcc_assert (access->base == base);
- FOR_EACH_ACTUAL_CHILD (fld, elt)
+ for (i = 1; i <= n && can_scalarize; i++)
{
- tree flen, fpos;
+ /* We do one iteration more, to reduce some code. */
+ bool last_iter = (i == n);
- if (!bitfield_overlaps_p (blen, bpos, fld, &flp))
- continue;
+ if (!last_iter)
+ access = VEC_index (access_p, access_vec, i);
+
+ /* NOTE: This loop is unneeded now. (There is a `break' after every
+ condition). However, eventually this part should be much more
+ sophisticated. */
+ for (j = offer_sp; j >= offer_bot; j--)
+ {
+ o = &offer_stack[j];
- flen = flp.overlap_len ? flp.overlap_len : flp.field_len;
- fpos = flp.overlap_pos ? flp.overlap_pos : bitsize_int (0);
+ if (last_iter || access->offset >= o->end)
+ {
+ tree repl;
- if (fld->replacement)
- {
- tree infld, invar, type;
- gimple_seq st;
+ o->to = i - 1;
+ repl = build_replacement (o, VEC_address (access_p, access_vec));
- infld = fld->replacement;
+ if (!repl || !check_offer_accesses (o, access_vec))
+ {
+ can_scalarize = false;
+ break;
+ }
- type = TREE_TYPE (infld);
- if (TYPE_PRECISION (type) != TREE_INT_CST_LOW (flen))
- type = lang_hooks.types.type_for_size (TREE_INT_CST_LOW (flen), 1);
- else
- type = unsigned_type_for (type);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Let's create a variable (size = %ld),"
+ "hot_bb: %d, for accesses %d-%d without:",
+ o->end - o->begin, (int) o->have_hot_bb,
+ o->from, i - 1);
+ if (o->without)
+ dump_bitmap (dump_file, o->without);
+ else
+ fprintf (dump_file, "\n");
+ fprintf (dump_file, "repl: ");
+ print_generic_expr (dump_file, repl, 0);
+ fprintf (dump_file, " (");
+ print_generic_expr (dump_file, TREE_TYPE (repl), 0);
+ fprintf (dump_file, ")\n");
+ }
- if (TREE_CODE (infld) == BIT_FIELD_REF)
- {
- fpos = size_binop (PLUS_EXPR, fpos, TREE_OPERAND (infld, 2));
- infld = TREE_OPERAND (infld, 0);
+ if (!last_iter)
+ {
+ offer_sp++;
+ offer_stack[offer_sp].from = i;
+ offer_stack[offer_sp].begin = access->offset;
+ offer_stack[offer_sp].end = access->offset + access->size;
+ offer_bot = j;
+ }
+ break;
}
- else if (BYTES_BIG_ENDIAN && DECL_P (fld->element)
- && !tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (infld)),
- DECL_SIZE (fld->element)))
+ else if (access->offset == o->begin
+ && access->offset + access->size == o->end)
{
- fpos = size_binop (PLUS_EXPR, fpos,
- TYPE_SIZE (TREE_TYPE (infld)));
- fpos = size_binop (MINUS_EXPR, fpos,
- DECL_SIZE (fld->element));
+ /* Just add this access to the current offer. */
+ break;
}
-
- infld = fold_build3 (BIT_FIELD_REF, type, infld, flen, fpos);
-
- invar = size_binop (MINUS_EXPR, flp.field_pos, bpos);
- if (flp.overlap_pos)
- invar = size_binop (PLUS_EXPR, invar, flp.overlap_pos);
- invar = size_binop (PLUS_EXPR, invar, vpos);
-
- invar = fold_build3 (BIT_FIELD_REF, type, var, flen, invar);
-
- if (to_var)
- st = sra_build_bf_assignment (invar, infld);
else
- st = sra_build_bf_assignment (infld, invar);
-
- gimple_seq_add_seq (seq_p, st);
+ {
+ can_scalarize = false;
+ if (dump_file)
+ fprintf (dump_file, "Cannot scalarize, go home\n");
+ break;
+ }
}
- else
- {
- tree sub = size_binop (MINUS_EXPR, flp.field_pos, bpos);
- sub = size_binop (PLUS_EXPR, vpos, sub);
- if (flp.overlap_pos)
- sub = size_binop (PLUS_EXPR, sub, flp.overlap_pos);
+ }
- sra_explode_bitfield_assignment (var, sub, to_var, seq_p,
- flen, fpos, fld);
- }
+ if (can_scalarize == false)
+ {
+ return false;
}
+
+ if (dump_file)
+ fprintf (dump_file, "Fields are OK\n");
+
+ dump_vec_accesses (access_vec);
+ return true;
}
-/* Add to LISTBEFOREP statements that copy scalarized members of ELT
- that overlap with BIT_FIELD_REF<(ELT->element), BLEN, BPOS> back
- into the full variable, and to LISTAFTERP, if non-NULL, statements
- that copy the (presumably modified) overlapping portions of the
- full variable back to the scalarized variables. */
-static void
-sra_sync_for_bitfield_assignment (gimple_seq *seq_before_p,
- gimple_seq *seq_after_p,
- tree blen, tree bpos,
- struct sra_elt *elt)
-{
- struct sra_elt *fld;
- struct bitfield_overlap_info flp;
-
- FOR_EACH_ACTUAL_CHILD (fld, elt)
- if (bitfield_overlaps_p (blen, bpos, fld, &flp))
- {
- if (fld->replacement || (!flp.overlap_len && !flp.overlap_pos))
- {
- generate_copy_inout (fld, false, generate_element_ref (fld),
- seq_before_p);
- mark_no_warning (fld);
- if (seq_after_p)
- generate_copy_inout (fld, true, generate_element_ref (fld),
- seq_after_p);
- }
- else
- {
- tree flen = flp.overlap_len ? flp.overlap_len : flp.field_len;
- tree fpos = flp.overlap_pos ? flp.overlap_pos : bitsize_int (0);
-
- sra_sync_for_bitfield_assignment (seq_before_p, seq_after_p,
- flen, fpos, fld);
- }
- }
-}
-
-/* Scalarize a USE. To recap, this is either a simple reference to ELT,
- if elt is scalar, or some occurrence of ELT that requires a complete
- aggregate. IS_OUTPUT is true if ELT is being modified. */
+/* Analyze all accesses, return if any scalarization is going to happen. */
-static void
-scalarize_use (struct sra_elt *elt, tree *expr_p, gimple_stmt_iterator *gsi,
- bool is_output, bool use_all)
+static bool
+analyze_accesses (void)
{
- gimple stmt = gsi_stmt (*gsi);
- tree bfexpr;
+ bitmap_iterator bi;
+ unsigned i;
+ bool any = false;
+ tree base;
- if (elt->replacement)
- {
- tree replacement = elt->replacement;
-
- /* If we have a replacement, then updating the reference is as
- simple as modifying the existing statement in place. */
- if (is_output
- && TREE_CODE (elt->replacement) == BIT_FIELD_REF
- && is_gimple_reg (TREE_OPERAND (elt->replacement, 0))
- && is_gimple_assign (stmt)
- && gimple_assign_lhs_ptr (stmt) == expr_p)
- {
- gimple_seq newseq;
- /* RHS must be a single operand. */
- gcc_assert (gimple_assign_single_p (stmt));
- newseq = sra_build_elt_assignment (elt, gimple_assign_rhs1 (stmt));
- sra_replace (gsi, newseq);
- return;
- }
- else if (!is_output
- && TREE_CODE (elt->replacement) == BIT_FIELD_REF
- && is_gimple_assign (stmt)
- && gimple_assign_rhs1_ptr (stmt) == expr_p)
- {
- tree tmp = make_rename_temp
- (TREE_TYPE (gimple_assign_lhs (stmt)), "SR");
- gimple_seq newseq = sra_build_assignment (tmp, REPLDUP (elt->replacement));
+ bitmap cannot_map = BITMAP_ALLOC (NULL);
- sra_insert_before (gsi, newseq);
- replacement = tmp;
- }
- if (is_output)
- mark_all_v_defs_stmt (stmt);
- *expr_p = REPLDUP (replacement);
- update_stmt (stmt);
+ EXECUTE_IF_SET_IN_BITMAP (base_map, 0, i, bi)
+ {
+ base = referenced_var (i);
+ if (analyze_base_access (base))
+ any = true;
+ else
+ bitmap_set_bit (cannot_map, i);
}
- else if (use_all && is_output
- && is_gimple_assign (stmt)
- && TREE_CODE (bfexpr
- = gimple_assign_lhs (stmt)) == BIT_FIELD_REF
- && &TREE_OPERAND (bfexpr, 0) == expr_p
- && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr))
- && TREE_CODE (TREE_TYPE (*expr_p)) == RECORD_TYPE)
- {
- gimple_seq seq_before = NULL;
- gimple_seq seq_after = NULL;
- tree blen = fold_convert (bitsizetype, TREE_OPERAND (bfexpr, 1));
- tree bpos = fold_convert (bitsizetype, TREE_OPERAND (bfexpr, 2));
- bool update = false;
-
- if (!elt->use_block_copy)
- {
- tree type = TREE_TYPE (bfexpr);
- tree var = make_rename_temp (type, "SR"), tmp, vpos;
- gimple st;
-
- gimple_assign_set_lhs (stmt, var);
- update = true;
- if (!TYPE_UNSIGNED (type))
- {
- type = unsigned_type_for (type);
- tmp = make_rename_temp (type, "SR");
- st = gimple_build_assign (tmp, fold_convert (type, var));
- gimple_seq_add_stmt (&seq_after, st);
- var = tmp;
- }
+ bitmap_and_compl_into (base_map, cannot_map);
+ BITMAP_FREE (cannot_map);
- /* If VAR is wider than BLEN bits, it is padded at the
- most-significant end. We want to set VPOS such that
- <BIT_FIELD_REF VAR BLEN VPOS> would refer to the
- least-significant BLEN bits of VAR. */
- if (BYTES_BIG_ENDIAN)
- vpos = size_binop (MINUS_EXPR, TYPE_SIZE (type), blen);
- else
- vpos = bitsize_int (0);
- sra_explode_bitfield_assignment
- (var, vpos, false, &seq_after, blen, bpos, elt);
- }
- else
- sra_sync_for_bitfield_assignment
- (&seq_before, &seq_after, blen, bpos, elt);
+ return any;
+}
- if (seq_before)
- {
- mark_all_v_defs_seq (seq_before);
- sra_insert_before (gsi, seq_before);
- }
- if (seq_after)
- {
- mark_all_v_defs_seq (seq_after);
- sra_insert_after (gsi, seq_after);
- }
- if (update)
- update_stmt (stmt);
- }
- else if (use_all && !is_output
- && is_gimple_assign (stmt)
- && TREE_CODE (bfexpr
- = gimple_assign_rhs1 (stmt)) == BIT_FIELD_REF
- && &TREE_OPERAND (gimple_assign_rhs1 (stmt), 0) == expr_p
- && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr))
- && TREE_CODE (TREE_TYPE (*expr_p)) == RECORD_TYPE)
- {
- gimple_seq seq = NULL;
- tree blen = fold_convert (bitsizetype, TREE_OPERAND (bfexpr, 1));
- tree bpos = fold_convert (bitsizetype, TREE_OPERAND (bfexpr, 2));
- bool update = false;
+/* Return access field for *EXPR expression, or NULL if it not possible. */
- if (!elt->use_block_copy)
- {
- tree type = TREE_TYPE (bfexpr);
- tree var, vpos;
+static struct access *
+scalarize_access (tree *expr)
+{
+ struct access *access = NULL;
- if (!TYPE_UNSIGNED (type))
- type = unsigned_type_for (type);
+ switch (TREE_CODE (*expr))
+ {
+ case PARM_DECL:
+ case RESULT_DECL:
+ case VAR_DECL:
+ case COMPONENT_REF:
+ case BIT_FIELD_REF:
+ access = get_access (*expr);
+ break;
- var = make_rename_temp (type, "SR");
+ case ARRAY_REF:
+ *expr = TREE_OPERAND (*expr, 0);
- gimple_seq_add_stmt (&seq,
- gimple_build_assign
- (var, build_int_cst_wide (type, 0, 0)));
-
- /* If VAR is wider than BLEN bits, it is padded at the
- most-significant end. We want to set VPOS such that
- <BIT_FIELD_REF VAR BLEN VPOS> would refer to the
- least-significant BLEN bits of VAR. */
- if (BYTES_BIG_ENDIAN)
- vpos = size_binop (MINUS_EXPR, TYPE_SIZE (type), blen);
- else
- vpos = bitsize_int (0);
- sra_explode_bitfield_assignment
- (var, vpos, true, &seq, blen, bpos, elt);
+ if (TREE_CODE (*expr) == VIEW_CONVERT_EXPR)
+ *expr = TREE_OPERAND (*expr, 0);
- gimple_assign_set_rhs1 (stmt, var);
- update = true;
- }
- else
- sra_sync_for_bitfield_assignment
- (&seq, NULL, blen, bpos, elt);
+ access = get_access (*expr);
+ break;
- if (seq)
- {
- mark_all_v_defs_seq (seq);
- sra_insert_before (gsi, seq);
- }
+ case ARRAY_RANGE_REF:
+ case VIEW_CONVERT_EXPR:
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ /* TODO */
- if (update)
- update_stmt (stmt);
+ default:
+ break;
}
- else
- {
- gimple_seq seq = NULL;
- /* Otherwise we need some copies. If ELT is being read, then we
- want to store all (modified) sub-elements back into the
- structure before the reference takes place. If ELT is being
- written, then we want to load the changed values back into
- our shadow variables. */
- /* ??? We don't check modified for reads, we just always write all of
- the values. We should be able to record the SSA number of the VOP
- for which the values were last read. If that number matches the
- SSA number of the VOP in the current statement, then we needn't
- emit an assignment. This would also eliminate double writes when
- a structure is passed as more than one argument to a function call.
- This optimization would be most effective if sra_walk_function
- processed the blocks in dominator order. */
-
- generate_copy_inout (elt, is_output, generate_element_ref (elt), &seq);
- if (seq == NULL)
- return;
- mark_all_v_defs_seq (seq);
- if (is_output)
- sra_insert_after (gsi, seq);
- else
- {
- sra_insert_before (gsi, seq);
- if (use_all)
- mark_no_warning (elt);
- }
- }
+ if (access && !bitmap_bit_p (base_map, DECL_UID (access->base)))
+ return NULL;
+
+ return access;
}
-/* Scalarize a COPY. To recap, this is an assignment statement between
- two scalarizable references, LHS_ELT and RHS_ELT. */
-static void
-scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
- gimple_stmt_iterator *gsi)
+/* Scalarize nonBLK array reference. */
+
+static tree
+scalarize_non_blk_array_ref (struct access *access, tree safe_expr, tree expr,
+ gimple_seq *seq, tree *stmt_rhs)
{
- gimple_seq seq;
gimple stmt;
- if (lhs_elt->replacement && rhs_elt->replacement)
- {
- /* If we have two scalar operands, modify the existing statement. */
- stmt = gsi_stmt (*gsi);
+ tree sra_int1, sra_int2, sra_shift, sra_rhs, sra_mask;
+ tree sra_int_type;
+ tree sra_type = TREE_TYPE (expr);
+ tree safe_type = TREE_TYPE (safe_expr);
+ HOST_WIDE_INT sra_size;
+ tree index = access->index;
+ tree repl = access->replacement;
+
+ gcc_assert (host_integerp (TYPE_SIZE (sra_type), 1));
+ gcc_assert (host_integerp (TYPE_SIZE (safe_type), 1));
+
+ sra_size = TREE_INT_CST_LOW (TYPE_SIZE (sra_type));
+ sra_int_type = build_nonstandard_integer_type (sra_size, 1);
+ sra_int1 = make_rename_temp (sra_int_type, "sra_int_1");
+ sra_int2 = make_rename_temp (sra_int_type, "sra_int_2");
+ sra_mask = make_rename_temp (sra_int_type, "sra_mask");
+
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, sra_int_type, repl);
+ stmt = gimple_build_assign (sra_int1, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, sra_int_type,
+ *stmt_rhs);
+ stmt = gimple_build_assign (sra_int2, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ sra_shift = fold_build2 (MULT_EXPR, sra_int_type,
+ TYPE_SIZE (TREE_TYPE (*stmt_rhs)),
+ index);
+
+ if (! host_integerp (sra_shift, 1))
+ return safe_expr; /* Richi said: "Only constants" */
+
+ sra_mask = build_bit_mask (sra_int_type,
+ TREE_INT_CST_LOW (TYPE_SIZE (safe_type)),
+ TREE_INT_CST_LOW (sra_shift));
+ sra_mask = fold_build1 (BIT_NOT_EXPR, sra_int_type, sra_mask);
+
+ sra_rhs = fold_build2 (BIT_AND_EXPR, sra_int_type, sra_int1,
+ sra_mask);
+ stmt = gimple_build_assign (sra_int1, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ sra_rhs = fold_build2 (LSHIFT_EXPR, sra_int_type, sra_int2,
+ sra_shift);
+ stmt = gimple_build_assign (sra_int2, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ sra_rhs = fold_build2 (BIT_IOR_EXPR, sra_int_type, sra_int1,
+ sra_int2);
+ stmt = gimple_build_assign (sra_int1, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (repl),
+ sra_int1);
+ stmt = gimple_build_assign (repl, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ *stmt_rhs = NULL_TREE;
+ return NULL_TREE;
+}
+
+
+/* Scalarize expression EXPR. If any new statement has to be added, put it to
+ SEQ. If EXPR is LHS of assignment statement STMT_RHS points to the RHS.
+ Return expression which should replace EXPR in statement. */
+
+static tree
+scalarize_expr (tree expr, gimple_seq *seq, tree *stmt_rhs)
+{
+ struct access *access;
+ tree repl;
+ tree safe_expr;
+ tree ret = NULL_TREE;
+ bool non_blk;
+
+ if (stmt_rhs)
+ gcc_assert (TREE_CODE (*stmt_rhs) != CONSTRUCTOR);
+
+ gcc_assert (expr);
+
+ safe_expr = expr;
+ access = scalarize_access (&expr);
+
+ if (access)
+ {
+ bool convert = false;
+ gcc_assert (TREE_TYPE (expr) == access->type);
+
+ gcc_assert (access->replacement);
+ repl = access->replacement;
- /* See the commentary in sra_walk_function concerning
- RETURN_EXPR, and why we should never see one here. */
- gcc_assert (is_gimple_assign (stmt));
- gcc_assert (gimple_assign_copy_p (stmt));
+ non_blk = access->non_blk;
+ if (TREE_TYPE (expr) != TREE_TYPE (repl))
+ convert = true;
- gimple_assign_set_lhs (stmt, lhs_elt->replacement);
- gimple_assign_set_rhs1 (stmt, REPLDUP (rhs_elt->replacement));
- update_stmt (stmt);
- }
- else if (lhs_elt->use_block_copy || rhs_elt->use_block_copy)
- {
- /* If either side requires a block copy, then sync the RHS back
- to the original structure, leave the original assignment
- statement (which will perform the block copy), then load the
- LHS values out of its now-updated original structure. */
- /* ??? Could perform a modified pair-wise element copy. That
- would at least allow those elements that are instantiated in
- both structures to be optimized well. */
-
- seq = NULL;
- generate_copy_inout (rhs_elt, false,
- generate_element_ref (rhs_elt), &seq);
- if (seq)
+ if (access->index)
{
- mark_all_v_defs_seq (seq);
- sra_insert_before (gsi, seq);
+ if (convert)
+ {
+ if (stmt_rhs)
+ {
+ if (non_blk)
+ ret = scalarize_non_blk_array_ref (access, safe_expr, expr,
+ seq, stmt_rhs);
+ else
+ {
+ ret = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expr),
+ repl);
+ ret = build4 (ARRAY_REF, TREE_TYPE (safe_expr), ret,
+ access->index, NULL_TREE, NULL_TREE);
+ }
+ }
+ else if (seq)
+ {
+ /* We can't do this at once, we need to use seq. */
+ gimple stmt;
+ tree sra_lhs, sra_rhs;
+ sra_lhs = make_rename_temp (TREE_TYPE (expr), "sra_tmp");
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expr),
+ repl);
+ stmt = gimple_build_assign (sra_lhs, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+
+ ret = build4 (ARRAY_REF, TREE_TYPE (safe_expr), sra_lhs,
+ access->index, NULL_TREE, NULL_TREE);
+ }
+ }
+ else
+ {
+ ret = build4 (ARRAY_REF, TREE_TYPE (safe_expr), repl,
+ access->index, NULL_TREE, NULL_TREE);
+ }
}
+ else if (stmt_rhs)
+ {
+ if (convert)
+ {
+ /* No streight CONVERT, please! */
+ gimple stmt;
+ tree sra_lhs, sra_rhs;
+ sra_lhs = make_rename_temp (TREE_TYPE (repl), "sra_tmp2");
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (repl),
+ *stmt_rhs);
+ stmt = gimple_build_assign (sra_lhs, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
- seq = NULL;
- generate_copy_inout (lhs_elt, true,
- generate_element_ref (lhs_elt), &seq);
- if (seq)
+ *stmt_rhs = sra_lhs;
+ }
+
+ ret = repl;
+ }
+ else if (convert && seq)
{
- mark_all_v_defs_seq (seq);
- sra_insert_after (gsi, seq);
+ /* No streight CONVERT, please! */
+ gimple stmt;
+ tree sra_lhs, sra_rhs;
+ sra_lhs = make_rename_temp (TREE_TYPE (expr), "sra_tmp3");
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expr),
+ repl);
+ stmt = gimple_build_assign (sra_lhs, sra_rhs);
+ gimple_seq_add_stmt (seq, stmt);
+ ret = sra_lhs;
+
+ /* ret = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expr), repl); */
}
+ else
+ {
+ ret = repl;
+ }
}
else
{
- /* Otherwise both sides must be fully instantiated. In which
- case perform pair-wise element assignments and replace the
- original block copy statement. */
-
- stmt = gsi_stmt (*gsi);
- mark_all_v_defs_stmt (stmt);
-
- seq = NULL;
- generate_element_copy (lhs_elt, rhs_elt, &seq);
- gcc_assert (seq);
- mark_all_v_defs_seq (seq);
- sra_replace (gsi, seq);
+ ret = safe_expr;
}
+
+ return ret;
}
-/* Scalarize an INIT. To recap, this is an assignment to a scalarizable
- reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
- COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
- CONSTRUCTOR. */
+
+/* Mark all virtual operands from statement STMT to renaming. */
static void
-scalarize_init (struct sra_elt *lhs_elt, tree rhs, gimple_stmt_iterator *gsi)
+mark_all_virt_stmt (gimple stmt)
{
- bool result = true;
- gimple_seq seq = NULL, init_seq = NULL;
+ tree sym;
+ ssa_op_iter iter;
- /* Generate initialization statements for all members extant in the RHS. */
- if (rhs)
- {
- /* Unshare the expression just in case this is from a decl's initial. */
- rhs = unshare_expr (rhs);
- result = generate_element_init (lhs_elt, rhs, &init_seq);
- }
-
- if (!result)
- {
- /* If we failed to convert the entire initializer, then we must
- leave the structure assignment in place and must load values
- from the structure into the slots for which we did not find
- constants. The easiest way to do this is to generate a complete
- copy-out, and then follow that with the constant assignments
- that we were able to build. DCE will clean things up. */
- gimple_seq seq0 = NULL;
- generate_copy_inout (lhs_elt, true, generate_element_ref (lhs_elt),
- &seq0);
- gimple_seq_add_seq (&seq0, seq);
- seq = seq0;
- }
- else
- {
- /* CONSTRUCTOR is defined such that any member not mentioned is assigned
- a zero value. Initialize the rest of the instantiated elements. */
- generate_element_zero (lhs_elt, &seq);
- gimple_seq_add_seq (&seq, init_seq);
- }
+ update_stmt (stmt);
- if (lhs_elt->use_block_copy || !result)
- {
- /* Since LHS is not fully instantiated, we must leave the structure
- assignment in place. Treating this case differently from a USE
- exposes constants to later optimizations. */
- if (seq)
- {
- mark_all_v_defs_seq (seq);
- sra_insert_after (gsi, seq);
- }
- }
- else
+ FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
{
- /* The LHS is fully instantiated. The list of initializations
- replaces the original structure assignment. */
- gcc_assert (seq);
- mark_all_v_defs_stmt (gsi_stmt (*gsi));
- mark_all_v_defs_seq (seq);
- sra_replace (gsi, seq);
+ if (TREE_CODE (sym) == SSA_NAME)
+ sym = SSA_NAME_VAR (sym);
+ mark_sym_for_renaming (sym);
}
}
-/* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
- on all INDIRECT_REFs. */
-static tree
-mark_notrap (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
-{
- tree t = *tp;
+/* Mark all virtual operands from SEQ to renaming. */
- if (TREE_CODE (t) == INDIRECT_REF)
- {
- TREE_THIS_NOTRAP (t) = 1;
- *walk_subtrees = 0;
- }
- else if (IS_TYPE_OR_DECL_P (t))
- *walk_subtrees = 0;
+static void
+mark_all_virt_seq (gimple_seq seq)
+{
+ gimple_stmt_iterator gsi;
- return NULL;
+ for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
+ mark_all_virt_stmt (gsi_stmt (gsi));
}
-/* Scalarize a LDST. To recap, this is an assignment between one scalarizable
- reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
- if ELT is on the left-hand side. */
-static void
-scalarize_ldst (struct sra_elt *elt, tree other,
- gimple_stmt_iterator *gsi, bool is_output)
+/* Scalarize statement. Return true if any change has been made. */
+
+static bool
+scalarize_stmt (decomposed_gsi *dgsi)
{
- /* Shouldn't have gotten called for a scalar. */
- gcc_assert (!elt->replacement);
+ gimple_stmt_iterator gsi = dgsi->gsi;
+ gimple stmt = gsi_stmt (gsi);
+ tree arg1, t1, t2;
+ gimple_seq seq_before = NULL;
+ gimple_seq seq_after = NULL;
+ bool remove_stmt = false;
+ bool update = false;
+ bool ret = false;
+ unsigned i;
- if (elt->use_block_copy)
- {
- /* Since ELT is not fully instantiated, we have to leave the
- block copy in place. Treat this as a USE. */
- scalarize_use (elt, NULL, gsi, is_output, false);
- }
- else
+ switch (gimple_code (stmt))
{
- /* The interesting case is when ELT is fully instantiated. In this
- case we can have each element stored/loaded directly to/from the
- corresponding slot in OTHER. This avoids a block copy. */
-
- gimple_seq seq = NULL;
- gimple stmt = gsi_stmt (*gsi);
-
- mark_all_v_defs_stmt (stmt);
- generate_copy_inout (elt, is_output, other, &seq);
- gcc_assert (seq);
- mark_all_v_defs_seq (seq);
-
- /* Preserve EH semantics. */
- if (stmt_ends_bb_p (stmt))
+ case GIMPLE_RETURN:
+ if (gimple_return_retval (stmt) != NULL_TREE)
{
- gimple_stmt_iterator si;
- gimple first;
- gimple_seq blist = NULL;
- bool thr = stmt_could_throw_p (stmt);
-
- /* If the last statement of this BB created an EH edge
- before scalarization, we have to locate the first
- statement that can throw in the new statement list and
- use that as the last statement of this BB, such that EH
- semantics is preserved. All statements up to this one
- are added to the same BB. All other statements in the
- list will be added to normal outgoing edges of the same
- BB. If they access any memory, it's the same memory, so
- we can assume they won't throw. */
- si = gsi_start (seq);
- for (first = gsi_stmt (si);
- thr && !gsi_end_p (si) && !stmt_could_throw_p (first);
- first = gsi_stmt (si))
+ t1 = gimple_return_retval (stmt);
+ t2 = scalarize_expr (t1, &seq_before, NULL);
+ if (t1 != t2)
{
- gsi_remove (&si, false);
- gimple_seq_add_stmt (&blist, first);
+ gimple_return_set_retval (stmt, t2);
+ update = true;
}
+ }
+ break;
- /* Extract the first remaining statement from LIST, this is
- the EH statement if there is one. */
- gsi_remove (&si, false);
+ case GIMPLE_ASSIGN:
+ t1 = gimple_assign_rhs1 (stmt);
+ t2 = scalarize_expr (t1, &seq_before, NULL);
+ if (t1 != t2)
+ {
+ gimple_assign_set_rhs_from_tree (&gsi, t2);
+ stmt = gsi_stmt (gsi); /* who knows.... */
+ update = true;
+ }
- if (blist)
- sra_insert_before (gsi, blist);
+ arg1 = gimple_assign_rhs1 (stmt);
+ t1 = gimple_assign_lhs (stmt);
+ t2 = scalarize_expr (t1 , &seq_before, &arg1);
+ if (t1 != t2 && t2 != NULL)
+ {
+ gimple_assign_set_lhs (stmt, t2);
+ update = true;
+ }
- /* Replace the old statement with this new representative. */
- gsi_replace (gsi, first, true);
+ if (arg1 == NULL_TREE)
+ {
+ /* Just remove old statement. Everything is on the list. */
+ remove_stmt = true;
+ }
+ else if (gimple_assign_rhs1 (stmt) != arg1)
+ {
+ gimple_assign_set_rhs_from_tree (&gsi, arg1);
+ update = true;
+ }
+ break;
- if (!gsi_end_p (si))
+ case GIMPLE_CALL:
+ if (gimple_call_lhs (stmt))
+ {
+ t1 = gimple_call_lhs (stmt);
+ t2 = scalarize_expr (t1, NULL, NULL);
+ if (t1 != t2)
{
- /* If any reference would trap, then they all would. And more
- to the point, the first would. Therefore none of the rest
- will trap since the first didn't. Indicate this by
- iterating over the remaining statements and set
- TREE_THIS_NOTRAP in all INDIRECT_REFs. */
- do
- {
- walk_gimple_stmt (&si, NULL, mark_notrap, NULL);
- gsi_next (&si);
- }
- while (!gsi_end_p (si));
+ gimple new_stmt;
+ tree sra_tmp, sra_rhs;
+
+ sra_tmp = make_rename_temp (TREE_TYPE (t1), "sra_tmp4");
+ gimple_call_set_lhs (stmt, sra_tmp);
- insert_edge_copies_seq (seq, gsi_bb (*gsi));
+ sra_rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (t2),
+ sra_tmp);
+ /* t2 is a replacement */
+ new_stmt = gimple_build_assign (t2, sra_rhs);
+ gimple_seq_add_stmt (&seq_after, new_stmt);
+
+ update = true;
}
}
- else
- sra_replace (gsi, seq);
- }
-}
-/* Generate initializations for all scalarizable parameters. */
+ for (i = 0; i < gimple_call_num_args (stmt); i++)
+ {
+ t1 = gimple_call_arg (stmt, i);
+ t2 = scalarize_expr (t1, &seq_before, NULL);
+ if (t1 != t2)
+ {
+ gimple_call_set_arg (stmt, i, t2);
+ update = true;
+ }
+ }
+ break;
-static void
-scalarize_parms (void)
-{
- gimple_seq seq = NULL;
- unsigned i;
- bitmap_iterator bi;
+ case GIMPLE_ASM:
+ /* TODO */
- EXECUTE_IF_SET_IN_BITMAP (needs_copy_in, 0, i, bi)
- {
- tree var = referenced_var (i);
- struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
- generate_copy_inout (elt, true, var, &seq);
+ default:
+ break;
}
- if (seq)
+ if (seq_before)
{
- insert_edge_copies_seq (seq, ENTRY_BLOCK_PTR);
- mark_all_v_defs_seq (seq);
+ mark_all_virt_seq (seq_before);
+ gsi_insert_seq_before (&gsi, seq_before, GSI_SAME_STMT);
+ ret = true;
}
-}
-
-/* Entry point to phase 4. Update the function to match replacements. */
-
-static void
-scalarize_function (void)
-{
- static const struct sra_walk_fns fns = {
- scalarize_use, scalarize_copy, scalarize_init, scalarize_ldst, false
- };
-
- sra_walk_function (&fns);
- scalarize_parms ();
- gsi_commit_edge_inserts ();
-}
-\f
-/* Debug helper function. Print ELT in a nice human-readable format. */
+ if (seq_after)
+ {
+ mark_all_virt_seq (seq_after);
+ gsi_insert_seq_after (&gsi, seq_after, GSI_SAME_STMT);
+ ret = true;
+ }
-static void
-dump_sra_elt_name (FILE *f, struct sra_elt *elt)
-{
- if (elt->parent && TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
+ if (remove_stmt)
{
- fputs (elt->element == integer_zero_node ? "__real__ " : "__imag__ ", f);
- dump_sra_elt_name (f, elt->parent);
+ gsi_remove (&gsi, false);
+ ret = true;
}
- else
+ else if (update)
{
- if (elt->parent)
- dump_sra_elt_name (f, elt->parent);
- if (DECL_P (elt->element))
- {
- if (TREE_CODE (elt->element) == FIELD_DECL)
- fputc ('.', f);
- print_generic_expr (f, elt->element, dump_flags);
- }
- else if (TREE_CODE (elt->element) == BIT_FIELD_REF)
- fprintf (f, "$B" HOST_WIDE_INT_PRINT_DEC "F" HOST_WIDE_INT_PRINT_DEC,
- tree_low_cst (TREE_OPERAND (elt->element, 2), 1),
- tree_low_cst (TREE_OPERAND (elt->element, 1), 1));
- else if (TREE_CODE (elt->element) == RANGE_EXPR)
- fprintf (f, "["HOST_WIDE_INT_PRINT_DEC".."HOST_WIDE_INT_PRINT_DEC"]",
- TREE_INT_CST_LOW (TREE_OPERAND (elt->element, 0)),
- TREE_INT_CST_LOW (TREE_OPERAND (elt->element, 1)));
- else
- fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]",
- TREE_INT_CST_LOW (elt->element));
+ mark_all_virt_stmt (stmt);
+ update_stmt (stmt);
+ ret = true;
}
+
+ return ret;
}
-/* Likewise, but callable from the debugger. */
-void
-debug_sra_elt_name (struct sra_elt *elt)
-{
- dump_sra_elt_name (stderr, elt);
- fputc ('\n', stderr);
-}
+/* Scalarize all statements marked in `scan_function' stage. Return true if any
+ change has been made. */
-void
-sra_init_cache (void)
+static bool
+scalarize_function (void)
{
- if (sra_type_decomp_cache)
- return;
+ unsigned i;
+ bool ret = false;
+ decomposed_gsi *dgsi;
- sra_type_decomp_cache = BITMAP_ALLOC (NULL);
- sra_type_inst_cache = BITMAP_ALLOC (NULL);
+ for (i = 0; VEC_iterate (decomposed_gsi, decomposed_gsis, i, dgsi); i++)
+ ret |= scalarize_stmt (dgsi);
+
+ return ret;
}
-/* Main entry point. */
+/* Main entry point to the SRA pass. EARLY is true if function is called from
+ pass_sra_early. */
static unsigned int
-tree_sra (void)
+execute_sra (bool early)
{
- /* Initialize local variables. */
- todoflags = 0;
- gcc_obstack_init (&sra_obstack);
- sra_candidates = BITMAP_ALLOC (NULL);
- needs_copy_in = BITMAP_ALLOC (NULL);
- sra_init_cache ();
- sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL);
-
- /* Scan. If we find anything, instantiate and scalarize. */
- if (find_candidates_for_sra ())
- {
- scan_function ();
- decide_instantiations ();
- scalarize_function ();
- if (!bitmap_empty_p (sra_candidates))
- todoflags |= TODO_rebuild_alias;
- }
-
- /* Free allocated memory. */
- htab_delete (sra_map);
- sra_map = NULL;
- BITMAP_FREE (sra_candidates);
- BITMAP_FREE (needs_copy_in);
- BITMAP_FREE (sra_type_decomp_cache);
- BITMAP_FREE (sra_type_inst_cache);
- obstack_free (&sra_obstack, NULL);
- return todoflags;
+ unsigned int ret = 0;
+
+ sra_init ();
+
+ if (! find_base_candidates ())
+ goto deinit;
+
+ if (! scan_function ())
+ goto deinit;
+
+ if (! analyze_accesses ())
+ goto deinit;
+
+ if (! scalarize_function ())
+ goto deinit;
+
+ ret = TODO_ggc_collect | TODO_verify_ssa
+ | TODO_remove_unused_locals | TODO_verify_flow;
+
+ if (!early)
+ ret |= TODO_rebuild_alias;
+
+deinit:
+ sra_deinit ();
+
+ return ret;
}
+
+/* Gate and execute functions for SRA. */
+
static unsigned int
tree_sra_early (void)
{
- unsigned int ret;
+ return execute_sra (true);
+}
- early_sra = true;
- ret = tree_sra ();
- early_sra = false;
- return ret & ~TODO_rebuild_alias;
+static unsigned int
+tree_sra (void)
+{
+ return execute_sra (false);
}
+
static bool
gate_sra (void)
{
return flag_tree_sra != 0;
}
+
struct gimple_opt_pass pass_sra_early =
{
- {
+{
GIMPLE_PASS,
"esra", /* name */
gate_sra, /* gate */
@@ -3718,18 +1359,16 @@ struct gimple_opt_pass pass_sra_early =
TV_TREE_SRA, /* tv_id */
PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
- 0, /* properties_destroyed */
+ 0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func
- | TODO_update_ssa
- | TODO_ggc_collect
- | TODO_verify_ssa /* todo_flags_finish */
- }
+ TODO_dump_func | TODO_update_ssa /* todo_flags_finish */
+}
};
+
struct gimple_opt_pass pass_sra =
{
- {
+{
GIMPLE_PASS,
"sra", /* name */
gate_sra, /* gate */
@@ -3740,11 +1379,8 @@ struct gimple_opt_pass pass_sra =
TV_TREE_SRA, /* tv_id */
PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
- 0, /* properties_destroyed */
+ 0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func
- | TODO_update_ssa
- | TODO_ggc_collect
- | TODO_verify_ssa /* todo_flags_finish */
- }
+ TODO_dump_func | TODO_update_ssa /* todo_flags_finish */
+}
};
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2008-08-29 13:02 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2004-06-29 18:58 New SRA implementation Richard Henderson
2004-06-29 20:03 ` Paolo Carlini
2004-06-29 20:12 ` Richard Henderson
2004-06-29 20:51 ` Andrew Pinski
2004-07-10 17:17 ` Roman Zippel
2008-08-30 20:53 New SRA Implementation Jakub Staszak
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).