[gcc.git] / gcc / print-rtl.c

/* Print RTL for GNU C Compiler.
   Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


#include "config.h"
#include "system.h"
#include "rtl.h"
#include "real.h"
#include "flags.h"
#include "basic-block.h"


/* How to print out a register name.
   We don't use PRINT_REG because some definitions of PRINT_REG
   don't work here.  */
#ifndef DEBUG_PRINT_REG
#define DEBUG_PRINT_REG(RTX, CODE, FILE) \
  fprintf ((FILE), "%d %s", REGNO (RTX), reg_names[REGNO (RTX)])
#endif

/* Array containing all of the register names */

#ifdef DEBUG_REGISTER_NAMES
static const char * const reg_names[] = DEBUG_REGISTER_NAMES;
#else
static const char * const reg_names[] = REGISTER_NAMES;
#endif

static FILE *outfile;

static const char xspaces[] = "                                                                                                                                                                ";

static int sawclose = 0;

static int indent;

/* Names for patterns.  Non-zero only when linked with insn-output.c.  */

extern char **insn_name_ptr;

static void print_rtx		PROTO ((rtx));

/* Nonzero means suppress output of instruction numbers and line number
   notes in debugging dumps.
   This must be defined here so that programs like gencodes can be linked.  */
int flag_dump_unnumbered = 0;

/* Nonzero if we are dumping graphical description.  */
int dump_for_graph;

/* Print IN_RTX onto OUTFILE.  This is the recursive part of printing.  */

