* xcofflink.c: Extensive changes to support linking shared objects

	and generating a .loader section.
	* libcoff-in.h (struct xcoff_tdata): Add import_file_id field.
	(struct xcoff_section_tdata): Add first_symndx, last_symndx,
	and ldrel_count fields.
	* libcoff.h: Rebuild.
	* coff-rs6000.c (xcoff_howto_table): Correct reloc names.
	* coffcode.h (styp_to_sec_flags): Don't set any flags if STYP_PAD
	is set.
	* bfd-in.h (bfd_xcoff_import_symbol): Declare.
	(bfd_xcoff_export_symbol): Declare.
	(bfd_xcoff_size_dynamic_sections): Declare.
	* bfd-in2.h: Rebuild.

1 files changed, 2468 insertions, 438 deletions

diff --git a/bfd/xcofflink.c b/bfd/xcofflink.c
index 7601839a..723eefd 100644
--- a/bfd/xcofflink.c
+++ b/bfd/xcofflink.c
@@ -36,21 +36,256 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #define obj_xcoff_sym_hashes(bfd) \
   ((struct xcoff_link_hash_entry **) obj_coff_sym_hashes (bfd))
 
+/* XCOFF relocation types.  These probably belong in a header file
+   somewhere.  The relocations are described in the function
+   _bfd_ppc_xcoff_relocate_section in this file.  */
+
+#define R_POS   (0x00)
+#define R_NEG   (0x01)
+#define R_REL   (0x02)
+#define R_TOC   (0x03)
+#define R_RTB   (0x04)
+#define R_GL    (0x05)
+#define R_TCL   (0x06)
+#define R_BA    (0x08)
+#define R_BR    (0x0a)
+#define R_RL    (0x0c)
+#define R_RLA   (0x0d)
+#define R_REF   (0x0f)
+#define R_TRL   (0x12)
+#define R_TRLA  (0x13)
+#define R_RRTBI (0x14)
+#define R_RRTBA (0x15)
+#define R_CAI   (0x16)
+#define R_CREL  (0x17)
+#define R_RBA   (0x18)
+#define R_RBAC  (0x19)
+#define R_RBR   (0x1a)
+#define R_RBRC  (0x1b)
+
+/* The first word of global linkage code.  This must be modified by
+   filling in the correct TOC offset.  */
+
+#define XCOFF_GLINK_FIRST (0x81820000)	/* lwz r12,0(r2) */
+
+/* The remaining words of global linkage code.  */
+
+static unsigned long xcoff_glink_code[] =
+{
+  0x90410014,	/* stw r2,20(r1) */
+  0x800c0000,	/* lwz r0,0(r12) */
+  0x804c0004,	/* lwz r2,4(r12) */
+  0x7c0903a6,	/* mtctr r0 */
+  0x4e800420,	/* bctr */
+  0x0,		/* start of traceback table */
+  0x000c8000,	/* traceback table */
+  0x0		/* traceback table */
+};
+
+#define XCOFF_GLINK_SIZE \
+  (((sizeof xcoff_glink_code / sizeof xcoff_glink_code[0]) * 4) + 4)
+
+/* We reuse the SEC_ROM flag as a mark flag for garbage collection.
+   This flag will only be used on input sections.  */
+
+#define SEC_MARK (SEC_ROM)
+
+/* The ldhdr structure.  This appears at the start of the .loader
+   section.  */
+
+struct internal_ldhdr
+{
+  /* The version number: currently always 1.  */
+  unsigned long l_version;
+  /* The number of symbol table entries.  */
+  bfd_size_type l_nsyms;
+  /* The number of relocation table entries.  */
+  bfd_size_type l_nreloc;
+  /* The length of the import file string table.  */
+  bfd_size_type l_istlen;
+  /* The number of import files.  */
+  bfd_size_type l_nimpid;
+  /* The offset from the start of the .loader section to the first
+     entry in the import file table.  */
+  bfd_size_type l_impoff;
+  /* The length of the string table.  */
+  bfd_size_type l_stlen;
+  /* The offset from the start of the .loader section to the first
+     entry in the string table.  */
+  bfd_size_type l_stoff;
+};
+
+struct external_ldhdr
+{
+  bfd_byte l_version[4];
+  bfd_byte l_nsyms[4];
+  bfd_byte l_nreloc[4];
+  bfd_byte l_istlen[4];
+  bfd_byte l_nimpid[4];
+  bfd_byte l_impoff[4];
+  bfd_byte l_stlen[4];
+  bfd_byte l_stoff[4];
+};
+
+#define LDHDRSZ (8 * 4)
+
+/* The ldsym structure.  This is used to represent a symbol in the
+   .loader section.  */
+
+struct internal_ldsym
+{
+  union
+    {
+      /* The symbol name if <= SYMNMLEN characters.  */
+      char _l_name[SYMNMLEN];
+      struct
+	{
+	  /* Zero if the symbol name is more than SYMNMLEN characters.  */
+	  long _l_zeroes;
+	  /* The offset in the string table if the symbol name is more
+             than SYMNMLEN characters.  */
+	  long _l_offset;
+	} _l_l;
+    } _l;
+  /* The symbol value.  */
+  bfd_vma l_value;
+  /* The symbol section number.  */
+  short l_scnum;
+  /* The symbol type and flags.  */
+  char l_smtype;
+  /* The symbol storage class.  */
+  char l_smclas;
+  /* The import file ID.  */
+  bfd_size_type l_ifile;
+  /* Offset to the parameter type check string.  */
+  bfd_size_type l_parm;
+};
+
+struct external_ldsym
+{
+  union
+    {
+      bfd_byte _l_name[SYMNMLEN];
+      struct
+	{
+	  bfd_byte _l_zeroes[4];
+	  bfd_byte _l_offset[4];
+	} _l_l;
+    } _l;
+  bfd_byte l_value[4];
+  bfd_byte l_scnum[2];
+  bfd_byte l_smtype[1];
+  bfd_byte l_smclas[1];
+  bfd_byte l_ifile[4];
+  bfd_byte l_parm[4];
+};
+
+#define LDSYMSZ (8 + 3 * 4 + 2 + 2)
+
+/* These flags are for the l_smtype field (the lower three bits are an
+   XTY_* value).  */
+
+/* Imported symbol.  */
+#define L_IMPORT (0x40)
+/* Entry point.  */
+#define L_ENTRY (0x20)
+/* Exported symbol.  */
+#define L_EXPORT (0x10)
+
+/* The ldrel structure.  This is used to represent a reloc in the
+   .loader section.  */
+
+struct internal_ldrel
+{
+  /* The reloc address.  */
+  bfd_vma l_vaddr;
+  /* The symbol table index in the .loader section symbol table.  */
+  bfd_size_type l_symndx;
+  /* The relocation type and size.  */
+  short l_rtype;
+  /* The section number this relocation applies to.  */
+  short l_rsecnm;
+};
+
+struct external_ldrel
+{
+  bfd_byte l_vaddr[4];
+  bfd_byte l_symndx[4];
+  bfd_byte l_rtype[2];
+  bfd_byte l_rsecnm[2];
+};
+
+#define LDRELSZ (2 * 4 + 2 * 2)
+
+/* The list of import files.  */
+
+struct xcoff_import_file
+{
+  /* The next entry in the list.  */
+  struct xcoff_import_file *next;
+  /* The path.  */
+  const char *path;
+  /* The file name.  */
+  const char *file;
+  /* The member name.  */
+  const char *member;
+};
+
 /* An entry in the XCOFF linker hash table.  */
 
 struct xcoff_link_hash_entry
 {
   struct bfd_link_hash_entry root;
 
-  /* Whether this symbol came from an XCOFF input file.  */
-  boolean xcoff;
-
   /* Symbol index in output file.  Set to -1 initially.  Set to -2 if
      there is a reloc against this symbol.  */
   long indx;
 
-  /* Whether we have created a TOC entry for this symbol.  */
-  boolean toc;
+  /* If we have created a TOC entry for this symbol, this is the .tc
+     section which holds it.  */
+  asection *toc_section;
+
+  /* If we have created a TOC entry, this is the offset in
+     toc_section.  */
+  bfd_vma toc_offset;
+
+  /* If this symbol is a function entry point which is called, this
+     field holds a pointer to the function descriptor.  */
+  struct xcoff_link_hash_entry *descriptor;
+
+  /* The .loader symbol table entry, if there is one.  */
+  struct internal_ldsym *ldsym;
+
+  /* The .loader symbol table index.  */
+  long ldindx;
+
+  /* Some linker flags.  */
+  unsigned short flags;
+  /* Symbol is referenced by a regular object.  */
+#define XCOFF_REF_REGULAR (01)
+  /* Symbol is defined by a regular object.  */
+#define XCOFF_DEF_REGULAR (02)
+  /* Symbol is referenced by a dynamic object.  */
+#define XCOFF_REF_DYNAMIC (04)
+  /* Symbol is used in a reloc being copied into the .loader section.  */
+#define XCOFF_LDREL (010)
+  /* Symbol is the entry point.  */
+#define XCOFF_ENTRY (020)
+  /* Symbol is called; this is, it appears in a R_BR reloc.  */
+#define XCOFF_CALLED (040)
+  /* Symbol needs the TOC entry filled in.  */
+#define XCOFF_SET_TOC (0100)
+  /* Symbol is explicitly imported.  */
+#define XCOFF_IMPORT (0200)
+  /* Symbol is explicitly exported.  */
+#define XCOFF_EXPORT (0400)
+  /* Symbol has been processed by xcoff_build_ldsyms.  */
+#define XCOFF_BUILT_LDSYM (01000)
+  /* Symbol is mentioned by a section which was not garbage collected.  */
+#define XCOFF_MARK (02000)
+
+  /* The storage mapping class.  */
+  unsigned char smclas;
 };
 
 /* The XCOFF linker hash table.  */
@@ -66,9 +301,39 @@ struct xcoff_link_hash_table
 
   /* The .debug section we will use for the final output.  */
   asection *debug_section;
+
+  /* The .loader section we will use for the final output.  */
+  asection *loader_section;
+
+  /* A count of non TOC relative relocs which will need to be
+     allocated in the .loader section.  */
+  size_t ldrel_count;
+
+  /* The .loader section header.  */
+  struct internal_ldhdr ldhdr;
+
+  /* The .gl section we use to hold global linkage code.  */
+  asection *linkage_section;
+
+  /* The .tc section we use to hold toc entries we build for global
+     linkage code.  */
+  asection *toc_section;
+
+  /* The list of import files.  */
+  struct xcoff_import_file *imports;
+
+  /* Required alignment of sections within the output file.  */
+  unsigned long file_align;
+
+  /* Whether the .text section must be read-only.  */
+  boolean textro;
+
+  /* Whether garbage collection was done.  */
+  boolean gc;
 };
 
-/* Information we keep for each section in the output file.  */
+/* Information we keep for each section in the output file during the
+   final link phase.  */
 
 struct xcoff_link_section_info
 {
@@ -98,6 +363,10 @@ struct xcoff_final_link_info
   struct internal_syment last_file;
   /* Symbol index of TOC symbol.  */
   long toc_symindx;
+  /* Start of .loader symbols.  */
+  struct external_ldsym *ldsym;
+  /* Next .loader reloc to swap out.  */
+  struct external_ldrel *ldrel;
   /* Buffer large enough to hold swapped symbols of any input file.  */
   struct internal_syment *internal_syms;
   /* Buffer large enough to hold output indices of symbols of any
@@ -114,8 +383,17 @@ struct xcoff_final_link_info
   bfd_byte *external_relocs;
 };
 
+static void xcoff_swap_ldhdr_out
+  PARAMS ((bfd *, const struct internal_ldhdr *, struct external_ldhdr *));
+static void xcoff_swap_ldsym_out
+  PARAMS ((bfd *, const struct internal_ldsym *, struct external_ldsym *));
+static void xcoff_swap_ldrel_out
+  PARAMS ((bfd *, const struct internal_ldrel *, struct external_ldrel *));
 static struct bfd_hash_entry *xcoff_link_hash_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
+static struct internal_reloc *xcoff_read_internal_relocs
+  PARAMS ((bfd *, asection *, boolean, bfd_byte *, boolean,
+	   struct internal_reloc *));
 static boolean xcoff_link_add_object_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
 static boolean xcoff_link_check_archive_element
@@ -123,6 +401,12 @@ static boolean xcoff_link_check_archive_element
 static boolean xcoff_link_check_ar_symbols
   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
 static boolean xcoff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
+static boolean xcoff_link_add_dynamic_symbols
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean xcoff_mark PARAMS ((struct bfd_link_info *, asection *));
+static void xcoff_sweep PARAMS ((struct bfd_link_info *));
+static boolean xcoff_build_ldsyms
+  PARAMS ((struct xcoff_link_hash_entry *, PTR));
 static boolean xcoff_link_input_bfd
   PARAMS ((struct xcoff_final_link_info *, bfd *));
 static boolean xcoff_write_global_symbol
@@ -131,7 +415,69 @@ static boolean xcoff_reloc_link_order
   PARAMS ((bfd *, struct xcoff_final_link_info *, asection *,
 	   struct bfd_link_order *));
 static int xcoff_sort_relocs PARAMS ((const PTR, const PTR));
+
+/* Routines to swap information in the XCOFF .loader section.  We only
+   need to swap this information out, not in.  I believe that only the
+   loader needs to swap this information in.  If we ever need to write
+   an XCOFF loader, this stuff will need to be moved to another file
+   shared by the linker (which XCOFF calls the ``binder'') and the
+   loader.  */
+
+/* Swap out the ldhdr structure.  */
 
+static void
+xcoff_swap_ldhdr_out (abfd, src, dst)
+     bfd *abfd;
+     const struct internal_ldhdr *src;
+     struct external_ldhdr *dst;
+{
+  bfd_put_32 (abfd, src->l_version, dst->l_version);
+  bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
+  bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
+  bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
+  bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
+  bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
+  bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
+  bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
+}
+
+/* Swap out the ldsym structure.  */
+
+static void
+xcoff_swap_ldsym_out (abfd, src, dst)
+     bfd *abfd;
+     const struct internal_ldsym *src;
+     struct external_ldsym *dst;
+{
+  if (src->_l._l_l._l_zeroes != 0)
+    memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
+  else
+    {
+      bfd_put_32 (abfd, 0, dst->_l._l_l._l_zeroes);
+      bfd_put_32 (abfd, src->_l._l_l._l_offset, dst->_l._l_l._l_offset);
+    }
+  bfd_put_32 (abfd, src->l_value, dst->l_value);
+  bfd_put_16 (abfd, src->l_scnum, dst->l_scnum);
+  bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
+  bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
+  bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
+  bfd_put_32 (abfd, src->l_parm, dst->l_parm);
+}
+
+/* Swap out the ldrel structure.  */
+
+static void
+xcoff_swap_ldrel_out (abfd, src, dst)
+     bfd *abfd;
+     const struct internal_ldrel *src;
+     struct external_ldrel *dst;
+{
+  bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
+  bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
+  bfd_put_16 (abfd, src->l_rtype, dst->l_rtype);
+  bfd_put_16 (abfd, src->l_rsecnm, dst->l_rsecnm);
+}
+
 /* Routine to create an entry in an XCOFF link hash table.  */
 
 static struct bfd_hash_entry *
@@ -160,9 +506,14 @@ xcoff_link_hash_newfunc (entry, table, string)
   if (ret != NULL)
     {
       /* Set local fields.  */
-      ret->xcoff = false;
       ret->indx = -1;
-      ret->toc = false;
+      ret->toc_section = NULL;
+      ret->toc_offset = 0;
+      ret->descriptor = NULL;
+      ret->ldsym = NULL;
+      ret->ldindx = -1;
+      ret->flags = 0;
+      ret->smclas = XMC_UA;
     }
 
   return (struct bfd_hash_entry *) ret;
@@ -191,6 +542,15 @@ _bfd_xcoff_bfd_link_hash_table_create (abfd)
 
   ret->debug_strtab = _bfd_xcoff_stringtab_init ();
   ret->debug_section = NULL;
+  ret->loader_section = NULL;
+  ret->ldrel_count = 0;
+  memset (&ret->ldhdr, 0, sizeof (struct internal_ldhdr));
+  ret->linkage_section = NULL;
+  ret->toc_section = NULL;
+  ret->imports = NULL;
+  ret->file_align = 0;
+  ret->textro = false;
+  ret->gc = false;
 
   return &ret->root;
 }
