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