* Clean up xcoff relocation.

objfiles.h (struct objfiles): Add section_offsets, num_sections.
	symfile.c (syms_from_objfile), xcoffread.c (xcoff_symfile_offsets):
	Set them.
	symtab.h (struct general_symbol_info): Add section field.
	minsyms.c (prim_record_minimal_symbol{,_and_info}): Set it.
	xcoffread.c: Set section for symbols and msymbols.
	(struct symtab): Add block_line_section field.
	buildsym.c (end_symtab): Set it.
	(end_symtab and callers): Add section parameter.
	objfiles.c (objfile_relocate): New funciton.
	xcoffexec.c (vmap_symtab): Use it.
	xcoffsolib.h (struct vmap): Remove unused fields.
	config/rs6000/tm-rs6000.h, stack.c, xcoffexec.c: Remove
	CORE_NEEDS_RELOCATION, symtab_relocated.
	config/rs6000/tm-rs6000.h: Remove use of loadinfotext.
	rs6000-tdep.c: Make loadinfotext static.
	breakpoint.c (fixup_breakpoints): Doc fix.
	symtab.h (struct symtab), config/rs6000/tm-rs6000.h, buildsym.c
	(end_symtab): primary field replaces nonreloc.

gdb/ChangeLog

@@ -1,3 +1,26 @@
+Wed Mar 24 08:48:30 1993  Jim Kingdon  (kingdon@cygnus.com)
+
+	* Clean up xcoff relocation.
+	objfiles.h (struct objfiles): Add section_offsets, num_sections.
+	symfile.c (syms_from_objfile), xcoffread.c (xcoff_symfile_offsets):
+	Set them.
+	symtab.h (struct general_symbol_info): Add section field.
+	minsyms.c (prim_record_minimal_symbol{,_and_info}): Set it.
+	xcoffread.c: Set section for symbols and msymbols.
+	(struct symtab): Add block_line_section field.
+	buildsym.c (end_symtab): Set it.
+	(end_symtab and callers): Add section parameter.
+	objfiles.c (objfile_relocate): New funciton.
+	xcoffexec.c (vmap_symtab): Use it.
+	xcoffsolib.h (struct vmap): Remove unused fields.
+	config/rs6000/tm-rs6000.h, stack.c, xcoffexec.c: Remove
+	CORE_NEEDS_RELOCATION, symtab_relocated.
+	config/rs6000/tm-rs6000.h: Remove use of loadinfotext.
+	rs6000-tdep.c: Make loadinfotext static.
+	breakpoint.c (fixup_breakpoints): Doc fix.
+	symtab.h (struct symtab), config/rs6000/tm-rs6000.h, buildsym.c
+	(end_symtab): primary field replaces nonreloc.
+
 Thu Mar 25 12:26:50 1993  Stu Grossman  (grossman@cygnus.com)
 
 	* findvar.c (read_register, write_register):  Make these capable

gdb/buildsym.c

@@ -588,6 +588,8 @@ start_symtab (name, dirname, start_addr)
    for that file and put it in the list of all such.
 
    END_ADDR is the address of the end of the file's text.
+   SECTION is the section number (in objfile->section_offsets) of
+   the blockvector and linetable.
 
    Note that it is possible for end_symtab() to return NULL.  In particular,
    for the DWARF case at least, it will return NULL when it finds a
@@ -597,11 +599,12 @@ start_symtab (name, dirname, start_addr)
    because then gdb will never know about this empty file (FIXME). */
 
 struct symtab *
-end_symtab (end_addr, sort_pending, sort_linevec, objfile)
+end_symtab (end_addr, sort_pending, sort_linevec, objfile, section)
      CORE_ADDR end_addr;
      int sort_pending;
      int sort_linevec;
      struct objfile *objfile;
