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