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