bfd/elf32-i386.c

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