static void
print_rtx (in_rtx)
     register rtx in_rtx;
{
  register int i = 0;
  register int j;
  register const char *format_ptr;
  register int is_insn;

  if (sawclose)
    {
      fprintf (outfile, "\n%s",
	       (xspaces + (sizeof xspaces - 1 - indent * 2)));
      sawclose = 0;
    }

  if (in_rtx == 0)
    {
      fputs ("(nil)", outfile);
      sawclose = 1;
      return;
    }

  is_insn = (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i');

  /* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
     in separate nodes and therefore have to handle them special here.  */
  if (dump_for_graph &&
      (is_insn || GET_CODE (in_rtx) == NOTE || GET_CODE (in_rtx) == CODE_LABEL
       || GET_CODE (in_rtx) == BARRIER))
    {
      i = 3;
      indent = 0;
    }
  else
    {
      /* print name of expression code */
      fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));

      if (in_rtx->in_struct)
	fputs ("/s", outfile);

      if (in_rtx->volatil)
	fputs ("/v", outfile);

      if (in_rtx->unchanging)
	fputs ("/u", outfile);

      if (in_rtx->integrated)
	fputs ("/i", outfile);

      if (in_rtx->frame_related)
	fputs ("/f", outfile);

      if (in_rtx->jump)
	fputs ("/j", outfile);

      if (in_rtx->call)
	fputs ("/c", outfile);

      if (GET_MODE (in_rtx) != VOIDmode)
	{
	  /* Print REG_NOTE names for EXPR_LIST and INSN_LIST.  */
	  if (GET_CODE (in_rtx) == EXPR_LIST || GET_CODE (in_rtx) == INSN_LIST)
	    fprintf (outfile, ":%s", GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
	  else
	    fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
	}
    }

  /* Get the format string and skip the first elements if we have handled
     them already.  */
  format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;

  for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
    switch (*format_ptr++)
      {
      case 'S':
      case 's':
	if (XSTR (in_rtx, i) == 0)
	  fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
	else
	  fprintf (outfile, dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")",
		   XSTR (in_rtx, i));
	sawclose = 1;
	break;

	/* 0 indicates a field for internal use that should not be printed.
	   An exception is the third field of a NOTE, where it indicates
	   that the field has several different valid contents.  */
      case '0':
	if (i == 3 && GET_CODE (in_rtx) == NOTE)
	  {
	    if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_BEG
		|| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_END
		|| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_BEG
		|| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_END)
	      {
		fprintf (outfile, " %d", NOTE_BLOCK_NUMBER (in_rtx));
		sawclose = 1;
	      }
	    else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_START
		     || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_END
		     || NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_LIVE)
	      {
		indent += 2;
		if (!sawclose)
		  fprintf (outfile, " ");
		print_rtx (NOTE_RANGE_INFO (in_rtx));
		indent -= 2;
	      }
	    else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BASIC_BLOCK)
	      {
		basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
		fprintf (outfile, " [bb %d]", bb->index);
	      }
	    else
	      {
		/* Can't use XSTR because of type checking.  */
		char *str = in_rtx->fld[i].rtstr;
		if (str == 0)
		  fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
		else
		  fprintf (outfile,
			   dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")",
			   str);
	      }
	  }
	break;

      case 'e':
	indent += 2;
	if (!sawclose)
	  fprintf (outfile, " ");
	print_rtx (XEXP (in_rtx, i));
	indent -= 2;
	break;

      case 'E':
      case 'V':
	indent += 2;
	if (sawclose)
	  {
	    fprintf (outfile, "\n%s",
		     (xspaces + (sizeof xspaces - 1 - indent * 2)));
	    sawclose = 0;
	  }
	fputs ("[ ", outfile);
	if (NULL != XVEC (in_rtx, i))
	  {
	    indent += 2;
	    if (XVECLEN (in_rtx, i))
	      sawclose = 1;

	    for (j = 0; j < XVECLEN (in_rtx, i); j++)
	      print_rtx (XVECEXP (in_rtx, i, j));

	    indent -= 2;
	  }
	if (sawclose)
	  fprintf (outfile, "\n%s",
		   (xspaces + (sizeof xspaces - 1 - indent * 2)));

	fputs ("] ", outfile);
	sawclose = 1;
	indent -= 2;
	break;

      case 'w':
	fprintf (outfile, " ");
	fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
	fprintf (outfile, " [");
	fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, XWINT (in_rtx, i));
	fprintf (outfile, "]");
	break;

      case 'i':
	{
	  register int value = XINT (in_rtx, i);

	  if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER)
	    {
	      fputc (' ', outfile);
	      DEBUG_PRINT_REG (in_rtx, 0, outfile);
	    }
	  else if (GET_CODE (in_rtx) == REG && value <= LAST_VIRTUAL_REGISTER)
	    {
	      if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
		fprintf (outfile, " %d virtual-incoming-args", value);
	      else if (value == VIRTUAL_STACK_VARS_REGNUM)
		fprintf (outfile, " %d virtual-stack-vars", value);
	      else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
		fprintf (outfile, " %d virtual-stack-dynamic", value);
	      else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
		fprintf (outfile, " %d virtual-outgoing-args", value);
	      else if (value == VIRTUAL_CFA_REGNUM)
		fprintf (outfile, " %d virtual-cfa", value);
	      else
		fprintf (outfile, " %d virtual-reg-%d", value,
			 value-FIRST_VIRTUAL_REGISTER);
	    }
	  else if (flag_dump_unnumbered
		   && (is_insn || GET_CODE (in_rtx) == NOTE))
	    fputc ('#', outfile);
	  else
	    fprintf (outfile, " %d", value);
	}
	if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
	    && insn_name_ptr
	    && XINT (in_rtx, i) >= 0)
	  fprintf (outfile, " {%s}", insn_name_ptr[XINT (in_rtx, i)]);
	sawclose = 0;
	break;

      /* Print NOTE_INSN names rather than integer codes.  */

      case 'n':
	if (XINT (in_rtx, i) <= 0)
	  fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
	else
	  fprintf (outfile, " %d", XINT (in_rtx, i));
	sawclose = 0;
	break;

      case 'u':
	if (XEXP (in_rtx, i) != NULL)
	  {
	    if (flag_dump_unnumbered)
	      fputc ('#', outfile);
	    else
	      fprintf (outfile, " %d", INSN_UID (XEXP (in_rtx, i)));
	  }
	else
	  fputs (" 0", outfile);
	sawclose = 0;
	break;

      case 'b':
	if (XBITMAP (in_rtx, i) == NULL)
	  fputs (" {null}", outfile);
	else
	  bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
	sawclose = 0;
	break;

      case 't':
	putc (' ', outfile);
	fprintf (outfile, HOST_PTR_PRINTF, (char *) XTREE (in_rtx, i));
	break;

      case '*':
	fputs (" Unknown", outfile);
	sawclose = 0;
	break;

      default:
	fprintf (stderr,
		 "switch format wrong in rtl.print_rtx(). format was: %c.\n",
		 format_ptr[-1]);
	abort ();
      }

  if (GET_CODE (in_rtx) == MEM)
    fprintf (outfile, " %d", MEM_ALIAS_SET (in_rtx));

