bfd/coff-ppc.c

   1 /* BFD back-end for PowerPC Microsoft Portable Executable files.
   2    Copyright (C) 1990-2017 Free Software Foundation, Inc.
   3
   4    Original version pieced together by Kim Knuttila (krk@cygnus.com)
   5
   6    There is nothing new under the sun. This file draws a lot on other
   7    coff files, in particular, those for the rs/6000, alpha, mips, and
   8    intel backends, and the PE work for the arm.
   9
  10    This file is part of BFD, the Binary File Descriptor library.
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software
  24    Foundation, 51 Franklin Street - Fifth Floor,
  25    Boston, MA 02110-1301, USA.  */
  26
  27 /* Current State:
  28    - objdump works
  29    - relocs generated by gas
  30    - ld will link files, but they do not run.
  31    - dlltool will not produce correct output in some .reloc cases, and will
  32      not produce the right glue code for dll function calls.  */
  33
  34 #include "sysdep.h"
  35 #include "bfd.h"
  36 #include "libbfd.h"
  37
  38 #include "coff/powerpc.h"
  39 #include "coff/internal.h"
  40
  41 #include "coff/pe.h"
  42
  43 #ifdef BADMAG
  44 #undef BADMAG
  45 #endif
  46
  47 #define BADMAG(x) PPCBADMAG(x)
  48
  49 #include "libcoff.h"
  50
  51 /* This file is compiled more than once, but we only compile the
  52    final_link routine once.  */
  53 extern bfd_boolean ppc_bfd_coff_final_link (bfd *, struct bfd_link_info *);
  54 extern void dump_toc (void *);
  55
  56 /* The toc is a set of bfd_vma fields. We use the fact that valid
  57    addresses are even (i.e. the bit representing "1" is off) to allow
  58    us to encode a little extra information in the field
  59    - Unallocated addresses are initialized to 1.
  60    - Allocated addresses are even numbers.
  61    The first time we actually write a reference to the toc in the bfd,
  62    we want to record that fact in a fixup file (if it is asked for), so
  63    we keep track of whether or not an address has been written by marking
  64    the low order bit with a "1" upon writing.  */
  65
  66 #define SET_UNALLOCATED(x)  ((x) = 1)
  67 #define IS_UNALLOCATED(x)   ((x) == 1)
  68
  69 #define IS_WRITTEN(x)       ((x) & 1)
  70 #define MARK_AS_WRITTEN(x)  ((x) |= 1)
  71 #define MAKE_ADDR_AGAIN(x)  ((x) &= ~1)
  72
  73 /* Turn on this check if you suspect something amiss in the hash tables.  */
  74 #ifdef DEBUG_HASH
  75
  76 /* Need a 7 char string for an eye catcher.  */
  77 #define EYE "krkjunk"
  78
  79 #define HASH_CHECK_DCL char eye_catcher[8];
  80 #define HASH_CHECK_INIT(ret)      strcpy(ret->eye_catcher, EYE)
  81 #define HASH_CHECK(addr) \
  82  if (strcmp (addr->eye_catcher, EYE) != 0) \
  83   { \
  84     fprintf (stderr,\
  85     /* xgettext: c-format */ \
  86     _("File %s, line %d, Hash check failure, bad eye %8s\n"), \
  87     __FILE__, __LINE__, addr->eye_catcher); \
  88     abort (); \
  89  }
  90
  91 #else
  92
  93 #define HASH_CHECK_DCL
  94 #define HASH_CHECK_INIT(ret)
  95 #define HASH_CHECK(addr)
  96
  97 #endif
  98
  99 /* In order not to add an int to every hash table item for every coff
 100    linker, we define our own hash table, derived from the coff one.  */
 101
 102 /* PE linker hash table entries.  */
 103
 104 struct ppc_coff_link_hash_entry
 105 {
 106   struct coff_link_hash_entry root; /* First entry, as required.  */
 107
 108   /* As we wonder around the relocs, we'll keep the assigned toc_offset
 109      here.  */
 110   bfd_vma toc_offset;               /* Our addition, as required.  */
 111   int symbol_is_glue;
 112   unsigned long int glue_insn;
 113
 114   HASH_CHECK_DCL
 115 };
 116
 117 /* PE linker hash table.  */
 118
 119 struct ppc_coff_link_hash_table
 120 {
 121   struct coff_link_hash_table root; /* First entry, as required.  */
 122 };
 123
 124 /* Routine to create an entry in the link hash table.  */
 125
 126 static struct bfd_hash_entry *
 127 ppc_coff_link_hash_newfunc (struct bfd_hash_entry * entry,
 128                             struct bfd_hash_table * table,
 129                             const char * string)
 130 {
 131   struct ppc_coff_link_hash_entry *ret =
 132     (struct ppc_coff_link_hash_entry *) entry;
 133
 134   /* Allocate the structure if it has not already been allocated by a
 135      subclass.  */
 136   if (ret == (struct ppc_coff_link_hash_entry *) NULL)
 137     ret = (struct ppc_coff_link_hash_entry *)
 138       bfd_hash_allocate (table,
 139                          sizeof (struct ppc_coff_link_hash_entry));
 140
 141   if (ret == (struct ppc_coff_link_hash_entry *) NULL)
 142     return NULL;
 143
 144   /* Call the allocation method of the superclass.  */
 145   ret = ((struct ppc_coff_link_hash_entry *)
 146          _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 147                                       table, string));
 148
 149   if (ret)
 150     {
 151       /* Initialize the local fields.  */
 152       SET_UNALLOCATED (ret->toc_offset);
 153       ret->symbol_is_glue = 0;
 154       ret->glue_insn = 0;
 155
 156       HASH_CHECK_INIT (ret);
 157     }
 158
 159   return (struct bfd_hash_entry *) ret;
 160 }
 161
 162 /* Initialize a PE linker hash table.  */
 163
 164 static bfd_boolean
 165 ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table,
 166                                bfd *abfd,
 167                                struct bfd_hash_entry *(*newfunc)
 168                                  (struct bfd_hash_entry *,
 169                                   struct bfd_hash_table *,
 170                                   const char *),
 171                                unsigned int entsize)
 172 {
 173   return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize);
 174 }
 175
 176 /* Create a PE linker hash table.  */
 177
 178 static struct bfd_link_hash_table *
 179 ppc_coff_link_hash_table_create (bfd *abfd)
 180 {
 181   struct ppc_coff_link_hash_table *ret;
 182   bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table);
 183
 184   ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt);
 185   if (ret == NULL)
 186     return NULL;
 187   if (!ppc_coff_link_hash_table_init (ret, abfd,
 188                                       ppc_coff_link_hash_newfunc,
 189                                       sizeof (struct ppc_coff_link_hash_entry)))
 190     {
 191       free (ret);
 192       return (struct bfd_link_hash_table *) NULL;
 193     }
 194   return &ret->root.root;
 195 }
 196
 197 /* Now, tailor coffcode.h to use our hash stuff.  */
 198
 199 #define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create
 200 \f
 201 /* The nt loader points the toc register to &toc + 32768, in order to
 202    use the complete range of a 16-bit displacement. We have to adjust
 203    for this when we fix up loads displaced off the toc reg.  */
 204 #define TOC_LOAD_ADJUSTMENT (-32768)
 205 #define TOC_SECTION_NAME ".private.toc"
 206
 207 /* The main body of code is in coffcode.h.  */
 208
 209 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 210
 211 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 212    from smaller values.  Start with zero, widen, *then* decrement.  */
 213 #define MINUS_ONE       (((bfd_vma)0) - 1)
 214
 215 /* These should definitely go in a header file somewhere...  */
 216
 217 /* NOP */
 218 #define IMAGE_REL_PPC_ABSOLUTE          0x0000
 219
 220 /* 64-bit address */
 221 #define IMAGE_REL_PPC_ADDR64            0x0001
 222
 223 /* 32-bit address */
 224 #define IMAGE_REL_PPC_ADDR32            0x0002
 225
 226 /* 26-bit address, shifted left 2 (branch absolute) */
 227 #define IMAGE_REL_PPC_ADDR24            0x0003
 228
 229 /* 16-bit address */
 230 #define IMAGE_REL_PPC_ADDR16            0x0004
 231
 232 /* 16-bit address, shifted left 2 (load doubleword) */
 233 #define IMAGE_REL_PPC_ADDR14            0x0005
 234
 235 /* 26-bit PC-relative offset, shifted left 2 (branch relative) */
 236 #define IMAGE_REL_PPC_REL24             0x0006
 237
 238 /* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
 239 #define IMAGE_REL_PPC_REL14             0x0007
 240
 241 /* 16-bit offset from TOC base */
 242 #define IMAGE_REL_PPC_TOCREL16          0x0008
 243
 244 /* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
 245 #define IMAGE_REL_PPC_TOCREL14          0x0009
 246
 247 /* 32-bit addr w/o image base */
 248 #define IMAGE_REL_PPC_ADDR32NB          0x000A
 249
 250 /* va of containing section (as in an image sectionhdr) */
 251 #define IMAGE_REL_PPC_SECREL            0x000B
 252
 253 /* sectionheader number */
 254 #define IMAGE_REL_PPC_SECTION           0x000C
 255
 256 /* substitute TOC restore instruction iff symbol is glue code */
 257 #define IMAGE_REL_PPC_IFGLUE            0x000D
 258
 259 /* symbol is glue code; virtual address is TOC restore instruction */
 260 #define IMAGE_REL_PPC_IMGLUE            0x000E
 261
 262 /* va of containing section (limited to 16 bits) */
 263 #define IMAGE_REL_PPC_SECREL16          0x000F
 264
 265 /* Stuff to handle immediate data when the number of bits in the
 266    data is greater than the number of bits in the immediate field
 267    We need to do (usually) 32 bit arithmetic on 16 bit chunks.  */
 268 #define IMAGE_REL_PPC_REFHI             0x0010
 269 #define IMAGE_REL_PPC_REFLO             0x0011
 270 #define IMAGE_REL_PPC_PAIR              0x0012
 271
 272 /* This is essentially the same as tocrel16, with TOCDEFN assumed.  */
 273 #define IMAGE_REL_PPC_TOCREL16_DEFN     0x0013
 274
 275 /* Flag bits in IMAGE_RELOCATION.TYPE.  */
 276
 277 /* Subtract reloc value rather than adding it.  */
 278 #define IMAGE_REL_PPC_NEG               0x0100
 279
 280 /* Fix branch prediction bit to predict branch taken.  */
 281 #define IMAGE_REL_PPC_BRTAKEN           0x0200
 282
 283 /* Fix branch prediction bit to predict branch not taken.  */
 284 #define IMAGE_REL_PPC_BRNTAKEN          0x0400
 285
 286 /* TOC slot defined in file (or, data in toc).  */
 287 #define IMAGE_REL_PPC_TOCDEFN           0x0800
 288
 289 /* Masks to isolate above values in IMAGE_RELOCATION.Type.  */
 290 #define IMAGE_REL_PPC_TYPEMASK          0x00FF
 291 #define IMAGE_REL_PPC_FLAGMASK          0x0F00
 292
 293 #define EXTRACT_TYPE(x)                 ((x) & IMAGE_REL_PPC_TYPEMASK)
 294 #define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
 295 #define EXTRACT_JUNK(x)  \
 296            ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))
 297 \f
 298 /* Static helper functions to make relocation work.  */
 299 /* (Work In Progress) */
 300
 301 static bfd_reloc_status_type ppc_refhi_reloc
 302   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 303 static bfd_reloc_status_type ppc_pair_reloc
 304   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 305 static bfd_reloc_status_type ppc_toc16_reloc
 306   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 307 static bfd_reloc_status_type ppc_section_reloc
 308   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 309 static bfd_reloc_status_type ppc_secrel_reloc
 310   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 311 static bfd_reloc_status_type ppc_imglue_reloc
 312   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 313
 314 /* FIXME: It'll take a while to get through all of these. I only need a few to
 315    get us started, so those I'll make sure work. Those marked FIXME are either
 316    completely unverified or have a specific unknown marked in the comment.  */
 317
 318 /* Relocation entries for Windows/NT on PowerPC.
 319
 320    From the document "" we find the following listed as used relocs:
 321
 322      ABSOLUTE       : The noop
 323      ADDR[64|32|16] : fields that hold addresses in data fields or the
 324                       16 bit displacement field on a load/store.
 325      ADDR[24|14]    : fields that hold addresses in branch and cond
 326                       branches. These represent [26|16] bit addresses.
 327                       The low order 2 bits are preserved.
 328      REL[24|14]     : branches relative to the Instruction Address
 329                       register. These represent [26|16] bit addresses,
 330                       as before. The instruction field will be zero, and
 331                       the address of the SYM will be inserted at link time.
 332      TOCREL16       : 16 bit displacement field referring to a slot in
 333                       toc.
 334      TOCREL14       : 16 bit displacement field, similar to REL14 or ADDR14.
 335      ADDR32NB       : 32 bit address relative to the virtual origin.
 336                       (On the alpha, this is always a linker generated thunk)
 337                       (i.e. 32bit addr relative to the image base)
 338      SECREL         : The value is relative to the start of the section
 339                       containing the symbol.
 340      SECTION        : access to the header containing the item. Supports the
 341                       codeview debugger.
 342
 343    In particular, note that the document does not indicate that the
 344    relocations listed in the header file are used.  */
 345
 346
 347 static reloc_howto_type ppc_coff_howto_table[] =
 348 {
 349   /* IMAGE_REL_PPC_ABSOLUTE 0x0000   NOP */
 350   /* Unused: */
 351   HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
 352          0,                      /* rightshift */
 353          0,                      /* size (0 = byte, 1 = short, 2 = long) */
 354          0,                      /* bitsize */
 355          FALSE,                  /* pc_relative */
 356          0,                      /* bitpos */
 357          complain_overflow_dont, /* dont complain_on_overflow */
 358          0,                      /* special_function */
 359          "ABSOLUTE",             /* name */
 360          FALSE,                  /* partial_inplace */
 361          0x00,                   /* src_mask */
 362          0x00,                   /* dst_mask */
 363          FALSE),                 /* pcrel_offset */
 364
 365   /* IMAGE_REL_PPC_ADDR64 0x0001  64-bit address */
 366   /* Unused: */
 367   HOWTO(IMAGE_REL_PPC_ADDR64,    /* type */
 368         0,                       /* rightshift */
 369         3,                       /* size (0 = byte, 1 = short, 2 = long) */
 370         64,                      /* bitsize */
 371         FALSE,                   /* pc_relative */
 372         0,                       /* bitpos */
 373         complain_overflow_bitfield,      /* complain_on_overflow */
 374         0,                       /* special_function */
 375         "ADDR64",               /* name */
 376         TRUE,                    /* partial_inplace */
 377         MINUS_ONE,               /* src_mask */
 378         MINUS_ONE,               /* dst_mask */
 379         FALSE),                 /* pcrel_offset */
 380
 381   /* IMAGE_REL_PPC_ADDR32 0x0002  32-bit address */
 382   /* Used: */
 383   HOWTO (IMAGE_REL_PPC_ADDR32,  /* type */
 384          0,                     /* rightshift */
 385          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 386          32,                    /* bitsize */
 387          FALSE,                 /* pc_relative */
 388          0,                     /* bitpos */
 389          complain_overflow_bitfield, /* complain_on_overflow */
 390          0,                     /* special_function */
 391          "ADDR32",              /* name */
 392          TRUE,                  /* partial_inplace */
 393          0xffffffff,            /* src_mask */
 394          0xffffffff,            /* dst_mask */
 395          FALSE),                /* pcrel_offset */
 396
 397   /* IMAGE_REL_PPC_ADDR24 0x0003  26-bit address, shifted left 2 (branch absolute) */
 398   /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
 399   /* Of course, That's the IBM approved bit numbering, which is not what */
 400   /* anyone else uses.... The li field is in bit 2 thru 25 */
 401   /* Used: */
 402   HOWTO (IMAGE_REL_PPC_ADDR24,  /* type */
 403          0,                     /* rightshift */
 404          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 405          26,                    /* bitsize */
 406          FALSE,                 /* pc_relative */
 407          0,                     /* bitpos */
 408          complain_overflow_bitfield, /* complain_on_overflow */
 409          0,                     /* special_function */
 410          "ADDR24",              /* name */
 411          TRUE,                  /* partial_inplace */
 412          0x07fffffc,            /* src_mask */
 413          0x07fffffc,            /* dst_mask */
 414          FALSE),                /* pcrel_offset */
 415
 416   /* IMAGE_REL_PPC_ADDR16 0x0004  16-bit address */
 417   /* Used: */
 418   HOWTO (IMAGE_REL_PPC_ADDR16,  /* type */
 419          0,                     /* rightshift */
 420          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          16,                    /* bitsize */
 422          FALSE,                 /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          0,                     /* special_function */
 426          "ADDR16",              /* name */
 427          TRUE,                  /* partial_inplace */
 428          0xffff,                /* src_mask */
 429          0xffff,                /* dst_mask */
 430          FALSE),                /* pcrel_offset */
 431
 432   /* IMAGE_REL_PPC_ADDR14 0x0005 */
 433   /*  16-bit address, shifted left 2 (load doubleword) */
 434   /* FIXME: the mask is likely wrong, and the bit position may be as well */
 435   /* Unused: */
 436   HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
 437          1,                     /* rightshift */
 438          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          FALSE,                 /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          0,                     /* special_function */
 444          "ADDR16",              /* name */
 445          TRUE,                  /* partial_inplace */
 446          0xffff,                /* src_mask */
 447          0xffff,                /* dst_mask */
 448          FALSE),                /* pcrel_offset */
 449
 450   /* IMAGE_REL_PPC_REL24 0x0006 */
 451   /*   26-bit PC-relative offset, shifted left 2 (branch relative) */
 452   /* Used: */
 453   HOWTO (IMAGE_REL_PPC_REL24,   /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          26,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          0,                     /* special_function */
 461          "REL24",               /* name */
 462          TRUE,                  /* partial_inplace */
 463          0x3fffffc,             /* src_mask */
 464          0x3fffffc,             /* dst_mask */
 465          FALSE),                /* pcrel_offset */
 466
 467   /* IMAGE_REL_PPC_REL14 0x0007 */
 468   /*   16-bit PC-relative offset, shifted left 2 (br cond relative) */
 469   /* FIXME: the mask is likely wrong, and the bit position may be as well */
 470   /* FIXME: how does it know how far to shift? */
 471   /* Unused: */
 472   HOWTO (IMAGE_REL_PPC_ADDR14,  /* type */
 473          1,                     /* rightshift */
 474          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 475          16,                    /* bitsize */
 476          FALSE,                 /* pc_relative */
 477          0,                     /* bitpos */
 478          complain_overflow_signed, /* complain_on_overflow */
 479          0,                     /* special_function */
 480          "ADDR16",              /* name */
 481          TRUE,                  /* partial_inplace */
 482          0xffff,                /* src_mask */
 483          0xffff,                /* dst_mask */
 484          TRUE),                 /* pcrel_offset */
 485
 486   /* IMAGE_REL_PPC_TOCREL16 0x0008 */
 487   /*   16-bit offset from TOC base */
 488   /* Used: */
 489   HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
 490          0,                     /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_dont, /* complain_on_overflow */
 496          ppc_toc16_reloc,       /* special_function */
 497          "TOCREL16",            /* name */
 498          FALSE,                 /* partial_inplace */
 499          0xffff,                /* src_mask */
 500          0xffff,                /* dst_mask */
 501          FALSE),                /* pcrel_offset */
 502
 503   /* IMAGE_REL_PPC_TOCREL14 0x0009 */
 504   /*   16-bit offset from TOC base, shifted left 2 (load doubleword) */
 505   /* Unused: */
 506   HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
 507          1,                     /* rightshift */
 508          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 509          16,                    /* bitsize */
 510          FALSE,                 /* pc_relative */
 511          0,                     /* bitpos */
 512          complain_overflow_signed, /* complain_on_overflow */
 513          0,                     /* special_function */
 514          "TOCREL14",            /* name */
 515          FALSE,                 /* partial_inplace */
 516          0xffff,                /* src_mask */
 517          0xffff,                /* dst_mask */
 518          FALSE),                /* pcrel_offset */
 519
 520   /* IMAGE_REL_PPC_ADDR32NB 0x000A */
 521   /*   32-bit addr w/ image base */
 522   /* Unused: */
 523   HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
 524          0,                     /* rightshift */
 525          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          32,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed, /* complain_on_overflow */
 530          0,                     /* special_function */
 531          "ADDR32NB",            /* name */
 532          TRUE,                  /* partial_inplace */
 533          0xffffffff,            /* src_mask */
 534          0xffffffff,            /* dst_mask */
 535          FALSE),                 /* pcrel_offset */
 536
 537   /* IMAGE_REL_PPC_SECREL 0x000B */
 538   /*   va of containing section (as in an image sectionhdr) */
 539   /* Unused: */
 540   HOWTO (IMAGE_REL_PPC_SECREL,/* type */
 541          0,                     /* rightshift */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          32,                    /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_signed, /* complain_on_overflow */
 547          ppc_secrel_reloc,      /* special_function */
 548          "SECREL",              /* name */
 549          TRUE,                  /* partial_inplace */
 550          0xffffffff,            /* src_mask */
 551          0xffffffff,            /* dst_mask */
 552          TRUE),                 /* pcrel_offset */
 553
 554   /* IMAGE_REL_PPC_SECTION 0x000C */
 555   /*   sectionheader number */
 556   /* Unused: */
 557   HOWTO (IMAGE_REL_PPC_SECTION,/* type */
 558          0,                     /* rightshift */
 559          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 560          32,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_signed, /* complain_on_overflow */
 564          ppc_section_reloc,     /* special_function */
 565          "SECTION",             /* name */
 566          TRUE,                  /* partial_inplace */
 567          0xffffffff,            /* src_mask */
 568          0xffffffff,            /* dst_mask */
 569          TRUE),                 /* pcrel_offset */
 570
 571   /* IMAGE_REL_PPC_IFGLUE 0x000D */
 572   /*   substitute TOC restore instruction iff symbol is glue code */
 573   /* Used: */
 574   HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
 575          0,                     /* rightshift */
 576          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 577          32,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_signed, /* complain_on_overflow */
 581          0,                     /* special_function */
 582          "IFGLUE",              /* name */
 583          TRUE,                  /* partial_inplace */
 584          0xffffffff,            /* src_mask */
 585          0xffffffff,            /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* IMAGE_REL_PPC_IMGLUE 0x000E */
 589   /*   symbol is glue code; virtual address is TOC restore instruction */
 590   /* Unused: */
 591   HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
 592          0,                     /* rightshift */
 593          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 594          32,                    /* bitsize */
 595          FALSE,                 /* pc_relative */
 596          0,                     /* bitpos */
 597          complain_overflow_dont, /* complain_on_overflow */
 598          ppc_imglue_reloc,      /* special_function */
 599          "IMGLUE",              /* name */
 600          FALSE,                 /* partial_inplace */
 601          0xffffffff,            /* src_mask */
 602          0xffffffff,            /* dst_mask */
 603          FALSE),                 /* pcrel_offset */
 604
 605   /* IMAGE_REL_PPC_SECREL16 0x000F */
 606   /*   va of containing section (limited to 16 bits) */
 607   /* Unused: */
 608   HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
 609          0,                     /* rightshift */
 610          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 611          16,                    /* bitsize */
 612          FALSE,                 /* pc_relative */
 613          0,                     /* bitpos */
 614          complain_overflow_signed, /* complain_on_overflow */
 615          0,                     /* special_function */
 616          "SECREL16",            /* name */
 617          TRUE,                  /* partial_inplace */
 618          0xffff,                /* src_mask */
 619          0xffff,                /* dst_mask */
 620          TRUE),                 /* pcrel_offset */
 621
 622   /* IMAGE_REL_PPC_REFHI             0x0010 */
 623   /* Unused: */
 624   HOWTO (IMAGE_REL_PPC_REFHI,   /* type */
 625          0,                     /* rightshift */
 626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 627          16,                    /* bitsize */
 628          FALSE,                 /* pc_relative */
 629          0,                     /* bitpos */
 630          complain_overflow_signed, /* complain_on_overflow */
 631          ppc_refhi_reloc,       /* special_function */
 632          "REFHI",               /* name */
 633          TRUE,                  /* partial_inplace */
 634          0xffffffff,            /* src_mask */
 635          0xffffffff,            /* dst_mask */
 636          FALSE),                 /* pcrel_offset */
 637
 638   /* IMAGE_REL_PPC_REFLO             0x0011 */
 639   /* Unused: */
 640   HOWTO (IMAGE_REL_PPC_REFLO,   /* type */
 641          0,                     /* rightshift */
 642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 643          16,                    /* bitsize */
 644          FALSE,                 /* pc_relative */
 645          0,                     /* bitpos */
 646          complain_overflow_signed, /* complain_on_overflow */
 647          ppc_refhi_reloc,       /* special_function */
 648          "REFLO",               /* name */
 649          TRUE,                  /* partial_inplace */
 650          0xffffffff,            /* src_mask */
 651          0xffffffff,            /* dst_mask */
 652          FALSE),                /* pcrel_offset */
 653
 654   /* IMAGE_REL_PPC_PAIR              0x0012 */
 655   /* Unused: */
 656   HOWTO (IMAGE_REL_PPC_PAIR,    /* type */
 657          0,                     /* rightshift */
 658          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 659          16,                    /* bitsize */
 660          FALSE,                 /* pc_relative */
 661          0,                     /* bitpos */
 662          complain_overflow_signed, /* complain_on_overflow */
 663          ppc_pair_reloc,        /* special_function */
 664          "PAIR",                /* name */
 665          TRUE,                  /* partial_inplace */
 666          0xffffffff,            /* src_mask */
 667          0xffffffff,            /* dst_mask */
 668          FALSE),                /* pcrel_offset */
 669
 670   /* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */
 671   /*   16-bit offset from TOC base, without causing a definition */
 672   /* Used: */
 673   HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */
 674          0,                     /* rightshift */
 675          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          16,                    /* bitsize */
 677          FALSE,                 /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_dont, /* complain_on_overflow */
 680          0,                     /* special_function */
 681          "TOCREL16, TOCDEFN",   /* name */
 682          FALSE,                 /* partial_inplace */
 683          0xffff,                /* src_mask */
 684          0xffff,                /* dst_mask */
 685          FALSE),                /* pcrel_offset */
 686
 687 };
 688 \f
 689 /* Some really cheezy macros that can be turned on to test stderr :-)  */
 690
 691 #ifdef DEBUG_RELOC
 692 #define UN_IMPL(x)                                           \
 693 {                                                            \
 694    static int i;                                             \
 695    if (i == 0)                                               \
 696      {                                                       \
 697        i = 1;                                                \
 698        fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \
 699      }                                                       \
 700 }
 701
 702 #define DUMP_RELOC(n,r)                              \
 703 {                                                    \
 704    fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \
 705            n, (*(r->sym_ptr_ptr))->name,             \
 706            r->address, r->addend);                   \
 707 }
 708
 709 /* Given a reloc name, n, and a pointer to an internal_reloc,
 710    dump out interesting information on the contents
 711
 712 #define n_name          _n._n_name
 713 #define n_zeroes        _n._n_n._n_zeroes
 714 #define n_offset        _n._n_n._n_offset  */
 715
 716 #define DUMP_RELOC2(n,r)                                \
 717 {                                                       \
 718    fprintf (stderr,"%s sym %d, r_vaddr %d %s\n",        \
 719            n, r->r_symndx, r->r_vaddr,                  \
 720            (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
 721            ?" ":" TOCDEFN"  );                          \
 722 }
 723
 724 #else
 725 #define UN_IMPL(x)
 726 #define DUMP_RELOC(n,r)
 727 #define DUMP_RELOC2(n,r)
 728 #endif
 729 \f
 730 /* TOC construction and management routines.  */
 731
 732 /* This file is compiled twice, and these variables are defined in one
 733    of the compilations.  FIXME: This is confusing and weird.  Also,
 734    BFD should not use global variables.  */
 735 extern bfd *    bfd_of_toc_owner;
 736 extern long int global_toc_size;
 737 extern long int import_table_size;
 738 extern long int first_thunk_address;
 739 extern long int thunk_size;
 740
 741 enum toc_type
 742 {
 743   default_toc,
 744   toc_32,
 745   toc_64
 746 };
 747
 748 enum ref_category
 749 {
 750   priv,
 751   pub,
 752   tocdata
 753 };
 754
 755 struct list_ele
 756 {
 757   struct list_ele *next;
 758   bfd_vma addr;
 759   enum ref_category cat;
 760   int offset;
 761   const char *name;
 762 };
 763
 764 extern struct list_ele *head;
 765 extern struct list_ele *tail;
 766
 767 static void
 768 record_toc (asection *toc_section,
 769             bfd_signed_vma our_toc_offset,
 770             enum ref_category cat,
 771             const char *name)
 772 {
 773   /* Add this entry to our toc addr-offset-name list.  */
 774   bfd_size_type amt = sizeof (struct list_ele);
 775   struct list_ele *t = (struct list_ele *) bfd_malloc (amt);
 776
 777   if (t == NULL)
 778     abort ();
 779   t->next = 0;
 780   t->offset = our_toc_offset;
 781   t->name = name;
 782   t->cat = cat;
 783   t->addr = toc_section->output_offset + our_toc_offset;
 784
 785   if (head == 0)
 786     {
 787       head = t;
 788       tail = t;
 789     }
 790   else
 791     {
 792       tail->next = t;
 793       tail = t;
 794     }
 795 }
 796
 797 #ifdef COFF_IMAGE_WITH_PE
 798
 799 /* Record a toc offset against a symbol.  */
 800 static bfd_boolean
 801 ppc_record_toc_entry (bfd *abfd,
 802                       struct bfd_link_info *info ATTRIBUTE_UNUSED,
 803                       asection *sec ATTRIBUTE_UNUSED,
 804                       int sym,
 805                       enum toc_type toc_kind ATTRIBUTE_UNUSED)
 806 {
 807   struct ppc_coff_link_hash_entry *h;
 808   int *local_syms;
 809
 810   h = 0;
 811
 812   h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
 813   if (h != 0)
 814     {
 815       HASH_CHECK(h);
 816     }
 817
 818   if (h == 0)
 819     {
 820       local_syms = obj_coff_local_toc_table(abfd);
 821
 822       if (local_syms == 0)
 823         {
 824           unsigned int i;
 825           bfd_size_type amt;
 826
 827           /* allocate a table */
 828           amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
 829           local_syms = (int *) bfd_zalloc (abfd, amt);
 830           if (local_syms == 0)
 831             return FALSE;
 832           obj_coff_local_toc_table (abfd) = local_syms;
 833
 834           for (i = 0; i < obj_raw_syment_count (abfd); ++i)
 835             {
 836               SET_UNALLOCATED (local_syms[i]);
 837             }
 838         }
 839
 840       if (IS_UNALLOCATED(local_syms[sym]))
 841         {
 842           local_syms[sym] = global_toc_size;
 843           global_toc_size += 4;
 844
 845           /* The size must fit in a 16-bit displacement.  */
 846           if (global_toc_size > 65535)
 847             {
 848               _bfd_error_handler (_("TOC overflow"));
 849               bfd_set_error (bfd_error_file_too_big);
 850               return FALSE;
 851             }
 852         }
 853     }
 854   else
 855     {
 856       /* Check to see if there's a toc slot allocated. If not, do it
 857          here. It will be used in relocate_section.  */
 858       if (IS_UNALLOCATED(h->toc_offset))
 859         {
 860           h->toc_offset = global_toc_size;
 861           global_toc_size += 4;
 862
 863           /* The size must fit in a 16-bit displacement.  */
 864           if (global_toc_size >= 65535)
 865             {
 866               _bfd_error_handler (_("TOC overflow"));
 867               bfd_set_error (bfd_error_file_too_big);
 868               return FALSE;
 869             }
 870         }
 871     }
 872
 873   return TRUE;
 874 }
 875
 876 /* Record a toc offset against a symbol.  */
 877 static void
 878 ppc_mark_symbol_as_glue (bfd *abfd,
 879                          int sym,
 880                          struct internal_reloc *rel)
 881 {
 882   struct ppc_coff_link_hash_entry *h;
 883
 884   h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
 885
 886   HASH_CHECK(h);
 887
 888   h->symbol_is_glue = 1;
 889   h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
 890
 891   return;
 892 }
 893
 894 #endif /* COFF_IMAGE_WITH_PE */
 895 \f
 896 /* Return TRUE if this relocation should
 897    appear in the output .reloc section.  */
 898
 899 static bfd_boolean
 900 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
 901             reloc_howto_type *howto)
 902 {
 903   return
 904     (! howto->pc_relative)
 905       && (howto->type != IMAGE_REL_PPC_ADDR32NB)
 906       && (howto->type != IMAGE_REL_PPC_TOCREL16)
 907       && (howto->type != IMAGE_REL_PPC_IMGLUE)
 908       && (howto->type != IMAGE_REL_PPC_IFGLUE)
 909       && (howto->type != IMAGE_REL_PPC_SECREL)
 910       && (howto->type != IMAGE_REL_PPC_SECTION)
 911       && (howto->type != IMAGE_REL_PPC_SECREL16)
 912       && (howto->type != IMAGE_REL_PPC_REFHI)
 913       && (howto->type != IMAGE_REL_PPC_REFLO)
 914       && (howto->type != IMAGE_REL_PPC_PAIR)
 915       && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
 916 }
 917
 918 static bfd_boolean
 919 write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
 920 {
 921   if (coff_data (obfd)->pe)
 922      addr -= pe_data (obfd)->pe_opthdr.ImageBase;
 923   if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
 924     return TRUE;
 925
 926   bfd_set_error (bfd_error_system_call);
 927   return FALSE;
 928 }
 929
 930 /* The reloc processing routine for the optimized COFF linker.  */
 931
 932 static bfd_boolean
 933 coff_ppc_relocate_section (bfd *output_bfd,
 934                            struct bfd_link_info *info,
 935                            bfd *input_bfd,
 936                            asection *input_section,
 937                            bfd_byte *contents,
 938                            struct internal_reloc *relocs,
 939                            struct internal_syment *syms,
 940                            asection **sections)
 941 {
 942   struct internal_reloc *rel;
 943   struct internal_reloc *relend;
 944   asection *toc_section = 0;
 945   bfd_vma relocation;
 946   reloc_howto_type *howto = 0;
 947
 948   /* If we are performing a relocatable link, we don't need to do a
 949      thing.  The caller will take care of adjusting the reloc
 950      addresses and symbol indices.  */
 951   if (bfd_link_relocatable (info))
 952     return TRUE;
 953
 954   rel = relocs;
 955   relend = rel + input_section->reloc_count;
 956   for (; rel < relend; rel++)
 957     {
 958       long symndx;
 959       struct ppc_coff_link_hash_entry *h;
 960       struct internal_syment *sym;
 961       bfd_vma val;
 962
 963       asection *sec;
 964       bfd_reloc_status_type rstat;
 965       bfd_byte *loc;
 966
 967       unsigned short r_type  = EXTRACT_TYPE (rel->r_type);
 968       unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
 969
 970       symndx = rel->r_symndx;
 971       loc = contents + rel->r_vaddr - input_section->vma;
 972
 973       /* FIXME: check bounds on r_type */
 974       howto = ppc_coff_howto_table + r_type;
 975
 976       if (symndx == -1)
 977         {
 978           h = NULL;
 979           sym = NULL;
 980         }
 981       else
 982         {
 983           h = (struct ppc_coff_link_hash_entry *)
 984             (obj_coff_sym_hashes (input_bfd)[symndx]);
 985           if (h != 0)
 986             {
 987               HASH_CHECK(h);
 988             }
 989
 990           sym = syms + symndx;
 991         }
 992
 993       if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
 994         {
 995           /* An IMGLUE reloc must have a name. Something is very wrong.  */
 996           abort ();
 997         }
 998
 999       sec = NULL;
1000       val = 0;
1001
1002       /* FIXME: PAIR unsupported in the following code.  */
1003       if (h == NULL)
1004         {
1005           if (symndx == -1)
1006             sec = bfd_abs_section_ptr;
1007           else
1008             {
1009               sec = sections[symndx];
1010               val = (sec->output_section->vma
1011                      + sec->output_offset
1012                      + sym->n_value);
1013               if (! obj_pe (output_bfd))
1014                 val -= sec->vma;
1015             }
1016         }
1017       else
1018         {
1019           HASH_CHECK(h);
1020
1021           if (h->root.root.type == bfd_link_hash_defined
1022               || h->root.root.type == bfd_link_hash_defweak)
1023             {
1024               sec = h->root.root.u.def.section;
1025               val = (h->root.root.u.def.value
1026                      + sec->output_section->vma
1027                      + sec->output_offset);
1028             }
1029           else
1030             (*info->callbacks->undefined_symbol)
1031               (info, h->root.root.root.string, input_bfd, input_section,
1032                rel->r_vaddr - input_section->vma, TRUE);
1033         }
1034
1035       rstat = bfd_reloc_ok;
1036
1037       /* Each case must do its own relocation, setting rstat appropriately.  */
1038       switch (r_type)
1039         {
1040         default:
1041           _bfd_error_handler
1042             /* xgettext: c-format */
1043             (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
1044           bfd_set_error (bfd_error_bad_value);
1045           return FALSE;
1046         case IMAGE_REL_PPC_TOCREL16:
1047           {
1048             bfd_signed_vma our_toc_offset;
1049             int fixit;
1050
1051             DUMP_RELOC2(howto->name, rel);
1052
1053             if (toc_section == 0)
1054               {
1055                 toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1056                                                        TOC_SECTION_NAME);
1057
1058                 if ( toc_section == NULL )
1059                   {
1060                     /* There is no toc section. Something is very wrong.  */
1061                     abort ();
1062                   }
1063               }
1064
1065             /* Amazing bit tricks present. As we may have seen earlier, we
1066                use the 1 bit to tell us whether or not a toc offset has been
1067                allocated. Now that they've all been allocated, we will use
1068                the 1 bit to tell us if we've written this particular toc
1069                entry out.  */
1070             fixit = FALSE;
1071             if (h == 0)
1072               {
1073                 /* It is a file local symbol.  */
1074                 int *local_toc_table;
1075                 char name[SYMNMLEN + 1];
1076
1077                 sym = syms + symndx;
1078                 strncpy (name, sym->_n._n_name, SYMNMLEN);
1079                 name[SYMNMLEN] = '\0';
1080
1081                 local_toc_table = obj_coff_local_toc_table(input_bfd);
1082                 our_toc_offset = local_toc_table[symndx];
1083
1084                 if (IS_WRITTEN(our_toc_offset))
1085                   {
1086                     /* If it has been written out, it is marked with the
1087                        1 bit. Fix up our offset, but do not write it out
1088                        again.  */
1089                     MAKE_ADDR_AGAIN(our_toc_offset);
1090                   }
1091                 else
1092                   {
1093                     /* Write out the toc entry.  */
1094                     record_toc (toc_section, our_toc_offset, priv,
1095                                 strdup (name));
1096
1097                     bfd_put_32 (output_bfd, val,
1098                                toc_section->contents + our_toc_offset);
1099
1100                     MARK_AS_WRITTEN(local_toc_table[symndx]);
1101                     fixit = TRUE;
1102                   }
1103               }
1104             else
1105               {
1106                 const char *name = h->root.root.root.string;
1107                 our_toc_offset = h->toc_offset;
1108
1109                 if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
1110                     == IMAGE_REL_PPC_TOCDEFN )
1111                   {
1112                     /* This is unbelievable cheese. Some knowledgable asm
1113                        hacker has decided to use r2 as a base for loading
1114                        a value. He/She does this by setting the tocdefn bit,
1115                        and not supplying a toc definition. The behaviour is
1116                        then to use the difference between the value of the
1117                        symbol and the actual location of the toc as the toc
1118                        index.
1119
1120                        In fact, what is usually happening is, because the
1121                        Import Address Table is mapped immediately following
1122                        the toc, some trippy library code trying for speed on
1123                        dll linkage, takes advantage of that and considers
1124                        the IAT to be part of the toc, thus saving a load.  */
1125
1126                     our_toc_offset = val - (toc_section->output_section->vma
1127                                             + toc_section->output_offset);
1128
1129                     /* The size must still fit in a 16-bit displacement.  */
1130                     if ((bfd_vma) our_toc_offset >= 65535)
1131                       {
1132                         _bfd_error_handler
1133                           /* xgettext: c-format */
1134                           (_("%B: Relocation for %s of %lx exceeds "
1135                              "Toc size limit"),
1136                            input_bfd, name,
1137                            (unsigned long) our_toc_offset);
1138                         bfd_set_error (bfd_error_bad_value);
1139                         return FALSE;
1140                       }
1141
1142                     record_toc (toc_section, our_toc_offset, pub,
1143                                 strdup (name));
1144                   }
1145                 else if (IS_WRITTEN (our_toc_offset))
1146                   {
1147                     /* If it has been written out, it is marked with the
1148                        1 bit. Fix up our offset, but do not write it out
1149                        again.  */
1150                     MAKE_ADDR_AGAIN(our_toc_offset);
1151                   }
1152                 else
1153                   {
1154                     record_toc(toc_section, our_toc_offset, pub,
1155                                strdup (name));
1156
1157                     /* Write out the toc entry.  */
1158                     bfd_put_32 (output_bfd, val,
1159                                toc_section->contents + our_toc_offset);
1160
1161                     MARK_AS_WRITTEN(h->toc_offset);
1162                     /* The tricky part is that this is the address that
1163                        needs a .reloc entry for it.  */
1164                     fixit = TRUE;
1165                   }
1166               }
1167
1168             if (fixit && info->base_file)
1169               {
1170                 /* So if this is non pcrelative, and is referenced
1171                    to a section or a common symbol, then it needs a reloc.  */
1172
1173                 /* Relocation to a symbol in a section which
1174                    isn't absolute - we output the address here
1175                    to a file.  */
1176                 bfd_vma addr = (toc_section->output_section->vma
1177                                 + toc_section->output_offset + our_toc_offset);
1178
1179                 if (!write_base_file_entry (output_bfd, info, addr))
1180                   return FALSE;
1181               }
1182
1183             /* FIXME: this test is conservative.  */
1184             if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
1185                 && (bfd_vma) our_toc_offset > toc_section->size)
1186               {
1187                 _bfd_error_handler
1188                   /* xgettext: c-format */
1189                   (_("%B: Relocation exceeds allocated TOC (%lx)"),
1190                    input_bfd, (unsigned long) toc_section->size);
1191                 bfd_set_error (bfd_error_bad_value);
1192                 return FALSE;
1193               }
1194
1195             /* Now we know the relocation for this toc reference.  */
1196             relocation =  our_toc_offset + TOC_LOAD_ADJUSTMENT;
1197             rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
1198           }
1199           break;
1200         case IMAGE_REL_PPC_IFGLUE:
1201           {
1202             /* To solve this, we need to know whether or not the symbol
1203                appearing on the call instruction is a glue function or not.
1204                A glue function must announce itself via a IMGLUE reloc, and
1205                the reloc contains the required toc restore instruction.  */
1206             DUMP_RELOC2 (howto->name, rel);
1207
1208             if (h != 0)
1209               {
1210                 if (h->symbol_is_glue == 1)
1211                   {
1212                     bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
1213                   }
1214               }
1215           }
1216           break;
1217         case IMAGE_REL_PPC_SECREL:
1218           /* Unimplemented: codeview debugging information.  */
1219           /* For fast access to the header of the section
1220              containing the item.  */
1221           break;
1222         case IMAGE_REL_PPC_SECTION:
1223           /* Unimplemented: codeview debugging information.  */
1224           /* Is used to indicate that the value should be relative
1225              to the beginning of the section that contains the
1226              symbol.  */
1227           break;
1228         case IMAGE_REL_PPC_ABSOLUTE:
1229           {
1230             const char *my_name;
1231             char buf[SYMNMLEN + 1];
1232
1233             if (h == 0)
1234               {
1235                 strncpy (buf, (syms+symndx)->_n._n_name, SYMNMLEN);
1236                 buf[SYMNMLEN] = '\0';
1237                 my_name = buf;
1238               }
1239             else
1240               my_name = h->root.root.root.string;
1241
1242             _bfd_error_handler
1243               /* xgettext: c-format */
1244               (_("Warning: unsupported reloc %s <file %B, section %A>\n"
1245                  "sym %ld (%s), r_vaddr %ld (%lx)"),
1246                input_bfd, input_section, howto->name,
1247                rel->r_symndx, my_name, (long) rel->r_vaddr,
1248                (unsigned long) rel->r_vaddr);
1249           }
1250           break;
1251         case IMAGE_REL_PPC_IMGLUE:
1252           {
1253             /* There is nothing to do now. This reloc was noted in the first
1254                pass over the relocs, and the glue instruction extracted.  */
1255             const char *my_name;
1256
1257             if (h->symbol_is_glue == 1)
1258               break;
1259             my_name = h->root.root.root.string;
1260
1261             _bfd_error_handler
1262               /* xgettext: c-format */
1263               (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
1264             bfd_set_error (bfd_error_bad_value);
1265             return FALSE;
1266           }
1267
1268         case IMAGE_REL_PPC_ADDR32NB:
1269           {
1270             const char *name = 0;
1271
1272             DUMP_RELOC2 (howto->name, rel);
1273
1274             if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
1275               {
1276                 /* Set magic values.  */
1277                 int idata5offset;
1278                 struct coff_link_hash_entry *myh;
1279
1280                 myh = coff_link_hash_lookup (coff_hash_table (info),
1281                                              "__idata5_magic__",
1282                                              FALSE, FALSE, TRUE);
1283                 first_thunk_address = myh->root.u.def.value +
1284                   sec->output_section->vma +
1285                     sec->output_offset -
1286                       pe_data(output_bfd)->pe_opthdr.ImageBase;
1287
1288                 idata5offset = myh->root.u.def.value;
1289                 myh = coff_link_hash_lookup (coff_hash_table (info),
1290                                              "__idata6_magic__",
1291                                              FALSE, FALSE, TRUE);
1292
1293                 thunk_size = myh->root.u.def.value - idata5offset;
1294                 myh = coff_link_hash_lookup (coff_hash_table (info),
1295                                              "__idata4_magic__",
1296                                              FALSE, FALSE, TRUE);
1297                 import_table_size = myh->root.u.def.value;
1298               }
1299
1300             if (h == 0)
1301               /* It is a file local symbol.  */
1302               sym = syms + symndx;
1303             else
1304               {
1305                 char *target = 0;
1306
1307                 name = h->root.root.root.string;
1308                 if (strcmp (".idata$2", name) == 0)
1309                   target = "__idata2_magic__";
1310                 else if (strcmp (".idata$4", name) == 0)
1311                   target = "__idata4_magic__";
1312                 else if (strcmp (".idata$5", name) == 0)
1313                   target = "__idata5_magic__";
1314
1315                 if (target != 0)
1316                   {
1317                     struct coff_link_hash_entry *myh;
1318
1319                     myh = coff_link_hash_lookup (coff_hash_table (info),
1320                                                  target,
1321                                                  FALSE, FALSE, TRUE);
1322                     if (myh == 0)
1323                       {
1324                         /* Missing magic cookies. Something is very wrong.  */
1325                         abort ();
1326                       }
1327
1328                     val = myh->root.u.def.value +
1329                       sec->output_section->vma + sec->output_offset;
1330                     if (first_thunk_address == 0)
1331                       {
1332                         int idata5offset;
1333                         myh = coff_link_hash_lookup (coff_hash_table (info),
1334                                                      "__idata5_magic__",
1335                                                      FALSE, FALSE, TRUE);
1336                         first_thunk_address = myh->root.u.def.value +
1337                           sec->output_section->vma +
1338                             sec->output_offset -
1339                               pe_data(output_bfd)->pe_opthdr.ImageBase;
1340
1341                         idata5offset = myh->root.u.def.value;
1342                         myh = coff_link_hash_lookup (coff_hash_table (info),
1343                                                      "__idata6_magic__",
1344                                                      FALSE, FALSE, TRUE);
1345
1346                         thunk_size = myh->root.u.def.value - idata5offset;
1347                         myh = coff_link_hash_lookup (coff_hash_table (info),
1348                                                      "__idata4_magic__",
1349                                                      FALSE, FALSE, TRUE);
1350                         import_table_size = myh->root.u.def.value;
1351                       }
1352                   }
1353               }
1354
1355             rstat = _bfd_relocate_contents (howto,
1356                                             input_bfd,
1357                                             val -
1358                                             pe_data (output_bfd)->pe_opthdr.ImageBase,
1359                                             loc);
1360           }
1361           break;
1362
1363         case IMAGE_REL_PPC_REL24:
1364           DUMP_RELOC2(howto->name, rel);
1365           val -= (input_section->output_section->vma
1366                   + input_section->output_offset);
1367
1368           rstat = _bfd_relocate_contents (howto,
1369                                           input_bfd,
1370                                           val,
1371                                           loc);
1372           break;
1373         case IMAGE_REL_PPC_ADDR16:
1374         case IMAGE_REL_PPC_ADDR24:
1375         case IMAGE_REL_PPC_ADDR32:
1376           DUMP_RELOC2(howto->name, rel);
1377           rstat = _bfd_relocate_contents (howto,
1378                                           input_bfd,
1379                                           val,
1380                                           loc);
1381           break;
1382         }
1383
1384       if (info->base_file)
1385         {
1386           /* So if this is non pcrelative, and is referenced
1387              to a section or a common symbol, then it needs a reloc.  */
1388           if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
1389             {
1390               /* Relocation to a symbol in a section which
1391                  isn't absolute - we output the address here
1392                  to a file.  */
1393               bfd_vma addr = (rel->r_vaddr
1394                               - input_section->vma
1395                               + input_section->output_offset
1396                               + input_section->output_section->vma);
1397
1398               if (!write_base_file_entry (output_bfd, info, addr))
1399                 return FALSE;
1400             }
1401         }
1402
1403       switch (rstat)
1404         {
1405         default:
1406           abort ();
1407         case bfd_reloc_ok:
1408           break;
1409         case bfd_reloc_overflow:
1410           {
1411             const char *name;
1412             char buf[SYMNMLEN + 1];
1413
1414             if (symndx == -1)
1415               name = "*ABS*";
1416             else if (h != NULL)
1417               name = NULL;
1418             else if (sym == NULL)
1419               name = "*unknown*";
1420             else if (sym->_n._n_n._n_zeroes == 0
1421                      && sym->_n._n_n._n_offset != 0)
1422               name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1423             else
1424               {
1425                 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1426                 buf[SYMNMLEN] = '\0';
1427                 name = buf;
1428               }
1429
1430             (*info->callbacks->reloc_overflow)
1431               (info, (h ? &h->root.root : NULL), name, howto->name,
1432                (bfd_vma) 0, input_bfd, input_section,
1433                rel->r_vaddr - input_section->vma);
1434           }
1435         }
1436     }
1437
1438   return TRUE;
1439 }
1440
1441 #ifdef COFF_IMAGE_WITH_PE
1442
1443 /* FIXME: BFD should not use global variables.  This file is compiled
1444    twice, and these variables are shared.  This is confusing and
1445    weird.  */
1446
1447 long int global_toc_size = 4;
1448
1449 bfd* bfd_of_toc_owner = 0;
1450
1451 long int import_table_size;
1452 long int first_thunk_address;
1453 long int thunk_size;
1454
1455 struct list_ele *head;
1456 struct list_ele *tail;
1457
1458 static char *
1459 h1 = N_("\n\t\t\tTOC MAPPING\n\n");
1460 static char *
1461 h2 = N_(" TOC    disassembly  Comments       Name\n");
1462 static char *
1463 h3 = N_(" Offset  spelling                   (if present)\n");
1464
1465 void
1466 dump_toc (void * vfile)
1467 {
1468   FILE *file = (FILE *) vfile;
1469   struct list_ele *t;
1470
1471   fputs (_(h1), file);
1472   fputs (_(h2), file);
1473   fputs (_(h3), file);
1474
1475   for (t = head; t != 0; t=t->next)
1476     {
1477       const char *cat = "";
1478
1479       if (t->cat == priv)
1480         cat = _("private       ");
1481       else if (t->cat == pub)
1482         cat = _("public        ");
1483       else if (t->cat == tocdata)
1484         cat = _("data-in-toc   ");
1485
1486       if (t->offset > global_toc_size)
1487         {
1488           if (t->offset <= global_toc_size + thunk_size)
1489             cat = _("IAT reference ");
1490           else
1491             {
1492               fprintf (file,
1493                        /* xgettext: c-format */
1494                       _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
1495                        global_toc_size, (unsigned long) global_toc_size,
1496                        thunk_size, (unsigned long) thunk_size);
1497               cat = _("Out of bounds!");
1498             }
1499         }
1500
1501       fprintf (file,
1502               " %04lx    (%d)", (unsigned long) t->offset, t->offset - 32768);
1503       fprintf (file,
1504               "    %s %s\n",
1505               cat, t->name);
1506
1507     }
1508
1509   fprintf (file, "\n");
1510 }
1511
1512 bfd_boolean
1513 ppc_allocate_toc_section (struct bfd_link_info *info ATTRIBUTE_UNUSED)
1514 {
1515   asection *s;
1516   bfd_byte *foo;
1517   bfd_size_type amt;
1518   static char test_char = '1';
1519
1520   if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble?  */
1521     return TRUE;
1522
1523   if (bfd_of_toc_owner == 0)
1524     /* No toc owner? Something is very wrong.  */
1525     abort ();
1526
1527   s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1528   if (s == NULL)
1529     /* No toc section? Something is very wrong.  */
1530     abort ();
1531
1532   amt = global_toc_size;
1533   foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
1534   memset(foo, test_char, (size_t) global_toc_size);
1535
1536   s->size = global_toc_size;
1537   s->contents = foo;
1538
1539   return TRUE;
1540 }
1541
1542 bfd_boolean
1543 ppc_process_before_allocation (bfd *abfd,
1544                                struct bfd_link_info *info)
1545 {
1546   asection *sec;
1547   struct internal_reloc *i, *rel;
1548
1549   /* Here we have a bfd that is to be included on the link. We have a hook
1550      to do reloc rummaging, before section sizes are nailed down.  */
1551   _bfd_coff_get_external_symbols (abfd);
1552
1553   /* Rummage around all the relocs and map the toc.  */
1554   sec = abfd->sections;
1555
1556   if (sec == 0)
1557     return TRUE;
1558
1559   for (; sec != 0; sec = sec->next)
1560     {
1561       if (sec->reloc_count == 0)
1562         continue;
1563
1564       /* load the relocs */
1565       /* FIXME: there may be a storage leak here */
1566       i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1567
1568       if (i == 0)
1569         abort ();
1570
1571       for (rel = i; rel < i + sec->reloc_count; ++rel)
1572         {
1573           unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
1574           unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1575           bfd_boolean ok = TRUE;
1576
1577           DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
1578
1579           switch(r_type)
1580             {
1581             case IMAGE_REL_PPC_TOCREL16:
1582               /* If TOCDEFN is on, ignore as someone else has allocated the
1583                  toc entry.  */
1584               if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
1585                 ok = ppc_record_toc_entry(abfd, info, sec,
1586                                           rel->r_symndx, default_toc);
1587               if (!ok)
1588                 return FALSE;
1589               break;
1590             case IMAGE_REL_PPC_IMGLUE:
1591               ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
1592               break;
1593             default:
1594               break;
1595             }
1596         }
1597     }
1598
1599   return TRUE;
1600 }
1601
1602 #endif
1603
1604 static bfd_reloc_status_type
1605 ppc_refhi_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1606                  arelent *reloc_entry ATTRIBUTE_UNUSED,
1607                  asymbol *symbol ATTRIBUTE_UNUSED,
1608                  void * data ATTRIBUTE_UNUSED,
1609                  asection *input_section ATTRIBUTE_UNUSED,
1610                  bfd *output_bfd,
1611                  char **error_message ATTRIBUTE_UNUSED)
1612 {
1613   UN_IMPL("REFHI");
1614   DUMP_RELOC("REFHI",reloc_entry);
1615
1616   if (output_bfd == (bfd *) NULL)
1617     return bfd_reloc_continue;
1618
1619   return bfd_reloc_undefined;
1620 }
1621
1622 static bfd_reloc_status_type
1623 ppc_pair_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1624                 arelent *reloc_entry ATTRIBUTE_UNUSED,
1625                 asymbol *symbol ATTRIBUTE_UNUSED,
1626                 void * data ATTRIBUTE_UNUSED,
1627                 asection *input_section ATTRIBUTE_UNUSED,
1628                 bfd *output_bfd,
1629                 char **error_message ATTRIBUTE_UNUSED)
1630 {
1631   UN_IMPL("PAIR");
1632   DUMP_RELOC("PAIR",reloc_entry);
1633
1634   if (output_bfd == (bfd *) NULL)
1635     return bfd_reloc_continue;
1636
1637   return bfd_reloc_undefined;
1638 }
1639
1640 static bfd_reloc_status_type
1641 ppc_toc16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1642                  arelent *reloc_entry ATTRIBUTE_UNUSED,
1643                  asymbol *symbol ATTRIBUTE_UNUSED,
1644                  void * data ATTRIBUTE_UNUSED,
1645                  asection *input_section ATTRIBUTE_UNUSED,
1646                  bfd *output_bfd,
1647                  char **error_message ATTRIBUTE_UNUSED)
1648 {
1649   UN_IMPL ("TOCREL16");
1650   DUMP_RELOC ("TOCREL16",reloc_entry);
1651
1652   if (output_bfd == (bfd *) NULL)
1653     return bfd_reloc_continue;
1654
1655   return bfd_reloc_ok;
1656 }
1657
1658 static bfd_reloc_status_type
1659 ppc_secrel_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1660                   arelent *reloc_entry ATTRIBUTE_UNUSED,
1661                   asymbol *symbol ATTRIBUTE_UNUSED,
1662                   void * data ATTRIBUTE_UNUSED,
1663                   asection *input_section ATTRIBUTE_UNUSED,
1664                   bfd *output_bfd,
1665                   char **error_message ATTRIBUTE_UNUSED)
1666 {
1667   UN_IMPL("SECREL");
1668   DUMP_RELOC("SECREL",reloc_entry);
1669
1670   if (output_bfd == (bfd *) NULL)
1671     return bfd_reloc_continue;
1672
1673   return bfd_reloc_ok;
1674 }
1675
1676 static bfd_reloc_status_type
1677 ppc_section_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1678                    arelent *reloc_entry ATTRIBUTE_UNUSED,
1679                    asymbol *symbol ATTRIBUTE_UNUSED,
1680                    void * data ATTRIBUTE_UNUSED,
1681                    asection *input_section ATTRIBUTE_UNUSED,
1682                    bfd *output_bfd,
1683                    char **error_message ATTRIBUTE_UNUSED)
1684 {
1685   UN_IMPL("SECTION");
1686   DUMP_RELOC("SECTION",reloc_entry);
1687
1688   if (output_bfd == (bfd *) NULL)
1689     return bfd_reloc_continue;
1690
1691   return bfd_reloc_ok;
1692 }
1693
1694 static bfd_reloc_status_type
1695 ppc_imglue_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1696                   arelent *reloc_entry ATTRIBUTE_UNUSED,
1697                   asymbol *symbol ATTRIBUTE_UNUSED,
1698                   void * data ATTRIBUTE_UNUSED,
1699                   asection *input_section ATTRIBUTE_UNUSED,
1700                   bfd *output_bfd,
1701                   char **error_message ATTRIBUTE_UNUSED)
1702
1703 {
1704   UN_IMPL("IMGLUE");
1705   DUMP_RELOC("IMGLUE",reloc_entry);
1706
1707   if (output_bfd == (bfd *) NULL)
1708     return bfd_reloc_continue;
1709
1710   return bfd_reloc_ok;
1711 }
1712 \f
1713 #define MAX_RELOC_INDEX  \
1714       (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
1715
1716 /* FIXME: There is a possibility that when we read in a reloc from a file,
1717           that there are some bits encoded in the upper portion of the
1718           type field. Not yet implemented.  */
1719
1720 static void
1721 ppc_coff_rtype2howto (arelent *relent, struct internal_reloc *internal)
1722 {
1723   /* We can encode one of three things in the type field, aside from the
1724      type:
1725      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1726         value, rather than an addition value
1727      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1728         the branch is expected to be taken or not.
1729      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1730      For now, we just strip this stuff to find the type, and ignore it other
1731      than that.  */
1732   reloc_howto_type *howto;
1733   unsigned short r_type  = EXTRACT_TYPE (internal->r_type);
1734   unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
1735   unsigned short junk    = EXTRACT_JUNK (internal->r_type);
1736
1737   /* The masking process only slices off the bottom byte for r_type.  */
1738   if ( r_type > MAX_RELOC_INDEX )
1739     abort ();
1740
1741   /* Check for absolute crap.  */
1742   if (junk != 0)
1743     abort ();
1744
1745   switch(r_type)
1746     {
1747     case IMAGE_REL_PPC_ADDR16:
1748     case IMAGE_REL_PPC_REL24:
1749     case IMAGE_REL_PPC_ADDR24:
1750     case IMAGE_REL_PPC_ADDR32:
1751     case IMAGE_REL_PPC_IFGLUE:
1752     case IMAGE_REL_PPC_ADDR32NB:
1753     case IMAGE_REL_PPC_SECTION:
1754     case IMAGE_REL_PPC_SECREL:
1755       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1756       howto = ppc_coff_howto_table + r_type;
1757       break;
1758     case IMAGE_REL_PPC_IMGLUE:
1759       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1760       howto = ppc_coff_howto_table + r_type;
1761       break;
1762     case IMAGE_REL_PPC_TOCREL16:
1763       DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1764       if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1765         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1766       else
1767         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1768       break;
1769     default:
1770       _bfd_error_handler
1771         /* xgettext: c-format */
1772         (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1773          ppc_coff_howto_table[r_type].name, r_type);
1774       howto = ppc_coff_howto_table + r_type;
1775       break;
1776     }
1777
1778   relent->howto = howto;
1779 }
1780
1781 static reloc_howto_type *
1782 coff_ppc_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1783                          asection *sec,
1784                          struct internal_reloc *rel,
1785                          struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
1786                          struct internal_syment *sym ATTRIBUTE_UNUSED,
1787                          bfd_vma *addendp)
1788 {
1789   reloc_howto_type *howto;
1790
1791   /* We can encode one of three things in the type field, aside from the
1792      type:
1793      1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1794         value, rather than an addition value
1795      2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1796         the branch is expected to be taken or not.
1797      3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1798      For now, we just strip this stuff to find the type, and ignore it other
1799      than that.  */
1800
1801   unsigned short r_type  = EXTRACT_TYPE  (rel->r_type);
1802   unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1803   unsigned short junk    = EXTRACT_JUNK  (rel->r_type);
1804
1805   /* The masking process only slices off the bottom byte for r_type.  */
1806   if (r_type > MAX_RELOC_INDEX)
1807     abort ();
1808
1809   /* Check for absolute crap.  */
1810   if (junk != 0)
1811     abort ();
1812
1813   switch(r_type)
1814     {
1815     case IMAGE_REL_PPC_ADDR32NB:
1816       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1817       *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
1818       howto = ppc_coff_howto_table + r_type;
1819       break;
1820     case IMAGE_REL_PPC_TOCREL16:
1821       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1822       if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1823         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1824       else
1825         howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1826       break;
1827     case IMAGE_REL_PPC_ADDR16:
1828     case IMAGE_REL_PPC_REL24:
1829     case IMAGE_REL_PPC_ADDR24:
1830     case IMAGE_REL_PPC_ADDR32:
1831     case IMAGE_REL_PPC_IFGLUE:
1832     case IMAGE_REL_PPC_SECTION:
1833     case IMAGE_REL_PPC_SECREL:
1834       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1835       howto = ppc_coff_howto_table + r_type;
1836       break;
1837     case IMAGE_REL_PPC_IMGLUE:
1838       DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1839       howto = ppc_coff_howto_table + r_type;
1840       break;
1841     default:
1842       _bfd_error_handler
1843         /* xgettext: c-format */
1844         (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1845          ppc_coff_howto_table[r_type].name, r_type);
1846       howto = ppc_coff_howto_table + r_type;
1847       break;
1848     }
1849
1850   return howto;
1851 }
1852
1853 /* A cheesy little macro to make the code a little more readable.  */
1854 #define HOW2MAP(bfd_rtype,ppc_rtype)  \
1855  case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
1856
1857 static reloc_howto_type *
1858 ppc_coff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1859                             bfd_reloc_code_real_type code)
1860 {
1861   switch (code)
1862     {
1863       HOW2MAP(BFD_RELOC_32_GOTOFF,    IMAGE_REL_PPC_IMGLUE);
1864       HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
1865       HOW2MAP(BFD_RELOC_16,           IMAGE_REL_PPC_ADDR16);
1866       HOW2MAP(BFD_RELOC_PPC_B26,      IMAGE_REL_PPC_REL24);
1867       HOW2MAP(BFD_RELOC_PPC_BA26,     IMAGE_REL_PPC_ADDR24);
1868       HOW2MAP(BFD_RELOC_PPC_TOC16,    IMAGE_REL_PPC_TOCREL16);
1869       HOW2MAP(BFD_RELOC_16_GOTOFF,    IMAGE_REL_PPC_TOCREL16_DEFN);
1870       HOW2MAP(BFD_RELOC_32,           IMAGE_REL_PPC_ADDR32);
1871       HOW2MAP(BFD_RELOC_RVA,          IMAGE_REL_PPC_ADDR32NB);
1872     default:
1873       return NULL;
1874     }
1875 }
1876 #undef HOW2MAP
1877
1878 static reloc_howto_type *
1879 ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1880                             const char *r_name)
1881 {
1882   unsigned int i;
1883
1884   for (i = 0;
1885        i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
1886        i++)
1887     if (ppc_coff_howto_table[i].name != NULL
1888         && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
1889       return &ppc_coff_howto_table[i];
1890
1891   return NULL;
1892 }
1893 \f
1894 /* Tailor coffcode.h -- macro heaven.  */
1895
1896 #define RTYPE2HOWTO(cache_ptr, dst)  ppc_coff_rtype2howto (cache_ptr, dst)
1897
1898 /* We use the special COFF backend linker, with our own special touch.  */
1899
1900 #define coff_bfd_reloc_type_lookup   ppc_coff_reloc_type_lookup
1901 #define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
1902 #define coff_rtype_to_howto          coff_ppc_rtype_to_howto
1903 #define coff_relocate_section        coff_ppc_relocate_section
1904 #define coff_bfd_final_link          ppc_bfd_coff_final_link
1905
1906 #ifndef COFF_IMAGE_WITH_PE
1907 #endif
1908
1909 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
1910
1911 #define COFF_PAGE_SIZE                       0x1000
1912
1913 /* FIXME: This controls some code that used to be in peicode.h and is
1914    now in peigen.c.  It will not control the code in peigen.c.  If
1915    anybody wants to get this working, you will need to fix that.  */
1916 #define POWERPC_LE_PE
1917
1918 #define COFF_SECTION_ALIGNMENT_ENTRIES \
1919 { COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
1920   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
1921 { COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
1922   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
1923 { COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
1924   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
1925 { COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
1926   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
1927 { COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
1928   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
1929 { COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
1930   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
1931
1932 #include "coffcode.h"
1933 \f
1934 #ifndef COFF_IMAGE_WITH_PE
1935
1936 static bfd_boolean
1937 ppc_do_last (bfd *abfd)
1938 {
1939   if (abfd == bfd_of_toc_owner)
1940     return TRUE;
1941   else
1942     return FALSE;
1943 }
1944
1945 static bfd *
1946 ppc_get_last (void)
1947 {
1948   return bfd_of_toc_owner;
1949 }
1950
1951 /* This piece of machinery exists only to guarantee that the bfd that holds
1952    the toc section is written last.
1953
1954    This does depend on bfd_make_section attaching a new section to the
1955    end of the section list for the bfd.
1956
1957    This is otherwise intended to be functionally the same as
1958    cofflink.c:_bfd_coff_final_link(). It is specifically different only
1959    where the POWERPC_LE_PE macro modifies the code. It is left in as a
1960    precise form of comment. krk@cygnus.com  */
1961
1962 /* Do the final link step.  */
1963
1964 bfd_boolean
1965 ppc_bfd_coff_final_link (bfd *abfd, struct bfd_link_info *info)
1966 {
1967   bfd_size_type symesz;
1968   struct coff_final_link_info flaginfo;
1969   bfd_boolean debug_merge_allocated;
1970   asection *o;
1971   struct bfd_link_order *p;
1972   bfd_size_type max_sym_count;
1973   bfd_size_type max_lineno_count;
1974   bfd_size_type max_reloc_count;
1975   bfd_size_type max_output_reloc_count;
1976   bfd_size_type max_contents_size;
1977   file_ptr rel_filepos;
1978   unsigned int relsz;
1979   file_ptr line_filepos;
1980   unsigned int linesz;
1981   bfd *sub;
1982   bfd_byte *external_relocs = NULL;
1983   char strbuf[STRING_SIZE_SIZE];
1984   bfd_size_type amt;
1985
1986   symesz = bfd_coff_symesz (abfd);
1987
1988   flaginfo.info = info;
1989   flaginfo.output_bfd = abfd;
1990   flaginfo.strtab = NULL;
1991   flaginfo.section_info = NULL;
1992   flaginfo.last_file_index = -1;
1993   flaginfo.last_bf_index = -1;
1994   flaginfo.internal_syms = NULL;
1995   flaginfo.sec_ptrs = NULL;
1996   flaginfo.sym_indices = NULL;
1997   flaginfo.outsyms = NULL;
1998   flaginfo.linenos = NULL;
1999   flaginfo.contents = NULL;
2000   flaginfo.external_relocs = NULL;
2001   flaginfo.internal_relocs = NULL;
2002   debug_merge_allocated = FALSE;
2003
2004   coff_data (abfd)->link_info = info;
2005
2006   flaginfo.strtab = _bfd_stringtab_init ();
2007   if (flaginfo.strtab == NULL)
2008     goto error_return;
2009
2010   if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
2011     goto error_return;
2012   debug_merge_allocated = TRUE;
2013
2014   /* Compute the file positions for all the sections.  */
2015   if (! abfd->output_has_begun)
2016     {
2017       if (! bfd_coff_compute_section_file_positions (abfd))
2018         return FALSE;
2019     }
2020
2021   /* Count the line numbers and relocation entries required for the
2022      output file.  Set the file positions for the relocs.  */
2023   rel_filepos = obj_relocbase (abfd);
2024   relsz = bfd_coff_relsz (abfd);
2025   max_contents_size = 0;
2026   max_lineno_count = 0;
2027   max_reloc_count = 0;
2028
2029   for (o = abfd->sections; o != NULL; o = o->next)
2030     {
2031       o->reloc_count = 0;
2032       o->lineno_count = 0;
2033
2034       for (p = o->map_head.link_order; p != NULL; p = p->next)
2035         {
2036           if (p->type == bfd_indirect_link_order)
2037             {
2038               asection *sec;
2039
2040               sec = p->u.indirect.section;
2041
2042               /* Mark all sections which are to be included in the
2043                  link.  This will normally be every section.  We need
2044                  to do this so that we can identify any sections which
2045                  the linker has decided to not include.  */
2046               sec->linker_mark = TRUE;
2047
2048               if (info->strip == strip_none
2049                   || info->strip == strip_some)
2050                 o->lineno_count += sec->lineno_count;
2051
2052               if (bfd_link_relocatable (info))
2053                 o->reloc_count += sec->reloc_count;
2054
2055               if (sec->rawsize > max_contents_size)
2056                 max_contents_size = sec->rawsize;
2057               if (sec->size > max_contents_size)
2058                 max_contents_size = sec->size;
2059               if (sec->lineno_count > max_lineno_count)
2060                 max_lineno_count = sec->lineno_count;
2061               if (sec->reloc_count > max_reloc_count)
2062                 max_reloc_count = sec->reloc_count;
2063             }
2064           else if (bfd_link_relocatable (info)
2065                    && (p->type == bfd_section_reloc_link_order
2066                        || p->type == bfd_symbol_reloc_link_order))
2067             ++o->reloc_count;
2068         }
2069       if (o->reloc_count == 0)
2070         o->rel_filepos = 0;
2071       else
2072         {
2073           o->flags |= SEC_RELOC;
2074           o->rel_filepos = rel_filepos;
2075           rel_filepos += o->reloc_count * relsz;
2076         }
2077     }
2078
2079   /* If doing a relocatable link, allocate space for the pointers we
2080      need to keep.  */
2081   if (bfd_link_relocatable (info))
2082     {
2083       unsigned int i;
2084
2085       /* We use section_count + 1, rather than section_count, because
2086          the target_index fields are 1 based.  */
2087       amt = abfd->section_count + 1;
2088       amt *= sizeof (struct coff_link_section_info);
2089       flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
2090
2091       if (flaginfo.section_info == NULL)
2092         goto error_return;
2093
2094       for (i = 0; i <= abfd->section_count; i++)
2095         {
2096           flaginfo.section_info[i].relocs = NULL;
2097           flaginfo.section_info[i].rel_hashes = NULL;
2098         }
2099     }
2100
2101   /* We now know the size of the relocs, so we can determine the file
2102      positions of the line numbers.  */
2103   line_filepos = rel_filepos;
2104   linesz = bfd_coff_linesz (abfd);
2105   max_output_reloc_count = 0;
2106
2107   for (o = abfd->sections; o != NULL; o = o->next)
2108     {
2109       if (o->lineno_count == 0)
2110         o->line_filepos = 0;
2111       else
2112         {
2113           o->line_filepos = line_filepos;
2114           line_filepos += o->lineno_count * linesz;
2115         }
2116
2117       if (o->reloc_count != 0)
2118         {
2119           /* We don't know the indices of global symbols until we have
2120              written out all the local symbols.  For each section in
2121              the output file, we keep an array of pointers to hash
2122              table entries.  Each entry in the array corresponds to a
2123              reloc.  When we find a reloc against a global symbol, we
2124              set the corresponding entry in this array so that we can
2125              fix up the symbol index after we have written out all the
2126              local symbols.
2127
2128              Because of this problem, we also keep the relocs in
2129              memory until the end of the link.  This wastes memory,
2130              but only when doing a relocatable link, which is not the
2131              common case.  */
2132           BFD_ASSERT (bfd_link_relocatable (info));
2133           amt = o->reloc_count;
2134           amt *= sizeof (struct internal_reloc);
2135           flaginfo.section_info[o->target_index].relocs =
2136             (struct internal_reloc *) bfd_malloc (amt);
2137           amt = o->reloc_count;
2138           amt *= sizeof (struct coff_link_hash_entry *);
2139           flaginfo.section_info[o->target_index].rel_hashes =
2140             (struct coff_link_hash_entry **) bfd_malloc (amt);
2141           if (flaginfo.section_info[o->target_index].relocs == NULL
2142               || flaginfo.section_info[o->target_index].rel_hashes == NULL)
2143             goto error_return;
2144
2145           if (o->reloc_count > max_output_reloc_count)
2146             max_output_reloc_count = o->reloc_count;
2147         }
2148
2149       /* Reset the reloc and lineno counts, so that we can use them to
2150          count the number of entries we have output so far.  */
2151       o->reloc_count = 0;
2152       o->lineno_count = 0;
2153     }
2154
2155   obj_sym_filepos (abfd) = line_filepos;
2156
2157   /* Figure out the largest number of symbols in an input BFD.  Take
2158      the opportunity to clear the output_has_begun fields of all the
2159      input BFD's.  */
2160   max_sym_count = 0;
2161   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2162     {
2163       bfd_size_type sz;
2164
2165       sub->output_has_begun = FALSE;
2166       sz = obj_raw_syment_count (sub);
2167       if (sz > max_sym_count)
2168         max_sym_count = sz;
2169     }
2170
2171   /* Allocate some buffers used while linking.  */
2172   amt = max_sym_count * sizeof (struct internal_syment);
2173   flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
2174   amt = max_sym_count * sizeof (asection *);
2175   flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
2176   amt = max_sym_count * sizeof (long);
2177   flaginfo.sym_indices = (long *) bfd_malloc (amt);
2178   amt = (max_sym_count + 1) * symesz;
2179   flaginfo.outsyms = (bfd_byte *) bfd_malloc (amt);
2180   amt = max_lineno_count * bfd_coff_linesz (abfd);
2181   flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
2182   flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2183   flaginfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
2184   if (! bfd_link_relocatable (info))
2185     {
2186       amt = max_reloc_count * sizeof (struct internal_reloc);
2187       flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
2188     }
2189   if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
2190       || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
2191       || (flaginfo.sym_indices == NULL && max_sym_count > 0)
2192       || flaginfo.outsyms == NULL
2193       || (flaginfo.linenos == NULL && max_lineno_count > 0)
2194       || (flaginfo.contents == NULL && max_contents_size > 0)
2195       || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
2196       || (! bfd_link_relocatable (info)
2197           && flaginfo.internal_relocs == NULL
2198           && max_reloc_count > 0))
2199     goto error_return;
2200
2201   /* We now know the position of everything in the file, except that
2202      we don't know the size of the symbol table and therefore we don't
2203      know where the string table starts.  We just build the string
2204      table in memory as we go along.  We process all the relocations
2205      for a single input file at once.  */
2206   obj_raw_syment_count (abfd) = 0;
2207
2208   if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
2209     {
2210       if (! bfd_coff_start_final_link (abfd, info))
2211         goto error_return;
2212     }
2213
2214   for (o = abfd->sections; o != NULL; o = o->next)
2215     {
2216       for (p = o->map_head.link_order; p != NULL; p = p->next)
2217         {
2218           if (p->type == bfd_indirect_link_order
2219               && (bfd_get_flavour (p->u.indirect.section->owner)
2220                   == bfd_target_coff_flavour))
2221             {
2222               sub = p->u.indirect.section->owner;
2223 #ifdef POWERPC_LE_PE
2224               if (! sub->output_has_begun && !ppc_do_last(sub))
2225 #else
2226               if (! sub->output_has_begun)
2227 #endif
2228                 {
2229                   if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
2230                     goto error_return;
2231                   sub->output_has_begun = TRUE;
2232                 }
2233             }
2234           else if (p->type == bfd_section_reloc_link_order
2235                    || p->type == bfd_symbol_reloc_link_order)
2236             {
2237               if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
2238                 goto error_return;
2239             }
2240           else
2241             {
2242               if (! _bfd_default_link_order (abfd, info, o, p))
2243                 goto error_return;
2244             }
2245         }
2246     }
2247
2248 #ifdef POWERPC_LE_PE
2249   {
2250     bfd* last_one = ppc_get_last();
2251     if (last_one)
2252       {
2253         if (! _bfd_coff_link_input_bfd (&flaginfo, last_one))
2254           goto error_return;
2255       }
2256     last_one->output_has_begun = TRUE;
2257   }
2258 #endif
2259
2260   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
2261   coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
2262   debug_merge_allocated = FALSE;
2263
2264   if (flaginfo.internal_syms != NULL)
2265     {
2266       free (flaginfo.internal_syms);
2267       flaginfo.internal_syms = NULL;
2268     }
2269   if (flaginfo.sec_ptrs != NULL)
2270     {
2271       free (flaginfo.sec_ptrs);
2272       flaginfo.sec_ptrs = NULL;
2273     }
2274   if (flaginfo.sym_indices != NULL)
2275     {
2276       free (flaginfo.sym_indices);
2277       flaginfo.sym_indices = NULL;
2278     }
2279   if (flaginfo.linenos != NULL)
2280     {
2281       free (flaginfo.linenos);
2282       flaginfo.linenos = NULL;
2283     }
2284   if (flaginfo.contents != NULL)
2285     {
2286       free (flaginfo.contents);
2287       flaginfo.contents = NULL;
2288     }
2289   if (flaginfo.external_relocs != NULL)
2290     {
2291       free (flaginfo.external_relocs);
2292       flaginfo.external_relocs = NULL;
2293     }
2294   if (flaginfo.internal_relocs != NULL)
2295     {
2296       free (flaginfo.internal_relocs);
2297       flaginfo.internal_relocs = NULL;
2298     }
2299
2300   /* The value of the last C_FILE symbol is supposed to be the symbol
2301      index of the first external symbol.  Write it out again if
2302      necessary.  */
2303   if (flaginfo.last_file_index != -1
2304       && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
2305     {
2306       file_ptr pos;
2307
2308       flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
2309       bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
2310                              flaginfo.outsyms);
2311       pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
2312       if (bfd_seek (abfd, pos, SEEK_SET) != 0
2313           || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
2314         return FALSE;
2315     }
2316
2317   /* Write out the global symbols.  */
2318   flaginfo.failed = FALSE;
2319   bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
2320   if (flaginfo.failed)
2321     goto error_return;
2322
2323   /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
2324   if (flaginfo.outsyms != NULL)
2325     {
2326       free (flaginfo.outsyms);
2327       flaginfo.outsyms = NULL;
2328     }
2329
2330   if (bfd_link_relocatable (info))
2331     {
2332       /* Now that we have written out all the global symbols, we know
2333          the symbol indices to use for relocs against them, and we can
2334          finally write out the relocs.  */
2335       amt = max_output_reloc_count * relsz;
2336       external_relocs = (bfd_byte *) bfd_malloc (amt);
2337       if (external_relocs == NULL)
2338         goto error_return;
2339
2340       for (o = abfd->sections; o != NULL; o = o->next)
2341         {
2342           struct internal_reloc *irel;
2343           struct internal_reloc *irelend;
2344           struct coff_link_hash_entry **rel_hash;
2345           bfd_byte *erel;
2346
2347           if (o->reloc_count == 0)
2348             continue;
2349
2350           irel = flaginfo.section_info[o->target_index].relocs;
2351           irelend = irel + o->reloc_count;
2352           rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
2353           erel = external_relocs;
2354           for (; irel < irelend; irel++, rel_hash++, erel += relsz)
2355             {
2356               if (*rel_hash != NULL)
2357                 {
2358                   BFD_ASSERT ((*rel_hash)->indx >= 0);
2359                   irel->r_symndx = (*rel_hash)->indx;
2360                 }
2361               bfd_coff_swap_reloc_out (abfd, irel, erel);
2362             }
2363
2364           amt = relsz * o->reloc_count;
2365           if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
2366               || bfd_bwrite (external_relocs, amt, abfd) != amt)
2367             goto error_return;
2368         }
2369
2370       free (external_relocs);
2371       external_relocs = NULL;
2372     }
2373
2374   /* Free up the section information.  */
2375   if (flaginfo.section_info != NULL)
2376     {
2377       unsigned int i;
2378
2379       for (i = 0; i < abfd->section_count; i++)
2380         {
2381           if (flaginfo.section_info[i].relocs != NULL)
2382             free (flaginfo.section_info[i].relocs);
2383           if (flaginfo.section_info[i].rel_hashes != NULL)
2384             free (flaginfo.section_info[i].rel_hashes);
2385         }
2386       free (flaginfo.section_info);
2387       flaginfo.section_info = NULL;
2388     }
2389
2390   /* If we have optimized stabs strings, output them.  */
2391   if (coff_hash_table (info)->stab_info.stabstr != NULL)
2392     {
2393       if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
2394         return FALSE;
2395     }
2396
2397   /* Write out the string table.  */
2398   if (obj_raw_syment_count (abfd) != 0)
2399     {
2400       file_ptr pos;
2401
2402       pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
2403       if (bfd_seek (abfd, pos, SEEK_SET) != 0)
2404         return FALSE;
2405
2406 #if STRING_SIZE_SIZE == 4
2407       H_PUT_32 (abfd,
2408                 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
2409                 strbuf);
2410 #else
2411  #error Change H_PUT_32 above
2412 #endif
2413
2414       if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
2415           != STRING_SIZE_SIZE)
2416         return FALSE;
2417
2418       if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
2419         return FALSE;
2420     }
2421
2422   _bfd_stringtab_free (flaginfo.strtab);
2423
2424   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
2425      not try to write out the symbols.  */
2426   bfd_get_symcount (abfd) = 0;
2427
2428   return TRUE;
2429
2430  error_return:
2431   if (debug_merge_allocated)
2432     coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
2433   if (flaginfo.strtab != NULL)
2434     _bfd_stringtab_free (flaginfo.strtab);
2435   if (flaginfo.section_info != NULL)
2436     {
2437       unsigned int i;
2438
2439       for (i = 0; i < abfd->section_count; i++)
2440         {
2441           if (flaginfo.section_info[i].relocs != NULL)
2442             free (flaginfo.section_info[i].relocs);
2443           if (flaginfo.section_info[i].rel_hashes != NULL)
2444             free (flaginfo.section_info[i].rel_hashes);
2445         }
2446       free (flaginfo.section_info);
2447     }
2448   if (flaginfo.internal_syms != NULL)
2449     free (flaginfo.internal_syms);
2450   if (flaginfo.sec_ptrs != NULL)
2451     free (flaginfo.sec_ptrs);
2452   if (flaginfo.sym_indices != NULL)
2453     free (flaginfo.sym_indices);
2454   if (flaginfo.outsyms != NULL)
2455     free (flaginfo.outsyms);
2456   if (flaginfo.linenos != NULL)
2457     free (flaginfo.linenos);
2458   if (flaginfo.contents != NULL)
2459     free (flaginfo.contents);
2460   if (flaginfo.external_relocs != NULL)
2461     free (flaginfo.external_relocs);
2462   if (flaginfo.internal_relocs != NULL)
2463     free (flaginfo.internal_relocs);
2464   if (external_relocs != NULL)
2465     free (external_relocs);
2466   return FALSE;
2467 }
2468 #endif
2469 \f
2470 /* Forward declaration for use by alternative_target field.  */
2471 #ifdef TARGET_BIG_SYM
2472 extern const bfd_target TARGET_BIG_SYM;
2473 #endif
2474
2475 /* The transfer vectors that lead the outside world to all of the above.  */
2476
2477 #ifdef TARGET_LITTLE_SYM
2478 const bfd_target TARGET_LITTLE_SYM =
2479 {
2480   TARGET_LITTLE_NAME,           /* name or coff-arm-little */
2481   bfd_target_coff_flavour,
2482   BFD_ENDIAN_LITTLE,            /* data byte order is little */
2483   BFD_ENDIAN_LITTLE,            /* header byte order is little */
2484
2485   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2486    HAS_LINENO | HAS_DEBUG |
2487    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2488
2489 #ifndef COFF_WITH_PE
2490   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2491    | SEC_RELOC),                /* section flags */
2492 #else
2493   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2494    | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2495 #endif
2496
2497   0,                            /* leading char */
2498   '/',                          /* ar_pad_char */
2499   15,                           /* ar_max_namelen??? FIXMEmgo */
2500   0,                            /* match priority.  */
2501
2502   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2503   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2504   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2505
2506   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2507   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2508   bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2509
2510   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2511      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2512   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2513      bfd_false},
2514   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2515      _bfd_write_archive_contents, bfd_false},
2516
2517   BFD_JUMP_TABLE_GENERIC (coff),
2518   BFD_JUMP_TABLE_COPY (coff),
2519   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2520   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2521   BFD_JUMP_TABLE_SYMBOLS (coff),
2522   BFD_JUMP_TABLE_RELOCS (coff),
2523   BFD_JUMP_TABLE_WRITE (coff),
2524   BFD_JUMP_TABLE_LINK (coff),
2525   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2526
2527   /* Alternative_target.  */
2528 #ifdef TARGET_BIG_SYM
2529   & TARGET_BIG_SYM,
2530 #else
2531   NULL,
2532 #endif
2533
2534   COFF_SWAP_TABLE
2535 };
2536 #endif
2537
2538 #ifdef TARGET_BIG_SYM
2539 const bfd_target TARGET_BIG_SYM =
2540 {
2541   TARGET_BIG_NAME,
2542   bfd_target_coff_flavour,
2543   BFD_ENDIAN_BIG,               /* data byte order is big */
2544   BFD_ENDIAN_BIG,               /* header byte order is big */
2545
2546   (HAS_RELOC | EXEC_P |         /* FIXME: object flags */
2547    HAS_LINENO | HAS_DEBUG |
2548    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2549
2550 #ifndef COFF_WITH_PE
2551   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2552    | SEC_RELOC),                /* section flags */
2553 #else
2554   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2555    | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2556 #endif
2557
2558   0,                            /* leading char */
2559   '/',                          /* ar_pad_char */
2560   15,                           /* ar_max_namelen??? FIXMEmgo */
2561   0,                            /* match priority.  */
2562
2563   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2564   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2565   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2566
2567   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2568   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2569   bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2570
2571   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2572      bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2573   {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2574      bfd_false},
2575   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2576      _bfd_write_archive_contents, bfd_false},
2577
2578   BFD_JUMP_TABLE_GENERIC (coff),
2579   BFD_JUMP_TABLE_COPY (coff),
2580   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2581   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2582   BFD_JUMP_TABLE_SYMBOLS (coff),
2583   BFD_JUMP_TABLE_RELOCS (coff),
2584   BFD_JUMP_TABLE_WRITE (coff),
2585   BFD_JUMP_TABLE_LINK (coff),
2586   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2587
2588   /* Alternative_target.  */
2589 #ifdef TARGET_LITTLE_SYM
2590   & TARGET_LITTLE_SYM,
2591 #else
2592   NULL,
2593 #endif
2594
2595   COFF_SWAP_TABLE
2596 };
2597
2598 #endif