PR c++/39866

[pf3gnuchains/gcc-fork.git] / gcc / sched-vis.c

diff --git a/gcc/sched-vis.c b/gcc/sched-vis.c
index 2436207..906e9c3 100644 (file)
--- a/gcc/sched-vis.c
+++ b/gcc/sched-vis.c
@@ -1,6 +1,6 @@
 /* Instruction scheduling pass.
 /* 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 Free Software Foundation, Inc.

    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
    and currently maintained by, Jim Wilson (wilson@cygnus.com)
 
    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
    and currently maintained by, Jim Wilson (wilson@cygnus.com)
 


@@ -8,7 +8,7 @@ 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
 
 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
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -17,31 +17,23 @@ 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
 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 "coretypes.h"
 #include "tm.h"
 \f
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"

-#include "toplev.h"

 #include "rtl.h"
 #include "rtl.h"

-#include "tm_p.h"
-#include "regs.h"
+#include "obstack.h"

 #include "hard-reg-set.h"
 #include "basic-block.h"
 #include "hard-reg-set.h"
 #include "basic-block.h"

-#include "insn-attr.h"

 #include "real.h"
 #include "real.h"

+#include "insn-attr.h"

 #include "sched-int.h"
 #include "sched-int.h"

-#include "target.h"
-
-#ifdef INSN_SCHEDULING
+#include "tree-pass.h"

 
 static char *safe_concat (char *, char *, const char *);
 
 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
 
 
 #define BUF_LEN 2048
 


@@ -69,7 +61,7 @@ safe_concat (char *buf, char *cur, const char *str)
    may be stored in objects representing values.  */
 
 static void
    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];
 {
   char tmp[BUF_LEN];
   const char *st[4];


@@ -89,7 +81,7 @@ print_exp (char *buf, rtx x, int verbose)
     {
     case PLUS:
       op[0] = XEXP (x, 0);
     {
     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] = "-";
          && INTVAL (XEXP (x, 1)) < 0)
        {
          st[1] = "-";


@@ -336,6 +328,18 @@ print_exp (char *buf, rtx x, int verbose)
       op[0] = XEXP (x, 0);
       st[1] = "++";
       break;
       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);
     case CALL:
       st[0] = "call ";
       op[0] = XEXP (x, 0);


@@ -419,8 +423,8 @@ print_exp (char *buf, rtx x, int verbose)
 /* Prints rtxes, I customarily classified as values.  They're constants,
    registers, labels, symbols and memory accesses.  */
 
 /* 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;
 {
   char t[BUF_LEN];
   char *cur = buf;


@@ -428,14 +432,22 @@ print_value (char *buf, rtx x, int verbose)
   switch (GET_CODE (x))
     {
     case CONST_INT:
   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:
       if (FLOAT_MODE_P (GET_MODE (x)))
        real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
       else
       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, "<0x%lx,0x%lx>", (long) CONST_DOUBLE_LOW (x), (long) CONST_DOUBLE_HIGH (x));
+       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, t);
       break;
     case CONST_STRING:


@@ -478,6 +490,15 @@ print_value (char *buf, rtx x, int verbose)
          sprintf (t, "r%d", REGNO (x));
          cur = safe_concat (buf, cur, t);
        }
          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);
       break;
     case SUBREG:
       print_value (t, SUBREG_REG (x), verbose);


@@ -500,6 +521,10 @@ print_value (char *buf, rtx x, int verbose)
       cur = safe_concat (buf, cur, t);
       cur = safe_concat (buf, cur, "]");
       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);
     default:
       print_exp (t, x, verbose);
       cur = safe_concat (buf, cur, t);


@@ -509,8 +534,8 @@ print_value (char *buf, rtx x, int verbose)
 
 /* The next step in insn detalization, its pattern recognition.  */
 
 
 /* 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];
 
 {
   char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
 


@@ -535,6 +560,10 @@ print_pattern (char *buf, rtx x, int verbose)
       print_value (t1, XEXP (x, 0), verbose);
       sprintf (buf, "use %s", t1);
       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)
     case COND_EXEC:
       if (GET_CODE (COND_EXEC_TEST (x)) == NE
          && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)


@@ -620,28 +649,67 @@ print_pattern (char *buf, rtx x, int verbose)
    depends now on sched.c inner variables ...)  */
 
 void
    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];
 {
   char t[BUF_LEN];

-  rtx insn = x;
+  const_rtx insn = x;

 
   switch (GET_CODE (x))
     {
     case INSN:
       print_pattern (t, PATTERN (x), verbose);
 
   switch (GET_CODE (x))
     {
     case INSN:
       print_pattern (t, PATTERN (x), verbose);

-      if (verbose)
+#ifdef INSN_SCHEDULING
+      if (verbose && current_sched_info)

        sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
                 t);
       else
        sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
                 t);
       else

-       sprintf (buf, "%-4d %s", INSN_UID (x), t);
+#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;
       break;

+

     case JUMP_INSN:
       print_pattern (t, PATTERN (x), verbose);
     case JUMP_INSN:
       print_pattern (t, PATTERN (x), verbose);

-      if (verbose)
+#ifdef INSN_SCHEDULING
+      if (verbose && current_sched_info)

        sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
                 t);
       else
        sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
                 t);
       else

-       sprintf (buf, "%-4d %s", INSN_UID (x), t);
+#endif
+       sprintf (buf, " %4d %s", INSN_UID (x), t);

       break;
     case CALL_INSN:
       x = PATTERN (insn);
       break;
     case CALL_INSN:
       x = PATTERN (insn);


@@ -652,38 +720,111 @@ print_insn (char *buf, rtx x, int verbose)
        }
       else
        strcpy (t, "call <...>");
        }
       else
        strcpy (t, "call <...>");

-      if (verbose)
-       sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
+#ifdef INSN_SCHEDULING
+      if (verbose && current_sched_info)
+       sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);

       else
       else

-       sprintf (buf, "%-4d %s", INSN_UID (insn), t);
+#endif
+       sprintf (buf, " %4d %s", INSN_UID (insn), t);

       break;
     case CODE_LABEL:
       sprintf (buf, "L%d:", INSN_UID (x));
       break;
     case BARRIER:
       break;
     case CODE_LABEL:
       sprintf (buf, "L%d:", INSN_UID (x));
       break;
     case BARRIER:

-      sprintf (buf, "i% 4d: barrier", INSN_UID (x));
+      sprintf (buf, "i%4d: barrier", INSN_UID (x));

       break;
     case NOTE:
       break;
     case NOTE:

-      if (NOTE_LINE_NUMBER (x) > 0)
-       {
-         expanded_location xloc;
-         NOTE_EXPANDED_LOCATION (xloc, x);
-         sprintf (buf, "%4d note \"%s\" %d", INSN_UID (x),
-                  xloc.file, xloc.line);
-       }
-      else
-       sprintf (buf, "%4d %s", INSN_UID (x),
-                GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x)));
+      sprintf (buf, " %4d %s", INSN_UID (x),
+              GET_NOTE_INSN_NAME (NOTE_KIND (x)));

       break;
     default:
       break;
     default:

-      if (verbose)
+      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)

        {
        {

-         sprintf (buf, "Not an INSN at all\n");
-         debug_rtx (x);
+         current_bb = BLOCK_FOR_INSN (insn);
+         dump_bb_info (current_bb, true, false, flags, ";; ", f);

        }
        }

-      else
-       sprintf (buf, "i%-4d  <What?>", INSN_UID (x));
+
+      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--;

     }
     }

-}                              /* print_insn */
+}
+
+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);
+}

 
 

-#endif