dbxout.c: Consistently use putc instead of fputc.

	* dbxout.c: Consistently use putc instead of fputc.
 	(print_wide_int): New function; call instead of direct fprintf.
	(dbxout_type_index): Adjust calls of CHARS to be more accurate.
	(dbxout_type_fields, dbxout_type_method_1): Likewise.
	(dbxout_type_methods, dbxout_range_type, dbxout_type): Likewise.
	(print_int_cst_octal): Likewise.
	(print_octal): Show we wrote characters.
	(dbxout_type): Set have_used_extensions in more places.

From-SVN: r44367

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d6ecd42a5bab205953cc64b29bff8bb2d48594e1..690e74f1e80498e05f7331ce663f73017256ee51 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+Wed Jul 25 18:00:05 2001  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+       * dbxout.c: Consistently use putc instead of fputc.
+       (print_wide_int): New function; call instead of direct fprintf.
+       (dbxout_type_index): Adjust calls of CHARS to be more accurate.
+       (dbxout_type_fields, dbxout_type_method_1): Likewise.
+       (dbxout_type_methods, dbxout_range_type, dbxout_type): Likewise.
+       (print_int_cst_octal): Likewise.
+       (print_octal): Show we wrote characters.
+       (dbxout_type): Set have_used_extensions in more places.
+
 2001-07-25  Catherine Moore  <clm@redhat.com>
 
         * config/v850/v850.c (v850_va_arg):  Use addr
@@ -7,7 +18,8 @@ Wed Jul 25 22:48:59 CEST 2001  Jan Hubicka  <jh@suse.cz>
 
        * flow.c (delete_dead_jumptables): New function.
        (life_analyzis): Call it.
-       * bb-reorder.c (skip_insns_after_block): Handle contradictive sequences.
+       * bb-reorder.c (skip_insns_after_block): Handle contradictory
+       sequences.
 
 2001-07-25  Richard Henderson  <rth@redhat.com>
 
@@ -17,7 +29,7 @@ Wed Jul 25 22:48:59 CEST 2001  Jan Hubicka  <jh@suse.cz>
 2001-07-25  Richard Henderson  <rth@redhat.com>
 
        * config/alpha/alpha.c (alpha_emit_conditional_move): Always
-       swap GE/GT if its an fp comparison.
+       swap GE/GT if it is an fp comparison.
 
 2001-07-25  Andrew Haley  <aph@cambridge.redhat.com>
 

diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index b321cfce745b11103ed2300037cfe09b3547aa8d..7589f69f6b00d0d4aa678c8133742eb14c2cf690 100644 (file)
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -306,6 +306,7 @@ static void dbxout_range_type               PARAMS ((tree));
 static void dbxout_type                        PARAMS ((tree, int));
 static void print_int_cst_octal                PARAMS ((tree));
 static void print_octal                        PARAMS ((unsigned HOST_WIDE_INT, int));
+static void print_wide_int             PARAMS ((HOST_WIDE_INT));
 static void dbxout_type_name           PARAMS ((tree));
 static int dbxout_symbol_location      PARAMS ((tree, tree, const char *, rtx));
 static void dbxout_symbol_name         PARAMS ((tree, const char *, int));
@@ -394,7 +395,7 @@ dbxout_function_end ()
      symbol and an empty string.  */
   fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
   assemble_name (asmfile, lscope_label_name);
-  fputc ('-', asmfile);
+  putc ('-', asmfile);
   assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
   fprintf (asmfile, "\n");
 }
@@ -690,7 +691,7 @@ dbxout_type_index (type)
 #else
   struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
   fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
-  CHARS (7);
+  CHARS (9);
 #endif
 }
 
@@ -756,7 +757,7 @@ dbxout_type_fields (type)
          else
            {
              fprintf (asmfile, ":");
-             CHARS (2);
+             CHARS (1);
            }
 
          if (use_gnu_debug_info_extensions
@@ -779,26 +780,27 @@ dbxout_type_fields (type)
            {
              if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
                {
-                 const char *name =
-                   IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
+                 tree name = DECL_ASSEMBLER_NAME (tem);
+
                  have_used_extensions = 1;
-                 fprintf (asmfile, ":%s;", name);
-                 CHARS (strlen (name));
+                 fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
+                 CHARS (IDENTIFIER_LENGTH (name) + 2);
                }
              else
-               /* If TEM is non-static, GDB won't understand it.  */
-               fprintf (asmfile, ",0,0;");
+               {
+                 /* If TEM is non-static, GDB won't understand it.  */
+                 fprintf (asmfile, ",0,0;");
+                 CHARS (5);
+               }
            }
          else
            {
-             fputc (',', asmfile);
-             fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                      int_bit_position (tem));
-             fputc (',', asmfile);
-             fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                      tree_low_cst (DECL_SIZE (tem), 1));
-             fputc (';', asmfile);
-             CHARS (23);
+             putc (',', asmfile);
+             print_wide_int (int_bit_position (tem));
+             putc (',', asmfile);
+             print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
+             putc (';', asmfile);
+             CHARS (3);
            }
        }
     }
