[thirdparty/gcc.git] / gcc / sched-vis.c

/* Instruction scheduling pass.
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
   and currently maintained by, Jim Wilson (wilson@cygnus.com)

This file is part of GCC.

GCC 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 3, or (at your option) any later
version.

GCC 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 GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
\f
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "rtl.h"
#include "obstack.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "real.h"
#include "insn-attr.h"
#include "sched-int.h"
#include "tree-pass.h"

static char *safe_concat (char *, char *, const char *);

#define BUF_LEN 2048

static char *
safe_concat (char *buf, char *cur, const char *str)
{
  char *end = buf + BUF_LEN - 2;	/* Leave room for null.  */
  int c;

  if (cur > end)
    {
      *end = '\0';
      return end;
    }

  while (cur < end && (c = *str++) != '\0')
    *cur++ = c;

  *cur = '\0';
  return cur;
}

/* This recognizes rtx, I classified as expressions.  These are always
   represent some action on values or results of other expression, that
   may be stored in objects representing values.  */

static void
print_exp (char *buf, const_rtx x, int verbose)
{
  char tmp[BUF_LEN];
  const char *st[4];
  char *cur = buf;
  const char *fun = (char *) 0;
  const char *sep;
  rtx op[4];
  int i;

  for (i = 0; i < 4; i++)
    {
      st[i] = (char *) 0;
      op[i] = NULL_RTX;
    }

  switch (GET_CODE (x))
    {
    case PLUS:
      op[0] = XEXP (x, 0);
      if (CONST_INT_P (XEXP (x, 1))
	  && INTVAL (XEXP (x, 1)) < 0)
	{
	  st[1] = "-";
	  op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
	}
      else
	{
	  st[1] = "+";
	  op[1] = XEXP (x, 1);
	}
      break;
    case LO_SUM:
      op[0] = XEXP (x, 0);
      st[1] = "+low(";
      op[1] = XEXP (x, 1);
      st[2] = ")";
      break;
    case MINUS:
      op[0] = XEXP (x, 0);
      st[1] = "-";
      op[1] = XEXP (x, 1);
      break;
    case COMPARE:
      fun = "cmp";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case NEG:
      st[0] = "-";
      op[0] = XEXP (x, 0);
      break;
    case MULT:
      op[0] = XEXP (x, 0);
      st[1] = "*";
      op[1] = XEXP (x, 1);
      break;
    case DIV:
      op[0] = XEXP (x, 0);
      st[1] = "/";
      op[1] = XEXP (x, 1);
      break;
    case UDIV:
      fun = "udiv";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case MOD:
      op[0] = XEXP (x, 0);
      st[1] = "%";
      op[1] = XEXP (x, 1);
      break;
    case UMOD:
      fun = "umod";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case SMIN:
      fun = "smin";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case SMAX:
      fun = "smax";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case UMIN:
      fun = "umin";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case UMAX:
      fun = "umax";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case NOT:
      st[0] = "!";
      op[0] = XEXP (x, 0);
      break;
    case AND:
      op[0] = XEXP (x, 0);
      st[1] = "&";
      op[1] = XEXP (x, 1);
      break;
    case IOR:
      op[0] = XEXP (x, 0);
      st[1] = "|";
      op[1] = XEXP (x, 1);
      break;
    case XOR:
      op[0] = XEXP (x, 0);
      st[1] = "^";
      op[1] = XEXP (x, 1);
      break;
    case ASHIFT:
      op[0] = XEXP (x, 0);
      st[1] = "<<";
      op[1] = XEXP (x, 1);
      break;
    case LSHIFTRT:
      op[0] = XEXP (x, 0);
      st[1] = " 0>>";
      op[1] = XEXP (x, 1);
      break;
    case ASHIFTRT:
      op[0] = XEXP (x, 0);
      st[1] = ">>";
      op[1] = XEXP (x, 1);
      break;
    case ROTATE:
      op[0] = XEXP (x, 0);
      st[1] = "<-<";
      op[1] = XEXP (x, 1);
      break;
    case ROTATERT:
      op[0] = XEXP (x, 0);
      st[1] = ">->";
      op[1] = XEXP (x, 1);
      break;
    case ABS:
      fun = "abs";
      op[0] = XEXP (x, 0);
      break;
    case SQRT:
      fun = "sqrt";
      op[0] = XEXP (x, 0);
      break;
    case FFS:
      fun = "ffs";
      op[0] = XEXP (x, 0);
      break;
    case EQ:
      op[0] = XEXP (x, 0);
      st[1] = "==";
      op[1] = XEXP (x, 1);
      break;
    case NE:
      op[0] = XEXP (x, 0);
      st[1] = "!=";
      op[1] = XEXP (x, 1);
      break;
    case GT:
      op[0] = XEXP (x, 0);
      st[1] = ">";
      op[1] = XEXP (x, 1);
      break;
    case GTU:
      fun = "gtu";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case LT:
      op[0] = XEXP (x, 0);
      st[1] = "<";
      op[1] = XEXP (x, 1);
      break;
    case LTU:
      fun = "ltu";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case GE:
      op[0] = XEXP (x, 0);
      st[1] = ">=";
      op[1] = XEXP (x, 1);
      break;
    case GEU:
      fun = "geu";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case LE:
      op[0] = XEXP (x, 0);
      st[1] = "<=";
      op[1] = XEXP (x, 1);
      break;
    case LEU:
      fun = "leu";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      break;
    case SIGN_EXTRACT:
      fun = (verbose) ? "sign_extract" : "sxt";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      op[2] = XEXP (x, 2);
      break;
    case ZERO_EXTRACT:
      fun = (verbose) ? "zero_extract" : "zxt";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      op[2] = XEXP (x, 2);
      break;
    case SIGN_EXTEND:
      fun = (verbose) ? "sign_extend" : "sxn";
      op[0] = XEXP (x, 0);
      break;
    case ZERO_EXTEND:
      fun = (verbose) ? "zero_extend" : "zxn";
      op[0] = XEXP (x, 0);
      break;
    case FLOAT_EXTEND:
      fun = (verbose) ? "float_extend" : "fxn";
      op[0] = XEXP (x, 0);
      break;
    case TRUNCATE:
      fun = (verbose) ? "trunc" : "trn";
      op[0] = XEXP (x, 0);
      break;
    case FLOAT_TRUNCATE:
      fun = (verbose) ? "float_trunc" : "ftr";
      op[0] = XEXP (x, 0);
      break;
    case FLOAT:
      fun = (verbose) ? "float" : "flt";
      op[0] = XEXP (x, 0);
      break;
    case UNSIGNED_FLOAT:
      fun = (verbose) ? "uns_float" : "ufl";
      op[0] = XEXP (x, 0);
      break;
    case FIX:
      fun = "fix";
      op[0] = XEXP (x, 0);
      break;
    case UNSIGNED_FIX:
      fun = (verbose) ? "uns_fix" : "ufx";
      op[0] = XEXP (x, 0);
      break;
    case PRE_DEC:
      st[0] = "--";
      op[0] = XEXP (x, 0);
      break;
    case PRE_INC:
      st[0] = "++";
      op[0] = XEXP (x, 0);
      break;
    case POST_DEC:
      op[0] = XEXP (x, 0);
      st[1] = "--";
      break;
    case POST_INC:
      op[0] = XEXP (x, 0);
      st[1] = "++";
      break;
    case PRE_MODIFY:
      st[0] = "pre ";
      op[0] = XEXP (XEXP (x, 1), 0);
      st[1] = "+=";
      op[1] = XEXP (XEXP (x, 1), 1);
      break;
    case POST_MODIFY:
      st[0] = "post ";
      op[0] = XEXP (XEXP (x, 1), 0);
      st[1] = "+=";
      op[1] = XEXP (XEXP (x, 1), 1);
      break;
    case CALL:
      st[0] = "call ";
      op[0] = XEXP (x, 0);
      if (verbose)
	{
	  st[1] = " argc:";
	  op[1] = XEXP (x, 1);
	}
      break;
    case IF_THEN_ELSE:
      st[0] = "{(";
      op[0] = XEXP (x, 0);
      st[1] = ")?";
      op[1] = XEXP (x, 1);
      st[2] = ":";
      op[2] = XEXP (x, 2);
      st[3] = "}";
      break;
    case TRAP_IF:
      fun = "trap_if";
      op[0] = TRAP_CONDITION (x);
      break;
    case PREFETCH:
      fun = "prefetch";
      op[0] = XEXP (x, 0);
      op[1] = XEXP (x, 1);
      op[2] = XEXP (x, 2);
      break;
    case UNSPEC:
    case UNSPEC_VOLATILE:
      {
	cur = safe_concat (buf, cur, "unspec");
	if (GET_CODE (x) == UNSPEC_VOLATILE)
	  cur = safe_concat (buf, cur, "/v");
	cur = safe_concat (buf, cur, "[");
	sep = "";
	for (i = 0; i < XVECLEN (x, 0); i++)
	  {
	    print_pattern (tmp, XVECEXP (x, 0, i), verbose);
	    cur = safe_concat (buf, cur, sep);
	    cur = safe_concat (buf, cur, tmp);
	    sep = ",";
	  }
	cur = safe_concat (buf, cur, "] ");
	sprintf (tmp, "%d", XINT (x, 1));
	cur = safe_concat (buf, cur, tmp);
      }
      break;
    default:
      /* If (verbose) debug_rtx (x);  */
      st[0] = GET_RTX_NAME (GET_CODE (x));
      break;
    }

  /* Print this as a function?  */
  if (fun)
    {
      cur = safe_concat (buf, cur, fun);
      cur = safe_concat (buf, cur, "(");
    }

  for (i = 0; i < 4; i++)
    {
      if (st[i])
	cur = safe_concat (buf, cur, st[i]);

      if (op[i])
	{
	  if (fun && i != 0)
	    cur = safe_concat (buf, cur, ",");

	  print_value (tmp, op[i], verbose);
	  cur = safe_concat (buf, cur, tmp);
	}
    }

  if (fun)
    cur = safe_concat (buf, cur, ")");
}		/* print_exp */

