Mon Mar 21 11:02:51 1994 Stu Grossman (grossman at cygnus.com)

	* alpha-tdep.c:  Gobs of changes (many imported from mips-tdep) to
	improve remote debugging efficiency.  Also fixed problems with
	doing function calls for programs with no entry points.
	* infcmd.c (run_stack_dummy):  Use CALL_DUMMY_ADDRESS instead of
	entry_point_address.
	* inferior.h (PC_IN_CALL_DUMMY):  ditto.
	* mdebugread.c (parse_symbol, parse_procedure, parse_external,
	parse_lines):  Pass section_offsets info to these routines so that
	we can relocate symbol table entries upon readin.
	* (psymtab_to_symtab_1):  Set symtab->primary to tell
	objfile_relocate to do relocations for our symbols.
	* (ecoff_relocate_efi):  New routine to relocate adr field of PDRs
	(which hang off of the symbol table).
	* Use prim_record_minimal_symbols_and_info instead of
	prim_record_minimal_symbols to supply section info to make minimal
	symbol relocations work.
	* minsyms.c (prim_record_minimal_symbols_and_info):  If section is
	-1, try to deduce it from ms_type.
	* objfiles.c (objfile_relocate):  Use ALL_OBJFILE_SYMTABS where
	appropriate.  Handle relocation of MIPS_EFI symbols special. Also,
	add code to relocate objfile->sections data structure.
	* remote.c (get_offsets):  Use new protocol message to acquire
	section offsets from the target.
	* (remote_wait):  Get rid of relocation stuff.  That's all handled
	by objfile_relocate now.
	* config/alpha/alpha-nw.mt (TM_FILE):  Use tm-alphanw.h.
	* config/alpha/tm-alpha.h:  Define CALL_DUMMY_ADDRESS, and
	VM_MIN_ADDRESS.
	* config/alpha/tm-alphanw.h:  DECR_PC_AFTER_BREAK=0, VM_MIN_ADDRESS=0.

6 files changed, 450 insertions, 236 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b87030d..2e116cb 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -3,6 +3,38 @@ Mon Mar 21 11:50:28 1994  Jeffrey A. Law  (law@snake.cs.utah.edu)
 	* hppa-tdep.c (hppa_fix_call_dummy): Use value_ptr.
 	(hppa_push_arguments): Likewise.
 
+Mon Mar 21 11:02:51 1994  Stu Grossman  (grossman at cygnus.com)
+
+	* alpha-tdep.c:  Gobs of changes (many imported from mips-tdep) to
+	improve remote debugging efficiency.  Also fixed problems with
+	doing function calls for programs with no entry points.
+	* infcmd.c (run_stack_dummy):  Use CALL_DUMMY_ADDRESS instead of
+	entry_point_address.
+	* inferior.h (PC_IN_CALL_DUMMY):  ditto.
+	* mdebugread.c (parse_symbol, parse_procedure, parse_external,
+	parse_lines):  Pass section_offsets info to these routines so that
+	we can relocate symbol table entries upon readin.
+	* (psymtab_to_symtab_1):  Set symtab->primary to tell
+	objfile_relocate to do relocations for our symbols.
+	* (ecoff_relocate_efi):  New routine to relocate adr field of PDRs
+	(which hang off of the symbol table).
+	* Use prim_record_minimal_symbols_and_info instead of
+	prim_record_minimal_symbols to supply section info to make minimal
+	symbol relocations work.
+	* minsyms.c (prim_record_minimal_symbols_and_info):  If section is
+	-1, try to deduce it from ms_type.
+	* objfiles.c (objfile_relocate):  Use ALL_OBJFILE_SYMTABS where
+	appropriate.  Handle relocation of MIPS_EFI symbols special. Also,
+	add code to relocate objfile->sections data structure.
+	* remote.c (get_offsets):  Use new protocol message to acquire
+	section offsets from the target.
+	* (remote_wait):  Get rid of relocation stuff.  That's all handled
+	by objfile_relocate now.
+	* config/alpha/alpha-nw.mt (TM_FILE):  Use tm-alphanw.h.
+	* config/alpha/tm-alpha.h:  Define CALL_DUMMY_ADDRESS, and
+	VM_MIN_ADDRESS.
+	* config/alpha/tm-alphanw.h:  DECR_PC_AFTER_BREAK=0, VM_MIN_ADDRESS=0.
+
 Sun Mar 20 15:21:57 1994  Doug Evans  (dje@cygnus.com)
 
 	* sparc-tdep.c (sparc_frame_find_save_regs): Use REGISTER_RAW_SIZE
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 31c467b..ce06b81 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -25,10 +25,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "gdbcmd.h"
 #include "gdbcore.h"
 #include "dis-asm.h"
+#include "symfile.h"
+#include "objfiles.h"
 
 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c.  */
 
-#define VM_MIN_ADDRESS (CORE_ADDR)0x120000000
+/* FIXME: Put this declaration in frame.h.  */
+extern struct obstack frame_cache_obstack;
 
 
 /* Forward declarations.  */
@@ -51,6 +54,12 @@ alpha_in_lenient_prologue PARAMS ((CORE_ADDR, CORE_ADDR));
 static void
 reinit_frame_cache_sfunc PARAMS ((char *, int, struct cmd_list_element *));
 
