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