/* Prints rtxes, I customarily classified as values.  They're constants,
   registers, labels, symbols and memory accesses.  */

void
print_value (char *buf, const_rtx x, int verbose)
{
  char t[BUF_LEN];
  char *cur = buf;

  switch (GET_CODE (x))
    {
    case CONST_INT:
      sprintf (t, HOST_WIDE_INT_PRINT_HEX,
	       (unsigned HOST_WIDE_INT) INTVAL (x));
      cur = safe_concat (buf, cur, t);
      break;
    case CONST_DOUBLE:
      if (FLOAT_MODE_P (GET_MODE (x)))
	real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
      else
	sprintf (t,
		 "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
		 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
		 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
      cur = safe_concat (buf, cur, t);
      break;
    case CONST_FIXED:
      fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
      cur = safe_concat (buf, cur, t);
      break;
    case CONST_STRING:
      cur = safe_concat (buf, cur, "\"");
      cur = safe_concat (buf, cur, XSTR (x, 0));
      cur = safe_concat (buf, cur, "\"");
      break;
    case SYMBOL_REF:
      cur = safe_concat (buf, cur, "`");
      cur = safe_concat (buf, cur, XSTR (x, 0));
      cur = safe_concat (buf, cur, "'");
      break;
    case LABEL_REF:
      sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
      cur = safe_concat (buf, cur, t);
      break;
    case CONST:
      print_value (t, XEXP (x, 0), verbose);
      cur = safe_concat (buf, cur, "const(");
      cur = safe_concat (buf, cur, t);
      cur = safe_concat (buf, cur, ")");
      break;
    case HIGH:
      print_value (t, XEXP (x, 0), verbose);
      cur = safe_concat (buf, cur, "high(");
      cur = safe_concat (buf, cur, t);
      cur = safe_concat (buf, cur, ")");
      break;
    case REG:
      if (REGNO (x) < FIRST_PSEUDO_REGISTER)
	{
	  int c = reg_names[REGNO (x)][0];
	  if (ISDIGIT (c))
	    cur = safe_concat (buf, cur, "%");

	  cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
	}
      else
	{
	  sprintf (t, "r%d", REGNO (x));
	  cur = safe_concat (buf, cur, t);
	}
      if (verbose
#ifdef INSN_SCHEDULING
	  && !current_sched_info
#endif
	 )
	{
	  sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
	  cur = safe_concat (buf, cur, t);
	}
      break;
    case SUBREG:
      print_value (t, SUBREG_REG (x), verbose);
      cur = safe_concat (buf, cur, t);
      sprintf (t, "#%d", SUBREG_BYTE (x));
      cur = safe_concat (buf, cur, t);
      break;
    case SCRATCH:
      cur = safe_concat (buf, cur, "scratch");
      break;
    case CC0:
      cur = safe_concat (buf, cur, "cc0");
      break;
    case PC:
      cur = safe_concat (buf, cur, "pc");
      break;
    case MEM:
      print_value (t, XEXP (x, 0), verbose);
      cur = safe_concat (buf, cur, "[");
      cur = safe_concat (buf, cur, t);
      cur = safe_concat (buf, cur, "]");
      break;
    default:
      print_exp (t, x, verbose);
      cur = safe_concat (buf, cur, t);
      break;
    }
}				/* print_value */

/* The next step in insn detalization, its pattern recognition.  */

void
print_pattern (char *buf, const_rtx x, int verbose)
{
  char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];

  switch (GET_CODE (x))
    {
    case SET:
      print_value (t1, SET_DEST (x), verbose);
      print_value (t2, SET_SRC (x), verbose);
      sprintf (buf, "%s=%s", t1, t2);
      break;
    case RETURN:
      sprintf (buf, "return");
      break;
    case CALL:
      print_exp (buf, x, verbose);
      break;
    case CLOBBER:
      print_value (t1, XEXP (x, 0), verbose);
      sprintf (buf, "clobber %s", t1);
      break;
    case USE:
      print_value (t1, XEXP (x, 0), verbose);
      sprintf (buf, "use %s", t1);
      break;
    case COND_EXEC:
      if (GET_CODE (COND_EXEC_TEST (x)) == NE
	  && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
	print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
      else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
	       && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
	{
	  t1[0] = '!';
	  print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
	}
      else
	print_value (t1, COND_EXEC_TEST (x), verbose);
      print_pattern (t2, COND_EXEC_CODE (x), verbose);
      sprintf (buf, "(%s) %s", t1, t2);
      break;
    case PARALLEL:
      {
	int i;

	sprintf (t1, "{");
	for (i = 0; i < XVECLEN (x, 0); i++)
	  {
	    print_pattern (t2, XVECEXP (x, 0, i), verbose);
	    sprintf (t3, "%s%s;", t1, t2);
	    strcpy (t1, t3);
	  }
	sprintf (buf, "%s}", t1);
      }
      break;
    case SEQUENCE:
      /* Should never see SEQUENCE codes until after reorg.  */
      gcc_unreachable ();
    case ASM_INPUT:
      sprintf (buf, "asm {%s}", XSTR (x, 0));
      break;
    case ADDR_VEC:
      break;
    case ADDR_DIFF_VEC:
      print_value (buf, XEXP (x, 0), verbose);
      break;
    case TRAP_IF:
      print_value (t1, TRAP_CONDITION (x), verbose);
      sprintf (buf, "trap_if %s", t1);
      break;
    case UNSPEC:
      {
	int i;

	sprintf (t1, "unspec{");
	for (i = 0; i < XVECLEN (x, 0); i++)
	  {
	    print_pattern (t2, XVECEXP (x, 0, i), verbose);
	    sprintf (t3, "%s%s;", t1, t2);
	    strcpy (t1, t3);
	  }
	sprintf (buf, "%s}", t1);
      }
      break;
    case UNSPEC_VOLATILE:
      {
	int i;

	sprintf (t1, "unspec/v{");
	for (i = 0; i < XVECLEN (x, 0); i++)
	  {
	    print_pattern (t2, XVECEXP (x, 0, i), verbose);
	    sprintf (t3, "%s%s;", t1, t2);
	    strcpy (t1, t3);
	  }
	sprintf (buf, "%s}", t1);
      }
      break;
    default:
      print_value (buf, x, verbose);
    }
}				/* print_pattern */

/* This is the main function in rtl visualization mechanism. It
   accepts an rtx and tries to recognize it as an insn, then prints it
   properly in human readable form, resembling assembler mnemonics.
   For every insn it prints its UID and BB the insn belongs too.
   (Probably the last "option" should be extended somehow, since it
   depends now on sched.c inner variables ...)  */

void
print_insn (char *buf, const_rtx x, int verbose)
{
  char t[BUF_LEN];
  const_rtx insn = x;

  switch (GET_CODE (x))
    {
    case INSN:
      print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
      if (verbose && current_sched_info)
	sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
		 t);
      else
#endif
	sprintf (buf, " %4d %s", INSN_UID (x), t);
      break;
    case JUMP_INSN:
      print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
      if (verbose && current_sched_info)
	sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
		 t);
      else
#endif
	sprintf (buf, " %4d %s", INSN_UID (x), t);
      break;
    case CALL_INSN:
      x = PATTERN (insn);
      if (GET_CODE (x) == PARALLEL)
	{
	  x = XVECEXP (x, 0, 0);
	  print_pattern (t, x, verbose);
	}
      else
	strcpy (t, "call <...>");
#ifdef INSN_SCHEDULING
      if (verbose && current_sched_info)
	sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
      else
#endif
	sprintf (buf, " %4d %s", INSN_UID (insn), t);
      break;
    case CODE_LABEL:
      sprintf (buf, "L%d:", INSN_UID (x));
      break;
    case BARRIER:
      sprintf (buf, "i%4d: barrier", INSN_UID (x));
      break;
    case NOTE:
      sprintf (buf, " %4d %s", INSN_UID (x),
	       GET_NOTE_INSN_NAME (NOTE_KIND (x)));
      break;
    default:
      sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
	       GET_RTX_NAME (GET_CODE (x)));
    }
}				/* print_insn */

