projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* read.c (read_a_source_file): Rearrange evaluation order when
[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
252b5132 1196/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1197 calculate needed space in the global offset table, procedure linkage
1198 table, and dynamic reloc sections. */
252b5132 1199
b34976b6 1200static bfd_boolean
55fd94b0
AM		 1201elf_i386_check_relocs (bfd *abfd,
1202 struct bfd_link_info *info,
1203 asection *sec,
1204 const Elf_Internal_Rela *relocs)
252b5132 1205{
6725bdbf 1206 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1207 Elf_Internal_Shdr *symtab_hdr;
1208 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1209 const Elf_Internal_Rela *rel;
1210 const Elf_Internal_Rela *rel_end;
252b5132
RH		 1211 asection *sreloc;
1212
1049f94e 1213 if (info->relocatable)
b34976b6 1214 return TRUE;
252b5132 1215
0ffa91dd
NC		 1216 BFD_ASSERT (is_i386_elf (abfd));
1217
6725bdbf 1218 htab = elf_i386_hash_table (info);
0ffa91dd 1219 symtab_hdr = &elf_symtab_hdr (abfd);
252b5132 1220 sym_hashes = elf_sym_hashes (abfd);
252b5132 1221
252b5132
RH		 1222 sreloc = NULL;
1223
1224 rel_end = relocs + sec->reloc_count;
1225 for (rel = relocs; rel < rel_end; rel++)
1226 {
13ae64f3 1227 unsigned int r_type;
252b5132
RH		 1228 unsigned long r_symndx;
1229 struct elf_link_hash_entry *h;
1230
1231 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1232 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1233
d9bc7a44 1234 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1235 {
d003868e
AM		 1236 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1237 abfd,
8f615d07 1238 r_symndx);
b34976b6 1239 return FALSE;
f5f31454
L		 1240 }
1241
252b5132
RH		 1242 if (r_symndx < symtab_hdr->sh_info)
1243 h = NULL;
1244 else
71cb9464
L		 1245 {
1246 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1247 while (h->root.type == bfd_link_hash_indirect
1248 || h->root.type == bfd_link_hash_warning)
1249 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1250 }
252b5132 1251
142411ca
L		 1252 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1253 symtab_hdr, sym_hashes,
1254 &r_type, GOT_UNKNOWN,
1255 rel, rel_end, h))
1256 return FALSE;
13ae64f3
JJ		 1257
1258 switch (r_type)
252b5132 1259 {
37e55690
JJ		 1260 case R_386_TLS_LDM:
1261 htab->tls_ldm_got.refcount += 1;
1262 goto create_got;
1263
1264 case R_386_PLT32:
1265 /* This symbol requires a procedure linkage table entry. We
1266 actually build the entry in adjust_dynamic_symbol,
1267 because this might be a case of linking PIC code which is
1268 never referenced by a dynamic object, in which case we
1269 don't need to generate a procedure linkage table entry
1270 after all. */
1271
1272 /* If this is a local symbol, we resolve it directly without
1273 creating a procedure linkage table entry. */
1274 if (h == NULL)
1275 continue;
1276
f5385ebf 1277 h->needs_plt = 1;
37e55690
JJ		 1278 h->plt.refcount += 1;
1279 break;
1280
13ae64f3 1281 case R_386_TLS_IE_32:
37e55690
JJ		 1282 case R_386_TLS_IE:
1283 case R_386_TLS_GOTIE:
13ae64f3
JJ		 1284 if (info->shared)
1285 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 1286 /* Fall through */
1287
252b5132 1288 case R_386_GOT32:
13ae64f3 1289 case R_386_TLS_GD:
67a4f2b7
AO		 1290 case R_386_TLS_GOTDESC:
1291 case R_386_TLS_DESC_CALL:
252b5132 1292 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 1293 {
1294 int tls_type, old_tls_type;
1295
1296 switch (r_type)
1297 {
1298 default:
1299 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1300 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1301 case R_386_TLS_GOTDESC:
1302 case R_386_TLS_DESC_CALL:
1303 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1304 case R_386_TLS_IE_32:
1305 if (ELF32_R_TYPE (rel->r_info) == r_type)
1306 tls_type = GOT_TLS_IE_NEG;
1307 else
ebcfb3c0
JJ		 1308 /* If this is a GD->IE transition, we may use either of
1309 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1310 tls_type = GOT_TLS_IE;
1311 break;
1312 case R_386_TLS_IE:
1313 case R_386_TLS_GOTIE:
1314 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1315 }
1316
1317 if (h != NULL)
1318 {
1319 h->got.refcount += 1;
1320 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1321 }
1322 else
1323 {
1324 bfd_signed_vma *local_got_refcounts;
1325
1326 /* This is a global offset table entry for a local symbol. */
1327 local_got_refcounts = elf_local_got_refcounts (abfd);
1328 if (local_got_refcounts == NULL)
1329 {
1330 bfd_size_type size;
1331
1332 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1333 size *= (sizeof (bfd_signed_vma)
1334 + sizeof (bfd_vma) + sizeof(char));
55fd94b0 1335 local_got_refcounts = bfd_zalloc (abfd, size);
13ae64f3 1336 if (local_got_refcounts == NULL)
b34976b6 1337 return FALSE;
13ae64f3 1338 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1339 elf_i386_local_tlsdesc_gotent (abfd)
1340 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1341 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1342 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1343 }
1344 local_got_refcounts[r_symndx] += 1;
1345 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1346 }
1347
37e55690
JJ		 1348 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1349 tls_type |= old_tls_type;
13ae64f3
JJ		 1350 /* If a TLS symbol is accessed using IE at least once,
1351 there is no point to use dynamic model for it. */
ebcfb3c0 1352 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 1353 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 1354 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1355 {
67a4f2b7 1356 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 1357 tls_type = old_tls_type;
67a4f2b7
AO		 1358 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1359 && GOT_TLS_GD_ANY_P (tls_type))
1360 tls_type |= old_tls_type;
13ae64f3
JJ		 1361 else
1362 {
1363 (*_bfd_error_handler)
d003868e 1364 (_("%B: `%s' accessed both as normal and "
55fd94b0 1365 "thread local symbol"),
d003868e 1366 abfd,
37e55690 1367 h ? h->root.root.string : "<local>");
b34976b6 1368 return FALSE;
13ae64f3
JJ		 1369 }
1370 }
1371
1372 if (old_tls_type != tls_type)
1373 {
1374 if (h != NULL)
1375 elf_i386_hash_entry (h)->tls_type = tls_type;
1376 else
1377 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1378 }
1379 }
0ac8d2ca
AM		 1380 /* Fall through */
1381
1382 case R_386_GOTOFF:
1383 case R_386_GOTPC:
13ae64f3 1384 create_got:
0ac8d2ca
AM		 1385 if (htab->sgot == NULL)
1386 {
1387 if (htab->elf.dynobj == NULL)
1388 htab->elf.dynobj = abfd;
1389 if (!create_got_section (htab->elf.dynobj, info))
b34976b6 1390 return FALSE;
0ac8d2ca 1391 }
37e55690
JJ		 1392 if (r_type != R_386_TLS_IE)
1393 break;
1394 /* Fall through */
252b5132 1395
37e55690
JJ		 1396 case R_386_TLS_LE_32:
1397 case R_386_TLS_LE:
1398 if (!info->shared)
1399 break;
bffbf940 1400 info->flags |= DF_STATIC_TLS;
b34976b6 1401 /* Fall through */
252b5132
RH		 1402
1403 case R_386_32:
1404 case R_386_PC32:
12d0ee4a 1405 if (h != NULL && !info->shared)
6725bdbf 1406 {
12d0ee4a 1407 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1408 need a copy reloc. We can't check reliably at this
1409 stage whether the section is read-only, as input
1410 sections have not yet been mapped to output sections.
1411 Tentatively set the flag for now, and correct in
1412 adjust_dynamic_symbol. */
f5385ebf 1413 h->non_got_ref = 1;
12d0ee4a
AM		 1414
1415 /* We may need a .plt entry if the function this reloc
1416 refers to is in a shared lib. */
51b64d56 1417 h->plt.refcount += 1;
c6585bbb 1418 if (r_type != R_386_PC32)
f5385ebf 1419 h->pointer_equality_needed = 1;
6725bdbf 1420 }
7843f00e 1421
252b5132 1422 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1423 against a global symbol, or a non PC relative reloc
1424 against a local symbol, then we need to copy the reloc
1425 into the shared library. However, if we are linking with
1426 -Bsymbolic, we do not need to copy a reloc against a
1427 global symbol which is defined in an object we are
1428 including in the link (i.e., DEF_REGULAR is set). At
1429 this point we have not seen all the input files, so it is
1430 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1431 later (it is never cleared). In case of a weak definition,
1432 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1433 a shared library. We account for that possibility below by
1f655a09
L		 1434 storing information in the relocs_copied field of the hash
1435 table entry. A similar situation occurs when creating
1436 shared libraries and symbol visibility changes render the
12d0ee4a 1437 symbol local.
56882138 1438
12d0ee4a
AM		 1439 If on the other hand, we are creating an executable, we
1440 may need to keep relocations for symbols satisfied by a
1441 dynamic library if we manage to avoid copy relocs for the
1442 symbol. */
1443 if ((info->shared
1444 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1445 && (r_type != R_386_PC32
12d0ee4a 1446 || (h != NULL
55255dae 1447 && (! SYMBOLIC_BIND (info, h)
12d0ee4a 1448 || h->root.type == bfd_link_hash_defweak
f5385ebf 1449 || !h->def_regular))))
a23b6845
AM		 1450 || (ELIMINATE_COPY_RELOCS
1451 && !info->shared
12d0ee4a
AM		 1452 && (sec->flags & SEC_ALLOC) != 0
1453 && h != NULL
12d0ee4a 1454 && (h->root.type == bfd_link_hash_defweak
f5385ebf 1455 || !h->def_regular)))
252b5132 1456 {
ec338859
AM		 1457 struct elf_i386_dyn_relocs *p;
1458 struct elf_i386_dyn_relocs **head;
1459
12d0ee4a
AM		 1460 /* We must copy these reloc types into the output file.
1461 Create a reloc section in dynobj and make room for
1462 this reloc. */
252b5132
RH		 1463 if (sreloc == NULL)
1464 {
1465 const char *name;
0ac8d2ca 1466 bfd *dynobj;
e92d460e
AM		 1467 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1468 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
252b5132 1469
e92d460e 1470 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
252b5132 1471 if (name == NULL)
b34976b6 1472 return FALSE;
252b5132 1473
0112cd26 1474 if (! CONST_STRNEQ (name, ".rel")
c8492176
L		 1475 || strcmp (bfd_get_section_name (abfd, sec),
1476 name + 4) != 0)
1477 {
0c715baa 1478 (*_bfd_error_handler)
d003868e
AM		 1479 (_("%B: bad relocation section name `%s\'"),
1480 abfd, name);
f5f31454 1481 }
252b5132 1482
0ac8d2ca
AM		 1483 if (htab->elf.dynobj == NULL)
1484 htab->elf.dynobj = abfd;
1485
1486 dynobj = htab->elf.dynobj;
252b5132
RH		 1487 sreloc = bfd_get_section_by_name (dynobj, name);
1488 if (sreloc == NULL)
1489 {
1490 flagword flags;
1491
252b5132
RH		 1492 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1493 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1494 if ((sec->flags & SEC_ALLOC) != 0)
1495 flags |= SEC_ALLOC | SEC_LOAD;
3496cb2a
L		 1496 sreloc = bfd_make_section_with_flags (dynobj,
1497 name,
1498 flags);
252b5132 1499 if (sreloc == NULL
252b5132 1500 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 1501 return FALSE;
252b5132 1502 }
0c715baa 1503 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1504 }
1505
0c715baa
AM		 1506 /* If this is a global symbol, we count the number of
1507 relocations we need for this symbol. */
1508 if (h != NULL)
252b5132 1509 {
ec338859 1510 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1511 }
1512 else
1513 {
e81d3500 1514 void **vpp;
ec338859
AM		 1515 /* Track dynamic relocs needed for local syms too.
1516 We really need local syms available to do this
1517 easily. Oh well. */
1518
1519 asection *s;
1520 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1521 sec, r_symndx);
1522 if (s == NULL)
b34976b6 1523 return FALSE;
ec338859 1524
e81d3500
DD		 1525 vpp = &elf_section_data (s)->local_dynrel;
1526 head = (struct elf_i386_dyn_relocs **)vpp;
ec338859
AM		 1527 }
1528
1529 p = *head;
1530 if (p == NULL || p->sec != sec)
1531 {
1532 bfd_size_type amt = sizeof *p;
55fd94b0 1533 p = bfd_alloc (htab->elf.dynobj, amt);
ec338859 1534 if (p == NULL)
b34976b6 1535 return FALSE;
ec338859
AM		 1536 p->next = *head;
1537 *head = p;
1538 p->sec = sec;
1539 p->count = 0;
1540 p->pc_count = 0;
252b5132 1541 }
ec338859
AM		 1542
1543 p->count += 1;
13ae64f3 1544 if (r_type == R_386_PC32)
ec338859 1545 p->pc_count += 1;
252b5132 1546 }
252b5132
RH		 1547 break;
1548
1549 /* This relocation describes the C++ object vtable hierarchy.
1550 Reconstruct it for later use during GC. */
1551 case R_386_GNU_VTINHERIT:
d17e0c6e 1552 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 1553 return FALSE;
252b5132
RH		 1554 break;
1555
1556 /* This relocation describes which C++ vtable entries are actually
1557 used. Record for later use during GC. */
1558 case R_386_GNU_VTENTRY:
c6aa130f
MS		 1559 BFD_ASSERT (h != NULL);
1560 if (h != NULL
1561 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 1562 return FALSE;
252b5132
RH		 1563 break;
1564
1565 default:
1566 break;
1567 }
1568 }
1569
b34976b6 1570 return TRUE;
252b5132
RH		 1571}
1572
1573/* Return the section that should be marked against GC for a given
1574 relocation. */
1575
1576static asection *
55fd94b0 1577elf_i386_gc_mark_hook (asection *sec,
07adf181 1578 struct bfd_link_info *info,
55fd94b0
AM		 1579 Elf_Internal_Rela *rel,
1580 struct elf_link_hash_entry *h,
1581 Elf_Internal_Sym *sym)
252b5132
RH		 1582{
1583 if (h != NULL)
07adf181
AM		 1584 switch (ELF32_R_TYPE (rel->r_info))
1585 {
1586 case R_386_GNU_VTINHERIT:
1587 case R_386_GNU_VTENTRY:
1588 return NULL;
1589 }
1590
1591 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 1592}
1593
1594/* Update the got entry reference counts for the section being removed. */
1595
b34976b6 1596static bfd_boolean
55fd94b0
AM		 1597elf_i386_gc_sweep_hook (bfd *abfd,
1598 struct bfd_link_info *info,
1599 asection *sec,
1600 const Elf_Internal_Rela *relocs)
252b5132 1601{
dd5724d5
AM		 1602 Elf_Internal_Shdr *symtab_hdr;
1603 struct elf_link_hash_entry **sym_hashes;
1604 bfd_signed_vma *local_got_refcounts;
1605 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1606
7dda2462
TG		 1607 if (info->relocatable)
1608 return TRUE;
1609
ec338859 1610 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1611
0ffa91dd 1612 symtab_hdr = &elf_symtab_hdr (abfd);
6725bdbf
AM		 1613 sym_hashes = elf_sym_hashes (abfd);
1614 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1615
1616 relend = relocs + sec->reloc_count;
1617 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1618 {
1619 unsigned long r_symndx;
1620 unsigned int r_type;
1621 struct elf_link_hash_entry *h = NULL;
37e55690 1622
26e41594
AM		 1623 r_symndx = ELF32_R_SYM (rel->r_info);
1624 if (r_symndx >= symtab_hdr->sh_info)
1625 {
1626 struct elf_i386_link_hash_entry *eh;
1627 struct elf_i386_dyn_relocs **pp;
1628 struct elf_i386_dyn_relocs *p;
dd5724d5 1629
26e41594 1630 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1631 while (h->root.type == bfd_link_hash_indirect
1632 || h->root.type == bfd_link_hash_warning)
1633 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1634 eh = (struct elf_i386_link_hash_entry *) h;
0c715baa 1635
26e41594
AM		 1636 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1637 if (p->sec == sec)
1638 {
1639 /* Everything must go for SEC. */
1640 *pp = p->next;
1641 break;
1642 }
1643 }
0c715baa 1644
26e41594 1645 r_type = ELF32_R_TYPE (rel->r_info);
142411ca
L		 1646 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1647 symtab_hdr, sym_hashes,
1648 &r_type, GOT_UNKNOWN,
1649 rel, relend, h))
1650 return FALSE;
1651
26e41594
AM		 1652 switch (r_type)
1653 {
1654 case R_386_TLS_LDM:
1655 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1656 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1657 break;
0c715baa 1658
26e41594 1659 case R_386_TLS_GD:
67a4f2b7
AO		 1660 case R_386_TLS_GOTDESC:
1661 case R_386_TLS_DESC_CALL:
26e41594
AM		 1662 case R_386_TLS_IE_32:
1663 case R_386_TLS_IE:
1664 case R_386_TLS_GOTIE:
1665 case R_386_GOT32:
1666 if (h != NULL)
1667 {
1668 if (h->got.refcount > 0)
1669 h->got.refcount -= 1;
1670 }
1671 else if (local_got_refcounts != NULL)
1672 {
1673 if (local_got_refcounts[r_symndx] > 0)
1674 local_got_refcounts[r_symndx] -= 1;
1675 }
1676 break;
0c715baa 1677
26e41594
AM		 1678 case R_386_32:
1679 case R_386_PC32:
1680 if (info->shared)
1681 break;
1682 /* Fall through */
6725bdbf 1683
26e41594
AM		 1684 case R_386_PLT32:
1685 if (h != NULL)
1686 {
1687 if (h->plt.refcount > 0)
1688 h->plt.refcount -= 1;
1689 }
1690 break;
dd5724d5 1691
26e41594
AM		 1692 default:
1693 break;
1694 }
1695 }
252b5132 1696
b34976b6 1697 return TRUE;
252b5132
RH		 1698}
1699
1700/* Adjust a symbol defined by a dynamic object and referenced by a
1701 regular object. The current definition is in some section of the
1702 dynamic object, but we're not including those sections. We have to
1703 change the definition to something the rest of the link can
1704 understand. */
1705
b34976b6 1706static bfd_boolean
55fd94b0
AM		 1707elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1708 struct elf_link_hash_entry *h)
252b5132 1709{
6725bdbf 1710 struct elf_i386_link_hash_table *htab;
252b5132 1711 asection *s;
252b5132 1712
252b5132
RH		 1713 /* If this is a function, put it in the procedure linkage table. We
1714 will fill in the contents of the procedure linkage table later,
1715 when we know the address of the .got section. */
1716 if (h->type == STT_FUNC
f5385ebf 1717 || h->needs_plt)
252b5132 1718 {
6725bdbf 1719 if (h->plt.refcount <= 0
9c7a29a3
AM		 1720 || SYMBOL_CALLS_LOCAL (info, h)
1721 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1722 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 1723 {
1724 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1725 file, but the symbol was never referred to by a dynamic
1726 object, or if all references were garbage collected. In
1727 such a case, we don't actually need to build a procedure
1728 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1729 h->plt.offset = (bfd_vma) -1;
f5385ebf 1730 h->needs_plt = 0;
252b5132
RH		 1731 }
1732
b34976b6 1733 return TRUE;
252b5132 1734 }
6725bdbf
AM		 1735 else
1736 /* It's possible that we incorrectly decided a .plt reloc was
1737 needed for an R_386_PC32 reloc to a non-function sym in
1738 check_relocs. We can't decide accurately between function and
1739 non-function syms in check-relocs; Objects loaded later in
1740 the link may change h->type. So fix it now. */
bbd7ec4a 1741 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1742
1743 /* If this is a weak symbol, and there is a real definition, the
1744 processor independent code will have arranged for us to see the
1745 real definition first, and we can just use the same value. */
f6e332e6 1746 if (h->u.weakdef != NULL)
252b5132 1747 {
f6e332e6
AM		 1748 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1749 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1750 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1751 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 1752 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 1753 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 1754 return TRUE;
252b5132
RH		 1755 }
1756
1757 /* This is a reference to a symbol defined by a dynamic object which
1758 is not a function. */
1759
1760 /* If we are creating a shared library, we must presume that the
1761 only references to the symbol are via the global offset table.
1762 For such cases we need not do anything here; the relocations will
1763 be handled correctly by relocate_section. */
1764 if (info->shared)
b34976b6 1765 return TRUE;
252b5132 1766
7843f00e
ILT		 1767 /* If there are no references to this symbol that do not use the
1768 GOT, we don't need to generate a copy reloc. */
f5385ebf 1769 if (!h->non_got_ref)
b34976b6 1770 return TRUE;
7843f00e 1771
8bd621d8
AM		 1772 /* If -z nocopyreloc was given, we won't generate them either. */
1773 if (info->nocopyreloc)
1774 {
f5385ebf 1775 h->non_got_ref = 0;
b34976b6 1776 return TRUE;
8bd621d8
AM		 1777 }
1778
643796e3
DJ		 1779 htab = elf_i386_hash_table (info);
1780
1781 /* If there aren't any dynamic relocs in read-only sections, then
1782 we can keep the dynamic relocs and avoid the copy reloc. This
1783 doesn't work on VxWorks, where we can not have dynamic relocations
1784 (other than copy and jump slot relocations) in an executable. */
1785 if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
ebe50bae 1786 {
a23b6845
AM		 1787 struct elf_i386_link_hash_entry * eh;
1788 struct elf_i386_dyn_relocs *p;
ebe50bae 1789
a23b6845
AM		 1790 eh = (struct elf_i386_link_hash_entry *) h;
1791 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1792 {
1793 s = p->sec->output_section;
1794 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1795 break;
1796 }
1797
a23b6845
AM		 1798 if (p == NULL)
1799 {
f5385ebf 1800 h->non_got_ref = 0;
a23b6845
AM		 1801 return TRUE;
1802 }
ebe50bae
AM		 1803 }
1804
909272ee
AM		 1805 if (h->size == 0)
1806 {
1807 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1808 h->root.root.string);
1809 return TRUE;
1810 }
1811
252b5132
RH		 1812 /* We must allocate the symbol in our .dynbss section, which will
1813 become part of the .bss section of the executable. There will be
1814 an entry for this symbol in the .dynsym section. The dynamic
1815 object will contain position independent code, so all references
1816 from the dynamic object to this symbol will go through the global
1817 offset table. The dynamic linker will use the .dynsym entry to
1818 determine the address it must put in the global offset table, so
1819 both the dynamic object and the regular object will refer to the
1820 same memory location for the variable. */
1821
252b5132
RH		 1822 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1823 copy the initial value out of the dynamic object and into the
0ac8d2ca 1824 runtime process image. */
252b5132
RH		 1825 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1826 {
eea6121a 1827 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 1828 h->needs_copy = 1;
252b5132
RH		 1829 }
1830
0ac8d2ca 1831 s = htab->sdynbss;
252b5132 1832
027297b7 1833 return _bfd_elf_adjust_dynamic_copy (h, s);
252b5132
RH		 1834}
1835
6725bdbf 1836/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1837 dynamic relocs. */
6725bdbf 1838
b34976b6 1839static bfd_boolean
55fd94b0 1840allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 1841{
1842 struct bfd_link_info *info;
1843 struct elf_i386_link_hash_table *htab;
5a15f56f 1844 struct elf_i386_link_hash_entry *eh;
0c715baa 1845 struct elf_i386_dyn_relocs *p;
6725bdbf 1846
e92d460e 1847 if (h->root.type == bfd_link_hash_indirect)
b34976b6 1848 return TRUE;
6725bdbf 1849
e92d460e
AM		 1850 if (h->root.type == bfd_link_hash_warning)
1851 /* When warning symbols are created, they **replace** the "real"
1852 entry in the hash table, thus we never get to see the real
1853 symbol in a hash traversal. So look at it now. */
1854 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1855
6725bdbf
AM		 1856 info = (struct bfd_link_info *) inf;
1857 htab = elf_i386_hash_table (info);
1858
ebe50bae 1859 if (htab->elf.dynamic_sections_created
9c7a29a3 1860 && h->plt.refcount > 0)
6725bdbf 1861 {
5a15f56f
AM		 1862 /* Make sure this symbol is output as a dynamic symbol.
1863 Undefined weak syms won't yet be marked as dynamic. */
1864 if (h->dynindx == -1
f5385ebf 1865 && !h->forced_local)
5a15f56f 1866 {
c152c796 1867 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1868 return FALSE;
5a15f56f
AM		 1869 }
1870
4e795f50
AM		 1871 if (info->shared
1872 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 1873 {
0ac8d2ca 1874 asection *s = htab->splt;
6725bdbf 1875
ced53ee5
AM		 1876 /* If this is the first .plt entry, make room for the special
1877 first entry. */
eea6121a
AM		 1878 if (s->size == 0)
1879 s->size += PLT_ENTRY_SIZE;
6725bdbf 1880
eea6121a 1881 h->plt.offset = s->size;
6725bdbf 1882
ced53ee5
AM		 1883 /* If this symbol is not defined in a regular file, and we are
1884 not generating a shared library, then set the symbol to this
1885 location in the .plt. This is required to make function
1886 pointers compare as equal between the normal executable and
1887 the shared library. */
1888 if (! info->shared
f5385ebf 1889 && !h->def_regular)
ced53ee5
AM		 1890 {
1891 h->root.u.def.section = s;
1892 h->root.u.def.value = h->plt.offset;
1893 }
6725bdbf 1894
ced53ee5 1895 /* Make room for this entry. */
eea6121a 1896 s->size += PLT_ENTRY_SIZE;
6725bdbf 1897
ced53ee5
AM		 1898 /* We also need to make an entry in the .got.plt section, which
1899 will be placed in the .got section by the linker script. */
eea6121a 1900 htab->sgotplt->size += 4;
6725bdbf 1901
6725bdbf 1902 /* We also need to make an entry in the .rel.plt section. */
eea6121a 1903 htab->srelplt->size += sizeof (Elf32_External_Rel);
5ae0bfb6 1904 htab->next_tls_desc_index++;
eac338cf
PB		 1905
1906 if (htab->is_vxworks && !info->shared)
1907 {
1908 /* VxWorks has a second set of relocations for each PLT entry
1909 in executables. They go in a separate relocation section,
1910 which is processed by the kernel loader. */
1911
1912 /* There are two relocations for the initial PLT entry: an
1913 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
1914 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
1915
1916 if (h->plt.offset == PLT_ENTRY_SIZE)
1917 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1918
1919 /* There are two extra relocations for each subsequent PLT entry:
1920 an R_386_32 relocation for the GOT entry, and an R_386_32
1921 relocation for the PLT entry. */
1922
1923 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
1924 }
6725bdbf 1925 }
ced53ee5
AM		 1926 else
1927 {
51b64d56 1928 h->plt.offset = (bfd_vma) -1;
f5385ebf 1929 h->needs_plt = 0;
ced53ee5 1930 }
6725bdbf
AM		 1931 }
1932 else
1933 {
51b64d56 1934 h->plt.offset = (bfd_vma) -1;
f5385ebf 1935 h->needs_plt = 0;
6725bdbf
AM		 1936 }
1937
67a4f2b7
AO		 1938 eh = (struct elf_i386_link_hash_entry *) h;
1939 eh->tlsdesc_got = (bfd_vma) -1;
1940
37e55690 1941 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 1942 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1943 if (h->got.refcount > 0
1944 && !info->shared
1945 && h->dynindx == -1
37e55690 1946 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 1947 h->got.offset = (bfd_vma) -1;
13ae64f3 1948 else if (h->got.refcount > 0)
6725bdbf 1949 {
0ac8d2ca 1950 asection *s;
b34976b6 1951 bfd_boolean dyn;
13ae64f3 1952 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1953
5a15f56f
AM		 1954 /* Make sure this symbol is output as a dynamic symbol.
1955 Undefined weak syms won't yet be marked as dynamic. */
1956 if (h->dynindx == -1
f5385ebf 1957 && !h->forced_local)
5a15f56f 1958 {
c152c796 1959 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1960 return FALSE;
5a15f56f
AM		 1961 }
1962
6725bdbf 1963 s = htab->sgot;
67a4f2b7
AO		 1964 if (GOT_TLS_GDESC_P (tls_type))
1965 {
1966 eh->tlsdesc_got = htab->sgotplt->size
1967 - elf_i386_compute_jump_table_size (htab);
1968 htab->sgotplt->size += 8;
1969 h->got.offset = (bfd_vma) -2;
1970 }
1971 if (! GOT_TLS_GDESC_P (tls_type)
1972 || GOT_TLS_GD_P (tls_type))
1973 {
1974 h->got.offset = s->size;
1975 s->size += 4;
1976 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1977 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
1978 s->size += 4;
1979 }
ebe50bae 1980 dyn = htab->elf.dynamic_sections_created;
13ae64f3 1981 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 1982 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1983 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1984 need two), R_386_TLS_GD needs one if local symbol and two if
1985 global. */
1986 if (tls_type == GOT_TLS_IE_BOTH)
eea6121a 1987 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 1988 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 1989 || (tls_type & GOT_TLS_IE))
eea6121a 1990 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 1991 else if (GOT_TLS_GD_P (tls_type))
eea6121a 1992 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1993 else if (! GOT_TLS_GDESC_P (tls_type)
1994 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1995 || h->root.type != bfd_link_hash_undefweak)
ef5aade5
L		 1996 && (info->shared
1997 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
eea6121a 1998 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 1999 if (GOT_TLS_GDESC_P (tls_type))
2000 htab->srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2001 }
2002 else
51b64d56 2003 h->got.offset = (bfd_vma) -1;
6725bdbf 2004
5a15f56f 2005 if (eh->dyn_relocs == NULL)
b34976b6 2006 return TRUE;
5a15f56f 2007
0c715baa
AM		 2008 /* In the shared -Bsymbolic case, discard space allocated for
2009 dynamic pc-relative relocs against symbols which turn out to be
2010 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2011 space for pc-relative relocs that have become local due to symbol
2012 visibility changes. */
0c715baa
AM		 2013
2014 if (info->shared)
5a15f56f 2015 {
09695f56
AM		 2016 /* The only reloc that uses pc_count is R_386_PC32, which will
2017 appear on a call or on something like ".long foo - .". We
2018 want calls to protected symbols to resolve directly to the
2019 function rather than going via the plt. If people want
2020 function pointer comparisons to work as expected then they
2021 should avoid writing assembly like ".long foo - .". */
2022 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2023 {
0c715baa
AM		 2024 struct elf_i386_dyn_relocs **pp;
2025
2026 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2027 {
2028 p->count -= p->pc_count;
2029 p->pc_count = 0;
2030 if (p->count == 0)
2031 *pp = p->next;
2032 else
2033 pp = &p->next;
2034 }
5a15f56f 2035 }
4e795f50 2036
3348747a
NS		 2037 if (htab->is_vxworks)
2038 {
2039 struct elf_i386_dyn_relocs **pp;
2040 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2041 {
2042 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2043 *pp = p->next;
2044 else
2045 pp = &p->next;
2046 }
2047 }
2048
4e795f50 2049 /* Also discard relocs on undefined weak syms with non-default
3348747a 2050 visibility. */
22d606e9 2051 if (eh->dyn_relocs != NULL
4e795f50 2052 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 2053 {
2054 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2055 eh->dyn_relocs = NULL;
2056
2057 /* Make sure undefined weak symbols are output as a dynamic
2058 symbol in PIEs. */
2059 else if (h->dynindx == -1
2060 && !h->forced_local)
2061 {
2062 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2063 return FALSE;
2064 }
2065 }
0c715baa 2066 }
a23b6845 2067 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2068 {
2069 /* For the non-shared case, discard space for relocs against
2070 symbols which turn out to need copy relocs or are not
2071 dynamic. */
2072
f5385ebf
AM		 2073 if (!h->non_got_ref
2074 && ((h->def_dynamic
2075 && !h->def_regular)
ebe50bae 2076 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2077 && (h->root.type == bfd_link_hash_undefweak
2078 || h->root.type == bfd_link_hash_undefined))))
2079 {
2080 /* Make sure this symbol is output as a dynamic symbol.
2081 Undefined weak syms won't yet be marked as dynamic. */
2082 if (h->dynindx == -1
f5385ebf 2083 && !h->forced_local)
0c715baa 2084 {
c152c796 2085 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2086 return FALSE;
0c715baa 2087 }
5a15f56f 2088
0c715baa
AM		 2089 /* If that succeeded, we know we'll be keeping all the
2090 relocs. */
2091 if (h->dynindx != -1)
2092 goto keep;
2093 }
2094
2095 eh->dyn_relocs = NULL;
2096
ec338859 2097 keep: ;
5a15f56f
AM		 2098 }
2099
0c715baa
AM		 2100 /* Finally, allocate space. */
2101 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 2102 {
0c715baa 2103 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 2104 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 2105 }
2106
b34976b6 2107 return TRUE;
6725bdbf
AM		 2108}
2109
0c715baa
AM		 2110/* Find any dynamic relocs that apply to read-only sections. */
2111
b34976b6 2112static bfd_boolean
55fd94b0 2113readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 2114{
2115 struct elf_i386_link_hash_entry *eh;
2116 struct elf_i386_dyn_relocs *p;
2117
e92d460e
AM		 2118 if (h->root.type == bfd_link_hash_warning)
2119 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2120
0c715baa
AM		 2121 eh = (struct elf_i386_link_hash_entry *) h;
2122 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2123 {
2124 asection *s = p->sec->output_section;
2125
2126 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2127 {
2128 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2129
2130 info->flags |= DF_TEXTREL;
2131
2132 /* Not an error, just cut short the traversal. */
b34976b6 2133 return FALSE;
0c715baa
AM		 2134 }
2135 }
b34976b6 2136 return TRUE;
0c715baa
AM		 2137}
2138
252b5132
RH		 2139/* Set the sizes of the dynamic sections. */
2140
b34976b6 2141static bfd_boolean
55fd94b0
AM		 2142elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2143 struct bfd_link_info *info)
252b5132 2144{
6725bdbf 2145 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2146 bfd *dynobj;
2147 asection *s;
b34976b6 2148 bfd_boolean relocs;
0c715baa 2149 bfd *ibfd;
252b5132 2150
6725bdbf 2151 htab = elf_i386_hash_table (info);
ebe50bae 2152 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 2153 if (dynobj == NULL)
2154 abort ();
252b5132 2155
ebe50bae 2156 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2157 {
2158 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 2159 if (info->executable)
252b5132
RH		 2160 {
2161 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 2162 if (s == NULL)
2163 abort ();
eea6121a 2164 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 2165 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2166 }
161d71a6 2167 }
6725bdbf 2168
0c715baa
AM		 2169 /* Set up .got offsets for local syms, and space for local dynamic
2170 relocs. */
2171 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 2172 {
2173 bfd_signed_vma *local_got;
2174 bfd_signed_vma *end_local_got;
13ae64f3 2175 char *local_tls_type;
67a4f2b7 2176 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 2177 bfd_size_type locsymcount;
2178 Elf_Internal_Shdr *symtab_hdr;
2179 asection *srel;
6725bdbf 2180
0ffa91dd 2181 if (! is_i386_elf (ibfd))
161d71a6 2182 continue;
6725bdbf 2183
0c715baa
AM		 2184 for (s = ibfd->sections; s != NULL; s = s->next)
2185 {
ec338859 2186 struct elf_i386_dyn_relocs *p;
0c715baa 2187
e81d3500
DD		 2188 for (p = ((struct elf_i386_dyn_relocs *)
2189 elf_section_data (s)->local_dynrel);
ec338859
AM		 2190 p != NULL;
2191 p = p->next)
0c715baa 2192 {
ec338859
AM		 2193 if (!bfd_is_abs_section (p->sec)
2194 && bfd_is_abs_section (p->sec->output_section))
2195 {
2196 /* Input section has been discarded, either because
2197 it is a copy of a linkonce section or due to
2198 linker script /DISCARD/, so we'll be discarding
2199 the relocs too. */
2200 }
3348747a
NS		 2201 else if (htab->is_vxworks
2202 && strcmp (p->sec->output_section->name,
2203 ".tls_vars") == 0)
2204 {
2205 /* Relocations in vxworks .tls_vars sections are
2206 handled specially by the loader. */
2207 }
248866a8 2208 else if (p->count != 0)
ec338859
AM		 2209 {
2210 srel = elf_section_data (p->sec)->sreloc;
eea6121a 2211 srel->size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 2212 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2213 info->flags |= DF_TEXTREL;
ec338859 2214 }
0c715baa
AM		 2215 }
2216 }
2217
2218 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 2219 if (!local_got)
2220 continue;
6725bdbf 2221
0ffa91dd 2222 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 2223 locsymcount = symtab_hdr->sh_info;
2224 end_local_got = local_got + locsymcount;
13ae64f3 2225 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 2226 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
161d71a6
L		 2227 s = htab->sgot;
2228 srel = htab->srelgot;
67a4f2b7
AO		 2229 for (; local_got < end_local_got;
2230 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 2231 {
67a4f2b7 2232 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 2233 if (*local_got > 0)
6725bdbf 2234 {
67a4f2b7
AO		 2235 if (GOT_TLS_GDESC_P (*local_tls_type))
2236 {
2237 *local_tlsdesc_gotent = htab->sgotplt->size
2238 - elf_i386_compute_jump_table_size (htab);
2239 htab->sgotplt->size += 8;
2240 *local_got = (bfd_vma) -2;
2241 }
2242 if (! GOT_TLS_GDESC_P (*local_tls_type)
2243 || GOT_TLS_GD_P (*local_tls_type))
2244 {
2245 *local_got = s->size;
2246 s->size += 4;
2247 if (GOT_TLS_GD_P (*local_tls_type)
2248 || *local_tls_type == GOT_TLS_IE_BOTH)
2249 s->size += 4;
2250 }
13ae64f3 2251 if (info->shared
67a4f2b7 2252 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 2253 || (*local_tls_type & GOT_TLS_IE))
2254 {
2255 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 2256 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2257 else if (GOT_TLS_GD_P (*local_tls_type)
2258 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 2259 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2260 if (GOT_TLS_GDESC_P (*local_tls_type))
2261 htab->srelplt->size += sizeof (Elf32_External_Rel);
37e55690 2262 }
6725bdbf 2263 }
161d71a6
L		 2264 else
2265 *local_got = (bfd_vma) -1;
6725bdbf 2266 }
252b5132 2267 }
6725bdbf 2268
13ae64f3
JJ		 2269 if (htab->tls_ldm_got.refcount > 0)
2270 {
2271 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2272 relocs. */
eea6121a
AM		 2273 htab->tls_ldm_got.offset = htab->sgot->size;
2274 htab->sgot->size += 8;
2275 htab->srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2276 }
2277 else
2278 htab->tls_ldm_got.offset = -1;
2279
0c715baa
AM		 2280 /* Allocate global sym .plt and .got entries, and space for global
2281 sym dynamic relocs. */
ebe50bae 2282 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 2283
67a4f2b7
AO		 2284 /* For every jump slot reserved in the sgotplt, reloc_count is
2285 incremented. However, when we reserve space for TLS descriptors,
2286 it's not incremented, so in order to compute the space reserved
2287 for them, it suffices to multiply the reloc count by the jump
2288 slot size. */
2289 if (htab->srelplt)
5ae0bfb6 2290 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
67a4f2b7 2291
5a15f56f
AM		 2292 /* We now have determined the sizes of the various dynamic sections.
2293 Allocate memory for them. */
b34976b6 2294 relocs = FALSE;
252b5132
RH		 2295 for (s = dynobj->sections; s != NULL; s = s->next)
2296 {
eac338cf
PB		 2297 bfd_boolean strip_section = TRUE;
2298
252b5132
RH		 2299 if ((s->flags & SEC_LINKER_CREATED) == 0)
2300 continue;
2301
6725bdbf
AM		 2302 if (s == htab->splt
2303 || s == htab->sgot
75ff4589
L		 2304 || s == htab->sgotplt
2305 || s == htab->sdynbss)
252b5132 2306 {
6725bdbf
AM		 2307 /* Strip this section if we don't need it; see the
2308 comment below. */
eac338cf
PB		 2309 /* We'd like to strip these sections if they aren't needed, but if
2310 we've exported dynamic symbols from them we must leave them.
2311 It's too late to tell BFD to get rid of the symbols. */
2312
7325306f 2313 if (htab->elf.hplt != NULL)
eac338cf 2314 strip_section = FALSE;
252b5132 2315 }
0112cd26 2316 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 2317 {
eac338cf 2318 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
b34976b6 2319 relocs = TRUE;
252b5132 2320
0ac8d2ca
AM		 2321 /* We use the reloc_count field as a counter if we need
2322 to copy relocs into the output file. */
5ae0bfb6 2323 s->reloc_count = 0;
252b5132 2324 }
6725bdbf 2325 else
252b5132
RH		 2326 {
2327 /* It's not one of our sections, so don't allocate space. */
2328 continue;
2329 }
2330
c456f082 2331 if (s->size == 0)
252b5132 2332 {
0ac8d2ca
AM		 2333 /* If we don't need this section, strip it from the
2334 output file. This is mostly to handle .rel.bss and
2335 .rel.plt. We must create both sections in
2336 create_dynamic_sections, because they must be created
2337 before the linker maps input sections to output
2338 sections. The linker does that before
2339 adjust_dynamic_symbol is called, and it is that
2340 function which decides whether anything needs to go
2341 into these sections. */
c456f082
AM		 2342 if (strip_section)
2343 s->flags |= SEC_EXCLUDE;
252b5132
RH		 2344 continue;
2345 }
2346
c456f082
AM		 2347 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2348 continue;
2349
f69da49f
AM		 2350 /* Allocate memory for the section contents. We use bfd_zalloc
2351 here in case unused entries are not reclaimed before the
2352 section's contents are written out. This should not happen,
2353 but this way if it does, we get a R_386_NONE reloc instead
2354 of garbage. */
eea6121a 2355 s->contents = bfd_zalloc (dynobj, s->size);
6725bdbf 2356 if (s->contents == NULL)
b34976b6 2357 return FALSE;
252b5132
RH		 2358 }
2359
ebe50bae 2360 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2361 {
2362 /* Add some entries to the .dynamic section. We fill in the
2363 values later, in elf_i386_finish_dynamic_sections, but we
2364 must add the entries now so that we get the correct size for
2365 the .dynamic section. The DT_DEBUG entry is filled in by the
2366 dynamic linker and used by the debugger. */
dc810e39 2367#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2368 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2369
36af4a4e 2370 if (info->executable)
252b5132 2371 {
dc810e39 2372 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2373 return FALSE;
252b5132
RH		 2374 }
2375
eea6121a 2376 if (htab->splt->size != 0)
252b5132 2377 {
dc810e39
AM		 2378 if (!add_dynamic_entry (DT_PLTGOT, 0)
2379 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2380 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2381 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2382 return FALSE;
252b5132
RH		 2383 }
2384
2385 if (relocs)
2386 {
dc810e39
AM		 2387 if (!add_dynamic_entry (DT_REL, 0)
2388 || !add_dynamic_entry (DT_RELSZ, 0)
2389 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 2390 return FALSE;
252b5132 2391
0c715baa
AM		 2392 /* If any dynamic relocs apply to a read-only section,
2393 then we need a DT_TEXTREL entry. */
248866a8
AM		 2394 if ((info->flags & DF_TEXTREL) == 0)
2395 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2396 (PTR) info);
0c715baa
AM		 2397
2398 if ((info->flags & DF_TEXTREL) != 0)
2399 {
2400 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2401 return FALSE;
0c715baa 2402 }
252b5132 2403 }
7a2b07ff
NS		 2404 if (htab->is_vxworks
2405 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2406 return FALSE;
252b5132 2407 }
dc810e39 2408#undef add_dynamic_entry
252b5132 2409
b34976b6 2410 return TRUE;
252b5132
RH		 2411}
2412
67a4f2b7
AO		 2413static bfd_boolean
2414elf_i386_always_size_sections (bfd *output_bfd,
2415 struct bfd_link_info *info)
2416{
2417 asection *tls_sec = elf_hash_table (info)->tls_sec;
2418
2419 if (tls_sec)
2420 {
2421 struct elf_link_hash_entry *tlsbase;
2422
2423 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2424 "_TLS_MODULE_BASE_",
2425 FALSE, FALSE, FALSE);
2426
2427 if (tlsbase && tlsbase->type == STT_TLS)
2428 {
2429 struct bfd_link_hash_entry *bh = NULL;
2430 const struct elf_backend_data *bed
2431 = get_elf_backend_data (output_bfd);
2432
2433 if (!(_bfd_generic_link_add_one_symbol
2434 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2435 tls_sec, 0, NULL, FALSE,
2436 bed->collect, &bh)))
2437 return FALSE;
9f03412a
AO		 2438
2439 elf_i386_hash_table (info)->tls_module_base = bh;
2440
67a4f2b7
AO		 2441 tlsbase = (struct elf_link_hash_entry *)bh;
2442 tlsbase->def_regular = 1;
2443 tlsbase->other = STV_HIDDEN;
2444 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2445 }
2446 }
2447
2448 return TRUE;
2449}
2450
38701953
AM		 2451/* Set the correct type for an x86 ELF section. We do this by the
2452 section name, which is a hack, but ought to work. */
2453
b34976b6 2454static bfd_boolean
55fd94b0
AM		 2455elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2456 Elf_Internal_Shdr *hdr,
2457 asection *sec)
38701953
AM		 2458{
2459 register const char *name;
2460
2461 name = bfd_get_section_name (abfd, sec);
2462
2463 /* This is an ugly, but unfortunately necessary hack that is
2464 needed when producing EFI binaries on x86. It tells
2465 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2466 containing ELF relocation info. We need this hack in order to
2467 be able to generate ELF binaries that can be translated into
2468 EFI applications (which are essentially COFF objects). Those
2469 files contain a COFF ".reloc" section inside an ELFNN object,
2470 which would normally cause BFD to segfault because it would
2471 attempt to interpret this section as containing relocation
2472 entries for section "oc". With this hack enabled, ".reloc"
2473 will be treated as a normal data section, which will avoid the
2474 segfault. However, you won't be able to create an ELFNN binary
2475 with a section named "oc" that needs relocations, but that's
2476 the kind of ugly side-effects you get when detecting section
2477 types based on their names... In practice, this limitation is
2478 unlikely to bite. */
2479 if (strcmp (name, ".reloc") == 0)
2480 hdr->sh_type = SHT_PROGBITS;
2481
b34976b6 2482 return TRUE;
38701953
AM		 2483}
2484
9f03412a
AO		 2485/* _TLS_MODULE_BASE_ needs to be treated especially when linking
2486 executables. Rather than setting it to the beginning of the TLS
2487 section, we have to set it to the end. This function may be called
2488 multiple times, it is idempotent. */
2489
2490static void
2491set_tls_module_base (struct bfd_link_info *info)
2492{
2493 struct bfd_link_hash_entry *base;
2494
2495 if (!info->executable)
2496 return;
2497
2498 base = elf_i386_hash_table (info)->tls_module_base;
2499
2500 if (!base)
2501 return;
2502
2503 base->u.def.value = elf_hash_table (info)->tls_size;
2504}
2505
13ae64f3
JJ		 2506/* Return the base VMA address which should be subtracted from real addresses
2507 when resolving @dtpoff relocation.
2508 This is PT_TLS segment p_vaddr. */
2509
2510static bfd_vma
55fd94b0 2511dtpoff_base (struct bfd_link_info *info)
13ae64f3 2512{
e1918d23
AM		 2513 /* If tls_sec is NULL, we should have signalled an error already. */
2514 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 2515 return 0;
e1918d23 2516 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 2517}
2518
2519/* Return the relocation value for @tpoff relocation
2520 if STT_TLS virtual address is ADDRESS. */
2521
2522static bfd_vma
55fd94b0 2523tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 2524{
e1918d23 2525 struct elf_link_hash_table *htab = elf_hash_table (info);
13ae64f3 2526
e1918d23
AM		 2527 /* If tls_sec is NULL, we should have signalled an error already. */
2528 if (htab->tls_sec == NULL)
6a30718d 2529 return 0;
e1918d23 2530 return htab->tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 2531}
2532
252b5132
RH		 2533/* Relocate an i386 ELF section. */
2534
b34976b6 2535static bfd_boolean
55fd94b0
AM		 2536elf_i386_relocate_section (bfd *output_bfd,
2537 struct bfd_link_info *info,
2538 bfd *input_bfd,
2539 asection *input_section,
2540 bfd_byte *contents,
2541 Elf_Internal_Rela *relocs,
2542 Elf_Internal_Sym *local_syms,
2543 asection **local_sections)
252b5132 2544{
6725bdbf 2545 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2546 Elf_Internal_Shdr *symtab_hdr;
2547 struct elf_link_hash_entry **sym_hashes;
2548 bfd_vma *local_got_offsets;
67a4f2b7 2549 bfd_vma *local_tlsdesc_gotents;
252b5132
RH		 2550 Elf_Internal_Rela *rel;
2551 Elf_Internal_Rela *relend;
3348747a 2552 bfd_boolean is_vxworks_tls;
252b5132 2553
0ffa91dd
NC		 2554 BFD_ASSERT (is_i386_elf (input_bfd));
2555
6725bdbf 2556 htab = elf_i386_hash_table (info);
0ffa91dd 2557 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 2558 sym_hashes = elf_sym_hashes (input_bfd);
2559 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 2560 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 2561 /* We have to handle relocations in vxworks .tls_vars sections
2562 specially, because the dynamic loader is 'weird'. */
2563 is_vxworks_tls = (htab->is_vxworks && info->shared
2564 && !strcmp (input_section->output_section->name,
2565 ".tls_vars"));
252b5132 2566
9f03412a
AO		 2567 set_tls_module_base (info);
2568
252b5132
RH		 2569 rel = relocs;
2570 relend = relocs + input_section->reloc_count;
2571 for (; rel < relend; rel++)
2572 {
13ae64f3 2573 unsigned int r_type;
252b5132
RH		 2574 reloc_howto_type *howto;
2575 unsigned long r_symndx;
2576 struct elf_link_hash_entry *h;
2577 Elf_Internal_Sym *sym;
2578 asection *sec;
67a4f2b7 2579 bfd_vma off, offplt;
252b5132 2580 bfd_vma relocation;
b34976b6 2581 bfd_boolean unresolved_reloc;
252b5132 2582 bfd_reloc_status_type r;
1b452ec6 2583 unsigned int indx;
13ae64f3 2584 int tls_type;
252b5132
RH		 2585
2586 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 2587 if (r_type == R_386_GNU_VTINHERIT
2588 || r_type == R_386_GNU_VTENTRY)
252b5132 2589 continue;
dc47f327 2590
55fd94b0 2591 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 2592 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2593 >= R_386_ext - R_386_standard)
2594 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2595 >= R_386_tls - R_386_ext))
252b5132 2596 {
6ba842b6 2597 (*_bfd_error_handler)
d003868e
AM		 2598 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2599 input_bfd, input_section, r_type);
252b5132 2600 bfd_set_error (bfd_error_bad_value);
b34976b6 2601 return FALSE;
252b5132 2602 }
1b452ec6 2603 howto = elf_howto_table + indx;
252b5132
RH		 2604
2605 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 2606 h = NULL;
2607 sym = NULL;
2608 sec = NULL;
b34976b6 2609 unresolved_reloc = FALSE;
252b5132
RH		 2610 if (r_symndx < symtab_hdr->sh_info)
2611 {
2612 sym = local_syms + r_symndx;
2613 sec = local_sections[r_symndx];
2614 relocation = (sec->output_section->vma
2615 + sec->output_offset
2616 + sym->st_value);
ab96bf03
AM		 2617
2618 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2619 && ((sec->flags & SEC_MERGE) != 0
2620 || (info->relocatable
2621 && sec->output_offset != 0)))
f8df10f4 2622 {
f8df10f4 2623 bfd_vma addend;
4a335f3d 2624 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2625
4a335f3d 2626 switch (howto->size)
f8df10f4 2627 {
4a335f3d
AM		 2628 case 0:
2629 addend = bfd_get_8 (input_bfd, where);
2630 if (howto->pc_relative)
2631 {
2632 addend = (addend ^ 0x80) - 0x80;
2633 addend += 1;
2634 }
2635 break;
2636 case 1:
2637 addend = bfd_get_16 (input_bfd, where);
2638 if (howto->pc_relative)
2639 {
2640 addend = (addend ^ 0x8000) - 0x8000;
2641 addend += 2;
2642 }
2643 break;
2644 case 2:
2645 addend = bfd_get_32 (input_bfd, where);
2646 if (howto->pc_relative)
2647 {
2648 addend = (addend ^ 0x80000000) - 0x80000000;
2649 addend += 4;
2650 }
2651 break;
2652 default:
2653 abort ();
f8df10f4
JJ		 2654 }
2655
ab96bf03
AM		 2656 if (info->relocatable)
2657 addend += sec->output_offset;
2658 else
2659 {
2660 asection *msec = sec;
2661 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
2662 addend);
2663 addend -= relocation;
2664 addend += msec->output_section->vma + msec->output_offset;
2665 }
4a335f3d
AM		 2666
2667 switch (howto->size)
2668 {
2669 case 0:
16a10388 2670 /* FIXME: overflow checks. */
4a335f3d
AM		 2671 if (howto->pc_relative)
2672 addend -= 1;
2673 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2674 break;
2675 case 1:
2676 if (howto->pc_relative)
2677 addend -= 2;
2678 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2679 break;
2680 case 2:
2681 if (howto->pc_relative)
2682 addend -= 4;
2683 bfd_put_32 (input_bfd, addend, where);
2684 break;
2685 }
f8df10f4 2686 }
252b5132
RH		 2687 }
2688 else
2689 {
560e09e9 2690 bfd_boolean warned;
ffb2e45b 2691
b2a8e766
AM		 2692 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2693 r_symndx, symtab_hdr, sym_hashes,
2694 h, sec, relocation,
2695 unresolved_reloc, warned);
252b5132
RH		 2696 }
2697
ab96bf03 2698 if (sec != NULL && elf_discarded_section (sec))
9635fe29 2699 {
ab96bf03
AM		 2700 /* For relocs against symbols from removed linkonce sections,
2701 or sections discarded by a linker script, we just want the
2702 section contents zeroed. Avoid any special processing. */
b1e24c02 2703 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
ab96bf03
AM		 2704 rel->r_info = 0;
2705 rel->r_addend = 0;
b1e24c02 2706 continue;
9635fe29
AM		 2707 }
2708
ab96bf03
AM		 2709 if (info->relocatable)
2710 continue;
2711
252b5132
RH		 2712 switch (r_type)
2713 {
2714 case R_386_GOT32:
2715 /* Relocation is to the entry for this symbol in the global
2716 offset table. */
ffb2e45b
AM		 2717 if (htab->sgot == NULL)
2718 abort ();
252b5132
RH		 2719
2720 if (h != NULL)
2721 {
b34976b6 2722 bfd_boolean dyn;
252b5132
RH		 2723
2724 off = h->got.offset;
ebe50bae 2725 dyn = htab->elf.dynamic_sections_created;
26e41594 2726 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2727 || (info->shared
586119b3 2728 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 2729 || (ELF_ST_VISIBILITY (h->other)
2730 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2731 {
2732 /* This is actually a static link, or it is a
2733 -Bsymbolic link and the symbol is defined
2734 locally, or the symbol was forced to be local
2735 because of a version file. We must initialize
2736 this entry in the global offset table. Since the
2737 offset must always be a multiple of 4, we use the
2738 least significant bit to record whether we have
2739 initialized it already.
2740
2741 When doing a dynamic link, we create a .rel.got
2742 relocation entry to initialize the value. This
2743 is done in the finish_dynamic_symbol routine. */
2744 if ((off & 1) != 0)
2745 off &= ~1;
2746 else
2747 {
2748 bfd_put_32 (output_bfd, relocation,
6725bdbf 2749 htab->sgot->contents + off);
252b5132
RH		 2750 h->got.offset |= 1;
2751 }
2752 }
8c694914 2753 else
b34976b6 2754 unresolved_reloc = FALSE;
252b5132
RH		 2755 }
2756 else
2757 {
ffb2e45b
AM		 2758 if (local_got_offsets == NULL)
2759 abort ();
252b5132
RH		 2760
2761 off = local_got_offsets[r_symndx];
2762
2763 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2764 the least significant bit to record whether we have
2765 already generated the necessary reloc. */
252b5132
RH		 2766 if ((off & 1) != 0)
2767 off &= ~1;
2768 else
2769 {
6725bdbf
AM		 2770 bfd_put_32 (output_bfd, relocation,
2771 htab->sgot->contents + off);
252b5132
RH		 2772
2773 if (info->shared)
2774 {
947216bf
AM		 2775 asection *s;
2776 Elf_Internal_Rela outrel;
2777 bfd_byte *loc;
252b5132 2778
947216bf
AM		 2779 s = htab->srelgot;
2780 if (s == NULL)
ffb2e45b 2781 abort ();
252b5132 2782
6725bdbf
AM		 2783 outrel.r_offset = (htab->sgot->output_section->vma
2784 + htab->sgot->output_offset
252b5132
RH		 2785 + off);
2786 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 2787 loc = s->contents;
2788 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 2789 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2790 }
2791
2792 local_got_offsets[r_symndx] |= 1;
2793 }
252b5132
RH		 2794 }
2795
ffb2e45b
AM		 2796 if (off >= (bfd_vma) -2)
2797 abort ();
2798
8c37241b
JJ		 2799 relocation = htab->sgot->output_section->vma
2800 + htab->sgot->output_offset + off
2801 - htab->sgotplt->output_section->vma
2802 - htab->sgotplt->output_offset;
252b5132
RH		 2803 break;
2804
2805 case R_386_GOTOFF:
2806 /* Relocation is relative to the start of the global offset
2807 table. */
2808
90f487df
L		 2809 /* Check to make sure it isn't a protected function symbol
2810 for shared library since it may not be local when used
41bed6dd
L		 2811 as function address. We also need to make sure that a
2812 symbol is defined locally. */
2813 if (info->shared && h)
90f487df 2814 {
41bed6dd
L		 2815 if (!h->def_regular)
2816 {
2817 const char *v;
2818
2819 switch (ELF_ST_VISIBILITY (h->other))
2820 {
2821 case STV_HIDDEN:
2822 v = _("hidden symbol");
2823 break;
2824 case STV_INTERNAL:
2825 v = _("internal symbol");
2826 break;
2827 case STV_PROTECTED:
2828 v = _("protected symbol");
2829 break;
2830 default:
2831 v = _("symbol");
2832 break;
2833 }
2834
2835 (*_bfd_error_handler)
2836 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
2837 input_bfd, v, h->root.root.string);
2838 bfd_set_error (bfd_error_bad_value);
2839 return FALSE;
2840 }
2841 else if (!info->executable
2842 && h->type == STT_FUNC
2843 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2844 {
2845 (*_bfd_error_handler)
2846 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
2847 input_bfd, h->root.root.string);
2848 bfd_set_error (bfd_error_bad_value);
2849 return FALSE;
2850 }
90f487df
L		 2851 }
2852
8c37241b
JJ		 2853 /* Note that sgot is not involved in this
2854 calculation. We always want the start of .got.plt. If we
2855 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 2856 permitted by the ABI, we might have to change this
2857 calculation. */
8c37241b
JJ		 2858 relocation -= htab->sgotplt->output_section->vma
2859 + htab->sgotplt->output_offset;
252b5132
RH		 2860 break;
2861
2862 case R_386_GOTPC:
2863 /* Use global offset table as symbol value. */
8c37241b
JJ		 2864 relocation = htab->sgotplt->output_section->vma
2865 + htab->sgotplt->output_offset;
b34976b6 2866 unresolved_reloc = FALSE;
252b5132
RH		 2867 break;
2868
2869 case R_386_PLT32:
2870 /* Relocation is to the entry for this symbol in the
2871 procedure linkage table. */
2872
dd5724d5 2873 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2874 without using the procedure linkage table. */
252b5132
RH		 2875 if (h == NULL)
2876 break;
2877
dd5724d5 2878 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2879 || htab->splt == NULL)
252b5132
RH		 2880 {
2881 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2882 happens when statically linking PIC code, or when
2883 using -Bsymbolic. */
252b5132
RH		 2884 break;
2885 }
2886
6725bdbf
AM		 2887 relocation = (htab->splt->output_section->vma
2888 + htab->splt->output_offset
252b5132 2889 + h->plt.offset);
b34976b6 2890 unresolved_reloc = FALSE;
252b5132
RH		 2891 break;
2892
2893 case R_386_32:
2894 case R_386_PC32:
3348747a
NS		 2895 if ((input_section->flags & SEC_ALLOC) == 0
2896 || is_vxworks_tls)
ec338859
AM		 2897 break;
2898
12d0ee4a 2899 if ((info->shared
ef5aade5
L		 2900 && (h == NULL
2901 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2902 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a 2903 && (r_type != R_386_PC32
f6c52c13 2904 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845
AM		 2905 || (ELIMINATE_COPY_RELOCS
2906 && !info->shared
12d0ee4a
AM		 2907 && h != NULL
2908 && h->dynindx != -1
f5385ebf
AM		 2909 && !h->non_got_ref
2910 && ((h->def_dynamic
2911 && !h->def_regular)
28d0b90e
AM		 2912 || h->root.type == bfd_link_hash_undefweak
2913 || h->root.type == bfd_link_hash_undefined)))
252b5132 2914 {
947216bf
AM		 2915 Elf_Internal_Rela outrel;
2916 bfd_byte *loc;
b34976b6 2917 bfd_boolean skip, relocate;
0c715baa 2918 asection *sreloc;
252b5132
RH		 2919
2920 /* When generating a shared object, these relocations
2921 are copied into the output file to be resolved at run
2922 time. */
2923
b34976b6
AM		 2924 skip = FALSE;
2925 relocate = FALSE;
252b5132 2926
c629eae0
JJ		 2927 outrel.r_offset =
2928 _bfd_elf_section_offset (output_bfd, info, input_section,
2929 rel->r_offset);
2930 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2931 skip = TRUE;
0bb2d96a 2932 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2933 skip = TRUE, relocate = TRUE;
252b5132
RH		 2934 outrel.r_offset += (input_section->output_section->vma
2935 + input_section->output_offset);
2936
2937 if (skip)
0bb2d96a 2938 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2939 else if (h != NULL
2940 && h->dynindx != -1
2941 && (r_type == R_386_PC32
2942 || !info->shared
55255dae 2943 || !SYMBOLIC_BIND (info, h)
f5385ebf 2944 || !h->def_regular))
0bb2d96a 2945 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2946 else
2947 {
5a15f56f 2948 /* This symbol is local, or marked to become local. */
b34976b6 2949 relocate = TRUE;
5a15f56f 2950 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2951 }
2952
0c715baa
AM		 2953 sreloc = elf_section_data (input_section)->sreloc;
2954 if (sreloc == NULL)
2955 abort ();
2956
947216bf
AM		 2957 loc = sreloc->contents;
2958 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
0c715baa 2959 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2960
2961 /* If this reloc is against an external symbol, we do
2962 not want to fiddle with the addend. Otherwise, we
2963 need to include the symbol value so that it becomes
2964 an addend for the dynamic reloc. */
2965 if (! relocate)
2966 continue;
2967 }
252b5132
RH		 2968 break;
2969
37e55690
JJ		 2970 case R_386_TLS_IE:
2971 if (info->shared)
2972 {
947216bf
AM		 2973 Elf_Internal_Rela outrel;
2974 bfd_byte *loc;
37e55690 2975 asection *sreloc;
37e55690
JJ		 2976
2977 outrel.r_offset = rel->r_offset
2978 + input_section->output_section->vma
2979 + input_section->output_offset;
2980 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2981 sreloc = elf_section_data (input_section)->sreloc;
2982 if (sreloc == NULL)
2983 abort ();
947216bf
AM		 2984 loc = sreloc->contents;
2985 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2986 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2987 }
2988 /* Fall through */
2989
13ae64f3 2990 case R_386_TLS_GD:
67a4f2b7
AO		 2991 case R_386_TLS_GOTDESC:
2992 case R_386_TLS_DESC_CALL:
13ae64f3 2993 case R_386_TLS_IE_32:
37e55690 2994 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2995 tls_type = GOT_UNKNOWN;
2996 if (h == NULL && local_got_offsets)
2997 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2998 else if (h != NULL)
142411ca 2999 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 3000 if (tls_type == GOT_TLS_IE)
3001 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 3002
3003 if (! elf_i386_tls_transition (info, input_bfd,
3004 input_section, contents,
3005 symtab_hdr, sym_hashes,
3006 &r_type, tls_type, rel,
3007 relend, h))
3008 return FALSE;
13ae64f3
JJ		 3009
3010 if (r_type == R_386_TLS_LE_32)
3011 {
82e51918 3012 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 3013 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3014 {
142411ca 3015 unsigned int type;
13ae64f3
JJ		 3016 bfd_vma roff;
3017
3018 /* GD->LE transition. */
13ae64f3 3019 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 3020 if (type == 0x04)
3021 {
3022 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3023 Change it into:
3024 movl %gs:0, %eax; subl $foo@tpoff, %eax
3025 (6 byte form of subl). */
13ae64f3
JJ		 3026 memcpy (contents + rel->r_offset - 3,
3027 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
142411ca 3028 roff = rel->r_offset + 5;
13ae64f3
JJ		 3029 }
3030 else
3031 {
142411ca
L		 3032 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3033 Change it into:
3034 movl %gs:0, %eax; subl $foo@tpoff, %eax
3035 (6 byte form of subl). */
3036 memcpy (contents + rel->r_offset - 2,
3037 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3038 roff = rel->r_offset + 6;
13ae64f3
JJ		 3039 }
3040 bfd_put_32 (output_bfd, tpoff (info, relocation),
3041 contents + roff);
a3fadc9a 3042 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 3043 rel++;
3044 continue;
3045 }
67a4f2b7
AO		 3046 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3047 {
3048 /* GDesc -> LE transition.
3049 It's originally something like:
3050 leal x@tlsdesc(%ebx), %eax
3051
3052 leal x@ntpoff, %eax
3053
3054 Registers other than %eax may be set up here. */
3055
142411ca 3056 unsigned int val;
67a4f2b7
AO		 3057 bfd_vma roff;
3058
67a4f2b7 3059 roff = rel->r_offset;
67a4f2b7 3060 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 3061
3062 /* Now modify the instruction as appropriate. */
3063 /* aoliva FIXME: remove the above and xor the byte
3064 below with 0x86. */
3065 bfd_put_8 (output_bfd, val ^ 0x86,
3066 contents + roff - 1);
3067 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3068 contents + roff);
3069 continue;
3070 }
3071 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3072 {
3073 /* GDesc -> LE transition.
3074 It's originally:
3075 call *(%eax)
3076 Turn it into:
142411ca 3077 xchg %ax,%ax */
67a4f2b7 3078
67a4f2b7 3079 bfd_vma roff;
142411ca 3080
67a4f2b7 3081 roff = rel->r_offset;
10efb593 3082 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3083 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3084 continue;
3085 }
37e55690 3086 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 3087 {
142411ca 3088 unsigned int val;
13ae64f3
JJ		 3089
3090 /* IE->LE transition:
37e55690
JJ		 3091 Originally it can be one of:
3092 movl foo, %eax
3093 movl foo, %reg
3094 addl foo, %reg
3095 We change it into:
3096 movl $foo, %eax
3097 movl $foo, %reg
3098 addl $foo, %reg. */
37e55690 3099 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 3100 if (val == 0xa1)
3101 {
3102 /* movl foo, %eax. */
55fd94b0
AM		 3103 bfd_put_8 (output_bfd, 0xb8,
3104 contents + rel->r_offset - 1);
37e55690 3105 }
299bf759 3106 else
37e55690 3107 {
142411ca
L		 3108 unsigned int type;
3109
55fd94b0
AM		 3110 type = bfd_get_8 (input_bfd,
3111 contents + rel->r_offset - 2);
299bf759 3112 switch (type)
26e41594 3113 {
299bf759
L		 3114 case 0x8b:
3115 /* movl */
299bf759
L		 3116 bfd_put_8 (output_bfd, 0xc7,
3117 contents + rel->r_offset - 2);
3118 bfd_put_8 (output_bfd,
3119 0xc0 | ((val >> 3) & 7),
3120 contents + rel->r_offset - 1);
3121 break;
3122 case 0x03:
3123 /* addl */
299bf759
L		 3124 bfd_put_8 (output_bfd, 0x81,
3125 contents + rel->r_offset - 2);
3126 bfd_put_8 (output_bfd,
3127 0xc0 | ((val >> 3) & 7),
3128 contents + rel->r_offset - 1);
3129 break;
3130 default:
3131 BFD_FAIL ();
3132 break;
26e41594 3133 }
37e55690 3134 }
37e55690
JJ		 3135 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3136 contents + rel->r_offset);
3137 continue;
3138 }
3139 else
3140 {
3141 unsigned int val, type;
3142
3143 /* {IE_32,GOTIE}->LE transition:
3144 Originally it can be one of:
13ae64f3 3145 subl foo(%reg1), %reg2
13ae64f3 3146 movl foo(%reg1), %reg2
37e55690 3147 addl foo(%reg1), %reg2
13ae64f3
JJ		 3148 We change it into:
3149 subl $foo, %reg2
37e55690
JJ		 3150 movl $foo, %reg2 (6 byte form)
3151 addl $foo, %reg2. */
13ae64f3
JJ		 3152 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3153 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 3154 if (type == 0x8b)
3155 {
3156 /* movl */
13ae64f3
JJ		 3157 bfd_put_8 (output_bfd, 0xc7,
3158 contents + rel->r_offset - 2);
3159 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3160 contents + rel->r_offset - 1);
3161 }
3162 else if (type == 0x2b)
3163 {
3164 /* subl */
13ae64f3
JJ		 3165 bfd_put_8 (output_bfd, 0x81,
3166 contents + rel->r_offset - 2);
3167 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3168 contents + rel->r_offset - 1);
3169 }
37e55690
JJ		 3170 else if (type == 0x03)
3171 {
3172 /* addl */
3173 bfd_put_8 (output_bfd, 0x81,
3174 contents + rel->r_offset - 2);
3175 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3176 contents + rel->r_offset - 1);
3177 }
13ae64f3
JJ		 3178 else
3179 BFD_FAIL ();
37e55690
JJ		 3180 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
3181 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3182 contents + rel->r_offset);
3183 else
3184 bfd_put_32 (output_bfd, tpoff (info, relocation),
3185 contents + rel->r_offset);
13ae64f3
JJ		 3186 continue;
3187 }
3188 }
3189
3190 if (htab->sgot == NULL)
3191 abort ();
3192
3193 if (h != NULL)
67a4f2b7
AO		 3194 {
3195 off = h->got.offset;
3196 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3197 }
13ae64f3
JJ		 3198 else
3199 {
3200 if (local_got_offsets == NULL)
3201 abort ();
3202
3203 off = local_got_offsets[r_symndx];
67a4f2b7 3204 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 3205 }
3206
3207 if ((off & 1) != 0)
3208 off &= ~1;
26e41594 3209 else
13ae64f3 3210 {
947216bf
AM		 3211 Elf_Internal_Rela outrel;
3212 bfd_byte *loc;
13ae64f3 3213 int dr_type, indx;
67a4f2b7 3214 asection *sreloc;
13ae64f3
JJ		 3215
3216 if (htab->srelgot == NULL)
3217 abort ();
3218
67a4f2b7
AO		 3219 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3220
3221 if (GOT_TLS_GDESC_P (tls_type))
3222 {
3223 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3224 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3225 <= htab->sgotplt->size);
3226 outrel.r_offset = (htab->sgotplt->output_section->vma
3227 + htab->sgotplt->output_offset
3228 + offplt
3229 + htab->sgotplt_jump_table_size);
3230 sreloc = htab->srelplt;
3231 loc = sreloc->contents;
5ae0bfb6
RS		 3232 loc += (htab->next_tls_desc_index++
3233 * sizeof (Elf32_External_Rel));
67a4f2b7
AO		 3234 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3235 <= sreloc->contents + sreloc->size);
3236 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3237 if (indx == 0)
3238 {
3239 BFD_ASSERT (! unresolved_reloc);
3240 bfd_put_32 (output_bfd,
3241 relocation - dtpoff_base (info),
3242 htab->sgotplt->contents + offplt
3243 + htab->sgotplt_jump_table_size + 4);
3244 }
3245 else
3246 {
3247 bfd_put_32 (output_bfd, 0,
3248 htab->sgotplt->contents + offplt
3249 + htab->sgotplt_jump_table_size + 4);
3250 }
3251 }
3252
3253 sreloc = htab->srelgot;
3254
13ae64f3
JJ		 3255 outrel.r_offset = (htab->sgot->output_section->vma
3256 + htab->sgot->output_offset + off);
3257
67a4f2b7 3258 if (GOT_TLS_GD_P (tls_type))
13ae64f3 3259 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 3260 else if (GOT_TLS_GDESC_P (tls_type))
3261 goto dr_done;
37e55690
JJ		 3262 else if (tls_type == GOT_TLS_IE_POS)
3263 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 3264 else
3265 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 3266
37e55690
JJ		 3267 if (dr_type == R_386_TLS_TPOFF && indx == 0)
3268 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3269 htab->sgot->contents + off);
3270 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 3271 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e 3272 htab->sgot->contents + off);
67a4f2b7 3273 else if (dr_type != R_386_TLS_DESC)
c366c25e
JJ		 3274 bfd_put_32 (output_bfd, 0,
3275 htab->sgot->contents + off);
13ae64f3 3276 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7
AO		 3277
3278 loc = sreloc->contents;
3279 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3280 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3281 <= sreloc->contents + sreloc->size);
13ae64f3
JJ		 3282 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3283
67a4f2b7 3284 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 3285 {
3286 if (indx == 0)
3287 {
82e51918 3288 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 3289 bfd_put_32 (output_bfd,
3290 relocation - dtpoff_base (info),
3291 htab->sgot->contents + off + 4);
3292 }
3293 else
3294 {
3295 bfd_put_32 (output_bfd, 0,
3296 htab->sgot->contents + off + 4);
3297 outrel.r_info = ELF32_R_INFO (indx,
3298 R_386_TLS_DTPOFF32);
3299 outrel.r_offset += 4;
67a4f2b7 3300 sreloc->reloc_count++;
947216bf 3301 loc += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3302 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3303 <= sreloc->contents + sreloc->size);
947216bf 3304 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 3305 }
3306 }
37e55690
JJ		 3307 else if (tls_type == GOT_TLS_IE_BOTH)
3308 {
3309 bfd_put_32 (output_bfd,
3310 indx == 0 ? relocation - dtpoff_base (info) : 0,
3311 htab->sgot->contents + off + 4);
3312 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3313 outrel.r_offset += 4;
67a4f2b7 3314 sreloc->reloc_count++;
947216bf 3315 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 3316 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3317 }
13ae64f3 3318
67a4f2b7 3319 dr_done:
13ae64f3
JJ		 3320 if (h != NULL)
3321 h->got.offset |= 1;
3322 else
3323 local_got_offsets[r_symndx] |= 1;
3324 }
3325
67a4f2b7
AO		 3326 if (off >= (bfd_vma) -2
3327 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 3328 abort ();
67a4f2b7
AO		 3329 if (r_type == R_386_TLS_GOTDESC
3330 || r_type == R_386_TLS_DESC_CALL)
3331 {
3332 relocation = htab->sgotplt_jump_table_size + offplt;
3333 unresolved_reloc = FALSE;
3334 }
3335 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 3336 {
8c37241b
JJ		 3337 bfd_vma g_o_t = htab->sgotplt->output_section->vma
3338 + htab->sgotplt->output_offset;
3339 relocation = htab->sgot->output_section->vma
67a4f2b7 3340 + htab->sgot->output_offset + off - g_o_t;
37e55690
JJ		 3341 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3342 && tls_type == GOT_TLS_IE_BOTH)
3343 relocation += 4;
3344 if (r_type == R_386_TLS_IE)
8c37241b 3345 relocation += g_o_t;
b34976b6 3346 unresolved_reloc = FALSE;
13ae64f3 3347 }
67a4f2b7 3348 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 3349 {
3350 unsigned int val, type;
3351 bfd_vma roff;
3352
3353 /* GD->IE transition. */
13ae64f3 3354 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 3355 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3356 if (type == 0x04)
3357 {
3358 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3359 Change it into:
3360 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3 3361 val >>= 3;
142411ca 3362 roff = rel->r_offset - 3;
13ae64f3
JJ		 3363 }
3364 else
3365 {
3366 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3367 Change it into:
3368 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 3369 roff = rel->r_offset - 2;
3370 }
3371 memcpy (contents + roff,
3372 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3373 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 3374 /* If foo is used only with foo@gotntpoff(%reg) and
3375 foo@indntpoff, but not with foo@gottpoff(%reg), change
3376 subl $foo@gottpoff(%reg), %eax
3377 into:
3378 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 3379 if (tls_type == GOT_TLS_IE_POS)
3380 contents[roff + 6] = 0x03;
8c37241b
JJ		 3381 bfd_put_32 (output_bfd,
3382 htab->sgot->output_section->vma
3383 + htab->sgot->output_offset + off
3384 - htab->sgotplt->output_section->vma
3385 - htab->sgotplt->output_offset,
13ae64f3
JJ		 3386 contents + roff + 8);
3387 /* Skip R_386_PLT32. */
3388 rel++;
3389 continue;
3390 }
67a4f2b7
AO		 3391 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3392 {
3393 /* GDesc -> IE transition.
3394 It's originally something like:
3395 leal x@tlsdesc(%ebx), %eax
3396
3397 Change it to:
142411ca 3398 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 3399 or:
3400 movl x@gottpoff(%ebx), %eax # before negl %eax
3401
3402 Registers other than %eax may be set up here. */
3403
67a4f2b7
AO		 3404 bfd_vma roff;
3405
3406 /* First, make sure it's a leal adding ebx to a 32-bit
3407 offset into any register, although it's probably
3408 almost always going to be eax. */
3409 roff = rel->r_offset;
67a4f2b7
AO		 3410
3411 /* Now modify the instruction as appropriate. */
3412 /* To turn a leal into a movl in the form we use it, it
3413 suffices to change the first byte from 0x8d to 0x8b.
3414 aoliva FIXME: should we decide to keep the leal, all
3415 we have to do is remove the statement below, and
3416 adjust the relaxation of R_386_TLS_DESC_CALL. */
3417 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3418
3419 if (tls_type == GOT_TLS_IE_BOTH)
3420 off += 4;
3421
3422 bfd_put_32 (output_bfd,
3423 htab->sgot->output_section->vma
3424 + htab->sgot->output_offset + off
3425 - htab->sgotplt->output_section->vma
3426 - htab->sgotplt->output_offset,
3427 contents + roff);
3428 continue;
3429 }
3430 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3431 {
3432 /* GDesc -> IE transition.
3433 It's originally:
3434 call *(%eax)
3435
3436 Change it to:
142411ca 3437 xchg %ax,%ax
67a4f2b7
AO		 3438 or
3439 negl %eax
3440 depending on how we transformed the TLS_GOTDESC above.
3441 */
3442
67a4f2b7
AO		 3443 bfd_vma roff;
3444
67a4f2b7 3445 roff = rel->r_offset;
67a4f2b7
AO		 3446
3447 /* Now modify the instruction as appropriate. */
3448 if (tls_type != GOT_TLS_IE_NEG)
3449 {
10efb593
L		 3450 /* xchg %ax,%ax */
3451 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3452 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3453 }
3454 else
3455 {
3456 /* negl %eax */
3457 bfd_put_8 (output_bfd, 0xf7, contents + roff);
3458 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
3459 }
3460
3461 continue;
3462 }
3463 else
3464 BFD_ASSERT (FALSE);
13ae64f3
JJ		 3465 break;
3466
3467 case R_386_TLS_LDM:
142411ca
L		 3468 if (! elf_i386_tls_transition (info, input_bfd,
3469 input_section, contents,
3470 symtab_hdr, sym_hashes,
3471 &r_type, GOT_UNKNOWN, rel,
3472 relend, h))
3473 return FALSE;
13ae64f3 3474
142411ca
L		 3475 if (r_type != R_386_TLS_LDM)
3476 {
13ae64f3 3477 /* LD->LE transition:
13ae64f3
JJ		 3478 leal foo(%reg), %eax; call ___tls_get_addr.
3479 We change it into:
3480 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
142411ca 3481 BFD_ASSERT (r_type == R_386_TLS_LE_32);
13ae64f3
JJ		 3482 memcpy (contents + rel->r_offset - 2,
3483 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 3484 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 3485 rel++;
3486 continue;
3487 }
3488
3489 if (htab->sgot == NULL)
3490 abort ();
3491
3492 off = htab->tls_ldm_got.offset;
3493 if (off & 1)
3494 off &= ~1;
3495 else
3496 {
947216bf
AM		 3497 Elf_Internal_Rela outrel;
3498 bfd_byte *loc;
13ae64f3
JJ		 3499
3500 if (htab->srelgot == NULL)
3501 abort ();
3502
3503 outrel.r_offset = (htab->sgot->output_section->vma
3504 + htab->sgot->output_offset + off);
3505
3506 bfd_put_32 (output_bfd, 0,
3507 htab->sgot->contents + off);
3508 bfd_put_32 (output_bfd, 0,
3509 htab->sgot->contents + off + 4);
3510 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
947216bf
AM		 3511 loc = htab->srelgot->contents;
3512 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 3513 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3514 htab->tls_ldm_got.offset |= 1;
3515 }
8c37241b
JJ		 3516 relocation = htab->sgot->output_section->vma
3517 + htab->sgot->output_offset + off
3518 - htab->sgotplt->output_section->vma
3519 - htab->sgotplt->output_offset;
b34976b6 3520 unresolved_reloc = FALSE;
13ae64f3
JJ		 3521 break;
3522
3523 case R_386_TLS_LDO_32:
a45bb67d 3524 if (info->shared || (input_section->flags & SEC_CODE) == 0)
13ae64f3
JJ		 3525 relocation -= dtpoff_base (info);
3526 else
3527 /* When converting LDO to LE, we must negate. */
3528 relocation = -tpoff (info, relocation);
3529 break;
3530
3531 case R_386_TLS_LE_32:
13ae64f3 3532 case R_386_TLS_LE:
37e55690
JJ		 3533 if (info->shared)
3534 {
947216bf 3535 Elf_Internal_Rela outrel;
37e55690 3536 asection *sreloc;
947216bf 3537 bfd_byte *loc;
37e55690
JJ		 3538 int indx;
3539
3540 outrel.r_offset = rel->r_offset
3541 + input_section->output_section->vma
3542 + input_section->output_offset;
3543 if (h != NULL && h->dynindx != -1)
3544 indx = h->dynindx;
3545 else
3546 indx = 0;
3547 if (r_type == R_386_TLS_LE_32)
3548 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
3549 else
3550 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3551 sreloc = elf_section_data (input_section)->sreloc;
3552 if (sreloc == NULL)
3553 abort ();
947216bf
AM		 3554 loc = sreloc->contents;
3555 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 3556 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3557 if (indx)
3558 continue;
3559 else if (r_type == R_386_TLS_LE_32)
3560 relocation = dtpoff_base (info) - relocation;
3561 else
3562 relocation -= dtpoff_base (info);
3563 }
3564 else if (r_type == R_386_TLS_LE_32)
3565 relocation = tpoff (info, relocation);
3566 else
3567 relocation = -tpoff (info, relocation);
13ae64f3
JJ		 3568 break;
3569
252b5132
RH		 3570 default:
3571 break;
3572 }
3573
239e1f3a
AM		 3574 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3575 because such sections are not SEC_ALLOC and thus ld.so will
3576 not process them. */
8c694914 3577 if (unresolved_reloc
239e1f3a 3578 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 3579 && h->def_dynamic))
6a30718d
JJ		 3580 {
3581 (*_bfd_error_handler)
843fe662 3582 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 3583 input_bfd,
3584 input_section,
6a30718d 3585 (long) rel->r_offset,
843fe662 3586 howto->name,
6a30718d 3587 h->root.root.string);
b34976b6 3588 return FALSE;
6a30718d 3589 }
83be169b 3590
252b5132
RH		 3591 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3592 contents, rel->r_offset,
55fd94b0 3593 relocation, 0);
252b5132 3594
cf5c0c5b 3595 if (r != bfd_reloc_ok)
252b5132 3596 {
cf5c0c5b 3597 const char *name;
ffb2e45b 3598
cf5c0c5b
AM		 3599 if (h != NULL)
3600 name = h->root.root.string;
3601 else
3602 {
3603 name = bfd_elf_string_from_elf_section (input_bfd,
3604 symtab_hdr->sh_link,
3605 sym->st_name);
3606 if (name == NULL)
b34976b6 3607 return FALSE;
cf5c0c5b
AM		 3608 if (*name == '\0')
3609 name = bfd_section_name (input_bfd, sec);
3610 }
ffb2e45b 3611
cf5c0c5b
AM		 3612 if (r == bfd_reloc_overflow)
3613 {
cf5c0c5b 3614 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 3615 (info, (h ? &h->root : NULL), name, howto->name,
3616 (bfd_vma) 0, input_bfd, input_section,
3617 rel->r_offset)))
b34976b6 3618 return FALSE;
cf5c0c5b
AM		 3619 }
3620 else
3621 {
3622 (*_bfd_error_handler)
d003868e
AM		 3623 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3624 input_bfd, input_section,
cf5c0c5b 3625 (long) rel->r_offset, name, (int) r);
b34976b6 3626 return FALSE;
cf5c0c5b 3627 }
252b5132
RH		 3628 }
3629 }
3630
b34976b6 3631 return TRUE;
252b5132
RH		 3632}
3633
3634/* Finish up dynamic symbol handling. We set the contents of various
3635 dynamic sections here. */
3636
b34976b6 3637static bfd_boolean
55fd94b0
AM		 3638elf_i386_finish_dynamic_symbol (bfd *output_bfd,
3639 struct bfd_link_info *info,
3640 struct elf_link_hash_entry *h,
3641 Elf_Internal_Sym *sym)
252b5132 3642{
6725bdbf 3643 struct elf_i386_link_hash_table *htab;
252b5132 3644
6725bdbf 3645 htab = elf_i386_hash_table (info);
252b5132
RH		 3646
3647 if (h->plt.offset != (bfd_vma) -1)
3648 {
252b5132
RH		 3649 bfd_vma plt_index;
3650 bfd_vma got_offset;
947216bf
AM		 3651 Elf_Internal_Rela rel;
3652 bfd_byte *loc;
252b5132
RH		 3653
3654 /* This symbol has an entry in the procedure linkage table. Set
3655 it up. */
3656
ffb2e45b
AM		 3657 if (h->dynindx == -1
3658 || htab->splt == NULL
3659 || htab->sgotplt == NULL
3660 || htab->srelplt == NULL)
3661 abort ();
252b5132
RH		 3662
3663 /* Get the index in the procedure linkage table which
3664 corresponds to this symbol. This is the index of this symbol
3665 in all the symbols for which we are making plt entries. The
3666 first entry in the procedure linkage table is reserved. */
3667 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3668
3669 /* Get the offset into the .got table of the entry that
3670 corresponds to this function. Each .got entry is 4 bytes.
3671 The first three are reserved. */
3672 got_offset = (plt_index + 3) * 4;
3673
3674 /* Fill in the entry in the procedure linkage table. */
3675 if (! info->shared)
3676 {
6725bdbf 3677 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 3678 PLT_ENTRY_SIZE);
3679 bfd_put_32 (output_bfd,
6725bdbf
AM		 3680 (htab->sgotplt->output_section->vma
3681 + htab->sgotplt->output_offset
252b5132 3682 + got_offset),
6725bdbf 3683 htab->splt->contents + h->plt.offset + 2);
eac338cf
PB		 3684
3685 if (htab->is_vxworks)
3686 {
3687 int s, k, reloc_index;
3688
3689 /* Create the R_386_32 relocation referencing the GOT
3690 for this PLT entry. */
3691
3692 /* S: Current slot number (zero-based). */
3693 s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3694 /* K: Number of relocations for PLTResolve. */
3695 if (info->shared)
3696 k = PLTRESOLVE_RELOCS_SHLIB;
3697 else
3698 k = PLTRESOLVE_RELOCS;
3699 /* Skip the PLTresolve relocations, and the relocations for
3700 the other PLT slots. */
3701 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
3702 loc = (htab->srelplt2->contents + reloc_index
3703 * sizeof (Elf32_External_Rel));
3704
3705 rel.r_offset = (htab->splt->output_section->vma
3706 + htab->splt->output_offset
3707 + h->plt.offset + 2),
7325306f 3708 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 3709 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3710
3711 /* Create the R_386_32 relocation referencing the beginning of
3712 the PLT for this GOT entry. */
3713 rel.r_offset = (htab->sgotplt->output_section->vma
3714 + htab->sgotplt->output_offset
3715 + got_offset);
7325306f 3716 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 3717 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3718 loc + sizeof (Elf32_External_Rel));
3719 }
252b5132
RH		 3720 }
3721 else
3722 {
6725bdbf 3723 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 3724 PLT_ENTRY_SIZE);
3725 bfd_put_32 (output_bfd, got_offset,
6725bdbf 3726 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3727 }
3728
3729 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 3730 htab->splt->contents + h->plt.offset + 7);
252b5132 3731 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 3732 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 3733
3734 /* Fill in the entry in the global offset table. */
3735 bfd_put_32 (output_bfd,
6725bdbf
AM		 3736 (htab->splt->output_section->vma
3737 + htab->splt->output_offset
252b5132
RH		 3738 + h->plt.offset
3739 + 6),
6725bdbf 3740 htab->sgotplt->contents + got_offset);
252b5132
RH		 3741
3742 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 3743 rel.r_offset = (htab->sgotplt->output_section->vma
3744 + htab->sgotplt->output_offset
252b5132
RH		 3745 + got_offset);
3746 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
947216bf 3747 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 3748 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132 3749
f5385ebf 3750 if (!h->def_regular)
252b5132
RH		 3751 {
3752 /* Mark the symbol as undefined, rather than as defined in
c6585bbb
JJ		 3753 the .plt section. Leave the value if there were any
3754 relocations where pointer equality matters (this is a clue
51b64d56
AM		 3755 for the dynamic linker, to make function pointer
3756 comparisons work between an application and shared
c6585bbb
JJ		 3757 library), otherwise set it to zero. If a function is only
3758 called from a binary, there is no need to slow down
3759 shared libraries because of that. */
252b5132 3760 sym->st_shndx = SHN_UNDEF;
f5385ebf 3761 if (!h->pointer_equality_needed)
c6585bbb 3762 sym->st_value = 0;
252b5132
RH		 3763 }
3764 }
3765
13ae64f3 3766 if (h->got.offset != (bfd_vma) -1
67a4f2b7 3767 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
37e55690 3768 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 3769 {
947216bf
AM		 3770 Elf_Internal_Rela rel;
3771 bfd_byte *loc;
252b5132
RH		 3772
3773 /* This symbol has an entry in the global offset table. Set it
3774 up. */
3775
ffb2e45b
AM		 3776 if (htab->sgot == NULL || htab->srelgot == NULL)
3777 abort ();
252b5132 3778
6725bdbf
AM		 3779 rel.r_offset = (htab->sgot->output_section->vma
3780 + htab->sgot->output_offset
dc810e39 3781 + (h->got.offset & ~(bfd_vma) 1));
252b5132 3782
dd5724d5
AM		 3783 /* If this is a static link, or it is a -Bsymbolic link and the
3784 symbol is defined locally or was forced to be local because
3785 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 3786 The entry in the global offset table will already have been
3787 initialized in the relocate_section function. */
6725bdbf 3788 if (info->shared
586119b3 3789 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 3790 {
6725bdbf 3791 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 3792 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3793 }
252b5132
RH		 3794 else
3795 {
dd5724d5 3796 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 3797 bfd_put_32 (output_bfd, (bfd_vma) 0,
3798 htab->sgot->contents + h->got.offset);
252b5132
RH		 3799 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3800 }
3801
947216bf
AM		 3802 loc = htab->srelgot->contents;
3803 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3804 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3805 }
3806
f5385ebf 3807 if (h->needs_copy)
252b5132 3808 {
947216bf
AM		 3809 Elf_Internal_Rela rel;
3810 bfd_byte *loc;
252b5132
RH		 3811
3812 /* This symbol needs a copy reloc. Set it up. */
3813
ffb2e45b
AM		 3814 if (h->dynindx == -1
3815 || (h->root.type != bfd_link_hash_defined
3816 && h->root.type != bfd_link_hash_defweak)
3817 || htab->srelbss == NULL)
3818 abort ();
252b5132
RH		 3819
3820 rel.r_offset = (h->root.u.def.value
3821 + h->root.u.def.section->output_section->vma
3822 + h->root.u.def.section->output_offset);
3823 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
947216bf
AM		 3824 loc = htab->srelbss->contents;
3825 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3826 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3827 }
3828
eac338cf
PB		 3829 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.
3830 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
3831 is relative to the ".got" section. */
252b5132 3832 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
22edb2f1 3833 || (!htab->is_vxworks && h == htab->elf.hgot))
252b5132
RH		 3834 sym->st_shndx = SHN_ABS;
3835
b34976b6 3836 return TRUE;
252b5132
RH		 3837}
3838
38701953
AM		 3839/* Used to decide how to sort relocs in an optimal manner for the
3840 dynamic linker, before writing them out. */
3841
3842static enum elf_reloc_type_class
55fd94b0 3843elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
38701953 3844{
55fd94b0 3845 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 3846 {
3847 case R_386_RELATIVE:
3848 return reloc_class_relative;
3849 case R_386_JUMP_SLOT:
3850 return reloc_class_plt;
3851 case R_386_COPY:
3852 return reloc_class_copy;
3853 default:
3854 return reloc_class_normal;
3855 }
3856}
3857
252b5132
RH		 3858/* Finish up the dynamic sections. */
3859
b34976b6 3860static bfd_boolean
55fd94b0
AM		 3861elf_i386_finish_dynamic_sections (bfd *output_bfd,
3862 struct bfd_link_info *info)
252b5132 3863{
6725bdbf 3864 struct elf_i386_link_hash_table *htab;
252b5132 3865 bfd *dynobj;
252b5132
RH		 3866 asection *sdyn;
3867
6725bdbf 3868 htab = elf_i386_hash_table (info);
ebe50bae 3869 dynobj = htab->elf.dynobj;
252b5132
RH		 3870 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3871
ebe50bae 3872 if (htab->elf.dynamic_sections_created)
252b5132 3873 {
252b5132
RH		 3874 Elf32_External_Dyn *dyncon, *dynconend;
3875
ffb2e45b
AM		 3876 if (sdyn == NULL || htab->sgot == NULL)
3877 abort ();
252b5132
RH		 3878
3879 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 3880 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 3881 for (; dyncon < dynconend; dyncon++)
3882 {
3883 Elf_Internal_Dyn dyn;
51b64d56 3884 asection *s;
252b5132
RH		 3885
3886 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3887
3888 switch (dyn.d_tag)
3889 {
3890 default:
7a2b07ff
NS		 3891 if (htab->is_vxworks
3892 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
3893 break;
0ac8d2ca 3894 continue;
252b5132
RH		 3895
3896 case DT_PLTGOT:
8c37241b
JJ		 3897 s = htab->sgotplt;
3898 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 3899 break;
3900
252b5132 3901 case DT_JMPREL:
6348e046
AM		 3902 s = htab->srelplt;
3903 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 3904 break;
3905
3906 case DT_PLTRELSZ:
6348e046 3907 s = htab->srelplt;
eea6121a 3908 dyn.d_un.d_val = s->size;
252b5132
RH		 3909 break;
3910
3911 case DT_RELSZ:
3912 /* My reading of the SVR4 ABI indicates that the
3913 procedure linkage table relocs (DT_JMPREL) should be
3914 included in the overall relocs (DT_REL). This is
3915 what Solaris does. However, UnixWare can not handle
3916 that case. Therefore, we override the DT_RELSZ entry
6348e046
AM		 3917 here to make it not include the JMPREL relocs. */
3918 s = htab->srelplt;
3919 if (s == NULL)
3920 continue;
eea6121a 3921 dyn.d_un.d_val -= s->size;
6348e046
AM		 3922 break;
3923
3924 case DT_REL:
3925 /* We may not be using the standard ELF linker script.
3926 If .rel.plt is the first .rel section, we adjust
3927 DT_REL to not include it. */
3928 s = htab->srelplt;
3929 if (s == NULL)
3930 continue;
3931 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3932 continue;
eea6121a 3933 dyn.d_un.d_ptr += s->size;
252b5132
RH		 3934 break;
3935 }
0ac8d2ca
AM		 3936
3937 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3938 }
3939
3940 /* Fill in the first entry in the procedure linkage table. */
eea6121a 3941 if (htab->splt && htab->splt->size > 0)
252b5132
RH		 3942 {
3943 if (info->shared)
eac338cf
PB		 3944 {
3945 memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
3946 sizeof (elf_i386_pic_plt0_entry));
3947 memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
3948 htab->plt0_pad_byte,
3949 PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
3950 }
252b5132
RH		 3951 else
3952 {
eac338cf
PB		 3953 memcpy (htab->splt->contents, elf_i386_plt0_entry,
3954 sizeof(elf_i386_plt0_entry));
3955 memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
3956 htab->plt0_pad_byte,
3957 PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
252b5132 3958 bfd_put_32 (output_bfd,
6725bdbf
AM		 3959 (htab->sgotplt->output_section->vma
3960 + htab->sgotplt->output_offset
3961 + 4),
3962 htab->splt->contents + 2);
252b5132 3963 bfd_put_32 (output_bfd,
6725bdbf
AM		 3964 (htab->sgotplt->output_section->vma
3965 + htab->sgotplt->output_offset
3966 + 8),
3967 htab->splt->contents + 8);
eac338cf
PB		 3968
3969 if (htab->is_vxworks)
3970 {
3971 Elf_Internal_Rela rel;
7325306f 3972
eac338cf
PB		 3973 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
3974 On IA32 we use REL relocations so the addend goes in
3975 the PLT directly. */
3976 rel.r_offset = (htab->splt->output_section->vma
3977 + htab->splt->output_offset
3978 + 2);
7325306f 3979 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 3980 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3981 htab->srelplt2->contents);
3982 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
3983 rel.r_offset = (htab->splt->output_section->vma
3984 + htab->splt->output_offset
3985 + 8);
7325306f 3986 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 3987 bfd_elf32_swap_reloc_out (output_bfd, &rel,
3988 htab->srelplt2->contents +
3989 sizeof (Elf32_External_Rel));
3990 }
252b5132
RH		 3991 }
3992
3993 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3994 really seem like the right value. */
6725bdbf
AM		 3995 elf_section_data (htab->splt->output_section)
3996 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 3997
3998 /* Correct the .rel.plt.unloaded relocations. */
3999 if (htab->is_vxworks && !info->shared)
4000 {
4001 int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
4c9b0de6 4002 unsigned char *p;
eac338cf
PB		 4003
4004 p = htab->srelplt2->contents;
4005 if (info->shared)
4006 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4007 else
4008 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4009
4010 for (; num_plts; num_plts--)
4011 {
4012 Elf_Internal_Rela rel;
4013 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4014 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4015 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4016 p += sizeof (Elf32_External_Rel);
4017
4018 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4019 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 4020 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4021 p += sizeof (Elf32_External_Rel);
4022 }
4023 }
252b5132
RH		 4024 }
4025 }
4026
12d0ee4a 4027 if (htab->sgotplt)
252b5132 4028 {
12d0ee4a 4029 /* Fill in the first three entries in the global offset table. */
eea6121a 4030 if (htab->sgotplt->size > 0)
12d0ee4a
AM		 4031 {
4032 bfd_put_32 (output_bfd,
55fd94b0 4033 (sdyn == NULL ? 0
12d0ee4a
AM		 4034 : sdyn->output_section->vma + sdyn->output_offset),
4035 htab->sgotplt->contents);
55fd94b0
AM		 4036 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
4037 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
12d0ee4a 4038 }
252b5132 4039
12d0ee4a
AM		 4040 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
4041 }
8c37241b 4042
eea6121a 4043 if (htab->sgot && htab->sgot->size > 0)
8c37241b
JJ		 4044 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
4045
b34976b6 4046 return TRUE;
252b5132
RH		 4047}
4048
4c45e5c9
JJ		 4049/* Return address for Ith PLT stub in section PLT, for relocation REL
4050 or (bfd_vma) -1 if it should not be included. */
4051
4052static bfd_vma
4053elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4054 const arelent *rel ATTRIBUTE_UNUSED)
4055{
4056 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4057}
4058
fdc90cb4
JJ		 4059/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4060
4061static bfd_boolean
4062elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4063{
4064 if (h->plt.offset != (bfd_vma) -1
4065 && !h->def_regular
4066 && !h->pointer_equality_needed)
4067 return FALSE;
4068
4069 return _bfd_elf_hash_symbol (h);
4070}
4c45e5c9 4071
252b5132
RH		 4072#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4073#define TARGET_LITTLE_NAME "elf32-i386"
4074#define ELF_ARCH bfd_arch_i386
4075#define ELF_MACHINE_CODE EM_386
4076#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 4077
4078#define elf_backend_can_gc_sections 1
51b64d56 4079#define elf_backend_can_refcount 1
252b5132
RH		 4080#define elf_backend_want_got_plt 1
4081#define elf_backend_plt_readonly 1
4082#define elf_backend_want_plt_sym 0
4083#define elf_backend_got_header_size 12
252b5132 4084
8c29f035
AM		 4085/* Support RELA for objdump of prelink objects. */
4086#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 4087#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4088
13ae64f3 4089#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 4090
dd5724d5
AM		 4091#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4092#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
4093#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 4094#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
dd5724d5
AM		 4095
4096#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 4097#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 4098#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 4099#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 4100#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 4101#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 4102#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4103#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4104#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4105#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 4106#define elf_backend_grok_prstatus elf_i386_grok_prstatus
4107#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 4108#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 4109#define elf_backend_relocate_section elf_i386_relocate_section
4110#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 4111#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 4112#define elf_backend_omit_section_dynsym \
4113 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4c45e5c9 4114#define elf_backend_plt_sym_val elf_i386_plt_sym_val
fdc90cb4 4115#define elf_backend_hash_symbol elf_i386_hash_symbol
dd5724d5 4116
252b5132 4117#include "elf32-target.h"
2bc3c89a
AM		 4118
4119/* FreeBSD support. */
4120
4121#undef TARGET_LITTLE_SYM
4122#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4123#undef TARGET_LITTLE_NAME
4124#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 4125#undef ELF_OSABI
4126#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 4127
4128/* The kernel recognizes executables as valid only if they carry a
4129 "FreeBSD" label in the ELF header. So we put this label on all
4130 executables and (for simplicity) also all other object files. */
4131
2bc3c89a 4132static void
55fd94b0
AM		 4133elf_i386_post_process_headers (bfd *abfd,
4134 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2bc3c89a
AM		 4135{
4136 Elf_Internal_Ehdr *i_ehdrp;
4137
4138 i_ehdrp = elf_elfheader (abfd);
4139
4140 /* Put an ABI label supported by FreeBSD >= 4.1. */
d1036acb 4141 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
2bc3c89a
AM		 4142#ifdef OLD_FREEBSD_ABI_LABEL
4143 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4144 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 4145#endif
2bc3c89a
AM		 4146}
4147
4148#undef elf_backend_post_process_headers
571fe01f
NC		 4149#define elf_backend_post_process_headers elf_i386_post_process_headers
4150#undef elf32_bed
4151#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a
AM		 4152
4153#include "elf32-target.h"
eac338cf
PB		 4154
4155/* VxWorks support. */
4156
4157#undef TARGET_LITTLE_SYM
4158#define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4159#undef TARGET_LITTLE_NAME
4160#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 4161#undef ELF_OSABI
eac338cf
PB		 4162
4163/* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
4164
4165static struct bfd_link_hash_table *
4166elf_i386_vxworks_link_hash_table_create (bfd *abfd)
4167{
4168 struct bfd_link_hash_table *ret;
4169 struct elf_i386_link_hash_table *htab;
4170
4171 ret = elf_i386_link_hash_table_create (abfd);
4172 if (ret)
4173 {
4174 htab = (struct elf_i386_link_hash_table *) ret;
4175 htab->is_vxworks = 1;
4176 htab->plt0_pad_byte = 0x90;
4177 }
4178
4179 return ret;
4180}
4181
4182
13285a1b
AM		 4183#undef elf_backend_relocs_compatible
4184#undef elf_backend_post_process_headers
eac338cf
PB		 4185#undef bfd_elf32_bfd_link_hash_table_create
4186#define bfd_elf32_bfd_link_hash_table_create \
4187 elf_i386_vxworks_link_hash_table_create
4188#undef elf_backend_add_symbol_hook
4189#define elf_backend_add_symbol_hook \
4190 elf_vxworks_add_symbol_hook
4191#undef elf_backend_link_output_symbol_hook
4192#define elf_backend_link_output_symbol_hook \
9c72ff84 4193 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 4194#undef elf_backend_emit_relocs
4195#define elf_backend_emit_relocs elf_vxworks_emit_relocs
4196#undef elf_backend_final_write_processing
4197#define elf_backend_final_write_processing \
4198 elf_vxworks_final_write_processing
4199
4200/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4201 define it. */
4202#undef elf_backend_want_plt_sym
4203#define elf_backend_want_plt_sym 1
4204
4205#undef elf32_bed
4206#define elf32_bed elf32_i386_vxworks_bed
4207
4208#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.714968 seconds and 4 git commands to generate.