@@ -844,12 +846,12 @@ dbxout_type_method_1 (decl, debug_name)
 
   if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
     {
-      fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-              tree_low_cst (DECL_VINDEX (decl), 0));
-      fputc (';', asmfile);
+      print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
+      putc (';', asmfile);
+      CHARS (1);
       dbxout_type (DECL_CONTEXT (decl), 0);
       fprintf (asmfile, ";");
-      CHARS (8);
+      CHARS (1);
     }
 }
 \f
@@ -925,8 +927,7 @@ dbxout_type_methods (type)
          if (TREE_CODE (fndecl) != FUNCTION_DECL)
            continue;
 
-         debug_name =
-           IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+         debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
 
          CONTIN;
 
@@ -995,23 +996,30 @@ dbxout_range_type (type)
   if (TYPE_MIN_VALUE (type) != 0
       && host_integerp (TYPE_MIN_VALUE (type), 0))
     {
-      fputc (';', asmfile);
-      fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-              tree_low_cst (TYPE_MIN_VALUE (type), 0));
+      putc (';', asmfile);
+      CHARS (1);
+      print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
     }
   else
-    fprintf (asmfile, ";0");
+    {
+      fprintf (asmfile, ";0");
+      CHARS (2);
+    }
 
   if (TYPE_MAX_VALUE (type) != 0
       && host_integerp (TYPE_MAX_VALUE (type), 0))
     {
-      fputc (';', asmfile);
-      fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-              tree_low_cst (TYPE_MAX_VALUE (type), 0));
-      fputc (';', asmfile);
+      putc (';', asmfile);
+      CHARS (1);
+      print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
+      putc (';', asmfile);
+      CHARS (1);
     }
   else
-    fprintf (asmfile, ";-1;");
+    {
+      fprintf (asmfile, ";-1;");
+      CHARS (4);
+    }
 }
 \f
 /* Output a reference to a type.  If the type has not yet been
@@ -1177,8 +1185,10 @@ dbxout_type (type, full)
             This used to use `r2' explicitly and we used to
             take care to make sure that `char' was type number 2.  */
          fprintf (asmfile, "r");
+         CHARS (1);
          dbxout_type_index (type);
          fprintf (asmfile, ";0;127;");
+         CHARS (7);
        }
 
       /* If this is a subtype of another integer type, always prefer to
@@ -1194,7 +1204,11 @@ dbxout_type (type, full)
 
          if (use_gnu_debug_info_extensions
              && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
-           fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
+           {
+             have_used_extensions = 1;
+             fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
+             CHARS (5);
+           }
 
          /* If we can use GDB extensions and the size is wider than a
             long (the size used by GDB to read them) or we may have
@@ -1222,12 +1236,16 @@ dbxout_type (type, full)
                      && TREE_UNSIGNED (type))))
            {
              fprintf (asmfile, "r");
+             CHARS (1);
              dbxout_type_index (type);
              fprintf (asmfile, ";");
+             CHARS (1);
              print_int_cst_octal (TYPE_MIN_VALUE (type));
              fprintf (asmfile, ";");
+             CHARS (1);
              print_int_cst_octal (TYPE_MAX_VALUE (type));
              fprintf (asmfile, ";");
+             CHARS (1);
            }
 
          else
@@ -1235,50 +1253,58 @@ dbxout_type (type, full)
            dbxout_range_type (type);
        }
 
-      CHARS (22);
       break;
 
     case REAL_TYPE:
       /* This used to say `r1' and we used to take care
         to make sure that `int' was type number 1.  */
       fprintf (asmfile, "r");
+      CHARS (1);
       dbxout_type_index (integer_type_node);
-      fputc (';', asmfile);
-      fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
+      putc (';', asmfile);
+      CHARS (1);
+      print_wide_int (int_size_in_bytes (type));
       fputs (";0;", asmfile);
