Speed up GDB startup time by not demangling partial symbols.

	* symfile.h (ADD_PSYMBOL_VT_TO_LIST),
	symfile.c (add_psymbol_to_list, add_psymbol_addr_to_list):
	No longer demangle partial symbols.
	* symtab.c (lookup_symbol, list_symbols): Handle mangled
	variables, e.g. C++ static members, via the minimal symbols.

	Handle reordered functions in an objfile, for Irix 5.2 shared
	libraries.
	* objfiles.h (OBJF_REORDERED):  New bit in the objfile flags,
	set if the functions in an objfile are reordered.
	* mdebugread.c (parse_partial_symbols):  Detect reordered
	functions in an objfile.
	* symtab.c (find_pc_psymtab, find_pc_symtab):  Use expensive
	lookup algorithm if the functions in the objfile are reordered.

	* xcoffexec.c (exec_close):  If the current target has a copy
	of the exec_ops sections, reflect the freeing of the sections
	in current_target.

	* valops.c (call_function_by_hand):  Use `sizeof dummy1', not
	`sizeof dummy', for constructing the call dummy code.

	* config/sparc/tm-sparc.h:  Add PARAMS declarations to all
	function declarations.
	* sparc-tdep.c (sparc_pop_frame):  Cast result of
	read_memory_integer to CORE_ADDR when passing it to PC_ADJUST.

	* irix5-nat.c (enable_break):  Set breakpoint at the entry point
	of the executable, to handle the case where main resides in a
	shared library.
	* irix5-nat.c (solib_create_inferior_hook):  Reset stop_soon_quietly
	after shared library symbol reading, to get rid of a warning from
	heuristic_proc_start if the startup code has no symbolic debug info.

	* breakpoint.h (struct breakpoint):  Add new fields language
	and input_radix, to enable breakpoint resetting with the
	proper language and radix.
	* breakpoint.c (set_raw_breakpoint):  Initialize them.
	(breakpoint_re_set_one):  Use them when resetting the breakpoint.
	(breakpoint_re_set):  Preserve current language and input_radix
	across breakpoint_re_set_one calls.

	* symtab.c (decode_line_1):  Do not build a canonical line
	specification for `*expr' line specifications.

	* breakpoint.h (bpstat_stop_status):  Fix prototype declaration.

1 files changed, 185 insertions, 137 deletions

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 0a63964..3f6c00e 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -35,7 +35,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "demangle.h"
 
 #include <obstack.h>
-#include <assert.h>
 
 #include <sys/types.h>
 #include <fcntl.h>
@@ -291,7 +290,6 @@ gdb_mangle_name (type, i, j)
   if (!is_destructor)
     is_destructor = (strncmp(physname, "__dt", 4) == 0); 
 
-#ifndef GCC_MANGLE_BUG
   if (is_destructor || is_full_physname_constructor)
     {
       mangled_name = (char*) xmalloc(strlen(physname)+1);
@@ -305,6 +303,13 @@ gdb_mangle_name (type, i, j)
       if (strcmp(buf, "__") == 0)
 	buf[0] = '\0';
     }
+  else if (newname != NULL && strchr (newname, '<') != NULL)
+    {
+      /* Template methods are fully mangled.  */
+      sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
+      newname = NULL;
+      len = 0;
+    }
   else
     {
       sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
@@ -343,51 +348,6 @@ gdb_mangle_name (type, i, j)
   if (newname != NULL)
     strcat (mangled_name, newname);
 
-#else
-
-  if (is_constructor)
-    {
-      buf[0] = '\0';
-    }
-  else
-    {
-      sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
-    }
-
-  mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
-		      + strlen (buf) + strlen (physname) + 1);
-
-  /* Only needed for GNU-mangled names.  ANSI-mangled names
-     work with the normal mechanisms.  */
-  if (OPNAME_PREFIX_P (field_name))
-    {
-      char *opname;
-      opname = cplus_mangle_opname (field_name + 3, 0);
-      if (opname == NULL)
-	{
-	  error ("No mangling for \"%s\"", field_name);
-	}
-      mangled_name_len += strlen (opname);
-      mangled_name = (char *) xmalloc (mangled_name_len);
-
-      strncpy (mangled_name, field_name, 3);
-      strcpy (mangled_name + 3, opname);
-    }
-  else
-    {
-      mangled_name = (char *) xmalloc (mangled_name_len);
-      if (is_constructor)
-	{
-	  mangled_name[0] = '\0';
-	}
-      else
-	{
-	  strcpy (mangled_name, field_name);
-	}
-    }
-  strcat (mangled_name, buf);
-
-#endif
   strcat (mangled_name, physname);
   return (mangled_name);
 }
@@ -405,7 +365,36 @@ find_pc_psymtab (pc)
   ALL_PSYMTABS (objfile, pst)
     {
       if (pc >= pst->textlow && pc < pst->texthigh)
-	return (pst);
+	{
+	  struct minimal_symbol *msymbol;
+	  struct partial_symtab *tpst;
+
+	  /* An objfile that has its functions reordered might have
+	     many partial symbol tables containing the PC, but
+	     we want the partial symbol table that contains the
+	     function containing the PC.  */
+	  if (!(objfile->flags & OBJF_REORDERED))
+	    return (pst);
+
+	  msymbol = lookup_minimal_symbol_by_pc (pc);
+	  if (msymbol == NULL)
+	    return (pst);
+
+	  for (tpst = pst; tpst != NULL; tpst = tpst->next)
+	    {
+	      if (pc >= tpst->textlow && pc < tpst->texthigh)
+		{
+		  struct partial_symbol *p;
+
+		  p = find_pc_psymbol (tpst, pc);
+		  if (p != NULL
+		      && SYMBOL_VALUE_ADDRESS(p)
+			 == SYMBOL_VALUE_ADDRESS (msymbol))
+		    return (tpst);
+		}
+	    }
+	  return (pst);
+	}
     }
   return (NULL);
 }
@@ -590,9 +579,9 @@ found:
 	}
     }
 
-  /* Check for the possibility of the symbol being a global function
-     that is stored in one of the minimal symbol tables.  Eventually, all
-     global symbols might be resolved in this way.  */
+  /* Check for the possibility of the symbol being a function or
+     a mangled variable that is stored in one of the minimal symbol tables.
+     Eventually, all global symbols might be resolved in this way.  */
   
   if (namespace == VAR_NAMESPACE)
     {
@@ -600,10 +589,9 @@ found:
       if (msymbol != NULL)
 	{
 	  s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
-	  /* If S is NULL, there are no debug symbols for this file.
-	     Skip this stuff and check for matching static symbols below. */
 	  if (s != NULL)
 	    {
+	      /* This is a function which has a symtab for its address.  */
 	      bv = BLOCKVECTOR (s);
 	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 	      sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
@@ -633,6 +621,18 @@ found:
 		*symtab = s;
 	      return sym;
 	    }
+	  else if (MSYMBOL_TYPE (msymbol) != mst_text
+		   && MSYMBOL_TYPE (msymbol) != mst_file_text
+		   && !STREQ (name, SYMBOL_NAME (msymbol)))
+	    {
+	      /* This is a mangled variable, look it up by its
+		 mangled name.  */
+	      return lookup_symbol (SYMBOL_NAME (msymbol), block,
+				    namespace, is_a_field_of_this, symtab);
+	    }
+	  /* There are no debug symbols for this file, or we are looking
+	     for an unmangled variable.
+	     Try to find a matching static symbol below. */
 	}
     }
       
@@ -765,7 +765,8 @@ lookup_partial_symbol (pst, name, global, namespace)
       while (top > bottom)
 	{
 	  center = bottom + (top - bottom) / 2;
-	  assert (center < top);
+	  if (!(center < top))
+	    abort ();
 	  if (!do_linear_search && SYMBOL_LANGUAGE (center) == language_cplus)
 	    {
 	      do_linear_search = 1;
@@ -779,7 +780,8 @@ lookup_partial_symbol (pst, name, global, namespace)
 	      bottom = center + 1;
 	    }
 	}
-      assert (top == bottom);
+      if (!(top == bottom))
+	abort ();
       while (STREQ (SYMBOL_NAME (top), name))
 	{
 	  if (SYMBOL_NAMESPACE (top) == namespace)
@@ -1003,8 +1005,15 @@ find_pc_symtab (pc)
      to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
      and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
      0x1000-0x4000, but for address 0x2345 we want to return symtab b.
-     This is said to happen for the mips; it might be swifter to create
-     several symtabs with the same name like xcoff does (I'm not sure).  */
+
+     This happens for native ecoff format, where code from included files
+     gets its own symtab. The symtab for the included file should have
+     been read in already via the dependency mechanism.
+     It might be swifter to create several symtabs with the same name
+     like xcoff does (I'm not sure).
+
+     It also happens for objfiles that have their functions reordered.
+     For these, the symtab we are looking for is not necessarily read in.  */
 
   ALL_SYMTABS (objfile, s)
     {
@@ -1015,6 +1024,18 @@ find_pc_symtab (pc)
 	  && (distance == 0
 	      || BLOCK_END (b) - BLOCK_START (b) < distance))
 	{
+	  /* For an objfile that has its functions reordered,
+	     find_pc_psymtab will find the proper partial symbol table
+	     and we simply return its corresponding symtab.  */
+	  if (objfile->flags & OBJF_REORDERED)
+	    {
+	      ps = find_pc_psymtab (pc);
+	      if (ps)
+		s = PSYMTAB_TO_SYMTAB (ps);
+	      else
+	        s = NULL;
+	      return (s);
+	    }
 	  distance = BLOCK_END (b) - BLOCK_START (b);
 	  best_s = s;
 	}
@@ -1500,6 +1521,51 @@ find_pc_line_pc_range (pc, startptr, endptr)
   *endptr = sal.end;
   return sal.symtab != 0;
 }
+
+/* Given a function symbol SYM, find the symtab and line for the start
+   of the function.
+   If the argument FUNFIRSTLINE is nonzero, we want the first line
+   of real code inside the function.  */
+
+static struct symtab_and_line
+find_function_start_sal PARAMS ((struct symbol *sym, int));
+
+static struct symtab_and_line
+find_function_start_sal (sym, funfirstline)
+     struct symbol *sym;
+     int funfirstline;
+{
+  CORE_ADDR pc;
+  struct symtab_and_line sal;
+
+  pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+  if (funfirstline)
+    {
+      pc += FUNCTION_START_OFFSET;
+      SKIP_PROLOGUE (pc);
+    }
+  sal = find_pc_line (pc, 0);
+
+#ifdef PROLOGUE_FIRSTLINE_OVERLAP
+  /* Convex: no need to suppress code on first line, if any */
+  sal.pc = pc;
+#else
+  /* Check if SKIP_PROLOGUE left us in mid-line, and the next
+     line is still part of the same function.  */
+  if (sal.pc != pc
+      && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end
+      && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
+    {
+      /* First pc of next line */
+      pc = sal.end;
+      /* Recalculate the line number (might not be N+1).  */
+      sal = find_pc_line (pc, 0);
+    }
+  sal.pc = pc;
+#endif
+
+  return sal;
+}
 
 /* If P is of the form "operator[ \t]+..." where `...' is
    some legitimate operator text, return a pointer to the
