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"
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. */
TREE_LIST or TREE_VEC
TREE_PRIVATE in
..._DECL
+ CALL_EXPR_HAS_RETURN_SLOT_ADDR in
+ CALL_EXPR
protected_flag:
__FUNCTION__); \
__t; })
+#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]; }))
+
extern void tree_check_failed PARAMS ((const tree, enum tree_code,
const char *, int, const char *))
ATTRIBUTE_NORETURN;
extern void tree_class_check_failed PARAMS ((const tree, int,
const char *, int, const char *))
ATTRIBUTE_NORETURN;
+extern void tree_vec_elt_check_failed PARAMS ((int, int, const char *,
+ int, const char *))
+ ATTRIBUTE_NORETURN;
#else /* not ENABLE_TREE_CHECKING, or not gcc */
#define TREE_CLASS_CHECK(t, code) (t)
#define CST_OR_CONSTRUCTOR_CHECK(t) (t)
#define EXPR_CHECK(t) (t)
+#define TREE_VEC_ELT_CHECK(t, i) ((t)->vec.a[i])
#endif
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"
+ supertype is seated to a 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++?). */
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.
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
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
+ rounding up to an alignment boundary in a way that preserves the
pointer's bounds.
In an IDENTIFIER_NODE, nonzero means that the name is prefixed with
#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_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 */
/* 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 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))
struct tree_common common;
int complexity;
tree GTY ((special ("tree_exp"),
- length ("TREE_CODE_LENGTH (TREE_CODE ((tree) &%h))")))
+ desc ("TREE_CODE ((tree) &%0)")))
operands[1];
};
\f
tree pointer_to;
tree reference_to;
union tree_type_symtab {
- int address;
+ int GTY ((tag ("0"))) address;
char * GTY ((tag ("1"))) pointer;
- struct die_struct * GTY ((tag ("2"), skip (""))) die;
+ 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;
/* 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))
+#define BINFO_ELTS 6
/* 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) \
? (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)
/* 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
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_VOID_TYPE,
TI_PTR_TYPE,
TI_CONST_PTR_TYPE,
+ TI_SIZE_TYPE,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
TI_UV8HI_TYPE,
TI_UV8QI_TYPE,
TI_UV4HI_TYPE,
+ TI_UV2HI_TYPE,
TI_UV2SI_TYPE,
TI_UV2SF_TYPE,
TI_UV2DI_TYPE,
+ TI_UV1DI_TYPE,
TI_UV16QI_TYPE,
TI_V4SF_TYPE,
TI_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_MAIN_IDENTIFIER,
#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 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]
/* 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
+/* A pointer-to-function member type looks like:
+
+ struct {
+ __P __pfn;
+ ptrdiff_t __delta;
+ };
+ 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
statistical reports, not code generation. */
extern double approx_sqrt PARAMS ((double));
-extern char *permalloc PARAMS ((int));
-extern char *expralloc PARAMS ((int));
extern tree decl_assembler_name PARAMS ((tree));
/* Compute the number of bytes occupied by 'node'. This routine only
extern void initialize_sizetypes PARAMS ((void));
extern void set_sizetype PARAMS ((tree));
extern void fixup_unsigned_type PARAMS ((tree));
+extern tree build_pointer_type_for_mode PARAMS ((tree, enum machine_mode));
extern tree build_pointer_type PARAMS ((tree));
+extern tree build_reference_type_for_mode PARAMS ((tree, enum machine_mode));
extern tree build_reference_type PARAMS ((tree));
extern tree build_type_no_quals PARAMS ((tree));
extern tree build_index_type PARAMS ((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));
/* From expmed.c. Since rtl.h is included after tree.h, we can't
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 *));
/* Split a list of declspecs and attributes into two. */
extern int valid_machine_attribute PARAMS ((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 tree merge_dllimport_decl_attributes PARAMS ((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. */
/* 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) \
extern tree build_type_copy PARAMS ((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 PARAMS ((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. */
/* 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;
int packed_maybe_necessary;
} *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 *,
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 finish_record_layout PARAMS ((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.
/* 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
extern int integer_pow2p PARAMS ((tree));
+/* integer_nonzerop (tree x) is nonzero if X is an integer constant
+ with a nonzero value. */
+
+extern int integer_nonzerop PARAMS ((tree));
+
/* staticp (tree x) is nonzero if X is a reference to data allocated
at a fixed address in memory. */
extern tree unsave_expr PARAMS ((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));
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));
\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 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_asm PARAMS ((tree, int));
extern void expand_start_cond PARAMS ((tree, int));
extern void expand_end_cond PARAMS ((void));
extern void expand_start_else PARAMS ((void));
tree (*) (tree, tree),
tree, tree *));
extern void using_eh_for_cleanups PARAMS ((void));
-extern int stmt_loop_nest_empty PARAMS ((void));
/* In fold-const.c */
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));
+/* In builtins.c */
+extern tree fold_builtin PARAMS ((tree));
+extern enum built_in_function builtin_mathfn_code PARAMS ((tree));
+extern tree build_function_call_expr PARAMS ((tree, tree));
+extern tree mathfn_built_in PARAMS ((tree, enum built_in_function fn));
+extern tree strip_float_extensions PARAMS ((tree));
+
+/* In convert.c */
+extern tree strip_float_extensions PARAMS ((tree));
/* In alias.c */
extern void record_component_aliases PARAMS ((tree));
/* In tree.c */
extern int really_constant_p PARAMS ((tree));
extern int int_fits_type_p PARAMS ((tree, tree));
+extern bool variably_modified_type_p PARAMS ((tree));
extern int tree_log2 PARAMS ((tree));
extern int tree_floor_log2 PARAMS ((tree));
extern int simple_cst_equal PARAMS ((tree, 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 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 init_ttree PARAMS ((void));
extern void build_common_tree_nodes PARAMS ((int));
extern void build_common_tree_nodes_2 PARAMS ((int));
+extern tree build_range_type PARAMS ((tree, tree, tree));
/* In function.c */
extern void setjmp_protect_args PARAMS ((void));
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));
/* In calls.c */
extern int setjmp_call_p PARAMS ((tree));
+extern bool alloca_call_p PARAMS ((tree));
/* In attribs.c. */
extern void make_decl_one_only PARAMS ((tree));
extern int supports_one_only PARAMS ((void));
extern void variable_section PARAMS ((tree, int));
+enum tls_model decl_tls_model PARAMS ((tree));
+enum symbol_visibility decl_visibility PARAMS ((tree));
/* In fold-const.c */
extern int div_and_round_double PARAMS ((enum tree_code, 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 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 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));
+/* Assign the RTX to declaration. */
+
+extern void set_decl_rtl PARAMS ((tree, rtx));
+
+/* In callgraph.c */
+void cgraph_finalize_function PARAMS ((tree, tree));
+void cgraph_finalize_compilation_unit PARAMS ((void));
+void cgraph_create_edges PARAMS ((tree, tree));
+void dump_cgraph PARAMS ((FILE *));
+void cgraph_optimize PARAMS ((void));
+void cgraph_remove_call PARAMS ((tree, tree));
+bool cgraph_calls_p PARAMS ((tree, tree));
\f
/* Redefine abort to report an internal error w/o coredump, and
extern void fancy_abort PARAMS ((const char *, int, const char *))
ATTRIBUTE_NORETURN;
#define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
+
+#endif /* GCC_TREE_H */