/* Front-end tree definitions for GNU compiler.
Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002 Free Software Foundation, Inc.
+ 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
+#ifndef GCC_TREE_H
+#define GCC_TREE_H
+
#include "machmode.h"
#include "version.h"
-#include "location.h"
+#include "input.h"
/* Codes of tree nodes */
extern const char tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
-/* Returns non-zero iff CLASS is the tree-code class of an
+/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
#define IS_EXPR_CODE_CLASS(CLASS) \
/* Codes that identify the various built in functions
so that expand_call can identify them quickly. */
-#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT) ENUM,
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM) ENUM,
enum built_in_function
{
#include "builtins.def"
extern const char *const built_in_names[(int) END_BUILTINS];
/* An array of _DECL trees for the above. */
-extern tree built_in_decls[(int) END_BUILTINS];
+extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
+extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
\f
/* The definition of tree nodes fills the next several pages. */
unsigned public_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
- unsigned bounded_flag : 1;
unsigned deprecated_flag : 1;
+ unsigned unused_1 : 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_1 : 1;
+ unsigned unused_2 : 1;
};
/* The following table lists the uses of each of the above flags and
addressable_flag:
TREE_ADDRESSABLE in
- VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
+ VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
..._TYPE, IDENTIFIER_NODE.
In a STMT_EXPR, it means we want the result of the enclosed
expression.
INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
TREE_PUBLIC in
VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
- TREE_VIA_PUBLIC in
- TREE_LIST or TREE_VEC
EXPR_WFL_EMIT_LINE_NOTE in
EXPR_WITH_FILE_LOCATION
private_flag:
- TREE_VIA_PRIVATE in
- TREE_LIST or TREE_VEC
TREE_PRIVATE in
..._DECL
+ CALL_EXPR_HAS_RETURN_SLOT_ADDR in
+ CALL_EXPR
protected_flag:
- TREE_VIA_PROTECTED in
- TREE_LIST
- TREE_VEC
TREE_PROTECTED in
BLOCK
..._DECL
TREE_UNSIGNED in
INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
- DECL_BUILT_IN_NONANSI in
- FUNCTION_DECL
SAVE_EXPR_NOPLACEHOLDER in
SAVE_EXPR
TREE_NOTHROW in
CALL_EXPR, FUNCTION_DECL
- bounded_flag:
-
- TREE_BOUNDED in
- expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
- IDENTIFIER_NODE
- TYPE_BOUNDED in
- ..._TYPE
-
deprecated_flag:
TREE_DEPRECATED in
is accessed incorrectly. The macros abort with a fatal error. */
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-#define TREE_CHECK(t, code) __extension__ \
-({ const tree __t = (t); \
- if (TREE_CODE(__t) != (code)) \
- tree_check_failed (__t, code, __FILE__, __LINE__, __FUNCTION__); \
+#define TREE_CHECK(T, CODE) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE (__t) != (CODE)) \
+ tree_check_failed (__t, (CODE), __FILE__, __LINE__, __FUNCTION__); \
__t; })
-#define TREE_CLASS_CHECK(t, class) __extension__ \
-({ const tree __t = (t); \
- if (TREE_CODE_CLASS(TREE_CODE(__t)) != (class)) \
- tree_class_check_failed (__t, class, __FILE__, __LINE__, \
+
+#define TREE_CLASS_CHECK(T, CLASS) __extension__ \
+({ const tree __t = (T); \
+ if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \
+ tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
/* These checks have to be special cased. */
-#define CST_OR_CONSTRUCTOR_CHECK(t) __extension__ \
-({ const tree __t = (t); \
- enum tree_code const __c = TREE_CODE(__t); \
- if (__c != CONSTRUCTOR && TREE_CODE_CLASS(__c) != 'c') \
- tree_check_failed (__t, CONSTRUCTOR, __FILE__, __LINE__, \
- __FUNCTION__); \
- __t; })
-#define EXPR_CHECK(t) __extension__ \
-({ const tree __t = (t); \
- char const __c = TREE_CODE_CLASS(TREE_CODE(__t)); \
- if (__c != 'r' && __c != 's' && __c != '<' \
- && __c != '1' && __c != '2' && __c != 'e') \
+#define EXPR_CHECK(T) __extension__ \
+({ const tree __t = (T); \
+ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
+ if (!IS_EXPR_CODE_CLASS (__c) && __c != 'r' && __c != 's') \
tree_class_check_failed (__t, 'e', __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
-extern void tree_check_failed PARAMS ((const tree, enum tree_code,
- const char *, int, const char *))
+#define TREE_VEC_ELT_CHECK(T, I) __extension__ \
+(*({const tree __t = (T); \
+ const int __i = (I); \
+ if (TREE_CODE (__t) != TREE_VEC) \
+ tree_check_failed (__t, TREE_VEC, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= __t->vec.length) \
+ tree_vec_elt_check_failed (__i, __t->vec.length, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->vec.a[__i]; }))
+
+/* Special checks for TREE_OPERANDs. */
+#define TREE_OPERAND_CHECK(T, I) __extension__ \
+(*({const tree __t = EXPR_CHECK (T); \
+ const int __i = (I); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \
+ tree_operand_check_failed (__i, TREE_CODE (__t), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
+#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__ \
+(*({const tree __t = (T); \
+ const int __i = (I); \
+ if (TREE_CODE (__t) != CODE) \
+ tree_check_failed (__t, CODE, __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH (CODE)) \
+ tree_operand_check_failed (__i, (CODE), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
+#define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__ \
+(*(rtx *) \
+ ({const tree __t = (T); \
+ const int __i = (I); \
+ if (TREE_CODE (__t) != (CODE)) \
+ tree_check_failed (__t, (CODE), __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH ((CODE))) \
+ tree_operand_check_failed (__i, (CODE), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
+extern void tree_check_failed (const tree, 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_class_check_failed PARAMS ((const tree, int,
- const char *, int, const char *))
+extern void tree_vec_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 *)
ATTRIBUTE_NORETURN;
#else /* not ENABLE_TREE_CHECKING, or not gcc */
-#define TREE_CHECK(t, code) (t)
-#define TREE_CLASS_CHECK(t, code) (t)
-#define CST_OR_CONSTRUCTOR_CHECK(t) (t)
-#define EXPR_CHECK(t) (t)
+#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_RTL_OPERAND_CHECK(T, CODE, I) (*(rtx *) &((T)->exp.operands[I]))
#endif
#include "tree-check.h"
-#define TYPE_CHECK(tree) TREE_CLASS_CHECK (tree, 't')
-#define DECL_CHECK(tree) TREE_CLASS_CHECK (tree, 'd')
-#define CST_CHECK(tree) TREE_CLASS_CHECK (tree, 'c')
+#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')
/* 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.
== TREE_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. */
+
+#define STRIP_MAIN_TYPE_NOPS(EXP) \
+ while ((TREE_CODE (EXP) == NOP_EXPR \
+ || TREE_CODE (EXP) == CONVERT_EXPR \
+ || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
+ && TREE_OPERAND (EXP, 0) != error_mark_node \
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (EXP)) \
+ == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
+ (EXP) = TREE_OPERAND (EXP, 0)
+
/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
#define STRIP_TYPE_NOPS(EXP) \
|| TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
|| TREE_CODE (TYPE) == SET_TYPE)
-/* Nonzero if TYPE represents an unbounded pointer or unbounded
- reference type. (It should be renamed to INDIRECT_TYPE_P.) */
+/* Nonzero if TYPE represents a pointer or reference type.
+ (It should be renamed to INDIRECT_TYPE_P.) */
#define POINTER_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
-/* Nonzero if TYPE represents a bounded pointer or bounded reference type. */
-
-#define BOUNDED_INDIRECT_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == RECORD_TYPE && TREE_TYPE (TYPE))
-
-/* Nonzero if TYPE represents a bounded pointer type. */
-
-#define BOUNDED_POINTER_TYPE_P(TYPE) \
- (BOUNDED_INDIRECT_TYPE_P (TYPE) \
- && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == POINTER_TYPE)
-
-/* Nonzero if TYPE represents a bounded reference type. Bounded
- reference types have two specific uses: (1) When a reference is
- seated to a variable-length RECORD_TYPE that has an array of
- indeterminate length as its final field. For all other objects, it
- is sufficient to check bounds at the time the reference is seated,
- and assume that all future uses of the reference are safe, since
- the address of references cannot change. (2) When a reference
- supertype is seated to an subtype object. The bounds "remember"
- the true size of the complete object, so that subsequent upcasts of
- the address of the reference will be checked properly (is such a
- thing valid C++?). */
-
-#define BOUNDED_REFERENCE_TYPE_P(TYPE) \
- (BOUNDED_INDIRECT_TYPE_P (TYPE) \
- && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == REFERENCE_TYPE)
-
-/* Nonzero if TYPE represents a pointer or reference type, either
- bounded or unbounded. */
-
-#define MAYBE_BOUNDED_INDIRECT_TYPE_P(TYPE) \
- (POINTER_TYPE_P (TYPE) || BOUNDED_INDIRECT_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a pointer type, either bounded or unbounded. */
-
-#define MAYBE_BOUNDED_POINTER_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == POINTER_TYPE || BOUNDED_POINTER_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a reference type, either bounded or
- unbounded. */
-
-#define MAYBE_BOUNDED_REFERENCE_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == REFERENCE_TYPE || BOUNDED_REFERENCE_TYPE_P (TYPE))
-
/* Nonzero if this type is a complete type. */
#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
-/* Nonzero for TREE_LIST or TREE_VEC node means that the path to the
- base class is via a `public' declaration, which preserves public
- fields from the base class as public. */
-#define TREE_VIA_PUBLIC(NODE) ((NODE)->common.public_flag)
-
-/* Ditto, for `private' declarations. */
-#define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag)
-
-/* Nonzero for TREE_LIST or TREE_VEC node means that the path to the
- base class is via a `protected' declaration, which preserves
- protected fields from the base class as protected.
- OVERLOADED. */
-#define TREE_VIA_PROTECTED(NODE) ((NODE)->common.protected_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
when the node is a type). */
#define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
-/* Non-zero if NODE is a _DECL with TREE_READONLY set. */
+/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
/* Value of expression is constant.
#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
/* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type.
- In FIELD_DECL nodes, means an unsigned bit field.
- The same bit is used in functions as DECL_BUILT_IN_NONANSI. */
+ In FIELD_DECL nodes, means an unsigned bit field. */
#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
#define TYPE_TRAP_SIGNED(NODE) \
an exception. In a CALL_EXPR, nonzero means the call cannot throw. */
#define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)
+/* In a CALL_EXPR, means that the address of the return slot is part of the
+ argument list. */
+#define CALL_EXPR_HAS_RETURN_SLOT_ADDR(NODE) ((NODE)->common.private_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
In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */
#define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
-/* In a ..._TYPE node, nonzero means that the type's size and layout,
- (or the size and layout of its arguments and/or return value in the
- case of a FUNCTION_TYPE or METHOD_TYPE) was changed by the presence
- of pointer bounds. Use TYPE_BOUNDED instead of this macro when the
- node is a type, because eventually we may make that a different
- bit. TYPE_BOUNDED doesn't mean that this type is a bounded indirect
- type--use BOUNDED_POINTER_TYPE_P, BOUNDED_REFERENCE_TYPE_P,
- BOUNDED_INDIRECT_TYPE_P to test for that.
-
- In a FUNCTION_DECL, nonzero means that the size and layout of one
- of its arguments and/or return value was changed by the presence of
- pointer bounds. This value can differ from the value of
- TYPE_BOUNDED (TREE_TYPE (fundecl)) if the function was implicitly
- declared, then later called with pointer args, or was declared with
- a variable argument list and is later called with pointer values in
- the variable argument list.
-
- In a VAR_DECL, PARM_DECL or FIELD_DECL, TREE_BOUNDED matches the value
- of the decl's type's BOUNDED_POINTER_TYPE_P.
-
- In a CONSTRUCTOR or other expression, nonzero means the value is a
- bounded pointer. It is insufficient to determine the boundedness
- of an expression EXP with BOUNDED_POINTER_TYPE_P (TREE_TYPE (EXP)),
- since we allow pointer to be temporarily cast to integer for
- rounding up to an alignment boudary in a way that preserves the
- pointer's bounds.
-
- In an IDENTIFIER_NODE, nonzero means that the name is prefixed with
- BP_PREFIX (see varasm.c). This occurs for the DECL_ASSEMBLER_NAME
- of a function that has bounded pointer(s) for its return type and/or
- argument type(s). */
-
-#define TREE_BOUNDED(NODE) ((NODE)->common.bounded_flag)
-
/* Nonzero in an IDENTIFIER_NODE if the use of the name is defined as a
deprecated feature by __attribute__((deprecated)). */
#define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
|| (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
== (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
&& TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
-
+
struct tree_int_cst GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language
- (rtl) info */
/* A sub-struct is necessary here because the function `const_hash'
wants to scan both words as a unit and taking the address of the
sub-struct yields the properly inclusive bounded pointer. */
} int_cst;
};
-/* In REAL_CST, STRING_CST, COMPLEX_CST, VECTOR_CST nodes, and
- CONSTRUCTOR nodes, and generally in all kinds of constants that
- could be given labels (rather than being immediate). */
-
-#define TREE_CST_RTL(NODE) (CST_OR_CONSTRUCTOR_CHECK (NODE)->real_cst.rtl)
-
-/* In a REAL_CST node. struct realvaluetype is an opaque entity, with
+/* In a REAL_CST node. struct real_value is an opaque entity, with
manipulators defined in real.h. We don't want tree.h depending on
real.h and transitively on tm.h. */
-struct realvaluetype;
+struct real_value;
#define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
struct tree_real_cst GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
- struct realvaluetype * real_cst_ptr;
+ struct real_value * real_cst_ptr;
};
/* In a STRING_CST */
struct tree_string GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
int length;
const char *pointer;
};
struct tree_complex GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
tree real;
tree imag;
};
struct tree_vector GTY(())
{
struct tree_common common;
- rtx rtl;
tree elements;
};
\f
(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
#define IDENTIFIER_POINTER(NODE) \
((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
+#define IDENTIFIER_HASH_VALUE(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
/* Translate a hash table identifier pointer to a tree_identifier
pointer, and vice versa. */
/* In a TREE_VEC node. */
#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
-#define TREE_VEC_ELT(NODE,I) (TREE_VEC_CHECK (NODE)->vec.a[I])
#define TREE_VEC_END(NODE) \
((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
+#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
+
struct tree_vec GTY(())
{
struct tree_common common;
/* Define fields and accessors for some nodes that represent expressions. */
/* In a SAVE_EXPR node. */
-#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND (SAVE_EXPR_CHECK (NODE), 1)
-#define SAVE_EXPR_RTL(NODE) (*(rtx *) &SAVE_EXPR_CHECK (NODE)->exp.operands[2])
+#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))
/* 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 there values are
+ SAVE_EXPRs are unsaved, meaning that their values are
recalculated.) */
#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
/* In a RTL_EXPR node. */
-#define RTL_EXPR_SEQUENCE(NODE) \
- (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[0])
-#define RTL_EXPR_RTL(NODE) (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[1])
+#define RTL_EXPR_SEQUENCE(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 0)
+#define RTL_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 1)
/* In a WITH_CLEANUP_EXPR node. */
#define WITH_CLEANUP_EXPR_RTL(NODE) \
- (*(rtx *) &WITH_CLEANUP_EXPR_CHECK (NODE)->exp.operands[2])
+ TREE_RTL_OPERAND_CHECK (NODE, WITH_CLEANUP_EXPR, 2)
/* In a CONSTRUCTOR node. */
-#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (CONSTRUCTOR_CHECK (NODE), 1)
+#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND_CHECK_CODE (NODE, CONSTRUCTOR, 0)
/* In ordinary expression nodes. */
-#define TREE_OPERAND(NODE, I) (EXPR_CHECK (NODE)->exp.operands[I])
+#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
/* In a LABELED_BLOCK_EXPR node. */
#define LABELED_BLOCK_LABEL(NODE) \
- TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 0)
+ TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 0)
#define LABELED_BLOCK_BODY(NODE) \
- TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 1)
+ TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 1)
/* In an EXIT_BLOCK_EXPR node. */
#define EXIT_BLOCK_LABELED_BLOCK(NODE) \
- TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 0)
-#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 1)
+ TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 0)
+#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 1)
/* In a LOOP_EXPR node. */
-#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (LOOP_EXPR_CHECK (NODE), 0)
+#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 (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 0)
+ TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 0)
#define EXPR_WFL_FILENAME_NODE(NODE) \
- TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 1)
+ 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. */
(EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
/* In a TARGET_EXPR node. */
-#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 0)
-#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 1)
-#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 2)
+#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)
struct tree_exp GTY(())
{
struct tree_common common;
int complexity;
- tree GTY ((special ("tree_exp"),
- length ("TREE_CODE_LENGTH (TREE_CODE ((tree) &%h))")))
+ tree GTY ((special ("tree_exp"),
+ desc ("TREE_CODE ((tree) &%0)")))
operands[1];
};
\f
structure containing an array. */
#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
-/* Indirect types present difficulties because they may be represented
- as either POINTER_TYPE/REFERENCE_TYPE nodes (unbounded) or as
- RECORD_TYPE nodes (bounded). Bounded and unbounded pointers might
- be logically equivalent, but physically different. Simple
- comparison of the main variant only tells if the types are
- logically equivalent. Use this predicate to compare for physical
- equivalency. */
-
-/* Types have the same main variant, and have the same boundedness. */
-#define TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P(TYPE1, TYPE2) \
- (TYPE_MAIN_VARIANT (TYPE1) == TYPE_MAIN_VARIANT (TYPE2) \
- && TREE_CODE (TYPE1) == TREE_CODE (TYPE2))
-
-/* Return the type variant that has no qualifiers (i.e., the main variant),
- except that the boundedness qualifier is preserved. */
-#define TYPE_MAIN_PHYSICAL_VARIANT(TYPE) \
- (BOUNDED_POINTER_TYPE_P (TYPE) \
- ? build_qualified_type (TYPE, TYPE_QUAL_BOUNDED) \
- : TYPE_MAIN_VARIANT (TYPE))
-
/* For aggregate types, information about this type, as a base type
for itself. Used in a language-dependent way for types that are
neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE. */
the term. */
#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
-/* If nonzero, this type's size and layout, (or the size and layout of
- its arguments and/or return value in the case of a FUNCTION_TYPE or
- METHOD_TYPE) was changed by the presence of pointer bounds. */
-#define TYPE_BOUNDED(NODE) (TYPE_CHECK (NODE)->common.bounded_flag)
-
/* There is a TYPE_QUAL value for each type qualifier. They can be
combined by bitwise-or to form the complete set of qualifiers for a
type. */
#define TYPE_QUAL_CONST 0x1
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_RESTRICT 0x4
-#define TYPE_QUAL_BOUNDED 0x8
/* The set of type qualifiers for this type. */
#define TYPE_QUALS(NODE) \
((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
- | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT) \
- | (BOUNDED_INDIRECT_TYPE_P (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to an expression node. */
-#define TREE_EXPR_QUALS(NODE) \
- ((TREE_READONLY (NODE) * TYPE_QUAL_CONST) \
- | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
- | (TREE_BOUNDED (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to a FUNCTION_DECL node. */
-#define TREE_FUNC_QUALS(NODE) \
- ((TREE_READONLY (NODE) * TYPE_QUAL_CONST) \
- | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE))
+ | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
/* These flags are available for each language front end to use internally. */
#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
compact a way as possible. */
#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
-/* A bounded pointer or bounded reference type (collectively called
- indirect types) is represented as a RECORD_TYPE node containing
- three pointer fields whose type is the corresponding unbounded
- POINTER_TYPE or REFERENCE_TYPE. A RECORD_TYPE node that represents
- a bounded indirect type differs from a normal RECORD_TYPE node in
- that its TREE_TYPE is non-NULL and has the pointed-to type just as
- a POINTER_TYPE or REFERENCE_TYPE node has. The bounded RECORD_TYPE
- nodes are stored on the same type variant chain alongside the
- variants of the underlaying indirect types nodes. The main variant
- of such chains is always the unbounded type. */
-
-/* Access the field decls of a bounded-pointer type. */
-#define TYPE_BOUNDED_VALUE(TYPE) TYPE_FIELDS (TYPE)
-#define TYPE_BOUNDED_BASE(TYPE) TREE_CHAIN (TYPE_BOUNDED_VALUE (TYPE))
-#define TYPE_BOUNDED_EXTENT(TYPE) TREE_CHAIN (TYPE_BOUNDED_BASE (TYPE))
-
-/* Access the simple-pointer subtype of a bounded-pointer type. */
-#define TYPE_BOUNDED_SUBTYPE(TYPE) TREE_TYPE (TYPE_BOUNDED_VALUE (TYPE))
-
-/* Find the unbounded counterpart to a type, or return TYPE if it is
- already unbounded. */
-#define TYPE_UNBOUNDED_VARIANT(TYPE) \
- (BOUNDED_POINTER_TYPE_P (TYPE) ? TYPE_BOUNDED_SUBTYPE (TYPE) : (TYPE))
-
-/* This field comprises two bits, for values in the range 0..3:
-
- depth=0 means that type is a scalar, or an aggregate that contains
- only depth=0 types, or a function that has only depth=0 types for
- its return value and argument types.
-
- depth=1 means that type is a pointer to a depth=0 type, or an
- aggregate that contains only depth=0 and depth=1 types, or a
- function that has only depth=0 and depth=1 types for its return
- value and argument types.
-
- The meanings of depth=2 and depth=3 are obvious by induction.
- Varargs functions are depth=3. The type `va_list' is depth=3.
-
- The purpose of measuring pointer depth of a type is to determine
- the eligibility of a function for an automatically-generated
- bounded-pointer thunk. A depth=0 functions needs no thunk. A
- depth=1 function is eligible for an automatic thunk. Functions
- with depth 2 or more are too complex to get automatic thunks.
-
- Function decls also have a pointer_depth field, since we also
- consider the actual argument types for functions. */
-
-#define TYPE_POINTER_DEPTH(TYPE) (TYPE_CHECK (TYPE)->type.pointer_depth)
-
-/* In a FUNCTION_TYPE node, this bit stores the value of
- default_pointer_boundedness at the time TYPE was created. It is
- useful for choosing default boundedness of function arguments for
- non-prototype function decls and for varargs/stdarg lists. */
-#define TYPE_AMBIENT_BOUNDEDNESS(TYPE) \
- (FUNCTION_TYPE_CHECK (TYPE)->type.transparent_union_flag)
-
-#define MAX_POINTER_DEPTH 2
-#define VA_LIST_POINTER_DEPTH 3
-
struct die_struct;
struct tree_type GTY(())
unsigned transparent_union_flag : 1;
unsigned packed_flag : 1;
unsigned restrict_flag : 1;
- unsigned pointer_depth : 2;
+ unsigned spare : 2;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
tree pointer_to;
tree reference_to;
union tree_type_symtab {
- int address;
- char * GTY ((tag ("1"))) pointer;
- struct die_struct * GTY ((tag ("2"), skip (""))) die;
- } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
+ int GTY ((tag ("0"))) address;
+ char * GTY ((tag ("1"))) pointer;
+ struct die_struct * GTY ((tag ("2"))) die;
+ } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
descbits ("2"))) symtab;
tree name;
tree minval;
/* For a BINFO record describing a virtual base class, i.e., one where
TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
- base. The actual contents are language-dependent. Under the old
- ABI, the C++ front-end uses a FIELD_DECL whose contents are a
- pointer to the virtual base; under the new ABI this field is
- instead an INTEGER_CST giving an offset into the vtable where the
- offset to the virtual base can be found. */
+ base. The actual contents are language-dependent. In the C++
+ front-end this field is an INTEGER_CST giving an offset into the
+ vtable where the offset to the virtual base can be found. */
#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT (NODE, 5)
-/* The size of a base class subobject of this type. Not all frontends
- currently allocate the space for these fields. */
-#define BINFO_SIZE(NODE) TREE_VEC_ELT (NODE, 6)
-#define BINFO_SIZE_UNIT(NODE) TREE_VEC_ELT (NODE, 7)
-#define TYPE_BINFO_SIZE(NODE) BINFO_SIZE (TYPE_BINFO (NODE))
-#define TYPE_BINFO_SIZE_UNIT(NODE) BINFO_SIZE_UNIT (TYPE_BINFO (NODE))
+/* Indicates the accesses this binfo has to its bases. The values are
+ access_public_node, access_protected_node or access_private_node.
+ If this array is not present, public access is implied. */
+#define BINFO_BASEACCESSES(NODE) TREE_VEC_ELT ((NODE), 6)
+#define BINFO_BASEACCESS(NODE,N) TREE_VEC_ELT (BINFO_BASEACCESSES(NODE), (N))
+
+/* Number of language independent elements in a binfo. Languages may
+ add additional trailing elements. */
+
+#define BINFO_ELTS 7
/* Slot used to build a chain that represents a use of inheritance.
For example, if X is derived from Y, and Y is derived from Z,
as DECL_NAME. It is an IDENTIFIER_NODE. */
#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
-/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
+/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
yet. */
#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
the name from decl_attributes to make_function_rtl and make_decl_rtl. */
#define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
-/* For FIELD_DECLs, this is the
- RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is
- a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
- and CONST_DECL nodes, this points to either the FUNCTION_DECL for the
- containing function, the RECORD_TYPE or UNION_TYPE for the containing
- type, or NULL_TREE if the given decl has "file scope". */
+/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
+ QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
+ PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
+ points to either the FUNCTION_DECL for the containing function,
+ the RECORD_TYPE or UNION_TYPE for the containing type, or
+ NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
+ scope". */
#define DECL_CONTEXT(NODE) (DECL_CHECK (NODE)->decl.context)
#define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.context)
/* In a DECL this is the field where attributes are stored. */
/* In PARM_DECL, holds the type as written (perhaps a function or array). */
#define DECL_ARG_TYPE_AS_WRITTEN(NODE) (PARM_DECL_CHECK (NODE)->decl.result)
/* For a FUNCTION_DECL, holds the tree of BINDINGs.
+ For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
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,
? (NODE)->decl.rtl \
: (make_decl_rtl (NODE, NULL), (NODE)->decl.rtl))
/* Set the DECL_RTL for NODE to RTL. */
-#define SET_DECL_RTL(NODE, RTL) (DECL_CHECK (NODE)->decl.rtl = (RTL))
-/* Returns non-zero if the DECL_RTL for NODE has already been set. */
+#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
+/* Returns nonzero if the DECL_RTL for NODE has already been set. */
#define DECL_RTL_SET_P(NODE) (DECL_CHECK (NODE)->decl.rtl != NULL)
/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
NODE1, it will not be set for NODE2; this is a lazy copy. */
/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
-/* Holds an INSN_LIST of all of the live ranges in which the variable
- has been moved to a possibly different register. */
-#define DECL_LIVE_RANGE_RTL(NODE) (DECL_CHECK (NODE)->decl.live_range_rtl)
-
/* For PARM_DECL, holds an RTL for the stack slot or register
where the data was actually passed. */
#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r)
#define DECL_EXTERNAL(NODE) (DECL_CHECK (NODE)->decl.external_flag)
/* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority
- initializatons. */
+ initializations. */
#define DEFAULT_INIT_PRIORITY 65535
#define MAX_INIT_PRIORITY 65535
#define MAX_RESERVED_INIT_PRIORITY 100
/* In a FIELD_DECL, indicates this field should be bit-packed. */
#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag)
-/* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a
+/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
static chain is not needed. */
#define DECL_NO_STATIC_CHAIN(NODE) \
(FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
where it is called. */
#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+/* Nonzero in a FUNCTION_DECL means this function has been found inlinable
+ only by virtue of -finline-functions */
+#define DID_INLINE_FUNC(NODE) \
+ (FUNCTION_DECL_CHECK (NODE)->decl.inlined_function_flag)
+
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
/* List of FUNCTION_DECLs inlined into this function's body. */
#define DECL_INLINED_FNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inlined_fns)
-/* Nonzero in a FUNCTION_DECL means this is a built-in function
- that is not specified by ansi C and that users are supposed to be allowed
- to redefine for any purpose whatever. */
-#define DECL_BUILT_IN_NONANSI(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->common.unsigned_flag)
-
/* Nonzero in a FUNCTION_DECL means this function should be treated
as if it were a malloc, meaning it returns a pointer that is
not an alias. */
#define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
(DECL_POINTER_ALIAS_SET (NODE) != - 1)
-/* The pointer_depth field comprises two bits for values in the range
- 0..3. The value is normally equal to TYPE_POINTER_DEPTH of decl's
- type node, but for functions it migth be greater. For example,
- this can happen when the function is declared to accept a parameter
- of type void* (depth=1), but is actually called with an argument of
- type foo** (depth=2). The function type will get the formal
- parameter's depth, but the function decl will get the actual
- argument's depth. */
-#define DECL_POINTER_DEPTH(DECL) (DECL_CHECK (DECL)->decl.pointer_depth)
-
struct function;
struct tree_decl GTY(())
ENUM_BITFIELD(built_in_class) built_in_class : 2;
unsigned pure_flag : 1;
- unsigned pointer_depth : 2;
unsigned non_addressable : 1;
unsigned user_align : 1;
unsigned uninlinable : 1;
unsigned thread_local_flag : 1;
- /* Two unused bits. */
+ unsigned inlined_function_flag : 1;
+ unsigned unused : 3;
+ /* three unused bits. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
DECL_FUNCTION_CODE. */
enum built_in_function f;
- /* In a FUNCITON_DECL for which DECL_BUILT_IN does not hold, this
+ /* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this
is used by language-dependent code. */
HOST_WIDE_INT i;
/* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for
FUNCTION_DECLs). */
struct tree_decl_u1_a {
- unsigned int align : 24;
+ unsigned int align : 24;
unsigned int off_align : 8;
} a;
} GTY ((skip (""))) u1;
tree section_name;
tree attributes;
rtx rtl; /* RTL representation for object. */
- rtx live_range_rtl;
/* In FUNCTION_DECL, if it is inline, holds the saved insn chain.
In FIELD_DECL, is DECL_FIELD_BIT_OFFSET.
struct function * GTY ((tag ("FUNCTION_DECL"))) f;
rtx GTY ((tag ("PARM_DECL"))) r;
tree GTY ((tag ("FIELD_DECL"))) t;
- int i;
+ int GTY ((tag ("VAR_DECL"))) i;
} GTY ((desc ("TREE_CODE((tree) &(%0))"))) u2;
/* In a FUNCTION_DECL, this is DECL_SAVED_TREE. */
TI_BITSIZE_ONE,
TI_BITSIZE_UNIT,
+ TI_BOOLEAN_FALSE,
+ TI_BOOLEAN_TRUE,
+
TI_COMPLEX_INTEGER_TYPE,
TI_COMPLEX_FLOAT_TYPE,
TI_COMPLEX_DOUBLE_TYPE,
TI_VOID_TYPE,
TI_PTR_TYPE,
TI_CONST_PTR_TYPE,
+ TI_SIZE_TYPE,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
+ TI_BOOLEAN_TYPE,
TI_VOID_LIST_NODE,
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_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,
#define bitsize_one_node global_trees[TI_BITSIZE_ONE]
#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 null_pointer_node global_trees[TI_NULL_POINTER]
#define float_type_node global_trees[TI_FLOAT_TYPE]
#define ptr_type_node global_trees[TI_PTR_TYPE]
/* The C type `const void *'. */
#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 ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
+#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]
+#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]
+#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]
+
/* The node that should be placed at the end of a parameter list to
indicate that the function does not take a variable number of
arguments. The TREE_VALUE will be void_type_node and there will be
#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 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
#define long_unsigned_type_node integer_types[itk_unsigned_long]
#define long_long_integer_type_node integer_types[itk_long_long]
#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
+\f
+/* Set to the default thread-local storage (tls) model to use. */
+
+enum tls_model {
+ TLS_MODEL_GLOBAL_DYNAMIC = 1,
+ TLS_MODEL_LOCAL_DYNAMIC,
+ TLS_MODEL_INITIAL_EXEC,
+ TLS_MODEL_LOCAL_EXEC
+};
+
+extern enum tls_model flag_tls_default;
+
+/* Enumerate visibility settings. */
+enum symbol_visibility
+{
+ VISIBILITY_DEFAULT,
+ VISIBILITY_INTERNAL,
+ VISIBILITY_HIDDEN,
+ VISIBILITY_PROTECTED
+};
\f
-#define NULL_TREE (tree) NULL
+/* A pointer-to-function member type looks like:
-/* Approximate positive square root of a host double. This is for
- statistical reports, not code generation. */
-extern double approx_sqrt PARAMS ((double));
+ struct {
+ __P __pfn;
+ ptrdiff_t __delta;
+ };
-extern char *permalloc PARAMS ((int));
-extern char *expralloc PARAMS ((int));
-extern tree decl_assembler_name PARAMS ((tree));
+ If __pfn is NULL, it is a NULL pointer-to-member-function.
+
+ (Because the vtable is always the first thing in the object, we
+ don't need its offset.) If the function is virtual, then PFN is
+ one plus twice the index into the vtable; otherwise, it is just a
+ pointer to the function.
+
+ Unfortunately, using the lowest bit of PFN doesn't work in
+ architectures that don't impose alignment requirements on function
+ addresses, or that use the lowest bit to tell one ISA from another,
+ for example. For such architectures, we use the lowest bit of
+ DELTA instead of the lowest bit of the PFN, and DELTA will be
+ multiplied by 2. */
+
+enum ptrmemfunc_vbit_where_t
+{
+ ptrmemfunc_vbit_in_pfn,
+ ptrmemfunc_vbit_in_delta
+};
+\f
+#define NULL_TREE (tree) NULL
+
+extern tree decl_assembler_name (tree);
/* Compute the number of bytes occupied by 'node'. This routine only
looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
-extern size_t tree_size PARAMS ((tree));
+extern size_t tree_size (tree);
/* Lowest level primitive for allocating a node.
The TREE_CODE is the only argument. Contents are initialized
to zero except for a few of the common fields. */
-extern tree make_node PARAMS ((enum tree_code));
+extern tree make_node (enum tree_code);
/* Make a copy of a node, with all the same contents. */
-extern tree copy_node PARAMS ((tree));
+extern tree copy_node (tree);
/* Make a copy of a chain of TREE_LIST nodes. */
-extern tree copy_list PARAMS ((tree));
+extern tree copy_list (tree);
/* Make a TREE_VEC. */
-extern tree make_tree_vec PARAMS ((int));
+extern tree make_tree_vec (int);
/* Return the (unique) IDENTIFIER_NODE node for a given name.
The name is supplied as a char *. */
-extern tree get_identifier PARAMS ((const char *));
+extern tree get_identifier (const char *);
/* Identical to get_identifier, except that the length is assumed
known. */
-extern tree get_identifier_with_length PARAMS ((const char *, unsigned int));
+extern tree get_identifier_with_length (const char *, unsigned int);
/* If an identifier with the name TEXT (a null-terminated string) has
previously been referred to, return that node; otherwise return
NULL_TREE. */
-extern tree maybe_get_identifier PARAMS ((const char *));
+extern tree maybe_get_identifier (const char *);
/* Construct various types of nodes. */
#define build_int_2(LO, HI) \
build_int_2_wide ((unsigned HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
-extern tree build PARAMS ((enum tree_code, tree, ...));
-extern tree build_nt PARAMS ((enum tree_code, ...));
-
-extern tree build_int_2_wide PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
-extern tree build_vector PARAMS ((tree, tree));
-extern tree build_real_from_int_cst PARAMS ((tree, tree));
-extern tree build_complex PARAMS ((tree, tree, tree));
-extern tree build_string PARAMS ((int, const char *));
-extern tree build1 PARAMS ((enum tree_code, tree, tree));
-extern tree build_tree_list PARAMS ((tree, tree));
-extern tree build_decl PARAMS ((enum tree_code, tree, tree));
-extern tree build_block PARAMS ((tree, tree, tree, tree, tree));
-extern tree build_expr_wfl PARAMS ((tree, const char *, int, int));
+extern tree build (enum tree_code, tree, ...);
+extern tree build_nt (enum tree_code, ...);
+
+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_block (tree, tree, tree, tree, tree);
+extern tree build_expr_wfl (tree, const char *, int, int);
/* Construct various nodes representing data types. */
-extern tree make_signed_type PARAMS ((int));
-extern tree make_unsigned_type PARAMS ((int));
-extern void initialize_sizetypes PARAMS ((void));
-extern void set_sizetype PARAMS ((tree));
-extern void fixup_unsigned_type PARAMS ((tree));
-extern tree build_pointer_type PARAMS ((tree));
-extern tree build_reference_type PARAMS ((tree));
-extern tree build_type_no_quals PARAMS ((tree));
-extern tree build_index_type PARAMS ((tree));
-extern tree build_index_2_type PARAMS ((tree, tree));
-extern tree build_array_type PARAMS ((tree, tree));
-extern tree build_function_type PARAMS ((tree, tree));
-extern tree build_function_type_list PARAMS ((tree, ...));
-extern tree build_method_type PARAMS ((tree, tree));
-extern tree build_offset_type PARAMS ((tree, tree));
-extern tree build_complex_type PARAMS ((tree));
-extern tree array_type_nelts PARAMS ((tree));
-
-extern tree value_member PARAMS ((tree, tree));
-extern tree purpose_member PARAMS ((tree, tree));
-extern tree binfo_member PARAMS ((tree, tree));
-extern unsigned int attribute_hash_list PARAMS ((tree));
-extern int attribute_list_equal PARAMS ((tree, tree));
-extern int attribute_list_contained PARAMS ((tree, tree));
-extern int tree_int_cst_equal PARAMS ((tree, tree));
-extern int tree_int_cst_lt PARAMS ((tree, tree));
-extern int tree_int_cst_compare PARAMS ((tree, tree));
-extern int host_integerp PARAMS ((tree, int));
-extern HOST_WIDE_INT tree_low_cst PARAMS ((tree, int));
-extern int tree_int_cst_msb PARAMS ((tree));
-extern int tree_int_cst_sgn PARAMS ((tree));
-extern int tree_expr_nonnegative_p PARAMS ((tree));
-extern int rtl_expr_nonnegative_p PARAMS ((rtx));
-extern int index_type_equal PARAMS ((tree, tree));
-extern tree get_inner_array_type PARAMS ((tree));
+extern tree make_signed_type (int);
+extern tree make_unsigned_type (int);
+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 (tree);
+extern tree build_reference_type_for_mode (tree, enum machine_mode);
+extern tree build_reference_type (tree);
+extern tree build_type_no_quals (tree);
+extern tree build_index_type (tree);
+extern tree build_index_2_type (tree, tree);
+extern tree build_array_type (tree, tree);
+extern tree build_function_type (tree, tree);
+extern tree build_function_type_list (tree, ...);
+extern tree build_method_type (tree, tree);
+extern tree build_offset_type (tree, tree);
+extern tree build_complex_type (tree);
+extern tree array_type_nelts (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 int tree_int_cst_lt (tree, tree);
+extern int tree_int_cst_compare (tree, tree);
+extern int host_integerp (tree, int);
+extern HOST_WIDE_INT tree_low_cst (tree, int);
+extern int tree_int_cst_msb (tree);
+extern int tree_int_cst_sgn (tree);
+extern int tree_expr_nonnegative_p (tree);
+extern int rtl_expr_nonnegative_p (rtx);
+extern tree get_inner_array_type (tree);
/* From expmed.c. Since rtl.h is included after tree.h, we can't
put the prototype here. Rtl.h does declare the prototype if
tree.h had been included. */
-extern tree make_tree PARAMS ((tree, rtx));
+extern tree make_tree (tree, rtx);
\f
/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
is ATTRIBUTE.
Such modified types already made are recorded so that duplicates
are not made. */
-extern tree build_type_attribute_variant PARAMS ((tree, tree));
-extern tree build_decl_attribute_variant PARAMS ((tree, tree));
+extern tree build_type_attribute_variant (tree, tree);
+extern tree build_decl_attribute_variant (tree, tree);
/* Structure describing an attribute and a function to handle it. */
struct attribute_spec
otherwise the return value should be NULL_TREE. This pointer may be
NULL if no special handling is required beyond the checks implied
by the rest of this structure. */
- tree (*const handler) PARAMS ((tree *node, tree name, tree args,
- int flags, bool *no_add_attrs));
+ tree (*const handler) (tree *node, tree name, tree args,
+ int flags, bool *no_add_attrs);
};
/* Flags that may be passed in the third argument of decl_attributes, and
/* Default versions of target-overridable functions. */
-extern tree merge_decl_attributes PARAMS ((tree, tree));
-extern tree merge_type_attributes PARAMS ((tree, tree));
-extern int default_comp_type_attributes PARAMS ((tree, tree));
-extern void default_set_default_type_attributes PARAMS ((tree));
-extern void default_insert_attributes PARAMS ((tree, tree *));
-extern bool default_function_attribute_inlinable_p PARAMS ((tree));
-extern bool default_ms_bitfield_layout_p PARAMS ((tree));
-struct cpp_reader;
-extern void default_register_cpp_builtins PARAMS ((struct cpp_reader *));
+extern tree merge_decl_attributes (tree, tree);
+extern tree merge_type_attributes (tree, tree);
+extern void default_register_cpp_builtins (struct cpp_reader *);
/* Split a list of declspecs and attributes into two. */
-extern void split_specs_attrs PARAMS ((tree, tree *, tree *));
+extern void split_specs_attrs (tree, tree *, tree *);
/* Strip attributes from a list of combined specs and attrs. */
-extern tree strip_attrs PARAMS ((tree));
+extern tree strip_attrs (tree);
/* Return 1 if an attribute and its arguments are valid for a decl or type. */
-extern int valid_machine_attribute PARAMS ((tree, tree, tree, tree));
+extern int valid_machine_attribute (tree, tree, tree, tree);
-/* Given a tree node and a string, return non-zero if the tree node is
+/* Given a tree node and a string, return nonzero if the tree node is
a valid attribute name for the string. */
-extern int is_attribute_p PARAMS ((const char *, tree));
+extern int is_attribute_p (const char *, tree);
/* Given an attribute name and a list of attributes, return the list element
of the attribute or NULL_TREE if not found. */
-extern tree lookup_attribute PARAMS ((const char *, tree));
+extern tree lookup_attribute (const char *, tree);
/* Given two attributes lists, return a list of their union. */
-extern tree merge_attributes PARAMS ((tree, tree));
+extern tree merge_attributes (tree, tree);
#ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
/* Given two Windows decl attributes lists, possibly including
dllimport, return a list of their union . */
-extern tree merge_dllimport_decl_attributes PARAMS ((tree, tree));
+extern tree merge_dllimport_decl_attributes (tree, tree);
#endif
-/* Return true if DECL will be always resolved to a symbol defined in the
- same module (shared library or program). */
-#define MODULE_LOCAL_P(DECL) \
- (lookup_attribute ("visibility", DECL_ATTRIBUTES (DECL)) != NULL)
-
/* 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 tree get_qualified_type PARAMS ((tree, int));
+extern tree get_qualified_type (tree, int);
/* Like get_qualified_type, but creates the type if it does not
exist. This function never returns NULL_TREE. */
-extern tree build_qualified_type PARAMS ((tree, int));
+extern tree build_qualified_type (tree, int);
/* Like build_qualified_type, but only deals with the `const' and
`volatile' qualifiers. This interface is retained for backwards
- compatiblity with the various front-ends; new code should use
+ compatibility with the various front-ends; new code should use
build_qualified_type instead. */
#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
/* Make a copy of a type node. */
-extern tree build_type_copy PARAMS ((tree));
+extern tree build_type_copy (tree);
+
+/* Finish up a builtin RECORD_TYPE. Give it a name and provide its
+ fields. Optionally specify an alignment, and then lsy it out. */
+
+extern void finish_builtin_struct (tree, const char *,
+ tree, tree);
/* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
TYPE_ALIGN and TYPE_MODE fields. If called more than once on one
node, does nothing except for the first time. */
-extern void layout_type PARAMS ((tree));
+extern void layout_type (tree);
/* These functions allow a front-end to perform a manual layout of a
RECORD_TYPE. (For instance, if the placement of subsequent fields
tree bitpos;
/* The alignment of the record so far, in bits. */
unsigned int record_align;
- /* The alignment of the record so far, not including padding, in bits. */
+ /* The alignment of the record so far, ignoring #pragma pack and
+ __attribute__ ((packed)), in bits. */
unsigned int unpacked_align;
- /* The alignment of the record so far, allowing for the record to be
- padded only at the end, in bits. */
- unsigned int unpadded_align;
/* The previous field layed out. */
tree prev_field;
/* The static variables (i.e., class variables, as opposed to
instance variables) encountered in T. */
tree pending_statics;
+ /* Bits remaining in the current alignment group */
+ int remaining_in_alignment;
+ /* True if we've seen a packed field that didn't have normal
+ alignment anyway. */
int packed_maybe_necessary;
} *record_layout_info;
-extern void set_lang_adjust_rli PARAMS ((void (*) PARAMS
- ((record_layout_info))));
-extern record_layout_info start_record_layout PARAMS ((tree));
-extern tree bit_from_pos PARAMS ((tree, tree));
-extern tree byte_from_pos PARAMS ((tree, tree));
-extern void pos_from_byte PARAMS ((tree *, tree *, unsigned int,
- tree));
-extern void pos_from_bit PARAMS ((tree *, tree *, unsigned int,
- tree));
-extern void normalize_offset PARAMS ((tree *, tree *,
- unsigned int));
-extern tree rli_size_unit_so_far PARAMS ((record_layout_info));
-extern tree rli_size_so_far PARAMS ((record_layout_info));
-extern void normalize_rli PARAMS ((record_layout_info));
-extern void place_field PARAMS ((record_layout_info, tree));
-extern void compute_record_mode PARAMS ((tree));
-extern void finish_record_layout PARAMS ((record_layout_info));
+extern void set_lang_adjust_rli (void (*) (record_layout_info));
+extern record_layout_info start_record_layout (tree);
+extern tree bit_from_pos (tree, tree);
+extern tree byte_from_pos (tree, tree);
+extern void pos_from_bit (tree *, tree *, unsigned int, tree);
+extern void normalize_offset (tree *, tree *, unsigned int);
+extern tree rli_size_unit_so_far (record_layout_info);
+extern tree rli_size_so_far (record_layout_info);
+extern void normalize_rli (record_layout_info);
+extern void place_field (record_layout_info, tree);
+extern void compute_record_mode (tree);
+extern void finish_record_layout (record_layout_info, int);
/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
return a canonicalized ..._TYPE node, so that duplicates are not made.
How the hash code is computed is up to the caller, as long as any two
callers that could hash identical-looking type nodes agree. */
-extern tree type_hash_canon PARAMS ((unsigned int, tree));
+extern tree type_hash_canon (unsigned int, tree);
/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
be starting at (in bits). Zero means it can be assumed aligned
on any boundary that may be needed. */
-extern void layout_decl PARAMS ((tree, unsigned));
+extern void layout_decl (tree, unsigned);
/* Return the mode for data of a given size SIZE and mode class CLASS.
If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
The value is BLKmode if no other mode is found. This is like
mode_for_size, but is passed a tree. */
-extern enum machine_mode mode_for_size_tree PARAMS ((tree, enum mode_class,
- int));
+extern enum machine_mode mode_for_size_tree (tree, enum mode_class, int);
/* Return an expr equal to X but certainly not valid as an lvalue. */
-extern tree non_lvalue PARAMS ((tree));
-extern tree pedantic_non_lvalue PARAMS ((tree));
-
-extern tree convert PARAMS ((tree, tree));
-extern unsigned int expr_align PARAMS ((tree));
-extern tree size_in_bytes PARAMS ((tree));
-extern HOST_WIDE_INT int_size_in_bytes PARAMS ((tree));
-extern tree bit_position PARAMS ((tree));
-extern HOST_WIDE_INT int_bit_position PARAMS ((tree));
-extern tree byte_position PARAMS ((tree));
-extern HOST_WIDE_INT int_byte_position PARAMS ((tree));
+extern tree non_lvalue (tree);
+extern tree pedantic_non_lvalue (tree);
+
+extern tree convert (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 size_in_bytes (tree);
+extern HOST_WIDE_INT int_size_in_bytes (tree);
+extern tree bit_position (tree);
+extern HOST_WIDE_INT int_bit_position (tree);
+extern tree byte_position (tree);
+extern HOST_WIDE_INT int_byte_position (tree);
/* Define data structures, macros, and functions for handling sizes
and the various types used to represent sizes. */
#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
#define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]
-extern tree size_binop PARAMS ((enum tree_code, tree, tree));
-extern tree size_diffop PARAMS ((tree, tree));
-extern tree size_int_wide PARAMS ((HOST_WIDE_INT,
- enum size_type_kind));
-extern tree size_int_type_wide PARAMS ((HOST_WIDE_INT, tree));
+extern tree size_binop (enum tree_code, tree, tree);
+extern tree size_diffop (tree, tree);
+extern tree size_int_wide (HOST_WIDE_INT, enum size_type_kind);
+extern tree size_int_type_wide (HOST_WIDE_INT, tree);
#define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
#define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)
-extern tree round_up PARAMS ((tree, int));
-extern tree round_down PARAMS ((tree, int));
-extern tree get_pending_sizes PARAMS ((void));
-extern int is_pending_size PARAMS ((tree));
-extern void put_pending_size PARAMS ((tree));
-extern void put_pending_sizes PARAMS ((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);
/* Type for sizes of data-type. */
/* If nonzero, an upper limit on alignment of structure fields, in bits. */
extern unsigned int maximum_field_alignment;
-/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
+/* If nonzero, the alignment of a bitstring or (power-)set value, in bits. */
extern unsigned int set_alignment;
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
by making the last node in X point to Y.
Returns X, except if X is 0 returns Y. */
-extern tree chainon PARAMS ((tree, tree));
+extern tree chainon (tree, tree);
/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
-extern tree tree_cons PARAMS ((tree, tree, tree));
+extern tree tree_cons (tree, tree, tree);
/* Return the last tree node in a chain. */
-extern tree tree_last PARAMS ((tree));
+extern tree tree_last (tree);
/* Reverse the order of elements in a chain, and return the new head. */
-extern tree nreverse PARAMS ((tree));
+extern tree nreverse (tree);
/* Returns the length of a chain of nodes
(number of chain pointers to follow before reaching a null pointer). */
-extern int list_length PARAMS ((tree));
+extern int list_length (tree);
/* Returns the number of FIELD_DECLs in a type. */
-extern int fields_length PARAMS ((tree));
+extern int fields_length (tree);
/* Given an initializer INIT, return TRUE if INIT is zero or some
aggregate of zeros. Otherwise return FALSE. */
-extern bool initializer_zerop PARAMS ((tree));
+extern bool initializer_zerop (tree);
+
+/* Given an initializer INIT, return TRUE if INIT is at least 3/4 zeros.
+ Otherwise return FALSE. */
+
+extern int mostly_zeros_p (tree);
/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
-extern int integer_zerop PARAMS ((tree));
+extern int integer_zerop (tree);
/* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
-extern int integer_onep PARAMS ((tree));
+extern int integer_onep (tree);
/* integer_all_onesp (tree x) is nonzero if X is an integer constant
all of whose significant bits are 1. */
-extern int integer_all_onesp PARAMS ((tree));
+extern int integer_all_onesp (tree);
/* integer_pow2p (tree x) is nonzero is X is an integer constant with
exactly one bit 1. */
-extern int integer_pow2p PARAMS ((tree));
+extern int integer_pow2p (tree);
+
+/* integer_nonzerop (tree x) is nonzero if X is an integer constant
+ with a nonzero value. */
+
+extern int integer_nonzerop (tree);
/* staticp (tree x) is nonzero if X is a reference to data allocated
at a fixed address in memory. */
-extern int staticp PARAMS ((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 PARAMS ((tree, const char *));
+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 save_expr PARAMS ((tree));
+extern tree save_expr (tree);
+
+/* Look inside EXPR and into any simple arithmetic operations. Return
+ the innermost non-arithmetic node. */
+
+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 int first_rtl_op PARAMS ((enum tree_code));
+extern int first_rtl_op (enum tree_code);
/* Return which tree structure is used by T. */
-enum tree_node_structure_enum tree_node_structure PARAMS ((tree));
+enum tree_node_structure_enum tree_node_structure (tree);
/* unsave_expr (EXP) returns an expression equivalent to EXP but it
can be used multiple times and will evaluate EXP in its entirety
each time. */
-extern tree unsave_expr PARAMS ((tree));
+extern tree unsave_expr (tree);
-/* Reset EXP in place so that it can be expaned again. Does not
+/* Reset EXP in place so that it can be expanded again. Does not
recurse into subtrees. */
-extern void unsave_expr_1 PARAMS ((tree));
+extern void unsave_expr_1 (tree);
/* Return 0 if it is safe to evaluate EXPR multiple times,
return 1 if it is safe if EXPR is unsaved afterward, or
return 2 if it is completely unsafe. */
-extern int unsafe_for_reeval PARAMS ((tree));
+extern int unsafe_for_reeval (tree);
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
or offset that depends on a field within a record.
Note that we only allow such expressions within simple arithmetic
or a COND_EXPR. */
-extern int contains_placeholder_p PARAMS ((tree));
+extern bool contains_placeholder_p (tree);
+
+/* This macro calls the above function but short-circuits the common
+ case of a constant to save time. Also check for null. */
+
+#define CONTAINS_PLACEHOLDER_P(EXP) \
+ ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
+
+/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
+ This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
+ positions. */
+
+extern bool type_contains_placeholder_p (tree);
/* Return 1 if EXP contains any expressions that produce cleanups for an
outer scope to deal with. Used by fold. */
-extern int has_cleanups PARAMS ((tree));
+extern int has_cleanups (tree);
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
return a tree with all occurrences of references to F in a
PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
contains only arithmetic expressions. */
-extern tree substitute_in_expr PARAMS ((tree, tree, tree));
+extern tree substitute_in_expr (tree, tree, tree);
/* variable_size (EXP) is like save_expr (EXP) except that it
is for the special case of something that is part of a
to compute the value at the right time when the data type
belongs to a function parameter. */
-extern tree variable_size PARAMS ((tree));
+extern tree variable_size (tree);
/* stabilize_reference (EXP) returns an reference equivalent to EXP
but it can be used multiple times
and only evaluate the subexpressions once. */
-extern tree stabilize_reference PARAMS ((tree));
+extern tree stabilize_reference (tree);
/* Subroutine of stabilize_reference; this is called for subtrees of
references. Any expression with side-effects must be put in a SAVE_EXPR
to ensure that it is only evaluated once. */
-extern tree stabilize_reference_1 PARAMS ((tree));
+extern tree stabilize_reference_1 (tree);
/* Return EXP, stripped of any conversions to wider types
in such a way that the result of converting to type FOR_TYPE
is the same as if EXP were converted to FOR_TYPE.
If FOR_TYPE is 0, it signifies EXP's type. */
-extern tree get_unwidened PARAMS ((tree, tree));
+extern tree get_unwidened (tree, tree);
/* Return OP or a simpler expression for a narrower value
which can be sign-extended or zero-extended to give back OP.
Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
or 0 if the value should be sign-extended. */
-extern tree get_narrower PARAMS ((tree, int *));
+extern tree get_narrower (tree, int *);
/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
look for nested component-refs or array-refs at constant positions
and find the ultimate containing object, which is returned. */
-extern tree get_inner_reference PARAMS ((tree, HOST_WIDE_INT *,
- HOST_WIDE_INT *, tree *,
- enum machine_mode *, int *,
- int *));
+extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
+ tree *, enum machine_mode *, int *, int *);
/* Return 1 if T is an expression that get_inner_reference handles. */
-extern int handled_component_p PARAMS ((tree));
+extern int handled_component_p (tree);
/* Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope. */
-extern tree get_containing_scope PARAMS ((tree));
+extern tree get_containing_scope (tree);
/* Return the FUNCTION_DECL which provides this _DECL with its context,
or zero if none. */
-extern tree decl_function_context PARAMS ((tree));
+extern tree decl_function_context (tree);
/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
this _DECL with its context, or zero if none. */
-extern tree decl_type_context PARAMS ((tree));
+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 PARAMS ((tree));
+extern const char *function_cannot_inline_p (tree);
/* Return 1 if EXPR is the real constant zero. */
-extern int real_zerop PARAMS ((tree));
+extern int real_zerop (tree);
\f
/* Declare commonly used variables for tree structure. */
-/* Points to the name of the input file from which the current input
- being parsed originally came (before it went into cpp). */
-extern const char *input_filename;
-
-/* Current line number in input file. */
-extern int lineno;
-
/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
Zero means allow extended lvalues. */
extern int all_types_permanent;
+/* Exit a binding level. This function is provided by each language
+ frontend. */
+extern tree poplevel (int, int, int);
+
/* Declare a predefined function. Return the declaration. This function is
provided by each language frontend. */
-extern tree builtin_function PARAMS ((const char *, tree, int,
- enum built_in_class,
- const char *, tree));
+extern tree builtin_function (const char *, tree, int, enum built_in_class,
+ const char *, tree);
\f
/* In tree.c */
-extern char *perm_calloc PARAMS ((int, long));
-extern void clean_symbol_name PARAMS ((char *));
-extern tree get_file_function_name_long PARAMS ((const char *));
-extern tree get_set_constructor_bits PARAMS ((tree, char *, int));
-extern tree get_set_constructor_bytes PARAMS ((tree,
- unsigned char *, int));
-extern tree get_callee_fndecl PARAMS ((tree));
-extern void set_decl_assembler_name PARAMS ((tree));
-extern int type_num_arguments PARAMS ((tree));
-extern tree lhd_unsave_expr_now PARAMS ((tree));
+extern unsigned crc32_string (unsigned, const char *);
+extern void clean_symbol_name (char *);
+extern tree get_file_function_name_long (const char *);
+extern tree get_set_constructor_bits (tree, char *, int);
+extern tree get_set_constructor_bytes (tree, unsigned char *, int);
+extern tree get_callee_fndecl (tree);
+extern void set_decl_assembler_name (tree);
+extern int type_num_arguments (tree);
+extern tree lhd_unsave_expr_now (tree);
\f
/* In stmt.c */
-extern int in_control_zone_p PARAMS ((void));
-extern void expand_fixups PARAMS ((rtx));
-extern tree expand_start_stmt_expr PARAMS ((int));
-extern tree expand_end_stmt_expr PARAMS ((tree));
-extern void expand_expr_stmt PARAMS ((tree));
-extern void expand_expr_stmt_value PARAMS ((tree, int, int));
-extern int warn_if_unused_value PARAMS ((tree));
-extern void expand_decl_init PARAMS ((tree));
-extern void clear_last_expr PARAMS ((void));
-extern void expand_label PARAMS ((tree));
-extern void expand_goto PARAMS ((tree));
-extern void expand_asm PARAMS ((tree));
-extern void expand_start_cond PARAMS ((tree, int));
-extern void expand_end_cond PARAMS ((void));
-extern void expand_start_else PARAMS ((void));
-extern void expand_start_elseif PARAMS ((tree));
-extern struct nesting *expand_start_loop PARAMS ((int));
-extern struct nesting *expand_start_loop_continue_elsewhere PARAMS ((int));
-extern struct nesting *expand_start_null_loop PARAMS ((void));
-extern void expand_loop_continue_here PARAMS ((void));
-extern void expand_end_loop PARAMS ((void));
-extern void expand_end_null_loop PARAMS ((void));
-extern int expand_continue_loop PARAMS ((struct nesting *));
-extern int expand_exit_loop PARAMS ((struct nesting *));
-extern int expand_exit_loop_if_false PARAMS ((struct nesting *,
- tree));
-extern int expand_exit_loop_top_cond PARAMS ((struct nesting *,
- tree));
-extern int expand_exit_something PARAMS ((void));
-
-extern void expand_return PARAMS ((tree));
-extern int optimize_tail_recursion PARAMS ((tree, rtx));
-extern void expand_start_bindings_and_block PARAMS ((int, tree));
+extern void expand_fixups (rtx);
+extern tree expand_start_stmt_expr (int);
+extern tree expand_end_stmt_expr (tree);
+extern void expand_expr_stmt (tree);
+extern void expand_expr_stmt_value (tree, int, int);
+extern int warn_if_unused_value (tree);
+extern void expand_decl_init (tree);
+extern void clear_last_expr (void);
+extern void expand_label (tree);
+extern void expand_goto (tree);
+extern void expand_asm (tree, int);
+extern void expand_start_cond (tree, int);
+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_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_end_bindings PARAMS ((tree, int, int));
-extern void warn_about_unused_variables PARAMS ((tree));
-extern void start_cleanup_deferral PARAMS ((void));
-extern void end_cleanup_deferral PARAMS ((void));
-extern int is_body_block PARAMS ((tree));
-
-extern int conditional_context PARAMS ((void));
-extern struct nesting * current_nesting_level PARAMS ((void));
-extern tree last_cleanup_this_contour PARAMS ((void));
-extern void expand_start_case PARAMS ((int, tree, tree,
- const char *));
-extern void expand_end_case_type PARAMS ((tree, tree));
+extern void expand_end_bindings (tree, int, int);
+extern void warn_about_unused_variables (tree);
+extern void start_cleanup_deferral (void);
+extern void end_cleanup_deferral (void);
+extern int is_body_block (tree);
+
+extern int conditional_context (void);
+extern struct nesting * current_nesting_level (void);
+extern tree last_cleanup_this_contour (void);
+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 PARAMS ((tree, tree,
- tree, tree *));
-extern int pushcase PARAMS ((tree,
- tree (*) (tree, tree),
- tree, tree *));
-extern int pushcase_range PARAMS ((tree, tree,
- tree (*) (tree, tree),
- tree, tree *));
-extern void using_eh_for_cleanups PARAMS ((void));
-extern int stmt_loop_nest_empty PARAMS ((void));
+extern int add_case_node (tree, tree, tree, tree *);
+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);
/* In fold-const.c */
if the argument itself cannot be simplified, its
subexpressions are not changed. */
-extern tree fold PARAMS ((tree));
-
-extern int force_fit_type PARAMS ((tree, int));
-extern int add_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern int neg_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern int mul_double PARAMS ((unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void lshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void rshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void lrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void rrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern int operand_equal_p PARAMS ((tree, tree, int));
-extern tree invert_truthvalue PARAMS ((tree));
-
-extern tree fold_builtin PARAMS ((tree));
-\f
-extern tree build_range_type PARAMS ((tree, tree, tree));
+extern tree fold (tree);
+extern tree fold_initializer (tree);
+extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
+
+extern int force_fit_type (tree, int);
+extern int add_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int mul_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
+extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
+extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+
+extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *);
+
+extern int operand_equal_p (tree, tree, int);
+extern tree omit_one_operand (tree, tree, tree);
+extern tree invert_truthvalue (tree);
+
+/* 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);
+
+/* In convert.c */
+extern tree strip_float_extensions (tree);
/* In alias.c */
-extern void record_component_aliases PARAMS ((tree));
-extern HOST_WIDE_INT get_alias_set PARAMS ((tree));
-extern int alias_sets_conflict_p PARAMS ((HOST_WIDE_INT,
- HOST_WIDE_INT));
-extern int readonly_fields_p PARAMS ((tree));
-extern int objects_must_conflict_p PARAMS ((tree, tree));
-
-struct obstack;
+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 readonly_fields_p (tree);
+extern int objects_must_conflict_p (tree, tree);
/* In tree.c */
-extern int really_constant_p PARAMS ((tree));
-extern int int_fits_type_p PARAMS ((tree, tree));
-extern int tree_log2 PARAMS ((tree));
-extern int tree_floor_log2 PARAMS ((tree));
-extern int simple_cst_equal PARAMS ((tree, tree));
-extern int compare_tree_int PARAMS ((tree,
- unsigned HOST_WIDE_INT));
-extern int type_list_equal PARAMS ((tree, tree));
-extern int chain_member PARAMS ((tree, tree));
-extern int chain_member_purpose PARAMS ((tree, tree));
-extern int chain_member_value PARAMS ((tree, tree));
-extern tree listify PARAMS ((tree));
-extern tree type_hash_lookup PARAMS ((unsigned int, tree));
-extern void type_hash_add PARAMS ((unsigned int, tree));
-extern unsigned int type_hash_list PARAMS ((tree));
-extern int simple_cst_list_equal PARAMS ((tree, tree));
-extern void dump_tree_statistics PARAMS ((void));
-extern void print_obstack_statistics PARAMS ((const char *,
- struct obstack *));
-#ifdef BUFSIZ
-extern void print_obstack_name PARAMS ((char *, FILE *,
- const char *));
-#endif
-extern void expand_function_end PARAMS ((const char *, int, int));
-extern void expand_function_start PARAMS ((tree, int));
-extern void expand_pending_sizes PARAMS ((tree));
-
-extern int real_onep PARAMS ((tree));
-extern int real_twop PARAMS ((tree));
-extern int real_minus_onep PARAMS ((tree));
-extern void gcc_obstack_init PARAMS ((struct obstack *));
-extern void init_obstacks PARAMS ((void));
-extern void build_common_tree_nodes PARAMS ((int));
-extern void build_common_tree_nodes_2 PARAMS ((int));
+extern int really_constant_p (tree);
+extern int int_fits_type_p (tree, tree);
+extern bool variably_modified_type_p (tree);
+extern int tree_log2 (tree);
+extern int tree_floor_log2 (tree);
+extern int simple_cst_equal (tree, tree);
+extern unsigned int iterative_hash_expr (tree, unsigned int);
+extern int compare_tree_int (tree, unsigned HOST_WIDE_INT);
+extern int type_list_equal (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 int real_onep (tree);
+extern int real_twop (tree);
+extern int real_minus_onep (tree);
+extern void init_ttree (void);
+extern void build_common_tree_nodes (int);
+extern void build_common_tree_nodes_2 (int);
+extern tree build_range_type (tree, tree, tree);
/* In function.c */
-extern void setjmp_protect_args PARAMS ((void));
-extern void setjmp_protect PARAMS ((tree));
-extern void expand_main_function PARAMS ((void));
-extern void mark_varargs PARAMS ((void));
-extern void init_dummy_function_start PARAMS ((void));
-extern void expand_dummy_function_end PARAMS ((void));
-extern void init_function_for_compilation PARAMS ((void));
-extern void init_function_start PARAMS ((tree, const char *, int));
-extern void assign_parms PARAMS ((tree));
-extern void put_var_into_stack PARAMS ((tree));
-extern void flush_addressof PARAMS ((tree));
-extern void uninitialized_vars_warning PARAMS ((tree));
-extern void setjmp_args_warning PARAMS ((void));
-extern void mark_all_temps_used PARAMS ((void));
-extern void init_temp_slots PARAMS ((void));
-extern void combine_temp_slots PARAMS ((void));
-extern void free_temp_slots PARAMS ((void));
-extern void pop_temp_slots PARAMS ((void));
-extern void push_temp_slots PARAMS ((void));
-extern void preserve_temp_slots PARAMS ((rtx));
-extern void preserve_rtl_expr_temps PARAMS ((tree));
-extern int aggregate_value_p PARAMS ((tree));
-extern void free_temps_for_rtl_expr PARAMS ((tree));
-extern void instantiate_virtual_regs PARAMS ((tree, rtx));
-extern void unshare_all_rtl PARAMS ((tree, rtx));
-extern int max_parm_reg_num PARAMS ((void));
-extern void push_function_context PARAMS ((void));
-extern void pop_function_context PARAMS ((void));
-extern void push_function_context_to PARAMS ((tree));
-extern void pop_function_context_from PARAMS ((tree));
+extern void setjmp_protect_args (void);
+extern void setjmp_protect (tree);
+extern void expand_main_function (void);
+extern void init_dummy_function_start (void);
+extern void expand_dummy_function_end (void);
+extern void init_function_for_compilation (void);
+extern void init_function_start (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_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);
+extern void pop_temp_slots (void);
+extern void push_temp_slots (void);
+extern void preserve_temp_slots (rtx);
+extern void preserve_rtl_expr_temps (tree);
+extern int aggregate_value_p (tree);
+extern void free_temps_for_rtl_expr (tree);
+extern void instantiate_virtual_regs (tree, rtx);
+extern void unshare_all_rtl (tree, rtx);
+extern void push_function_context (void);
+extern void pop_function_context (void);
+extern void push_function_context_to (tree);
+extern void pop_function_context_from (tree);
/* In print-rtl.c */
#ifdef BUFSIZ
-extern void print_rtl PARAMS ((FILE *, rtx));
+extern void print_rtl (FILE *, rtx);
#endif
/* In print-tree.c */
-extern void debug_tree PARAMS ((tree));
+extern void debug_tree (tree);
#ifdef BUFSIZ
-extern void print_node PARAMS ((FILE *, const char *, tree,
- int));
-extern void print_node_brief PARAMS ((FILE *, const char *, tree,
- int));
-extern void indent_to PARAMS ((FILE *, int));
+extern void print_node (FILE *, const char *, tree, int);
+extern void print_node_brief (FILE *, const char *, tree, int);
+extern void indent_to (FILE *, int);
#endif
/* In expr.c */
-extern int apply_args_register_offset PARAMS ((int));
-extern rtx expand_builtin_return_addr
- PARAMS ((enum built_in_function, int, rtx));
-extern void check_max_integer_computation_mode PARAMS ((tree));
+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);
/* In emit-rtl.c */
-extern void start_sequence_for_rtl_expr PARAMS ((tree));
-extern rtx emit_line_note PARAMS ((const char *, int));
+extern void start_sequence_for_rtl_expr (tree);
+extern rtx emit_line_note (location_t);
/* In calls.c */
-extern int setjmp_call_p PARAMS ((tree));
+/* Nonzero if this is a call to a `const' function. */
+#define ECF_CONST 1
+/* Nonzero if this is a call to a `volatile' function. */
+#define ECF_NORETURN 2
+/* Nonzero if this is a call to malloc or a related function. */
+#define ECF_MALLOC 4
+/* Nonzero if it is plausible that this is a call to alloca. */
+#define ECF_MAY_BE_ALLOCA 8
+/* Nonzero if this is a call to a function that won't throw an exception. */
+#define ECF_NOTHROW 16
+/* Nonzero if this is a call to setjmp or a related function. */
+#define ECF_RETURNS_TWICE 32
+/* Nonzero if this is a call to `longjmp'. */
+#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
+/* Nonzero if this is a call to "pure" function (like const function,
+ but may read memory. */
+#define ECF_PURE 512
+/* Nonzero if this is a call to a function that returns with the stack
+ pointer depressed. */
+#define ECF_SP_DEPRESSED 1024
+/* Nonzero if this call is known to always return. */
+#define ECF_ALWAYS_RETURN 2048
+/* Create libcall block around the call. */
+#define ECF_LIBCALL_BLOCK 4096
+
+extern int flags_from_decl_or_type (tree);
+
+extern int setjmp_call_p (tree);
+extern bool alloca_call_p (tree);
/* In attribs.c. */
from tree.h. Depending on these flags, some attributes may be
returned to be applied at a later stage (for example, to apply
a decl attribute to the declaration rather than to its type). */
-extern tree decl_attributes PARAMS ((tree *, tree, int));
+extern tree decl_attributes (tree *, tree, int);
/* In integrate.c */
-extern void save_for_inline PARAMS ((tree));
-extern void set_decl_abstract_flags PARAMS ((tree, int));
-extern void output_inline_function PARAMS ((tree));
-extern void set_decl_origin_self PARAMS ((tree));
+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 fixup_signed_type PARAMS ((tree));
-extern void internal_reference_types PARAMS ((void));
+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);
/* varasm.c */
-extern void make_decl_rtl PARAMS ((tree, const char *));
-extern void make_decl_one_only PARAMS ((tree));
-extern int supports_one_only PARAMS ((void));
-extern void variable_section PARAMS ((tree, int));
-
-/* In fold-const.c */
-extern int div_and_round_double PARAMS ((enum tree_code, int,
- unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
+extern void make_decl_rtl (tree, const char *);
+extern void make_decl_one_only (tree);
+extern int supports_one_only (void);
+extern void variable_section (tree, int);
+enum tls_model decl_tls_model (tree);
+enum symbol_visibility decl_visibility (tree);
+extern void resolve_unique_section (tree, int, int);
+extern void mark_referenced (tree);
/* In stmt.c */
-extern void emit_nop PARAMS ((void));
-extern void expand_computed_goto PARAMS ((tree));
-extern bool parse_output_constraint PARAMS ((const char **,
- int, int, int,
- bool *, bool *, bool *));
-extern void expand_asm_operands PARAMS ((tree, tree, tree, tree, int,
- const char *, int));
-extern int any_pending_cleanups PARAMS ((int));
-extern void init_stmt_for_function PARAMS ((void));
-extern int drop_through_at_end_p PARAMS ((void));
-extern void expand_start_target_temps PARAMS ((void));
-extern void expand_end_target_temps PARAMS ((void));
-extern void expand_elseif PARAMS ((tree));
-extern void save_stack_pointer PARAMS ((void));
-extern void expand_decl PARAMS ((tree));
-extern int expand_decl_cleanup PARAMS ((tree, tree));
-extern int expand_decl_cleanup_eh PARAMS ((tree, tree, int));
-extern void expand_anon_union_decl PARAMS ((tree, tree, tree));
-extern void move_cleanups_up PARAMS ((void));
-extern void expand_start_case_dummy PARAMS ((void));
-extern void expand_end_case_dummy PARAMS ((void));
-extern tree case_index_expr_type PARAMS ((void));
-extern HOST_WIDE_INT all_cases_count PARAMS ((tree, int *));
-extern void check_for_full_enumeration_handling PARAMS ((tree));
-extern void declare_nonlocal_label PARAMS ((tree));
+extern void emit_nop (void);
+extern void expand_computed_goto (tree);
+extern bool parse_output_constraint (const char **, int, int, int,
+ bool *, bool *, bool *);
+extern void expand_asm_operands (tree, tree, tree, tree, int,
+ const char *, int);
+extern tree resolve_asm_operand_names (tree, tree, tree);
+extern int any_pending_cleanups (void);
+extern void init_stmt_for_function (void);
+extern void expand_start_target_temps (void);
+extern void expand_end_target_temps (void);
+extern void expand_elseif (tree);
+extern void save_stack_pointer (void);
+extern void expand_decl (tree);
+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);
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
-extern tree get_file_function_name PARAMS ((int));
+extern tree get_file_function_name (int);
\f
/* Interface of the DWARF2 unwind info support. */
/* Generate a new label for the CFI info to refer to. */
-extern char *dwarf2out_cfi_label PARAMS ((void));
+extern char *dwarf2out_cfi_label (void);
/* Entry point to update the canonical frame address (CFA). */
-extern void dwarf2out_def_cfa PARAMS ((const char *, unsigned, long));
+extern void dwarf2out_def_cfa (const char *, unsigned, long);
/* Add the CFI for saving a register window. */
-extern void dwarf2out_window_save PARAMS ((const char *));
+extern void dwarf2out_window_save (const char *);
/* Add a CFI to update the running total of the size of arguments pushed
onto the stack. */
-extern void dwarf2out_args_size PARAMS ((const char *, long));
+extern void dwarf2out_args_size (const char *, long);
/* Entry point for saving a register to the stack. */
-extern void dwarf2out_reg_save PARAMS ((const char *, unsigned, long));
+extern void dwarf2out_reg_save (const char *, unsigned, long);
/* Entry point for saving the return address in the stack. */
-extern void dwarf2out_return_save PARAMS ((const char *, long));
+extern void dwarf2out_return_save (const char *, long);
/* Entry point for saving the return address in a register. */
-extern void dwarf2out_return_reg PARAMS ((const char *, unsigned));
+extern void dwarf2out_return_reg (const char *, unsigned);
/* The type of a function that walks over tree structure. */
-typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *));
+typedef tree (*walk_tree_fn) (tree *, int *, void *);
/* In tree-dump.c */
typedef struct dump_info *dump_info_p;
-extern int dump_flag PARAMS ((dump_info_p, int, tree));
-extern int dump_enabled_p PARAMS ((enum tree_dump_index));
-extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *));
-extern void dump_end PARAMS ((enum tree_dump_index, FILE *));
-extern void dump_node PARAMS ((tree, int, FILE *));
-extern int dump_switch_p PARAMS ((const char *));
-extern const char *dump_flag_name PARAMS ((enum tree_dump_index));
+extern int dump_flag (dump_info_p, int, tree);
+extern int dump_enabled_p (enum tree_dump_index);
+extern FILE *dump_begin (enum tree_dump_index, int *);
+extern void dump_end (enum tree_dump_index, FILE *);
+extern void dump_node (tree, int, FILE *);
+extern int dump_switch_p (const char *);
+extern const char *dump_flag_name (enum tree_dump_index);
+/* Assign the RTX to declaration. */
+extern void set_decl_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
special abort includes one or both. toplev.h gets too few files,
system.h gets too many. */
-extern void fancy_abort PARAMS ((const char *, int, const char *))
+extern void fancy_abort (const char *, int, const char *)
ATTRIBUTE_NORETURN;
#define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
+
+/* Enum and arrays used for tree allocation stats.
+ Keep in sync with tree.c:tree_node_kind_names. */
+typedef enum
+{
+ d_kind,
+ t_kind,
+ b_kind,
+ s_kind,
+ r_kind,
+ e_kind,
+ c_kind,
+ id_kind,
+ perm_list_kind,
+ temp_list_kind,
+ vec_kind,
+ x_kind,
+ lang_decl,
+ lang_type,
+ all_kinds
+} tree_node_kind;
+
+extern int tree_node_counts[];
+extern int tree_node_sizes[];
+
+#endif /* GCC_TREE_H */
OSDN Git Service