+static CORE_ADDR after_prologue PARAMS ((CORE_ADDR pc,
+					 alpha_extra_func_info_t proc_desc));
+
+static int in_prologue PARAMS ((CORE_ADDR pc,
+				alpha_extra_func_info_t proc_desc));
+
 /* Heuristic_proc_start may hunt through the text section for a long
    time across a 2400 baud serial line.  Allows the user to limit this
    search.  */
@@ -122,7 +131,70 @@ struct linked_proc_info
 } *linked_proc_desc_table = NULL;
 
 
-#define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
+/* Guaranteed to set fci->saved_regs to some values (it never leaves it
+   NULL).  */
+
+void
+alpha_find_saved_regs (fci)
+     FRAME fci;
+{
+  int ireg;
+  CORE_ADDR reg_position;
+  unsigned long mask;
+  alpha_extra_func_info_t proc_desc;
+  int returnreg;
+
+  fci->saved_regs = (struct frame_saved_regs *)
+    obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
+  memset (fci->saved_regs, 0, sizeof (struct frame_saved_regs));
+
+  proc_desc = fci->proc_desc;
+  if (proc_desc == NULL)
+    /* I'm not sure how/whether this can happen.  Normally when we can't
+       find a proc_desc, we "synthesize" one using heuristic_proc_desc
+       and set the saved_regs right away.  */
+    return;
+
+  /* Fill in the offsets for the registers which gen_mask says
+     were saved.  */
+
+  reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
+  mask = PROC_REG_MASK (proc_desc);
+
+  returnreg = PROC_PC_REG (proc_desc);
+
+  /* Note that RA is always saved first, regardless of it's actual
+     register number.  */
+  if (mask & (1 << returnreg))
+    {
+      fci->saved_regs->regs[returnreg] = reg_position;
+      reg_position += 8;
+      mask &= ~(1 << returnreg); /* Clear bit for RA so we
+				    don't save again later. */
+    }
+
+  for (ireg = 0; ireg <= 31 ; ++ireg)
+    if (mask & (1 << ireg))
+      {
+	fci->saved_regs->regs[ireg] = reg_position;
+	reg_position += 8;
+      }
+
+  /* Fill in the offsets for the registers which float_mask says
+     were saved.  */
+
+  reg_position = fci->frame + PROC_FREG_OFFSET (proc_desc);
+  mask = PROC_FREG_MASK (proc_desc);
+
+  for (ireg = 0; ireg <= 31 ; ++ireg)
+    if (mask & (1 << ireg))
+      {
+	fci->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
+	reg_position += 8;
+      }
+
+  fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[returnreg];
+}
 
 static CORE_ADDR
 read_next_frame_reg(fi, regno)
@@ -154,8 +226,13 @@ read_next_frame_reg(fi, regno)
         }
       else if (regno == SP_REGNUM)
 	return fi->frame;
-      else if (fi->saved_regs->regs[regno])
-	return read_memory_integer(fi->saved_regs->regs[regno], 8);
+      else
+	{
+	  if (fi->saved_regs == NULL)
+	    alpha_find_saved_regs (fi);
+	  if (fi->saved_regs->regs[regno])
+	    return read_memory_integer(fi->saved_regs->regs[regno], 8);
+	}
     }
   return read_register(regno);
 }
@@ -297,9 +374,67 @@ heuristic_proc_desc(start_pc, limit_pc, next_frame)
     PROC_FRAME_OFFSET(&temp_proc_desc) = frame_size;
     PROC_REG_MASK(&temp_proc_desc) = reg_mask;
     PROC_PC_REG(&temp_proc_desc) = RA_REGNUM;
+    PROC_LOCALOFF(&temp_proc_desc) = 0;	/* XXX - bogus */
     return &temp_proc_desc;
 }
 
+/* This returns the PC of the first inst after the prologue.  If we can't
+   find the prologue, then return 0.  */
+
+static CORE_ADDR
+after_prologue (pc, proc_desc)
+     CORE_ADDR pc;
+     alpha_extra_func_info_t proc_desc;
+{
+  struct block *b;
+  struct symtab_and_line sal;
+  CORE_ADDR func_addr, func_end;
+
+  if (!proc_desc)
+    proc_desc = find_proc_desc (pc, NULL);
+
+  if (proc_desc)
+    {
+      /* If function is frameless, then we need to do it the hard way.  I
+	 strongly suspect that frameless always means prologueless... */
+      if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
+	  && PROC_FRAME_OFFSET (proc_desc) == 0)
+	return 0;
+    }
+
+  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+    return 0;			/* Unknown */
+
+  sal = find_pc_line (func_addr, 0);
+
+  if (sal.end < func_end)
+    return sal.end;
+
+  /* The line after the prologue is after the end of the function.  In this
+     case, tell the caller to find the prologue the hard way.  */
+
+  return 0;
+}
+
+/* Return non-zero if we *might* be in a function prologue.  Return zero if we
+   are definatly *not* in a function prologue.  */
+
+static int
+in_prologue (pc, proc_desc)
+     CORE_ADDR pc;
+     alpha_extra_func_info_t proc_desc;
+{
+  CORE_ADDR after_prologue_pc;
+
+  after_prologue_pc = after_prologue (pc, proc_desc);
+
+  if (after_prologue_pc == 0
+      || pc < after_prologue_pc)
+    return 1;
+  else
+    return 0;
+}
+
 static alpha_extra_func_info_t
 find_proc_desc(pc, next_frame)
     CORE_ADDR pc;
@@ -317,6 +452,7 @@ find_proc_desc(pc, next_frame)
      as it will be contained in the proc_desc we are searching for.
      So we have to find the proc_desc whose frame is closest to the current
      stack pointer.  */
