bfd/elf32-ppc.c

   1 /* PowerPC-specific support for 32-bit ELF
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor, Cygnus Support.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the
  20    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* This file is based on a preliminary PowerPC ELF ABI.  The
  24    information may not match the final PowerPC ELF ABI.  It includes
  25    suggestions from the in-progress Embedded PowerPC ABI, and that
  26    information may also not match.  */
  27
  28 #include "bfd.h"
  29 #include "sysdep.h"
  30 #include "bfdlink.h"
  31 #include "libbfd.h"
  32 #include "elf-bfd.h"
  33 #include "elf/ppc.h"
  34 #include "elf32-ppc.h"
  35
  36 /* RELA relocations are used here.  */
  37
  38 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc_elf_unhandled_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42
  43 /* Branch prediction bit for branch taken relocs.  */
  44 #define BRANCH_PREDICT_BIT 0x200000
  45 /* Mask to set RA in memory instructions.  */
  46 #define RA_REGISTER_MASK 0x001f0000
  47 /* Value to shift register by to insert RA.  */
  48 #define RA_REGISTER_SHIFT 16
  49
  50 /* The name of the dynamic interpreter.  This is put in the .interp
  51    section.  */
  52 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  53
  54 /* The size in bytes of an entry in the procedure linkage table.  */
  55 #define PLT_ENTRY_SIZE 12
  56 /* The initial size of the plt reserved for the dynamic linker.  */
  57 #define PLT_INITIAL_ENTRY_SIZE 72
  58 /* The size of the gap between entries in the PLT.  */
  59 #define PLT_SLOT_SIZE 8
  60 /* The number of single-slot PLT entries (the rest use two slots).  */
  61 #define PLT_NUM_SINGLE_ENTRIES 8192
  62
  63 /* Some nop instructions.  */
  64 #define NOP             0x60000000
  65 #define CROR_151515     0x4def7b82
  66 #define CROR_313131     0x4ffffb82
  67
  68 /* Offset of tp and dtp pointers from start of TLS block.  */
  69 #define TP_OFFSET       0x7000
  70 #define DTP_OFFSET      0x8000
  71
  72 \f
  73 /* Enumeration to specify the special section.  */
  74 enum elf_linker_section_enum
  75 {
  76   LINKER_SECTION_SDATA,
  77   LINKER_SECTION_SDATA2
  78 };
  79
  80 /* Sections created by the linker.  */
  81
  82 typedef struct elf_linker_section
  83 {
  84   /* pointer to the section */
  85   asection *section;
  86   /* pointer to the relocations needed for this section */
  87   asection *rel_section;
  88   /* pointer to the created symbol hash value */
  89   struct elf_link_hash_entry *sym_hash;
  90   /* offset of symbol from beginning of section */
  91   bfd_vma sym_offset;
  92 } elf_linker_section_t;
  93
  94 /* Linked list of allocated pointer entries.  This hangs off of the
  95    symbol lists, and provides allows us to return different pointers,
  96    based on different addend's.  */
  97
  98 typedef struct elf_linker_section_pointers
  99 {
 100   /* next allocated pointer for this symbol */
 101   struct elf_linker_section_pointers *next;
 102   /* offset of pointer from beginning of section */
 103   bfd_vma offset;
 104   /* addend used */
 105   bfd_vma addend;
 106   /* which linker section this is */
 107   elf_linker_section_t *lsect;
 108   /* whether address was written yet */
 109   bfd_boolean written_address_p;
 110 } elf_linker_section_pointers_t;
 111
 112 struct ppc_elf_obj_tdata
 113 {
 114   struct elf_obj_tdata elf;
 115
 116   /* A mapping from local symbols to offsets into the various linker
 117      sections added.  This is index by the symbol index.  */
 118   elf_linker_section_pointers_t **linker_section_pointers;
 119 };
 120
 121 #define ppc_elf_tdata(bfd) \
 122   ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any)
 123
 124 #define elf_local_ptr_offsets(bfd) \
 125   (ppc_elf_tdata (bfd)->linker_section_pointers)
 126
 127 /* Override the generic function because we store some extras.  */
 128
 129 static bfd_boolean
 130 ppc_elf_mkobject (bfd *abfd)
 131 {
 132   bfd_size_type amt = sizeof (struct ppc_elf_obj_tdata);
 133   abfd->tdata.any = bfd_zalloc (abfd, amt);
 134   if (abfd->tdata.any == NULL)
 135     return FALSE;
 136   return TRUE;
 137 }
 138
 139 /* The PPC linker needs to keep track of the number of relocs that it
 140    decides to copy as dynamic relocs in check_relocs for each symbol.
 141    This is so that it can later discard them if they are found to be
 142    unnecessary.  We store the information in a field extending the
 143    regular ELF linker hash table.  */
 144
 145 struct ppc_elf_dyn_relocs
 146 {
 147   struct ppc_elf_dyn_relocs *next;
 148
 149   /* The input section of the reloc.  */
 150   asection *sec;
 151
 152   /* Total number of relocs copied for the input section.  */
 153   bfd_size_type count;
 154
 155   /* Number of pc-relative relocs copied for the input section.  */
 156   bfd_size_type pc_count;
 157 };
 158
 159 /* PPC ELF linker hash entry.  */
 160
 161 struct ppc_elf_link_hash_entry
 162 {
 163   struct elf_link_hash_entry elf;
 164
 165   /* If this symbol is used in the linker created sections, the processor
 166      specific backend uses this field to map the field into the offset
 167      from the beginning of the section.  */
 168   elf_linker_section_pointers_t *linker_section_pointer;
 169
 170   /* Track dynamic relocs copied for this symbol.  */
 171   struct ppc_elf_dyn_relocs *dyn_relocs;
 172
 173   /* Contexts in which symbol is used in the GOT (or TOC).
 174      TLS_GD .. TLS_TLS bits are or'd into the mask as the
 175      corresponding relocs are encountered during check_relocs.
 176      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
 177      indicate the corresponding GOT entry type is not needed.  */
 178 #define TLS_GD           1      /* GD reloc. */
 179 #define TLS_LD           2      /* LD reloc. */
 180 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
 181 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
 182 #define TLS_TLS         16      /* Any TLS reloc.  */
 183 #define TLS_TPRELGD     32      /* TPREL reloc resulting from GD->IE. */
 184   char tls_mask;
 185 };
 186
 187 #define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent))
 188
 189 /* PPC ELF linker hash table.  */
 190
 191 struct ppc_elf_link_hash_table
 192 {
 193   struct elf_link_hash_table elf;
 194
 195   /* Short-cuts to get to dynamic linker sections.  */
 196   asection *got;
 197   asection *relgot;
 198   asection *plt;
 199   asection *relplt;
 200   asection *dynbss;
 201   asection *relbss;
 202   asection *dynsbss;
 203   asection *relsbss;
 204   elf_linker_section_t *sdata;
 205   elf_linker_section_t *sdata2;
 206   asection *sbss;
 207
 208   /* Short-cut to first output tls section.  */
 209   asection *tls_sec;
 210
 211   /* Shortcut to .__tls_get_addr.  */
 212   struct elf_link_hash_entry *tls_get_addr;
 213
 214   /* TLS local dynamic got entry handling.  */
 215   union {
 216     bfd_signed_vma refcount;
 217     bfd_vma offset;
 218   } tlsld_got;
 219
 220   /* Small local sym to section mapping cache.  */
 221   struct sym_sec_cache sym_sec;
 222 };
 223
 224 /* Get the PPC ELF linker hash table from a link_info structure.  */
 225
 226 #define ppc_elf_hash_table(p) \
 227   ((struct ppc_elf_link_hash_table *) (p)->hash)
 228
 229 /* Create an entry in a PPC ELF linker hash table.  */
 230
 231 static struct bfd_hash_entry *
 232 ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 233                            struct bfd_hash_table *table,
 234                            const char *string)
 235 {
 236   /* Allocate the structure if it has not already been allocated by a
 237      subclass.  */
 238   if (entry == NULL)
 239     {
 240       entry = bfd_hash_allocate (table,
 241                                  sizeof (struct ppc_elf_link_hash_entry));
 242       if (entry == NULL)
 243         return entry;
 244     }
 245
 246   /* Call the allocation method of the superclass.  */
 247   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 248   if (entry != NULL)
 249     {
 250       ppc_elf_hash_entry (entry)->linker_section_pointer = NULL;
 251       ppc_elf_hash_entry (entry)->dyn_relocs = NULL;
 252       ppc_elf_hash_entry (entry)->tls_mask = 0;
 253     }
 254
 255   return entry;
 256 }
 257
 258 /* Create a PPC ELF linker hash table.  */
 259
 260 static struct bfd_link_hash_table *
 261 ppc_elf_link_hash_table_create (bfd *abfd)
 262 {
 263   struct ppc_elf_link_hash_table *ret;
 264
 265   ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table));
 266   if (ret == NULL)
 267     return NULL;
 268
 269   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
 270                                        ppc_elf_link_hash_newfunc))
 271     {
 272       free (ret);
 273       return NULL;
 274     }
 275
 276   return &ret->elf.root;
 277 }
 278
 279 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 280    copying dynamic variables from a shared lib into an app's dynbss
 281    section, and instead use a dynamic relocation to point into the
 282    shared lib.  */
 283 #define ELIMINATE_COPY_RELOCS 1
 284
 285 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 286
 287 static void
 288 ppc_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
 289                               struct elf_link_hash_entry *dir,
 290                               struct elf_link_hash_entry *ind)
 291 {
 292   struct ppc_elf_link_hash_entry *edir, *eind;
 293
 294   edir = (struct ppc_elf_link_hash_entry *) dir;
 295   eind = (struct ppc_elf_link_hash_entry *) ind;
 296
 297   if (eind->dyn_relocs != NULL)
 298     {
 299       if (edir->dyn_relocs != NULL)
 300         {
 301           struct ppc_elf_dyn_relocs **pp;
 302           struct ppc_elf_dyn_relocs *p;
 303
 304           if (ind->root.type == bfd_link_hash_indirect)
 305             abort ();
 306
 307           /* Add reloc counts against the weak sym to the strong sym
 308              list.  Merge any entries against the same section.  */
 309           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 310             {
 311               struct ppc_elf_dyn_relocs *q;
 312
 313               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 314                 if (q->sec == p->sec)
 315                   {
 316                     q->pc_count += p->pc_count;
 317                     q->count += p->count;
 318                     *pp = p->next;
 319                     break;
 320                   }
 321               if (q == NULL)
 322                 pp = &p->next;
 323             }
 324           *pp = edir->dyn_relocs;
 325         }
 326
 327       edir->dyn_relocs = eind->dyn_relocs;
 328       eind->dyn_relocs = NULL;
 329     }
 330
 331   edir->tls_mask |= eind->tls_mask;
 332
 333   if (ELIMINATE_COPY_RELOCS
 334       && ind->root.type != bfd_link_hash_indirect
 335       && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
 336     /* If called to transfer flags for a weakdef during processing
 337        of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
 338        We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 339     dir->elf_link_hash_flags |=
 340       (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
 341                                    | ELF_LINK_HASH_REF_REGULAR
 342                                    | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
 343   else
 344     _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 345 }
 346 \f
 347 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
 348
 349 static reloc_howto_type ppc_elf_howto_raw[] = {
 350   /* This reloc does nothing.  */
 351   HOWTO (R_PPC_NONE,            /* type */
 352          0,                     /* rightshift */
 353          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          32,                    /* bitsize */
 355          FALSE,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_bitfield, /* complain_on_overflow */
 358          bfd_elf_generic_reloc, /* special_function */
 359          "R_PPC_NONE",          /* name */
 360          FALSE,                 /* partial_inplace */
 361          0,                     /* src_mask */
 362          0,                     /* dst_mask */
 363          FALSE),                /* pcrel_offset */
 364
 365   /* A standard 32 bit relocation.  */
 366   HOWTO (R_PPC_ADDR32,          /* type */
 367          0,                     /* rightshift */
 368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          32,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_bitfield, /* complain_on_overflow */
 373          bfd_elf_generic_reloc, /* special_function */
 374          "R_PPC_ADDR32",        /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffffffff,            /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 26 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC_ADDR24,          /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          26,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_bitfield, /* complain_on_overflow */
 389          bfd_elf_generic_reloc, /* special_function */
 390          "R_PPC_ADDR24",        /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x3fffffc,             /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* A standard 16 bit relocation.  */
 397   HOWTO (R_PPC_ADDR16,          /* type */
 398          0,                     /* rightshift */
 399          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 400          16,                    /* bitsize */
 401          FALSE,                 /* pc_relative */
 402          0,                     /* bitpos */
 403          complain_overflow_bitfield, /* complain_on_overflow */
 404          bfd_elf_generic_reloc, /* special_function */
 405          "R_PPC_ADDR16",        /* name */
 406          FALSE,                 /* partial_inplace */
 407          0,                     /* src_mask */
 408          0xffff,                /* dst_mask */
 409          FALSE),                /* pcrel_offset */
 410
 411   /* A 16 bit relocation without overflow.  */
 412   HOWTO (R_PPC_ADDR16_LO,       /* type */
 413          0,                     /* rightshift */
 414          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 415          16,                    /* bitsize */
 416          FALSE,                 /* pc_relative */
 417          0,                     /* bitpos */
 418          complain_overflow_dont,/* complain_on_overflow */
 419          bfd_elf_generic_reloc, /* special_function */
 420          "R_PPC_ADDR16_LO",     /* name */
 421          FALSE,                 /* partial_inplace */
 422          0,                     /* src_mask */
 423          0xffff,                /* dst_mask */
 424          FALSE),                /* pcrel_offset */
 425
 426   /* The high order 16 bits of an address.  */
 427   HOWTO (R_PPC_ADDR16_HI,       /* type */
 428          16,                    /* rightshift */
 429          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 430          16,                    /* bitsize */
 431          FALSE,                 /* pc_relative */
 432          0,                     /* bitpos */
 433          complain_overflow_dont, /* complain_on_overflow */
 434          bfd_elf_generic_reloc, /* special_function */
 435          "R_PPC_ADDR16_HI",     /* name */
 436          FALSE,                 /* partial_inplace */
 437          0,                     /* src_mask */
 438          0xffff,                /* dst_mask */
 439          FALSE),                /* pcrel_offset */
 440
 441   /* The high order 16 bits of an address, plus 1 if the contents of
 442      the low 16 bits, treated as a signed number, is negative.  */
 443   HOWTO (R_PPC_ADDR16_HA,       /* type */
 444          16,                    /* rightshift */
 445          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          16,                    /* bitsize */
 447          FALSE,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_dont, /* complain_on_overflow */
 450          ppc_elf_addr16_ha_reloc, /* special_function */
 451          "R_PPC_ADDR16_HA",     /* name */
 452          FALSE,                 /* partial_inplace */
 453          0,                     /* src_mask */
 454          0xffff,                /* dst_mask */
 455          FALSE),                /* pcrel_offset */
 456
 457   /* An absolute 16 bit branch; the lower two bits must be zero.
 458      FIXME: we don't check that, we just clear them.  */
 459   HOWTO (R_PPC_ADDR14,          /* type */
 460          0,                     /* rightshift */
 461          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 462          16,                    /* bitsize */
 463          FALSE,                 /* pc_relative */
 464          0,                     /* bitpos */
 465          complain_overflow_bitfield, /* complain_on_overflow */
 466          bfd_elf_generic_reloc, /* special_function */
 467          "R_PPC_ADDR14",        /* name */
 468          FALSE,                 /* partial_inplace */
 469          0,                     /* src_mask */
 470          0xfffc,                /* dst_mask */
 471          FALSE),                /* pcrel_offset */
 472
 473   /* An absolute 16 bit branch, for which bit 10 should be set to
 474      indicate that the branch is expected to be taken.  The lower two
 475      bits must be zero.  */
 476   HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
 477          0,                     /* rightshift */
 478          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          16,                    /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_bitfield, /* complain_on_overflow */
 483          bfd_elf_generic_reloc, /* special_function */
 484          "R_PPC_ADDR14_BRTAKEN",/* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0xfffc,                /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* An absolute 16 bit branch, for which bit 10 should be set to
 491      indicate that the branch is not expected to be taken.  The lower
 492      two bits must be zero.  */
 493   HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
 494          0,                     /* rightshift */
 495          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 496          16,                    /* bitsize */
 497          FALSE,                 /* pc_relative */
 498          0,                     /* bitpos */
 499          complain_overflow_bitfield, /* complain_on_overflow */
 500          bfd_elf_generic_reloc, /* special_function */
 501          "R_PPC_ADDR14_BRNTAKEN",/* name */
 502          FALSE,                 /* partial_inplace */
 503          0,                     /* src_mask */
 504          0xfffc,                /* dst_mask */
 505          FALSE),                /* pcrel_offset */
 506
 507   /* A relative 26 bit branch; the lower two bits must be zero.  */
 508   HOWTO (R_PPC_REL24,           /* type */
 509          0,                     /* rightshift */
 510          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          26,                    /* bitsize */
 512          TRUE,                  /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_signed, /* complain_on_overflow */
 515          bfd_elf_generic_reloc, /* special_function */
 516          "R_PPC_REL24",         /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0x3fffffc,             /* dst_mask */
 520          TRUE),                 /* pcrel_offset */
 521
 522   /* A relative 16 bit branch; the lower two bits must be zero.  */
 523   HOWTO (R_PPC_REL14,           /* type */
 524          0,                     /* rightshift */
 525          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          TRUE,                  /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed, /* complain_on_overflow */
 530          bfd_elf_generic_reloc, /* special_function */
 531          "R_PPC_REL14",         /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xfffc,                /* dst_mask */
 535          TRUE),                 /* pcrel_offset */
 536
 537   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 538      the branch is expected to be taken.  The lower two bits must be
 539      zero.  */
 540   HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
 541          0,                     /* rightshift */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          16,                    /* bitsize */
 544          TRUE,                  /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_signed, /* complain_on_overflow */
 547          bfd_elf_generic_reloc, /* special_function */
 548          "R_PPC_REL14_BRTAKEN", /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0xfffc,                /* dst_mask */
 552          TRUE),                 /* pcrel_offset */
 553
 554   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 555      the branch is not expected to be taken.  The lower two bits must
 556      be zero.  */
 557   HOWTO (R_PPC_REL14_BRNTAKEN,  /* type */
 558          0,                     /* rightshift */
 559          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 560          16,                    /* bitsize */
 561          TRUE,                  /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_signed, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC_REL14_BRNTAKEN",/* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          0xfffc,                /* dst_mask */
 569          TRUE),                 /* pcrel_offset */
 570
 571   /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
 572      symbol.  */
 573   HOWTO (R_PPC_GOT16,           /* type */
 574          0,                     /* rightshift */
 575          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 576          16,                    /* bitsize */
 577          FALSE,                 /* pc_relative */
 578          0,                     /* bitpos */
 579          complain_overflow_signed, /* complain_on_overflow */
 580          bfd_elf_generic_reloc, /* special_function */
 581          "R_PPC_GOT16",         /* name */
 582          FALSE,                 /* partial_inplace */
 583          0,                     /* src_mask */
 584          0xffff,                /* dst_mask */
 585          FALSE),                /* pcrel_offset */
 586
 587   /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
 588      the symbol.  */
 589   HOWTO (R_PPC_GOT16_LO,        /* type */
 590          0,                     /* rightshift */
 591          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 592          16,                    /* bitsize */
 593          FALSE,                 /* pc_relative */
 594          0,                     /* bitpos */
 595          complain_overflow_dont, /* complain_on_overflow */
 596          bfd_elf_generic_reloc, /* special_function */
 597          "R_PPC_GOT16_LO",      /* name */
 598          FALSE,                 /* partial_inplace */
 599          0,                     /* src_mask */
 600          0xffff,                /* dst_mask */
 601          FALSE),                /* pcrel_offset */
 602
 603   /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
 604      the symbol.  */
 605   HOWTO (R_PPC_GOT16_HI,        /* type */
 606          16,                    /* rightshift */
 607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 608          16,                    /* bitsize */
 609          FALSE,                 /* pc_relative */
 610          0,                     /* bitpos */
 611          complain_overflow_bitfield, /* complain_on_overflow */
 612          bfd_elf_generic_reloc, /* special_function */
 613          "R_PPC_GOT16_HI",      /* name */
 614          FALSE,                 /* partial_inplace */
 615          0,                     /* src_mask */
 616          0xffff,                /* dst_mask */
 617          FALSE),                 /* pcrel_offset */
 618
 619   /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
 620      the symbol.  */
 621   HOWTO (R_PPC_GOT16_HA,        /* type */
 622          16,                    /* rightshift */
 623          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 624          16,                    /* bitsize */
 625          FALSE,                 /* pc_relative */
 626          0,                     /* bitpos */
 627          complain_overflow_bitfield, /* complain_on_overflow */
 628          ppc_elf_addr16_ha_reloc, /* special_function */
 629          "R_PPC_GOT16_HA",      /* name */
 630          FALSE,                 /* partial_inplace */
 631          0,                     /* src_mask */
 632          0xffff,                /* dst_mask */
 633          FALSE),                /* pcrel_offset */
 634
 635   /* Like R_PPC_REL24, but referring to the procedure linkage table
 636      entry for the symbol.  */
 637   HOWTO (R_PPC_PLTREL24,        /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          26,                    /* bitsize */
 641          TRUE,                  /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_signed,  /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC_PLTREL24",      /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0x3fffffc,             /* dst_mask */
 649          TRUE),                 /* pcrel_offset */
 650
 651   /* This is used only by the dynamic linker.  The symbol should exist
 652      both in the object being run and in some shared library.  The
 653      dynamic linker copies the data addressed by the symbol from the
 654      shared library into the object, because the object being
 655      run has to have the data at some particular address.  */
 656   HOWTO (R_PPC_COPY,            /* type */
 657          0,                     /* rightshift */
 658          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 659          32,                    /* bitsize */
 660          FALSE,                 /* pc_relative */
 661          0,                     /* bitpos */
 662          complain_overflow_bitfield, /* complain_on_overflow */
 663          bfd_elf_generic_reloc,  /* special_function */
 664          "R_PPC_COPY",          /* name */
 665          FALSE,                 /* partial_inplace */
 666          0,                     /* src_mask */
 667          0,                     /* dst_mask */
 668          FALSE),                /* pcrel_offset */
 669
 670   /* Like R_PPC_ADDR32, but used when setting global offset table
 671      entries.  */
 672   HOWTO (R_PPC_GLOB_DAT,        /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          bfd_elf_generic_reloc,  /* special_function */
 680          "R_PPC_GLOB_DAT",      /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* Marks a procedure linkage table entry for a symbol.  */
 687   HOWTO (R_PPC_JMP_SLOT,        /* type */
 688          0,                     /* rightshift */
 689          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          32,                    /* bitsize */
 691          FALSE,                 /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_bitfield, /* complain_on_overflow */
 694          bfd_elf_generic_reloc,  /* special_function */
 695          "R_PPC_JMP_SLOT",      /* name */
 696          FALSE,                 /* partial_inplace */
 697          0,                     /* src_mask */
 698          0,                     /* dst_mask */
 699          FALSE),                /* pcrel_offset */
 700
 701   /* Used only by the dynamic linker.  When the object is run, this
 702      longword is set to the load address of the object, plus the
 703      addend.  */
 704   HOWTO (R_PPC_RELATIVE,        /* type */
 705          0,                     /* rightshift */
 706          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          32,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_bitfield, /* complain_on_overflow */
 711          bfd_elf_generic_reloc,  /* special_function */
 712          "R_PPC_RELATIVE",      /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffffffff,            /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC_REL24, but uses the value of the symbol within the
 719      object rather than the final value.  Normally used for
 720      _GLOBAL_OFFSET_TABLE_.  */
 721   HOWTO (R_PPC_LOCAL24PC,       /* type */
 722          0,                     /* rightshift */
 723          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 724          26,                    /* bitsize */
 725          TRUE,                  /* pc_relative */
 726          0,                     /* bitpos */
 727          complain_overflow_signed, /* complain_on_overflow */
 728          bfd_elf_generic_reloc, /* special_function */
 729          "R_PPC_LOCAL24PC",     /* name */
 730          FALSE,                 /* partial_inplace */
 731          0,                     /* src_mask */
 732          0x3fffffc,             /* dst_mask */
 733          TRUE),                 /* pcrel_offset */
 734
 735   /* Like R_PPC_ADDR32, but may be unaligned.  */
 736   HOWTO (R_PPC_UADDR32,         /* type */
 737          0,                     /* rightshift */
 738          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          32,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_bitfield, /* complain_on_overflow */
 743          bfd_elf_generic_reloc, /* special_function */
 744          "R_PPC_UADDR32",       /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffffffff,            /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* Like R_PPC_ADDR16, but may be unaligned.  */
 751   HOWTO (R_PPC_UADDR16,         /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_bitfield, /* complain_on_overflow */
 758          bfd_elf_generic_reloc, /* special_function */
 759          "R_PPC_UADDR16",       /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* 32-bit PC relative */
 766   HOWTO (R_PPC_REL32,           /* type */
 767          0,                     /* rightshift */
 768          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          32,                    /* bitsize */
 770          TRUE,                  /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_bitfield, /* complain_on_overflow */
 773          bfd_elf_generic_reloc, /* special_function */
 774          "R_PPC_REL32",         /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffffffff,            /* dst_mask */
 778          TRUE),                 /* pcrel_offset */
 779
 780   /* 32-bit relocation to the symbol's procedure linkage table.
 781      FIXME: not supported.  */
 782   HOWTO (R_PPC_PLT32,           /* type */
 783          0,                     /* rightshift */
 784          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 785          32,                    /* bitsize */
 786          FALSE,                 /* pc_relative */
 787          0,                     /* bitpos */
 788          complain_overflow_bitfield, /* complain_on_overflow */
 789          bfd_elf_generic_reloc, /* special_function */
 790          "R_PPC_PLT32",         /* name */
 791          FALSE,                 /* partial_inplace */
 792          0,                     /* src_mask */
 793          0,                     /* dst_mask */
 794          FALSE),                /* pcrel_offset */
 795
 796   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 797      FIXME: not supported.  */
 798   HOWTO (R_PPC_PLTREL32,        /* type */
 799          0,                     /* rightshift */
 800          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 801          32,                    /* bitsize */
 802          TRUE,                  /* pc_relative */
 803          0,                     /* bitpos */
 804          complain_overflow_bitfield, /* complain_on_overflow */
 805          bfd_elf_generic_reloc, /* special_function */
 806          "R_PPC_PLTREL32",      /* name */
 807          FALSE,                 /* partial_inplace */
 808          0,                     /* src_mask */
 809          0,                     /* dst_mask */
 810          TRUE),                 /* pcrel_offset */
 811
 812   /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
 813      the symbol.  */
 814   HOWTO (R_PPC_PLT16_LO,        /* type */
 815          0,                     /* rightshift */
 816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 817          16,                    /* bitsize */
 818          FALSE,                 /* pc_relative */
 819          0,                     /* bitpos */
 820          complain_overflow_dont, /* complain_on_overflow */
 821          bfd_elf_generic_reloc, /* special_function */
 822          "R_PPC_PLT16_LO",      /* name */
 823          FALSE,                 /* partial_inplace */
 824          0,                     /* src_mask */
 825          0xffff,                /* dst_mask */
 826          FALSE),                /* pcrel_offset */
 827
 828   /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
 829      the symbol.  */
 830   HOWTO (R_PPC_PLT16_HI,        /* type */
 831          16,                    /* rightshift */
 832          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 833          16,                    /* bitsize */
 834          FALSE,                 /* pc_relative */
 835          0,                     /* bitpos */
 836          complain_overflow_bitfield, /* complain_on_overflow */
 837          bfd_elf_generic_reloc, /* special_function */
 838          "R_PPC_PLT16_HI",      /* name */
 839          FALSE,                 /* partial_inplace */
 840          0,                     /* src_mask */
 841          0xffff,                /* dst_mask */
 842          FALSE),                 /* pcrel_offset */
 843
 844   /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
 845      the symbol.  */
 846   HOWTO (R_PPC_PLT16_HA,        /* type */
 847          16,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_bitfield, /* complain_on_overflow */
 853          ppc_elf_addr16_ha_reloc, /* special_function */
 854          "R_PPC_PLT16_HA",      /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
 861      small data items.  */
 862   HOWTO (R_PPC_SDAREL16,        /* type */
 863          0,                     /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_signed, /* complain_on_overflow */
 869          bfd_elf_generic_reloc, /* special_function */
 870          "R_PPC_SDAREL16",      /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* 16-bit section relative relocation.  */
 877   HOWTO (R_PPC_SECTOFF,         /* type */
 878          0,                     /* rightshift */
 879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          16,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_bitfield, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC_SECTOFF",       /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          0xffff,                /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* 16-bit lower half section relative relocation.  */
 892   HOWTO (R_PPC_SECTOFF_LO,        /* type */
 893          0,                     /* rightshift */
 894          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 895          16,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_PPC_SECTOFF_LO",    /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          0xffff,                /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   /* 16-bit upper half section relative relocation.  */
 907   HOWTO (R_PPC_SECTOFF_HI,      /* type */
 908          16,                    /* rightshift */
 909          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 910          16,                    /* bitsize */
 911          FALSE,                 /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_bitfield, /* complain_on_overflow */
 914          bfd_elf_generic_reloc, /* special_function */
 915          "R_PPC_SECTOFF_HI",    /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          0xffff,                /* dst_mask */
 919          FALSE),                 /* pcrel_offset */
 920
 921   /* 16-bit upper half adjusted section relative relocation.  */
 922   HOWTO (R_PPC_SECTOFF_HA,      /* type */
 923          16,                    /* rightshift */
 924          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 925          16,                    /* bitsize */
 926          FALSE,                 /* pc_relative */
 927          0,                     /* bitpos */
 928          complain_overflow_bitfield, /* complain_on_overflow */
 929          ppc_elf_addr16_ha_reloc, /* special_function */
 930          "R_PPC_SECTOFF_HA",    /* name */
 931          FALSE,                 /* partial_inplace */
 932          0,                     /* src_mask */
 933          0xffff,                /* dst_mask */
 934          FALSE),                /* pcrel_offset */
 935
 936   /* Marker reloc for TLS.  */
 937   HOWTO (R_PPC_TLS,
 938          0,                     /* rightshift */
 939          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 940          32,                    /* bitsize */
 941          FALSE,                 /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          bfd_elf_generic_reloc, /* special_function */
 945          "R_PPC_TLS",           /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          0,                     /* dst_mask */
 949          FALSE),                /* pcrel_offset */
 950
 951   /* Computes the load module index of the load module that contains the
 952      definition of its TLS sym.  */
 953   HOWTO (R_PPC_DTPMOD32,
 954          0,                     /* rightshift */
 955          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 956          32,                    /* bitsize */
 957          FALSE,                 /* pc_relative */
 958          0,                     /* bitpos */
 959          complain_overflow_dont, /* complain_on_overflow */
 960          ppc_elf_unhandled_reloc, /* special_function */
 961          "R_PPC_DTPMOD32",      /* name */
 962          FALSE,                 /* partial_inplace */
 963          0,                     /* src_mask */
 964          0xffffffff,            /* dst_mask */
 965          FALSE),                /* pcrel_offset */
 966
 967   /* Computes a dtv-relative displacement, the difference between the value
 968      of sym+add and the base address of the thread-local storage block that
 969      contains the definition of sym, minus 0x8000.  */
 970   HOWTO (R_PPC_DTPREL32,
 971          0,                     /* rightshift */
 972          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 973          32,                    /* bitsize */
 974          FALSE,                 /* pc_relative */
 975          0,                     /* bitpos */
 976          complain_overflow_dont, /* complain_on_overflow */
 977          ppc_elf_unhandled_reloc, /* special_function */
 978          "R_PPC_DTPREL32",      /* name */
 979          FALSE,                 /* partial_inplace */
 980          0,                     /* src_mask */
 981          0xffffffff,            /* dst_mask */
 982          FALSE),                /* pcrel_offset */
 983
 984   /* A 16 bit dtprel reloc.  */
 985   HOWTO (R_PPC_DTPREL16,
 986          0,                     /* rightshift */
 987          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 988          16,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_signed, /* complain_on_overflow */
 992          ppc_elf_unhandled_reloc, /* special_function */
 993          "R_PPC_DTPREL16",      /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          0xffff,                /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* Like DTPREL16, but no overflow.  */
1000   HOWTO (R_PPC_DTPREL16_LO,
1001          0,                     /* rightshift */
1002          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1003          16,                    /* bitsize */
1004          FALSE,                 /* pc_relative */
1005          0,                     /* bitpos */
1006          complain_overflow_dont, /* complain_on_overflow */
1007          ppc_elf_unhandled_reloc, /* special_function */
1008          "R_PPC_DTPREL16_LO",   /* name */
1009          FALSE,                 /* partial_inplace */
1010          0,                     /* src_mask */
1011          0xffff,                /* dst_mask */
1012          FALSE),                /* pcrel_offset */
1013
1014   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1015   HOWTO (R_PPC_DTPREL16_HI,
1016          16,                    /* rightshift */
1017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1018          16,                    /* bitsize */
1019          FALSE,                 /* pc_relative */
1020          0,                     /* bitpos */
1021          complain_overflow_dont, /* complain_on_overflow */
1022          ppc_elf_unhandled_reloc, /* special_function */
1023          "R_PPC_DTPREL16_HI",   /* name */
1024          FALSE,                 /* partial_inplace */
1025          0,                     /* src_mask */
1026          0xffff,                /* dst_mask */
1027          FALSE),                /* pcrel_offset */
1028
1029   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1030   HOWTO (R_PPC_DTPREL16_HA,
1031          16,                    /* rightshift */
1032          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1033          16,                    /* bitsize */
1034          FALSE,                 /* pc_relative */
1035          0,                     /* bitpos */
1036          complain_overflow_dont, /* complain_on_overflow */
1037          ppc_elf_unhandled_reloc, /* special_function */
1038          "R_PPC_DTPREL16_HA",   /* name */
1039          FALSE,                 /* partial_inplace */
1040          0,                     /* src_mask */
1041          0xffff,                /* dst_mask */
1042          FALSE),                /* pcrel_offset */
1043
1044   /* Computes a tp-relative displacement, the difference between the value of
1045      sym+add and the value of the thread pointer (r13).  */
1046   HOWTO (R_PPC_TPREL32,
1047          0,                     /* rightshift */
1048          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049          32,                    /* bitsize */
1050          FALSE,                 /* pc_relative */
1051          0,                     /* bitpos */
1052          complain_overflow_dont, /* complain_on_overflow */
1053          ppc_elf_unhandled_reloc, /* special_function */
1054          "R_PPC_TPREL32",       /* name */
1055          FALSE,                 /* partial_inplace */
1056          0,                     /* src_mask */
1057          0xffffffff,            /* dst_mask */
1058          FALSE),                /* pcrel_offset */
1059
1060   /* A 16 bit tprel reloc.  */
1061   HOWTO (R_PPC_TPREL16,
1062          0,                     /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_signed, /* complain_on_overflow */
1068          ppc_elf_unhandled_reloc, /* special_function */
1069          "R_PPC_TPREL16",       /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xffff,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like TPREL16, but no overflow.  */
1076   HOWTO (R_PPC_TPREL16_LO,
1077          0,                     /* rightshift */
1078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          16,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          0,                     /* bitpos */
1082          complain_overflow_dont, /* complain_on_overflow */
1083          ppc_elf_unhandled_reloc, /* special_function */
1084          "R_PPC_TPREL16_LO",    /* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0xffff,                /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1091   HOWTO (R_PPC_TPREL16_HI,
1092          16,                    /* rightshift */
1093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          16,                    /* bitsize */
1095          FALSE,                 /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_dont, /* complain_on_overflow */
1098          ppc_elf_unhandled_reloc, /* special_function */
1099          "R_PPC_TPREL16_HI",    /* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0xffff,                /* dst_mask */
1103          FALSE),                /* pcrel_offset */
1104
1105   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1106   HOWTO (R_PPC_TPREL16_HA,
1107          16,                    /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_dont, /* complain_on_overflow */
1113          ppc_elf_unhandled_reloc, /* special_function */
1114          "R_PPC_TPREL16_HA",    /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xffff,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1121      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1122      to the first entry.  */
1123   HOWTO (R_PPC_GOT_TLSGD16,
1124          0,                     /* rightshift */
1125          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1126          16,                    /* bitsize */
1127          FALSE,                 /* pc_relative */
1128          0,                     /* bitpos */
1129          complain_overflow_signed, /* complain_on_overflow */
1130          ppc_elf_unhandled_reloc, /* special_function */
1131          "R_PPC_GOT_TLSGD16",   /* name */
1132          FALSE,                 /* partial_inplace */
1133          0,                     /* src_mask */
1134          0xffff,                /* dst_mask */
1135          FALSE),                /* pcrel_offset */
1136
1137   /* Like GOT_TLSGD16, but no overflow.  */
1138   HOWTO (R_PPC_GOT_TLSGD16_LO,
1139          0,                     /* rightshift */
1140          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1141          16,                    /* bitsize */
1142          FALSE,                 /* pc_relative */
1143          0,                     /* bitpos */
1144          complain_overflow_dont, /* complain_on_overflow */
1145          ppc_elf_unhandled_reloc, /* special_function */
1146          "R_PPC_GOT_TLSGD16_LO", /* name */
1147          FALSE,                 /* partial_inplace */
1148          0,                     /* src_mask */
1149          0xffff,                /* dst_mask */
1150          FALSE),                /* pcrel_offset */
1151
1152   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1153   HOWTO (R_PPC_GOT_TLSGD16_HI,
1154          16,                    /* rightshift */
1155          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1156          16,                    /* bitsize */
1157          FALSE,                 /* pc_relative */
1158          0,                     /* bitpos */
1159          complain_overflow_dont, /* complain_on_overflow */
1160          ppc_elf_unhandled_reloc, /* special_function */
1161          "R_PPC_GOT_TLSGD16_HI", /* name */
1162          FALSE,                 /* partial_inplace */
1163          0,                     /* src_mask */
1164          0xffff,                /* dst_mask */
1165          FALSE),                /* pcrel_offset */
1166
1167   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1168   HOWTO (R_PPC_GOT_TLSGD16_HA,
1169          16,                    /* rightshift */
1170          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1171          16,                    /* bitsize */
1172          FALSE,                 /* pc_relative */
1173          0,                     /* bitpos */
1174          complain_overflow_dont, /* complain_on_overflow */
1175          ppc_elf_unhandled_reloc, /* special_function */
1176          "R_PPC_GOT_TLSGD16_HA", /* name */
1177          FALSE,                 /* partial_inplace */
1178          0,                     /* src_mask */
1179          0xffff,                /* dst_mask */
1180          FALSE),                /* pcrel_offset */
1181
1182   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1183      with values (sym+add)@dtpmod and zero, and computes the offset to the
1184      first entry.  */
1185   HOWTO (R_PPC_GOT_TLSLD16,
1186          0,                     /* rightshift */
1187          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1188          16,                    /* bitsize */
1189          FALSE,                 /* pc_relative */
1190          0,                     /* bitpos */
1191          complain_overflow_signed, /* complain_on_overflow */
1192          ppc_elf_unhandled_reloc, /* special_function */
1193          "R_PPC_GOT_TLSLD16",   /* name */
1194          FALSE,                 /* partial_inplace */
1195          0,                     /* src_mask */
1196          0xffff,                /* dst_mask */
1197          FALSE),                /* pcrel_offset */
1198
1199   /* Like GOT_TLSLD16, but no overflow.  */
1200   HOWTO (R_PPC_GOT_TLSLD16_LO,
1201          0,                     /* rightshift */
1202          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1203          16,                    /* bitsize */
1204          FALSE,                 /* pc_relative */
1205          0,                     /* bitpos */
1206          complain_overflow_dont, /* complain_on_overflow */
1207          ppc_elf_unhandled_reloc, /* special_function */
1208          "R_PPC_GOT_TLSLD16_LO", /* name */
1209          FALSE,                 /* partial_inplace */
1210          0,                     /* src_mask */
1211          0xffff,                /* dst_mask */
1212          FALSE),                /* pcrel_offset */
1213
1214   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1215   HOWTO (R_PPC_GOT_TLSLD16_HI,
1216          16,                    /* rightshift */
1217          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1218          16,                    /* bitsize */
1219          FALSE,                 /* pc_relative */
1220          0,                     /* bitpos */
1221          complain_overflow_dont, /* complain_on_overflow */
1222          ppc_elf_unhandled_reloc, /* special_function */
1223          "R_PPC_GOT_TLSLD16_HI", /* name */
1224          FALSE,                 /* partial_inplace */
1225          0,                     /* src_mask */
1226          0xffff,                /* dst_mask */
1227          FALSE),                /* pcrel_offset */
1228
1229   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1230   HOWTO (R_PPC_GOT_TLSLD16_HA,
1231          16,                    /* rightshift */
1232          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1233          16,                    /* bitsize */
1234          FALSE,                 /* pc_relative */
1235          0,                     /* bitpos */
1236          complain_overflow_dont, /* complain_on_overflow */
1237          ppc_elf_unhandled_reloc, /* special_function */
1238          "R_PPC_GOT_TLSLD16_HA", /* name */
1239          FALSE,                 /* partial_inplace */
1240          0,                     /* src_mask */
1241          0xffff,                /* dst_mask */
1242          FALSE),                /* pcrel_offset */
1243
1244   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1245      the offset to the entry.  */
1246   HOWTO (R_PPC_GOT_DTPREL16,
1247          0,                     /* rightshift */
1248          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1249          16,                    /* bitsize */
1250          FALSE,                 /* pc_relative */
1251          0,                     /* bitpos */
1252          complain_overflow_signed, /* complain_on_overflow */
1253          ppc_elf_unhandled_reloc, /* special_function */
1254          "R_PPC_GOT_DTPREL16",  /* name */
1255          FALSE,                 /* partial_inplace */
1256          0,                     /* src_mask */
1257          0xffff,                /* dst_mask */
1258          FALSE),                /* pcrel_offset */
1259
1260   /* Like GOT_DTPREL16, but no overflow.  */
1261   HOWTO (R_PPC_GOT_DTPREL16_LO,
1262          0,                     /* rightshift */
1263          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1264          16,                    /* bitsize */
1265          FALSE,                 /* pc_relative */
1266          0,                     /* bitpos */
1267          complain_overflow_dont, /* complain_on_overflow */
1268          ppc_elf_unhandled_reloc, /* special_function */
1269          "R_PPC_GOT_DTPREL16_LO", /* name */
1270          FALSE,                 /* partial_inplace */
1271          0,                     /* src_mask */
1272          0xffff,                /* dst_mask */
1273          FALSE),                /* pcrel_offset */
1274
1275   /* Like GOT_DTPREL16_LO, but next higher group of 16 bits.  */
1276   HOWTO (R_PPC_GOT_DTPREL16_HI,
1277          16,                    /* rightshift */
1278          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1279          16,                    /* bitsize */
1280          FALSE,                 /* pc_relative */
1281          0,                     /* bitpos */
1282          complain_overflow_dont, /* complain_on_overflow */
1283          ppc_elf_unhandled_reloc, /* special_function */
1284          "R_PPC_GOT_DTPREL16_HI", /* name */
1285          FALSE,                 /* partial_inplace */
1286          0,                     /* src_mask */
1287          0xffff,                /* dst_mask */
1288          FALSE),                /* pcrel_offset */
1289
1290   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1291   HOWTO (R_PPC_GOT_DTPREL16_HA,
1292          16,                    /* rightshift */
1293          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1294          16,                    /* bitsize */
1295          FALSE,                 /* pc_relative */
1296          0,                     /* bitpos */
1297          complain_overflow_dont, /* complain_on_overflow */
1298          ppc_elf_unhandled_reloc, /* special_function */
1299          "R_PPC_GOT_DTPREL16_HA", /* name */
1300          FALSE,                 /* partial_inplace */
1301          0,                     /* src_mask */
1302          0xffff,                /* dst_mask */
1303          FALSE),                /* pcrel_offset */
1304
1305   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1306      offset to the entry.  */
1307   HOWTO (R_PPC_GOT_TPREL16,
1308          0,                     /* rightshift */
1309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          16,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_signed, /* complain_on_overflow */
1314          ppc_elf_unhandled_reloc, /* special_function */
1315          "R_PPC_GOT_TPREL16",   /* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0xffff,                /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   /* Like GOT_TPREL16, but no overflow.  */
1322   HOWTO (R_PPC_GOT_TPREL16_LO,
1323          0,                     /* rightshift */
1324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          16,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          ppc_elf_unhandled_reloc, /* special_function */
1330          "R_PPC_GOT_TPREL16_LO", /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0xffff,                /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   /* Like GOT_TPREL16_LO, but next higher group of 16 bits.  */
1337   HOWTO (R_PPC_GOT_TPREL16_HI,
1338          16,                    /* rightshift */
1339          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1340          16,                    /* bitsize */
1341          FALSE,                 /* pc_relative */
1342          0,                     /* bitpos */
1343          complain_overflow_dont, /* complain_on_overflow */
1344          ppc_elf_unhandled_reloc, /* special_function */
1345          "R_PPC_GOT_TPREL16_HI", /* name */
1346          FALSE,                 /* partial_inplace */
1347          0,                     /* src_mask */
1348          0xffff,                /* dst_mask */
1349          FALSE),                /* pcrel_offset */
1350
1351   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1352   HOWTO (R_PPC_GOT_TPREL16_HA,
1353          16,                    /* rightshift */
1354          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          16,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc_elf_unhandled_reloc, /* special_function */
1360          "R_PPC_GOT_TPREL16_HA", /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          0xffff,                /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* The remaining relocs are from the Embedded ELF ABI, and are not
1367      in the SVR4 ELF ABI.  */
1368
1369   /* 32 bit value resulting from the addend minus the symbol.  */
1370   HOWTO (R_PPC_EMB_NADDR32,     /* type */
1371          0,                     /* rightshift */
1372          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1373          32,                    /* bitsize */
1374          FALSE,                 /* pc_relative */
1375          0,                     /* bitpos */
1376          complain_overflow_bitfield, /* complain_on_overflow */
1377          bfd_elf_generic_reloc, /* special_function */
1378          "R_PPC_EMB_NADDR32",   /* name */
1379          FALSE,                 /* partial_inplace */
1380          0,                     /* src_mask */
1381          0xffffffff,            /* dst_mask */
1382          FALSE),                /* pcrel_offset */
1383
1384   /* 16 bit value resulting from the addend minus the symbol.  */
1385   HOWTO (R_PPC_EMB_NADDR16,     /* type */
1386          0,                     /* rightshift */
1387          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1388          16,                    /* bitsize */
1389          FALSE,                 /* pc_relative */
1390          0,                     /* bitpos */
1391          complain_overflow_bitfield, /* complain_on_overflow */
1392          bfd_elf_generic_reloc, /* special_function */
1393          "R_PPC_EMB_NADDR16",   /* name */
1394          FALSE,                 /* partial_inplace */
1395          0,                     /* src_mask */
1396          0xffff,                /* dst_mask */
1397          FALSE),                /* pcrel_offset */
1398
1399   /* 16 bit value resulting from the addend minus the symbol.  */
1400   HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
1401          0,                     /* rightshift */
1402          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1403          16,                    /* bitsize */
1404          FALSE,                 /* pc_relative */
1405          0,                     /* bitpos */
1406          complain_overflow_dont,/* complain_on_overflow */
1407          bfd_elf_generic_reloc, /* special_function */
1408          "R_PPC_EMB_ADDR16_LO", /* name */
1409          FALSE,                 /* partial_inplace */
1410          0,                     /* src_mask */
1411          0xffff,                /* dst_mask */
1412          FALSE),                /* pcrel_offset */
1413
1414   /* The high order 16 bits of the addend minus the symbol.  */
1415   HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
1416          16,                    /* rightshift */
1417          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1418          16,                    /* bitsize */
1419          FALSE,                 /* pc_relative */
1420          0,                     /* bitpos */
1421          complain_overflow_dont, /* complain_on_overflow */
1422          bfd_elf_generic_reloc, /* special_function */
1423          "R_PPC_EMB_NADDR16_HI", /* name */
1424          FALSE,                 /* partial_inplace */
1425          0,                     /* src_mask */
1426          0xffff,                /* dst_mask */
1427          FALSE),                /* pcrel_offset */
1428
1429   /* The high order 16 bits of the result of the addend minus the address,
1430      plus 1 if the contents of the low 16 bits, treated as a signed number,
1431      is negative.  */
1432   HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
1433          16,                    /* rightshift */
1434          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          16,                    /* bitsize */
1436          FALSE,                 /* pc_relative */
1437          0,                     /* bitpos */
1438          complain_overflow_dont, /* complain_on_overflow */
1439          ppc_elf_addr16_ha_reloc, /* special_function */
1440          "R_PPC_EMB_NADDR16_HA", /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0xffff,                /* dst_mask */
1444          FALSE),                /* pcrel_offset */
1445
1446   /* 16 bit value resulting from allocating a 4 byte word to hold an
1447      address in the .sdata section, and returning the offset from
1448      _SDA_BASE_ for that relocation.  */
1449   HOWTO (R_PPC_EMB_SDAI16,      /* type */
1450          0,                     /* rightshift */
1451          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1452          16,                    /* bitsize */
1453          FALSE,                 /* pc_relative */
1454          0,                     /* bitpos */
1455          complain_overflow_bitfield, /* complain_on_overflow */
1456          bfd_elf_generic_reloc, /* special_function */
1457          "R_PPC_EMB_SDAI16",    /* name */
1458          FALSE,                 /* partial_inplace */
1459          0,                     /* src_mask */
1460          0xffff,                /* dst_mask */
1461          FALSE),                /* pcrel_offset */
1462
1463   /* 16 bit value resulting from allocating a 4 byte word to hold an
1464      address in the .sdata2 section, and returning the offset from
1465      _SDA2_BASE_ for that relocation.  */
1466   HOWTO (R_PPC_EMB_SDA2I16,     /* type */
1467          0,                     /* rightshift */
1468          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1469          16,                    /* bitsize */
1470          FALSE,                 /* pc_relative */
1471          0,                     /* bitpos */
1472          complain_overflow_bitfield, /* complain_on_overflow */
1473          bfd_elf_generic_reloc, /* special_function */
1474          "R_PPC_EMB_SDA2I16",   /* name */
1475          FALSE,                 /* partial_inplace */
1476          0,                     /* src_mask */
1477          0xffff,                /* dst_mask */
1478          FALSE),                /* pcrel_offset */
1479
1480   /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
1481      small data items.   */
1482   HOWTO (R_PPC_EMB_SDA2REL,     /* type */
1483          0,                     /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_signed, /* complain_on_overflow */
1489          bfd_elf_generic_reloc, /* special_function */
1490          "R_PPC_EMB_SDA2REL",   /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
1497      signed offset from the appropriate base, and filling in the register
1498      field with the appropriate register (0, 2, or 13).  */
1499   HOWTO (R_PPC_EMB_SDA21,       /* type */
1500          0,                     /* rightshift */
1501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          bfd_elf_generic_reloc, /* special_function */
1507          "R_PPC_EMB_SDA21",     /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xffff,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Relocation not handled: R_PPC_EMB_MRKREF */
1514   /* Relocation not handled: R_PPC_EMB_RELSEC16 */
1515   /* Relocation not handled: R_PPC_EMB_RELST_LO */
1516   /* Relocation not handled: R_PPC_EMB_RELST_HI */
1517   /* Relocation not handled: R_PPC_EMB_RELST_HA */
1518   /* Relocation not handled: R_PPC_EMB_BIT_FLD */
1519
1520   /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
1521      in the 16 bit signed offset from the appropriate base, and filling in the
1522      register field with the appropriate register (0, 2, or 13).  */
1523   HOWTO (R_PPC_EMB_RELSDA,      /* type */
1524          0,                     /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          TRUE,                  /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_signed, /* complain_on_overflow */
1530          bfd_elf_generic_reloc, /* special_function */
1531          "R_PPC_EMB_RELSDA",    /* name */
1532          FALSE,                 /* partial_inplace */
1533          0,                     /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Phony reloc to handle branch stubs.  */
1538   HOWTO (R_PPC_RELAX32,         /* type */
1539          0,                     /* rightshift */
1540          0,                     /* size */
1541          0,                     /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_dont, /* complain_on_overflow */
1545          bfd_elf_generic_reloc, /* special_function */
1546          "R_PPC_RELAX32",       /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          0,                     /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* GNU extension to record C++ vtable hierarchy.  */
1553   HOWTO (R_PPC_GNU_VTINHERIT,   /* type */
1554          0,                     /* rightshift */
1555          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1556          0,                     /* bitsize */
1557          FALSE,                 /* pc_relative */
1558          0,                     /* bitpos */
1559          complain_overflow_dont, /* complain_on_overflow */
1560          NULL,                  /* special_function */
1561          "R_PPC_GNU_VTINHERIT", /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0,                     /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* GNU extension to record C++ vtable member usage.  */
1568   HOWTO (R_PPC_GNU_VTENTRY,     /* type */
1569          0,                     /* rightshift */
1570          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1571          0,                     /* bitsize */
1572          FALSE,                 /* pc_relative */
1573          0,                     /* bitpos */
1574          complain_overflow_dont, /* complain_on_overflow */
1575          NULL,                  /* special_function */
1576          "R_PPC_GNU_VTENTRY",   /* name */
1577          FALSE,                 /* partial_inplace */
1578          0,                     /* src_mask */
1579          0,                     /* dst_mask */
1580          FALSE),                /* pcrel_offset */
1581
1582   /* Phony reloc to handle AIX style TOC entries.  */
1583   HOWTO (R_PPC_TOC16,           /* type */
1584          0,                     /* rightshift */
1585          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          16,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_signed, /* complain_on_overflow */
1590          bfd_elf_generic_reloc, /* special_function */
1591          "R_PPC_TOC16",         /* name */
1592          FALSE,                 /* partial_inplace */
1593          0,                     /* src_mask */
1594          0xffff,                /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596 };
1597 \f
1598 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
1599
1600 static void
1601 ppc_elf_howto_init (void)
1602 {
1603   unsigned int i, type;
1604
1605   for (i = 0;
1606        i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]);
1607        i++)
1608     {
1609       type = ppc_elf_howto_raw[i].type;
1610       if (type >= (sizeof (ppc_elf_howto_table)
1611                    / sizeof (ppc_elf_howto_table[0])))
1612         abort ();
1613       ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
1614     }
1615 }
1616 \f
1617 static bfd_reloc_status_type
1618 ppc_elf_install_value (bfd *abfd,
1619                        bfd_byte *hit_addr,
1620                        bfd_vma v,
1621                        unsigned int r_type)
1622 {
1623   bfd_vma t0, t1;
1624 #ifdef BFD_HOST_U_64_BIT
1625   BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
1626 #else
1627   bfd_vma val = v;
1628 #endif
1629
1630   switch (r_type)
1631     {
1632     case R_PPC_RELAX32:
1633       /* Do stuff here.  */
1634       t0 = bfd_get_32 (abfd, hit_addr);
1635       t1 = bfd_get_32 (abfd, hit_addr + 4);
1636
1637       /* We're clearing the bits for R_PPC_ADDR16_HA
1638          and R_PPC_ADDR16_LO here.  */
1639       t0 &= ~0xffff;
1640       t1 &= ~0xffff;
1641
1642       /* t0 is HA, t1 is lo */
1643       t0 |= ((val + 0x8000) >> 16) & 0xffff;
1644       t1 |= val & 0xffff;
1645
1646       bfd_put_32 (abfd, t0, hit_addr);
1647       bfd_put_32 (abfd, t1, hit_addr + 4);
1648       break;
1649
1650     case R_PPC_REL24:
1651       t0 = bfd_get_32 (abfd, hit_addr);
1652       t0 &= ~0x3fffffc;
1653       t0 |= val & 0x3fffffc;
1654       bfd_put_32 (abfd, t0, hit_addr);
1655       break;
1656
1657     case R_PPC_REL14:
1658     case R_PPC_REL14_BRTAKEN:
1659     case R_PPC_REL14_BRNTAKEN:
1660       t0 = bfd_get_32 (abfd, hit_addr);
1661       t0 &= ~0xfffc;
1662       t0 |= val & 0xfffc;
1663       bfd_put_32 (abfd, t0, hit_addr);
1664       break;
1665
1666     case R_PPC_LOCAL24PC:
1667     case R_PPC_PLTREL24:
1668       t0 = bfd_get_32 (abfd, hit_addr);
1669       t0 &= ~0x3fffffc;
1670       t0 |= val & 0x3fffffc;
1671       bfd_put_32 (abfd, t0, hit_addr);
1672       break;
1673
1674     default:
1675       return bfd_reloc_notsupported;
1676     }
1677
1678   return bfd_reloc_ok;
1679 }
1680
1681 static const bfd_byte shared_stub_entry[] =
1682   {
1683     0x48, 0x00, 0x00, 0x24, /* b .+36 */
1684     0x7c, 0x08, 0x02, 0xa6, /* mflr 0 */
1685     0x42, 0x9f, 0x00, 0x05, /* bcl 20, 31, .Lxxx */
1686     0x7d, 0x68, 0x02, 0xa6, /* mflr 11 */
1687     0x3d, 0x60, 0x00, 0x00, /* addis 11, 11, (xxx-.Lxxx)@ha */
1688     0x39, 0x6b, 0x00, 0x18, /* addi 11, 11, (xxx-.Lxxx)@l */
1689     0x7c, 0x08, 0x03, 0xa6, /* mtlr 0 */
1690     0x7d, 0x69, 0x03, 0xa6, /* mtctr 11 */
1691     0x4e, 0x80, 0x04, 0x20, /* bctr */
1692   };
1693
1694 static const bfd_byte stub_entry[] =
1695   {
1696     0x48, 0x00, 0x00, 0x14, /* b .+20 */
1697     0x3d, 0x60, 0x00, 0x00, /* lis 11,xxx@ha */
1698     0x39, 0x6b, 0x00, 0x00, /* addi 11,11,xxx@l */
1699     0x7d, 0x69, 0x03, 0xa6, /* mtctr 11 */
1700     0x4e, 0x80, 0x04, 0x20, /* bctr */
1701   };
1702
1703
1704 static bfd_boolean
1705 ppc_elf_relax_section (bfd *abfd,
1706                        asection *isec,
1707                        struct bfd_link_info *link_info,
1708                        bfd_boolean *again)
1709 {
1710   struct one_fixup
1711   {
1712     struct one_fixup *next;
1713     asection *tsec;
1714     bfd_vma toff;
1715     bfd_vma trampoff;
1716   };
1717
1718   Elf_Internal_Shdr *symtab_hdr;
1719   bfd_byte *contents = NULL;
1720   Elf_Internal_Sym *isymbuf = NULL;
1721   Elf_Internal_Rela *internal_relocs = NULL;
1722   Elf_Internal_Rela *irel, *irelend;
1723   struct one_fixup *fixups = NULL;
1724   bfd_boolean changed_contents = FALSE;
1725   bfd_boolean changed_relocs = FALSE;
1726   struct ppc_elf_link_hash_table *ppc_info;
1727
1728   *again = FALSE;
1729
1730   /* Nothing to do if there are no relocations and no need for
1731      the relax finalize pass.  */
1732   if ((isec->flags & SEC_RELOC) == 0
1733       || isec->reloc_count == 0
1734       || link_info->relax_finalizing)
1735     return TRUE;
1736
1737   /* If needed, initialize this section's cooked size.  */
1738   if (isec->_cooked_size == 0)
1739     isec->_cooked_size = isec->_raw_size;
1740
1741   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1742
1743   /* Get a copy of the native relocations.  */
1744   internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL,
1745                                                link_info->keep_memory);
1746   if (internal_relocs == NULL)
1747     goto error_return;
1748
1749   ppc_info = ppc_elf_hash_table (link_info);
1750   irelend = internal_relocs + isec->reloc_count;
1751
1752   /* Get the section contents.  */
1753   /* Get cached copy if it exists.  */
1754   if (elf_section_data (isec)->this_hdr.contents != NULL)
1755     contents = elf_section_data (isec)->this_hdr.contents;
1756   else
1757     {
1758       /* Go get them off disk.  */
1759       contents = bfd_malloc (isec->_raw_size);
1760       if (contents == NULL)
1761         goto error_return;
1762
1763       if (!bfd_get_section_contents (abfd, isec, contents, 0, isec->_raw_size))
1764         goto error_return;
1765     }
1766
1767   for (irel = internal_relocs; irel < irelend; irel++)
1768     {
1769       unsigned long r_type = ELF32_R_TYPE (irel->r_info);
1770       bfd_vma symaddr, reladdr, trampoff, toff, roff;
1771       asection *tsec;
1772       bfd_size_type amt;
1773       struct one_fixup *f;
1774       size_t insn_offset = 0;
1775       bfd_vma max_branch_offset;
1776
1777       switch (r_type)
1778         {
1779         case R_PPC_REL24:
1780         case R_PPC_LOCAL24PC:
1781         case R_PPC_REL14:
1782         case R_PPC_REL14_BRTAKEN:
1783         case R_PPC_REL14_BRNTAKEN:
1784         case R_PPC_PLTREL24:
1785           break;
1786
1787         default:
1788           continue;
1789         }
1790
1791       /* Get the value of the symbol referred to by the reloc.  */
1792       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1793         {
1794           /* A local symbol.  */
1795           Elf_Internal_Sym *isym;
1796
1797           /* Read this BFD's local symbols.  */
1798           if (isymbuf == NULL)
1799             {
1800               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1801               if (isymbuf == NULL)
1802                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1803                                                 symtab_hdr->sh_info, 0,
1804                                                 NULL, NULL, NULL);
1805               if (isymbuf == 0)
1806                 goto error_return;
1807             }
1808           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1809           if (isym->st_shndx == SHN_UNDEF)
1810             continue;   /* We can't do anthing with undefined symbols.  */
1811           else if (isym->st_shndx == SHN_ABS)
1812             tsec = bfd_abs_section_ptr;
1813           else if (isym->st_shndx == SHN_COMMON)
1814             tsec = bfd_com_section_ptr;
1815           else
1816             tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1817
1818           toff = isym->st_value;
1819         }
1820       else
1821         {
1822           /* Need dynamic symbol handling.  */
1823           unsigned long indx;
1824           struct elf_link_hash_entry *h;
1825
1826           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1827           h = elf_sym_hashes (abfd)[indx];
1828
1829           while (h->root.type == bfd_link_hash_indirect
1830                  || h->root.type == bfd_link_hash_warning)
1831             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1832
1833           if (r_type == R_PPC_PLTREL24)
1834             {
1835               Elf_Internal_Sym *isym;
1836
1837               if (h->plt.offset == (bfd_vma) -1
1838                   || ppc_info->plt == NULL)
1839                 {
1840
1841                   /* Read this BFD's local symbols.  */
1842                   if (isymbuf == NULL)
1843                     {
1844                       isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1845                       if (isymbuf == NULL)
1846                         isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1847                                                         symtab_hdr->sh_info, 0,
1848                                                         NULL, NULL, NULL);
1849                       if (isymbuf == 0)
1850                         goto error_return;
1851                     }
1852                   isym = isymbuf + ELF32_R_SYM (irel->r_info);
1853
1854                   if (isym->st_shndx == SHN_UNDEF)
1855                     /* We can't do anthing with undefined symbols.  */
1856                     continue;
1857                   else if (isym->st_shndx == SHN_ABS)
1858                     tsec = bfd_abs_section_ptr;
1859                   else if (isym->st_shndx == SHN_COMMON)
1860                     tsec = bfd_com_section_ptr;
1861                   else
1862                     tsec = h->root.u.def.section;
1863
1864                   toff = h->root.u.def.value;
1865                 }
1866               else
1867                 {
1868                   tsec = ppc_info->plt;
1869                   toff = h->plt.offset;
1870                 }
1871             }
1872           else if (h->root.type == bfd_link_hash_undefined
1873                    || h->root.type == bfd_link_hash_undefweak)
1874             continue;
1875
1876           else
1877             {
1878               tsec = h->root.u.def.section;
1879               toff = h->root.u.def.value;
1880             }
1881         }
1882
1883       if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
1884         toff = _bfd_merged_section_offset (abfd, &tsec,
1885                                            elf_section_data (tsec)->sec_info,
1886                                            toff + irel->r_addend, 0);
1887       else
1888         toff += irel->r_addend;
1889
1890       symaddr = tsec->output_section->vma + tsec->output_offset + toff;
1891
1892       roff = irel->r_offset;
1893
1894       reladdr = (isec->output_section->vma
1895                  + isec->output_offset
1896                  + roff) & (bfd_vma) -4;
1897
1898       /* If the branch is in range, no need to do anything.  */
1899       max_branch_offset = 1 << 25;
1900       if (r_type != R_PPC_REL24
1901           && r_type != R_PPC_LOCAL24PC
1902           && r_type != R_PPC_PLTREL24)
1903         max_branch_offset = 1 << 15;
1904
1905       if ((bfd_vma) (symaddr - reladdr) + max_branch_offset
1906           <= 2 * max_branch_offset)
1907         continue;
1908
1909       /* If the branch and target are in the same section, you have
1910          no hope.  We'll error out later.  */
1911       if (tsec == isec)
1912         continue;
1913
1914       /* Look for an existing fixup to this address.  */
1915       for (f = fixups; f ; f = f->next)
1916         if (f->tsec == tsec && f->toff == toff)
1917           break;
1918
1919       if (f == NULL)
1920         {
1921           size_t size;
1922
1923           if (link_info->shared
1924               || tsec == ppc_info->plt
1925               || r_type == R_PPC_LOCAL24PC)
1926             {
1927               size = sizeof (shared_stub_entry);
1928               insn_offset = 16;
1929             }
1930           else
1931             {
1932               size = sizeof (stub_entry);
1933               insn_offset = 4;
1934             }
1935
1936           /* Resize the current section to make room for the new branch.  */
1937           trampoff = (isec->_cooked_size + 3) & (bfd_vma) - 4;
1938           amt = trampoff + size;
1939           contents = bfd_realloc (contents, amt);
1940           if (contents == NULL)
1941             abort ();
1942
1943           isec->_cooked_size = amt;
1944
1945           if (link_info->shared
1946               || tsec == ppc_info->plt
1947               || r_type == R_PPC_LOCAL24PC)
1948             memcpy (contents + trampoff, shared_stub_entry, size);
1949           else
1950             memcpy (contents + trampoff, stub_entry, size);
1951
1952           /* Hijack the old relocation.  Since we need two
1953              relocations for this use a "composite" reloc.  */
1954           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1955                                        R_PPC_RELAX32);
1956           irel->r_offset = trampoff + insn_offset;
1957
1958           /* Record the fixup so we don't do it again this section.  */
1959           f = bfd_malloc (sizeof (*f));
1960           f->next = fixups;
1961           f->tsec = tsec;
1962           f->toff = toff;
1963           f->trampoff = trampoff;
1964           fixups = f;
1965         }
1966       else
1967         {
1968           /* Nop out the reloc, since we're finalizing things here.  */
1969           irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
1970         }
1971
1972       /* Fix up the existing branch to hit the trampoline.  Hope like
1973          hell this doesn't overflow too.  */
1974       if (ppc_elf_install_value (abfd, contents + roff,
1975                                  f->trampoff - (roff & (bfd_vma) -3) + 4,
1976                                  r_type) != bfd_reloc_ok)
1977         abort ();
1978
1979       changed_contents = TRUE;
1980       changed_relocs = TRUE;
1981     }
1982
1983   /* Clean up.  */
1984   while (fixups)
1985     {
1986       struct one_fixup *f = fixups;
1987       fixups = fixups->next;
1988       free (f);
1989     }
1990   if (isymbuf != NULL
1991       && symtab_hdr->contents != (unsigned char *) isymbuf)
1992     {
1993       if (! link_info->keep_memory)
1994         free (isymbuf);
1995       else
1996         {
1997           /* Cache the symbols for elf_link_input_bfd.  */
1998           symtab_hdr->contents = (unsigned char *) isymbuf;
1999         }
2000     }
2001
2002   if (contents != NULL
2003       && elf_section_data (isec)->this_hdr.contents != contents)
2004     {
2005       if (!changed_contents && !link_info->keep_memory)
2006         free (contents);
2007       else
2008         {
2009           /* Cache the section contents for elf_link_input_bfd.  */
2010           elf_section_data (isec)->this_hdr.contents = contents;
2011         }
2012     }
2013
2014   if (elf_section_data (isec)->relocs != internal_relocs)
2015     {
2016       if (!changed_relocs)
2017         free (internal_relocs);
2018       else
2019         elf_section_data (isec)->relocs = internal_relocs;
2020     }
2021
2022   *again = changed_contents || changed_relocs;
2023   return TRUE;
2024
2025  error_return:
2026   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
2027     free (isymbuf);
2028   if (contents != NULL
2029       && elf_section_data (isec)->this_hdr.contents != contents)
2030     free (contents);
2031   if (internal_relocs != NULL
2032       && elf_section_data (isec)->relocs != internal_relocs)
2033     free (internal_relocs);
2034   return FALSE;
2035 }
2036 \f
2037 static reloc_howto_type *
2038 ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2039                            bfd_reloc_code_real_type code)
2040 {
2041   enum elf_ppc_reloc_type r;
2042
2043   /* Initialize howto table if not already done.  */
2044   if (!ppc_elf_howto_table[R_PPC_ADDR32])
2045     ppc_elf_howto_init ();
2046
2047   switch (code)
2048     {
2049     default:
2050       return NULL;
2051
2052     case BFD_RELOC_NONE:                r = R_PPC_NONE;                 break;
2053     case BFD_RELOC_32:                  r = R_PPC_ADDR32;               break;
2054     case BFD_RELOC_PPC_BA26:            r = R_PPC_ADDR24;               break;
2055     case BFD_RELOC_16:                  r = R_PPC_ADDR16;               break;
2056     case BFD_RELOC_LO16:                r = R_PPC_ADDR16_LO;            break;
2057     case BFD_RELOC_HI16:                r = R_PPC_ADDR16_HI;            break;
2058     case BFD_RELOC_HI16_S:              r = R_PPC_ADDR16_HA;            break;
2059     case BFD_RELOC_PPC_BA16:            r = R_PPC_ADDR14;               break;
2060     case BFD_RELOC_PPC_BA16_BRTAKEN:    r = R_PPC_ADDR14_BRTAKEN;       break;
2061     case BFD_RELOC_PPC_BA16_BRNTAKEN:   r = R_PPC_ADDR14_BRNTAKEN;      break;
2062     case BFD_RELOC_PPC_B26:             r = R_PPC_REL24;                break;
2063     case BFD_RELOC_PPC_B16:             r = R_PPC_REL14;                break;
2064     case BFD_RELOC_PPC_B16_BRTAKEN:     r = R_PPC_REL14_BRTAKEN;        break;
2065     case BFD_RELOC_PPC_B16_BRNTAKEN:    r = R_PPC_REL14_BRNTAKEN;       break;
2066     case BFD_RELOC_16_GOTOFF:           r = R_PPC_GOT16;                break;
2067     case BFD_RELOC_LO16_GOTOFF:         r = R_PPC_GOT16_LO;             break;
2068     case BFD_RELOC_HI16_GOTOFF:         r = R_PPC_GOT16_HI;             break;
2069     case BFD_RELOC_HI16_S_GOTOFF:       r = R_PPC_GOT16_HA;             break;
2070     case BFD_RELOC_24_PLT_PCREL:        r = R_PPC_PLTREL24;             break;
2071     case BFD_RELOC_PPC_COPY:            r = R_PPC_COPY;                 break;
2072     case BFD_RELOC_PPC_GLOB_DAT:        r = R_PPC_GLOB_DAT;             break;
2073     case BFD_RELOC_PPC_LOCAL24PC:       r = R_PPC_LOCAL24PC;            break;
2074     case BFD_RELOC_32_PCREL:            r = R_PPC_REL32;                break;
2075     case BFD_RELOC_32_PLTOFF:           r = R_PPC_PLT32;                break;
2076     case BFD_RELOC_32_PLT_PCREL:        r = R_PPC_PLTREL32;             break;
2077     case BFD_RELOC_LO16_PLTOFF:         r = R_PPC_PLT16_LO;             break;
2078     case BFD_RELOC_HI16_PLTOFF:         r = R_PPC_PLT16_HI;             break;
2079     case BFD_RELOC_HI16_S_PLTOFF:       r = R_PPC_PLT16_HA;             break;
2080     case BFD_RELOC_GPREL16:             r = R_PPC_SDAREL16;             break;
2081     case BFD_RELOC_16_BASEREL:          r = R_PPC_SECTOFF;              break;
2082     case BFD_RELOC_LO16_BASEREL:        r = R_PPC_SECTOFF_LO;           break;
2083     case BFD_RELOC_HI16_BASEREL:        r = R_PPC_SECTOFF_HI;           break;
2084     case BFD_RELOC_HI16_S_BASEREL:      r = R_PPC_SECTOFF_HA;           break;
2085     case BFD_RELOC_CTOR:                r = R_PPC_ADDR32;               break;
2086     case BFD_RELOC_PPC_TOC16:           r = R_PPC_TOC16;                break;
2087     case BFD_RELOC_PPC_TLS:             r = R_PPC_TLS;                  break;
2088     case BFD_RELOC_PPC_DTPMOD:          r = R_PPC_DTPMOD32;             break;
2089     case BFD_RELOC_PPC_TPREL16:         r = R_PPC_TPREL16;              break;
2090     case BFD_RELOC_PPC_TPREL16_LO:      r = R_PPC_TPREL16_LO;           break;
2091     case BFD_RELOC_PPC_TPREL16_HI:      r = R_PPC_TPREL16_HI;           break;
2092     case BFD_RELOC_PPC_TPREL16_HA:      r = R_PPC_TPREL16_HA;           break;
2093     case BFD_RELOC_PPC_TPREL:           r = R_PPC_TPREL32;              break;
2094     case BFD_RELOC_PPC_DTPREL16:        r = R_PPC_DTPREL16;             break;
2095     case BFD_RELOC_PPC_DTPREL16_LO:     r = R_PPC_DTPREL16_LO;          break;
2096     case BFD_RELOC_PPC_DTPREL16_HI:     r = R_PPC_DTPREL16_HI;          break;
2097     case BFD_RELOC_PPC_DTPREL16_HA:     r = R_PPC_DTPREL16_HA;          break;
2098     case BFD_RELOC_PPC_DTPREL:          r = R_PPC_DTPREL32;             break;
2099     case BFD_RELOC_PPC_GOT_TLSGD16:     r = R_PPC_GOT_TLSGD16;          break;
2100     case BFD_RELOC_PPC_GOT_TLSGD16_LO:  r = R_PPC_GOT_TLSGD16_LO;       break;
2101     case BFD_RELOC_PPC_GOT_TLSGD16_HI:  r = R_PPC_GOT_TLSGD16_HI;       break;
2102     case BFD_RELOC_PPC_GOT_TLSGD16_HA:  r = R_PPC_GOT_TLSGD16_HA;       break;
2103     case BFD_RELOC_PPC_GOT_TLSLD16:     r = R_PPC_GOT_TLSLD16;          break;
2104     case BFD_RELOC_PPC_GOT_TLSLD16_LO:  r = R_PPC_GOT_TLSLD16_LO;       break;
2105     case BFD_RELOC_PPC_GOT_TLSLD16_HI:  r = R_PPC_GOT_TLSLD16_HI;       break;
2106     case BFD_RELOC_PPC_GOT_TLSLD16_HA:  r = R_PPC_GOT_TLSLD16_HA;       break;
2107     case BFD_RELOC_PPC_GOT_TPREL16:     r = R_PPC_GOT_TPREL16;          break;
2108     case BFD_RELOC_PPC_GOT_TPREL16_LO:  r = R_PPC_GOT_TPREL16_LO;       break;
2109     case BFD_RELOC_PPC_GOT_TPREL16_HI:  r = R_PPC_GOT_TPREL16_HI;       break;
2110     case BFD_RELOC_PPC_GOT_TPREL16_HA:  r = R_PPC_GOT_TPREL16_HA;       break;
2111     case BFD_RELOC_PPC_GOT_DTPREL16:    r = R_PPC_GOT_DTPREL16;         break;
2112     case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO;      break;
2113     case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI;      break;
2114     case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA;      break;
2115     case BFD_RELOC_PPC_EMB_NADDR32:     r = R_PPC_EMB_NADDR32;          break;
2116     case BFD_RELOC_PPC_EMB_NADDR16:     r = R_PPC_EMB_NADDR16;          break;
2117     case BFD_RELOC_PPC_EMB_NADDR16_LO:  r = R_PPC_EMB_NADDR16_LO;       break;
2118     case BFD_RELOC_PPC_EMB_NADDR16_HI:  r = R_PPC_EMB_NADDR16_HI;       break;
2119     case BFD_RELOC_PPC_EMB_NADDR16_HA:  r = R_PPC_EMB_NADDR16_HA;       break;
2120     case BFD_RELOC_PPC_EMB_SDAI16:      r = R_PPC_EMB_SDAI16;           break;
2121     case BFD_RELOC_PPC_EMB_SDA2I16:     r = R_PPC_EMB_SDA2I16;          break;
2122     case BFD_RELOC_PPC_EMB_SDA2REL:     r = R_PPC_EMB_SDA2REL;          break;
2123     case BFD_RELOC_PPC_EMB_SDA21:       r = R_PPC_EMB_SDA21;            break;
2124     case BFD_RELOC_PPC_EMB_MRKREF:      r = R_PPC_EMB_MRKREF;           break;
2125     case BFD_RELOC_PPC_EMB_RELSEC16:    r = R_PPC_EMB_RELSEC16;         break;
2126     case BFD_RELOC_PPC_EMB_RELST_LO:    r = R_PPC_EMB_RELST_LO;         break;
2127     case BFD_RELOC_PPC_EMB_RELST_HI:    r = R_PPC_EMB_RELST_HI;         break;
2128     case BFD_RELOC_PPC_EMB_RELST_HA:    r = R_PPC_EMB_RELST_HA;         break;
2129     case BFD_RELOC_PPC_EMB_BIT_FLD:     r = R_PPC_EMB_BIT_FLD;          break;
2130     case BFD_RELOC_PPC_EMB_RELSDA:      r = R_PPC_EMB_RELSDA;           break;
2131     case BFD_RELOC_VTABLE_INHERIT:      r = R_PPC_GNU_VTINHERIT;        break;
2132     case BFD_RELOC_VTABLE_ENTRY:        r = R_PPC_GNU_VTENTRY;          break;
2133     }
2134
2135   return ppc_elf_howto_table[r];
2136 };
2137
2138 /* Set the howto pointer for a PowerPC ELF reloc.  */
2139
2140 static void
2141 ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
2142                        arelent *cache_ptr,
2143                        Elf_Internal_Rela *dst)
2144 {
2145   /* Initialize howto table if not already done.  */
2146   if (!ppc_elf_howto_table[R_PPC_ADDR32])
2147     ppc_elf_howto_init ();
2148
2149   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
2150   cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
2151 }
2152
2153 /* Handle the R_PPC_ADDR16_HA reloc.  */
2154
2155 static bfd_reloc_status_type
2156 ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2157                          arelent *reloc_entry,
2158                          asymbol *symbol,
2159                          void *data ATTRIBUTE_UNUSED,
2160                          asection *input_section,
2161                          bfd *output_bfd,
2162                          char **error_message ATTRIBUTE_UNUSED)
2163 {
2164   bfd_vma relocation;
2165
2166   if (output_bfd != NULL)
2167     {
2168       reloc_entry->address += input_section->output_offset;
2169       return bfd_reloc_ok;
2170     }
2171
2172   if (reloc_entry->address > input_section->_cooked_size)
2173     return bfd_reloc_outofrange;
2174
2175   if (bfd_is_com_section (symbol->section))
2176     relocation = 0;
2177   else
2178     relocation = symbol->value;
2179
2180   relocation += symbol->section->output_section->vma;
2181   relocation += symbol->section->output_offset;
2182   relocation += reloc_entry->addend;
2183
2184   reloc_entry->addend += (relocation & 0x8000) << 1;
2185
2186   return bfd_reloc_continue;
2187 }
2188
2189 static bfd_reloc_status_type
2190 ppc_elf_unhandled_reloc (bfd *abfd,
2191                          arelent *reloc_entry,
2192                          asymbol *symbol,
2193                          void *data,
2194                          asection *input_section,
2195                          bfd *output_bfd,
2196                          char **error_message)
2197 {
2198   /* If this is a relocatable link (output_bfd test tells us), just
2199      call the generic function.  Any adjustment will be done at final
2200      link time.  */
2201   if (output_bfd != NULL)
2202     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2203                                   input_section, output_bfd, error_message);
2204
2205   if (error_message != NULL)
2206     {
2207       static char buf[60];
2208       sprintf (buf, _("generic linker can't handle %s"),
2209                reloc_entry->howto->name);
2210       *error_message = buf;
2211     }
2212   return bfd_reloc_dangerous;
2213 }
2214
2215 /* Fix bad default arch selected for a 32 bit input bfd when the
2216    default is 64 bit.  */
2217
2218 static bfd_boolean
2219 ppc_elf_object_p (bfd *abfd)
2220 {
2221   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 64)
2222     {
2223       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2224
2225       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32)
2226         {
2227           /* Relies on arch after 64 bit default being 32 bit default.  */
2228           abfd->arch_info = abfd->arch_info->next;
2229           BFD_ASSERT (abfd->arch_info->bits_per_word == 32);
2230         }
2231     }
2232   return TRUE;
2233 }
2234
2235 /* Function to set whether a module needs the -mrelocatable bit set.  */
2236
2237 static bfd_boolean
2238 ppc_elf_set_private_flags (bfd *abfd, flagword flags)
2239 {
2240   BFD_ASSERT (!elf_flags_init (abfd)
2241               || elf_elfheader (abfd)->e_flags == flags);
2242
2243   elf_elfheader (abfd)->e_flags = flags;
2244   elf_flags_init (abfd) = TRUE;
2245   return TRUE;
2246 }
2247
2248 /* Merge backend specific data from an object file to the output
2249    object file when linking.  */
2250
2251 static bfd_boolean
2252 ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2253 {
2254   flagword old_flags;
2255   flagword new_flags;
2256   bfd_boolean error;
2257
2258   /* Check if we have the same endianess.  */
2259   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2260     return FALSE;
2261
2262   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2263       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2264     return TRUE;
2265
2266   new_flags = elf_elfheader (ibfd)->e_flags;
2267   old_flags = elf_elfheader (obfd)->e_flags;
2268   if (!elf_flags_init (obfd))
2269     {
2270       /* First call, no flags set.  */
2271       elf_flags_init (obfd) = TRUE;
2272       elf_elfheader (obfd)->e_flags = new_flags;
2273     }
2274
2275   /* Compatible flags are ok.  */
2276   else if (new_flags == old_flags)
2277     ;
2278
2279   /* Incompatible flags.  */
2280   else
2281     {
2282       /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib
2283          to be linked with either.  */
2284       error = FALSE;
2285       if ((new_flags & EF_PPC_RELOCATABLE) != 0
2286           && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
2287         {
2288           error = TRUE;
2289           (*_bfd_error_handler)
2290             (_("%s: compiled with -mrelocatable and linked with "
2291                "modules compiled normally"),
2292              bfd_archive_filename (ibfd));
2293         }
2294       else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
2295                && (old_flags & EF_PPC_RELOCATABLE) != 0)
2296         {
2297           error = TRUE;
2298           (*_bfd_error_handler)
2299             (_("%s: compiled normally and linked with "
2300                "modules compiled with -mrelocatable"),
2301              bfd_archive_filename (ibfd));
2302         }
2303
2304       /* The output is -mrelocatable-lib iff both the input files are.  */
2305       if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
2306         elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
2307
2308       /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
2309          but each input file is either -mrelocatable or -mrelocatable-lib.  */
2310       if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
2311           && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
2312           && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
2313         elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
2314
2315       /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if
2316          any module uses it.  */
2317       elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
2318
2319       new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
2320       old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
2321
2322       /* Warn about any other mismatches.  */
2323       if (new_flags != old_flags)
2324         {
2325           error = TRUE;
2326           (*_bfd_error_handler)
2327             (_("%s: uses different e_flags (0x%lx) fields "
2328                "than previous modules (0x%lx)"),
2329              bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
2330         }
2331
2332       if (error)
2333         {
2334           bfd_set_error (bfd_error_bad_value);
2335           return FALSE;
2336         }
2337     }
2338
2339   return TRUE;
2340 }
2341 \f
2342 /* Handle a PowerPC specific section when reading an object file.  This
2343    is called when elfcode.h finds a section with an unknown type.  */
2344
2345 static bfd_boolean
2346 ppc_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name)
2347 {
2348   asection *newsect;
2349   flagword flags;
2350
2351   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2352     return FALSE;
2353
2354   newsect = hdr->bfd_section;
2355   flags = bfd_get_section_flags (abfd, newsect);
2356   if (hdr->sh_flags & SHF_EXCLUDE)
2357     flags |= SEC_EXCLUDE;
2358
2359   if (hdr->sh_type == SHT_ORDERED)
2360     flags |= SEC_SORT_ENTRIES;
2361
2362   bfd_set_section_flags (abfd, newsect, flags);
2363   return TRUE;
2364 }
2365 \f
2366 /* Set up any other section flags and such that may be necessary.  */
2367
2368 static bfd_boolean
2369 ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2370                        Elf_Internal_Shdr *shdr,
2371                        asection *asect)
2372 {
2373   if ((asect->flags & SEC_EXCLUDE) != 0)
2374     shdr->sh_flags |= SHF_EXCLUDE;
2375
2376   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
2377     shdr->sh_type = SHT_ORDERED;
2378
2379   return TRUE;
2380 }
2381 \f
2382 /* Find a linker generated pointer with a given addend and type.  */
2383
2384 static elf_linker_section_pointers_t *
2385 elf_find_pointer_linker_section
2386   (elf_linker_section_pointers_t *linker_pointers,
2387    bfd_vma addend,
2388    elf_linker_section_t *lsect)
2389 {
2390   for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
2391     if (lsect == linker_pointers->lsect && addend == linker_pointers->addend)
2392       return linker_pointers;
2393
2394   return NULL;
2395 }
2396 \f
2397 /* Allocate a pointer to live in a linker created section.  */
2398
2399 static bfd_boolean
2400 elf_create_pointer_linker_section (bfd *abfd,
2401                                    struct bfd_link_info *info,
2402                                    elf_linker_section_t *lsect,
2403                                    struct elf_link_hash_entry *h,
2404                                    const Elf_Internal_Rela *rel)
2405 {
2406   elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL;
2407   elf_linker_section_pointers_t *linker_section_ptr;
2408   unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
2409   bfd_size_type amt;
2410
2411   BFD_ASSERT (lsect != NULL);
2412
2413   /* Is this a global symbol?  */
2414   if (h != NULL)
2415     {
2416       struct ppc_elf_link_hash_entry *eh;
2417
2418       /* Has this symbol already been allocated?  If so, our work is done.  */
2419       eh = (struct ppc_elf_link_hash_entry *) h;
2420       if (elf_find_pointer_linker_section (eh->linker_section_pointer,
2421                                            rel->r_addend,
2422                                            lsect))
2423         return TRUE;
2424
2425       ptr_linker_section_ptr = &eh->linker_section_pointer;
2426       /* Make sure this symbol is output as a dynamic symbol.  */
2427       if (h->dynindx == -1)
2428         {
2429           if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2430             return FALSE;
2431         }
2432
2433       if (lsect->rel_section)
2434         lsect->rel_section->_raw_size += sizeof (Elf32_External_Rela);
2435     }
2436   else
2437     {
2438       /* Allocation of a pointer to a local symbol.  */
2439       elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd);
2440
2441       /* Allocate a table to hold the local symbols if first time.  */
2442       if (!ptr)
2443         {
2444           unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info;
2445
2446           amt = num_symbols;
2447           amt *= sizeof (elf_linker_section_pointers_t *);
2448           ptr = bfd_zalloc (abfd, amt);
2449
2450           if (!ptr)
2451             return FALSE;
2452
2453           elf_local_ptr_offsets (abfd) = ptr;
2454         }
2455
2456       /* Has this symbol already been allocated?  If so, our work is done.  */
2457       if (elf_find_pointer_linker_section (ptr[r_symndx],
2458                                            rel->r_addend,
2459                                            lsect))
2460         return TRUE;
2461
2462       ptr_linker_section_ptr = &ptr[r_symndx];
2463
2464       if (info->shared)
2465         {
2466           /* If we are generating a shared object, we need to
2467              output a R_<xxx>_RELATIVE reloc so that the
2468              dynamic linker can adjust this GOT entry.  */
2469           BFD_ASSERT (lsect->rel_section != NULL);
2470           lsect->rel_section->_raw_size += sizeof (Elf32_External_Rela);
2471         }
2472     }
2473
2474   /* Allocate space for a pointer in the linker section, and allocate
2475      a new pointer record from internal memory.  */
2476   BFD_ASSERT (ptr_linker_section_ptr != NULL);
2477   amt = sizeof (elf_linker_section_pointers_t);
2478   linker_section_ptr = bfd_alloc (abfd, amt);
2479
2480   if (!linker_section_ptr)
2481     return FALSE;
2482
2483   linker_section_ptr->next = *ptr_linker_section_ptr;
2484   linker_section_ptr->addend = rel->r_addend;
2485   linker_section_ptr->lsect = lsect;
2486   linker_section_ptr->written_address_p = FALSE;
2487   *ptr_linker_section_ptr = linker_section_ptr;
2488
2489   linker_section_ptr->offset = lsect->section->_raw_size;
2490   lsect->section->_raw_size += 4;
2491
2492 #ifdef DEBUG
2493   fprintf (stderr,
2494            "Create pointer in linker section %s, offset = %ld, section size = %ld\n",
2495            lsect->name, (long) linker_section_ptr->offset,
2496            (long) lsect->section->_raw_size);
2497 #endif
2498
2499   return TRUE;
2500 }
2501 \f
2502 #define bfd_put_ptr(BFD, VAL, ADDR) bfd_put_32 (BFD, VAL, ADDR)
2503
2504 /* Fill in the address for a pointer generated in a linker section.  */
2505
2506 static bfd_vma
2507 elf_finish_pointer_linker_section (bfd *output_bfd,
2508                                    bfd *input_bfd,
2509                                    struct bfd_link_info *info,
2510                                    elf_linker_section_t *lsect,
2511                                    struct elf_link_hash_entry *h,
2512                                    bfd_vma relocation,
2513                                    const Elf_Internal_Rela *rel,
2514                                    int relative_reloc)
2515 {
2516   elf_linker_section_pointers_t *linker_section_ptr;
2517
2518   BFD_ASSERT (lsect != NULL);
2519
2520   if (h != NULL)
2521     {
2522       /* Handle global symbol.  */
2523       struct ppc_elf_link_hash_entry *eh;
2524
2525       eh = (struct ppc_elf_link_hash_entry *) h;
2526       linker_section_ptr
2527         = elf_find_pointer_linker_section (eh->linker_section_pointer,
2528                                            rel->r_addend,
2529                                            lsect);
2530
2531       BFD_ASSERT (linker_section_ptr != NULL);
2532
2533       if (! elf_hash_table (info)->dynamic_sections_created
2534           || (info->shared
2535               && info->symbolic
2536               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2537         {
2538           /* This is actually a static link, or it is a
2539              -Bsymbolic link and the symbol is defined
2540              locally.  We must initialize this entry in the
2541              global section.
2542
2543              When doing a dynamic link, we create a .rela.<xxx>
2544              relocation entry to initialize the value.  This
2545              is done in the finish_dynamic_symbol routine.  */
2546           if (!linker_section_ptr->written_address_p)
2547             {
2548               linker_section_ptr->written_address_p = TRUE;
2549               bfd_put_ptr (output_bfd,
2550                            relocation + linker_section_ptr->addend,
2551                            (lsect->section->contents
2552                             + linker_section_ptr->offset));
2553             }
2554         }
2555     }
2556   else
2557     {
2558       /* Handle local symbol.  */
2559       unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
2560       BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL);
2561       BFD_ASSERT (elf_local_ptr_offsets (input_bfd)[r_symndx] != NULL);
2562       linker_section_ptr = (elf_find_pointer_linker_section
2563                             (elf_local_ptr_offsets (input_bfd)[r_symndx],
2564                              rel->r_addend,
2565                              lsect));
2566
2567       BFD_ASSERT (linker_section_ptr != NULL);
2568
2569       /* Write out pointer if it hasn't been rewritten out before.  */
2570       if (!linker_section_ptr->written_address_p)
2571         {
2572           linker_section_ptr->written_address_p = TRUE;
2573           bfd_put_ptr (output_bfd, relocation + linker_section_ptr->addend,
2574                        lsect->section->contents + linker_section_ptr->offset);
2575
2576           if (info->shared)
2577             {
2578               /* We need to generate a relative reloc for the dynamic
2579                  linker.  */
2580
2581               asection *srel = lsect->rel_section;
2582               Elf_Internal_Rela outrel[MAX_INT_RELS_PER_EXT_REL];
2583               bfd_byte *erel;
2584               const struct elf_backend_data *bed;
2585               unsigned int i;
2586
2587               BFD_ASSERT (srel != NULL);
2588
2589               bed = get_elf_backend_data (output_bfd);
2590               for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
2591                 {
2592                   outrel[i].r_offset = (lsect->section->output_section->vma
2593                                         + lsect->section->output_offset
2594                                         + linker_section_ptr->offset);
2595                   outrel[i].r_info = 0;
2596                   outrel[i].r_addend = 0;
2597                 }
2598               outrel[0].r_info = ELF32_R_INFO (0, relative_reloc);
2599               erel = lsect->section->contents;
2600               erel += (elf_section_data (lsect->section)->rel_count++
2601                        * sizeof (Elf32_External_Rela));
2602               bfd_elf32_swap_reloca_out (output_bfd, outrel, erel);
2603             }
2604         }
2605     }
2606
2607   relocation = (lsect->section->output_offset
2608                 + linker_section_ptr->offset
2609                 - lsect->sym_offset);
2610
2611 #ifdef DEBUG
2612   fprintf (stderr,
2613            "Finish pointer in linker section %s, offset = %ld (0x%lx)\n",
2614            lsect->name, (long) relocation, (long) relocation);
2615 #endif
2616
2617   /* Subtract out the addend, because it will get added back in by the normal
2618      processing.  */
2619   return relocation - linker_section_ptr->addend;
2620 }
2621 \f
2622 /* Create a special linker section */
2623 static elf_linker_section_t *
2624 ppc_elf_create_linker_section (bfd *abfd,
2625                                struct bfd_link_info *info,
2626                                enum elf_linker_section_enum which)
2627 {
2628   elf_linker_section_t *lsect;
2629   struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info);
2630   asection *s;
2631   bfd_size_type amt;
2632   flagword flags;
2633   const char *name;
2634   const char *rel_name;
2635   const char *sym_name;
2636   bfd_vma sym_offset;
2637
2638   /* Both of these sections are (technically) created by the user
2639      putting data in them, so they shouldn't be marked
2640      SEC_LINKER_CREATED.
2641
2642      The linker creates them so it has somewhere to attach their
2643      respective symbols. In fact, if they were empty it would
2644      be OK to leave the symbol set to 0 (or any random number), because
2645      the appropriate register should never be used.  */
2646   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
2647   sym_offset = 32768;
2648
2649   switch (which)
2650     {
2651     default:
2652       abort ();
2653       return NULL;
2654
2655     case LINKER_SECTION_SDATA:  /* .sdata/.sbss section */
2656       name      = ".sdata";
2657       rel_name  = ".rela.sdata";
2658       sym_name  = "_SDA_BASE_";
2659       break;
2660
2661     case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
2662       name      = ".sdata2";
2663       rel_name  = ".rela.sdata2";
2664       sym_name  = "_SDA2_BASE_";
2665       flags    |= SEC_READONLY;
2666       break;
2667     }
2668
2669   /* Record the first bfd that needs the special sections.  */
2670   if (!htab->elf.dynobj)
2671     htab->elf.dynobj = abfd;
2672
2673   amt = sizeof (elf_linker_section_t);
2674   lsect = bfd_zalloc (htab->elf.dynobj, amt);
2675
2676   lsect->sym_offset = sym_offset;
2677
2678   /* See if the sections already exist.  */
2679   s = bfd_get_section_by_name (htab->elf.dynobj, name);
2680   if (s == NULL || (s->flags & flags) != flags)
2681     {
2682       s = bfd_make_section_anyway (htab->elf.dynobj, name);
2683       if (s == NULL
2684           || !bfd_set_section_flags (htab->elf.dynobj, s, flags))
2685         return NULL;
2686     }
2687   lsect->section = s;
2688
2689   if (bfd_get_section_alignment (htab->elf.dynobj, s) < 2
2690       && !bfd_set_section_alignment (htab->elf.dynobj, s, 2))
2691     return NULL;
2692
2693   s->_raw_size = align_power (s->_raw_size, 2);
2694
2695 #ifdef DEBUG
2696   fprintf (stderr, "Creating section %s, current size = %ld\n",
2697            name, (long) s->_raw_size);
2698 #endif
2699
2700   if (sym_name)
2701     {
2702       struct elf_link_hash_entry *h;
2703       struct bfd_link_hash_entry *bh;
2704
2705 #ifdef DEBUG
2706       fprintf (stderr, "Adding %s to section %s\n", sym_name, name);
2707 #endif
2708       bh = bfd_link_hash_lookup (info->hash, sym_name,
2709                                  FALSE, FALSE, FALSE);
2710
2711       if ((bh == NULL || bh->type == bfd_link_hash_undefined)
2712           && !(_bfd_generic_link_add_one_symbol
2713                (info, abfd, sym_name, BSF_GLOBAL, s, sym_offset, NULL,
2714                 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2715         return NULL;
2716       h = (struct elf_link_hash_entry *) bh;
2717
2718       h->type = STT_OBJECT;
2719       lsect->sym_hash = h;
2720
2721       if (info->shared
2722           && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2723         return NULL;
2724     }
2725
2726   if (info->shared)
2727     {
2728       s = bfd_make_section_anyway (htab->elf.dynobj, rel_name);
2729       lsect->rel_section = s;
2730       flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2731                | SEC_LINKER_CREATED | SEC_READONLY);
2732       if (s == NULL
2733           || ! bfd_set_section_flags (htab->elf.dynobj, s, flags)
2734           || ! bfd_set_section_alignment (htab->elf.dynobj, s, 2))
2735         return NULL;
2736     }
2737
2738   return lsect;
2739 }
2740 \f
2741 /* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we
2742    need to bump up the number of section headers.  */
2743
2744 static int
2745 ppc_elf_additional_program_headers (bfd *abfd)
2746 {
2747   asection *s;
2748   int ret;
2749
2750   ret = 0;
2751
2752   s = bfd_get_section_by_name (abfd, ".interp");
2753   if (s != NULL)
2754     ++ret;
2755
2756   s = bfd_get_section_by_name (abfd, ".sbss2");
2757   if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
2758     ++ret;
2759
2760   s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
2761   if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
2762     ++ret;
2763
2764   return ret;
2765 }
2766
2767 /* Modify the segment map if needed.  */
2768
2769 static bfd_boolean
2770 ppc_elf_modify_segment_map (bfd *abfd ATTRIBUTE_UNUSED)
2771 {
2772   return TRUE;
2773 }
2774 \f
2775 /* The powerpc .got has a blrl instruction in it.  Mark it executable.  */
2776
2777 static bfd_boolean
2778 ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info)
2779 {
2780   struct ppc_elf_link_hash_table *htab;
2781   asection *s;
2782   flagword flags;
2783
2784   if (!_bfd_elf_create_got_section (abfd, info))
2785     return FALSE;
2786
2787   htab = ppc_elf_hash_table (info);
2788   htab->got = s = bfd_get_section_by_name (abfd, ".got");
2789   if (s == NULL)
2790     abort ();
2791
2792   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2793            | SEC_LINKER_CREATED);
2794   if (!bfd_set_section_flags (abfd, s, flags))
2795     return FALSE;
2796
2797   htab->relgot = bfd_make_section (abfd, ".rela.got");
2798   if (!htab->relgot
2799       || ! bfd_set_section_flags (abfd, htab->relgot,
2800                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2801                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
2802                                    | SEC_READONLY))
2803       || ! bfd_set_section_alignment (abfd, htab->relgot, 2))
2804     return FALSE;
2805
2806   return TRUE;
2807 }
2808
2809 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
2810    to output sections (just like _bfd_elf_create_dynamic_sections has
2811    to create .dynbss and .rela.bss).  */
2812
2813 static bfd_boolean
2814 ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2815 {
2816   struct ppc_elf_link_hash_table *htab;
2817   asection *s;
2818   flagword flags;
2819
2820   htab = ppc_elf_hash_table (info);
2821
2822   if (htab->got == NULL
2823       && !ppc_elf_create_got (abfd, info))
2824     return FALSE;
2825
2826   if (!_bfd_elf_create_dynamic_sections (abfd, info))
2827     return FALSE;
2828
2829   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2830            | SEC_LINKER_CREATED);
2831
2832   htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss");
2833   htab->dynsbss = s = bfd_make_section (abfd, ".dynsbss");
2834   if (s == NULL
2835       || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
2836     return FALSE;
2837
2838   if (! info->shared)
2839     {
2840       htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss");
2841       htab->relsbss = s = bfd_make_section (abfd, ".rela.sbss");
2842       if (s == NULL
2843           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2844           || ! bfd_set_section_alignment (abfd, s, 2))
2845         return FALSE;
2846     }
2847
2848   htab->relplt = bfd_get_section_by_name (abfd, ".rela.plt");
2849   htab->plt = s = bfd_get_section_by_name (abfd, ".plt");
2850   if (s == NULL)
2851     abort ();
2852
2853   flags = SEC_ALLOC | SEC_CODE | SEC_IN_MEMORY | SEC_LINKER_CREATED;
2854   return bfd_set_section_flags (abfd, s, flags);
2855 }
2856
2857 /* Adjust a symbol defined by a dynamic object and referenced by a
2858    regular object.  The current definition is in some section of the
2859    dynamic object, but we're not including those sections.  We have to
2860    change the definition to something the rest of the link can
2861    understand.  */
2862
2863 static bfd_boolean
2864 ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2865                                struct elf_link_hash_entry *h)
2866 {
2867   struct ppc_elf_link_hash_table *htab;
2868   asection *s;
2869   unsigned int power_of_two;
2870
2871 #ifdef DEBUG
2872   fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n",
2873            h->root.root.string);
2874 #endif
2875
2876   /* Make sure we know what is going on here.  */
2877   htab = ppc_elf_hash_table (info);
2878   BFD_ASSERT (htab->elf.dynobj != NULL
2879               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2880                   || h->weakdef != NULL
2881                   || ((h->elf_link_hash_flags
2882                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2883                       && (h->elf_link_hash_flags
2884                           & ELF_LINK_HASH_REF_REGULAR) != 0
2885                       && (h->elf_link_hash_flags
2886                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2887
2888   /* Deal with function syms.  */
2889   if (h->type == STT_FUNC
2890       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2891     {
2892       /* Clear procedure linkage table information for any symbol that
2893          won't need a .plt entry.  */
2894       if (h->plt.refcount <= 0
2895           || SYMBOL_CALLS_LOCAL (info, h)
2896           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2897               && h->root.type == bfd_link_hash_undefweak))
2898         {
2899           /* A PLT entry is not required/allowed when:
2900
2901              1. We are not using ld.so; because then the PLT entry
2902              can't be set up, so we can't use one.  In this case,
2903              ppc_elf_adjust_dynamic_symbol won't even be called.
2904
2905              2. GC has rendered the entry unused.
2906
2907              3. We know for certain that a call to this symbol
2908              will go to this object, or will remain undefined.  */
2909           h->plt.offset = (bfd_vma) -1;
2910           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2911         }
2912       return TRUE;
2913     }
2914   else
2915     h->plt.offset = (bfd_vma) -1;
2916
2917   /* If this is a weak symbol, and there is a real definition, the
2918      processor independent code will have arranged for us to see the
2919      real definition first, and we can just use the same value.  */
2920   if (h->weakdef != NULL)
2921     {
2922       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2923                   || h->weakdef->root.type == bfd_link_hash_defweak);
2924       h->root.u.def.section = h->weakdef->root.u.def.section;
2925       h->root.u.def.value = h->weakdef->root.u.def.value;
2926       if (ELIMINATE_COPY_RELOCS)
2927         h->elf_link_hash_flags
2928           = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
2929              | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
2930       return TRUE;
2931     }
2932
2933   /* This is a reference to a symbol defined by a dynamic object which
2934      is not a function.  */
2935
2936   /* If we are creating a shared library, we must presume that the
2937      only references to the symbol are via the global offset table.
2938      For such cases we need not do anything here; the relocations will
2939      be handled correctly by relocate_section.  */
2940   if (info->shared)
2941     return TRUE;
2942
2943   /* If there are no references to this symbol that do not use the
2944      GOT, we don't need to generate a copy reloc.  */
2945   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
2946     return TRUE;
2947
2948   if (ELIMINATE_COPY_RELOCS)
2949     {
2950       struct ppc_elf_dyn_relocs *p;
2951       for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2952         {
2953           s = p->sec->output_section;
2954           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2955             break;
2956         }
2957
2958       /* If we didn't find any dynamic relocs in read-only sections, then
2959          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2960       if (p == NULL)
2961         {
2962           h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
2963           return TRUE;
2964         }
2965     }
2966
2967   /* We must allocate the symbol in our .dynbss section, which will
2968      become part of the .bss section of the executable.  There will be
2969      an entry for this symbol in the .dynsym section.  The dynamic
2970      object will contain position independent code, so all references
2971      from the dynamic object to this symbol will go through the global
2972      offset table.  The dynamic linker will use the .dynsym entry to
2973      determine the address it must put in the global offset table, so
2974      both the dynamic object and the regular object will refer to the
2975      same memory location for the variable.
2976
2977      Of course, if the symbol is sufficiently small, we must instead
2978      allocate it in .sbss.  FIXME: It would be better to do this if and
2979      only if there were actually SDAREL relocs for that symbol.  */
2980
2981   if (h->size <= elf_gp_size (htab->elf.dynobj))
2982     s = htab->dynsbss;
2983   else
2984     s = htab->dynbss;
2985   BFD_ASSERT (s != NULL);
2986
2987   /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
2988      copy the initial value out of the dynamic object and into the
2989      runtime process image.  We need to remember the offset into the
2990      .rela.bss section we are going to use.  */
2991   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2992     {
2993       asection *srel;
2994
2995       if (h->size <= elf_gp_size (htab->elf.dynobj))
2996         srel = htab->relsbss;
2997       else
2998         srel = htab->relbss;
2999       BFD_ASSERT (srel != NULL);
3000       srel->_raw_size += sizeof (Elf32_External_Rela);
3001       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3002     }
3003
3004   /* We need to figure out the alignment required for this symbol.  I
3005      have no idea how ELF linkers handle this.  */
3006   power_of_two = bfd_log2 (h->size);
3007   if (power_of_two > 4)
3008     power_of_two = 4;
3009
3010   /* Apply the required alignment.  */
3011   s->_raw_size = BFD_ALIGN (s->_raw_size,
3012                             (bfd_size_type) (1 << power_of_two));
3013   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
3014     {
3015       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
3016         return FALSE;
3017     }
3018
3019   /* Define the symbol as being at this point in the section.  */
3020   h->root.u.def.section = s;
3021   h->root.u.def.value = s->_raw_size;
3022
3023   /* Increment the section size to make room for the symbol.  */
3024   s->_raw_size += h->size;
3025
3026   return TRUE;
3027 }
3028 \f
3029 /* This is the condition under which finish_dynamic_symbol will be
3030    called from elflink.h.  If elflink.h doesn't call our
3031    finish_dynamic_symbol routine, we'll need to do something about
3032    initializing any .plt and .got entries in relocate_section.  */
3033 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
3034   ((DYN)                                                                \
3035    && ((SHARED)                                                         \
3036        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
3037    && ((H)->dynindx != -1                                               \
3038        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
3039
3040 /* Of those relocs that might be copied as dynamic relocs, this macro
3041    selects those that must be copied when linking a shared library,
3042    even when the symbol is local.  */
3043
3044 #define MUST_BE_DYN_RELOC(RTYPE)                \
3045   ((RTYPE) != R_PPC_REL24                       \
3046    && (RTYPE) != R_PPC_REL14                    \
3047    && (RTYPE) != R_PPC_REL14_BRTAKEN            \
3048    && (RTYPE) != R_PPC_REL14_BRNTAKEN           \
3049    && (RTYPE) != R_PPC_REL32)
3050
3051 /* Allocate space in associated reloc sections for dynamic relocs.  */
3052
3053 static bfd_boolean
3054 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3055 {
3056   struct bfd_link_info *info = inf;
3057   struct ppc_elf_link_hash_entry *eh;
3058   struct ppc_elf_link_hash_table *htab;
3059   struct ppc_elf_dyn_relocs *p;
3060
3061   if (h->root.type == bfd_link_hash_indirect)
3062     return TRUE;
3063
3064   if (h->root.type == bfd_link_hash_warning)
3065     /* When warning symbols are created, they **replace** the "real"
3066        entry in the hash table, thus we never get to see the real
3067        symbol in a hash traversal.  So look at it now.  */
3068     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3069
3070   htab = ppc_elf_hash_table (info);
3071   if (htab->elf.dynamic_sections_created
3072       && h->plt.refcount > 0)
3073     {
3074       /* Make sure this symbol is output as a dynamic symbol.  */
3075       if (h->dynindx == -1
3076           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3077         {
3078           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
3079             return FALSE;
3080         }
3081
3082       if (info->shared
3083           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3084         {
3085           asection *s = htab->plt;
3086
3087           /* If this is the first .plt entry, make room for the special
3088              first entry.  */
3089           if (s->_raw_size == 0)
3090             s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
3091
3092           /* The PowerPC PLT is actually composed of two parts, the
3093              first part is 2 words (for a load and a jump), and then
3094              there is a remaining word available at the end.  */
3095           h->plt.offset = (PLT_INITIAL_ENTRY_SIZE
3096                            + (PLT_SLOT_SIZE
3097                               * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE)
3098                                  / PLT_ENTRY_SIZE)));
3099
3100           /* If this symbol is not defined in a regular file, and we
3101              are not generating a shared library, then set the symbol
3102              to this location in the .plt.  This is required to make
3103              function pointers compare as equal between the normal
3104              executable and the shared library.  */
3105           if (! info->shared
3106               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3107             {
3108               h->root.u.def.section = s;
3109               h->root.u.def.value = h->plt.offset;
3110             }
3111
3112           /* Make room for this entry.  After the 8192nd entry, room
3113              for two entries is allocated.  */
3114           s->_raw_size += PLT_ENTRY_SIZE;
3115           if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
3116               > PLT_NUM_SINGLE_ENTRIES)
3117             s->_raw_size += PLT_ENTRY_SIZE;
3118
3119           /* We also need to make an entry in the .rela.plt section.  */
3120           htab->relplt->_raw_size += sizeof (Elf32_External_Rela);
3121         }
3122       else
3123         {
3124           h->plt.offset = (bfd_vma) -1;
3125           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3126         }
3127     }
3128   else
3129     {
3130       h->plt.offset = (bfd_vma) -1;
3131       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3132     }
3133
3134   eh = (struct ppc_elf_link_hash_entry *) h;
3135   if (eh->elf.got.refcount > 0)
3136     {
3137       /* Make sure this symbol is output as a dynamic symbol.  */
3138       if (eh->elf.dynindx == -1
3139           && (eh->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3140         {
3141           if (!bfd_elf32_link_record_dynamic_symbol (info, &eh->elf))
3142             return FALSE;
3143         }
3144
3145       if (eh->tls_mask == (TLS_TLS | TLS_LD)
3146           && !(eh->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
3147         /* If just an LD reloc, we'll just use htab->tlsld_got.offset.  */
3148         eh->elf.got.offset = (bfd_vma) -1;
3149       else
3150         {
3151           bfd_boolean dyn;
3152           eh->elf.got.offset = htab->got->_raw_size;
3153           if ((eh->tls_mask & TLS_TLS) != 0)
3154             {
3155               if ((eh->tls_mask & TLS_LD) != 0)
3156                 htab->got->_raw_size += 8;
3157               if ((eh->tls_mask & TLS_GD) != 0)
3158                 htab->got->_raw_size += 8;
3159               if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
3160                 htab->got->_raw_size += 4;
3161               if ((eh->tls_mask & TLS_DTPREL) != 0)
3162                 htab->got->_raw_size += 4;
3163             }
3164           else
3165             htab->got->_raw_size += 4;
3166           dyn = htab->elf.dynamic_sections_created;
3167           if ((info->shared
3168                || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf))
3169               && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT
3170                   || eh->elf.root.type != bfd_link_hash_undefweak))
3171             {
3172               /* All the entries we allocated need relocs.  */
3173               htab->relgot->_raw_size
3174                 += ((htab->got->_raw_size - eh->elf.got.offset) / 4
3175                     * sizeof (Elf32_External_Rela));
3176               /* Except LD only needs one.  */
3177               if ((eh->tls_mask & TLS_LD) != 0)
3178                 htab->relgot->_raw_size -= sizeof (Elf32_External_Rela);
3179             }
3180         }
3181     }
3182   else
3183     eh->elf.got.offset = (bfd_vma) -1;
3184
3185   if (eh->dyn_relocs == NULL)
3186     return TRUE;
3187
3188   /* In the shared -Bsymbolic case, discard space allocated for
3189      dynamic pc-relative relocs against symbols which turn out to be
3190      defined in regular objects.  For the normal shared case, discard
3191      space for relocs that have become local due to symbol visibility
3192      changes.  */
3193
3194   if (info->shared)
3195     {
3196       /* Relocs that use pc_count are those that appear on a call insn,
3197          or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
3198          generated via assembly.  We want calls to protected symbols to
3199          resolve directly to the function rather than going via the plt.
3200          If people want function pointer comparisons to work as expected
3201          then they should avoid writing weird assembly.  */
3202       if (SYMBOL_CALLS_LOCAL (info, h))
3203         {
3204           struct ppc_elf_dyn_relocs **pp;
3205
3206           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3207             {
3208               p->count -= p->pc_count;
3209               p->pc_count = 0;
3210               if (p->count == 0)
3211                 *pp = p->next;
3212               else
3213                 pp = &p->next;
3214             }
3215         }
3216
3217       /* Also discard relocs on undefined weak syms with non-default
3218          visibility.  */
3219       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3220           && h->root.type == bfd_link_hash_undefweak)
3221         eh->dyn_relocs = NULL;
3222     }
3223   else if (ELIMINATE_COPY_RELOCS)
3224     {
3225       /* For the non-shared case, discard space for relocs against
3226          symbols which turn out to need copy relocs or are not
3227          dynamic.  */
3228
3229       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3230           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3231           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3232         {
3233           /* Make sure this symbol is output as a dynamic symbol.
3234              Undefined weak syms won't yet be marked as dynamic.  */
3235           if (h->dynindx == -1
3236               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3237             {
3238               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
3239                 return FALSE;
3240             }
3241
3242           /* If that succeeded, we know we'll be keeping all the
3243              relocs.  */
3244           if (h->dynindx != -1)
3245             goto keep;
3246         }
3247
3248       eh->dyn_relocs = NULL;
3249
3250     keep: ;
3251     }
3252
3253   /* Finally, allocate space.  */
3254   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3255     {
3256       asection *sreloc = elf_section_data (p->sec)->sreloc;
3257       sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
3258     }
3259
3260   return TRUE;
3261 }
3262
3263 /* Find any dynamic relocs that apply to read-only sections.  */
3264
3265 static bfd_boolean
3266 readonly_dynrelocs (struct elf_link_hash_entry *h, void *info)
3267 {
3268   struct ppc_elf_dyn_relocs *p;
3269
3270   if (h->root.type == bfd_link_hash_indirect)
3271     return TRUE;
3272
3273   if (h->root.type == bfd_link_hash_warning)
3274     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3275
3276   for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3277     {
3278       asection *s = p->sec->output_section;
3279
3280       if (s != NULL
3281           && ((s->flags & (SEC_READONLY | SEC_ALLOC))
3282               == (SEC_READONLY | SEC_ALLOC)))
3283         {
3284           ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
3285
3286           /* Not an error, just cut short the traversal.  */
3287           return FALSE;
3288         }
3289     }
3290   return TRUE;
3291 }
3292
3293 /* Set the sizes of the dynamic sections.  */
3294
3295 static bfd_boolean
3296 ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3297                                struct bfd_link_info *info)
3298 {
3299   struct ppc_elf_link_hash_table *htab;
3300   asection *s;
3301   bfd_boolean relocs;
3302   bfd *ibfd;
3303
3304 #ifdef DEBUG
3305   fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
3306 #endif
3307
3308   htab = ppc_elf_hash_table (info);
3309   BFD_ASSERT (htab->elf.dynobj != NULL);
3310
3311   if (elf_hash_table (info)->dynamic_sections_created)
3312     {
3313       /* Set the contents of the .interp section to the interpreter.  */
3314       if (info->executable)
3315         {
3316           s = bfd_get_section_by_name (htab->elf.dynobj, ".interp");
3317           BFD_ASSERT (s != NULL);
3318           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3319           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3320         }
3321     }
3322
3323   if (htab->tlsld_got.refcount > 0)
3324     {
3325       htab->tlsld_got.offset = htab->got->_raw_size;
3326       htab->got->_raw_size += 8;
3327       if (info->shared)
3328         htab->relgot->_raw_size += sizeof (Elf32_External_Rela);
3329     }
3330   else
3331     htab->tlsld_got.offset = (bfd_vma) -1;
3332
3333   /* Set up .got offsets for local syms, and space for local dynamic
3334      relocs.  */
3335   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3336     {
3337       bfd_signed_vma *local_got;
3338       bfd_signed_vma *end_local_got;
3339       char *lgot_masks;
3340       bfd_size_type locsymcount;
3341       Elf_Internal_Shdr *symtab_hdr;
3342       asection *srel;
3343
3344       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3345         continue;
3346
3347       for (s = ibfd->sections; s != NULL; s = s->next)
3348         {
3349           struct ppc_elf_dyn_relocs *p;
3350
3351           for (p = ((struct ppc_elf_dyn_relocs *)
3352                     elf_section_data (s)->local_dynrel);
3353                p != NULL;
3354                p = p->next)
3355             {
3356               if (!bfd_is_abs_section (p->sec)
3357                   && bfd_is_abs_section (p->sec->output_section))
3358                 {
3359                   /* Input section has been discarded, either because
3360                      it is a copy of a linkonce section or due to
3361                      linker script /DISCARD/, so we'll be discarding
3362                      the relocs too.  */
3363                 }
3364               else if (p->count != 0)
3365                 {
3366                   elf_section_data (p->sec)->sreloc->_raw_size
3367                     += p->count * sizeof (Elf32_External_Rela);
3368                   if ((p->sec->output_section->flags
3369                        & (SEC_READONLY | SEC_ALLOC))
3370                       == (SEC_READONLY | SEC_ALLOC))
3371                     info->flags |= DF_TEXTREL;
3372                 }
3373             }
3374         }
3375
3376       local_got = elf_local_got_refcounts (ibfd);
3377       if (!local_got)
3378         continue;
3379
3380       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3381       locsymcount = symtab_hdr->sh_info;
3382       end_local_got = local_got + locsymcount;
3383       lgot_masks = (char *) end_local_got;
3384       s = htab->got;
3385       srel = htab->relgot;
3386       for (; local_got < end_local_got; ++local_got, ++lgot_masks)
3387         if (*local_got > 0)
3388           {
3389             if (*lgot_masks == (TLS_TLS | TLS_LD))
3390               {
3391                 /* If just an LD reloc, we'll just use
3392                    htab->tlsld_got.offset.  */
3393                 if (htab->tlsld_got.offset == (bfd_vma) -1)
3394                   {
3395                     htab->tlsld_got.offset = s->_raw_size;
3396                     s->_raw_size += 8;
3397                     if (info->shared)
3398                       srel->_raw_size += sizeof (Elf32_External_Rela);
3399                   }
3400                 *local_got = (bfd_vma) -1;
3401               }
3402             else
3403               {
3404                 *local_got = s->_raw_size;
3405                 if ((*lgot_masks & TLS_TLS) != 0)
3406                   {
3407                     if ((*lgot_masks & TLS_GD) != 0)
3408                       s->_raw_size += 8;
3409                     if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
3410                       s->_raw_size += 4;
3411                     if ((*lgot_masks & TLS_DTPREL) != 0)
3412                       s->_raw_size += 4;
3413                   }
3414                 else
3415                   s->_raw_size += 4;
3416                 if (info->shared)
3417                   srel->_raw_size += ((s->_raw_size - *local_got) / 4
3418                                       * sizeof (Elf32_External_Rela));
3419               }
3420           }
3421         else
3422           *local_got = (bfd_vma) -1;
3423     }
3424
3425   /* Allocate space for global sym dynamic relocs.  */
3426   elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
3427
3428   /* We've now determined the sizes of the various dynamic sections.
3429      Allocate memory for them.  */
3430   relocs = FALSE;
3431   for (s = htab->elf.dynobj->sections; s != NULL; s = s->next)
3432     {
3433       if ((s->flags & SEC_LINKER_CREATED) == 0)
3434         continue;
3435
3436       if (s == htab->plt
3437           || s == htab->got
3438           || (htab->sdata != NULL && s == htab->sdata->section)
3439           || (htab->sdata2 != NULL && s == htab->sdata2->section))
3440         {
3441           /* Strip this section if we don't need it; see the
3442              comment below.  */
3443         }
3444       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
3445         {
3446           if (s->_raw_size == 0)
3447             {
3448               /* If we don't need this section, strip it from the
3449                  output file.  This is mostly to handle .rela.bss and
3450                  .rela.plt.  We must create both sections in
3451                  create_dynamic_sections, because they must be created
3452                  before the linker maps input sections to output
3453                  sections.  The linker does that before
3454                  adjust_dynamic_symbol is called, and it is that
3455                  function which decides whether anything needs to go
3456                  into these sections.  */
3457             }
3458           else
3459             {
3460               /* Remember whether there are any relocation sections.  */
3461               relocs = TRUE;
3462
3463               /* We use the reloc_count field as a counter if we need
3464                  to copy relocs into the output file.  */
3465               s->reloc_count = 0;
3466             }
3467         }
3468       else
3469         {
3470           /* It's not one of our sections, so don't allocate space.  */
3471           continue;
3472         }
3473
3474       if (s->_raw_size == 0)
3475         {
3476           _bfd_strip_section_from_output (info, s);
3477           continue;
3478         }
3479
3480       /* Allocate memory for the section contents.  */
3481       s->contents = bfd_zalloc (htab->elf.dynobj, s->_raw_size);
3482       if (s->contents == NULL)
3483         return FALSE;
3484     }
3485
3486   if (htab->elf.dynamic_sections_created)
3487     {
3488       /* Add some entries to the .dynamic section.  We fill in the
3489          values later, in ppc_elf_finish_dynamic_sections, but we
3490          must add the entries now so that we get the correct size for
3491          the .dynamic section.  The DT_DEBUG entry is filled in by the
3492          dynamic linker and used by the debugger.  */
3493 #define add_dynamic_entry(TAG, VAL) \
3494   bfd_elf32_add_dynamic_entry (info, (TAG), (VAL))
3495
3496       if (info->executable)
3497         {
3498           if (!add_dynamic_entry (DT_DEBUG, 0))
3499             return FALSE;
3500         }
3501
3502       if (htab->plt != NULL && htab->plt->_raw_size != 0)
3503         {
3504           if (!add_dynamic_entry (DT_PLTGOT, 0)
3505               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3506               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3507               || !add_dynamic_entry (DT_JMPREL, 0))
3508             return FALSE;
3509         }
3510
3511       if (relocs)
3512         {
3513           if (!add_dynamic_entry (DT_RELA, 0)
3514               || !add_dynamic_entry (DT_RELASZ, 0)
3515               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3516             return FALSE;
3517         }
3518
3519       /* If any dynamic relocs apply to a read-only section, then we
3520          need a DT_TEXTREL entry.  */
3521       if ((info->flags & DF_TEXTREL) == 0)
3522         elf_link_hash_traverse (elf_hash_table (info), readonly_dynrelocs,
3523                                 info);
3524
3525       if ((info->flags & DF_TEXTREL) != 0)
3526         {
3527           if (!add_dynamic_entry (DT_TEXTREL, 0))
3528             return FALSE;
3529         }
3530     }
3531 #undef add_dynamic_entry
3532
3533   return TRUE;
3534 }
3535 \f
3536 static bfd_boolean
3537 update_local_sym_info (bfd *abfd,
3538                        Elf_Internal_Shdr *symtab_hdr,
3539                        unsigned long r_symndx,
3540                        int tls_type)
3541 {
3542   bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
3543   char *local_got_tls_masks;
3544
3545   if (local_got_refcounts == NULL)
3546     {
3547       bfd_size_type size = symtab_hdr->sh_info;
3548
3549       size *= sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks);
3550       local_got_refcounts = bfd_zalloc (abfd, size);
3551       if (local_got_refcounts == NULL)
3552         return FALSE;
3553       elf_local_got_refcounts (abfd) = local_got_refcounts;
3554     }
3555
3556   local_got_refcounts[r_symndx] += 1;
3557   local_got_tls_masks = (char *) (local_got_refcounts + symtab_hdr->sh_info);
3558   local_got_tls_masks[r_symndx] |= tls_type;
3559   return TRUE;
3560 }
3561
3562 static void
3563 bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type)
3564 {
3565   (*_bfd_error_handler)
3566     (_("%s: relocation %s cannot be used when making a shared object"),
3567      bfd_archive_filename (abfd),
3568      ppc_elf_howto_table[r_type]->name);
3569   bfd_set_error (bfd_error_bad_value);
3570 }
3571
3572 /* Look through the relocs for a section during the first phase, and
3573    allocate space in the global offset table or procedure linkage
3574    table.  */
3575
3576 static bfd_boolean
3577 ppc_elf_check_relocs (bfd *abfd,
3578                       struct bfd_link_info *info,
3579                       asection *sec,
3580                       const Elf_Internal_Rela *relocs)
3581 {
3582   struct ppc_elf_link_hash_table *htab;
3583   Elf_Internal_Shdr *symtab_hdr;
3584   struct elf_link_hash_entry **sym_hashes;
3585   const Elf_Internal_Rela *rel;
3586   const Elf_Internal_Rela *rel_end;
3587   asection *sreloc;
3588
3589   if (info->relocatable)
3590     return TRUE;
3591
3592 #ifdef DEBUG
3593   fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
3594            bfd_get_section_name (abfd, sec),
3595            bfd_archive_filename (abfd));
3596 #endif
3597
3598   /* Initialize howto table if not already done.  */
3599   if (!ppc_elf_howto_table[R_PPC_ADDR32])
3600     ppc_elf_howto_init ();
3601
3602   /* Create the linker generated sections all the time so that the
3603      special symbols are created.  */
3604   htab = ppc_elf_hash_table (info);
3605   if (htab->sdata == NULL)
3606     {
3607       htab->sdata = ppc_elf_create_linker_section (abfd, info,
3608                                                    LINKER_SECTION_SDATA);
3609       if (htab->sdata == NULL)
3610         return FALSE;
3611     }
3612
3613   if (htab->sdata2 == NULL)
3614     {
3615       htab->sdata2 = ppc_elf_create_linker_section (abfd, info,
3616                                                     LINKER_SECTION_SDATA2);
3617       if (htab->sdata2 == NULL)
3618         return FALSE;
3619     }
3620
3621   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3622   sym_hashes = elf_sym_hashes (abfd);
3623   sreloc = NULL;
3624
3625   rel_end = relocs + sec->reloc_count;
3626   for (rel = relocs; rel < rel_end; rel++)
3627     {
3628       unsigned long r_symndx;
3629       enum elf_ppc_reloc_type r_type;
3630       struct elf_link_hash_entry *h;
3631       int tls_type = 0;
3632
3633       r_symndx = ELF32_R_SYM (rel->r_info);
3634       if (r_symndx < symtab_hdr->sh_info)
3635         h = NULL;
3636       else
3637         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3638
3639       /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
3640          This shows up in particular in an R_PPC_ADDR32 in the eabi
3641          startup code.  */
3642       if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3643         {
3644           if (htab->got == NULL)
3645             {
3646               if (htab->elf.dynobj == NULL)
3647                 htab->elf.dynobj = abfd;
3648               if (!ppc_elf_create_got (htab->elf.dynobj, info))
3649                 return FALSE;
3650             }
3651         }
3652
3653       r_type = ELF32_R_TYPE (rel->r_info);
3654       switch (r_type)
3655         {
3656         case R_PPC_GOT_TLSLD16:
3657         case R_PPC_GOT_TLSLD16_LO:
3658         case R_PPC_GOT_TLSLD16_HI:
3659         case R_PPC_GOT_TLSLD16_HA:
3660           htab->tlsld_got.refcount += 1;
3661           tls_type = TLS_TLS | TLS_LD;
3662           goto dogottls;
3663
3664         case R_PPC_GOT_TLSGD16:
3665         case R_PPC_GOT_TLSGD16_LO:
3666         case R_PPC_GOT_TLSGD16_HI:
3667         case R_PPC_GOT_TLSGD16_HA:
3668           tls_type = TLS_TLS | TLS_GD;
3669           goto dogottls;
3670
3671         case R_PPC_GOT_TPREL16:
3672         case R_PPC_GOT_TPREL16_LO:
3673         case R_PPC_GOT_TPREL16_HI:
3674         case R_PPC_GOT_TPREL16_HA:
3675           if (info->shared)
3676             info->flags |= DF_STATIC_TLS;
3677           tls_type = TLS_TLS | TLS_TPREL;
3678           goto dogottls;
3679
3680         case R_PPC_GOT_DTPREL16:
3681         case R_PPC_GOT_DTPREL16_LO:
3682         case R_PPC_GOT_DTPREL16_HI:
3683         case R_PPC_GOT_DTPREL16_HA:
3684           tls_type = TLS_TLS | TLS_DTPREL;
3685         dogottls:
3686           sec->has_tls_reloc = 1;
3687           /* Fall thru */
3688
3689           /* GOT16 relocations */
3690         case R_PPC_GOT16:
3691         case R_PPC_GOT16_LO:
3692         case R_PPC_GOT16_HI:
3693         case R_PPC_GOT16_HA:
3694           /* This symbol requires a global offset table entry.  */
3695           if (htab->got == NULL)
3696             {
3697               if (htab->elf.dynobj == NULL)
3698                 htab->elf.dynobj = abfd;
3699               if (!ppc_elf_create_got (htab->elf.dynobj, info))
3700                 return FALSE;
3701             }
3702           if (h != NULL)
3703             {
3704               h->got.refcount += 1;
3705               ppc_elf_hash_entry (h)->tls_mask |= tls_type;
3706             }
3707           else
3708             /* This is a global offset table entry for a local symbol.  */
3709             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type))
3710               return FALSE;
3711           break;
3712
3713           /* Indirect .sdata relocation.  */
3714         case R_PPC_EMB_SDAI16:
3715           if (info->shared)
3716             {
3717               bad_shared_reloc (abfd, r_type);
3718               return FALSE;
3719             }
3720           if (!elf_create_pointer_linker_section (abfd, info,
3721                                                   htab->sdata, h, rel))
3722             return FALSE;
3723           break;
3724
3725           /* Indirect .sdata2 relocation.  */
3726         case R_PPC_EMB_SDA2I16:
3727           if (info->shared)
3728             {
3729               bad_shared_reloc (abfd, r_type);
3730               return FALSE;
3731             }
3732           if (!elf_create_pointer_linker_section (abfd, info,
3733                                                   htab->sdata2, h, rel))
3734             return FALSE;
3735           break;
3736
3737         case R_PPC_SDAREL16:
3738         case R_PPC_EMB_SDA2REL:
3739         case R_PPC_EMB_SDA21:
3740         case R_PPC_EMB_RELSDA:
3741         case R_PPC_EMB_NADDR32:
3742         case R_PPC_EMB_NADDR16:
3743         case R_PPC_EMB_NADDR16_LO:
3744         case R_PPC_EMB_NADDR16_HI:
3745         case R_PPC_EMB_NADDR16_HA:
3746           if (info->shared)
3747             {
3748               bad_shared_reloc (abfd, r_type);
3749               return FALSE;
3750             }
3751           break;
3752
3753         case R_PPC_PLT32:
3754         case R_PPC_PLTREL24:
3755         case R_PPC_PLTREL32:
3756         case R_PPC_PLT16_LO:
3757         case R_PPC_PLT16_HI:
3758         case R_PPC_PLT16_HA:
3759 #ifdef DEBUG
3760           fprintf (stderr, "Reloc requires a PLT entry\n");
3761 #endif
3762           /* This symbol requires a procedure linkage table entry.  We
3763              actually build the entry in finish_dynamic_symbol,
3764              because this might be a case of linking PIC code without
3765              linking in any dynamic objects, in which case we don't
3766              need to generate a procedure linkage table after all.  */
3767
3768           if (h == NULL)
3769             {
3770               /* It does not make sense to have a procedure linkage
3771                  table entry for a local symbol.  */
3772               (*_bfd_error_handler) (_("%s(%s+0x%lx): %s reloc against "
3773                                        "local symbol"),
3774                                      bfd_archive_filename (abfd),
3775                                      sec->name,
3776                                      (long) rel->r_offset,
3777                                      ppc_elf_howto_table[r_type]->name);
3778               bfd_set_error (bfd_error_bad_value);
3779               return FALSE;
3780             }
3781
3782           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3783           h->plt.refcount++;
3784           break;
3785
3786           /* The following relocations don't need to propagate the
3787              relocation if linking a shared object since they are
3788              section relative.  */
3789         case R_PPC_SECTOFF:
3790         case R_PPC_SECTOFF_LO:
3791         case R_PPC_SECTOFF_HI:
3792         case R_PPC_SECTOFF_HA:
3793         case R_PPC_DTPREL16:
3794         case R_PPC_DTPREL16_LO:
3795         case R_PPC_DTPREL16_HI:
3796         case R_PPC_DTPREL16_HA:
3797         case R_PPC_TOC16:
3798           break;
3799
3800           /* This are just markers.  */
3801         case R_PPC_TLS:
3802         case R_PPC_EMB_MRKREF:
3803         case R_PPC_NONE:
3804         case R_PPC_max:
3805           break;
3806
3807           /* These should only appear in dynamic objects.  */
3808         case R_PPC_COPY:
3809         case R_PPC_GLOB_DAT:
3810         case R_PPC_JMP_SLOT:
3811         case R_PPC_RELATIVE:
3812           break;
3813
3814           /* These aren't handled yet.  We'll report an error later.  */
3815         case R_PPC_ADDR30:
3816         case R_PPC_EMB_RELSEC16:
3817         case R_PPC_EMB_RELST_LO:
3818         case R_PPC_EMB_RELST_HI:
3819         case R_PPC_EMB_RELST_HA:
3820         case R_PPC_EMB_BIT_FLD:
3821           break;
3822
3823           /* This refers only to functions defined in the shared library.  */
3824         case R_PPC_LOCAL24PC:
3825           break;
3826
3827           /* This relocation describes the C++ object vtable hierarchy.
3828              Reconstruct it for later use during GC.  */
3829         case R_PPC_GNU_VTINHERIT:
3830           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3831             return FALSE;
3832           break;
3833
3834           /* This relocation describes which C++ vtable entries are actually
3835              used.  Record for later use during GC.  */
3836         case R_PPC_GNU_VTENTRY:
3837           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3838             return FALSE;
3839           break;
3840
3841           /* We shouldn't really be seeing these.  */
3842         case R_PPC_TPREL32:
3843           if (info->shared)
3844             info->flags |= DF_STATIC_TLS;
3845           goto dodyn;
3846
3847           /* Nor these.  */
3848         case R_PPC_DTPMOD32:
3849         case R_PPC_DTPREL32:
3850           goto dodyn;
3851
3852         case R_PPC_TPREL16:
3853         case R_PPC_TPREL16_LO:
3854         case R_PPC_TPREL16_HI:
3855         case R_PPC_TPREL16_HA:
3856           if (info->shared)
3857             info->flags |= DF_STATIC_TLS;
3858           goto dodyn;
3859
3860           /* When creating a shared object, we must copy these
3861              relocs into the output file.  We create a reloc
3862              section in dynobj and make room for the reloc.  */
3863         case R_PPC_REL24:
3864         case R_PPC_REL14:
3865         case R_PPC_REL14_BRTAKEN:
3866         case R_PPC_REL14_BRNTAKEN:
3867         case R_PPC_REL32:
3868           if (h == NULL
3869               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3870             break;
3871           /* fall through */
3872
3873         case R_PPC_ADDR32:
3874         case R_PPC_ADDR24:
3875         case R_PPC_ADDR16:
3876         case R_PPC_ADDR16_LO:
3877         case R_PPC_ADDR16_HI:
3878         case R_PPC_ADDR16_HA:
3879         case R_PPC_ADDR14:
3880         case R_PPC_ADDR14_BRTAKEN:
3881         case R_PPC_ADDR14_BRNTAKEN:
3882         case R_PPC_UADDR32:
3883         case R_PPC_UADDR16:
3884           if (h != NULL && !info->shared)
3885             {
3886               /* We may need a plt entry if the symbol turns out to be
3887                  a function defined in a dynamic object.  */
3888               h->plt.refcount++;
3889
3890               /* We may need a copy reloc too.  */
3891               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
3892             }
3893
3894         dodyn:
3895           /* If we are creating a shared library, and this is a reloc
3896              against a global symbol, or a non PC relative reloc
3897              against a local symbol, then we need to copy the reloc
3898              into the shared library.  However, if we are linking with
3899              -Bsymbolic, we do not need to copy a reloc against a
3900              global symbol which is defined in an object we are
3901              including in the link (i.e., DEF_REGULAR is set).  At
3902              this point we have not seen all the input files, so it is
3903              possible that DEF_REGULAR is not set now but will be set
3904              later (it is never cleared).  In case of a weak definition,
3905              DEF_REGULAR may be cleared later by a strong definition in
3906              a shared library.  We account for that possibility below by
3907              storing information in the dyn_relocs field of the hash
3908              table entry.  A similar situation occurs when creating
3909              shared libraries and symbol visibility changes render the
3910              symbol local.
3911
3912              If on the other hand, we are creating an executable, we
3913              may need to keep relocations for symbols satisfied by a
3914              dynamic library if we manage to avoid copy relocs for the
3915              symbol.  */
3916           if ((info->shared
3917                && (MUST_BE_DYN_RELOC (r_type)
3918                    || (h != NULL
3919                        && (! info->symbolic
3920                            || h->root.type == bfd_link_hash_defweak
3921                            || (h->elf_link_hash_flags
3922                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3923               || (ELIMINATE_COPY_RELOCS
3924                   && !info->shared
3925                   && (sec->flags & SEC_ALLOC) != 0
3926                   && h != NULL
3927                   && (h->root.type == bfd_link_hash_defweak
3928                       || (h->elf_link_hash_flags
3929                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3930             {
3931               struct ppc_elf_dyn_relocs *p;
3932               struct ppc_elf_dyn_relocs **head;
3933
3934 #ifdef DEBUG
3935               fprintf (stderr,
3936                        "ppc_elf_check_relocs needs to "
3937                        "create relocation for %s\n",
3938                        (h && h->root.root.string
3939                         ? h->root.root.string : "<unknown>"));
3940 #endif
3941               if (sreloc == NULL)
3942                 {
3943                   const char *name;
3944
3945                   name = (bfd_elf_string_from_elf_section
3946                           (abfd,
3947                            elf_elfheader (abfd)->e_shstrndx,
3948                            elf_section_data (sec)->rel_hdr.sh_name));
3949                   if (name == NULL)
3950                     return FALSE;
3951
3952                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3953                               && strcmp (bfd_get_section_name (abfd, sec),
3954                                          name + 5) == 0);
3955
3956                   sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
3957                   if (sreloc == NULL)
3958                     {
3959                       flagword flags;
3960
3961                       sreloc = bfd_make_section (htab->elf.dynobj, name);
3962                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
3963                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3964                       if ((sec->flags & SEC_ALLOC) != 0)
3965                         flags |= SEC_ALLOC | SEC_LOAD;
3966                       if (sreloc == NULL
3967                           || ! bfd_set_section_flags (htab->elf.dynobj,
3968                                                       sreloc, flags)
3969                           || ! bfd_set_section_alignment (htab->elf.dynobj,
3970                                                           sreloc, 2))
3971                         return FALSE;
3972                     }
3973                   elf_section_data (sec)->sreloc = sreloc;
3974                 }
3975
3976               /* If this is a global symbol, we count the number of
3977                  relocations we need for this symbol.  */
3978               if (h != NULL)
3979                 {
3980                   head = &ppc_elf_hash_entry (h)->dyn_relocs;
3981                 }
3982               else
3983                 {
3984                   /* Track dynamic relocs needed for local syms too.
3985                      We really need local syms available to do this
3986                      easily.  Oh well.  */
3987
3988                   asection *s;
3989                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
3990                                                  sec, r_symndx);
3991                   if (s == NULL)
3992                     return FALSE;
3993
3994                   head = ((struct ppc_elf_dyn_relocs **)
3995                           &elf_section_data (s)->local_dynrel);
3996                 }
3997
3998               p = *head;
3999               if (p == NULL || p->sec != sec)
4000                 {
4001                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4002                   if (p == NULL)
4003                     return FALSE;
4004                   p->next = *head;
4005                   *head = p;
4006                   p->sec = sec;
4007                   p->count = 0;
4008                   p->pc_count = 0;
4009                 }
4010
4011               p->count += 1;
4012               if (!MUST_BE_DYN_RELOC (r_type))
4013                 p->pc_count += 1;
4014             }
4015
4016           break;
4017         }
4018     }
4019
4020   return TRUE;
4021 }
4022
4023 /* Return the section that should be marked against GC for a given
4024    relocation.  */
4025
4026 static asection *
4027 ppc_elf_gc_mark_hook (asection *sec,
4028                       struct bfd_link_info *info ATTRIBUTE_UNUSED,
4029                       Elf_Internal_Rela *rel,
4030                       struct elf_link_hash_entry *h,
4031                       Elf_Internal_Sym *sym)
4032 {
4033   if (h != NULL)
4034     {
4035       switch (ELF32_R_TYPE (rel->r_info))
4036         {
4037         case R_PPC_GNU_VTINHERIT:
4038         case R_PPC_GNU_VTENTRY:
4039           break;
4040
4041         default:
4042           switch (h->root.type)
4043             {
4044             case bfd_link_hash_defined:
4045             case bfd_link_hash_defweak:
4046               return h->root.u.def.section;
4047
4048             case bfd_link_hash_common:
4049               return h->root.u.c.p->section;
4050
4051             default:
4052               break;
4053             }
4054         }
4055     }
4056   else
4057     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4058
4059   return NULL;
4060 }
4061
4062 /* Update the got, plt and dynamic reloc reference counts for the
4063    section being removed.  */
4064
4065 static bfd_boolean
4066 ppc_elf_gc_sweep_hook (bfd *abfd,
4067                        struct bfd_link_info *info,
4068                        asection *sec,
4069                        const Elf_Internal_Rela *relocs)
4070 {
4071   struct ppc_elf_link_hash_table *htab;
4072   Elf_Internal_Shdr *symtab_hdr;
4073   struct elf_link_hash_entry **sym_hashes;
4074   bfd_signed_vma *local_got_refcounts;
4075   const Elf_Internal_Rela *rel, *relend;
4076
4077   elf_section_data (sec)->local_dynrel = NULL;
4078
4079   htab = ppc_elf_hash_table (info);
4080   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4081   sym_hashes = elf_sym_hashes (abfd);
4082   local_got_refcounts = elf_local_got_refcounts (abfd);
4083
4084   relend = relocs + sec->reloc_count;
4085   for (rel = relocs; rel < relend; rel++)
4086     {
4087       unsigned long r_symndx;
4088       enum elf_ppc_reloc_type r_type;
4089       struct elf_link_hash_entry *h = NULL;
4090
4091       r_symndx = ELF32_R_SYM (rel->r_info);
4092       if (r_symndx >= symtab_hdr->sh_info)
4093         {
4094           struct ppc_elf_dyn_relocs **pp, *p;
4095           struct ppc_elf_link_hash_entry *eh;
4096
4097           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4098           eh = (struct ppc_elf_link_hash_entry *) h;
4099
4100           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
4101             if (p->sec == sec)
4102               {
4103                 /* Everything must go for SEC.  */
4104                 *pp = p->next;
4105                 break;
4106               }
4107         }
4108
4109       r_type = ELF32_R_TYPE (rel->r_info);
4110       switch (r_type)
4111         {
4112         case R_PPC_GOT_TLSLD16:
4113         case R_PPC_GOT_TLSLD16_LO:
4114         case R_PPC_GOT_TLSLD16_HI:
4115         case R_PPC_GOT_TLSLD16_HA:
4116           htab->tlsld_got.refcount -= 1;
4117           /* Fall thru */
4118
4119         case R_PPC_GOT_TLSGD16:
4120         case R_PPC_GOT_TLSGD16_LO:
4121         case R_PPC_GOT_TLSGD16_HI:
4122         case R_PPC_GOT_TLSGD16_HA:
4123         case R_PPC_GOT_TPREL16:
4124         case R_PPC_GOT_TPREL16_LO:
4125         case R_PPC_GOT_TPREL16_HI:
4126         case R_PPC_GOT_TPREL16_HA:
4127         case R_PPC_GOT_DTPREL16:
4128         case R_PPC_GOT_DTPREL16_LO:
4129         case R_PPC_GOT_DTPREL16_HI:
4130         case R_PPC_GOT_DTPREL16_HA:
4131         case R_PPC_GOT16:
4132         case R_PPC_GOT16_LO:
4133         case R_PPC_GOT16_HI:
4134         case R_PPC_GOT16_HA:
4135           if (h != NULL)
4136             {
4137               if (h->got.refcount > 0)
4138                 h->got.refcount--;
4139             }
4140           else if (local_got_refcounts != NULL)
4141             {
4142               if (local_got_refcounts[r_symndx] > 0)
4143                 local_got_refcounts[r_symndx]--;
4144             }
4145           break;
4146
4147         case R_PPC_REL24:
4148         case R_PPC_REL14:
4149         case R_PPC_REL14_BRTAKEN:
4150         case R_PPC_REL14_BRNTAKEN:
4151         case R_PPC_REL32:
4152           if (h == NULL
4153               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
4154             break;
4155           /* Fall thru */
4156
4157         case R_PPC_ADDR32:
4158         case R_PPC_ADDR24:
4159         case R_PPC_ADDR16:
4160         case R_PPC_ADDR16_LO:
4161         case R_PPC_ADDR16_HI:
4162         case R_PPC_ADDR16_HA:
4163         case R_PPC_ADDR14:
4164         case R_PPC_ADDR14_BRTAKEN:
4165         case R_PPC_ADDR14_BRNTAKEN:
4166         case R_PPC_UADDR32:
4167         case R_PPC_UADDR16:
4168         case R_PPC_PLT32:
4169         case R_PPC_PLTREL24:
4170         case R_PPC_PLT16_LO:
4171         case R_PPC_PLT16_HI:
4172         case R_PPC_PLT16_HA:
4173           if (h != NULL)
4174             {
4175               if (h->plt.refcount > 0)
4176                 h->plt.refcount--;
4177             }
4178           break;
4179
4180         default:
4181           break;
4182         }
4183     }
4184   return TRUE;
4185 }
4186
4187 /* Set htab->tls_sec and htab->tls_get_addr.  */
4188
4189 bfd_boolean
4190 ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
4191 {
4192   asection *tls;
4193   struct ppc_elf_link_hash_table *htab;
4194
4195   htab = ppc_elf_hash_table (info);
4196   htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4197                                              FALSE, FALSE, TRUE);
4198
4199   for (tls = obfd->sections; tls != NULL; tls = tls->next)
4200     if ((tls->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4201         == (SEC_THREAD_LOCAL | SEC_LOAD))
4202       break;
4203   htab->tls_sec = tls;
4204
4205   return tls != NULL;
4206 }
4207
4208 /* Run through all the TLS relocs looking for optimization
4209    opportunities.  */
4210
4211 bfd_boolean
4212 ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED,
4213                       struct bfd_link_info *info)
4214 {
4215   bfd *ibfd;
4216   asection *sec;
4217   struct ppc_elf_link_hash_table *htab;
4218
4219   if (info->relocatable || info->shared)
4220     return TRUE;
4221
4222   htab = ppc_elf_hash_table (info);
4223   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4224     {
4225       Elf_Internal_Sym *locsyms = NULL;
4226       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4227
4228       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4229         if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
4230           {
4231             Elf_Internal_Rela *relstart, *rel, *relend;
4232             int expecting_tls_get_addr;
4233
4234             /* Read the relocations.  */
4235             relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
4236                                                   info->keep_memory);
4237             if (relstart == NULL)
4238               return FALSE;
4239
4240             expecting_tls_get_addr = 0;
4241             relend = relstart + sec->reloc_count;
4242             for (rel = relstart; rel < relend; rel++)
4243               {
4244                 enum elf_ppc_reloc_type r_type;
4245                 unsigned long r_symndx;
4246                 struct elf_link_hash_entry *h = NULL;
4247                 char *tls_mask;
4248                 char tls_set, tls_clear;
4249                 bfd_boolean is_local;
4250
4251                 r_symndx = ELF32_R_SYM (rel->r_info);
4252                 if (r_symndx >= symtab_hdr->sh_info)
4253                   {
4254                     struct elf_link_hash_entry **sym_hashes;
4255
4256                     sym_hashes = elf_sym_hashes (ibfd);
4257                     h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4258                     while (h->root.type == bfd_link_hash_indirect
4259                            || h->root.type == bfd_link_hash_warning)
4260                       h = (struct elf_link_hash_entry *) h->root.u.i.link;
4261                   }
4262
4263                 is_local = FALSE;
4264                 if (h == NULL
4265                     || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC))
4266                   is_local = TRUE;
4267
4268                 r_type = ELF32_R_TYPE (rel->r_info);
4269                 switch (r_type)
4270                   {
4271                   case R_PPC_GOT_TLSLD16:
4272                   case R_PPC_GOT_TLSLD16_LO:
4273                   case R_PPC_GOT_TLSLD16_HI:
4274                   case R_PPC_GOT_TLSLD16_HA:
4275                     /* These relocs should never be against a symbol
4276                        defined in a shared lib.  Leave them alone if
4277                        that turns out to be the case.  */
4278                     expecting_tls_get_addr = 0;
4279                     htab->tlsld_got.refcount -= 1;
4280                     if (!is_local)
4281                       continue;
4282
4283                     /* LD -> LE */
4284                     tls_set = 0;
4285                     tls_clear = TLS_LD;
4286                     expecting_tls_get_addr = 1;
4287                     break;
4288
4289                   case R_PPC_GOT_TLSGD16:
4290                   case R_PPC_GOT_TLSGD16_LO:
4291                   case R_PPC_GOT_TLSGD16_HI:
4292                   case R_PPC_GOT_TLSGD16_HA:
4293                     if (is_local)
4294                       /* GD -> LE */
4295                       tls_set = 0;
4296                     else
4297                       /* GD -> IE */
4298                       tls_set = TLS_TLS | TLS_TPRELGD;
4299                     tls_clear = TLS_GD;
4300                     expecting_tls_get_addr = 1;
4301                     break;
4302
4303                   case R_PPC_GOT_TPREL16:
4304                   case R_PPC_GOT_TPREL16_LO:
4305                   case R_PPC_GOT_TPREL16_HI:
4306                   case R_PPC_GOT_TPREL16_HA:
4307                     expecting_tls_get_addr = 0;
4308                     if (is_local)
4309                       {
4310                         /* IE -> LE */
4311                         tls_set = 0;
4312                         tls_clear = TLS_TPREL;
4313                         break;
4314                       }
4315                     else
4316                       continue;
4317
4318                   case R_PPC_REL14:
4319                   case R_PPC_REL14_BRTAKEN:
4320                   case R_PPC_REL14_BRNTAKEN:
4321                   case R_PPC_REL24:
4322                     if (expecting_tls_get_addr
4323                         && h != NULL
4324                         && h == htab->tls_get_addr)
4325                       {
4326                         if (h->plt.refcount > 0)
4327                           h->plt.refcount -= 1;
4328                       }
4329                     expecting_tls_get_addr = 0;
4330                     continue;
4331
4332                   default:
4333                     expecting_tls_get_addr = 0;
4334                     continue;
4335                   }
4336
4337                 if (h != NULL)
4338                   {
4339                     if (tls_set == 0)
4340                       {
4341                         /* We managed to get rid of a got entry.  */
4342                         if (h->got.refcount > 0)
4343                           h->got.refcount -= 1;
4344                       }
4345                     tls_mask = &ppc_elf_hash_entry (h)->tls_mask;
4346                   }
4347                 else
4348                   {
4349                     Elf_Internal_Sym *sym;
4350                     bfd_signed_vma *lgot_refs;
4351                     char *lgot_masks;
4352
4353                     if (locsyms == NULL)
4354                       {
4355                         locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
4356                         if (locsyms == NULL)
4357                           locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
4358                                                           symtab_hdr->sh_info,
4359                                                           0, NULL, NULL, NULL);
4360                         if (locsyms == NULL)
4361                           {
4362                             if (elf_section_data (sec)->relocs != relstart)
4363                               free (relstart);
4364                             return FALSE;
4365                           }
4366                       }
4367                     sym = locsyms + r_symndx;
4368                     lgot_refs = elf_local_got_refcounts (ibfd);
4369                     if (lgot_refs == NULL)
4370                       abort ();
4371                     if (tls_set == 0)
4372                       {
4373                         /* We managed to get rid of a got entry.  */
4374                         if (lgot_refs[r_symndx] > 0)
4375                           lgot_refs[r_symndx] -= 1;
4376                       }
4377                     lgot_masks = (char *) (lgot_refs + symtab_hdr->sh_info);
4378                     tls_mask = &lgot_masks[r_symndx];
4379                   }
4380
4381                 *tls_mask |= tls_set;
4382                 *tls_mask &= ~tls_clear;
4383               }
4384
4385             if (elf_section_data (sec)->relocs != relstart)
4386               free (relstart);
4387           }
4388
4389       if (locsyms != NULL
4390           && (symtab_hdr->contents != (unsigned char *) locsyms))
4391         {
4392           if (!info->keep_memory)
4393             free (locsyms);
4394           else
4395             symtab_hdr->contents = (unsigned char *) locsyms;
4396         }
4397     }
4398   return TRUE;
4399 }
4400 \f
4401 /* Hook called by the linker routine which adds symbols from an object
4402    file.  We use it to put .comm items in .sbss, and not .bss.  */
4403
4404 static bfd_boolean
4405 ppc_elf_add_symbol_hook (bfd *abfd,
4406                          struct bfd_link_info *info,
4407                          const Elf_Internal_Sym *sym,
4408                          const char **namep ATTRIBUTE_UNUSED,
4409                          flagword *flagsp ATTRIBUTE_UNUSED,
4410                          asection **secp,
4411                          bfd_vma *valp)
4412 {
4413   if (sym->st_shndx == SHN_COMMON
4414       && !info->relocatable
4415       && sym->st_size <= elf_gp_size (abfd)
4416       && (info->hash->creator == abfd->xvec
4417           || info->hash->creator == abfd->xvec->alternative_target))
4418     {
4419       /* Common symbols less than or equal to -G nn bytes are automatically
4420          put into .sbss.  */
4421       struct ppc_elf_link_hash_table *htab;
4422
4423       htab = ppc_elf_hash_table (info);
4424       if (htab->sbss == NULL)
4425         {
4426           flagword flags = SEC_IS_COMMON;
4427
4428           htab->sbss = bfd_make_section_anyway (abfd, ".sbss");
4429           if (htab->sbss == NULL
4430               || ! bfd_set_section_flags (abfd, htab->sbss, flags))
4431             return FALSE;
4432         }
4433
4434       *secp = htab->sbss;
4435       *valp = sym->st_size;
4436     }
4437
4438   return TRUE;
4439 }
4440 \f
4441 /* Finish up dynamic symbol handling.  We set the contents of various
4442    dynamic sections here.  */
4443
4444 static bfd_boolean
4445 ppc_elf_finish_dynamic_symbol (bfd *output_bfd,
4446                                struct bfd_link_info *info,
4447                                struct elf_link_hash_entry *h,
4448                                Elf_Internal_Sym *sym)
4449 {
4450   struct ppc_elf_link_hash_table *htab;
4451
4452 #ifdef DEBUG
4453   fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
4454            h->root.root.string);
4455 #endif
4456
4457   htab = ppc_elf_hash_table (info);
4458   BFD_ASSERT (htab->elf.dynobj != NULL);
4459
4460   if (h->plt.offset != (bfd_vma) -1)
4461     {
4462       Elf_Internal_Rela rela;
4463       bfd_byte *loc;
4464       bfd_vma reloc_index;
4465
4466 #ifdef DEBUG
4467       fprintf (stderr, ", plt_offset = %d", h->plt.offset);
4468 #endif
4469
4470       /* This symbol has an entry in the procedure linkage table.  Set
4471          it up.  */
4472
4473       BFD_ASSERT (h->dynindx != -1);
4474       BFD_ASSERT (htab->plt != NULL && htab->relplt != NULL);
4475
4476       /* We don't need to fill in the .plt.  The ppc dynamic linker
4477          will fill it in.  */
4478
4479       /* Fill in the entry in the .rela.plt section.  */
4480       rela.r_offset = (htab->plt->output_section->vma
4481                        + htab->plt->output_offset
4482                        + h->plt.offset);
4483       rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
4484       rela.r_addend = 0;
4485
4486       reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE;
4487       if (reloc_index > PLT_NUM_SINGLE_ENTRIES)
4488         reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
4489       loc = (htab->relplt->contents
4490              + reloc_index * sizeof (Elf32_External_Rela));
4491       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4492
4493       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4494         {
4495           /* Mark the symbol as undefined, rather than as defined in
4496              the .plt section.  Leave the value alone.  */
4497           sym->st_shndx = SHN_UNDEF;
4498           /* If the symbol is weak, we do need to clear the value.
4499              Otherwise, the PLT entry would provide a definition for
4500              the symbol even if the symbol wasn't defined anywhere,
4501              and so the symbol would never be NULL.  */
4502           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
4503               == 0)
4504             sym->st_value = 0;
4505         }
4506     }
4507
4508   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4509     {
4510       asection *s;
4511       Elf_Internal_Rela rela;
4512       bfd_byte *loc;
4513
4514       /* This symbols needs a copy reloc.  Set it up.  */
4515
4516 #ifdef DEBUG
4517       fprintf (stderr, ", copy");
4518 #endif
4519
4520       BFD_ASSERT (h->dynindx != -1);
4521
4522       if (h->size <= elf_gp_size (htab->elf.dynobj))
4523         s = htab->relsbss;
4524       else
4525         s = htab->relbss;
4526       BFD_ASSERT (s != NULL);
4527
4528       rela.r_offset = (h->root.u.def.value
4529                        + h->root.u.def.section->output_section->vma
4530                        + h->root.u.def.section->output_offset);
4531       rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
4532       rela.r_addend = 0;
4533       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4534       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4535     }
4536
4537 #ifdef DEBUG
4538   fprintf (stderr, "\n");
4539 #endif
4540
4541   /* Mark some specially defined symbols as absolute.  */
4542   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4543       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4544       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4545     sym->st_shndx = SHN_ABS;
4546
4547   return TRUE;
4548 }
4549 \f
4550 /* Finish up the dynamic sections.  */
4551
4552 static bfd_boolean
4553 ppc_elf_finish_dynamic_sections (bfd *output_bfd,
4554                                  struct bfd_link_info *info)
4555 {
4556   asection *sdyn;
4557   struct ppc_elf_link_hash_table *htab;
4558
4559 #ifdef DEBUG
4560   fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
4561 #endif
4562
4563   htab = ppc_elf_hash_table (info);
4564   sdyn = bfd_get_section_by_name (htab->elf.dynobj, ".dynamic");
4565
4566   if (htab->elf.dynamic_sections_created)
4567     {
4568       Elf32_External_Dyn *dyncon, *dynconend;
4569
4570       BFD_ASSERT (htab->plt != NULL && sdyn != NULL);
4571
4572       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4573       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4574       for (; dyncon < dynconend; dyncon++)
4575         {
4576           Elf_Internal_Dyn dyn;
4577           asection *s;
4578
4579           bfd_elf32_swap_dyn_in (htab->elf.dynobj, dyncon, &dyn);
4580
4581           switch (dyn.d_tag)
4582             {
4583             case DT_PLTGOT:
4584               s = htab->plt;
4585               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4586               break;
4587
4588             case DT_PLTRELSZ:
4589               dyn.d_un.d_val = htab->relplt->_raw_size;
4590               break;
4591
4592             case DT_JMPREL:
4593               s = htab->relplt;
4594               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4595               break;
4596
4597             default:
4598               continue;
4599             }
4600
4601           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4602         }
4603     }
4604
4605   /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
4606      easily find the address of the _GLOBAL_OFFSET_TABLE_.  */
4607   if (htab->got)
4608     {
4609       unsigned char *contents = htab->got->contents;
4610       bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
4611
4612       if (sdyn == NULL)
4613         bfd_put_32 (output_bfd, 0, contents + 4);
4614       else
4615         bfd_put_32 (output_bfd,
4616                     sdyn->output_section->vma + sdyn->output_offset,
4617                     contents + 4);
4618
4619       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
4620     }
4621
4622   return TRUE;
4623 }
4624 \f
4625 /* The RELOCATE_SECTION function is called by the ELF backend linker
4626    to handle the relocations for a section.
4627
4628    The relocs are always passed as Rela structures; if the section
4629    actually uses Rel structures, the r_addend field will always be
4630    zero.
4631
4632    This function is responsible for adjust the section contents as
4633    necessary, and (if using Rela relocs and generating a
4634    relocatable output file) adjusting the reloc addend as
4635    necessary.
4636
4637    This function does not have to worry about setting the reloc
4638    address or the reloc symbol index.
4639
4640    LOCAL_SYMS is a pointer to the swapped in local symbols.
4641
4642    LOCAL_SECTIONS is an array giving the section in the input file
4643    corresponding to the st_shndx field of each local symbol.
4644
4645    The global hash table entry for the global symbols can be found
4646    via elf_sym_hashes (input_bfd).
4647
4648    When generating relocatable output, this function must handle
4649    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
4650    going to be the section symbol corresponding to the output
4651    section, which means that the addend must be adjusted
4652    accordingly.  */
4653
4654 static bfd_boolean
4655 ppc_elf_relocate_section (bfd *output_bfd,
4656                           struct bfd_link_info *info,
4657                           bfd *input_bfd,
4658                           asection *input_section,
4659                           bfd_byte *contents,
4660                           Elf_Internal_Rela *relocs,
4661                           Elf_Internal_Sym *local_syms,
4662                           asection **local_sections)
4663 {
4664   Elf_Internal_Shdr *symtab_hdr;
4665   struct elf_link_hash_entry **sym_hashes;
4666   struct ppc_elf_link_hash_table *htab;
4667   Elf_Internal_Rela *rel;
4668   Elf_Internal_Rela *relend;
4669   Elf_Internal_Rela outrel;
4670   bfd_byte *loc;
4671   asection *sreloc = NULL;
4672   bfd_vma *local_got_offsets;
4673   bfd_boolean ret = TRUE;
4674
4675 #ifdef DEBUG
4676   fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, "
4677            "%ld relocations%s\n",
4678            bfd_archive_filename (input_bfd),
4679            bfd_section_name(input_bfd, input_section),
4680            (long) input_section->reloc_count,
4681            (info->relocatable) ? " (relocatable)" : "");
4682 #endif
4683
4684   if (info->relocatable)
4685     return TRUE;
4686
4687   /* Initialize howto table if not already done.  */
4688   if (!ppc_elf_howto_table[R_PPC_ADDR32])
4689     ppc_elf_howto_init ();
4690
4691   htab = ppc_elf_hash_table (info);
4692   local_got_offsets = elf_local_got_offsets (input_bfd);
4693   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4694   sym_hashes = elf_sym_hashes (input_bfd);
4695   rel = relocs;
4696   relend = relocs + input_section->reloc_count;
4697   for (; rel < relend; rel++)
4698     {
4699       enum elf_ppc_reloc_type r_type;
4700       bfd_vma addend;
4701       bfd_reloc_status_type r;
4702       Elf_Internal_Sym *sym;
4703       asection *sec;
4704       struct elf_link_hash_entry *h;
4705       const char *sym_name;
4706       reloc_howto_type *howto;
4707       unsigned long r_symndx;
4708       bfd_vma relocation;
4709       bfd_vma branch_bit, insn, from;
4710       bfd_boolean unresolved_reloc;
4711       bfd_boolean warned;
4712       unsigned int tls_type, tls_mask, tls_gd;
4713
4714       r_type = ELF32_R_TYPE (rel->r_info);
4715       sym = NULL;
4716       sec = NULL;
4717       h = NULL;
4718       unresolved_reloc = FALSE;
4719       warned = FALSE;
4720       r_symndx = ELF32_R_SYM (rel->r_info);
4721       if (r_symndx < symtab_hdr->sh_info)
4722         {
4723           sym = local_syms + r_symndx;
4724           sec = local_sections[r_symndx];
4725           sym_name = bfd_elf_local_sym_name (input_bfd, sym);
4726
4727           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4728         }
4729       else
4730         {
4731           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4732           while (h->root.type == bfd_link_hash_indirect
4733                  || h->root.type == bfd_link_hash_warning)
4734             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4735           sym_name = h->root.root.string;
4736
4737           relocation = 0;
4738           if (h->root.type == bfd_link_hash_defined
4739               || h->root.type == bfd_link_hash_defweak)
4740             {
4741               sec = h->root.u.def.section;
4742               /* Set a flag that will be cleared later if we find a
4743                  relocation value for this symbol.  output_section
4744                  is typically NULL for symbols satisfied by a shared
4745                  library.  */
4746               if (sec->output_section == NULL)
4747                 unresolved_reloc = TRUE;
4748               else
4749                 relocation = (h->root.u.def.value
4750                               + sec->output_section->vma
4751                               + sec->output_offset);
4752             }
4753           else if (h->root.type == bfd_link_hash_undefweak)
4754             ;
4755           else if (!info->executable
4756                    && !info->no_undefined
4757                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4758             ;
4759           else
4760             {
4761               if (! ((*info->callbacks->undefined_symbol)
4762                      (info, h->root.root.string, input_bfd, input_section,
4763                       rel->r_offset, (info->executable
4764                                       || info->no_undefined
4765                                       || ELF_ST_VISIBILITY (h->other)))))
4766                 return FALSE;
4767               warned = TRUE;
4768             }
4769         }
4770
4771       /* TLS optimizations.  Replace instruction sequences and relocs
4772          based on information we collected in tls_optimize.  We edit
4773          RELOCS so that --emit-relocs will output something sensible
4774          for the final instruction stream.  */
4775       tls_mask = 0;
4776       tls_gd = 0;
4777       if (IS_PPC_TLS_RELOC (r_type))
4778         {
4779           if (h != NULL)
4780             tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask;
4781           else if (local_got_offsets != NULL)
4782             {
4783               char *lgot_masks;
4784               lgot_masks = (char *) (local_got_offsets + symtab_hdr->sh_info);
4785               tls_mask = lgot_masks[r_symndx];
4786             }
4787         }
4788
4789       /* Ensure reloc mapping code below stays sane.  */
4790       if ((R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TLSGD16 & 3)
4791           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3)
4792           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3)
4793           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3)
4794           || (R_PPC_GOT_TLSLD16 & 3)    != (R_PPC_GOT_TPREL16 & 3)
4795           || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3)
4796           || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3)
4797           || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3))
4798         abort ();
4799       switch (r_type)
4800         {
4801         default:
4802           break;
4803
4804         case R_PPC_GOT_TPREL16:
4805         case R_PPC_GOT_TPREL16_LO:
4806           if (tls_mask != 0
4807               && (tls_mask & TLS_TPREL) == 0)
4808             {
4809               bfd_vma insn;
4810               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
4811               insn &= 31 << 21;
4812               insn |= 0x3c020000;       /* addis 0,2,0 */
4813               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
4814               r_type = R_PPC_TPREL16_HA;
4815               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4816             }
4817           break;
4818
4819         case R_PPC_TLS:
4820           if (tls_mask != 0
4821               && (tls_mask & TLS_TPREL) == 0)
4822             {
4823               bfd_vma insn, rtra;
4824               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
4825               if ((insn & ((31 << 26) | (31 << 11)))
4826                   == ((31 << 26) | (2 << 11)))
4827                 rtra = insn & ((1 << 26) - (1 << 16));
4828               else if ((insn & ((31 << 26) | (31 << 16)))
4829                        == ((31 << 26) | (2 << 16)))
4830                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
4831               else
4832                 abort ();
4833               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
4834                 /* add -> addi.  */
4835                 insn = 14 << 26;
4836               else if ((insn & (31 << 1)) == 23 << 1
4837                        && ((insn & (31 << 6)) < 14 << 6
4838                            || ((insn & (31 << 6)) >= 16 << 6
4839                                && (insn & (31 << 6)) < 24 << 6)))
4840                 /* load and store indexed -> dform.  */
4841                 insn = (32 | ((insn >> 6) & 31)) << 26;
4842               else if ((insn & (31 << 1)) == 21 << 1
4843                        && (insn & (0x1a << 6)) == 0)
4844                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
4845                 insn = (((58 | ((insn >> 6) & 4)) << 26)
4846                         | ((insn >> 6) & 1));
4847               else if ((insn & (31 << 1)) == 21 << 1
4848                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
4849                 /* lwax -> lwa.  */
4850                 insn = (58 << 26) | 2;
4851               else
4852                 abort ();
4853               insn |= rtra;
4854               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
4855               r_type = R_PPC_TPREL16_LO;
4856               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4857               /* Was PPC_TLS which sits on insn boundary, now
4858                  PPC_TPREL16_LO which is at insn+2.  */
4859               rel->r_offset += 2;
4860             }
4861           break;
4862
4863         case R_PPC_GOT_TLSGD16_HI:
4864         case R_PPC_GOT_TLSGD16_HA:
4865           tls_gd = TLS_TPRELGD;
4866           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
4867             goto tls_gdld_hi;
4868           break;
4869
4870         case R_PPC_GOT_TLSLD16_HI:
4871         case R_PPC_GOT_TLSLD16_HA:
4872           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
4873             {
4874             tls_gdld_hi:
4875               if ((tls_mask & tls_gd) != 0)
4876                 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
4877                           + R_PPC_GOT_TPREL16);
4878               else
4879                 {
4880                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
4881                   rel->r_offset -= 2;
4882                   r_type = R_PPC_NONE;
4883                 }
4884               rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4885             }
4886           break;
4887
4888         case R_PPC_GOT_TLSGD16:
4889         case R_PPC_GOT_TLSGD16_LO:
4890           tls_gd = TLS_TPRELGD;
4891           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
4892             goto tls_get_addr_check;
4893           break;
4894
4895         case R_PPC_GOT_TLSLD16:
4896         case R_PPC_GOT_TLSLD16_LO:
4897           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
4898             {
4899             tls_get_addr_check:
4900               if (rel + 1 < relend)
4901                 {
4902                   enum elf_ppc_reloc_type r_type2;
4903                   unsigned long r_symndx2;
4904                   struct elf_link_hash_entry *h2;
4905                   bfd_vma insn1, insn2;
4906                   bfd_vma offset;
4907
4908                   /* The next instruction should be a call to
4909                      __tls_get_addr.  Peek at the reloc to be sure.  */
4910                   r_type2 = ELF32_R_TYPE (rel[1].r_info);
4911                   r_symndx2 = ELF32_R_SYM (rel[1].r_info);
4912                   if (r_symndx2 < symtab_hdr->sh_info
4913                       || (r_type2 != R_PPC_REL14
4914                           && r_type2 != R_PPC_REL14_BRTAKEN
4915                           && r_type2 != R_PPC_REL14_BRNTAKEN
4916                           && r_type2 != R_PPC_REL24
4917                           && r_type2 != R_PPC_PLTREL24))
4918                     break;
4919
4920                   h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
4921                   while (h2->root.type == bfd_link_hash_indirect
4922                          || h2->root.type == bfd_link_hash_warning)
4923                     h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
4924                   if (h2 == NULL || h2 != htab->tls_get_addr)
4925                     break;
4926
4927                   /* OK, it checks out.  Replace the call.  */
4928                   offset = rel[1].r_offset;
4929                   insn1 = bfd_get_32 (output_bfd,
4930                                       contents + rel->r_offset - 2);
4931                   if ((tls_mask & tls_gd) != 0)
4932                     {
4933                       /* IE */
4934                       insn1 &= (1 << 26) - 1;
4935                       insn1 |= 32 << 26;        /* lwz */
4936                       insn2 = 0x7c631214;       /* add 3,3,2 */
4937                       rel[1].r_info = ELF32_R_INFO (r_symndx2, R_PPC_NONE);
4938                       r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3)
4939                                 + R_PPC_GOT_TPREL16);
4940                       rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4941                     }
4942                   else
4943                     {
4944                       /* LE */
4945                       insn1 = 0x3c620000;       /* addis 3,2,0 */
4946                       insn2 = 0x38630000;       /* addi 3,3,0 */
4947                       if (tls_gd == 0)
4948                         {
4949                           /* Was an LD reloc.  */
4950                           r_symndx = 0;
4951                           rel->r_addend = htab->tls_sec->vma + DTP_OFFSET;
4952                           rel[1].r_addend = htab->tls_sec->vma + DTP_OFFSET;
4953                         }
4954                       r_type = R_PPC_TPREL16_HA;
4955                       rel->r_info = ELF32_R_INFO (r_symndx, r_type);
4956                       rel[1].r_info = ELF32_R_INFO (r_symndx,
4957                                                     R_PPC_TPREL16_LO);
4958                       rel[1].r_offset += 2;
4959                     }
4960                   bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
4961                   bfd_put_32 (output_bfd, insn2, contents + offset);
4962                   if (tls_gd == 0)
4963                     {
4964                       /* We changed the symbol on an LD reloc.  Start over
4965                          in order to get h, sym, sec etc. right.  */
4966                       rel--;
4967                       continue;
4968                     }
4969                 }
4970             }
4971           break;
4972         }
4973
4974       /* Handle other relocations that tweak non-addend part of insn.  */
4975       branch_bit = 0;
4976       switch (r_type)
4977         {
4978         default:
4979           break;
4980
4981           /* Branch taken prediction relocations.  */
4982         case R_PPC_ADDR14_BRTAKEN:
4983         case R_PPC_REL14_BRTAKEN:
4984           branch_bit = BRANCH_PREDICT_BIT;
4985           /* Fall thru */
4986
4987           /* Branch not taken predicition relocations.  */
4988         case R_PPC_ADDR14_BRNTAKEN:
4989         case R_PPC_REL14_BRNTAKEN:
4990           insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
4991           insn &= ~BRANCH_PREDICT_BIT;
4992           insn |= branch_bit;
4993
4994           from = (rel->r_offset
4995                   + input_section->output_offset
4996                   + input_section->output_section->vma);
4997
4998           /* Invert 'y' bit if not the default.  */
4999           if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0)
5000             insn ^= BRANCH_PREDICT_BIT;
5001
5002           bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5003           break;
5004         }
5005
5006       addend = rel->r_addend;
5007       tls_type = 0;
5008       howto = NULL;
5009       if (r_type < R_PPC_max)
5010         howto = ppc_elf_howto_table[r_type];
5011       switch (r_type)
5012         {
5013         default:
5014           (*_bfd_error_handler)
5015             (_("%s: unknown relocation type %d for symbol %s"),
5016              bfd_archive_filename (input_bfd), (int) r_type, sym_name);
5017
5018           bfd_set_error (bfd_error_bad_value);
5019           ret = FALSE;
5020           continue;
5021
5022         case R_PPC_NONE:
5023         case R_PPC_TLS:
5024         case R_PPC_EMB_MRKREF:
5025         case R_PPC_GNU_VTINHERIT:
5026         case R_PPC_GNU_VTENTRY:
5027           continue;
5028
5029           /* GOT16 relocations.  Like an ADDR16 using the symbol's
5030              address in the GOT as relocation value instead of the
5031              symbol's value itself.  Also, create a GOT entry for the
5032              symbol and put the symbol value there.  */
5033         case R_PPC_GOT_TLSGD16:
5034         case R_PPC_GOT_TLSGD16_LO:
5035         case R_PPC_GOT_TLSGD16_HI:
5036         case R_PPC_GOT_TLSGD16_HA:
5037           tls_type = TLS_TLS | TLS_GD;
5038           goto dogot;
5039
5040         case R_PPC_GOT_TLSLD16:
5041         case R_PPC_GOT_TLSLD16_LO:
5042         case R_PPC_GOT_TLSLD16_HI:
5043         case R_PPC_GOT_TLSLD16_HA:
5044           tls_type = TLS_TLS | TLS_LD;
5045           goto dogot;
5046
5047         case R_PPC_GOT_TPREL16:
5048         case R_PPC_GOT_TPREL16_LO:
5049         case R_PPC_GOT_TPREL16_HI:
5050         case R_PPC_GOT_TPREL16_HA:
5051           tls_type = TLS_TLS | TLS_TPREL;
5052           goto dogot;
5053
5054         case R_PPC_GOT_DTPREL16:
5055         case R_PPC_GOT_DTPREL16_LO:
5056         case R_PPC_GOT_DTPREL16_HI:
5057         case R_PPC_GOT_DTPREL16_HA:
5058           tls_type = TLS_TLS | TLS_DTPREL;
5059           goto dogot;
5060
5061         case R_PPC_GOT16:
5062         case R_PPC_GOT16_LO:
5063         case R_PPC_GOT16_HI:
5064         case R_PPC_GOT16_HA:
5065         dogot:
5066           {
5067             /* Relocation is to the entry for this symbol in the global
5068                offset table.  */
5069             bfd_vma off;
5070             bfd_vma *offp;
5071             unsigned long indx;
5072
5073             if (htab->got == NULL)
5074               abort ();
5075
5076             indx = 0;
5077             if (tls_type == (TLS_TLS | TLS_LD)
5078                 && (h == NULL
5079                     || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)))
5080               offp = &htab->tlsld_got.offset;
5081             else if (h != NULL)
5082               {
5083                 bfd_boolean dyn;
5084                 dyn = htab->elf.dynamic_sections_created;
5085                 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5086                     || (info->shared
5087                         && SYMBOL_REFERENCES_LOCAL (info, h)))
5088                   /* This is actually a static link, or it is a
5089                      -Bsymbolic link and the symbol is defined
5090                      locally, or the symbol was forced to be local
5091                      because of a version file.  */
5092                   ;
5093                 else
5094                   {
5095                     indx = h->dynindx;
5096                     unresolved_reloc = FALSE;
5097                   }
5098                 offp = &h->got.offset;
5099               }
5100             else
5101               {
5102                 if (local_got_offsets == NULL)
5103                   abort ();
5104                 offp = &local_got_offsets[r_symndx];
5105               }
5106
5107             /* The offset must always be a multiple of 4.  We use the
5108                least significant bit to record whether we have already
5109                processed this entry.  */
5110             off = *offp;
5111             if ((off & 1) != 0)
5112               off &= ~1;
5113             else
5114               {
5115                 unsigned int tls_m = (tls_mask
5116                                       & (TLS_LD | TLS_GD | TLS_DTPREL
5117                                          | TLS_TPREL | TLS_TPRELGD));
5118
5119                 if (offp == &htab->tlsld_got.offset)
5120                   tls_m = TLS_LD;
5121                 else if (h == NULL
5122                          || !(h->elf_link_hash_flags
5123                               & ELF_LINK_HASH_DEF_DYNAMIC))
5124                   tls_m &= ~TLS_LD;
5125
5126                 /* We might have multiple got entries for this sym.
5127                    Initialize them all.  */
5128                 do
5129                   {
5130                     int tls_ty = 0;
5131
5132                     if ((tls_m & TLS_LD) != 0)
5133                       {
5134                         tls_ty = TLS_TLS | TLS_LD;
5135                         tls_m &= ~TLS_LD;
5136                       }
5137                     else if ((tls_m & TLS_GD) != 0)
5138                       {
5139                         tls_ty = TLS_TLS | TLS_GD;
5140                         tls_m &= ~TLS_GD;
5141                       }
5142                     else if ((tls_m & TLS_DTPREL) != 0)
5143                       {
5144                         tls_ty = TLS_TLS | TLS_DTPREL;
5145                         tls_m &= ~TLS_DTPREL;
5146                       }
5147                     else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0)
5148                       {
5149                         tls_ty = TLS_TLS | TLS_TPREL;
5150                         tls_m = 0;
5151                       }
5152
5153                     /* Generate relocs for the dynamic linker.  */
5154                     if ((info->shared || indx != 0)
5155                         && (h == NULL
5156                             || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5157                             || h->root.type != bfd_link_hash_undefweak))
5158                       {
5159                         outrel.r_offset = (htab->got->output_section->vma
5160                                            + htab->got->output_offset
5161                                            + off);
5162                         outrel.r_addend = 0;
5163                         if (tls_ty & (TLS_LD | TLS_GD))
5164                           {
5165                             outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32);
5166                             if (tls_ty == (TLS_TLS | TLS_GD))
5167                               {
5168                                 loc = htab->relgot->contents;
5169                                 loc += (htab->relgot->reloc_count++
5170                                         * sizeof (Elf32_External_Rela));
5171                                 bfd_elf32_swap_reloca_out (output_bfd,
5172                                                            &outrel, loc);
5173                                 outrel.r_offset += 4;
5174                                 outrel.r_info
5175                                   = ELF32_R_INFO (indx, R_PPC_DTPREL32);
5176                               }
5177                           }
5178                         else if (tls_ty == (TLS_TLS | TLS_DTPREL))
5179                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32);
5180                         else if (tls_ty == (TLS_TLS | TLS_TPREL))
5181                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32);
5182                         else if (indx == 0)
5183                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_RELATIVE);
5184                         else
5185                           outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
5186                         if (indx == 0)
5187                           {
5188                             outrel.r_addend += relocation;
5189                             if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
5190                               outrel.r_addend -= htab->tls_sec->vma;
5191                           }
5192                         loc = htab->relgot->contents;
5193                         loc += (htab->relgot->reloc_count++
5194                                 * sizeof (Elf32_External_Rela));
5195                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5196                       }
5197
5198                     /* Init the .got section contents if we're not
5199                        emitting a reloc.  */
5200                     else
5201                       {
5202                         bfd_vma value = relocation;
5203
5204                         if (tls_ty == (TLS_TLS | TLS_LD))
5205                           value = 1;
5206                         else if (tls_ty != 0)
5207                           {
5208                             value -= htab->tls_sec->vma + DTP_OFFSET;
5209                             if (tls_ty == (TLS_TLS | TLS_TPREL))
5210                               value += DTP_OFFSET - TP_OFFSET;
5211
5212                             if (tls_ty == (TLS_TLS | TLS_GD))
5213                               {
5214                                 bfd_put_32 (output_bfd, value,
5215                                             htab->got->contents + off + 4);
5216                                 value = 1;
5217                               }
5218                           }
5219                         bfd_put_32 (output_bfd, value,
5220                                     htab->got->contents + off);
5221                       }
5222
5223                     off += 4;
5224                     if (tls_ty & (TLS_LD | TLS_GD))
5225                       off += 4;
5226                   }
5227                 while (tls_m != 0);
5228
5229                 off = *offp;
5230                 *offp = off | 1;
5231               }
5232
5233             if (off >= (bfd_vma) -2)
5234               abort ();
5235
5236             if ((tls_type & TLS_TLS) != 0)
5237               {
5238                 if (tls_type != (TLS_TLS | TLS_LD))
5239                   {
5240                     if ((tls_mask & TLS_LD) != 0
5241                         && !(h == NULL
5242                              || !(h->elf_link_hash_flags
5243                                   & ELF_LINK_HASH_DEF_DYNAMIC)))
5244                       off += 8;
5245                     if (tls_type != (TLS_TLS | TLS_GD))
5246                       {
5247                         if ((tls_mask & TLS_GD) != 0)
5248                           off += 8;
5249                         if (tls_type != (TLS_TLS | TLS_DTPREL))
5250                           {
5251                             if ((tls_mask & TLS_DTPREL) != 0)
5252                               off += 4;
5253                           }
5254                       }
5255                   }
5256               }
5257
5258             relocation = htab->got->output_offset + off - 4;
5259
5260             /* Addends on got relocations don't make much sense.
5261                x+off@got is actually x@got+off, and since the got is
5262                generated by a hash table traversal, the value in the
5263                got at entry m+n bears little relation to the entry m.  */
5264             if (addend != 0)
5265               (*_bfd_error_handler)
5266                 (_("%s(%s+0x%lx): non-zero addend on %s reloc against `%s'"),
5267                  bfd_archive_filename (input_bfd),
5268                  bfd_get_section_name (input_bfd, input_section),
5269                  (long) rel->r_offset,
5270                  howto->name,
5271                  sym_name);
5272           }
5273         break;
5274
5275         /* Relocations that need no special processing.  */
5276         case R_PPC_LOCAL24PC:
5277           /* It makes no sense to point a local relocation
5278              at a symbol not in this object.  */
5279           if (unresolved_reloc)
5280             {
5281               if (! (*info->callbacks->undefined_symbol) (info,
5282                                                           h->root.root.string,
5283                                                           input_bfd,
5284                                                           input_section,
5285                                                           rel->r_offset,
5286                                                           TRUE))
5287                 return FALSE;
5288               continue;
5289             }
5290           break;
5291
5292         case R_PPC_DTPREL16:
5293         case R_PPC_DTPREL16_LO:
5294         case R_PPC_DTPREL16_HI:
5295         case R_PPC_DTPREL16_HA:
5296           addend -= htab->tls_sec->vma + DTP_OFFSET;
5297           break;
5298
5299           /* Relocations that may need to be propagated if this is a shared
5300              object.  */
5301         case R_PPC_TPREL16:
5302         case R_PPC_TPREL16_LO:
5303         case R_PPC_TPREL16_HI:
5304         case R_PPC_TPREL16_HA:
5305           addend -= htab->tls_sec->vma + TP_OFFSET;
5306           /* The TPREL16 relocs shouldn't really be used in shared
5307              libs as they will result in DT_TEXTREL being set, but
5308              support them anyway.  */
5309           goto dodyn;
5310
5311         case R_PPC_TPREL32:
5312           addend -= htab->tls_sec->vma + TP_OFFSET;
5313           goto dodyn;
5314
5315         case R_PPC_DTPREL32:
5316           addend -= htab->tls_sec->vma + DTP_OFFSET;
5317           goto dodyn;
5318
5319         case R_PPC_DTPMOD32:
5320           relocation = 1;
5321           addend = 0;
5322           goto dodyn;
5323
5324         case R_PPC_REL24:
5325         case R_PPC_REL32:
5326         case R_PPC_REL14:
5327         case R_PPC_REL14_BRTAKEN:
5328         case R_PPC_REL14_BRNTAKEN:
5329           /* If these relocations are not to a named symbol, they can be
5330              handled right here, no need to bother the dynamic linker.  */
5331           if (SYMBOL_REFERENCES_LOCAL (info, h)
5332               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5333             break;
5334           /* fall through */
5335
5336           /* Relocations that always need to be propagated if this is a shared
5337              object.  */
5338         case R_PPC_ADDR32:
5339         case R_PPC_ADDR24:
5340         case R_PPC_ADDR16:
5341         case R_PPC_ADDR16_LO:
5342         case R_PPC_ADDR16_HI:
5343         case R_PPC_ADDR16_HA:
5344         case R_PPC_ADDR14:
5345         case R_PPC_ADDR14_BRTAKEN:
5346         case R_PPC_ADDR14_BRNTAKEN:
5347         case R_PPC_UADDR32:
5348         case R_PPC_UADDR16:
5349           /* r_symndx will be zero only for relocs against symbols
5350              from removed linkonce sections, or sections discarded by
5351              a linker script.  */
5352         dodyn:
5353           if (r_symndx == 0)
5354             break;
5355           /* Fall thru.  */
5356
5357           if ((info->shared
5358                && (h == NULL
5359                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5360                    || h->root.type != bfd_link_hash_undefweak)
5361                && (MUST_BE_DYN_RELOC (r_type)
5362                    || !SYMBOL_CALLS_LOCAL (info, h)))
5363               || (ELIMINATE_COPY_RELOCS
5364                   && !info->shared
5365                   && (input_section->flags & SEC_ALLOC) != 0
5366                   && h != NULL
5367                   && h->dynindx != -1
5368                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
5369                   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5370                   && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0))
5371             {
5372               int skip;
5373
5374 #ifdef DEBUG
5375               fprintf (stderr, "ppc_elf_relocate_section needs to "
5376                        "create relocation for %s\n",
5377                        (h && h->root.root.string
5378                         ? h->root.root.string : "<unknown>"));
5379 #endif
5380
5381               /* When generating a shared object, these relocations
5382                  are copied into the output file to be resolved at run
5383                  time.  */
5384               if (sreloc == NULL)
5385                 {
5386                   const char *name;
5387
5388                   name = (bfd_elf_string_from_elf_section
5389                           (input_bfd,
5390                            elf_elfheader (input_bfd)->e_shstrndx,
5391                            elf_section_data (input_section)->rel_hdr.sh_name));
5392                   if (name == NULL)
5393                     return FALSE;
5394
5395                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5396                               && strcmp (bfd_get_section_name (input_bfd,
5397                                                                input_section),
5398                                          name + 5) == 0);
5399
5400                   sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
5401                   BFD_ASSERT (sreloc != NULL);
5402                 }
5403
5404               skip = 0;
5405
5406               outrel.r_offset =
5407                 _bfd_elf_section_offset (output_bfd, info, input_section,
5408                                          rel->r_offset);
5409               if (outrel.r_offset == (bfd_vma) -1
5410                   || outrel.r_offset == (bfd_vma) -2)
5411                 skip = (int) outrel.r_offset;
5412               outrel.r_offset += (input_section->output_section->vma
5413                                   + input_section->output_offset);
5414
5415               if (skip)
5416                 memset (&outrel, 0, sizeof outrel);
5417               else if (!SYMBOL_REFERENCES_LOCAL (info, h))
5418                 {
5419                   unresolved_reloc = FALSE;
5420                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5421                   outrel.r_addend = rel->r_addend;
5422                 }
5423               else
5424                 {
5425                   outrel.r_addend = relocation + rel->r_addend;
5426
5427                   if (r_type == R_PPC_ADDR32)
5428                     outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
5429                   else
5430                     {
5431                       long indx;
5432
5433                       if (bfd_is_abs_section (sec))
5434                         indx = 0;
5435                       else if (sec == NULL || sec->owner == NULL)
5436                         {
5437                           bfd_set_error (bfd_error_bad_value);
5438                           return FALSE;
5439                         }
5440                       else
5441                         {
5442                           asection *osec;
5443
5444                           /* We are turning this relocation into one
5445                              against a section symbol.  It would be
5446                              proper to subtract the symbol's value,
5447                              osec->vma, from the emitted reloc addend,
5448                              but ld.so expects buggy relocs.  */
5449                           osec = sec->output_section;
5450                           indx = elf_section_data (osec)->dynindx;
5451                           BFD_ASSERT (indx > 0);
5452 #ifdef DEBUG
5453                           if (indx <= 0)
5454                             printf ("indx=%d section=%s flags=%08x name=%s\n",
5455                                     indx, osec->name, osec->flags,
5456                                     h->root.root.string);
5457 #endif
5458                         }
5459
5460                       outrel.r_info = ELF32_R_INFO (indx, r_type);
5461                     }
5462                 }
5463
5464               loc = sreloc->contents;
5465               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5466               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5467
5468               if (skip == -1)
5469                 continue;
5470
5471               /* This reloc will be computed at runtime.  We clear the memory
5472                  so that it contains predictable value.  */
5473               if (! skip
5474                   && ((input_section->flags & SEC_ALLOC) != 0
5475                       || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE))
5476                 {
5477                   relocation = howto->pc_relative ? outrel.r_offset : 0;
5478                   addend = 0;
5479                   break;
5480                 }
5481             }
5482           break;
5483
5484         case R_PPC_RELAX32:
5485           {
5486             unsigned long r_symndx;
5487             Elf_Internal_Sym *sym;
5488             asection *sym_sec;
5489             bfd_byte *hit_addr = 0;
5490             bfd_vma value = 0;
5491
5492             r_symndx = ELF32_R_SYM (rel->r_info);
5493
5494             if (r_symndx < symtab_hdr->sh_info)
5495               {
5496                 sym = local_syms + r_symndx;
5497                 sym_sec = local_sections[r_symndx];
5498
5499                 value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
5500               }
5501             else
5502               {
5503                 long indx;
5504
5505                 indx = r_symndx - symtab_hdr->sh_info;
5506                 h = elf_sym_hashes (input_bfd)[indx];
5507                 while (h->root.type == bfd_link_hash_indirect
5508                  || h->root.type == bfd_link_hash_warning)
5509                   h = (struct elf_link_hash_entry *) h->root.u.i.link;
5510
5511                 value = 0;
5512                 if (h->root.type == bfd_link_hash_defined
5513                     || h->root.type == bfd_link_hash_defweak)
5514                   {
5515                     sym_sec = h->root.u.def.section;
5516
5517                     /* Detect the cases that sym_sec->output_section is
5518                        expected to be NULL -- all cases in which the symbol
5519                        is defined in another shared module.  This includes
5520                        PLT relocs for which we've created a PLT entry and
5521                        other relocs for which we're prepared to create
5522                        dynamic relocations.  */
5523                     /* ??? Just accept it NULL and continue.  */
5524
5525                     if (sym_sec->output_section != NULL)
5526                       {
5527                         value = (h->root.u.def.value
5528                                  + sym_sec->output_section->vma
5529                                  + sym_sec->output_offset);
5530                       }
5531                   }
5532                 else if (!info->executable
5533                          && !info->no_undefined
5534                          && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
5535                   ;
5536                 else
5537                   {
5538                     if (! ((*info->callbacks->undefined_symbol)
5539                            (info, h->root.root.string, input_bfd,
5540                             input_section, rel->r_offset,
5541                             (info->executable || info->no_undefined
5542                              || ELF_ST_VISIBILITY (h->other)))))
5543                       return FALSE;
5544                     continue;
5545                   }
5546               }
5547             hit_addr = contents + rel->r_offset;
5548             value += rel->r_addend;
5549
5550             r = ppc_elf_install_value (output_bfd, hit_addr, value, r_type);
5551             if (r != bfd_reloc_ok)
5552               break;
5553             else
5554               continue;
5555           }
5556
5557           /* Indirect .sdata relocation.  */
5558         case R_PPC_EMB_SDAI16:
5559           BFD_ASSERT (htab->sdata != NULL);
5560           relocation
5561             = elf_finish_pointer_linker_section (output_bfd, input_bfd, info,
5562                                                  htab->sdata, h, relocation,
5563                                                  rel, R_PPC_RELATIVE);
5564           break;
5565
5566           /* Indirect .sdata2 relocation.  */
5567         case R_PPC_EMB_SDA2I16:
5568           BFD_ASSERT (htab->sdata2 != NULL);
5569           relocation
5570             = elf_finish_pointer_linker_section (output_bfd, input_bfd, info,
5571                                                  htab->sdata2, h, relocation,
5572                                                  rel, R_PPC_RELATIVE);
5573           break;
5574
5575           /* Handle the TOC16 reloc.  We want to use the offset within the .got
5576              section, not the actual VMA.  This is appropriate when generating
5577              an embedded ELF object, for which the .got section acts like the
5578              AIX .toc section.  */
5579         case R_PPC_TOC16:                       /* phony GOT16 relocations */
5580           BFD_ASSERT (sec != NULL);
5581           BFD_ASSERT (bfd_is_und_section (sec)
5582                       || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
5583                       || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
5584
5585             addend -= sec->output_section->vma + sec->output_offset + 0x8000;
5586           break;
5587
5588         case R_PPC_PLTREL24:
5589           /* Relocation is to the entry for this symbol in the
5590              procedure linkage table.  */
5591           BFD_ASSERT (h != NULL);
5592
5593           if (h->plt.offset == (bfd_vma) -1
5594               || htab->plt == NULL)
5595             {
5596               /* We didn't make a PLT entry for this symbol.  This
5597                  happens when statically linking PIC code, or when
5598                  using -Bsymbolic.  */
5599               break;
5600             }
5601
5602           unresolved_reloc = FALSE;
5603           relocation = (htab->plt->output_section->vma
5604                         + htab->plt->output_offset
5605                         + h->plt.offset);
5606           break;
5607
5608           /* Relocate against _SDA_BASE_.  */
5609         case R_PPC_SDAREL16:
5610           {
5611             const char *name;
5612             const struct elf_link_hash_entry *sh;
5613
5614             BFD_ASSERT (sec != NULL);
5615             name = bfd_get_section_name (abfd, sec->output_section);
5616             if (! ((strncmp (name, ".sdata", 6) == 0
5617                     && (name[6] == 0 || name[6] == '.'))
5618                    || (strncmp (name, ".sbss", 5) == 0
5619                        && (name[5] == 0 || name[5] == '.'))))
5620               {
5621                 (*_bfd_error_handler)
5622                   (_("%s: the target (%s) of a %s relocation is "
5623                      "in the wrong output section (%s)"),
5624                    bfd_archive_filename (input_bfd),
5625                    sym_name,
5626                    howto->name,
5627                    name);
5628               }
5629             sh = htab->sdata->sym_hash;
5630             addend -= (sh->root.u.def.value
5631                        + sh->root.u.def.section->output_section->vma
5632                        + sh->root.u.def.section->output_offset);
5633           }
5634           break;
5635
5636           /* Relocate against _SDA2_BASE_.  */
5637         case R_PPC_EMB_SDA2REL:
5638           {
5639             const char *name;
5640             const struct elf_link_hash_entry *sh;
5641
5642             BFD_ASSERT (sec != NULL);
5643             name = bfd_get_section_name (abfd, sec->output_section);
5644             if (! (strncmp (name, ".sdata2", 7) == 0
5645                    || strncmp (name, ".sbss2", 6) == 0))
5646               {
5647                 (*_bfd_error_handler)
5648                   (_("%s: the target (%s) of a %s relocation is "
5649                      "in the wrong output section (%s)"),
5650                    bfd_archive_filename (input_bfd),
5651                    sym_name,
5652                    howto->name,
5653                    name);
5654
5655                 bfd_set_error (bfd_error_bad_value);
5656                 ret = FALSE;
5657                 continue;
5658               }
5659             sh = htab->sdata2->sym_hash;
5660             addend -= (sh->root.u.def.value
5661                        + sh->root.u.def.section->output_section->vma
5662                        + sh->root.u.def.section->output_offset);
5663           }
5664           break;
5665
5666           /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0.  */
5667         case R_PPC_EMB_SDA21:
5668         case R_PPC_EMB_RELSDA:
5669           {
5670             const char *name;
5671             const struct elf_link_hash_entry *sh;
5672             int reg;
5673
5674             BFD_ASSERT (sec != NULL);
5675             name = bfd_get_section_name (abfd, sec->output_section);
5676             if (((strncmp (name, ".sdata", 6) == 0
5677                   && (name[6] == 0 || name[6] == '.'))
5678                  || (strncmp (name, ".sbss", 5) == 0
5679                      && (name[5] == 0 || name[5] == '.'))))
5680               {
5681                 reg = 13;
5682                 sh = htab->sdata->sym_hash;
5683                 addend -= (sh->root.u.def.value
5684                            + sh->root.u.def.section->output_section->vma
5685                            + sh->root.u.def.section->output_offset);
5686               }
5687
5688             else if (strncmp (name, ".sdata2", 7) == 0
5689                      || strncmp (name, ".sbss2", 6) == 0)
5690               {
5691                 reg = 2;
5692                 sh = htab->sdata2->sym_hash;
5693                 addend -= (sh->root.u.def.value
5694                            + sh->root.u.def.section->output_section->vma
5695                            + sh->root.u.def.section->output_offset);
5696               }
5697
5698             else if (strcmp (name, ".PPC.EMB.sdata0") == 0
5699                      || strcmp (name, ".PPC.EMB.sbss0") == 0)
5700               {
5701                 reg = 0;
5702               }
5703
5704             else
5705               {
5706                 (*_bfd_error_handler)
5707                   (_("%s: the target (%s) of a %s relocation is "
5708                      "in the wrong output section (%s)"),
5709                    bfd_archive_filename (input_bfd),
5710                    sym_name,
5711                    howto->name,
5712                    name);
5713
5714                 bfd_set_error (bfd_error_bad_value);
5715                 ret = FALSE;
5716                 continue;
5717               }
5718
5719             if (r_type == R_PPC_EMB_SDA21)
5720               {                 /* fill in register field */
5721                 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
5722                 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
5723                 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5724               }
5725           }
5726           break;
5727
5728           /* Relocate against the beginning of the section.  */
5729         case R_PPC_SECTOFF:
5730         case R_PPC_SECTOFF_LO:
5731         case R_PPC_SECTOFF_HI:
5732         case R_PPC_SECTOFF_HA:
5733           BFD_ASSERT (sec != NULL);
5734           addend -= sec->output_section->vma;
5735           break;
5736
5737           /* Negative relocations.  */
5738         case R_PPC_EMB_NADDR32:
5739         case R_PPC_EMB_NADDR16:
5740         case R_PPC_EMB_NADDR16_LO:
5741         case R_PPC_EMB_NADDR16_HI:
5742         case R_PPC_EMB_NADDR16_HA:
5743           addend -= 2 * relocation;
5744           break;
5745
5746         case R_PPC_COPY:
5747         case R_PPC_GLOB_DAT:
5748         case R_PPC_JMP_SLOT:
5749         case R_PPC_RELATIVE:
5750         case R_PPC_PLT32:
5751         case R_PPC_PLTREL32:
5752         case R_PPC_PLT16_LO:
5753         case R_PPC_PLT16_HI:
5754         case R_PPC_PLT16_HA:
5755         case R_PPC_ADDR30:
5756         case R_PPC_EMB_RELSEC16:
5757         case R_PPC_EMB_RELST_LO:
5758         case R_PPC_EMB_RELST_HI:
5759         case R_PPC_EMB_RELST_HA:
5760         case R_PPC_EMB_BIT_FLD:
5761           (*_bfd_error_handler)
5762             (_("%s: relocation %s is not yet supported for symbol %s."),
5763              bfd_archive_filename (input_bfd),
5764              howto->name,
5765              sym_name);
5766
5767           bfd_set_error (bfd_error_invalid_operation);
5768           ret = FALSE;
5769           continue;
5770         }
5771
5772       /* Do any further special processing.  */
5773       switch (r_type)
5774         {
5775         default:
5776           break;
5777
5778         case R_PPC_ADDR16_HA:
5779         case R_PPC_GOT16_HA:
5780         case R_PPC_PLT16_HA:
5781         case R_PPC_SECTOFF_HA:
5782         case R_PPC_TPREL16_HA:
5783         case R_PPC_DTPREL16_HA:
5784         case R_PPC_GOT_TLSGD16_HA:
5785         case R_PPC_GOT_TLSLD16_HA:
5786         case R_PPC_GOT_TPREL16_HA:
5787         case R_PPC_GOT_DTPREL16_HA:
5788         case R_PPC_EMB_NADDR16_HA:
5789         case R_PPC_EMB_RELST_HA:
5790           /* It's just possible that this symbol is a weak symbol
5791              that's not actually defined anywhere.  In that case,
5792              'sec' would be NULL, and we should leave the symbol
5793              alone (it will be set to zero elsewhere in the link).  */
5794           if (sec != NULL)
5795             /* Add 0x10000 if sign bit in 0:15 is set.
5796                Bits 0:15 are not used.  */
5797             addend += 0x8000;
5798           break;
5799         }
5800
5801 #ifdef DEBUG
5802       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, "
5803                "offset = %ld, addend = %ld\n",
5804                howto->name,
5805                (int) r_type,
5806                sym_name,
5807                r_symndx,
5808                (long) rel->r_offset,
5809                (long) addend);
5810 #endif
5811
5812       if (unresolved_reloc
5813           && !((input_section->flags & SEC_DEBUGGING) != 0
5814                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
5815         {
5816           (*_bfd_error_handler)
5817             (_("%s(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
5818              bfd_archive_filename (input_bfd),
5819              bfd_get_section_name (input_bfd, input_section),
5820              (long) rel->r_offset,
5821              howto->name,
5822              sym_name);
5823           ret = FALSE;
5824         }
5825
5826       r = _bfd_final_link_relocate (howto,
5827                                     input_bfd,
5828                                     input_section,
5829                                     contents,
5830                                     rel->r_offset,
5831                                     relocation,
5832                                     addend);
5833
5834       if (r != bfd_reloc_ok)
5835         {
5836           if (sym_name == NULL)
5837             sym_name = "(null)";
5838           if (r == bfd_reloc_overflow)
5839             {
5840               if (warned)
5841                 continue;
5842               if (h != NULL
5843                   && h->root.type == bfd_link_hash_undefweak
5844                   && howto->pc_relative)
5845                 {
5846                   /* Assume this is a call protected by other code that
5847                      detect the symbol is undefined.  If this is the case,
5848                      we can safely ignore the overflow.  If not, the
5849                      program is hosed anyway, and a little warning isn't
5850                      going to help.  */
5851
5852                   continue;
5853                 }
5854
5855               if (! (*info->callbacks->reloc_overflow) (info,
5856                                                         sym_name,
5857                                                         howto->name,
5858                                                         rel->r_addend,
5859                                                         input_bfd,
5860                                                         input_section,
5861                                                         rel->r_offset))
5862                 return FALSE;
5863             }
5864           else
5865             {
5866               (*_bfd_error_handler)
5867                 (_("%s(%s+0x%lx): %s reloc against `%s': error %d"),
5868                  bfd_archive_filename (input_bfd),
5869                  bfd_get_section_name (input_bfd, input_section),
5870                  (long) rel->r_offset, howto->name, sym_name, (int) r);
5871               ret = FALSE;
5872             }
5873         }
5874     }
5875
5876 #ifdef DEBUG
5877   fprintf (stderr, "\n");
5878 #endif
5879
5880   return ret;
5881 }
5882
5883 static enum elf_reloc_type_class
5884 ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela)
5885 {
5886   switch (ELF32_R_TYPE (rela->r_info))
5887     {
5888     case R_PPC_RELATIVE:
5889       return reloc_class_relative;
5890     case R_PPC_REL24:
5891     case R_PPC_ADDR24:
5892     case R_PPC_JMP_SLOT:
5893       return reloc_class_plt;
5894     case R_PPC_COPY:
5895       return reloc_class_copy;
5896     default:
5897       return reloc_class_normal;
5898     }
5899 }
5900 \f
5901 /* Support for core dump NOTE sections.  */
5902
5903 static bfd_boolean
5904 ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
5905 {
5906   int offset;
5907   unsigned int raw_size;
5908
5909   switch (note->descsz)
5910     {
5911     default:
5912       return FALSE;
5913
5914     case 268:           /* Linux/PPC.  */
5915       /* pr_cursig */
5916       elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
5917
5918       /* pr_pid */
5919       elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
5920
5921       /* pr_reg */
5922       offset = 72;
5923       raw_size = 192;
5924
5925       break;
5926     }
5927
5928   /* Make a ".reg/999" section.  */
5929   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5930                                           raw_size, note->descpos + offset);
5931 }
5932
5933 static bfd_boolean
5934 ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
5935 {
5936   switch (note->descsz)
5937     {
5938     default:
5939       return FALSE;
5940
5941     case 128:           /* Linux/PPC elf_prpsinfo.  */
5942       elf_tdata (abfd)->core_program
5943         = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
5944       elf_tdata (abfd)->core_command
5945         = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
5946     }
5947
5948   /* Note that for some reason, a spurious space is tacked
5949      onto the end of the args in some (at least one anyway)
5950      implementations, so strip it off if it exists.  */
5951
5952   {
5953     char *command = elf_tdata (abfd)->core_command;
5954     int n = strlen (command);
5955
5956     if (0 < n && command[n - 1] == ' ')
5957       command[n - 1] = '\0';
5958   }
5959
5960   return TRUE;
5961 }
5962 \f
5963 /* Very simple linked list structure for recording apuinfo values.  */
5964 typedef struct apuinfo_list
5965 {
5966   struct apuinfo_list *next;
5967   unsigned long value;
5968 }
5969 apuinfo_list;
5970
5971 static apuinfo_list *head;
5972
5973
5974 static void
5975 apuinfo_list_init (void)
5976 {
5977   head = NULL;
5978 }
5979
5980 static void
5981 apuinfo_list_add (unsigned long value)
5982 {
5983   apuinfo_list *entry = head;
5984
5985   while (entry != NULL)
5986     {
5987       if (entry->value == value)
5988         return;
5989       entry = entry->next;
5990     }
5991
5992   entry = bfd_malloc (sizeof (* entry));
5993   if (entry == NULL)
5994     return;
5995
5996   entry->value = value;
5997   entry->next  = head;
5998   head = entry;
5999 }
6000
6001 static unsigned
6002 apuinfo_list_length (void)
6003 {
6004   apuinfo_list *entry;
6005   unsigned long count;
6006
6007   for (entry = head, count = 0;
6008        entry;
6009        entry = entry->next)
6010     ++ count;
6011
6012   return count;
6013 }
6014
6015 static inline unsigned long
6016 apuinfo_list_element (unsigned long number)
6017 {
6018   apuinfo_list * entry;
6019
6020   for (entry = head;
6021        entry && number --;
6022        entry = entry->next)
6023     ;
6024
6025   return entry ? entry->value : 0;
6026 }
6027
6028 static void
6029 apuinfo_list_finish (void)
6030 {
6031   apuinfo_list *entry;
6032
6033   for (entry = head; entry;)
6034     {
6035       apuinfo_list *next = entry->next;
6036       free (entry);
6037       entry = next;
6038     }
6039
6040   head = NULL;
6041 }
6042
6043 #define APUINFO_SECTION_NAME    ".PPC.EMB.apuinfo"
6044 #define APUINFO_LABEL           "APUinfo"
6045
6046 /* Scan the input BFDs and create a linked list of
6047    the APUinfo values that will need to be emitted.  */
6048
6049 static void
6050 ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info)
6051 {
6052   bfd *ibfd;
6053   asection *asec;
6054   char *buffer;
6055   unsigned num_input_sections;
6056   bfd_size_type output_section_size;
6057   unsigned i;
6058   unsigned num_entries;
6059   unsigned long offset;
6060   unsigned long length;
6061   const char *error_message = NULL;
6062
6063   if (link_info == NULL)
6064     return;
6065
6066   /* Scan the input bfds, looking for apuinfo sections.  */
6067   num_input_sections = 0;
6068   output_section_size = 0;
6069
6070   for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
6071     {
6072       asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
6073       if (asec)
6074         {
6075           ++ num_input_sections;
6076           output_section_size += asec->_raw_size;
6077         }
6078     }
6079
6080   /* We need at least one input sections
6081      in order to make merging worthwhile.  */
6082   if (num_input_sections < 1)
6083     return;
6084
6085   /* Just make sure that the output section exists as well.  */
6086   asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
6087   if (asec == NULL)
6088     return;
6089
6090   /* Allocate a buffer for the contents of the input sections.  */
6091   buffer = bfd_malloc (output_section_size);
6092   if (buffer == NULL)
6093     return;
6094
6095   offset = 0;
6096   apuinfo_list_init ();
6097
6098   /* Read in the input sections contents.  */
6099   for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next)
6100     {
6101       unsigned long datum;
6102       char *ptr;
6103
6104       asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME);
6105       if (asec == NULL)
6106         continue;
6107
6108       length = asec->_raw_size;
6109       if (length < 24)
6110         {
6111           error_message = _("corrupt or empty %s section in %s");
6112           goto fail;
6113         }
6114
6115       if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0
6116           || (bfd_bread (buffer + offset, length, ibfd) != length))
6117         {
6118           error_message = _("unable to read in %s section from %s");
6119           goto fail;
6120         }
6121
6122       /* Process the contents of the section.  */
6123       ptr = buffer + offset;
6124       error_message = _("corrupt %s section in %s");
6125
6126       /* Verify the contents of the header.  Note - we have to
6127          extract the values this way in order to allow for a
6128          host whose endian-ness is different from the target.  */
6129       datum = bfd_get_32 (ibfd, ptr);
6130       if (datum != sizeof APUINFO_LABEL)
6131         goto fail;
6132
6133       datum = bfd_get_32 (ibfd, ptr + 8);
6134       if (datum != 0x2)
6135         goto fail;
6136
6137       if (strcmp (ptr + 12, APUINFO_LABEL) != 0)
6138         goto fail;
6139
6140       /* Get the number of bytes used for apuinfo entries.  */
6141       datum = bfd_get_32 (ibfd, ptr + 4);
6142       if (datum + 20 != length)
6143         goto fail;
6144
6145       /* Make sure that we do not run off the end of the section.  */
6146       if (offset + length > output_section_size)
6147         goto fail;
6148
6149       /* Scan the apuinfo section, building a list of apuinfo numbers.  */
6150       for (i = 0; i < datum; i += 4)
6151         apuinfo_list_add (bfd_get_32 (ibfd, ptr + 20 + i));
6152
6153       /* Update the offset.  */
6154       offset += length;
6155     }
6156
6157   error_message = NULL;
6158
6159   /* Compute the size of the output section.  */
6160   num_entries = apuinfo_list_length ();
6161   output_section_size = 20 + num_entries * 4;
6162
6163   asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
6164
6165   if (! bfd_set_section_size (abfd, asec, output_section_size))
6166     ibfd = abfd,
6167       error_message = _("warning: unable to set size of %s section in %s");
6168
6169  fail:
6170   free (buffer);
6171
6172   if (error_message)
6173     (*_bfd_error_handler) (error_message, APUINFO_SECTION_NAME,
6174                            bfd_archive_filename (ibfd));
6175 }
6176
6177
6178 /* Prevent the output section from accumulating the input sections'
6179    contents.  We have already stored this in our linked list structure.  */
6180
6181 static bfd_boolean
6182 ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED,
6183                        asection *asec,
6184                        bfd_byte *contents ATTRIBUTE_UNUSED)
6185 {
6186   return (apuinfo_list_length ()
6187           && strcmp (asec->name, APUINFO_SECTION_NAME) == 0);
6188 }
6189
6190
6191 /* Finally we can generate the output section.  */
6192
6193 static void
6194 ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
6195 {
6196   bfd_byte *buffer;
6197   asection *asec;
6198   unsigned i;
6199   unsigned num_entries;
6200   bfd_size_type length;
6201
6202   asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME);
6203   if (asec == NULL)
6204     return;
6205
6206   if (apuinfo_list_length () == 0)
6207     return;
6208
6209   length = asec->_raw_size;
6210   if (length < 20)
6211     return;
6212
6213   buffer = bfd_malloc (length);
6214   if (buffer == NULL)
6215     {
6216       (*_bfd_error_handler)
6217         (_("failed to allocate space for new APUinfo section."));
6218       return;
6219     }
6220
6221   /* Create the apuinfo header.  */
6222   num_entries = apuinfo_list_length ();
6223   bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer);
6224   bfd_put_32 (abfd, num_entries * 4, buffer + 4);
6225   bfd_put_32 (abfd, 0x2, buffer + 8);
6226   strcpy (buffer + 12, APUINFO_LABEL);
6227
6228   length = 20;
6229   for (i = 0; i < num_entries; i++)
6230     {
6231       bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length);
6232       length += 4;
6233     }
6234
6235   if (length != asec->_raw_size)
6236     (*_bfd_error_handler) (_("failed to compute new APUinfo section."));
6237
6238   if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length))
6239     (*_bfd_error_handler) (_("failed to install new APUinfo section."));
6240
6241   free (buffer);
6242
6243   apuinfo_list_finish ();
6244 }
6245
6246 /* Add extra PPC sections -- Note, for now, make .sbss2 and
6247    .PPC.EMB.sbss0 a normal section, and not a bss section so
6248    that the linker doesn't crater when trying to make more than
6249    2 sections.  */
6250
6251 static struct bfd_elf_special_section const ppc_elf_special_sections[]=
6252 {
6253   { ".tags",            0,      NULL,   0,
6254     SHT_ORDERED,        SHF_ALLOC },
6255   { ".sdata",           0,      NULL,   0,
6256     SHT_PROGBITS,       SHF_ALLOC + SHF_WRITE },
6257   { ".sbss",            0,      NULL,   0,
6258     SHT_NOBITS,         SHF_ALLOC + SHF_WRITE },
6259   { ".sdata2",          0,      NULL,   0,
6260     SHT_PROGBITS,       SHF_ALLOC },
6261   { ".sbss2",           0,      NULL,   0,
6262     SHT_PROGBITS,       SHF_ALLOC },
6263   { ".PPC.EMB.apuinfo", 0,      NULL,   0,
6264     SHT_NOTE,           0 },
6265   { ".PPC.EMB.sdata0",  0,      NULL,   0,
6266     SHT_PROGBITS,       SHF_ALLOC },
6267   { ".PPC.EMB.sbss0",   0,      NULL,   0,
6268     SHT_PROGBITS,       SHF_ALLOC },
6269   { ".plt",             0,      NULL,   0,
6270     SHT_NOBITS,         0 },
6271   { NULL,               0,      NULL,   0,
6272     0,                  0 }
6273 };
6274 \f
6275 #define TARGET_LITTLE_SYM       bfd_elf32_powerpcle_vec
6276 #define TARGET_LITTLE_NAME      "elf32-powerpcle"
6277 #define TARGET_BIG_SYM          bfd_elf32_powerpc_vec
6278 #define TARGET_BIG_NAME         "elf32-powerpc"
6279 #define ELF_ARCH                bfd_arch_powerpc
6280 #define ELF_MACHINE_CODE        EM_PPC
6281 #ifdef __QNXTARGET__
6282 #define ELF_MAXPAGESIZE         0x1000
6283 #else
6284 #define ELF_MAXPAGESIZE         0x10000
6285 #endif
6286 #define elf_info_to_howto       ppc_elf_info_to_howto
6287
6288 #ifdef  EM_CYGNUS_POWERPC
6289 #define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
6290 #endif
6291
6292 #ifdef EM_PPC_OLD
6293 #define ELF_MACHINE_ALT2        EM_PPC_OLD
6294 #endif
6295
6296 #define elf_backend_plt_not_loaded      1
6297 #define elf_backend_got_symbol_offset   4
6298 #define elf_backend_can_gc_sections     1
6299 #define elf_backend_can_refcount        1
6300 #define elf_backend_got_header_size     12
6301 #define elf_backend_plt_header_size     PLT_INITIAL_ENTRY_SIZE
6302 #define elf_backend_rela_normal         1
6303
6304 #define bfd_elf32_mkobject                      ppc_elf_mkobject
6305 #define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
6306 #define bfd_elf32_bfd_relax_section             ppc_elf_relax_section
6307 #define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
6308 #define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
6309 #define bfd_elf32_bfd_link_hash_table_create    ppc_elf_link_hash_table_create
6310
6311 #define elf_backend_object_p                    ppc_elf_object_p
6312 #define elf_backend_gc_mark_hook                ppc_elf_gc_mark_hook
6313 #define elf_backend_gc_sweep_hook               ppc_elf_gc_sweep_hook
6314 #define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
6315 #define elf_backend_relocate_section            ppc_elf_relocate_section
6316 #define elf_backend_create_dynamic_sections     ppc_elf_create_dynamic_sections
6317 #define elf_backend_check_relocs                ppc_elf_check_relocs
6318 #define elf_backend_copy_indirect_symbol        ppc_elf_copy_indirect_symbol
6319 #define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
6320 #define elf_backend_add_symbol_hook             ppc_elf_add_symbol_hook
6321 #define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
6322 #define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
6323 #define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
6324 #define elf_backend_fake_sections               ppc_elf_fake_sections
6325 #define elf_backend_additional_program_headers  ppc_elf_additional_program_headers
6326 #define elf_backend_modify_segment_map          ppc_elf_modify_segment_map
6327 #define elf_backend_grok_prstatus               ppc_elf_grok_prstatus
6328 #define elf_backend_grok_psinfo                 ppc_elf_grok_psinfo
6329 #define elf_backend_reloc_type_class            ppc_elf_reloc_type_class
6330 #define elf_backend_begin_write_processing      ppc_elf_begin_write_processing
6331 #define elf_backend_final_write_processing      ppc_elf_final_write_processing
6332 #define elf_backend_write_section               ppc_elf_write_section
6333 #define elf_backend_special_sections            ppc_elf_special_sections
6334
6335 #include "elf32-target.h"