projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix handling of R_ARM_THM_PC11
[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{
1965 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1966 return elf_hash_table (info)->tls_segment->start;
1967}
1968
1969/* Return the relocation value for @tpoff relocation
1970 if STT_TLS virtual address is ADDRESS. */
1971
1972static bfd_vma
1973tpoff (info, address)
1974 struct bfd_link_info *info;
1975 bfd_vma address;
1976{
1977 struct elf_link_tls_segment *tls_segment
1978 = elf_hash_table (info)->tls_segment;
1979
1980 BFD_ASSERT (tls_segment != NULL);
1981 return (align_power (tls_segment->size, tls_segment->align)
1982 + tls_segment->start - address);
1983}
1984
252b5132
RH		 1985/* Relocate an i386 ELF section. */
1986
1987static boolean
1988elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1989 contents, relocs, local_syms, local_sections)
1990 bfd *output_bfd;
1991 struct bfd_link_info *info;
1992 bfd *input_bfd;
1993 asection *input_section;
1994 bfd_byte *contents;
1995 Elf_Internal_Rela *relocs;
1996 Elf_Internal_Sym *local_syms;
1997 asection **local_sections;
1998{
6725bdbf 1999 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2000 Elf_Internal_Shdr *symtab_hdr;
2001 struct elf_link_hash_entry **sym_hashes;
2002 bfd_vma *local_got_offsets;
252b5132
RH		 2003 Elf_Internal_Rela *rel;
2004 Elf_Internal_Rela *relend;
2005
6725bdbf 2006 htab = elf_i386_hash_table (info);
252b5132
RH		 2007 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2008 sym_hashes = elf_sym_hashes (input_bfd);
2009 local_got_offsets = elf_local_got_offsets (input_bfd);
2010
252b5132
RH		 2011 rel = relocs;
2012 relend = relocs + input_section->reloc_count;
2013 for (; rel < relend; rel++)
2014 {
13ae64f3 2015 unsigned int r_type;
252b5132
RH		 2016 reloc_howto_type *howto;
2017 unsigned long r_symndx;
2018 struct elf_link_hash_entry *h;
2019 Elf_Internal_Sym *sym;
2020 asection *sec;
ffb2e45b 2021 bfd_vma off;
252b5132 2022 bfd_vma relocation;
83be169b 2023 boolean unresolved_reloc;
252b5132 2024 bfd_reloc_status_type r;
1b452ec6 2025 unsigned int indx;
13ae64f3 2026 int tls_type;
252b5132
RH		 2027
2028 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 2029 if (r_type == (int) R_386_GNU_VTINHERIT
2030 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 2031 continue;
dc47f327 2032
1b452ec6 2033 if ((indx = (unsigned) r_type) >= R_386_standard
13ae64f3
JJ		 2034 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2035 >= R_386_ext - R_386_standard)
2036 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2037 >= R_386_tls - R_386_ext))
252b5132
RH		 2038 {
2039 bfd_set_error (bfd_error_bad_value);
2040 return false;
2041 }
1b452ec6 2042 howto = elf_howto_table + indx;
252b5132
RH		 2043
2044 r_symndx = ELF32_R_SYM (rel->r_info);
2045
2046 if (info->relocateable)
2047 {
4a335f3d 2048 bfd_vma val;
4a335f3d
AM		 2049 bfd_byte *where;
2050
0ac8d2ca 2051 /* This is a relocatable link. We don't have to change
252b5132
RH		 2052 anything, unless the reloc is against a section symbol,
2053 in which case we have to adjust according to where the
2054 section symbol winds up in the output section. */
4a335f3d
AM		 2055 if (r_symndx >= symtab_hdr->sh_info)
2056 continue;
2057
2058 sym = local_syms + r_symndx;
2059 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2060 continue;
2061
2062 sec = local_sections[r_symndx];
2063 val = sec->output_offset;
2064 if (val == 0)
2065 continue;
2066
2067 where = contents + rel->r_offset;
2068 switch (howto->size)
252b5132 2069 {
16a10388 2070 /* FIXME: overflow checks. */
4a335f3d 2071 case 0:
16a10388 2072 val += bfd_get_8 (input_bfd, where);
4a335f3d 2073 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2074 break;
2075 case 1:
16a10388 2076 val += bfd_get_16 (input_bfd, where);
4a335f3d 2077 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2078 break;
2079 case 2:
2080 val += bfd_get_32 (input_bfd, where);
2081 bfd_put_32 (input_bfd, val, where);
2082 break;
2083 default:
2084 abort ();
252b5132 2085 }
252b5132
RH		 2086 continue;
2087 }
2088
2089 /* This is a final link. */
2090 h = NULL;
2091 sym = NULL;
2092 sec = NULL;
83be169b 2093 unresolved_reloc = false;
252b5132
RH		 2094 if (r_symndx < symtab_hdr->sh_info)
2095 {
2096 sym = local_syms + r_symndx;
2097 sec = local_sections[r_symndx];
2098 relocation = (sec->output_section->vma
2099 + sec->output_offset
2100 + sym->st_value);
f8df10f4
JJ		 2101 if ((sec->flags & SEC_MERGE)
2102 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2103 {
2104 asection *msec;
2105 bfd_vma addend;
4a335f3d 2106 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2107
4a335f3d 2108 switch (howto->size)
f8df10f4 2109 {
4a335f3d
AM		 2110 case 0:
2111 addend = bfd_get_8 (input_bfd, where);
2112 if (howto->pc_relative)
2113 {
2114 addend = (addend ^ 0x80) - 0x80;
2115 addend += 1;
2116 }
2117 break;
2118 case 1:
2119 addend = bfd_get_16 (input_bfd, where);
2120 if (howto->pc_relative)
2121 {
2122 addend = (addend ^ 0x8000) - 0x8000;
2123 addend += 2;
2124 }
2125 break;
2126 case 2:
2127 addend = bfd_get_32 (input_bfd, where);
2128 if (howto->pc_relative)
2129 {
2130 addend = (addend ^ 0x80000000) - 0x80000000;
2131 addend += 4;
2132 }
2133 break;
2134 default:
2135 abort ();
f8df10f4
JJ		 2136 }
2137
f8df10f4 2138 msec = sec;
4a335f3d
AM		 2139 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2140 addend -= relocation;
f8df10f4 2141 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2142
2143 switch (howto->size)
2144 {
2145 case 0:
16a10388 2146 /* FIXME: overflow checks. */
4a335f3d
AM		 2147 if (howto->pc_relative)
2148 addend -= 1;
2149 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2150 break;
2151 case 1:
2152 if (howto->pc_relative)
2153 addend -= 2;
2154 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2155 break;
2156 case 2:
2157 if (howto->pc_relative)
2158 addend -= 4;
2159 bfd_put_32 (input_bfd, addend, where);
2160 break;
2161 }
f8df10f4 2162 }
252b5132
RH		 2163 }
2164 else
2165 {
2166 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2167 while (h->root.type == bfd_link_hash_indirect
2168 || h->root.type == bfd_link_hash_warning)
2169 h = (struct elf_link_hash_entry *) h->root.u.i.link;
ffb2e45b 2170
6725bdbf 2171 relocation = 0;
252b5132
RH		 2172 if (h->root.type == bfd_link_hash_defined
2173 || h->root.type == bfd_link_hash_defweak)
2174 {
2175 sec = h->root.u.def.section;
83be169b
AM		 2176 if (sec->output_section == NULL)
2177 /* Set a flag that will be cleared later if we find a
2178 relocation value for this symbol. output_section
2179 is typically NULL for symbols satisfied by a shared
2180 library. */
2181 unresolved_reloc = true;
252b5132
RH		 2182 else
2183 relocation = (h->root.u.def.value
2184 + sec->output_section->vma
2185 + sec->output_offset);
2186 }
2187 else if (h->root.type == bfd_link_hash_undefweak)
6725bdbf 2188 ;
671bae9c
NC		 2189 else if (info->shared
2190 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730
L		 2191 && !info->no_undefined
2192 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
6725bdbf 2193 ;
252b5132
RH		 2194 else
2195 {
2196 if (! ((*info->callbacks->undefined_symbol)
2197 (info, h->root.root.string, input_bfd,
5cc7c785 2198 input_section, rel->r_offset,
3a27a730
L		 2199 (!info->shared || info->no_undefined
2200 || ELF_ST_VISIBILITY (h->other)))))
252b5132 2201 return false;
252b5132
RH		 2202 }
2203 }
2204
2205 switch (r_type)
2206 {
2207 case R_386_GOT32:
2208 /* Relocation is to the entry for this symbol in the global
2209 offset table. */
ffb2e45b
AM		 2210 if (htab->sgot == NULL)
2211 abort ();
252b5132
RH		 2212
2213 if (h != NULL)
2214 {
6725bdbf 2215 boolean dyn;
252b5132
RH		 2216
2217 off = h->got.offset;
ebe50bae 2218 dyn = htab->elf.dynamic_sections_created;
6725bdbf 2219 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
252b5132 2220 || (info->shared
6725bdbf
AM		 2221 && (info->symbolic
2222 || h->dynindx == -1
2223 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
252b5132
RH		 2224 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2225 {
2226 /* This is actually a static link, or it is a
2227 -Bsymbolic link and the symbol is defined
2228 locally, or the symbol was forced to be local
2229 because of a version file. We must initialize
2230 this entry in the global offset table. Since the
2231 offset must always be a multiple of 4, we use the
2232 least significant bit to record whether we have
2233 initialized it already.
2234
2235 When doing a dynamic link, we create a .rel.got
2236 relocation entry to initialize the value. This
2237 is done in the finish_dynamic_symbol routine. */
2238 if ((off & 1) != 0)
2239 off &= ~1;
2240 else
2241 {
2242 bfd_put_32 (output_bfd, relocation,
6725bdbf 2243 htab->sgot->contents + off);
252b5132
RH		 2244 h->got.offset |= 1;
2245 }
2246 }
8c694914
AM		 2247 else
2248 unresolved_reloc = false;
252b5132
RH		 2249 }
2250 else
2251 {
ffb2e45b
AM		 2252 if (local_got_offsets == NULL)
2253 abort ();
252b5132
RH		 2254
2255 off = local_got_offsets[r_symndx];
2256
2257 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2258 the least significant bit to record whether we have
2259 already generated the necessary reloc. */
252b5132
RH		 2260 if ((off & 1) != 0)
2261 off &= ~1;
2262 else
2263 {
6725bdbf
AM		 2264 bfd_put_32 (output_bfd, relocation,
2265 htab->sgot->contents + off);
252b5132
RH		 2266
2267 if (info->shared)
2268 {
2269 asection *srelgot;
2270 Elf_Internal_Rel outrel;
0ac8d2ca 2271 Elf32_External_Rel *loc;
252b5132 2272
6725bdbf 2273 srelgot = htab->srelgot;
ffb2e45b
AM		 2274 if (srelgot == NULL)
2275 abort ();
252b5132 2276
6725bdbf
AM		 2277 outrel.r_offset = (htab->sgot->output_section->vma
2278 + htab->sgot->output_offset
252b5132
RH		 2279 + off);
2280 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
0ac8d2ca
AM		 2281 loc = (Elf32_External_Rel *) srelgot->contents;
2282 loc += srelgot->reloc_count++;
2283 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2284 }
2285
2286 local_got_offsets[r_symndx] |= 1;
2287 }
252b5132
RH		 2288 }
2289
ffb2e45b
AM		 2290 if (off >= (bfd_vma) -2)
2291 abort ();
2292
2293 relocation = htab->sgot->output_offset + off;
252b5132
RH		 2294 break;
2295
2296 case R_386_GOTOFF:
2297 /* Relocation is relative to the start of the global offset
2298 table. */
2299
252b5132
RH		 2300 /* Note that sgot->output_offset is not involved in this
2301 calculation. We always want the start of .got. If we
2302 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2303 permitted by the ABI, we might have to change this
2304 calculation. */
6725bdbf 2305 relocation -= htab->sgot->output_section->vma;
252b5132
RH		 2306 break;
2307
2308 case R_386_GOTPC:
2309 /* Use global offset table as symbol value. */
6725bdbf 2310 relocation = htab->sgot->output_section->vma;
83be169b 2311 unresolved_reloc = false;
252b5132
RH		 2312 break;
2313
2314 case R_386_PLT32:
2315 /* Relocation is to the entry for this symbol in the
2316 procedure linkage table. */
2317
dd5724d5 2318 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2319 without using the procedure linkage table. */
252b5132
RH		 2320 if (h == NULL)
2321 break;
2322
dd5724d5 2323 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2324 || htab->splt == NULL)
252b5132
RH		 2325 {
2326 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2327 happens when statically linking PIC code, or when
2328 using -Bsymbolic. */
252b5132
RH		 2329 break;
2330 }
2331
6725bdbf
AM		 2332 relocation = (htab->splt->output_section->vma
2333 + htab->splt->output_offset
252b5132 2334 + h->plt.offset);
83be169b 2335 unresolved_reloc = false;
252b5132
RH		 2336 break;
2337
2338 case R_386_32:
2339 case R_386_PC32:
ec338859
AM		 2340 /* r_symndx will be zero only for relocs against symbols
2341 from removed linkonce sections, or sections discarded by
2342 a linker script. */
2343 if (r_symndx == 0
2344 || (input_section->flags & SEC_ALLOC) == 0)
2345 break;
2346
12d0ee4a 2347 if ((info->shared
12d0ee4a
AM		 2348 && (r_type != R_386_PC32
2349 || (h != NULL
2350 && h->dynindx != -1
2351 && (! info->symbolic
2352 || (h->elf_link_hash_flags
2353 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2354 || (!info->shared
12d0ee4a
AM		 2355 && h != NULL
2356 && h->dynindx != -1
2357 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM		 2358 && (((h->elf_link_hash_flags
2359 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2360 && (h->elf_link_hash_flags
2361 & ELF_LINK_HASH_DEF_REGULAR) == 0)
28d0b90e
AM		 2362 || h->root.type == bfd_link_hash_undefweak
2363 || h->root.type == bfd_link_hash_undefined)))
252b5132
RH		 2364 {
2365 Elf_Internal_Rel outrel;
2366 boolean skip, relocate;
0c715baa
AM		 2367 asection *sreloc;
2368 Elf32_External_Rel *loc;
252b5132
RH		 2369
2370 /* When generating a shared object, these relocations
2371 are copied into the output file to be resolved at run
2372 time. */
2373
252b5132 2374 skip = false;
0bb2d96a 2375 relocate = false;
252b5132 2376
c629eae0
JJ		 2377 outrel.r_offset =
2378 _bfd_elf_section_offset (output_bfd, info, input_section,
2379 rel->r_offset);
2380 if (outrel.r_offset == (bfd_vma) -1)
2381 skip = true;
0bb2d96a
JJ		 2382 else if (outrel.r_offset == (bfd_vma) -2)
2383 skip = true, relocate = true;
252b5132
RH		 2384 outrel.r_offset += (input_section->output_section->vma
2385 + input_section->output_offset);
2386
2387 if (skip)
0bb2d96a 2388 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2389 else if (h != NULL
2390 && h->dynindx != -1
2391 && (r_type == R_386_PC32
2392 || !info->shared
2393 || !info->symbolic
2394 || (h->elf_link_hash_flags
2395 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 2396 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2397 else
2398 {
5a15f56f
AM		 2399 /* This symbol is local, or marked to become local. */
2400 relocate = true;
2401 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2402 }
2403
0c715baa
AM		 2404 sreloc = elf_section_data (input_section)->sreloc;
2405 if (sreloc == NULL)
2406 abort ();
2407
0ac8d2ca
AM		 2408 loc = (Elf32_External_Rel *) sreloc->contents;
2409 loc += sreloc->reloc_count++;
0c715baa 2410 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2411
2412 /* If this reloc is against an external symbol, we do
2413 not want to fiddle with the addend. Otherwise, we
2414 need to include the symbol value so that it becomes
2415 an addend for the dynamic reloc. */
2416 if (! relocate)
2417 continue;
2418 }
252b5132
RH		 2419 break;
2420
13ae64f3
JJ		 2421 case R_386_TLS_GD:
2422 case R_386_TLS_IE_32:
2423 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2424 tls_type = GOT_UNKNOWN;
2425 if (h == NULL && local_got_offsets)
2426 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2427 else if (h != NULL)
2428 {
2429 tls_type = elf_i386_hash_entry(h)->tls_type;
2430 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2431 r_type = R_386_TLS_LE_32;
2432 }
2433 if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2434 r_type = R_386_TLS_IE_32;
2435
2436 if (r_type == R_386_TLS_LE_32)
2437 {
82e51918 2438 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2439 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2440 {
2441 unsigned int val, type;
2442 bfd_vma roff;
2443
2444 /* GD->LE transition. */
2445 BFD_ASSERT (rel->r_offset >= 2);
2446 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2447 BFD_ASSERT (type == 0x8d || type == 0x04);
2448 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2449 BFD_ASSERT (bfd_get_8 (input_bfd,
2450 contents + rel->r_offset + 4)
2451 == 0xe8);
2452 BFD_ASSERT (rel + 1 < relend);
2453 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2454 roff = rel->r_offset + 5;
2455 val = bfd_get_8 (input_bfd,
2456 contents + rel->r_offset - 1);
2457 if (type == 0x04)
2458 {
2459 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2460 Change it into:
2461 movl %gs:0, %eax; subl $foo@tpoff, %eax
2462 (6 byte form of subl). */
2463 BFD_ASSERT (rel->r_offset >= 3);
2464 BFD_ASSERT (bfd_get_8 (input_bfd,
2465 contents + rel->r_offset - 3)
2466 == 0x8d);
2467 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2468 memcpy (contents + rel->r_offset - 3,
2469 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2470 }
2471 else
2472 {
2473 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2474 if (rel->r_offset + 10 <= input_section->_raw_size
2475 && bfd_get_8 (input_bfd,
2476 contents + rel->r_offset + 9) == 0x90)
2477 {
2478 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2479 Change it into:
2480 movl %gs:0, %eax; subl $foo@tpoff, %eax
2481 (6 byte form of subl). */
2482 memcpy (contents + rel->r_offset - 2,
2483 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2484 roff = rel->r_offset + 6;
2485 }
2486 else
2487 {
2488 /* leal foo(%reg), %eax; call ___tls_get_addr
2489 Change it into:
2490 movl %gs:0, %eax; subl $foo@tpoff, %eax
2491 (5 byte form of subl). */
2492 memcpy (contents + rel->r_offset - 2,
2493 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2494 }
2495 }
2496 bfd_put_32 (output_bfd, tpoff (info, relocation),
2497 contents + roff);
2498 /* Skip R_386_PLT32. */
2499 rel++;
2500 continue;
2501 }
2502 else
2503 {
2504 unsigned int val, type;
2505
2506 /* IE->LE transition:
2507 Originally it can be either:
2508 subl foo(%reg1), %reg2
2509 or
2510 movl foo(%reg1), %reg2
2511 We change it into:
2512 subl $foo, %reg2
2513 or
2514 movl $foo, %reg2 (6 byte form) */
2515 BFD_ASSERT (rel->r_offset >= 2);
2516 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2517 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2518 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2519 if (type == 0x8b)
2520 {
2521 /* movl */
2522 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2523 bfd_put_8 (output_bfd, 0xc7,
2524 contents + rel->r_offset - 2);
2525 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2526 contents + rel->r_offset - 1);
2527 }
2528 else if (type == 0x2b)
2529 {
2530 /* subl */
2531 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2532 bfd_put_8 (output_bfd, 0x81,
2533 contents + rel->r_offset - 2);
2534 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2535 contents + rel->r_offset - 1);
2536 }
2537 else
2538 BFD_FAIL ();
2539 bfd_put_32 (output_bfd, tpoff (info, relocation),
2540 contents + rel->r_offset);
2541 continue;
2542 }
2543 }
2544
2545 if (htab->sgot == NULL)
2546 abort ();
2547
2548 if (h != NULL)
2549 off = h->got.offset;
2550 else
2551 {
2552 if (local_got_offsets == NULL)
2553 abort ();
2554
2555 off = local_got_offsets[r_symndx];
2556 }
2557
2558 if ((off & 1) != 0)
2559 off &= ~1;
2560 else
2561 {
2562 Elf_Internal_Rel outrel;
2563 Elf32_External_Rel *loc;
2564 int dr_type, indx;
2565
2566 if (htab->srelgot == NULL)
2567 abort ();
2568
2569 outrel.r_offset = (htab->sgot->output_section->vma
2570 + htab->sgot->output_offset + off);
2571
13ae64f3
JJ		 2572 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2573 if (r_type == R_386_TLS_GD)
2574 dr_type = R_386_TLS_DTPMOD32;
2575 else
2576 dr_type = R_386_TLS_TPOFF32;
c366c25e
JJ		 2577 if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2578 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2579 htab->sgot->contents + off);
2580 else
2581 bfd_put_32 (output_bfd, 0,
2582 htab->sgot->contents + off);
13ae64f3
JJ		 2583 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2584 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2585 loc += htab->srelgot->reloc_count++;
2586 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2587
2588 if (r_type == R_386_TLS_GD)
2589 {
2590 if (indx == 0)
2591 {
82e51918 2592 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2593 bfd_put_32 (output_bfd,
2594 relocation - dtpoff_base (info),
2595 htab->sgot->contents + off + 4);
2596 }
2597 else
2598 {
2599 bfd_put_32 (output_bfd, 0,
2600 htab->sgot->contents + off + 4);
2601 outrel.r_info = ELF32_R_INFO (indx,
2602 R_386_TLS_DTPOFF32);
2603 outrel.r_offset += 4;
2604 htab->srelgot->reloc_count++;
2605 loc++;
2606 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2607 loc);
2608 }
2609 }
2610
2611 if (h != NULL)
2612 h->got.offset |= 1;
2613 else
2614 local_got_offsets[r_symndx] |= 1;
2615 }
2616
2617 if (off >= (bfd_vma) -2)
2618 abort ();
2619 if (r_type == ELF32_R_TYPE (rel->r_info))
2620 {
2621 relocation = htab->sgot->output_offset + off;
2622 unresolved_reloc = false;
2623 }
2624 else
2625 {
2626 unsigned int val, type;
2627 bfd_vma roff;
2628
2629 /* GD->IE transition. */
2630 BFD_ASSERT (rel->r_offset >= 2);
2631 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2632 BFD_ASSERT (type == 0x8d || type == 0x04);
2633 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2634 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2635 == 0xe8);
2636 BFD_ASSERT (rel + 1 < relend);
2637 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2638 roff = rel->r_offset - 3;
2639 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2640 if (type == 0x04)
2641 {
2642 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2643 Change it into:
2644 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2645 BFD_ASSERT (rel->r_offset >= 3);
2646 BFD_ASSERT (bfd_get_8 (input_bfd,
2647 contents + rel->r_offset - 3)
2648 == 0x8d);
2649 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2650 val >>= 3;
2651 }
2652 else
2653 {
2654 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2655 Change it into:
2656 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2657 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2658 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2659 BFD_ASSERT (bfd_get_8 (input_bfd,
2660 contents + rel->r_offset + 9)
2661 == 0x90);
2662 roff = rel->r_offset - 2;
2663 }
2664 memcpy (contents + roff,
2665 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2666 contents[roff + 7] = 0x80 | (val & 7);
2667 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2668 contents + roff + 8);
2669 /* Skip R_386_PLT32. */
2670 rel++;
2671 continue;
2672 }
2673 break;
2674
2675 case R_386_TLS_LDM:
2676 if (! info->shared)
2677 {
2678 unsigned int val;
2679
2680 /* LD->LE transition:
2681 Ensure it is:
2682 leal foo(%reg), %eax; call ___tls_get_addr.
2683 We change it into:
2684 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2685 BFD_ASSERT (rel->r_offset >= 2);
2686 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2687 == 0x8d);
2688 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2689 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2690 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2691 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2692 == 0xe8);
2693 BFD_ASSERT (rel + 1 < relend);
2694 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2695 memcpy (contents + rel->r_offset - 2,
2696 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2697 /* Skip R_386_PLT32. */
2698 rel++;
2699 continue;
2700 }
2701
2702 if (htab->sgot == NULL)
2703 abort ();
2704
2705 off = htab->tls_ldm_got.offset;
2706 if (off & 1)
2707 off &= ~1;
2708 else
2709 {
2710 Elf_Internal_Rel outrel;
2711 Elf32_External_Rel *loc;
2712
2713 if (htab->srelgot == NULL)
2714 abort ();
2715
2716 outrel.r_offset = (htab->sgot->output_section->vma
2717 + htab->sgot->output_offset + off);
2718
2719 bfd_put_32 (output_bfd, 0,
2720 htab->sgot->contents + off);
2721 bfd_put_32 (output_bfd, 0,
2722 htab->sgot->contents + off + 4);
2723 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2724 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2725 loc += htab->srelgot->reloc_count++;
2726 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2727 htab->tls_ldm_got.offset |= 1;
2728 }
2729 relocation = htab->sgot->output_offset + off;
2730 unresolved_reloc = false;
2731 break;
2732
2733 case R_386_TLS_LDO_32:
2734 if (info->shared)
2735 relocation -= dtpoff_base (info);
2736 else
2737 /* When converting LDO to LE, we must negate. */
2738 relocation = -tpoff (info, relocation);
2739 break;
2740
2741 case R_386_TLS_LE_32:
2742 relocation = tpoff (info, relocation);
2743 break;
2744
2745 case R_386_TLS_LE:
2746 relocation = -tpoff (info, relocation);
2747 break;
2748
252b5132
RH		 2749 default:
2750 break;
2751 }
2752
239e1f3a
AM		 2753 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2754 because such sections are not SEC_ALLOC and thus ld.so will
2755 not process them. */
8c694914 2756 if (unresolved_reloc
239e1f3a 2757 && !((input_section->flags & SEC_DEBUGGING) != 0
8c694914 2758 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
83be169b
AM		 2759 (*_bfd_error_handler)
2760 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
8f615d07 2761 bfd_archive_filename (input_bfd),
83be169b
AM		 2762 bfd_get_section_name (input_bfd, input_section),
2763 (long) rel->r_offset,
2764 h->root.root.string);
2765
252b5132
RH		 2766 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2767 contents, rel->r_offset,
2768 relocation, (bfd_vma) 0);
2769
cf5c0c5b 2770 if (r != bfd_reloc_ok)
252b5132 2771 {
cf5c0c5b 2772 const char *name;
ffb2e45b 2773
cf5c0c5b
AM		 2774 if (h != NULL)
2775 name = h->root.root.string;
2776 else
2777 {
2778 name = bfd_elf_string_from_elf_section (input_bfd,
2779 symtab_hdr->sh_link,
2780 sym->st_name);
2781 if (name == NULL)
2782 return false;
2783 if (*name == '\0')
2784 name = bfd_section_name (input_bfd, sec);
2785 }
ffb2e45b 2786
cf5c0c5b
AM		 2787 if (r == bfd_reloc_overflow)
2788 {
cf5c0c5b
AM		 2789 if (! ((*info->callbacks->reloc_overflow)
2790 (info, name, howto->name, (bfd_vma) 0,
2791 input_bfd, input_section, rel->r_offset)))
2792 return false;
2793 }
2794 else
2795 {
2796 (*_bfd_error_handler)
2797 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2798 bfd_archive_filename (input_bfd),
2799 bfd_get_section_name (input_bfd, input_section),
2800 (long) rel->r_offset, name, (int) r);
2801 return false;
2802 }
252b5132
RH		 2803 }
2804 }
2805
2806 return true;
2807}
2808
2809/* Finish up dynamic symbol handling. We set the contents of various
2810 dynamic sections here. */
2811
2812static boolean
2813elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2814 bfd *output_bfd;
2815 struct bfd_link_info *info;
2816 struct elf_link_hash_entry *h;
2817 Elf_Internal_Sym *sym;
2818{
6725bdbf 2819 struct elf_i386_link_hash_table *htab;
252b5132 2820
6725bdbf 2821 htab = elf_i386_hash_table (info);
252b5132
RH		 2822
2823 if (h->plt.offset != (bfd_vma) -1)
2824 {
252b5132
RH		 2825 bfd_vma plt_index;
2826 bfd_vma got_offset;
2827 Elf_Internal_Rel rel;
0ac8d2ca 2828 Elf32_External_Rel *loc;
252b5132
RH		 2829
2830 /* This symbol has an entry in the procedure linkage table. Set
2831 it up. */
2832
ffb2e45b
AM		 2833 if (h->dynindx == -1
2834 || htab->splt == NULL
2835 || htab->sgotplt == NULL
2836 || htab->srelplt == NULL)
2837 abort ();
252b5132
RH		 2838
2839 /* Get the index in the procedure linkage table which
2840 corresponds to this symbol. This is the index of this symbol
2841 in all the symbols for which we are making plt entries. The
2842 first entry in the procedure linkage table is reserved. */
2843 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2844
2845 /* Get the offset into the .got table of the entry that
2846 corresponds to this function. Each .got entry is 4 bytes.
2847 The first three are reserved. */
2848 got_offset = (plt_index + 3) * 4;
2849
2850 /* Fill in the entry in the procedure linkage table. */
2851 if (! info->shared)
2852 {
6725bdbf 2853 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 2854 PLT_ENTRY_SIZE);
2855 bfd_put_32 (output_bfd,
6725bdbf
AM		 2856 (htab->sgotplt->output_section->vma
2857 + htab->sgotplt->output_offset
252b5132 2858 + got_offset),
6725bdbf 2859 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 2860 }
2861 else
2862 {
6725bdbf 2863 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 2864 PLT_ENTRY_SIZE);
2865 bfd_put_32 (output_bfd, got_offset,
6725bdbf 2866 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 2867 }
2868
2869 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 2870 htab->splt->contents + h->plt.offset + 7);
252b5132 2871 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 2872 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 2873
2874 /* Fill in the entry in the global offset table. */
2875 bfd_put_32 (output_bfd,
6725bdbf
AM		 2876 (htab->splt->output_section->vma
2877 + htab->splt->output_offset
252b5132
RH		 2878 + h->plt.offset
2879 + 6),
6725bdbf 2880 htab->sgotplt->contents + got_offset);
252b5132
RH		 2881
2882 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 2883 rel.r_offset = (htab->sgotplt->output_section->vma
2884 + htab->sgotplt->output_offset
252b5132
RH		 2885 + got_offset);
2886 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
0ac8d2ca
AM		 2887 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2888 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2889
2890 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2891 {
2892 /* Mark the symbol as undefined, rather than as defined in
51b64d56
AM		 2893 the .plt section. Leave the value alone. This is a clue
2894 for the dynamic linker, to make function pointer
2895 comparisons work between an application and shared
cedb70c5 2896 library. */
252b5132
RH		 2897 sym->st_shndx = SHN_UNDEF;
2898 }
2899 }
2900
13ae64f3
JJ		 2901 if (h->got.offset != (bfd_vma) -1
2902 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2903 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
252b5132 2904 {
252b5132 2905 Elf_Internal_Rel rel;
0ac8d2ca 2906 Elf32_External_Rel *loc;
252b5132
RH		 2907
2908 /* This symbol has an entry in the global offset table. Set it
2909 up. */
2910
ffb2e45b
AM		 2911 if (htab->sgot == NULL || htab->srelgot == NULL)
2912 abort ();
252b5132 2913
6725bdbf
AM		 2914 rel.r_offset = (htab->sgot->output_section->vma
2915 + htab->sgot->output_offset
dc810e39 2916 + (h->got.offset & ~(bfd_vma) 1));
252b5132 2917
dd5724d5
AM		 2918 /* If this is a static link, or it is a -Bsymbolic link and the
2919 symbol is defined locally or was forced to be local because
2920 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 2921 The entry in the global offset table will already have been
2922 initialized in the relocate_section function. */
6725bdbf
AM		 2923 if (info->shared
2924 && (info->symbolic
2925 || h->dynindx == -1
2926 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2927 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
dd5724d5 2928 {
6725bdbf 2929 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 2930 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2931 }
252b5132
RH		 2932 else
2933 {
dd5724d5 2934 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 2935 bfd_put_32 (output_bfd, (bfd_vma) 0,
2936 htab->sgot->contents + h->got.offset);
252b5132
RH		 2937 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2938 }
2939
0ac8d2ca
AM		 2940 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2941 loc += htab->srelgot->reloc_count++;
2942 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2943 }
2944
791987af 2945 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132 2946 {
252b5132 2947 Elf_Internal_Rel rel;
0ac8d2ca 2948 Elf32_External_Rel *loc;
252b5132
RH		 2949
2950 /* This symbol needs a copy reloc. Set it up. */
2951
ffb2e45b
AM		 2952 if (h->dynindx == -1
2953 || (h->root.type != bfd_link_hash_defined
2954 && h->root.type != bfd_link_hash_defweak)
2955 || htab->srelbss == NULL)
2956 abort ();
252b5132
RH		 2957
2958 rel.r_offset = (h->root.u.def.value
2959 + h->root.u.def.section->output_section->vma
2960 + h->root.u.def.section->output_offset);
2961 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
0ac8d2ca
AM		 2962 loc = (Elf32_External_Rel *) htab->srelbss->contents;
2963 loc += htab->srelbss->reloc_count++;
2964 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2965 }
2966
2967 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2968 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2969 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2970 sym->st_shndx = SHN_ABS;
2971
2972 return true;
2973}
2974
38701953
AM		 2975/* Used to decide how to sort relocs in an optimal manner for the
2976 dynamic linker, before writing them out. */
2977
2978static enum elf_reloc_type_class
2979elf_i386_reloc_type_class (rela)
2980 const Elf_Internal_Rela *rela;
2981{
2982 switch ((int) ELF32_R_TYPE (rela->r_info))
2983 {
2984 case R_386_RELATIVE:
2985 return reloc_class_relative;
2986 case R_386_JUMP_SLOT:
2987 return reloc_class_plt;
2988 case R_386_COPY:
2989 return reloc_class_copy;
2990 default:
2991 return reloc_class_normal;
2992 }
2993}
2994
252b5132
RH		 2995/* Finish up the dynamic sections. */
2996
2997static boolean
2998elf_i386_finish_dynamic_sections (output_bfd, info)
2999 bfd *output_bfd;
3000 struct bfd_link_info *info;
3001{
6725bdbf 3002 struct elf_i386_link_hash_table *htab;
252b5132 3003 bfd *dynobj;
252b5132
RH		 3004 asection *sdyn;
3005
6725bdbf 3006 htab = elf_i386_hash_table (info);
ebe50bae 3007 dynobj = htab->elf.dynobj;
252b5132
RH		 3008 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3009
ebe50bae 3010 if (htab->elf.dynamic_sections_created)
252b5132 3011 {
252b5132
RH		 3012 Elf32_External_Dyn *dyncon, *dynconend;
3013
ffb2e45b
AM		 3014 if (sdyn == NULL || htab->sgot == NULL)
3015 abort ();
252b5132
RH		 3016
3017 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3018 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3019 for (; dyncon < dynconend; dyncon++)
3020 {
3021 Elf_Internal_Dyn dyn;
51b64d56 3022 asection *s;
252b5132
RH		 3023
3024 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3025
3026 switch (dyn.d_tag)
3027 {
3028 default:
0ac8d2ca 3029 continue;
252b5132
RH		 3030
3031 case DT_PLTGOT:
6725bdbf 3032 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
6725bdbf
AM		 3033 break;
3034
252b5132 3035 case DT_JMPREL:
6725bdbf 3036 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
252b5132
RH		 3037 break;
3038
3039 case DT_PLTRELSZ:
51b64d56
AM		 3040 s = htab->srelplt->output_section;
3041 if (s->_cooked_size != 0)
3042 dyn.d_un.d_val = s->_cooked_size;
252b5132 3043 else
51b64d56 3044 dyn.d_un.d_val = s->_raw_size;
252b5132
RH		 3045 break;
3046
3047 case DT_RELSZ:
3048 /* My reading of the SVR4 ABI indicates that the
3049 procedure linkage table relocs (DT_JMPREL) should be
3050 included in the overall relocs (DT_REL). This is
3051 what Solaris does. However, UnixWare can not handle
3052 that case. Therefore, we override the DT_RELSZ entry
3053 here to make it not include the JMPREL relocs. Since
3054 the linker script arranges for .rel.plt to follow all
3055 other relocation sections, we don't have to worry
3056 about changing the DT_REL entry. */
6725bdbf 3057 if (htab->srelplt != NULL)
252b5132 3058 {
51b64d56
AM		 3059 s = htab->srelplt->output_section;
3060 if (s->_cooked_size != 0)
3061 dyn.d_un.d_val -= s->_cooked_size;
252b5132 3062 else
51b64d56 3063 dyn.d_un.d_val -= s->_raw_size;
252b5132 3064 }
252b5132
RH		 3065 break;
3066 }
0ac8d2ca
AM		 3067
3068 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3069 }
3070
3071 /* Fill in the first entry in the procedure linkage table. */
6725bdbf 3072 if (htab->splt && htab->splt->_raw_size > 0)
252b5132
RH		 3073 {
3074 if (info->shared)
6725bdbf
AM		 3075 memcpy (htab->splt->contents,
3076 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3077 else
3078 {
6725bdbf
AM		 3079 memcpy (htab->splt->contents,
3080 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3081 bfd_put_32 (output_bfd,
6725bdbf
AM		 3082 (htab->sgotplt->output_section->vma
3083 + htab->sgotplt->output_offset
3084 + 4),
3085 htab->splt->contents + 2);
252b5132 3086 bfd_put_32 (output_bfd,
6725bdbf
AM		 3087 (htab->sgotplt->output_section->vma
3088 + htab->sgotplt->output_offset
3089 + 8),
3090 htab->splt->contents + 8);
252b5132
RH		 3091 }
3092
3093 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3094 really seem like the right value. */
6725bdbf
AM		 3095 elf_section_data (htab->splt->output_section)
3096 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3097 }
3098 }
3099
12d0ee4a 3100 if (htab->sgotplt)
252b5132 3101 {
12d0ee4a
AM		 3102 /* Fill in the first three entries in the global offset table. */
3103 if (htab->sgotplt->_raw_size > 0)
3104 {
3105 bfd_put_32 (output_bfd,
3106 (sdyn == NULL ? (bfd_vma) 0
3107 : sdyn->output_section->vma + sdyn->output_offset),
3108 htab->sgotplt->contents);
3109 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3110 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3111 }
252b5132 3112
12d0ee4a
AM		 3113 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3114 }
252b5132
RH		 3115 return true;
3116}
3117
3118#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3119#define TARGET_LITTLE_NAME "elf32-i386"
3120#define ELF_ARCH bfd_arch_i386
3121#define ELF_MACHINE_CODE EM_386
3122#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3123
3124#define elf_backend_can_gc_sections 1
51b64d56 3125#define elf_backend_can_refcount 1
252b5132
RH		 3126#define elf_backend_want_got_plt 1
3127#define elf_backend_plt_readonly 1
3128#define elf_backend_want_plt_sym 0
3129#define elf_backend_got_header_size 12
3130#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3131
dd5724d5
AM		 3132#define elf_info_to_howto elf_i386_info_to_howto
3133#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3134
13ae64f3
JJ		 3135#define bfd_elf32_mkobject elf_i386_mkobject
3136#define elf_backend_object_p elf_i386_object_p
3137
dd5724d5
AM		 3138#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3139#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3140#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3141
3142#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3143#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3144#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3145#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3146#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3147#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3148#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3149#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3150#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3151#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3152#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3153#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3154#define elf_backend_relocate_section elf_i386_relocate_section
3155#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
dd5724d5 3156
caf47ea6 3157#ifndef ELF32_I386_C_INCLUDED
252b5132 3158#include "elf32-target.h"
caf47ea6 3159#endif
GDB Binutils - Deliverables
This page took 0.409287 seconds and 4 git commands to generate.