#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && LONG_DOUBLE_TYPE_SIZE == 64
  if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx)))
    {
      double val;
      REAL_VALUE_FROM_CONST_DOUBLE (val, in_rtx);
      fprintf (outfile, " [%.16g]", val);
    }
#endif

  if (GET_CODE (in_rtx) == CODE_LABEL)
    fprintf (outfile, " [num uses: %d]", LABEL_NUSES (in_rtx));
  
  if (dump_for_graph
      && (is_insn || GET_CODE (in_rtx) == NOTE
	  || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER))
    sawclose = 0;
  else
    {
      fputc (')', outfile);
      sawclose = 1;
    }
}

/* Print an rtx on the current line of FILE.  Initially indent IND
   characters.  */

void
print_inline_rtx (outf, x, ind)
     FILE *outf;
     rtx x;
     int ind;
{
  int oldsaw = sawclose;
  int oldindent = indent;

  sawclose = 0;
  indent = ind;
  outfile = outf;
  print_rtx (x);
  sawclose = oldsaw;
  indent = oldindent;
}

/* Call this function from the debugger to see what X looks like.  */

void
debug_rtx (x)
     rtx x;
{
  outfile = stderr;
  print_rtx (x);
  fprintf (stderr, "\n");
}

/* Count of rtx's to print with debug_rtx_list.
   This global exists because gdb user defined commands have no arguments.  */

int debug_rtx_count = 0;	/* 0 is treated as equivalent to 1 */

/* Call this function to print list from X on.

   N is a count of the rtx's to print. Positive values print from the specified
   rtx on.  Negative values print a window around the rtx.
   EG: -5 prints 2 rtx's on either side (in addition to the specified rtx).  */

void
debug_rtx_list (x, n)
     rtx x;
     int n;
{
  int i,count;
  rtx insn;

  count = n == 0 ? 1 : n < 0 ? -n : n;

  /* If we are printing a window, back up to the start.  */

  if (n < 0)
    for (i = count / 2; i > 0; i--)
      {
	if (PREV_INSN (x) == 0)
	  break;
	x = PREV_INSN (x);
      }

  for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
    debug_rtx (insn);
}

/* Call this function to search an rtx list to find one with insn uid UID,
   and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
   The found insn is returned to enable further debugging analysis.  */

rtx
debug_rtx_find (x, uid)
     rtx x;
     int uid;
{
  while (x != 0 && INSN_UID (x) != uid)
    x = NEXT_INSN (x);
  if (x != 0)
    {
      debug_rtx_list (x, debug_rtx_count);
      return x;
    }
  else
    {
      fprintf (stderr, "insn uid %d not found\n", uid);
      return 0;
    }
}

/* External entry point for printing a chain of insns
   starting with RTX_FIRST onto file OUTF.
   A blank line separates insns.

   If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */

void
print_rtl (outf, rtx_first)
     FILE *outf;
     rtx rtx_first;
{
  register rtx tmp_rtx;

  outfile = outf;
  sawclose = 0;

  if (rtx_first == 0)
    fputs ("(nil)\n", outf);
  else
    switch (GET_CODE (rtx_first))
      {
      case INSN:
      case JUMP_INSN:
      case CALL_INSN:
      case NOTE:
      case CODE_LABEL:
      case BARRIER:
	for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
	  {
	    if (! flag_dump_unnumbered
		|| GET_CODE (tmp_rtx) != NOTE
		|| NOTE_LINE_NUMBER (tmp_rtx) < 0)
	      {
		print_rtx (tmp_rtx);
		fprintf (outfile, "\n");
	      }
	  }
	break;

      default:
	print_rtx (rtx_first);
      }
}

/* Like print_rtx, except specify a file.  */
/* Return nonzero if we actually printed anything.  */

int
print_rtl_single (outf, x)
     FILE *outf;
     rtx x;
{
  outfile = outf;
  sawclose = 0;
  if (! flag_dump_unnumbered
      || GET_CODE (x) != NOTE || NOTE_LINE_NUMBER (x) < 0)
    {
      print_rtx (x);
      putc ('\n', outf);
      return 1;
    }
  return 0;
}
Commit	Line	Data
e1a79915	1	/* Print RTL for GNU C Compiler.
a6c7a886	2	Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
e1a79915 RS	3
	4	This file is part of GNU CC.
	5
	6	GNU CC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU CC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU CC; see the file COPYING. If not, write to
e99215a3 RK	18	the Free Software Foundation, 59 Temple Place - Suite 330,
e99215a3 RK	19	Boston, MA 02111-1307, USA. */
e1a79915 RS	20
	21
	22	#include "config.h"
670ee920	23	#include "system.h"
e1a79915	24	#include "rtl.h"
800d5c9e	25	#include "real.h"
b707b450	26	#include "flags.h"
e881bb1b	27	#include "basic-block.h"
e1a79915 RS	28
e1a79915 RS	29
cf99a734 RS	30	/* How to print out a register name.
	31	We don't use PRINT_REG because some definitions of PRINT_REG
	32	don't work here. */
	33	#ifndef DEBUG_PRINT_REG
	34	#define DEBUG_PRINT_REG(RTX, CODE, FILE) \
	35	fprintf ((FILE), "%d %s", REGNO (RTX), reg_names[REGNO (RTX)])
	36	#endif
	37
	38	/* Array containing all of the register names */
	39
	40	#ifdef DEBUG_REGISTER_NAMES
6f7d635c	41	static const char * const reg_names[] = DEBUG_REGISTER_NAMES;
cf99a734	42	#else
6f7d635c	43	static const char * const reg_names[] = REGISTER_NAMES;
cf99a734 RS	44	#endif
cf99a734 RS	45
e1a79915 RS	46	static FILE *outfile;
e1a79915 RS	47
2778b98d	48	static const char xspaces[] = " ";
e1a79915 RS	49
	50	static int sawclose = 0;
	51
1d79197a RK	52	static int indent;
1d79197a RK	53
e1a79915 RS	54	/* Names for patterns. Non-zero only when linked with insn-output.c. */
	55
	56	extern char **insn_name_ptr;
	57
5edc9230 L	58	static void print_rtx PROTO ((rtx));
5edc9230 L	59
b707b450 R	60	/* Nonzero means suppress output of instruction numbers and line number
	61	notes in debugging dumps.
	62	This must be defined here so that programs like gencodes can be linked. */
9ec36da5	63	int flag_dump_unnumbered = 0;
b707b450	64
735a0e33 UD	65	/* Nonzero if we are dumping graphical description. */
	66	int dump_for_graph;
	67