+
   if (PC_IN_CALL_DUMMY (pc, 0, 0))
     {
       struct linked_proc_info *link;
@@ -338,6 +474,7 @@ find_proc_desc(pc, next_frame)
     }
 
   b = block_for_pc(pc);
+
   find_pc_partial_function (pc, NULL, &startaddr, NULL);
   if (b == NULL)
     sym = NULL;
@@ -355,45 +492,39 @@ find_proc_desc(pc, next_frame)
 
   if (sym)
     {
-	/* IF (this is the topmost frame OR a frame interrupted by a signal)
-	 * AND (this proc does not have debugging information OR
+	/* IF this is the topmost frame AND
+	 * (this proc does not have debugging information OR
 	 * the PC is in the procedure prologue)
 	 * THEN create a "heuristic" proc_desc (by analyzing
 	 * the actual code) to replace the "official" proc_desc.
 	 */
 	proc_desc = (alpha_extra_func_info_t)SYMBOL_VALUE(sym);
-	if (next_frame == NULL || next_frame->signal_handler_caller) {
-	    struct symtab_and_line val;
-	    struct symbol *proc_symbol =
-		PROC_DESC_IS_DUMMY(proc_desc) ? 0 : PROC_SYMBOL(proc_desc);
-
-	    if (proc_symbol) {
-		val = find_pc_line (BLOCK_START
-				    (SYMBOL_BLOCK_VALUE(proc_symbol)),
-				    0);
-		val.pc = val.end ? val.end : pc;
-	    }
-	    if (!proc_symbol || pc < val.pc) {
+	if (next_frame == NULL)
+	  {
+	    if (PROC_DESC_IS_DUMMY (proc_desc) || in_prologue (pc, proc_desc))
+	      {
 		alpha_extra_func_info_t found_heuristic =
-		    heuristic_proc_desc(PROC_LOW_ADDR(proc_desc),
-					pc, next_frame);
+		  heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
+				       pc, next_frame);
+		PROC_LOCALOFF (found_heuristic) = PROC_LOCALOFF (proc_desc);
 		if (found_heuristic)
-		  {
-		    /* The call to heuristic_proc_desc determines
-		       which registers have been saved so far and if the
-		       frame is already set up.
-		       The heuristic algorithm doesn't work well for other
-		       information in the procedure descriptor, so copy
-		       it from the found procedure descriptor.  */
-		    PROC_LOCALOFF(found_heuristic) = PROC_LOCALOFF(proc_desc);
-		    PROC_PC_REG(found_heuristic) = PROC_PC_REG(proc_desc);
-		    proc_desc = found_heuristic;
-		  }
-	    }
-	}
+		  proc_desc = found_heuristic;
+	      }
+	  }
     }
   else
     {
+      /* Is linked_proc_desc_table really necessary?  It only seems to be used
+	 by procedure call dummys.  However, the procedures being called ought
+	 to have their own proc_descs, and even if they don't,
+	 heuristic_proc_desc knows how to create them! */
+
+      register struct linked_proc_info *link;
+      for (link = linked_proc_desc_table; link; link = link->next)
+	  if (PROC_LOW_ADDR(&link->info) <= pc
+	      && PROC_HIGH_ADDR(&link->info) > pc)
+	      return &link->info;
+
       if (startaddr == 0)
 	startaddr = heuristic_proc_start (pc);
 
@@ -454,104 +585,43 @@ void
 init_extra_frame_info(fci)
      struct frame_info *fci;
 {
-  extern struct obstack frame_cache_obstack;
   /* Use proc_desc calculated in frame_chain */
   alpha_extra_func_info_t proc_desc =
     fci->next ? cached_proc_desc : find_proc_desc(fci->pc, fci->next);
 
-  fci->saved_regs = (struct frame_saved_regs*)
-    obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
-  memset (fci->saved_regs, 0, sizeof (struct frame_saved_regs));
+  fci->saved_regs = NULL;
   fci->proc_desc =
     proc_desc == &temp_proc_desc ? 0 : proc_desc;
   if (proc_desc)
     {
-      int ireg;
-      CORE_ADDR reg_position;
-      unsigned long mask;
-      int returnreg;
-
       /* Get the locals offset from the procedure descriptor, it is valid
 	 even if we are in the middle of the prologue.  */
       fci->localoff = PROC_LOCALOFF(proc_desc);
 
       /* Fixup frame-pointer - only needed for top frame */
+
       /* Fetch the frame pointer for a dummy frame from the procedure
 	 descriptor.  */
       if (PROC_DESC_IS_DUMMY(proc_desc))
 	fci->frame = (FRAME_ADDR) PROC_DUMMY_FRAME(proc_desc);
+
       /* This may not be quite right, if proc has a real frame register.
 	 Get the value of the frame relative sp, procedure might have been
 	 interrupted by a signal at it's very start.  */
-      else if (fci->pc == PROC_LOW_ADDR(proc_desc))
-	fci->frame = READ_FRAME_REG(fci, SP_REGNUM);
+      else if (fci->pc == PROC_LOW_ADDR (proc_desc) && !PROC_DESC_IS_DUMMY (proc_desc))
+	fci->frame = read_next_frame_reg (fci->next, SP_REGNUM);
       else
-	fci->frame = READ_FRAME_REG(fci, PROC_FRAME_REG(proc_desc))
-		      + PROC_FRAME_OFFSET(proc_desc);
-
-      /* If this is the innermost frame, and we are still in the
-	 prologue (loosely defined), then the registers may not have
-	 been saved yet.  */
-      if (fci->next == NULL
-          && !PROC_DESC_IS_DUMMY(proc_desc)
-	  && alpha_in_lenient_prologue (PROC_LOW_ADDR (proc_desc), fci->pc))
-	{
-	  /* Can't just say that the registers are not saved, because they
-	     might get clobbered halfway through the prologue.
-	     heuristic_proc_desc already has the right code to figure out
-	     exactly what has been saved, so use it.  As far as I know we
-	     could be doing this (as we do on the 68k, for example)
-	     regardless of whether we are in the prologue; I'm leaving in
-	     the check for being in the prologue only out of conservatism
-	     (I'm not sure whether heuristic_proc_desc handles all cases,
-	     for example).
-
-	     This stuff is ugly (and getting uglier by the minute).  Probably
-	     the best way to clean it up is to ignore the proc_desc's from
-	     the symbols altogher, and get all the information we need by
-	     examining the prologue (provided we can make the prologue
-	     examining code good enough to get all the cases...).  */
-	  proc_desc =
-	    heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
-				 fci->pc,
-				 fci->next);
-	}
+	fci->frame = read_next_frame_reg (fci->next, PROC_FRAME_REG (proc_desc))
+			+ PROC_FRAME_OFFSET (proc_desc);
 
       if (proc_desc == &temp_proc_desc)
-	*fci->saved_regs = temp_saved_regs;
-      else
 	{
-	  /* Find which general-purpose registers were saved.
-	     The return address register is the first saved register,
-	     the other registers follow in ascending order.  */
-	  reg_position = fci->frame + PROC_REG_OFFSET(proc_desc);
-	  mask = PROC_REG_MASK(proc_desc) & 0xffffffffL;
-	  returnreg = PROC_PC_REG(proc_desc);
-	  if (mask & (1 << returnreg))
-	    {
-	      fci->saved_regs->regs[returnreg] = reg_position;
-	      reg_position += 8;
-	    }
-	  for (ireg = 0; mask; ireg++, mask >>= 1)
-	    if (mask & 1)
-	      {
-		if (ireg == returnreg)
-		  continue;
-		fci->saved_regs->regs[ireg] = reg_position;
-		reg_position += 8;
-	      }
-	  /* find which floating-point registers were saved */
-	  reg_position = fci->frame + PROC_FREG_OFFSET(proc_desc);
-	  mask = PROC_FREG_MASK(proc_desc) & 0xffffffffL;
-	  for (ireg = 0; mask; ireg++, mask >>= 1)
-	    if (mask & 1)
-	      {
-		fci->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
-		reg_position += 8;
-	      }
+	  fci->saved_regs = (struct frame_saved_regs*)
+	    obstack_alloc (&frame_cache_obstack,
+			   sizeof (struct frame_saved_regs));
+	  *fci->saved_regs = temp_saved_regs;
+	  fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[RA_REGNUM];
 	}
-
-      fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[PROC_PC_REG(proc_desc)];
     }
 }
 
