* config/mcore/mcore.h (target_flags, HARDLIT_BIT, ALIGN8_BIT, DIV_BIT)

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

diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index 496613b..56f4da6 100644 (file)
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -1,5 +1,5 @@
-/* Print RTL for GNU C Compiler.
-   Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000
+/* Print RTL for GCC.
+   Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000, 2002, 2003, 2004

    Free Software Foundation, Inc.
 
 This file is part of GCC.
    Free Software Foundation, Inc.
 
 This file is part of GCC.


@@ -19,35 +19,27 @@ along with GCC; see the file COPYING.  If not, write to the Free
 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.  */
 
 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.  */
 

-
+/* This file is compiled twice: once for the generator programs,
+   once for the compiler.  */
+#ifdef GENERATOR_FILE
+#include "bconfig.h"
+#else

 #include "config.h"
 #include "config.h"

+#endif
+

 #include "system.h"
 #include "system.h"

+#include "coretypes.h"
+#include "tm.h"

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

-/* We don't want the tree code checking code for the access to the
-   DECL_NAME to be included in the gen* programs.  */
-#undef ENABLE_TREE_CHECKING
+/* These headers all define things which are not available in
+   generator programs.  */
+#ifndef GENERATOR_FILE

 #include "tree.h"
 #include "real.h"
 #include "flags.h"
 #include "hard-reg-set.h"
 #include "basic-block.h"
 #include "tree.h"
 #include "real.h"
 #include "flags.h"
 #include "hard-reg-set.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 debug_reg_names[] = DEBUG_REGISTER_NAMES;
-#define reg_names debug_reg_names
-#else
-const char * reg_names[] = REGISTER_NAMES;

 #endif
 
 static FILE *outfile;
 #endif
 
 static FILE *outfile;


@@ -56,7 +48,7 @@ static int sawclose = 0;
 
 static int indent;
 
 
 static int indent;
 

-static void print_rtx          PARAMS ((rtx));
+static void print_rtx (rtx);

 
 /* String printed at beginning of each RTL when it is dumped.
    This string is set to ASM_COMMENT_START when the RTL is dumped in
 
 /* String printed at beginning of each RTL when it is dumped.
    This string is set to ASM_COMMENT_START when the RTL is dumped in


@@ -74,42 +66,73 @@ int flag_simple = 0;
 /* Nonzero if we are dumping graphical description.  */
 int dump_for_graph;
 
 /* Nonzero if we are dumping graphical description.  */
 int dump_for_graph;
 

-/* Nonzero to dump all call_placeholder alternatives.  */
-static int debug_call_placeholder_verbose;
+#ifndef GENERATOR_FILE
+static void
+print_decl_name (FILE *outfile, tree node)
+{
+  if (DECL_NAME (node))
+    fputs (IDENTIFIER_POINTER (DECL_NAME (node)), outfile);
+  else
+    {
+      if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
+       fprintf (outfile, "L." HOST_WIDE_INT_PRINT_DEC, LABEL_DECL_UID (node));
+      else
+        {
+          char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
+         fprintf (outfile, "%c.%u", c, DECL_UID (node));
+        }
+    }
+}

 
 void
 
 void

-print_mem_expr (outfile, expr)
-     FILE *outfile;
-     tree expr;
+print_mem_expr (FILE *outfile, tree expr)

 {
   if (TREE_CODE (expr) == COMPONENT_REF)
     {
       if (TREE_OPERAND (expr, 0))
 {
   if (TREE_CODE (expr) == COMPONENT_REF)
     {
       if (TREE_OPERAND (expr, 0))

-        print_mem_expr (outfile, TREE_OPERAND (expr, 0));
+       print_mem_expr (outfile, TREE_OPERAND (expr, 0));

       else
        fputs (" <variable>", outfile);
       else
        fputs (" <variable>", outfile);

-      fprintf (outfile, ".%s",
-              IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (expr, 1))));
+      fputc ('.', outfile);
+      print_decl_name (outfile, TREE_OPERAND (expr, 1));
+    }
+  else if (TREE_CODE (expr) == INDIRECT_REF)
+    {
+      fputs (" (*", outfile);
+      print_mem_expr (outfile, TREE_OPERAND (expr, 0));
+      fputs (")", outfile);
+    }
+  else if (TREE_CODE (expr) == ALIGN_INDIRECT_REF)
+    {
+      fputs (" (A*", outfile);
+      print_mem_expr (outfile, TREE_OPERAND (expr, 0));
+      fputs (")", outfile);
+    }
+  else if (TREE_CODE (expr) == MISALIGNED_INDIRECT_REF)
+    {
+      fputs (" (M*", outfile);
+      print_mem_expr (outfile, TREE_OPERAND (expr, 0));
+      fputs (")", outfile);

     }
     }

