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

1 files changed, 187 insertions, 118 deletions

diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index b321cfc..7589f69 100644
--- 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);
     }
 }
 
@@ -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);
+    }
 }
 
 /* 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");