LCOV - code coverage report
Current view: top level - gcc/c - c-tree.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 11 11 100.0 %
Date: 2020-03-28 11:57:23 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Definitions for C parsing and type checking.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #ifndef GCC_C_TREE_H
      21                 :            : #define GCC_C_TREE_H
      22                 :            : 
      23                 :            : #include "c-family/c-common.h"
      24                 :            : #include "diagnostic.h"
      25                 :            : 
      26                 :            : /* struct lang_identifier is private to c-decl.c, but langhooks.c needs to
      27                 :            :    know how big it is.  This is sanity-checked in c-decl.c.  */
      28                 :            : #define C_SIZEOF_STRUCT_LANG_IDENTIFIER \
      29                 :            :   (sizeof (struct c_common_identifier) + 3 * sizeof (void *))
      30                 :            : 
      31                 :            : /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
      32                 :            : #define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1 (TYPE)
      33                 :            : 
      34                 :            : /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is volatile.  */
      35                 :            : #define C_TYPE_FIELDS_VOLATILE(TYPE) TREE_LANG_FLAG_2 (TYPE)
      36                 :            : 
      37                 :            : /* In a RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE
      38                 :            :    nonzero if the definition of the type has already started.  */
      39                 :            : #define C_TYPE_BEING_DEFINED(TYPE) TYPE_LANG_FLAG_0 (TYPE)
      40                 :            : 
      41                 :            : /* In an incomplete RECORD_TYPE, UNION_TYPE or ENUMERAL_TYPE, a list of
      42                 :            :    variable declarations whose type would be completed by completing
      43                 :            :    that type.  */
      44                 :            : #define C_TYPE_INCOMPLETE_VARS(TYPE) \
      45                 :            :   TYPE_LANG_SLOT_1 (TREE_CHECK4 (TYPE, RECORD_TYPE, UNION_TYPE, \
      46                 :            :                                  QUAL_UNION_TYPE, ENUMERAL_TYPE))
      47                 :            : 
      48                 :            : /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
      49                 :            :    keyword.  C_RID_CODE (node) is then the RID_* value of the keyword.  */
      50                 :            : #define C_IS_RESERVED_WORD(ID) TREE_LANG_FLAG_0 (ID)
      51                 :            : 
      52                 :            : /* Record whether a type or decl was written with nonconstant size.
      53                 :            :    Note that TYPE_SIZE may have simplified to a constant.  */
      54                 :            : #define C_TYPE_VARIABLE_SIZE(TYPE) TYPE_LANG_FLAG_1 (TYPE)
      55                 :            : #define C_DECL_VARIABLE_SIZE(TYPE) DECL_LANG_FLAG_0 (TYPE)
      56                 :            : 
      57                 :            : /* Record whether a type is defined inside a struct or union type.
      58                 :            :    This is used for -Wc++-compat. */
      59                 :            : #define C_TYPE_DEFINED_IN_STRUCT(TYPE) TYPE_LANG_FLAG_2 (TYPE)
      60                 :            : 
      61                 :            : /* Record whether a typedef for type `int' was actually `signed int'.  */
      62                 :            : #define C_TYPEDEF_EXPLICITLY_SIGNED(EXP) DECL_LANG_FLAG_1 (EXP)
      63                 :            : 
      64                 :            : /* For a FUNCTION_DECL, nonzero if it was defined without an explicit
      65                 :            :    return type.  */
      66                 :            : #define C_FUNCTION_IMPLICIT_INT(EXP) DECL_LANG_FLAG_1 (EXP)
      67                 :            : 
      68                 :            : /* For a FUNCTION_DECL, nonzero if it was an implicit declaration.  */
      69                 :            : #define C_DECL_IMPLICIT(EXP) DECL_LANG_FLAG_2 (EXP)
      70                 :            : 
      71                 :            : /* For a PARM_DECL, nonzero if it was declared as an array.  */
      72                 :            : #define C_ARRAY_PARAMETER(NODE) DECL_LANG_FLAG_0 (NODE)
      73                 :            : 
      74                 :            : /* For FUNCTION_DECLs, evaluates true if the decl is built-in but has
      75                 :            :    been declared.  */
      76                 :            : #define C_DECL_DECLARED_BUILTIN(EXP)            \
      77                 :            :   DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (EXP))
      78                 :            : 
      79                 :            : /* For FUNCTION_DECLs, evaluates true if the decl is built-in, has a
      80                 :            :    built-in prototype and does not have a non-built-in prototype.  */
      81                 :            : #define C_DECL_BUILTIN_PROTOTYPE(EXP)           \
      82                 :            :   DECL_LANG_FLAG_6 (FUNCTION_DECL_CHECK (EXP))
      83                 :            : 
      84                 :            : /* Record whether a decl was declared register.  This is strictly a
      85                 :            :    front-end flag, whereas DECL_REGISTER is used for code generation;
      86                 :            :    they may differ for structures with volatile fields.  */
      87                 :            : #define C_DECL_REGISTER(EXP) DECL_LANG_FLAG_4 (EXP)
      88                 :            : 
      89                 :            : /* Record whether a decl was used in an expression anywhere except an
      90                 :            :    unevaluated operand of sizeof / typeof / alignof.  This is only
      91                 :            :    used for functions declared static but not defined, though outside
      92                 :            :    sizeof and typeof it is set for other function decls as well.  */
      93                 :            : #define C_DECL_USED(EXP) DECL_LANG_FLAG_5 (FUNCTION_DECL_CHECK (EXP))
      94                 :            : 
      95                 :            : /* Record whether a variable has been declared threadprivate by
      96                 :            :    #pragma omp threadprivate.  */
      97                 :            : #define C_DECL_THREADPRIVATE_P(DECL) DECL_LANG_FLAG_3 (VAR_DECL_CHECK (DECL))
      98                 :            : 
      99                 :            : /* Set on VAR_DECLs for compound literals.  */
     100                 :            : #define C_DECL_COMPOUND_LITERAL_P(DECL) \
     101                 :            :   DECL_LANG_FLAG_5 (VAR_DECL_CHECK (DECL))
     102                 :            : 
     103                 :            : /* Nonzero for a decl which either doesn't exist or isn't a prototype.
     104                 :            :    N.B. Could be simplified if all built-in decls had complete prototypes
     105                 :            :    (but this is presently difficult because some of them need FILE*).  */
     106                 :            : #define C_DECL_ISNT_PROTOTYPE(EXP)                      \
     107                 :            :        (EXP == 0                                        \
     108                 :            :         || (!prototype_p (TREE_TYPE (EXP))      \
     109                 :            :             && !fndecl_built_in_p (EXP)))
     110                 :            : 
     111                 :            : /* For FUNCTION_TYPE, a hidden list of types of arguments.  The same as
     112                 :            :    TYPE_ARG_TYPES for functions with prototypes, but created for functions
     113                 :            :    without prototypes.  */
     114                 :            : #define TYPE_ACTUAL_ARG_TYPES(NODE) \
     115                 :            :   TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE))
     116                 :            : 
     117                 :            : /* For a CONSTRUCTOR, whether some initializer contains a
     118                 :            :    subexpression meaning it is not a constant expression.  */
     119                 :            : #define CONSTRUCTOR_NON_CONST(EXPR) TREE_LANG_FLAG_1 (CONSTRUCTOR_CHECK (EXPR))
     120                 :            : 
     121                 :            : /* For a SAVE_EXPR, nonzero if the operand of the SAVE_EXPR has already
     122                 :            :    been folded.  */
     123                 :            : #define SAVE_EXPR_FOLDED_P(EXP) TREE_LANG_FLAG_1 (SAVE_EXPR_CHECK (EXP))
     124                 :            : 
     125                 :            : /* Record parser information about an expression that is irrelevant
     126                 :            :    for code generation alongside a tree representing its value.  */
     127                 :            : struct c_expr
     128                 :            : {
     129                 :            :   /* The value of the expression.  */
     130                 :            :   tree value;
     131                 :            :   /* Record the original unary/binary operator of an expression, which may
     132                 :            :      have been changed by fold, STRING_CST for unparenthesized string
     133                 :            :      constants, C_MAYBE_CONST_EXPR for __builtin_constant_p calls
     134                 :            :      (even if parenthesized), for subexpressions, and for non-constant
     135                 :            :      initializers, or ERROR_MARK for other expressions (including
     136                 :            :      parenthesized expressions).  */
     137                 :            :   enum tree_code original_code;
     138                 :            :   /* If not NULL, the original type of an expression.  This will
     139                 :            :      differ from the type of the value field for an enum constant.
     140                 :            :      The type of an enum constant is a plain integer type, but this
     141                 :            :      field will be the enum type.  */
     142                 :            :   tree original_type;
     143                 :            : 
     144                 :            :   /* The source range of this expression.  This is redundant
     145                 :            :      for node values that have locations, but not all node kinds
     146                 :            :      have locations (e.g. constants, and references to params, locals,
     147                 :            :      etc), so we stash a copy here.  */
     148                 :            :   source_range src_range;
     149                 :            : 
     150                 :            :   /* Access to the first and last locations within the source spelling
     151                 :            :      of this expression.  */
     152                 :   31990444 :   location_t get_start () const { return src_range.m_start; }
     153                 :   84392505 :   location_t get_finish () const { return src_range.m_finish; }
     154                 :            : 
     155                 :  137991000 :   location_t get_location () const
     156                 :            :   {
     157                 :  137991000 :     if (EXPR_HAS_LOCATION (value))
     158                 :   97497000 :       return EXPR_LOCATION (value);
     159                 :            :     else
     160                 :   40493500 :       return make_location (get_start (), get_start (), get_finish ());
     161                 :            :   }
     162                 :            : 
     163                 :            :   /* Set the value to error_mark_node whilst ensuring that src_range
     164                 :            :      is initialized.  */
     165                 :       6719 :   void set_error ()
     166                 :            :   {
     167                 :       6719 :     value = error_mark_node;
     168                 :       6719 :     src_range.m_start = UNKNOWN_LOCATION;
     169                 :       5881 :     src_range.m_finish = UNKNOWN_LOCATION;
     170                 :        838 :   }
     171                 :            : };
     172                 :            : 
     173                 :            : /* Type alias for struct c_expr. This allows to use the structure
     174                 :            :    inside the VEC types.  */
     175                 :            : typedef struct c_expr c_expr_t;
     176                 :            : 
     177                 :            : /* A kind of type specifier.  Note that this information is currently
     178                 :            :    only used to distinguish tag definitions, tag references and typeof
     179                 :            :    uses.  */
     180                 :            : enum c_typespec_kind {
     181                 :            :   /* No typespec.  This appears only in struct c_declspec.  */
     182                 :            :   ctsk_none,
     183                 :            :   /* A reserved keyword type specifier.  */
     184                 :            :   ctsk_resword,
     185                 :            :   /* A reference to a tag, previously declared, such as "struct foo".
     186                 :            :      This includes where the previous declaration was as a different
     187                 :            :      kind of tag, in which case this is only valid if shadowing that
     188                 :            :      tag in an inner scope.  */
     189                 :            :   ctsk_tagref,
     190                 :            :   /* Likewise, with standard attributes present in the reference.  */
     191                 :            :   ctsk_tagref_attrs,
     192                 :            :   /* A reference to a tag, not previously declared in a visible
     193                 :            :      scope.  */
     194                 :            :   ctsk_tagfirstref,
     195                 :            :   /* Likewise, with standard attributes present in the reference.  */
     196                 :            :   ctsk_tagfirstref_attrs,
     197                 :            :   /* A definition of a tag such as "struct foo { int a; }".  */
     198                 :            :   ctsk_tagdef,
     199                 :            :   /* A typedef name.  */
     200                 :            :   ctsk_typedef,
     201                 :            :   /* An ObjC-specific kind of type specifier.  */
     202                 :            :   ctsk_objc,
     203                 :            :   /* A typeof specifier, or _Atomic ( type-name ).  */
     204                 :            :   ctsk_typeof
     205                 :            : };
     206                 :            : 
     207                 :            : /* A type specifier: this structure is created in the parser and
     208                 :            :    passed to declspecs_add_type only.  */
     209                 :            : struct c_typespec {
     210                 :            :   /* What kind of type specifier this is.  */
     211                 :            :   enum c_typespec_kind kind;
     212                 :            :   /* Whether the expression has operands suitable for use in constant
     213                 :            :      expressions.  */
     214                 :            :   bool expr_const_operands;
     215                 :            :   /* The specifier itself.  */
     216                 :            :   tree spec;
     217                 :            :   /* An expression to be evaluated before the type specifier, in the
     218                 :            :      case of typeof specifiers, or NULL otherwise or if no such
     219                 :            :      expression is required for a particular typeof specifier.  In
     220                 :            :      particular, when typeof is applied to an expression of variably
     221                 :            :      modified type, that expression must be evaluated in order to
     222                 :            :      determine array sizes that form part of the type, but the
     223                 :            :      expression itself (as opposed to the array sizes) forms no part
     224                 :            :      of the type and so needs to be recorded separately.  */
     225                 :            :   tree expr;
     226                 :            : };
     227                 :            : 
     228                 :            : /* A storage class specifier.  */
     229                 :            : enum c_storage_class {
     230                 :            :   csc_none,
     231                 :            :   csc_auto,
     232                 :            :   csc_extern,
     233                 :            :   csc_register,
     234                 :            :   csc_static,
     235                 :            :   csc_typedef
     236                 :            : };
     237                 :            : 
     238                 :            : /* A type specifier keyword "void", "_Bool", "char", "int", "float",
     239                 :            :    "double", "_Decimal32", "_Decimal64", "_Decimal128", "_Fract", "_Accum",
     240                 :            :    or none of these.  */
     241                 :            : enum c_typespec_keyword {
     242                 :            :   cts_none,
     243                 :            :   cts_void,
     244                 :            :   cts_bool,
     245                 :            :   cts_char,
     246                 :            :   cts_int,
     247                 :            :   cts_float,
     248                 :            :   cts_int_n,
     249                 :            :   cts_double,
     250                 :            :   cts_dfloat32,
     251                 :            :   cts_dfloat64,
     252                 :            :   cts_dfloat128,
     253                 :            :   cts_floatn_nx,
     254                 :            :   cts_fract,
     255                 :            :   cts_accum,
     256                 :            :   cts_auto_type
     257                 :            : };
     258                 :            : 
     259                 :            : /* This enum lists all the possible declarator specifiers, storage
     260                 :            :    class or attribute that a user can write.  There is at least one
     261                 :            :    enumerator per possible declarator specifier in the struct
     262                 :            :    c_declspecs below.
     263                 :            : 
     264                 :            :    It is used to index the array of declspec locations in struct
     265                 :            :    c_declspecs.  */
     266                 :            : enum c_declspec_word {
     267                 :            :   cdw_typespec /* A catch-all for a typespec.  */,
     268                 :            :   cdw_storage_class  /* A catch-all for a storage class */,
     269                 :            :   cdw_attributes,
     270                 :            :   cdw_typedef,
     271                 :            :   cdw_explicit_signed,
     272                 :            :   cdw_deprecated,
     273                 :            :   cdw_default_int,
     274                 :            :   cdw_long,
     275                 :            :   cdw_long_long,
     276                 :            :   cdw_short,
     277                 :            :   cdw_signed,
     278                 :            :   cdw_unsigned,
     279                 :            :   cdw_complex,
     280                 :            :   cdw_inline,
     281                 :            :   cdw_noreturn,
     282                 :            :   cdw_thread,
     283                 :            :   cdw_const,
     284                 :            :   cdw_volatile,
     285                 :            :   cdw_restrict,
     286                 :            :   cdw_atomic,
     287                 :            :   cdw_saturating,
     288                 :            :   cdw_alignas,
     289                 :            :   cdw_address_space,
     290                 :            :   cdw_gimple,
     291                 :            :   cdw_rtl,
     292                 :            :   cdw_number_of_elements /* This one must always be the last
     293                 :            :                             enumerator.  */
     294                 :            : };
     295                 :            : 
     296                 :            : enum c_declspec_il {
     297                 :            :   cdil_none,
     298                 :            :   cdil_gimple,          /* __GIMPLE  */
     299                 :            :   cdil_gimple_cfg,      /* __GIMPLE(cfg)  */
     300                 :            :   cdil_gimple_ssa,      /* __GIMPLE(ssa)  */
     301                 :            :   cdil_rtl              /* __RTL  */
     302                 :            : };
     303                 :            : 
     304                 :            : /* A sequence of declaration specifiers in C.  When a new declaration
     305                 :            :    specifier is added, please update the enum c_declspec_word above
     306                 :            :    accordingly.  */
     307                 :            : struct c_declspecs {
     308                 :            :   location_t locations[cdw_number_of_elements];
     309                 :            :   /* The type specified, if a single type specifier such as a struct,
     310                 :            :      union or enum specifier, typedef name or typeof specifies the
     311                 :            :      whole type, or NULL_TREE if none or a keyword such as "void" or
     312                 :            :      "char" is used.  Does not include qualifiers.  */
     313                 :            :   tree type;
     314                 :            :   /* Any expression to be evaluated before the type, from a typeof
     315                 :            :      specifier.  */
     316                 :            :   tree expr;
     317                 :            :   /* The attributes from a typedef decl.  */
     318                 :            :   tree decl_attr;
     319                 :            :   /* When parsing, the GNU attributes and prefix standard attributes.
     320                 :            :      Outside the parser, this will be NULL; attributes (possibly from
     321                 :            :      multiple lists) will be passed separately.  */
     322                 :            :   tree attrs;
     323                 :            :   /* When parsing, postfix standard attributes (which appertain to the
     324                 :            :      type specified by the preceding declaration specifiers, unlike
     325                 :            :      prefix standard attributes which appertain to the declaration or
     326                 :            :      declarations as a whole).  */
     327                 :            :   tree postfix_attrs;
     328                 :            :   /* The pass to start compiling a __GIMPLE or __RTL function with.  */
     329                 :            :   char *gimple_or_rtl_pass;
     330                 :            :   /* ENTRY BB count.  */
     331                 :            :   profile_count entry_bb_count;
     332                 :            :   /* The base-2 log of the greatest alignment required by an _Alignas
     333                 :            :      specifier, in bytes, or -1 if no such specifiers with nonzero
     334                 :            :      alignment.  */
     335                 :            :   int align_log;
     336                 :            :   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
     337                 :            :   int int_n_idx;
     338                 :            :   /* For the _FloatN and _FloatNx declspec, this stores the index into
     339                 :            :      the floatn_nx_types array.  */
     340                 :            :   int floatn_nx_idx;
     341                 :            :   /* The storage class specifier, or csc_none if none.  */
     342                 :            :   enum c_storage_class storage_class;
     343                 :            :   /* Any type specifier keyword used such as "int", not reflecting
     344                 :            :      modifiers such as "short", or cts_none if none.  */
     345                 :            :   ENUM_BITFIELD (c_typespec_keyword) typespec_word : 8;
     346                 :            :   /* The kind of type specifier if one has been seen, ctsk_none
     347                 :            :      otherwise.  */
     348                 :            :   ENUM_BITFIELD (c_typespec_kind) typespec_kind : 4;
     349                 :            :   ENUM_BITFIELD (c_declspec_il) declspec_il : 3;
     350                 :            :   /* Whether any expressions in typeof specifiers may appear in
     351                 :            :      constant expressions.  */
     352                 :            :   BOOL_BITFIELD expr_const_operands : 1;
     353                 :            :   /* Whether any declaration specifiers have been seen at all.  */
     354                 :            :   BOOL_BITFIELD declspecs_seen_p : 1;
     355                 :            :   /* Whether any declaration specifiers other than standard attributes
     356                 :            :      have been seen at all.  If only standard attributes have been
     357                 :            :      seen, this is an attribute-declaration.  */
     358                 :            :   BOOL_BITFIELD non_std_attrs_seen_p : 1;
     359                 :            :   /* Whether something other than a storage class specifier or
     360                 :            :      attribute has been seen.  This is used to warn for the
     361                 :            :      obsolescent usage of storage class specifiers other than at the
     362                 :            :      start of the list.  (Doing this properly would require function
     363                 :            :      specifiers to be handled separately from storage class
     364                 :            :      specifiers.)  */
     365                 :            :   BOOL_BITFIELD non_sc_seen_p : 1;
     366                 :            :   /* Whether the type is specified by a typedef or typeof name.  */
     367                 :            :   BOOL_BITFIELD typedef_p : 1;
     368                 :            :   /* Whether the type is explicitly "signed" or specified by a typedef
     369                 :            :      whose type is explicitly "signed".  */
     370                 :            :   BOOL_BITFIELD explicit_signed_p : 1;
     371                 :            :   /* Whether the specifiers include a deprecated typedef.  */
     372                 :            :   BOOL_BITFIELD deprecated_p : 1;
     373                 :            :   /* Whether the type defaulted to "int" because there were no type
     374                 :            :      specifiers.  */
     375                 :            :   BOOL_BITFIELD default_int_p : 1;
     376                 :            :   /* Whether "long" was specified.  */
     377                 :            :   BOOL_BITFIELD long_p : 1;
     378                 :            :   /* Whether "long" was specified more than once.  */
     379                 :            :   BOOL_BITFIELD long_long_p : 1;
     380                 :            :   /* Whether "short" was specified.  */
     381                 :            :   BOOL_BITFIELD short_p : 1;
     382                 :            :   /* Whether "signed" was specified.  */
     383                 :            :   BOOL_BITFIELD signed_p : 1;
     384                 :            :   /* Whether "unsigned" was specified.  */
     385                 :            :   BOOL_BITFIELD unsigned_p : 1;
     386                 :            :   /* Whether "complex" was specified.  */
     387                 :            :   BOOL_BITFIELD complex_p : 1;
     388                 :            :   /* Whether "inline" was specified.  */
     389                 :            :   BOOL_BITFIELD inline_p : 1;
     390                 :            :   /* Whether "_Noreturn" was speciied.  */
     391                 :            :   BOOL_BITFIELD noreturn_p : 1;
     392                 :            :   /* Whether "__thread" or "_Thread_local" was specified.  */
     393                 :            :   BOOL_BITFIELD thread_p : 1;
     394                 :            :   /* Whether "__thread" rather than "_Thread_local" was specified.  */
     395                 :            :   BOOL_BITFIELD thread_gnu_p : 1;
     396                 :            :   /* Whether "const" was specified.  */
     397                 :            :   BOOL_BITFIELD const_p : 1;
     398                 :            :   /* Whether "volatile" was specified.  */
     399                 :            :   BOOL_BITFIELD volatile_p : 1;
     400                 :            :   /* Whether "restrict" was specified.  */
     401                 :            :   BOOL_BITFIELD restrict_p : 1;
     402                 :            :   /* Whether "_Atomic" was specified.  */
     403                 :            :   BOOL_BITFIELD atomic_p : 1;
     404                 :            :   /* Whether "_Sat" was specified.  */
     405                 :            :   BOOL_BITFIELD saturating_p : 1;
     406                 :            :   /* Whether any alignment specifier (even with zero alignment) was
     407                 :            :      specified.  */
     408                 :            :   BOOL_BITFIELD alignas_p : 1;
     409                 :            :   /* The address space that the declaration belongs to.  */
     410                 :            :   addr_space_t address_space;
     411                 :            : };
     412                 :            : 
     413                 :            : /* The various kinds of declarators in C.  */
     414                 :            : enum c_declarator_kind {
     415                 :            :   /* An identifier.  */
     416                 :            :   cdk_id,
     417                 :            :   /* A function.  */
     418                 :            :   cdk_function,
     419                 :            :   /* An array.  */
     420                 :            :   cdk_array,
     421                 :            :   /* A pointer.  */
     422                 :            :   cdk_pointer,
     423                 :            :   /* Parenthesized declarator with nested attributes.  */
     424                 :            :   cdk_attrs
     425                 :            : };
     426                 :            : 
     427                 :            : struct c_arg_tag {
     428                 :            :   /* The argument name.  */
     429                 :            :   tree id;
     430                 :            :   /* The type of the argument.  */
     431                 :            :   tree type;
     432                 :            : };
     433                 :            : 
     434                 :            : 
     435                 :            : /* Information about the parameters in a function declarator.  */
     436                 :            : struct c_arg_info {
     437                 :            :   /* A list of parameter decls.  */
     438                 :            :   tree parms;
     439                 :            :   /* A list of structure, union and enum tags defined.  */
     440                 :            :   vec<c_arg_tag, va_gc> *tags;
     441                 :            :   /* A list of argument types to go in the FUNCTION_TYPE.  */
     442                 :            :   tree types;
     443                 :            :   /* A list of non-parameter decls (notably enumeration constants)
     444                 :            :      defined with the parameters.  */
     445                 :            :   tree others;
     446                 :            :   /* A compound expression of VLA sizes from the parameters, or NULL.
     447                 :            :      In a function definition, these are used to ensure that
     448                 :            :      side-effects in sizes of arrays converted to pointers (such as a
     449                 :            :      parameter int i[n++]) take place; otherwise, they are
     450                 :            :      ignored.  */
     451                 :            :   tree pending_sizes;
     452                 :            :   /* True when these arguments had [*].  */
     453                 :            :   BOOL_BITFIELD had_vla_unspec : 1;
     454                 :            : };
     455                 :            : 
     456                 :            : /* A declarator.  */
     457                 :            : struct c_declarator {
     458                 :            :   /* The kind of declarator.  */
     459                 :            :   enum c_declarator_kind kind;
     460                 :            :   location_t id_loc; /* Currently only set for cdk_id, cdk_array. */
     461                 :            :   /* Except for cdk_id, the contained declarator.  For cdk_id, NULL.  */
     462                 :            :   struct c_declarator *declarator;
     463                 :            :   union {
     464                 :            :     /* For identifiers.  */
     465                 :            :     struct {
     466                 :            :       /* An IDENTIFIER_NODE, or NULL_TREE if an abstract
     467                 :            :          declarator.  */
     468                 :            :       tree id;
     469                 :            :       /* Any attributes (which apply to the declaration rather than to
     470                 :            :          the type described by the outer declarators).  */
     471                 :            :       tree attrs;
     472                 :            :     } id;
     473                 :            :     /* For functions.  */
     474                 :            :     struct c_arg_info *arg_info;
     475                 :            :     /* For arrays.  */
     476                 :            :     struct {
     477                 :            :       /* The array dimension, or NULL for [] and [*].  */
     478                 :            :       tree dimen;
     479                 :            :       /* The qualifiers inside [].  */
     480                 :            :       int quals;
     481                 :            :       /* The attributes (currently ignored) inside [].  */
     482                 :            :       tree attrs;
     483                 :            :       /* Whether [static] was used.  */
     484                 :            :       BOOL_BITFIELD static_p : 1;
     485                 :            :       /* Whether [*] was used.  */
     486                 :            :       BOOL_BITFIELD vla_unspec_p : 1;
     487                 :            :     } array;
     488                 :            :     /* For pointers, the qualifiers on the pointer type.  */
     489                 :            :     int pointer_quals;
     490                 :            :     /* For attributes.  */
     491                 :            :     tree attrs;
     492                 :            :   } u;
     493                 :            : };
     494                 :            : 
     495                 :            : /* A type name.  */
     496                 :            : struct c_type_name {
     497                 :            :   /* The declaration specifiers.  */
     498                 :            :   struct c_declspecs *specs;
     499                 :            :   /* The declarator.  */
     500                 :            :   struct c_declarator *declarator;
     501                 :            : };
     502                 :            : 
     503                 :            : /* A parameter.  */
     504                 :            : struct c_parm {
     505                 :            :   /* The declaration specifiers, minus any prefix attributes.  */
     506                 :            :   struct c_declspecs *specs;
     507                 :            :   /* The attributes.  */
     508                 :            :   tree attrs;
     509                 :            :   /* The declarator.  */
     510                 :            :   struct c_declarator *declarator;
     511                 :            :   /* The location of the parameter.  */
     512                 :            :   location_t loc;
     513                 :            : };
     514                 :            : 
     515                 :            : /* Used when parsing an enum.  Initialized by start_enum.  */
     516                 :            : struct c_enum_contents
     517                 :            : {
     518                 :            :   /* While defining an enum type, this is 1 plus the last enumerator
     519                 :            :      constant value.  */
     520                 :            :   tree enum_next_value;
     521                 :            : 
     522                 :            :   /* Nonzero means that there was overflow computing enum_next_value.  */
     523                 :            :   int enum_overflow;
     524                 :            : };
     525                 :            : 
     526                 :            : /* A type of reference to a static identifier in an inline
     527                 :            :    function.  */
     528                 :            : enum c_inline_static_type {
     529                 :            :   /* Identifier with internal linkage used in function that may be an
     530                 :            :      inline definition (i.e., file-scope static).  */
     531                 :            :   csi_internal,
     532                 :            :   /* Modifiable object with static storage duration defined in
     533                 :            :      function that may be an inline definition (i.e., local
     534                 :            :      static).  */
     535                 :            :   csi_modifiable
     536                 :            : };
     537                 :            : 
     538                 :            : 
     539                 :            : /* in c-parser.c */
     540                 :            : extern void c_parse_init (void);
     541                 :            : extern bool c_keyword_starts_typename (enum rid keyword);
     542                 :            : 
     543                 :            : /* in c-aux-info.c */
     544                 :            : extern void gen_aux_info_record (tree, int, int, int);
     545                 :            : 
     546                 :            : /* in c-decl.c */
     547                 :            : struct c_spot_bindings;
     548                 :            : class c_struct_parse_info;
     549                 :            : extern struct obstack parser_obstack;
     550                 :            : extern tree c_break_label;
     551                 :            : extern tree c_cont_label;
     552                 :            : 
     553                 :            : extern bool global_bindings_p (void);
     554                 :            : extern tree pushdecl (tree);
     555                 :            : extern void push_scope (void);
     556                 :            : extern tree pop_scope (void);
     557                 :            : extern void c_bindings_start_stmt_expr (struct c_spot_bindings *);
     558                 :            : extern void c_bindings_end_stmt_expr (struct c_spot_bindings *);
     559                 :            : 
     560                 :            : extern void record_inline_static (location_t, tree, tree,
     561                 :            :                                   enum c_inline_static_type);
     562                 :            : extern void c_init_decl_processing (void);
     563                 :            : extern void c_print_identifier (FILE *, tree, int);
     564                 :            : extern int quals_from_declspecs (const struct c_declspecs *);
     565                 :            : extern struct c_declarator *build_array_declarator (location_t, tree,
     566                 :            :                                                     struct c_declspecs *,
     567                 :            :                                                     bool, bool);
     568                 :            : extern tree build_enumerator (location_t, location_t, struct c_enum_contents *,
     569                 :            :                               tree, tree);
     570                 :            : extern tree check_for_loop_decls (location_t, bool);
     571                 :            : extern void mark_forward_parm_decls (void);
     572                 :            : extern void declare_parm_level (void);
     573                 :            : extern void undeclared_variable (location_t, tree);
     574                 :            : extern tree lookup_label_for_goto (location_t, tree);
     575                 :            : extern tree declare_label (tree);
     576                 :            : extern tree define_label (location_t, tree);
     577                 :            : extern struct c_spot_bindings *c_get_switch_bindings (void);
     578                 :            : extern void c_release_switch_bindings (struct c_spot_bindings *);
     579                 :            : extern bool c_check_switch_jump_warnings (struct c_spot_bindings *,
     580                 :            :                                           location_t, location_t);
     581                 :            : extern void finish_decl (tree, location_t, tree, tree, tree);
     582                 :            : extern tree finish_enum (tree, tree, tree);
     583                 :            : extern void finish_function (location_t = input_location);
     584                 :            : extern tree finish_struct (location_t, tree, tree, tree,
     585                 :            :                            class c_struct_parse_info *);
     586                 :            : extern tree c_simulate_enum_decl (location_t, const char *,
     587                 :            :                                   vec<string_int_pair>);
     588                 :            : extern struct c_arg_info *build_arg_info (void);
     589                 :            : extern struct c_arg_info *get_parm_info (bool, tree);
     590                 :            : extern tree grokfield (location_t, struct c_declarator *,
     591                 :            :                        struct c_declspecs *, tree, tree *);
     592                 :            : extern tree groktypename (struct c_type_name *, tree *, bool *);
     593                 :            : extern tree grokparm (const struct c_parm *, tree *);
     594                 :            : extern tree implicitly_declare (location_t, tree);
     595                 :            : extern void keep_next_level (void);
     596                 :            : extern void pending_xref_error (void);
     597                 :            : extern void c_push_function_context (void);
     598                 :            : extern void c_pop_function_context (void);
     599                 :            : extern void push_parm_decl (const struct c_parm *, tree *);
     600                 :            : extern struct c_declarator *set_array_declarator_inner (struct c_declarator *,
     601                 :            :                                                         struct c_declarator *);
     602                 :            : extern tree c_builtin_function (tree);
     603                 :            : extern tree c_builtin_function_ext_scope (tree);
     604                 :            : extern tree c_simulate_builtin_function_decl (tree);
     605                 :            : extern void c_warn_unused_attributes (tree);
     606                 :            : extern tree c_warn_type_attributes (tree);
     607                 :            : extern void shadow_tag (const struct c_declspecs *);
     608                 :            : extern void shadow_tag_warned (const struct c_declspecs *, int);
     609                 :            : extern tree start_enum (location_t, struct c_enum_contents *, tree);
     610                 :            : extern bool start_function (struct c_declspecs *, struct c_declarator *, tree);
     611                 :            : extern tree start_decl (struct c_declarator *, struct c_declspecs *, bool,
     612                 :            :                         tree);
     613                 :            : extern tree start_struct (location_t, enum tree_code, tree,
     614                 :            :                           class c_struct_parse_info **);
     615                 :            : extern void store_parm_decls (void);
     616                 :            : extern void store_parm_decls_from (struct c_arg_info *);
     617                 :            : extern void temp_store_parm_decls (tree, tree);
     618                 :            : extern void temp_pop_parm_decls (void);
     619                 :            : extern tree xref_tag (enum tree_code, tree);
     620                 :            : extern struct c_typespec parser_xref_tag (location_t, enum tree_code, tree,
     621                 :            :                                           bool, tree);
     622                 :            : extern struct c_parm *build_c_parm (struct c_declspecs *, tree,
     623                 :            :                                     struct c_declarator *, location_t);
     624                 :            : extern struct c_declarator *build_attrs_declarator (tree,
     625                 :            :                                                     struct c_declarator *);
     626                 :            : extern struct c_declarator *build_function_declarator (struct c_arg_info *,
     627                 :            :                                                        struct c_declarator *);
     628                 :            : extern struct c_declarator *build_id_declarator (tree);
     629                 :            : extern struct c_declarator *make_pointer_declarator (struct c_declspecs *,
     630                 :            :                                                      struct c_declarator *);
     631                 :            : extern struct c_declspecs *build_null_declspecs (void);
     632                 :            : extern struct c_declspecs *declspecs_add_qual (location_t,
     633                 :            :                                                struct c_declspecs *, tree);
     634                 :            : extern struct c_declspecs *declspecs_add_type (location_t,
     635                 :            :                                                struct c_declspecs *,
     636                 :            :                                                struct c_typespec);
     637                 :            : extern struct c_declspecs *declspecs_add_scspec (location_t,
     638                 :            :                                                  struct c_declspecs *, tree);
     639                 :            : extern struct c_declspecs *declspecs_add_attrs (location_t,
     640                 :            :                                                 struct c_declspecs *, tree);
     641                 :            : extern struct c_declspecs *declspecs_add_addrspace (location_t,
     642                 :            :                                                     struct c_declspecs *,
     643                 :            :                                                     addr_space_t);
     644                 :            : extern struct c_declspecs *declspecs_add_alignas (location_t,
     645                 :            :                                                   struct c_declspecs *, tree);
     646                 :            : extern struct c_declspecs *finish_declspecs (struct c_declspecs *);
     647                 :            : 
     648                 :            : /* in c-objc-common.c */
     649                 :            : extern bool c_objc_common_init (void);
     650                 :            : extern bool c_missing_noreturn_ok_p (tree);
     651                 :            : extern bool c_warn_unused_global_decl (const_tree);
     652                 :            : extern void c_initialize_diagnostics (diagnostic_context *);
     653                 :            : extern bool c_vla_unspec_p (tree x, tree fn);
     654                 :            : extern alias_set_type c_get_alias_set (tree);
     655                 :            : 
     656                 :            : /* in c-typeck.c */
     657                 :            : extern int in_alignof;
     658                 :            : extern int in_sizeof;
     659                 :            : extern int in_typeof;
     660                 :            : 
     661                 :            : extern tree c_last_sizeof_arg;
     662                 :            : extern location_t c_last_sizeof_loc;
     663                 :            : 
     664                 :            : extern struct c_switch *c_switch_stack;
     665                 :            : 
     666                 :            : extern tree c_objc_common_truthvalue_conversion (location_t, tree);
     667                 :            : extern tree require_complete_type (location_t, tree);
     668                 :            : extern bool same_translation_unit_p (const_tree, const_tree);
     669                 :            : extern int comptypes (tree, tree);
     670                 :            : extern int comptypes_check_different_types (tree, tree, bool *);
     671                 :            : extern bool c_vla_type_p (const_tree);
     672                 :            : extern bool c_mark_addressable (tree, bool = false);
     673                 :            : extern void c_incomplete_type_error (location_t, const_tree, const_tree);
     674                 :            : extern tree c_type_promotes_to (tree);
     675                 :            : extern struct c_expr default_function_array_conversion (location_t,
     676                 :            :                                                         struct c_expr);
     677                 :            : extern struct c_expr default_function_array_read_conversion (location_t,
     678                 :            :                                                              struct c_expr);
     679                 :            : extern struct c_expr convert_lvalue_to_rvalue (location_t, struct c_expr,
     680                 :            :                                                bool, bool);
     681                 :            : extern tree decl_constant_value_1 (tree, bool);
     682                 :            : extern void mark_exp_read (tree);
     683                 :            : extern tree composite_type (tree, tree);
     684                 :            : extern tree build_component_ref (location_t, tree, tree, location_t);
     685                 :            : extern tree build_array_ref (location_t, tree, tree);
     686                 :            : extern tree build_external_ref (location_t, tree, bool, tree *);
     687                 :            : extern void pop_maybe_used (bool);
     688                 :            : extern struct c_expr c_expr_sizeof_expr (location_t, struct c_expr);
     689                 :            : extern struct c_expr c_expr_sizeof_type (location_t, struct c_type_name *);
     690                 :            : extern struct c_expr parser_build_unary_op (location_t, enum tree_code,
     691                 :            :                                             struct c_expr);
     692                 :            : extern struct c_expr parser_build_binary_op (location_t,
     693                 :            :                                              enum tree_code, struct c_expr,
     694                 :            :                                              struct c_expr);
     695                 :            : extern tree build_conditional_expr (location_t, tree, bool, tree, tree,
     696                 :            :                                     location_t, tree, tree, location_t);
     697                 :            : extern tree build_compound_expr (location_t, tree, tree);
     698                 :            : extern tree c_cast_expr (location_t, struct c_type_name *, tree);
     699                 :            : extern tree build_c_cast (location_t, tree, tree);
     700                 :            : extern void store_init_value (location_t, tree, tree, tree);
     701                 :            : extern void maybe_warn_string_init (location_t, tree, struct c_expr);
     702                 :            : extern void start_init (tree, tree, int, rich_location *);
     703                 :            : extern void finish_init (void);
     704                 :            : extern void really_start_incremental_init (tree);
     705                 :            : extern void finish_implicit_inits (location_t, struct obstack *);
     706                 :            : extern void push_init_level (location_t, int, struct obstack *);
     707                 :            : extern struct c_expr pop_init_level (location_t, int, struct obstack *,
     708                 :            :                                      location_t);
     709                 :            : extern void set_init_index (location_t, tree, tree, struct obstack *);
     710                 :            : extern void set_init_label (location_t, tree, location_t, struct obstack *);
     711                 :            : extern void process_init_element (location_t, struct c_expr, bool,
     712                 :            :                                   struct obstack *);
     713                 :            : extern tree build_compound_literal (location_t, tree, tree, bool,
     714                 :            :                                     unsigned int);
     715                 :            : extern void check_compound_literal_type (location_t, struct c_type_name *);
     716                 :            : extern tree c_start_case (location_t, location_t, tree, bool);
     717                 :            : extern void c_finish_case (tree, tree);
     718                 :            : extern tree build_asm_expr (location_t, tree, tree, tree, tree, tree, bool,
     719                 :            :                             bool);
     720                 :            : extern tree build_asm_stmt (bool, tree);
     721                 :            : extern int c_types_compatible_p (tree, tree);
     722                 :            : extern tree c_begin_compound_stmt (bool);
     723                 :            : extern tree c_end_compound_stmt (location_t, tree, bool);
     724                 :            : extern void c_finish_if_stmt (location_t, tree, tree, tree);
     725                 :            : extern void c_finish_loop (location_t, location_t, tree, location_t, tree,
     726                 :            :                            tree, tree, tree, bool);
     727                 :            : extern tree c_begin_stmt_expr (void);
     728                 :            : extern tree c_finish_stmt_expr (location_t, tree);
     729                 :            : extern tree c_process_expr_stmt (location_t, tree);
     730                 :            : extern tree c_finish_expr_stmt (location_t, tree);
     731                 :            : extern tree c_finish_return (location_t, tree, tree);
     732                 :            : extern tree c_finish_bc_stmt (location_t, tree *, bool);
     733                 :            : extern tree c_finish_goto_label (location_t, tree);
     734                 :            : extern tree c_finish_goto_ptr (location_t, tree);
     735                 :            : extern tree c_expr_to_decl (tree, bool *, bool *);
     736                 :            : extern tree c_finish_omp_construct (location_t, enum tree_code, tree, tree);
     737                 :            : extern tree c_finish_oacc_data (location_t, tree, tree);
     738                 :            : extern tree c_finish_oacc_host_data (location_t, tree, tree);
     739                 :            : extern tree c_begin_omp_parallel (void);
     740                 :            : extern tree c_finish_omp_parallel (location_t, tree, tree);
     741                 :            : extern tree c_begin_omp_task (void);
     742                 :            : extern tree c_finish_omp_task (location_t, tree, tree);
     743                 :            : extern void c_finish_omp_cancel (location_t, tree);
     744                 :            : extern void c_finish_omp_cancellation_point (location_t, tree);
     745                 :            : extern tree c_finish_omp_clauses (tree, enum c_omp_region_type);
     746                 :            : extern tree c_build_va_arg (location_t, tree, location_t, tree);
     747                 :            : extern tree c_finish_transaction (location_t, tree, int);
     748                 :            : extern bool c_tree_equal (tree, tree);
     749                 :            : extern tree c_build_function_call_vec (location_t, vec<location_t>, tree,
     750                 :            :                                        vec<tree, va_gc> *, vec<tree, va_gc> *);
     751                 :            : extern tree c_omp_clause_copy_ctor (tree, tree, tree);
     752                 :            : 
     753                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
     754                 :            :    a return statement that specifies a return value is seen.  */
     755                 :            : 
     756                 :            : extern int current_function_returns_value;
     757                 :            : 
     758                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
     759                 :            :    a return statement with no argument is seen.  */
     760                 :            : 
     761                 :            : extern int current_function_returns_null;
     762                 :            : 
     763                 :            : /* Set to 0 at beginning of a function definition, set to 1 if
     764                 :            :    a call to a noreturn function is seen.  */
     765                 :            : 
     766                 :            : extern int current_function_returns_abnormally;
     767                 :            : 
     768                 :            : /* In c-decl.c */
     769                 :            : 
     770                 :            : /* Tell the binding oracle what kind of binding we are looking for.  */
     771                 :            : 
     772                 :            : enum c_oracle_request
     773                 :            : {
     774                 :            :   C_ORACLE_SYMBOL,
     775                 :            :   C_ORACLE_TAG,
     776                 :            :   C_ORACLE_LABEL
     777                 :            : };
     778                 :            : 
     779                 :            : /* If this is non-NULL, then it is a "binding oracle" which can lazily
     780                 :            :    create bindings when needed by the C compiler.  The oracle is told
     781                 :            :    the name and type of the binding to create.  It can call pushdecl
     782                 :            :    or the like to ensure the binding is visible; or do nothing,
     783                 :            :    leaving the binding untouched.  c-decl.c takes note of when the
     784                 :            :    oracle has been called and will not call it again if it fails to
     785                 :            :    create a given binding.  */
     786                 :            : 
     787                 :            : typedef void c_binding_oracle_function (enum c_oracle_request, tree identifier);
     788                 :            : 
     789                 :            : extern c_binding_oracle_function *c_binding_oracle;
     790                 :            : 
     791                 :            : extern void c_finish_incomplete_decl (tree);
     792                 :            : extern tree c_omp_reduction_id (enum tree_code, tree);
     793                 :            : extern tree c_omp_reduction_decl (tree);
     794                 :            : extern tree c_omp_reduction_lookup (tree, tree);
     795                 :            : extern tree c_check_omp_declare_reduction_r (tree *, int *, void *);
     796                 :            : extern void c_pushtag (location_t, tree, tree);
     797                 :            : extern void c_bind (location_t, tree, bool);
     798                 :            : extern bool tag_exists_p (enum tree_code, tree);
     799                 :            : 
     800                 :            : /* In c-errors.c */
     801                 :            : extern bool pedwarn_c90 (location_t, int opt, const char *, ...)
     802                 :            :     ATTRIBUTE_GCC_DIAG(3,4);
     803                 :            : extern bool pedwarn_c99 (location_t, int opt, const char *, ...)
     804                 :            :     ATTRIBUTE_GCC_DIAG(3,4);
     805                 :            : extern bool pedwarn_c11 (location_t, int opt, const char *, ...)
     806                 :            :     ATTRIBUTE_GCC_DIAG(3,4);
     807                 :            : 
     808                 :            : extern void
     809                 :            : set_c_expr_source_range (c_expr *expr,
     810                 :            :                          location_t start, location_t finish);
     811                 :            : 
     812                 :            : extern void
     813                 :            : set_c_expr_source_range (c_expr *expr,
     814                 :            :                          source_range src_range);
     815                 :            : 
     816                 :            : /* In c-fold.c */
     817                 :            : extern vec<tree> incomplete_record_decls;
     818                 :            : 
     819                 :            : #if CHECKING_P
     820                 :            : namespace selftest {
     821                 :            :   extern void run_c_tests (void);
     822                 :            : } // namespace selftest
     823                 :            : #endif /* #if CHECKING_P */
     824                 :            : 
     825                 :            : 
     826                 :            : #endif /* ! GCC_C_TREE_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.