bfd/elfxx-x86.c

   1 /* x86 specific support for ELF
   2    Copyright (C) 2017 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "elfxx-x86.h"
  22 #include "elf-vxworks.h"
  23 #include "objalloc.h"
  24 #include "elf/i386.h"
  25 #include "elf/x86-64.h"
  26
  27 /* The name of the dynamic interpreter.  This is put in the .interp
  28    section.  */
  29
  30 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  31 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
  32 #define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
  33
  34 bfd_boolean
  35 _bfd_x86_elf_mkobject (bfd *abfd)
  36 {
  37   return bfd_elf_allocate_object (abfd,
  38                                   sizeof (struct elf_x86_obj_tdata),
  39                                   get_elf_backend_data (abfd)->target_id);
  40 }
  41
  42 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
  43    executables.  Rather than setting it to the beginning of the TLS
  44    section, we have to set it to the end.    This function may be called
  45    multiple times, it is idempotent.  */
  46
  47 void
  48 _bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
  49 {
  50   struct elf_x86_link_hash_table *htab;
  51   struct bfd_link_hash_entry *base;
  52   const struct elf_backend_data *bed;
  53
  54   if (!bfd_link_executable (info))
  55     return;
  56
  57   bed = get_elf_backend_data (info->output_bfd);
  58   htab = elf_x86_hash_table (info, bed->target_id);
  59   if (htab == NULL)
  60     return;
  61
  62   base = htab->tls_module_base;
  63   if (base == NULL)
  64     return;
  65
  66   base->u.def.value = htab->elf.tls_size;
  67 }
  68
  69 /* Return the base VMA address which should be subtracted from real addresses
  70    when resolving @dtpoff relocation.
  71    This is PT_TLS segment p_vaddr.  */
  72
  73 bfd_vma
  74 _bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
  75 {
  76   /* If tls_sec is NULL, we should have signalled an error already.  */
  77   if (elf_hash_table (info)->tls_sec == NULL)
  78     return 0;
  79   return elf_hash_table (info)->tls_sec->vma;
  80 }
  81
  82 /* Find any dynamic relocs that apply to read-only sections.  */
  83
  84 bfd_boolean
  85 _bfd_x86_elf_readonly_dynrelocs (struct elf_link_hash_entry *h,
  86                                  void *inf)
  87 {
  88   struct elf_x86_link_hash_entry *eh;
  89   struct elf_dyn_relocs *p;
  90
  91   /* Skip local IFUNC symbols. */
  92   if (h->forced_local && h->type == STT_GNU_IFUNC)
  93     return TRUE;
  94
  95   eh = (struct elf_x86_link_hash_entry *) h;
  96   for (p = eh->dyn_relocs; p != NULL; p = p->next)
  97     {
  98       asection *s = p->sec->output_section;
  99
 100       if (s != NULL && (s->flags & SEC_READONLY) != 0)
 101         {
 102           struct bfd_link_info *info = (struct bfd_link_info *) inf;
 103
 104           info->flags |= DF_TEXTREL;
 105
 106           if ((info->warn_shared_textrel && bfd_link_pic (info))
 107               || info->error_textrel)
 108             /* xgettext:c-format */
 109             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
 110                                     p->sec->owner, h->root.root.string,
 111                                     p->sec);
 112
 113           /* Not an error, just cut short the traversal.  */
 114           return FALSE;
 115         }
 116     }
 117   return TRUE;
 118 }
 119
 120 /* Find and/or create a hash entry for local symbol.  */
 121
 122 struct elf_link_hash_entry *
 123 _bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
 124                                  bfd *abfd, const Elf_Internal_Rela *rel,
 125                                  bfd_boolean create)
 126 {
 127   struct elf_x86_link_hash_entry e, *ret;
 128   asection *sec = abfd->sections;
 129   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
 130                                        htab->r_sym (rel->r_info));
 131   void **slot;
 132
 133   e.elf.indx = sec->id;
 134   e.elf.dynstr_index = htab->r_sym (rel->r_info);
 135   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
 136                                    create ? INSERT : NO_INSERT);
 137
 138   if (!slot)
 139     return NULL;
 140
 141   if (*slot)
 142     {
 143       ret = (struct elf_x86_link_hash_entry *) *slot;
 144       return &ret->elf;
 145     }
 146
 147   ret = (struct elf_x86_link_hash_entry *)
 148         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
 149                         sizeof (struct elf_x86_link_hash_entry));
 150   if (ret)
 151     {
 152       memset (ret, 0, sizeof (*ret));
 153       ret->elf.indx = sec->id;
 154       ret->elf.dynstr_index = htab->r_sym (rel->r_info);
 155       ret->elf.dynindx = -1;
 156       ret->plt_got.offset = (bfd_vma) -1;
 157       *slot = ret;
 158     }
 159   return &ret->elf;
 160 }
 161
 162 /* Create an entry in a x86 ELF linker hash table.  NB: THIS MUST BE IN
 163    SYNC WITH _bfd_elf_link_hash_newfunc.  */
 164
 165 struct bfd_hash_entry *
 166 _bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 167                                 struct bfd_hash_table *table,
 168                                 const char *string)
 169 {
 170   /* Allocate the structure if it has not already been allocated by a
 171      subclass.  */
 172   if (entry == NULL)
 173     {
 174       entry = (struct bfd_hash_entry *)
 175         bfd_hash_allocate (table,
 176                            sizeof (struct elf_x86_link_hash_entry));
 177       if (entry == NULL)
 178         return entry;
 179     }
 180
 181   /* Call the allocation method of the superclass.  */
 182   entry = _bfd_link_hash_newfunc (entry, table, string);
 183   if (entry != NULL)
 184     {
 185       struct elf_x86_link_hash_entry *eh
 186        = (struct elf_x86_link_hash_entry *) entry;
 187       struct elf_link_hash_table *htab
 188         = (struct elf_link_hash_table *) table;
 189
 190       memset (&eh->elf.size, 0,
 191               (sizeof (struct elf_x86_link_hash_entry)
 192                - offsetof (struct elf_link_hash_entry, size)));
 193       /* Set local fields.  */
 194       eh->elf.indx = -1;
 195       eh->elf.dynindx = -1;
 196       eh->elf.got = htab->init_got_refcount;
 197       eh->elf.plt = htab->init_plt_refcount;
 198       /* Assume that we have been called by a non-ELF symbol reader.
 199          This flag is then reset by the code which reads an ELF input
 200          file.  This ensures that a symbol created by a non-ELF symbol
 201          reader will have the flag set correctly.  */
 202       eh->elf.non_elf = 1;
 203       eh->plt_second.offset = (bfd_vma) -1;
 204       eh->plt_got.offset = (bfd_vma) -1;
 205       eh->tlsdesc_got = (bfd_vma) -1;
 206     }
 207
 208   return entry;
 209 }
 210
 211 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
 212   for local symbol so that we can handle local STT_GNU_IFUNC symbols
 213   as global symbol.  We reuse indx and dynstr_index for local symbol
 214   hash since they aren't used by global symbols in this backend.  */
 215
 216 hashval_t
 217 _bfd_x86_elf_local_htab_hash (const void *ptr)
 218 {
 219   struct elf_link_hash_entry *h
 220     = (struct elf_link_hash_entry *) ptr;
 221   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
 222 }
 223
 224 /* Compare local hash entries.  */
 225
 226 int
 227 _bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
 228 {
 229   struct elf_link_hash_entry *h1
 230      = (struct elf_link_hash_entry *) ptr1;
 231   struct elf_link_hash_entry *h2
 232     = (struct elf_link_hash_entry *) ptr2;
 233
 234   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
 235 }
 236
 237 /* Destroy an x86 ELF linker hash table.  */
 238
 239 static void
 240 elf_x86_link_hash_table_free (bfd *obfd)
 241 {
 242   struct elf_x86_link_hash_table *htab
 243     = (struct elf_x86_link_hash_table *) obfd->link.hash;
 244
 245   if (htab->loc_hash_table)
 246     htab_delete (htab->loc_hash_table);
 247   if (htab->loc_hash_memory)
 248     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
 249   _bfd_elf_link_hash_table_free (obfd);
 250 }
 251
 252 /* Create an x86 ELF linker hash table.  */
 253
 254 struct bfd_link_hash_table *
 255 _bfd_x86_elf_link_hash_table_create (bfd *abfd)
 256 {
 257   struct elf_x86_link_hash_table *ret;
 258   const struct elf_backend_data *bed;
 259   bfd_size_type amt = sizeof (struct elf_x86_link_hash_table);
 260
 261   ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
 262   if (ret == NULL)
 263     return NULL;
 264
 265   bed = get_elf_backend_data (abfd);
 266   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
 267                                       _bfd_x86_elf_link_hash_newfunc,
 268                                       sizeof (struct elf_x86_link_hash_entry),
 269                                       bed->target_id))
 270     {
 271       free (ret);
 272       return NULL;
 273     }
 274
 275 #ifdef BFD64
 276   if (ABI_64_P (abfd))
 277     {
 278       ret->r_info = elf64_r_info;
 279       ret->r_sym = elf64_r_sym;
 280       ret->pointer_r_type = R_X86_64_64;
 281       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
 282       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
 283       ret->tls_get_addr = "__tls_get_addr";
 284     }
 285   else
 286 #endif
 287     {
 288       ret->r_info = elf32_r_info;
 289       ret->r_sym = elf32_r_sym;
 290       if (bed->target_id == X86_64_ELF_DATA)
 291         {
 292           ret->pointer_r_type = R_X86_64_32;
 293           ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
 294           ret->dynamic_interpreter_size
 295             = sizeof ELFX32_DYNAMIC_INTERPRETER;
 296           ret->tls_get_addr = "__tls_get_addr";
 297         }
 298       else
 299         {
 300           ret->pointer_r_type = R_386_32;
 301           ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
 302           ret->dynamic_interpreter_size
 303             = sizeof ELF32_DYNAMIC_INTERPRETER;
 304           ret->tls_get_addr = "___tls_get_addr";
 305         }
 306     }
 307
 308   ret->loc_hash_table = htab_try_create (1024,
 309                                          _bfd_x86_elf_local_htab_hash,
 310                                          _bfd_x86_elf_local_htab_eq,
 311                                          NULL);
 312   ret->loc_hash_memory = objalloc_create ();
 313   if (!ret->loc_hash_table || !ret->loc_hash_memory)
 314     {
 315       elf_x86_link_hash_table_free (abfd);
 316       return NULL;
 317     }
 318   ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
 319
 320   return &ret->elf.root;
 321 }
 322
 323 /* Sort relocs into address order.  */
 324
 325 int
 326 _bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
 327 {
 328   const arelent *a = * (const arelent **) ap;
 329   const arelent *b = * (const arelent **) bp;
 330
 331   if (a->address > b->address)
 332     return 1;
 333   else if (a->address < b->address)
 334     return -1;
 335   else
 336     return 0;
 337 }
 338
 339 bfd_boolean
 340 _bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
 341 {
 342   if (!bfd_link_relocatable (info))
 343     {
 344       /* Check for __tls_get_addr reference.  */
 345       struct elf_x86_link_hash_table *htab;
 346       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 347       htab = elf_x86_hash_table (info, bed->target_id);
 348       if (htab)
 349         {
 350           struct elf_link_hash_entry *h
 351             = elf_link_hash_lookup (elf_hash_table (info),
 352                                     htab->tls_get_addr,
 353                                     FALSE, FALSE, FALSE);
 354           if (h != NULL)
 355             ((struct elf_x86_link_hash_entry *) h)->tls_get_addr = 1;
 356         }
 357     }
 358
 359   /* Invoke the regular ELF backend linker to do all the work.  */
 360   return _bfd_elf_link_check_relocs (abfd, info);
 361 }
 362
 363 bfd_boolean
 364 _bfd_x86_elf_always_size_sections (bfd *output_bfd,
 365                                    struct bfd_link_info *info)
 366 {
 367   asection *tls_sec = elf_hash_table (info)->tls_sec;
 368
 369   if (tls_sec)
 370     {
 371       struct elf_link_hash_entry *tlsbase;
 372
 373       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
 374                                       "_TLS_MODULE_BASE_",
 375                                       FALSE, FALSE, FALSE);
 376
 377       if (tlsbase && tlsbase->type == STT_TLS)
 378         {
 379           struct elf_x86_link_hash_table *htab;
 380           struct bfd_link_hash_entry *bh = NULL;
 381           const struct elf_backend_data *bed
 382             = get_elf_backend_data (output_bfd);
 383
 384           htab = elf_x86_hash_table (info, bed->target_id);
 385           if (htab == NULL)
 386             return FALSE;
 387
 388           if (!(_bfd_generic_link_add_one_symbol
 389                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
 390                  tls_sec, 0, NULL, FALSE,
 391                  bed->collect, &bh)))
 392             return FALSE;
 393
 394           htab->tls_module_base = bh;
 395
 396           tlsbase = (struct elf_link_hash_entry *)bh;
 397           tlsbase->def_regular = 1;
 398           tlsbase->other = STV_HIDDEN;
 399           tlsbase->root.linker_def = 1;
 400           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
 401         }
 402     }
 403
 404   return TRUE;
 405 }
 406
 407 void
 408 _bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
 409                                      const Elf_Internal_Sym *isym,
 410                                      bfd_boolean definition,
 411                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
 412 {
 413   if (definition)
 414     {
 415       struct elf_x86_link_hash_entry *eh
 416         = (struct elf_x86_link_hash_entry *) h;
 417       eh->def_protected = (ELF_ST_VISIBILITY (isym->st_other)
 418                            == STV_PROTECTED);
 419     }
 420 }
 421
 422 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 423
 424 void
 425 _bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
 426                                    struct elf_link_hash_entry *dir,
 427                                    struct elf_link_hash_entry *ind)
 428 {
 429   struct elf_x86_link_hash_entry *edir, *eind;
 430
 431   edir = (struct elf_x86_link_hash_entry *) dir;
 432   eind = (struct elf_x86_link_hash_entry *) ind;
 433
 434   if (eind->dyn_relocs != NULL)
 435     {
 436       if (edir->dyn_relocs != NULL)
 437         {
 438           struct elf_dyn_relocs **pp;
 439           struct elf_dyn_relocs *p;
 440
 441           /* Add reloc counts against the indirect sym to the direct sym
 442              list.  Merge any entries against the same section.  */
 443           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 444             {
 445               struct elf_dyn_relocs *q;
 446
 447               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 448                 if (q->sec == p->sec)
 449                   {
 450                     q->pc_count += p->pc_count;
 451                     q->count += p->count;
 452                     *pp = p->next;
 453                     break;
 454                   }
 455               if (q == NULL)
 456                 pp = &p->next;
 457             }
 458           *pp = edir->dyn_relocs;
 459         }
 460
 461       edir->dyn_relocs = eind->dyn_relocs;
 462       eind->dyn_relocs = NULL;
 463     }
 464
 465   if (ind->root.type == bfd_link_hash_indirect
 466       && dir->got.refcount <= 0)
 467     {
 468       edir->tls_type = eind->tls_type;
 469       eind->tls_type = GOT_UNKNOWN;
 470     }
 471
 472   /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
 473      generate a R_386_COPY reloc.  */
 474   edir->gotoff_ref |= eind->gotoff_ref;
 475
 476   edir->has_got_reloc |= eind->has_got_reloc;
 477   edir->has_non_got_reloc |= eind->has_non_got_reloc;
 478
 479   if (ELIMINATE_COPY_RELOCS
 480       && ind->root.type != bfd_link_hash_indirect
 481       && dir->dynamic_adjusted)
 482     {
 483       /* If called to transfer flags for a weakdef during processing
 484          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 485          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 486       if (dir->versioned != versioned_hidden)
 487         dir->ref_dynamic |= ind->ref_dynamic;
 488       dir->ref_regular |= ind->ref_regular;
 489       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 490       dir->needs_plt |= ind->needs_plt;
 491       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 492     }
 493   else
 494     {
 495       if (eind->func_pointer_refcount > 0)
 496         {
 497           edir->func_pointer_refcount += eind->func_pointer_refcount;
 498           eind->func_pointer_refcount = 0;
 499         }
 500
 501       _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 502     }
 503 }
 504
 505 /* Remove undefined weak symbol from the dynamic symbol table if it
 506    is resolved to 0.   */
 507
 508 bfd_boolean
 509 _bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
 510                            struct elf_link_hash_entry *h)
 511 {
 512   if (h->dynindx != -1)
 513     {
 514       const struct elf_backend_data *bed
 515         = get_elf_backend_data (info->output_bfd);
 516       if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
 517                                            bed->target_id,
 518                                            elf_x86_hash_entry (h)->has_got_reloc,
 519                                            elf_x86_hash_entry (h)))
 520         {
 521           h->dynindx = -1;
 522           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
 523                                   h->dynstr_index);
 524         }
 525     }
 526   return TRUE;
 527 }
 528
 529 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
 530
 531 bfd_boolean
 532 _bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
 533 {
 534   if (h->plt.offset != (bfd_vma) -1
 535       && !h->def_regular
 536       && !h->pointer_equality_needed)
 537     return FALSE;
 538
 539   return _bfd_elf_hash_symbol (h);
 540 }
 541
 542 /* Adjust a symbol defined by a dynamic object and referenced by a
 543    regular object.  The current definition is in some section of the
 544    dynamic object, but we're not including those sections.  We have to
 545    change the definition to something the rest of the link can
 546    understand.  */
 547
 548 bfd_boolean
 549 _bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 550                                     struct elf_link_hash_entry *h)
 551 {
 552   struct elf_x86_link_hash_table *htab;
 553   asection *s, *srel;
 554   struct elf_x86_link_hash_entry *eh;
 555   struct elf_dyn_relocs *p;
 556   const struct elf_backend_data *bed
 557     = get_elf_backend_data (info->output_bfd);
 558
 559   /* STT_GNU_IFUNC symbol must go through PLT. */
 560   if (h->type == STT_GNU_IFUNC)
 561     {
 562       /* All local STT_GNU_IFUNC references must be treate as local
 563          calls via local PLT.  */
 564       if (h->ref_regular
 565           && SYMBOL_CALLS_LOCAL (info, h))
 566         {
 567           bfd_size_type pc_count = 0, count = 0;
 568           struct elf_dyn_relocs **pp;
 569
 570           eh = (struct elf_x86_link_hash_entry *) h;
 571           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
 572             {
 573               pc_count += p->pc_count;
 574               p->count -= p->pc_count;
 575               p->pc_count = 0;
 576               count += p->count;
 577               if (p->count == 0)
 578                 *pp = p->next;
 579               else
 580                 pp = &p->next;
 581             }
 582
 583           if (pc_count || count)
 584             {
 585               h->non_got_ref = 1;
 586               if (pc_count)
 587                 {
 588                   /* Increment PLT reference count only for PC-relative
 589                      references.  */
 590                   h->needs_plt = 1;
 591                   if (h->plt.refcount <= 0)
 592                     h->plt.refcount = 1;
 593                   else
 594                     h->plt.refcount += 1;
 595                 }
 596             }
 597         }
 598
 599       if (h->plt.refcount <= 0)
 600         {
 601           h->plt.offset = (bfd_vma) -1;
 602           h->needs_plt = 0;
 603         }
 604       return TRUE;
 605     }
 606
 607   /* If this is a function, put it in the procedure linkage table.  We
 608      will fill in the contents of the procedure linkage table later,
 609      when we know the address of the .got section.  */
 610   if (h->type == STT_FUNC
 611       || h->needs_plt)
 612     {
 613       if (h->plt.refcount <= 0
 614           || SYMBOL_CALLS_LOCAL (info, h)
 615           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
 616               && h->root.type == bfd_link_hash_undefweak))
 617         {
 618           /* This case can occur if we saw a PLT32 reloc in an input
 619              file, but the symbol was never referred to by a dynamic
 620              object, or if all references were garbage collected.  In
 621              such a case, we don't actually need to build a procedure
 622              linkage table, and we can just do a PC32 reloc instead.  */
 623           h->plt.offset = (bfd_vma) -1;
 624           h->needs_plt = 0;
 625         }
 626
 627       return TRUE;
 628     }
 629   else
 630     /* It's possible that we incorrectly decided a .plt reloc was needed
 631      * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
 632        check_relocs.  We can't decide accurately between function and
 633        non-function syms in check-relocs;  Objects loaded later in
 634        the link may change h->type.  So fix it now.  */
 635     h->plt.offset = (bfd_vma) -1;
 636
 637   eh = (struct elf_x86_link_hash_entry *) h;
 638
 639   /* If this is a weak symbol, and there is a real definition, the
 640      processor independent code will have arranged for us to see the
 641      real definition first, and we can just use the same value.  */
 642   if (h->u.weakdef != NULL)
 643     {
 644       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
 645                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
 646       h->root.u.def.section = h->u.weakdef->root.u.def.section;
 647       h->root.u.def.value = h->u.weakdef->root.u.def.value;
 648       if (ELIMINATE_COPY_RELOCS
 649           || info->nocopyreloc
 650           || SYMBOL_NO_COPYRELOC (info, eh))
 651         {
 652           /* NB: needs_copy is always 0 for i386.  */
 653           h->non_got_ref = h->u.weakdef->non_got_ref;
 654           eh->needs_copy = h->u.weakdef->needs_copy;
 655         }
 656       return TRUE;
 657     }
 658
 659   /* This is a reference to a symbol defined by a dynamic object which
 660      is not a function.  */
 661
 662   /* If we are creating a shared library, we must presume that the
 663      only references to the symbol are via the global offset table.
 664      For such cases we need not do anything here; the relocations will
 665      be handled correctly by relocate_section.  */
 666   if (!bfd_link_executable (info))
 667     return TRUE;
 668
 669   /* If there are no references to this symbol that do not use the
 670      GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
 671      reloc.  NB: gotoff_ref is always 0 for x86-64.  */
 672   if (!h->non_got_ref && !eh->gotoff_ref)
 673     return TRUE;
 674
 675   /* If -z nocopyreloc was given, we won't generate them either.  */
 676   if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
 677     {
 678       h->non_got_ref = 0;
 679       return TRUE;
 680     }
 681
 682   htab = elf_x86_hash_table (info, bed->target_id);
 683   if (htab == NULL)
 684     return FALSE;
 685
 686   /* If there aren't any dynamic relocs in read-only sections nor
 687      R_386_GOTOFF relocation, then we can keep the dynamic relocs and
 688      avoid the copy reloc.  This doesn't work on VxWorks, where we can
 689      not have dynamic relocations (other than copy and jump slot
 690      relocations) in an executable.  */
 691   if (ELIMINATE_COPY_RELOCS
 692       && (bed->target_id == X86_64_ELF_DATA
 693           || (!eh->gotoff_ref
 694               && !htab->is_vxworks)))
 695     {
 696       for (p = eh->dyn_relocs; p != NULL; p = p->next)
 697         {
 698           s = p->sec->output_section;
 699           if (s != NULL && (s->flags & SEC_READONLY) != 0)
 700             break;
 701         }
 702
 703       /* If we didn't find any dynamic relocs in read-only sections,
 704          then we'll be keeping the dynamic relocs and avoiding the copy
 705          reloc.  */
 706       if (p == NULL)
 707         {
 708           h->non_got_ref = 0;
 709           return TRUE;
 710         }
 711     }
 712
 713   /* We must allocate the symbol in our .dynbss section, which will
 714      become part of the .bss section of the executable.  There will be
 715      an entry for this symbol in the .dynsym section.  The dynamic
 716      object will contain position independent code, so all references
 717      from the dynamic object to this symbol will go through the global
 718      offset table.  The dynamic linker will use the .dynsym entry to
 719      determine the address it must put in the global offset table, so
 720      both the dynamic object and the regular object will refer to the
 721      same memory location for the variable.  */
 722
 723   /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
 724      dynamic linker to copy the initial value out of the dynamic object
 725      and into the runtime process image.  */
 726   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
 727     {
 728       s = htab->elf.sdynrelro;
 729       srel = htab->elf.sreldynrelro;
 730     }
 731   else
 732     {
 733       s = htab->elf.sdynbss;
 734       srel = htab->elf.srelbss;
 735     }
 736   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
 737     {
 738       srel->size += ((bed->target_id == I386_ELF_DATA)
 739                      ? sizeof (Elf32_External_Rel)
 740                      : bed->s->sizeof_rela);
 741       h->needs_copy = 1;
 742     }
 743
 744   return _bfd_elf_adjust_dynamic_copy (info, h, s);
 745 }
 746
 747 static bfd_vma
 748 elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
 749                           bfd_vma off,
 750                           bfd_vma offset ATTRIBUTE_UNUSED,
 751                           bfd_vma got_addr)
 752 {
 753   return got_addr + off;
 754 }
 755
 756 static bfd_vma
 757 elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
 758                             bfd_vma off,
 759                             bfd_vma offset,
 760                             bfd_vma got_addr ATTRIBUTE_UNUSED)
 761 {
 762   return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
 763 }
 764
 765 static bfd_boolean
 766 elf_i386_valid_plt_reloc_p (unsigned int type)
 767 {
 768   return (type == R_386_JUMP_SLOT
 769           || type == R_386_GLOB_DAT
 770           || type == R_386_IRELATIVE);
 771 }
 772
 773 static bfd_boolean
 774 elf_x86_64_valid_plt_reloc_p (unsigned int type)
 775 {
 776   return (type == R_X86_64_JUMP_SLOT
 777           || type == R_X86_64_GLOB_DAT
 778           || type == R_X86_64_IRELATIVE);
 779 }
 780
 781 long
 782 _bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
 783                                    long count,
 784                                    long relsize,
 785                                    bfd_vma got_addr,
 786                                    struct elf_x86_plt plts[],
 787                                    asymbol **dynsyms,
 788                                    asymbol **ret)
 789 {
 790   long size, i, n, len;
 791   int j;
 792   unsigned int plt_got_offset, plt_entry_size;
 793   asymbol *s;
 794   bfd_byte *plt_contents;
 795   long dynrelcount;
 796   arelent **dynrelbuf, *p;
 797   char *names;
 798   const struct elf_backend_data *bed;
 799   bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
 800                               bfd_vma);
 801   bfd_boolean (*valid_plt_reloc_p) (unsigned int);
 802
 803   if (count == 0)
 804     return -1;
 805
 806   dynrelbuf = (arelent **) bfd_malloc (relsize);
 807   if (dynrelbuf == NULL)
 808     return -1;
 809
 810   dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
 811                                                 dynsyms);
 812
 813   /* Sort the relocs by address.  */
 814   qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
 815          _bfd_x86_elf_compare_relocs);
 816
 817   size = count * sizeof (asymbol);
 818
 819   /* Allocate space for @plt suffixes.  */
 820   n = 0;
 821   for (i = 0; i < dynrelcount; i++)
 822     {
 823       p = dynrelbuf[i];
 824       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
 825       if (p->addend != 0)
 826         size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
 827     }
 828
 829   s = *ret = (asymbol *) bfd_zmalloc (size);
 830   if (s == NULL)
 831     goto bad_return;
 832
 833   bed = get_elf_backend_data (abfd);
 834
 835   if (bed->target_id == X86_64_ELF_DATA)
 836     {
 837       get_plt_got_vma = elf_x86_64_get_plt_got_vma;
 838       valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
 839     }
 840   else
 841     {
 842       get_plt_got_vma = elf_i386_get_plt_got_vma;
 843       valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
 844       if (got_addr)
 845         {
 846           /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
 847              address.  */
 848           asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
 849           if (sec != NULL)
 850             got_addr = sec->vma;
 851           else
 852             {
 853               sec = bfd_get_section_by_name (abfd, ".got");
 854               if (sec != NULL)
 855                 got_addr = sec->vma;
 856             }
 857
 858           if (got_addr == (bfd_vma) -1)
 859             goto bad_return;
 860         }
 861     }
 862
 863   /* Check for each PLT section.  */
 864   names = (char *) (s + count);
 865   size = 0;
 866   n = 0;
 867   for (j = 0; plts[j].name != NULL; j++)
 868     if ((plt_contents = plts[j].contents) != NULL)
 869       {
 870         long k;
 871         bfd_vma offset;
 872         asection *plt;
 873         struct elf_x86_plt *plt_p = &plts[j];
 874
 875         plt_got_offset = plt_p->plt_got_offset;
 876         plt_entry_size = plt_p->plt_entry_size;
 877
 878         plt = plt_p->sec;
 879
 880         if ((plt_p->type & plt_lazy))
 881           {
 882             /* Skip PLT0 in lazy PLT.  */
 883             k = 1;
 884             offset = plt_entry_size;
 885           }
 886         else
 887           {
 888             k = 0;
 889             offset = 0;
 890           }
 891
 892         /* Check each PLT entry against dynamic relocations.  */
 893         for (; k < plt_p->count; k++)
 894           {
 895             int off;
 896             bfd_vma got_vma;
 897             long min, max, mid;
 898
 899             /* Get the GOT offset for i386 or the PC-relative offset
 900                for x86-64, a signed 32-bit integer.  */
 901             off = H_GET_32 (abfd, (plt_contents + offset
 902                                    + plt_got_offset));
 903             got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
 904
 905             /* Binary search.  */
 906             p = dynrelbuf[0];
 907             min = 0;
 908             max = dynrelcount;
 909             while ((min + 1) < max)
 910               {
 911                 arelent *r;
 912
 913                 mid = (min + max) / 2;
 914                 r = dynrelbuf[mid];
 915                 if (got_vma > r->address)
 916                   min = mid;
 917                 else if (got_vma < r->address)
 918                   max = mid;
 919                 else
 920                   {
 921                     p = r;
 922                     break;
 923                   }
 924               }
 925
 926             /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
 927             if (got_vma == p->address
 928                 && p->howto != NULL
 929                 && valid_plt_reloc_p (p->howto->type))
 930               {
 931                 *s = **p->sym_ptr_ptr;
 932                 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
 933                    set.  Since we are defining a symbol, ensure one
 934                    of them is set.  */
 935                 if ((s->flags & BSF_LOCAL) == 0)
 936                   s->flags |= BSF_GLOBAL;
 937                 s->flags |= BSF_SYNTHETIC;
 938                 /* This is no longer a section symbol.  */
 939                 s->flags &= ~BSF_SECTION_SYM;
 940                 s->section = plt;
 941                 s->the_bfd = plt->owner;
 942                 s->value = offset;
 943                 s->udata.p = NULL;
 944                 s->name = names;
 945                 len = strlen ((*p->sym_ptr_ptr)->name);
 946                 memcpy (names, (*p->sym_ptr_ptr)->name, len);
 947                 names += len;
 948                 if (p->addend != 0)
 949                   {
 950                     char buf[30], *a;
 951
 952                     memcpy (names, "+0x", sizeof ("+0x") - 1);
 953                     names += sizeof ("+0x") - 1;
 954                     bfd_sprintf_vma (abfd, buf, p->addend);
 955                     for (a = buf; *a == '0'; ++a)
 956                       ;
 957                     size = strlen (a);
 958                     memcpy (names, a, size);
 959                     names += size;
 960                   }
 961                 memcpy (names, "@plt", sizeof ("@plt"));
 962                 names += sizeof ("@plt");
 963                 n++;
 964                 s++;
 965               }
 966             offset += plt_entry_size;
 967           }
 968       }
 969
 970   /* PLT entries with R_386_TLS_DESC relocations are skipped.  */
 971   if (n == 0)
 972     {
 973 bad_return:
 974       count = -1;
 975     }
 976   else
 977     count = n;
 978
 979   for (j = 0; plts[j].name != NULL; j++)
 980     if (plts[j].contents != NULL)
 981       free (plts[j].contents);
 982
 983   free (dynrelbuf);
 984
 985   return count;
 986 }
 987
 988 /* Parse x86 GNU properties.  */
 989
 990 enum elf_property_kind
 991 _bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
 992                                    bfd_byte *ptr, unsigned int datasz)
 993 {
 994   elf_property *prop;
 995
 996   switch (type)
 997     {
 998     case GNU_PROPERTY_X86_ISA_1_USED:
 999     case GNU_PROPERTY_X86_ISA_1_NEEDED:
1000     case GNU_PROPERTY_X86_FEATURE_1_AND:
1001       if (datasz != 4)
1002         {
1003           _bfd_error_handler
1004             ((type == GNU_PROPERTY_X86_ISA_1_USED
1005               ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
1006               : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
1007                  ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
1008                  : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
1009              abfd, datasz);
1010           return property_corrupt;
1011         }
1012       prop = _bfd_elf_get_property (abfd, type, datasz);
1013       /* Combine properties of the same type.  */
1014       prop->u.number |= bfd_h_get_32 (abfd, ptr);
1015       prop->pr_kind = property_number;
1016       break;
1017
1018     default:
1019       return property_ignored;
1020     }
1021
1022   return property_number;
1023 }
1024
1025 /* Merge x86 GNU property BPROP with APROP.  If APROP isn't NULL,
1026    return TRUE if APROP is updated.  Otherwise, return TRUE if BPROP
1027    should be merged with ABFD.  */
1028
1029 bfd_boolean
1030 _bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
1031                                    bfd *abfd ATTRIBUTE_UNUSED,
1032                                    elf_property *aprop,
1033                                    elf_property *bprop)
1034 {
1035   unsigned int number, features;
1036   bfd_boolean updated = FALSE;
1037   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
1038
1039   switch (pr_type)
1040     {
1041     case GNU_PROPERTY_X86_ISA_1_USED:
1042     case GNU_PROPERTY_X86_ISA_1_NEEDED:
1043       if (aprop != NULL && bprop != NULL)
1044         {
1045           number = aprop->u.number;
1046           aprop->u.number = number | bprop->u.number;
1047           updated = number != (unsigned int) aprop->u.number;
1048         }
1049       else
1050         {
1051           /* Return TRUE if APROP is NULL to indicate that BPROP should
1052              be added to ABFD.  */
1053           updated = aprop == NULL;
1054         }
1055       break;
1056
1057     case GNU_PROPERTY_X86_FEATURE_1_AND:
1058       /* Only one of APROP and BPROP can be NULL:
1059          1. APROP & BPROP when both APROP and BPROP aren't NULL.
1060          2. If APROP is NULL, remove x86 feature.
1061          3. Otherwise, do nothing.
1062        */
1063       if (aprop != NULL && bprop != NULL)
1064         {
1065           features = 0;
1066           if (info->ibt)
1067             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1068           if (info->shstk)
1069             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1070           number = aprop->u.number;
1071           /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1072              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
1073           aprop->u.number = (number & bprop->u.number) | features;
1074           updated = number != (unsigned int) aprop->u.number;
1075           /* Remove the property if all feature bits are cleared.  */
1076           if (aprop->u.number == 0)
1077             aprop->pr_kind = property_remove;
1078         }
1079       else
1080         {
1081           features = 0;
1082           if (info->ibt)
1083             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1084           if (info->shstk)
1085             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1086           if (features)
1087             {
1088               /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
1089                  GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
1090               if (aprop != NULL)
1091                 {
1092                   number = aprop->u.number;
1093                   aprop->u.number = number | features;
1094                   updated = number != (unsigned int) aprop->u.number;
1095                 }
1096               else
1097                 {
1098                   bprop->u.number |= features;
1099                   updated = TRUE;
1100                 }
1101             }
1102           else if (aprop != NULL)
1103             {
1104               aprop->pr_kind = property_remove;
1105               updated = TRUE;
1106             }
1107         }
1108       break;
1109
1110     default:
1111       /* Never should happen.  */
1112       abort ();
1113     }
1114
1115   return updated;
1116 }
1117
1118 /* Set up x86 GNU properties.  Return the first relocatable ELF input
1119    with GNU properties if found.  Otherwise, return NULL.  */
1120
1121 bfd *
1122 _bfd_x86_elf_link_setup_gnu_properties
1123   (struct bfd_link_info *info,
1124    struct elf_x86_plt_layout_table *plt_layout)
1125 {
1126   bfd_boolean normal_target;
1127   bfd_boolean lazy_plt;
1128   asection *sec, *pltsec;
1129   bfd *dynobj;
1130   bfd_boolean use_ibt_plt;
1131   unsigned int plt_alignment, features;
1132   struct elf_x86_link_hash_table *htab;
1133   bfd *pbfd;
1134   bfd *ebfd = NULL;
1135   elf_property *prop;
1136   const struct elf_backend_data *bed;
1137   unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
1138   unsigned int got_align;
1139
1140   features = 0;
1141   if (info->ibt)
1142     features = GNU_PROPERTY_X86_FEATURE_1_IBT;
1143   if (info->shstk)
1144     features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
1145
1146   /* Find a normal input file with GNU property note.  */
1147   for (pbfd = info->input_bfds;
1148        pbfd != NULL;
1149        pbfd = pbfd->link.next)
1150     if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
1151         && bfd_count_sections (pbfd) != 0)
1152       {
1153         ebfd = pbfd;
1154
1155         if (elf_properties (pbfd) != NULL)
1156           break;
1157       }
1158
1159   if (ebfd != NULL && features)
1160     {
1161       /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
1162          GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
1163       prop = _bfd_elf_get_property (ebfd,
1164                                     GNU_PROPERTY_X86_FEATURE_1_AND,
1165                                     4);
1166       prop->u.number |= features;
1167       prop->pr_kind = property_number;
1168
1169       /* Create the GNU property note section if needed.  */
1170       if (pbfd == NULL)
1171         {
1172           sec = bfd_make_section_with_flags (ebfd,
1173                                              NOTE_GNU_PROPERTY_SECTION_NAME,
1174                                              (SEC_ALLOC
1175                                               | SEC_LOAD
1176                                               | SEC_IN_MEMORY
1177                                               | SEC_READONLY
1178                                               | SEC_HAS_CONTENTS
1179                                               | SEC_DATA));
1180           if (sec == NULL)
1181             info->callbacks->einfo (_("%F: failed to create GNU property section\n"));
1182
1183           if (!bfd_set_section_alignment (ebfd, sec, class_align))
1184             {
1185 error_alignment:
1186               info->callbacks->einfo (_("%F%A: failed to align section\n"),
1187                                       sec);
1188             }
1189
1190           elf_section_type (sec) = SHT_NOTE;
1191         }
1192     }
1193
1194   pbfd = _bfd_elf_link_setup_gnu_properties (info);
1195
1196   if (bfd_link_relocatable (info))
1197     return pbfd;
1198
1199   bed = get_elf_backend_data (info->output_bfd);
1200
1201   htab = elf_x86_hash_table (info, bed->target_id);
1202   if (htab == NULL)
1203     return pbfd;
1204
1205   htab->is_vxworks = plt_layout->is_vxworks;
1206
1207   use_ibt_plt = info->ibtplt || info->ibt;
1208   if (!use_ibt_plt && pbfd != NULL)
1209     {
1210       /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on.  */
1211       elf_property_list *p;
1212
1213       /* The property list is sorted in order of type.  */
1214       for (p = elf_properties (pbfd); p; p = p->next)
1215         {
1216           if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
1217             {
1218               use_ibt_plt = !!(p->property.u.number
1219                                & GNU_PROPERTY_X86_FEATURE_1_IBT);
1220               break;
1221             }
1222           else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
1223             break;
1224         }
1225     }
1226
1227   dynobj = htab->elf.dynobj;
1228
1229   /* Set htab->elf.dynobj here so that there is no need to check and
1230      set it in check_relocs.  */
1231   if (dynobj == NULL)
1232     {
1233       if (pbfd != NULL)
1234         {
1235           htab->elf.dynobj = pbfd;
1236           dynobj = pbfd;
1237         }
1238       else
1239         {
1240           bfd *abfd;
1241
1242           /* Find a normal input file to hold linker created
1243              sections.  */
1244           for (abfd = info->input_bfds;
1245                abfd != NULL;
1246                abfd = abfd->link.next)
1247             if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1248                 && (abfd->flags
1249                     & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
1250               {
1251                 htab->elf.dynobj = abfd;
1252                 dynobj = abfd;
1253                 break;
1254               }
1255         }
1256     }
1257
1258   /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
1259      still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
1260      canonical function address.  */
1261   htab->plt.has_plt0 = 1;
1262   normal_target = plt_layout->normal_target;
1263
1264   if (normal_target)
1265     {
1266       if (use_ibt_plt)
1267         {
1268           htab->lazy_plt = plt_layout->lazy_ibt_plt;
1269           htab->non_lazy_plt = plt_layout->non_lazy_ibt_plt;
1270         }
1271       else
1272         {
1273           htab->lazy_plt = plt_layout->lazy_plt;
1274           htab->non_lazy_plt = plt_layout->non_lazy_plt;
1275         }
1276     }
1277   else
1278     {
1279       htab->lazy_plt = plt_layout->lazy_plt;
1280       htab->non_lazy_plt = NULL;
1281     }
1282
1283   pltsec = htab->elf.splt;
1284
1285   /* If the non-lazy PLT is available, use it for all PLT entries if
1286      there are no PLT0 or no .plt section.  */
1287   if (htab->non_lazy_plt != NULL
1288       && (!htab->plt.has_plt0 || pltsec == NULL))
1289     {
1290       lazy_plt = FALSE;
1291       if (bfd_link_pic (info))
1292         htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
1293       else
1294         htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
1295       htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
1296       htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
1297       htab->plt.plt_got_insn_size
1298         = htab->non_lazy_plt->plt_got_insn_size;
1299       htab->plt.eh_frame_plt_size
1300         = htab->non_lazy_plt->eh_frame_plt_size;
1301       htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
1302     }
1303   else
1304     {
1305       lazy_plt = TRUE;
1306       if (bfd_link_pic (info))
1307         {
1308           htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
1309           htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
1310         }
1311       else
1312         {
1313           htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
1314           htab->plt.plt_entry = htab->lazy_plt->plt_entry;
1315         }
1316       htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
1317       htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
1318       htab->plt.plt_got_insn_size
1319         = htab->lazy_plt->plt_got_insn_size;
1320       htab->plt.eh_frame_plt_size
1321         = htab->lazy_plt->eh_frame_plt_size;
1322       htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
1323     }
1324
1325   /* Return if there are no normal input files.  */
1326   if (dynobj == NULL)
1327     return pbfd;
1328
1329   if (htab->is_vxworks
1330       && !elf_vxworks_create_dynamic_sections (dynobj, info,
1331                                                &htab->srelplt2))
1332     {
1333       info->callbacks->einfo (_("%F: failed to create VxWorks dynamic sections\n"));
1334       return pbfd;
1335     }
1336
1337   /* Since create_dynamic_sections isn't always called, but GOT
1338      relocations need GOT relocations, create them here so that we
1339      don't need to do it in check_relocs.  */
1340   if (htab->elf.sgot == NULL
1341       && !_bfd_elf_create_got_section (dynobj, info))
1342     info->callbacks->einfo (_("%F: failed to create GOT sections\n"));
1343
1344   got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
1345
1346   /* Align .got and .got.plt sections to their entry size.  Do it here
1347      instead of in create_dynamic_sections so that they are always
1348      properly aligned even if create_dynamic_sections isn't called.  */
1349   sec = htab->elf.sgot;
1350   if (!bfd_set_section_alignment (dynobj, sec, got_align))
1351     goto error_alignment;
1352
1353   sec = htab->elf.sgotplt;
1354   if (!bfd_set_section_alignment (dynobj, sec, got_align))
1355     goto error_alignment;
1356
1357   /* Create the ifunc sections here so that check_relocs can be
1358      simplified.  */
1359   if (!_bfd_elf_create_ifunc_sections (dynobj, info))
1360     info->callbacks->einfo (_("%F: failed to create ifunc sections\n"));
1361
1362   plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
1363
1364   if (pltsec != NULL)
1365     {
1366       /* Whe creating executable, set the contents of the .interp
1367          section to the interpreter.  */
1368       if (bfd_link_executable (info) && !info->nointerp)
1369         {
1370           asection *s = bfd_get_linker_section (dynobj, ".interp");
1371           if (s == NULL)
1372             abort ();
1373           s->size = htab->dynamic_interpreter_size;
1374           s->contents = (unsigned char *) htab->dynamic_interpreter;
1375           htab->interp = s;
1376         }
1377
1378       /* Don't change PLT section alignment for NaCl since it uses
1379          64-byte PLT entry and sets PLT section alignment to 32
1380          bytes.  Don't create additional PLT sections for NaCl.  */
1381       if (normal_target)
1382         {
1383           flagword pltflags = (bed->dynamic_sec_flags
1384                                | SEC_ALLOC
1385                                | SEC_CODE
1386                                | SEC_LOAD
1387                                | SEC_READONLY);
1388           unsigned int non_lazy_plt_alignment
1389             = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
1390
1391           sec = pltsec;
1392           if (!bfd_set_section_alignment (sec->owner, sec,
1393                                           plt_alignment))
1394             goto error_alignment;
1395
1396           /* Create the GOT procedure linkage table.  */
1397           sec = bfd_make_section_anyway_with_flags (dynobj,
1398                                                     ".plt.got",
1399                                                     pltflags);
1400           if (sec == NULL)
1401             info->callbacks->einfo (_("%F: failed to create GOT PLT section\n"));
1402
1403           if (!bfd_set_section_alignment (dynobj, sec,
1404                                           non_lazy_plt_alignment))
1405             goto error_alignment;
1406
1407           htab->plt_got = sec;
1408
1409           if (lazy_plt)
1410             {
1411               sec = NULL;
1412
1413               if (use_ibt_plt)
1414                 {
1415                   /* Create the second PLT for Intel IBT support.  IBT
1416                      PLT is supported only for non-NaCl target and is
1417                      is needed only for lazy binding.  */
1418                   sec = bfd_make_section_anyway_with_flags (dynobj,
1419                                                             ".plt.sec",
1420                                                             pltflags);
1421                   if (sec == NULL)
1422                     info->callbacks->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
1423
1424                   if (!bfd_set_section_alignment (dynobj, sec,
1425                                                   plt_alignment))
1426                     goto error_alignment;
1427                 }
1428               else if (info->bndplt && ABI_64_P (dynobj))
1429                 {
1430                   /* Create the second PLT for Intel MPX support.  MPX
1431                      PLT is supported only for non-NaCl target in 64-bit
1432                      mode and is needed only for lazy binding.  */
1433                   sec = bfd_make_section_anyway_with_flags (dynobj,
1434                                                             ".plt.sec",
1435                                                             pltflags);
1436                   if (sec == NULL)
1437                     info->callbacks->einfo (_("%F: failed to create BND PLT section\n"));
1438
1439                   if (!bfd_set_section_alignment (dynobj, sec,
1440                                                   non_lazy_plt_alignment))
1441                     goto error_alignment;
1442                 }
1443
1444               htab->plt_second = sec;
1445             }
1446         }
1447
1448       if (!info->no_ld_generated_unwind_info)
1449         {
1450           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1451                             | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1452                             | SEC_LINKER_CREATED);
1453
1454           sec = bfd_make_section_anyway_with_flags (dynobj,
1455                                                     ".eh_frame",
1456                                                     flags);
1457           if (sec == NULL)
1458             info->callbacks->einfo (_("%F: failed to create PLT .eh_frame section\n"));
1459
1460           if (!bfd_set_section_alignment (dynobj, sec, class_align))
1461             goto error_alignment;
1462
1463           htab->plt_eh_frame = sec;
1464
1465           if (htab->plt_got != NULL)
1466             {
1467               sec = bfd_make_section_anyway_with_flags (dynobj,
1468                                                         ".eh_frame",
1469                                                         flags);
1470               if (sec == NULL)
1471                 info->callbacks->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
1472
1473               if (!bfd_set_section_alignment (dynobj, sec, class_align))
1474                 goto error_alignment;
1475
1476               htab->plt_got_eh_frame = sec;
1477             }
1478
1479           if (htab->plt_second != NULL)
1480             {
1481               sec = bfd_make_section_anyway_with_flags (dynobj,
1482                                                         ".eh_frame",
1483                                                         flags);
1484               if (sec == NULL)
1485                 info->callbacks->einfo (_("%F: failed to create the second PLT .eh_frame section\n"));
1486
1487               if (!bfd_set_section_alignment (dynobj, sec, class_align))
1488                 goto error_alignment;
1489
1490               htab->plt_second_eh_frame = sec;
1491             }
1492         }
1493     }
1494
1495   if (normal_target)
1496     {
1497       /* The .iplt section is used for IFUNC symbols in static
1498          executables.  */
1499       sec = htab->elf.iplt;
1500       if (sec != NULL
1501           && !bfd_set_section_alignment (sec->owner, sec,
1502                                          plt_alignment))
1503         goto error_alignment;
1504     }
1505
1506   return pbfd;
1507 }