-  else if (DECL_NAME (expr))
-    fprintf (outfile, " %s", IDENTIFIER_POINTER (DECL_NAME (expr)));

   else if (TREE_CODE (expr) == RESULT_DECL)
     fputs (" <result>", outfile);
   else
   else if (TREE_CODE (expr) == RESULT_DECL)
     fputs (" <result>", outfile);
   else

-    fputs (" <anonymous>", outfile);
+    {
+      fputc (' ', outfile);
+      print_decl_name (outfile, expr);
+    }

 }
 }

+#endif

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

-print_rtx (in_rtx)
-     rtx in_rtx;
+print_rtx (rtx in_rtx)

 {
   int i = 0;
   int j;
   const char *format_ptr;
   int is_insn;
 {
   int i = 0;
   int j;
   const char *format_ptr;
   int is_insn;

-  rtx tem;

 
   if (sawclose)
     {
 
   if (sawclose)
     {


@@ -138,8 +161,8 @@ print_rtx (in_rtx)
   /* 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
   /* 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))
+      && (is_insn || NOTE_P (in_rtx)
+         || LABEL_P (in_rtx) || BARRIER_P (in_rtx)))

     {
       i = 3;
       indent = 0;
     {
       i = 3;
       indent = 0;


@@ -151,43 +174,47 @@ print_rtx (in_rtx)
        fputc ('(', outfile);
       else
        fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
        fputc ('(', outfile);
       else
        fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));

-      
+

       if (! flag_simple)
        {
       if (! flag_simple)
        {

-         if (in_rtx->in_struct)
+         if (RTX_FLAG (in_rtx, in_struct))

            fputs ("/s", outfile);
 
            fputs ("/s", outfile);
 

-         if (in_rtx->volatil)
+         if (RTX_FLAG (in_rtx, volatil))

            fputs ("/v", outfile);
            fputs ("/v", outfile);

-         
-         if (in_rtx->unchanging)
+
+         if (RTX_FLAG (in_rtx, unchanging))

            fputs ("/u", outfile);
            fputs ("/u", outfile);

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

            fputs ("/f", outfile);
            fputs ("/f", outfile);

-         
-         if (in_rtx->jump)
+
+         if (RTX_FLAG (in_rtx, jump))

            fputs ("/j", outfile);
            fputs ("/j", outfile);

-         
-         if (in_rtx->call)
+
+         if (RTX_FLAG (in_rtx, call))

            fputs ("/c", outfile);
 
            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)));
-           }
+         if (RTX_FLAG (in_rtx, return_val))
+           fputs ("/i", outfile);
+
+         /* 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)));
+
+         /* For other rtl, print the mode if it's not VOID.  */
+         else if (GET_MODE (in_rtx) != VOIDmode)
+           fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));

        }
     }
 
        }
     }
 

+#ifndef GENERATOR_FILE
+  if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx)))
+    i = 5;
+#endif
+

   /* 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;
   /* 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;


@@ -221,13 +248,26 @@ print_rtx (in_rtx)
           An exception is the third field of a NOTE, where it indicates
           that the field has several different valid contents.  */
       case '0':
           An exception is the third field of a NOTE, where it indicates
           that the field has several different valid contents.  */
       case '0':

-       if (i == 1 && GET_CODE (in_rtx) == REG)
+       if (i == 1 && REG_P (in_rtx))

          {
            if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
              fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
          {
            if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
              fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));

-           break;

          }
          }

