mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-22 11:17:19 +00:00
2633 lines
74 KiB
C
2633 lines
74 KiB
C
/* Conditional constant propagation pass for the GNU compiler.
|
||
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
||
Free Software Foundation, Inc.
|
||
Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
|
||
Adapted to GIMPLE trees 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, 51 Franklin Street, Fifth Floor, Boston, MA
|
||
02110-1301, USA. */
|
||
|
||
/* Conditional constant propagation (CCP) is based on the SSA
|
||
propagation engine (tree-ssa-propagate.c). Constant assignments of
|
||
the form VAR = CST are propagated from the assignments into uses of
|
||
VAR, which in turn may generate new constants. The simulation uses
|
||
a four level lattice to keep track of constant values associated
|
||
with SSA names. Given an SSA name V_i, it may take one of the
|
||
following values:
|
||
|
||
UNINITIALIZED -> This is the default starting value. V_i
|
||
has not been processed yet.
|
||
|
||
UNDEFINED -> V_i is a local variable whose definition
|
||
has not been processed yet. Therefore we
|
||
don't yet know if its value is a constant
|
||
or not.
|
||
|
||
CONSTANT -> V_i has been found to hold a constant
|
||
value C.
|
||
|
||
VARYING -> V_i cannot take a constant value, or if it
|
||
does, it is not possible to determine it
|
||
at compile time.
|
||
|
||
The core of SSA-CCP is in ccp_visit_stmt and ccp_visit_phi_node:
|
||
|
||
1- In ccp_visit_stmt, we are interested in assignments whose RHS
|
||
evaluates into a constant and conditional jumps whose predicate
|
||
evaluates into a boolean true or false. When an assignment of
|
||
the form V_i = CONST is found, V_i's lattice value is set to
|
||
CONSTANT and CONST is associated with it. This causes the
|
||
propagation engine to add all the SSA edges coming out the
|
||
assignment into the worklists, so that statements that use V_i
|
||
can be visited.
|
||
|
||
If the statement is a conditional with a constant predicate, we
|
||
mark the outgoing edges as executable or not executable
|
||
depending on the predicate's value. This is then used when
|
||
visiting PHI nodes to know when a PHI argument can be ignored.
|
||
|
||
|
||
2- In ccp_visit_phi_node, if all the PHI arguments evaluate to the
|
||
same constant C, then the LHS of the PHI is set to C. This
|
||
evaluation is known as the "meet operation". Since one of the
|
||
goals of this evaluation is to optimistically return constant
|
||
values as often as possible, it uses two main short cuts:
|
||
|
||
- If an argument is flowing in through a non-executable edge, it
|
||
is ignored. This is useful in cases like this:
|
||
|
||
if (PRED)
|
||
a_9 = 3;
|
||
else
|
||
a_10 = 100;
|
||
a_11 = PHI (a_9, a_10)
|
||
|
||
If PRED is known to always evaluate to false, then we can
|
||
assume that a_11 will always take its value from a_10, meaning
|
||
that instead of consider it VARYING (a_9 and a_10 have
|
||
different values), we can consider it CONSTANT 100.
|
||
|
||
- If an argument has an UNDEFINED value, then it does not affect
|
||
the outcome of the meet operation. If a variable V_i has an
|
||
UNDEFINED value, it means that either its defining statement
|
||
hasn't been visited yet or V_i has no defining statement, in
|
||
which case the original symbol 'V' is being used
|
||
uninitialized. Since 'V' is a local variable, the compiler
|
||
may assume any initial value for it.
|
||
|
||
|
||
After propagation, every variable V_i that ends up with a lattice
|
||
value of CONSTANT will have the associated constant value in the
|
||
array CONST_VAL[i].VALUE. That is fed into substitute_and_fold for
|
||
final substitution and folding.
|
||
|
||
|
||
Constant propagation in stores and loads (STORE-CCP)
|
||
----------------------------------------------------
|
||
|
||
While CCP has all the logic to propagate constants in GIMPLE
|
||
registers, it is missing the ability to associate constants with
|
||
stores and loads (i.e., pointer dereferences, structures and
|
||
global/aliased variables). We don't keep loads and stores in
|
||
SSA, but we do build a factored use-def web for them (in the
|
||
virtual operands).
|
||
|
||
For instance, consider the following code fragment:
|
||
|
||
struct A a;
|
||
const int B = 42;
|
||
|
||
void foo (int i)
|
||
{
|
||
if (i > 10)
|
||
a.a = 42;
|
||
else
|
||
{
|
||
a.b = 21;
|
||
a.a = a.b + 21;
|
||
}
|
||
|
||
if (a.a != B)
|
||
never_executed ();
|
||
}
|
||
|
||
We should be able to deduce that the predicate 'a.a != B' is always
|
||
false. To achieve this, we associate constant values to the SSA
|
||
names in the V_MAY_DEF and V_MUST_DEF operands for each store.
|
||
Additionally, since we also glob partial loads/stores with the base
|
||
symbol, we also keep track of the memory reference where the
|
||
constant value was stored (in the MEM_REF field of PROP_VALUE_T).
|
||
For instance,
|
||
|
||
# a_5 = V_MAY_DEF <a_4>
|
||
a.a = 2;
|
||
|
||
# VUSE <a_5>
|
||
x_3 = a.b;
|
||
|
||
In the example above, CCP will associate value '2' with 'a_5', but
|
||
it would be wrong to replace the load from 'a.b' with '2', because
|
||
'2' had been stored into a.a.
|
||
|
||
To support STORE-CCP, it is necessary to add a new value to the
|
||
constant propagation lattice. When evaluating a load for a memory
|
||
reference we can no longer assume a value of UNDEFINED if we
|
||
haven't seen a preceding store to the same memory location.
|
||
Consider, for instance global variables:
|
||
|
||
int A;
|
||
|
||
foo (int i)
|
||
{
|
||
if (i_3 > 10)
|
||
A_4 = 3;
|
||
# A_5 = PHI (A_4, A_2);
|
||
|
||
# VUSE <A_5>
|
||
A.0_6 = A;
|
||
|
||
return A.0_6;
|
||
}
|
||
|
||
The value of A_2 cannot be assumed to be UNDEFINED, as it may have
|
||
been defined outside of foo. If we were to assume it UNDEFINED, we
|
||
would erroneously optimize the above into 'return 3;'. Therefore,
|
||
when doing STORE-CCP, we introduce a fifth lattice value
|
||
(UNKNOWN_VAL), which overrides any other value when computing the
|
||
meet operation in PHI nodes.
|
||
|
||
Though STORE-CCP is not too expensive, it does have to do more work
|
||
than regular CCP, so it is only enabled at -O2. Both regular CCP
|
||
and STORE-CCP use the exact same algorithm. The only distinction
|
||
is that when doing STORE-CCP, the boolean variable DO_STORE_CCP is
|
||
set to true. This affects the evaluation of statements and PHI
|
||
nodes.
|
||
|
||
References:
|
||
|
||
Constant propagation with conditional branches,
|
||
Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
|
||
|
||
Building an Optimizing Compiler,
|
||
Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
|
||
|
||
Advanced Compiler Design and Implementation,
|
||
Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
|
||
|
||
#include "config.h"
|
||
#include "system.h"
|
||
#include "coretypes.h"
|
||
#include "tm.h"
|
||
#include "tree.h"
|
||
#include "flags.h"
|
||
#include "rtl.h"
|
||
#include "tm_p.h"
|
||
#include "ggc.h"
|
||
#include "basic-block.h"
|
||
#include "output.h"
|
||
#include "expr.h"
|
||
#include "function.h"
|
||
#include "diagnostic.h"
|
||
#include "timevar.h"
|
||
#include "tree-dump.h"
|
||
#include "tree-flow.h"
|
||
#include "tree-pass.h"
|
||
#include "tree-ssa-propagate.h"
|
||
#include "langhooks.h"
|
||
#include "target.h"
|
||
#include "toplev.h"
|
||
|
||
|
||
/* Possible lattice values. */
|
||
typedef enum
|
||
{
|
||
UNINITIALIZED = 0,
|
||
UNDEFINED,
|
||
UNKNOWN_VAL,
|
||
CONSTANT,
|
||
VARYING
|
||
} ccp_lattice_t;
|
||
|
||
/* Array of propagated constant values. After propagation,
|
||
CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
|
||
the constant is held in an SSA name representing a memory store
|
||
(i.e., a V_MAY_DEF or V_MUST_DEF), CONST_VAL[I].MEM_REF will
|
||
contain the actual memory reference used to store (i.e., the LHS of
|
||
the assignment doing the store). */
|
||
static prop_value_t *const_val;
|
||
|
||
/* True if we are also propagating constants in stores and loads. */
|
||
static bool do_store_ccp;
|
||
|
||
/* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
|
||
|
||
static void
|
||
dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val)
|
||
{
|
||
switch (val.lattice_val)
|
||
{
|
||
case UNINITIALIZED:
|
||
fprintf (outf, "%sUNINITIALIZED", prefix);
|
||
break;
|
||
case UNDEFINED:
|
||
fprintf (outf, "%sUNDEFINED", prefix);
|
||
break;
|
||
case VARYING:
|
||
fprintf (outf, "%sVARYING", prefix);
|
||
break;
|
||
case UNKNOWN_VAL:
|
||
fprintf (outf, "%sUNKNOWN_VAL", prefix);
|
||
break;
|
||
case CONSTANT:
|
||
fprintf (outf, "%sCONSTANT ", prefix);
|
||
print_generic_expr (outf, val.value, dump_flags);
|
||
break;
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
}
|
||
|
||
|
||
/* Print lattice value VAL to stderr. */
|
||
|
||
void debug_lattice_value (prop_value_t val);
|
||
|
||
void
|
||
debug_lattice_value (prop_value_t val)
|
||
{
|
||
dump_lattice_value (stderr, "", val);
|
||
fprintf (stderr, "\n");
|
||
}
|
||
|
||
|
||
/* The regular is_gimple_min_invariant does a shallow test of the object.
|
||
It assumes that full gimplification has happened, or will happen on the
|
||
object. For a value coming from DECL_INITIAL, this is not true, so we
|
||
have to be more strict ourselves. */
|
||
|
||
static bool
|
||
ccp_decl_initial_min_invariant (tree t)
|
||
{
|
||
if (!is_gimple_min_invariant (t))
|
||
return false;
|
||
if (TREE_CODE (t) == ADDR_EXPR)
|
||
{
|
||
/* Inline and unroll is_gimple_addressable. */
|
||
while (1)
|
||
{
|
||
t = TREE_OPERAND (t, 0);
|
||
if (is_gimple_id (t))
|
||
return true;
|
||
if (!handled_component_p (t))
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
/* Compute a default value for variable VAR and store it in the
|
||
CONST_VAL array. The following rules are used to get default
|
||
values:
|
||
|
||
1- Global and static variables that are declared constant are
|
||
considered CONSTANT.
|
||
|
||
2- Any other value is considered UNDEFINED. This is useful when
|
||
considering PHI nodes. PHI arguments that are undefined do not
|
||
change the constant value of the PHI node, which allows for more
|
||
constants to be propagated.
|
||
|
||
3- If SSA_NAME_VALUE is set and it is a constant, its value is
|
||
used.
|
||
|
||
4- Variables defined by statements other than assignments and PHI
|
||
nodes are considered VARYING.
|
||
|
||
5- Variables that are not GIMPLE registers are considered
|
||
UNKNOWN_VAL, which is really a stronger version of UNDEFINED.
|
||
It's used to avoid the short circuit evaluation implied by
|
||
UNDEFINED in ccp_lattice_meet. */
|
||
|
||
static prop_value_t
|
||
get_default_value (tree var)
|
||
{
|
||
tree sym = SSA_NAME_VAR (var);
|
||
prop_value_t val = { UNINITIALIZED, NULL_TREE, NULL_TREE };
|
||
|
||
if (!do_store_ccp && !is_gimple_reg (var))
|
||
{
|
||
/* Short circuit for regular CCP. We are not interested in any
|
||
non-register when DO_STORE_CCP is false. */
|
||
val.lattice_val = VARYING;
|
||
}
|
||
else if (SSA_NAME_VALUE (var)
|
||
&& is_gimple_min_invariant (SSA_NAME_VALUE (var)))
|
||
{
|
||
val.lattice_val = CONSTANT;
|
||
val.value = SSA_NAME_VALUE (var);
|
||
}
|
||
else if (TREE_STATIC (sym)
|
||
&& TREE_READONLY (sym)
|
||
&& !MTAG_P (sym)
|
||
&& DECL_INITIAL (sym)
|
||
&& ccp_decl_initial_min_invariant (DECL_INITIAL (sym)))
|
||
{
|
||
/* Globals and static variables declared 'const' take their
|
||
initial value. */
|
||
val.lattice_val = CONSTANT;
|
||
val.value = DECL_INITIAL (sym);
|
||
val.mem_ref = sym;
|
||
}
|
||
else
|
||
{
|
||
tree stmt = SSA_NAME_DEF_STMT (var);
|
||
|
||
if (IS_EMPTY_STMT (stmt))
|
||
{
|
||
/* Variables defined by an empty statement are those used
|
||
before being initialized. If VAR is a local variable, we
|
||
can assume initially that it is UNDEFINED. If we are
|
||
doing STORE-CCP, function arguments and non-register
|
||
variables are initially UNKNOWN_VAL, because we cannot
|
||
discard the value incoming from outside of this function
|
||
(see ccp_lattice_meet for details). */
|
||
if (is_gimple_reg (sym) && TREE_CODE (sym) != PARM_DECL)
|
||
val.lattice_val = UNDEFINED;
|
||
else if (do_store_ccp)
|
||
val.lattice_val = UNKNOWN_VAL;
|
||
else
|
||
val.lattice_val = VARYING;
|
||
}
|
||
else if (TREE_CODE (stmt) == MODIFY_EXPR
|
||
|| TREE_CODE (stmt) == PHI_NODE)
|
||
{
|
||
/* Any other variable defined by an assignment or a PHI node
|
||
is considered UNDEFINED (or UNKNOWN_VAL if VAR is not a
|
||
GIMPLE register). */
|
||
val.lattice_val = is_gimple_reg (sym) ? UNDEFINED : UNKNOWN_VAL;
|
||
}
|
||
else
|
||
{
|
||
/* Otherwise, VAR will never take on a constant value. */
|
||
val.lattice_val = VARYING;
|
||
}
|
||
}
|
||
|
||
return val;
|
||
}
|
||
|
||
|
||
/* Get the constant value associated with variable VAR. If
|
||
MAY_USE_DEFAULT_P is true, call get_default_value on variables that
|
||
have the lattice value UNINITIALIZED. */
|
||
|
||
static prop_value_t *
|
||
get_value (tree var, bool may_use_default_p)
|
||
{
|
||
prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
|
||
if (may_use_default_p && val->lattice_val == UNINITIALIZED)
|
||
*val = get_default_value (var);
|
||
|
||
return val;
|
||
}
|
||
|
||
|
||
/* Set the value for variable VAR to NEW_VAL. Return true if the new
|
||
value is different from VAR's previous value. */
|
||
|
||
static bool
|
||
set_lattice_value (tree var, prop_value_t new_val)
|
||
{
|
||
prop_value_t *old_val = get_value (var, false);
|
||
|
||
/* Lattice transitions must always be monotonically increasing in
|
||
value. We allow two exceptions:
|
||
|
||
1- If *OLD_VAL and NEW_VAL are the same, return false to
|
||
inform the caller that this was a non-transition.
|
||
|
||
2- If we are doing store-ccp (i.e., DOING_STORE_CCP is true),
|
||
allow CONSTANT->UNKNOWN_VAL. The UNKNOWN_VAL state is a
|
||
special type of UNDEFINED state which prevents the short
|
||
circuit evaluation of PHI arguments (see ccp_visit_phi_node
|
||
and ccp_lattice_meet). */
|
||
gcc_assert (old_val->lattice_val <= new_val.lattice_val
|
||
|| (old_val->lattice_val == new_val.lattice_val
|
||
&& old_val->value == new_val.value
|
||
&& old_val->mem_ref == new_val.mem_ref)
|
||
|| (do_store_ccp
|
||
&& old_val->lattice_val == CONSTANT
|
||
&& new_val.lattice_val == UNKNOWN_VAL));
|
||
|
||
if (old_val->lattice_val != new_val.lattice_val)
|
||
{
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
dump_lattice_value (dump_file, "Lattice value changed to ", new_val);
|
||
fprintf (dump_file, ". %sdding SSA edges to worklist.\n",
|
||
new_val.lattice_val != UNDEFINED ? "A" : "Not a");
|
||
}
|
||
|
||
*old_val = new_val;
|
||
|
||
/* Transitions UNINITIALIZED -> UNDEFINED are never interesting
|
||
for propagation purposes. In these cases return false to
|
||
avoid doing useless work. */
|
||
return (new_val.lattice_val != UNDEFINED);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/* Return the likely CCP lattice value for STMT.
|
||
|
||
If STMT has no operands, then return CONSTANT.
|
||
|
||
Else if any operands of STMT are undefined, then return UNDEFINED.
|
||
|
||
Else if any operands of STMT are constants, then return CONSTANT.
|
||
|
||
Else return VARYING. */
|
||
|
||
static ccp_lattice_t
|
||
likely_value (tree stmt)
|
||
{
|
||
bool found_constant;
|
||
stmt_ann_t ann;
|
||
tree use;
|
||
ssa_op_iter iter;
|
||
|
||
ann = stmt_ann (stmt);
|
||
|
||
/* If the statement has volatile operands, it won't fold to a
|
||
constant value. */
|
||
if (ann->has_volatile_ops)
|
||
return VARYING;
|
||
|
||
/* If we are not doing store-ccp, statements with loads
|
||
and/or stores will never fold into a constant. */
|
||
if (!do_store_ccp
|
||
&& !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
|
||
return VARYING;
|
||
|
||
|
||
/* A CALL_EXPR is assumed to be varying. NOTE: This may be overly
|
||
conservative, in the presence of const and pure calls. */
|
||
if (get_call_expr_in (stmt) != NULL_TREE)
|
||
return VARYING;
|
||
|
||
/* Anything other than assignments and conditional jumps are not
|
||
interesting for CCP. */
|
||
if (TREE_CODE (stmt) != MODIFY_EXPR
|
||
&& TREE_CODE (stmt) != COND_EXPR
|
||
&& TREE_CODE (stmt) != SWITCH_EXPR)
|
||
return VARYING;
|
||
|
||
if (is_gimple_min_invariant (get_rhs (stmt)))
|
||
return CONSTANT;
|
||
|
||
found_constant = false;
|
||
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
|
||
{
|
||
prop_value_t *val = get_value (use, true);
|
||
|
||
if (val->lattice_val == VARYING)
|
||
return VARYING;
|
||
|
||
if (val->lattice_val == UNKNOWN_VAL)
|
||
{
|
||
/* UNKNOWN_VAL is invalid when not doing STORE-CCP. */
|
||
gcc_assert (do_store_ccp);
|
||
return UNKNOWN_VAL;
|
||
}
|
||
|
||
if (val->lattice_val == CONSTANT)
|
||
found_constant = true;
|
||
}
|
||
|
||
if (found_constant
|
||
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_USE)
|
||
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE))
|
||
return CONSTANT;
|
||
|
||
return UNDEFINED;
|
||
}
|
||
|
||
|
||
/* Initialize local data structures for CCP. */
|
||
|
||
static void
|
||
ccp_initialize (void)
|
||
{
|
||
basic_block bb;
|
||
|
||
const_val = XNEWVEC (prop_value_t, num_ssa_names);
|
||
memset (const_val, 0, num_ssa_names * sizeof (*const_val));
|
||
|
||
/* Initialize simulation flags for PHI nodes and statements. */
|
||
FOR_EACH_BB (bb)
|
||
{
|
||
block_stmt_iterator i;
|
||
|
||
for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
|
||
{
|
||
bool is_varying = false;
|
||
tree stmt = bsi_stmt (i);
|
||
|
||
if (likely_value (stmt) == VARYING)
|
||
|
||
{
|
||
tree def;
|
||
ssa_op_iter iter;
|
||
|
||
/* If the statement will not produce a constant, mark
|
||
all its outputs VARYING. */
|
||
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
|
||
get_value (def, false)->lattice_val = VARYING;
|
||
|
||
/* Never mark conditional jumps with DONT_SIMULATE_AGAIN,
|
||
otherwise the propagator will never add the outgoing
|
||
control edges. */
|
||
if (TREE_CODE (stmt) != COND_EXPR
|
||
&& TREE_CODE (stmt) != SWITCH_EXPR)
|
||
is_varying = true;
|
||
}
|
||
|
||
DONT_SIMULATE_AGAIN (stmt) = is_varying;
|
||
}
|
||
}
|
||
|
||
/* Now process PHI nodes. */
|
||
FOR_EACH_BB (bb)
|
||
{
|
||
tree phi;
|
||
|
||
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
||
{
|
||
int i;
|
||
tree arg;
|
||
prop_value_t *val = get_value (PHI_RESULT (phi), false);
|
||
|
||
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
|
||
{
|
||
arg = PHI_ARG_DEF (phi, i);
|
||
|
||
if (TREE_CODE (arg) == SSA_NAME
|
||
&& get_value (arg, false)->lattice_val == VARYING)
|
||
{
|
||
val->lattice_val = VARYING;
|
||
break;
|
||
}
|
||
}
|
||
|
||
DONT_SIMULATE_AGAIN (phi) = (val->lattice_val == VARYING);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* Do final substitution of propagated values, cleanup the flowgraph and
|
||
free allocated storage. */
|
||
|
||
static void
|
||
ccp_finalize (void)
|
||
{
|
||
/* Perform substitutions based on the known constant values. */
|
||
substitute_and_fold (const_val, false);
|
||
|
||
free (const_val);
|
||
}
|
||
|
||
|
||
/* Compute the meet operator between *VAL1 and *VAL2. Store the result
|
||
in VAL1.
|
||
|
||
any M UNDEFINED = any
|
||
any M UNKNOWN_VAL = UNKNOWN_VAL
|
||
any M VARYING = VARYING
|
||
Ci M Cj = Ci if (i == j)
|
||
Ci M Cj = VARYING if (i != j)
|
||
|
||
Lattice values UNKNOWN_VAL and UNDEFINED are similar but have
|
||
different semantics at PHI nodes. Both values imply that we don't
|
||
know whether the variable is constant or not. However, UNKNOWN_VAL
|
||
values override all others. For instance, suppose that A is a
|
||
global variable:
|
||
|
||
+------+
|
||
| |
|
||
| / \
|
||
| / \
|
||
| | A_1 = 4
|
||
| \ /
|
||
| \ /
|
||
| A_3 = PHI (A_2, A_1)
|
||
| ... = A_3
|
||
| |
|
||
+----+
|
||
|
||
If the edge into A_2 is not executable, the first visit to A_3 will
|
||
yield the constant 4. But the second visit to A_3 will be with A_2
|
||
in state UNKNOWN_VAL. We can no longer conclude that A_3 is 4
|
||
because A_2 may have been set in another function. If we had used
|
||
the lattice value UNDEFINED, we would have had wrongly concluded
|
||
that A_3 is 4. */
|
||
|
||
|
||
static void
|
||
ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
|
||
{
|
||
if (val1->lattice_val == UNDEFINED)
|
||
{
|
||
/* UNDEFINED M any = any */
|
||
*val1 = *val2;
|
||
}
|
||
else if (val2->lattice_val == UNDEFINED)
|
||
{
|
||
/* any M UNDEFINED = any
|
||
Nothing to do. VAL1 already contains the value we want. */
|
||
;
|
||
}
|
||
else if (val1->lattice_val == UNKNOWN_VAL
|
||
|| val2->lattice_val == UNKNOWN_VAL)
|
||
{
|
||
/* UNKNOWN_VAL values are invalid if we are not doing STORE-CCP. */
|
||
gcc_assert (do_store_ccp);
|
||
|
||
/* any M UNKNOWN_VAL = UNKNOWN_VAL. */
|
||
val1->lattice_val = UNKNOWN_VAL;
|
||
val1->value = NULL_TREE;
|
||
val1->mem_ref = NULL_TREE;
|
||
}
|
||
else if (val1->lattice_val == VARYING
|
||
|| val2->lattice_val == VARYING)
|
||
{
|
||
/* any M VARYING = VARYING. */
|
||
val1->lattice_val = VARYING;
|
||
val1->value = NULL_TREE;
|
||
val1->mem_ref = NULL_TREE;
|
||
}
|
||
else if (val1->lattice_val == CONSTANT
|
||
&& val2->lattice_val == CONSTANT
|
||
&& simple_cst_equal (val1->value, val2->value) == 1
|
||
&& (!do_store_ccp
|
||
|| (val1->mem_ref && val2->mem_ref
|
||
&& operand_equal_p (val1->mem_ref, val2->mem_ref, 0))))
|
||
{
|
||
/* Ci M Cj = Ci if (i == j)
|
||
Ci M Cj = VARYING if (i != j)
|
||
|
||
If these two values come from memory stores, make sure that
|
||
they come from the same memory reference. */
|
||
val1->lattice_val = CONSTANT;
|
||
val1->value = val1->value;
|
||
val1->mem_ref = val1->mem_ref;
|
||
}
|
||
else
|
||
{
|
||
/* Any other combination is VARYING. */
|
||
val1->lattice_val = VARYING;
|
||
val1->value = NULL_TREE;
|
||
val1->mem_ref = NULL_TREE;
|
||
}
|
||
}
|
||
|
||
|
||
/* Loop through the PHI_NODE's parameters for BLOCK and compare their
|
||
lattice values to determine PHI_NODE's lattice value. The value of a
|
||
PHI node is determined calling ccp_lattice_meet with all the arguments
|
||
of the PHI node that are incoming via executable edges. */
|
||
|
||
static enum ssa_prop_result
|
||
ccp_visit_phi_node (tree phi)
|
||
{
|
||
int i;
|
||
prop_value_t *old_val, new_val;
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file, "\nVisiting PHI node: ");
|
||
print_generic_expr (dump_file, phi, dump_flags);
|
||
}
|
||
|
||
old_val = get_value (PHI_RESULT (phi), false);
|
||
switch (old_val->lattice_val)
|
||
{
|
||
case VARYING:
|
||
return SSA_PROP_VARYING;
|
||
|
||
case CONSTANT:
|
||
new_val = *old_val;
|
||
break;
|
||
|
||
case UNKNOWN_VAL:
|
||
/* To avoid the default value of UNKNOWN_VAL overriding
|
||
that of its possible constant arguments, temporarily
|
||
set the PHI node's default lattice value to be
|
||
UNDEFINED. If the PHI node's old value was UNKNOWN_VAL and
|
||
the new value is UNDEFINED, then we prevent the invalid
|
||
transition by not calling set_lattice_value. */
|
||
gcc_assert (do_store_ccp);
|
||
|
||
/* FALLTHRU */
|
||
|
||
case UNDEFINED:
|
||
case UNINITIALIZED:
|
||
new_val.lattice_val = UNDEFINED;
|
||
new_val.value = NULL_TREE;
|
||
new_val.mem_ref = NULL_TREE;
|
||
break;
|
||
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
|
||
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
|
||
{
|
||
/* Compute the meet operator over all the PHI arguments flowing
|
||
through executable edges. */
|
||
edge e = PHI_ARG_EDGE (phi, i);
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file,
|
||
"\n Argument #%d (%d -> %d %sexecutable)\n",
|
||
i, e->src->index, e->dest->index,
|
||
(e->flags & EDGE_EXECUTABLE) ? "" : "not ");
|
||
}
|
||
|
||
/* If the incoming edge is executable, Compute the meet operator for
|
||
the existing value of the PHI node and the current PHI argument. */
|
||
if (e->flags & EDGE_EXECUTABLE)
|
||
{
|
||
tree arg = PHI_ARG_DEF (phi, i);
|
||
prop_value_t arg_val;
|
||
|
||
if (is_gimple_min_invariant (arg))
|
||
{
|
||
arg_val.lattice_val = CONSTANT;
|
||
arg_val.value = arg;
|
||
arg_val.mem_ref = NULL_TREE;
|
||
}
|
||
else
|
||
arg_val = *(get_value (arg, true));
|
||
|
||
ccp_lattice_meet (&new_val, &arg_val);
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file, "\t");
|
||
print_generic_expr (dump_file, arg, dump_flags);
|
||
dump_lattice_value (dump_file, "\tValue: ", arg_val);
|
||
fprintf (dump_file, "\n");
|
||
}
|
||
|
||
if (new_val.lattice_val == VARYING)
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
|
||
fprintf (dump_file, "\n\n");
|
||
}
|
||
|
||
/* Check for an invalid change from UNKNOWN_VAL to UNDEFINED. */
|
||
if (do_store_ccp
|
||
&& old_val->lattice_val == UNKNOWN_VAL
|
||
&& new_val.lattice_val == UNDEFINED)
|
||
return SSA_PROP_NOT_INTERESTING;
|
||
|
||
/* Otherwise, make the transition to the new value. */
|
||
if (set_lattice_value (PHI_RESULT (phi), new_val))
|
||
{
|
||
if (new_val.lattice_val == VARYING)
|
||
return SSA_PROP_VARYING;
|
||
else
|
||
return SSA_PROP_INTERESTING;
|
||
}
|
||
else
|
||
return SSA_PROP_NOT_INTERESTING;
|
||
}
|
||
|
||
|
||
/* CCP specific front-end to the non-destructive constant folding
|
||
routines.
|
||
|
||
Attempt to simplify the RHS of STMT knowing that one or more
|
||
operands are constants.
|
||
|
||
If simplification is possible, return the simplified RHS,
|
||
otherwise return the original RHS. */
|
||
|
||
static tree
|
||
ccp_fold (tree stmt)
|
||
{
|
||
tree rhs = get_rhs (stmt);
|
||
enum tree_code code = TREE_CODE (rhs);
|
||
enum tree_code_class kind = TREE_CODE_CLASS (code);
|
||
tree retval = NULL_TREE;
|
||
|
||
if (TREE_CODE (rhs) == SSA_NAME)
|
||
{
|
||
/* If the RHS is an SSA_NAME, return its known constant value,
|
||
if any. */
|
||
return get_value (rhs, true)->value;
|
||
}
|
||
else if (do_store_ccp && stmt_makes_single_load (stmt))
|
||
{
|
||
/* If the RHS is a memory load, see if the VUSEs associated with
|
||
it are a valid constant for that memory load. */
|
||
prop_value_t *val = get_value_loaded_by (stmt, const_val);
|
||
if (val && val->mem_ref)
|
||
{
|
||
if (operand_equal_p (val->mem_ref, rhs, 0))
|
||
return val->value;
|
||
|
||
/* If RHS is extracting REALPART_EXPR or IMAGPART_EXPR of a
|
||
complex type with a known constant value, return it. */
|
||
if ((TREE_CODE (rhs) == REALPART_EXPR
|
||
|| TREE_CODE (rhs) == IMAGPART_EXPR)
|
||
&& operand_equal_p (val->mem_ref, TREE_OPERAND (rhs, 0), 0))
|
||
return fold_build1 (TREE_CODE (rhs), TREE_TYPE (rhs), val->value);
|
||
}
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Unary operators. Note that we know the single operand must
|
||
be a constant. So this should almost always return a
|
||
simplified RHS. */
|
||
if (kind == tcc_unary)
|
||
{
|
||
/* Handle unary operators which can appear in GIMPLE form. */
|
||
tree op0 = TREE_OPERAND (rhs, 0);
|
||
|
||
/* Simplify the operand down to a constant. */
|
||
if (TREE_CODE (op0) == SSA_NAME)
|
||
{
|
||
prop_value_t *val = get_value (op0, true);
|
||
if (val->lattice_val == CONSTANT)
|
||
op0 = get_value (op0, true)->value;
|
||
}
|
||
|
||
if ((code == NOP_EXPR || code == CONVERT_EXPR)
|
||
&& tree_ssa_useless_type_conversion_1 (TREE_TYPE (rhs),
|
||
TREE_TYPE (op0)))
|
||
return op0;
|
||
return fold_unary (code, TREE_TYPE (rhs), op0);
|
||
}
|
||
|
||
/* Binary and comparison operators. We know one or both of the
|
||
operands are constants. */
|
||
else if (kind == tcc_binary
|
||
|| kind == tcc_comparison
|
||
|| code == TRUTH_AND_EXPR
|
||
|| code == TRUTH_OR_EXPR
|
||
|| code == TRUTH_XOR_EXPR)
|
||
{
|
||
/* Handle binary and comparison operators that can appear in
|
||
GIMPLE form. */
|
||
tree op0 = TREE_OPERAND (rhs, 0);
|
||
tree op1 = TREE_OPERAND (rhs, 1);
|
||
|
||
/* Simplify the operands down to constants when appropriate. */
|
||
if (TREE_CODE (op0) == SSA_NAME)
|
||
{
|
||
prop_value_t *val = get_value (op0, true);
|
||
if (val->lattice_val == CONSTANT)
|
||
op0 = val->value;
|
||
}
|
||
|
||
if (TREE_CODE (op1) == SSA_NAME)
|
||
{
|
||
prop_value_t *val = get_value (op1, true);
|
||
if (val->lattice_val == CONSTANT)
|
||
op1 = val->value;
|
||
}
|
||
|
||
return fold_binary (code, TREE_TYPE (rhs), op0, op1);
|
||
}
|
||
|
||
/* We may be able to fold away calls to builtin functions if their
|
||
arguments are constants. */
|
||
else if (code == CALL_EXPR
|
||
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
|
||
&& (TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
|
||
== FUNCTION_DECL)
|
||
&& DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
|
||
{
|
||
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_USE))
|
||
{
|
||
tree *orig, var;
|
||
tree fndecl, arglist;
|
||
size_t i = 0;
|
||
ssa_op_iter iter;
|
||
use_operand_p var_p;
|
||
|
||
/* Preserve the original values of every operand. */
|
||
orig = XNEWVEC (tree, NUM_SSA_OPERANDS (stmt, SSA_OP_USE));
|
||
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
|
||
orig[i++] = var;
|
||
|
||
/* Substitute operands with their values and try to fold. */
|
||
replace_uses_in (stmt, NULL, const_val);
|
||
fndecl = get_callee_fndecl (rhs);
|
||
arglist = TREE_OPERAND (rhs, 1);
|
||
retval = fold_builtin (fndecl, arglist, false);
|
||
|
||
/* Restore operands to their original form. */
|
||
i = 0;
|
||
FOR_EACH_SSA_USE_OPERAND (var_p, stmt, iter, SSA_OP_USE)
|
||
SET_USE (var_p, orig[i++]);
|
||
free (orig);
|
||
}
|
||
}
|
||
else
|
||
return rhs;
|
||
|
||
/* If we got a simplified form, see if we need to convert its type. */
|
||
if (retval)
|
||
return fold_convert (TREE_TYPE (rhs), retval);
|
||
|
||
/* No simplification was possible. */
|
||
return rhs;
|
||
}
|
||
|
||
|
||
/* Return the tree representing the element referenced by T if T is an
|
||
ARRAY_REF or COMPONENT_REF into constant aggregates. Return
|
||
NULL_TREE otherwise. */
|
||
|
||
static tree
|
||
fold_const_aggregate_ref (tree t)
|
||
{
|
||
prop_value_t *value;
|
||
tree base, ctor, idx, field;
|
||
unsigned HOST_WIDE_INT cnt;
|
||
tree cfield, cval;
|
||
|
||
switch (TREE_CODE (t))
|
||
{
|
||
case ARRAY_REF:
|
||
/* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
|
||
DECL_INITIAL. If BASE is a nested reference into another
|
||
ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
|
||
the inner reference. */
|
||
base = TREE_OPERAND (t, 0);
|
||
switch (TREE_CODE (base))
|
||
{
|
||
case VAR_DECL:
|
||
if (!TREE_READONLY (base)
|
||
|| TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE
|
||
|| !targetm.binds_local_p (base))
|
||
return NULL_TREE;
|
||
|
||
ctor = DECL_INITIAL (base);
|
||
break;
|
||
|
||
case ARRAY_REF:
|
||
case COMPONENT_REF:
|
||
ctor = fold_const_aggregate_ref (base);
|
||
break;
|
||
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
if (ctor == NULL_TREE
|
||
|| (TREE_CODE (ctor) != CONSTRUCTOR
|
||
&& TREE_CODE (ctor) != STRING_CST)
|
||
|| !TREE_STATIC (ctor))
|
||
return NULL_TREE;
|
||
|
||
/* Get the index. If we have an SSA_NAME, try to resolve it
|
||
with the current lattice value for the SSA_NAME. */
|
||
idx = TREE_OPERAND (t, 1);
|
||
switch (TREE_CODE (idx))
|
||
{
|
||
case SSA_NAME:
|
||
if ((value = get_value (idx, true))
|
||
&& value->lattice_val == CONSTANT
|
||
&& TREE_CODE (value->value) == INTEGER_CST)
|
||
idx = value->value;
|
||
else
|
||
return NULL_TREE;
|
||
break;
|
||
|
||
case INTEGER_CST:
|
||
break;
|
||
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Fold read from constant string. */
|
||
if (TREE_CODE (ctor) == STRING_CST)
|
||
{
|
||
if ((TYPE_MODE (TREE_TYPE (t))
|
||
== TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
|
||
&& (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
|
||
== MODE_INT)
|
||
&& GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor)))) == 1
|
||
&& compare_tree_int (idx, TREE_STRING_LENGTH (ctor)) < 0)
|
||
return build_int_cst (TREE_TYPE (t), (TREE_STRING_POINTER (ctor)
|
||
[TREE_INT_CST_LOW (idx)]));
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Whoo-hoo! I'll fold ya baby. Yeah! */
|
||
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
|
||
if (tree_int_cst_equal (cfield, idx))
|
||
return cval;
|
||
break;
|
||
|
||
case COMPONENT_REF:
|
||
/* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
|
||
DECL_INITIAL. If BASE is a nested reference into another
|
||
ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
|
||
the inner reference. */
|
||
base = TREE_OPERAND (t, 0);
|
||
switch (TREE_CODE (base))
|
||
{
|
||
case VAR_DECL:
|
||
if (!TREE_READONLY (base)
|
||
|| TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
|
||
|| !targetm.binds_local_p (base))
|
||
return NULL_TREE;
|
||
|
||
ctor = DECL_INITIAL (base);
|
||
break;
|
||
|
||
case ARRAY_REF:
|
||
case COMPONENT_REF:
|
||
ctor = fold_const_aggregate_ref (base);
|
||
break;
|
||
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
if (ctor == NULL_TREE
|
||
|| TREE_CODE (ctor) != CONSTRUCTOR
|
||
|| !TREE_STATIC (ctor))
|
||
return NULL_TREE;
|
||
|
||
field = TREE_OPERAND (t, 1);
|
||
|
||
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
|
||
if (cfield == field
|
||
/* FIXME: Handle bit-fields. */
|
||
&& ! DECL_BIT_FIELD (cfield))
|
||
return cval;
|
||
break;
|
||
|
||
case REALPART_EXPR:
|
||
case IMAGPART_EXPR:
|
||
{
|
||
tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
|
||
if (c && TREE_CODE (c) == COMPLEX_CST)
|
||
return fold_build1 (TREE_CODE (t), TREE_TYPE (t), c);
|
||
break;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Evaluate statement STMT. */
|
||
|
||
static prop_value_t
|
||
evaluate_stmt (tree stmt)
|
||
{
|
||
prop_value_t val;
|
||
tree simplified = NULL_TREE;
|
||
ccp_lattice_t likelyvalue = likely_value (stmt);
|
||
bool is_constant;
|
||
|
||
val.mem_ref = NULL_TREE;
|
||
|
||
fold_defer_overflow_warnings ();
|
||
|
||
/* If the statement is likely to have a CONSTANT result, then try
|
||
to fold the statement to determine the constant value. */
|
||
if (likelyvalue == CONSTANT)
|
||
simplified = ccp_fold (stmt);
|
||
/* If the statement is likely to have a VARYING result, then do not
|
||
bother folding the statement. */
|
||
if (likelyvalue == VARYING)
|
||
simplified = get_rhs (stmt);
|
||
/* If the statement is an ARRAY_REF or COMPONENT_REF into constant
|
||
aggregates, extract the referenced constant. Otherwise the
|
||
statement is likely to have an UNDEFINED value, and there will be
|
||
nothing to do. Note that fold_const_aggregate_ref returns
|
||
NULL_TREE if the first case does not match. */
|
||
else if (!simplified)
|
||
simplified = fold_const_aggregate_ref (get_rhs (stmt));
|
||
|
||
is_constant = simplified && is_gimple_min_invariant (simplified);
|
||
|
||
fold_undefer_overflow_warnings (is_constant, stmt, 0);
|
||
|
||
if (is_constant)
|
||
{
|
||
/* The statement produced a constant value. */
|
||
val.lattice_val = CONSTANT;
|
||
val.value = simplified;
|
||
}
|
||
else
|
||
{
|
||
/* The statement produced a nonconstant value. If the statement
|
||
had UNDEFINED operands, then the result of the statement
|
||
should be UNDEFINED. Otherwise, the statement is VARYING. */
|
||
if (likelyvalue == UNDEFINED || likelyvalue == UNKNOWN_VAL)
|
||
val.lattice_val = likelyvalue;
|
||
else
|
||
val.lattice_val = VARYING;
|
||
|
||
val.value = NULL_TREE;
|
||
}
|
||
|
||
return val;
|
||
}
|
||
|
||
|
||
/* Visit the assignment statement STMT. Set the value of its LHS to the
|
||
value computed by the RHS and store LHS in *OUTPUT_P. If STMT
|
||
creates virtual definitions, set the value of each new name to that
|
||
of the RHS (if we can derive a constant out of the RHS). */
|
||
|
||
static enum ssa_prop_result
|
||
visit_assignment (tree stmt, tree *output_p)
|
||
{
|
||
prop_value_t val;
|
||
tree lhs, rhs;
|
||
enum ssa_prop_result retval;
|
||
|
||
lhs = TREE_OPERAND (stmt, 0);
|
||
rhs = TREE_OPERAND (stmt, 1);
|
||
|
||
if (TREE_CODE (rhs) == SSA_NAME)
|
||
{
|
||
/* For a simple copy operation, we copy the lattice values. */
|
||
prop_value_t *nval = get_value (rhs, true);
|
||
val = *nval;
|
||
}
|
||
else if (do_store_ccp && stmt_makes_single_load (stmt))
|
||
{
|
||
/* Same as above, but the RHS is not a gimple register and yet
|
||
has a known VUSE. If STMT is loading from the same memory
|
||
location that created the SSA_NAMEs for the virtual operands,
|
||
we can propagate the value on the RHS. */
|
||
prop_value_t *nval = get_value_loaded_by (stmt, const_val);
|
||
|
||
if (nval && nval->mem_ref
|
||
&& operand_equal_p (nval->mem_ref, rhs, 0))
|
||
val = *nval;
|
||
else
|
||
val = evaluate_stmt (stmt);
|
||
}
|
||
else
|
||
/* Evaluate the statement. */
|
||
val = evaluate_stmt (stmt);
|
||
|
||
/* If the original LHS was a VIEW_CONVERT_EXPR, modify the constant
|
||
value to be a VIEW_CONVERT_EXPR of the old constant value.
|
||
|
||
??? Also, if this was a definition of a bitfield, we need to widen
|
||
the constant value into the type of the destination variable. This
|
||
should not be necessary if GCC represented bitfields properly. */
|
||
{
|
||
tree orig_lhs = TREE_OPERAND (stmt, 0);
|
||
|
||
if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
|
||
&& val.lattice_val == CONSTANT)
|
||
{
|
||
tree w = fold_unary (VIEW_CONVERT_EXPR,
|
||
TREE_TYPE (TREE_OPERAND (orig_lhs, 0)),
|
||
val.value);
|
||
|
||
orig_lhs = TREE_OPERAND (orig_lhs, 0);
|
||
if (w && is_gimple_min_invariant (w))
|
||
val.value = w;
|
||
else
|
||
{
|
||
val.lattice_val = VARYING;
|
||
val.value = NULL;
|
||
}
|
||
}
|
||
|
||
if (val.lattice_val == CONSTANT
|
||
&& TREE_CODE (orig_lhs) == COMPONENT_REF
|
||
&& DECL_BIT_FIELD (TREE_OPERAND (orig_lhs, 1)))
|
||
{
|
||
tree w = widen_bitfield (val.value, TREE_OPERAND (orig_lhs, 1),
|
||
orig_lhs);
|
||
|
||
if (w && is_gimple_min_invariant (w))
|
||
val.value = w;
|
||
else
|
||
{
|
||
val.lattice_val = VARYING;
|
||
val.value = NULL_TREE;
|
||
val.mem_ref = NULL_TREE;
|
||
}
|
||
}
|
||
}
|
||
|
||
retval = SSA_PROP_NOT_INTERESTING;
|
||
|
||
/* Set the lattice value of the statement's output. */
|
||
if (TREE_CODE (lhs) == SSA_NAME)
|
||
{
|
||
/* If STMT is an assignment to an SSA_NAME, we only have one
|
||
value to set. */
|
||
if (set_lattice_value (lhs, val))
|
||
{
|
||
*output_p = lhs;
|
||
if (val.lattice_val == VARYING)
|
||
retval = SSA_PROP_VARYING;
|
||
else
|
||
retval = SSA_PROP_INTERESTING;
|
||
}
|
||
}
|
||
else if (do_store_ccp && stmt_makes_single_store (stmt))
|
||
{
|
||
/* Otherwise, set the names in V_MAY_DEF/V_MUST_DEF operands
|
||
to the new constant value and mark the LHS as the memory
|
||
reference associated with VAL. */
|
||
ssa_op_iter i;
|
||
tree vdef;
|
||
bool changed;
|
||
|
||
/* Stores cannot take on an UNDEFINED value. */
|
||
if (val.lattice_val == UNDEFINED)
|
||
val.lattice_val = UNKNOWN_VAL;
|
||
|
||
/* Mark VAL as stored in the LHS of this assignment. */
|
||
val.mem_ref = lhs;
|
||
|
||
/* Set the value of every VDEF to VAL. */
|
||
changed = false;
|
||
FOR_EACH_SSA_TREE_OPERAND (vdef, stmt, i, SSA_OP_VIRTUAL_DEFS)
|
||
changed |= set_lattice_value (vdef, val);
|
||
|
||
/* Note that for propagation purposes, we are only interested in
|
||
visiting statements that load the exact same memory reference
|
||
stored here. Those statements will have the exact same list
|
||
of virtual uses, so it is enough to set the output of this
|
||
statement to be its first virtual definition. */
|
||
*output_p = first_vdef (stmt);
|
||
if (changed)
|
||
{
|
||
if (val.lattice_val == VARYING)
|
||
retval = SSA_PROP_VARYING;
|
||
else
|
||
retval = SSA_PROP_INTERESTING;
|
||
}
|
||
}
|
||
|
||
return retval;
|
||
}
|
||
|
||
|
||
/* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
|
||
if it can determine which edge will be taken. Otherwise, return
|
||
SSA_PROP_VARYING. */
|
||
|
||
static enum ssa_prop_result
|
||
visit_cond_stmt (tree stmt, edge *taken_edge_p)
|
||
{
|
||
prop_value_t val;
|
||
basic_block block;
|
||
|
||
block = bb_for_stmt (stmt);
|
||
val = evaluate_stmt (stmt);
|
||
|
||
/* Find which edge out of the conditional block will be taken and add it
|
||
to the worklist. If no single edge can be determined statically,
|
||
return SSA_PROP_VARYING to feed all the outgoing edges to the
|
||
propagation engine. */
|
||
*taken_edge_p = val.value ? find_taken_edge (block, val.value) : 0;
|
||
if (*taken_edge_p)
|
||
return SSA_PROP_INTERESTING;
|
||
else
|
||
return SSA_PROP_VARYING;
|
||
}
|
||
|
||
|
||
/* Evaluate statement STMT. If the statement produces an output value and
|
||
its evaluation changes the lattice value of its output, return
|
||
SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
|
||
output value.
|
||
|
||
If STMT is a conditional branch and we can determine its truth
|
||
value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
|
||
value, return SSA_PROP_VARYING. */
|
||
|
||
static enum ssa_prop_result
|
||
ccp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
|
||
{
|
||
tree def;
|
||
ssa_op_iter iter;
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file, "\nVisiting statement:\n");
|
||
print_generic_stmt (dump_file, stmt, dump_flags);
|
||
fprintf (dump_file, "\n");
|
||
}
|
||
|
||
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
||
{
|
||
/* If the statement is an assignment that produces a single
|
||
output value, evaluate its RHS to see if the lattice value of
|
||
its output has changed. */
|
||
return visit_assignment (stmt, output_p);
|
||
}
|
||
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
|
||
{
|
||
/* If STMT is a conditional branch, see if we can determine
|
||
which branch will be taken. */
|
||
return visit_cond_stmt (stmt, taken_edge_p);
|
||
}
|
||
|
||
/* Any other kind of statement is not interesting for constant
|
||
propagation and, therefore, not worth simulating. */
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
|
||
|
||
/* Definitions made by statements other than assignments to
|
||
SSA_NAMEs represent unknown modifications to their outputs.
|
||
Mark them VARYING. */
|
||
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
|
||
{
|
||
prop_value_t v = { VARYING, NULL_TREE, NULL_TREE };
|
||
set_lattice_value (def, v);
|
||
}
|
||
|
||
return SSA_PROP_VARYING;
|
||
}
|
||
|
||
|
||
/* Main entry point for SSA Conditional Constant Propagation. */
|
||
|
||
static void
|
||
execute_ssa_ccp (bool store_ccp)
|
||
{
|
||
do_store_ccp = store_ccp;
|
||
ccp_initialize ();
|
||
ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
|
||
ccp_finalize ();
|
||
}
|
||
|
||
|
||
static unsigned int
|
||
do_ssa_ccp (void)
|
||
{
|
||
execute_ssa_ccp (false);
|
||
return 0;
|
||
}
|
||
|
||
|
||
static bool
|
||
gate_ccp (void)
|
||
{
|
||
return flag_tree_ccp != 0;
|
||
}
|
||
|
||
|
||
struct tree_opt_pass pass_ccp =
|
||
{
|
||
"ccp", /* name */
|
||
gate_ccp, /* gate */
|
||
do_ssa_ccp, /* execute */
|
||
NULL, /* sub */
|
||
NULL, /* next */
|
||
0, /* static_pass_number */
|
||
TV_TREE_CCP, /* tv_id */
|
||
PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
||
0, /* properties_provided */
|
||
PROP_smt_usage, /* properties_destroyed */
|
||
0, /* todo_flags_start */
|
||
TODO_cleanup_cfg | TODO_dump_func | TODO_update_ssa
|
||
| TODO_ggc_collect | TODO_verify_ssa
|
||
| TODO_verify_stmts | TODO_update_smt_usage, /* todo_flags_finish */
|
||
0 /* letter */
|
||
};
|
||
|
||
|
||
static unsigned int
|
||
do_ssa_store_ccp (void)
|
||
{
|
||
/* If STORE-CCP is not enabled, we just run regular CCP. */
|
||
execute_ssa_ccp (flag_tree_store_ccp != 0);
|
||
return 0;
|
||
}
|
||
|
||
static bool
|
||
gate_store_ccp (void)
|
||
{
|
||
/* STORE-CCP is enabled only with -ftree-store-ccp, but when
|
||
-fno-tree-store-ccp is specified, we should run regular CCP.
|
||
That's why the pass is enabled with either flag. */
|
||
return flag_tree_store_ccp != 0 || flag_tree_ccp != 0;
|
||
}
|
||
|
||
|
||
struct tree_opt_pass pass_store_ccp =
|
||
{
|
||
"store_ccp", /* name */
|
||
gate_store_ccp, /* gate */
|
||
do_ssa_store_ccp, /* execute */
|
||
NULL, /* sub */
|
||
NULL, /* next */
|
||
0, /* static_pass_number */
|
||
TV_TREE_STORE_CCP, /* tv_id */
|
||
PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
||
0, /* properties_provided */
|
||
PROP_smt_usage, /* properties_destroyed */
|
||
0, /* todo_flags_start */
|
||
TODO_dump_func | TODO_update_ssa
|
||
| TODO_ggc_collect | TODO_verify_ssa
|
||
| TODO_cleanup_cfg
|
||
| TODO_verify_stmts | TODO_update_smt_usage, /* todo_flags_finish */
|
||
0 /* letter */
|
||
};
|
||
|
||
/* Given a constant value VAL for bitfield FIELD, and a destination
|
||
variable VAR, return VAL appropriately widened to fit into VAR. If
|
||
FIELD is wider than HOST_WIDE_INT, NULL is returned. */
|
||
|
||
tree
|
||
widen_bitfield (tree val, tree field, tree var)
|
||
{
|
||
unsigned HOST_WIDE_INT var_size, field_size;
|
||
tree wide_val;
|
||
unsigned HOST_WIDE_INT mask;
|
||
unsigned int i;
|
||
|
||
/* We can only do this if the size of the type and field and VAL are
|
||
all constants representable in HOST_WIDE_INT. */
|
||
if (!host_integerp (TYPE_SIZE (TREE_TYPE (var)), 1)
|
||
|| !host_integerp (DECL_SIZE (field), 1)
|
||
|| !host_integerp (val, 0))
|
||
return NULL_TREE;
|
||
|
||
var_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (var)), 1);
|
||
field_size = tree_low_cst (DECL_SIZE (field), 1);
|
||
|
||
/* Give up if either the bitfield or the variable are too wide. */
|
||
if (field_size > HOST_BITS_PER_WIDE_INT || var_size > HOST_BITS_PER_WIDE_INT)
|
||
return NULL_TREE;
|
||
|
||
gcc_assert (var_size >= field_size);
|
||
|
||
/* If the sign bit of the value is not set or the field's type is unsigned,
|
||
just mask off the high order bits of the value. */
|
||
if (DECL_UNSIGNED (field)
|
||
|| !(tree_low_cst (val, 0) & (((HOST_WIDE_INT)1) << (field_size - 1))))
|
||
{
|
||
/* Zero extension. Build a mask with the lower 'field_size' bits
|
||
set and a BIT_AND_EXPR node to clear the high order bits of
|
||
the value. */
|
||
for (i = 0, mask = 0; i < field_size; i++)
|
||
mask |= ((HOST_WIDE_INT) 1) << i;
|
||
|
||
wide_val = fold_build2 (BIT_AND_EXPR, TREE_TYPE (var), val,
|
||
build_int_cst (TREE_TYPE (var), mask));
|
||
}
|
||
else
|
||
{
|
||
/* Sign extension. Create a mask with the upper 'field_size'
|
||
bits set and a BIT_IOR_EXPR to set the high order bits of the
|
||
value. */
|
||
for (i = 0, mask = 0; i < (var_size - field_size); i++)
|
||
mask |= ((HOST_WIDE_INT) 1) << (var_size - i - 1);
|
||
|
||
wide_val = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
|
||
build_int_cst (TREE_TYPE (var), mask));
|
||
}
|
||
|
||
return wide_val;
|
||
}
|
||
|
||
|
||
/* A subroutine of fold_stmt_r. Attempts to fold *(A+O) to A[X].
|
||
BASE is an array type. OFFSET is a byte displacement. ORIG_TYPE
|
||
is the desired result type. */
|
||
|
||
static tree
|
||
maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type)
|
||
{
|
||
tree min_idx, idx, elt_offset = integer_zero_node;
|
||
tree array_type, elt_type, elt_size;
|
||
|
||
/* If BASE is an ARRAY_REF, we can pick up another offset (this time
|
||
measured in units of the size of elements type) from that ARRAY_REF).
|
||
We can't do anything if either is variable.
|
||
|
||
The case we handle here is *(&A[N]+O). */
|
||
if (TREE_CODE (base) == ARRAY_REF)
|
||
{
|
||
tree low_bound = array_ref_low_bound (base);
|
||
|
||
elt_offset = TREE_OPERAND (base, 1);
|
||
if (TREE_CODE (low_bound) != INTEGER_CST
|
||
|| TREE_CODE (elt_offset) != INTEGER_CST)
|
||
return NULL_TREE;
|
||
|
||
elt_offset = int_const_binop (MINUS_EXPR, elt_offset, low_bound, 0);
|
||
base = TREE_OPERAND (base, 0);
|
||
}
|
||
|
||
/* Ignore stupid user tricks of indexing non-array variables. */
|
||
array_type = TREE_TYPE (base);
|
||
if (TREE_CODE (array_type) != ARRAY_TYPE)
|
||
return NULL_TREE;
|
||
elt_type = TREE_TYPE (array_type);
|
||
if (!lang_hooks.types_compatible_p (orig_type, elt_type))
|
||
return NULL_TREE;
|
||
|
||
/* If OFFSET and ELT_OFFSET are zero, we don't care about the size of the
|
||
element type (so we can use the alignment if it's not constant).
|
||
Otherwise, compute the offset as an index by using a division. If the
|
||
division isn't exact, then don't do anything. */
|
||
elt_size = TYPE_SIZE_UNIT (elt_type);
|
||
if (integer_zerop (offset))
|
||
{
|
||
if (TREE_CODE (elt_size) != INTEGER_CST)
|
||
elt_size = size_int (TYPE_ALIGN (elt_type));
|
||
|
||
idx = integer_zero_node;
|
||
}
|
||
else
|
||
{
|
||
unsigned HOST_WIDE_INT lquo, lrem;
|
||
HOST_WIDE_INT hquo, hrem;
|
||
|
||
if (TREE_CODE (elt_size) != INTEGER_CST
|
||
|| div_and_round_double (TRUNC_DIV_EXPR, 1,
|
||
TREE_INT_CST_LOW (offset),
|
||
TREE_INT_CST_HIGH (offset),
|
||
TREE_INT_CST_LOW (elt_size),
|
||
TREE_INT_CST_HIGH (elt_size),
|
||
&lquo, &hquo, &lrem, &hrem)
|
||
|| lrem || hrem)
|
||
return NULL_TREE;
|
||
|
||
idx = build_int_cst_wide (NULL_TREE, lquo, hquo);
|
||
}
|
||
|
||
/* Assume the low bound is zero. If there is a domain type, get the
|
||
low bound, if any, convert the index into that type, and add the
|
||
low bound. */
|
||
min_idx = integer_zero_node;
|
||
if (TYPE_DOMAIN (array_type))
|
||
{
|
||
if (TYPE_MIN_VALUE (TYPE_DOMAIN (array_type)))
|
||
min_idx = TYPE_MIN_VALUE (TYPE_DOMAIN (array_type));
|
||
else
|
||
min_idx = fold_convert (TYPE_DOMAIN (array_type), min_idx);
|
||
|
||
if (TREE_CODE (min_idx) != INTEGER_CST)
|
||
return NULL_TREE;
|
||
|
||
idx = fold_convert (TYPE_DOMAIN (array_type), idx);
|
||
elt_offset = fold_convert (TYPE_DOMAIN (array_type), elt_offset);
|
||
}
|
||
|
||
if (!integer_zerop (min_idx))
|
||
idx = int_const_binop (PLUS_EXPR, idx, min_idx, 0);
|
||
if (!integer_zerop (elt_offset))
|
||
idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
|
||
|
||
return build4 (ARRAY_REF, orig_type, base, idx, min_idx,
|
||
size_int (tree_low_cst (elt_size, 1)
|
||
/ (TYPE_ALIGN_UNIT (elt_type))));
|
||
}
|
||
|
||
|
||
/* A subroutine of fold_stmt_r. Attempts to fold *(S+O) to S.X.
|
||
BASE is a record type. OFFSET is a byte displacement. ORIG_TYPE
|
||
is the desired result type. */
|
||
/* ??? This doesn't handle class inheritance. */
|
||
|
||
static tree
|
||
maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
|
||
tree orig_type, bool base_is_ptr)
|
||
{
|
||
tree f, t, field_type, tail_array_field, field_offset;
|
||
|
||
if (TREE_CODE (record_type) != RECORD_TYPE
|
||
&& TREE_CODE (record_type) != UNION_TYPE
|
||
&& TREE_CODE (record_type) != QUAL_UNION_TYPE)
|
||
return NULL_TREE;
|
||
|
||
/* Short-circuit silly cases. */
|
||
if (lang_hooks.types_compatible_p (record_type, orig_type))
|
||
return NULL_TREE;
|
||
|
||
tail_array_field = NULL_TREE;
|
||
for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
|
||
{
|
||
int cmp;
|
||
|
||
if (TREE_CODE (f) != FIELD_DECL)
|
||
continue;
|
||
if (DECL_BIT_FIELD (f))
|
||
continue;
|
||
|
||
field_offset = byte_position (f);
|
||
if (TREE_CODE (field_offset) != INTEGER_CST)
|
||
continue;
|
||
|
||
/* ??? Java creates "interesting" fields for representing base classes.
|
||
They have no name, and have no context. With no context, we get into
|
||
trouble with nonoverlapping_component_refs_p. Skip them. */
|
||
if (!DECL_FIELD_CONTEXT (f))
|
||
continue;
|
||
|
||
/* The previous array field isn't at the end. */
|
||
tail_array_field = NULL_TREE;
|
||
|
||
/* Check to see if this offset overlaps with the field. */
|
||
cmp = tree_int_cst_compare (field_offset, offset);
|
||
if (cmp > 0)
|
||
continue;
|
||
|
||
field_type = TREE_TYPE (f);
|
||
|
||
/* Here we exactly match the offset being checked. If the types match,
|
||
then we can return that field. */
|
||
if (cmp == 0
|
||
&& lang_hooks.types_compatible_p (orig_type, field_type))
|
||
{
|
||
if (base_is_ptr)
|
||
base = build1 (INDIRECT_REF, record_type, base);
|
||
t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
|
||
return t;
|
||
}
|
||
|
||
/* Don't care about offsets into the middle of scalars. */
|
||
if (!AGGREGATE_TYPE_P (field_type))
|
||
continue;
|
||
|
||
/* Check for array at the end of the struct. This is often
|
||
used as for flexible array members. We should be able to
|
||
turn this into an array access anyway. */
|
||
if (TREE_CODE (field_type) == ARRAY_TYPE)
|
||
tail_array_field = f;
|
||
|
||
/* Check the end of the field against the offset. */
|
||
if (!DECL_SIZE_UNIT (f)
|
||
|| TREE_CODE (DECL_SIZE_UNIT (f)) != INTEGER_CST)
|
||
continue;
|
||
t = int_const_binop (MINUS_EXPR, offset, field_offset, 1);
|
||
if (!tree_int_cst_lt (t, DECL_SIZE_UNIT (f)))
|
||
continue;
|
||
|
||
/* If we matched, then set offset to the displacement into
|
||
this field. */
|
||
offset = t;
|
||
goto found;
|
||
}
|
||
|
||
if (!tail_array_field)
|
||
return NULL_TREE;
|
||
|
||
f = tail_array_field;
|
||
field_type = TREE_TYPE (f);
|
||
offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
|
||
|
||
found:
|
||
/* If we get here, we've got an aggregate field, and a possibly
|
||
nonzero offset into them. Recurse and hope for a valid match. */
|
||
if (base_is_ptr)
|
||
base = build1 (INDIRECT_REF, record_type, base);
|
||
base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
|
||
|
||
t = maybe_fold_offset_to_array_ref (base, offset, orig_type);
|
||
if (t)
|
||
return t;
|
||
return maybe_fold_offset_to_component_ref (field_type, base, offset,
|
||
orig_type, false);
|
||
}
|
||
|
||
|
||
/* A subroutine of fold_stmt_r. Attempt to simplify *(BASE+OFFSET).
|
||
Return the simplified expression, or NULL if nothing could be done. */
|
||
|
||
static tree
|
||
maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
|
||
{
|
||
tree t;
|
||
|
||
/* We may well have constructed a double-nested PLUS_EXPR via multiple
|
||
substitutions. Fold that down to one. Remove NON_LVALUE_EXPRs that
|
||
are sometimes added. */
|
||
base = fold (base);
|
||
STRIP_TYPE_NOPS (base);
|
||
TREE_OPERAND (expr, 0) = base;
|
||
|
||
/* One possibility is that the address reduces to a string constant. */
|
||
t = fold_read_from_constant_string (expr);
|
||
if (t)
|
||
return t;
|
||
|
||
/* Add in any offset from a PLUS_EXPR. */
|
||
if (TREE_CODE (base) == PLUS_EXPR)
|
||
{
|
||
tree offset2;
|
||
|
||
offset2 = TREE_OPERAND (base, 1);
|
||
if (TREE_CODE (offset2) != INTEGER_CST)
|
||
return NULL_TREE;
|
||
base = TREE_OPERAND (base, 0);
|
||
|
||
offset = int_const_binop (PLUS_EXPR, offset, offset2, 1);
|
||
}
|
||
|
||
if (TREE_CODE (base) == ADDR_EXPR)
|
||
{
|
||
/* Strip the ADDR_EXPR. */
|
||
base = TREE_OPERAND (base, 0);
|
||
|
||
/* Fold away CONST_DECL to its value, if the type is scalar. */
|
||
if (TREE_CODE (base) == CONST_DECL
|
||
&& ccp_decl_initial_min_invariant (DECL_INITIAL (base)))
|
||
return DECL_INITIAL (base);
|
||
|
||
/* Try folding *(&B+O) to B[X]. */
|
||
t = maybe_fold_offset_to_array_ref (base, offset, TREE_TYPE (expr));
|
||
if (t)
|
||
return t;
|
||
|
||
/* Try folding *(&B+O) to B.X. */
|
||
t = maybe_fold_offset_to_component_ref (TREE_TYPE (base), base, offset,
|
||
TREE_TYPE (expr), false);
|
||
if (t)
|
||
return t;
|
||
|
||
/* Fold *&B to B. We can only do this if EXPR is the same type
|
||
as BASE. We can't do this if EXPR is the element type of an array
|
||
and BASE is the array. */
|
||
if (integer_zerop (offset)
|
||
&& lang_hooks.types_compatible_p (TREE_TYPE (base),
|
||
TREE_TYPE (expr)))
|
||
return base;
|
||
}
|
||
else
|
||
{
|
||
/* We can get here for out-of-range string constant accesses,
|
||
such as "_"[3]. Bail out of the entire substitution search
|
||
and arrange for the entire statement to be replaced by a
|
||
call to __builtin_trap. In all likelihood this will all be
|
||
constant-folded away, but in the meantime we can't leave with
|
||
something that get_expr_operands can't understand. */
|
||
|
||
t = base;
|
||
STRIP_NOPS (t);
|
||
if (TREE_CODE (t) == ADDR_EXPR
|
||
&& TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
|
||
{
|
||
/* FIXME: Except that this causes problems elsewhere with dead
|
||
code not being deleted, and we die in the rtl expanders
|
||
because we failed to remove some ssa_name. In the meantime,
|
||
just return zero. */
|
||
/* FIXME2: This condition should be signaled by
|
||
fold_read_from_constant_string directly, rather than
|
||
re-checking for it here. */
|
||
return integer_zero_node;
|
||
}
|
||
|
||
/* Try folding *(B+O) to B->X. Still an improvement. */
|
||
if (POINTER_TYPE_P (TREE_TYPE (base)))
|
||
{
|
||
t = maybe_fold_offset_to_component_ref (TREE_TYPE (TREE_TYPE (base)),
|
||
base, offset,
|
||
TREE_TYPE (expr), true);
|
||
if (t)
|
||
return t;
|
||
}
|
||
}
|
||
|
||
/* Otherwise we had an offset that we could not simplify. */
|
||
return NULL_TREE;
|
||
}
|
||
|
||
|
||
/* A subroutine of fold_stmt_r. EXPR is a PLUS_EXPR.
|
||
|
||
A quaint feature extant in our address arithmetic is that there
|
||
can be hidden type changes here. The type of the result need
|
||
not be the same as the type of the input pointer.
|
||
|
||
What we're after here is an expression of the form
|
||
(T *)(&array + const)
|
||
where the cast doesn't actually exist, but is implicit in the
|
||
type of the PLUS_EXPR. We'd like to turn this into
|
||
&array[x]
|
||
which may be able to propagate further. */
|
||
|
||
static tree
|
||
maybe_fold_stmt_addition (tree expr)
|
||
{
|
||
tree op0 = TREE_OPERAND (expr, 0);
|
||
tree op1 = TREE_OPERAND (expr, 1);
|
||
tree ptr_type = TREE_TYPE (expr);
|
||
tree ptd_type;
|
||
tree t;
|
||
bool subtract = (TREE_CODE (expr) == MINUS_EXPR);
|
||
|
||
/* We're only interested in pointer arithmetic. */
|
||
if (!POINTER_TYPE_P (ptr_type))
|
||
return NULL_TREE;
|
||
/* Canonicalize the integral operand to op1. */
|
||
if (INTEGRAL_TYPE_P (TREE_TYPE (op0)))
|
||
{
|
||
if (subtract)
|
||
return NULL_TREE;
|
||
t = op0, op0 = op1, op1 = t;
|
||
}
|
||
/* It had better be a constant. */
|
||
if (TREE_CODE (op1) != INTEGER_CST)
|
||
return NULL_TREE;
|
||
/* The first operand should be an ADDR_EXPR. */
|
||
if (TREE_CODE (op0) != ADDR_EXPR)
|
||
return NULL_TREE;
|
||
op0 = TREE_OPERAND (op0, 0);
|
||
|
||
/* If the first operand is an ARRAY_REF, expand it so that we can fold
|
||
the offset into it. */
|
||
while (TREE_CODE (op0) == ARRAY_REF)
|
||
{
|
||
tree array_obj = TREE_OPERAND (op0, 0);
|
||
tree array_idx = TREE_OPERAND (op0, 1);
|
||
tree elt_type = TREE_TYPE (op0);
|
||
tree elt_size = TYPE_SIZE_UNIT (elt_type);
|
||
tree min_idx;
|
||
|
||
if (TREE_CODE (array_idx) != INTEGER_CST)
|
||
break;
|
||
if (TREE_CODE (elt_size) != INTEGER_CST)
|
||
break;
|
||
|
||
/* Un-bias the index by the min index of the array type. */
|
||
min_idx = TYPE_DOMAIN (TREE_TYPE (array_obj));
|
||
if (min_idx)
|
||
{
|
||
min_idx = TYPE_MIN_VALUE (min_idx);
|
||
if (min_idx)
|
||
{
|
||
if (TREE_CODE (min_idx) != INTEGER_CST)
|
||
break;
|
||
|
||
array_idx = fold_convert (TREE_TYPE (min_idx), array_idx);
|
||
if (!integer_zerop (min_idx))
|
||
array_idx = int_const_binop (MINUS_EXPR, array_idx,
|
||
min_idx, 0);
|
||
}
|
||
}
|
||
|
||
/* Convert the index to a byte offset. */
|
||
array_idx = fold_convert (sizetype, array_idx);
|
||
array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
|
||
|
||
/* Update the operands for the next round, or for folding. */
|
||
/* If we're manipulating unsigned types, then folding into negative
|
||
values can produce incorrect results. Particularly if the type
|
||
is smaller than the width of the pointer. */
|
||
if (subtract
|
||
&& TYPE_UNSIGNED (TREE_TYPE (op1))
|
||
&& tree_int_cst_lt (array_idx, op1))
|
||
return NULL;
|
||
op1 = int_const_binop (subtract ? MINUS_EXPR : PLUS_EXPR,
|
||
array_idx, op1, 0);
|
||
subtract = false;
|
||
op0 = array_obj;
|
||
}
|
||
|
||
/* If we weren't able to fold the subtraction into another array reference,
|
||
canonicalize the integer for passing to the array and component ref
|
||
simplification functions. */
|
||
if (subtract)
|
||
{
|
||
if (TYPE_UNSIGNED (TREE_TYPE (op1)))
|
||
return NULL;
|
||
op1 = fold_unary (NEGATE_EXPR, TREE_TYPE (op1), op1);
|
||
/* ??? In theory fold should always produce another integer. */
|
||
if (op1 == NULL || TREE_CODE (op1) != INTEGER_CST)
|
||
return NULL;
|
||
}
|
||
|
||
ptd_type = TREE_TYPE (ptr_type);
|
||
|
||
/* At which point we can try some of the same things as for indirects. */
|
||
t = maybe_fold_offset_to_array_ref (op0, op1, ptd_type);
|
||
if (!t)
|
||
t = maybe_fold_offset_to_component_ref (TREE_TYPE (op0), op0, op1,
|
||
ptd_type, false);
|
||
if (t)
|
||
t = build1 (ADDR_EXPR, ptr_type, t);
|
||
|
||
return t;
|
||
}
|
||
|
||
/* For passing state through walk_tree into fold_stmt_r and its
|
||
children. */
|
||
|
||
struct fold_stmt_r_data
|
||
{
|
||
tree stmt;
|
||
bool *changed_p;
|
||
bool *inside_addr_expr_p;
|
||
};
|
||
|
||
/* Subroutine of fold_stmt called via walk_tree. We perform several
|
||
simplifications of EXPR_P, mostly having to do with pointer arithmetic. */
|
||
|
||
static tree
|
||
fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data)
|
||
{
|
||
struct fold_stmt_r_data *fold_stmt_r_data = (struct fold_stmt_r_data *) data;
|
||
bool *inside_addr_expr_p = fold_stmt_r_data->inside_addr_expr_p;
|
||
bool *changed_p = fold_stmt_r_data->changed_p;
|
||
tree expr = *expr_p, t;
|
||
|
||
/* ??? It'd be nice if walk_tree had a pre-order option. */
|
||
switch (TREE_CODE (expr))
|
||
{
|
||
case INDIRECT_REF:
|
||
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
|
||
if (t)
|
||
return t;
|
||
*walk_subtrees = 0;
|
||
|
||
t = maybe_fold_stmt_indirect (expr, TREE_OPERAND (expr, 0),
|
||
integer_zero_node);
|
||
break;
|
||
|
||
/* ??? Could handle more ARRAY_REFs here, as a variant of INDIRECT_REF.
|
||
We'd only want to bother decomposing an existing ARRAY_REF if
|
||
the base array is found to have another offset contained within.
|
||
Otherwise we'd be wasting time. */
|
||
case ARRAY_REF:
|
||
/* If we are not processing expressions found within an
|
||
ADDR_EXPR, then we can fold constant array references. */
|
||
if (!*inside_addr_expr_p)
|
||
t = fold_read_from_constant_string (expr);
|
||
else
|
||
t = NULL;
|
||
break;
|
||
|
||
case ADDR_EXPR:
|
||
*inside_addr_expr_p = true;
|
||
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
|
||
*inside_addr_expr_p = false;
|
||
if (t)
|
||
return t;
|
||
*walk_subtrees = 0;
|
||
|
||
/* Set TREE_INVARIANT properly so that the value is properly
|
||
considered constant, and so gets propagated as expected. */
|
||
if (*changed_p)
|
||
recompute_tree_invariant_for_addr_expr (expr);
|
||
return NULL_TREE;
|
||
|
||
case PLUS_EXPR:
|
||
case MINUS_EXPR:
|
||
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
|
||
if (t)
|
||
return t;
|
||
t = walk_tree (&TREE_OPERAND (expr, 1), fold_stmt_r, data, NULL);
|
||
if (t)
|
||
return t;
|
||
*walk_subtrees = 0;
|
||
|
||
t = maybe_fold_stmt_addition (expr);
|
||
break;
|
||
|
||
case COMPONENT_REF:
|
||
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
|
||
if (t)
|
||
return t;
|
||
*walk_subtrees = 0;
|
||
|
||
/* Make sure the FIELD_DECL is actually a field in the type on the lhs.
|
||
We've already checked that the records are compatible, so we should
|
||
come up with a set of compatible fields. */
|
||
{
|
||
tree expr_record = TREE_TYPE (TREE_OPERAND (expr, 0));
|
||
tree expr_field = TREE_OPERAND (expr, 1);
|
||
|
||
if (DECL_FIELD_CONTEXT (expr_field) != TYPE_MAIN_VARIANT (expr_record))
|
||
{
|
||
expr_field = find_compatible_field (expr_record, expr_field);
|
||
TREE_OPERAND (expr, 1) = expr_field;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case TARGET_MEM_REF:
|
||
t = maybe_fold_tmr (expr);
|
||
break;
|
||
|
||
case COND_EXPR:
|
||
if (COMPARISON_CLASS_P (TREE_OPERAND (expr, 0)))
|
||
{
|
||
tree op0 = TREE_OPERAND (expr, 0);
|
||
tree tem;
|
||
bool set;
|
||
|
||
fold_defer_overflow_warnings ();
|
||
tem = fold_binary (TREE_CODE (op0), TREE_TYPE (op0),
|
||
TREE_OPERAND (op0, 0),
|
||
TREE_OPERAND (op0, 1));
|
||
set = tem && is_gimple_condexpr (tem);
|
||
fold_undefer_overflow_warnings (set, fold_stmt_r_data->stmt, 0);
|
||
if (set)
|
||
TREE_OPERAND (expr, 0) = tem;
|
||
t = expr;
|
||
break;
|
||
}
|
||
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
if (t)
|
||
{
|
||
*expr_p = t;
|
||
*changed_p = true;
|
||
}
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
|
||
/* Return the string length, maximum string length or maximum value of
|
||
ARG in LENGTH.
|
||
If ARG is an SSA name variable, follow its use-def chains. If LENGTH
|
||
is not NULL and, for TYPE == 0, its value is not equal to the length
|
||
we determine or if we are unable to determine the length or value,
|
||
return false. VISITED is a bitmap of visited variables.
|
||
TYPE is 0 if string length should be returned, 1 for maximum string
|
||
length and 2 for maximum value ARG can have. */
|
||
|
||
static bool
|
||
get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
|
||
{
|
||
tree var, def_stmt, val;
|
||
|
||
if (TREE_CODE (arg) != SSA_NAME)
|
||
{
|
||
if (type == 2)
|
||
{
|
||
val = arg;
|
||
if (TREE_CODE (val) != INTEGER_CST
|
||
|| tree_int_cst_sgn (val) < 0)
|
||
return false;
|
||
}
|
||
else
|
||
val = c_strlen (arg, 1);
|
||
if (!val)
|
||
return false;
|
||
|
||
if (*length)
|
||
{
|
||
if (type > 0)
|
||
{
|
||
if (TREE_CODE (*length) != INTEGER_CST
|
||
|| TREE_CODE (val) != INTEGER_CST)
|
||
return false;
|
||
|
||
if (tree_int_cst_lt (*length, val))
|
||
*length = val;
|
||
return true;
|
||
}
|
||
else if (simple_cst_equal (val, *length) != 1)
|
||
return false;
|
||
}
|
||
|
||
*length = val;
|
||
return true;
|
||
}
|
||
|
||
/* If we were already here, break the infinite cycle. */
|
||
if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
|
||
return true;
|
||
bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
|
||
|
||
var = arg;
|
||
def_stmt = SSA_NAME_DEF_STMT (var);
|
||
|
||
switch (TREE_CODE (def_stmt))
|
||
{
|
||
case MODIFY_EXPR:
|
||
{
|
||
tree rhs;
|
||
|
||
/* The RHS of the statement defining VAR must either have a
|
||
constant length or come from another SSA_NAME with a constant
|
||
length. */
|
||
rhs = TREE_OPERAND (def_stmt, 1);
|
||
STRIP_NOPS (rhs);
|
||
return get_maxval_strlen (rhs, length, visited, type);
|
||
}
|
||
|
||
case PHI_NODE:
|
||
{
|
||
/* All the arguments of the PHI node must have the same constant
|
||
length. */
|
||
int i;
|
||
|
||
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
|
||
{
|
||
tree arg = PHI_ARG_DEF (def_stmt, i);
|
||
|
||
/* If this PHI has itself as an argument, we cannot
|
||
determine the string length of this argument. However,
|
||
if we can find a constant string length for the other
|
||
PHI args then we can still be sure that this is a
|
||
constant string length. So be optimistic and just
|
||
continue with the next argument. */
|
||
if (arg == PHI_RESULT (def_stmt))
|
||
continue;
|
||
|
||
if (!get_maxval_strlen (arg, length, visited, type))
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/* Fold builtin call FN in statement STMT. If it cannot be folded into a
|
||
constant, return NULL_TREE. Otherwise, return its constant value. */
|
||
|
||
static tree
|
||
ccp_fold_builtin (tree stmt, tree fn)
|
||
{
|
||
tree result, val[3];
|
||
tree callee, arglist, a;
|
||
int arg_mask, i, type;
|
||
bitmap visited;
|
||
bool ignore;
|
||
|
||
ignore = TREE_CODE (stmt) != MODIFY_EXPR;
|
||
|
||
/* First try the generic builtin folder. If that succeeds, return the
|
||
result directly. */
|
||
callee = get_callee_fndecl (fn);
|
||
arglist = TREE_OPERAND (fn, 1);
|
||
result = fold_builtin (callee, arglist, ignore);
|
||
if (result)
|
||
{
|
||
if (ignore)
|
||
STRIP_NOPS (result);
|
||
return result;
|
||
}
|
||
|
||
/* Ignore MD builtins. */
|
||
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_MD)
|
||
return NULL_TREE;
|
||
|
||
/* If the builtin could not be folded, and it has no argument list,
|
||
we're done. */
|
||
if (!arglist)
|
||
return NULL_TREE;
|
||
|
||
/* Limit the work only for builtins we know how to simplify. */
|
||
switch (DECL_FUNCTION_CODE (callee))
|
||
{
|
||
case BUILT_IN_STRLEN:
|
||
case BUILT_IN_FPUTS:
|
||
case BUILT_IN_FPUTS_UNLOCKED:
|
||
arg_mask = 1;
|
||
type = 0;
|
||
break;
|
||
case BUILT_IN_STRCPY:
|
||
case BUILT_IN_STRNCPY:
|
||
arg_mask = 2;
|
||
type = 0;
|
||
break;
|
||
case BUILT_IN_MEMCPY_CHK:
|
||
case BUILT_IN_MEMPCPY_CHK:
|
||
case BUILT_IN_MEMMOVE_CHK:
|
||
case BUILT_IN_MEMSET_CHK:
|
||
case BUILT_IN_STRNCPY_CHK:
|
||
arg_mask = 4;
|
||
type = 2;
|
||
break;
|
||
case BUILT_IN_STRCPY_CHK:
|
||
case BUILT_IN_STPCPY_CHK:
|
||
arg_mask = 2;
|
||
type = 1;
|
||
break;
|
||
case BUILT_IN_SNPRINTF_CHK:
|
||
case BUILT_IN_VSNPRINTF_CHK:
|
||
arg_mask = 2;
|
||
type = 2;
|
||
break;
|
||
default:
|
||
return NULL_TREE;
|
||
}
|
||
|
||
/* Try to use the dataflow information gathered by the CCP process. */
|
||
visited = BITMAP_ALLOC (NULL);
|
||
|
||
memset (val, 0, sizeof (val));
|
||
for (i = 0, a = arglist;
|
||
arg_mask;
|
||
i++, arg_mask >>= 1, a = TREE_CHAIN (a))
|
||
if (arg_mask & 1)
|
||
{
|
||
bitmap_clear (visited);
|
||
if (!get_maxval_strlen (TREE_VALUE (a), &val[i], visited, type))
|
||
val[i] = NULL_TREE;
|
||
}
|
||
|
||
BITMAP_FREE (visited);
|
||
|
||
result = NULL_TREE;
|
||
switch (DECL_FUNCTION_CODE (callee))
|
||
{
|
||
case BUILT_IN_STRLEN:
|
||
if (val[0])
|
||
{
|
||
tree new = fold_convert (TREE_TYPE (fn), val[0]);
|
||
|
||
/* If the result is not a valid gimple value, or not a cast
|
||
of a valid gimple value, then we can not use the result. */
|
||
if (is_gimple_val (new)
|
||
|| (is_gimple_cast (new)
|
||
&& is_gimple_val (TREE_OPERAND (new, 0))))
|
||
return new;
|
||
}
|
||
break;
|
||
|
||
case BUILT_IN_STRCPY:
|
||
if (val[1] && is_gimple_val (val[1]))
|
||
result = fold_builtin_strcpy (callee, arglist, val[1]);
|
||
break;
|
||
|
||
case BUILT_IN_STRNCPY:
|
||
if (val[1] && is_gimple_val (val[1]))
|
||
result = fold_builtin_strncpy (callee, arglist, val[1]);
|
||
break;
|
||
|
||
case BUILT_IN_FPUTS:
|
||
result = fold_builtin_fputs (arglist,
|
||
TREE_CODE (stmt) != MODIFY_EXPR, 0,
|
||
val[0]);
|
||
break;
|
||
|
||
case BUILT_IN_FPUTS_UNLOCKED:
|
||
result = fold_builtin_fputs (arglist,
|
||
TREE_CODE (stmt) != MODIFY_EXPR, 1,
|
||
val[0]);
|
||
break;
|
||
|
||
case BUILT_IN_MEMCPY_CHK:
|
||
case BUILT_IN_MEMPCPY_CHK:
|
||
case BUILT_IN_MEMMOVE_CHK:
|
||
case BUILT_IN_MEMSET_CHK:
|
||
if (val[2] && is_gimple_val (val[2]))
|
||
result = fold_builtin_memory_chk (callee, arglist, val[2], ignore,
|
||
DECL_FUNCTION_CODE (callee));
|
||
break;
|
||
|
||
case BUILT_IN_STRCPY_CHK:
|
||
case BUILT_IN_STPCPY_CHK:
|
||
if (val[1] && is_gimple_val (val[1]))
|
||
result = fold_builtin_stxcpy_chk (callee, arglist, val[1], ignore,
|
||
DECL_FUNCTION_CODE (callee));
|
||
break;
|
||
|
||
case BUILT_IN_STRNCPY_CHK:
|
||
if (val[2] && is_gimple_val (val[2]))
|
||
result = fold_builtin_strncpy_chk (arglist, val[2]);
|
||
break;
|
||
|
||
case BUILT_IN_SNPRINTF_CHK:
|
||
case BUILT_IN_VSNPRINTF_CHK:
|
||
if (val[1] && is_gimple_val (val[1]))
|
||
result = fold_builtin_snprintf_chk (arglist, val[1],
|
||
DECL_FUNCTION_CODE (callee));
|
||
break;
|
||
|
||
default:
|
||
gcc_unreachable ();
|
||
}
|
||
|
||
if (result && ignore)
|
||
result = fold_ignored_result (result);
|
||
return result;
|
||
}
|
||
|
||
|
||
/* Fold the statement pointed to by STMT_P. In some cases, this function may
|
||
replace the whole statement with a new one. Returns true iff folding
|
||
makes any changes. */
|
||
|
||
bool
|
||
fold_stmt (tree *stmt_p)
|
||
{
|
||
tree rhs, result, stmt;
|
||
struct fold_stmt_r_data fold_stmt_r_data;
|
||
bool changed = false;
|
||
bool inside_addr_expr = false;
|
||
|
||
stmt = *stmt_p;
|
||
|
||
fold_stmt_r_data.stmt = stmt;
|
||
fold_stmt_r_data.changed_p = &changed;
|
||
fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
|
||
|
||
/* If we replaced constants and the statement makes pointer dereferences,
|
||
then we may need to fold instances of *&VAR into VAR, etc. */
|
||
if (walk_tree (stmt_p, fold_stmt_r, &fold_stmt_r_data, NULL))
|
||
{
|
||
*stmt_p
|
||
= build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
|
||
NULL);
|
||
return true;
|
||
}
|
||
|
||
rhs = get_rhs (stmt);
|
||
if (!rhs)
|
||
return changed;
|
||
result = NULL_TREE;
|
||
|
||
if (TREE_CODE (rhs) == CALL_EXPR)
|
||
{
|
||
tree callee;
|
||
|
||
/* Check for builtins that CCP can handle using information not
|
||
available in the generic fold routines. */
|
||
callee = get_callee_fndecl (rhs);
|
||
if (callee && DECL_BUILT_IN (callee))
|
||
result = ccp_fold_builtin (stmt, rhs);
|
||
else
|
||
{
|
||
/* Check for resolvable OBJ_TYPE_REF. The only sorts we can resolve
|
||
here are when we've propagated the address of a decl into the
|
||
object slot. */
|
||
/* ??? Should perhaps do this in fold proper. However, doing it
|
||
there requires that we create a new CALL_EXPR, and that requires
|
||
copying EH region info to the new node. Easier to just do it
|
||
here where we can just smash the call operand. Also
|
||
CALL_EXPR_RETURN_SLOT_OPT needs to be handled correctly and
|
||
copied, fold_ternary does not have not information. */
|
||
callee = TREE_OPERAND (rhs, 0);
|
||
if (TREE_CODE (callee) == OBJ_TYPE_REF
|
||
&& lang_hooks.fold_obj_type_ref
|
||
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
|
||
&& DECL_P (TREE_OPERAND
|
||
(OBJ_TYPE_REF_OBJECT (callee), 0)))
|
||
{
|
||
tree t;
|
||
|
||
/* ??? Caution: Broken ADDR_EXPR semantics means that
|
||
looking at the type of the operand of the addr_expr
|
||
can yield an array type. See silly exception in
|
||
check_pointer_types_r. */
|
||
|
||
t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
|
||
t = lang_hooks.fold_obj_type_ref (callee, t);
|
||
if (t)
|
||
{
|
||
TREE_OPERAND (rhs, 0) = t;
|
||
changed = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* If we couldn't fold the RHS, hand over to the generic fold routines. */
|
||
if (result == NULL_TREE)
|
||
result = fold (rhs);
|
||
|
||
/* Strip away useless type conversions. Both the NON_LVALUE_EXPR that
|
||
may have been added by fold, and "useless" type conversions that might
|
||
now be apparent due to propagation. */
|
||
STRIP_USELESS_TYPE_CONVERSION (result);
|
||
|
||
if (result != rhs)
|
||
changed |= set_rhs (stmt_p, result);
|
||
|
||
return changed;
|
||
}
|
||
|
||
/* Perform the minimal folding on statement STMT. Only operations like
|
||
*&x created by constant propagation are handled. The statement cannot
|
||
be replaced with a new one. */
|
||
|
||
bool
|
||
fold_stmt_inplace (tree stmt)
|
||
{
|
||
tree old_stmt = stmt, rhs, new_rhs;
|
||
struct fold_stmt_r_data fold_stmt_r_data;
|
||
bool changed = false;
|
||
bool inside_addr_expr = false;
|
||
|
||
fold_stmt_r_data.stmt = stmt;
|
||
fold_stmt_r_data.changed_p = &changed;
|
||
fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
|
||
|
||
walk_tree (&stmt, fold_stmt_r, &fold_stmt_r_data, NULL);
|
||
gcc_assert (stmt == old_stmt);
|
||
|
||
rhs = get_rhs (stmt);
|
||
if (!rhs || rhs == stmt)
|
||
return changed;
|
||
|
||
new_rhs = fold (rhs);
|
||
STRIP_USELESS_TYPE_CONVERSION (new_rhs);
|
||
if (new_rhs == rhs)
|
||
return changed;
|
||
|
||
changed |= set_rhs (&stmt, new_rhs);
|
||
gcc_assert (stmt == old_stmt);
|
||
|
||
return changed;
|
||
}
|
||
|
||
/* Convert EXPR into a GIMPLE value suitable for substitution on the
|
||
RHS of an assignment. Insert the necessary statements before
|
||
iterator *SI_P. */
|
||
|
||
static tree
|
||
convert_to_gimple_builtin (block_stmt_iterator *si_p, tree expr)
|
||
{
|
||
tree_stmt_iterator ti;
|
||
tree stmt = bsi_stmt (*si_p);
|
||
tree tmp, stmts = NULL;
|
||
|
||
push_gimplify_context ();
|
||
tmp = get_initialized_tmp_var (expr, &stmts, NULL);
|
||
pop_gimplify_context (NULL);
|
||
|
||
if (EXPR_HAS_LOCATION (stmt))
|
||
annotate_all_with_locus (&stmts, EXPR_LOCATION (stmt));
|
||
|
||
/* The replacement can expose previously unreferenced variables. */
|
||
for (ti = tsi_start (stmts); !tsi_end_p (ti); tsi_next (&ti))
|
||
{
|
||
tree new_stmt = tsi_stmt (ti);
|
||
find_new_referenced_vars (tsi_stmt_ptr (ti));
|
||
bsi_insert_before (si_p, new_stmt, BSI_NEW_STMT);
|
||
mark_new_vars_to_rename (bsi_stmt (*si_p));
|
||
bsi_next (si_p);
|
||
}
|
||
|
||
return tmp;
|
||
}
|
||
|
||
|
||
/* A simple pass that attempts to fold all builtin functions. This pass
|
||
is run after we've propagated as many constants as we can. */
|
||
|
||
static unsigned int
|
||
execute_fold_all_builtins (void)
|
||
{
|
||
bool cfg_changed = false;
|
||
basic_block bb;
|
||
FOR_EACH_BB (bb)
|
||
{
|
||
block_stmt_iterator i;
|
||
for (i = bsi_start (bb); !bsi_end_p (i); )
|
||
{
|
||
tree *stmtp = bsi_stmt_ptr (i);
|
||
tree old_stmt = *stmtp;
|
||
tree call = get_rhs (*stmtp);
|
||
tree callee, result;
|
||
enum built_in_function fcode;
|
||
|
||
if (!call || TREE_CODE (call) != CALL_EXPR)
|
||
{
|
||
bsi_next (&i);
|
||
continue;
|
||
}
|
||
callee = get_callee_fndecl (call);
|
||
if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
|
||
{
|
||
bsi_next (&i);
|
||
continue;
|
||
}
|
||
fcode = DECL_FUNCTION_CODE (callee);
|
||
|
||
result = ccp_fold_builtin (*stmtp, call);
|
||
if (!result)
|
||
switch (DECL_FUNCTION_CODE (callee))
|
||
{
|
||
case BUILT_IN_CONSTANT_P:
|
||
/* Resolve __builtin_constant_p. If it hasn't been
|
||
folded to integer_one_node by now, it's fairly
|
||
certain that the value simply isn't constant. */
|
||
result = integer_zero_node;
|
||
break;
|
||
|
||
default:
|
||
bsi_next (&i);
|
||
continue;
|
||
}
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file, "Simplified\n ");
|
||
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
||
}
|
||
|
||
if (!set_rhs (stmtp, result))
|
||
{
|
||
result = convert_to_gimple_builtin (&i, result);
|
||
if (result)
|
||
{
|
||
bool ok = set_rhs (stmtp, result);
|
||
|
||
gcc_assert (ok);
|
||
}
|
||
}
|
||
mark_new_vars_to_rename (*stmtp);
|
||
if (maybe_clean_or_replace_eh_stmt (old_stmt, *stmtp)
|
||
&& tree_purge_dead_eh_edges (bb))
|
||
cfg_changed = true;
|
||
|
||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||
{
|
||
fprintf (dump_file, "to\n ");
|
||
print_generic_stmt (dump_file, *stmtp, dump_flags);
|
||
fprintf (dump_file, "\n");
|
||
}
|
||
|
||
/* Retry the same statement if it changed into another
|
||
builtin, there might be new opportunities now. */
|
||
call = get_rhs (*stmtp);
|
||
if (!call || TREE_CODE (call) != CALL_EXPR)
|
||
{
|
||
bsi_next (&i);
|
||
continue;
|
||
}
|
||
callee = get_callee_fndecl (call);
|
||
if (!callee
|
||
|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
|
||
|| DECL_FUNCTION_CODE (callee) == fcode)
|
||
bsi_next (&i);
|
||
}
|
||
}
|
||
|
||
/* Delete unreachable blocks. */
|
||
if (cfg_changed)
|
||
cleanup_tree_cfg ();
|
||
return 0;
|
||
}
|
||
|
||
|
||
struct tree_opt_pass pass_fold_builtins =
|
||
{
|
||
"fab", /* name */
|
||
NULL, /* gate */
|
||
execute_fold_all_builtins, /* execute */
|
||
NULL, /* sub */
|
||
NULL, /* next */
|
||
0, /* static_pass_number */
|
||
0, /* tv_id */
|
||
PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
||
0, /* properties_provided */
|
||
0, /* properties_destroyed */
|
||
0, /* todo_flags_start */
|
||
TODO_dump_func
|
||
| TODO_verify_ssa
|
||
| TODO_update_ssa, /* todo_flags_finish */
|
||
0 /* letter */
|
||
};
|