?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
file as.info-5 was initially added on branch binutils-2_10-branch.
[binutils.git] / bfd / elf32-i386.c
blob53edaaf254381a0f6a78705b6672f0bf4e64dac0
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
1394 && !info->no_undefined
1395 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1396 relocation = 0;
1397 else
1398 {
1399 if (! ((*info->callbacks->undefined_symbol)
1400 (info, h->root.root.string, input_bfd,
1401 input_section, rel->r_offset,
1402 (!info->shared || info->no_undefined
1403 || ELF_ST_VISIBILITY (h->other)))))
1404 return false;
1405 relocation = 0;
1406 }
1407 }
1408
1409 switch (r_type)
1410 {
1411 case R_386_GOT32:
1412 /* Relocation is to the entry for this symbol in the global
1413 offset table. */
1414 BFD_ASSERT (sgot != NULL);
1415
1416 if (h != NULL)
1417 {
1418 bfd_vma off;
1419
1420 off = h->got.offset;
1421 BFD_ASSERT (off != (bfd_vma) -1);
1422
1423 if (! elf_hash_table (info)->dynamic_sections_created
1424 || (info->shared
1425 && (info->symbolic || h->dynindx == -1)
1426 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1427 {
1428 /* This is actually a static link, or it is a
1429 -Bsymbolic link and the symbol is defined
1430 locally, or the symbol was forced to be local
1431 because of a version file. We must initialize
1432 this entry in the global offset table. Since the
1433 offset must always be a multiple of 4, we use the
1434 least significant bit to record whether we have
1435 initialized it already.
1436
1437 When doing a dynamic link, we create a .rel.got
1438 relocation entry to initialize the value. This
1439 is done in the finish_dynamic_symbol routine. */
1440 if ((off & 1) != 0)
1441 off &= ~1;
1442 else
1443 {
1444 bfd_put_32 (output_bfd, relocation,
1445 sgot->contents + off);
1446 h->got.offset |= 1;
1447 }
1448 }
1449
1450 relocation = sgot->output_offset + off;
1451 }
1452 else
1453 {
1454 bfd_vma off;
1455
1456 BFD_ASSERT (local_got_offsets != NULL
1457 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1458
1459 off = local_got_offsets[r_symndx];
1460
1461 /* The offset must always be a multiple of 4. We use
1462 the least significant bit to record whether we have
1463 already generated the necessary reloc. */
1464 if ((off & 1) != 0)
1465 off &= ~1;
1466 else
1467 {
1468 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1469
1470 if (info->shared)
1471 {
1472 asection *srelgot;
1473 Elf_Internal_Rel outrel;
1474
1475 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1476 BFD_ASSERT (srelgot != NULL);
1477
1478 outrel.r_offset = (sgot->output_section->vma
1479 + sgot->output_offset
1480 + off);
1481 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1482 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1483 (((Elf32_External_Rel *)
1484 srelgot->contents)
1485 + srelgot->reloc_count));
1486 ++srelgot->reloc_count;
1487 }
1488
1489 local_got_offsets[r_symndx] |= 1;
1490 }
1491
1492 relocation = sgot->output_offset + off;
1493 }
1494
1495 break;
1496
1497 case R_386_GOTOFF:
1498 /* Relocation is relative to the start of the global offset
1499 table. */
1500
1501 if (sgot == NULL)
1502 {
1503 sgot = bfd_get_section_by_name (dynobj, ".got");
1504 BFD_ASSERT (sgot != NULL);
1505 }
1506
1507 /* Note that sgot->output_offset is not involved in this
1508 calculation. We always want the start of .got. If we
1509 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1510 permitted by the ABI, we might have to change this
1511 calculation. */
1512 relocation -= sgot->output_section->vma;
1513
1514 break;
1515
1516 case R_386_GOTPC:
1517 /* Use global offset table as symbol value. */
1518
1519 if (sgot == NULL)
1520 {
1521 sgot = bfd_get_section_by_name (dynobj, ".got");
1522 BFD_ASSERT (sgot != NULL);
1523 }
1524
1525 relocation = sgot->output_section->vma;
1526
1527 break;
1528
1529 case R_386_PLT32:
1530 /* Relocation is to the entry for this symbol in the
1531 procedure linkage table. */
1532
1533 /* Resolve a PLT32 reloc against a local symbol directly,
1534 without using the procedure linkage table. */
1535 if (h == NULL)
1536 break;
1537
1538 if (h->plt.offset == (bfd_vma) -1
1539 || splt == NULL)
1540 {
1541 /* We didn't make a PLT entry for this symbol. This
1542 happens when statically linking PIC code, or when
1543 using -Bsymbolic. */
1544 break;
1545 }
1546
1547 relocation = (splt->output_section->vma
1548 + splt->output_offset
1549 + h->plt.offset);
1550
1551 break;
1552
1553 case R_386_32:
1554 case R_386_PC32:
1555 if (info->shared
1556 && (input_section->flags & SEC_ALLOC) != 0
1557 && (r_type != R_386_PC32
1558 || (h != NULL
1559 && h->dynindx != -1
1560 && (! info->symbolic
1561 || (h->elf_link_hash_flags
1562 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1563 {
1564 Elf_Internal_Rel outrel;
1565 boolean skip, relocate;
1566
1567 /* When generating a shared object, these relocations
1568 are copied into the output file to be resolved at run
1569 time. */
1570
1571 if (sreloc == NULL)
1572 {
1573 const char *name;
1574
1575 name = (bfd_elf_string_from_elf_section
1576 (input_bfd,
1577 elf_elfheader (input_bfd)->e_shstrndx,
1578 elf_section_data (input_section)->rel_hdr.sh_name));
1579 if (name == NULL)
1580 return false;
1581
1582 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1583 && strcmp (bfd_get_section_name (input_bfd,
1584 input_section),
1585 name + 4) == 0);
1586
1587 sreloc = bfd_get_section_by_name (dynobj, name);
1588 BFD_ASSERT (sreloc != NULL);
1589 }
1590
1591 skip = false;
1592
1593 if (elf_section_data (input_section)->stab_info == NULL)
1594 outrel.r_offset = rel->r_offset;
1595 else
1596 {
1597 bfd_vma off;
1598
1599 off = (_bfd_stab_section_offset
1600 (output_bfd, &elf_hash_table (info)->stab_info,
1601 input_section,
1602 &elf_section_data (input_section)->stab_info,
1603 rel->r_offset));
1604 if (off == (bfd_vma) -1)
1605 skip = true;
1606 outrel.r_offset = off;
1607 }
1608
1609 outrel.r_offset += (input_section->output_section->vma
1610 + input_section->output_offset);
1611
1612 if (skip)
1613 {
1614 memset (&outrel, 0, sizeof outrel);
1615 relocate = false;
1616 }
1617 else if (r_type == R_386_PC32)
1618 {
1619 BFD_ASSERT (h != NULL && h->dynindx != -1);
1620 relocate = false;
1621 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1622 }
1623 else
1624 {
1625 /* h->dynindx may be -1 if this symbol was marked to
1626 become local. */
1627 if (h == NULL
1628 || ((info->symbolic || h->dynindx == -1)
1629 && (h->elf_link_hash_flags
1630 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1631 {
1632 relocate = true;
1633 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1634 }
1635 else
1636 {
1637 BFD_ASSERT (h->dynindx != -1);
1638 relocate = false;
1639 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1640 }
1641 }
1642
1643 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1644 (((Elf32_External_Rel *)
1645 sreloc->contents)
1646 + sreloc->reloc_count));
1647 ++sreloc->reloc_count;
1648
1649 /* If this reloc is against an external symbol, we do
1650 not want to fiddle with the addend. Otherwise, we
1651 need to include the symbol value so that it becomes
1652 an addend for the dynamic reloc. */
1653 if (! relocate)
1654 continue;
1655 }
1656
1657 break;
1658
1659 default:
1660 break;
1661 }
1662
1663 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1664 contents, rel->r_offset,
1665 relocation, (bfd_vma) 0);
1666
1667 if (r != bfd_reloc_ok)
1668 {
1669 switch (r)
1670 {
1671 default:
1672 case bfd_reloc_outofrange:
1673 abort ();
1674 case bfd_reloc_overflow:
1675 {
1676 const char *name;
1677
1678 if (h != NULL)
1679 name = h->root.root.string;
1680 else
1681 {
1682 name = bfd_elf_string_from_elf_section (input_bfd,
1683 symtab_hdr->sh_link,
1684 sym->st_name);
1685 if (name == NULL)
1686 return false;
1687 if (*name == '\0')
1688 name = bfd_section_name (input_bfd, sec);
1689 }
1690 if (! ((*info->callbacks->reloc_overflow)
1691 (info, name, howto->name, (bfd_vma) 0,
1692 input_bfd, input_section, rel->r_offset)))
1693 return false;
1694 }
1695 break;
1696 }
1697 }
1698 }
1699
1700 return true;
1701 }
1702
1703 /* Finish up dynamic symbol handling. We set the contents of various
1704 dynamic sections here. */
1705
1706 static boolean
1707 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1708 bfd *output_bfd;
1709 struct bfd_link_info *info;
1710 struct elf_link_hash_entry *h;
1711 Elf_Internal_Sym *sym;
1712 {
1713 bfd *dynobj;
1714
1715 dynobj = elf_hash_table (info)->dynobj;
1716
1717 if (h->plt.offset != (bfd_vma) -1)
1718 {
1719 asection *splt;
1720 asection *sgot;
1721 asection *srel;
1722 bfd_vma plt_index;
1723 bfd_vma got_offset;
1724 Elf_Internal_Rel rel;
1725
1726 /* This symbol has an entry in the procedure linkage table. Set
1727 it up. */
1728
1729 BFD_ASSERT (h->dynindx != -1);
1730
1731 splt = bfd_get_section_by_name (dynobj, ".plt");
1732 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1733 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1734 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1735
1736 /* Get the index in the procedure linkage table which
1737 corresponds to this symbol. This is the index of this symbol
1738 in all the symbols for which we are making plt entries. The
1739 first entry in the procedure linkage table is reserved. */
1740 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1741
1742 /* Get the offset into the .got table of the entry that
1743 corresponds to this function. Each .got entry is 4 bytes.
1744 The first three are reserved. */
1745 got_offset = (plt_index + 3) * 4;
1746
1747 /* Fill in the entry in the procedure linkage table. */
1748 if (! info->shared)
1749 {
1750 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1751 PLT_ENTRY_SIZE);
1752 bfd_put_32 (output_bfd,
1753 (sgot->output_section->vma
1754 + sgot->output_offset
1755 + got_offset),
1756 splt->contents + h->plt.offset + 2);
1757 }
1758 else
1759 {
1760 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1761 PLT_ENTRY_SIZE);
1762 bfd_put_32 (output_bfd, got_offset,
1763 splt->contents + h->plt.offset + 2);
1764 }
1765
1766 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1767 splt->contents + h->plt.offset + 7);
1768 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1769 splt->contents + h->plt.offset + 12);
1770
1771 /* Fill in the entry in the global offset table. */
1772 bfd_put_32 (output_bfd,
1773 (splt->output_section->vma
1774 + splt->output_offset
1775 + h->plt.offset
1776 + 6),
1777 sgot->contents + got_offset);
1778
1779 /* Fill in the entry in the .rel.plt section. */
1780 rel.r_offset = (sgot->output_section->vma
1781 + sgot->output_offset
1782 + got_offset);
1783 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1784 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1785 ((Elf32_External_Rel *) srel->contents
1786 + plt_index));
1787
1788 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1789 {
1790 /* Mark the symbol as undefined, rather than as defined in
1791 the .plt section. Leave the value alone. */
1792 sym->st_shndx = SHN_UNDEF;
1793 }
1794 }
1795
1796 if (h->got.offset != (bfd_vma) -1)
1797 {
1798 asection *sgot;
1799 asection *srel;
1800 Elf_Internal_Rel rel;
1801
1802 /* This symbol has an entry in the global offset table. Set it
1803 up. */
1804
1805 sgot = bfd_get_section_by_name (dynobj, ".got");
1806 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1807 BFD_ASSERT (sgot != NULL && srel != NULL);
1808
1809 rel.r_offset = (sgot->output_section->vma
1810 + sgot->output_offset
1811 + (h->got.offset &~ 1));
1812
1813 /* If this is a static link, or it is a -Bsymbolic link and the
1814 symbol is defined locally or was forced to be local because
1815 of a version file, we just want to emit a RELATIVE reloc.
1816 The entry in the global offset table will already have been
1817 initialized in the relocate_section function. */
1818 if (! elf_hash_table (info)->dynamic_sections_created
1819 || (info->shared
1820 && (info->symbolic || h->dynindx == -1)
1821 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1822 {
1823 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1824 }
1825 else
1826 {
1827 BFD_ASSERT((h->got.offset & 1) == 0);
1828 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1829 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1830 }
1831
1832 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1833 ((Elf32_External_Rel *) srel->contents
1834 + srel->reloc_count));
1835 ++srel->reloc_count;
1836 }
1837
1838 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1839 {
1840 asection *s;
1841 Elf_Internal_Rel rel;
1842
1843 /* This symbol needs a copy reloc. Set it up. */
1844
1845 BFD_ASSERT (h->dynindx != -1
1846 && (h->root.type == bfd_link_hash_defined
1847 || h->root.type == bfd_link_hash_defweak));
1848
1849 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1850 ".rel.bss");
1851 BFD_ASSERT (s != NULL);
1852
1853 rel.r_offset = (h->root.u.def.value
1854 + h->root.u.def.section->output_section->vma
1855 + h->root.u.def.section->output_offset);
1856 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1857 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1858 ((Elf32_External_Rel *) s->contents
1859 + s->reloc_count));
1860 ++s->reloc_count;
1861 }
1862
1863 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1864 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1865 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1866 sym->st_shndx = SHN_ABS;
1867
1868 return true;
1869 }
1870
1871 /* Finish up the dynamic sections. */
1872
1873 static boolean
1874 elf_i386_finish_dynamic_sections (output_bfd, info)
1875 bfd *output_bfd;
1876 struct bfd_link_info *info;
1877 {
1878 bfd *dynobj;
1879 asection *sgot;
1880 asection *sdyn;
1881
1882 dynobj = elf_hash_table (info)->dynobj;
1883
1884 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1885 BFD_ASSERT (sgot != NULL);
1886 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1887
1888 if (elf_hash_table (info)->dynamic_sections_created)
1889 {
1890 asection *splt;
1891 Elf32_External_Dyn *dyncon, *dynconend;
1892
1893 BFD_ASSERT (sdyn != NULL);
1894
1895 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1896 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1897 for (; dyncon < dynconend; dyncon++)
1898 {
1899 Elf_Internal_Dyn dyn;
1900 const char *name;
1901 asection *s;
1902
1903 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1904
1905 switch (dyn.d_tag)
1906 {
1907 default:
1908 break;
1909
1910 case DT_PLTGOT:
1911 name = ".got";
1912 goto get_vma;
1913 case DT_JMPREL:
1914 name = ".rel.plt";
1915 get_vma:
1916 s = bfd_get_section_by_name (output_bfd, name);
1917 BFD_ASSERT (s != NULL);
1918 dyn.d_un.d_ptr = s->vma;
1919 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1920 break;
1921
1922 case DT_PLTRELSZ:
1923 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1924 BFD_ASSERT (s != NULL);
1925 if (s->_cooked_size != 0)
1926 dyn.d_un.d_val = s->_cooked_size;
1927 else
1928 dyn.d_un.d_val = s->_raw_size;
1929 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1930 break;
1931
1932 case DT_RELSZ:
1933 /* My reading of the SVR4 ABI indicates that the
1934 procedure linkage table relocs (DT_JMPREL) should be
1935 included in the overall relocs (DT_REL). This is
1936 what Solaris does. However, UnixWare can not handle
1937 that case. Therefore, we override the DT_RELSZ entry
1938 here to make it not include the JMPREL relocs. Since
1939 the linker script arranges for .rel.plt to follow all
1940 other relocation sections, we don't have to worry
1941 about changing the DT_REL entry. */
1942 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1943 if (s != NULL)
1944 {
1945 if (s->_cooked_size != 0)
1946 dyn.d_un.d_val -= s->_cooked_size;
1947 else
1948 dyn.d_un.d_val -= s->_raw_size;
1949 }
1950 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1951 break;
1952 }
1953 }
1954
1955 /* Fill in the first entry in the procedure linkage table. */
1956 splt = bfd_get_section_by_name (dynobj, ".plt");
1957 if (splt && splt->_raw_size > 0)
1958 {
1959 if (info->shared)
1960 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1961 else
1962 {
1963 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1964 bfd_put_32 (output_bfd,
1965 sgot->output_section->vma + sgot->output_offset + 4,
1966 splt->contents + 2);
1967 bfd_put_32 (output_bfd,
1968 sgot->output_section->vma + sgot->output_offset + 8,
1969 splt->contents + 8);
1970 }
1971
1972 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1973 really seem like the right value. */
1974 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1975 }
1976 }
1977
1978 /* Fill in the first three entries in the global offset table. */
1979 if (sgot->_raw_size > 0)
1980 {
1981 if (sdyn == NULL)
1982 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1983 else
1984 bfd_put_32 (output_bfd,
1985 sdyn->output_section->vma + sdyn->output_offset,
1986 sgot->contents);
1987 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1988 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1989 }
1990
1991 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1992
1993 return true;
1994 }
1995
1996 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1997 #define TARGET_LITTLE_NAME "elf32-i386"
1998 #define ELF_ARCH bfd_arch_i386
1999 #define ELF_MACHINE_CODE EM_386
2000 #define ELF_MAXPAGESIZE 0x1000
2001
2002 #define elf_backend_can_gc_sections 1
2003 #define elf_backend_want_got_plt 1
2004 #define elf_backend_plt_readonly 1
2005 #define elf_backend_want_plt_sym 0
2006 #define elf_backend_got_header_size 12
2007 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2008
2009 #define elf_info_to_howto elf_i386_info_to_howto
2010 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2011
2012 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2013 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2014 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2015 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2016
2017 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2018 #define elf_backend_check_relocs elf_i386_check_relocs
2019 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2020 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2021 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2022 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2023 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2024 #define elf_backend_relocate_section elf_i386_relocate_section
2025 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2026
2027 #include "elf32-target.h"
git-cvsimport of binutils cvsroot