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