bfd/elf32-i386.c

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