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