@@ -661,16 +731,18 @@ void
 alpha_push_dummy_frame()
 {
   int ireg;
-  struct linked_proc_info *link = (struct linked_proc_info*)
-      xmalloc(sizeof (struct linked_proc_info));
-  alpha_extra_func_info_t proc_desc = &link->info;
+  struct linked_proc_info *link;
+  alpha_extra_func_info_t proc_desc;
   CORE_ADDR sp = read_register (SP_REGNUM);
   CORE_ADDR save_address;
   char raw_buffer[MAX_REGISTER_RAW_SIZE];
   unsigned long mask;
 
+  link = (struct linked_proc_info *) xmalloc(sizeof (struct linked_proc_info));
   link->next = linked_proc_desc_table;
   linked_proc_desc_table = link;
+ 
+  proc_desc = &link->info;
 
   /*
    * The registers we must save are all those not preserved across
@@ -764,7 +836,7 @@ alpha_push_dummy_frame()
   sp += PROC_REG_OFFSET(proc_desc);
   write_register (SP_REGNUM, sp);
 
-  PROC_LOW_ADDR(proc_desc) = entry_point_address ();
+  PROC_LOW_ADDR(proc_desc) = CALL_DUMMY_ADDRESS ();
   PROC_HIGH_ADDR(proc_desc) = PROC_LOW_ADDR(proc_desc) + 4;
 
   SET_PROC_DESC_IS_DUMMY(proc_desc);
@@ -781,6 +853,8 @@ alpha_pop_frame()
   alpha_extra_func_info_t proc_desc = frame->proc_desc;
 
   write_register (PC_REGNUM, FRAME_SAVED_PC(frame));
+  if (frame->saved_regs == NULL)
+    alpha_find_saved_regs (frame);
   if (proc_desc)
     {
       for (regnum = 32; --regnum >= 0; )
@@ -838,6 +912,19 @@ alpha_skip_prologue (pc, lenient)
 {
     unsigned long inst;
     int offset;
+    CORE_ADDR post_prologue_pc;
+
+    /* See if we can determine the end of the prologue via the symbol table.
+       If so, then return either PC, or the PC after the prologue, whichever
+       is greater.  */
+
+    post_prologue_pc = after_prologue (pc, NULL);
+
+    if (post_prologue_pc != 0)
+      return max (pc, post_prologue_pc);
+
+    /* Can't determine prologue from the symbol table, need to examine
+       instructions.  */
 
     /* Skip the typical prologue instructions. These are the stack adjustment
        instruction and the instructions that save registers on the stack
@@ -1015,6 +1102,30 @@ reinit_frame_cache_sfunc (args, from_tty, c)
   reinit_frame_cache ();
 }
 
+/* This is the definition of CALL_DUMMY_ADDRESS.  It's a heuristic that is used
+   to find a convenient place in the text segment to stick a breakpoint to
+   detect the completion of a target function call (ala call_function_by_hand).
+ */
+
+CORE_ADDR
+alpha_call_dummy_address ()
+{
+  CORE_ADDR entry;
+  struct minimal_symbol *sym;
+
+  entry = entry_point_address ();
+
+  if (entry != 0)
+    return entry;
+
+  sym = lookup_minimal_symbol ("_Prelude", symfile_objfile);
+
+  if (!sym || MSYMBOL_TYPE (sym) != mst_text)
+    return 0;
+  else
+    return SYMBOL_VALUE_ADDRESS (sym) + 4;
+}
+
 void
 _initialize_alpha_tdep ()
 {
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 4e71322..7471f1e 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -315,7 +315,7 @@ static struct blockvector *
 new_bvect PARAMS ((int));
 
 static int
-parse_symbol PARAMS ((SYMR *, union aux_ext *, char *, int));
+parse_symbol PARAMS ((SYMR *, union aux_ext *, char *, int, struct section_offsets *));
 
 static struct type *
 parse_type PARAMS ((int, union aux_ext *, unsigned int, int *, int, char *));
@@ -648,11 +648,12 @@ add_pending (fh, sh, t)
    SYMR's handled (normally one).  */
 
 static int
-parse_symbol (sh, ax, ext_sh, bigend)
+parse_symbol (sh, ax, ext_sh, bigend, section_offsets)
      SYMR *sh;
      union aux_ext *ax;
      char *ext_sh;
      int bigend;
+     struct section_offsets *section_offsets;
 {
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
   void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) =
@@ -674,6 +675,19 @@ parse_symbol (sh, ax, ext_sh, bigend)
   else
     name = debug_info->ss + cur_fdr->issBase + sh->iss;
 
+  switch (sh->sc)
+    {
+    case scText:
+      sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+      break;
+    case scData:
+      sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA);
+      break;
+    case scBss:
+      sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS);
+      break;
+    }
+
   switch (sh->st)
     {
     case stNil:
@@ -1699,13 +1713,15 @@ upgrade_type (fd, tpp, tq, ax, bigend, sym_name)
    to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
    in question, or NULL to use top_stack->cur_block.  */
 
-static void parse_procedure PARAMS ((PDR *, struct symtab *, unsigned long));
+static void parse_procedure PARAMS ((PDR *, struct symtab *, unsigned long,
+				     struct section_offsets *));
 
 static void
-parse_procedure (pr, search_symtab, first_off)
+parse_procedure (pr, search_symtab, first_off, section_offsets)
      PDR *pr;
      struct symtab *search_symtab;
      unsigned long first_off;
+     struct section_offsets *section_offsets;
 {
   struct symbol *s, *i;
   struct block *b;
@@ -1810,7 +1826,8 @@ parse_procedure (pr, search_symtab, first_off)
       e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
       e->pdr = *pr;
       e->pdr.isym = (long) s;
-      e->pdr.adr += cur_fdr->adr - first_off;
+      e->pdr.adr += cur_fdr->adr - first_off
+	+ ANOFFSET (section_offsets, SECT_OFF_TEXT);
 
       /* Correct incorrect setjmp procedure descriptor from the library
 	 to make backtrace through setjmp work.  */
@@ -1824,6 +1841,20 @@ parse_procedure (pr, search_symtab, first_off)
     }
 }
 