-       if (i == 3 && GET_CODE (in_rtx) == NOTE)
+#ifndef GENERATOR_FILE
+       else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
+         {
+           int flags = SYMBOL_REF_FLAGS (in_rtx);
+           if (flags)
+             fprintf (outfile, " [flags 0x%x]", flags);
+         }
+       else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF)
+         {
+           tree decl = SYMBOL_REF_DECL (in_rtx);
+           if (decl)
+             print_node_brief (outfile, "", decl, 0);
+         }
+#endif
+       else if (i == 4 && NOTE_P (in_rtx))

          {
            switch (NOTE_LINE_NUMBER (in_rtx))
              {
          {
            switch (NOTE_LINE_NUMBER (in_rtx))
              {


@@ -246,26 +286,18 @@ print_rtx (in_rtx)
                if (flag_dump_unnumbered)
                  fprintf (outfile, "#");
                else
                if (flag_dump_unnumbered)
                  fprintf (outfile, "#");
                else

-                 fprintf (outfile, HOST_PTR_PRINTF, 
+                 fprintf (outfile, HOST_PTR_PRINTF,

                           (char *) NOTE_BLOCK (in_rtx));
                sawclose = 1;
                break;
 
                           (char *) NOTE_BLOCK (in_rtx));
                sawclose = 1;
                break;
 

-             case NOTE_INSN_RANGE_BEG:
-             case NOTE_INSN_RANGE_END:
-             case NOTE_INSN_LIVE:
-               indent += 2;
-               if (!sawclose)
-                 fprintf (outfile, " ");
-               print_rtx (NOTE_RANGE_INFO (in_rtx));
-               indent -= 2;
-               break;
-

              case NOTE_INSN_BASIC_BLOCK:
                {
              case NOTE_INSN_BASIC_BLOCK:
                {

+#ifndef GENERATOR_FILE

                  basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
                  if (bb != 0)
                    fprintf (outfile, " [bb %d]", bb->index);
                  basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
                  if (bb != 0)
                    fprintf (outfile, " [bb %d]", bb->index);

+#endif

                  break;
                }
 
                  break;
                }
 


@@ -278,10 +310,33 @@ print_rtx (in_rtx)
                break;
 
              case NOTE_INSN_DELETED_LABEL:
                break;
 
              case NOTE_INSN_DELETED_LABEL:

-               if (NOTE_SOURCE_FILE (in_rtx))
-                 fprintf (outfile, " (\"%s\")", NOTE_SOURCE_FILE (in_rtx));
-               else
-                 fprintf (outfile, " \"\"");
+               {
+                 const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
+                 if (label)
+                   fprintf (outfile, " (\"%s\")", label);
+                 else
+                   fprintf (outfile, " \"\"");
+               }
+               break;
+
+             case NOTE_INSN_SWITCH_TEXT_SECTIONS:
+               {
+#ifndef GENERATOR_FILE
+                 basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
+                 if (bb != 0)
+                   fprintf (outfile, " [bb %d]", bb->index);
+#endif
+                 break;
+               }
+               
+             case NOTE_INSN_VAR_LOCATION:
+#ifndef GENERATOR_FILE
+               fprintf (outfile, " (");
+               print_mem_expr (outfile, NOTE_VAR_LOCATION_DECL (in_rtx));
+               fprintf (outfile, " ");
+               print_rtx (NOTE_VAR_LOCATION_LOC (in_rtx));
+               fprintf (outfile, ")");
+#endif

                break;
 
              default:
                break;
 
              default:


@@ -320,10 +375,10 @@ print_rtx (in_rtx)
        if (sawclose)
          {
            fprintf (outfile, "\n%s%*s",
        if (sawclose)
          {
            fprintf (outfile, "\n%s%*s",

-                     print_rtx_head, indent * 2, "");
+                    print_rtx_head, indent * 2, "");

            sawclose = 0;
          }
            sawclose = 0;
          }

-       fputs ("[ ", outfile);
+       fputs (" [", outfile);

        if (NULL != XVEC (in_rtx, i))
          {
            indent += 2;
        if (NULL != XVEC (in_rtx, i))
          {
            indent += 2;


@@ -338,7 +393,7 @@ print_rtx (in_rtx)
        if (sawclose)
          fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
 
        if (sawclose)
          fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
 

-       fputs ("] ", outfile);
+       fputs ("]", outfile);

        sawclose = 1;
        indent -= 2;
        break;
        sawclose = 1;
        indent -= 2;
        break;


@@ -348,15 +403,22 @@ print_rtx (in_rtx)
          fprintf (outfile, " ");
        fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
        if (! flag_simple)
          fprintf (outfile, " ");
        fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
        if (! flag_simple)

-         {
-           fprintf (outfile, " [");
-           fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, XWINT (in_rtx, i));
-           fprintf (outfile, "]");
-         }
+         fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
+                  XWINT (in_rtx, i));

        break;
 
       case 'i':
        break;
 
       case 'i':

-       if (i == 5 && GET_CODE (in_rtx) == NOTE)
+       if (i == 4 && INSN_P (in_rtx))
+         {
+#ifndef GENERATOR_FILE
+           /*  Pretty-print insn locators.  Ignore scoping as it is mostly
+               redundant with line number information and do not print anything
+               when there is no location information available.  */
+           if (INSN_LOCATOR (in_rtx) && insn_file (in_rtx))
+             fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
+#endif
+         }
+       else if (i == 6 && NOTE_P (in_rtx))

          {
            /* This field is only used for NOTE_INSN_DELETED_LABEL, and
               other times often contains garbage from INSN->NOTE death.  */
          {
            /* This field is only used for NOTE_INSN_DELETED_LABEL, and
               other times often contains garbage from INSN->NOTE death.  */


@@ -368,12 +430,11 @@ print_rtx (in_rtx)
            int value = XINT (in_rtx, i);
            const char *name;
 
            int value = XINT (in_rtx, i);
            const char *name;
 

-           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
+#ifndef GENERATOR_FILE
+           if (REG_P (in_rtx) && value < FIRST_PSEUDO_REGISTER)
+             fprintf (outfile, " %d %s", REGNO (in_rtx),
+                      reg_names[REGNO (in_rtx)]);
+           else if (REG_P (in_rtx)

                     && value <= LAST_VIRTUAL_REGISTER)
              {
                if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
                     && value <= LAST_VIRTUAL_REGISTER)
              {
                if (value == VIRTUAL_INCOMING_ARGS_REGNUM)


@@ -390,12 +451,30 @@ print_rtx (in_rtx)
                  fprintf (outfile, " %d virtual-reg-%d", value,
                           value-FIRST_VIRTUAL_REGISTER);
              }
                  fprintf (outfile, " %d virtual-reg-%d", value,
                           value-FIRST_VIRTUAL_REGISTER);
              }

-           else if (flag_dump_unnumbered
-                    && (is_insn || GET_CODE (in_rtx) == NOTE))
+           else
+#endif
+             if (flag_dump_unnumbered
+                    && (is_insn || NOTE_P (in_rtx)))

              fputc ('#', outfile);
            else
              fprintf (outfile, " %d", value);
 
              fputc ('#', outfile);
            else
              fprintf (outfile, " %d", value);
 

+#ifndef GENERATOR_FILE
+           if (REG_P (in_rtx) && REG_ATTRS (in_rtx))
+             {
+               fputs (" [", outfile);
+               if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx))
+                 fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
+               if (REG_EXPR (in_rtx))
+                 print_mem_expr (outfile, REG_EXPR (in_rtx));
+
+               if (REG_OFFSET (in_rtx))
+                 fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
+                          REG_OFFSET (in_rtx));
+               fputs (" ]", outfile);
+             }
+#endif
+

            if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
                && XINT (in_rtx, i) >= 0
                && (name = get_insn_name (XINT (in_rtx, i))) != NULL)
            if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
                && XINT (in_rtx, i) >= 0
                && (name = get_insn_name (XINT (in_rtx, i))) != NULL)