@@ -214,7 +574,62 @@ _bfd_xcoff_bfd_link_hash_table_create (abfd)
    just a cast.  */
 
 #define xcoff_hash_table(p) ((struct xcoff_link_hash_table *) ((p)->hash))
+
+/* Read internal relocs for an XCOFF csect.  This is a wrapper around
+   _bfd_coff_read_internal_relocs which tries to take advantage of any
+   relocs which may have been cached for the enclosing section.  */
+
+static struct internal_reloc *
+xcoff_read_internal_relocs (abfd, sec, cache, external_relocs,
+			    require_internal, internal_relocs)
+     bfd *abfd;
+     asection *sec;
+     boolean cache;
+     bfd_byte *external_relocs;
+     boolean require_internal;
+     struct internal_reloc *internal_relocs;
+{
+  if (coff_section_data (abfd, sec) != NULL
+      && coff_section_data (abfd, sec)->relocs == NULL
+      && xcoff_section_data (abfd, sec) != NULL)
+    {
+      asection *enclosing;
+
+      enclosing = xcoff_section_data (abfd, sec)->enclosing;
+
+      if (enclosing != NULL
+	  && (coff_section_data (abfd, enclosing) == NULL
+	      || coff_section_data (abfd, enclosing)->relocs == NULL)
+	  && cache)
+	{
+	  if (_bfd_coff_read_internal_relocs (abfd, enclosing, true,
+					      external_relocs, false,
+					      (struct internal_reloc *) NULL)
+	      == NULL)
+	    return NULL;
+	}
+
+      if (enclosing != NULL
+	  && coff_section_data (abfd, enclosing) != NULL
+	  && coff_section_data (abfd, enclosing)->relocs != NULL)
+	{
+	  size_t off;
+
+	  off = ((sec->rel_filepos - enclosing->rel_filepos)
+		 / bfd_coff_relsz (abfd));
+	  if (! require_internal)
+	    return coff_section_data (abfd, enclosing)->relocs + off;
+	  memcpy (internal_relocs,
+		  coff_section_data (abfd, enclosing)->relocs + off,
+		  sec->reloc_count * sizeof (struct internal_reloc));
+	  return internal_relocs;
+	}
+    }
 
+  return _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
+					 require_internal, internal_relocs);
+}
+
 /* Given an XCOFF BFD, add symbols to the global hash table as
    appropriate.  */
 
@@ -328,7 +743,8 @@ xcoff_link_check_ar_symbols (abfd, info, pneeded)
 	  /* We are only interested in symbols that are currently
 	     undefined.  If a symbol is currently known to be common,
 	     XCOFF linkers do not bring in an object file which
-	     defines it.  */
+	     defines it.  We also don't bring in symbols to satisfy
+	     undefined references in shared objects.  */
 	  if (h != (struct bfd_link_hash_entry *) NULL
 	      && h->type == bfd_link_hash_undefined)
 	    {
@@ -369,27 +785,86 @@ xcoff_link_add_symbols (abfd, info)
      bfd *abfd;
      struct bfd_link_info *info;
 {
+  unsigned int n_tmask;
+  unsigned int n_btshft;
   boolean default_copy;
   bfd_size_type symcount;
   struct xcoff_link_hash_entry **sym_hash;
   asection **csect_cache;
-  asection *debug_section;
-  unsigned long *debug_index = NULL;
-  bfd_byte *debug_contents = NULL;
+  bfd_size_type linesz;
   asection *sub;
+  boolean keep_syms;
   asection *csect;
   unsigned int csect_index;
   asection *first_csect;
-  boolean new_debug;
   bfd_size_type symesz;
   bfd_byte *esym;
   bfd_byte *esym_end;
   struct reloc_info_struct
     {
       struct internal_reloc *relocs;
-      boolean *used;
+      asection **csects;
+      bfd_byte *linenos;
     } *reloc_info = NULL;
 
+  if ((abfd->flags & DYNAMIC) != 0
+      && ! info->static_link)
+    return xcoff_link_add_dynamic_symbols (abfd, info);
+
+  n_tmask = coff_data (abfd)->local_n_tmask;
+  n_btshft = coff_data (abfd)->local_n_btshft;
+
+  /* Define macros so that ISFCN, et. al., macros work correctly.  */
+#define N_TMASK n_tmask
+#define N_BTSHFT n_btshft
+
+  /* We need to build a .loader section, so we do it here.  This won't
+     work if we're producing an XCOFF output file with no non dynamic
+     XCOFF input files.  FIXME.  */
+  if (xcoff_hash_table (info)->loader_section == NULL)
+    {
+      asection *lsec;
+
+      lsec = bfd_make_section_anyway (abfd, ".loader");
+      if (lsec == NULL)
+	goto error_return;
+      xcoff_hash_table (info)->loader_section = lsec;
+      lsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
+    }
+  /* Likewise for the linkage section.  */
+  if (xcoff_hash_table (info)->linkage_section == NULL)
+    {
+      asection *lsec;
+
+      lsec = bfd_make_section_anyway (abfd, ".gl");
+      if (lsec == NULL)
+	goto error_return;
+      xcoff_hash_table (info)->linkage_section = lsec;
+      lsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
+    }
+  /* Likewise for the TOC section.  */
+  if (xcoff_hash_table (info)->toc_section == NULL)
+    {
+      asection *tsec;
+
+      tsec = bfd_make_section_anyway (abfd, ".tc");
+      if (tsec == NULL)
+	goto error_return;
+      xcoff_hash_table (info)->toc_section = tsec;
+      tsec->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
+    }
+  /* Likewise for the .debug section.  */
+  if (xcoff_hash_table (info)->debug_section == NULL)
+    {
+      asection *dsec;
+
+      dsec = bfd_make_section_anyway (abfd, ".debug");
+      if (dsec == NULL)
+	goto error_return;
+      xcoff_hash_table (info)->debug_section = dsec;
+      dsec->flags |= SEC_HAS_CONTENTS | SEC_IN_MEMORY;
+    }
+
   if (info->keep_memory)
     default_copy = false;
   else
@@ -425,42 +900,6 @@ xcoff_link_add_symbols (abfd, info)
   xcoff_data (abfd)->csects = csect_cache;
   memset (csect_cache, 0, (size_t) symcount * sizeof (asection *));
 
-  /* XCOFF stores debugging symbol names in the .debug section.  We
-     need to determine the size of the final .debug section while
-     reading the input files, before the linker starts deciding where
-     to put everything.  We build a hash table for the final .debug
-     section.  For each symbol whose name goes into it, we store the
-     index in the .debug section in the debug_indices array.  */
-  debug_section = bfd_get_section_by_name (abfd, ".debug");
-  if (debug_section != NULL && debug_section->_raw_size > 0)
-    {
-      debug_index = ((unsigned long *)
-		     bfd_zalloc (abfd, symcount * sizeof (unsigned long)));
-      if (debug_index == NULL && symcount != 0)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  goto error_return;
-	}
-      xcoff_data (abfd)->debug_indices = debug_index;
-
-      /* Grab the contents of the current .debug section.  We use
-         malloc and copy the names into the string tab hash table,
-         rather than bfd_alloc, because I expect that when linking
-         many files together, many of the strings will be the same.
-         Storing the strings in the hash table should save space in
-         that case.  */
-      debug_contents = (bfd_byte *) malloc (debug_section->_raw_size);
-      if (debug_contents == NULL)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  goto error_return;
-	}
-      if (! bfd_get_section_contents (abfd, debug_section,
-				      (PTR) debug_contents, (file_ptr) 0,
-				      debug_section->_raw_size))
-	goto error_return;
-    }
-
   /* While splitting sections into csects, we need to assign the
      relocs correctly.  The relocs and the csects must both be in
      order by VMA within a given section, so we handle this by
@@ -477,31 +916,52 @@ xcoff_link_add_symbols (abfd, info)
   memset ((PTR) reloc_info, 0,
 	  (abfd->section_count + 1) * sizeof (struct reloc_info_struct));
 
-  /* Read in the relocs for each section which has relocs.  */
+  /* Read in the relocs and line numbers for each section.  */
+  linesz = bfd_coff_linesz (abfd);
   for (sub = abfd->sections; sub != NULL; sub = sub->next)
     {
       if ((sub->flags & SEC_RELOC) != 0)
 	{
 	  reloc_info[sub->target_index].relocs =
-	    _bfd_coff_read_internal_relocs (abfd, sub, true,
-					    (bfd_byte *) NULL, false,
-					    (struct internal_reloc *) NULL);
-	  reloc_info[sub->target_index].used =
-	    (boolean *) malloc (sub->reloc_count * sizeof (boolean));
-	  if (reloc_info[sub->target_index].used == NULL)
+	    xcoff_read_internal_relocs (abfd, sub, true, (bfd_byte *) NULL,
+					false, (struct internal_reloc *) NULL);
+	  reloc_info[sub->target_index].csects =
+	    (asection **) malloc (sub->reloc_count * sizeof (asection *));
+	  if (reloc_info[sub->target_index].csects == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_memory);
+	      goto error_return;
+	    }
+	  memset (reloc_info[sub->target_index].csects, 0,
+		  sub->reloc_count * sizeof (asection *));
+	}
+
+      if ((info->strip == strip_none || info->strip == strip_some)
+	  && sub->lineno_count > 0)
+	{
+	  bfd_byte *linenos;
+
+	  linenos = (bfd_byte *) malloc (sub->lineno_count * linesz);
+	  if (linenos == NULL)
 	    {
 	      bfd_set_error (bfd_error_no_memory);
 	      goto error_return;
 	    }
-	  memset (reloc_info[sub->target_index].used, 0,
-		  sub->reloc_count * sizeof (boolean));
+	  reloc_info[sub->target_index].linenos = linenos;
+	  if (bfd_seek (abfd, sub->line_filepos, SEEK_SET) != 0
+	      || (bfd_read (linenos, linesz, sub->lineno_count, abfd)
+		  != linesz * sub->lineno_count))
+	    goto error_return;
 	}
     }
 
+  /* Don't let the linker relocation routines discard the symbols.  */
+  keep_syms = obj_coff_keep_syms (abfd);
+  obj_coff_keep_syms (abfd) = true;
+
   csect = NULL;
   csect_index = 0;
   first_csect = NULL;
-  new_debug = false;
 
   symesz = bfd_coff_symesz (abfd);
   BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
@@ -511,55 +971,38 @@ xcoff_link_add_symbols (abfd, info)
     {
       struct internal_syment sym;
       union internal_auxent aux;
-      PTR name;
+      const char *name;
       char buf[SYMNMLEN + 1];
       int smtyp;
       flagword flags;
       asection *section;
       bfd_vma value;
+      struct xcoff_link_hash_entry *set_toc;
 
       bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
 
-      *debug_index = (unsigned long) -1;
-
-      /* If the name of this symbol is in the .debug section, and it
-         looks like we are going to keep it, add the name to the
-         .debug hash table.  */
-      if (info->hash->creator == abfd->xvec
-	  && sym._n._n_n._n_zeroes == 0
-	  && info->strip != strip_all
-	  && info->strip != strip_debugger
-	  && info->discard != discard_all
-	  && bfd_coff_symname_in_debug (abfd, &sym))
-	{
-	  bfd_size_type indx;
-
-	  /* Add 2 to skip the length.  */
-	  name = debug_contents + sym._n._n_n._n_offset;
-
-	  indx = _bfd_stringtab_add (xcoff_hash_table (info)->debug_strtab,
-				     name, true, true);
-	  if (indx == (bfd_size_type) -1)
-	    goto error_return;
-	  *debug_index = indx;
-	  new_debug = true;
-	}
-
       /* In this pass we are only interested in symbols with csect
          information.  */
       if (sym.n_sclass != C_EXT && sym.n_sclass != C_HIDEXT)
 	{
+	  if (sym.n_sclass == C_FILE && csect != NULL)
+	    {
+	      xcoff_section_data (abfd, csect)->last_symndx =
+		((esym
+		  - (bfd_byte *) obj_coff_external_syms (abfd))
+		 / symesz);
+	      csect = NULL;
+	    }
+
 	  if (csect != NULL)
 	    *csect_cache = csect;
-	  else if (first_csect == NULL)
+	  else if (first_csect == NULL || sym.n_sclass == C_FILE)
 	    *csect_cache = coff_section_from_bfd_index (abfd, sym.n_scnum);
 	  else
 	    *csect_cache = NULL;
 	  esym += (sym.n_numaux + 1) * symesz;
 	  sym_hash += sym.n_numaux + 1;
 	  csect_cache += sym.n_numaux + 1;
-	  if (debug_index != NULL)
-	    debug_index += sym.n_numaux + 1;
 	  continue;
 	}
 
@@ -567,6 +1010,63 @@ xcoff_link_add_symbols (abfd, info)
       if (name == NULL)
 	goto error_return;
 
+      /* If this symbol has line number information attached to it,
+         and we're not stripping it, count the number of entries and
+         add them to the count for this csect.  In the final link pass
+         we are going to attach line number information by symbol,
+         rather than by section, in order to more easily handle
+         garbage collection.  */
+      if ((info->strip == strip_none || info->strip == strip_some)
+	  && sym.n_numaux > 1
+	  && csect != NULL
+	  && ISFCN (sym.n_type))
+	{
+	  union internal_auxent auxlin;
+
+	  bfd_coff_swap_aux_in (abfd, (PTR) (esym + symesz),
+				sym.n_type, sym.n_sclass,
+				0, sym.n_numaux, (PTR) &auxlin);
+	  if (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
+	    {
+	      asection *enclosing;
+	      bfd_size_type linoff;
+
+	      enclosing = xcoff_section_data (abfd, csect)->enclosing;
+	      linoff = (auxlin.x_sym.x_fcnary.x_fcn.x_lnnoptr
+			- enclosing->line_filepos);
+	      if (linoff < enclosing->lineno_count * linesz)
+		{
+		  struct internal_lineno lin;
+		  bfd_byte *linpstart;
+
+		  linpstart = (reloc_info[enclosing->target_index].linenos
+			       + linoff);
+		  bfd_coff_swap_lineno_in (abfd, (PTR) linpstart, (PTR) &lin);
+		  if (lin.l_lnno == 0
+		      && ((bfd_size_type) lin.l_addr.l_symndx
+			  == ((esym
+			       - (bfd_byte *) obj_coff_external_syms (abfd))
+			      / symesz)))
+		    {
+		      bfd_byte *linpend, *linp;
+
+		      linpend = (reloc_info[enclosing->target_index].linenos
+				 + enclosing->lineno_count * linesz);
+		      for (linp = linpstart + linesz;
+			   linp < linpend;
+			   linp += linesz)
+			{
+			  bfd_coff_swap_lineno_in (abfd, (PTR) linp,
+						   (PTR) &lin);
+			  if (lin.l_lnno == 0)
+			    break;
+			}
+		      csect->lineno_count += (linp - linpstart) / linesz;
+		    }
+		}
+	    }
+	}
+
       /* Pick up the csect auxiliary information.  */
 
       if (sym.n_numaux == 0)
@@ -589,6 +1089,7 @@ xcoff_link_add_symbols (abfd, info)
       flags = BSF_GLOBAL;
       section = NULL;
       value = 0;
+      set_toc = NULL;
 
       switch (smtyp)
 	{
@@ -618,6 +1119,14 @@ xcoff_link_add_symbols (abfd, info)
 	case XTY_SD:
 	  /* This is a csect definition.  */
 
+	  if (csect != NULL)
+	    {
+	      xcoff_section_data (abfd, csect)->last_symndx =
+		((esym
+		  - (bfd_byte *) obj_coff_external_syms (abfd))
+		 / symesz);
+	    }
+
 	  csect = NULL;
 	  csect_index = -1;
 
@@ -645,29 +1154,30 @@ xcoff_link_add_symbols (abfd, info)
 	     that we must look through the relocations.  Ick.  */
 	  if (aux.x_csect.x_smclas == XMC_TC
 	      && sym.n_sclass == C_HIDEXT
-	      && aux.x_csect.x_scnlen.l == 4)
+	      && aux.x_csect.x_scnlen.l == 4
+	      && info->hash->creator == abfd->xvec)
 	    {
 	      asection *enclosing;
 	      bfd_size_type relindx;
 	      struct internal_reloc *rel;
-	      boolean *used;
+	      asection **rel_csect;
 
 	      enclosing = coff_section_from_bfd_index (abfd, sym.n_scnum);
 	      if (enclosing == NULL)
-		return false;
+		goto error_return;
 
 	      /* XCOFF requires that relocs be sorted by address, so
                  we could do a binary search here.  FIXME.  */
 	      rel = reloc_info[enclosing->target_index].relocs;
-	      used = reloc_info[enclosing->target_index].used;
+	      rel_csect = reloc_info[enclosing->target_index].csects;
 	      for (relindx = 0;
 		   relindx < enclosing->reloc_count;
-		   relindx++, rel++, used++)
+		   relindx++, rel++, rel_csect++)
 		{
-		  if (! *used
+		  if (*rel_csect == NULL
 		      && rel->r_vaddr == (bfd_vma) sym.n_value
 		      && rel->r_size == 31
-		      && rel->r_type == 0)
+		      && rel->r_type == R_POS)
 		    break;
 		}
 	      if (relindx < enclosing->reloc_count)
@@ -690,38 +1200,35 @@ xcoff_link_add_symbols (abfd, info)
 		      relname = _bfd_coff_internal_syment_name (abfd, &relsym,
 								relbuf);
 		      if (relname == NULL)
-			return false;
+			goto error_return;
 		      copy = (! info->keep_memory
 			      || relsym._n._n_n._n_zeroes != 0
 			      || relsym._n._n_n._n_offset == 0);
 		      h = xcoff_link_hash_lookup (xcoff_hash_table (info),
 						  relname, true, copy, false);
 		      if (h == NULL)
-			return false;
+			goto error_return;
 
 		      /* At this point h->root.type could be
 			 bfd_link_hash_new.  That should be OK, since
 			 we know for sure that we will come across
 			 this symbol as we step through the file.  */
 
-		      /* Stuff h into *sym_hash.  We normally only set
-                         *sym_hash for global variables.  Remembering
-                         it here saves us doing this work again later.  */
+		      /* We store h in *sym_hash for the convenience
+			 of the relocate_section function.  */
 		      *sym_hash = h;
 
-		      if (h->toc)
+		      if (h->toc_section != NULL)
 			{
 			  /* We already have a TOC entry for this
-			     symbol, so we can just ignore this one.
-			     We need to skip the csect, and the reloc
-			     as well.  */
-			  *used = true;
+			     symbol, so we can just ignore this one.  */
+			  *rel_csect = bfd_und_section_ptr;
 			  break;
 			}
 
 		      /* We are about to create a TOC entry for this
 			 symbol.  */
-		      h->toc = true;
+		      set_toc = h;
 		    }
 		}
 	    }
