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