OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [coff-ppc.c] - Diff between revs 827 and 840

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 827 Rev 840
/* BFD back-end for PowerPC Microsoft Portable Executable files.
/* BFD back-end for PowerPC Microsoft Portable Executable files.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   Original version pieced together by Kim Knuttila (krk@cygnus.com)
   Original version pieced together by Kim Knuttila (krk@cygnus.com)
 
 
   There is nothing new under the sun. This file draws a lot on other
   There is nothing new under the sun. This file draws a lot on other
   coff files, in particular, those for the rs/6000, alpha, mips, and
   coff files, in particular, those for the rs/6000, alpha, mips, and
   intel backends, and the PE work for the arm.
   intel backends, and the PE work for the arm.
 
 
   This file is part of BFD, the Binary File Descriptor library.
   This file is part of BFD, the Binary File Descriptor library.
 
 
   This program is free software; you can redistribute it and/or modify
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor,
   Foundation, 51 Franklin Street - Fifth Floor,
   Boston, MA 02110-1301, USA.  */
   Boston, MA 02110-1301, USA.  */
 
 
/* Current State:
/* Current State:
   - objdump works
   - objdump works
   - relocs generated by gas
   - relocs generated by gas
   - ld will link files, but they do not run.
   - ld will link files, but they do not run.
   - dlltool will not produce correct output in some .reloc cases, and will
   - dlltool will not produce correct output in some .reloc cases, and will
     not produce the right glue code for dll function calls.  */
     not produce the right glue code for dll function calls.  */
 
 
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#include "coff/powerpc.h"
#include "coff/powerpc.h"
#include "coff/internal.h"
#include "coff/internal.h"
 
 
#include "coff/pe.h"
#include "coff/pe.h"
 
 
#ifdef BADMAG
#ifdef BADMAG
#undef BADMAG
#undef BADMAG
#endif
#endif
 
 
#define BADMAG(x) PPCBADMAG(x)
#define BADMAG(x) PPCBADMAG(x)
 
 
#include "libcoff.h"
#include "libcoff.h"
 
 
/* This file is compiled more than once, but we only compile the
/* This file is compiled more than once, but we only compile the
   final_link routine once.  */
   final_link routine once.  */
extern bfd_boolean ppc_bfd_coff_final_link
extern bfd_boolean ppc_bfd_coff_final_link
  PARAMS ((bfd *, struct bfd_link_info *));
  PARAMS ((bfd *, struct bfd_link_info *));
extern void dump_toc PARAMS ((PTR));
extern void dump_toc PARAMS ((PTR));
 
 
/* The toc is a set of bfd_vma fields. We use the fact that valid
/* The toc is a set of bfd_vma fields. We use the fact that valid
   addresses are even (i.e. the bit representing "1" is off) to allow
   addresses are even (i.e. the bit representing "1" is off) to allow
   us to encode a little extra information in the field
   us to encode a little extra information in the field
   - Unallocated addresses are initialized to 1.
   - Unallocated addresses are initialized to 1.
   - Allocated addresses are even numbers.
   - Allocated addresses are even numbers.
   The first time we actually write a reference to the toc in the bfd,
   The first time we actually write a reference to the toc in the bfd,
   we want to record that fact in a fixup file (if it is asked for), so
   we want to record that fact in a fixup file (if it is asked for), so
   we keep track of whether or not an address has been written by marking
   we keep track of whether or not an address has been written by marking
   the low order bit with a "1" upon writing.  */
   the low order bit with a "1" upon writing.  */
 
 
#define SET_UNALLOCATED(x)  ((x) = 1)
#define SET_UNALLOCATED(x)  ((x) = 1)
#define IS_UNALLOCATED(x)   ((x) == 1)
#define IS_UNALLOCATED(x)   ((x) == 1)
 
 
#define IS_WRITTEN(x)       ((x) & 1)
#define IS_WRITTEN(x)       ((x) & 1)
#define MARK_AS_WRITTEN(x)  ((x) |= 1)
#define MARK_AS_WRITTEN(x)  ((x) |= 1)
#define MAKE_ADDR_AGAIN(x)  ((x) &= ~1)
#define MAKE_ADDR_AGAIN(x)  ((x) &= ~1)
 
 
/* Turn on this check if you suspect something amiss in the hash tables.  */
/* Turn on this check if you suspect something amiss in the hash tables.  */
#ifdef DEBUG_HASH
#ifdef DEBUG_HASH
 
 
/* Need a 7 char string for an eye catcher.  */
/* Need a 7 char string for an eye catcher.  */
#define EYE "krkjunk"
#define EYE "krkjunk"
 
 
#define HASH_CHECK_DCL char eye_catcher[8];
#define HASH_CHECK_DCL char eye_catcher[8];
#define HASH_CHECK_INIT(ret)      strcpy(ret->eye_catcher, EYE)
#define HASH_CHECK_INIT(ret)      strcpy(ret->eye_catcher, EYE)
#define HASH_CHECK(addr) \
#define HASH_CHECK(addr) \
 if (strcmp(addr->eye_catcher, EYE) != 0) \
 if (strcmp(addr->eye_catcher, EYE) != 0) \
  { \
  { \
    fprintf (stderr,\
    fprintf (stderr,\
    _("File %s, line %d, Hash check failure, bad eye %8s\n"), \
    _("File %s, line %d, Hash check failure, bad eye %8s\n"), \
    __FILE__, __LINE__, addr->eye_catcher); \
    __FILE__, __LINE__, addr->eye_catcher); \
    abort (); \
    abort (); \
 }
 }
 
 
#else
#else
 
 
#define HASH_CHECK_DCL
#define HASH_CHECK_DCL
#define HASH_CHECK_INIT(ret)
#define HASH_CHECK_INIT(ret)
#define HASH_CHECK(addr)
#define HASH_CHECK(addr)
 
 
#endif
#endif
 
 
/* In order not to add an int to every hash table item for every coff
/* In order not to add an int to every hash table item for every coff
   linker, we define our own hash table, derived from the coff one.  */
   linker, we define our own hash table, derived from the coff one.  */
 
 
/* PE linker hash table entries.  */
/* PE linker hash table entries.  */
 
 
struct ppc_coff_link_hash_entry
struct ppc_coff_link_hash_entry
{
{
  struct coff_link_hash_entry root; /* First entry, as required.  */
  struct coff_link_hash_entry root; /* First entry, as required.  */
 
 
  /* As we wonder around the relocs, we'll keep the assigned toc_offset
  /* As we wonder around the relocs, we'll keep the assigned toc_offset
     here.  */
     here.  */
  bfd_vma toc_offset;               /* Our addition, as required.  */
  bfd_vma toc_offset;               /* Our addition, as required.  */
  int symbol_is_glue;
  int symbol_is_glue;
  unsigned long int glue_insn;
  unsigned long int glue_insn;
 
 
  HASH_CHECK_DCL
  HASH_CHECK_DCL
};
};
 
 
/* PE linker hash table.  */
/* PE linker hash table.  */
 
 
struct ppc_coff_link_hash_table
struct ppc_coff_link_hash_table
{
{
  struct coff_link_hash_table root; /* First entry, as required.  */
  struct coff_link_hash_table root; /* First entry, as required.  */
};
};
 
 
static struct bfd_hash_entry *ppc_coff_link_hash_newfunc
static struct bfd_hash_entry *ppc_coff_link_hash_newfunc
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
           const char *));
           const char *));
static struct bfd_link_hash_table *ppc_coff_link_hash_table_create
static struct bfd_link_hash_table *ppc_coff_link_hash_table_create
  PARAMS ((bfd *));
  PARAMS ((bfd *));
static bfd_boolean coff_ppc_relocate_section
static bfd_boolean coff_ppc_relocate_section
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
           struct internal_reloc *, struct internal_syment *, asection **));
           struct internal_reloc *, struct internal_syment *, asection **));
static reloc_howto_type *coff_ppc_rtype_to_howto
static reloc_howto_type *coff_ppc_rtype_to_howto
  PARAMS ((bfd *, asection *, struct internal_reloc *,
  PARAMS ((bfd *, asection *, struct internal_reloc *,
           struct coff_link_hash_entry *, struct internal_syment *,
           struct coff_link_hash_entry *, struct internal_syment *,
           bfd_vma *));
           bfd_vma *));
 
 
/* Routine to create an entry in the link hash table.  */
/* Routine to create an entry in the link hash table.  */
 
 
static struct bfd_hash_entry *
static struct bfd_hash_entry *
ppc_coff_link_hash_newfunc (entry, table, string)
ppc_coff_link_hash_newfunc (entry, table, string)
     struct bfd_hash_entry *entry;
     struct bfd_hash_entry *entry;
     struct bfd_hash_table *table;
     struct bfd_hash_table *table;
     const char *string;
     const char *string;
{
{
  struct ppc_coff_link_hash_entry *ret =
  struct ppc_coff_link_hash_entry *ret =
    (struct ppc_coff_link_hash_entry *) entry;
    (struct ppc_coff_link_hash_entry *) entry;
 
 
  /* Allocate the structure if it has not already been allocated by a
  /* Allocate the structure if it has not already been allocated by a
     subclass.  */
     subclass.  */
  if (ret == (struct ppc_coff_link_hash_entry *) NULL)
  if (ret == (struct ppc_coff_link_hash_entry *) NULL)
    ret = (struct ppc_coff_link_hash_entry *)
    ret = (struct ppc_coff_link_hash_entry *)
      bfd_hash_allocate (table,
      bfd_hash_allocate (table,
                         sizeof (struct ppc_coff_link_hash_entry));
                         sizeof (struct ppc_coff_link_hash_entry));
 
 
  if (ret == (struct ppc_coff_link_hash_entry *) NULL)
  if (ret == (struct ppc_coff_link_hash_entry *) NULL)
    return NULL;
    return NULL;
 
 
  /* Call the allocation method of the superclass.  */
  /* Call the allocation method of the superclass.  */
  ret = ((struct ppc_coff_link_hash_entry *)
  ret = ((struct ppc_coff_link_hash_entry *)
         _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
         _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
                                      table, string));
                                      table, string));
 
 
  if (ret)
  if (ret)
    {
    {
      /* Initialize the local fields.  */
      /* Initialize the local fields.  */
      SET_UNALLOCATED (ret->toc_offset);
      SET_UNALLOCATED (ret->toc_offset);
      ret->symbol_is_glue = 0;
      ret->symbol_is_glue = 0;
      ret->glue_insn = 0;
      ret->glue_insn = 0;
 
 
      HASH_CHECK_INIT (ret);
      HASH_CHECK_INIT (ret);
    }
    }
 
 
  return (struct bfd_hash_entry *) ret;
  return (struct bfd_hash_entry *) ret;
}
}
 
 
/* Initialize a PE linker hash table.  */
/* Initialize a PE linker hash table.  */
 
 
static bfd_boolean
static bfd_boolean
ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table,
ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table,
                               bfd *abfd,
                               bfd *abfd,
                               struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
                               struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
                                                                  struct bfd_hash_table *,
                                                                  struct bfd_hash_table *,
                                                                  const char *),
                                                                  const char *),
                               unsigned int entsize)
                               unsigned int entsize)
{
{
  return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize);
  return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize);
}
}
 
 
/* Create a PE linker hash table.  */
/* Create a PE linker hash table.  */
 
 
static struct bfd_link_hash_table *
static struct bfd_link_hash_table *
ppc_coff_link_hash_table_create (abfd)
ppc_coff_link_hash_table_create (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  struct ppc_coff_link_hash_table *ret;
  struct ppc_coff_link_hash_table *ret;
  bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table);
  bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table);
 
 
  ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt);
  ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt);
  if (ret == NULL)
  if (ret == NULL)
    return NULL;
    return NULL;
  if (!ppc_coff_link_hash_table_init (ret, abfd,
  if (!ppc_coff_link_hash_table_init (ret, abfd,
                                      ppc_coff_link_hash_newfunc,
                                      ppc_coff_link_hash_newfunc,
                                      sizeof (struct ppc_coff_link_hash_entry)))
                                      sizeof (struct ppc_coff_link_hash_entry)))
    {
    {
      free (ret);
      free (ret);
      return (struct bfd_link_hash_table *) NULL;
      return (struct bfd_link_hash_table *) NULL;
    }
    }
  return &ret->root.root;
  return &ret->root.root;
}
}
 
 
/* Now, tailor coffcode.h to use our hash stuff.  */
/* Now, tailor coffcode.h to use our hash stuff.  */
 
 
#define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create
#define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create


/* The nt loader points the toc register to &toc + 32768, in order to
/* The nt loader points the toc register to &toc + 32768, in order to
   use the complete range of a 16-bit displacement. We have to adjust
   use the complete range of a 16-bit displacement. We have to adjust
   for this when we fix up loads displaced off the toc reg.  */
   for this when we fix up loads displaced off the toc reg.  */
#define TOC_LOAD_ADJUSTMENT (-32768)
#define TOC_LOAD_ADJUSTMENT (-32768)
#define TOC_SECTION_NAME ".private.toc"
#define TOC_SECTION_NAME ".private.toc"
 
 
/* The main body of code is in coffcode.h.  */
/* The main body of code is in coffcode.h.  */
 
 
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 
 
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
   from smaller values.  Start with zero, widen, *then* decrement.  */
   from smaller values.  Start with zero, widen, *then* decrement.  */
#define MINUS_ONE       (((bfd_vma)0) - 1)
#define MINUS_ONE       (((bfd_vma)0) - 1)
 
 
/* These should definitely go in a header file somewhere...  */
/* These should definitely go in a header file somewhere...  */
 
 
/* NOP */
/* NOP */
#define IMAGE_REL_PPC_ABSOLUTE          0x0000
#define IMAGE_REL_PPC_ABSOLUTE          0x0000
 
 
/* 64-bit address */
/* 64-bit address */
#define IMAGE_REL_PPC_ADDR64            0x0001
#define IMAGE_REL_PPC_ADDR64            0x0001
 
 
/* 32-bit address */
/* 32-bit address */
#define IMAGE_REL_PPC_ADDR32            0x0002
#define IMAGE_REL_PPC_ADDR32            0x0002
 
 
/* 26-bit address, shifted left 2 (branch absolute) */
/* 26-bit address, shifted left 2 (branch absolute) */
#define IMAGE_REL_PPC_ADDR24            0x0003
#define IMAGE_REL_PPC_ADDR24            0x0003
 
 
/* 16-bit address */
/* 16-bit address */
#define IMAGE_REL_PPC_ADDR16            0x0004
#define IMAGE_REL_PPC_ADDR16            0x0004
 
 
/* 16-bit address, shifted left 2 (load doubleword) */
/* 16-bit address, shifted left 2 (load doubleword) */
#define IMAGE_REL_PPC_ADDR14            0x0005
#define IMAGE_REL_PPC_ADDR14            0x0005
 
 
/* 26-bit PC-relative offset, shifted left 2 (branch relative) */
/* 26-bit PC-relative offset, shifted left 2 (branch relative) */
#define IMAGE_REL_PPC_REL24             0x0006
#define IMAGE_REL_PPC_REL24             0x0006
 
 
/* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
/* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
#define IMAGE_REL_PPC_REL14             0x0007
#define IMAGE_REL_PPC_REL14             0x0007
 
 
/* 16-bit offset from TOC base */
/* 16-bit offset from TOC base */
#define IMAGE_REL_PPC_TOCREL16          0x0008
#define IMAGE_REL_PPC_TOCREL16          0x0008
 
 
/* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
/* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
#define IMAGE_REL_PPC_TOCREL14          0x0009
#define IMAGE_REL_PPC_TOCREL14          0x0009
 
 
/* 32-bit addr w/o image base */
/* 32-bit addr w/o image base */
#define IMAGE_REL_PPC_ADDR32NB          0x000A
#define IMAGE_REL_PPC_ADDR32NB          0x000A
 
 
/* va of containing section (as in an image sectionhdr) */
/* va of containing section (as in an image sectionhdr) */
#define IMAGE_REL_PPC_SECREL            0x000B
#define IMAGE_REL_PPC_SECREL            0x000B
 
 
/* sectionheader number */
/* sectionheader number */
#define IMAGE_REL_PPC_SECTION           0x000C
#define IMAGE_REL_PPC_SECTION           0x000C
 
 
/* substitute TOC restore instruction iff symbol is glue code */
/* substitute TOC restore instruction iff symbol is glue code */
#define IMAGE_REL_PPC_IFGLUE            0x000D
#define IMAGE_REL_PPC_IFGLUE            0x000D
 
 
/* symbol is glue code; virtual address is TOC restore instruction */
/* symbol is glue code; virtual address is TOC restore instruction */
#define IMAGE_REL_PPC_IMGLUE            0x000E
#define IMAGE_REL_PPC_IMGLUE            0x000E
 
 
/* va of containing section (limited to 16 bits) */
/* va of containing section (limited to 16 bits) */
#define IMAGE_REL_PPC_SECREL16          0x000F
#define IMAGE_REL_PPC_SECREL16          0x000F
 
 
/* Stuff to handle immediate data when the number of bits in the
/* Stuff to handle immediate data when the number of bits in the
   data is greater than the number of bits in the immediate field
   data is greater than the number of bits in the immediate field
   We need to do (usually) 32 bit arithmetic on 16 bit chunks.  */
   We need to do (usually) 32 bit arithmetic on 16 bit chunks.  */