+/* Relocate the extra function info pointed to by the symbol table.  */
+
+void
+ecoff_relocate_efi (sym, delta)
+     struct symbol *sym;
+     CORE_ADDR delta;
+{
+  struct mips_extra_func_info *e;
+
+  e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym);
+  
+  e->pdr.adr += delta;
+}
+
 /* Parse the external symbol ES. Just call parse_symbol() after
    making sure we know where the aux are for it. For procedures,
    parsing of the PDRs has already provided all the needed
@@ -1834,10 +1865,11 @@ parse_procedure (pr, search_symtab, first_off)
    This routine clobbers top_stack->cur_block and ->cur_st. */
 
 static void
-parse_external (es, skip_procedures, bigend)
+parse_external (es, skip_procedures, bigend, section_offsets)
      EXTR *es;
      int skip_procedures;
      int bigend;
+     struct section_offsets *section_offsets;
 {
   union aux_ext *ax;
 
@@ -1904,7 +1936,7 @@ parse_external (es, skip_procedures, bigend)
     case stLabel:
       /* Note that the case of a symbol with indexNil must be handled
 	 anyways by parse_symbol().  */
-      parse_symbol (&es->asym, ax, (char *) NULL, bigend);
+      parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets);
       break;
     default:
       break;
@@ -1918,11 +1950,12 @@ parse_external (es, skip_procedures, bigend)
    with that and do not need to reorder our linetables */
 
 static void
-parse_lines (fh, pr, lt, maxlines)
+parse_lines (fh, pr, lt, maxlines, section_offsets)
      FDR *fh;
      PDR *pr;
      struct linetable *lt;
      int maxlines;
