Subversion Repositories Kolibri OS

Rev

Rev 5197 | Blame | Compare with Previous | Last modification | View Log | RSS feed

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