@@ -740,7 +1247,7 @@ xcoff_link_add_symbols (abfd, info)
 	    asection *enclosing;
 	    struct internal_reloc *rel;
 	    bfd_size_type relindx;
-	    boolean *used;
+	    asection **rel_csect;
 
 	    if ((aux.x_csect.x_smclas >=
 		 sizeof csect_name_by_class / sizeof csect_name_by_class[0])
@@ -778,17 +1285,36 @@ xcoff_link_add_symbols (abfd, info)
 	    csect->flags |= SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
 	    csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
 
+	    /* Record the enclosing section in the tdata for this new
+	       section.  */
+	    csect->used_by_bfd =
+	      ((struct coff_section_tdata *)
+	       bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
+	    if (csect->used_by_bfd == NULL)
+	      {
+		bfd_set_error (bfd_error_no_memory);
+		goto error_return;
+	      }
+	    coff_section_data (abfd, csect)->tdata =
+	      bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
+	    if (coff_section_data (abfd, csect)->tdata == NULL)
+	      {
+		bfd_set_error (bfd_error_no_memory);
+		goto error_return;
+	      }
+	    xcoff_section_data (abfd, csect)->enclosing = enclosing;
+
 	    /* XCOFF requires that relocs be sorted by address, so we
                could do a binary search here.  FIXME.  (XCOFF
                unfortunately does not require that symbols be sorted
                by address, or this would be a simple merge).  */
 	    rel = reloc_info[enclosing->target_index].relocs;
-	    used = reloc_info[enclosing->target_index].used;
+	    rel_csect = reloc_info[enclosing->target_index].csects;
 	    for (relindx = 0;
 		 relindx < enclosing->reloc_count;
-		 relindx++, rel++, used++)
+		 relindx++, rel++, rel_csect++)
 	      {
-		if (! *used
+		if (*rel_csect == NULL
 		    && rel->r_vaddr >= csect->vma
 		    && rel->r_vaddr < csect->vma + csect->_raw_size)
 		  {
@@ -798,44 +1324,27 @@ xcoff_link_add_symbols (abfd, info)
 		  }
 	      }
 	    while (relindx < enclosing->reloc_count
-		   && ! *used
+		   && *rel_csect == NULL
 		   && rel->r_vaddr >= csect->vma
 		   && rel->r_vaddr < csect->vma + csect->_raw_size)
 	      {
-		*used = true;
+		*rel_csect = csect;
 		csect->flags |= SEC_RELOC;
 		++csect->reloc_count;
 		++relindx;
 		++rel;
-		++used;
+		++rel_csect;
 	      }
 
 	    /* There are a number of other fields and section flags
 	       which we do not bother to set.  */
 
-	    /* Record the enclosing section in the tdata for this new
-	       section.  */
-	    csect->used_by_bfd =
-	      ((struct coff_section_tdata *)
-	       bfd_alloc (abfd, sizeof (struct coff_section_tdata)));
-	    if (csect->used_by_bfd == NULL)
-	      {
-		bfd_set_error (bfd_error_no_memory);
-		goto error_return;
-	      }
-	    coff_section_data (abfd, csect)->tdata =
-	      bfd_alloc (abfd, sizeof (struct xcoff_section_tdata));
-	    if (coff_section_data (abfd, csect)->tdata == NULL)
-	      {
-		bfd_set_error (bfd_error_no_memory);
-		goto error_return;
-	      }
-	    xcoff_section_data (abfd, csect)->enclosing = enclosing;
-
 	    csect_index = ((esym
 			    - (bfd_byte *) obj_coff_external_syms (abfd))
 			   / symesz);
 
+	    xcoff_section_data (abfd, csect)->first_symndx = csect_index;
+
 	    if (first_csect == NULL)
 	      first_csect = csect;
 
@@ -846,6 +1355,13 @@ xcoff_link_add_symbols (abfd, info)
 		section = csect;
 		value = 0;
 	      }
+
+	    /* If this is a TOC section for a symbol, record it.  */
+	    if (set_toc != NULL)
+	      {
+		set_toc->toc_section = csect;
+		set_toc->toc_offset = 0;
+	      }
 	  }
 	  break;
 
@@ -858,8 +1374,7 @@ xcoff_link_add_symbols (abfd, info)
 	    boolean bad;
 
 	    bad = false;
-	    if (sym.n_sclass != C_EXT
-		|| aux.x_csect.x_scnlen.l < 0
+	    if (aux.x_csect.x_scnlen.l < 0
 		|| (aux.x_csect.x_scnlen.l
 		    >= esym - (bfd_byte *) obj_coff_external_syms (abfd)))
 	      bad = true;
@@ -887,30 +1402,56 @@ xcoff_link_add_symbols (abfd, info)
 	  /* This is an unitialized csect.  We could base the name on
              the storage mapping class, but we don't bother.  If this
              csect is externally visible, it is a common symbol.  */
-	  if (sym.n_sclass == C_EXT)
+
+	  if (csect != NULL)
 	    {
-	      section = bfd_com_section_ptr;
-	      value = aux.x_csect.x_scnlen.l;
+	      xcoff_section_data (abfd, csect)->last_symndx =
+		((esym
+		  - (bfd_byte *) obj_coff_external_syms (abfd))
+		 / symesz);
 	    }
-	  else
+
+	  csect = bfd_make_section_anyway (abfd, ".bss");
+	  if (csect == NULL)
+	    goto error_return;
+	  csect->vma = 0;
+	  csect->_raw_size = aux.x_csect.x_scnlen.l;
+	  csect->flags |= SEC_ALLOC;
+	  csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
+	  /* There are a number of other fields and section flags
+	     which we do not bother to set.  */
+
+	  csect_index = ((esym
+			  - (bfd_byte *) obj_coff_external_syms (abfd))
+			 / symesz);
+
+	  csect->used_by_bfd =
+	    ((struct coff_section_tdata *)
+	     bfd_zalloc (abfd, sizeof (struct coff_section_tdata)));
+	  if (csect->used_by_bfd == NULL)
 	    {
-	      csect = bfd_make_section_anyway (abfd, ".bss");
-	      if (csect == NULL)
-		goto error_return;
-	      csect->vma = 0;
-	      csect->_raw_size = aux.x_csect.x_scnlen.l;
-	      csect->flags |= SEC_ALLOC;
-	      csect->alignment_power = SMTYP_ALIGN (aux.x_csect.x_smtyp);
-	      /* There are a number of other fields and section flags
-                 which we do not bother to set.  */
-
-	      csect_index = ((esym
-			      - (bfd_byte *) obj_coff_external_syms (abfd))
-			     / symesz);
-
-	      if (first_csect == NULL)
-		first_csect = csect;
+	      bfd_set_error (bfd_error_no_memory);
+	      goto error_return;
 	    }
+	  coff_section_data (abfd, csect)->tdata =
+	    bfd_zalloc (abfd, sizeof (struct xcoff_section_tdata));
+	  if (coff_section_data (abfd, csect)->tdata == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_memory);
+	      goto error_return;
+	    }
+	  xcoff_section_data (abfd, csect)->first_symndx = csect_index;
+
+	  if (first_csect == NULL)
+	    first_csect = csect;
+
+	  if (sym.n_sclass == C_EXT)
+	    {
+	      csect->flags |= SEC_IS_COMMON;
+	      section = csect;
+	      value = aux.x_csect.x_scnlen.l;
+	    }
+
 	  break;
 	}
 
@@ -930,6 +1471,36 @@ xcoff_link_add_symbols (abfd, info)
 	      || sym._n._n_n._n_offset == 0)
 	    copy = true;
 