@@ -1752,7 +1818,8 @@ build_canonical_line_spec (sal, symname, canonical)
    FUNCTION may be an undebuggable function found in minimal symbol table.
 
    If the argument FUNFIRSTLINE is nonzero, we want the first line
-   of real code inside a function when a function is specified.
+   of real code inside a function when a function is specified, and it is
+   not OK to specify a variable or type to get its line number.
 
    DEFAULT_SYMTAB specifies the file to use if none is specified.
    It defaults to current_source_symtab.
@@ -1846,17 +1913,13 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
 
   if (**argptr == '*')
     {
-      if (**argptr == '*')
-	{
-	  (*argptr)++;
-	}
+      (*argptr)++;
       pc = parse_and_eval_address_1 (argptr);
       values.sals = (struct symtab_and_line *)
 	xmalloc (sizeof (struct symtab_and_line));
       values.nelts = 1;
       values.sals[0] = find_pc_line (pc, 0);
       values.sals[0].pc = pc;
-      build_canonical_line_spec (values.sals, NULL, canonical);
       return values;
     }
 
@@ -1871,7 +1934,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
     {
       if (p[0] == '<') 
 	{
-	  while(!++p && *p != '>');
+	  while(++p && *p != '>');
 	  if (!p)
 	    {
 	      error ("non-matching '<' and '>' in command");
@@ -1988,17 +2051,10 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
 
 		  if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
 		    {
-		      /* Arg is the name of a function */
-		      pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
-		      if (funfirstline)
-			{
-			  pc += FUNCTION_START_OFFSET;
-			  SKIP_PROLOGUE (pc);
-			}
 		      values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
 		      values.nelts = 1;
-		      values.sals[0] = find_pc_line (pc, 0);
-		      values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
+		      values.sals[0] = find_function_start_sal (sym,
+								funfirstline);
 		    }
 		  else
 		    {
@@ -2185,32 +2241,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
 	{
 	  /* Arg is the name of a function */
-	  pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
-	  if (funfirstline)
-	    {
-	      pc += FUNCTION_START_OFFSET;
-	      SKIP_PROLOGUE (pc);
-	    }
-	  val = find_pc_line (pc, 0);
-#ifdef PROLOGUE_FIRSTLINE_OVERLAP
-	  /* Convex: no need to suppress code on first line, if any */
-	  val.pc = pc;
-#else
-	  /* Check if SKIP_PROLOGUE left us in mid-line, and the next
-	     line is still part of the same function.  */
-	  if (val.pc != pc
-	      && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= val.end
-	      && val.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
-	    {
-	      /* First pc of next line */
-	      pc = val.end;
-	      /* Recalculate the line number (might not be N+1).  */
-	      val = find_pc_line (pc, 0);
-	    }
-	  val.pc = pc;
-#endif
 	  values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
-	  values.sals[0] = val;
+	  values.sals[0] = find_function_start_sal (sym, funfirstline);
 	  values.nelts = 1;
 
 	  /* Don't use the SYMBOL_LINE; if used at all it points to
@@ -2228,23 +2260,29 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
 	    }
 	  return values;
 	}
-      else if (SYMBOL_LINE (sym) != 0)
+      else
 	{
-	  /* We know its line number.  */
-	  values.sals = (struct symtab_and_line *)
-	    xmalloc (sizeof (struct symtab_and_line));
-	  values.nelts = 1;
-	  memset (&values.sals[0], 0, sizeof (values.sals[0]));
-	  values.sals[0].symtab = sym_symtab;
-	  values.sals[0].line = SYMBOL_LINE (sym);
-	  return values;
+	  if (funfirstline)
+	    error ("\"%s\" is not a function", copy);
+	  else if (SYMBOL_LINE (sym) != 0)
+	    {
+	      /* We know its line number.  */
+	      values.sals = (struct symtab_and_line *)
+		xmalloc (sizeof (struct symtab_and_line));
+	      values.nelts = 1;
+	      memset (&values.sals[0], 0, sizeof (values.sals[0]));
+	      values.sals[0].symtab = sym_symtab;
+	      values.sals[0].line = SYMBOL_LINE (sym);
+	      return values;
+	    }
+	  else
+	    /* This can happen if it is compiled with a compiler which doesn't
+	       put out line numbers for variables.  */
+	    /* FIXME: Shouldn't we just set .line and .symtab to zero
+	       and return?  For example, "info line foo" could print
+	       the address.  */
+	    error ("Line number not known for symbol \"%s\"", copy);
 	}
-      else
-	/* This can happen if it is compiled with a compiler which doesn't
-	   put out line numbers for variables.  */
-	/* FIXME: Shouldn't we just set .line and .symtab to zero and
-	   return?  For example, "info line foo" could print the address.  */
-	error ("Line number not known for symbol \"%s\"", copy);
     }
 
   msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
@@ -2301,7 +2339,6 @@ decode_line_2 (sym_arr, nelts, funfirstline, canonical)
      char ***canonical;
 {
   struct symtabs_and_lines values, return_values;
-  register CORE_ADDR pc;
   char *args, *arg1;
   int i;
   char *prompt;
@@ -2327,20 +2364,15 @@ decode_line_2 (sym_arr, nelts, funfirstline, canonical)
     {
       if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
 	{
-	  /* Arg is the name of a function */
-	  pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]));
-	  if (funfirstline)
-	    {
-	      pc += FUNCTION_START_OFFSET;
-	      SKIP_PROLOGUE (pc);
-	    }
-	  values.sals[i] = find_pc_line (pc, 0);
-	  values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
-			       values.sals[i].end                      :  pc;
-	  printf_unfiltered("[%d] %s at %s:%d\n", (i+2), SYMBOL_SOURCE_NAME (sym_arr[i]),
-		 values.sals[i].symtab->filename, values.sals[i].line);
+	  values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
+	  printf_unfiltered ("[%d] %s at %s:%d\n",
+			     (i+2),
+			     SYMBOL_SOURCE_NAME (sym_arr[i]),
+			     values.sals[i].symtab->filename,
+			     values.sals[i].line);
 	}
-      else printf_unfiltered ("?HERE\n");
+      else
+	printf_unfiltered ("?HERE\n");
       i++;
     }
   
@@ -2652,13 +2684,20 @@ list_symbols (regexp, class, bpt, from_tty)
 	}
     }
 