+     struct section_offsets *section_offsets;
 {
   unsigned char *base;
   int j, k;
@@ -1932,8 +1965,6 @@ parse_lines (fh, pr, lt, maxlines)
   if (fh->cbLine == 0)
     return;
 
-  base = debug_info->line + fh->cbLineOffset;
-
   /* Scan by procedure descriptors */
   k = 0;
   for (j = 0; j < fh->cpd; j++, pr++)
@@ -1956,7 +1987,9 @@ parse_lines (fh, pr, lt, maxlines)
  	halt = base + fh->cbLine;
       base += pr->cbLineOffset;
 
-      adr = fh->adr + pr->adr - first_off;
+      adr = fh->adr + pr->adr - first_off
+	+ ANOFFSET (section_offsets, SECT_OFF_TEXT);
+
       l = adr >> 2;		/* in words */
       for (lineno = pr->lnLow; base < halt; )
 	{
@@ -2286,9 +2319,11 @@ parse_partial_symbols (objfile, section_offsets)
 		{
 		  if (sh.st == stProc || sh.st == stStaticProc)
 		    {
-		      long procaddr = sh.value;
+		      long procaddr;
 		      long isym;
-
+	
+		      sh.value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+		      procaddr = sh.value;
 
 		      isym = AUX_GET_ISYM (fh->fBigendian,
 					   (debug_info->external_aux
@@ -2358,8 +2393,9 @@ parse_partial_symbols (objfile, section_offsets)
 		  int new_sdx;
 
 		case stStaticProc:
-		  prim_record_minimal_symbol (name, sh.value, mst_file_text,
-					      objfile);
+		  prim_record_minimal_symbol_and_info (name, sh.value,
+						       mst_file_text, NULL,
+						       SECT_OFF_TEXT, objfile);
 
 		  /* FALLTHROUGH */
 
@@ -2427,11 +2463,15 @@ parse_partial_symbols (objfile, section_offsets)
 		      || sh.sc == scRData
 		      || sh.sc == scPData
 		      || sh.sc == scXData)
-		    prim_record_minimal_symbol (name, sh.value, mst_file_data,
-						objfile);
+		    prim_record_minimal_symbol_and_info (name, sh.value,
+							 mst_file_data, NULL,
+							 SECT_OFF_DATA,
+							 objfile);
 		  else
-		    prim_record_minimal_symbol (name, sh.value, mst_file_bss,
-						objfile);
+		    prim_record_minimal_symbol_and_info (name, sh.value,
+							 mst_file_bss, NULL,
+							 SECT_OFF_BSS,
+							 objfile);
 		  class = LOC_STATIC;
 		  break;
 
@@ -2899,7 +2939,7 @@ psymtab_to_symtab_1 (pst, filename)
 	      first_off = pr.adr;
 	      first_pdr = 0;
 	    }
-	  parse_procedure (&pr, st, first_off);
+	  parse_procedure (&pr, st, first_off, pst->section_offsets);
 	}
     }
   else
@@ -2966,7 +3006,7 @@ psymtab_to_symtab_1 (pst, filename)
 	      (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
 	      c = parse_symbol (&sh,
 				debug_info->external_aux + fh->iauxBase,
-				sym_ptr, fh->fBigendian);
+				sym_ptr, fh->fBigendian, pst->section_offsets);
 	      sym_ptr += c * external_sym_size;
 	    }
 
@@ -2995,7 +3035,8 @@ psymtab_to_symtab_1 (pst, filename)
 		   pdr_ptr += external_pdr_size, pdr_in++)
 		(*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
 
-	      parse_lines (fh, pr_block, lines, maxlines);
+	      parse_lines (fh, pr_block, lines, maxlines,
+			   pst->section_offsets);
 	      if (lines->nitems < fh->cline)
 		lines = shrink_linetable (lines);
 
@@ -3003,7 +3044,8 @@ psymtab_to_symtab_1 (pst, filename)
 	      pdr_in = pr_block;
 	      pdr_in_end = pdr_in + fh->cpd;
 	      for (; pdr_in < pdr_in_end; pdr_in++)
-		parse_procedure (pdr_in, 0, pr_block->adr);
+		parse_procedure (pdr_in, 0, pr_block->adr,
+				 pst->section_offsets);
 
 	      do_cleanups (old_chain);
 	    }
@@ -3025,7 +3067,7 @@ psymtab_to_symtab_1 (pst, filename)
 
       ext_ptr = PST_PRIVATE (pst)->extern_tab;
       for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
-	parse_external (ext_ptr, 1, fh->fBigendian);
+	parse_external (ext_ptr, 1, fh->fBigendian, pst->section_offsets);
 
       /* If there are undefined symbols, tell the user.
 	 The alpha has an undefined symbol for every symbol that is
@@ -3041,6 +3083,8 @@ psymtab_to_symtab_1 (pst, filename)
 	}
       pop_parse_stack ();
 
+      st->primary = 1;
+
       /* Sort the symbol table now, we are done adding symbols to it.*/
       sort_symtab_syms (st);
 
diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index ec72471..ff31f73 100644
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -44,6 +44,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "symfile.h"
 #include "objfiles.h"
 #include "demangle.h"
+#include "gdb-stabs.h"
 
 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
    At the end, copy them all into one newly allocated location on an objfile's