e1a79915 RS	68	/* Print IN_RTX onto OUTFILE. This is the recursive part of printing. */
	69
	70	static void
	71	print_rtx (in_rtx)
	72	register rtx in_rtx;
	73	{
735a0e33 UD	74	register int i = 0;
735a0e33 UD	75	register int j;
6f7d635c	76	register const char *format_ptr;
e1a79915 RS	77	register int is_insn;
	78
	79	if (sawclose)
	80	{
	81	fprintf (outfile, "\n%s",
2778b98d	82	(xspaces + (sizeof xspaces - 1 - indent * 2)));
e1a79915 RS	83	sawclose = 0;
	84	}
	85
	86	if (in_rtx == 0)
	87	{
735a0e33	88	fputs ("(nil)", outfile);
e1a79915 RS	89	sawclose = 1;
	90	return;
	91	}
	92
735a0e33 UD	93	is_insn = (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i');
	94
	95	/* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
	96	in separate nodes and therefore have to handle them special here. */
	97	if (dump_for_graph &&
	98	(is_insn \|\| GET_CODE (in_rtx) == NOTE \|\| GET_CODE (in_rtx) == CODE_LABEL
	99	\|\| GET_CODE (in_rtx) == BARRIER))
	100	{
	101	i = 3;
	102	indent = 0;
	103	}
	104	else
	105	{
	106	/* print name of expression code */
	107	fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
e1a79915	108
735a0e33 UD	109	if (in_rtx->in_struct)
735a0e33 UD	110	fputs ("/s", outfile);
e1a79915	111
735a0e33 UD	112	if (in_rtx->volatil)
735a0e33 UD	113	fputs ("/v", outfile);
e1a79915	114
735a0e33 UD	115	if (in_rtx->unchanging)
735a0e33 UD	116	fputs ("/u", outfile);
e1a79915	117
735a0e33 UD	118	if (in_rtx->integrated)
735a0e33 UD	119	fputs ("/i", outfile);
e1a79915	120
c6df88cb MM	121	if (in_rtx->frame_related)
	122	fputs ("/f", outfile);
	123
5a25c64c JL	124	if (in_rtx->jump)
	125	fputs ("/j", outfile);
	126
	127	if (in_rtx->call)
	128	fputs ("/c", outfile);
	129
735a0e33 UD	130	if (GET_MODE (in_rtx) != VOIDmode)
	131	{
	132	/* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
	133	if (GET_CODE (in_rtx) == EXPR_LIST \|\| GET_CODE (in_rtx) == INSN_LIST)
	134	fprintf (outfile, ":%s", GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
	135	else
	136	fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
	137	}
e1a79915 RS	138	}
e1a79915 RS	139
735a0e33 UD	140	/* Get the format string and skip the first elements if we have handled
	141	them already. */
	142	format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
e1a79915	143
735a0e33	144	for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
e1a79915 RS	145	switch (*format_ptr++)
	146	{
	147	case 'S':
	148	case 's':
	149	if (XSTR (in_rtx, i) == 0)
735a0e33	150	fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
e1a79915	151	else
735a0e33 UD	152	fprintf (outfile, dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")",
735a0e33 UD	153	XSTR (in_rtx, i));
e1a79915 RS	154	sawclose = 1;
	155	break;
	156
8f985ec4 ZW	157	/* 0 indicates a field for internal use that should not be printed.
	158	An exception is the third field of a NOTE, where it indicates
	159	that the field has several different valid contents. */
e1a79915	160	case '0':
8f985ec4 ZW	161	if (i == 3 && GET_CODE (in_rtx) == NOTE)
	162	{
	163	if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_BEG
	164	\|\| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_EH_REGION_END
	165	\|\| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_BEG
	166	\|\| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BLOCK_END)
	167	{
	168	fprintf (outfile, " %d", NOTE_BLOCK_NUMBER (in_rtx));
	169	sawclose = 1;
	170	}
	171	else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_START
	172	\|\| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_RANGE_END
	173	\|\| NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_LIVE)
	174	{
	175	indent += 2;
	176	if (!sawclose)
	177	fprintf (outfile, " ");
	178	print_rtx (NOTE_RANGE_INFO (in_rtx));
	179	indent -= 2;
	180	}
	181	else if (NOTE_LINE_NUMBER (in_rtx) == NOTE_INSN_BASIC_BLOCK)
	182	{
	183	basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
	184	fprintf (outfile, " [bb %d]", bb->index);
	185	}
	186	else
	187	{
	188	/* Can't use XSTR because of type checking. */
	189	char *str = in_rtx->fld[i].rtstr;
	190	if (str == 0)
	191	fputs (dump_for_graph ? " \\\"\\\"" : " \"\"", outfile);
	192	else
	193	fprintf (outfile,
	194	dump_for_graph ? " (\\\"%s\\\")" : " (\"%s\")",
	195	str);
	196	}
	197	}
e1a79915 RS	198	break;
	199
	200	case 'e':
	201	indent += 2;
	202	if (!sawclose)
	203	fprintf (outfile, " ");
	204	print_rtx (XEXP (in_rtx, i));
	205	indent -= 2;
	206	break;
	207
	208	case 'E':
	209	case 'V':
	210	indent += 2;
	211	if (sawclose)
	212	{
	213	fprintf (outfile, "\n%s",
2778b98d	214	(xspaces + (sizeof xspaces - 1 - indent * 2)));
e1a79915 RS	215	sawclose = 0;
e1a79915 RS	216	}
735a0e33	217	fputs ("[ ", outfile);
e1a79915 RS	218	if (NULL != XVEC (in_rtx, i))
	219	{
	220	indent += 2;
	221	if (XVECLEN (in_rtx, i))
	222	sawclose = 1;
	223
	224	for (j = 0; j < XVECLEN (in_rtx, i); j++)
	225	print_rtx (XVECEXP (in_rtx, i, j));
	226
	227	indent -= 2;
	228	}
	229	if (sawclose)
	230	fprintf (outfile, "\n%s",
2778b98d	231	(xspaces + (sizeof xspaces - 1 - indent * 2)));
e1a79915	232
735a0e33	233	fputs ("] ", outfile);
e1a79915 RS	234	sawclose = 1;
	235	indent -= 2;
	236	break;
	237
5bf665df	238	case 'w':
734de8c8 RK	239	fprintf (outfile, " ");
734de8c8 RK	240	fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
7b028dba NC	241	fprintf (outfile, " [");
	242	fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, XWINT (in_rtx, i));
	243	fprintf (outfile, "]");
5bf665df RK	244	break;
5bf665df RK	245
e1a79915	246	case 'i':
cf99a734 RS	247	{
	248	register int value = XINT (in_rtx, i);
	249
	250	if (GET_CODE (in_rtx) == REG && value < FIRST_PSEUDO_REGISTER)
	251	{
	252	fputc (' ', outfile);
	253	DEBUG_PRINT_REG (in_rtx, 0, outfile);
	254	}
a6c7a886 MM	255	else if (GET_CODE (in_rtx) == REG && value <= LAST_VIRTUAL_REGISTER)
	256	{
	257	if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
	258	fprintf (outfile, " %d virtual-incoming-args", value);
	259	else if (value == VIRTUAL_STACK_VARS_REGNUM)
	260	fprintf (outfile, " %d virtual-stack-vars", value);
	261	else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
	262	fprintf (outfile, " %d virtual-stack-dynamic", value);
	263	else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
	264	fprintf (outfile, " %d virtual-outgoing-args", value);
	265	else if (value == VIRTUAL_CFA_REGNUM)
	266	fprintf (outfile, " %d virtual-cfa", value);
	267	else
	268	fprintf (outfile, " %d virtual-reg-%d", value,
	269	value-FIRST_VIRTUAL_REGISTER);
	270	}
9ec36da5 JL	271	else if (flag_dump_unnumbered
9ec36da5 JL	272	&& (is_insn \|\| GET_CODE (in_rtx) == NOTE))
735a0e33	273	fputc ('#', outfile);
cf99a734 RS	274	else
	275	fprintf (outfile, " %d", value);
	276	}
e1a79915 RS	277	if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
	278	&& insn_name_ptr
	279	&& XINT (in_rtx, i) >= 0)
cf99a734	280	fprintf (outfile, " {%s}", insn_name_ptr[XINT (in_rtx, i)]);
e1a79915 RS	281	sawclose = 0;
	282	break;
	283
	284	/* Print NOTE_INSN names rather than integer codes. */
	285
	286	case 'n':
	287	if (XINT (in_rtx, i) <= 0)
	288	fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
	289	else
	290	fprintf (outfile, " %d", XINT (in_rtx, i));
	291	sawclose = 0;
	292	break;
	293
	294	case 'u':
	295	if (XEXP (in_rtx, i) != NULL)
9ec36da5 JL	296	{
9ec36da5 JL	297	if (flag_dump_unnumbered)
735a0e33	298	fputc ('#', outfile);
9ec36da5 JL	299	else
	300	fprintf (outfile, " %d", INSN_UID (XEXP (in_rtx, i)));
	301	}
e1a79915	302	else
735a0e33	303	fputs (" 0", outfile);
d64be5ec CH	304	sawclose = 0;
	305	break;
	306
0dfa1860 MM	307	case 'b':
0dfa1860 MM	308	if (XBITMAP (in_rtx, i) == NULL)
735a0e33	309	fputs (" {null}", outfile);
0dfa1860 MM	310	else
	311	bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
	312	sawclose = 0;
	313	break;
	314
	315	case 't':
	316	putc (' ', outfile);
c6b0465b	317	fprintf (outfile, HOST_PTR_PRINTF, (char *) XTREE (in_rtx, i));
0dfa1860 MM	318	break;
0dfa1860 MM	319
d64be5ec	320	case '*':
735a0e33	321	fputs (" Unknown", outfile);
e1a79915 RS	322	sawclose = 0;
	323	break;
	324
	325	default:
	326	fprintf (stderr,
	327	"switch format wrong in rtl.print_rtx(). format was: %c.\n",
	328	format_ptr[-1]);
	329	abort ();
	330	}
	331