+	  if (info->hash->creator == abfd->xvec)
+	    {
+	      /* If we are statically linking a shared object, it is
+                 OK for symbol redefinitions to occur.  I can't figure
+                 out just what the XCOFF linker is doing, but
+                 something like this is required for -bnso to work.  */
+	      *sym_hash = xcoff_link_hash_lookup (xcoff_hash_table (info),
+						  name, true, copy, false);
+	      if (*sym_hash == NULL)
+		goto error_return;
+	      if (((*sym_hash)->root.type == bfd_link_hash_defined
+		   || (*sym_hash)->root.type == bfd_link_hash_defweak)
+		  && ! bfd_is_und_section (section)
+		  && ! bfd_is_com_section (section))
+		{
+		  if ((abfd->flags & DYNAMIC) != 0)
+		    {
+		      section = bfd_und_section_ptr;
+		      value = 0;
+		    }
+		  else if (((*sym_hash)->root.u.def.section->owner->flags
+			    & DYNAMIC) != 0)
+		    {
+		      (*sym_hash)->root.type = bfd_link_hash_undefined;
+		      (*sym_hash)->root.u.undef.abfd =
+			(*sym_hash)->root.u.def.section->owner;
+		    }
+		}
+	    }
+
 	  if (! (_bfd_generic_link_add_one_symbol
 		 (info, abfd, name, flags, section, value,
 		  (const char *) NULL, copy, false,
@@ -937,7 +1508,18 @@ xcoff_link_add_symbols (abfd, info)
 	    goto error_return;
 
 	  if (info->hash->creator == abfd->xvec)
-	    (*sym_hash)->xcoff = true;
+	    {
+	      int flag;
+
+	      if (smtyp == XTY_ER || smtyp == XTY_CM)
+		flag = XCOFF_REF_REGULAR;
+	      else
+		flag = XCOFF_DEF_REGULAR;
+	      (*sym_hash)->flags |= flag;
+
+	      if ((*sym_hash)->smclas == XMC_UA)
+		(*sym_hash)->smclas = aux.x_csect.x_smclas;
+	    }
 	}
 
       *csect_cache = csect;
@@ -945,42 +1527,28 @@ xcoff_link_add_symbols (abfd, info)
       esym += (sym.n_numaux + 1) * symesz;
       sym_hash += sym.n_numaux + 1;
       csect_cache += sym.n_numaux + 1;
-      if (debug_index != NULL)
-	debug_index += sym.n_numaux + 1;
-    }
-
-  if (new_debug)
-    {
-      /* Update the size of the .debug section we are building.  */
-      if (xcoff_hash_table (info)->debug_section == NULL)
-	{
-	  asection *n;
-
-	  n = bfd_make_section_anyway (abfd, ".debug");
-	  if (n == NULL)
-	    goto error_return;
-	  n->flags |= SEC_HAS_CONTENTS;
-	  /* Note that reading from this section will fail.  */
-	  xcoff_hash_table (info)->debug_section = n;
-	}
-      xcoff_hash_table (info)->debug_section->_raw_size =
-	_bfd_stringtab_size (xcoff_hash_table (info)->debug_strtab);
     }
 
   /* Make sure that we have seen all the relocs.  */
   for (sub = abfd->sections; sub != first_csect; sub = sub->next)
     {
       /* Reset the section size, since the data is now attached to the
-         csects.  */
-      sub->_raw_size = 0;
+	 csects.  Don't reset the size of the .debug section, since we
+	 need to read it below in bfd_xcoff_size_dynamic_sections.  */
+      if (strcmp (bfd_get_section_name (abfd, sub), ".debug") != 0)
+	sub->_raw_size = 0;
 
       if ((sub->flags & SEC_RELOC) != 0)
 	{
 	  bfd_size_type i;
+	  struct internal_reloc *rel;
+	  asection **rel_csect;
 
-	  for (i = 0; i < sub->reloc_count; i++)
+	  rel = reloc_info[sub->target_index].relocs;
+	  rel_csect = reloc_info[sub->target_index].csects;
+	  for (i = 0; i < sub->reloc_count; i++, rel++, rel_csect++)
 	    {
-	      if (! reloc_info[sub->target_index].used[i])
+	      if (*rel_csect == NULL)
 		{
 		  (*_bfd_error_handler)
 		    ("%s: reloc %s:%d not in csect",
@@ -988,50 +1556,1032 @@ xcoff_link_add_symbols (abfd, info)
 		  bfd_set_error (bfd_error_bad_value);
 		  goto error_return;
 		}
+
+	      /* We need to copy all relocs which are not PC relative
+		 and not TOC relative into the .loader section.
+
+		 We also identify all symbols which are called, so
+		 that we can create glue code for calls to functions
+		 imported from dynamic objects.  */
+
+	      if (info->hash->creator == abfd->xvec
+		  && *rel_csect != bfd_und_section_ptr)
+		{
+		  struct xcoff_link_hash_entry *h;
+
+		  switch (rel->r_type)
+		    {
+		    default:
+		      break;
+		    case R_POS:
+		    case R_NEG:
+		    case R_RL:
+		    case R_RLA:
+		      ++xcoff_hash_table (info)->ldrel_count;
+		      ++xcoff_section_data (abfd, *rel_csect)->ldrel_count;
+		      h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
+		      if (h != NULL)
+			h->flags |= XCOFF_LDREL;
+		      break;
+		    case R_BR:
+		    case R_RBR:
+		      h = obj_xcoff_sym_hashes (abfd)[rel->r_symndx];
+		      if (h != NULL)
+			{
+			  h->flags |= XCOFF_CALLED;
+			  /* If the symbol name starts with a period,
+                             it is the code of a function.  If the
+                             symbol is currently undefined, then add
+                             an undefined symbol for the function
+                             descriptor.  This should do no harm,
+                             because any regular object that defines
+                             the function should also define the
+                             function descriptor.  It helps, because
+                             it means that we will identify the
+                             function descriptor with a dynamic object
+                             if a dynamic object defines it.  */
+			  if (h->root.root.string[0] == '.'
+			      && h->descriptor == NULL)
+			    {
+			      struct xcoff_link_hash_entry *hds;
+
+			      hds = (xcoff_link_hash_lookup
+				     (xcoff_hash_table (info),
+				      h->root.root.string + 1, true, false,
+				      true));
+			      if (hds == NULL)
+				goto error_return;
+			      if (hds->root.type == bfd_link_hash_new)
+				{
+				  if (! (_bfd_generic_link_add_one_symbol
+					 (info, abfd, hds->root.root.string,
+					  (flagword) 0, bfd_und_section_ptr,
+					  (bfd_vma) 0, (const char *) NULL,
+					  false, false,
+					  ((struct bfd_link_hash_entry **)
+					   NULL))))
+				    goto error_return;
+				}
+			      h->descriptor = hds;
+			    }
+			}
+		      break;
+		    }
+		}
 	    }
 
-	  free (reloc_info[sub->target_index].used);
-	  reloc_info[sub->target_index].used = NULL;
+	  free (reloc_info[sub->target_index].csects);
+	  reloc_info[sub->target_index].csects = NULL;
 
-	  /* Reset SEC_RELOC and the reloc_count, since the reloc
-             information is now attached to the csects.  */
+	  /* Reset SEC_RELOC, the reloc_count, and the lineno_count,
+	     since the reloc and lineno information is now attached to
+	     the csects.  */
 	  sub->flags &=~ SEC_RELOC;
 	  sub->reloc_count = 0;
+	  sub->lineno_count = 0;
 
 	  /* If we are not keeping memory, free the reloc information.  */
 	  if (! info->keep_memory
 	      && coff_section_data (abfd, sub) != NULL
-	      && coff_section_data (abfd, sub)->relocs != NULL)
+	      && coff_section_data (abfd, sub)->relocs != NULL
+	      && ! coff_section_data (abfd, sub)->keep_relocs)
 	    {
 	      free (coff_section_data (abfd, sub)->relocs);
 	      coff_section_data (abfd, sub)->relocs = NULL;
 	    }
 	}
+
+      /* Free up the line numbers.  FIXME: We could cache these
+         somewhere for the final link, to avoid reading them again.  */
+      if (reloc_info[sub->target_index].linenos != NULL)
+	{
+	  free (reloc_info[sub->target_index].linenos);
+	  reloc_info[sub->target_index].linenos = NULL;
+	}
     }
 
   free (reloc_info);
 
-  if (debug_contents != NULL)
+  obj_coff_keep_syms (abfd) = keep_syms;
+
+  return true;
+
+ error_return:
+  if (reloc_info != NULL)
+    {
+      for (sub = abfd->sections; sub != NULL; sub = sub->next)
+	{
+	  if (reloc_info[sub->target_index].csects != NULL)
+	    free (reloc_info[sub->target_index].csects);
+	  if (reloc_info[sub->target_index].linenos != NULL)
+	    free (reloc_info[sub->target_index].linenos);
+	}
+    free (reloc_info);
+    }
+  obj_coff_keep_syms (abfd) = keep_syms;
+  return false;
+}
+
+#undef N_TMASK
+#undef N_BTSHFT
+
+/* This function is used to add symbols from a dynamic object to the
+   global symbol table.  */
+
+static boolean
+xcoff_link_add_dynamic_symbols (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  bfd_size_type symesz;
+  bfd_byte *esym;
+  bfd_byte *esym_end;
+  struct xcoff_import_file *n;
+  const char *bname;
+  const char *mname;
+  const char *s;
+  unsigned int c;
+  struct xcoff_import_file **pp;
+
+  /* We can only handle a dynamic object if we are generating an XCOFF
+     output file.  */
+  if (info->hash->creator != abfd->xvec)
+    {
+      (*_bfd_error_handler)
+	("%s: XCOFF shared object when not producing XCOFF output",
+	 bfd_get_filename (abfd));
+      bfd_set_error (bfd_error_invalid_operation);
+      return false;
+    }
+
+  /* Remove the sections from this object, so that they do not get
+     included in the link.  */
+  abfd->sections = NULL;
+
+  symesz = bfd_coff_symesz (abfd);
+  esym = (bfd_byte *) obj_coff_external_syms (abfd);
+  esym_end = esym + obj_raw_syment_count (abfd) * symesz;
+  while (esym < esym_end)
+    {
+      struct internal_syment sym;
+
+      bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
+
+      /* I think that every symbol mentioned in a dynamic object must
+	 be defined by that object, perhaps by importing it from
+	 another dynamic object.  All we have to do is look up each
+	 external symbol.  If we have already put it in the hash
+	 table, we simply set a flag indicating that it appears in a
+	 dynamic object.  */
+
+      if (sym.n_sclass == C_EXT)
+	{
+	  const char *name;
+	  char buf[SYMNMLEN + 1];
+	  struct xcoff_link_hash_entry *h;
+
+	  name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
+	  if (name == NULL)
+	    return false;
+
+	  /* Normally we could not xcoff_link_hash_lookup in an add
+             symbols routine, since we might not be using an XCOFF
+             hash table.  However, we verified above that we are using
+             an XCOFF hash table.  */
+	  h = xcoff_link_hash_lookup (xcoff_hash_table (info), name,
+				      false, false, true);
+	  if (h != NULL)
+	    {
+	      h->flags |= XCOFF_REF_DYNAMIC;
+
+	      /* If the symbol is undefined, and the current BFD is
+		 not a dynamic object, change the BFD to this dynamic
+		 object, so that we can get the import file ID
+		 correctly.  */
+	      if (h->root.u.undef.abfd == NULL
+		  || (h->root.u.undef.abfd->flags & DYNAMIC) == 0)
+		h->root.u.undef.abfd = abfd;
+
+	      if (h->smclas == XMC_UA
+		  && sym.n_numaux > 0)
+		{
+		  union internal_auxent aux;
+
+		  bfd_coff_swap_aux_in (abfd,
+					(PTR) (esym + symesz * sym.n_numaux),
+					sym.n_type, sym.n_sclass,
+					sym.n_numaux - 1, sym.n_numaux,
+					(PTR) &aux);
+		  h->smclas = aux.x_csect.x_smclas;
+		}
+	    }
+	}
+
+      esym += (sym.n_numaux + 1) * symesz;
+    }
+
+  /* Record this file in the import files.  */
+
+  n = ((struct xcoff_import_file *)
+       bfd_alloc (abfd, sizeof (struct xcoff_import_file)));
+  if (n == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }
+  n->next = NULL;
+
+  /* For some reason, the path entry in the import file list for a
+     shared object appears to always be empty.  The file name is the
+     base name.  */
+  n->path = "";
+  if (abfd->my_archive == NULL)
+    {
+      bname = bfd_get_filename (abfd);
+      mname = "";
+    }
+  else
+    {
+      bname = bfd_get_filename (abfd->my_archive);
+      mname = bfd_get_filename (abfd);
+    }
+  s = strrchr (bname, '/');
+  if (s != NULL)
+    bname = s + 1;
+  n->file = bname;
+  n->member = mname;
+
+  /* We start c at 1 because the first import file number is reserved
+     for LIBPATH.  */
+  for (pp = &xcoff_hash_table (info)->imports, c = 1;
+       *pp != NULL;
+       pp = &(*pp)->next, ++c)
+    ;
+  *pp = n;
+
+  xcoff_data (abfd)->import_file_id = c;
+
+  return true;
+}
+
+/* Routines that are called after all the input files have been
+   handled, but before the sections are laid out in memory.  */
+
+/* Import a symbol.  */
+
+boolean
+bfd_xcoff_import_symbol (output_bfd, info, harg, val, imppath, impfile,
+			 impmember)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     struct bfd_link_hash_entry *harg;
+     bfd_vma val;
+     const char *imppath;
+     const char *impfile;
+     const char *impmember;
+{
+  struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
+
+  h->flags |= XCOFF_IMPORT;
+
+  if (val != (bfd_vma) -1)
+    {
+      if (h->root.type == bfd_link_hash_defined)
+	{
+	  if (! ((*info->callbacks->multiple_definition)
+		 (info, h->root.root.string, h->root.u.def.section->owner,
+		  h->root.u.def.section, h->root.u.def.value,
+		  output_bfd, bfd_abs_section_ptr, val)))
+	    return false;
+	}
+
+      h->root.type = bfd_link_hash_defined;
+      h->root.u.def.section = bfd_abs_section_ptr;
+      h->root.u.def.value = val;
+    }
+
+  if (h->ldsym == NULL)
+    {
+      h->ldsym = ((struct internal_ldsym *)
+		  bfd_zalloc (output_bfd, sizeof (struct internal_ldsym)));
+      if (h->ldsym == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  return false;
+	}
+    }
+
+  if (imppath == NULL)
+    h->ldsym->l_ifile = (bfd_size_type) -1;
+  else
+    {
+      unsigned int c;
+      struct xcoff_import_file **pp;
+
+      /* We start c at 1 because the first entry in the import list is
+         reserved for the library search path.  */
+      for (pp = &xcoff_hash_table (info)->imports, c = 1;
+	   *pp != NULL;
+	   pp = &(*pp)->next, ++c)
+	{
+	  if (strcmp ((*pp)->path, imppath) == 0
+	      && strcmp ((*pp)->file, impfile) == 0
+	      && strcmp ((*pp)->member, impmember) == 0)
+	    break;
+	}
+
+      if (*pp == NULL)
+	{
+	  struct xcoff_import_file *n;
+
+	  n = ((struct xcoff_import_file *)
+	       bfd_alloc (output_bfd, sizeof (struct xcoff_import_file)));
+	  if (n == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_memory);
+	      return false;
+	    }
+	  n->next = NULL;
+	  n->path = imppath;
+	  n->file = impfile;
+	  n->member = impmember;
+	  *pp = n;
+	}
+
+      h->ldsym->l_ifile = c;
+    }
+
+  return true;
+}
+
+/* Export a symbol.  */
+
+boolean
+bfd_xcoff_export_symbol (output_bfd, info, harg, syscall)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     struct bfd_link_hash_entry *harg;
+     boolean syscall;
+{
+  struct xcoff_link_hash_entry *h = (struct xcoff_link_hash_entry *) harg;
+
+  h->flags |= XCOFF_EXPORT;
+
+  /* FIXME: I'm not at all sure what syscall is supposed to mean, so
+     I'm just going to ignore it until somebody explains it.  */
+
+  return true;
+}
+
+/* This structure is used to pass information through
+   xcoff_link_hash_traverse.  */
+
+struct xcoff_loader_info
+{
+  /* Set if a problem occurred.  */
+  boolean failed;
+  /* Output BFD.  */
+  bfd *output_bfd;
+  /* Link information structure.  */
+  struct bfd_link_info *info;
+  /* Number of ldsym structures.  */
+  size_t ldsym_count;
+  /* Size of string table.  */
+  size_t string_size;
+  /* String table.  */
+  bfd_byte *strings;
+  /* Allocated size of string table.  */
+  size_t string_alc;
+};
+
+/* Build the .loader section.  This is called by the XCOFF linker
+   emulation before_allocation routine.  We must set the size of the
+   .loader section before the linker lays out the output file.
+   LIBPATH is the library path to search for shared objects; this is
+   normally built from the -L arguments passed to the linker.  ENTRY
+   is the name of the entry point symbol.  */
+
+boolean
+bfd_xcoff_size_dynamic_sections (output_bfd, info, libpath, entry,
+				 file_align, maxstack, maxdata, gc,
+				 modtype, textro)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     const char *libpath;
+     const char *entry;
+     unsigned long file_align;
+     unsigned long maxstack;
+     unsigned long maxdata;
+     boolean gc;
+     int modtype;
+     boolean textro;
+{
+  struct xcoff_link_hash_entry *hentry;
+  asection *lsec;
+  struct xcoff_loader_info ldinfo;
+  size_t impsize, impcount;
+  struct xcoff_import_file *fl;
+  struct internal_ldhdr *ldhdr;
+  register char *out;
+  asection *sec;
+  bfd *sub;
+  struct bfd_strtab_hash *debug_strtab;
+  bfd_byte *debug_contents = NULL;
+
+  ldinfo.failed = false;
+  ldinfo.output_bfd = output_bfd;
+  ldinfo.info = info;
+  ldinfo.ldsym_count = 0;
+  ldinfo.string_size = 0;
+  ldinfo.strings = NULL;
+  ldinfo.string_alc = 0;
+
+  xcoff_data (output_bfd)->maxstack = maxstack;
+  xcoff_data (output_bfd)->maxdata = maxdata;
+  xcoff_data (output_bfd)->modtype = modtype;
+
+  xcoff_hash_table (info)->file_align = file_align;
+  xcoff_hash_table (info)->textro = textro;
+
+  hentry = xcoff_link_hash_lookup (xcoff_hash_table (info), entry,
+				   false, false, true);
+  if (hentry != NULL)
+    hentry->flags |= XCOFF_ENTRY;
+
+  /* Garbage collect unused sections.  */
+  if (info->relocateable
+      || ! gc
+      || hentry == NULL
+      || (hentry->root.type != bfd_link_hash_defined
+	  && hentry->root.type != bfd_link_hash_defweak))
+    xcoff_hash_table (info)->gc = false;
+  else
+    {
+      if (! xcoff_mark (info, hentry->root.u.def.section))
+	goto error_return;
+      xcoff_sweep (info);
+      xcoff_hash_table (info)->gc = true;
+    }
+
+  if (info->input_bfds == NULL)
+    {
+      /* I'm not sure what to do in this bizarre case.  */
+      return true;
+    }
+
+  xcoff_link_hash_traverse (xcoff_hash_table (info), xcoff_build_ldsyms,
+			    (PTR) &ldinfo);
+  if (ldinfo.failed)
+    goto error_return;
+
+  /* Work out the size of the import file names.  Each import file ID
+     consists of three null terminated strings: the path, the file
+     name, and the archive member name.  The first entry in the list
+     of names is the path to use to find objects, which the linker has
+     passed in as the libpath argument.  For some reason, the path
+     entry in the other import file names appears to always be empty.  */
+  impsize = strlen (libpath) + 3;
+  impcount = 1;
+  for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
+    {
+      ++impcount;
+      impsize += (strlen (fl->path)
+		  + strlen (fl->file)
+		  + strlen (fl->member)
+		  + 3);
+    }
+
+  /* Set up the .loader section header.  */
+  ldhdr = &xcoff_hash_table (info)->ldhdr;
+  ldhdr->l_version = 1;
+  ldhdr->l_nsyms = ldinfo.ldsym_count;
+  ldhdr->l_nreloc = xcoff_hash_table (info)->ldrel_count;
+  ldhdr->l_istlen = impsize;
+  ldhdr->l_nimpid = impcount;
+  ldhdr->l_impoff = (LDHDRSZ
+		     + ldhdr->l_nsyms * LDSYMSZ
+		     + ldhdr->l_nreloc * LDRELSZ);
+  ldhdr->l_stlen = ldinfo.string_size;
+  ldhdr->l_stoff = ldhdr->l_impoff + impsize;
+
+  /* We now know the final size of the .loader section.  Allocate
+     space for it.  */
+  lsec = xcoff_hash_table (info)->loader_section;
+  lsec->_raw_size = ldhdr->l_stoff + ldhdr->l_stlen;
+  lsec->contents = (bfd_byte *) bfd_zalloc (output_bfd, lsec->_raw_size);
+  if (lsec->contents == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      goto error_return;
+    }
+
+  /* Set up the header.  */
+  xcoff_swap_ldhdr_out (output_bfd, ldhdr,
+			(struct external_ldhdr *) lsec->contents);
+
+  /* Set up the import file names.  */
+  out = (char *) lsec->contents + ldhdr->l_impoff;
+  strcpy (out, libpath);
+  out += strlen (libpath) + 1;
+  *out++ = '\0';
+  *out++ = '\0';
+  for (fl = xcoff_hash_table (info)->imports; fl != NULL; fl = fl->next)
+    {
+      register const char *s;
+
+      s = fl->path;
+      while ((*out++ = *s++) != '\0')
+	;
+      s = fl->file;
+      while ((*out++ = *s++) != '\0')
+	;
+      s = fl->member;
+      while ((*out++ = *s++) != '\0')
+	;
+    }
+
+  BFD_ASSERT ((bfd_size_type) ((bfd_byte *) out - lsec->contents)
+	      == ldhdr->l_stoff);
+
+  /* Set up the symbol string table.  */
+  if (ldinfo.string_size > 0)
+    {
+      memcpy (out, ldinfo.strings, ldinfo.string_size);
+      free (ldinfo.strings);
+      ldinfo.strings = NULL;
+    }
+
+  /* We can't set up the symbol table or the relocs yet, because we
+     don't yet know the final position of the various sections.  The
+     .loader symbols are written out when the corresponding normal
+     symbols are written out in xcoff_link_input_bfd or
+     xcoff_write_global_symbol.  The .loader relocs are written out
+     when the corresponding normal relocs are handled in
+     xcoff_link_input_bfd.  */
+
+  /* Allocate space for the global linkage section and the global toc
+     section.  */
+  sec = xcoff_hash_table (info)->linkage_section;
+  if (sec->_raw_size > 0)
+    {
+      sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
+      if (sec->contents == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  goto error_return;
+	}
+    }
+  sec = xcoff_hash_table (info)->toc_section;
+  if (sec->_raw_size > 0)
     {
+      sec->contents = (bfd_byte *) bfd_zalloc (output_bfd, sec->_raw_size);
+      if (sec->contents == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  goto error_return;
+	}
+    }
+
+  /* Now that we've done garbage collection, figure out the contents
+     of the .debug section.  */
+  debug_strtab = xcoff_hash_table (info)->debug_strtab;
+
+  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+    {
+      asection *subdeb;
+      bfd_size_type symcount;
+      unsigned long *debug_index;
+      asection **csectpp;
+      bfd_byte *esym, *esymend;
+      bfd_size_type symesz;
+
+      if (sub->xvec != info->hash->creator)
+	continue;
+      subdeb = bfd_get_section_by_name (sub, ".debug");
+      if (subdeb == NULL || subdeb->_raw_size == 0)
+	continue;
+
+      if (info->strip == strip_all
+	  || info->strip == strip_debugger
+	  || info->discard == discard_all)
+	{
+	  subdeb->_raw_size = 0;
+	  continue;
+	}
+
+      if (! _bfd_coff_get_external_symbols (sub))
+	goto error_return;
+
+      symcount = obj_raw_syment_count (sub);
+      debug_index = ((unsigned long *)
+		     bfd_zalloc (sub, symcount * sizeof (unsigned long)));
+      if (debug_index == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  goto error_return;
+	}
+      xcoff_data (sub)->debug_indices = debug_index;
+
+      /* Grab the contents of the .debug section.  We use malloc and
+	 copy the neams into the debug stringtab, rather than
+	 bfd_alloc, because I expect that, when linking many files
+	 together, many of the strings will be the same.  Storing the
+	 strings in the hash table should save space in this case.  */
+      debug_contents = (bfd_byte *) malloc (subdeb->_raw_size);
+      if (debug_contents == NULL)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  goto error_return;
+	}
+      if (! bfd_get_section_contents (sub, subdeb, (PTR) debug_contents,
+				      (file_ptr) 0, subdeb->_raw_size))
+	goto error_return;
+
+      csectpp = xcoff_data (sub)->csects;
+
+      symesz = bfd_coff_symesz (sub);
+      esym = (bfd_byte *) obj_coff_external_syms (sub);
+      esymend = esym + symcount * symesz;
+      while (esym < esymend)
+	{
+	  struct internal_syment sym;
+
+	  bfd_coff_swap_sym_in (sub, (PTR) esym, (PTR) &sym);
+
+	  *debug_index = (unsigned long) -1;
+
+	  if (sym._n._n_n._n_zeroes == 0
+	      && *csectpp != NULL
+	      && (! gc
+		  || ((*csectpp)->flags & SEC_MARK) != 0
+		  || *csectpp == bfd_abs_section_ptr)
+	      && bfd_coff_symname_in_debug (sub, &sym))
+	    {
+	      char *name;
+	      bfd_size_type indx;
+
+	      name = (char *) debug_contents + sym._n._n_n._n_offset;
+	      indx = _bfd_stringtab_add (debug_strtab, name, true, true);
+	      if (indx == (bfd_size_type) -1)
+		goto error_return;
+	      *debug_index = indx;
+	    }
+
+	  esym += (sym.n_numaux + 1) * symesz;
+	  csectpp += sym.n_numaux + 1;
+	  debug_index += sym.n_numaux + 1;
+	}
+
       free (debug_contents);
       debug_contents = NULL;
+
+      /* Clear the size of subdeb, so that it is not included directly
+	 in the output file.  */
+      subdeb->_raw_size = 0;
+
+      if (! info->keep_memory)
+	{
+	  if (! _bfd_coff_free_symbols (sub))
+	    goto error_return;
+	}
     }
 
