From 5e351e96076332aa8c42848701b59923468eae98 Mon Sep 17 00:00:00 2001 From: Diego Novillo Date: Mon, 2 Sep 2013 10:25:40 -0400 Subject: [PATCH] Split all the structures, enums, typedefs and some fundamental declarations from tree.h into tree-core.h. Split all the structures, enums, typedefs and some fundamental declarations from tree.h into tree-core.h. Everything else stays in tree.h for now. As we convert gimple files, we'll move declarations out of tree.h into other headers and rewrite missing functions in the new gimple API. * Makefile.in (TREE_CORE_H): Define. (TREE_H): Use. (GTFILES): Add tree-core.h. * builtins.c (built_in_class_names): Use BUILT_IN_LAST to size the array. * tree-core.h: New file. Move all data structures, enum, typedefs, global declarations and constants from ... * tree.h: ... here. From-SVN: r202172 --- gcc/ChangeLog | 12 + gcc/Makefile.in | 11 +- gcc/builtins.c | 2 +- gcc/tree-core.h | 1688 ++++++++++++++++++++++++++++++++++++++++++++++ gcc/tree.h | 1702 +---------------------------------------------- 5 files changed, 1710 insertions(+), 1705 deletions(-) create mode 100644 gcc/tree-core.h diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 498f68e4027..94e99927253 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -67,6 +67,18 @@ * config/darwin.h (LINK_COMMAND_SPEC_A): Revise sanitizer specs to include sanitize(undefined). +2013-08-31 Diego Novillo + + * Makefile.in (TREE_CORE_H): Define. + (TREE_H): Use. + (GTFILES): Add tree-core.h. + * builtins.c (built_in_class_names): Use BUILT_IN_LAST to + size the array. + * tree-core.h: New file. + Move all data structures, enum, typedefs, global + declarations and constants from ... + * tree.h: ... here. + 2013-08-31 Jan Hubicka * bulitins.c (expand_builtin): Do not early exit for gcov diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 25124103a13..77166d6c392 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -872,11 +872,13 @@ BUILTINS_DEF = builtins.def sync-builtins.def omp-builtins.def \ gtm-builtins.def sanitizer.def cilkplus.def INTERNAL_FN_DEF = internal-fn.def INTERNAL_FN_H = internal-fn.h $(INTERNAL_FN_DEF) -TREE_H = coretypes.h tree.h all-tree.def tree.def c-family/c-common.def \ - $(lang_tree_files) $(MACHMODE_H) tree-check.h $(BUILTINS_DEF) \ - $(INPUT_H) statistics.h $(VEC_H) treestruct.def $(HASHTAB_H) \ +TREE_CORE_H = tree-core.h coretypes.h all-tree.def tree.def \ + c-family/c-common.def $(lang_tree_files) $(MACHMODE_H) \ + $(BUILTINS_DEF) $(INPUT_H) statistics.h \ + $(VEC_H) treestruct.def $(HASHTAB_H) \ double-int.h alias.h $(SYMTAB_H) $(FLAGS_H) \ $(REAL_H) $(FIXED_VALUE_H) +TREE_H = tree.h $(TREE_CORE_H) tree-check.h REGSET_H = regset.h $(BITMAP_H) hard-reg-set.h BASIC_BLOCK_H = basic-block.h $(PREDICT_H) $(VEC_H) $(FUNCTION_H) \ cfg-flags.def cfghooks.h @@ -3795,7 +3797,8 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \ $(host_xm_file_list) \ $(tm_file_list) $(HASHTAB_H) $(SPLAY_TREE_H) $(srcdir)/bitmap.h \ $(srcdir)/alias.h $(srcdir)/coverage.c $(srcdir)/rtl.h \ - $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/libfuncs.h $(SYMTAB_H) \ + $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/tree-core.h \ + $(srcdir)/libfuncs.h $(SYMTAB_H) \ $(srcdir)/real.h $(srcdir)/function.h $(srcdir)/insn-addr.h $(srcdir)/hwint.h \ $(srcdir)/fixed-value.h \ $(srcdir)/output.h $(srcdir)/cfgloop.h \ diff --git a/gcc/builtins.c b/gcc/builtins.c index 581a0507425..bb44a7f9b01 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -62,7 +62,7 @@ struct target_builtins *this_target_builtins = &default_target_builtins; #endif /* Define the names of the builtin function types and codes. */ -const char *const built_in_class_names[4] +const char *const built_in_class_names[BUILT_IN_LAST] = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"}; #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X, diff --git a/gcc/tree-core.h b/gcc/tree-core.h new file mode 100644 index 00000000000..57d5e9c6817 --- /dev/null +++ b/gcc/tree-core.h @@ -0,0 +1,1688 @@ +/* Core data structures for the 'tree' type. + Copyright (C) 1989-2013 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#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. + There are no accessor macros nor functions in this file. Only the + basic data structures, extern declarations and type definitions. */ + +/*--------------------------------------------------------------------------- + Forward type declarations. Mostly to avoid including unnecessary headers +---------------------------------------------------------------------------*/ +struct function; +struct real_value; +struct fixed_value; +struct ptr_info_def; +struct die_struct; +struct pointer_set_t; + + +/*--------------------------------------------------------------------------- + #defined constants +---------------------------------------------------------------------------*/ +/* 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. This corresponds to TREE_READONLY for function + decls. */ +#define ECF_CONST (1 << 0) + +/* Nonzero if this is a call to "pure" function (like const function, + but may read memory. This corresponds to DECL_PURE_P for function + decls. */ +#define ECF_PURE (1 << 1) + +/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no + infinite loop. This corresponds to DECL_LOOPING_CONST_OR_PURE_P + for function decls.*/ +#define ECF_LOOPING_CONST_OR_PURE (1 << 2) + +/* Nonzero if this call will never return. */ +#define ECF_NORETURN (1 << 3) + +/* Nonzero if this is a call to malloc or a related function. */ +#define ECF_MALLOC (1 << 4) + +/* Nonzero if it is plausible that this is a call to alloca. */ +#define ECF_MAY_BE_ALLOCA (1 << 5) + +/* Nonzero if this is a call to a function that won't throw an exception. */ +#define ECF_NOTHROW (1 << 6) + +/* Nonzero if this is a call to setjmp or a related function. */ +#define ECF_RETURNS_TWICE (1 << 7) + +/* Nonzero if this call replaces the current stack frame. */ +#define ECF_SIBCALL (1 << 8) + +/* Function does not read or write memory (but may have side effects, so + it does not necessarily fit ECF_CONST). */ +#define ECF_NOVOPS (1 << 9) + +/* The function does not lead to calls within current function unit. */ +#define ECF_LEAF (1 << 10) + +/* Nonzero if this call does not affect transactions. */ +#define ECF_TM_PURE (1 << 11) + +/* Nonzero if this call is into the transaction runtime library. */ +#define ECF_TM_BUILTIN (1 << 12) + +/* Call argument flags. */ +/* Nonzero if the argument is not dereferenced recursively, thus only + directly reachable memory is read or written. */ +#define EAF_DIRECT (1 << 0) + +/* Nonzero if memory reached by the argument is not clobbered. */ +#define EAF_NOCLOBBER (1 << 1) + +/* Nonzero if the argument does not escape. */ +#define EAF_NOESCAPE (1 << 2) + +/* Nonzero if the argument is not used by the function. */ +#define EAF_UNUSED (1 << 3) + +/* Call return flags. */ +/* Mask for the argument number that is returned. Lower two bits of + the return flags, encodes argument slots zero to three. */ +#define ERF_RETURN_ARG_MASK (3) + +/* Nonzero if the return value is equal to the argument number + flags & ERF_RETURN_ARG_MASK. */ +#define ERF_RETURNS_ARG (1 << 2) + +/* Nonzero if the return value does not alias with anything. Functions + with the malloc attribute have this set on their return value. */ +#define ERF_NOALIAS (1 << 3) + + +/*--------------------------------------------------------------------------- + Enumerations +---------------------------------------------------------------------------*/ +/* Codes of tree nodes. */ +#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, +#define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE, + +enum tree_code { +#include "all-tree.def" +MAX_TREE_CODES +}; + +#undef DEFTREECODE +#undef END_OF_BASE_TREE_CODES + +/* Number of language-independent tree codes. */ +#define NUM_TREE_CODES \ + ((int) LAST_AND_UNUSED_TREE_CODE) + +#define CODE_CONTAINS_STRUCT(CODE, STRUCT) \ + (tree_contains_struct[(CODE)][(STRUCT)]) + + +/* Classify which part of the compiler has defined a given builtin function. + Note that we assume below that this is no more than two bits. */ +enum built_in_class { + NOT_BUILT_IN = 0, + BUILT_IN_FRONTEND, + BUILT_IN_MD, + BUILT_IN_NORMAL +}; + +/* Last marker used for LTO stremaing of built_in_class. We can not add it + to the enum since we need the enumb to fit in 2 bits. */ +#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1) + +/* 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, IM, COND) ENUM, +enum built_in_function { +#include "builtins.def" + + /* 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, + BUILT_IN_COMPLEX_MUL_MAX + = BUILT_IN_COMPLEX_MUL_MIN + + MAX_MODE_COMPLEX_FLOAT + - MIN_MODE_COMPLEX_FLOAT, + + BUILT_IN_COMPLEX_DIV_MIN, + BUILT_IN_COMPLEX_DIV_MAX + = BUILT_IN_COMPLEX_DIV_MIN + + MAX_MODE_COMPLEX_FLOAT + - MIN_MODE_COMPLEX_FLOAT, + + /* Upper bound on non-language-specific builtins. */ + END_BUILTINS +}; +#undef DEF_BUILTIN + +/* 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_vl_exp, /* A function call or other expression with a + variable-length operand vector. */ + tcc_expression /* Any other expression. */ +}; + +/* OMP_CLAUSE codes. Do not reorder, as this is used to index into + the tables omp_clause_num_ops and omp_clause_code_name. */ +enum omp_clause_code { + /* Clause zero is special-cased inside the parser + (c_parser_omp_variable_list). */ + OMP_CLAUSE_ERROR = 0, + + /* OpenMP clause: private (variable_list). */ + OMP_CLAUSE_PRIVATE, + + /* OpenMP clause: shared (variable_list). */ + OMP_CLAUSE_SHARED, + + /* OpenMP clause: firstprivate (variable_list). */ + OMP_CLAUSE_FIRSTPRIVATE, + + /* OpenMP clause: lastprivate (variable_list). */ + OMP_CLAUSE_LASTPRIVATE, + + /* 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}. */ + OMP_CLAUSE_REDUCTION, + + /* OpenMP clause: copyin (variable_list). */ + OMP_CLAUSE_COPYIN, + + /* OpenMP clause: copyprivate (variable_list). */ + OMP_CLAUSE_COPYPRIVATE, + + /* OpenMP clause: linear (variable-list[:linear-step]). */ + OMP_CLAUSE_LINEAR, + + /* OpenMP clause: uniform (argument-list). */ + OMP_CLAUSE_UNIFORM, + + /* OpenMP clause: if (scalar-expression). */ + OMP_CLAUSE_IF, + + /* OpenMP clause: num_threads (integer-expression). */ + OMP_CLAUSE_NUM_THREADS, + + /* OpenMP clause: schedule. */ + OMP_CLAUSE_SCHEDULE, + + /* OpenMP clause: nowait. */ + OMP_CLAUSE_NOWAIT, + + /* OpenMP clause: ordered. */ + OMP_CLAUSE_ORDERED, + + /* OpenMP clause: default. */ + OMP_CLAUSE_DEFAULT, + + /* OpenMP clause: collapse (constant-integer-expression). */ + OMP_CLAUSE_COLLAPSE, + + /* OpenMP clause: untied. */ + OMP_CLAUSE_UNTIED, + + /* OpenMP clause: final (scalar-expression). */ + OMP_CLAUSE_FINAL, + + /* OpenMP clause: mergeable. */ + OMP_CLAUSE_MERGEABLE, + + /* OpenMP clause: safelen (constant-integer-expression). */ + OMP_CLAUSE_SAFELEN, + + /* Internally used only clause, holding SIMD uid. */ + OMP_CLAUSE__SIMDUID_ +}; + +#undef DEFTREESTRUCT +#define DEFTREESTRUCT(ENUM, NAME) ENUM, +enum tree_node_structure_enum { +#include "treestruct.def" + LAST_TS_ENUM +}; +#undef DEFTREESTRUCT + +enum omp_clause_schedule_kind { + OMP_CLAUSE_SCHEDULE_STATIC, + OMP_CLAUSE_SCHEDULE_DYNAMIC, + OMP_CLAUSE_SCHEDULE_GUIDED, + OMP_CLAUSE_SCHEDULE_AUTO, + OMP_CLAUSE_SCHEDULE_RUNTIME +}; + +enum omp_clause_default_kind { + OMP_CLAUSE_DEFAULT_UNSPECIFIED, + OMP_CLAUSE_DEFAULT_SHARED, + OMP_CLAUSE_DEFAULT_NONE, + OMP_CLAUSE_DEFAULT_PRIVATE, + OMP_CLAUSE_DEFAULT_FIRSTPRIVATE +}; + +/* 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. */ +enum cv_qualifier { + TYPE_UNQUALIFIED = 0x0, + TYPE_QUAL_CONST = 0x1, + TYPE_QUAL_VOLATILE = 0x2, + TYPE_QUAL_RESTRICT = 0x4 +}; + +/* 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_INTQI_TYPE, + TI_INTHI_TYPE, + TI_INTSI_TYPE, + TI_INTDI_TYPE, + TI_INTTI_TYPE, + + TI_UINTQI_TYPE, + TI_UINTHI_TYPE, + TI_UINTSI_TYPE, + TI_UINTDI_TYPE, + TI_UINTTI_TYPE, + + TI_UINT16_TYPE, + TI_UINT32_TYPE, + TI_UINT64_TYPE, + + TI_INTEGER_ZERO, + TI_INTEGER_ONE, + TI_INTEGER_THREE, + TI_INTEGER_MINUS_ONE, + TI_NULL_POINTER, + + TI_SIZE_ZERO, + TI_SIZE_ONE, + + TI_BITSIZE_ZERO, + TI_BITSIZE_ONE, + TI_BITSIZE_UNIT, + + TI_PUBLIC, + TI_PROTECTED, + TI_PRIVATE, + + TI_BOOLEAN_FALSE, + TI_BOOLEAN_TRUE, + + 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_FLOAT_PTR_TYPE, + TI_DOUBLE_PTR_TYPE, + TI_LONG_DOUBLE_PTR_TYPE, + TI_INTEGER_PTR_TYPE, + + TI_VOID_TYPE, + TI_PTR_TYPE, + TI_CONST_PTR_TYPE, + TI_SIZE_TYPE, + TI_PID_TYPE, + TI_PTRDIFF_TYPE, + TI_VA_LIST_TYPE, + TI_VA_LIST_GPR_COUNTER_FIELD, + TI_VA_LIST_FPR_COUNTER_FIELD, + TI_BOOLEAN_TYPE, + TI_FILEPTR_TYPE, + TI_POINTER_SIZED_TYPE, + + TI_DFLOAT32_TYPE, + TI_DFLOAT64_TYPE, + TI_DFLOAT128_TYPE, + TI_DFLOAT32_PTR_TYPE, + TI_DFLOAT64_PTR_TYPE, + TI_DFLOAT128_PTR_TYPE, + + TI_VOID_LIST_NODE, + + TI_MAIN_IDENTIFIER, + + TI_SAT_SFRACT_TYPE, + TI_SAT_FRACT_TYPE, + TI_SAT_LFRACT_TYPE, + TI_SAT_LLFRACT_TYPE, + TI_SAT_USFRACT_TYPE, + TI_SAT_UFRACT_TYPE, + TI_SAT_ULFRACT_TYPE, + TI_SAT_ULLFRACT_TYPE, + TI_SFRACT_TYPE, + TI_FRACT_TYPE, + TI_LFRACT_TYPE, + TI_LLFRACT_TYPE, + TI_USFRACT_TYPE, + TI_UFRACT_TYPE, + TI_ULFRACT_TYPE, + TI_ULLFRACT_TYPE, + TI_SAT_SACCUM_TYPE, + TI_SAT_ACCUM_TYPE, + TI_SAT_LACCUM_TYPE, + TI_SAT_LLACCUM_TYPE, + TI_SAT_USACCUM_TYPE, + TI_SAT_UACCUM_TYPE, + TI_SAT_ULACCUM_TYPE, + TI_SAT_ULLACCUM_TYPE, + TI_SACCUM_TYPE, + TI_ACCUM_TYPE, + TI_LACCUM_TYPE, + TI_LLACCUM_TYPE, + TI_USACCUM_TYPE, + TI_UACCUM_TYPE, + TI_ULACCUM_TYPE, + TI_ULLACCUM_TYPE, + TI_QQ_TYPE, + TI_HQ_TYPE, + TI_SQ_TYPE, + TI_DQ_TYPE, + TI_TQ_TYPE, + TI_UQQ_TYPE, + TI_UHQ_TYPE, + TI_USQ_TYPE, + TI_UDQ_TYPE, + TI_UTQ_TYPE, + TI_SAT_QQ_TYPE, + TI_SAT_HQ_TYPE, + TI_SAT_SQ_TYPE, + TI_SAT_DQ_TYPE, + TI_SAT_TQ_TYPE, + TI_SAT_UQQ_TYPE, + TI_SAT_UHQ_TYPE, + TI_SAT_USQ_TYPE, + TI_SAT_UDQ_TYPE, + TI_SAT_UTQ_TYPE, + TI_HA_TYPE, + TI_SA_TYPE, + TI_DA_TYPE, + TI_TA_TYPE, + TI_UHA_TYPE, + TI_USA_TYPE, + TI_UDA_TYPE, + TI_UTA_TYPE, + TI_SAT_HA_TYPE, + TI_SAT_SA_TYPE, + TI_SAT_DA_TYPE, + TI_SAT_TA_TYPE, + TI_SAT_UHA_TYPE, + TI_SAT_USA_TYPE, + TI_SAT_UDA_TYPE, + TI_SAT_UTA_TYPE, + + TI_OPTIMIZATION_DEFAULT, + TI_OPTIMIZATION_CURRENT, + TI_TARGET_OPTION_DEFAULT, + TI_TARGET_OPTION_CURRENT, + TI_CURRENT_TARGET_PRAGMA, + TI_CURRENT_OPTIMIZE_PRAGMA, + + TI_MAX +}; + +/* An enumeration of the standard C integer types. These must be + ordered so that shorter types appear before longer ones, and so + that signed types appear before unsigned ones, for the correct + functioning of interpret_integer() in c-lex.c. */ +enum integer_type_kind { + itk_char, + itk_signed_char, + itk_unsigned_char, + itk_short, + itk_unsigned_short, + itk_int, + itk_unsigned_int, + itk_long, + itk_unsigned_long, + itk_long_long, + itk_unsigned_long_long, + itk_int128, + itk_unsigned_int128, + itk_none +}; + +/* 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 +}; + +/* Flags that may be passed in the third argument of decl_attributes, and + to handler functions for attributes. */ +enum attribute_flags { + /* The type passed in is the type of a DECL, and any attributes that + should be passed in again to be applied to the DECL rather than the + type should be returned. */ + ATTR_FLAG_DECL_NEXT = 1, + /* The type passed in is a function return type, and any attributes that + should be passed in again to be applied to the function type rather + than the return type should be returned. */ + ATTR_FLAG_FUNCTION_NEXT = 2, + /* The type passed in is an array element type, and any attributes that + should be passed in again to be applied to the array type rather + than the element type should be returned. */ + ATTR_FLAG_ARRAY_NEXT = 4, + /* The type passed in is a structure, union or enumeration type being + created, and should be modified in place. */ + ATTR_FLAG_TYPE_IN_PLACE = 8, + /* The attributes are being applied by default to a library function whose + name indicates known behavior, and should be silently ignored if they + are not in fact compatible with the function type. */ + ATTR_FLAG_BUILT_IN = 16, + /* A given attribute has been parsed as a C++-11 attribute. */ + ATTR_FLAG_CXX11 = 32 +}; + +/* Types used to represent sizes. */ +enum size_type_kind { + stk_sizetype, /* Normal representation of sizes in bytes. */ + stk_ssizetype, /* Signed representation of sizes in bytes. */ + stk_bitsizetype, /* Normal representation of sizes in bits. */ + stk_sbitsizetype, /* Signed representation of sizes in bits. */ + stk_type_kind_last +}; + +enum operand_equal_flag { + OEP_ONLY_CONST = 1, + OEP_PURE_SAME = 2, + OEP_CONSTANT_ADDRESS_OF = 4 +}; + +/* Enum and arrays used for tree allocation stats. + Keep in sync with tree.c:tree_node_kind_names. */ +enum tree_node_kind { + d_kind, + t_kind, + b_kind, + s_kind, + r_kind, + e_kind, + c_kind, + id_kind, + vec_kind, + binfo_kind, + ssa_name_kind, + constr_kind, + x_kind, + lang_decl, + lang_type, + omp_clause_kind, + all_kinds +}; + + +/*--------------------------------------------------------------------------- + Type definitions +---------------------------------------------------------------------------*/ +/* When processing aliases at the symbol table level, we need the + declaration of target. For this reason we need to queue aliases and + process them after all declarations has been produced. */ +typedef struct GTY(()) alias_pair { + tree decl; + tree target; +} alias_pair; + +/* An initialization priority. */ +typedef unsigned short priority_type; + +/* The type of a callback function for walking over tree structure. */ +typedef tree (*walk_tree_fn) (tree *, int *, void *); + +/* 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*); + + +/*--------------------------------------------------------------------------- + Main data structures +---------------------------------------------------------------------------*/ +/* A tree node can represent a data type, a variable, an expression + or a statement. Each node has a TREE_CODE which says what kind of + thing it represents. Some common codes are: + INTEGER_TYPE -- represents a type of integers. + ARRAY_TYPE -- represents a type of pointer. + VAR_DECL -- represents a declared variable. + INTEGER_CST -- represents a constant integer value. + PLUS_EXPR -- represents a sum (an expression). + + As for the contents of a tree node: there are some fields + that all nodes share. Each TREE_CODE has various special-purpose + fields as well. The fields of a node are never accessed directly, + always through accessor macros. */ + +/* Every kind of tree node starts with this structure, + so all nodes have these fields. + + See the accessor macros, defined below, for documentation of the + fields, and the table below which connects the fields and the + accessor macros. */ + +struct GTY(()) tree_base { + ENUM_BITFIELD(tree_code) code : 16; + + unsigned side_effects_flag : 1; + unsigned constant_flag : 1; + unsigned addressable_flag : 1; + unsigned volatile_flag : 1; + unsigned readonly_flag : 1; + unsigned asm_written_flag: 1; + unsigned nowarning_flag : 1; + unsigned visited : 1; + + unsigned used_flag : 1; + unsigned nothrow_flag : 1; + unsigned static_flag : 1; + unsigned public_flag : 1; + unsigned private_flag : 1; + unsigned protected_flag : 1; + unsigned deprecated_flag : 1; + unsigned default_def_flag : 1; + + union { + /* The bits in the following structure should only be used with + accessor macros that constrain inputs with tree checking. */ + struct { + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + unsigned saturating_flag : 1; + + unsigned unsigned_flag : 1; + unsigned packed_flag : 1; + unsigned user_align : 1; + unsigned nameless_flag : 1; + unsigned spare0 : 4; + + unsigned spare1 : 8; + + /* This field is only used with TREE_TYPE nodes; the only reason it is + present in tree_base instead of tree_type is to save space. The size + 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. */ + /* 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; + } GTY((skip(""))) u; +}; + +/* The following table lists the uses of each of the above flags and + for which types of nodes they are defined. + + addressable_flag: + + TREE_ADDRESSABLE in + VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL + SSA_NAME + all types + CONSTRUCTOR, IDENTIFIER_NODE + STMT_EXPR + + CALL_EXPR_TAILCALL in + CALL_EXPR + + CASE_LOW_SEEN in + CASE_LABEL_EXPR + + PREDICT_EXPR_OUTCOME in + PREDICT_EXPR + + static_flag: + + TREE_STATIC in + VAR_DECL, FUNCTION_DECL + CONSTRUCTOR + + TREE_NO_TRAMPOLINE in + ADDR_EXPR + + BINFO_VIRTUAL_P in + TREE_BINFO + + TREE_SYMBOL_REFERENCED in + IDENTIFIER_NODE + + CLEANUP_EH_ONLY in + TARGET_EXPR, WITH_CLEANUP_EXPR + + TRY_CATCH_IS_CLEANUP in + TRY_CATCH_EXPR + + ASM_INPUT_P in + ASM_EXPR + + TYPE_REF_CAN_ALIAS_ALL in + POINTER_TYPE, REFERENCE_TYPE + + CASE_HIGH_SEEN in + CASE_LABEL_EXPR + + ENUM_IS_SCOPED in + ENUMERAL_TYPE + + TRANSACTION_EXPR_OUTER in + TRANSACTION_EXPR + + public_flag: + + TREE_OVERFLOW in + INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST + + TREE_PUBLIC in + VAR_DECL, FUNCTION_DECL + IDENTIFIER_NODE + + ASM_VOLATILE_P in + ASM_EXPR + + CALL_EXPR_VA_ARG_PACK in + CALL_EXPR + + TYPE_CACHED_VALUES_P in + all types + + SAVE_EXPR_RESOLVED_P in + SAVE_EXPR + + OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in + OMP_CLAUSE_LASTPRIVATE + + OMP_CLAUSE_PRIVATE_DEBUG in + OMP_CLAUSE_PRIVATE + + TRANSACTION_EXPR_RELAXED in + TRANSACTION_EXPR + + private_flag: + + TREE_PRIVATE in + all decls + + CALL_EXPR_RETURN_SLOT_OPT in + CALL_EXPR + + OMP_SECTION_LAST in + OMP_SECTION + + OMP_PARALLEL_COMBINED in + OMP_PARALLEL + + OMP_CLAUSE_PRIVATE_OUTER_REF in + OMP_CLAUSE_PRIVATE + + TYPE_REF_IS_RVALUE in + REFERENCE_TYPE + + ENUM_IS_OPAQUE in + ENUMERAL_TYPE + + protected_flag: + + TREE_PROTECTED in + BLOCK + all decls + + CALL_FROM_THUNK_P and + CALL_ALLOCA_FOR_VAR_P in + CALL_EXPR + + side_effects_flag: + + TREE_SIDE_EFFECTS in + all expressions + all decls + all constants + + FORCED_LABEL in + LABEL_DECL + + volatile_flag: + + TREE_THIS_VOLATILE in + all expressions + all decls + + TYPE_VOLATILE in + all types + + readonly_flag: + + TREE_READONLY in + all expressions + all decls + + TYPE_READONLY in + all types + + constant_flag: + + TREE_CONSTANT in + all expressions + all decls + all constants + + TYPE_SIZES_GIMPLIFIED in + all types + + unsigned_flag: + + TYPE_UNSIGNED in + all types + + DECL_UNSIGNED in + all decls + + asm_written_flag: + + TREE_ASM_WRITTEN in + VAR_DECL, FUNCTION_DECL, TYPE_DECL + RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE + BLOCK, STRING_CST + + SSA_NAME_OCCURS_IN_ABNORMAL_PHI in + SSA_NAME + + used_flag: + + TREE_USED in + all expressions + all decls + IDENTIFIER_NODE + + nothrow_flag: + + TREE_NOTHROW 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 + + deprecated_flag: + + TREE_DEPRECATED in + all decls + all types + + IDENTIFIER_TRANSPARENT_ALIAS in + IDENTIFIER_NODE + + visited: + + TREE_VISITED in + all trees (used liberally by many passes) + + saturating_flag: + + TYPE_SATURATING in + all types + + VAR_DECL_IS_VIRTUAL_OPERAND in + VAR_DECL + + nowarning_flag: + + TREE_NO_WARNING in + all expressions + all decls + + TYPE_ARTIFICIAL in + all types + + default_def_flag: + + TYPE_VECTOR_OPAQUE in + VECTOR_TYPE + + SSA_NAME_IS_DEFAULT_DEF in + SSA_NAME + + DECL_NONLOCAL_FRAME in + VAR_DECL +*/ + +struct GTY(()) tree_typed { + struct tree_base base; + tree type; +}; + +struct GTY(()) tree_common { + struct tree_typed typed; + tree chain; +}; + +struct GTY(()) tree_int_cst { + struct tree_typed typed; + double_int int_cst; +}; + + +struct GTY(()) tree_real_cst { + struct tree_typed typed; + struct real_value * real_cst_ptr; +}; + +struct GTY(()) tree_fixed_cst { + struct tree_typed typed; + struct fixed_value * fixed_cst_ptr; +}; + +struct GTY(()) tree_string { + struct tree_typed typed; + int length; + char str[1]; +}; + +struct GTY(()) tree_complex { + struct tree_typed typed; + tree real; + tree imag; +}; + +struct GTY(()) tree_vector { + struct tree_typed typed; + tree GTY ((length ("TYPE_VECTOR_SUBPARTS (TREE_TYPE ((tree)&%h))"))) elts[1]; +}; + +struct GTY(()) tree_identifier { + struct tree_common common; + struct ht_identifier id; +}; + +struct GTY(()) tree_list { + struct tree_common common; + tree purpose; + tree value; +}; + +struct GTY(()) tree_vec { + struct tree_common common; + tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1]; +}; + +/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the + element. INDEX can optionally design the position of VALUE: in arrays, + it is the index where VALUE has to be placed; in structures, it is the + FIELD_DECL of the member. */ +typedef struct GTY(()) constructor_elt_d { + tree index; + tree value; +} constructor_elt; + +struct GTY(()) tree_constructor { + struct tree_typed typed; + vec *elts; +}; + +struct GTY(()) tree_exp { + struct tree_typed typed; + location_t locus; + tree GTY ((special ("tree_exp"), + desc ("TREE_CODE ((tree) &%0)"))) + operands[1]; +}; + +/* Immediate use linking structure. This structure is used for maintaining + a doubly linked list of uses of an SSA_NAME. */ +typedef struct GTY(()) ssa_use_operand_d { + struct ssa_use_operand_d* GTY((skip(""))) prev; + struct ssa_use_operand_d* GTY((skip(""))) next; + /* Immediate uses for a given SSA name are maintained as a cyclic + list. To recognize the root of this list, the location field + 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 immediate_use_iterator_d. */ + union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc; + tree *GTY((skip(""))) use; +} ssa_use_operand_t; + +struct GTY(()) tree_ssa_name { + struct tree_typed typed; + + /* _DECL wrapped by this SSA name. */ + tree var; + + /* Statement that defines this SSA name. */ + gimple def_stmt; + + /* Pointer attributes used for alias analysis. */ + struct ptr_info_def *ptr_info; + + /* Immediate uses list for this SSA_NAME. */ + struct ssa_use_operand_d imm_uses; +}; + +struct GTY(()) phi_arg_d { + /* imm_use MUST be the first element in struct because we do some + pointer arithmetic with it. See phi_arg_index_from_use. */ + struct ssa_use_operand_d imm_use; + tree def; + location_t locus; +}; + +struct GTY(()) tree_omp_clause { + struct tree_common common; + location_t locus; + enum omp_clause_code code; + union omp_clause_subcode { + enum omp_clause_default_kind default_kind; + enum omp_clause_schedule_kind schedule_kind; + enum tree_code reduction_code; + } GTY ((skip)) subcode; + + /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's + usage. */ + gimple_seq gimple_reduction_init; + gimple_seq gimple_reduction_merge; + + tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) + ops[1]; +}; + +struct GTY(()) tree_block { + struct tree_base base; + tree chain; + + unsigned abstract_flag : 1; + unsigned block_num : 31; + + location_t locus; + + tree vars; + vec *nonlocalized_vars; + + tree subblocks; + tree supercontext; + tree abstract_origin; + tree fragment_origin; + tree fragment_chain; +}; + +struct GTY(()) tree_type_common { + struct tree_common common; + tree size; + tree size_unit; + tree attributes; + unsigned int uid; + + unsigned int precision : 10; + unsigned no_force_blk_flag : 1; + unsigned needs_constructing_flag : 1; + unsigned transparent_aggr_flag : 1; + unsigned restrict_flag : 1; + unsigned contains_placeholder_bits : 2; + + ENUM_BITFIELD(machine_mode) mode : 8; + + unsigned string_flag : 1; + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + + unsigned int align; + alias_set_type alias_set; + tree pointer_to; + tree reference_to; + union tree_type_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 next_variant; + tree main_variant; + tree context; + tree canonical; +}; + +struct GTY(()) tree_type_with_lang_specific { + struct tree_type_common common; + /* Points to a structure whose details depend on the language in use. */ + struct lang_type *lang_specific; +}; + +struct GTY(()) tree_type_non_common { + struct tree_type_with_lang_specific with_lang_specific; + tree values; + tree minval; + tree maxval; + tree binfo; +}; + +struct GTY (()) tree_binfo { + struct tree_common common; + + tree offset; + tree vtable; + tree virtuals; + tree vptr_field; + vec *base_accesses; + tree inheritance; + + tree vtt_subvtt; + tree vtt_vptr; + + vec base_binfos; +}; + +struct GTY(()) tree_decl_minimal { + struct tree_common common; + location_t locus; + unsigned int uid; + tree name; + tree context; +}; + +struct GTY(()) tree_decl_common { + struct tree_decl_minimal common; + tree size; + + ENUM_BITFIELD(machine_mode) mode : 8; + + unsigned nonlocal_flag : 1; + unsigned virtual_flag : 1; + unsigned ignored_flag : 1; + unsigned abstract_flag : 1; + unsigned artificial_flag : 1; + unsigned preserve_flag: 1; + unsigned debug_expr_is_from : 1; + + unsigned lang_flag_0 : 1; + unsigned lang_flag_1 : 1; + unsigned lang_flag_2 : 1; + unsigned lang_flag_3 : 1; + unsigned lang_flag_4 : 1; + unsigned lang_flag_5 : 1; + unsigned lang_flag_6 : 1; + unsigned lang_flag_7 : 1; + unsigned lang_flag_8 : 1; + + /* In LABEL_DECL, this is DECL_ERROR_ISSUED. + In VAR_DECL and PARM_DECL, this is DECL_REGISTER. */ + unsigned decl_flag_0 : 1; + /* In FIELD_DECL, this is DECL_BIT_FIELD + In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL. + 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, PARM_DECL and RESULT_DECL, this is + DECL_HAS_VALUE_EXPR_P. */ + unsigned decl_flag_2 : 1; + /* 1 bit unused. */ + unsigned decl_flag_3 : 1; + /* Logically, these two would go in a theoretical base shared by var and + parm decl. */ + unsigned gimple_reg_flag : 1; + /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */ + unsigned decl_by_reference_flag : 1; + /* In a VAR_DECL and PARM_DECL, this is DECL_READ_P. */ + unsigned decl_read_flag : 1; + /* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE. */ + unsigned decl_nonshareable_flag : 1; + + /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ + unsigned int off_align : 8; + + /* 24 bits unused. */ + + /* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */ + unsigned int align; + + /* UID for points-to sets, stable over copying from inlining. */ + unsigned int pt_uid; + + tree size_unit; + tree initial; + tree attributes; + tree abstract_origin; + + /* Points to a structure whose details depend on the language in use. */ + struct lang_decl *lang_specific; +}; + +struct GTY(()) tree_decl_with_rtl { + struct tree_decl_common common; + rtx rtl; +}; + +struct GTY(()) tree_field_decl { + struct tree_decl_common common; + + tree offset; + tree bit_field_type; + tree qualifier; + tree bit_offset; + tree fcontext; +}; + +struct GTY(()) tree_label_decl { + struct tree_decl_with_rtl common; + int label_decl_uid; + int eh_landing_pad_nr; +}; + +struct GTY(()) tree_result_decl { + struct tree_decl_with_rtl common; +}; + +struct GTY(()) tree_const_decl { + struct tree_decl_common common; +}; + +struct GTY(()) tree_parm_decl { + struct tree_decl_with_rtl common; + rtx incoming_rtl; +}; + +struct GTY(()) tree_decl_with_vis { + struct tree_decl_with_rtl common; + tree assembler_name; + tree section_name; + tree comdat_group; + + /* Belong to VAR_DECL exclusively. */ + unsigned defer_output : 1; + unsigned hard_register : 1; + unsigned common_flag : 1; + unsigned in_text_section : 1; + unsigned in_constant_pool : 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; + 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; + /* Used by C++ only. Might become a generic decl flag. */ + unsigned shadowed_for_var_p : 1; + /* Belong to FUNCTION_DECL exclusively. */ + unsigned cxx_constructor : 1; + /* Belong to FUNCTION_DECL exclusively. */ + unsigned cxx_destructor : 1; + /* Belong to FUNCTION_DECL exclusively. */ + unsigned final : 1; + /* 11 unused bits. */ +}; + +struct GTY(()) tree_var_decl { + struct tree_decl_with_vis common; +}; + +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; +}; + +struct GTY(()) tree_function_decl { + struct tree_decl_non_common common; + + struct function *f; + + /* The personality function. Used for stack unwinding. */ + tree personality; + + /* Function specific options that are used by this function. */ + tree function_specific_target; /* target options */ + tree function_specific_optimization; /* optimization options */ + + /* 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_class) built_in_class : 2; + + unsigned static_ctor_flag : 1; + unsigned static_dtor_flag : 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; + unsigned no_limit_stack : 1; + unsigned disregard_inline_limits : 1; + unsigned pure_flag : 1; + unsigned looping_const_or_pure_flag : 1; + unsigned has_debug_args_flag : 1; + unsigned tm_clone_flag : 1; + unsigned versioned_function : 1; + /* No bits left. */ +}; + +struct GTY(()) tree_translation_unit_decl { + struct tree_decl_common common; + /* Source language of this translation unit. Used for DWARF output. */ + const char * GTY((skip(""))) language; + /* TODO: Non-optimization used to build this translation unit. */ + /* TODO: Root of a partial DWARF tree for global types and decls. */ +}; + +struct GTY(()) tree_type_decl { + struct tree_decl_non_common common; + +}; + +struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node + { + struct tree_statement_list_node *prev; + struct tree_statement_list_node *next; + tree stmt; +}; + +struct GTY(()) tree_statement_list + { + struct tree_typed typed; + struct tree_statement_list_node *head; + struct tree_statement_list_node *tail; +}; + +struct GTY(()) tree_optimization_option { + struct tree_common common; + + /* The optimization options used by the user. */ + struct cl_optimization opts; + + /* Target optabs for this set of optimization options. This is of + type `struct target_optabs *'. */ + unsigned char *GTY ((atomic)) optabs; + + /* The value of this_target_optabs against which the optabs above were + generated. */ + struct target_optabs *GTY ((skip)) base_optabs; +}; + +struct GTY(()) tree_target_option { + struct tree_common common; + + /* The optimization options used by the user. */ + struct cl_target_option opts; +}; + +/* Define the overall contents of a tree node. + It may be any of the structures declared above + for various types of node. */ +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; + struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst; + struct tree_vector GTY ((tag ("TS_VECTOR"))) vector; + struct tree_string GTY ((tag ("TS_STRING"))) string; + struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex; + struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier; + struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal; + struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common; + struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl; + struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) + decl_non_common; + struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl; + struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis; + struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl; + struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl; + struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl; + struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl; + struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl; + struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl; + struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl; + struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL"))) + translation_unit_decl; + struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common; + struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC"))) + type_with_lang_specific; + struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON"))) + type_non_common; + struct tree_list GTY ((tag ("TS_LIST"))) list; + struct tree_vec GTY ((tag ("TS_VEC"))) vec; + struct tree_exp GTY ((tag ("TS_EXP"))) exp; + struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; + struct tree_block GTY ((tag ("TS_BLOCK"))) block; + struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo; + struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; + struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor; + struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause; + struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization; + struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option; +}; + +/* Structure describing an attribute and a function to handle it. */ +struct attribute_spec { + /* The name of the attribute (without any leading or trailing __), + or NULL to mark the end of a table of attributes. */ + const char *name; + /* The minimum length of the list of arguments of the attribute. */ + int min_length; + /* The maximum length of the list of arguments of the attribute + (-1 for no maximum). */ + int max_length; + /* Whether this attribute requires a DECL. If it does, it will be passed + from types of DECLs, function return types and array element types to + the DECLs, function types and array types respectively; but when + applied to a type in any other circumstances, it will be ignored with + a warning. (If greater control is desired for a given attribute, + this should be false, and the flags argument to the handler may be + used to gain greater control in that case.) */ + bool decl_required; + /* Whether this attribute requires a type. If it does, it will be passed + from a DECL to the type of that DECL. */ + bool type_required; + /* Whether this attribute requires a function (or method) type. If it does, + it will be passed from a function pointer type to the target type, + and from a function return type (which is not itself a function + pointer type) to the function type. */ + bool function_type_required; + /* Function to handle this attribute. NODE points to the node to which + the attribute is to be applied. If a DECL, it should be modified in + place; if a TYPE, a copy should be created. NAME is the name of the + attribute (possibly with leading or trailing __). ARGS is the TREE_LIST + of the arguments (which may be NULL). FLAGS gives further information + about the context of the attribute. Afterwards, the attributes will + be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate, + unless *NO_ADD_ATTRS is set to true (which should be done on error, + as well as in any other cases when the attributes should not be added + to the DECL or TYPE). Depending on FLAGS, any attributes to be + applied to another type or DECL later may be returned; + otherwise the return value should be NULL_TREE. This pointer may be + NULL if no special handling is required beyond the checks implied + by the rest of this structure. */ + tree (*handler) (tree *node, tree name, tree args, + int flags, bool *no_add_attrs); + /* Specifies if attribute affects type's identity. */ + bool affects_type_identity; +}; + +/* These functions allow a front-end to perform a manual layout of a + RECORD_TYPE. (For instance, if the placement of subsequent fields + depends on the placement of fields so far.) Begin by calling + start_record_layout. Then, call place_field for each of the + fields. Then, call finish_record_layout. See layout_type for the + default way in which these functions are used. */ +typedef struct record_layout_info_s { + /* The RECORD_TYPE that we are laying out. */ + tree t; + /* The offset into the record so far, in bytes, not including bits in + BITPOS. */ + tree offset; + /* The last known alignment of SIZE. */ + unsigned int offset_align; + /* The bit position within the last OFFSET_ALIGN bits, in bits. */ + tree bitpos; + /* The alignment of the record so far, in bits. */ + unsigned int record_align; + /* The alignment of the record so far, ignoring #pragma pack and + __attribute__ ((packed)), in bits. */ + unsigned int unpacked_align; + /* The previous field laid out. */ + tree prev_field; + /* The static variables (i.e., class variables, as opposed to + instance variables) encountered in T. */ + vec *pending_statics; + /* Bits remaining in the current alignment group */ + int remaining_in_alignment; + /* True if we've seen a packed field that didn't have normal + alignment anyway. */ + int packed_maybe_necessary; +} *record_layout_info; + +/* Iterator for going through the function arguments. */ +struct function_args_iterator { + tree next; /* TREE_LIST pointing to the next argument */ +}; + +/* Structures to map from a tree to another tree. */ +struct GTY(()) tree_map_base { + tree from; +}; + +struct GTY(()) 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 tree_map_base base; + tree to; +}; + +/* Map from a tree to an int. */ +struct GTY(()) 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 tree_map_base base; + vec *to; +}; + +/* Abstract iterators for CALL_EXPRs. These static inline definitions + have to go towards the end of tree.h so that union tree_node is fully + defined by this point. */ + +/* Structure containing iterator state. */ +struct call_expr_arg_iterator { + tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +}; + +struct const_call_expr_arg_iterator { + const_tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +}; + +/* 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_. */ +struct GTY(()) builtin_info_type { + tree decl[(int)END_BUILTINS]; + bool implicit_p[(int)END_BUILTINS]; +}; + + +/*--------------------------------------------------------------------------- + Global variables +---------------------------------------------------------------------------*/ +/* Matrix describing the structures contained in a given tree code. */ +extern unsigned char tree_contains_struct[MAX_TREE_CODES][64]; + +/* Class of tree given its code. */ +extern const enum tree_code_class tree_code_type[]; + +/* 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[]; + +/* Number of argument-words in each kind of tree-node. */ +extern const unsigned char tree_code_length[]; + +/* Names of tree components. */ +extern const char *const tree_code_name[]; + +/* Vector of all alias pairs for global symbols. */ +extern GTY(()) vec *alias_pairs; + +/* Names of all the built_in classes. */ +extern const char *const built_in_class_names[BUILT_IN_LAST]; + +/* Names of all the built_in functions. */ +extern const char * built_in_names[(int) END_BUILTINS]; + +/* Number of operands and names for each OMP_CLAUSE node. */ +extern unsigned const char omp_clause_num_ops[]; +extern const char * const omp_clause_code_name[]; + +/* A vector of all translation-units. */ +extern GTY (()) vec *all_translation_units; + +/* Vector of standard trees used by the C compiler. */ +extern GTY(()) tree global_trees[TI_MAX]; + +/* The standard C integer types. Use integer_type_kind to index into + this array. */ +extern GTY(()) tree integer_types[itk_none]; + +/* Types used to represent sizes. */ +extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last]; + +/* Arrays for keeping track of tree node statistics. */ +extern int tree_node_counts[]; +extern int tree_node_sizes[]; + +/* True if we are in gimple form and the actions of the folders need to + be restricted. False if we are not in gimple form and folding is not + restricted to creating gimple expressions. */ +extern bool in_gimple_form; + +/* Functional interface to the builtin functions. */ +extern GTY(()) builtin_info_type builtin_info; + +/* 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; + +#endif // GCC_TREE_CORE_H diff --git a/gcc/tree.h b/gcc/tree.h index 83edabaeff9..718d8f45276 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -20,32 +20,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_TREE_H #define GCC_TREE_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" - -/* Codes of tree nodes */ - -#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, -#define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE, - -enum tree_code { -#include "all-tree.def" -MAX_TREE_CODES -}; - -#undef DEFTREECODE -#undef END_OF_BASE_TREE_CODES - -extern unsigned char tree_contains_struct[MAX_TREE_CODES][64]; -#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)]) +#include "tree-core.h" /* Macros for initializing `tree_contains_struct'. */ #define MARK_TS_BASE(C) \ @@ -107,42 +82,12 @@ extern unsigned char tree_contains_struct[MAX_TREE_CODES][64]; 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) - -/* 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_vl_exp, /* A function call or other expression with a - variable-length operand vector. */ - 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)] -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. */ @@ -231,76 +176,8 @@ extern const enum tree_code_class tree_code_type[]; #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) -/* Number of argument-words in each kind of tree-node. */ - -extern const unsigned char tree_code_length[]; #define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)] -/* Names of tree components. */ - -extern const char *const tree_code_name[]; - -/* When procesing aliases on symtab level, we need the declaration of target. - For this reason we need to queue aliases and process them after all declarations - has been produced. */ - -typedef struct GTY(()) alias_pair -{ - tree decl; - tree target; -} alias_pair; - -/* Define gc'd vector type. */ - -extern GTY(()) vec *alias_pairs; - - -/* Classify which part of the compiler has defined a given builtin function. - Note that we assume below that this is no more than two bits. */ -enum built_in_class -{ - NOT_BUILT_IN = 0, - BUILT_IN_FRONTEND, - BUILT_IN_MD, - BUILT_IN_NORMAL -}; - -/* Last marker used for LTO stremaing of built_in_class. We can not add it - to the enum since we need the enumb to fit in 2 bits. */ -#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1) - -/* Names for the above. */ -extern const char *const built_in_class_names[4]; - -/* 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, IM, COND) ENUM, -enum built_in_function -{ -#include "builtins.def" - - /* 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, - BUILT_IN_COMPLEX_MUL_MAX - = BUILT_IN_COMPLEX_MUL_MIN - + MAX_MODE_COMPLEX_FLOAT - - MIN_MODE_COMPLEX_FLOAT, - - BUILT_IN_COMPLEX_DIV_MIN, - BUILT_IN_COMPLEX_DIV_MAX - = BUILT_IN_COMPLEX_DIV_MIN - + MAX_MODE_COMPLEX_FLOAT - - MIN_MODE_COMPLEX_FLOAT, - - /* Upper bound on non-language-specific builtins. */ - END_BUILTINS -}; -#undef DEF_BUILTIN - -/* Names for the above. */ -extern const char * built_in_names[(int) END_BUILTINS]; /* Helper macros for math builtins. */ @@ -323,438 +200,6 @@ extern const char * built_in_names[(int) END_BUILTINS]; #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX - -/* In an OMP_CLAUSE node. */ - -/* Number of operands and names for each clause. */ -extern unsigned const char omp_clause_num_ops[]; -extern const char * const omp_clause_code_name[]; - -/* Clause codes. Do not reorder, as this is used to index into the tables - omp_clause_num_ops and omp_clause_code_name. */ -enum omp_clause_code -{ - /* Clause zero is special-cased inside the parser - (c_parser_omp_variable_list). */ - OMP_CLAUSE_ERROR = 0, - - /* OpenMP clause: private (variable_list). */ - OMP_CLAUSE_PRIVATE, - - /* OpenMP clause: shared (variable_list). */ - OMP_CLAUSE_SHARED, - - /* OpenMP clause: firstprivate (variable_list). */ - OMP_CLAUSE_FIRSTPRIVATE, - - /* OpenMP clause: lastprivate (variable_list). */ - OMP_CLAUSE_LASTPRIVATE, - - /* 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}. */ - OMP_CLAUSE_REDUCTION, - - /* OpenMP clause: copyin (variable_list). */ - OMP_CLAUSE_COPYIN, - - /* OpenMP clause: copyprivate (variable_list). */ - OMP_CLAUSE_COPYPRIVATE, - - /* OpenMP clause: linear (variable-list[:linear-step]). */ - OMP_CLAUSE_LINEAR, - - /* OpenMP clause: uniform (argument-list). */ - OMP_CLAUSE_UNIFORM, - - /* OpenMP clause: if (scalar-expression). */ - OMP_CLAUSE_IF, - - /* OpenMP clause: num_threads (integer-expression). */ - OMP_CLAUSE_NUM_THREADS, - - /* OpenMP clause: schedule. */ - OMP_CLAUSE_SCHEDULE, - - /* OpenMP clause: nowait. */ - OMP_CLAUSE_NOWAIT, - - /* OpenMP clause: ordered. */ - OMP_CLAUSE_ORDERED, - - /* OpenMP clause: default. */ - OMP_CLAUSE_DEFAULT, - - /* OpenMP clause: collapse (constant-integer-expression). */ - OMP_CLAUSE_COLLAPSE, - - /* OpenMP clause: untied. */ - OMP_CLAUSE_UNTIED, - - /* OpenMP clause: final (scalar-expression). */ - OMP_CLAUSE_FINAL, - - /* OpenMP clause: mergeable. */ - OMP_CLAUSE_MERGEABLE, - - /* OpenMP clause: safelen (constant-integer-expression). */ - OMP_CLAUSE_SAFELEN, - - /* Internally used only clause, holding SIMD uid. */ - OMP_CLAUSE__SIMDUID_ -}; - -/* The definition of tree nodes fills the next several pages. */ - -/* A tree node can represent a data type, a variable, an expression - or a statement. Each node has a TREE_CODE which says what kind of - thing it represents. Some common codes are: - INTEGER_TYPE -- represents a type of integers. - ARRAY_TYPE -- represents a type of pointer. - VAR_DECL -- represents a declared variable. - INTEGER_CST -- represents a constant integer value. - PLUS_EXPR -- represents a sum (an expression). - - As for the contents of a tree node: there are some fields - that all nodes share. Each TREE_CODE has various special-purpose - fields as well. The fields of a node are never accessed directly, - always through accessor macros. */ - -/* Every kind of tree node starts with this structure, - so all nodes have these fields. - - See the accessor macros, defined below, for documentation of the - fields, and the table below which connects the fields and the - accessor macros. */ - -struct GTY(()) tree_base { - ENUM_BITFIELD(tree_code) code : 16; - - unsigned side_effects_flag : 1; - unsigned constant_flag : 1; - unsigned addressable_flag : 1; - unsigned volatile_flag : 1; - unsigned readonly_flag : 1; - unsigned asm_written_flag: 1; - unsigned nowarning_flag : 1; - unsigned visited : 1; - - unsigned used_flag : 1; - unsigned nothrow_flag : 1; - unsigned static_flag : 1; - unsigned public_flag : 1; - unsigned private_flag : 1; - unsigned protected_flag : 1; - unsigned deprecated_flag : 1; - unsigned default_def_flag : 1; - - union { - /* The bits in the following structure should only be used with - accessor macros that constrain inputs with tree checking. */ - struct { - unsigned lang_flag_0 : 1; - unsigned lang_flag_1 : 1; - unsigned lang_flag_2 : 1; - unsigned lang_flag_3 : 1; - unsigned lang_flag_4 : 1; - unsigned lang_flag_5 : 1; - unsigned lang_flag_6 : 1; - unsigned saturating_flag : 1; - - unsigned unsigned_flag : 1; - unsigned packed_flag : 1; - unsigned user_align : 1; - unsigned nameless_flag : 1; - unsigned spare0 : 4; - - unsigned spare1 : 8; - - /* This field is only used with TREE_TYPE nodes; the only reason it is - present in tree_base instead of tree_type is to save space. The size - 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. */ - /* 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; - } GTY((skip(""))) u; -}; - -/* The following table lists the uses of each of the above flags and - for which types of nodes they are defined. - - addressable_flag: - - TREE_ADDRESSABLE in - VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL - SSA_NAME - all types - CONSTRUCTOR, IDENTIFIER_NODE - STMT_EXPR - - CALL_EXPR_TAILCALL in - CALL_EXPR - - CASE_LOW_SEEN in - CASE_LABEL_EXPR - - PREDICT_EXPR_OUTCOME in - PREDICT_EXPR - - static_flag: - - TREE_STATIC in - VAR_DECL, FUNCTION_DECL - CONSTRUCTOR - - TREE_NO_TRAMPOLINE in - ADDR_EXPR - - BINFO_VIRTUAL_P in - TREE_BINFO - - TREE_SYMBOL_REFERENCED in - IDENTIFIER_NODE - - CLEANUP_EH_ONLY in - TARGET_EXPR, WITH_CLEANUP_EXPR - - TRY_CATCH_IS_CLEANUP in - TRY_CATCH_EXPR - - ASM_INPUT_P in - ASM_EXPR - - TYPE_REF_CAN_ALIAS_ALL in - POINTER_TYPE, REFERENCE_TYPE - - CASE_HIGH_SEEN in - CASE_LABEL_EXPR - - ENUM_IS_SCOPED in - ENUMERAL_TYPE - - TRANSACTION_EXPR_OUTER in - TRANSACTION_EXPR - - public_flag: - - TREE_OVERFLOW in - INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST - - TREE_PUBLIC in - VAR_DECL, FUNCTION_DECL - IDENTIFIER_NODE - - ASM_VOLATILE_P in - ASM_EXPR - - CALL_EXPR_VA_ARG_PACK in - CALL_EXPR - - TYPE_CACHED_VALUES_P in - all types - - SAVE_EXPR_RESOLVED_P in - SAVE_EXPR - - OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in - OMP_CLAUSE_LASTPRIVATE - - OMP_CLAUSE_PRIVATE_DEBUG in - OMP_CLAUSE_PRIVATE - - OMP_CLAUSE_LINEAR_NO_COPYIN in - OMP_CLAUSE_LINEAR - - TRANSACTION_EXPR_RELAXED in - TRANSACTION_EXPR - - private_flag: - - TREE_PRIVATE in - all decls - - CALL_EXPR_RETURN_SLOT_OPT in - CALL_EXPR - - OMP_SECTION_LAST in - OMP_SECTION - - OMP_PARALLEL_COMBINED in - OMP_PARALLEL - - OMP_CLAUSE_PRIVATE_OUTER_REF in - OMP_CLAUSE_PRIVATE - - OMP_CLAUSE_LINEAR_NO_COPYOUT in - OMP_CLAUSE_LINEAR - - TYPE_REF_IS_RVALUE in - REFERENCE_TYPE - - ENUM_IS_OPAQUE in - ENUMERAL_TYPE - - protected_flag: - - TREE_PROTECTED in - BLOCK - all decls - - CALL_FROM_THUNK_P and - CALL_ALLOCA_FOR_VAR_P in - CALL_EXPR - - side_effects_flag: - - TREE_SIDE_EFFECTS in - all expressions - all decls - all constants - - FORCED_LABEL in - LABEL_DECL - - volatile_flag: - - TREE_THIS_VOLATILE in - all expressions - all decls - - TYPE_VOLATILE in - all types - - readonly_flag: - - TREE_READONLY in - all expressions - all decls - - TYPE_READONLY in - all types - - constant_flag: - - TREE_CONSTANT in - all expressions - all decls - all constants - - TYPE_SIZES_GIMPLIFIED in - all types - - unsigned_flag: - - TYPE_UNSIGNED in - all types - - DECL_UNSIGNED in - all decls - - asm_written_flag: - - TREE_ASM_WRITTEN in - VAR_DECL, FUNCTION_DECL, TYPE_DECL - RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE - BLOCK, STRING_CST - - SSA_NAME_OCCURS_IN_ABNORMAL_PHI in - SSA_NAME - - used_flag: - - TREE_USED in - all expressions - all decls - IDENTIFIER_NODE - - nothrow_flag: - - TREE_NOTHROW 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 - - deprecated_flag: - - TREE_DEPRECATED in - all decls - all types - - IDENTIFIER_TRANSPARENT_ALIAS in - IDENTIFIER_NODE - - visited: - - TREE_VISITED in - all trees (used liberally by many passes) - - saturating_flag: - - TYPE_SATURATING in - all types - - VAR_DECL_IS_VIRTUAL_OPERAND in - VAR_DECL - - nowarning_flag: - - TREE_NO_WARNING in - all expressions - all decls - - TYPE_ARTIFICIAL in - all types - - default_def_flag: - - TYPE_VECTOR_OPAQUE in - VECTOR_TYPE - - SSA_NAME_IS_DEFAULT_DEF in - SSA_NAME - - DECL_NONLOCAL_FRAME in - VAR_DECL - - TYPE_FINAL_P in - RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE -*/ - -struct GTY(()) tree_typed { - struct tree_base base; - tree type; -}; - -struct GTY(()) tree_common { - struct tree_typed typed; - tree chain; -}; - -#undef DEFTREESTRUCT -#define DEFTREESTRUCT(ENUM, NAME) ENUM, -enum tree_node_structure_enum { -#include "treestruct.def" - LAST_TS_ENUM -}; -#undef DEFTREESTRUCT /* Define accessors for the fields that all tree nodes have (though some fields are not used for all kinds of nodes). */ @@ -1439,70 +884,28 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) -struct GTY(()) tree_int_cst { - struct tree_typed typed; - double_int int_cst; -}; - -/* 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 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 GTY(()) tree_real_cst { - struct tree_typed typed; - struct real_value * real_cst_ptr; -}; - -/* In a FIXED_CST node. */ -struct fixed_value; - #define TREE_FIXED_CST_PTR(NODE) \ (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr) #define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE)) -struct GTY(()) tree_fixed_cst { - struct tree_typed typed; - struct fixed_value * fixed_cst_ptr; -}; - /* In a STRING_CST */ /* In C terms, this is sizeof, not strlen. */ #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length) #define TREE_STRING_POINTER(NODE) \ ((const char *)(STRING_CST_CHECK (NODE)->string.str)) -struct GTY(()) tree_string { - struct tree_typed typed; - int length; - char str[1]; -}; - /* In a COMPLEX_CST node. */ #define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real) #define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag) -struct GTY(()) tree_complex { - struct tree_typed typed; - tree real; - tree imag; -}; - /* In a VECTOR_CST node. */ #define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE))) #define VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elts) #define VECTOR_CST_ELT(NODE,IDX) (VECTOR_CST_CHECK (NODE)->vector.elts[IDX]) -struct GTY(()) tree_vector { - struct tree_typed typed; - tree GTY ((length ("TYPE_VECTOR_SUBPARTS (TREE_TYPE ((tree)&%h))"))) elts[1]; -}; - -#include "symtab.h" - /* Define fields and accessors for some special-purpose tree nodes. */ #define IDENTIFIER_LENGTH(NODE) \ @@ -1519,21 +922,10 @@ struct GTY(()) tree_vector { ((tree) ((char *) (NODE) - sizeof (struct tree_common))) #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id) -struct GTY(()) tree_identifier { - struct tree_common common; - struct ht_identifier id; -}; - /* In a TREE_LIST node. */ #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose) #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value) -struct GTY(()) tree_list { - struct tree_common common; - tree purpose; - tree value; -}; - /* In a TREE_VEC node. */ #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length) #define TREE_VEC_END(NODE) \ @@ -1541,11 +933,6 @@ struct GTY(()) tree_list { #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I) -struct GTY(()) tree_vec { - struct tree_common common; - tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1]; -}; - /* In a CONSTRUCTOR node. */ #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts) #define CONSTRUCTOR_ELT(NODE,IDX) \ @@ -1594,21 +981,6 @@ struct GTY(()) tree_vec { #define TREE_CLOBBER_P(NODE) \ (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE)) -/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the - element. INDEX can optionally design the position of VALUE: in arrays, - it is the index where VALUE has to be placed; in structures, it is the - FIELD_DECL of the member. */ -typedef struct GTY(()) constructor_elt_d { - tree index; - tree value; -} constructor_elt; - - -struct GTY(()) tree_constructor { - struct tree_typed typed; - vec *elts; -}; - /* Define fields and accessors for some nodes that represent expressions. */ /* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */ @@ -1907,38 +1279,12 @@ extern void protected_set_expr_location (tree, location_t); #define OMP_CLAUSE__SIMDUID__DECL(NODE) \ OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0) -enum omp_clause_schedule_kind -{ - OMP_CLAUSE_SCHEDULE_STATIC, - OMP_CLAUSE_SCHEDULE_DYNAMIC, - OMP_CLAUSE_SCHEDULE_GUIDED, - OMP_CLAUSE_SCHEDULE_AUTO, - OMP_CLAUSE_SCHEDULE_RUNTIME -}; - #define OMP_CLAUSE_SCHEDULE_KIND(NODE) \ (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind) -enum omp_clause_default_kind -{ - OMP_CLAUSE_DEFAULT_UNSPECIFIED, - OMP_CLAUSE_DEFAULT_SHARED, - OMP_CLAUSE_DEFAULT_NONE, - OMP_CLAUSE_DEFAULT_PRIVATE, - OMP_CLAUSE_DEFAULT_FIRSTPRIVATE -}; - #define OMP_CLAUSE_DEFAULT_KIND(NODE) \ (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind) -struct GTY(()) tree_exp { - struct tree_typed typed; - location_t locus; - tree GTY ((special ("tree_exp"), - desc ("TREE_CODE ((tree) &%0)"))) - operands[1]; -}; - /* SSA_NAME accessors. */ /* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE @@ -1992,51 +1338,9 @@ struct GTY(()) tree_exp { #define SSA_NAME_PTR_INFO(N) \ SSA_NAME_CHECK (N)->ssa_name.ptr_info -/* Defined in tree-flow.h. */ -struct ptr_info_def; - -/* Immediate use linking structure. This structure is used for maintaining - a doubly linked list of uses of an SSA_NAME. */ -typedef struct GTY(()) ssa_use_operand_d { - struct ssa_use_operand_d* GTY((skip(""))) prev; - struct ssa_use_operand_d* GTY((skip(""))) next; - /* Immediate uses for a given SSA name are maintained as a cyclic - list. To recognize the root of this list, the location field - 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 immediate_use_iterator_d. */ - union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc; - tree *GTY((skip(""))) use; -} ssa_use_operand_t; - /* Return the immediate_use information for an SSA_NAME. */ #define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses -struct GTY(()) tree_ssa_name { - struct tree_typed typed; - - /* _DECL wrapped by this SSA name. */ - tree var; - - /* Statement that defines this SSA name. */ - gimple def_stmt; - - /* Pointer attributes used for alias analysis. */ - struct ptr_info_def *ptr_info; - - /* Immediate uses list for this SSA_NAME. */ - struct ssa_use_operand_d imm_uses; -}; - -struct GTY(()) phi_arg_d { - /* imm_use MUST be the first element in struct because we do some - pointer arithmetic with it. See phi_arg_index_from_use. */ - struct ssa_use_operand_d imm_use; - tree def; - location_t locus; -}; - - #define OMP_CLAUSE_CODE(NODE) \ (OMP_CLAUSE_CHECK (NODE))->omp_clause.code @@ -2049,25 +1353,6 @@ struct GTY(()) phi_arg_d { #define OMP_CLAUSE_OPERAND(NODE, I) \ OMP_CLAUSE_ELT_CHECK (NODE, I) -struct GTY(()) tree_omp_clause { - struct tree_common common; - location_t locus; - enum omp_clause_code code; - union omp_clause_subcode { - enum omp_clause_default_kind default_kind; - enum omp_clause_schedule_kind schedule_kind; - enum tree_code reduction_code; - } GTY ((skip)) subcode; - - /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's - usage. */ - gimple_seq gimple_reduction_init; - gimple_seq gimple_reduction_merge; - - tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1]; -}; - - /* In a BLOCK node. */ #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars) #define BLOCK_NONLOCALIZED_VARS(NODE) \ @@ -2120,25 +1405,6 @@ struct GTY(()) tree_omp_clause { #define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus) -struct GTY(()) tree_block { - struct tree_base base; - tree chain; - - unsigned abstract_flag : 1; - unsigned block_num : 31; - - location_t locus; - - tree vars; - vec *nonlocalized_vars; - - tree subblocks; - tree supercontext; - tree abstract_origin; - tree fragment_origin; - tree fragment_chain; -}; - /* Define fields and accessors for nodes representing data types. */ /* See tree.def for documentation of the use of these fields. @@ -2258,17 +1524,6 @@ extern enum machine_mode vector_type_mode (const_tree); /* The address space the type is in. */ #define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space) -/* 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. */ -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. */ #define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8) @@ -2388,58 +1643,9 @@ enum cv_qualifier #define TYPE_SYMTAB_IS_POINTER (1) #define TYPE_SYMTAB_IS_DIE (2) -struct die_struct; - -struct GTY(()) tree_type_common { - struct tree_common common; - tree size; - tree size_unit; - tree attributes; - unsigned int uid; - - unsigned int precision : 10; - unsigned no_force_blk_flag : 1; - unsigned needs_constructing_flag : 1; - unsigned transparent_aggr_flag : 1; - unsigned restrict_flag : 1; - unsigned contains_placeholder_bits : 2; - - ENUM_BITFIELD(machine_mode) mode : 8; - - unsigned string_flag : 1; - unsigned lang_flag_0 : 1; - unsigned lang_flag_1 : 1; - unsigned lang_flag_2 : 1; - unsigned lang_flag_3 : 1; - unsigned lang_flag_4 : 1; - unsigned lang_flag_5 : 1; - unsigned lang_flag_6 : 1; - - unsigned int align; - alias_set_type alias_set; - tree pointer_to; - tree reference_to; - union tree_type_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 next_variant; - tree main_variant; - tree context; - tree canonical; -}; - #define TYPE_LANG_SPECIFIC(NODE) \ (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific) -struct GTY(()) tree_type_with_lang_specific { - struct tree_type_common common; - /* Points to a structure whose details depend on the language in use. */ - struct lang_type *lang_specific; -}; - #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values) #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values) #define TYPE_FIELDS(NODE) \ @@ -2482,14 +1688,6 @@ struct GTY(()) tree_type_with_lang_specific { #define TYPE_LANG_SLOT_1(NODE) \ (NOT_RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo) -struct GTY(()) tree_type_non_common { - struct tree_type_with_lang_specific with_lang_specific; - tree values; - tree minval; - tree maxval; - tree binfo; -}; - /* Define accessor macros for information about type inheritance and basetypes. @@ -2593,23 +1791,7 @@ struct GTY(()) tree_type_non_common { #define BINFO_INHERITANCE_CHAIN(NODE) \ (TREE_BINFO_CHECK(NODE)->binfo.inheritance) -struct GTY (()) tree_binfo { - struct tree_common common; - tree offset; - tree vtable; - tree virtuals; - tree vptr_field; - vec *base_accesses; - tree inheritance; - - tree vtt_subvtt; - tree vtt_vptr; - - vec base_binfos; -}; - - /* Define fields and accessors for nodes representing declared names. */ /* Nonzero if DECL represents an SSA name or a variable that can possibly @@ -2621,21 +1803,6 @@ struct GTY (()) tree_binfo { || TREE_CODE (DECL) == SSA_NAME) - -/* Enumerate visibility settings. */ -#ifndef SYMBOL_VISIBILITY_DEFINED -#define SYMBOL_VISIBILITY_DEFINED -enum symbol_visibility -{ - VISIBILITY_DEFAULT, - VISIBILITY_PROTECTED, - VISIBILITY_HIDDEN, - VISIBILITY_INTERNAL -}; -#endif - -struct function; - #define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE))) /* This is the name of the object as written by the user. @@ -2690,15 +1857,6 @@ struct function; /* If nonzero, decl's name shouldn't be emitted into debug info. */ #define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag) -struct GTY(()) tree_decl_minimal { - struct tree_common common; - location_t locus; - unsigned int uid; - tree name; - tree context; -}; - - /* For any sort of a ..._DECL node, this points to the original (abstract) decl node which this decl is an inlined/cloned instance of, or else it is NULL indicating that this decl is not an instance of some other decl. @@ -2856,72 +2014,6 @@ struct GTY(()) tree_decl_minimal { #define DECL_GIMPLE_REG_P(DECL) \ DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag -struct GTY(()) tree_decl_common { - struct tree_decl_minimal common; - tree size; - - ENUM_BITFIELD(machine_mode) mode : 8; - - unsigned nonlocal_flag : 1; - unsigned virtual_flag : 1; - unsigned ignored_flag : 1; - unsigned abstract_flag : 1; - unsigned artificial_flag : 1; - unsigned preserve_flag: 1; - unsigned debug_expr_is_from : 1; - - unsigned lang_flag_0 : 1; - unsigned lang_flag_1 : 1; - unsigned lang_flag_2 : 1; - unsigned lang_flag_3 : 1; - unsigned lang_flag_4 : 1; - unsigned lang_flag_5 : 1; - unsigned lang_flag_6 : 1; - unsigned lang_flag_7 : 1; - unsigned lang_flag_8 : 1; - - /* In VAR_DECL and PARM_DECL, this is DECL_REGISTER. */ - unsigned decl_flag_0 : 1; - /* In FIELD_DECL, this is DECL_BIT_FIELD - In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL. - 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, PARM_DECL and RESULT_DECL, this is - DECL_HAS_VALUE_EXPR_P. */ - unsigned decl_flag_2 : 1; - /* 1 bit unused. */ - unsigned decl_flag_3 : 1; - /* Logically, these two would go in a theoretical base shared by var and - parm decl. */ - unsigned gimple_reg_flag : 1; - /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */ - unsigned decl_by_reference_flag : 1; - /* In a VAR_DECL and PARM_DECL, this is DECL_READ_P. */ - unsigned decl_read_flag : 1; - /* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE. */ - unsigned decl_nonshareable_flag : 1; - - /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ - unsigned int off_align : 8; - - /* 24 bits unused. */ - - /* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */ - unsigned int align; - - /* UID for points-to sets, stable over copying from inlining. */ - unsigned int pt_uid; - - tree size_unit; - tree initial; - tree attributes; - tree abstract_origin; - - /* Points to a structure whose details depend on the language in use. */ - struct lang_decl *lang_specific; -}; - extern tree decl_value_expr_lookup (tree); extern void decl_value_expr_insert (tree, tree); @@ -2978,11 +2070,6 @@ extern void decl_value_expr_insert (tree, tree); /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */ #define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0) -struct GTY(()) tree_decl_with_rtl { - struct tree_decl_common common; - rtx rtl; -}; - /* In a FIELD_DECL, this is the field position, counting in bytes, of the DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning of the structure. */ @@ -3051,16 +2138,6 @@ struct GTY(()) tree_decl_with_rtl { #define DECL_NONADDRESSABLE_P(NODE) \ (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2) -struct GTY(()) tree_field_decl { - struct tree_decl_common common; - - tree offset; - tree bit_field_type; - tree qualifier; - tree bit_offset; - tree fcontext; -}; - /* 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. If the value is -1, then no UID has been assigned. */ @@ -3072,20 +2149,6 @@ struct GTY(()) tree_field_decl { #define EH_LANDING_PAD_NR(NODE) \ (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr) -struct GTY(()) tree_label_decl { - struct tree_decl_with_rtl common; - int label_decl_uid; - int eh_landing_pad_nr; -}; - -struct GTY(()) tree_result_decl { - struct tree_decl_with_rtl common; -}; - -struct GTY(()) tree_const_decl { - struct tree_decl_common common; -}; - /* For a PARM_DECL, records the data type used to pass the argument, which may be different from the type seen in the program. */ #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial) @@ -3095,12 +2158,6 @@ struct GTY(()) tree_const_decl { #define DECL_INCOMING_RTL(NODE) \ (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl) -struct GTY(()) tree_parm_decl { - struct tree_decl_with_rtl common; - rtx incoming_rtl; -}; - - /* Nonzero for a given ..._DECL node means that no warnings should be generated just because this node is unused. */ #define DECL_IN_SYSTEM_HEADER(NODE) \ @@ -3233,46 +2290,9 @@ struct GTY(()) tree_parm_decl { #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; - tree section_name; - tree comdat_group; - - /* Belong to VAR_DECL exclusively. */ - unsigned defer_output : 1; - unsigned hard_register : 1; - unsigned common_flag : 1; - unsigned in_text_section : 1; - unsigned in_constant_pool : 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; - 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; - /* Used by C++ only. Might become a generic decl flag. */ - unsigned shadowed_for_var_p : 1; - /* Belong to FUNCTION_DECL exclusively. */ - unsigned cxx_constructor : 1; - /* Belong to FUNCTION_DECL exclusively. */ - unsigned cxx_destructor : 1; - /* Belong to FUNCTION_DECL exclusively. */ - unsigned final : 1; - /* 11 unused bits. */ -}; - extern tree decl_debug_expr_lookup (tree); extern void decl_debug_expr_insert (tree, tree); + /* For VAR_DECL, this is set to an expression that it was split from. */ #define DECL_HAS_DEBUG_EXPR_P(NODE) \ (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from) @@ -3282,9 +2302,6 @@ extern void decl_debug_expr_insert (tree, tree); #define SET_DECL_DEBUG_EXPR(NODE, VAL) \ (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL)) -/* An initialization priority. */ -typedef unsigned short priority_type; - extern priority_type decl_init_priority_lookup (tree); extern priority_type decl_fini_priority_lookup (tree); extern void decl_init_priority_insert (tree, priority_type); @@ -3324,11 +2341,6 @@ extern void decl_fini_priority_insert (tree, priority_type); #define DECL_NONLOCAL_FRAME(NODE) \ (VAR_DECL_CHECK (NODE)->base.default_def_flag) -struct GTY(()) tree_var_decl { - struct tree_decl_with_vis common; -}; - - /* This field is used to reference anything in decl.result and is meant only for use by the garbage collector. */ #define DECL_RESULT_FLD(NODE) \ @@ -3345,19 +2357,6 @@ struct GTY(()) tree_var_decl { #define DECL_VINDEX(NODE) \ (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex) -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; -}; - /* In FUNCTION_DECL, holds the decl for the return value. */ #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result) @@ -3540,66 +2539,12 @@ extern vec **decl_debug_args_insert (tree); FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL, which seemed a bit strange. */ -struct GTY(()) tree_function_decl { - struct tree_decl_non_common common; - - struct function *f; - - /* The personality function. Used for stack unwinding. */ - tree personality; - - /* Function specific options that are used by this function. */ - tree function_specific_target; /* target options */ - tree function_specific_optimization; /* optimization options */ - - /* 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_class) built_in_class : 2; - - unsigned static_ctor_flag : 1; - unsigned static_dtor_flag : 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; - unsigned no_limit_stack : 1; - unsigned disregard_inline_limits : 1; - unsigned pure_flag : 1; - unsigned looping_const_or_pure_flag : 1; - unsigned has_debug_args_flag : 1; - unsigned tm_clone_flag : 1; - unsigned versioned_function : 1; - /* No bits left. */ -}; - /* The source language of the translation-unit. */ #define TRANSLATION_UNIT_LANGUAGE(NODE) \ (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language) /* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL. */ -struct GTY(()) tree_translation_unit_decl { - struct tree_decl_common common; - /* Source language of this translation unit. Used for DWARF output. */ - const char * GTY((skip(""))) language; - /* TODO: Non-optimization used to build this translation unit. */ - /* TODO: Root of a partial DWARF tree for global types and decls. */ -}; - -/* A vector of all translation-units. */ -extern GTY (()) vec *all_translation_units; - /* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */ #define DECL_ORIGINAL_TYPE(NODE) \ (TYPE_DECL_CHECK (NODE)->decl_non_common.result) @@ -3615,11 +2560,6 @@ extern GTY (()) vec *all_translation_units; #define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \ (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE))) -struct GTY(()) tree_type_decl { - struct tree_decl_non_common common; - -}; - /* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE. To reduce overhead, the nodes containing the statements are not trees. This avoids the overhead of tree_common on all linked list elements. @@ -3631,38 +2571,6 @@ struct GTY(()) tree_type_decl { #define STATEMENT_LIST_TAIL(NODE) \ (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail) -struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node - { - struct tree_statement_list_node *prev; - struct tree_statement_list_node *next; - tree stmt; -}; - -struct GTY(()) tree_statement_list - { - struct tree_typed typed; - struct tree_statement_list_node *head; - struct tree_statement_list_node *tail; -}; - - -/* Optimization options used by a function. */ - -struct GTY(()) tree_optimization_option { - struct tree_common common; - - /* The optimization options used by the user. */ - struct cl_optimization opts; - - /* Target optabs for this set of optimization options. This is of - type `struct target_optabs *'. */ - unsigned char *GTY ((atomic)) optabs; - - /* The value of this_target_optabs against which the optabs above were - generated. */ - struct target_optabs *GTY ((skip)) base_optabs; -}; - #define TREE_OPTIMIZATION(NODE) \ (&OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts) @@ -3677,71 +2585,12 @@ extern tree build_optimization_node (void); extern void init_tree_optimization_optabs (tree); -/* Target options used by a function. */ - -struct GTY(()) tree_target_option { - struct tree_common common; - - /* The optimization options used by the user. */ - struct cl_target_option opts; -}; - #define TREE_TARGET_OPTION(NODE) \ (&TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts) /* Return a tree node that encapsulates the current target options. */ extern tree build_target_option_node (void); - -/* Define the overall contents of a tree node. - It may be any of the structures declared above - for various types of node. */ - -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; - struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst; - struct tree_vector GTY ((tag ("TS_VECTOR"))) vector; - struct tree_string GTY ((tag ("TS_STRING"))) string; - struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex; - struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier; - struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal; - struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common; - struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl; - struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common; - struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl; - struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis; - struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl; - struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl; - struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl; - struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl; - struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl; - struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl; - struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl; - struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL"))) - translation_unit_decl; - struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common; - struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC"))) - type_with_lang_specific; - struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON"))) - type_non_common; - struct tree_list GTY ((tag ("TS_LIST"))) list; - struct tree_vec GTY ((tag ("TS_VEC"))) vec; - struct tree_exp GTY ((tag ("TS_EXP"))) exp; - struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; - struct tree_block GTY ((tag ("TS_BLOCK"))) block; - struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo; - struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; - struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor; - struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause; - struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization; - struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option; -}; - #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) inline tree @@ -4221,167 +3070,6 @@ tree_operand_check_code (const_tree __t, enum tree_code __code, int __i, #endif - -/* Standard named or nameless data types of the C compiler. */ - -enum tree_index -{ - TI_ERROR_MARK, - TI_INTQI_TYPE, - TI_INTHI_TYPE, - TI_INTSI_TYPE, - TI_INTDI_TYPE, - TI_INTTI_TYPE, - - TI_UINTQI_TYPE, - TI_UINTHI_TYPE, - TI_UINTSI_TYPE, - TI_UINTDI_TYPE, - TI_UINTTI_TYPE, - - TI_UINT16_TYPE, - TI_UINT32_TYPE, - TI_UINT64_TYPE, - - TI_INTEGER_ZERO, - TI_INTEGER_ONE, - TI_INTEGER_THREE, - TI_INTEGER_MINUS_ONE, - TI_NULL_POINTER, - - TI_SIZE_ZERO, - TI_SIZE_ONE, - - TI_BITSIZE_ZERO, - TI_BITSIZE_ONE, - TI_BITSIZE_UNIT, - - TI_PUBLIC, - TI_PROTECTED, - TI_PRIVATE, - - TI_BOOLEAN_FALSE, - TI_BOOLEAN_TRUE, - - 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_FLOAT_PTR_TYPE, - TI_DOUBLE_PTR_TYPE, - TI_LONG_DOUBLE_PTR_TYPE, - TI_INTEGER_PTR_TYPE, - - TI_VOID_TYPE, - TI_PTR_TYPE, - TI_CONST_PTR_TYPE, - TI_SIZE_TYPE, - TI_PID_TYPE, - TI_PTRDIFF_TYPE, - TI_VA_LIST_TYPE, - TI_VA_LIST_GPR_COUNTER_FIELD, - TI_VA_LIST_FPR_COUNTER_FIELD, - TI_BOOLEAN_TYPE, - TI_FILEPTR_TYPE, - TI_POINTER_SIZED_TYPE, - - TI_DFLOAT32_TYPE, - TI_DFLOAT64_TYPE, - TI_DFLOAT128_TYPE, - TI_DFLOAT32_PTR_TYPE, - TI_DFLOAT64_PTR_TYPE, - TI_DFLOAT128_PTR_TYPE, - - TI_VOID_LIST_NODE, - - TI_MAIN_IDENTIFIER, - - TI_SAT_SFRACT_TYPE, - TI_SAT_FRACT_TYPE, - TI_SAT_LFRACT_TYPE, - TI_SAT_LLFRACT_TYPE, - TI_SAT_USFRACT_TYPE, - TI_SAT_UFRACT_TYPE, - TI_SAT_ULFRACT_TYPE, - TI_SAT_ULLFRACT_TYPE, - TI_SFRACT_TYPE, - TI_FRACT_TYPE, - TI_LFRACT_TYPE, - TI_LLFRACT_TYPE, - TI_USFRACT_TYPE, - TI_UFRACT_TYPE, - TI_ULFRACT_TYPE, - TI_ULLFRACT_TYPE, - TI_SAT_SACCUM_TYPE, - TI_SAT_ACCUM_TYPE, - TI_SAT_LACCUM_TYPE, - TI_SAT_LLACCUM_TYPE, - TI_SAT_USACCUM_TYPE, - TI_SAT_UACCUM_TYPE, - TI_SAT_ULACCUM_TYPE, - TI_SAT_ULLACCUM_TYPE, - TI_SACCUM_TYPE, - TI_ACCUM_TYPE, - TI_LACCUM_TYPE, - TI_LLACCUM_TYPE, - TI_USACCUM_TYPE, - TI_UACCUM_TYPE, - TI_ULACCUM_TYPE, - TI_ULLACCUM_TYPE, - TI_QQ_TYPE, - TI_HQ_TYPE, - TI_SQ_TYPE, - TI_DQ_TYPE, - TI_TQ_TYPE, - TI_UQQ_TYPE, - TI_UHQ_TYPE, - TI_USQ_TYPE, - TI_UDQ_TYPE, - TI_UTQ_TYPE, - TI_SAT_QQ_TYPE, - TI_SAT_HQ_TYPE, - TI_SAT_SQ_TYPE, - TI_SAT_DQ_TYPE, - TI_SAT_TQ_TYPE, - TI_SAT_UQQ_TYPE, - TI_SAT_UHQ_TYPE, - TI_SAT_USQ_TYPE, - TI_SAT_UDQ_TYPE, - TI_SAT_UTQ_TYPE, - TI_HA_TYPE, - TI_SA_TYPE, - TI_DA_TYPE, - TI_TA_TYPE, - TI_UHA_TYPE, - TI_USA_TYPE, - TI_UDA_TYPE, - TI_UTA_TYPE, - TI_SAT_HA_TYPE, - TI_SAT_SA_TYPE, - TI_SAT_DA_TYPE, - TI_SAT_TA_TYPE, - TI_SAT_UHA_TYPE, - TI_SAT_USA_TYPE, - TI_SAT_UDA_TYPE, - TI_SAT_UTA_TYPE, - - TI_OPTIMIZATION_DEFAULT, - TI_OPTIMIZATION_CURRENT, - TI_TARGET_OPTION_DEFAULT, - TI_TARGET_OPTION_CURRENT, - TI_CURRENT_TARGET_PRAGMA, - TI_CURRENT_OPTIMIZE_PRAGMA, - - TI_MAX -}; - -extern GTY(()) tree global_trees[TI_MAX]; - #define error_mark_node global_trees[TI_ERROR_MARK] #define intQI_type_node global_trees[TI_INTQI_TYPE] @@ -4562,34 +3250,6 @@ extern GTY(()) tree global_trees[TI_MAX]; #define current_target_pragma global_trees[TI_CURRENT_TARGET_PRAGMA] #define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_PRAGMA] -/* An enumeration of the standard C integer types. These must be - ordered so that shorter types appear before longer ones, and so - that signed types appear before unsigned ones, for the correct - functioning of interpret_integer() in c-lex.c. */ -enum integer_type_kind -{ - itk_char, - itk_signed_char, - itk_unsigned_char, - itk_short, - itk_unsigned_short, - itk_int, - itk_unsigned_int, - itk_long, - itk_unsigned_long, - itk_long_long, - itk_unsigned_long_long, - itk_int128, - itk_unsigned_int128, - itk_none -}; - -typedef enum integer_type_kind integer_type_kind; - -/* The standard C integer types. Use integer_type_kind to index into - this array. */ -extern GTY(()) tree integer_types[itk_none]; - #define char_type_node integer_types[itk_char] #define signed_char_type_node integer_types[itk_signed_char] #define unsigned_char_type_node integer_types[itk_unsigned_char] @@ -4603,34 +3263,7 @@ extern GTY(()) tree integer_types[itk_none]; #define long_long_unsigned_type_node integer_types[itk_unsigned_long_long] #define int128_integer_type_node integer_types[itk_int128] #define int128_unsigned_type_node integer_types[itk_unsigned_int128] - -/* 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 -}; - #define NULL_TREE (tree) NULL /* True if NODE is an erroneous expression. */ @@ -4987,82 +3620,7 @@ extern tree build_type_attribute_qual_variant (tree, tree, int); 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 -{ - /* The name of the attribute (without any leading or trailing __), - or NULL to mark the end of a table of attributes. */ - const char *name; - /* The minimum length of the list of arguments of the attribute. */ - int min_length; - /* The maximum length of the list of arguments of the attribute - (-1 for no maximum). */ - int max_length; - /* Whether this attribute requires a DECL. If it does, it will be passed - from types of DECLs, function return types and array element types to - the DECLs, function types and array types respectively; but when - applied to a type in any other circumstances, it will be ignored with - a warning. (If greater control is desired for a given attribute, - this should be false, and the flags argument to the handler may be - used to gain greater control in that case.) */ - bool decl_required; - /* Whether this attribute requires a type. If it does, it will be passed - from a DECL to the type of that DECL. */ - bool type_required; - /* Whether this attribute requires a function (or method) type. If it does, - it will be passed from a function pointer type to the target type, - and from a function return type (which is not itself a function - pointer type) to the function type. */ - bool function_type_required; - /* Function to handle this attribute. NODE points to the node to which - the attribute is to be applied. If a DECL, it should be modified in - place; if a TYPE, a copy should be created. NAME is the name of the - attribute (possibly with leading or trailing __). ARGS is the TREE_LIST - of the arguments (which may be NULL). FLAGS gives further information - about the context of the attribute. Afterwards, the attributes will - be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate, - unless *NO_ADD_ATTRS is set to true (which should be done on error, - as well as in any other cases when the attributes should not be added - to the DECL or TYPE). Depending on FLAGS, any attributes to be - applied to another type or DECL later may be returned; - otherwise the return value should be NULL_TREE. This pointer may be - NULL if no special handling is required beyond the checks implied - by the rest of this structure. */ - tree (*handler) (tree *node, tree name, tree args, - int flags, bool *no_add_attrs); - /* Specifies if attribute affects type's identity. */ - bool affects_type_identity; -}; - -/* Flags that may be passed in the third argument of decl_attributes, and - to handler functions for attributes. */ -enum attribute_flags -{ - /* The type passed in is the type of a DECL, and any attributes that - should be passed in again to be applied to the DECL rather than the - type should be returned. */ - ATTR_FLAG_DECL_NEXT = 1, - /* The type passed in is a function return type, and any attributes that - should be passed in again to be applied to the function type rather - than the return type should be returned. */ - ATTR_FLAG_FUNCTION_NEXT = 2, - /* The type passed in is an array element type, and any attributes that - should be passed in again to be applied to the array type rather - than the element type should be returned. */ - ATTR_FLAG_ARRAY_NEXT = 4, - /* The type passed in is a structure, union or enumeration type being - created, and should be modified in place. */ - ATTR_FLAG_TYPE_IN_PLACE = 8, - /* The attributes are being applied by default to a library function whose - name indicates known behavior, and should be silently ignored if they - are not in fact compatible with the function type. */ - ATTR_FLAG_BUILT_IN = 16, - /* A given attribute has been parsed as a C++-11 attribute. */ - ATTR_FLAG_CXX11 = 32 -}; - /* Default versions of target-overridable functions. */ - extern tree merge_decl_attributes (tree, tree); extern tree merge_type_attributes (tree, tree); @@ -5177,41 +3735,6 @@ extern void finish_builtin_struct (tree, const char *, extern void layout_type (tree); -/* These functions allow a front-end to perform a manual layout of a - RECORD_TYPE. (For instance, if the placement of subsequent fields - depends on the placement of fields so far.) Begin by calling - start_record_layout. Then, call place_field for each of the - fields. Then, call finish_record_layout. See layout_type for the - default way in which these functions are used. */ - -typedef struct record_layout_info_s -{ - /* The RECORD_TYPE that we are laying out. */ - tree t; - /* The offset into the record so far, in bytes, not including bits in - BITPOS. */ - tree offset; - /* The last known alignment of SIZE. */ - unsigned int offset_align; - /* The bit position within the last OFFSET_ALIGN bits, in bits. */ - tree bitpos; - /* The alignment of the record so far, in bits. */ - unsigned int record_align; - /* The alignment of the record so far, ignoring #pragma pack and - __attribute__ ((packed)), in bits. */ - unsigned int unpacked_align; - /* The previous field laid out. */ - tree prev_field; - /* The static variables (i.e., class variables, as opposed to - instance variables) encountered in T. */ - vec *pending_statics; - /* Bits remaining in the current alignment group */ - int remaining_in_alignment; - /* True if we've seen a packed field that didn't have normal - alignment anyway. */ - int packed_maybe_necessary; -} *record_layout_info; - extern record_layout_info start_record_layout (tree); extern tree bit_from_pos (tree, tree); extern tree byte_from_pos (tree, tree); @@ -5271,20 +3794,6 @@ extern HOST_WIDE_INT int_bit_position (const_tree); extern tree byte_position (const_tree); extern HOST_WIDE_INT int_byte_position (const_tree); -/* Define data structures, macros, and functions for handling sizes - and the various types used to represent sizes. */ - -enum size_type_kind -{ - stk_sizetype, /* Normal representation of sizes in bytes. */ - stk_ssizetype, /* Signed representation of sizes in bytes. */ - stk_bitsizetype, /* Normal representation of sizes in bits. */ - stk_sbitsizetype, /* Signed representation of sizes in bits. */ - stk_type_kind_last -}; - -extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last]; - #define sizetype sizetype_tab[(int) stk_sizetype] #define bitsizetype sizetype_tab[(int) stk_bitsizetype] #define ssizetype sizetype_tab[(int) stk_ssizetype] @@ -5316,9 +3825,6 @@ extern void finalize_size_functions (void); + (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, */ -extern unsigned int maximum_field_alignment; - /* Concatenate two lists (chains of TREE_LIST nodes) X and Y by making the last node in X point to Y. Returns X, except if X is 0 returns Y. */ @@ -5593,25 +4099,6 @@ extern tree decl_type_context (const_tree); /* Return 1 if EXPR is the real constant zero. */ extern int real_zerop (const_tree); - -/* Declare commonly used variables for tree structure. */ - -/* 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; - -/* Iterator for going through the function arguments. */ -typedef struct { - tree next; /* TREE_LIST pointing to the next argument */ -} function_args_iterator; /* Initialize the iterator I with arguments from function FNDECL */ @@ -5817,14 +4304,6 @@ extern void fold_undefer_overflow_warnings (bool, const_gimple, int); extern void fold_undefer_and_ignore_overflow_warnings (void); extern bool fold_deferring_overflow_warnings_p (void); extern tree fold_fma (location_t, tree, tree, tree, tree); - -enum operand_equal_flag -{ - OEP_ONLY_CONST = 1, - OEP_PURE_SAME = 2, - OEP_CONSTANT_ADDRESS_OF = 4 -}; - extern int operand_equal_p (const_tree, const_tree, unsigned int); extern int multiple_of_p (tree, const_tree, const_tree); #define omit_one_operand(T1,T2,T3)\ @@ -6109,70 +4588,10 @@ extern bool debug_find_tree (tree, tree); extern tree build_duplicate_type (tree); /* In calls.c */ - -/* 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. This corresponds to TREE_READONLY for function - decls. */ -#define ECF_CONST (1 << 0) -/* Nonzero if this is a call to "pure" function (like const function, - but may read memory. This corresponds to DECL_PURE_P for function - decls. */ -#define ECF_PURE (1 << 1) -/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no - infinite loop. This corresponds to DECL_LOOPING_CONST_OR_PURE_P - for function decls.*/ -#define ECF_LOOPING_CONST_OR_PURE (1 << 2) -/* Nonzero if this call will never return. */ -#define ECF_NORETURN (1 << 3) -/* Nonzero if this is a call to malloc or a related function. */ -#define ECF_MALLOC (1 << 4) -/* Nonzero if it is plausible that this is a call to alloca. */ -#define ECF_MAY_BE_ALLOCA (1 << 5) -/* Nonzero if this is a call to a function that won't throw an exception. */ -#define ECF_NOTHROW (1 << 6) -/* Nonzero if this is a call to setjmp or a related function. */ -#define ECF_RETURNS_TWICE (1 << 7) -/* Nonzero if this call replaces the current stack frame. */ -#define ECF_SIBCALL (1 << 8) -/* Function does not read or write memory (but may have side effects, so - it does not necessarily fit ECF_CONST). */ -#define ECF_NOVOPS (1 << 9) -/* The function does not lead to calls within current function unit. */ -#define ECF_LEAF (1 << 10) -/* Nonzero if this call does not affect transactions. */ -#define ECF_TM_PURE (1 << 11) -/* Nonzero if this call is into the transaction runtime library. */ -#define ECF_TM_BUILTIN (1 << 12) - extern int flags_from_decl_or_type (const_tree); extern int call_expr_flags (const_tree); extern void set_call_expr_flags (tree, int); -/* Call argument flags. */ - -/* Nonzero if the argument is not dereferenced recursively, thus only - directly reachable memory is read or written. */ -#define EAF_DIRECT (1 << 0) -/* Nonzero if memory reached by the argument is not clobbered. */ -#define EAF_NOCLOBBER (1 << 1) -/* Nonzero if the argument does not escape. */ -#define EAF_NOESCAPE (1 << 2) -/* Nonzero if the argument is not used by the function. */ -#define EAF_UNUSED (1 << 3) - -/* Call return flags. */ - -/* Mask for the argument number that is returned. Lower two bits of - the return flags, encodes argument slots zero to three. */ -#define ERF_RETURN_ARG_MASK (3) -/* Nonzero if the return value is equal to the argument number - flags & ERF_RETURN_ARG_MASK. */ -#define ERF_RETURNS_ARG (1 << 2) -/* Nonzero if the return value does not alias with anything. Functions - with the malloc attribute have this set on their return value. */ -#define ERF_NOALIAS (1 << 3) - extern int setjmp_call_p (const_tree); extern bool gimple_alloca_call_p (const_gimple); extern bool alloca_call_p (const_tree); @@ -6273,19 +4692,6 @@ extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *); /* 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 *); - -/* 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*); - extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*, walk_tree_lh); extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*, @@ -6300,106 +4706,33 @@ extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*, extern void set_decl_rtl (tree, rtx); extern void set_decl_incoming_rtl (tree, rtx, bool); - -/* Enum and arrays used for tree allocation stats. - Keep in sync with tree.c:tree_node_kind_names. */ -typedef enum -{ - d_kind, - t_kind, - b_kind, - s_kind, - r_kind, - e_kind, - c_kind, - id_kind, - vec_kind, - binfo_kind, - ssa_name_kind, - constr_kind, - x_kind, - lang_decl, - lang_type, - omp_clause_kind, - all_kinds -} tree_node_kind; - -extern int tree_node_counts[]; -extern int tree_node_sizes[]; - -/* True if we are in gimple form and the actions of the folders need to - be restricted. False if we are not in gimple form and folding is not - restricted to creating gimple expressions. */ -extern bool in_gimple_form; /* In gimple.c. */ extern tree get_base_address (tree t); extern void mark_addressable (tree); /* In tree.c. */ - -struct GTY(()) tree_map_base { - tree from; -}; - extern int tree_map_base_eq (const void *, const void *); extern unsigned int tree_map_base_hash (const void *); extern int tree_map_base_marked_p (const void *); extern bool list_equal_p (const_tree, const_tree); -/* Map from a tree to another tree. */ - -struct GTY(()) tree_map { - struct tree_map_base base; - unsigned int hash; - tree to; -}; - #define tree_map_eq tree_map_base_eq extern unsigned int tree_map_hash (const void *); #define tree_map_marked_p tree_map_base_marked_p -/* Map from a decl tree to another tree. */ - -struct GTY(()) tree_decl_map { - struct tree_map_base base; - tree to; -}; - #define tree_decl_map_eq tree_map_base_eq extern unsigned int tree_decl_map_hash (const void *); #define tree_decl_map_marked_p tree_map_base_marked_p -/* Map from a tree to an int. */ - -struct GTY(()) tree_int_map { - struct tree_map_base base; - unsigned int to; -}; - #define tree_int_map_eq tree_map_base_eq #define tree_int_map_hash tree_map_base_hash #define tree_int_map_marked_p tree_map_base_marked_p -/* Map from a tree to initialization/finalization priorities. */ - -struct GTY(()) tree_priority_map { - struct tree_map_base base; - priority_type init; - priority_type fini; -}; - #define tree_priority_map_eq tree_map_base_eq #define tree_priority_map_hash tree_map_base_hash #define tree_priority_map_marked_p tree_map_base_marked_p -/* Map from a decl tree to a tree vector. */ - -struct GTY(()) tree_vec_map { - struct tree_map_base base; - vec *to; -}; - #define tree_vec_map_eq tree_map_base_eq #define tree_vec_map_hash tree_decl_map_hash #define tree_vec_map_marked_p tree_map_base_marked_p @@ -6452,23 +4785,6 @@ is_tm_safe_or_pure (const_tree x) void init_inline_once (void); -/* Abstract iterators for CALL_EXPRs. These static inline definitions - have to go towards the end of tree.h so that union tree_node is fully - defined by this point. */ - -/* Structure containing iterator state. */ -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 const_call_expr_arg_iterator_d { - const_tree t; /* the call_expr */ - int n; /* argument count */ - int i; /* next argument index */ -} const_call_expr_arg_iterator; - /* Initialize the abstract argument list iterator object ITER with the arguments from CALL_EXPR node EXP. */ static inline void @@ -6566,20 +4882,6 @@ extern bool block_may_fallthru (const_tree); /* In vtable-verify.c. */ extern void save_vtable_map_decl (tree); - -/* Functional interface to the builtin functions. */ - -/* 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_. */ - -typedef struct GTY(()) builtin_info_type_d { - tree decl[(int)END_BUILTINS]; - bool implicit_p[(int)END_BUILTINS]; -} builtin_info_type; - -extern GTY(()) builtin_info_type builtin_info; - /* Valid builtin number. */ #define BUILTIN_VALID_P(FNCODE) \ (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1)) -- 2.30.2