#define IMAGE_REL_PPC_REFHI             0x0010
#define IMAGE_REL_PPC_REFHI             0x0010
#define IMAGE_REL_PPC_REFLO             0x0011
#define IMAGE_REL_PPC_REFLO             0x0011
#define IMAGE_REL_PPC_PAIR              0x0012
#define IMAGE_REL_PPC_PAIR              0x0012
 
 
/* This is essentially the same as tocrel16, with TOCDEFN assumed.  */
/* This is essentially the same as tocrel16, with TOCDEFN assumed.  */
#define IMAGE_REL_PPC_TOCREL16_DEFN     0x0013
#define IMAGE_REL_PPC_TOCREL16_DEFN     0x0013
 
 
/* Flag bits in IMAGE_RELOCATION.TYPE.  */
/* Flag bits in IMAGE_RELOCATION.TYPE.  */
 
 
/* Subtract reloc value rather than adding it.  */
/* Subtract reloc value rather than adding it.  */
#define IMAGE_REL_PPC_NEG               0x0100
#define IMAGE_REL_PPC_NEG               0x0100
 
 
/* Fix branch prediction bit to predict branch taken.  */
/* Fix branch prediction bit to predict branch taken.  */
#define IMAGE_REL_PPC_BRTAKEN           0x0200
#define IMAGE_REL_PPC_BRTAKEN           0x0200
 
 
/* Fix branch prediction bit to predict branch not taken.  */
/* Fix branch prediction bit to predict branch not taken.  */
#define IMAGE_REL_PPC_BRNTAKEN          0x0400
#define IMAGE_REL_PPC_BRNTAKEN          0x0400
 
 
/* TOC slot defined in file (or, data in toc).  */
/* TOC slot defined in file (or, data in toc).  */
#define IMAGE_REL_PPC_TOCDEFN           0x0800
#define IMAGE_REL_PPC_TOCDEFN           0x0800
 
 
/* Masks to isolate above values in IMAGE_RELOCATION.Type.  */
/* Masks to isolate above values in IMAGE_RELOCATION.Type.  */
#define IMAGE_REL_PPC_TYPEMASK          0x00FF
#define IMAGE_REL_PPC_TYPEMASK          0x00FF
#define IMAGE_REL_PPC_FLAGMASK          0x0F00
#define IMAGE_REL_PPC_FLAGMASK          0x0F00
 
 
#define EXTRACT_TYPE(x)                 ((x) & IMAGE_REL_PPC_TYPEMASK)
#define EXTRACT_TYPE(x)                 ((x) & IMAGE_REL_PPC_TYPEMASK)
#define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
#define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
#define EXTRACT_JUNK(x)  \
#define EXTRACT_JUNK(x)  \
           ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))
           ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))


/* Static helper functions to make relocation work.  */
/* Static helper functions to make relocation work.  */
/* (Work In Progress) */
/* (Work In Progress) */
 
 
static bfd_reloc_status_type ppc_refhi_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_refhi_reloc PARAMS ((bfd *abfd,
                                                      arelent *reloc,
                                                      arelent *reloc,
                                                      asymbol *symbol,
                                                      asymbol *symbol,
                                                      PTR data,
                                                      PTR data,
                                                      asection *section,
                                                      asection *section,
                                                      bfd *output_bfd,
                                                      bfd *output_bfd,
                                                      char **error));
                                                      char **error));
static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd,
                                                     arelent *reloc,
                                                     arelent *reloc,
                                                     asymbol *symbol,
                                                     asymbol *symbol,
                                                     PTR data,
                                                     PTR data,
                                                     asection *section,
                                                     asection *section,
                                                     bfd *output_bfd,
                                                     bfd *output_bfd,
                                                     char **error));
                                                     char **error));


static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd,
                                                      arelent *reloc,
                                                      arelent *reloc,
                                                      asymbol *symbol,
                                                      asymbol *symbol,
                                                      PTR data,
                                                      PTR data,
                                                      asection *section,
                                                      asection *section,
                                                      bfd *output_bfd,
                                                      bfd *output_bfd,
                                                      char **error));
                                                      char **error));
 
 
static bfd_reloc_status_type ppc_section_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_section_reloc PARAMS ((bfd *abfd,
                                                        arelent *reloc,
                                                        arelent *reloc,
                                                        asymbol *symbol,
                                                        asymbol *symbol,
                                                        PTR data,
                                                        PTR data,
                                                        asection *section,
                                                        asection *section,
                                                        bfd *output_bfd,
                                                        bfd *output_bfd,
                                                        char **error));
                                                        char **error));
 
 
static bfd_reloc_status_type ppc_secrel_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_secrel_reloc PARAMS ((bfd *abfd,
                                                       arelent *reloc,
                                                       arelent *reloc,
                                                       asymbol *symbol,
                                                       asymbol *symbol,
                                                       PTR data,
                                                       PTR data,
                                                       asection *section,
                                                       asection *section,
                                                       bfd *output_bfd,
                                                       bfd *output_bfd,
                                                       char **error));
                                                       char **error));
 
 
static bfd_reloc_status_type ppc_imglue_reloc PARAMS ((bfd *abfd,
static bfd_reloc_status_type ppc_imglue_reloc PARAMS ((bfd *abfd,
                                                       arelent *reloc,
                                                       arelent *reloc,
                                                       asymbol *symbol,
                                                       asymbol *symbol,
                                                       PTR data,
                                                       PTR data,
                                                       asection *section,
                                                       asection *section,
                                                       bfd *output_bfd,
                                                       bfd *output_bfd,
                                                       char **error));
                                                       char **error));
 
 
static bfd_boolean in_reloc_p PARAMS((bfd *abfd, reloc_howto_type *howto));
static bfd_boolean in_reloc_p PARAMS((bfd *abfd, reloc_howto_type *howto));


/* FIXME: It'll take a while to get through all of these. I only need a few to
/* FIXME: It'll take a while to get through all of these. I only need a few to
   get us started, so those I'll make sure work. Those marked FIXME are either
   get us started, so those I'll make sure work. Those marked FIXME are either
   completely unverified or have a specific unknown marked in the comment.  */
   completely unverified or have a specific unknown marked in the comment.  */
 
 
/* Relocation entries for Windows/NT on PowerPC.
/* Relocation entries for Windows/NT on PowerPC.
 
 
   From the document "" we find the following listed as used relocs:
   From the document "" we find the following listed as used relocs:
 
 
     ABSOLUTE       : The noop
     ABSOLUTE       : The noop
     ADDR[64|32|16] : fields that hold addresses in data fields or the
     ADDR[64|32|16] : fields that hold addresses in data fields or the
                      16 bit displacement field on a load/store.
                      16 bit displacement field on a load/store.
     ADDR[24|14]    : fields that hold addresses in branch and cond
     ADDR[24|14]    : fields that hold addresses in branch and cond
                      branches. These represent [26|16] bit addresses.
                      branches. These represent [26|16] bit addresses.
                      The low order 2 bits are preserved.
                      The low order 2 bits are preserved.
     REL[24|14]     : branches relative to the Instruction Address
     REL[24|14]     : branches relative to the Instruction Address
                      register. These represent [26|16] bit addresses,
                      register. These represent [26|16] bit addresses,
                      as before. The instruction field will be zero, and
                      as before. The instruction field will be zero, and
                      the address of the SYM will be inserted at link time.
                      the address of the SYM will be inserted at link time.
     TOCREL16       : 16 bit displacement field referring to a slot in
     TOCREL16       : 16 bit displacement field referring to a slot in
                      toc.
                      toc.
     TOCREL14       : 16 bit displacement field, similar to REL14 or ADDR14.
     TOCREL14       : 16 bit displacement field, similar to REL14 or ADDR14.
     ADDR32NB       : 32 bit address relative to the virtual origin.
     ADDR32NB       : 32 bit address relative to the virtual origin.
                      (On the alpha, this is always a linker generated thunk)
                      (On the alpha, this is always a linker generated thunk)
                      (i.e. 32bit addr relative to the image base)
                      (i.e. 32bit addr relative to the image base)
     SECREL         : The value is relative to the start of the section
     SECREL         : The value is relative to the start of the section
                      containing the symbol.
                      containing the symbol.
     SECTION        : access to the header containing the item. Supports the
     SECTION        : access to the header containing the item. Supports the
                      codeview debugger.
                      codeview debugger.
 
 
   In particular, note that the document does not indicate that the
   In particular, note that the document does not indicate that the
   relocations listed in the header file are used.  */
   relocations listed in the header file are used.  */
 
 
 
 