5a0a1a66 BS	332	if (GET_CODE (in_rtx) == MEM)
	333	fprintf (outfile, " %d", MEM_ALIAS_SET (in_rtx));
	334
61632854	335	#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT && LONG_DOUBLE_TYPE_SIZE == 64
800d5c9e RH	336	if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx)))
800d5c9e RH	337	{
5dd2add6	338	double val;
800d5c9e RH	339	REAL_VALUE_FROM_CONST_DOUBLE (val, in_rtx);
	340	fprintf (outfile, " [%.16g]", val);
	341	}
	342	#endif
	343
75c437de NC	344	if (GET_CODE (in_rtx) == CODE_LABEL)
	345	fprintf (outfile, " [num uses: %d]", LABEL_NUSES (in_rtx));
	346
735a0e33 UD	347	if (dump_for_graph
	348	&& (is_insn \|\| GET_CODE (in_rtx) == NOTE
	349	\|\| GET_CODE (in_rtx) == CODE_LABEL \|\| GET_CODE (in_rtx) == BARRIER))
	350	sawclose = 0;
	351	else
	352	{
	353	fputc (')', outfile);
	354	sawclose = 1;
	355	}
e1a79915 RS	356	}
e1a79915 RS	357
1d79197a RK	358	/* Print an rtx on the current line of FILE. Initially indent IND
	359	characters. */
	360
	361	void
	362	print_inline_rtx (outf, x, ind)
	363	FILE *outf;
	364	rtx x;