+  xcoff_hash_table (info)->debug_section->_raw_size =
+    _bfd_stringtab_size (debug_strtab);
+
   return true;
 
  error_return:
+  if (ldinfo.strings != NULL)
+    free (ldinfo.strings);
   if (debug_contents != NULL)
     free (debug_contents);
-  if (reloc_info != NULL)
+  return false;
+}
+
+/* The mark phase of garbage collection.  For a given section, mark
+   it, and all the sections which define symbols to which it refers.  */
+
+static boolean
+xcoff_mark (info, sec)
+     struct bfd_link_info *info;
+     asection *sec;
+{
+  if ((sec->flags & SEC_MARK) != 0)
+    return true;
+
+  sec->flags |= SEC_MARK;
+
+  if (sec->owner->xvec == info->hash->creator
+      && coff_section_data (sec->owner, sec) != NULL
+      && xcoff_section_data (sec->owner, sec) != NULL)
     {
-      for (sub = abfd->sections; sub != NULL; sub = sub->next)
+      register struct xcoff_link_hash_entry **hp, **hpend;
+      struct internal_reloc *rel, *relend;
+
+      /* Mark all the symbols in this section.  */
+
+      hp = (obj_xcoff_sym_hashes (sec->owner)
+	    + xcoff_section_data (sec->owner, sec)->first_symndx);
+      hpend = (obj_xcoff_sym_hashes (sec->owner)
+	       + xcoff_section_data (sec->owner, sec)->last_symndx);
+      for (; hp < hpend; hp++)
 	{
-	  if (reloc_info[sub->target_index].used != NULL)
-	    free (reloc_info[sub->target_index].used);
+	  register struct xcoff_link_hash_entry *h;
+
+	  h = *hp;
+	  if (h != NULL
+	      && (h->flags & XCOFF_MARK) == 0)
+	    {
+	      h->flags |= XCOFF_MARK;
+	      if (h->root.type == bfd_link_hash_defined
+		  || h->root.type == bfd_link_hash_defweak)
+		{
+		  asection *hsec;
+
+		  hsec = h->root.u.def.section;
+		  if ((hsec->flags & SEC_MARK) == 0)
+		    {
+		      if (! xcoff_mark (info, hsec))
+			return false;
+		    }
+		}
+
+	      if (h->toc_section != NULL
+		  && (h->toc_section->flags & SEC_MARK) == 0)
+		{
+		  if (! xcoff_mark (info, h->toc_section))
+		    return false;
+		}
+	    }
+	}
+
+      /* Look through the section relocs.  */
+
+      rel = xcoff_read_internal_relocs (sec->owner, sec, true,
+					(bfd_byte *) NULL, false,
+					(struct internal_reloc *) NULL);
+      if (rel == NULL)
+	return false;
+      relend = rel + sec->reloc_count;
+      for (; rel < relend; rel++)
+	{
+	  asection *rsec;
+	  struct xcoff_link_hash_entry *h;
+
+	  if ((unsigned int) rel->r_symndx
+	      > obj_raw_syment_count (sec->owner))
+	    continue;
+
+	  h = obj_xcoff_sym_hashes (sec->owner)[rel->r_symndx];
+	  if (h != NULL
+	      && (h->flags & XCOFF_MARK) == 0)
+	    {
+	      h->flags |= XCOFF_MARK;
+	      if (h->root.type == bfd_link_hash_defined
+		  || h->root.type == bfd_link_hash_defweak)
+		{
+		  asection *hsec;
+
+		  hsec = h->root.u.def.section;
+		  if ((hsec->flags & SEC_MARK) == 0)
+		    {
+		      if (! xcoff_mark (info, hsec))
+			return false;
+		    }
+		}
+
+	      if (h->toc_section != NULL
+		  && (h->toc_section->flags & SEC_MARK) == 0)
+		{
+		  if (! xcoff_mark (info, h->toc_section))
+		    return false;
+		}
+	    }
+
+	  rsec = xcoff_data (sec->owner)->csects[rel->r_symndx];
+	  if (rsec != NULL
+	      && (rsec->flags & SEC_MARK) == 0)
+	    {
+	      if (! xcoff_mark (info, rsec))
+		return false;
+	    }
+	}
+
+      if (! info->keep_memory
+	  && coff_section_data (sec->owner, sec) != NULL
+	  && coff_section_data (sec->owner, sec)->relocs != NULL
+	  && ! coff_section_data (sec->owner, sec)->keep_relocs)
+	{
+	  free (coff_section_data (sec->owner, sec)->relocs);
+	  coff_section_data (sec->owner, sec)->relocs = NULL;
 	}
-    free (reloc_info);
     }
-  return false;
+
+  return true;
+}
+
+/* The sweep phase of garbage collection.  Remove all garbage
+   sections.  */
+
+static void
+xcoff_sweep (info)
+     struct bfd_link_info *info;
+{
+  bfd *sub;
+
+  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+    {
+      asection *o;
+
+      for (o = sub->sections; o != NULL; o = o->next)
+	{
+	  if ((o->flags & SEC_MARK) == 0)
+	    {
+	      /* Keep all sections from non-XCOFF input files.  Keep
+                 special sections.  Keep .debug sections for the
+                 moment.  */
+	      if (sub->xvec != info->hash->creator
+		  || o == xcoff_hash_table (info)->debug_section
+		  || o == xcoff_hash_table (info)->loader_section
+		  || o == xcoff_hash_table (info)->linkage_section
+		  || o == xcoff_hash_table (info)->toc_section
+		  || strcmp (o->name, ".debug") == 0)
+		o->flags |= SEC_MARK;
+	      else
+		{
+		  o->_raw_size = 0;
+		  o->reloc_count = 0;
+		  o->lineno_count = 0;
+		  if (coff_section_data (sub, o) != NULL
+		      && xcoff_section_data (sub, o) != NULL)
+		    xcoff_hash_table (info)->ldrel_count -=
+		      xcoff_section_data (sub, o)->ldrel_count;
+		}
+	    }
+	}
+    }
+}
+
+/* Add a symbol to the .loader symbols, if necessary.  */
+
+static boolean
+xcoff_build_ldsyms (h, p)
+     struct xcoff_link_hash_entry *h;
+     PTR p;
+{
+  struct xcoff_loader_info *ldinfo = (struct xcoff_loader_info *) p;
+  size_t len;
+
+  /* We don't want to garbage collect symbols which are not defined in
+     XCOFF files.  This is a convenient place to mark them.  */
+  if (xcoff_hash_table (ldinfo->info)->gc
+      && (h->flags & XCOFF_MARK) == 0
+      && (h->root.type == bfd_link_hash_defined
+	  || h->root.type == bfd_link_hash_defweak)
+      && (h->root.u.def.section->owner == NULL
+	  || (h->root.u.def.section->owner->xvec
+	      != ldinfo->info->hash->creator)))
+    h->flags |= XCOFF_MARK;
+
+  /* If this symbol is called, and it is defined in a dynamic object,
+     then we need to set up global linkage code for it.  (Unless we
+     did garbage collection and we didn't need this symbol.)  */
+  if ((h->flags & XCOFF_CALLED) != 0
+      && (h->flags & XCOFF_DEF_REGULAR) == 0
+      && (h->flags & XCOFF_REF_DYNAMIC) != 0
+      && (h->root.type == bfd_link_hash_undefined
+	  || h->root.type == bfd_link_hash_undefweak)
+      && h->root.root.string[0] == '.'
+      && (! xcoff_hash_table (ldinfo->info)->gc
+	  || (h->flags & XCOFF_MARK) != 0))
+    {
+      asection *sec;
+      struct xcoff_link_hash_entry *hds;
+
+      sec = xcoff_hash_table (ldinfo->info)->linkage_section;
+      h->root.type = bfd_link_hash_defined;
+      h->root.u.def.section = sec;
+      h->root.u.def.value = sec->_raw_size;
+      h->smclas = XMC_GL;
+      sec->_raw_size += XCOFF_GLINK_SIZE;
+
+      /* The global linkage code requires a TOC entry for the
+         descriptor.  */
+      hds = h->descriptor;
+      BFD_ASSERT ((hds->root.type == bfd_link_hash_undefined
+		   || hds->root.type == bfd_link_hash_undefweak)
+		  && (hds->flags & XCOFF_DEF_REGULAR) == 0
+		  && (hds->flags & XCOFF_REF_DYNAMIC) != 0);
+      hds->flags |= XCOFF_MARK;
+      if (hds->toc_section == NULL)
+	{
+	  hds->toc_section = xcoff_hash_table (ldinfo->info)->toc_section;
+	  hds->toc_offset = hds->toc_section->_raw_size;
+	  hds->toc_section->_raw_size += 4;
+	  ++xcoff_hash_table (ldinfo->info)->ldrel_count;
+	  ++hds->toc_section->reloc_count;
+	  hds->indx = -2;
+	  hds->flags |= XCOFF_SET_TOC | XCOFF_LDREL;
+
+	  /* We need to call xcoff_build_ldsyms recursively here,
+             because we may already have passed hds on the traversal.  */
+	  xcoff_build_ldsyms (hds, p);
+	}
+    }
+
+  /* We need to add a symbol to the .loader section if it is mentioned
+     in a reloc which we are copying to the .loader section and it was
+     not defined, or if it is the entry point.  */
+
+  if (((h->flags & XCOFF_LDREL) == 0
+       || h->root.type == bfd_link_hash_defined
+       || h->root.type == bfd_link_hash_defweak)
+      && (h->flags & XCOFF_ENTRY) == 0)
+    {
+      h->ldsym = NULL;
+      return true;
+    }
+
+  /* We don't need to add this symbol if we did garbage collection and
+     we did not mark this symbol.  */
+  if (xcoff_hash_table (ldinfo->info)->gc
+      && (h->flags & XCOFF_MARK) == 0)
+    {
+      h->ldsym = NULL;
+      return true;
+    }
+
+  /* We may have already processed this symbol due to the recursive
+     call above.  */
+  if ((h->flags & XCOFF_BUILT_LDSYM) != 0)
+    return true;
+
+  /* We need to add this symbol to the .loader symbols.  */
+
+  /* h->ldsym will already have been allocated for an explicitly
+     imported symbol.  */
+  if (h->ldsym == NULL)
+    {
+      h->ldsym = ((struct internal_ldsym *)
+		  bfd_zalloc (ldinfo->output_bfd,
+			      sizeof (struct internal_ldsym)));
+      if (h->ldsym == NULL)
+	{
+	  ldinfo->failed = true;
+	  bfd_set_error (bfd_error_no_memory);
+	  return false;
+	}
+    }
+
+  /* The first 3 symbol table indices are reserved to indicate the
+     sections.  */
+  h->ldindx = ldinfo->ldsym_count + 3;
+
+  ++ldinfo->ldsym_count;
+
+  len = strlen (h->root.root.string);
+  if (len <= SYMNMLEN)
+    strncpy (h->ldsym->_l._l_name, h->root.root.string, SYMNMLEN);
+  else
+    {
+      if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
+	{
+	  size_t newalc;
+	  bfd_byte *newstrings;
+
+	  newalc = ldinfo->string_alc * 2;
+	  if (newalc == 0)
+	    newalc = 32;
+	  while (ldinfo->string_size + len + 3 > newalc)
+	    newalc *= 2;
+
+	  if (ldinfo->strings == NULL)
+	    newstrings = (bfd_byte *) malloc (newalc);
+	  else
+	    newstrings = ((bfd_byte *)
+			  realloc ((PTR) ldinfo->strings, newalc));
+	  if (newstrings == NULL)
+	    {
+	      ldinfo->failed = true;
+	      bfd_set_error (bfd_error_no_memory);
+	      return false;
+	    }
+	  ldinfo->string_alc = newalc;
+	  ldinfo->strings = newstrings;
+	}
+
+      bfd_put_16 (ldinfo->output_bfd, len + 1,
+		  ldinfo->strings + ldinfo->string_size);
+      strcpy (ldinfo->strings + ldinfo->string_size + 2, h->root.root.string);
+      h->ldsym->_l._l_l._l_zeroes = 0;
+      h->ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
+      ldinfo->string_size += len + 3;
+    }
+
+  h->flags |= XCOFF_BUILT_LDSYM;
+
+  return true;
 }
 
 /* Do the final link step.  */