@@ -449,16 +528,17 @@ print_rtx (in_rtx)
        break;
 
       case 'b':
        break;
 
       case 'b':

+#ifndef GENERATOR_FILE

        if (XBITMAP (in_rtx, i) == NULL)
          fputs (" {null}", outfile);
        else
          bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");
        if (XBITMAP (in_rtx, i) == NULL)
          fputs (" {null}", outfile);
        else
          bitmap_print (outfile, XBITMAP (in_rtx, i), " {", "}");

+#endif

        sawclose = 0;
        break;
 
       case 't':
        sawclose = 0;
        break;
 
       case 't':

-       putc (' ', outfile);
-       fprintf (outfile, HOST_PTR_PRINTF, (char *) XTREE (in_rtx, i));
+       fprintf (outfile, " " HOST_PTR_PRINTF, (void *) XTREE (in_rtx, i));

        break;
 
       case '*':
        break;
 
       case '*':


@@ -466,6 +546,13 @@ print_rtx (in_rtx)
        sawclose = 0;
        break;
 
        sawclose = 0;
        break;
 

+      case 'B':
+#ifndef GENERATOR_FILE
+       if (XBBDEF (in_rtx, i))
+         fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index);
+#endif
+       break;
+

       default:
        fprintf (stderr,
                 "switch format wrong in rtl.print_rtx(). format was: %c.\n",
       default:
        fprintf (stderr,
                 "switch format wrong in rtl.print_rtx(). format was: %c.\n",


@@ -475,26 +562,20 @@ print_rtx (in_rtx)
 
   switch (GET_CODE (in_rtx))
     {
 
   switch (GET_CODE (in_rtx))
     {

+#ifndef GENERATOR_FILE

     case MEM:
     case MEM:

-      fputs (" [", outfile);
-      fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));
+      fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC, MEM_ALIAS_SET (in_rtx));

 
       if (MEM_EXPR (in_rtx))
        print_mem_expr (outfile, MEM_EXPR (in_rtx));
 
       if (MEM_OFFSET (in_rtx))
 
       if (MEM_EXPR (in_rtx))
        print_mem_expr (outfile, MEM_EXPR (in_rtx));
 
       if (MEM_OFFSET (in_rtx))

-       {
-         fputc ('+', outfile);
-         fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
-                  INTVAL (MEM_OFFSET (in_rtx)));
-       }
+       fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
+                INTVAL (MEM_OFFSET (in_rtx)));

 
       if (MEM_SIZE (in_rtx))
 
       if (MEM_SIZE (in_rtx))

