]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-i386.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* aout-adobe.c: Don't compare against "true" or "false.
[thirdparty/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
AM		 59static asection *elf_i386_gc_mark_hook
60 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
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 *
1177elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
1178 bfd *abfd;
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
1208 {
9ad5cbcf 1209 return bfd_section_from_elf_index (abfd, sym->st_shndx);
252b5132
RH		 1210 }
1211
1212 return NULL;
1213}
1214
1215/* Update the got entry reference counts for the section being removed. */
1216
1217static boolean
1218elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
dd5724d5 1219 bfd *abfd;
6725bdbf 1220 struct bfd_link_info *info;
dd5724d5
AM		 1221 asection *sec;
1222 const Elf_Internal_Rela *relocs;
252b5132 1223{
dd5724d5
AM		 1224 Elf_Internal_Shdr *symtab_hdr;
1225 struct elf_link_hash_entry **sym_hashes;
1226 bfd_signed_vma *local_got_refcounts;
1227 const Elf_Internal_Rela *rel, *relend;
1228 unsigned long r_symndx;
1229 struct elf_link_hash_entry *h;
dd5724d5 1230
ec338859 1231 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1232
6725bdbf
AM		 1233 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1234 sym_hashes = elf_sym_hashes (abfd);
1235 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1236
1237 relend = relocs + sec->reloc_count;
1238 for (rel = relocs; rel < relend; rel++)
13ae64f3
JJ		 1239 switch (elf_i386_tls_transition (info, ELF32_R_TYPE (rel->r_info),
1240 ELF32_R_SYM (rel->r_info)
1241 >= symtab_hdr->sh_info))
dd5724d5 1242 {
13ae64f3
JJ		 1243 case R_386_TLS_LDM:
1244 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1245 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1246 break;
1247
1248 case R_386_TLS_GD:
1249 case R_386_TLS_IE_32:
dd5724d5 1250 case R_386_GOT32:
dd5724d5
AM		 1251 r_symndx = ELF32_R_SYM (rel->r_info);
1252 if (r_symndx >= symtab_hdr->sh_info)
1253 {
1254 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1255 if (h->got.refcount > 0)
6725bdbf 1256 h->got.refcount -= 1;
dd5724d5
AM		 1257 }
1258 else if (local_got_refcounts != NULL)
1259 {
1260 if (local_got_refcounts[r_symndx] > 0)
6725bdbf 1261 local_got_refcounts[r_symndx] -= 1;
dd5724d5
AM		 1262 }
1263 break;
1264
6725bdbf
AM		 1265 case R_386_32:
1266 case R_386_PC32:
0c715baa
AM		 1267 r_symndx = ELF32_R_SYM (rel->r_info);
1268 if (r_symndx >= symtab_hdr->sh_info)
1269 {
1270 struct elf_i386_link_hash_entry *eh;
1271 struct elf_i386_dyn_relocs **pp;
1272 struct elf_i386_dyn_relocs *p;
1273
1274 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1275
1276 if (!info->shared && h->plt.refcount > 0)
1277 h->plt.refcount -= 1;
1278
1279 eh = (struct elf_i386_link_hash_entry *) h;
1280
1281 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1282 if (p->sec == sec)
1283 {
1284 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1285 p->pc_count -= 1;
1286 p->count -= 1;
1287 if (p->count == 0)
1288 *pp = p->next;
1289 break;
1290 }
1291 }
1292 break;
6725bdbf 1293
dd5724d5
AM		 1294 case R_386_PLT32:
1295 r_symndx = ELF32_R_SYM (rel->r_info);
1296 if (r_symndx >= symtab_hdr->sh_info)
1297 {
1298 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1299 if (h->plt.refcount > 0)
1300 h->plt.refcount -= 1;
1301 }
1302 break;
1303
1304 default:
1305 break;
1306 }
252b5132
RH		 1307
1308 return true;
1309}
1310
1311/* Adjust a symbol defined by a dynamic object and referenced by a
1312 regular object. The current definition is in some section of the
1313 dynamic object, but we're not including those sections. We have to
1314 change the definition to something the rest of the link can
1315 understand. */
1316
1317static boolean
1318elf_i386_adjust_dynamic_symbol (info, h)
1319 struct bfd_link_info *info;
1320 struct elf_link_hash_entry *h;
1321{
6725bdbf 1322 struct elf_i386_link_hash_table *htab;
ebe50bae
AM		 1323 struct elf_i386_link_hash_entry * eh;
1324 struct elf_i386_dyn_relocs *p;
252b5132
RH		 1325 asection *s;
1326 unsigned int power_of_two;
1327
252b5132
RH		 1328 /* If this is a function, put it in the procedure linkage table. We
1329 will fill in the contents of the procedure linkage table later,
1330 when we know the address of the .got section. */
1331 if (h->type == STT_FUNC
1332 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1333 {
6725bdbf
AM		 1334 if (h->plt.refcount <= 0
1335 || (! info->shared
1336 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
f9cd9119
MS		 1337 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1338 && h->root.type != bfd_link_hash_undefweak
1339 && h->root.type != bfd_link_hash_undefined))
252b5132
RH		 1340 {
1341 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1342 file, but the symbol was never referred to by a dynamic
1343 object, or if all references were garbage collected. In
1344 such a case, we don't actually need to build a procedure
1345 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1346 h->plt.offset = (bfd_vma) -1;
dd5724d5 1347 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
252b5132
RH		 1348 }
1349
252b5132
RH		 1350 return true;
1351 }
6725bdbf
AM		 1352 else
1353 /* It's possible that we incorrectly decided a .plt reloc was
1354 needed for an R_386_PC32 reloc to a non-function sym in
1355 check_relocs. We can't decide accurately between function and
1356 non-function syms in check-relocs; Objects loaded later in
1357 the link may change h->type. So fix it now. */
bbd7ec4a 1358 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1359
1360 /* If this is a weak symbol, and there is a real definition, the
1361 processor independent code will have arranged for us to see the
1362 real definition first, and we can just use the same value. */
1363 if (h->weakdef != NULL)
1364 {
1365 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1366 || h->weakdef->root.type == bfd_link_hash_defweak);
1367 h->root.u.def.section = h->weakdef->root.u.def.section;
1368 h->root.u.def.value = h->weakdef->root.u.def.value;
0a991dfe 1369 return true;
252b5132
RH		 1370 }
1371
1372 /* This is a reference to a symbol defined by a dynamic object which
1373 is not a function. */
1374
1375 /* If we are creating a shared library, we must presume that the
1376 only references to the symbol are via the global offset table.
1377 For such cases we need not do anything here; the relocations will
1378 be handled correctly by relocate_section. */
1379 if (info->shared)
1380 return true;
1381
7843f00e
ILT		 1382 /* If there are no references to this symbol that do not use the
1383 GOT, we don't need to generate a copy reloc. */
1384 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1385 return true;
1386
8bd621d8
AM		 1387 /* If -z nocopyreloc was given, we won't generate them either. */
1388 if (info->nocopyreloc)
1389 {
1390 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1391 return true;
1392 }
1393
ebe50bae
AM		 1394 eh = (struct elf_i386_link_hash_entry *) h;
1395 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1396 {
1397 s = p->sec->output_section;
1398 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1399 break;
1400 }
1401
1402 /* If we didn't find any dynamic relocs in read-only sections, then
cedb70c5 1403 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
ebe50bae
AM		 1404 if (p == NULL)
1405 {
1406 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1407 return true;
1408 }
1409
252b5132
RH		 1410 /* We must allocate the symbol in our .dynbss section, which will
1411 become part of the .bss section of the executable. There will be
1412 an entry for this symbol in the .dynsym section. The dynamic
1413 object will contain position independent code, so all references
1414 from the dynamic object to this symbol will go through the global
1415 offset table. The dynamic linker will use the .dynsym entry to
1416 determine the address it must put in the global offset table, so
1417 both the dynamic object and the regular object will refer to the
1418 same memory location for the variable. */
1419
0ac8d2ca 1420 htab = elf_i386_hash_table (info);
252b5132
RH		 1421
1422 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1423 copy the initial value out of the dynamic object and into the
0ac8d2ca 1424 runtime process image. */
252b5132
RH		 1425 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1426 {
0ac8d2ca 1427 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
252b5132
RH		 1428 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1429 }
1430
1431 /* We need to figure out the alignment required for this symbol. I
1432 have no idea how ELF linkers handle this. */
1433 power_of_two = bfd_log2 (h->size);
1434 if (power_of_two > 3)
1435 power_of_two = 3;
1436
1437 /* Apply the required alignment. */
0ac8d2ca
AM		 1438 s = htab->sdynbss;
1439 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1440 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
252b5132 1441 {
0ac8d2ca 1442 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
252b5132
RH		 1443 return false;
1444 }
1445
1446 /* Define the symbol as being at this point in the section. */
1447 h->root.u.def.section = s;
1448 h->root.u.def.value = s->_raw_size;
1449
1450 /* Increment the section size to make room for the symbol. */
1451 s->_raw_size += h->size;
1452
1453 return true;
1454}
1455
6725bdbf
AM		 1456/* This is the condition under which elf_i386_finish_dynamic_symbol
1457 will be called from elflink.h. If elflink.h doesn't call our
1458 finish_dynamic_symbol routine, we'll need to do something about
1459 initializing any .plt and .got entries in elf_i386_relocate_section. */
1460#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1461 ((DYN) \
1462 && ((INFO)->shared \
1463 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1464 && ((H)->dynindx != -1 \
1465 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1466
1467/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1468 dynamic relocs. */
6725bdbf
AM		 1469
1470static boolean
0c715baa 1471allocate_dynrelocs (h, inf)
6725bdbf
AM		 1472 struct elf_link_hash_entry *h;
1473 PTR inf;
1474{
1475 struct bfd_link_info *info;
1476 struct elf_i386_link_hash_table *htab;
5a15f56f 1477 struct elf_i386_link_hash_entry *eh;
0c715baa 1478 struct elf_i386_dyn_relocs *p;
6725bdbf 1479
e92d460e 1480 if (h->root.type == bfd_link_hash_indirect)
6725bdbf
AM		 1481 return true;
1482
e92d460e
AM		 1483 if (h->root.type == bfd_link_hash_warning)
1484 /* When warning symbols are created, they **replace** the "real"
1485 entry in the hash table, thus we never get to see the real
1486 symbol in a hash traversal. So look at it now. */
1487 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1488
6725bdbf
AM		 1489 info = (struct bfd_link_info *) inf;
1490 htab = elf_i386_hash_table (info);
1491
ebe50bae 1492 if (htab->elf.dynamic_sections_created
6725bdbf
AM		 1493 && h->plt.refcount > 0)
1494 {
5a15f56f
AM		 1495 /* Make sure this symbol is output as a dynamic symbol.
1496 Undefined weak syms won't yet be marked as dynamic. */
1497 if (h->dynindx == -1
1498 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1499 {
1500 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1501 return false;
1502 }
1503
ced53ee5
AM		 1504 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1505 {
0ac8d2ca 1506 asection *s = htab->splt;
6725bdbf 1507
ced53ee5
AM		 1508 /* If this is the first .plt entry, make room for the special
1509 first entry. */
1510 if (s->_raw_size == 0)
1511 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1512
ced53ee5 1513 h->plt.offset = s->_raw_size;
6725bdbf 1514
ced53ee5
AM		 1515 /* If this symbol is not defined in a regular file, and we are
1516 not generating a shared library, then set the symbol to this
1517 location in the .plt. This is required to make function
1518 pointers compare as equal between the normal executable and
1519 the shared library. */
1520 if (! info->shared
1521 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1522 {
1523 h->root.u.def.section = s;
1524 h->root.u.def.value = h->plt.offset;
1525 }
6725bdbf 1526
ced53ee5
AM		 1527 /* Make room for this entry. */
1528 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1529
ced53ee5
AM		 1530 /* We also need to make an entry in the .got.plt section, which
1531 will be placed in the .got section by the linker script. */
0ac8d2ca 1532 htab->sgotplt->_raw_size += 4;
6725bdbf 1533
6725bdbf 1534 /* We also need to make an entry in the .rel.plt section. */
0ac8d2ca 1535 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
6725bdbf 1536 }
ced53ee5
AM		 1537 else
1538 {
51b64d56 1539 h->plt.offset = (bfd_vma) -1;
ced53ee5
AM		 1540 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1541 }
6725bdbf
AM		 1542 }
1543 else
1544 {
51b64d56 1545 h->plt.offset = (bfd_vma) -1;
6725bdbf
AM		 1546 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1547 }
1548
13ae64f3
JJ		 1549 /* If R_386_TLS_IE_32 symbol is now local to the binary,
1550 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1551 if (h->got.refcount > 0
1552 && !info->shared
1553 && h->dynindx == -1
1554 && elf_i386_hash_entry(h)->tls_type == GOT_TLS_IE)
cedb70c5 1555 h->got.offset = (bfd_vma) -1;
13ae64f3 1556 else if (h->got.refcount > 0)
6725bdbf 1557 {
0ac8d2ca 1558 asection *s;
6725bdbf 1559 boolean dyn;
13ae64f3 1560 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1561
5a15f56f
AM		 1562 /* Make sure this symbol is output as a dynamic symbol.
1563 Undefined weak syms won't yet be marked as dynamic. */
1564 if (h->dynindx == -1
1565 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1566 {
1567 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1568 return false;
1569 }
1570
6725bdbf
AM		 1571 s = htab->sgot;
1572 h->got.offset = s->_raw_size;
1573 s->_raw_size += 4;
13ae64f3
JJ		 1574 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1575 if (tls_type == GOT_TLS_GD)
1576 s->_raw_size += 4;
ebe50bae 1577 dyn = htab->elf.dynamic_sections_created;
13ae64f3
JJ		 1578 /* R_386_TLS_IE_32 needs one dynamic relocation,
1579 R_386_TLS_GD needs one if local symbol and two if global. */
1580 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1581 || tls_type == GOT_TLS_IE)
1582 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1583 else if (tls_type == GOT_TLS_GD)
1584 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1585 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
6725bdbf
AM		 1586 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1587 }
1588 else
51b64d56 1589 h->got.offset = (bfd_vma) -1;
6725bdbf 1590
5a15f56f
AM		 1591 eh = (struct elf_i386_link_hash_entry *) h;
1592 if (eh->dyn_relocs == NULL)
1593 return true;
1594
0c715baa
AM		 1595 /* In the shared -Bsymbolic case, discard space allocated for
1596 dynamic pc-relative relocs against symbols which turn out to be
1597 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 1598 space for pc-relative relocs that have become local due to symbol
1599 visibility changes. */
0c715baa
AM		 1600
1601 if (info->shared)
5a15f56f 1602 {
0c715baa
AM		 1603 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1604 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1605 || info->symbolic))
5a15f56f 1606 {
0c715baa
AM		 1607 struct elf_i386_dyn_relocs **pp;
1608
1609 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1610 {
1611 p->count -= p->pc_count;
1612 p->pc_count = 0;
1613 if (p->count == 0)
1614 *pp = p->next;
1615 else
1616 pp = &p->next;
1617 }
5a15f56f 1618 }
0c715baa
AM		 1619 }
1620 else
1621 {
1622 /* For the non-shared case, discard space for relocs against
1623 symbols which turn out to need copy relocs or are not
1624 dynamic. */
1625
1626 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1627 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1628 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
ebe50bae 1629 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1630 && (h->root.type == bfd_link_hash_undefweak
1631 || h->root.type == bfd_link_hash_undefined))))
1632 {
1633 /* Make sure this symbol is output as a dynamic symbol.
1634 Undefined weak syms won't yet be marked as dynamic. */
1635 if (h->dynindx == -1
1636 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1637 {
1638 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1639 return false;
1640 }
5a15f56f 1641
0c715baa
AM		 1642 /* If that succeeded, we know we'll be keeping all the
1643 relocs. */
1644 if (h->dynindx != -1)
1645 goto keep;
1646 }
1647
1648 eh->dyn_relocs = NULL;
1649
ec338859 1650 keep: ;
5a15f56f
AM		 1651 }
1652
0c715baa
AM		 1653 /* Finally, allocate space. */
1654 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1655 {
0c715baa
AM		 1656 asection *sreloc = elf_section_data (p->sec)->sreloc;
1657 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1658 }
1659
6725bdbf
AM		 1660 return true;
1661}
1662
0c715baa
AM		 1663/* Find any dynamic relocs that apply to read-only sections. */
1664
1665static boolean
1666readonly_dynrelocs (h, inf)
1667 struct elf_link_hash_entry *h;
1668 PTR inf;
1669{
1670 struct elf_i386_link_hash_entry *eh;
1671 struct elf_i386_dyn_relocs *p;
1672
e92d460e
AM		 1673 if (h->root.type == bfd_link_hash_warning)
1674 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1675
0c715baa
AM		 1676 eh = (struct elf_i386_link_hash_entry *) h;
1677 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1678 {
1679 asection *s = p->sec->output_section;
1680
1681 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1682 {
1683 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1684
1685 info->flags |= DF_TEXTREL;
1686
1687 /* Not an error, just cut short the traversal. */
1688 return false;
1689 }
1690 }
1691 return true;
1692}
1693
252b5132
RH		 1694/* Set the sizes of the dynamic sections. */
1695
1696static boolean
1697elf_i386_size_dynamic_sections (output_bfd, info)
db6751f2 1698 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 1699 struct bfd_link_info *info;
1700{
6725bdbf 1701 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1702 bfd *dynobj;
1703 asection *s;
252b5132 1704 boolean relocs;
0c715baa 1705 bfd *ibfd;
252b5132 1706
6725bdbf 1707 htab = elf_i386_hash_table (info);
ebe50bae 1708 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1709 if (dynobj == NULL)
1710 abort ();
252b5132 1711
ebe50bae 1712 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1713 {
1714 /* Set the contents of the .interp section to the interpreter. */
1715 if (! info->shared)
1716 {
1717 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1718 if (s == NULL)
1719 abort ();
252b5132
RH		 1720 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1721 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1722 }
161d71a6 1723 }
6725bdbf 1724
0c715baa
AM		 1725 /* Set up .got offsets for local syms, and space for local dynamic
1726 relocs. */
1727 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1728 {
1729 bfd_signed_vma *local_got;
1730 bfd_signed_vma *end_local_got;
13ae64f3 1731 char *local_tls_type;
161d71a6
L		 1732 bfd_size_type locsymcount;
1733 Elf_Internal_Shdr *symtab_hdr;
1734 asection *srel;
6725bdbf 1735
0c715baa 1736 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1737 continue;
6725bdbf 1738
0c715baa
AM		 1739 for (s = ibfd->sections; s != NULL; s = s->next)
1740 {
ec338859 1741 struct elf_i386_dyn_relocs *p;
0c715baa 1742
ec338859
AM		 1743 for (p = *((struct elf_i386_dyn_relocs **)
1744 &elf_section_data (s)->local_dynrel);
1745 p != NULL;
1746 p = p->next)
0c715baa 1747 {
ec338859
AM		 1748 if (!bfd_is_abs_section (p->sec)
1749 && bfd_is_abs_section (p->sec->output_section))
1750 {
1751 /* Input section has been discarded, either because
1752 it is a copy of a linkonce section or due to
1753 linker script /DISCARD/, so we'll be discarding
1754 the relocs too. */
1755 }
248866a8 1756 else if (p->count != 0)
ec338859
AM		 1757 {
1758 srel = elf_section_data (p->sec)->sreloc;
1759 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1760 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1761 info->flags |= DF_TEXTREL;
ec338859 1762 }
0c715baa
AM		 1763 }
1764 }
1765
1766 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1767 if (!local_got)
1768 continue;
6725bdbf 1769
0c715baa 1770 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1771 locsymcount = symtab_hdr->sh_info;
1772 end_local_got = local_got + locsymcount;
13ae64f3 1773 local_tls_type = elf_i386_local_got_tls_type (ibfd);
161d71a6
L		 1774 s = htab->sgot;
1775 srel = htab->srelgot;
13ae64f3 1776 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
161d71a6
L		 1777 {
1778 if (*local_got > 0)
6725bdbf 1779 {
161d71a6
L		 1780 *local_got = s->_raw_size;
1781 s->_raw_size += 4;
13ae64f3
JJ		 1782 if (*local_tls_type == GOT_TLS_GD)
1783 s->_raw_size += 4;
1784 if (info->shared
1785 || *local_tls_type == GOT_TLS_GD
1786 || *local_tls_type == GOT_TLS_IE)
161d71a6 1787 srel->_raw_size += sizeof (Elf32_External_Rel);
6725bdbf 1788 }
161d71a6
L		 1789 else
1790 *local_got = (bfd_vma) -1;
6725bdbf 1791 }
252b5132 1792 }
6725bdbf 1793
13ae64f3
JJ		 1794 if (htab->tls_ldm_got.refcount > 0)
1795 {
1796 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1797 relocs. */
1798 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1799 htab->sgot->_raw_size += 8;
1800 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1801 }
1802 else
1803 htab->tls_ldm_got.offset = -1;
1804
0c715baa
AM		 1805 /* Allocate global sym .plt and .got entries, and space for global
1806 sym dynamic relocs. */
ebe50bae 1807 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1808
5a15f56f
AM		 1809 /* We now have determined the sizes of the various dynamic sections.
1810 Allocate memory for them. */
252b5132 1811 relocs = false;
252b5132
RH		 1812 for (s = dynobj->sections; s != NULL; s = s->next)
1813 {
252b5132
RH		 1814 if ((s->flags & SEC_LINKER_CREATED) == 0)
1815 continue;
1816
6725bdbf
AM		 1817 if (s == htab->splt
1818 || s == htab->sgot
1819 || s == htab->sgotplt)
252b5132 1820 {
6725bdbf
AM		 1821 /* Strip this section if we don't need it; see the
1822 comment below. */
252b5132 1823 }
6725bdbf 1824 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 1825 {
0ac8d2ca
AM		 1826 if (s->_raw_size != 0 && s != htab->srelplt)
1827 relocs = true;
252b5132 1828
0ac8d2ca
AM		 1829 /* We use the reloc_count field as a counter if we need
1830 to copy relocs into the output file. */
1831 s->reloc_count = 0;
252b5132 1832 }
6725bdbf 1833 else
252b5132
RH		 1834 {
1835 /* It's not one of our sections, so don't allocate space. */
1836 continue;
1837 }
1838
6725bdbf 1839 if (s->_raw_size == 0)
252b5132 1840 {
0ac8d2ca
AM		 1841 /* If we don't need this section, strip it from the
1842 output file. This is mostly to handle .rel.bss and
1843 .rel.plt. We must create both sections in
1844 create_dynamic_sections, because they must be created
1845 before the linker maps input sections to output
1846 sections. The linker does that before
1847 adjust_dynamic_symbol is called, and it is that
1848 function which decides whether anything needs to go
1849 into these sections. */
1850
7f8d5fc9 1851 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1852 continue;
1853 }
1854
f69da49f
AM		 1855 /* Allocate memory for the section contents. We use bfd_zalloc
1856 here in case unused entries are not reclaimed before the
1857 section's contents are written out. This should not happen,
1858 but this way if it does, we get a R_386_NONE reloc instead
1859 of garbage. */
7a9af8c4 1860 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6725bdbf 1861 if (s->contents == NULL)
252b5132
RH		 1862 return false;
1863 }
1864
ebe50bae 1865 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1866 {
1867 /* Add some entries to the .dynamic section. We fill in the
1868 values later, in elf_i386_finish_dynamic_sections, but we
1869 must add the entries now so that we get the correct size for
1870 the .dynamic section. The DT_DEBUG entry is filled in by the
1871 dynamic linker and used by the debugger. */
dc810e39
AM		 1872#define add_dynamic_entry(TAG, VAL) \
1873 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1874
252b5132
RH		 1875 if (! info->shared)
1876 {
dc810e39 1877 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 1878 return false;
1879 }
1880
6725bdbf 1881 if (htab->splt->_raw_size != 0)
252b5132 1882 {
dc810e39
AM		 1883 if (!add_dynamic_entry (DT_PLTGOT, 0)
1884 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1885 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1886 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 1887 return false;
1888 }
1889
1890 if (relocs)
1891 {
dc810e39
AM		 1892 if (!add_dynamic_entry (DT_REL, 0)
1893 || !add_dynamic_entry (DT_RELSZ, 0)
1894 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
252b5132 1895 return false;
252b5132 1896
0c715baa
AM		 1897 /* If any dynamic relocs apply to a read-only section,
1898 then we need a DT_TEXTREL entry. */
248866a8
AM		 1899 if ((info->flags & DF_TEXTREL) == 0)
1900 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1901 (PTR) info);
0c715baa
AM		 1902
1903 if ((info->flags & DF_TEXTREL) != 0)
1904 {
1905 if (!add_dynamic_entry (DT_TEXTREL, 0))
1906 return false;
1907 }
252b5132
RH		 1908 }
1909 }
dc810e39 1910#undef add_dynamic_entry
252b5132
RH		 1911
1912 return true;
1913}
1914
38701953
AM		 1915/* Set the correct type for an x86 ELF section. We do this by the
1916 section name, which is a hack, but ought to work. */
1917
1918static boolean
1919elf_i386_fake_sections (abfd, hdr, sec)
1920 bfd *abfd ATTRIBUTE_UNUSED;
1921 Elf32_Internal_Shdr *hdr;
1922 asection *sec;
1923{
1924 register const char *name;
1925
1926 name = bfd_get_section_name (abfd, sec);
1927
1928 /* This is an ugly, but unfortunately necessary hack that is
1929 needed when producing EFI binaries on x86. It tells
1930 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1931 containing ELF relocation info. We need this hack in order to
1932 be able to generate ELF binaries that can be translated into
1933 EFI applications (which are essentially COFF objects). Those
1934 files contain a COFF ".reloc" section inside an ELFNN object,
1935 which would normally cause BFD to segfault because it would
1936 attempt to interpret this section as containing relocation
1937 entries for section "oc". With this hack enabled, ".reloc"
1938 will be treated as a normal data section, which will avoid the
1939 segfault. However, you won't be able to create an ELFNN binary
1940 with a section named "oc" that needs relocations, but that's
1941 the kind of ugly side-effects you get when detecting section
1942 types based on their names... In practice, this limitation is
1943 unlikely to bite. */
1944 if (strcmp (name, ".reloc") == 0)
1945 hdr->sh_type = SHT_PROGBITS;
1946
1947 return true;
1948}
1949
13ae64f3
JJ		 1950/* Return the base VMA address which should be subtracted from real addresses
1951 when resolving @dtpoff relocation.
1952 This is PT_TLS segment p_vaddr. */
1953
1954static bfd_vma
1955dtpoff_base (info)
1956 struct bfd_link_info *info;
1957{
1958 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1959 return elf_hash_table (info)->tls_segment->start;
1960}
1961
1962/* Return the relocation value for @tpoff relocation
1963 if STT_TLS virtual address is ADDRESS. */
1964
1965static bfd_vma
1966tpoff (info, address)
1967 struct bfd_link_info *info;
1968 bfd_vma address;
1969{
1970 struct elf_link_tls_segment *tls_segment
1971 = elf_hash_table (info)->tls_segment;
1972
1973 BFD_ASSERT (tls_segment != NULL);
1974 return (align_power (tls_segment->size, tls_segment->align)
1975 + tls_segment->start - address);
1976}
1977
252b5132
RH		 1978/* Relocate an i386 ELF section. */
1979
1980static boolean
1981elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1982 contents, relocs, local_syms, local_sections)
1983 bfd *output_bfd;
1984 struct bfd_link_info *info;
1985 bfd *input_bfd;
1986 asection *input_section;
1987 bfd_byte *contents;
1988 Elf_Internal_Rela *relocs;
1989 Elf_Internal_Sym *local_syms;
1990 asection **local_sections;
1991{
6725bdbf 1992 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1993 Elf_Internal_Shdr *symtab_hdr;
1994 struct elf_link_hash_entry **sym_hashes;
1995 bfd_vma *local_got_offsets;
252b5132
RH		 1996 Elf_Internal_Rela *rel;
1997 Elf_Internal_Rela *relend;
1998
6725bdbf 1999 htab = elf_i386_hash_table (info);
252b5132
RH		 2000 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2001 sym_hashes = elf_sym_hashes (input_bfd);
2002 local_got_offsets = elf_local_got_offsets (input_bfd);
2003
252b5132
RH		 2004 rel = relocs;
2005 relend = relocs + input_section->reloc_count;
2006 for (; rel < relend; rel++)
2007 {
13ae64f3 2008 unsigned int r_type;
252b5132
RH		 2009 reloc_howto_type *howto;
2010 unsigned long r_symndx;
2011 struct elf_link_hash_entry *h;
2012 Elf_Internal_Sym *sym;
2013 asection *sec;
ffb2e45b 2014 bfd_vma off;
252b5132 2015 bfd_vma relocation;
83be169b 2016 boolean unresolved_reloc;
252b5132 2017 bfd_reloc_status_type r;
1b452ec6 2018 unsigned int indx;
13ae64f3 2019 int tls_type;
252b5132
RH		 2020
2021 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 2022 if (r_type == (int) R_386_GNU_VTINHERIT
2023 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 2024 continue;
dc47f327 2025
1b452ec6 2026 if ((indx = (unsigned) r_type) >= R_386_standard
13ae64f3
JJ		 2027 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2028 >= R_386_ext - R_386_standard)
2029 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2030 >= R_386_tls - R_386_ext))
252b5132
RH		 2031 {
2032 bfd_set_error (bfd_error_bad_value);
2033 return false;
2034 }
1b452ec6 2035 howto = elf_howto_table + indx;
252b5132
RH		 2036
2037 r_symndx = ELF32_R_SYM (rel->r_info);
2038
2039 if (info->relocateable)
2040 {
4a335f3d 2041 bfd_vma val;
4a335f3d
AM		 2042 bfd_byte *where;
2043
0ac8d2ca 2044 /* This is a relocatable link. We don't have to change
252b5132
RH		 2045 anything, unless the reloc is against a section symbol,
2046 in which case we have to adjust according to where the
2047 section symbol winds up in the output section. */
4a335f3d
AM		 2048 if (r_symndx >= symtab_hdr->sh_info)
2049 continue;
2050
2051 sym = local_syms + r_symndx;
2052 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2053 continue;
2054
2055 sec = local_sections[r_symndx];
2056 val = sec->output_offset;
2057 if (val == 0)
2058 continue;
2059
2060 where = contents + rel->r_offset;
2061 switch (howto->size)
252b5132 2062 {
16a10388 2063 /* FIXME: overflow checks. */
4a335f3d 2064 case 0:
16a10388 2065 val += bfd_get_8 (input_bfd, where);
4a335f3d 2066 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2067 break;
2068 case 1:
16a10388 2069 val += bfd_get_16 (input_bfd, where);
4a335f3d 2070 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2071 break;
2072 case 2:
2073 val += bfd_get_32 (input_bfd, where);
2074 bfd_put_32 (input_bfd, val, where);
2075 break;
2076 default:
2077 abort ();
252b5132 2078 }
252b5132
RH		 2079 continue;
2080 }
2081
2082 /* This is a final link. */
2083 h = NULL;
2084 sym = NULL;
2085 sec = NULL;
83be169b 2086 unresolved_reloc = false;
252b5132
RH		 2087 if (r_symndx < symtab_hdr->sh_info)
2088 {
2089 sym = local_syms + r_symndx;
2090 sec = local_sections[r_symndx];
2091 relocation = (sec->output_section->vma
2092 + sec->output_offset
2093 + sym->st_value);
f8df10f4
JJ		 2094 if ((sec->flags & SEC_MERGE)
2095 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2096 {
2097 asection *msec;
2098 bfd_vma addend;
4a335f3d 2099 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2100
4a335f3d 2101 switch (howto->size)
f8df10f4 2102 {
4a335f3d
AM		 2103 case 0:
2104 addend = bfd_get_8 (input_bfd, where);
2105 if (howto->pc_relative)
2106 {
2107 addend = (addend ^ 0x80) - 0x80;
2108 addend += 1;
2109 }
2110 break;
2111 case 1:
2112 addend = bfd_get_16 (input_bfd, where);
2113 if (howto->pc_relative)
2114 {
2115 addend = (addend ^ 0x8000) - 0x8000;
2116 addend += 2;
2117 }
2118 break;
2119 case 2:
2120 addend = bfd_get_32 (input_bfd, where);
2121 if (howto->pc_relative)
2122 {
2123 addend = (addend ^ 0x80000000) - 0x80000000;
2124 addend += 4;
2125 }
2126 break;
2127 default:
2128 abort ();
f8df10f4
JJ		 2129 }
2130
f8df10f4 2131 msec = sec;
4a335f3d
AM		 2132 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2133 addend -= relocation;
f8df10f4 2134 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2135
2136 switch (howto->size)
2137 {
2138 case 0:
16a10388 2139 /* FIXME: overflow checks. */
4a335f3d
AM		 2140 if (howto->pc_relative)
2141 addend -= 1;
2142 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2143 break;
2144 case 1:
2145 if (howto->pc_relative)
2146 addend -= 2;
2147 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2148 break;
2149 case 2:
2150 if (howto->pc_relative)
2151 addend -= 4;
2152 bfd_put_32 (input_bfd, addend, where);
2153 break;
2154 }
f8df10f4 2155 }
252b5132
RH		 2156 }
2157 else
2158 {
2159 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2160 while (h->root.type == bfd_link_hash_indirect
2161 || h->root.type == bfd_link_hash_warning)
2162 h = (struct elf_link_hash_entry *) h->root.u.i.link;
ffb2e45b 2163
6725bdbf 2164 relocation = 0;
252b5132
RH		 2165 if (h->root.type == bfd_link_hash_defined
2166 || h->root.type == bfd_link_hash_defweak)
2167 {
2168 sec = h->root.u.def.section;
83be169b
AM		 2169 if (sec->output_section == NULL)
2170 /* Set a flag that will be cleared later if we find a
2171 relocation value for this symbol. output_section
2172 is typically NULL for symbols satisfied by a shared
2173 library. */
2174 unresolved_reloc = true;
252b5132
RH		 2175 else
2176 relocation = (h->root.u.def.value
2177 + sec->output_section->vma
2178 + sec->output_offset);
2179 }
2180 else if (h->root.type == bfd_link_hash_undefweak)
6725bdbf 2181 ;
671bae9c
NC		 2182 else if (info->shared
2183 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730
L		 2184 && !info->no_undefined
2185 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
6725bdbf 2186 ;
252b5132
RH		 2187 else
2188 {
2189 if (! ((*info->callbacks->undefined_symbol)
2190 (info, h->root.root.string, input_bfd,
5cc7c785 2191 input_section, rel->r_offset,
3a27a730
L		 2192 (!info->shared || info->no_undefined
2193 || ELF_ST_VISIBILITY (h->other)))))
252b5132 2194 return false;
252b5132
RH		 2195 }
2196 }
2197
2198 switch (r_type)
2199 {
2200 case R_386_GOT32:
2201 /* Relocation is to the entry for this symbol in the global
2202 offset table. */
ffb2e45b
AM		 2203 if (htab->sgot == NULL)
2204 abort ();
252b5132
RH		 2205
2206 if (h != NULL)
2207 {
6725bdbf 2208 boolean dyn;
252b5132
RH		 2209
2210 off = h->got.offset;
ebe50bae 2211 dyn = htab->elf.dynamic_sections_created;
6725bdbf 2212 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
252b5132 2213 || (info->shared
6725bdbf
AM		 2214 && (info->symbolic
2215 || h->dynindx == -1
2216 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
252b5132
RH		 2217 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2218 {
2219 /* This is actually a static link, or it is a
2220 -Bsymbolic link and the symbol is defined
2221 locally, or the symbol was forced to be local
2222 because of a version file. We must initialize
2223 this entry in the global offset table. Since the
2224 offset must always be a multiple of 4, we use the
2225 least significant bit to record whether we have
2226 initialized it already.
2227
2228 When doing a dynamic link, we create a .rel.got
2229 relocation entry to initialize the value. This
2230 is done in the finish_dynamic_symbol routine. */
2231 if ((off & 1) != 0)
2232 off &= ~1;
2233 else
2234 {
2235 bfd_put_32 (output_bfd, relocation,
6725bdbf 2236 htab->sgot->contents + off);
252b5132
RH		 2237 h->got.offset |= 1;
2238 }
2239 }
8c694914
AM		 2240 else
2241 unresolved_reloc = false;
252b5132
RH		 2242 }
2243 else
2244 {
ffb2e45b
AM		 2245 if (local_got_offsets == NULL)
2246 abort ();
252b5132
RH		 2247
2248 off = local_got_offsets[r_symndx];
2249
2250 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2251 the least significant bit to record whether we have
2252 already generated the necessary reloc. */
252b5132
RH		 2253 if ((off & 1) != 0)
2254 off &= ~1;
2255 else
2256 {
6725bdbf
AM		 2257 bfd_put_32 (output_bfd, relocation,
2258 htab->sgot->contents + off);
252b5132
RH		 2259
2260 if (info->shared)
2261 {
2262 asection *srelgot;
2263 Elf_Internal_Rel outrel;
0ac8d2ca 2264 Elf32_External_Rel *loc;
252b5132 2265
6725bdbf 2266 srelgot = htab->srelgot;
ffb2e45b
AM		 2267 if (srelgot == NULL)
2268 abort ();
252b5132 2269
6725bdbf
AM		 2270 outrel.r_offset = (htab->sgot->output_section->vma
2271 + htab->sgot->output_offset
252b5132
RH		 2272 + off);
2273 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
0ac8d2ca
AM		 2274 loc = (Elf32_External_Rel *) srelgot->contents;
2275 loc += srelgot->reloc_count++;
2276 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2277 }
2278
2279 local_got_offsets[r_symndx] |= 1;
2280 }
252b5132
RH		 2281 }
2282
ffb2e45b
AM		 2283 if (off >= (bfd_vma) -2)
2284 abort ();
2285
2286 relocation = htab->sgot->output_offset + off;
252b5132
RH		 2287 break;
2288
2289 case R_386_GOTOFF:
2290 /* Relocation is relative to the start of the global offset
2291 table. */
2292
252b5132
RH		 2293 /* Note that sgot->output_offset is not involved in this
2294 calculation. We always want the start of .got. If we
2295 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2296 permitted by the ABI, we might have to change this
2297 calculation. */
6725bdbf 2298 relocation -= htab->sgot->output_section->vma;
252b5132
RH		 2299 break;
2300
2301 case R_386_GOTPC:
2302 /* Use global offset table as symbol value. */
6725bdbf 2303 relocation = htab->sgot->output_section->vma;
83be169b 2304 unresolved_reloc = false;
252b5132
RH		 2305 break;
2306
2307 case R_386_PLT32:
2308 /* Relocation is to the entry for this symbol in the
2309 procedure linkage table. */
2310
dd5724d5 2311 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2312 without using the procedure linkage table. */
252b5132
RH		 2313 if (h == NULL)
2314 break;
2315
dd5724d5 2316 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2317 || htab->splt == NULL)
252b5132
RH		 2318 {
2319 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2320 happens when statically linking PIC code, or when
2321 using -Bsymbolic. */
252b5132
RH		 2322 break;
2323 }
2324
6725bdbf
AM		 2325 relocation = (htab->splt->output_section->vma
2326 + htab->splt->output_offset
252b5132 2327 + h->plt.offset);
83be169b 2328 unresolved_reloc = false;
252b5132
RH		 2329 break;
2330
2331 case R_386_32:
2332 case R_386_PC32:
ec338859
AM		 2333 /* r_symndx will be zero only for relocs against symbols
2334 from removed linkonce sections, or sections discarded by
2335 a linker script. */
2336 if (r_symndx == 0
2337 || (input_section->flags & SEC_ALLOC) == 0)
2338 break;
2339
12d0ee4a 2340 if ((info->shared
12d0ee4a
AM		 2341 && (r_type != R_386_PC32
2342 || (h != NULL
2343 && h->dynindx != -1
2344 && (! info->symbolic
2345 || (h->elf_link_hash_flags
2346 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2347 || (!info->shared
12d0ee4a
AM		 2348 && h != NULL
2349 && h->dynindx != -1
2350 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM		 2351 && (((h->elf_link_hash_flags
2352 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2353 && (h->elf_link_hash_flags
2354 & ELF_LINK_HASH_DEF_REGULAR) == 0)
28d0b90e
AM		 2355 || h->root.type == bfd_link_hash_undefweak
2356 || h->root.type == bfd_link_hash_undefined)))
252b5132
RH		 2357 {
2358 Elf_Internal_Rel outrel;
2359 boolean skip, relocate;
0c715baa
AM		 2360 asection *sreloc;
2361 Elf32_External_Rel *loc;
252b5132
RH		 2362
2363 /* When generating a shared object, these relocations
2364 are copied into the output file to be resolved at run
2365 time. */
2366
252b5132 2367 skip = false;
0bb2d96a 2368 relocate = false;
252b5132 2369
c629eae0
JJ		 2370 outrel.r_offset =
2371 _bfd_elf_section_offset (output_bfd, info, input_section,
2372 rel->r_offset);
2373 if (outrel.r_offset == (bfd_vma) -1)
2374 skip = true;
0bb2d96a
JJ		 2375 else if (outrel.r_offset == (bfd_vma) -2)
2376 skip = true, relocate = true;
252b5132
RH		 2377 outrel.r_offset += (input_section->output_section->vma
2378 + input_section->output_offset);
2379
2380 if (skip)
0bb2d96a 2381 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2382 else if (h != NULL
2383 && h->dynindx != -1
2384 && (r_type == R_386_PC32
2385 || !info->shared
2386 || !info->symbolic
2387 || (h->elf_link_hash_flags
2388 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 2389 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2390 else
2391 {
5a15f56f
AM		 2392 /* This symbol is local, or marked to become local. */
2393 relocate = true;
2394 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2395 }
2396
0c715baa
AM		 2397 sreloc = elf_section_data (input_section)->sreloc;
2398 if (sreloc == NULL)
2399 abort ();
2400
0ac8d2ca
AM		 2401 loc = (Elf32_External_Rel *) sreloc->contents;
2402 loc += sreloc->reloc_count++;
0c715baa 2403 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2404
2405 /* If this reloc is against an external symbol, we do
2406 not want to fiddle with the addend. Otherwise, we
2407 need to include the symbol value so that it becomes
2408 an addend for the dynamic reloc. */
2409 if (! relocate)
2410 continue;
2411 }
252b5132
RH		 2412 break;
2413
13ae64f3
JJ		 2414 case R_386_TLS_GD:
2415 case R_386_TLS_IE_32:
2416 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2417 tls_type = GOT_UNKNOWN;
2418 if (h == NULL && local_got_offsets)
2419 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2420 else if (h != NULL)
2421 {
2422 tls_type = elf_i386_hash_entry(h)->tls_type;
2423 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2424 r_type = R_386_TLS_LE_32;
2425 }
2426 if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2427 r_type = R_386_TLS_IE_32;
2428
2429 if (r_type == R_386_TLS_LE_32)
2430 {
82e51918 2431 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2432 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2433 {
2434 unsigned int val, type;
2435 bfd_vma roff;
2436
2437 /* GD->LE transition. */
2438 BFD_ASSERT (rel->r_offset >= 2);
2439 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2440 BFD_ASSERT (type == 0x8d || type == 0x04);
2441 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2442 BFD_ASSERT (bfd_get_8 (input_bfd,
2443 contents + rel->r_offset + 4)
2444 == 0xe8);
2445 BFD_ASSERT (rel + 1 < relend);
2446 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2447 roff = rel->r_offset + 5;
2448 val = bfd_get_8 (input_bfd,
2449 contents + rel->r_offset - 1);
2450 if (type == 0x04)
2451 {
2452 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2453 Change it into:
2454 movl %gs:0, %eax; subl $foo@tpoff, %eax
2455 (6 byte form of subl). */
2456 BFD_ASSERT (rel->r_offset >= 3);
2457 BFD_ASSERT (bfd_get_8 (input_bfd,
2458 contents + rel->r_offset - 3)
2459 == 0x8d);
2460 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2461 memcpy (contents + rel->r_offset - 3,
2462 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2463 }
2464 else
2465 {
2466 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2467 if (rel->r_offset + 10 <= input_section->_raw_size
2468 && bfd_get_8 (input_bfd,
2469 contents + rel->r_offset + 9) == 0x90)
2470 {
2471 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2472 Change it into:
2473 movl %gs:0, %eax; subl $foo@tpoff, %eax
2474 (6 byte form of subl). */
2475 memcpy (contents + rel->r_offset - 2,
2476 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2477 roff = rel->r_offset + 6;
2478 }
2479 else
2480 {
2481 /* leal foo(%reg), %eax; call ___tls_get_addr
2482 Change it into:
2483 movl %gs:0, %eax; subl $foo@tpoff, %eax
2484 (5 byte form of subl). */
2485 memcpy (contents + rel->r_offset - 2,
2486 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2487 }
2488 }
2489 bfd_put_32 (output_bfd, tpoff (info, relocation),
2490 contents + roff);
2491 /* Skip R_386_PLT32. */
2492 rel++;
2493 continue;
2494 }
2495 else
2496 {
2497 unsigned int val, type;
2498
2499 /* IE->LE transition:
2500 Originally it can be either:
2501 subl foo(%reg1), %reg2
2502 or
2503 movl foo(%reg1), %reg2
2504 We change it into:
2505 subl $foo, %reg2
2506 or
2507 movl $foo, %reg2 (6 byte form) */
2508 BFD_ASSERT (rel->r_offset >= 2);
2509 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2510 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2511 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2512 if (type == 0x8b)
2513 {
2514 /* movl */
2515 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2516 bfd_put_8 (output_bfd, 0xc7,
2517 contents + rel->r_offset - 2);
2518 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2519 contents + rel->r_offset - 1);
2520 }
2521 else if (type == 0x2b)
2522 {
2523 /* subl */
2524 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2525 bfd_put_8 (output_bfd, 0x81,
2526 contents + rel->r_offset - 2);
2527 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2528 contents + rel->r_offset - 1);
2529 }
2530 else
2531 BFD_FAIL ();
2532 bfd_put_32 (output_bfd, tpoff (info, relocation),
2533 contents + rel->r_offset);
2534 continue;
2535 }
2536 }
2537
2538 if (htab->sgot == NULL)
2539 abort ();
2540
2541 if (h != NULL)
2542 off = h->got.offset;
2543 else
2544 {
2545 if (local_got_offsets == NULL)
2546 abort ();
2547
2548 off = local_got_offsets[r_symndx];
2549 }
2550
2551 if ((off & 1) != 0)
2552 off &= ~1;
2553 else
2554 {
2555 Elf_Internal_Rel outrel;
2556 Elf32_External_Rel *loc;
2557 int dr_type, indx;
2558
2559 if (htab->srelgot == NULL)
2560 abort ();
2561
2562 outrel.r_offset = (htab->sgot->output_section->vma
2563 + htab->sgot->output_offset + off);
2564
2565 bfd_put_32 (output_bfd, 0,
2566 htab->sgot->contents + off);
2567 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2568 if (r_type == R_386_TLS_GD)
2569 dr_type = R_386_TLS_DTPMOD32;
2570 else
2571 dr_type = R_386_TLS_TPOFF32;
2572 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2573 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2574 loc += htab->srelgot->reloc_count++;
2575 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2576
2577 if (r_type == R_386_TLS_GD)
2578 {
2579 if (indx == 0)
2580 {
82e51918 2581 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2582 bfd_put_32 (output_bfd,
2583 relocation - dtpoff_base (info),
2584 htab->sgot->contents + off + 4);
2585 }
2586 else
2587 {
2588 bfd_put_32 (output_bfd, 0,
2589 htab->sgot->contents + off + 4);
2590 outrel.r_info = ELF32_R_INFO (indx,
2591 R_386_TLS_DTPOFF32);
2592 outrel.r_offset += 4;
2593 htab->srelgot->reloc_count++;
2594 loc++;
2595 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2596 loc);
2597 }
2598 }
2599
2600 if (h != NULL)
2601 h->got.offset |= 1;
2602 else
2603 local_got_offsets[r_symndx] |= 1;
2604 }
2605
2606 if (off >= (bfd_vma) -2)
2607 abort ();
2608 if (r_type == ELF32_R_TYPE (rel->r_info))
2609 {
2610 relocation = htab->sgot->output_offset + off;
2611 unresolved_reloc = false;
2612 }
2613 else
2614 {
2615 unsigned int val, type;
2616 bfd_vma roff;
2617
2618 /* GD->IE transition. */
2619 BFD_ASSERT (rel->r_offset >= 2);
2620 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2621 BFD_ASSERT (type == 0x8d || type == 0x04);
2622 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2623 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2624 == 0xe8);
2625 BFD_ASSERT (rel + 1 < relend);
2626 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2627 roff = rel->r_offset - 3;
2628 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2629 if (type == 0x04)
2630 {
2631 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2632 Change it into:
2633 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2634 BFD_ASSERT (rel->r_offset >= 3);
2635 BFD_ASSERT (bfd_get_8 (input_bfd,
2636 contents + rel->r_offset - 3)
2637 == 0x8d);
2638 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2639 val >>= 3;
2640 }
2641 else
2642 {
2643 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2644 Change it into:
2645 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2646 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2647 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2648 BFD_ASSERT (bfd_get_8 (input_bfd,
2649 contents + rel->r_offset + 9)
2650 == 0x90);
2651 roff = rel->r_offset - 2;
2652 }
2653 memcpy (contents + roff,
2654 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2655 contents[roff + 7] = 0x80 | (val & 7);
2656 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2657 contents + roff + 8);
2658 /* Skip R_386_PLT32. */
2659 rel++;
2660 continue;
2661 }
2662 break;
2663
2664 case R_386_TLS_LDM:
2665 if (! info->shared)
2666 {
2667 unsigned int val;
2668
2669 /* LD->LE transition:
2670 Ensure it is:
2671 leal foo(%reg), %eax; call ___tls_get_addr.
2672 We change it into:
2673 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2674 BFD_ASSERT (rel->r_offset >= 2);
2675 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2676 == 0x8d);
2677 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2678 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2679 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2680 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2681 == 0xe8);
2682 BFD_ASSERT (rel + 1 < relend);
2683 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2684 memcpy (contents + rel->r_offset - 2,
2685 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2686 /* Skip R_386_PLT32. */
2687 rel++;
2688 continue;
2689 }
2690
2691 if (htab->sgot == NULL)
2692 abort ();
2693
2694 off = htab->tls_ldm_got.offset;
2695 if (off & 1)
2696 off &= ~1;
2697 else
2698 {
2699 Elf_Internal_Rel outrel;
2700 Elf32_External_Rel *loc;
2701
2702 if (htab->srelgot == NULL)
2703 abort ();
2704
2705 outrel.r_offset = (htab->sgot->output_section->vma
2706 + htab->sgot->output_offset + off);
2707
2708 bfd_put_32 (output_bfd, 0,
2709 htab->sgot->contents + off);
2710 bfd_put_32 (output_bfd, 0,
2711 htab->sgot->contents + off + 4);
2712 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2713 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2714 loc += htab->srelgot->reloc_count++;
2715 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2716 htab->tls_ldm_got.offset |= 1;
2717 }
2718 relocation = htab->sgot->output_offset + off;
2719 unresolved_reloc = false;
2720 break;
2721
2722 case R_386_TLS_LDO_32:
2723 if (info->shared)
2724 relocation -= dtpoff_base (info);
2725 else
2726 /* When converting LDO to LE, we must negate. */
2727 relocation = -tpoff (info, relocation);
2728 break;
2729
2730 case R_386_TLS_LE_32:
2731 relocation = tpoff (info, relocation);
2732 break;
2733
2734 case R_386_TLS_LE:
2735 relocation = -tpoff (info, relocation);
2736 break;
2737
252b5132
RH		 2738 default:
2739 break;
2740 }
2741
8c694914
AM		 2742 /* FIXME: Why do we allow debugging sections to escape this error?
2743 More importantly, why do we not emit dynamic relocs for
2744 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2745 If we had emitted the dynamic reloc, we could remove the
2746 fudge here. */
2747 if (unresolved_reloc
2748 && !(info->shared
2749 && (input_section->flags & SEC_DEBUGGING) != 0
2750 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
83be169b
AM		 2751 (*_bfd_error_handler)
2752 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
8f615d07 2753 bfd_archive_filename (input_bfd),
83be169b
AM		 2754 bfd_get_section_name (input_bfd, input_section),
2755 (long) rel->r_offset,
2756 h->root.root.string);
2757
252b5132
RH		 2758 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2759 contents, rel->r_offset,
2760 relocation, (bfd_vma) 0);
2761
cf5c0c5b 2762 if (r != bfd_reloc_ok)
252b5132 2763 {
cf5c0c5b 2764 const char *name;
ffb2e45b 2765
cf5c0c5b
AM		 2766 if (h != NULL)
2767 name = h->root.root.string;
2768 else
2769 {
2770 name = bfd_elf_string_from_elf_section (input_bfd,
2771 symtab_hdr->sh_link,
2772 sym->st_name);
2773 if (name == NULL)
2774 return false;
2775 if (*name == '\0')
2776 name = bfd_section_name (input_bfd, sec);
2777 }
ffb2e45b 2778
cf5c0c5b
AM		 2779 if (r == bfd_reloc_overflow)
2780 {
cf5c0c5b
AM		 2781 if (! ((*info->callbacks->reloc_overflow)
2782 (info, name, howto->name, (bfd_vma) 0,
2783 input_bfd, input_section, rel->r_offset)))
2784 return false;
2785 }
2786 else
2787 {
2788 (*_bfd_error_handler)
2789 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2790 bfd_archive_filename (input_bfd),
2791 bfd_get_section_name (input_bfd, input_section),
2792 (long) rel->r_offset, name, (int) r);
2793 return false;
2794 }
252b5132
RH		 2795 }
2796 }
2797
2798 return true;
2799}
2800
2801/* Finish up dynamic symbol handling. We set the contents of various
2802 dynamic sections here. */
2803
2804static boolean
2805elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2806 bfd *output_bfd;
2807 struct bfd_link_info *info;
2808 struct elf_link_hash_entry *h;
2809 Elf_Internal_Sym *sym;
2810{
6725bdbf 2811 struct elf_i386_link_hash_table *htab;
252b5132 2812
6725bdbf 2813 htab = elf_i386_hash_table (info);
252b5132
RH		 2814
2815 if (h->plt.offset != (bfd_vma) -1)
2816 {
252b5132
RH		 2817 bfd_vma plt_index;
2818 bfd_vma got_offset;
2819 Elf_Internal_Rel rel;
0ac8d2ca 2820 Elf32_External_Rel *loc;
252b5132
RH		 2821
2822 /* This symbol has an entry in the procedure linkage table. Set
2823 it up. */
2824
ffb2e45b
AM		 2825 if (h->dynindx == -1
2826 || htab->splt == NULL
2827 || htab->sgotplt == NULL
2828 || htab->srelplt == NULL)
2829 abort ();
252b5132
RH		 2830
2831 /* Get the index in the procedure linkage table which
2832 corresponds to this symbol. This is the index of this symbol
2833 in all the symbols for which we are making plt entries. The
2834 first entry in the procedure linkage table is reserved. */
2835 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2836
2837 /* Get the offset into the .got table of the entry that
2838 corresponds to this function. Each .got entry is 4 bytes.
2839 The first three are reserved. */
2840 got_offset = (plt_index + 3) * 4;
2841
2842 /* Fill in the entry in the procedure linkage table. */
2843 if (! info->shared)
2844 {
6725bdbf 2845 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 2846 PLT_ENTRY_SIZE);
2847 bfd_put_32 (output_bfd,
6725bdbf
AM		 2848 (htab->sgotplt->output_section->vma
2849 + htab->sgotplt->output_offset
252b5132 2850 + got_offset),
6725bdbf 2851 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 2852 }
2853 else
2854 {
6725bdbf 2855 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 2856 PLT_ENTRY_SIZE);
2857 bfd_put_32 (output_bfd, got_offset,
6725bdbf 2858 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 2859 }
2860
2861 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 2862 htab->splt->contents + h->plt.offset + 7);
252b5132 2863 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 2864 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 2865
2866 /* Fill in the entry in the global offset table. */
2867 bfd_put_32 (output_bfd,
6725bdbf
AM		 2868 (htab->splt->output_section->vma
2869 + htab->splt->output_offset
252b5132
RH		 2870 + h->plt.offset
2871 + 6),
6725bdbf 2872 htab->sgotplt->contents + got_offset);
252b5132
RH		 2873
2874 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 2875 rel.r_offset = (htab->sgotplt->output_section->vma
2876 + htab->sgotplt->output_offset
252b5132
RH		 2877 + got_offset);
2878 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
0ac8d2ca
AM		 2879 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2880 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2881
2882 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2883 {
2884 /* Mark the symbol as undefined, rather than as defined in
51b64d56
AM		 2885 the .plt section. Leave the value alone. This is a clue
2886 for the dynamic linker, to make function pointer
2887 comparisons work between an application and shared
cedb70c5 2888 library. */
252b5132
RH		 2889 sym->st_shndx = SHN_UNDEF;
2890 }
2891 }
2892
13ae64f3
JJ		 2893 if (h->got.offset != (bfd_vma) -1
2894 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2895 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
252b5132 2896 {
252b5132 2897 Elf_Internal_Rel rel;
0ac8d2ca 2898 Elf32_External_Rel *loc;
252b5132
RH		 2899
2900 /* This symbol has an entry in the global offset table. Set it
2901 up. */
2902
ffb2e45b
AM		 2903 if (htab->sgot == NULL || htab->srelgot == NULL)
2904 abort ();
252b5132 2905
6725bdbf
AM		 2906 rel.r_offset = (htab->sgot->output_section->vma
2907 + htab->sgot->output_offset
dc810e39 2908 + (h->got.offset & ~(bfd_vma) 1));
252b5132 2909
dd5724d5
AM		 2910 /* If this is a static link, or it is a -Bsymbolic link and the
2911 symbol is defined locally or was forced to be local because
2912 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 2913 The entry in the global offset table will already have been
2914 initialized in the relocate_section function. */
6725bdbf
AM		 2915 if (info->shared
2916 && (info->symbolic
2917 || h->dynindx == -1
2918 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2919 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
dd5724d5 2920 {
6725bdbf 2921 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 2922 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2923 }
252b5132
RH		 2924 else
2925 {
dd5724d5 2926 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 2927 bfd_put_32 (output_bfd, (bfd_vma) 0,
2928 htab->sgot->contents + h->got.offset);
252b5132
RH		 2929 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2930 }
2931
0ac8d2ca
AM		 2932 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2933 loc += htab->srelgot->reloc_count++;
2934 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2935 }
2936
791987af 2937 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132 2938 {
252b5132 2939 Elf_Internal_Rel rel;
0ac8d2ca 2940 Elf32_External_Rel *loc;
252b5132
RH		 2941
2942 /* This symbol needs a copy reloc. Set it up. */
2943
ffb2e45b
AM		 2944 if (h->dynindx == -1
2945 || (h->root.type != bfd_link_hash_defined
2946 && h->root.type != bfd_link_hash_defweak)
2947 || htab->srelbss == NULL)
2948 abort ();
252b5132
RH		 2949
2950 rel.r_offset = (h->root.u.def.value
2951 + h->root.u.def.section->output_section->vma
2952 + h->root.u.def.section->output_offset);
2953 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
0ac8d2ca
AM		 2954 loc = (Elf32_External_Rel *) htab->srelbss->contents;
2955 loc += htab->srelbss->reloc_count++;
2956 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 2957 }
2958
2959 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2960 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2961 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2962 sym->st_shndx = SHN_ABS;
2963
2964 return true;
2965}
2966
38701953
AM		 2967/* Used to decide how to sort relocs in an optimal manner for the
2968 dynamic linker, before writing them out. */
2969
2970static enum elf_reloc_type_class
2971elf_i386_reloc_type_class (rela)
2972 const Elf_Internal_Rela *rela;
2973{
2974 switch ((int) ELF32_R_TYPE (rela->r_info))
2975 {
2976 case R_386_RELATIVE:
2977 return reloc_class_relative;
2978 case R_386_JUMP_SLOT:
2979 return reloc_class_plt;
2980 case R_386_COPY:
2981 return reloc_class_copy;
2982 default:
2983 return reloc_class_normal;
2984 }
2985}
2986
252b5132
RH		 2987/* Finish up the dynamic sections. */
2988
2989static boolean
2990elf_i386_finish_dynamic_sections (output_bfd, info)
2991 bfd *output_bfd;
2992 struct bfd_link_info *info;
2993{
6725bdbf 2994 struct elf_i386_link_hash_table *htab;
252b5132 2995 bfd *dynobj;
252b5132
RH		 2996 asection *sdyn;
2997
6725bdbf 2998 htab = elf_i386_hash_table (info);
ebe50bae 2999 dynobj = htab->elf.dynobj;
252b5132
RH		 3000 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3001
ebe50bae 3002 if (htab->elf.dynamic_sections_created)
252b5132 3003 {
252b5132
RH		 3004 Elf32_External_Dyn *dyncon, *dynconend;
3005
ffb2e45b
AM		 3006 if (sdyn == NULL || htab->sgot == NULL)
3007 abort ();
252b5132
RH		 3008
3009 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3010 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3011 for (; dyncon < dynconend; dyncon++)
3012 {
3013 Elf_Internal_Dyn dyn;
51b64d56 3014 asection *s;
252b5132
RH		 3015
3016 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3017
3018 switch (dyn.d_tag)
3019 {
3020 default:
0ac8d2ca 3021 continue;
252b5132
RH		 3022
3023 case DT_PLTGOT:
6725bdbf 3024 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
6725bdbf
AM		 3025 break;
3026
252b5132 3027 case DT_JMPREL:
6725bdbf 3028 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
252b5132
RH		 3029 break;
3030
3031 case DT_PLTRELSZ:
51b64d56
AM		 3032 s = htab->srelplt->output_section;
3033 if (s->_cooked_size != 0)
3034 dyn.d_un.d_val = s->_cooked_size;
252b5132 3035 else
51b64d56 3036 dyn.d_un.d_val = s->_raw_size;
252b5132
RH		 3037 break;
3038
3039 case DT_RELSZ:
3040 /* My reading of the SVR4 ABI indicates that the
3041 procedure linkage table relocs (DT_JMPREL) should be
3042 included in the overall relocs (DT_REL). This is
3043 what Solaris does. However, UnixWare can not handle
3044 that case. Therefore, we override the DT_RELSZ entry
3045 here to make it not include the JMPREL relocs. Since
3046 the linker script arranges for .rel.plt to follow all
3047 other relocation sections, we don't have to worry
3048 about changing the DT_REL entry. */
6725bdbf 3049 if (htab->srelplt != NULL)
252b5132 3050 {
51b64d56
AM		 3051 s = htab->srelplt->output_section;
3052 if (s->_cooked_size != 0)
3053 dyn.d_un.d_val -= s->_cooked_size;
252b5132 3054 else
51b64d56 3055 dyn.d_un.d_val -= s->_raw_size;
252b5132 3056 }
252b5132
RH		 3057 break;
3058 }
0ac8d2ca
AM		 3059
3060 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3061 }
3062
3063 /* Fill in the first entry in the procedure linkage table. */
6725bdbf 3064 if (htab->splt && htab->splt->_raw_size > 0)
252b5132
RH		 3065 {
3066 if (info->shared)
6725bdbf
AM		 3067 memcpy (htab->splt->contents,
3068 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3069 else
3070 {
6725bdbf
AM		 3071 memcpy (htab->splt->contents,
3072 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3073 bfd_put_32 (output_bfd,
6725bdbf
AM		 3074 (htab->sgotplt->output_section->vma
3075 + htab->sgotplt->output_offset
3076 + 4),
3077 htab->splt->contents + 2);
252b5132 3078 bfd_put_32 (output_bfd,
6725bdbf
AM		 3079 (htab->sgotplt->output_section->vma
3080 + htab->sgotplt->output_offset
3081 + 8),
3082 htab->splt->contents + 8);
252b5132
RH		 3083 }
3084
3085 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3086 really seem like the right value. */
6725bdbf
AM		 3087 elf_section_data (htab->splt->output_section)
3088 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3089 }
3090 }
3091
12d0ee4a 3092 if (htab->sgotplt)
252b5132 3093 {
12d0ee4a
AM		 3094 /* Fill in the first three entries in the global offset table. */
3095 if (htab->sgotplt->_raw_size > 0)
3096 {
3097 bfd_put_32 (output_bfd,
3098 (sdyn == NULL ? (bfd_vma) 0
3099 : sdyn->output_section->vma + sdyn->output_offset),
3100 htab->sgotplt->contents);
3101 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3102 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3103 }
252b5132 3104
12d0ee4a
AM		 3105 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3106 }
252b5132
RH		 3107 return true;
3108}
3109
3110#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3111#define TARGET_LITTLE_NAME "elf32-i386"
3112#define ELF_ARCH bfd_arch_i386
3113#define ELF_MACHINE_CODE EM_386
3114#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 3115
3116#define elf_backend_can_gc_sections 1
51b64d56 3117#define elf_backend_can_refcount 1
252b5132
RH		 3118#define elf_backend_want_got_plt 1
3119#define elf_backend_plt_readonly 1
3120#define elf_backend_want_plt_sym 0
3121#define elf_backend_got_header_size 12
3122#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3123
dd5724d5
AM		 3124#define elf_info_to_howto elf_i386_info_to_howto
3125#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3126
13ae64f3
JJ		 3127#define bfd_elf32_mkobject elf_i386_mkobject
3128#define elf_backend_object_p elf_i386_object_p
3129
dd5724d5
AM		 3130#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3131#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3132#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3133
3134#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3135#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3136#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3137#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3138#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3139#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3140#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3141#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3142#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3143#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3144#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3145#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3146#define elf_backend_relocate_section elf_i386_relocate_section
3147#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
dd5724d5 3148
caf47ea6 3149#ifndef ELF32_I386_C_INCLUDED
252b5132 3150#include "elf32-target.h"
caf47ea6 3151#endif
A mirror of the official binutils-gdb repository