bfd/elf32-i386.c

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