#include "machmode.h"
#include "version.h"
#include "input.h"
+#include "statistics.h"
/* Codes of tree nodes */
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_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)
-/* 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 decl (most significantly a FIELD_DECL), means an unsigned field. */
+#define DECL_UNSIGNED(NODE) (DECL_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 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 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.
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)
/* Define fields and accessors for some nodes that represent expressions. */
+/* Non-zero if NODE is an emtpy 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
+
+struct edge_def;
+
+struct phi_arg_d GTY(())
+{
+ tree def;
+ struct edge_def * GTY((skip (""))) e;
+};
+
+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. */
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)
(! 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
+
/* 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;
+ /* 15 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_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 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
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 *. */
#define _buildC2(x,a1,a2,a3,a4,a5,a6,a7,a8,a9,c,...) c
#endif
-extern tree build0 (enum tree_code, tree);
-extern tree build1 (enum tree_code, tree, tree);
-extern tree build2 (enum tree_code, tree, tree, tree);
-extern tree build3 (enum tree_code, tree, tree, tree, tree);
-extern tree build4 (enum tree_code, tree, tree, tree, tree, tree);
+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_real_from_int_cst (tree, tree);
extern tree build_complex (tree, tree, tree);
extern tree build_string (int, const char *);
-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 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);
/* 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 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 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);
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 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);
#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);
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);
/* 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;
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
