bfd/elf32-i386.c

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