/* Instruction scheduling pass.
- Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+ 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)
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 2, or (at your option) any later
+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
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
\f
#include "config.h"
#include "system.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 *);
-static void print_exp (char *, rtx, int);
-static void print_value (char *, rtx, int);
-static void print_pattern (char *, rtx, int);
#define BUF_LEN 2048
may be stored in objects representing values. */
static void
-print_exp (char *buf, rtx x, int verbose)
+print_exp (char *buf, const_rtx x, int verbose)
{
char tmp[BUF_LEN];
const char *st[4];
{
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] = "-";
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);
/* Prints rtxes, I customarily classified as values. They're constants,
registers, labels, symbols and memory accesses. */
-static void
-print_value (char *buf, rtx x, int verbose)
+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, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
+ sprintf (t, HOST_WIDE_INT_PRINT_HEX,
+ (unsigned HOST_WIDE_INT) INTVAL (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_DOUBLE:
(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));
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
-print_pattern (char *buf, rtx x, int verbose)
+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);
+}
+