9870475c	365	int ind;
1d79197a	366	{
956d6950 JL	367	int oldsaw = sawclose;
	368	int oldindent = indent;
	369
1d79197a RK	370	sawclose = 0;
	371	indent = ind;
	372	outfile = outf;
	373	print_rtx (x);
956d6950 JL	374	sawclose = oldsaw;
956d6950 JL	375	indent = oldindent;
1d79197a RK	376	}
1d79197a RK	377
e1a79915 RS	378	/* Call this function from the debugger to see what X looks like. */
	379
	380	void
	381	debug_rtx (x)
	382	rtx x;
	383	{
	384	outfile = stderr;
	385	print_rtx (x);
	386	fprintf (stderr, "\n");
	387	}
	388
716f003f DE	389	/* Count of rtx's to print with debug_rtx_list.
	390	This global exists because gdb user defined commands have no arguments. */
	391
	392	int debug_rtx_count = 0; /* 0 is treated as equivalent to 1 */
	393
	394	/* Call this function to print list from X on.
	395
	396	N is a count of the rtx's to print. Positive values print from the specified
	397	rtx on. Negative values print a window around the rtx.
	398	EG: -5 prints 2 rtx's on either side (in addition to the specified rtx). */
	399
	400	void
	401	debug_rtx_list (x, n)
	402	rtx x;
	403	int n;
	404	{
	405	int i,count;
	406	rtx insn;
	407
	408	count = n == 0 ? 1 : n < 0 ? -n : n;
	409
	410	/* If we are printing a window, back up to the start. */
	411
	412	if (n < 0)
	413	for (i = count / 2; i > 0; i--)
	414	{
	415	if (PREV_INSN (x) == 0)
	416	break;
	417	x = PREV_INSN (x);
	418	}
	419
	420	for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
	421	debug_rtx (insn);
	422	}
	423
	424	/* Call this function to search an rtx list to find one with insn uid UID,
	425	and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
	426	The found insn is returned to enable further debugging analysis. */
	427
	428	rtx