+     int section;
 {
   register struct symtab *symtab;
   register struct blockvector *blockvector;
@@ -731,6 +734,7 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
 	    {
 	      symtab->linetable = NULL;
 	    }
+	  symtab->block_line_section = section;
 	  if (subfile->dirname)
 	    {
 	      /* Reallocate the dirname on the symbol obstack */
@@ -753,14 +757,11 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
 	     language it is from things we found in the symbols. */
 	  symtab->language = subfile->language;
 
-#ifdef IBM6000_TARGET
+	  /* All symtabs for the main file and the subfiles share a
-	  /* In case we need to duplicate symbol tables (to represent include
+	     blockvector, so we need to clear primary for everything but
-	     files), and in case our system needs relocation, we want to
+	     the main file.  */
-	     relocate the main symbol table node only (for the main file,
-	     not for the include files). */
 
-	  symtab->nonreloc = TRUE;
+	  symtab->primary = 0;
-#endif
 	}
       if (subfile->name != NULL)
 	{
@@ -779,14 +780,11 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
       free ((PTR)subfile);
     }
 
-#ifdef IBM6000_TARGET
+  /* Set this for the main source file.  */
-  /* all include symbol tables are non-relocatable, except the main source
-     file's. */
   if (symtab)
     {
-      symtab->nonreloc = FALSE;
+      symtab->primary = 1;
     }
-#endif
 
   last_source_file = NULL;
   current_subfile = NULL;

gdb/buildsym.h

@@ -227,7 +227,7 @@ extern char *
 pop_subfile PARAMS ((void));
 
 extern struct symtab *
-end_symtab PARAMS ((CORE_ADDR, int, int, struct objfile *));
+end_symtab PARAMS ((CORE_ADDR, int, int, struct objfile *, int));
 
 extern void
 scan_file_globals PARAMS ((struct objfile *));

gdb/dwarfread.c

@@ -336,7 +336,8 @@ static int isreg;	/* Kludge to identify register variables */
 static int offreg;	/* Kludge to identify basereg references */
 
 /* This value is added to each symbol value.  FIXME:  Generalize to 
-   the section_offsets structure used by dbxread.  */
+   the section_offsets structure used by dbxread (once this is done,
+   pass the appropriate section number to end_symtab).  */
 static CORE_ADDR baseaddr;	/* Add to each symbol value */
 
 /* The section offsets used in the current psymtab or symtab.  FIXME,
@@ -1977,7 +1978,8 @@ read_file_scope (dip, thisdie, enddie, objfile)
   start_symtab (dip -> at_name, dip -> at_comp_dir, dip -> at_low_pc);
   decode_line_numbers (lnbase);
   process_dies (thisdie + dip -> die_length, enddie, objfile);
-  symtab = end_symtab (dip -> at_high_pc, 0, 0, objfile);
+
+  symtab = end_symtab (dip -> at_high_pc, 0, 0, objfile, 0);
   if (symtab != NULL)
     {
       symtab -> language = cu_language;

gdb/elfread.c

@@ -187,7 +187,7 @@ record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
      struct objfile *objfile;
 {
   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
-  prim_record_minimal_symbol_and_info (name, address, ms_type, info);
+  prim_record_minimal_symbol_and_info (name, address, ms_type, info, -1);
 }
 
 /*

gdb/minsyms.c

@@ -266,6 +266,7 @@ prim_record_minimal_symbol (name, address, ms_type)
   SYMBOL_NAME (msymbol) = (char *) name;
   SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
   SYMBOL_VALUE_ADDRESS (msymbol) = address;
+  SYMBOL_SECTION (msymbol) = -1;
   MSYMBOL_TYPE (msymbol) = ms_type;
   /* FIXME:  This info, if it remains, needs its own field.  */
   MSYMBOL_INFO (msymbol) = NULL; /* FIXME! */
@@ -277,11 +278,12 @@ prim_record_minimal_symbol (name, address, ms_type)
    and pass it a NULL info pointer value if info is not needed? */
 
 void
-prim_record_minimal_symbol_and_info (name, address, ms_type, info)
+prim_record_minimal_symbol_and_info (name, address, ms_type, info, section)
      const char *name;
      CORE_ADDR address;
      enum minimal_symbol_type ms_type;
      char *info;
+     int section;
 {
   register struct msym_bunch *new;
   register struct minimal_symbol *msymbol;
@@ -297,6 +299,7 @@ prim_record_minimal_symbol_and_info (name, address, ms_type, info)
   SYMBOL_NAME (msymbol) = (char *) name;
   SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
   SYMBOL_VALUE_ADDRESS (msymbol) = address;
+  SYMBOL_SECTION (msymbol) = section;
   MSYMBOL_TYPE (msymbol) = ms_type;
   /* FIXME:  This info, if it remains, needs its own field.  */
   MSYMBOL_INFO (msymbol) = info; /* FIXME! */

gdb/objfiles.c

@@ -341,7 +341,96 @@ free_all_objfiles ()
       free_objfile (objfile);
     }
 }
