bfd/elf32-i386.c

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