-      CHARS (13);
+      CHARS (3);
       break;
 
     case CHAR_TYPE:
       if (use_gnu_debug_info_extensions)
        {
+         have_used_extensions = 1;
          fputs ("@s", asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                  BITS_PER_UNIT * int_size_in_bytes (type));
+         CHARS (2);
+         print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
          fputs (";-20;", asmfile);
+         CHARS (4);
        }
       else
        {
          /* Output the type `char' as a subrange of itself.
             That is what pcc seems to do.  */
          fprintf (asmfile, "r");
+         CHARS (1);
          dbxout_type_index (char_type_node);
          fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
+         CHARS (7);
        }
-      CHARS (9);
       break;
 
     case BOOLEAN_TYPE:
       if (use_gnu_debug_info_extensions)
        {
+         have_used_extensions = 1;
          fputs ("@s", asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                  BITS_PER_UNIT * int_size_in_bytes (type));
+         CHARS (2);
+         print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
          fputs (";-16;", asmfile);
+         CHARS (4);
        }
       else /* Define as enumeral type (False, True) */
-       fprintf (asmfile, "eFalse:0,True:1,;");
-      CHARS (17);
+       {
+         fprintf (asmfile, "eFalse:0,True:1,;");
+         CHARS (17);
+       }
       break;
 
     case FILE_TYPE:
@@ -1293,33 +1319,33 @@ dbxout_type (type, full)
       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
        {
          fprintf (asmfile, "r");
+         CHARS (1);
          dbxout_type_index (type);
-         fputc (';', asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                  2 * int_size_in_bytes (TREE_TYPE (type)));
+         putc (';', asmfile);
+         CHARS (1);
+         print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
          fputs (";0;", asmfile);
-         CHARS (12);           /* The number is probably incorrect here.  */
+         CHARS (3);
        }
       else
        {
          /* Output a complex integer type as a structure,
             pending some other way to do it.  */
-         fputc ('s', asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
-
+         putc ('s', asmfile);
+         CHARS (1);
+         print_wide_int (int_size_in_bytes (type));
          fprintf (asmfile, "real:");
-         CHARS (10);
+         CHARS (5);
+
          dbxout_type (TREE_TYPE (type), 0);
-         fprintf (asmfile, ",%d,%d;",
-                  0, TYPE_PRECISION (TREE_TYPE (type)));
-         CHARS (8);
+         fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
+         CHARS (7);
          fprintf (asmfile, "imag:");
          CHARS (5);
          dbxout_type (TREE_TYPE (type), 0);
-         fprintf (asmfile, ",%d,%d;;",
-                  TYPE_PRECISION (TREE_TYPE (type)),
+         fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
                   TYPE_PRECISION (TREE_TYPE (type)));
-         CHARS (9);
+         CHARS (10);
        }
       break;
 
@@ -1328,13 +1354,18 @@ dbxout_type (type, full)
        {
          have_used_extensions = 1;
          fputs ("@s", asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                  BITS_PER_UNIT * int_size_in_bytes (type));
-         fputc (';', asmfile);
+         CHARS (2);
+         print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
+         putc (';', asmfile);
+         CHARS (1);
+
          /* Check if a bitstring type, which in Chill is
             different from a [power]set.  */
          if (TYPE_STRING_FLAG (type))
-           fprintf (asmfile, "@S;");
+           {
+             fprintf (asmfile, "@S;");
+             CHARS (3);
+           }
        }
       putc ('S', asmfile);
       CHARS (1);
@@ -1347,15 +1378,14 @@ dbxout_type (type, full)
        {
          have_used_extensions = 1;
          fputs ("@s", asmfile);
-         fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                  BITS_PER_UNIT * int_size_in_bytes (type));
-         fputc (';', asmfile);
-         fprintf (asmfile, "@S;");
-         putc ('S', asmfile);
-         CHARS (1);
+         CHARS (2);
+         print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
+         fprintf (asmfile, ";@S;S");
+         CHARS (5);
          dbxout_type (TYPE_DOMAIN (type), 0);
          break;
        }