+
+/* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
+   entries in new_offsets.  */
+void
+objfile_relocate (objfile, new_offsets)
+     struct objfile *objfile;
+     struct section_offsets *new_offsets;
+{
+  struct section_offsets *delta = (struct section_offsets *) alloca
+    (sizeof (struct section_offsets)
+     + objfile->num_sections * sizeof (delta->offsets));
 
+  {
+    int i;
+    int something_changed = 0;
+    for (i = 0; i < objfile->num_sections; ++i)
+      {
+	ANOFFSET (delta, i) =
+	  ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
+	if (ANOFFSET (delta, i) != 0)
+	  something_changed = 1;
+      }
+    if (!something_changed)
+      return;
+  }
+
+  /* OK, get all the symtabs.  */
+  {
+    struct symtab *s;
+
+    for (s = objfile->symtabs; s; s = s->next)
+      {
+	struct linetable *l;
+	struct blockvector *bv;
+	int i;
+	
+	/* First the line table.  */
+	l = LINETABLE (s);
+	if (l)
+	  {
+	    for (i = 0; i < l->nitems; ++i)
+	      l->item[i].pc += ANOFFSET (delta, s->block_line_section);
+	  }
+
+	/* Don't relocate a shared blockvector more than once.  */
+	if (!s->primary)
+	  continue;
+
+	bv = BLOCKVECTOR (s);
+	for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
+	  {
+	    struct block *b;
+	    int j;
+	    
+	    b = BLOCKVECTOR_BLOCK (bv, i);
+	    BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
+	    BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
+
+	    for (j = 0; j < BLOCK_NSYMS (b); ++j)
+	      {
+		struct symbol *sym = BLOCK_SYM (b, j);
+		/* The RS6000 code from which this was taken skipped
+		   any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
+		   But I'm leaving out that test, on the theory that
+		   they can't possibly pass the tests below.  */
+		if ((SYMBOL_CLASS (sym) == LOC_LABEL
+		     || SYMBOL_CLASS (sym) == LOC_STATIC)
+		    && SYMBOL_SECTION (sym) >= 0)
+		  {
+		    SYMBOL_VALUE_ADDRESS (sym) +=
+		      ANOFFSET (delta, SYMBOL_SECTION (sym));
+		  }
+	      }
+	  }
+      }
+  }
+
+  {
+    struct minimal_symbol *msym;
+    ALL_OBJFILE_MSYMBOLS (objfile, msym)
+      SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
+  }
+
+  {
+    int i;
+    for (i = 0; i < objfile->num_sections; ++i)
+      ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
+  }
+}
+
 /* Many places in gdb want to test just to see if we have any partial
    symbols available.  This function returns zero if none are currently
    available, nonzero otherwise. */

gdb/objfiles.h

@@ -245,6 +245,18 @@ struct objfile
      gets freed automatically when reading a new object file. */
 
   PTR obj_private;
+
+  /* Set of relocation offsets to apply to each section.
+     Currently on the psymbol_obstack (which makes no sense, but I'm
+     not sure it's harming anything).
+
+     These offsets indicate that all symbols (including partial and
+     minimal symbols) which have been read have been relocated by this
+     much.  Symbols which are yet to be read need to be relocated by
+     it.  */
+
+  struct section_offsets *section_offsets;
+  int num_sections;
 };
 
 /* Defines for the objfile flag word. */
@@ -306,6 +318,9 @@ free_objfile PARAMS ((struct objfile *));
 extern void
 free_all_objfiles PARAMS ((void));
 
+extern void
+objfile_relocate PARAMS ((struct objfile *, struct section_offsets *));
+
 extern int
 have_partial_symbols PARAMS ((void));
 

gdb/rs6000-tdep.c

