projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
b2a8e766
AM		 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 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
9 the Free Software Foundation; either version 2 of the License, or
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
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
252b5132
RH		 20
21#include "bfd.h"
22#include "sysdep.h"
23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
26
55fd94b0
AM		 27/* 386 uses REL relocations instead of RELA. */
28#define USE_REL 1
252b5132
RH		 29
30#include "elf/i386.h"
31
32static reloc_howto_type elf_howto_table[]=
33{
b34976b6 34 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
1b452ec6 35 bfd_elf_generic_reloc, "R_386_NONE",
b34976b6
AM		 36 TRUE, 0x00000000, 0x00000000, FALSE),
37 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 38 bfd_elf_generic_reloc, "R_386_32",
b34976b6
AM		 39 TRUE, 0xffffffff, 0xffffffff, FALSE),
40 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 41 bfd_elf_generic_reloc, "R_386_PC32",
b34976b6
AM		 42 TRUE, 0xffffffff, 0xffffffff, TRUE),
43 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 44 bfd_elf_generic_reloc, "R_386_GOT32",
b34976b6
AM		 45 TRUE, 0xffffffff, 0xffffffff, FALSE),
46 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 47 bfd_elf_generic_reloc, "R_386_PLT32",
b34976b6
AM		 48 TRUE, 0xffffffff, 0xffffffff, TRUE),
49 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 50 bfd_elf_generic_reloc, "R_386_COPY",
b34976b6
AM		 51 TRUE, 0xffffffff, 0xffffffff, FALSE),
52 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 53 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
b34976b6
AM		 54 TRUE, 0xffffffff, 0xffffffff, FALSE),
55 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 56 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
b34976b6
AM		 57 TRUE, 0xffffffff, 0xffffffff, FALSE),
58 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 59 bfd_elf_generic_reloc, "R_386_RELATIVE",
b34976b6
AM		 60 TRUE, 0xffffffff, 0xffffffff, FALSE),
61 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 62 bfd_elf_generic_reloc, "R_386_GOTOFF",
b34976b6
AM		 63 TRUE, 0xffffffff, 0xffffffff, FALSE),
64 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 65 bfd_elf_generic_reloc, "R_386_GOTPC",
b34976b6 66 TRUE, 0xffffffff, 0xffffffff, TRUE),
1b452ec6 67
dc47f327
AM		 68 /* We have a gap in the reloc numbers here.
69 R_386_standard counts the number up to this point, and
70 R_386_ext_offset is the value to subtract from a reloc type of
71 R_386_16 thru R_386_PC8 to form an index into this table. */
55fd94b0
AM		 72#define R_386_standard (R_386_GOTPC + 1)
73#define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
1b452ec6 74
37e55690 75 /* These relocs are a GNU extension. */
b34976b6 76 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 77 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
b34976b6
AM		 78 TRUE, 0xffffffff, 0xffffffff, FALSE),
79 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 80 bfd_elf_generic_reloc, "R_386_TLS_IE",
b34976b6
AM		 81 TRUE, 0xffffffff, 0xffffffff, FALSE),
82 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 83 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
b34976b6
AM		 84 TRUE, 0xffffffff, 0xffffffff, FALSE),
85 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 86 bfd_elf_generic_reloc, "R_386_TLS_LE",
b34976b6
AM		 87 TRUE, 0xffffffff, 0xffffffff, FALSE),
88 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 89 bfd_elf_generic_reloc, "R_386_TLS_GD",
b34976b6
AM		 90 TRUE, 0xffffffff, 0xffffffff, FALSE),
91 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 92 bfd_elf_generic_reloc, "R_386_TLS_LDM",
b34976b6
AM		 93 TRUE, 0xffffffff, 0xffffffff, FALSE),
94 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
1b452ec6 95 bfd_elf_generic_reloc, "R_386_16",
b34976b6
AM		 96 TRUE, 0xffff, 0xffff, FALSE),
97 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
1b452ec6 98 bfd_elf_generic_reloc, "R_386_PC16",
b34976b6
AM		 99 TRUE, 0xffff, 0xffff, TRUE),
100 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
1b452ec6 101 bfd_elf_generic_reloc, "R_386_8",
b34976b6
AM		 102 TRUE, 0xff, 0xff, FALSE),
103 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
1b452ec6 104 bfd_elf_generic_reloc, "R_386_PC8",
b34976b6 105 TRUE, 0xff, 0xff, TRUE),
dc47f327 106
55fd94b0
AM		 107#define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
108#define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
13ae64f3 109 /* These are common with Solaris TLS implementation. */
b34976b6 110 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 111 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
b34976b6
AM		 112 TRUE, 0xffffffff, 0xffffffff, FALSE),
113 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 114 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
b34976b6
AM		 115 TRUE, 0xffffffff, 0xffffffff, FALSE),
116 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 117 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
b34976b6
AM		 118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 120 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
b34976b6
AM		 121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 123 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
b34976b6
AM		 124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 126 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
b34976b6 127 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 128
129 /* Another gap. */
55fd94b0
AM		 130#define R_386_tls (R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
131#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_tls)
252b5132
RH		 132
133/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 134 HOWTO (R_386_GNU_VTINHERIT, /* type */
135 0, /* rightshift */
136 2, /* size (0 = byte, 1 = short, 2 = long) */
137 0, /* bitsize */
b34976b6 138 FALSE, /* pc_relative */
252b5132
RH		 139 0, /* bitpos */
140 complain_overflow_dont, /* complain_on_overflow */
141 NULL, /* special_function */
142 "R_386_GNU_VTINHERIT", /* name */
b34976b6 143 FALSE, /* partial_inplace */
252b5132
RH		 144 0, /* src_mask */
145 0, /* dst_mask */
b34976b6 146 FALSE), /* pcrel_offset */
252b5132
RH		 147
148/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 149 HOWTO (R_386_GNU_VTENTRY, /* type */
150 0, /* rightshift */
151 2, /* size (0 = byte, 1 = short, 2 = long) */
152 0, /* bitsize */
b34976b6 153 FALSE, /* pc_relative */
252b5132
RH		 154 0, /* bitpos */
155 complain_overflow_dont, /* complain_on_overflow */
156 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
157 "R_386_GNU_VTENTRY", /* name */
b34976b6 158 FALSE, /* partial_inplace */
252b5132
RH		 159 0, /* src_mask */
160 0, /* dst_mask */
b34976b6 161 FALSE) /* pcrel_offset */
dc47f327 162
55fd94b0 163#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
dc47f327
AM		 164
165};
166
252b5132 167#ifdef DEBUG_GEN_RELOC
55fd94b0
AM		 168#define TRACE(str) \
169 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
252b5132
RH		 170#else
171#define TRACE(str)
172#endif
173
174static reloc_howto_type *
55fd94b0
AM		 175elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
176 bfd_reloc_code_real_type code)
252b5132
RH		 177{
178 switch (code)
179 {
180 case BFD_RELOC_NONE:
181 TRACE ("BFD_RELOC_NONE");
55fd94b0 182 return &elf_howto_table[R_386_NONE];
252b5132
RH		 183
184 case BFD_RELOC_32:
185 TRACE ("BFD_RELOC_32");
55fd94b0 186 return &elf_howto_table[R_386_32];
252b5132
RH		 187
188 case BFD_RELOC_CTOR:
189 TRACE ("BFD_RELOC_CTOR");
55fd94b0 190 return &elf_howto_table[R_386_32];
252b5132
RH		 191
192 case BFD_RELOC_32_PCREL:
193 TRACE ("BFD_RELOC_PC32");
55fd94b0 194 return &elf_howto_table[R_386_PC32];
252b5132
RH		 195
196 case BFD_RELOC_386_GOT32:
197 TRACE ("BFD_RELOC_386_GOT32");
55fd94b0 198 return &elf_howto_table[R_386_GOT32];
252b5132
RH		 199
200 case BFD_RELOC_386_PLT32:
201 TRACE ("BFD_RELOC_386_PLT32");
55fd94b0 202 return &elf_howto_table[R_386_PLT32];
252b5132
RH		 203
204 case BFD_RELOC_386_COPY:
205 TRACE ("BFD_RELOC_386_COPY");
55fd94b0 206 return &elf_howto_table[R_386_COPY];
252b5132
RH		 207
208 case BFD_RELOC_386_GLOB_DAT:
209 TRACE ("BFD_RELOC_386_GLOB_DAT");
55fd94b0 210 return &elf_howto_table[R_386_GLOB_DAT];
252b5132
RH		 211
212 case BFD_RELOC_386_JUMP_SLOT:
213 TRACE ("BFD_RELOC_386_JUMP_SLOT");
55fd94b0 214 return &elf_howto_table[R_386_JUMP_SLOT];
252b5132
RH		 215
216 case BFD_RELOC_386_RELATIVE:
217 TRACE ("BFD_RELOC_386_RELATIVE");
55fd94b0 218 return &elf_howto_table[R_386_RELATIVE];
252b5132
RH		 219
220 case BFD_RELOC_386_GOTOFF:
221 TRACE ("BFD_RELOC_386_GOTOFF");
55fd94b0 222 return &elf_howto_table[R_386_GOTOFF];
252b5132
RH		 223
224 case BFD_RELOC_386_GOTPC:
225 TRACE ("BFD_RELOC_386_GOTPC");
55fd94b0 226 return &elf_howto_table[R_386_GOTPC];
252b5132 227
37e55690
JJ		 228 /* These relocs are a GNU extension. */
229 case BFD_RELOC_386_TLS_TPOFF:
230 TRACE ("BFD_RELOC_386_TLS_TPOFF");
55fd94b0 231 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
37e55690
JJ		 232
233 case BFD_RELOC_386_TLS_IE:
234 TRACE ("BFD_RELOC_386_TLS_IE");
55fd94b0 235 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
37e55690
JJ		 236
237 case BFD_RELOC_386_TLS_GOTIE:
238 TRACE ("BFD_RELOC_386_TLS_GOTIE");
55fd94b0 239 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
37e55690 240
13ae64f3
JJ		 241 case BFD_RELOC_386_TLS_LE:
242 TRACE ("BFD_RELOC_386_TLS_LE");
55fd94b0 243 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
13ae64f3
JJ		 244
245 case BFD_RELOC_386_TLS_GD:
246 TRACE ("BFD_RELOC_386_TLS_GD");
55fd94b0 247 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
13ae64f3
JJ		 248
249 case BFD_RELOC_386_TLS_LDM:
250 TRACE ("BFD_RELOC_386_TLS_LDM");
55fd94b0 251 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
13ae64f3 252
252b5132
RH		 253 case BFD_RELOC_16:
254 TRACE ("BFD_RELOC_16");
55fd94b0 255 return &elf_howto_table[R_386_16 - R_386_ext_offset];
252b5132
RH		 256
257 case BFD_RELOC_16_PCREL:
258 TRACE ("BFD_RELOC_16_PCREL");
55fd94b0 259 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
252b5132
RH		 260
261 case BFD_RELOC_8:
262 TRACE ("BFD_RELOC_8");
55fd94b0 263 return &elf_howto_table[R_386_8 - R_386_ext_offset];
252b5132
RH		 264
265 case BFD_RELOC_8_PCREL:
266 TRACE ("BFD_RELOC_8_PCREL");
55fd94b0 267 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
252b5132 268
13ae64f3
JJ		 269 /* Common with Sun TLS implementation. */
270 case BFD_RELOC_386_TLS_LDO_32:
271 TRACE ("BFD_RELOC_386_TLS_LDO_32");
55fd94b0 272 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
13ae64f3
JJ		 273
274 case BFD_RELOC_386_TLS_IE_32:
275 TRACE ("BFD_RELOC_386_TLS_IE_32");
55fd94b0 276 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
13ae64f3
JJ		 277
278 case BFD_RELOC_386_TLS_LE_32:
279 TRACE ("BFD_RELOC_386_TLS_LE_32");
55fd94b0 280 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
13ae64f3
JJ		 281
282 case BFD_RELOC_386_TLS_DTPMOD32:
283 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
55fd94b0 284 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
13ae64f3
JJ		 285
286 case BFD_RELOC_386_TLS_DTPOFF32:
287 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
55fd94b0 288 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
13ae64f3
JJ		 289
290 case BFD_RELOC_386_TLS_TPOFF32:
291 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
55fd94b0 292 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
13ae64f3 293
252b5132
RH		 294 case BFD_RELOC_VTABLE_INHERIT:
295 TRACE ("BFD_RELOC_VTABLE_INHERIT");
55fd94b0 296 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
252b5132
RH		 297
298 case BFD_RELOC_VTABLE_ENTRY:
299 TRACE ("BFD_RELOC_VTABLE_ENTRY");
55fd94b0 300 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
252b5132
RH		 301
302 default:
303 break;
304 }
305
306 TRACE ("Unknown");
307 return 0;
308}
309
252b5132 310static void
55fd94b0
AM		 311elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
312 arelent *cache_ptr,
313 Elf_Internal_Rela *dst)
252b5132 314{
dc47f327
AM		 315 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
316 unsigned int indx;
317
318 if ((indx = r_type) >= R_386_standard
319 && ((indx = r_type - R_386_ext_offset) - R_386_standard
320 >= R_386_ext - R_386_standard)
13ae64f3
JJ		 321 && ((indx = r_type - R_386_tls_offset) - R_386_ext
322 >= R_386_tls - R_386_ext)
323 && ((indx = r_type - R_386_vt_offset) - R_386_tls
324 >= R_386_vt - R_386_tls))
252b5132 325 {
d003868e
AM		 326 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
327 abfd, (int) r_type);
55fd94b0 328 indx = R_386_NONE;
252b5132 329 }
dc47f327 330 cache_ptr->howto = &elf_howto_table[indx];
252b5132
RH		 331}
332
333/* Return whether a symbol name implies a local label. The UnixWare
334 2.1 cc generates temporary symbols that start with .X, so we
335 recognize them here. FIXME: do other SVR4 compilers also use .X?.
336 If so, we should move the .X recognition into
337 _bfd_elf_is_local_label_name. */
338
b34976b6 339static bfd_boolean
55fd94b0 340elf_i386_is_local_label_name (bfd *abfd, const char *name)
252b5132
RH		 341{
342 if (name[0] == '.' && name[1] == 'X')
b34976b6 343 return TRUE;
252b5132
RH		 344
345 return _bfd_elf_is_local_label_name (abfd, name);
346}
347\f
38701953 348/* Support for core dump NOTE sections. */
61adc1a4 349
b34976b6 350static bfd_boolean
55fd94b0 351elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
38701953
AM		 352{
353 int offset;
eea6121a 354 size_t size;
38701953 355
61adc1a4 356 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 357 {
61adc1a4
NC		 358 int pr_version = bfd_get_32 (abfd, note->descdata);
359
360 if (pr_version != 1)
361 return FALSE;
362
363 /* pr_cursig */
364 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
365
366 /* pr_pid */
367 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
368
369 /* pr_reg */
370 offset = 28;
eea6121a 371 size = bfd_get_32 (abfd, note->descdata + 8);
61adc1a4
NC		 372 }
373 else
374 {
375 switch (note->descsz)
376 {
377 default:
378 return FALSE;
38701953 379
61adc1a4
NC		 380 case 144: /* Linux/i386 */
381 /* pr_cursig */
382 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
38701953 383
61adc1a4
NC		 384 /* pr_pid */
385 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
38701953 386
61adc1a4
NC		 387 /* pr_reg */
388 offset = 72;
eea6121a 389 size = 68;
38701953 390
61adc1a4
NC		 391 break;
392 }
38701953
AM		 393 }
394
395 /* Make a ".reg/999" section. */
396 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 397 size, note->descpos + offset);
38701953
AM		 398}
399
b34976b6 400static bfd_boolean
55fd94b0 401elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
38701953 402{
61adc1a4 403 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 404 {
61adc1a4
NC		 405 int pr_version = bfd_get_32 (abfd, note->descdata);
406
407 if (pr_version != 1)
b34976b6 408 return FALSE;
38701953 409
61adc1a4
NC		 410 elf_tdata (abfd)->core_program
411 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
412 elf_tdata (abfd)->core_command
413 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
414 }
415 else
416 {
417 switch (note->descsz)
418 {
419 default:
420 return FALSE;
421
422 case 124: /* Linux/i386 elf_prpsinfo. */
423 elf_tdata (abfd)->core_program
424 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
425 elf_tdata (abfd)->core_command
426 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
427 }
38701953
AM		 428 }
429
430 /* Note that for some reason, a spurious space is tacked
431 onto the end of the args in some (at least one anyway)
432 implementations, so strip it off if it exists. */
38701953
AM		 433 {
434 char *command = elf_tdata (abfd)->core_command;
435 int n = strlen (command);
436
437 if (0 < n && command[n - 1] == ' ')
438 command[n - 1] = '\0';
439 }
440
b34976b6 441 return TRUE;
38701953
AM		 442}
443\f
444/* Functions for the i386 ELF linker.
445
446 In order to gain some understanding of code in this file without
447 knowing all the intricate details of the linker, note the
448 following:
449
450 Functions named elf_i386_* are called by external routines, other
451 functions are only called locally. elf_i386_* functions appear
452 in this file more or less in the order in which they are called
453 from external routines. eg. elf_i386_check_relocs is called
454 early in the link process, elf_i386_finish_dynamic_sections is
455 one of the last functions. */
456
252b5132
RH		 457
458/* The name of the dynamic interpreter. This is put in the .interp
459 section. */
460
461#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
462
a23b6845
AM		 463/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
464 copying dynamic variables from a shared lib into an app's dynbss
465 section, and instead use a dynamic relocation to point into the
466 shared lib. */
467#define ELIMINATE_COPY_RELOCS 1
468
252b5132
RH		 469/* The size in bytes of an entry in the procedure linkage table. */
470
471#define PLT_ENTRY_SIZE 16
472
473/* The first entry in an absolute procedure linkage table looks like
474 this. See the SVR4 ABI i386 supplement to see how this works. */
475
476static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
477{
478 0xff, 0x35, /* pushl contents of address */
479 0, 0, 0, 0, /* replaced with address of .got + 4. */
480 0xff, 0x25, /* jmp indirect */
481 0, 0, 0, 0, /* replaced with address of .got + 8. */
482 0, 0, 0, 0 /* pad out to 16 bytes. */
483};
484
485/* Subsequent entries in an absolute procedure linkage table look like
486 this. */
487
488static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
489{
490 0xff, 0x25, /* jmp indirect */
491 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
492 0x68, /* pushl immediate */
493 0, 0, 0, 0, /* replaced with offset into relocation table. */
494 0xe9, /* jmp relative */
495 0, 0, 0, 0 /* replaced with offset to start of .plt. */
496};
497
498/* The first entry in a PIC procedure linkage table look like this. */
499
500static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
501{
502 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
503 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
504 0, 0, 0, 0 /* pad out to 16 bytes. */
505};
506
507/* Subsequent entries in a PIC procedure linkage table look like this. */
508
509static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
510{
511 0xff, 0xa3, /* jmp *offset(%ebx) */
512 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
513 0x68, /* pushl immediate */
514 0, 0, 0, 0, /* replaced with offset into relocation table. */
515 0xe9, /* jmp relative */
516 0, 0, 0, 0 /* replaced with offset to start of .plt. */
517};
518
519/* The i386 linker needs to keep track of the number of relocs that it
ffb2e45b
AM		 520 decides to copy as dynamic relocs in check_relocs for each symbol.
521 This is so that it can later discard them if they are found to be
522 unnecessary. We store the information in a field extending the
523 regular ELF linker hash table. */
252b5132 524
ffb2e45b 525struct elf_i386_dyn_relocs
252b5132 526{
ffb2e45b 527 struct elf_i386_dyn_relocs *next;
0c715baa
AM		 528
529 /* The input section of the reloc. */
530 asection *sec;
531
532 /* Total number of relocs copied for the input section. */
252b5132 533 bfd_size_type count;
0c715baa
AM		 534
535 /* Number of pc-relative relocs copied for the input section. */
536 bfd_size_type pc_count;
252b5132
RH		 537};
538
539/* i386 ELF linker hash entry. */
540
541struct elf_i386_link_hash_entry
542{
ebe50bae 543 struct elf_link_hash_entry elf;
252b5132 544
0c715baa 545 /* Track dynamic relocs copied for this symbol. */
ffb2e45b 546 struct elf_i386_dyn_relocs *dyn_relocs;
13ae64f3 547
37e55690
JJ		 548#define GOT_UNKNOWN 0
549#define GOT_NORMAL 1
550#define GOT_TLS_GD 2
551#define GOT_TLS_IE 4
552#define GOT_TLS_IE_POS 5
553#define GOT_TLS_IE_NEG 6
554#define GOT_TLS_IE_BOTH 7
555 unsigned char tls_type;
13ae64f3
JJ		 556};
557
558#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
559
560struct elf_i386_obj_tdata
561{
562 struct elf_obj_tdata root;
563
564 /* tls_type for each local got entry. */
565 char *local_got_tls_type;
252b5132
RH		 566};
567
13ae64f3
JJ		 568#define elf_i386_tdata(abfd) \
569 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
570
571#define elf_i386_local_got_tls_type(abfd) \
572 (elf_i386_tdata (abfd)->local_got_tls_type)
573
b34976b6 574static bfd_boolean
55fd94b0 575elf_i386_mkobject (bfd *abfd)
13ae64f3
JJ		 576{
577 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
578 abfd->tdata.any = bfd_zalloc (abfd, amt);
579 if (abfd->tdata.any == NULL)
b34976b6
AM		 580 return FALSE;
581 return TRUE;
13ae64f3 582}
cedb70c5 583
252b5132
RH		 584/* i386 ELF linker hash table. */
585
586struct elf_i386_link_hash_table
587{
ebe50bae 588 struct elf_link_hash_table elf;
252b5132 589
6725bdbf
AM		 590 /* Short-cuts to get to dynamic linker sections. */
591 asection *sgot;
592 asection *sgotplt;
593 asection *srelgot;
594 asection *splt;
595 asection *srelplt;
596 asection *sdynbss;
597 asection *srelbss;
ec338859 598
13ae64f3
JJ		 599 union {
600 bfd_signed_vma refcount;
601 bfd_vma offset;
602 } tls_ldm_got;
603
ec338859
AM		 604 /* Small local sym to section mapping cache. */
605 struct sym_sec_cache sym_sec;
6725bdbf 606};
252b5132
RH		 607
608/* Get the i386 ELF linker hash table from a link_info structure. */
609
610#define elf_i386_hash_table(p) \
611 ((struct elf_i386_link_hash_table *) ((p)->hash))
612
613/* Create an entry in an i386 ELF linker hash table. */
614
615static struct bfd_hash_entry *
55fd94b0
AM		 616link_hash_newfunc (struct bfd_hash_entry *entry,
617 struct bfd_hash_table *table,
618 const char *string)
252b5132 619{
252b5132
RH		 620 /* Allocate the structure if it has not already been allocated by a
621 subclass. */
ebe50bae
AM		 622 if (entry == NULL)
623 {
624 entry = bfd_hash_allocate (table,
625 sizeof (struct elf_i386_link_hash_entry));
626 if (entry == NULL)
627 return entry;
628 }
252b5132
RH		 629
630 /* Call the allocation method of the superclass. */
ebe50bae
AM		 631 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
632 if (entry != NULL)
252b5132 633 {
ebe50bae
AM		 634 struct elf_i386_link_hash_entry *eh;
635
636 eh = (struct elf_i386_link_hash_entry *) entry;
637 eh->dyn_relocs = NULL;
13ae64f3 638 eh->tls_type = GOT_UNKNOWN;
252b5132
RH		 639 }
640
ebe50bae 641 return entry;
252b5132
RH		 642}
643
644/* Create an i386 ELF linker hash table. */
645
646static struct bfd_link_hash_table *
55fd94b0 647elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 648{
649 struct elf_i386_link_hash_table *ret;
dc810e39 650 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 651
55fd94b0 652 ret = bfd_malloc (amt);
ebe50bae 653 if (ret == NULL)
252b5132
RH		 654 return NULL;
655
ebe50bae 656 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
252b5132 657 {
e2d34d7d 658 free (ret);
252b5132
RH		 659 return NULL;
660 }
661
6725bdbf
AM		 662 ret->sgot = NULL;
663 ret->sgotplt = NULL;
664 ret->srelgot = NULL;
665 ret->splt = NULL;
666 ret->srelplt = NULL;
667 ret->sdynbss = NULL;
668 ret->srelbss = NULL;
7a624474 669 ret->tls_ldm_got.refcount = 0;
ec338859 670 ret->sym_sec.abfd = NULL;
6725bdbf 671
ebe50bae 672 return &ret->elf.root;
252b5132
RH		 673}
674
6725bdbf
AM		 675/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
676 shortcuts to them in our hash table. */
677
b34976b6 678static bfd_boolean
55fd94b0 679create_got_section (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 680{
681 struct elf_i386_link_hash_table *htab;
682
683 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 684 return FALSE;
6725bdbf
AM		 685
686 htab = elf_i386_hash_table (info);
687 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
688 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
689 if (!htab->sgot || !htab->sgotplt)
690 abort ();
691
692 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
693 if (htab->srelgot == NULL
694 || ! bfd_set_section_flags (dynobj, htab->srelgot,
695 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
696 | SEC_IN_MEMORY | SEC_LINKER_CREATED
697 | SEC_READONLY))
698 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
b34976b6
AM		 699 return FALSE;
700 return TRUE;
6725bdbf
AM		 701}
702
703/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
704 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
705 hash table. */
706
b34976b6 707static bfd_boolean
55fd94b0 708elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 709{
710 struct elf_i386_link_hash_table *htab;
711
712 htab = elf_i386_hash_table (info);
713 if (!htab->sgot && !create_got_section (dynobj, info))
b34976b6 714 return FALSE;
6725bdbf
AM		 715
716 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 717 return FALSE;
6725bdbf
AM		 718
719 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
720 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
721 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
722 if (!info->shared)
723 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
724
725 if (!htab->splt || !htab->srelplt || !htab->sdynbss
726 || (!info->shared && !htab->srelbss))
727 abort ();
728
b34976b6 729 return TRUE;
6725bdbf
AM		 730}
731
ebe50bae
AM		 732/* Copy the extra info we tack onto an elf_link_hash_entry. */
733
51b64d56 734static void
9c5bfbb7 735elf_i386_copy_indirect_symbol (const struct elf_backend_data *bed,
55fd94b0
AM		 736 struct elf_link_hash_entry *dir,
737 struct elf_link_hash_entry *ind)
ebe50bae
AM		 738{
739 struct elf_i386_link_hash_entry *edir, *eind;
740
741 edir = (struct elf_i386_link_hash_entry *) dir;
742 eind = (struct elf_i386_link_hash_entry *) ind;
743
bbd7ec4a 744 if (eind->dyn_relocs != NULL)
ebe50bae 745 {
bbd7ec4a
AM		 746 if (edir->dyn_relocs != NULL)
747 {
748 struct elf_i386_dyn_relocs **pp;
749 struct elf_i386_dyn_relocs *p;
750
1e370bd2 751 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM		 752 abort ();
753
754 /* Add reloc counts against the weak sym to the strong sym
755 list. Merge any entries against the same section. */
756 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
757 {
758 struct elf_i386_dyn_relocs *q;
759
760 for (q = edir->dyn_relocs; q != NULL; q = q->next)
761 if (q->sec == p->sec)
762 {
763 q->pc_count += p->pc_count;
764 q->count += p->count;
765 *pp = p->next;
766 break;
767 }
768 if (q == NULL)
769 pp = &p->next;
770 }
771 *pp = edir->dyn_relocs;
772 }
773
ebe50bae
AM		 774 edir->dyn_relocs = eind->dyn_relocs;
775 eind->dyn_relocs = NULL;
776 }
ebe50bae 777
cd67d266
JJ		 778 if (ind->root.type == bfd_link_hash_indirect
779 && dir->got.refcount <= 0)
780 {
781 edir->tls_type = eind->tls_type;
782 eind->tls_type = GOT_UNKNOWN;
783 }
81848ca0
AM		 784
785 if (ELIMINATE_COPY_RELOCS
786 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 787 && dir->dynamic_adjusted)
788 {
789 /* If called to transfer flags for a weakdef during processing
790 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
791 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
792 dir->ref_dynamic |= ind->ref_dynamic;
793 dir->ref_regular |= ind->ref_regular;
794 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
795 dir->needs_plt |= ind->needs_plt;
796 dir->pointer_equality_needed |= ind->pointer_equality_needed;
797 }
81848ca0
AM		 798 else
799 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
ebe50bae
AM		 800}
801
13ae64f3 802static int
55fd94b0 803elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
13ae64f3
JJ		 804{
805 if (info->shared)
806 return r_type;
807
808 switch (r_type)
809 {
810 case R_386_TLS_GD:
811 case R_386_TLS_IE_32:
812 if (is_local)
813 return R_386_TLS_LE_32;
814 return R_386_TLS_IE_32;
37e55690
JJ		 815 case R_386_TLS_IE:
816 case R_386_TLS_GOTIE:
817 if (is_local)
818 return R_386_TLS_LE_32;
819 return r_type;
13ae64f3
JJ		 820 case R_386_TLS_LDM:
821 return R_386_TLS_LE_32;
822 }
823
824 return r_type;
825}
826
252b5132 827/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 828 calculate needed space in the global offset table, procedure linkage
829 table, and dynamic reloc sections. */
252b5132 830
b34976b6 831static bfd_boolean
55fd94b0
AM		 832elf_i386_check_relocs (bfd *abfd,
833 struct bfd_link_info *info,
834 asection *sec,
835 const Elf_Internal_Rela *relocs)
252b5132 836{
6725bdbf 837 struct elf_i386_link_hash_table *htab;
252b5132
RH		 838 Elf_Internal_Shdr *symtab_hdr;
839 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 840 const Elf_Internal_Rela *rel;
841 const Elf_Internal_Rela *rel_end;
252b5132
RH		 842 asection *sreloc;
843
1049f94e 844 if (info->relocatable)
b34976b6 845 return TRUE;
252b5132 846
6725bdbf 847 htab = elf_i386_hash_table (info);
252b5132
RH		 848 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
849 sym_hashes = elf_sym_hashes (abfd);
252b5132 850
252b5132
RH		 851 sreloc = NULL;
852
853 rel_end = relocs + sec->reloc_count;
854 for (rel = relocs; rel < rel_end; rel++)
855 {
13ae64f3 856 unsigned int r_type;
252b5132
RH		 857 unsigned long r_symndx;
858 struct elf_link_hash_entry *h;
859
860 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 861 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 862
d9bc7a44 863 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 864 {
d003868e
AM		 865 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
866 abfd,
8f615d07 867 r_symndx);
b34976b6 868 return FALSE;
f5f31454
L		 869 }
870
252b5132
RH		 871 if (r_symndx < symtab_hdr->sh_info)
872 h = NULL;
873 else
874 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
875
13ae64f3
JJ		 876 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
877
878 switch (r_type)
252b5132 879 {
37e55690
JJ		 880 case R_386_TLS_LDM:
881 htab->tls_ldm_got.refcount += 1;
882 goto create_got;
883
884 case R_386_PLT32:
885 /* This symbol requires a procedure linkage table entry. We
886 actually build the entry in adjust_dynamic_symbol,
887 because this might be a case of linking PIC code which is
888 never referenced by a dynamic object, in which case we
889 don't need to generate a procedure linkage table entry
890 after all. */
891
892 /* If this is a local symbol, we resolve it directly without
893 creating a procedure linkage table entry. */
894 if (h == NULL)
895 continue;
896
f5385ebf 897 h->needs_plt = 1;
37e55690
JJ		 898 h->plt.refcount += 1;
899 break;
900
13ae64f3 901 case R_386_TLS_IE_32:
37e55690
JJ		 902 case R_386_TLS_IE:
903 case R_386_TLS_GOTIE:
13ae64f3
JJ		 904 if (info->shared)
905 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 906 /* Fall through */
907
252b5132 908 case R_386_GOT32:
13ae64f3 909 case R_386_TLS_GD:
252b5132 910 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 911 {
912 int tls_type, old_tls_type;
913
914 switch (r_type)
915 {
916 default:
917 case R_386_GOT32: tls_type = GOT_NORMAL; break;
918 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
37e55690
JJ		 919 case R_386_TLS_IE_32:
920 if (ELF32_R_TYPE (rel->r_info) == r_type)
921 tls_type = GOT_TLS_IE_NEG;
922 else
923 /* If this is a GD->IE transition, we may use either of
924 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
925 tls_type = GOT_TLS_IE;
926 break;
927 case R_386_TLS_IE:
928 case R_386_TLS_GOTIE:
929 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 930 }
931
932 if (h != NULL)
933 {
934 h->got.refcount += 1;
935 old_tls_type = elf_i386_hash_entry(h)->tls_type;
936 }
937 else
938 {
939 bfd_signed_vma *local_got_refcounts;
940
941 /* This is a global offset table entry for a local symbol. */
942 local_got_refcounts = elf_local_got_refcounts (abfd);
943 if (local_got_refcounts == NULL)
944 {
945 bfd_size_type size;
946
947 size = symtab_hdr->sh_info;
948 size *= (sizeof (bfd_signed_vma) + sizeof(char));
55fd94b0 949 local_got_refcounts = bfd_zalloc (abfd, size);
13ae64f3 950 if (local_got_refcounts == NULL)
b34976b6 951 return FALSE;
13ae64f3
JJ		 952 elf_local_got_refcounts (abfd) = local_got_refcounts;
953 elf_i386_local_got_tls_type (abfd)
954 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
955 }
956 local_got_refcounts[r_symndx] += 1;
957 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
958 }
959
37e55690
JJ		 960 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
961 tls_type |= old_tls_type;
13ae64f3
JJ		 962 /* If a TLS symbol is accessed using IE at least once,
963 there is no point to use dynamic model for it. */
37e55690
JJ		 964 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
965 && (old_tls_type != GOT_TLS_GD
966 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 967 {
37e55690
JJ		 968 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
969 tls_type = old_tls_type;
13ae64f3
JJ		 970 else
971 {
972 (*_bfd_error_handler)
d003868e 973 (_("%B: `%s' accessed both as normal and "
55fd94b0 974 "thread local symbol"),
d003868e 975 abfd,
37e55690 976 h ? h->root.root.string : "<local>");
b34976b6 977 return FALSE;
13ae64f3
JJ		 978 }
979 }
980
981 if (old_tls_type != tls_type)
982 {
983 if (h != NULL)
984 elf_i386_hash_entry (h)->tls_type = tls_type;
985 else
986 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
987 }
988 }
0ac8d2ca
AM		 989 /* Fall through */
990
991 case R_386_GOTOFF:
992 case R_386_GOTPC:
13ae64f3 993 create_got:
0ac8d2ca
AM		 994 if (htab->sgot == NULL)
995 {
996 if (htab->elf.dynobj == NULL)
997 htab->elf.dynobj = abfd;
998 if (!create_got_section (htab->elf.dynobj, info))
b34976b6 999 return FALSE;
0ac8d2ca 1000 }
37e55690
JJ		 1001 if (r_type != R_386_TLS_IE)
1002 break;
1003 /* Fall through */
252b5132 1004
37e55690
JJ		 1005 case R_386_TLS_LE_32:
1006 case R_386_TLS_LE:
1007 if (!info->shared)
1008 break;
bffbf940 1009 info->flags |= DF_STATIC_TLS;
b34976b6 1010 /* Fall through */
252b5132
RH		 1011
1012 case R_386_32:
1013 case R_386_PC32:
12d0ee4a 1014 if (h != NULL && !info->shared)
6725bdbf 1015 {
12d0ee4a 1016 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1017 need a copy reloc. We can't check reliably at this
1018 stage whether the section is read-only, as input
1019 sections have not yet been mapped to output sections.
1020 Tentatively set the flag for now, and correct in
1021 adjust_dynamic_symbol. */
f5385ebf 1022 h->non_got_ref = 1;
12d0ee4a
AM		 1023
1024 /* We may need a .plt entry if the function this reloc
1025 refers to is in a shared lib. */
51b64d56 1026 h->plt.refcount += 1;
c6585bbb 1027 if (r_type != R_386_PC32)
f5385ebf 1028 h->pointer_equality_needed = 1;
6725bdbf 1029 }
7843f00e 1030
252b5132 1031 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1032 against a global symbol, or a non PC relative reloc
1033 against a local symbol, then we need to copy the reloc
1034 into the shared library. However, if we are linking with
1035 -Bsymbolic, we do not need to copy a reloc against a
1036 global symbol which is defined in an object we are
1037 including in the link (i.e., DEF_REGULAR is set). At
1038 this point we have not seen all the input files, so it is
1039 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1040 later (it is never cleared). In case of a weak definition,
1041 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1042 a shared library. We account for that possibility below by
1f655a09
L		 1043 storing information in the relocs_copied field of the hash
1044 table entry. A similar situation occurs when creating
1045 shared libraries and symbol visibility changes render the
12d0ee4a 1046 symbol local.
56882138 1047
12d0ee4a
AM		 1048 If on the other hand, we are creating an executable, we
1049 may need to keep relocations for symbols satisfied by a
1050 dynamic library if we manage to avoid copy relocs for the
1051 symbol. */
1052 if ((info->shared
1053 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1054 && (r_type != R_386_PC32
12d0ee4a
AM		 1055 || (h != NULL
1056 && (! info->symbolic
1057 || h->root.type == bfd_link_hash_defweak
f5385ebf 1058 || !h->def_regular))))
a23b6845
AM		 1059 || (ELIMINATE_COPY_RELOCS
1060 && !info->shared
12d0ee4a
AM		 1061 && (sec->flags & SEC_ALLOC) != 0
1062 && h != NULL
12d0ee4a 1063 && (h->root.type == bfd_link_hash_defweak
f5385ebf 1064 || !h->def_regular)))
252b5132 1065 {
ec338859
AM		 1066 struct elf_i386_dyn_relocs *p;
1067 struct elf_i386_dyn_relocs **head;
1068
12d0ee4a
AM		 1069 /* We must copy these reloc types into the output file.
1070 Create a reloc section in dynobj and make room for
1071 this reloc. */
252b5132
RH		 1072 if (sreloc == NULL)
1073 {
1074 const char *name;
0ac8d2ca 1075 bfd *dynobj;
e92d460e
AM		 1076 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1077 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
252b5132 1078
e92d460e 1079 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
252b5132 1080 if (name == NULL)
b34976b6 1081 return FALSE;
252b5132 1082
c8492176
L		 1083 if (strncmp (name, ".rel", 4) != 0
1084 || strcmp (bfd_get_section_name (abfd, sec),
1085 name + 4) != 0)
1086 {
0c715baa 1087 (*_bfd_error_handler)
d003868e
AM		 1088 (_("%B: bad relocation section name `%s\'"),
1089 abfd, name);
f5f31454 1090 }
252b5132 1091
0ac8d2ca
AM		 1092 if (htab->elf.dynobj == NULL)
1093 htab->elf.dynobj = abfd;
1094
1095 dynobj = htab->elf.dynobj;
252b5132
RH		 1096 sreloc = bfd_get_section_by_name (dynobj, name);
1097 if (sreloc == NULL)
1098 {
1099 flagword flags;
1100
1101 sreloc = bfd_make_section (dynobj, name);
1102 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1103 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1104 if ((sec->flags & SEC_ALLOC) != 0)
1105 flags |= SEC_ALLOC | SEC_LOAD;
1106 if (sreloc == NULL
1107 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1108 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 1109 return FALSE;
252b5132 1110 }
0c715baa 1111 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1112 }
1113
0c715baa
AM		 1114 /* If this is a global symbol, we count the number of
1115 relocations we need for this symbol. */
1116 if (h != NULL)
252b5132 1117 {
ec338859 1118 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1119 }
1120 else
1121 {
ec338859
AM		 1122 /* Track dynamic relocs needed for local syms too.
1123 We really need local syms available to do this
1124 easily. Oh well. */
1125
1126 asection *s;
1127 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1128 sec, r_symndx);
1129 if (s == NULL)
b34976b6 1130 return FALSE;
ec338859
AM		 1131
1132 head = ((struct elf_i386_dyn_relocs **)
1133 &elf_section_data (s)->local_dynrel);
1134 }
1135
1136 p = *head;
1137 if (p == NULL || p->sec != sec)
1138 {
1139 bfd_size_type amt = sizeof *p;
55fd94b0 1140 p = bfd_alloc (htab->elf.dynobj, amt);
ec338859 1141 if (p == NULL)
b34976b6 1142 return FALSE;
ec338859
AM		 1143 p->next = *head;
1144 *head = p;
1145 p->sec = sec;
1146 p->count = 0;
1147 p->pc_count = 0;
252b5132 1148 }
ec338859
AM		 1149
1150 p->count += 1;
13ae64f3 1151 if (r_type == R_386_PC32)
ec338859 1152 p->pc_count += 1;
252b5132 1153 }
252b5132
RH		 1154 break;
1155
1156 /* This relocation describes the C++ object vtable hierarchy.
1157 Reconstruct it for later use during GC. */
1158 case R_386_GNU_VTINHERIT:
c152c796 1159 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 1160 return FALSE;
252b5132
RH		 1161 break;
1162
1163 /* This relocation describes which C++ vtable entries are actually
1164 used. Record for later use during GC. */
1165 case R_386_GNU_VTENTRY:
c152c796 1166 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 1167 return FALSE;
252b5132
RH		 1168 break;
1169
1170 default:
1171 break;
1172 }
1173 }
1174
b34976b6 1175 return TRUE;
252b5132
RH		 1176}
1177
1178/* Return the section that should be marked against GC for a given
1179 relocation. */
1180
1181static asection *
55fd94b0
AM		 1182elf_i386_gc_mark_hook (asection *sec,
1183 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1184 Elf_Internal_Rela *rel,
1185 struct elf_link_hash_entry *h,
1186 Elf_Internal_Sym *sym)
252b5132
RH		 1187{
1188 if (h != NULL)
1189 {
1190 switch (ELF32_R_TYPE (rel->r_info))
1191 {
1192 case R_386_GNU_VTINHERIT:
1193 case R_386_GNU_VTENTRY:
1194 break;
1195
1196 default:
1197 switch (h->root.type)
1198 {
1199 case bfd_link_hash_defined:
1200 case bfd_link_hash_defweak:
1201 return h->root.u.def.section;
1202
1203 case bfd_link_hash_common:
1204 return h->root.u.c.p->section;
1205
1206 default:
1207 break;
1208 }
1209 }
1210 }
1211 else
1e2f5b6e 1212 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
252b5132
RH		 1213
1214 return NULL;
1215}
1216
1217/* Update the got entry reference counts for the section being removed. */
1218
b34976b6 1219static bfd_boolean
55fd94b0
AM		 1220elf_i386_gc_sweep_hook (bfd *abfd,
1221 struct bfd_link_info *info,
1222 asection *sec,
1223 const Elf_Internal_Rela *relocs)
252b5132 1224{
dd5724d5
AM		 1225 Elf_Internal_Shdr *symtab_hdr;
1226 struct elf_link_hash_entry **sym_hashes;
1227 bfd_signed_vma *local_got_refcounts;
1228 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1229
ec338859 1230 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1231
6725bdbf
AM		 1232 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1233 sym_hashes = elf_sym_hashes (abfd);
1234 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1235
1236 relend = relocs + sec->reloc_count;
1237 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1238 {
1239 unsigned long r_symndx;
1240 unsigned int r_type;
1241 struct elf_link_hash_entry *h = NULL;
37e55690 1242
26e41594
AM		 1243 r_symndx = ELF32_R_SYM (rel->r_info);
1244 if (r_symndx >= symtab_hdr->sh_info)
1245 {
1246 struct elf_i386_link_hash_entry *eh;
1247 struct elf_i386_dyn_relocs **pp;
1248 struct elf_i386_dyn_relocs *p;
dd5724d5 1249
26e41594
AM		 1250 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1251 eh = (struct elf_i386_link_hash_entry *) h;
0c715baa 1252
26e41594
AM		 1253 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1254 if (p->sec == sec)
1255 {
1256 /* Everything must go for SEC. */
1257 *pp = p->next;
1258 break;
1259 }
1260 }
0c715baa 1261
26e41594
AM		 1262 r_type = ELF32_R_TYPE (rel->r_info);
1263 r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1264 switch (r_type)
1265 {
1266 case R_386_TLS_LDM:
1267 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1268 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1269 break;
0c715baa 1270
26e41594
AM		 1271 case R_386_TLS_GD:
1272 case R_386_TLS_IE_32:
1273 case R_386_TLS_IE:
1274 case R_386_TLS_GOTIE:
1275 case R_386_GOT32:
1276 if (h != NULL)
1277 {
1278 if (h->got.refcount > 0)
1279 h->got.refcount -= 1;
1280 }
1281 else if (local_got_refcounts != NULL)
1282 {
1283 if (local_got_refcounts[r_symndx] > 0)
1284 local_got_refcounts[r_symndx] -= 1;
1285 }
1286 break;
0c715baa 1287
26e41594
AM		 1288 case R_386_32:
1289 case R_386_PC32:
1290 if (info->shared)
1291 break;
1292 /* Fall through */
6725bdbf 1293
26e41594
AM		 1294 case R_386_PLT32:
1295 if (h != NULL)
1296 {
1297 if (h->plt.refcount > 0)
1298 h->plt.refcount -= 1;
1299 }
1300 break;
dd5724d5 1301
26e41594
AM		 1302 default:
1303 break;
1304 }
1305 }
252b5132 1306
b34976b6 1307 return TRUE;
252b5132
RH		 1308}
1309
1310/* Adjust a symbol defined by a dynamic object and referenced by a
1311 regular object. The current definition is in some section of the
1312 dynamic object, but we're not including those sections. We have to
1313 change the definition to something the rest of the link can
1314 understand. */
1315
b34976b6 1316static bfd_boolean
55fd94b0
AM		 1317elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1318 struct elf_link_hash_entry *h)
252b5132 1319{
6725bdbf 1320 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1321 asection *s;
1322 unsigned int power_of_two;
1323
252b5132
RH		 1324 /* If this is a function, put it in the procedure linkage table. We
1325 will fill in the contents of the procedure linkage table later,
1326 when we know the address of the .got section. */
1327 if (h->type == STT_FUNC
f5385ebf 1328 || h->needs_plt)
252b5132 1329 {
6725bdbf 1330 if (h->plt.refcount <= 0
9c7a29a3
AM		 1331 || SYMBOL_CALLS_LOCAL (info, h)
1332 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1333 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 1334 {
1335 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1336 file, but the symbol was never referred to by a dynamic
1337 object, or if all references were garbage collected. In
1338 such a case, we don't actually need to build a procedure
1339 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1340 h->plt.offset = (bfd_vma) -1;
f5385ebf 1341 h->needs_plt = 0;
252b5132
RH		 1342 }
1343
b34976b6 1344 return TRUE;
252b5132 1345 }
6725bdbf
AM		 1346 else
1347 /* It's possible that we incorrectly decided a .plt reloc was
1348 needed for an R_386_PC32 reloc to a non-function sym in
1349 check_relocs. We can't decide accurately between function and
1350 non-function syms in check-relocs; Objects loaded later in
1351 the link may change h->type. So fix it now. */
bbd7ec4a 1352 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1353
1354 /* If this is a weak symbol, and there is a real definition, the
1355 processor independent code will have arranged for us to see the
1356 real definition first, and we can just use the same value. */
f6e332e6 1357 if (h->u.weakdef != NULL)
252b5132 1358 {
f6e332e6
AM		 1359 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1360 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1361 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1362 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 1363 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 1364 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 1365 return TRUE;
252b5132
RH		 1366 }
1367
1368 /* This is a reference to a symbol defined by a dynamic object which
1369 is not a function. */
1370
1371 /* If we are creating a shared library, we must presume that the
1372 only references to the symbol are via the global offset table.
1373 For such cases we need not do anything here; the relocations will
1374 be handled correctly by relocate_section. */
1375 if (info->shared)
b34976b6 1376 return TRUE;
252b5132 1377
7843f00e
ILT		 1378 /* If there are no references to this symbol that do not use the
1379 GOT, we don't need to generate a copy reloc. */
f5385ebf 1380 if (!h->non_got_ref)
b34976b6 1381 return TRUE;
7843f00e 1382
8bd621d8
AM		 1383 /* If -z nocopyreloc was given, we won't generate them either. */
1384 if (info->nocopyreloc)
1385 {
f5385ebf 1386 h->non_got_ref = 0;
b34976b6 1387 return TRUE;
8bd621d8
AM		 1388 }
1389
a23b6845 1390 if (ELIMINATE_COPY_RELOCS)
ebe50bae 1391 {
a23b6845
AM		 1392 struct elf_i386_link_hash_entry * eh;
1393 struct elf_i386_dyn_relocs *p;
ebe50bae 1394
a23b6845
AM		 1395 eh = (struct elf_i386_link_hash_entry *) h;
1396 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1397 {
1398 s = p->sec->output_section;
1399 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1400 break;
1401 }
1402
1403 /* If we didn't find any dynamic relocs in read-only sections, then
1404 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1405 if (p == NULL)
1406 {
f5385ebf 1407 h->non_got_ref = 0;
a23b6845
AM		 1408 return TRUE;
1409 }
ebe50bae
AM		 1410 }
1411
252b5132
RH		 1412 /* We must allocate the symbol in our .dynbss section, which will
1413 become part of the .bss section of the executable. There will be
1414 an entry for this symbol in the .dynsym section. The dynamic
1415 object will contain position independent code, so all references
1416 from the dynamic object to this symbol will go through the global
1417 offset table. The dynamic linker will use the .dynsym entry to
1418 determine the address it must put in the global offset table, so
1419 both the dynamic object and the regular object will refer to the
1420 same memory location for the variable. */
1421
0ac8d2ca 1422 htab = elf_i386_hash_table (info);
252b5132
RH		 1423
1424 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1425 copy the initial value out of the dynamic object and into the
0ac8d2ca 1426 runtime process image. */
252b5132
RH		 1427 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1428 {
eea6121a 1429 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 1430 h->needs_copy = 1;
252b5132
RH		 1431 }
1432
1433 /* We need to figure out the alignment required for this symbol. I
1434 have no idea how ELF linkers handle this. */
1435 power_of_two = bfd_log2 (h->size);
1436 if (power_of_two > 3)
1437 power_of_two = 3;
1438
1439 /* Apply the required alignment. */
0ac8d2ca 1440 s = htab->sdynbss;
eea6121a 1441 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
0ac8d2ca 1442 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
252b5132 1443 {
0ac8d2ca 1444 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
b34976b6 1445 return FALSE;
252b5132
RH		 1446 }
1447
1448 /* Define the symbol as being at this point in the section. */
1449 h->root.u.def.section = s;
eea6121a 1450 h->root.u.def.value = s->size;
252b5132
RH		 1451
1452 /* Increment the section size to make room for the symbol. */
eea6121a 1453 s->size += h->size;
252b5132 1454
b34976b6 1455 return TRUE;
252b5132
RH		 1456}
1457
6725bdbf 1458/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1459 dynamic relocs. */
6725bdbf 1460
b34976b6 1461static bfd_boolean
55fd94b0 1462allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 1463{
1464 struct bfd_link_info *info;
1465 struct elf_i386_link_hash_table *htab;
5a15f56f 1466 struct elf_i386_link_hash_entry *eh;
0c715baa 1467 struct elf_i386_dyn_relocs *p;
6725bdbf 1468
e92d460e 1469 if (h->root.type == bfd_link_hash_indirect)
b34976b6 1470 return TRUE;
6725bdbf 1471
e92d460e
AM		 1472 if (h->root.type == bfd_link_hash_warning)
1473 /* When warning symbols are created, they **replace** the "real"
1474 entry in the hash table, thus we never get to see the real
1475 symbol in a hash traversal. So look at it now. */
1476 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1477
6725bdbf
AM		 1478 info = (struct bfd_link_info *) inf;
1479 htab = elf_i386_hash_table (info);
1480
ebe50bae 1481 if (htab->elf.dynamic_sections_created
9c7a29a3 1482 && h->plt.refcount > 0)
6725bdbf 1483 {
5a15f56f
AM		 1484 /* Make sure this symbol is output as a dynamic symbol.
1485 Undefined weak syms won't yet be marked as dynamic. */
1486 if (h->dynindx == -1
f5385ebf 1487 && !h->forced_local)
5a15f56f 1488 {
c152c796 1489 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1490 return FALSE;
5a15f56f
AM		 1491 }
1492
4e795f50
AM		 1493 if (info->shared
1494 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 1495 {
0ac8d2ca 1496 asection *s = htab->splt;
6725bdbf 1497
ced53ee5
AM		 1498 /* If this is the first .plt entry, make room for the special
1499 first entry. */
eea6121a
AM		 1500 if (s->size == 0)
1501 s->size += PLT_ENTRY_SIZE;
6725bdbf 1502
eea6121a 1503 h->plt.offset = s->size;
6725bdbf 1504
ced53ee5
AM		 1505 /* If this symbol is not defined in a regular file, and we are
1506 not generating a shared library, then set the symbol to this
1507 location in the .plt. This is required to make function
1508 pointers compare as equal between the normal executable and
1509 the shared library. */
1510 if (! info->shared
f5385ebf 1511 && !h->def_regular)
ced53ee5
AM		 1512 {
1513 h->root.u.def.section = s;
1514 h->root.u.def.value = h->plt.offset;
1515 }
6725bdbf 1516
ced53ee5 1517 /* Make room for this entry. */
eea6121a 1518 s->size += PLT_ENTRY_SIZE;
6725bdbf 1519
ced53ee5
AM		 1520 /* We also need to make an entry in the .got.plt section, which
1521 will be placed in the .got section by the linker script. */
eea6121a 1522 htab->sgotplt->size += 4;
6725bdbf 1523
6725bdbf 1524 /* We also need to make an entry in the .rel.plt section. */
eea6121a 1525 htab->srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf 1526 }
ced53ee5
AM		 1527 else
1528 {
51b64d56 1529 h->plt.offset = (bfd_vma) -1;
f5385ebf 1530 h->needs_plt = 0;
ced53ee5 1531 }
6725bdbf
AM		 1532 }
1533 else
1534 {
51b64d56 1535 h->plt.offset = (bfd_vma) -1;
f5385ebf 1536 h->needs_plt = 0;
6725bdbf
AM		 1537 }
1538
37e55690 1539 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 1540 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1541 if (h->got.refcount > 0
1542 && !info->shared
1543 && h->dynindx == -1
37e55690 1544 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 1545 h->got.offset = (bfd_vma) -1;
13ae64f3 1546 else if (h->got.refcount > 0)
6725bdbf 1547 {
0ac8d2ca 1548 asection *s;
b34976b6 1549 bfd_boolean dyn;
13ae64f3 1550 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1551
5a15f56f
AM		 1552 /* Make sure this symbol is output as a dynamic symbol.
1553 Undefined weak syms won't yet be marked as dynamic. */
1554 if (h->dynindx == -1
f5385ebf 1555 && !h->forced_local)
5a15f56f 1556 {
c152c796 1557 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1558 return FALSE;
5a15f56f
AM		 1559 }
1560
6725bdbf 1561 s = htab->sgot;
eea6121a
AM		 1562 h->got.offset = s->size;
1563 s->size += 4;
13ae64f3 1564 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
37e55690 1565 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
eea6121a 1566 s->size += 4;
ebe50bae 1567 dyn = htab->elf.dynamic_sections_created;
13ae64f3 1568 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 1569 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1570 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1571 need two), R_386_TLS_GD needs one if local symbol and two if
1572 global. */
1573 if (tls_type == GOT_TLS_IE_BOTH)
eea6121a 1574 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
37e55690
JJ		 1575 else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1576 || (tls_type & GOT_TLS_IE))
eea6121a 1577 htab->srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3 1578 else if (tls_type == GOT_TLS_GD)
eea6121a 1579 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
ef5aade5
L		 1580 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1581 || h->root.type != bfd_link_hash_undefweak)
1582 && (info->shared
1583 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
eea6121a 1584 htab->srelgot->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 1585 }
1586 else
51b64d56 1587 h->got.offset = (bfd_vma) -1;
6725bdbf 1588
5a15f56f
AM		 1589 eh = (struct elf_i386_link_hash_entry *) h;
1590 if (eh->dyn_relocs == NULL)
b34976b6 1591 return TRUE;
5a15f56f 1592
0c715baa
AM		 1593 /* In the shared -Bsymbolic case, discard space allocated for
1594 dynamic pc-relative relocs against symbols which turn out to be
1595 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 1596 space for pc-relative relocs that have become local due to symbol
1597 visibility changes. */
0c715baa
AM		 1598
1599 if (info->shared)
5a15f56f 1600 {
09695f56
AM		 1601 /* The only reloc that uses pc_count is R_386_PC32, which will
1602 appear on a call or on something like ".long foo - .". We
1603 want calls to protected symbols to resolve directly to the
1604 function rather than going via the plt. If people want
1605 function pointer comparisons to work as expected then they
1606 should avoid writing assembly like ".long foo - .". */
1607 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 1608 {
0c715baa
AM		 1609 struct elf_i386_dyn_relocs **pp;
1610
1611 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1612 {
1613 p->count -= p->pc_count;
1614 p->pc_count = 0;
1615 if (p->count == 0)
1616 *pp = p->next;
1617 else
1618 pp = &p->next;
1619 }
5a15f56f 1620 }
4e795f50
AM		 1621
1622 /* Also discard relocs on undefined weak syms with non-default
1623 visibility. */
1624 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1625 && h->root.type == bfd_link_hash_undefweak)
1626 eh->dyn_relocs = NULL;
0c715baa 1627 }
a23b6845 1628 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 1629 {
1630 /* For the non-shared case, discard space for relocs against
1631 symbols which turn out to need copy relocs or are not
1632 dynamic. */
1633
f5385ebf
AM		 1634 if (!h->non_got_ref
1635 && ((h->def_dynamic
1636 && !h->def_regular)
ebe50bae 1637 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1638 && (h->root.type == bfd_link_hash_undefweak
1639 || h->root.type == bfd_link_hash_undefined))))
1640 {
1641 /* Make sure this symbol is output as a dynamic symbol.
1642 Undefined weak syms won't yet be marked as dynamic. */
1643 if (h->dynindx == -1
f5385ebf 1644 && !h->forced_local)
0c715baa 1645 {
c152c796 1646 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1647 return FALSE;
0c715baa 1648 }
5a15f56f 1649
0c715baa
AM		 1650 /* If that succeeded, we know we'll be keeping all the
1651 relocs. */
1652 if (h->dynindx != -1)
1653 goto keep;
1654 }
1655
1656 eh->dyn_relocs = NULL;
1657
ec338859 1658 keep: ;
5a15f56f
AM		 1659 }
1660
0c715baa
AM		 1661 /* Finally, allocate space. */
1662 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1663 {
0c715baa 1664 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 1665 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1666 }
1667
b34976b6 1668 return TRUE;
6725bdbf
AM		 1669}
1670
0c715baa
AM		 1671/* Find any dynamic relocs that apply to read-only sections. */
1672
b34976b6 1673static bfd_boolean
55fd94b0 1674readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 1675{
1676 struct elf_i386_link_hash_entry *eh;
1677 struct elf_i386_dyn_relocs *p;
1678
e92d460e
AM		 1679 if (h->root.type == bfd_link_hash_warning)
1680 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1681
0c715baa
AM		 1682 eh = (struct elf_i386_link_hash_entry *) h;
1683 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1684 {
1685 asection *s = p->sec->output_section;
1686
1687 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1688 {
1689 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1690
1691 info->flags |= DF_TEXTREL;
1692
1693 /* Not an error, just cut short the traversal. */
b34976b6 1694 return FALSE;
0c715baa
AM		 1695 }
1696 }
b34976b6 1697 return TRUE;
0c715baa
AM		 1698}
1699
252b5132
RH		 1700/* Set the sizes of the dynamic sections. */
1701
b34976b6 1702static bfd_boolean
55fd94b0
AM		 1703elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1704 struct bfd_link_info *info)
252b5132 1705{
6725bdbf 1706 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1707 bfd *dynobj;
1708 asection *s;
b34976b6 1709 bfd_boolean relocs;
0c715baa 1710 bfd *ibfd;
252b5132 1711
6725bdbf 1712 htab = elf_i386_hash_table (info);
ebe50bae 1713 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1714 if (dynobj == NULL)
1715 abort ();
252b5132 1716
ebe50bae 1717 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1718 {
1719 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 1720 if (info->executable)
252b5132
RH		 1721 {
1722 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1723 if (s == NULL)
1724 abort ();
eea6121a 1725 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 1726 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1727 }
161d71a6 1728 }
6725bdbf 1729
0c715baa
AM		 1730 /* Set up .got offsets for local syms, and space for local dynamic
1731 relocs. */
1732 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1733 {
1734 bfd_signed_vma *local_got;
1735 bfd_signed_vma *end_local_got;
13ae64f3 1736 char *local_tls_type;
161d71a6
L		 1737 bfd_size_type locsymcount;
1738 Elf_Internal_Shdr *symtab_hdr;
1739 asection *srel;
6725bdbf 1740
0c715baa 1741 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1742 continue;
6725bdbf 1743
0c715baa
AM		 1744 for (s = ibfd->sections; s != NULL; s = s->next)
1745 {
ec338859 1746 struct elf_i386_dyn_relocs *p;
0c715baa 1747
ec338859
AM		 1748 for (p = *((struct elf_i386_dyn_relocs **)
1749 &elf_section_data (s)->local_dynrel);
1750 p != NULL;
1751 p = p->next)
0c715baa 1752 {
ec338859
AM		 1753 if (!bfd_is_abs_section (p->sec)
1754 && bfd_is_abs_section (p->sec->output_section))
1755 {
1756 /* Input section has been discarded, either because
1757 it is a copy of a linkonce section or due to
1758 linker script /DISCARD/, so we'll be discarding
1759 the relocs too. */
1760 }
248866a8 1761 else if (p->count != 0)
ec338859
AM		 1762 {
1763 srel = elf_section_data (p->sec)->sreloc;
eea6121a 1764 srel->size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1765 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1766 info->flags |= DF_TEXTREL;
ec338859 1767 }
0c715baa
AM		 1768 }
1769 }
1770
1771 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1772 if (!local_got)
1773 continue;
6725bdbf 1774
0c715baa 1775 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1776 locsymcount = symtab_hdr->sh_info;
1777 end_local_got = local_got + locsymcount;
13ae64f3 1778 local_tls_type = elf_i386_local_got_tls_type (ibfd);
161d71a6
L		 1779 s = htab->sgot;
1780 srel = htab->srelgot;
13ae64f3 1781 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
161d71a6
L		 1782 {
1783 if (*local_got > 0)
6725bdbf 1784 {
eea6121a
AM		 1785 *local_got = s->size;
1786 s->size += 4;
37e55690
JJ		 1787 if (*local_tls_type == GOT_TLS_GD
1788 || *local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 1789 s->size += 4;
13ae64f3
JJ		 1790 if (info->shared
1791 || *local_tls_type == GOT_TLS_GD
37e55690
JJ		 1792 || (*local_tls_type & GOT_TLS_IE))
1793 {
1794 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 1795 srel->size += 2 * sizeof (Elf32_External_Rel);
37e55690 1796 else
eea6121a 1797 srel->size += sizeof (Elf32_External_Rel);
37e55690 1798 }
6725bdbf 1799 }
161d71a6
L		 1800 else
1801 *local_got = (bfd_vma) -1;
6725bdbf 1802 }
252b5132 1803 }
6725bdbf 1804
13ae64f3
JJ		 1805 if (htab->tls_ldm_got.refcount > 0)
1806 {
1807 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1808 relocs. */
eea6121a
AM		 1809 htab->tls_ldm_got.offset = htab->sgot->size;
1810 htab->sgot->size += 8;
1811 htab->srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 1812 }
1813 else
1814 htab->tls_ldm_got.offset = -1;
1815
0c715baa
AM		 1816 /* Allocate global sym .plt and .got entries, and space for global
1817 sym dynamic relocs. */
ebe50bae 1818 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1819
5a15f56f
AM		 1820 /* We now have determined the sizes of the various dynamic sections.
1821 Allocate memory for them. */
b34976b6 1822 relocs = FALSE;
252b5132
RH		 1823 for (s = dynobj->sections; s != NULL; s = s->next)
1824 {
252b5132
RH		 1825 if ((s->flags & SEC_LINKER_CREATED) == 0)
1826 continue;
1827
6725bdbf
AM		 1828 if (s == htab->splt
1829 || s == htab->sgot
1830 || s == htab->sgotplt)
252b5132 1831 {
6725bdbf
AM		 1832 /* Strip this section if we don't need it; see the
1833 comment below. */
252b5132 1834 }
6725bdbf 1835 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 1836 {
eea6121a 1837 if (s->size != 0 && s != htab->srelplt)
b34976b6 1838 relocs = TRUE;
252b5132 1839
0ac8d2ca
AM		 1840 /* We use the reloc_count field as a counter if we need
1841 to copy relocs into the output file. */
1842 s->reloc_count = 0;
252b5132 1843 }
6725bdbf 1844 else
252b5132
RH		 1845 {
1846 /* It's not one of our sections, so don't allocate space. */
1847 continue;
1848 }
1849
eea6121a 1850 if (s->size == 0)
252b5132 1851 {
0ac8d2ca
AM		 1852 /* If we don't need this section, strip it from the
1853 output file. This is mostly to handle .rel.bss and
1854 .rel.plt. We must create both sections in
1855 create_dynamic_sections, because they must be created
1856 before the linker maps input sections to output
1857 sections. The linker does that before
1858 adjust_dynamic_symbol is called, and it is that
1859 function which decides whether anything needs to go
1860 into these sections. */
1861
7f8d5fc9 1862 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1863 continue;
1864 }
1865
f69da49f
AM		 1866 /* Allocate memory for the section contents. We use bfd_zalloc
1867 here in case unused entries are not reclaimed before the
1868 section's contents are written out. This should not happen,
1869 but this way if it does, we get a R_386_NONE reloc instead
1870 of garbage. */
eea6121a 1871 s->contents = bfd_zalloc (dynobj, s->size);
6725bdbf 1872 if (s->contents == NULL)
b34976b6 1873 return FALSE;
252b5132
RH		 1874 }
1875
ebe50bae 1876 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1877 {
1878 /* Add some entries to the .dynamic section. We fill in the
1879 values later, in elf_i386_finish_dynamic_sections, but we
1880 must add the entries now so that we get the correct size for
1881 the .dynamic section. The DT_DEBUG entry is filled in by the
1882 dynamic linker and used by the debugger. */
dc810e39 1883#define add_dynamic_entry(TAG, VAL) \
5a580b3a 1884 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 1885
36af4a4e 1886 if (info->executable)
252b5132 1887 {
dc810e39 1888 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 1889 return FALSE;
252b5132
RH		 1890 }
1891
eea6121a 1892 if (htab->splt->size != 0)
252b5132 1893 {
dc810e39
AM		 1894 if (!add_dynamic_entry (DT_PLTGOT, 0)
1895 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1896 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1897 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 1898 return FALSE;
252b5132
RH		 1899 }
1900
1901 if (relocs)
1902 {
dc810e39
AM		 1903 if (!add_dynamic_entry (DT_REL, 0)
1904 || !add_dynamic_entry (DT_RELSZ, 0)
1905 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 1906 return FALSE;
252b5132 1907
0c715baa
AM		 1908 /* If any dynamic relocs apply to a read-only section,
1909 then we need a DT_TEXTREL entry. */
248866a8
AM		 1910 if ((info->flags & DF_TEXTREL) == 0)
1911 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1912 (PTR) info);
0c715baa
AM		 1913
1914 if ((info->flags & DF_TEXTREL) != 0)
1915 {
1916 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 1917 return FALSE;
0c715baa 1918 }
252b5132
RH		 1919 }
1920 }
dc810e39 1921#undef add_dynamic_entry
252b5132 1922
b34976b6 1923 return TRUE;
252b5132
RH		 1924}
1925
38701953
AM		 1926/* Set the correct type for an x86 ELF section. We do this by the
1927 section name, which is a hack, but ought to work. */
1928
b34976b6 1929static bfd_boolean
55fd94b0
AM		 1930elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
1931 Elf_Internal_Shdr *hdr,
1932 asection *sec)
38701953
AM		 1933{
1934 register const char *name;
1935
1936 name = bfd_get_section_name (abfd, sec);
1937
1938 /* This is an ugly, but unfortunately necessary hack that is
1939 needed when producing EFI binaries on x86. It tells
1940 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1941 containing ELF relocation info. We need this hack in order to
1942 be able to generate ELF binaries that can be translated into
1943 EFI applications (which are essentially COFF objects). Those
1944 files contain a COFF ".reloc" section inside an ELFNN object,
1945 which would normally cause BFD to segfault because it would
1946 attempt to interpret this section as containing relocation
1947 entries for section "oc". With this hack enabled, ".reloc"
1948 will be treated as a normal data section, which will avoid the
1949 segfault. However, you won't be able to create an ELFNN binary
1950 with a section named "oc" that needs relocations, but that's
1951 the kind of ugly side-effects you get when detecting section
1952 types based on their names... In practice, this limitation is
1953 unlikely to bite. */
1954 if (strcmp (name, ".reloc") == 0)
1955 hdr->sh_type = SHT_PROGBITS;
1956
b34976b6 1957 return TRUE;
38701953
AM		 1958}
1959
13ae64f3
JJ		 1960/* Return the base VMA address which should be subtracted from real addresses
1961 when resolving @dtpoff relocation.
1962 This is PT_TLS segment p_vaddr. */
1963
1964static bfd_vma
55fd94b0 1965dtpoff_base (struct bfd_link_info *info)
13ae64f3 1966{
e1918d23
AM		 1967 /* If tls_sec is NULL, we should have signalled an error already. */
1968 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 1969 return 0;
e1918d23 1970 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 1971}
1972
1973/* Return the relocation value for @tpoff relocation
1974 if STT_TLS virtual address is ADDRESS. */
1975
1976static bfd_vma
55fd94b0 1977tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 1978{
e1918d23 1979 struct elf_link_hash_table *htab = elf_hash_table (info);
13ae64f3 1980
e1918d23
AM		 1981 /* If tls_sec is NULL, we should have signalled an error already. */
1982 if (htab->tls_sec == NULL)
6a30718d 1983 return 0;
e1918d23 1984 return htab->tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 1985}
1986
252b5132
RH		 1987/* Relocate an i386 ELF section. */
1988
b34976b6 1989static bfd_boolean
55fd94b0
AM		 1990elf_i386_relocate_section (bfd *output_bfd,
1991 struct bfd_link_info *info,
1992 bfd *input_bfd,
1993 asection *input_section,
1994 bfd_byte *contents,
1995 Elf_Internal_Rela *relocs,
1996 Elf_Internal_Sym *local_syms,
1997 asection **local_sections)
252b5132 1998{
6725bdbf 1999 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2000 Elf_Internal_Shdr *symtab_hdr;
2001 struct elf_link_hash_entry **sym_hashes;
2002 bfd_vma *local_got_offsets;
252b5132
RH		 2003 Elf_Internal_Rela *rel;
2004 Elf_Internal_Rela *relend;
2005
6725bdbf 2006 htab = elf_i386_hash_table (info);
252b5132
RH		 2007 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2008 sym_hashes = elf_sym_hashes (input_bfd);
2009 local_got_offsets = elf_local_got_offsets (input_bfd);
2010
252b5132
RH		 2011 rel = relocs;
2012 relend = relocs + input_section->reloc_count;
2013 for (; rel < relend; rel++)
2014 {
13ae64f3 2015 unsigned int r_type;
252b5132
RH		 2016 reloc_howto_type *howto;
2017 unsigned long r_symndx;
2018 struct elf_link_hash_entry *h;
2019 Elf_Internal_Sym *sym;
2020 asection *sec;
ffb2e45b 2021 bfd_vma off;
252b5132 2022 bfd_vma relocation;
b34976b6 2023 bfd_boolean unresolved_reloc;
252b5132 2024 bfd_reloc_status_type r;
1b452ec6 2025 unsigned int indx;
13ae64f3 2026 int tls_type;
252b5132
RH		 2027
2028 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 2029 if (r_type == R_386_GNU_VTINHERIT
2030 || r_type == R_386_GNU_VTENTRY)
252b5132 2031 continue;
dc47f327 2032
55fd94b0 2033 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 2034 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2035 >= R_386_ext - R_386_standard)
2036 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2037 >= R_386_tls - R_386_ext))
252b5132 2038 {
6ba842b6 2039 (*_bfd_error_handler)
d003868e
AM		 2040 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2041 input_bfd, input_section, r_type);
252b5132 2042 bfd_set_error (bfd_error_bad_value);
b34976b6 2043 return FALSE;
252b5132 2044 }
1b452ec6 2045 howto = elf_howto_table + indx;
252b5132
RH		 2046
2047 r_symndx = ELF32_R_SYM (rel->r_info);
2048
1049f94e 2049 if (info->relocatable)
252b5132 2050 {
4a335f3d 2051 bfd_vma val;
4a335f3d
AM		 2052 bfd_byte *where;
2053
0ac8d2ca 2054 /* This is a relocatable link. We don't have to change
252b5132
RH		 2055 anything, unless the reloc is against a section symbol,
2056 in which case we have to adjust according to where the
2057 section symbol winds up in the output section. */
4a335f3d
AM		 2058 if (r_symndx >= symtab_hdr->sh_info)
2059 continue;
2060
2061 sym = local_syms + r_symndx;
2062 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2063 continue;
2064
2065 sec = local_sections[r_symndx];
2066 val = sec->output_offset;
2067 if (val == 0)
2068 continue;
2069
2070 where = contents + rel->r_offset;
2071 switch (howto->size)
252b5132 2072 {
16a10388 2073 /* FIXME: overflow checks. */
4a335f3d 2074 case 0:
16a10388 2075 val += bfd_get_8 (input_bfd, where);
4a335f3d 2076 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2077 break;
2078 case 1:
16a10388 2079 val += bfd_get_16 (input_bfd, where);
4a335f3d 2080 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2081 break;
2082 case 2:
2083 val += bfd_get_32 (input_bfd, where);
2084 bfd_put_32 (input_bfd, val, where);
2085 break;
2086 default:
2087 abort ();
252b5132 2088 }
252b5132
RH		 2089 continue;
2090 }
2091
2092 /* This is a final link. */
2093 h = NULL;
2094 sym = NULL;
2095 sec = NULL;
b34976b6 2096 unresolved_reloc = FALSE;
252b5132
RH		 2097 if (r_symndx < symtab_hdr->sh_info)
2098 {
2099 sym = local_syms + r_symndx;
2100 sec = local_sections[r_symndx];
2101 relocation = (sec->output_section->vma
2102 + sec->output_offset
2103 + sym->st_value);
f8df10f4
JJ		 2104 if ((sec->flags & SEC_MERGE)
2105 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2106 {
2107 asection *msec;
2108 bfd_vma addend;
4a335f3d 2109 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2110
4a335f3d 2111 switch (howto->size)
f8df10f4 2112 {
4a335f3d
AM		 2113 case 0:
2114 addend = bfd_get_8 (input_bfd, where);
2115 if (howto->pc_relative)
2116 {
2117 addend = (addend ^ 0x80) - 0x80;
2118 addend += 1;
2119 }
2120 break;
2121 case 1:
2122 addend = bfd_get_16 (input_bfd, where);
2123 if (howto->pc_relative)
2124 {
2125 addend = (addend ^ 0x8000) - 0x8000;
2126 addend += 2;
2127 }
2128 break;
2129 case 2:
2130 addend = bfd_get_32 (input_bfd, where);
2131 if (howto->pc_relative)
2132 {
2133 addend = (addend ^ 0x80000000) - 0x80000000;
2134 addend += 4;
2135 }
2136 break;
2137 default:
2138 abort ();
f8df10f4
JJ		 2139 }
2140
f8df10f4 2141 msec = sec;
4a335f3d
AM		 2142 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2143 addend -= relocation;
f8df10f4 2144 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2145
2146 switch (howto->size)
2147 {
2148 case 0:
16a10388 2149 /* FIXME: overflow checks. */
4a335f3d
AM		 2150 if (howto->pc_relative)
2151 addend -= 1;
2152 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2153 break;
2154 case 1:
2155 if (howto->pc_relative)
2156 addend -= 2;
2157 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2158 break;
2159 case 2:
2160 if (howto->pc_relative)
2161 addend -= 4;
2162 bfd_put_32 (input_bfd, addend, where);
2163 break;
2164 }
f8df10f4 2165 }
252b5132
RH		 2166 }
2167 else
2168 {
560e09e9 2169 bfd_boolean warned;
ffb2e45b 2170
b2a8e766
AM		 2171 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2172 r_symndx, symtab_hdr, sym_hashes,
2173 h, sec, relocation,
2174 unresolved_reloc, warned);
252b5132
RH		 2175 }
2176
2177 switch (r_type)
2178 {
2179 case R_386_GOT32:
2180 /* Relocation is to the entry for this symbol in the global
2181 offset table. */
ffb2e45b
AM		 2182 if (htab->sgot == NULL)
2183 abort ();
252b5132
RH		 2184
2185 if (h != NULL)
2186 {
b34976b6 2187 bfd_boolean dyn;
252b5132
RH		 2188
2189 off = h->got.offset;
ebe50bae 2190 dyn = htab->elf.dynamic_sections_created;
26e41594 2191 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2192 || (info->shared
586119b3 2193 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 2194 || (ELF_ST_VISIBILITY (h->other)
2195 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2196 {
2197 /* This is actually a static link, or it is a
2198 -Bsymbolic link and the symbol is defined
2199 locally, or the symbol was forced to be local
2200 because of a version file. We must initialize
2201 this entry in the global offset table. Since the
2202 offset must always be a multiple of 4, we use the
2203 least significant bit to record whether we have
2204 initialized it already.
2205
2206 When doing a dynamic link, we create a .rel.got
2207 relocation entry to initialize the value. This
2208 is done in the finish_dynamic_symbol routine. */
2209 if ((off & 1) != 0)
2210 off &= ~1;
2211 else
2212 {
2213 bfd_put_32 (output_bfd, relocation,
6725bdbf 2214 htab->sgot->contents + off);
252b5132
RH		 2215 h->got.offset |= 1;
2216 }
2217 }
8c694914 2218 else
b34976b6 2219 unresolved_reloc = FALSE;
252b5132
RH		 2220 }
2221 else
2222 {
ffb2e45b
AM		 2223 if (local_got_offsets == NULL)
2224 abort ();
252b5132
RH		 2225
2226 off = local_got_offsets[r_symndx];
2227
2228 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2229 the least significant bit to record whether we have
2230 already generated the necessary reloc. */
252b5132
RH		 2231 if ((off & 1) != 0)
2232 off &= ~1;
2233 else
2234 {
6725bdbf
AM		 2235 bfd_put_32 (output_bfd, relocation,
2236 htab->sgot->contents + off);
252b5132
RH		 2237
2238 if (info->shared)
2239 {
947216bf
AM		 2240 asection *s;
2241 Elf_Internal_Rela outrel;
2242 bfd_byte *loc;
252b5132 2243
947216bf
AM		 2244 s = htab->srelgot;
2245 if (s == NULL)
ffb2e45b 2246 abort ();
252b5132 2247
6725bdbf
AM		 2248 outrel.r_offset = (htab->sgot->output_section->vma
2249 + htab->sgot->output_offset
252b5132
RH		 2250 + off);
2251 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 2252 loc = s->contents;
2253 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 2254 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2255 }
2256
2257 local_got_offsets[r_symndx] |= 1;
2258 }
252b5132
RH		 2259 }
2260
ffb2e45b
AM		 2261 if (off >= (bfd_vma) -2)
2262 abort ();
2263
8c37241b
JJ		 2264 relocation = htab->sgot->output_section->vma
2265 + htab->sgot->output_offset + off
2266 - htab->sgotplt->output_section->vma
2267 - htab->sgotplt->output_offset;
252b5132
RH		 2268 break;
2269
2270 case R_386_GOTOFF:
2271 /* Relocation is relative to the start of the global offset
2272 table. */
2273
8c37241b
JJ		 2274 /* Note that sgot is not involved in this
2275 calculation. We always want the start of .got.plt. If we
2276 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 2277 permitted by the ABI, we might have to change this
2278 calculation. */
8c37241b
JJ		 2279 relocation -= htab->sgotplt->output_section->vma
2280 + htab->sgotplt->output_offset;
252b5132
RH		 2281 break;
2282
2283 case R_386_GOTPC:
2284 /* Use global offset table as symbol value. */
8c37241b
JJ		 2285 relocation = htab->sgotplt->output_section->vma
2286 + htab->sgotplt->output_offset;
b34976b6 2287 unresolved_reloc = FALSE;
252b5132
RH		 2288 break;
2289
2290 case R_386_PLT32:
2291 /* Relocation is to the entry for this symbol in the
2292 procedure linkage table. */
2293
dd5724d5 2294 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2295 without using the procedure linkage table. */
252b5132
RH		 2296 if (h == NULL)
2297 break;
2298
dd5724d5 2299 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2300 || htab->splt == NULL)
252b5132
RH		 2301 {
2302 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2303 happens when statically linking PIC code, or when
2304 using -Bsymbolic. */
252b5132
RH		 2305 break;
2306 }
2307
6725bdbf
AM		 2308 relocation = (htab->splt->output_section->vma
2309 + htab->splt->output_offset
252b5132 2310 + h->plt.offset);
b34976b6 2311 unresolved_reloc = FALSE;
252b5132
RH		 2312 break;
2313
2314 case R_386_32:
2315 case R_386_PC32:
ec338859
AM		 2316 /* r_symndx will be zero only for relocs against symbols
2317 from removed linkonce sections, or sections discarded by
2318 a linker script. */
f855931b
AM		 2319 if (r_symndx == 0)
2320 {
2321 /* Zero the section contents. eh_frame generated by old
2322 versions of gcc isn't edited by elf-eh-frame.c, so
2323 FDEs for discarded linkonce functions might remain.
2324 Putting zeros here will zero such FDE's address range.
2325 This is a hint to unwinders and other consumers of
2326 exception handling info that the FDE is invalid. */
2327 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
3e95eabc 2328 break;
f855931b
AM		 2329 }
2330
2331 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 2332 break;
2333
12d0ee4a 2334 if ((info->shared
ef5aade5
L		 2335 && (h == NULL
2336 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2337 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a 2338 && (r_type != R_386_PC32
f6c52c13 2339 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845
AM		 2340 || (ELIMINATE_COPY_RELOCS
2341 && !info->shared
12d0ee4a
AM		 2342 && h != NULL
2343 && h->dynindx != -1
f5385ebf
AM		 2344 && !h->non_got_ref
2345 && ((h->def_dynamic
2346 && !h->def_regular)
28d0b90e
AM		 2347 || h->root.type == bfd_link_hash_undefweak
2348 || h->root.type == bfd_link_hash_undefined)))
252b5132 2349 {
947216bf
AM		 2350 Elf_Internal_Rela outrel;
2351 bfd_byte *loc;
b34976b6 2352 bfd_boolean skip, relocate;
0c715baa 2353 asection *sreloc;
252b5132
RH		 2354
2355 /* When generating a shared object, these relocations
2356 are copied into the output file to be resolved at run
2357 time. */
2358
b34976b6
AM		 2359 skip = FALSE;
2360 relocate = FALSE;
252b5132 2361
c629eae0
JJ		 2362 outrel.r_offset =
2363 _bfd_elf_section_offset (output_bfd, info, input_section,
2364 rel->r_offset);
2365 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2366 skip = TRUE;
0bb2d96a 2367 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2368 skip = TRUE, relocate = TRUE;
252b5132
RH		 2369 outrel.r_offset += (input_section->output_section->vma
2370 + input_section->output_offset);
2371
2372 if (skip)
0bb2d96a 2373 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2374 else if (h != NULL
2375 && h->dynindx != -1
2376 && (r_type == R_386_PC32
2377 || !info->shared
2378 || !info->symbolic
f5385ebf 2379 || !h->def_regular))
0bb2d96a 2380 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2381 else
2382 {
5a15f56f 2383 /* This symbol is local, or marked to become local. */
b34976b6 2384 relocate = TRUE;
5a15f56f 2385 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2386 }
2387
0c715baa
AM		 2388 sreloc = elf_section_data (input_section)->sreloc;
2389 if (sreloc == NULL)
2390 abort ();
2391
947216bf
AM		 2392 loc = sreloc->contents;
2393 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
0c715baa 2394 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2395
2396 /* If this reloc is against an external symbol, we do
2397 not want to fiddle with the addend. Otherwise, we
2398 need to include the symbol value so that it becomes
2399 an addend for the dynamic reloc. */
2400 if (! relocate)
2401 continue;
2402 }
252b5132
RH		 2403 break;
2404
37e55690
JJ		 2405 case R_386_TLS_IE:
2406 if (info->shared)
2407 {
947216bf
AM		 2408 Elf_Internal_Rela outrel;
2409 bfd_byte *loc;
37e55690 2410 asection *sreloc;
37e55690
JJ		 2411
2412 outrel.r_offset = rel->r_offset
2413 + input_section->output_section->vma
2414 + input_section->output_offset;
2415 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2416 sreloc = elf_section_data (input_section)->sreloc;
2417 if (sreloc == NULL)
2418 abort ();
947216bf
AM		 2419 loc = sreloc->contents;
2420 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2421 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2422 }
2423 /* Fall through */
2424
13ae64f3
JJ		 2425 case R_386_TLS_GD:
2426 case R_386_TLS_IE_32:
37e55690 2427 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2428 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2429 tls_type = GOT_UNKNOWN;
2430 if (h == NULL && local_got_offsets)
2431 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2432 else if (h != NULL)
2433 {
2434 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690 2435 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 2436 r_type = R_386_TLS_LE_32;
2437 }
37e55690
JJ		 2438 if (tls_type == GOT_TLS_IE)
2439 tls_type = GOT_TLS_IE_NEG;
2440 if (r_type == R_386_TLS_GD)
2441 {
2442 if (tls_type == GOT_TLS_IE_POS)
2443 r_type = R_386_TLS_GOTIE;
2444 else if (tls_type & GOT_TLS_IE)
2445 r_type = R_386_TLS_IE_32;
2446 }
13ae64f3
JJ		 2447
2448 if (r_type == R_386_TLS_LE_32)
2449 {
82e51918 2450 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2451 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2452 {
2453 unsigned int val, type;
2454 bfd_vma roff;
2455
2456 /* GD->LE transition. */
2457 BFD_ASSERT (rel->r_offset >= 2);
2458 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2459 BFD_ASSERT (type == 0x8d || type == 0x04);
eea6121a 2460 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
13ae64f3
JJ		 2461 BFD_ASSERT (bfd_get_8 (input_bfd,
2462 contents + rel->r_offset + 4)
2463 == 0xe8);
2464 BFD_ASSERT (rel + 1 < relend);
2465 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2466 roff = rel->r_offset + 5;
2467 val = bfd_get_8 (input_bfd,
2468 contents + rel->r_offset - 1);
2469 if (type == 0x04)
2470 {
2471 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2472 Change it into:
2473 movl %gs:0, %eax; subl $foo@tpoff, %eax
2474 (6 byte form of subl). */
2475 BFD_ASSERT (rel->r_offset >= 3);
2476 BFD_ASSERT (bfd_get_8 (input_bfd,
2477 contents + rel->r_offset - 3)
2478 == 0x8d);
2479 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2480 memcpy (contents + rel->r_offset - 3,
2481 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2482 }
2483 else
2484 {
2485 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
eea6121a 2486 if (rel->r_offset + 10 <= input_section->size
13ae64f3
JJ		 2487 && bfd_get_8 (input_bfd,
2488 contents + rel->r_offset + 9) == 0x90)
2489 {
2490 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2491 Change it into:
2492 movl %gs:0, %eax; subl $foo@tpoff, %eax
2493 (6 byte form of subl). */
2494 memcpy (contents + rel->r_offset - 2,
2495 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2496 roff = rel->r_offset + 6;
2497 }
2498 else
2499 {
2500 /* leal foo(%reg), %eax; call ___tls_get_addr
2501 Change it into:
2502 movl %gs:0, %eax; subl $foo@tpoff, %eax
2503 (5 byte form of subl). */
2504 memcpy (contents + rel->r_offset - 2,
2505 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2506 }
2507 }
2508 bfd_put_32 (output_bfd, tpoff (info, relocation),
2509 contents + roff);
2510 /* Skip R_386_PLT32. */
2511 rel++;
2512 continue;
2513 }
37e55690 2514 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3
JJ		 2515 {
2516 unsigned int val, type;
2517
2518 /* IE->LE transition:
37e55690
JJ		 2519 Originally it can be one of:
2520 movl foo, %eax
2521 movl foo, %reg
2522 addl foo, %reg
2523 We change it into:
2524 movl $foo, %eax
2525 movl $foo, %reg
2526 addl $foo, %reg. */
2527 BFD_ASSERT (rel->r_offset >= 1);
2528 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
eea6121a 2529 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
37e55690
JJ		 2530 if (val == 0xa1)
2531 {
2532 /* movl foo, %eax. */
55fd94b0
AM		 2533 bfd_put_8 (output_bfd, 0xb8,
2534 contents + rel->r_offset - 1);
37e55690 2535 }
299bf759 2536 else
37e55690 2537 {
299bf759 2538 BFD_ASSERT (rel->r_offset >= 2);
55fd94b0
AM		 2539 type = bfd_get_8 (input_bfd,
2540 contents + rel->r_offset - 2);
299bf759 2541 switch (type)
26e41594 2542 {
299bf759
L		 2543 case 0x8b:
2544 /* movl */
2545 BFD_ASSERT ((val & 0xc7) == 0x05);
2546 bfd_put_8 (output_bfd, 0xc7,
2547 contents + rel->r_offset - 2);
2548 bfd_put_8 (output_bfd,
2549 0xc0 | ((val >> 3) & 7),
2550 contents + rel->r_offset - 1);
2551 break;
2552 case 0x03:
2553 /* addl */
2554 BFD_ASSERT ((val & 0xc7) == 0x05);
2555 bfd_put_8 (output_bfd, 0x81,
2556 contents + rel->r_offset - 2);
2557 bfd_put_8 (output_bfd,
2558 0xc0 | ((val >> 3) & 7),
2559 contents + rel->r_offset - 1);
2560 break;
2561 default:
2562 BFD_FAIL ();
2563 break;
26e41594 2564 }
37e55690 2565 }
37e55690
JJ		 2566 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2567 contents + rel->r_offset);
2568 continue;
2569 }
2570 else
2571 {
2572 unsigned int val, type;
2573
2574 /* {IE_32,GOTIE}->LE transition:
2575 Originally it can be one of:
13ae64f3 2576 subl foo(%reg1), %reg2
13ae64f3 2577 movl foo(%reg1), %reg2
37e55690 2578 addl foo(%reg1), %reg2
13ae64f3
JJ		 2579 We change it into:
2580 subl $foo, %reg2
37e55690
JJ		 2581 movl $foo, %reg2 (6 byte form)
2582 addl $foo, %reg2. */
13ae64f3
JJ		 2583 BFD_ASSERT (rel->r_offset >= 2);
2584 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2585 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
eea6121a 2586 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
37e55690 2587 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
13ae64f3
JJ		 2588 if (type == 0x8b)
2589 {
2590 /* movl */
13ae64f3
JJ		 2591 bfd_put_8 (output_bfd, 0xc7,
2592 contents + rel->r_offset - 2);
2593 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2594 contents + rel->r_offset - 1);
2595 }
2596 else if (type == 0x2b)
2597 {
2598 /* subl */
13ae64f3
JJ		 2599 bfd_put_8 (output_bfd, 0x81,
2600 contents + rel->r_offset - 2);
2601 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2602 contents + rel->r_offset - 1);
2603 }
37e55690
JJ		 2604 else if (type == 0x03)
2605 {
2606 /* addl */
2607 bfd_put_8 (output_bfd, 0x81,
2608 contents + rel->r_offset - 2);
2609 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2610 contents + rel->r_offset - 1);
2611 }
13ae64f3
JJ		 2612 else
2613 BFD_FAIL ();
37e55690
JJ		 2614 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2615 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2616 contents + rel->r_offset);
2617 else
2618 bfd_put_32 (output_bfd, tpoff (info, relocation),
2619 contents + rel->r_offset);
13ae64f3
JJ		 2620 continue;
2621 }
2622 }
2623
2624 if (htab->sgot == NULL)
2625 abort ();
2626
2627 if (h != NULL)
2628 off = h->got.offset;
2629 else
2630 {
2631 if (local_got_offsets == NULL)
2632 abort ();
2633
2634 off = local_got_offsets[r_symndx];
2635 }
2636
2637 if ((off & 1) != 0)
2638 off &= ~1;
26e41594 2639 else
13ae64f3 2640 {
947216bf
AM		 2641 Elf_Internal_Rela outrel;
2642 bfd_byte *loc;
13ae64f3
JJ		 2643 int dr_type, indx;
2644
2645 if (htab->srelgot == NULL)
2646 abort ();
2647
2648 outrel.r_offset = (htab->sgot->output_section->vma
2649 + htab->sgot->output_offset + off);
2650
13ae64f3
JJ		 2651 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2652 if (r_type == R_386_TLS_GD)
2653 dr_type = R_386_TLS_DTPMOD32;
37e55690
JJ		 2654 else if (tls_type == GOT_TLS_IE_POS)
2655 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 2656 else
2657 dr_type = R_386_TLS_TPOFF32;
37e55690
JJ		 2658 if (dr_type == R_386_TLS_TPOFF && indx == 0)
2659 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2660 htab->sgot->contents + off);
2661 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 2662 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e
JJ		 2663 htab->sgot->contents + off);
2664 else
2665 bfd_put_32 (output_bfd, 0,
2666 htab->sgot->contents + off);
13ae64f3 2667 outrel.r_info = ELF32_R_INFO (indx, dr_type);
947216bf
AM		 2668 loc = htab->srelgot->contents;
2669 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2670 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2671
2672 if (r_type == R_386_TLS_GD)
2673 {
2674 if (indx == 0)
2675 {
82e51918 2676 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2677 bfd_put_32 (output_bfd,
2678 relocation - dtpoff_base (info),
2679 htab->sgot->contents + off + 4);
2680 }
2681 else
2682 {
2683 bfd_put_32 (output_bfd, 0,
2684 htab->sgot->contents + off + 4);
2685 outrel.r_info = ELF32_R_INFO (indx,
2686 R_386_TLS_DTPOFF32);
2687 outrel.r_offset += 4;
2688 htab->srelgot->reloc_count++;
947216bf
AM		 2689 loc += sizeof (Elf32_External_Rel);
2690 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 2691 }
2692 }
37e55690
JJ		 2693 else if (tls_type == GOT_TLS_IE_BOTH)
2694 {
2695 bfd_put_32 (output_bfd,
2696 indx == 0 ? relocation - dtpoff_base (info) : 0,
2697 htab->sgot->contents + off + 4);
2698 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2699 outrel.r_offset += 4;
2700 htab->srelgot->reloc_count++;
947216bf 2701 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 2702 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2703 }
13ae64f3
JJ		 2704
2705 if (h != NULL)
2706 h->got.offset |= 1;
2707 else
2708 local_got_offsets[r_symndx] |= 1;
2709 }
2710
2711 if (off >= (bfd_vma) -2)
2712 abort ();
2713 if (r_type == ELF32_R_TYPE (rel->r_info))
2714 {
8c37241b
JJ		 2715 bfd_vma g_o_t = htab->sgotplt->output_section->vma
2716 + htab->sgotplt->output_offset;
2717 relocation = htab->sgot->output_section->vma
2718 + htab->sgot->output_offset + off - g_o_t;
37e55690
JJ		 2719 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2720 && tls_type == GOT_TLS_IE_BOTH)
2721 relocation += 4;
2722 if (r_type == R_386_TLS_IE)
8c37241b 2723 relocation += g_o_t;
b34976b6 2724 unresolved_reloc = FALSE;
13ae64f3
JJ		 2725 }
2726 else
2727 {
2728 unsigned int val, type;
2729 bfd_vma roff;
2730
2731 /* GD->IE transition. */
2732 BFD_ASSERT (rel->r_offset >= 2);
2733 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2734 BFD_ASSERT (type == 0x8d || type == 0x04);
eea6121a 2735 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
13ae64f3
JJ		 2736 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2737 == 0xe8);
2738 BFD_ASSERT (rel + 1 < relend);
2739 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2740 roff = rel->r_offset - 3;
2741 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2742 if (type == 0x04)
2743 {
2744 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2745 Change it into:
2746 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2747 BFD_ASSERT (rel->r_offset >= 3);
2748 BFD_ASSERT (bfd_get_8 (input_bfd,
2749 contents + rel->r_offset - 3)
2750 == 0x8d);
2751 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2752 val >>= 3;
2753 }
2754 else
2755 {
2756 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2757 Change it into:
2758 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
eea6121a 2759 BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
13ae64f3
JJ		 2760 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2761 BFD_ASSERT (bfd_get_8 (input_bfd,
2762 contents + rel->r_offset + 9)
2763 == 0x90);
2764 roff = rel->r_offset - 2;
2765 }
2766 memcpy (contents + roff,
2767 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2768 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 2769 /* If foo is used only with foo@gotntpoff(%reg) and
2770 foo@indntpoff, but not with foo@gottpoff(%reg), change
2771 subl $foo@gottpoff(%reg), %eax
2772 into:
2773 addl $foo@gotntpoff(%reg), %eax. */
2774 if (r_type == R_386_TLS_GOTIE)
2775 {
2776 contents[roff + 6] = 0x03;
2777 if (tls_type == GOT_TLS_IE_BOTH)
2778 off += 4;
2779 }
8c37241b
JJ		 2780 bfd_put_32 (output_bfd,
2781 htab->sgot->output_section->vma
2782 + htab->sgot->output_offset + off
2783 - htab->sgotplt->output_section->vma
2784 - htab->sgotplt->output_offset,
13ae64f3
JJ		 2785 contents + roff + 8);
2786 /* Skip R_386_PLT32. */
2787 rel++;
2788 continue;
2789 }
2790 break;
2791
2792 case R_386_TLS_LDM:
2793 if (! info->shared)
2794 {
2795 unsigned int val;
2796
2797 /* LD->LE transition:
2798 Ensure it is:
2799 leal foo(%reg), %eax; call ___tls_get_addr.
2800 We change it into:
2801 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2802 BFD_ASSERT (rel->r_offset >= 2);
2803 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2804 == 0x8d);
2805 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2806 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
eea6121a 2807 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
13ae64f3
JJ		 2808 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2809 == 0xe8);
2810 BFD_ASSERT (rel + 1 < relend);
2811 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2812 memcpy (contents + rel->r_offset - 2,
2813 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2814 /* Skip R_386_PLT32. */
2815 rel++;
2816 continue;
2817 }
2818
2819 if (htab->sgot == NULL)
2820 abort ();
2821
2822 off = htab->tls_ldm_got.offset;
2823 if (off & 1)
2824 off &= ~1;
2825 else
2826 {
947216bf
AM		 2827 Elf_Internal_Rela outrel;
2828 bfd_byte *loc;
13ae64f3
JJ		 2829
2830 if (htab->srelgot == NULL)
2831 abort ();
2832
2833 outrel.r_offset = (htab->sgot->output_section->vma
2834 + htab->sgot->output_offset + off);
2835
2836 bfd_put_32 (output_bfd, 0,
2837 htab->sgot->contents + off);
2838 bfd_put_32 (output_bfd, 0,
2839 htab->sgot->contents + off + 4);
2840 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
947216bf
AM		 2841 loc = htab->srelgot->contents;
2842 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2843 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2844 htab->tls_ldm_got.offset |= 1;
2845 }
8c37241b
JJ		 2846 relocation = htab->sgot->output_section->vma
2847 + htab->sgot->output_offset + off
2848 - htab->sgotplt->output_section->vma
2849 - htab->sgotplt->output_offset;
b34976b6 2850 unresolved_reloc = FALSE;
13ae64f3
JJ		 2851 break;
2852
2853 case R_386_TLS_LDO_32:
a45bb67d 2854 if (info->shared || (input_section->flags & SEC_CODE) == 0)
13ae64f3
JJ		 2855 relocation -= dtpoff_base (info);
2856 else
2857 /* When converting LDO to LE, we must negate. */
2858 relocation = -tpoff (info, relocation);
2859 break;
2860
2861 case R_386_TLS_LE_32:
13ae64f3 2862 case R_386_TLS_LE:
37e55690
JJ		 2863 if (info->shared)
2864 {
947216bf 2865 Elf_Internal_Rela outrel;
37e55690 2866 asection *sreloc;
947216bf 2867 bfd_byte *loc;
37e55690
JJ		 2868 int indx;
2869
2870 outrel.r_offset = rel->r_offset
2871 + input_section->output_section->vma
2872 + input_section->output_offset;
2873 if (h != NULL && h->dynindx != -1)
2874 indx = h->dynindx;
2875 else
2876 indx = 0;
2877 if (r_type == R_386_TLS_LE_32)
2878 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2879 else
2880 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2881 sreloc = elf_section_data (input_section)->sreloc;
2882 if (sreloc == NULL)
2883 abort ();
947216bf
AM		 2884 loc = sreloc->contents;
2885 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 2886 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2887 if (indx)
2888 continue;
2889 else if (r_type == R_386_TLS_LE_32)
2890 relocation = dtpoff_base (info) - relocation;
2891 else
2892 relocation -= dtpoff_base (info);
2893 }
2894 else if (r_type == R_386_TLS_LE_32)
2895 relocation = tpoff (info, relocation);
2896 else
2897 relocation = -tpoff (info, relocation);
13ae64f3
JJ		 2898 break;
2899
252b5132
RH		 2900 default:
2901 break;
2902 }
2903
239e1f3a
AM		 2904 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2905 because such sections are not SEC_ALLOC and thus ld.so will
2906 not process them. */
8c694914 2907 if (unresolved_reloc
239e1f3a 2908 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 2909 && h->def_dynamic))
6a30718d
JJ		 2910 {
2911 (*_bfd_error_handler)
d003868e
AM		 2912 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2913 input_bfd,
2914 input_section,
6a30718d
JJ		 2915 (long) rel->r_offset,
2916 h->root.root.string);
b34976b6 2917 return FALSE;
6a30718d 2918 }
83be169b 2919
252b5132
RH		 2920 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2921 contents, rel->r_offset,
55fd94b0 2922 relocation, 0);
252b5132 2923
cf5c0c5b 2924 if (r != bfd_reloc_ok)
252b5132 2925 {
cf5c0c5b 2926 const char *name;
ffb2e45b 2927
cf5c0c5b
AM		 2928 if (h != NULL)
2929 name = h->root.root.string;
2930 else
2931 {
2932 name = bfd_elf_string_from_elf_section (input_bfd,
2933 symtab_hdr->sh_link,
2934 sym->st_name);
2935 if (name == NULL)
b34976b6 2936 return FALSE;
cf5c0c5b
AM		 2937 if (*name == '\0')
2938 name = bfd_section_name (input_bfd, sec);
2939 }
ffb2e45b 2940
cf5c0c5b
AM		 2941 if (r == bfd_reloc_overflow)
2942 {
cf5c0c5b 2943 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 2944 (info, (h ? &h->root : NULL), name, howto->name,
2945 (bfd_vma) 0, input_bfd, input_section,
2946 rel->r_offset)))
b34976b6 2947 return FALSE;
cf5c0c5b
AM		 2948 }
2949 else
2950 {
2951 (*_bfd_error_handler)
d003868e
AM		 2952 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2953 input_bfd, input_section,
cf5c0c5b 2954 (long) rel->r_offset, name, (int) r);
b34976b6 2955 return FALSE;
cf5c0c5b 2956 }
252b5132
RH		 2957 }
2958 }
2959
b34976b6 2960 return TRUE;
252b5132
RH		 2961}
2962
2963/* Finish up dynamic symbol handling. We set the contents of various
2964 dynamic sections here. */
2965
b34976b6 2966static bfd_boolean
55fd94b0
AM		 2967elf_i386_finish_dynamic_symbol (bfd *output_bfd,
2968 struct bfd_link_info *info,
2969 struct elf_link_hash_entry *h,
2970 Elf_Internal_Sym *sym)
252b5132 2971{
6725bdbf 2972 struct elf_i386_link_hash_table *htab;
252b5132 2973
6725bdbf 2974 htab = elf_i386_hash_table (info);
252b5132
RH		 2975
2976 if (h->plt.offset != (bfd_vma) -1)
2977 {
252b5132
RH		 2978 bfd_vma plt_index;
2979 bfd_vma got_offset;
947216bf
AM		 2980 Elf_Internal_Rela rel;
2981 bfd_byte *loc;
252b5132
RH		 2982
2983 /* This symbol has an entry in the procedure linkage table. Set
2984 it up. */
2985
ffb2e45b
AM		 2986 if (h->dynindx == -1
2987 || htab->splt == NULL
2988 || htab->sgotplt == NULL
2989 || htab->srelplt == NULL)
2990 abort ();
252b5132
RH		 2991
2992 /* Get the index in the procedure linkage table which
2993 corresponds to this symbol. This is the index of this symbol
2994 in all the symbols for which we are making plt entries. The
2995 first entry in the procedure linkage table is reserved. */
2996 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2997
2998 /* Get the offset into the .got table of the entry that
2999 corresponds to this function. Each .got entry is 4 bytes.
3000 The first three are reserved. */
3001 got_offset = (plt_index + 3) * 4;
3002
3003 /* Fill in the entry in the procedure linkage table. */
3004 if (! info->shared)
3005 {
6725bdbf 3006 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 3007 PLT_ENTRY_SIZE);
3008 bfd_put_32 (output_bfd,
6725bdbf
AM		 3009 (htab->sgotplt->output_section->vma
3010 + htab->sgotplt->output_offset
252b5132 3011 + got_offset),
6725bdbf 3012 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3013 }
3014 else
3015 {
6725bdbf 3016 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 3017 PLT_ENTRY_SIZE);
3018 bfd_put_32 (output_bfd, got_offset,
6725bdbf 3019 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3020 }
3021
3022 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 3023 htab->splt->contents + h->plt.offset + 7);
252b5132 3024 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 3025 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 3026
3027 /* Fill in the entry in the global offset table. */
3028 bfd_put_32 (output_bfd,
6725bdbf
AM		 3029 (htab->splt->output_section->vma
3030 + htab->splt->output_offset
252b5132
RH		 3031 + h->plt.offset
3032 + 6),
6725bdbf 3033 htab->sgotplt->contents + got_offset);
252b5132
RH		 3034
3035 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 3036 rel.r_offset = (htab->sgotplt->output_section->vma
3037 + htab->sgotplt->output_offset
252b5132
RH		 3038 + got_offset);
3039 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
947216bf 3040 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 3041 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132 3042
f5385ebf 3043 if (!h->def_regular)
252b5132
RH		 3044 {
3045 /* Mark the symbol as undefined, rather than as defined in
c6585bbb
JJ		 3046 the .plt section. Leave the value if there were any
3047 relocations where pointer equality matters (this is a clue
51b64d56
AM		 3048 for the dynamic linker, to make function pointer
3049 comparisons work between an application and shared
c6585bbb
JJ		 3050 library), otherwise set it to zero. If a function is only
3051 called from a binary, there is no need to slow down
3052 shared libraries because of that. */
252b5132 3053 sym->st_shndx = SHN_UNDEF;
f5385ebf 3054 if (!h->pointer_equality_needed)
c6585bbb 3055 sym->st_value = 0;
252b5132
RH		 3056 }
3057 }
3058
13ae64f3
JJ		 3059 if (h->got.offset != (bfd_vma) -1
3060 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
37e55690 3061 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 3062 {
947216bf
AM		 3063 Elf_Internal_Rela rel;
3064 bfd_byte *loc;
252b5132
RH		 3065
3066 /* This symbol has an entry in the global offset table. Set it
3067 up. */
3068
ffb2e45b
AM		 3069 if (htab->sgot == NULL || htab->srelgot == NULL)
3070 abort ();
252b5132 3071
6725bdbf
AM		 3072 rel.r_offset = (htab->sgot->output_section->vma
3073 + htab->sgot->output_offset
dc810e39 3074 + (h->got.offset & ~(bfd_vma) 1));
252b5132 3075
dd5724d5
AM		 3076 /* If this is a static link, or it is a -Bsymbolic link and the
3077 symbol is defined locally or was forced to be local because
3078 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 3079 The entry in the global offset table will already have been
3080 initialized in the relocate_section function. */
6725bdbf 3081 if (info->shared
586119b3 3082 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 3083 {
6725bdbf 3084 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 3085 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3086 }
252b5132
RH		 3087 else
3088 {
dd5724d5 3089 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 3090 bfd_put_32 (output_bfd, (bfd_vma) 0,
3091 htab->sgot->contents + h->got.offset);
252b5132
RH		 3092 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3093 }
3094
947216bf
AM		 3095 loc = htab->srelgot->contents;
3096 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3097 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3098 }
3099
f5385ebf 3100 if (h->needs_copy)
252b5132 3101 {
947216bf
AM		 3102 Elf_Internal_Rela rel;
3103 bfd_byte *loc;
252b5132
RH		 3104
3105 /* This symbol needs a copy reloc. Set it up. */
3106
ffb2e45b
AM		 3107 if (h->dynindx == -1
3108 || (h->root.type != bfd_link_hash_defined
3109 && h->root.type != bfd_link_hash_defweak)
3110 || htab->srelbss == NULL)
3111 abort ();
252b5132
RH		 3112
3113 rel.r_offset = (h->root.u.def.value
3114 + h->root.u.def.section->output_section->vma
3115 + h->root.u.def.section->output_offset);
3116 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
947216bf
AM		 3117 loc = htab->srelbss->contents;
3118 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3119 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3120 }
3121
3122 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3123 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3124 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3125 sym->st_shndx = SHN_ABS;
3126
b34976b6 3127 return TRUE;
252b5132
RH		 3128}
3129
38701953
AM		 3130/* Used to decide how to sort relocs in an optimal manner for the
3131 dynamic linker, before writing them out. */
3132
3133static enum elf_reloc_type_class
55fd94b0 3134elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
38701953 3135{
55fd94b0 3136 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 3137 {
3138 case R_386_RELATIVE:
3139 return reloc_class_relative;
3140 case R_386_JUMP_SLOT:
3141 return reloc_class_plt;
3142 case R_386_COPY:
3143 return reloc_class_copy;
3144 default:
3145 return reloc_class_normal;
3146 }
3147}
3148
252b5132
RH		 3149/* Finish up the dynamic sections. */
3150
b34976b6 3151static bfd_boolean
55fd94b0
AM		 3152elf_i386_finish_dynamic_sections (bfd *output_bfd,
3153 struct bfd_link_info *info)
252b5132 3154{
6725bdbf 3155 struct elf_i386_link_hash_table *htab;
252b5132 3156 bfd *dynobj;
252b5132
RH		 3157 asection *sdyn;
3158
6725bdbf 3159 htab = elf_i386_hash_table (info);
ebe50bae 3160 dynobj = htab->elf.dynobj;
252b5132
RH		 3161 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3162
ebe50bae 3163 if (htab->elf.dynamic_sections_created)
252b5132 3164 {
252b5132
RH		 3165 Elf32_External_Dyn *dyncon, *dynconend;
3166
ffb2e45b
AM		 3167 if (sdyn == NULL || htab->sgot == NULL)
3168 abort ();
252b5132
RH		 3169
3170 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 3171 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 3172 for (; dyncon < dynconend; dyncon++)
3173 {
3174 Elf_Internal_Dyn dyn;
51b64d56 3175 asection *s;
252b5132
RH		 3176
3177 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3178
3179 switch (dyn.d_tag)
3180 {
3181 default:
0ac8d2ca 3182 continue;
252b5132
RH		 3183
3184 case DT_PLTGOT:
8c37241b
JJ		 3185 s = htab->sgotplt;
3186 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 3187 break;
3188
252b5132 3189 case DT_JMPREL:
6348e046
AM		 3190 s = htab->srelplt;
3191 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 3192 break;
3193
3194 case DT_PLTRELSZ:
6348e046 3195 s = htab->srelplt;
eea6121a 3196 dyn.d_un.d_val = s->size;
252b5132
RH		 3197 break;
3198
3199 case DT_RELSZ:
3200 /* My reading of the SVR4 ABI indicates that the
3201 procedure linkage table relocs (DT_JMPREL) should be
3202 included in the overall relocs (DT_REL). This is
3203 what Solaris does. However, UnixWare can not handle
3204 that case. Therefore, we override the DT_RELSZ entry
6348e046
AM		 3205 here to make it not include the JMPREL relocs. */
3206 s = htab->srelplt;
3207 if (s == NULL)
3208 continue;
eea6121a 3209 dyn.d_un.d_val -= s->size;
6348e046
AM		 3210 break;
3211
3212 case DT_REL:
3213 /* We may not be using the standard ELF linker script.
3214 If .rel.plt is the first .rel section, we adjust
3215 DT_REL to not include it. */
3216 s = htab->srelplt;
3217 if (s == NULL)
3218 continue;
3219 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3220 continue;
eea6121a 3221 dyn.d_un.d_ptr += s->size;
252b5132
RH		 3222 break;
3223 }
0ac8d2ca
AM		 3224
3225 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3226 }
3227
3228 /* Fill in the first entry in the procedure linkage table. */
eea6121a 3229 if (htab->splt && htab->splt->size > 0)
252b5132
RH		 3230 {
3231 if (info->shared)
6725bdbf
AM		 3232 memcpy (htab->splt->contents,
3233 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3234 else
3235 {
6725bdbf
AM		 3236 memcpy (htab->splt->contents,
3237 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3238 bfd_put_32 (output_bfd,
6725bdbf
AM		 3239 (htab->sgotplt->output_section->vma
3240 + htab->sgotplt->output_offset
3241 + 4),
3242 htab->splt->contents + 2);
252b5132 3243 bfd_put_32 (output_bfd,
6725bdbf
AM		 3244 (htab->sgotplt->output_section->vma
3245 + htab->sgotplt->output_offset
3246 + 8),
3247 htab->splt->contents + 8);
252b5132
RH		 3248 }
3249
3250 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3251 really seem like the right value. */
6725bdbf
AM		 3252 elf_section_data (htab->splt->output_section)
3253 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3254 }
3255 }
3256
12d0ee4a 3257 if (htab->sgotplt)
252b5132 3258 {
12d0ee4a 3259 /* Fill in the first three entries in the global offset table. */
eea6121a 3260 if (htab->sgotplt->size > 0)
12d0ee4a
AM		 3261 {
3262 bfd_put_32 (output_bfd,
55fd94b0 3263 (sdyn == NULL ? 0
12d0ee4a
AM		 3264 : sdyn->output_section->vma + sdyn->output_offset),
3265 htab->sgotplt->contents);
55fd94b0
AM		 3266 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
3267 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
12d0ee4a 3268 }
252b5132 3269
12d0ee4a
AM		 3270 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3271 }
8c37241b 3272
eea6121a 3273 if (htab->sgot && htab->sgot->size > 0)
8c37241b
JJ		 3274 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3275
b34976b6 3276 return TRUE;
252b5132
RH		 3277}
3278
4c45e5c9
JJ		 3279/* Return address for Ith PLT stub in section PLT, for relocation REL
3280 or (bfd_vma) -1 if it should not be included. */
3281
3282static bfd_vma
3283elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
3284 const arelent *rel ATTRIBUTE_UNUSED)
3285{
3286 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3287}
3288
3289
252b5132
RH		 3290#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3291#define TARGET_LITTLE_NAME "elf32-i386"
3292#define ELF_ARCH bfd_arch_i386
3293#define ELF_MACHINE_CODE EM_386
3294#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3295
3296#define elf_backend_can_gc_sections 1
51b64d56 3297#define elf_backend_can_refcount 1
252b5132
RH		 3298#define elf_backend_want_got_plt 1
3299#define elf_backend_plt_readonly 1
3300#define elf_backend_want_plt_sym 0
3301#define elf_backend_got_header_size 12
252b5132 3302
8c29f035
AM		 3303/* Support RELA for objdump of prelink objects. */
3304#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 3305#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3306
13ae64f3 3307#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 3308
dd5724d5
AM		 3309#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3310#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3311#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3312
3313#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3314#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3315#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3316#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3317#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3318#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3319#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3320#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3321#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3322#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3323#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3324#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3325#define elf_backend_relocate_section elf_i386_relocate_section
3326#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
4c45e5c9 3327#define elf_backend_plt_sym_val elf_i386_plt_sym_val
dd5724d5 3328
252b5132 3329#include "elf32-target.h"
2bc3c89a
AM		 3330
3331/* FreeBSD support. */
3332
3333#undef TARGET_LITTLE_SYM
3334#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3335#undef TARGET_LITTLE_NAME
3336#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3337
3338/* The kernel recognizes executables as valid only if they carry a
3339 "FreeBSD" label in the ELF header. So we put this label on all
3340 executables and (for simplicity) also all other object files. */
3341
2bc3c89a 3342static void
55fd94b0
AM		 3343elf_i386_post_process_headers (bfd *abfd,
3344 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2bc3c89a
AM		 3345{
3346 Elf_Internal_Ehdr *i_ehdrp;
3347
3348 i_ehdrp = elf_elfheader (abfd);
3349
3350 /* Put an ABI label supported by FreeBSD >= 4.1. */
3351 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3352#ifdef OLD_FREEBSD_ABI_LABEL
3353 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3354 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 3355#endif
2bc3c89a
AM		 3356}
3357
3358#undef elf_backend_post_process_headers
571fe01f
NC		 3359#define elf_backend_post_process_headers elf_i386_post_process_headers
3360#undef elf32_bed
3361#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a
AM		 3362
3363#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.473812 seconds and 4 git commands to generate.