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