static reloc_howto_type ppc_coff_howto_table[] =
static reloc_howto_type ppc_coff_howto_table[] =
{
{
  /* IMAGE_REL_PPC_ABSOLUTE 0x0000   NOP */
  /* IMAGE_REL_PPC_ABSOLUTE 0x0000   NOP */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
  HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
         0,                       /* rightshift */
         0,                       /* rightshift */
         0,                       /* size (0 = byte, 1 = short, 2 = long) */
         0,                       /* size (0 = byte, 1 = short, 2 = long) */
         0,                       /* bitsize */
         0,                       /* bitsize */
         FALSE,                  /* pc_relative */
         FALSE,                  /* pc_relative */
         0,                       /* bitpos */
         0,                       /* bitpos */
         complain_overflow_dont, /* dont complain_on_overflow */
         complain_overflow_dont, /* dont complain_on_overflow */
         0,                       /* special_function */
         0,                       /* special_function */
         "ABSOLUTE",             /* name */
         "ABSOLUTE",             /* name */
         FALSE,                  /* partial_inplace */
         FALSE,                  /* partial_inplace */
         0x00,                   /* src_mask */
         0x00,                   /* src_mask */
         0x00,                   /* dst_mask */
         0x00,                   /* dst_mask */
         FALSE),                 /* pcrel_offset */
         FALSE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR64 0x0001  64-bit address */
  /* IMAGE_REL_PPC_ADDR64 0x0001  64-bit address */
  /* Unused: */
  /* Unused: */
  HOWTO(IMAGE_REL_PPC_ADDR64,    /* type */
  HOWTO(IMAGE_REL_PPC_ADDR64,    /* type */
        0,                        /* rightshift */
        0,                        /* rightshift */
        3,                       /* size (0 = byte, 1 = short, 2 = long) */
        3,                       /* size (0 = byte, 1 = short, 2 = long) */
        64,                      /* bitsize */
        64,                      /* bitsize */
        FALSE,                   /* pc_relative */
        FALSE,                   /* pc_relative */
        0,                        /* bitpos */
        0,                        /* bitpos */
        complain_overflow_bitfield,      /* complain_on_overflow */
        complain_overflow_bitfield,      /* complain_on_overflow */
        0,                        /* special_function */
        0,                        /* special_function */
        "ADDR64",               /* name */
        "ADDR64",               /* name */
        TRUE,                    /* partial_inplace */
        TRUE,                    /* partial_inplace */
        MINUS_ONE,               /* src_mask */
        MINUS_ONE,               /* src_mask */
        MINUS_ONE,               /* dst_mask */
        MINUS_ONE,               /* dst_mask */
        FALSE),                 /* pcrel_offset */
        FALSE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR32 0x0002  32-bit address */
  /* IMAGE_REL_PPC_ADDR32 0x0002  32-bit address */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_ADDR32,  /* type */
  HOWTO (IMAGE_REL_PPC_ADDR32,  /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_bitfield, /* complain_on_overflow */
         complain_overflow_bitfield, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "ADDR32",              /* name */
         "ADDR32",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR24 0x0003  26-bit address, shifted left 2 (branch absolute) */
  /* IMAGE_REL_PPC_ADDR24 0x0003  26-bit address, shifted left 2 (branch absolute) */
  /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
  /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
  /* Of course, That's the IBM approved bit numbering, which is not what */
  /* Of course, That's the IBM approved bit numbering, which is not what */
  /* anyone else uses.... The li field is in bit 2 thru 25 */
  /* anyone else uses.... The li field is in bit 2 thru 25 */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_ADDR24,  /* type */
  HOWTO (IMAGE_REL_PPC_ADDR24,  /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         26,                    /* bitsize */
         26,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_bitfield, /* complain_on_overflow */
         complain_overflow_bitfield, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "ADDR24",              /* name */
         "ADDR24",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0x07fffffc,            /* src_mask */
         0x07fffffc,            /* src_mask */
         0x07fffffc,            /* dst_mask */
         0x07fffffc,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR16 0x0004  16-bit address */
  /* IMAGE_REL_PPC_ADDR16 0x0004  16-bit address */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_ADDR16,  /* type */
  HOWTO (IMAGE_REL_PPC_ADDR16,  /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "ADDR16",              /* name */
         "ADDR16",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR14 0x0005 */
  /* IMAGE_REL_PPC_ADDR14 0x0005 */
  /*  16-bit address, shifted left 2 (load doubleword) */
  /*  16-bit address, shifted left 2 (load doubleword) */
  /* FIXME: the mask is likely wrong, and the bit position may be as well */
  /* FIXME: the mask is likely wrong, and the bit position may be as well */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
  HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
         1,                     /* rightshift */
         1,                     /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "ADDR16",              /* name */
         "ADDR16",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_REL24 0x0006 */
  /* IMAGE_REL_PPC_REL24 0x0006 */
  /*   26-bit PC-relative offset, shifted left 2 (branch relative) */
  /*   26-bit PC-relative offset, shifted left 2 (branch relative) */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_REL24,   /* type */
  HOWTO (IMAGE_REL_PPC_REL24,   /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         26,                    /* bitsize */
         26,                    /* bitsize */
         TRUE,                  /* pc_relative */
         TRUE,                  /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "REL24",               /* name */
         "REL24",               /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0x3fffffc,             /* src_mask */
         0x3fffffc,             /* src_mask */
         0x3fffffc,             /* dst_mask */
         0x3fffffc,             /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_REL14 0x0007 */
  /* IMAGE_REL_PPC_REL14 0x0007 */
  /*   16-bit PC-relative offset, shifted left 2 (br cond relative) */
  /*   16-bit PC-relative offset, shifted left 2 (br cond relative) */
  /* FIXME: the mask is likely wrong, and the bit position may be as well */
  /* FIXME: the mask is likely wrong, and the bit position may be as well */
  /* FIXME: how does it know how far to shift? */
  /* FIXME: how does it know how far to shift? */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
  HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
         1,                     /* rightshift */
         1,                     /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "ADDR16",              /* name */
         "ADDR16",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         TRUE),                 /* pcrel_offset */
         TRUE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_TOCREL16 0x0008 */
  /* IMAGE_REL_PPC_TOCREL16 0x0008 */
  /*   16-bit offset from TOC base */
  /*   16-bit offset from TOC base */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
  HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         ppc_toc16_reloc,       /* special_function */
         ppc_toc16_reloc,       /* special_function */
         "TOCREL16",            /* name */
         "TOCREL16",            /* name */
         FALSE,                 /* partial_inplace */
         FALSE,                 /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_TOCREL14 0x0009 */
  /* IMAGE_REL_PPC_TOCREL14 0x0009 */
  /*   16-bit offset from TOC base, shifted left 2 (load doubleword) */
  /*   16-bit offset from TOC base, shifted left 2 (load doubleword) */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
  HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
         1,                     /* rightshift */
         1,                     /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "TOCREL14",            /* name */
         "TOCREL14",            /* name */
         FALSE,                 /* partial_inplace */
         FALSE,                 /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_ADDR32NB 0x000A */
  /* IMAGE_REL_PPC_ADDR32NB 0x000A */
  /*   32-bit addr w/ image base */
  /*   32-bit addr w/ image base */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
  HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                     /* special_function */
         0,                     /* special_function */
         "ADDR32NB",            /* name */
         "ADDR32NB",            /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                 /* pcrel_offset */
         FALSE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_SECREL 0x000B */
  /* IMAGE_REL_PPC_SECREL 0x000B */
  /*   va of containing section (as in an image sectionhdr) */
  /*   va of containing section (as in an image sectionhdr) */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_SECREL,/* type */
  HOWTO (IMAGE_REL_PPC_SECREL,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         ppc_secrel_reloc,      /* special_function */
         ppc_secrel_reloc,      /* special_function */
         "SECREL",              /* name */
         "SECREL",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         TRUE),                 /* pcrel_offset */
         TRUE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_SECTION 0x000C */
  /* IMAGE_REL_PPC_SECTION 0x000C */
  /*   sectionheader number */
  /*   sectionheader number */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_SECTION,/* type */
  HOWTO (IMAGE_REL_PPC_SECTION,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         ppc_section_reloc,     /* special_function */
         ppc_section_reloc,     /* special_function */
         "SECTION",             /* name */
         "SECTION",             /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         TRUE),                 /* pcrel_offset */
         TRUE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_IFGLUE 0x000D */
  /* IMAGE_REL_PPC_IFGLUE 0x000D */
  /*   substitute TOC restore instruction iff symbol is glue code */
  /*   substitute TOC restore instruction iff symbol is glue code */
  /* Used: */
  /* Used: */
  HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
  HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "IFGLUE",              /* name */
         "IFGLUE",              /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_IMGLUE 0x000E */
  /* IMAGE_REL_PPC_IMGLUE 0x000E */
  /*   symbol is glue code; virtual address is TOC restore instruction */
  /*   symbol is glue code; virtual address is TOC restore instruction */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
  HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         32,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         ppc_imglue_reloc,      /* special_function */
         ppc_imglue_reloc,      /* special_function */
         "IMGLUE",              /* name */
         "IMGLUE",              /* name */
         FALSE,                 /* partial_inplace */
         FALSE,                 /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                 /* pcrel_offset */
         FALSE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_SECREL16 0x000F */
  /* IMAGE_REL_PPC_SECREL16 0x000F */
  /*   va of containing section (limited to 16 bits) */
  /*   va of containing section (limited to 16 bits) */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
  HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "SECREL16",            /* name */
         "SECREL16",            /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         TRUE),                 /* pcrel_offset */
         TRUE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_REFHI             0x0010 */
  /* IMAGE_REL_PPC_REFHI             0x0010 */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_REFHI,   /* type */
  HOWTO (IMAGE_REL_PPC_REFHI,   /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         ppc_refhi_reloc,       /* special_function */
         ppc_refhi_reloc,       /* special_function */
         "REFHI",               /* name */
         "REFHI",               /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                 /* pcrel_offset */
         FALSE),                 /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_REFLO             0x0011 */
  /* IMAGE_REL_PPC_REFLO             0x0011 */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_REFLO,   /* type */
  HOWTO (IMAGE_REL_PPC_REFLO,   /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         ppc_refhi_reloc,       /* special_function */
         ppc_refhi_reloc,       /* special_function */
         "REFLO",               /* name */
         "REFLO",               /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_PAIR              0x0012 */
  /* IMAGE_REL_PPC_PAIR              0x0012 */
  /* Unused: */
  /* Unused: */
  HOWTO (IMAGE_REL_PPC_PAIR,    /* type */
  HOWTO (IMAGE_REL_PPC_PAIR,    /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         complain_overflow_signed, /* complain_on_overflow */
         ppc_pair_reloc,        /* special_function */
         ppc_pair_reloc,        /* special_function */
         "PAIR",                /* name */
         "PAIR",                /* name */
         TRUE,                  /* partial_inplace */
         TRUE,                  /* partial_inplace */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  /* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */
  /* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */
  /*   16-bit offset from TOC base, without causing a definition */
  /*   16-bit offset from TOC base, without causing a definition */
  /* Used: */
  /* Used: */
  HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */
  HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
         16,                    /* bitsize */
         16,                    /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         0,                     /* special_function */
         0,                     /* special_function */
         "TOCREL16, TOCDEFN",   /* name */
         "TOCREL16, TOCDEFN",   /* name */
         FALSE,                 /* partial_inplace */
         FALSE,                 /* partial_inplace */
         0xffff,                /* src_mask */
         0xffff,                /* src_mask */
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
};
};


/* Some really cheezy macros that can be turned on to test stderr :-)  */
/* Some really cheezy macros that can be turned on to test stderr :-)  */
 
 
#ifdef DEBUG_RELOC
#ifdef DEBUG_RELOC
#define UN_IMPL(x)                                           \
#define UN_IMPL(x)                                           \
{                                                            \
{                                                            \
   static int i;                                             \
   static int i;                                             \
   if (i == 0)                                               \
   if (i == 0)                                               \
     {                                                       \
     {                                                       \
       i = 1;                                                \
       i = 1;                                                \
       fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \
       fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \
     }                                                       \
     }                                                       \
}
}
 
 
#define DUMP_RELOC(n,r)                              \
#define DUMP_RELOC(n,r)                              \
{                                                    \
{                                                    \
   fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \
   fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \
           n, (*(r->sym_ptr_ptr))->name,             \
           n, (*(r->sym_ptr_ptr))->name,             \
           r->address, r->addend);                   \
           r->address, r->addend);                   \
}
}
 
 
/* Given a reloc name, n, and a pointer to an internal_reloc,
/* Given a reloc name, n, and a pointer to an internal_reloc,
   dump out interesting information on the contents
   dump out interesting information on the contents
 
 
#define n_name          _n._n_name
#define n_name          _n._n_name
#define n_zeroes        _n._n_n._n_zeroes
#define n_zeroes        _n._n_n._n_zeroes
#define n_offset        _n._n_n._n_offset  */
#define n_offset        _n._n_n._n_offset  */
 
 
#define DUMP_RELOC2(n,r)                                \
#define DUMP_RELOC2(n,r)                                \
{                                                       \
{                                                       \
   fprintf (stderr,"%s sym %d, r_vaddr %d %s\n",        \
   fprintf (stderr,"%s sym %d, r_vaddr %d %s\n",        \
           n, r->r_symndx, r->r_vaddr,                  \
           n, r->r_symndx, r->r_vaddr,                  \
           (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
           (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
           ?" ":" TOCDEFN"  );                          \
           ?" ":" TOCDEFN"  );                          \
}
}
 
 
#else
#else
#define UN_IMPL(x)
#define UN_IMPL(x)
#define DUMP_RELOC(n,r)
#define DUMP_RELOC(n,r)
#define DUMP_RELOC2(n,r)
#define DUMP_RELOC2(n,r)
#endif
#endif


/* TOC construction and management routines.  */
/* TOC construction and management routines.  */
 
 
/* This file is compiled twice, and these variables are defined in one
/* This file is compiled twice, and these variables are defined in one
   of the compilations.  FIXME: This is confusing and weird.  Also,
   of the compilations.  FIXME: This is confusing and weird.  Also,
   BFD should not use global variables.  */
   BFD should not use global variables.  */
extern bfd *    bfd_of_toc_owner;
extern bfd *    bfd_of_toc_owner;
extern long int global_toc_size;
extern long int global_toc_size;
extern long int import_table_size;
extern long int import_table_size;
extern long int first_thunk_address;
extern long int first_thunk_address;
extern long int thunk_size;
extern long int thunk_size;
 
 
enum toc_type
enum toc_type
{
{
  default_toc,
  default_toc,
  toc_32,
  toc_32,
  toc_64
  toc_64
};
};
 
 
enum ref_category
enum ref_category
{
{
  priv,
  priv,
  pub,
  pub,
  tocdata
  tocdata
};
};
 
 
struct list_ele
struct list_ele
{
{
  struct list_ele *next;
  struct list_ele *next;
  bfd_vma addr;
  bfd_vma addr;
  enum ref_category cat;
  enum ref_category cat;
  int offset;
  int offset;
  const char *name;
  const char *name;
};
};
 
 
extern struct list_ele *head;
extern struct list_ele *head;
extern struct list_ele *tail;
extern struct list_ele *tail;
 
 
static void record_toc
static void record_toc
  PARAMS ((asection *, bfd_signed_vma, enum ref_category, const char *));
  PARAMS ((asection *, bfd_signed_vma, enum ref_category, const char *));
 
 
static void
static void
record_toc (toc_section, our_toc_offset, cat, name)
record_toc (toc_section, our_toc_offset, cat, name)
     asection *toc_section;
     asection *toc_section;
     bfd_signed_vma our_toc_offset;
     bfd_signed_vma our_toc_offset;
     enum ref_category cat;
     enum ref_category cat;
     const char *name;
     const char *name;
{
{
  /* Add this entry to our toc addr-offset-name list.  */
  /* Add this entry to our toc addr-offset-name list.  */
  bfd_size_type amt = sizeof (struct list_ele);
  bfd_size_type amt = sizeof (struct list_ele);
  struct list_ele *t = (struct list_ele *) bfd_malloc (amt);
  struct list_ele *t = (struct list_ele *) bfd_malloc (amt);
 
 
  if (t == NULL)
  if (t == NULL)
    abort ();
    abort ();
  t->next = 0;
  t->next = 0;
  t->offset = our_toc_offset;
  t->offset = our_toc_offset;
  t->name = name;
  t->name = name;
  t->cat = cat;
  t->cat = cat;
  t->addr = toc_section->output_offset + our_toc_offset;
  t->addr = toc_section->output_offset + our_toc_offset;
 
 
  if (head == 0)
  if (head == 0)
    {
    {
      head = t;
      head = t;
      tail = t;
      tail = t;
    }
    }
  else
  else
    {
    {
      tail->next = t;
      tail->next = t;
      tail = t;
      tail = t;
    }
    }
}
}
 
 
#ifdef COFF_IMAGE_WITH_PE
#ifdef COFF_IMAGE_WITH_PE
 
 
static bfd_boolean ppc_record_toc_entry
static bfd_boolean ppc_record_toc_entry
  PARAMS ((bfd *, struct bfd_link_info *, asection *, int, enum toc_type));
  PARAMS ((bfd *, struct bfd_link_info *, asection *, int, enum toc_type));
static void ppc_mark_symbol_as_glue
static void ppc_mark_symbol_as_glue
  PARAMS ((bfd *, int, struct internal_reloc *));
  PARAMS ((bfd *, int, struct internal_reloc *));
 
 
/* Record a toc offset against a symbol.  */
/* Record a toc offset against a symbol.  */
static bfd_boolean
static bfd_boolean
ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
     bfd *abfd;
     bfd *abfd;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     asection *sec ATTRIBUTE_UNUSED;
     asection *sec ATTRIBUTE_UNUSED;
     int sym;
     int sym;
     enum toc_type toc_kind ATTRIBUTE_UNUSED;
     enum toc_type toc_kind ATTRIBUTE_UNUSED;
{
{
  struct ppc_coff_link_hash_entry *h;
  struct ppc_coff_link_hash_entry *h;
  const char *name;
  const char *name;
 
 
  int *local_syms;
  int *local_syms;
 
 
  h = 0;
  h = 0;
 
 
  h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
  h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
  if (h != 0)
  if (h != 0)
    {
    {
      HASH_CHECK(h);
      HASH_CHECK(h);
    }
    }
 
 
  if (h == 0)
  if (h == 0)
    {
    {
      local_syms = obj_coff_local_toc_table(abfd);
      local_syms = obj_coff_local_toc_table(abfd);
 
 
      if (local_syms == 0)
      if (local_syms == 0)
        {
        {
          unsigned int i;
          unsigned int i;
          bfd_size_type amt;
          bfd_size_type amt;
 
 
          /* allocate a table */
          /* allocate a table */
          amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
          amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
          local_syms = (int *) bfd_zalloc (abfd, amt);
          local_syms = (int *) bfd_zalloc (abfd, amt);
          if (local_syms == 0)
          if (local_syms == 0)
            return FALSE;
            return FALSE;
          obj_coff_local_toc_table (abfd) = local_syms;
          obj_coff_local_toc_table (abfd) = local_syms;
 
 
          for (i = 0; i < obj_raw_syment_count (abfd); ++i)
          for (i = 0; i < obj_raw_syment_count (abfd); ++i)
            {
            {
              SET_UNALLOCATED (local_syms[i]);
              SET_UNALLOCATED (local_syms[i]);
            }
            }
        }
        }
 
 
      if (IS_UNALLOCATED(local_syms[sym]))
      if (IS_UNALLOCATED(local_syms[sym]))
        {
        {
          local_syms[sym] = global_toc_size;
          local_syms[sym] = global_toc_size;
          global_toc_size += 4;
          global_toc_size += 4;
 
 
          /* The size must fit in a 16-bit displacement.  */
          /* The size must fit in a 16-bit displacement.  */
          if (global_toc_size > 65535)
          if (global_toc_size > 65535)
            {
            {
              (*_bfd_error_handler) (_("TOC overflow"));
              (*_bfd_error_handler) (_("TOC overflow"));
              bfd_set_error (bfd_error_file_too_big);
              bfd_set_error (bfd_error_file_too_big);
              return FALSE;
              return FALSE;
            }
            }
        }
        }
    }
    }
  else
  else
    {
    {
      name = h->root.root.root.string;
      name = h->root.root.root.string;
 
 
      /* Check to see if there's a toc slot allocated. If not, do it
      /* Check to see if there's a toc slot allocated. If not, do it
         here. It will be used in relocate_section.  */
         here. It will be used in relocate_section.  */
      if (IS_UNALLOCATED(h->toc_offset))
      if (IS_UNALLOCATED(h->toc_offset))
        {
        {
          h->toc_offset = global_toc_size;
          h->toc_offset = global_toc_size;
          global_toc_size += 4;
          global_toc_size += 4;
 
 
          /* The size must fit in a 16-bit displacement.  */
          /* The size must fit in a 16-bit displacement.  */
          if (global_toc_size >= 65535)
          if (global_toc_size >= 65535)
            {
            {
              (*_bfd_error_handler) (_("TOC overflow"));
              (*_bfd_error_handler) (_("TOC overflow"));
              bfd_set_error (bfd_error_file_too_big);
              bfd_set_error (bfd_error_file_too_big);
              return FALSE;
              return FALSE;
            }
            }
        }
        }
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
/* Record a toc offset against a symbol.  */
/* Record a toc offset against a symbol.  */
static void
static void
ppc_mark_symbol_as_glue(abfd, sym, rel)
ppc_mark_symbol_as_glue(abfd, sym, rel)
     bfd *abfd;
     bfd *abfd;
     int sym;
     int sym;
     struct internal_reloc *rel;
     struct internal_reloc *rel;
{
{
  struct ppc_coff_link_hash_entry *h;
  struct ppc_coff_link_hash_entry *h;
 
 
  h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
  h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
 
 
  HASH_CHECK(h);
  HASH_CHECK(h);
 
 
  h->symbol_is_glue = 1;
  h->symbol_is_glue = 1;
  h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
  h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
 
 
  return;
  return;
}
}
 
 
#endif /* COFF_IMAGE_WITH_PE */
#endif /* COFF_IMAGE_WITH_PE */


/* Return TRUE if this relocation should
/* Return TRUE if this relocation should
   appear in the output .reloc section.  */
   appear in the output .reloc section.  */
 
 
static bfd_boolean in_reloc_p(abfd, howto)
static bfd_boolean in_reloc_p(abfd, howto)
     bfd * abfd ATTRIBUTE_UNUSED;
     bfd * abfd ATTRIBUTE_UNUSED;
     reloc_howto_type *howto;
     reloc_howto_type *howto;
{
{
  return
  return
    (! howto->pc_relative)
    (! howto->pc_relative)
      && (howto->type != IMAGE_REL_PPC_ADDR32NB)
      && (howto->type != IMAGE_REL_PPC_ADDR32NB)
      && (howto->type != IMAGE_REL_PPC_TOCREL16)
      && (howto->type != IMAGE_REL_PPC_TOCREL16)
      && (howto->type != IMAGE_REL_PPC_IMGLUE)
      && (howto->type != IMAGE_REL_PPC_IMGLUE)
      && (howto->type != IMAGE_REL_PPC_IFGLUE)
      && (howto->type != IMAGE_REL_PPC_IFGLUE)
      && (howto->type != IMAGE_REL_PPC_SECREL)
      && (howto->type != IMAGE_REL_PPC_SECREL)
      && (howto->type != IMAGE_REL_PPC_SECTION)
      && (howto->type != IMAGE_REL_PPC_SECTION)
      && (howto->type != IMAGE_REL_PPC_SECREL16)
      && (howto->type != IMAGE_REL_PPC_SECREL16)
      && (howto->type != IMAGE_REL_PPC_REFHI)
      && (howto->type != IMAGE_REL_PPC_REFHI)
      && (howto->type != IMAGE_REL_PPC_REFLO)
      && (howto->type != IMAGE_REL_PPC_REFLO)
      && (howto->type != IMAGE_REL_PPC_PAIR)
      && (howto->type != IMAGE_REL_PPC_PAIR)
      && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
      && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
}
}
 
 
static bfd_boolean
static bfd_boolean
write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
{
{
  if (coff_data (obfd)->pe)
  if (coff_data (obfd)->pe)
     addr -= pe_data (obfd)->pe_opthdr.ImageBase;
     addr -= pe_data (obfd)->pe_opthdr.ImageBase;
  if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
  if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
    return TRUE;
    return TRUE;
 
 
  bfd_set_error (bfd_error_system_call);
  bfd_set_error (bfd_error_system_call);
  return FALSE;
  return FALSE;
}
}
 
 
/* The reloc processing routine for the optimized COFF linker.  */
/* The reloc processing routine for the optimized COFF linker.  */
 
 
static bfd_boolean
static bfd_boolean
coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
                           contents, relocs, syms, sections)
                           contents, relocs, syms, sections)
     bfd *output_bfd;
     bfd *output_bfd;
     struct bfd_link_info *info;
     struct bfd_link_info *info;
     bfd *input_bfd;
     bfd *input_bfd;
     asection *input_section;
     asection *input_section;
     bfd_byte *contents;
     bfd_byte *contents;
     struct internal_reloc *relocs;
     struct internal_reloc *relocs;
     struct internal_syment *syms;
     struct internal_syment *syms;
     asection **sections;
     asection **sections;
{
{
  struct internal_reloc *rel;
  struct internal_reloc *rel;
  struct internal_reloc *relend;
  struct internal_reloc *relend;
  bfd_boolean hihalf;
  bfd_boolean hihalf;
  bfd_vma hihalf_val;
  bfd_vma hihalf_val;
  asection *toc_section = 0;
  asection *toc_section = 0;
  bfd_vma relocation;
  bfd_vma relocation;
  reloc_howto_type *howto = 0;
  reloc_howto_type *howto = 0;
 
 
  /* If we are performing a relocatable link, we don't need to do a
  /* If we are performing a relocatable link, we don't need to do a
     thing.  The caller will take care of adjusting the reloc
     thing.  The caller will take care of adjusting the reloc
     addresses and symbol indices.  */
     addresses and symbol indices.  */
  if (info->relocatable)
  if (info->relocatable)
    return TRUE;
    return TRUE;
 
 
  hihalf = FALSE;
  hihalf = FALSE;
  hihalf_val = 0;
  hihalf_val = 0;
 
 
  rel = relocs;
  rel = relocs;
  relend = rel + input_section->reloc_count;
  relend = rel + input_section->reloc_count;
  for (; rel < relend; rel++)
  for (; rel < relend; rel++)
    {
    {
      long symndx;
      long symndx;
      struct ppc_coff_link_hash_entry *h;
      struct ppc_coff_link_hash_entry *h;
      struct internal_syment *sym;
      struct internal_syment *sym;
      bfd_vma val;
      bfd_vma val;
 
 
      asection *sec;
      asection *sec;
      bfd_reloc_status_type rstat;
      bfd_reloc_status_type rstat;
      bfd_byte *loc;
      bfd_byte *loc;
 
 
      unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
      unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
      unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
      unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
 
 
      symndx = rel->r_symndx;
      symndx = rel->r_symndx;
      loc = contents + rel->r_vaddr - input_section->vma;
      loc = contents + rel->r_vaddr - input_section->vma;
 
 
      /* FIXME: check bounds on r_type */
      /* FIXME: check bounds on r_type */
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
 
 
      if (symndx == -1)
      if (symndx == -1)
        {
        {
          h = NULL;
          h = NULL;
          sym = NULL;
          sym = NULL;
        }
        }
      else
      else
        {
        {
          h = (struct ppc_coff_link_hash_entry *)
          h = (struct ppc_coff_link_hash_entry *)
            (obj_coff_sym_hashes (input_bfd)[symndx]);
            (obj_coff_sym_hashes (input_bfd)[symndx]);
          if (h != 0)
          if (h != 0)
            {
            {
              HASH_CHECK(h);
              HASH_CHECK(h);
            }
            }
 
 
          sym = syms + symndx;
          sym = syms + symndx;
        }
        }
 
 
      if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
      if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
        {
        {
          /* An IMGLUE reloc must have a name. Something is very wrong.  */
          /* An IMGLUE reloc must have a name. Something is very wrong.  */
          abort ();
          abort ();
        }
        }
 
 
      sec = NULL;
      sec = NULL;
      val = 0;
      val = 0;
 
 
      /* FIXME: PAIR unsupported in the following code.  */
      /* FIXME: PAIR unsupported in the following code.  */
      if (h == NULL)
      if (h == NULL)
        {
        {
          if (symndx == -1)
          if (symndx == -1)
            sec = bfd_abs_section_ptr;
            sec = bfd_abs_section_ptr;
          else
          else
            {
            {
              sec = sections[symndx];
              sec = sections[symndx];
              val = (sec->output_section->vma
              val = (sec->output_section->vma
                     + sec->output_offset
                     + sec->output_offset
                     + sym->n_value);
                     + sym->n_value);
              if (! obj_pe (output_bfd))
              if (! obj_pe (output_bfd))
                val -= sec->vma;
                val -= sec->vma;
            }
            }
        }
        }
      else
      else
        {
        {
          HASH_CHECK(h);
          HASH_CHECK(h);
 
 
          if (h->root.root.type == bfd_link_hash_defined
          if (h->root.root.type == bfd_link_hash_defined
              || h->root.root.type == bfd_link_hash_defweak)
              || h->root.root.type == bfd_link_hash_defweak)
            {
            {
              sec = h->root.root.u.def.section;
              sec = h->root.root.u.def.section;
              val = (h->root.root.u.def.value
              val = (h->root.root.u.def.value
                     + sec->output_section->vma
                     + sec->output_section->vma
                     + sec->output_offset);
                     + sec->output_offset);
            }
            }
          else
          else
            {
            {
              if (! ((*info->callbacks->undefined_symbol)
              if (! ((*info->callbacks->undefined_symbol)
                     (info, h->root.root.root.string, input_bfd, input_section,
                     (info, h->root.root.root.string, input_bfd, input_section,
                      rel->r_vaddr - input_section->vma, TRUE)))
                      rel->r_vaddr - input_section->vma, TRUE)))
                return FALSE;
                return FALSE;
            }
            }
        }
        }
 
 
      rstat = bfd_reloc_ok;
      rstat = bfd_reloc_ok;
 
 
      /* Each case must do its own relocation, setting rstat appropriately.  */
      /* Each case must do its own relocation, setting rstat appropriately.  */
      switch (r_type)
      switch (r_type)
        {
        {
        default:
        default:
          (*_bfd_error_handler)
          (*_bfd_error_handler)
            (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
            (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
          bfd_set_error (bfd_error_bad_value);
          bfd_set_error (bfd_error_bad_value);
          return FALSE;
          return FALSE;
        case IMAGE_REL_PPC_TOCREL16:
        case IMAGE_REL_PPC_TOCREL16:
          {
          {
            bfd_signed_vma our_toc_offset;
            bfd_signed_vma our_toc_offset;
            int fixit;
            int fixit;
 
 
            DUMP_RELOC2(howto->name, rel);
            DUMP_RELOC2(howto->name, rel);
 
 
            if (toc_section == 0)
            if (toc_section == 0)
              {
              {
                toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
                toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
                                                       TOC_SECTION_NAME);
                                                       TOC_SECTION_NAME);
 
 
                if ( toc_section == NULL )
                if ( toc_section == NULL )
                  {
                  {
                    /* There is no toc section. Something is very wrong.  */
                    /* There is no toc section. Something is very wrong.  */
                    abort ();
                    abort ();
                  }
                  }
              }
              }
 
 
            /* Amazing bit tricks present. As we may have seen earlier, we
            /* Amazing bit tricks present. As we may have seen earlier, we
               use the 1 bit to tell us whether or not a toc offset has been
               use the 1 bit to tell us whether or not a toc offset has been
               allocated. Now that they've all been allocated, we will use
               allocated. Now that they've all been allocated, we will use
               the 1 bit to tell us if we've written this particular toc
               the 1 bit to tell us if we've written this particular toc
               entry out.  */
               entry out.  */
            fixit = FALSE;
            fixit = FALSE;
            if (h == 0)
            if (h == 0)
              {
              {
                /* It is a file local symbol.  */
                /* It is a file local symbol.  */
                int *local_toc_table;
                int *local_toc_table;
                const char *name;
                const char *name;
 
 
                sym = syms + symndx;
                sym = syms + symndx;
                name = sym->_n._n_name;
                name = sym->_n._n_name;
 
 
                local_toc_table = obj_coff_local_toc_table(input_bfd);
                local_toc_table = obj_coff_local_toc_table(input_bfd);
                our_toc_offset = local_toc_table[symndx];
                our_toc_offset = local_toc_table[symndx];
 
 
                if (IS_WRITTEN(our_toc_offset))
                if (IS_WRITTEN(our_toc_offset))
                  {
                  {
                    /* If it has been written out, it is marked with the
                    /* If it has been written out, it is marked with the
                       1 bit. Fix up our offset, but do not write it out
                       1 bit. Fix up our offset, but do not write it out
                       again.  */
                       again.  */
                    MAKE_ADDR_AGAIN(our_toc_offset);
                    MAKE_ADDR_AGAIN(our_toc_offset);
                  }
                  }
                else
                else
                  {
                  {
                    /* Write out the toc entry.  */
                    /* Write out the toc entry.  */
                    record_toc (toc_section, our_toc_offset, priv,
                    record_toc (toc_section, our_toc_offset, priv,
                                strdup (name));
                                strdup (name));
 
 
                    bfd_put_32 (output_bfd, val,
                    bfd_put_32 (output_bfd, val,
                               toc_section->contents + our_toc_offset);
                               toc_section->contents + our_toc_offset);
 
 
                    MARK_AS_WRITTEN(local_toc_table[symndx]);
                    MARK_AS_WRITTEN(local_toc_table[symndx]);
                    fixit = TRUE;
                    fixit = TRUE;
                  }
                  }
              }
              }
            else
            else
              {
              {
                const char *name = h->root.root.root.string;
                const char *name = h->root.root.root.string;
                our_toc_offset = h->toc_offset;
                our_toc_offset = h->toc_offset;
 
 
                if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
                if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
                    == IMAGE_REL_PPC_TOCDEFN )
                    == IMAGE_REL_PPC_TOCDEFN )
                  {
                  {
                    /* This is unbelievable cheese. Some knowledgable asm
                    /* This is unbelievable cheese. Some knowledgable asm
                       hacker has decided to use r2 as a base for loading
                       hacker has decided to use r2 as a base for loading
                       a value. He/She does this by setting the tocdefn bit,
                       a value. He/She does this by setting the tocdefn bit,
                       and not supplying a toc definition. The behaviour is
                       and not supplying a toc definition. The behaviour is
                       then to use the difference between the value of the
                       then to use the difference between the value of the
                       symbol and the actual location of the toc as the toc
                       symbol and the actual location of the toc as the toc
                       index.
                       index.
 
 
                       In fact, what is usually happening is, because the
                       In fact, what is usually happening is, because the
                       Import Address Table is mapped immediately following
                       Import Address Table is mapped immediately following
                       the toc, some trippy library code trying for speed on
                       the toc, some trippy library code trying for speed on
                       dll linkage, takes advantage of that and considers
                       dll linkage, takes advantage of that and considers
                       the IAT to be part of the toc, thus saving a load.  */
                       the IAT to be part of the toc, thus saving a load.  */
 
 
                    our_toc_offset = val - (toc_section->output_section->vma
                    our_toc_offset = val - (toc_section->output_section->vma
                                            + toc_section->output_offset);
                                            + toc_section->output_offset);
 
 
                    /* The size must still fit in a 16-bit displacement.  */
                    /* The size must still fit in a 16-bit displacement.  */
                    if ((bfd_vma) our_toc_offset >= 65535)
                    if ((bfd_vma) our_toc_offset >= 65535)
                      {
                      {
                        (*_bfd_error_handler)
                        (*_bfd_error_handler)
                          (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
                          (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
                           input_bfd, name,
                           input_bfd, name,
                           (unsigned long) our_toc_offset);
                           (unsigned long) our_toc_offset);
                        bfd_set_error (bfd_error_bad_value);
                        bfd_set_error (bfd_error_bad_value);
                        return FALSE;
                        return FALSE;
                      }
                      }
 
 
                    record_toc (toc_section, our_toc_offset, pub,
                    record_toc (toc_section, our_toc_offset, pub,
                                strdup (name));
                                strdup (name));
                  }
                  }
                else if (IS_WRITTEN (our_toc_offset))
                else if (IS_WRITTEN (our_toc_offset))
                  {
                  {
                    /* If it has been written out, it is marked with the
                    /* If it has been written out, it is marked with the
                       1 bit. Fix up our offset, but do not write it out
                       1 bit. Fix up our offset, but do not write it out
                       again.  */
                       again.  */
                    MAKE_ADDR_AGAIN(our_toc_offset);
                    MAKE_ADDR_AGAIN(our_toc_offset);
                  }
                  }
                else
                else
                  {
                  {
                    record_toc(toc_section, our_toc_offset, pub,
                    record_toc(toc_section, our_toc_offset, pub,
                               strdup (name));
                               strdup (name));
 
 
                    /* Write out the toc entry.  */
                    /* Write out the toc entry.  */
                    bfd_put_32 (output_bfd, val,
                    bfd_put_32 (output_bfd, val,
                               toc_section->contents + our_toc_offset);
                               toc_section->contents + our_toc_offset);
 
 
                    MARK_AS_WRITTEN(h->toc_offset);
                    MARK_AS_WRITTEN(h->toc_offset);
                    /* The tricky part is that this is the address that
                    /* The tricky part is that this is the address that
                       needs a .reloc entry for it.  */
                       needs a .reloc entry for it.  */
                    fixit = TRUE;
                    fixit = TRUE;
                  }
                  }
              }
              }
 
 
            if (fixit && info->base_file)
            if (fixit && info->base_file)
              {
              {
                /* So if this is non pcrelative, and is referenced
                /* So if this is non pcrelative, and is referenced
                   to a section or a common symbol, then it needs a reloc.  */
                   to a section or a common symbol, then it needs a reloc.  */
 
 
                /* Relocation to a symbol in a section which
                /* Relocation to a symbol in a section which
                   isn't absolute - we output the address here
                   isn't absolute - we output the address here
                   to a file.  */
                   to a file.  */
                bfd_vma addr = (toc_section->output_section->vma
                bfd_vma addr = (toc_section->output_section->vma
                                + toc_section->output_offset + our_toc_offset);
                                + toc_section->output_offset + our_toc_offset);
 
 
                if (!write_base_file_entry (output_bfd, info, addr))
                if (!write_base_file_entry (output_bfd, info, addr))
                  return FALSE;
                  return FALSE;
              }
              }
 
 
            /* FIXME: this test is conservative.  */
            /* FIXME: this test is conservative.  */
            if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
            if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
                && (bfd_vma) our_toc_offset > toc_section->size)
                && (bfd_vma) our_toc_offset > toc_section->size)
              {
              {
                (*_bfd_error_handler)
                (*_bfd_error_handler)
                  (_("%B: Relocation exceeds allocated TOC (%lx)"),
                  (_("%B: Relocation exceeds allocated TOC (%lx)"),
                   input_bfd, (unsigned long) toc_section->size);
                   input_bfd, (unsigned long) toc_section->size);
                bfd_set_error (bfd_error_bad_value);
                bfd_set_error (bfd_error_bad_value);
                return FALSE;
                return FALSE;
              }
              }
 
 
            /* Now we know the relocation for this toc reference.  */
            /* Now we know the relocation for this toc reference.  */
            relocation =  our_toc_offset + TOC_LOAD_ADJUSTMENT;
            relocation =  our_toc_offset + TOC_LOAD_ADJUSTMENT;
            rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
            rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
          }
          }
          break;
          break;
        case IMAGE_REL_PPC_IFGLUE:
        case IMAGE_REL_PPC_IFGLUE:
          {
          {
            /* To solve this, we need to know whether or not the symbol
            /* To solve this, we need to know whether or not the symbol
               appearing on the call instruction is a glue function or not.
               appearing on the call instruction is a glue function or not.
               A glue function must announce itself via a IMGLUE reloc, and
               A glue function must announce itself via a IMGLUE reloc, and
               the reloc contains the required toc restore instruction.  */
               the reloc contains the required toc restore instruction.  */
            bfd_vma x;
            bfd_vma x;
            const char *my_name;
            const char *my_name;
 
 
            DUMP_RELOC2 (howto->name, rel);
            DUMP_RELOC2 (howto->name, rel);
 
 
            if (h != 0)
            if (h != 0)
              {
              {
                my_name = h->root.root.root.string;
                my_name = h->root.root.root.string;
                if (h->symbol_is_glue == 1)
                if (h->symbol_is_glue == 1)
                  {
                  {
                    x = bfd_get_32 (input_bfd, loc);
                    x = bfd_get_32 (input_bfd, loc);
                    bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
                    bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
                  }
                  }
              }
              }
          }
          }
          break;
          break;
        case IMAGE_REL_PPC_SECREL:
        case IMAGE_REL_PPC_SECREL:
          /* Unimplemented: codeview debugging information.  */
          /* Unimplemented: codeview debugging information.  */
          /* For fast access to the header of the section
          /* For fast access to the header of the section
             containing the item.  */
             containing the item.  */
          break;
          break;
        case IMAGE_REL_PPC_SECTION:
        case IMAGE_REL_PPC_SECTION:
          /* Unimplemented: codeview debugging information.  */
          /* Unimplemented: codeview debugging information.  */
          /* Is used to indicate that the value should be relative
          /* Is used to indicate that the value should be relative
             to the beginning of the section that contains the
             to the beginning of the section that contains the
             symbol.  */
             symbol.  */
          break;
          break;
        case IMAGE_REL_PPC_ABSOLUTE:
        case IMAGE_REL_PPC_ABSOLUTE:
          {
          {
            const char *my_name;
            const char *my_name;
 
 
            if (h == 0)
            if (h == 0)
              my_name = (syms+symndx)->_n._n_name;
              my_name = (syms+symndx)->_n._n_name;
            else
            else
              my_name = h->root.root.root.string;
              my_name = h->root.root.root.string;
 
 
            (*_bfd_error_handler)
            (*_bfd_error_handler)
              (_("Warning: unsupported reloc %s <file %B, section %A>\n"
              (_("Warning: unsupported reloc %s <file %B, section %A>\n"
                 "sym %ld (%s), r_vaddr %ld (%lx)"),
                 "sym %ld (%s), r_vaddr %ld (%lx)"),
               input_bfd, input_section, howto->name,
               input_bfd, input_section, howto->name,
               rel->r_symndx, my_name, (long) rel->r_vaddr,
               rel->r_symndx, my_name, (long) rel->r_vaddr,
               (unsigned long) rel->r_vaddr);
               (unsigned long) rel->r_vaddr);
          }
          }
          break;
          break;
        case IMAGE_REL_PPC_IMGLUE:
        case IMAGE_REL_PPC_IMGLUE:
          {
          {
            /* There is nothing to do now. This reloc was noted in the first
            /* There is nothing to do now. This reloc was noted in the first
               pass over the relocs, and the glue instruction extracted.  */
               pass over the relocs, and the glue instruction extracted.  */
            const char *my_name;
            const char *my_name;
 
 
            if (h->symbol_is_glue == 1)
            if (h->symbol_is_glue == 1)
              break;
              break;
            my_name = h->root.root.root.string;
            my_name = h->root.root.root.string;
 
 
            (*_bfd_error_handler)
            (*_bfd_error_handler)
              (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
              (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
            bfd_set_error (bfd_error_bad_value);
            bfd_set_error (bfd_error_bad_value);
            return FALSE;
            return FALSE;
          }
          }
 
 
        case IMAGE_REL_PPC_ADDR32NB:
        case IMAGE_REL_PPC_ADDR32NB:
          {
          {
            const char *name = 0;
            const char *name = 0;
 
 
            DUMP_RELOC2 (howto->name, rel);
            DUMP_RELOC2 (howto->name, rel);
 
 
            if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
            if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
              {
              {
                /* Set magic values.  */
                /* Set magic values.  */
                int idata5offset;
                int idata5offset;
                struct coff_link_hash_entry *myh;
                struct coff_link_hash_entry *myh;
 
 
                myh = coff_link_hash_lookup (coff_hash_table (info),
                myh = coff_link_hash_lookup (coff_hash_table (info),
                                             "__idata5_magic__",
                                             "__idata5_magic__",
                                             FALSE, FALSE, TRUE);
                                             FALSE, FALSE, TRUE);
                first_thunk_address = myh->root.u.def.value +
                first_thunk_address = myh->root.u.def.value +
                  sec->output_section->vma +
                  sec->output_section->vma +
                    sec->output_offset -
                    sec->output_offset -
                      pe_data(output_bfd)->pe_opthdr.ImageBase;
                      pe_data(output_bfd)->pe_opthdr.ImageBase;
 
 
                idata5offset = myh->root.u.def.value;
                idata5offset = myh->root.u.def.value;
                myh = coff_link_hash_lookup (coff_hash_table (info),
                myh = coff_link_hash_lookup (coff_hash_table (info),
                                             "__idata6_magic__",
                                             "__idata6_magic__",
                                             FALSE, FALSE, TRUE);
                                             FALSE, FALSE, TRUE);
 
 
                thunk_size = myh->root.u.def.value - idata5offset;
                thunk_size = myh->root.u.def.value - idata5offset;
                myh = coff_link_hash_lookup (coff_hash_table (info),
                myh = coff_link_hash_lookup (coff_hash_table (info),
                                             "__idata4_magic__",
                                             "__idata4_magic__",
                                             FALSE, FALSE, TRUE);
                                             FALSE, FALSE, TRUE);
                import_table_size = myh->root.u.def.value;
                import_table_size = myh->root.u.def.value;
              }
              }
 
 
            if (h == 0)
            if (h == 0)
              {
              {
                /* It is a file local symbol.  */
                /* It is a file local symbol.  */
                sym = syms + symndx;
                sym = syms + symndx;
                name = sym->_n._n_name;
                name = sym->_n._n_name;
              }
              }
            else
            else
              {
              {
                char *target = 0;
                char *target = 0;
 
 
                name = h->root.root.root.string;
                name = h->root.root.root.string;
                if (strcmp (".idata$2", name) == 0)
                if (strcmp (".idata$2", name) == 0)
                  target = "__idata2_magic__";
                  target = "__idata2_magic__";
                else if (strcmp (".idata$4", name) == 0)
                else if (strcmp (".idata$4", name) == 0)
                  target = "__idata4_magic__";
                  target = "__idata4_magic__";
                else if (strcmp (".idata$5", name) == 0)
                else if (strcmp (".idata$5", name) == 0)
                  target = "__idata5_magic__";
                  target = "__idata5_magic__";
 
 
                if (target != 0)
                if (target != 0)
                  {
                  {
                    struct coff_link_hash_entry *myh;
                    struct coff_link_hash_entry *myh;
 
 
                    myh = coff_link_hash_lookup (coff_hash_table (info),
                    myh = coff_link_hash_lookup (coff_hash_table (info),
                                                 target,
                                                 target,
                                                 FALSE, FALSE, TRUE);
                                                 FALSE, FALSE, TRUE);
                    if (myh == 0)
                    if (myh == 0)
                      {
                      {
                        /* Missing magic cookies. Something is very wrong.  */
                        /* Missing magic cookies. Something is very wrong.  */
                        abort ();
                        abort ();
                      }
                      }
 
 
                    val = myh->root.u.def.value +
                    val = myh->root.u.def.value +
                      sec->output_section->vma + sec->output_offset;
                      sec->output_section->vma + sec->output_offset;
                    if (first_thunk_address == 0)
                    if (first_thunk_address == 0)
                      {
                      {
                        int idata5offset;
                        int idata5offset;
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                                                     "__idata5_magic__",
                                                     "__idata5_magic__",
                                                     FALSE, FALSE, TRUE);
                                                     FALSE, FALSE, TRUE);
                        first_thunk_address = myh->root.u.def.value +
                        first_thunk_address = myh->root.u.def.value +
                          sec->output_section->vma +
                          sec->output_section->vma +
                            sec->output_offset -
                            sec->output_offset -
                              pe_data(output_bfd)->pe_opthdr.ImageBase;
                              pe_data(output_bfd)->pe_opthdr.ImageBase;
 
 
                        idata5offset = myh->root.u.def.value;
                        idata5offset = myh->root.u.def.value;
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                                                     "__idata6_magic__",
                                                     "__idata6_magic__",
                                                     FALSE, FALSE, TRUE);
                                                     FALSE, FALSE, TRUE);
 
 
                        thunk_size = myh->root.u.def.value - idata5offset;
                        thunk_size = myh->root.u.def.value - idata5offset;
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                        myh = coff_link_hash_lookup (coff_hash_table (info),
                                                     "__idata4_magic__",
                                                     "__idata4_magic__",
                                                     FALSE, FALSE, TRUE);
                                                     FALSE, FALSE, TRUE);
                        import_table_size = myh->root.u.def.value;
                        import_table_size = myh->root.u.def.value;
                      }
                      }
                  }
                  }
              }
              }
 
 
            rstat = _bfd_relocate_contents (howto,
            rstat = _bfd_relocate_contents (howto,
                                            input_bfd,
                                            input_bfd,
                                            val -
                                            val -
                                            pe_data (output_bfd)->pe_opthdr.ImageBase,
                                            pe_data (output_bfd)->pe_opthdr.ImageBase,
                                            loc);
                                            loc);
          }
          }
          break;
          break;
 
 
        case IMAGE_REL_PPC_REL24:
        case IMAGE_REL_PPC_REL24:
          DUMP_RELOC2(howto->name, rel);
          DUMP_RELOC2(howto->name, rel);
          val -= (input_section->output_section->vma
          val -= (input_section->output_section->vma
                  + input_section->output_offset);
                  + input_section->output_offset);
 
 
          rstat = _bfd_relocate_contents (howto,
          rstat = _bfd_relocate_contents (howto,
                                          input_bfd,
                                          input_bfd,
                                          val,
                                          val,
                                          loc);
                                          loc);
          break;
          break;
        case IMAGE_REL_PPC_ADDR16:
        case IMAGE_REL_PPC_ADDR16:
        case IMAGE_REL_PPC_ADDR24:
        case IMAGE_REL_PPC_ADDR24:
        case IMAGE_REL_PPC_ADDR32:
        case IMAGE_REL_PPC_ADDR32:
          DUMP_RELOC2(howto->name, rel);
          DUMP_RELOC2(howto->name, rel);
          rstat = _bfd_relocate_contents (howto,
          rstat = _bfd_relocate_contents (howto,
                                          input_bfd,
                                          input_bfd,
                                          val,
                                          val,
                                          loc);
                                          loc);
          break;
          break;
        }
        }
 
 
      if (info->base_file)
      if (info->base_file)
        {
        {
          /* So if this is non pcrelative, and is referenced
          /* So if this is non pcrelative, and is referenced
             to a section or a common symbol, then it needs a reloc.  */
             to a section or a common symbol, then it needs a reloc.  */
          if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
          if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
            {
            {
              /* Relocation to a symbol in a section which
              /* Relocation to a symbol in a section which
                 isn't absolute - we output the address here
                 isn't absolute - we output the address here
                 to a file.  */
                 to a file.  */
              bfd_vma addr = (rel->r_vaddr
              bfd_vma addr = (rel->r_vaddr
                              - input_section->vma
                              - input_section->vma
                              + input_section->output_offset
                              + input_section->output_offset
                              + input_section->output_section->vma);
                              + input_section->output_section->vma);
 
 
              if (!write_base_file_entry (output_bfd, info, addr))
              if (!write_base_file_entry (output_bfd, info, addr))
                return FALSE;
                return FALSE;
            }
            }
        }
        }
 
 
      switch (rstat)
      switch (rstat)
        {
        {
        default:
        default:
          abort ();
          abort ();
        case bfd_reloc_ok:
        case bfd_reloc_ok:
          break;
          break;
        case bfd_reloc_overflow:
        case bfd_reloc_overflow:
          {
          {
            const char *name;
            const char *name;
            char buf[SYMNMLEN + 1];
            char buf[SYMNMLEN + 1];
 
 
            if (symndx == -1)
            if (symndx == -1)
              name = "*ABS*";
              name = "*ABS*";
            else if (h != NULL)
            else if (h != NULL)
              name = NULL;
              name = NULL;
            else if (sym == NULL)
            else if (sym == NULL)
              name = "*unknown*";
              name = "*unknown*";
            else if (sym->_n._n_n._n_zeroes == 0
            else if (sym->_n._n_n._n_zeroes == 0
                     && sym->_n._n_n._n_offset != 0)
                     && sym->_n._n_n._n_offset != 0)
              name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
              name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
            else
            else
              {
              {
                strncpy (buf, sym->_n._n_name, SYMNMLEN);
                strncpy (buf, sym->_n._n_name, SYMNMLEN);
                buf[SYMNMLEN] = '\0';
                buf[SYMNMLEN] = '\0';
                name = buf;
                name = buf;
              }
              }
 
 
            if (! ((*info->callbacks->reloc_overflow)
            if (! ((*info->callbacks->reloc_overflow)
                   (info, (h ? &h->root.root : NULL), name, howto->name,
                   (info, (h ? &h->root.root : NULL), name, howto->name,
                    (bfd_vma) 0, input_bfd,
                    (bfd_vma) 0, input_bfd,
                    input_section, rel->r_vaddr - input_section->vma)))
                    input_section, rel->r_vaddr - input_section->vma)))
              return FALSE;
              return FALSE;
          }
          }
        }
        }
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
#ifdef COFF_IMAGE_WITH_PE
#ifdef COFF_IMAGE_WITH_PE
 
 
/* FIXME: BFD should not use global variables.  This file is compiled
/* FIXME: BFD should not use global variables.  This file is compiled
   twice, and these variables are shared.  This is confusing and
   twice, and these variables are shared.  This is confusing and
   weird.  */
   weird.  */
 
 
long int global_toc_size = 4;
long int global_toc_size = 4;
 
 
bfd* bfd_of_toc_owner = 0;
bfd* bfd_of_toc_owner = 0;
 
 
long int import_table_size;
long int import_table_size;
long int first_thunk_address;
long int first_thunk_address;
long int thunk_size;
long int thunk_size;
 
 
struct list_ele *head;
struct list_ele *head;
struct list_ele *tail;
struct list_ele *tail;
 
 
static char *
static char *
h1 = N_("\n\t\t\tTOC MAPPING\n\n");
h1 = N_("\n\t\t\tTOC MAPPING\n\n");
static char *
static char *
h2 = N_(" TOC    disassembly  Comments       Name\n");
h2 = N_(" TOC    disassembly  Comments       Name\n");
static char *
static char *
h3 = N_(" Offset  spelling                   (if present)\n");
h3 = N_(" Offset  spelling                   (if present)\n");
 
 
void
void
dump_toc (vfile)
dump_toc (vfile)
     PTR vfile;
     PTR vfile;
{
{
  FILE *file = (FILE *) vfile;
  FILE *file = (FILE *) vfile;
  struct list_ele *t;
  struct list_ele *t;
 
 
  fputs (_(h1), file);
  fputs (_(h1), file);
  fputs (_(h2), file);
  fputs (_(h2), file);
  fputs (_(h3), file);
  fputs (_(h3), file);
 
 
  for (t = head; t != 0; t=t->next)
  for (t = head; t != 0; t=t->next)
    {
    {
      const char *cat = "";
      const char *cat = "";
 
 
      if (t->cat == priv)
      if (t->cat == priv)
        cat = _("private       ");
        cat = _("private       ");
      else if (t->cat == pub)
      else if (t->cat == pub)
        cat = _("public        ");
        cat = _("public        ");
      else if (t->cat == tocdata)
      else if (t->cat == tocdata)
        cat = _("data-in-toc   ");
        cat = _("data-in-toc   ");
 
 
      if (t->offset > global_toc_size)
      if (t->offset > global_toc_size)
        {
        {
          if (t->offset <= global_toc_size + thunk_size)
          if (t->offset <= global_toc_size + thunk_size)
            cat = _("IAT reference ");
            cat = _("IAT reference ");
          else
          else
            {
            {
              fprintf (file,
              fprintf (file,
                      _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
                      _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
                       global_toc_size, (unsigned long) global_toc_size,
                       global_toc_size, (unsigned long) global_toc_size,
                       thunk_size, (unsigned long) thunk_size);
                       thunk_size, (unsigned long) thunk_size);
              cat = _("Out of bounds!");
              cat = _("Out of bounds!");
            }
            }
        }
        }
 
 
      fprintf (file,
      fprintf (file,
              " %04lx    (%d)", (unsigned long) t->offset, t->offset - 32768);
              " %04lx    (%d)", (unsigned long) t->offset, t->offset - 32768);
      fprintf (file,
      fprintf (file,
              "    %s %s\n",
              "    %s %s\n",
              cat, t->name);
              cat, t->name);
 
 
    }
    }
 
 
  fprintf (file, "\n");
  fprintf (file, "\n");
}
}
 
 
bfd_boolean
bfd_boolean
ppc_allocate_toc_section (info)
ppc_allocate_toc_section (info)
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
{
{
  asection *s;
  asection *s;
  bfd_byte *foo;
  bfd_byte *foo;
  bfd_size_type amt;
  bfd_size_type amt;
  static char test_char = '1';
  static char test_char = '1';
 
 
  if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble?  */
  if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble?  */
    return TRUE;
    return TRUE;
 
 
  if (bfd_of_toc_owner == 0)
  if (bfd_of_toc_owner == 0)
    /* No toc owner? Something is very wrong.  */
    /* No toc owner? Something is very wrong.  */
    abort ();
    abort ();
 
 
  s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
  s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
  if (s == NULL)
  if (s == NULL)
    /* No toc section? Something is very wrong.  */
    /* No toc section? Something is very wrong.  */
    abort ();
    abort ();
 
 
  amt = global_toc_size;
  amt = global_toc_size;
  foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
  foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
  memset(foo, test_char, (size_t) global_toc_size);
  memset(foo, test_char, (size_t) global_toc_size);
 
 
  s->size = global_toc_size;
  s->size = global_toc_size;
  s->contents = foo;
  s->contents = foo;
 
 
  return TRUE;
  return TRUE;
}
}
 
 
bfd_boolean
bfd_boolean
ppc_process_before_allocation (abfd, info)
ppc_process_before_allocation (abfd, info)
     bfd *abfd;
     bfd *abfd;
     struct bfd_link_info *info;
     struct bfd_link_info *info;
{
{
  asection *sec;
  asection *sec;
  struct internal_reloc *i, *rel;
  struct internal_reloc *i, *rel;
 
 
  /* Here we have a bfd that is to be included on the link. We have a hook
  /* Here we have a bfd that is to be included on the link. We have a hook
     to do reloc rummaging, before section sizes are nailed down.  */
     to do reloc rummaging, before section sizes are nailed down.  */
  _bfd_coff_get_external_symbols (abfd);
  _bfd_coff_get_external_symbols (abfd);
 
 
  /* Rummage around all the relocs and map the toc.  */
  /* Rummage around all the relocs and map the toc.  */
  sec = abfd->sections;
  sec = abfd->sections;
 
 
  if (sec == 0)
  if (sec == 0)
    return TRUE;
    return TRUE;
 
 
  for (; sec != 0; sec = sec->next)
  for (; sec != 0; sec = sec->next)
    {
    {
      if (sec->reloc_count == 0)
      if (sec->reloc_count == 0)
        continue;
        continue;
 
 
      /* load the relocs */
      /* load the relocs */
      /* FIXME: there may be a storage leak here */
      /* FIXME: there may be a storage leak here */
      i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
      i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
 
 
      if (i == 0)
      if (i == 0)
        abort ();
        abort ();
 
 
      for (rel = i; rel < i + sec->reloc_count; ++rel)
      for (rel = i; rel < i + sec->reloc_count; ++rel)
        {
        {
          unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
          unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
          unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
          unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
          bfd_boolean ok = TRUE;
          bfd_boolean ok = TRUE;
 
 
          DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
          DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
 
 
          switch(r_type)
          switch(r_type)
            {
            {
            case IMAGE_REL_PPC_TOCREL16:
            case IMAGE_REL_PPC_TOCREL16:
              /* If TOCDEFN is on, ignore as someone else has allocated the
              /* If TOCDEFN is on, ignore as someone else has allocated the
                 toc entry.  */
                 toc entry.  */
              if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
              if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
                ok = ppc_record_toc_entry(abfd, info, sec,
                ok = ppc_record_toc_entry(abfd, info, sec,
                                          rel->r_symndx, default_toc);
                                          rel->r_symndx, default_toc);
              if (!ok)
              if (!ok)
                return FALSE;
                return FALSE;
              break;
              break;
            case IMAGE_REL_PPC_IMGLUE:
            case IMAGE_REL_PPC_IMGLUE:
              ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
              ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
              break;
              break;
            default:
            default:
              break;
              break;
            }
            }
        }
        }
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
#endif
#endif
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_refhi_reloc (abfd, reloc_entry, symbol, data,
ppc_refhi_reloc (abfd, reloc_entry, symbol, data,
                 input_section, output_bfd, error_message)
                 input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL("REFHI");
  UN_IMPL("REFHI");
  DUMP_RELOC("REFHI",reloc_entry);
  DUMP_RELOC("REFHI",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_undefined;
  return bfd_reloc_undefined;
}
}
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_pair_reloc (abfd, reloc_entry, symbol, data,
ppc_pair_reloc (abfd, reloc_entry, symbol, data,
                input_section, output_bfd, error_message)
                input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL("PAIR");
  UN_IMPL("PAIR");
  DUMP_RELOC("PAIR",reloc_entry);
  DUMP_RELOC("PAIR",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_undefined;
  return bfd_reloc_undefined;
}
}


static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_toc16_reloc (abfd, reloc_entry, symbol, data,
ppc_toc16_reloc (abfd, reloc_entry, symbol, data,
                 input_section, output_bfd, error_message)
                 input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL ("TOCREL16");
  UN_IMPL ("TOCREL16");
  DUMP_RELOC ("TOCREL16",reloc_entry);
  DUMP_RELOC ("TOCREL16",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_ok;
  return bfd_reloc_ok;
}
}
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_secrel_reloc (abfd, reloc_entry, symbol, data,
ppc_secrel_reloc (abfd, reloc_entry, symbol, data,
                  input_section, output_bfd, error_message)
                  input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL("SECREL");
  UN_IMPL("SECREL");
  DUMP_RELOC("SECREL",reloc_entry);
  DUMP_RELOC("SECREL",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_ok;
  return bfd_reloc_ok;
}
}
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_section_reloc (abfd, reloc_entry, symbol, data,
ppc_section_reloc (abfd, reloc_entry, symbol, data,
                   input_section, output_bfd, error_message)
                   input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL("SECTION");
  UN_IMPL("SECTION");
  DUMP_RELOC("SECTION",reloc_entry);
  DUMP_RELOC("SECTION",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_ok;
  return bfd_reloc_ok;
}
}
 
 
static bfd_reloc_status_type
static bfd_reloc_status_type
ppc_imglue_reloc (abfd, reloc_entry, symbol, data,
ppc_imglue_reloc (abfd, reloc_entry, symbol, data,
                  input_section, output_bfd, error_message)
                  input_section, output_bfd, error_message)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     arelent *reloc_entry ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     asymbol *symbol ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     PTR data ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     asection *input_section ATTRIBUTE_UNUSED;
     bfd *output_bfd;
     bfd *output_bfd;
     char **error_message ATTRIBUTE_UNUSED;
     char **error_message ATTRIBUTE_UNUSED;
{
{
  UN_IMPL("IMGLUE");
  UN_IMPL("IMGLUE");
  DUMP_RELOC("IMGLUE",reloc_entry);
  DUMP_RELOC("IMGLUE",reloc_entry);
 
 
  if (output_bfd == (bfd *) NULL)
  if (output_bfd == (bfd *) NULL)
    return bfd_reloc_continue;
    return bfd_reloc_continue;
 
 
  return bfd_reloc_ok;
  return bfd_reloc_ok;
}
}


#define MAX_RELOC_INDEX  \
#define MAX_RELOC_INDEX  \
      (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
      (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
 
 
/* FIXME: There is a possibility that when we read in a reloc from a file,
/* FIXME: There is a possibility that when we read in a reloc from a file,
          that there are some bits encoded in the upper portion of the
          that there are some bits encoded in the upper portion of the
          type field. Not yet implemented.  */
          type field. Not yet implemented.  */
static void ppc_coff_rtype2howto PARAMS ((arelent *, struct internal_reloc *));
static void ppc_coff_rtype2howto PARAMS ((arelent *, struct internal_reloc *));
 
 
static void
static void
ppc_coff_rtype2howto (relent, internal)
ppc_coff_rtype2howto (relent, internal)
     arelent *relent;
     arelent *relent;
     struct internal_reloc *internal;
     struct internal_reloc *internal;
{
{
  /* We can encode one of three things in the type field, aside from the
  /* We can encode one of three things in the type field, aside from the
     type:
     type:
     1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
     1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
        value, rather than an addition value
        value, rather than an addition value
     2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
     2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
        the branch is expected to be taken or not.
        the branch is expected to be taken or not.
     3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
     3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
     For now, we just strip this stuff to find the type, and ignore it other
     For now, we just strip this stuff to find the type, and ignore it other
     than that.  */
     than that.  */
  reloc_howto_type *howto;
  reloc_howto_type *howto;
  unsigned short r_type  = EXTRACT_TYPE (internal->r_type);
  unsigned short r_type  = EXTRACT_TYPE (internal->r_type);
  unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
  unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
  unsigned short junk    = EXTRACT_JUNK (internal->r_type);
  unsigned short junk    = EXTRACT_JUNK (internal->r_type);
 
 
  /* The masking process only slices off the bottom byte for r_type.  */
  /* The masking process only slices off the bottom byte for r_type.  */
  if ( r_type > MAX_RELOC_INDEX )
  if ( r_type > MAX_RELOC_INDEX )
    abort ();
    abort ();
 
 
  /* Check for absolute crap.  */
  /* Check for absolute crap.  */
  if (junk != 0)
  if (junk != 0)
    abort ();
    abort ();
 
 
  switch(r_type)
  switch(r_type)
    {
    {
    case IMAGE_REL_PPC_ADDR16:
    case IMAGE_REL_PPC_ADDR16:
    case IMAGE_REL_PPC_REL24:
    case IMAGE_REL_PPC_REL24:
    case IMAGE_REL_PPC_ADDR24:
    case IMAGE_REL_PPC_ADDR24:
    case IMAGE_REL_PPC_ADDR32:
    case IMAGE_REL_PPC_ADDR32:
    case IMAGE_REL_PPC_IFGLUE:
    case IMAGE_REL_PPC_IFGLUE:
    case IMAGE_REL_PPC_ADDR32NB:
    case IMAGE_REL_PPC_ADDR32NB:
    case IMAGE_REL_PPC_SECTION:
    case IMAGE_REL_PPC_SECTION:
    case IMAGE_REL_PPC_SECREL:
    case IMAGE_REL_PPC_SECREL:
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    case IMAGE_REL_PPC_IMGLUE:
    case IMAGE_REL_PPC_IMGLUE:
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    case IMAGE_REL_PPC_TOCREL16:
    case IMAGE_REL_PPC_TOCREL16:
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
      if (r_flags & IMAGE_REL_PPC_TOCDEFN)
      if (r_flags & IMAGE_REL_PPC_TOCDEFN)
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
      else
      else
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
      break;
      break;
    default:
    default:
      fprintf (stderr,
      fprintf (stderr,
              _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
              _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
              ppc_coff_howto_table[r_type].name,
              ppc_coff_howto_table[r_type].name,
              r_type);
              r_type);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    }
    }
 
 
  relent->howto = howto;
  relent->howto = howto;
}
}
 
 
static reloc_howto_type *
static reloc_howto_type *
coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     asection *sec;
     asection *sec;
     struct internal_reloc *rel;
     struct internal_reloc *rel;
     struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
     struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
     struct internal_syment *sym ATTRIBUTE_UNUSED;
     struct internal_syment *sym ATTRIBUTE_UNUSED;
     bfd_vma *addendp;
     bfd_vma *addendp;
{
{
  reloc_howto_type *howto;
  reloc_howto_type *howto;
 
 
  /* We can encode one of three things in the type field, aside from the
  /* We can encode one of three things in the type field, aside from the
     type:
     type:
     1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
     1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
        value, rather than an addition value
        value, rather than an addition value
     2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
     2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
        the branch is expected to be taken or not.
        the branch is expected to be taken or not.
     3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
     3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
     For now, we just strip this stuff to find the type, and ignore it other
     For now, we just strip this stuff to find the type, and ignore it other
     than that.  */
     than that.  */
 
 
  unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
  unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
  unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
  unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
  unsigned short junk    = EXTRACT_JUNK  (rel->r_type);
  unsigned short junk    = EXTRACT_JUNK  (rel->r_type);
 
 
  /* The masking process only slices off the bottom byte for r_type.  */
  /* The masking process only slices off the bottom byte for r_type.  */
  if (r_type > MAX_RELOC_INDEX)
  if (r_type > MAX_RELOC_INDEX)
    abort ();
    abort ();
 
 
  /* Check for absolute crap.  */
  /* Check for absolute crap.  */
  if (junk != 0)
  if (junk != 0)
    abort ();
    abort ();
 
 
  switch(r_type)
  switch(r_type)
    {
    {
    case IMAGE_REL_PPC_ADDR32NB:
    case IMAGE_REL_PPC_ADDR32NB:
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
      *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    case IMAGE_REL_PPC_TOCREL16:
    case IMAGE_REL_PPC_TOCREL16:
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      if (r_flags & IMAGE_REL_PPC_TOCDEFN)
      if (r_flags & IMAGE_REL_PPC_TOCDEFN)
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
      else
      else
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
      break;
      break;
    case IMAGE_REL_PPC_ADDR16:
    case IMAGE_REL_PPC_ADDR16:
    case IMAGE_REL_PPC_REL24:
    case IMAGE_REL_PPC_REL24:
    case IMAGE_REL_PPC_ADDR24:
    case IMAGE_REL_PPC_ADDR24:
    case IMAGE_REL_PPC_ADDR32:
    case IMAGE_REL_PPC_ADDR32:
    case IMAGE_REL_PPC_IFGLUE:
    case IMAGE_REL_PPC_IFGLUE:
    case IMAGE_REL_PPC_SECTION:
    case IMAGE_REL_PPC_SECTION:
    case IMAGE_REL_PPC_SECREL:
    case IMAGE_REL_PPC_SECREL:
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    case IMAGE_REL_PPC_IMGLUE:
    case IMAGE_REL_PPC_IMGLUE:
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    default:
    default:
      fprintf (stderr,
      fprintf (stderr,
              _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
              _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
              ppc_coff_howto_table[r_type].name,
              ppc_coff_howto_table[r_type].name,
              r_type);
              r_type);
      howto = ppc_coff_howto_table + r_type;
      howto = ppc_coff_howto_table + r_type;
      break;
      break;
    }
    }
 
 
  return howto;
  return howto;
}
}
 
 
/* A cheesy little macro to make the code a little more readable.  */
/* A cheesy little macro to make the code a little more readable.  */
#define HOW2MAP(bfd_rtype,ppc_rtype)  \
#define HOW2MAP(bfd_rtype,ppc_rtype)  \
 case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
 case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
 
 
static reloc_howto_type *ppc_coff_reloc_type_lookup
static reloc_howto_type *ppc_coff_reloc_type_lookup
PARAMS ((bfd *, bfd_reloc_code_real_type));
PARAMS ((bfd *, bfd_reloc_code_real_type));
 
 
static reloc_howto_type *
static reloc_howto_type *
ppc_coff_reloc_type_lookup (abfd, code)
ppc_coff_reloc_type_lookup (abfd, code)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd_reloc_code_real_type code;
     bfd_reloc_code_real_type code;
{
{
  switch (code)
  switch (code)
    {
    {
      HOW2MAP(BFD_RELOC_32_GOTOFF,    IMAGE_REL_PPC_IMGLUE);
      HOW2MAP(BFD_RELOC_32_GOTOFF,    IMAGE_REL_PPC_IMGLUE);
      HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
      HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
      HOW2MAP(BFD_RELOC_16,           IMAGE_REL_PPC_ADDR16);
      HOW2MAP(BFD_RELOC_16,           IMAGE_REL_PPC_ADDR16);
      HOW2MAP(BFD_RELOC_PPC_B26,      IMAGE_REL_PPC_REL24);
      HOW2MAP(BFD_RELOC_PPC_B26,      IMAGE_REL_PPC_REL24);
      HOW2MAP(BFD_RELOC_PPC_BA26,     IMAGE_REL_PPC_ADDR24);
      HOW2MAP(BFD_RELOC_PPC_BA26,     IMAGE_REL_PPC_ADDR24);
      HOW2MAP(BFD_RELOC_PPC_TOC16,    IMAGE_REL_PPC_TOCREL16);
      HOW2MAP(BFD_RELOC_PPC_TOC16,    IMAGE_REL_PPC_TOCREL16);
      HOW2MAP(BFD_RELOC_16_GOTOFF,    IMAGE_REL_PPC_TOCREL16_DEFN);
      HOW2MAP(BFD_RELOC_16_GOTOFF,    IMAGE_REL_PPC_TOCREL16_DEFN);
      HOW2MAP(BFD_RELOC_32,           IMAGE_REL_PPC_ADDR32);
      HOW2MAP(BFD_RELOC_32,           IMAGE_REL_PPC_ADDR32);
      HOW2MAP(BFD_RELOC_RVA,          IMAGE_REL_PPC_ADDR32NB);
      HOW2MAP(BFD_RELOC_RVA,          IMAGE_REL_PPC_ADDR32NB);
    default:
    default:
      return NULL;
      return NULL;
    }
    }
}
}
#undef HOW2MAP
#undef HOW2MAP
 
 
static reloc_howto_type *
static reloc_howto_type *
ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
                            const char *r_name)
                            const char *r_name)
{
{
  unsigned int i;
  unsigned int i;
 
 
  for (i = 0;
  for (i = 0;
       i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
       i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
       i++)
       i++)
    if (ppc_coff_howto_table[i].name != NULL
    if (ppc_coff_howto_table[i].name != NULL
        && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
        && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
      return &ppc_coff_howto_table[i];
      return &ppc_coff_howto_table[i];
 
 
  return NULL;
  return NULL;
}
}


/* Tailor coffcode.h -- macro heaven.  */
/* Tailor coffcode.h -- macro heaven.  */
 
 
#define RTYPE2HOWTO(cache_ptr, dst)  ppc_coff_rtype2howto (cache_ptr, dst)
#define RTYPE2HOWTO(cache_ptr, dst)  ppc_coff_rtype2howto (cache_ptr, dst)
 
 
/* We use the special COFF backend linker, with our own special touch.  */
/* We use the special COFF backend linker, with our own special touch.  */
 
 
#define coff_bfd_reloc_type_lookup   ppc_coff_reloc_type_lookup
#define coff_bfd_reloc_type_lookup   ppc_coff_reloc_type_lookup
#define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
#define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
#define coff_rtype_to_howto          coff_ppc_rtype_to_howto
#define coff_rtype_to_howto          coff_ppc_rtype_to_howto
#define coff_relocate_section        coff_ppc_relocate_section
#define coff_relocate_section        coff_ppc_relocate_section
#define coff_bfd_final_link          ppc_bfd_coff_final_link
#define coff_bfd_final_link          ppc_bfd_coff_final_link
 
 
#ifndef COFF_IMAGE_WITH_PE
#ifndef COFF_IMAGE_WITH_PE
#endif
#endif
 
 
#define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
#define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
 
 
#define COFF_PAGE_SIZE                       0x1000
#define COFF_PAGE_SIZE                       0x1000
 
 
/* FIXME: This controls some code that used to be in peicode.h and is
/* FIXME: This controls some code that used to be in peicode.h and is
   now in peigen.c.  It will not control the code in peigen.c.  If
   now in peigen.c.  It will not control the code in peigen.c.  If
   anybody wants to get this working, you will need to fix that.  */
   anybody wants to get this working, you will need to fix that.  */
#define POWERPC_LE_PE
#define POWERPC_LE_PE
 
 
#define COFF_SECTION_ALIGNMENT_ENTRIES \
#define COFF_SECTION_ALIGNMENT_ENTRIES \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
{ COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
 
 
#include "coffcode.h"
#include "coffcode.h"


#ifndef COFF_IMAGE_WITH_PE
#ifndef COFF_IMAGE_WITH_PE
 
 
static bfd_boolean ppc_do_last PARAMS ((bfd *));
static bfd_boolean ppc_do_last PARAMS ((bfd *));
static bfd *ppc_get_last PARAMS ((void));
static bfd *ppc_get_last PARAMS ((void));
 
 
static bfd_boolean
static bfd_boolean
ppc_do_last (abfd)
ppc_do_last (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  if (abfd == bfd_of_toc_owner)
  if (abfd == bfd_of_toc_owner)
    return TRUE;
    return TRUE;
  else
  else
    return FALSE;
    return FALSE;
}
}
 
 
static bfd *
static bfd *
ppc_get_last()
ppc_get_last()
{
{
  return bfd_of_toc_owner;
  return bfd_of_toc_owner;
}
}
 
 
/* This piece of machinery exists only to guarantee that the bfd that holds
/* This piece of machinery exists only to guarantee that the bfd that holds
   the toc section is written last.
   the toc section is written last.
 
 
   This does depend on bfd_make_section attaching a new section to the
   This does depend on bfd_make_section attaching a new section to the
   end of the section list for the bfd.
   end of the section list for the bfd.
 
 
   This is otherwise intended to be functionally the same as
   This is otherwise intended to be functionally the same as
   cofflink.c:_bfd_coff_final_link(). It is specifically different only
   cofflink.c:_bfd_coff_final_link(). It is specifically different only
   where the POWERPC_LE_PE macro modifies the code. It is left in as a
   where the POWERPC_LE_PE macro modifies the code. It is left in as a
   precise form of comment. krk@cygnus.com  */
   precise form of comment. krk@cygnus.com  */
 
 
/* Do the final link step.  */
/* Do the final link step.  */
 
 
bfd_boolean
bfd_boolean
ppc_bfd_coff_final_link (abfd, info)
ppc_bfd_coff_final_link (abfd, info)
     bfd *abfd;
     bfd *abfd;
     struct bfd_link_info *info;
     struct bfd_link_info *info;
{
{
  bfd_size_type symesz;
  bfd_size_type symesz;
  struct coff_final_link_info finfo;
  struct coff_final_link_info finfo;
  bfd_boolean debug_merge_allocated;
  bfd_boolean debug_merge_allocated;
  asection *o;
  asection *o;
  struct bfd_link_order *p;
  struct bfd_link_order *p;
  bfd_size_type max_sym_count;
  bfd_size_type max_sym_count;
  bfd_size_type max_lineno_count;
  bfd_size_type max_lineno_count;
  bfd_size_type max_reloc_count;
  bfd_size_type max_reloc_count;
  bfd_size_type max_output_reloc_count;
  bfd_size_type max_output_reloc_count;
  bfd_size_type max_contents_size;
  bfd_size_type max_contents_size;
  file_ptr rel_filepos;
  file_ptr rel_filepos;
  unsigned int relsz;
  unsigned int relsz;
  file_ptr line_filepos;
  file_ptr line_filepos;
  unsigned int linesz;
  unsigned int linesz;
  bfd *sub;
  bfd *sub;
  bfd_byte *external_relocs = NULL;
  bfd_byte *external_relocs = NULL;
  char strbuf[STRING_SIZE_SIZE];
  char strbuf[STRING_SIZE_SIZE];
  bfd_size_type amt;
  bfd_size_type amt;
 
 
  symesz = bfd_coff_symesz (abfd);
  symesz = bfd_coff_symesz (abfd);
 
 
  finfo.info = info;
  finfo.info = info;
  finfo.output_bfd = abfd;
  finfo.output_bfd = abfd;
  finfo.strtab = NULL;
  finfo.strtab = NULL;
  finfo.section_info = NULL;
  finfo.section_info = NULL;
  finfo.last_file_index = -1;
  finfo.last_file_index = -1;
  finfo.last_bf_index = -1;
  finfo.last_bf_index = -1;
  finfo.internal_syms = NULL;
  finfo.internal_syms = NULL;
  finfo.sec_ptrs = NULL;
  finfo.sec_ptrs = NULL;
  finfo.sym_indices = NULL;
  finfo.sym_indices = NULL;
  finfo.outsyms = NULL;
  finfo.outsyms = NULL;
  finfo.linenos = NULL;
  finfo.linenos = NULL;
  finfo.contents = NULL;
  finfo.contents = NULL;
  finfo.external_relocs = NULL;
  finfo.external_relocs = NULL;
  finfo.internal_relocs = NULL;
  finfo.internal_relocs = NULL;
  debug_merge_allocated = FALSE;
  debug_merge_allocated = FALSE;
 
 
  coff_data (abfd)->link_info = info;
  coff_data (abfd)->link_info = info;
 
 
  finfo.strtab = _bfd_stringtab_init ();
  finfo.strtab = _bfd_stringtab_init ();
  if (finfo.strtab == NULL)
  if (finfo.strtab == NULL)
    goto error_return;
    goto error_return;
 
 
  if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
  if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
    goto error_return;
    goto error_return;
  debug_merge_allocated = TRUE;
  debug_merge_allocated = TRUE;
 
 
  /* Compute the file positions for all the sections.  */
  /* Compute the file positions for all the sections.  */
  if (! abfd->output_has_begun)
  if (! abfd->output_has_begun)
    {
    {
      if (! bfd_coff_compute_section_file_positions (abfd))
      if (! bfd_coff_compute_section_file_positions (abfd))
        return FALSE;
        return FALSE;
    }
    }
 
 
  /* Count the line numbers and relocation entries required for the
  /* Count the line numbers and relocation entries required for the
     output file.  Set the file positions for the relocs.  */
     output file.  Set the file positions for the relocs.  */
  rel_filepos = obj_relocbase (abfd);
  rel_filepos = obj_relocbase (abfd);
  relsz = bfd_coff_relsz (abfd);
  relsz = bfd_coff_relsz (abfd);
  max_contents_size = 0;
  max_contents_size = 0;
  max_lineno_count = 0;
  max_lineno_count = 0;
  max_reloc_count = 0;
  max_reloc_count = 0;
 
 
  for (o = abfd->sections; o != NULL; o = o->next)
  for (o = abfd->sections; o != NULL; o = o->next)
    {
    {
      o->reloc_count = 0;
      o->reloc_count = 0;
      o->lineno_count = 0;
      o->lineno_count = 0;
 
 
      for (p = o->map_head.link_order; p != NULL; p = p->next)
      for (p = o->map_head.link_order; p != NULL; p = p->next)
        {
        {
          if (p->type == bfd_indirect_link_order)
          if (p->type == bfd_indirect_link_order)
            {
            {
              asection *sec;
              asection *sec;
 
 
              sec = p->u.indirect.section;
              sec = p->u.indirect.section;
 
 
              /* Mark all sections which are to be included in the
              /* Mark all sections which are to be included in the
                 link.  This will normally be every section.  We need
                 link.  This will normally be every section.  We need
                 to do this so that we can identify any sections which
                 to do this so that we can identify any sections which
                 the linker has decided to not include.  */
                 the linker has decided to not include.  */
              sec->linker_mark = TRUE;
              sec->linker_mark = TRUE;
 
 
              if (info->strip == strip_none
              if (info->strip == strip_none
                  || info->strip == strip_some)
                  || info->strip == strip_some)
                o->lineno_count += sec->lineno_count;
                o->lineno_count += sec->lineno_count;
 
 
              if (info->relocatable)
              if (info->relocatable)
                o->reloc_count += sec->reloc_count;
                o->reloc_count += sec->reloc_count;
 
 
              if (sec->rawsize > max_contents_size)
              if (sec->rawsize > max_contents_size)
                max_contents_size = sec->rawsize;
                max_contents_size = sec->rawsize;
              if (sec->size > max_contents_size)
              if (sec->size > max_contents_size)
                max_contents_size = sec->size;
                max_contents_size = sec->size;
              if (sec->lineno_count > max_lineno_count)
              if (sec->lineno_count > max_lineno_count)
                max_lineno_count = sec->lineno_count;
                max_lineno_count = sec->lineno_count;
              if (sec->reloc_count > max_reloc_count)
              if (sec->reloc_count > max_reloc_count)
                max_reloc_count = sec->reloc_count;
                max_reloc_count = sec->reloc_count;
            }
            }
          else if (info->relocatable
          else if (info->relocatable
                   && (p->type == bfd_section_reloc_link_order
                   && (p->type == bfd_section_reloc_link_order
                       || p->type == bfd_symbol_reloc_link_order))
                       || p->type == bfd_symbol_reloc_link_order))
            ++o->reloc_count;
            ++o->reloc_count;
        }
        }
      if (o->reloc_count == 0)
      if (o->reloc_count == 0)
        o->rel_filepos = 0;
        o->rel_filepos = 0;
      else
      else
        {
        {
          o->flags |= SEC_RELOC;
          o->flags |= SEC_RELOC;
          o->rel_filepos = rel_filepos;
          o->rel_filepos = rel_filepos;
          rel_filepos += o->reloc_count * relsz;
          rel_filepos += o->reloc_count * relsz;
        }
        }
    }
    }
 
 
  /* If doing a relocatable link, allocate space for the pointers we
  /* If doing a relocatable link, allocate space for the pointers we
     need to keep.  */
     need to keep.  */
  if (info->relocatable)
  if (info->relocatable)
    {
    {
      unsigned int i;
      unsigned int i;
 
 
      /* We use section_count + 1, rather than section_count, because
      /* We use section_count + 1, rather than section_count, because
         the target_index fields are 1 based.  */
         the target_index fields are 1 based.  */
      amt = abfd->section_count + 1;
      amt = abfd->section_count + 1;
      amt *= sizeof (struct coff_link_section_info);
      amt *= sizeof (struct coff_link_section_info);
      finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
      finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
 
 
      if (finfo.section_info == NULL)
      if (finfo.section_info == NULL)
        goto error_return;
        goto error_return;
 
 
      for (i = 0; i <= abfd->section_count; i++)
      for (i = 0; i <= abfd->section_count; i++)
        {
        {
          finfo.section_info[i].relocs = NULL;
          finfo.section_info[i].relocs = NULL;
          finfo.section_info[i].rel_hashes = NULL;
          finfo.section_info[i].rel_hashes = NULL;
        }
        }
    }
    }
 
 
  /* We now know the size of the relocs, so we can determine the file
  /* We now know the size of the relocs, so we can determine the file
     positions of the line numbers.  */
     positions of the line numbers.  */
  line_filepos = rel_filepos;
  line_filepos = rel_filepos;
  linesz = bfd_coff_linesz (abfd);
  linesz = bfd_coff_linesz (abfd);
  max_output_reloc_count = 0;
  max_output_reloc_count = 0;
 
 
  for (o = abfd->sections; o != NULL; o = o->next)
  for (o = abfd->sections; o != NULL; o = o->next)
    {
    {
      if (o->lineno_count == 0)
      if (o->lineno_count == 0)
        o->line_filepos = 0;
        o->line_filepos = 0;
      else
      else
        {
        {
          o->line_filepos = line_filepos;
          o->line_filepos = line_filepos;
          line_filepos += o->lineno_count * linesz;
          line_filepos += o->lineno_count * linesz;
        }
        }
 
 
      if (o->reloc_count != 0)
      if (o->reloc_count != 0)
        {
        {
          /* We don't know the indices of global symbols until we have
          /* We don't know the indices of global symbols until we have
             written out all the local symbols.  For each section in
             written out all the local symbols.  For each section in
             the output file, we keep an array of pointers to hash
             the output file, we keep an array of pointers to hash
             table entries.  Each entry in the array corresponds to a
             table entries.  Each entry in the array corresponds to a
             reloc.  When we find a reloc against a global symbol, we
             reloc.  When we find a reloc against a global symbol, we
             set the corresponding entry in this array so that we can
             set the corresponding entry in this array so that we can
             fix up the symbol index after we have written out all the
             fix up the symbol index after we have written out all the
             local symbols.
             local symbols.
 
 
             Because of this problem, we also keep the relocs in
             Because of this problem, we also keep the relocs in
             memory until the end of the link.  This wastes memory,
             memory until the end of the link.  This wastes memory,
             but only when doing a relocatable link, which is not the
             but only when doing a relocatable link, which is not the
             common case.  */
             common case.  */
          BFD_ASSERT (info->relocatable);
          BFD_ASSERT (info->relocatable);
          amt = o->reloc_count;
          amt = o->reloc_count;
          amt *= sizeof (struct internal_reloc);
          amt *= sizeof (struct internal_reloc);
          finfo.section_info[o->target_index].relocs =
          finfo.section_info[o->target_index].relocs =
            (struct internal_reloc *) bfd_malloc (amt);
            (struct internal_reloc *) bfd_malloc (amt);
          amt = o->reloc_count;
          amt = o->reloc_count;
          amt *= sizeof (struct coff_link_hash_entry *);
          amt *= sizeof (struct coff_link_hash_entry *);
          finfo.section_info[o->target_index].rel_hashes =
          finfo.section_info[o->target_index].rel_hashes =
            (struct coff_link_hash_entry **) bfd_malloc (amt);
            (struct coff_link_hash_entry **) bfd_malloc (amt);
          if (finfo.section_info[o->target_index].relocs == NULL
          if (finfo.section_info[o->target_index].relocs == NULL
              || finfo.section_info[o->target_index].rel_hashes == NULL)
              || finfo.section_info[o->target_index].rel_hashes == NULL)
            goto error_return;
            goto error_return;
 
 
          if (o->reloc_count > max_output_reloc_count)
          if (o->reloc_count > max_output_reloc_count)
            max_output_reloc_count = o->reloc_count;
            max_output_reloc_count = o->reloc_count;
        }
        }
 
 
      /* Reset the reloc and lineno counts, so that we can use them to
      /* Reset the reloc and lineno counts, so that we can use them to
         count the number of entries we have output so far.  */
         count the number of entries we have output so far.  */
      o->reloc_count = 0;
      o->reloc_count = 0;
      o->lineno_count = 0;
      o->lineno_count = 0;
    }
    }
 
 
  obj_sym_filepos (abfd) = line_filepos;
  obj_sym_filepos (abfd) = line_filepos;
 
 
  /* Figure out the largest number of symbols in an input BFD.  Take
  /* Figure out the largest number of symbols in an input BFD.  Take
     the opportunity to clear the output_has_begun fields of all the
     the opportunity to clear the output_has_begun fields of all the
     input BFD's.  */
     input BFD's.  */
  max_sym_count = 0;
  max_sym_count = 0;
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
    {
    {
      bfd_size_type sz;
      bfd_size_type sz;
 
 
      sub->output_has_begun = FALSE;
      sub->output_has_begun = FALSE;
      sz = obj_raw_syment_count (sub);
      sz = obj_raw_syment_count (sub);
      if (sz > max_sym_count)
      if (sz > max_sym_count)
        max_sym_count = sz;
        max_sym_count = sz;
    }
    }
 
 
  /* Allocate some buffers used while linking.  */
  /* Allocate some buffers used while linking.  */
  amt = max_sym_count * sizeof (struct internal_syment);
  amt = max_sym_count * sizeof (struct internal_syment);
  finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
  finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
  amt = max_sym_count * sizeof (asection *);
  amt = max_sym_count * sizeof (asection *);
  finfo.sec_ptrs = (asection **) bfd_malloc (amt);
  finfo.sec_ptrs = (asection **) bfd_malloc (amt);
  amt = max_sym_count * sizeof (long);
  amt = max_sym_count * sizeof (long);
  finfo.sym_indices = (long *) bfd_malloc (amt);
  finfo.sym_indices = (long *) bfd_malloc (amt);
  amt = (max_sym_count + 1) * symesz;
  amt = (max_sym_count + 1) * symesz;
  finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
  finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
  amt = max_lineno_count * bfd_coff_linesz (abfd);
  amt = max_lineno_count * bfd_coff_linesz (abfd);
  finfo.linenos = (bfd_byte *) bfd_malloc (amt);
  finfo.linenos = (bfd_byte *) bfd_malloc (amt);
  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
  finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
  finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
  if (! info->relocatable)
  if (! info->relocatable)
    {
    {
      amt = max_reloc_count * sizeof (struct internal_reloc);
      amt = max_reloc_count * sizeof (struct internal_reloc);
      finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
      finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
    }
    }
  if ((finfo.internal_syms == NULL && max_sym_count > 0)
  if ((finfo.internal_syms == NULL && max_sym_count > 0)
      || (finfo.sec_ptrs == NULL && max_sym_count > 0)
      || (finfo.sec_ptrs == NULL && max_sym_count > 0)
      || (finfo.sym_indices == NULL && max_sym_count > 0)
      || (finfo.sym_indices == NULL && max_sym_count > 0)
      || finfo.outsyms == NULL
      || finfo.outsyms == NULL
      || (finfo.linenos == NULL && max_lineno_count > 0)
      || (finfo.linenos == NULL && max_lineno_count > 0)
      || (finfo.contents == NULL && max_contents_size > 0)
      || (finfo.contents == NULL && max_contents_size > 0)
      || (finfo.external_relocs == NULL && max_reloc_count > 0)
      || (finfo.external_relocs == NULL && max_reloc_count > 0)
      || (! info->relocatable
      || (! info->relocatable
          && finfo.internal_relocs == NULL
          && finfo.internal_relocs == NULL
          && max_reloc_count > 0))
          && max_reloc_count > 0))
    goto error_return;
    goto error_return;
 
 
  /* We now know the position of everything in the file, except that
  /* 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
     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
     know where the string table starts.  We just build the string
     table in memory as we go along.  We process all the relocations
     table in memory as we go along.  We process all the relocations
     for a single input file at once.  */
     for a single input file at once.  */
  obj_raw_syment_count (abfd) = 0;
  obj_raw_syment_count (abfd) = 0;
 
 
  if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
  if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
    {
    {
      if (! bfd_coff_start_final_link (abfd, info))
      if (! bfd_coff_start_final_link (abfd, info))
        goto error_return;
        goto error_return;
    }
    }
 
 
  for (o = abfd->sections; o != NULL; o = o->next)
  for (o = abfd->sections; o != NULL; o = o->next)
    {
    {
      for (p = o->map_head.link_order; p != NULL; p = p->next)
      for (p = o->map_head.link_order; p != NULL; p = p->next)
        {
        {
          if (p->type == bfd_indirect_link_order
          if (p->type == bfd_indirect_link_order
              && (bfd_get_flavour (p->u.indirect.section->owner)
              && (bfd_get_flavour (p->u.indirect.section->owner)
                  == bfd_target_coff_flavour))
                  == bfd_target_coff_flavour))
            {
            {
              sub = p->u.indirect.section->owner;
              sub = p->u.indirect.section->owner;
#ifdef POWERPC_LE_PE
#ifdef POWERPC_LE_PE
              if (! sub->output_has_begun && !ppc_do_last(sub))
              if (! sub->output_has_begun && !ppc_do_last(sub))
#else
#else
              if (! sub->output_has_begun)
              if (! sub->output_has_begun)
#endif
#endif
                {
                {
                  if (! _bfd_coff_link_input_bfd (&finfo, sub))
                  if (! _bfd_coff_link_input_bfd (&finfo, sub))
                    goto error_return;
                    goto error_return;
                  sub->output_has_begun = TRUE;
                  sub->output_has_begun = TRUE;
                }
                }
            }
            }
          else if (p->type == bfd_section_reloc_link_order
          else if (p->type == bfd_section_reloc_link_order
                   || p->type == bfd_symbol_reloc_link_order)
                   || p->type == bfd_symbol_reloc_link_order)
            {
            {
              if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
              if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
                goto error_return;
                goto error_return;
            }
            }
          else
          else
            {
            {
              if (! _bfd_default_link_order (abfd, info, o, p))
              if (! _bfd_default_link_order (abfd, info, o, p))
                goto error_return;
                goto error_return;
            }
            }
        }
        }
    }
    }
 
 
#ifdef POWERPC_LE_PE
#ifdef POWERPC_LE_PE
  {
  {
    bfd* last_one = ppc_get_last();
    bfd* last_one = ppc_get_last();
    if (last_one)
    if (last_one)
      {
      {
        if (! _bfd_coff_link_input_bfd (&finfo, last_one))
        if (! _bfd_coff_link_input_bfd (&finfo, last_one))
          goto error_return;
          goto error_return;
      }
      }
    last_one->output_has_begun = TRUE;
    last_one->output_has_begun = TRUE;
  }
  }
#endif
#endif
 
 
  /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
  /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
  coff_debug_merge_hash_table_free (&finfo.debug_merge);
  coff_debug_merge_hash_table_free (&finfo.debug_merge);
  debug_merge_allocated = FALSE;
  debug_merge_allocated = FALSE;
 
 
  if (finfo.internal_syms != NULL)
  if (finfo.internal_syms != NULL)
    {
    {
      free (finfo.internal_syms);
      free (finfo.internal_syms);
      finfo.internal_syms = NULL;
      finfo.internal_syms = NULL;
    }
    }
  if (finfo.sec_ptrs != NULL)
  if (finfo.sec_ptrs != NULL)
    {
    {
      free (finfo.sec_ptrs);
      free (finfo.sec_ptrs);
      finfo.sec_ptrs = NULL;
      finfo.sec_ptrs = NULL;
    }
    }
  if (finfo.sym_indices != NULL)
  if (finfo.sym_indices != NULL)
    {
    {
      free (finfo.sym_indices);
      free (finfo.sym_indices);
      finfo.sym_indices = NULL;
      finfo.sym_indices = NULL;
    }
    }
  if (finfo.linenos != NULL)
  if (finfo.linenos != NULL)
    {
    {
      free (finfo.linenos);
      free (finfo.linenos);
      finfo.linenos = NULL;
      finfo.linenos = NULL;
    }
    }
  if (finfo.contents != NULL)
  if (finfo.contents != NULL)
    {
    {
      free (finfo.contents);
      free (finfo.contents);
      finfo.contents = NULL;
      finfo.contents = NULL;
    }
    }
  if (finfo.external_relocs != NULL)
  if (finfo.external_relocs != NULL)
    {
    {
      free (finfo.external_relocs);
      free (finfo.external_relocs);
      finfo.external_relocs = NULL;
      finfo.external_relocs = NULL;
    }
    }
  if (finfo.internal_relocs != NULL)
  if (finfo.internal_relocs != NULL)
    {
    {
      free (finfo.internal_relocs);
      free (finfo.internal_relocs);
      finfo.internal_relocs = NULL;
      finfo.internal_relocs = NULL;
    }
    }
 
 
  /* The value of the last C_FILE symbol is supposed to be the symbol
  /* The value of the last C_FILE symbol is supposed to be the symbol
     index of the first external symbol.  Write it out again if
     index of the first external symbol.  Write it out again if
     necessary.  */
     necessary.  */
  if (finfo.last_file_index != -1
  if (finfo.last_file_index != -1
      && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
      && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
    {
    {
      file_ptr pos;
      file_ptr pos;
 
 
      finfo.last_file.n_value = obj_raw_syment_count (abfd);
      finfo.last_file.n_value = obj_raw_syment_count (abfd);
      bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
      bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
                             (PTR) finfo.outsyms);
                             (PTR) finfo.outsyms);
      pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
      pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
      if (bfd_seek (abfd, pos, SEEK_SET) != 0
      if (bfd_seek (abfd, pos, SEEK_SET) != 0
          || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
          || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
        return FALSE;
        return FALSE;
    }
    }
 
 
  /* Write out the global symbols.  */
  /* Write out the global symbols.  */
  finfo.failed = FALSE;
  finfo.failed = FALSE;
  coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
  coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
                           (PTR) &finfo);
                           (PTR) &finfo);
  if (finfo.failed)
  if (finfo.failed)
    goto error_return;
    goto error_return;
 
 
  /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
  /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
  if (finfo.outsyms != NULL)
  if (finfo.outsyms != NULL)
    {
    {
      free (finfo.outsyms);
      free (finfo.outsyms);
      finfo.outsyms = NULL;
      finfo.outsyms = NULL;
    }
    }
 
 
  if (info->relocatable)
  if (info->relocatable)
    {
    {
      /* Now that we have written out all the global symbols, we know
      /* Now that we have written out all the global symbols, we know
         the symbol indices to use for relocs against them, and we can
         the symbol indices to use for relocs against them, and we can
         finally write out the relocs.  */
         finally write out the relocs.  */
      amt = max_output_reloc_count * relsz;
      amt = max_output_reloc_count * relsz;
      external_relocs = (bfd_byte *) bfd_malloc (amt);
      external_relocs = (bfd_byte *) bfd_malloc (amt);
      if (external_relocs == NULL)
      if (external_relocs == NULL)
        goto error_return;
        goto error_return;
 
 
      for (o = abfd->sections; o != NULL; o = o->next)
      for (o = abfd->sections; o != NULL; o = o->next)
        {
        {
          struct internal_reloc *irel;
          struct internal_reloc *irel;
          struct internal_reloc *irelend;
          struct internal_reloc *irelend;
          struct coff_link_hash_entry **rel_hash;
          struct coff_link_hash_entry **rel_hash;
          bfd_byte *erel;
          bfd_byte *erel;
 
 
          if (o->reloc_count == 0)
          if (o->reloc_count == 0)
            continue;
            continue;
 
 
          irel = finfo.section_info[o->target_index].relocs;
          irel = finfo.section_info[o->target_index].relocs;
          irelend = irel + o->reloc_count;
          irelend = irel + o->reloc_count;
          rel_hash = finfo.section_info[o->target_index].rel_hashes;
          rel_hash = finfo.section_info[o->target_index].rel_hashes;
          erel = external_relocs;
          erel = external_relocs;
          for (; irel < irelend; irel++, rel_hash++, erel += relsz)
          for (; irel < irelend; irel++, rel_hash++, erel += relsz)
            {
            {
              if (*rel_hash != NULL)
              if (*rel_hash != NULL)
                {
                {
                  BFD_ASSERT ((*rel_hash)->indx >= 0);
                  BFD_ASSERT ((*rel_hash)->indx >= 0);
                  irel->r_symndx = (*rel_hash)->indx;
                  irel->r_symndx = (*rel_hash)->indx;
                }
                }
              bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
              bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
            }
            }
 
 
          amt = relsz * o->reloc_count;
          amt = relsz * o->reloc_count;
          if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
          if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
              || bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt)
              || bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt)
            goto error_return;
            goto error_return;
        }
        }
 
 
      free (external_relocs);
      free (external_relocs);
      external_relocs = NULL;
      external_relocs = NULL;
    }
    }
 
 
  /* Free up the section information.  */
  /* Free up the section information.  */
  if (finfo.section_info != NULL)
  if (finfo.section_info != NULL)
    {
    {
      unsigned int i;
      unsigned int i;
 
 
      for (i = 0; i < abfd->section_count; i++)
      for (i = 0; i < abfd->section_count; i++)
        {
        {
          if (finfo.section_info[i].relocs != NULL)
          if (finfo.section_info[i].relocs != NULL)
            free (finfo.section_info[i].relocs);
            free (finfo.section_info[i].relocs);
          if (finfo.section_info[i].rel_hashes != NULL)
          if (finfo.section_info[i].rel_hashes != NULL)
            free (finfo.section_info[i].rel_hashes);
            free (finfo.section_info[i].rel_hashes);
        }
        }
      free (finfo.section_info);
      free (finfo.section_info);
      finfo.section_info = NULL;
      finfo.section_info = NULL;
    }
    }
 
 
  /* If we have optimized stabs strings, output them.  */
  /* If we have optimized stabs strings, output them.  */
  if (coff_hash_table (info)->stab_info.stabstr != NULL)
  if (coff_hash_table (info)->stab_info.stabstr != NULL)
    {
    {
      if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
      if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
        return FALSE;
        return FALSE;
    }
    }
 
 
  /* Write out the string table.  */
  /* Write out the string table.  */
  if (obj_raw_syment_count (abfd) != 0)
  if (obj_raw_syment_count (abfd) != 0)
    {
    {
      file_ptr pos;
      file_ptr pos;
 
 
      pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
      pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
      if (bfd_seek (abfd, pos, SEEK_SET) != 0)
      if (bfd_seek (abfd, pos, SEEK_SET) != 0)
        return FALSE;
        return FALSE;
 
 
#if STRING_SIZE_SIZE == 4
#if STRING_SIZE_SIZE == 4
      H_PUT_32 (abfd,
      H_PUT_32 (abfd,
                _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
                _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
                strbuf);
                strbuf);
#else
#else
 #error Change H_PUT_32 above
 #error Change H_PUT_32 above
#endif
#endif
 
 
      if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
      if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
          != STRING_SIZE_SIZE)
          != STRING_SIZE_SIZE)
        return FALSE;
        return FALSE;
 
 
      if (! _bfd_stringtab_emit (abfd, finfo.strtab))
      if (! _bfd_stringtab_emit (abfd, finfo.strtab))
        return FALSE;
        return FALSE;
    }
    }
 
 
  _bfd_stringtab_free (finfo.strtab);
  _bfd_stringtab_free (finfo.strtab);
 
 
  /* Setting bfd_get_symcount to 0 will cause write_object_contents to
  /* Setting bfd_get_symcount to 0 will cause write_object_contents to
     not try to write out the symbols.  */
     not try to write out the symbols.  */
  bfd_get_symcount (abfd) = 0;
  bfd_get_symcount (abfd) = 0;
 
 
  return TRUE;
  return TRUE;
 
 
 error_return:
 error_return:
  if (debug_merge_allocated)
  if (debug_merge_allocated)
    coff_debug_merge_hash_table_free (&finfo.debug_merge);
    coff_debug_merge_hash_table_free (&finfo.debug_merge);
  if (finfo.strtab != NULL)
  if (finfo.strtab != NULL)
    _bfd_stringtab_free (finfo.strtab);
    _bfd_stringtab_free (finfo.strtab);
  if (finfo.section_info != NULL)
  if (finfo.section_info != NULL)
    {
    {
      unsigned int i;
      unsigned int i;
 
 
      for (i = 0; i < abfd->section_count; i++)
      for (i = 0; i < abfd->section_count; i++)
        {
        {
          if (finfo.section_info[i].relocs != NULL)
          if (finfo.section_info[i].relocs != NULL)
            free (finfo.section_info[i].relocs);
            free (finfo.section_info[i].relocs);
          if (finfo.section_info[i].rel_hashes != NULL)
          if (finfo.section_info[i].rel_hashes != NULL)
            free (finfo.section_info[i].rel_hashes);
            free (finfo.section_info[i].rel_hashes);
        }
        }
      free (finfo.section_info);
      free (finfo.section_info);
    }
    }
  if (finfo.internal_syms != NULL)
  if (finfo.internal_syms != NULL)
    free (finfo.internal_syms);
    free (finfo.internal_syms);
  if (finfo.sec_ptrs != NULL)
  if (finfo.sec_ptrs != NULL)
    free (finfo.sec_ptrs);
    free (finfo.sec_ptrs);
  if (finfo.sym_indices != NULL)
  if (finfo.sym_indices != NULL)
    free (finfo.sym_indices);
    free (finfo.sym_indices);
  if (finfo.outsyms != NULL)
  if (finfo.outsyms != NULL)
    free (finfo.outsyms);
    free (finfo.outsyms);
  if (finfo.linenos != NULL)
  if (finfo.linenos != NULL)
    free (finfo.linenos);
    free (finfo.linenos);
  if (finfo.contents != NULL)
  if (finfo.contents != NULL)
    free (finfo.contents);
    free (finfo.contents);
  if (finfo.external_relocs != NULL)
  if (finfo.external_relocs != NULL)
    free (finfo.external_relocs);
    free (finfo.external_relocs);
  if (finfo.internal_relocs != NULL)
  if (finfo.internal_relocs != NULL)
    free (finfo.internal_relocs);
    free (finfo.internal_relocs);
  if (external_relocs != NULL)
  if (external_relocs != NULL)
    free (external_relocs);
    free (external_relocs);
  return FALSE;
  return FALSE;
}
}
#endif
#endif


/* Forward declaration for use by alternative_target field.  */
/* Forward declaration for use by alternative_target field.  */
#ifdef TARGET_BIG_SYM
#ifdef TARGET_BIG_SYM
extern const bfd_target TARGET_BIG_SYM;
extern const bfd_target TARGET_BIG_SYM;
#endif
#endif
 
 
/* The transfer vectors that lead the outside world to all of the above.  */
/* The transfer vectors that lead the outside world to all of the above.  */
 
 
#ifdef TARGET_LITTLE_SYM
#ifdef TARGET_LITTLE_SYM
const bfd_target TARGET_LITTLE_SYM =
const bfd_target TARGET_LITTLE_SYM =
{
{
  TARGET_LITTLE_NAME,           /* name or coff-arm-little */
  TARGET_LITTLE_NAME,           /* name or coff-arm-little */
  bfd_target_coff_flavour,
  bfd_target_coff_flavour,
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
  BFD_ENDIAN_LITTLE,            /* data byte order is little */
  BFD_ENDIAN_LITTLE,            /* header byte order is little */
  BFD_ENDIAN_LITTLE,            /* header byte order is little */
 
 
  (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
  (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
   HAS_LINENO | HAS_DEBUG |
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
 
#ifndef COFF_WITH_PE
#ifndef COFF_WITH_PE
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
#else
#else
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
#endif
#endif
 
 
  0,                             /* leading char */
  0,                             /* leading char */
  '/',                          /* ar_pad_char */
  '/',                          /* ar_pad_char */
  15,                           /* ar_max_namelen??? FIXMEmgo */
  15,                           /* ar_max_namelen??? FIXMEmgo */
 
 
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
 
 
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
 
 
  {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
  {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
     bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
     bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
     bfd_false},
     bfd_false},
  {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
  {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
     _bfd_write_archive_contents, bfd_false},
     _bfd_write_archive_contents, bfd_false},
 
 
  BFD_JUMP_TABLE_GENERIC (coff),
  BFD_JUMP_TABLE_GENERIC (coff),
  BFD_JUMP_TABLE_COPY (coff),
  BFD_JUMP_TABLE_COPY (coff),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
  BFD_JUMP_TABLE_SYMBOLS (coff),
  BFD_JUMP_TABLE_SYMBOLS (coff),
  BFD_JUMP_TABLE_RELOCS (coff),
  BFD_JUMP_TABLE_RELOCS (coff),
  BFD_JUMP_TABLE_WRITE (coff),
  BFD_JUMP_TABLE_WRITE (coff),
  BFD_JUMP_TABLE_LINK (coff),
  BFD_JUMP_TABLE_LINK (coff),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
 
  /* Alternative_target.  */
  /* Alternative_target.  */
#ifdef TARGET_BIG_SYM
#ifdef TARGET_BIG_SYM
  & TARGET_BIG_SYM,
  & TARGET_BIG_SYM,
#else
#else
  NULL,
  NULL,
#endif
#endif
 
 
  COFF_SWAP_TABLE
  COFF_SWAP_TABLE
};
};
#endif
#endif
 
 
#ifdef TARGET_BIG_SYM
#ifdef TARGET_BIG_SYM
const bfd_target TARGET_BIG_SYM =
const bfd_target TARGET_BIG_SYM =
{
{
  TARGET_BIG_NAME,
  TARGET_BIG_NAME,
  bfd_target_coff_flavour,
  bfd_target_coff_flavour,
  BFD_ENDIAN_BIG,               /* data byte order is big */
  BFD_ENDIAN_BIG,               /* data byte order is big */
  BFD_ENDIAN_BIG,               /* header byte order is big */
  BFD_ENDIAN_BIG,               /* header byte order is big */
 
 
  (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
  (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
   HAS_LINENO | HAS_DEBUG |
   HAS_LINENO | HAS_DEBUG |
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
 
#ifndef COFF_WITH_PE
#ifndef COFF_WITH_PE
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
#else
#else
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
   | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
#endif
#endif
 
 
  0,                             /* leading char */
  0,                             /* leading char */
  '/',                          /* ar_pad_char */
  '/',                          /* ar_pad_char */
  15,                           /* ar_max_namelen??? FIXMEmgo */
  15,                           /* ar_max_namelen??? FIXMEmgo */
 
 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
 
 
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
  bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
 
 
  {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
  {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
     bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
     bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
  {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
     bfd_false},
     bfd_false},
  {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
  {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
     _bfd_write_archive_contents, bfd_false},
     _bfd_write_archive_contents, bfd_false},
 
 
  BFD_JUMP_TABLE_GENERIC (coff),
  BFD_JUMP_TABLE_GENERIC (coff),
  BFD_JUMP_TABLE_COPY (coff),
  BFD_JUMP_TABLE_COPY (coff),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
  BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
  BFD_JUMP_TABLE_SYMBOLS (coff),
  BFD_JUMP_TABLE_SYMBOLS (coff),
  BFD_JUMP_TABLE_RELOCS (coff),
  BFD_JUMP_TABLE_RELOCS (coff),
  BFD_JUMP_TABLE_WRITE (coff),
  BFD_JUMP_TABLE_WRITE (coff),
  BFD_JUMP_TABLE_LINK (coff),
  BFD_JUMP_TABLE_LINK (coff),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
 
  /* Alternative_target.  */
  /* Alternative_target.  */
#ifdef TARGET_LITTLE_SYM
#ifdef TARGET_LITTLE_SYM
  & TARGET_LITTLE_SYM,
  & TARGET_LITTLE_SYM,
#else
#else
  NULL,
  NULL,
#endif
#endif
 
 
  COFF_SWAP_TABLE
  COFF_SWAP_TABLE
};
};
 
 
#endif
#endif
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.