-       {
-         fputs (" S", outfile);
-         fprintf (outfile, HOST_WIDE_INT_PRINT_DEC,
-                  INTVAL (MEM_SIZE (in_rtx)));
-       }
+       fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC,
+                INTVAL (MEM_SIZE (in_rtx)));

 
       if (MEM_ALIGN (in_rtx) != 1)
        fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
 
       if (MEM_ALIGN (in_rtx) != 1)
        fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));


@@ -502,18 +583,17 @@ print_rtx (in_rtx)
       fputc (']', outfile);
       break;
 
       fputc (']', outfile);
       break;
 

-#if 0
-    /* It would be nice to do this, but it would require real.o to
-       be linked into the MD-generator programs.  Maybe we should
-       do that.  -zw 2002-03-03  */

     case CONST_DOUBLE:
       if (FLOAT_MODE_P (GET_MODE (in_rtx)))
        {
     case CONST_DOUBLE:
       if (FLOAT_MODE_P (GET_MODE (in_rtx)))
        {

-         REAL_VALUE_TYPE val;
-         char s[30];
+         char s[60];

 
 

-         REAL_VALUE_FROM_CONST_DOUBLE (val, in_rtx);
-         REAL_VALUE_TO_DECIMAL (val, "%.16g", s);
+         real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
+                          sizeof (s), 0, 1);
+         fprintf (outfile, " %s", s);
+
+         real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
+                              sizeof (s), 0, 1);

          fprintf (outfile, " [%s]", s);
        }
       break;
          fprintf (outfile, " [%s]", s);
        }
       break;


@@ -521,52 +601,14 @@ print_rtx (in_rtx)
 
     case CODE_LABEL:
       fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
 
     case CODE_LABEL:
       fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));

