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