@@ -1073,6 +2623,14 @@ _bfd_xcoff_bfd_final_link (abfd, info)
   finfo.contents = NULL;
   finfo.external_relocs = NULL;
 
+  finfo.ldsym = ((struct external_ldsym *)
+		 (xcoff_hash_table (info)->loader_section->contents
+		  + LDHDRSZ));
+  finfo.ldrel = ((struct external_ldrel *)
+		 (xcoff_hash_table (info)->loader_section->contents
+		  + LDHDRSZ
+		  + xcoff_hash_table (info)->ldhdr.l_nsyms * LDSYMSZ));
+
   xcoff_data (abfd)->coff.link_info = info;
 
   finfo.strtab = _bfd_stringtab_init ();
@@ -1080,8 +2638,103 @@ _bfd_xcoff_bfd_final_link (abfd, info)
     goto error_return;
 
   /* Compute the file positions for all the sections.  */
-  if (! abfd->output_has_begun)
-    bfd_coff_compute_section_file_positions (abfd);
+  if (abfd->output_has_begun)
+    {
+      if (xcoff_hash_table (info)->file_align != 0)
+	abort ();
+    }
+  else
+    {
+      bfd_vma file_align;
+
+      file_align = xcoff_hash_table (info)->file_align;
+      if (file_align != 0)
+	{
+	  boolean saw_contents;
+	  int indx;
+	  asection **op;
+	  file_ptr sofar;
+
+	  /* Insert .pad sections before every section which has
+             contents and is loaded, if it is preceded by some other
+             section which has contents and is loaded.  */
+	  saw_contents = true;
+	  for (op = &abfd->sections; *op != NULL; op = &(*op)->next)
+	    {
+	      (*op)->target_index = indx;
+	      if (strcmp ((*op)->name, ".pad") == 0)
+		saw_contents = false;
+	      else if (((*op)->flags & SEC_HAS_CONTENTS) != 0
+		       && ((*op)->flags & SEC_LOAD) != 0)
+		{
+		  if (! saw_contents)
+		    saw_contents = true;
+		  else
+		    {
+		      asection *n, *hold;
+
+		      hold = *op;
+		      *op = NULL;
+		      n = bfd_make_section_anyway (abfd, ".pad");
+		      BFD_ASSERT (*op == n);
+		      n->next = hold;
+		      n->flags = SEC_HAS_CONTENTS;
+		      n->alignment_power = 0;
+		      saw_contents = false;
+		    }
+		}
+	    }
+
+	  /* Reset the section indices after inserting the new
+             sections.  */
+	  indx = 0;
+	  for (o = abfd->sections; o != NULL; o = o->next)
+	    {
+	      ++indx;
+	      o->target_index = indx;
+	    }
+	  BFD_ASSERT ((unsigned int) indx == abfd->section_count);
+
+	  /* Work out appropriate sizes for the .pad sections to force
+             each section to land on a page boundary.  This bit of
+             code knows what compute_section_file_positions is going
+             to do.  */
+	  sofar = bfd_coff_filhsz (abfd);
+	  if ((abfd->flags & EXEC_P) != 0)
+	    sofar += bfd_coff_aoutsz (abfd);
+	  else
+	    {
+	      /* FIXME.  */
+	      sofar += 28;
+	    }
+	  sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
+
+	  for (o = abfd->sections; o != NULL; o = o->next)
+	    {
+	      if (strcmp (o->name, ".pad") == 0)
+		{
+		  bfd_vma pageoff;
+
+		  BFD_ASSERT (o->_raw_size == 0);
+		  pageoff = sofar & (file_align - 1);
+		  if (pageoff != 0)
+		    {
+		      o->_raw_size = file_align - pageoff;
+		      sofar += file_align - pageoff;
+		      o->flags |= SEC_HAS_CONTENTS;
+		    }
+		}
+	      else
+		{
+		  if ((o->flags & SEC_HAS_CONTENTS) != 0)
+		    sofar += BFD_ALIGN (o->_raw_size,
+					1 << o->alignment_power);
+		}
+	    }
+	}
+
+      bfd_coff_compute_section_file_positions (abfd);
+    }
 
   /* Count the line numbers and relocation entries required for the
      output file.  Set the file positions for the relocs.  */
@@ -1246,13 +2899,6 @@ _bfd_xcoff_bfd_final_link (abfd, info)
   obj_raw_syment_count (abfd) = 0;
   xcoff_data (abfd)->toc = (bfd_vma) -1;
 
-  /* Write out all the global symbols which do not come from XCOFF
-     input files.  In COFF these must come at the end, but in XCOFF it
-     doesn't seem to matter.  */
-  xcoff_link_hash_traverse (xcoff_hash_table (info),
-			    xcoff_write_global_symbol,
-			    (PTR) &finfo);
-
   /* We now know the position of everything in the file, except that
      we don't know the size of the symbol table and therefore we don't
      know where the string table starts.  We just build the string
@@ -1330,6 +2976,12 @@ _bfd_xcoff_bfd_final_link (abfd, info)
 	goto error_return;
     }
 
+  /* Write out all the global symbols which do not come from XCOFF
+     input files.  */
+  xcoff_link_hash_traverse (xcoff_hash_table (info),
+			    xcoff_write_global_symbol,
+			    (PTR) &finfo);
+
   if (finfo.outsyms != NULL)
     {
       free (finfo.outsyms);
@@ -1356,19 +3008,9 @@ _bfd_xcoff_bfd_final_link (abfd, info)
       if (o->reloc_count == 0)
 	continue;
 
-      /* XCOFF requires that the relocs be sorted by address.  We tend
-         to produce them in the order in which their containing csects
-         appear in the symbol table, which is not necessarily by
-         address.  So we sort them here.  There may be a better way to
-         do this.  */
-      qsort ((PTR) finfo.section_info[o->target_index].relocs,
-	     o->reloc_count, sizeof (struct internal_reloc),
-	     xcoff_sort_relocs);
-
       irel = finfo.section_info[o->target_index].relocs;
       irelend = irel + o->reloc_count;
       rel_hash = finfo.section_info[o->target_index].rel_hashes;
-      erel = external_relocs;
       for (; irel < irelend; irel++, rel_hash++, erel += relsz)
 	{
 	  if (*rel_hash != NULL)
@@ -1376,16 +3018,30 @@ _bfd_xcoff_bfd_final_link (abfd, info)
 	      if ((*rel_hash)->indx < 0)
 		{
 		  if (! ((*info->callbacks->unattached_reloc)
-			 (info, (*rel_hash)->root.root.string, abfd, o,
-			  irel->r_vaddr)))
+			 (info, (*rel_hash)->root.root.string,
+			  (bfd *) NULL, o, irel->r_vaddr)))
 		    goto error_return;
 		  (*rel_hash)->indx = 0;
 		}
 	      irel->r_symndx = (*rel_hash)->indx;
 	    }
-	  bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
 	}
 
+      /* XCOFF requires that the relocs be sorted by address.  We tend
+         to produce them in the order in which their containing csects
+         appear in the symbol table, which is not necessarily by
+         address.  So we sort them here.  There may be a better way to
+         do this.  */
+      qsort ((PTR) finfo.section_info[o->target_index].relocs,
+	     o->reloc_count, sizeof (struct internal_reloc),
+	     xcoff_sort_relocs);
+
+      irel = finfo.section_info[o->target_index].relocs;
+      irelend = irel + o->reloc_count;
+      erel = external_relocs;
+      for (; irel < irelend; irel++, rel_hash++, erel += relsz)
+	bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
+
       if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
 	  || bfd_write ((PTR) external_relocs, relsz, o->reloc_count,
 			abfd) != relsz * o->reloc_count)
@@ -1414,6 +3070,28 @@ _bfd_xcoff_bfd_final_link (abfd, info)
       finfo.section_info = NULL;
     }
 