-      if (LABEL_ALTERNATE_NAME (in_rtx))
-        fprintf (outfile, " [alternate name: %s]",
-                LABEL_ALTERNATE_NAME (in_rtx));
-      break;
-
-    case CALL_PLACEHOLDER:
-      if (debug_call_placeholder_verbose)
+      switch (LABEL_KIND (in_rtx))

        {
        {

-         fputs (" (cond [\n  (const_string \"normal\") (sequence [", outfile);
-         for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem))
-           {
-             fputs ("\n    ", outfile);
-             print_inline_rtx (outfile, tem, 4);
-           }
-
-         tem = XEXP (in_rtx, 1);
-         if (tem)
-           fputs ("\n    ])\n  (const_string \"tail_call\") (sequence [",
-                  outfile);
-         for (; tem != 0; tem = NEXT_INSN (tem))
-           {
-             fputs ("\n    ", outfile);
-             print_inline_rtx (outfile, tem, 4);
-           }
-
-         tem = XEXP (in_rtx, 2);
-         if (tem)
-           fputs ("\n    ])\n  (const_string \"tail_recursion\") (sequence [",
-                  outfile);
-         for (; tem != 0; tem = NEXT_INSN (tem))
-           {
-             fputs ("\n    ", outfile);
-             print_inline_rtx (outfile, tem, 4);
-           }
-
-         fputs ("\n    ])\n  ])", outfile);
-         break;
+         case LABEL_NORMAL: break;
+         case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break;
+         case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break;
+         case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break;
+         default: gcc_unreachable ();

        }
        }

-
-      for (tem = XEXP (in_rtx, 0); tem != 0; tem = NEXT_INSN (tem))
-       if (GET_CODE (tem) == CALL_INSN)
-         {
-           fprintf (outfile, " ");
-           print_rtx (tem);
-           break;
-         }

       break;
 
     default:
       break;
 
     default:


@@ -574,8 +616,8 @@ print_rtx (in_rtx)
     }
 
   if (dump_for_graph
     }
 
   if (dump_for_graph

-      && (is_insn || GET_CODE (in_rtx) == NOTE
-         || GET_CODE (in_rtx) == CODE_LABEL || GET_CODE (in_rtx) == BARRIER))
+      && (is_insn || NOTE_P (in_rtx)
+         || LABEL_P (in_rtx) || BARRIER_P (in_rtx)))

     sawclose = 0;
   else
     {
     sawclose = 0;
   else
     {


@@ -588,10 +630,7 @@ print_rtx (in_rtx)
    characters.  */
 
 void
    characters.  */
 
 void

-print_inline_rtx (outf, x, ind)
-     FILE *outf;
-     rtx x;
-     int ind;
+print_inline_rtx (FILE *outf, rtx x, int ind)

 {
   int oldsaw = sawclose;
   int oldindent = indent;
 {
   int oldsaw = sawclose;
   int oldindent = indent;


@@ -607,10 +646,10 @@ print_inline_rtx (outf, x, ind)
 /* Call this function from the debugger to see what X looks like.  */
 
 void
 /* Call this function from the debugger to see what X looks like.  */
 
 void

-debug_rtx (x)
-     rtx x;
+debug_rtx (rtx x)

 {
   outfile = stderr;
 {
   outfile = stderr;

+  sawclose = 0;

   print_rtx (x);
   fprintf (stderr, "\n");
 }
   print_rtx (x);
   fprintf (stderr, "\n");
 }


@@ -627,9 +666,7 @@ int debug_rtx_count = 0;    /* 0 is treated as equivalent to 1 */
    EG: -5 prints 2 rtx's on either side (in addition to the specified rtx).  */
 
 void
    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;
+debug_rtx_list (rtx x, int n)

 {
   int i,count;
   rtx insn;
 {
   int i,count;
   rtx insn;


@@ -647,18 +684,21 @@ debug_rtx_list (x, n)
       }
 
   for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))
       }
 
   for (i = count, insn = x; i > 0 && insn != 0; i--, insn = NEXT_INSN (insn))

-    debug_rtx (insn);
+    {
+      debug_rtx (insn);
+      fprintf (stderr, "\n");
+    }

 }
 
 /* Call this function to print an rtx list from START to END inclusive.  */
 
 void
 }
 
 /* Call this function to print an rtx list from START to END inclusive.  */
 
 void

