/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
+ Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
#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 *);
-static void print_exp (char *, const_rtx, int);
-static void print_value (char *, const_rtx, int);
-static void print_pattern (char *, const_rtx, int);
#define BUF_LEN 2048
{
case PLUS:
op[0] = XEXP (x, 0);
- if (GET_CODE (XEXP (x, 1)) == CONST_INT
+ if (CONST_INT_P (XEXP (x, 1))
&& INTVAL (XEXP (x, 1)) < 0)
{
st[1] = "-";
/* Prints rtxes, I customarily classified as values. They're constants,
registers, labels, symbols and memory accesses. */
-static void
+void
print_value (char *buf, const_rtx x, int verbose)
{
char t[BUF_LEN];
char *cur = buf;
+ if (!x)
+ {
+ safe_concat (buf, buf, "(nil)");
+ return;
+ }
switch (GET_CODE (x))
{
case CONST_INT:
sprintf (t, "#%d", SUBREG_BYTE (x));
cur = safe_concat (buf, cur, t);
break;
+ case STRICT_LOW_PART:
+ print_value (t, XEXP (x, 0), verbose);
+ cur = safe_concat (buf, cur, "strict_low_part(");
+ cur = safe_concat (buf, cur, t);
+ cur = safe_concat (buf, cur, ")");
+ break;
case SCRATCH:
cur = safe_concat (buf, cur, "scratch");
break;
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, "]");
break;
+ case DEBUG_EXPR:
+ sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
+ cur = safe_concat (buf, cur, t);
+ break;
default:
print_exp (t, x, verbose);
cur = safe_concat (buf, cur, t);
/* The next step in insn detalization, its pattern recognition. */
-static void
+void
print_pattern (char *buf, const_rtx x, int verbose)
{
char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
case RETURN:
sprintf (buf, "return");
break;
+ case SIMPLE_RETURN:
+ sprintf (buf, "simple_return");
+ break;
case CALL:
print_exp (buf, x, verbose);
break;
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "use %s", t1);
break;
+ case VAR_LOCATION:
+ print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
+ sprintf (buf, "loc %s", t1);
+ break;
case COND_EXEC:
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
sprintf (buf, "asm {%s}", XSTR (x, 0));
break;
case ADDR_VEC:
- break;
+ /* Fall through. */
case ADDR_DIFF_VEC:
print_value (buf, XEXP (x, 0), verbose);
break;
depends now on sched.c inner variables ...) */
void
-print_insn (char *buf, rtx x, int verbose)
+print_insn (char *buf, const_rtx x, int verbose)
{
char t[BUF_LEN];
- rtx insn = x;
+ const_rtx insn = x;
switch (GET_CODE (x))
{
#endif
sprintf (buf, " %4d %s", INSN_UID (x), t);
break;
+
+ case DEBUG_INSN:
+ {
+ const char *name = "?";
+
+ if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
+ {
+ tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
+ char idbuf[32];
+ if (id)
+ name = IDENTIFIER_POINTER (id);
+ else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
+ == DEBUG_EXPR_DECL)
+ {
+ sprintf (idbuf, "D#%i",
+ DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
+ name = idbuf;
+ }
+ else
+ {
+ sprintf (idbuf, "D.%i",
+ DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
+ name = idbuf;
+ }
+ }
+ if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
+ sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
+ else
+ {
+ print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
+ sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
+ }
+ }
+ break;
+
case JUMP_INSN:
print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
strcpy (t, "call <...>");
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
- sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
+ sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (insn), t);
}
} /* print_insn */
-
/* Emit a slim dump of X (an insn) to the file F, including any register
note attached to the instruction. */
void
}
/* Emit a slim dump of X (an insn) to stderr. */
-void
+DEBUG_FUNCTION void
debug_insn_slim (rtx x)
{
dump_insn_slim (stderr, x);
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;
+ rtx insn, tail;
- for (insn = first; NULL != insn; insn = NEXT_INSN (insn))
+ 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) || GET_CODE (insn) == NOTE)
+ && (INSN_P (insn) || NOTE_P (insn))
&& BLOCK_FOR_INSN (insn)
&& !current_bb)
{
dump_bb_info (current_bb, false, true, flags, ";; ", f);
current_bb = NULL;
}
+ if (count > 0)
+ count--;
}
}
+DEBUG_FUNCTION void
+debug_bb_slim (struct basic_block_def *bb)
+{
+ print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
+}
+
+DEBUG_FUNCTION void
+debug_bb_n_slim (int n)
+{
+ struct basic_block_def *bb = BASIC_BLOCK (n);
+ debug_bb_slim (bb);
+}
+