@@ -1129,13 +1129,10 @@ struct loadinfo {
 
 #define	LOADINFOLEN	10
 
-/* FIXME Warning -- loadinfotextindex is used for a nefarious purpose by
-   tm-rs6000.h.  */
-
 static	struct loadinfo *loadinfo = NULL;
 static	int	loadinfolen = 0;
 static	int	loadinfotocindex = 0;
-int	loadinfotextindex = 0;
+static	int	loadinfotextindex = 0;
 
 
 void

gdb/xcoffexec.c

@@ -301,21 +301,19 @@ map_vmap (bfd *bf, bfd *arch)
 }
 
 
-/* true, if symbol table and minimal symbol table are relocated. */
-
-int symtab_relocated = 0;
-
-
 /*  vmap_symtab -	handle symbol translation on vmapping */
 
-vmap_symtab(vp, old_start, vip)
+static void
-register struct vmap *vp;
+vmap_symtab (vp)
-CORE_ADDR old_start;
+     register struct vmap *vp;
-struct stat *vip; 
 {
-  register struct symtab *s;
   register struct objfile *objfile;
-  register struct minimal_symbol *msymbol;
+  asection *textsec;
+  asection *datasec;
+  asection *bsssec;
+  CORE_ADDR old_text_offset;
+  struct section_offsets *new_offsets;
+  int i;
   
   objfile = vp->objfile;
   if (objfile == NULL)
@@ -328,140 +326,26 @@ struct stat *vip;
       objfile = symfile_objfile;
     }
 
-  s = objfile->symtabs;
+  new_offsets = alloca
+    (sizeof (struct section_offsets)
+     + sizeof (new_offsets->offsets) * objfile->num_sections);
 
-	if (vp->tstart != old_start) {
+  for (i = 0; i < objfile->num_sections; ++i)
+    ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
   
-	  /* Once we find a relocation base address for one of the symtabs
+  textsec = bfd_get_section_by_name (vp->bfd, ".text");
-	     in this objfile, it will be the same for all symtabs in this
+  old_text_offset = ANOFFSET (objfile->section_offsets, textsec->target_index);
-	     objfile. Clean this algorithm. FIXME. */
+  ANOFFSET (new_offsets, textsec->target_index) = vp->tstart;
+  datasec = bfd_get_section_by_name (vp->bfd, ".data");
+  ANOFFSET (new_offsets, datasec->target_index) = vp->dstart;
+  bsssec = bfd_get_section_by_name (vp->bfd, ".bss");
+  ANOFFSET (new_offsets, bsssec->target_index) = vp->dstart;
 
-	  for (; s; s = s->next)
+  objfile_relocate (objfile, new_offsets);
-	    if (!s->nonreloc || LINETABLE(s))
-		vmap_symtab_1(s, vp, old_start);
   
-#if 1
+  if (old_text_offset != ANOFFSET (new_offsets, textsec->target_index))
-	  /* I believe trampoline entries now have a name like
-	     <trampoline>.  In any event, if something needs to be changed,
-	     it should be changed in ALL_MSYMBOLS, so it works everywhere.  */
-	  /*
-	  Himm.., recently we nullified trampoline entry names in order not
-	  to confuse them with real symbols.  Appearently this turned into a
-	  problem, and msymbol vector did not get relocated properly.  If
-	  msymbols have to have non-null names, then we should name
-	  trampoline entries with empty strings. */
-
-	  ALL_MSYMBOLS (objfile, msymbol)
-#else
-	  for (msymbol = objfile->msymbols;
-	       SYMBOL_NAME (msymbol) || SYMBOL_VALUE_ADDRESS (msymbol);
-	       (msymbol)++)
-#endif
-	      if (SYMBOL_VALUE_ADDRESS (msymbol) < TEXT_SEGMENT_BASE)
-		SYMBOL_VALUE_ADDRESS (msymbol) += vp->tstart - old_start;
-
-	}
-
-  if (vp->tstart != old_start) {
     /* breakpoints need to be relocated as well. */
-    fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_start);
+    fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_text_offset);
-  }
-  
-  symtab_relocated = 1;
-}
-
-
-vmap_symtab_1(s, vp, old_start)
-register struct symtab *s;
-register struct vmap *vp;
-CORE_ADDR old_start; 
-{
-    register int i, j;
-    int len, blen;
-    register struct linetable *l;
-    struct blockvector *bv;
-    register struct block *b;
-    int depth;
-    register ulong reloc, dreloc;
-    
-    if ((reloc = vp->tstart - old_start) == 0)
-	return;
-
-    dreloc = vp->dstart;			/* data relocation */
-
-    /*
-     * The line table must be relocated.  This is only present for
-     * .text sections, so only vp->text type maps need be considered.
-     */
-    l = LINETABLE (s);
-    if (l) {
-      len = l->nitems;
-      for (i = 0; i < len; i++)
-	l->item[i].pc += reloc;
-    }
-
-    /* if this symbol table is not relocatable, only line table should
-       be relocated and the rest ignored. */
-    if (s->nonreloc)
-      return;
-    
-    bv  = BLOCKVECTOR(s);
-    len = BLOCKVECTOR_NBLOCKS(bv);
-    
-    for (i = 0; i < len; i++) {
-	b = BLOCKVECTOR_BLOCK(bv, i);
-	
-	BLOCK_START(b) += reloc;
-	BLOCK_END(b)   += reloc;
-	
-	blen = BLOCK_NSYMS(b);
-	for (j = 0; j < blen; j++) {
-	    register struct symbol *sym;
-	    
-	    sym = BLOCK_SYM(b, j);
-	    switch (SYMBOL_NAMESPACE(sym)) {
-	      case STRUCT_NAMESPACE:
-	      case UNDEF_NAMESPACE:
-		continue;
-		
-	      case LABEL_NAMESPACE:
-	      case VAR_NAMESPACE:
-		break;
-	    }
-	    
-	    switch (SYMBOL_CLASS(sym)) {
-	      case LOC_CONST:
-	      case LOC_CONST_BYTES:
-	      case LOC_LOCAL:
-	      case LOC_REGISTER:
-	      case LOC_ARG:
-	      case LOC_LOCAL_ARG:
-	      case LOC_REF_ARG:
-	      case LOC_REGPARM:
-	      case LOC_TYPEDEF:
-		continue;
-		
-#ifdef FIXME
-	      case LOC_EXTERNAL:
-#endif
-	      case LOC_LABEL:
-		SYMBOL_VALUE_ADDRESS(sym) += reloc;
-		break;
-
-	      case LOC_STATIC:
-		SYMBOL_VALUE_ADDRESS(sym) += dreloc;
-		break;
-
-	      case LOC_BLOCK:
-		break;
-		
-	      default:
-		fatal("botched symbol class %x"
-		      , SYMBOL_CLASS(sym));
-		break;
-	    }
-	}
-    }
 }
 
 /* Add symbols for an objfile.  */
