/* Front-end tree definitions for GNU compiler.
- Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+ Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "machmode.h"
#include "version.h"
-#ifndef RTX_CODE
-struct rtx_def;
-#endif
-
/* Codes of tree nodes */
#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
/* Codes that identify the various built in functions
so that expand_call can identify them quickly. */
-#define DEF_BUILTIN(x) x,
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA) ENUM,
enum built_in_function
{
#include "builtins.def"
- /* Upper bound on non-language-specific builtins. */
+ /* Upper bound on non-language-specific builtins. */
END_BUILTINS
};
#undef DEF_BUILTIN
extern const char *const built_in_names[(int) END_BUILTINS];
/* An array of _DECL trees for the above. */
-extern union tree_node *built_in_decls[(int) END_BUILTINS];
+extern tree built_in_decls[(int) END_BUILTINS];
\f
/* The definition of tree nodes fills the next several pages. */
fields as well. The fields of a node are never accessed directly,
always through accessor macros. */
-/* This type is used everywhere to refer to a tree node. */
-
-typedef union tree_node *tree;
-
/* Every kind of tree node starts with this structure,
so all nodes have these fields.
See the accessor macros, defined below, for documentation of the
- fields. */
+ fields. */
struct tree_common
{
- union tree_node *chain;
- union tree_node *type;
+ tree chain;
+ tree type;
+ void *aux;
ENUM_BITFIELD(tree_code) code : 8;
unsigned side_effects_flag : 1;
unsigned constant_flag : 1;
- unsigned permanent_flag : 1;
unsigned addressable_flag : 1;
unsigned volatile_flag : 1;
unsigned readonly_flag : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
+ /* This flag is presently unused. However, language front-ends
+ should not make use of this flag; it is reserved for future
+ expansion. */
+ unsigned dummy : 1;
};
/* The following table lists the uses of each of the above flags and
TREE_OVERFLOW in
INTEGER_CST, REAL_CST, COMPLEX_CST
TREE_PUBLIC in
- VAR_DECL or FUNCTION_DECL
+ VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
TREE_VIA_PUBLIC in
TREE_LIST or TREE_VEC
EXPR_WFL_EMIT_LINE_NOTE in
TREE_VIA_PROTECTED in
TREE_LIST
+ TREE_VEC
TREE_PROTECTED in
BLOCK
??? unspecified nodes
TREE_CONSTANT in
all expressions
- permanent_flag: TREE_PERMANENT in all nodes
-
unsigned_flag:
TREE_UNSIGNED in
INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
DECL_BUILT_IN_NONANSI in
FUNCTION_DECL
- TREE_PARMLIST in
- TREE_PARMLIST (C++)
SAVE_EXPR_NOPLACEHOLDER in
SAVE_EXPR
bounded_flag:
TREE_BOUNDED in
- expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL
+ expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
+ IDENTIFIER_NODE
TYPE_BOUNDED in
..._TYPE
*/
/* The tree-code says what kind of node it is.
Codes are defined in tree.def. */
#define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
-#define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (int) (VALUE))
+#define TREE_SET_CODE(NODE, VALUE) \
+((NODE)->common.code = (ENUM_BITFIELD(tree_code)) (VALUE))
/* When checking is enabled, errors will be generated if a tree node
is accessed incorrectly. The macros abort with a fatal error. */
In VECTOR_TYPE nodes, this is the type of the elements. */
#define TREE_TYPE(NODE) ((NODE)->common.type)
+/* Here is how primitive or already-canonicalized types' hash codes
+ are made. */
+#define TYPE_HASH(TYPE) ((size_t) (TYPE) & 0777777)
+
/* Nodes are chained together for many purposes.
Types are chained together to record them for being output to the debugger
(see the function `chain_type').
&& TREE_OPERAND (EXP, 0) != error_mark_node \
&& (TYPE_MODE (TREE_TYPE (EXP)) \
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Like STRIP_NOPS, but don't let the signedness change either. */
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
&& (TREE_UNSIGNED (TREE_TYPE (EXP)) \
== TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
&& TREE_OPERAND (EXP, 0) != error_mark_node \
&& (TREE_TYPE (EXP) \
== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Nonzero if TYPE represents an integral type. Note that we do not
include COMPLEX types here. */
|| (TREE_CODE (TYPE) == COMPLEX_TYPE \
&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE))
-/* Nonzero if TYPE represents an aggregate (multi-component) type. */
+/* Nonzero if TYPE represents an aggregate (multi-component) type. */
#define AGGREGATE_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
#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. */
+/* 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 complete or is cv void. */
#define COMPLETE_OR_VOID_TYPE_P(NODE) \
- (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
+ (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
/* Nonzero if this type is complete or is an array with unspecified bound. */
#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
- (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : NODE))
+ (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
/* Nonzero if TYPE represents a type. */
/* In an IDENTIFIER_NODE, this means that assemble_name was called with
this string as an argument. */
-#define TREE_SYMBOL_REFERENCED(NODE) ((NODE)->common.static_flag)
+#define TREE_SYMBOL_REFERENCED(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)
/* In an INTEGER_CST, REAL_CST, of COMPLEX_CST, this means there was an
overflow in folding, and no warning has been issued for this subexpression.
/* In a VAR_DECL or FUNCTION_DECL,
nonzero means name is to be accessible from outside this module.
- In an identifier node, nonzero means an external declaration
+ In an IDENTIFIER_NODE, nonzero means an external declaration
accessible from outside this module was previously seen
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
/* Ditto, for `private' declarations. */
#define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag)
-/* Nonzero for TREE_LIST node means that the path to the
+/* 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. */
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. */
+#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
+
/* Value of expression is constant.
Always appears in all ..._CST nodes.
May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR
if the value is constant. */
#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
-/* Nonzero means permanent node;
- node will continue to exist for the entire compiler run.
- Otherwise it will be recycled at the end of the function.
- This flag is always zero if garbage collection is in use.
- Try not to use this. Only set it with TREE_SET_PERMANENT. */
-#define TREE_PERMANENT(NODE) ((NODE)->common.permanent_flag)
-#define TREE_SET_PERMANENT(NODE) do { \
- if (!ggc_p && current_obstack == &permanent_obstack) \
- TREE_PERMANENT(NODE) = 1; \
-} while (0)
-
/* 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. */
#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
+#define TYPE_TRAP_SIGNED(NODE) \
+ (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE)))
+
/* Nonzero in a VAR_DECL means assembler code has been written.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
This is interesting in an inline function, since it might not need
an exception. In a CALL_EXPR, nonzero means the call cannot throw. */
#define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)
+/* In a type, nonzero means that all objects of the type are guaranteed by the
+ language or front-end to be properly aligned, so we can indicate that a MEM
+ of this type is aligned at least to the alignment of the type, even if it
+ doesn't appear that it is. We see this, for example, in object-oriented
+ languages where a tag field may show this is an object of a more-aligned
+ variant of the more generic type. */
+#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)
+
/* Used in classes in C++. */
#define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
/* Used in classes in C++.
#define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
#define INT_CST_LT(A, B) \
-(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
- || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
- && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
+ (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
+ || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
+ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
#define INT_CST_LT_UNSIGNED(A, B) \
-(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
- < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
- || (((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)))
-
+ (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
+ < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
+ || (((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
{
struct tree_common common;
- struct rtx_def *rtl; /* acts as link to register transfer language
+ 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
#define TREE_CST_RTL(NODE) (CST_OR_CONSTRUCTOR_CHECK (NODE)->real_cst.rtl)
-/* In a REAL_CST node. */
-/* We can represent a real value as either a `double' or a string.
- Strings don't allow for any optimization, but they do allow
- for cross-compilation. */
+/* In a REAL_CST node.
+
+ We can represent a real value as either a `double' or an array of
+ longs. */
#define TREE_REAL_CST(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst)
struct tree_real_cst
{
struct tree_common common;
- struct rtx_def *rtl; /* acts as link to register transfer language
+ rtx rtl; /* acts as link to register transfer language
(rtl) info */
REAL_VALUE_TYPE real_cst;
};
struct tree_string
{
struct tree_common common;
- struct rtx_def *rtl; /* acts as link to register transfer language
+ rtx rtl; /* acts as link to register transfer language
(rtl) info */
int length;
- char *pointer;
+ const char *pointer;
};
/* In a COMPLEX_CST node. */
struct tree_complex
{
struct tree_common common;
- struct rtx_def *rtl; /* acts as link to register transfer language
+ rtx rtl; /* acts as link to register transfer language
(rtl) info */
- union tree_node *real;
- union tree_node *imag;
+ tree real;
+ tree imag;
};
\f
+#include "hashtable.h"
+
/* Define fields and accessors for some special-purpose tree nodes. */
-#define IDENTIFIER_LENGTH(NODE) (IDENTIFIER_NODE_CHECK (NODE)->identifier.length)
-#define IDENTIFIER_POINTER(NODE) (IDENTIFIER_NODE_CHECK (NODE)->identifier.pointer)
+#define IDENTIFIER_LENGTH(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
+#define IDENTIFIER_POINTER(NODE) \
+ ((char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
+
+/* Translate a hash table identifier pointer to a tree_identifier
+ pointer, and vice versa. */
+
+#define HT_IDENT_TO_GCC_IDENT(NODE) \
+ ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
+#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
struct tree_identifier
{
struct tree_common common;
- int length;
- const char *pointer;
+ struct ht_identifier id;
};
/* In a TREE_LIST node. */
struct tree_list
{
struct tree_common common;
- union tree_node *purpose;
- union tree_node *value;
+ tree purpose;
+ tree value;
};
/* 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_END(NODE) \
+ ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
struct tree_vec
{
struct tree_common common;
int length;
- union tree_node *a[1];
+ tree a[1];
};
/* Define fields and accessors for some nodes that represent expressions. */
/* In a SAVE_EXPR node. */
-#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1)
-#define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2])
-#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (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_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
recalculated.) */
-#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (NODE)
+#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
/* In a RTL_EXPR node. */
-#define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[0])
-#define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[1])
+#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])
-/* In a CALL_EXPR node. */
-#define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2])
+/* In a WITH_CLEANUP_EXPR node. */
+#define WITH_CLEANUP_EXPR_RTL(NODE) \
+ (*(rtx *) &WITH_CLEANUP_EXPR_CHECK (NODE)->exp.operands[2])
/* In a CONSTRUCTOR node. */
-#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)
+#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (CONSTRUCTOR_CHECK (NODE), 1)
/* In ordinary expression nodes. */
#define TREE_OPERAND(NODE, I) (EXPR_CHECK (NODE)->exp.operands[I])
#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
/* In a LABELED_BLOCK_EXPR node. */
-#define LABELED_BLOCK_LABEL(NODE) TREE_OPERAND (NODE, 0)
-#define LABELED_BLOCK_BODY(NODE) TREE_OPERAND (NODE, 1)
+#define LABELED_BLOCK_LABEL(NODE) \
+ TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 0)
+#define LABELED_BLOCK_BODY(NODE) \
+ TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 1)
/* In a EXIT_BLOCK_EXPR node. */
-#define EXIT_BLOCK_LABELED_BLOCK(NODE) TREE_OPERAND (NODE, 0)
-#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (NODE, 1)
+#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)
/* In a LOOP_EXPR node. */
-#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (NODE, 0)
+#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (LOOP_EXPR_CHECK (NODE), 0)
/* In a EXPR_WITH_FILE_LOCATION node. */
-#define EXPR_WFL_NODE(NODE) TREE_OPERAND((NODE), 0)
+#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)
+#define EXPR_WFL_FILENAME_NODE(NODE) \
+ TREE_OPERAND(EXPR_WITH_FILE_LOCATION_CHECK (NODE), 1)
#define EXPR_WFL_FILENAME(NODE) \
- (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE ((NODE))))
-#define EXPR_WFL_FILENAME_NODE(NODE) TREE_OPERAND((NODE), 1)
-#define EXPR_WFL_LINENO(NODE) (EXPR_CHECK (NODE)->exp.complexity >> 12)
-#define EXPR_WFL_COLNO(NODE) (EXPR_CHECK (NODE)->exp.complexity & 0xfff)
+ IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE ((NODE)))
+/* ??? Java uses this in all expressions. */
#define EXPR_WFL_LINECOL(NODE) (EXPR_CHECK (NODE)->exp.complexity)
+#define EXPR_WFL_LINENO(NODE) (EXPR_WFL_LINECOL (NODE) >> 12)
+#define EXPR_WFL_COLNO(NODE) (EXPR_WFL_LINECOL (NODE) & 0xfff)
#define EXPR_WFL_SET_LINECOL(NODE, LINE, COL) \
(EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
-#define EXPR_WFL_EMIT_LINE_NOTE(NODE) ((NODE)->common.public_flag)
struct tree_exp
{
struct tree_common common;
int complexity;
- union tree_node *operands[1];
+ tree operands[1];
};
\f
/* In a BLOCK node. */
#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
/* Note: when changing this, make sure to find the places
that use chainon or nreverse. */
-#define BLOCK_CHAIN(NODE) TREE_CHAIN (NODE)
+#define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
#define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
/* Nonzero means that this block is prepared to handle exceptions
listed in the BLOCK_VARS slot. */
-#define BLOCK_HANDLER_BLOCK(NODE) (BLOCK_CHECK (NODE)->block.handler_block_flag)
+#define BLOCK_HANDLER_BLOCK(NODE) \
+ (BLOCK_CHECK (NODE)->block.handler_block_flag)
/* An index number for this block. These values are not guaranteed to
be unique across functions -- whether or not they are depends on
the debugging output format in use. */
#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
+/* If block reordering splits a lexical block into discontiguous
+ address ranges, we'll make a copy of the original block.
+
+ Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
+ In that case, we have one source block that has been replicated
+ (through inlining or unrolling) into many logical blocks, and that
+ these logical blocks have different physical variables in them.
+
+ In this case, we have one logical block split into several
+ non-contiguous address ranges. Most debug formats can't actually
+ represent this idea directly, so we fake it by creating multiple
+ logical blocks with the same variables in them. However, for those
+ that do support non-contiguous regions, these allow the original
+ logical block to be reconstructed, along with the set of address
+ ranges.
+
+ One of the logical block fragments is arbitrarily chosen to be
+ the ORIGIN. The other fragments will point to the origin via
+ BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
+ be null. The list of fragments will be chained through
+ BLOCK_FRAGMENT_CHAIN from the origin. */
+
+#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
+#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
+
struct tree_block
{
struct tree_common common;
unsigned abstract_flag : 1;
unsigned block_num : 30;
- union tree_node *vars;
- union tree_node *subblocks;
- union tree_node *supercontext;
- union tree_node *abstract_origin;
+ tree vars;
+ tree subblocks;
+ tree supercontext;
+ tree abstract_origin;
+ tree fragment_origin;
+ tree fragment_chain;
};
\f
/* Define fields and accessors for nodes representing data types. */
#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
-#define TYPE_NONCOPIED_PARTS(NODE) (TYPE_CHECK (NODE)->type.noncopied_parts)
#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
-#define TYPE_OBSTACK(NODE) (TYPE_CHECK (NODE)->type.obstack)
#define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
/* For a VECTOR_TYPE node, this describes a different type which is emitted
/* Nonzero iff the typed-based alias set for this type has been
calculated. */
-#define TYPE_ALIAS_SET_KNOWN_P(NODE) \
- (TYPE_CHECK (NODE)->type.alias_set != -1)
+#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)
/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
to this type. */
#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
/* The alignment for NODE, in bytes. */
-#define TYPE_ALIGN_UNIT(NODE) \
- (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
+#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
-#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE))
+/* If your language allows you to declare types, and you want debug info
+ for them, then you need to generate corresponding TYPE_DECL nodes.
+ These "stub" TYPE_DECL nodes have no name, and simply point at the
+ type node. You then set the TYPE_STUB_DECL field of the type node
+ to point back at the TYPE_DECL node. This allows the debug routines
+ to know that the two nodes represent the same type, so that we only
+ get one debug info record for them. */
+#define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)
/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
has BLKmode only because it lacks the alignment requirement for
its size. */
#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
-/* In an INTEGER_TYPE, it means the type represents a size. We use this
- both for validity checking and to permit optimziations that are unsafe
- for other types. */
+/* In an INTEGER_TYPE, it means the type represents a size. We use
+ this both for validity checking and to permit optimizations that
+ are unsafe for other types. Note that the C `size_t' type should
+ *not* have this flag set. The `size_t' type is simply a typedef
+ for an ordinary integer type that happens to be the type of an
+ expression returned by `sizeof'; `size_t' has no special
+ properties. Expressions whose type have TYPE_IS_SIZETYPE set are
+ always actual sizes. */
#define TYPE_IS_SIZETYPE(NODE) \
(INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
(FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)
/* Nonzero in a type considered volatile as a whole. */
-#define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
+#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->common.volatile_flag)
/* Means this type is const-qualified. */
-#define TYPE_READONLY(NODE) ((NODE)->common.readonly_flag)
+#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->common.readonly_flag)
/* If nonzero, this type is `restrict'-qualified, in the C sense of
the term. */
/* If set in an ARRAY_TYPE, indicates a string type (for languages
that distinguish string from array of char).
- If set in a SET_TYPE, indicates a bitstring type. */
+ If set in a SET_TYPE, indicates a bitstring type. */
#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)
-/* If non-NULL, this is a upper bound of the size (in bytes) of an
- object of the given ARRAY_TYPE. This allows temporaries to be allocated. */
-#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) TYPE_MAX_VALUE (ARRAY_TYPE)
+/* If non-NULL, this is an upper bound of the size (in bytes) of an
+ object of the given ARRAY_TYPE. This allows temporaries to be
+ allocated. */
+#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
+ TYPE_MAX_VALUE (ARRAY_TYPE_CHECK (ARRAY_TYPE))
/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */
-#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) (GET_MODE_NUNITS (TYPE_CHECK (VECTOR_TYPE)->type.mode))
+#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
+ GET_MODE_NUNITS (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.mode)
/* Indicates that objects of this type must be initialized by calling a
function when they are created. */
struct tree_type
{
struct tree_common common;
- union tree_node *values;
- union tree_node *size;
- union tree_node *size_unit;
- union tree_node *attributes;
+ tree values;
+ tree size;
+ tree size_unit;
+ tree attributes;
unsigned int uid;
unsigned int precision : 9;
unsigned user_align : 1;
unsigned int align;
- union tree_node *pointer_to;
- union tree_node *reference_to;
+ tree pointer_to;
+ tree reference_to;
union {int address; char *pointer; } symtab;
- union tree_node *name;
- union tree_node *minval;
- union tree_node *maxval;
- union tree_node *next_variant;
- union tree_node *main_variant;
- union tree_node *binfo;
- union tree_node *noncopied_parts;
- union tree_node *context;
- struct obstack *obstack;
+ tree name;
+ tree minval;
+ tree maxval;
+ tree next_variant;
+ tree main_variant;
+ tree binfo;
+ tree context;
HOST_WIDE_INT alias_set;
/* Points to a structure whose details depend on the language in use. */
struct lang_type *lang_specific;
/* Accessor macro to get to the Nth basetype of this basetype. */
#define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N))
-#define TYPE_BINFO_BASETYPE(NODE,N) BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
+#define TYPE_BINFO_BASETYPE(NODE,N) \
+ BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
/* 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
pointer to the virtual base; under the new ABI this field is
instead a 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)
+#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 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))
/* Nonzero if DECL represents a decl. */
#define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
+
/* This is the name of the object as written by the user.
It is an IDENTIFIER_NODE. */
#define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
-/* This is the name of the object as the assembler will see it
- (but before any translations made by ASM_OUTPUT_LABELREF).
- Often this is the same as DECL_NAME.
- It is an IDENTIFIER_NODE. */
-#define DECL_ASSEMBLER_NAME(NODE) (DECL_CHECK (NODE)->decl.assembler_name)
+
+/* The name of the object as the assembler will see it (but before any
+ translations made by ASM_OUTPUT_LABELREF). Often this is the same
+ as DECL_NAME. It is an IDENTIFIER_NODE. */
+#define DECL_ASSEMBLER_NAME(NODE) \
+ ((DECL_ASSEMBLER_NAME_SET_P (NODE) \
+ ? (void) 0 \
+ : (*lang_set_decl_assembler_name) (NODE)), \
+ DECL_CHECK (NODE)->decl.assembler_name)
+
+/* Returns non-zero 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) \
+ (DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
+
+/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
+#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
+ (DECL_CHECK (NODE)->decl.assembler_name = (NAME))
+
+/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's
+ DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
+ the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the
+ semantics of using this macro, are different than saying:
+
+ SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
+
+ which will try to set the DECL_ASSEMBLER_NAME for DECL1. */
+
+#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \
+ (DECL_ASSEMBLER_NAME_SET_P (DECL1) \
+ ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
+ DECL_ASSEMBLER_NAME (DECL1)) \
+ : (void) 0)
+
/* Records the section name in a section attribute. Used to pass
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,
type, or NULL_TREE 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 configuration dependent machine
- attributes are store */
-#define DECL_MACHINE_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.machine_attributes)
+/* In a DECL this is the field where attributes are stored. */
+#define DECL_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.attributes)
/* In a FIELD_DECL, this is the field position, counting in bytes, of the
byte containing the bit closest to the beginning of the structure. */
#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.arguments)
if so, the type that was originally specified for it.
TREE_TYPE may have been modified (in finish_struct). */
#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->decl.result)
-/* In FUNCTION_DECL, a chain of ..._DECL nodes. */
-/* VAR_DECL and PARM_DECL reserve the arguments slot
- for language-specific uses. */
+/* In FUNCTION_DECL, a chain of ..._DECL nodes.
+ VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
+ uses. */
#define DECL_ARGUMENTS(NODE) (DECL_CHECK (NODE)->decl.arguments)
/* This field is used to reference anything in decl.result and is meant only
for use by the garbage collector. */
/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
if nonzero, indicates that the field occupies the type. */
#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->decl.initial)
-/* These two fields describe where in the source code the declaration was. */
+/* These two fields describe where in the source code the declaration
+ was. If the declaration appears in several places (as for a C
+ function that is declared first and then defined later), this
+ information should refer to the definition. */
#define DECL_SOURCE_FILE(NODE) (DECL_CHECK (NODE)->decl.filename)
#define DECL_SOURCE_LINE(NODE) (DECL_CHECK (NODE)->decl.linenum)
/* Holds the size of the datum, in bits, as a tree expression.
#define DECL_SIZE(NODE) (DECL_CHECK (NODE)->decl.size)
/* Likewise for the size in bytes. */
#define DECL_SIZE_UNIT(NODE) (DECL_CHECK (NODE)->decl.size_unit)
-/* Holds the alignment required for the datum. */
+/* Holds the alignment required for the datum, in bits. */
#define DECL_ALIGN(NODE) (DECL_CHECK (NODE)->decl.u1.a.align)
+/* The alignment of NODE, in bytes. */
+#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
/* For FIELD_DECLs, off_align holds the number of low-order bits of
DECL_FIELD_OFFSET which are known to be always zero.
DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
PROMOTED_MODE is defined, the mode of this expression may not be same
as DECL_MODE. In that case, DECL_MODE contains the mode corresponding
to the variable's data type, while the mode
- of DECL_RTL is the mode actually used to contain the data. */
-#define DECL_RTL(NODE) (DECL_CHECK (NODE)->decl.rtl)
+ of DECL_RTL is the mode actually used to contain the data.
+
+ This value can be evaluated lazily for functions, variables with
+ static storage duration, and labels. */
+#define DECL_RTL(NODE) \
+ (DECL_CHECK (NODE)->decl.rtl \
+ ? (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 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. */
+#define COPY_DECL_RTL(NODE1, NODE2) \
+ (DECL_CHECK (NODE2)->decl.rtl = DECL_CHECK (NODE1)->decl.rtl)
+/* 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)
+
/* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */
#define DECL_SAVED_INSNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
-/* For FUNCTION_DECL, if it is inline,
- holds the size of the stack frame, as an integer. */
-#define DECL_FRAME_SIZE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.i)
+
/* For FUNCTION_DECL, if it is built-in,
this identifies which built-in operation it is. */
#define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.f)
to an INTEGER_CST node which is suitable for use as an index
into the virtual function table. */
#define DECL_VINDEX(NODE) (DECL_CHECK (NODE)->decl.vindex)
+
/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
which this FIELD_DECL is defined. This information is needed when
writing debugging information about vfield and vbase decls for C++. */
/* Nonzero for any sort of ..._DECL node means this decl node represents an
inline instance of some original (abstract) decl from an inline function;
suppress any warnings about shadowing some other variable. FUNCTION_DECL
- nodes can also have their abstract origin set to themselves. */
+ nodes can also have their abstract origin set to themselves. */
#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != (tree) 0 \
&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
/* Nonzero if a _DECL means that no warnings should be generated just
because this decl is unused. */
-#define DECL_IN_SYSTEM_HEADER(NODE) (DECL_CHECK (NODE)->decl.in_system_header_flag)
+#define DECL_IN_SYSTEM_HEADER(NODE) \
+ (DECL_CHECK (NODE)->decl.in_system_header_flag)
/* Nonzero for a given ..._DECL node means that this node should be
put in .common, if possible. If a DECL_INITIAL is given, and it
#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. */
+ initializatons. */
#define DEFAULT_INIT_PRIORITY 65535
#define MAX_INIT_PRIORITY 65535
#define MAX_RESERVED_INIT_PRIORITY 100
/* In a TYPE_DECL
nonzero means the detail info about this type is not dumped into stabs.
Instead it will generate cross reference ('x') of names.
- This uses the same flag as DECL_EXTERNAL. */
+ This uses the same flag as DECL_EXTERNAL. */
#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
-(TYPE_DECL_CHECK (NODE)->decl.external_flag)
+ (TYPE_DECL_CHECK (NODE)->decl.external_flag)
/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
#define DECL_REGISTER(NODE) (DECL_CHECK (NODE)->decl.regdecl_flag)
+
/* In LABEL_DECL nodes, nonzero means that an error message about
jumping into such a binding contour has been printed for this label. */
#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl.regdecl_flag)
+
/* 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
static chain is not needed. */
#define DECL_NO_STATIC_CHAIN(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
where it is called. */
#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
+#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
+
+/* In a FUNCTION_DECL, the saved representation of the body of the
+ entire function. Usually a COMPOUND_STMT, but in C++ this may also
+ be a RETURN_INIT, CTOR_INITIALIZER, or TRY_BLOCK. */
+#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.saved_tree)
+
+/* 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)
+ (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
/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
specially. */
#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl.bit_field_flag)
+
/* In a LABEL_DECL, nonzero means label was defined inside a binding
contour that restored a stack level and which is now exited. */
#define DECL_TOO_LATE(NODE) (LABEL_DECL_CHECK (NODE)->decl.bit_field_flag)
/* In a FUNCTION_DECL, nonzero means a built in function. */
#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
+
/* For a builtin function, identify which part of the compiler defined it. */
#define DECL_BUILT_IN_CLASS(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
+ (FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
/* Used in VAR_DECLs to indicate that the variable is a vtable.
Used in FIELD_DECLs for vtable pointers.
argument should be passed in the same way that the first union
alternative would be passed. */
#define DECL_TRANSPARENT_UNION(NODE) \
-(PARM_DECL_CHECK (NODE)->decl.transparent_union)
+ (PARM_DECL_CHECK (NODE)->decl.transparent_union)
/* Used in FUNCTION_DECLs to indicate that they should be run automatically
at the beginning or end of execution. */
#define DECL_STATIC_CONSTRUCTOR(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
#define DECL_STATIC_DESTRUCTOR(NODE) \
(FUNCTION_DECL_CHECK (NODE)->decl.static_dtor_flag)
/* Used in FUNCTION_DECLs to indicate that function entry and exit should
be instrumented with calls to support routines. */
#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
-
-/* Used in FUNCTION_DECLs to indicate that check-memory-usage should be
- disabled in this function. */
-#define DECL_NO_CHECK_MEMORY_USAGE(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_check_memory_usage)
+ (FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
disabled in this function. */
#define DECL_NO_LIMIT_STACK(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
+ (FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
/* Additional flags for language-specific uses. */
#define DECL_LANG_FLAG_0(NODE) (DECL_CHECK (NODE)->decl.lang_flag_0)
argument's depth. */
#define DECL_POINTER_DEPTH(DECL) (DECL_CHECK (DECL)->decl.pointer_depth)
+struct function;
+
struct tree_decl
{
struct tree_common common;
const char *filename;
int linenum;
unsigned int uid;
- union tree_node *size;
+ tree size;
ENUM_BITFIELD(machine_mode) mode : 8;
unsigned external_flag : 1;
unsigned non_addr_const_p : 1;
unsigned no_instrument_function_entry_exit : 1;
- unsigned no_check_memory_usage : 1;
unsigned comdat_flag : 1;
unsigned malloc_flag : 1;
unsigned no_limit_stack : 1;
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;
/* Three unused bits. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
- /* For a FUNCTION_DECL, if inline, this is the size of frame needed.
- If built-in, this is the code for which built-in function.
- For other kinds of decls, this is DECL_ALIGN and DECL_OFFSET_ALIGN. */
union {
- HOST_WIDE_INT i;
+ /* 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
+ is used by language-dependent code. */
+ HOST_WIDE_INT i;
+ /* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for
+ FUNCTION_DECLs). */
struct {unsigned int align : 24; unsigned int off_align : 8;} a;
} u1;
- union tree_node *size_unit;
- union tree_node *name;
- union tree_node *context;
- union tree_node *arguments; /* Also used for DECL_FIELD_OFFSET */
- union tree_node *result; /* Also used for DECL_BIT_FIELD_TYPE */
- union tree_node *initial; /* Also used for DECL_QUALIFIER */
- union tree_node *abstract_origin;
- union tree_node *assembler_name;
- union tree_node *section_name;
- union tree_node *machine_attributes;
- struct rtx_def *rtl; /* RTL representation for object. */
- struct rtx_def *live_range_rtl;
+ tree size_unit;
+ tree name;
+ tree context;
+ tree arguments; /* Also used for DECL_FIELD_OFFSET */
+ tree result; /* Also used for DECL_BIT_FIELD_TYPE */
+ tree initial; /* Also used for DECL_QUALIFIER */
+ tree abstract_origin;
+ tree assembler_name;
+ 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.
Used by Chill and Java in LABEL_DECL and by C++ and Java in VAR_DECL. */
union {
struct function *f;
- struct rtx_def *r;
- union tree_node *t;
+ rtx r;
+ tree t;
int i;
} u2;
- union tree_node *vindex;
+ /* In a FUNCTION_DECL, this is DECL_SAVED_TREE. */
+ tree saved_tree;
+
+ /* In a FUNCTION_DECL, these are function data which is to be kept
+ as long as FUNCTION_DECL is kept. */
+ tree inlined_fns;
+
+ tree vindex;
HOST_WIDE_INT pointer_alias_set;
/* Points to a structure whose details depend on the language in use. */
struct lang_decl *lang_specific;
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
+ TI_INTEGER_MINUS_ONE,
TI_NULL_POINTER,
TI_SIZE_ZERO,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
+ TI_VOID_LIST_NODE,
+
+ TI_UV4SF_TYPE,
+ TI_UV4SI_TYPE,
+ TI_UV8HI_TYPE,
+ TI_UV8QI_TYPE,
+ TI_UV4HI_TYPE,
+ TI_UV2SI_TYPE,
+ TI_UV2SF_TYPE,
+ TI_UV16QI_TYPE,
+
TI_V4SF_TYPE,
TI_V4SI_TYPE,
+ TI_V8HI_TYPE,
TI_V8QI_TYPE,
TI_V4HI_TYPE,
TI_V2SI_TYPE,
+ TI_V2SF_TYPE,
+ TI_V16QI_TYPE,
TI_MAIN_IDENTIFIER,
#define integer_zero_node global_trees[TI_INTEGER_ZERO]
#define integer_one_node global_trees[TI_INTEGER_ONE]
+#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
#define size_zero_node global_trees[TI_SIZE_ZERO]
#define size_one_node global_trees[TI_SIZE_ONE]
#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
+/* 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
+ no TREE_CHAIN. Language-independent code should not assume
+ anything else about this node. */
+#define void_list_node global_trees[TI_VOID_LIST_NODE]
+
#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
+#define unsigned_V16QI_type_node global_trees[TI_UV16QI_TYPE]
+#define unsigned_V4SI_type_node global_trees[TI_UV4SI_TYPE]
+#define unsigned_V8QI_type_node global_trees[TI_UV8QI_TYPE]
+#define unsigned_V8HI_type_node global_trees[TI_UV8HI_TYPE]
+#define unsigned_V4HI_type_node global_trees[TI_UV4HI_TYPE]
+#define unsigned_V2SI_type_node global_trees[TI_UV2SI_TYPE]
+
+#define V16QI_type_node global_trees[TI_V16QI_TYPE]
#define V4SF_type_node global_trees[TI_V4SF_TYPE]
#define V4SI_type_node global_trees[TI_V4SI_TYPE]
#define V8QI_type_node global_trees[TI_V8QI_TYPE]
+#define V8HI_type_node global_trees[TI_V8HI_TYPE]
#define V4HI_type_node global_trees[TI_V4HI_TYPE]
#define V2SI_type_node global_trees[TI_V2SI_TYPE]
+#define V2SF_type_node global_trees[TI_V2SF_TYPE]
/* An enumeration of the standard C integer types. These must be
ordered so that shorter types appear before longer ones. */
\f
#define NULL_TREE (tree) NULL
-/* The following functions accept a wide integer argument. Rather than
- having to cast on every function call, we use a macro instead, that is
- defined here and in rtl.h. */
+/* Approximate positive square root of a host double. This is for
+ statistical reports, not code generation. */
+extern double approx_sqrt PARAMS ((double));
-#ifndef exact_log2
-#define exact_log2(N) exact_log2_wide ((unsigned HOST_WIDE_INT) (N))
-#define floor_log2(N) floor_log2_wide ((unsigned HOST_WIDE_INT) (N))
-#endif
-extern int exact_log2_wide PARAMS ((unsigned HOST_WIDE_INT));
-extern int floor_log2_wide PARAMS ((unsigned HOST_WIDE_INT));
-
-extern char *oballoc PARAMS ((int));
extern char *permalloc PARAMS ((int));
-extern char *savealloc PARAMS ((int));
extern char *expralloc PARAMS ((int));
+/* 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));
+
/* 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 get_identifier PARAMS ((const char *));
+/* Identical to get_identifier, except that the length is assumed
+ known. */
+
+extern tree get_identifier_with_length PARAMS ((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 build PARAMS ((enum tree_code, tree, ...));
extern tree build_nt PARAMS ((enum tree_code, ...));
-extern tree build_parse_node PARAMS ((enum tree_code, ...));
extern tree build_int_2_wide PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
extern tree build_real PARAMS ((tree, REAL_VALUE_TYPE));
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_list PARAMS ((tree, tree));
-extern tree build_expr_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 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 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 ((struct rtx_def *));
+extern int rtl_expr_nonnegative_p PARAMS ((rtx));
extern int index_type_equal PARAMS ((tree, tree));
extern tree get_inner_array_type PARAMS ((tree));
put the prototype here. Rtl.h does declare the prototype if
tree.h had been included. */
-extern tree make_tree PARAMS ((tree, struct rtx_def *));
+extern tree make_tree PARAMS ((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. */
+ are not made. */
extern tree build_type_attribute_variant PARAMS ((tree, tree));
extern tree build_decl_attribute_variant PARAMS ((tree, tree));
-extern tree merge_machine_decl_attributes PARAMS ((tree, tree));
-extern tree merge_machine_type_attributes PARAMS ((tree, tree));
+/* Structure describing an attribute and a function to handle it. */
+struct attribute_spec
+{
+ /* The name of the attribute (without any leading or trailing __),
+ or NULL to mark the end of a table of attributes. */
+ const char *const name;
+ /* The minimum length of the list of arguments of the attribute. */
+ const int min_length;
+ /* The maximum length of the list of arguments of the attribute
+ (-1 for no maximum). */
+ const int max_length;
+ /* Whether this attribute requires a DECL. If it does, it will be passed
+ from types of DECLs, function return types and array element types to
+ the DECLs, function types and array types respectively; but when
+ applied to a type in any other circumstances, it will be ignored with
+ a warning. (If greater control is desired for a given attribute,
+ this should be false, and the flags argument to the handler may be
+ used to gain greater control in that case.) */
+ const bool decl_required;
+ /* Whether this attribute requires a type. If it does, it will be passed
+ from a DECL to the type of that DECL. */
+ const bool type_required;
+ /* Whether this attribute requires a function (or method) type. If it does,
+ it will be passed from a function pointer type to the target type,
+ and from a function return type (which is not itself a function
+ pointer type) to the function type. */
+ const bool function_type_required;
+ /* Function to handle this attribute. NODE points to the node to which
+ the attribute is to be applied. If a DECL, it should be modified in
+ place; if a TYPE, a copy should be created. NAME is the name of the
+ attribute (possibly with leading or trailing __). ARGS is the TREE_LIST
+ of the arguments (which may be NULL). FLAGS gives further information
+ about the context of the attribute. Afterwards, the attributes will
+ be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
+ unless *NO_ADD_ATTRS is set to true (which should be done on error,
+ as well as in any other cases when the attributes should not be added
+ to the DECL or TYPE). Depending on FLAGS, any attributes to be
+ applied to another type or DECL later may be returned;
+ 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));
+};
+
+extern const struct attribute_spec default_target_attribute_table[];
+
+/* Flags that may be passed in the third argument of decl_attributes, and
+ to handler functions for attributes. */
+enum attribute_flags
+{
+ /* The type passed in is the type of a DECL, and any attributes that
+ should be passed in again to be applied to the DECL rather than the
+ type should be returned. */
+ ATTR_FLAG_DECL_NEXT = 1,
+ /* The type passed in is a function return type, and any attributes that
+ should be passed in again to be applied to the function type rather
+ than the return type should be returned. */
+ ATTR_FLAG_FUNCTION_NEXT = 2,
+ /* The type passed in is an array element type, and any attributes that
+ should be passed in again to be applied to the array type rather
+ than the element type should be returned. */
+ ATTR_FLAG_ARRAY_NEXT = 4,
+ /* The type passed in is a structure, union or enumeration type being
+ created, and should be modified in place. */
+ ATTR_FLAG_TYPE_IN_PLACE = 8,
+ /* The attributes are being applied by default to a library function whose
+ name indicates known behavior, and should be silently ignored if they
+ are not in fact compatible with the function type. */
+ ATTR_FLAG_BUILT_IN = 16
+};
+
+/* 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));
/* Split a list of declspecs and attributes into two. */
extern tree merge_attributes PARAMS ((tree, tree));
-/* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
- the same kind of data as TYPE describes. Variants point to the
- "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT,
- and it points to a chain of other variants so that duplicate
- variants are never made. Only main variants should ever appear as
- types of expressions. */
+#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));
+#endif
+
+/* 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));
+
+/* 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));
unsigned int record_align;
/* The alignment of the record so far, not including padding, 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 static variables (i.e., class variables, as opposed to
instance variables) encountered in T. */
tree pending_statics;
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));
enum size_type_kind
{
- SIZETYPE, /* Normal representation of sizes in bytes. */
- SSIZETYPE, /* Signed representation of sizes in bytes. */
+ SIZETYPE, /* Normal representation of sizes in bytes. */
+ SSIZETYPE, /* Signed representation of sizes in bytes. */
USIZETYPE, /* Unsigned representation of sizes in bytes. */
BITSIZETYPE, /* Normal representation of sizes in bits. */
SBITSIZETYPE, /* Signed representation of sizes in bits. */
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));
/* Type for sizes of data-type. */
+ (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
+ (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
-/* If nonzero, an upper limit on alignment of structure fields, in bits. */
+/* 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 non-zero, 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
/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
extern tree tree_cons PARAMS ((tree, tree, tree));
-extern tree perm_tree_cons PARAMS ((tree, tree, tree));
-extern tree temp_tree_cons PARAMS ((tree, tree, tree));
-extern tree saveable_tree_cons PARAMS ((tree, tree, tree));
-extern tree decl_tree_cons PARAMS ((tree, tree, tree));
-extern tree expr_tree_cons PARAMS ((tree, tree, tree));
/* Return the last tree node in a chain. */
/* 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 PARAMS ((tree));
+
+/* If non-null, these are language-specific helper functions for
+ unsafe_for_reeval. Return negative to not handle some tree. */
+extern int (*lang_unsafe_for_reeval) PARAMS ((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.
extern tree get_inner_reference PARAMS ((tree, HOST_WIDE_INT *,
HOST_WIDE_INT *, tree *,
enum machine_mode *, int *,
- int *, unsigned int *));
+ int *));
+
+/* Return 1 if T is an expression that get_inner_reference handles. */
+
+extern int handled_component_p PARAMS ((tree));
/* Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope. */
/* Current line number in input file. */
extern int lineno;
-/* Nonzero for -pedantic switch: warn about anything
- that standard C forbids. */
-extern int pedantic;
-
/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
Zero means allow extended lvalues. */
extern int immediate_size_expand;
-/* Points to the FUNCTION_DECL of the function whose body we are reading. */
+/* Points to the FUNCTION_DECL of the function whose body we are reading. */
extern tree current_function_decl;
extern void (*incomplete_decl_finalize_hook) PARAMS ((tree));
-extern const char *init_parse PARAMS ((const char *));
-extern void finish_parse PARAMS ((void));
-
-extern const char * const language_string;
-
/* 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 *));
-/* Pointer to function to check the format of printf, etc. This is
- used by the backend, e.g. builtins.c. */
-extern void (*check_function_format_ptr) PARAMS ((int *, tree, tree, tree));
\f
/* In tree.c */
extern char *perm_calloc PARAMS ((int, long));
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));
\f
/* In stmt.c */
extern int in_control_zone_p PARAMS ((void));
-extern void expand_fixups PARAMS ((struct rtx_def *));
+extern void expand_fixups PARAMS ((rtx));
extern tree expand_start_stmt_expr PARAMS ((void));
extern tree expand_end_stmt_expr PARAMS ((tree));
extern void expand_expr_stmt PARAMS ((tree));
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_something PARAMS ((void));
-extern void expand_null_return PARAMS ((void));
extern void expand_return PARAMS ((tree));
-extern int optimize_tail_recursion PARAMS ((tree, struct rtx_def *));
+extern int optimize_tail_recursion PARAMS ((tree, rtx));
extern void expand_start_bindings_and_block PARAMS ((int, tree));
#define expand_start_bindings(flags) \
expand_start_bindings_and_block(flags, NULL_TREE)
extern void end_cleanup_deferral PARAMS ((void));
extern int is_body_block PARAMS ((tree));
-extern void mark_block_as_eh_region PARAMS ((void));
-extern void mark_block_as_not_eh_region PARAMS ((void));
-extern int is_eh_region PARAMS ((void));
extern int conditional_context PARAMS ((void));
+extern struct nesting * current_nesting_level PARAMS ((void));
extern tree last_cleanup_this_contour PARAMS ((void));
-extern int expand_dhc_cleanup PARAMS ((tree));
-extern int expand_dcc_cleanup PARAMS ((tree));
extern void expand_start_case PARAMS ((int, tree, tree,
const char *));
extern void expand_end_case PARAMS ((tree));
change. Required by any language that supports variadic arguments. */
extern tree (*lang_type_promotes_to) PARAMS ((tree));
+extern tree fold_builtin PARAMS ((tree));
\f
/* The language front-end must define these functions. */
-/* Function of no arguments for initializing options. */
-extern void lang_init_options PARAMS ((void));
-
-/* Function of no arguments for initializing lexical scanning. */
-extern void init_lex PARAMS ((void));
-/* Function of no arguments for initializing the symbol table. */
-extern void init_decl_processing PARAMS ((void));
-
-/* Functions called with no arguments at the beginning and end or processing
- the input source file. */
-extern void lang_init PARAMS ((void));
-extern void lang_finish PARAMS ((void));
-
-/* Function to identify which front-end produced the output file. */
-extern const char *lang_identify PARAMS ((void));
-
-/* Called by report_error_function to print out function name.
- * Default may be overridden by language front-ends. */
-extern void (*print_error_function) PARAMS ((const char *));
-
/* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */
extern void copy_lang_decl PARAMS ((tree));
/* Function called with no arguments to parse and compile the input. */
extern int yyparse PARAMS ((void));
-/* Function called with option as argument
- to decode options starting with -f or -W or +.
- It should return nonzero if it handles the option. */
-extern int lang_decode_option PARAMS ((int, char **));
-
/* Functions for processing symbol declarations. */
/* Function to enter a new lexical scope.
Takes one argument: always zero when called from outside the front end. */
extern tree build_range_type PARAMS ((tree, tree, tree));
-/* Call when starting to parse a declaration:
- make expressions in the declaration last the length of the function.
- Returns an argument that should be passed to resume_momentary later. */
-extern int suspend_momentary PARAMS ((void));
-
-extern int allocation_temporary_p PARAMS ((void));
-
-/* Call when finished parsing a declaration:
- restore the treatment of node-allocation that was
- in effect before the suspension.
- YES should be the value previously returned by suspend_momentary. */
-extern void resume_momentary PARAMS ((int));
-
-/* Called after finishing a record, union or enumeral type. */
-extern void rest_of_type_compilation PARAMS ((tree, int));
-
-/* Save the current set of obstacks, but don't change them. */
-extern void push_obstacks_nochange PARAMS ((void));
-
-extern void permanent_allocation PARAMS ((int));
-extern void push_momentary PARAMS ((void));
-extern void clear_momentary PARAMS ((void));
-extern void pop_momentary PARAMS ((void));
-extern void end_temporary_allocation PARAMS ((void));
-
-/* Pop the obstack selection stack. */
-extern void pop_obstacks PARAMS ((void));
-
/* 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));
-/* In c-common.c */
-extern HOST_WIDE_INT lang_get_alias_set PARAMS ((tree));
+/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
+ that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
+ appropriate IDENTIFIER_NODE. Otherwise, set it to the
+ ERROR_MARK_NODE to ensure that the assembler does not talk about
+ it. */
+extern void (*lang_set_decl_assembler_name) PARAMS ((tree));
+
+struct obstack;
/* In tree.c */
extern int really_constant_p PARAMS ((tree));
-extern void push_obstacks PARAMS ((struct obstack *,
- struct obstack *));
-extern void pop_momentary_nofree PARAMS ((void));
-extern void preserve_momentary PARAMS ((void));
-extern void saveable_allocation PARAMS ((void));
-extern void temporary_allocation PARAMS ((void));
-extern void resume_temporary_allocation PARAMS ((void));
-extern void set_identifier_size PARAMS ((int));
extern int int_fits_type_p PARAMS ((tree, tree));
extern int tree_log2 PARAMS ((tree));
extern int tree_floor_log2 PARAMS ((tree));
-extern void preserve_initializer PARAMS ((void));
extern void preserve_data PARAMS ((void));
extern int object_permanent_p PARAMS ((tree));
extern int type_precision PARAMS ((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 debug_obstack PARAMS ((char *));
-extern void rtl_in_current_obstack PARAMS ((void));
-extern void rtl_in_saveable_obstack PARAMS ((void));
-extern void init_tree_codes PARAMS ((void));
extern void dump_tree_statistics PARAMS ((void));
extern void print_obstack_statistics PARAMS ((const char *,
struct obstack *));
#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 void start_identifier_warnings PARAMS ((void));
extern void gcc_obstack_init PARAMS ((struct obstack *));
extern void init_obstacks PARAMS ((void));
-extern void obfree PARAMS ((char *));
extern void build_common_tree_nodes PARAMS ((int));
extern void build_common_tree_nodes_2 PARAMS ((int));
+extern void mark_tree_hashtable PARAMS ((void *));
/* In function.c */
extern void setjmp_protect_args 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 ((struct rtx_def *));
+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, struct rtx_def *));
-extern void unshare_all_rtl PARAMS ((tree, struct rtx_def *));
+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 ggc_mark_struct_function PARAMS ((struct function *));
/* In print-rtl.c */
#ifdef BUFSIZ
-extern void print_rtl PARAMS ((FILE *, struct rtx_def *));
+extern void print_rtl PARAMS ((FILE *, rtx));
#endif
/* In print-tree.c */
#endif
/* In expr.c */
-extern void emit_queue PARAMS ((void));
extern int apply_args_register_offset PARAMS ((int));
-extern struct rtx_def *expand_builtin_return_addr
- PARAMS ((enum built_in_function, int, struct rtx_def *));
-extern void do_pending_stack_adjust PARAMS ((void));
-extern struct rtx_def *expand_assignment PARAMS ((tree, tree, int,
- int));
-extern struct rtx_def *store_expr PARAMS ((tree,
- struct rtx_def *,
- int));
+extern rtx expand_builtin_return_addr
+ PARAMS ((enum built_in_function, int, rtx));
extern void check_max_integer_computation_mode PARAMS ((tree));
/* In emit-rtl.c */
extern void start_sequence_for_rtl_expr PARAMS ((tree));
-extern struct rtx_def *emit_line_note_after PARAMS ((const char *, int,
- struct rtx_def *));
-extern struct rtx_def *emit_line_note PARAMS ((const char *, int));
-extern struct rtx_def *emit_line_note_force PARAMS ((const char *, int));
+extern rtx emit_line_note PARAMS ((const char *, int));
/* In calls.c */
extern int setjmp_call_p PARAMS ((tree));
+/* In attribs.c. */
+
+/* Process the attributes listed in ATTRIBUTES and install them in *NODE,
+ which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL,
+ it should be modified in place; if a TYPE, a copy should be created
+ unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further
+ information, in the form of a bitwise OR of flags in enum attribute_flags
+ 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));
+
+/* The following function must be provided by front ends
+ using attribs.c. */
+
+/* Possibly apply default attributes to a function (represented by
+ a FUNCTION_DECL). */
+extern void insert_default_attributes PARAMS ((tree));
+
+/* Table of machine-independent attributes for checking formats, if used. */
+extern const struct attribute_spec *format_attribute_table;
+
+/* Table of machine-independent attributes for a particular language. */
+extern const struct attribute_spec *lang_attribute_table;
+
+/* Flag saying whether common language attributes are to be supported. */
+extern int lang_attribute_common;
+
/* In front end. */
extern int mark_addressable PARAMS ((tree));
extern void incomplete_type_error PARAMS ((tree, tree));
-extern void print_lang_statistics PARAMS ((void));
extern tree truthvalue_conversion PARAMS ((tree));
-extern void split_specs_attrs PARAMS ((tree, tree *, tree *));
-#ifdef BUFSIZ
-extern void print_lang_decl PARAMS ((FILE *, tree, int));
-extern void print_lang_type PARAMS ((FILE *, tree, int));
-extern void print_lang_identifier PARAMS ((FILE *, tree, int));
-#endif
extern int global_bindings_p PARAMS ((void));
extern void insert_block PARAMS ((tree));
extern void output_inline_function PARAMS ((tree));
extern void set_decl_origin_self PARAMS ((tree));
-/* In front end. */
-extern void set_yydebug PARAMS ((int));
-
/* In stor-layout.c */
extern void fixup_signed_type PARAMS ((tree));
+extern void internal_reference_types PARAMS ((void));
/* varasm.c */
-extern void make_decl_rtl PARAMS ((tree, const char *, int));
+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 stmt.c */
extern void emit_nop PARAMS ((void));
extern void expand_computed_goto PARAMS ((tree));
-extern struct rtx_def *label_rtx 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 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));
-#ifdef BUFSIZ
-extern void lang_print_xnode PARAMS ((FILE *, tree, int));
-#endif
-
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
\f
/* Interface of the DWARF2 unwind info support. */
-/* Decide whether we want to emit frame unwind information for the current
- translation unit. */
-
-extern int dwarf2out_do_frame PARAMS ((void));
-
/* Generate a new label for the CFI info to refer to. */
extern char *dwarf2out_cfi_label PARAMS ((void));
extern void dwarf2out_return_reg PARAMS ((const char *, unsigned));
-/* Output a marker (i.e. a label) for the beginning of a function, before
- the prologue. */
+/* The type of a function that walks over tree structure. */
+
+typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *));
+
+/* In tree-dump.c */
+
+/* Different tree dump places. When you add new tree dump places,
+ extend the DUMP_FILES array in tree-dump.c */
+enum tree_dump_index
+{
+ TDI_all, /* dump the whole translation unit */
+ TDI_class, /* dump class hierarchy */
+ TDI_original, /* dump each function before optimizing it */
+ TDI_optimized, /* dump each function after optimizing it */
+ TDI_inlined, /* dump each function after inlining
+ within it. */
+ TDI_end
+};
+
+/* Bit masks to control tree dumping. Not all values are applicable to
+ all tree dumps. Add new ones at the end. When you define new
+ values, extend the DUMP_OPTIONS array in tree-dump.c */
+#define TDF_ADDRESS (1 << 0) /* dump node addresses */
+#define TDF_SLIM (1 << 1) /* don't go wild following links */
-extern void dwarf2out_begin_prologue PARAMS ((void));
+typedef struct dump_info *dump_info_p;
-/* Output a marker (i.e. a label) for the absolute end of the generated
- code for a function definition. */
+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 void dwarf2out_end_epilogue PARAMS ((void));
\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic