*** empty log message ***

From-SVN: r669

gcc/dbxout.c

@@ -557,9 +557,9 @@ dbxout_type_fields (type)
 	      have_used_extensions = 1;
 	      CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem)))));
 	      fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
-	      dbxout_type (DECL_FCONTEXT (tem), 0);
+	      dbxout_type (DECL_FCONTEXT (tem), 0, 0);
 	      fprintf (asmfile, ":");
-	      dbxout_type (TREE_TYPE (tem), 0);
+	      dbxout_type (TREE_TYPE (tem), 0, 0);
 	      fprintf (asmfile, ",%d;",
 		       TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
 	      continue;
@@ -583,7 +583,7 @@ dbxout_type_fields (type)
 	  dbxout_type ((TREE_CODE (tem) == FIELD_DECL
 			&& DECL_BIT_FIELD_TYPE (tem))
 		       ? DECL_BIT_FIELD_TYPE (tem)
-		       : TREE_TYPE (tem), 0);
+		       : TREE_TYPE (tem), 0, 0);
 
 	  if (TREE_CODE (tem) == VAR_DECL)
 	    {
@@ -591,17 +591,6 @@ dbxout_type_fields (type)
 		{
 		  char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
 		  have_used_extensions = 1;
-
-#if 0 /* ??? Comment below makes it clear this is unacceptable.  */
-		  /* Adding 1 here only works on systems
-		     which flush an initial underscore from
-		     the .stabs entry.  This loses for static names
-		     which have an initial leading '_' on systems which
-		     don't use leading underscores.  */
-		  if (name[0] == '_')
-		    name += 1;
-#endif
-
 		  fprintf (asmfile, ":%s;", name);
 		  CHARS (strlen (name));
 		}
@@ -665,7 +654,7 @@ dbxout_type_method_1 (decl, debug_name)
     {
       fprintf (asmfile, "%d;",
 	       TREE_INT_CST_LOW (DECL_VINDEX (decl)));
-      dbxout_type (DECL_CONTEXT (decl), 0);
+      dbxout_type (DECL_CONTEXT (decl), 0, 0);
       fprintf (asmfile, ";");
       CHARS (8);
     }
@@ -679,7 +668,6 @@ dbxout_type_methods (type)
      register tree type;
 {
   /* C++: put out the method names and their parameter lists */
-  tree ctor_name;
   tree methods = TYPE_METHODS (type);
   tree type_encoding;
   register tree fndecl;
@@ -689,13 +677,13 @@ dbxout_type_methods (type)
   if (methods == NULL_TREE)
     return;
 
-  ctor_name = DECL_NAME (TYPE_NAME (type));
+  type_encoding = DECL_NAME (TYPE_NAME (type));
 
   /* C++: Template classes break some assumptions made by this code about
      the class names, constructor names, and encodings for assembler
      label names.  For now, disable output of dbx info for them.  */
   {
-    char *ptr = IDENTIFIER_POINTER (ctor_name);
+    char *ptr = IDENTIFIER_POINTER (type_encoding);
     /* Avoid strchr or index since those names aren't universal.  */
     while (*ptr && *ptr != '<') ptr++;
     if (*ptr != 0)
@@ -710,7 +698,7 @@ dbxout_type_methods (type)
       }
   }
 
-  type_identifier_length = IDENTIFIER_LENGTH (ctor_name);
+  type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
 
   if (TREE_CODE (methods) == FUNCTION_DECL)
     fndecl = methods;
@@ -718,94 +706,13 @@ dbxout_type_methods (type)
     fndecl = TREE_VEC_ELT (methods, 0);
   else fndecl = TREE_VEC_ELT (methods, 1);
 
-  if (TREE_CODE (type) == RECORD_TYPE && DECL_NAME (fndecl) == ctor_name)
-    {
-      tree ctor = fndecl;
-      tree dtor;
-
-      /* Destructors lie in a special place.
-         n.b.  TYPE_HAS_DESTRUCTOR == TYPE_LANG_FLAG_2 */
-      if (TYPE_LANG_FLAG_2 (type))
-	{
-	  dtor = fndecl;
-	  fndecl = ctor = TREE_CHAIN (dtor);
-	}
-      else
-	dtor = NULL_TREE;
-
-      CHARS (2);
-
-      if (ctor)
-	{
-	  int need_prefix = 1;
-
-	  while (ctor)
-	    {
-	      /* Output the name of the field (after overloading), as
-		 well as the name of the field before overloading, along
-		 with its parameter list.  */
-	      char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (ctor));
-	      int old_minimal_debug = flag_minimal_debug;
-
-	      CONTIN;
-
-	      if (DECL_NAME (ctor) == ctor_name && ! DECL_IGNORED_P (ctor))
-		{
-		  if (need_prefix)
-		    {
-		      fprintf (asmfile, "%s::", IDENTIFIER_POINTER (DECL_NAME (ctor)));
-		      CHARS (IDENTIFIER_LENGTH (DECL_NAME (ctor)) + 3);
-		      need_prefix = 0;
-		    }
-
-		  if (ctor == dtor)
-		    /* Always output destructors with full information.  */
-		    flag_minimal_debug = 0;
-
-		  dbxout_type (TREE_TYPE (ctor), 0);
-		  flag_minimal_debug = old_minimal_debug;
-
-		  if (flag_minimal_debug && ctor != dtor)
-		    {
-		      /* Cut down on debugging information by not outputting
-			 the parts of the name we can just as easily
-			 have the debugger figure out.  */
-
-		      /* Get past '__'.  */
-		      debug_name += 2;
-		      /* Get past const and volatile qualifiers.  */
-		      while (*debug_name == 'C' || *debug_name == 'V')
-			debug_name++;
-		      /* Get past numeric type length prefix.  */
-		      while (*debug_name >= '0' && *debug_name <= '9')
-			debug_name++;
-		      /* Get past type of `this'.  */
-		      debug_name += type_identifier_length;
-		    }
-		  dbxout_type_method_1 (ctor, debug_name);
-		}
-
-	      if (ctor == dtor)
-		break;
-
-	      ctor = TREE_CHAIN (ctor);
-	      if (ctor == NULL_TREE || DECL_NAME (ctor) != ctor_name)
-		{
-		  fndecl = ctor;
-		  ctor = dtor;
-		}
-	    }
-	  if (! need_prefix)
-	    putc (';', asmfile);
-	}
-    }
-
   while (fndecl)
     {
       tree name = DECL_NAME (fndecl);
-      fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
-      CHARS (IDENTIFIER_LENGTH (name) + 3);
+      int need_prefix = 1;
 
+      /* Group together all the methods for the same operation.
+	 These differ in the types of the arguments.  */
       for (last = NULL_TREE;
 	   fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
 	   fndecl = TREE_CHAIN (fndecl))
@@ -813,22 +720,65 @@ dbxout_type_methods (type)
 	   well as the name of the field before overloading, along
 	   with its parameter list */
 	{
+	  /* This is the "mangled" name of the method.
+	     It encodes the argument types.  */
 	  char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+	  int destructor = 0;
 
 	  CONTIN;
 
 	  last = fndecl;
-	  dbxout_type (TREE_TYPE (fndecl), 0);
+
+	  if (DECL_IGNORED_P (fndecl))
+	    continue;
+
 	  if (flag_minimal_debug)
 	    {
-	      debug_name += IDENTIFIER_LENGTH (DECL_NAME (fndecl)) + 2;
-	      /* Get past const and volatile qualifiers.  */
-	      while (*debug_name == 'C' || *debug_name == 'V')
-		debug_name++;
-	      while (*debug_name >= '0' && *debug_name <= '9')
-		debug_name++;
-	      debug_name += type_identifier_length;
+	      /* Detect ordinary methods because their mangled names
+		 start with the operation name.  */
+	      if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
+			    IDENTIFIER_LENGTH (name)))
+		{
+		  debug_name += IDENTIFIER_LENGTH (name);
+		  if (debug_name[0] == '_' && debug_name[1] == '_')
+		    {
+		      char *method_name = debug_name + 2;
+		      /* Get past const and volatile qualifiers.  */
+		      while (*method_name == 'C' || *method_name == 'V')
+			method_name++;
+		      if (! strncmp (method_name,
+				     IDENTIFIER_POINTER (type_encoding),
+				     type_identifier_length))
+			method_name += type_identifier_length;
+		      debug_name = method_name;
+		    }
+		}
+	      /* Detect constructors by their style of name mangling.  */
+	      else if (debug_name[0] == '_' && debug_name[1] == '_')
+		{
+		  char *ctor_name = debug_name + 2;
+		  while (*ctor_name == 'C' || *ctor_name == 'V')
+		    ctor_name++;
+		  if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
+				type_identifier_length))
+		    debug_name = ctor_name + type_identifier_length;
+		}
+	      /* The other alternative is a destructor.  */
+	      else
+		destructor = 1;
+
+	      /* Output the operation name just once, for the first method
+		 that we output.  */
+	      if (need_prefix)
+		{
+		  fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
+		  CHARS (IDENTIFIER_LENGTH (name) + 2);
+		  need_prefix = 0;
+		}
 	    }
+
+	  dbxout_type (TREE_TYPE (fndecl), 0, destructor);
+
 	  dbxout_type_method_1 (fndecl, debug_name);
 	}
       putc (';', asmfile);
@@ -844,12 +794,16 @@ dbxout_type_methods (type)
    If FULL is nonzero, and the type has been described only with
    a forward-reference, output the definition now.
    If FULL is zero in this case, just refer to the forward-reference
-   using the number previously allocated.  */
+   using the number previously allocated.
+
+   If SHOW_ARG_TYPES is nonzero, we output a description of the argument
+   types for a METHOD_TYPE.  */
 
 static void
-dbxout_type (type, full)
+dbxout_type (type, full, show_arg_types)
      tree type;
      int full;
+     int show_arg_types;
 {
   register tree tem;
 
@@ -996,7 +950,7 @@ dbxout_type (type, full)
 		? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
 	        : -1));
       CHARS (17);
-      dbxout_type (TREE_TYPE (type), 0);
+      dbxout_type (TREE_TYPE (type), 0, 0);
       break;
 
     case RECORD_TYPE:
@@ -1015,7 +969,9 @@ dbxout_type (type, full)
 		   && DECL_IGNORED_P (TYPE_NAME (type)))
 #endif
 	     && !full)
-	    || TYPE_SIZE (type) == 0)
+	    || TYPE_SIZE (type) == 0
+	    /* No way in DBX fmt to describe a variable size.  */
+	    || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
 	  {
 	    /* If the type is just a cross reference, output one
 	       and mark the type as partially described.
@@ -1040,10 +996,6 @@ dbxout_type (type, full)
 	  }
 	tem = size_in_bytes (type);
 
-	/* The code below assumes the size is an integer constant.  */
-	if (TREE_CODE (tem) != INTEGER_CST)
-	  abort ();
-
 	/* Identify record or union, and print its size.  */
 	fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
 		 TREE_INT_CST_LOW (tem));
@@ -1072,7 +1024,7 @@ dbxout_type (type, full)
 		fprintf (asmfile, "%d,",
 			 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
 		CHARS (15);
-		dbxout_type (BINFO_TYPE (child), 0);
+		dbxout_type (BINFO_TYPE (child), 0, 0);
 		putc (';', asmfile);
 	      }
 	    else
@@ -1081,7 +1033,7 @@ dbxout_type (type, full)
 		   which have the same names at the types they hold.  */
 		dbxout_type_name (BINFO_TYPE (child));
 		putc (':', asmfile);
-		dbxout_type (BINFO_TYPE (child), full);
+		dbxout_type (BINFO_TYPE (child), full, 0);
 		fprintf (asmfile, ",%d,%d;",
 			 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
 			 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
@@ -1117,7 +1069,7 @@ dbxout_type (type, full)
 	  if (TYPE_VFIELD (type))
 	    {
 	      putc ('%', asmfile);
-	      dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
+	      dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
 	    }
 	  putc (';', asmfile);
 	  CHARS (3);
@@ -1154,7 +1106,7 @@ dbxout_type (type, full)
     case POINTER_TYPE:
       putc ('*', asmfile);
       CHARS (1);
-      dbxout_type (TREE_TYPE (type), 0);
+      dbxout_type (TREE_TYPE (type), 0, 0);
       break;
 
     case METHOD_TYPE:
@@ -1163,19 +1115,23 @@ dbxout_type (type, full)
 	  have_used_extensions = 1;
 	  putc ('#', asmfile);
 	  CHARS (1);
-	  if (flag_minimal_debug)
+	  if (flag_minimal_debug && !show_arg_types)
 	    {
+	      /* Normally, just output the return type.
+		 The argument types are encoded in the method name.  */
 	      putc ('#', asmfile);
-	      dbxout_type (TREE_TYPE (type), 0);
+	      dbxout_type (TREE_TYPE (type), 0, 0);
 	      putc (';', asmfile);
 	      CHARS (1);
 	    }
 	  else
 	    {
-	      dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
+	      /* When outputing destructors, we need to write
+		 the argument types out longhand.  */
+	      dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
 	      putc (',', asmfile);
 	      CHARS (1);
-	      dbxout_type (TREE_TYPE (type), 0);
+	      dbxout_type (TREE_TYPE (type), 0, 0);
 	      dbxout_args (TYPE_ARG_TYPES (type));
 	      putc (';', asmfile);
 	      CHARS (1);
@@ -1184,7 +1140,7 @@ dbxout_type (type, full)
       else
 	{
 	  /* Treat it as a function type.  */
-	  dbxout_type (TREE_TYPE (type), 0);
+	  dbxout_type (TREE_TYPE (type), 0, 0);
 	}
       break;
 
@@ -1194,16 +1150,16 @@ dbxout_type (type, full)
 	  have_used_extensions = 1;
 	  putc ('@', asmfile);
 	  CHARS (1);
-	  dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
+	  dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
 	  putc (',', asmfile);
 	  CHARS (1);
-	  dbxout_type (TREE_TYPE (type), 0);
+	  dbxout_type (TREE_TYPE (type), 0, 0);
 	}
       else
 	{
 	  /* Should print as an int, because it is really
 	     just an offset.  */
-	  dbxout_type (integer_type_node, 0);
+	  dbxout_type (integer_type_node, 0, 0);
 	}
       break;
 
@@ -1212,13 +1168,13 @@ dbxout_type (type, full)
 	have_used_extensions = 1;
       putc (use_gdb_dbx_extensions ? '&' : '*', asmfile);
       CHARS (1);
-      dbxout_type (TREE_TYPE (type), 0);
+      dbxout_type (TREE_TYPE (type), 0, 0);
       break;
 
     case FUNCTION_TYPE:
       putc ('f', asmfile);
       CHARS (1);
-      dbxout_type (TREE_TYPE (type), 0);
+      dbxout_type (TREE_TYPE (type), 0, 0);
       break;
 
     default:
@@ -1355,9 +1311,9 @@ dbxout_symbol (decl, local)
       current_sym_addr = XEXP (DECL_RTL (decl), 0);
 
       if (TREE_TYPE (type))
-	dbxout_type (TREE_TYPE (type), 0);
+	dbxout_type (TREE_TYPE (type), 0, 0);
       else
-	dbxout_type (void_type_node, 0);
+	dbxout_type (void_type_node, 0, 0);
 
       /* For a nested function, when that function is compiled,
 	 mention the containing function name
@@ -1409,7 +1365,7 @@ dbxout_symbol (decl, local)
 	  putc ('t', asmfile);
 	  current_sym_code = DBX_DECL_STABS_CODE;
 
-	  dbxout_type (type, 1);
+	  dbxout_type (type, 1, 0);
 	  dbxout_finish_symbol (decl);
 	}
       else if (TYPE_NAME (type) != 0 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
@@ -1429,7 +1385,7 @@ dbxout_symbol (decl, local)
 
 	  fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
 		   IDENTIFIER_POINTER (name));
-	  dbxout_type (type, 1);
+	  dbxout_type (type, 1, 0);
 	  dbxout_finish_symbol (0);
 	}
 
@@ -1673,22 +1629,13 @@ dbxout_symbol (decl, local)
 	/* Note also that static member (variable) names DO NOT begin
 	   with underscores in .stabs directives.  */
 	if (DECL_LANG_SPECIFIC (decl))
-	  {
-	    name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
-
-#if 0 /* Tiemann says get rid of this.  */
-	    /* Adding 1 here only works on systems
-	       which flush an initial underscore.  */
-	    if (name[0] == '_')
-	      name += 1;
-#endif
-	  }
+	  name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 	else
 	  name = IDENTIFIER_POINTER (DECL_NAME (decl));
 	fprintf (asmfile, "%s \"%s:", ASM_STABS_OP, name);
       }
       if (letter) putc (letter, asmfile);
