?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2001-02-09 Bo Thorsen <bo@suse.de>
[binutils.git] / bfd / elf32-i386.c
blobb433c25d63527f81b00200c8ec8ebd1d1edf812d
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 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
27 static reloc_howto_type *elf_i386_reloc_type_lookup
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
29 static void elf_i386_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31 static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
33 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
34 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
37 PARAMS ((bfd *));
38 static boolean elf_i386_check_relocs
39 PARAMS ((bfd *, struct bfd_link_info *, asection *,
40 const Elf_Internal_Rela *));
41 static boolean elf_i386_adjust_dynamic_symbol
42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
43 static boolean elf_i386_size_dynamic_sections
44 PARAMS ((bfd *, struct bfd_link_info *));
45 static boolean elf_i386_relocate_section
46 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
47 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
48 static boolean elf_i386_finish_dynamic_symbol
49 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
50 Elf_Internal_Sym *));
51 static boolean elf_i386_finish_dynamic_sections
52 PARAMS ((bfd *, struct bfd_link_info *));
53
54 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
55
56 #include "elf/i386.h"
57
58 static reloc_howto_type elf_howto_table[]=
59 {
60 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_386_NONE",
62 true, 0x00000000, 0x00000000, false),
63 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_386_32",
65 true, 0xffffffff, 0xffffffff, false),
66 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_386_PC32",
68 true, 0xffffffff, 0xffffffff, true),
69 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_386_GOT32",
71 true, 0xffffffff, 0xffffffff, false),
72 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_386_PLT32",
74 true, 0xffffffff, 0xffffffff, true),
75 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_386_COPY",
77 true, 0xffffffff, 0xffffffff, false),
78 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
80 true, 0xffffffff, 0xffffffff, false),
81 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
83 true, 0xffffffff, 0xffffffff, false),
84 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_386_RELATIVE",
86 true, 0xffffffff, 0xffffffff, false),
87 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_386_GOTOFF",
89 true, 0xffffffff, 0xffffffff, false),
90 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_386_GOTPC",
92 true, 0xffffffff, 0xffffffff, true),
93
94 /* We have a gap in the reloc numbers here.
95 R_386_standard counts the number up to this point, and
96 R_386_ext_offset is the value to subtract from a reloc type of
97 R_386_16 thru R_386_PC8 to form an index into this table. */
98 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
99 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
100
101 /* The remaining relocs are a GNU extension. */
102 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_16",
104 true, 0xffff, 0xffff, false),
105 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_PC16",
107 true, 0xffff, 0xffff, true),
108 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_8",
110 true, 0xff, 0xff, false),
111 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_386_PC8",
113 true, 0xff, 0xff, true),
114
115 /* Another gap. */
116 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
117 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
118
119 /* GNU extension to record C++ vtable hierarchy. */
120 HOWTO (R_386_GNU_VTINHERIT, /* type */
121 0, /* rightshift */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
123 0, /* bitsize */
124 false, /* pc_relative */
125 0, /* bitpos */
126 complain_overflow_dont, /* complain_on_overflow */
127 NULL, /* special_function */
128 "R_386_GNU_VTINHERIT", /* name */
129 false, /* partial_inplace */
130 0, /* src_mask */
131 0, /* dst_mask */
132 false),
133
134 /* GNU extension to record C++ vtable member usage. */
135 HOWTO (R_386_GNU_VTENTRY, /* type */
136 0, /* rightshift */
137 2, /* size (0 = byte, 1 = short, 2 = long) */
138 0, /* bitsize */
139 false, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_dont, /* complain_on_overflow */
142 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
143 "R_386_GNU_VTENTRY", /* name */
144 false, /* partial_inplace */
145 0, /* src_mask */
146 0, /* dst_mask */
147 false)
148
149 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
150
151 };
152
153 #ifdef DEBUG_GEN_RELOC
154 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
155 #else
156 #define TRACE(str)
157 #endif
158
159 static reloc_howto_type *
160 elf_i386_reloc_type_lookup (abfd, code)
161 bfd *abfd ATTRIBUTE_UNUSED;
162 bfd_reloc_code_real_type code;
163 {
164 switch (code)
165 {
166 case BFD_RELOC_NONE:
167 TRACE ("BFD_RELOC_NONE");
168 return &elf_howto_table[(unsigned int) R_386_NONE ];
169
170 case BFD_RELOC_32:
171 TRACE ("BFD_RELOC_32");
172 return &elf_howto_table[(unsigned int) R_386_32 ];
173
174 case BFD_RELOC_CTOR:
175 TRACE ("BFD_RELOC_CTOR");
176 return &elf_howto_table[(unsigned int) R_386_32 ];
177
178 case BFD_RELOC_32_PCREL:
179 TRACE ("BFD_RELOC_PC32");
180 return &elf_howto_table[(unsigned int) R_386_PC32 ];
181
182 case BFD_RELOC_386_GOT32:
183 TRACE ("BFD_RELOC_386_GOT32");
184 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
185
186 case BFD_RELOC_386_PLT32:
187 TRACE ("BFD_RELOC_386_PLT32");
188 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
189
190 case BFD_RELOC_386_COPY:
191 TRACE ("BFD_RELOC_386_COPY");
192 return &elf_howto_table[(unsigned int) R_386_COPY ];
193
194 case BFD_RELOC_386_GLOB_DAT:
195 TRACE ("BFD_RELOC_386_GLOB_DAT");
196 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
197
198 case BFD_RELOC_386_JUMP_SLOT:
199 TRACE ("BFD_RELOC_386_JUMP_SLOT");
200 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
201
202 case BFD_RELOC_386_RELATIVE:
203 TRACE ("BFD_RELOC_386_RELATIVE");
204 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
205
206 case BFD_RELOC_386_GOTOFF:
207 TRACE ("BFD_RELOC_386_GOTOFF");
208 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
209
210 case BFD_RELOC_386_GOTPC:
211 TRACE ("BFD_RELOC_386_GOTPC");
212 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
213
214 /* The remaining relocs are a GNU extension. */
215 case BFD_RELOC_16:
216 TRACE ("BFD_RELOC_16");
217 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
218
219 case BFD_RELOC_16_PCREL:
220 TRACE ("BFD_RELOC_16_PCREL");
221 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
222
223 case BFD_RELOC_8:
224 TRACE ("BFD_RELOC_8");
225 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
226
227 case BFD_RELOC_8_PCREL:
228 TRACE ("BFD_RELOC_8_PCREL");
229 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
230
231 case BFD_RELOC_VTABLE_INHERIT:
232 TRACE ("BFD_RELOC_VTABLE_INHERIT");
233 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
234 - R_386_vt_offset];
235
236 case BFD_RELOC_VTABLE_ENTRY:
237 TRACE ("BFD_RELOC_VTABLE_ENTRY");
238 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
239 - R_386_vt_offset];
240
241 default:
242 break;
243 }
244
245 TRACE ("Unknown");
246 return 0;
247 }
248
249 static void
250 elf_i386_info_to_howto (abfd, cache_ptr, dst)
251 bfd *abfd ATTRIBUTE_UNUSED;
252 arelent *cache_ptr ATTRIBUTE_UNUSED;
253 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
254 {
255 abort ();
256 }
257
258 static void
259 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
260 bfd *abfd ATTRIBUTE_UNUSED;
261 arelent *cache_ptr;
262 Elf32_Internal_Rel *dst;
263 {
264 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
265 unsigned int indx;
266
267 if ((indx = r_type) >= R_386_standard
268 && ((indx = r_type - R_386_ext_offset) - R_386_standard
269 >= R_386_ext - R_386_standard)
270 && ((indx = r_type - R_386_vt_offset) - R_386_ext
271 >= R_386_vt - R_386_ext))
272 {
273 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
274 bfd_get_filename (abfd), (int) r_type);
275 indx = (unsigned int) R_386_NONE;
276 }
277 cache_ptr->howto = &elf_howto_table[indx];
278 }
279
280 /* Return whether a symbol name implies a local label. The UnixWare
281 2.1 cc generates temporary symbols that start with .X, so we
282 recognize them here. FIXME: do other SVR4 compilers also use .X?.
283 If so, we should move the .X recognition into
284 _bfd_elf_is_local_label_name. */
285
286 static boolean
287 elf_i386_is_local_label_name (abfd, name)
288 bfd *abfd;
289 const char *name;
290 {
291 if (name[0] == '.' && name[1] == 'X')
292 return true;
293
294 return _bfd_elf_is_local_label_name (abfd, name);
295 }
296 \f
297 /* Functions for the i386 ELF linker. */
298
299 /* The name of the dynamic interpreter. This is put in the .interp
300 section. */
301
302 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
303
304 /* The size in bytes of an entry in the procedure linkage table. */
305
306 #define PLT_ENTRY_SIZE 16
307
308 /* The first entry in an absolute procedure linkage table looks like
309 this. See the SVR4 ABI i386 supplement to see how this works. */
310
311 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
312 {
313 0xff, 0x35, /* pushl contents of address */
314 0, 0, 0, 0, /* replaced with address of .got + 4. */
315 0xff, 0x25, /* jmp indirect */
316 0, 0, 0, 0, /* replaced with address of .got + 8. */
317 0, 0, 0, 0 /* pad out to 16 bytes. */
318 };
319
320 /* Subsequent entries in an absolute procedure linkage table look like
321 this. */
322
323 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
324 {
325 0xff, 0x25, /* jmp indirect */
326 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
327 0x68, /* pushl immediate */
328 0, 0, 0, 0, /* replaced with offset into relocation table. */
329 0xe9, /* jmp relative */
330 0, 0, 0, 0 /* replaced with offset to start of .plt. */
331 };
332
333 /* The first entry in a PIC procedure linkage table look like this. */
334
335 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
336 {
337 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
338 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
339 0, 0, 0, 0 /* pad out to 16 bytes. */
340 };
341
342 /* Subsequent entries in a PIC procedure linkage table look like this. */
343
344 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
345 {
346 0xff, 0xa3, /* jmp *offset(%ebx) */
347 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
348 0x68, /* pushl immediate */
349 0, 0, 0, 0, /* replaced with offset into relocation table. */
350 0xe9, /* jmp relative */
351 0, 0, 0, 0 /* replaced with offset to start of .plt. */
352 };
353
354 /* The i386 linker needs to keep track of the number of relocs that it
355 decides to copy in check_relocs for each symbol. This is so that
356 it can discard PC relative relocs if it doesn't need them when
357 linking with -Bsymbolic. We store the information in a field
358 extending the regular ELF linker hash table. */
359
360 /* This structure keeps track of the number of PC relative relocs we
361 have copied for a given symbol. */
362
363 struct elf_i386_pcrel_relocs_copied
364 {
365 /* Next section. */
366 struct elf_i386_pcrel_relocs_copied *next;
367 /* A section in dynobj. */
368 asection *section;
369 /* Number of relocs copied in this section. */
370 bfd_size_type count;
371 };
372
373 /* i386 ELF linker hash entry. */
374
375 struct elf_i386_link_hash_entry
376 {
377 struct elf_link_hash_entry root;
378
379 /* Number of PC relative relocs copied for this symbol. */
380 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
381 };
382
383 /* i386 ELF linker hash table. */
384
385 struct elf_i386_link_hash_table
386 {
387 struct elf_link_hash_table root;
388 };
389
390 /* Declare this now that the above structures are defined. */
391
392 static boolean elf_i386_discard_copies
393 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
394
395 /* Traverse an i386 ELF linker hash table. */
396
397 #define elf_i386_link_hash_traverse(table, func, info) \
398 (elf_link_hash_traverse \
399 (&(table)->root, \
400 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
401 (info)))
402
403 /* Get the i386 ELF linker hash table from a link_info structure. */
404
405 #define elf_i386_hash_table(p) \
406 ((struct elf_i386_link_hash_table *) ((p)->hash))
407
408 /* Create an entry in an i386 ELF linker hash table. */
409
410 static struct bfd_hash_entry *
411 elf_i386_link_hash_newfunc (entry, table, string)
412 struct bfd_hash_entry *entry;
413 struct bfd_hash_table *table;
414 const char *string;
415 {
416 struct elf_i386_link_hash_entry *ret =
417 (struct elf_i386_link_hash_entry *) entry;
418
419 /* Allocate the structure if it has not already been allocated by a
420 subclass. */
421 if (ret == (struct elf_i386_link_hash_entry *) NULL)
422 ret = ((struct elf_i386_link_hash_entry *)
423 bfd_hash_allocate (table,
424 sizeof (struct elf_i386_link_hash_entry)));
425 if (ret == (struct elf_i386_link_hash_entry *) NULL)
426 return (struct bfd_hash_entry *) ret;
427
428 /* Call the allocation method of the superclass. */
429 ret = ((struct elf_i386_link_hash_entry *)
430 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
431 table, string));
432 if (ret != (struct elf_i386_link_hash_entry *) NULL)
433 {
434 ret->pcrel_relocs_copied = NULL;
435 }
436
437 return (struct bfd_hash_entry *) ret;
438 }
439
440 /* Create an i386 ELF linker hash table. */
441
442 static struct bfd_link_hash_table *
443 elf_i386_link_hash_table_create (abfd)
444 bfd *abfd;
445 {
446 struct elf_i386_link_hash_table *ret;
447
448 ret = ((struct elf_i386_link_hash_table *)
449 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
450 if (ret == (struct elf_i386_link_hash_table *) NULL)
451 return NULL;
452
453 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
454 elf_i386_link_hash_newfunc))
455 {
456 bfd_release (abfd, ret);
457 return NULL;
458 }
459
460 return &ret->root.root;
461 }
462
463 /* Look through the relocs for a section during the first phase, and
464 allocate space in the global offset table or procedure linkage
465 table. */
466
467 static boolean
468 elf_i386_check_relocs (abfd, info, sec, relocs)
469 bfd *abfd;
470 struct bfd_link_info *info;
471 asection *sec;
472 const Elf_Internal_Rela *relocs;
473 {
474 bfd *dynobj;
475 Elf_Internal_Shdr *symtab_hdr;
476 struct elf_link_hash_entry **sym_hashes;
477 bfd_signed_vma *local_got_refcounts;
478 const Elf_Internal_Rela *rel;
479 const Elf_Internal_Rela *rel_end;
480 asection *sgot;
481 asection *srelgot;
482 asection *sreloc;
483
484 if (info->relocateable)
485 return true;
486
487 dynobj = elf_hash_table (info)->dynobj;
488 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
489 sym_hashes = elf_sym_hashes (abfd);
490 local_got_refcounts = elf_local_got_refcounts (abfd);
491
492 sgot = NULL;
493 srelgot = NULL;
494 sreloc = NULL;
495
496 rel_end = relocs + sec->reloc_count;
497 for (rel = relocs; rel < rel_end; rel++)
498 {
499 unsigned long r_symndx;
500 struct elf_link_hash_entry *h;
501
502 r_symndx = ELF32_R_SYM (rel->r_info);
503
504 if (r_symndx < symtab_hdr->sh_info)
505 h = NULL;
506 else
507 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
508
509 /* Some relocs require a global offset table. */
510 if (dynobj == NULL)
511 {
512 switch (ELF32_R_TYPE (rel->r_info))
513 {
514 case R_386_GOT32:
515 case R_386_GOTOFF:
516 case R_386_GOTPC:
517 elf_hash_table (info)->dynobj = dynobj = abfd;
518 if (! _bfd_elf_create_got_section (dynobj, info))
519 return false;
520 break;
521
522 default:
523 break;
524 }
525 }
526
527 switch (ELF32_R_TYPE (rel->r_info))
528 {
529 case R_386_GOT32:
530 /* This symbol requires a global offset table entry. */
531
532 if (sgot == NULL)
533 {
534 sgot = bfd_get_section_by_name (dynobj, ".got");
535 BFD_ASSERT (sgot != NULL);
536 }
537
538 if (srelgot == NULL
539 && (h != NULL || info->shared))
540 {
541 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
542 if (srelgot == NULL)
543 {
544 srelgot = bfd_make_section (dynobj, ".rel.got");
545 if (srelgot == NULL
546 || ! bfd_set_section_flags (dynobj, srelgot,
547 (SEC_ALLOC
548 | SEC_LOAD
549 | SEC_HAS_CONTENTS
550 | SEC_IN_MEMORY
551 | SEC_LINKER_CREATED
552 | SEC_READONLY))
553 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
554 return false;
555 }
556 }
557
558 if (h != NULL)
559 {
560 if (h->got.refcount == -1)
561 {
562 h->got.refcount = 1;
563
564 /* Make sure this symbol is output as a dynamic symbol. */
565 if (h->dynindx == -1)
566 {
567 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
568 return false;
569 }
570
571 sgot->_raw_size += 4;
572 srelgot->_raw_size += sizeof (Elf32_External_Rel);
573 }
574 else
575 h->got.refcount += 1;
576 }
577 else
578 {
579 /* This is a global offset table entry for a local symbol. */
580 if (local_got_refcounts == NULL)
581 {
582 size_t size;
583
584 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
585 local_got_refcounts = ((bfd_signed_vma *)
586 bfd_alloc (abfd, size));
587 if (local_got_refcounts == NULL)
588 return false;
589 elf_local_got_refcounts (abfd) = local_got_refcounts;
590 memset (local_got_refcounts, -1, size);
591 }
592 if (local_got_refcounts[r_symndx] == -1)
593 {
594 local_got_refcounts[r_symndx] = 1;
595
596 sgot->_raw_size += 4;
597 if (info->shared)
598 {
599 /* If we are generating a shared object, we need to
600 output a R_386_RELATIVE reloc so that the dynamic
601 linker can adjust this GOT entry. */
602 srelgot->_raw_size += sizeof (Elf32_External_Rel);
603 }
604 }
605 else
606 local_got_refcounts[r_symndx] += 1;
607 }
608 break;
609
610 case R_386_PLT32:
611 /* This symbol requires a procedure linkage table entry. We
612 actually build the entry in adjust_dynamic_symbol,
613 because this might be a case of linking PIC code which is
614 never referenced by a dynamic object, in which case we
615 don't need to generate a procedure linkage table entry
616 after all. */
617
618 /* If this is a local symbol, we resolve it directly without
619 creating a procedure linkage table entry. */
620 if (h == NULL)
621 continue;
622
623 if (h->plt.refcount == -1)
624 {
625 h->plt.refcount = 1;
626 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
627 }
628 else
629 h->plt.refcount += 1;
630 break;
631
632 case R_386_32:
633 case R_386_PC32:
634 if (h != NULL)
635 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
636
637 /* If we are creating a shared library, and this is a reloc
638 against a global symbol, or a non PC relative reloc
639 against a local symbol, then we need to copy the reloc
640 into the shared library. However, if we are linking with
641 -Bsymbolic, we do not need to copy a reloc against a
642 global symbol which is defined in an object we are
643 including in the link (i.e., DEF_REGULAR is set). At
644 this point we have not seen all the input files, so it is
645 possible that DEF_REGULAR is not set now but will be set
646 later (it is never cleared). We account for that
647 possibility below by storing information in the
648 pcrel_relocs_copied field of the hash table entry.
649 A similar situation occurs when creating shared libraries
650 and symbol visibility changes render the symbol local. */
651 if (info->shared
652 && (sec->flags & SEC_ALLOC) != 0
653 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
654 || (h != NULL
655 && (! info->symbolic
656 || (h->elf_link_hash_flags
657 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
658 {
659 /* When creating a shared object, we must copy these
660 reloc types into the output file. We create a reloc
661 section in dynobj and make room for this reloc. */
662 if (sreloc == NULL)
663 {
664 const char *name;
665
666 name = (bfd_elf_string_from_elf_section
667 (abfd,
668 elf_elfheader (abfd)->e_shstrndx,
669 elf_section_data (sec)->rel_hdr.sh_name));
670 if (name == NULL)
671 return false;
672
673 if (strncmp (name, ".rel", 4) != 0
674 || strcmp (bfd_get_section_name (abfd, sec),
675 name + 4) != 0)
676 {
677 if (abfd->my_archive)
678 (*_bfd_error_handler) (_("%s(%s): bad relocation section name `%s\'"),
679 bfd_get_filename (abfd->my_archive),
680 bfd_get_filename (abfd),
681 name);
682 else
683 (*_bfd_error_handler) (_("%s: bad relocation section name `%s\'"),
684 bfd_get_filename (abfd),
685 name);
686 }
687
688 sreloc = bfd_get_section_by_name (dynobj, name);
689 if (sreloc == NULL)
690 {
691 flagword flags;
692
693 sreloc = bfd_make_section (dynobj, name);
694 flags = (SEC_HAS_CONTENTS | SEC_READONLY
695 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
696 if ((sec->flags & SEC_ALLOC) != 0)
697 flags |= SEC_ALLOC | SEC_LOAD;
698 if (sreloc == NULL
699 || ! bfd_set_section_flags (dynobj, sreloc, flags)
700 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
701 return false;
702 }
703 }
704
705 sreloc->_raw_size += sizeof (Elf32_External_Rel);
706
707 /* If this is a global symbol, we count the number of PC
708 relative relocations we have entered for this symbol,
709 so that we can discard them later as necessary. Note
710 that this function is only called if we are using an
711 elf_i386 linker hash table, which means that h is
712 really a pointer to an elf_i386_link_hash_entry. */
713 if (h != NULL
714 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
715 {
716 struct elf_i386_link_hash_entry *eh;
717 struct elf_i386_pcrel_relocs_copied *p;
718
719 eh = (struct elf_i386_link_hash_entry *) h;
720
721 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
722 if (p->section == sreloc)
723 break;
724
725 if (p == NULL)
726 {
727 p = ((struct elf_i386_pcrel_relocs_copied *)
728 bfd_alloc (dynobj, sizeof *p));
729 if (p == NULL)
730 return false;
731 p->next = eh->pcrel_relocs_copied;
732 eh->pcrel_relocs_copied = p;
733 p->section = sreloc;
734 p->count = 0;
735 }
736
737 ++p->count;
738 }
739 }
740
741 break;
742
743 /* This relocation describes the C++ object vtable hierarchy.
744 Reconstruct it for later use during GC. */
745 case R_386_GNU_VTINHERIT:
746 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
747 return false;
748 break;
749
750 /* This relocation describes which C++ vtable entries are actually
751 used. Record for later use during GC. */
752 case R_386_GNU_VTENTRY:
753 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
754 return false;
755 break;
756
757 default:
758 break;
759 }
760 }
761
762 return true;
763 }
764
765 /* Return the section that should be marked against GC for a given
766 relocation. */
767
768 static asection *
769 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
770 bfd *abfd;
771 struct bfd_link_info *info ATTRIBUTE_UNUSED;
772 Elf_Internal_Rela *rel;
773 struct elf_link_hash_entry *h;
774 Elf_Internal_Sym *sym;
775 {
776 if (h != NULL)
777 {
778 switch (ELF32_R_TYPE (rel->r_info))
779 {
780 case R_386_GNU_VTINHERIT:
781 case R_386_GNU_VTENTRY:
782 break;
783
784 default:
785 switch (h->root.type)
786 {
787 case bfd_link_hash_defined:
788 case bfd_link_hash_defweak:
789 return h->root.u.def.section;
790
791 case bfd_link_hash_common:
792 return h->root.u.c.p->section;
793
794 default:
795 break;
796 }
797 }
798 }
799 else
800 {
801 if (!(elf_bad_symtab (abfd)
802 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
803 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
804 && sym->st_shndx != SHN_COMMON))
805 {
806 return bfd_section_from_elf_index (abfd, sym->st_shndx);
807 }
808 }
809
810 return NULL;
811 }
812
813 /* Update the got entry reference counts for the section being removed. */
814
815 static boolean
816 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
817 bfd *abfd;
818 struct bfd_link_info *info ATTRIBUTE_UNUSED;
819 asection *sec;
820 const Elf_Internal_Rela *relocs;
821 {
822 Elf_Internal_Shdr *symtab_hdr;
823 struct elf_link_hash_entry **sym_hashes;
824 bfd_signed_vma *local_got_refcounts;
825 const Elf_Internal_Rela *rel, *relend;
826 unsigned long r_symndx;
827 struct elf_link_hash_entry *h;
828 bfd *dynobj;
829 asection *sgot;
830 asection *srelgot;
831
832 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
833 sym_hashes = elf_sym_hashes (abfd);
834 local_got_refcounts = elf_local_got_refcounts (abfd);
835
836 dynobj = elf_hash_table (info)->dynobj;
837 if (dynobj == NULL)
838 return true;
839
840 sgot = bfd_get_section_by_name (dynobj, ".got");
841 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
842
843 relend = relocs + sec->reloc_count;
844 for (rel = relocs; rel < relend; rel++)
845 switch (ELF32_R_TYPE (rel->r_info))
846 {
847 case R_386_GOT32:
848 case R_386_GOTOFF:
849 case R_386_GOTPC:
850 r_symndx = ELF32_R_SYM (rel->r_info);
851 if (r_symndx >= symtab_hdr->sh_info)
852 {
853 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
854 if (h->got.refcount > 0)
855 {
856 h->got.refcount -= 1;
857 if (h->got.refcount == 0)
858 {
859 sgot->_raw_size -= 4;
860 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
861 }
862 }
863 }
864 else if (local_got_refcounts != NULL)
865 {
866 if (local_got_refcounts[r_symndx] > 0)
867 {
868 local_got_refcounts[r_symndx] -= 1;
869 if (local_got_refcounts[r_symndx] == 0)
870 {
871 sgot->_raw_size -= 4;
872 if (info->shared)
873 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
874 }
875 }
876 }
877 break;
878
879 case R_386_PLT32:
880 r_symndx = ELF32_R_SYM (rel->r_info);
881 if (r_symndx >= symtab_hdr->sh_info)
882 {
883 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
884 if (h->plt.refcount > 0)
885 h->plt.refcount -= 1;
886 }
887 break;
888
889 default:
890 break;
891 }
892
893 return true;
894 }
895
896 /* Adjust a symbol defined by a dynamic object and referenced by a
897 regular object. The current definition is in some section of the
898 dynamic object, but we're not including those sections. We have to
899 change the definition to something the rest of the link can
900 understand. */
901
902 static boolean
903 elf_i386_adjust_dynamic_symbol (info, h)
904 struct bfd_link_info *info;
905 struct elf_link_hash_entry *h;
906 {
907 bfd *dynobj;
908 asection *s;
909 unsigned int power_of_two;
910
911 dynobj = elf_hash_table (info)->dynobj;
912
913 /* Make sure we know what is going on here. */
914 BFD_ASSERT (dynobj != NULL
915 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
916 || h->weakdef != NULL
917 || ((h->elf_link_hash_flags
918 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
919 && (h->elf_link_hash_flags
920 & ELF_LINK_HASH_REF_REGULAR) != 0
921 && (h->elf_link_hash_flags
922 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
923
924 /* If this is a function, put it in the procedure linkage table. We
925 will fill in the contents of the procedure linkage table later,
926 when we know the address of the .got section. */
927 if (h->type == STT_FUNC
928 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
929 {
930 if ((! info->shared
931 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
932 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
933 || (info->shared && h->plt.refcount <= 0))
934 {
935 /* This case can occur if we saw a PLT32 reloc in an input
936 file, but the symbol was never referred to by a dynamic
937 object, or if all references were garbage collected. In
938 such a case, we don't actually need to build a procedure
939 linkage table, and we can just do a PC32 reloc instead. */
940 h->plt.offset = (bfd_vma) -1;
941 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
942 return true;
943 }
944
945 /* Make sure this symbol is output as a dynamic symbol. */
946 if (h->dynindx == -1)
947 {
948 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
949 return false;
950 }
951
952 s = bfd_get_section_by_name (dynobj, ".plt");
953 BFD_ASSERT (s != NULL);
954
955 /* If this is the first .plt entry, make room for the special
956 first entry. */
957 if (s->_raw_size == 0)
958 s->_raw_size += PLT_ENTRY_SIZE;
959
960 /* If this symbol is not defined in a regular file, and we are
961 not generating a shared library, then set the symbol to this
962 location in the .plt. This is required to make function
963 pointers compare as equal between the normal executable and
964 the shared library. */
965 if (! info->shared
966 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
967 {
968 h->root.u.def.section = s;
969 h->root.u.def.value = s->_raw_size;
970 }
971
972 h->plt.offset = s->_raw_size;
973
974 /* Make room for this entry. */
975 s->_raw_size += PLT_ENTRY_SIZE;
976
977 /* We also need to make an entry in the .got.plt section, which
978 will be placed in the .got section by the linker script. */
979 s = bfd_get_section_by_name (dynobj, ".got.plt");
980 BFD_ASSERT (s != NULL);
981 s->_raw_size += 4;
982
983 /* We also need to make an entry in the .rel.plt section. */
984 s = bfd_get_section_by_name (dynobj, ".rel.plt");
985 BFD_ASSERT (s != NULL);
986 s->_raw_size += sizeof (Elf32_External_Rel);
987
988 return true;
989 }
990
991 /* If this is a weak symbol, and there is a real definition, the
992 processor independent code will have arranged for us to see the
993 real definition first, and we can just use the same value. */
994 if (h->weakdef != NULL)
995 {
996 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
997 || h->weakdef->root.type == bfd_link_hash_defweak);
998 h->root.u.def.section = h->weakdef->root.u.def.section;
999 h->root.u.def.value = h->weakdef->root.u.def.value;
1000 return true;
1001 }
1002
1003 /* This is a reference to a symbol defined by a dynamic object which
1004 is not a function. */
1005
1006 /* If we are creating a shared library, we must presume that the
1007 only references to the symbol are via the global offset table.
1008 For such cases we need not do anything here; the relocations will
1009 be handled correctly by relocate_section. */
1010 if (info->shared)
1011 return true;
1012
1013 /* If there are no references to this symbol that do not use the
1014 GOT, we don't need to generate a copy reloc. */
1015 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1016 return true;
1017
1018 /* We must allocate the symbol in our .dynbss section, which will
1019 become part of the .bss section of the executable. There will be
1020 an entry for this symbol in the .dynsym section. The dynamic
1021 object will contain position independent code, so all references
1022 from the dynamic object to this symbol will go through the global
1023 offset table. The dynamic linker will use the .dynsym entry to
1024 determine the address it must put in the global offset table, so
1025 both the dynamic object and the regular object will refer to the
1026 same memory location for the variable. */
1027
1028 s = bfd_get_section_by_name (dynobj, ".dynbss");
1029 BFD_ASSERT (s != NULL);
1030
1031 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1032 copy the initial value out of the dynamic object and into the
1033 runtime process image. We need to remember the offset into the
1034 .rel.bss section we are going to use. */
1035 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1036 {
1037 asection *srel;
1038
1039 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
1040 BFD_ASSERT (srel != NULL);
1041 srel->_raw_size += sizeof (Elf32_External_Rel);
1042 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1043 }
1044
1045 /* We need to figure out the alignment required for this symbol. I
1046 have no idea how ELF linkers handle this. */
1047 power_of_two = bfd_log2 (h->size);
1048 if (power_of_two > 3)
1049 power_of_two = 3;
1050
1051 /* Apply the required alignment. */
1052 s->_raw_size = BFD_ALIGN (s->_raw_size,
1053 (bfd_size_type) (1 << power_of_two));
1054 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1055 {
1056 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1057 return false;
1058 }
1059
1060 /* Define the symbol as being at this point in the section. */
1061 h->root.u.def.section = s;
1062 h->root.u.def.value = s->_raw_size;
1063
1064 /* Increment the section size to make room for the symbol. */
1065 s->_raw_size += h->size;
1066
1067 return true;
1068 }
1069
1070 /* Set the sizes of the dynamic sections. */
1071
1072 static boolean
1073 elf_i386_size_dynamic_sections (output_bfd, info)
1074 bfd *output_bfd;
1075 struct bfd_link_info *info;
1076 {
1077 bfd *dynobj;
1078 asection *s;
1079 boolean plt;
1080 boolean relocs;
1081 boolean reltext;
1082
1083 dynobj = elf_hash_table (info)->dynobj;
1084 BFD_ASSERT (dynobj != NULL);
1085
1086 if (elf_hash_table (info)->dynamic_sections_created)
1087 {
1088 /* Set the contents of the .interp section to the interpreter. */
1089 if (! info->shared)
1090 {
1091 s = bfd_get_section_by_name (dynobj, ".interp");
1092 BFD_ASSERT (s != NULL);
1093 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1094 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1095 }
1096 }
1097 else
1098 {
1099 /* We may have created entries in the .rel.got section.
1100 However, if we are not creating the dynamic sections, we will
1101 not actually use these entries. Reset the size of .rel.got,
1102 which will cause it to get stripped from the output file
1103 below. */
1104 s = bfd_get_section_by_name (dynobj, ".rel.got");
1105 if (s != NULL)
1106 s->_raw_size = 0;
1107 }
1108
1109 /* If this is a -Bsymbolic shared link, then we need to discard all
1110 PC relative relocs against symbols defined in a regular object.
1111 We allocated space for them in the check_relocs routine, but we
1112 will not fill them in in the relocate_section routine. */
1113 if (info->shared)
1114 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
1115 elf_i386_discard_copies,
1116 (PTR) info);
1117
1118 /* The check_relocs and adjust_dynamic_symbol entry points have
1119 determined the sizes of the various dynamic sections. Allocate
1120 memory for them. */
1121 plt = false;
1122 relocs = false;
1123 reltext = false;
1124 for (s = dynobj->sections; s != NULL; s = s->next)
1125 {
1126 const char *name;
1127 boolean strip;
1128
1129 if ((s->flags & SEC_LINKER_CREATED) == 0)
1130 continue;
1131
1132 /* It's OK to base decisions on the section name, because none
1133 of the dynobj section names depend upon the input files. */
1134 name = bfd_get_section_name (dynobj, s);
1135
1136 strip = false;
1137
1138 if (strcmp (name, ".plt") == 0)
1139 {
1140 if (s->_raw_size == 0)
1141 {
1142 /* Strip this section if we don't need it; see the
1143 comment below. */
1144 strip = true;
1145 }
1146 else
1147 {
1148 /* Remember whether there is a PLT. */
1149 plt = true;
1150 }
1151 }
1152 else if (strncmp (name, ".rel", 4) == 0)
1153 {
1154 if (s->_raw_size == 0)
1155 {
1156 /* If we don't need this section, strip it from the
1157 output file. This is mostly to handle .rel.bss and
1158 .rel.plt. We must create both sections in
1159 create_dynamic_sections, because they must be created
1160 before the linker maps input sections to output
1161 sections. The linker does that before
1162 adjust_dynamic_symbol is called, and it is that
1163 function which decides whether anything needs to go
1164 into these sections. */
1165 strip = true;
1166 }
1167 else
1168 {
1169 asection *target;
1170
1171 /* Remember whether there are any reloc sections other
1172 than .rel.plt. */
1173 if (strcmp (name, ".rel.plt") != 0)
1174 {
1175 const char *outname;
1176
1177 relocs = true;
1178
1179 /* If this relocation section applies to a read only
1180 section, then we probably need a DT_TEXTREL
1181 entry. The entries in the .rel.plt section
1182 really apply to the .got section, which we
1183 created ourselves and so know is not readonly. */
1184 outname = bfd_get_section_name (output_bfd,
1185 s->output_section);
1186 target = bfd_get_section_by_name (output_bfd, outname + 4);
1187 if (target != NULL
1188 && (target->flags & SEC_READONLY) != 0
1189 && (target->flags & SEC_ALLOC) != 0)
1190 reltext = true;
1191 }
1192
1193 /* We use the reloc_count field as a counter if we need
1194 to copy relocs into the output file. */
1195 s->reloc_count = 0;
1196 }
1197 }
1198 else if (strncmp (name, ".got", 4) != 0)
1199 {
1200 /* It's not one of our sections, so don't allocate space. */
1201 continue;
1202 }
1203
1204 if (strip)
1205 {
1206 _bfd_strip_section_from_output (info, s);
1207 continue;
1208 }
1209
1210 /* Allocate memory for the section contents. We use bfd_zalloc
1211 here in case unused entries are not reclaimed before the
1212 section's contents are written out. This should not happen,
1213 but this way if it does, we get a R_386_NONE reloc instead
1214 of garbage. */
1215 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1216 if (s->contents == NULL && s->_raw_size != 0)
1217 return false;
1218 }
1219
1220 if (elf_hash_table (info)->dynamic_sections_created)
1221 {
1222 /* Add some entries to the .dynamic section. We fill in the
1223 values later, in elf_i386_finish_dynamic_sections, but we
1224 must add the entries now so that we get the correct size for
1225 the .dynamic section. The DT_DEBUG entry is filled in by the
1226 dynamic linker and used by the debugger. */
1227 if (! info->shared)
1228 {
1229 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1230 return false;
1231 }
1232
1233 if (plt)
1234 {
1235 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1236 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1237 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1238 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1239 return false;
1240 }
1241
1242 if (relocs)
1243 {
1244 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1245 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1246 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1247 sizeof (Elf32_External_Rel)))
1248 return false;
1249 }
1250
1251 if (reltext)
1252 {
1253 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1254 return false;
1255 info->flags |= DF_TEXTREL;
1256 }
1257 }
1258
1259 return true;
1260 }
1261
1262 /* This function is called via elf_i386_link_hash_traverse if we are
1263 creating a shared object. In the -Bsymbolic case, it discards the
1264 space allocated to copy PC relative relocs against symbols which
1265 are defined in regular objects. For the normal non-symbolic case,
1266 we also discard space for relocs that have become local due to
1267 symbol visibility changes. We allocated space for them in the
1268 check_relocs routine, but we won't fill them in in the
1269 relocate_section routine. */
1270
1271 static boolean
1272 elf_i386_discard_copies (h, inf)
1273 struct elf_i386_link_hash_entry *h;
1274 PTR inf;
1275 {
1276 struct elf_i386_pcrel_relocs_copied *s;
1277 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1278
1279 /* If a symbol has been forced local or we have found a regular
1280 definition for the symbolic link case, then we won't be needing
1281 any relocs. */
1282 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1283 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1284 || info->symbolic))
1285 {
1286 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1287 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1288 }
1289
1290 return true;
1291 }
1292
1293 /* Relocate an i386 ELF section. */
1294
1295 static boolean
1296 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1297 contents, relocs, local_syms, local_sections)
1298 bfd *output_bfd;
1299 struct bfd_link_info *info;
1300 bfd *input_bfd;
1301 asection *input_section;
1302 bfd_byte *contents;
1303 Elf_Internal_Rela *relocs;
1304 Elf_Internal_Sym *local_syms;
1305 asection **local_sections;
1306 {
1307 bfd *dynobj;
1308 Elf_Internal_Shdr *symtab_hdr;
1309 struct elf_link_hash_entry **sym_hashes;
1310 bfd_vma *local_got_offsets;
1311 asection *sgot;
1312 asection *splt;
1313 asection *sreloc;
1314 Elf_Internal_Rela *rel;
1315 Elf_Internal_Rela *relend;
1316
1317 dynobj = elf_hash_table (info)->dynobj;
1318 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1319 sym_hashes = elf_sym_hashes (input_bfd);
1320 local_got_offsets = elf_local_got_offsets (input_bfd);
1321
1322 sreloc = NULL;
1323 splt = NULL;
1324 sgot = NULL;
1325 if (dynobj != NULL)
1326 {
1327 splt = bfd_get_section_by_name (dynobj, ".plt");
1328 sgot = bfd_get_section_by_name (dynobj, ".got");
1329 }
1330
1331 rel = relocs;
1332 relend = relocs + input_section->reloc_count;
1333 for (; rel < relend; rel++)
1334 {
1335 int r_type;
1336 reloc_howto_type *howto;
1337 unsigned long r_symndx;
1338 struct elf_link_hash_entry *h;
1339 Elf_Internal_Sym *sym;
1340 asection *sec;
1341 bfd_vma relocation;
1342 bfd_reloc_status_type r;
1343 unsigned int indx;
1344
1345 r_type = ELF32_R_TYPE (rel->r_info);
1346 if (r_type == (int) R_386_GNU_VTINHERIT
1347 || r_type == (int) R_386_GNU_VTENTRY)
1348 continue;
1349
1350 if ((indx = (unsigned) r_type) >= R_386_standard
1351 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1352 >= R_386_ext - R_386_standard))
1353 {
1354 bfd_set_error (bfd_error_bad_value);
1355 return false;
1356 }
1357 howto = elf_howto_table + indx;
1358
1359 r_symndx = ELF32_R_SYM (rel->r_info);
1360
1361 if (info->relocateable)
1362 {
1363 /* This is a relocateable link. We don't have to change
1364 anything, unless the reloc is against a section symbol,
1365 in which case we have to adjust according to where the
1366 section symbol winds up in the output section. */
1367 if (r_symndx < symtab_hdr->sh_info)
1368 {
1369 sym = local_syms + r_symndx;
1370 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1371 {
1372 bfd_vma val;
1373
1374 sec = local_sections[r_symndx];
1375 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1376 val += sec->output_offset + sym->st_value;
1377 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1378 }
1379 }
1380
1381 continue;
1382 }
1383
1384 /* This is a final link. */
1385 h = NULL;
1386 sym = NULL;
1387 sec = NULL;
1388 if (r_symndx < symtab_hdr->sh_info)
1389 {
1390 sym = local_syms + r_symndx;
1391 sec = local_sections[r_symndx];
1392 relocation = (sec->output_section->vma
1393 + sec->output_offset
1394 + sym->st_value);
1395 }
1396 else
1397 {
1398 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1399 while (h->root.type == bfd_link_hash_indirect
1400 || h->root.type == bfd_link_hash_warning)
1401 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1402 if (h->root.type == bfd_link_hash_defined
1403 || h->root.type == bfd_link_hash_defweak)
1404 {
1405 sec = h->root.u.def.section;
1406 if (r_type == R_386_GOTPC
1407 || (r_type == R_386_PLT32
1408 && splt != NULL
1409 && h->plt.offset != (bfd_vma) -1)
1410 || (r_type == R_386_GOT32
1411 && elf_hash_table (info)->dynamic_sections_created
1412 && (! info->shared
1413 || (! info->symbolic && h->dynindx != -1)
1414 || (h->elf_link_hash_flags
1415 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1416 || (info->shared
1417 && ((! info->symbolic && h->dynindx != -1)
1418 || (h->elf_link_hash_flags
1419 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1420 && (r_type == R_386_32
1421 || r_type == R_386_PC32)
1422 && ((input_section->flags & SEC_ALLOC) != 0
1423 /* DWARF will emit R_386_32 relocations in its
1424 sections against symbols defined externally
1425 in shared libraries. We can't do anything
1426 with them here. */
1427 || ((input_section->flags & SEC_DEBUGGING) != 0
1428 && (h->elf_link_hash_flags
1429 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1430 {
1431 /* In these cases, we don't need the relocation
1432 value. We check specially because in some
1433 obscure cases sec->output_section will be NULL. */
1434 relocation = 0;
1435 }
1436 else if (sec->output_section == NULL)
1437 {
1438 (*_bfd_error_handler)
1439 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1440 bfd_get_filename (input_bfd), h->root.root.string,
1441 bfd_get_section_name (input_bfd, input_section));
1442 relocation = 0;
1443 }
1444 else
1445 relocation = (h->root.u.def.value
1446 + sec->output_section->vma
1447 + sec->output_offset);
1448 }
1449 else if (h->root.type == bfd_link_hash_undefweak)
1450 relocation = 0;
1451 else if (info->shared && !info->symbolic
1452 && !info->no_undefined
1453 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1454 relocation = 0;
1455 else
1456 {
1457 if (! ((*info->callbacks->undefined_symbol)
1458 (info, h->root.root.string, input_bfd,
1459 input_section, rel->r_offset,
1460 (!info->shared || info->no_undefined
1461 || ELF_ST_VISIBILITY (h->other)))))
1462 return false;
1463 relocation = 0;
1464 }
1465 }
1466
1467 switch (r_type)
1468 {
1469 case R_386_GOT32:
1470 /* Relocation is to the entry for this symbol in the global
1471 offset table. */
1472 BFD_ASSERT (sgot != NULL);
1473
1474 if (h != NULL)
1475 {
1476 bfd_vma off;
1477
1478 off = h->got.offset;
1479 BFD_ASSERT (off != (bfd_vma) -1);
1480
1481 if (! elf_hash_table (info)->dynamic_sections_created
1482 || (info->shared
1483 && (info->symbolic || h->dynindx == -1)
1484 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1485 {
1486 /* This is actually a static link, or it is a
1487 -Bsymbolic link and the symbol is defined
1488 locally, or the symbol was forced to be local
1489 because of a version file. We must initialize
1490 this entry in the global offset table. Since the
1491 offset must always be a multiple of 4, we use the
1492 least significant bit to record whether we have
1493 initialized it already.
1494
1495 When doing a dynamic link, we create a .rel.got
1496 relocation entry to initialize the value. This
1497 is done in the finish_dynamic_symbol routine. */
1498 if ((off & 1) != 0)
1499 off &= ~1;
1500 else
1501 {
1502 bfd_put_32 (output_bfd, relocation,
1503 sgot->contents + off);
1504 h->got.offset |= 1;
1505 }
1506 }
1507
1508 relocation = sgot->output_offset + off;
1509 }
1510 else
1511 {
1512 bfd_vma off;
1513
1514 BFD_ASSERT (local_got_offsets != NULL
1515 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1516
1517 off = local_got_offsets[r_symndx];
1518
1519 /* The offset must always be a multiple of 4. We use
1520 the least significant bit to record whether we have
1521 already generated the necessary reloc. */
1522 if ((off & 1) != 0)
1523 off &= ~1;
1524 else
1525 {
1526 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1527
1528 if (info->shared)
1529 {
1530 asection *srelgot;
1531 Elf_Internal_Rel outrel;
1532
1533 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1534 BFD_ASSERT (srelgot != NULL);
1535
1536 outrel.r_offset = (sgot->output_section->vma
1537 + sgot->output_offset
1538 + off);
1539 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1540 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1541 (((Elf32_External_Rel *)
1542 srelgot->contents)
1543 + srelgot->reloc_count));
1544 ++srelgot->reloc_count;
1545 }
1546
1547 local_got_offsets[r_symndx] |= 1;
1548 }
1549
1550 relocation = sgot->output_offset + off;
1551 }
1552
1553 break;
1554
1555 case R_386_GOTOFF:
1556 /* Relocation is relative to the start of the global offset
1557 table. */
1558
1559 if (sgot == NULL)
1560 {
1561 sgot = bfd_get_section_by_name (dynobj, ".got");
1562 BFD_ASSERT (sgot != NULL);
1563 }
1564
1565 /* Note that sgot->output_offset is not involved in this
1566 calculation. We always want the start of .got. If we
1567 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1568 permitted by the ABI, we might have to change this
1569 calculation. */
1570 relocation -= sgot->output_section->vma;
1571
1572 break;
1573
1574 case R_386_GOTPC:
1575 /* Use global offset table as symbol value. */
1576
1577 if (sgot == NULL)
1578 {
1579 sgot = bfd_get_section_by_name (dynobj, ".got");
1580 BFD_ASSERT (sgot != NULL);
1581 }
1582
1583 relocation = sgot->output_section->vma;
1584
1585 break;
1586
1587 case R_386_PLT32:
1588 /* Relocation is to the entry for this symbol in the
1589 procedure linkage table. */
1590
1591 /* Resolve a PLT32 reloc against a local symbol directly,
1592 without using the procedure linkage table. */
1593 if (h == NULL)
1594 break;
1595
1596 if (h->plt.offset == (bfd_vma) -1
1597 || splt == NULL)
1598 {
1599 /* We didn't make a PLT entry for this symbol. This
1600 happens when statically linking PIC code, or when
1601 using -Bsymbolic. */
1602 break;
1603 }
1604
1605 relocation = (splt->output_section->vma
1606 + splt->output_offset
1607 + h->plt.offset);
1608
1609 break;
1610
1611 case R_386_32:
1612 case R_386_PC32:
1613 if (info->shared
1614 && (input_section->flags & SEC_ALLOC) != 0
1615 && (r_type != R_386_PC32
1616 || (h != NULL
1617 && h->dynindx != -1
1618 && (! info->symbolic
1619 || (h->elf_link_hash_flags
1620 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1621 {
1622 Elf_Internal_Rel outrel;
1623 boolean skip, relocate;
1624
1625 /* When generating a shared object, these relocations
1626 are copied into the output file to be resolved at run
1627 time. */
1628
1629 if (sreloc == NULL)
1630 {
1631 const char *name;
1632
1633 name = (bfd_elf_string_from_elf_section
1634 (input_bfd,
1635 elf_elfheader (input_bfd)->e_shstrndx,
1636 elf_section_data (input_section)->rel_hdr.sh_name));
1637 if (name == NULL)
1638 return false;
1639
1640 if (strncmp (name, ".rel", 4) != 0
1641 || strcmp (bfd_get_section_name (input_bfd,
1642 input_section),
1643 name + 4) != 0)
1644 {
1645 if (input_bfd->my_archive)
1646 (*_bfd_error_handler) (_("%s(%s): bad relocation section name `%s\'"),
1647 bfd_get_filename (input_bfd->my_archive),
1648 bfd_get_filename (input_bfd),
1649 name);
1650 else
1651 (*_bfd_error_handler) (_("%s: bad relocation section name `%s\'"),
1652 bfd_get_filename (input_bfd),
1653 name);
1654 return false;
1655 }
1656
1657 sreloc = bfd_get_section_by_name (dynobj, name);
1658 BFD_ASSERT (sreloc != NULL);
1659 }
1660
1661 skip = false;
1662
1663 if (elf_section_data (input_section)->stab_info == NULL)
1664 outrel.r_offset = rel->r_offset;
1665 else
1666 {
1667 bfd_vma off;
1668
1669 off = (_bfd_stab_section_offset
1670 (output_bfd, &elf_hash_table (info)->stab_info,
1671 input_section,
1672 &elf_section_data (input_section)->stab_info,
1673 rel->r_offset));
1674 if (off == (bfd_vma) -1)
1675 skip = true;
1676 outrel.r_offset = off;
1677 }
1678
1679 outrel.r_offset += (input_section->output_section->vma
1680 + input_section->output_offset);
1681
1682 if (skip)
1683 {
1684 memset (&outrel, 0, sizeof outrel);
1685 relocate = false;
1686 }
1687 else if (r_type == R_386_PC32)
1688 {
1689 BFD_ASSERT (h != NULL && h->dynindx != -1);
1690 relocate = false;
1691 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1692 }
1693 else
1694 {
1695 /* h->dynindx may be -1 if this symbol was marked to
1696 become local. */
1697 if (h == NULL
1698 || ((info->symbolic || h->dynindx == -1)
1699 && (h->elf_link_hash_flags
1700 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1701 {
1702 relocate = true;
1703 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1704 }
1705 else
1706 {
1707 BFD_ASSERT (h->dynindx != -1);
1708 relocate = false;
1709 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1710 }
1711 }
1712
1713 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1714 (((Elf32_External_Rel *)
1715 sreloc->contents)
1716 + sreloc->reloc_count));
1717 ++sreloc->reloc_count;
1718
1719 /* If this reloc is against an external symbol, we do
1720 not want to fiddle with the addend. Otherwise, we
1721 need to include the symbol value so that it becomes
1722 an addend for the dynamic reloc. */
1723 if (! relocate)
1724 continue;
1725 }
1726
1727 break;
1728
1729 default:
1730 break;
1731 }
1732
1733 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1734 contents, rel->r_offset,
1735 relocation, (bfd_vma) 0);
1736
1737 if (r != bfd_reloc_ok)
1738 {
1739 switch (r)
1740 {
1741 default:
1742 case bfd_reloc_outofrange:
1743 abort ();
1744 case bfd_reloc_overflow:
1745 {
1746 const char *name;
1747
1748 if (h != NULL)
1749 name = h->root.root.string;
1750 else
1751 {
1752 name = bfd_elf_string_from_elf_section (input_bfd,
1753 symtab_hdr->sh_link,
1754 sym->st_name);
1755 if (name == NULL)
1756 return false;
1757 if (*name == '\0')
1758 name = bfd_section_name (input_bfd, sec);
1759 }
1760 if (! ((*info->callbacks->reloc_overflow)
1761 (info, name, howto->name, (bfd_vma) 0,
1762 input_bfd, input_section, rel->r_offset)))
1763 return false;
1764 }
1765 break;
1766 }
1767 }
1768 }
1769
1770 return true;
1771 }
1772
1773 /* Finish up dynamic symbol handling. We set the contents of various
1774 dynamic sections here. */
1775
1776 static boolean
1777 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1778 bfd *output_bfd;
1779 struct bfd_link_info *info;
1780 struct elf_link_hash_entry *h;
1781 Elf_Internal_Sym *sym;
1782 {
1783 bfd *dynobj;
1784
1785 dynobj = elf_hash_table (info)->dynobj;
1786
1787 if (h->plt.offset != (bfd_vma) -1)
1788 {
1789 asection *splt;
1790 asection *sgot;
1791 asection *srel;
1792 bfd_vma plt_index;
1793 bfd_vma got_offset;
1794 Elf_Internal_Rel rel;
1795
1796 /* This symbol has an entry in the procedure linkage table. Set
1797 it up. */
1798
1799 BFD_ASSERT (h->dynindx != -1);
1800
1801 splt = bfd_get_section_by_name (dynobj, ".plt");
1802 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1803 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1804 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1805
1806 /* Get the index in the procedure linkage table which
1807 corresponds to this symbol. This is the index of this symbol
1808 in all the symbols for which we are making plt entries. The
1809 first entry in the procedure linkage table is reserved. */
1810 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1811
1812 /* Get the offset into the .got table of the entry that
1813 corresponds to this function. Each .got entry is 4 bytes.
1814 The first three are reserved. */
1815 got_offset = (plt_index + 3) * 4;
1816
1817 /* Fill in the entry in the procedure linkage table. */
1818 if (! info->shared)
1819 {
1820 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1821 PLT_ENTRY_SIZE);
1822 bfd_put_32 (output_bfd,
1823 (sgot->output_section->vma
1824 + sgot->output_offset
1825 + got_offset),
1826 splt->contents + h->plt.offset + 2);
1827 }
1828 else
1829 {
1830 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1831 PLT_ENTRY_SIZE);
1832 bfd_put_32 (output_bfd, got_offset,
1833 splt->contents + h->plt.offset + 2);
1834 }
1835
1836 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1837 splt->contents + h->plt.offset + 7);
1838 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1839 splt->contents + h->plt.offset + 12);
1840
1841 /* Fill in the entry in the global offset table. */
1842 bfd_put_32 (output_bfd,
1843 (splt->output_section->vma
1844 + splt->output_offset
1845 + h->plt.offset
1846 + 6),
1847 sgot->contents + got_offset);
1848
1849 /* Fill in the entry in the .rel.plt section. */
1850 rel.r_offset = (sgot->output_section->vma
1851 + sgot->output_offset
1852 + got_offset);
1853 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1854 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1855 ((Elf32_External_Rel *) srel->contents
1856 + plt_index));
1857
1858 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1859 {
1860 /* Mark the symbol as undefined, rather than as defined in
1861 the .plt section. Leave the value alone. */
1862 sym->st_shndx = SHN_UNDEF;
1863 }
1864 }
1865
1866 if (h->got.offset != (bfd_vma) -1)
1867 {
1868 asection *sgot;
1869 asection *srel;
1870 Elf_Internal_Rel rel;
1871
1872 /* This symbol has an entry in the global offset table. Set it
1873 up. */
1874
1875 sgot = bfd_get_section_by_name (dynobj, ".got");
1876 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1877 BFD_ASSERT (sgot != NULL && srel != NULL);
1878
1879 rel.r_offset = (sgot->output_section->vma
1880 + sgot->output_offset
1881 + (h->got.offset &~ 1));
1882
1883 /* If this is a static link, or it is a -Bsymbolic link and the
1884 symbol is defined locally or was forced to be local because
1885 of a version file, we just want to emit a RELATIVE reloc.
1886 The entry in the global offset table will already have been
1887 initialized in the relocate_section function. */
1888 if (! elf_hash_table (info)->dynamic_sections_created
1889 || (info->shared
1890 && (info->symbolic || h->dynindx == -1)
1891 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1892 {
1893 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1894 }
1895 else
1896 {
1897 BFD_ASSERT((h->got.offset & 1) == 0);
1898 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1899 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1900 }
1901
1902 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1903 ((Elf32_External_Rel *) srel->contents
1904 + srel->reloc_count));
1905 ++srel->reloc_count;
1906 }
1907
1908 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1909 {
1910 asection *s;
1911 Elf_Internal_Rel rel;
1912
1913 /* This symbol needs a copy reloc. Set it up. */
1914
1915 BFD_ASSERT (h->dynindx != -1
1916 && (h->root.type == bfd_link_hash_defined
1917 || h->root.type == bfd_link_hash_defweak));
1918
1919 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1920 ".rel.bss");
1921 BFD_ASSERT (s != NULL);
1922
1923 rel.r_offset = (h->root.u.def.value
1924 + h->root.u.def.section->output_section->vma
1925 + h->root.u.def.section->output_offset);
1926 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1927 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1928 ((Elf32_External_Rel *) s->contents
1929 + s->reloc_count));
1930 ++s->reloc_count;
1931 }
1932
1933 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1934 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1935 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1936 sym->st_shndx = SHN_ABS;
1937
1938 return true;
1939 }
1940
1941 /* Finish up the dynamic sections. */
1942
1943 static boolean
1944 elf_i386_finish_dynamic_sections (output_bfd, info)
1945 bfd *output_bfd;
1946 struct bfd_link_info *info;
1947 {
1948 bfd *dynobj;
1949 asection *sgot;
1950 asection *sdyn;
1951
1952 dynobj = elf_hash_table (info)->dynobj;
1953
1954 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1955 BFD_ASSERT (sgot != NULL);
1956 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1957
1958 if (elf_hash_table (info)->dynamic_sections_created)
1959 {
1960 asection *splt;
1961 Elf32_External_Dyn *dyncon, *dynconend;
1962
1963 BFD_ASSERT (sdyn != NULL);
1964
1965 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1966 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1967 for (; dyncon < dynconend; dyncon++)
1968 {
1969 Elf_Internal_Dyn dyn;
1970 const char *name;
1971 asection *s;
1972
1973 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1974
1975 switch (dyn.d_tag)
1976 {
1977 default:
1978 break;
1979
1980 case DT_PLTGOT:
1981 name = ".got";
1982 goto get_vma;
1983 case DT_JMPREL:
1984 name = ".rel.plt";
1985 get_vma:
1986 s = bfd_get_section_by_name (output_bfd, name);
1987 BFD_ASSERT (s != NULL);
1988 dyn.d_un.d_ptr = s->vma;
1989 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1990 break;
1991
1992 case DT_PLTRELSZ:
1993 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1994 BFD_ASSERT (s != NULL);
1995 if (s->_cooked_size != 0)
1996 dyn.d_un.d_val = s->_cooked_size;
1997 else
1998 dyn.d_un.d_val = s->_raw_size;
1999 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2000 break;
2001
2002 case DT_RELSZ:
2003 /* My reading of the SVR4 ABI indicates that the
2004 procedure linkage table relocs (DT_JMPREL) should be
2005 included in the overall relocs (DT_REL). This is
2006 what Solaris does. However, UnixWare can not handle
2007 that case. Therefore, we override the DT_RELSZ entry
2008 here to make it not include the JMPREL relocs. Since
2009 the linker script arranges for .rel.plt to follow all
2010 other relocation sections, we don't have to worry
2011 about changing the DT_REL entry. */
2012 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
2013 if (s != NULL)
2014 {
2015 if (s->_cooked_size != 0)
2016 dyn.d_un.d_val -= s->_cooked_size;
2017 else
2018 dyn.d_un.d_val -= s->_raw_size;
2019 }
2020 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2021 break;
2022 }
2023 }
2024
2025 /* Fill in the first entry in the procedure linkage table. */
2026 splt = bfd_get_section_by_name (dynobj, ".plt");
2027 if (splt && splt->_raw_size > 0)
2028 {
2029 if (info->shared)
2030 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2031 else
2032 {
2033 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2034 bfd_put_32 (output_bfd,
2035 sgot->output_section->vma + sgot->output_offset + 4,
2036 splt->contents + 2);
2037 bfd_put_32 (output_bfd,
2038 sgot->output_section->vma + sgot->output_offset + 8,
2039 splt->contents + 8);
2040 }
2041
2042 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2043 really seem like the right value. */
2044 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2045 }
2046 }
2047
2048 /* Fill in the first three entries in the global offset table. */
2049 if (sgot->_raw_size > 0)
2050 {
2051 if (sdyn == NULL)
2052 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2053 else
2054 bfd_put_32 (output_bfd,
2055 sdyn->output_section->vma + sdyn->output_offset,
2056 sgot->contents);
2057 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2058 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2059 }
2060
2061 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2062
2063 return true;
2064 }
2065
2066 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2067 #define TARGET_LITTLE_NAME "elf32-i386"
2068 #define ELF_ARCH bfd_arch_i386
2069 #define ELF_MACHINE_CODE EM_386
2070 #define ELF_MAXPAGESIZE 0x1000
2071
2072 #define elf_backend_can_gc_sections 1
2073 #define elf_backend_want_got_plt 1
2074 #define elf_backend_plt_readonly 1
2075 #define elf_backend_want_plt_sym 0
2076 #define elf_backend_got_header_size 12
2077 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2078
2079 #define elf_info_to_howto elf_i386_info_to_howto
2080 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2081
2082 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2083 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2084 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2085 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2086
2087 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2088 #define elf_backend_check_relocs elf_i386_check_relocs
2089 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2090 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2091 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2092 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2093 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2094 #define elf_backend_relocate_section elf_i386_relocate_section
2095 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2096
2097 #include "elf32-target.h"
git-cvsimport of binutils cvsroot