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