@@ -554,7 +438,7 @@ add_vmap(ldi)
 			  "Error while reading shared library symbols:\n"))
 	  {
 	    /* Note this is only done if symbol reading was successful.  */
-	    vmap_symtab (vp, 0, 0);
+	    vmap_symtab (vp);
 	    vp->loaded = 1;
 	  }
 #endif
@@ -698,7 +582,7 @@ retry:
 	  }
 
 	  /* relocate symbol table(s). */
-	  vmap_symtab(vp, ostart, &vi);
+	  vmap_symtab (vp);
 
 	  /* there may be more, so we don't break out of the loop. */
 	}
@@ -1079,7 +963,7 @@ bfd_err:
 	  stp->endaddr = bfd_section_vma (stp->bfd, stp->sec_ptr) + vp->dend;
 	}
 
-      vmap_symtab (vp, 0, 0);
+      vmap_symtab (vp);
 
       add_text_to_loadinfo (ldip->ldinfo_textorg, ldip->ldinfo_dataorg);
     } while (ldip->ldinfo_next != 0);

gdb/xcoffread.c

@@ -50,7 +50,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "objfiles.h"
 #include "buildsym.h"
 #include "stabsread.h"
-#include "gdb-stabs.h"
 #include "complaints.h"
 
 #include "coff/internal.h"	/* FIXME, internal data from BFD */
@@ -201,6 +200,9 @@ init_lineno PARAMS ((bfd *, file_ptr, int));
 static void
 find_linenos PARAMS ((bfd *, sec_ptr, PTR));
 
+static void
+read_symbol PARAMS ((struct internal_syment *, int));
+
 static int
 read_symbol_lineno PARAMS ((int));
 
