#define GCC_TREE_H
#include "machmode.h"
-#include "version.h"
#include "input.h"
+#include "statistics.h"
/* Codes of tree nodes */
#include "tree.def"
LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for
- NUM_TREE_CODE. */
+ NUM_TREE_CODES. */
};
#undef DEFTREECODE
extern const char tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
+/* Returns nonzero iff CLASS is not the tree code of a type. */
+
+#define IS_NON_TYPE_CODE_CLASS(CLASS) (strchr ("xbcdr<12se", (CLASS)) != 0)
+
/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
/* Names for the above. */
extern const char *const built_in_names[(int) END_BUILTINS];
+/* Helper macros for math builtins. */
+
+#define BUILTIN_EXP10_P(FN) \
+ ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
+ || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
+
+#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
+ || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
+ || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
+
+#define BUILTIN_SQRT_P(FN) \
+ ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
+
+#define BUILTIN_CBRT_P(FN) \
+ ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
+
+#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
+
/* An array of _DECL trees for the above. */
extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
See the accessor macros, defined below, for documentation of the
fields. */
+union tree_ann_d;
struct tree_common GTY(())
{
tree chain;
tree type;
+ union tree_ann_d *ann;
ENUM_BITFIELD(tree_code) code : 8;
unsigned readonly_flag : 1;
unsigned unsigned_flag : 1;
unsigned asm_written_flag: 1;
- unsigned unused_0 : 1;
+ unsigned nowarning_flag : 1;
unsigned used_flag : 1;
unsigned nothrow_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
unsigned deprecated_flag : 1;
- unsigned unused_1 : 1;
+ unsigned invariant_flag : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
- unsigned unused_2 : 1;
+ unsigned visited : 1;
};
/* The following table lists the uses of each of the above flags and
..._TYPE, IDENTIFIER_NODE.
In a STMT_EXPR, it means we want the result of the enclosed
expression.
+ CALL_EXPR_TAILCALL in CALL_EXPR
static_flag:
TREE_STATIC in
VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
- TREE_NO_UNUSED_WARNING in
- CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR
TREE_VIA_VIRTUAL in
TREE_LIST or TREE_VEC
TREE_CONSTANT_OVERFLOW in
CLEANUP_EH_ONLY in
TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT,
TREE_LIST elements of a block's cleanup list.
+ ASM_INPUT_P in
+ ASM_EXPR
+ EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR
+ TYPE_REF_CAN_ALIAS_ALL in
+ POINTER_TYPE, REFERENCE_TYPE
public_flag:
TREE_OVERFLOW in
INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
+ ??? and other expressions?
TREE_PUBLIC in
VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
- EXPR_WFL_EMIT_LINE_NOTE in
- EXPR_WITH_FILE_LOCATION
+ TREE_VIA_PUBLIC in
+ TREE_LIST or TREE_VEC
+ ASM_VOLATILE_P in
+ ASM_EXPR
private_flag:
TREE_PROTECTED in
BLOCK
..._DECL
+ CALL_FROM_THUNK_P in
+ CALL_EXPR
side_effects_flag:
TREE_SIDE_EFFECTS in
all expressions
+ all decls
+ all constants
+
+ FORCED_LABEL in
+ LABEL_DECL
volatile_flag:
TREE_CONSTANT in
all expressions
+ all decls
+ all constants
unsigned_flag:
- TREE_UNSIGNED in
- INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
+ TYPE_UNSIGNED in
+ all types
+ DECL_UNSIGNED in
+ all decls
+ BIT_FIELD_REF_UNSIGNED in
+ BIT_FIELD_REF
SAVE_EXPR_NOPLACEHOLDER in
SAVE_EXPR
TREE_ASM_WRITTEN in
VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
- BLOCK
+ BLOCK, SSA_NAME
used_flag:
TREE_DEPRECATED in
..._DECL
+
+ visited:
+
+ Used in tree traversals to mark visited nodes.
+
+ invariant_flag:
+
+ TREE_INVARIANT in
+ all expressions.
+
+ nowarning_flag:
+
+ TREE_NO_WARNING in
+ ... any expr node
*/
/* Define accessors for the fields that all tree nodes have
tree_check_failed (__t, (CODE), __FILE__, __LINE__, __FUNCTION__); \
__t; })
+#define TREE_CHECK2(T, CODE1, CODE2) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE (__t) != (CODE1) \
+ && TREE_CODE (__t) != (CODE2)) \
+ tree_check2_failed (__t, (CODE1), (CODE2), __FILE__, __LINE__, \
+ __FUNCTION__); \
+ __t; })
+
+#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE (__t) != (CODE1) \
+ && TREE_CODE (__t) != (CODE2) \
+ && TREE_CODE (__t) != (CODE3)) \
+ tree_check3_failed (__t, (CODE1), (CODE2), (CODE3), __FILE__, \
+ __LINE__, __FUNCTION__); \
+ __t; })
+
+#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE (__t) != (CODE1) \
+ && TREE_CODE (__t) != (CODE2) \
+ && TREE_CODE (__t) != (CODE3) \
+ && TREE_CODE (__t) != (CODE4)) \
+ tree_check4_failed (__t, (CODE1), (CODE2), (CODE3), (CODE4), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ __t; })
+
+#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE (__t) != (CODE1) \
+ && TREE_CODE (__t) != (CODE2) \
+ && TREE_CODE (__t) != (CODE3) \
+ && TREE_CODE (__t) != (CODE4) \
+ && TREE_CODE (__t) != (CODE5)) \
+ tree_check5_failed (__t, (CODE1), (CODE2), (CODE3), (CODE4), \
+ (CODE5), __FILE__, __LINE__, __FUNCTION__); \
+ __t; })
+
#define TREE_CLASS_CHECK(T, CLASS) __extension__ \
({ const tree __t = (T); \
if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_EXPR_CODE_CLASS (__c)) \
- tree_class_check_failed (__t, 'e', __FILE__, __LINE__, \
+ tree_class_check_failed (__t, 'E', __FILE__, __LINE__, \
+ __FUNCTION__); \
+ __t; })
+
+/* These checks have to be special cased. */
+#define NON_TYPE_CHECK(T) __extension__ \
+({ const tree __t = (T); \
+ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
+ if (!IS_NON_TYPE_CODE_CLASS (__c)) \
+ tree_class_check_failed (__t, 'T', __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
+#define EREF_NODE_CHECK(t) __extension__ \
+({ const tree __t = t; \
+ if (TREE_CODE (__t) != EPHI_NODE \
+ && TREE_CODE (__t) != EKILL_NODE \
+ && TREE_CODE (__t) != EUSE_NODE \
+ && TREE_CODE (__t) != EEXIT_NODE) \
+ tree_check_failed (__t, TREE_CODE (t), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ __t; })
+
#define TREE_VEC_ELT_CHECK(T, I) __extension__ \
(*({const tree __t = (T); \
const int __i = (I); \
__FILE__, __LINE__, __FUNCTION__); \
&__t->vec.a[__i]; }))
+#define EPHI_NODE_ELT_CHECK(t, i) __extension__ \
+(*({const tree __t = t; \
+ const int __i = (i); \
+ if (TREE_CODE (__t) != EPHI_NODE) \
+ tree_check_failed (__t, EPHI_NODE, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= __t->ephi.capacity) \
+ ephi_node_elt_check_failed (__i, __t->ephi.num_args, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->ephi.a[__i]; }))
+
+#define PHI_NODE_ELT_CHECK(t, i) __extension__ \
+(*({const tree __t = t; \
+ const int __i = (i); \
+ if (TREE_CODE (__t) != PHI_NODE) \
+ tree_check_failed (__t, PHI_NODE, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= __t->phi.capacity) \
+ phi_node_elt_check_failed (__i, __t->phi.num_args, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->phi.a[__i]; }))
+
/* Special checks for TREE_OPERANDs. */
#define TREE_OPERAND_CHECK(T, I) __extension__ \
(*({const tree __t = EXPR_CHECK (T); \
extern void tree_check_failed (const tree, enum tree_code,
const char *, int, const char *)
ATTRIBUTE_NORETURN;
+extern void tree_check2_failed (const tree, enum tree_code, enum tree_code,
+ const char *, int, const char *)
+ ATTRIBUTE_NORETURN;
+extern void tree_check3_failed (const tree, enum tree_code, enum tree_code,
+ enum tree_code, const char *, int,
+ const char *)
+ ATTRIBUTE_NORETURN;
+extern void tree_check4_failed (const tree, enum tree_code, enum tree_code,
+ enum tree_code, enum tree_code,
+ const char *, int, const char *)
+ ATTRIBUTE_NORETURN;
+extern void tree_check5_failed (const tree, enum tree_code, enum tree_code,
+ enum tree_code, enum tree_code, enum tree_code,
+ const char *, int, const char *)
+ ATTRIBUTE_NORETURN;
extern void tree_class_check_failed (const tree, int,
const char *, int, const char *)
ATTRIBUTE_NORETURN;
extern void tree_vec_elt_check_failed (int, int, const char *,
int, const char *)
ATTRIBUTE_NORETURN;
+extern void phi_node_elt_check_failed (int, int, const char *,
+ int, const char *)
+ ATTRIBUTE_NORETURN;
+extern void ephi_node_elt_check_failed (int, int, const char *,
+ int, const char *)
+ ATTRIBUTE_NORETURN;
extern void tree_operand_check_failed (int, enum tree_code,
const char *, int, const char *)
#else /* not ENABLE_TREE_CHECKING, or not gcc */
-#define TREE_CHECK(T, CODE) (T)
-#define TREE_CLASS_CHECK(T, CODE) (T)
-#define EXPR_CHECK(T) (T)
-#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
-#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
-#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
+#define TREE_CHECK(T, CODE) (T)
+#define TREE_CHECK2(T, CODE1, CODE2) (T)
+#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T)
+#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
+#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
+#define TREE_CLASS_CHECK(T, CODE) (T)
+#define EXPR_CHECK(T) (T)
+#define NON_TYPE_CHECK(T) (T)
+#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
+#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
+#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
#define TREE_RTL_OPERAND_CHECK(T, CODE, I) (*(rtx *) &((T)->exp.operands[I]))
+#define EREF_NODE_CHECK(T) (T)
+#define PHI_NODE_ELT_CHECK(T, i) ((T)->phi.a[i])
+#define EPHI_NODE_ELT_CHECK(T, i) ((T)->ephi.a[i])
#endif
+#define TREE_BLOCK(NODE) ((NODE)->exp.block)
+
#include "tree-check.h"
#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, 't')
#define DECL_CHECK(T) TREE_CLASS_CHECK (T, 'd')
#define CST_CHECK(T) TREE_CLASS_CHECK (T, 'c')
#define STMT_CHECK(T) TREE_CLASS_CHECK (T, 's')
+#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
+#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
+
+#define SET_OR_ARRAY_CHECK(T) \
+ TREE_CHECK2 (T, ARRAY_TYPE, SET_TYPE)
+
+#define REC_OR_UNION_CHECK(T) \
+ TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
+
+#define NUMERICAL_TYPE_CHECK(T) \
+ TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, \
+ CHAR_TYPE, REAL_TYPE)
/* In all nodes that are expressions, this is the data type of the expression.
In POINTER_TYPE nodes, this is the type that the pointer points to.
/* Here is how primitive or already-canonicalized types' hash codes
are made. */
-#define TYPE_HASH(TYPE) ((size_t) (TYPE) & 0777777)
+#define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
+
+/* A simple hash function for an arbitrary tree node. This must not be
+ used in hash tables which are saved to a PCH. */
+#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
/* Nodes are chained together for many purposes.
Types are chained together to record them for being output to the debugger
&& TREE_OPERAND (EXP, 0) != error_mark_node \
&& (TYPE_MODE (TREE_TYPE (EXP)) \
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
- && (TREE_UNSIGNED (TREE_TYPE (EXP)) \
- == TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
+ && (TYPE_UNSIGNED (TREE_TYPE (EXP)) \
+ == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
(EXP) = TREE_OPERAND (EXP, 0)
/* Like STRIP_NOPS, but don't alter the TREE_TYPE main variant either. */
== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
(EXP) = TREE_OPERAND (EXP, 0)
+/* Remove unnecessary type conversions according to
+ tree_ssa_useless_type_conversion. */
+
+#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
+ while (tree_ssa_useless_type_conversion (EXP)) \
+ EXP = TREE_OPERAND (EXP, 0)
+
/* Nonzero if TYPE represents an integral type. Note that we do not
include COMPLEX types here. */
had its address taken. That matters for inline functions. */
#define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)
+#define CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK(NODE)->common.addressable_flag)
+
/* In a VAR_DECL, nonzero means allocate static storage.
In a FUNCTION_DECL, nonzero if function has been defined.
- In a CONSTRUCTOR, nonzero means allocate static storage. */
+ In a CONSTRUCTOR, nonzero means allocate static storage.
+
+ ??? This is also used in lots of other nodes in unclear ways which
+ should be cleaned up some day. */
#define TREE_STATIC(NODE) ((NODE)->common.static_flag)
/* In a TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, or element of a
executed if an exception is thrown, not on normal exit of its scope. */
#define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)
-/* In a CONVERT_EXPR, NOP_EXPR or COMPOUND_EXPR, this means the node was
- made implicitly and should not lead to an "unused value" warning. */
-#define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
+/* In an expr node (usually a conversion) this means the node was made
+ implicitly and should not lead to any sort of warning. */
+#define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_flag)
/* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation
chain is via a `virtual' declaration. */
-#define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.static_flag)
+#define TREE_VIA_VIRTUAL(NODE) \
+ (TREE_CHECK2 (NODE, TREE_LIST, TREE_VEC)->common.static_flag)
/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
there was an overflow in folding. This is distinct from
TREE_OVERFLOW because ANSI C requires a diagnostic when overflows
occur in constant expressions. */
-#define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
+#define TREE_CONSTANT_OVERFLOW(NODE) (CST_CHECK (NODE)->common.static_flag)
/* In an IDENTIFIER_NODE, this means that assemble_name was called with
this string as an argument. */
#define TREE_SYMBOL_REFERENCED(NODE) \
(IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)
+/* Nonzero in a pointer or reference type means the data pointed to
+ by this type can alias anything. */
+#define TYPE_REF_CAN_ALIAS_ALL(NODE) \
+ (PTR_OR_REF_CHECK (NODE)->common.static_flag)
+
/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
there was an overflow in folding, and no warning has been issued
- for this subexpression. TREE_OVERFLOW implies
- TREE_CONSTANT_OVERFLOW, but not vice versa. */
+ for this subexpression. TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW,
+ but not vice versa.
+
+ ??? Apparently, lots of code assumes this is defined in all
+ expressions. */
#define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag)
/* In a VAR_DECL or FUNCTION_DECL,
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
-/* In any expression, nonzero means it has side effects or reevaluation
- of the whole expression could produce a different value.
- This is set if any subexpression is a function call, a side effect
- or a reference to a volatile variable.
- In a ..._DECL, this is set only if the declaration said `volatile'. */
-#define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_flag)
+/* In any expression, decl, or constant, nonzero means it has side effects or
+ reevaluation of the whole expression could produce a different value.
+ This is set if any subexpression is a function call, a side effect or a
+ reference to a volatile variable. In a ..._DECL, this is set only if the
+ declaration said `volatile'. This will never be set for a constant. */
+#define TREE_SIDE_EFFECTS(NODE) \
+ (NON_TYPE_CHECK (NODE)->common.side_effects_flag)
+
+/* In a LABEL_DECL, nonzero means this label had its address taken
+ and therefore can never be deleted and is a jump target for
+ computed gotos. */
+#define FORCED_LABEL(NODE) ((NODE)->common.side_effects_flag)
/* Nonzero means this expression is volatile in the C sense:
its address should be of type `volatile WHATEVER *'.
#define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)
/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
- nonzero means it may not be the lhs of an assignment.
- In a ..._TYPE node, means this type is const-qualified
- (but the macro TYPE_READONLY should be used instead of this macro
- when the node is a type). */
-#define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
+ nonzero means it may not be the lhs of an assignment. */
+#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)
/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
-#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
+#define TREE_READONLY_DECL_P(NODE) (DECL_P (NODE) && TREE_READONLY (NODE))
+
+/* Value of expression is constant. Always on in all ..._CST nodes. May
+ also appear in an expression or decl where the value is constant. */
+#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag)
+
+/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
+#define DECL_UNSIGNED(NODE) (DECL_CHECK (NODE)->common.unsigned_flag)
-/* Value of expression is constant.
- Always appears in all ..._CST nodes.
- May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR
- if the value is constant. */
-#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
+/* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned. */
+#define BIT_FIELD_REF_UNSIGNED(NODE) \
+ (BIT_FIELD_REF_CHECK (NODE)->common.unsigned_flag)
-/* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type.
- In FIELD_DECL nodes, means an unsigned bit field. */
-#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
+/* In integral and pointer types, means an unsigned type. */
+#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->common.unsigned_flag)
#define TYPE_TRAP_SIGNED(NODE) \
- (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE)))
+ (flag_trapv && ! TYPE_UNSIGNED (NODE))
/* Nonzero in a VAR_DECL means assembler code has been written.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
to be compiled separately.
Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
if the sdb debugging info for the type has been written.
- In a BLOCK node, nonzero if reorder_blocks has already seen this block. */
+ In a BLOCK node, nonzero if reorder_blocks has already seen this block.
+ In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
+ PHI node. */
#define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)
/* Nonzero in a _DECL if the name is used in its scope.
argument list. */
#define CALL_EXPR_HAS_RETURN_SLOT_ADDR(NODE) ((NODE)->common.private_flag)
+/* In a CALL_EXPR, means that the call is the jump from a thunk to the
+ thunked-to function. */
+#define CALL_FROM_THUNK_P(NODE) ((NODE)->common.protected_flag)
+
/* In a type, nonzero means that all objects of the type are guaranteed by the
language or front-end to be properly aligned, so we can indicate that a MEM
of this type is aligned at least to the alignment of the type, even if it
doesn't appear that it is. We see this, for example, in object-oriented
languages where a tag field may show this is an object of a more-aligned
- variant of the more generic type. */
+ variant of the more generic type.
+
+ In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME
+ freelist. */
#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)
/* Used in classes in C++. */
deprecated feature by __attribute__((deprecated)). */
#define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
+/* Value of expression is function invariant. A strict subset of
+ TREE_CONSTANT, such an expression is constant over any one function
+ invocation, though not across different invocations. May appear in
+ any expression node. */
+#define TREE_INVARIANT(NODE) ((NODE)->common.invariant_flag)
+
/* These flags are available for each language front end to use internally. */
#define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
#define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
/* In a STRING_CST */
#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
-#define TREE_STRING_POINTER(NODE) (STRING_CST_CHECK (NODE)->string.str)
+#define TREE_STRING_POINTER(NODE) (STRING_CST_CHECK (NODE)->string.pointer)
struct tree_string GTY(())
{
struct tree_common common;
int length;
- const char str[1];
+ const char *pointer;
};
/* In a COMPLEX_CST node. */
tree elements;
};
\f
-#include "hashtable.h"
+#include "symtab.h"
/* Define fields and accessors for some special-purpose tree nodes. */
/* Define fields and accessors for some nodes that represent expressions. */
+/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
+#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \
+ && VOID_TYPE_P (TREE_TYPE (NODE)) \
+ && integer_zerop (TREE_OPERAND (NODE, 0)))
+
/* In a SAVE_EXPR node. */
#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND_CHECK_CODE (NODE, SAVE_EXPR, 1)
#define SAVE_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, SAVE_EXPR, 2)
-#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (SAVE_EXPR_CHECK (NODE))
+#define SAVE_EXPR_NOPLACEHOLDER(NODE) \
+ (SAVE_EXPR_CHECK (NODE)->common.unsigned_flag)
+
/* Nonzero if the SAVE_EXPRs value should be kept, even if it occurs
both in normal code and in a handler. (Normally, in a handler, all
SAVE_EXPRs are unsaved, meaning that their values are
/* In a LOOP_EXPR node. */
#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
-/* In an EXPR_WITH_FILE_LOCATION node. */
-#define EXPR_WFL_EMIT_LINE_NOTE(NODE) \
- (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag)
-#define EXPR_WFL_NODE(NODE) \
- TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 0)
-#define EXPR_WFL_FILENAME_NODE(NODE) \
- TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 1)
-#define EXPR_WFL_FILENAME(NODE) \
- IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (NODE))
-/* ??? Java uses this in all expressions. */
-#define EXPR_WFL_LINECOL(NODE) (EXPR_CHECK (NODE)->exp.complexity)
-#define EXPR_WFL_LINENO(NODE) (EXPR_WFL_LINECOL (NODE) >> 12)
-#define EXPR_WFL_COLNO(NODE) (EXPR_WFL_LINECOL (NODE) & 0xfff)
-#define EXPR_WFL_SET_LINECOL(NODE, LINE, COL) \
- (EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
+/* The source location of this expression. Non-tree_exp nodes such as
+ decls and constants can be shared among multiple locations, so
+ return nothing. */
+#define EXPR_LOCUS(NODE) \
+ (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
+ ? (NODE)->exp.locus \
+ : (location_t *)NULL)
+#define SET_EXPR_LOCUS(NODE, FROM) \
+ (EXPR_CHECK (NODE)->exp.locus = (FROM))
+#define EXPR_FILENAME(NODE) \
+ (EXPR_CHECK (NODE)->exp.locus->file)
+#define EXPR_LINENO(NODE) \
+ (EXPR_CHECK (NODE)->exp.locus->line)
+#ifdef USE_MAPPED_LOCATION
+#define EXPR_LOCATION(NODE) \
+ (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
+ ? (NODE)->exp.locus \
+ : UNKNOWN_LOCATION)
+#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
+#else
+#define EXPR_LOCATION(NODE) (*EXPR_LOCUS (NODE))
+#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCUS (NODE) != NULL)
+#endif
/* In a TARGET_EXPR node. */
#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
+#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
+
+/* SWITCH_EXPR accessors. These give access to the condition, body and
+ original condition type (before any compiler conversions)
+ of the switch statement, respectively. */
+#define SWITCH_COND(NODE) TREE_OPERAND ((NODE), 0)
+#define SWITCH_BODY(NODE) TREE_OPERAND ((NODE), 1)
+#define SWITCH_LABELS(NODE) TREE_OPERAND ((NODE), 2)
+
+/* CASE_LABEL accessors. These give access to the high and low values
+ of a case label, respectively. */
+#define CASE_LOW(NODE) TREE_OPERAND ((NODE), 0)
+#define CASE_HIGH(NODE) TREE_OPERAND ((NODE), 1)
+#define CASE_LABEL(NODE) TREE_OPERAND ((NODE), 2)
+
+/* The operands of a BIND_EXPR. */
+#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
+#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
+#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
+
+/* GOTO_EXPR accessor. This gives access to the label associated with
+ a goto statement. */
+#define GOTO_DESTINATION(NODE) TREE_OPERAND ((NODE), 0)
+
+/* ASM_STMT accessors. ASM_STRING returns a STRING_CST for the
+ instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
+ ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
+ statement. */
+#define ASM_STRING(NODE) TREE_OPERAND ((NODE), 0)
+#define ASM_OUTPUTS(NODE) TREE_OPERAND ((NODE), 1)
+#define ASM_INPUTS(NODE) TREE_OPERAND ((NODE), 2)
+#define ASM_CLOBBERS(NODE) TREE_OPERAND ((NODE), 3)
+/* Nonzero if we want to create an ASM_INPUT instead of an
+ ASM_OPERAND with no operands. */
+#define ASM_INPUT_P(NODE) (TREE_STATIC (NODE))
+#define ASM_VOLATILE_P(NODE) (TREE_PUBLIC (NODE))
+
+/* COND_EXPR accessors. */
+#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
+#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
+#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
+
+/* LABEL_EXPR accessor. This gives access to the label associated with
+ the given label expression. */
+#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
+
+/* VDEF_EXPR accessors are specified in tree-flow.h, along with the other
+ accessors for SSA operands. */
+
+/* CATCH_EXPR accessors. */
+#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
+#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
+
+/* EH_FILTER_EXPR accessors. */
+#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
+#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
+#define EH_FILTER_MUST_NOT_THROW(NODE) TREE_STATIC (EH_FILTER_EXPR_CHECK (NODE))
+
struct tree_exp GTY(())
{
struct tree_common common;
+ location_t *locus;
int complexity;
+ tree block;
tree GTY ((special ("tree_exp"),
desc ("TREE_CODE ((tree) &%0)")))
operands[1];
};
\f
+/* SSA_NAME accessors. */
+
+/* Returns the variable being referenced. Once released, this is the
+ only field that can be relied upon. */
+#define SSA_NAME_VAR(NODE) SSA_NAME_CHECK (NODE)->ssa_name.var
+
+/* Returns the statement which defines this reference. Note that
+ we use the same field when chaining SSA_NAME nodes together on
+ the SSA_NAME freelist. */
+#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->common.chain
+
+/* Returns the SSA version number of this SSA name. Note that in
+ tree SSA, version numbers are not per variable and may be recycled. */
+#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->ssa_name.version
+
+/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
+ never output, so we can safely use the ASM_WRITTEN_FLAG for this
+ status bit. */
+#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
+ SSA_NAME_CHECK (NODE)->common.asm_written_flag
+
+/* Nonzero if this SSA_NAME expression is currently on the freelist of
+ SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
+ has no meaning for an SSA_NAME. */
+#define SSA_NAME_IN_FREE_LIST(NODE) \
+ SSA_NAME_CHECK (NODE)->common.nothrow_flag
+
+struct tree_ssa_name GTY(())
+{
+ struct tree_common common;
+
+ /* _DECL wrapped by this SSA name. */
+ tree var;
+
+ /* SSA version number. */
+ unsigned int version;
+};
+\f
+/* In a PHI_NODE node. */
+#define PHI_RESULT(NODE) PHI_NODE_CHECK (NODE)->phi.result
+
+/* Nonzero if the PHI node was rewritten by a previous pass through the
+ SSA renamer. */
+#define PHI_REWRITTEN(NODE) PHI_NODE_CHECK (NODE)->phi.rewritten
+#define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args
+#define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity
+#define PHI_ARG_ELT(NODE, I) PHI_NODE_ELT_CHECK (NODE, I)
+#define PHI_ARG_EDGE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).e
+#define PHI_ARG_DEF(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).def
+#define PHI_ARG_NONZERO(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).nonzero
+
+struct edge_def;
+
+struct phi_arg_d GTY(())
+{
+ tree def;
+ struct edge_def * GTY((skip (""))) e;
+ bool nonzero;
+};
+
+struct tree_phi_node GTY(())
+{
+ struct tree_common common;
+ tree result;
+ int num_args;
+ int capacity;
+
+ /* Nonzero if the PHI node was rewritten by a previous pass through the
+ SSA renamer. */
+ int rewritten;
+
+ struct phi_arg_d GTY ((length ("((tree)&%h)->phi.capacity"))) a[1];
+};
+\f
+
+struct varray_head_tag;
+
+struct tree_eref_common GTY(())
+{
+ struct tree_common common;
+
+ /* SSAPRE: ID for the EREF. Used only for sorting erefs inside a
+ block. */
+ int id;
+
+ /* SSAPRE: Name for the EREF. Used only for printing.*/
+ tree name;
+
+ /* SSAPRE: The statement associated with this expression reference. */
+ tree stmt;
+
+ /* SSAPRE: True if expression needs to be saved to a temporary. */
+ unsigned int save:1;
+
+ /* SSAPRE: True if expression needs to be reloaded from a temporary. */
+ unsigned int reload:1;
+
+ /* SSAPRE: Redundancy class of expression. */
+ unsigned int class;
+
+ /* SSAPRE: Processed flag 1. */
+ unsigned int processed:1;
+
+ /* SSAPRE: True if expression is injured. */
+ unsigned int injured:1;
+
+ /* SSAPRE: Temporary assigned to this reference. */
+ tree temp;
+
+};
+
+struct tree_euse_node GTY(())
+{
+ struct tree_eref_common common;
+
+ /* SSAPRE: Definition for this use. */
+ tree def;
+
+ /* SSAPRE: True if this is an EPHI operand occurrence. */
+ unsigned int op_occurrence:1;
+
+ /* SSAPRE: True if expression was inserted as a PHI operand occurrence. */
+ unsigned int inserted:1;
+
+ /* SSAPRE: True if expression occurs as a lvalue. */
+ unsigned int lval:1;
+};
+struct ephi_arg_d GTY(())
+{
+
+ /* SSAPRE: True if this phi argument is injured. */
+ unsigned int injured:1;
+
+ /* SSAPRE: True if there is a real occurrence for this phi argument. */
+ unsigned int has_real_use:1;
+
+ /* SSAPRE: True if delayed renaming is required on this phi argument. */
+ unsigned int delayed_rename:1;
+
+ /* SSAPRE: Processed 2 flag for this phi argument. */
+ unsigned int processed2:1;
+
+ /* SSAPRE: True if this operand stops forward movement. */
+ unsigned int stops:1;
+
+ /* SSAPRE: Definition of this phi operand. */
+ tree def;
+
+ /* SSAPRE: Phi predecessor for this phi operand. */
+ tree pred;
+
+ struct edge_def * GTY((skip (""))) e;
+};
+struct tree_ephi_node GTY(())
+{
+ struct tree_eref_common common;
+
+ /* SSAPRE: True if PHI is downsafe. */
+ unsigned int downsafe:1;
+
+ /* SSAPRE: True if PHI is cant_be_avail. */
+ unsigned int cant_be_avail:1;
+
+ /* SSAPRE: True if PHI is dead. */
+ unsigned int dead:1;
+
+ /* SSAPRE: True if PHI is pointless or identical to some value. */
+ unsigned int identity:1;
+
+ /* SSAPRE: True if replacing occurrence known for ESSA minimization. */
+ unsigned int rep_occur_known:1;
+
+ /* SSAPRE: True if PHI is pointless, but is also injured. */
+ unsigned int ident_injured:1;
+
+ /* SSAPRE: True if this PHI stops forward movement. */
+ unsigned int stops:1;
+
+ /* SSAPRE: If PHI's replacing occurrence is known, this is it. */
+ tree identical_to;
+
+ /* SSAPRE: Uses of this ephi. */
+ struct varray_head_tag *uses;
+
+ int num_args;
+ int capacity;
+ struct ephi_arg_d GTY ((length ("((tree)&%h)->ephi.capacity"))) a[1];
+
+};
+/* In both EPHI's and EUSES */
+#define EREF_PROCESSED(NODE) EREF_NODE_CHECK (NODE)->eref.processed
+#define EREF_ID(NODE) EREF_NODE_CHECK (NODE)->eref.id
+#define EREF_NAME(NODE) EREF_NODE_CHECK (NODE)->eref.name
+#define EREF_STMT(NODE) EREF_NODE_CHECK (NODE)->eref.stmt
+#define EREF_RELOAD(NODE) EREF_NODE_CHECK (NODE)->eref.reload
+#define EREF_SAVE(NODE) EREF_NODE_CHECK (NODE)->eref.save
+#define EREF_CLASS(NODE) EREF_NODE_CHECK (NODE)->eref.class
+#define EREF_INJURED(NODE) EREF_NODE_CHECK (NODE)->eref.injured
+#define EREF_TEMP(NODE) EREF_NODE_CHECK (NODE)->eref.temp
+
+/* In a EUSE_NODE node. */
+#define EUSE_DEF(NODE) EUSE_NODE_CHECK (NODE)->euse.def
+#define EUSE_PHIOP(NODE) EUSE_NODE_CHECK (NODE)->euse.op_occurrence
+#define EUSE_INSERTED(NODE) EUSE_NODE_CHECK (NODE)->euse.inserted
+#define EUSE_LVAL(NODE) EUSE_NODE_CHECK (NODE)->euse.lval
+
+/* In a EPHI_NODE node. */
+#define EPHI_NUM_ARGS(NODE) EPHI_NODE_CHECK (NODE)->ephi.num_args
+#define EPHI_ARG_CAPACITY(NODE) EPHI_NODE_CHECK (NODE)->ephi.capacity
+#define EPHI_ARG_ELT(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I)
+#define EPHI_ARG_EDGE(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).e
+#define EPHI_ARG_PRED(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).pred
+#define EPHI_ARG_DEF(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).def
+#define EPHI_ARG_INJURED(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).injured
+#define EPHI_ARG_DELAYED_RENAME(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).delayed_rename
+#define EPHI_ARG_HAS_REAL_USE(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).has_real_use
+#define EPHI_ARG_STOPS(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).stops
+#define EPHI_ARG_PROCESSED2(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).processed2
+#define EPHI_IDENTITY(NODE) EPHI_NODE_CHECK (NODE)->ephi.identity
+#define EPHI_IDENT_INJURED(NODE) EPHI_NODE_CHECK (NODE)->ephi.ident_injured
+
+#define EPHI_REP_OCCUR_KNOWN(NODE) EPHI_NODE_CHECK (NODE)->ephi.rep_occur_known
+#define EPHI_IDENTICAL_TO(NODE) EPHI_NODE_CHECK (NODE)->ephi.identical_to
+#define EPHI_DOWNSAFE(NODE) EPHI_NODE_CHECK (NODE)->ephi.downsafe
+#define EPHI_CANT_BE_AVAIL(NODE) EPHI_NODE_CHECK (NODE)->ephi.cant_be_avail
+#define EPHI_DEAD(NODE) EPHI_NODE_CHECK (NODE)->ephi.dead
+#define EPHI_USES(NODE) EPHI_NODE_CHECK (NODE)->ephi.uses
+#define EPHI_STOPS(NODE) EPHI_NODE_CHECK (NODE)->ephi.stops
+
/* In a BLOCK node. */
#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
/* Define fields and accessors for nodes representing data types. */
/* See tree.def for documentation of the use of these fields.
- Look at the documentation of the various ..._TYPE tree codes. */
+ Look at the documentation of the various ..._TYPE tree codes.
+
+ Note that the type.values, type.minval, and type.maxval fields are
+ overloaded and used for different macros in different kinds of types.
+ Each macro must check to ensure the tree node is of the proper kind of
+ type. Note also that some of the front-ends also overload these fields,
+ so they must be checked as well. */
#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
-#define TYPE_VALUES(NODE) (TYPE_CHECK (NODE)->type.values)
-#define TYPE_DOMAIN(NODE) (TYPE_CHECK (NODE)->type.values)
-#define TYPE_FIELDS(NODE) (TYPE_CHECK (NODE)->type.values)
-#define TYPE_METHODS(NODE) (TYPE_CHECK (NODE)->type.maxval)
-#define TYPE_VFIELD(NODE) (TYPE_CHECK (NODE)->type.minval)
-#define TYPE_ARG_TYPES(NODE) (TYPE_CHECK (NODE)->type.values)
-#define TYPE_METHOD_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval)
-#define TYPE_OFFSET_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval)
+#define TYPE_ORIG_SIZE_TYPE(NODE) (INTEGER_TYPE_CHECK (NODE)->type.values)
+#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
+#define TYPE_DOMAIN(NODE) (SET_OR_ARRAY_CHECK (NODE)->type.values)
+#define TYPE_FIELDS(NODE) (REC_OR_UNION_CHECK (NODE)->type.values)
+#define TYPE_METHODS(NODE) (REC_OR_UNION_CHECK (NODE)->type.maxval)
+#define TYPE_VFIELD(NODE) (REC_OR_UNION_CHECK (NODE)->type.minval)
+#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
+#define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval)
+#define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval)
#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to)
#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to)
-#define TYPE_MIN_VALUE(NODE) (TYPE_CHECK (NODE)->type.minval)
-#define TYPE_MAX_VALUE(NODE) (TYPE_CHECK (NODE)->type.maxval)
+#define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval)
+#define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval)
+#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
+#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
/* For a VECTOR_TYPE node, this describes a different type which is emitted
in the debugging output. We use this to describe a vector as a
structure containing an array. */
-#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
+#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)
/* For aggregate types, information about this type, as a base type
for itself. Used in a language-dependent way for types that are
#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5)
#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6)
+/* Used to keep track of visited nodes in tree traversals. This is set to
+ 0 by copy_node and make_node. */
+#define TREE_VISITED(NODE) ((NODE)->common.visited)
+
/* If set in an ARRAY_TYPE, indicates a string type (for languages
that distinguish string from array of char).
If set in a SET_TYPE, indicates a bitstring type. */
object of the given ARRAY_TYPE. This allows temporaries to be
allocated. */
#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
- TYPE_MAX_VALUE (ARRAY_TYPE_CHECK (ARRAY_TYPE))
+ (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval)
/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */
#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
/* Nonzero if DECL represents a decl. */
#define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
+/* Nonzero if DECL represents a variable for the SSA passes. */
+#define SSA_VAR_P(DECL) \
+ (TREE_CODE (DECL) == VAR_DECL \
+ || TREE_CODE (DECL) == PARM_DECL \
+ || TREE_CODE (DECL) == RESULT_DECL \
+ || (TREE_CODE (DECL) == SSA_NAME \
+ && (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL \
+ || TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL \
+ || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL)))
+
/* This is the name of the object as written by the user.
It is an IDENTIFIER_NODE. */
#define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
For a VAR_DECL, holds the initial value.
For a PARM_DECL, not used--default
values for parameters are encoded in the type of the function,
- not in the PARM_DECL slot. */
+ not in the PARM_DECL slot.
+
+ ??? Need to figure out some way to check this isn't a PARM_DECL. */
#define DECL_INITIAL(NODE) (DECL_CHECK (NODE)->decl.initial)
/* For a PARM_DECL, records the data type used to pass the argument,
which may be different from the type seen in the program. */
where the data was actually passed. */
#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r)
-/* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */
-#define DECL_SAVED_INSNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
+/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
+ that describes the status of this function. */
+#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
/* For FUNCTION_DECL, if it is built-in,
this identifies which built-in operation it is. */
#define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.f)
+/* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this is
+ the approximate number of statements in this function. There is
+ no need for this number to be exact; it is only used in various
+ heuristics regarding optimization. */
+#define DECL_NUM_STMTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.i)
+
/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
Before the struct containing the FUNCTION_DECL is laid out,
DECL_VINDEX may point to a FUNCTION_DECL in a base class which
#define DECL_DECLARED_INLINE_P(NODE) \
(FUNCTION_DECL_CHECK (NODE)->decl.declared_inline_flag)
+/* In a VAR_DECL, nonzero if the decl is a register variable with
+ an explicit asm specification. */
+#define DECL_HARD_REGISTER(NODE) (DECL_CHECK (NODE)->decl.inline_flag)
+
/* Value of the decls's visibility attribute */
#define DECL_VISIBILITY(NODE) (DECL_CHECK (NODE)->decl.visibility)
#define DECL_POINTER_ALIAS_SET(NODE) \
(DECL_CHECK (NODE)->decl.pointer_alias_set)
+/* Used to store the alias_var for a DECL node. */
+#define DECL_PTA_ALIASVAR(NODE) \
+ (DECL_CHECK (NODE)->decl.alias_var)
+
+/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
+ dense, unique within any one function, and may be used to index arrays.
+ If the value is -1, then no UID has been assigned. */
+#define LABEL_DECL_UID(NODE) \
+ (LABEL_DECL_CHECK (NODE)->decl.pointer_alias_set)
+
/* Nonzero if an alias set has been assigned to this declaration. */
#define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
(DECL_POINTER_ALIAS_SET (NODE) != - 1)
-/* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this is
- the approximate number of statements in this function. There is
- no need for this number to be exact; it is only used in various
- heuristics regarding optimization. */
-#define DECL_ESTIMATED_INSNS(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.u1.i)
-
/* Nonzero for a decl which is at file scope. */
#define DECL_FILE_SCOPE_P(EXP) \
(! DECL_CONTEXT (EXP) \
|| TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL)
+/* Nonzero for a decl that has been marked as needing a memory slot.
+ NOTE: Never use this macro directly. It will give you incomplete
+ information. Most of the time this bit will only be set after alias
+ analysis in the tree optimizers. It's always better to call
+ needs_to_live_in_memory instead. To mark memory variables use
+ mark_call_clobbered. */
+#define DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL(DECL) \
+ DECL_CHECK (DECL)->decl.needs_to_live_in_memory
+
+/* Nonzero for a decl that cgraph has decided should be inlined into
+ at least one call site. It is not meaningful to look at this
+ directly; always use cgraph_function_possibly_inlined_p. */
+#define DECL_POSSIBLY_INLINED(DECL) \
+ FUNCTION_DECL_CHECK (DECL)->decl.possibly_inlined
+
/* Enumerate visibility settings. */
enum symbol_visibility
};
struct function;
-
+union alias_var_def;
struct tree_decl GTY(())
{
struct tree_common common;
unsigned uninlinable : 1;
unsigned thread_local_flag : 1;
unsigned declared_inline_flag : 1;
+ unsigned seen_in_bind_expr : 1;
ENUM_BITFIELD(symbol_visibility) visibility : 2;
- unsigned unused : 1;
- /* one unused bit. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
+ unsigned needs_to_live_in_memory : 1;
+ unsigned possibly_inlined : 1;
+ /* 14 unused bits. */
+
union tree_decl_u1 {
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
DECL_FUNCTION_CODE. */
unsigned int align : 24;
unsigned int off_align : 8;
} a;
- } GTY ((skip (""))) u1;
+ } GTY ((skip)) u1;
tree size_unit;
tree name;
tree vindex;
HOST_WIDE_INT pointer_alias_set;
+ union alias_var_def *GTY ((skip(""))) alias_var;
/* Points to a structure whose details depend on the language in use. */
struct lang_decl *lang_specific;
};
+
+\f
+/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
+ To reduce overhead, the nodes containing the statements are not trees.
+ This avoids the overhead of tree_common on all linked list elements.
+
+ Use the interface in tree-iterator.h to access this node. */
+
+#define STATEMENT_LIST_HEAD(NODE) \
+ (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
+#define STATEMENT_LIST_TAIL(NODE) \
+ (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
+
+struct tree_statement_list_node
+ GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
+{
+ struct tree_statement_list_node *prev;
+ struct tree_statement_list_node *next;
+ tree stmt;
+};
+
+struct tree_statement_list
+ GTY(())
+{
+ struct tree_common common;
+ struct tree_statement_list_node *head;
+ struct tree_statement_list_node *tail;
+};
\f
enum tree_node_structure_enum {
TS_COMMON,
TS_LIST,
TS_VEC,
TS_EXP,
+ TS_SSA_NAME,
+ TS_PHI_NODE,
+ TS_EPHI_NODE,
+ TS_EUSE_NODE,
+ TS_EREF_NODE,
TS_BLOCK,
+ TS_STATEMENT_LIST,
LAST_TS_ENUM
};
struct tree_list GTY ((tag ("TS_LIST"))) list;
struct tree_vec GTY ((tag ("TS_VEC"))) vec;
struct tree_exp GTY ((tag ("TS_EXP"))) exp;
+ struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
+ struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
+ struct tree_eref_common GTY ((tag ("TS_EREF_NODE"))) eref;
+ struct tree_ephi_node GTY ((tag ("TS_EPHI_NODE"))) ephi;
+ struct tree_euse_node GTY ((tag ("TS_EUSE_NODE"))) euse;
struct tree_block GTY ((tag ("TS_BLOCK"))) block;
- };
+ struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
+};
\f
/* Standard named or nameless data types of the C compiler. */
TI_BITSIZE_ONE,
TI_BITSIZE_UNIT,
+ TI_PUBLIC,
+ TI_PROTECTED,
+ TI_PRIVATE,
+
TI_BOOLEAN_FALSE,
TI_BOOLEAN_TRUE,
TI_PTR_TYPE,
TI_CONST_PTR_TYPE,
TI_SIZE_TYPE,
+ TI_PID_TYPE,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
TI_BOOLEAN_TYPE,
TI_VOID_LIST_NODE,
- TI_UV4SF_TYPE,
- TI_UV4SI_TYPE,
- TI_UV8HI_TYPE,
- TI_UV8QI_TYPE,
- TI_UV4HI_TYPE,
- TI_UV2HI_TYPE,
- TI_UV2SI_TYPE,
- TI_UV2SF_TYPE,
- TI_UV2DI_TYPE,
- TI_UV1DI_TYPE,
- TI_UV16QI_TYPE,
-
- TI_V4SF_TYPE,
- TI_V16SF_TYPE,
- TI_V4SI_TYPE,
- TI_V8HI_TYPE,
- TI_V8QI_TYPE,
- TI_V4HI_TYPE,
- TI_V2HI_TYPE,
- TI_V2SI_TYPE,
- TI_V2SF_TYPE,
- TI_V2DF_TYPE,
- TI_V2DI_TYPE,
- TI_V1DI_TYPE,
- TI_V16QI_TYPE,
- TI_V4DF_TYPE,
-
TI_MAIN_IDENTIFIER,
TI_MAX
#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]
/* Base access nodes. */
-#define access_public_node NULL_TREE
-#define access_protected_node size_zero_node
-#define access_private_node size_one_node
+#define access_public_node global_trees[TI_PUBLIC]
+#define access_protected_node global_trees[TI_PROTECTED]
+#define access_private_node global_trees[TI_PRIVATE]
#define null_pointer_node global_trees[TI_NULL_POINTER]
#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]
/* The C type `size_t'. */
#define size_type_node global_trees[TI_SIZE_TYPE]
+#define pid_type_node global_trees[TI_PID_TYPE]
#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
-#define unsigned_V16QI_type_node global_trees[TI_UV16QI_TYPE]
-#define unsigned_V4SI_type_node global_trees[TI_UV4SI_TYPE]
-#define unsigned_V8QI_type_node global_trees[TI_UV8QI_TYPE]
-#define unsigned_V8HI_type_node global_trees[TI_UV8HI_TYPE]
-#define unsigned_V4HI_type_node global_trees[TI_UV4HI_TYPE]
-#define unsigned_V2HI_type_node global_trees[TI_UV2HI_TYPE]
-#define unsigned_V2SI_type_node global_trees[TI_UV2SI_TYPE]
-#define unsigned_V2DI_type_node global_trees[TI_UV2DI_TYPE]
-#define unsigned_V1DI_type_node global_trees[TI_UV1DI_TYPE]
-
-#define V16QI_type_node global_trees[TI_V16QI_TYPE]
-#define V4SF_type_node global_trees[TI_V4SF_TYPE]
-#define V4SI_type_node global_trees[TI_V4SI_TYPE]
-#define V8QI_type_node global_trees[TI_V8QI_TYPE]
-#define V8HI_type_node global_trees[TI_V8HI_TYPE]
-#define V4HI_type_node global_trees[TI_V4HI_TYPE]
-#define V2HI_type_node global_trees[TI_V2HI_TYPE]
-#define V2SI_type_node global_trees[TI_V2SI_TYPE]
-#define V2SF_type_node global_trees[TI_V2SF_TYPE]
-#define V2DI_type_node global_trees[TI_V2DI_TYPE]
-#define V2DF_type_node global_trees[TI_V2DF_TYPE]
-#define V16SF_type_node global_trees[TI_V16SF_TYPE]
-#define V1DI_type_node global_trees[TI_V1DI_TYPE]
-#define V4DF_type_node global_trees[TI_V4DF_TYPE]
-
/* An enumeration of the standard C integer types. These must be
ordered so that shorter types appear before longer ones, and so
that signed types appear before unsigned ones, for the correct
\f
#define NULL_TREE (tree) NULL
+extern GTY(()) tree frame_base_decl;
extern tree decl_assembler_name (tree);
/* Compute the number of bytes occupied by 'node'. This routine only
The TREE_CODE is the only argument. Contents are initialized
to zero except for a few of the common fields. */
-extern tree make_node (enum tree_code);
+extern tree make_node_stat (enum tree_code MEM_STAT_DECL);
+#define make_node(t) make_node_stat (t MEM_STAT_INFO)
/* Make a copy of a node, with all the same contents. */
-extern tree copy_node (tree);
+extern tree copy_node_stat (tree MEM_STAT_DECL);
+#define copy_node(t) copy_node_stat (t MEM_STAT_INFO)
/* Make a copy of a chain of TREE_LIST nodes. */
/* Make a TREE_VEC. */
-extern tree make_tree_vec (int);
+extern tree make_tree_vec_stat (int MEM_STAT_DECL);
+#define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO)
+
+/* Tree nodes for SSA analysis. */
+
+extern tree make_phi_node (tree, int);
+extern void init_phinodes (void);
+extern void fini_phinodes (void);
+extern void release_phi_node (tree);
+#ifdef GATHER_STATISTICS
+extern void phinodes_print_statistics (void);
+#endif
+
+extern void init_ssanames (void);
+extern void fini_ssanames (void);
+extern tree make_ssa_name (tree, tree);
+extern void release_ssa_name (tree);
+#ifdef GATHER_STATISTICS
+extern void ssanames_print_statistics (void);
+#endif
/* Return the (unique) IDENTIFIER_NODE node for a given name.
The name is supplied as a char *. */
extern tree build (enum tree_code, tree, ...);
extern tree build_nt (enum tree_code, ...);
+#if GCC_VERSION >= 3000 || __STDC_VERSION__ >= 199901L
+/* Use preprocessor trickery to map "build" to "buildN" where N is the
+ expected number of arguments. This is used for both efficiency (no
+ varargs), and checking (verifying number of passed arguments). */
+#define build(code, ...) \
+ _buildN1(build, _buildC1(__VA_ARGS__))(code, __VA_ARGS__)
+#define _buildN1(BASE, X) _buildN2(BASE, X)
+#define _buildN2(BASE, X) BASE##X
+#define _buildC1(...) _buildC2(__VA_ARGS__,9,8,7,6,5,4,3,2,1,0,0)
+#define _buildC2(x,a1,a2,a3,a4,a5,a6,a7,a8,a9,c,...) c
+#endif
+
+extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL);
+#define build0(c,t) build0_stat (c,t MEM_STAT_INFO)
+extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
+#define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO)
+extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
+#define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO)
+extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
+#define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)
+extern tree build4_stat (enum tree_code, tree, tree, tree, tree,
+ tree MEM_STAT_DECL);
+#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
+
extern tree build_int_2_wide (unsigned HOST_WIDE_INT, HOST_WIDE_INT);
extern tree build_vector (tree, tree);
extern tree build_constructor (tree, tree);
extern tree build_real_from_int_cst (tree, tree);
extern tree build_complex (tree, tree, tree);
extern tree build_string (int, const char *);
-extern tree build1 (enum tree_code, tree, tree);
-extern tree build_tree_list (tree, tree);
-extern tree build_decl (enum tree_code, tree, tree);
+extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
+#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO)
+extern tree build_decl_stat (enum tree_code, tree, tree MEM_STAT_DECL);
+#define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO)
extern tree build_block (tree, tree, tree, tree, tree);
-extern tree build_expr_wfl (tree, const char *, int, int);
+extern void annotate_with_file_line (tree, const char *, int);
+extern void annotate_with_locus (tree, location_t);
+extern tree build_empty_stmt (void);
/* Construct various nodes representing data types. */
extern void initialize_sizetypes (void);
extern void set_sizetype (tree);
extern void fixup_unsigned_type (tree);
-extern tree build_pointer_type_for_mode (tree, enum machine_mode);
+extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
extern tree build_pointer_type (tree);
-extern tree build_reference_type_for_mode (tree, enum machine_mode);
+extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
extern tree build_reference_type (tree);
+extern tree build_vector_type_for_mode (tree, enum machine_mode);
+extern tree build_vector_type (tree innertype, int nunits);
extern tree build_type_no_quals (tree);
extern tree build_index_type (tree);
extern tree build_index_2_type (tree, tree);
extern tree value_member (tree, tree);
extern tree purpose_member (tree, tree);
extern tree binfo_member (tree, tree);
-extern unsigned int attribute_hash_list (tree);
+
extern int attribute_list_equal (tree, tree);
extern int attribute_list_contained (tree, tree);
extern int tree_int_cst_equal (tree, tree);
extern tree merge_dllimport_decl_attributes (tree, tree);
#endif
+/* Check whether CAND is suitable to be returned from get_qualified_type
+ (BASE, TYPE_QUALS). */
+
+extern bool check_qualified_type (tree, tree, int);
+
/* Return a version of the TYPE, qualified as indicated by the
TYPE_QUALS, if one exists. If no qualified version exists yet,
return NULL_TREE. */
extern unsigned int expr_align (tree);
extern tree expr_first (tree);
extern tree expr_last (tree);
-extern int expr_length (tree);
+extern tree expr_only (tree);
extern tree size_in_bytes (tree);
extern HOST_WIDE_INT int_size_in_bytes (tree);
extern tree bit_position (tree);
extern tree round_up (tree, int);
extern tree round_down (tree, int);
extern tree get_pending_sizes (void);
-extern int is_pending_size (tree);
extern void put_pending_size (tree);
extern void put_pending_sizes (tree);
/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
-extern tree tree_cons (tree, tree, tree);
+extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL);
+#define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO)
/* Return the last tree node in a chain. */
extern bool initializer_zerop (tree);
-/* Given an initializer INIT, return TRUE if INIT is at least 3/4 zeros.
- Otherwise return FALSE. */
-
+extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern HOST_WIDE_INT count_type_elements (tree);
extern int mostly_zeros_p (tree);
+/* add_var_to_bind_expr (bind_expr, var) binds var to bind_expr. */
+
+extern void add_var_to_bind_expr (tree, tree);
+
/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
extern int integer_zerop (tree);
extern int staticp (tree);
-/* Gets an error if argument X is not an lvalue.
- Also returns 1 if X is an lvalue, 0 if not. */
-
-extern int lvalue_or_else (tree, const char *);
-
/* save_expr (EXP) returns an expression equivalent to EXP
but it can be used multiple times within context CTX
and only evaluate EXP once. */
extern tree skip_simple_arithmetic (tree);
-/* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a
- SAVE_EXPR. Return FALSE otherwise. */
-
-extern bool saved_expr_p (tree);
-
/* Returns the index of the first non-tree operand for CODE, or the number
of operands if all are trees. */
extern tree substitute_in_expr (tree, tree, tree);
+/* This macro calls the above function but short-circuits the common
+ case of a constant to save time and also checks for NULL. */
+
+#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
+ ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
+
+/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
+ for it within OBJ, a tree that is an object or a chain of references. */
+
+extern tree substitute_placeholder_in_expr (tree, tree);
+
+/* This macro calls the above function but short-circuits the common
+ case of a constant to save time and also checks for NULL. */
+
+#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
+ ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \
+ : substitute_placeholder_in_expr (EXP, OBJ))
+
/* variable_size (EXP) is like save_expr (EXP) except that it
is for the special case of something that is part of a
variable size for a data type. It makes special arrangements
extern tree variable_size (tree);
+/* Given a type T, force elaboration of any SAVE_EXPRs used in the definition
+ of that type. */
+
+extern void force_type_save_exprs (tree);
+
/* stabilize_reference (EXP) returns a reference equivalent to EXP
but it can be used multiple times
and only evaluate the subexpressions once. */
this _DECL with its context, or zero if none. */
extern tree decl_type_context (tree);
-/* Given the FUNCTION_DECL for the current function,
- return zero if it is ok for this function to be inline.
- Otherwise return a warning message with a single %s
- for the function's name. */
-
-extern const char *function_cannot_inline_p (tree);
-
/* Return 1 if EXPR is the real constant zero. */
extern int real_zerop (tree);
\f
/* Nonzero means a FUNC_BEGIN label was emitted. */
extern GTY(()) tree current_function_func_begin_label;
+/* A DECL for the current file-scope context. When using IMA, this heads a
+ chain of FILE_DECLs; currently only C uses it. */
+
+extern GTY(()) tree current_file_decl;
+
/* Nonzero means all ..._TYPE nodes should be allocated permanently. */
extern int all_types_permanent;
extern void change_decl_assembler_name (tree, tree);
extern int type_num_arguments (tree);
extern tree lhd_unsave_expr_now (tree);
+extern bool is_essa_node (tree);
extern bool associative_tree_code (enum tree_code);
extern bool commutative_tree_code (enum tree_code);
extern void expand_end_cond (void);
extern void expand_start_else (void);
extern void expand_start_elseif (tree);
-extern struct nesting *expand_start_loop (int);
-extern struct nesting *expand_start_loop_continue_elsewhere (int);
-extern struct nesting *expand_start_null_loop (void);
-extern void expand_loop_continue_here (void);
-extern void expand_end_loop (void);
-extern void expand_end_null_loop (void);
-extern int expand_continue_loop (struct nesting *);
-extern int expand_exit_loop (struct nesting *);
-extern int expand_exit_loop_if_false (struct nesting *,tree);
-extern int expand_exit_loop_top_cond (struct nesting *, tree);
-extern int expand_exit_something (void);
+extern void expand_stack_alloc (tree, tree);
+extern rtx expand_stack_save (void);
+extern void expand_stack_restore (tree);
extern void expand_return (tree);
-extern int optimize_tail_recursion (tree, rtx);
extern void expand_start_bindings_and_block (int, tree);
#define expand_start_bindings(flags) \
expand_start_bindings_and_block(flags, NULL_TREE)
extern void expand_start_case (int, tree, tree, const char *);
extern void expand_end_case_type (tree, tree);
#define expand_end_case(cond) expand_end_case_type (cond, NULL)
-extern int add_case_node (tree, tree, tree, tree *);
+extern int add_case_node (tree, tree, tree, tree *, bool);
extern int pushcase (tree, tree (*) (tree, tree), tree, tree *);
extern int pushcase_range (tree, tree, tree (*) (tree, tree), tree, tree *);
extern void using_eh_for_cleanups (void);
extern tree fold (tree);
extern tree fold_initializer (tree);
+extern tree fold_convert (tree, tree);
extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
extern int force_fit_type (tree, int);
HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
HOST_WIDE_INT *);
-extern int operand_equal_p (tree, tree, int);
+enum operand_equal_flag
+{
+ OEP_ONLY_CONST = 1,
+ OEP_PURE_SAME = 2
+};
+
+extern int operand_equal_p (tree, tree, unsigned int);
+
extern tree omit_one_operand (tree, tree, tree);
extern tree invert_truthvalue (tree);
+extern tree nondestructive_fold_unary_to_constant (enum tree_code, tree, tree);
+extern tree nondestructive_fold_binary_to_constant (enum tree_code, tree, tree, tree);
+extern tree fold_read_from_constant_string (tree);
+extern tree int_const_binop (enum tree_code, tree, tree, int);
/* In builtins.c */
extern tree fold_builtin (tree);
extern enum built_in_function builtin_mathfn_code (tree);
extern tree build_function_call_expr (tree, tree);
extern tree mathfn_built_in (tree, enum built_in_function fn);
+extern tree strip_float_extensions (tree);
+extern tree simplify_builtin (tree, int);
+extern tree c_strlen (tree, int);
/* In convert.c */
extern tree strip_float_extensions (tree);
extern void record_component_aliases (tree);
extern HOST_WIDE_INT get_alias_set (tree);
extern int alias_sets_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
+extern int alias_sets_might_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
extern int readonly_fields_p (tree);
extern int objects_must_conflict_p (tree, tree);
extern int chain_member (tree, tree);
extern tree type_hash_lookup (unsigned int, tree);
extern void type_hash_add (unsigned int, tree);
-extern unsigned int type_hash_list (tree);
extern int simple_cst_list_equal (tree, tree);
extern void dump_tree_statistics (void);
extern void expand_function_end (void);
extern void expand_function_start (tree, int);
extern void expand_pending_sizes (tree);
+extern void recompute_tree_invarant_for_addr_expr (tree);
+extern bool needs_to_live_in_memory (tree);
+extern tree make_vector (enum machine_mode, tree, int);
+extern tree reconstruct_complex_type (tree, tree);
extern int real_onep (tree);
extern int real_twop (tree);
extern void assign_parms (tree);
extern void put_var_into_stack (tree, int);
extern void flush_addressof (tree);
-extern void uninitialized_vars_warning (tree);
+extern void setjmp_vars_warning (tree);
extern void setjmp_args_warning (void);
-extern void mark_all_temps_used (void);
extern void init_temp_slots (void);
extern void combine_temp_slots (void);
extern void free_temp_slots (void);
#endif
/* In expr.c */
-extern int apply_args_register_offset (int);
extern rtx expand_builtin_return_addr (enum built_in_function, int, rtx);
extern void check_max_integer_computation_mode (tree);
#define ECF_LONGJMP 64
/* Nonzero if this is a syscall that makes a new process in the image of
the current one. */
-#define ECF_FORK_OR_EXEC 128
-#define ECF_SIBCALL 256
+#define ECF_SIBCALL 128
/* Nonzero if this is a call to "pure" function (like const function,
but may read memory. */
-#define ECF_PURE 512
+#define ECF_PURE 256
/* Nonzero if this is a call to a function that returns with the stack
pointer depressed. */
-#define ECF_SP_DEPRESSED 1024
+#define ECF_SP_DEPRESSED 512
/* Nonzero if this call is known to always return. */
-#define ECF_ALWAYS_RETURN 2048
+#define ECF_ALWAYS_RETURN 1024
/* Create libcall block around the call. */
-#define ECF_LIBCALL_BLOCK 4096
+#define ECF_LIBCALL_BLOCK 2048
extern int flags_from_decl_or_type (tree);
extern int call_expr_flags (tree);
extern tree decl_attributes (tree *, tree, int);
/* In integrate.c */
-extern void save_for_inline (tree);
extern void set_decl_abstract_flags (tree, int);
-extern void output_inline_function (tree);
extern void set_decl_origin_self (tree);
/* In stor-layout.c */
extern void set_min_and_max_values_for_integral_type (tree, int, bool);
extern void fixup_signed_type (tree);
extern void internal_reference_types (void);
-
+extern unsigned int update_alignment_for_field (record_layout_info, tree,
+ unsigned int);
/* varasm.c */
extern void make_decl_rtl (tree, const char *);
extern void make_decl_one_only (tree);
enum tls_model decl_tls_model (tree);
extern void resolve_unique_section (tree, int, int);
extern void mark_referenced (tree);
+extern void mark_decl_referenced (tree);
extern void notice_global_symbol (tree);
/* In stmt.c */
extern bool parse_input_constraint (const char **, int, int, int, int,
const char * const *, bool *, bool *);
extern void expand_asm_operands (tree, tree, tree, tree, int, location_t);
+extern void expand_asm_expr (tree);
+extern bool asm_op_is_mem_input (tree, tree);
extern tree resolve_asm_operand_names (tree, tree, tree);
extern int any_pending_cleanups (void);
extern void init_stmt_for_function (void);
extern int expand_decl_cleanup (tree, tree);
extern int expand_decl_cleanup_eh (tree, tree, int);
extern void expand_anon_union_decl (tree, tree, tree);
-extern void expand_start_case_dummy (void);
-extern HOST_WIDE_INT all_cases_count (tree, int *);
-extern void check_for_full_enumeration_handling (tree);
-extern void declare_nonlocal_label (tree);
+extern int containing_blocks_have_cleanups_or_stack_level (void);
+
+/* In gimplify.c. */
+extern tree create_artificial_label (void);
+extern void gimplify_function_tree (tree);
+extern const char *get_name (tree);
+extern tree unshare_expr (tree);
+extern void sort_case_labels (tree);
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
extern void dwarf2out_return_reg (const char *, unsigned);
-/* The type of a function that walks over tree structure. */
+/* The type of a callback function for walking over tree structure. */
typedef tree (*walk_tree_fn) (tree *, int *, void *);
+tree walk_tree (tree*, walk_tree_fn, void*, void*);
+tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*);
/* In tree-dump.c */
/* Different tree dump places. When you add new tree dump places,
- extend the DUMP_FILES array in tree-dump.c */
+ extend the DUMP_FILES array in tree-dump.c. */
enum tree_dump_index
{
- TDI_all, /* dump the whole translation unit */
- TDI_class, /* dump class hierarchy */
+ TDI_none, /* No dump */
+ TDI_tu, /* dump the whole translation unit. */
+ TDI_class, /* dump class hierarchy. */
TDI_original, /* dump each function before optimizing it */
- TDI_optimized, /* dump each function after optimizing it */
+ TDI_generic, /* dump each function after genericizing it */
+ TDI_nested, /* dump each function after unnesting it */
TDI_inlined, /* dump each function after inlining
within it. */
+ TDI_vcg, /* create a VCG graph file for each
+ function's flowgraph. */
+ TDI_xml, /* dump function call graph. */
+ TDI_all, /* enable all the dumps. */
TDI_end
};
values, extend the DUMP_OPTIONS array in tree-dump.c */
#define TDF_ADDRESS (1 << 0) /* dump node addresses */
#define TDF_SLIM (1 << 1) /* don't go wild following links */
+#define TDF_RAW (1 << 2) /* don't unparse the function */
+#define TDF_DETAILS (1 << 3) /* show more detailed info about
+ each pass */
+#define TDF_STATS (1 << 4) /* dump various statistics about
+ each pass */
+#define TDF_BLOCKS (1 << 5) /* display basic block boundaries */
+#define TDF_VOPS (1 << 6) /* display virtual operands */
+#define TDF_LINENO (1 << 7) /* display statement line numbers */
+#define TDF_UID (1 << 8) /* display decl UIDs */
+
typedef struct dump_info *dump_info_p;
/* Assign the RTX to declaration. */
extern void set_decl_rtl (tree, rtx);
+extern void set_decl_incoming_rtl (tree, rtx);
\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic
perm_list_kind,
temp_list_kind,
vec_kind,
+ phi_kind,
+ ssa_name_kind,
x_kind,
lang_decl,
lang_type,
extern int tree_node_counts[];
extern int tree_node_sizes[];
+
+/* True if we are in gimple form and the actions of the folders need to
+ be restricted. False if we are not in gimple form and folding is not
+ restricted to creating gimple expressions. */
+extern bool in_gimple_form;
#endif /* GCC_TREE_H */
OSDN Git Service