@@ -327,7 +328,27 @@ prim_record_minimal_symbol_and_info (name, address, ms_type, info, section,
   SYMBOL_NAME (msymbol) = (char *) name;
   SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
   SYMBOL_VALUE_ADDRESS (msymbol) = address;
-  SYMBOL_SECTION (msymbol) = section;
+  if (section == -1)
+    switch (ms_type)
+      {
+      case mst_text:
+      case mst_file_text:
+	SYMBOL_SECTION (msymbol) = SECT_OFF_TEXT;
+	break;
+      case mst_data:
+      case mst_file_data:
+	SYMBOL_SECTION (msymbol) = SECT_OFF_DATA;
+	break;
+      case mst_bss:
+      case mst_file_bss:
+	SYMBOL_SECTION (msymbol) = SECT_OFF_BSS;
+	break;
+      default:
+	SYMBOL_SECTION (msymbol) = -1;
+      }
+  else
+    SYMBOL_SECTION (msymbol) = section;
+
   MSYMBOL_TYPE (msymbol) = ms_type;
   /* FIXME:  This info, if it remains, needs its own field.  */
   MSYMBOL_INFO (msymbol) = info; /* FIXME! */
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 6c6dfc2..4f0dfd6 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -450,7 +450,7 @@ objfile_relocate (objfile, new_offsets)
   {
     struct symtab *s;
 
-    for (s = objfile->symtabs; s; s = s->next)
+    ALL_OBJFILE_SYMTABS (objfile, s)
       {
 	struct linetable *l;
 	struct blockvector *bv;
@@ -492,6 +492,15 @@ objfile_relocate (objfile, new_offsets)
 		    SYMBOL_VALUE_ADDRESS (sym) +=
 		      ANOFFSET (delta, SYMBOL_SECTION (sym));
 		  }
+#ifdef MIPS_EFI_SYMBOL_NAME
+		/* Relocate Extra Function Info for ecoff.  */
+
+		else
+		  if (SYMBOL_CLASS (sym) == LOC_CONST
+		      && SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE
+		      && STRCMP (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
+		    ecoff_relocate_efi (sym, ANOFFSET (delta, s->block_line_section));
+#endif
 	      }
 	  }
       }
@@ -538,6 +547,37 @@ objfile_relocate (objfile, new_offsets)
     for (i = 0; i < objfile->num_sections; ++i)
       ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
   }
+
+  {
+    struct obj_section *s;
+    bfd *abfd;
+
+    abfd = symfile_objfile->obfd;
+
+    for (s = symfile_objfile->sections;
+	 s < symfile_objfile->sections_end; ++s)
+      {
+	flagword flags;
+
+	flags = bfd_get_section_flags (abfd, s->the_bfd_section);
+
+	if (flags & SEC_CODE)
+	  {
+	    s->addr += ANOFFSET (delta, SECT_OFF_TEXT);
+	    s->endaddr += ANOFFSET (delta, SECT_OFF_TEXT);
+	  }
+	else if (flags & (SEC_DATA | SEC_LOAD))
+	  {
+	    s->addr += ANOFFSET (delta, SECT_OFF_DATA);
+	    s->endaddr += ANOFFSET (delta, SECT_OFF_DATA);
+	  }
+	else if (flags & SEC_ALLOC)
+	  {
+	    s->addr += ANOFFSET (delta, SECT_OFF_BSS);
+	    s->endaddr += ANOFFSET (delta, SECT_OFF_BSS);
+	  }
+      }
+  }
 }
 
 /* Many places in gdb want to test just to see if we have any partial
diff --git a/gdb/remote.c b/gdb/remote.c
index 7240f0b..d969e11 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -90,22 +90,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 					AA = signal number
 					n... = register number
 					r... = register contents
-	or...		WAA		The process extited, and AA is
+	or...		WAA		The process exited, and AA is
 					the exit status.  This is only
 					applicable for certains sorts of
 					targets.
-	or...		NAATT;DD;BB	Relocate the object file.
-					AA = signal number
-					TT = text address
-					DD = data address
-					BB = bss address
-					This is used by the NLM stub,
-					which is why it only has three
-					addresses rather than one per
-					section: the NLM stub always
-					sees only three sections, even
-					though gdb may see more.
-
 	kill request	k
 
 	toggle debug	d		toggle debug flag (see 386 & 68k stubs)
@@ -116,17 +104,33 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 					we can extend the protocol and GDB
 					can tell whether the stub it is
 					talking to uses the old or the new.
+<<<<<<< remote.c
+	search		tAA:PP,MM	Search backwards starting at address
+||||||| 1.81
+	search		tAA:PP,MM	Search backword starting at address
+=======
 	search		tAA:PP,MM	Search backward starting at address
+>>>>>>> 1.82
 					AA for a match with pattern PP and
 					mask MM.  PP and MM are 4 bytes.
 					Not supported by all stubs.
 
+<<<<<<< remote.c
+	general query	qXXXX		Request info about XXXX.
+	general set	QXXXX=yyyy	Set value of XXXX to yyyy.
+	query sect offs	qOffsets	Get section offsets.  Reply is
+					Text=xxx;Data=yyy;Bss=zzz
+*/
+
+||||||| 1.81
+=======
 	Responses can be run-length encoded to save space.  A '*' means that
 	the next two characters are hex digits giving a repeat count which
 	stands for that many repititions of the character preceding the '*'.
 	Note that this means that responses cannot contain '*'.  Example:
         "0*03" means the same as "0000".  */
 
+>>>>>>> 1.82
 #include "defs.h"
 #include <string.h>
 #include <fcntl.h>
@@ -265,6 +269,49 @@ remote_close (quitting)
   remote_desc = NULL;
 }
 
