Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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