LCOV - code coverage report
Current view: top level - gcc/c-family - c-common.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 7 7 100.0 %
Date: 2020-03-28 11:57:23 Functions: 2 2 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-common.c.
       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_COMMON_H
      21                 :            : #define GCC_C_COMMON_H
      22                 :            : 
      23                 :            : #include "splay-tree.h"
      24                 :            : #include "cpplib.h"
      25                 :            : #include "alias.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "fold-const.h"
      28                 :            : #include "wide-int-bitmask.h"
      29                 :            : 
      30                 :            : /* In order for the format checking to accept the C frontend
      31                 :            :    diagnostic framework extensions, you must include this file before
      32                 :            :    diagnostic-core.h, not after.  The C front end formats are a subset of those
      33                 :            :    for C++, so they are the appropriate set to use in common code;
      34                 :            :    cp-tree.h overrides this for C++.  */
      35                 :            : #if defined(GCC_DIAGNOSTIC_CORE_H)
      36                 :            : #error \
      37                 :            : In order for the format checking to accept the C front end diagnostic \
      38                 :            : framework extensions, you must include this file before diagnostic-core.h \
      39                 :            : never after.
      40                 :            : #endif
      41                 :            : #ifndef GCC_DIAG_STYLE
      42                 :            : #define GCC_DIAG_STYLE __gcc_cdiag__
      43                 :            : #endif
      44                 :            : #include "diagnostic-core.h"
      45                 :            : 
      46                 :            : /* Usage of TREE_LANG_FLAG_?:
      47                 :            :    0: IDENTIFIER_MARKED (used by search routines).
      48                 :            :       C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)
      49                 :            :    1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
      50                 :            :       STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
      51                 :            :       C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)
      52                 :            :    2: unused
      53                 :            :    3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
      54                 :            :    4: unused
      55                 :            : */
      56                 :            : 
      57                 :            : /* Reserved identifiers.  This is the union of all the keywords for C,
      58                 :            :    C++, and Objective-C.  All the type modifiers have to be in one
      59                 :            :    block at the beginning, because they are used as mask bits.  There
      60                 :            :    are 28 type modifiers; if we add many more we will have to redesign
      61                 :            :    the mask mechanism.  */
      62                 :            : 
      63                 :            : enum rid
      64                 :            : {
      65                 :            :   /* Modifiers: */
      66                 :            :   /* C, in empirical order of frequency.  */
      67                 :            :   RID_STATIC = 0,
      68                 :            :   RID_UNSIGNED, RID_LONG,    RID_CONST, RID_EXTERN,
      69                 :            :   RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
      70                 :            :   RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
      71                 :            :   RID_NORETURN, RID_ATOMIC,
      72                 :            : 
      73                 :            :   /* C extensions */
      74                 :            :   RID_COMPLEX, RID_THREAD, RID_SAT,
      75                 :            : 
      76                 :            :   /* C++ */
      77                 :            :   RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
      78                 :            : 
      79                 :            :   /* ObjC ("PQ" reserved words - they do not appear after a '@' and
      80                 :            :      are keywords only in specific contexts)  */
      81                 :            :   RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
      82                 :            : 
      83                 :            :   /* ObjC ("PATTR" reserved words - they do not appear after a '@' 
      84                 :            :      and are keywords only as property attributes)  */
      85                 :            :   RID_GETTER, RID_SETTER,
      86                 :            :   RID_READONLY, RID_READWRITE,
      87                 :            :   RID_ASSIGN, RID_RETAIN, RID_COPY,
      88                 :            :   RID_NONATOMIC,
      89                 :            : 
      90                 :            :   /* C (reserved and imaginary types not implemented, so any use is a
      91                 :            :      syntax error) */
      92                 :            :   RID_IMAGINARY,
      93                 :            : 
      94                 :            :   /* C */
      95                 :            :   RID_INT,     RID_CHAR,   RID_FLOAT,    RID_DOUBLE, RID_VOID,
      96                 :            :   RID_ENUM,    RID_STRUCT, RID_UNION,    RID_IF,     RID_ELSE,
      97                 :            :   RID_WHILE,   RID_DO,     RID_FOR,      RID_SWITCH, RID_CASE,
      98                 :            :   RID_DEFAULT, RID_BREAK,  RID_CONTINUE, RID_RETURN, RID_GOTO,
      99                 :            :   RID_SIZEOF,
     100                 :            : 
     101                 :            :   /* C extensions */
     102                 :            :   RID_ASM,       RID_TYPEOF,   RID_ALIGNOF,  RID_ATTRIBUTE,  RID_VA_ARG,
     103                 :            :   RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
     104                 :            :   RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,          RID_BUILTIN_SHUFFLE,
     105                 :            :   RID_BUILTIN_CONVERTVECTOR,   RID_BUILTIN_TGMATH,
     106                 :            :   RID_BUILTIN_HAS_ATTRIBUTE,
     107                 :            :   RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
     108                 :            : 
     109                 :            :   /* TS 18661-3 keywords, in the same sequence as the TI_* values.  */
     110                 :            :   RID_FLOAT16,
     111                 :            :   RID_FLOATN_NX_FIRST = RID_FLOAT16,
     112                 :            :   RID_FLOAT32,
     113                 :            :   RID_FLOAT64,
     114                 :            :   RID_FLOAT128,
     115                 :            :   RID_FLOAT32X,
     116                 :            :   RID_FLOAT64X,
     117                 :            :   RID_FLOAT128X,
     118                 :            : #define CASE_RID_FLOATN_NX                                              \
     119                 :            :   case RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128: \
     120                 :            :   case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X
     121                 :            : 
     122                 :            :   RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
     123                 :            : 
     124                 :            :   /* "__GIMPLE", for the GIMPLE-parsing extension to the C frontend. */
     125                 :            :   RID_GIMPLE,
     126                 :            : 
     127                 :            :   /* "__PHI", for parsing PHI function in GIMPLE FE.  */
     128                 :            :   RID_PHI,
     129                 :            : 
     130                 :            :   /* "__RTL", for the RTL-parsing extension to the C frontend.  */
     131                 :            :   RID_RTL,
     132                 :            : 
     133                 :            :   /* C11 */
     134                 :            :   RID_ALIGNAS, RID_GENERIC,
     135                 :            : 
     136                 :            :   /* This means to warn that this is a C++ keyword, and then treat it
     137                 :            :      as a normal identifier.  */
     138                 :            :   RID_CXX_COMPAT_WARN,
     139                 :            : 
     140                 :            :   /* GNU transactional memory extension */
     141                 :            :   RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,
     142                 :            : 
     143                 :            :   /* Too many ways of getting the name of a function as a string */
     144                 :            :   RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
     145                 :            : 
     146                 :            :   /* C++ (some of these are keywords in Objective-C as well, but only
     147                 :            :      if they appear after a '@') */
     148                 :            :   RID_BOOL,     RID_WCHAR,    RID_CLASS,
     149                 :            :   RID_PUBLIC,   RID_PRIVATE,  RID_PROTECTED,
     150                 :            :   RID_TEMPLATE, RID_NULL,     RID_CATCH,
     151                 :            :   RID_DELETE,   RID_FALSE,    RID_NAMESPACE,
     152                 :            :   RID_NEW,      RID_OFFSETOF, RID_OPERATOR,
     153                 :            :   RID_THIS,     RID_THROW,    RID_TRUE,
     154                 :            :   RID_TRY,      RID_TYPENAME, RID_TYPEID,
     155                 :            :   RID_USING,    RID_CHAR16,   RID_CHAR32,
     156                 :            : 
     157                 :            :   /* casts */
     158                 :            :   RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
     159                 :            : 
     160                 :            :   /* C++ extensions */
     161                 :            :   RID_ADDRESSOF,               RID_BASES,
     162                 :            :   RID_BUILTIN_LAUNDER,         RID_DIRECT_BASES,
     163                 :            :   RID_HAS_NOTHROW_ASSIGN,      RID_HAS_NOTHROW_CONSTRUCTOR,
     164                 :            :   RID_HAS_NOTHROW_COPY,        RID_HAS_TRIVIAL_ASSIGN,
     165                 :            :   RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY,
     166                 :            :   RID_HAS_TRIVIAL_DESTRUCTOR,  RID_HAS_UNIQUE_OBJ_REPRESENTATIONS,
     167                 :            :   RID_HAS_VIRTUAL_DESTRUCTOR,
     168                 :            :   RID_IS_ABSTRACT,             RID_IS_AGGREGATE,
     169                 :            :   RID_IS_BASE_OF,              RID_IS_CLASS,
     170                 :            :   RID_IS_EMPTY,                RID_IS_ENUM,
     171                 :            :   RID_IS_FINAL,                RID_IS_LITERAL_TYPE,
     172                 :            :   RID_IS_POD,                  RID_IS_POLYMORPHIC,
     173                 :            :   RID_IS_SAME_AS,
     174                 :            :   RID_IS_STD_LAYOUT,           RID_IS_TRIVIAL,
     175                 :            :   RID_IS_TRIVIALLY_ASSIGNABLE, RID_IS_TRIVIALLY_CONSTRUCTIBLE,
     176                 :            :   RID_IS_TRIVIALLY_COPYABLE,
     177                 :            :   RID_IS_UNION,                RID_UNDERLYING_TYPE,
     178                 :            :   RID_IS_ASSIGNABLE,           RID_IS_CONSTRUCTIBLE,
     179                 :            : 
     180                 :            :   /* C++11 */
     181                 :            :   RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
     182                 :            : 
     183                 :            :   /* C++20 */
     184                 :            :   RID_CONSTINIT, RID_CONSTEVAL,
     185                 :            : 
     186                 :            :   /* char8_t */
     187                 :            :   RID_CHAR8,
     188                 :            : 
     189                 :            :   /* C++ concepts */
     190                 :            :   RID_CONCEPT, RID_REQUIRES,
     191                 :            : 
     192                 :            :   /* C++ coroutines */
     193                 :            :   RID_CO_AWAIT, RID_CO_YIELD, RID_CO_RETURN,
     194                 :            : 
     195                 :            :   /* C++ transactional memory.  */
     196                 :            :   RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED,
     197                 :            : 
     198                 :            :   /* Objective-C ("AT" reserved words - they are only keywords when
     199                 :            :      they follow '@')  */
     200                 :            :   RID_AT_ENCODE,   RID_AT_END,
     201                 :            :   RID_AT_CLASS,    RID_AT_ALIAS,     RID_AT_DEFS,
     202                 :            :   RID_AT_PRIVATE,  RID_AT_PROTECTED, RID_AT_PUBLIC,  RID_AT_PACKAGE,
     203                 :            :   RID_AT_PROTOCOL, RID_AT_SELECTOR,
     204                 :            :   RID_AT_THROW,    RID_AT_TRY,       RID_AT_CATCH,
     205                 :            :   RID_AT_FINALLY,  RID_AT_SYNCHRONIZED, 
     206                 :            :   RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,
     207                 :            :   RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,
     208                 :            :   RID_AT_INTERFACE,
     209                 :            :   RID_AT_IMPLEMENTATION,
     210                 :            : 
     211                 :            :   /* Named address support, mapping the keyword to a particular named address
     212                 :            :      number.  Named address space 0 is reserved for the generic address.  If
     213                 :            :      there are more than 254 named addresses, the addr_space_t type will need
     214                 :            :      to be grown from an unsigned char to unsigned short.  */
     215                 :            :   RID_ADDR_SPACE_0,             /* generic address */
     216                 :            :   RID_ADDR_SPACE_1,
     217                 :            :   RID_ADDR_SPACE_2,
     218                 :            :   RID_ADDR_SPACE_3,
     219                 :            :   RID_ADDR_SPACE_4,
     220                 :            :   RID_ADDR_SPACE_5,
     221                 :            :   RID_ADDR_SPACE_6,
     222                 :            :   RID_ADDR_SPACE_7,
     223                 :            :   RID_ADDR_SPACE_8,
     224                 :            :   RID_ADDR_SPACE_9,
     225                 :            :   RID_ADDR_SPACE_10,
     226                 :            :   RID_ADDR_SPACE_11,
     227                 :            :   RID_ADDR_SPACE_12,
     228                 :            :   RID_ADDR_SPACE_13,
     229                 :            :   RID_ADDR_SPACE_14,
     230                 :            :   RID_ADDR_SPACE_15,
     231                 :            : 
     232                 :            :   RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,
     233                 :            :   RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,
     234                 :            : 
     235                 :            :   /* __intN keywords.  The _N_M here doesn't correspond to the intN
     236                 :            :      in the keyword; use the bitsize in int_n_t_data_t[M] for that.
     237                 :            :      For example, if int_n_t_data_t[0].bitsize is 13, then RID_INT_N_0
     238                 :            :      is for __int13.  */
     239                 :            : 
     240                 :            :   /* Note that the range to use is RID_FIRST_INT_N through
     241                 :            :      RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.c has a list of
     242                 :            :      all RID_INT_N_* in a case statement.  */
     243                 :            : 
     244                 :            :   RID_INT_N_0,
     245                 :            :   RID_INT_N_1,
     246                 :            :   RID_INT_N_2,
     247                 :            :   RID_INT_N_3,
     248                 :            : 
     249                 :            :   RID_FIRST_INT_N = RID_INT_N_0,
     250                 :            :   RID_LAST_INT_N = RID_INT_N_3,
     251                 :            : 
     252                 :            :   RID_MAX,
     253                 :            : 
     254                 :            :   RID_FIRST_MODIFIER = RID_STATIC,
     255                 :            :   RID_LAST_MODIFIER = RID_ONEWAY,
     256                 :            : 
     257                 :            :   RID_FIRST_CXX11 = RID_CONSTEXPR,
     258                 :            :   RID_LAST_CXX11 = RID_STATIC_ASSERT,
     259                 :            :   RID_FIRST_CXX20 = RID_CONSTINIT,
     260                 :            :   RID_LAST_CXX20 = RID_CONSTINIT,
     261                 :            :   RID_FIRST_AT = RID_AT_ENCODE,
     262                 :            :   RID_LAST_AT = RID_AT_IMPLEMENTATION,
     263                 :            :   RID_FIRST_PQ = RID_IN,
     264                 :            :   RID_LAST_PQ = RID_ONEWAY,
     265                 :            :   RID_FIRST_PATTR = RID_GETTER,
     266                 :            :   RID_LAST_PATTR = RID_NONATOMIC
     267                 :            : };
     268                 :            : 
     269                 :            : #define OBJC_IS_AT_KEYWORD(rid) \
     270                 :            :   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
     271                 :            :    (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
     272                 :            : 
     273                 :            : #define OBJC_IS_PQ_KEYWORD(rid) \
     274                 :            :   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
     275                 :            :    (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
     276                 :            : 
     277                 :            : #define OBJC_IS_PATTR_KEYWORD(rid) \
     278                 :            :   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \
     279                 :            :    (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)
     280                 :            : 
     281                 :            : /* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as
     282                 :            :    'class') which are shared in a subtle way between Objective-C and
     283                 :            :    C++.  When the lexer is lexing in Objective-C/Objective-C++, if it
     284                 :            :    finds '@' followed by one of these identifiers (eg, '@class'), it
     285                 :            :    recognizes the whole as an Objective-C keyword.  If the identifier
     286                 :            :    is found elsewhere, it follows the rules of the C/C++ language.
     287                 :            :  */
     288                 :            : #define OBJC_IS_CXX_KEYWORD(rid) \
     289                 :            :   (rid == RID_CLASS || rid == RID_SYNCHRONIZED                  \
     290                 :            :    || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE   \
     291                 :            :    || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)
     292                 :            : 
     293                 :            : /* The elements of `ridpointers' are identifier nodes for the reserved
     294                 :            :    type names and storage classes.  It is indexed by a RID_... value.  */
     295                 :            : extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
     296                 :            : 
     297                 :            : /* Standard named or nameless data types of the C compiler.  */
     298                 :            : 
     299                 :            : enum c_tree_index
     300                 :            : {
     301                 :            :     CTI_CHAR8_TYPE,
     302                 :            :     CTI_CHAR16_TYPE,
     303                 :            :     CTI_CHAR32_TYPE,
     304                 :            :     CTI_WCHAR_TYPE,
     305                 :            :     CTI_UNDERLYING_WCHAR_TYPE,
     306                 :            :     CTI_WINT_TYPE,
     307                 :            :     CTI_SIGNED_SIZE_TYPE, /* For format checking only.  */
     308                 :            :     CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only.  */
     309                 :            :     CTI_INTMAX_TYPE,
     310                 :            :     CTI_UINTMAX_TYPE,
     311                 :            :     CTI_WIDEST_INT_LIT_TYPE,
     312                 :            :     CTI_WIDEST_UINT_LIT_TYPE,
     313                 :            : 
     314                 :            :     /* Types for <stdint.h>, that may not be defined on all
     315                 :            :        targets.  */
     316                 :            :     CTI_SIG_ATOMIC_TYPE,
     317                 :            :     CTI_INT8_TYPE,
     318                 :            :     CTI_INT16_TYPE,
     319                 :            :     CTI_INT32_TYPE,
     320                 :            :     CTI_INT64_TYPE,
     321                 :            :     CTI_UINT8_TYPE,
     322                 :            :     CTI_UINT16_TYPE,
     323                 :            :     CTI_UINT32_TYPE,
     324                 :            :     CTI_UINT64_TYPE,
     325                 :            :     CTI_INT_LEAST8_TYPE,
     326                 :            :     CTI_INT_LEAST16_TYPE,
     327                 :            :     CTI_INT_LEAST32_TYPE,
     328                 :            :     CTI_INT_LEAST64_TYPE,
     329                 :            :     CTI_UINT_LEAST8_TYPE,
     330                 :            :     CTI_UINT_LEAST16_TYPE,
     331                 :            :     CTI_UINT_LEAST32_TYPE,
     332                 :            :     CTI_UINT_LEAST64_TYPE,
     333                 :            :     CTI_INT_FAST8_TYPE,
     334                 :            :     CTI_INT_FAST16_TYPE,
     335                 :            :     CTI_INT_FAST32_TYPE,
     336                 :            :     CTI_INT_FAST64_TYPE,
     337                 :            :     CTI_UINT_FAST8_TYPE,
     338                 :            :     CTI_UINT_FAST16_TYPE,
     339                 :            :     CTI_UINT_FAST32_TYPE,
     340                 :            :     CTI_UINT_FAST64_TYPE,
     341                 :            :     CTI_INTPTR_TYPE,
     342                 :            :     CTI_UINTPTR_TYPE,
     343                 :            : 
     344                 :            :     CTI_CHAR_ARRAY_TYPE,
     345                 :            :     CTI_CHAR8_ARRAY_TYPE,
     346                 :            :     CTI_CHAR16_ARRAY_TYPE,
     347                 :            :     CTI_CHAR32_ARRAY_TYPE,
     348                 :            :     CTI_WCHAR_ARRAY_TYPE,
     349                 :            :     CTI_STRING_TYPE,
     350                 :            :     CTI_CONST_STRING_TYPE,
     351                 :            : 
     352                 :            :     /* Type for boolean expressions (bool in C++, int in C).  */
     353                 :            :     CTI_TRUTHVALUE_TYPE,
     354                 :            :     CTI_TRUTHVALUE_TRUE,
     355                 :            :     CTI_TRUTHVALUE_FALSE,
     356                 :            : 
     357                 :            :     CTI_DEFAULT_FUNCTION_TYPE,
     358                 :            : 
     359                 :            :     /* These are not types, but we have to look them up all the time.  */
     360                 :            :     CTI_FUNCTION_NAME_DECL,
     361                 :            :     CTI_PRETTY_FUNCTION_NAME_DECL,
     362                 :            :     CTI_C99_FUNCTION_NAME_DECL,
     363                 :            :     CTI_SAVED_FUNCTION_NAME_DECLS,
     364                 :            : 
     365                 :            :     CTI_NULL,
     366                 :            : 
     367                 :            :     CTI_MAX
     368                 :            : };
     369                 :            : 
     370                 :            : #define C_CPP_HASHNODE(id) \
     371                 :            :   (&(((struct c_common_identifier *) (id))->node))
     372                 :            : #define C_RID_CODE(id) \
     373                 :            :   ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
     374                 :            : #define C_SET_RID_CODE(id, code) \
     375                 :            :   (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
     376                 :            : 
     377                 :            : /* Identifier part common to the C front ends.  Inherits from
     378                 :            :    tree_identifier, despite appearances.  */
     379                 :            : struct GTY(()) c_common_identifier {
     380                 :            :   struct tree_common common;
     381                 :            :   struct cpp_hashnode node;
     382                 :            : };
     383                 :            : 
     384                 :            : /* An entry in the reserved keyword table.  */
     385                 :            : 
     386                 :            : struct c_common_resword
     387                 :            : {
     388                 :            :   const char *const word;
     389                 :            :   ENUM_BITFIELD(rid) const rid : 16;
     390                 :            :   const unsigned int disable   : 16;
     391                 :            : };
     392                 :            : 
     393                 :            : /* Mode used to build pointers (VOIDmode means ptr_mode).  */
     394                 :            : 
     395                 :            : extern machine_mode c_default_pointer_mode;
     396                 :            : 
     397                 :            : /* Extra cpp_ttype values for C++.  */
     398                 :            : 
     399                 :            : /* A token type for template-ids.  If a template-id is processed while
     400                 :            :    parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
     401                 :            :    the value of the CPP_TEMPLATE_ID is whatever was returned by
     402                 :            :    cp_parser_template_id.  */
     403                 :            : #define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
     404                 :            : 
     405                 :            : /* A token type for nested-name-specifiers.  If a
     406                 :            :    nested-name-specifier is processed while parsing tentatively, it is
     407                 :            :    replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
     408                 :            :    CPP_NESTED_NAME_SPECIFIER is whatever was returned by
     409                 :            :    cp_parser_nested_name_specifier_opt.  */
     410                 :            : #define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
     411                 :            : 
     412                 :            : /* A token type for pre-parsed C++0x decltype.  */
     413                 :            : #define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
     414                 :            : 
     415                 :            : /* A token type for pre-parsed primary-expression (lambda- or statement-).  */
     416                 :            : #define CPP_PREPARSED_EXPR ((enum cpp_ttype) (CPP_DECLTYPE + 1))
     417                 :            : 
     418                 :            : /* The number of token types, including C++-specific ones.  */
     419                 :            : #define N_CP_TTYPES ((int) (CPP_PREPARSED_EXPR + 1))
     420                 :            : 
     421                 :            : /* Disable mask.  Keywords are disabled if (reswords[i].disable &
     422                 :            :    mask) is _true_.  Thus for keywords which are present in all
     423                 :            :    languages the disable field is zero.  */
     424                 :            : 
     425                 :            : #define D_CONLY         0x0001  /* C only (not in C++).  */
     426                 :            : #define D_CXXONLY       0x0002  /* C++ only (not in C).  */
     427                 :            : #define D_C99           0x0004  /* In C, C99 only.  */
     428                 :            : #define D_CXX11         0x0008  /* In C++, C++11 only.  */
     429                 :            : #define D_EXT           0x0010  /* GCC extension.  */
     430                 :            : #define D_EXT89         0x0020  /* GCC extension incorporated in C99.  */
     431                 :            : #define D_ASM           0x0040  /* Disabled by -fno-asm.  */
     432                 :            : #define D_OBJC          0x0080  /* In Objective C and neither C nor C++.  */
     433                 :            : #define D_CXX_OBJC      0x0100  /* In Objective C, and C++, but not C.  */
     434                 :            : #define D_CXXWARN       0x0200  /* In C warn with -Wcxx-compat.  */
     435                 :            : #define D_CXX_CONCEPTS  0x0400  /* In C++, only with concepts.  */
     436                 :            : #define D_TRANSMEM      0X0800  /* C++ transactional memory TS.  */
     437                 :            : #define D_CXX_CHAR8_T   0X1000  /* In C++, only with -fchar8_t.  */
     438                 :            : #define D_CXX20         0x2000  /* In C++, C++20 only.  */
     439                 :            : #define D_CXX_COROUTINES 0x4000  /* In C++, only with coroutines.  */
     440                 :            : 
     441                 :            : #define D_CXX_CONCEPTS_FLAGS D_CXXONLY | D_CXX_CONCEPTS
     442                 :            : #define D_CXX_CHAR8_T_FLAGS D_CXXONLY | D_CXX_CHAR8_T
     443                 :            : #define D_CXX_COROUTINES_FLAGS (D_CXXONLY | D_CXX_COROUTINES)
     444                 :            : 
     445                 :            : /* The reserved keyword table.  */
     446                 :            : extern const struct c_common_resword c_common_reswords[];
     447                 :            : 
     448                 :            : /* The number of items in the reserved keyword table.  */
     449                 :            : extern const unsigned int num_c_common_reswords;
     450                 :            : 
     451                 :            : #define char8_type_node                 c_global_trees[CTI_CHAR8_TYPE]
     452                 :            : #define char16_type_node                c_global_trees[CTI_CHAR16_TYPE]
     453                 :            : #define char32_type_node                c_global_trees[CTI_CHAR32_TYPE]
     454                 :            : #define wchar_type_node                 c_global_trees[CTI_WCHAR_TYPE]
     455                 :            : #define underlying_wchar_type_node      c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]
     456                 :            : #define wint_type_node                  c_global_trees[CTI_WINT_TYPE]
     457                 :            : #define signed_size_type_node           c_global_trees[CTI_SIGNED_SIZE_TYPE]
     458                 :            : #define unsigned_ptrdiff_type_node      c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
     459                 :            : #define intmax_type_node                c_global_trees[CTI_INTMAX_TYPE]
     460                 :            : #define uintmax_type_node               c_global_trees[CTI_UINTMAX_TYPE]
     461                 :            : #define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
     462                 :            : #define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
     463                 :            : 
     464                 :            : #define sig_atomic_type_node            c_global_trees[CTI_SIG_ATOMIC_TYPE]
     465                 :            : #define int8_type_node                  c_global_trees[CTI_INT8_TYPE]
     466                 :            : #define int16_type_node                 c_global_trees[CTI_INT16_TYPE]
     467                 :            : #define int32_type_node                 c_global_trees[CTI_INT32_TYPE]
     468                 :            : #define int64_type_node                 c_global_trees[CTI_INT64_TYPE]
     469                 :            : #define uint8_type_node                 c_global_trees[CTI_UINT8_TYPE]
     470                 :            : #define c_uint16_type_node              c_global_trees[CTI_UINT16_TYPE]
     471                 :            : #define c_uint32_type_node              c_global_trees[CTI_UINT32_TYPE]
     472                 :            : #define c_uint64_type_node              c_global_trees[CTI_UINT64_TYPE]
     473                 :            : #define int_least8_type_node            c_global_trees[CTI_INT_LEAST8_TYPE]
     474                 :            : #define int_least16_type_node           c_global_trees[CTI_INT_LEAST16_TYPE]
     475                 :            : #define int_least32_type_node           c_global_trees[CTI_INT_LEAST32_TYPE]
     476                 :            : #define int_least64_type_node           c_global_trees[CTI_INT_LEAST64_TYPE]
     477                 :            : #define uint_least8_type_node           c_global_trees[CTI_UINT_LEAST8_TYPE]
     478                 :            : #define uint_least16_type_node          c_global_trees[CTI_UINT_LEAST16_TYPE]
     479                 :            : #define uint_least32_type_node          c_global_trees[CTI_UINT_LEAST32_TYPE]
     480                 :            : #define uint_least64_type_node          c_global_trees[CTI_UINT_LEAST64_TYPE]
     481                 :            : #define int_fast8_type_node             c_global_trees[CTI_INT_FAST8_TYPE]
     482                 :            : #define int_fast16_type_node            c_global_trees[CTI_INT_FAST16_TYPE]
     483                 :            : #define int_fast32_type_node            c_global_trees[CTI_INT_FAST32_TYPE]
     484                 :            : #define int_fast64_type_node            c_global_trees[CTI_INT_FAST64_TYPE]
     485                 :            : #define uint_fast8_type_node            c_global_trees[CTI_UINT_FAST8_TYPE]
     486                 :            : #define uint_fast16_type_node           c_global_trees[CTI_UINT_FAST16_TYPE]
     487                 :            : #define uint_fast32_type_node           c_global_trees[CTI_UINT_FAST32_TYPE]
     488                 :            : #define uint_fast64_type_node           c_global_trees[CTI_UINT_FAST64_TYPE]
     489                 :            : #define intptr_type_node                c_global_trees[CTI_INTPTR_TYPE]
     490                 :            : #define uintptr_type_node               c_global_trees[CTI_UINTPTR_TYPE]
     491                 :            : 
     492                 :            : #define truthvalue_type_node            c_global_trees[CTI_TRUTHVALUE_TYPE]
     493                 :            : #define truthvalue_true_node            c_global_trees[CTI_TRUTHVALUE_TRUE]
     494                 :            : #define truthvalue_false_node           c_global_trees[CTI_TRUTHVALUE_FALSE]
     495                 :            : 
     496                 :            : #define char_array_type_node            c_global_trees[CTI_CHAR_ARRAY_TYPE]
     497                 :            : #define char8_array_type_node           c_global_trees[CTI_CHAR8_ARRAY_TYPE]
     498                 :            : #define char16_array_type_node          c_global_trees[CTI_CHAR16_ARRAY_TYPE]
     499                 :            : #define char32_array_type_node          c_global_trees[CTI_CHAR32_ARRAY_TYPE]
     500                 :            : #define wchar_array_type_node           c_global_trees[CTI_WCHAR_ARRAY_TYPE]
     501                 :            : #define string_type_node                c_global_trees[CTI_STRING_TYPE]
     502                 :            : #define const_string_type_node          c_global_trees[CTI_CONST_STRING_TYPE]
     503                 :            : 
     504                 :            : #define default_function_type           c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
     505                 :            : 
     506                 :            : #define function_name_decl_node         c_global_trees[CTI_FUNCTION_NAME_DECL]
     507                 :            : #define pretty_function_name_decl_node  c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
     508                 :            : #define c99_function_name_decl_node             c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
     509                 :            : #define saved_function_name_decls       c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
     510                 :            : 
     511                 :            : /* The node for C++ `__null'.  */
     512                 :            : #define null_node                       c_global_trees[CTI_NULL]
     513                 :            : 
     514                 :            : extern GTY(()) tree c_global_trees[CTI_MAX];
     515                 :            : 
     516                 :            : /* Mark which labels are explicitly declared.
     517                 :            :    These may be shadowed, and may be referenced from nested functions.  */
     518                 :            : #define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
     519                 :            : 
     520                 :            : enum c_language_kind
     521                 :            : {
     522                 :            :   clk_c         = 0,            /* C90, C94, C99, C11 or C2X */
     523                 :            :   clk_objc      = 1,            /* clk_c with ObjC features.  */
     524                 :            :   clk_cxx       = 2,            /* ANSI/ISO C++ */
     525                 :            :   clk_objcxx    = 3             /* clk_cxx with ObjC features.  */
     526                 :            : };
     527                 :            : 
     528                 :            : /* To test for a specific language use c_language, defined by each
     529                 :            :    front end.  For "ObjC features" or "not C++" use the macros.  */
     530                 :            : extern c_language_kind c_language;
     531                 :            : 
     532                 :            : #define c_dialect_cxx()         ((c_language & clk_cxx) != 0)
     533                 :            : #define c_dialect_objc()        ((c_language & clk_objc) != 0)
     534                 :            : 
     535                 :            : /* The various name of operator that appears in error messages. */
     536                 :            : enum ref_operator {
     537                 :            :   /* NULL */
     538                 :            :   RO_NULL,
     539                 :            :   /* array indexing */
     540                 :            :   RO_ARRAY_INDEXING,
     541                 :            :   /* unary * */
     542                 :            :   RO_UNARY_STAR,
     543                 :            :   /* -> */
     544                 :            :   RO_ARROW,
     545                 :            :   /* implicit conversion */
     546                 :            :   RO_IMPLICIT_CONVERSION,
     547                 :            :   /* ->* */
     548                 :            :   RO_ARROW_STAR
     549                 :            : };
     550                 :            : 
     551                 :            : /* Information about a statement tree.  */
     552                 :            : 
     553                 :            : struct GTY(()) stmt_tree_s {
     554                 :            :   /* A stack of statement lists being collected.  */
     555                 :            :   vec<tree, va_gc> *x_cur_stmt_list;
     556                 :            : 
     557                 :            :   /* In C++, Nonzero if we should treat statements as full
     558                 :            :      expressions.  In particular, this variable is non-zero if at the
     559                 :            :      end of a statement we should destroy any temporaries created
     560                 :            :      during that statement.  Similarly, if, at the end of a block, we
     561                 :            :      should destroy any local variables in this block.  Normally, this
     562                 :            :      variable is nonzero, since those are the normal semantics of
     563                 :            :      C++.
     564                 :            : 
     565                 :            :      This flag has no effect in C.  */
     566                 :            :   int stmts_are_full_exprs_p;
     567                 :            : };
     568                 :            : 
     569                 :            : typedef struct stmt_tree_s *stmt_tree;
     570                 :            : 
     571                 :            : /* Global state pertinent to the current function.  Some C dialects
     572                 :            :    extend this structure with additional fields.  */
     573                 :            : 
     574                 :            : struct GTY(()) c_language_function {
     575                 :            :   /* While we are parsing the function, this contains information
     576                 :            :      about the statement-tree that we are building.  */
     577                 :            :   struct stmt_tree_s x_stmt_tree;
     578                 :            : 
     579                 :            :   /* Vector of locally defined typedefs, for
     580                 :            :      -Wunused-local-typedefs.  */
     581                 :            :   vec<tree, va_gc> *local_typedefs;
     582                 :            : };
     583                 :            : 
     584                 :            : #define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
     585                 :            : 
     586                 :            : /* When building a statement-tree, this is the current statement list
     587                 :            :    being collected.  */
     588                 :            : #define cur_stmt_list   (stmt_list_stack->last ())
     589                 :            : 
     590                 :            : #define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
     591                 :            : 
     592                 :            : /* Language-specific hooks.  */
     593                 :            : 
     594                 :            : /* If non-NULL, this function is called after a precompile header file
     595                 :            :    is loaded.  */
     596                 :            : extern void (*lang_post_pch_load) (void);
     597                 :            : 
     598                 :            : extern void push_file_scope (void);
     599                 :            : extern void pop_file_scope (void);
     600                 :            : extern stmt_tree current_stmt_tree (void);
     601                 :            : extern tree push_stmt_list (void);
     602                 :            : extern tree pop_stmt_list (tree);
     603                 :            : extern tree add_stmt (tree);
     604                 :            : extern void push_cleanup (tree, tree, bool);
     605                 :            : 
     606                 :            : extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
     607                 :            :                                location_t, tree, tree);
     608                 :            : extern tree build_indirect_ref (location_t, tree, ref_operator);
     609                 :            : 
     610                 :            : extern bool has_c_linkage (const_tree decl);
     611                 :            : extern bool c_decl_implicit (const_tree);
     612                 :            : 
     613                 :            : /* Switches common to the C front ends.  */
     614                 :            : 
     615                 :            : /* Nonzero means don't output line number information.  */
     616                 :            : 
     617                 :            : extern char flag_no_line_commands;
     618                 :            : 
     619                 :            : /* Nonzero causes -E output not to be done, but directives such as
     620                 :            :    #define that have side effects are still obeyed.  */
     621                 :            : 
     622                 :            : extern char flag_no_output;
     623                 :            : 
     624                 :            : /* Nonzero means dump macros in some fashion; contains the 'D', 'M',
     625                 :            :    'N' or 'U' of the command line switch.  */
     626                 :            : 
     627                 :            : extern char flag_dump_macros;
     628                 :            : 
     629                 :            : /* Nonzero means pass #include lines through to the output.  */
     630                 :            : 
     631                 :            : extern char flag_dump_includes;
     632                 :            : 
     633                 :            : /* Nonzero means process PCH files while preprocessing.  */
     634                 :            : 
     635                 :            : extern bool flag_pch_preprocess;
     636                 :            : 
     637                 :            : /* The file name to which we should write a precompiled header, or
     638                 :            :    NULL if no header will be written in this compile.  */
     639                 :            : 
     640                 :            : extern const char *pch_file;
     641                 :            : 
     642                 :            : /* Nonzero if an ISO standard was selected.  It rejects macros in the
     643                 :            :    user's namespace.  */
     644                 :            : 
     645                 :            : extern int flag_iso;
     646                 :            : 
     647                 :            : /* C/ObjC language option variables.  */
     648                 :            : 
     649                 :            : 
     650                 :            : /* Nonzero means allow type mismatches in conditional expressions;
     651                 :            :    just make their values `void'.  */
     652                 :            : 
     653                 :            : extern int flag_cond_mismatch;
     654                 :            : 
     655                 :            : /* Nonzero means enable C89 Amendment 1 features.  */
     656                 :            : 
     657                 :            : extern int flag_isoc94;
     658                 :            : 
     659                 :            : /* Nonzero means use the ISO C99 (or later) dialect of C.  */
     660                 :            : 
     661                 :            : extern int flag_isoc99;
     662                 :            : 
     663                 :            : /* Nonzero means use the ISO C11 (or later) dialect of C.  */
     664                 :            : 
     665                 :            : extern int flag_isoc11;
     666                 :            : 
     667                 :            : /* Nonzero means use the ISO C2X dialect of C.  */
     668                 :            : 
     669                 :            : extern int flag_isoc2x;
     670                 :            : 
     671                 :            : /* Nonzero means that we have builtin functions, and main is an int.  */
     672                 :            : 
     673                 :            : extern int flag_hosted;
     674                 :            : 
     675                 :            : /* ObjC language option variables.  */
     676                 :            : 
     677                 :            : 
     678                 :            : /* Tells the compiler that this is a special run.  Do not perform any
     679                 :            :    compiling, instead we are to test some platform dependent features
     680                 :            :    and output a C header file with appropriate definitions.  */
     681                 :            : 
     682                 :            : extern int print_struct_values;
     683                 :            : 
     684                 :            : /* Tells the compiler what is the constant string class for ObjC.  */
     685                 :            : 
     686                 :            : extern const char *constant_string_class_name;
     687                 :            : 
     688                 :            : 
     689                 :            : /* C++ language option variables.  */
     690                 :            : 
     691                 :            : /* The reference version of the ABI for -Wabi.  */
     692                 :            : 
     693                 :            : extern int warn_abi_version;
     694                 :            : 
     695                 :            : /* Return TRUE if one of {flag_abi_version,flag_abi_compat_version} is
     696                 :            :    less than N and the other is at least N.  */
     697                 :            : #define abi_compat_version_crosses(N)           \
     698                 :            :   (abi_version_at_least(N)                      \
     699                 :            :    != (flag_abi_compat_version == 0             \
     700                 :            :        || flag_abi_compat_version >= (N)))
     701                 :            : 
     702                 :            : /* Return TRUE if one of {flag_abi_version,warn_abi_version} is
     703                 :            :    less than N and the other is at least N, for use by -Wabi.  */
     704                 :            : #define abi_version_crosses(N)                  \
     705                 :            :   (abi_version_at_least(N)                      \
     706                 :            :    != (warn_abi_version == 0                    \
     707                 :            :        || warn_abi_version >= (N)))
     708                 :            : 
     709                 :            : /* The supported C++ dialects.  */
     710                 :            : 
     711                 :            : enum cxx_dialect {
     712                 :            :   cxx_unset,
     713                 :            :   /* C++98 with TC1  */
     714                 :            :   cxx98,
     715                 :            :   cxx03 = cxx98,
     716                 :            :   /* C++11  */
     717                 :            :   cxx0x,
     718                 :            :   cxx11 = cxx0x,
     719                 :            :   /* C++14 */
     720                 :            :   cxx14,
     721                 :            :   /* C++17 */
     722                 :            :   cxx17,
     723                 :            :   /* C++2a (C++20?) */
     724                 :            :   cxx2a
     725                 :            : };
     726                 :            : 
     727                 :            : /* The C++ dialect being used. C++98 is the default.  */
     728                 :            : extern enum cxx_dialect cxx_dialect;
     729                 :            : 
     730                 :            : /* Maximum template instantiation depth.  This limit is rather
     731                 :            :    arbitrary, but it exists to limit the time it takes to notice
     732                 :            :    excessively recursive template instantiations.  */
     733                 :            : 
     734                 :            : extern int max_tinst_depth;
     735                 :            : 
     736                 :            : /* Nonzero means that we should not issue warnings about problems that
     737                 :            :    occur when the code is executed, because the code being processed
     738                 :            :    is not expected to be executed.  This is set during parsing.  This
     739                 :            :    is used for cases like sizeof() and "0 ? a : b".  This is a count,
     740                 :            :    not a bool, because unexecuted expressions can nest.  */
     741                 :            : 
     742                 :            : extern int c_inhibit_evaluation_warnings;
     743                 :            : 
     744                 :            : /* Whether lexing has been completed, so subsequent preprocessor
     745                 :            :    errors should use the compiler's input_location.  */
     746                 :            : 
     747                 :            : extern bool done_lexing;
     748                 :            : 
     749                 :            : /* C types are partitioned into three subsets: object, function, and
     750                 :            :    incomplete types.  */
     751                 :            : #define C_TYPE_OBJECT_P(type) \
     752                 :            :   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
     753                 :            : 
     754                 :            : #define C_TYPE_INCOMPLETE_P(type) \
     755                 :            :   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
     756                 :            : 
     757                 :            : #define C_TYPE_FUNCTION_P(type) \
     758                 :            :   (TREE_CODE (type) == FUNCTION_TYPE)
     759                 :            : 
     760                 :            : /* For convenience we define a single macro to identify the class of
     761                 :            :    object or incomplete types.  */
     762                 :            : #define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
     763                 :            :   (!C_TYPE_FUNCTION_P (type))
     764                 :            : 
     765                 :            : /* Return true if TYPE is a vector type that should be subject to the GNU
     766                 :            :    vector extensions (as opposed to a vector type that is used only for
     767                 :            :    the purposes of defining target-specific built-in functions).  */
     768                 :            : 
     769                 :            : inline bool
     770                 :  158554305 : gnu_vector_type_p (const_tree type)
     771                 :            : {
     772                 :  235944116 :   return TREE_CODE (type) == VECTOR_TYPE && !TYPE_INDIVISIBLE_P (type);
     773                 :            : }
     774                 :            : 
     775                 :            : struct visibility_flags
     776                 :            : {
     777                 :            :   unsigned inpragma : 1;        /* True when in #pragma GCC visibility.  */
     778                 :            :   unsigned inlines_hidden : 1;  /* True when -finlineshidden in effect.  */
     779                 :            : };
     780                 :            : 
     781                 :            : /* These enumerators are possible types of unsafe conversions.  */
     782                 :            : enum conversion_safety {
     783                 :            :   /* The conversion is safe.  */
     784                 :            :   SAFE_CONVERSION = 0,
     785                 :            :   /* Another type of conversion with problems.  */
     786                 :            :   UNSAFE_OTHER,
     787                 :            :   /* Conversion between signed and unsigned integers.  */
     788                 :            :   UNSAFE_SIGN,
     789                 :            :   /* Conversions that reduce the precision of reals including conversions
     790                 :            :      from reals to integers.  */
     791                 :            :   UNSAFE_REAL,
     792                 :            :   /* Conversions from complex to reals or integers, that discard imaginary
     793                 :            :      component.  */
     794                 :            :   UNSAFE_IMAGINARY
     795                 :            : };
     796                 :            : 
     797                 :            : /* Global visibility options.  */
     798                 :            : extern struct visibility_flags visibility_options;
     799                 :            : 
     800                 :            : /* Attribute table common to the C front ends.  */
     801                 :            : extern const struct attribute_spec c_common_attribute_table[];
     802                 :            : extern const struct attribute_spec c_common_format_attribute_table[];
     803                 :            : 
     804                 :            : /* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
     805                 :            :    ID is the identifier to use, NAME is the string.
     806                 :            :    TYPE_DEP indicates whether it depends on type of the function or not
     807                 :            :    (i.e. __PRETTY_FUNCTION__).  */
     808                 :            : 
     809                 :            : extern tree (*make_fname_decl) (location_t, tree, int);
     810                 :            : 
     811                 :            : /* In c-decl.c and cp/tree.c.  FIXME.  */
     812                 :            : extern void c_register_addr_space (const char *str, addr_space_t as);
     813                 :            : 
     814                 :            : /* In c-common.c.  */
     815                 :            : extern bool in_late_binary_op;
     816                 :            : extern const char *c_addr_space_name (addr_space_t as);
     817                 :            : extern tree identifier_global_value (tree);
     818                 :            : extern tree identifier_global_tag (tree);
     819                 :            : extern bool names_builtin_p (const char *);
     820                 :            : extern tree c_linkage_bindings (tree);
     821                 :            : extern void record_builtin_type (enum rid, const char *, tree);
     822                 :            : extern tree build_void_list_node (void);
     823                 :            : extern void start_fname_decls (void);
     824                 :            : extern void finish_fname_decls (void);
     825                 :            : extern const char *fname_as_string (int);
     826                 :            : extern tree fname_decl (location_t, unsigned, tree);
     827                 :            : 
     828                 :            : extern int check_user_alignment (const_tree, bool, bool);
     829                 :            : extern bool check_function_arguments (location_t loc, const_tree, const_tree,
     830                 :            :                                       int, tree *, vec<location_t> *);
     831                 :            : extern void check_function_arguments_recurse (void (*)
     832                 :            :                                               (void *, tree,
     833                 :            :                                                unsigned HOST_WIDE_INT),
     834                 :            :                                               void *, tree,
     835                 :            :                                               unsigned HOST_WIDE_INT);
     836                 :            : extern bool check_builtin_function_arguments (location_t, vec<location_t>,
     837                 :            :                                               tree, tree, int, tree *);
     838                 :            : extern void check_function_format (const_tree, tree, int, tree *,
     839                 :            :                                    vec<location_t> *);
     840                 :            : extern bool attribute_fallthrough_p (tree);
     841                 :            : extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
     842                 :            : extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
     843                 :            : extern bool c_common_handle_option (size_t, const char *, HOST_WIDE_INT, int,
     844                 :            :                                     location_t,
     845                 :            :                                     const struct cl_option_handlers *);
     846                 :            : extern bool default_handle_c_option (size_t, const char *, int);
     847                 :            : extern tree c_common_type_for_mode (machine_mode, int);
     848                 :            : extern tree c_common_type_for_size (unsigned int, int);
     849                 :            : extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
     850                 :            :                                                 int, int);
     851                 :            : extern tree c_common_unsigned_type (tree);
     852                 :            : extern tree c_common_signed_type (tree);
     853                 :            : extern tree c_common_signed_or_unsigned_type (int, tree);
     854                 :            : extern void c_common_init_ts (void);
     855                 :            : extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
     856                 :            : extern enum conversion_safety unsafe_conversion_p (tree, tree, tree, bool);
     857                 :            : extern bool decl_with_nonnull_addr_p (const_tree);
     858                 :            : extern tree c_fully_fold (tree, bool, bool *, bool = false);
     859                 :            : extern tree c_wrap_maybe_const (tree, bool);
     860                 :            : extern tree c_common_truthvalue_conversion (location_t, tree);
     861                 :            : extern void c_apply_type_quals_to_decl (int, tree);
     862                 :            : extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int);
     863                 :            : extern tree c_alignof_expr (location_t, tree);
     864                 :            : /* Print an error message for invalid operands to arith operation CODE.
     865                 :            :    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
     866                 :            : extern void binary_op_error (rich_location *, enum tree_code, tree, tree);
     867                 :            : extern tree fix_string_type (tree);
     868                 :            : extern tree convert_and_check (location_t, tree, tree);
     869                 :            : extern bool c_determine_visibility (tree);
     870                 :            : extern bool vector_types_compatible_elements_p (tree, tree);
     871                 :            : extern void mark_valid_location_for_stdc_pragma (bool);
     872                 :            : extern bool valid_location_for_stdc_pragma_p (void);
     873                 :            : extern void set_float_const_decimal64 (void);
     874                 :            : extern void clear_float_const_decimal64 (void);
     875                 :            : extern bool float_const_decimal64_p (void);
     876                 :            : 
     877                 :            : extern bool keyword_begins_type_specifier (enum rid);
     878                 :            : extern bool keyword_is_storage_class_specifier (enum rid);
     879                 :            : extern bool keyword_is_type_qualifier (enum rid);
     880                 :            : extern bool keyword_is_decl_specifier (enum rid);
     881                 :            : extern unsigned max_align_t_align (void);
     882                 :            : extern bool cxx_fundamental_alignment_p (unsigned);
     883                 :            : extern bool pointer_to_zero_sized_aggr_p (tree);
     884                 :            : extern bool bool_promoted_to_int_p (tree);
     885                 :            : extern tree fold_for_warn (tree);
     886                 :            : extern tree c_common_get_narrower (tree, int *);
     887                 :            : extern bool get_attribute_operand (tree, unsigned HOST_WIDE_INT *);
     888                 :            : 
     889                 :            : #define c_sizeof(LOC, T)  c_sizeof_or_alignof_type (LOC, T, true, false, 1)
     890                 :            : #define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
     891                 :            : 
     892                 :            : /* Subroutine of build_binary_op, used for certain operations.  */
     893                 :            : extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
     894                 :            : 
     895                 :            : /* Subroutine of build_binary_op, used for comparison operations.
     896                 :            :    See if the operands have both been converted from subword integer types
     897                 :            :    and, if so, perhaps change them both back to their original type.  */
     898                 :            : extern tree shorten_compare (location_t, tree *, tree *, tree *,
     899                 :            :                              enum tree_code *);
     900                 :            : 
     901                 :            : extern tree pointer_int_sum (location_t, enum tree_code, tree, tree,
     902                 :            :                              bool = true);
     903                 :            : 
     904                 :            : /* Add qualifiers to a type, in the fashion for C.  */
     905                 :            : extern tree c_build_qualified_type (tree, int, tree = NULL_TREE, size_t = 0);
     906                 :            : 
     907                 :            : /* Build tree nodes and builtin functions common to both C and C++ language
     908                 :            :    frontends.  */
     909                 :            : extern void c_common_nodes_and_builtins (void);
     910                 :            : 
     911                 :            : extern void disable_builtin_function (const char *);
     912                 :            : 
     913                 :            : extern void set_compound_literal_name (tree decl);
     914                 :            : 
     915                 :            : extern tree build_va_arg (location_t, tree, tree);
     916                 :            : 
     917                 :            : extern const unsigned int c_family_lang_mask;
     918                 :            : extern unsigned int c_common_option_lang_mask (void);
     919                 :            : extern void c_common_diagnostics_set_defaults (diagnostic_context *);
     920                 :            : extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
     921                 :            : extern void c_common_init_options_struct (struct gcc_options *);
     922                 :            : extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
     923                 :            : extern bool c_common_post_options (const char **);
     924                 :            : extern bool c_common_init (void);
     925                 :            : extern void c_common_finish (void);
     926                 :            : extern void c_common_parse_file (void);
     927                 :            : extern FILE *get_dump_info (int, dump_flags_t *);
     928                 :            : extern alias_set_type c_common_get_alias_set (tree);
     929                 :            : extern void c_register_builtin_type (tree, const char*);
     930                 :            : extern bool c_promoting_integer_type_p (const_tree);
     931                 :            : extern bool self_promoting_args_p (const_tree);
     932                 :            : extern tree strip_pointer_operator (tree);
     933                 :            : extern tree strip_pointer_or_array_types (tree);
     934                 :            : extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
     935                 :            : 
     936                 :            : /* This is the basic parsing function.  */
     937                 :            : extern void c_parse_file (void);
     938                 :            : 
     939                 :            : extern void c_parse_final_cleanups (void);
     940                 :            : 
     941                 :            : /* These macros provide convenient access to the various _STMT nodes.  */
     942                 :            : 
     943                 :            : /* Nonzero if a given STATEMENT_LIST represents the outermost binding
     944                 :            :    if a statement expression.  */
     945                 :            : #define STATEMENT_LIST_STMT_EXPR(NODE) \
     946                 :            :   TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
     947                 :            : 
     948                 :            : /* Nonzero if a label has been added to the statement list.  */
     949                 :            : #define STATEMENT_LIST_HAS_LABEL(NODE) \
     950                 :            :   TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
     951                 :            : 
     952                 :            : /* C_MAYBE_CONST_EXPR accessors.  */
     953                 :            : #define C_MAYBE_CONST_EXPR_PRE(NODE)                    \
     954                 :            :   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
     955                 :            : #define C_MAYBE_CONST_EXPR_EXPR(NODE)                   \
     956                 :            :   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
     957                 :            : #define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE)           \
     958                 :            :   TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
     959                 :            : #define C_MAYBE_CONST_EXPR_NON_CONST(NODE)              \
     960                 :            :   TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
     961                 :            : #define EXPR_INT_CONST_OPERANDS(EXPR)                   \
     962                 :            :   (INTEGRAL_TYPE_P (TREE_TYPE (EXPR))                   \
     963                 :            :    && (TREE_CODE (EXPR) == INTEGER_CST                  \
     964                 :            :        || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR       \
     965                 :            :            && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
     966                 :            : 
     967                 :            : /* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
     968                 :            : #define DECL_C_BIT_FIELD(NODE) \
     969                 :            :   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
     970                 :            : #define SET_DECL_C_BIT_FIELD(NODE) \
     971                 :            :   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
     972                 :            : #define CLEAR_DECL_C_BIT_FIELD(NODE) \
     973                 :            :   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
     974                 :            : 
     975                 :            : /* True if the decl was an unnamed bitfield.  */
     976                 :            : #define DECL_UNNAMED_BIT_FIELD(NODE) \
     977                 :            :   (DECL_C_BIT_FIELD (NODE) && !DECL_NAME (NODE))
     978                 :            : 
     979                 :            : extern tree do_case (location_t, tree, tree);
     980                 :            : extern tree build_stmt (location_t, enum tree_code, ...);
     981                 :            : extern tree build_real_imag_expr (location_t, enum tree_code, tree);
     982                 :            : 
     983                 :            : /* These functions must be defined by each front-end which implements
     984                 :            :    a variant of the C language.  They are used in c-common.c.  */
     985                 :            : 
     986                 :            : extern tree build_unary_op (location_t, enum tree_code, tree, bool);
     987                 :            : extern tree build_binary_op (location_t, enum tree_code, tree, tree, bool);
     988                 :            : extern tree perform_integral_promotions (tree);
     989                 :            : 
     990                 :            : /* These functions must be defined by each front-end which implements
     991                 :            :    a variant of the C language.  They are used by port files.  */
     992                 :            : 
     993                 :            : extern tree default_conversion (tree);
     994                 :            : 
     995                 :            : /* Given two integer or real types, return the type for their sum.
     996                 :            :    Given two compatible ANSI C types, returns the merged type.  */
     997                 :            : 
     998                 :            : extern tree common_type (tree, tree);
     999                 :            : 
    1000                 :            : extern tree decl_constant_value (tree);
    1001                 :            : 
    1002                 :            : /* Handle increment and decrement of boolean types.  */
    1003                 :            : extern tree boolean_increment (enum tree_code, tree);
    1004                 :            : 
    1005                 :            : extern int case_compare (splay_tree_key, splay_tree_key);
    1006                 :            : 
    1007                 :            : extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree);
    1008                 :            : extern bool c_switch_covers_all_cases_p (splay_tree, tree);
    1009                 :            : 
    1010                 :            : extern tree build_function_call (location_t, tree, tree);
    1011                 :            : 
    1012                 :            : extern tree build_function_call_vec (location_t, vec<location_t>, tree,
    1013                 :            :                                      vec<tree, va_gc> *, vec<tree, va_gc> *,
    1014                 :            :                                      tree = NULL_TREE);
    1015                 :            : 
    1016                 :            : extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
    1017                 :            : 
    1018                 :            : extern tree finish_label_address_expr (tree, location_t);
    1019                 :            : 
    1020                 :            : /* Same function prototype, but the C and C++ front ends have
    1021                 :            :    different implementations.  Used in c-common.c.  */
    1022                 :            : extern tree lookup_label (tree);
    1023                 :            : extern tree lookup_name (tree);
    1024                 :            : extern bool lvalue_p (const_tree);
    1025                 :            : 
    1026                 :            : extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
    1027                 :            : extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
    1028                 :            : extern tree c_build_vec_perm_expr (location_t, tree, tree, tree, bool = true);
    1029                 :            : extern tree c_build_vec_convert (location_t, tree, location_t, tree, bool = true);
    1030                 :            : 
    1031                 :            : extern void init_c_lex (void);
    1032                 :            : 
    1033                 :            : extern void c_cpp_builtins (cpp_reader *);
    1034                 :            : extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
    1035                 :            : extern bool c_cpp_diagnostic (cpp_reader *, enum cpp_diagnostic_level,
    1036                 :            :                               enum cpp_warning_reason, rich_location *,
    1037                 :            :                               const char *, va_list *)
    1038                 :            :      ATTRIBUTE_GCC_DIAG(5,0);
    1039                 :            : extern int c_common_has_attribute (cpp_reader *);
    1040                 :            : extern int c_common_has_builtin (cpp_reader *);
    1041                 :            : 
    1042                 :            : extern bool parse_optimize_options (tree, bool);
    1043                 :            : 
    1044                 :            : /* Positive if an implicit `extern "C"' scope has just been entered;
    1045                 :            :    negative if such a scope has just been exited.  */
    1046                 :            : extern GTY(()) int pending_lang_change;
    1047                 :            : 
    1048                 :            : /* Information recorded about each file examined during compilation.  */
    1049                 :            : 
    1050                 :            : struct c_fileinfo
    1051                 :            : {
    1052                 :            :   int time;     /* Time spent in the file.  */
    1053                 :            : 
    1054                 :            :   /* Flags used only by C++.
    1055                 :            :      INTERFACE_ONLY nonzero means that we are in an "interface" section
    1056                 :            :      of the compiler.  INTERFACE_UNKNOWN nonzero means we cannot trust
    1057                 :            :      the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN is zero and
    1058                 :            :      INTERFACE_ONLY is zero, it means that we are responsible for
    1059                 :            :      exporting definitions that others might need.  */
    1060                 :            :   short interface_only;
    1061                 :            :   short interface_unknown;
    1062                 :            : };
    1063                 :            : 
    1064                 :            : struct c_fileinfo *get_fileinfo (const char *);
    1065                 :            : extern void dump_time_statistics (void);
    1066                 :            : 
    1067                 :            : extern bool c_dump_tree (void *, tree);
    1068                 :            : 
    1069                 :            : extern void verify_sequence_points (tree);
    1070                 :            : 
    1071                 :            : extern tree fold_offsetof (tree, tree = size_type_node,
    1072                 :            :                            tree_code ctx = ERROR_MARK);
    1073                 :            : 
    1074                 :            : extern int complete_array_type (tree *, tree, bool);
    1075                 :            : extern void complete_flexible_array_elts (tree);
    1076                 :            : 
    1077                 :            : extern tree builtin_type_for_size (int, bool);
    1078                 :            : 
    1079                 :            : extern void c_common_mark_addressable_vec (tree);
    1080                 :            : 
    1081                 :            : extern void set_underlying_type (tree);
    1082                 :            : extern bool user_facing_original_type_p (const_tree);
    1083                 :            : extern void record_types_used_by_current_var_decl (tree);
    1084                 :            : extern vec<tree, va_gc> *make_tree_vector (void);
    1085                 :            : extern void release_tree_vector (vec<tree, va_gc> *);
    1086                 :            : extern vec<tree, va_gc> *make_tree_vector_single (tree);
    1087                 :            : extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
    1088                 :            : extern vec<tree, va_gc> *make_tree_vector_from_ctor (tree);
    1089                 :            : extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
    1090                 :            : 
    1091                 :            : /* Used for communication between c_common_type_for_mode and
    1092                 :            :    c_register_builtin_type.  */
    1093                 :            : extern GTY(()) tree registered_builtin_types;
    1094                 :            : 
    1095                 :            : /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
    1096                 :            :    timestamp to replace embedded current dates to get reproducible
    1097                 :            :    results.  Returns -1 if SOURCE_DATE_EPOCH is not defined.  */
    1098                 :            : extern time_t cb_get_source_date_epoch (cpp_reader *pfile);
    1099                 :            : 
    1100                 :            : /* The value (as a unix timestamp) corresponds to date
    1101                 :            :    "Dec 31 9999 23:59:59 UTC", which is the latest date that __DATE__ and
    1102                 :            :    __TIME__ can store.  */
    1103                 :            : #define MAX_SOURCE_DATE_EPOCH HOST_WIDE_INT_C (253402300799)
    1104                 :            : 
    1105                 :            : /* Callback for libcpp for offering spelling suggestions for misspelled
    1106                 :            :    directives.  */
    1107                 :            : extern const char *cb_get_suggestion (cpp_reader *, const char *,
    1108                 :            :                                       const char *const *);
    1109                 :            : 
    1110                 :            : extern GTY(()) string_concat_db *g_string_concat_db;
    1111                 :            : 
    1112                 :            : class substring_loc;
    1113                 :            : extern const char *c_get_substring_location (const substring_loc &substr_loc,
    1114                 :            :                                              location_t *out_loc);
    1115                 :            : 
    1116                 :            : /* In c-gimplify.c  */
    1117                 :            : extern void c_genericize (tree);
    1118                 :            : extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
    1119                 :            : extern tree c_build_bind_expr (location_t, tree, tree);
    1120                 :            : 
    1121                 :            : /* In c-lex.c.  */
    1122                 :            : extern enum cpp_ttype
    1123                 :            : conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind);
    1124                 :            : 
    1125                 :            : /* In c-pch.c  */
    1126                 :            : extern void pch_init (void);
    1127                 :            : extern void pch_cpp_save_state (void);
    1128                 :            : extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
    1129                 :            : extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
    1130                 :            :                                const char *orig);
    1131                 :            : extern void c_common_write_pch (void);
    1132                 :            : extern void c_common_no_more_pch (void);
    1133                 :            : extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
    1134                 :            : 
    1135                 :            : /* In *-checksum.c */
    1136                 :            : extern const unsigned char executable_checksum[16];
    1137                 :            : 
    1138                 :            : /* In c-cppbuiltin.c  */
    1139                 :            : extern void builtin_define_std (const char *macro);
    1140                 :            : extern void builtin_define_with_value (const char *, const char *, int);
    1141                 :            : extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
    1142                 :            : extern void builtin_define_type_sizeof (const char *, tree);
    1143                 :            : extern void c_stddef_cpp_builtins (void);
    1144                 :            : extern void fe_file_change (const line_map_ordinary *);
    1145                 :            : extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char,
    1146                 :            :                            rich_location *richloc);
    1147                 :            : 
    1148                 :            : /* In c-ppoutput.c  */
    1149                 :            : extern void init_pp_output (FILE *);
    1150                 :            : extern void preprocess_file (cpp_reader *);
    1151                 :            : extern void pp_file_change (const line_map_ordinary *);
    1152                 :            : extern void pp_dir_change (cpp_reader *, const char *);
    1153                 :            : extern bool check_missing_format_attribute (tree, tree);
    1154                 :            : 
    1155                 :            : /* In c-omp.c  */
    1156                 :            : typedef wide_int_bitmask omp_clause_mask;
    1157                 :            : 
    1158                 :            : #define OMP_CLAUSE_MASK_1 omp_clause_mask (1)
    1159                 :            : 
    1160                 :            : enum c_omp_clause_split
    1161                 :            : {
    1162                 :            :   C_OMP_CLAUSE_SPLIT_TARGET = 0,
    1163                 :            :   C_OMP_CLAUSE_SPLIT_TEAMS,
    1164                 :            :   C_OMP_CLAUSE_SPLIT_DISTRIBUTE,
    1165                 :            :   C_OMP_CLAUSE_SPLIT_PARALLEL,
    1166                 :            :   C_OMP_CLAUSE_SPLIT_FOR,
    1167                 :            :   C_OMP_CLAUSE_SPLIT_SIMD,
    1168                 :            :   C_OMP_CLAUSE_SPLIT_COUNT,
    1169                 :            :   C_OMP_CLAUSE_SPLIT_SECTIONS = C_OMP_CLAUSE_SPLIT_FOR,
    1170                 :            :   C_OMP_CLAUSE_SPLIT_TASKLOOP = C_OMP_CLAUSE_SPLIT_FOR,
    1171                 :            :   C_OMP_CLAUSE_SPLIT_LOOP = C_OMP_CLAUSE_SPLIT_FOR
    1172                 :            : };
    1173                 :            : 
    1174                 :            : enum c_omp_region_type
    1175                 :            : {
    1176                 :            :   C_ORT_OMP                     = 1 << 0,
    1177                 :            :   C_ORT_ACC                     = 1 << 1,
    1178                 :            :   C_ORT_DECLARE_SIMD            = 1 << 2,
    1179                 :            :   C_ORT_OMP_DECLARE_SIMD        = C_ORT_OMP | C_ORT_DECLARE_SIMD
    1180                 :            : };
    1181                 :            : 
    1182                 :            : extern tree c_finish_omp_master (location_t, tree);
    1183                 :            : extern tree c_finish_omp_taskgroup (location_t, tree, tree);
    1184                 :            : extern tree c_finish_omp_critical (location_t, tree, tree, tree);
    1185                 :            : extern tree c_finish_omp_ordered (location_t, tree, tree);
    1186                 :            : extern void c_finish_omp_barrier (location_t);
    1187                 :            : extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
    1188                 :            :                                  tree, tree, tree, tree, tree, bool,
    1189                 :            :                                  enum omp_memory_order, bool = false);
    1190                 :            : extern bool c_omp_depend_t_p (tree);
    1191                 :            : extern void c_finish_omp_depobj (location_t, tree, enum omp_clause_depend_kind,
    1192                 :            :                                  tree);
    1193                 :            : extern void c_finish_omp_flush (location_t, int);
    1194                 :            : extern void c_finish_omp_taskwait (location_t);
    1195                 :            : extern void c_finish_omp_taskyield (location_t);
    1196                 :            : extern tree c_finish_omp_for (location_t, enum tree_code, tree, tree, tree,
    1197                 :            :                               tree, tree, tree, tree, bool);
    1198                 :            : extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
    1199                 :            : extern bool c_omp_check_loop_iv_exprs (location_t, tree, tree, tree, tree,
    1200                 :            :                                        walk_tree_lh);
    1201                 :            : extern tree c_finish_oacc_wait (location_t, tree, tree);
    1202                 :            : extern tree c_oacc_split_loop_clauses (tree, tree *, bool);
    1203                 :            : extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
    1204                 :            :                                  tree, tree *);
    1205                 :            : extern tree c_omp_declare_simd_clauses_to_numbers (tree, tree);
    1206                 :            : extern void c_omp_declare_simd_clauses_to_decls (tree, tree);
    1207                 :            : extern bool c_omp_predefined_variable (tree);
    1208                 :            : extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
    1209                 :            : extern tree c_omp_check_context_selector (location_t, tree);
    1210                 :            : extern void c_omp_mark_declare_variant (location_t, tree, tree);
    1211                 :            : extern const char *c_omp_map_clause_name (tree, bool);
    1212                 :            : 
    1213                 :            : /* Return next tree in the chain for chain_next walking of tree nodes.  */
    1214                 :            : static inline tree
    1215                 :12118690000 : c_tree_chain_next (tree t)
    1216                 :            : {
    1217                 :            :   /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
    1218                 :            :      kind of object, never a long chain of nodes.  Prefer
    1219                 :            :      TYPE_NEXT_VARIANT for types.  */
    1220                 :12118690000 :   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
    1221                 : 1177921000 :     return TYPE_NEXT_VARIANT (t);
    1222                 :            :   /* Otherwise, if there is TREE_CHAIN, return it.  */
    1223                 :10940770000 :   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
    1224                 : 7406190000 :     return TREE_CHAIN (t);
    1225                 :            :   return NULL;
    1226                 :            : }
    1227                 :            : 
    1228                 :            : /* Mask used by tm_stmt_attr.  */
    1229                 :            : #define TM_STMT_ATTR_OUTER      2
    1230                 :            : #define TM_STMT_ATTR_ATOMIC     4
    1231                 :            : #define TM_STMT_ATTR_RELAXED    8
    1232                 :            : 
    1233                 :            : /* Mask used by tm_attr_to_mask and tm_mask_to_attr.  Note that these
    1234                 :            :    are ordered specifically such that more restrictive attributes are
    1235                 :            :    at lower bit positions.  This fact is known by the C++ tm attribute
    1236                 :            :    inheritance code such that least bit extraction (mask & -mask) results
    1237                 :            :    in the most restrictive attribute.  */
    1238                 :            : #define TM_ATTR_SAFE                    1
    1239                 :            : #define TM_ATTR_CALLABLE                2
    1240                 :            : #define TM_ATTR_PURE                    4
    1241                 :            : #define TM_ATTR_IRREVOCABLE             8
    1242                 :            : #define TM_ATTR_MAY_CANCEL_OUTER        16
    1243                 :            : 
    1244                 :            : /* A suffix-identifier value doublet that represents user-defined literals
    1245                 :            :    for C++-0x.  */
    1246                 :            : enum overflow_type {
    1247                 :            :   OT_UNDERFLOW = -1,
    1248                 :            :   OT_NONE,
    1249                 :            :   OT_OVERFLOW
    1250                 :            : };
    1251                 :            : 
    1252                 :            : struct GTY(()) tree_userdef_literal {
    1253                 :            :   struct tree_base base;
    1254                 :            :   tree suffix_id;
    1255                 :            :   tree value;
    1256                 :            :   tree num_string;
    1257                 :            :   enum overflow_type overflow;
    1258                 :            : };
    1259                 :            : 
    1260                 :            : #define USERDEF_LITERAL_SUFFIX_ID(NODE) \
    1261                 :            :   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
    1262                 :            : 
    1263                 :            : #define USERDEF_LITERAL_VALUE(NODE) \
    1264                 :            :   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
    1265                 :            : 
    1266                 :            : #define USERDEF_LITERAL_OVERFLOW(NODE) \
    1267                 :            :   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
    1268                 :            : 
    1269                 :            : #define USERDEF_LITERAL_NUM_STRING(NODE) \
    1270                 :            :   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
    1271                 :            : 
    1272                 :            : #define USERDEF_LITERAL_TYPE(NODE) \
    1273                 :            :   (TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
    1274                 :            : 
    1275                 :            : extern tree build_userdef_literal (tree suffix_id, tree value,
    1276                 :            :                                    enum overflow_type overflow,
    1277                 :            :                                    tree num_string);
    1278                 :            : 
    1279                 :            : extern bool convert_vector_to_array_for_subscript (location_t, tree *, tree);
    1280                 :            : 
    1281                 :            : /* Possibe cases of scalar_to_vector conversion.  */
    1282                 :            : enum stv_conv {
    1283                 :            :   stv_error,        /* Error occurred.  */
    1284                 :            :   stv_nothing,      /* Nothing happened.  */
    1285                 :            :   stv_firstarg,     /* First argument must be expanded.  */
    1286                 :            :   stv_secondarg     /* Second argument must be expanded.  */
    1287                 :            : };
    1288                 :            : 
    1289                 :            : extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
    1290                 :            :                                        tree op0, tree op1, bool);
    1291                 :            : 
    1292                 :            : extern tree find_inv_trees (tree *, int *, void *);
    1293                 :            : extern tree replace_inv_trees (tree *, int *, void *);
    1294                 :            : 
    1295                 :            : extern bool reject_gcc_builtin (const_tree, location_t = UNKNOWN_LOCATION);
    1296                 :            : extern bool valid_array_size_p (location_t, const_tree, tree, bool = true);
    1297                 :            : extern void invalid_array_size_error (location_t, cst_size_error,
    1298                 :            :                                       const_tree, const_tree);
    1299                 :            : 
    1300                 :            : /* In c-warn.c.  */
    1301                 :            : extern void constant_expression_warning (tree);
    1302                 :            : extern void constant_expression_error (tree);
    1303                 :            : extern void overflow_warning (location_t, tree, tree = NULL_TREE);
    1304                 :            : extern void warn_logical_operator (location_t, enum tree_code, tree,
    1305                 :            :                                    enum tree_code, tree, enum tree_code, tree);
    1306                 :            : extern void warn_tautological_cmp (const op_location_t &, enum tree_code,
    1307                 :            :                                    tree, tree);
    1308                 :            : extern void warn_logical_not_parentheses (location_t, enum tree_code, tree,
    1309                 :            :                                           tree);
    1310                 :            : extern bool warn_if_unused_value (const_tree, location_t);
    1311                 :            : extern bool strict_aliasing_warning (location_t, tree, tree);
    1312                 :            : extern void sizeof_pointer_memaccess_warning (location_t *, tree,
    1313                 :            :                                               vec<tree, va_gc> *, tree *,
    1314                 :            :                                               bool (*) (tree, tree));
    1315                 :            : extern void check_main_parameter_types (tree decl);
    1316                 :            : extern void warnings_for_convert_and_check (location_t, tree, tree, tree);
    1317                 :            : extern void c_do_switch_warnings (splay_tree, location_t, tree, tree, bool);
    1318                 :            : extern void warn_for_omitted_condop (location_t, tree);
    1319                 :            : extern bool warn_for_restrict (unsigned, tree *, unsigned);
    1320                 :            : extern void warn_for_address_or_pointer_of_packed_member (tree, tree);
    1321                 :            : 
    1322                 :            : /* Places where an lvalue, or modifiable lvalue, may be required.
    1323                 :            :    Used to select diagnostic messages in lvalue_error and
    1324                 :            :    readonly_error.  */
    1325                 :            : enum lvalue_use {
    1326                 :            :   lv_assign,
    1327                 :            :   lv_increment,
    1328                 :            :   lv_decrement,
    1329                 :            :   lv_addressof,
    1330                 :            :   lv_asm
    1331                 :            : };
    1332                 :            : 
    1333                 :            : extern void lvalue_error (location_t, enum lvalue_use);
    1334                 :            : extern void invalid_indirection_error (location_t, tree, ref_operator);
    1335                 :            : extern void readonly_error (location_t, tree, enum lvalue_use);
    1336                 :            : extern void warn_array_subscript_with_type_char (location_t, tree);
    1337                 :            : extern void warn_about_parentheses (location_t,
    1338                 :            :                                     enum tree_code,
    1339                 :            :                                     enum tree_code, tree,
    1340                 :            :                                     enum tree_code, tree);
    1341                 :            : extern void warn_for_unused_label (tree label);
    1342                 :            : extern void warn_for_div_by_zero (location_t, tree divisor);
    1343                 :            : extern void warn_for_memset (location_t, tree, tree, int);
    1344                 :            : extern void warn_for_sign_compare (location_t,
    1345                 :            :                                    tree orig_op0, tree orig_op1,
    1346                 :            :                                    tree op0, tree op1,
    1347                 :            :                                    tree result_type,
    1348                 :            :                                    enum tree_code resultcode);
    1349                 :            : extern void do_warn_double_promotion (tree, tree, tree, const char *,
    1350                 :            :                                       location_t);
    1351                 :            : extern void do_warn_unused_parameter (tree);
    1352                 :            : extern void record_locally_defined_typedef (tree);
    1353                 :            : extern void maybe_record_typedef_use (tree);
    1354                 :            : extern void maybe_warn_unused_local_typedefs (void);
    1355                 :            : extern void maybe_warn_bool_compare (location_t, enum tree_code, tree, tree);
    1356                 :            : extern bool maybe_warn_shift_overflow (location_t, tree, tree);
    1357                 :            : extern void warn_duplicated_cond_add_or_warn (location_t, tree, vec<tree> **);
    1358                 :            : extern bool diagnose_mismatched_attributes (tree, tree);
    1359                 :            : extern tree do_warn_duplicated_branches_r (tree *, int *, void *);
    1360                 :            : extern void warn_for_multistatement_macros (location_t, location_t,
    1361                 :            :                                             location_t, enum rid);
    1362                 :            : 
    1363                 :            : /* In c-attribs.c.  */
    1364                 :            : extern bool attribute_takes_identifier_p (const_tree);
    1365                 :            : extern tree handle_deprecated_attribute (tree *, tree, tree, int, bool *);
    1366                 :            : extern tree handle_unused_attribute (tree *, tree, tree, int, bool *);
    1367                 :            : extern tree handle_fallthrough_attribute (tree *, tree, tree, int, bool *);
    1368                 :            : extern int parse_tm_stmt_attr (tree, int);
    1369                 :            : extern int tm_attr_to_mask (tree);
    1370                 :            : extern tree tm_mask_to_attr (int);
    1371                 :            : extern tree find_tm_attribute (tree);
    1372                 :            : extern const struct attribute_spec::exclusions attr_cold_hot_exclusions[];
    1373                 :            : extern const struct attribute_spec::exclusions attr_noreturn_exclusions[];
    1374                 :            : extern tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
    1375                 :            : 
    1376                 :            : /* In c-format.c.  */
    1377                 :            : extern bool valid_format_string_type_p (tree);
    1378                 :            : 
    1379                 :            : /* A bitmap of flags to positional_argument.  */
    1380                 :            : enum posargflags {
    1381                 :            :   /* Consider positional attribute argument value zero valid.  */
    1382                 :            :   POSARG_ZERO = 1,
    1383                 :            :   /* Consider positional attribute argument value valid if it refers
    1384                 :            :      to the ellipsis (i.e., beyond the last typed argument).  */
    1385                 :            :   POSARG_ELLIPSIS = 2
    1386                 :            : };
    1387                 :            : 
    1388                 :            : extern tree positional_argument (const_tree, const_tree, tree, tree_code,
    1389                 :            :                                  int = 0, int = posargflags ());
    1390                 :            : 
    1391                 :            : extern enum flt_eval_method
    1392                 :            : excess_precision_mode_join (enum flt_eval_method, enum flt_eval_method);
    1393                 :            : 
    1394                 :            : extern int c_flt_eval_method (bool ts18661_p);
    1395                 :            : extern void add_no_sanitize_value (tree node, unsigned int flags);
    1396                 :            : 
    1397                 :            : extern void maybe_add_include_fixit (rich_location *, const char *, bool);
    1398                 :            : extern void maybe_suggest_missing_token_insertion (rich_location *richloc,
    1399                 :            :                                                    enum cpp_ttype token_type,
    1400                 :            :                                                    location_t prev_token_loc);
    1401                 :            : extern tree braced_lists_to_strings (tree, tree);
    1402                 :            : 
    1403                 :            : extern bool has_attribute (location_t, tree, tree, tree (*)(tree));
    1404                 :            : 
    1405                 :            : #if CHECKING_P
    1406                 :            : namespace selftest {
    1407                 :            :   /* Declarations for specific families of tests within c-family,
    1408                 :            :      by source file, in alphabetical order.  */
    1409                 :            :   extern void c_format_c_tests (void);
    1410                 :            :   extern void c_indentation_c_tests (void);
    1411                 :            :   extern void c_pretty_print_c_tests (void);
    1412                 :            :   extern void c_spellcheck_cc_tests (void);
    1413                 :            : 
    1414                 :            :   /* The entrypoint for running all of the above tests.  */
    1415                 :            :   extern void c_family_tests (void);
    1416                 :            : } // namespace selftest
    1417                 :            : #endif /* #if CHECKING_P */
    1418                 :            : 
    1419                 :            : #endif /* ! GCC_C_COMMON_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.