+  /* Write out the loader section contents.  */
+  BFD_ASSERT ((bfd_byte *) finfo.ldrel
+	      == (xcoff_hash_table (info)->loader_section->contents
+		  + xcoff_hash_table (info)->ldhdr.l_impoff));
+  o = xcoff_hash_table (info)->loader_section;
+  if (! bfd_set_section_contents (abfd, o->output_section,
+				  o->contents, o->output_offset,
+				  o->_raw_size))
+    goto error_return;
+
+  /* Write out the global linkage section and the toc section.  */
+  o = xcoff_hash_table (info)->linkage_section;
+  if (o->_raw_size > 0
+      && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
+				     o->output_offset, o->_raw_size))
+    goto error_return;
+  o = xcoff_hash_table (info)->toc_section;
+  if (o->_raw_size > 0
+      && ! bfd_set_section_contents (abfd, o->output_section, o->contents,
+				     o->output_offset, o->_raw_size))
+    goto error_return;
+
   /* Write out the string table.  */
   if (bfd_seek (abfd,
 		(obj_sym_filepos (abfd)
@@ -1515,6 +3193,11 @@ xcoff_link_input_bfd (finfo, input_bfd)
   boolean keep_syms;
   asection *o;
 
+  /* We can just skip DYNAMIC files, unless this is a static link.  */
+  if ((input_bfd->flags & DYNAMIC) != 0
+      && ! finfo->info->static_link)
+    return true;
+
   /* Move all the symbols to the output file.  */
 
   output_bfd = finfo->output_bfd;
@@ -1582,6 +3265,87 @@ xcoff_link_input_bfd (finfo, input_bfd)
 	 the symbol.  */
       isym = *isymp;
 
+      /* If this symbol is in the .loader section, swap out the
+         .loader symbol information.  If this is an external symbol
+         reference to a defined symbol, though, then wait until we get
+         to the definition.  */
+      if (isym.n_sclass == C_EXT
+	  && *sym_hash != NULL
+	  && (*sym_hash)->ldsym != NULL
+	  && (smtyp != XTY_ER
+	      || (*sym_hash)->root.type == bfd_link_hash_undefined))
+	{
+	  struct xcoff_link_hash_entry *h;
+	  struct internal_ldsym *ldsym;
+
+	  h = *sym_hash;
+	  ldsym = h->ldsym;
+	  if (isym.n_scnum > 0)
+	    {
+	      ldsym->l_scnum = (*csectpp)->output_section->target_index;
+	      ldsym->l_value = (isym.n_value
+				+ (*csectpp)->output_section->vma
+				+ (*csectpp)->output_offset
+				- (*csectpp)->vma);
+	    }
+	  else
+	    {
+	      ldsym->l_scnum = isym.n_scnum;
+	      ldsym->l_value = isym.n_value;
+	    }
+
+	  ldsym->l_smtype = smtyp;
+	  if (((h->flags & XCOFF_DEF_REGULAR) == 0
+	       && (h->flags & XCOFF_REF_DYNAMIC) != 0)
+	      || (h->flags & XCOFF_IMPORT) != 0)
+	    ldsym->l_smtype |= L_IMPORT;
+	  if (((h->flags & XCOFF_DEF_REGULAR) != 0
+	       && (h->flags & XCOFF_REF_DYNAMIC) != 0)
+	      || (h->flags & XCOFF_EXPORT) != 0)
+	    ldsym->l_smtype |= L_EXPORT;
+	  if ((h->flags & XCOFF_ENTRY) != 0)
+	    ldsym->l_smtype |= L_ENTRY;
+
+	  ldsym->l_smclas = aux.x_csect.x_smclas;
+
+	  if (ldsym->l_ifile == (bfd_size_type) -1)
+	    ldsym->l_ifile = 0;
+	  else if (ldsym->l_ifile == 0)
+	    {
+	      if ((ldsym->l_smtype & L_IMPORT) == 0)
+		ldsym->l_ifile = 0;
+	      else
+		{
+		  bfd *impbfd;
+
+		  if (h->root.type == bfd_link_hash_defined
+		      || h->root.type == bfd_link_hash_defweak)
+		    impbfd = h->root.u.def.section->owner;
+		  else if (h->root.type == bfd_link_hash_undefined
+			   || h->root.type == bfd_link_hash_undefweak)
+		    impbfd = h->root.u.undef.abfd;
+		  else
+		    impbfd = NULL;
+
+		  if (impbfd == NULL)
+		    ldsym->l_ifile = 0;
+		  else
+		    {
+		      BFD_ASSERT (impbfd->xvec == finfo->output_bfd->xvec);
+		      ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
+		    }
+		}
+	    }
+
+	  ldsym->l_parm = 0;
+
+	  BFD_ASSERT (h->ldindx >= 0);
+	  BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
+	  xcoff_swap_ldsym_out (finfo->output_bfd, ldsym,
+				finfo->ldsym + h->ldindx - 3);
+	  h->ldsym = NULL;
+	}
+
       *indexp = -1;
 
       skip = false;
@@ -1592,6 +3356,14 @@ xcoff_link_input_bfd (finfo, input_bfd)
       if (*csectpp == NULL)
 	skip = true;
 
+      /* If we garbage collected this csect, we want to skip this
+         symbol.  */
+      if (! skip
+	  && xcoff_hash_table (finfo->info)->gc
+	  && ((*csectpp)->flags & SEC_MARK) == 0
+	  && *csectpp != bfd_abs_section_ptr)
+	skip = true;
+
       /* An XCOFF linker always skips C_STAT symbols.  */
       if (! skip
 	  && isymp->n_sclass == C_STAT)
@@ -1628,6 +3400,14 @@ xcoff_link_input_bfd (finfo, input_bfd)
 	  && (*sym_hash)->root.type != bfd_link_hash_undefined)
 	skip = true;
 
+      /* We can skip common symbols if they got defined somewhere
+         else.  */
+      if (! skip
+	  && isym.n_sclass == C_EXT
+	  && smtyp == XTY_CM
+	  && ((*sym_hash)->flags & XCOFF_DEF_REGULAR) != 0)
+	skip = true;
+
       /* Skip local symbols if we are discarding them.  */
       if (! skip
 	  && finfo->info->discard == discard_all
@@ -1673,11 +3453,9 @@ xcoff_link_input_bfd (finfo, input_bfd)
 	}
 
       /* On the other hand, we can't skip global symbols which have
-         relocs against them.  FIXME: This won't always work, because
-         we're not always outputting the global symbols at the end, as
-         we do for COFF.  */
+         relocs against them.  */
       if (skip
-	  && *sym_hash != NULL
+	  && isym.n_sclass == C_EXT
 	  && (*sym_hash)->indx == -2
 	  && finfo->info->strip != strip_all)
 	skip = false;
@@ -1829,6 +3607,7 @@ xcoff_link_input_bfd (finfo, input_bfd)
   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
   isymp = finfo->internal_syms;
   indexp = finfo->sym_indices;
+  csectpp = xcoff_data (input_bfd)->csects;
   outsym = finfo->outsyms;
   while (esym < esym_end)
     {
@@ -1948,132 +3727,108 @@ xcoff_link_input_bfd (finfo, input_bfd)
 		    }
 		}
 
-	      bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
-				     isymp->n_sclass, i, isymp->n_numaux,
-				     (PTR) outsym);
-	      outsym += osymesz;
-	      esym += isymesz;
-	    }
-	}
-
-      indexp += add;
-      isymp += add;
-    }
-
-  /* Relocate the line numbers, unless we are stripping them.  */
-  if (finfo->info->strip == strip_none
-      || finfo->info->strip == strip_some)
-    {
-      for (o = input_bfd->sections; o != NULL; o = o->next)
-	{
-	  bfd_vma offset;
-	  bfd_byte *eline;
-	  bfd_byte *elineend;
-
-	  /* FIXME: If SEC_HAS_CONTENTS is not set for the section,
-	     then build_link_order in ldwrite.c will not have created
-	     a link order, which means that we will not have seen this
-	     input section in _bfd_xcoff_final_link, which means that
-	     we will not have allocated space for the line numbers of
-	     this section.  I don't think line numbers can be
-	     meaningful for a section which does not have
-	     SEC_HAS_CONTENTS set, but, if they do, this must be
-	     changed.  */
-	  if (o->lineno_count == 0
-	      || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
-	    continue;
-
-	  if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
-	      || bfd_read (finfo->linenos, linesz, o->lineno_count,
-			   input_bfd) != linesz * o->lineno_count)
-	    return false;
-
-	  offset = o->output_section->vma + o->output_offset - o->vma;
-	  eline = finfo->linenos;
-	  elineend = eline + linesz * o->lineno_count;
-	  for (; eline < elineend; eline += linesz)
-	    {
-	      struct internal_lineno iline;
-
-	      bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline);
-
-	      if (iline.l_lnno != 0)
-		iline.l_addr.l_paddr += offset;
-	      else if (iline.l_addr.l_symndx >= 0
-		       && ((unsigned long) iline.l_addr.l_symndx
-			   < obj_raw_syment_count (input_bfd)))
+	      /* Copy over the line numbers, unless we are stripping
+		 them.  We do this on a symbol by symbol basis in
+		 order to more easily handle garbage collection.  */
+	      if ((isymp->n_sclass == C_EXT
+		   || isymp->n_sclass == C_HIDEXT)
+		  && i == 0
+		  && isymp->n_numaux > 1
+		  && ISFCN (isymp->n_type)
+		  && aux.x_sym.x_fcnary.x_fcn.x_lnnoptr != 0)
 		{
-		  long indx;
-
-		  indx = finfo->sym_indices[iline.l_addr.l_symndx];
-
-		  if (indx < 0)
-		    {
-		      /* These line numbers are attached to a symbol
-			 which we are stripping.  We should really
-			 just discard the line numbers, but that would
-			 be a pain because we have already counted
-			 them.  */
-		      indx = 0;
-		    }
+		  if (finfo->info->strip != strip_none
+		      && finfo->info->strip != strip_some)
+		    aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
 		  else
 		    {
-		      struct internal_syment is;
-		      union internal_auxent ia;
-
-		      /* Fix up the lnnoptr field in the aux entry of
-			 the symbol.  It turns out that we can't do
-			 this when we modify the symbol aux entries,
-			 because gas sometimes screws up the lnnoptr
-			 field and makes it an offset from the start
-			 of the line numbers rather than an absolute
-			 file index.  */
-		      bfd_coff_swap_sym_in (output_bfd,
-					    (PTR) (finfo->outsyms
-						   + ((indx - syment_base)
-						      * osymesz)),
-					    (PTR) &is);
-		      if ((ISFCN (is.n_type)
-			   || is.n_sclass == C_BLOCK)
-			  && ((is.n_sclass == C_EXT
-			       || is.n_sclass == C_HIDEXT)
-			      ? is.n_numaux >= 2
-			      : is.n_numaux >= 1))
+		      asection *enclosing;
+		      bfd_size_type linoff;
+		      struct internal_lineno lin;
+
+		      o = *csectpp;
+		      enclosing = xcoff_section_data (abfd, o)->enclosing;
+		      linoff = (aux.x_sym.x_fcnary.x_fcn.x_lnnoptr
+				- enclosing->line_filepos);
+
+		      if (bfd_seek (input_bfd,
+				    enclosing->line_filepos + linoff,
+				    SEEK_SET != 0)
+			  || (bfd_read (finfo->linenos, linesz,
+					o->lineno_count, input_bfd)
+			      != linesz * o->lineno_count))
+			return false;
+
+		      bfd_coff_swap_lineno_in (input_bfd,
+					       (PTR) finfo->linenos,
+					       (PTR) &lin);
+		      if (lin.l_lnno != 0
+			  || ((bfd_size_type) lin.l_addr.l_symndx
+			      != ((esym
+				   - isymesz
+				   - ((bfd_byte *)
+				      obj_coff_external_syms (input_bfd)))
+				  / isymesz)))
+			aux.x_sym.x_fcnary.x_fcn.x_lnnoptr = 0;
+		      else
 			{
-			  PTR auxptr;
-
-			  auxptr = (PTR) (finfo->outsyms
-					  + ((indx - syment_base + 1)
-					     * osymesz));
-			  bfd_coff_swap_aux_in (output_bfd, auxptr,
-						is.n_type, is.n_sclass,
-						0, is.n_numaux, (PTR) &ia);
-			  ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
+			  bfd_byte *linpend, *linp;
+			  bfd_vma offset;
+			  bfd_size_type count;
+
+			  lin.l_addr.l_symndx = *indexp;
+			  bfd_coff_swap_lineno_out (output_bfd, (PTR) &lin,
+						    (PTR) finfo->linenos);
+
+			  linpend = (finfo->linenos
+				     + o->lineno_count * linesz);
+			  offset = (o->output_section->vma
+				    + o->output_offset
+				    - o->vma);
+			  for (linp = finfo->linenos + linesz;
+			       linp < linpend;
+			       linp += linesz)
+			    {
+			      bfd_coff_swap_lineno_in (input_bfd, (PTR) linp,
+						       (PTR) &lin);
+			      if (lin.l_lnno == 0)
+				break;
+			      lin.l_addr.l_paddr += offset;
+			      bfd_coff_swap_lineno_out (output_bfd,
+							(PTR) &lin,
+							(PTR) linp);
+			    }
+
+			  count = (linp - finfo->linenos) / linesz;
+
+			  aux.x_sym.x_fcnary.x_fcn.x_lnnoptr =
 			    (o->output_section->line_filepos
-			     + o->output_section->lineno_count * linesz
-			     + eline - finfo->linenos);
-			  bfd_coff_swap_aux_out (output_bfd, (PTR) &ia,
-						 is.n_type, is.n_sclass, 0,
-						 is.n_numaux, auxptr);
+			     + o->output_section->lineno_count * linesz);
+
+			  if (bfd_seek (output_bfd,
+					aux.x_sym.x_fcnary.x_fcn.x_lnnoptr,
+					SEEK_SET) != 0
+			      || (bfd_write (finfo->linenos, linesz, count,
+					     output_bfd)
+				  != linesz * count))
+			    return false;
+
+			  o->output_section->lineno_count += count;
 			}
 		    }
-
-		  iline.l_addr.l_symndx = indx;
 		}
 
-	      bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline, (PTR) eline);
+	      bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, isymp->n_type,
+				     isymp->n_sclass, i, isymp->n_numaux,
+				     (PTR) outsym);
+	      outsym += osymesz;
+	      esym += isymesz;
 	    }
-
-	  if (bfd_seek (output_bfd,
-			(o->output_section->line_filepos
-			 + o->output_section->lineno_count * linesz),
-			SEEK_SET) != 0
-	      || bfd_write (finfo->linenos, linesz, o->lineno_count,
-			    output_bfd) != linesz * o->lineno_count)
-	    return false;
-
-	  o->output_section->lineno_count += o->lineno_count;
 	}
+
+      indexp += add;
+      isymp += add;
+      csectpp += add;
     }
 
   /* If we swapped out a C_FILE symbol, guess that the next C_FILE
@@ -2118,7 +3873,8 @@ xcoff_link_input_bfd (finfo, input_bfd)
       bfd_byte *contents;
 
       if ((o->flags & SEC_HAS_CONTENTS) == 0
-	  || o->_raw_size == 0)
+	  || o->_raw_size == 0
+	  || (o->flags & SEC_IN_MEMORY) != 0)
 	continue;
 
       /* We have set filepos correctly for the sections we created to
@@ -2142,12 +3898,11 @@ xcoff_link_input_bfd (finfo, input_bfd)
 	  bfd_vma offset;
 	  struct internal_reloc *irelend;
 	  struct xcoff_link_hash_entry **rel_hash;
+	  long r_symndx;
 
-	  /* Read in the relocs.  We have set rel_filepos correctly
-             for the sections we created to represent csects, so this
-             should work.  */
+	  /* Read in the relocs.  */
 	  target_index = o->output_section->target_index;
