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