1d79197a	429	debug_rtx_find (x, uid)
716f003f DE	430	rtx x;
	431	int uid;
	432	{
	433	while (x != 0 && INSN_UID (x) != uid)
	434	x = NEXT_INSN (x);
	435	if (x != 0)
	436	{
	437	debug_rtx_list (x, debug_rtx_count);
	438	return x;
	439	}
	440	else
	441	{
	442	fprintf (stderr, "insn uid %d not found\n", uid);
	443	return 0;
	444	}
	445	}
	446
e1a79915 RS	447	/* External entry point for printing a chain of insns
	448	starting with RTX_FIRST onto file OUTF.
	449	A blank line separates insns.
	450
	451	If RTX_FIRST is not an insn, then it alone is printed, with no newline. */
	452
	453	void
	454	print_rtl (outf, rtx_first)
	455	FILE *outf;
	456	rtx rtx_first;
	457	{
	458	register rtx tmp_rtx;
	459
	460	outfile = outf;
	461	sawclose = 0;
	462
	463	if (rtx_first == 0)
735a0e33	464	fputs ("(nil)\n", outf);
e1a79915 RS	465	else
	466	switch (GET_CODE (rtx_first))
	467	{
	468	case INSN:
	469	case JUMP_INSN:
	470	case CALL_INSN:
	471	case NOTE:
	472	case CODE_LABEL:
	473	case BARRIER:
	474	for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
	475	{
9ec36da5 JL	476	if (! flag_dump_unnumbered
	477	\|\| GET_CODE (tmp_rtx) != NOTE
	478	\|\| NOTE_LINE_NUMBER (tmp_rtx) < 0)
	479	{
	480	print_rtx (tmp_rtx);
	481	fprintf (outfile, "\n");
	482	}
e1a79915 RS	483	}
	484	break;
	485
	486	default:
	487	print_rtx (rtx_first);
	488	}
	489	}
3e28fe44 MM	490
3e28fe44 MM	491	/* Like print_rtx, except specify a file. */
b707b450	492	/* Return nonzero if we actually printed anything. */
3e28fe44	493
b707b450	494	int
3e28fe44 MM	495	print_rtl_single (outf, x)
	496	FILE *outf;
	497	rtx x;
	498	{
	499	outfile = outf;
	500	sawclose = 0;
9ec36da5 JL	501	if (! flag_dump_unnumbered
	502	\|\| GET_CODE (x) != NOTE \|\| NOTE_LINE_NUMBER (x) < 0)
	503	{
	504	print_rtx (x);
	505	putc ('\n', outf);
b707b450	506	return 1;
9ec36da5	507	}
b707b450	508	return 0;
3e28fe44	509	}