bfd/elf32-i386.c

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