@@ -972,7 +974,7 @@ retrieve_traceback (abfd, textsec, cs, size)
 /* Reading symbol table has to be fast! Keep the followings as macros, rather
    than functions. */
 
-#define	RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED)	\
+#define	RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION)	\
 {						\
   char *namestr;				\
   if (ALLOCED) 					\
@@ -982,7 +984,8 @@ retrieve_traceback (abfd, textsec, cs, size)
     obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
     (ALLOCED) = 1;						\
   }								\
-  prim_record_minimal_symbol (namestr, (ADDR), (TYPE));		\
+  prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
+				       (char *)NULL, (SECTION));	\
   misc_func_recorded = 1;					\
 }
 
@@ -1012,6 +1015,10 @@ static struct symbol parmsym;
    
 static int static_block_base = 0;
 
+/* Section number for the current static block.  */
+
+static int static_block_section = -1;
+
 /* true if space for symbol name has been allocated. */
 
 static int symname_alloced = 0;
@@ -1056,6 +1063,7 @@ read_xcoff_symtab (objfile, nsyms)
 
   char *last_csect_name;		/* last seen csect's name and value */
   CORE_ADDR last_csect_val;
+  int last_csect_sec;
   int  misc_func_recorded;		/* true if any misc. function */
 
   current_objfile = objfile;
@@ -1154,7 +1162,7 @@ read_xcoff_symtab (objfile, nsyms)
     if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) {
       if (last_source_file)
 	{
-	  end_symtab (cur_src_end_addr, 1, 0, objfile);
+	  end_symtab (cur_src_end_addr, 1, 0, objfile, textsec->target_index);
 	  end_stabs ();
 	}
 
@@ -1215,13 +1223,14 @@ read_xcoff_symtab (objfile, nsyms)
 		  if (!misc_func_recorded) {
 		     int alloced = 0;
 		     RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
-					    mst_text, alloced);
+					    mst_text, alloced, last_csect_sec);
 		  }
 		    
 
 		  complete_symtab (filestring, file_start_addr);
 		  cur_src_end_addr = file_end_addr;
-		  end_symtab (file_end_addr, 1, 0, objfile);
+		  end_symtab (file_end_addr, 1, 0, objfile,
+			      textsec->target_index);
 		  end_stabs ();
 		  start_stabs ();
 		  start_symtab ((char *)NULL, (char *)NULL, (CORE_ADDR)0);
@@ -1239,6 +1248,7 @@ read_xcoff_symtab (objfile, nsyms)
 		if (cs->c_name && cs->c_name[0] == '.') {
 		  last_csect_name = cs->c_name;
 		  last_csect_val = cs->c_value;
+		  last_csect_sec = cs->c_secnum;
 		}
 	      }
 	      misc_func_recorded = 0;
@@ -1270,7 +1280,7 @@ read_xcoff_symtab (objfile, nsyms)
 
 function_entry_point:
 	    RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, 
-				   symname_alloced);
+				   symname_alloced, cs->c_secnum);
 
 	    fcn_line_offset = main_aux->x_sym.x_fcnary.x_fcn.x_lnnoptr;
 	    fcn_start_addr = cs->c_value;
@@ -1357,8 +1367,9 @@ function_entry_point:
 	    /* Recording this entry is necessary. Single stepping relies on
 	       this vector to get an idea about function address boundaries. */
 
-	    prim_record_minimal_symbol ("<trampoline>", cs->c_value,
+	    prim_record_minimal_symbol_and_info
-					mst_unknown);
+	      ("<trampoline>", cs->c_value, mst_unknown,
+	       (char *)NULL, cs->c_secnum);
 #else
 
 	    /* record trampoline code entries as mst_unknown symbol. When we
@@ -1389,7 +1400,7 @@ function_entry_point:
 
 	  int alloced = 0;
 	  RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
-				mst_text, alloced);
+				mst_text, alloced, last_csect_sec);
       }
 
       /* c_value field contains symnum of next .file entry in table
@@ -1406,7 +1417,7 @@ function_entry_point:
 
       complete_symtab (filestring, file_start_addr);
       cur_src_end_addr = file_end_addr;
-      end_symtab (file_end_addr, 1, 0, objfile);
+      end_symtab (file_end_addr, 1, 0, objfile, textsec->target_index);
       end_stabs ();
       start_stabs ();
       start_symtab (cs->c_name, (char *)NULL, (CORE_ADDR)0);
@@ -1526,6 +1537,8 @@ function_entry_point:
 #else
 	new->name = define_symbol 
 		(fcn_cs_saved.c_value, fcn_stab_saved.c_name, 0, 0, objfile);
+	if (new->name != NULL)
+	  SYMBOL_SECTION (new->name) = cs->c_secnum;
 #endif
       }
       else if (STREQ (cs->c_name, ".ef")) {
@@ -1553,11 +1566,18 @@ function_entry_point:
       break;
 
     case C_BSTAT	:		/* begin static block	*/
