/* Language-dependent node constructors for parse phase of GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Hacked by Michael Tiemann (tiemann@cygnus.com)
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "insn-config.h"
#include "integrate.h"
#include "tree-inline.h"
+#include "debug.h"
#include "target.h"
+#include "convert.h"
static tree bot_manip (tree *, int *, void *);
static tree bot_replace (tree *, int *, void *);
static tree build_target_expr (tree, tree);
static tree count_trees_r (tree *, int *, void *);
static tree verify_stmt_tree_r (tree *, int *, void *);
-static tree find_tree_r (tree *, int *, void *);
static tree build_local_temp (tree);
static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
static cp_lvalue_kind
lvalue_p_1 (tree ref,
- int treat_class_rvalues_as_lvalues)
+ int treat_class_rvalues_as_lvalues)
{
cp_lvalue_kind op1_lvalue_kind = clk_none;
cp_lvalue_kind op2_lvalue_kind = clk_none;
case COMPONENT_REF:
op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
treat_class_rvalues_as_lvalues);
- /* In an expression of the form "X.Y", the packed-ness of the
- expression does not depend on "X". */
- op1_lvalue_kind &= ~clk_packed;
/* Look at the member designator. */
if (!op1_lvalue_kind
/* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
- situations. */
- || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
- ;
+ situations. */
+ || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
+ ;
else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
{
/* Clear the ordinary bit. If this object was a class
case STRING_CST:
return clk_ordinary;
+ case CONST_DECL:
case VAR_DECL:
if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
&& DECL_LANG_SPECIFIC (ref)
case TARGET_EXPR:
return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
- case CALL_EXPR:
case VA_ARG_EXPR:
+ return (treat_class_rvalues_as_lvalues
+ && CLASS_TYPE_P (TREE_TYPE (ref))
+ ? clk_class : clk_none);
+
+ case CALL_EXPR:
/* Any class-valued call would be wrapped in a TARGET_EXPR. */
return clk_none;
(lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);
}
-/* Return nonzero if REF is an lvalue valid for this language;
- otherwise, print an error message and return zero. */
+/* Test whether DECL is a builtin that may appear in a
+ constant-expression. */
-int
-lvalue_or_else (tree ref, const char* string)
+bool
+builtin_valid_in_constant_expr_p (tree decl)
{
- if (!lvalue_p (ref))
- {
- error ("non-lvalue in %s", string);
- return 0;
- }
- return 1;
+ /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
+ in constant-expressions. We may want to add other builtins later. */
+ return DECL_IS_BUILTIN_CONSTANT_P (decl);
}
/* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
{
tree slot = build_decl (VAR_DECL, NULL_TREE, type);
DECL_ARTIFICIAL (slot) = 1;
+ DECL_IGNORED_P (slot) = 1;
DECL_CONTEXT (slot) = current_function_decl;
layout_decl (slot, 0);
return slot;
tree
build_target_expr_with_type (tree init, tree type)
{
- tree slot;
-
gcc_assert (!VOID_TYPE_P (type));
if (TREE_CODE (init) == TARGET_EXPR)
aggregate; there's no additional work to be done. */
return force_rvalue (init);
- slot = build_local_temp (type);
- return build_target_expr (slot, init);
+ return force_target_expr (type, init);
}
/* Like the above function, but without the checking. This function should
return build_target_expr_with_type (init, TREE_TYPE (init));
}
+/* If EXPR is a bitfield reference, convert it to the declared type of
+ the bitfield, and return the resulting expression. Otherwise,
+ return EXPR itself. */
+
+tree
+convert_bitfield_to_declared_type (tree expr)
+{
+ tree bitfield_type;
+
+ bitfield_type = is_bitfield_expr_with_lowered_type (expr);
+ if (bitfield_type)
+ expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
+ expr);
+ return expr;
+}
+
+/* EXPR is being used in an rvalue context. Return a version of EXPR
+ that is marked as an rvalue. */
+
+tree
+rvalue (tree expr)
+{
+ tree type;
+
+ if (error_operand_p (expr))
+ return expr;
+
+ /* [basic.lval]
+
+ Non-class rvalues always have cv-unqualified types. */
+ type = TREE_TYPE (expr);
+ if (!CLASS_TYPE_P (type) && cp_type_quals (type))
+ type = TYPE_MAIN_VARIANT (type);
+
+ if (!processing_template_decl && real_lvalue_p (expr))
+ expr = build1 (NON_LVALUE_EXPR, type, expr);
+ else if (type != TREE_TYPE (expr))
+ expr = build_nop (type, expr);
+
+ return expr;
+}
+
\f
static tree
build_cplus_array_type_1 (tree elt_type, tree index_type)
tree
cp_build_qualified_type_real (tree type,
- int type_quals,
- tsubst_flags_t complain)
+ int type_quals,
+ tsubst_flags_t complain)
{
tree result;
int bad_quals = TYPE_UNQUALIFIED;
return build_ptrmemfunc_type (t);
}
- /* A reference, function or method type shall not be cv qualified.
+ /* A reference or method type shall not be cv qualified.
[dcl.ref], [dct.fct] */
if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
&& (TREE_CODE (type) == REFERENCE_TYPE
- || TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == METHOD_TYPE))
{
bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
}
/* A restrict-qualified type must be a pointer (or reference)
- to object or incomplete type. */
+ to object or incomplete type, or a function type. */
if ((type_quals & TYPE_QUAL_RESTRICT)
&& TREE_CODE (type) != TEMPLATE_TYPE_PARM
&& TREE_CODE (type) != TYPENAME_TYPE
+ && TREE_CODE (type) != FUNCTION_TYPE
&& !POINTER_TYPE_P (type))
{
bad_quals |= TYPE_QUAL_RESTRICT;
else
{
if (complain & tf_ignore_bad_quals)
- /* We're not going to warn about constifying things that can't
- be constified. */
- bad_quals &= ~TYPE_QUAL_CONST;
+ /* We're not going to warn about constifying things that can't
+ be constified. */
+ bad_quals &= ~TYPE_QUAL_CONST;
if (bad_quals)
- {
- tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
+ {
+ tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
- if (!(complain & tf_ignore_bad_quals))
- error ("`%V' qualifiers cannot be applied to `%T'",
+ if (!(complain & tf_ignore_bad_quals))
+ error ("%qV qualifiers cannot be applied to %qT",
bad_type, type);
- }
+ }
}
/* Retrieve (or create) the appropriately qualified variant. */
tree base_binfo;
gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
- gcc_assert (type == BINFO_TYPE (binfo));
+ gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
/* If not, create a new node. */
if (!*slot)
*slot = tree_cons (purpose, value, chain);
- return *slot;
+ return (tree) *slot;
}
/* Constructor for hashed lists. */
{
return hash_tree_cons (NULL_TREE, value, chain);
}
-
-/* Similar, but used for concatenating two lists. */
-
-tree
-hash_chainon (tree list1, tree list2)
-{
- if (list2 == 0)
- return list1;
- if (list1 == 0)
- return list2;
- if (TREE_CHAIN (list1) == NULL_TREE)
- return hash_tree_chain (TREE_VALUE (list1), list2);
- return hash_tree_chain (TREE_VALUE (list1),
- hash_chainon (TREE_CHAIN (list1), list2));
-}
\f
void
debug_binfo (tree elem)
}
}
-int
-count_functions (tree t)
+/* Build a representation for the qualified name SCOPE::NAME. TYPE is
+ the type of the result expression, if known, or NULL_TREE if the
+ resulting expression is type-dependent. If TEMPLATE_P is true,
+ NAME is known to be a template because the user explicitly used the
+ "template" keyword after the "::".
+
+ All SCOPE_REFs should be built by use of this function. */
+
+tree
+build_qualified_name (tree type, tree scope, tree name, bool template_p)
{
- int i;
-
- if (TREE_CODE (t) == FUNCTION_DECL)
- return 1;
- gcc_assert (TREE_CODE (t) == OVERLOAD);
-
- for (i = 0; t; t = OVL_CHAIN (t))
- i++;
- return i;
+ tree t;
+ if (type == error_mark_node
+ || scope == error_mark_node
+ || name == error_mark_node)
+ return error_mark_node;
+ t = build2 (SCOPE_REF, type, scope, name);
+ QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
+ return t;
}
int
int
really_overloaded_fn (tree x)
{
- /* A baselink is also considered an overloaded function. */
if (TREE_CODE (x) == OFFSET_REF)
x = TREE_OPERAND (x, 1);
+ /* A baselink is also considered an overloaded function. */
if (BASELINK_P (x))
x = BASELINK_FUNCTIONS (x);
return OVL_CURRENT (from);
}
-/* Returns nonzero if T is a ->* or .* expression that refers to a
- member function. */
-
-int
-bound_pmf_p (tree t)
-{
- return (TREE_CODE (t) == OFFSET_REF
- && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
-}
-
/* Return a new OVL node, concatenating it with the old one. */
tree
for (; v; v = TYPE_NEXT_VARIANT (v))
if (check_qualified_type (v, type, type_quals)
- && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
+ && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
return v;
/* Need to build a new variant. */
static tree
verify_stmt_tree_r (tree* tp,
- int* walk_subtrees ATTRIBUTE_UNUSED ,
- void* data)
+ int* walk_subtrees ATTRIBUTE_UNUSED ,
+ void* data)
{
tree t = *tp;
htab_t *statements = (htab_t *) data;
htab_delete (statements);
}
-/* Called from find_tree via walk_tree. */
-
-static tree
-find_tree_r (tree* tp,
- int* walk_subtrees ATTRIBUTE_UNUSED ,
- void* data)
-{
- if (*tp == (tree) data)
- return (tree) data;
-
- return NULL_TREE;
-}
-
-/* Returns X if X appears in the tree structure rooted at T. */
-
-tree
-find_tree (tree t, tree x)
-{
- return walk_tree_without_duplicates (&t, find_tree_r, x);
-}
-
/* Check if the type T depends on a type with no linkage and if so, return
it. If RELAXED_P then do not consider a class type declared within
a TREE_PUBLIC function to have no linkage. */
tree
array_type_nelts_top (tree type)
{
- return fold (build2 (PLUS_EXPR, sizetype,
- array_type_nelts (type),
- integer_one_node));
+ return fold_build2 (PLUS_EXPR, sizetype,
+ array_type_nelts (type),
+ integer_one_node);
}
/* Return, as an INTEGER_CST node, the number of elements for TYPE
while (TREE_CODE (type) == ARRAY_TYPE)
{
tree n = array_type_nelts_top (type);
- sz = fold (build2 (MULT_EXPR, sizetype, sz, n));
+ sz = fold_build2 (MULT_EXPR, sizetype, sz, n);
type = TREE_TYPE (type);
}
return sz;
if (!TYPE_P (t) && TREE_CONSTANT (t))
{
/* There can't be any TARGET_EXPRs or their slot variables below
- this point. We used to check !TREE_SIDE_EFFECTS, but then we
- failed to copy an ADDR_EXPR of the slot VAR_DECL. */
+ this point. We used to check !TREE_SIDE_EFFECTS, but then we
+ failed to copy an ADDR_EXPR of the slot VAR_DECL. */
*walk_subtrees = 0;
return NULL_TREE;
}
tree u;
if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
- {
- mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
- u = build_cplus_new
- (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
- }
+ u = build_cplus_new
+ (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
else
- {
- u = build_target_expr_with_type
- (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t));
- }
+ u = build_target_expr_with_type
+ (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t));
/* Map the old variable to the new one. */
splay_tree_insert (target_remap,
*walk_subtrees = 0;
return NULL_TREE;
}
- else if (TREE_CODE (t) == CALL_EXPR)
- mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
/* Make a copy of this node. */
return copy_tree_r (tp, walk_subtrees, NULL);
static tree
bot_replace (tree* t,
- int* walk_subtrees ATTRIBUTE_UNUSED ,
- void* data)
+ int* walk_subtrees ATTRIBUTE_UNUSED ,
+ void* data)
{
splay_tree target_remap = ((splay_tree) data);
case FUNCTION_DECL:
case TEMPLATE_DECL:
case IDENTIFIER_NODE:
+ case SSA_NAME:
return false;
+ case BASELINK:
+ return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
+ && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
+ && cp_tree_equal (BASELINK_FUNCTIONS (t1),
+ BASELINK_FUNCTIONS (t2)));
+
case TEMPLATE_PARM_INDEX:
return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
&& TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
+ case OVERLOAD:
+ if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
+ return false;
+ return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
+
default:
break;
}
if (current_class_type
&& (binfo = lookup_base (current_class_type, type,
- ba_ignore | ba_quiet, NULL)))
+ ba_unique | ba_quiet, NULL)))
context = current_class_type;
else
{
if (current_class_ref && context == current_class_type
/* Kludge: Make sure that current_class_type is actually
- correct. It might not be if we're in the middle of
- tsubst_default_argument. */
+ correct. It might not be if we're in the middle of
+ tsubst_default_argument. */
&& same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
current_class_type))
decl = current_class_ref;
return 1; /* pointer to member */
if (TREE_CODE (t) == VECTOR_TYPE)
- return 1; /* vectors are (small) arrays if scalars */
+ return 1; /* vectors are (small) arrays of scalars */
if (! CLASS_TYPE_P (t))
return 0; /* other non-class type (reference or function) */
{ "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
{ "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
{ "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
- { NULL, 0, 0, false, false, false, NULL }
+ { NULL, 0, 0, false, false, false, NULL }
};
/* Handle a "java_interface" attribute; arguments as in
struct attribute_spec.handler. */
static tree
handle_java_interface_attribute (tree* node,
- tree name,
- tree args ATTRIBUTE_UNUSED ,
- int flags,
- bool* no_add_attrs)
+ tree name,
+ tree args ATTRIBUTE_UNUSED ,
+ int flags,
+ bool* no_add_attrs)
{
if (DECL_P (*node)
|| !CLASS_TYPE_P (*node)
|| !TYPE_FOR_JAVA (*node))
{
- error ("`%E' attribute can only be applied to Java class definitions",
+ error ("%qE attribute can only be applied to Java class definitions",
name);
*no_add_attrs = true;
return NULL_TREE;
struct attribute_spec.handler. */
static tree
handle_com_interface_attribute (tree* node,
- tree name,
- tree args ATTRIBUTE_UNUSED ,
- int flags ATTRIBUTE_UNUSED ,
- bool* no_add_attrs)
+ tree name,
+ tree args ATTRIBUTE_UNUSED ,
+ int flags ATTRIBUTE_UNUSED ,
+ bool* no_add_attrs)
{
static int warned;
|| !CLASS_TYPE_P (*node)
|| *node != TYPE_MAIN_VARIANT (*node))
{
- warning ("`%E' attribute can only be applied to class definitions",
- name);
+ warning (OPT_Wattributes, "%qE attribute can only be applied "
+ "to class definitions", name);
return NULL_TREE;
}
if (!warned++)
- warning ("`%E' is obsolete; g++ vtables are now COM-compatible by default",
+ warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
name);
return NULL_TREE;
struct attribute_spec.handler. */
static tree
handle_init_priority_attribute (tree* node,
- tree name,
- tree args,
- int flags ATTRIBUTE_UNUSED ,
- bool* no_add_attrs)
+ tree name,
+ tree args,
+ int flags ATTRIBUTE_UNUSED ,
+ bool* no_add_attrs)
{
tree initp_expr = TREE_VALUE (args);
tree decl = *node;
init_priority value, so don't allow it. */
|| current_function_decl)
{
- error ("can only use `%E' attribute on file-scope definitions "
- "of objects of class type", name);
+ error ("can only use %qE attribute on file-scope definitions "
+ "of objects of class type", name);
*no_add_attrs = true;
return NULL_TREE;
}
if (pri <= MAX_RESERVED_INIT_PRIORITY)
{
warning
- ("requested init_priority is reserved for internal use");
+ (0, "requested init_priority is reserved for internal use");
}
if (SUPPORTS_INIT_PRIORITY)
{
- DECL_INIT_PRIORITY (decl) = pri;
+ SET_DECL_INIT_PRIORITY (decl, pri);
+ DECL_HAS_INIT_PRIORITY_P (decl) = 1;
return NULL_TREE;
}
else
{
- error ("`%E' attribute is not supported on this platform", name);
+ error ("%qE attribute is not supported on this platform", name);
*no_add_attrs = true;
return NULL_TREE;
}
}
-/* Return a new TINST_LEVEL for DECL at location locus. */
-tree
-make_tinst_level (tree decl, location_t locus)
-{
- tree tinst_level = make_node (TINST_LEVEL);
- TREE_CHAIN (tinst_level) = NULL_TREE;
- TINST_DECL (tinst_level) = decl;
- TINST_LOCATION (tinst_level) = locus;
- return tinst_level;
-}
-
/* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
thing pointed to by the constant. */
tree
cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
- void *data, void *htab)
+ void *data, struct pointer_set_t *pset)
{
enum tree_code code = TREE_CODE (*tp);
location_t save_locus;
#define WALK_SUBTREE(NODE) \
do \
{ \
- result = walk_tree (&(NODE), func, data, htab); \
+ result = walk_tree (&(NODE), func, data, pset); \
if (result) goto out; \
} \
while (0)
case TYPEOF_TYPE:
case BASELINK:
/* None of these have subtrees other than those already walked
- above. */
+ above. */
*walk_subtrees_p = 0;
break;
return prev_fn;
}
-/* Determine whether a tree node is an OVERLOAD node. Used to decide
- whether to copy a node or to preserve its chain when inlining a
- function. */
-
-int
-cp_is_overload_p (tree t)
-{
- return TREE_CODE (t) == OVERLOAD;
-}
-
/* Determine whether VAR is a declaration of an automatic variable in
function FN. */
&& nonstatic_local_decl_p (var));
}
-/* FN body has been duplicated. Update language specific fields. */
+/* Like save_expr, but for C++. */
-void
-cp_update_decl_after_saving (tree fn,
- void* decl_map_)
+tree
+cp_save_expr (tree expr)
{
- splay_tree decl_map = (splay_tree)decl_map_;
- tree nrv = DECL_SAVED_FUNCTION_DATA (fn)->x_return_value;
- if (nrv)
- {
- DECL_SAVED_FUNCTION_DATA (fn)->x_return_value
- = (tree) splay_tree_lookup (decl_map, (splay_tree_key) nrv)->value;
- }
+ /* There is no reason to create a SAVE_EXPR within a template; if
+ needed, we can create the SAVE_EXPR when instantiating the
+ template. Furthermore, the middle-end cannot handle C++-specific
+ tree codes. */
+ if (processing_template_decl)
+ return expr;
+ return save_expr (expr);
}
+
/* Initialize tree.c. */
void
return sfk_none;
}
-/* Returns true if and only if NODE is a name, i.e., a node created
- by the parser when processing an id-expression. */
-
-bool
-name_p (tree node)
-{
- if (TREE_CODE (node) == TEMPLATE_ID_EXPR)
- node = TREE_OPERAND (node, 0);
- return (/* An ordinary unqualified name. */
- TREE_CODE (node) == IDENTIFIER_NODE
- /* A destructor name. */
- || TREE_CODE (node) == BIT_NOT_EXPR
- /* A qualified name. */
- || TREE_CODE (node) == SCOPE_REF);
-}
-
/* Returns nonzero if TYPE is a character type, including wchar_t. */
int
/* Things that are TREE_PUBLIC have external linkage. */
if (TREE_PUBLIC (decl))
return lk_external;
+
+ /* Linkage of a CONST_DECL depends on the linkage of the enumeration
+ type. */
+ if (TREE_CODE (decl) == CONST_DECL)
+ return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
/* Some things that are not TREE_PUBLIC have external linkage, too.
For example, on targets that don't have weak symbols, we make all
template instantiations have internal linkage (in the object
file), but the symbols should still be treated as having external
linkage from the point of view of the language. */
- if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
+ if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
return lk_external;
/* Things in local scope do not have linkage, if they don't have
if (TREE_CODE (t) == COMPOUND_EXPR)
t = expr_last (t);
if (TREE_CODE (t) == CONSTRUCTOR
- && CONSTRUCTOR_ELTS (t) == NULL_TREE)
+ && EMPTY_CONSTRUCTOR_P (t))
{
/* Default-initialization. */
*initp = NULL_TREE;
if (TREE_CODE (t) == COND_EXPR)
return false;
- stabilize_call (t, initp);
+ /* The TARGET_EXPR might be initializing via bitwise copy from
+ another variable; leave that alone. */
+ if (TREE_SIDE_EFFECTS (t))
+ stabilize_call (t, initp);
}
return true;
}
+/* Like "fold", but should be used whenever we might be processing the
+ body of a template. */
+
+tree
+fold_if_not_in_template (tree expr)
+{
+ /* In the body of a template, there is never any need to call
+ "fold". We will call fold later when actually instantiating the
+ template. Integral constant expressions in templates will be
+ evaluated via fold_non_dependent_expr, as necessary. */
+ if (processing_template_decl)
+ return expr;
+
+ /* Fold C++ front-end specific tree codes. */
+ if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
+ return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
+
+ return fold (expr);
+}
+
\f
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
/* Complain that some language-specific thing hanging off a tree
OSDN Git Service
