bfd/elf32-i386.c

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