-	  internal_relocs = (_bfd_coff_read_internal_relocs
+	  internal_relocs = (xcoff_read_internal_relocs
 			     (input_bfd, o, false, finfo->external_relocs,
 			      true,
 			      (finfo->section_info[target_index].relocs
@@ -2172,7 +3927,8 @@ xcoff_link_input_bfd (finfo, input_bfd)
 		      + o->output_section->reloc_count);
 	  for (; irel < irelend; irel++, rel_hash++)
 	    {
-	      struct xcoff_link_hash_entry *h;
+	      struct xcoff_link_hash_entry *h = NULL;
+	      struct internal_ldrel ldrel;
 
 	      *rel_hash = NULL;
 
@@ -2180,85 +3936,158 @@ xcoff_link_input_bfd (finfo, input_bfd)
 
 	      irel->r_vaddr += offset;
 
-	      if (irel->r_symndx == -1)
-		continue;
+	      r_symndx = irel->r_symndx;
 
-	      h = obj_xcoff_sym_hashes (input_bfd)[irel->r_symndx];
-	      if (h != NULL)
+	      if (r_symndx != -1)
 		{
-		  /* This is a global symbol.  */
-		  if (h->indx >= 0)
-		    irel->r_symndx = h->indx;
+		  h = obj_xcoff_sym_hashes (input_bfd)[r_symndx];
+		  if (h != NULL)
+		    {
+		      /* This is a global symbol.  */
+		      if (h->indx >= 0)
+			irel->r_symndx = h->indx;
+		      else
+			{
+			  /* This symbol is being written at the end
+			     of the file, and we do not yet know the
+			     symbol index.  We save the pointer to the
+			     hash table entry in the rel_hash list.
+			     We set the indx field to -2 to indicate
+			     that this symbol must not be stripped.  */
+			  *rel_hash = h;
+			  h->indx = -2;
+			}
+		    }
 		  else
 		    {
-		      /* This symbol is being written at the end of
-			 the file, and we do not yet know the symbol
-			 index.  We save the pointer to the hash table
-			 entry in the rel_hash list.  We set the indx
-			 field to -2 to indicate that this symbol must
-			 not be stripped.  */
-		      *rel_hash = h;
-		      h->indx = -2;
+		      long indx;
+
+		      indx = finfo->sym_indices[r_symndx];
+
+		      if (indx == -1)
+			{
+			  struct internal_syment *is;
+
+			  /* Relocations against a TC0 TOC anchor are
+			     automatically transformed to be against
+			     the TOC anchor in the output file.  */
+			  is = finfo->internal_syms + r_symndx;
+			  if (is->n_sclass == C_HIDEXT
+			      && is->n_numaux > 0)
+			    {
+			      PTR auxptr;
+			      union internal_auxent aux;
+
+			      auxptr = ((PTR)
+					(((bfd_byte *)
+					  obj_coff_external_syms (input_bfd))
+					 + ((r_symndx + is->n_numaux)
+					    * isymesz)));
+			      bfd_coff_swap_aux_in (input_bfd, auxptr,
+						    is->n_type, is->n_sclass,
+						    is->n_numaux - 1,
+						    is->n_numaux,
+						    (PTR) &aux);
+			      if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
+				  && aux.x_csect.x_smclas == XMC_TC0)
+				indx = finfo->toc_symindx;
+			    }
+			}
+
+		      if (indx != -1)
+			irel->r_symndx = indx;
+		      else
+			{
+			  struct internal_syment *is;
+			  const char *name;
+			  char buf[SYMNMLEN + 1];
+
+			  /* This reloc is against a symbol we are
+			     stripping.  It would be possible to handle
+			     this case, but I don't think it's worth it.  */
+			  is = finfo->internal_syms + r_symndx;
+
+			  name = (_bfd_coff_internal_syment_name
+				  (input_bfd, is, buf));
+			  if (name == NULL)
+			    return false;
+
+			  if (! ((*finfo->info->callbacks->unattached_reloc)
+				 (finfo->info, name, input_bfd, o,
+				  irel->r_vaddr)))
+			    return false;
+			}
 		    }
 		}
-	      else
+
+	      switch (irel->r_type)
 		{
-		  long indx;
+		default:
+		  break;
+		case R_POS:
+		case R_NEG:
+		case R_RL:
+		case R_RLA:
+		  /* This reloc needs to be copied into the .loader
+		     section.  */
+		  ldrel.l_vaddr = irel->r_vaddr;
+		  if (r_symndx == -1)
+		    ldrel.l_symndx = -1;
+		  else if (h == NULL)
+		    {
+		      asection *sec;
 
-		  indx = finfo->sym_indices[irel->r_symndx];
+		      sec = xcoff_data (input_bfd)->csects[r_symndx];
+		      if ((sec->flags & SEC_CODE) != 0)
+			ldrel.l_symndx = 0;
+		      else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
+			ldrel.l_symndx = 1;
+		      else
+			ldrel.l_symndx = 2;
+		    }
+		  else if (h->root.type == bfd_link_hash_defined
+			   || h->root.type == bfd_link_hash_defweak)
+		    {
+		      asection *sec;
 
-		  if (indx == -1)
+		      sec = h->root.u.def.section->output_section;
+		      if ((sec->flags & SEC_CODE) != 0)
+			ldrel.l_symndx = 0;
+		      else if ((sec->flags & SEC_HAS_CONTENTS) != 0)
+			ldrel.l_symndx = 1;
+		      else
+			ldrel.l_symndx = 2;
+		    }
+		  else
 		    {
-		      struct internal_syment *is;
-
-		      /* Relocations against a TC0 TOC anchor are
-                         automatically transformed to be against the
-                         TOC anchor in the output file.  */
-		      is = finfo->internal_syms + irel->r_symndx;
-		      if (is->n_sclass == C_HIDEXT
-			  && is->n_numaux > 0)
+		      if (h->ldindx < 0)
 			{
-			  PTR auxptr;
-			  union internal_auxent aux;
-
-			  auxptr = (PTR) (((bfd_byte *)
-					   obj_coff_external_syms (input_bfd))
-					  + ((irel->r_symndx + is->n_numaux)
-					     * isymesz));
-			  bfd_coff_swap_aux_in (input_bfd, auxptr,
-						is->n_type, is->n_sclass,
-						is->n_numaux - 1,
-						is->n_numaux,
-						(PTR) &aux);
-			  if (SMTYP_SMTYP (aux.x_csect.x_smtyp) == XTY_SD
-			      && aux.x_csect.x_smclas == XMC_TC0)
-			    indx = finfo->toc_symindx;
+			  (*_bfd_error_handler)
+			    ("%s: `%s' in loader reloc but not loader sym",
+			     bfd_get_filename (input_bfd),
+			     h->root.root.string);
+			  bfd_set_error (bfd_error_bad_value);
+			  return false;
 			}
+		      ldrel.l_symndx = h->ldindx;
 		    }
-
-		  if (indx != -1)
-		    irel->r_symndx = indx;
-		  else
+		  ldrel.l_rtype = (irel->r_size << 8) | irel->r_type;
+		  ldrel.l_rsecnm = o->output_section->target_index;
+		  if (xcoff_hash_table (finfo->info)->textro
+		      && (o->output_section->flags & SEC_CODE) != 0)
 		    {
-		      struct internal_syment *is;
-		      const char *name;
-		      char buf[SYMNMLEN + 1];
-
-		      /* This reloc is against a symbol we are
-			 stripping.  It would be possible to handle
-			 this case, but I don't think it's worth it.  */
-		      is = finfo->internal_syms + irel->r_symndx;
-
-		      name = (_bfd_coff_internal_syment_name
-			      (input_bfd, is, buf));
-		      if (name == NULL)
-			return false;
-
-		      if (! ((*finfo->info->callbacks->unattached_reloc)
-			     (finfo->info, name, input_bfd, o,
-			      irel->r_vaddr)))
-			return false;
+		      (*_bfd_error_handler)
+			("%s: loader reloc in read-only section %s",
+			 bfd_get_filename (input_bfd),
+			 bfd_get_section_name (finfo->output_bfd,
+					       o->output_section));
+		      bfd_set_error (bfd_error_invalid_operation);
+		      return false;
 		    }
+		  xcoff_swap_ldrel_out (output_bfd, &ldrel,
+					finfo->ldrel);
+		  BFD_ASSERT (sizeof (struct external_ldrel) == LDRELSZ);
+		  ++finfo->ldrel;
 		}
 	    }
 
@@ -2285,6 +4114,9 @@ xcoff_link_input_bfd (finfo, input_bfd)
   return true;
 }
 
+#undef N_TMASK
+#undef N_BTSHFT
+
 /* Write out a non-XCOFF global symbol.  */
 
 static boolean
@@ -2298,13 +4130,158 @@ xcoff_write_global_symbol (h, p)
   struct internal_syment isym;
   union internal_auxent aux;
 
-  /* XCOFF global symbols will be written out in xcoff_link_input_bfd.
-     The only symbols we need to handle here are those from non-XCOFF
-     files and from the linker script.  */
-  if (h->xcoff)
+  output_bfd = finfo->output_bfd;
+
+  /* If this symbol was garbage collected, just skip it.  */
+  if (xcoff_hash_table (finfo->info)->gc
+      && (h->flags & XCOFF_MARK) == 0)
+    return true;
+
+  /* If we need a .loader section entry, write it out.  */
+  if (h->ldsym != NULL)
+    {
+      struct internal_ldsym *ldsym;
+      bfd *impbfd;
+
+      ldsym = h->ldsym;
+
+      if (h->root.type == bfd_link_hash_undefined
+	  || h->root.type == bfd_link_hash_undefweak)
+	{
+	  ldsym->l_value = 0;
+	  ldsym->l_scnum = N_UNDEF;
+	  ldsym->l_smtype = XTY_ER;
+	  impbfd = h->root.u.undef.abfd;
+	}
+      else if (h->root.type == bfd_link_hash_defined
+	       || h->root.type == bfd_link_hash_defweak)
+	{
+	  asection *sec;
+
+	  sec = h->root.u.def.section;
+	  ldsym->l_value = (sec->output_section->vma
+			    + sec->output_offset
+			    + h->root.u.def.value);
+	  ldsym->l_scnum = sec->output_section->target_index;
+	  ldsym->l_smtype = XTY_SD;
+	  impbfd = sec->owner;
+	}
+      else
+	abort ();
+
+      if (((h->flags & XCOFF_DEF_REGULAR) == 0
+	   && (h->flags & XCOFF_REF_DYNAMIC) != 0)
+	  || (h->flags & XCOFF_IMPORT) != 0)
+	ldsym->l_smtype |= L_IMPORT;
+      if (((h->flags & XCOFF_DEF_REGULAR) != 0
+	   && (h->flags & XCOFF_REF_DYNAMIC) != 0)
+	  || (h->flags & XCOFF_EXPORT) != 0)
+	ldsym->l_smtype |= L_EXPORT;
+      if ((h->flags & XCOFF_ENTRY) != 0)
+	ldsym->l_smtype |= L_ENTRY;
+
+      ldsym->l_smclas = h->smclas;
+
+      if (ldsym->l_ifile == (bfd_size_type) -1)
+	ldsym->l_ifile = 0;
+      else if (ldsym->l_ifile == 0)
+	{
+	  if ((ldsym->l_smtype & L_IMPORT) == 0)
+	    ldsym->l_ifile = 0;
+	  else if (impbfd == NULL)
+	    ldsym->l_ifile = 0;
+	  else
+	    {
+	      BFD_ASSERT (impbfd->xvec == output_bfd->xvec);
+	      ldsym->l_ifile = xcoff_data (impbfd)->import_file_id;
+	    }
+	}
+
+      ldsym->l_parm = 0;
+
+      BFD_ASSERT (h->ldindx >= 0);
+      BFD_ASSERT (LDSYMSZ == sizeof (struct external_ldsym));
+      xcoff_swap_ldsym_out (output_bfd, ldsym, finfo->ldsym + h->ldindx - 3);
+      h->ldsym = NULL;
+    }
+
+  /* If this symbol needs global linkage code, write it out.  */
+  if (h->root.type == bfd_link_hash_defined
+      && (h->root.u.def.section
+	  == xcoff_hash_table (finfo->info)->linkage_section))
+    {
+      bfd_byte *p;
+      bfd_vma tocoff;
+      unsigned int i;
+
+      p = h->root.u.def.section->contents + h->root.u.def.value;
+
+      /* The first instruction in the global linkage code loads a
+         specific TOC element.  */
+      tocoff = (h->descriptor->toc_section->output_section->vma
+		+ h->descriptor->toc_section->output_offset
+		+ h->descriptor->toc_offset
+		- xcoff_data (output_bfd)->toc);
+      bfd_put_32 (output_bfd, XCOFF_GLINK_FIRST | tocoff, p);
+      for (i = 0, p += 4;
+	   i < sizeof xcoff_glink_code / sizeof xcoff_glink_code[0];
+	   i++, p += 4)
+	bfd_put_32 (output_bfd, xcoff_glink_code[i], p);
+    }
+
+  /* If we created a TOC entry for this symbol, write out the required
+     relocs.  */
+  if ((h->flags & XCOFF_SET_TOC) != 0)
+    {
+      asection *tocsec;
+      asection *osec;
+      int oindx;
+      struct internal_reloc *irel;
+      struct internal_ldrel ldrel;
+
+      tocsec = h->toc_section;
+      osec = tocsec->output_section;
+      oindx = osec->target_index;
+      irel = finfo->section_info[oindx].relocs + osec->reloc_count;
+      irel->r_vaddr = (osec->vma
+		       + tocsec->output_offset
+		       + h->toc_offset);
+      if (h->indx >= 0)
+	irel->r_symndx = h->indx;
+      else
+	{
+	  h->indx = -2;
+	  irel->r_symndx = obj_raw_syment_count (output_bfd);
+	}
+      irel->r_type = R_POS;
+      irel->r_size = 31;
+      finfo->section_info[oindx].rel_hashes[osec->reloc_count] = NULL;
+      ++osec->reloc_count;
+
+      BFD_ASSERT (h->ldindx >= 0);
+      ldrel.l_vaddr = irel->r_vaddr;
+      ldrel.l_symndx = h->ldindx;
+      ldrel.l_rtype = (31 << 8) | R_POS;
+      ldrel.l_rsecnm = oindx;
+      xcoff_swap_ldrel_out (output_bfd, &ldrel, finfo->ldrel);
+      ++finfo->ldrel;
+    }
+
+  if (h->indx >= 0)
+    return true;
+
+  if (h->indx != -2
+      && (finfo->info->strip == strip_all
+	  || (finfo->info->strip == strip_some
+	      && (bfd_hash_lookup (finfo->info->keep_hash,
+				   h->root.root.string, false, false)
+		  == NULL))))
+    return true;
+
+  if (h->indx != -2
+      && (h->flags & (XCOFF_REF_REGULAR | XCOFF_DEF_REGULAR)) == 0)
     return true;
 
-  output_bfd = finfo->output_bfd;
   outsym = finfo->outsyms;
 
   memset (&aux, 0, sizeof aux);
@@ -2357,15 +4334,14 @@ xcoff_write_global_symbol (h, p)
   bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
   outsym += bfd_coff_symesz (output_bfd);
 
-  aux.x_csect.x_smclas = XMC_UA;
+  aux.x_csect.x_smclas = h->smclas;
 
   bfd_coff_swap_aux_out (output_bfd, (PTR) &aux, T_NULL, isym.n_sclass, 0, 1,
 			 (PTR) outsym);
   outsym += bfd_coff_auxesz (output_bfd);
 
-  if ((h->root.type == bfd_link_hash_defined
-       || h->root.type == bfd_link_hash_defweak)
-      && aux.x_csect.x_smclas != XMC_TC0)
+  if (h->root.type == bfd_link_hash_defined
+      || h->root.type == bfd_link_hash_defweak)
     {
       /* We just output an SD symbol.  Now output an LD symbol.  */
 
@@ -2576,10 +4552,10 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
       struct reloc_howto_struct howto;
       bfd_reloc_status_type rstat;
 
-      /* Relocation type 0x0f is a special relocation type which is
+      /* Relocation type R_REF is a special relocation type which is
          merely used to prevent garbage collection from occurring for
          the csect including the symbol which it references.  */
-      if (rel->r_type == 0x0f)
+      if (rel->r_type == R_REF)
 	continue;
 
       symndx = rel->r_symndx;
@@ -2654,6 +4630,12 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
 		     + sec->output_section->vma
 		     + sec->output_offset);
 	    }
+	  else if ((h->flags & XCOFF_REF_DYNAMIC) != 0
+		   || (h->flags & XCOFF_IMPORT) != 0)
+	    {
+	      /* Every symbol in a shared object is defined somewhere.  */
+	      val = 0;
+	    }
 	  else if (! info->relocateable)
 	    {
 	      if (! ((*info->callbacks->undefined_symbol)
@@ -2671,9 +4653,9 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
 
       switch (rel->r_type)
 	{
-	case 0x04:
-	case 0x14:
-	case 0x15:
+	case R_RTB:
+	case R_RRTBI:
+	case R_RRTBA:
 	  /* These relocs are defined by the PowerPC ABI to be
              relative branches which use half of the difference
              between the symbol and the program counter.  I can't
@@ -2685,18 +4667,18 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
 	     bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
 	  bfd_set_error (bfd_error_bad_value);
 	  return false;
-	case 0x00:
+	case R_POS:
 	  /* Simple positive relocation.  */
 	  break;
-	case 0x01:
+	case R_NEG:
 	  /* Simple negative relocation.  */
 	  val = - val;
 	  break;
-	case 0x02:
+	case R_REL:
 	  /* Simple PC relative relocation.  */
 	  howto.pc_relative = true;
 	  break;
-	case 0x03:
+	case R_TOC:
 	  /* TOC relative relocation.  The value in the instruction in
              the input file is the offset from the input file TOC to
              the desired location.  We want the offset from the final
@@ -2707,55 +4689,68 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
 		 oinsn = on + o
 	     so we must change insn by on - in.
 	     */
-	case 0x05:
+	case R_GL:
 	  /* Global linkage relocation.  The value of this relocation
              is the address of the entry in the TOC section.  */
-	case 0x06:
+	case R_TCL:
 	  /* Local object TOC address.  I can't figure out the
-             difference between this and case 0x05.  */
-	case 0x12:
+             difference between this and case R_GL.  */
+	case R_TRL:
 	  /* TOC relative relocation.  A TOC relative load instruction
              which may be changed to a load address instruction.
              FIXME: We don't currently implement this optimization.  */
-	case 0x13:
+	case R_TRLA:
 	  /* TOC relative relocation.  This is a TOC relative load
              address instruction which may be changed to a load
              instruction.  FIXME: I don't know if this is the correct
              implementation.  */
+	  if (h != NULL && h->toc_section == NULL)
+	    {
+	      (*_bfd_error_handler)
+		("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry",
+		 bfd_get_filename (input_bfd), rel->r_vaddr,
+		 h->root.root.string);
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	  if (h != NULL)
+	    val = (h->toc_section->output_section->vma
+		   + h->toc_section->output_offset
+		   + h->toc_offset);
 	  val = ((val - xcoff_data (output_bfd)->toc)
 		 - (sym->n_value - xcoff_data (input_bfd)->toc));
 	  addend = 0;
 	  break;
-	case 0x08:
+	case R_BA:
 	  /* Absolute branch.  We don't want to mess with the lower
              two bits of the instruction.  */
-	case 0x16:
+	case R_CAI:
 	  /* The PowerPC ABI defines this as an absolute call which
              may be modified to become a relative call.  The PowerOpen
              ABI does not define this relocation type.  */
-	case 0x18:
+	case R_RBA:
 	  /* Absolute branch which may be modified to become a
              relative branch.  */
-	case 0x19:
+	case R_RBAC:
 	  /* The PowerPC ABI defines this as an absolute branch to a
              fixed address which may be modified to an absolute branch
              to a symbol.  The PowerOpen ABI does not define this
              relocation type.  */
-	case 0x1b:
+	case R_RBRC:
 	  /* The PowerPC ABI defines this as an absolute branch to a
              fixed address which may be modified to a relative branch.
              The PowerOpen ABI does not define this relocation type.  */
 	  howto.src_mask &= ~3;
 	  howto.dst_mask = howto.src_mask;
 	  break;
-	case 0x0a:
+	case R_BR:
 	  /* Relative branch.  We don't want to mess with the lower
              two bits of the instruction.  */
-	case 0x17:
+	case R_CREL:
 	  /* The PowerPC ABI defines this as a relative call which may
              be modified to become an absolute call.  The PowerOpen
              ABI does not define this relocation type.  */
-	case 0x1a:
+	case R_RBR:
 	  /* A relative branch which may be modified to become an
              absolute branch.  FIXME: We don't implement this,
              although we should for symbols of storage mapping class
@@ -2764,18 +4759,53 @@ _bfd_ppc_xcoff_relocate_section (output_bfd, info, input_bfd,
 	  howto.src_mask &= ~3;
 	  howto.dst_mask = howto.src_mask;
 	  break;
-	case 0x0c:
+	case R_RL:
 	  /* The PowerPC AIX ABI describes this as a load which may be
              changed to a load address.  The PowerOpen ABI says this
-             is the same as case 0x00.  */
+             is the same as case R_POS.  */
 	  break;
-	case 0x0d:
+	case R_RLA:
 	  /* The PowerPC AIX ABI describes this as a load address
              which may be changed to a load.  The PowerOpen ABI says
-             this is the same as case 0x00.  */
+             this is the same as R_POS.  */
 	  break;
 	}
 
+      /* If we see an R_BR or R_RBR reloc which is jumping to global
+         linkage code, and it is followed by an appropriate cror nop
+         instruction, we replace the cror with lwz r2,20(r1).  This
+         restores the TOC after the glink code.  Contrariwise, if the
+         call is followed by a lwz r2,20(r1), but the call is not
+         going to global linkage code, we can replace the load with a
+         cror.  */
+      if ((rel->r_type == R_BR || rel->r_type == R_RBR)
+	  && h != NULL
+	  && h->root.type == bfd_link_hash_defined
+	  && (rel->r_vaddr - input_section->vma + 8
+	      <= input_section->_cooked_size))
+	{
+	  bfd_byte *pnext;
+	  unsigned long next;
+
+	  pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
+	  next = bfd_get_32 (input_bfd, pnext);
+	  if (h->smclas == XMC_GL)
+	    {
+	      if (next == 0x4def7b82		/* cror 15,15,15 */
+		  || next == 0x4ffffb82)	/* cror 31,31,31 */
+		bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */
+	    }
+	  else
+	    {
+	      if (next == 0x80410014)		/* lwz r1,20(r1) */
+		bfd_put_32 (input_bfd, 0x4ffffb82, pnext); /* cror 31,31,31 */
+	    }
+	}
+
+      /* A PC relative reloc includes the section address.  */
+      if (howto.pc_relative)
+	addend += input_section->vma;
+
       rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
 					contents,
 					rel->r_vaddr - input_section->vma,