+
       /* Output "a" followed by a range type definition
         for the index type of the array
         followed by a reference to the target-type.
@@ -1366,20 +1396,24 @@ dbxout_type (type, full)
        {
          have_used_extensions = 1;
          fprintf (asmfile, "@S;");
+         CHARS (3);
        }
       tem = TYPE_DOMAIN (type);
       if (tem == NULL)
        {
          fprintf (asmfile, "ar");
+         CHARS (2);
          dbxout_type_index (integer_type_node);
          fprintf (asmfile, ";0;-1;");
+         CHARS (6);
        }
       else
        {
          fprintf (asmfile, "a");
+         CHARS (1);
          dbxout_range_type (tem);
        }
-      CHARS (14);
+
       dbxout_type (TREE_TYPE (type), 0);
       break;
 
@@ -1412,7 +1446,7 @@ dbxout_type (type, full)
               another type's definition; instead, output an xref
               and let the definition come when the name is defined.  */
            fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
-           CHARS (3);
+           CHARS (2);
 #if 0 /* This assertion is legitimately false in C++.  */
            /* We shouldn't be outputting a reference to a type before its
               definition unless the type has a tag name.
@@ -1423,16 +1457,21 @@ dbxout_type (type, full)
            if (TYPE_NAME (type) != 0)
              dbxout_type_name (type);
            else
-             fprintf (asmfile, "$$%d", anonymous_type_number++);
+             {
+               fprintf (asmfile, "$$%d", anonymous_type_number++);
+               CHARS (5);
+             }
+
            fprintf (asmfile, ":");
+           CHARS (1);
            typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
            break;
          }
 
        /* Identify record or union, and print its size.  */
-       fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
-       fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                int_size_in_bytes (type));
+       putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
+       CHARS (1);
+       print_wide_int (int_size_in_bytes (type));
 
        if (use_gnu_debug_info_extensions)
          {
@@ -1452,13 +1491,14 @@ dbxout_type (type, full)
                have_used_extensions = 1;
                putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
                putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
-               fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                        (tree_low_cst (BINFO_OFFSET (child), 0)
-                         * BITS_PER_UNIT));
-               fputc (',', asmfile);
-               CHARS (15);
+               CHARS (2);
+               print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
+                               * BITS_PER_UNIT);
+               putc (',', asmfile);
+               CHARS (1);
                dbxout_type (BINFO_TYPE (child), 0);
                putc (';', asmfile);
+               CHARS (1);
              }
            else
              {
@@ -1466,24 +1506,25 @@ dbxout_type (type, full)
                   which have the same names at the types they hold.  */
                dbxout_type_name (BINFO_TYPE (child));
                putc (':', asmfile);
+               CHARS (1);
                dbxout_type (BINFO_TYPE (child), full);
-               fputc (',', asmfile);
-               fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                        tree_low_cst (BINFO_OFFSET (child), 0)
-                        * BITS_PER_UNIT);
-               fputc (',', asmfile);
-               fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                        (tree_low_cst (DECL_SIZE (TYPE_NAME
-                                                 (BINFO_TYPE (child))), 0)
-                         * BITS_PER_UNIT));
-               fputc (';', asmfile);
-               CHARS (20);
+               putc (',', asmfile);
+               CHARS (1);
+               print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
+                               * BITS_PER_UNIT);
+               putc (',', asmfile);
+               CHARS (1);
+               print_wide_int (tree_low_cst (DECL_SIZE
+                                             (TYPE_NAME
+                                              (BINFO_TYPE (child))),
+                                             0)
+                               * BITS_PER_UNIT);
+               putc (';', asmfile);
+               CHARS (1);
              }
          }
       }
 
-      CHARS (11);
-
       /* Write out the field declarations.  */
       dbxout_type_fields (type);
       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
@@ -1493,6 +1534,7 @@ dbxout_type (type, full)
        }
 
       putc (';', asmfile);
+      CHARS (1);
 
       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
          /* Avoid the ~ if we don't really need it--it confuses dbx.  */
@@ -1502,6 +1544,7 @@ dbxout_type (type, full)
 
          /* Tell GDB+ that it may keep reading.  */
          putc ('~', asmfile);
+         CHARS (1);
 
          /* We need to write out info about what field this class
             uses as its "main" vtable pointer field, because if this
@@ -1510,10 +1553,12 @@ dbxout_type (type, full)
          if (TYPE_VFIELD (type))
            {
              putc ('%', asmfile);
+             CHARS (1);
              dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
            }
+
          putc (';', asmfile);
-         CHARS (3);
+         CHARS (1);
        }
       break;
 
@@ -1528,10 +1573,11 @@ dbxout_type (type, full)
          || !COMPLETE_TYPE_P (type))
        {
          fprintf (asmfile, "xe");
-         CHARS (3);
+         CHARS (2);
          dbxout_type_name (type);
          typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
-         fprintf (asmfile, ":");
+         putc (':', asmfile);
+         CHARS (1);
          return;
        }
 #ifdef DBX_OUTPUT_ENUM
@@ -1539,28 +1585,31 @@ dbxout_type (type, full)
 #else
       if (use_gnu_debug_info_extensions
          && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
-       fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
+       {
+         fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
+         CHARS (5);
+       }
+
       putc ('e', asmfile);
       CHARS (1);
       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
        {
          fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
+         CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
          if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
-           fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
-                    TREE_INT_CST_LOW (TREE_VALUE (tem)));
+           print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
          else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
-           fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
-                    TREE_INT_CST_LOW (TREE_VALUE (tem)));
+           print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
          else
            print_int_cst_octal (TREE_VALUE (tem));
-         fprintf (asmfile, ",");
-         CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
+
+         putc (',', asmfile);
+         CHARS (1);
          if (TREE_CHAIN (tem) != 0)
-           {
-             CONTIN;
-           }
+           CONTIN;
        }
+
       putc (';', asmfile);
       CHARS (1);
 #endif
@@ -1589,10 +1638,8 @@ dbxout_type (type, full)
          CHARS (1);
        }
       else
-       {
-         /* Treat it as a function type.  */
-         dbxout_type (TREE_TYPE (type), 0);
-       }
+       /* Treat it as a function type.  */
+       dbxout_type (TREE_TYPE (type), 0);
       break;
 
     case OFFSET_TYPE:
@@ -1607,11 +1654,8 @@ dbxout_type (type, full)
          dbxout_type (TREE_TYPE (type), 0);
        }
       else
-       {
-         /* Should print as an int, because it is really
-            just an offset.  */
-         dbxout_type (integer_type_node, 0);
-       }
+       /* Should print as an int, because it is really just an offset.  */
+       dbxout_type (integer_type_node, 0);
       break;
 
     case REFERENCE_TYPE:
@@ -1658,6 +1702,7 @@ print_int_cst_octal (c)
     high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
 
   fprintf (asmfile, "0");
+  CHARS (1);
 
   if (excess == 3)
     {
@@ -1676,6 +1721,7 @@ print_int_cst_octal (c)
                 - 1);
 
       fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
+      CHARS (2);
       print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
     }
 }
@@ -1689,8 +1735,29 @@ print_octal (value, digits)
 
   for (i = digits - 1; i >= 0; i--)
     fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
+
+  CHARS (digits);
 }
 
+/* Output C in decimal while adjusting the number of digits written.  */
+
+static void
+print_wide_int (c)
+     HOST_WIDE_INT c;
+{
+  int digs = 0;
+
+  fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
+
+  if (c < 0)
+    digs++, c = -c;
+
+  while (c > 0)
+    c /= 10; digs++;
+
+  CHARS (digs);
+}
+      
 /* Output the name of type TYPE, with no punctuation.
    Such names can be set up either by typedef declarations
    or by struct, enum and union tags.  */
@@ -2257,7 +2324,8 @@ dbxout_symbol_name (decl, suffix, letter)
   fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
           (suffix ? suffix : ""));
 
-  if (letter) putc (letter, asmfile);
+  if (letter)
+    putc (letter, asmfile);
 }
 
 static void
@@ -2479,7 +2547,8 @@ dbxout_parms (parms)
            FORCE_TEXT;
            if (DECL_NAME (parms))
              {
-               current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
+               current_sym_nchars
+                 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
 
                fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
                         IDENTIFIER_POINTER (DECL_NAME (parms)),
@@ -2715,7 +2784,7 @@ dbxout_block (block, depth, args)
              fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
              assemble_name (asmfile, buf);
 #if DBX_BLOCKS_FUNCTION_RELATIVE
-             fputc ('-', asmfile);
+             putc ('-', asmfile);
              assemble_name (asmfile, begin_label);
 #endif
              fprintf (asmfile, "\n");
@@ -2745,7 +2814,7 @@ dbxout_block (block, depth, args)
              fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
              assemble_name (asmfile, buf);
 #if DBX_BLOCKS_FUNCTION_RELATIVE
-             fputc ('-', asmfile);
+             putc ('-', asmfile);
              assemble_name (asmfile, begin_label);
 #endif
              fprintf (asmfile, "\n");