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