/* Front-end tree definitions for GNU compiler.
Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
/* Number of language-independent tree codes. */
#define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
-/* Indexed by enum tree_code, contains a character which is
- `<' for a comparison expression, `1', for a unary arithmetic
- expression, `2' for a binary arithmetic expression, `e' for
- other types of expressions, `r' for a reference, `c' for a
- constant, `d' for a decl, `t' for a type, `s' for a statement,
- and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */
+/* Tree code classes. */
+
+/* Each tree_code has an associated code class represented by a
+ TREE_CODE_CLASS. */
+
+enum tree_code_class {
+ tcc_exceptional, /* An exceptional code (fits no category). */
+ tcc_constant, /* A constant. */
+ /* Order of tcc_type and tcc_declaration is important. */
+ tcc_type, /* A type object code. */
+ tcc_declaration, /* A declaration (also serving as variable refs). */
+ tcc_reference, /* A reference to storage. */
+ tcc_comparison, /* A comparison expression. */
+ tcc_unary, /* A unary arithmetic expression. */
+ tcc_binary, /* A binary arithmetic expression. */
+ tcc_statement, /* A statement expression, which have side effects
+ but usually no interesting value. */
+ tcc_expression /* Any other expression. */
+};
+
+/* Each tree code class has an associated string representation.
+ These must correspond to the tree_code_class entries. */
+
+extern const char *const tree_code_class_strings[];
+
+/* Returns the string representing CLASS. */
+
+#define TREE_CODE_CLASS_STRING(CLASS)\
+ tree_code_class_strings[(int) (CLASS)]
#define MAX_TREE_CODES 256
-extern const char tree_code_type[];
+extern const enum tree_code_class tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
+/* Nonzero if CODE represents an exceptional code. */
+
+#define EXCEPTIONAL_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
+
+/* Nonzero if CODE represents a constant. */
+
+#define CONSTANT_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
+
+/* Nonzero if CODE represents a type. */
+
+#define TYPE_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
+
+/* Nonzero if CODE represents a declaration. */
+
+#define DECL_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
+
+/* Nonzero if CODE represents a INDIRECT_REF. Keep these checks in
+ ascending code order. */
+#define INDIRECT_REF_P(CODE)\
+ (TREE_CODE (CODE) == INDIRECT_REF \
+ || TREE_CODE (CODE) == ALIGN_INDIRECT_REF \
+ || TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF)
+
+/* Nonzero if CODE represents a reference. */
+
+#define REFERENCE_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)
+
+/* Nonzero if CODE represents a comparison. */
+
+#define COMPARISON_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
+
+/* Nonzero if CODE represents a unary arithmetic expression. */
+
+#define UNARY_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
+
+/* Nonzero if CODE represents a binary arithmetic expression. */
+
+#define BINARY_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
+
+/* Nonzero if CODE represents a statement expression. */
+
+#define STATEMENT_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
+
+/* Nonzero if CODE represents any other expression. */
+
+#define EXPRESSION_CLASS_P(CODE)\
+ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
+
/* Returns nonzero iff CLASS is not the tree code of a type. */
-#define IS_NON_TYPE_CODE_CLASS(CLASS) ((CLASS) != 't')
+#define IS_NON_TYPE_CODE_CLASS(CLASS) ((CLASS) != tcc_type)
+
+/* Returns nonzero iff CODE represents a type or declaration. */
+
+#define IS_TYPE_OR_DECL_P(CODE)\
+ (TYPE_P (CODE) || DECL_P (CODE))
/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
-#define IS_EXPR_CODE_CLASS(CLASS) (strchr ("<12ers", (CLASS)) != 0)
+#define IS_EXPR_CODE_CLASS(CLASS)\
+ ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
/* Returns nonzero iff NODE is an expression of some kind. */
extern const char *const tree_code_name[];
-/* A vector of trees. */
-DEF_VEC_P(tree);
+/* A garbage collected vector of trees. */
+DEF_VEC_GC_P(tree);
\f
/* Classify which part of the compiler has defined a given builtin function.
all expressions
all decls
all constants
+ TYPE_SIZES_GIMPLIFIED
+ ..._TYPE
unsigned_flag:
..._TYPE
TREE_THIS_NOTRAP in
- INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
+ (ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
deprecated_flag:
nowarning_flag:
TREE_NO_WARNING in
- ... any expr node
+ ... any expr or decl node
*/
/* Define accessors for the fields that all tree nodes have
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_EXPR_CODE_CLASS (__c)) \
- tree_class_check_failed (__t, 'E', __FILE__, __LINE__, \
+ tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_NON_TYPE_CODE_CLASS (__c)) \
- tree_class_check_failed (__t, 'T', __FILE__, __LINE__, \
+ tree_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
...) ATTRIBUTE_NORETURN;
extern void tree_not_check_failed (const tree, const char *, int, const char *,
...) ATTRIBUTE_NORETURN;
-extern void tree_class_check_failed (const tree, int,
+extern void tree_class_check_failed (const tree, const enum tree_code_class,
const char *, int, const char *)
ATTRIBUTE_NORETURN;
extern void tree_vec_elt_check_failed (int, int, const char *,
#include "tree-check.h"
-#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, 't')
-#define DECL_CHECK(T) TREE_CLASS_CHECK (T, 'd')
-#define CST_CHECK(T) TREE_CLASS_CHECK (T, 'c')
-#define STMT_CHECK(T) TREE_CLASS_CHECK (T, 's')
+#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
+#define DECL_CHECK(T) TREE_CLASS_CHECK (T, tcc_declaration)
+#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
+#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
-#define SET_OR_ARRAY_CHECK(T) \
- TREE_CHECK2 (T, ARRAY_TYPE, SET_TYPE)
-
#define RECORD_OR_UNION_CHECK(T) \
TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
#define NOT_RECORD_OR_UNION_CHECK(T) \
EXP = TREE_OPERAND (EXP, 0)
/* Nonzero if TYPE represents an integral type. Note that we do not
- include COMPLEX types here. */
+ include COMPLEX types here. Keep these checks in ascending code
+ order. */
#define INTEGRAL_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE \
- || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE)
+ (TREE_CODE (TYPE) == ENUMERAL_TYPE \
+ || TREE_CODE (TYPE) == BOOLEAN_TYPE \
+ || TREE_CODE (TYPE) == CHAR_TYPE \
+ || TREE_CODE (TYPE) == INTEGER_TYPE)
/* Nonzero if TYPE represents a scalar floating-point type. */
&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
/* Nonzero if TYPE represents a floating-point type, including complex
- and vector floating-point types. */
+ and vector floating-point types. The vector and complex check does
+ not use the previous two macros to enable early folding. */
-#define FLOAT_TYPE_P(TYPE) \
- (SCALAR_FLOAT_TYPE_P (TYPE) || COMPLEX_FLOAT_TYPE_P (TYPE) \
- || VECTOR_FLOAT_TYPE_P (TYPE))
+#define FLOAT_TYPE_P(TYPE) \
+ (SCALAR_FLOAT_TYPE_P (TYPE) \
+ || ((TREE_CODE (TYPE) == COMPLEX_TYPE \
+ || TREE_CODE (TYPE) == VECTOR_TYPE) \
+ && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
-/* Nonzero if TYPE represents an aggregate (multi-component) type. */
+/* Nonzero if TYPE represents an aggregate (multi-component) type.
+ Keep these checks in ascending code order. */
#define AGGREGATE_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
- || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
- || TREE_CODE (TYPE) == SET_TYPE)
+ || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
/* Nonzero if TYPE represents a pointer or reference type.
- (It should be renamed to INDIRECT_TYPE_P.) */
+ (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
+ ascending code order. */
#define POINTER_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
(COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
-/* Nonzero if TYPE represents a type. */
-
-#define TYPE_P(TYPE) (TREE_CODE_CLASS (TREE_CODE (TYPE)) == 't')
\f
/* Define many boolean fields that all tree nodes have. */
had its address taken. That matters for inline functions. */
#define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)
+/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
+ exit of a function. Calls for which this is true are candidates for tail
+ call optimizations. */
#define CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK(NODE)->common.addressable_flag)
/* In a VAR_DECL, nonzero means allocate static storage.
#define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)
/* In an expr node (usually a conversion) this means the node was made
- implicitly and should not lead to any sort of warning. */
+ implicitly and should not lead to any sort of warning. In a decl node,
+ warnings concerning the decl should be suppressed. This is used at
+ least for used-before-set warnings, and it set after one warning is
+ emitted. */
#define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_flag)
/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
/* Nonzero means this node will not trap. In an INDIRECT_REF, means
accessing the memory pointed to won't generate a trap. However,
this only applies to an object when used appropriately: it doesn't
- mean that writing a READONLY mem won't trap.
+ mean that writing a READONLY mem won't trap. Similarly for
+ ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
(or slice of the array) always belongs to the range of the array.
#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)
/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
-#define TREE_READONLY_DECL_P(NODE) (DECL_P (NODE) && TREE_READONLY (NODE))
+#define TREE_READONLY_DECL_P(NODE)\
+ (DECL_P (NODE) && TREE_READONLY (NODE))
/* Value of expression is constant. Always on in all ..._CST nodes. May
also appear in an expression or decl where the value is constant. */
#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag)
+/* Nonzero if NODE, a type, has had its sizes gimplified. */
+#define TYPE_SIZES_GIMPLIFIED(NODE) (TYPE_CHECK (NODE)->common.constant_flag)
+
/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
#define DECL_UNSIGNED(NODE) (DECL_CHECK (NODE)->common.unsigned_flag)
/* Nonzero in a _DECL if the name is used in its scope.
Nonzero in an expr node means inhibit warning if value is unused.
In IDENTIFIER_NODEs, this means that some extern decl for this name
- was used. */
+ was used.
+ In a BLOCK, this means that the block contains variables that are used. */
#define TREE_USED(NODE) ((NODE)->common.used_flag)
/* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
/* In a STRING_CST */
#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
-#define TREE_STRING_POINTER(NODE) (STRING_CST_CHECK (NODE)->string.pointer)
+#define TREE_STRING_POINTER(NODE) \
+ ((const char *)(STRING_CST_CHECK (NODE)->string.str))
struct tree_string GTY(())
{
struct tree_common common;
int length;
- const char *pointer;
+ char str[1];
};
/* In a COMPLEX_CST node. */
#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
-/* In a LABELED_BLOCK_EXPR node. */
-#define LABELED_BLOCK_LABEL(NODE) \
- TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 0)
-#define LABELED_BLOCK_BODY(NODE) \
- TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 1)
-
-/* In an EXIT_BLOCK_EXPR node. */
-#define EXIT_BLOCK_LABELED_BLOCK(NODE) \
- TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 0)
-#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 1)
+/* In INDIRECT_REF, ALIGN_INDIRECT_REF, MISALIGNED_INDIRECT_REF. */
+#define REF_ORIGINAL(NODE) TREE_CHAIN (TREE_CHECK3 (NODE, \
+ INDIRECT_REF, ALIGN_INDIRECT_REF, MISALIGNED_INDIRECT_REF))
/* In a LOOP_EXPR node. */
#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
decls and constants can be shared among multiple locations, so
return nothing. */
#define EXPR_LOCATION(NODE) \
- (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
- ? (NODE)->exp.locus \
- : UNKNOWN_LOCATION)
+ (EXPR_P (NODE) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
#define SET_EXPR_LOCATION(NODE, FROM) \
(EXPR_CHECK (NODE)->exp.locus = (FROM))
#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
-/* EXPR_LOCUS and SET_EXPR_LOCUS are deprecated. */
+/* EXPR_LOCUS and SET_EXPR_LOCUS are deprecated. */
#define EXPR_LOCUS(NODE) \
- (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
- ? &(NODE)->exp.locus \
- : (location_t *)NULL)
+ (EXPR_P (NODE) ? &(NODE)->exp.locus : (location_t *)NULL)
#define SET_EXPR_LOCUS(NODE, FROM) \
do { source_location *loc_tmp = FROM; \
EXPR_CHECK (NODE)->exp.locus \
decls and constants can be shared among multiple locations, so
return nothing. */
#define EXPR_LOCUS(NODE) \
- (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \
- ? (NODE)->exp.locus \
- : (location_t *)NULL)
+ (EXPR_P (NODE) ? (NODE)->exp.locus : (location_t *)NULL)
#define SET_EXPR_LOCUS(NODE, FROM) \
(EXPR_CHECK (NODE)->exp.locus = (FROM))
#define SET_EXPR_LOCATION(NODE, FROM) annotate_with_locus (NODE, FROM)
/* SWITCH_EXPR accessors. These give access to the condition, body and
original condition type (before any compiler conversions)
of the switch statement, respectively. */
-#define SWITCH_COND(NODE) TREE_OPERAND ((NODE), 0)
-#define SWITCH_BODY(NODE) TREE_OPERAND ((NODE), 1)
-#define SWITCH_LABELS(NODE) TREE_OPERAND ((NODE), 2)
+#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
+#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
+#define SWITCH_LABELS(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)
/* CASE_LABEL_EXPR accessors. These give access to the high and low values
of a case label, respectively. */
-#define CASE_LOW(NODE) TREE_OPERAND ((NODE), 0)
-#define CASE_HIGH(NODE) TREE_OPERAND ((NODE), 1)
-#define CASE_LABEL(NODE) TREE_OPERAND ((NODE), 2)
+#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)
/* The operands of a BIND_EXPR. */
#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
statement. */
-#define ASM_STRING(NODE) TREE_OPERAND ((NODE), 0)
-#define ASM_OUTPUTS(NODE) TREE_OPERAND ((NODE), 1)
-#define ASM_INPUTS(NODE) TREE_OPERAND ((NODE), 2)
-#define ASM_CLOBBERS(NODE) TREE_OPERAND ((NODE), 3)
+#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
+#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
+#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
+#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
/* Nonzero if we want to create an ASM_INPUT instead of an
ASM_OPERAND with no operands. */
#define ASM_INPUT_P(NODE) (TREE_STATIC (NODE))
/* Pointer attributes used for alias analysis. */
struct ptr_info_def *ptr_info;
- /* Value for SSA name used by GVN. */
- tree GTY((skip)) value_handle;
+ /* Value for SSA name used by various passes.
+
+ Right now only invariants are allowed to persist beyond a pass in
+ this field; in the future we will allow VALUE_HANDLEs to persist
+ as well. */
+ tree value_handle;
/* Auxiliary information stored with the ssa name. */
PTR GTY((skip)) aux;
#define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args
#define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity
#define PHI_ARG_ELT(NODE, I) PHI_NODE_ELT_CHECK (NODE, I)
-#define PHI_ARG_EDGE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).e
+#define PHI_ARG_EDGE(NODE, I) (EDGE_PRED (PHI_BB ((NODE)), (I)))
#define PHI_ARG_NONZERO(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).nonzero
+#define PHI_BB(NODE) PHI_NODE_CHECK (NODE)->phi.bb
+#define PHI_DF(NODE) PHI_NODE_CHECK (NODE)->phi.df
struct edge_def;
struct phi_arg_d GTY(())
{
tree def;
- struct edge_def * GTY((skip (""))) e;
bool nonzero;
};
SSA renamer. */
int rewritten;
- struct phi_arg_d GTY ((length ("((tree)&%h)->phi.capacity"))) a[1];
+ /* Basic block to that the phi node belongs. */
+ struct basic_block_def *bb;
+
+ /* Dataflow information. */
+ struct dataflow_d *df;
+
+ struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
};
\f
#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
-#define TYPE_DOMAIN(NODE) (SET_OR_ARRAY_CHECK (NODE)->type.values)
+#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
#define TYPE_ORIG_SIZE_TYPE(NODE) \
#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)
/* For record and union types, information about this type, as a base type
- for itself. */
+ for itself. */
#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo)
/* For non record and union types, used in a language-dependent way. */
compact a way as possible. */
#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
+/* Used by type_contains_placeholder_p to avoid recomputation.
+ Values are: 0 (unknown), 1 (false), 2 (true). Never access
+ this field directly. */
+#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
+ (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
+
struct die_struct;
struct tree_type GTY(())
unsigned transparent_union_flag : 1;
unsigned packed_flag : 1;
unsigned restrict_flag : 1;
- unsigned spare : 2;
+ unsigned contains_placeholder_bits : 2;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
found. NULL_TREE if there is no secondary vptr in the VTT. */
#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr)
-/* The binfo of which NODE is a primary base. (This is different from
- BINFO_INHERITANCE_CHAIN for virtual base because a virtual base is
- sometimes a primary base for a class for which it is not an
- immediate base.) */
-#define BINFO_PRIMARY_BASE_OF(NODE) (TREE_BINFO_CHECK(NODE)->binfo.primary)
-
/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
inheriting this base for non-virtual bases. For virtual bases it
- points to the binfo of the most derived type. */
+ points either to the binfo for which this is a primary binfo, or to
+ the binfo of the most derived type. */
#define BINFO_INHERITANCE_CHAIN(NODE) \
(TREE_BINFO_CHECK(NODE)->binfo.inheritance)
tree vtt_subvtt;
tree vtt_vptr;
- tree primary;
VEC(tree) base_binfos;
};
\f
/* Define fields and accessors for nodes representing declared names. */
-/* Nonzero if DECL represents a decl. */
-#define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
-
/* Nonzero if DECL represents a variable for the SSA passes. */
#define SSA_VAR_P(DECL) \
(TREE_CODE (DECL) == VAR_DECL \
writing debugging information about vfield and vbase decls for C++. */
#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.vindex)
+/* For VAR_DECL, this is set to the variable we were split from, due to
+ optimization. */
+#define DECL_DEBUG_ALIAS_OF(NODE) (DECL_CHECK (NODE)->decl.vindex)
+
/* Every ..._DECL node gets a unique number. */
#define DECL_UID(NODE) (DECL_CHECK (NODE)->decl.uid)
/* In a VAR_DECL, nonzero if the decl is a register variable with
an explicit asm specification. */
-#define DECL_HARD_REGISTER(NODE) (DECL_CHECK (NODE)->decl.inline_flag)
+#define DECL_HARD_REGISTER(NODE) (VAR_DECL_CHECK (NODE)->decl.inline_flag)
/* Value of the decls's visibility attribute */
#define DECL_VISIBILITY(NODE) (DECL_CHECK (NODE)->decl.visibility)
#define DECL_VALUE_EXPR(NODE) \
(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->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 function should be treated
as if it were a malloc, meaning it returns a pointer that is
not an alias. */
#define DECL_POINTER_ALIAS_SET(NODE) \
(DECL_CHECK (NODE)->decl.pointer_alias_set)
-/* Used to store the alias_var for a DECL node. */
-#define DECL_PTA_ALIASVAR(NODE) \
- (DECL_CHECK (NODE)->decl.alias_var)
/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
dense, unique within any one function, and may be used to index arrays.
#endif
struct function;
-union alias_var_def;
struct tree_decl GTY(())
{
struct tree_common common;
/* In a FUNCTION_DECL, this is DECL_SAVED_TREE.
In a VAR_DECL or PARM_DECL, this is DECL_VALUE_EXPR. */
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;
- union alias_var_def *GTY ((skip(""))) alias_var;
/* Points to a structure whose details depend on the language in use. */
struct lang_decl *lang_specific;
};
/* Unique ID for this value handle. IDs are handed out in a
conveniently dense form starting at 0, so that we can make
- bitmaps of value handles. */
+ bitmaps of value handles. */
unsigned int id;
};
\f
extern size_t tree_size (tree);
+/* Compute the number of bytes occupied by a tree with code CODE. This
+ function cannot be used for TREE_VEC or PHI_NODE codes, which are of
+ variable length. */
+extern size_t tree_code_size (enum tree_code);
+
/* 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. */
/* Tree nodes for SSA analysis. */
-extern tree make_phi_node (tree, int);
extern void init_phinodes (void);
extern void fini_phinodes (void);
extern void release_phi_node (tree);
#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
extern tree build_int_cst (tree, HOST_WIDE_INT);
+extern tree build_int_cst_type (tree, HOST_WIDE_INT);
extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
extern tree build_vector (tree, tree);
extern tree make_signed_type (int);
extern tree make_unsigned_type (int);
+extern tree signed_type_for (tree);
+extern tree unsigned_type_for (tree);
extern void initialize_sizetypes (bool);
extern void set_sizetype (tree);
extern void fixup_unsigned_type (tree);
extern tree merge_decl_attributes (tree, tree);
extern tree merge_type_attributes (tree, tree);
-extern void default_register_cpp_builtins (struct cpp_reader *);
-
-/* Split a list of declspecs and attributes into two. */
-
-extern void split_specs_attrs (tree, tree *, tree *);
-
-/* Strip attributes from a list of combined specs and attrs. */
-
-extern tree strip_attrs (tree);
-
-/* Return 1 if an attribute and its arguments are valid for a decl or type. */
-
-extern int valid_machine_attribute (tree, tree, tree, tree);
/* Given a tree node and a string, return nonzero if the tree node is
a valid attribute name for the string. */
/* Return an expr equal to X but certainly not valid as an lvalue. */
extern tree non_lvalue (tree);
-extern tree pedantic_non_lvalue (tree);
extern tree convert (tree, tree);
extern unsigned int expr_align (tree);
#define ssizetype sizetype_tab[(int) SSIZETYPE]
#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
+extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
extern tree size_binop (enum tree_code, tree, tree);
extern tree size_diffop (tree, tree);
-extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
-extern tree size_int_type (HOST_WIDE_INT, tree);
#define size_int(L) size_int_kind (L, SIZETYPE)
#define ssize_int(L) size_int_kind (L, SSIZETYPE)
+ (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;
+/* and its original value in bytes, specified via -fpack-struct=<value>. */
+extern unsigned int initial_max_fld_align;
/* If nonzero, the alignment of a bitstring or (power-)set value, in bits. */
extern unsigned int set_alignment;
extern bool initializer_zerop (tree);
-extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
+ HOST_WIDE_INT *, bool *);
extern HOST_WIDE_INT count_type_elements (tree);
-extern int mostly_zeros_p (tree);
/* add_var_to_bind_expr (bind_expr, var) binds var to bind_expr. */
extern void add_var_to_bind_expr (tree, tree);
-/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
+/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */
extern int integer_zerop (tree);
-/* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
+/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */
extern int integer_onep (tree);
extern int integer_nonzerop (tree);
-/* staticp (tree x) is true if X is a reference to data allocated
- at a fixed address in memory. */
+extern bool zero_p (tree);
+extern bool cst_and_fits_in_hwi (tree);
-extern bool staticp (tree);
+/* staticp (tree x) is nonzero if X is a reference to data allocated
+ at a fixed address in memory. Returns the outermost data. */
+
+extern tree staticp (tree);
/* save_expr (EXP) returns an expression equivalent to EXP
but it can be used multiple times within context CTX
extern tree skip_simple_arithmetic (tree);
-/* Returns the index of the first non-tree operand for CODE, or the number
- of operands if all are trees. */
-
-extern int first_rtl_op (enum tree_code);
-
/* Return which tree structure is used by T. */
enum tree_node_structure_enum tree_node_structure (tree);
extern bool type_contains_placeholder_p (tree);
-/* Return 1 if EXP contains any expressions that produce cleanups for an
- outer scope to deal with. Used by fold. */
-
-extern int has_cleanups (tree);
-
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
return a tree with all occurrences of references to F in a
PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
and find the ultimate containing object, which is returned. */
extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
- tree *, enum machine_mode *, int *, int *);
+ tree *, enum machine_mode *, int *, int *,
+ bool);
/* Return 1 if T is an expression that get_inner_reference handles. */
extern GTY(()) tree current_function_decl;
/* Nonzero means a FUNC_BEGIN label was emitted. */
-extern GTY(()) tree current_function_func_begin_label;
+extern GTY(()) const char * current_function_func_begin_label;
\f
/* In tree.c */
extern unsigned crc32_string (unsigned, const char *);
extern int type_num_arguments (tree);
extern bool associative_tree_code (enum tree_code);
extern bool commutative_tree_code (enum tree_code);
-
+extern tree upper_bound_in_type (tree, tree);
+extern tree lower_bound_in_type (tree, tree);
+extern int operand_equal_for_phi_arg_p (tree, tree);
\f
/* In stmt.c */
extern void expand_expr_stmt (tree);
-extern void expand_expr_stmt_value (tree, int, int);
extern int warn_if_unused_value (tree, location_t);
-extern void expand_decl_init (tree);
extern void expand_label (tree);
extern void expand_goto (tree);
-extern void expand_asm (tree, int);
extern rtx expand_stack_save (void);
extern void expand_stack_restore (tree);
extern tree omit_one_operand (tree, tree, tree);
extern tree omit_two_operands (tree, tree, tree, tree);
extern tree invert_truthvalue (tree);
-extern tree nondestructive_fold_unary_to_constant (enum tree_code, tree, tree);
-extern tree nondestructive_fold_binary_to_constant (enum tree_code, tree, tree, tree);
+extern tree fold_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, tree, tree, int);
extern tree build_fold_addr_expr (tree);
+tree fold_build_cleanup_point_expr (tree type, tree expr);
extern tree build_fold_addr_expr_with_type (tree, tree);
extern tree build_fold_indirect_ref (tree);
extern tree constant_boolean_node (int, tree);
+extern tree build_low_bits_mask (tree, unsigned);
extern bool tree_swap_operands_p (tree, tree, bool);
extern enum tree_code swap_tree_comparison (enum tree_code);
+extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
+
/* In builtins.c */
extern tree fold_builtin (tree, bool);
extern tree fold_builtin_fputs (tree, bool, bool, tree);
extern tree fold_builtin_strcpy (tree, tree);
extern tree fold_builtin_strncpy (tree, tree);
+extern bool fold_builtin_next_arg (tree);
extern enum built_in_function builtin_mathfn_code (tree);
extern tree build_function_call_expr (tree, tree);
extern tree mathfn_built_in (tree, enum built_in_function fn);
extern tree strip_float_extensions (tree);
-extern tree simplify_builtin (tree, int);
extern tree c_strlen (tree, int);
extern tree std_gimplify_va_arg_expr (tree, tree, tree *, tree *);
+extern tree build_va_arg_indirect_ref (tree);
/* In convert.c */
extern tree strip_float_extensions (tree);
extern void dump_tree_statistics (void);
extern void expand_function_end (void);
extern void expand_function_start (tree);
-extern void expand_pending_sizes (tree);
extern void recompute_tree_invarant_for_addr_expr (tree);
extern bool is_global_var (tree t);
extern bool needs_to_live_in_memory (tree);
extern tree build_range_type (tree, tree, tree);
extern HOST_WIDE_INT int_cst_value (tree);
extern tree tree_fold_gcd (tree, tree);
+extern tree build_addr (tree);
extern bool fields_compatible_p (tree, tree);
extern tree find_compatible_field (tree, tree);
extern void allocate_struct_function (tree);
extern void init_function_start (tree);
extern bool use_register_for_decl (tree);
-extern void assign_parms (tree);
extern void setjmp_vars_warning (tree);
extern void setjmp_args_warning (void);
extern void init_temp_slots (void);
-extern void combine_temp_slots (void);
extern void free_temp_slots (void);
extern void pop_temp_slots (void);
extern void push_temp_slots (void);
extern void preserve_temp_slots (rtx);
-extern void preserve_rtl_expr_temps (tree);
extern int aggregate_value_p (tree, tree);
extern void push_function_context (void);
extern void pop_function_context (void);
extern void push_function_context_to (tree);
extern void pop_function_context_from (tree);
+extern tree gimplify_parameters (void);
/* In print-rtl.c */
#ifdef BUFSIZ
data structures from the inliner. */
extern tree unsave_expr_now (tree);
-/* In expr.c */
-extern rtx expand_builtin_return_addr (enum built_in_function, int, rtx);
-extern void check_max_integer_computation_mode (tree);
-
/* In emit-rtl.c */
extern rtx emit_line_note (location_t);
/* In calls.c */
-/* Nonzero if this is a call to a `const' function. */
+/* Nonzero if this is a call to a function whose return value depends
+ solely on its arguments, has no side effects, and does not read
+ global memory. */
#define ECF_CONST 1
-/* Nonzero if this is a call to a `volatile' function. */
+/* Nonzero if this call will never return. */
#define ECF_NORETURN 2
/* Nonzero if this is a call to malloc or a related function. */
#define ECF_MALLOC 4
#define ECF_NOTHROW 16
/* Nonzero if this is a call to setjmp or a related function. */
#define ECF_RETURNS_TWICE 32
-/* Nonzero if this is a call to `longjmp'. */
-#define ECF_LONGJMP 64
-/* Nonzero if this is a syscall that makes a new process in the image of
- the current one. */
-#define ECF_SIBCALL 128
+/* Nonzero if this call replaces the current stack frame. */
+#define ECF_SIBCALL 64
/* Nonzero if this is a call to "pure" function (like const function,
but may read memory. */
-#define ECF_PURE 256
+#define ECF_PURE 128
/* Nonzero if this is a call to a function that returns with the stack
pointer depressed. */
-#define ECF_SP_DEPRESSED 512
+#define ECF_SP_DEPRESSED 256
/* Nonzero if this call is known to always return. */
-#define ECF_ALWAYS_RETURN 1024
+#define ECF_ALWAYS_RETURN 512
/* Create libcall block around the call. */
-#define ECF_LIBCALL_BLOCK 2048
+#define ECF_LIBCALL_BLOCK 1024
extern int flags_from_decl_or_type (tree);
extern int call_expr_flags (tree);
extern void make_decl_one_only (tree);
extern int supports_one_only (void);
extern void variable_section (tree, int);
-enum tls_model decl_tls_model (tree);
extern void resolve_unique_section (tree, int, int);
extern void mark_referenced (tree);
extern void mark_decl_referenced (tree);
extern void notice_global_symbol (tree);
extern void set_user_assembler_name (tree, const char *);
+extern void process_pending_assemble_externals (void);
+extern void process_pending_assemble_output_defs (void);
/* In stmt.c */
extern void expand_computed_goto (tree);
bool *, bool *, bool *);
extern bool parse_input_constraint (const char **, int, int, int, int,
const char * const *, bool *, bool *);
-extern void expand_asm_operands (tree, tree, tree, tree, int, location_t);
extern void expand_asm_expr (tree);
-extern bool asm_op_is_mem_input (tree, tree);
extern tree resolve_asm_operand_names (tree, tree, tree);
extern void expand_case (tree);
extern void expand_decl (tree);
/* In tree-inline.c */
+/* The type of a set of already-visited pointers. Functions for creating
+ and manipulating it are declared in pointer-set.h */
+struct pointer_set_t;
+
/* The type of a callback function for walking over tree structure. */
typedef tree (*walk_tree_fn) (tree *, int *, void *);
-extern tree walk_tree (tree*, walk_tree_fn, void*, void*);
+extern tree walk_tree (tree*, walk_tree_fn, void*, struct pointer_set_t*);
extern tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*);
/* In tree-dump.c */
within it. */
TDI_vcg, /* create a VCG graph file for each
function's flowgraph. */
- TDI_xml, /* dump function call graph. */
- TDI_all, /* enable all the dumps. */
+ TDI_tree_all, /* enable all the GENERIC/GIMPLE dumps. */
+ TDI_rtl_all, /* enable all the RTL dumps. */
+ TDI_ipa_all, /* enable all the IPA dumps. */
+
+ TDI_cgraph, /* dump function call graph. */
+
+ DFI_MIN, /* For now, RTL dumps are placed here. */
+ DFI_sibling = DFI_MIN,
+ DFI_eh,
+ DFI_jump,
+ DFI_cse,
+ DFI_gcse,
+ DFI_loop,
+ DFI_bypass,
+ DFI_cfg,
+ DFI_bp,
+ DFI_vpt,
+ DFI_ce1,
+ DFI_tracer,
+ DFI_loop2,
+ DFI_web,
+ DFI_cse2,
+ DFI_life,
+ DFI_combine,
+ DFI_ce2,
+ DFI_regmove,
+ DFI_sms,
+ DFI_sched,
+ DFI_lreg,
+ DFI_greg,
+ DFI_postreload,
+ DFI_gcse2,
+ DFI_flow2,
+ DFI_peephole2,
+ DFI_ce3,
+ DFI_rnreg,
+ DFI_bbro,
+ DFI_branch_target_load,
+ DFI_sched2,
+ DFI_stack,
+ DFI_vartrack,
+ DFI_mach,
+ DFI_dbr,
+
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
+/* Bit masks to control dumping. Not all values are applicable to
+ all 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 */
#define TDF_LINENO (1 << 7) /* display statement line numbers */
#define TDF_UID (1 << 8) /* display decl UIDs */
+#define TDF_TREE (1 << 9) /* is a tree dump */
+#define TDF_RTL (1 << 10) /* is a RTL dump */
+#define TDF_IPA (1 << 11) /* is an IPA dump */
typedef struct dump_info *dump_info_p;
+extern char *get_dump_file_name (enum tree_dump_index);
extern int dump_flag (dump_info_p, int, tree);
extern int dump_enabled_p (enum tree_dump_index);
+extern int dump_initialized_p (enum tree_dump_index);
extern FILE *dump_begin (enum tree_dump_index, int *);
extern void dump_end (enum tree_dump_index, FILE *);
extern void dump_node (tree, int, FILE *);
restricted to creating gimple expressions. */
extern bool in_gimple_form;
-/* In tree-ssa-loop-niter.c. */
-tree lower_bound_in_type (tree, tree);
-tree upper_bound_in_type (tree, tree);
-
/* In tree-ssa-threadupdate.c. */
extern bool thread_through_all_blocks (void);
OSDN Git Service