-  /* Here, we search through the minimal symbol tables for functions that
-     match, and call find_pc_symtab on them to force their symbols to
-     be read.  The symbol will then be found during the scan of symtabs
-     below.  If find_pc_symtab fails, set found_misc so that we will
-     rescan to print any matching symbols without debug info.  */
+  /* Here, we search through the minimal symbol tables for functions
+     and variables that match, and force their symbols to be read.
+     This is in particular necessary for demangled variable names,
+     which are no longer put into the partial symbol tables.
+     The symbol will then be found during the scan of symtabs below.
+
+     For functions, find_pc_symtab should succeed if we have debug info
+     for the function, for variables we have to call lookup_symbol
+     to determine if the variable has debug info.
+     If the lookup fails, set found_misc so that we will rescan to print
+     any matching symbols without debug info.
+  */
 
-  if (class == 1)
+  if (class == 0 || class == 1)
     {
       ALL_MSYMBOLS (objfile, msymbol)
 	{
@@ -2671,7 +2710,12 @@ list_symbols (regexp, class, bpt, from_tty)
 		{
 		  if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
 		    {
-		      found_misc = 1;
+		      if (class == 1
+			  || lookup_symbol (SYMBOL_NAME (msymbol), 
+					    (struct block *) NULL,
+					    VAR_NAMESPACE,
+					    0, (struct symtab **) NULL) == NULL)
+		        found_misc = 1;
 		    }
 		}
 	    }
@@ -2724,14 +2768,18 @@ list_symbols (regexp, class, bpt, from_tty)
 			       same name but in different files.  In order to
 			       set breakpoints on all of them, we must give
 			       both the file name and the function name to
-			       break_command.  */
+			       break_command.
+			       Quoting the symbol name gets rid of problems
+			       with mangled symbol names that contain
+			       CPLUS_MARKER characters.  */
 			    char *string =
 			      (char *) alloca (strlen (s->filename)
 					       + strlen (SYMBOL_NAME(sym))
-					       + 2);
+					       + 4);
 			    strcpy (string, s->filename);
-			    strcat (string, ":");
+			    strcat (string, ":'");
 			    strcat (string, SYMBOL_NAME(sym));
+			    strcat (string, "'");
 			    break_command (string, from_tty);
 			  }
 		      }