1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
3 Contributed by Jon Beniston <jon@beniston.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #define DEFAULT_STACK_SIZE 0x20000
30 #define PLT_ENTRY_SIZE 20
32 #define PLT0_ENTRY_WORD0 0
33 #define PLT0_ENTRY_WORD1 0
34 #define PLT0_ENTRY_WORD2 0
35 #define PLT0_ENTRY_WORD3 0
36 #define PLT0_ENTRY_WORD4 0
38 #define PLT0_PIC_ENTRY_WORD0 0
39 #define PLT0_PIC_ENTRY_WORD1 0
40 #define PLT0_PIC_ENTRY_WORD2 0
41 #define PLT0_PIC_ENTRY_WORD3 0
42 #define PLT0_PIC_ENTRY_WORD4 0
44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
46 extern const bfd_target bfd_elf32_lm32fdpic_vec
;
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_lm32fdpic_vec)
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 /* The linker needs to keep track of the number of relocs that it
54 decides to copy as dynamic relocs in check_relocs for each symbol.
55 This is so that it can later discard them if they are found to be
56 unnecessary. We store the information in a field extending the
57 regular ELF linker hash table. */
59 struct elf_lm32_dyn_relocs
61 struct elf_lm32_dyn_relocs
*next
;
63 /* The input section of the reloc. */
66 /* Total number of relocs copied for the input section. */
69 /* Number of pc-relative relocs copied for the input section. */
70 bfd_size_type pc_count
;
73 /* lm32 ELF linker hash entry. */
75 struct elf_lm32_link_hash_entry
77 struct elf_link_hash_entry root
;
79 /* Track dynamic relocs copied for this symbol. */
80 struct elf_lm32_dyn_relocs
*dyn_relocs
;
83 /* lm32 ELF linker hash table. */
85 struct elf_lm32_link_hash_table
87 struct elf_link_hash_table root
;
89 /* Short-cuts to get to dynamic linker sections. */
102 /* Get the lm32 ELF linker hash table from a link_info structure. */
104 #define lm32_elf_hash_table(p) \
105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
106 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
108 #define lm32fdpic_got_section(info) \
109 (lm32_elf_hash_table (info)->sgot)
110 #define lm32fdpic_gotrel_section(info) \
111 (lm32_elf_hash_table (info)->srelgot)
112 #define lm32fdpic_fixup32_section(info) \
113 (lm32_elf_hash_table (info)->sfixup32)
115 struct weak_symbol_list
118 struct weak_symbol_list
*next
;
121 /* Create an entry in an lm32 ELF linker hash table. */
123 static struct bfd_hash_entry
*
124 lm32_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
125 struct bfd_hash_table
*table
,
128 struct elf_lm32_link_hash_entry
*ret
=
129 (struct elf_lm32_link_hash_entry
*) entry
;
131 /* Allocate the structure if it has not already been allocated by a
134 ret
= bfd_hash_allocate (table
,
135 sizeof (struct elf_lm32_link_hash_entry
));
139 /* Call the allocation method of the superclass. */
140 ret
= ((struct elf_lm32_link_hash_entry
*)
141 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
145 struct elf_lm32_link_hash_entry
*eh
;
147 eh
= (struct elf_lm32_link_hash_entry
*) ret
;
148 eh
->dyn_relocs
= NULL
;
151 return (struct bfd_hash_entry
*) ret
;
154 /* Create an lm32 ELF linker hash table. */
156 static struct bfd_link_hash_table
*
157 lm32_elf_link_hash_table_create (bfd
*abfd
)
159 struct elf_lm32_link_hash_table
*ret
;
160 bfd_size_type amt
= sizeof (struct elf_lm32_link_hash_table
);
162 ret
= bfd_malloc (amt
);
166 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
167 lm32_elf_link_hash_newfunc
,
168 sizeof (struct elf_lm32_link_hash_entry
),
178 ret
->sfixup32
= NULL
;
185 return &ret
->root
.root
;
188 /* Add a fixup to the ROFIXUP section. */
191 _lm32fdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma relocation
)
193 bfd_vma fixup_offset
;
195 if (rofixup
->flags
& SEC_EXCLUDE
)
198 fixup_offset
= rofixup
->reloc_count
* 4;
199 if (rofixup
->contents
)
201 BFD_ASSERT (fixup_offset
< rofixup
->size
);
202 if (fixup_offset
< rofixup
->size
)
203 bfd_put_32 (output_bfd
, relocation
, rofixup
->contents
+ fixup_offset
);
205 rofixup
->reloc_count
++;
210 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
211 shortcuts to them in our hash table. */
214 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
216 struct elf_lm32_link_hash_table
*htab
;
219 /* This function may be called more than once. */
220 s
= bfd_get_section_by_name (dynobj
, ".got");
221 if (s
!= NULL
&& (s
->flags
& SEC_LINKER_CREATED
) != 0)
224 htab
= lm32_elf_hash_table (info
);
228 if (! _bfd_elf_create_got_section (dynobj
, info
))
231 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
232 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
233 htab
->srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
234 if (! htab
->sgot
|| ! htab
->sgotplt
|| ! htab
->srelgot
)
240 /* Create .rofixup sections in DYNOBJ, and set up
241 shortcuts to them in our hash table. */
244 create_rofixup_section (bfd
*dynobj
, struct bfd_link_info
*info
)
246 struct elf_lm32_link_hash_table
*htab
;
247 htab
= lm32_elf_hash_table (info
);
252 /* Fixup section for R_LM32_32 relocs. */
253 lm32fdpic_fixup32_section (info
) = bfd_make_section_with_flags (dynobj
,
261 if (lm32fdpic_fixup32_section (info
) == NULL
262 || ! bfd_set_section_alignment (dynobj
, lm32fdpic_fixup32_section (info
), 2))
268 static reloc_howto_type lm32_elf_howto_table
[] =
270 /* This reloc does nothing. */
271 HOWTO (R_LM32_NONE
, /* type */
273 2, /* size (0 = byte, 1 = short, 2 = long) */
275 FALSE
, /* pc_relative */
277 complain_overflow_bitfield
,/* complain_on_overflow */
278 bfd_elf_generic_reloc
, /* special_function */
279 "R_LM32_NONE", /* name */
280 FALSE
, /* partial_inplace */
283 FALSE
), /* pcrel_offset */
285 /* An 8 bit absolute relocation. */
286 HOWTO (R_LM32_8
, /* type */
288 0, /* size (0 = byte, 1 = short, 2 = long) */
290 FALSE
, /* pc_relative */
292 complain_overflow_bitfield
,/* complain_on_overflow */
293 bfd_elf_generic_reloc
, /* special_function */
294 "R_LM32_8", /* name */
295 FALSE
, /* partial_inplace */
298 FALSE
), /* pcrel_offset */
300 /* A 16 bit absolute relocation. */
301 HOWTO (R_LM32_16
, /* type */
303 1, /* size (0 = byte, 1 = short, 2 = long) */
305 FALSE
, /* pc_relative */
307 complain_overflow_bitfield
,/* complain_on_overflow */
308 bfd_elf_generic_reloc
, /* special_function */
309 "R_LM32_16", /* name */
310 FALSE
, /* partial_inplace */
312 0xffff, /* dst_mask */
313 FALSE
), /* pcrel_offset */
315 /* A 32 bit absolute relocation. */
316 HOWTO (R_LM32_32
, /* type */
318 2, /* size (0 = byte, 1 = short, 2 = long) */
320 FALSE
, /* pc_relative */
322 complain_overflow_bitfield
,/* complain_on_overflow */
323 bfd_elf_generic_reloc
, /* special_function */
324 "R_LM32_32", /* name */
325 FALSE
, /* partial_inplace */
327 0xffffffff, /* dst_mask */
328 FALSE
), /* pcrel_offset */
330 HOWTO (R_LM32_HI16
, /* type */
332 2, /* size (0 = byte, 1 = short, 2 = long) */
334 FALSE
, /* pc_relative */
336 complain_overflow_bitfield
,/* complain_on_overflow */
337 bfd_elf_generic_reloc
, /* special_function */
338 "R_LM32_HI16", /* name */
339 FALSE
, /* partial_inplace */
341 0xffff, /* dst_mask */
342 FALSE
), /* pcrel_offset */
344 HOWTO (R_LM32_LO16
, /* type */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
348 FALSE
, /* pc_relative */
350 complain_overflow_dont
, /* complain_on_overflow */
351 bfd_elf_generic_reloc
, /* special_function */
352 "R_LM32_LO16", /* name */
353 FALSE
, /* partial_inplace */
355 0xffff, /* dst_mask */
356 FALSE
), /* pcrel_offset */
358 HOWTO (R_LM32_GPREL16
, /* type */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
362 FALSE
, /* pc_relative */
364 complain_overflow_dont
, /* complain_on_overflow */
365 lm32_elf_gprel_reloc
, /* special_function */
366 "R_LM32_GPREL16", /* name */
367 FALSE
, /* partial_inplace */
369 0xffff, /* dst_mask */
370 FALSE
), /* pcrel_offset */
372 HOWTO (R_LM32_CALL
, /* type */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
376 TRUE
, /* pc_relative */
378 complain_overflow_signed
, /* complain_on_overflow */
379 bfd_elf_generic_reloc
, /* special_function */
380 "R_LM32_CALL", /* name */
381 FALSE
, /* partial_inplace */
383 0x3ffffff, /* dst_mask */
384 TRUE
), /* pcrel_offset */
386 HOWTO (R_LM32_BRANCH
, /* type */
388 2, /* size (0 = byte, 1 = short, 2 = long) */
390 TRUE
, /* pc_relative */
392 complain_overflow_signed
, /* complain_on_overflow */
393 bfd_elf_generic_reloc
, /* special_function */
394 "R_LM32_BRANCH", /* name */
395 FALSE
, /* partial_inplace */
397 0xffff, /* dst_mask */
398 TRUE
), /* pcrel_offset */
400 /* GNU extension to record C++ vtable hierarchy. */
401 HOWTO (R_LM32_GNU_VTINHERIT
, /* type */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
405 FALSE
, /* pc_relative */
407 complain_overflow_dont
, /* complain_on_overflow */
408 NULL
, /* special_function */
409 "R_LM32_GNU_VTINHERIT", /* name */
410 FALSE
, /* partial_inplace */
413 FALSE
), /* pcrel_offset */
415 /* GNU extension to record C++ vtable member usage. */
416 HOWTO (R_LM32_GNU_VTENTRY
, /* type */
418 2, /* size (0 = byte, 1 = short, 2 = long) */
420 FALSE
, /* pc_relative */
422 complain_overflow_dont
, /* complain_on_overflow */
423 _bfd_elf_rel_vtable_reloc_fn
,/* special_function */
424 "R_LM32_GNU_VTENTRY", /* name */
425 FALSE
, /* partial_inplace */
428 FALSE
), /* pcrel_offset */
430 HOWTO (R_LM32_16_GOT
, /* type */
432 2, /* size (0 = byte, 1 = short, 2 = long) */
434 FALSE
, /* pc_relative */
436 complain_overflow_signed
, /* complain_on_overflow */
437 bfd_elf_generic_reloc
, /* special_function */
438 "R_LM32_16_GOT", /* name */
439 FALSE
, /* partial_inplace */
441 0xffff, /* dst_mask */
442 FALSE
), /* pcrel_offset */
444 HOWTO (R_LM32_GOTOFF_HI16
, /* type */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
448 FALSE
, /* pc_relative */
450 complain_overflow_dont
, /* complain_on_overflow */
451 bfd_elf_generic_reloc
, /* special_function */
452 "R_LM32_GOTOFF_HI16", /* name */
453 FALSE
, /* partial_inplace */
454 0xffff, /* src_mask */
455 0xffff, /* dst_mask */
456 FALSE
), /* pcrel_offset */
458 HOWTO (R_LM32_GOTOFF_LO16
, /* type */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
462 FALSE
, /* pc_relative */
464 complain_overflow_dont
, /* complain_on_overflow */
465 bfd_elf_generic_reloc
, /* special_function */
466 "R_LM32_GOTOFF_LO16", /* name */
467 FALSE
, /* partial_inplace */
468 0xffff, /* src_mask */
469 0xffff, /* dst_mask */
470 FALSE
), /* pcrel_offset */
472 HOWTO (R_LM32_COPY
, /* type */
474 2, /* size (0 = byte, 1 = short, 2 = long) */
476 FALSE
, /* pc_relative */
478 complain_overflow_bitfield
, /* complain_on_overflow */
479 bfd_elf_generic_reloc
, /* special_function */
480 "R_LM32_COPY", /* name */
481 FALSE
, /* partial_inplace */
482 0xffffffff, /* src_mask */
483 0xffffffff, /* dst_mask */
484 FALSE
), /* pcrel_offset */
486 HOWTO (R_LM32_GLOB_DAT
, /* type */
488 2, /* size (0 = byte, 1 = short, 2 = long) */
490 FALSE
, /* pc_relative */
492 complain_overflow_bitfield
, /* complain_on_overflow */
493 bfd_elf_generic_reloc
, /* special_function */
494 "R_LM32_GLOB_DAT", /* name */
495 FALSE
, /* partial_inplace */
496 0xffffffff, /* src_mask */
497 0xffffffff, /* dst_mask */
498 FALSE
), /* pcrel_offset */
500 HOWTO (R_LM32_JMP_SLOT
, /* type */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
504 FALSE
, /* pc_relative */
506 complain_overflow_bitfield
, /* complain_on_overflow */
507 bfd_elf_generic_reloc
, /* special_function */
508 "R_LM32_JMP_SLOT", /* name */
509 FALSE
, /* partial_inplace */
510 0xffffffff, /* src_mask */
511 0xffffffff, /* dst_mask */
512 FALSE
), /* pcrel_offset */
514 HOWTO (R_LM32_RELATIVE
, /* type */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
518 FALSE
, /* pc_relative */
520 complain_overflow_bitfield
, /* complain_on_overflow */
521 bfd_elf_generic_reloc
, /* special_function */
522 "R_LM32_RELATIVE", /* name */
523 FALSE
, /* partial_inplace */
524 0xffffffff, /* src_mask */
525 0xffffffff, /* dst_mask */
526 FALSE
), /* pcrel_offset */
530 /* Map BFD reloc types to lm32 ELF reloc types. */
532 struct lm32_reloc_map
534 bfd_reloc_code_real_type bfd_reloc_val
;
535 unsigned char elf_reloc_val
;
538 static const struct lm32_reloc_map lm32_reloc_map
[] =
540 { BFD_RELOC_NONE
, R_LM32_NONE
},
541 { BFD_RELOC_8
, R_LM32_8
},
542 { BFD_RELOC_16
, R_LM32_16
},
543 { BFD_RELOC_32
, R_LM32_32
},
544 { BFD_RELOC_HI16
, R_LM32_HI16
},
545 { BFD_RELOC_LO16
, R_LM32_LO16
},
546 { BFD_RELOC_GPREL16
, R_LM32_GPREL16
},
547 { BFD_RELOC_LM32_CALL
, R_LM32_CALL
},
548 { BFD_RELOC_LM32_BRANCH
, R_LM32_BRANCH
},
549 { BFD_RELOC_VTABLE_INHERIT
, R_LM32_GNU_VTINHERIT
},
550 { BFD_RELOC_VTABLE_ENTRY
, R_LM32_GNU_VTENTRY
},
551 { BFD_RELOC_LM32_16_GOT
, R_LM32_16_GOT
},
552 { BFD_RELOC_LM32_GOTOFF_HI16
, R_LM32_GOTOFF_HI16
},
553 { BFD_RELOC_LM32_GOTOFF_LO16
, R_LM32_GOTOFF_LO16
},
554 { BFD_RELOC_LM32_COPY
, R_LM32_COPY
},
555 { BFD_RELOC_LM32_GLOB_DAT
, R_LM32_GLOB_DAT
},
556 { BFD_RELOC_LM32_JMP_SLOT
, R_LM32_JMP_SLOT
},
557 { BFD_RELOC_LM32_RELATIVE
, R_LM32_RELATIVE
},
560 static reloc_howto_type
*
561 lm32_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
562 bfd_reloc_code_real_type code
)
566 for (i
= 0; i
< sizeof (lm32_reloc_map
) / sizeof (lm32_reloc_map
[0]); i
++)
567 if (lm32_reloc_map
[i
].bfd_reloc_val
== code
)
568 return &lm32_elf_howto_table
[lm32_reloc_map
[i
].elf_reloc_val
];
572 static reloc_howto_type
*
573 lm32_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
579 i
< sizeof (lm32_elf_howto_table
) / sizeof (lm32_elf_howto_table
[0]);
581 if (lm32_elf_howto_table
[i
].name
!= NULL
582 && strcasecmp (lm32_elf_howto_table
[i
].name
, r_name
) == 0)
583 return &lm32_elf_howto_table
[i
];
589 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
592 lm32_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
594 Elf_Internal_Rela
*dst
)
598 r_type
= ELF32_R_TYPE (dst
->r_info
);
599 BFD_ASSERT (r_type
< (unsigned int) R_LM32_max
);
600 cache_ptr
->howto
= &lm32_elf_howto_table
[r_type
];
603 /* Set the right machine number for an Lattice Mico32 ELF file. */
606 lm32_elf_object_p (bfd
*abfd
)
608 return bfd_default_set_arch_mach (abfd
, bfd_arch_lm32
, bfd_mach_lm32
);
611 /* Set machine type flags just before file is written out. */
614 lm32_elf_final_write_processing (bfd
*abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
616 elf_elfheader (abfd
)->e_machine
= EM_LATTICEMICO32
;
617 elf_elfheader (abfd
)->e_flags
&=~ EF_LM32_MACH
;
618 switch (bfd_get_mach (abfd
))
621 elf_elfheader (abfd
)->e_flags
|= E_LM32_MACH
;
628 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
629 dangerous relocation. */
632 lm32_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
638 /* If we've already figured out what GP will be, just return it. */
639 *pgp
= _bfd_get_gp_value (output_bfd
);
643 count
= bfd_get_symcount (output_bfd
);
644 sym
= bfd_get_outsymbols (output_bfd
);
646 /* The linker script will have created a symbol named `_gp' with the
647 appropriate value. */
652 for (i
= 0; i
< count
; i
++, sym
++)
656 name
= bfd_asymbol_name (*sym
);
657 if (*name
== '_' && strcmp (name
, "_gp") == 0)
659 *pgp
= bfd_asymbol_value (*sym
);
660 _bfd_set_gp_value (output_bfd
, *pgp
);
668 /* Only get the error once. */
670 _bfd_set_gp_value (output_bfd
, *pgp
);
677 /* We have to figure out the gp value, so that we can adjust the
678 symbol value correctly. We look up the symbol _gp in the output
679 BFD. If we can't find it, we're stuck. We cache it in the ELF
680 target data. We don't need to adjust the symbol value for an
681 external symbol if we are producing relocatable output. */
683 static bfd_reloc_status_type
684 lm32_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
685 char **error_message
, bfd_vma
*pgp
)
687 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
690 return bfd_reloc_undefined
;
693 *pgp
= _bfd_get_gp_value (output_bfd
);
694 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
698 /* Make up a value. */
699 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
700 _bfd_set_gp_value (output_bfd
, *pgp
);
702 else if (!lm32_elf_assign_gp (output_bfd
, pgp
))
706 _("global pointer relative relocation when _gp not defined");
707 return bfd_reloc_dangerous
;
714 static bfd_reloc_status_type
715 lm32_elf_do_gprel_relocate (bfd
*abfd
,
716 reloc_howto_type
*howto
,
717 asection
*input_section ATTRIBUTE_UNUSED
,
720 bfd_vma symbol_value
,
723 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
724 data
, offset
, symbol_value
, addend
);
727 static bfd_reloc_status_type
728 lm32_elf_gprel_reloc (bfd
*abfd
,
729 arelent
*reloc_entry
,
732 asection
*input_section
,
738 bfd_reloc_status_type r
;
740 if (output_bfd
!= (bfd
*) NULL
741 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
742 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
744 reloc_entry
->address
+= input_section
->output_offset
;
748 if (output_bfd
!= NULL
)
751 relocation
= symbol
->value
752 + symbol
->section
->output_section
->vma
+ symbol
->section
->output_offset
;
755 lm32_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
)) == bfd_reloc_ok
)
757 relocation
= relocation
+ reloc_entry
->addend
- gp
;
758 reloc_entry
->addend
= 0;
759 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
761 *msg
= _("global pointer relative address out of range");
762 r
= bfd_reloc_outofrange
;
766 r
= lm32_elf_do_gprel_relocate (abfd
, reloc_entry
->howto
,
768 data
, reloc_entry
->address
,
769 relocation
, reloc_entry
->addend
);
776 /* Find the segment number in which OSEC, and output section, is
780 _lm32fdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
782 struct elf_segment_map
*m
;
783 Elf_Internal_Phdr
*p
;
785 /* Find the segment that contains the output_section. */
786 for (m
= elf_tdata (output_bfd
)->segment_map
,
787 p
= elf_tdata (output_bfd
)->phdr
;
793 for (i
= m
->count
- 1; i
>= 0; i
--)
794 if (m
->sections
[i
] == osec
)
801 return p
- elf_tdata (output_bfd
)->phdr
;
804 /* Determine if an output section is read-only. */
806 inline static bfd_boolean
807 _lm32fdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
809 unsigned seg
= _lm32fdpic_osec_to_segment (output_bfd
, osec
);
811 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
814 /* Relocate a section */
817 lm32_elf_relocate_section (bfd
*output_bfd
,
818 struct bfd_link_info
*info
,
820 asection
*input_section
,
822 Elf_Internal_Rela
*relocs
,
823 Elf_Internal_Sym
*local_syms
,
824 asection
**local_sections
)
826 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
827 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
828 Elf_Internal_Rela
*rel
, *relend
;
829 struct elf_lm32_link_hash_table
*htab
= lm32_elf_hash_table (info
);
831 bfd_vma
*local_got_offsets
;
837 dynobj
= htab
->root
.dynobj
;
838 local_got_offsets
= elf_local_got_offsets (input_bfd
);
842 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
843 sym_hashes
= elf_sym_hashes (input_bfd
);
846 relend
= relocs
+ input_section
->reloc_count
;
847 for (; rel
< relend
; rel
++)
849 reloc_howto_type
*howto
;
851 unsigned long r_symndx
;
852 Elf_Internal_Sym
*sym
;
854 struct elf_link_hash_entry
*h
;
857 bfd_reloc_status_type r
;
858 const char *name
= NULL
;
860 r_symndx
= ELF32_R_SYM (rel
->r_info
);
861 r_type
= ELF32_R_TYPE (rel
->r_info
);
863 if (r_type
== R_LM32_GNU_VTENTRY
864 || r_type
== R_LM32_GNU_VTINHERIT
)
871 howto
= lm32_elf_howto_table
+ r_type
;
873 if (r_symndx
< symtab_hdr
->sh_info
)
875 /* It's a local symbol. */
876 sym
= local_syms
+ r_symndx
;
877 sec
= local_sections
[r_symndx
];
878 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
879 name
= bfd_elf_string_from_elf_section
880 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
881 name
= (name
== NULL
) ? bfd_section_name (input_bfd
, sec
) : name
;
885 /* It's a global symbol. */
886 bfd_boolean unresolved_reloc
;
889 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
890 r_symndx
, symtab_hdr
, sym_hashes
,
892 unresolved_reloc
, warned
);
893 name
= h
->root
.root
.string
;
896 if (sec
!= NULL
&& elf_discarded_section (sec
))
897 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
898 rel
, relend
, howto
, contents
);
900 if (info
->relocatable
)
902 /* This is a relocatable link. We don't have to change
903 anything, unless the reloc is against a section symbol,
904 in which case we have to adjust according to where the
905 section symbol winds up in the output section. */
906 if (sym
== NULL
|| ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
909 /* If partial_inplace, we need to store any additional addend
910 back in the section. */
911 if (! howto
->partial_inplace
)
914 /* Shouldn't reach here. */
923 if (!lm32_elf_assign_gp (output_bfd
, &gp
))
924 r
= bfd_reloc_dangerous
;
927 relocation
= relocation
+ rel
->r_addend
- gp
;
929 if ((signed)relocation
< -32768 || (signed)relocation
> 32767)
930 r
= bfd_reloc_outofrange
;
933 r
= _bfd_final_link_relocate (howto
, input_bfd
,
934 input_section
, contents
,
935 rel
->r_offset
, relocation
,
941 /* Relocation is to the entry for this symbol in the global
943 BFD_ASSERT (sgot
!= NULL
);
950 BFD_ASSERT (off
!= (bfd_vma
) -1);
952 dyn
= htab
->root
.dynamic_sections_created
;
953 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
960 /* This is actually a static link, or it is a
961 -Bsymbolic link and the symbol is defined
962 locally, or the symbol was forced to be local
963 because of a version file. We must initialize
964 this entry in the global offset table. Since the
965 offset must always be a multiple of 4, we use the
966 least significant bit to record whether we have
967 initialized it already.
969 When doing a dynamic link, we create a .rela.got
970 relocation entry to initialize the value. This
971 is done in the finish_dynamic_symbol routine. */
976 /* Write entry in GOT */
977 bfd_put_32 (output_bfd
, relocation
,
978 sgot
->contents
+ off
);
979 /* Create entry in .rofixup pointing to GOT entry. */
980 if (IS_FDPIC (output_bfd
) && h
->root
.type
!= bfd_link_hash_undefweak
)
982 _lm32fdpic_add_rofixup (output_bfd
,
983 lm32fdpic_fixup32_section
985 sgot
->output_section
->vma
986 + sgot
->output_offset
989 /* Mark GOT entry as having been written. */
994 relocation
= sgot
->output_offset
+ off
;
1001 BFD_ASSERT (local_got_offsets
!= NULL
1002 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1004 /* Get offset into GOT table. */
1005 off
= local_got_offsets
[r_symndx
];
1007 /* The offset must always be a multiple of 4. We use
1008 the least significant bit to record whether we have
1009 already processed this entry. */
1014 /* Write entry in GOT. */
1015 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1016 /* Create entry in .rofixup pointing to GOT entry. */
1017 if (IS_FDPIC (output_bfd
))
1019 _lm32fdpic_add_rofixup (output_bfd
,
1020 lm32fdpic_fixup32_section
1022 sgot
->output_section
->vma
1023 + sgot
->output_offset
1030 Elf_Internal_Rela outrel
;
1032 /* We need to generate a R_LM32_RELATIVE reloc
1033 for the dynamic linker. */
1034 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1035 BFD_ASSERT (srelgot
!= NULL
);
1037 outrel
.r_offset
= (sgot
->output_section
->vma
1038 + sgot
->output_offset
1040 outrel
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
1041 outrel
.r_addend
= relocation
;
1042 loc
= srelgot
->contents
;
1043 loc
+= srelgot
->reloc_count
* sizeof (Elf32_External_Rela
);
1044 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,loc
);
1045 ++srelgot
->reloc_count
;
1048 local_got_offsets
[r_symndx
] |= 1;
1052 relocation
= sgot
->output_offset
+ off
;
1055 /* Addend should be zero. */
1056 if (rel
->r_addend
!= 0)
1057 (*_bfd_error_handler
) (_("internal error: addend should be zero for R_LM32_16_GOT"));
1059 r
= _bfd_final_link_relocate (howto
,
1068 case R_LM32_GOTOFF_LO16
:
1069 case R_LM32_GOTOFF_HI16
:
1070 /* Relocation is offset from GOT. */
1071 BFD_ASSERT (sgot
!= NULL
);
1072 relocation
-= sgot
->output_section
->vma
;
1073 /* Account for sign-extension. */
1074 if ((r_type
== R_LM32_GOTOFF_HI16
)
1075 && ((relocation
+ rel
->r_addend
) & 0x8000))
1076 rel
->r_addend
+= 0x10000;
1077 r
= _bfd_final_link_relocate (howto
,
1087 if (IS_FDPIC (output_bfd
))
1089 if ((!h
) || (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
1091 /* Only create .rofixup entries for relocs in loadable sections. */
1092 if ((bfd_get_section_flags (output_bfd
, input_section
->output_section
)
1093 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
1096 /* Check address to be modified is writable. */
1097 if (_lm32fdpic_osec_readonly_p (output_bfd
,
1101 info
->callbacks
->warning
1103 _("cannot emit dynamic relocations in read-only section"),
1104 name
, input_bfd
, input_section
, rel
->r_offset
);
1107 /* Create entry in .rofixup section. */
1108 _lm32fdpic_add_rofixup (output_bfd
,
1109 lm32fdpic_fixup32_section (info
),
1110 input_section
->output_section
->vma
1111 + input_section
->output_offset
1119 r
= _bfd_final_link_relocate (howto
,
1130 if (r
!= bfd_reloc_ok
)
1132 const char *msg
= NULL
;
1135 lm32_info_to_howto_rela (input_bfd
, &bfd_reloc
, rel
);
1136 howto
= bfd_reloc
.howto
;
1139 name
= h
->root
.root
.string
;
1142 name
= (bfd_elf_string_from_elf_section
1143 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1144 if (name
== NULL
|| *name
== '\0')
1145 name
= bfd_section_name (input_bfd
, sec
);
1150 case bfd_reloc_overflow
:
1152 && (h
->root
.type
== bfd_link_hash_undefweak
))
1154 if (! ((*info
->callbacks
->reloc_overflow
)
1155 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1156 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
)))
1160 case bfd_reloc_undefined
:
1161 if (! ((*info
->callbacks
->undefined_symbol
)
1162 (info
, name
, input_bfd
, input_section
,
1163 rel
->r_offset
, TRUE
)))
1167 case bfd_reloc_outofrange
:
1168 msg
= _("internal error: out of range error");
1171 case bfd_reloc_notsupported
:
1172 msg
= _("internal error: unsupported relocation error");
1175 case bfd_reloc_dangerous
:
1176 msg
= _("internal error: dangerous error");
1180 msg
= _("internal error: unknown error");
1184 if (!((*info
->callbacks
->warning
)
1185 (info
, msg
, name
, input_bfd
, input_section
,
1197 lm32_elf_gc_mark_hook (asection
*sec
,
1198 struct bfd_link_info
*info
,
1199 Elf_Internal_Rela
*rel
,
1200 struct elf_link_hash_entry
*h
,
1201 Elf_Internal_Sym
*sym
)
1204 switch (ELF32_R_TYPE (rel
->r_info
))
1206 case R_LM32_GNU_VTINHERIT
:
1207 case R_LM32_GNU_VTENTRY
:
1211 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1215 lm32_elf_gc_sweep_hook (bfd
*abfd
,
1216 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1218 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
1220 /* Update the got entry reference counts for the section being removed. */
1221 Elf_Internal_Shdr
*symtab_hdr
;
1222 struct elf_link_hash_entry
**sym_hashes
;
1223 bfd_signed_vma
*local_got_refcounts
;
1224 const Elf_Internal_Rela
*rel
, *relend
;
1226 elf_section_data (sec
)->local_dynrel
= NULL
;
1228 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1229 sym_hashes
= elf_sym_hashes (abfd
);
1230 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1232 relend
= relocs
+ sec
->reloc_count
;
1233 for (rel
= relocs
; rel
< relend
; rel
++)
1235 unsigned long r_symndx
;
1236 struct elf_link_hash_entry
*h
= NULL
;
1238 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1239 if (r_symndx
>= symtab_hdr
->sh_info
)
1241 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1242 while (h
->root
.type
== bfd_link_hash_indirect
1243 || h
->root
.type
== bfd_link_hash_warning
)
1244 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1247 switch (ELF32_R_TYPE (rel
->r_info
))
1252 if (h
->got
.refcount
> 0)
1257 if (local_got_refcounts
&& local_got_refcounts
[r_symndx
] > 0)
1258 local_got_refcounts
[r_symndx
]--;
1269 /* Look through the relocs for a section during the first phase. */
1272 lm32_elf_check_relocs (bfd
*abfd
,
1273 struct bfd_link_info
*info
,
1275 const Elf_Internal_Rela
*relocs
)
1277 Elf_Internal_Shdr
*symtab_hdr
;
1278 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
1279 const Elf_Internal_Rela
*rel
;
1280 const Elf_Internal_Rela
*rel_end
;
1281 struct elf_lm32_link_hash_table
*htab
;
1284 if (info
->relocatable
)
1287 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1288 sym_hashes
= elf_sym_hashes (abfd
);
1289 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
1290 if (!elf_bad_symtab (abfd
))
1291 sym_hashes_end
-= symtab_hdr
->sh_info
;
1293 htab
= lm32_elf_hash_table (info
);
1297 dynobj
= htab
->root
.dynobj
;
1299 rel_end
= relocs
+ sec
->reloc_count
;
1300 for (rel
= relocs
; rel
< rel_end
; rel
++)
1303 struct elf_link_hash_entry
*h
;
1304 unsigned long r_symndx
;
1306 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1307 r_type
= ELF32_R_TYPE (rel
->r_info
);
1308 if (r_symndx
< symtab_hdr
->sh_info
)
1312 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1313 while (h
->root
.type
== bfd_link_hash_indirect
1314 || h
->root
.type
== bfd_link_hash_warning
)
1315 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1318 /* Some relocs require a global offset table. */
1319 if (htab
->sgot
== NULL
)
1324 case R_LM32_GOTOFF_HI16
:
1325 case R_LM32_GOTOFF_LO16
:
1327 htab
->root
.dynobj
= dynobj
= abfd
;
1328 if (! create_got_section (dynobj
, info
))
1334 /* Some relocs require a rofixup table. */
1335 if (IS_FDPIC (abfd
))
1340 /* FDPIC requires a GOT if there is a .rofixup section
1341 (Normal ELF doesn't). */
1343 htab
->root
.dynobj
= dynobj
= abfd
;
1344 if (! create_got_section (dynobj
, info
))
1346 /* Create .rofixup section */
1347 if (htab
->sfixup32
== NULL
)
1349 if (! create_rofixup_section (abfd
, info
))
1354 case R_LM32_GOTOFF_HI16
:
1355 case R_LM32_GOTOFF_LO16
:
1356 /* Create .rofixup section. */
1357 if (htab
->sfixup32
== NULL
)
1359 if (! create_rofixup_section (abfd
, info
))
1370 h
->got
.refcount
+= 1;
1373 bfd_signed_vma
*local_got_refcounts
;
1375 /* This is a global offset table entry for a local symbol. */
1376 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1377 if (local_got_refcounts
== NULL
)
1381 size
= symtab_hdr
->sh_info
;
1382 size
*= sizeof (bfd_signed_vma
);
1383 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1384 if (local_got_refcounts
== NULL
)
1386 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1388 local_got_refcounts
[r_symndx
] += 1;
1392 /* This relocation describes the C++ object vtable hierarchy.
1393 Reconstruct it for later use during GC. */
1394 case R_LM32_GNU_VTINHERIT
:
1395 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1399 /* This relocation describes which C++ vtable entries are actually
1400 used. Record for later use during GC. */
1401 case R_LM32_GNU_VTENTRY
:
1402 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1412 /* Finish up the dynamic sections. */
1415 lm32_elf_finish_dynamic_sections (bfd
*output_bfd
,
1416 struct bfd_link_info
*info
)
1418 struct elf_lm32_link_hash_table
*htab
;
1423 htab
= lm32_elf_hash_table (info
);
1427 dynobj
= htab
->root
.dynobj
;
1429 sgot
= htab
->sgotplt
;
1430 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1432 if (htab
->root
.dynamic_sections_created
)
1435 Elf32_External_Dyn
*dyncon
, *dynconend
;
1437 BFD_ASSERT (sgot
!= NULL
&& sdyn
!= NULL
);
1439 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1440 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
1442 for (; dyncon
< dynconend
; dyncon
++)
1444 Elf_Internal_Dyn dyn
;
1447 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1455 s
= htab
->sgot
->output_section
;
1458 s
= htab
->srelplt
->output_section
;
1460 BFD_ASSERT (s
!= NULL
);
1461 dyn
.d_un
.d_ptr
= s
->vma
;
1462 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1466 s
= htab
->srelplt
->output_section
;
1467 BFD_ASSERT (s
!= NULL
);
1468 dyn
.d_un
.d_val
= s
->size
;
1469 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1473 /* My reading of the SVR4 ABI indicates that the
1474 procedure linkage table relocs (DT_JMPREL) should be
1475 included in the overall relocs (DT_RELA). This is
1476 what Solaris does. However, UnixWare can not handle
1477 that case. Therefore, we override the DT_RELASZ entry
1478 here to make it not include the JMPREL relocs. Since
1479 the linker script arranges for .rela.plt to follow all
1480 other relocation sections, we don't have to worry
1481 about changing the DT_RELA entry. */
1482 if (htab
->srelplt
!= NULL
)
1484 s
= htab
->srelplt
->output_section
;
1485 dyn
.d_un
.d_val
-= s
->size
;
1487 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1492 /* Fill in the first entry in the procedure linkage table. */
1494 if (splt
&& splt
->size
> 0)
1498 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD0
, splt
->contents
);
1499 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD1
, splt
->contents
+ 4);
1500 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD2
, splt
->contents
+ 8);
1501 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD3
, splt
->contents
+ 12);
1502 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD4
, splt
->contents
+ 16);
1507 /* addr = .got + 4 */
1508 addr
= sgot
->output_section
->vma
+ sgot
->output_offset
+ 4;
1509 bfd_put_32 (output_bfd
,
1510 PLT0_ENTRY_WORD0
| ((addr
>> 16) & 0xffff),
1512 bfd_put_32 (output_bfd
,
1513 PLT0_ENTRY_WORD1
| (addr
& 0xffff),
1514 splt
->contents
+ 4);
1515 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD2
, splt
->contents
+ 8);
1516 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD3
, splt
->contents
+ 12);
1517 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD4
, splt
->contents
+ 16);
1520 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1525 /* Fill in the first three entries in the global offset table. */
1526 if (sgot
&& sgot
->size
> 0)
1529 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1531 bfd_put_32 (output_bfd
,
1532 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1534 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1535 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1537 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1538 if (elf_section_data (sgot
->output_section
) != NULL
)
1539 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1542 if (lm32fdpic_fixup32_section (info
))
1544 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
1545 bfd_vma got_value
= hgot
->root
.u
.def
.value
1546 + hgot
->root
.u
.def
.section
->output_section
->vma
1547 + hgot
->root
.u
.def
.section
->output_offset
;
1548 struct bfd_link_hash_entry
*hend
;
1550 /* Last entry is pointer to GOT. */
1551 _lm32fdpic_add_rofixup (output_bfd
, lm32fdpic_fixup32_section (info
), got_value
);
1553 /* Check we wrote enough entries. */
1554 if (lm32fdpic_fixup32_section (info
)->size
1555 != (lm32fdpic_fixup32_section (info
)->reloc_count
* 4))
1557 (*_bfd_error_handler
)
1558 ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1559 lm32fdpic_fixup32_section (info
)->size
/4,
1560 lm32fdpic_fixup32_section (info
)->reloc_count
);
1564 hend
= bfd_link_hash_lookup (info
->hash
, "__ROFIXUP_END__",
1565 FALSE
, FALSE
, TRUE
);
1567 && (hend
->type
== bfd_link_hash_defined
1568 || hend
->type
== bfd_link_hash_defweak
))
1571 lm32fdpic_fixup32_section (info
)->output_section
->vma
1572 + lm32fdpic_fixup32_section (info
)->output_offset
1573 + lm32fdpic_fixup32_section (info
)->size
1574 - hend
->u
.def
.section
->output_section
->vma
1575 - hend
->u
.def
.section
->output_offset
;
1576 BFD_ASSERT (hend
->u
.def
.value
== value
);
1577 if (hend
->u
.def
.value
!= value
)
1579 (*_bfd_error_handler
)
1580 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend
->u
.def
.value
, value
);
1589 /* Finish up dynamic symbol handling. We set the contents of various
1590 dynamic sections here. */
1593 lm32_elf_finish_dynamic_symbol (bfd
*output_bfd
,
1594 struct bfd_link_info
*info
,
1595 struct elf_link_hash_entry
*h
,
1596 Elf_Internal_Sym
*sym
)
1598 struct elf_lm32_link_hash_table
*htab
;
1601 htab
= lm32_elf_hash_table (info
);
1605 if (h
->plt
.offset
!= (bfd_vma
) -1)
1613 Elf_Internal_Rela rela
;
1615 /* This symbol has an entry in the procedure linkage table. Set
1617 BFD_ASSERT (h
->dynindx
!= -1);
1620 sgot
= htab
->sgotplt
;
1621 srela
= htab
->srelplt
;
1622 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1624 /* Get the index in the procedure linkage table which
1625 corresponds to this symbol. This is the index of this symbol
1626 in all the symbols for which we are making plt entries. The
1627 first entry in the procedure linkage table is reserved. */
1628 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1630 /* Get the offset into the .got table of the entry that
1631 corresponds to this function. Each .got entry is 4 bytes.
1632 The first three are reserved. */
1633 got_offset
= (plt_index
+ 3) * 4;
1635 /* Fill in the entry in the procedure linkage table. */
1645 /* Fill in the entry in the global offset table. */
1646 bfd_put_32 (output_bfd
,
1647 (splt
->output_section
->vma
1648 + splt
->output_offset
1650 + 12), /* same offset */
1651 sgot
->contents
+ got_offset
);
1653 /* Fill in the entry in the .rela.plt section. */
1654 rela
.r_offset
= (sgot
->output_section
->vma
1655 + sgot
->output_offset
1657 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_JMP_SLOT
);
1659 loc
= srela
->contents
;
1660 loc
+= plt_index
* sizeof (Elf32_External_Rela
);
1661 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1663 if (!h
->def_regular
)
1665 /* Mark the symbol as undefined, rather than as defined in
1666 the .plt section. Leave the value alone. */
1667 sym
->st_shndx
= SHN_UNDEF
;
1672 if (h
->got
.offset
!= (bfd_vma
) -1)
1676 Elf_Internal_Rela rela
;
1678 /* This symbol has an entry in the global offset table. Set it
1681 srela
= htab
->srelgot
;
1682 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1684 rela
.r_offset
= (sgot
->output_section
->vma
1685 + sgot
->output_offset
1686 + (h
->got
.offset
&~ 1));
1688 /* If this is a -Bsymbolic link, and the symbol is defined
1689 locally, we just want to emit a RELATIVE reloc. Likewise if
1690 the symbol was forced to be local because of a version file.
1691 The entry in the global offset table will already have been
1692 initialized in the relocate_section function. */
1699 rela
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
1700 rela
.r_addend
= (h
->root
.u
.def
.value
1701 + h
->root
.u
.def
.section
->output_section
->vma
1702 + h
->root
.u
.def
.section
->output_offset
);
1706 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
1707 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1708 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_GLOB_DAT
);
1712 loc
= srela
->contents
;
1713 loc
+= srela
->reloc_count
* sizeof (Elf32_External_Rela
);
1714 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1715 ++srela
->reloc_count
;
1721 Elf_Internal_Rela rela
;
1723 /* This symbols needs a copy reloc. Set it up. */
1724 BFD_ASSERT (h
->dynindx
!= -1
1725 && (h
->root
.type
== bfd_link_hash_defined
1726 || h
->root
.type
== bfd_link_hash_defweak
));
1728 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1730 BFD_ASSERT (s
!= NULL
);
1732 rela
.r_offset
= (h
->root
.u
.def
.value
1733 + h
->root
.u
.def
.section
->output_section
->vma
1734 + h
->root
.u
.def
.section
->output_offset
);
1735 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_COPY
);
1738 loc
+= s
->reloc_count
* sizeof (Elf32_External_Rela
);
1739 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1743 /* Mark some specially defined symbols as absolute. */
1744 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1745 || h
== htab
->root
.hgot
)
1746 sym
->st_shndx
= SHN_ABS
;
1751 static enum elf_reloc_type_class
1752 lm32_elf_reloc_type_class (const Elf_Internal_Rela
*rela
)
1754 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1756 case R_LM32_RELATIVE
: return reloc_class_relative
;
1757 case R_LM32_JMP_SLOT
: return reloc_class_plt
;
1758 case R_LM32_COPY
: return reloc_class_copy
;
1759 default: return reloc_class_normal
;
1763 /* Adjust a symbol defined by a dynamic object and referenced by a
1764 regular object. The current definition is in some section of the
1765 dynamic object, but we're not including those sections. We have to
1766 change the definition to something the rest of the link can
1770 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1771 struct elf_link_hash_entry
*h
)
1773 struct elf_lm32_link_hash_table
*htab
;
1774 struct elf_lm32_link_hash_entry
*eh
;
1775 struct elf_lm32_dyn_relocs
*p
;
1779 dynobj
= elf_hash_table (info
)->dynobj
;
1781 /* Make sure we know what is going on here. */
1782 BFD_ASSERT (dynobj
!= NULL
1784 || h
->u
.weakdef
!= NULL
1787 && !h
->def_regular
)));
1789 /* If this is a function, put it in the procedure linkage table. We
1790 will fill in the contents of the procedure linkage table later,
1791 when we know the address of the .got section. */
1792 if (h
->type
== STT_FUNC
1798 && h
->root
.type
!= bfd_link_hash_undefweak
1799 && h
->root
.type
!= bfd_link_hash_undefined
)
1801 /* This case can occur if we saw a PLT reloc in an input
1802 file, but the symbol was never referred to by a dynamic
1803 object. In such a case, we don't actually need to build
1804 a procedure linkage table, and we can just do a PCREL
1806 h
->plt
.offset
= (bfd_vma
) -1;
1813 h
->plt
.offset
= (bfd_vma
) -1;
1815 /* If this is a weak symbol, and there is a real definition, the
1816 processor independent code will have arranged for us to see the
1817 real definition first, and we can just use the same value. */
1818 if (h
->u
.weakdef
!= NULL
)
1820 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1821 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1822 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1823 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1827 /* This is a reference to a symbol defined by a dynamic object which
1828 is not a function. */
1830 /* If we are creating a shared library, we must presume that the
1831 only references to the symbol are via the global offset table.
1832 For such cases we need not do anything here; the relocations will
1833 be handled correctly by relocate_section. */
1837 /* If there are no references to this symbol that do not use the
1838 GOT, we don't need to generate a copy reloc. */
1839 if (!h
->non_got_ref
)
1842 /* If -z nocopyreloc was given, we won't generate them either. */
1843 if (info
->nocopyreloc
)
1849 eh
= (struct elf_lm32_link_hash_entry
*) h
;
1850 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1852 s
= p
->sec
->output_section
;
1853 if (s
!= NULL
&& (s
->flags
& (SEC_READONLY
| SEC_HAS_CONTENTS
)) != 0)
1857 /* If we didn't find any dynamic relocs in sections which needs the
1858 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1866 /* We must allocate the symbol in our .dynbss section, which will
1867 become part of the .bss section of the executable. There will be
1868 an entry for this symbol in the .dynsym section. The dynamic
1869 object will contain position independent code, so all references
1870 from the dynamic object to this symbol will go through the global
1871 offset table. The dynamic linker will use the .dynsym entry to
1872 determine the address it must put in the global offset table, so
1873 both the dynamic object and the regular object will refer to the
1874 same memory location for the variable. */
1876 htab
= lm32_elf_hash_table (info
);
1881 BFD_ASSERT (s
!= NULL
);
1883 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1884 to copy the initial value out of the dynamic object and into the
1885 runtime process image. We need to remember the offset into the
1886 .rela.bss section we are going to use. */
1887 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1891 srel
= htab
->srelbss
;
1892 BFD_ASSERT (srel
!= NULL
);
1893 srel
->size
+= sizeof (Elf32_External_Rela
);
1897 return _bfd_elf_adjust_dynamic_copy (h
, s
);
1900 /* Allocate space in .plt, .got and associated reloc sections for
1904 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1906 struct bfd_link_info
*info
;
1907 struct elf_lm32_link_hash_table
*htab
;
1908 struct elf_lm32_link_hash_entry
*eh
;
1909 struct elf_lm32_dyn_relocs
*p
;
1911 if (h
->root
.type
== bfd_link_hash_indirect
)
1914 info
= (struct bfd_link_info
*) inf
;
1915 htab
= lm32_elf_hash_table (info
);
1919 eh
= (struct elf_lm32_link_hash_entry
*) h
;
1921 if (htab
->root
.dynamic_sections_created
1922 && h
->plt
.refcount
> 0)
1924 /* Make sure this symbol is output as a dynamic symbol.
1925 Undefined weak syms won't yet be marked as dynamic. */
1926 if (h
->dynindx
== -1
1927 && !h
->forced_local
)
1929 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1933 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1935 asection
*s
= htab
->splt
;
1937 /* If this is the first .plt entry, make room for the special
1940 s
->size
+= PLT_ENTRY_SIZE
;
1942 h
->plt
.offset
= s
->size
;
1944 /* If this symbol is not defined in a regular file, and we are
1945 not generating a shared library, then set the symbol to this
1946 location in the .plt. This is required to make function
1947 pointers compare as equal between the normal executable and
1948 the shared library. */
1952 h
->root
.u
.def
.section
= s
;
1953 h
->root
.u
.def
.value
= h
->plt
.offset
;
1956 /* Make room for this entry. */
1957 s
->size
+= PLT_ENTRY_SIZE
;
1959 /* We also need to make an entry in the .got.plt section, which
1960 will be placed in the .got section by the linker script. */
1961 htab
->sgotplt
->size
+= 4;
1963 /* We also need to make an entry in the .rel.plt section. */
1964 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1968 h
->plt
.offset
= (bfd_vma
) -1;
1974 h
->plt
.offset
= (bfd_vma
) -1;
1978 if (h
->got
.refcount
> 0)
1983 /* Make sure this symbol is output as a dynamic symbol.
1984 Undefined weak syms won't yet be marked as dynamic. */
1985 if (h
->dynindx
== -1
1986 && !h
->forced_local
)
1988 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1994 h
->got
.offset
= s
->size
;
1996 dyn
= htab
->root
.dynamic_sections_created
;
1997 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
1998 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2001 h
->got
.offset
= (bfd_vma
) -1;
2003 if (eh
->dyn_relocs
== NULL
)
2006 /* In the shared -Bsymbolic case, discard space allocated for
2007 dynamic pc-relative relocs against symbols which turn out to be
2008 defined in regular objects. For the normal shared case, discard
2009 space for pc-relative relocs that have become local due to symbol
2010 visibility changes. */
2018 struct elf_lm32_dyn_relocs
**pp
;
2020 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
;)
2022 p
->count
-= p
->pc_count
;
2031 /* Also discard relocs on undefined weak syms with non-default
2033 if (eh
->dyn_relocs
!= NULL
2034 && h
->root
.type
== bfd_link_hash_undefweak
)
2036 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2037 eh
->dyn_relocs
= NULL
;
2039 /* Make sure undefined weak symbols are output as a dynamic
2041 else if (h
->dynindx
== -1
2042 && !h
->forced_local
)
2044 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2051 /* For the non-shared case, discard space for relocs against
2052 symbols which turn out to need copy relocs or are not
2058 || (htab
->root
.dynamic_sections_created
2059 && (h
->root
.type
== bfd_link_hash_undefweak
2060 || h
->root
.type
== bfd_link_hash_undefined
))))
2062 /* Make sure this symbol is output as a dynamic symbol.
2063 Undefined weak syms won't yet be marked as dynamic. */
2064 if (h
->dynindx
== -1
2065 && !h
->forced_local
)
2067 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2071 /* If that succeeded, we know we'll be keeping all the
2073 if (h
->dynindx
!= -1)
2077 eh
->dyn_relocs
= NULL
;
2082 /* Finally, allocate space. */
2083 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2085 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2086 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2092 /* Find any dynamic relocs that apply to read-only sections. */
2095 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2097 struct elf_lm32_link_hash_entry
*eh
;
2098 struct elf_lm32_dyn_relocs
*p
;
2100 eh
= (struct elf_lm32_link_hash_entry
*) h
;
2101 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2103 asection
*s
= p
->sec
->output_section
;
2105 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2107 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2109 info
->flags
|= DF_TEXTREL
;
2111 /* Not an error, just cut short the traversal. */
2118 /* Set the sizes of the dynamic sections. */
2121 lm32_elf_size_dynamic_sections (bfd
*output_bfd
,
2122 struct bfd_link_info
*info
)
2124 struct elf_lm32_link_hash_table
*htab
;
2130 htab
= lm32_elf_hash_table (info
);
2134 dynobj
= htab
->root
.dynobj
;
2135 BFD_ASSERT (dynobj
!= NULL
);
2137 if (htab
->root
.dynamic_sections_created
)
2139 /* Set the contents of the .interp section to the interpreter. */
2140 if (info
->executable
)
2142 s
= bfd_get_section_by_name (dynobj
, ".interp");
2143 BFD_ASSERT (s
!= NULL
);
2144 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2145 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2149 /* Set up .got offsets for local syms, and space for local dynamic
2151 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2153 bfd_signed_vma
*local_got
;
2154 bfd_signed_vma
*end_local_got
;
2155 bfd_size_type locsymcount
;
2156 Elf_Internal_Shdr
*symtab_hdr
;
2159 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2162 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2164 struct elf_lm32_dyn_relocs
*p
;
2166 for (p
= ((struct elf_lm32_dyn_relocs
*)
2167 elf_section_data (s
)->local_dynrel
);
2171 if (! bfd_is_abs_section (p
->sec
)
2172 && bfd_is_abs_section (p
->sec
->output_section
))
2174 /* Input section has been discarded, either because
2175 it is a copy of a linkonce section or due to
2176 linker script /DISCARD/, so we'll be discarding
2179 else if (p
->count
!= 0)
2181 srel
= elf_section_data (p
->sec
)->sreloc
;
2182 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2183 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2184 info
->flags
|= DF_TEXTREL
;
2189 local_got
= elf_local_got_refcounts (ibfd
);
2193 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2194 locsymcount
= symtab_hdr
->sh_info
;
2195 end_local_got
= local_got
+ locsymcount
;
2197 srel
= htab
->srelgot
;
2198 for (; local_got
< end_local_got
; ++local_got
)
2202 *local_got
= s
->size
;
2205 srel
->size
+= sizeof (Elf32_External_Rela
);
2208 *local_got
= (bfd_vma
) -1;
2212 /* Allocate global sym .plt and .got entries, and space for global
2213 sym dynamic relocs. */
2214 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
2216 /* We now have determined the sizes of the various dynamic sections.
2217 Allocate memory for them. */
2219 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2221 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2226 || s
== htab
->sgotplt
2227 || s
== htab
->sdynbss
)
2229 /* Strip this section if we don't need it; see the
2232 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2234 if (s
->size
!= 0 && s
!= htab
->srelplt
)
2237 /* We use the reloc_count field as a counter if we need
2238 to copy relocs into the output file. */
2242 /* It's not one of our sections, so don't allocate space. */
2247 /* If we don't need this section, strip it from the
2248 output file. This is mostly to handle .rela.bss and
2249 .rela.plt. We must create both sections in
2250 create_dynamic_sections, because they must be created
2251 before the linker maps input sections to output
2252 sections. The linker does that before
2253 adjust_dynamic_symbol is called, and it is that
2254 function which decides whether anything needs to go
2255 into these sections. */
2256 s
->flags
|= SEC_EXCLUDE
;
2260 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2263 /* Allocate memory for the section contents. We use bfd_zalloc
2264 here in case unused entries are not reclaimed before the
2265 section's contents are written out. This should not happen,
2266 but this way if it does, we get a R_LM32_NONE reloc instead
2268 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2269 if (s
->contents
== NULL
)
2273 if (htab
->root
.dynamic_sections_created
)
2275 /* Add some entries to the .dynamic section. We fill in the
2276 values later, in lm32_elf_finish_dynamic_sections, but we
2277 must add the entries now so that we get the correct size for
2278 the .dynamic section. The DT_DEBUG entry is filled in by the
2279 dynamic linker and used by the debugger. */
2280 #define add_dynamic_entry(TAG, VAL) \
2281 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2283 if (info
->executable
)
2285 if (! add_dynamic_entry (DT_DEBUG
, 0))
2289 if (htab
->splt
->size
!= 0)
2291 if (! add_dynamic_entry (DT_PLTGOT
, 0)
2292 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
2293 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2294 || ! add_dynamic_entry (DT_JMPREL
, 0))
2300 if (! add_dynamic_entry (DT_RELA
, 0)
2301 || ! add_dynamic_entry (DT_RELASZ
, 0)
2302 || ! add_dynamic_entry (DT_RELAENT
,
2303 sizeof (Elf32_External_Rela
)))
2306 /* If any dynamic relocs apply to a read-only section,
2307 then we need a DT_TEXTREL entry. */
2308 if ((info
->flags
& DF_TEXTREL
) == 0)
2309 elf_link_hash_traverse (&htab
->root
, readonly_dynrelocs
,
2312 if ((info
->flags
& DF_TEXTREL
) != 0)
2314 if (! add_dynamic_entry (DT_TEXTREL
, 0))
2319 #undef add_dynamic_entry
2321 /* Allocate .rofixup section. */
2322 if (IS_FDPIC (output_bfd
))
2324 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2325 int rgot_weak_count
= 0;
2328 /* Look for deleted sections. */
2329 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2331 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2335 /* Count relocs that need .rofixup entires. */
2336 Elf_Internal_Rela
*internal_relocs
, *end
;
2337 internal_relocs
= elf_section_data (s
)->relocs
;
2338 if (internal_relocs
== NULL
)
2339 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2340 if (internal_relocs
!= NULL
)
2342 end
= internal_relocs
+ s
->reloc_count
;
2343 while (internal_relocs
< end
)
2345 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2346 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2347 unsigned long r_symndx
;
2348 struct elf_link_hash_entry
*h
;
2350 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2351 sym_hashes
= elf_sym_hashes (ibfd
);
2352 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2354 if (r_symndx
< symtab_hdr
->sh_info
)
2359 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2360 while (h
->root
.type
== bfd_link_hash_indirect
2361 || h
->root
.type
== bfd_link_hash_warning
)
2362 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2365 /* Don't generate entries for weak symbols. */
2366 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2368 if (!elf_discarded_section (s
) && !((bfd_get_section_flags (ibfd
, s
) & SEC_ALLOC
) == 0))
2370 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2383 struct weak_symbol_list
*current
, *new_entry
;
2384 /* Is this symbol already in the list? */
2385 for (current
= list_start
; current
; current
= current
->next
)
2387 if (!strcmp (current
->name
, h
->root
.root
.string
))
2390 if (!current
&& !elf_discarded_section (s
) && (bfd_get_section_flags (ibfd
, s
) & SEC_ALLOC
))
2392 /* Will this have an entry in the GOT. */
2393 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2395 /* Create a new entry. */
2396 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2399 new_entry
->name
= h
->root
.root
.string
;
2400 new_entry
->next
= NULL
;
2402 if (list_start
== NULL
)
2404 list_start
= new_entry
;
2405 list_end
= new_entry
;
2409 list_end
->next
= new_entry
;
2410 list_end
= new_entry
;
2412 /* Increase count of undefined weak symbols in the got. */
2428 list_end
= list_start
->next
;
2430 list_start
= list_end
;
2433 /* Size sections. */
2434 lm32fdpic_fixup32_section (info
)->size
= (r32_count
+ (htab
->sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2435 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2436 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2439 lm32fdpic_fixup32_section (info
)->contents
=
2440 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2441 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2449 /* Create dynamic sections when linking against a dynamic object. */
2452 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2454 struct elf_lm32_link_hash_table
*htab
;
2455 flagword flags
, pltflags
;
2457 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2458 int ptralign
= 2; /* 32bit */
2460 htab
= lm32_elf_hash_table (info
);
2464 /* Make sure we have a GOT - For the case where we have a dynamic object
2465 but none of the relocs in check_relocs */
2466 if (! create_got_section (abfd
, info
))
2468 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2470 if (! create_rofixup_section (abfd
, info
))
2474 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2475 .rel[a].bss sections. */
2476 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2477 | SEC_LINKER_CREATED
);
2480 pltflags
|= SEC_CODE
;
2481 if (bed
->plt_not_loaded
)
2482 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2483 if (bed
->plt_readonly
)
2484 pltflags
|= SEC_READONLY
;
2486 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
2489 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2492 if (bed
->want_plt_sym
)
2494 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2496 struct bfd_link_hash_entry
*bh
= NULL
;
2497 struct elf_link_hash_entry
*h
;
2499 if (! (_bfd_generic_link_add_one_symbol
2500 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2501 (bfd_vma
) 0, NULL
, FALSE
,
2502 get_elf_backend_data (abfd
)->collect
, &bh
)))
2504 h
= (struct elf_link_hash_entry
*) bh
;
2506 h
->type
= STT_OBJECT
;
2507 htab
->root
.hplt
= h
;
2510 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2514 s
= bfd_make_section_with_flags (abfd
,
2515 bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt",
2516 flags
| SEC_READONLY
);
2519 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2522 if (htab
->sgot
== NULL
2523 && ! create_got_section (abfd
, info
))
2527 const char *secname
;
2532 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2534 secflags
= bfd_get_section_flags (abfd
, sec
);
2535 if ((secflags
& (SEC_DATA
| SEC_LINKER_CREATED
))
2536 || ((secflags
& SEC_HAS_CONTENTS
) != SEC_HAS_CONTENTS
))
2538 secname
= bfd_get_section_name (abfd
, sec
);
2539 relname
= bfd_malloc ((bfd_size_type
) strlen (secname
) + 6);
2540 strcpy (relname
, ".rela");
2541 strcat (relname
, secname
);
2542 if (bfd_get_section_by_name (abfd
, secname
))
2544 s
= bfd_make_section_with_flags (abfd
, relname
,
2545 flags
| SEC_READONLY
);
2547 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2552 if (bed
->want_dynbss
)
2554 /* The .dynbss section is a place to put symbols which are defined
2555 by dynamic objects, are referenced by regular objects, and are
2556 not functions. We must allocate space for them in the process
2557 image and use a R_*_COPY reloc to tell the dynamic linker to
2558 initialize them at run time. The linker script puts the .dynbss
2559 section into the .bss section of the final image. */
2560 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
2561 SEC_ALLOC
| SEC_LINKER_CREATED
);
2565 /* The .rel[a].bss section holds copy relocs. This section is not
2566 normally needed. We need to create it here, though, so that the
2567 linker will map it to an output section. We can't just create it
2568 only if we need it, because we will not know whether we need it
2569 until we have seen all the input files, and the first time the
2570 main linker code calls BFD after examining all the input files
2571 (size_dynamic_sections) the input sections have already been
2572 mapped to the output sections. If the section turns out not to
2573 be needed, we can discard it later. We will never need this
2574 section when generating a shared object, since they do not use
2578 s
= bfd_make_section_with_flags (abfd
,
2579 (bed
->default_use_rela_p
2580 ? ".rela.bss" : ".rel.bss"),
2581 flags
| SEC_READONLY
);
2584 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2592 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2595 lm32_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
2596 struct elf_link_hash_entry
*dir
,
2597 struct elf_link_hash_entry
*ind
)
2599 struct elf_lm32_link_hash_entry
* edir
;
2600 struct elf_lm32_link_hash_entry
* eind
;
2602 edir
= (struct elf_lm32_link_hash_entry
*) dir
;
2603 eind
= (struct elf_lm32_link_hash_entry
*) ind
;
2605 if (eind
->dyn_relocs
!= NULL
)
2607 if (edir
->dyn_relocs
!= NULL
)
2609 struct elf_lm32_dyn_relocs
**pp
;
2610 struct elf_lm32_dyn_relocs
*p
;
2612 /* Add reloc counts against the indirect sym to the direct sym
2613 list. Merge any entries against the same section. */
2614 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
;)
2616 struct elf_lm32_dyn_relocs
*q
;
2618 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
2619 if (q
->sec
== p
->sec
)
2621 q
->pc_count
+= p
->pc_count
;
2622 q
->count
+= p
->count
;
2629 *pp
= edir
->dyn_relocs
;
2632 edir
->dyn_relocs
= eind
->dyn_relocs
;
2633 eind
->dyn_relocs
= NULL
;
2636 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
2640 lm32_elf_always_size_sections (bfd
*output_bfd
,
2641 struct bfd_link_info
*info
)
2643 if (!info
->relocatable
)
2645 struct elf_link_hash_entry
*h
;
2647 /* Force a PT_GNU_STACK segment to be created. */
2648 if (! elf_tdata (output_bfd
)->stack_flags
)
2649 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
2651 /* Define __stacksize if it's not defined yet. */
2652 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
2653 FALSE
, FALSE
, FALSE
);
2654 if (! h
|| h
->root
.type
!= bfd_link_hash_defined
2655 || h
->type
!= STT_OBJECT
2658 struct bfd_link_hash_entry
*bh
= NULL
;
2660 if (!(_bfd_generic_link_add_one_symbol
2661 (info
, output_bfd
, "__stacksize",
2662 BSF_GLOBAL
, bfd_abs_section_ptr
, DEFAULT_STACK_SIZE
,
2663 (const char *) NULL
, FALSE
,
2664 get_elf_backend_data (output_bfd
)->collect
, &bh
)))
2667 h
= (struct elf_link_hash_entry
*) bh
;
2669 h
->type
= STT_OBJECT
;
2670 /* This one must NOT be hidden. */
2678 lm32_elf_modify_segment_map (bfd
*output_bfd
,
2679 struct bfd_link_info
*info
)
2681 struct elf_segment_map
*m
;
2683 /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2684 private_bfd_data (). */
2688 for (m
= elf_tdata (output_bfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2689 if (m
->p_type
== PT_GNU_STACK
)
2694 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2695 struct elf_link_hash_entry
*h
;
2699 /* Obtain the pointer to the __stacksize symbol. */
2700 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
2701 FALSE
, FALSE
, FALSE
);
2702 while (h
->root
.type
== bfd_link_hash_indirect
2703 || h
->root
.type
== bfd_link_hash_warning
)
2704 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
2705 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
2707 /* Set the section size from the symbol value. We
2708 intentionally ignore the symbol section. */
2709 if (h
->root
.type
== bfd_link_hash_defined
)
2710 sec
->size
= h
->root
.u
.def
.value
;
2712 sec
->size
= DEFAULT_STACK_SIZE
;
2714 /* Add the stack section to the PT_GNU_STACK segment,
2715 such that its size and alignment requirements make it
2717 m
->sections
[m
->count
] = sec
;
2726 lm32_elf_modify_program_headers (bfd
*output_bfd
,
2727 struct bfd_link_info
*info
)
2729 struct elf_obj_tdata
*tdata
= elf_tdata (output_bfd
);
2730 struct elf_segment_map
*m
;
2731 Elf_Internal_Phdr
*p
;
2736 for (p
= tdata
->phdr
, m
= tdata
->segment_map
; m
!= NULL
; m
= m
->next
, p
++)
2737 if (m
->p_type
== PT_GNU_STACK
)
2742 struct elf_link_hash_entry
*h
;
2744 /* Obtain the pointer to the __stacksize symbol. */
2745 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
2746 FALSE
, FALSE
, FALSE
);
2749 while (h
->root
.type
== bfd_link_hash_indirect
2750 || h
->root
.type
== bfd_link_hash_warning
)
2751 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2752 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
2755 /* Set the header p_memsz from the symbol value. We
2756 intentionally ignore the symbol section. */
2757 if (h
&& h
->root
.type
== bfd_link_hash_defined
)
2758 p
->p_memsz
= h
->root
.u
.def
.value
;
2760 p
->p_memsz
= DEFAULT_STACK_SIZE
;
2770 lm32_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2772 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2773 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2776 BFD_ASSERT (!elf_flags_init (obfd
)
2777 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
2779 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2780 elf_flags_init (obfd
) = TRUE
;
2782 /* Copy object attributes. */
2783 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
2790 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2794 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2795 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2798 if (! lm32_elf_copy_private_bfd_data (ibfd
, obfd
))
2801 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2802 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2805 /* Copy the stack size. */
2806 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2807 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2809 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2811 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2812 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2814 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2816 /* Rewrite the phdrs, since we're only called after they were first written. */
2817 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2818 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2819 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2820 elf_elfheader (obfd
)->e_phnum
) != 0)
2832 #define ELF_ARCH bfd_arch_lm32
2833 #define ELF_TARGET_ID LM32_ELF_DATA
2834 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2835 #define ELF_MAXPAGESIZE 0x1000
2837 #define TARGET_BIG_SYM bfd_elf32_lm32_vec
2838 #define TARGET_BIG_NAME "elf32-lm32"
2840 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2841 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2842 #define elf_info_to_howto lm32_info_to_howto_rela
2843 #define elf_info_to_howto_rel 0
2844 #define elf_backend_rela_normal 1
2845 #define elf_backend_object_p lm32_elf_object_p
2846 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2847 #define elf_backend_can_gc_sections 1
2848 #define elf_backend_can_refcount 1
2849 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2850 #define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook
2851 #define elf_backend_plt_readonly 1
2852 #define elf_backend_want_got_plt 1
2853 #define elf_backend_want_plt_sym 0
2854 #define elf_backend_got_header_size 12
2855 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2856 #define elf_backend_check_relocs lm32_elf_check_relocs
2857 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2858 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2859 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2860 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2861 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2862 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2863 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2864 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2865 #define elf_backend_relocate_section lm32_elf_relocate_section
2867 #include "elf32-target.h"
2869 #undef ELF_MAXPAGESIZE
2870 #define ELF_MAXPAGESIZE 0x4000
2873 #undef TARGET_BIG_SYM
2874 #define TARGET_BIG_SYM bfd_elf32_lm32fdpic_vec
2875 #undef TARGET_BIG_NAME
2876 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2878 #define elf32_bed elf32_lm32fdpic_bed
2880 #undef elf_backend_always_size_sections
2881 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2882 #undef elf_backend_modify_segment_map
2883 #define elf_backend_modify_segment_map lm32_elf_modify_segment_map
2884 #undef elf_backend_modify_program_headers
2885 #define elf_backend_modify_program_headers lm32_elf_modify_program_headers
2886 #undef bfd_elf32_bfd_copy_private_bfd_data
2887 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2889 #include "elf32-target.h"