/* Emit a slim dump of X (an insn) to the file F, including any register
   note attached to the instruction.  */
void
dump_insn_slim (FILE *f, rtx x)
{
  char t[BUF_LEN + 32];
  rtx note;

  print_insn (t, x, 1);
  fputs (t, f);
  putc ('\n', f);
  if (INSN_P (x) && REG_NOTES (x))
    for (note = REG_NOTES (x); note; note = XEXP (note, 1))
      {
        print_value (t, XEXP (note, 0), 1);
	fprintf (f, "      %s: %s\n",
		 GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
      }
}

/* Emit a slim dump of X (an insn) to stderr.  */
void
debug_insn_slim (rtx x)
{
  dump_insn_slim (stderr, x);
}

/* Provide a slim dump the instruction chain starting at FIRST to F, honoring
   the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
   include more information on the basic blocks.  */
void
print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
{
  print_rtl_slim (f, first, NULL, -1, flags);
}

/* Same as above, but stop at LAST or when COUNT == 0.  
   If COUNT < 0 it will stop only at LAST or NULL rtx.  */
void
print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
{
  basic_block current_bb = NULL;
  rtx insn, tail;

  tail = last ? NEXT_INSN (last) : NULL_RTX;
  for (insn = first; 
       (insn != NULL) && (insn != tail) && (count != 0); 
       insn = NEXT_INSN (insn))
    {
      if ((flags & TDF_BLOCKS)
	  && (INSN_P (insn) || NOTE_P (insn))
	  && BLOCK_FOR_INSN (insn)
	  && !current_bb)
	{
	  current_bb = BLOCK_FOR_INSN (insn);
	  dump_bb_info (current_bb, true, false, flags, ";; ", f);
	}

      dump_insn_slim (f, insn);

      if ((flags & TDF_BLOCKS)
	  && current_bb
	  && insn == BB_END (current_bb))
	{
	  dump_bb_info (current_bb, false, true, flags, ";; ", f);
	  current_bb = NULL;
	}
      if (count > 0)
        count--;
    }
}

void 
debug_bb_slim (struct basic_block_def *bb)
{
  print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
}

void
debug_bb_n_slim (int n)
{
  struct basic_block_def *bb = BASIC_BLOCK (n);
  debug_bb_slim (bb);
}
Commit	Line	Data
c62c2659	1	/* Instruction scheduling pass.
6fb5fa3c	2	Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
66647d44	3	2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
c62c2659 BS	4	Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
	5	and currently maintained by, Jim Wilson (wilson@cygnus.com)
	6
1322177d	7	This file is part of GCC.
c62c2659	8
1322177d LB	9	GCC is free software; you can redistribute it and/or modify it under
1322177d LB	10	the terms of the GNU General Public License as published by the Free
9dcd6f09	11	Software Foundation; either version 3, or (at your option) any later
1322177d	12	version.
c62c2659	13
1322177d LB	14	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
1322177d LB	15	WARRANTY; without even the implied warranty of MERCHANTABILITY or
c62c2659 BS	16	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	17	for more details.
	18
	19	You should have received a copy of the GNU General Public License
9dcd6f09 NC	20	along with GCC; see the file COPYING3. If not see
9dcd6f09 NC	21	<http://www.gnu.org/licenses/>. */
c62c2659 BS	22	\f
	23	#include "config.h"
	24	#include "system.h"
4977bab6 ZW	25	#include "coretypes.h"
4977bab6 ZW	26	#include "tm.h"
c62c2659	27	#include "rtl.h"
a68e7e6c	28	#include "obstack.h"
18e720b3 BS	29	#include "hard-reg-set.h"
18e720b3 BS	30	#include "basic-block.h"
b3ae1ccd	31	#include "real.h"
e855c69d	32	#include "insn-attr.h"
c62c2659	33	#include "sched-int.h"
a68e7e6c	34	#include "tree-pass.h"
c62c2659	35
46c5ad27	36	static char safe_concat (char , char , const char );
c62c2659	37
c62c2659 BS	38	#define BUF_LEN 2048
	39
	40	static char *
46c5ad27	41	safe_concat (char buf, char cur, const char *str)
c62c2659 BS	42	{
	43	char end = buf + BUF_LEN - 2; / Leave room for null. */
	44	int c;
	45
	46	if (cur > end)
	47	{
	48	*end = '\0';
	49	return end;
	50	}
	51
	52	while (cur < end && (c = *str++) != '\0')
	53	*cur++ = c;
	54
	55	*cur = '\0';
	56	return cur;
	57	}
	58
	59	/* This recognizes rtx, I classified as expressions. These are always
	60	represent some action on values or results of other expression, that
	61	may be stored in objects representing values. */
	62
	63	static void
22ea9ec0	64	print_exp (char *buf, const_rtx x, int verbose)
c62c2659 BS	65	{
	66	char tmp[BUF_LEN];
	67	const char *st[4];
	68	char *cur = buf;
	69	const char fun = (char ) 0;
	70	const char *sep;
	71	rtx op[4];
	72	int i;
	73
	74	for (i = 0; i < 4; i++)
	75	{
	76	st[i] = (char *) 0;
	77	op[i] = NULL_RTX;
	78	}
	79
	80	switch (GET_CODE (x))
	81	{
	82	case PLUS:
	83	op[0] = XEXP (x, 0);
481683e1	84	if (CONST_INT_P (XEXP (x, 1))
c62c2659 BS	85	&& INTVAL (XEXP (x, 1)) < 0)
	86	{
	87	st[1] = "-";
	88	op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
	89	}
	90	else
	91	{
	92	st[1] = "+";
	93	op[1] = XEXP (x, 1);
	94	}
	95	break;
	96	case LO_SUM:
	97	op[0] = XEXP (x, 0);
	98	st[1] = "+low(";
	99	op[1] = XEXP (x, 1);
	100	st[2] = ")";
	101	break;
	102	case MINUS:
	103	op[0] = XEXP (x, 0);
	104	st[1] = "-";
	105	op[1] = XEXP (x, 1);
	106	break;
	107	case COMPARE:
	108	fun = "cmp";
	109	op[0] = XEXP (x, 0);
	110	op[1] = XEXP (x, 1);
	111	break;
	112	case NEG:
	113	st[0] = "-";
	114	op[0] = XEXP (x, 0);
	115	break;
	116	case MULT:
	117	op[0] = XEXP (x, 0);
	118	st[1] = "*";
	119	op[1] = XEXP (x, 1);
	120	break;
	121	case DIV:
	122	op[0] = XEXP (x, 0);
	123	st[1] = "/";
	124	op[1] = XEXP (x, 1);
	125	break;
	126	case UDIV:
	127	fun = "udiv";
	128	op[0] = XEXP (x, 0);
	129	op[1] = XEXP (x, 1);
	130	break;
	131	case MOD:
	132	op[0] = XEXP (x, 0);
	133	st[1] = "%";
	134	op[1] = XEXP (x, 1);
	135	break;
	136	case UMOD:
	137	fun = "umod";
	138	op[0] = XEXP (x, 0);
	139	op[1] = XEXP (x, 1);
	140	break;
	141	case SMIN:
	142	fun = "smin";
	143	op[0] = XEXP (x, 0);
	144	op[1] = XEXP (x, 1);
	145	break;
	146	case SMAX:
	147	fun = "smax";
	148	op[0] = XEXP (x, 0);
149	op[1] = XEXP (x, 1);
150	break;
151	case UMIN:
152	fun = "umin";
153	op[0] = XEXP (x, 0);
154	op[1] = XEXP (x, 1);
155	break;
156	case UMAX:
157	fun = "umax";
158	op[0] = XEXP (x, 0);
159	op[1] = XEXP (x, 1);
160	break;
161	case NOT:
162	st[0] = "!";
163	op[0] = XEXP (x, 0);
164	break;
165	case AND:
166	op[0] = XEXP (x, 0);
167	st[1] = "&";
168	op[1] = XEXP (x, 1);
169	break;
170	case IOR:
171	op[0] = XEXP (x, 0);
172	st[1] = "\|";
173	op[1] = XEXP (x, 1);
174	break;
175	case XOR:
176	op[0] = XEXP (x, 0);
177	st[1] = "^";
178	op[1] = XEXP (x, 1);
179	break;
180	case ASHIFT:
181	op[0] = XEXP (x, 0);
182	st[1] = "<<";
183	op[1] = XEXP (x, 1);
184	break;
185	case LSHIFTRT:
186	op[0] = XEXP (x, 0);
187	st[1] = " 0>>";
188	op[1] = XEXP (x, 1);
189	break;
190	case ASHIFTRT:
191	op[0] = XEXP (x, 0);
192	st[1] = ">>";
193	op[1] = XEXP (x, 1);
194	break;
195	case ROTATE:
196	op[0] = XEXP (x, 0);
197	st[1] = "<-<";
198	op[1] = XEXP (x, 1);
199	break;
200	case ROTATERT:
201	op[0] = XEXP (x, 0);
202	st[1] = ">->";
203	op[1] = XEXP (x, 1);
204	break;
205	case ABS:
206	fun = "abs";
207	op[0] = XEXP (x, 0);
208	break;
209	case SQRT:
210	fun = "sqrt";
211	op[0] = XEXP (x, 0);
212	break;
213	case FFS:
214	fun = "ffs";
215	op[0] = XEXP (x, 0);
216	break;
217	case EQ:
218	op[0] = XEXP (x, 0);
219	st[1] = "==";
220	op[1] = XEXP (x, 1);
221	break;
222	case NE:
223	op[0] = XEXP (x, 0);
224	st[1] = "!=";
225	op[1] = XEXP (x, 1);
226	break;
227	case GT:
228	op[0] = XEXP (x, 0);
229	st[1] = ">";
230	op[1] = XEXP (x, 1);
231	break;
232	case GTU:
233	fun = "gtu";
234	op[0] = XEXP (x, 0);
235	op[1] = XEXP (x, 1);
236	break;
237	case LT:
238	op[0] = XEXP (x, 0);
239	st[1] = "<";
240	op[1] = XEXP (x, 1);
241	break;
242	case LTU:
243	fun = "ltu";
244	op[0] = XEXP (x, 0);
245	op[1] = XEXP (x, 1);
246	break;
247	case GE:
248	op[0] = XEXP (x, 0);
249	st[1] = ">=";
250	op[1] = XEXP (x, 1);
251	break;
252	case GEU:
253	fun = "geu";
254	op[0] = XEXP (x, 0);
255	op[1] = XEXP (x, 1);
256	break;
257	case LE:
258	op[0] = XEXP (x, 0);
259	st[1] = "<=";
260	op[1] = XEXP (x, 1);
261	break;
262	case LEU:
263	fun = "leu";
264	op[0] = XEXP (x, 0);
265	op[1] = XEXP (x, 1);
266	break;
267	case SIGN_EXTRACT:
268	fun = (verbose) ? "sign_extract" : "sxt";
269	op[0] = XEXP (x, 0);
270	op[1] = XEXP (x, 1);
271	op[2] = XEXP (x, 2);
272	break;
273	case ZERO_EXTRACT:
274	fun = (verbose) ? "zero_extract" : "zxt";
275	op[0] = XEXP (x, 0);
276	op[1] = XEXP (x, 1);
277	op[2] = XEXP (x, 2);
278	break;
279	case SIGN_EXTEND:
280	fun = (verbose) ? "sign_extend" : "sxn";
281	op[0] = XEXP (x, 0);
282	break;
283	case ZERO_EXTEND:
284	fun = (verbose) ? "zero_extend" : "zxn";
285	op[0] = XEXP (x, 0);
286	break;
287	case FLOAT_EXTEND:
288	fun = (verbose) ? "float_extend" : "fxn";
289	op[0] = XEXP (x, 0);
290	break;
291	case TRUNCATE:
292	fun = (verbose) ? "trunc" : "trn";
293	op[0] = XEXP (x, 0);
294	break;
295	case FLOAT_TRUNCATE:
296	fun = (verbose) ? "float_trunc" : "ftr";
297	op[0] = XEXP (x, 0);
298	break;
299	case FLOAT:
300	fun = (verbose) ? "float" : "flt";
301	op[0] = XEXP (x, 0);
302	break;
303	case UNSIGNED_FLOAT:
304	fun = (verbose) ? "uns_float" : "ufl";
305	op[0] = XEXP (x, 0);
306	break;
307	case FIX:
308	fun = "fix";
309	op[0] = XEXP (x, 0);
310	break;
311	case UNSIGNED_FIX:
312	fun = (verbose) ? "uns_fix" : "ufx";
313	op[0] = XEXP (x, 0);
314	break;
315	case PRE_DEC:
316	st[0] = "--";
317	op[0] = XEXP (x, 0);
318	break;
319	case PRE_INC:
320	st[0] = "++";
321	op[0] = XEXP (x, 0);
322	break;
323	case POST_DEC:
324	op[0] = XEXP (x, 0);
325	st[1] = "--";
326	break;
327	case POST_INC:
328	op[0] = XEXP (x, 0);
329	st[1] = "++";
330	break;
6fb5fa3c DB	331	case PRE_MODIFY:
	332	st[0] = "pre ";
	333	op[0] = XEXP (XEXP (x, 1), 0);
	334	st[1] = "+=";
	335	op[1] = XEXP (XEXP (x, 1), 1);
	336	break;
	337	case POST_MODIFY:
	338	st[0] = "post ";
	339	op[0] = XEXP (XEXP (x, 1), 0);
	340	st[1] = "+=";
	341	op[1] = XEXP (XEXP (x, 1), 1);
	342	break;
c62c2659 BS	343	case CALL:
	344	st[0] = "call ";
	345	op[0] = XEXP (x, 0);
	346	if (verbose)
	347	{
	348	st[1] = " argc:";
	349	op[1] = XEXP (x, 1);
	350	}
	351	break;
	352	case IF_THEN_ELSE:
	353	st[0] = "{(";
	354	op[0] = XEXP (x, 0);
	355	st[1] = ")?";
	356	op[1] = XEXP (x, 1);
	357	st[2] = ":";
	358	op[2] = XEXP (x, 2);
	359	st[3] = "}";
	360	break;
	361	case TRAP_IF:
	362	fun = "trap_if";
	363	op[0] = TRAP_CONDITION (x);
	364	break;
21b8482a JJ	365	case PREFETCH:
	366	fun = "prefetch";
	367	op[0] = XEXP (x, 0);
	368	op[1] = XEXP (x, 1);
	369	op[2] = XEXP (x, 2);
	370	break;
c62c2659 BS	371	case UNSPEC:
	372	case UNSPEC_VOLATILE:
	373	{
	374	cur = safe_concat (buf, cur, "unspec");
	375	if (GET_CODE (x) == UNSPEC_VOLATILE)
	376	cur = safe_concat (buf, cur, "/v");
	377	cur = safe_concat (buf, cur, "[");
	378	sep = "";
	379	for (i = 0; i < XVECLEN (x, 0); i++)
	380	{
	381	print_pattern (tmp, XVECEXP (x, 0, i), verbose);
	382	cur = safe_concat (buf, cur, sep);
	383	cur = safe_concat (buf, cur, tmp);
	384	sep = ",";
	385	}
	386	cur = safe_concat (buf, cur, "] ");
	387	sprintf (tmp, "%d", XINT (x, 1));
	388	cur = safe_concat (buf, cur, tmp);
	389	}
	390	break;
	391	default:
	392	/* If (verbose) debug_rtx (x); */
	393	st[0] = GET_RTX_NAME (GET_CODE (x));
	394	break;
	395	}
	396
	397	/* Print this as a function? */
	398	if (fun)
	399	{
	400	cur = safe_concat (buf, cur, fun);
	401	cur = safe_concat (buf, cur, "(");
	402	}
	403
	404	for (i = 0; i < 4; i++)
	405	{
	406	if (st[i])
	407	cur = safe_concat (buf, cur, st[i]);
	408
	409	if (op[i])
	410	{
	411	if (fun && i != 0)
	412	cur = safe_concat (buf, cur, ",");
	413
	414	print_value (tmp, op[i], verbose);
	415	cur = safe_concat (buf, cur, tmp);
	416	}
	417	}
	418
	419	if (fun)
	420	cur = safe_concat (buf, cur, ")");
	421	} /* print_exp */
	422
e0bb17a8	423	/* Prints rtxes, I customarily classified as values. They're constants,
c62c2659 BS	424	registers, labels, symbols and memory accesses. */
c62c2659 BS	425
e855c69d	426	void
22ea9ec0	427	print_value (char *buf, const_rtx x, int verbose)
c62c2659 BS	428	{
	429	char t[BUF_LEN];
	430	char *cur = buf;
	431
	432	switch (GET_CODE (x))
	433	{
	434	case CONST_INT:
3d57d7ce DK	435	sprintf (t, HOST_WIDE_INT_PRINT_HEX,
3d57d7ce DK	436	(unsigned HOST_WIDE_INT) INTVAL (x));
c62c2659 BS	437	cur = safe_concat (buf, cur, t);
	438	break;
	439	case CONST_DOUBLE:
b3ae1ccd	440	if (FLOAT_MODE_P (GET_MODE (x)))
da6eec72	441	real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
b3ae1ccd	442	else
8d5b1b67 GK	443	sprintf (t,
	444	"<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
	445	(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
	446	(unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
c62c2659 BS	447	cur = safe_concat (buf, cur, t);
c62c2659 BS	448	break;
091a3ac7 CF	449	case CONST_FIXED:
	450	fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
	451	cur = safe_concat (buf, cur, t);
	452	break;
c62c2659 BS	453	case CONST_STRING:
	454	cur = safe_concat (buf, cur, "\"");
	455	cur = safe_concat (buf, cur, XSTR (x, 0));
	456	cur = safe_concat (buf, cur, "\"");
	457	break;
	458	case SYMBOL_REF:
	459	cur = safe_concat (buf, cur, "`");
	460	cur = safe_concat (buf, cur, XSTR (x, 0));
	461	cur = safe_concat (buf, cur, "'");
	462	break;
	463	case LABEL_REF:
	464	sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
	465	cur = safe_concat (buf, cur, t);
	466	break;
	467	case CONST:
	468	print_value (t, XEXP (x, 0), verbose);
	469	cur = safe_concat (buf, cur, "const(");
	470	cur = safe_concat (buf, cur, t);
	471	cur = safe_concat (buf, cur, ")");
	472	break;
	473	case HIGH:
	474	print_value (t, XEXP (x, 0), verbose);
	475	cur = safe_concat (buf, cur, "high(");
	476	cur = safe_concat (buf, cur, t);
	477	cur = safe_concat (buf, cur, ")");
	478	break;
	479	case REG:
	480	if (REGNO (x) < FIRST_PSEUDO_REGISTER)
	481	{
	482	int c = reg_names[REGNO (x)][0];
0df6c2c7	483	if (ISDIGIT (c))
c62c2659 BS	484	cur = safe_concat (buf, cur, "%");
	485
	486	cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
	487	}
	488	else
	489	{
	490	sprintf (t, "r%d", REGNO (x));
	491	cur = safe_concat (buf, cur, t);
	492	}
a68e7e6c PB	493	if (verbose
	494	#ifdef INSN_SCHEDULING
	495	&& !current_sched_info
	496	#endif
	497	)
	498	{
	499	sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
	500	cur = safe_concat (buf, cur, t);
	501	}
c62c2659 BS	502	break;
	503	case SUBREG:
	504	print_value (t, SUBREG_REG (x), verbose);
	505	cur = safe_concat (buf, cur, t);
ddef6bc7	506	sprintf (t, "#%d", SUBREG_BYTE (x));
c62c2659 BS	507	cur = safe_concat (buf, cur, t);
	508	break;
	509	case SCRATCH:
	510	cur = safe_concat (buf, cur, "scratch");
	511	break;
	512	case CC0:
	513	cur = safe_concat (buf, cur, "cc0");
	514	break;
	515	case PC:
	516	cur = safe_concat (buf, cur, "pc");
	517	break;
	518	case MEM:
	519	print_value (t, XEXP (x, 0), verbose);
	520	cur = safe_concat (buf, cur, "[");
	521	cur = safe_concat (buf, cur, t);
	522	cur = safe_concat (buf, cur, "]");
	523	break;
	524	default:
	525	print_exp (t, x, verbose);
	526	cur = safe_concat (buf, cur, t);
	527	break;
	528	}
	529	} /* print_value */
	530
	531	/* The next step in insn detalization, its pattern recognition. */
	532
e855c69d	533	void
22ea9ec0	534	print_pattern (char *buf, const_rtx x, int verbose)
c62c2659 BS	535	{
	536	char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
	537
	538	switch (GET_CODE (x))
	539	{
	540	case SET:
	541	print_value (t1, SET_DEST (x), verbose);
	542	print_value (t2, SET_SRC (x), verbose);
	543	sprintf (buf, "%s=%s", t1, t2);
	544	break;
	545	case RETURN:
	546	sprintf (buf, "return");
	547	break;
	548	case CALL:
	549	print_exp (buf, x, verbose);
	550	break;
	551	case CLOBBER:
	552	print_value (t1, XEXP (x, 0), verbose);
	553	sprintf (buf, "clobber %s", t1);
	554	break;
	555	case USE:
	556	print_value (t1, XEXP (x, 0), verbose);
	557	sprintf (buf, "use %s", t1);
	558	break;
	559	case COND_EXEC:
	560	if (GET_CODE (COND_EXEC_TEST (x)) == NE
	561	&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
	562	print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
	563	else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
786de7eb KH	564	&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
786de7eb KH	565	{
c62c2659 BS	566	t1[0] = '!';
	567	print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
	568	}
	569	else
786de7eb	570	print_value (t1, COND_EXEC_TEST (x), verbose);
c62c2659 BS	571	print_pattern (t2, COND_EXEC_CODE (x), verbose);
	572	sprintf (buf, "(%s) %s", t1, t2);
	573	break;
	574	case PARALLEL:
	575	{
	576	int i;
	577
	578	sprintf (t1, "{");
	579	for (i = 0; i < XVECLEN (x, 0); i++)
	580	{
	581	print_pattern (t2, XVECEXP (x, 0, i), verbose);
	582	sprintf (t3, "%s%s;", t1, t2);
	583	strcpy (t1, t3);
	584	}
	585	sprintf (buf, "%s}", t1);
	586	}
	587	break;
	588	case SEQUENCE:
2f937369	589	/* Should never see SEQUENCE codes until after reorg. */
41374e13	590	gcc_unreachable ();
c62c2659 BS	591	case ASM_INPUT:
	592	sprintf (buf, "asm {%s}", XSTR (x, 0));
	593	break;
	594	case ADDR_VEC:
	595	break;
	596	case ADDR_DIFF_VEC:
	597	print_value (buf, XEXP (x, 0), verbose);
	598	break;
	599	case TRAP_IF:
	600	print_value (t1, TRAP_CONDITION (x), verbose);
	601	sprintf (buf, "trap_if %s", t1);
	602	break;
	603	case UNSPEC:
	604	{
	605	int i;
	606
	607	sprintf (t1, "unspec{");
	608	for (i = 0; i < XVECLEN (x, 0); i++)
	609	{
	610	print_pattern (t2, XVECEXP (x, 0, i), verbose);
	611	sprintf (t3, "%s%s;", t1, t2);
	612	strcpy (t1, t3);
	613	}
	614	sprintf (buf, "%s}", t1);
	615	}
	616	break;
	617	case UNSPEC_VOLATILE:
	618	{
	619	int i;
	620
	621	sprintf (t1, "unspec/v{");
	622	for (i = 0; i < XVECLEN (x, 0); i++)
	623	{
	624	print_pattern (t2, XVECEXP (x, 0, i), verbose);
	625	sprintf (t3, "%s%s;", t1, t2);
	626	strcpy (t1, t3);
	627	}
	628	sprintf (buf, "%s}", t1);
	629	}
	630	break;
	631	default:
	632	print_value (buf, x, verbose);
	633	}
	634	} /* print_pattern */
	635
	636	/* This is the main function in rtl visualization mechanism. It
	637	accepts an rtx and tries to recognize it as an insn, then prints it
	638	properly in human readable form, resembling assembler mnemonics.
	639	For every insn it prints its UID and BB the insn belongs too.
	640	(Probably the last "option" should be extended somehow, since it
	641	depends now on sched.c inner variables ...) */
	642
6d0de005	643	void
e855c69d	644	print_insn (char *buf, const_rtx x, int verbose)
c62c2659 BS	645	{
c62c2659 BS	646	char t[BUF_LEN];
e855c69d	647	const_rtx insn = x;
c62c2659 BS	648
	649	switch (GET_CODE (x))
	650	{
	651	case INSN:
	652	print_pattern (t, PATTERN (x), verbose);
a68e7e6c PB	653	#ifdef INSN_SCHEDULING
a68e7e6c PB	654	if (verbose && current_sched_info)
c62c2659 BS	655	sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
	656	t);
	657	else
a68e7e6c PB	658	#endif
a68e7e6c PB	659	sprintf (buf, " %4d %s", INSN_UID (x), t);
c62c2659 BS	660	break;
	661	case JUMP_INSN:
	662	print_pattern (t, PATTERN (x), verbose);
a68e7e6c PB	663	#ifdef INSN_SCHEDULING
a68e7e6c PB	664	if (verbose && current_sched_info)
c62c2659 BS	665	sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
	666	t);
	667	else
a68e7e6c PB	668	#endif
a68e7e6c PB	669	sprintf (buf, " %4d %s", INSN_UID (x), t);
c62c2659 BS	670	break;
	671	case CALL_INSN:
	672	x = PATTERN (insn);
	673	if (GET_CODE (x) == PARALLEL)
	674	{
	675	x = XVECEXP (x, 0, 0);
	676	print_pattern (t, x, verbose);
	677	}
	678	else
	679	strcpy (t, "call <...>");
a68e7e6c PB	680	#ifdef INSN_SCHEDULING
a68e7e6c PB	681	if (verbose && current_sched_info)
e855c69d	682	sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
c62c2659	683	else
a68e7e6c PB	684	#endif
a68e7e6c PB	685	sprintf (buf, " %4d %s", INSN_UID (insn), t);
c62c2659 BS	686	break;
	687	case CODE_LABEL:
	688	sprintf (buf, "L%d:", INSN_UID (x));
	689	break;
	690	case BARRIER:
a68e7e6c	691	sprintf (buf, "i%4d: barrier", INSN_UID (x));
c62c2659 BS	692	break;
c62c2659 BS	693	case NOTE:
a38e7aa5 JH	694	sprintf (buf, " %4d %s", INSN_UID (x),
a38e7aa5 JH	695	GET_NOTE_INSN_NAME (NOTE_KIND (x)));
c62c2659 BS	696	break;
c62c2659 BS	697	default:
a68e7e6c PB	698	sprintf (buf, "i%4d <What %s?>", INSN_UID (x),
	699	GET_RTX_NAME (GET_CODE (x)));
	700	}
	701	} /* print_insn */
	702
a68e7e6c PB	703	/* Emit a slim dump of X (an insn) to the file F, including any register
	704	note attached to the instruction. */
	705	void
	706	dump_insn_slim (FILE *f, rtx x)
	707	{
	708	char t[BUF_LEN + 32];
	709	rtx note;
	710
	711	print_insn (t, x, 1);
	712	fputs (t, f);
	713	putc ('\n', f);
	714	if (INSN_P (x) && REG_NOTES (x))
	715	for (note = REG_NOTES (x); note; note = XEXP (note, 1))
	716	{
	717	print_value (t, XEXP (note, 0), 1);
	718	fprintf (f, " %s: %s\n",
	719	GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
	720	}
	721	}
	722
	723	/* Emit a slim dump of X (an insn) to stderr. */
	724	void
	725	debug_insn_slim (rtx x)
	726	{
	727	dump_insn_slim (stderr, x);
	728	}
	729
	730	/* Provide a slim dump the instruction chain starting at FIRST to F, honoring
	731	the dump flags given in FLAGS. Currently, TDF_BLOCKS and TDF_DETAILS
	732	include more information on the basic blocks. */
	733	void
	734	print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
e855c69d AB	735	{
	736	print_rtl_slim (f, first, NULL, -1, flags);
	737	}
	738
	739	/* Same as above, but stop at LAST or when COUNT == 0.
	740	If COUNT < 0 it will stop only at LAST or NULL rtx. */
	741	void
	742	print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
a68e7e6c PB	743	{
a68e7e6c PB	744	basic_block current_bb = NULL;
e855c69d	745	rtx insn, tail;
a68e7e6c	746
e855c69d AB	747	tail = last ? NEXT_INSN (last) : NULL_RTX;
	748	for (insn = first;
	749	(insn != NULL) && (insn != tail) && (count != 0);
	750	insn = NEXT_INSN (insn))
a68e7e6c PB	751	{
a68e7e6c PB	752	if ((flags & TDF_BLOCKS)
481683e1	753	&& (INSN_P (insn) \|\| NOTE_P (insn))
a68e7e6c PB	754	&& BLOCK_FOR_INSN (insn)
a68e7e6c PB	755	&& !current_bb)
c62c2659	756	{
a68e7e6c PB	757	current_bb = BLOCK_FOR_INSN (insn);
	758	dump_bb_info (current_bb, true, false, flags, ";; ", f);
	759	}
	760
	761	dump_insn_slim (f, insn);
	762
	763	if ((flags & TDF_BLOCKS)
	764	&& current_bb
	765	&& insn == BB_END (current_bb))
	766	{
	767	dump_bb_info (current_bb, false, true, flags, ";; ", f);
	768	current_bb = NULL;
c62c2659	769	}
e855c69d AB	770	if (count > 0)
e855c69d AB	771	count--;
c62c2659	772	}
a68e7e6c	773	}
c62c2659	774
e855c69d AB	775	void
	776	debug_bb_slim (struct basic_block_def *bb)
	777	{
	778	print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
	779	}
	780
	781	void
	782	debug_bb_n_slim (int n)
	783	{
	784	struct basic_block_def *bb = BASIC_BLOCK (n);
	785	debug_bb_slim (bb);
	786	}
	787