/* Callgraph based analysis of static variables.
|
/* Callgraph based analysis of static variables.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
|
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
|
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* This file mark functions as being either const (TREE_READONLY) or
|
/* This file mark functions as being either const (TREE_READONLY) or
|
pure (DECL_IS_PURE).
|
pure (DECL_IS_PURE).
|
|
|
This must be run after inlining decisions have been made since
|
This must be run after inlining decisions have been made since
|
otherwise, the local sets will not contain information that is
|
otherwise, the local sets will not contain information that is
|
consistent with post inlined state. The global sets are not prone
|
consistent with post inlined state. The global sets are not prone
|
to this problem since they are by definition transitive. */
|
to this problem since they are by definition transitive. */
|
|
|
/* The code in this module is called by the ipa pass manager. It
|
/* The code in this module is called by the ipa pass manager. It
|
should be one of the later passes since it's information is used by
|
should be one of the later passes since it's information is used by
|
the rest of the compilation. */
|
the rest of the compilation. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "ipa-utils.h"
|
#include "ipa-utils.h"
|
#include "c-common.h"
|
#include "c-common.h"
|
#include "tree-gimple.h"
|
#include "tree-gimple.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "output.h"
|
#include "output.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
static struct pointer_set_t *visited_nodes;
|
static struct pointer_set_t *visited_nodes;
|
|
|
/* Lattice values for const and pure functions. Everything starts out
|
/* Lattice values for const and pure functions. Everything starts out
|
being const, then may drop to pure and then neither depending on
|
being const, then may drop to pure and then neither depending on
|
what is found. */
|
what is found. */
|
enum pure_const_state_e
|
enum pure_const_state_e
|
{
|
{
|
IPA_CONST,
|
IPA_CONST,
|
IPA_PURE,
|
IPA_PURE,
|
IPA_NEITHER
|
IPA_NEITHER
|
};
|
};
|
|
|
/* Holder inserted into the ipa_dfs_info aux field to hold the
|
/* Holder inserted into the ipa_dfs_info aux field to hold the
|
const_state. */
|
const_state. */
|
struct funct_state_d
|
struct funct_state_d
|
{
|
{
|
enum pure_const_state_e pure_const_state;
|
enum pure_const_state_e pure_const_state;
|
bool state_set_in_source;
|
bool state_set_in_source;
|
};
|
};
|
|
|
typedef struct funct_state_d * funct_state;
|
typedef struct funct_state_d * funct_state;
|
|
|
/* Return the function state from NODE. */
|
/* Return the function state from NODE. */
|
|
|
static inline funct_state
|
static inline funct_state
|
get_function_state (struct cgraph_node *node)
|
get_function_state (struct cgraph_node *node)
|
{
|
{
|
struct ipa_dfs_info * info = node->aux;
|
struct ipa_dfs_info * info = node->aux;
|
return info->aux;
|
return info->aux;
|
}
|
}
|
|
|
/* Check to see if the use (or definition when CHECHING_WRITE is true)
|
/* Check to see if the use (or definition when CHECHING_WRITE is true)
|
variable T is legal in a function that is either pure or const. */
|
variable T is legal in a function that is either pure or const. */
|
|
|
static inline void
|
static inline void
|
check_decl (funct_state local,
|
check_decl (funct_state local,
|
tree t, bool checking_write)
|
tree t, bool checking_write)
|
{
|
{
|
/* If the variable has the "used" attribute, treat it as if it had a
|
/* If the variable has the "used" attribute, treat it as if it had a
|
been touched by the devil. */
|
been touched by the devil. */
|
if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
|
if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
|
{
|
{
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
return;
|
return;
|
}
|
}
|
|
|
/* Do not want to do anything with volatile except mark any
|
/* Do not want to do anything with volatile except mark any
|
function that uses one to be not const or pure. */
|
function that uses one to be not const or pure. */
|
if (TREE_THIS_VOLATILE (t))
|
if (TREE_THIS_VOLATILE (t))
|
{
|
{
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
return;
|
return;
|
}
|
}
|
|
|
/* Do not care about a local automatic that is not static. */
|
/* Do not care about a local automatic that is not static. */
|
if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
|
if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
|
return;
|
return;
|
|
|
/* Since we have dealt with the locals and params cases above, if we
|
/* Since we have dealt with the locals and params cases above, if we
|
are CHECKING_WRITE, this cannot be a pure or constant
|
are CHECKING_WRITE, this cannot be a pure or constant
|
function. */
|
function. */
|
if (checking_write)
|
if (checking_write)
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
|
|
if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
|
if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
|
{
|
{
|
/* If the front end set the variable to be READONLY and
|
/* If the front end set the variable to be READONLY and
|
constant, we can allow this variable in pure or const
|
constant, we can allow this variable in pure or const
|
functions but the scope is too large for our analysis to set
|
functions but the scope is too large for our analysis to set
|
these bits ourselves. */
|
these bits ourselves. */
|
|
|
if (TREE_READONLY (t)
|
if (TREE_READONLY (t)
|
&& DECL_INITIAL (t)
|
&& DECL_INITIAL (t)
|
&& is_gimple_min_invariant (DECL_INITIAL (t)))
|
&& is_gimple_min_invariant (DECL_INITIAL (t)))
|
; /* Read of a constant, do not change the function state. */
|
; /* Read of a constant, do not change the function state. */
|
else
|
else
|
{
|
{
|
/* Just a regular read. */
|
/* Just a regular read. */
|
if (local->pure_const_state == IPA_CONST)
|
if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
}
|
}
|
|
|
/* Compilation level statics can be read if they are readonly
|
/* Compilation level statics can be read if they are readonly
|
variables. */
|
variables. */
|
if (TREE_READONLY (t))
|
if (TREE_READONLY (t))
|
return;
|
return;
|
|
|
/* Just a regular read. */
|
/* Just a regular read. */
|
if (local->pure_const_state == IPA_CONST)
|
if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
|
|
/* If T is a VAR_DECL check to see if it is an allowed reference. */
|
/* If T is a VAR_DECL check to see if it is an allowed reference. */
|
|
|
static void
|
static void
|
check_operand (funct_state local,
|
check_operand (funct_state local,
|
tree t, bool checking_write)
|
tree t, bool checking_write)
|
{
|
{
|
if (!t) return;
|
if (!t) return;
|
|
|
if (TREE_CODE (t) == VAR_DECL)
|
if (TREE_CODE (t) == VAR_DECL)
|
check_decl (local, t, checking_write);
|
check_decl (local, t, checking_write);
|
}
|
}
|
|
|
/* Examine tree T for references. */
|
/* Examine tree T for references. */
|
|
|
static void
|
static void
|
check_tree (funct_state local, tree t, bool checking_write)
|
check_tree (funct_state local, tree t, bool checking_write)
|
{
|
{
|
if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR))
|
if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR))
|
return;
|
return;
|
|
|
/* Any tree which is volatile disqualifies thie function from being
|
/* Any tree which is volatile disqualifies thie function from being
|
const or pure. */
|
const or pure. */
|
if (TREE_THIS_VOLATILE (t))
|
if (TREE_THIS_VOLATILE (t))
|
{
|
{
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
return;
|
return;
|
}
|
}
|
|
|
while (TREE_CODE (t) == REALPART_EXPR
|
while (TREE_CODE (t) == REALPART_EXPR
|
|| TREE_CODE (t) == IMAGPART_EXPR
|
|| TREE_CODE (t) == IMAGPART_EXPR
|
|| handled_component_p (t))
|
|| handled_component_p (t))
|
{
|
{
|
if (TREE_CODE (t) == ARRAY_REF)
|
if (TREE_CODE (t) == ARRAY_REF)
|
check_operand (local, TREE_OPERAND (t, 1), false);
|
check_operand (local, TREE_OPERAND (t, 1), false);
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
}
|
}
|
|
|
/* The bottom of an indirect reference can only be read, not
|
/* The bottom of an indirect reference can only be read, not
|
written. */
|
written. */
|
if (INDIRECT_REF_P (t))
|
if (INDIRECT_REF_P (t))
|
{
|
{
|
check_tree (local, TREE_OPERAND (t, 0), false);
|
check_tree (local, TREE_OPERAND (t, 0), false);
|
|
|
/* Any indirect reference that occurs on the lhs
|
/* Any indirect reference that occurs on the lhs
|
disqualifies the function from being pure or const. Any
|
disqualifies the function from being pure or const. Any
|
indirect reference that occurs on the rhs disqualifies the
|
indirect reference that occurs on the rhs disqualifies the
|
function from being const. */
|
function from being const. */
|
if (checking_write)
|
if (checking_write)
|
{
|
{
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
return;
|
return;
|
}
|
}
|
else if (local->pure_const_state == IPA_CONST)
|
else if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
|
|
if (SSA_VAR_P (t))
|
if (SSA_VAR_P (t))
|
check_operand (local, t, checking_write);
|
check_operand (local, t, checking_write);
|
}
|
}
|
|
|
/* Scan tree T to see if there are any addresses taken in within T. */
|
/* Scan tree T to see if there are any addresses taken in within T. */
|
|
|
static void
|
static void
|
look_for_address_of (funct_state local, tree t)
|
look_for_address_of (funct_state local, tree t)
|
{
|
{
|
if (TREE_CODE (t) == ADDR_EXPR)
|
if (TREE_CODE (t) == ADDR_EXPR)
|
{
|
{
|
tree x = get_base_var (t);
|
tree x = get_base_var (t);
|
if (TREE_CODE (x) == VAR_DECL)
|
if (TREE_CODE (x) == VAR_DECL)
|
{
|
{
|
check_decl (local, x, false);
|
check_decl (local, x, false);
|
|
|
/* Taking the address of something appears to be reasonable
|
/* Taking the address of something appears to be reasonable
|
in PURE code. Not allowed in const. */
|
in PURE code. Not allowed in const. */
|
if (local->pure_const_state == IPA_CONST)
|
if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Check to see if T is a read or address of operation on a var we are
|
/* Check to see if T is a read or address of operation on a var we are
|
interested in analyzing. LOCAL is passed in to get access to its
|
interested in analyzing. LOCAL is passed in to get access to its
|
bit vectors. */
|
bit vectors. */
|
|
|
static void
|
static void
|
check_rhs_var (funct_state local, tree t)
|
check_rhs_var (funct_state local, tree t)
|
{
|
{
|
look_for_address_of (local, t);
|
look_for_address_of (local, t);
|
|
|
/* Memcmp and strlen can both trap and they are declared pure. */
|
/* Memcmp and strlen can both trap and they are declared pure. */
|
if (tree_could_trap_p (t)
|
if (tree_could_trap_p (t)
|
&& local->pure_const_state == IPA_CONST)
|
&& local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
|
|
check_tree(local, t, false);
|
check_tree(local, t, false);
|
}
|
}
|
|
|
/* Check to see if T is an assignment to a var we are interested in
|
/* Check to see if T is an assignment to a var we are interested in
|
analyzing. LOCAL is passed in to get access to its bit vectors. */
|
analyzing. LOCAL is passed in to get access to its bit vectors. */
|
|
|
static void
|
static void
|
check_lhs_var (funct_state local, tree t)
|
check_lhs_var (funct_state local, tree t)
|
{
|
{
|
/* Memcmp and strlen can both trap and they are declared pure.
|
/* Memcmp and strlen can both trap and they are declared pure.
|
Which seems to imply that we can apply the same rule here. */
|
Which seems to imply that we can apply the same rule here. */
|
if (tree_could_trap_p (t)
|
if (tree_could_trap_p (t)
|
&& local->pure_const_state == IPA_CONST)
|
&& local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
|
|
check_tree(local, t, true);
|
check_tree(local, t, true);
|
}
|
}
|
|
|
/* This is a scaled down version of get_asm_expr_operands from
|
/* This is a scaled down version of get_asm_expr_operands from
|
tree_ssa_operands.c. The version there runs much later and assumes
|
tree_ssa_operands.c. The version there runs much later and assumes
|
that aliasing information is already available. Here we are just
|
that aliasing information is already available. Here we are just
|
trying to find if the set of inputs and outputs contain references
|
trying to find if the set of inputs and outputs contain references
|
or address of operations to local static variables. STMT is the
|
or address of operations to local static variables. STMT is the
|
actual asm statement. */
|
actual asm statement. */
|
|
|
static void
|
static void
|
get_asm_expr_operands (funct_state local, tree stmt)
|
get_asm_expr_operands (funct_state local, tree stmt)
|
{
|
{
|
int noutputs = list_length (ASM_OUTPUTS (stmt));
|
int noutputs = list_length (ASM_OUTPUTS (stmt));
|
const char **oconstraints
|
const char **oconstraints
|
= (const char **) alloca ((noutputs) * sizeof (const char *));
|
= (const char **) alloca ((noutputs) * sizeof (const char *));
|
int i;
|
int i;
|
tree link;
|
tree link;
|
const char *constraint;
|
const char *constraint;
|
bool allows_mem, allows_reg, is_inout;
|
bool allows_mem, allows_reg, is_inout;
|
|
|
for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
|
for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
|
{
|
{
|
oconstraints[i] = constraint
|
oconstraints[i] = constraint
|
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
parse_output_constraint (&constraint, i, 0, 0,
|
parse_output_constraint (&constraint, i, 0, 0,
|
&allows_mem, &allows_reg, &is_inout);
|
&allows_mem, &allows_reg, &is_inout);
|
|
|
check_lhs_var (local, TREE_VALUE (link));
|
check_lhs_var (local, TREE_VALUE (link));
|
}
|
}
|
|
|
for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
|
for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
|
{
|
{
|
constraint
|
constraint
|
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
|
parse_input_constraint (&constraint, 0, 0, noutputs, 0,
|
parse_input_constraint (&constraint, 0, 0, noutputs, 0,
|
oconstraints, &allows_mem, &allows_reg);
|
oconstraints, &allows_mem, &allows_reg);
|
|
|
check_rhs_var (local, TREE_VALUE (link));
|
check_rhs_var (local, TREE_VALUE (link));
|
}
|
}
|
|
|
for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
|
for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
|
if (simple_cst_equal(TREE_VALUE (link), memory_identifier_string) == 1)
|
if (simple_cst_equal(TREE_VALUE (link), memory_identifier_string) == 1)
|
/* Abandon all hope, ye who enter here. */
|
/* Abandon all hope, ye who enter here. */
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
|
|
if (ASM_VOLATILE_P (stmt))
|
if (ASM_VOLATILE_P (stmt))
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
}
|
}
|
|
|
/* Check the parameters of a function call to CALL_EXPR to see if
|
/* Check the parameters of a function call to CALL_EXPR to see if
|
there are any references in the parameters that are not allowed for
|
there are any references in the parameters that are not allowed for
|
pure or const functions. Also check to see if this is either an
|
pure or const functions. Also check to see if this is either an
|
indirect call, a call outside the compilation unit, or has special
|
indirect call, a call outside the compilation unit, or has special
|
attributes that may also effect the purity. The CALL_EXPR node for
|
attributes that may also effect the purity. The CALL_EXPR node for
|
the entire call expression. */
|
the entire call expression. */
|
|
|
static void
|
static void
|
check_call (funct_state local, tree call_expr)
|
check_call (funct_state local, tree call_expr)
|
{
|
{
|
int flags = call_expr_flags(call_expr);
|
int flags = call_expr_flags(call_expr);
|
tree operand_list = TREE_OPERAND (call_expr, 1);
|
tree operand_list = TREE_OPERAND (call_expr, 1);
|
tree operand;
|
tree operand;
|
tree callee_t = get_callee_fndecl (call_expr);
|
tree callee_t = get_callee_fndecl (call_expr);
|
struct cgraph_node* callee;
|
struct cgraph_node* callee;
|
enum availability avail = AVAIL_NOT_AVAILABLE;
|
enum availability avail = AVAIL_NOT_AVAILABLE;
|
|
|
for (operand = operand_list;
|
for (operand = operand_list;
|
operand != NULL_TREE;
|
operand != NULL_TREE;
|
operand = TREE_CHAIN (operand))
|
operand = TREE_CHAIN (operand))
|
{
|
{
|
tree argument = TREE_VALUE (operand);
|
tree argument = TREE_VALUE (operand);
|
check_rhs_var (local, argument);
|
check_rhs_var (local, argument);
|
}
|
}
|
|
|
/* The const and pure flags are set by a variety of places in the
|
/* The const and pure flags are set by a variety of places in the
|
compiler (including here). If someone has already set the flags
|
compiler (including here). If someone has already set the flags
|
for the callee, (such as for some of the builtins) we will use
|
for the callee, (such as for some of the builtins) we will use
|
them, otherwise we will compute our own information.
|
them, otherwise we will compute our own information.
|
|
|
Const and pure functions have less clobber effects than other
|
Const and pure functions have less clobber effects than other
|
functions so we process these first. Otherwise if it is a call
|
functions so we process these first. Otherwise if it is a call
|
outside the compilation unit or an indirect call we punt. This
|
outside the compilation unit or an indirect call we punt. This
|
leaves local calls which will be processed by following the call
|
leaves local calls which will be processed by following the call
|
graph. */
|
graph. */
|
if (callee_t)
|
if (callee_t)
|
{
|
{
|
callee = cgraph_node(callee_t);
|
callee = cgraph_node(callee_t);
|
avail = cgraph_function_body_availability (callee);
|
avail = cgraph_function_body_availability (callee);
|
|
|
/* When bad things happen to bad functions, they cannot be const
|
/* When bad things happen to bad functions, they cannot be const
|
or pure. */
|
or pure. */
|
if (setjmp_call_p (callee_t))
|
if (setjmp_call_p (callee_t))
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
|
|
if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
|
if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
|
switch (DECL_FUNCTION_CODE (callee_t))
|
switch (DECL_FUNCTION_CODE (callee_t))
|
{
|
{
|
case BUILT_IN_LONGJMP:
|
case BUILT_IN_LONGJMP:
|
case BUILT_IN_NONLOCAL_GOTO:
|
case BUILT_IN_NONLOCAL_GOTO:
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* The callee is either unknown (indirect call) or there is just no
|
/* The callee is either unknown (indirect call) or there is just no
|
scannable code for it (external call) . We look to see if there
|
scannable code for it (external call) . We look to see if there
|
are any bits available for the callee (such as by declaration or
|
are any bits available for the callee (such as by declaration or
|
because it is builtin) and process solely on the basis of those
|
because it is builtin) and process solely on the basis of those
|
bits. */
|
bits. */
|
if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
|
if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
|
{
|
{
|
if (flags & ECF_PURE)
|
if (flags & ECF_PURE)
|
{
|
{
|
if (local->pure_const_state == IPA_CONST)
|
if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
else
|
else
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We have the code and we will scan it for the effects. */
|
/* We have the code and we will scan it for the effects. */
|
if (flags & ECF_PURE)
|
if (flags & ECF_PURE)
|
{
|
{
|
if (local->pure_const_state == IPA_CONST)
|
if (local->pure_const_state == IPA_CONST)
|
local->pure_const_state = IPA_PURE;
|
local->pure_const_state = IPA_PURE;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* TP is the part of the tree currently under the microscope.
|
/* TP is the part of the tree currently under the microscope.
|
WALK_SUBTREES is part of the walk_tree api but is unused here.
|
WALK_SUBTREES is part of the walk_tree api but is unused here.
|
DATA is cgraph_node of the function being walked. */
|
DATA is cgraph_node of the function being walked. */
|
|
|
/* FIXME: When this is converted to run over SSA form, this code
|
/* FIXME: When this is converted to run over SSA form, this code
|
should be converted to use the operand scanner. */
|
should be converted to use the operand scanner. */
|
|
|
static tree
|
static tree
|
scan_function (tree *tp,
|
scan_function (tree *tp,
|
int *walk_subtrees,
|
int *walk_subtrees,
|
void *data)
|
void *data)
|
{
|
{
|
struct cgraph_node *fn = data;
|
struct cgraph_node *fn = data;
|
tree t = *tp;
|
tree t = *tp;
|
funct_state local = get_function_state (fn);
|
funct_state local = get_function_state (fn);
|
|
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case VAR_DECL:
|
case VAR_DECL:
|
if (DECL_INITIAL (t))
|
if (DECL_INITIAL (t))
|
walk_tree (&DECL_INITIAL (t), scan_function, fn, visited_nodes);
|
walk_tree (&DECL_INITIAL (t), scan_function, fn, visited_nodes);
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
{
|
{
|
/* First look on the lhs and see what variable is stored to */
|
/* First look on the lhs and see what variable is stored to */
|
tree lhs = TREE_OPERAND (t, 0);
|
tree lhs = TREE_OPERAND (t, 0);
|
tree rhs = TREE_OPERAND (t, 1);
|
tree rhs = TREE_OPERAND (t, 1);
|
check_lhs_var (local, lhs);
|
check_lhs_var (local, lhs);
|
|
|
/* For the purposes of figuring out what the cast affects */
|
/* For the purposes of figuring out what the cast affects */
|
|
|
/* Next check the operands on the rhs to see if they are ok. */
|
/* Next check the operands on the rhs to see if they are ok. */
|
switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
|
switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
|
{
|
{
|
case tcc_binary:
|
case tcc_binary:
|
{
|
{
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
check_rhs_var (local, op0);
|
check_rhs_var (local, op0);
|
check_rhs_var (local, op1);
|
check_rhs_var (local, op1);
|
}
|
}
|
break;
|
break;
|
case tcc_unary:
|
case tcc_unary:
|
{
|
{
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op0 = TREE_OPERAND (rhs, 0);
|
check_rhs_var (local, op0);
|
check_rhs_var (local, op0);
|
}
|
}
|
|
|
break;
|
break;
|
case tcc_reference:
|
case tcc_reference:
|
check_rhs_var (local, rhs);
|
check_rhs_var (local, rhs);
|
break;
|
break;
|
case tcc_declaration:
|
case tcc_declaration:
|
check_rhs_var (local, rhs);
|
check_rhs_var (local, rhs);
|
break;
|
break;
|
case tcc_expression:
|
case tcc_expression:
|
switch (TREE_CODE (rhs))
|
switch (TREE_CODE (rhs))
|
{
|
{
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
check_rhs_var (local, rhs);
|
check_rhs_var (local, rhs);
|
break;
|
break;
|
case CALL_EXPR:
|
case CALL_EXPR:
|
check_call (local, rhs);
|
check_call (local, rhs);
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
}
|
}
|
break;
|
break;
|
|
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
/* This case is here to find addresses on rhs of constructors in
|
/* This case is here to find addresses on rhs of constructors in
|
decl_initial of static variables. */
|
decl_initial of static variables. */
|
check_rhs_var (local, t);
|
check_rhs_var (local, t);
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
case LABEL_EXPR:
|
case LABEL_EXPR:
|
if (DECL_NONLOCAL (TREE_OPERAND (t, 0)))
|
if (DECL_NONLOCAL (TREE_OPERAND (t, 0)))
|
/* Target of long jump. */
|
/* Target of long jump. */
|
local->pure_const_state = IPA_NEITHER;
|
local->pure_const_state = IPA_NEITHER;
|
break;
|
break;
|
|
|
case CALL_EXPR:
|
case CALL_EXPR:
|
check_call (local, t);
|
check_call (local, t);
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
case ASM_EXPR:
|
case ASM_EXPR:
|
get_asm_expr_operands (local, t);
|
get_asm_expr_operands (local, t);
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* This is the main routine for finding the reference patterns for
|
/* This is the main routine for finding the reference patterns for
|
global variables within a function FN. */
|
global variables within a function FN. */
|
|
|
static void
|
static void
|
analyze_function (struct cgraph_node *fn)
|
analyze_function (struct cgraph_node *fn)
|
{
|
{
|
funct_state l = XCNEW (struct funct_state_d);
|
funct_state l = XCNEW (struct funct_state_d);
|
tree decl = fn->decl;
|
tree decl = fn->decl;
|
struct ipa_dfs_info * w_info = fn->aux;
|
struct ipa_dfs_info * w_info = fn->aux;
|
|
|
w_info->aux = l;
|
w_info->aux = l;
|
|
|
l->pure_const_state = IPA_CONST;
|
l->pure_const_state = IPA_CONST;
|
l->state_set_in_source = false;
|
l->state_set_in_source = false;
|
|
|
/* If this function does not return normally or does not bind local,
|
/* If this function does not return normally or does not bind local,
|
do not touch this unless it has been marked as const or pure by the
|
do not touch this unless it has been marked as const or pure by the
|
front end. */
|
front end. */
|
if (TREE_THIS_VOLATILE (decl)
|
if (TREE_THIS_VOLATILE (decl)
|
|| !targetm.binds_local_p (decl))
|
|| !targetm.binds_local_p (decl))
|
{
|
{
|
l->pure_const_state = IPA_NEITHER;
|
l->pure_const_state = IPA_NEITHER;
|
return;
|
return;
|
}
|
}
|
|
|
if (TREE_READONLY (decl))
|
if (TREE_READONLY (decl))
|
{
|
{
|
l->pure_const_state = IPA_CONST;
|
l->pure_const_state = IPA_CONST;
|
l->state_set_in_source = true;
|
l->state_set_in_source = true;
|
}
|
}
|
if (DECL_IS_PURE (decl))
|
if (DECL_IS_PURE (decl))
|
{
|
{
|
l->pure_const_state = IPA_PURE;
|
l->pure_const_state = IPA_PURE;
|
l->state_set_in_source = true;
|
l->state_set_in_source = true;
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "\n local analysis of %s with initial value = %d\n ",
|
fprintf (dump_file, "\n local analysis of %s with initial value = %d\n ",
|
cgraph_node_name (fn),
|
cgraph_node_name (fn),
|
l->pure_const_state);
|
l->pure_const_state);
|
}
|
}
|
|
|
if (!l->state_set_in_source)
|
if (!l->state_set_in_source)
|
{
|
{
|
struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
|
struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
|
basic_block this_block;
|
basic_block this_block;
|
|
|
FOR_EACH_BB_FN (this_block, this_cfun)
|
FOR_EACH_BB_FN (this_block, this_cfun)
|
{
|
{
|
block_stmt_iterator bsi;
|
block_stmt_iterator bsi;
|
for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
|
for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
|
{
|
{
|
walk_tree (bsi_stmt_ptr (bsi), scan_function,
|
walk_tree (bsi_stmt_ptr (bsi), scan_function,
|
fn, visited_nodes);
|
fn, visited_nodes);
|
if (l->pure_const_state == IPA_NEITHER)
|
if (l->pure_const_state == IPA_NEITHER)
|
goto end;
|
goto end;
|
}
|
}
|
}
|
}
|
|
|
if (l->pure_const_state != IPA_NEITHER)
|
if (l->pure_const_state != IPA_NEITHER)
|
{
|
{
|
tree old_decl = current_function_decl;
|
tree old_decl = current_function_decl;
|
/* Const functions cannot have back edges (an
|
/* Const functions cannot have back edges (an
|
indication of possible infinite loop side
|
indication of possible infinite loop side
|
effect. */
|
effect. */
|
|
|
current_function_decl = fn->decl;
|
current_function_decl = fn->decl;
|
|
|
/* The C++ front end, has a tendency to some times jerk away
|
/* The C++ front end, has a tendency to some times jerk away
|
a function after it has created it. This should have
|
a function after it has created it. This should have
|
been fixed. */
|
been fixed. */
|
gcc_assert (DECL_STRUCT_FUNCTION (fn->decl));
|
gcc_assert (DECL_STRUCT_FUNCTION (fn->decl));
|
|
|
push_cfun (DECL_STRUCT_FUNCTION (fn->decl));
|
push_cfun (DECL_STRUCT_FUNCTION (fn->decl));
|
|
|
if (mark_dfs_back_edges ())
|
if (mark_dfs_back_edges ())
|
l->pure_const_state = IPA_NEITHER;
|
l->pure_const_state = IPA_NEITHER;
|
|
|
current_function_decl = old_decl;
|
current_function_decl = old_decl;
|
pop_cfun ();
|
pop_cfun ();
|
}
|
}
|
}
|
}
|
|
|
end:
|
end:
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "after local analysis of %s with initial value = %d\n ",
|
fprintf (dump_file, "after local analysis of %s with initial value = %d\n ",
|
cgraph_node_name (fn),
|
cgraph_node_name (fn),
|
l->pure_const_state);
|
l->pure_const_state);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Produce the global information by preforming a transitive closure
|
/* Produce the global information by preforming a transitive closure
|
on the local information that was produced by ipa_analyze_function
|
on the local information that was produced by ipa_analyze_function
|
and ipa_analyze_variable. */
|
and ipa_analyze_variable. */
|
|
|
static unsigned int
|
static unsigned int
|
static_execute (void)
|
static_execute (void)
|
{
|
{
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
struct cgraph_node *w;
|
struct cgraph_node *w;
|
struct cgraph_node **order =
|
struct cgraph_node **order =
|
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
|
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
|
int order_pos = order_pos = ipa_utils_reduced_inorder (order, true, false);
|
int order_pos = order_pos = ipa_utils_reduced_inorder (order, true, false);
|
int i;
|
int i;
|
struct ipa_dfs_info * w_info;
|
struct ipa_dfs_info * w_info;
|
|
|
if (!memory_identifier_string)
|
if (!memory_identifier_string)
|
memory_identifier_string = build_string(7, "memory");
|
memory_identifier_string = build_string(7, "memory");
|
|
|
/* There are some shared nodes, in particular the initializers on
|
/* There are some shared nodes, in particular the initializers on
|
static declarations. We do not need to scan them more than once
|
static declarations. We do not need to scan them more than once
|
since all we would be interested in are the addressof
|
since all we would be interested in are the addressof
|
operations. */
|
operations. */
|
visited_nodes = pointer_set_create ();
|
visited_nodes = pointer_set_create ();
|
|
|
/* Process all of the functions.
|
/* Process all of the functions.
|
|
|
We do not want to process any of the clones so we check that this
|
We do not want to process any of the clones so we check that this
|
is a master clone. However, we do NOT process any
|
is a master clone. However, we do NOT process any
|
AVAIL_OVERWRITABLE functions (these are never clones) we cannot
|
AVAIL_OVERWRITABLE functions (these are never clones) we cannot
|
guarantee that what we learn about the one we see will be true
|
guarantee that what we learn about the one we see will be true
|
for the one that overriders it.
|
for the one that overriders it.
|
*/
|
*/
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
if (node->analyzed && cgraph_is_master_clone (node))
|
if (node->analyzed && cgraph_is_master_clone (node))
|
analyze_function (node);
|
analyze_function (node);
|
|
|
pointer_set_destroy (visited_nodes);
|
pointer_set_destroy (visited_nodes);
|
visited_nodes = NULL;
|
visited_nodes = NULL;
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
dump_cgraph (dump_file);
|
dump_cgraph (dump_file);
|
ipa_utils_print_order(dump_file, "reduced", order, order_pos);
|
ipa_utils_print_order(dump_file, "reduced", order, order_pos);
|
}
|
}
|
|
|
/* Propagate the local information thru the call graph to produce
|
/* Propagate the local information thru the call graph to produce
|
the global information. All the nodes within a cycle will have
|
the global information. All the nodes within a cycle will have
|
the same info so we collapse cycles first. Then we can do the
|
the same info so we collapse cycles first. Then we can do the
|
propagation in one pass from the leaves to the roots. */
|
propagation in one pass from the leaves to the roots. */
|
for (i = 0; i < order_pos; i++ )
|
for (i = 0; i < order_pos; i++ )
|
{
|
{
|
enum pure_const_state_e pure_const_state = IPA_CONST;
|
enum pure_const_state_e pure_const_state = IPA_CONST;
|
node = order[i];
|
node = order[i];
|
|
|
/* Find the worst state for any node in the cycle. */
|
/* Find the worst state for any node in the cycle. */
|
w = node;
|
w = node;
|
while (w)
|
while (w)
|
{
|
{
|
funct_state w_l = get_function_state (w);
|
funct_state w_l = get_function_state (w);
|
if (pure_const_state < w_l->pure_const_state)
|
if (pure_const_state < w_l->pure_const_state)
|
pure_const_state = w_l->pure_const_state;
|
pure_const_state = w_l->pure_const_state;
|
|
|
if (pure_const_state == IPA_NEITHER)
|
if (pure_const_state == IPA_NEITHER)
|
break;
|
break;
|
|
|
if (!w_l->state_set_in_source)
|
if (!w_l->state_set_in_source)
|
{
|
{
|
struct cgraph_edge *e;
|
struct cgraph_edge *e;
|
for (e = w->callees; e; e = e->next_callee)
|
for (e = w->callees; e; e = e->next_callee)
|
{
|
{
|
struct cgraph_node *y = e->callee;
|
struct cgraph_node *y = e->callee;
|
/* Only look at the master nodes and skip external nodes. */
|
/* Only look at the master nodes and skip external nodes. */
|
y = cgraph_master_clone (y);
|
y = cgraph_master_clone (y);
|
if (y)
|
if (y)
|
{
|
{
|
funct_state y_l = get_function_state (y);
|
funct_state y_l = get_function_state (y);
|
if (pure_const_state < y_l->pure_const_state)
|
if (pure_const_state < y_l->pure_const_state)
|
pure_const_state = y_l->pure_const_state;
|
pure_const_state = y_l->pure_const_state;
|
if (pure_const_state == IPA_NEITHER)
|
if (pure_const_state == IPA_NEITHER)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
w_info = w->aux;
|
w_info = w->aux;
|
w = w_info->next_cycle;
|
w = w_info->next_cycle;
|
}
|
}
|
|
|
/* Copy back the region's pure_const_state which is shared by
|
/* Copy back the region's pure_const_state which is shared by
|
all nodes in the region. */
|
all nodes in the region. */
|
w = node;
|
w = node;
|
while (w)
|
while (w)
|
{
|
{
|
funct_state w_l = get_function_state (w);
|
funct_state w_l = get_function_state (w);
|
|
|
/* All nodes within a cycle share the same info. */
|
/* All nodes within a cycle share the same info. */
|
if (!w_l->state_set_in_source)
|
if (!w_l->state_set_in_source)
|
{
|
{
|
w_l->pure_const_state = pure_const_state;
|
w_l->pure_const_state = pure_const_state;
|
switch (pure_const_state)
|
switch (pure_const_state)
|
{
|
{
|
case IPA_CONST:
|
case IPA_CONST:
|
TREE_READONLY (w->decl) = 1;
|
TREE_READONLY (w->decl) = 1;
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Function found to be const: %s\n",
|
fprintf (dump_file, "Function found to be const: %s\n",
|
lang_hooks.decl_printable_name(w->decl, 2));
|
lang_hooks.decl_printable_name(w->decl, 2));
|
break;
|
break;
|
|
|
case IPA_PURE:
|
case IPA_PURE:
|
DECL_IS_PURE (w->decl) = 1;
|
DECL_IS_PURE (w->decl) = 1;
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Function found to be pure: %s\n",
|
fprintf (dump_file, "Function found to be pure: %s\n",
|
lang_hooks.decl_printable_name(w->decl, 2));
|
lang_hooks.decl_printable_name(w->decl, 2));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
w_info = w->aux;
|
w_info = w->aux;
|
w = w_info->next_cycle;
|
w = w_info->next_cycle;
|
}
|
}
|
}
|
}
|
|
|
/* Cleanup. */
|
/* Cleanup. */
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
/* Get rid of the aux information. */
|
/* Get rid of the aux information. */
|
if (node->aux)
|
if (node->aux)
|
{
|
{
|
w_info = node->aux;
|
w_info = node->aux;
|
if (w_info->aux)
|
if (w_info->aux)
|
free (w_info->aux);
|
free (w_info->aux);
|
free (node->aux);
|
free (node->aux);
|
node->aux = NULL;
|
node->aux = NULL;
|
}
|
}
|
|
|
free (order);
|
free (order);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_pure_const (void)
|
gate_pure_const (void)
|
{
|
{
|
return (flag_unit_at_a_time != 0 && flag_ipa_pure_const
|
return (flag_unit_at_a_time != 0 && flag_ipa_pure_const
|
/* Don't bother doing anything if the program has errors. */
|
/* Don't bother doing anything if the program has errors. */
|
&& !(errorcount || sorrycount));
|
&& !(errorcount || sorrycount));
|
}
|
}
|
|
|
struct tree_opt_pass pass_ipa_pure_const =
|
struct tree_opt_pass pass_ipa_pure_const =
|
{
|
{
|
"pure-const", /* name */
|
"pure-const", /* name */
|
gate_pure_const, /* gate */
|
gate_pure_const, /* gate */
|
static_execute, /* execute */
|
static_execute, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_IPA_PURE_CONST, /* tv_id */
|
TV_IPA_PURE_CONST, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
0, /* todo_flags_finish */
|
0, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
|
|
