/* Core data structures for the 'tree' type.
- Copyright (C) 1989-2014 Free Software Foundation, Inc.
+ Copyright (C) 1989-2017 Free Software Foundation, Inc.
This file is part of GCC.
#ifndef GCC_TREE_CORE_H
#define GCC_TREE_CORE_H
-#include "hashtab.h"
-#include "machmode.h"
-#include "input.h"
-#include "statistics.h"
-#include "vec.h"
-#include "double-int.h"
-#include "real.h"
-#include "fixed-value.h"
-#include "alias.h"
-#include "flags.h"
#include "symtab.h"
/* This file contains all the data structures that define the 'tree' type.
struct ptr_info_def;
struct range_info_def;
struct die_struct;
-struct pointer_set_t;
/*---------------------------------------------------------------------------
/* The function does not lead to calls within current function unit. */
#define ECF_LEAF (1 << 10)
+/* Nonzero if this call returns its first argument. */
+#define ECF_RET1 (1 << 11)
+
/* Nonzero if this call does not affect transactions. */
-#define ECF_TM_PURE (1 << 11)
+#define ECF_TM_PURE (1 << 12)
/* Nonzero if this call is into the transaction runtime library. */
-#define ECF_TM_BUILTIN (1 << 12)
+#define ECF_TM_BUILTIN (1 << 13)
+
+/* Nonzero if this is an indirect call by descriptor. */
+#define ECF_BY_DESCRIPTOR (1 << 14)
/* Call argument flags. */
/* Nonzero if the argument is not dereferenced recursively, thus only
enum built_in_function {
#include "builtins.def"
+ BEGIN_CHKP_BUILTINS,
+
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND)
+#define DEF_BUILTIN_CHKP(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \
+ ENUM##_CHKP = ENUM + BEGIN_CHKP_BUILTINS + 1,
+#include "builtins.def"
+
+ END_CHKP_BUILTINS = BEGIN_CHKP_BUILTINS * 2 + 1,
+
/* Complex division routines in libgcc. These are done via builtins
because emit_library_call_value can't handle complex values. */
BUILT_IN_COMPLEX_MUL_MIN,
/* Upper bound on non-language-specific builtins. */
END_BUILTINS
};
-#undef DEF_BUILTIN
+
+/* Internal functions. */
+enum internal_fn {
+#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) IFN_##CODE,
+#include "internal-fn.def"
+ IFN_LAST
+};
+
+/* An enum that combines target-independent built-in functions with
+ internal functions, so that they can be treated in a similar way.
+ The numbers for built-in functions are the same as for the
+ built_in_function enum. The numbers for internal functions
+ start at END_BUITLINS. */
+enum combined_fn {
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \
+ CFN_##ENUM = int (ENUM),
+#include "builtins.def"
+
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND)
+#define DEF_BUILTIN_CHKP(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \
+ CFN_##ENUM##_CHKP = int (ENUM##_CHKP),
+#include "builtins.def"
+
+#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) \
+ CFN_##CODE = int (END_BUILTINS) + int (IFN_##CODE),
+#include "internal-fn.def"
+
+ CFN_LAST
+};
/* Tree code classes. Each tree_code has an associated code class
represented by a TREE_CODE_CLASS. */
(c_parser_omp_variable_list). */
OMP_CLAUSE_ERROR = 0,
- /* OpenMP clause: private (variable_list). */
+ /* OpenACC/OpenMP clause: private (variable_list). */
OMP_CLAUSE_PRIVATE,
/* OpenMP clause: shared (variable_list). */
OMP_CLAUSE_SHARED,
- /* OpenMP clause: firstprivate (variable_list). */
+ /* OpenACC/OpenMP clause: firstprivate (variable_list). */
OMP_CLAUSE_FIRSTPRIVATE,
/* OpenMP clause: lastprivate (variable_list). */
OMP_CLAUSE_LASTPRIVATE,
- /* OpenMP clause: reduction (operator:variable_list).
+ /* OpenACC/OpenMP clause: reduction (operator:variable_list).
OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
into the shared one.
Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
- placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}. */
+ placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}.
+ Operand 4: OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER: Another dummy
+ VAR_DECL placeholder, used like the above for C/C++ array
+ reductions. */
OMP_CLAUSE_REDUCTION,
/* OpenMP clause: copyin (variable_list). */
/* OpenMP clause: uniform (argument-list). */
OMP_CLAUSE_UNIFORM,
+ /* OpenMP clause: to (extended-list).
+ Only when it appears in declare target. */
+ OMP_CLAUSE_TO_DECLARE,
+
+ /* OpenMP clause: link (variable-list). */
+ OMP_CLAUSE_LINK,
+
/* OpenMP clause: from (variable-list). */
OMP_CLAUSE_FROM,
/* OpenMP clause: to (variable-list). */
OMP_CLAUSE_TO,
- /* OpenMP clause: map ({alloc:,to:,from:,tofrom:,}variable-list). */
+ /* OpenACC clauses: {copy, copyin, copyout, create, delete, deviceptr,
+ device, host (self), present, present_or_copy (pcopy), present_or_copyin
+ (pcopyin), present_or_copyout (pcopyout), present_or_create (pcreate)}
+ (variable-list).
+
+ OpenMP clause: map ({alloc:,to:,from:,tofrom:,}variable-list). */
OMP_CLAUSE_MAP,
+ /* OpenACC clause: use_device (variable_list).
+ OpenMP clause: use_device_ptr (variable-list). */
+ OMP_CLAUSE_USE_DEVICE_PTR,
+
+ /* OpenMP clause: is_device_ptr (variable-list). */
+ OMP_CLAUSE_IS_DEVICE_PTR,
+
+ /* Internal structure to hold OpenACC cache directive's variable-list.
+ #pragma acc cache (variable-list). */
+ OMP_CLAUSE__CACHE_,
+
+ /* OpenACC clause: gang [(gang-argument-list)].
+ Where
+ gang-argument-list: [gang-argument-list, ] gang-argument
+ gang-argument: [num:] integer-expression
+ | static: size-expression
+ size-expression: * | integer-expression. */
+ OMP_CLAUSE_GANG,
+
+ /* OpenACC clause: async [(integer-expression)]. */
+ OMP_CLAUSE_ASYNC,
+
+ /* OpenACC clause: wait [(integer-expression-list)]. */
+ OMP_CLAUSE_WAIT,
+
+ /* OpenACC clause: auto. */
+ OMP_CLAUSE_AUTO,
+
+ /* OpenACC clause: seq. */
+ OMP_CLAUSE_SEQ,
+
/* Internal clause: temporary for combined loops expansion. */
OMP_CLAUSE__LOOPTEMP_,
- /* OpenMP clause: if (scalar-expression). */
+ /* OpenACC/OpenMP clause: if (scalar-expression). */
OMP_CLAUSE_IF,
/* OpenMP clause: num_threads (integer-expression). */
/* OpenMP clause: nowait. */
OMP_CLAUSE_NOWAIT,
- /* OpenMP clause: ordered. */
+ /* OpenMP clause: ordered [(constant-integer-expression)]. */
OMP_CLAUSE_ORDERED,
/* OpenMP clause: default. */
OMP_CLAUSE_DEFAULT,
- /* OpenMP clause: collapse (constant-integer-expression). */
+ /* OpenACC/OpenMP clause: collapse (constant-integer-expression). */
OMP_CLAUSE_COLLAPSE,
/* OpenMP clause: untied. */
/* OpenMP clause: taskgroup. */
OMP_CLAUSE_TASKGROUP,
+ /* OpenMP clause: priority (integer-expression). */
+ OMP_CLAUSE_PRIORITY,
+
+ /* OpenMP clause: grainsize (integer-expression). */
+ OMP_CLAUSE_GRAINSIZE,
+
+ /* OpenMP clause: num_tasks (integer-expression). */
+ OMP_CLAUSE_NUM_TASKS,
+
+ /* OpenMP clause: nogroup. */
+ OMP_CLAUSE_NOGROUP,
+
+ /* OpenMP clause: threads. */
+ OMP_CLAUSE_THREADS,
+
+ /* OpenMP clause: simd. */
+ OMP_CLAUSE_SIMD,
+
+ /* OpenMP clause: hint (integer-expression). */
+ OMP_CLAUSE_HINT,
+
+ /* OpenMP clause: defaultmap (tofrom: scalar). */
+ OMP_CLAUSE_DEFAULTMAP,
+
/* Internally used only clause, holding SIMD uid. */
- OMP_CLAUSE__SIMDUID_
+ OMP_CLAUSE__SIMDUID_,
+
+ /* Internally used only clause, flag whether this is SIMT simd
+ loop or not. */
+ OMP_CLAUSE__SIMT_,
+
+ /* Internally used only clause, holding _Cilk_for # of iterations
+ on OMP_PARALLEL. */
+ OMP_CLAUSE__CILK_FOR_COUNT_,
+
+ /* OpenACC clause: independent. */
+ OMP_CLAUSE_INDEPENDENT,
+
+ /* OpenACC clause: worker [( [num:] integer-expression)]. */
+ OMP_CLAUSE_WORKER,
+
+ /* OpenACC clause: vector [( [length:] integer-expression)]. */
+ OMP_CLAUSE_VECTOR,
+
+ /* OpenACC clause: num_gangs (integer-expression). */
+ OMP_CLAUSE_NUM_GANGS,
+
+ /* OpenACC clause: num_workers (integer-expression). */
+ OMP_CLAUSE_NUM_WORKERS,
+
+ /* OpenACC clause: vector_length (integer-expression). */
+ OMP_CLAUSE_VECTOR_LENGTH,
+
+ /* OpenACC clause: tile ( size-expr-list ). */
+ OMP_CLAUSE_TILE,
+
+ /* OpenMP internal-only clause to specify grid dimensions of a gridified
+ kernel. */
+ OMP_CLAUSE__GRIDDIM_
};
#undef DEFTREESTRUCT
OMP_CLAUSE_SCHEDULE_GUIDED,
OMP_CLAUSE_SCHEDULE_AUTO,
OMP_CLAUSE_SCHEDULE_RUNTIME,
- OMP_CLAUSE_SCHEDULE_LAST
+ OMP_CLAUSE_SCHEDULE_CILKFOR,
+ OMP_CLAUSE_SCHEDULE_MASK = (1 << 3) - 1,
+ OMP_CLAUSE_SCHEDULE_MONOTONIC = (1 << 3),
+ OMP_CLAUSE_SCHEDULE_NONMONOTONIC = (1 << 4),
+ OMP_CLAUSE_SCHEDULE_LAST = 2 * OMP_CLAUSE_SCHEDULE_NONMONOTONIC - 1
};
enum omp_clause_default_kind {
TYPE_QUAL_ATOMIC = 0x8
};
-/* Enumerate visibility settings. */
-#ifndef SYMBOL_VISIBILITY_DEFINED
-#define SYMBOL_VISIBILITY_DEFINED
-enum symbol_visibility {
- VISIBILITY_DEFAULT,
- VISIBILITY_PROTECTED,
- VISIBILITY_HIDDEN,
- VISIBILITY_INTERNAL
-};
-#endif // SYMBOL_VISIBILITY_DEFINED
-
/* Standard named or nameless data types of the C compiler. */
enum tree_index {
TI_ERROR_MARK,
TI_UINT32_TYPE,
TI_UINT64_TYPE,
+ TI_VOID,
+
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
TI_INTEGER_THREE,
TI_BOOLEAN_FALSE,
TI_BOOLEAN_TRUE,
+ TI_FLOAT_TYPE,
+ TI_DOUBLE_TYPE,
+ TI_LONG_DOUBLE_TYPE,
+
+ /* The _FloatN and _FloatNx types must be consecutive, and in the
+ same sequence as the corresponding complex types, which must also
+ be consecutive; _FloatN must come before _FloatNx; the order must
+ also be the same as in the floatn_nx_types array and the RID_*
+ values in c-common.h. This is so that iterations over these
+ types work as intended. */
+ TI_FLOAT16_TYPE,
+ TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE,
+ TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE,
+ TI_FLOAT32_TYPE,
+ TI_FLOAT64_TYPE,
+ TI_FLOAT128_TYPE,
+ TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE,
+#define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1)
+ TI_FLOAT32X_TYPE,
+ TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE,
+ TI_FLOAT64X_TYPE,
+ TI_FLOAT128X_TYPE,
+ TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE,
+ TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE,
+#define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1)
+#define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST \
+ - TI_FLOATN_NX_TYPE_FIRST \
+ + 1)
+
+ /* Put the complex types after their component types, so that in (sequential)
+ tree streaming we can assert that their component types have already been
+ handled (see tree-streamer.c:record_common_node). */
TI_COMPLEX_INTEGER_TYPE,
TI_COMPLEX_FLOAT_TYPE,
TI_COMPLEX_DOUBLE_TYPE,
TI_COMPLEX_LONG_DOUBLE_TYPE,
- TI_FLOAT_TYPE,
- TI_DOUBLE_TYPE,
- TI_LONG_DOUBLE_TYPE,
+ TI_COMPLEX_FLOAT16_TYPE,
+ TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
+ TI_COMPLEX_FLOAT32_TYPE,
+ TI_COMPLEX_FLOAT64_TYPE,
+ TI_COMPLEX_FLOAT128_TYPE,
+ TI_COMPLEX_FLOAT32X_TYPE,
+ TI_COMPLEX_FLOAT64X_TYPE,
+ TI_COMPLEX_FLOAT128X_TYPE,
TI_FLOAT_PTR_TYPE,
TI_DOUBLE_PTR_TYPE,
TI_VA_LIST_FPR_COUNTER_FIELD,
TI_BOOLEAN_TYPE,
TI_FILEPTR_TYPE,
+ TI_CONST_TM_PTR_TYPE,
TI_POINTER_SIZED_TYPE,
+ TI_POINTER_BOUNDS_TYPE,
+
TI_DFLOAT32_TYPE,
TI_DFLOAT64_TYPE,
TI_DFLOAT128_TYPE,
itk_unsigned_long,
itk_long_long,
itk_unsigned_long_long,
- itk_int128,
- itk_unsigned_int128,
+
+ itk_intN_0,
+ itk_unsigned_intN_0,
+ itk_intN_1,
+ itk_unsigned_intN_1,
+ itk_intN_2,
+ itk_unsigned_intN_2,
+ itk_intN_3,
+ itk_unsigned_intN_3,
+
itk_none
};
enum operand_equal_flag {
OEP_ONLY_CONST = 1,
OEP_PURE_SAME = 2,
- OEP_CONSTANT_ADDRESS_OF = 4
+ OEP_MATCH_SIDE_EFFECTS = 4,
+ OEP_ADDRESS_OF = 8,
+ /* Internal within operand_equal_p: */
+ OEP_NO_HASH_CHECK = 16,
+ /* Internal within inchash::add_expr: */
+ OEP_HASH_CHECK = 32
};
/* Enum and arrays used for tree allocation stats.
};
enum annot_expr_kind {
- annot_expr_ivdep_kind
+ annot_expr_ivdep_kind,
+ annot_expr_no_vector_kind,
+ annot_expr_vector_kind,
+ annot_expr_kind_last
};
-
/*---------------------------------------------------------------------------
Type definitions
---------------------------------------------------------------------------*/
/* The type of a callback function that represents a custom walk_tree. */
typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
- void *, struct pointer_set_t*);
+ void *, hash_set<tree> *);
/*---------------------------------------------------------------------------
of the field must be large enough to hold addr_space_t values. */
unsigned address_space : 8;
} bits;
+
/* The following fields are present in tree_base to save space. The
nodes using them do not require any of the flags above and so can
make better use of the 4-byte sized word. */
+
+ /* The number of HOST_WIDE_INTs in an INTEGER_CST. */
+ struct {
+ /* The number of HOST_WIDE_INTs if the INTEGER_CST is accessed in
+ its native precision. */
+ unsigned char unextended;
+
+ /* The number of HOST_WIDE_INTs if the INTEGER_CST is extended to
+ wider precisions based on its TYPE_SIGN. */
+ unsigned char extended;
+
+ /* The number of HOST_WIDE_INTs if the INTEGER_CST is accessed in
+ offset_int precision, with smaller integers being extended
+ according to their TYPE_SIGN. This is equal to one of the two
+ fields above but is cached for speed. */
+ unsigned char offset;
+ } int_length;
+
/* VEC length. This field is only used with TREE_VEC. */
int length;
+
/* SSA version number. This field is only used with SSA_NAME. */
unsigned int version;
+
+ /* Internal function code. */
+ enum internal_fn ifn;
+
+ /* The following two fields are used for MEM_REF and TARGET_MEM_REF
+ expression trees and specify known data non-dependences. For
+ two memory references in a function they are known to not
+ alias if dependence_info.clique are equal and dependence_info.base
+ are distinct. */
+ struct {
+ unsigned short clique;
+ unsigned short base;
+ } dependence_info;
} GTY((skip(""))) u;
};
SSA_NAME_ANTI_RANGE_P in
SSA_NAME
+ MUST_TAIL_CALL in
+ CALL_EXPR
+
public_flag:
TREE_OVERFLOW in
TRANSACTION_EXPR_RELAXED in
TRANSACTION_EXPR
+ FALLTHROUGH_LABEL_P in
+ LABEL_DECL
+
+ SSA_NAME_IS_VIRTUAL_OPERAND in
+ SSA_NAME
+
private_flag:
TREE_PRIVATE in
CALL_EXPR
FUNCTION_DECL
- TYPE_ALIGN_OK in
- all types
-
TREE_THIS_NOTRAP in
INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF
- SSA_NAME_IN_FREELIST in
+ SSA_NAME_IN_FREE_LIST in
SSA_NAME
+ DECL_NONALIASED in
+ VAR_DECL
+
deprecated_flag:
TREE_DEPRECATED in
saturating_flag:
+ TYPE_REVERSE_STORAGE_ORDER in
+ RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE
+
TYPE_SATURATING in
- all types
+ other types
VAR_DECL_IS_VIRTUAL_OPERAND in
VAR_DECL
default_def_flag:
+ TYPE_FINAL_P in
+ RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE
+
TYPE_VECTOR_OPAQUE in
VECTOR_TYPE
DECL_NONLOCAL_FRAME in
VAR_DECL
- TYPE_FINAL_P in
- RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE
+ REF_REVERSE_STORAGE_ORDER in
+ BIT_FIELD_REF, MEM_REF
+
+ FUNC_ADDR_BY_DESCRIPTOR in
+ ADDR_EXPR
+
+ CALL_EXPR_BY_DESCRIPTOR in
+ CALL_EXPR
*/
struct GTY(()) tree_typed {
struct GTY(()) tree_int_cst {
struct tree_typed typed;
- double_int int_cst;
+ HOST_WIDE_INT val[1];
};
OMP_CLAUSE_DEPEND_IN,
OMP_CLAUSE_DEPEND_OUT,
OMP_CLAUSE_DEPEND_INOUT,
+ OMP_CLAUSE_DEPEND_SOURCE,
+ OMP_CLAUSE_DEPEND_SINK,
OMP_CLAUSE_DEPEND_LAST
};
-enum omp_clause_map_kind
-{
- OMP_CLAUSE_MAP_ALLOC,
- OMP_CLAUSE_MAP_TO,
- OMP_CLAUSE_MAP_FROM,
- OMP_CLAUSE_MAP_TOFROM,
- /* The following kind is an internal only map kind, used for pointer based
- array sections. OMP_CLAUSE_SIZE for these is not the pointer size,
- which is implicitly POINTER_SIZE / BITS_PER_UNIT, but the bias. */
- OMP_CLAUSE_MAP_POINTER,
- OMP_CLAUSE_MAP_LAST
-};
-
enum omp_clause_proc_bind_kind
{
/* Numbers should match omp_proc_bind_t enum in omp.h. */
OMP_CLAUSE_PROC_BIND_LAST
};
+enum omp_clause_linear_kind
+{
+ OMP_CLAUSE_LINEAR_DEFAULT,
+ OMP_CLAUSE_LINEAR_REF,
+ OMP_CLAUSE_LINEAR_VAL,
+ OMP_CLAUSE_LINEAR_UVAL
+};
+
struct GTY(()) tree_exp {
struct tree_typed typed;
location_t locus;
needs to point to the original SSA name. Since statements and
SSA names are of different data types, we need this union. See
the explanation in struct imm_use_iterator. */
- union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc;
+ union { gimple *stmt; tree ssa_name; } GTY((skip(""))) loc;
tree *GTY((skip(""))) use;
};
tree var;
/* Statement that defines this SSA name. */
- gimple def_stmt;
+ gimple *def_stmt;
/* Value range information. */
union ssa_name_info_type {
enum omp_clause_default_kind default_kind;
enum omp_clause_schedule_kind schedule_kind;
enum omp_clause_depend_kind depend_kind;
- enum omp_clause_map_kind map_kind;
+ /* See include/gomp-constants.h for enum gomp_map_kind's values. */
+ unsigned int map_kind;
enum omp_clause_proc_bind_kind proc_bind_kind;
enum tree_code reduction_code;
+ enum omp_clause_linear_kind linear_kind;
+ enum tree_code if_modifier;
+ /* The dimension a OMP_CLAUSE__GRIDDIM_ clause of a gridified target
+ construct describes. */
+ unsigned int dimension;
} GTY ((skip)) subcode;
/* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's
unsigned block_num : 31;
location_t locus;
+ location_t end_locus;
tree vars;
vec<tree, va_gc> *nonlocalized_vars;
tree abstract_origin;
tree fragment_origin;
tree fragment_chain;
+
+ /* Pointer to the DWARF lexical block. */
+ struct die_struct *die;
};
struct GTY(()) tree_type_common {
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
+ unsigned lang_flag_7 : 1;
- unsigned int align;
+ /* TYPE_ALIGN in log2; this has to be large enough to hold values
+ of the maximum of BIGGEST_ALIGNMENT and MAX_OFILE_ALIGNMENT,
+ the latter being usually the larger. For ELF it is 8<<28,
+ so we need to store the value 32 (not 31, as we need the zero
+ as well), hence six bits. */
+ unsigned align : 6;
+ unsigned spare : 25;
alias_set_type alias_set;
tree pointer_to;
tree reference_to;
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 canonical;
tree next_variant;
tree main_variant;
tree context;
- tree canonical;
+ tree name;
};
struct GTY(()) tree_type_with_lang_specific {
unsigned decl_nonshareable_flag : 1;
/* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */
- unsigned int off_align : 8;
-
- /* 24 bits unused. */
+ unsigned int off_align : 6;
/* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */
- unsigned int align;
+ unsigned int align : 6;
+
+ /* 20 bits unused. */
/* UID for points-to sets, stable over copying from inlining. */
unsigned int pt_uid;
struct GTY(()) tree_decl_with_vis {
struct tree_decl_with_rtl common;
tree assembler_name;
- tree section_name;
- tree comdat_group;
+ struct symtab_node *symtab_node;
/* Belong to VAR_DECL exclusively. */
unsigned defer_output : 1;
unsigned dllimport_flag : 1;
/* Don't belong to VAR_DECL exclusively. */
unsigned weak_flag : 1;
- /* When SECTION_NAME is implied by -ffunction-section. */
- unsigned implicit_section_name_p : 1;
unsigned seen_in_bind_expr : 1;
unsigned comdat_flag : 1;
+ /* Used for FUNCTION_DECL, VAR_DECL and in C++ for TYPE_DECL. */
ENUM_BITFIELD(symbol_visibility) visibility : 2;
unsigned visibility_specified : 1;
- /* Belongs to VAR_DECL exclusively. */
- ENUM_BITFIELD(tls_model) tls_model : 3;
/* Belong to FUNCTION_DECL exclusively. */
unsigned init_priority_p : 1;
unsigned cxx_destructor : 1;
/* Belong to FUNCTION_DECL exclusively. */
unsigned final : 1;
- /* 11 unused bits. */
+ /* Belong to FUNCTION_DECL exclusively. */
+ unsigned regdecl_flag : 1;
+ /* 14 unused bits. */
};
struct GTY(()) tree_var_decl {
struct GTY(()) tree_decl_non_common {
struct tree_decl_with_vis common;
- /* C++ uses this in namespaces. */
- tree saved_tree;
- /* C++ uses this in templates. */
- tree arguments;
/* Almost all FE's use this. */
tree result;
- /* C++ uses this in namespaces and function_decls. */
- tree vindex;
};
/* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
struct function *f;
+ /* Arguments of the function. */
+ tree arguments;
/* The personality function. Used for stack unwinding. */
tree personality;
tree function_specific_target; /* target options */
tree function_specific_optimization; /* optimization options */
+ /* Generic function body. */
+ tree saved_tree;
+ /* Index within a virtual table. */
+ tree vindex;
+
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
DECL_FUNCTION_CODE. Otherwise unused.
??? The bitfield needs to be able to hold all target function
codes as well. */
- ENUM_BITFIELD(built_in_function) function_code : 11;
+ ENUM_BITFIELD(built_in_function) function_code : 12;
ENUM_BITFIELD(built_in_class) built_in_class : 2;
unsigned static_ctor_flag : 1;
unsigned static_dtor_flag : 1;
- unsigned uninlinable : 1;
+ unsigned uninlinable : 1;
unsigned possibly_inlined : 1;
unsigned novops_flag : 1;
unsigned returns_twice_flag : 1;
unsigned malloc_flag : 1;
unsigned operator_new_flag : 1;
unsigned declared_inline_flag : 1;
- unsigned regdecl_flag : 1;
unsigned no_inline_warning_flag : 1;
unsigned no_instrument_function_entry_exit : 1;
struct tree_common common;
/* The optimization options used by the user. */
- struct cl_optimization opts;
+ struct cl_optimization *opts;
/* Target optabs for this set of optimization options. This is of
type `struct target_optabs *'. */
struct target_optabs *GTY ((skip)) base_optabs;
};
+/* Forward declaration, defined in target-globals.h. */
+
+struct GTY(()) target_globals;
+
/* Target options used by a function. */
struct GTY(()) tree_target_option {
struct tree_common common;
+ /* Target globals for the corresponding target option. */
+ struct target_globals *globals;
+
/* The optimization options used by the user. */
- struct cl_target_option opts;
+ struct cl_target_option *opts;
};
/* Define the overall contents of a tree node.
/* Map from a tree to another tree. */
-struct GTY(()) tree_map {
+struct GTY((for_user)) tree_map {
struct tree_map_base base;
unsigned int hash;
tree to;
};
/* Map from a decl tree to another tree. */
-struct GTY(()) tree_decl_map {
+struct GTY((for_user)) tree_decl_map {
struct tree_map_base base;
tree to;
};
/* Map from a tree to an int. */
-struct GTY(()) tree_int_map {
+struct GTY((for_user)) tree_int_map {
struct tree_map_base base;
unsigned int to;
};
-/* Map from a tree to initialization/finalization priorities. */
-struct GTY(()) tree_priority_map {
- struct tree_map_base base;
- priority_type init;
- priority_type fini;
-};
-
/* Map from a decl tree to a tree vector. */
-struct GTY(()) tree_vec_map {
+struct GTY((for_user)) tree_vec_map {
struct tree_map_base base;
vec<tree, va_gc> *to;
};
};
/* The builtin_info structure holds the FUNCTION_DECL of the standard builtin
- function, and a flag that says if the function is available implicitly, or
- whether the user has to code explicit calls to __builtin_<xxx>. */
+ function, and flags. */
struct GTY(()) builtin_info_type {
- tree decl[(int)END_BUILTINS];
- bool implicit_p[(int)END_BUILTINS];
+ tree decl;
+ /* Whether the user can use <xxx> instead of explicitly using calls
+ to __builtin_<xxx>. */
+ unsigned implicit_p : 1;
+ /* Whether the user has provided a declaration of <xxx>. */
+ unsigned declared_p : 1;
+};
+
+/* Information about a _FloatN or _FloatNx type that may be
+ supported. */
+struct floatn_type_info {
+ /* The number N in the type name. */
+ int n;
+ /* Whether it is an extended type _FloatNx (true) or an interchange
+ type (false). */
+ bool extended;
};
extern bool in_gimple_form;
/* Functional interface to the builtin functions. */
-extern GTY(()) builtin_info_type builtin_info;
+extern GTY(()) builtin_info_type builtin_info[(int)END_BUILTINS];
/* If nonzero, an upper limit on alignment of structure fields, in bits, */
extern unsigned int maximum_field_alignment;
-/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
- Zero means allow extended lvalues. */
-extern int pedantic_lvalues;
-
/* Points to the FUNCTION_DECL of the function whose body we are reading. */
extern GTY(()) tree current_function_decl;
/* Nonzero means a FUNC_BEGIN label was emitted. */
extern GTY(()) const char * current_function_func_begin_label;
+/* Information about the _FloatN and _FloatNx types. */
+extern const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES];
+
#endif // GCC_TREE_CORE_H
projects / thirdparty / gcc.git / blobdiff