extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])
+/* Macros for initializing `tree_contains_struct'. */
+#define MARK_TS_BASE(C) \
+ do { \
+ tree_contains_struct[C][TS_BASE] = 1; \
+ } while (0)
+
+#define MARK_TS_TYPED(C) \
+ do { \
+ MARK_TS_BASE (C); \
+ tree_contains_struct[C][TS_TYPED] = 1; \
+ } while (0)
+
+#define MARK_TS_COMMON(C) \
+ do { \
+ MARK_TS_TYPED (C); \
+ tree_contains_struct[C][TS_COMMON] = 1; \
+ } while (0)
+
+#define MARK_TS_DECL_MINIMAL(C) \
+ do { \
+ MARK_TS_COMMON (C); \
+ tree_contains_struct[C][TS_DECL_MINIMAL] = 1; \
+ } while (0)
+
+#define MARK_TS_DECL_COMMON(C) \
+ do { \
+ MARK_TS_DECL_MINIMAL (C); \
+ tree_contains_struct[C][TS_DECL_COMMON] = 1; \
+ } while (0)
+
+#define MARK_TS_DECL_WRTL(C) \
+ do { \
+ MARK_TS_DECL_COMMON (C); \
+ tree_contains_struct[C][TS_DECL_WRTL] = 1; \
+ } while (0)
+
+#define MARK_TS_DECL_WITH_VIS(C) \
+ do { \
+ MARK_TS_DECL_WRTL (C); \
+ tree_contains_struct[C][TS_DECL_WITH_VIS] = 1; \
+ } while (0)
+
+#define MARK_TS_DECL_NON_COMMON(C) \
+ do { \
+ MARK_TS_DECL_WITH_VIS (C); \
+ tree_contains_struct[C][TS_DECL_NON_COMMON] = 1; \
+ } while (0)
+
/* Number of language-independent tree codes. */
#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
unsigned address_space : 8;
};
-struct GTY(()) tree_common {
+struct GTY(()) tree_typed {
struct tree_base base;
- tree chain;
tree type;
};
+struct GTY(()) tree_common {
+ struct tree_typed typed;
+ tree chain;
+};
+
/* The following table lists the uses of each of the above flags and
for which types of nodes they are defined.
all decls
CALL_FROM_THUNK_P and
- ALLOCA_FOR_VAR_P in
+ CALL_ALLOCA_FOR_VAR_P in
CALL_EXPR
side_effects_flag:
are chained together. */
#define TREE_CHAIN(NODE) __extension__ \
-(*({__typeof (NODE) const __t = (NODE); \
+(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_COMMON);\
&__t->common.chain; }))
/* In all nodes that are expressions, this is the data type of the expression.
In ARRAY_TYPE nodes, this is the type of the elements.
In VECTOR_TYPE nodes, this is the type of the elements. */
#define TREE_TYPE(NODE) __extension__ \
-(*({__typeof (NODE) const __t = (NODE); \
- &__t->common.type; }))
+(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_TYPED); \
+ &__t->typed.type; }))
extern void tree_contains_struct_check_failed (const_tree,
const enum tree_node_structure_enum,
#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T)
#define TREE_CHAIN(NODE) ((NODE)->common.chain)
-#define TREE_TYPE(NODE) ((NODE)->common.type)
+#define TREE_TYPE(NODE) ((NODE)->typed.type)
#endif
/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
of this is needed. So it cannot be in a register.
- In a FUNCTION_DECL, nonzero means its address is needed.
- So it must be compiled even if it is an inline function.
+ In a FUNCTION_DECL it has no meaning.
In CONSTRUCTOR nodes, it means object constructed must be in memory.
In LABEL_DECL nodes, it means a goto for this label has been seen
from a place outside all binding contours that restore stack levels.
/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
it has been built for the declaration of a variable-sized object. */
-#define ALLOCA_FOR_VAR_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
+#define CALL_ALLOCA_FOR_VAR_P(NODE) \
+ (CALL_EXPR_CHECK (NODE)->base.protected_flag)
/* In a type, nonzero means that all objects of the type are guaranteed by the
language or front-end to be properly aligned, so we can indicate that a MEM
&& TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
struct GTY(()) tree_int_cst {
- struct tree_common common;
+ struct tree_typed typed;
double_int int_cst;
};
#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
struct GTY(()) tree_real_cst {
- struct tree_common common;
+ struct tree_typed typed;
struct real_value * real_cst_ptr;
};
#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
struct GTY(()) tree_fixed_cst {
- struct tree_common common;
+ struct tree_typed typed;
struct fixed_value * fixed_cst_ptr;
};
((const char *)(STRING_CST_CHECK (NODE)->string.str))
struct GTY(()) tree_string {
- struct tree_common common;
+ struct tree_typed typed;
int length;
char str[1];
};
#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
struct GTY(()) tree_complex {
- struct tree_common common;
+ struct tree_typed typed;
tree real;
tree imag;
};
#define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
struct GTY(()) tree_vector {
- struct tree_common common;
+ struct tree_typed typed;
tree elements;
};
\f
DEF_VEC_ALLOC_O(constructor_elt,gc);
struct GTY(()) tree_constructor {
- struct tree_common common;
+ struct tree_typed typed;
VEC(constructor_elt,gc) *elts;
};
#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
+#define CASE_CHAIN(NODE) TREE_CHAIN (CASE_LABEL_EXPR_CHECK (NODE))
/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match
corresponding MEM_REF operands. */
#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
struct GTY(()) tree_ssa_name {
- struct tree_common common;
+ struct tree_typed typed;
/* _DECL wrapped by this SSA name. */
tree var;
#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
-#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
-#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
-#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
#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)
/* 1 if the alignment for this type was requested by "aligned" attribute,
0 if it is the default for this type. */
-#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->common.base.user_align)
+#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->base.user_align)
/* The alignment for NODE, in bytes. */
#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
/* There is a TYPE_QUAL value for each type qualifier. They can be
combined by bitwise-or to form the complete set of qualifiers for a
type. */
-
-#define TYPE_UNQUALIFIED 0x0
-#define TYPE_QUAL_CONST 0x1
-#define TYPE_QUAL_VOLATILE 0x2
-#define TYPE_QUAL_RESTRICT 0x4
+enum cv_qualifier
+ {
+ TYPE_UNQUALIFIED = 0x0,
+ TYPE_QUAL_CONST = 0x1,
+ TYPE_QUAL_VOLATILE = 0x2,
+ TYPE_QUAL_RESTRICT = 0x4
+ };
/* Encode/decode the named memory support as part of the qualifier. If more
than 8 qualifiers are added, these macros need to be adjusted. */
/* Indicated that objects of this type should be laid out in as
compact a way as possible. */
-#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->common.base.packed_flag)
+#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->base.packed_flag)
/* Used by type_contains_placeholder_p to avoid recomputation.
Values are: 0 (unknown), 1 (false), 2 (true). Never access
#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
(TYPE_CHECK (NODE)->type.contains_placeholder_bits)
+/* The debug output functions use the symtab union field to store
+ information specific to the debugging format. The different debug
+ output hooks store different types in the union field. These three
+ macros are used to access different fields in the union. The debug
+ hooks are responsible for consistently using only a specific
+ macro. */
+
+/* Symtab field as an integer. Used by stabs generator in dbxout.c to
+ hold the type's number in the generated stabs. */
+#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
+
+/* Symtab field as a string. Used by COFF generator in sdbout.c to
+ hold struct/union type tag names. */
+#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
+
+/* Symtab field as a pointer to a DWARF DIE. Used by DWARF generator
+ in dwarf2out.c to point to the DIE generated for the type. */
+#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
+
+/* The garbage collector needs to know the interpretation of the
+ symtab field. These constants represent the different types in the
+ union. */
+
+#define TYPE_SYMTAB_IS_ADDRESS (0)
+#define TYPE_SYMTAB_IS_POINTER (1)
+#define TYPE_SYMTAB_IS_DIE (2)
+
struct die_struct;
struct GTY(()) tree_type {
tree pointer_to;
tree reference_to;
union tree_type_symtab {
- int GTY ((tag ("0"))) address;
- const char * GTY ((tag ("1"))) pointer;
- struct die_struct * GTY ((tag ("2"))) die;
- } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"))) symtab;
+ int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
+ const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer;
+ struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
+ } GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab;
tree name;
tree minval;
tree maxval;
/* Set if the alignment of this DECL has been set by the user, for
example with an 'aligned' attribute. */
#define DECL_USER_ALIGN(NODE) \
- (DECL_COMMON_CHECK (NODE)->common.base.user_align)
+ (DECL_COMMON_CHECK (NODE)->base.user_align)
/* Holds the machine mode corresponding to the declaration of a variable or
field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
FIELD_DECL. */
In TYPE_DECL, this is TYPE_DECL_SUPPRESS_DEBUG. */
unsigned decl_flag_1 : 1;
/* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
- In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR_P. */
+ In VAR_DECL, PARM_DECL and RESULT_DECL, this is
+ DECL_HAS_VALUE_EXPR_P. */
unsigned decl_flag_2 : 1;
/* Logically, these two would go in a theoretical base shared by var and
parm decl. */
decl itself. This should only be used for debugging; once this field has
been set, the decl itself may not legitimately appear in the function. */
#define DECL_HAS_VALUE_EXPR_P(NODE) \
- (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_2)
+ (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \
+ ->decl_common.decl_flag_2)
#define DECL_VALUE_EXPR(NODE) \
(decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
#define SET_DECL_VALUE_EXPR(NODE, VAL) \
#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
/* In a FIELD_DECL, indicates this field should be bit-packed. */
-#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->common.base.packed_flag)
+#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->base.packed_flag)
/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
specially. */
};
struct GTY(()) tree_const_decl {
- struct tree_decl_with_rtl common;
+ struct tree_decl_common common;
};
/* For a PARM_DECL, records the data type used to pass the argument,
#define DECL_HAS_INIT_PRIORITY_P(NODE) \
(VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
+/* Specify whether the section name was set by user or by
+ compiler via -ffunction-sections. */
+#define DECL_HAS_IMPLICIT_SECTION_NAME_P(NODE) \
+ (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.implicit_section_name_p)
+
struct GTY(()) tree_decl_with_vis {
struct tree_decl_with_rtl common;
tree assembler_name;
unsigned init_priority_p : 1;
/* Used by C++ only. Might become a generic decl flag. */
unsigned shadowed_for_var_p : 1;
- /* 14 unused bits. */
+ /* When SECTION_NAME is implied by -ffunsection-section. */
+ unsigned implicit_section_name_p : 1;
+ /* 13 unused bits. */
};
extern tree decl_debug_expr_lookup (tree);
tree arguments;
/* Almost all FE's use this. */
tree result;
- /* C++ uses this in namespaces. */
+ /* C++ uses this in namespaces and function_decls. */
tree vindex;
};
union GTY ((ptr_alias (union lang_tree_node),
desc ("tree_node_structure (&%h)"), variable_size)) tree_node {
struct tree_base GTY ((tag ("TS_BASE"))) base;
+ struct tree_typed GTY ((tag ("TS_TYPED"))) typed;
struct tree_common GTY ((tag ("TS_COMMON"))) common;
struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
length. */
extern size_t tree_code_size (enum tree_code);
+/* Allocate and return a new UID from the DECL_UID namespace. */
+extern int allocate_decl_uid (void);
+
/* 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 copy_list (tree);
+/* Make a CASE_LABEL_EXPR. */
+
+extern tree build_case_label (tree, tree, tree);
+
/* Make a BINFO. */
extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL);
#define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO)
#define build6(c,t1,t2,t3,t4,t5,t6,t7) \
build6_stat (c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
+/* _loc versions of build[1-6]. */
+
+static inline tree
+build1_stat_loc (location_t loc, enum tree_code code, tree type,
+ tree arg1 MEM_STAT_DECL)
+{
+ tree t = build1_stat (code, type, arg1 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build1_loc(l,c,t1,t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)
+
+static inline tree
+build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+ tree arg1 MEM_STAT_DECL)
+{
+ tree t = build2_stat (code, type, arg0, arg1 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build2_loc(l,c,t1,t2,t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)
+
+static inline tree
+build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+ tree arg1, tree arg2 MEM_STAT_DECL)
+{
+ tree t = build3_stat (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build3_loc(l,c,t1,t2,t3,t4) \
+ build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)
+
+static inline tree
+build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+ tree arg1, tree arg2, tree arg3 MEM_STAT_DECL)
+{
+ tree t = build4_stat (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build4_loc(l,c,t1,t2,t3,t4,t5) \
+ build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
+
+static inline tree
+build5_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+ tree arg1, tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
+{
+ tree t = build5_stat (code, type, arg0, arg1, arg2, arg3,
+ arg4 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build5_loc(l,c,t1,t2,t3,t4,t5,t6) \
+ build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
+
+static inline tree
+build6_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+ tree arg1, tree arg2, tree arg3, tree arg4,
+ tree arg5 MEM_STAT_DECL)
+{
+ tree t = build6_stat (code, type, arg0, arg1, arg2, arg3, arg4,
+ arg5 PASS_MEM_STAT);
+ if (CAN_HAVE_LOCATION_P (t))
+ SET_EXPR_LOCATION (t, loc);
+ return t;
+}
+#define build6_loc(l,c,t1,t2,t3,t4,t5,t6,t7) \
+ build6_stat_loc (l,c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
+
extern tree build_var_debug_value_stat (tree, tree MEM_STAT_DECL);
#define build_var_debug_value(t1,t2) \
build_var_debug_value_stat (t1,t2 MEM_STAT_INFO)
extern tree build_index_type (tree);
extern tree build_array_type (tree, tree);
extern tree build_nonshared_array_type (tree, tree);
+extern tree build_array_type_nelts (tree, unsigned HOST_WIDE_INT);
extern tree build_function_type (tree, tree);
extern tree build_function_type_list (tree, ...);
extern tree build_function_type_skip_args (tree, bitmap);
extern tree build_function_decl_skip_args (tree, bitmap);
extern tree build_varargs_function_type_list (tree, ...);
+extern tree build_function_type_array (tree, int, tree *);
+extern tree build_varargs_function_type_array (tree, int, tree *);
+#define build_function_type_vec(RET, V) \
+ build_function_type_array (RET, VEC_length (tree, V), VEC_address (tree, V))
+#define build_varargs_function_type_vec(RET, V) \
+ build_varargs_function_type_array (RET, VEC_length (tree, V), \
+ VEC_address (tree, V))
extern tree build_method_type_directly (tree, tree, tree);
extern tree build_method_type (tree, tree);
extern tree build_offset_type (tree, tree);
extern tree build_decl_attribute_variant (tree, tree);
extern tree build_type_attribute_qual_variant (tree, tree, int);
+/* Return 0 if the attributes for two types are incompatible, 1 if they
+ are compatible, and 2 if they are nearly compatible (which causes a
+ warning to be generated). */
+extern int comp_type_attributes (const_tree, const_tree);
+
/* Structure describing an attribute and a function to handle it. */
struct attribute_spec
{
by the rest of this structure. */
tree (*const handler) (tree *node, tree name, tree args,
int flags, bool *no_add_attrs);
+ /* Specifies if attribute affects type's identity. */
+ const bool affects_type_identity;
};
/* Flags that may be passed in the third argument of decl_attributes, and
extern tree round_up_loc (location_t, tree, int);
#define round_down(T,N) round_down_loc (UNKNOWN_LOCATION, T, N)
extern tree round_down_loc (location_t, tree, int);
-extern VEC(tree,gc) *get_pending_sizes (void);
-extern void put_pending_size (tree);
-extern void put_pending_sizes (VEC(tree,gc) *);
extern void finalize_size_functions (void);
/* Type for sizes of data-type. */
/* If nonzero, an upper limit on alignment of structure fields, in bits, */
extern unsigned int maximum_field_alignment;
-/* and its original value in bytes, specified via -fpack-struct=<value>. */
-extern unsigned int initial_max_fld_align;
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
by making the last node in X point to Y.
\f
/* In tree.c */
extern unsigned crc32_string (unsigned, const char *);
+extern unsigned crc32_byte (unsigned, char);
extern void clean_symbol_name (char *);
extern tree get_file_function_name (const char *);
extern tree get_callee_fndecl (const_tree);
extern tree tree_strip_sign_nop_conversions (tree);
extern tree lhd_gcc_personality (void);
extern void assign_assembler_name_if_neeeded (tree);
+extern void warn_deprecated_use (tree, tree);
\f
/* In cgraph.c */
enum operand_equal_flag
{
OEP_ONLY_CONST = 1,
- OEP_PURE_SAME = 2
+ OEP_PURE_SAME = 2,
+ OEP_CONSTANT_ADDRESS_OF = 4
};
extern int operand_equal_p (const_tree, const_tree, unsigned int);
extern tree fold_unary_to_constant (enum tree_code, tree, tree);
extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
extern tree fold_read_from_constant_string (tree);
-extern tree int_const_binop (enum tree_code, const_tree, const_tree, int);
+extern tree int_const_binop (enum tree_code, const_tree, const_tree);
#define build_fold_addr_expr(T)\
build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T))
extern tree build_fold_addr_expr_loc (location_t, tree);
build_simple_mem_ref_loc (UNKNOWN_LOCATION, T)
extern double_int mem_ref_offset (const_tree);
extern tree reference_alias_ptr_type (const_tree);
+extern tree build_invariant_address (tree, tree, HOST_WIDE_INT);
extern tree constant_boolean_node (int, tree);
extern tree div_if_zero_remainder (enum tree_code, const_tree, const_tree);
extern unsigned int get_pointer_alignment (tree, unsigned int);
extern bool is_builtin_name (const char *);
extern bool is_builtin_fn (tree);
+extern unsigned int get_object_alignment_1 (tree, unsigned HOST_WIDE_INT *);
extern unsigned int get_object_alignment (tree, unsigned int);
extern tree fold_call_stmt (gimple, bool);
extern tree gimple_fold_builtin_snprintf_chk (gimple, tree, enum built_in_function);
extern HOST_WIDE_INT int_cst_value (const_tree);
extern HOST_WIDEST_INT widest_int_cst_value (const_tree);
-extern bool fields_compatible_p (const_tree, const_tree);
-extern tree find_compatible_field (tree, tree);
-
extern tree *tree_block (tree);
extern location_t *block_nonartificial_location (tree);
extern location_t tree_nonartificial_location (tree);
/* In attribs.c. */
-extern const struct attribute_spec *lookup_attribute_spec (tree);
+extern const struct attribute_spec *lookup_attribute_spec (const_tree);
/* 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,
extern bool decl_replaceable_p (tree);
extern bool decl_binds_to_current_def_p (tree);
+/* Derived type for use by compute_visible_aliases and callers. A symbol
+ alias set is a pointer set into which we enter IDENTIFIER_NODES bearing
+ the canonicalised assembler-level symbol names corresponding to decls
+ and their aliases. */
+typedef struct pointer_set_t symbol_alias_set_t;
+
+extern void symbol_alias_set_destroy (symbol_alias_set_t *);
+extern int symbol_alias_set_contains (const symbol_alias_set_t *, tree);
+extern symbol_alias_set_t * propagate_aliases_backward (bool (*)
+ (tree, tree, void *),
+ void *);
+
/* In stmt.c */
extern void expand_computed_goto (tree);
extern bool parse_output_constraint (const char **, int, int, int,
const char * const *, bool *, bool *);
extern void expand_asm_stmt (gimple);
extern tree resolve_asm_operand_names (tree, tree, tree, tree);
+extern bool expand_switch_using_bit_tests_p (tree, tree, unsigned int,
+ unsigned int);
extern void expand_case (gimple);
extern void expand_decl (tree);
#ifdef HARD_CONST
extern tree get_base_address (tree t);
extern void mark_addressable (tree);
-/* In tree-vectorizer.c. */
-extern void vect_set_verbosity_level (const char *);
-
/* In tree.c. */
struct GTY(()) tree_map_base {
defined by this point. */
/* Structure containing iterator state. */
-typedef struct GTY (()) call_expr_arg_iterator_d {
+typedef struct call_expr_arg_iterator_d {
tree t; /* the call_expr */
int n; /* argument count */
int i; /* next argument index */
} call_expr_arg_iterator;
-typedef struct GTY (()) const_call_expr_arg_iterator_d {
+typedef struct const_call_expr_arg_iterator_d {
const_tree t; /* the call_expr */
int n; /* argument count */
int i; /* next argument index */