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)
999 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
1001 r = _bfd_final_link_relocate (howto,
1010 case R_LM32_GOTOFF_LO16:
1011 case R_LM32_GOTOFF_HI16:
1012 /* Relocation is offset from GOT. */
1013 BFD_ASSERT (sgot != NULL);
1014 relocation -= sgot->output_section->vma;
1015 /* Account for sign-extension. */
1016 if ((r_type == R_LM32_GOTOFF_HI16)
1017 && ((relocation + rel->r_addend) & 0x8000))
1018 rel->r_addend += 0x10000;
1019 r = _bfd_final_link_relocate (howto,
1029 if (IS_FDPIC (output_bfd))
1031 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1033 /* Only create .rofixup entries for relocs in loadable sections. */
1034 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1035 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1038 /* Check address to be modified is writable. */
1039 if (_lm32fdpic_osec_readonly_p (output_bfd,
1043 info->callbacks->warning
1045 _("cannot emit dynamic relocations in read-only section"),
1046 name, input_bfd, input_section, rel->r_offset);
1049 /* Create entry in .rofixup section. */
1050 _lm32fdpic_add_rofixup (output_bfd,
1051 lm32fdpic_fixup32_section (info),
1052 input_section->output_section->vma
1053 + input_section->output_offset
1061 r = _bfd_final_link_relocate (howto,
1072 if (r != bfd_reloc_ok)
1074 const char *msg = NULL;
1077 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1078 howto = bfd_reloc.howto;
1081 name = h->root.root.string;
1084 name = (bfd_elf_string_from_elf_section
1085 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1086 if (name == NULL || *name == '\0')
1087 name = bfd_section_name (input_bfd, sec);
1092 case bfd_reloc_overflow:
1094 && (h->root.type == bfd_link_hash_undefweak))
1096 (*info->callbacks->reloc_overflow)
1097 (info, (h ? &h->root : NULL), name, howto->name,
1098 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1101 case bfd_reloc_undefined:
1102 (*info->callbacks->undefined_symbol)
1103 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1106 case bfd_reloc_outofrange:
1107 msg = _("internal error: out of range error");
1110 case bfd_reloc_notsupported:
1111 msg = _("internal error: unsupported relocation error");
1114 case bfd_reloc_dangerous:
1115 msg = _("internal error: dangerous error");
1119 msg = _("internal error: unknown error");
1123 (*info->callbacks->warning) (info, msg, name, input_bfd,
1124 input_section, rel->r_offset);
1134 lm32_elf_gc_mark_hook (asection *sec,
1135 struct bfd_link_info *info,
1136 Elf_Internal_Rela *rel,
1137 struct elf_link_hash_entry *h,
1138 Elf_Internal_Sym *sym)
1141 switch (ELF32_R_TYPE (rel->r_info))
1143 case R_LM32_GNU_VTINHERIT:
1144 case R_LM32_GNU_VTENTRY:
1148 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1151 /* Look through the relocs for a section during the first phase. */
1154 lm32_elf_check_relocs (bfd *abfd,
1155 struct bfd_link_info *info,
1157 const Elf_Internal_Rela *relocs)
1159 Elf_Internal_Shdr *symtab_hdr;
1160 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1161 const Elf_Internal_Rela *rel;
1162 const Elf_Internal_Rela *rel_end;
1163 struct elf_lm32_link_hash_table *htab;
1166 if (bfd_link_relocatable (info))
1169 /* Don't do anything special with non-loaded, non-alloced sections.
1170 In particular, any relocs in such sections should not affect GOT
1171 and PLT reference counting (ie. we don't allow them to create GOT
1172 or PLT entries), there's no possibility or desire to optimize TLS
1173 relocs, and there's not much point in propagating relocs to shared
1174 libs that the dynamic linker won't relocate. */
1175 if ((sec->flags & SEC_ALLOC) == 0)
1178 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1179 sym_hashes = elf_sym_hashes (abfd);
1180 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1181 if (!elf_bad_symtab (abfd))
1182 sym_hashes_end -= symtab_hdr->sh_info;
1184 htab = lm32_elf_hash_table (info);
1188 dynobj = htab->root.dynobj;
1190 rel_end = relocs + sec->reloc_count;
1191 for (rel = relocs; rel < rel_end; rel++)
1194 struct elf_link_hash_entry *h;
1195 unsigned long r_symndx;
1197 r_symndx = ELF32_R_SYM (rel->r_info);
1198 r_type = ELF32_R_TYPE (rel->r_info);
1199 if (r_symndx < symtab_hdr->sh_info)
1203 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1204 while (h->root.type == bfd_link_hash_indirect
1205 || h->root.type == bfd_link_hash_warning)
1206 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1209 /* Some relocs require a global offset table. */
1210 if (htab->root.sgot == NULL)
1215 case R_LM32_GOTOFF_HI16:
1216 case R_LM32_GOTOFF_LO16:
1218 htab->root.dynobj = dynobj = abfd;
1219 if (!_bfd_elf_create_got_section (dynobj, info))
1225 /* Some relocs require a rofixup table. */
1226 if (IS_FDPIC (abfd))
1231 /* FDPIC requires a GOT if there is a .rofixup section
1232 (Normal ELF doesn't). */
1234 htab->root.dynobj = dynobj = abfd;
1235 if (!_bfd_elf_create_got_section (dynobj, info))
1237 /* Create .rofixup section */
1238 if (htab->sfixup32 == NULL)
1240 if (! create_rofixup_section (dynobj, info))
1245 case R_LM32_GOTOFF_HI16:
1246 case R_LM32_GOTOFF_LO16:
1247 /* Create .rofixup section. */
1248 if (htab->sfixup32 == NULL)
1251 htab->root.dynobj = dynobj = abfd;
1252 if (! create_rofixup_section (dynobj, info))
1263 h->got.refcount += 1;
1266 bfd_signed_vma *local_got_refcounts;
1268 /* This is a global offset table entry for a local symbol. */
1269 local_got_refcounts = elf_local_got_refcounts (abfd);
1270 if (local_got_refcounts == NULL)
1274 size = symtab_hdr->sh_info;
1275 size *= sizeof (bfd_signed_vma);
1276 local_got_refcounts = bfd_zalloc (abfd, size);
1277 if (local_got_refcounts == NULL)
1279 elf_local_got_refcounts (abfd) = local_got_refcounts;
1281 local_got_refcounts[r_symndx] += 1;
1285 /* This relocation describes the C++ object vtable hierarchy.
1286 Reconstruct it for later use during GC. */
1287 case R_LM32_GNU_VTINHERIT:
1288 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1292 /* This relocation describes which C++ vtable entries are actually
1293 used. Record for later use during GC. */
1294 case R_LM32_GNU_VTENTRY:
1295 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1305 /* Finish up the dynamic sections. */
1308 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1309 struct bfd_link_info *info)
1311 struct elf_lm32_link_hash_table *htab;
1316 htab = lm32_elf_hash_table (info);
1320 dynobj = htab->root.dynobj;
1322 sgot = htab->root.sgotplt;
1323 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1325 if (htab->root.dynamic_sections_created)
1328 Elf32_External_Dyn *dyncon, *dynconend;
1330 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1332 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1333 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1335 for (; dyncon < dynconend; dyncon++)
1337 Elf_Internal_Dyn dyn;
1340 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1348 s = htab->root.sgotplt;
1351 s = htab->root.srelplt;
1353 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1354 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1358 s = htab->root.srelplt;
1359 dyn.d_un.d_val = s->size;
1360 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1365 /* Fill in the first entry in the procedure linkage table. */
1366 splt = htab->root.splt;
1367 if (splt && splt->size > 0)
1369 if (bfd_link_pic (info))
1371 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1372 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1373 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1374 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1375 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1380 /* addr = .got + 4 */
1381 addr = sgot->output_section->vma + sgot->output_offset + 4;
1382 bfd_put_32 (output_bfd,
1383 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1385 bfd_put_32 (output_bfd,
1386 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1387 splt->contents + 4);
1388 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1389 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1390 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1393 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1398 /* Fill in the first three entries in the global offset table. */
1399 if (sgot && sgot->size > 0)
1402 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1404 bfd_put_32 (output_bfd,
1405 sdyn->output_section->vma + sdyn->output_offset,
1407 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1408 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1410 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1411 if (elf_section_data (sgot->output_section) != NULL)
1412 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1415 if (lm32fdpic_fixup32_section (info))
1417 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1418 bfd_vma got_value = hgot->root.u.def.value
1419 + hgot->root.u.def.section->output_section->vma
1420 + hgot->root.u.def.section->output_offset;
1421 struct bfd_link_hash_entry *hend;
1423 /* Last entry is pointer to GOT. */
1424 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1426 /* Check we wrote enough entries. */
1427 if (lm32fdpic_fixup32_section (info)->size
1428 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1431 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1433 (int64_t) (lm32fdpic_fixup32_section (info)->size / 4),
1434 lm32fdpic_fixup32_section (info)->reloc_count);
1438 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1439 FALSE, FALSE, TRUE);
1441 && (hend->type == bfd_link_hash_defined
1442 || hend->type == bfd_link_hash_defweak))
1445 lm32fdpic_fixup32_section (info)->output_section->vma
1446 + lm32fdpic_fixup32_section (info)->output_offset
1447 + lm32fdpic_fixup32_section (info)->size
1448 - hend->u.def.section->output_section->vma
1449 - hend->u.def.section->output_offset;
1450 BFD_ASSERT (hend->u.def.value == value);
1451 if (hend->u.def.value != value)
1454 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1455 PRId64 " != %" PRId64,
1456 (int64_t) hend->u.def.value, (int64_t) value);
1465 /* Finish up dynamic symbol handling. We set the contents of various
1466 dynamic sections here. */
1469 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1470 struct bfd_link_info *info,
1471 struct elf_link_hash_entry *h,
1472 Elf_Internal_Sym *sym)
1474 struct elf_lm32_link_hash_table *htab;
1477 htab = lm32_elf_hash_table (info);
1481 if (h->plt.offset != (bfd_vma) -1)
1489 Elf_Internal_Rela rela;
1491 /* This symbol has an entry in the procedure linkage table. Set
1493 BFD_ASSERT (h->dynindx != -1);
1495 splt = htab->root.splt;
1496 sgot = htab->root.sgotplt;
1497 srela = htab->root.srelplt;
1498 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1500 /* Get the index in the procedure linkage table which
1501 corresponds to this symbol. This is the index of this symbol
1502 in all the symbols for which we are making plt entries. The
1503 first entry in the procedure linkage table is reserved. */
1504 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1506 /* Get the offset into the .got table of the entry that
1507 corresponds to this function. Each .got entry is 4 bytes.
1508 The first three are reserved. */
1509 got_offset = (plt_index + 3) * 4;
1511 /* Fill in the entry in the procedure linkage table. */
1512 if (! bfd_link_pic (info))
1521 /* Fill in the entry in the global offset table. */
1522 bfd_put_32 (output_bfd,
1523 (splt->output_section->vma
1524 + splt->output_offset
1526 + 12), /* same offset */
1527 sgot->contents + got_offset);
1529 /* Fill in the entry in the .rela.plt section. */
1530 rela.r_offset = (sgot->output_section->vma
1531 + sgot->output_offset
1533 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1535 loc = srela->contents;
1536 loc += plt_index * sizeof (Elf32_External_Rela);
1537 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1539 if (!h->def_regular)
1541 /* Mark the symbol as undefined, rather than as defined in
1542 the .plt section. Leave the value alone. */
1543 sym->st_shndx = SHN_UNDEF;
1548 if (h->got.offset != (bfd_vma) -1)
1552 Elf_Internal_Rela rela;
1554 /* This symbol has an entry in the global offset table. Set it
1556 sgot = htab->root.sgot;
1557 srela = htab->root.srelgot;
1558 BFD_ASSERT (sgot != NULL && srela != NULL);
1560 rela.r_offset = (sgot->output_section->vma
1561 + sgot->output_offset
1562 + (h->got.offset &~ 1));
1564 /* If this is a -Bsymbolic link, and the symbol is defined
1565 locally, we just want to emit a RELATIVE reloc. Likewise if
1566 the symbol was forced to be local because of a version file.
1567 The entry in the global offset table will already have been
1568 initialized in the relocate_section function. */
1569 if (bfd_link_pic (info)
1575 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1576 rela.r_addend = (h->root.u.def.value
1577 + h->root.u.def.section->output_section->vma
1578 + h->root.u.def.section->output_offset);
1582 BFD_ASSERT ((h->got.offset & 1) == 0);
1583 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1584 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1588 loc = srela->contents;
1589 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1590 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1591 ++srela->reloc_count;
1597 Elf_Internal_Rela rela;
1599 /* This symbols needs a copy reloc. Set it up. */
1600 BFD_ASSERT (h->dynindx != -1
1601 && (h->root.type == bfd_link_hash_defined
1602 || h->root.type == bfd_link_hash_defweak));
1604 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1605 BFD_ASSERT (s != NULL);
1607 rela.r_offset = (h->root.u.def.value
1608 + h->root.u.def.section->output_section->vma
1609 + h->root.u.def.section->output_offset);
1610 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1613 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1614 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1618 /* Mark some specially defined symbols as absolute. */
1619 if (h == htab->root.hdynamic || h == htab->root.hgot)
1620 sym->st_shndx = SHN_ABS;
1625 static enum elf_reloc_type_class
1626 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1627 const asection *rel_sec ATTRIBUTE_UNUSED,
1628 const Elf_Internal_Rela *rela)
1630 switch ((int) ELF32_R_TYPE (rela->r_info))
1632 case R_LM32_RELATIVE: return reloc_class_relative;
1633 case R_LM32_JMP_SLOT: return reloc_class_plt;
1634 case R_LM32_COPY: return reloc_class_copy;
1635 default: return reloc_class_normal;
1639 /* Find dynamic relocs for H that apply to read-only sections. */
1642 readonly_dynrelocs (struct elf_link_hash_entry *h)
1644 struct elf_dyn_relocs *p;
1645 struct elf_lm32_link_hash_entry *eh = (struct elf_lm32_link_hash_entry *) h;
1647 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1649 asection *s = p->sec->output_section;
1651 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1657 /* Adjust a symbol defined by a dynamic object and referenced by a
1658 regular object. The current definition is in some section of the
1659 dynamic object, but we're not including those sections. We have to
1660 change the definition to something the rest of the link can
1664 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1665 struct elf_link_hash_entry *h)
1667 struct elf_lm32_link_hash_table *htab;
1671 dynobj = elf_hash_table (info)->dynobj;
1673 /* Make sure we know what is going on here. */
1674 BFD_ASSERT (dynobj != NULL
1679 && !h->def_regular)));
1681 /* If this is a function, put it in the procedure linkage table. We
1682 will fill in the contents of the procedure linkage table later,
1683 when we know the address of the .got section. */
1684 if (h->type == STT_FUNC
1687 if (! bfd_link_pic (info)
1690 && h->root.type != bfd_link_hash_undefweak
1691 && h->root.type != bfd_link_hash_undefined)
1693 /* This case can occur if we saw a PLT reloc in an input
1694 file, but the symbol was never referred to by a dynamic
1695 object. In such a case, we don't actually need to build
1696 a procedure linkage table, and we can just do a PCREL
1698 h->plt.offset = (bfd_vma) -1;
1705 h->plt.offset = (bfd_vma) -1;
1707 /* If this is a weak symbol, and there is a real definition, the
1708 processor independent code will have arranged for us to see the
1709 real definition first, and we can just use the same value. */
1710 if (h->is_weakalias)
1712 struct elf_link_hash_entry *def = weakdef (h);
1713 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1714 h->root.u.def.section = def->root.u.def.section;
1715 h->root.u.def.value = def->root.u.def.value;
1719 /* This is a reference to a symbol defined by a dynamic object which
1720 is not a function. */
1722 /* If we are creating a shared library, we must presume that the
1723 only references to the symbol are via the global offset table.
1724 For such cases we need not do anything here; the relocations will
1725 be handled correctly by relocate_section. */
1726 if (bfd_link_pic (info))
1729 /* If there are no references to this symbol that do not use the
1730 GOT, we don't need to generate a copy reloc. */
1731 if (!h->non_got_ref)
1734 /* If -z nocopyreloc was given, we won't generate them either. */
1735 if (0 && info->nocopyreloc)
1741 /* If we don't find any dynamic relocs in read-only sections, then
1742 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1743 if (0 && !readonly_dynrelocs (h))
1749 /* We must allocate the symbol in our .dynbss section, which will
1750 become part of the .bss section of the executable. There will be
1751 an entry for this symbol in the .dynsym section. The dynamic
1752 object will contain position independent code, so all references
1753 from the dynamic object to this symbol will go through the global
1754 offset table. The dynamic linker will use the .dynsym entry to
1755 determine the address it must put in the global offset table, so
1756 both the dynamic object and the regular object will refer to the
1757 same memory location for the variable. */
1759 htab = lm32_elf_hash_table (info);
1764 BFD_ASSERT (s != NULL);
1766 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1767 to copy the initial value out of the dynamic object and into the
1768 runtime process image. We need to remember the offset into the
1769 .rela.bss section we are going to use. */
1770 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1774 srel = htab->srelbss;
1775 BFD_ASSERT (srel != NULL);
1776 srel->size += sizeof (Elf32_External_Rela);
1780 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1783 /* Allocate space in .plt, .got and associated reloc sections for
1787 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1789 struct bfd_link_info *info;
1790 struct elf_lm32_link_hash_table *htab;
1791 struct elf_lm32_link_hash_entry *eh;
1792 struct elf_dyn_relocs *p;
1794 if (h->root.type == bfd_link_hash_indirect)
1797 info = (struct bfd_link_info *) inf;
1798 htab = lm32_elf_hash_table (info);
1802 eh = (struct elf_lm32_link_hash_entry *) h;
1804 if (htab->root.dynamic_sections_created
1805 && h->plt.refcount > 0)
1807 /* Make sure this symbol is output as a dynamic symbol.
1808 Undefined weak syms won't yet be marked as dynamic. */
1809 if (h->dynindx == -1
1810 && !h->forced_local)
1812 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1816 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1818 asection *s = htab->root.splt;
1820 /* If this is the first .plt entry, make room for the special
1823 s->size += PLT_ENTRY_SIZE;
1825 h->plt.offset = s->size;
1827 /* If this symbol is not defined in a regular file, and we are
1828 not generating a shared library, then set the symbol to this
1829 location in the .plt. This is required to make function
1830 pointers compare as equal between the normal executable and
1831 the shared library. */
1832 if (! bfd_link_pic (info)
1835 h->root.u.def.section = s;
1836 h->root.u.def.value = h->plt.offset;
1839 /* Make room for this entry. */
1840 s->size += PLT_ENTRY_SIZE;
1842 /* We also need to make an entry in the .got.plt section, which
1843 will be placed in the .got section by the linker script. */
1844 htab->root.sgotplt->size += 4;
1846 /* We also need to make an entry in the .rel.plt section. */
1847 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1851 h->plt.offset = (bfd_vma) -1;
1857 h->plt.offset = (bfd_vma) -1;
1861 if (h->got.refcount > 0)
1866 /* Make sure this symbol is output as a dynamic symbol.
1867 Undefined weak syms won't yet be marked as dynamic. */
1868 if (h->dynindx == -1
1869 && !h->forced_local)
1871 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1875 s = htab->root.sgot;
1877 h->got.offset = s->size;
1879 dyn = htab->root.dynamic_sections_created;
1880 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1881 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1884 h->got.offset = (bfd_vma) -1;
1886 if (eh->dyn_relocs == NULL)
1889 /* In the shared -Bsymbolic case, discard space allocated for
1890 dynamic pc-relative relocs against symbols which turn out to be
1891 defined in regular objects. For the normal shared case, discard
1892 space for pc-relative relocs that have become local due to symbol
1893 visibility changes. */
1895 if (bfd_link_pic (info))
1901 struct elf_dyn_relocs **pp;
1903 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1905 p->count -= p->pc_count;
1914 /* Also discard relocs on undefined weak syms with non-default
1916 if (eh->dyn_relocs != NULL
1917 && h->root.type == bfd_link_hash_undefweak)
1919 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1920 eh->dyn_relocs = NULL;
1922 /* Make sure undefined weak symbols are output as a dynamic
1924 else if (h->dynindx == -1
1925 && !h->forced_local)
1927 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1934 /* For the non-shared case, discard space for relocs against
1935 symbols which turn out to need copy relocs or are not
1941 || (htab->root.dynamic_sections_created
1942 && (h->root.type == bfd_link_hash_undefweak
1943 || h->root.type == bfd_link_hash_undefined))))
1945 /* Make sure this symbol is output as a dynamic symbol.
1946 Undefined weak syms won't yet be marked as dynamic. */
1947 if (h->dynindx == -1
1948 && !h->forced_local)
1950 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1954 /* If that succeeded, we know we'll be keeping all the
1956 if (h->dynindx != -1)
1960 eh->dyn_relocs = NULL;
1965 /* Finally, allocate space. */
1966 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1968 asection *sreloc = elf_section_data (p->sec)->sreloc;
1969 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1975 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1976 read-only sections. */
1979 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1983 if (h->root.type == bfd_link_hash_indirect)
1986 sec = readonly_dynrelocs (h);
1989 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1991 info->flags |= DF_TEXTREL;
1992 info->callbacks->minfo
1993 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1994 sec->owner, h->root.root.string, sec);
1996 /* Not an error, just cut short the traversal. */
2002 /* Set the sizes of the dynamic sections. */
2005 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2006 struct bfd_link_info *info)
2008 struct elf_lm32_link_hash_table *htab;
2014 htab = lm32_elf_hash_table (info);
2018 dynobj = htab->root.dynobj;
2019 BFD_ASSERT (dynobj != NULL);
2021 if (htab->root.dynamic_sections_created)
2023 /* Set the contents of the .interp section to the interpreter. */
2024 if (bfd_link_executable (info) && !info->nointerp)
2026 s = bfd_get_linker_section (dynobj, ".interp");
2027 BFD_ASSERT (s != NULL);
2028 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2029 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2033 /* Set up .got offsets for local syms, and space for local dynamic
2035 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2037 bfd_signed_vma *local_got;
2038 bfd_signed_vma *end_local_got;
2039 bfd_size_type locsymcount;
2040 Elf_Internal_Shdr *symtab_hdr;
2043 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2046 for (s = ibfd->sections; s != NULL; s = s->next)
2048 struct elf_dyn_relocs *p;
2050 for (p = ((struct elf_dyn_relocs *)
2051 elf_section_data (s)->local_dynrel);
2055 if (! bfd_is_abs_section (p->sec)
2056 && bfd_is_abs_section (p->sec->output_section))
2058 /* Input section has been discarded, either because
2059 it is a copy of a linkonce section or due to
2060 linker script /DISCARD/, so we'll be discarding
2063 else if (p->count != 0)
2065 srel = elf_section_data (p->sec)->sreloc;
2066 srel->size += p->count * sizeof (Elf32_External_Rela);
2067 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2068 info->flags |= DF_TEXTREL;
2073 local_got = elf_local_got_refcounts (ibfd);
2077 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2078 locsymcount = symtab_hdr->sh_info;
2079 end_local_got = local_got + locsymcount;
2080 s = htab->root.sgot;
2081 srel = htab->root.srelgot;
2082 for (; local_got < end_local_got; ++local_got)
2086 *local_got = s->size;
2088 if (bfd_link_pic (info))
2089 srel->size += sizeof (Elf32_External_Rela);
2092 *local_got = (bfd_vma) -1;
2096 /* Allocate global sym .plt and .got entries, and space for global
2097 sym dynamic relocs. */
2098 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2100 /* We now have determined the sizes of the various dynamic sections.
2101 Allocate memory for them. */
2103 for (s = dynobj->sections; s != NULL; s = s->next)
2105 if ((s->flags & SEC_LINKER_CREATED) == 0)
2108 if (s == htab->root.splt
2109 || s == htab->root.sgot
2110 || s == htab->root.sgotplt
2111 || s == htab->sdynbss)
2113 /* Strip this section if we don't need it; see the
2116 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2118 if (s->size != 0 && s != htab->root.srelplt)
2121 /* We use the reloc_count field as a counter if we need
2122 to copy relocs into the output file. */
2126 /* It's not one of our sections, so don't allocate space. */
2131 /* If we don't need this section, strip it from the
2132 output file. This is mostly to handle .rela.bss and
2133 .rela.plt. We must create both sections in
2134 create_dynamic_sections, because they must be created
2135 before the linker maps input sections to output
2136 sections. The linker does that before
2137 adjust_dynamic_symbol is called, and it is that
2138 function which decides whether anything needs to go
2139 into these sections. */
2140 s->flags |= SEC_EXCLUDE;
2144 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2147 /* Allocate memory for the section contents. We use bfd_zalloc
2148 here in case unused entries are not reclaimed before the
2149 section's contents are written out. This should not happen,
2150 but this way if it does, we get a R_LM32_NONE reloc instead
2152 s->contents = bfd_zalloc (dynobj, s->size);
2153 if (s->contents == NULL)
2157 if (htab->root.dynamic_sections_created)
2159 /* Add some entries to the .dynamic section. We fill in the
2160 values later, in lm32_elf_finish_dynamic_sections, but we
2161 must add the entries now so that we get the correct size for
2162 the .dynamic section. The DT_DEBUG entry is filled in by the
2163 dynamic linker and used by the debugger. */
2164 #define add_dynamic_entry(TAG, VAL) \
2165 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2167 if (bfd_link_executable (info))
2169 if (! add_dynamic_entry (DT_DEBUG, 0))
2173 if (htab->root.splt->size != 0)
2175 if (! add_dynamic_entry (DT_PLTGOT, 0)
2176 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2177 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2178 || ! add_dynamic_entry (DT_JMPREL, 0))
2184 if (! add_dynamic_entry (DT_RELA, 0)
2185 || ! add_dynamic_entry (DT_RELASZ, 0)
2186 || ! add_dynamic_entry (DT_RELAENT,
2187 sizeof (Elf32_External_Rela)))
2190 /* If any dynamic relocs apply to a read-only section,
2191 then we need a DT_TEXTREL entry. */
2192 if ((info->flags & DF_TEXTREL) == 0)
2193 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2195 if ((info->flags & DF_TEXTREL) != 0)
2197 if (! add_dynamic_entry (DT_TEXTREL, 0))
2202 #undef add_dynamic_entry
2204 /* Allocate .rofixup section. */
2205 if (IS_FDPIC (output_bfd))
2207 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2208 int rgot_weak_count = 0;
2211 /* Look for deleted sections. */
2212 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2214 for (s = ibfd->sections; s != NULL; s = s->next)
2218 /* Count relocs that need .rofixup entires. */
2219 Elf_Internal_Rela *internal_relocs, *end;
2220 internal_relocs = elf_section_data (s)->relocs;
2221 if (internal_relocs == NULL)
2222 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2223 if (internal_relocs != NULL)
2225 end = internal_relocs + s->reloc_count;
2226 while (internal_relocs < end)
2228 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2229 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2230 unsigned long r_symndx;
2231 struct elf_link_hash_entry *h;
2233 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2234 sym_hashes = elf_sym_hashes (ibfd);
2235 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2237 if (r_symndx < symtab_hdr->sh_info)
2242 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2243 while (h->root.type == bfd_link_hash_indirect
2244 || h->root.type == bfd_link_hash_warning)
2245 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2248 /* Don't generate entries for weak symbols. */
2249 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2251 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2253 switch (ELF32_R_TYPE (internal_relocs->r_info))
2266 struct weak_symbol_list *current, *new_entry;
2267 /* Is this symbol already in the list? */
2268 for (current = list_start; current; current = current->next)
2270 if (!strcmp (current->name, h->root.root.string))
2273 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2275 /* Will this have an entry in the GOT. */
2276 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2278 /* Create a new entry. */
2279 new_entry = malloc (sizeof (struct weak_symbol_list));
2282 new_entry->name = h->root.root.string;
2283 new_entry->next = NULL;
2285 if (list_start == NULL)
2287 list_start = new_entry;
2288 list_end = new_entry;
2292 list_end->next = new_entry;
2293 list_end = new_entry;
2295 /* Increase count of undefined weak symbols in the got. */
2311 list_end = list_start->next;
2313 list_start = list_end;
2316 /* Size sections. */
2317 lm32fdpic_fixup32_section (info)->size
2318 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2319 if (lm32fdpic_fixup32_section (info)->size == 0)
2320 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2323 lm32fdpic_fixup32_section (info)->contents =
2324 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2325 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2333 /* Create dynamic sections when linking against a dynamic object. */
2336 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2338 struct elf_lm32_link_hash_table *htab;
2339 flagword flags, pltflags;
2341 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2342 int ptralign = 2; /* 32bit */
2344 htab = lm32_elf_hash_table (info);
2348 /* Make sure we have a GOT - For the case where we have a dynamic object
2349 but none of the relocs in check_relocs */
2350 if (!_bfd_elf_create_got_section (abfd, info))
2352 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2354 if (! create_rofixup_section (abfd, info))
2358 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2359 .rel[a].bss sections. */
2360 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2361 | SEC_LINKER_CREATED);
2364 pltflags |= SEC_CODE;
2365 if (bed->plt_not_loaded)
2366 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2367 if (bed->plt_readonly)
2368 pltflags |= SEC_READONLY;
2370 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2371 htab->root.splt = s;
2373 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2376 if (bed->want_plt_sym)
2378 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2380 struct bfd_link_hash_entry *bh = NULL;
2381 struct elf_link_hash_entry *h;
2383 if (! (_bfd_generic_link_add_one_symbol
2384 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2385 (bfd_vma) 0, NULL, FALSE,
2386 get_elf_backend_data (abfd)->collect, &bh)))
2388 h = (struct elf_link_hash_entry *) bh;
2390 h->type = STT_OBJECT;
2391 htab->root.hplt = h;
2393 if (bfd_link_pic (info)
2394 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2398 s = bfd_make_section_anyway_with_flags (abfd,
2399 bed->default_use_rela_p
2400 ? ".rela.plt" : ".rel.plt",
2401 flags | SEC_READONLY);
2402 htab->root.srelplt = s;
2404 || ! bfd_set_section_alignment (abfd, s, ptralign))
2407 if (htab->root.sgot == NULL
2408 && !_bfd_elf_create_got_section (abfd, info))
2411 if (bed->want_dynbss)
2413 /* The .dynbss section is a place to put symbols which are defined
2414 by dynamic objects, are referenced by regular objects, and are
2415 not functions. We must allocate space for them in the process
2416 image and use a R_*_COPY reloc to tell the dynamic linker to
2417 initialize them at run time. The linker script puts the .dynbss
2418 section into the .bss section of the final image. */
2419 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2420 SEC_ALLOC | SEC_LINKER_CREATED);
2424 /* The .rel[a].bss section holds copy relocs. This section is not
2425 normally needed. We need to create it here, though, so that the
2426 linker will map it to an output section. We can't just create it
2427 only if we need it, because we will not know whether we need it
2428 until we have seen all the input files, and the first time the
2429 main linker code calls BFD after examining all the input files
2430 (size_dynamic_sections) the input sections have already been
2431 mapped to the output sections. If the section turns out not to
2432 be needed, we can discard it later. We will never need this
2433 section when generating a shared object, since they do not use
2435 if (! bfd_link_pic (info))
2437 s = bfd_make_section_anyway_with_flags (abfd,
2438 (bed->default_use_rela_p
2439 ? ".rela.bss" : ".rel.bss"),
2440 flags | SEC_READONLY);
2443 || ! bfd_set_section_alignment (abfd, s, ptralign))
2451 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2454 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2455 struct elf_link_hash_entry *dir,
2456 struct elf_link_hash_entry *ind)
2458 struct elf_lm32_link_hash_entry * edir;
2459 struct elf_lm32_link_hash_entry * eind;
2461 edir = (struct elf_lm32_link_hash_entry *) dir;
2462 eind = (struct elf_lm32_link_hash_entry *) ind;
2464 if (eind->dyn_relocs != NULL)
2466 if (edir->dyn_relocs != NULL)
2468 struct elf_dyn_relocs **pp;
2469 struct elf_dyn_relocs *p;
2471 /* Add reloc counts against the indirect sym to the direct sym
2472 list. Merge any entries against the same section. */
2473 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2475 struct elf_dyn_relocs *q;
2477 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2478 if (q->sec == p->sec)
2480 q->pc_count += p->pc_count;
2481 q->count += p->count;
2488 *pp = edir->dyn_relocs;
2491 edir->dyn_relocs = eind->dyn_relocs;
2492 eind->dyn_relocs = NULL;
2495 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2499 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2501 if (!bfd_link_relocatable (info))
2503 if (!bfd_elf_stack_segment_size (output_bfd, info,
2504 "__stacksize", DEFAULT_STACK_SIZE))
2507 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2509 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2516 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2520 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2521 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2524 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2527 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2528 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2531 /* Copy the stack size. */
2532 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2533 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2535 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2537 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2538 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2540 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2542 /* Rewrite the phdrs, since we're only called after they were first written. */
2543 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2544 ->s->sizeof_ehdr, SEEK_SET) != 0
2545 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2546 elf_elfheader (obfd)->e_phnum) != 0)
2558 #define ELF_ARCH bfd_arch_lm32
2559 #define ELF_TARGET_ID LM32_ELF_DATA
2560 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2561 #define ELF_MAXPAGESIZE 0x1000
2563 #define TARGET_BIG_SYM lm32_elf32_vec
2564 #define TARGET_BIG_NAME "elf32-lm32"
2566 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2567 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2568 #define elf_info_to_howto lm32_info_to_howto_rela
2569 #define elf_info_to_howto_rel 0
2570 #define elf_backend_rela_normal 1
2571 #define elf_backend_object_p lm32_elf_object_p
2572 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2573 #define elf_backend_stack_align 8
2574 #define elf_backend_can_gc_sections 1
2575 #define elf_backend_can_refcount 1
2576 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2577 #define elf_backend_plt_readonly 1
2578 #define elf_backend_want_got_plt 1
2579 #define elf_backend_want_plt_sym 0
2580 #define elf_backend_got_header_size 12
2581 #define elf_backend_dtrel_excludes_plt 1
2582 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2583 #define elf_backend_check_relocs lm32_elf_check_relocs
2584 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2585 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2586 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2587 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2588 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2589 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2590 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2591 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2592 #define elf_backend_relocate_section lm32_elf_relocate_section
2594 #include "elf32-target.h"
2596 #undef ELF_MAXPAGESIZE
2597 #define ELF_MAXPAGESIZE 0x4000
2600 #undef TARGET_BIG_SYM
2601 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2602 #undef TARGET_BIG_NAME
2603 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2605 #define elf32_bed elf32_lm32fdpic_bed
2607 #undef elf_backend_always_size_sections
2608 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2609 #undef bfd_elf32_bfd_copy_private_bfd_data
2610 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2612 #include "elf32-target.h"