LCOV - code coverage report
Current view: top level - gcc/c-family - c-pretty-print.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 958 1311 73.1 %
Date: 2020-03-28 11:57:23 Functions: 71 83 85.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Subroutines common to both C and C++ pretty-printers.
       2                 :            :    Copyright (C) 2002-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "c-pretty-print.h"
      25                 :            : #include "diagnostic.h"
      26                 :            : #include "stor-layout.h"
      27                 :            : #include "stringpool.h"
      28                 :            : #include "attribs.h"
      29                 :            : #include "intl.h"
      30                 :            : #include "tree-pretty-print.h"
      31                 :            : #include "selftest.h"
      32                 :            : 
      33                 :            : /* The pretty-printer code is primarily designed to closely follow
      34                 :            :    (GNU) C and C++ grammars.  That is to be contrasted with spaghetti
      35                 :            :    codes we used to have in the past.  Following a structured
      36                 :            :    approach (preferably the official grammars) is believed to make it
      37                 :            :    much easier to add extensions and nifty pretty-printing effects that
      38                 :            :    takes expression or declaration contexts into account.  */
      39                 :            : 
      40                 :            : 
      41                 :            : #define pp_c_maybe_whitespace(PP)            \
      42                 :            :    do {                                      \
      43                 :            :      if ((PP)->padding == pp_before) \
      44                 :            :        pp_c_whitespace (PP);                 \
      45                 :            :    } while (0)
      46                 :            : 
      47                 :            : /* literal  */
      48                 :            : static void pp_c_char (c_pretty_printer *, int);
      49                 :            : 
      50                 :            : /* postfix-expression  */
      51                 :            : static void pp_c_initializer_list (c_pretty_printer *, tree);
      52                 :            : static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
      53                 :            : 
      54                 :            : static void pp_c_additive_expression (c_pretty_printer *, tree);
      55                 :            : static void pp_c_shift_expression (c_pretty_printer *, tree);
      56                 :            : static void pp_c_relational_expression (c_pretty_printer *, tree);
      57                 :            : static void pp_c_equality_expression (c_pretty_printer *, tree);
      58                 :            : static void pp_c_and_expression (c_pretty_printer *, tree);
      59                 :            : static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
      60                 :            : static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
      61                 :            : static void pp_c_logical_and_expression (c_pretty_printer *, tree);
      62                 :            : 
      63                 :            : /* declarations.  */
      64                 :            : 
      65                 :            : 
      66                 :            : /* Helper functions.  */
      67                 :            : 
      68                 :            : void
      69                 :   16067800 : pp_c_whitespace (c_pretty_printer *pp)
      70                 :            : {
      71                 :   16067800 :   pp_space (pp);
      72                 :   16067800 :   pp->padding = pp_none;
      73                 :   16067800 : }
      74                 :            : 
      75                 :            : void
      76                 :    3571900 : pp_c_left_paren (c_pretty_printer *pp)
      77                 :            : {
      78                 :    3571900 :   pp_left_paren (pp);
      79                 :    3571900 :   pp->padding = pp_none;
      80                 :    3571900 : }
      81                 :            : 
      82                 :            : void
      83                 :    3571900 : pp_c_right_paren (c_pretty_printer *pp)
      84                 :            : {
      85                 :    3571900 :   pp_right_paren (pp);
      86                 :    3571900 :   pp->padding = pp_none;
      87                 :    3571900 : }
      88                 :            : 
      89                 :            : void
      90                 :      11700 : pp_c_left_brace (c_pretty_printer *pp)
      91                 :            : {
      92                 :      11700 :   pp_left_brace (pp);
      93                 :      11700 :   pp->padding = pp_none;
      94                 :      11700 : }
      95                 :            : 
      96                 :            : void
      97                 :      11700 : pp_c_right_brace (c_pretty_printer *pp)
      98                 :            : {
      99                 :      11700 :   pp_right_brace (pp);
     100                 :      11700 :   pp->padding = pp_none;
     101                 :      11700 : }
     102                 :            : 
     103                 :            : void
     104                 :     249045 : pp_c_left_bracket (c_pretty_printer *pp)
     105                 :            : {
     106                 :     249045 :   pp_left_bracket (pp);
     107                 :     249045 :   pp->padding = pp_none;
     108                 :     249045 : }
     109                 :            : 
     110                 :            : void
     111                 :     249045 : pp_c_right_bracket (c_pretty_printer *pp)
     112                 :            : {
     113                 :     249045 :   pp_right_bracket (pp);
     114                 :     249045 :   pp->padding = pp_none;
     115                 :     249045 : }
     116                 :            : 
     117                 :            : void
     118                 :        539 : pp_c_dot (c_pretty_printer *pp)
     119                 :            : {
     120                 :        539 :   pp_dot (pp);
     121                 :        539 :   pp->padding = pp_none;
     122                 :        539 : }
     123                 :            : 
     124                 :            : void
     125                 :         47 : pp_c_ampersand (c_pretty_printer *pp)
     126                 :            : {
     127                 :         47 :   pp_ampersand (pp);
     128                 :         47 :   pp->padding = pp_none;
     129                 :         47 : }
     130                 :            : 
     131                 :            : void
     132                 :     429094 : pp_c_star (c_pretty_printer *pp)
     133                 :            : {
     134                 :     429094 :   pp_star (pp);
     135                 :     429094 :   pp->padding = pp_none;
     136                 :     429094 : }
     137                 :            : 
     138                 :            : void
     139                 :        255 : pp_c_arrow (c_pretty_printer *pp)
     140                 :            : {
     141                 :        255 :   pp_arrow (pp);
     142                 :        255 :   pp->padding = pp_none;
     143                 :        255 : }
     144                 :            : 
     145                 :            : void
     146                 :         23 : pp_c_semicolon (c_pretty_printer *pp)
     147                 :            : {
     148                 :         23 :   pp_semicolon (pp);
     149                 :         23 :   pp->padding = pp_none;
     150                 :         23 : }
     151                 :            : 
     152                 :            : void
     153                 :     303165 : pp_c_complement (c_pretty_printer *pp)
     154                 :            : {
     155                 :     303165 :   pp_complement (pp);
     156                 :     303165 :   pp->padding = pp_none;
     157                 :     303165 : }
     158                 :            : 
     159                 :            : void
     160                 :          0 : pp_c_exclamation (c_pretty_printer *pp)
     161                 :            : {
     162                 :          0 :   pp_exclamation (pp);
     163                 :          0 :   pp->padding = pp_none;
     164                 :          0 : }
     165                 :            : 
     166                 :            : /* Print out the external representation of QUALIFIERS.  */
     167                 :            : 
     168                 :            : void
     169                 :   81389100 : pp_c_cv_qualifiers (c_pretty_printer *pp, int qualifiers, bool func_type)
     170                 :            : {
     171                 :   81389100 :   const char *p = pp_last_position_in_text (pp);
     172                 :            : 
     173                 :   81389100 :   if (!qualifiers)
     174                 :            :     return;
     175                 :            : 
     176                 :            :   /* The C programming language does not have references, but it is much
     177                 :            :      simpler to handle those here rather than going through the same
     178                 :            :      logic in the C++ pretty-printer.  */
     179                 :    4680780 :   if (p != NULL && (*p == '*' || *p == '&'))
     180                 :     760062 :     pp_c_whitespace (pp);
     181                 :            : 
     182                 :    4680780 :   if (qualifiers & TYPE_QUAL_ATOMIC)
     183                 :         71 :     pp_c_ws_string (pp, "_Atomic");
     184                 :    4680780 :   if (qualifiers & TYPE_QUAL_CONST)
     185                 :    9295430 :     pp_c_ws_string (pp, func_type ? "__attribute__((const))" : "const");
     186                 :    4680780 :   if (qualifiers & TYPE_QUAL_VOLATILE)
     187                 :     245043 :     pp_c_ws_string (pp, func_type ? "__attribute__((noreturn))" : "volatile");
     188                 :    4680780 :   if (qualifiers & TYPE_QUAL_RESTRICT)
     189                 :        555 :     pp_c_ws_string (pp, (flag_isoc99 && !c_dialect_cxx ()
     190                 :            :                          ? "restrict" : "__restrict__"));
     191                 :            : }
     192                 :            : 
     193                 :            : /* Pretty-print T using the type-cast notation '( type-name )'.  */
     194                 :            : 
     195                 :            : void
     196                 :     315586 : pp_c_type_cast (c_pretty_printer *pp, tree t)
     197                 :            : {
     198                 :     315586 :   pp_c_left_paren (pp);
     199                 :     315586 :   pp->type_id (t);
     200                 :     315586 :   pp_c_right_paren (pp);
     201                 :     315586 : }
     202                 :            : 
     203                 :            : /* We're about to pretty-print a pointer type as indicated by T.
     204                 :            :    Output a whitespace, if needed, preparing for subsequent output.  */
     205                 :            : 
     206                 :            : void
     207                 :          3 : pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
     208                 :            : {
     209                 :          3 :   if (POINTER_TYPE_P (t))
     210                 :            :     {
     211                 :          0 :       tree pointee = strip_pointer_operator (TREE_TYPE (t));
     212                 :          0 :       if (TREE_CODE (pointee) != ARRAY_TYPE
     213                 :          0 :           && TREE_CODE (pointee) != FUNCTION_TYPE)
     214                 :          0 :         pp_c_whitespace (pp);
     215                 :            :     }
     216                 :          3 : }
     217                 :            : 
     218                 :            : 
     219                 :            : /* Declarations.  */
     220                 :            : 
     221                 :            : /* C++ cv-qualifiers are called type-qualifiers in C.  Print out the
     222                 :            :    cv-qualifiers of T.  If T is a declaration then it is the cv-qualifier
     223                 :            :    of its type.  Take care of possible extensions.
     224                 :            : 
     225                 :            :    type-qualifier-list:
     226                 :            :        type-qualifier
     227                 :            :        type-qualifier-list type-qualifier
     228                 :            : 
     229                 :            :    type-qualifier:
     230                 :            :        const
     231                 :            :        restrict                              -- C99
     232                 :            :        __restrict__                          -- GNU C
     233                 :            :        address-space-qualifier               -- GNU C
     234                 :            :        volatile
     235                 :            :        _Atomic                               -- C11
     236                 :            : 
     237                 :            :    address-space-qualifier:
     238                 :            :        identifier                            -- GNU C  */
     239                 :            : 
     240                 :            : void
     241                 :   79933600 : pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
     242                 :            : {
     243                 :   79933600 :   int qualifiers;
     244                 :            : 
     245                 :   79933600 :   if (!t || t == error_mark_node)
     246                 :            :     return;
     247                 :            : 
     248                 :   79933600 :   if (!TYPE_P (t))
     249                 :          1 :     t = TREE_TYPE (t);
     250                 :            : 
     251                 :   79933600 :   qualifiers = TYPE_QUALS (t);
     252                 :   79933600 :   pp_c_cv_qualifiers (pp, qualifiers,
     253                 :            :                       TREE_CODE (t) == FUNCTION_TYPE);
     254                 :            : 
     255                 :   79933600 :   if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (t)))
     256                 :            :     {
     257                 :          0 :       const char *as = c_addr_space_name (TYPE_ADDR_SPACE (t));
     258                 :          0 :       pp_c_identifier (pp, as);
     259                 :            :     }
     260                 :            : }
     261                 :            : 
     262                 :            : /* pointer:
     263                 :            :       * type-qualifier-list(opt)
     264                 :            :       * type-qualifier-list(opt) pointer  */
     265                 :            : 
     266                 :            : static void
     267                 :       7445 : pp_c_pointer (c_pretty_printer *pp, tree t)
     268                 :            : {
     269                 :       7445 :   if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
     270                 :          0 :     t = TREE_TYPE (t);
     271                 :       7445 :   switch (TREE_CODE (t))
     272                 :            :     {
     273                 :       7445 :     case POINTER_TYPE:
     274                 :            :       /* It is easier to handle C++ reference types here.  */
     275                 :       7445 :     case REFERENCE_TYPE:
     276                 :       7445 :       if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
     277                 :        307 :         pp_c_pointer (pp, TREE_TYPE (t));
     278                 :       7445 :       if (TREE_CODE (t) == POINTER_TYPE)
     279                 :       7398 :         pp_c_star (pp);
     280                 :            :       else
     281                 :         47 :         pp_c_ampersand (pp);
     282                 :       7445 :       pp_c_type_qualifier_list (pp, t);
     283                 :       7445 :       break;
     284                 :            : 
     285                 :            :       /* ??? This node is now in GENERIC and so shouldn't be here.  But
     286                 :            :          we'll fix that later.  */
     287                 :          0 :     case DECL_EXPR:
     288                 :          0 :       pp->declaration (DECL_EXPR_DECL (t));
     289                 :          0 :       pp_needs_newline (pp) = true;
     290                 :          0 :       break;
     291                 :            : 
     292                 :          0 :     default:
     293                 :          0 :       pp_unsupported_tree (pp, t);
     294                 :            :     }
     295                 :       7445 : }
     296                 :            : 
     297                 :            : /* simple-type-specifier:
     298                 :            :      type-specifier
     299                 :            : 
     300                 :            :    type-specifier:
     301                 :            :       void
     302                 :            :       char
     303                 :            :       short
     304                 :            :       int
     305                 :            :       long
     306                 :            :       float
     307                 :            :       double
     308                 :            :       signed
     309                 :            :       unsigned
     310                 :            :       _Bool                          -- C99
     311                 :            :       _Complex                       -- C99
     312                 :            :       _Imaginary                     -- C99
     313                 :            :       struct-or-union-specifier
     314                 :            :       enum-specifier
     315                 :            :       typedef-name.
     316                 :            : 
     317                 :            :   GNU extensions.
     318                 :            :   simple-type-specifier:
     319                 :            :       __complex__
     320                 :            :       __vector__   */
     321                 :            : 
     322                 :            : void
     323                 :   27848800 : c_pretty_printer::simple_type_specifier (tree t)
     324                 :            : {
     325                 :   27848800 :   const enum tree_code code = TREE_CODE (t);
     326                 :   27848800 :   switch (code)
     327                 :            :     {
     328                 :          0 :     case ERROR_MARK:
     329                 :          0 :       translate_string ("<type-error>");
     330                 :          0 :       break;
     331                 :            : 
     332                 :         40 :     case IDENTIFIER_NODE:
     333                 :         40 :       pp_c_identifier (this, IDENTIFIER_POINTER (t));
     334                 :         40 :       break;
     335                 :            : 
     336                 :   13923300 :     case VOID_TYPE:
     337                 :   13923300 :     case BOOLEAN_TYPE:
     338                 :   13923300 :     case INTEGER_TYPE:
     339                 :   13923300 :     case REAL_TYPE:
     340                 :   13923300 :     case FIXED_POINT_TYPE:
     341                 :   13923300 :       if (TYPE_NAME (t))
     342                 :            :         {
     343                 :   13923100 :           t = TYPE_NAME (t);
     344                 :   13923100 :           simple_type_specifier (t);
     345                 :            :         }
     346                 :            :       else
     347                 :            :         {
     348                 :        214 :           int prec = TYPE_PRECISION (t);
     349                 :        214 :           tree common_t;
     350                 :       1712 :           if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (t)))
     351                 :          0 :             common_t = c_common_type_for_mode (TYPE_MODE (t),
     352                 :          0 :                                                TYPE_SATURATING (t));
     353                 :            :           else
     354                 :        428 :             common_t = c_common_type_for_mode (TYPE_MODE (t),
     355                 :        214 :                                                TYPE_UNSIGNED (t));
     356                 :        428 :           if (common_t && TYPE_NAME (common_t))
     357                 :            :             {
     358                 :        178 :               simple_type_specifier (common_t);
     359                 :        178 :               if (TYPE_PRECISION (common_t) != prec)
     360                 :            :                 {
     361                 :        163 :                   pp_colon (this);
     362                 :        163 :                   pp_decimal_int (this, prec);
     363                 :            :                 }
     364                 :            :             }
     365                 :            :           else
     366                 :            :             {
     367                 :         36 :               switch (code)
     368                 :            :                 {
     369                 :          0 :                 case INTEGER_TYPE:
     370                 :          0 :                   translate_string (TYPE_UNSIGNED (t)
     371                 :            :                                     ? "<unnamed-unsigned:"
     372                 :          0 :                                     : "<unnamed-signed:");
     373                 :          0 :                   break;
     374                 :         36 :                 case REAL_TYPE:
     375                 :         36 :                   translate_string ("<unnamed-float:");
     376                 :         36 :                   break;
     377                 :          0 :                 case FIXED_POINT_TYPE:
     378                 :          0 :                   translate_string ("<unnamed-fixed:");
     379                 :          0 :                   break;
     380                 :          0 :                 default:
     381                 :          0 :                   gcc_unreachable ();
     382                 :            :                 }
     383                 :         36 :               pp_decimal_int (this, prec);
     384                 :         36 :               pp_greater (this);
     385                 :            :             }
     386                 :            :         }
     387                 :            :       break;
     388                 :            : 
     389                 :   13923100 :     case TYPE_DECL:
     390                 :   13923100 :       if (DECL_NAME (t))
     391                 :   13923100 :         id_expression (t);
     392                 :            :       else
     393                 :          0 :         translate_string ("<typedef-error>");
     394                 :            :       break;
     395                 :            : 
     396                 :       2305 :     case UNION_TYPE:
     397                 :       2305 :     case RECORD_TYPE:
     398                 :       2305 :     case ENUMERAL_TYPE:
     399                 :       2305 :       if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
     400                 :            :         /* Don't decorate the type if this is a typedef name.  */;
     401                 :       1784 :       else if (code == UNION_TYPE)
     402                 :        117 :         pp_c_ws_string (this, "union");
     403                 :       1667 :       else if (code == RECORD_TYPE)
     404                 :       1457 :         pp_c_ws_string (this, "struct");
     405                 :        210 :       else if (code == ENUMERAL_TYPE)
     406                 :        210 :         pp_c_ws_string (this, "enum");
     407                 :            :       else
     408                 :          0 :         translate_string ("<tag-error>");
     409                 :            : 
     410                 :       2305 :       if (TYPE_NAME (t))
     411                 :       2290 :         id_expression (TYPE_NAME (t));
     412                 :            :       else
     413                 :         15 :         translate_string ("<anonymous>");
     414                 :            :       break;
     415                 :            : 
     416                 :         15 :     default:
     417                 :         15 :       pp_unsupported_tree (this, t);
     418                 :         15 :       break;
     419                 :            :     }
     420                 :   27848800 : }
     421                 :            : 
     422                 :            : /* specifier-qualifier-list:
     423                 :            :       type-specifier specifier-qualifier-list-opt
     424                 :            :       type-qualifier specifier-qualifier-list-opt
     425                 :            : 
     426                 :            : 
     427                 :            :   Implementation note:  Because of the non-linearities in array or
     428                 :            :   function declarations, this routine prints not just the
     429                 :            :   specifier-qualifier-list of such entities or types of such entities,
     430                 :            :   but also the 'pointer' production part of their declarators.  The
     431                 :            :   remaining part is done by declarator() or abstract_declarator().  */
     432                 :            : 
     433                 :            : void
     434                 :   14253200 : pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
     435                 :            : {
     436                 :   14253200 :   const enum tree_code code = TREE_CODE (t);
     437                 :            : 
     438                 :   14253200 :   if (!(pp->flags & pp_c_flag_gnu_v3) && code != POINTER_TYPE)
     439                 :     151911 :     pp_c_type_qualifier_list (pp, t);
     440                 :   14253200 :   switch (code)
     441                 :            :     {
     442                 :       7138 :     case REFERENCE_TYPE:
     443                 :       7138 :     case POINTER_TYPE:
     444                 :       7138 :       {
     445                 :            :         /* Get the types-specifier of this type.  */
     446                 :       7138 :         tree pointee = strip_pointer_operator (TREE_TYPE (t));
     447                 :       7138 :         pp_c_specifier_qualifier_list (pp, pointee);
     448                 :       7138 :         if (TREE_CODE (pointee) == ARRAY_TYPE
     449                 :       7010 :             || TREE_CODE (pointee) == FUNCTION_TYPE)
     450                 :            :           {
     451                 :       2104 :             pp_c_whitespace (pp);
     452                 :       2104 :             pp_c_left_paren (pp);
     453                 :       2104 :             pp_c_attributes_display (pp, TYPE_ATTRIBUTES (pointee));
     454                 :            :           }
     455                 :       5034 :         else if (!c_dialect_cxx ())
     456                 :       4968 :           pp_c_whitespace (pp);
     457                 :       7138 :         pp_ptr_operator (pp, t);
     458                 :            :       }
     459                 :       7138 :       break;
     460                 :            : 
     461                 :       3686 :     case FUNCTION_TYPE:
     462                 :       3686 :     case ARRAY_TYPE:
     463                 :       3686 :       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
     464                 :       3686 :       break;
     465                 :            : 
     466                 :       1311 :     case VECTOR_TYPE:
     467                 :       1311 :     case COMPLEX_TYPE:
     468                 :       1311 :       if (code == COMPLEX_TYPE)
     469                 :        579 :         pp_c_ws_string (pp, (flag_isoc99 && !c_dialect_cxx ()
     470                 :            :                              ? "_Complex" : "__complex__"));
     471                 :        968 :       else if (code == VECTOR_TYPE)
     472                 :            :         {
     473                 :            :           /* The syntax we print for vector types isn't real C or C++ syntax,
     474                 :            :              so it's better to print the type name if we have one.  */
     475                 :        968 :           tree name = TYPE_NAME (t);
     476                 :        968 :           if (!(pp->flags & pp_c_flag_gnu_v3)
     477                 :        877 :               && name
     478                 :         15 :               && TREE_CODE (name) == TYPE_DECL)
     479                 :            :             {
     480                 :         15 :               pp->id_expression (name);
     481                 :         15 :               break;
     482                 :            :             }
     483                 :        953 :           pp_c_ws_string (pp, "__vector");
     484                 :        953 :           pp_c_left_paren (pp);
     485                 :        953 :           pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (t));
     486                 :        953 :           pp_c_right_paren (pp);
     487                 :        953 :           pp_c_whitespace (pp);
     488                 :            :         }
     489                 :       1296 :       pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
     490                 :       1296 :       break;
     491                 :            : 
     492                 :   14241100 :     default:
     493                 :   14241100 :       pp->simple_type_specifier (t);
     494                 :   14241100 :       break;
     495                 :            :     }
     496                 :   14253200 :   if ((pp->flags & pp_c_flag_gnu_v3) && code != POINTER_TYPE)
     497                 :   14094200 :     pp_c_type_qualifier_list (pp, t);
     498                 :   14253200 : }
     499                 :            : 
     500                 :            : /* parameter-type-list:
     501                 :            :       parameter-list
     502                 :            :       parameter-list , ...
     503                 :            : 
     504                 :            :    parameter-list:
     505                 :            :       parameter-declaration
     506                 :            :       parameter-list , parameter-declaration
     507                 :            : 
     508                 :            :    parameter-declaration:
     509                 :            :       declaration-specifiers declarator
     510                 :            :       declaration-specifiers abstract-declarator(opt)   */
     511                 :            : 
     512                 :            : void
     513                 :       2307 : pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
     514                 :            : {
     515                 :       2307 :   bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
     516                 :       2307 :   tree parms = want_parm_decl ? DECL_ARGUMENTS (t) :  TYPE_ARG_TYPES (t);
     517                 :       2307 :   pp_c_left_paren (pp);
     518                 :       2307 :   if (parms == void_list_node)
     519                 :        381 :     pp_c_ws_string (pp, "void");
     520                 :            :   else
     521                 :            :     {
     522                 :            :       bool first = true;
     523                 :       4972 :       for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
     524                 :            :         {
     525                 :       3046 :           if (!first)
     526                 :       1351 :             pp_separate_with (pp, ',');
     527                 :       3046 :           first = false;
     528                 :       3046 :           pp->declaration_specifiers
     529                 :       6092 :             (want_parm_decl ? parms : TREE_VALUE (parms));
     530                 :       3046 :           if (want_parm_decl)
     531                 :          0 :             pp->declarator (parms);
     532                 :            :           else
     533                 :       3046 :             pp->abstract_declarator (TREE_VALUE (parms));
     534                 :            :         }
     535                 :       1926 :       if (!first && !parms)
     536                 :            :         {
     537                 :         43 :           pp_separate_with (pp, ',');
     538                 :         43 :           pp_string (pp, "...");
     539                 :            :         }
     540                 :            :     }
     541                 :       2307 :   pp_c_right_paren (pp);
     542                 :       2307 : }
     543                 :            : 
     544                 :            : /* abstract-declarator:
     545                 :            :       pointer
     546                 :            :       pointer(opt) direct-abstract-declarator  */
     547                 :            : 
     548                 :            : void
     549                 :      11927 : c_pretty_printer::abstract_declarator (tree t)
     550                 :            : {
     551                 :      11927 :   if (TREE_CODE (t) == POINTER_TYPE)
     552                 :            :     {
     553                 :       7373 :       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
     554                 :       7373 :           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
     555                 :       2098 :         pp_c_right_paren (this);
     556                 :       7373 :       t = TREE_TYPE (t);
     557                 :            :     }
     558                 :            : 
     559                 :      11927 :   direct_abstract_declarator (t);
     560                 :      11927 : }
     561                 :            : 
     562                 :            : /* direct-abstract-declarator:
     563                 :            :       ( abstract-declarator )
     564                 :            :       direct-abstract-declarator(opt) [ assignment-expression(opt) ]
     565                 :            :       direct-abstract-declarator(opt) [ * ]
     566                 :            :       direct-abstract-declarator(opt) ( parameter-type-list(opt) )  */
     567                 :            : 
     568                 :            : void
     569                 :      16123 : c_pretty_printer::direct_abstract_declarator (tree t)
     570                 :            : {
     571                 :      16123 :   switch (TREE_CODE (t))
     572                 :            :     {
     573                 :        682 :     case POINTER_TYPE:
     574                 :        682 :       abstract_declarator (t);
     575                 :        682 :       break;
     576                 :            : 
     577                 :       2307 :     case FUNCTION_TYPE:
     578                 :       2307 :       pp_c_parameter_type_list (this, t);
     579                 :       2307 :       direct_abstract_declarator (TREE_TYPE (t));
     580                 :       2307 :       break;
     581                 :            : 
     582                 :       1379 :     case ARRAY_TYPE:
     583                 :       1379 :       pp_c_left_bracket (this);
     584                 :       1379 :       if (tree dom = TYPE_DOMAIN (t))
     585                 :            :         {
     586                 :       1077 :           if (tree maxval = TYPE_MAX_VALUE (dom))
     587                 :            :             {
     588                 :        898 :               tree type = TREE_TYPE (maxval);
     589                 :            : 
     590                 :        898 :               if (tree_fits_shwi_p (maxval))
     591                 :        872 :                 pp_wide_integer (this, tree_to_shwi (maxval) + 1);
     592                 :            :               else
     593                 :         26 :                 expression (fold_build2 (PLUS_EXPR, type, maxval,
     594                 :         26 :                                          build_int_cst (type, 1)));
     595                 :            :             }
     596                 :            :           else
     597                 :        179 :             pp_string (this, "0");
     598                 :            :         }
     599                 :       1379 :       pp_c_right_bracket (this);
     600                 :       1379 :       direct_abstract_declarator (TREE_TYPE (t));
     601                 :       1379 :       break;
     602                 :            : 
     603                 :            :     case IDENTIFIER_NODE:
     604                 :            :     case VOID_TYPE:
     605                 :            :     case BOOLEAN_TYPE:
     606                 :            :     case INTEGER_TYPE:
     607                 :            :     case REAL_TYPE:
     608                 :            :     case FIXED_POINT_TYPE:
     609                 :            :     case ENUMERAL_TYPE:
     610                 :            :     case RECORD_TYPE:
     611                 :            :     case UNION_TYPE:
     612                 :            :     case VECTOR_TYPE:
     613                 :            :     case COMPLEX_TYPE:
     614                 :            :     case TYPE_DECL:
     615                 :            :       break;
     616                 :            : 
     617                 :         14 :     default:
     618                 :         14 :       pp_unsupported_tree (this, t);
     619                 :         14 :       break;
     620                 :            :     }
     621                 :      16123 : }
     622                 :            : 
     623                 :            : /* type-name:
     624                 :            :       specifier-qualifier-list  abstract-declarator(opt)  */
     625                 :            : 
     626                 :            : void
     627                 :       8749 : c_pretty_printer::type_id (tree t)
     628                 :            : {
     629                 :       8749 :   pp_c_specifier_qualifier_list (this, t);
     630                 :       8749 :   abstract_declarator (t);
     631                 :       8749 : }
     632                 :            : 
     633                 :            : /* storage-class-specifier:
     634                 :            :       typedef
     635                 :            :       extern
     636                 :            :       static
     637                 :            :       auto
     638                 :            :       register  */
     639                 :            : 
     640                 :            : void
     641                 :       3052 : c_pretty_printer::storage_class_specifier (tree t)
     642                 :            : {
     643                 :       3052 :   if (TREE_CODE (t) == TYPE_DECL)
     644                 :          0 :     pp_c_ws_string (this, "typedef");
     645                 :       3052 :   else if (DECL_P (t))
     646                 :            :     {
     647                 :          3 :       if (DECL_REGISTER (t))
     648                 :          0 :         pp_c_ws_string (this, "register");
     649                 :          3 :       else if (TREE_STATIC (t) && VAR_P (t))
     650                 :          0 :         pp_c_ws_string (this, "static");
     651                 :            :     }
     652                 :       3052 : }
     653                 :            : 
     654                 :            : /* function-specifier:
     655                 :            :       inline   */
     656                 :            : 
     657                 :            : void
     658                 :       3046 : c_pretty_printer::function_specifier (tree t)
     659                 :            : {
     660                 :       3046 :   if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
     661                 :          0 :     pp_c_ws_string (this, "inline");
     662                 :       3046 : }
     663                 :            : 
     664                 :            : /* declaration-specifiers:
     665                 :            :       storage-class-specifier declaration-specifiers(opt)
     666                 :            :       type-specifier declaration-specifiers(opt)
     667                 :            :       type-qualifier declaration-specifiers(opt)
     668                 :            :       function-specifier declaration-specifiers(opt)  */
     669                 :            : 
     670                 :            : void
     671                 :       3049 : c_pretty_printer::declaration_specifiers (tree t)
     672                 :            : {
     673                 :       3049 :   storage_class_specifier (t);
     674                 :       3049 :   function_specifier (t);
     675                 :       3049 :   pp_c_specifier_qualifier_list (this, DECL_P (t) ?  TREE_TYPE (t) : t);
     676                 :       3049 : }
     677                 :            : 
     678                 :            : /* direct-declarator
     679                 :            :       identifier
     680                 :            :       ( declarator )
     681                 :            :       direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
     682                 :            :       direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
     683                 :            :       direct-declarator [ type-qualifier-list static assignment-expression ]
     684                 :            :       direct-declarator [ type-qualifier-list * ]
     685                 :            :       direct-declarator ( parameter-type-list )
     686                 :            :       direct-declarator ( identifier-list(opt) )  */
     687                 :            : 
     688                 :            : void
     689                 :          0 : c_pretty_printer::direct_declarator (tree t)
     690                 :            : {
     691                 :          0 :   switch (TREE_CODE (t))
     692                 :            :     {
     693                 :          0 :     case VAR_DECL:
     694                 :          0 :     case PARM_DECL:
     695                 :          0 :     case TYPE_DECL:
     696                 :          0 :     case FIELD_DECL:
     697                 :          0 :     case LABEL_DECL:
     698                 :          0 :       pp_c_space_for_pointer_operator (this, TREE_TYPE (t));
     699                 :          0 :       pp_c_tree_decl_identifier (this, t);
     700                 :          0 :       break;
     701                 :            : 
     702                 :          0 :     case ARRAY_TYPE:
     703                 :          0 :     case POINTER_TYPE:
     704                 :          0 :       abstract_declarator (TREE_TYPE (t));
     705                 :          0 :       break;
     706                 :            : 
     707                 :          0 :     case FUNCTION_TYPE:
     708                 :          0 :       pp_parameter_list (this, t);
     709                 :          0 :       abstract_declarator (TREE_TYPE (t));
     710                 :          0 :       break;
     711                 :            : 
     712                 :          0 :     case FUNCTION_DECL:
     713                 :          0 :       pp_c_space_for_pointer_operator (this, TREE_TYPE (TREE_TYPE (t)));
     714                 :          0 :       pp_c_tree_decl_identifier (this, t);
     715                 :          0 :       if (flags & pp_c_flag_abstract)
     716                 :          0 :         abstract_declarator (TREE_TYPE (t));
     717                 :            :       else
     718                 :            :         {
     719                 :          0 :           pp_parameter_list (this, t);
     720                 :          0 :           abstract_declarator (TREE_TYPE (TREE_TYPE (t)));
     721                 :            :         }
     722                 :            :       break;
     723                 :            : 
     724                 :            :     case INTEGER_TYPE:
     725                 :            :     case REAL_TYPE:
     726                 :            :     case FIXED_POINT_TYPE:
     727                 :            :     case ENUMERAL_TYPE:
     728                 :            :     case UNION_TYPE:
     729                 :            :     case RECORD_TYPE:
     730                 :            :       break;
     731                 :            : 
     732                 :          0 :     default:
     733                 :          0 :       pp_unsupported_tree (this, t);
     734                 :          0 :       break;
     735                 :            :     }
     736                 :          0 : }
     737                 :            : 
     738                 :            : 
     739                 :            : /* declarator:
     740                 :            :       pointer(opt)  direct-declarator   */
     741                 :            : 
     742                 :            : void
     743                 :          0 : c_pretty_printer::declarator (tree t)
     744                 :            : {
     745                 :          0 :   switch (TREE_CODE (t))
     746                 :            :     {
     747                 :            :     case INTEGER_TYPE:
     748                 :            :     case REAL_TYPE:
     749                 :            :     case FIXED_POINT_TYPE:
     750                 :            :     case ENUMERAL_TYPE:
     751                 :            :     case UNION_TYPE:
     752                 :            :     case RECORD_TYPE:
     753                 :            :       break;
     754                 :            : 
     755                 :          0 :     case VAR_DECL:
     756                 :          0 :     case PARM_DECL:
     757                 :          0 :     case FIELD_DECL:
     758                 :          0 :     case ARRAY_TYPE:
     759                 :          0 :     case FUNCTION_TYPE:
     760                 :          0 :     case FUNCTION_DECL:
     761                 :          0 :     case TYPE_DECL:
     762                 :          0 :       direct_declarator (t);
     763                 :          0 :     break;
     764                 :            : 
     765                 :            : 
     766                 :          0 :     default:
     767                 :          0 :       pp_unsupported_tree (this, t);
     768                 :          0 :       break;
     769                 :            :     }
     770                 :          0 : }
     771                 :            : 
     772                 :            : /* declaration:
     773                 :            :       declaration-specifiers init-declarator-list(opt) ;  */
     774                 :            : 
     775                 :            : void
     776                 :          0 : c_pretty_printer::declaration (tree t)
     777                 :            : {
     778                 :          0 :   declaration_specifiers (t);
     779                 :          0 :   pp_c_init_declarator (this, t);
     780                 :          0 : }
     781                 :            : 
     782                 :            : /* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
     783                 :            : 
     784                 :            : void
     785                 :          0 : pp_c_attributes (c_pretty_printer *pp, tree attributes)
     786                 :            : {
     787                 :          0 :   if (attributes == NULL_TREE)
     788                 :            :     return;
     789                 :            : 
     790                 :          0 :   pp_c_ws_string (pp, "__attribute__");
     791                 :          0 :   pp_c_left_paren (pp);
     792                 :          0 :   pp_c_left_paren (pp);
     793                 :          0 :   for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
     794                 :            :     {
     795                 :          0 :       pp_tree_identifier (pp, TREE_PURPOSE (attributes));
     796                 :          0 :       if (TREE_VALUE (attributes))
     797                 :          0 :         pp_c_call_argument_list (pp, TREE_VALUE (attributes));
     798                 :            : 
     799                 :          0 :       if (TREE_CHAIN (attributes))
     800                 :          0 :         pp_separate_with (pp, ',');
     801                 :            :     }
     802                 :          0 :   pp_c_right_paren (pp);
     803                 :          0 :   pp_c_right_paren (pp);
     804                 :            : }
     805                 :            : 
     806                 :            : /* Pretty-print ATTRIBUTES using GNU C extension syntax for attributes
     807                 :            :    marked to be displayed on disgnostic.  */
     808                 :            : 
     809                 :            : void
     810                 :     750732 : pp_c_attributes_display (c_pretty_printer *pp, tree a)
     811                 :            : {
     812                 :     750732 :   bool is_first = true;
     813                 :            : 
     814                 :     750732 :   if (a == NULL_TREE)
     815                 :            :     return;
     816                 :            : 
     817                 :       1492 :   for (; a != NULL_TREE; a = TREE_CHAIN (a))
     818                 :            :     {
     819                 :        919 :       const struct attribute_spec *as;
     820                 :        919 :       as = lookup_attribute_spec (TREE_PURPOSE (a));
     821                 :        919 :       if (!as || as->affects_type_identity == false)
     822                 :        662 :         continue;
     823                 :        257 :       if (c_dialect_cxx ()
     824                 :        227 :           && !strcmp ("transaction_safe", as->name))
     825                 :            :         /* In C++ transaction_safe is printed at the end of the declarator.  */
     826                 :         24 :         continue;
     827                 :        233 :       if (is_first)
     828                 :            :        {
     829                 :        233 :          pp_c_ws_string (pp, "__attribute__");
     830                 :        233 :          pp_c_left_paren (pp);
     831                 :        233 :          pp_c_left_paren (pp);
     832                 :        233 :          is_first = false;
     833                 :            :        }
     834                 :            :       else
     835                 :            :        {
     836                 :          0 :          pp_separate_with (pp, ',');
     837                 :            :        }
     838                 :        233 :       pp_tree_identifier (pp, TREE_PURPOSE (a));
     839                 :        233 :       if (TREE_VALUE (a))
     840                 :          0 :        pp_c_call_argument_list (pp, TREE_VALUE (a));
     841                 :            :     }
     842                 :            : 
     843                 :        573 :   if (!is_first)
     844                 :            :     {
     845                 :        233 :       pp_c_right_paren (pp);
     846                 :        233 :       pp_c_right_paren (pp);
     847                 :        233 :       pp_c_whitespace (pp);
     848                 :            :     }
     849                 :            : }
     850                 :            : 
     851                 :            : /* function-definition:
     852                 :            :       declaration-specifiers declarator compound-statement  */
     853                 :            : 
     854                 :            : void
     855                 :          0 : pp_c_function_definition (c_pretty_printer *pp, tree t)
     856                 :            : {
     857                 :          0 :   pp->declaration_specifiers (t);
     858                 :          0 :   pp->declarator (t);
     859                 :          0 :   pp_needs_newline (pp) = true;
     860                 :          0 :   pp->statement (DECL_SAVED_TREE (t));
     861                 :          0 :   pp_newline_and_flush (pp);
     862                 :          0 : }
     863                 :            : 
     864                 :            : 
     865                 :            : /* Expressions.  */
     866                 :            : 
     867                 :            : /* Print out a c-char.  This is called solely for characters which are
     868                 :            :    in the *target* execution character set.  We ought to convert them
     869                 :            :    back to the *host* execution character set before printing, but we
     870                 :            :    have no way to do this at present.  A decent compromise is to print
     871                 :            :    all characters as if they were in the host execution character set,
     872                 :            :    and not attempt to recover any named escape characters, but render
     873                 :            :    all unprintables as octal escapes.  If the host and target character
     874                 :            :    sets are the same, this produces relatively readable output.  If they
     875                 :            :    are not the same, strings may appear as gibberish, but that's okay
     876                 :            :    (in fact, it may well be what the reader wants, e.g. if they are looking
     877                 :            :    to see if conversion to the target character set happened correctly).
     878                 :            : 
     879                 :            :    A special case: we need to prefix \, ", and ' with backslashes.  It is
     880                 :            :    correct to do so for the *host*'s \, ", and ', because the rest of the
     881                 :            :    file appears in the host character set.  */
     882                 :            : 
     883                 :            : static void
     884                 :      37067 : pp_c_char (c_pretty_printer *pp, int c)
     885                 :            : {
     886                 :      37067 :   if (ISPRINT (c))
     887                 :            :     {
     888                 :      28849 :       switch (c)
     889                 :            :         {
     890                 :          0 :         case '\\': pp_string (pp, "\\\\"); break;
     891                 :         57 :         case '\'': pp_string (pp, "\\\'"); break;
     892                 :          0 :         case '\"': pp_string (pp, "\\\""); break;
     893                 :      28792 :         default:   pp_character (pp, c);
     894                 :            :         }
     895                 :            :     }
     896                 :            :   else
     897                 :       8218 :     pp_scalar (pp, "\\%03o", (unsigned) c);
     898                 :      37067 : }
     899                 :            : 
     900                 :            : /* Print out a STRING literal.  */
     901                 :            : 
     902                 :            : void
     903                 :        118 : pp_c_string_literal (c_pretty_printer *pp, tree s)
     904                 :            : {
     905                 :        118 :   const char *p = TREE_STRING_POINTER (s);
     906                 :        118 :   int n = TREE_STRING_LENGTH (s) - 1;
     907                 :        118 :   int i;
     908                 :        118 :   pp_doublequote (pp);
     909                 :        596 :   for (i = 0; i < n; ++i)
     910                 :        478 :     pp_c_char (pp, p[i]);
     911                 :        118 :   pp_doublequote (pp);
     912                 :        118 : }
     913                 :            : 
     914                 :            : /* Pretty-print a VOID_CST (void_node).  */
     915                 :            : 
     916                 :            : static void
     917                 :         20 : pp_c_void_constant (c_pretty_printer *pp)
     918                 :            : {
     919                 :         20 :   pp_c_type_cast (pp, void_type_node);
     920                 :         20 :   pp_string (pp, "0");
     921                 :         20 : }
     922                 :            : 
     923                 :            : /* Pretty-print an INTEGER literal.  */
     924                 :            : 
     925                 :            : void
     926                 :    1900870 : pp_c_integer_constant (c_pretty_printer *pp, tree i)
     927                 :            : {
     928                 :    1900870 :   if (tree_fits_shwi_p (i))
     929                 :    1866960 :     pp_wide_integer (pp, tree_to_shwi (i));
     930                 :      33903 :   else if (tree_fits_uhwi_p (i))
     931                 :      33892 :     pp_unsigned_wide_integer (pp, tree_to_uhwi (i));
     932                 :            :   else
     933                 :            :     {
     934                 :         11 :       wide_int wi = wi::to_wide (i);
     935                 :            : 
     936                 :         11 :       if (wi::lt_p (wi::to_wide (i), 0, TYPE_SIGN (TREE_TYPE (i))))
     937                 :            :         {
     938                 :          0 :           pp_minus (pp);
     939                 :          0 :           wi = -wi;
     940                 :            :         }
     941                 :         11 :       print_hex (wi, pp_buffer (pp)->digit_buffer);
     942                 :         11 :       pp_string (pp, pp_buffer (pp)->digit_buffer);
     943                 :            :     }
     944                 :    1900870 : }
     945                 :            : 
     946                 :            : /* Print out a CHARACTER literal.  */
     947                 :            : 
     948                 :            : static void
     949                 :      36589 : pp_c_character_constant (c_pretty_printer *pp, tree c)
     950                 :            : {
     951                 :      36589 :   pp_quote (pp);
     952                 :      36589 :   pp_c_char (pp, (unsigned) TREE_INT_CST_LOW (c));
     953                 :      36589 :   pp_quote (pp);
     954                 :      36589 : }
     955                 :            : 
     956                 :            : /* Print out a BOOLEAN literal.  */
     957                 :            : 
     958                 :            : static void
     959                 :    3587460 : pp_c_bool_constant (c_pretty_printer *pp, tree b)
     960                 :            : {
     961                 :    3587460 :   if (b == boolean_false_node)
     962                 :            :     {
     963                 :    2013940 :       if (c_dialect_cxx ())
     964                 :    2013940 :         pp_c_ws_string (pp, "false");
     965                 :          0 :       else if (flag_isoc99)
     966                 :          0 :         pp_c_ws_string (pp, "_False");
     967                 :            :       else
     968                 :          0 :         pp_unsupported_tree (pp, b);
     969                 :            :     }
     970                 :    1573520 :   else if (b == boolean_true_node)
     971                 :            :     {
     972                 :    1573520 :       if (c_dialect_cxx ())
     973                 :    1573520 :         pp_c_ws_string (pp, "true");
     974                 :          0 :       else if (flag_isoc99)
     975                 :          0 :         pp_c_ws_string (pp, "_True");
     976                 :            :       else
     977                 :          0 :         pp_unsupported_tree (pp, b);
     978                 :            :     }
     979                 :          0 :   else if (TREE_CODE (b) == INTEGER_CST)
     980                 :          0 :     pp_c_integer_constant (pp, b);
     981                 :            :   else
     982                 :          0 :     pp_unsupported_tree (pp, b);
     983                 :    3587460 : }
     984                 :            : 
     985                 :            : /* Given a value e of ENUMERAL_TYPE:
     986                 :            :    Print out the first ENUMERATOR id with value e, if one is found,
     987                 :            :    else print out the value as a C-style cast (type-id)value.  */
     988                 :            : 
     989                 :            : static void
     990                 :          0 : pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
     991                 :            : {
     992                 :          0 :   tree type = TREE_TYPE (e);
     993                 :          0 :   tree value = NULL_TREE;
     994                 :            : 
     995                 :            :   /* Find the name of this constant.  */
     996                 :          0 :   if ((pp->flags & pp_c_flag_gnu_v3) == 0)
     997                 :          0 :     for (value = TYPE_VALUES (type); value != NULL_TREE;
     998                 :          0 :          value = TREE_CHAIN (value))
     999                 :          0 :       if (tree_int_cst_equal (DECL_INITIAL (TREE_VALUE (value)), e))
    1000                 :            :         break;
    1001                 :            : 
    1002                 :          0 :   if (value != NULL_TREE)
    1003                 :          0 :     pp->id_expression (TREE_PURPOSE (value));
    1004                 :            :   else
    1005                 :            :     {
    1006                 :            :       /* Value must have been cast.  */
    1007                 :          0 :       pp_c_type_cast (pp, type);
    1008                 :          0 :       pp_c_integer_constant (pp, e);
    1009                 :            :     }
    1010                 :          0 : }
    1011                 :            : 
    1012                 :            : /* Print out a REAL value as a decimal-floating-constant.  */
    1013                 :            : 
    1014                 :            : static void
    1015                 :        869 : pp_c_floating_constant (c_pretty_printer *pp, tree r)
    1016                 :            : {
    1017                 :        869 :   const struct real_format *fmt
    1018                 :       2562 :     = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (r)));
    1019                 :            : 
    1020                 :        869 :   REAL_VALUE_TYPE floating_cst = TREE_REAL_CST (r);
    1021                 :        869 :   bool is_decimal = floating_cst.decimal;
    1022                 :            : 
    1023                 :            :   /* See ISO C++ WG N1822.  Note: The fraction 643/2136 approximates
    1024                 :            :      log10(2) to 7 significant digits.  */
    1025                 :        869 :   int max_digits10 = 2 + (is_decimal ? fmt->p : fmt->p * 643L / 2136);
    1026                 :            : 
    1027                 :        869 :   real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
    1028                 :            :                    sizeof (pp_buffer (pp)->digit_buffer),
    1029                 :            :                    max_digits10, 1);
    1030                 :            : 
    1031                 :        869 :   pp_string (pp, pp_buffer(pp)->digit_buffer);
    1032                 :        869 :   if (TREE_TYPE (r) == float_type_node)
    1033                 :        301 :     pp_character (pp, 'f');
    1034                 :        568 :   else if (TREE_TYPE (r) == long_double_type_node)
    1035                 :         40 :     pp_character (pp, 'l');
    1036                 :        528 :   else if (TREE_TYPE (r) == dfloat128_type_node)
    1037                 :         15 :     pp_string (pp, "dl");
    1038                 :        513 :   else if (TREE_TYPE (r) == dfloat64_type_node)
    1039                 :         15 :     pp_string (pp, "dd");
    1040                 :        498 :   else if (TREE_TYPE (r) == dfloat32_type_node)
    1041                 :         15 :     pp_string (pp, "df");
    1042                 :        483 :   else if (TREE_TYPE (r) != double_type_node)
    1043                 :          0 :     for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
    1044                 :          0 :       if (TREE_TYPE (r) == FLOATN_NX_TYPE_NODE (i))
    1045                 :            :         {
    1046                 :          0 :           pp_character (pp, 'f');
    1047                 :          0 :           pp_decimal_int (pp, floatn_nx_types[i].n);
    1048                 :          0 :           if (floatn_nx_types[i].extended)
    1049                 :          0 :             pp_character (pp, 'x');
    1050                 :            :           break;
    1051                 :            :         }
    1052                 :        869 : }
    1053                 :            : 
    1054                 :            : /* Print out a FIXED value as a decimal-floating-constant.  */
    1055                 :            : 
    1056                 :            : static void
    1057                 :          0 : pp_c_fixed_constant (c_pretty_printer *pp, tree r)
    1058                 :            : {
    1059                 :          0 :   fixed_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_FIXED_CST (r),
    1060                 :            :                    sizeof (pp_buffer (pp)->digit_buffer));
    1061                 :          0 :   pp_string (pp, pp_buffer(pp)->digit_buffer);
    1062                 :          0 : }
    1063                 :            : 
    1064                 :            : /* Pretty-print a compound literal expression.  GNU extensions include
    1065                 :            :    vector constants.  */
    1066                 :            : 
    1067                 :            : static void
    1068                 :         70 : pp_c_compound_literal (c_pretty_printer *pp, tree e)
    1069                 :            : {
    1070                 :         70 :   tree type = TREE_TYPE (e);
    1071                 :         70 :   pp_c_type_cast (pp, type);
    1072                 :            : 
    1073                 :         70 :   switch (TREE_CODE (type))
    1074                 :            :     {
    1075                 :         70 :     case RECORD_TYPE:
    1076                 :         70 :     case UNION_TYPE:
    1077                 :         70 :     case ARRAY_TYPE:
    1078                 :         70 :     case VECTOR_TYPE:
    1079                 :         70 :     case COMPLEX_TYPE:
    1080                 :         70 :       pp_c_brace_enclosed_initializer_list (pp, e);
    1081                 :         70 :       break;
    1082                 :            : 
    1083                 :          0 :     default:
    1084                 :          0 :       pp_unsupported_tree (pp, e);
    1085                 :          0 :       break;
    1086                 :            :     }
    1087                 :         70 : }
    1088                 :            : 
    1089                 :            : /* Pretty-print a COMPLEX_EXPR expression.  */
    1090                 :            : 
    1091                 :            : static void
    1092                 :         30 : pp_c_complex_expr (c_pretty_printer *pp, tree e)
    1093                 :            : {
    1094                 :            :   /* Handle a few common special cases, otherwise fallback
    1095                 :            :      to printing it as compound literal.  */
    1096                 :         30 :   tree type = TREE_TYPE (e);
    1097                 :         30 :   tree realexpr = TREE_OPERAND (e, 0);
    1098                 :         30 :   tree imagexpr = TREE_OPERAND (e, 1);
    1099                 :            : 
    1100                 :            :   /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE.  */
    1101                 :         30 :   if (TREE_CODE (realexpr) == NOP_EXPR
    1102                 :         25 :       && TREE_CODE (imagexpr) == NOP_EXPR
    1103                 :         10 :       && TREE_TYPE (realexpr) == TREE_TYPE (type)
    1104                 :         10 :       && TREE_TYPE (imagexpr) == TREE_TYPE (type)
    1105                 :         10 :       && TREE_CODE (TREE_OPERAND (realexpr, 0)) == REALPART_EXPR
    1106                 :         10 :       && TREE_CODE (TREE_OPERAND (imagexpr, 0)) == IMAGPART_EXPR
    1107                 :         40 :       && TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0)
    1108                 :         10 :          == TREE_OPERAND (TREE_OPERAND (imagexpr, 0), 0))
    1109                 :            :     {
    1110                 :         10 :       pp_c_type_cast (pp, type);
    1111                 :         10 :       pp->expression (TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0));
    1112                 :         10 :       return;
    1113                 :            :     }
    1114                 :            : 
    1115                 :            :   /* Cast of an scalar expression to COMPLEX_TYPE.  */
    1116                 :         30 :   if ((integer_zerop (imagexpr) || real_zerop (imagexpr))
    1117                 :         32 :       && TREE_TYPE (realexpr) == TREE_TYPE (type))
    1118                 :            :     {
    1119                 :         12 :       pp_c_type_cast (pp, type);
    1120                 :         12 :       if (TREE_CODE (realexpr) == NOP_EXPR)
    1121                 :          7 :         realexpr = TREE_OPERAND (realexpr, 0);
    1122                 :         12 :       pp->expression (realexpr);
    1123                 :         12 :       return;
    1124                 :            :     }
    1125                 :            : 
    1126                 :          8 :   pp_c_compound_literal (pp, e);
    1127                 :            : }
    1128                 :            : 
    1129                 :            : /* constant:
    1130                 :            :       integer-constant
    1131                 :            :       floating-constant
    1132                 :            :       fixed-point-constant
    1133                 :            :       enumeration-constant
    1134                 :            :       character-constant   */
    1135                 :            : 
    1136                 :            : void
    1137                 :    5206410 : c_pretty_printer::constant (tree e)
    1138                 :            : {
    1139                 :    5206410 :   const enum tree_code code = TREE_CODE (e);
    1140                 :            : 
    1141                 :    5206410 :   switch (code)
    1142                 :            :     {
    1143                 :         20 :     case VOID_CST:
    1144                 :         20 :       pp_c_void_constant (this);
    1145                 :         20 :       break;
    1146                 :            : 
    1147                 :    5205580 :     case INTEGER_CST:
    1148                 :    5205580 :       {
    1149                 :    5205580 :         tree type = TREE_TYPE (e);
    1150                 :    5205580 :         if (type == boolean_type_node)
    1151                 :    3587460 :           pp_c_bool_constant (this, e);
    1152                 :    1618120 :         else if (type == char_type_node)
    1153                 :      36589 :           pp_c_character_constant (this, e);
    1154                 :    1581530 :         else if (TREE_CODE (type) == ENUMERAL_TYPE)
    1155                 :          0 :           pp_c_enumeration_constant (this, e);
    1156                 :            :         else
    1157                 :    1581530 :           pp_c_integer_constant (this, e);
    1158                 :            :       }
    1159                 :            :       break;
    1160                 :            : 
    1161                 :        714 :     case REAL_CST:
    1162                 :        714 :       pp_c_floating_constant (this, e);
    1163                 :        714 :       break;
    1164                 :            : 
    1165                 :          0 :     case FIXED_CST:
    1166                 :          0 :       pp_c_fixed_constant (this, e);
    1167                 :          0 :       break;
    1168                 :            : 
    1169                 :        101 :     case STRING_CST:
    1170                 :        101 :       pp_c_string_literal (this, e);
    1171                 :        101 :       break;
    1172                 :            : 
    1173                 :          0 :     case COMPLEX_CST:
    1174                 :            :       /* Sometimes, we are confused and we think a complex literal
    1175                 :            :          is a constant.  Such thing is a compound literal which
    1176                 :            :          grammatically belongs to postfix-expr production.  */
    1177                 :          0 :       pp_c_compound_literal (this, e);
    1178                 :          0 :       break;
    1179                 :            : 
    1180                 :          0 :     default:
    1181                 :          0 :       pp_unsupported_tree (this, e);
    1182                 :          0 :       break;
    1183                 :            :     }
    1184                 :    5206410 : }
    1185                 :            : 
    1186                 :            : /* Pretty-print a string such as an identifier, without changing its
    1187                 :            :    encoding, preceded by whitespace is necessary.  */
    1188                 :            : 
    1189                 :            : void
    1190                 :    8544340 : pp_c_ws_string (c_pretty_printer *pp, const char *str)
    1191                 :            : {
    1192                 :    8544340 :   pp_c_maybe_whitespace (pp);
    1193                 :    8544340 :   pp_string (pp, str);
    1194                 :    8544340 :   pp->padding = pp_before;
    1195                 :    8544340 : }
    1196                 :            : 
    1197                 :            : void
    1198                 :      72471 : c_pretty_printer::translate_string (const char *gmsgid)
    1199                 :            : {
    1200                 :      72471 :   if (pp_translate_identifiers (this))
    1201                 :       5296 :     pp_c_ws_string (this, _(gmsgid));
    1202                 :            :   else
    1203                 :      67175 :     pp_c_ws_string (this, gmsgid);
    1204                 :      72471 : }
    1205                 :            : 
    1206                 :            : /* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
    1207                 :            :    that need converting to the locale encoding, preceded by whitespace
    1208                 :            :    is necessary.  */
    1209                 :            : 
    1210                 :            : void
    1211                 :  125968000 : pp_c_identifier (c_pretty_printer *pp, const char *id)
    1212                 :            : {
    1213                 :  125968000 :   pp_c_maybe_whitespace (pp);
    1214                 :  125968000 :   pp_identifier (pp, id);
    1215                 :  125968000 :   pp->padding = pp_before;
    1216                 :  125968000 : }
    1217                 :            : 
    1218                 :            : /* Pretty-print a C primary-expression.
    1219                 :            :    primary-expression:
    1220                 :            :       identifier
    1221                 :            :       constant
    1222                 :            :       string-literal
    1223                 :            :       ( expression )   */
    1224                 :            : 
    1225                 :            : void
    1226                 :       8148 : c_pretty_printer::primary_expression (tree e)
    1227                 :            : {
    1228                 :       8148 :   switch (TREE_CODE (e))
    1229                 :            :     {
    1230                 :       7582 :     case VAR_DECL:
    1231                 :       7582 :     case PARM_DECL:
    1232                 :       7582 :     case FIELD_DECL:
    1233                 :       7582 :     case CONST_DECL:
    1234                 :       7582 :     case FUNCTION_DECL:
    1235                 :       7582 :     case LABEL_DECL:
    1236                 :       7582 :       pp_c_tree_decl_identifier (this, e);
    1237                 :       7582 :       break;
    1238                 :            : 
    1239                 :         32 :     case IDENTIFIER_NODE:
    1240                 :         32 :       pp_c_tree_identifier (this, e);
    1241                 :         32 :       break;
    1242                 :            : 
    1243                 :         11 :     case ERROR_MARK:
    1244                 :         11 :       translate_string ("<erroneous-expression>");
    1245                 :         11 :       break;
    1246                 :            : 
    1247                 :         16 :     case RESULT_DECL:
    1248                 :         16 :       translate_string ("<return-value>");
    1249                 :         16 :       break;
    1250                 :            : 
    1251                 :        238 :     case VOID_CST:
    1252                 :        238 :     case INTEGER_CST:
    1253                 :        238 :     case REAL_CST:
    1254                 :        238 :     case FIXED_CST:
    1255                 :        238 :     case STRING_CST:
    1256                 :        238 :       constant (e);
    1257                 :        238 :       break;
    1258                 :            : 
    1259                 :          0 :     case TARGET_EXPR:
    1260                 :          0 :       pp_c_ws_string (this, "__builtin_memcpy");
    1261                 :          0 :       pp_c_left_paren (this);
    1262                 :          0 :       pp_ampersand (this);
    1263                 :          0 :       primary_expression (TREE_OPERAND (e, 0));
    1264                 :          0 :       pp_separate_with (this, ',');
    1265                 :          0 :       pp_ampersand (this);
    1266                 :          0 :       initializer (TREE_OPERAND (e, 1));
    1267                 :          0 :       if (TREE_OPERAND (e, 2))
    1268                 :            :         {
    1269                 :          0 :           pp_separate_with (this, ',');
    1270                 :          0 :           expression (TREE_OPERAND (e, 2));
    1271                 :            :         }
    1272                 :          0 :       pp_c_right_paren (this);
    1273                 :          0 :       break;
    1274                 :            : 
    1275                 :        269 :     default:
    1276                 :            :       /* FIXME:  Make sure we won't get into an infinite loop.  */
    1277                 :        269 :       if (location_wrapper_p (e))
    1278                 :         28 :         expression (e);
    1279                 :            :       else
    1280                 :            :         {
    1281                 :        241 :           pp_c_left_paren (this);
    1282                 :        241 :           expression (e);
    1283                 :        241 :           pp_c_right_paren (this);
    1284                 :            :         }
    1285                 :            :       break;
    1286                 :            :     }
    1287                 :       8148 : }
    1288                 :            : 
    1289                 :            : /* Print out a C initializer -- also support C compound-literals.
    1290                 :            :    initializer:
    1291                 :            :       assignment-expression:
    1292                 :            :       { initializer-list }
    1293                 :            :       { initializer-list , }   */
    1294                 :            : 
    1295                 :            : void
    1296                 :          3 : c_pretty_printer::initializer (tree e)
    1297                 :            : {
    1298                 :          3 :   if (TREE_CODE (e) == CONSTRUCTOR)
    1299                 :          3 :     pp_c_brace_enclosed_initializer_list (this, e);
    1300                 :            :   else
    1301                 :          0 :     expression (e);
    1302                 :          3 : }
    1303                 :            : 
    1304                 :            : /* init-declarator:
    1305                 :            :       declarator:
    1306                 :            :       declarator = initializer   */
    1307                 :            : 
    1308                 :            : void
    1309                 :          0 : pp_c_init_declarator (c_pretty_printer *pp, tree t)
    1310                 :            : {
    1311                 :          0 :   pp->declarator (t);
    1312                 :            :   /* We don't want to output function definitions here.  There are handled
    1313                 :            :      elsewhere (and the syntactic form is bogus anyway).  */
    1314                 :          0 :   if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
    1315                 :            :     {
    1316                 :          0 :       tree init = DECL_INITIAL (t);
    1317                 :            :       /* This C++ bit is handled here because it is easier to do so.
    1318                 :            :          In templates, the C++ parser builds a TREE_LIST for a
    1319                 :            :          direct-initialization; the TREE_PURPOSE is the variable to
    1320                 :            :          initialize and the TREE_VALUE is the initializer.  */
    1321                 :          0 :       if (TREE_CODE (init) == TREE_LIST)
    1322                 :            :         {
    1323                 :          0 :           pp_c_left_paren (pp);
    1324                 :          0 :           pp->expression (TREE_VALUE (init));
    1325                 :          0 :           pp_right_paren (pp);
    1326                 :            :         }
    1327                 :            :       else
    1328                 :            :         {
    1329                 :          0 :           pp_space (pp);
    1330                 :          0 :           pp_equal (pp);
    1331                 :          0 :           pp_space (pp);
    1332                 :          0 :           pp->initializer (init);
    1333                 :            :         }
    1334                 :            :     }
    1335                 :          0 : }
    1336                 :            : 
    1337                 :            : /* initializer-list:
    1338                 :            :       designation(opt) initializer
    1339                 :            :       initializer-list , designation(opt) initializer
    1340                 :            : 
    1341                 :            :    designation:
    1342                 :            :       designator-list =
    1343                 :            : 
    1344                 :            :    designator-list:
    1345                 :            :       designator
    1346                 :            :       designator-list designator
    1347                 :            : 
    1348                 :            :    designator:
    1349                 :            :       [ constant-expression ]
    1350                 :            :       identifier   */
    1351                 :            : 
    1352                 :            : static void
    1353                 :         73 : pp_c_initializer_list (c_pretty_printer *pp, tree e)
    1354                 :            : {
    1355                 :         73 :   tree type = TREE_TYPE (e);
    1356                 :         73 :   const enum tree_code code = TREE_CODE (type);
    1357                 :            : 
    1358                 :         73 :   if (TREE_CODE (e) == CONSTRUCTOR)
    1359                 :            :     {
    1360                 :          3 :       pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
    1361                 :          3 :       return;
    1362                 :            :     }
    1363                 :            : 
    1364                 :         70 :   switch (code)
    1365                 :            :     {
    1366                 :          0 :     case RECORD_TYPE:
    1367                 :          0 :     case UNION_TYPE:
    1368                 :          0 :     case ARRAY_TYPE:
    1369                 :          0 :       {
    1370                 :          0 :         tree init = TREE_OPERAND (e, 0);
    1371                 :          0 :         for (; init != NULL_TREE; init = TREE_CHAIN (init))
    1372                 :            :           {
    1373                 :          0 :             if (code == RECORD_TYPE || code == UNION_TYPE)
    1374                 :            :               {
    1375                 :          0 :                 pp_c_dot (pp);
    1376                 :          0 :                 pp->primary_expression (TREE_PURPOSE (init));
    1377                 :            :               }
    1378                 :            :             else
    1379                 :            :               {
    1380                 :          0 :                 pp_c_left_bracket (pp);
    1381                 :          0 :                 if (TREE_PURPOSE (init))
    1382                 :          0 :                   pp->constant (TREE_PURPOSE (init));
    1383                 :          0 :                 pp_c_right_bracket (pp);
    1384                 :            :               }
    1385                 :          0 :             pp_c_whitespace (pp);
    1386                 :          0 :             pp_equal (pp);
    1387                 :          0 :             pp_c_whitespace (pp);
    1388                 :          0 :             pp->initializer (TREE_VALUE (init));
    1389                 :          0 :             if (TREE_CHAIN (init))
    1390                 :          0 :               pp_separate_with (pp, ',');
    1391                 :            :           }
    1392                 :            :       }
    1393                 :            :       return;
    1394                 :            : 
    1395                 :          8 :     case VECTOR_TYPE:
    1396                 :          8 :       if (TREE_CODE (e) == VECTOR_CST)
    1397                 :            :         {
    1398                 :            :           /* We don't create variable-length VECTOR_CSTs.  */
    1399                 :          8 :           unsigned int nunits = VECTOR_CST_NELTS (e).to_constant ();
    1400                 :         40 :           for (unsigned int i = 0; i < nunits; ++i)
    1401                 :            :             {
    1402                 :         32 :               if (i > 0)
    1403                 :         24 :                 pp_separate_with (pp, ',');
    1404                 :         32 :               pp->expression (VECTOR_CST_ELT (e, i));
    1405                 :            :             }
    1406                 :            :         }
    1407                 :            :       else
    1408                 :            :         break;
    1409                 :            :       return;
    1410                 :            : 
    1411                 :         62 :     case COMPLEX_TYPE:
    1412                 :         62 :       if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
    1413                 :            :         {
    1414                 :         62 :           const bool cst = TREE_CODE (e) == COMPLEX_CST;
    1415                 :         62 :           pp->expression (cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
    1416                 :         62 :           pp_separate_with (pp, ',');
    1417                 :        116 :           pp->expression (cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
    1418                 :            :         }
    1419                 :            :       else
    1420                 :            :         break;
    1421                 :         62 :       return;
    1422                 :            : 
    1423                 :            :     default:
    1424                 :            :       break;
    1425                 :            :     }
    1426                 :            : 
    1427                 :          0 :   pp_unsupported_tree (pp, type);
    1428                 :            : }
    1429                 :            : 
    1430                 :            : /* Pretty-print a brace-enclosed initializer-list.  */
    1431                 :            : 
    1432                 :            : static void
    1433                 :         73 : pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
    1434                 :            : {
    1435                 :         73 :   pp_c_left_brace (pp);
    1436                 :         73 :   pp_c_initializer_list (pp, l);
    1437                 :         73 :   pp_c_right_brace (pp);
    1438                 :         73 : }
    1439                 :            : 
    1440                 :            : 
    1441                 :            : /*  This is a convenient function, used to bridge gap between C and C++
    1442                 :            :     grammars.
    1443                 :            : 
    1444                 :            :     id-expression:
    1445                 :            :        identifier  */
    1446                 :            : 
    1447                 :            : void
    1448                 :      11223 : c_pretty_printer::id_expression (tree t)
    1449                 :            : {
    1450                 :      11223 :   switch (TREE_CODE (t))
    1451                 :            :     {
    1452                 :       9454 :     case VAR_DECL:
    1453                 :       9454 :     case PARM_DECL:
    1454                 :       9454 :     case CONST_DECL:
    1455                 :       9454 :     case TYPE_DECL:
    1456                 :       9454 :     case FUNCTION_DECL:
    1457                 :       9454 :     case FIELD_DECL:
    1458                 :       9454 :     case LABEL_DECL:
    1459                 :       9454 :       pp_c_tree_decl_identifier (this, t);
    1460                 :       9454 :       break;
    1461                 :            : 
    1462                 :       1769 :     case IDENTIFIER_NODE:
    1463                 :       1769 :       pp_c_tree_identifier (this, t);
    1464                 :       1769 :       break;
    1465                 :            : 
    1466                 :          0 :     default:
    1467                 :          0 :       pp_unsupported_tree (this, t);
    1468                 :          0 :       break;
    1469                 :            :     }
    1470                 :      11223 : }
    1471                 :            : 
    1472                 :            : /* postfix-expression:
    1473                 :            :       primary-expression
    1474                 :            :       postfix-expression [ expression ]
    1475                 :            :       postfix-expression ( argument-expression-list(opt) )
    1476                 :            :       postfix-expression . identifier
    1477                 :            :       postfix-expression -> identifier
    1478                 :            :       postfix-expression ++
    1479                 :            :       postfix-expression --
    1480                 :            :       ( type-name ) { initializer-list }
    1481                 :            :       ( type-name ) { initializer-list , }  */
    1482                 :            : 
    1483                 :            : void
    1484                 :       1569 : c_pretty_printer::postfix_expression (tree e)
    1485                 :            : {
    1486                 :       1569 :   enum tree_code code = TREE_CODE (e);
    1487                 :       1569 :   switch (code)
    1488                 :            :     {
    1489                 :          0 :     case POSTINCREMENT_EXPR:
    1490                 :          0 :     case POSTDECREMENT_EXPR:
    1491                 :          0 :       postfix_expression (TREE_OPERAND (e, 0));
    1492                 :          0 :       pp_string (this, code == POSTINCREMENT_EXPR ? "++" : "--");
    1493                 :          0 :       break;
    1494                 :            : 
    1495                 :        222 :     case ARRAY_REF:
    1496                 :        222 :       postfix_expression (TREE_OPERAND (e, 0));
    1497                 :        222 :       pp_c_left_bracket (this);
    1498                 :        222 :       expression (TREE_OPERAND (e, 1));
    1499                 :        222 :       pp_c_right_bracket (this);
    1500                 :        222 :       break;
    1501                 :            : 
    1502                 :          3 :     case CALL_EXPR:
    1503                 :          3 :       {
    1504                 :          3 :         call_expr_arg_iterator iter;
    1505                 :          3 :         tree arg;
    1506                 :          3 :         postfix_expression (CALL_EXPR_FN (e));
    1507                 :          3 :         pp_c_left_paren (this);
    1508                 :          6 :         FOR_EACH_CALL_EXPR_ARG (arg, iter, e)
    1509                 :            :           {
    1510                 :          3 :             expression (arg);
    1511                 :          3 :             if (more_call_expr_args_p (&iter))
    1512                 :          0 :               pp_separate_with (this, ',');
    1513                 :            :           }
    1514                 :          3 :         pp_c_right_paren (this);
    1515                 :          3 :         break;
    1516                 :            :       }
    1517                 :            : 
    1518                 :          0 :     case UNORDERED_EXPR:
    1519                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1520                 :            :                            ? "isunordered"
    1521                 :          0 :                            : "__builtin_isunordered");
    1522                 :          0 :       goto two_args_fun;
    1523                 :            : 
    1524                 :          0 :     case ORDERED_EXPR:
    1525                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1526                 :            :                            ? "!isunordered"
    1527                 :          0 :                            : "!__builtin_isunordered");
    1528                 :          0 :       goto two_args_fun;
    1529                 :            : 
    1530                 :          0 :     case UNLT_EXPR:
    1531                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1532                 :            :                            ? "!isgreaterequal"
    1533                 :          0 :                            : "!__builtin_isgreaterequal");
    1534                 :          0 :       goto two_args_fun;
    1535                 :            : 
    1536                 :          0 :     case UNLE_EXPR:
    1537                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1538                 :            :                            ? "!isgreater"
    1539                 :          0 :                            : "!__builtin_isgreater");
    1540                 :          0 :       goto two_args_fun;
    1541                 :            : 
    1542                 :          0 :     case UNGT_EXPR:
    1543                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1544                 :            :                            ? "!islessequal"
    1545                 :          0 :                            : "!__builtin_islessequal");
    1546                 :          0 :       goto two_args_fun;
    1547                 :            : 
    1548                 :          0 :     case UNGE_EXPR:
    1549                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1550                 :            :                            ? "!isless"
    1551                 :          0 :                            : "!__builtin_isless");
    1552                 :          0 :       goto two_args_fun;
    1553                 :            : 
    1554                 :          0 :     case UNEQ_EXPR:
    1555                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1556                 :            :                            ? "!islessgreater"
    1557                 :          0 :                            : "!__builtin_islessgreater");
    1558                 :          0 :       goto two_args_fun;
    1559                 :            : 
    1560                 :          0 :     case LTGT_EXPR:
    1561                 :          0 :       pp_c_ws_string (this, flag_isoc99
    1562                 :            :                            ? "islessgreater"
    1563                 :          0 :                            : "__builtin_islessgreater");
    1564                 :          0 :       goto two_args_fun;
    1565                 :            : 
    1566                 :          1 :     case MAX_EXPR:
    1567                 :          1 :       pp_c_ws_string (this, "max");
    1568                 :          1 :       goto two_args_fun;
    1569                 :            : 
    1570                 :          1 :     case MIN_EXPR:
    1571                 :          1 :       pp_c_ws_string (this, "min");
    1572                 :          1 :       goto two_args_fun;
    1573                 :            : 
    1574                 :          2 :     two_args_fun:
    1575                 :          2 :       pp_c_left_paren (this);
    1576                 :          2 :       expression (TREE_OPERAND (e, 0));
    1577                 :          2 :       pp_separate_with (this, ',');
    1578                 :          2 :       expression (TREE_OPERAND (e, 1));
    1579                 :          2 :       pp_c_right_paren (this);
    1580                 :          2 :       break;
    1581                 :            : 
    1582                 :          0 :     case ABS_EXPR:
    1583                 :          0 :       pp_c_ws_string (this, "__builtin_abs");
    1584                 :          0 :       pp_c_left_paren (this);
    1585                 :          0 :       expression (TREE_OPERAND (e, 0));
    1586                 :          0 :       pp_c_right_paren (this);
    1587                 :          0 :       break;
    1588                 :            : 
    1589                 :        212 :     case COMPONENT_REF:
    1590                 :        212 :       {
    1591                 :        212 :         tree object = TREE_OPERAND (e, 0);
    1592                 :        212 :         if (INDIRECT_REF_P (object))
    1593                 :            :           {
    1594                 :         18 :             postfix_expression (TREE_OPERAND (object, 0));
    1595                 :         18 :             pp_c_arrow (this);
    1596                 :            :           }
    1597                 :            :         else
    1598                 :            :           {
    1599                 :        194 :             postfix_expression (object);
    1600                 :        194 :             pp_c_dot (this);
    1601                 :            :           }
    1602                 :        212 :         expression (TREE_OPERAND (e, 1));
    1603                 :            :       }
    1604                 :        212 :       break;
    1605                 :            : 
    1606                 :          0 :     case BIT_FIELD_REF:
    1607                 :          0 :       {
    1608                 :          0 :         tree type = TREE_TYPE (e);
    1609                 :            : 
    1610                 :          0 :         type = signed_or_unsigned_type_for (TYPE_UNSIGNED (type), type);
    1611                 :          0 :         if (type
    1612                 :          0 :             && tree_int_cst_equal (TYPE_SIZE (type), TREE_OPERAND (e, 1)))
    1613                 :            :           {
    1614                 :          0 :             HOST_WIDE_INT bitpos = tree_to_shwi (TREE_OPERAND (e, 2));
    1615                 :          0 :             HOST_WIDE_INT size = tree_to_shwi (TYPE_SIZE (type));
    1616                 :          0 :             if ((bitpos % size) == 0)
    1617                 :            :               {
    1618                 :          0 :                 pp_c_left_paren (this);
    1619                 :          0 :                 pp_c_left_paren (this);
    1620                 :          0 :                 type_id (type);
    1621                 :          0 :                 pp_c_star (this);
    1622                 :          0 :                 pp_c_right_paren (this);
    1623                 :          0 :                 pp_c_ampersand (this);
    1624                 :          0 :                 expression (TREE_OPERAND (e, 0));
    1625                 :          0 :                 pp_c_right_paren (this);
    1626                 :          0 :                 pp_c_left_bracket (this);
    1627                 :          0 :                 pp_wide_integer (this, bitpos / size);
    1628                 :          0 :                 pp_c_right_bracket (this);
    1629                 :          0 :                 break;
    1630                 :            :               }
    1631                 :            :           }
    1632                 :          0 :         pp_unsupported_tree (this, e);
    1633                 :            :       }
    1634                 :          0 :       break;
    1635                 :            : 
    1636                 :          6 :     case MEM_REF:
    1637                 :          6 :       expression (e);
    1638                 :          6 :       break;
    1639                 :            : 
    1640                 :         62 :     case COMPLEX_CST:
    1641                 :         62 :     case VECTOR_CST:
    1642                 :         62 :       pp_c_compound_literal (this, e);
    1643                 :         62 :       break;
    1644                 :            : 
    1645                 :         30 :     case COMPLEX_EXPR:
    1646                 :         30 :       pp_c_complex_expr (this, e);
    1647                 :         30 :       break;
    1648                 :            : 
    1649                 :          2 :     case COMPOUND_LITERAL_EXPR:
    1650                 :          2 :       e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
    1651                 :            :       /* Fall through.  */
    1652                 :          3 :     case CONSTRUCTOR:
    1653                 :          3 :       initializer (e);
    1654                 :          3 :       break;
    1655                 :            : 
    1656                 :          0 :     case VA_ARG_EXPR:
    1657                 :          0 :       pp_c_ws_string (this, "__builtin_va_arg");
    1658                 :          0 :       pp_c_left_paren (this);
    1659                 :          0 :       assignment_expression (TREE_OPERAND (e, 0));
    1660                 :          0 :       pp_separate_with (this, ',');
    1661                 :          0 :       type_id (TREE_TYPE (e));
    1662                 :          0 :       pp_c_right_paren (this);
    1663                 :          0 :       break;
    1664                 :            : 
    1665                 :          3 :     case ADDR_EXPR:
    1666                 :          3 :       if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
    1667                 :            :         {
    1668                 :          3 :           id_expression (TREE_OPERAND (e, 0));
    1669                 :          3 :           break;
    1670                 :            :         }
    1671                 :            :       /* fall through.  */
    1672                 :            : 
    1673                 :       1026 :     default:
    1674                 :       1026 :       primary_expression (e);
    1675                 :       1026 :       break;
    1676                 :            :     }
    1677                 :       1569 : }
    1678                 :            : 
    1679                 :            : /* Print out an expression-list; E is expected to be a TREE_LIST.  */
    1680                 :            : 
    1681                 :            : void
    1682                 :          0 : pp_c_expression_list (c_pretty_printer *pp, tree e)
    1683                 :            : {
    1684                 :          0 :   for (; e != NULL_TREE; e = TREE_CHAIN (e))
    1685                 :            :     {
    1686                 :          0 :       pp->expression (TREE_VALUE (e));
    1687                 :          0 :       if (TREE_CHAIN (e))
    1688                 :          0 :         pp_separate_with (pp, ',');
    1689                 :            :     }
    1690                 :          0 : }
    1691                 :            : 
    1692                 :            : /* Print out V, which contains the elements of a constructor.  */
    1693                 :            : 
    1694                 :            : void
    1695                 :          3 : pp_c_constructor_elts (c_pretty_printer *pp, vec<constructor_elt, va_gc> *v)
    1696                 :            : {
    1697                 :          3 :   unsigned HOST_WIDE_INT ix;
    1698                 :          3 :   tree value;
    1699                 :            : 
    1700                 :         11 :   FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
    1701                 :            :     {
    1702                 :          3 :       pp->expression (value);
    1703                 :          3 :       if (ix != vec_safe_length (v) - 1)
    1704                 :          1 :         pp_separate_with (pp, ',');
    1705                 :            :     }
    1706                 :          3 : }
    1707                 :            : 
    1708                 :            : /* Print out an expression-list in parens, as if it were the argument
    1709                 :            :    list to a function.  */
    1710                 :            : 
    1711                 :            : void
    1712                 :          8 : pp_c_call_argument_list (c_pretty_printer *pp, tree t)
    1713                 :            : {
    1714                 :          8 :   pp_c_left_paren (pp);
    1715                 :          8 :   if (t && TREE_CODE (t) == TREE_LIST)
    1716                 :          0 :     pp_c_expression_list (pp, t);
    1717                 :          8 :   pp_c_right_paren (pp);
    1718                 :          8 : }
    1719                 :            : 
    1720                 :            : /* unary-expression:
    1721                 :            :       postfix-expression
    1722                 :            :       ++ cast-expression
    1723                 :            :       -- cast-expression
    1724                 :            :       unary-operator cast-expression
    1725                 :            :       sizeof unary-expression
    1726                 :            :       sizeof ( type-id )
    1727                 :            : 
    1728                 :            :   unary-operator: one of
    1729                 :            :       * &  + - ! ~
    1730                 :            : 
    1731                 :            :    GNU extensions.
    1732                 :            :    unary-expression:
    1733                 :            :       __alignof__ unary-expression
    1734                 :            :       __alignof__ ( type-id )
    1735                 :            :       __real__ unary-expression
    1736                 :            :       __imag__ unary-expression  */
    1737                 :            : 
    1738                 :            : void
    1739                 :        819 : c_pretty_printer::unary_expression (tree e)
    1740                 :            : {
    1741                 :        819 :   enum tree_code code = TREE_CODE (e);
    1742                 :        819 :   switch (code)
    1743                 :            :     {
    1744                 :          0 :     case PREINCREMENT_EXPR:
    1745                 :          0 :     case PREDECREMENT_EXPR:
    1746                 :          0 :       pp_string (this, code == PREINCREMENT_EXPR ? "++" : "--");
    1747                 :          0 :       unary_expression (TREE_OPERAND (e, 0));
    1748                 :          0 :       break;
    1749                 :            : 
    1750                 :        127 :     case ADDR_EXPR:
    1751                 :        127 :     case INDIRECT_REF:
    1752                 :        127 :     case NEGATE_EXPR:
    1753                 :        127 :     case BIT_NOT_EXPR:
    1754                 :        127 :     case TRUTH_NOT_EXPR:
    1755                 :        127 :     case CONJ_EXPR:
    1756                 :            :       /* String literal are used by address.  */
    1757                 :        127 :       if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
    1758                 :         39 :         pp_ampersand (this);
    1759                 :         88 :       else if (code == INDIRECT_REF)
    1760                 :            :         {
    1761                 :         63 :           tree type = TREE_TYPE (TREE_OPERAND (e, 0));
    1762                 :         63 :           if (type && TREE_CODE (type) == REFERENCE_TYPE)
    1763                 :            :             /* Reference decay is implicit, don't print anything.  */;
    1764                 :            :           else
    1765                 :         62 :             pp_c_star (this);
    1766                 :            :         }
    1767                 :         25 :       else if (code == NEGATE_EXPR)
    1768                 :          3 :         pp_minus (this);
    1769                 :         22 :       else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
    1770                 :          0 :         pp_complement (this);
    1771                 :         22 :       else if (code == TRUTH_NOT_EXPR)
    1772                 :         22 :         pp_exclamation (this);
    1773                 :        127 :       pp_c_cast_expression (this, TREE_OPERAND (e, 0));
    1774                 :        127 :       break;
    1775                 :            : 
    1776                 :          7 :     case MEM_REF:
    1777                 :          7 :       if (TREE_CODE (TREE_OPERAND (e, 0)) == ADDR_EXPR
    1778                 :          7 :           && integer_zerop (TREE_OPERAND (e, 1)))
    1779                 :          6 :         expression (TREE_OPERAND (TREE_OPERAND (e, 0), 0));
    1780                 :            :       else
    1781                 :            :         {
    1782                 :          1 :           pp_c_star (this);
    1783                 :          1 :           if (!integer_zerop (TREE_OPERAND (e, 1)))
    1784                 :            :             {
    1785                 :          0 :               pp_c_left_paren (this);
    1786                 :          0 :               if (!integer_onep (TYPE_SIZE_UNIT
    1787                 :            :                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (e, 0))))))
    1788                 :          0 :                 pp_c_type_cast (this, ptr_type_node);
    1789                 :            :             }
    1790                 :          1 :           pp_c_cast_expression (this, TREE_OPERAND (e, 0));
    1791                 :          1 :           if (!integer_zerop (TREE_OPERAND (e, 1)))
    1792                 :            :             {
    1793                 :          0 :               pp_plus (this);
    1794                 :          0 :               pp_c_integer_constant (this,
    1795                 :          0 :                                      fold_convert (ssizetype,
    1796                 :            :                                                    TREE_OPERAND (e, 1)));
    1797                 :          0 :               pp_c_right_paren (this);
    1798                 :            :             }
    1799                 :            :         }
    1800                 :            :       break;
    1801                 :            : 
    1802                 :          0 :     case REALPART_EXPR:
    1803                 :          0 :     case IMAGPART_EXPR:
    1804                 :          0 :       pp_c_ws_string (this, code == REALPART_EXPR ? "__real__" : "__imag__");
    1805                 :          0 :       pp_c_whitespace (this);
    1806                 :          0 :       unary_expression (TREE_OPERAND (e, 0));
    1807                 :          0 :       break;
    1808                 :            : 
    1809                 :        685 :     default:
    1810                 :        685 :       postfix_expression (e);
    1811                 :        685 :       break;
    1812                 :            :     }
    1813                 :        819 : }
    1814                 :            : 
    1815                 :            : /* cast-expression:
    1816                 :            :       unary-expression
    1817                 :            :       ( type-name ) cast-expression  */
    1818                 :            : 
    1819                 :            : void
    1820                 :        737 : pp_c_cast_expression (c_pretty_printer *pp, tree e)
    1821                 :            : {
    1822                 :        960 :   switch (TREE_CODE (e))
    1823                 :            :     {
    1824                 :        223 :     case FLOAT_EXPR:
    1825                 :        223 :     case FIX_TRUNC_EXPR:
    1826                 :        223 :     CASE_CONVERT:
    1827                 :        223 :     case VIEW_CONVERT_EXPR:
    1828                 :        223 :       if (!location_wrapper_p (e))
    1829                 :        110 :         pp_c_type_cast (pp, TREE_TYPE (e));
    1830                 :        223 :       pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
    1831                 :        223 :       break;
    1832                 :            : 
    1833                 :        737 :     default:
    1834                 :        737 :       pp->unary_expression (e);
    1835                 :            :     }
    1836                 :        737 : }
    1837                 :            : 
    1838                 :            : /* multiplicative-expression:
    1839                 :            :       cast-expression
    1840                 :            :       multiplicative-expression * cast-expression
    1841                 :            :       multiplicative-expression / cast-expression
    1842                 :            :       multiplicative-expression % cast-expression   */
    1843                 :            : 
    1844                 :            : void
    1845                 :        303 : c_pretty_printer::multiplicative_expression (tree e)
    1846                 :            : {
    1847                 :        303 :   enum tree_code code = TREE_CODE (e);
    1848                 :        303 :   switch (code)
    1849                 :            :     {
    1850                 :          9 :     case MULT_EXPR:
    1851                 :          9 :     case TRUNC_DIV_EXPR:
    1852                 :          9 :     case TRUNC_MOD_EXPR:
    1853                 :          9 :     case EXACT_DIV_EXPR:
    1854                 :          9 :     case RDIV_EXPR:
    1855                 :          9 :       multiplicative_expression (TREE_OPERAND (e, 0));
    1856                 :          9 :       pp_c_whitespace (this);
    1857                 :          9 :       if (code == MULT_EXPR)
    1858                 :          6 :         pp_c_star (this);
    1859                 :          3 :       else if (code != TRUNC_MOD_EXPR)
    1860                 :          3 :         pp_slash (this);
    1861                 :            :       else
    1862                 :          0 :         pp_modulo (this);
    1863                 :          9 :       pp_c_whitespace (this);
    1864                 :          9 :       pp_c_cast_expression (this, TREE_OPERAND (e, 1));
    1865                 :          9 :       break;
    1866                 :            : 
    1867                 :        294 :     default:
    1868                 :        294 :       pp_c_cast_expression (this, e);
    1869                 :        294 :       break;
    1870                 :            :     }
    1871                 :        303 : }
    1872                 :            : 
    1873                 :            : /* additive-expression:
    1874                 :            :       multiplicative-expression
    1875                 :            :       additive-expression + multiplicative-expression
    1876                 :            :       additive-expression - multiplicative-expression   */
    1877                 :            : 
    1878                 :            : static void
    1879                 :        429 : pp_c_additive_expression (c_pretty_printer *pp, tree e)
    1880                 :            : {
    1881                 :        429 :   enum tree_code code = TREE_CODE (e);
    1882                 :        429 :   switch (code)
    1883                 :            :     {
    1884                 :         45 :     case POINTER_PLUS_EXPR:
    1885                 :         45 :     case PLUS_EXPR:
    1886                 :         45 :     case POINTER_DIFF_EXPR:
    1887                 :         45 :     case MINUS_EXPR:
    1888                 :         45 :       pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
    1889                 :         45 :       pp_c_whitespace (pp);
    1890                 :         45 :       if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)
    1891                 :         43 :         pp_plus (pp);
    1892                 :            :       else
    1893                 :          2 :         pp_minus (pp);
    1894                 :         45 :       pp_c_whitespace (pp);
    1895                 :         45 :       pp->multiplicative_expression (TREE_OPERAND (e, 1));
    1896                 :         45 :       break;
    1897                 :            : 
    1898                 :        384 :     default:
    1899                 :        384 :       pp->multiplicative_expression (e);
    1900                 :        384 :       break;
    1901                 :            :     }
    1902                 :        429 : }
    1903                 :            : 
    1904                 :            : /* additive-expression:
    1905                 :            :       additive-expression
    1906                 :            :       shift-expression << additive-expression
    1907                 :            :       shift-expression >> additive-expression   */
    1908                 :            : 
    1909                 :            : static void
    1910                 :        340 : pp_c_shift_expression (c_pretty_printer *pp, tree e)
    1911                 :            : {
    1912                 :        340 :   enum tree_code code = TREE_CODE (e);
    1913                 :        340 :   switch (code)
    1914                 :            :     {
    1915                 :         87 :     case LSHIFT_EXPR:
    1916                 :         87 :     case RSHIFT_EXPR:
    1917                 :         87 :     case LROTATE_EXPR:
    1918                 :         87 :     case RROTATE_EXPR:
    1919                 :         87 :       pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
    1920                 :         87 :       pp_c_whitespace (pp);
    1921                 :         93 :       pp_string (pp, code == LSHIFT_EXPR ? "<<" :
    1922                 :          6 :                      code == RSHIFT_EXPR ? ">>" :
    1923                 :            :                      code == LROTATE_EXPR ? "<<<" : ">>>");
    1924                 :         87 :       pp_c_whitespace (pp);
    1925                 :         87 :       pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
    1926                 :         87 :       break;
    1927                 :            : 
    1928                 :        253 :     default:
    1929                 :        253 :       pp_c_additive_expression (pp, e);
    1930                 :            :     }
    1931                 :        340 : }
    1932                 :            : 
    1933                 :            : /* relational-expression:
    1934                 :            :       shift-expression
    1935                 :            :       relational-expression < shift-expression
    1936                 :            :       relational-expression > shift-expression
    1937                 :            :       relational-expression <= shift-expression
    1938                 :            :       relational-expression >= shift-expression   */
    1939                 :            : 
    1940                 :            : static void
    1941                 :        166 : pp_c_relational_expression (c_pretty_printer *pp, tree e)
    1942                 :            : {
    1943                 :        166 :   enum tree_code code = TREE_CODE (e);
    1944                 :        166 :   switch (code)
    1945                 :            :     {
    1946                 :          4 :     case LT_EXPR:
    1947                 :          4 :     case GT_EXPR:
    1948                 :          4 :     case LE_EXPR:
    1949                 :          4 :     case GE_EXPR:
    1950                 :          4 :       pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
    1951                 :          4 :       pp_c_whitespace (pp);
    1952                 :          4 :       if (code == LT_EXPR)
    1953                 :          0 :         pp_less (pp);
    1954                 :          4 :       else if (code == GT_EXPR)
    1955                 :          0 :         pp_greater (pp);
    1956                 :          4 :       else if (code == LE_EXPR)
    1957                 :          1 :         pp_less_equal (pp);
    1958                 :          3 :       else if (code == GE_EXPR)
    1959                 :          3 :         pp_greater_equal (pp);
    1960                 :          4 :       pp_c_whitespace (pp);
    1961                 :          4 :       pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
    1962                 :          4 :       break;
    1963                 :            : 
    1964                 :        162 :     default:
    1965                 :        162 :       pp_c_shift_expression (pp, e);
    1966                 :        162 :       break;
    1967                 :            :     }
    1968                 :        166 : }
    1969                 :            : 
    1970                 :            : /* equality-expression:
    1971                 :            :       relational-expression
    1972                 :            :       equality-expression == relational-expression
    1973                 :            :       equality-equality != relational-expression  */
    1974                 :            : 
    1975                 :            : static void
    1976                 :        158 : pp_c_equality_expression (c_pretty_printer *pp, tree e)
    1977                 :            : {
    1978                 :        158 :   enum tree_code code = TREE_CODE (e);
    1979                 :        158 :   switch (code)
    1980                 :            :     {
    1981                 :         15 :     case EQ_EXPR:
    1982                 :         15 :     case NE_EXPR:
    1983                 :         15 :       pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
    1984                 :         15 :       pp_c_whitespace (pp);
    1985                 :         20 :       pp_string (pp, code == EQ_EXPR ? "==" : "!=");
    1986                 :         15 :       pp_c_whitespace (pp);
    1987                 :         15 :       pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
    1988                 :         15 :       break;
    1989                 :            : 
    1990                 :        143 :     default:
    1991                 :        143 :       pp_c_relational_expression (pp, e);
    1992                 :        143 :       break;
    1993                 :            :     }
    1994                 :        158 : }
    1995                 :            : 
    1996                 :            : /* AND-expression:
    1997                 :            :       equality-expression
    1998                 :            :       AND-expression & equality-equality   */
    1999                 :            : 
    2000                 :            : static void
    2001                 :        142 : pp_c_and_expression (c_pretty_printer *pp, tree e)
    2002                 :            : {
    2003                 :        142 :   if (TREE_CODE (e) == BIT_AND_EXPR)
    2004                 :            :     {
    2005                 :          1 :       pp_c_and_expression (pp, TREE_OPERAND (e, 0));
    2006                 :          1 :       pp_c_whitespace (pp);
    2007                 :          1 :       pp_ampersand (pp);
    2008                 :          1 :       pp_c_whitespace (pp);
    2009                 :          1 :       pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
    2010                 :            :     }
    2011                 :            :   else
    2012                 :        141 :     pp_c_equality_expression (pp, e);
    2013                 :        142 : }
    2014                 :            : 
    2015                 :            : /* exclusive-OR-expression:
    2016                 :            :      AND-expression
    2017                 :            :      exclusive-OR-expression ^ AND-expression  */
    2018                 :            : 
    2019                 :            : static void
    2020                 :        140 : pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
    2021                 :            : {
    2022                 :        140 :   if (TREE_CODE (e) == BIT_XOR_EXPR
    2023                 :        140 :       || TREE_CODE (e) == TRUTH_XOR_EXPR)
    2024                 :            :     {
    2025                 :          1 :       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
    2026                 :          1 :       if (TREE_CODE (e) == BIT_XOR_EXPR)
    2027                 :          0 :         pp_c_maybe_whitespace (pp);
    2028                 :            :       else
    2029                 :          1 :         pp_c_whitespace (pp);
    2030                 :          1 :       pp_carret (pp);
    2031                 :          1 :       pp_c_whitespace (pp);
    2032                 :          1 :       pp_c_and_expression (pp, TREE_OPERAND (e, 1));
    2033                 :            :     }
    2034                 :            :   else
    2035                 :        139 :     pp_c_and_expression (pp, e);
    2036                 :        140 : }
    2037                 :            : 
    2038                 :            : /* inclusive-OR-expression:
    2039                 :            :      exclusive-OR-expression
    2040                 :            :      inclusive-OR-expression | exclusive-OR-expression  */
    2041                 :            : 
    2042                 :            : static void
    2043                 :        138 : pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
    2044                 :            : {
    2045                 :        138 :   if (TREE_CODE (e) == BIT_IOR_EXPR)
    2046                 :            :     {
    2047                 :          0 :       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
    2048                 :          0 :       pp_c_whitespace (pp);
    2049                 :          0 :       pp_bar (pp);
    2050                 :          0 :       pp_c_whitespace (pp);
    2051                 :          0 :       pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
    2052                 :            :     }
    2053                 :            :   else
    2054                 :        138 :     pp_c_exclusive_or_expression (pp, e);
    2055                 :        138 : }
    2056                 :            : 
    2057                 :            : /* logical-AND-expression:
    2058                 :            :       inclusive-OR-expression
    2059                 :            :       logical-AND-expression && inclusive-OR-expression  */
    2060                 :            : 
    2061                 :            : static void
    2062                 :        138 : pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
    2063                 :            : {
    2064                 :        138 :   if (TREE_CODE (e) == TRUTH_ANDIF_EXPR
    2065                 :         93 :       || TREE_CODE (e) == TRUTH_AND_EXPR)
    2066                 :            :     {
    2067                 :         46 :       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
    2068                 :         46 :       pp_c_whitespace (pp);
    2069                 :         46 :       pp_ampersand_ampersand (pp);
    2070                 :         46 :       pp_c_whitespace (pp);
    2071                 :         46 :       pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
    2072                 :            :     }
    2073                 :            :   else
    2074                 :         92 :     pp_c_inclusive_or_expression (pp, e);
    2075                 :        138 : }
    2076                 :            : 
    2077                 :            : /* logical-OR-expression:
    2078                 :            :       logical-AND-expression
    2079                 :            :       logical-OR-expression || logical-AND-expression  */
    2080                 :            : 
    2081                 :            : void
    2082                 :         65 : pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
    2083                 :            : {
    2084                 :         65 :   if (TREE_CODE (e) == TRUTH_ORIF_EXPR
    2085                 :         51 :       || TREE_CODE (e) == TRUTH_OR_EXPR)
    2086                 :            :     {
    2087                 :         15 :       pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
    2088                 :         15 :       pp_c_whitespace (pp);
    2089                 :         15 :       pp_bar_bar (pp);
    2090                 :         15 :       pp_c_whitespace (pp);
    2091                 :         15 :       pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
    2092                 :            :     }
    2093                 :            :   else
    2094                 :         50 :     pp_c_logical_and_expression (pp, e);
    2095                 :         65 : }
    2096                 :            : 
    2097                 :            : /* conditional-expression:
    2098                 :            :       logical-OR-expression
    2099                 :            :       logical-OR-expression ? expression : conditional-expression  */
    2100                 :            : 
    2101                 :            : void
    2102                 :         16 : c_pretty_printer::conditional_expression (tree e)
    2103                 :            : {
    2104                 :         16 :   if (TREE_CODE (e) == COND_EXPR)
    2105                 :            :     {
    2106                 :          8 :       pp_c_logical_or_expression (this, TREE_OPERAND (e, 0));
    2107                 :          8 :       pp_c_whitespace (this);
    2108                 :          8 :       pp_question (this);
    2109                 :          8 :       pp_c_whitespace (this);
    2110                 :          8 :       expression (TREE_OPERAND (e, 1));
    2111                 :          8 :       pp_c_whitespace (this);
    2112                 :          8 :       pp_colon (this);
    2113                 :          8 :       pp_c_whitespace (this);
    2114                 :          8 :       conditional_expression (TREE_OPERAND (e, 2));
    2115                 :            :     }
    2116                 :            :   else
    2117                 :          8 :     pp_c_logical_or_expression (this, e);
    2118                 :         16 : }
    2119                 :            : 
    2120                 :            : 
    2121                 :            : /* assignment-expression:
    2122                 :            :       conditional-expression
    2123                 :            :       unary-expression assignment-operator  assignment-expression
    2124                 :            : 
    2125                 :            :    assignment-expression: one of
    2126                 :            :       =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
    2127                 :            : 
    2128                 :            : void
    2129                 :          0 : c_pretty_printer::assignment_expression (tree e)
    2130                 :            : {
    2131                 :          0 :   if (TREE_CODE (e) == MODIFY_EXPR
    2132                 :          0 :       || TREE_CODE (e) == INIT_EXPR)
    2133                 :            :     {
    2134                 :          0 :       unary_expression (TREE_OPERAND (e, 0));
    2135                 :          0 :       pp_c_whitespace (this);
    2136                 :          0 :       pp_equal (this);
    2137                 :          0 :       pp_space (this);
    2138                 :          0 :       expression (TREE_OPERAND (e, 1));
    2139                 :            :     }
    2140                 :            :   else
    2141                 :          0 :     conditional_expression (e);
    2142                 :          0 : }
    2143                 :            : 
    2144                 :            : /* expression:
    2145                 :            :        assignment-expression
    2146                 :            :        expression , assignment-expression
    2147                 :            : 
    2148                 :            :   Implementation note:  instead of going through the usual recursion
    2149                 :            :   chain, I take the liberty of dispatching nodes to the appropriate
    2150                 :            :   functions.  This makes some redundancy, but it worths it. That also
    2151                 :            :   prevents a possible infinite recursion between primary_expression ()
    2152                 :            :   and expression ().  */
    2153                 :            : 
    2154                 :            : void
    2155                 :      13151 : c_pretty_printer::expression (tree e)
    2156                 :            : {
    2157                 :      13151 :   switch (TREE_CODE (e))
    2158                 :            :     {
    2159                 :          0 :     case VOID_CST:
    2160                 :          0 :       pp_c_void_constant (this);
    2161                 :          0 :       break;
    2162                 :            : 
    2163                 :       3970 :     case INTEGER_CST:
    2164                 :       3970 :       pp_c_integer_constant (this, e);
    2165                 :       3970 :       break;
    2166                 :            : 
    2167                 :        155 :     case REAL_CST:
    2168                 :        155 :       pp_c_floating_constant (this, e);
    2169                 :        155 :       break;
    2170                 :            : 
    2171                 :          0 :     case FIXED_CST:
    2172                 :          0 :       pp_c_fixed_constant (this, e);
    2173                 :          0 :       break;
    2174                 :            : 
    2175                 :         17 :     case STRING_CST:
    2176                 :         17 :       pp_c_string_literal (this, e);
    2177                 :         17 :       break;
    2178                 :            : 
    2179                 :       7160 :     case IDENTIFIER_NODE:
    2180                 :       7160 :     case FUNCTION_DECL:
    2181                 :       7160 :     case VAR_DECL:
    2182                 :       7160 :     case CONST_DECL:
    2183                 :       7160 :     case PARM_DECL:
    2184                 :       7160 :     case RESULT_DECL:
    2185                 :       7160 :     case FIELD_DECL:
    2186                 :       7160 :     case LABEL_DECL:
    2187                 :       7160 :     case ERROR_MARK:
    2188                 :       7160 :       primary_expression (e);
    2189                 :       7160 :       break;
    2190                 :            : 
    2191                 :        911 :     case SSA_NAME:
    2192                 :        911 :       if (SSA_NAME_VAR (e)
    2193                 :        853 :           && !DECL_ARTIFICIAL (SSA_NAME_VAR (e)))
    2194                 :        853 :         expression (SSA_NAME_VAR (e));
    2195                 :            :       else
    2196                 :         58 :         translate_string ("<unknown>");
    2197                 :            :       break;
    2198                 :            : 
    2199                 :        455 :     case POSTINCREMENT_EXPR:
    2200                 :        455 :     case POSTDECREMENT_EXPR:
    2201                 :        455 :     case ARRAY_REF:
    2202                 :        455 :     case CALL_EXPR:
    2203                 :        455 :     case COMPONENT_REF:
    2204                 :        455 :     case BIT_FIELD_REF:
    2205                 :        455 :     case COMPLEX_CST:
    2206                 :        455 :     case COMPLEX_EXPR:
    2207                 :        455 :     case VECTOR_CST:
    2208                 :        455 :     case ORDERED_EXPR:
    2209                 :        455 :     case UNORDERED_EXPR:
    2210                 :        455 :     case LTGT_EXPR:
    2211                 :        455 :     case UNEQ_EXPR:
    2212                 :        455 :     case UNLE_EXPR:
    2213                 :        455 :     case UNLT_EXPR:
    2214                 :        455 :     case UNGE_EXPR:
    2215                 :        455 :     case UNGT_EXPR:
    2216                 :        455 :     case MAX_EXPR:
    2217                 :        455 :     case MIN_EXPR:
    2218                 :        455 :     case ABS_EXPR:
    2219                 :        455 :     case CONSTRUCTOR:
    2220                 :        455 :     case COMPOUND_LITERAL_EXPR:
    2221                 :        455 :     case VA_ARG_EXPR:
    2222                 :        455 :       postfix_expression (e);
    2223                 :        455 :       break;
    2224                 :            : 
    2225                 :         88 :     case CONJ_EXPR:
    2226                 :         88 :     case ADDR_EXPR:
    2227                 :         88 :     case INDIRECT_REF:
    2228                 :         88 :     case MEM_REF:
    2229                 :         88 :     case NEGATE_EXPR:
    2230                 :         88 :     case BIT_NOT_EXPR:
    2231                 :         88 :     case TRUTH_NOT_EXPR:
    2232                 :         88 :     case PREINCREMENT_EXPR:
    2233                 :         88 :     case PREDECREMENT_EXPR:
    2234                 :         88 :     case REALPART_EXPR:
    2235                 :         88 :     case IMAGPART_EXPR:
    2236                 :         88 :       unary_expression (e);
    2237                 :         88 :       break;
    2238                 :            : 
    2239                 :        134 :     case FLOAT_EXPR:
    2240                 :        134 :     case FIX_TRUNC_EXPR:
    2241                 :        134 :     CASE_CONVERT:
    2242                 :        134 :     case VIEW_CONVERT_EXPR:
    2243                 :        134 :       pp_c_cast_expression (this, e);
    2244                 :        134 :       break;
    2245                 :            : 
    2246                 :          8 :     case MULT_EXPR:
    2247                 :          8 :     case TRUNC_MOD_EXPR:
    2248                 :          8 :     case TRUNC_DIV_EXPR:
    2249                 :          8 :     case EXACT_DIV_EXPR:
    2250                 :          8 :     case RDIV_EXPR:
    2251                 :          8 :       multiplicative_expression (e);
    2252                 :          8 :       break;
    2253                 :            : 
    2254                 :         87 :     case LSHIFT_EXPR:
    2255                 :         87 :     case RSHIFT_EXPR:
    2256                 :         87 :     case LROTATE_EXPR:
    2257                 :         87 :     case RROTATE_EXPR:
    2258                 :         87 :       pp_c_shift_expression (this, e);
    2259                 :         87 :       break;
    2260                 :            : 
    2261                 :          4 :     case LT_EXPR:
    2262                 :          4 :     case GT_EXPR:
    2263                 :          4 :     case LE_EXPR:
    2264                 :          4 :     case GE_EXPR:
    2265                 :          4 :       pp_c_relational_expression (this, e);
    2266                 :          4 :       break;
    2267                 :            : 
    2268                 :          1 :     case BIT_AND_EXPR:
    2269                 :          1 :       pp_c_and_expression (this, e);
    2270                 :          1 :       break;
    2271                 :            : 
    2272                 :          1 :     case BIT_XOR_EXPR:
    2273                 :          1 :     case TRUTH_XOR_EXPR:
    2274                 :          1 :       pp_c_exclusive_or_expression (this, e);
    2275                 :          1 :       break;
    2276                 :            : 
    2277                 :          0 :     case BIT_IOR_EXPR:
    2278                 :          0 :       pp_c_inclusive_or_expression (this, e);
    2279                 :          0 :       break;
    2280                 :            : 
    2281                 :         27 :     case TRUTH_ANDIF_EXPR:
    2282                 :         27 :     case TRUTH_AND_EXPR:
    2283                 :         27 :       pp_c_logical_and_expression (this, e);
    2284                 :         27 :       break;
    2285                 :            : 
    2286                 :         10 :     case TRUTH_ORIF_EXPR:
    2287                 :         10 :     case TRUTH_OR_EXPR:
    2288                 :         10 :       pp_c_logical_or_expression (this, e);
    2289                 :         10 :       break;
    2290                 :            : 
    2291                 :          1 :     case EQ_EXPR:
    2292                 :          1 :     case NE_EXPR:
    2293                 :          1 :       pp_c_equality_expression (this, e);
    2294                 :          1 :       break;
    2295                 :            : 
    2296                 :          8 :     case COND_EXPR:
    2297                 :          8 :       conditional_expression (e);
    2298                 :          8 :       break;
    2299                 :            : 
    2300                 :         44 :     case POINTER_PLUS_EXPR:
    2301                 :         44 :     case PLUS_EXPR:
    2302                 :         44 :     case POINTER_DIFF_EXPR:
    2303                 :         44 :     case MINUS_EXPR:
    2304                 :         44 :       pp_c_additive_expression (this, e);
    2305                 :         44 :       break;
    2306                 :            : 
    2307                 :          0 :     case MODIFY_EXPR:
    2308                 :          0 :     case INIT_EXPR:
    2309                 :          0 :       assignment_expression (e);
    2310                 :          0 :       break;
    2311                 :            : 
    2312                 :          0 :     case COMPOUND_EXPR:
    2313                 :          0 :       pp_c_left_paren (this);
    2314                 :          0 :       expression (TREE_OPERAND (e, 0));
    2315                 :          0 :       pp_separate_with (this, ',');
    2316                 :          0 :       assignment_expression (TREE_OPERAND (e, 1));
    2317                 :          0 :       pp_c_right_paren (this);
    2318                 :          0 :       break;
    2319                 :            : 
    2320                 :         65 :     case NON_LVALUE_EXPR:
    2321                 :         65 :     case SAVE_EXPR:
    2322                 :         65 :       expression (TREE_OPERAND (e, 0));
    2323                 :         65 :       break;
    2324                 :            : 
    2325                 :          1 :     case TARGET_EXPR:
    2326                 :          1 :       postfix_expression (TREE_OPERAND (e, 1));
    2327                 :          1 :       break;
    2328                 :            : 
    2329                 :          3 :     case BIND_EXPR:
    2330                 :          3 :     case GOTO_EXPR:
    2331                 :            :       /* We don't yet have a way of dumping statements in a
    2332                 :            :          human-readable format.  */
    2333                 :          3 :       pp_string (this, "({...})");
    2334                 :          3 :       break;
    2335                 :            : 
    2336                 :          1 :     case C_MAYBE_CONST_EXPR:
    2337                 :          1 :       expression (C_MAYBE_CONST_EXPR_EXPR (e));
    2338                 :          1 :       break;
    2339                 :            : 
    2340                 :          0 :     default:
    2341                 :          0 :       pp_unsupported_tree (this, e);
    2342                 :          0 :       break;
    2343                 :            :     }
    2344                 :      13151 : }
    2345                 :            : 
    2346                 :            : 
    2347                 :            : 
    2348                 :            : /* Statements.  */
    2349                 :            : 
    2350                 :            : void
    2351                 :        870 : c_pretty_printer::statement (tree stmt)
    2352                 :            : {
    2353                 :        870 :   if (stmt == NULL)
    2354                 :            :     return;
    2355                 :            : 
    2356                 :        870 :   if (pp_needs_newline (this))
    2357                 :        870 :     pp_newline_and_indent (this, 0);
    2358                 :            : 
    2359                 :        870 :   dump_generic_node (this, stmt, pp_indentation (this), TDF_NONE, true);
    2360                 :            : }
    2361                 :            : 
    2362                 :            : 
    2363                 :            : /* Initialize the PRETTY-PRINTER for handling C codes.  */
    2364                 :            : 
    2365                 :     237567 : c_pretty_printer::c_pretty_printer ()
    2366                 :            :   : pretty_printer (),
    2367                 :            :     offset_list (),
    2368                 :     237567 :     flags ()
    2369                 :            : {
    2370                 :     237567 :   type_specifier_seq        = pp_c_specifier_qualifier_list;
    2371                 :     237567 :   ptr_operator              = pp_c_pointer;
    2372                 :     237567 :   parameter_list            = pp_c_parameter_type_list;
    2373                 :     237567 : }
    2374                 :            : 
    2375                 :            : /* c_pretty_printer's implementation of pretty_printer::clone vfunc.  */
    2376                 :            : 
    2377                 :            : pretty_printer *
    2378                 :       2324 : c_pretty_printer::clone () const
    2379                 :            : {
    2380                 :       2324 :   return new c_pretty_printer (*this);
    2381                 :            : }
    2382                 :            : 
    2383                 :            : /* Print the tree T in full, on file FILE.  */
    2384                 :            : 
    2385                 :            : void
    2386                 :        870 : print_c_tree (FILE *file, tree t)
    2387                 :            : {
    2388                 :        870 :   c_pretty_printer pp;
    2389                 :            : 
    2390                 :        870 :   pp_needs_newline (&pp) = true;
    2391                 :        870 :   pp.buffer->stream = file;
    2392                 :        870 :   pp.statement (t);
    2393                 :        870 :   pp_newline_and_flush (&pp);
    2394                 :        870 : }
    2395                 :            : 
    2396                 :            : /* Print the tree T in full, on stderr.  */
    2397                 :            : 
    2398                 :            : DEBUG_FUNCTION void
    2399                 :          0 : debug_c_tree (tree t)
    2400                 :            : {
    2401                 :          0 :   print_c_tree (stderr, t);
    2402                 :          0 :   fputc ('\n', stderr);
    2403                 :          0 : }
    2404                 :            : 
    2405                 :            : /* Output the DECL_NAME of T.  If T has no DECL_NAME, output a string made
    2406                 :            :    up of T's memory address.  */
    2407                 :            : 
    2408                 :            : void
    2409                 :      17036 : pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
    2410                 :            : {
    2411                 :      17036 :   const char *name;
    2412                 :            : 
    2413                 :      17036 :   gcc_assert (DECL_P (t));
    2414                 :            : 
    2415                 :      17036 :   if (DECL_NAME (t))
    2416                 :      17014 :     name = IDENTIFIER_POINTER (DECL_NAME (t));
    2417                 :            :   else
    2418                 :            :     {
    2419                 :         22 :       static char xname[8];
    2420                 :         22 :       sprintf (xname, "<U%4hx>", ((unsigned short) ((uintptr_t) (t)
    2421                 :            :                                                     & 0xffff)));
    2422                 :         22 :       name = xname;
    2423                 :            :     }
    2424                 :            : 
    2425                 :      17036 :   pp_c_identifier (pp, name);
    2426                 :      17036 : }
    2427                 :            : 
    2428                 :            : #if CHECKING_P
    2429                 :            : 
    2430                 :            : namespace selftest {
    2431                 :            : 
    2432                 :            : /* Selftests for pretty-printing trees.  */
    2433                 :            : 
    2434                 :            : /* Verify that EXPR printed by c_pretty_printer is EXPECTED, using
    2435                 :            :    LOC as the effective location for any failures.  */
    2436                 :            : 
    2437                 :            : static void
    2438                 :          8 : assert_c_pretty_printer_output (const location &loc, const char *expected,
    2439                 :            :                                 tree expr)
    2440                 :            : {
    2441                 :          8 :   c_pretty_printer pp;
    2442                 :          8 :   pp.expression (expr);
    2443                 :          8 :   ASSERT_STREQ_AT (loc, expected, pp_formatted_text (&pp));
    2444                 :          8 : }
    2445                 :            : 
    2446                 :            : /* Helper function for calling assert_c_pretty_printer_output.
    2447                 :            :    This is to avoid having to write SELFTEST_LOCATION.  */
    2448                 :            : 
    2449                 :            : #define ASSERT_C_PRETTY_PRINTER_OUTPUT(EXPECTED, EXPR) \
    2450                 :            :   SELFTEST_BEGIN_STMT                                           \
    2451                 :            :     assert_c_pretty_printer_output ((SELFTEST_LOCATION),        \
    2452                 :            :                                     (EXPECTED),         \
    2453                 :            :                                     (EXPR));                    \
    2454                 :            :   SELFTEST_END_STMT
    2455                 :            : 
    2456                 :            : /* Verify that location wrappers don't show up in pretty-printed output.  */
    2457                 :            : 
    2458                 :            : static void
    2459                 :          2 : test_location_wrappers ()
    2460                 :            : {
    2461                 :            :   /* VAR_DECL.  */
    2462                 :          2 :   tree id = get_identifier ("foo");
    2463                 :          2 :   tree decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id,
    2464                 :            :                           integer_type_node);
    2465                 :          2 :   tree wrapped_decl = maybe_wrap_with_location (decl, BUILTINS_LOCATION);
    2466                 :          2 :   ASSERT_NE (wrapped_decl, decl);
    2467                 :          2 :   ASSERT_C_PRETTY_PRINTER_OUTPUT ("foo", decl);
    2468                 :          2 :   ASSERT_C_PRETTY_PRINTER_OUTPUT ("foo", wrapped_decl);
    2469                 :            : 
    2470                 :            :   /* INTEGER_CST.  */
    2471                 :          2 :   tree int_cst = build_int_cst (integer_type_node, 42);
    2472                 :          2 :   tree wrapped_cst = maybe_wrap_with_location (int_cst, BUILTINS_LOCATION);
    2473                 :          2 :   ASSERT_NE (wrapped_cst, int_cst);
    2474                 :          2 :   ASSERT_C_PRETTY_PRINTER_OUTPUT ("42", int_cst);
    2475                 :          2 :   ASSERT_C_PRETTY_PRINTER_OUTPUT ("42", wrapped_cst);
    2476                 :          2 : }
    2477                 :            : 
    2478                 :            : /* Run all of the selftests within this file.  */
    2479                 :            : 
    2480                 :            : void
    2481                 :          2 : c_pretty_print_c_tests ()
    2482                 :            : {
    2483                 :          2 :   test_location_wrappers ();
    2484                 :          2 : }
    2485                 :            : 
    2486                 :            : } // namespace selftest
    2487                 :            : 
    2488                 :            : #endif /* CHECKING_P */

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.