bfd/elf32-i386.c

   1 /* Intel 80386/80486-specific support for 32-bit ELF
   2    Copyright (C) 1993-2021 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 "dwarf2.h"
  24 #include "opcode/i386.h"
  25
  26 /* 386 uses REL relocations instead of RELA.  */
  27 #define USE_REL 1
  28
  29 #include "elf/i386.h"
  30
  31 static reloc_howto_type elf_howto_table[]=
  32 {
  33   HOWTO(R_386_NONE, 0, 3, 0, false, 0, complain_overflow_dont,
  34         bfd_elf_generic_reloc, "R_386_NONE",
  35         true, 0x00000000, 0x00000000, false),
  36   HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  37         bfd_elf_generic_reloc, "R_386_32",
  38         true, 0xffffffff, 0xffffffff, false),
  39   HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
  40         bfd_elf_generic_reloc, "R_386_PC32",
  41         true, 0xffffffff, 0xffffffff, true),
  42   HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
  43         bfd_elf_generic_reloc, "R_386_GOT32",
  44         true, 0xffffffff, 0xffffffff, false),
  45   HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
  46         bfd_elf_generic_reloc, "R_386_PLT32",
  47         true, 0xffffffff, 0xffffffff, true),
  48   HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
  49         bfd_elf_generic_reloc, "R_386_COPY",
  50         true, 0xffffffff, 0xffffffff, false),
  51   HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
  52         bfd_elf_generic_reloc, "R_386_GLOB_DAT",
  53         true, 0xffffffff, 0xffffffff, false),
  54   HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
  55         bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
  56         true, 0xffffffff, 0xffffffff, false),
  57   HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
  58         bfd_elf_generic_reloc, "R_386_RELATIVE",
  59         true, 0xffffffff, 0xffffffff, false),
  60   HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
  61         bfd_elf_generic_reloc, "R_386_GOTOFF",
  62         true, 0xffffffff, 0xffffffff, false),
  63   HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
  64         bfd_elf_generic_reloc, "R_386_GOTPC",
  65         true, 0xffffffff, 0xffffffff, true),
  66
  67   /* We have a gap in the reloc numbers here.
  68      R_386_standard counts the number up to this point, and
  69      R_386_ext_offset is the value to subtract from a reloc type of
  70      R_386_16 thru R_386_PC8 to form an index into this table.  */
  71 #define R_386_standard (R_386_GOTPC + 1)
  72 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
  73
  74   /* These relocs are a GNU extension.  */
  75   HOWTO(R_386_TLS_TPOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
  76         bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
  77         true, 0xffffffff, 0xffffffff, false),
  78   HOWTO(R_386_TLS_IE, 0, 2, 32, false, 0, complain_overflow_bitfield,
  79         bfd_elf_generic_reloc, "R_386_TLS_IE",
  80         true, 0xffffffff, 0xffffffff, false),
  81   HOWTO(R_386_TLS_GOTIE, 0, 2, 32, false, 0, complain_overflow_bitfield,
  82         bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
  83         true, 0xffffffff, 0xffffffff, false),
  84   HOWTO(R_386_TLS_LE, 0, 2, 32, false, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_386_TLS_LE",
  86         true, 0xffffffff, 0xffffffff, false),
  87   HOWTO(R_386_TLS_GD, 0, 2, 32, false, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_386_TLS_GD",
  89         true, 0xffffffff, 0xffffffff, false),
  90   HOWTO(R_386_TLS_LDM, 0, 2, 32, false, 0, complain_overflow_bitfield,
  91         bfd_elf_generic_reloc, "R_386_TLS_LDM",
  92         true, 0xffffffff, 0xffffffff, false),
  93   HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
  94         bfd_elf_generic_reloc, "R_386_16",
  95         true, 0xffff, 0xffff, false),
  96   HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_386_PC16",
  98         true, 0xffff, 0xffff, true),
  99   HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_386_8",
 101         true, 0xff, 0xff, false),
 102   HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
 103         bfd_elf_generic_reloc, "R_386_PC8",
 104         true, 0xff, 0xff, true),
 105
 106 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
 107 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
 108   /* These are common with Solaris TLS implementation.  */
 109   HOWTO(R_386_TLS_LDO_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 110         bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
 111         true, 0xffffffff, 0xffffffff, false),
 112   HOWTO(R_386_TLS_IE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 113         bfd_elf_generic_reloc, "R_386_TLS_IE_32",
 114         true, 0xffffffff, 0xffffffff, false),
 115   HOWTO(R_386_TLS_LE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 116         bfd_elf_generic_reloc, "R_386_TLS_LE_32",
 117         true, 0xffffffff, 0xffffffff, false),
 118   HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 119         bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
 120         true, 0xffffffff, 0xffffffff, false),
 121   HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 122         bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
 123         true, 0xffffffff, 0xffffffff, false),
 124   HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 125         bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
 126         true, 0xffffffff, 0xffffffff, false),
 127   HOWTO(R_386_SIZE32, 0, 2, 32, false, 0, complain_overflow_unsigned,
 128         bfd_elf_generic_reloc, "R_386_SIZE32",
 129         true, 0xffffffff, 0xffffffff, false),
 130   HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, false, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
 132         true, 0xffffffff, 0xffffffff, false),
 133   HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, false, 0, complain_overflow_dont,
 134         bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
 135         false, 0, 0, false),
 136   HOWTO(R_386_TLS_DESC, 0, 2, 32, false, 0, complain_overflow_bitfield,
 137         bfd_elf_generic_reloc, "R_386_TLS_DESC",
 138         true, 0xffffffff, 0xffffffff, false),
 139   HOWTO(R_386_IRELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
 140         bfd_elf_generic_reloc, "R_386_IRELATIVE",
 141         true, 0xffffffff, 0xffffffff, false),
 142   HOWTO(R_386_GOT32X, 0, 2, 32, false, 0, complain_overflow_bitfield,
 143         bfd_elf_generic_reloc, "R_386_GOT32X",
 144         true, 0xffffffff, 0xffffffff, false),
 145
 146   /* Another gap.  */
 147 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
 148 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
 149
 150 /* GNU extension to record C++ vtable hierarchy.  */
 151   HOWTO (R_386_GNU_VTINHERIT,   /* type */
 152          0,                     /* rightshift */
 153          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 154          0,                     /* bitsize */
 155          false,                 /* pc_relative */
 156          0,                     /* bitpos */
 157          complain_overflow_dont, /* complain_on_overflow */
 158          NULL,                  /* special_function */
 159          "R_386_GNU_VTINHERIT", /* name */
 160          false,                 /* partial_inplace */
 161          0,                     /* src_mask */
 162          0,                     /* dst_mask */
 163          false),                /* pcrel_offset */
 164
 165 /* GNU extension to record C++ vtable member usage.  */
 166   HOWTO (R_386_GNU_VTENTRY,     /* type */
 167          0,                     /* rightshift */
 168          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 169          0,                     /* bitsize */
 170          false,                 /* pc_relative */
 171          0,                     /* bitpos */
 172          complain_overflow_dont, /* complain_on_overflow */
 173          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 174          "R_386_GNU_VTENTRY",   /* name */
 175          false,                 /* partial_inplace */
 176          0,                     /* src_mask */
 177          0,                     /* dst_mask */
 178          false)                 /* pcrel_offset */
 179
 180 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
 181
 182 };
 183
 184 #define X86_PCREL_TYPE_P(TYPE) ((TYPE) == R_386_PC32)
 185
 186 #define X86_SIZE_TYPE_P(TYPE) ((TYPE) == R_386_SIZE32)
 187
 188 #ifdef DEBUG_GEN_RELOC
 189 #define TRACE(str) \
 190   fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
 191 #else
 192 #define TRACE(str)
 193 #endif
 194
 195 static reloc_howto_type *
 196 elf_i386_reloc_type_lookup (bfd *abfd,
 197                             bfd_reloc_code_real_type code)
 198 {
 199   switch (code)
 200     {
 201     case BFD_RELOC_NONE:
 202       TRACE ("BFD_RELOC_NONE");
 203       return &elf_howto_table[R_386_NONE];
 204
 205     case BFD_RELOC_32:
 206       TRACE ("BFD_RELOC_32");
 207       return &elf_howto_table[R_386_32];
 208
 209     case BFD_RELOC_CTOR:
 210       TRACE ("BFD_RELOC_CTOR");
 211       return &elf_howto_table[R_386_32];
 212
 213     case BFD_RELOC_32_PCREL:
 214       TRACE ("BFD_RELOC_PC32");
 215       return &elf_howto_table[R_386_PC32];
 216
 217     case BFD_RELOC_386_GOT32:
 218       TRACE ("BFD_RELOC_386_GOT32");
 219       return &elf_howto_table[R_386_GOT32];
 220
 221     case BFD_RELOC_386_PLT32:
 222       TRACE ("BFD_RELOC_386_PLT32");
 223       return &elf_howto_table[R_386_PLT32];
 224
 225     case BFD_RELOC_386_COPY:
 226       TRACE ("BFD_RELOC_386_COPY");
 227       return &elf_howto_table[R_386_COPY];
 228
 229     case BFD_RELOC_386_GLOB_DAT:
 230       TRACE ("BFD_RELOC_386_GLOB_DAT");
 231       return &elf_howto_table[R_386_GLOB_DAT];
 232
 233     case BFD_RELOC_386_JUMP_SLOT:
 234       TRACE ("BFD_RELOC_386_JUMP_SLOT");
 235       return &elf_howto_table[R_386_JUMP_SLOT];
 236
 237     case BFD_RELOC_386_RELATIVE:
 238       TRACE ("BFD_RELOC_386_RELATIVE");
 239       return &elf_howto_table[R_386_RELATIVE];
 240
 241     case BFD_RELOC_386_GOTOFF:
 242       TRACE ("BFD_RELOC_386_GOTOFF");
 243       return &elf_howto_table[R_386_GOTOFF];
 244
 245     case BFD_RELOC_386_GOTPC:
 246       TRACE ("BFD_RELOC_386_GOTPC");
 247       return &elf_howto_table[R_386_GOTPC];
 248
 249       /* These relocs are a GNU extension.  */
 250     case BFD_RELOC_386_TLS_TPOFF:
 251       TRACE ("BFD_RELOC_386_TLS_TPOFF");
 252       return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
 253
 254     case BFD_RELOC_386_TLS_IE:
 255       TRACE ("BFD_RELOC_386_TLS_IE");
 256       return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
 257
 258     case BFD_RELOC_386_TLS_GOTIE:
 259       TRACE ("BFD_RELOC_386_TLS_GOTIE");
 260       return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
 261
 262     case BFD_RELOC_386_TLS_LE:
 263       TRACE ("BFD_RELOC_386_TLS_LE");
 264       return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
 265
 266     case BFD_RELOC_386_TLS_GD:
 267       TRACE ("BFD_RELOC_386_TLS_GD");
 268       return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
 269
 270     case BFD_RELOC_386_TLS_LDM:
 271       TRACE ("BFD_RELOC_386_TLS_LDM");
 272       return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
 273
 274     case BFD_RELOC_16:
 275       TRACE ("BFD_RELOC_16");
 276       return &elf_howto_table[R_386_16 - R_386_ext_offset];
 277
 278     case BFD_RELOC_16_PCREL:
 279       TRACE ("BFD_RELOC_16_PCREL");
 280       return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
 281
 282     case BFD_RELOC_8:
 283       TRACE ("BFD_RELOC_8");
 284       return &elf_howto_table[R_386_8 - R_386_ext_offset];
 285
 286     case BFD_RELOC_8_PCREL:
 287       TRACE ("BFD_RELOC_8_PCREL");
 288       return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
 289
 290     /* Common with Sun TLS implementation.  */
 291     case BFD_RELOC_386_TLS_LDO_32:
 292       TRACE ("BFD_RELOC_386_TLS_LDO_32");
 293       return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
 294
 295     case BFD_RELOC_386_TLS_IE_32:
 296       TRACE ("BFD_RELOC_386_TLS_IE_32");
 297       return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
 298
 299     case BFD_RELOC_386_TLS_LE_32:
 300       TRACE ("BFD_RELOC_386_TLS_LE_32");
 301       return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
 302
 303     case BFD_RELOC_386_TLS_DTPMOD32:
 304       TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
 305       return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
 306
 307     case BFD_RELOC_386_TLS_DTPOFF32:
 308       TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
 309       return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
 310
 311     case BFD_RELOC_386_TLS_TPOFF32:
 312       TRACE ("BFD_RELOC_386_TLS_TPOFF32");
 313       return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
 314
 315     case BFD_RELOC_SIZE32:
 316       TRACE ("BFD_RELOC_SIZE32");
 317       return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
 318
 319     case BFD_RELOC_386_TLS_GOTDESC:
 320       TRACE ("BFD_RELOC_386_TLS_GOTDESC");
 321       return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
 322
 323     case BFD_RELOC_386_TLS_DESC_CALL:
 324       TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
 325       return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
 326
 327     case BFD_RELOC_386_TLS_DESC:
 328       TRACE ("BFD_RELOC_386_TLS_DESC");
 329       return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
 330
 331     case BFD_RELOC_386_IRELATIVE:
 332       TRACE ("BFD_RELOC_386_IRELATIVE");
 333       return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
 334
 335     case BFD_RELOC_386_GOT32X:
 336       TRACE ("BFD_RELOC_386_GOT32X");
 337       return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
 338
 339     case BFD_RELOC_VTABLE_INHERIT:
 340       TRACE ("BFD_RELOC_VTABLE_INHERIT");
 341       return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
 342
 343     case BFD_RELOC_VTABLE_ENTRY:
 344       TRACE ("BFD_RELOC_VTABLE_ENTRY");
 345       return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
 346
 347     default:
 348       TRACE ("Unknown");
 349       /* xgettext:c-format */
 350       _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
 351                           abfd, (int) code);
 352       bfd_set_error (bfd_error_bad_value);
 353       return NULL;
 354     }
 355 }
 356
 357 static reloc_howto_type *
 358 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 359                             const char *r_name)
 360 {
 361   unsigned int i;
 362
 363   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 364     if (elf_howto_table[i].name != NULL
 365         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 366       return &elf_howto_table[i];
 367
 368   return NULL;
 369 }
 370
 371 static reloc_howto_type *
 372 elf_i386_rtype_to_howto (unsigned r_type)
 373 {
 374   unsigned int indx;
 375
 376   if ((indx = r_type) >= R_386_standard
 377       && ((indx = r_type - R_386_ext_offset) - R_386_standard
 378           >= R_386_ext - R_386_standard)
 379       && ((indx = r_type - R_386_tls_offset) - R_386_ext
 380           >= R_386_ext2 - R_386_ext)
 381       && ((indx = r_type - R_386_vt_offset) - R_386_ext2
 382           >= R_386_vt - R_386_ext2))
 383       return NULL;
 384   /* PR 17512: file: 0f67f69d.  */
 385   if (elf_howto_table [indx].type != r_type)
 386     return NULL;
 387   return &elf_howto_table[indx];
 388 }
 389
 390 static bool
 391 elf_i386_info_to_howto_rel (bfd *abfd,
 392                             arelent *cache_ptr,
 393                             Elf_Internal_Rela *dst)
 394 {
 395   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 396
 397   if ((cache_ptr->howto = elf_i386_rtype_to_howto (r_type)) == NULL)
 398     {
 399       /* xgettext:c-format */
 400       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 401                           abfd, r_type);
 402       bfd_set_error (bfd_error_bad_value);
 403       return false;
 404     }
 405
 406   return true;
 407 }
 408
 409 /* Return whether a symbol name implies a local label.  The UnixWare
 410    2.1 cc generates temporary symbols that start with .X, so we
 411    recognize them here.  FIXME: do other SVR4 compilers also use .X?.
 412    If so, we should move the .X recognition into
 413    _bfd_elf_is_local_label_name.  */
 414
 415 static bool
 416 elf_i386_is_local_label_name (bfd *abfd, const char *name)
 417 {
 418   if (name[0] == '.' && name[1] == 'X')
 419     return true;
 420
 421   return _bfd_elf_is_local_label_name (abfd, name);
 422 }
 423 \f
 424 /* Support for core dump NOTE sections.  */
 425
 426 static bool
 427 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 428 {
 429   int offset;
 430   size_t size;
 431
 432   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 433     {
 434       int pr_version = bfd_get_32 (abfd, note->descdata);
 435
 436       if (pr_version != 1)
 437         return false;
 438
 439       /* pr_cursig */
 440       elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
 441
 442       /* pr_pid */
 443       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
 444
 445       /* pr_reg */
 446       offset = 28;
 447       size = bfd_get_32 (abfd, note->descdata + 8);
 448     }
 449   else
 450     {
 451       switch (note->descsz)
 452         {
 453         default:
 454           return false;
 455
 456         case 144:               /* Linux/i386 */
 457           /* pr_cursig */
 458           elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
 459
 460           /* pr_pid */
 461           elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
 462
 463           /* pr_reg */
 464           offset = 72;
 465           size = 68;
 466
 467           break;
 468         }
 469     }
 470
 471   /* Make a ".reg/999" section.  */
 472   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 473                                           size, note->descpos + offset);
 474 }
 475
 476 static bool
 477 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 478 {
 479   if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
 480     {
 481       int pr_version = bfd_get_32 (abfd, note->descdata);
 482
 483       if (pr_version != 1)
 484         return false;
 485
 486       elf_tdata (abfd)->core->program
 487         = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
 488       elf_tdata (abfd)->core->command
 489         = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
 490     }
 491   else
 492     {
 493       switch (note->descsz)
 494         {
 495         default:
 496           return false;
 497
 498         case 124:               /* Linux/i386 elf_prpsinfo.  */
 499           elf_tdata (abfd)->core->pid
 500             = bfd_get_32 (abfd, note->descdata + 12);
 501           elf_tdata (abfd)->core->program
 502             = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 503           elf_tdata (abfd)->core->command
 504             = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 505         }
 506     }
 507
 508   /* Note that for some reason, a spurious space is tacked
 509      onto the end of the args in some (at least one anyway)
 510      implementations, so strip it off if it exists.  */
 511   {
 512     char *command = elf_tdata (abfd)->core->command;
 513     int n = strlen (command);
 514
 515     if (0 < n && command[n - 1] == ' ')
 516       command[n - 1] = '\0';
 517   }
 518
 519   return true;
 520 }
 521 \f
 522 /* Functions for the i386 ELF linker.
 523
 524    In order to gain some understanding of code in this file without
 525    knowing all the intricate details of the linker, note the
 526    following:
 527
 528    Functions named elf_i386_* are called by external routines, other
 529    functions are only called locally.  elf_i386_* functions appear
 530    in this file more or less in the order in which they are called
 531    from external routines.  eg. elf_i386_check_relocs is called
 532    early in the link process, elf_i386_finish_dynamic_sections is
 533    one of the last functions.  */
 534
 535 /* The size in bytes of an entry in the lazy procedure linkage table.  */
 536
 537 #define LAZY_PLT_ENTRY_SIZE 16
 538
 539 /* The size in bytes of an entry in the non-lazy procedure linkage
 540    table.  */
 541
 542 #define NON_LAZY_PLT_ENTRY_SIZE 8
 543
 544 /* The first entry in an absolute lazy procedure linkage table looks
 545    like this.  See the SVR4 ABI i386 supplement to see how this works.
 546    Will be padded to LAZY_PLT_ENTRY_SIZE with lazy_plt->plt0_pad_byte.  */
 547
 548 static const bfd_byte elf_i386_lazy_plt0_entry[12] =
 549 {
 550   0xff, 0x35,   /* pushl contents of address */
 551   0, 0, 0, 0,   /* replaced with address of .got + 4.  */
 552   0xff, 0x25,   /* jmp indirect */
 553   0, 0, 0, 0    /* replaced with address of .got + 8.  */
 554 };
 555
 556 /* Subsequent entries in an absolute lazy procedure linkage table look
 557    like this.  */
 558
 559 static const bfd_byte elf_i386_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 560 {
 561   0xff, 0x25,   /* jmp indirect */
 562   0, 0, 0, 0,   /* replaced with address of this symbol in .got.  */
 563   0x68,         /* pushl immediate */
 564   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 565   0xe9,         /* jmp relative */
 566   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 567 };
 568
 569 /* The first entry in a PIC lazy procedure linkage table look like
 570    this.  Will be padded to LAZY_PLT_ENTRY_SIZE with
 571    lazy_plt->plt0_pad_byte.  */
 572
 573 static const bfd_byte elf_i386_pic_lazy_plt0_entry[12] =
 574 {
 575   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx) */
 576   0xff, 0xa3, 8, 0, 0, 0        /* jmp *8(%ebx) */
 577 };
 578
 579 /* Subsequent entries in a PIC lazy procedure linkage table look like
 580    this.  */
 581
 582 static const bfd_byte elf_i386_pic_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 583 {
 584   0xff, 0xa3,   /* jmp *offset(%ebx) */
 585   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 586   0x68,         /* pushl immediate */
 587   0, 0, 0, 0,   /* replaced with offset into relocation table.  */
 588   0xe9,         /* jmp relative */
 589   0, 0, 0, 0    /* replaced with offset to start of .plt.  */
 590 };
 591
 592 /* Entries in the non-lazy procedure linkage table look like this.  */
 593
 594 static const bfd_byte elf_i386_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
 595 {
 596   0xff, 0x25,   /* jmp indirect */
 597   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 598   0x66, 0x90    /* xchg %ax,%ax  */
 599 };
 600
 601 /* Entries in the PIC non-lazy procedure linkage table look like
 602    this.  */
 603
 604 static const bfd_byte elf_i386_pic_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
 605 {
 606   0xff, 0xa3,   /* jmp *offset(%ebx)  */
 607   0, 0, 0, 0,   /* replaced with offset of this symbol in .got.  */
 608   0x66, 0x90    /* xchg %ax,%ax  */
 609 };
 610
 611 /* The first entry in an absolute IBT-enabled lazy procedure linkage
 612    table looks like this.  */
 613
 614 static const bfd_byte elf_i386_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
 615 {
 616   0xff, 0x35, 0, 0, 0, 0,       /* pushl GOT[1]       */
 617   0xff, 0x25, 0, 0, 0, 0,       /* jmp *GOT[2]        */
 618   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 619 };
 620
 621 /* Subsequent entries for an absolute IBT-enabled lazy procedure linkage
 622    table look like this.  Subsequent entries for a PIC IBT-enabled lazy
 623    procedure linkage table are the same.  */
 624
 625 static const bfd_byte elf_i386_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 626 {
 627   0xf3, 0x0f, 0x1e, 0xfb,       /* endbr32                    */
 628   0x68, 0, 0, 0, 0,             /* pushl immediate            */
 629   0xe9, 0, 0, 0, 0,             /* jmp relative               */
 630   0x66, 0x90                    /* xchg %ax,%ax               */
 631 };
 632
 633 /* The first entry in a PIC IBT-enabled lazy procedure linkage table
 634    look like.  */
 635
 636 static const bfd_byte elf_i386_pic_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
 637 {
 638   0xff, 0xb3, 4, 0, 0, 0,       /* pushl 4(%ebx)      */
 639   0xff, 0xa3, 8, 0, 0, 0,       /* jmp *8(%ebx)       */
 640   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 641 };
 642
 643 /* Entries for branches with IBT-enabled in the absolute non-lazey
 644    procedure linkage table look like this.  They have the same size
 645    as the lazy PLT entry.  */
 646
 647 static const bfd_byte elf_i386_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 648 {
 649   0xf3, 0x0f, 0x1e, 0xfb,            /* endbr32               */
 650   0xff, 0x25, 0, 0, 0, 0,            /* jmp *name@GOT         */
 651   0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
 652 };
 653
 654 /* Entries for branches with IBT-enabled in the PIC non-lazey procedure
 655    linkage table look like this.  They have the same size as the lazy
 656    PLT entry.  */
 657
 658 static const bfd_byte elf_i386_pic_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 659 {
 660   0xf3, 0x0f, 0x1e, 0xfb,            /* endbr32               */
 661   0xff, 0xa3, 0, 0, 0, 0,            /* jmp *name@GOT(%ebx)   */
 662   0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
 663 };
 664
 665 /* .eh_frame covering the lazy .plt section.  */
 666
 667 static const bfd_byte elf_i386_eh_frame_lazy_plt[] =
 668 {
 669   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 670   0, 0, 0, 0,                   /* CIE ID */
 671   1,                            /* CIE version */
 672   'z', 'R', 0,                  /* Augmentation string */
 673   1,                            /* Code alignment factor */
 674   0x7c,                         /* Data alignment factor */
 675   8,                            /* Return address column */
 676   1,                            /* Augmentation size */
 677   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 678   DW_CFA_def_cfa, 4, 4,         /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
 679   DW_CFA_offset + 8, 1,         /* DW_CFA_offset: r8 (eip) at cfa-4 */
 680   DW_CFA_nop, DW_CFA_nop,
 681
 682   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 683   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 684   0, 0, 0, 0,                   /* R_386_PC32 .plt goes here */
 685   0, 0, 0, 0,                   /* .plt size goes here */
 686   0,                            /* Augmentation size */
 687   DW_CFA_def_cfa_offset, 8,     /* DW_CFA_def_cfa_offset: 8 */
 688   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 689   DW_CFA_def_cfa_offset, 12,    /* DW_CFA_def_cfa_offset: 12 */
 690   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 691   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 692   11,                           /* Block length */
 693   DW_OP_breg4, 4,               /* DW_OP_breg4 (esp): 4 */
 694   DW_OP_breg8, 0,               /* DW_OP_breg8 (eip): 0 */
 695   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
 696   DW_OP_lit2, DW_OP_shl, DW_OP_plus,
 697   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 698 };
 699
 700 /* .eh_frame covering the lazy .plt section with IBT-enabled.  */
 701
 702 static const bfd_byte elf_i386_eh_frame_lazy_ibt_plt[] =
 703 {
 704   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 705   0, 0, 0, 0,                   /* CIE ID */
 706   1,                            /* CIE version */
 707   'z', 'R', 0,                  /* Augmentation string */
 708   1,                            /* Code alignment factor */
 709   0x7c,                         /* Data alignment factor */
 710   8,                            /* Return address column */
 711   1,                            /* Augmentation size */
 712   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 713   DW_CFA_def_cfa, 4, 4,         /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
 714   DW_CFA_offset + 8, 1,         /* DW_CFA_offset: r8 (eip) at cfa-4 */
 715   DW_CFA_nop, DW_CFA_nop,
 716
 717   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 718   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 719   0, 0, 0, 0,                   /* R_386_PC32 .plt goes here */
 720   0, 0, 0, 0,                   /* .plt size goes here */
 721   0,                            /* Augmentation size */
 722   DW_CFA_def_cfa_offset, 8,     /* DW_CFA_def_cfa_offset: 8 */
 723   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 724   DW_CFA_def_cfa_offset, 12,    /* DW_CFA_def_cfa_offset: 12 */
 725   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 726   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 727   11,                           /* Block length */
 728   DW_OP_breg4, 4,               /* DW_OP_breg4 (esp): 4 */
 729   DW_OP_breg8, 0,               /* DW_OP_breg8 (eip): 0 */
 730   DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
 731   DW_OP_lit2, DW_OP_shl, DW_OP_plus,
 732   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 733 };
 734
 735 /* .eh_frame covering the non-lazy .plt section.  */
 736
 737 static const bfd_byte elf_i386_eh_frame_non_lazy_plt[] =
 738 {
 739 #define PLT_GOT_FDE_LENGTH              16
 740   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 741   0, 0, 0, 0,                   /* CIE ID */
 742   1,                            /* CIE version */
 743   'z', 'R', 0,                  /* Augmentation string */
 744   1,                            /* Code alignment factor */
 745   0x7c,                         /* Data alignment factor */
 746   8,                            /* Return address column */
 747   1,                            /* Augmentation size */
 748   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 749   DW_CFA_def_cfa, 4, 4,         /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
 750   DW_CFA_offset + 8, 1,         /* DW_CFA_offset: r8 (eip) at cfa-4 */
 751   DW_CFA_nop, DW_CFA_nop,
 752
 753   PLT_GOT_FDE_LENGTH, 0, 0, 0,  /* FDE length */
 754   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 755   0, 0, 0, 0,                   /* the start of non-lazy .plt goes here */
 756   0, 0, 0, 0,                   /* non-lazy .plt size goes here */
 757   0,                            /* Augmentation size */
 758   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 759 };
 760
 761 /* These are the standard parameters.  */
 762 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_plt =
 763   {
 764     elf_i386_lazy_plt0_entry,           /* plt0_entry */
 765     sizeof (elf_i386_lazy_plt0_entry),  /* plt0_entry_size */
 766     elf_i386_lazy_plt_entry,            /* plt_entry */
 767     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 768     NULL,                               /* plt_tlsdesc_entry */
 769     0,                                  /* plt_tlsdesc_entry_size*/
 770     0,                                  /* plt_tlsdesc_got1_offset */
 771     0,                                  /* plt_tlsdesc_got2_offset */
 772     0,                                  /* plt_tlsdesc_got1_insn_end */
 773     0,                                  /* plt_tlsdesc_got2_insn_end */
 774     2,                                  /* plt0_got1_offset */
 775     8,                                  /* plt0_got2_offset */
 776     0,                                  /* plt0_got2_insn_end */
 777     2,                                  /* plt_got_offset */
 778     7,                                  /* plt_reloc_offset */
 779     12,                                 /* plt_plt_offset */
 780     0,                                  /* plt_got_insn_size */
 781     0,                                  /* plt_plt_insn_end */
 782     6,                                  /* plt_lazy_offset */
 783     elf_i386_pic_lazy_plt0_entry,       /* pic_plt0_entry */
 784     elf_i386_pic_lazy_plt_entry,        /* pic_plt_entry */
 785     elf_i386_eh_frame_lazy_plt,         /* eh_frame_plt */
 786     sizeof (elf_i386_eh_frame_lazy_plt) /* eh_frame_plt_size */
 787   };
 788
 789 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_plt =
 790   {
 791     elf_i386_non_lazy_plt_entry,        /* plt_entry */
 792     elf_i386_pic_non_lazy_plt_entry,    /* pic_plt_entry */
 793     NON_LAZY_PLT_ENTRY_SIZE,            /* plt_entry_size */
 794     2,                                  /* plt_got_offset */
 795     0,                                  /* plt_got_insn_size */
 796     elf_i386_eh_frame_non_lazy_plt,     /* eh_frame_plt */
 797     sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
 798   };
 799
 800 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_ibt_plt =
 801   {
 802     elf_i386_lazy_ibt_plt0_entry,       /* plt0_entry */
 803     sizeof (elf_i386_lazy_ibt_plt0_entry), /* plt0_entry_size */
 804     elf_i386_lazy_ibt_plt_entry,        /* plt_entry */
 805     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 806     NULL,                               /* plt_tlsdesc_entry */
 807     0,                                  /* plt_tlsdesc_entry_size*/
 808     0,                                  /* plt_tlsdesc_got1_offset */
 809     0,                                  /* plt_tlsdesc_got2_offset */
 810     0,                                  /* plt_tlsdesc_got1_insn_end */
 811     0,                                  /* plt_tlsdesc_got2_insn_end */
 812     2,                                  /* plt0_got1_offset */
 813     8,                                  /* plt0_got2_offset */
 814     0,                                  /* plt0_got2_insn_end */
 815     4+2,                                /* plt_got_offset */
 816     4+1,                                /* plt_reloc_offset */
 817     4+6,                                /* plt_plt_offset */
 818     0,                                  /* plt_got_insn_size */
 819     0,                                  /* plt_plt_insn_end */
 820     0,                                  /* plt_lazy_offset */
 821     elf_i386_pic_lazy_ibt_plt0_entry,   /* pic_plt0_entry */
 822     elf_i386_lazy_ibt_plt_entry,        /* pic_plt_entry */
 823     elf_i386_eh_frame_lazy_ibt_plt,     /* eh_frame_plt */
 824     sizeof (elf_i386_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
 825   };
 826
 827 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_ibt_plt =
 828   {
 829     elf_i386_non_lazy_ibt_plt_entry,    /* plt_entry */
 830     elf_i386_pic_non_lazy_ibt_plt_entry,/* pic_plt_entry */
 831     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 832     4+2,                                /* plt_got_offset */
 833     0,                                  /* plt_got_insn_size */
 834     elf_i386_eh_frame_non_lazy_plt,     /* eh_frame_plt */
 835     sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
 836   };
 837 \f
 838
 839 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
 840    for the PLTResolve stub and then for each PLT entry.  */
 841 #define PLTRESOLVE_RELOCS_SHLIB 0
 842 #define PLTRESOLVE_RELOCS 2
 843 #define PLT_NON_JUMP_SLOT_RELOCS 2
 844
 845 /* Return TRUE if the TLS access code sequence support transition
 846    from R_TYPE.  */
 847
 848 static bool
 849 elf_i386_check_tls_transition (asection *sec,
 850                                bfd_byte *contents,
 851                                Elf_Internal_Shdr *symtab_hdr,
 852                                struct elf_link_hash_entry **sym_hashes,
 853                                unsigned int r_type,
 854                                const Elf_Internal_Rela *rel,
 855                                const Elf_Internal_Rela *relend)
 856 {
 857   unsigned int val, type, reg;
 858   unsigned long r_symndx;
 859   struct elf_link_hash_entry *h;
 860   bfd_vma offset;
 861   bfd_byte *call;
 862   bool indirect_call;
 863
 864   offset = rel->r_offset;
 865   switch (r_type)
 866     {
 867     case R_386_TLS_GD:
 868     case R_386_TLS_LDM:
 869       if (offset < 2 || (rel + 1) >= relend)
 870         return false;
 871
 872       indirect_call = false;
 873       call = contents + offset + 4;
 874       val = *(call - 5);
 875       type = *(call - 6);
 876       if (r_type == R_386_TLS_GD)
 877         {
 878           /* Check transition from GD access model.  Only
 879                 leal foo@tlsgd(,%ebx,1), %eax
 880                 call ___tls_get_addr@PLT
 881              or
 882                 leal foo@tlsgd(%ebx) %eax
 883                 call ___tls_get_addr@PLT
 884                 nop
 885              or
 886                 leal foo@tlsgd(%reg), %eax
 887                 call *___tls_get_addr@GOT(%reg)
 888                 which may be converted to
 889                 addr32 call ___tls_get_addr
 890              can transit to different access model.  */
 891           if ((offset + 10) > sec->size
 892               || (type != 0x8d && type != 0x04))
 893             return false;
 894
 895           if (type == 0x04)
 896             {
 897               /* leal foo@tlsgd(,%ebx,1), %eax
 898                  call ___tls_get_addr@PLT  */
 899               if (offset < 3)
 900                 return false;
 901
 902               if (*(call - 7) != 0x8d
 903                   || val != 0x1d
 904                   || call[0] != 0xe8)
 905                 return false;
 906             }
 907           else
 908             {
 909               /* This must be
 910                         leal foo@tlsgd(%ebx), %eax
 911                         call ___tls_get_addr@PLT
 912                         nop
 913                  or
 914                         leal foo@tlsgd(%reg), %eax
 915                         call *___tls_get_addr@GOT(%reg)
 916                         which may be converted to
 917                         addr32 call ___tls_get_addr
 918
 919                  %eax can't be used as the GOT base register since it
 920                  is used to pass parameter to ___tls_get_addr.  */
 921               reg = val & 7;
 922               if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
 923                 return false;
 924
 925               indirect_call = call[0] == 0xff;
 926               if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
 927                   && !(call[0] == 0x67 && call[1] == 0xe8)
 928                   && !(indirect_call
 929                        && (call[1] & 0xf8) == 0x90
 930                        && (call[1] & 0x7) == reg))
 931                 return false;
 932             }
 933         }
 934       else
 935         {
 936           /* Check transition from LD access model.  Only
 937                 leal foo@tlsldm(%ebx), %eax
 938                 call ___tls_get_addr@PLT
 939              or
 940                 leal foo@tlsldm(%reg), %eax
 941                 call *___tls_get_addr@GOT(%reg)
 942                 which may be converted to
 943                 addr32 call ___tls_get_addr
 944              can transit to different access model.  */
 945           if (type != 0x8d || (offset + 9) > sec->size)
 946             return false;
 947
 948           /* %eax can't be used as the GOT base register since it is
 949              used to pass parameter to ___tls_get_addr.  */
 950           reg = val & 7;
 951           if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
 952             return false;
 953
 954           indirect_call = call[0] == 0xff;
 955           if (!(reg == 3 && call[0] == 0xe8)
 956               && !(call[0] == 0x67 && call[1] == 0xe8)
 957               && !(indirect_call
 958                    && (call[1] & 0xf8) == 0x90
 959                    && (call[1] & 0x7) == reg))
 960             return false;
 961         }
 962
 963       r_symndx = ELF32_R_SYM (rel[1].r_info);
 964       if (r_symndx < symtab_hdr->sh_info)
 965         return false;
 966
 967       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 968       if (h == NULL
 969           || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
 970         return false;
 971       else if (indirect_call)
 972         return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
 973       else
 974         return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
 975                 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
 976
 977     case R_386_TLS_IE:
 978       /* Check transition from IE access model:
 979                 movl foo@indntpoff(%rip), %eax
 980                 movl foo@indntpoff(%rip), %reg
 981                 addl foo@indntpoff(%rip), %reg
 982        */
 983
 984       if (offset < 1 || (offset + 4) > sec->size)
 985         return false;
 986
 987       /* Check "movl foo@tpoff(%rip), %eax" first.  */
 988       val = bfd_get_8 (abfd, contents + offset - 1);
 989       if (val == 0xa1)
 990         return true;
 991
 992       if (offset < 2)
 993         return false;
 994
 995       /* Check movl|addl foo@tpoff(%rip), %reg.   */
 996       type = bfd_get_8 (abfd, contents + offset - 2);
 997       return ((type == 0x8b || type == 0x03)
 998               && (val & 0xc7) == 0x05);
 999
1000     case R_386_TLS_GOTIE:
1001     case R_386_TLS_IE_32:
1002       /* Check transition from {IE_32,GOTIE} access model:
1003                 subl foo@{tpoff,gontoff}(%reg1), %reg2
1004                 movl foo@{tpoff,gontoff}(%reg1), %reg2
1005                 addl foo@{tpoff,gontoff}(%reg1), %reg2
1006        */
1007
1008       if (offset < 2 || (offset + 4) > sec->size)
1009         return false;
1010
1011       val = bfd_get_8 (abfd, contents + offset - 1);
1012       if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1013         return false;
1014
1015       type = bfd_get_8 (abfd, contents + offset - 2);
1016       return type == 0x8b || type == 0x2b || type == 0x03;
1017
1018     case R_386_TLS_GOTDESC:
1019       /* Check transition from GDesc access model:
1020                 leal x@tlsdesc(%ebx), %eax
1021
1022          Make sure it's a leal adding ebx to a 32-bit offset
1023          into any register, although it's probably almost always
1024          going to be eax.  */
1025
1026       if (offset < 2 || (offset + 4) > sec->size)
1027         return false;
1028
1029       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1030         return false;
1031
1032       val = bfd_get_8 (abfd, contents + offset - 1);
1033       return (val & 0xc7) == 0x83;
1034
1035     case R_386_TLS_DESC_CALL:
1036       /* Check transition from GDesc access model:
1037                 call *x@tlsdesc(%eax)
1038        */
1039       if (offset + 2 <= sec->size)
1040         {
1041           /* Make sure that it's a call *x@tlsdesc(%eax).  */
1042           call = contents + offset;
1043           return call[0] == 0xff && call[1] == 0x10;
1044         }
1045
1046       return false;
1047
1048     default:
1049       abort ();
1050     }
1051 }
1052
1053 /* Return TRUE if the TLS access transition is OK or no transition
1054    will be performed.  Update R_TYPE if there is a transition.  */
1055
1056 static bool
1057 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1058                          asection *sec, bfd_byte *contents,
1059                          Elf_Internal_Shdr *symtab_hdr,
1060                          struct elf_link_hash_entry **sym_hashes,
1061                          unsigned int *r_type, int tls_type,
1062                          const Elf_Internal_Rela *rel,
1063                          const Elf_Internal_Rela *relend,
1064                          struct elf_link_hash_entry *h,
1065                          unsigned long r_symndx,
1066                          bool from_relocate_section)
1067 {
1068   unsigned int from_type = *r_type;
1069   unsigned int to_type = from_type;
1070   bool check = true;
1071
1072   /* Skip TLS transition for functions.  */
1073   if (h != NULL
1074       && (h->type == STT_FUNC
1075           || h->type == STT_GNU_IFUNC))
1076     return true;
1077
1078   switch (from_type)
1079     {
1080     case R_386_TLS_GD:
1081     case R_386_TLS_GOTDESC:
1082     case R_386_TLS_DESC_CALL:
1083     case R_386_TLS_IE_32:
1084     case R_386_TLS_IE:
1085     case R_386_TLS_GOTIE:
1086       if (bfd_link_executable (info))
1087         {
1088           if (h == NULL)
1089             to_type = R_386_TLS_LE_32;
1090           else if (from_type != R_386_TLS_IE
1091                    && from_type != R_386_TLS_GOTIE)
1092             to_type = R_386_TLS_IE_32;
1093         }
1094
1095       /* When we are called from elf_i386_relocate_section, there may
1096          be additional transitions based on TLS_TYPE.  */
1097       if (from_relocate_section)
1098         {
1099           unsigned int new_to_type = to_type;
1100
1101           if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
1102             new_to_type = R_386_TLS_LE_32;
1103
1104           if (to_type == R_386_TLS_GD
1105               || to_type == R_386_TLS_GOTDESC
1106               || to_type == R_386_TLS_DESC_CALL)
1107             {
1108               if (tls_type == GOT_TLS_IE_POS)
1109                 new_to_type = R_386_TLS_GOTIE;
1110               else if (tls_type & GOT_TLS_IE)
1111                 new_to_type = R_386_TLS_IE_32;
1112             }
1113
1114           /* We checked the transition before when we were called from
1115              elf_i386_check_relocs.  We only want to check the new
1116              transition which hasn't been checked before.  */
1117           check = new_to_type != to_type && from_type == to_type;
1118           to_type = new_to_type;
1119         }
1120
1121       break;
1122
1123     case R_386_TLS_LDM:
1124       if (bfd_link_executable (info))
1125         to_type = R_386_TLS_LE_32;
1126       break;
1127
1128     default:
1129       return true;
1130     }
1131
1132   /* Return TRUE if there is no transition.  */
1133   if (from_type == to_type)
1134     return true;
1135
1136   /* Check if the transition can be performed.  */
1137   if (check
1138       && ! elf_i386_check_tls_transition (sec, contents,
1139                                           symtab_hdr, sym_hashes,
1140                                           from_type, rel, relend))
1141     {
1142       reloc_howto_type *from, *to;
1143       const char *name;
1144
1145       from = elf_i386_rtype_to_howto (from_type);
1146       to = elf_i386_rtype_to_howto (to_type);
1147
1148       if (h)
1149         name = h->root.root.string;
1150       else
1151         {
1152           struct elf_x86_link_hash_table *htab;
1153
1154           htab = elf_x86_hash_table (info, I386_ELF_DATA);
1155           if (htab == NULL)
1156             name = "*unknown*";
1157           else
1158             {
1159               Elf_Internal_Sym *isym;
1160
1161               isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1162                                             abfd, r_symndx);
1163               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1164             }
1165         }
1166
1167       _bfd_error_handler
1168         /* xgettext:c-format */
1169         (_("%pB: TLS transition from %s to %s against `%s'"
1170            " at %#" PRIx64 " in section `%pA' failed"),
1171          abfd, from->name, to->name, name,
1172          (uint64_t) rel->r_offset, sec);
1173       bfd_set_error (bfd_error_bad_value);
1174       return false;
1175     }
1176
1177   *r_type = to_type;
1178   return true;
1179 }
1180
1181 /* With the local symbol, foo, we convert
1182    mov foo@GOT[(%reg1)], %reg2
1183    to
1184    lea foo[@GOTOFF(%reg1)], %reg2
1185    and convert
1186    call/jmp *foo@GOT[(%reg)]
1187    to
1188    nop call foo/jmp foo nop
1189    When PIC is false, convert
1190    test %reg1, foo@GOT[(%reg2)]
1191    to
1192    test $foo, %reg1
1193    and convert
1194    binop foo@GOT[(%reg1)], %reg2
1195    to
1196    binop $foo, %reg2
1197    where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1198    instructions.  */
1199
1200 static
1201 bool
1202 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1203                              bfd_byte *contents,
1204                              unsigned int *r_type_p,
1205                              Elf_Internal_Rela *irel,
1206                              struct elf_link_hash_entry *h,
1207                              bool *converted,
1208                              struct bfd_link_info *link_info)
1209 {
1210   struct elf_x86_link_hash_table *htab;
1211   unsigned int opcode;
1212   unsigned int modrm;
1213   bool baseless;
1214   Elf_Internal_Sym *isym;
1215   unsigned int addend;
1216   unsigned int nop;
1217   bfd_vma nop_offset;
1218   bool is_pic;
1219   bool to_reloc_32;
1220   bool abs_symbol;
1221   unsigned int r_type;
1222   unsigned int r_symndx;
1223   bfd_vma roff = irel->r_offset;
1224   bool local_ref;
1225   struct elf_x86_link_hash_entry *eh;
1226
1227   if (roff < 2)
1228     return true;
1229
1230   /* Addend for R_386_GOT32X relocations must be 0.  */
1231   addend = bfd_get_32 (abfd, contents + roff);
1232   if (addend != 0)
1233     return true;
1234
1235   htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
1236   is_pic = bfd_link_pic (link_info);
1237
1238   r_type = *r_type_p;
1239   r_symndx = ELF32_R_SYM (irel->r_info);
1240
1241   modrm = bfd_get_8 (abfd, contents + roff - 1);
1242   baseless = (modrm & 0xc7) == 0x5;
1243
1244   if (h)
1245     {
1246       /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P.  */
1247       local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
1248       isym = NULL;
1249       abs_symbol = ABS_SYMBOL_P (h);
1250     }
1251   else
1252     {
1253       local_ref = true;
1254       isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, abfd,
1255                                     r_symndx);
1256       abs_symbol = isym->st_shndx == SHN_ABS;
1257     }
1258
1259   if (baseless && is_pic)
1260     {
1261       /* For PIC, disallow R_386_GOT32X without a base register
1262          since we don't know what the GOT base is.  */
1263       const char *name;
1264
1265       if (h == NULL)
1266         name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1267       else
1268         name = h->root.root.string;
1269
1270       _bfd_error_handler
1271         /* xgettext:c-format */
1272         (_("%pB: direct GOT relocation R_386_GOT32X against `%s' without base"
1273            " register can not be used when making a shared object"),
1274          abfd, name);
1275       return false;
1276     }
1277
1278   opcode = bfd_get_8 (abfd, contents + roff - 2);
1279
1280   /* Convert to R_386_32 if PIC is false or there is no base
1281      register.  */
1282   to_reloc_32 = !is_pic || baseless;
1283
1284   eh = elf_x86_hash_entry (h);
1285
1286   /* Try to convert R_386_GOT32X.  Get the symbol referred to by the
1287      reloc.  */
1288   if (h == NULL)
1289     {
1290       if (opcode == 0x0ff)
1291         /* Convert "call/jmp *foo@GOT[(%reg)]".  */
1292         goto convert_branch;
1293       else
1294         /* Convert "mov foo@GOT[(%reg1)], %reg2",
1295            "test %reg1, foo@GOT(%reg2)" and
1296            "binop foo@GOT[(%reg1)], %reg2". */
1297         goto convert_load;
1298     }
1299
1300   /* Undefined weak symbol is only bound locally in executable
1301      and its reference is resolved as 0.  */
1302   if (h->root.type == bfd_link_hash_undefweak
1303       && !eh->linker_def
1304       && local_ref)
1305     {
1306       if (opcode == 0xff)
1307         {
1308           /* No direct branch to 0 for PIC.  */
1309           if (is_pic)
1310             return true;
1311           else
1312             goto convert_branch;
1313         }
1314       else
1315         {
1316           /* We can convert load of address 0 to R_386_32.  */
1317           to_reloc_32 = true;
1318           goto convert_load;
1319         }
1320     }
1321
1322   if (opcode == 0xff)
1323     {
1324       /* We have "call/jmp *foo@GOT[(%reg)]".  */
1325       if ((h->root.type == bfd_link_hash_defined
1326            || h->root.type == bfd_link_hash_defweak)
1327           && local_ref)
1328         {
1329           /* The function is locally defined.   */
1330         convert_branch:
1331           /* Convert R_386_GOT32X to R_386_PC32.  */
1332           if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1333             {
1334               /* Convert to "nop call foo".  ADDR_PREFIX_OPCODE
1335                  is a nop prefix.  */
1336               modrm = 0xe8;
1337               /* To support TLS optimization, always use addr32 prefix
1338                  for "call *___tls_get_addr@GOT(%reg)".  */
1339               if (eh && eh->tls_get_addr)
1340                 {
1341                   nop = 0x67;
1342                   nop_offset = irel->r_offset - 2;
1343                 }
1344               else
1345                 {
1346                   nop = htab->params->call_nop_byte;
1347                   if (htab->params->call_nop_as_suffix)
1348                     {
1349                       nop_offset = roff + 3;
1350                       irel->r_offset -= 1;
1351                     }
1352                   else
1353                     nop_offset = roff - 2;
1354                 }
1355             }
1356           else
1357             {
1358               /* Convert to "jmp foo nop".  */
1359               modrm = 0xe9;
1360               nop = NOP_OPCODE;
1361               nop_offset = roff + 3;
1362               irel->r_offset -= 1;
1363             }
1364
1365           bfd_put_8 (abfd, nop, contents + nop_offset);
1366           bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1367           /* When converting to PC-relative relocation, we
1368              need to adjust addend by -4.  */
1369           bfd_put_32 (abfd, -4, contents + irel->r_offset);
1370           irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1371           *r_type_p = R_386_PC32;
1372           *converted = true;
1373         }
1374     }
1375   else
1376     {
1377       /* We have "mov foo@GOT[(%re1g)], %reg2",
1378          "test %reg1, foo@GOT(%reg2)" and
1379          "binop foo@GOT[(%reg1)], %reg2".
1380
1381          Avoid optimizing _DYNAMIC since ld.so may use its
1382          link-time address.  */
1383       if (h == htab->elf.hdynamic)
1384         return true;
1385
1386       /* def_regular is set by an assignment in a linker script in
1387          bfd_elf_record_link_assignment.  start_stop is set on
1388          __start_SECNAME/__stop_SECNAME which mark section SECNAME.  */
1389       if (h->start_stop
1390           || eh->linker_def
1391           || ((h->def_regular
1392                || h->root.type == bfd_link_hash_defined
1393                || h->root.type == bfd_link_hash_defweak)
1394               && local_ref))
1395         {
1396         convert_load:
1397           if (opcode == 0x8b)
1398             {
1399               if (abs_symbol && local_ref)
1400                 to_reloc_32 = true;
1401
1402               if (to_reloc_32)
1403                 {
1404                   /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1405                      "mov $foo, %reg2" with R_386_32.  */
1406                   r_type = R_386_32;
1407                   modrm = 0xc0 | (modrm & 0x38) >> 3;
1408                   bfd_put_8 (abfd, modrm, contents + roff - 1);
1409                   opcode = 0xc7;
1410                 }
1411               else
1412                 {
1413                   /* Convert "mov foo@GOT(%reg1), %reg2" to
1414                      "lea foo@GOTOFF(%reg1), %reg2".  */
1415                   r_type = R_386_GOTOFF;
1416                   opcode = 0x8d;
1417                 }
1418             }
1419           else
1420             {
1421               /* Only R_386_32 is supported.  */
1422               if (!to_reloc_32)
1423                 return true;
1424
1425               if (opcode == 0x85)
1426                 {
1427                   /* Convert "test %reg1, foo@GOT(%reg2)" to
1428                      "test $foo, %reg1".  */
1429                   modrm = 0xc0 | (modrm & 0x38) >> 3;
1430                   opcode = 0xf7;
1431                 }
1432               else
1433                 {
1434                   /* Convert "binop foo@GOT(%reg1), %reg2" to
1435                      "binop $foo, %reg2".  */
1436                   modrm = (0xc0
1437                            | (modrm & 0x38) >> 3
1438                            | (opcode & 0x3c));
1439                   opcode = 0x81;
1440                 }
1441               bfd_put_8 (abfd, modrm, contents + roff - 1);
1442               r_type = R_386_32;
1443             }
1444
1445           bfd_put_8 (abfd, opcode, contents + roff - 2);
1446           irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1447           *r_type_p = r_type;
1448           *converted = true;
1449         }
1450     }
1451
1452   return true;
1453 }
1454
1455 /* Rename some of the generic section flags to better document how they
1456    are used here.  */
1457 #define check_relocs_failed     sec_flg0
1458
1459 /* Look through the relocs for a section during the first phase, and
1460    calculate needed space in the global offset table, procedure linkage
1461    table, and dynamic reloc sections.  */
1462
1463 static bool
1464 elf_i386_check_relocs (bfd *abfd,
1465                        struct bfd_link_info *info,
1466                        asection *sec,
1467                        const Elf_Internal_Rela *relocs)
1468 {
1469   struct elf_x86_link_hash_table *htab;
1470   Elf_Internal_Shdr *symtab_hdr;
1471   struct elf_link_hash_entry **sym_hashes;
1472   const Elf_Internal_Rela *rel;
1473   const Elf_Internal_Rela *rel_end;
1474   asection *sreloc;
1475   bfd_byte *contents;
1476   bool converted;
1477
1478   if (bfd_link_relocatable (info))
1479     return true;
1480
1481   htab = elf_x86_hash_table (info, I386_ELF_DATA);
1482   if (htab == NULL)
1483     {
1484       sec->check_relocs_failed = 1;
1485       return false;
1486     }
1487
1488   BFD_ASSERT (is_x86_elf (abfd, htab));
1489
1490   /* Get the section contents.  */
1491   if (elf_section_data (sec)->this_hdr.contents != NULL)
1492     contents = elf_section_data (sec)->this_hdr.contents;
1493   else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1494     {
1495       sec->check_relocs_failed = 1;
1496       return false;
1497     }
1498
1499   symtab_hdr = &elf_symtab_hdr (abfd);
1500   sym_hashes = elf_sym_hashes (abfd);
1501
1502   converted = false;
1503
1504   sreloc = NULL;
1505
1506   rel_end = relocs + sec->reloc_count;
1507   for (rel = relocs; rel < rel_end; rel++)
1508     {
1509       unsigned int r_type;
1510       unsigned int r_symndx;
1511       struct elf_link_hash_entry *h;
1512       struct elf_x86_link_hash_entry *eh;
1513       Elf_Internal_Sym *isym;
1514       const char *name;
1515       bool size_reloc;
1516       bool no_dynreloc;
1517
1518       r_symndx = ELF32_R_SYM (rel->r_info);
1519       r_type = ELF32_R_TYPE (rel->r_info);
1520
1521       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1522         {
1523           /* xgettext:c-format */
1524           _bfd_error_handler (_("%pB: bad symbol index: %d"),
1525                               abfd, r_symndx);
1526           goto error_return;
1527         }
1528
1529       if (r_symndx < symtab_hdr->sh_info)
1530         {
1531           /* A local symbol.  */
1532           isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1533                                         abfd, r_symndx);
1534           if (isym == NULL)
1535             goto error_return;
1536
1537           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1538           if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1539             {
1540               h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel, true);
1541               if (h == NULL)
1542                 goto error_return;
1543
1544               /* Fake a STT_GNU_IFUNC symbol.  */
1545               h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1546                                                       isym, NULL);
1547               h->type = STT_GNU_IFUNC;
1548               h->def_regular = 1;
1549               h->ref_regular = 1;
1550               h->forced_local = 1;
1551               h->root.type = bfd_link_hash_defined;
1552             }
1553           else
1554             h = NULL;
1555         }
1556       else
1557         {
1558           isym = NULL;
1559           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1560           while (h->root.type == bfd_link_hash_indirect
1561                  || h->root.type == bfd_link_hash_warning)
1562             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1563         }
1564
1565       eh = (struct elf_x86_link_hash_entry *) h;
1566       if (h != NULL)
1567         {
1568           if (r_type == R_386_GOTOFF)
1569             eh->gotoff_ref = 1;
1570
1571           /* It is referenced by a non-shared object. */
1572           h->ref_regular = 1;
1573         }
1574
1575       if (r_type == R_386_GOT32X
1576           && (h == NULL || h->type != STT_GNU_IFUNC))
1577         {
1578           Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
1579           if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
1580                                             &r_type, irel, h,
1581                                             &converted, info))
1582             goto error_return;
1583         }
1584
1585       if (!_bfd_elf_x86_valid_reloc_p (sec, info, htab, rel, h, isym,
1586                                        symtab_hdr, &no_dynreloc))
1587         return false;
1588
1589       if (! elf_i386_tls_transition (info, abfd, sec, contents,
1590                                      symtab_hdr, sym_hashes,
1591                                      &r_type, GOT_UNKNOWN,
1592                                      rel, rel_end, h, r_symndx, false))
1593         goto error_return;
1594
1595       /* Check if _GLOBAL_OFFSET_TABLE_ is referenced.  */
1596       if (h == htab->elf.hgot)
1597         htab->got_referenced = true;
1598
1599       switch (r_type)
1600         {
1601         case R_386_TLS_LDM:
1602           htab->tls_ld_or_ldm_got.refcount = 1;
1603           goto create_got;
1604
1605         case R_386_PLT32:
1606           /* This symbol requires a procedure linkage table entry.  We
1607              actually build the entry in adjust_dynamic_symbol,
1608              because this might be a case of linking PIC code which is
1609              never referenced by a dynamic object, in which case we
1610              don't need to generate a procedure linkage table entry
1611              after all.  */
1612
1613           /* If this is a local symbol, we resolve it directly without
1614              creating a procedure linkage table entry.  */
1615           if (h == NULL)
1616             continue;
1617
1618           eh->zero_undefweak &= 0x2;
1619           h->needs_plt = 1;
1620           h->plt.refcount = 1;
1621           break;
1622
1623         case R_386_SIZE32:
1624           size_reloc = true;
1625           goto do_size;
1626
1627         case R_386_TLS_IE_32:
1628         case R_386_TLS_IE:
1629         case R_386_TLS_GOTIE:
1630           if (!bfd_link_executable (info))
1631             info->flags |= DF_STATIC_TLS;
1632           /* Fall through */
1633
1634         case R_386_GOT32:
1635         case R_386_GOT32X:
1636         case R_386_TLS_GD:
1637         case R_386_TLS_GOTDESC:
1638         case R_386_TLS_DESC_CALL:
1639           /* This symbol requires a global offset table entry.  */
1640           {
1641             int tls_type, old_tls_type;
1642
1643             switch (r_type)
1644               {
1645               default:
1646               case R_386_GOT32:
1647               case R_386_GOT32X:
1648                 tls_type = GOT_NORMAL;
1649                 break;
1650               case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1651               case R_386_TLS_GOTDESC:
1652               case R_386_TLS_DESC_CALL:
1653                 tls_type = GOT_TLS_GDESC; break;
1654               case R_386_TLS_IE_32:
1655                 if (ELF32_R_TYPE (rel->r_info) == r_type)
1656                   tls_type = GOT_TLS_IE_NEG;
1657                 else
1658                   /* If this is a GD->IE transition, we may use either of
1659                      R_386_TLS_TPOFF and R_386_TLS_TPOFF32.  */
1660                   tls_type = GOT_TLS_IE;
1661                 break;
1662               case R_386_TLS_IE:
1663               case R_386_TLS_GOTIE:
1664                 tls_type = GOT_TLS_IE_POS; break;
1665               }
1666
1667             if (h != NULL)
1668               {
1669                 h->got.refcount = 1;
1670                 old_tls_type = elf_x86_hash_entry (h)->tls_type;
1671               }
1672             else
1673               {
1674                 bfd_signed_vma *local_got_refcounts;
1675
1676                 /* This is a global offset table entry for a local symbol.  */
1677                 local_got_refcounts = elf_local_got_refcounts (abfd);
1678                 if (local_got_refcounts == NULL)
1679                   {
1680                     bfd_size_type size;
1681
1682                     size = symtab_hdr->sh_info;
1683                     size *= (sizeof (bfd_signed_vma)
1684                              + sizeof (bfd_vma) + sizeof(char));
1685                     local_got_refcounts = (bfd_signed_vma *)
1686                         bfd_zalloc (abfd, size);
1687                     if (local_got_refcounts == NULL)
1688                       goto error_return;
1689                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1690                     elf_x86_local_tlsdesc_gotent (abfd)
1691                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1692                     elf_x86_local_got_tls_type (abfd)
1693                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1694                   }
1695                 local_got_refcounts[r_symndx] = 1;
1696                 old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx];
1697               }
1698
1699             if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1700               tls_type |= old_tls_type;
1701             /* If a TLS symbol is accessed using IE at least once,
1702                there is no point to use dynamic model for it.  */
1703             else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1704                      && (! GOT_TLS_GD_ANY_P (old_tls_type)
1705                          || (tls_type & GOT_TLS_IE) == 0))
1706               {
1707                 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1708                   tls_type = old_tls_type;
1709                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1710                          && GOT_TLS_GD_ANY_P (tls_type))
1711                   tls_type |= old_tls_type;
1712                 else
1713                   {
1714                     if (h)
1715                       name = h->root.root.string;
1716                     else
1717                       name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1718                                              NULL);
1719                     _bfd_error_handler
1720                       /* xgettext:c-format */
1721                       (_("%pB: `%s' accessed both as normal and "
1722                          "thread local symbol"),
1723                        abfd, name);
1724                     bfd_set_error (bfd_error_bad_value);
1725                     goto error_return;
1726                   }
1727               }
1728
1729             if (old_tls_type != tls_type)
1730               {
1731                 if (h != NULL)
1732                   elf_x86_hash_entry (h)->tls_type = tls_type;
1733                 else
1734                   elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
1735               }
1736           }
1737           /* Fall through */
1738
1739         case R_386_GOTOFF:
1740         case R_386_GOTPC:
1741         create_got:
1742           if (r_type != R_386_TLS_IE)
1743             {
1744               if (eh != NULL)
1745                 {
1746                   eh->zero_undefweak &= 0x2;
1747
1748                   /* Need GOT to resolve undefined weak symbol to 0.  */
1749                   if (r_type == R_386_GOTOFF
1750                       && h->root.type == bfd_link_hash_undefweak
1751                       && bfd_link_executable (info))
1752                     htab->got_referenced = true;
1753                 }
1754               break;
1755             }
1756           /* Fall through */
1757
1758         case R_386_TLS_LE_32:
1759         case R_386_TLS_LE:
1760           if (eh != NULL)
1761             eh->zero_undefweak &= 0x2;
1762           if (bfd_link_executable (info))
1763             break;
1764           info->flags |= DF_STATIC_TLS;
1765           goto do_relocation;
1766
1767         case R_386_32:
1768         case R_386_PC32:
1769           if (eh != NULL && (sec->flags & SEC_CODE) != 0)
1770             eh->zero_undefweak |= 0x2;
1771         do_relocation:
1772           /* We are called after all symbols have been resolved.  Only
1773              relocation against STT_GNU_IFUNC symbol must go through
1774              PLT.  */
1775           if (h != NULL
1776               && (bfd_link_executable (info)
1777                   || h->type == STT_GNU_IFUNC))
1778             {
1779               bool func_pointer_ref = false;
1780
1781               if (r_type == R_386_PC32)
1782                 {
1783                   /* Since something like ".long foo - ." may be used
1784                      as pointer, make sure that PLT is used if foo is
1785                      a function defined in a shared library.  */
1786                   if ((sec->flags & SEC_CODE) == 0)
1787                     h->pointer_equality_needed = 1;
1788                   else if (h->type == STT_GNU_IFUNC
1789                            && bfd_link_pic (info))
1790                     {
1791                       _bfd_error_handler
1792                         /* xgettext:c-format */
1793                         (_("%pB: unsupported non-PIC call to IFUNC `%s'"),
1794                          abfd, h->root.root.string);
1795                       bfd_set_error (bfd_error_bad_value);
1796                       goto error_return;
1797                     }
1798                 }
1799               else
1800                 {
1801                   h->pointer_equality_needed = 1;
1802                   /* R_386_32 can be resolved at run-time.  */
1803                   if (r_type == R_386_32
1804                       && (sec->flags & SEC_READONLY) == 0)
1805                     func_pointer_ref = true;
1806                 }
1807
1808               if (!func_pointer_ref)
1809                 {
1810                   /* If this reloc is in a read-only section, we might
1811                      need a copy reloc.  We can't check reliably at this
1812                      stage whether the section is read-only, as input
1813                      sections have not yet been mapped to output sections.
1814                      Tentatively set the flag for now, and correct in
1815                      adjust_dynamic_symbol.  */
1816                   h->non_got_ref = 1;
1817
1818                   /* We may need a .plt entry if the symbol is a function
1819                      defined in a shared lib or is a function referenced
1820                      from the code or read-only section.  */
1821                   if (!h->def_regular
1822                       || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
1823                     h->plt.refcount = 1;
1824                 }
1825             }
1826
1827           size_reloc = false;
1828         do_size:
1829           if (!no_dynreloc
1830               && NEED_DYNAMIC_RELOCATION_P (info, false, h, sec, r_type,
1831                                             R_386_32))
1832             {
1833               struct elf_dyn_relocs *p;
1834               struct elf_dyn_relocs **head;
1835
1836               /* We must copy these reloc types into the output file.
1837                  Create a reloc section in dynobj and make room for
1838                  this reloc.  */
1839               if (sreloc == NULL)
1840                 {
1841                   sreloc = _bfd_elf_make_dynamic_reloc_section
1842                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ false);
1843
1844                   if (sreloc == NULL)
1845                     goto error_return;
1846                 }
1847
1848               /* If this is a global symbol, we count the number of
1849                  relocations we need for this symbol.  */
1850               if (h != NULL)
1851                 {
1852                   head = &h->dyn_relocs;
1853                 }
1854               else
1855                 {
1856                   /* Track dynamic relocs needed for local syms too.
1857                      We really need local syms available to do this
1858                      easily.  Oh well.  */
1859                   void **vpp;
1860                   asection *s;
1861
1862                   isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
1863                                                 abfd, r_symndx);
1864                   if (isym == NULL)
1865                     goto error_return;
1866
1867                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1868                   if (s == NULL)
1869                     s = sec;
1870
1871                   vpp = &elf_section_data (s)->local_dynrel;
1872                   head = (struct elf_dyn_relocs **)vpp;
1873                 }
1874
1875               p = *head;
1876               if (p == NULL || p->sec != sec)
1877                 {
1878                   size_t amt = sizeof *p;
1879                   p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1880                                                            amt);
1881                   if (p == NULL)
1882                     goto error_return;
1883                   p->next = *head;
1884                   *head = p;
1885                   p->sec = sec;
1886                   p->count = 0;
1887                   p->pc_count = 0;
1888                 }
1889
1890               p->count += 1;
1891               /* Count size relocation as PC-relative relocation.  */
1892               if (r_type == R_386_PC32 || size_reloc)
1893                 p->pc_count += 1;
1894             }
1895           break;
1896
1897           /* This relocation describes the C++ object vtable hierarchy.
1898              Reconstruct it for later use during GC.  */
1899         case R_386_GNU_VTINHERIT:
1900           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1901             goto error_return;
1902           break;
1903
1904           /* This relocation describes which C++ vtable entries are actually
1905              used.  Record for later use during GC.  */
1906         case R_386_GNU_VTENTRY:
1907           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1908             goto error_return;
1909           break;
1910
1911         default:
1912           break;
1913         }
1914     }
1915
1916   if (elf_section_data (sec)->this_hdr.contents != contents)
1917     {
1918       if (!converted && !info->keep_memory)
1919         free (contents);
1920       else
1921         {
1922           /* Cache the section contents for elf_link_input_bfd if any
1923              load is converted or --no-keep-memory isn't used.  */
1924           elf_section_data (sec)->this_hdr.contents = contents;
1925         }
1926     }
1927
1928   /* Cache relocations if any load is converted.  */
1929   if (elf_section_data (sec)->relocs != relocs && converted)
1930     elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
1931
1932   return true;
1933
1934  error_return:
1935   if (elf_section_data (sec)->this_hdr.contents != contents)
1936     free (contents);
1937   sec->check_relocs_failed = 1;
1938   return false;
1939 }
1940
1941 /* Set the correct type for an x86 ELF section.  We do this by the
1942    section name, which is a hack, but ought to work.  */
1943
1944 static bool
1945 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1946                         Elf_Internal_Shdr *hdr,
1947                         asection *sec)
1948 {
1949   const char *name;
1950
1951   name = bfd_section_name (sec);
1952
1953   /* This is an ugly, but unfortunately necessary hack that is
1954      needed when producing EFI binaries on x86. It tells
1955      elf.c:elf_fake_sections() not to consider ".reloc" as a section
1956      containing ELF relocation info.  We need this hack in order to
1957      be able to generate ELF binaries that can be translated into
1958      EFI applications (which are essentially COFF objects).  Those
1959      files contain a COFF ".reloc" section inside an ELFNN object,
1960      which would normally cause BFD to segfault because it would
1961      attempt to interpret this section as containing relocation
1962      entries for section "oc".  With this hack enabled, ".reloc"
1963      will be treated as a normal data section, which will avoid the
1964      segfault.  However, you won't be able to create an ELFNN binary
1965      with a section named "oc" that needs relocations, but that's
1966      the kind of ugly side-effects you get when detecting section
1967      types based on their names...  In practice, this limitation is
1968      unlikely to bite.  */
1969   if (strcmp (name, ".reloc") == 0)
1970     hdr->sh_type = SHT_PROGBITS;
1971
1972   return true;
1973 }
1974
1975 /* Return the relocation value for @tpoff relocation
1976    if STT_TLS virtual address is ADDRESS.  */
1977
1978 static bfd_vma
1979 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
1980 {
1981   struct elf_link_hash_table *htab = elf_hash_table (info);
1982   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
1983   bfd_vma static_tls_size;
1984
1985   /* If tls_sec is NULL, we should have signalled an error already.  */
1986   if (htab->tls_sec == NULL)
1987     return 0;
1988
1989   /* Consider special static TLS alignment requirements.  */
1990   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
1991   return static_tls_size + htab->tls_sec->vma - address;
1992 }
1993
1994 /* Relocate an i386 ELF section.  */
1995
1996 static int
1997 elf_i386_relocate_section (bfd *output_bfd,
1998                            struct bfd_link_info *info,
1999                            bfd *input_bfd,
2000                            asection *input_section,
2001                            bfd_byte *contents,
2002                            Elf_Internal_Rela *relocs,
2003                            Elf_Internal_Sym *local_syms,
2004                            asection **local_sections)
2005 {
2006   struct elf_x86_link_hash_table *htab;
2007   Elf_Internal_Shdr *symtab_hdr;
2008   struct elf_link_hash_entry **sym_hashes;
2009   bfd_vma *local_got_offsets;
2010   bfd_vma *local_tlsdesc_gotents;
2011   Elf_Internal_Rela *rel;
2012   Elf_Internal_Rela *wrel;
2013   Elf_Internal_Rela *relend;
2014   bool is_vxworks_tls;
2015   unsigned plt_entry_size;
2016
2017   /* Skip if check_relocs failed.  */
2018   if (input_section->check_relocs_failed)
2019     return false;
2020
2021   htab = elf_x86_hash_table (info, I386_ELF_DATA);
2022   if (htab == NULL)
2023     return false;
2024
2025   if (!is_x86_elf (input_bfd, htab))
2026     {
2027       bfd_set_error (bfd_error_wrong_format);
2028       return false;
2029     }
2030
2031   symtab_hdr = &elf_symtab_hdr (input_bfd);
2032   sym_hashes = elf_sym_hashes (input_bfd);
2033   local_got_offsets = elf_local_got_offsets (input_bfd);
2034   local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2035   /* We have to handle relocations in vxworks .tls_vars sections
2036      specially, because the dynamic loader is 'weird'.  */
2037   is_vxworks_tls = (htab->elf.target_os == is_vxworks
2038                     && bfd_link_pic (info)
2039                     && !strcmp (input_section->output_section->name,
2040                                 ".tls_vars"));
2041
2042   _bfd_x86_elf_set_tls_module_base (info);
2043
2044   plt_entry_size = htab->plt.plt_entry_size;
2045
2046   rel = wrel = relocs;
2047   relend = relocs + input_section->reloc_count;
2048   for (; rel < relend; wrel++, rel++)
2049     {
2050       unsigned int r_type, r_type_tls;
2051       reloc_howto_type *howto;
2052       unsigned long r_symndx;
2053       struct elf_link_hash_entry *h;
2054       struct elf_x86_link_hash_entry *eh;
2055       Elf_Internal_Sym *sym;
2056       asection *sec;
2057       bfd_vma off, offplt, plt_offset;
2058       bfd_vma relocation;
2059       bool unresolved_reloc;
2060       bfd_reloc_status_type r;
2061       unsigned int indx;
2062       int tls_type;
2063       bfd_vma st_size;
2064       asection *resolved_plt;
2065       bool resolved_to_zero;
2066       bool relative_reloc;
2067
2068       r_type = ELF32_R_TYPE (rel->r_info);
2069       if (r_type == R_386_GNU_VTINHERIT
2070           || r_type == R_386_GNU_VTENTRY)
2071         {
2072           if (wrel != rel)
2073             *wrel = *rel;
2074           continue;
2075         }
2076
2077       howto = elf_i386_rtype_to_howto (r_type);
2078       if (howto == NULL)
2079         return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2080
2081       r_symndx = ELF32_R_SYM (rel->r_info);
2082       h = NULL;
2083       sym = NULL;
2084       sec = NULL;
2085       unresolved_reloc = false;
2086       if (r_symndx < symtab_hdr->sh_info)
2087         {
2088           sym = local_syms + r_symndx;
2089           sec = local_sections[r_symndx];
2090           relocation = (sec->output_section->vma
2091                         + sec->output_offset
2092                         + sym->st_value);
2093           st_size = sym->st_size;
2094
2095           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2096               && ((sec->flags & SEC_MERGE) != 0
2097                   || (bfd_link_relocatable (info)
2098                       && sec->output_offset != 0)))
2099             {
2100               bfd_vma addend;
2101               bfd_byte *where = contents + rel->r_offset;
2102
2103               switch (howto->size)
2104                 {
2105                 case 0:
2106                   addend = bfd_get_8 (input_bfd, where);
2107                   if (howto->pc_relative)
2108                     {
2109                       addend = (addend ^ 0x80) - 0x80;
2110                       addend += 1;
2111                     }
2112                   break;
2113                 case 1:
2114                   addend = bfd_get_16 (input_bfd, where);
2115                   if (howto->pc_relative)
2116                     {
2117                       addend = (addend ^ 0x8000) - 0x8000;
2118                       addend += 2;
2119                     }
2120                   break;
2121                 case 2:
2122                   addend = bfd_get_32 (input_bfd, where);
2123                   if (howto->pc_relative)
2124                     {
2125                       addend = (addend ^ 0x80000000) - 0x80000000;
2126                       addend += 4;
2127                     }
2128                   break;
2129                 default:
2130                   abort ();
2131                 }
2132
2133               if (bfd_link_relocatable (info))
2134                 addend += sec->output_offset;
2135               else
2136                 {
2137                   asection *msec = sec;
2138                   addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2139                                                    addend);
2140                   addend -= relocation;
2141                   addend += msec->output_section->vma + msec->output_offset;
2142                 }
2143
2144               switch (howto->size)
2145                 {
2146                 case 0:
2147                   /* FIXME: overflow checks.  */
2148                   if (howto->pc_relative)
2149                     addend -= 1;
2150                   bfd_put_8 (input_bfd, addend, where);
2151                   break;
2152                 case 1:
2153                   if (howto->pc_relative)
2154                     addend -= 2;
2155                   bfd_put_16 (input_bfd, addend, where);
2156                   break;
2157                 case 2:
2158                   if (howto->pc_relative)
2159                     addend -= 4;
2160                   bfd_put_32 (input_bfd, addend, where);
2161                   break;
2162                 }
2163             }
2164           else if (!bfd_link_relocatable (info)
2165                    && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2166             {
2167               /* Relocate against local STT_GNU_IFUNC symbol.  */
2168               h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd, rel,
2169                                                    false);
2170               if (h == NULL)
2171                 abort ();
2172
2173               /* Set STT_GNU_IFUNC symbol value.  */
2174               h->root.u.def.value = sym->st_value;
2175               h->root.u.def.section = sec;
2176             }
2177         }
2178       else
2179         {
2180           bool warned ATTRIBUTE_UNUSED;
2181           bool ignored ATTRIBUTE_UNUSED;
2182
2183           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2184                                    r_symndx, symtab_hdr, sym_hashes,
2185                                    h, sec, relocation,
2186                                    unresolved_reloc, warned, ignored);
2187           st_size = h->size;
2188         }
2189
2190       if (sec != NULL && discarded_section (sec))
2191         {
2192           _bfd_clear_contents (howto, input_bfd, input_section,
2193                                contents, rel->r_offset);
2194           wrel->r_offset = rel->r_offset;
2195           wrel->r_info = 0;
2196           wrel->r_addend = 0;
2197
2198           /* For ld -r, remove relocations in debug sections against
2199              sections defined in discarded sections.  Not done for
2200              eh_frame editing code expects to be present.  */
2201            if (bfd_link_relocatable (info)
2202                && (input_section->flags & SEC_DEBUGGING))
2203              wrel--;
2204
2205            continue;
2206         }
2207
2208       if (bfd_link_relocatable (info))
2209         {
2210           if (wrel != rel)
2211             *wrel = *rel;
2212           continue;
2213         }
2214
2215       eh = (struct elf_x86_link_hash_entry *) h;
2216
2217       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2218          it here if it is defined in a non-shared object.  */
2219       if (h != NULL
2220           && h->type == STT_GNU_IFUNC
2221           && h->def_regular)
2222         {
2223           asection *gotplt, *base_got;
2224           bfd_vma plt_index;
2225           const char *name;
2226
2227           if ((input_section->flags & SEC_ALLOC) == 0)
2228             {
2229               /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2230                  STT_GNU_IFUNC symbol as STT_FUNC.  */
2231               if (elf_section_type (input_section) == SHT_NOTE)
2232                 goto skip_ifunc;
2233               /* Dynamic relocs are not propagated for SEC_DEBUGGING
2234                  sections because such sections are not SEC_ALLOC and
2235                  thus ld.so will not process them.  */
2236               if ((input_section->flags & SEC_DEBUGGING) != 0)
2237                 continue;
2238               abort ();
2239             }
2240
2241           /* STT_GNU_IFUNC symbol must go through PLT.  */
2242           if (htab->elf.splt != NULL)
2243             {
2244               if (htab->plt_second != NULL)
2245                 {
2246                   resolved_plt = htab->plt_second;
2247                   plt_offset = eh->plt_second.offset;
2248                 }
2249               else
2250                 {
2251                   resolved_plt = htab->elf.splt;
2252                   plt_offset = h->plt.offset;
2253                 }
2254               gotplt = htab->elf.sgotplt;
2255             }
2256           else
2257             {
2258               resolved_plt = htab->elf.iplt;
2259               plt_offset = h->plt.offset;
2260               gotplt = htab->elf.igotplt;
2261             }
2262
2263           switch (r_type)
2264             {
2265             default:
2266               break;
2267
2268             case R_386_GOT32:
2269             case R_386_GOT32X:
2270               base_got = htab->elf.sgot;
2271               off = h->got.offset;
2272
2273               if (base_got == NULL)
2274                 abort ();
2275
2276               if (off == (bfd_vma) -1)
2277                 {
2278                   /* We can't use h->got.offset here to save state, or
2279                      even just remember the offset, as finish_dynamic_symbol
2280                      would use that as offset into .got.  */
2281
2282                   if (h->plt.offset == (bfd_vma) -1)
2283                     abort ();
2284
2285                   if (htab->elf.splt != NULL)
2286                     {
2287                       plt_index = (h->plt.offset / plt_entry_size
2288                                    - htab->plt.has_plt0);
2289                       off = (plt_index + 3) * 4;
2290                       base_got = htab->elf.sgotplt;
2291                     }
2292                   else
2293                     {
2294                       plt_index = h->plt.offset / plt_entry_size;
2295                       off = plt_index * 4;
2296                       base_got = htab->elf.igotplt;
2297                     }
2298
2299                   if (h->dynindx == -1
2300                       || h->forced_local
2301                       || info->symbolic)
2302                     {
2303                       /* This references the local defitionion.  We must
2304                          initialize this entry in the global offset table.
2305                          Since the offset must always be a multiple of 8,
2306                          we use the least significant bit to record
2307                          whether we have initialized it already.
2308
2309                          When doing a dynamic link, we create a .rela.got
2310                          relocation entry to initialize the value.  This
2311                          is done in the finish_dynamic_symbol routine.   */
2312                       if ((off & 1) != 0)
2313                         off &= ~1;
2314                       else
2315                         {
2316                           bfd_put_32 (output_bfd, relocation,
2317                                       base_got->contents + off);
2318                           h->got.offset |= 1;
2319                         }
2320                     }
2321
2322                   relocation = off;
2323                 }
2324               else
2325                 relocation = (base_got->output_section->vma
2326                               + base_got->output_offset + off
2327                               - gotplt->output_section->vma
2328                               - gotplt->output_offset);
2329
2330               if (rel->r_offset > 1
2331                   && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2332                   && *(contents + rel->r_offset - 2) != 0x8d)
2333                 {
2334                   if (bfd_link_pic (info))
2335                     goto disallow_got32;
2336
2337                   /* Add the GOT base if there is no base register.  */
2338                   relocation += (gotplt->output_section->vma
2339                                  + gotplt->output_offset);
2340                 }
2341               else if (htab->elf.splt == NULL)
2342                 {
2343                   /* Adjust for static executables.  */
2344                   relocation += gotplt->output_offset;
2345                 }
2346
2347               goto do_relocation;
2348             }
2349
2350           if (h->plt.offset == (bfd_vma) -1)
2351             {
2352               /* Handle static pointers of STT_GNU_IFUNC symbols.  */
2353               if (r_type == R_386_32
2354                   && (input_section->flags & SEC_CODE) == 0)
2355                 goto do_ifunc_pointer;
2356               goto bad_ifunc_reloc;
2357             }
2358
2359           relocation = (resolved_plt->output_section->vma
2360                         + resolved_plt->output_offset + plt_offset);
2361
2362           switch (r_type)
2363             {
2364             default:
2365             bad_ifunc_reloc:
2366               if (h->root.root.string)
2367                 name = h->root.root.string;
2368               else
2369                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2370                                          NULL);
2371               _bfd_error_handler
2372                 /* xgettext:c-format */
2373                 (_("%pB: relocation %s against STT_GNU_IFUNC "
2374                    "symbol `%s' isn't supported"), input_bfd,
2375                  howto->name, name);
2376               bfd_set_error (bfd_error_bad_value);
2377               return false;
2378
2379             case R_386_32:
2380               /* Generate dynamic relcoation only when there is a
2381                  non-GOT reference in a shared object.  */
2382               if ((bfd_link_pic (info) && h->non_got_ref)
2383                   || h->plt.offset == (bfd_vma) -1)
2384                 {
2385                   Elf_Internal_Rela outrel;
2386                   asection *sreloc;
2387                   bfd_vma offset;
2388
2389                 do_ifunc_pointer:
2390                   /* Need a dynamic relocation to get the real function
2391                      adddress.  */
2392                   offset = _bfd_elf_section_offset (output_bfd,
2393                                                     info,
2394                                                     input_section,
2395                                                     rel->r_offset);
2396                   if (offset == (bfd_vma) -1
2397                       || offset == (bfd_vma) -2)
2398                     abort ();
2399
2400                   outrel.r_offset = (input_section->output_section->vma
2401                                      + input_section->output_offset
2402                                      + offset);
2403
2404                   if (POINTER_LOCAL_IFUNC_P (info, h))
2405                     {
2406                       info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
2407                                               h->root.root.string,
2408                                               h->root.u.def.section->owner);
2409
2410                       /* This symbol is resolved locally.  */
2411                       outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
2412
2413                       if (htab->params->report_relative_reloc)
2414                         _bfd_x86_elf_link_report_relative_reloc
2415                           (info, input_section, h, sym,
2416                            "R_386_IRELATIVE", &outrel);
2417
2418                       bfd_put_32 (output_bfd,
2419                                   (h->root.u.def.value
2420                                    + h->root.u.def.section->output_section->vma
2421                                    + h->root.u.def.section->output_offset),
2422                                   contents + offset);
2423                     }
2424                   else
2425                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2426
2427                   /* Dynamic relocations are stored in
2428                      1. .rel.ifunc section in PIC object.
2429                      2. .rel.got section in dynamic executable.
2430                      3. .rel.iplt section in static executable.  */
2431                   if (bfd_link_pic (info))
2432                     sreloc = htab->elf.irelifunc;
2433                   else if (htab->elf.splt != NULL)
2434                     sreloc = htab->elf.srelgot;
2435                   else
2436                     sreloc = htab->elf.irelplt;
2437                   elf_append_rel (output_bfd, sreloc, &outrel);
2438
2439                   /* If this reloc is against an external symbol, we
2440                      do not want to fiddle with the addend.  Otherwise,
2441                      we need to include the symbol value so that it
2442                      becomes an addend for the dynamic reloc.  For an
2443                      internal symbol, we have updated addend.  */
2444                   continue;
2445                 }
2446               /* FALLTHROUGH */
2447             case R_386_PC32:
2448             case R_386_PLT32:
2449               goto do_relocation;
2450
2451             case R_386_GOTOFF:
2452               relocation -= (gotplt->output_section->vma
2453                              + gotplt->output_offset);
2454               goto do_relocation;
2455             }
2456         }
2457
2458     skip_ifunc:
2459       resolved_to_zero = (eh != NULL
2460                           && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2461
2462       switch (r_type)
2463         {
2464         case R_386_GOT32X:
2465         case R_386_GOT32:
2466           /* Relocation is to the entry for this symbol in the global
2467              offset table.  */
2468           if (htab->elf.sgot == NULL)
2469             abort ();
2470
2471           relative_reloc = false;
2472           if (h != NULL)
2473             {
2474               off = h->got.offset;
2475               if (RESOLVED_LOCALLY_P (info, h, htab))
2476                 {
2477                   /* We must initialize this entry in the global offset
2478                      table.  Since the offset must always be a multiple
2479                      of 4, we use the least significant bit to record
2480                      whether we have initialized it already.
2481
2482                      When doing a dynamic link, we create a .rel.got
2483                      relocation entry to initialize the value.  This
2484                      is done in the finish_dynamic_symbol routine.  */
2485                   if ((off & 1) != 0)
2486                     off &= ~1;
2487                   else
2488                     {
2489                       bfd_put_32 (output_bfd, relocation,
2490                                   htab->elf.sgot->contents + off);
2491                       h->got.offset |= 1;
2492
2493                       if (GENERATE_RELATIVE_RELOC_P (info, h))
2494                         {
2495                           /* PR ld/21402: If this symbol isn't dynamic
2496                              in PIC, generate R_386_RELATIVE here.  */
2497                           eh->no_finish_dynamic_symbol = 1;
2498                           relative_reloc = true;
2499                         }
2500                     }
2501                 }
2502               else
2503                 unresolved_reloc = false;
2504             }
2505           else
2506             {
2507               if (local_got_offsets == NULL)
2508                 abort ();
2509
2510               off = local_got_offsets[r_symndx];
2511
2512               /* The offset must always be a multiple of 4.  We use
2513                  the least significant bit to record whether we have
2514                  already generated the necessary reloc.  */
2515               if ((off & 1) != 0)
2516                 off &= ~1;
2517               else
2518                 {
2519                   bfd_put_32 (output_bfd, relocation,
2520                               htab->elf.sgot->contents + off);
2521                   local_got_offsets[r_symndx] |= 1;
2522
2523                   if (bfd_link_pic (info))
2524                     relative_reloc = true;
2525                 }
2526             }
2527
2528           if (relative_reloc)
2529             {
2530               asection *s;
2531               Elf_Internal_Rela outrel;
2532
2533               s = htab->elf.srelgot;
2534               if (s == NULL)
2535                 abort ();
2536
2537               outrel.r_offset = (htab->elf.sgot->output_section->vma
2538                                  + htab->elf.sgot->output_offset
2539                                  + off);
2540               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2541
2542               if (htab->params->report_relative_reloc)
2543                 _bfd_x86_elf_link_report_relative_reloc
2544                   (info, input_section, h, sym, "R_386_RELATIVE",
2545                    &outrel);
2546
2547               elf_append_rel (output_bfd, s, &outrel);
2548             }
2549
2550           if (off >= (bfd_vma) -2)
2551             abort ();
2552
2553           relocation = (htab->elf.sgot->output_section->vma
2554                         + htab->elf.sgot->output_offset + off);
2555           if (rel->r_offset > 1
2556               && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
2557               && *(contents + rel->r_offset - 2) != 0x8d)
2558             {
2559               if (bfd_link_pic (info))
2560                 {
2561                   /* For PIC, disallow R_386_GOT32 without a base
2562                      register, except for "lea foo@GOT, %reg", since
2563                      we don't know what the GOT base is.  */
2564                   const char *name;
2565
2566                 disallow_got32:
2567                   if (h == NULL || h->root.root.string == NULL)
2568                     name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2569                                              NULL);
2570                   else
2571                     name = h->root.root.string;
2572
2573                   _bfd_error_handler
2574                     /* xgettext:c-format */
2575                     (_("%pB: direct GOT relocation %s against `%s'"
2576                        " without base register can not be used"
2577                        " when making a shared object"),
2578                      input_bfd, howto->name, name);
2579                   bfd_set_error (bfd_error_bad_value);
2580                   return false;
2581                 }
2582             }
2583           else
2584             {
2585               /* Subtract the .got.plt section address only with a base
2586                  register.  */
2587               relocation -= (htab->elf.sgotplt->output_section->vma
2588                              + htab->elf.sgotplt->output_offset);
2589             }
2590
2591           break;
2592
2593         case R_386_GOTOFF:
2594           /* Relocation is relative to the start of the global offset
2595              table.  */
2596
2597           /* Check to make sure it isn't a protected function or data
2598              symbol for shared library since it may not be local when
2599              used as function address or with copy relocation.  We also
2600              need to make sure that a symbol is referenced locally.  */
2601           if (!bfd_link_executable (info) && h)
2602             {
2603               if (!h->def_regular)
2604                 {
2605                   const char *v;
2606
2607                   switch (ELF_ST_VISIBILITY (h->other))
2608                     {
2609                     case STV_HIDDEN:
2610                       v = _("hidden symbol");
2611                       break;
2612                     case STV_INTERNAL:
2613                       v = _("internal symbol");
2614                       break;
2615                     case STV_PROTECTED:
2616                       v = _("protected symbol");
2617                       break;
2618                     default:
2619                       v = _("symbol");
2620                       break;
2621                     }
2622
2623                   _bfd_error_handler
2624                     /* xgettext:c-format */
2625                     (_("%pB: relocation R_386_GOTOFF against undefined %s"
2626                        " `%s' can not be used when making a shared object"),
2627                      input_bfd, v, h->root.root.string);
2628                   bfd_set_error (bfd_error_bad_value);
2629                   return false;
2630                 }
2631               else if (!SYMBOL_REFERENCES_LOCAL_P (info, h)
2632                        && (h->type == STT_FUNC
2633                            || h->type == STT_OBJECT)
2634                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2635                 {
2636                   _bfd_error_handler
2637                     /* xgettext:c-format */
2638                     (_("%pB: relocation R_386_GOTOFF against protected %s"
2639                        " `%s' can not be used when making a shared object"),
2640                      input_bfd,
2641                      h->type == STT_FUNC ? "function" : "data",
2642                      h->root.root.string);
2643                   bfd_set_error (bfd_error_bad_value);
2644                   return false;
2645                 }
2646             }
2647
2648           /* Note that sgot is not involved in this
2649              calculation.  We always want the start of .got.plt.  If we
2650              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2651              permitted by the ABI, we might have to change this
2652              calculation.  */
2653           relocation -= htab->elf.sgotplt->output_section->vma
2654                         + htab->elf.sgotplt->output_offset;
2655           break;
2656
2657         case R_386_GOTPC:
2658           /* Use global offset table as symbol value.  */
2659           relocation = htab->elf.sgotplt->output_section->vma
2660                        + htab->elf.sgotplt->output_offset;
2661           unresolved_reloc = false;
2662           break;
2663
2664         case R_386_PLT32:
2665           /* Relocation is to the entry for this symbol in the
2666              procedure linkage table.  */
2667
2668           /* Resolve a PLT32 reloc against a local symbol directly,
2669              without using the procedure linkage table.  */
2670           if (h == NULL)
2671             break;
2672
2673           if ((h->plt.offset == (bfd_vma) -1
2674                && eh->plt_got.offset == (bfd_vma) -1)
2675               || htab->elf.splt == NULL)
2676             {
2677               /* We didn't make a PLT entry for this symbol.  This
2678                  happens when statically linking PIC code, or when
2679                  using -Bsymbolic.  */
2680               break;
2681             }
2682
2683           if (h->plt.offset != (bfd_vma) -1)
2684             {
2685               if (htab->plt_second != NULL)
2686                 {
2687                   resolved_plt = htab->plt_second;
2688                   plt_offset = eh->plt_second.offset;
2689                 }
2690               else
2691                 {
2692                   resolved_plt = htab->elf.splt;
2693                   plt_offset = h->plt.offset;
2694                 }
2695             }
2696           else
2697             {
2698               resolved_plt = htab->plt_got;
2699               plt_offset = eh->plt_got.offset;
2700             }
2701
2702           relocation = (resolved_plt->output_section->vma
2703                         + resolved_plt->output_offset
2704                         + plt_offset);
2705           unresolved_reloc = false;
2706           break;
2707
2708         case R_386_SIZE32:
2709           /* Set to symbol size.  */
2710           relocation = st_size;
2711           /* Fall through.  */
2712
2713         case R_386_32:
2714         case R_386_PC32:
2715           if ((input_section->flags & SEC_ALLOC) == 0
2716               || is_vxworks_tls)
2717             break;
2718
2719           if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type, sec,
2720                                              false, resolved_to_zero,
2721                                              (r_type == R_386_PC32)))
2722             {
2723               Elf_Internal_Rela outrel;
2724               bool skip, relocate;
2725               asection *sreloc;
2726
2727               /* When generating a shared object, these relocations
2728                  are copied into the output file to be resolved at run
2729                  time.  */
2730
2731               skip = false;
2732               relocate = false;
2733
2734               outrel.r_offset =
2735                 _bfd_elf_section_offset (output_bfd, info, input_section,
2736                                          rel->r_offset);
2737               if (outrel.r_offset == (bfd_vma) -1)
2738                 skip = true;
2739               else if (outrel.r_offset == (bfd_vma) -2)
2740                 skip = true, relocate = true;
2741               outrel.r_offset += (input_section->output_section->vma
2742                                   + input_section->output_offset);
2743
2744               if (skip)
2745                 memset (&outrel, 0, sizeof outrel);
2746               else if (COPY_INPUT_RELOC_P (info, h, r_type))
2747                 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2748               else
2749                 {
2750                   /* This symbol is local, or marked to become local.  */
2751                   relocate = true;
2752                   outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2753
2754                   if (htab->params->report_relative_reloc)
2755                     _bfd_x86_elf_link_report_relative_reloc
2756                       (info, input_section, h, sym, "R_386_RELATIVE",
2757                        &outrel);
2758                 }
2759
2760               sreloc = elf_section_data (input_section)->sreloc;
2761
2762               if (sreloc == NULL || sreloc->contents == NULL)
2763                 {
2764                   r = bfd_reloc_notsupported;
2765                   goto check_relocation_error;
2766                 }
2767
2768               elf_append_rel (output_bfd, sreloc, &outrel);
2769
2770               /* If this reloc is against an external symbol, we do
2771                  not want to fiddle with the addend.  Otherwise, we
2772                  need to include the symbol value so that it becomes
2773                  an addend for the dynamic reloc.  */
2774               if (! relocate)
2775                 continue;
2776             }
2777           break;
2778
2779         case R_386_TLS_IE:
2780           if (!bfd_link_executable (info))
2781             {
2782               Elf_Internal_Rela outrel;
2783               asection *sreloc;
2784
2785               outrel.r_offset = rel->r_offset
2786                                 + input_section->output_section->vma
2787                                 + input_section->output_offset;
2788               outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2789
2790               if (htab->params->report_relative_reloc)
2791                 _bfd_x86_elf_link_report_relative_reloc
2792                   (info, input_section, h, sym, "R_386_RELATIVE",
2793                    &outrel);
2794
2795               sreloc = elf_section_data (input_section)->sreloc;
2796               if (sreloc == NULL)
2797                 abort ();
2798               elf_append_rel (output_bfd, sreloc, &outrel);
2799             }
2800           /* Fall through */
2801
2802         case R_386_TLS_GD:
2803         case R_386_TLS_GOTDESC:
2804         case R_386_TLS_DESC_CALL:
2805         case R_386_TLS_IE_32:
2806         case R_386_TLS_GOTIE:
2807           tls_type = GOT_UNKNOWN;
2808           if (h == NULL && local_got_offsets)
2809             tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
2810           else if (h != NULL)
2811             tls_type = elf_x86_hash_entry(h)->tls_type;
2812           if (tls_type == GOT_TLS_IE)
2813             tls_type = GOT_TLS_IE_NEG;
2814
2815            r_type_tls = r_type;
2816           if (! elf_i386_tls_transition (info, input_bfd,
2817                                          input_section, contents,
2818                                          symtab_hdr, sym_hashes,
2819                                          &r_type_tls, tls_type, rel,
2820                                          relend, h, r_symndx, true))
2821             return false;
2822
2823           if (r_type_tls == R_386_TLS_LE_32)
2824             {
2825               BFD_ASSERT (! unresolved_reloc);
2826               if (r_type == R_386_TLS_GD)
2827                 {
2828                   unsigned int type;
2829                   bfd_vma roff;
2830
2831                   /* GD->LE transition.  */
2832                   type = *(contents + rel->r_offset - 2);
2833                   if (type == 0x04)
2834                     {
2835                       /* Change
2836                                 leal foo@tlsgd(,%ebx,1), %eax
2837                                 call ___tls_get_addr@PLT
2838                          into:
2839                                 movl %gs:0, %eax
2840                                 subl $foo@tpoff, %eax
2841                          (6 byte form of subl).  */
2842                       roff = rel->r_offset + 5;
2843                     }
2844                   else
2845                     {
2846                       /* Change
2847                                 leal foo@tlsgd(%ebx), %eax
2848                                 call ___tls_get_addr@PLT
2849                                 nop
2850                          or
2851                                 leal foo@tlsgd(%reg), %eax
2852                                 call *___tls_get_addr@GOT(%reg)
2853                                 which may be converted to
2854                                 addr32 call ___tls_get_addr
2855                          into:
2856                                 movl %gs:0, %eax; subl $foo@tpoff, %eax
2857                          (6 byte form of subl).  */
2858                       roff = rel->r_offset + 6;
2859                     }
2860                   memcpy (contents + roff - 8,
2861                           "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2862                   bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
2863                               contents + roff);
2864                   /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X.  */
2865                   rel++;
2866                   wrel++;
2867                   continue;
2868                 }
2869               else if (r_type == R_386_TLS_GOTDESC)
2870                 {
2871                   /* GDesc -> LE transition.
2872                      It's originally something like:
2873                      leal x@tlsdesc(%ebx), %eax
2874
2875                      leal x@ntpoff, %eax
2876
2877                      Registers other than %eax may be set up here.  */
2878
2879                   unsigned int val;
2880                   bfd_vma roff;
2881
2882                   roff = rel->r_offset;
2883                   val = bfd_get_8 (input_bfd, contents + roff - 1);
2884
2885                   /* Now modify the instruction as appropriate.  */
2886                   /* aoliva FIXME: remove the above and xor the byte
2887                      below with 0x86.  */
2888                   bfd_put_8 (output_bfd, val ^ 0x86,
2889                              contents + roff - 1);
2890                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2891                               contents + roff);
2892                   continue;
2893                 }
2894               else if (r_type == R_386_TLS_DESC_CALL)
2895                 {
2896                   /* GDesc -> LE transition.
2897                      It's originally:
2898                      call *(%eax)
2899                      Turn it into:
2900                      xchg %ax,%ax  */
2901
2902                   bfd_vma roff;
2903
2904                   roff = rel->r_offset;
2905                   bfd_put_8 (output_bfd, 0x66, contents + roff);
2906                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2907                   continue;
2908                 }
2909               else if (r_type == R_386_TLS_IE)
2910                 {
2911                   unsigned int val;
2912
2913                   /* IE->LE transition:
2914                      Originally it can be one of:
2915                      movl foo, %eax
2916                      movl foo, %reg
2917                      addl foo, %reg
2918                      We change it into:
2919                      movl $foo, %eax
2920                      movl $foo, %reg
2921                      addl $foo, %reg.  */
2922                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2923                   if (val == 0xa1)
2924                     {
2925                       /* movl foo, %eax.  */
2926                       bfd_put_8 (output_bfd, 0xb8,
2927                                  contents + rel->r_offset - 1);
2928                     }
2929                   else
2930                     {
2931                       unsigned int type;
2932
2933                       type = bfd_get_8 (input_bfd,
2934                                         contents + rel->r_offset - 2);
2935                       switch (type)
2936                         {
2937                         case 0x8b:
2938                           /* movl */
2939                           bfd_put_8 (output_bfd, 0xc7,
2940                                      contents + rel->r_offset - 2);
2941                           bfd_put_8 (output_bfd,
2942                                      0xc0 | ((val >> 3) & 7),
2943                                      contents + rel->r_offset - 1);
2944                           break;
2945                         case 0x03:
2946                           /* addl */
2947                           bfd_put_8 (output_bfd, 0x81,
2948                                      contents + rel->r_offset - 2);
2949                           bfd_put_8 (output_bfd,
2950                                      0xc0 | ((val >> 3) & 7),
2951                                      contents + rel->r_offset - 1);
2952                           break;
2953                         default:
2954                           BFD_FAIL ();
2955                           break;
2956                         }
2957                     }
2958                   bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
2959                               contents + rel->r_offset);
2960                   continue;
2961                 }
2962               else
2963                 {
2964                   unsigned int val, type;
2965
2966                   /* {IE_32,GOTIE}->LE transition:
2967                      Originally it can be one of:
2968                      subl foo(%reg1), %reg2
2969                      movl foo(%reg1), %reg2
2970                      addl foo(%reg1), %reg2
2971                      We change it into:
2972                      subl $foo, %reg2
2973                      movl $foo, %reg2 (6 byte form)
2974                      addl $foo, %reg2.  */
2975                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2976                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2977                   if (type == 0x8b)
2978                     {
2979                       /* movl */
2980                       bfd_put_8 (output_bfd, 0xc7,
2981                                  contents + rel->r_offset - 2);
2982                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2983                                  contents + rel->r_offset - 1);
2984                     }
2985                   else if (type == 0x2b)
2986                     {
2987                       /* subl */
2988                       bfd_put_8 (output_bfd, 0x81,
2989                                  contents + rel->r_offset - 2);
2990                       bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2991                                  contents + rel->r_offset - 1);
2992                     }
2993                   else if (type == 0x03)
2994                     {
2995                       /* addl */
2996                       bfd_put_8 (output_bfd, 0x81,
2997                                  contents + rel->r_offset - 2);
2998                       bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2999                                  contents + rel->r_offset - 1);
3000                     }
3001                   else
3002                     BFD_FAIL ();
3003                   if (r_type == R_386_TLS_GOTIE)
3004                     bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
3005                                 contents + rel->r_offset);
3006                   else
3007                     bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
3008                                 contents + rel->r_offset);
3009                   continue;
3010                 }
3011             }
3012
3013           if (htab->elf.sgot == NULL)
3014             abort ();
3015
3016           if (h != NULL)
3017             {
3018               off = h->got.offset;
3019               offplt = elf_x86_hash_entry (h)->tlsdesc_got;
3020             }
3021           else
3022             {
3023               if (local_got_offsets == NULL)
3024                 abort ();
3025
3026               off = local_got_offsets[r_symndx];
3027               offplt = local_tlsdesc_gotents[r_symndx];
3028             }
3029
3030           if ((off & 1) != 0)
3031             off &= ~1;
3032           else
3033             {
3034               Elf_Internal_Rela outrel;
3035               int dr_type;
3036               asection *sreloc;
3037
3038               if (htab->elf.srelgot == NULL)
3039                 abort ();
3040
3041               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3042
3043               if (GOT_TLS_GDESC_P (tls_type))
3044                 {
3045                   bfd_byte *loc;
3046                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3047                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3048                               <= htab->elf.sgotplt->size);
3049                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3050                                      + htab->elf.sgotplt->output_offset
3051                                      + offplt
3052                                      + htab->sgotplt_jump_table_size);
3053                   sreloc = htab->elf.srelplt;
3054                   loc = sreloc->contents;
3055                   loc += (htab->next_tls_desc_index++
3056                           * sizeof (Elf32_External_Rel));
3057                   BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3058                               <= sreloc->contents + sreloc->size);
3059                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3060                   if (indx == 0)
3061                     {
3062                       BFD_ASSERT (! unresolved_reloc);
3063                       bfd_put_32 (output_bfd,
3064                                   relocation - _bfd_x86_elf_dtpoff_base (info),
3065                                   htab->elf.sgotplt->contents + offplt
3066                                   + htab->sgotplt_jump_table_size + 4);
3067                     }
3068                   else
3069                     {
3070                       bfd_put_32 (output_bfd, 0,
3071                                   htab->elf.sgotplt->contents + offplt
3072                                   + htab->sgotplt_jump_table_size + 4);
3073                     }
3074                 }
3075
3076               sreloc = htab->elf.srelgot;
3077
3078               outrel.r_offset = (htab->elf.sgot->output_section->vma
3079                                  + htab->elf.sgot->output_offset + off);
3080
3081               if (GOT_TLS_GD_P (tls_type))
3082                 dr_type = R_386_TLS_DTPMOD32;
3083               else if (GOT_TLS_GDESC_P (tls_type))
3084                 goto dr_done;
3085               else if (tls_type == GOT_TLS_IE_POS)
3086                 dr_type = R_386_TLS_TPOFF;
3087               else
3088                 dr_type = R_386_TLS_TPOFF32;
3089
3090               if (dr_type == R_386_TLS_TPOFF && indx == 0)
3091                 bfd_put_32 (output_bfd,
3092                             relocation - _bfd_x86_elf_dtpoff_base (info),
3093                             htab->elf.sgot->contents + off);
3094               else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
3095                 bfd_put_32 (output_bfd,
3096                             _bfd_x86_elf_dtpoff_base (info) - relocation,
3097                             htab->elf.sgot->contents + off);
3098               else if (dr_type != R_386_TLS_DESC)
3099                 bfd_put_32 (output_bfd, 0,
3100                             htab->elf.sgot->contents + off);
3101               outrel.r_info = ELF32_R_INFO (indx, dr_type);
3102
3103               elf_append_rel (output_bfd, sreloc, &outrel);
3104
3105               if (GOT_TLS_GD_P (tls_type))
3106                 {
3107                   if (indx == 0)
3108                     {
3109                       BFD_ASSERT (! unresolved_reloc);
3110                       bfd_put_32 (output_bfd,
3111                                   relocation - _bfd_x86_elf_dtpoff_base (info),
3112                                   htab->elf.sgot->contents + off + 4);
3113                     }
3114                   else
3115                     {
3116                       bfd_put_32 (output_bfd, 0,
3117                                   htab->elf.sgot->contents + off + 4);
3118                       outrel.r_info = ELF32_R_INFO (indx,
3119                                                     R_386_TLS_DTPOFF32);
3120                       outrel.r_offset += 4;
3121                       elf_append_rel (output_bfd, sreloc, &outrel);
3122                     }
3123                 }
3124               else if (tls_type == GOT_TLS_IE_BOTH)
3125                 {
3126                   bfd_put_32 (output_bfd,
3127                               (indx == 0
3128                                ? relocation - _bfd_x86_elf_dtpoff_base (info)
3129                                : 0),
3130                               htab->elf.sgot->contents + off + 4);
3131                   outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3132                   outrel.r_offset += 4;
3133                   elf_append_rel (output_bfd, sreloc, &outrel);
3134                 }
3135
3136             dr_done:
3137               if (h != NULL)
3138                 h->got.offset |= 1;
3139               else
3140                 local_got_offsets[r_symndx] |= 1;
3141             }
3142
3143           if (off >= (bfd_vma) -2
3144               && ! GOT_TLS_GDESC_P (tls_type))
3145             abort ();
3146           if (r_type_tls == R_386_TLS_GOTDESC
3147               || r_type_tls == R_386_TLS_DESC_CALL)
3148             {
3149               relocation = htab->sgotplt_jump_table_size + offplt;
3150               unresolved_reloc = false;
3151             }
3152           else if (r_type_tls == r_type)
3153             {
3154               bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
3155                               + htab->elf.sgotplt->output_offset;
3156               relocation = htab->elf.sgot->output_section->vma
3157                 + htab->elf.sgot->output_offset + off - g_o_t;
3158               if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3159                   && tls_type == GOT_TLS_IE_BOTH)
3160                 relocation += 4;
3161               if (r_type == R_386_TLS_IE)
3162                 relocation += g_o_t;
3163               unresolved_reloc = false;
3164             }
3165           else if (r_type == R_386_TLS_GD)
3166             {
3167               unsigned int val, type;
3168               bfd_vma roff;
3169
3170               /* GD->IE transition.  */
3171               type = *(contents + rel->r_offset - 2);
3172               val = *(contents + rel->r_offset - 1);
3173               if (type == 0x04)
3174                 {
3175                   /* Change
3176                         leal foo@tlsgd(,%ebx,1), %eax
3177                         call ___tls_get_addr@PLT
3178                      into:
3179                         movl %gs:0, %eax
3180                         subl $foo@gottpoff(%ebx), %eax.  */
3181                   val >>= 3;
3182                   roff = rel->r_offset - 3;
3183                 }
3184               else
3185                 {
3186                   /* Change
3187                         leal foo@tlsgd(%ebx), %eax
3188                         call ___tls_get_addr@PLT
3189                         nop
3190                      or
3191                         leal foo@tlsgd(%reg), %eax
3192                         call *___tls_get_addr@GOT(%reg)
3193                         which may be converted to
3194                         addr32 call ___tls_get_addr
3195                      into:
3196                         movl %gs:0, %eax;
3197                         subl $foo@gottpoff(%reg), %eax.  */
3198                   roff = rel->r_offset - 2;
3199                 }
3200               memcpy (contents + roff,
3201                       "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3202               contents[roff + 7] = 0x80 | (val & 7);
3203               /* If foo is used only with foo@gotntpoff(%reg) and
3204                  foo@indntpoff, but not with foo@gottpoff(%reg), change
3205                  subl $foo@gottpoff(%reg), %eax
3206                  into:
3207                  addl $foo@gotntpoff(%reg), %eax.  */
3208               if (tls_type == GOT_TLS_IE_POS)
3209                 contents[roff + 6] = 0x03;
3210               bfd_put_32 (output_bfd,
3211                           htab->elf.sgot->output_section->vma
3212                           + htab->elf.sgot->output_offset + off
3213                           - htab->elf.sgotplt->output_section->vma
3214                           - htab->elf.sgotplt->output_offset,
3215                           contents + roff + 8);
3216               /* Skip R_386_PLT32 and R_386_GOT32X.  */
3217               rel++;
3218               wrel++;
3219               continue;
3220             }
3221           else if (r_type == R_386_TLS_GOTDESC)
3222             {
3223               /* GDesc -> IE transition.
3224                  It's originally something like:
3225                  leal x@tlsdesc(%ebx), %eax
3226
3227                  Change it to:
3228                  movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3229                  or:
3230                  movl x@gottpoff(%ebx), %eax # before negl %eax
3231
3232                  Registers other than %eax may be set up here.  */
3233
3234               bfd_vma roff;
3235
3236               /* First, make sure it's a leal adding ebx to a 32-bit
3237                  offset into any register, although it's probably
3238                  almost always going to be eax.  */
3239               roff = rel->r_offset;
3240
3241               /* Now modify the instruction as appropriate.  */
3242               /* To turn a leal into a movl in the form we use it, it
3243                  suffices to change the first byte from 0x8d to 0x8b.
3244                  aoliva FIXME: should we decide to keep the leal, all
3245                  we have to do is remove the statement below, and
3246                  adjust the relaxation of R_386_TLS_DESC_CALL.  */
3247               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3248
3249               if (tls_type == GOT_TLS_IE_BOTH)
3250                 off += 4;
3251
3252               bfd_put_32 (output_bfd,
3253                           htab->elf.sgot->output_section->vma
3254                           + htab->elf.sgot->output_offset + off
3255                           - htab->elf.sgotplt->output_section->vma
3256                           - htab->elf.sgotplt->output_offset,
3257                           contents + roff);
3258               continue;
3259             }
3260           else if (r_type == R_386_TLS_DESC_CALL)
3261             {
3262               /* GDesc -> IE transition.
3263                  It's originally:
3264                  call *(%eax)
3265
3266                  Change it to:
3267                  xchg %ax,%ax
3268                  or
3269                  negl %eax
3270                  depending on how we transformed the TLS_GOTDESC above.
3271               */
3272
3273               bfd_vma roff;
3274
3275               roff = rel->r_offset;
3276
3277               /* Now modify the instruction as appropriate.  */
3278               if (tls_type != GOT_TLS_IE_NEG)
3279                 {
3280                   /* xchg %ax,%ax */
3281                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3282                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3283                 }
3284               else
3285                 {
3286                   /* negl %eax */
3287                   bfd_put_8 (output_bfd, 0xf7, contents + roff);
3288                   bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3289                 }
3290
3291               continue;
3292             }
3293           else
3294             BFD_ASSERT (false);
3295           break;
3296
3297         case R_386_TLS_LDM:
3298           if (! elf_i386_tls_transition (info, input_bfd,
3299                                          input_section, contents,
3300                                          symtab_hdr, sym_hashes,
3301                                          &r_type, GOT_UNKNOWN, rel,
3302                                          relend, h, r_symndx, true))
3303             return false;
3304
3305           if (r_type != R_386_TLS_LDM)
3306             {
3307               /* LD->LE transition.  Change
3308                         leal foo@tlsldm(%ebx) %eax
3309                         call ___tls_get_addr@PLT
3310                  into:
3311                         movl %gs:0, %eax
3312                         nop
3313                         leal 0(%esi,1), %esi
3314                  or change
3315                         leal foo@tlsldm(%reg) %eax
3316                         call *___tls_get_addr@GOT(%reg)
3317                         which may be converted to
3318                         addr32 call ___tls_get_addr
3319                  into:
3320                         movl %gs:0, %eax
3321                         leal 0(%esi), %esi  */
3322               BFD_ASSERT (r_type == R_386_TLS_LE_32);
3323               if (*(contents + rel->r_offset + 4) == 0xff
3324                   || *(contents + rel->r_offset + 4) == 0x67)
3325                 memcpy (contents + rel->r_offset - 2,
3326                         "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
3327               else
3328                 memcpy (contents + rel->r_offset - 2,
3329                         "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3330               /* Skip R_386_PC32/R_386_PLT32.  */
3331               rel++;
3332               wrel++;
3333               continue;
3334             }
3335
3336           if (htab->elf.sgot == NULL)
3337             abort ();
3338
3339           off = htab->tls_ld_or_ldm_got.offset;
3340           if (off & 1)
3341             off &= ~1;
3342           else
3343             {
3344               Elf_Internal_Rela outrel;
3345
3346               if (htab->elf.srelgot == NULL)
3347                 abort ();
3348
3349               outrel.r_offset = (htab->elf.sgot->output_section->vma
3350                                  + htab->elf.sgot->output_offset + off);
3351
3352               bfd_put_32 (output_bfd, 0,
3353                           htab->elf.sgot->contents + off);
3354               bfd_put_32 (output_bfd, 0,
3355                           htab->elf.sgot->contents + off + 4);
3356               outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
3357               elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
3358               htab->tls_ld_or_ldm_got.offset |= 1;
3359             }
3360           relocation = htab->elf.sgot->output_section->vma
3361                        + htab->elf.sgot->output_offset + off
3362                        - htab->elf.sgotplt->output_section->vma
3363                        - htab->elf.sgotplt->output_offset;
3364           unresolved_reloc = false;
3365           break;
3366
3367         case R_386_TLS_LDO_32:
3368           if (!bfd_link_executable (info)
3369               || (input_section->flags & SEC_CODE) == 0)
3370             relocation -= _bfd_x86_elf_dtpoff_base (info);
3371           else
3372             /* When converting LDO to LE, we must negate.  */
3373             relocation = -elf_i386_tpoff (info, relocation);
3374           break;
3375
3376         case R_386_TLS_LE_32:
3377         case R_386_TLS_LE:
3378           if (!bfd_link_executable (info))
3379             {
3380               Elf_Internal_Rela outrel;
3381               asection *sreloc;
3382
3383               outrel.r_offset = rel->r_offset
3384                                 + input_section->output_section->vma
3385                                 + input_section->output_offset;
3386               if (h != NULL && h->dynindx != -1)
3387                 indx = h->dynindx;
3388               else
3389                 indx = 0;
3390               if (r_type == R_386_TLS_LE_32)
3391                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3392               else
3393                 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3394               sreloc = elf_section_data (input_section)->sreloc;
3395               if (sreloc == NULL)
3396                 abort ();
3397               elf_append_rel (output_bfd, sreloc, &outrel);
3398               if (indx)
3399                 continue;
3400               else if (r_type == R_386_TLS_LE_32)
3401                 relocation = _bfd_x86_elf_dtpoff_base (info) - relocation;
3402               else
3403                 relocation -= _bfd_x86_elf_dtpoff_base (info);
3404             }
3405           else if (r_type == R_386_TLS_LE_32)
3406             relocation = elf_i386_tpoff (info, relocation);
3407           else
3408             relocation = -elf_i386_tpoff (info, relocation);
3409           break;
3410
3411         default:
3412           break;
3413         }
3414
3415       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3416          because such sections are not SEC_ALLOC and thus ld.so will
3417          not process them.  */
3418       if (unresolved_reloc
3419           && !((input_section->flags & SEC_DEBUGGING) != 0
3420                && h->def_dynamic)
3421           && _bfd_elf_section_offset (output_bfd, info, input_section,
3422                                       rel->r_offset) != (bfd_vma) -1)
3423         {
3424           _bfd_error_handler
3425             /* xgettext:c-format */
3426             (_("%pB(%pA+%#" PRIx64 "): unresolvable %s relocation against symbol `%s'"),
3427              input_bfd,
3428              input_section,
3429              (uint64_t) rel->r_offset,
3430              howto->name,
3431              h->root.root.string);
3432           return false;
3433         }
3434
3435     do_relocation:
3436       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3437                                     contents, rel->r_offset,
3438                                     relocation, 0);
3439
3440     check_relocation_error:
3441       if (r != bfd_reloc_ok)
3442         {
3443           const char *name;
3444
3445           if (h != NULL)
3446             name = h->root.root.string;
3447           else
3448             {
3449               name = bfd_elf_string_from_elf_section (input_bfd,
3450                                                       symtab_hdr->sh_link,
3451                                                       sym->st_name);
3452               if (name == NULL)
3453                 return false;
3454               if (*name == '\0')
3455                 name = bfd_section_name (sec);
3456             }
3457
3458           if (r == bfd_reloc_overflow)
3459             (*info->callbacks->reloc_overflow)
3460               (info, (h ? &h->root : NULL), name, howto->name,
3461                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3462           else
3463             {
3464               _bfd_error_handler
3465                 /* xgettext:c-format */
3466                 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3467                  input_bfd, input_section,
3468                  (uint64_t) rel->r_offset, name, (int) r);
3469               return false;
3470             }
3471         }
3472
3473       if (wrel != rel)
3474         *wrel = *rel;
3475     }
3476
3477   if (wrel != rel)
3478     {
3479       Elf_Internal_Shdr *rel_hdr;
3480       size_t deleted = rel - wrel;
3481
3482       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3483       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3484       if (rel_hdr->sh_size == 0)
3485         {
3486           /* It is too late to remove an empty reloc section.  Leave
3487              one NONE reloc.
3488              ??? What is wrong with an empty section???  */
3489           rel_hdr->sh_size = rel_hdr->sh_entsize;
3490           deleted -= 1;
3491         }
3492       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3493       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3494       input_section->reloc_count -= deleted;
3495     }
3496
3497   return true;
3498 }
3499
3500 /* Finish up dynamic symbol handling.  We set the contents of various
3501    dynamic sections here.  */
3502
3503 static bool
3504 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3505                                 struct bfd_link_info *info,
3506                                 struct elf_link_hash_entry *h,
3507                                 Elf_Internal_Sym *sym)
3508 {
3509   struct elf_x86_link_hash_table *htab;
3510   unsigned plt_entry_size;
3511   struct elf_x86_link_hash_entry *eh;
3512   bool local_undefweak;
3513   bool use_plt_second;
3514
3515   htab = elf_x86_hash_table (info, I386_ELF_DATA);
3516   if (htab == NULL)
3517     return false;
3518
3519   plt_entry_size = htab->plt.plt_entry_size;
3520
3521   /* Use the second PLT section only if there is .plt section.  */
3522   use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3523
3524   eh = (struct elf_x86_link_hash_entry *) h;
3525   if (eh->no_finish_dynamic_symbol)
3526     abort ();
3527
3528   /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3529      resolved undefined weak symbols in executable so that their
3530      references have value 0 at run-time.  */
3531   local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3532
3533   if (h->plt.offset != (bfd_vma) -1)
3534     {
3535       bfd_vma plt_index, plt_offset;
3536       bfd_vma got_offset;
3537       Elf_Internal_Rela rel;
3538       bfd_byte *loc;
3539       asection *plt, *resolved_plt, *gotplt, *relplt;
3540
3541       /* When building a static executable, use .iplt, .igot.plt and
3542          .rel.iplt sections for STT_GNU_IFUNC symbols.  */
3543       if (htab->elf.splt != NULL)
3544         {
3545           plt = htab->elf.splt;
3546           gotplt = htab->elf.sgotplt;
3547           relplt = htab->elf.srelplt;
3548         }
3549       else
3550         {
3551           plt = htab->elf.iplt;
3552           gotplt = htab->elf.igotplt;
3553           relplt = htab->elf.irelplt;
3554         }
3555
3556       VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3557
3558       /* Get the index in the procedure linkage table which
3559          corresponds to this symbol.  This is the index of this symbol
3560          in all the symbols for which we are making plt entries.  The
3561          first entry in the procedure linkage table is reserved.
3562
3563          Get the offset into the .got table of the entry that
3564          corresponds to this function.  Each .got entry is 4 bytes.
3565          The first three are reserved.
3566
3567          For static executables, we don't reserve anything.  */
3568
3569       if (plt == htab->elf.splt)
3570         {
3571           got_offset = (h->plt.offset / plt_entry_size
3572                         - htab->plt.has_plt0);
3573           got_offset = (got_offset + 3) * 4;
3574         }
3575       else
3576         {
3577           got_offset = h->plt.offset / plt_entry_size;
3578           got_offset = got_offset * 4;
3579         }
3580
3581       /* Fill in the entry in the procedure linkage table and update
3582          the first slot.  */
3583       memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3584               plt_entry_size);
3585
3586       if (use_plt_second)
3587         {
3588           const bfd_byte *plt_entry;
3589           if (bfd_link_pic (info))
3590             plt_entry = htab->non_lazy_plt->pic_plt_entry;
3591           else
3592             plt_entry = htab->non_lazy_plt->plt_entry;
3593           memcpy (htab->plt_second->contents + eh->plt_second.offset,
3594                   plt_entry, htab->non_lazy_plt->plt_entry_size);
3595
3596           resolved_plt = htab->plt_second;
3597           plt_offset = eh->plt_second.offset;
3598         }
3599       else
3600         {
3601           resolved_plt = plt;
3602           plt_offset = h->plt.offset;
3603         }
3604
3605       if (! bfd_link_pic (info))
3606         {
3607           bfd_put_32 (output_bfd,
3608                       (gotplt->output_section->vma
3609                        + gotplt->output_offset
3610                        + got_offset),
3611                       resolved_plt->contents + plt_offset
3612                       + htab->plt.plt_got_offset);
3613
3614           if (htab->elf.target_os == is_vxworks)
3615             {
3616               int s, k, reloc_index;
3617
3618               /* Create the R_386_32 relocation referencing the GOT
3619                  for this PLT entry.  */
3620
3621               /* S: Current slot number (zero-based).  */
3622               s = ((h->plt.offset - htab->plt.plt_entry_size)
3623                    / htab->plt.plt_entry_size);
3624               /* K: Number of relocations for PLTResolve. */
3625               if (bfd_link_pic (info))
3626                 k = PLTRESOLVE_RELOCS_SHLIB;
3627               else
3628                 k = PLTRESOLVE_RELOCS;
3629               /* Skip the PLTresolve relocations, and the relocations for
3630                  the other PLT slots. */
3631               reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3632               loc = (htab->srelplt2->contents + reloc_index
3633                      * sizeof (Elf32_External_Rel));
3634
3635               rel.r_offset = (plt->output_section->vma
3636                               + plt->output_offset
3637                               + h->plt.offset + 2),
3638               rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
3639               bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3640
3641               /* Create the R_386_32 relocation referencing the beginning of
3642                  the PLT for this GOT entry.  */
3643               rel.r_offset = (htab->elf.sgotplt->output_section->vma
3644                               + htab->elf.sgotplt->output_offset
3645                               + got_offset);
3646               rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
3647               bfd_elf32_swap_reloc_out (output_bfd, &rel,
3648                                         loc + sizeof (Elf32_External_Rel));
3649             }
3650         }
3651       else
3652         {
3653           bfd_put_32 (output_bfd, got_offset,
3654                       resolved_plt->contents + plt_offset
3655                       + htab->plt.plt_got_offset);
3656         }
3657
3658       /* Fill in the entry in the global offset table.  Leave the entry
3659          as zero for undefined weak symbol in PIE.  No PLT relocation
3660          against undefined weak symbol in PIE.  */
3661       if (!local_undefweak)
3662         {
3663           if (htab->plt.has_plt0)
3664             bfd_put_32 (output_bfd,
3665                         (plt->output_section->vma
3666                          + plt->output_offset
3667                          + h->plt.offset
3668                          + htab->lazy_plt->plt_lazy_offset),
3669                         gotplt->contents + got_offset);
3670
3671           /* Fill in the entry in the .rel.plt section.  */
3672           rel.r_offset = (gotplt->output_section->vma
3673                           + gotplt->output_offset
3674                           + got_offset);
3675           if (PLT_LOCAL_IFUNC_P (info, h))
3676             {
3677               info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3678                                       h->root.root.string,
3679                                       h->root.u.def.section->owner);
3680
3681               /* If an STT_GNU_IFUNC symbol is locally defined, generate
3682                  R_386_IRELATIVE instead of R_386_JUMP_SLOT.  Store addend
3683                  in the .got.plt section.  */
3684               bfd_put_32 (output_bfd,
3685                           (h->root.u.def.value
3686                            + h->root.u.def.section->output_section->vma
3687                            + h->root.u.def.section->output_offset),
3688                           gotplt->contents + got_offset);
3689               rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3690
3691               if (htab->params->report_relative_reloc)
3692                 _bfd_x86_elf_link_report_relative_reloc
3693                   (info, relplt, h, sym, "R_386_IRELATIVE", &rel);
3694
3695               /* R_386_IRELATIVE comes last.  */
3696               plt_index = htab->next_irelative_index--;
3697             }
3698           else
3699             {
3700               rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3701               plt_index = htab->next_jump_slot_index++;
3702             }
3703
3704           loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
3705           bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3706
3707           /* Don't fill the second and third slots in PLT entry for
3708              static executables nor without PLT0.  */
3709           if (plt == htab->elf.splt && htab->plt.has_plt0)
3710             {
3711               bfd_put_32 (output_bfd,
3712                           plt_index * sizeof (Elf32_External_Rel),
3713                           plt->contents + h->plt.offset
3714                           + htab->lazy_plt->plt_reloc_offset);
3715               bfd_put_32 (output_bfd,
3716                           - (h->plt.offset
3717                              + htab->lazy_plt->plt_plt_offset + 4),
3718                           (plt->contents + h->plt.offset
3719                            + htab->lazy_plt->plt_plt_offset));
3720             }
3721         }
3722     }
3723   else if (eh->plt_got.offset != (bfd_vma) -1)
3724     {
3725       bfd_vma got_offset, plt_offset;
3726       asection *plt, *got, *gotplt;
3727       const bfd_byte *got_plt_entry;
3728
3729       /* Set the entry in the GOT procedure linkage table.  */
3730       plt = htab->plt_got;
3731       got = htab->elf.sgot;
3732       gotplt = htab->elf.sgotplt;
3733       got_offset = h->got.offset;
3734
3735       if (got_offset == (bfd_vma) -1
3736           || plt == NULL
3737           || got == NULL
3738           || gotplt == NULL)
3739         abort ();
3740
3741       /* Fill in the entry in the GOT procedure linkage table.  */
3742       if (! bfd_link_pic (info))
3743         {
3744           got_plt_entry = htab->non_lazy_plt->plt_entry;
3745           got_offset += got->output_section->vma + got->output_offset;
3746         }
3747       else
3748         {
3749           got_plt_entry = htab->non_lazy_plt->pic_plt_entry;
3750           got_offset += (got->output_section->vma
3751                          + got->output_offset
3752                          - gotplt->output_section->vma
3753                          - gotplt->output_offset);
3754         }
3755
3756       plt_offset = eh->plt_got.offset;
3757       memcpy (plt->contents + plt_offset, got_plt_entry,
3758               htab->non_lazy_plt->plt_entry_size);
3759       bfd_put_32 (output_bfd, got_offset,
3760                   (plt->contents + plt_offset
3761                    + htab->non_lazy_plt->plt_got_offset));
3762     }
3763
3764   if (!local_undefweak
3765       && !h->def_regular
3766       && (h->plt.offset != (bfd_vma) -1
3767           || eh->plt_got.offset != (bfd_vma) -1))
3768     {
3769       /* Mark the symbol as undefined, rather than as defined in
3770          the .plt section.  Leave the value if there were any
3771          relocations where pointer equality matters (this is a clue
3772          for the dynamic linker, to make function pointer
3773          comparisons work between an application and shared
3774          library), otherwise set it to zero.  If a function is only
3775          called from a binary, there is no need to slow down
3776          shared libraries because of that.  */
3777       sym->st_shndx = SHN_UNDEF;
3778       if (!h->pointer_equality_needed)
3779         sym->st_value = 0;
3780     }
3781
3782   _bfd_x86_elf_link_fixup_ifunc_symbol (info, htab, h, sym);
3783
3784   /* Don't generate dynamic GOT relocation against undefined weak
3785      symbol in executable.  */
3786   if (h->got.offset != (bfd_vma) -1
3787       && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry(h)->tls_type)
3788       && (elf_x86_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
3789       && !local_undefweak)
3790     {
3791       Elf_Internal_Rela rel;
3792       asection *relgot = htab->elf.srelgot;
3793       const char *relative_reloc_name = NULL;
3794
3795       /* This symbol has an entry in the global offset table.  Set it
3796          up.  */
3797
3798       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3799         abort ();
3800
3801       rel.r_offset = (htab->elf.sgot->output_section->vma
3802                       + htab->elf.sgot->output_offset
3803                       + (h->got.offset & ~(bfd_vma) 1));
3804
3805       /* If this is a static link, or it is a -Bsymbolic link and the
3806          symbol is defined locally or was forced to be local because
3807          of a version file, we just want to emit a RELATIVE reloc.
3808          The entry in the global offset table will already have been
3809          initialized in the relocate_section function.  */
3810       if (h->def_regular
3811           && h->type == STT_GNU_IFUNC)
3812         {
3813           if (h->plt.offset == (bfd_vma) -1)
3814             {
3815               /* STT_GNU_IFUNC is referenced without PLT.  */
3816               if (htab->elf.splt == NULL)
3817                 {
3818                   /* use .rel[a].iplt section to store .got relocations
3819                      in static executable.  */
3820                   relgot = htab->elf.irelplt;
3821                 }
3822               if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3823                 {
3824                   info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
3825                                           h->root.root.string,
3826                                           h->root.u.def.section->owner);
3827
3828                   bfd_put_32 (output_bfd,
3829                               (h->root.u.def.value
3830                                + h->root.u.def.section->output_section->vma
3831                                + h->root.u.def.section->output_offset),
3832                               htab->elf.sgot->contents + h->got.offset);
3833                   rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3834                   relative_reloc_name = "R_386_IRELATIVE";
3835                 }
3836               else
3837                 goto do_glob_dat;
3838             }
3839           else if (bfd_link_pic (info))
3840             {
3841               /* Generate R_386_GLOB_DAT.  */
3842               goto do_glob_dat;
3843             }
3844           else
3845             {
3846               asection *plt;
3847               bfd_vma plt_offset;
3848
3849               if (!h->pointer_equality_needed)
3850                 abort ();
3851
3852               /* For non-shared object, we can't use .got.plt, which
3853                  contains the real function addres if we need pointer
3854                  equality.  We load the GOT entry with the PLT entry.  */
3855               if (htab->plt_second != NULL)
3856                 {
3857                   plt = htab->plt_second;
3858                   plt_offset = eh->plt_second.offset;
3859                 }
3860               else
3861                 {
3862                   plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3863                   plt_offset = h->plt.offset;
3864                 }
3865               bfd_put_32 (output_bfd,
3866                           (plt->output_section->vma
3867                            + plt->output_offset + plt_offset),
3868                           htab->elf.sgot->contents + h->got.offset);
3869               return true;
3870             }
3871         }
3872       else if (bfd_link_pic (info)
3873                && SYMBOL_REFERENCES_LOCAL_P (info, h))
3874         {
3875           BFD_ASSERT((h->got.offset & 1) != 0);
3876           rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3877           relative_reloc_name = "R_386_RELATIVE";
3878         }
3879       else
3880         {
3881           BFD_ASSERT((h->got.offset & 1) == 0);
3882         do_glob_dat:
3883           bfd_put_32 (output_bfd, (bfd_vma) 0,
3884                       htab->elf.sgot->contents + h->got.offset);
3885           rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3886         }
3887
3888       if (relative_reloc_name != NULL
3889           && htab->params->report_relative_reloc)
3890         _bfd_x86_elf_link_report_relative_reloc
3891           (info, relgot, h, sym, relative_reloc_name, &rel);
3892
3893       elf_append_rel (output_bfd, relgot, &rel);
3894     }
3895
3896   if (h->needs_copy)
3897     {
3898       Elf_Internal_Rela rel;
3899       asection *s;
3900
3901       /* This symbol needs a copy reloc.  Set it up.  */
3902       VERIFY_COPY_RELOC (h, htab)
3903
3904       rel.r_offset = (h->root.u.def.value
3905                       + h->root.u.def.section->output_section->vma
3906                       + h->root.u.def.section->output_offset);
3907       rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3908       if (h->root.u.def.section == htab->elf.sdynrelro)
3909         s = htab->elf.sreldynrelro;
3910       else
3911         s = htab->elf.srelbss;
3912       elf_append_rel (output_bfd, s, &rel);
3913     }
3914
3915   return true;
3916 }
3917
3918 /* Finish up local dynamic symbol handling.  We set the contents of
3919    various dynamic sections here.  */
3920
3921 static int
3922 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
3923 {
3924   struct elf_link_hash_entry *h
3925     = (struct elf_link_hash_entry *) *slot;
3926   struct bfd_link_info *info
3927     = (struct bfd_link_info *) inf;
3928
3929   return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
3930                                          h, NULL);
3931 }
3932
3933 /* Finish up undefined weak symbol handling in PIE.  Fill its PLT entry
3934    here since undefined weak symbol may not be dynamic and may not be
3935    called for elf_i386_finish_dynamic_symbol.  */
3936
3937 static bool
3938 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
3939                                       void *inf)
3940 {
3941   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
3942   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3943
3944   if (h->root.type != bfd_link_hash_undefweak
3945       || h->dynindx != -1)
3946     return true;
3947
3948   return elf_i386_finish_dynamic_symbol (info->output_bfd,
3949                                          info, h, NULL);
3950 }
3951
3952 /* Used to decide how to sort relocs in an optimal manner for the
3953    dynamic linker, before writing them out.  */
3954
3955 static enum elf_reloc_type_class
3956 elf_i386_reloc_type_class (const struct bfd_link_info *info,
3957                            const asection *rel_sec ATTRIBUTE_UNUSED,
3958                            const Elf_Internal_Rela *rela)
3959 {
3960   bfd *abfd = info->output_bfd;
3961   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3962   struct elf_link_hash_table *htab = elf_hash_table (info);
3963
3964   if (htab->dynsym != NULL
3965       && htab->dynsym->contents != NULL)
3966     {
3967       /* Check relocation against STT_GNU_IFUNC symbol if there are
3968          dynamic symbols.  */
3969       unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3970       if (r_symndx != STN_UNDEF)
3971         {
3972           Elf_Internal_Sym sym;
3973           if (!bed->s->swap_symbol_in (abfd,
3974                                        (htab->dynsym->contents
3975                                         + r_symndx * sizeof (Elf32_External_Sym)),
3976                                        0, &sym))
3977             abort ();
3978
3979           if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3980             return reloc_class_ifunc;
3981         }
3982     }
3983
3984   switch (ELF32_R_TYPE (rela->r_info))
3985     {
3986     case R_386_IRELATIVE:
3987       return reloc_class_ifunc;
3988     case R_386_RELATIVE:
3989       return reloc_class_relative;
3990     case R_386_JUMP_SLOT:
3991       return reloc_class_plt;
3992     case R_386_COPY:
3993       return reloc_class_copy;
3994     default:
3995       return reloc_class_normal;
3996     }
3997 }
3998
3999 /* Finish up the dynamic sections.  */
4000
4001 static bool
4002 elf_i386_finish_dynamic_sections (bfd *output_bfd,
4003                                   struct bfd_link_info *info)
4004 {
4005   struct elf_x86_link_hash_table *htab;
4006
4007   htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
4008   if (htab == NULL)
4009     return false;
4010
4011   if (!htab->elf.dynamic_sections_created)
4012     return true;
4013
4014   if (htab->elf.splt && htab->elf.splt->size > 0)
4015     {
4016       /* UnixWare sets the entsize of .plt to 4, although that doesn't
4017          really seem like the right value.  */
4018       elf_section_data (htab->elf.splt->output_section)
4019         ->this_hdr.sh_entsize = 4;
4020
4021       if (htab->plt.has_plt0)
4022         {
4023           /* Fill in the special first entry in the procedure linkage
4024              table.  */
4025           memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
4026                   htab->lazy_plt->plt0_entry_size);
4027           memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
4028                   htab->plt0_pad_byte,
4029                   htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
4030           if (!bfd_link_pic (info))
4031             {
4032               bfd_put_32 (output_bfd,
4033                           (htab->elf.sgotplt->output_section->vma
4034                            + htab->elf.sgotplt->output_offset
4035                            + 4),
4036                           htab->elf.splt->contents
4037                           + htab->lazy_plt->plt0_got1_offset);
4038               bfd_put_32 (output_bfd,
4039                           (htab->elf.sgotplt->output_section->vma
4040                            + htab->elf.sgotplt->output_offset
4041                            + 8),
4042                           htab->elf.splt->contents
4043                           + htab->lazy_plt->plt0_got2_offset);
4044
4045               if (htab->elf.target_os == is_vxworks)
4046                 {
4047                   Elf_Internal_Rela rel;
4048                   int num_plts = (htab->elf.splt->size
4049                                   / htab->plt.plt_entry_size) - 1;
4050                   unsigned char *p;
4051                   asection *srelplt2 = htab->srelplt2;
4052
4053                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4054                      + 4.  On IA32 we use REL relocations so the
4055                      addend goes in the PLT directly.  */
4056                   rel.r_offset = (htab->elf.splt->output_section->vma
4057                                   + htab->elf.splt->output_offset
4058                                   + htab->lazy_plt->plt0_got1_offset);
4059                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4060                                              R_386_32);
4061                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4062                                             srelplt2->contents);
4063                   /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
4064                      + 8.  */
4065                   rel.r_offset = (htab->elf.splt->output_section->vma
4066                                   + htab->elf.splt->output_offset
4067                                   + htab->lazy_plt->plt0_got2_offset);
4068                   rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4069                                              R_386_32);
4070                   bfd_elf32_swap_reloc_out (output_bfd, &rel,
4071                                             srelplt2->contents +
4072                                             sizeof (Elf32_External_Rel));
4073                   /* Correct the .rel.plt.unloaded relocations.  */
4074                   p = srelplt2->contents;
4075                   if (bfd_link_pic (info))
4076                     p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4077                   else
4078                     p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4079
4080                   for (; num_plts; num_plts--)
4081                     {
4082                       bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4083                       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
4084                                                  R_386_32);
4085                       bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4086                       p += sizeof (Elf32_External_Rel);
4087
4088                       bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
4089                       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
4090                                                  R_386_32);
4091                       bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4092                       p += sizeof (Elf32_External_Rel);
4093                     }
4094                 }
4095             }
4096         }
4097     }
4098
4099   /* Fill PLT entries for undefined weak symbols in PIE.  */
4100   if (bfd_link_pie (info))
4101     bfd_hash_traverse (&info->hash->table,
4102                        elf_i386_pie_finish_undefweak_symbol,
4103                        info);
4104
4105   return true;
4106 }
4107
4108 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4109    STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4110    It has to be done before elf_link_sort_relocs is called so that
4111    dynamic relocations are properly sorted.  */
4112
4113 static bool
4114 elf_i386_output_arch_local_syms
4115   (bfd *output_bfd ATTRIBUTE_UNUSED,
4116    struct bfd_link_info *info,
4117    void *flaginfo ATTRIBUTE_UNUSED,
4118    int (*func) (void *, const char *,
4119                 Elf_Internal_Sym *,
4120                 asection *,
4121                 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4122 {
4123   struct elf_x86_link_hash_table *htab
4124     = elf_x86_hash_table (info, I386_ELF_DATA);
4125   if (htab == NULL)
4126     return false;
4127
4128   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4129   htab_traverse (htab->loc_hash_table,
4130                  elf_i386_finish_local_dynamic_symbol,
4131                  info);
4132
4133   return true;
4134 }
4135
4136 /* Similar to _bfd_elf_get_synthetic_symtab.  Support PLTs with all
4137    dynamic relocations.   */
4138
4139 static long
4140 elf_i386_get_synthetic_symtab (bfd *abfd,
4141                                long symcount ATTRIBUTE_UNUSED,
4142                                asymbol **syms ATTRIBUTE_UNUSED,
4143                                long dynsymcount,
4144                                asymbol **dynsyms,
4145                                asymbol **ret)
4146 {
4147   long count, i, n;
4148   int j;
4149   bfd_byte *plt_contents;
4150   long relsize;
4151   const struct elf_x86_lazy_plt_layout *lazy_plt;
4152   const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4153   const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4154   const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4155   asection *plt;
4156   bfd_vma got_addr;
4157   enum elf_x86_plt_type plt_type;
4158   struct elf_x86_plt plts[] =
4159     {
4160       { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4161       { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4162       { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4163       { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4164     };
4165
4166   *ret = NULL;
4167
4168   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4169     return 0;
4170
4171   if (dynsymcount <= 0)
4172     return 0;
4173
4174   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4175   if (relsize <= 0)
4176     return -1;
4177
4178   non_lazy_plt = NULL;
4179   /* Silence GCC 6.  */
4180   lazy_plt = NULL;
4181   non_lazy_ibt_plt = NULL;
4182   lazy_ibt_plt = NULL;
4183   switch (get_elf_backend_data (abfd)->target_os)
4184     {
4185     case is_normal:
4186     case is_solaris:
4187       non_lazy_plt = &elf_i386_non_lazy_plt;
4188       lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4189       non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4190       /* Fall through */
4191     case is_vxworks:
4192       lazy_plt = &elf_i386_lazy_plt;
4193       break;
4194     default:
4195       abort ();
4196     }
4197
4198   got_addr = 0;
4199
4200   count = 0;
4201   for (j = 0; plts[j].name != NULL; j++)
4202     {
4203       plt = bfd_get_section_by_name (abfd, plts[j].name);
4204       if (plt == NULL || plt->size == 0)
4205         continue;
4206
4207       /* Get the PLT section contents.  */
4208       plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4209       if (plt_contents == NULL)
4210         break;
4211       if (!bfd_get_section_contents (abfd, (asection *) plt,
4212                                      plt_contents, 0, plt->size))
4213         {
4214           free (plt_contents);
4215           break;
4216         }
4217
4218       /* Check what kind of PLT it is.  */
4219       plt_type = plt_unknown;
4220       if (plts[j].type == plt_unknown
4221           && (plt->size >= (lazy_plt->plt0_entry_size
4222                             + lazy_plt->plt_entry_size)))
4223         {
4224           /* Match lazy PLT first.  */
4225           if (memcmp (plt_contents, lazy_plt->plt0_entry,
4226                       lazy_plt->plt0_got1_offset) == 0)
4227             {
4228               /* The fist entry in the lazy IBT PLT is the same as the
4229                  normal lazy PLT.  */
4230               if (lazy_ibt_plt != NULL
4231                   && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4232                               lazy_ibt_plt->plt_entry,
4233                               lazy_ibt_plt->plt_got_offset) == 0))
4234                 plt_type = plt_lazy | plt_second;
4235               else
4236                 plt_type = plt_lazy;
4237             }
4238           else if (memcmp (plt_contents, lazy_plt->pic_plt0_entry,
4239                            lazy_plt->plt0_got1_offset) == 0)
4240             {
4241               /* The fist entry in the PIC lazy IBT PLT is the same as
4242                  the normal PIC lazy PLT.  */
4243               if (lazy_ibt_plt != NULL
4244                   && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
4245                               lazy_ibt_plt->pic_plt_entry,
4246                               lazy_ibt_plt->plt_got_offset) == 0))
4247                 plt_type = plt_lazy | plt_pic | plt_second;
4248               else
4249                 plt_type = plt_lazy | plt_pic;
4250             }
4251         }
4252
4253       if (non_lazy_plt != NULL
4254           && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4255           && plt->size >= non_lazy_plt->plt_entry_size)
4256         {
4257           /* Match non-lazy PLT.  */
4258           if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4259                       non_lazy_plt->plt_got_offset) == 0)
4260             plt_type = plt_non_lazy;
4261           else if (memcmp (plt_contents, non_lazy_plt->pic_plt_entry,
4262                            non_lazy_plt->plt_got_offset) == 0)
4263             plt_type = plt_pic;
4264         }
4265
4266       if ((non_lazy_ibt_plt != NULL)
4267           && (plt_type == plt_unknown || plt_type == plt_second)
4268           && plt->size >= non_lazy_ibt_plt->plt_entry_size)
4269         {
4270           if (memcmp (plt_contents,
4271                       non_lazy_ibt_plt->plt_entry,
4272                       non_lazy_ibt_plt->plt_got_offset) == 0)
4273             {
4274               /* Match IBT PLT.  */
4275               plt_type = plt_second;
4276               non_lazy_plt = non_lazy_ibt_plt;
4277             }
4278           else if (memcmp (plt_contents,
4279                            non_lazy_ibt_plt->pic_plt_entry,
4280                            non_lazy_ibt_plt->plt_got_offset) == 0)
4281             {
4282               /* Match PIC IBT PLT.  */
4283               plt_type = plt_second | plt_pic;
4284               non_lazy_plt = non_lazy_ibt_plt;
4285             }
4286         }
4287
4288       if (plt_type == plt_unknown)
4289         {
4290           free (plt_contents);
4291           continue;
4292         }
4293
4294       plts[j].sec = plt;
4295       plts[j].type = plt_type;
4296
4297       if ((plt_type & plt_lazy))
4298         {
4299           plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4300           plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4301           /* Skip PLT0 in lazy PLT.  */
4302           i = 1;
4303         }
4304       else
4305         {
4306           plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4307           plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4308           i = 0;
4309         }
4310
4311       /* Skip lazy PLT when the second PLT is used.  */
4312       if ((plt_type & (plt_lazy | plt_second))
4313           == (plt_lazy | plt_second))
4314         plts[j].count = 0;
4315       else
4316         {
4317           n = plt->size / plts[j].plt_entry_size;
4318           plts[j].count = n;
4319           count += n - i;
4320         }
4321
4322       plts[j].contents = plt_contents;
4323
4324       /* The _GLOBAL_OFFSET_TABLE_ address is needed.  */
4325       if ((plt_type & plt_pic))
4326         got_addr = (bfd_vma) -1;
4327     }
4328
4329   return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4330                                             got_addr, plts, dynsyms,
4331                                             ret);
4332 }
4333
4334 /* Set up i386 GNU properties.  Return the first relocatable ELF input
4335    with GNU properties if found.  Otherwise, return NULL.  */
4336
4337 static bfd *
4338 elf_i386_link_setup_gnu_properties (struct bfd_link_info *info)
4339 {
4340   struct elf_x86_init_table init_table;
4341
4342   switch (get_elf_backend_data (info->output_bfd)->target_os)
4343     {
4344     case is_normal:
4345     case is_solaris:
4346       init_table.plt0_pad_byte = 0x0;
4347       init_table.lazy_plt = &elf_i386_lazy_plt;
4348       init_table.non_lazy_plt = &elf_i386_non_lazy_plt;
4349       init_table.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
4350       init_table.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
4351       break;
4352     case is_vxworks:
4353       init_table.plt0_pad_byte = 0x90;
4354       init_table.lazy_plt = &elf_i386_lazy_plt;
4355       init_table.non_lazy_plt = NULL;
4356       init_table.lazy_ibt_plt = NULL;
4357       init_table.non_lazy_ibt_plt = NULL;
4358       break;
4359     default:
4360       abort ();
4361     }
4362
4363   init_table.r_info = elf32_r_info;
4364   init_table.r_sym = elf32_r_sym;
4365
4366   return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4367 }
4368
4369 #define TARGET_LITTLE_SYM               i386_elf32_vec
4370 #define TARGET_LITTLE_NAME              "elf32-i386"
4371 #define ELF_ARCH                        bfd_arch_i386
4372 #define ELF_TARGET_ID                   I386_ELF_DATA
4373 #define ELF_MACHINE_CODE                EM_386
4374 #define ELF_MAXPAGESIZE                 0x1000
4375
4376 #define elf_backend_can_gc_sections     1
4377 #define elf_backend_can_refcount        1
4378 #define elf_backend_want_got_plt        1
4379 #define elf_backend_plt_readonly        1
4380 #define elf_backend_want_plt_sym        0
4381 #define elf_backend_got_header_size     12
4382 #define elf_backend_plt_alignment       4
4383 #define elf_backend_dtrel_excludes_plt  1
4384 #define elf_backend_extern_protected_data 1
4385 #define elf_backend_caches_rawsize      1
4386 #define elf_backend_want_dynrelro       1
4387
4388 /* Support RELA for objdump of prelink objects.  */
4389 #define elf_info_to_howto                     elf_i386_info_to_howto_rel
4390 #define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
4391
4392 #define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
4393 #define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
4394 #define bfd_elf32_bfd_reloc_name_lookup       elf_i386_reloc_name_lookup
4395 #define bfd_elf32_get_synthetic_symtab        elf_i386_get_synthetic_symtab
4396
4397 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
4398 #define elf_backend_check_relocs              elf_i386_check_relocs
4399 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
4400 #define elf_backend_fake_sections             elf_i386_fake_sections
4401 #define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
4402 #define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
4403 #define elf_backend_output_arch_local_syms     elf_i386_output_arch_local_syms
4404 #define elf_backend_grok_prstatus             elf_i386_grok_prstatus
4405 #define elf_backend_grok_psinfo               elf_i386_grok_psinfo
4406 #define elf_backend_reloc_type_class          elf_i386_reloc_type_class
4407 #define elf_backend_relocate_section          elf_i386_relocate_section
4408 #define elf_backend_setup_gnu_properties      elf_i386_link_setup_gnu_properties
4409 #define elf_backend_hide_symbol               _bfd_x86_elf_hide_symbol
4410
4411 #define elf_backend_linux_prpsinfo32_ugid16     true
4412
4413 #define elf32_bed                             elf32_i386_bed
4414
4415 #include "elf32-target.h"
4416
4417 /* FreeBSD support.  */
4418
4419 #undef  TARGET_LITTLE_SYM
4420 #define TARGET_LITTLE_SYM               i386_elf32_fbsd_vec
4421 #undef  TARGET_LITTLE_NAME
4422 #define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
4423 #undef  ELF_OSABI
4424 #define ELF_OSABI                       ELFOSABI_FREEBSD
4425
4426 /* The kernel recognizes executables as valid only if they carry a
4427    "FreeBSD" label in the ELF header.  So we put this label on all
4428    executables and (for simplicity) also all other object files.  */
4429
4430 static bool
4431 elf_i386_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
4432 {
4433   if (!_bfd_elf_init_file_header (abfd, info))
4434     return false;
4435
4436 #ifdef OLD_FREEBSD_ABI_LABEL
4437   {
4438     /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
4439     Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4440     memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
4441   }
4442 #endif
4443   return true;
4444 }
4445
4446 #undef  elf_backend_init_file_header
4447 #define elf_backend_init_file_header    elf_i386_fbsd_init_file_header
4448 #undef  elf32_bed
4449 #define elf32_bed                               elf32_i386_fbsd_bed
4450
4451 #undef elf_backend_add_symbol_hook
4452
4453 #include "elf32-target.h"
4454
4455 #undef elf_backend_init_file_header
4456
4457 /* Solaris 2.  */
4458
4459 #undef  TARGET_LITTLE_SYM
4460 #define TARGET_LITTLE_SYM               i386_elf32_sol2_vec
4461 #undef  TARGET_LITTLE_NAME
4462 #define TARGET_LITTLE_NAME              "elf32-i386-sol2"
4463
4464 #undef  ELF_TARGET_OS
4465 #define ELF_TARGET_OS                   is_solaris
4466
4467 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4468    objects won't be recognized.  */
4469 #undef ELF_OSABI
4470
4471 #undef  elf32_bed
4472 #define elf32_bed                       elf32_i386_sol2_bed
4473
4474 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
4475    boundary.  */
4476 #undef  elf_backend_static_tls_alignment
4477 #define elf_backend_static_tls_alignment 8
4478
4479 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4480
4481    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4482    File, p.63.  */
4483 #undef  elf_backend_want_plt_sym
4484 #define elf_backend_want_plt_sym        1
4485
4486 #undef  elf_backend_strtab_flags
4487 #define elf_backend_strtab_flags        SHF_STRINGS
4488
4489 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
4490    has a type >= SHT_LOOS.  Returns TRUE if these fields were initialised
4491    FALSE otherwise.  ISECTION is the best guess matching section from the
4492    input bfd IBFD, but it might be NULL.  */
4493
4494 static bool
4495 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
4496                                                 bfd *obfd ATTRIBUTE_UNUSED,
4497                                                 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
4498                                                 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
4499 {
4500   /* PR 19938: FIXME: Need to add code for setting the sh_info
4501      and sh_link fields of Solaris specific section types.  */
4502   return false;
4503
4504   /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
4505      Object File Format, Table 13-9  ELF sh_link and sh_info Interpretation:
4506
4507 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
4508
4509      The following values should be set:
4510
4511 Type                 Link                           Info
4512 -----------------------------------------------------------------------------
4513 SHT_SUNW_ancillary   The section header index of    0
4514  [0x6fffffee]        the associated string table.
4515
4516 SHT_SUNW_capinfo     The section header index of    For a dynamic object, the
4517  [0x6ffffff0]        the associated symbol table.   section header index of
4518                                                     the associated
4519                                                     SHT_SUNW_capchain table,
4520                                                     otherwise 0.
4521
4522 SHT_SUNW_symsort     The section header index of    0
4523  [0x6ffffff1]        the associated symbol table.
4524
4525 SHT_SUNW_tlssort     The section header index of    0
4526  [0x6ffffff2]        the associated symbol table.
4527
4528 SHT_SUNW_LDYNSYM     The section header index of    One greater than the
4529  [0x6ffffff3]        the associated string table.   symbol table index of the
4530                      This index is the same string  last local symbol,
4531                      table used by the SHT_DYNSYM   STB_LOCAL. Since
4532                      section.                       SHT_SUNW_LDYNSYM only
4533                                                     contains local symbols,
4534                                                     sh_info is equivalent to
4535                                                     the number of symbols in
4536                                                     the table.
4537
4538 SHT_SUNW_cap         If symbol capabilities exist,  If any capabilities refer
4539  [0x6ffffff5]        the section header index of    to named strings, the
4540                      the associated                 section header index of
4541                      SHT_SUNW_capinfo table,        the associated string
4542                           otherwise 0.              table, otherwise 0.
4543
4544 SHT_SUNW_move        The section header index of    0
4545  [0x6ffffffa]        the associated symbol table.
4546
4547 SHT_SUNW_COMDAT      0                              0
4548  [0x6ffffffb]
4549
4550 SHT_SUNW_syminfo     The section header index of    The section header index
4551  [0x6ffffffc]        the associated symbol table.   of the associated
4552                                                     .dynamic section.
4553
4554 SHT_SUNW_verdef      The section header index of    The number of version
4555  [0x6ffffffd]        the associated string table.   definitions within the
4556                                                     section.
4557
4558 SHT_SUNW_verneed     The section header index of    The number of version
4559  [0x6ffffffe]        the associated string table.   dependencies within the
4560                                                     section.
4561
4562 SHT_SUNW_versym      The section header index of    0
4563  [0x6fffffff]        the associated symbol table.  */
4564 }
4565
4566 #undef  elf_backend_copy_special_section_fields
4567 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
4568
4569 #include "elf32-target.h"
4570
4571 /* Intel MCU support.  */
4572
4573 static bool
4574 elf32_iamcu_elf_object_p (bfd *abfd)
4575 {
4576   /* Set the right machine number for an IAMCU elf32 file.  */
4577   bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
4578   return true;
4579 }
4580
4581 #undef  TARGET_LITTLE_SYM
4582 #define TARGET_LITTLE_SYM               iamcu_elf32_vec
4583 #undef  TARGET_LITTLE_NAME
4584 #define TARGET_LITTLE_NAME              "elf32-iamcu"
4585 #undef  ELF_ARCH
4586 #define ELF_ARCH                        bfd_arch_iamcu
4587
4588 #undef  ELF_MACHINE_CODE
4589 #define ELF_MACHINE_CODE                EM_IAMCU
4590
4591 #undef  ELF_TARGET_OS
4592 #undef  ELF_OSABI
4593
4594 #undef  elf32_bed
4595 #define elf32_bed                       elf32_iamcu_bed
4596
4597 #undef  elf_backend_object_p
4598 #define elf_backend_object_p            elf32_iamcu_elf_object_p
4599
4600 #undef  elf_backend_static_tls_alignment
4601
4602 #undef  elf_backend_want_plt_sym
4603 #define elf_backend_want_plt_sym        0
4604
4605 #undef  elf_backend_strtab_flags
4606 #undef  elf_backend_copy_special_section_fields
4607
4608 #include "elf32-target.h"
4609
4610 /* Restore defaults.  */
4611 #undef  ELF_ARCH
4612 #define ELF_ARCH                        bfd_arch_i386
4613 #undef  ELF_MACHINE_CODE
4614 #define ELF_MACHINE_CODE                EM_386
4615 #undef  elf_backend_object_p
4616
4617 /* VxWorks support.  */
4618
4619 #undef  TARGET_LITTLE_SYM
4620 #define TARGET_LITTLE_SYM               i386_elf32_vxworks_vec
4621 #undef  TARGET_LITTLE_NAME
4622 #define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
4623 #undef  ELF_OSABI
4624 #undef  ELF_MAXPAGESIZE
4625 #define ELF_MAXPAGESIZE                 0x1000
4626 #undef  elf_backend_plt_alignment
4627 #define elf_backend_plt_alignment       4
4628
4629 #undef  ELF_TARGET_OS
4630 #define ELF_TARGET_OS           is_vxworks
4631
4632 #undef elf_backend_relocs_compatible
4633 #undef elf_backend_add_symbol_hook
4634 #define elf_backend_add_symbol_hook \
4635   elf_vxworks_add_symbol_hook
4636 #undef elf_backend_link_output_symbol_hook
4637 #define elf_backend_link_output_symbol_hook \
4638   elf_vxworks_link_output_symbol_hook
4639 #undef elf_backend_emit_relocs
4640 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
4641 #undef elf_backend_final_write_processing
4642 #define elf_backend_final_write_processing \
4643   elf_vxworks_final_write_processing
4644 #undef elf_backend_static_tls_alignment
4645
4646 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4647    define it.  */
4648 #undef elf_backend_want_plt_sym
4649 #define elf_backend_want_plt_sym        1
4650
4651 #undef  elf32_bed
4652 #define elf32_bed                               elf32_i386_vxworks_bed
4653
4654 #include "elf32-target.h"