1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2017 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 /* The linker needs to keep track of the number of relocs that it
54 decides to copy as dynamic relocs in check_relocs for each symbol.
55 This is so that it can later discard them if they are found to be
56 unnecessary. We store the information in a field extending the
57 regular ELF linker hash table. */
59 struct elf_lm32_dyn_relocs
61 struct elf_lm32_dyn_relocs *next;
63 /* The input section of the reloc. */
66 /* Total number of relocs copied for the input section. */
69 /* Number of pc-relative relocs copied for the input section. */
70 bfd_size_type pc_count;
73 /* lm32 ELF linker hash entry. */
75 struct elf_lm32_link_hash_entry
77 struct elf_link_hash_entry root;
79 /* Track dynamic relocs copied for this symbol. */
80 struct elf_lm32_dyn_relocs *dyn_relocs;
83 /* lm32 ELF linker hash table. */
85 struct elf_lm32_link_hash_table
87 struct elf_link_hash_table root;
89 /* Short-cuts to get to dynamic linker sections. */
97 /* Get the lm32 ELF linker hash table from a link_info structure. */
99 #define lm32_elf_hash_table(p) \
100 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
101 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
103 #define lm32fdpic_got_section(info) \
104 (lm32_elf_hash_table (info)->root.sgot)
105 #define lm32fdpic_gotrel_section(info) \
106 (lm32_elf_hash_table (info)->root.srelgot)
107 #define lm32fdpic_fixup32_section(info) \
108 (lm32_elf_hash_table (info)->sfixup32)
110 struct weak_symbol_list
113 struct weak_symbol_list *next;
116 /* Create an entry in an lm32 ELF linker hash table. */
118 static struct bfd_hash_entry *
119 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
120 struct bfd_hash_table *table,
123 struct elf_lm32_link_hash_entry *ret =
124 (struct elf_lm32_link_hash_entry *) entry;
126 /* Allocate the structure if it has not already been allocated by a
129 ret = bfd_hash_allocate (table,
130 sizeof (struct elf_lm32_link_hash_entry));
134 /* Call the allocation method of the superclass. */
135 ret = ((struct elf_lm32_link_hash_entry *)
136 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
140 struct elf_lm32_link_hash_entry *eh;
142 eh = (struct elf_lm32_link_hash_entry *) ret;
143 eh->dyn_relocs = NULL;
146 return (struct bfd_hash_entry *) ret;
149 /* Create an lm32 ELF linker hash table. */
151 static struct bfd_link_hash_table *
152 lm32_elf_link_hash_table_create (bfd *abfd)
154 struct elf_lm32_link_hash_table *ret;
155 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
157 ret = bfd_zmalloc (amt);
161 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
162 lm32_elf_link_hash_newfunc,
163 sizeof (struct elf_lm32_link_hash_entry),
170 return &ret->root.root;
173 /* Add a fixup to the ROFIXUP section. */
176 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
178 bfd_vma fixup_offset;
180 if (rofixup->flags & SEC_EXCLUDE)
183 fixup_offset = rofixup->reloc_count * 4;
184 if (rofixup->contents)
186 BFD_ASSERT (fixup_offset < rofixup->size);
187 if (fixup_offset < rofixup->size)
188 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
190 rofixup->reloc_count++;
195 /* Create .rofixup sections in DYNOBJ, and set up
196 shortcuts to them in our hash table. */
199 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
201 struct elf_lm32_link_hash_table *htab;
202 htab = lm32_elf_hash_table (info);
207 /* Fixup section for R_LM32_32 relocs. */
208 lm32fdpic_fixup32_section (info)
209 = bfd_make_section_anyway_with_flags (dynobj,
217 if (lm32fdpic_fixup32_section (info) == NULL
218 || ! bfd_set_section_alignment (dynobj,
219 lm32fdpic_fixup32_section (info), 2))
225 static reloc_howto_type lm32_elf_howto_table [] =
227 /* This reloc does nothing. */
228 HOWTO (R_LM32_NONE, /* type */
230 3, /* size (0 = byte, 1 = short, 2 = long) */
232 FALSE, /* pc_relative */
234 complain_overflow_dont, /* complain_on_overflow */
235 bfd_elf_generic_reloc, /* special_function */
236 "R_LM32_NONE", /* name */
237 FALSE, /* partial_inplace */
240 FALSE), /* pcrel_offset */
242 /* An 8 bit absolute relocation. */
243 HOWTO (R_LM32_8, /* type */
245 0, /* size (0 = byte, 1 = short, 2 = long) */
247 FALSE, /* pc_relative */
249 complain_overflow_bitfield,/* complain_on_overflow */
250 bfd_elf_generic_reloc, /* special_function */
251 "R_LM32_8", /* name */
252 FALSE, /* partial_inplace */
255 FALSE), /* pcrel_offset */
257 /* A 16 bit absolute relocation. */
258 HOWTO (R_LM32_16, /* type */
260 1, /* size (0 = byte, 1 = short, 2 = long) */
262 FALSE, /* pc_relative */
264 complain_overflow_bitfield,/* complain_on_overflow */
265 bfd_elf_generic_reloc, /* special_function */
266 "R_LM32_16", /* name */
267 FALSE, /* partial_inplace */
269 0xffff, /* dst_mask */
270 FALSE), /* pcrel_offset */
272 /* A 32 bit absolute relocation. */
273 HOWTO (R_LM32_32, /* type */
275 2, /* size (0 = byte, 1 = short, 2 = long) */
277 FALSE, /* pc_relative */
279 complain_overflow_bitfield,/* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_LM32_32", /* name */
282 FALSE, /* partial_inplace */
284 0xffffffff, /* dst_mask */
285 FALSE), /* pcrel_offset */
287 HOWTO (R_LM32_HI16, /* type */
289 2, /* size (0 = byte, 1 = short, 2 = long) */
291 FALSE, /* pc_relative */
293 complain_overflow_bitfield,/* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_LM32_HI16", /* name */
296 FALSE, /* partial_inplace */
298 0xffff, /* dst_mask */
299 FALSE), /* pcrel_offset */
301 HOWTO (R_LM32_LO16, /* type */
303 2, /* size (0 = byte, 1 = short, 2 = long) */
305 FALSE, /* pc_relative */
307 complain_overflow_dont, /* complain_on_overflow */
308 bfd_elf_generic_reloc, /* special_function */
309 "R_LM32_LO16", /* name */
310 FALSE, /* partial_inplace */
312 0xffff, /* dst_mask */
313 FALSE), /* pcrel_offset */
315 HOWTO (R_LM32_GPREL16, /* type */
317 2, /* size (0 = byte, 1 = short, 2 = long) */
319 FALSE, /* pc_relative */
321 complain_overflow_dont, /* complain_on_overflow */
322 lm32_elf_gprel_reloc, /* special_function */
323 "R_LM32_GPREL16", /* name */
324 FALSE, /* partial_inplace */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
329 HOWTO (R_LM32_CALL, /* type */
331 2, /* size (0 = byte, 1 = short, 2 = long) */
333 TRUE, /* pc_relative */
335 complain_overflow_signed, /* complain_on_overflow */
336 bfd_elf_generic_reloc, /* special_function */
337 "R_LM32_CALL", /* name */
338 FALSE, /* partial_inplace */
340 0x3ffffff, /* dst_mask */
341 TRUE), /* pcrel_offset */
343 HOWTO (R_LM32_BRANCH, /* type */
345 2, /* size (0 = byte, 1 = short, 2 = long) */
347 TRUE, /* pc_relative */
349 complain_overflow_signed, /* complain_on_overflow */
350 bfd_elf_generic_reloc, /* special_function */
351 "R_LM32_BRANCH", /* name */
352 FALSE, /* partial_inplace */
354 0xffff, /* dst_mask */
355 TRUE), /* pcrel_offset */
357 /* GNU extension to record C++ vtable hierarchy. */
358 HOWTO (R_LM32_GNU_VTINHERIT, /* type */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
362 FALSE, /* pc_relative */
364 complain_overflow_dont, /* complain_on_overflow */
365 NULL, /* special_function */
366 "R_LM32_GNU_VTINHERIT", /* name */
367 FALSE, /* partial_inplace */
370 FALSE), /* pcrel_offset */
372 /* GNU extension to record C++ vtable member usage. */
373 HOWTO (R_LM32_GNU_VTENTRY, /* type */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
377 FALSE, /* pc_relative */
379 complain_overflow_dont, /* complain_on_overflow */
380 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
381 "R_LM32_GNU_VTENTRY", /* name */
382 FALSE, /* partial_inplace */
385 FALSE), /* pcrel_offset */
387 HOWTO (R_LM32_16_GOT, /* type */
389 2, /* size (0 = byte, 1 = short, 2 = long) */
391 FALSE, /* pc_relative */
393 complain_overflow_signed, /* complain_on_overflow */
394 bfd_elf_generic_reloc, /* special_function */
395 "R_LM32_16_GOT", /* name */
396 FALSE, /* partial_inplace */
398 0xffff, /* dst_mask */
399 FALSE), /* pcrel_offset */
401 HOWTO (R_LM32_GOTOFF_HI16, /* type */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
405 FALSE, /* pc_relative */
407 complain_overflow_dont, /* complain_on_overflow */
408 bfd_elf_generic_reloc, /* special_function */
409 "R_LM32_GOTOFF_HI16", /* name */
410 FALSE, /* partial_inplace */
411 0xffff, /* src_mask */
412 0xffff, /* dst_mask */
413 FALSE), /* pcrel_offset */
415 HOWTO (R_LM32_GOTOFF_LO16, /* type */
417 2, /* size (0 = byte, 1 = short, 2 = long) */
419 FALSE, /* pc_relative */
421 complain_overflow_dont, /* complain_on_overflow */
422 bfd_elf_generic_reloc, /* special_function */
423 "R_LM32_GOTOFF_LO16", /* name */
424 FALSE, /* partial_inplace */
425 0xffff, /* src_mask */
426 0xffff, /* dst_mask */
427 FALSE), /* pcrel_offset */
429 HOWTO (R_LM32_COPY, /* type */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
433 FALSE, /* pc_relative */
435 complain_overflow_bitfield, /* complain_on_overflow */
436 bfd_elf_generic_reloc, /* special_function */
437 "R_LM32_COPY", /* name */
438 FALSE, /* partial_inplace */
439 0xffffffff, /* src_mask */
440 0xffffffff, /* dst_mask */
441 FALSE), /* pcrel_offset */
443 HOWTO (R_LM32_GLOB_DAT, /* type */
445 2, /* size (0 = byte, 1 = short, 2 = long) */
447 FALSE, /* pc_relative */
449 complain_overflow_bitfield, /* complain_on_overflow */
450 bfd_elf_generic_reloc, /* special_function */
451 "R_LM32_GLOB_DAT", /* name */
452 FALSE, /* partial_inplace */
453 0xffffffff, /* src_mask */
454 0xffffffff, /* dst_mask */
455 FALSE), /* pcrel_offset */
457 HOWTO (R_LM32_JMP_SLOT, /* type */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
461 FALSE, /* pc_relative */
463 complain_overflow_bitfield, /* complain_on_overflow */
464 bfd_elf_generic_reloc, /* special_function */
465 "R_LM32_JMP_SLOT", /* name */
466 FALSE, /* partial_inplace */
467 0xffffffff, /* src_mask */
468 0xffffffff, /* dst_mask */
469 FALSE), /* pcrel_offset */
471 HOWTO (R_LM32_RELATIVE, /* type */
473 2, /* size (0 = byte, 1 = short, 2 = long) */
475 FALSE, /* pc_relative */
477 complain_overflow_bitfield, /* complain_on_overflow */
478 bfd_elf_generic_reloc, /* special_function */
479 "R_LM32_RELATIVE", /* name */
480 FALSE, /* partial_inplace */
481 0xffffffff, /* src_mask */
482 0xffffffff, /* dst_mask */
483 FALSE), /* pcrel_offset */
487 /* Map BFD reloc types to lm32 ELF reloc types. */
489 struct lm32_reloc_map
491 bfd_reloc_code_real_type bfd_reloc_val;
492 unsigned char elf_reloc_val;
495 static const struct lm32_reloc_map lm32_reloc_map[] =
497 { BFD_RELOC_NONE, R_LM32_NONE },
498 { BFD_RELOC_8, R_LM32_8 },
499 { BFD_RELOC_16, R_LM32_16 },
500 { BFD_RELOC_32, R_LM32_32 },
501 { BFD_RELOC_HI16, R_LM32_HI16 },
502 { BFD_RELOC_LO16, R_LM32_LO16 },
503 { BFD_RELOC_GPREL16, R_LM32_GPREL16 },
504 { BFD_RELOC_LM32_CALL, R_LM32_CALL },
505 { BFD_RELOC_LM32_BRANCH, R_LM32_BRANCH },
506 { BFD_RELOC_VTABLE_INHERIT, R_LM32_GNU_VTINHERIT },
507 { BFD_RELOC_VTABLE_ENTRY, R_LM32_GNU_VTENTRY },
508 { BFD_RELOC_LM32_16_GOT, R_LM32_16_GOT },
509 { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
510 { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
511 { BFD_RELOC_LM32_COPY, R_LM32_COPY },
512 { BFD_RELOC_LM32_GLOB_DAT, R_LM32_GLOB_DAT },
513 { BFD_RELOC_LM32_JMP_SLOT, R_LM32_JMP_SLOT },
514 { BFD_RELOC_LM32_RELATIVE, R_LM32_RELATIVE },
517 static reloc_howto_type *
518 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
519 bfd_reloc_code_real_type code)
523 for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
524 if (lm32_reloc_map[i].bfd_reloc_val == code)
525 return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
529 static reloc_howto_type *
530 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
536 i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
538 if (lm32_elf_howto_table[i].name != NULL
539 && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
540 return &lm32_elf_howto_table[i];
546 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
549 lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
551 Elf_Internal_Rela *dst)
555 r_type = ELF32_R_TYPE (dst->r_info);
556 if (r_type >= (unsigned int) R_LM32_max)
558 /* xgettext:c-format */
559 _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type);
562 cache_ptr->howto = &lm32_elf_howto_table[r_type];
565 /* Set the right machine number for an Lattice Mico32 ELF file. */
568 lm32_elf_object_p (bfd *abfd)
570 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
573 /* Set machine type flags just before file is written out. */
576 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
578 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
579 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
580 switch (bfd_get_mach (abfd))
583 elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
590 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
591 dangerous relocation. */
594 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
600 /* If we've already figured out what GP will be, just return it. */
601 *pgp = _bfd_get_gp_value (output_bfd);
605 count = bfd_get_symcount (output_bfd);
606 sym = bfd_get_outsymbols (output_bfd);
608 /* The linker script will have created a symbol named `_gp' with the
609 appropriate value. */
614 for (i = 0; i < count; i++, sym++)
618 name = bfd_asymbol_name (*sym);
619 if (*name == '_' && strcmp (name, "_gp") == 0)
621 *pgp = bfd_asymbol_value (*sym);
622 _bfd_set_gp_value (output_bfd, *pgp);
630 /* Only get the error once. */
632 _bfd_set_gp_value (output_bfd, *pgp);
639 /* We have to figure out the gp value, so that we can adjust the
640 symbol value correctly. We look up the symbol _gp in the output
641 BFD. If we can't find it, we're stuck. We cache it in the ELF
642 target data. We don't need to adjust the symbol value for an
643 external symbol if we are producing relocatable output. */
645 static bfd_reloc_status_type
646 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
647 char **error_message, bfd_vma *pgp)
649 if (bfd_is_und_section (symbol->section) && !relocatable)
652 return bfd_reloc_undefined;
655 *pgp = _bfd_get_gp_value (output_bfd);
656 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
660 /* Make up a value. */
661 *pgp = symbol->section->output_section->vma + 0x4000;
662 _bfd_set_gp_value (output_bfd, *pgp);
664 else if (!lm32_elf_assign_gp (output_bfd, pgp))
668 _("global pointer relative relocation when _gp not defined");
669 return bfd_reloc_dangerous;
676 static bfd_reloc_status_type
677 lm32_elf_do_gprel_relocate (bfd *abfd,
678 reloc_howto_type *howto,
679 asection *input_section ATTRIBUTE_UNUSED,
682 bfd_vma symbol_value,
685 return _bfd_final_link_relocate (howto, abfd, input_section,
686 data, offset, symbol_value, addend);
689 static bfd_reloc_status_type
690 lm32_elf_gprel_reloc (bfd *abfd,
691 arelent *reloc_entry,
694 asection *input_section,
700 bfd_reloc_status_type r;
702 if (output_bfd != (bfd *) NULL
703 && (symbol->flags & BSF_SECTION_SYM) == 0
704 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
706 reloc_entry->address += input_section->output_offset;
710 if (output_bfd != NULL)
713 relocation = symbol->value
714 + symbol->section->output_section->vma + symbol->section->output_offset;
717 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
719 relocation = relocation + reloc_entry->addend - gp;
720 reloc_entry->addend = 0;
721 if ((signed) relocation < -32768 || (signed) relocation > 32767)
723 *msg = _("global pointer relative address out of range");
724 r = bfd_reloc_outofrange;
728 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
730 data, reloc_entry->address,
731 relocation, reloc_entry->addend);
738 /* Find the segment number in which OSEC, and output section, is
742 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
744 struct elf_segment_map *m;
745 Elf_Internal_Phdr *p;
747 /* Find the segment that contains the output_section. */
748 for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr;
754 for (i = m->count - 1; i >= 0; i--)
755 if (m->sections[i] == osec)
762 return p - elf_tdata (output_bfd)->phdr;
765 /* Determine if an output section is read-only. */
767 inline static bfd_boolean
768 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
770 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
772 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
775 /* Relocate a section */
778 lm32_elf_relocate_section (bfd *output_bfd,
779 struct bfd_link_info *info,
781 asection *input_section,
783 Elf_Internal_Rela *relocs,
784 Elf_Internal_Sym *local_syms,
785 asection **local_sections)
787 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
788 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
789 Elf_Internal_Rela *rel, *relend;
790 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
791 bfd_vma *local_got_offsets;
797 local_got_offsets = elf_local_got_offsets (input_bfd);
799 sgot = htab->root.sgot;
801 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
802 sym_hashes = elf_sym_hashes (input_bfd);
805 relend = relocs + input_section->reloc_count;
806 for (; rel < relend; rel++)
808 reloc_howto_type *howto;
810 unsigned long r_symndx;
811 Elf_Internal_Sym *sym;
813 struct elf_link_hash_entry *h;
816 bfd_reloc_status_type r;
817 const char *name = NULL;
819 r_symndx = ELF32_R_SYM (rel->r_info);
820 r_type = ELF32_R_TYPE (rel->r_info);
822 if (r_type == R_LM32_GNU_VTENTRY
823 || r_type == R_LM32_GNU_VTINHERIT )
830 howto = lm32_elf_howto_table + r_type;
832 if (r_symndx < symtab_hdr->sh_info)
834 /* It's a local symbol. */
835 sym = local_syms + r_symndx;
836 sec = local_sections[r_symndx];
837 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
838 name = bfd_elf_string_from_elf_section
839 (input_bfd, symtab_hdr->sh_link, sym->st_name);
840 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
844 /* It's a global symbol. */
845 bfd_boolean unresolved_reloc;
846 bfd_boolean warned, ignored;
848 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
849 r_symndx, symtab_hdr, sym_hashes,
851 unresolved_reloc, warned, ignored);
852 name = h->root.root.string;
855 if (sec != NULL && discarded_section (sec))
856 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
857 rel, 1, relend, howto, 0, contents);
859 if (bfd_link_relocatable (info))
861 /* This is a relocatable link. We don't have to change
862 anything, unless the reloc is against a section symbol,
863 in which case we have to adjust according to where the
864 section symbol winds up in the output section. */
865 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
868 /* If partial_inplace, we need to store any additional addend
869 back in the section. */
870 if (! howto->partial_inplace)
873 /* Shouldn't reach here. */
882 if (!lm32_elf_assign_gp (output_bfd, &gp))
883 r = bfd_reloc_dangerous;
886 relocation = relocation + rel->r_addend - gp;
888 if ((signed)relocation < -32768 || (signed)relocation > 32767)
889 r = bfd_reloc_outofrange;
892 r = _bfd_final_link_relocate (howto, input_bfd,
893 input_section, contents,
894 rel->r_offset, relocation,
900 /* Relocation is to the entry for this symbol in the global
902 BFD_ASSERT (sgot != NULL);
909 BFD_ASSERT (off != (bfd_vma) -1);
911 dyn = htab->root.dynamic_sections_created;
912 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
915 || (bfd_link_pic (info)
921 /* This is actually a static link, or it is a
922 -Bsymbolic link and the symbol is defined
923 locally, or the symbol was forced to be local
924 because of a version file. We must initialize
925 this entry in the global offset table. Since the
926 offset must always be a multiple of 4, we use the
927 least significant bit to record whether we have
928 initialized it already.
930 When doing a dynamic link, we create a .rela.got
931 relocation entry to initialize the value. This
932 is done in the finish_dynamic_symbol routine. */
937 /* Write entry in GOT */
938 bfd_put_32 (output_bfd, relocation,
939 sgot->contents + off);
940 /* Create entry in .rofixup pointing to GOT entry. */
941 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
943 _lm32fdpic_add_rofixup (output_bfd,
944 lm32fdpic_fixup32_section
946 sgot->output_section->vma
947 + sgot->output_offset
950 /* Mark GOT entry as having been written. */
955 relocation = sgot->output_offset + off;
962 BFD_ASSERT (local_got_offsets != NULL
963 && local_got_offsets[r_symndx] != (bfd_vma) -1);
965 /* Get offset into GOT table. */
966 off = local_got_offsets[r_symndx];
968 /* The offset must always be a multiple of 4. We use
969 the least significant bit to record whether we have
970 already processed this entry. */
975 /* Write entry in GOT. */
976 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
977 /* Create entry in .rofixup pointing to GOT entry. */
978 if (IS_FDPIC (output_bfd))
980 _lm32fdpic_add_rofixup (output_bfd,
981 lm32fdpic_fixup32_section
983 sgot->output_section->vma
984 + sgot->output_offset
988 if (bfd_link_pic (info))
991 Elf_Internal_Rela outrel;
993 /* We need to generate a R_LM32_RELATIVE reloc
994 for the dynamic linker. */
995 srelgot = htab->root.srelgot;
996 BFD_ASSERT (srelgot != NULL);
998 outrel.r_offset = (sgot->output_section->vma
999 + sgot->output_offset
1001 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1002 outrel.r_addend = relocation;
1003 loc = srelgot->contents;
1004 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1005 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1006 ++srelgot->reloc_count;
1009 local_got_offsets[r_symndx] |= 1;
1013 relocation = sgot->output_offset + off;
1016 /* Addend should be zero. */
1017 if (rel->r_addend != 0)
1018 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
1020 r = _bfd_final_link_relocate (howto,
1029 case R_LM32_GOTOFF_LO16:
1030 case R_LM32_GOTOFF_HI16:
1031 /* Relocation is offset from GOT. */
1032 BFD_ASSERT (sgot != NULL);
1033 relocation -= sgot->output_section->vma;
1034 /* Account for sign-extension. */
1035 if ((r_type == R_LM32_GOTOFF_HI16)
1036 && ((relocation + rel->r_addend) & 0x8000))
1037 rel->r_addend += 0x10000;
1038 r = _bfd_final_link_relocate (howto,
1048 if (IS_FDPIC (output_bfd))
1050 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1052 /* Only create .rofixup entries for relocs in loadable sections. */
1053 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1054 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1057 /* Check address to be modified is writable. */
1058 if (_lm32fdpic_osec_readonly_p (output_bfd,
1062 info->callbacks->warning
1064 _("cannot emit dynamic relocations in read-only section"),
1065 name, input_bfd, input_section, rel->r_offset);
1068 /* Create entry in .rofixup section. */
1069 _lm32fdpic_add_rofixup (output_bfd,
1070 lm32fdpic_fixup32_section (info),
1071 input_section->output_section->vma
1072 + input_section->output_offset
1080 r = _bfd_final_link_relocate (howto,
1091 if (r != bfd_reloc_ok)
1093 const char *msg = NULL;
1096 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1097 howto = bfd_reloc.howto;
1100 name = h->root.root.string;
1103 name = (bfd_elf_string_from_elf_section
1104 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1105 if (name == NULL || *name == '\0')
1106 name = bfd_section_name (input_bfd, sec);
1111 case bfd_reloc_overflow:
1113 && (h->root.type == bfd_link_hash_undefweak))
1115 (*info->callbacks->reloc_overflow)
1116 (info, (h ? &h->root : NULL), name, howto->name,
1117 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1120 case bfd_reloc_undefined:
1121 (*info->callbacks->undefined_symbol)
1122 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1125 case bfd_reloc_outofrange:
1126 msg = _("internal error: out of range error");
1129 case bfd_reloc_notsupported:
1130 msg = _("internal error: unsupported relocation error");
1133 case bfd_reloc_dangerous:
1134 msg = _("internal error: dangerous error");
1138 msg = _("internal error: unknown error");
1142 (*info->callbacks->warning) (info, msg, name, input_bfd,
1143 input_section, rel->r_offset);
1153 lm32_elf_gc_mark_hook (asection *sec,
1154 struct bfd_link_info *info,
1155 Elf_Internal_Rela *rel,
1156 struct elf_link_hash_entry *h,
1157 Elf_Internal_Sym *sym)
1160 switch (ELF32_R_TYPE (rel->r_info))
1162 case R_LM32_GNU_VTINHERIT:
1163 case R_LM32_GNU_VTENTRY:
1167 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1170 /* Look through the relocs for a section during the first phase. */
1173 lm32_elf_check_relocs (bfd *abfd,
1174 struct bfd_link_info *info,
1176 const Elf_Internal_Rela *relocs)
1178 Elf_Internal_Shdr *symtab_hdr;
1179 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1180 const Elf_Internal_Rela *rel;
1181 const Elf_Internal_Rela *rel_end;
1182 struct elf_lm32_link_hash_table *htab;
1185 if (bfd_link_relocatable (info))
1188 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1189 sym_hashes = elf_sym_hashes (abfd);
1190 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1191 if (!elf_bad_symtab (abfd))
1192 sym_hashes_end -= symtab_hdr->sh_info;
1194 htab = lm32_elf_hash_table (info);
1198 dynobj = htab->root.dynobj;
1200 rel_end = relocs + sec->reloc_count;
1201 for (rel = relocs; rel < rel_end; rel++)
1204 struct elf_link_hash_entry *h;
1205 unsigned long r_symndx;
1207 r_symndx = ELF32_R_SYM (rel->r_info);
1208 r_type = ELF32_R_TYPE (rel->r_info);
1209 if (r_symndx < symtab_hdr->sh_info)
1213 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1214 while (h->root.type == bfd_link_hash_indirect
1215 || h->root.type == bfd_link_hash_warning)
1216 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1219 /* Some relocs require a global offset table. */
1220 if (htab->root.sgot == NULL)
1225 case R_LM32_GOTOFF_HI16:
1226 case R_LM32_GOTOFF_LO16:
1228 htab->root.dynobj = dynobj = abfd;
1229 if (!_bfd_elf_create_got_section (dynobj, info))
1235 /* Some relocs require a rofixup table. */
1236 if (IS_FDPIC (abfd))
1241 /* FDPIC requires a GOT if there is a .rofixup section
1242 (Normal ELF doesn't). */
1244 htab->root.dynobj = dynobj = abfd;
1245 if (!_bfd_elf_create_got_section (dynobj, info))
1247 /* Create .rofixup section */
1248 if (htab->sfixup32 == NULL)
1250 if (! create_rofixup_section (dynobj, info))
1255 case R_LM32_GOTOFF_HI16:
1256 case R_LM32_GOTOFF_LO16:
1257 /* Create .rofixup section. */
1258 if (htab->sfixup32 == NULL)
1261 htab->root.dynobj = dynobj = abfd;
1262 if (! create_rofixup_section (dynobj, info))
1273 h->got.refcount += 1;
1276 bfd_signed_vma *local_got_refcounts;
1278 /* This is a global offset table entry for a local symbol. */
1279 local_got_refcounts = elf_local_got_refcounts (abfd);
1280 if (local_got_refcounts == NULL)
1284 size = symtab_hdr->sh_info;
1285 size *= sizeof (bfd_signed_vma);
1286 local_got_refcounts = bfd_zalloc (abfd, size);
1287 if (local_got_refcounts == NULL)
1289 elf_local_got_refcounts (abfd) = local_got_refcounts;
1291 local_got_refcounts[r_symndx] += 1;
1295 /* This relocation describes the C++ object vtable hierarchy.
1296 Reconstruct it for later use during GC. */
1297 case R_LM32_GNU_VTINHERIT:
1298 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1302 /* This relocation describes which C++ vtable entries are actually
1303 used. Record for later use during GC. */
1304 case R_LM32_GNU_VTENTRY:
1305 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1315 /* Finish up the dynamic sections. */
1318 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1319 struct bfd_link_info *info)
1321 struct elf_lm32_link_hash_table *htab;
1326 htab = lm32_elf_hash_table (info);
1330 dynobj = htab->root.dynobj;
1332 sgot = htab->root.sgotplt;
1333 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1335 if (htab->root.dynamic_sections_created)
1338 Elf32_External_Dyn *dyncon, *dynconend;
1340 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1342 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1343 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1345 for (; dyncon < dynconend; dyncon++)
1347 Elf_Internal_Dyn dyn;
1350 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1358 s = htab->root.sgotplt;
1361 s = htab->root.srelplt;
1363 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1364 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1368 s = htab->root.srelplt;
1369 dyn.d_un.d_val = s->size;
1370 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1375 /* Fill in the first entry in the procedure linkage table. */
1376 splt = htab->root.splt;
1377 if (splt && splt->size > 0)
1379 if (bfd_link_pic (info))
1381 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1382 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1383 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1384 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1385 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1390 /* addr = .got + 4 */
1391 addr = sgot->output_section->vma + sgot->output_offset + 4;
1392 bfd_put_32 (output_bfd,
1393 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1395 bfd_put_32 (output_bfd,
1396 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1397 splt->contents + 4);
1398 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1399 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1400 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1403 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1408 /* Fill in the first three entries in the global offset table. */
1409 if (sgot && sgot->size > 0)
1412 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1414 bfd_put_32 (output_bfd,
1415 sdyn->output_section->vma + sdyn->output_offset,
1417 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1418 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1420 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1421 if (elf_section_data (sgot->output_section) != NULL)
1422 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1425 if (lm32fdpic_fixup32_section (info))
1427 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1428 bfd_vma got_value = hgot->root.u.def.value
1429 + hgot->root.u.def.section->output_section->vma
1430 + hgot->root.u.def.section->output_offset;
1431 struct bfd_link_hash_entry *hend;
1433 /* Last entry is pointer to GOT. */
1434 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1436 /* Check we wrote enough entries. */
1437 if (lm32fdpic_fixup32_section (info)->size
1438 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1441 ("LINKER BUG: .rofixup section size mismatch: size/4 %Ld != relocs %d",
1442 lm32fdpic_fixup32_section (info)->size/4,
1443 lm32fdpic_fixup32_section (info)->reloc_count);
1447 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1448 FALSE, FALSE, TRUE);
1450 && (hend->type == bfd_link_hash_defined
1451 || hend->type == bfd_link_hash_defweak))
1454 lm32fdpic_fixup32_section (info)->output_section->vma
1455 + lm32fdpic_fixup32_section (info)->output_offset
1456 + lm32fdpic_fixup32_section (info)->size
1457 - hend->u.def.section->output_section->vma
1458 - hend->u.def.section->output_offset;
1459 BFD_ASSERT (hend->u.def.value == value);
1460 if (hend->u.def.value != value)
1463 ("LINKER BUG: .rofixup section hend->u.def.value != value: %Ld != %Ld", hend->u.def.value, value);
1472 /* Finish up dynamic symbol handling. We set the contents of various
1473 dynamic sections here. */
1476 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1477 struct bfd_link_info *info,
1478 struct elf_link_hash_entry *h,
1479 Elf_Internal_Sym *sym)
1481 struct elf_lm32_link_hash_table *htab;
1484 htab = lm32_elf_hash_table (info);
1488 if (h->plt.offset != (bfd_vma) -1)
1496 Elf_Internal_Rela rela;
1498 /* This symbol has an entry in the procedure linkage table. Set
1500 BFD_ASSERT (h->dynindx != -1);
1502 splt = htab->root.splt;
1503 sgot = htab->root.sgotplt;
1504 srela = htab->root.srelplt;
1505 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1507 /* Get the index in the procedure linkage table which
1508 corresponds to this symbol. This is the index of this symbol
1509 in all the symbols for which we are making plt entries. The
1510 first entry in the procedure linkage table is reserved. */
1511 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1513 /* Get the offset into the .got table of the entry that
1514 corresponds to this function. Each .got entry is 4 bytes.
1515 The first three are reserved. */
1516 got_offset = (plt_index + 3) * 4;
1518 /* Fill in the entry in the procedure linkage table. */
1519 if (! bfd_link_pic (info))
1528 /* Fill in the entry in the global offset table. */
1529 bfd_put_32 (output_bfd,
1530 (splt->output_section->vma
1531 + splt->output_offset
1533 + 12), /* same offset */
1534 sgot->contents + got_offset);
1536 /* Fill in the entry in the .rela.plt section. */
1537 rela.r_offset = (sgot->output_section->vma
1538 + sgot->output_offset
1540 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1542 loc = srela->contents;
1543 loc += plt_index * sizeof (Elf32_External_Rela);
1544 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1546 if (!h->def_regular)
1548 /* Mark the symbol as undefined, rather than as defined in
1549 the .plt section. Leave the value alone. */
1550 sym->st_shndx = SHN_UNDEF;
1555 if (h->got.offset != (bfd_vma) -1)
1559 Elf_Internal_Rela rela;
1561 /* This symbol has an entry in the global offset table. Set it
1563 sgot = htab->root.sgot;
1564 srela = htab->root.srelgot;
1565 BFD_ASSERT (sgot != NULL && srela != NULL);
1567 rela.r_offset = (sgot->output_section->vma
1568 + sgot->output_offset
1569 + (h->got.offset &~ 1));
1571 /* If this is a -Bsymbolic link, and the symbol is defined
1572 locally, we just want to emit a RELATIVE reloc. Likewise if
1573 the symbol was forced to be local because of a version file.
1574 The entry in the global offset table will already have been
1575 initialized in the relocate_section function. */
1576 if (bfd_link_pic (info)
1582 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1583 rela.r_addend = (h->root.u.def.value
1584 + h->root.u.def.section->output_section->vma
1585 + h->root.u.def.section->output_offset);
1589 BFD_ASSERT ((h->got.offset & 1) == 0);
1590 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1591 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1595 loc = srela->contents;
1596 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1597 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1598 ++srela->reloc_count;
1604 Elf_Internal_Rela rela;
1606 /* This symbols needs a copy reloc. Set it up. */
1607 BFD_ASSERT (h->dynindx != -1
1608 && (h->root.type == bfd_link_hash_defined
1609 || h->root.type == bfd_link_hash_defweak));
1611 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1612 BFD_ASSERT (s != NULL);
1614 rela.r_offset = (h->root.u.def.value
1615 + h->root.u.def.section->output_section->vma
1616 + h->root.u.def.section->output_offset);
1617 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1620 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1621 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1625 /* Mark some specially defined symbols as absolute. */
1626 if (h == htab->root.hdynamic || h == htab->root.hgot)
1627 sym->st_shndx = SHN_ABS;
1632 static enum elf_reloc_type_class
1633 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1634 const asection *rel_sec ATTRIBUTE_UNUSED,
1635 const Elf_Internal_Rela *rela)
1637 switch ((int) ELF32_R_TYPE (rela->r_info))
1639 case R_LM32_RELATIVE: return reloc_class_relative;
1640 case R_LM32_JMP_SLOT: return reloc_class_plt;
1641 case R_LM32_COPY: return reloc_class_copy;
1642 default: return reloc_class_normal;
1646 /* Find dynamic relocs for H that apply to read-only sections. */
1649 readonly_dynrelocs (struct elf_link_hash_entry *h)
1651 struct elf_lm32_dyn_relocs *p;
1652 struct elf_lm32_link_hash_entry *eh = (struct elf_lm32_link_hash_entry *) h;
1654 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1656 asection *s = p->sec->output_section;
1658 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1664 /* Adjust a symbol defined by a dynamic object and referenced by a
1665 regular object. The current definition is in some section of the
1666 dynamic object, but we're not including those sections. We have to
1667 change the definition to something the rest of the link can
1671 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1672 struct elf_link_hash_entry *h)
1674 struct elf_lm32_link_hash_table *htab;
1675 struct elf_lm32_link_hash_entry *eh;
1676 struct elf_lm32_dyn_relocs *p;
1680 dynobj = elf_hash_table (info)->dynobj;
1682 /* Make sure we know what is going on here. */
1683 BFD_ASSERT (dynobj != NULL
1688 && !h->def_regular)));
1690 /* If this is a function, put it in the procedure linkage table. We
1691 will fill in the contents of the procedure linkage table later,
1692 when we know the address of the .got section. */
1693 if (h->type == STT_FUNC
1696 if (! bfd_link_pic (info)
1699 && h->root.type != bfd_link_hash_undefweak
1700 && h->root.type != bfd_link_hash_undefined)
1702 /* This case can occur if we saw a PLT reloc in an input
1703 file, but the symbol was never referred to by a dynamic
1704 object. In such a case, we don't actually need to build
1705 a procedure linkage table, and we can just do a PCREL
1707 h->plt.offset = (bfd_vma) -1;
1714 h->plt.offset = (bfd_vma) -1;
1716 /* If this is a weak symbol, and there is a real definition, the
1717 processor independent code will have arranged for us to see the
1718 real definition first, and we can just use the same value. */
1719 if (h->is_weakalias)
1721 struct elf_link_hash_entry *def = weakdef (h);
1722 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1723 h->root.u.def.section = def->root.u.def.section;
1724 h->root.u.def.value = def->root.u.def.value;
1728 /* This is a reference to a symbol defined by a dynamic object which
1729 is not a function. */
1731 /* If we are creating a shared library, we must presume that the
1732 only references to the symbol are via the global offset table.
1733 For such cases we need not do anything here; the relocations will
1734 be handled correctly by relocate_section. */
1735 if (bfd_link_pic (info))
1738 /* If there are no references to this symbol that do not use the
1739 GOT, we don't need to generate a copy reloc. */
1740 if (!h->non_got_ref)
1743 /* If -z nocopyreloc was given, we won't generate them either. */
1744 if (info->nocopyreloc)
1750 eh = (struct elf_lm32_link_hash_entry *) h;
1751 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1753 s = p->sec->output_section;
1754 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1758 /* If we didn't find any dynamic relocs in sections which needs the
1759 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1767 /* We must allocate the symbol in our .dynbss section, which will
1768 become part of the .bss section of the executable. There will be
1769 an entry for this symbol in the .dynsym section. The dynamic
1770 object will contain position independent code, so all references
1771 from the dynamic object to this symbol will go through the global
1772 offset table. The dynamic linker will use the .dynsym entry to
1773 determine the address it must put in the global offset table, so
1774 both the dynamic object and the regular object will refer to the
1775 same memory location for the variable. */
1777 htab = lm32_elf_hash_table (info);
1782 BFD_ASSERT (s != NULL);
1784 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1785 to copy the initial value out of the dynamic object and into the
1786 runtime process image. We need to remember the offset into the
1787 .rela.bss section we are going to use. */
1788 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1792 srel = htab->srelbss;
1793 BFD_ASSERT (srel != NULL);
1794 srel->size += sizeof (Elf32_External_Rela);
1798 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1801 /* Allocate space in .plt, .got and associated reloc sections for
1805 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1807 struct bfd_link_info *info;
1808 struct elf_lm32_link_hash_table *htab;
1809 struct elf_lm32_link_hash_entry *eh;
1810 struct elf_lm32_dyn_relocs *p;
1812 if (h->root.type == bfd_link_hash_indirect)
1815 info = (struct bfd_link_info *) inf;
1816 htab = lm32_elf_hash_table (info);
1820 eh = (struct elf_lm32_link_hash_entry *) h;
1822 if (htab->root.dynamic_sections_created
1823 && h->plt.refcount > 0)
1825 /* Make sure this symbol is output as a dynamic symbol.
1826 Undefined weak syms won't yet be marked as dynamic. */
1827 if (h->dynindx == -1
1828 && !h->forced_local)
1830 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1834 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1836 asection *s = htab->root.splt;
1838 /* If this is the first .plt entry, make room for the special
1841 s->size += PLT_ENTRY_SIZE;
1843 h->plt.offset = s->size;
1845 /* If this symbol is not defined in a regular file, and we are
1846 not generating a shared library, then set the symbol to this
1847 location in the .plt. This is required to make function
1848 pointers compare as equal between the normal executable and
1849 the shared library. */
1850 if (! bfd_link_pic (info)
1853 h->root.u.def.section = s;
1854 h->root.u.def.value = h->plt.offset;
1857 /* Make room for this entry. */
1858 s->size += PLT_ENTRY_SIZE;
1860 /* We also need to make an entry in the .got.plt section, which
1861 will be placed in the .got section by the linker script. */
1862 htab->root.sgotplt->size += 4;
1864 /* We also need to make an entry in the .rel.plt section. */
1865 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1869 h->plt.offset = (bfd_vma) -1;
1875 h->plt.offset = (bfd_vma) -1;
1879 if (h->got.refcount > 0)
1884 /* Make sure this symbol is output as a dynamic symbol.
1885 Undefined weak syms won't yet be marked as dynamic. */
1886 if (h->dynindx == -1
1887 && !h->forced_local)
1889 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1893 s = htab->root.sgot;
1895 h->got.offset = s->size;
1897 dyn = htab->root.dynamic_sections_created;
1898 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1899 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1902 h->got.offset = (bfd_vma) -1;
1904 if (eh->dyn_relocs == NULL)
1907 /* In the shared -Bsymbolic case, discard space allocated for
1908 dynamic pc-relative relocs against symbols which turn out to be
1909 defined in regular objects. For the normal shared case, discard
1910 space for pc-relative relocs that have become local due to symbol
1911 visibility changes. */
1913 if (bfd_link_pic (info))
1919 struct elf_lm32_dyn_relocs **pp;
1921 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1923 p->count -= p->pc_count;
1932 /* Also discard relocs on undefined weak syms with non-default
1934 if (eh->dyn_relocs != NULL
1935 && h->root.type == bfd_link_hash_undefweak)
1937 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1938 eh->dyn_relocs = NULL;
1940 /* Make sure undefined weak symbols are output as a dynamic
1942 else if (h->dynindx == -1
1943 && !h->forced_local)
1945 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1952 /* For the non-shared case, discard space for relocs against
1953 symbols which turn out to need copy relocs or are not
1959 || (htab->root.dynamic_sections_created
1960 && (h->root.type == bfd_link_hash_undefweak
1961 || h->root.type == bfd_link_hash_undefined))))
1963 /* Make sure this symbol is output as a dynamic symbol.
1964 Undefined weak syms won't yet be marked as dynamic. */
1965 if (h->dynindx == -1
1966 && !h->forced_local)
1968 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1972 /* If that succeeded, we know we'll be keeping all the
1974 if (h->dynindx != -1)
1978 eh->dyn_relocs = NULL;
1983 /* Finally, allocate space. */
1984 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1986 asection *sreloc = elf_section_data (p->sec)->sreloc;
1987 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1993 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1994 read-only sections. */
1997 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2001 if (h->root.type == bfd_link_hash_indirect)
2004 sec = readonly_dynrelocs (h);
2007 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2009 info->flags |= DF_TEXTREL;
2010 info->callbacks->minfo
2011 (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
2012 sec->owner, h->root.root.string, sec);
2014 /* Not an error, just cut short the traversal. */
2020 /* Set the sizes of the dynamic sections. */
2023 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2024 struct bfd_link_info *info)
2026 struct elf_lm32_link_hash_table *htab;
2032 htab = lm32_elf_hash_table (info);
2036 dynobj = htab->root.dynobj;
2037 BFD_ASSERT (dynobj != NULL);
2039 if (htab->root.dynamic_sections_created)
2041 /* Set the contents of the .interp section to the interpreter. */
2042 if (bfd_link_executable (info) && !info->nointerp)
2044 s = bfd_get_linker_section (dynobj, ".interp");
2045 BFD_ASSERT (s != NULL);
2046 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2047 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2051 /* Set up .got offsets for local syms, and space for local dynamic
2053 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2055 bfd_signed_vma *local_got;
2056 bfd_signed_vma *end_local_got;
2057 bfd_size_type locsymcount;
2058 Elf_Internal_Shdr *symtab_hdr;
2061 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2064 for (s = ibfd->sections; s != NULL; s = s->next)
2066 struct elf_lm32_dyn_relocs *p;
2068 for (p = ((struct elf_lm32_dyn_relocs *)
2069 elf_section_data (s)->local_dynrel);
2073 if (! bfd_is_abs_section (p->sec)
2074 && bfd_is_abs_section (p->sec->output_section))
2076 /* Input section has been discarded, either because
2077 it is a copy of a linkonce section or due to
2078 linker script /DISCARD/, so we'll be discarding
2081 else if (p->count != 0)
2083 srel = elf_section_data (p->sec)->sreloc;
2084 srel->size += p->count * sizeof (Elf32_External_Rela);
2085 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2086 info->flags |= DF_TEXTREL;
2091 local_got = elf_local_got_refcounts (ibfd);
2095 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2096 locsymcount = symtab_hdr->sh_info;
2097 end_local_got = local_got + locsymcount;
2098 s = htab->root.sgot;
2099 srel = htab->root.srelgot;
2100 for (; local_got < end_local_got; ++local_got)
2104 *local_got = s->size;
2106 if (bfd_link_pic (info))
2107 srel->size += sizeof (Elf32_External_Rela);
2110 *local_got = (bfd_vma) -1;
2114 /* Allocate global sym .plt and .got entries, and space for global
2115 sym dynamic relocs. */
2116 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2118 /* We now have determined the sizes of the various dynamic sections.
2119 Allocate memory for them. */
2121 for (s = dynobj->sections; s != NULL; s = s->next)
2123 if ((s->flags & SEC_LINKER_CREATED) == 0)
2126 if (s == htab->root.splt
2127 || s == htab->root.sgot
2128 || s == htab->root.sgotplt
2129 || s == htab->sdynbss)
2131 /* Strip this section if we don't need it; see the
2134 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2136 if (s->size != 0 && s != htab->root.srelplt)
2139 /* We use the reloc_count field as a counter if we need
2140 to copy relocs into the output file. */
2144 /* It's not one of our sections, so don't allocate space. */
2149 /* If we don't need this section, strip it from the
2150 output file. This is mostly to handle .rela.bss and
2151 .rela.plt. We must create both sections in
2152 create_dynamic_sections, because they must be created
2153 before the linker maps input sections to output
2154 sections. The linker does that before
2155 adjust_dynamic_symbol is called, and it is that
2156 function which decides whether anything needs to go
2157 into these sections. */
2158 s->flags |= SEC_EXCLUDE;
2162 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2165 /* Allocate memory for the section contents. We use bfd_zalloc
2166 here in case unused entries are not reclaimed before the
2167 section's contents are written out. This should not happen,
2168 but this way if it does, we get a R_LM32_NONE reloc instead
2170 s->contents = bfd_zalloc (dynobj, s->size);
2171 if (s->contents == NULL)
2175 if (htab->root.dynamic_sections_created)
2177 /* Add some entries to the .dynamic section. We fill in the
2178 values later, in lm32_elf_finish_dynamic_sections, but we
2179 must add the entries now so that we get the correct size for
2180 the .dynamic section. The DT_DEBUG entry is filled in by the
2181 dynamic linker and used by the debugger. */
2182 #define add_dynamic_entry(TAG, VAL) \
2183 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2185 if (bfd_link_executable (info))
2187 if (! add_dynamic_entry (DT_DEBUG, 0))
2191 if (htab->root.splt->size != 0)
2193 if (! add_dynamic_entry (DT_PLTGOT, 0)
2194 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2195 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2196 || ! add_dynamic_entry (DT_JMPREL, 0))
2202 if (! add_dynamic_entry (DT_RELA, 0)
2203 || ! add_dynamic_entry (DT_RELASZ, 0)
2204 || ! add_dynamic_entry (DT_RELAENT,
2205 sizeof (Elf32_External_Rela)))
2208 /* If any dynamic relocs apply to a read-only section,
2209 then we need a DT_TEXTREL entry. */
2210 if ((info->flags & DF_TEXTREL) == 0)
2211 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2213 if ((info->flags & DF_TEXTREL) != 0)
2215 if (! add_dynamic_entry (DT_TEXTREL, 0))
2220 #undef add_dynamic_entry
2222 /* Allocate .rofixup section. */
2223 if (IS_FDPIC (output_bfd))
2225 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2226 int rgot_weak_count = 0;
2229 /* Look for deleted sections. */
2230 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2232 for (s = ibfd->sections; s != NULL; s = s->next)
2236 /* Count relocs that need .rofixup entires. */
2237 Elf_Internal_Rela *internal_relocs, *end;
2238 internal_relocs = elf_section_data (s)->relocs;
2239 if (internal_relocs == NULL)
2240 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2241 if (internal_relocs != NULL)
2243 end = internal_relocs + s->reloc_count;
2244 while (internal_relocs < end)
2246 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2247 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2248 unsigned long r_symndx;
2249 struct elf_link_hash_entry *h;
2251 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2252 sym_hashes = elf_sym_hashes (ibfd);
2253 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2255 if (r_symndx < symtab_hdr->sh_info)
2260 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2261 while (h->root.type == bfd_link_hash_indirect
2262 || h->root.type == bfd_link_hash_warning)
2263 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2266 /* Don't generate entries for weak symbols. */
2267 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2269 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2271 switch (ELF32_R_TYPE (internal_relocs->r_info))
2284 struct weak_symbol_list *current, *new_entry;
2285 /* Is this symbol already in the list? */
2286 for (current = list_start; current; current = current->next)
2288 if (!strcmp (current->name, h->root.root.string))
2291 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2293 /* Will this have an entry in the GOT. */
2294 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2296 /* Create a new entry. */
2297 new_entry = malloc (sizeof (struct weak_symbol_list));
2300 new_entry->name = h->root.root.string;
2301 new_entry->next = NULL;
2303 if (list_start == NULL)
2305 list_start = new_entry;
2306 list_end = new_entry;
2310 list_end->next = new_entry;
2311 list_end = new_entry;
2313 /* Increase count of undefined weak symbols in the got. */
2329 list_end = list_start->next;
2331 list_start = list_end;
2334 /* Size sections. */
2335 lm32fdpic_fixup32_section (info)->size
2336 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2337 if (lm32fdpic_fixup32_section (info)->size == 0)
2338 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2341 lm32fdpic_fixup32_section (info)->contents =
2342 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2343 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2351 /* Create dynamic sections when linking against a dynamic object. */
2354 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2356 struct elf_lm32_link_hash_table *htab;
2357 flagword flags, pltflags;
2359 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2360 int ptralign = 2; /* 32bit */
2362 htab = lm32_elf_hash_table (info);
2366 /* Make sure we have a GOT - For the case where we have a dynamic object
2367 but none of the relocs in check_relocs */
2368 if (!_bfd_elf_create_got_section (abfd, info))
2370 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2372 if (! create_rofixup_section (abfd, info))
2376 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2377 .rel[a].bss sections. */
2378 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2379 | SEC_LINKER_CREATED);
2382 pltflags |= SEC_CODE;
2383 if (bed->plt_not_loaded)
2384 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2385 if (bed->plt_readonly)
2386 pltflags |= SEC_READONLY;
2388 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2389 htab->root.splt = s;
2391 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2394 if (bed->want_plt_sym)
2396 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2398 struct bfd_link_hash_entry *bh = NULL;
2399 struct elf_link_hash_entry *h;
2401 if (! (_bfd_generic_link_add_one_symbol
2402 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2403 (bfd_vma) 0, NULL, FALSE,
2404 get_elf_backend_data (abfd)->collect, &bh)))
2406 h = (struct elf_link_hash_entry *) bh;
2408 h->type = STT_OBJECT;
2409 htab->root.hplt = h;
2411 if (bfd_link_pic (info)
2412 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2416 s = bfd_make_section_anyway_with_flags (abfd,
2417 bed->default_use_rela_p
2418 ? ".rela.plt" : ".rel.plt",
2419 flags | SEC_READONLY);
2420 htab->root.srelplt = s;
2422 || ! bfd_set_section_alignment (abfd, s, ptralign))
2425 if (htab->root.sgot == NULL
2426 && !_bfd_elf_create_got_section (abfd, info))
2429 if (bed->want_dynbss)
2431 /* The .dynbss section is a place to put symbols which are defined
2432 by dynamic objects, are referenced by regular objects, and are
2433 not functions. We must allocate space for them in the process
2434 image and use a R_*_COPY reloc to tell the dynamic linker to
2435 initialize them at run time. The linker script puts the .dynbss
2436 section into the .bss section of the final image. */
2437 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2438 SEC_ALLOC | SEC_LINKER_CREATED);
2442 /* The .rel[a].bss section holds copy relocs. This section is not
2443 normally needed. We need to create it here, though, so that the
2444 linker will map it to an output section. We can't just create it
2445 only if we need it, because we will not know whether we need it
2446 until we have seen all the input files, and the first time the
2447 main linker code calls BFD after examining all the input files
2448 (size_dynamic_sections) the input sections have already been
2449 mapped to the output sections. If the section turns out not to
2450 be needed, we can discard it later. We will never need this
2451 section when generating a shared object, since they do not use
2453 if (! bfd_link_pic (info))
2455 s = bfd_make_section_anyway_with_flags (abfd,
2456 (bed->default_use_rela_p
2457 ? ".rela.bss" : ".rel.bss"),
2458 flags | SEC_READONLY);
2461 || ! bfd_set_section_alignment (abfd, s, ptralign))
2469 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2472 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2473 struct elf_link_hash_entry *dir,
2474 struct elf_link_hash_entry *ind)
2476 struct elf_lm32_link_hash_entry * edir;
2477 struct elf_lm32_link_hash_entry * eind;
2479 edir = (struct elf_lm32_link_hash_entry *) dir;
2480 eind = (struct elf_lm32_link_hash_entry *) ind;
2482 if (eind->dyn_relocs != NULL)
2484 if (edir->dyn_relocs != NULL)
2486 struct elf_lm32_dyn_relocs **pp;
2487 struct elf_lm32_dyn_relocs *p;
2489 /* Add reloc counts against the indirect sym to the direct sym
2490 list. Merge any entries against the same section. */
2491 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2493 struct elf_lm32_dyn_relocs *q;
2495 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2496 if (q->sec == p->sec)
2498 q->pc_count += p->pc_count;
2499 q->count += p->count;
2506 *pp = edir->dyn_relocs;
2509 edir->dyn_relocs = eind->dyn_relocs;
2510 eind->dyn_relocs = NULL;
2513 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2517 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2519 if (!bfd_link_relocatable (info))
2521 if (!bfd_elf_stack_segment_size (output_bfd, info,
2522 "__stacksize", DEFAULT_STACK_SIZE))
2525 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2527 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2534 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2538 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2539 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2542 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2545 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2546 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2549 /* Copy the stack size. */
2550 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2551 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2553 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2555 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2556 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2558 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2560 /* Rewrite the phdrs, since we're only called after they were first written. */
2561 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2562 ->s->sizeof_ehdr, SEEK_SET) != 0
2563 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2564 elf_elfheader (obfd)->e_phnum) != 0)
2576 #define ELF_ARCH bfd_arch_lm32
2577 #define ELF_TARGET_ID LM32_ELF_DATA
2578 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2579 #define ELF_MAXPAGESIZE 0x1000
2581 #define TARGET_BIG_SYM lm32_elf32_vec
2582 #define TARGET_BIG_NAME "elf32-lm32"
2584 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2585 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2586 #define elf_info_to_howto lm32_info_to_howto_rela
2587 #define elf_info_to_howto_rel 0
2588 #define elf_backend_rela_normal 1
2589 #define elf_backend_object_p lm32_elf_object_p
2590 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2591 #define elf_backend_stack_align 8
2592 #define elf_backend_can_gc_sections 1
2593 #define elf_backend_can_refcount 1
2594 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2595 #define elf_backend_plt_readonly 1
2596 #define elf_backend_want_got_plt 1
2597 #define elf_backend_want_plt_sym 0
2598 #define elf_backend_got_header_size 12
2599 #define elf_backend_dtrel_excludes_plt 1
2600 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2601 #define elf_backend_check_relocs lm32_elf_check_relocs
2602 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2603 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2604 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2605 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2606 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2607 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2608 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2609 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2610 #define elf_backend_relocate_section lm32_elf_relocate_section
2612 #include "elf32-target.h"
2614 #undef ELF_MAXPAGESIZE
2615 #define ELF_MAXPAGESIZE 0x4000
2618 #undef TARGET_BIG_SYM
2619 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2620 #undef TARGET_BIG_NAME
2621 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2623 #define elf32_bed elf32_lm32fdpic_bed
2625 #undef elf_backend_always_size_sections
2626 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2627 #undef bfd_elf32_bfd_copy_private_bfd_data
2628 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2630 #include "elf32-target.h"