LCOV - code coverage report
Current view: top level - gcc - print-rtl.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 865 1217 71.1 %
Date: 2020-04-04 11:58:09 Functions: 33 59 55.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Print RTL for GCC.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : /* This file is compiled twice: once for the generator programs,
      21                 :            :    once for the compiler.  */
      22                 :            : #ifdef GENERATOR_FILE
      23                 :            : #include "bconfig.h"
      24                 :            : #else
      25                 :            : #include "config.h"
      26                 :            : #endif
      27                 :            : 
      28                 :            : #include "system.h"
      29                 :            : #include "coretypes.h"
      30                 :            : #include "tm.h"
      31                 :            : #include "rtl.h"
      32                 :            : 
      33                 :            : /* These headers all define things which are not available in
      34                 :            :    generator programs.  */
      35                 :            : #ifndef GENERATOR_FILE
      36                 :            : #include "alias.h"
      37                 :            : #include "tree.h"
      38                 :            : #include "basic-block.h"
      39                 :            : #include "print-tree.h"
      40                 :            : #include "flags.h"
      41                 :            : #include "predict.h"
      42                 :            : #include "function.h"
      43                 :            : #include "cfg.h"
      44                 :            : #include "basic-block.h"
      45                 :            : #include "diagnostic.h"
      46                 :            : #include "tree-pretty-print.h"
      47                 :            : #include "alloc-pool.h"
      48                 :            : #include "cselib.h"
      49                 :            : #include "dumpfile.h" /* for dump_flags */
      50                 :            : #include "dwarf2out.h"
      51                 :            : #include "pretty-print.h"
      52                 :            : #endif
      53                 :            : 
      54                 :            : #include "print-rtl.h"
      55                 :            : #include "rtl-iter.h"
      56                 :            : 
      57                 :            : /* Disable warnings about quoting issues in the pp_xxx calls below
      58                 :            :    that (intentionally) don't follow GCC diagnostic conventions.  */
      59                 :            : #if __GNUC__ >= 10
      60                 :            : #  pragma GCC diagnostic push
      61                 :            : #  pragma GCC diagnostic ignored "-Wformat-diag"
      62                 :            : #endif
      63                 :            : 
      64                 :            : /* String printed at beginning of each RTL when it is dumped.
      65                 :            :    This string is set to ASM_COMMENT_START when the RTL is dumped in
      66                 :            :    the assembly output file.  */
      67                 :            : const char *print_rtx_head = "";
      68                 :            : 
      69                 :            : #ifdef GENERATOR_FILE
      70                 :            : /* These are defined from the .opt file when not used in generator
      71                 :            :    programs.  */
      72                 :            : 
      73                 :            : /* Nonzero means suppress output of instruction numbers
      74                 :            :    in debugging dumps.
      75                 :            :    This must be defined here so that programs like gencodes can be linked.  */
      76                 :            : int flag_dump_unnumbered = 0;
      77                 :            : 
      78                 :            : /* Nonzero means suppress output of instruction numbers for previous
      79                 :            :    and next insns in debugging dumps.
      80                 :            :    This must be defined here so that programs like gencodes can be linked.  */
      81                 :            : int flag_dump_unnumbered_links = 0;
      82                 :            : #endif
      83                 :            : 
      84                 :            : /* Constructor for rtx_writer.  */
      85                 :            : 
      86                 :     290352 : rtx_writer::rtx_writer (FILE *outf, int ind, bool simple, bool compact,
      87                 :     290352 :                         rtx_reuse_manager *reuse_manager)
      88                 :            : : m_outfile (outf), m_sawclose (0), m_indent (ind),
      89                 :            :   m_in_call_function_usage (false), m_simple (simple), m_compact (compact),
      90                 :     290352 :   m_rtx_reuse_manager (reuse_manager)
      91                 :            : {
      92                 :     290352 : }
      93                 :            : 
      94                 :            : #ifndef GENERATOR_FILE
      95                 :            : 
      96                 :            : /* rtx_reuse_manager's ctor.  */
      97                 :            : 
      98                 :          6 : rtx_reuse_manager::rtx_reuse_manager ()
      99                 :          6 : : m_next_id (0)
     100                 :            : {
     101                 :          6 : }
     102                 :            : 
     103                 :            : /* Determine if X is of a kind suitable for dumping via reuse_rtx.  */
     104                 :            : 
     105                 :            : static bool
     106                 :         70 : uses_rtx_reuse_p (const_rtx x)
     107                 :            : {
     108                 :         70 :   if (x == NULL)
     109                 :            :     return false;
     110                 :            : 
     111                 :         60 :   switch (GET_CODE (x))
     112                 :            :     {
     113                 :            :     case DEBUG_EXPR:
     114                 :            :     case VALUE:
     115                 :            :     case SCRATCH:
     116                 :            :       return true;
     117                 :            : 
     118                 :            :     /* We don't use reuse_rtx for consts.  */
     119                 :          0 :     CASE_CONST_UNIQUE:
     120                 :          0 :     default:
     121                 :          0 :       return false;
     122                 :            :     }
     123                 :            : }
     124                 :            : 
     125                 :            : /* Traverse X and its descendents, determining if we see any rtx more than
     126                 :            :    once.  Any rtx suitable for "reuse_rtx" that is seen more than once is
     127                 :            :    assigned an ID.  */
     128                 :            : 
     129                 :            : void
     130                 :         26 : rtx_reuse_manager::preprocess (const_rtx x)
     131                 :            : {
     132                 :         26 :   subrtx_iterator::array_type array;
     133                 :         96 :   FOR_EACH_SUBRTX (iter, array, x, NONCONST)
     134                 :        130 :     if (uses_rtx_reuse_p (*iter))
     135                 :            :       {
     136                 :         14 :         if (int *count = m_rtx_occurrence_count.get (*iter))
     137                 :            :           {
     138                 :          6 :             if (*(count++) == 1)
     139                 :          6 :               m_rtx_reuse_ids.put (*iter, m_next_id++);
     140                 :            :           }
     141                 :            :         else
     142                 :          8 :           m_rtx_occurrence_count.put (*iter, 1);
     143                 :            :       }
     144                 :         26 : }
     145                 :            : 
     146                 :            : /* Return true iff X has been assigned a reuse ID.  If it has,
     147                 :            :    and OUT is non-NULL, then write the reuse ID to *OUT.  */
     148                 :            : 
     149                 :            : bool
     150                 :         72 : rtx_reuse_manager::has_reuse_id (const_rtx x, int *out)
     151                 :            : {
     152                 :         72 :   int *id = m_rtx_reuse_ids.get (x);
     153                 :         20 :   if (id)
     154                 :            :     {
     155                 :         20 :       if (out)
     156                 :         20 :         *out = *id;
     157                 :         20 :       return true;
     158                 :            :     }
     159                 :            :   else
     160                 :            :     return false;
     161                 :            : }
     162                 :            : 
     163                 :            : /* Determine if set_seen_def has been called for the given reuse ID.  */
     164                 :            : 
     165                 :            : bool
     166                 :         16 : rtx_reuse_manager::seen_def_p (int reuse_id)
     167                 :            : {
     168                 :         16 :   return bitmap_bit_p (m_defs_seen, reuse_id);
     169                 :            : }
     170                 :            : 
     171                 :            : /* Record that the definition of the given reuse ID has been seen.  */
     172                 :            : 
     173                 :            : void
     174                 :          6 : rtx_reuse_manager::set_seen_def (int reuse_id)
     175                 :            : {
     176                 :          6 :   bitmap_set_bit (m_defs_seen, reuse_id);
     177                 :          6 : }
     178                 :            : 
     179                 :            : #endif /* #ifndef GENERATOR_FILE */
     180                 :            : 
     181                 :            : #ifndef GENERATOR_FILE
     182                 :            : void
     183                 :     236633 : print_mem_expr (FILE *outfile, const_tree expr)
     184                 :            : {
     185                 :     236633 :   fputc (' ', outfile);
     186                 :     236633 :   print_generic_expr (outfile, CONST_CAST_TREE (expr), dump_flags);
     187                 :     236633 : }
     188                 :            : #endif
     189                 :            : 
     190                 :            : /* Print X to FILE.  */
     191                 :            : 
     192                 :            : static void
     193                 :     111736 : print_poly_int (FILE *file, poly_int64 x)
     194                 :            : {
     195                 :     111736 :   HOST_WIDE_INT const_x;
     196                 :       1993 :   if (x.is_constant (&const_x))
     197                 :     109743 :     fprintf (file, HOST_WIDE_INT_PRINT_DEC, const_x);
     198                 :            :   else
     199                 :            :     {
     200                 :            :       fprintf (file, "[" HOST_WIDE_INT_PRINT_DEC, x.coeffs[0]);
     201                 :            :       for (int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
     202                 :            :         fprintf (file, ", " HOST_WIDE_INT_PRINT_DEC, x.coeffs[i]);
     203                 :            :       fprintf (file, "]");
     204                 :            :     }
     205                 :          0 : }
     206                 :            : 
     207                 :            : /* Subroutine of print_rtx_operand for handling code '0'.
     208                 :            :    0 indicates a field for internal use that should not be printed.
     209                 :            :    However there are various special cases, such as the third field
     210                 :            :    of a NOTE, where it indicates that the field has several different
     211                 :            :    valid contents.  */
     212                 :            : 
     213                 :            : void
     214                 :     288641 : rtx_writer::print_rtx_operand_code_0 (const_rtx in_rtx ATTRIBUTE_UNUSED,
     215                 :            :                                       int idx ATTRIBUTE_UNUSED)
     216                 :            : {
     217                 :            : #ifndef GENERATOR_FILE
     218                 :     288641 :   if (idx == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
     219                 :            :     {
     220                 :      28626 :       int flags = SYMBOL_REF_FLAGS (in_rtx);
     221                 :      28626 :       if (flags)
     222                 :      28608 :         fprintf (m_outfile, " [flags %#x]", flags);
     223                 :      28626 :       tree decl = SYMBOL_REF_DECL (in_rtx);
     224                 :      28388 :       if (decl)
     225                 :      28386 :         print_node_brief (m_outfile, "", decl, dump_flags);
     226                 :            :     }
     227                 :     260015 :   else if (idx == 3 && NOTE_P (in_rtx))
     228                 :            :     {
     229                 :      78955 :       switch (NOTE_KIND (in_rtx))
     230                 :            :         {
     231                 :        546 :         case NOTE_INSN_EH_REGION_BEG:
     232                 :        546 :         case NOTE_INSN_EH_REGION_END:
     233                 :        546 :           if (flag_dump_unnumbered)
     234                 :        546 :             fprintf (m_outfile, " #");
     235                 :            :           else
     236                 :          0 :             fprintf (m_outfile, " %d", NOTE_EH_HANDLER (in_rtx));
     237                 :        546 :           m_sawclose = 1;
     238                 :        546 :           break;
     239                 :            : 
     240                 :          0 :         case NOTE_INSN_BLOCK_BEG:
     241                 :          0 :         case NOTE_INSN_BLOCK_END:
     242                 :          0 :           dump_addr (m_outfile, " ", NOTE_BLOCK (in_rtx));
     243                 :          0 :           m_sawclose = 1;
     244                 :          0 :           break;
     245                 :            : 
     246                 :      35205 :         case NOTE_INSN_BASIC_BLOCK:
     247                 :      35205 :           {
     248                 :      35205 :             basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
     249                 :      35205 :             if (bb != 0)
     250                 :      35185 :               fprintf (m_outfile, " [bb %d]", bb->index);
     251                 :            :             break;
     252                 :            :           }
     253                 :            : 
     254                 :          8 :         case NOTE_INSN_DELETED_LABEL:
     255                 :          8 :         case NOTE_INSN_DELETED_DEBUG_LABEL:
     256                 :          8 :           {
     257                 :          8 :             const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
     258                 :          8 :             if (label)
     259                 :          8 :               fprintf (m_outfile, " (\"%s\")", label);
     260                 :            :             else
     261                 :          0 :               fprintf (m_outfile, " \"\"");
     262                 :            :           }
     263                 :            :           break;
     264                 :            : 
     265                 :         89 :         case NOTE_INSN_SWITCH_TEXT_SECTIONS:
     266                 :         89 :           {
     267                 :         89 :             basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
     268                 :         89 :             if (bb != 0)
     269                 :          0 :               fprintf (m_outfile, " [bb %d]", bb->index);
     270                 :            :             break;
     271                 :            :           }
     272                 :            : 
     273                 :       1584 :         case NOTE_INSN_VAR_LOCATION:
     274                 :       1584 :           fputc (' ', m_outfile);
     275                 :       1584 :           print_rtx (NOTE_VAR_LOCATION (in_rtx));
     276                 :       1584 :           break;
     277                 :            : 
     278                 :        342 :         case NOTE_INSN_CFI:
     279                 :        342 :           fputc ('\n', m_outfile);
     280                 :        342 :           output_cfi_directive (m_outfile, NOTE_CFI (in_rtx));
     281                 :        342 :           fputc ('\t', m_outfile);
     282                 :        342 :           break;
     283                 :            : 
     284                 :        656 :         case NOTE_INSN_BEGIN_STMT:
     285                 :        656 :         case NOTE_INSN_INLINE_ENTRY:
     286                 :            : #ifndef GENERATOR_FILE
     287                 :        656 :           {
     288                 :        656 :             expanded_location xloc
     289                 :        656 :               = expand_location (NOTE_MARKER_LOCATION (in_rtx));
     290                 :        656 :             fprintf (m_outfile, " %s:%i", xloc.file, xloc.line);
     291                 :            :           }
     292                 :            : #endif
     293                 :        656 :           break;
     294                 :            : 
     295                 :            :         default:
     296                 :            :           break;
     297                 :            :         }
     298                 :            :     }
     299                 :     181060 :   else if (idx == 7 && JUMP_P (in_rtx) && JUMP_LABEL (in_rtx) != NULL
     300                 :      22565 :            && !m_compact)
     301                 :            :     {
     302                 :            :       /* Output the JUMP_LABEL reference.  */
     303                 :      22565 :       fprintf (m_outfile, "\n%s%*s -> ", print_rtx_head, m_indent * 2, "");
     304                 :      22565 :       if (GET_CODE (JUMP_LABEL (in_rtx)) == RETURN)
     305                 :          0 :         fprintf (m_outfile, "return");
     306                 :      22565 :       else if (GET_CODE (JUMP_LABEL (in_rtx)) == SIMPLE_RETURN)
     307                 :       5103 :         fprintf (m_outfile, "simple_return");
     308                 :            :       else
     309                 :      17462 :         fprintf (m_outfile, "%d", INSN_UID (JUMP_LABEL (in_rtx)));
     310                 :            :     }
     311                 :     158495 :   else if (idx == 0 && GET_CODE (in_rtx) == VALUE)
     312                 :            :     {
     313                 :       1520 :       cselib_val *val = CSELIB_VAL_PTR (in_rtx);
     314                 :            : 
     315                 :       1520 :       fprintf (m_outfile, " %u:%u", val->uid, val->hash);
     316                 :       1520 :       dump_addr (m_outfile, " @", in_rtx);
     317                 :       1520 :       dump_addr (m_outfile, "/", (void*)val);
     318                 :            :     }
     319                 :     156975 :   else if (idx == 0 && GET_CODE (in_rtx) == DEBUG_EXPR)
     320                 :            :     {
     321                 :       3252 :       fprintf (m_outfile, " D#%i",
     322                 :       1626 :                DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (in_rtx)));
     323                 :            :     }
     324                 :     155349 :   else if (idx == 0 && GET_CODE (in_rtx) == ENTRY_VALUE)
     325                 :            :     {
     326                 :        260 :       m_indent += 2;
     327                 :        260 :       if (!m_sawclose)
     328                 :        260 :         fprintf (m_outfile, " ");
     329                 :        260 :       print_rtx (ENTRY_VALUE_EXP (in_rtx));
     330                 :        260 :       m_indent -= 2;
     331                 :            :     }
     332                 :            : #endif
     333                 :     288641 : }
     334                 :            : 
     335                 :            : /* Subroutine of print_rtx_operand for handling code 'e'.
     336                 :            :    Also called by print_rtx_operand_code_u for handling code 'u'
     337                 :            :    for LABEL_REFs when they don't reference a CODE_LABEL.  */
     338                 :            : 
     339                 :            : void
     340                 :    1395260 : rtx_writer::print_rtx_operand_code_e (const_rtx in_rtx, int idx)
     341                 :            : {
     342                 :    1395260 :   m_indent += 2;
     343                 :    1395260 :   if (idx == 6 && INSN_P (in_rtx))
     344                 :            :     /* Put REG_NOTES on their own line.  */
     345                 :     178113 :     fprintf (m_outfile, "\n%s%*s",
     346                 :            :              print_rtx_head, m_indent * 2, "");
     347                 :    1395260 :   if (!m_sawclose)
     348                 :     940113 :     fprintf (m_outfile, " ");
     349                 :    1395260 :   if (idx == 7 && CALL_P (in_rtx))
     350                 :            :     {
     351                 :      11192 :       m_in_call_function_usage = true;
     352                 :      11192 :       print_rtx (XEXP (in_rtx, idx));
     353                 :      11192 :       m_in_call_function_usage = false;
     354                 :            :     }
     355                 :            :   else
     356                 :    1384070 :     print_rtx (XEXP (in_rtx, idx));
     357                 :    1395260 :   m_indent -= 2;
     358                 :    1395260 : }
     359                 :            : 
     360                 :            : /* Subroutine of print_rtx_operand for handling codes 'E' and 'V'.  */
     361                 :            : 
     362                 :            : void
     363                 :      28333 : rtx_writer::print_rtx_operand_codes_E_and_V (const_rtx in_rtx, int idx)
     364                 :            : {
     365                 :      28333 :   m_indent += 2;
     366                 :      28333 :   if (m_sawclose)
     367                 :            :     {
     368                 :         58 :       fprintf (m_outfile, "\n%s%*s",
     369                 :            :       print_rtx_head, m_indent * 2, "");
     370                 :         58 :       m_sawclose = 0;
     371                 :            :     }
     372                 :      28333 :   fputs (" [", m_outfile);
     373                 :      28333 :   if (XVEC (in_rtx, idx) != NULL)
     374                 :            :     {
     375                 :      28333 :       m_indent += 2;
     376                 :      28333 :       if (XVECLEN (in_rtx, idx))
     377                 :      28282 :         m_sawclose = 1;
     378                 :            : 
     379                 :      88882 :       for (int j = 0; j < XVECLEN (in_rtx, idx); j++)
     380                 :            :         {
     381                 :      60549 :           int j1;
     382                 :            : 
     383                 :      60549 :           print_rtx (XVECEXP (in_rtx, idx, j));
     384                 :      61655 :           for (j1 = j + 1; j1 < XVECLEN (in_rtx, idx); j1++)
     385                 :      33373 :             if (XVECEXP (in_rtx, idx, j) != XVECEXP (in_rtx, idx, j1))
     386                 :            :               break;
     387                 :            : 
     388                 :      60549 :           if (j1 != j + 1)
     389                 :            :             {
     390                 :        308 :               fprintf (m_outfile, " repeated x%i", j1 - j);
     391                 :        308 :               j = j1 - 1;
     392                 :            :             }
     393                 :            :         }
     394                 :            : 
     395                 :      28333 :       m_indent -= 2;
     396                 :            :     }
     397                 :      28333 :   if (m_sawclose)
     398                 :      28282 :     fprintf (m_outfile, "\n%s%*s", print_rtx_head, m_indent * 2, "");
     399                 :            : 
     400                 :      28333 :   fputs ("]", m_outfile);
     401                 :      28333 :   m_sawclose = 1;
     402                 :      28333 :   m_indent -= 2;
     403                 :      28333 : }
     404                 :            : 
     405                 :            : /* Subroutine of print_rtx_operand for handling code 'i'.  */
     406                 :            : 
     407                 :            : void
     408                 :     465752 : rtx_writer::print_rtx_operand_code_i (const_rtx in_rtx, int idx)
     409                 :            : {
     410                 :     465752 :   if (idx == 4 && INSN_P (in_rtx))
     411                 :            :     {
     412                 :            : #ifndef GENERATOR_FILE
     413                 :     178125 :       const rtx_insn *in_insn = as_a <const rtx_insn *> (in_rtx);
     414                 :            : 
     415                 :            :       /*  Pretty-print insn locations.  Ignore scoping as it is mostly
     416                 :            :           redundant with line number information and do not print anything
     417                 :            :           when there is no location information available.  */
     418                 :     289177 :       if (INSN_HAS_LOCATION (in_insn))
     419                 :            :         {
     420                 :     145484 :           expanded_location xloc = insn_location (in_insn);
     421                 :     145484 :           fprintf (m_outfile, " \"%s\":%i:%i", xloc.file, xloc.line,
     422                 :            :                    xloc.column);
     423                 :            :         }
     424                 :            : #endif
     425                 :            :     }
     426                 :     287627 :   else if (idx == 6 && GET_CODE (in_rtx) == ASM_OPERANDS)
     427                 :            :     {
     428                 :            : #ifndef GENERATOR_FILE
     429                 :         29 :       if (ASM_OPERANDS_SOURCE_LOCATION (in_rtx) != UNKNOWN_LOCATION)
     430                 :         29 :         fprintf (m_outfile, " %s:%i",
     431                 :         29 :                  LOCATION_FILE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)),
     432                 :         58 :                  LOCATION_LINE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)));
     433                 :            : #endif
     434                 :            :     }
     435                 :     287598 :   else if (idx == 1 && GET_CODE (in_rtx) == ASM_INPUT)
     436                 :            :     {
     437                 :            : #ifndef GENERATOR_FILE
     438                 :         24 :       if (ASM_INPUT_SOURCE_LOCATION (in_rtx) != UNKNOWN_LOCATION)
     439                 :         24 :         fprintf (m_outfile, " %s:%i",
     440                 :         24 :                  LOCATION_FILE (ASM_INPUT_SOURCE_LOCATION (in_rtx)),
     441                 :         48 :                  LOCATION_LINE (ASM_INPUT_SOURCE_LOCATION (in_rtx)));
     442                 :            : #endif
     443                 :            :     }
     444                 :     287574 :   else if (idx == 5 && NOTE_P (in_rtx))
     445                 :            :     {
     446                 :            :       /* This field is only used for NOTE_INSN_DELETED_LABEL, and
     447                 :            :          other times often contains garbage from INSN->NOTE death.  */
     448                 :      78955 :       if (NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_LABEL
     449                 :      78955 :           || NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_DEBUG_LABEL)
     450                 :          8 :         fprintf (m_outfile, " %d",  XINT (in_rtx, idx));
     451                 :            :     }
     452                 :            : #if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
     453                 :     208619 :   else if (idx == 1
     454                 :       1466 :            && GET_CODE (in_rtx) == UNSPEC_VOLATILE
     455                 :        213 :            && XINT (in_rtx, 1) >= 0
     456                 :        213 :            && XINT (in_rtx, 1) < NUM_UNSPECV_VALUES)
     457                 :        213 :     fprintf (m_outfile, " %s", unspecv_strings[XINT (in_rtx, 1)]);
     458                 :            : #endif
     459                 :            : #if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
     460                 :     208406 :   else if (idx == 1
     461                 :       1253 :            && (GET_CODE (in_rtx) == UNSPEC
     462                 :       1253 :                || GET_CODE (in_rtx) == UNSPEC_VOLATILE)
     463                 :       1253 :            && XINT (in_rtx, 1) >= 0
     464                 :       1253 :            && XINT (in_rtx, 1) < NUM_UNSPEC_VALUES)
     465                 :       1253 :     fprintf (m_outfile, " %s", unspec_strings[XINT (in_rtx, 1)]);
     466                 :            : #endif
     467                 :            :   else
     468                 :            :     {
     469                 :     207153 :       int value = XINT (in_rtx, idx);
     470                 :     207153 :       const char *name;
     471                 :     207153 :       int is_insn = INSN_P (in_rtx);
     472                 :            : 
     473                 :            :       /* Don't print INSN_CODEs in compact mode.  */
     474                 :     207153 :       if (m_compact && is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, idx))
     475                 :            :         {
     476                 :         12 :           m_sawclose = 0;
     477                 :         12 :           return;
     478                 :            :         }
     479                 :            : 
     480                 :     207141 :       if (flag_dump_unnumbered
     481                 :      86862 :           && (is_insn || NOTE_P (in_rtx)))
     482                 :      74909 :         fputc ('#', m_outfile);
     483                 :            :       else
     484                 :     132232 :         fprintf (m_outfile, " %d", value);
     485                 :            : 
     486                 :     178113 :       if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, idx)
     487                 :     178113 :           && XINT (in_rtx, idx) >= 0
     488                 :     364267 :           && (name = get_insn_name (XINT (in_rtx, idx))) != NULL)
     489                 :     157126 :         fprintf (m_outfile, " {%s}", name);
     490                 :     207141 :       m_sawclose = 0;
     491                 :            :     }
     492                 :            : }
     493                 :            : 
     494                 :            : /* Subroutine of print_rtx_operand for handling code 'r'.  */
     495                 :            : 
     496                 :            : void
     497                 :     442527 : rtx_writer::print_rtx_operand_code_r (const_rtx in_rtx)
     498                 :            : {
     499                 :     442527 :   int is_insn = INSN_P (in_rtx);
     500                 :     442527 :   unsigned int regno = REGNO (in_rtx);
     501                 :            : 
     502                 :            : #ifndef GENERATOR_FILE
     503                 :            :   /* For hard registers and virtuals, always print the
     504                 :            :      regno, except in compact mode.  */
     505                 :     442527 :   if (regno <= LAST_VIRTUAL_REGISTER && !m_compact)
     506                 :     344401 :     fprintf (m_outfile, " %d", regno);
     507                 :     442527 :   if (regno < FIRST_PSEUDO_REGISTER)
     508                 :     344050 :     fprintf (m_outfile, " %s", reg_names[regno]);
     509                 :      98477 :   else if (regno <= LAST_VIRTUAL_REGISTER)
     510                 :            :     {
     511                 :        373 :       if (regno == VIRTUAL_INCOMING_ARGS_REGNUM)
     512                 :          2 :         fprintf (m_outfile, " virtual-incoming-args");
     513                 :        371 :       else if (regno == VIRTUAL_STACK_VARS_REGNUM)
     514                 :        318 :         fprintf (m_outfile, " virtual-stack-vars");
     515                 :         53 :       else if (regno == VIRTUAL_STACK_DYNAMIC_REGNUM)
     516                 :         11 :         fprintf (m_outfile, " virtual-stack-dynamic");
     517                 :         42 :       else if (regno == VIRTUAL_OUTGOING_ARGS_REGNUM)
     518                 :          2 :         fprintf (m_outfile, " virtual-outgoing-args");
     519                 :         40 :       else if (regno == VIRTUAL_CFA_REGNUM)
     520                 :          2 :         fprintf (m_outfile, " virtual-cfa");
     521                 :         38 :       else if (regno == VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM)
     522                 :         38 :         fprintf (m_outfile, " virtual-preferred-stack-boundary");
     523                 :            :       else
     524                 :            :         fprintf (m_outfile, " virtual-reg-%d", regno-FIRST_VIRTUAL_REGISTER);
     525                 :            :     }
     526                 :            :   else
     527                 :            : #endif
     528                 :      98104 :     if (flag_dump_unnumbered && is_insn)
     529                 :          0 :       fputc ('#', m_outfile);
     530                 :      98104 :     else if (m_compact)
     531                 :            :       {
     532                 :            :         /* In compact mode, print pseudos with '< and '>' wrapping the regno,
     533                 :            :            offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
     534                 :            :            first non-virtual pseudo is dumped as "<0>".  */
     535                 :         12 :         gcc_assert (regno > LAST_VIRTUAL_REGISTER);
     536                 :         12 :         fprintf (m_outfile, " <%d>", regno - (LAST_VIRTUAL_REGISTER + 1));
     537                 :            :       }
     538                 :            :     else
     539                 :      98092 :       fprintf (m_outfile, " %d", regno);
     540                 :            : 
     541                 :            : #ifndef GENERATOR_FILE
     542                 :     442527 :   if (REG_ATTRS (in_rtx))
     543                 :            :     {
     544                 :     175559 :       fputs (" [", m_outfile);
     545                 :     175559 :       if (regno != ORIGINAL_REGNO (in_rtx))
     546                 :      87768 :         fprintf (m_outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
     547                 :     175559 :       if (REG_EXPR (in_rtx))
     548                 :     175202 :         print_mem_expr (m_outfile, REG_EXPR (in_rtx));
     549                 :            : 
     550                 :     175559 :       if (maybe_ne (REG_OFFSET (in_rtx), 0))
     551                 :            :         {
     552                 :        939 :           fprintf (m_outfile, "+");
     553                 :        939 :           print_poly_int (m_outfile, REG_OFFSET (in_rtx));
     554                 :            :         }
     555                 :     175559 :       fputs (" ]", m_outfile);
     556                 :            :     }
     557                 :     442527 :   if (regno != ORIGINAL_REGNO (in_rtx))
     558                 :     129453 :     fprintf (m_outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
     559                 :            : #endif
     560                 :     442527 : }
     561                 :            : 
     562                 :            : /* Subroutine of print_rtx_operand for handling code 'u'.  */
     563                 :            : 
     564                 :            : void
     565                 :     586990 : rtx_writer::print_rtx_operand_code_u (const_rtx in_rtx, int idx)
     566                 :            : {
     567                 :            :   /* Don't print insn UIDs for PREV/NEXT_INSN in compact mode.  */
     568                 :     586990 :   if (m_compact && INSN_CHAIN_CODE_P (GET_CODE (in_rtx)) && idx < 2)
     569                 :            :     return;
     570                 :            : 
     571                 :     586942 :   if (XEXP (in_rtx, idx) != NULL)
     572                 :            :     {
     573                 :     326811 :       rtx sub = XEXP (in_rtx, idx);
     574                 :     326811 :       enum rtx_code subc = GET_CODE (sub);
     575                 :            : 
     576                 :     326811 :       if (GET_CODE (in_rtx) == LABEL_REF)
     577                 :            :         {
     578                 :      18816 :           if (subc == NOTE
     579                 :          0 :               && NOTE_KIND (sub) == NOTE_INSN_DELETED_LABEL)
     580                 :            :             {
     581                 :          0 :               if (flag_dump_unnumbered)
     582                 :          0 :                 fprintf (m_outfile, " [# deleted]");
     583                 :            :               else
     584                 :          0 :                 fprintf (m_outfile, " [%d deleted]", INSN_UID (sub));
     585                 :          0 :               m_sawclose = 0;
     586                 :          0 :               return;
     587                 :            :             }
     588                 :            : 
     589                 :      18816 :           if (subc != CODE_LABEL)
     590                 :            :             {
     591                 :          0 :               print_rtx_operand_code_e (in_rtx, idx);
     592                 :          0 :               return;
     593                 :            :             }
     594                 :            :         }
     595                 :            : 
     596                 :     326811 :       if (flag_dump_unnumbered
     597                 :     318605 :           || (flag_dump_unnumbered_links && idx <= 1
     598                 :          0 :               && (INSN_P (in_rtx) || NOTE_P (in_rtx)
     599                 :          0 :                   || LABEL_P (in_rtx) || BARRIER_P (in_rtx))))
     600                 :       8206 :         fputs (" #", m_outfile);
     601                 :            :       else
     602                 :     318605 :         fprintf (m_outfile, " %d", INSN_UID (sub));
     603                 :            :     }
     604                 :            :   else
     605                 :     260131 :     fputs (" 0", m_outfile);
     606                 :     586942 :   m_sawclose = 0;
     607                 :            : }
     608                 :            : 
     609                 :            : /* Subroutine of print_rtx.   Print operand IDX of IN_RTX.  */
     610                 :            : 
     611                 :            : void
     612                 :    3729810 : rtx_writer::print_rtx_operand (const_rtx in_rtx, int idx)
     613                 :            : {
     614                 :    3729810 :   const char *format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
     615                 :            : 
     616                 :    3729810 :   switch (format_ptr[idx])
     617                 :            :     {
     618                 :          0 :       const char *str;
     619                 :            : 
     620                 :          0 :     case 'T':
     621                 :          0 :       str = XTMPL (in_rtx, idx);
     622                 :          0 :       goto string;
     623                 :            : 
     624                 :      45397 :     case 'S':
     625                 :      45397 :     case 's':
     626                 :      45397 :       str = XSTR (in_rtx, idx);
     627                 :      45397 :     string:
     628                 :            : 
     629                 :      45397 :       if (str == 0)
     630                 :      16549 :         fputs (" (nil)", m_outfile);
     631                 :            :       else
     632                 :      28848 :         fprintf (m_outfile, " (\"%s\")", str);
     633                 :      45397 :       m_sawclose = 1;
     634                 :      45397 :       break;
     635                 :            : 
     636                 :     288641 :     case '0':
     637                 :     288641 :       print_rtx_operand_code_0 (in_rtx, idx);
     638                 :     288641 :       break;
     639                 :            : 
     640                 :    1395260 :     case 'e':
     641                 :    1395260 :       print_rtx_operand_code_e (in_rtx, idx);
     642                 :    1395260 :       break;
     643                 :            : 
     644                 :      28333 :     case 'E':
     645                 :      28333 :     case 'V':
     646                 :      28333 :       print_rtx_operand_codes_E_and_V (in_rtx, idx);
     647                 :      28333 :       break;
     648                 :            : 
     649                 :     122028 :     case 'w':
     650                 :     122028 :       if (! m_simple)
     651                 :     122028 :         fprintf (m_outfile, " ");
     652                 :     122028 :       fprintf (m_outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, idx));
     653                 :     122028 :       if (! m_simple && !m_compact)
     654                 :     122018 :         fprintf (m_outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
     655                 :     122018 :                  (unsigned HOST_WIDE_INT) XWINT (in_rtx, idx));
     656                 :            :       break;
     657                 :            : 
     658                 :     465752 :     case 'i':
     659                 :     465752 :       print_rtx_operand_code_i (in_rtx, idx);
     660                 :     465752 :       break;
     661                 :            : 
     662                 :       1993 :     case 'p':
     663                 :       1993 :       fprintf (m_outfile, " ");
     664                 :       1993 :       print_poly_int (m_outfile, SUBREG_BYTE (in_rtx));
     665                 :       1993 :       break;
     666                 :            : 
     667                 :     442527 :     case 'r':
     668                 :     442527 :       print_rtx_operand_code_r (in_rtx);
     669                 :     442527 :       break;
     670                 :            : 
     671                 :            :     /* Print NOTE_INSN names rather than integer codes.  */
     672                 :            : 
     673                 :      78955 :     case 'n':
     674                 :      78955 :       fprintf (m_outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, idx)));
     675                 :      78955 :       m_sawclose = 0;
     676                 :      78955 :       break;
     677                 :            : 
     678                 :     586990 :     case 'u':
     679                 :     586990 :       print_rtx_operand_code_u (in_rtx, idx);
     680                 :     586990 :       break;
     681                 :            : 
     682                 :          0 :     case 't':
     683                 :            : #ifndef GENERATOR_FILE
     684                 :          0 :       if (idx == 0 && GET_CODE (in_rtx) == DEBUG_IMPLICIT_PTR)
     685                 :          0 :         print_mem_expr (m_outfile, DEBUG_IMPLICIT_PTR_DECL (in_rtx));
     686                 :          0 :       else if (idx == 0 && GET_CODE (in_rtx) == DEBUG_PARAMETER_REF)
     687                 :          0 :         print_mem_expr (m_outfile, DEBUG_PARAMETER_REF_DECL (in_rtx));
     688                 :            :       else
     689                 :          0 :         dump_addr (m_outfile, " ", XTREE (in_rtx, idx));
     690                 :            : #endif
     691                 :            :       break;
     692                 :            : 
     693                 :          0 :     case '*':
     694                 :          0 :       fputs (" Unknown", m_outfile);
     695                 :          0 :       m_sawclose = 0;
     696                 :          0 :       break;
     697                 :            : 
     698                 :     273933 :     case 'B':
     699                 :            :       /* Don't print basic block ids in compact mode.  */
     700                 :     273933 :       if (m_compact)
     701                 :            :         break;
     702                 :            : #ifndef GENERATOR_FILE
     703                 :     273911 :       if (XBBDEF (in_rtx, idx))
     704                 :     230070 :         fprintf (m_outfile, " %i", XBBDEF (in_rtx, idx)->index);
     705                 :            : #endif
     706                 :            :       break;
     707                 :            : 
     708                 :          0 :     default:
     709                 :          0 :       gcc_unreachable ();
     710                 :            :     }
     711                 :    3729810 : }
     712                 :            : 
     713                 :            : /* Subroutine of rtx_writer::print_rtx.
     714                 :            :    In compact mode, determine if operand IDX of IN_RTX is interesting
     715                 :            :    to dump, or (if in a trailing position) it can be omitted.  */
     716                 :            : 
     717                 :            : bool
     718                 :        112 : rtx_writer::operand_has_default_value_p (const_rtx in_rtx, int idx)
     719                 :            : {
     720                 :        112 :   const char *format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
     721                 :            : 
     722                 :        112 :   switch (format_ptr[idx])
     723                 :            :     {
     724                 :         30 :     case 'e':
     725                 :         30 :     case 'u':
     726                 :         30 :       return XEXP (in_rtx, idx) == NULL_RTX;
     727                 :            : 
     728                 :          4 :     case 's':
     729                 :          4 :       return XSTR (in_rtx, idx) == NULL;
     730                 :            : 
     731                 :          8 :     case '0':
     732                 :          8 :       switch (GET_CODE (in_rtx))
     733                 :            :         {
     734                 :          2 :         case JUMP_INSN:
     735                 :            :           /* JUMP_LABELs are always omitted in compact mode, so treat
     736                 :            :              any value here as omittable, so that earlier operands can
     737                 :            :              potentially be omitted also.  */
     738                 :          2 :           return m_compact;
     739                 :            : 
     740                 :            :         default:
     741                 :            :           return false;
     742                 :            : 
     743                 :            :         }
     744                 :            : 
     745                 :            :     default:
     746                 :            :       return false;
     747                 :            :     }
     748                 :            : }
     749                 :            : 
     750                 :            : /* Print IN_RTX onto m_outfile.  This is the recursive part of printing.  */
     751                 :            : 
     752                 :            : void
     753                 :    1753950 : rtx_writer::print_rtx (const_rtx in_rtx)
     754                 :            : {
     755                 :    1753950 :   int idx = 0;
     756                 :            : 
     757                 :    1753950 :   if (m_sawclose)
     758                 :            :     {
     759                 :     515892 :       if (m_simple)
     760                 :          0 :         fputc (' ', m_outfile);
     761                 :            :       else
     762                 :     515892 :         fprintf (m_outfile, "\n%s%*s", print_rtx_head, m_indent * 2, "");
     763                 :     515892 :       m_sawclose = 0;
     764                 :            :     }
     765                 :            : 
     766                 :    1753950 :   if (in_rtx == 0)
     767                 :            :     {
     768                 :     190785 :       fputs ("(nil)", m_outfile);
     769                 :     190785 :       m_sawclose = 1;
     770                 :     190785 :       return;
     771                 :            :     }
     772                 :    1563160 :   else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
     773                 :            :     {
     774                 :          0 :        fprintf (m_outfile, "(??? bad code %d\n%s%*s)", GET_CODE (in_rtx),
     775                 :          0 :                 print_rtx_head, m_indent * 2, "");
     776                 :          0 :        m_sawclose = 1;
     777                 :          0 :        return;
     778                 :            :     }
     779                 :            : 
     780                 :    1563160 :   fputc ('(', m_outfile);
     781                 :            : 
     782                 :            :   /* Print name of expression code.  */
     783                 :            : 
     784                 :            :   /* Handle reuse.  */
     785                 :            : #ifndef GENERATOR_FILE
     786                 :    1563160 :   if (m_rtx_reuse_manager)
     787                 :            :     {
     788                 :         66 :       int reuse_id;
     789                 :         66 :       if (m_rtx_reuse_manager->has_reuse_id (in_rtx, &reuse_id))
     790                 :            :         {
     791                 :            :           /* Have we already seen the defn of this rtx?  */
     792                 :         16 :           if (m_rtx_reuse_manager->seen_def_p (reuse_id))
     793                 :            :             {
     794                 :         10 :               fprintf (m_outfile, "reuse_rtx %i)", reuse_id);
     795                 :         10 :               m_sawclose = 1;
     796                 :         10 :               return;
     797                 :            :             }
     798                 :            :           else
     799                 :            :             {
     800                 :            :               /* First time we've seen this reused-rtx.  */
     801                 :          6 :               fprintf (m_outfile, "%i|", reuse_id);
     802                 :          6 :               m_rtx_reuse_manager->set_seen_def (reuse_id);
     803                 :            :             }
     804                 :            :         }
     805                 :            :     }
     806                 :            : #endif /* #ifndef GENERATOR_FILE */
     807                 :            : 
     808                 :            :   /* In compact mode, prefix the code of insns with "c",
     809                 :            :      giving "cinsn", "cnote" etc.  */
     810                 :    1563150 :   if (m_compact && is_a <const rtx_insn *, const struct rtx_def> (in_rtx))
     811                 :            :     {
     812                 :            :       /* "ccode_label" is slightly awkward, so special-case it as
     813                 :            :          just "clabel".  */
     814                 :         24 :       rtx_code code = GET_CODE (in_rtx);
     815                 :         24 :       if (code == CODE_LABEL)
     816                 :          4 :         fprintf (m_outfile, "clabel");
     817                 :            :       else
     818                 :         20 :         fprintf (m_outfile, "c%s", GET_RTX_NAME (code));
     819                 :            :     }
     820                 :    1563130 :   else if (m_simple && CONST_INT_P (in_rtx))
     821                 :            :     ; /* no code.  */
     822                 :            :   else
     823                 :    1563130 :     fprintf (m_outfile, "%s", GET_RTX_NAME (GET_CODE (in_rtx)));
     824                 :            : 
     825                 :    1563150 :   if (! m_simple)
     826                 :            :     {
     827                 :    1561860 :       if (RTX_FLAG (in_rtx, in_struct))
     828                 :        157 :         fputs ("/s", m_outfile);
     829                 :            : 
     830                 :    1561860 :       if (RTX_FLAG (in_rtx, volatil))
     831                 :      55739 :         fputs ("/v", m_outfile);
     832                 :            : 
     833                 :    1561860 :       if (RTX_FLAG (in_rtx, unchanging))
     834                 :       3547 :         fputs ("/u", m_outfile);
     835                 :            : 
     836                 :    1561860 :       if (RTX_FLAG (in_rtx, frame_related))
     837                 :     120135 :         fputs ("/f", m_outfile);
     838                 :            : 
     839                 :    1561860 :       if (RTX_FLAG (in_rtx, jump))
     840                 :        912 :         fputs ("/j", m_outfile);
     841                 :            : 
     842                 :    1561860 :       if (RTX_FLAG (in_rtx, call))
     843                 :      22776 :         fputs ("/c", m_outfile);
     844                 :            : 
     845                 :    1561860 :       if (RTX_FLAG (in_rtx, return_val))
     846                 :       9824 :         fputs ("/i", m_outfile);
     847                 :            : 
     848                 :            :       /* Print REG_NOTE names for EXPR_LIST and INSN_LIST.  */
     849                 :    1561860 :       if ((GET_CODE (in_rtx) == EXPR_LIST
     850                 :            :            || GET_CODE (in_rtx) == INSN_LIST
     851                 :    1561860 :            || GET_CODE (in_rtx) == INT_LIST)
     852                 :     136695 :           && (int)GET_MODE (in_rtx) < REG_NOTE_MAX
     853                 :     134687 :           && !m_in_call_function_usage)
     854                 :     118617 :         fprintf (m_outfile, ":%s",
     855                 :     118617 :                  GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
     856                 :            : 
     857                 :            :       /* For other rtl, print the mode if it's not VOID.  */
     858                 :    1443250 :       else if (GET_MODE (in_rtx) != VOIDmode)
     859                 :     739501 :         fprintf (m_outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
     860                 :            : 
     861                 :            : #ifndef GENERATOR_FILE
     862                 :    1561860 :       if (GET_CODE (in_rtx) == VAR_LOCATION)
     863                 :            :         {
     864                 :       5740 :           if (TREE_CODE (PAT_VAR_LOCATION_DECL (in_rtx)) == STRING_CST)
     865                 :          0 :             fputs (" <debug string placeholder>", m_outfile);
     866                 :            :           else
     867                 :       5740 :             print_mem_expr (m_outfile, PAT_VAR_LOCATION_DECL (in_rtx));
     868                 :       5740 :           fputc (' ', m_outfile);
     869                 :       5740 :           print_rtx (PAT_VAR_LOCATION_LOC (in_rtx));
     870                 :       5740 :           if (PAT_VAR_LOCATION_STATUS (in_rtx)
     871                 :            :               == VAR_INIT_STATUS_UNINITIALIZED)
     872                 :          0 :             fprintf (m_outfile, " [uninit]");
     873                 :       5740 :           m_sawclose = 1;
     874                 :       5740 :           idx = GET_RTX_LENGTH (VAR_LOCATION);
     875                 :            :         }
     876                 :            : #endif
     877                 :            :     }
     878                 :            : 
     879                 :            : #ifndef GENERATOR_FILE
     880                 :    1563150 :   if (CONST_DOUBLE_AS_FLOAT_P (in_rtx))
     881                 :        122 :     idx = 5;
     882                 :            : #endif
     883                 :            : 
     884                 :            :   /* For insns, print the INSN_UID.  */
     885                 :    1563150 :   if (INSN_CHAIN_CODE_P (GET_CODE (in_rtx)))
     886                 :            :     {
     887                 :     283959 :       if (flag_dump_unnumbered)
     888                 :     126254 :         fprintf (m_outfile, " #");
     889                 :            :       else
     890                 :     157705 :         fprintf (m_outfile, " %d", INSN_UID (in_rtx));
     891                 :            :     }
     892                 :            : 
     893                 :            :   /* Determine which is the final operand to print.
     894                 :            :      In compact mode, skip trailing operands that have the default values
     895                 :            :      e.g. trailing "(nil)" values.  */
     896                 :    1563150 :   int limit = GET_RTX_LENGTH (GET_CODE (in_rtx));
     897                 :    1563150 :   if (m_compact)
     898                 :        124 :     while (limit > idx && operand_has_default_value_p (in_rtx, limit - 1))
     899                 :            :       limit--;
     900                 :            : 
     901                 :            :   /* Get the format string and skip the first elements if we have handled
     902                 :            :      them already.  */
     903                 :            : 
     904                 :    5292960 :   for (; idx < limit; idx++)
     905                 :    3729810 :     print_rtx_operand (in_rtx, idx);
     906                 :            : 
     907                 :    1563150 :   switch (GET_CODE (in_rtx))
     908                 :            :     {
     909                 :            : #ifndef GENERATOR_FILE
     910                 :      70869 :     case MEM:
     911                 :      70869 :       if (__builtin_expect (final_insns_dump_p, false))
     912                 :      38462 :         fprintf (m_outfile, " [");
     913                 :            :       else
     914                 :      32407 :         fprintf (m_outfile, " [" HOST_WIDE_INT_PRINT_DEC,
     915                 :      32407 :                  (HOST_WIDE_INT) MEM_ALIAS_SET (in_rtx));
     916                 :            : 
     917                 :      85200 :       if (MEM_EXPR (in_rtx))
     918                 :      55475 :         print_mem_expr (m_outfile, MEM_EXPR (in_rtx));
     919                 :            :       else
     920                 :      15394 :         fputc (' ', m_outfile);
     921                 :            : 
     922                 :      85200 :       if (MEM_OFFSET_KNOWN_P (in_rtx))
     923                 :            :         {
     924                 :      43135 :           fprintf (m_outfile, "+");
     925                 :      43135 :           print_poly_int (m_outfile, MEM_OFFSET (in_rtx));
     926                 :            :         }
     927                 :            : 
     928                 :      85200 :       if (MEM_SIZE_KNOWN_P (in_rtx))
     929                 :            :         {
     930                 :      65669 :           fprintf (m_outfile, " S");
     931                 :      74803 :           print_poly_int (m_outfile, MEM_SIZE (in_rtx));
     932                 :            :         }
     933                 :            : 
     934                 :      85200 :       if (MEM_ALIGN (in_rtx) != 1)
     935                 :      70869 :         fprintf (m_outfile, " A%u", MEM_ALIGN (in_rtx));
     936                 :            : 
     937                 :      85200 :       if (!ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (in_rtx)))
     938                 :         64 :         fprintf (m_outfile, " AS%u", MEM_ADDR_SPACE (in_rtx));
     939                 :            : 
     940                 :      70869 :       fputc (']', m_outfile);
     941                 :      70869 :       break;
     942                 :            : 
     943                 :        122 :     case CONST_DOUBLE:
     944                 :        122 :       if (FLOAT_MODE_P (GET_MODE (in_rtx)))
     945                 :            :         {
     946                 :        122 :           char s[60];
     947                 :            : 
     948                 :        122 :           real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
     949                 :            :                            sizeof (s), 0, 1);
     950                 :        122 :           fprintf (m_outfile, " %s", s);
     951                 :            : 
     952                 :        122 :           real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
     953                 :            :                                sizeof (s), 0, 1);
     954                 :        122 :           fprintf (m_outfile, " [%s]", s);
     955                 :            :         }
     956                 :            :       break;
     957                 :            : 
     958                 :          4 :     case CONST_WIDE_INT:
     959                 :          4 :       fprintf (m_outfile, " ");
     960                 :          4 :       cwi_output_hex (m_outfile, in_rtx);
     961                 :          4 :       break;
     962                 :            : 
     963                 :          0 :     case CONST_POLY_INT:
     964                 :          0 :       fprintf (m_outfile, " [");
     965                 :          0 :       print_dec (CONST_POLY_INT_COEFFS (in_rtx)[0], m_outfile, SIGNED);
     966                 :          0 :       for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
     967                 :            :         {
     968                 :            :           fprintf (m_outfile, ", ");
     969                 :            :           print_dec (CONST_POLY_INT_COEFFS (in_rtx)[i], m_outfile, SIGNED);
     970                 :            :         }
     971                 :          0 :       fprintf (m_outfile, "]");
     972                 :          0 :       break;
     973                 :            : #endif
     974                 :            : 
     975                 :      16691 :     case CODE_LABEL:
     976                 :      16691 :       if (!m_compact)
     977                 :      16687 :         fprintf (m_outfile, " [%d uses]", LABEL_NUSES (in_rtx));
     978                 :      16691 :       switch (LABEL_KIND (in_rtx))
     979                 :            :         {
     980                 :            :           case LABEL_NORMAL: break;
     981                 :          0 :           case LABEL_STATIC_ENTRY: fputs (" [entry]", m_outfile); break;
     982                 :          0 :           case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", m_outfile); break;
     983                 :          0 :           case LABEL_WEAK_ENTRY: fputs (" [weak entry]", m_outfile); break;
     984                 :            :           default: gcc_unreachable ();
     985                 :            :         }
     986                 :            :       break;
     987                 :            : 
     988                 :            :     default:
     989                 :            :       break;
     990                 :            :     }
     991                 :            : 
     992                 :    1563150 :   fputc (')', m_outfile);
     993                 :    1563150 :   m_sawclose = 1;
     994                 :            : }
     995                 :            : 
     996                 :            : /* Emit a closing parenthesis and newline.  */
     997                 :            : 
     998                 :            : void
     999                 :          0 : rtx_writer::finish_directive ()
    1000                 :            : {
    1001                 :          0 :   fprintf (m_outfile, ")\n");
    1002                 :          0 :   m_sawclose = 0;
    1003                 :          0 : }
    1004                 :            : 
    1005                 :            : /* Print an rtx on the current line of FILE.  Initially indent IND
    1006                 :            :    characters.  */
    1007                 :            : 
    1008                 :            : void
    1009                 :       2241 : print_inline_rtx (FILE *outf, const_rtx x, int ind)
    1010                 :            : {
    1011                 :       2241 :   rtx_writer w (outf, ind, false, false, NULL);
    1012                 :       2241 :   w.print_rtx (x);
    1013                 :       2241 : }
    1014                 :            : 
    1015                 :            : /* Call this function from the debugger to see what X looks like.  */
    1016                 :            : 
    1017                 :            : DEBUG_FUNCTION void
    1018                 :          0 : debug_rtx (const_rtx x)
    1019                 :            : {
    1020                 :          0 :   rtx_writer w (stderr, 0, false, false, NULL);
    1021                 :          0 :   w.print_rtx (x);
    1022                 :          0 :   fprintf (stderr, "\n");
    1023                 :          0 : }
    1024                 :            : 
    1025                 :            : /* Dump rtx REF.  */
    1026                 :            : 
    1027                 :            : DEBUG_FUNCTION void
    1028                 :          0 : debug (const rtx_def &ref)
    1029                 :            : {
    1030                 :          0 :   debug_rtx (&ref);
    1031                 :          0 : }
    1032                 :            : 
    1033                 :            : DEBUG_FUNCTION void
    1034                 :          0 : debug (const rtx_def *ptr)
    1035                 :            : {
    1036                 :          0 :   if (ptr)
    1037                 :          0 :     debug (*ptr);
    1038                 :            :   else
    1039                 :          0 :     fprintf (stderr, "<nil>\n");
    1040                 :          0 : }
    1041                 :            : 
    1042                 :            : /* Like debug_rtx but with no newline, as debug_helper will add one.
    1043                 :            : 
    1044                 :            :    Note: No debug_slim(rtx_insn *) variant implemented, as this
    1045                 :            :    function can serve for both rtx and rtx_insn.  */
    1046                 :            : 
    1047                 :            : static void
    1048                 :          0 : debug_slim (const_rtx x)
    1049                 :            : {
    1050                 :          0 :   rtx_writer w (stderr, 0, false, false, NULL);
    1051                 :          0 :   w.print_rtx (x);
    1052                 :          0 : }
    1053                 :            : 
    1054                 :          0 : DEFINE_DEBUG_VEC (rtx_def *)
    1055                 :          0 : DEFINE_DEBUG_VEC (rtx_insn *)
    1056                 :          0 : DEFINE_DEBUG_HASH_SET (rtx_def *)
    1057                 :          0 : DEFINE_DEBUG_HASH_SET (rtx_insn *)
    1058                 :            : 
    1059                 :            : /* Count of rtx's to print with debug_rtx_list.
    1060                 :            :    This global exists because gdb user defined commands have no arguments.  */
    1061                 :            : 
    1062                 :            : DEBUG_VARIABLE int debug_rtx_count = 0; /* 0 is treated as equivalent to 1 */
    1063                 :            : 
    1064                 :            : /* Call this function to print list from X on.
    1065                 :            : 
    1066                 :            :    N is a count of the rtx's to print. Positive values print from the specified
    1067                 :            :    rtx_insn on.  Negative values print a window around the rtx_insn.
    1068                 :            :    EG: -5 prints 2 rtx_insn's on either side (in addition to the specified
    1069                 :            :    rtx_insn).  */
    1070                 :            : 
    1071                 :            : DEBUG_FUNCTION void
    1072                 :          0 : debug_rtx_list (const rtx_insn *x, int n)
    1073                 :            : {
    1074                 :          0 :   int i,count;
    1075                 :          0 :   const rtx_insn *insn;
    1076                 :            : 
    1077                 :          0 :   count = n == 0 ? 1 : n < 0 ? -n : n;
    1078                 :            : 
    1079                 :            :   /* If we are printing a window, back up to the start.  */
    1080                 :            : 
    1081                 :          0 :   if (n < 0)
    1082                 :          0 :     for (i = count / 2; i > 0; i--)
    1083                 :            :       {
    1084                 :          0 :         if (PREV_INSN (x) == 0)
    1085                 :            :           break;
    1086                 :          0 :         x = PREV_INSN (x);
    1087                 :            :       }
    1088                 :            : 
    1089                 :          0 :   for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
    1090                 :            :     {
    1091                 :          0 :       debug_rtx (insn);
    1092                 :          0 :       fprintf (stderr, "\n");
    1093                 :            :     }
    1094                 :          0 : }
    1095                 :            : 
    1096                 :            : /* Call this function to print an rtx_insn list from START to END
    1097                 :            :    inclusive.  */
    1098                 :            : 
    1099                 :            : DEBUG_FUNCTION void
    1100                 :          0 : debug_rtx_range (const rtx_insn *start, const rtx_insn *end)
    1101                 :            : {
    1102                 :          0 :   while (1)
    1103                 :            :     {
    1104                 :          0 :       debug_rtx (start);
    1105                 :          0 :       fprintf (stderr, "\n");
    1106                 :          0 :       if (!start || start == end)
    1107                 :            :         break;
    1108                 :          0 :       start = NEXT_INSN (start);
    1109                 :            :     }
    1110                 :          0 : }
    1111                 :            : 
    1112                 :            : /* Call this function to search an rtx_insn list to find one with insn uid UID,
    1113                 :            :    and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
    1114                 :            :    The found insn is returned to enable further debugging analysis.  */
    1115                 :            : 
    1116                 :            : DEBUG_FUNCTION const rtx_insn *
    1117                 :          0 : debug_rtx_find (const rtx_insn *x, int uid)
    1118                 :            : {
    1119                 :          0 :   while (x != 0 && INSN_UID (x) != uid)
    1120                 :          0 :     x = NEXT_INSN (x);
    1121                 :          0 :   if (x != 0)
    1122                 :            :     {
    1123                 :          0 :       debug_rtx_list (x, debug_rtx_count);
    1124                 :          0 :       return x;
    1125                 :            :     }
    1126                 :            :   else
    1127                 :            :     {
    1128                 :          0 :       fprintf (stderr, "insn uid %d not found\n", uid);
    1129                 :          0 :       return 0;
    1130                 :            :     }
    1131                 :            : }
    1132                 :            : 
    1133                 :            : /* External entry point for printing a chain of insns
    1134                 :            :    starting with RTX_FIRST.
    1135                 :            :    A blank line separates insns.
    1136                 :            : 
    1137                 :            :    If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */
    1138                 :            : 
    1139                 :            : void
    1140                 :       4217 : rtx_writer::print_rtl (const_rtx rtx_first)
    1141                 :            : {
    1142                 :       4217 :   const rtx_insn *tmp_rtx;
    1143                 :            : 
    1144                 :       4217 :   if (rtx_first == 0)
    1145                 :            :     {
    1146                 :          9 :       fputs (print_rtx_head, m_outfile);
    1147                 :          9 :       fputs ("(nil)\n", m_outfile);
    1148                 :            :     }
    1149                 :            :   else
    1150                 :       4208 :     switch (GET_CODE (rtx_first))
    1151                 :            :       {
    1152                 :        173 :       case INSN:
    1153                 :        173 :       case JUMP_INSN:
    1154                 :        173 :       case CALL_INSN:
    1155                 :        173 :       case NOTE:
    1156                 :        173 :       case CODE_LABEL:
    1157                 :        173 :       case JUMP_TABLE_DATA:
    1158                 :        173 :       case BARRIER:
    1159                 :        173 :         for (tmp_rtx = as_a <const rtx_insn *> (rtx_first);
    1160                 :        540 :              tmp_rtx != 0;
    1161                 :        367 :              tmp_rtx = NEXT_INSN (tmp_rtx))
    1162                 :            :           {
    1163                 :        367 :             fputs (print_rtx_head, m_outfile);
    1164                 :        367 :             print_rtx (tmp_rtx);
    1165                 :        367 :             fprintf (m_outfile, "\n");
    1166                 :            :           }
    1167                 :            :         break;
    1168                 :            : 
    1169                 :       4035 :       default:
    1170                 :       4035 :         fputs (print_rtx_head, m_outfile);
    1171                 :       4035 :         print_rtx (rtx_first);
    1172                 :            :       }
    1173                 :       4217 : }
    1174                 :            : 
    1175                 :            : /* External entry point for printing a chain of insns
    1176                 :            :    starting with RTX_FIRST onto file OUTF.
    1177                 :            :    A blank line separates insns.
    1178                 :            : 
    1179                 :            :    If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */
    1180                 :            : 
    1181                 :            : void
    1182                 :       2897 : print_rtl (FILE *outf, const_rtx rtx_first)
    1183                 :            : {
    1184                 :       2897 :   rtx_writer w (outf, 0, false, false, NULL);
    1185                 :       2897 :   w.print_rtl (rtx_first);
    1186                 :       2897 : }
    1187                 :            : 
    1188                 :            : /* Like print_rtx, except specify a file.  */
    1189                 :            : /* Return nonzero if we actually printed anything.  */
    1190                 :            : 
    1191                 :            : int
    1192                 :     283892 : print_rtl_single (FILE *outf, const_rtx x)
    1193                 :            : {
    1194                 :     283892 :   rtx_writer w (outf, 0, false, false, NULL);
    1195                 :     283892 :   return w.print_rtl_single_with_indent (x, 0);
    1196                 :            : }
    1197                 :            : 
    1198                 :            : /* Like print_rtl_single, except specify an indentation.  */
    1199                 :            : 
    1200                 :            : int
    1201                 :     283908 : rtx_writer::print_rtl_single_with_indent (const_rtx x, int ind)
    1202                 :            : {
    1203                 :     283908 :   char *s_indent = (char *) alloca ((size_t) ind + 1);
    1204                 :     283908 :   memset ((void *) s_indent, ' ', (size_t) ind);
    1205                 :     283908 :   s_indent[ind] = '\0';
    1206                 :     283908 :   fputs (s_indent, m_outfile);
    1207                 :     283908 :   fputs (print_rtx_head, m_outfile);
    1208                 :            : 
    1209                 :     283908 :   int old_indent = m_indent;
    1210                 :     283908 :   m_indent = ind;
    1211                 :     283908 :   m_sawclose = 0;
    1212                 :     283908 :   print_rtx (x);
    1213                 :     283908 :   putc ('\n', m_outfile);
    1214                 :     283908 :   m_indent = old_indent;
    1215                 :     283908 :   return 1;
    1216                 :            : }
    1217                 :            : 
    1218                 :            : 
    1219                 :            : /* Like print_rtl except without all the detail; for example,
    1220                 :            :    if RTX is a CONST_INT then print in decimal format.  */
    1221                 :            : 
    1222                 :            : void
    1223                 :       1270 : print_simple_rtl (FILE *outf, const_rtx x)
    1224                 :            : {
    1225                 :       1270 :   rtx_writer w (outf, 0, true, false, NULL);
    1226                 :       1270 :   w.print_rtl (x);
    1227                 :       1270 : }
    1228                 :            : 
    1229                 :            : /* Print the elements of VEC to FILE.  */
    1230                 :            : 
    1231                 :            : void
    1232                 :         36 : print_rtx_insn_vec (FILE *file, const vec<rtx_insn *> &vec)
    1233                 :            : {
    1234                 :         36 :   fputc('{', file);
    1235                 :            : 
    1236                 :         36 :   unsigned int len = vec.length ();
    1237                 :         38 :   for (unsigned int i = 0; i < len; i++)
    1238                 :            :     {
    1239                 :          2 :       print_rtl (file, vec[i]);
    1240                 :          2 :       if (i < len - 1)
    1241                 :          0 :         fputs (", ", file);
    1242                 :            :     }
    1243                 :            : 
    1244                 :         36 :   fputc ('}', file);
    1245                 :         36 : }
    1246                 :            : 
    1247                 :            : #ifndef GENERATOR_FILE
    1248                 :            : /* The functions below  try to print RTL in a form resembling assembler
    1249                 :            :    mnemonics.  Because this form is more concise than the "traditional" form
    1250                 :            :    of RTL printing in Lisp-style, the form printed by this file is called
    1251                 :            :    "slim".  RTL dumps in slim format can be obtained by appending the "-slim"
    1252                 :            :    option to -fdump-rtl-<pass>.  Control flow graph output as a DOT file is
    1253                 :            :    always printed in slim form.
    1254                 :            : 
    1255                 :            :    The normal interface to the functionality provided in this pretty-printer
    1256                 :            :    is through the dump_*_slim functions to print to a stream, or via the
    1257                 :            :    print_*_slim functions to print into a user's pretty-printer.
    1258                 :            : 
    1259                 :            :    It is also possible to obtain a string for a single pattern as a string
    1260                 :            :    pointer, via str_pattern_slim, but this usage is discouraged.  */
    1261                 :            : 
    1262                 :            : /* For insns we print patterns, and for some patterns we print insns...  */
    1263                 :            : static void print_insn_with_notes (pretty_printer *, const rtx_insn *);
    1264                 :            : 
    1265                 :            : /* This recognizes rtx'en classified as expressions.  These are always
    1266                 :            :    represent some action on values or results of other expression, that
    1267                 :            :    may be stored in objects representing values.  */
    1268                 :            : 
    1269                 :            : static void
    1270                 :       4682 : print_exp (pretty_printer *pp, const_rtx x, int verbose)
    1271                 :            : {
    1272                 :       4682 :   const char *st[4];
    1273                 :       4682 :   const char *fun;
    1274                 :       4682 :   rtx op[4];
    1275                 :       4682 :   int i;
    1276                 :            : 
    1277                 :       4682 :   fun = (char *) 0;
    1278                 :      23410 :   for (i = 0; i < 4; i++)
    1279                 :            :     {
    1280                 :      18728 :       st[i] = (char *) 0;
    1281                 :      18728 :       op[i] = NULL_RTX;
    1282                 :            :     }
    1283                 :            : 
    1284                 :       4682 :   switch (GET_CODE (x))
    1285                 :            :     {
    1286                 :       1926 :     case PLUS:
    1287                 :       1926 :       op[0] = XEXP (x, 0);
    1288                 :       1926 :       if (CONST_INT_P (XEXP (x, 1))
    1289                 :        786 :           && INTVAL (XEXP (x, 1)) < 0)
    1290                 :            :         {
    1291                 :         98 :           st[1] = "-";
    1292                 :         98 :           op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
    1293                 :            :         }
    1294                 :            :       else
    1295                 :            :         {
    1296                 :       1828 :           st[1] = "+";
    1297                 :       1828 :           op[1] = XEXP (x, 1);
    1298                 :            :         }
    1299                 :            :       break;
    1300                 :          0 :     case LO_SUM:
    1301                 :          0 :       op[0] = XEXP (x, 0);
    1302                 :          0 :       st[1] = "+low(";
    1303                 :          0 :       op[1] = XEXP (x, 1);
    1304                 :          0 :       st[2] = ")";
    1305                 :          0 :       break;
    1306                 :         94 :     case MINUS:
    1307                 :         94 :       op[0] = XEXP (x, 0);
    1308                 :         94 :       st[1] = "-";
    1309                 :         94 :       op[1] = XEXP (x, 1);
    1310                 :         94 :       break;
    1311                 :        410 :     case COMPARE:
    1312                 :        410 :       fun = "cmp";
    1313                 :        410 :       op[0] = XEXP (x, 0);
    1314                 :        410 :       op[1] = XEXP (x, 1);
    1315                 :        410 :       break;
    1316                 :          3 :     case NEG:
    1317                 :          3 :       st[0] = "-";
    1318                 :          3 :       op[0] = XEXP (x, 0);
    1319                 :          3 :       break;
    1320                 :          0 :     case FMA:
    1321                 :          0 :       st[0] = "{";
    1322                 :          0 :       op[0] = XEXP (x, 0);
    1323                 :          0 :       st[1] = "*";
    1324                 :          0 :       op[1] = XEXP (x, 1);
    1325                 :          0 :       st[2] = "+";
    1326                 :          0 :       op[2] = XEXP (x, 2);
    1327                 :          0 :       st[3] = "}";
    1328                 :          0 :       break;
    1329                 :        554 :     case MULT:
    1330                 :        554 :       op[0] = XEXP (x, 0);
    1331                 :        554 :       st[1] = "*";
    1332                 :        554 :       op[1] = XEXP (x, 1);
    1333                 :        554 :       break;
    1334                 :         14 :     case DIV:
    1335                 :         14 :       op[0] = XEXP (x, 0);
    1336                 :         14 :       st[1] = "/";
    1337                 :         14 :       op[1] = XEXP (x, 1);
    1338                 :         14 :       break;
    1339                 :          4 :     case UDIV:
    1340                 :          4 :       fun = "udiv";
    1341                 :          4 :       op[0] = XEXP (x, 0);
    1342                 :          4 :       op[1] = XEXP (x, 1);
    1343                 :          4 :       break;
    1344                 :         14 :     case MOD:
    1345                 :         14 :       op[0] = XEXP (x, 0);
    1346                 :         14 :       st[1] = "%";
    1347                 :         14 :       op[1] = XEXP (x, 1);
    1348                 :         14 :       break;
    1349                 :          4 :     case UMOD:
    1350                 :          4 :       fun = "umod";
    1351                 :          4 :       op[0] = XEXP (x, 0);
    1352                 :          4 :       op[1] = XEXP (x, 1);
    1353                 :          4 :       break;
    1354                 :          0 :     case SMIN:
    1355                 :          0 :       fun = "smin";
    1356                 :          0 :       op[0] = XEXP (x, 0);
    1357                 :          0 :       op[1] = XEXP (x, 1);
    1358                 :          0 :       break;
    1359                 :          0 :     case SMAX:
    1360                 :          0 :       fun = "smax";
    1361                 :          0 :       op[0] = XEXP (x, 0);
    1362                 :          0 :       op[1] = XEXP (x, 1);
    1363                 :          0 :       break;
    1364                 :          0 :     case UMIN:
    1365                 :          0 :       fun = "umin";
    1366                 :          0 :       op[0] = XEXP (x, 0);
    1367                 :          0 :       op[1] = XEXP (x, 1);
    1368                 :          0 :       break;
    1369                 :          0 :     case UMAX:
    1370                 :          0 :       fun = "umax";
    1371                 :          0 :       op[0] = XEXP (x, 0);
    1372                 :          0 :       op[1] = XEXP (x, 1);
    1373                 :          0 :       break;
    1374                 :          8 :     case NOT:
    1375                 :          8 :       st[0] = "~";
    1376                 :          8 :       op[0] = XEXP (x, 0);
    1377                 :          8 :       break;
    1378                 :        118 :     case AND:
    1379                 :        118 :       op[0] = XEXP (x, 0);
    1380                 :        118 :       st[1] = "&";
    1381                 :        118 :       op[1] = XEXP (x, 1);
    1382                 :        118 :       break;
    1383                 :         26 :     case IOR:
    1384                 :         26 :       op[0] = XEXP (x, 0);
    1385                 :         26 :       st[1] = "|";
    1386                 :         26 :       op[1] = XEXP (x, 1);
    1387                 :         26 :       break;
    1388                 :         10 :     case XOR:
    1389                 :         10 :       op[0] = XEXP (x, 0);
    1390                 :         10 :       st[1] = "^";
    1391                 :         10 :       op[1] = XEXP (x, 1);
    1392                 :         10 :       break;
    1393                 :         92 :     case ASHIFT:
    1394                 :         92 :       op[0] = XEXP (x, 0);
    1395                 :         92 :       st[1] = "<<";
    1396                 :         92 :       op[1] = XEXP (x, 1);
    1397                 :         92 :       break;
    1398                 :        109 :     case LSHIFTRT:
    1399                 :        109 :       op[0] = XEXP (x, 0);
    1400                 :        109 :       st[1] = " 0>>";
    1401                 :        109 :       op[1] = XEXP (x, 1);
    1402                 :        109 :       break;
    1403                 :         41 :     case ASHIFTRT:
    1404                 :         41 :       op[0] = XEXP (x, 0);
    1405                 :         41 :       st[1] = ">>";
    1406                 :         41 :       op[1] = XEXP (x, 1);
    1407                 :         41 :       break;
    1408                 :          0 :     case ROTATE:
    1409                 :          0 :       op[0] = XEXP (x, 0);
    1410                 :          0 :       st[1] = "<-<";
    1411                 :          0 :       op[1] = XEXP (x, 1);
    1412                 :          0 :       break;
    1413                 :          0 :     case ROTATERT:
    1414                 :          0 :       op[0] = XEXP (x, 0);
    1415                 :          0 :       st[1] = ">->";
    1416                 :          0 :       op[1] = XEXP (x, 1);
    1417                 :          0 :       break;
    1418                 :         53 :     case NE:
    1419                 :         53 :       op[0] = XEXP (x, 0);
    1420                 :         53 :       st[1] = "!=";
    1421                 :         53 :       op[1] = XEXP (x, 1);
    1422                 :         53 :       break;
    1423                 :        101 :     case EQ:
    1424                 :        101 :       op[0] = XEXP (x, 0);
    1425                 :        101 :       st[1] = "==";
    1426                 :        101 :       op[1] = XEXP (x, 1);
    1427                 :        101 :       break;
    1428                 :         24 :     case GE:
    1429                 :         24 :       op[0] = XEXP (x, 0);
    1430                 :         24 :       st[1] = ">=";
    1431                 :         24 :       op[1] = XEXP (x, 1);
    1432                 :         24 :       break;
    1433                 :         18 :     case GT:
    1434                 :         18 :       op[0] = XEXP (x, 0);
    1435                 :         18 :       st[1] = ">";
    1436                 :         18 :       op[1] = XEXP (x, 1);
    1437                 :         18 :       break;
    1438                 :          8 :     case LE:
    1439                 :          8 :       op[0] = XEXP (x, 0);
    1440                 :          8 :       st[1] = "<=";
    1441                 :          8 :       op[1] = XEXP (x, 1);
    1442                 :          8 :       break;
    1443                 :         79 :     case LT:
    1444                 :         79 :       op[0] = XEXP (x, 0);
    1445                 :         79 :       st[1] = "<";
    1446                 :         79 :       op[1] = XEXP (x, 1);
    1447                 :         79 :       break;
    1448                 :          0 :     case SIGN_EXTRACT:
    1449                 :          0 :       fun = (verbose) ? "sign_extract" : "sxt";
    1450                 :          0 :       op[0] = XEXP (x, 0);
    1451                 :          0 :       op[1] = XEXP (x, 1);
    1452                 :          0 :       op[2] = XEXP (x, 2);
    1453                 :          0 :       break;
    1454                 :          0 :     case ZERO_EXTRACT:
    1455                 :          0 :       fun = (verbose) ? "zero_extract" : "zxt";
    1456                 :          0 :       op[0] = XEXP (x, 0);
    1457                 :          0 :       op[1] = XEXP (x, 1);
    1458                 :          0 :       op[2] = XEXP (x, 2);
    1459                 :          0 :       break;
    1460                 :         78 :     case SIGN_EXTEND:
    1461                 :         78 :       fun = (verbose) ? "sign_extend" : "sxn";
    1462                 :         78 :       op[0] = XEXP (x, 0);
    1463                 :         78 :       break;
    1464                 :         79 :     case ZERO_EXTEND:
    1465                 :         79 :       fun = (verbose) ? "zero_extend" : "zxn";
    1466                 :         79 :       op[0] = XEXP (x, 0);
    1467                 :         79 :       break;
    1468                 :          0 :     case FLOAT_EXTEND:
    1469                 :          0 :       fun = (verbose) ? "float_extend" : "fxn";
    1470                 :          0 :       op[0] = XEXP (x, 0);
    1471                 :          0 :       break;
    1472                 :          0 :     case TRUNCATE:
    1473                 :          0 :       fun = (verbose) ? "trunc" : "trn";
    1474                 :          0 :       op[0] = XEXP (x, 0);
    1475                 :          0 :       break;
    1476                 :          0 :     case FLOAT_TRUNCATE:
    1477                 :          0 :       fun = (verbose) ? "float_trunc" : "ftr";
    1478                 :          0 :       op[0] = XEXP (x, 0);
    1479                 :          0 :       break;
    1480                 :          2 :     case FLOAT:
    1481                 :          2 :       fun = (verbose) ? "float" : "flt";
    1482                 :          2 :       op[0] = XEXP (x, 0);
    1483                 :          2 :       break;
    1484                 :          0 :     case UNSIGNED_FLOAT:
    1485                 :          0 :       fun = (verbose) ? "uns_float" : "ufl";
    1486                 :          0 :       op[0] = XEXP (x, 0);
    1487                 :          0 :       break;
    1488                 :          0 :     case FIX:
    1489                 :          0 :       fun = "fix";
    1490                 :          0 :       op[0] = XEXP (x, 0);
    1491                 :          0 :       break;
    1492                 :          0 :     case UNSIGNED_FIX:
    1493                 :          0 :       fun = (verbose) ? "uns_fix" : "ufx";
    1494                 :          0 :       op[0] = XEXP (x, 0);
    1495                 :          0 :       break;
    1496                 :         54 :     case PRE_DEC:
    1497                 :         54 :       st[0] = "--";
    1498                 :         54 :       op[0] = XEXP (x, 0);
    1499                 :         54 :       break;
    1500                 :          0 :     case PRE_INC:
    1501                 :          0 :       st[0] = "++";
    1502                 :          0 :       op[0] = XEXP (x, 0);
    1503                 :          0 :       break;
    1504                 :          0 :     case POST_DEC:
    1505                 :          0 :       op[0] = XEXP (x, 0);
    1506                 :          0 :       st[1] = "--";
    1507                 :          0 :       break;
    1508                 :         59 :     case POST_INC:
    1509                 :         59 :       op[0] = XEXP (x, 0);
    1510                 :         59 :       st[1] = "++";
    1511                 :         59 :       break;
    1512                 :          0 :     case PRE_MODIFY:
    1513                 :          0 :       st[0] = "pre ";
    1514                 :          0 :       op[0] = XEXP (XEXP (x, 1), 0);
    1515                 :          0 :       st[1] = "+=";
    1516                 :          0 :       op[1] = XEXP (XEXP (x, 1), 1);
    1517                 :          0 :       break;
    1518                 :          0 :     case POST_MODIFY:
    1519                 :          0 :       st[0] = "post ";
    1520                 :          0 :       op[0] = XEXP (XEXP (x, 1), 0);
    1521                 :          0 :       st[1] = "+=";
    1522                 :          0 :       op[1] = XEXP (XEXP (x, 1), 1);
    1523                 :          0 :       break;
    1524                 :         71 :     case CALL:
    1525                 :         71 :       st[0] = "call ";
    1526                 :         71 :       op[0] = XEXP (x, 0);
    1527                 :         71 :       if (verbose)
    1528                 :            :         {
    1529                 :         56 :           st[1] = " argc:";
    1530                 :         56 :           op[1] = XEXP (x, 1);
    1531                 :            :         }
    1532                 :            :       break;
    1533                 :        330 :     case IF_THEN_ELSE:
    1534                 :        330 :       st[0] = "{(";
    1535                 :        330 :       op[0] = XEXP (x, 0);
    1536                 :        330 :       st[1] = ")?";
    1537                 :        330 :       op[1] = XEXP (x, 1);
    1538                 :        330 :       st[2] = ":";
    1539                 :        330 :       op[2] = XEXP (x, 2);
    1540                 :        330 :       st[3] = "}";
    1541                 :        330 :       break;
    1542                 :          0 :     case TRAP_IF:
    1543                 :          0 :       fun = "trap_if";
    1544                 :          0 :       op[0] = TRAP_CONDITION (x);
    1545                 :          0 :       break;
    1546                 :          0 :     case PREFETCH:
    1547                 :          0 :       fun = "prefetch";
    1548                 :          0 :       op[0] = XEXP (x, 0);
    1549                 :          0 :       op[1] = XEXP (x, 1);
    1550                 :          0 :       op[2] = XEXP (x, 2);
    1551                 :          0 :       break;
    1552                 :          0 :     case UNSPEC:
    1553                 :          0 :     case UNSPEC_VOLATILE:
    1554                 :          0 :       {
    1555                 :          0 :         pp_string (pp, "unspec");
    1556                 :          0 :         if (GET_CODE (x) == UNSPEC_VOLATILE)
    1557                 :          0 :           pp_string (pp, "/v");
    1558                 :          0 :         pp_left_bracket (pp);
    1559                 :          0 :         for (i = 0; i < XVECLEN (x, 0); i++)
    1560                 :            :           {
    1561                 :          0 :             if (i != 0)
    1562                 :          0 :               pp_comma (pp);
    1563                 :          0 :             print_pattern (pp, XVECEXP (x, 0, i), verbose);
    1564                 :            :           }
    1565                 :          0 :         pp_string (pp, "] ");
    1566                 :          0 :         pp_decimal_int (pp, XINT (x, 1));
    1567                 :            :       }
    1568                 :          0 :       break;
    1569                 :        299 :     default:
    1570                 :        299 :       {
    1571                 :            :         /* Most unhandled codes can be printed as pseudo-functions.  */
    1572                 :        299 :         if (GET_RTX_CLASS (GET_CODE (x)) == RTX_UNARY)
    1573                 :            :           {
    1574                 :         62 :             fun = GET_RTX_NAME (GET_CODE (x));
    1575                 :         62 :             op[0] = XEXP (x, 0);
    1576                 :            :           }
    1577                 :        237 :         else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_COMPARE
    1578                 :            :                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_COMPARE
    1579                 :            :                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_BIN_ARITH
    1580                 :            :                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_ARITH)
    1581                 :            :           {
    1582                 :        122 :             fun = GET_RTX_NAME (GET_CODE (x));
    1583                 :        122 :             op[0] = XEXP (x, 0);
    1584                 :        122 :             op[1] = XEXP (x, 1);
    1585                 :            :           }
    1586                 :        115 :         else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY)
    1587                 :            :           {
    1588                 :          2 :             fun = GET_RTX_NAME (GET_CODE (x));
    1589                 :          2 :             op[0] = XEXP (x, 0);
    1590                 :          2 :             op[1] = XEXP (x, 1);
    1591                 :          2 :             op[2] = XEXP (x, 2);
    1592                 :            :           }
    1593                 :            :         else
    1594                 :            :           /* Give up, just print the RTX name.  */
    1595                 :        113 :           st[0] = GET_RTX_NAME (GET_CODE (x));
    1596                 :            :       }
    1597                 :            :       break;
    1598                 :            :     }
    1599                 :            : 
    1600                 :            :   /* Print this as a function?  */
    1601                 :       4667 :   if (fun)
    1602                 :            :     {
    1603                 :        763 :       pp_string (pp, fun);
    1604                 :        763 :       pp_left_paren (pp);
    1605                 :            :     }
    1606                 :            : 
    1607                 :      23410 :   for (i = 0; i < 4; i++)
    1608                 :            :     {
    1609                 :      18728 :       if (st[i])
    1610                 :       4965 :         pp_string (pp, st[i]);
    1611                 :            : 
    1612                 :      18728 :       if (op[i])
    1613                 :            :         {
    1614                 :       9110 :           if (fun && i != 0)
    1615                 :        544 :             pp_comma (pp);
    1616                 :       9110 :           print_value (pp, op[i], verbose);
    1617                 :            :         }
    1618                 :            :     }
    1619                 :            : 
    1620                 :       4682 :   if (fun)
    1621                 :        763 :     pp_right_paren (pp);
    1622                 :       4682 : }               /* print_exp */
    1623                 :            : 
    1624                 :            : /* Prints rtxes, I customarily classified as values.  They're constants,
    1625                 :            :    registers, labels, symbols and memory accesses.  */
    1626                 :            : 
    1627                 :            : void
    1628                 :      24754 : print_value (pretty_printer *pp, const_rtx x, int verbose)
    1629                 :            : {
    1630                 :      24754 :   char tmp[1024];
    1631                 :            : 
    1632                 :      24754 :   if (!x)
    1633                 :            :     {
    1634                 :          1 :       pp_string (pp, "(nil)");
    1635                 :          1 :       return;
    1636                 :            :     }
    1637                 :      24753 :   switch (GET_CODE (x))
    1638                 :            :     {
    1639                 :       2958 :     case CONST_INT:
    1640                 :       2958 :       pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
    1641                 :            :                  (unsigned HOST_WIDE_INT) INTVAL (x));
    1642                 :       2958 :       break;
    1643                 :            : 
    1644                 :          0 :     case CONST_WIDE_INT:
    1645                 :          0 :       {
    1646                 :          0 :         const char *sep = "<";
    1647                 :          0 :         int i;
    1648                 :          0 :         for (i = CONST_WIDE_INT_NUNITS (x) - 1; i >= 0; i--)
    1649                 :            :           {
    1650                 :          0 :             pp_string (pp, sep);
    1651                 :          0 :             sep = ",";
    1652                 :          0 :             sprintf (tmp, HOST_WIDE_INT_PRINT_HEX,
    1653                 :          0 :                      (unsigned HOST_WIDE_INT) CONST_WIDE_INT_ELT (x, i));
    1654                 :          0 :             pp_string (pp, tmp);
    1655                 :            :           }
    1656                 :          0 :         pp_greater (pp);
    1657                 :            :       }
    1658                 :          0 :       break;
    1659                 :            : 
    1660                 :          0 :     case CONST_POLY_INT:
    1661                 :          0 :       pp_left_bracket (pp);
    1662                 :          0 :       pp_wide_int (pp, CONST_POLY_INT_COEFFS (x)[0], SIGNED);
    1663                 :          0 :       for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
    1664                 :            :         {
    1665                 :            :           pp_string (pp, ", ");
    1666                 :            :           pp_wide_int (pp, CONST_POLY_INT_COEFFS (x)[i], SIGNED);
    1667                 :            :         }
    1668                 :          0 :       pp_right_bracket (pp);
    1669                 :          0 :       break;
    1670                 :            : 
    1671                 :          1 :     case CONST_DOUBLE:
    1672                 :          1 :       if (FLOAT_MODE_P (GET_MODE (x)))
    1673                 :            :         {
    1674                 :          1 :           real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x),
    1675                 :            :                            sizeof (tmp), 0, 1);
    1676                 :          1 :           pp_string (pp, tmp);
    1677                 :            :         }
    1678                 :            :       else
    1679                 :          0 :         pp_printf (pp, "<%wx,%wx>",
    1680                 :          0 :                    (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
    1681                 :          0 :                    (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
    1682                 :            :       break;
    1683                 :          0 :     case CONST_FIXED:
    1684                 :          0 :       fixed_to_decimal (tmp, CONST_FIXED_VALUE (x), sizeof (tmp));
    1685                 :          0 :       pp_string (pp, tmp);
    1686                 :          0 :       break;
    1687                 :          2 :     case CONST_STRING:
    1688                 :          2 :       pp_string (pp, "\"");
    1689                 :          2 :       pretty_print_string (pp, XSTR (x, 0), strlen (XSTR (x, 0)));
    1690                 :          2 :       pp_string (pp, "\"");
    1691                 :          2 :       break;
    1692                 :        257 :     case SYMBOL_REF:
    1693                 :        257 :       pp_printf (pp, "`%s'", XSTR (x, 0));
    1694                 :        257 :       break;
    1695                 :        312 :     case LABEL_REF:
    1696                 :        312 :       pp_printf (pp, "L%d", INSN_UID (label_ref_label (x)));
    1697                 :        312 :       break;
    1698                 :         28 :     case CONST:
    1699                 :         28 :     case HIGH:
    1700                 :         28 :     case STRICT_LOW_PART:
    1701                 :         28 :       pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x)));
    1702                 :         28 :       print_value (pp, XEXP (x, 0), verbose);
    1703                 :         28 :       pp_right_paren (pp);
    1704                 :         28 :       break;
    1705                 :      14630 :     case REG:
    1706                 :      14630 :       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
    1707                 :            :         {
    1708                 :       6654 :           if (ISDIGIT (reg_names[REGNO (x)][0]))
    1709                 :          0 :             pp_modulo (pp);
    1710                 :       6654 :           pp_string (pp, reg_names[REGNO (x)]);
    1711                 :            :         }
    1712                 :            :       else
    1713                 :       7976 :         pp_printf (pp, "r%d", REGNO (x));
    1714                 :      14630 :       if (verbose)
    1715                 :      12309 :         pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x)));
    1716                 :            :       break;
    1717                 :        106 :     case SUBREG:
    1718                 :        106 :       print_value (pp, SUBREG_REG (x), verbose);
    1719                 :        106 :       pp_printf (pp, "#");
    1720                 :        106 :       pp_wide_integer (pp, SUBREG_BYTE (x));
    1721                 :        106 :       break;
    1722                 :        590 :     case SCRATCH:
    1723                 :        590 :     case CC0:
    1724                 :        590 :     case PC:
    1725                 :        590 :       pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
    1726                 :        590 :       break;
    1727                 :       1138 :     case MEM:
    1728                 :       1138 :       pp_left_bracket (pp);
    1729                 :       1138 :       print_value (pp, XEXP (x, 0), verbose);
    1730                 :       1138 :       pp_right_bracket (pp);
    1731                 :       1138 :       break;
    1732                 :         52 :     case DEBUG_EXPR:
    1733                 :         52 :       pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
    1734                 :         52 :       break;
    1735                 :       4679 :     default:
    1736                 :       4679 :       print_exp (pp, x, verbose);
    1737                 :       4679 :       break;
    1738                 :            :     }
    1739                 :            : }                               /* print_value */
    1740                 :            : 
    1741                 :            : /* The next step in insn detalization, its pattern recognition.  */
    1742                 :            : 
    1743                 :            : void
    1744                 :      11049 : print_pattern (pretty_printer *pp, const_rtx x, int verbose)
    1745                 :            : {
    1746                 :      11049 :   if (! x)
    1747                 :            :     {
    1748                 :         24 :       pp_string (pp, "(nil)");
    1749                 :         24 :       return;
    1750                 :            :     }
    1751                 :            : 
    1752                 :      11025 :   switch (GET_CODE (x))
    1753                 :            :     {
    1754                 :       4541 :     case SET:
    1755                 :       4541 :       print_value (pp, SET_DEST (x), verbose);
    1756                 :       4541 :       pp_equal (pp);
    1757                 :       4541 :       print_value (pp, SET_SRC (x), verbose);
    1758                 :       4541 :       break;
    1759                 :         87 :     case RETURN:
    1760                 :         87 :     case SIMPLE_RETURN:
    1761                 :         87 :     case EH_RETURN:
    1762                 :         87 :       pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
    1763                 :         87 :       break;
    1764                 :          3 :     case CALL:
    1765                 :          3 :       print_exp (pp, x, verbose);
    1766                 :          3 :       break;
    1767                 :       1439 :     case CLOBBER:
    1768                 :       1439 :     case USE:
    1769                 :       1439 :       pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x)));
    1770                 :       1439 :       print_value (pp, XEXP (x, 0), verbose);
    1771                 :       1439 :       break;
    1772                 :         60 :     case VAR_LOCATION:
    1773                 :         60 :       pp_string (pp, "loc ");
    1774                 :         60 :       print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
    1775                 :         60 :       break;
    1776                 :          0 :     case COND_EXEC:
    1777                 :          0 :       pp_left_paren (pp);
    1778                 :          0 :       if (GET_CODE (COND_EXEC_TEST (x)) == NE
    1779                 :          0 :           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
    1780                 :          0 :         print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
    1781                 :          0 :       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
    1782                 :          0 :                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
    1783                 :            :         {
    1784                 :          0 :           pp_exclamation (pp);
    1785                 :          0 :           print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
    1786                 :            :         }
    1787                 :            :       else
    1788                 :          0 :         print_value (pp, COND_EXEC_TEST (x), verbose);
    1789                 :          0 :       pp_string (pp, ") ");
    1790                 :          0 :       print_pattern (pp, COND_EXEC_CODE (x), verbose);
    1791                 :          0 :       break;
    1792                 :       1161 :     case PARALLEL:
    1793                 :       1161 :       {
    1794                 :       1161 :         int i;
    1795                 :            : 
    1796                 :       1161 :         pp_left_brace (pp);
    1797                 :       3505 :         for (i = 0; i < XVECLEN (x, 0); i++)
    1798                 :            :           {
    1799                 :       2344 :             print_pattern (pp, XVECEXP (x, 0, i), verbose);
    1800                 :       2344 :             pp_semicolon (pp);
    1801                 :            :           }
    1802                 :       1161 :         pp_right_brace (pp);
    1803                 :            :       }
    1804                 :       1161 :       break;
    1805                 :          0 :     case SEQUENCE:
    1806                 :          0 :       {
    1807                 :          0 :         const rtx_sequence *seq = as_a <const rtx_sequence *> (x);
    1808                 :          0 :         pp_string (pp, "sequence{");
    1809                 :          0 :         if (INSN_P (seq->element (0)))
    1810                 :            :           {
    1811                 :            :             /* Print the sequence insns indented.  */
    1812                 :          0 :             const char * save_print_rtx_head = print_rtx_head;
    1813                 :          0 :             char indented_print_rtx_head[32];
    1814                 :            : 
    1815                 :          0 :             pp_newline (pp);
    1816                 :          0 :             gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4);
    1817                 :          0 :             snprintf (indented_print_rtx_head,
    1818                 :            :                       sizeof (indented_print_rtx_head),
    1819                 :            :                       "%s    ", print_rtx_head);
    1820                 :          0 :             print_rtx_head = indented_print_rtx_head;
    1821                 :          0 :             for (int i = 0; i < seq->len (); i++)
    1822                 :          0 :               print_insn_with_notes (pp, seq->insn (i));
    1823                 :          0 :             pp_printf (pp, "%s      ", save_print_rtx_head);
    1824                 :          0 :             print_rtx_head = save_print_rtx_head;
    1825                 :            :           }
    1826                 :            :         else
    1827                 :            :           {
    1828                 :          0 :             for (int i = 0; i < seq->len (); i++)
    1829                 :            :               {
    1830                 :          0 :                 print_pattern (pp, seq->element (i), verbose);
    1831                 :          0 :                 pp_semicolon (pp);
    1832                 :            :               }
    1833                 :            :           }
    1834                 :          0 :         pp_right_brace (pp);
    1835                 :            :       }
    1836                 :          0 :       break;
    1837                 :          0 :     case ASM_INPUT:
    1838                 :          0 :       pp_printf (pp, "asm {%s}", XSTR (x, 0));
    1839                 :          0 :       break;
    1840                 :            :     case ADDR_VEC:
    1841                 :          0 :       for (int i = 0; i < XVECLEN (x, 0); i++)
    1842                 :            :         {
    1843                 :          0 :           print_value (pp, XVECEXP (x, 0, i), verbose);
    1844                 :          0 :           pp_semicolon (pp);
    1845                 :            :         }
    1846                 :            :       break;
    1847                 :            :     case ADDR_DIFF_VEC:
    1848                 :          0 :       for (int i = 0; i < XVECLEN (x, 1); i++)
    1849                 :            :         {
    1850                 :          0 :           print_value (pp, XVECEXP (x, 1, i), verbose);
    1851                 :          0 :           pp_semicolon (pp);
    1852                 :            :         }
    1853                 :            :       break;
    1854                 :          0 :     case TRAP_IF:
    1855                 :          0 :       pp_string (pp, "trap_if ");
    1856                 :          0 :       print_value (pp, TRAP_CONDITION (x), verbose);
    1857                 :          0 :       break;
    1858                 :       3734 :     case UNSPEC:
    1859                 :       3734 :     case UNSPEC_VOLATILE:
    1860                 :            :       /* Fallthru -- leave UNSPECs to print_exp.  */
    1861                 :       3734 :     default:
    1862                 :       3734 :       print_value (pp, x, verbose);
    1863                 :            :     }
    1864                 :            : }                               /* print_pattern */
    1865                 :            : 
    1866                 :            : /* This is the main function in slim rtl visualization mechanism.
    1867                 :            : 
    1868                 :            :    X is an insn, to be printed into PP.
    1869                 :            : 
    1870                 :            :    This function tries to print it properly in human-readable form,
    1871                 :            :    resembling assembler mnemonics (instead of the older Lisp-style
    1872                 :            :    form).
    1873                 :            : 
    1874                 :            :    If VERBOSE is TRUE, insns are printed with more complete (but
    1875                 :            :    longer) pattern names and with extra information, and prefixed
    1876                 :            :    with their INSN_UIDs.  */
    1877                 :            : 
    1878                 :            : void
    1879                 :       4933 : print_insn (pretty_printer *pp, const rtx_insn *x, int verbose)
    1880                 :            : {
    1881                 :       4933 :   if (verbose)
    1882                 :            :     {
    1883                 :            :       /* Blech, pretty-print can't print integers with a specified width.  */
    1884                 :       4933 :       char uid_prefix[32];
    1885                 :       4933 :       snprintf (uid_prefix, sizeof uid_prefix, " %4d: ", INSN_UID (x));
    1886                 :       4933 :       pp_string (pp, uid_prefix);
    1887                 :            :     }
    1888                 :            : 
    1889                 :       4933 :   switch (GET_CODE (x))
    1890                 :            :     {
    1891                 :       3651 :     case INSN:
    1892                 :       3651 :       print_pattern (pp, PATTERN (x), verbose);
    1893                 :       3651 :       break;
    1894                 :            : 
    1895                 :        154 :     case DEBUG_INSN:
    1896                 :        154 :       {
    1897                 :        154 :         if (DEBUG_MARKER_INSN_P (x))
    1898                 :            :           {
    1899                 :         82 :             switch (INSN_DEBUG_MARKER_KIND (x))
    1900                 :            :               {
    1901                 :         82 :               case NOTE_INSN_BEGIN_STMT:
    1902                 :         82 :                 pp_string (pp, "debug begin stmt marker");
    1903                 :         82 :                 break;
    1904                 :            : 
    1905                 :          0 :               case NOTE_INSN_INLINE_ENTRY:
    1906                 :          0 :                 pp_string (pp, "debug inline entry marker");
    1907                 :          0 :                 break;
    1908                 :            : 
    1909                 :          0 :               default:
    1910                 :          0 :                 gcc_unreachable ();
    1911                 :            :               }
    1912                 :         82 :             break;
    1913                 :            :           }
    1914                 :            : 
    1915                 :         72 :         const char *name = "?";
    1916                 :         72 :         char idbuf[32];
    1917                 :            : 
    1918                 :         72 :         if (DECL_P (INSN_VAR_LOCATION_DECL (x)))
    1919                 :            :           {
    1920                 :         72 :             tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (x));
    1921                 :         72 :             if (id)
    1922                 :         70 :               name = IDENTIFIER_POINTER (id);
    1923                 :          2 :             else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x))
    1924                 :            :                      == DEBUG_EXPR_DECL)
    1925                 :            :               {
    1926                 :          2 :                 sprintf (idbuf, "D#%i",
    1927                 :          2 :                          DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x)));
    1928                 :          2 :                 name = idbuf;
    1929                 :            :               }
    1930                 :            :             else
    1931                 :            :               {
    1932                 :          0 :                 sprintf (idbuf, "D.%i",
    1933                 :          0 :                          DECL_UID (INSN_VAR_LOCATION_DECL (x)));
    1934                 :          0 :                 name = idbuf;
    1935                 :            :               }
    1936                 :            :           }
    1937                 :         72 :         pp_printf (pp, "debug %s => ", name);
    1938                 :         72 :         if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x)))
    1939                 :         14 :           pp_string (pp, "optimized away");
    1940                 :            :         else
    1941                 :         58 :           print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose);
    1942                 :            :       }
    1943                 :         72 :       break;
    1944                 :            : 
    1945                 :        259 :     case JUMP_INSN:
    1946                 :        259 :       print_pattern (pp, PATTERN (x), verbose);
    1947                 :        259 :       break;
    1948                 :         56 :     case CALL_INSN:
    1949                 :         56 :       if (GET_CODE (PATTERN (x)) == PARALLEL)
    1950                 :          0 :         print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose);
    1951                 :            :       else
    1952                 :         56 :         print_pattern (pp, PATTERN (x), verbose);
    1953                 :            :       break;
    1954                 :         77 :     case CODE_LABEL:
    1955                 :         77 :       pp_printf (pp, "L%d:", INSN_UID (x));
    1956                 :         77 :       break;
    1957                 :          0 :     case JUMP_TABLE_DATA:
    1958                 :          0 :       pp_string (pp, "jump_table_data{\n");
    1959                 :          0 :       print_pattern (pp, PATTERN (x), verbose);
    1960                 :          0 :       pp_right_brace (pp);
    1961                 :          0 :       break;
    1962                 :         25 :     case BARRIER:
    1963                 :         25 :       pp_string (pp, "barrier");
    1964                 :         25 :       break;
    1965                 :        711 :     case NOTE:
    1966                 :        711 :       {
    1967                 :        711 :         pp_string (pp, GET_NOTE_INSN_NAME (NOTE_KIND (x)));
    1968                 :        711 :         switch (NOTE_KIND (x))
    1969                 :            :           {
    1970                 :          0 :           case NOTE_INSN_EH_REGION_BEG:
    1971                 :          0 :           case NOTE_INSN_EH_REGION_END:
    1972                 :          0 :             pp_printf (pp, " %d", NOTE_EH_HANDLER (x));
    1973                 :          0 :             break;
    1974                 :            : 
    1975                 :          0 :           case NOTE_INSN_BLOCK_BEG:
    1976                 :          0 :           case NOTE_INSN_BLOCK_END:
    1977                 :          0 :             pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x)));
    1978                 :          0 :             break;
    1979                 :            : 
    1980                 :        323 :           case NOTE_INSN_BASIC_BLOCK:
    1981                 :        323 :             pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index);
    1982                 :        323 :             break;
    1983                 :            : 
    1984                 :          0 :           case NOTE_INSN_DELETED_LABEL:
    1985                 :          0 :           case NOTE_INSN_DELETED_DEBUG_LABEL:
    1986                 :          0 :             {
    1987                 :          0 :               const char *label = NOTE_DELETED_LABEL_NAME (x);
    1988                 :          0 :               if (label == NULL)
    1989                 :          0 :                 label = "";
    1990                 :          0 :               pp_printf (pp, " (\"%s\")", label);
    1991                 :            :             }
    1992                 :          0 :             break;
    1993                 :            : 
    1994                 :          2 :           case NOTE_INSN_VAR_LOCATION:
    1995                 :          2 :             pp_left_brace (pp);
    1996                 :          2 :             print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
    1997                 :          2 :             pp_right_brace (pp);
    1998                 :          2 :             break;
    1999                 :            : 
    2000                 :            :           default:
    2001                 :            :             break;
    2002                 :            :           }
    2003                 :            :         break;
    2004                 :            :       }
    2005                 :          0 :     default:
    2006                 :          0 :       gcc_unreachable ();
    2007                 :            :     }
    2008                 :       4933 : }                               /* print_insn */
    2009                 :            : 
    2010                 :            : /* Pretty-print a slim dump of X (an insn) to PP, including any register
    2011                 :            :    note attached to the instruction.  */
    2012                 :            : 
    2013                 :            : static void
    2014                 :       4933 : print_insn_with_notes (pretty_printer *pp, const rtx_insn *x)
    2015                 :            : {
    2016                 :       4933 :   pp_string (pp, print_rtx_head);
    2017                 :       4933 :   print_insn (pp, x, 1);
    2018                 :       4933 :   pp_newline (pp);
    2019                 :       4933 :   if (INSN_P (x) && REG_NOTES (x))
    2020                 :       5917 :     for (rtx note = REG_NOTES (x); note; note = XEXP (note, 1))
    2021                 :            :       {
    2022                 :       3559 :         pp_printf (pp, "%s      %s ", print_rtx_head,
    2023                 :       3559 :                    GET_REG_NOTE_NAME (REG_NOTE_KIND (note)));
    2024                 :       3559 :         if (GET_CODE (note) == INT_LIST)
    2025                 :        187 :           pp_printf (pp, "%d", XINT (note, 0));
    2026                 :            :         else
    2027                 :       3372 :           print_pattern (pp, XEXP (note, 0), 1);
    2028                 :       3559 :         pp_newline (pp);
    2029                 :            :       }
    2030                 :       4933 : }
    2031                 :            : 
    2032                 :            : /* Print X, an RTL value node, to file F in slim format.  Include
    2033                 :            :    additional information if VERBOSE is nonzero.
    2034                 :            : 
    2035                 :            :    Value nodes are constants, registers, labels, symbols and
    2036                 :            :    memory.  */
    2037                 :            : 
    2038                 :            : void
    2039                 :         57 : dump_value_slim (FILE *f, const_rtx x, int verbose)
    2040                 :            : {
    2041                 :        114 :   pretty_printer rtl_slim_pp;
    2042                 :         57 :   rtl_slim_pp.buffer->stream = f;
    2043                 :         57 :   print_value (&rtl_slim_pp, x, verbose);
    2044                 :         57 :   pp_flush (&rtl_slim_pp);
    2045                 :         57 : }
    2046                 :            : 
    2047                 :            : /* Emit a slim dump of X (an insn) to the file F, including any register
    2048                 :            :    note attached to the instruction.  */
    2049                 :            : void
    2050                 :       3242 : dump_insn_slim (FILE *f, const rtx_insn *x)
    2051                 :            : {
    2052                 :       6484 :   pretty_printer rtl_slim_pp;
    2053                 :       3242 :   rtl_slim_pp.buffer->stream = f;
    2054                 :       3242 :   print_insn_with_notes (&rtl_slim_pp, x);
    2055                 :       3242 :   pp_flush (&rtl_slim_pp);
    2056                 :       3242 : }
    2057                 :            : 
    2058                 :            : /* Same as above, but stop at LAST or when COUNT == 0.
    2059                 :            :    If COUNT < 0 it will stop only at LAST or NULL rtx.  */
    2060                 :            : 
    2061                 :            : void
    2062                 :        405 : dump_rtl_slim (FILE *f, const rtx_insn *first, const rtx_insn *last,
    2063                 :            :                int count, int flags ATTRIBUTE_UNUSED)
    2064                 :            : {
    2065                 :        405 :   const rtx_insn *insn, *tail;
    2066                 :        810 :   pretty_printer rtl_slim_pp;
    2067                 :        405 :   rtl_slim_pp.buffer->stream = f;
    2068                 :            : 
    2069                 :        405 :   tail = last ? NEXT_INSN (last) : NULL;
    2070                 :        405 :   for (insn = first;
    2071                 :        810 :        (insn != NULL) && (insn != tail) && (count != 0);
    2072                 :        405 :        insn = NEXT_INSN (insn))
    2073                 :            :     {
    2074                 :        405 :       print_insn_with_notes (&rtl_slim_pp, insn);
    2075                 :        405 :       if (count > 0)
    2076                 :          0 :         count--;
    2077                 :            :     }
    2078                 :            : 
    2079                 :        405 :   pp_flush (&rtl_slim_pp);
    2080                 :        405 : }
    2081                 :            : 
    2082                 :            : /* Dumps basic block BB to pretty-printer PP in slim form and without and
    2083                 :            :    no indentation, for use as a label of a DOT graph record-node.  */
    2084                 :            : 
    2085                 :            : void
    2086                 :        270 : rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
    2087                 :            : {
    2088                 :        270 :   rtx_insn *insn;
    2089                 :        270 :   bool first = true;
    2090                 :            : 
    2091                 :            :   /* TODO: inter-bb stuff.  */
    2092                 :       2842 :   FOR_BB_INSNS (bb, insn)
    2093                 :            :     {
    2094                 :       1286 :       if (! first)
    2095                 :            :         {
    2096                 :       1016 :           pp_bar (pp);
    2097                 :       1016 :           pp_write_text_to_stream (pp);
    2098                 :            :         }
    2099                 :       1286 :       first = false;
    2100                 :       1286 :       print_insn_with_notes (pp, insn);
    2101                 :       1286 :       pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
    2102                 :            :     }
    2103                 :        270 : }
    2104                 :            : 
    2105                 :            : /* Pretty-print pattern X of some insn in non-verbose mode.
    2106                 :            :    Return a string pointer to the pretty-printer buffer.
    2107                 :            : 
    2108                 :            :    This function is only exported exists only to accommodate some older users
    2109                 :            :    of the slim RTL pretty printers.  Please do not use it for new code.  */
    2110                 :            : 
    2111                 :            : const char *
    2112                 :       1305 : str_pattern_slim (const_rtx x)
    2113                 :            : {
    2114                 :       2610 :   pretty_printer rtl_slim_pp;
    2115                 :       1305 :   print_pattern (&rtl_slim_pp, x, 0);
    2116                 :       1305 :   return ggc_strdup (pp_formatted_text (&rtl_slim_pp));
    2117                 :            : }
    2118                 :            : 
    2119                 :            : /* Emit a slim dump of X (an insn) to stderr.  */
    2120                 :            : extern void debug_insn_slim (const rtx_insn *);
    2121                 :            : DEBUG_FUNCTION void
    2122                 :          0 : debug_insn_slim (const rtx_insn *x)
    2123                 :            : {
    2124                 :          0 :   dump_insn_slim (stderr, x);
    2125                 :          0 : }
    2126                 :            : 
    2127                 :            : /* Same as above, but using dump_rtl_slim.  */
    2128                 :            : extern void debug_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *,
    2129                 :            :                             int, int);
    2130                 :            : DEBUG_FUNCTION void
    2131                 :          0 : debug_rtl_slim (const rtx_insn *first, const rtx_insn *last, int count,
    2132                 :            :                 int flags)
    2133                 :            : {
    2134                 :          0 :   dump_rtl_slim (stderr, first, last, count, flags);
    2135                 :          0 : }
    2136                 :            : 
    2137                 :            : extern void debug_bb_slim (basic_block);
    2138                 :            : DEBUG_FUNCTION void
    2139                 :          0 : debug_bb_slim (basic_block bb)
    2140                 :            : {
    2141                 :          0 :   dump_bb (stderr, bb, 0, TDF_SLIM | TDF_BLOCKS);
    2142                 :          0 : }
    2143                 :            : 
    2144                 :            : extern void debug_bb_n_slim (int);
    2145                 :            : DEBUG_FUNCTION void
    2146                 :          0 : debug_bb_n_slim (int n)
    2147                 :            : {
    2148                 :          0 :   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n);
    2149                 :          0 :   debug_bb_slim (bb);
    2150                 :          0 : }
    2151                 :            : 
    2152                 :            : #endif
    2153                 :            : 
    2154                 :            : #if __GNUC__ >= 10
    2155                 :            : #  pragma GCC diagnostic pop
    2156                 :            : #endif

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.