-      dbxout_type (type, 0);
+      dbxout_type (type, 0, 0);
       dbxout_finish_symbol (decl);
 
 #ifdef DBX_STATIC_BLOCK_END
@@ -1812,7 +1759,7 @@ dbxout_parms (parms)
 	    if (GET_CODE (DECL_RTL (parms)) == REG
 		&& REGNO (DECL_RTL (parms)) >= 0
 		&& REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
-	      dbxout_type (DECL_ARG_TYPE (parms), 0);
+	      dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
 	    else
 	      {
 		int original_value = current_sym_value;
@@ -1833,11 +1780,11 @@ dbxout_parms (parms)
 		    && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
 		    && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
 		    && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
-		  dbxout_type (TREE_TYPE (parms), 0);
+		  dbxout_type (TREE_TYPE (parms), 0, 0);
 		else
 		  {
 		    current_sym_value = original_value;
-		    dbxout_type (DECL_ARG_TYPE (parms), 0);
+		    dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
 		  }
 	      }
 	    current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
@@ -1881,7 +1828,7 @@ dbxout_parms (parms)
 			 regparm_letter);
 	      }
 
-	    dbxout_type (DECL_ARG_TYPE (parms), 0);
+	    dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
 	    dbxout_finish_symbol (parms);
 	  }
 	else if (GET_CODE (DECL_RTL (parms)) == MEM
@@ -1918,7 +1865,7 @@ dbxout_parms (parms)
 	    current_sym_value
 	      = DEBUGGER_ARG_OFFSET (current_sym_value,
 				     XEXP (DECL_RTL (parms), 0));
-	    dbxout_type (TREE_TYPE (parms), 0);
+	    dbxout_type (TREE_TYPE (parms), 0, 0);
 	    dbxout_finish_symbol (parms);
 	  }
       }
@@ -1967,7 +1914,7 @@ dbxout_reg_parms (parms)
 		current_sym_nchars = 8;
 		fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
 	      }
-	    dbxout_type (TREE_TYPE (parms), 0);
+	    dbxout_type (TREE_TYPE (parms), 0, 0);
 	    dbxout_finish_symbol (parms);
 	  }
 	/* Report parms that live in memory but not where they were passed.  */
@@ -2004,7 +1951,7 @@ dbxout_reg_parms (parms)
 		current_sym_nchars = 8;
 		fprintf (asmfile, "%s \"(anon):", ASM_STABS_OP);
 	      }
-	    dbxout_type (TREE_TYPE (parms), 0);
+	    dbxout_type (TREE_TYPE (parms), 0, 0);
 	    dbxout_finish_symbol (parms);
 	  }
       }
@@ -2020,7 +1967,7 @@ dbxout_args (args)
   while (args)
     {
       putc (',', asmfile);
-      dbxout_type (TREE_VALUE (args), 0);
+      dbxout_type (TREE_VALUE (args), 0, 0);
       CHARS (1);
       args = TREE_CHAIN (args);
     }