+/* Query the remote side for the text, data and bss offsets. */
+
+static void
+get_offsets ()
+{
+  unsigned char buf [PBUFSIZ];
+  int nvals;
+  CORE_ADDR text_addr, data_addr, bss_addr;
+  struct section_offsets *offs;
+
+  putpkt ("qOffsets");
+
+  getpkt (buf, 1);
+
+  if (buf[0] == 'E')
+    {
+      warning ("Remote failure reply: %s", buf);
+      return;
+    }
+
+  nvals = sscanf (buf, "Text=%lx;Data=%lx;Bss=%lx", &text_addr, &data_addr,
+		  &bss_addr);
+  if (nvals != 3)
+    error ("Malformed response to offset query, %s", buf);
+
+  if (symfile_objfile == NULL)
+    return;
+
+  offs = (struct section_offsets *) alloca (sizeof (struct section_offsets)
+					    + symfile_objfile->num_sections
+					    * sizeof (offs->offsets));
+  memcpy (offs, symfile_objfile->section_offsets,
+	  sizeof (struct section_offsets)
+	  + symfile_objfile->num_sections
+	  * sizeof (offs->offsets));
+
+  ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
+  ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
+  ANOFFSET (offs, SECT_OFF_BSS) = bss_addr;
+
+  objfile_relocate (symfile_objfile, offs);
+}
+
 /* Stub for catch_errors.  */
 
 static int
@@ -274,13 +321,16 @@ remote_start_remote (dummy)
   immediate_quit = 1;		/* Allow user to interrupt it */
 
   /* Ack any packet which the remote side has already sent.  */
-  /* I'm not sure this \r is needed; we don't use it any other time we
-     send an ack.  */
-  SERIAL_WRITE (remote_desc, "+\r", 2);
+
+  SERIAL_WRITE (remote_desc, "+", 1);
+
+  get_offsets ();		/* Get text, data & bss offsets */
+
   putpkt ("?");			/* initiate a query from remote machine */
   immediate_quit = 0;
 
   start_remote ();		/* Initialize gdb process mechanisms */
+
   return 1;
 }
 
@@ -536,90 +586,6 @@ remote_wait (pid, status)
 	    }
 	  break;
 	}
-      else if (buf[0] == 'N')
-	{
-	  unsigned char *p1;
-	  bfd_vma text_addr, data_addr, bss_addr;
-
-	  /* Relocate object file.  Format is NAATT;DD;BB where AA is
-	     the signal number, TT is the new text address, DD is the
-	     new data address, and BB is the new bss address.  This is
-	     used by the NLM stub; gdb may see more sections.  */
-	  p = &buf[3];
-	  text_addr = strtoul (p, &p1, 16);
-	  if (p1 == p || *p1 != ';')
-	    warning ("Malformed relocation packet: Packet '%s'", buf);
-	  p = p1 + 1;
-	  data_addr = strtoul (p, &p1, 16);
-	  if (p1 == p || *p1 != ';')
-	    warning ("Malformed relocation packet: Packet '%s'", buf);
-	  p = p1 + 1;
-	  bss_addr = strtoul (p, &p1, 16);
-	  if (p1 == p)
-	    warning ("Malformed relocation packet: Packet '%s'", buf);
-
-	  if (symfile_objfile != NULL
-	      && (ANOFFSET (symfile_objfile->section_offsets,
-			    SECT_OFF_TEXT) != text_addr
-		  || ANOFFSET (symfile_objfile->section_offsets,
-			       SECT_OFF_DATA) != data_addr
-		  || ANOFFSET (symfile_objfile->section_offsets,
-			       SECT_OFF_BSS) != bss_addr))
-	    {
-	      struct section_offsets *offs;
-
-	      /* FIXME: This code assumes gdb-stabs.h is being used;
-		 it's broken for xcoff, dwarf, sdb-coff, etc.  But
-		 there is no simple canonical representation for this
-		 stuff.  (Just what does "text" as seen by the stub
-		 mean, anyway?).  */
-
-	      offs = ((struct section_offsets *)
-		      alloca (sizeof (struct section_offsets)
-			      + (symfile_objfile->num_sections
-				 * sizeof (offs->offsets))));
-	      memcpy (offs, symfile_objfile->section_offsets,
-		      (sizeof (struct section_offsets)
-		       + (symfile_objfile->num_sections
-			  * sizeof (offs->offsets))));
-	      ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
-	      ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
-	      ANOFFSET (offs, SECT_OFF_BSS) = bss_addr;
-
-	      objfile_relocate (symfile_objfile, offs);
-	      {
-		struct obj_section *s;
-		bfd *abfd;
-
-		abfd = symfile_objfile->obfd;
-
-		for (s = symfile_objfile->sections;
-		     s < symfile_objfile->sections_end; ++s)
-		  {
-		    flagword flags;
-
-		    flags = bfd_get_section_flags (abfd, s->the_bfd_section);
-
-		    if (flags & SEC_CODE)
-		      {
-			s->addr += text_addr;
-			s->endaddr += text_addr;
-		      }
-		    else if (flags & (SEC_DATA | SEC_LOAD))
-		      {
-			s->addr += data_addr;
-			s->endaddr += data_addr;
-		      }
-		    else if (flags & SEC_ALLOC)
-		      {
-			s->addr += bss_addr;
-			s->endaddr += bss_addr;
-		      }
-		  }
-	      }
-	    }
-	  break;
-	}
       else if (buf[0] == 'W')
 	{
 	  /* The remote process exited.  */