?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
From Brad Lucier <lucier@math.purdue.edu>:
[binutils.git] / bfd / elf32-i386.c
blob0153fa872eb98704a98356ac5198b209b472cb18
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_vma *local_got_offsets;
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_offsets = elf_local_got_offsets (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.offset != (bfd_vma) -1)
526 {
527 /* We have already allocated space in the .got. */
528 break;
529 }
530 h->got.offset = sgot->_raw_size;
531
532 /* Make sure this symbol is output as a dynamic symbol. */
533 if (h->dynindx == -1)
534 {
535 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
536 return false;
537 }
538
539 srelgot->_raw_size += sizeof (Elf32_External_Rel);
540 }
541 else
542 {
543 /* This is a global offset table entry for a local
544 symbol. */
545 if (local_got_offsets == NULL)
546 {
547 size_t size;
548 register unsigned int i;
549
550 size = symtab_hdr->sh_info * sizeof (bfd_vma);
551 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
552 if (local_got_offsets == NULL)
553 return false;
554 elf_local_got_offsets (abfd) = local_got_offsets;
555 for (i = 0; i < symtab_hdr->sh_info; i++)
556 local_got_offsets[i] = (bfd_vma) -1;
557 }
558 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
559 {
560 /* We have already allocated space in the .got. */
561 break;
562 }
563 local_got_offsets[r_symndx] = sgot->_raw_size;
564
565 if (info->shared)
566 {
567 /* If we are generating a shared object, we need to
568 output a R_386_RELATIVE reloc so that the dynamic
569 linker can adjust this GOT entry. */
570 srelgot->_raw_size += sizeof (Elf32_External_Rel);
571 }
572 }
573
574 sgot->_raw_size += 4;
575
576 break;
577
578 case R_386_PLT32:
579 /* This symbol requires a procedure linkage table entry. We
580 actually build the entry in adjust_dynamic_symbol,
581 because this might be a case of linking PIC code which is
582 never referenced by a dynamic object, in which case we
583 don't need to generate a procedure linkage table entry
584 after all. */
585
586 /* If this is a local symbol, we resolve it directly without
587 creating a procedure linkage table entry. */
588 if (h == NULL)
589 continue;
590
591 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
592
593 break;
594
595 case R_386_32:
596 case R_386_PC32:
597 if (h != NULL)
598 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
599
600 /* If we are creating a shared library, and this is a reloc
601 against a global symbol, or a non PC relative reloc
602 against a local symbol, then we need to copy the reloc
603 into the shared library. However, if we are linking with
604 -Bsymbolic, we do not need to copy a reloc against a
605 global symbol which is defined in an object we are
606 including in the link (i.e., DEF_REGULAR is set). At
607 this point we have not seen all the input files, so it is
608 possible that DEF_REGULAR is not set now but will be set
609 later (it is never cleared). We account for that
610 possibility below by storing information in the
611 pcrel_relocs_copied field of the hash table entry. */
612 if (info->shared
613 && (sec->flags & SEC_ALLOC) != 0
614 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
615 || (h != NULL
616 && (! info->symbolic
617 || (h->elf_link_hash_flags
618 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
619 {
620 /* When creating a shared object, we must copy these
621 reloc types into the output file. We create a reloc
622 section in dynobj and make room for this reloc. */
623 if (sreloc == NULL)
624 {
625 const char *name;
626
627 name = (bfd_elf_string_from_elf_section
628 (abfd,
629 elf_elfheader (abfd)->e_shstrndx,
630 elf_section_data (sec)->rel_hdr.sh_name));
631 if (name == NULL)
632 return false;
633
634 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
635 && strcmp (bfd_get_section_name (abfd, sec),
636 name + 4) == 0);
637
638 sreloc = bfd_get_section_by_name (dynobj, name);
639 if (sreloc == NULL)
640 {
641 flagword flags;
642
643 sreloc = bfd_make_section (dynobj, name);
644 flags = (SEC_HAS_CONTENTS | SEC_READONLY
645 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
646 if ((sec->flags & SEC_ALLOC) != 0)
647 flags |= SEC_ALLOC | SEC_LOAD;
648 if (sreloc == NULL
649 || ! bfd_set_section_flags (dynobj, sreloc, flags)
650 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
651 return false;
652 }
653 }
654
655 sreloc->_raw_size += sizeof (Elf32_External_Rel);
656
657 /* If we are linking with -Bsymbolic, and this is a
658 global symbol, we count the number of PC relative
659 relocations we have entered for this symbol, so that
660 we can discard them again if the symbol is later
661 defined by a regular object. Note that this function
662 is only called if we are using an elf_i386 linker
663 hash table, which means that h is really a pointer to
664 an elf_i386_link_hash_entry. */
665 if (h != NULL && info->symbolic
666 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
667 {
668 struct elf_i386_link_hash_entry *eh;
669 struct elf_i386_pcrel_relocs_copied *p;
670
671 eh = (struct elf_i386_link_hash_entry *) h;
672
673 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
674 if (p->section == sreloc)
675 break;
676
677 if (p == NULL)
678 {
679 p = ((struct elf_i386_pcrel_relocs_copied *)
680 bfd_alloc (dynobj, sizeof *p));
681 if (p == NULL)
682 return false;
683 p->next = eh->pcrel_relocs_copied;
684 eh->pcrel_relocs_copied = p;
685 p->section = sreloc;
686 p->count = 0;
687 }
688
689 ++p->count;
690 }
691 }
692
693 break;
694
695 /* This relocation describes the C++ object vtable hierarchy.
696 Reconstruct it for later use during GC. */
697 case R_386_GNU_VTINHERIT:
698 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
699 return false;
700 break;
701
702 /* This relocation describes which C++ vtable entries are actually
703 used. Record for later use during GC. */
704 case R_386_GNU_VTENTRY:
705 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
706 return false;
707 break;
708
709 default:
710 break;
711 }
712 }
713
714 return true;
715 }
716
717 /* Return the section that should be marked against GC for a given
718 relocation. */
719
720 static asection *
721 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
722 bfd *abfd;
723 struct bfd_link_info *info ATTRIBUTE_UNUSED;
724 Elf_Internal_Rela *rel;
725 struct elf_link_hash_entry *h;
726 Elf_Internal_Sym *sym;
727 {
728 if (h != NULL)
729 {
730 switch (ELF32_R_TYPE (rel->r_info))
731 {
732 case R_386_GNU_VTINHERIT:
733 case R_386_GNU_VTENTRY:
734 break;
735
736 default:
737 switch (h->root.type)
738 {
739 case bfd_link_hash_defined:
740 case bfd_link_hash_defweak:
741 return h->root.u.def.section;
742
743 case bfd_link_hash_common:
744 return h->root.u.c.p->section;
745
746 default:
747 break;
748 }
749 }
750 }
751 else
752 {
753 if (!(elf_bad_symtab (abfd)
754 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
755 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
756 && sym->st_shndx != SHN_COMMON))
757 {
758 return bfd_section_from_elf_index (abfd, sym->st_shndx);
759 }
760 }
761
762 return NULL;
763 }
764
765 /* Update the got entry reference counts for the section being removed. */
766
767 static boolean
768 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
769 bfd *abfd ATTRIBUTE_UNUSED;
770 struct bfd_link_info *info ATTRIBUTE_UNUSED;
771 asection *sec ATTRIBUTE_UNUSED;
772 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
773 {
774 /* ??? It would seem that the existing i386 code does no sort
775 of reference counting or whatnot on its GOT and PLT entries,
776 so it is not possible to garbage collect them at this time. */
777
778 return true;
779 }
780
781 /* Adjust a symbol defined by a dynamic object and referenced by a
782 regular object. The current definition is in some section of the
783 dynamic object, but we're not including those sections. We have to
784 change the definition to something the rest of the link can
785 understand. */
786
787 static boolean
788 elf_i386_adjust_dynamic_symbol (info, h)
789 struct bfd_link_info *info;
790 struct elf_link_hash_entry *h;
791 {
792 bfd *dynobj;
793 asection *s;
794 unsigned int power_of_two;
795
796 dynobj = elf_hash_table (info)->dynobj;
797
798 /* Make sure we know what is going on here. */
799 BFD_ASSERT (dynobj != NULL
800 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
801 || h->weakdef != NULL
802 || ((h->elf_link_hash_flags
803 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
804 && (h->elf_link_hash_flags
805 & ELF_LINK_HASH_REF_REGULAR) != 0
806 && (h->elf_link_hash_flags
807 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
808
809 /* If this is a function, put it in the procedure linkage table. We
810 will fill in the contents of the procedure linkage table later,
811 when we know the address of the .got section. */
812 if (h->type == STT_FUNC
813 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
814 {
815 if (! info->shared
816 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
817 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
818 {
819 /* This case can occur if we saw a PLT32 reloc in an input
820 file, but the symbol was never referred to by a dynamic
821 object. In such a case, we don't actually need to build
822 a procedure linkage table, and we can just do a PC32
823 reloc instead. */
824 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
825 return true;
826 }
827
828 /* Make sure this symbol is output as a dynamic symbol. */
829 if (h->dynindx == -1)
830 {
831 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
832 return false;
833 }
834
835 s = bfd_get_section_by_name (dynobj, ".plt");
836 BFD_ASSERT (s != NULL);
837
838 /* If this is the first .plt entry, make room for the special
839 first entry. */
840 if (s->_raw_size == 0)
841 s->_raw_size += PLT_ENTRY_SIZE;
842
843 /* If this symbol is not defined in a regular file, and we are
844 not generating a shared library, then set the symbol to this
845 location in the .plt. This is required to make function
846 pointers compare as equal between the normal executable and
847 the shared library. */
848 if (! info->shared
849 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
850 {
851 h->root.u.def.section = s;
852 h->root.u.def.value = s->_raw_size;
853 }
854
855 h->plt.offset = s->_raw_size;
856
857 /* Make room for this entry. */
858 s->_raw_size += PLT_ENTRY_SIZE;
859
860 /* We also need to make an entry in the .got.plt section, which
861 will be placed in the .got section by the linker script. */
862
863 s = bfd_get_section_by_name (dynobj, ".got.plt");
864 BFD_ASSERT (s != NULL);
865 s->_raw_size += 4;
866
867 /* We also need to make an entry in the .rel.plt section. */
868
869 s = bfd_get_section_by_name (dynobj, ".rel.plt");
870 BFD_ASSERT (s != NULL);
871 s->_raw_size += sizeof (Elf32_External_Rel);
872
873 return true;
874 }
875
876 /* If this is a weak symbol, and there is a real definition, the
877 processor independent code will have arranged for us to see the
878 real definition first, and we can just use the same value. */
879 if (h->weakdef != NULL)
880 {
881 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
882 || h->weakdef->root.type == bfd_link_hash_defweak);
883 h->root.u.def.section = h->weakdef->root.u.def.section;
884 h->root.u.def.value = h->weakdef->root.u.def.value;
885 return true;
886 }
887
888 /* This is a reference to a symbol defined by a dynamic object which
889 is not a function. */
890
891 /* If we are creating a shared library, we must presume that the
892 only references to the symbol are via the global offset table.
893 For such cases we need not do anything here; the relocations will
894 be handled correctly by relocate_section. */
895 if (info->shared)
896 return true;
897
898 /* If there are no references to this symbol that do not use the
899 GOT, we don't need to generate a copy reloc. */
900 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
901 return true;
902
903 /* We must allocate the symbol in our .dynbss section, which will
904 become part of the .bss section of the executable. There will be
905 an entry for this symbol in the .dynsym section. The dynamic
906 object will contain position independent code, so all references
907 from the dynamic object to this symbol will go through the global
908 offset table. The dynamic linker will use the .dynsym entry to
909 determine the address it must put in the global offset table, so
910 both the dynamic object and the regular object will refer to the
911 same memory location for the variable. */
912
913 s = bfd_get_section_by_name (dynobj, ".dynbss");
914 BFD_ASSERT (s != NULL);
915
916 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
917 copy the initial value out of the dynamic object and into the
918 runtime process image. We need to remember the offset into the
919 .rel.bss section we are going to use. */
920 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
921 {
922 asection *srel;
923
924 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
925 BFD_ASSERT (srel != NULL);
926 srel->_raw_size += sizeof (Elf32_External_Rel);
927 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
928 }
929
930 /* We need to figure out the alignment required for this symbol. I
931 have no idea how ELF linkers handle this. */
932 power_of_two = bfd_log2 (h->size);
933 if (power_of_two > 3)
934 power_of_two = 3;
935
936 /* Apply the required alignment. */
937 s->_raw_size = BFD_ALIGN (s->_raw_size,
938 (bfd_size_type) (1 << power_of_two));
939 if (power_of_two > bfd_get_section_alignment (dynobj, s))
940 {
941 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
942 return false;
943 }
944
945 /* Define the symbol as being at this point in the section. */
946 h->root.u.def.section = s;
947 h->root.u.def.value = s->_raw_size;
948
949 /* Increment the section size to make room for the symbol. */
950 s->_raw_size += h->size;
951
952 return true;
953 }
954
955 /* Set the sizes of the dynamic sections. */
956
957 static boolean
958 elf_i386_size_dynamic_sections (output_bfd, info)
959 bfd *output_bfd;
960 struct bfd_link_info *info;
961 {
962 bfd *dynobj;
963 asection *s;
964 boolean plt;
965 boolean relocs;
966 boolean reltext;
967
968 dynobj = elf_hash_table (info)->dynobj;
969 BFD_ASSERT (dynobj != NULL);
970
971 if (elf_hash_table (info)->dynamic_sections_created)
972 {
973 /* Set the contents of the .interp section to the interpreter. */
974 if (! info->shared)
975 {
976 s = bfd_get_section_by_name (dynobj, ".interp");
977 BFD_ASSERT (s != NULL);
978 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
979 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
980 }
981 }
982 else
983 {
984 /* We may have created entries in the .rel.got section.
985 However, if we are not creating the dynamic sections, we will
986 not actually use these entries. Reset the size of .rel.got,
987 which will cause it to get stripped from the output file
988 below. */
989 s = bfd_get_section_by_name (dynobj, ".rel.got");
990 if (s != NULL)
991 s->_raw_size = 0;
992 }
993
994 /* If this is a -Bsymbolic shared link, then we need to discard all
995 PC relative relocs against symbols defined in a regular object.
996 We allocated space for them in the check_relocs routine, but we
997 will not fill them in in the relocate_section routine. */
998 if (info->shared && info->symbolic)
999 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
1000 elf_i386_discard_copies,
1001 (PTR) NULL);
1002
1003 /* The check_relocs and adjust_dynamic_symbol entry points have
1004 determined the sizes of the various dynamic sections. Allocate
1005 memory for them. */
1006 plt = false;
1007 relocs = false;
1008 reltext = false;
1009 for (s = dynobj->sections; s != NULL; s = s->next)
1010 {
1011 const char *name;
1012 boolean strip;
1013
1014 if ((s->flags & SEC_LINKER_CREATED) == 0)
1015 continue;
1016
1017 /* It's OK to base decisions on the section name, because none
1018 of the dynobj section names depend upon the input files. */
1019 name = bfd_get_section_name (dynobj, s);
1020
1021 strip = false;
1022
1023 if (strcmp (name, ".plt") == 0)
1024 {
1025 if (s->_raw_size == 0)
1026 {
1027 /* Strip this section if we don't need it; see the
1028 comment below. */
1029 strip = true;
1030 }
1031 else
1032 {
1033 /* Remember whether there is a PLT. */
1034 plt = true;
1035 }
1036 }
1037 else if (strncmp (name, ".rel", 4) == 0)
1038 {
1039 if (s->_raw_size == 0)
1040 {
1041 /* If we don't need this section, strip it from the
1042 output file. This is mostly to handle .rel.bss and
1043 .rel.plt. We must create both sections in
1044 create_dynamic_sections, because they must be created
1045 before the linker maps input sections to output
1046 sections. The linker does that before
1047 adjust_dynamic_symbol is called, and it is that
1048 function which decides whether anything needs to go
1049 into these sections. */
1050 strip = true;
1051 }
1052 else
1053 {
1054 asection *target;
1055
1056 /* Remember whether there are any reloc sections other
1057 than .rel.plt. */
1058 if (strcmp (name, ".rel.plt") != 0)
1059 {
1060 const char *outname;
1061
1062 relocs = true;
1063
1064 /* If this relocation section applies to a read only
1065 section, then we probably need a DT_TEXTREL
1066 entry. The entries in the .rel.plt section
1067 really apply to the .got section, which we
1068 created ourselves and so know is not readonly. */
1069 outname = bfd_get_section_name (output_bfd,
1070 s->output_section);
1071 target = bfd_get_section_by_name (output_bfd, outname + 4);
1072 if (target != NULL
1073 && (target->flags & SEC_READONLY) != 0
1074 && (target->flags & SEC_ALLOC) != 0)
1075 reltext = true;
1076 }
1077
1078 /* We use the reloc_count field as a counter if we need
1079 to copy relocs into the output file. */
1080 s->reloc_count = 0;
1081 }
1082 }
1083 else if (strncmp (name, ".got", 4) != 0)
1084 {
1085 /* It's not one of our sections, so don't allocate space. */
1086 continue;
1087 }
1088
1089 if (strip)
1090 {
1091 _bfd_strip_section_from_output (info, s);
1092 continue;
1093 }
1094
1095 /* Allocate memory for the section contents. */
1096 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1097 if (s->contents == NULL && s->_raw_size != 0)
1098 return false;
1099 }
1100
1101 if (elf_hash_table (info)->dynamic_sections_created)
1102 {
1103 /* Add some entries to the .dynamic section. We fill in the
1104 values later, in elf_i386_finish_dynamic_sections, but we
1105 must add the entries now so that we get the correct size for
1106 the .dynamic section. The DT_DEBUG entry is filled in by the
1107 dynamic linker and used by the debugger. */
1108 if (! info->shared)
1109 {
1110 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1111 return false;
1112 }
1113
1114 if (plt)
1115 {
1116 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1117 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1118 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1119 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1120 return false;
1121 }
1122
1123 if (relocs)
1124 {
1125 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1126 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1127 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1128 sizeof (Elf32_External_Rel)))
1129 return false;
1130 }
1131
1132 if (reltext)
1133 {
1134 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1135 return false;
1136 }
1137 }
1138
1139 return true;
1140 }
1141
1142 /* This function is called via elf_i386_link_hash_traverse if we are
1143 creating a shared object with -Bsymbolic. It discards the space
1144 allocated to copy PC relative relocs against symbols which are
1145 defined in regular objects. We allocated space for them in the
1146 check_relocs routine, but we won't fill them in in the
1147 relocate_section routine. */
1148
1149 /*ARGSUSED*/
1150 static boolean
1151 elf_i386_discard_copies (h, ignore)
1152 struct elf_i386_link_hash_entry *h;
1153 PTR ignore ATTRIBUTE_UNUSED;
1154 {
1155 struct elf_i386_pcrel_relocs_copied *s;
1156
1157 /* We only discard relocs for symbols defined in a regular object. */
1158 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1159 return true;
1160
1161 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1162 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1163
1164 return true;
1165 }
1166
1167 /* Relocate an i386 ELF section. */
1168
1169 static boolean
1170 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1171 contents, relocs, local_syms, local_sections)
1172 bfd *output_bfd;
1173 struct bfd_link_info *info;
1174 bfd *input_bfd;
1175 asection *input_section;
1176 bfd_byte *contents;
1177 Elf_Internal_Rela *relocs;
1178 Elf_Internal_Sym *local_syms;
1179 asection **local_sections;
1180 {
1181 bfd *dynobj;
1182 Elf_Internal_Shdr *symtab_hdr;
1183 struct elf_link_hash_entry **sym_hashes;
1184 bfd_vma *local_got_offsets;
1185 asection *sgot;
1186 asection *splt;
1187 asection *sreloc;
1188 Elf_Internal_Rela *rel;
1189 Elf_Internal_Rela *relend;
1190
1191 dynobj = elf_hash_table (info)->dynobj;
1192 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1193 sym_hashes = elf_sym_hashes (input_bfd);
1194 local_got_offsets = elf_local_got_offsets (input_bfd);
1195
1196 sgot = NULL;
1197 splt = NULL;
1198 sreloc = NULL;
1199
1200 rel = relocs;
1201 relend = relocs + input_section->reloc_count;
1202 for (; rel < relend; rel++)
1203 {
1204 int r_type;
1205 reloc_howto_type *howto;
1206 unsigned long r_symndx;
1207 struct elf_link_hash_entry *h;
1208 Elf_Internal_Sym *sym;
1209 asection *sec;
1210 bfd_vma relocation;
1211 bfd_reloc_status_type r;
1212
1213 r_type = ELF32_R_TYPE (rel->r_info);
1214 if (r_type == R_386_GNU_VTINHERIT
1215 || r_type == R_386_GNU_VTENTRY)
1216 continue;
1217 if (r_type < 0
1218 || r_type >= (int) R_386_max
1219 || (r_type >= (int) FIRST_INVALID_RELOC
1220 && r_type <= (int) LAST_INVALID_RELOC))
1221 {
1222 bfd_set_error (bfd_error_bad_value);
1223 return false;
1224 }
1225 howto = elf_howto_table + r_type;
1226
1227 r_symndx = ELF32_R_SYM (rel->r_info);
1228
1229 if (info->relocateable)
1230 {
1231 /* This is a relocateable link. We don't have to change
1232 anything, unless the reloc is against a section symbol,
1233 in which case we have to adjust according to where the
1234 section symbol winds up in the output section. */
1235 if (r_symndx < symtab_hdr->sh_info)
1236 {
1237 sym = local_syms + r_symndx;
1238 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1239 {
1240 bfd_vma val;
1241
1242 sec = local_sections[r_symndx];
1243 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1244 val += sec->output_offset + sym->st_value;
1245 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1246 }
1247 }
1248
1249 continue;
1250 }
1251
1252 /* This is a final link. */
1253 h = NULL;
1254 sym = NULL;
1255 sec = NULL;
1256 if (r_symndx < symtab_hdr->sh_info)
1257 {
1258 sym = local_syms + r_symndx;
1259 sec = local_sections[r_symndx];
1260 relocation = (sec->output_section->vma
1261 + sec->output_offset
1262 + sym->st_value);
1263 }
1264 else
1265 {
1266 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1267 while (h->root.type == bfd_link_hash_indirect
1268 || h->root.type == bfd_link_hash_warning)
1269 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1270 if (h->root.type == bfd_link_hash_defined
1271 || h->root.type == bfd_link_hash_defweak)
1272 {
1273 sec = h->root.u.def.section;
1274 if (r_type == R_386_GOTPC
1275 || (r_type == R_386_PLT32
1276 && h->plt.offset != (bfd_vma) -1)
1277 || (r_type == R_386_GOT32
1278 && elf_hash_table (info)->dynamic_sections_created
1279 && (! info->shared
1280 || (! info->symbolic && h->dynindx != -1)
1281 || (h->elf_link_hash_flags
1282 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1283 || (info->shared
1284 && ((! info->symbolic && h->dynindx != -1)
1285 || (h->elf_link_hash_flags
1286 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1287 && (r_type == R_386_32
1288 || r_type == R_386_PC32)
1289 && ((input_section->flags & SEC_ALLOC) != 0
1290 /* DWARF will emit R_386_32 relocations in its
1291 sections against symbols defined externally
1292 in shared libraries. We can't do anything
1293 with them here. */
1294 || (input_section->flags & SEC_DEBUGGING) != 0)))
1295 {
1296 /* In these cases, we don't need the relocation
1297 value. We check specially because in some
1298 obscure cases sec->output_section will be NULL. */
1299 relocation = 0;
1300 }
1301 else if (sec->output_section == NULL)
1302 {
1303 (*_bfd_error_handler)
1304 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1305 bfd_get_filename (input_bfd), h->root.root.string,
1306 bfd_get_section_name (input_bfd, input_section));
1307 relocation = 0;
1308 }
1309 else
1310 relocation = (h->root.u.def.value
1311 + sec->output_section->vma
1312 + sec->output_offset);
1313 }
1314 else if (h->root.type == bfd_link_hash_undefweak)
1315 relocation = 0;
1316 else if (info->shared && !info->symbolic && !info->no_undefined)
1317 relocation = 0;
1318 else
1319 {
1320 if (! ((*info->callbacks->undefined_symbol)
1321 (info, h->root.root.string, input_bfd,
1322 input_section, rel->r_offset)))
1323 return false;
1324 relocation = 0;
1325 }
1326 }
1327
1328 switch (r_type)
1329 {
1330 case R_386_GOT32:
1331 /* Relocation is to the entry for this symbol in the global
1332 offset table. */
1333 if (sgot == NULL)
1334 {
1335 sgot = bfd_get_section_by_name (dynobj, ".got");
1336 BFD_ASSERT (sgot != NULL);
1337 }
1338
1339 if (h != NULL)
1340 {
1341 bfd_vma off;
1342
1343 off = h->got.offset;
1344 BFD_ASSERT (off != (bfd_vma) -1);
1345
1346 if (! elf_hash_table (info)->dynamic_sections_created
1347 || (info->shared
1348 && (info->symbolic || h->dynindx == -1)
1349 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1350 {
1351 /* This is actually a static link, or it is a
1352 -Bsymbolic link and the symbol is defined
1353 locally, or the symbol was forced to be local
1354 because of a version file. We must initialize
1355 this entry in the global offset table. Since the
1356 offset must always be a multiple of 4, we use the
1357 least significant bit to record whether we have
1358 initialized it already.
1359
1360 When doing a dynamic link, we create a .rel.got
1361 relocation entry to initialize the value. This
1362 is done in the finish_dynamic_symbol routine. */
1363 if ((off & 1) != 0)
1364 off &= ~1;
1365 else
1366 {
1367 bfd_put_32 (output_bfd, relocation,
1368 sgot->contents + off);
1369 h->got.offset |= 1;
1370 }
1371 }
1372
1373 relocation = sgot->output_offset + off;
1374 }
1375 else
1376 {
1377 bfd_vma off;
1378
1379 BFD_ASSERT (local_got_offsets != NULL
1380 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1381
1382 off = local_got_offsets[r_symndx];
1383
1384 /* The offset must always be a multiple of 4. We use
1385 the least significant bit to record whether we have
1386 already generated the necessary reloc. */
1387 if ((off & 1) != 0)
1388 off &= ~1;
1389 else
1390 {
1391 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1392
1393 if (info->shared)
1394 {
1395 asection *srelgot;
1396 Elf_Internal_Rel outrel;
1397
1398 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1399 BFD_ASSERT (srelgot != NULL);
1400
1401 outrel.r_offset = (sgot->output_section->vma
1402 + sgot->output_offset
1403 + off);
1404 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1405 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1406 (((Elf32_External_Rel *)
1407 srelgot->contents)
1408 + srelgot->reloc_count));
1409 ++srelgot->reloc_count;
1410 }
1411
1412 local_got_offsets[r_symndx] |= 1;
1413 }
1414
1415 relocation = sgot->output_offset + off;
1416 }
1417
1418 break;
1419
1420 case R_386_GOTOFF:
1421 /* Relocation is relative to the start of the global offset
1422 table. */
1423
1424 if (sgot == NULL)
1425 {
1426 sgot = bfd_get_section_by_name (dynobj, ".got");
1427 BFD_ASSERT (sgot != NULL);
1428 }
1429
1430 /* Note that sgot->output_offset is not involved in this
1431 calculation. We always want the start of .got. If we
1432 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1433 permitted by the ABI, we might have to change this
1434 calculation. */
1435 relocation -= sgot->output_section->vma;
1436
1437 break;
1438
1439 case R_386_GOTPC:
1440 /* Use global offset table as symbol value. */
1441
1442 if (sgot == NULL)
1443 {
1444 sgot = bfd_get_section_by_name (dynobj, ".got");
1445 BFD_ASSERT (sgot != NULL);
1446 }
1447
1448 relocation = sgot->output_section->vma;
1449
1450 break;
1451
1452 case R_386_PLT32:
1453 /* Relocation is to the entry for this symbol in the
1454 procedure linkage table. */
1455
1456 /* Resolve a PLT32 reloc again a local symbol directly,
1457 without using the procedure linkage table. */
1458 if (h == NULL)
1459 break;
1460
1461 if (h->plt.offset == (bfd_vma) -1)
1462 {
1463 /* We didn't make a PLT entry for this symbol. This
1464 happens when statically linking PIC code, or when
1465 using -Bsymbolic. */
1466 break;
1467 }
1468
1469 if (splt == NULL)
1470 {
1471 splt = bfd_get_section_by_name (dynobj, ".plt");
1472 BFD_ASSERT (splt != NULL);
1473 }
1474
1475 relocation = (splt->output_section->vma
1476 + splt->output_offset
1477 + h->plt.offset);
1478
1479 break;
1480
1481 case R_386_32:
1482 case R_386_PC32:
1483 if (info->shared
1484 && (input_section->flags & SEC_ALLOC) != 0
1485 && (r_type != R_386_PC32
1486 || (h != NULL
1487 && h->dynindx != -1
1488 && (! info->symbolic
1489 || (h->elf_link_hash_flags
1490 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1491 {
1492 Elf_Internal_Rel outrel;
1493 boolean skip, relocate;
1494
1495 /* When generating a shared object, these relocations
1496 are copied into the output file to be resolved at run
1497 time. */
1498
1499 if (sreloc == NULL)
1500 {
1501 const char *name;
1502
1503 name = (bfd_elf_string_from_elf_section
1504 (input_bfd,
1505 elf_elfheader (input_bfd)->e_shstrndx,
1506 elf_section_data (input_section)->rel_hdr.sh_name));
1507 if (name == NULL)
1508 return false;
1509
1510 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1511 && strcmp (bfd_get_section_name (input_bfd,
1512 input_section),
1513 name + 4) == 0);
1514
1515 sreloc = bfd_get_section_by_name (dynobj, name);
1516 BFD_ASSERT (sreloc != NULL);
1517 }
1518
1519 skip = false;
1520
1521 if (elf_section_data (input_section)->stab_info == NULL)
1522 outrel.r_offset = rel->r_offset;
1523 else
1524 {
1525 bfd_vma off;
1526
1527 off = (_bfd_stab_section_offset
1528 (output_bfd, &elf_hash_table (info)->stab_info,
1529 input_section,
1530 &elf_section_data (input_section)->stab_info,
1531 rel->r_offset));
1532 if (off == (bfd_vma) -1)
1533 skip = true;
1534 outrel.r_offset = off;
1535 }
1536
1537 outrel.r_offset += (input_section->output_section->vma
1538 + input_section->output_offset);
1539
1540 if (skip)
1541 {
1542 memset (&outrel, 0, sizeof outrel);
1543 relocate = false;
1544 }
1545 else if (r_type == R_386_PC32)
1546 {
1547 BFD_ASSERT (h != NULL && h->dynindx != -1);
1548 relocate = false;
1549 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1550 }
1551 else
1552 {
1553 /* h->dynindx may be -1 if this symbol was marked to
1554 become local. */
1555 if (h == NULL
1556 || ((info->symbolic || h->dynindx == -1)
1557 && (h->elf_link_hash_flags
1558 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1559 {
1560 relocate = true;
1561 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1562 }
1563 else
1564 {
1565 BFD_ASSERT (h->dynindx != -1);
1566 relocate = false;
1567 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1568 }
1569 }
1570
1571 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1572 (((Elf32_External_Rel *)
1573 sreloc->contents)
1574 + sreloc->reloc_count));
1575 ++sreloc->reloc_count;
1576
1577 /* If this reloc is against an external symbol, we do
1578 not want to fiddle with the addend. Otherwise, we
1579 need to include the symbol value so that it becomes
1580 an addend for the dynamic reloc. */
1581 if (! relocate)
1582 continue;
1583 }
1584
1585 break;
1586
1587 default:
1588 break;
1589 }
1590
1591 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1592 contents, rel->r_offset,
1593 relocation, (bfd_vma) 0);
1594
1595 if (r != bfd_reloc_ok)
1596 {
1597 switch (r)
1598 {
1599 default:
1600 case bfd_reloc_outofrange:
1601 abort ();
1602 case bfd_reloc_overflow:
1603 {
1604 const char *name;
1605
1606 if (h != NULL)
1607 name = h->root.root.string;
1608 else
1609 {
1610 name = bfd_elf_string_from_elf_section (input_bfd,
1611 symtab_hdr->sh_link,
1612 sym->st_name);
1613 if (name == NULL)
1614 return false;
1615 if (*name == '\0')
1616 name = bfd_section_name (input_bfd, sec);
1617 }
1618 if (! ((*info->callbacks->reloc_overflow)
1619 (info, name, howto->name, (bfd_vma) 0,
1620 input_bfd, input_section, rel->r_offset)))
1621 return false;
1622 }
1623 break;
1624 }
1625 }
1626 }
1627
1628 return true;
1629 }
1630
1631 /* Finish up dynamic symbol handling. We set the contents of various
1632 dynamic sections here. */
1633
1634 static boolean
1635 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1636 bfd *output_bfd;
1637 struct bfd_link_info *info;
1638 struct elf_link_hash_entry *h;
1639 Elf_Internal_Sym *sym;
1640 {
1641 bfd *dynobj;
1642
1643 dynobj = elf_hash_table (info)->dynobj;
1644
1645 if (h->plt.offset != (bfd_vma) -1)
1646 {
1647 asection *splt;
1648 asection *sgot;
1649 asection *srel;
1650 bfd_vma plt_index;
1651 bfd_vma got_offset;
1652 Elf_Internal_Rel rel;
1653
1654 /* This symbol has an entry in the procedure linkage table. Set
1655 it up. */
1656
1657 BFD_ASSERT (h->dynindx != -1);
1658
1659 splt = bfd_get_section_by_name (dynobj, ".plt");
1660 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1661 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1662 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1663
1664 /* Get the index in the procedure linkage table which
1665 corresponds to this symbol. This is the index of this symbol
1666 in all the symbols for which we are making plt entries. The
1667 first entry in the procedure linkage table is reserved. */
1668 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1669
1670 /* Get the offset into the .got table of the entry that
1671 corresponds to this function. Each .got entry is 4 bytes.
1672 The first three are reserved. */
1673 got_offset = (plt_index + 3) * 4;
1674
1675 /* Fill in the entry in the procedure linkage table. */
1676 if (! info->shared)
1677 {
1678 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1679 PLT_ENTRY_SIZE);
1680 bfd_put_32 (output_bfd,
1681 (sgot->output_section->vma
1682 + sgot->output_offset
1683 + got_offset),
1684 splt->contents + h->plt.offset + 2);
1685 }
1686 else
1687 {
1688 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1689 PLT_ENTRY_SIZE);
1690 bfd_put_32 (output_bfd, got_offset,
1691 splt->contents + h->plt.offset + 2);
1692 }
1693
1694 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1695 splt->contents + h->plt.offset + 7);
1696 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1697 splt->contents + h->plt.offset + 12);
1698
1699 /* Fill in the entry in the global offset table. */
1700 bfd_put_32 (output_bfd,
1701 (splt->output_section->vma
1702 + splt->output_offset
1703 + h->plt.offset
1704 + 6),
1705 sgot->contents + got_offset);
1706
1707 /* Fill in the entry in the .rel.plt section. */
1708 rel.r_offset = (sgot->output_section->vma
1709 + sgot->output_offset
1710 + got_offset);
1711 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1712 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1713 ((Elf32_External_Rel *) srel->contents
1714 + plt_index));
1715
1716 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1717 {
1718 /* Mark the symbol as undefined, rather than as defined in
1719 the .plt section. Leave the value alone. */
1720 sym->st_shndx = SHN_UNDEF;
1721 }
1722 }
1723
1724 if (h->got.offset != (bfd_vma) -1)
1725 {
1726 asection *sgot;
1727 asection *srel;
1728 Elf_Internal_Rel rel;
1729
1730 /* This symbol has an entry in the global offset table. Set it
1731 up. */
1732
1733 sgot = bfd_get_section_by_name (dynobj, ".got");
1734 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1735 BFD_ASSERT (sgot != NULL && srel != NULL);
1736
1737 rel.r_offset = (sgot->output_section->vma
1738 + sgot->output_offset
1739 + (h->got.offset &~ 1));
1740
1741 /* If this is a -Bsymbolic link, and the symbol is defined
1742 locally, we just want to emit a RELATIVE reloc. Likewise if
1743 the symbol was forced to be local because of a version file.
1744 The entry in the global offset table will already have been
1745 initialized in the relocate_section function. */
1746 if (info->shared
1747 && (info->symbolic || h->dynindx == -1)
1748 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1749 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1750 else
1751 {
1752 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1753 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1754 }
1755
1756 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1757 ((Elf32_External_Rel *) srel->contents
1758 + srel->reloc_count));
1759 ++srel->reloc_count;
1760 }
1761
1762 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1763 {
1764 asection *s;
1765 Elf_Internal_Rel rel;
1766
1767 /* This symbol needs a copy reloc. Set it up. */
1768
1769 BFD_ASSERT (h->dynindx != -1
1770 && (h->root.type == bfd_link_hash_defined
1771 || h->root.type == bfd_link_hash_defweak));
1772
1773 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1774 ".rel.bss");
1775 BFD_ASSERT (s != NULL);
1776
1777 rel.r_offset = (h->root.u.def.value
1778 + h->root.u.def.section->output_section->vma
1779 + h->root.u.def.section->output_offset);
1780 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1781 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1782 ((Elf32_External_Rel *) s->contents
1783 + s->reloc_count));
1784 ++s->reloc_count;
1785 }
1786
1787 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1788 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1789 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1790 sym->st_shndx = SHN_ABS;
1791
1792 return true;
1793 }
1794
1795 /* Finish up the dynamic sections. */
1796
1797 static boolean
1798 elf_i386_finish_dynamic_sections (output_bfd, info)
1799 bfd *output_bfd;
1800 struct bfd_link_info *info;
1801 {
1802 bfd *dynobj;
1803 asection *sgot;
1804 asection *sdyn;
1805
1806 dynobj = elf_hash_table (info)->dynobj;
1807
1808 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1809 BFD_ASSERT (sgot != NULL);
1810 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1811
1812 if (elf_hash_table (info)->dynamic_sections_created)
1813 {
1814 asection *splt;
1815 Elf32_External_Dyn *dyncon, *dynconend;
1816
1817 BFD_ASSERT (sdyn != NULL);
1818
1819 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1820 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1821 for (; dyncon < dynconend; dyncon++)
1822 {
1823 Elf_Internal_Dyn dyn;
1824 const char *name;
1825 asection *s;
1826
1827 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1828
1829 switch (dyn.d_tag)
1830 {
1831 default:
1832 break;
1833
1834 case DT_PLTGOT:
1835 name = ".got";
1836 goto get_vma;
1837 case DT_JMPREL:
1838 name = ".rel.plt";
1839 get_vma:
1840 s = bfd_get_section_by_name (output_bfd, name);
1841 BFD_ASSERT (s != NULL);
1842 dyn.d_un.d_ptr = s->vma;
1843 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1844 break;
1845
1846 case DT_PLTRELSZ:
1847 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1848 BFD_ASSERT (s != NULL);
1849 if (s->_cooked_size != 0)
1850 dyn.d_un.d_val = s->_cooked_size;
1851 else
1852 dyn.d_un.d_val = s->_raw_size;
1853 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1854 break;
1855
1856 case DT_RELSZ:
1857 /* My reading of the SVR4 ABI indicates that the
1858 procedure linkage table relocs (DT_JMPREL) should be
1859 included in the overall relocs (DT_REL). This is
1860 what Solaris does. However, UnixWare can not handle
1861 that case. Therefore, we override the DT_RELSZ entry
1862 here to make it not include the JMPREL relocs. Since
1863 the linker script arranges for .rel.plt to follow all
1864 other relocation sections, we don't have to worry
1865 about changing the DT_REL entry. */
1866 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1867 if (s != NULL)
1868 {
1869 if (s->_cooked_size != 0)
1870 dyn.d_un.d_val -= s->_cooked_size;
1871 else
1872 dyn.d_un.d_val -= s->_raw_size;
1873 }
1874 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1875 break;
1876 }
1877 }
1878
1879 /* Fill in the first entry in the procedure linkage table. */
1880 splt = bfd_get_section_by_name (dynobj, ".plt");
1881 if (splt && splt->_raw_size > 0)
1882 {
1883 if (info->shared)
1884 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1885 else
1886 {
1887 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1888 bfd_put_32 (output_bfd,
1889 sgot->output_section->vma + sgot->output_offset + 4,
1890 splt->contents + 2);
1891 bfd_put_32 (output_bfd,
1892 sgot->output_section->vma + sgot->output_offset + 8,
1893 splt->contents + 8);
1894 }
1895
1896 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1897 really seem like the right value. */
1898 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1899 }
1900 }
1901
1902 /* Fill in the first three entries in the global offset table. */
1903 if (sgot->_raw_size > 0)
1904 {
1905 if (sdyn == NULL)
1906 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1907 else
1908 bfd_put_32 (output_bfd,
1909 sdyn->output_section->vma + sdyn->output_offset,
1910 sgot->contents);
1911 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1912 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1913 }
1914
1915 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1916
1917 return true;
1918 }
1919
1920 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1921 #define TARGET_LITTLE_NAME "elf32-i386"
1922 #define ELF_ARCH bfd_arch_i386
1923 #define ELF_MACHINE_CODE EM_386
1924 #define ELF_MAXPAGESIZE 0x1000
1925 #define elf_info_to_howto elf_i386_info_to_howto
1926 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1927 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
1928 #define bfd_elf32_bfd_is_local_label_name \
1929 elf_i386_is_local_label_name
1930 #define elf_backend_create_dynamic_sections \
1931 _bfd_elf_create_dynamic_sections
1932 #define bfd_elf32_bfd_link_hash_table_create \
1933 elf_i386_link_hash_table_create
1934 #define elf_backend_check_relocs elf_i386_check_relocs
1935 #define elf_backend_adjust_dynamic_symbol \
1936 elf_i386_adjust_dynamic_symbol
1937 #define elf_backend_size_dynamic_sections \
1938 elf_i386_size_dynamic_sections
1939 #define elf_backend_relocate_section elf_i386_relocate_section
1940 #define elf_backend_finish_dynamic_symbol \
1941 elf_i386_finish_dynamic_symbol
1942 #define elf_backend_finish_dynamic_sections \
1943 elf_i386_finish_dynamic_sections
1944 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
1945 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
1946
1947 #define elf_backend_can_gc_sections 1
1948 #define elf_backend_want_got_plt 1
1949 #define elf_backend_plt_readonly 1
1950 #define elf_backend_want_plt_sym 0
1951 #define elf_backend_got_header_size 12
1952 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
1953
1954 #include "elf32-target.h"
git-cvsimport of binutils cvsroot