gcc/print-rtl.c

   1 /* Print RTL for GNU C Compiler.
   2    Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "rtl.h"
  26
  27 /* We don't want the tree code checking code for the access to the
  28    DECL_NAME to be included in the gen* programs.  */
  29 #undef ENABLE_TREE_CHECKING
  30 #include "tree.h"
  31 #include "real.h"
  32 #include "flags.h"
  33 #include "hard-reg-set.h"
  34 #include "basic-block.h"
  35
  36 /* How to print out a register name.
  37    We don't use PRINT_REG because some definitions of PRINT_REG
  38    don't work here.  */
  39 #ifndef DEBUG_PRINT_REG
  40 #define DEBUG_PRINT_REG(RTX, CODE, FILE) \
  41   fprintf ((FILE), "%d %s", REGNO (RTX), reg_names[REGNO (RTX)])
  42 #endif
  43
  44 /* Array containing all of the register names */
  45
  46 #ifdef DEBUG_REGISTER_NAMES
  47 static const char * const debug_reg_names[] = DEBUG_REGISTER_NAMES;
  48 #define reg_names debug_reg_names
  49 #else
  50 const char * reg_names[] = REGISTER_NAMES;
  51 #endif
  52
  53 static FILE *outfile;
  54
  55 static int sawclose = 0;
  56
  57 static int indent;
  58
  59 static void print_rtx           PARAMS ((rtx));
  60
  61 /* String printed at beginning of each RTL when it is dumped.
  62    This string is set to ASM_COMMENT_START when the RTL is dumped in
  63    the assembly output file.  */
  64 const char *print_rtx_head = "";
  65
  66 /* Nonzero means suppress output of instruction numbers and line number
  67    notes in debugging dumps.
  68    This must be defined here so that programs like gencodes can be linked.  */
  69 int flag_dump_unnumbered = 0;
  70
  71 /* Nonzero means use simplified format without flags, modes, etc.  */
  72 int flag_simple = 0;
  73
  74 /* Nonzero if we are dumping graphical description.  */
  75 int dump_for_graph;
  76
  77 /* Nonzero to dump all call_placeholder alternatives.  */
  78 static int debug_call_placeholder_verbose;
  79
  80 void
  81 print_mem_expr (outfile, expr)
  82      FILE *outfile;
  83      tree expr;
  84 {
  85   if (TREE_CODE (expr) == COMPONENT_REF)
  86     {
  87       if (TREE_OPERAND (expr, 0))
  88         print_mem_expr (outfile, TREE_OPERAND (expr, 0));
  89       else
  90         fputs (" <variable>", outfile);
  91       if (DECL_NAME (TREE_OPERAND (expr, 1)))
  92         fprintf (outfile, ".%s",
  93                  IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (expr, 1))));
  94     }
  95   else if (DECL_NAME (expr))
  96     fprintf (outfile, " %s", IDENTIFIER_POINTER (DECL_NAME (expr)));
  97   else if (TREE_CODE (expr) == RESULT_DECL)
  98     fputs (" <result>", outfile);
  99   else
 100     fputs (" <anonymous>", outfile);
 101 }
 102
 103 /* Print IN_RTX onto OUTFILE.  This is the recursive part of printing.  */
 104
 105 static void
 106 print_rtx (in_rtx)
 107      rtx in_rtx;
 108 {
 109   int i = 0;
 110   int j;
 111   const char *format_ptr;
 112   int is_insn;
 113   rtx tem;
 114
 115   if (sawclose)
 116     {
 117       if (flag_simple)
 118         fputc (' ', outfile);
 119       else
 120         fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
 121       sawclose = 0;
 122     }
 123
 124   if (in_rtx == 0)
 125     {
 126       fputs ("(nil)", outfile);
 127       sawclose = 1;
 128       return;
 129     }
 130   else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
 131     {
 132        fprintf (outfile, "(??? bad code %d\n)", GET_CODE (in_rtx));
 133        sawclose = 1;
 134        return;
 135     }
 136
 137   is_insn = INSN_P (in_rtx);
 138
 139   /* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
 140      in separate nodes and therefore have to handle them special here.  */
 141   if (dump_for_graph
 142       && (is_insn || GET_CODE (in_rtx) == NOTE
 143           || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER))
 144     {
 145       i = 3;
 146       indent = 0;
 147     }
 148   else
 149     {
 150       /* Print name of expression code.  */
 151       if (flag_simple && GET_CODE (in_rtx) == CONST_INT)
 152         fputc ('(', outfile);
 153       else
 154         fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
 155
 156       if (! flag_simple)
 157         {
 158           if (in_rtx->in_struct)
 159             fputs ("/s", outfile);
 160
 161           if (in_rtx->volatil)
 162             fputs ("/v", outfile);
 163
 164           if (in_rtx->unchanging)
 165             fputs ("/u", outfile);
 166
 167           if (in_rtx->integrated)
 168             fputs ("/i", outfile);
 169
 170           if (in_rtx->frame_related)
 171             fputs ("/f", outfile);
 172
 173           if (in_rtx->jump)
 174             fputs ("/j", outfile);
 175
 176           if (in_rtx->call)
 177             fputs ("/c", outfile);
 178
 179           if (GET_MODE (in_rtx) != VOIDmode)
 180             {
 181               /* Print REG_NOTE names for EXPR_LIST and INSN_LIST.  */
 182               if (GET_CODE (in_rtx) == EXPR_LIST
 183                   || GET_CODE (in_rtx) == INSN_LIST)
 184                 fprintf (outfile, ":%s",
 185                          GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
 186               else
 187                 fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
 188             }
 189         }
 190     }
 191
 192   /* Get the format string and skip the first elements if we have handled
 193      them already.  */
 194   format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
 195   for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
 196     switch (*format_ptr++)
 197       {
 198         const char *str;
 199
 200       case 'T':
 201         str = XTMPL (in_rtx, i);
 202         goto string;
 203
 204       case 'S':
 205       case 's':
 206         str = XSTR (in_rtx, i);
 207       string:
 208
 209         if (str == 0)
 210           fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
 211         else
 212           {
 213             if (dump_for_graph)
 214               fprintf (outfile, " (\\\"%s\\\")", str);
 215             else
 216               fprintf (outfile, " (\"%s\")", str);
 217           }
 218         sawclose = 1;
 219         break;
 220
 221         /* 0 indicates a field for internal use that should not be printed.
 222            An exception is the third field of a NOTE, where it indicates
 223            that the field has several different valid contents.  */
 224       case '0':
 225         if (i == 1 && GET_CODE (in_rtx) == REG)
 226           {
 227             if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
 228               fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
 229             break;
 230           }
 231         if (i == 3 && GET_CODE (in_rtx) == NOTE)
 232           {
 233             switch (NOTE_LINE_NUMBER (in_rtx))
 234               {
 235               case NOTE_INSN_EH_REGION_BEG:
 236               case NOTE_INSN_EH_REGION_END:
 237                 if (flag_dump_unnumbered)
 238                   fprintf (outfile, " #");
 239                 else
 240                   fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx));
 241                 sawclose = 1;
 242                 break;
 243
 244               case NOTE_INSN_BLOCK_BEG:
 245               case NOTE_INSN_BLOCK_END:
 246                 fprintf (outfile, " ");
 247                 if (flag_dump_unnumbered)
 248                   fprintf (outfile, "#");
 249                 else
 250                   fprintf (outfile, HOST_PTR_PRINTF,
 251                            (char *) NOTE_BLOCK (in_rtx));
 252                 sawclose = 1;
 253                 break;
 254
 255               case NOTE_INSN_RANGE_BEG:
 256               case NOTE_INSN_RANGE_END:
 257               case NOTE_INSN_LIVE:
 258                 indent += 2;
 259                 if (!sawclose)
 260                   fprintf (outfile, " ");
 261                 print_rtx (NOTE_RANGE_INFO (in_rtx));
 262                 indent -= 2;
 263                 break;
 264
 265               case NOTE_INSN_BASIC_BLOCK:
 266                 {
 267                   basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
 268                   if (bb != 0)
 269                     fprintf (outfile, " [bb %d]", bb->index);
 270                   break;
 271                 }
 272
 273               case NOTE_INSN_EXPECTED_VALUE:
 274                 indent += 2;
 275                 if (!sawclose)
 276                   fprintf (outfile, " ");
 277                 print_rtx (NOTE_EXPECTED_VALUE (in_rtx));
 278                 indent -= 2;
 279                 break;
 280
 281               case NOTE_INSN_DELETED_LABEL:
 282                 if (NOTE_SOURCE_FILE (in_rtx))
 283                   fprintf (outfile, " (\"%s\")", NOTE_SOURCE_FILE (in_rtx));
 284                 else
 285                   fprintf (outfile, " \"\"");
 286                 break;
 287
 288               default:
 289                 {
 290                   const char * const str = X0STR (in_rtx, i);
 291
 292                   if (NOTE_LINE_NUMBER (in_rtx) < 0)
 293                     ;
 294                   else if (str == 0)
 295                     fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
 296                   else
 297                     {
 298                       if (dump_for_graph)
 299                         fprintf (outfile, " (\\\"%s\\\")", str);
 300                       else
 301                         fprintf (outfile, " (\"%s\")", str);
 302                     }
 303                   break;
 304                 }
 305               }
 306           }
 307         break;
 308
 309       case 'e':
 310       do_e:
 311         indent += 2;
 312         if (!sawclose)
 313           fprintf (outfile, " ");
 314         print_rtx (XEXP (in_rtx, i));
 315         indent -= 2;
 316         break;
 317
 318       case 'E':
 319       case 'V':
 320         indent += 2;
 321         if (sawclose)
 322           {
 323             fprintf (outfile, "\n%s%*s",
 324                      print_rtx_head, indent * 2, "");
 325             sawclose = 0;
 326           }
 327         fputs ("[ ", outfile);
 328         if (NULL != XVEC (in_rtx, i))
 329           {
 330             indent += 2;
 331             if (XVECLEN (in_rtx, i))
 332               sawclose = 1;
 333
 334             for (j = 0; j < XVECLEN (in_rtx, i); j++)
 335               print_rtx (XVECEXP (in_rtx, i, j));
 336
 337             indent -= 2;
 338           }
 339         if (sawclose)
 340           fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
 341
 342         fputs ("] ", outfile);
 343         sawclose = 1;
 344         indent -= 2;
 345         break;
 346
 347       case 'w':
 348         if (! flag_simple)
 349           fprintf (outfile, " ");
 350         fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
 351         if (! flag_simple)
 352           {
 353             fprintf (outfile, " [");
 354             fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, XWINT (in_rtx, i));
 355             fprintf (outfile, "]");
 356           }
 357         break;
 358
 359       case 'i':
 360         if (i == 5 && GET_CODE (in_rtx) == NOTE)
 361           {
 362             /* This field is only used for NOTE_INSN_DELETED_LABEL, and
 363                other times often contains garbage from INSN->NOTE death.  */
 364             if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_DELETED_LABEL)
 365               fprintf (outfile, " %d",  XINT (in_rtx, i));
 366           }
 367         else
 368           {
 369             int value = XINT (in_rtx, i);
 370             const char *name;
 371
 372             if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER)
 373               {
 374                 fputc (' ', outfile);
 375                 DEBUG_PRINT_REG (in_rtx, 0, outfile);
 376               }
 377             else if (GET_CODE (in_rtx) == REG
 378                      && value <= LAST_VIRTUAL_REGISTER)
 379               {
 380                 if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
 381                   fprintf (outfile, " %d virtual-incoming-args", value);
 382                 else if (value == VIRTUAL_STACK_VARS_REGNUM)
 383                   fprintf (outfile, " %d virtual-stack-vars", value);
 384                 else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
 385                   fprintf (outfile, " %d virtual-stack-dynamic", value);
 386                 else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
 387                   fprintf (outfile, " %d virtual-outgoing-args", value);
 388                 else if (value == VIRTUAL_CFA_REGNUM)
 389                   fprintf (outfile, " %d virtual-cfa", value);
 390                 else
 391                   fprintf (outfile, " %d virtual-reg-%d", value,
 392                            value-FIRST_VIRTUAL_REGISTER);
 393               }
 394             else if (flag_dump_unnumbered
 395                      && (is_insn || GET_CODE (in_rtx) == NOTE))
 396               fputc ('#', outfile);
 397             else
 398               fprintf (outfile, " %d", value);
 399
 400             if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
 401                 && XINT (in_rtx, i) >= 0
 402                 && (name = get_insn_name (XINT (in_rtx, i))) != NULL)
 403               fprintf (outfile, " {%s}", name);
 404             sawclose = 0;
 405           }
 406         break;
 407
 408       /* Print NOTE_INSN names rather than integer codes.  */
 409
 410       case 'n':
 411         if (XINT (in_rtx, i) >= (int) NOTE_INSN_BIAS
 412             && XINT (in_rtx, i) < (int) NOTE_INSN_MAX)
 413           fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
 414         else
 415           fprintf (outfile, " %d", XINT (in_rtx, i));
 416         sawclose = 0;
 417         break;
 418
 419       case 'u':
 420         if (XEXP (in_rtx, i) != NULL)
 421           {
 422             rtx sub = XEXP (in_rtx, i);
 423             enum rtx_code subc = GET_CODE (sub);
 424
 425             if (GET_CODE (in_rtx) == LABEL_REF)
 426               {
 427                 if (subc == NOTE
 428                     && NOTE_LINE_NUMBER (sub) == NOTE_INSN_DELETED_LABEL)
 429                   {
 430                     if (flag_dump_unnumbered)
 431                       fprintf (outfile, " [# deleted]");
 432                     else
 433                       fprintf (outfile, " [%d deleted]", INSN_UID (sub));
 434                     sawclose = 0;
 435                     break;
 436                   }
 437
 438                 if (subc != CODE_LABEL)
 439                   goto do_e;
 440               }
 441
 442             if (flag_dump_unnumbered)
 443               fputs (" #", outfile);
 444             else
 445               fprintf (outfile, " %d", INSN_UID (sub));
 446           }
 447         else
 448           fputs (" 0", outfile);
 449         sawclose = 0;
 450         break;
 451
 452       case 'b':
 453         if (XBITMAP (in_rtx, i) == NULL)
 454           fputs (" {null}", outfile);
 455         else
 456           bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
 457         sawclose = 0;
 458         break;
 459
 460       case 't':
 461         putc (' ', outfile);
 462         fprintf (outfile, HOST_PTR_PRINTF, (char *) XTREE (in_rtx, i));
 463         break;
 464
 465       case '*':
 466         fputs (" Unknown", outfile);
 467         sawclose = 0;
 468         break;
 469
 470       default:
 471         fprintf (stderr,
 472                  "switch format wrong in rtl.print_rtx(). format was: %c.\n",
 473                  format_ptr[-1]);
 474         abort ();
 475       }
 476
 477   switch (GET_CODE (in_rtx))
 478     {
 479     case MEM:
 480       fputs (" [", outfile);
 481       fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));
 482
 483       if (MEM_EXPR (in_rtx))
 484         print_mem_expr (outfile, MEM_EXPR (in_rtx));
 485
 486       if (MEM_OFFSET (in_rtx))
 487         {
 488           fputc ('+', outfile);
 489           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
 490                    INTVAL (MEM_OFFSET (in_rtx)));
 491         }
 492
 493       if (MEM_SIZE (in_rtx))
 494         {
 495           fputs (" S", outfile);
 496           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
 497                    INTVAL (MEM_SIZE (in_rtx)));
 498         }
 499
 500       if (MEM_ALIGN (in_rtx) != 1)
 501         fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
 502
 503       fputc (']', outfile);
 504       break;
 505
 506 #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && MAX_LONG_DOUBLE_TYPE_SIZE == 64
 507     case CONST_DOUBLE:
 508       if (FLOAT_MODE_P (GET_MODE (in_rtx)))
 509         {
 510           double val;
 511           REAL_VALUE_FROM_CONST_DOUBLE (val, in_rtx);
 512           fprintf (outfile, " [%.16g]", val);
 513         }
 514       break;
 515 #endif
 516
 517     case CODE_LABEL:
 518       fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
 519       if (LABEL_ALTERNATE_NAME (in_rtx))
 520         fprintf (outfile, " [alternate name: %s]",
 521                  LABEL_ALTERNATE_NAME (in_rtx));
 522       break;
 523
 524     case CALL_PLACEHOLDER:
 525       if (debug_call_placeholder_verbose)
 526         {
 527           fputs (" (cond [\n  (const_string \"normal\") (sequence [", outfile);
 528           for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem))
 529             {
 530               fputs ("\n    ", outfile);
 531               print_inline_rtx (outfile, tem, 4);
 532             }
 533
 534           tem = XEXP (in_rtx, 1);
 535           if (tem)
 536             fputs ("\n    ])\n  (const_string \"tail_call\") (sequence [",
 537                    outfile);
 538           for (; tem != 0; tem = NEXT_INSN (tem))
 539             {
 540               fputs ("\n    ", outfile);
 541               print_inline_rtx (outfile, tem, 4);
 542             }
 543
 544           tem = XEXP (in_rtx, 2);
 545           if (tem)
 546             fputs ("\n    ])\n  (const_string \"tail_recursion\") (sequence [",
 547                    outfile);
 548           for (; tem != 0; tem = NEXT_INSN (tem))
 549             {
 550               fputs ("\n    ", outfile);
 551               print_inline_rtx (outfile, tem, 4);
 552             }
 553
 554           fputs ("\n    ])\n  ])", outfile);
 555           break;
 556         }
 557
 558       for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem))
 559         if (GET_CODE (tem) == CALL_INSN)
 560           {
 561             fprintf (outfile, " ");
 562             print_rtx (tem);
 563             break;
 564           }
 565       break;
 566
 567     default:
 568       break;
 569     }
 570
 571   if (dump_for_graph
 572       && (is_insn || GET_CODE (in_rtx) == NOTE
 573           || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER))
 574     sawclose = 0;
 575   else
 576     {
 577       fputc (')', outfile);
 578       sawclose = 1;
 579     }
 580 }
 581
 582 /* Print an rtx on the current line of FILE.  Initially indent IND
 583    characters.  */
 584
 585 void
 586 print_inline_rtx (outf, x, ind)
 587      FILE *outf;
 588      rtx x;
 589      int ind;
 590 {
 591   int oldsaw = sawclose;
 592   int oldindent = indent;
 593
 594   sawclose = 0;
 595   indent = ind;
 596   outfile = outf;
 597   print_rtx (x);
 598   sawclose = oldsaw;
 599   indent = oldindent;
 600 }
 601
 602 /* Call this function from the debugger to see what X looks like.  */
 603
 604 void
 605 debug_rtx (x)
 606      rtx x;
 607 {
 608   outfile = stderr;
 609   print_rtx (x);
 610   fprintf (stderr, "\n");
 611 }
 612
 613 /* Count of rtx's to print with debug_rtx_list.
 614    This global exists because gdb user defined commands have no arguments.  */
 615
 616 int debug_rtx_count = 0;        /* 0 is treated as equivalent to 1 */
 617
 618 /* Call this function to print list from X on.
 619
 620    N is a count of the rtx's to print. Positive values print from the specified
 621    rtx on.  Negative values print a window around the rtx.
 622    EG: -5 prints 2 rtx's on either side (in addition to the specified rtx).  */
 623
 624 void
 625 debug_rtx_list (x, n)
 626      rtx x;
 627      int n;
 628 {
 629   int i,count;
 630   rtx insn;
 631
 632   count = n == 0 ? 1 : n < 0 ? -n : n;
 633
 634   /* If we are printing a window, back up to the start.  */
 635
 636   if (n < 0)
 637     for (i = count / 2; i > 0; i--)
 638       {
 639         if (PREV_INSN (x) == 0)
 640           break;
 641         x = PREV_INSN (x);
 642       }
 643
 644   for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
 645     debug_rtx (insn);
 646 }
 647
 648 /* Call this function to print an rtx list from START to END inclusive.  */
 649
 650 void
 651 debug_rtx_range (start, end)
 652      rtx start, end;
 653 {
 654   while (1)
 655     {
 656       debug_rtx (start);
 657       if (!start || start == end)
 658         break;
 659       start = NEXT_INSN (start);
 660     }
 661 }
 662
 663 /* Call this function to search an rtx list to find one with insn uid UID,
 664    and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
 665    The found insn is returned to enable further debugging analysis.  */
 666
 667 rtx
 668 debug_rtx_find (x, uid)
 669      rtx x;
 670      int uid;
 671 {
 672   while (x != 0 && INSN_UID (x) != uid)
 673     x = NEXT_INSN (x);
 674   if (x != 0)
 675     {
 676       debug_rtx_list (x, debug_rtx_count);
 677       return x;
 678     }
 679   else
 680     {
 681       fprintf (stderr, "insn uid %d not found\n", uid);
 682       return 0;
 683     }
 684 }
 685
 686 /* External entry point for printing a chain of insns
 687    starting with RTX_FIRST onto file OUTF.
 688    A blank line separates insns.
 689
 690    If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */
 691
 692 void
 693 print_rtl (outf, rtx_first)
 694      FILE *outf;
 695      rtx rtx_first;
 696 {
 697   rtx tmp_rtx;
 698
 699   outfile = outf;
 700   sawclose = 0;
 701
 702   if (rtx_first == 0)
 703     {
 704       fputs (print_rtx_head, outf);
 705       fputs ("(nil)\n", outf);
 706     }
 707   else
 708     switch (GET_CODE (rtx_first))
 709       {
 710       case INSN:
 711       case JUMP_INSN:
 712       case CALL_INSN:
 713       case NOTE:
 714       case CODE_LABEL:
 715       case BARRIER:
 716         for (tmp_rtx = rtx_first; tmp_rtx != 0; tmp_rtx = NEXT_INSN (tmp_rtx))
 717           if (! flag_dump_unnumbered
 718               || GET_CODE (tmp_rtx) != NOTE || NOTE_LINE_NUMBER (tmp_rtx) < 0)
 719             {
 720               fputs (print_rtx_head, outfile);
 721               print_rtx (tmp_rtx);
 722               fprintf (outfile, "\n");
 723             }
 724         break;
 725
 726       default:
 727         fputs (print_rtx_head, outfile);
 728         print_rtx (rtx_first);
 729       }
 730 }
 731
 732 /* Like print_rtx, except specify a file.  */
 733 /* Return nonzero if we actually printed anything.  */
 734
 735 int
 736 print_rtl_single (outf, x)
 737      FILE *outf;
 738      rtx x;
 739 {
 740   outfile = outf;
 741   sawclose = 0;
 742   if (! flag_dump_unnumbered
 743       || GET_CODE (x) != NOTE || NOTE_LINE_NUMBER (x) < 0)
 744     {
 745       fputs (print_rtx_head, outfile);
 746       print_rtx (x);
 747       putc ('\n', outf);
 748       return 1;
 749     }
 750   return 0;
 751 }
 752
 753
 754 /* Like print_rtl except without all the detail; for example,
 755    if RTX is a CONST_INT then print in decimal format.  */
 756
 757 void
 758 print_simple_rtl (outf, x)
 759      FILE *outf;
 760      rtx x;
 761 {
 762   flag_simple = 1;
 763   print_rtl (outf, x);
 764   flag_simple = 0;
 765 }