1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2018 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 lm32_elf32_fdpic_vec
;
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 /* lm32 ELF linker hash entry. */
55 struct elf_lm32_link_hash_entry
57 struct elf_link_hash_entry root
;
59 /* Track dynamic relocs copied for this symbol. */
60 struct elf_dyn_relocs
*dyn_relocs
;
63 /* lm32 ELF linker hash table. */
65 struct elf_lm32_link_hash_table
67 struct elf_link_hash_table root
;
69 /* Short-cuts to get to dynamic linker sections. */
77 /* Get the lm32 ELF linker hash table from a link_info structure. */
79 #define lm32_elf_hash_table(p) \
80 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
81 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
83 #define lm32fdpic_got_section(info) \
84 (lm32_elf_hash_table (info)->root.sgot)
85 #define lm32fdpic_gotrel_section(info) \
86 (lm32_elf_hash_table (info)->root.srelgot)
87 #define lm32fdpic_fixup32_section(info) \
88 (lm32_elf_hash_table (info)->sfixup32)
90 struct weak_symbol_list
93 struct weak_symbol_list
*next
;
96 /* Create an entry in an lm32 ELF linker hash table. */
98 static struct bfd_hash_entry
*
99 lm32_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
100 struct bfd_hash_table
*table
,
103 struct elf_lm32_link_hash_entry
*ret
=
104 (struct elf_lm32_link_hash_entry
*) entry
;
106 /* Allocate the structure if it has not already been allocated by a
109 ret
= bfd_hash_allocate (table
,
110 sizeof (struct elf_lm32_link_hash_entry
));
114 /* Call the allocation method of the superclass. */
115 ret
= ((struct elf_lm32_link_hash_entry
*)
116 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
120 struct elf_lm32_link_hash_entry
*eh
;
122 eh
= (struct elf_lm32_link_hash_entry
*) ret
;
123 eh
->dyn_relocs
= NULL
;
126 return (struct bfd_hash_entry
*) ret
;
129 /* Create an lm32 ELF linker hash table. */
131 static struct bfd_link_hash_table
*
132 lm32_elf_link_hash_table_create (bfd
*abfd
)
134 struct elf_lm32_link_hash_table
*ret
;
135 bfd_size_type amt
= sizeof (struct elf_lm32_link_hash_table
);
137 ret
= bfd_zmalloc (amt
);
141 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
142 lm32_elf_link_hash_newfunc
,
143 sizeof (struct elf_lm32_link_hash_entry
),
150 return &ret
->root
.root
;
153 /* Add a fixup to the ROFIXUP section. */
156 _lm32fdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma relocation
)
158 bfd_vma fixup_offset
;
160 if (rofixup
->flags
& SEC_EXCLUDE
)
163 fixup_offset
= rofixup
->reloc_count
* 4;
164 if (rofixup
->contents
)
166 BFD_ASSERT (fixup_offset
< rofixup
->size
);
167 if (fixup_offset
< rofixup
->size
)
168 bfd_put_32 (output_bfd
, relocation
, rofixup
->contents
+ fixup_offset
);
170 rofixup
->reloc_count
++;
175 /* Create .rofixup sections in DYNOBJ, and set up
176 shortcuts to them in our hash table. */
179 create_rofixup_section (bfd
*dynobj
, struct bfd_link_info
*info
)
181 struct elf_lm32_link_hash_table
*htab
;
182 htab
= lm32_elf_hash_table (info
);
187 /* Fixup section for R_LM32_32 relocs. */
188 lm32fdpic_fixup32_section (info
)
189 = bfd_make_section_anyway_with_flags (dynobj
,
197 if (lm32fdpic_fixup32_section (info
) == NULL
198 || ! bfd_set_section_alignment (dynobj
,
199 lm32fdpic_fixup32_section (info
), 2))
205 static reloc_howto_type lm32_elf_howto_table
[] =
207 /* This reloc does nothing. */
208 HOWTO (R_LM32_NONE
, /* type */
210 3, /* size (0 = byte, 1 = short, 2 = long) */
212 FALSE
, /* pc_relative */
214 complain_overflow_dont
, /* complain_on_overflow */
215 bfd_elf_generic_reloc
, /* special_function */
216 "R_LM32_NONE", /* name */
217 FALSE
, /* partial_inplace */
220 FALSE
), /* pcrel_offset */
222 /* An 8 bit absolute relocation. */
223 HOWTO (R_LM32_8
, /* type */
225 0, /* size (0 = byte, 1 = short, 2 = long) */
227 FALSE
, /* pc_relative */
229 complain_overflow_bitfield
,/* complain_on_overflow */
230 bfd_elf_generic_reloc
, /* special_function */
231 "R_LM32_8", /* name */
232 FALSE
, /* partial_inplace */
235 FALSE
), /* pcrel_offset */
237 /* A 16 bit absolute relocation. */
238 HOWTO (R_LM32_16
, /* type */
240 1, /* size (0 = byte, 1 = short, 2 = long) */
242 FALSE
, /* pc_relative */
244 complain_overflow_bitfield
,/* complain_on_overflow */
245 bfd_elf_generic_reloc
, /* special_function */
246 "R_LM32_16", /* name */
247 FALSE
, /* partial_inplace */
249 0xffff, /* dst_mask */
250 FALSE
), /* pcrel_offset */
252 /* A 32 bit absolute relocation. */
253 HOWTO (R_LM32_32
, /* type */
255 2, /* size (0 = byte, 1 = short, 2 = long) */
257 FALSE
, /* pc_relative */
259 complain_overflow_bitfield
,/* complain_on_overflow */
260 bfd_elf_generic_reloc
, /* special_function */
261 "R_LM32_32", /* name */
262 FALSE
, /* partial_inplace */
264 0xffffffff, /* dst_mask */
265 FALSE
), /* pcrel_offset */
267 HOWTO (R_LM32_HI16
, /* type */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
271 FALSE
, /* pc_relative */
273 complain_overflow_bitfield
,/* complain_on_overflow */
274 bfd_elf_generic_reloc
, /* special_function */
275 "R_LM32_HI16", /* name */
276 FALSE
, /* partial_inplace */
278 0xffff, /* dst_mask */
279 FALSE
), /* pcrel_offset */
281 HOWTO (R_LM32_LO16
, /* type */
283 2, /* size (0 = byte, 1 = short, 2 = long) */
285 FALSE
, /* pc_relative */
287 complain_overflow_dont
, /* complain_on_overflow */
288 bfd_elf_generic_reloc
, /* special_function */
289 "R_LM32_LO16", /* name */
290 FALSE
, /* partial_inplace */
292 0xffff, /* dst_mask */
293 FALSE
), /* pcrel_offset */
295 HOWTO (R_LM32_GPREL16
, /* type */
297 2, /* size (0 = byte, 1 = short, 2 = long) */
299 FALSE
, /* pc_relative */
301 complain_overflow_dont
, /* complain_on_overflow */
302 lm32_elf_gprel_reloc
, /* special_function */
303 "R_LM32_GPREL16", /* name */
304 FALSE
, /* partial_inplace */
306 0xffff, /* dst_mask */
307 FALSE
), /* pcrel_offset */
309 HOWTO (R_LM32_CALL
, /* type */
311 2, /* size (0 = byte, 1 = short, 2 = long) */
313 TRUE
, /* pc_relative */
315 complain_overflow_signed
, /* complain_on_overflow */
316 bfd_elf_generic_reloc
, /* special_function */
317 "R_LM32_CALL", /* name */
318 FALSE
, /* partial_inplace */
320 0x3ffffff, /* dst_mask */
321 TRUE
), /* pcrel_offset */
323 HOWTO (R_LM32_BRANCH
, /* type */
325 2, /* size (0 = byte, 1 = short, 2 = long) */
327 TRUE
, /* pc_relative */
329 complain_overflow_signed
, /* complain_on_overflow */
330 bfd_elf_generic_reloc
, /* special_function */
331 "R_LM32_BRANCH", /* name */
332 FALSE
, /* partial_inplace */
334 0xffff, /* dst_mask */
335 TRUE
), /* pcrel_offset */
337 /* GNU extension to record C++ vtable hierarchy. */
338 HOWTO (R_LM32_GNU_VTINHERIT
, /* type */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
342 FALSE
, /* pc_relative */
344 complain_overflow_dont
, /* complain_on_overflow */
345 NULL
, /* special_function */
346 "R_LM32_GNU_VTINHERIT", /* name */
347 FALSE
, /* partial_inplace */
350 FALSE
), /* pcrel_offset */
352 /* GNU extension to record C++ vtable member usage. */
353 HOWTO (R_LM32_GNU_VTENTRY
, /* type */
355 2, /* size (0 = byte, 1 = short, 2 = long) */
357 FALSE
, /* pc_relative */
359 complain_overflow_dont
, /* complain_on_overflow */
360 _bfd_elf_rel_vtable_reloc_fn
,/* special_function */
361 "R_LM32_GNU_VTENTRY", /* name */
362 FALSE
, /* partial_inplace */
365 FALSE
), /* pcrel_offset */
367 HOWTO (R_LM32_16_GOT
, /* type */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
371 FALSE
, /* pc_relative */
373 complain_overflow_signed
, /* complain_on_overflow */
374 bfd_elf_generic_reloc
, /* special_function */
375 "R_LM32_16_GOT", /* name */
376 FALSE
, /* partial_inplace */
378 0xffff, /* dst_mask */
379 FALSE
), /* pcrel_offset */
381 HOWTO (R_LM32_GOTOFF_HI16
, /* type */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
385 FALSE
, /* pc_relative */
387 complain_overflow_dont
, /* complain_on_overflow */
388 bfd_elf_generic_reloc
, /* special_function */
389 "R_LM32_GOTOFF_HI16", /* name */
390 FALSE
, /* partial_inplace */
391 0xffff, /* src_mask */
392 0xffff, /* dst_mask */
393 FALSE
), /* pcrel_offset */
395 HOWTO (R_LM32_GOTOFF_LO16
, /* type */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
399 FALSE
, /* pc_relative */
401 complain_overflow_dont
, /* complain_on_overflow */
402 bfd_elf_generic_reloc
, /* special_function */
403 "R_LM32_GOTOFF_LO16", /* name */
404 FALSE
, /* partial_inplace */
405 0xffff, /* src_mask */
406 0xffff, /* dst_mask */
407 FALSE
), /* pcrel_offset */
409 HOWTO (R_LM32_COPY
, /* type */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
413 FALSE
, /* pc_relative */
415 complain_overflow_bitfield
, /* complain_on_overflow */
416 bfd_elf_generic_reloc
, /* special_function */
417 "R_LM32_COPY", /* name */
418 FALSE
, /* partial_inplace */
419 0xffffffff, /* src_mask */
420 0xffffffff, /* dst_mask */
421 FALSE
), /* pcrel_offset */
423 HOWTO (R_LM32_GLOB_DAT
, /* type */
425 2, /* size (0 = byte, 1 = short, 2 = long) */
427 FALSE
, /* pc_relative */
429 complain_overflow_bitfield
, /* complain_on_overflow */
430 bfd_elf_generic_reloc
, /* special_function */
431 "R_LM32_GLOB_DAT", /* name */
432 FALSE
, /* partial_inplace */
433 0xffffffff, /* src_mask */
434 0xffffffff, /* dst_mask */
435 FALSE
), /* pcrel_offset */
437 HOWTO (R_LM32_JMP_SLOT
, /* type */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
441 FALSE
, /* pc_relative */
443 complain_overflow_bitfield
, /* complain_on_overflow */
444 bfd_elf_generic_reloc
, /* special_function */
445 "R_LM32_JMP_SLOT", /* name */
446 FALSE
, /* partial_inplace */
447 0xffffffff, /* src_mask */
448 0xffffffff, /* dst_mask */
449 FALSE
), /* pcrel_offset */
451 HOWTO (R_LM32_RELATIVE
, /* type */
453 2, /* size (0 = byte, 1 = short, 2 = long) */
455 FALSE
, /* pc_relative */
457 complain_overflow_bitfield
, /* complain_on_overflow */
458 bfd_elf_generic_reloc
, /* special_function */
459 "R_LM32_RELATIVE", /* name */
460 FALSE
, /* partial_inplace */
461 0xffffffff, /* src_mask */
462 0xffffffff, /* dst_mask */
463 FALSE
), /* pcrel_offset */
467 /* Map BFD reloc types to lm32 ELF reloc types. */
469 struct lm32_reloc_map
471 bfd_reloc_code_real_type bfd_reloc_val
;
472 unsigned char elf_reloc_val
;
475 static const struct lm32_reloc_map lm32_reloc_map
[] =
477 { BFD_RELOC_NONE
, R_LM32_NONE
},
478 { BFD_RELOC_8
, R_LM32_8
},
479 { BFD_RELOC_16
, R_LM32_16
},
480 { BFD_RELOC_32
, R_LM32_32
},
481 { BFD_RELOC_HI16
, R_LM32_HI16
},
482 { BFD_RELOC_LO16
, R_LM32_LO16
},
483 { BFD_RELOC_GPREL16
, R_LM32_GPREL16
},
484 { BFD_RELOC_LM32_CALL
, R_LM32_CALL
},
485 { BFD_RELOC_LM32_BRANCH
, R_LM32_BRANCH
},
486 { BFD_RELOC_VTABLE_INHERIT
, R_LM32_GNU_VTINHERIT
},
487 { BFD_RELOC_VTABLE_ENTRY
, R_LM32_GNU_VTENTRY
},
488 { BFD_RELOC_LM32_16_GOT
, R_LM32_16_GOT
},
489 { BFD_RELOC_LM32_GOTOFF_HI16
, R_LM32_GOTOFF_HI16
},
490 { BFD_RELOC_LM32_GOTOFF_LO16
, R_LM32_GOTOFF_LO16
},
491 { BFD_RELOC_LM32_COPY
, R_LM32_COPY
},
492 { BFD_RELOC_LM32_GLOB_DAT
, R_LM32_GLOB_DAT
},
493 { BFD_RELOC_LM32_JMP_SLOT
, R_LM32_JMP_SLOT
},
494 { BFD_RELOC_LM32_RELATIVE
, R_LM32_RELATIVE
},
497 static reloc_howto_type
*
498 lm32_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
499 bfd_reloc_code_real_type code
)
503 for (i
= 0; i
< sizeof (lm32_reloc_map
) / sizeof (lm32_reloc_map
[0]); i
++)
504 if (lm32_reloc_map
[i
].bfd_reloc_val
== code
)
505 return &lm32_elf_howto_table
[lm32_reloc_map
[i
].elf_reloc_val
];
509 static reloc_howto_type
*
510 lm32_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
516 i
< sizeof (lm32_elf_howto_table
) / sizeof (lm32_elf_howto_table
[0]);
518 if (lm32_elf_howto_table
[i
].name
!= NULL
519 && strcasecmp (lm32_elf_howto_table
[i
].name
, r_name
) == 0)
520 return &lm32_elf_howto_table
[i
];
526 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
529 lm32_info_to_howto_rela (bfd
*abfd
,
531 Elf_Internal_Rela
*dst
)
535 r_type
= ELF32_R_TYPE (dst
->r_info
);
536 if (r_type
>= (unsigned int) R_LM32_max
)
538 /* xgettext:c-format */
539 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
543 cache_ptr
->howto
= &lm32_elf_howto_table
[r_type
];
546 /* Set the right machine number for an Lattice Mico32 ELF file. */
549 lm32_elf_object_p (bfd
*abfd
)
551 return bfd_default_set_arch_mach (abfd
, bfd_arch_lm32
, bfd_mach_lm32
);
554 /* Set machine type flags just before file is written out. */
557 lm32_elf_final_write_processing (bfd
*abfd
, bfd_boolean linker ATTRIBUTE_UNUSED
)
559 elf_elfheader (abfd
)->e_machine
= EM_LATTICEMICO32
;
560 elf_elfheader (abfd
)->e_flags
&=~ EF_LM32_MACH
;
561 switch (bfd_get_mach (abfd
))
564 elf_elfheader (abfd
)->e_flags
|= E_LM32_MACH
;
571 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
572 dangerous relocation. */
575 lm32_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
581 /* If we've already figured out what GP will be, just return it. */
582 *pgp
= _bfd_get_gp_value (output_bfd
);
586 count
= bfd_get_symcount (output_bfd
);
587 sym
= bfd_get_outsymbols (output_bfd
);
589 /* The linker script will have created a symbol named `_gp' with the
590 appropriate value. */
595 for (i
= 0; i
< count
; i
++, sym
++)
599 name
= bfd_asymbol_name (*sym
);
600 if (*name
== '_' && strcmp (name
, "_gp") == 0)
602 *pgp
= bfd_asymbol_value (*sym
);
603 _bfd_set_gp_value (output_bfd
, *pgp
);
611 /* Only get the error once. */
613 _bfd_set_gp_value (output_bfd
, *pgp
);
620 /* We have to figure out the gp value, so that we can adjust the
621 symbol value correctly. We look up the symbol _gp in the output
622 BFD. If we can't find it, we're stuck. We cache it in the ELF
623 target data. We don't need to adjust the symbol value for an
624 external symbol if we are producing relocatable output. */
626 static bfd_reloc_status_type
627 lm32_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
628 char **error_message
, bfd_vma
*pgp
)
630 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
633 return bfd_reloc_undefined
;
636 *pgp
= _bfd_get_gp_value (output_bfd
);
637 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
641 /* Make up a value. */
642 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
643 _bfd_set_gp_value (output_bfd
, *pgp
);
645 else if (!lm32_elf_assign_gp (output_bfd
, pgp
))
649 _("global pointer relative relocation when _gp not defined");
650 return bfd_reloc_dangerous
;
657 static bfd_reloc_status_type
658 lm32_elf_do_gprel_relocate (bfd
*abfd
,
659 reloc_howto_type
*howto
,
660 asection
*input_section ATTRIBUTE_UNUSED
,
663 bfd_vma symbol_value
,
666 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
667 data
, offset
, symbol_value
, addend
);
670 static bfd_reloc_status_type
671 lm32_elf_gprel_reloc (bfd
*abfd
,
672 arelent
*reloc_entry
,
675 asection
*input_section
,
681 bfd_reloc_status_type r
;
683 if (output_bfd
!= (bfd
*) NULL
684 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
685 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
687 reloc_entry
->address
+= input_section
->output_offset
;
691 if (output_bfd
!= NULL
)
694 relocation
= symbol
->value
695 + symbol
->section
->output_section
->vma
+ symbol
->section
->output_offset
;
698 lm32_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
)) == bfd_reloc_ok
)
700 relocation
= relocation
+ reloc_entry
->addend
- gp
;
701 reloc_entry
->addend
= 0;
702 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
704 *msg
= _("global pointer relative address out of range");
705 r
= bfd_reloc_outofrange
;
709 r
= lm32_elf_do_gprel_relocate (abfd
, reloc_entry
->howto
,
711 data
, reloc_entry
->address
,
712 relocation
, reloc_entry
->addend
);
719 /* Find the segment number in which OSEC, and output section, is
723 _lm32fdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
725 struct elf_segment_map
*m
;
726 Elf_Internal_Phdr
*p
;
728 /* Find the segment that contains the output_section. */
729 for (m
= elf_seg_map (output_bfd
), p
= elf_tdata (output_bfd
)->phdr
;
735 for (i
= m
->count
- 1; i
>= 0; i
--)
736 if (m
->sections
[i
] == osec
)
743 return p
- elf_tdata (output_bfd
)->phdr
;
746 /* Determine if an output section is read-only. */
748 inline static bfd_boolean
749 _lm32fdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
751 unsigned seg
= _lm32fdpic_osec_to_segment (output_bfd
, osec
);
753 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
756 /* Relocate a section */
759 lm32_elf_relocate_section (bfd
*output_bfd
,
760 struct bfd_link_info
*info
,
762 asection
*input_section
,
764 Elf_Internal_Rela
*relocs
,
765 Elf_Internal_Sym
*local_syms
,
766 asection
**local_sections
)
768 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
769 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
770 Elf_Internal_Rela
*rel
, *relend
;
771 struct elf_lm32_link_hash_table
*htab
= lm32_elf_hash_table (info
);
772 bfd_vma
*local_got_offsets
;
778 local_got_offsets
= elf_local_got_offsets (input_bfd
);
780 sgot
= htab
->root
.sgot
;
782 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
783 sym_hashes
= elf_sym_hashes (input_bfd
);
786 relend
= relocs
+ input_section
->reloc_count
;
787 for (; rel
< relend
; rel
++)
789 reloc_howto_type
*howto
;
791 unsigned long r_symndx
;
792 Elf_Internal_Sym
*sym
;
794 struct elf_link_hash_entry
*h
;
797 bfd_reloc_status_type r
;
798 const char *name
= NULL
;
800 r_symndx
= ELF32_R_SYM (rel
->r_info
);
801 r_type
= ELF32_R_TYPE (rel
->r_info
);
803 if (r_type
== R_LM32_GNU_VTENTRY
804 || r_type
== R_LM32_GNU_VTINHERIT
)
811 howto
= lm32_elf_howto_table
+ r_type
;
813 if (r_symndx
< symtab_hdr
->sh_info
)
815 /* It's a local symbol. */
816 sym
= local_syms
+ r_symndx
;
817 sec
= local_sections
[r_symndx
];
818 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
819 name
= bfd_elf_string_from_elf_section
820 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
821 name
= (name
== NULL
) ? bfd_section_name (input_bfd
, sec
) : name
;
825 /* It's a global symbol. */
826 bfd_boolean unresolved_reloc
;
827 bfd_boolean warned
, ignored
;
829 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
830 r_symndx
, symtab_hdr
, sym_hashes
,
832 unresolved_reloc
, warned
, ignored
);
833 name
= h
->root
.root
.string
;
836 if (sec
!= NULL
&& discarded_section (sec
))
837 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
838 rel
, 1, relend
, howto
, 0, contents
);
840 if (bfd_link_relocatable (info
))
842 /* This is a relocatable link. We don't have to change
843 anything, unless the reloc is against a section symbol,
844 in which case we have to adjust according to where the
845 section symbol winds up in the output section. */
846 if (sym
== NULL
|| ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
849 /* If partial_inplace, we need to store any additional addend
850 back in the section. */
851 if (! howto
->partial_inplace
)
854 /* Shouldn't reach here. */
863 if (!lm32_elf_assign_gp (output_bfd
, &gp
))
864 r
= bfd_reloc_dangerous
;
867 relocation
= relocation
+ rel
->r_addend
- gp
;
869 if ((signed)relocation
< -32768 || (signed)relocation
> 32767)
870 r
= bfd_reloc_outofrange
;
873 r
= _bfd_final_link_relocate (howto
, input_bfd
,
874 input_section
, contents
,
875 rel
->r_offset
, relocation
,
881 /* Relocation is to the entry for this symbol in the global
883 BFD_ASSERT (sgot
!= NULL
);
890 BFD_ASSERT (off
!= (bfd_vma
) -1);
892 dyn
= htab
->root
.dynamic_sections_created
;
893 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
896 || (bfd_link_pic (info
)
902 /* This is actually a static link, or it is a
903 -Bsymbolic link and the symbol is defined
904 locally, or the symbol was forced to be local
905 because of a version file. We must initialize
906 this entry in the global offset table. Since the
907 offset must always be a multiple of 4, we use the
908 least significant bit to record whether we have
909 initialized it already.
911 When doing a dynamic link, we create a .rela.got
912 relocation entry to initialize the value. This
913 is done in the finish_dynamic_symbol routine. */
918 /* Write entry in GOT */
919 bfd_put_32 (output_bfd
, relocation
,
920 sgot
->contents
+ off
);
921 /* Create entry in .rofixup pointing to GOT entry. */
922 if (IS_FDPIC (output_bfd
) && h
->root
.type
!= bfd_link_hash_undefweak
)
924 _lm32fdpic_add_rofixup (output_bfd
,
925 lm32fdpic_fixup32_section
927 sgot
->output_section
->vma
928 + sgot
->output_offset
931 /* Mark GOT entry as having been written. */
936 relocation
= sgot
->output_offset
+ off
;
943 BFD_ASSERT (local_got_offsets
!= NULL
944 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
946 /* Get offset into GOT table. */
947 off
= local_got_offsets
[r_symndx
];
949 /* The offset must always be a multiple of 4. We use
950 the least significant bit to record whether we have
951 already processed this entry. */
956 /* Write entry in GOT. */
957 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
958 /* Create entry in .rofixup pointing to GOT entry. */
959 if (IS_FDPIC (output_bfd
))
961 _lm32fdpic_add_rofixup (output_bfd
,
962 lm32fdpic_fixup32_section
964 sgot
->output_section
->vma
965 + sgot
->output_offset
969 if (bfd_link_pic (info
))
972 Elf_Internal_Rela outrel
;
974 /* We need to generate a R_LM32_RELATIVE reloc
975 for the dynamic linker. */
976 srelgot
= htab
->root
.srelgot
;
977 BFD_ASSERT (srelgot
!= NULL
);
979 outrel
.r_offset
= (sgot
->output_section
->vma
980 + sgot
->output_offset
982 outrel
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
983 outrel
.r_addend
= relocation
;
984 loc
= srelgot
->contents
;
985 loc
+= srelgot
->reloc_count
* sizeof (Elf32_External_Rela
);
986 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,loc
);
987 ++srelgot
->reloc_count
;
990 local_got_offsets
[r_symndx
] |= 1;
994 relocation
= sgot
->output_offset
+ off
;
997 /* Addend should be zero. */
998 if (rel
->r_addend
!= 0)
1000 (_("internal error: addend should be zero for %s"),
1003 r
= _bfd_final_link_relocate (howto
,
1012 case R_LM32_GOTOFF_LO16
:
1013 case R_LM32_GOTOFF_HI16
:
1014 /* Relocation is offset from GOT. */
1015 BFD_ASSERT (sgot
!= NULL
);
1016 relocation
-= sgot
->output_section
->vma
;
1017 /* Account for sign-extension. */
1018 if ((r_type
== R_LM32_GOTOFF_HI16
)
1019 && ((relocation
+ rel
->r_addend
) & 0x8000))
1020 rel
->r_addend
+= 0x10000;
1021 r
= _bfd_final_link_relocate (howto
,
1031 if (IS_FDPIC (output_bfd
))
1033 if ((!h
) || (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
1035 /* Only create .rofixup entries for relocs in loadable sections. */
1036 if ((bfd_get_section_flags (output_bfd
, input_section
->output_section
)
1037 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
1040 /* Check address to be modified is writable. */
1041 if (_lm32fdpic_osec_readonly_p (output_bfd
,
1045 info
->callbacks
->warning
1047 _("cannot emit dynamic relocations in read-only section"),
1048 name
, input_bfd
, input_section
, rel
->r_offset
);
1051 /* Create entry in .rofixup section. */
1052 _lm32fdpic_add_rofixup (output_bfd
,
1053 lm32fdpic_fixup32_section (info
),
1054 input_section
->output_section
->vma
1055 + input_section
->output_offset
1063 r
= _bfd_final_link_relocate (howto
,
1074 if (r
!= bfd_reloc_ok
)
1076 const char *msg
= NULL
;
1079 lm32_info_to_howto_rela (input_bfd
, &bfd_reloc
, rel
);
1080 howto
= bfd_reloc
.howto
;
1083 name
= h
->root
.root
.string
;
1086 name
= (bfd_elf_string_from_elf_section
1087 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1088 if (name
== NULL
|| *name
== '\0')
1089 name
= bfd_section_name (input_bfd
, sec
);
1094 case bfd_reloc_overflow
:
1096 && (h
->root
.type
== bfd_link_hash_undefweak
))
1098 (*info
->callbacks
->reloc_overflow
)
1099 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1100 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1103 case bfd_reloc_undefined
:
1104 (*info
->callbacks
->undefined_symbol
)
1105 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1108 case bfd_reloc_outofrange
:
1109 msg
= _("internal error: out of range error");
1112 case bfd_reloc_notsupported
:
1113 msg
= _("internal error: unsupported relocation error");
1116 case bfd_reloc_dangerous
:
1117 msg
= _("internal error: dangerous error");
1121 msg
= _("internal error: unknown error");
1125 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1126 input_section
, rel
->r_offset
);
1136 lm32_elf_gc_mark_hook (asection
*sec
,
1137 struct bfd_link_info
*info
,
1138 Elf_Internal_Rela
*rel
,
1139 struct elf_link_hash_entry
*h
,
1140 Elf_Internal_Sym
*sym
)
1143 switch (ELF32_R_TYPE (rel
->r_info
))
1145 case R_LM32_GNU_VTINHERIT
:
1146 case R_LM32_GNU_VTENTRY
:
1150 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1153 /* Look through the relocs for a section during the first phase. */
1156 lm32_elf_check_relocs (bfd
*abfd
,
1157 struct bfd_link_info
*info
,
1159 const Elf_Internal_Rela
*relocs
)
1161 Elf_Internal_Shdr
*symtab_hdr
;
1162 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
1163 const Elf_Internal_Rela
*rel
;
1164 const Elf_Internal_Rela
*rel_end
;
1165 struct elf_lm32_link_hash_table
*htab
;
1168 if (bfd_link_relocatable (info
))
1171 /* Don't do anything special with non-loaded, non-alloced sections.
1172 In particular, any relocs in such sections should not affect GOT
1173 and PLT reference counting (ie. we don't allow them to create GOT
1174 or PLT entries), there's no possibility or desire to optimize TLS
1175 relocs, and there's not much point in propagating relocs to shared
1176 libs that the dynamic linker won't relocate. */
1177 if ((sec
->flags
& SEC_ALLOC
) == 0)
1180 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1181 sym_hashes
= elf_sym_hashes (abfd
);
1182 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
1183 if (!elf_bad_symtab (abfd
))
1184 sym_hashes_end
-= symtab_hdr
->sh_info
;
1186 htab
= lm32_elf_hash_table (info
);
1190 dynobj
= htab
->root
.dynobj
;
1192 rel_end
= relocs
+ sec
->reloc_count
;
1193 for (rel
= relocs
; rel
< rel_end
; rel
++)
1196 struct elf_link_hash_entry
*h
;
1197 unsigned long r_symndx
;
1199 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1200 r_type
= ELF32_R_TYPE (rel
->r_info
);
1201 if (r_symndx
< symtab_hdr
->sh_info
)
1205 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1206 while (h
->root
.type
== bfd_link_hash_indirect
1207 || h
->root
.type
== bfd_link_hash_warning
)
1208 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1211 /* Some relocs require a global offset table. */
1212 if (htab
->root
.sgot
== NULL
)
1217 case R_LM32_GOTOFF_HI16
:
1218 case R_LM32_GOTOFF_LO16
:
1220 htab
->root
.dynobj
= dynobj
= abfd
;
1221 if (!_bfd_elf_create_got_section (dynobj
, info
))
1227 /* Some relocs require a rofixup table. */
1228 if (IS_FDPIC (abfd
))
1233 /* FDPIC requires a GOT if there is a .rofixup section
1234 (Normal ELF doesn't). */
1236 htab
->root
.dynobj
= dynobj
= abfd
;
1237 if (!_bfd_elf_create_got_section (dynobj
, info
))
1239 /* Create .rofixup section */
1240 if (htab
->sfixup32
== NULL
)
1242 if (! create_rofixup_section (dynobj
, info
))
1247 case R_LM32_GOTOFF_HI16
:
1248 case R_LM32_GOTOFF_LO16
:
1249 /* Create .rofixup section. */
1250 if (htab
->sfixup32
== NULL
)
1253 htab
->root
.dynobj
= dynobj
= abfd
;
1254 if (! create_rofixup_section (dynobj
, info
))
1265 h
->got
.refcount
+= 1;
1268 bfd_signed_vma
*local_got_refcounts
;
1270 /* This is a global offset table entry for a local symbol. */
1271 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1272 if (local_got_refcounts
== NULL
)
1276 size
= symtab_hdr
->sh_info
;
1277 size
*= sizeof (bfd_signed_vma
);
1278 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1279 if (local_got_refcounts
== NULL
)
1281 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1283 local_got_refcounts
[r_symndx
] += 1;
1287 /* This relocation describes the C++ object vtable hierarchy.
1288 Reconstruct it for later use during GC. */
1289 case R_LM32_GNU_VTINHERIT
:
1290 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1294 /* This relocation describes which C++ vtable entries are actually
1295 used. Record for later use during GC. */
1296 case R_LM32_GNU_VTENTRY
:
1297 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1307 /* Finish up the dynamic sections. */
1310 lm32_elf_finish_dynamic_sections (bfd
*output_bfd
,
1311 struct bfd_link_info
*info
)
1313 struct elf_lm32_link_hash_table
*htab
;
1318 htab
= lm32_elf_hash_table (info
);
1322 dynobj
= htab
->root
.dynobj
;
1324 sgot
= htab
->root
.sgotplt
;
1325 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1327 if (htab
->root
.dynamic_sections_created
)
1330 Elf32_External_Dyn
*dyncon
, *dynconend
;
1332 BFD_ASSERT (sgot
!= NULL
&& sdyn
!= NULL
);
1334 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1335 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
1337 for (; dyncon
< dynconend
; dyncon
++)
1339 Elf_Internal_Dyn dyn
;
1342 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1350 s
= htab
->root
.sgotplt
;
1353 s
= htab
->root
.srelplt
;
1355 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1356 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1360 s
= htab
->root
.srelplt
;
1361 dyn
.d_un
.d_val
= s
->size
;
1362 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1367 /* Fill in the first entry in the procedure linkage table. */
1368 splt
= htab
->root
.splt
;
1369 if (splt
&& splt
->size
> 0)
1371 if (bfd_link_pic (info
))
1373 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD0
, splt
->contents
);
1374 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD1
, splt
->contents
+ 4);
1375 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD2
, splt
->contents
+ 8);
1376 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD3
, splt
->contents
+ 12);
1377 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD4
, splt
->contents
+ 16);
1382 /* addr = .got + 4 */
1383 addr
= sgot
->output_section
->vma
+ sgot
->output_offset
+ 4;
1384 bfd_put_32 (output_bfd
,
1385 PLT0_ENTRY_WORD0
| ((addr
>> 16) & 0xffff),
1387 bfd_put_32 (output_bfd
,
1388 PLT0_ENTRY_WORD1
| (addr
& 0xffff),
1389 splt
->contents
+ 4);
1390 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD2
, splt
->contents
+ 8);
1391 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD3
, splt
->contents
+ 12);
1392 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD4
, splt
->contents
+ 16);
1395 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1400 /* Fill in the first three entries in the global offset table. */
1401 if (sgot
&& sgot
->size
> 0)
1404 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1406 bfd_put_32 (output_bfd
,
1407 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1409 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1410 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1412 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1413 if (elf_section_data (sgot
->output_section
) != NULL
)
1414 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1417 if (lm32fdpic_fixup32_section (info
))
1419 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
1420 bfd_vma got_value
= hgot
->root
.u
.def
.value
1421 + hgot
->root
.u
.def
.section
->output_section
->vma
1422 + hgot
->root
.u
.def
.section
->output_offset
;
1423 struct bfd_link_hash_entry
*hend
;
1425 /* Last entry is pointer to GOT. */
1426 _lm32fdpic_add_rofixup (output_bfd
, lm32fdpic_fixup32_section (info
), got_value
);
1428 /* Check we wrote enough entries. */
1429 if (lm32fdpic_fixup32_section (info
)->size
1430 != (lm32fdpic_fixup32_section (info
)->reloc_count
* 4))
1433 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1435 (int64_t) (lm32fdpic_fixup32_section (info
)->size
/ 4),
1436 lm32fdpic_fixup32_section (info
)->reloc_count
);
1440 hend
= bfd_link_hash_lookup (info
->hash
, "__ROFIXUP_END__",
1441 FALSE
, FALSE
, TRUE
);
1443 && (hend
->type
== bfd_link_hash_defined
1444 || hend
->type
== bfd_link_hash_defweak
))
1447 lm32fdpic_fixup32_section (info
)->output_section
->vma
1448 + lm32fdpic_fixup32_section (info
)->output_offset
1449 + lm32fdpic_fixup32_section (info
)->size
1450 - hend
->u
.def
.section
->output_section
->vma
1451 - hend
->u
.def
.section
->output_offset
;
1452 BFD_ASSERT (hend
->u
.def
.value
== value
);
1453 if (hend
->u
.def
.value
!= value
)
1456 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1457 PRId64
" != %" PRId64
,
1458 (int64_t) hend
->u
.def
.value
, (int64_t) value
);
1467 /* Finish up dynamic symbol handling. We set the contents of various
1468 dynamic sections here. */
1471 lm32_elf_finish_dynamic_symbol (bfd
*output_bfd
,
1472 struct bfd_link_info
*info
,
1473 struct elf_link_hash_entry
*h
,
1474 Elf_Internal_Sym
*sym
)
1476 struct elf_lm32_link_hash_table
*htab
;
1479 htab
= lm32_elf_hash_table (info
);
1483 if (h
->plt
.offset
!= (bfd_vma
) -1)
1491 Elf_Internal_Rela rela
;
1493 /* This symbol has an entry in the procedure linkage table. Set
1495 BFD_ASSERT (h
->dynindx
!= -1);
1497 splt
= htab
->root
.splt
;
1498 sgot
= htab
->root
.sgotplt
;
1499 srela
= htab
->root
.srelplt
;
1500 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1502 /* Get the index in the procedure linkage table which
1503 corresponds to this symbol. This is the index of this symbol
1504 in all the symbols for which we are making plt entries. The
1505 first entry in the procedure linkage table is reserved. */
1506 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1508 /* Get the offset into the .got table of the entry that
1509 corresponds to this function. Each .got entry is 4 bytes.
1510 The first three are reserved. */
1511 got_offset
= (plt_index
+ 3) * 4;
1513 /* Fill in the entry in the procedure linkage table. */
1514 if (! bfd_link_pic (info
))
1523 /* Fill in the entry in the global offset table. */
1524 bfd_put_32 (output_bfd
,
1525 (splt
->output_section
->vma
1526 + splt
->output_offset
1528 + 12), /* same offset */
1529 sgot
->contents
+ got_offset
);
1531 /* Fill in the entry in the .rela.plt section. */
1532 rela
.r_offset
= (sgot
->output_section
->vma
1533 + sgot
->output_offset
1535 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_JMP_SLOT
);
1537 loc
= srela
->contents
;
1538 loc
+= plt_index
* sizeof (Elf32_External_Rela
);
1539 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1541 if (!h
->def_regular
)
1543 /* Mark the symbol as undefined, rather than as defined in
1544 the .plt section. Leave the value alone. */
1545 sym
->st_shndx
= SHN_UNDEF
;
1550 if (h
->got
.offset
!= (bfd_vma
) -1)
1554 Elf_Internal_Rela rela
;
1556 /* This symbol has an entry in the global offset table. Set it
1558 sgot
= htab
->root
.sgot
;
1559 srela
= htab
->root
.srelgot
;
1560 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1562 rela
.r_offset
= (sgot
->output_section
->vma
1563 + sgot
->output_offset
1564 + (h
->got
.offset
&~ 1));
1566 /* If this is a -Bsymbolic link, and the symbol is defined
1567 locally, we just want to emit a RELATIVE reloc. Likewise if
1568 the symbol was forced to be local because of a version file.
1569 The entry in the global offset table will already have been
1570 initialized in the relocate_section function. */
1571 if (bfd_link_pic (info
)
1577 rela
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
1578 rela
.r_addend
= (h
->root
.u
.def
.value
1579 + h
->root
.u
.def
.section
->output_section
->vma
1580 + h
->root
.u
.def
.section
->output_offset
);
1584 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
1585 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1586 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_GLOB_DAT
);
1590 loc
= srela
->contents
;
1591 loc
+= srela
->reloc_count
* sizeof (Elf32_External_Rela
);
1592 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1593 ++srela
->reloc_count
;
1599 Elf_Internal_Rela rela
;
1601 /* This symbols needs a copy reloc. Set it up. */
1602 BFD_ASSERT (h
->dynindx
!= -1
1603 && (h
->root
.type
== bfd_link_hash_defined
1604 || h
->root
.type
== bfd_link_hash_defweak
));
1606 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
1607 BFD_ASSERT (s
!= NULL
);
1609 rela
.r_offset
= (h
->root
.u
.def
.value
1610 + h
->root
.u
.def
.section
->output_section
->vma
1611 + h
->root
.u
.def
.section
->output_offset
);
1612 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_COPY
);
1615 loc
+= s
->reloc_count
* sizeof (Elf32_External_Rela
);
1616 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1620 /* Mark some specially defined symbols as absolute. */
1621 if (h
== htab
->root
.hdynamic
|| h
== htab
->root
.hgot
)
1622 sym
->st_shndx
= SHN_ABS
;
1627 static enum elf_reloc_type_class
1628 lm32_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1629 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1630 const Elf_Internal_Rela
*rela
)
1632 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1634 case R_LM32_RELATIVE
: return reloc_class_relative
;
1635 case R_LM32_JMP_SLOT
: return reloc_class_plt
;
1636 case R_LM32_COPY
: return reloc_class_copy
;
1637 default: return reloc_class_normal
;
1641 /* Find dynamic relocs for H that apply to read-only sections. */
1644 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
1646 struct elf_dyn_relocs
*p
;
1647 struct elf_lm32_link_hash_entry
*eh
= (struct elf_lm32_link_hash_entry
*) h
;
1649 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1651 asection
*s
= p
->sec
->output_section
;
1653 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1659 /* Adjust a symbol defined by a dynamic object and referenced by a
1660 regular object. The current definition is in some section of the
1661 dynamic object, but we're not including those sections. We have to
1662 change the definition to something the rest of the link can
1666 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1667 struct elf_link_hash_entry
*h
)
1669 struct elf_lm32_link_hash_table
*htab
;
1673 dynobj
= elf_hash_table (info
)->dynobj
;
1675 /* Make sure we know what is going on here. */
1676 BFD_ASSERT (dynobj
!= NULL
1681 && !h
->def_regular
)));
1683 /* If this is a function, put it in the procedure linkage table. We
1684 will fill in the contents of the procedure linkage table later,
1685 when we know the address of the .got section. */
1686 if (h
->type
== STT_FUNC
1689 if (! bfd_link_pic (info
)
1692 && h
->root
.type
!= bfd_link_hash_undefweak
1693 && h
->root
.type
!= bfd_link_hash_undefined
)
1695 /* This case can occur if we saw a PLT reloc in an input
1696 file, but the symbol was never referred to by a dynamic
1697 object. In such a case, we don't actually need to build
1698 a procedure linkage table, and we can just do a PCREL
1700 h
->plt
.offset
= (bfd_vma
) -1;
1707 h
->plt
.offset
= (bfd_vma
) -1;
1709 /* If this is a weak symbol, and there is a real definition, the
1710 processor independent code will have arranged for us to see the
1711 real definition first, and we can just use the same value. */
1712 if (h
->is_weakalias
)
1714 struct elf_link_hash_entry
*def
= weakdef (h
);
1715 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1716 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1717 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1721 /* This is a reference to a symbol defined by a dynamic object which
1722 is not a function. */
1724 /* If we are creating a shared library, we must presume that the
1725 only references to the symbol are via the global offset table.
1726 For such cases we need not do anything here; the relocations will
1727 be handled correctly by relocate_section. */
1728 if (bfd_link_pic (info
))
1731 /* If there are no references to this symbol that do not use the
1732 GOT, we don't need to generate a copy reloc. */
1733 if (!h
->non_got_ref
)
1736 /* If -z nocopyreloc was given, we won't generate them either. */
1737 if (0 && info
->nocopyreloc
)
1743 /* If we don't find any dynamic relocs in read-only sections, then
1744 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1745 if (0 && !readonly_dynrelocs (h
))
1751 /* We must allocate the symbol in our .dynbss section, which will
1752 become part of the .bss section of the executable. There will be
1753 an entry for this symbol in the .dynsym section. The dynamic
1754 object will contain position independent code, so all references
1755 from the dynamic object to this symbol will go through the global
1756 offset table. The dynamic linker will use the .dynsym entry to
1757 determine the address it must put in the global offset table, so
1758 both the dynamic object and the regular object will refer to the
1759 same memory location for the variable. */
1761 htab
= lm32_elf_hash_table (info
);
1766 BFD_ASSERT (s
!= NULL
);
1768 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1769 to copy the initial value out of the dynamic object and into the
1770 runtime process image. We need to remember the offset into the
1771 .rela.bss section we are going to use. */
1772 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1776 srel
= htab
->srelbss
;
1777 BFD_ASSERT (srel
!= NULL
);
1778 srel
->size
+= sizeof (Elf32_External_Rela
);
1782 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1785 /* Allocate space in .plt, .got and associated reloc sections for
1789 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1791 struct bfd_link_info
*info
;
1792 struct elf_lm32_link_hash_table
*htab
;
1793 struct elf_lm32_link_hash_entry
*eh
;
1794 struct elf_dyn_relocs
*p
;
1796 if (h
->root
.type
== bfd_link_hash_indirect
)
1799 info
= (struct bfd_link_info
*) inf
;
1800 htab
= lm32_elf_hash_table (info
);
1804 eh
= (struct elf_lm32_link_hash_entry
*) h
;
1806 if (htab
->root
.dynamic_sections_created
1807 && h
->plt
.refcount
> 0)
1809 /* Make sure this symbol is output as a dynamic symbol.
1810 Undefined weak syms won't yet be marked as dynamic. */
1811 if (h
->dynindx
== -1
1812 && !h
->forced_local
)
1814 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1818 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1820 asection
*s
= htab
->root
.splt
;
1822 /* If this is the first .plt entry, make room for the special
1825 s
->size
+= PLT_ENTRY_SIZE
;
1827 h
->plt
.offset
= s
->size
;
1829 /* If this symbol is not defined in a regular file, and we are
1830 not generating a shared library, then set the symbol to this
1831 location in the .plt. This is required to make function
1832 pointers compare as equal between the normal executable and
1833 the shared library. */
1834 if (! bfd_link_pic (info
)
1837 h
->root
.u
.def
.section
= s
;
1838 h
->root
.u
.def
.value
= h
->plt
.offset
;
1841 /* Make room for this entry. */
1842 s
->size
+= PLT_ENTRY_SIZE
;
1844 /* We also need to make an entry in the .got.plt section, which
1845 will be placed in the .got section by the linker script. */
1846 htab
->root
.sgotplt
->size
+= 4;
1848 /* We also need to make an entry in the .rel.plt section. */
1849 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1853 h
->plt
.offset
= (bfd_vma
) -1;
1859 h
->plt
.offset
= (bfd_vma
) -1;
1863 if (h
->got
.refcount
> 0)
1868 /* Make sure this symbol is output as a dynamic symbol.
1869 Undefined weak syms won't yet be marked as dynamic. */
1870 if (h
->dynindx
== -1
1871 && !h
->forced_local
)
1873 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1877 s
= htab
->root
.sgot
;
1879 h
->got
.offset
= s
->size
;
1881 dyn
= htab
->root
.dynamic_sections_created
;
1882 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1883 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1886 h
->got
.offset
= (bfd_vma
) -1;
1888 if (eh
->dyn_relocs
== NULL
)
1891 /* In the shared -Bsymbolic case, discard space allocated for
1892 dynamic pc-relative relocs against symbols which turn out to be
1893 defined in regular objects. For the normal shared case, discard
1894 space for pc-relative relocs that have become local due to symbol
1895 visibility changes. */
1897 if (bfd_link_pic (info
))
1903 struct elf_dyn_relocs
**pp
;
1905 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
;)
1907 p
->count
-= p
->pc_count
;
1916 /* Also discard relocs on undefined weak syms with non-default
1918 if (eh
->dyn_relocs
!= NULL
1919 && h
->root
.type
== bfd_link_hash_undefweak
)
1921 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1922 eh
->dyn_relocs
= NULL
;
1924 /* Make sure undefined weak symbols are output as a dynamic
1926 else if (h
->dynindx
== -1
1927 && !h
->forced_local
)
1929 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1936 /* For the non-shared case, discard space for relocs against
1937 symbols which turn out to need copy relocs or are not
1943 || (htab
->root
.dynamic_sections_created
1944 && (h
->root
.type
== bfd_link_hash_undefweak
1945 || h
->root
.type
== bfd_link_hash_undefined
))))
1947 /* Make sure this symbol is output as a dynamic symbol.
1948 Undefined weak syms won't yet be marked as dynamic. */
1949 if (h
->dynindx
== -1
1950 && !h
->forced_local
)
1952 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1956 /* If that succeeded, we know we'll be keeping all the
1958 if (h
->dynindx
!= -1)
1962 eh
->dyn_relocs
= NULL
;
1967 /* Finally, allocate space. */
1968 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1970 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1971 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1977 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1978 read-only sections. */
1981 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1985 if (h
->root
.type
== bfd_link_hash_indirect
)
1988 sec
= readonly_dynrelocs (h
);
1991 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1993 info
->flags
|= DF_TEXTREL
;
1994 info
->callbacks
->minfo
1995 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1996 sec
->owner
, h
->root
.root
.string
, sec
);
1998 /* Not an error, just cut short the traversal. */
2004 /* Set the sizes of the dynamic sections. */
2007 lm32_elf_size_dynamic_sections (bfd
*output_bfd
,
2008 struct bfd_link_info
*info
)
2010 struct elf_lm32_link_hash_table
*htab
;
2016 htab
= lm32_elf_hash_table (info
);
2020 dynobj
= htab
->root
.dynobj
;
2021 BFD_ASSERT (dynobj
!= NULL
);
2023 if (htab
->root
.dynamic_sections_created
)
2025 /* Set the contents of the .interp section to the interpreter. */
2026 if (bfd_link_executable (info
) && !info
->nointerp
)
2028 s
= bfd_get_linker_section (dynobj
, ".interp");
2029 BFD_ASSERT (s
!= NULL
);
2030 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2031 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2035 /* Set up .got offsets for local syms, and space for local dynamic
2037 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2039 bfd_signed_vma
*local_got
;
2040 bfd_signed_vma
*end_local_got
;
2041 bfd_size_type locsymcount
;
2042 Elf_Internal_Shdr
*symtab_hdr
;
2045 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2048 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2050 struct elf_dyn_relocs
*p
;
2052 for (p
= ((struct elf_dyn_relocs
*)
2053 elf_section_data (s
)->local_dynrel
);
2057 if (! bfd_is_abs_section (p
->sec
)
2058 && bfd_is_abs_section (p
->sec
->output_section
))
2060 /* Input section has been discarded, either because
2061 it is a copy of a linkonce section or due to
2062 linker script /DISCARD/, so we'll be discarding
2065 else if (p
->count
!= 0)
2067 srel
= elf_section_data (p
->sec
)->sreloc
;
2068 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2069 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2070 info
->flags
|= DF_TEXTREL
;
2075 local_got
= elf_local_got_refcounts (ibfd
);
2079 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2080 locsymcount
= symtab_hdr
->sh_info
;
2081 end_local_got
= local_got
+ locsymcount
;
2082 s
= htab
->root
.sgot
;
2083 srel
= htab
->root
.srelgot
;
2084 for (; local_got
< end_local_got
; ++local_got
)
2088 *local_got
= s
->size
;
2090 if (bfd_link_pic (info
))
2091 srel
->size
+= sizeof (Elf32_External_Rela
);
2094 *local_got
= (bfd_vma
) -1;
2098 /* Allocate global sym .plt and .got entries, and space for global
2099 sym dynamic relocs. */
2100 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
2102 /* We now have determined the sizes of the various dynamic sections.
2103 Allocate memory for them. */
2105 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2107 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2110 if (s
== htab
->root
.splt
2111 || s
== htab
->root
.sgot
2112 || s
== htab
->root
.sgotplt
2113 || s
== htab
->sdynbss
)
2115 /* Strip this section if we don't need it; see the
2118 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2120 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
)
2123 /* We use the reloc_count field as a counter if we need
2124 to copy relocs into the output file. */
2128 /* It's not one of our sections, so don't allocate space. */
2133 /* If we don't need this section, strip it from the
2134 output file. This is mostly to handle .rela.bss and
2135 .rela.plt. We must create both sections in
2136 create_dynamic_sections, because they must be created
2137 before the linker maps input sections to output
2138 sections. The linker does that before
2139 adjust_dynamic_symbol is called, and it is that
2140 function which decides whether anything needs to go
2141 into these sections. */
2142 s
->flags
|= SEC_EXCLUDE
;
2146 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2149 /* Allocate memory for the section contents. We use bfd_zalloc
2150 here in case unused entries are not reclaimed before the
2151 section's contents are written out. This should not happen,
2152 but this way if it does, we get a R_LM32_NONE reloc instead
2154 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2155 if (s
->contents
== NULL
)
2159 if (htab
->root
.dynamic_sections_created
)
2161 /* Add some entries to the .dynamic section. We fill in the
2162 values later, in lm32_elf_finish_dynamic_sections, but we
2163 must add the entries now so that we get the correct size for
2164 the .dynamic section. The DT_DEBUG entry is filled in by the
2165 dynamic linker and used by the debugger. */
2166 #define add_dynamic_entry(TAG, VAL) \
2167 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2169 if (bfd_link_executable (info
))
2171 if (! add_dynamic_entry (DT_DEBUG
, 0))
2175 if (htab
->root
.splt
->size
!= 0)
2177 if (! add_dynamic_entry (DT_PLTGOT
, 0)
2178 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
2179 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2180 || ! add_dynamic_entry (DT_JMPREL
, 0))
2186 if (! add_dynamic_entry (DT_RELA
, 0)
2187 || ! add_dynamic_entry (DT_RELASZ
, 0)
2188 || ! add_dynamic_entry (DT_RELAENT
,
2189 sizeof (Elf32_External_Rela
)))
2192 /* If any dynamic relocs apply to a read-only section,
2193 then we need a DT_TEXTREL entry. */
2194 if ((info
->flags
& DF_TEXTREL
) == 0)
2195 elf_link_hash_traverse (&htab
->root
, maybe_set_textrel
, info
);
2197 if ((info
->flags
& DF_TEXTREL
) != 0)
2199 if (! add_dynamic_entry (DT_TEXTREL
, 0))
2204 #undef add_dynamic_entry
2206 /* Allocate .rofixup section. */
2207 if (IS_FDPIC (output_bfd
))
2209 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2210 int rgot_weak_count
= 0;
2213 /* Look for deleted sections. */
2214 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2216 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2220 /* Count relocs that need .rofixup entires. */
2221 Elf_Internal_Rela
*internal_relocs
, *end
;
2222 internal_relocs
= elf_section_data (s
)->relocs
;
2223 if (internal_relocs
== NULL
)
2224 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2225 if (internal_relocs
!= NULL
)
2227 end
= internal_relocs
+ s
->reloc_count
;
2228 while (internal_relocs
< end
)
2230 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2231 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2232 unsigned long r_symndx
;
2233 struct elf_link_hash_entry
*h
;
2235 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2236 sym_hashes
= elf_sym_hashes (ibfd
);
2237 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2239 if (r_symndx
< symtab_hdr
->sh_info
)
2244 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2245 while (h
->root
.type
== bfd_link_hash_indirect
2246 || h
->root
.type
== bfd_link_hash_warning
)
2247 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2250 /* Don't generate entries for weak symbols. */
2251 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2253 if (!discarded_section (s
) && !((bfd_get_section_flags (ibfd
, s
) & SEC_ALLOC
) == 0))
2255 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2268 struct weak_symbol_list
*current
, *new_entry
;
2269 /* Is this symbol already in the list? */
2270 for (current
= list_start
; current
; current
= current
->next
)
2272 if (!strcmp (current
->name
, h
->root
.root
.string
))
2275 if (!current
&& !discarded_section (s
) && (bfd_get_section_flags (ibfd
, s
) & SEC_ALLOC
))
2277 /* Will this have an entry in the GOT. */
2278 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2280 /* Create a new entry. */
2281 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2284 new_entry
->name
= h
->root
.root
.string
;
2285 new_entry
->next
= NULL
;
2287 if (list_start
== NULL
)
2289 list_start
= new_entry
;
2290 list_end
= new_entry
;
2294 list_end
->next
= new_entry
;
2295 list_end
= new_entry
;
2297 /* Increase count of undefined weak symbols in the got. */
2313 list_end
= list_start
->next
;
2315 list_start
= list_end
;
2318 /* Size sections. */
2319 lm32fdpic_fixup32_section (info
)->size
2320 = (r32_count
+ (htab
->root
.sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2321 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2322 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2325 lm32fdpic_fixup32_section (info
)->contents
=
2326 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2327 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2335 /* Create dynamic sections when linking against a dynamic object. */
2338 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2340 struct elf_lm32_link_hash_table
*htab
;
2341 flagword flags
, pltflags
;
2343 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2344 int ptralign
= 2; /* 32bit */
2346 htab
= lm32_elf_hash_table (info
);
2350 /* Make sure we have a GOT - For the case where we have a dynamic object
2351 but none of the relocs in check_relocs */
2352 if (!_bfd_elf_create_got_section (abfd
, info
))
2354 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2356 if (! create_rofixup_section (abfd
, info
))
2360 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2361 .rel[a].bss sections. */
2362 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2363 | SEC_LINKER_CREATED
);
2366 pltflags
|= SEC_CODE
;
2367 if (bed
->plt_not_loaded
)
2368 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2369 if (bed
->plt_readonly
)
2370 pltflags
|= SEC_READONLY
;
2372 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2373 htab
->root
.splt
= s
;
2375 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
2378 if (bed
->want_plt_sym
)
2380 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2382 struct bfd_link_hash_entry
*bh
= NULL
;
2383 struct elf_link_hash_entry
*h
;
2385 if (! (_bfd_generic_link_add_one_symbol
2386 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2387 (bfd_vma
) 0, NULL
, FALSE
,
2388 get_elf_backend_data (abfd
)->collect
, &bh
)))
2390 h
= (struct elf_link_hash_entry
*) bh
;
2392 h
->type
= STT_OBJECT
;
2393 htab
->root
.hplt
= h
;
2395 if (bfd_link_pic (info
)
2396 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2400 s
= bfd_make_section_anyway_with_flags (abfd
,
2401 bed
->default_use_rela_p
2402 ? ".rela.plt" : ".rel.plt",
2403 flags
| SEC_READONLY
);
2404 htab
->root
.srelplt
= s
;
2406 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2409 if (htab
->root
.sgot
== NULL
2410 && !_bfd_elf_create_got_section (abfd
, info
))
2413 if (bed
->want_dynbss
)
2415 /* The .dynbss section is a place to put symbols which are defined
2416 by dynamic objects, are referenced by regular objects, and are
2417 not functions. We must allocate space for them in the process
2418 image and use a R_*_COPY reloc to tell the dynamic linker to
2419 initialize them at run time. The linker script puts the .dynbss
2420 section into the .bss section of the final image. */
2421 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2422 SEC_ALLOC
| SEC_LINKER_CREATED
);
2426 /* The .rel[a].bss section holds copy relocs. This section is not
2427 normally needed. We need to create it here, though, so that the
2428 linker will map it to an output section. We can't just create it
2429 only if we need it, because we will not know whether we need it
2430 until we have seen all the input files, and the first time the
2431 main linker code calls BFD after examining all the input files
2432 (size_dynamic_sections) the input sections have already been
2433 mapped to the output sections. If the section turns out not to
2434 be needed, we can discard it later. We will never need this
2435 section when generating a shared object, since they do not use
2437 if (! bfd_link_pic (info
))
2439 s
= bfd_make_section_anyway_with_flags (abfd
,
2440 (bed
->default_use_rela_p
2441 ? ".rela.bss" : ".rel.bss"),
2442 flags
| SEC_READONLY
);
2445 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2453 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2456 lm32_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
2457 struct elf_link_hash_entry
*dir
,
2458 struct elf_link_hash_entry
*ind
)
2460 struct elf_lm32_link_hash_entry
* edir
;
2461 struct elf_lm32_link_hash_entry
* eind
;
2463 edir
= (struct elf_lm32_link_hash_entry
*) dir
;
2464 eind
= (struct elf_lm32_link_hash_entry
*) ind
;
2466 if (eind
->dyn_relocs
!= NULL
)
2468 if (edir
->dyn_relocs
!= NULL
)
2470 struct elf_dyn_relocs
**pp
;
2471 struct elf_dyn_relocs
*p
;
2473 /* Add reloc counts against the indirect sym to the direct sym
2474 list. Merge any entries against the same section. */
2475 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
;)
2477 struct elf_dyn_relocs
*q
;
2479 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
2480 if (q
->sec
== p
->sec
)
2482 q
->pc_count
+= p
->pc_count
;
2483 q
->count
+= p
->count
;
2490 *pp
= edir
->dyn_relocs
;
2493 edir
->dyn_relocs
= eind
->dyn_relocs
;
2494 eind
->dyn_relocs
= NULL
;
2497 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
2501 lm32_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2503 if (!bfd_link_relocatable (info
))
2505 if (!bfd_elf_stack_segment_size (output_bfd
, info
,
2506 "__stacksize", DEFAULT_STACK_SIZE
))
2509 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2511 sec
->size
= info
->stacksize
>= 0 ? info
->stacksize
: 0;
2518 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2522 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2523 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2526 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
2529 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2530 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2533 /* Copy the stack size. */
2534 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2535 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2537 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2539 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2540 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2542 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2544 /* Rewrite the phdrs, since we're only called after they were first written. */
2545 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2546 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2547 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2548 elf_elfheader (obfd
)->e_phnum
) != 0)
2560 #define ELF_ARCH bfd_arch_lm32
2561 #define ELF_TARGET_ID LM32_ELF_DATA
2562 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2563 #define ELF_MAXPAGESIZE 0x1000
2565 #define TARGET_BIG_SYM lm32_elf32_vec
2566 #define TARGET_BIG_NAME "elf32-lm32"
2568 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2569 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2570 #define elf_info_to_howto lm32_info_to_howto_rela
2571 #define elf_info_to_howto_rel 0
2572 #define elf_backend_rela_normal 1
2573 #define elf_backend_object_p lm32_elf_object_p
2574 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2575 #define elf_backend_stack_align 8
2576 #define elf_backend_can_gc_sections 1
2577 #define elf_backend_can_refcount 1
2578 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2579 #define elf_backend_plt_readonly 1
2580 #define elf_backend_want_got_plt 1
2581 #define elf_backend_want_plt_sym 0
2582 #define elf_backend_got_header_size 12
2583 #define elf_backend_dtrel_excludes_plt 1
2584 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2585 #define elf_backend_check_relocs lm32_elf_check_relocs
2586 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2587 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2588 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2589 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2590 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2591 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2592 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2593 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2594 #define elf_backend_relocate_section lm32_elf_relocate_section
2596 #include "elf32-target.h"
2598 #undef ELF_MAXPAGESIZE
2599 #define ELF_MAXPAGESIZE 0x4000
2602 #undef TARGET_BIG_SYM
2603 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2604 #undef TARGET_BIG_NAME
2605 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2607 #define elf32_bed elf32_lm32fdpic_bed
2609 #undef elf_backend_always_size_sections
2610 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2611 #undef bfd_elf32_bfd_copy_private_bfd_data
2612 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2614 #include "elf32-target.h"