-      static_block_base = read_symbol_nvalue (cs->c_value);
+      {
+	struct internal_syment symbol;
+	
+	read_symbol (&symbol, cs->c_value);
+	static_block_base = symbol.n_value;
+	static_block_section = symbol.n_scnum;
+      }
       break;
 
     case C_ESTAT	:		/* end of static block	*/
       static_block_base = 0;
+      static_block_section = -1;
       break;
 
     case C_ARG		:		/* These are not implemented. */
@@ -1619,7 +1639,7 @@ function_entry_point:
 
   if (last_source_file)
     {
-      end_symtab (cur_src_end_addr, 1, 0, objfile);
+      end_symtab (cur_src_end_addr, 1, 0, objfile, textsec->target_index);
       end_stabs ();
     }
 
@@ -1669,6 +1689,7 @@ process_xcoff_symbol (cs, objfile)
   /* default assumptions */
   SYMBOL_VALUE (sym) = cs->c_value;
   SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+  SYMBOL_SECTION (sym) = cs->c_secnum;
 
   if (ISFCN (cs->c_type)) {
 
@@ -1814,7 +1835,10 @@ process_xcoff_symbol (cs, objfile)
 	break;
 
 #else /* !NO_DEFINE_SYMBOL */
- 	return define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+      sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+      if (sym != NULL)
+	SYMBOL_SECTION (sym) = cs->c_secnum;
+      return sym;
 #endif
 
     case C_GSYM:
@@ -1836,7 +1860,12 @@ process_xcoff_symbol (cs, objfile)
 	break;
 #else
       sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
-	SYMBOL_CLASS (sym) = (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
+      if (sym != NULL)
+	{
+	  SYMBOL_CLASS (sym) =
+	    (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
+	  SYMBOL_SECTION (sym) = cs->c_secnum;
+	}
       return sym;
 #endif
 
@@ -1865,7 +1894,11 @@ process_xcoff_symbol (cs, objfile)
 	++pp;
 	if (*pp == 'V') *pp = 'S';
 	sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+        if (sym != NULL)
+	  {
 	    SYMBOL_VALUE (sym) += static_block_base;
+	    SYMBOL_SECTION (sym) = static_block_section;
+	  }
 	return sym;
 #endif
 
@@ -1876,6 +1909,7 @@ process_xcoff_symbol (cs, objfile)
 	SYMBOL_CLASS (sym) = LOC_LOCAL;
 	pp += 1;
 	SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+        SYMBOL_SECTION (sym) = cs->c_secnum;
 	SYMBOL_DUP (sym, sym2);
 	add_symbol_to_list (sym2, &local_symbols);
 	break;
@@ -1883,6 +1917,7 @@ process_xcoff_symbol (cs, objfile)
     case C_AUTO:
       SYMBOL_CLASS (sym) = LOC_LOCAL;
       SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+      SYMBOL_SECTION (sym) = cs->c_secnum;
       SYMBOL_DUP (sym, sym2);
       add_symbol_to_list (sym2, &local_symbols);
       break;
@@ -1890,6 +1925,7 @@ process_xcoff_symbol (cs, objfile)
     case C_EXT:
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+      SYMBOL_SECTION (sym) = cs->c_secnum;
       SYMBOL_DUP (sym, sym2);
       add_symbol_to_list (sym2, &global_symbols);
       break;
@@ -1897,6 +1933,7 @@ process_xcoff_symbol (cs, objfile)
     case C_STAT:
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+      SYMBOL_SECTION (sym) = cs->c_secnum;
       SYMBOL_DUP (sym, sym2);
       add_symbol_to_list 
 	   (sym2, within_function ? &local_symbols : &file_symbols);
@@ -1906,6 +1943,7 @@ process_xcoff_symbol (cs, objfile)
       printf ("ERROR! C_REG is not fully implemented!\n");
       SYMBOL_CLASS (sym) = LOC_REGISTER;
       SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+      SYMBOL_SECTION (sym) = cs->c_secnum;
       SYMBOL_DUP (sym, sym2);
       add_symbol_to_list (sym2, &local_symbols);
       break;
@@ -1935,6 +1973,8 @@ process_xcoff_symbol (cs, objfile)
 #else
 	if (pp) {
 	  sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+	  if (sym != NULL)
+	    SYMBOL_SECTION (sym) = cs->c_secnum;
 	  return sym;
 	}
 	else {
@@ -1951,6 +1991,24 @@ process_xcoff_symbol (cs, objfile)
   return sym2;
 }
 
+/* Set *SYMBOL to symbol number symno in symtbl.  */
+static void
+read_symbol (symbol, symno)
+     struct internal_syment *symbol;
+     int symno;
+{
+  if (symno < 0 || symno >= symtbl_num_syms)
+    {
+      struct complaint msg =
+	{"Invalid symbol offset", 0, 0};
+      complain (&msg);
+      symbol->n_value = 0;
+      symbol->n_scnum = -1;
+      return;
+    }
+  bfd_coff_swap_sym_in (symfile_bfd, symtbl + (symno*local_symesz), symbol);
+}
+  
 /* Get value corresponding to symbol number symno in symtbl.  */
 
 static int
@@ -1959,14 +2017,7 @@ read_symbol_nvalue (symno)
 {
   struct internal_syment symbol[1];
 
-  if (symno < 0 || symno >= symtbl_num_syms)
+  read_symbol (symbol, symno);
-    {
-      struct complaint msg =
-	{"Invalid symbol offset", 0, 0};
-      complain (&msg);
-      return 0;
-    }
-  bfd_coff_swap_sym_in (symfile_bfd, symtbl + (symno*local_symesz), symbol);
   return symbol->n_value;  
 }
 
@@ -2313,8 +2364,19 @@ xcoff_symfile_read (objfile, section_offset, mainline)
   select_source_symtab (0);
 }
 
-/* XCOFF-specific parsing routine for section offsets.
+/* XCOFF-specific parsing routine for section offsets.  */
-   Plain and simple for now.  */
+
+static int largest_section;
+
+static void
+note_one_section (abfd, asect, ptr)
+     bfd *abfd;
+     asection *asect;
+     PTR ptr;
+{
+  if (asect->target_index > largest_section)
+    largest_section = asect->target_index;
+}
 
 static
 struct section_offsets *
@@ -2325,12 +2387,16 @@ xcoff_symfile_offsets (objfile, addr)
   struct section_offsets *section_offsets;
   int i;
 
+  largest_section = 0;
+  bfd_map_over_sections (objfile->obfd, note_one_section, NULL);
+  objfile->num_sections = largest_section + 1;
   section_offsets = (struct section_offsets *)
-    obstack_alloc (&objfile -> psymbol_obstack,
+    obstack_alloc
-		   sizeof (struct section_offsets) +
+      (&objfile -> psymbol_obstack,
-		          sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
+       sizeof (struct section_offsets)
+       + sizeof (section_offsets->offsets) * (objfile->num_sections));
 
-  for (i = 0; i < SECT_OFF_MAX; i++)
+  for (i = 0; i < objfile->num_sections; i++)
     ANOFFSET (section_offsets, i) = addr;
   
   return section_offsets;

gdb/xcoffsolib.h

@@ -40,10 +40,8 @@ struct vmap {
 	/* This is NULL for the exec-file.  */
 	struct objfile *objfile;
 
-	CORE_ADDR ostart;	/* objext start ???			*/
 	unsigned  loaded:1;	/* True if symbols are loaded		*/
-	unsigned  reloced:1;	/* True, if symbols relocated		*/
+	unsigned  padding:15;
-	unsigned  padding:14;
 };