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