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