-debug_rtx_range (start, end)
-     rtx start, end;
+debug_rtx_range (rtx start, rtx end)

 {
   while (1)
     {
       debug_rtx (start);
 {
   while (1)
     {
       debug_rtx (start);

+      fprintf (stderr, "\n");

       if (!start || start == end)
        break;
       start = NEXT_INSN (start);
       if (!start || start == end)
        break;
       start = NEXT_INSN (start);


@@ -670,9 +710,7 @@ debug_rtx_range (start, end)
    The found insn is returned to enable further debugging analysis.  */
 
 rtx
    The found insn is returned to enable further debugging analysis.  */
 
 rtx

-debug_rtx_find (x, uid)
-     rtx x;
-     int uid;
+debug_rtx_find (rtx x, int uid)

 {
   while (x != 0 && INSN_UID (x) != uid)
     x = NEXT_INSN (x);
 {
   while (x != 0 && INSN_UID (x) != uid)
     x = NEXT_INSN (x);


@@ -695,9 +733,7 @@ debug_rtx_find (x, uid)
    If RTX_FIRST is not an insn, then it alone is printed, with no newline.  */
 
 void
    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;
+print_rtl (FILE *outf, rtx rtx_first)

 {
   rtx tmp_rtx;
 
 {
   rtx tmp_rtx;
 


@@ -720,16 +756,16 @@ print_rtl (outf, rtx_first)
       case BARRIER:
        for (tmp_rtx = rtx_first; tmp_rtx != 0; tmp_rtx = NEXT_INSN (tmp_rtx))
          if (! flag_dump_unnumbered
       case BARRIER:
        for (tmp_rtx = rtx_first; tmp_rtx != 0; tmp_rtx = NEXT_INSN (tmp_rtx))
          if (! flag_dump_unnumbered

-             || GET_CODE (tmp_rtx) != NOTE || NOTE_LINE_NUMBER (tmp_rtx) < 0)
+             || !NOTE_P (tmp_rtx) || NOTE_LINE_NUMBER (tmp_rtx) < 0)

            {
            {

-              fputs (print_rtx_head, outfile);
+             fputs (print_rtx_head, outfile);

              print_rtx (tmp_rtx);
              fprintf (outfile, "\n");
            }
        break;
 
       default:
              print_rtx (tmp_rtx);
              fprintf (outfile, "\n");
            }
        break;
 
       default:

-        fputs (print_rtx_head, outfile);
+       fputs (print_rtx_head, outfile);

        print_rtx (rtx_first);
       }
 }
        print_rtx (rtx_first);
       }
 }


@@ -738,14 +774,12 @@ print_rtl (outf, rtx_first)
 /* Return nonzero if we actually printed anything.  */
 
 int
 /* Return nonzero if we actually printed anything.  */
 
 int

-print_rtl_single (outf, x)
-     FILE *outf;
-     rtx x;
+print_rtl_single (FILE *outf, rtx x)

 {
   outfile = outf;
   sawclose = 0;
   if (! flag_dump_unnumbered
 {
   outfile = outf;
   sawclose = 0;
   if (! flag_dump_unnumbered

-      || GET_CODE (x) != NOTE || NOTE_LINE_NUMBER (x) < 0)
+      || !NOTE_P (x) || NOTE_LINE_NUMBER (x) < 0)

     {
       fputs (print_rtx_head, outfile);
       print_rtx (x);
     {
       fputs (print_rtx_head, outfile);
       print_rtx (x);


@@ -760,9 +794,7 @@ print_rtl_single (outf, x)
    if RTX is a CONST_INT then print in decimal format.  */
 
 void
    if RTX is a CONST_INT then print in decimal format.  */
 
 void

-print_simple_rtl (outf, x)
-     FILE *outf;
-     rtx x;
+print_simple_rtl (FILE *outf, rtx x)

 {
   flag_simple = 1;
   print_rtl (outf, x);
 {
   flag_simple = 1;
   print_rtl (outf, x);