1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2016 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. */
102 /* Get the lm32 ELF linker hash table from a link_info structure. */
104 #define lm32_elf_hash_table(p) \
105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
106 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
108 #define lm32fdpic_got_section(info) \
109 (lm32_elf_hash_table (info)->sgot)
110 #define lm32fdpic_gotrel_section(info) \
111 (lm32_elf_hash_table (info)->srelgot)
112 #define lm32fdpic_fixup32_section(info) \
113 (lm32_elf_hash_table (info)->sfixup32)
115 struct weak_symbol_list
118 struct weak_symbol_list *next;
121 /* Create an entry in an lm32 ELF linker hash table. */
123 static struct bfd_hash_entry *
124 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
125 struct bfd_hash_table *table,
128 struct elf_lm32_link_hash_entry *ret =
129 (struct elf_lm32_link_hash_entry *) entry;
131 /* Allocate the structure if it has not already been allocated by a
134 ret = bfd_hash_allocate (table,
135 sizeof (struct elf_lm32_link_hash_entry));
139 /* Call the allocation method of the superclass. */
140 ret = ((struct elf_lm32_link_hash_entry *)
141 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
145 struct elf_lm32_link_hash_entry *eh;
147 eh = (struct elf_lm32_link_hash_entry *) ret;
148 eh->dyn_relocs = NULL;
151 return (struct bfd_hash_entry *) ret;
154 /* Create an lm32 ELF linker hash table. */
156 static struct bfd_link_hash_table *
157 lm32_elf_link_hash_table_create (bfd *abfd)
159 struct elf_lm32_link_hash_table *ret;
160 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
162 ret = bfd_zmalloc (amt);
166 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
167 lm32_elf_link_hash_newfunc,
168 sizeof (struct elf_lm32_link_hash_entry),
175 return &ret->root.root;
178 /* Add a fixup to the ROFIXUP section. */
181 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
183 bfd_vma fixup_offset;
185 if (rofixup->flags & SEC_EXCLUDE)
188 fixup_offset = rofixup->reloc_count * 4;
189 if (rofixup->contents)
191 BFD_ASSERT (fixup_offset < rofixup->size);
192 if (fixup_offset < rofixup->size)
193 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
195 rofixup->reloc_count++;
200 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
201 shortcuts to them in our hash table. */
204 create_got_section (bfd *dynobj, struct bfd_link_info *info)
206 struct elf_lm32_link_hash_table *htab;
209 /* This function may be called more than once. */
210 s = bfd_get_linker_section (dynobj, ".got");
214 htab = lm32_elf_hash_table (info);
218 if (! _bfd_elf_create_got_section (dynobj, info))
221 htab->sgot = bfd_get_linker_section (dynobj, ".got");
222 htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
223 htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
224 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
230 /* Create .rofixup sections in DYNOBJ, and set up
231 shortcuts to them in our hash table. */
234 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
236 struct elf_lm32_link_hash_table *htab;
237 htab = lm32_elf_hash_table (info);
242 /* Fixup section for R_LM32_32 relocs. */
243 lm32fdpic_fixup32_section (info)
244 = bfd_make_section_anyway_with_flags (dynobj,
252 if (lm32fdpic_fixup32_section (info) == NULL
253 || ! bfd_set_section_alignment (dynobj,
254 lm32fdpic_fixup32_section (info), 2))
260 static reloc_howto_type lm32_elf_howto_table [] =
262 /* This reloc does nothing. */
263 HOWTO (R_LM32_NONE, /* type */
265 3, /* size (0 = byte, 1 = short, 2 = long) */
267 FALSE, /* pc_relative */
269 complain_overflow_dont, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_LM32_NONE", /* name */
272 FALSE, /* partial_inplace */
275 FALSE), /* pcrel_offset */
277 /* An 8 bit absolute relocation. */
278 HOWTO (R_LM32_8, /* type */
280 0, /* size (0 = byte, 1 = short, 2 = long) */
282 FALSE, /* pc_relative */
284 complain_overflow_bitfield,/* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_LM32_8", /* name */
287 FALSE, /* partial_inplace */
290 FALSE), /* pcrel_offset */
292 /* A 16 bit absolute relocation. */
293 HOWTO (R_LM32_16, /* type */
295 1, /* size (0 = byte, 1 = short, 2 = long) */
297 FALSE, /* pc_relative */
299 complain_overflow_bitfield,/* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_LM32_16", /* name */
302 FALSE, /* partial_inplace */
304 0xffff, /* dst_mask */
305 FALSE), /* pcrel_offset */
307 /* A 32 bit absolute relocation. */
308 HOWTO (R_LM32_32, /* type */
310 2, /* size (0 = byte, 1 = short, 2 = long) */
312 FALSE, /* pc_relative */
314 complain_overflow_bitfield,/* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_LM32_32", /* name */
317 FALSE, /* partial_inplace */
319 0xffffffff, /* dst_mask */
320 FALSE), /* pcrel_offset */
322 HOWTO (R_LM32_HI16, /* type */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
326 FALSE, /* pc_relative */
328 complain_overflow_bitfield,/* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_LM32_HI16", /* name */
331 FALSE, /* partial_inplace */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
336 HOWTO (R_LM32_LO16, /* type */
338 2, /* size (0 = byte, 1 = short, 2 = long) */
340 FALSE, /* pc_relative */
342 complain_overflow_dont, /* complain_on_overflow */
343 bfd_elf_generic_reloc, /* special_function */
344 "R_LM32_LO16", /* name */
345 FALSE, /* partial_inplace */
347 0xffff, /* dst_mask */
348 FALSE), /* pcrel_offset */
350 HOWTO (R_LM32_GPREL16, /* type */
352 2, /* size (0 = byte, 1 = short, 2 = long) */
354 FALSE, /* pc_relative */
356 complain_overflow_dont, /* complain_on_overflow */
357 lm32_elf_gprel_reloc, /* special_function */
358 "R_LM32_GPREL16", /* name */
359 FALSE, /* partial_inplace */
361 0xffff, /* dst_mask */
362 FALSE), /* pcrel_offset */
364 HOWTO (R_LM32_CALL, /* type */
366 2, /* size (0 = byte, 1 = short, 2 = long) */
368 TRUE, /* pc_relative */
370 complain_overflow_signed, /* complain_on_overflow */
371 bfd_elf_generic_reloc, /* special_function */
372 "R_LM32_CALL", /* name */
373 FALSE, /* partial_inplace */
375 0x3ffffff, /* dst_mask */
376 TRUE), /* pcrel_offset */
378 HOWTO (R_LM32_BRANCH, /* type */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
382 TRUE, /* pc_relative */
384 complain_overflow_signed, /* complain_on_overflow */
385 bfd_elf_generic_reloc, /* special_function */
386 "R_LM32_BRANCH", /* name */
387 FALSE, /* partial_inplace */
389 0xffff, /* dst_mask */
390 TRUE), /* pcrel_offset */
392 /* GNU extension to record C++ vtable hierarchy. */
393 HOWTO (R_LM32_GNU_VTINHERIT, /* type */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
397 FALSE, /* pc_relative */
399 complain_overflow_dont, /* complain_on_overflow */
400 NULL, /* special_function */
401 "R_LM32_GNU_VTINHERIT", /* name */
402 FALSE, /* partial_inplace */
405 FALSE), /* pcrel_offset */
407 /* GNU extension to record C++ vtable member usage. */
408 HOWTO (R_LM32_GNU_VTENTRY, /* type */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
412 FALSE, /* pc_relative */
414 complain_overflow_dont, /* complain_on_overflow */
415 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
416 "R_LM32_GNU_VTENTRY", /* name */
417 FALSE, /* partial_inplace */
420 FALSE), /* pcrel_offset */
422 HOWTO (R_LM32_16_GOT, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 FALSE, /* pc_relative */
428 complain_overflow_signed, /* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_LM32_16_GOT", /* name */
431 FALSE, /* partial_inplace */
433 0xffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
436 HOWTO (R_LM32_GOTOFF_HI16, /* type */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
440 FALSE, /* pc_relative */
442 complain_overflow_dont, /* complain_on_overflow */
443 bfd_elf_generic_reloc, /* special_function */
444 "R_LM32_GOTOFF_HI16", /* name */
445 FALSE, /* partial_inplace */
446 0xffff, /* src_mask */
447 0xffff, /* dst_mask */
448 FALSE), /* pcrel_offset */
450 HOWTO (R_LM32_GOTOFF_LO16, /* type */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
454 FALSE, /* pc_relative */
456 complain_overflow_dont, /* complain_on_overflow */
457 bfd_elf_generic_reloc, /* special_function */
458 "R_LM32_GOTOFF_LO16", /* name */
459 FALSE, /* partial_inplace */
460 0xffff, /* src_mask */
461 0xffff, /* dst_mask */
462 FALSE), /* pcrel_offset */
464 HOWTO (R_LM32_COPY, /* type */
466 2, /* size (0 = byte, 1 = short, 2 = long) */
468 FALSE, /* pc_relative */
470 complain_overflow_bitfield, /* complain_on_overflow */
471 bfd_elf_generic_reloc, /* special_function */
472 "R_LM32_COPY", /* name */
473 FALSE, /* partial_inplace */
474 0xffffffff, /* src_mask */
475 0xffffffff, /* dst_mask */
476 FALSE), /* pcrel_offset */
478 HOWTO (R_LM32_GLOB_DAT, /* type */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
482 FALSE, /* pc_relative */
484 complain_overflow_bitfield, /* complain_on_overflow */
485 bfd_elf_generic_reloc, /* special_function */
486 "R_LM32_GLOB_DAT", /* name */
487 FALSE, /* partial_inplace */
488 0xffffffff, /* src_mask */
489 0xffffffff, /* dst_mask */
490 FALSE), /* pcrel_offset */
492 HOWTO (R_LM32_JMP_SLOT, /* type */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
496 FALSE, /* pc_relative */
498 complain_overflow_bitfield, /* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_LM32_JMP_SLOT", /* name */
501 FALSE, /* partial_inplace */
502 0xffffffff, /* src_mask */
503 0xffffffff, /* dst_mask */
504 FALSE), /* pcrel_offset */
506 HOWTO (R_LM32_RELATIVE, /* type */
508 2, /* size (0 = byte, 1 = short, 2 = long) */
510 FALSE, /* pc_relative */
512 complain_overflow_bitfield, /* complain_on_overflow */
513 bfd_elf_generic_reloc, /* special_function */
514 "R_LM32_RELATIVE", /* name */
515 FALSE, /* partial_inplace */
516 0xffffffff, /* src_mask */
517 0xffffffff, /* dst_mask */
518 FALSE), /* pcrel_offset */
522 /* Map BFD reloc types to lm32 ELF reloc types. */
524 struct lm32_reloc_map
526 bfd_reloc_code_real_type bfd_reloc_val;
527 unsigned char elf_reloc_val;
530 static const struct lm32_reloc_map lm32_reloc_map[] =
532 { BFD_RELOC_NONE, R_LM32_NONE },
533 { BFD_RELOC_8, R_LM32_8 },
534 { BFD_RELOC_16, R_LM32_16 },
535 { BFD_RELOC_32, R_LM32_32 },
536 { BFD_RELOC_HI16, R_LM32_HI16 },
537 { BFD_RELOC_LO16, R_LM32_LO16 },
538 { BFD_RELOC_GPREL16, R_LM32_GPREL16 },
539 { BFD_RELOC_LM32_CALL, R_LM32_CALL },
540 { BFD_RELOC_LM32_BRANCH, R_LM32_BRANCH },
541 { BFD_RELOC_VTABLE_INHERIT, R_LM32_GNU_VTINHERIT },
542 { BFD_RELOC_VTABLE_ENTRY, R_LM32_GNU_VTENTRY },
543 { BFD_RELOC_LM32_16_GOT, R_LM32_16_GOT },
544 { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
545 { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
546 { BFD_RELOC_LM32_COPY, R_LM32_COPY },
547 { BFD_RELOC_LM32_GLOB_DAT, R_LM32_GLOB_DAT },
548 { BFD_RELOC_LM32_JMP_SLOT, R_LM32_JMP_SLOT },
549 { BFD_RELOC_LM32_RELATIVE, R_LM32_RELATIVE },
552 static reloc_howto_type *
553 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
554 bfd_reloc_code_real_type code)
558 for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
559 if (lm32_reloc_map[i].bfd_reloc_val == code)
560 return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
564 static reloc_howto_type *
565 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
571 i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
573 if (lm32_elf_howto_table[i].name != NULL
574 && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
575 return &lm32_elf_howto_table[i];
581 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
584 lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
586 Elf_Internal_Rela *dst)
590 r_type = ELF32_R_TYPE (dst->r_info);
591 if (r_type >= (unsigned int) R_LM32_max)
593 _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type);
596 cache_ptr->howto = &lm32_elf_howto_table[r_type];
599 /* Set the right machine number for an Lattice Mico32 ELF file. */
602 lm32_elf_object_p (bfd *abfd)
604 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
607 /* Set machine type flags just before file is written out. */
610 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
612 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
613 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
614 switch (bfd_get_mach (abfd))
617 elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
624 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
625 dangerous relocation. */
628 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
634 /* If we've already figured out what GP will be, just return it. */
635 *pgp = _bfd_get_gp_value (output_bfd);
639 count = bfd_get_symcount (output_bfd);
640 sym = bfd_get_outsymbols (output_bfd);
642 /* The linker script will have created a symbol named `_gp' with the
643 appropriate value. */
648 for (i = 0; i < count; i++, sym++)
652 name = bfd_asymbol_name (*sym);
653 if (*name == '_' && strcmp (name, "_gp") == 0)
655 *pgp = bfd_asymbol_value (*sym);
656 _bfd_set_gp_value (output_bfd, *pgp);
664 /* Only get the error once. */
666 _bfd_set_gp_value (output_bfd, *pgp);
673 /* We have to figure out the gp value, so that we can adjust the
674 symbol value correctly. We look up the symbol _gp in the output
675 BFD. If we can't find it, we're stuck. We cache it in the ELF
676 target data. We don't need to adjust the symbol value for an
677 external symbol if we are producing relocatable output. */
679 static bfd_reloc_status_type
680 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
681 char **error_message, bfd_vma *pgp)
683 if (bfd_is_und_section (symbol->section) && !relocatable)
686 return bfd_reloc_undefined;
689 *pgp = _bfd_get_gp_value (output_bfd);
690 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
694 /* Make up a value. */
695 *pgp = symbol->section->output_section->vma + 0x4000;
696 _bfd_set_gp_value (output_bfd, *pgp);
698 else if (!lm32_elf_assign_gp (output_bfd, pgp))
702 _("global pointer relative relocation when _gp not defined");
703 return bfd_reloc_dangerous;
710 static bfd_reloc_status_type
711 lm32_elf_do_gprel_relocate (bfd *abfd,
712 reloc_howto_type *howto,
713 asection *input_section ATTRIBUTE_UNUSED,
716 bfd_vma symbol_value,
719 return _bfd_final_link_relocate (howto, abfd, input_section,
720 data, offset, symbol_value, addend);
723 static bfd_reloc_status_type
724 lm32_elf_gprel_reloc (bfd *abfd,
725 arelent *reloc_entry,
728 asection *input_section,
734 bfd_reloc_status_type r;
736 if (output_bfd != (bfd *) NULL
737 && (symbol->flags & BSF_SECTION_SYM) == 0
738 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
740 reloc_entry->address += input_section->output_offset;
744 if (output_bfd != NULL)
747 relocation = symbol->value
748 + symbol->section->output_section->vma + symbol->section->output_offset;
751 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
753 relocation = relocation + reloc_entry->addend - gp;
754 reloc_entry->addend = 0;
755 if ((signed) relocation < -32768 || (signed) relocation > 32767)
757 *msg = _("global pointer relative address out of range");
758 r = bfd_reloc_outofrange;
762 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
764 data, reloc_entry->address,
765 relocation, reloc_entry->addend);
772 /* Find the segment number in which OSEC, and output section, is
776 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
778 struct elf_segment_map *m;
779 Elf_Internal_Phdr *p;
781 /* Find the segment that contains the output_section. */
782 for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr;
788 for (i = m->count - 1; i >= 0; i--)
789 if (m->sections[i] == osec)
796 return p - elf_tdata (output_bfd)->phdr;
799 /* Determine if an output section is read-only. */
801 inline static bfd_boolean
802 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
804 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
806 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
809 /* Relocate a section */
812 lm32_elf_relocate_section (bfd *output_bfd,
813 struct bfd_link_info *info,
815 asection *input_section,
817 Elf_Internal_Rela *relocs,
818 Elf_Internal_Sym *local_syms,
819 asection **local_sections)
821 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
822 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
823 Elf_Internal_Rela *rel, *relend;
824 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
826 bfd_vma *local_got_offsets;
832 dynobj = htab->root.dynobj;
833 local_got_offsets = elf_local_got_offsets (input_bfd);
837 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
838 sym_hashes = elf_sym_hashes (input_bfd);
841 relend = relocs + input_section->reloc_count;
842 for (; rel < relend; rel++)
844 reloc_howto_type *howto;
846 unsigned long r_symndx;
847 Elf_Internal_Sym *sym;
849 struct elf_link_hash_entry *h;
852 bfd_reloc_status_type r;
853 const char *name = NULL;
855 r_symndx = ELF32_R_SYM (rel->r_info);
856 r_type = ELF32_R_TYPE (rel->r_info);
858 if (r_type == R_LM32_GNU_VTENTRY
859 || r_type == R_LM32_GNU_VTINHERIT )
866 howto = lm32_elf_howto_table + r_type;
868 if (r_symndx < symtab_hdr->sh_info)
870 /* It's a local symbol. */
871 sym = local_syms + r_symndx;
872 sec = local_sections[r_symndx];
873 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
874 name = bfd_elf_string_from_elf_section
875 (input_bfd, symtab_hdr->sh_link, sym->st_name);
876 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
880 /* It's a global symbol. */
881 bfd_boolean unresolved_reloc;
882 bfd_boolean warned, ignored;
884 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
885 r_symndx, symtab_hdr, sym_hashes,
887 unresolved_reloc, warned, ignored);
888 name = h->root.root.string;
891 if (sec != NULL && discarded_section (sec))
892 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
893 rel, 1, relend, howto, 0, contents);
895 if (bfd_link_relocatable (info))
897 /* This is a relocatable link. We don't have to change
898 anything, unless the reloc is against a section symbol,
899 in which case we have to adjust according to where the
900 section symbol winds up in the output section. */
901 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
904 /* If partial_inplace, we need to store any additional addend
905 back in the section. */
906 if (! howto->partial_inplace)
909 /* Shouldn't reach here. */
918 if (!lm32_elf_assign_gp (output_bfd, &gp))
919 r = bfd_reloc_dangerous;
922 relocation = relocation + rel->r_addend - gp;
924 if ((signed)relocation < -32768 || (signed)relocation > 32767)
925 r = bfd_reloc_outofrange;
928 r = _bfd_final_link_relocate (howto, input_bfd,
929 input_section, contents,
930 rel->r_offset, relocation,
936 /* Relocation is to the entry for this symbol in the global
938 BFD_ASSERT (sgot != NULL);
945 BFD_ASSERT (off != (bfd_vma) -1);
947 dyn = htab->root.dynamic_sections_created;
948 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
951 || (bfd_link_pic (info)
957 /* This is actually a static link, or it is a
958 -Bsymbolic link and the symbol is defined
959 locally, or the symbol was forced to be local
960 because of a version file. We must initialize
961 this entry in the global offset table. Since the
962 offset must always be a multiple of 4, we use the
963 least significant bit to record whether we have
964 initialized it already.
966 When doing a dynamic link, we create a .rela.got
967 relocation entry to initialize the value. This
968 is done in the finish_dynamic_symbol routine. */
973 /* Write entry in GOT */
974 bfd_put_32 (output_bfd, relocation,
975 sgot->contents + off);
976 /* Create entry in .rofixup pointing to GOT entry. */
977 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
979 _lm32fdpic_add_rofixup (output_bfd,
980 lm32fdpic_fixup32_section
982 sgot->output_section->vma
983 + sgot->output_offset
986 /* Mark GOT entry as having been written. */
991 relocation = sgot->output_offset + off;
998 BFD_ASSERT (local_got_offsets != NULL
999 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1001 /* Get offset into GOT table. */
1002 off = local_got_offsets[r_symndx];
1004 /* The offset must always be a multiple of 4. We use
1005 the least significant bit to record whether we have
1006 already processed this entry. */
1011 /* Write entry in GOT. */
1012 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1013 /* Create entry in .rofixup pointing to GOT entry. */
1014 if (IS_FDPIC (output_bfd))
1016 _lm32fdpic_add_rofixup (output_bfd,
1017 lm32fdpic_fixup32_section
1019 sgot->output_section->vma
1020 + sgot->output_offset
1024 if (bfd_link_pic (info))
1027 Elf_Internal_Rela outrel;
1029 /* We need to generate a R_LM32_RELATIVE reloc
1030 for the dynamic linker. */
1031 srelgot = bfd_get_linker_section (dynobj,
1033 BFD_ASSERT (srelgot != NULL);
1035 outrel.r_offset = (sgot->output_section->vma
1036 + sgot->output_offset
1038 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1039 outrel.r_addend = relocation;
1040 loc = srelgot->contents;
1041 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1042 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1043 ++srelgot->reloc_count;
1046 local_got_offsets[r_symndx] |= 1;
1050 relocation = sgot->output_offset + off;
1053 /* Addend should be zero. */
1054 if (rel->r_addend != 0)
1055 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
1057 r = _bfd_final_link_relocate (howto,
1066 case R_LM32_GOTOFF_LO16:
1067 case R_LM32_GOTOFF_HI16:
1068 /* Relocation is offset from GOT. */
1069 BFD_ASSERT (sgot != NULL);
1070 relocation -= sgot->output_section->vma;
1071 /* Account for sign-extension. */
1072 if ((r_type == R_LM32_GOTOFF_HI16)
1073 && ((relocation + rel->r_addend) & 0x8000))
1074 rel->r_addend += 0x10000;
1075 r = _bfd_final_link_relocate (howto,
1085 if (IS_FDPIC (output_bfd))
1087 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1089 /* Only create .rofixup entries for relocs in loadable sections. */
1090 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1091 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1094 /* Check address to be modified is writable. */
1095 if (_lm32fdpic_osec_readonly_p (output_bfd,
1099 info->callbacks->warning
1101 _("cannot emit dynamic relocations in read-only section"),
1102 name, input_bfd, input_section, rel->r_offset);
1105 /* Create entry in .rofixup section. */
1106 _lm32fdpic_add_rofixup (output_bfd,
1107 lm32fdpic_fixup32_section (info),
1108 input_section->output_section->vma
1109 + input_section->output_offset
1117 r = _bfd_final_link_relocate (howto,
1128 if (r != bfd_reloc_ok)
1130 const char *msg = NULL;
1133 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1134 howto = bfd_reloc.howto;
1137 name = h->root.root.string;
1140 name = (bfd_elf_string_from_elf_section
1141 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1142 if (name == NULL || *name == '\0')
1143 name = bfd_section_name (input_bfd, sec);
1148 case bfd_reloc_overflow:
1150 && (h->root.type == bfd_link_hash_undefweak))
1152 (*info->callbacks->reloc_overflow)
1153 (info, (h ? &h->root : NULL), name, howto->name,
1154 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1157 case bfd_reloc_undefined:
1158 (*info->callbacks->undefined_symbol)
1159 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1162 case bfd_reloc_outofrange:
1163 msg = _("internal error: out of range error");
1166 case bfd_reloc_notsupported:
1167 msg = _("internal error: unsupported relocation error");
1170 case bfd_reloc_dangerous:
1171 msg = _("internal error: dangerous error");
1175 msg = _("internal error: unknown error");
1179 (*info->callbacks->warning) (info, msg, name, input_bfd,
1180 input_section, rel->r_offset);
1190 lm32_elf_gc_mark_hook (asection *sec,
1191 struct bfd_link_info *info,
1192 Elf_Internal_Rela *rel,
1193 struct elf_link_hash_entry *h,
1194 Elf_Internal_Sym *sym)
1197 switch (ELF32_R_TYPE (rel->r_info))
1199 case R_LM32_GNU_VTINHERIT:
1200 case R_LM32_GNU_VTENTRY:
1204 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1208 lm32_elf_gc_sweep_hook (bfd *abfd,
1209 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1211 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1213 /* Update the got entry reference counts for the section being removed. */
1214 Elf_Internal_Shdr *symtab_hdr;
1215 struct elf_link_hash_entry **sym_hashes;
1216 bfd_signed_vma *local_got_refcounts;
1217 const Elf_Internal_Rela *rel, *relend;
1219 elf_section_data (sec)->local_dynrel = NULL;
1221 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1222 sym_hashes = elf_sym_hashes (abfd);
1223 local_got_refcounts = elf_local_got_refcounts (abfd);
1225 relend = relocs + sec->reloc_count;
1226 for (rel = relocs; rel < relend; rel++)
1228 unsigned long r_symndx;
1229 struct elf_link_hash_entry *h = NULL;
1231 r_symndx = ELF32_R_SYM (rel->r_info);
1232 if (r_symndx >= symtab_hdr->sh_info)
1234 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1235 while (h->root.type == bfd_link_hash_indirect
1236 || h->root.type == bfd_link_hash_warning)
1237 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1240 switch (ELF32_R_TYPE (rel->r_info))
1245 if (h->got.refcount > 0)
1250 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1251 local_got_refcounts[r_symndx]--;
1262 /* Look through the relocs for a section during the first phase. */
1265 lm32_elf_check_relocs (bfd *abfd,
1266 struct bfd_link_info *info,
1268 const Elf_Internal_Rela *relocs)
1270 Elf_Internal_Shdr *symtab_hdr;
1271 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1272 const Elf_Internal_Rela *rel;
1273 const Elf_Internal_Rela *rel_end;
1274 struct elf_lm32_link_hash_table *htab;
1277 if (bfd_link_relocatable (info))
1280 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1281 sym_hashes = elf_sym_hashes (abfd);
1282 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1283 if (!elf_bad_symtab (abfd))
1284 sym_hashes_end -= symtab_hdr->sh_info;
1286 htab = lm32_elf_hash_table (info);
1290 dynobj = htab->root.dynobj;
1292 rel_end = relocs + sec->reloc_count;
1293 for (rel = relocs; rel < rel_end; rel++)
1296 struct elf_link_hash_entry *h;
1297 unsigned long r_symndx;
1299 r_symndx = ELF32_R_SYM (rel->r_info);
1300 r_type = ELF32_R_TYPE (rel->r_info);
1301 if (r_symndx < symtab_hdr->sh_info)
1305 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1306 while (h->root.type == bfd_link_hash_indirect
1307 || h->root.type == bfd_link_hash_warning)
1308 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1310 /* PR15323, ref flags aren't set for references in the same
1312 h->root.non_ir_ref = 1;
1315 /* Some relocs require a global offset table. */
1316 if (htab->sgot == NULL)
1321 case R_LM32_GOTOFF_HI16:
1322 case R_LM32_GOTOFF_LO16:
1324 htab->root.dynobj = dynobj = abfd;
1325 if (! create_got_section (dynobj, info))
1331 /* Some relocs require a rofixup table. */
1332 if (IS_FDPIC (abfd))
1337 /* FDPIC requires a GOT if there is a .rofixup section
1338 (Normal ELF doesn't). */
1340 htab->root.dynobj = dynobj = abfd;
1341 if (! create_got_section (dynobj, info))
1343 /* Create .rofixup section */
1344 if (htab->sfixup32 == NULL)
1346 if (! create_rofixup_section (dynobj, info))
1351 case R_LM32_GOTOFF_HI16:
1352 case R_LM32_GOTOFF_LO16:
1353 /* Create .rofixup section. */
1354 if (htab->sfixup32 == NULL)
1357 htab->root.dynobj = dynobj = abfd;
1358 if (! create_rofixup_section (dynobj, info))
1369 h->got.refcount += 1;
1372 bfd_signed_vma *local_got_refcounts;
1374 /* This is a global offset table entry for a local symbol. */
1375 local_got_refcounts = elf_local_got_refcounts (abfd);
1376 if (local_got_refcounts == NULL)
1380 size = symtab_hdr->sh_info;
1381 size *= sizeof (bfd_signed_vma);
1382 local_got_refcounts = bfd_zalloc (abfd, size);
1383 if (local_got_refcounts == NULL)
1385 elf_local_got_refcounts (abfd) = local_got_refcounts;
1387 local_got_refcounts[r_symndx] += 1;
1391 /* This relocation describes the C++ object vtable hierarchy.
1392 Reconstruct it for later use during GC. */
1393 case R_LM32_GNU_VTINHERIT:
1394 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1398 /* This relocation describes which C++ vtable entries are actually
1399 used. Record for later use during GC. */
1400 case R_LM32_GNU_VTENTRY:
1401 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1411 /* Finish up the dynamic sections. */
1414 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1415 struct bfd_link_info *info)
1417 struct elf_lm32_link_hash_table *htab;
1422 htab = lm32_elf_hash_table (info);
1426 dynobj = htab->root.dynobj;
1428 sgot = htab->sgotplt;
1429 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1431 if (htab->root.dynamic_sections_created)
1434 Elf32_External_Dyn *dyncon, *dynconend;
1436 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1438 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1439 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1441 for (; dyncon < dynconend; dyncon++)
1443 Elf_Internal_Dyn dyn;
1446 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1459 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1460 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1465 dyn.d_un.d_val = s->size;
1466 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1470 /* My reading of the SVR4 ABI indicates that the
1471 procedure linkage table relocs (DT_JMPREL) should be
1472 included in the overall relocs (DT_RELA). This is
1473 what Solaris does. However, UnixWare can not handle
1474 that case. Therefore, we override the DT_RELASZ entry
1475 here to make it not include the JMPREL relocs. Since
1476 the linker script arranges for .rela.plt to follow all
1477 other relocation sections, we don't have to worry
1478 about changing the DT_RELA entry. */
1479 if (htab->srelplt != NULL)
1482 dyn.d_un.d_val -= s->size;
1484 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1489 /* Fill in the first entry in the procedure linkage table. */
1491 if (splt && splt->size > 0)
1493 if (bfd_link_pic (info))
1495 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1496 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1497 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1498 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1499 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1504 /* addr = .got + 4 */
1505 addr = sgot->output_section->vma + sgot->output_offset + 4;
1506 bfd_put_32 (output_bfd,
1507 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1509 bfd_put_32 (output_bfd,
1510 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1511 splt->contents + 4);
1512 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1513 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1514 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1517 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1522 /* Fill in the first three entries in the global offset table. */
1523 if (sgot && sgot->size > 0)
1526 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1528 bfd_put_32 (output_bfd,
1529 sdyn->output_section->vma + sdyn->output_offset,
1531 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1532 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1534 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1535 if (elf_section_data (sgot->output_section) != NULL)
1536 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1539 if (lm32fdpic_fixup32_section (info))
1541 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1542 bfd_vma got_value = hgot->root.u.def.value
1543 + hgot->root.u.def.section->output_section->vma
1544 + hgot->root.u.def.section->output_offset;
1545 struct bfd_link_hash_entry *hend;
1547 /* Last entry is pointer to GOT. */
1548 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1550 /* Check we wrote enough entries. */
1551 if (lm32fdpic_fixup32_section (info)->size
1552 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1555 ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1556 lm32fdpic_fixup32_section (info)->size/4,
1557 lm32fdpic_fixup32_section (info)->reloc_count);
1561 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1562 FALSE, FALSE, TRUE);
1564 && (hend->type == bfd_link_hash_defined
1565 || hend->type == bfd_link_hash_defweak))
1568 lm32fdpic_fixup32_section (info)->output_section->vma
1569 + lm32fdpic_fixup32_section (info)->output_offset
1570 + lm32fdpic_fixup32_section (info)->size
1571 - hend->u.def.section->output_section->vma
1572 - hend->u.def.section->output_offset;
1573 BFD_ASSERT (hend->u.def.value == value);
1574 if (hend->u.def.value != value)
1577 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1586 /* Finish up dynamic symbol handling. We set the contents of various
1587 dynamic sections here. */
1590 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1591 struct bfd_link_info *info,
1592 struct elf_link_hash_entry *h,
1593 Elf_Internal_Sym *sym)
1595 struct elf_lm32_link_hash_table *htab;
1598 htab = lm32_elf_hash_table (info);
1602 if (h->plt.offset != (bfd_vma) -1)
1610 Elf_Internal_Rela rela;
1612 /* This symbol has an entry in the procedure linkage table. Set
1614 BFD_ASSERT (h->dynindx != -1);
1617 sgot = htab->sgotplt;
1618 srela = htab->srelplt;
1619 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1621 /* Get the index in the procedure linkage table which
1622 corresponds to this symbol. This is the index of this symbol
1623 in all the symbols for which we are making plt entries. The
1624 first entry in the procedure linkage table is reserved. */
1625 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1627 /* Get the offset into the .got table of the entry that
1628 corresponds to this function. Each .got entry is 4 bytes.
1629 The first three are reserved. */
1630 got_offset = (plt_index + 3) * 4;
1632 /* Fill in the entry in the procedure linkage table. */
1633 if (! bfd_link_pic (info))
1642 /* Fill in the entry in the global offset table. */
1643 bfd_put_32 (output_bfd,
1644 (splt->output_section->vma
1645 + splt->output_offset
1647 + 12), /* same offset */
1648 sgot->contents + got_offset);
1650 /* Fill in the entry in the .rela.plt section. */
1651 rela.r_offset = (sgot->output_section->vma
1652 + sgot->output_offset
1654 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1656 loc = srela->contents;
1657 loc += plt_index * sizeof (Elf32_External_Rela);
1658 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1660 if (!h->def_regular)
1662 /* Mark the symbol as undefined, rather than as defined in
1663 the .plt section. Leave the value alone. */
1664 sym->st_shndx = SHN_UNDEF;
1669 if (h->got.offset != (bfd_vma) -1)
1673 Elf_Internal_Rela rela;
1675 /* This symbol has an entry in the global offset table. Set it
1678 srela = htab->srelgot;
1679 BFD_ASSERT (sgot != NULL && srela != NULL);
1681 rela.r_offset = (sgot->output_section->vma
1682 + sgot->output_offset
1683 + (h->got.offset &~ 1));
1685 /* If this is a -Bsymbolic link, and the symbol is defined
1686 locally, we just want to emit a RELATIVE reloc. Likewise if
1687 the symbol was forced to be local because of a version file.
1688 The entry in the global offset table will already have been
1689 initialized in the relocate_section function. */
1690 if (bfd_link_pic (info)
1696 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1697 rela.r_addend = (h->root.u.def.value
1698 + h->root.u.def.section->output_section->vma
1699 + h->root.u.def.section->output_offset);
1703 BFD_ASSERT ((h->got.offset & 1) == 0);
1704 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1705 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1709 loc = srela->contents;
1710 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1711 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1712 ++srela->reloc_count;
1718 Elf_Internal_Rela rela;
1720 /* This symbols needs a copy reloc. Set it up. */
1721 BFD_ASSERT (h->dynindx != -1
1722 && (h->root.type == bfd_link_hash_defined
1723 || h->root.type == bfd_link_hash_defweak));
1725 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1726 BFD_ASSERT (s != NULL);
1728 rela.r_offset = (h->root.u.def.value
1729 + h->root.u.def.section->output_section->vma
1730 + h->root.u.def.section->output_offset);
1731 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1734 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1735 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1739 /* Mark some specially defined symbols as absolute. */
1740 if (h == htab->root.hdynamic || h == htab->root.hgot)
1741 sym->st_shndx = SHN_ABS;
1746 static enum elf_reloc_type_class
1747 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1748 const asection *rel_sec ATTRIBUTE_UNUSED,
1749 const Elf_Internal_Rela *rela)
1751 switch ((int) ELF32_R_TYPE (rela->r_info))
1753 case R_LM32_RELATIVE: return reloc_class_relative;
1754 case R_LM32_JMP_SLOT: return reloc_class_plt;
1755 case R_LM32_COPY: return reloc_class_copy;
1756 default: return reloc_class_normal;
1760 /* Adjust a symbol defined by a dynamic object and referenced by a
1761 regular object. The current definition is in some section of the
1762 dynamic object, but we're not including those sections. We have to
1763 change the definition to something the rest of the link can
1767 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1768 struct elf_link_hash_entry *h)
1770 struct elf_lm32_link_hash_table *htab;
1771 struct elf_lm32_link_hash_entry *eh;
1772 struct elf_lm32_dyn_relocs *p;
1776 dynobj = elf_hash_table (info)->dynobj;
1778 /* Make sure we know what is going on here. */
1779 BFD_ASSERT (dynobj != NULL
1781 || h->u.weakdef != NULL
1784 && !h->def_regular)));
1786 /* If this is a function, put it in the procedure linkage table. We
1787 will fill in the contents of the procedure linkage table later,
1788 when we know the address of the .got section. */
1789 if (h->type == STT_FUNC
1792 if (! bfd_link_pic (info)
1795 && h->root.type != bfd_link_hash_undefweak
1796 && h->root.type != bfd_link_hash_undefined)
1798 /* This case can occur if we saw a PLT reloc in an input
1799 file, but the symbol was never referred to by a dynamic
1800 object. In such a case, we don't actually need to build
1801 a procedure linkage table, and we can just do a PCREL
1803 h->plt.offset = (bfd_vma) -1;
1810 h->plt.offset = (bfd_vma) -1;
1812 /* If this is a weak symbol, and there is a real definition, the
1813 processor independent code will have arranged for us to see the
1814 real definition first, and we can just use the same value. */
1815 if (h->u.weakdef != NULL)
1817 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1818 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1819 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1820 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1824 /* This is a reference to a symbol defined by a dynamic object which
1825 is not a function. */
1827 /* If we are creating a shared library, we must presume that the
1828 only references to the symbol are via the global offset table.
1829 For such cases we need not do anything here; the relocations will
1830 be handled correctly by relocate_section. */
1831 if (bfd_link_pic (info))
1834 /* If there are no references to this symbol that do not use the
1835 GOT, we don't need to generate a copy reloc. */
1836 if (!h->non_got_ref)
1839 /* If -z nocopyreloc was given, we won't generate them either. */
1840 if (info->nocopyreloc)
1846 eh = (struct elf_lm32_link_hash_entry *) h;
1847 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1849 s = p->sec->output_section;
1850 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1854 /* If we didn't find any dynamic relocs in sections which needs the
1855 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1863 /* We must allocate the symbol in our .dynbss section, which will
1864 become part of the .bss section of the executable. There will be
1865 an entry for this symbol in the .dynsym section. The dynamic
1866 object will contain position independent code, so all references
1867 from the dynamic object to this symbol will go through the global
1868 offset table. The dynamic linker will use the .dynsym entry to
1869 determine the address it must put in the global offset table, so
1870 both the dynamic object and the regular object will refer to the
1871 same memory location for the variable. */
1873 htab = lm32_elf_hash_table (info);
1878 BFD_ASSERT (s != NULL);
1880 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1881 to copy the initial value out of the dynamic object and into the
1882 runtime process image. We need to remember the offset into the
1883 .rela.bss section we are going to use. */
1884 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1888 srel = htab->srelbss;
1889 BFD_ASSERT (srel != NULL);
1890 srel->size += sizeof (Elf32_External_Rela);
1894 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1897 /* Allocate space in .plt, .got and associated reloc sections for
1901 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1903 struct bfd_link_info *info;
1904 struct elf_lm32_link_hash_table *htab;
1905 struct elf_lm32_link_hash_entry *eh;
1906 struct elf_lm32_dyn_relocs *p;
1908 if (h->root.type == bfd_link_hash_indirect)
1911 info = (struct bfd_link_info *) inf;
1912 htab = lm32_elf_hash_table (info);
1916 eh = (struct elf_lm32_link_hash_entry *) h;
1918 if (htab->root.dynamic_sections_created
1919 && h->plt.refcount > 0)
1921 /* Make sure this symbol is output as a dynamic symbol.
1922 Undefined weak syms won't yet be marked as dynamic. */
1923 if (h->dynindx == -1
1924 && !h->forced_local)
1926 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1930 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1932 asection *s = htab->splt;
1934 /* If this is the first .plt entry, make room for the special
1937 s->size += PLT_ENTRY_SIZE;
1939 h->plt.offset = s->size;
1941 /* If this symbol is not defined in a regular file, and we are
1942 not generating a shared library, then set the symbol to this
1943 location in the .plt. This is required to make function
1944 pointers compare as equal between the normal executable and
1945 the shared library. */
1946 if (! bfd_link_pic (info)
1949 h->root.u.def.section = s;
1950 h->root.u.def.value = h->plt.offset;
1953 /* Make room for this entry. */
1954 s->size += PLT_ENTRY_SIZE;
1956 /* We also need to make an entry in the .got.plt section, which
1957 will be placed in the .got section by the linker script. */
1958 htab->sgotplt->size += 4;
1960 /* We also need to make an entry in the .rel.plt section. */
1961 htab->srelplt->size += sizeof (Elf32_External_Rela);
1965 h->plt.offset = (bfd_vma) -1;
1971 h->plt.offset = (bfd_vma) -1;
1975 if (h->got.refcount > 0)
1980 /* Make sure this symbol is output as a dynamic symbol.
1981 Undefined weak syms won't yet be marked as dynamic. */
1982 if (h->dynindx == -1
1983 && !h->forced_local)
1985 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1991 h->got.offset = s->size;
1993 dyn = htab->root.dynamic_sections_created;
1994 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1995 htab->srelgot->size += sizeof (Elf32_External_Rela);
1998 h->got.offset = (bfd_vma) -1;
2000 if (eh->dyn_relocs == NULL)
2003 /* In the shared -Bsymbolic case, discard space allocated for
2004 dynamic pc-relative relocs against symbols which turn out to be
2005 defined in regular objects. For the normal shared case, discard
2006 space for pc-relative relocs that have become local due to symbol
2007 visibility changes. */
2009 if (bfd_link_pic (info))
2015 struct elf_lm32_dyn_relocs **pp;
2017 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2019 p->count -= p->pc_count;
2028 /* Also discard relocs on undefined weak syms with non-default
2030 if (eh->dyn_relocs != NULL
2031 && h->root.type == bfd_link_hash_undefweak)
2033 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2034 eh->dyn_relocs = NULL;
2036 /* Make sure undefined weak symbols are output as a dynamic
2038 else if (h->dynindx == -1
2039 && !h->forced_local)
2041 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2048 /* For the non-shared case, discard space for relocs against
2049 symbols which turn out to need copy relocs or are not
2055 || (htab->root.dynamic_sections_created
2056 && (h->root.type == bfd_link_hash_undefweak
2057 || h->root.type == bfd_link_hash_undefined))))
2059 /* Make sure this symbol is output as a dynamic symbol.
2060 Undefined weak syms won't yet be marked as dynamic. */
2061 if (h->dynindx == -1
2062 && !h->forced_local)
2064 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2068 /* If that succeeded, we know we'll be keeping all the
2070 if (h->dynindx != -1)
2074 eh->dyn_relocs = NULL;
2079 /* Finally, allocate space. */
2080 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2082 asection *sreloc = elf_section_data (p->sec)->sreloc;
2083 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2089 /* Find any dynamic relocs that apply to read-only sections. */
2092 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2094 struct elf_lm32_link_hash_entry *eh;
2095 struct elf_lm32_dyn_relocs *p;
2097 eh = (struct elf_lm32_link_hash_entry *) h;
2098 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2100 asection *s = p->sec->output_section;
2102 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2104 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2106 info->flags |= DF_TEXTREL;
2108 /* Not an error, just cut short the traversal. */
2115 /* Set the sizes of the dynamic sections. */
2118 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2119 struct bfd_link_info *info)
2121 struct elf_lm32_link_hash_table *htab;
2127 htab = lm32_elf_hash_table (info);
2131 dynobj = htab->root.dynobj;
2132 BFD_ASSERT (dynobj != NULL);
2134 if (htab->root.dynamic_sections_created)
2136 /* Set the contents of the .interp section to the interpreter. */
2137 if (bfd_link_executable (info) && !info->nointerp)
2139 s = bfd_get_linker_section (dynobj, ".interp");
2140 BFD_ASSERT (s != NULL);
2141 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2142 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2146 /* Set up .got offsets for local syms, and space for local dynamic
2148 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2150 bfd_signed_vma *local_got;
2151 bfd_signed_vma *end_local_got;
2152 bfd_size_type locsymcount;
2153 Elf_Internal_Shdr *symtab_hdr;
2156 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2159 for (s = ibfd->sections; s != NULL; s = s->next)
2161 struct elf_lm32_dyn_relocs *p;
2163 for (p = ((struct elf_lm32_dyn_relocs *)
2164 elf_section_data (s)->local_dynrel);
2168 if (! bfd_is_abs_section (p->sec)
2169 && bfd_is_abs_section (p->sec->output_section))
2171 /* Input section has been discarded, either because
2172 it is a copy of a linkonce section or due to
2173 linker script /DISCARD/, so we'll be discarding
2176 else if (p->count != 0)
2178 srel = elf_section_data (p->sec)->sreloc;
2179 srel->size += p->count * sizeof (Elf32_External_Rela);
2180 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2181 info->flags |= DF_TEXTREL;
2186 local_got = elf_local_got_refcounts (ibfd);
2190 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2191 locsymcount = symtab_hdr->sh_info;
2192 end_local_got = local_got + locsymcount;
2194 srel = htab->srelgot;
2195 for (; local_got < end_local_got; ++local_got)
2199 *local_got = s->size;
2201 if (bfd_link_pic (info))
2202 srel->size += sizeof (Elf32_External_Rela);
2205 *local_got = (bfd_vma) -1;
2209 /* Allocate global sym .plt and .got entries, and space for global
2210 sym dynamic relocs. */
2211 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2213 /* We now have determined the sizes of the various dynamic sections.
2214 Allocate memory for them. */
2216 for (s = dynobj->sections; s != NULL; s = s->next)
2218 if ((s->flags & SEC_LINKER_CREATED) == 0)
2223 || s == htab->sgotplt
2224 || s == htab->sdynbss)
2226 /* Strip this section if we don't need it; see the
2229 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2231 if (s->size != 0 && s != htab->srelplt)
2234 /* We use the reloc_count field as a counter if we need
2235 to copy relocs into the output file. */
2239 /* It's not one of our sections, so don't allocate space. */
2244 /* If we don't need this section, strip it from the
2245 output file. This is mostly to handle .rela.bss and
2246 .rela.plt. We must create both sections in
2247 create_dynamic_sections, because they must be created
2248 before the linker maps input sections to output
2249 sections. The linker does that before
2250 adjust_dynamic_symbol is called, and it is that
2251 function which decides whether anything needs to go
2252 into these sections. */
2253 s->flags |= SEC_EXCLUDE;
2257 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2260 /* Allocate memory for the section contents. We use bfd_zalloc
2261 here in case unused entries are not reclaimed before the
2262 section's contents are written out. This should not happen,
2263 but this way if it does, we get a R_LM32_NONE reloc instead
2265 s->contents = bfd_zalloc (dynobj, s->size);
2266 if (s->contents == NULL)
2270 if (htab->root.dynamic_sections_created)
2272 /* Add some entries to the .dynamic section. We fill in the
2273 values later, in lm32_elf_finish_dynamic_sections, but we
2274 must add the entries now so that we get the correct size for
2275 the .dynamic section. The DT_DEBUG entry is filled in by the
2276 dynamic linker and used by the debugger. */
2277 #define add_dynamic_entry(TAG, VAL) \
2278 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2280 if (bfd_link_executable (info))
2282 if (! add_dynamic_entry (DT_DEBUG, 0))
2286 if (htab->splt->size != 0)
2288 if (! add_dynamic_entry (DT_PLTGOT, 0)
2289 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2290 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2291 || ! add_dynamic_entry (DT_JMPREL, 0))
2297 if (! add_dynamic_entry (DT_RELA, 0)
2298 || ! add_dynamic_entry (DT_RELASZ, 0)
2299 || ! add_dynamic_entry (DT_RELAENT,
2300 sizeof (Elf32_External_Rela)))
2303 /* If any dynamic relocs apply to a read-only section,
2304 then we need a DT_TEXTREL entry. */
2305 if ((info->flags & DF_TEXTREL) == 0)
2306 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2309 if ((info->flags & DF_TEXTREL) != 0)
2311 if (! add_dynamic_entry (DT_TEXTREL, 0))
2316 #undef add_dynamic_entry
2318 /* Allocate .rofixup section. */
2319 if (IS_FDPIC (output_bfd))
2321 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2322 int rgot_weak_count = 0;
2325 /* Look for deleted sections. */
2326 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2328 for (s = ibfd->sections; s != NULL; s = s->next)
2332 /* Count relocs that need .rofixup entires. */
2333 Elf_Internal_Rela *internal_relocs, *end;
2334 internal_relocs = elf_section_data (s)->relocs;
2335 if (internal_relocs == NULL)
2336 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2337 if (internal_relocs != NULL)
2339 end = internal_relocs + s->reloc_count;
2340 while (internal_relocs < end)
2342 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2343 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2344 unsigned long r_symndx;
2345 struct elf_link_hash_entry *h;
2347 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2348 sym_hashes = elf_sym_hashes (ibfd);
2349 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2351 if (r_symndx < symtab_hdr->sh_info)
2356 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2357 while (h->root.type == bfd_link_hash_indirect
2358 || h->root.type == bfd_link_hash_warning)
2359 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2362 /* Don't generate entries for weak symbols. */
2363 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2365 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2367 switch (ELF32_R_TYPE (internal_relocs->r_info))
2380 struct weak_symbol_list *current, *new_entry;
2381 /* Is this symbol already in the list? */
2382 for (current = list_start; current; current = current->next)
2384 if (!strcmp (current->name, h->root.root.string))
2387 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2389 /* Will this have an entry in the GOT. */
2390 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2392 /* Create a new entry. */
2393 new_entry = malloc (sizeof (struct weak_symbol_list));
2396 new_entry->name = h->root.root.string;
2397 new_entry->next = NULL;
2399 if (list_start == NULL)
2401 list_start = new_entry;
2402 list_end = new_entry;
2406 list_end->next = new_entry;
2407 list_end = new_entry;
2409 /* Increase count of undefined weak symbols in the got. */
2425 list_end = list_start->next;
2427 list_start = list_end;
2430 /* Size sections. */
2431 lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2432 if (lm32fdpic_fixup32_section (info)->size == 0)
2433 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2436 lm32fdpic_fixup32_section (info)->contents =
2437 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2438 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2446 /* Create dynamic sections when linking against a dynamic object. */
2449 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2451 struct elf_lm32_link_hash_table *htab;
2452 flagword flags, pltflags;
2454 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2455 int ptralign = 2; /* 32bit */
2457 htab = lm32_elf_hash_table (info);
2461 /* Make sure we have a GOT - For the case where we have a dynamic object
2462 but none of the relocs in check_relocs */
2463 if (! create_got_section (abfd, info))
2465 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2467 if (! create_rofixup_section (abfd, info))
2471 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2472 .rel[a].bss sections. */
2473 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2474 | SEC_LINKER_CREATED);
2477 pltflags |= SEC_CODE;
2478 if (bed->plt_not_loaded)
2479 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2480 if (bed->plt_readonly)
2481 pltflags |= SEC_READONLY;
2483 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2486 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2489 if (bed->want_plt_sym)
2491 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2493 struct bfd_link_hash_entry *bh = NULL;
2494 struct elf_link_hash_entry *h;
2496 if (! (_bfd_generic_link_add_one_symbol
2497 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2498 (bfd_vma) 0, NULL, FALSE,
2499 get_elf_backend_data (abfd)->collect, &bh)))
2501 h = (struct elf_link_hash_entry *) bh;
2503 h->type = STT_OBJECT;
2504 htab->root.hplt = h;
2506 if (bfd_link_pic (info)
2507 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2511 s = bfd_make_section_anyway_with_flags (abfd,
2512 bed->default_use_rela_p
2513 ? ".rela.plt" : ".rel.plt",
2514 flags | SEC_READONLY);
2517 || ! bfd_set_section_alignment (abfd, s, ptralign))
2520 if (htab->sgot == NULL
2521 && ! create_got_section (abfd, info))
2524 if (bed->want_dynbss)
2526 /* The .dynbss section is a place to put symbols which are defined
2527 by dynamic objects, are referenced by regular objects, and are
2528 not functions. We must allocate space for them in the process
2529 image and use a R_*_COPY reloc to tell the dynamic linker to
2530 initialize them at run time. The linker script puts the .dynbss
2531 section into the .bss section of the final image. */
2532 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2533 SEC_ALLOC | SEC_LINKER_CREATED);
2537 /* The .rel[a].bss section holds copy relocs. This section is not
2538 normally needed. We need to create it here, though, so that the
2539 linker will map it to an output section. We can't just create it
2540 only if we need it, because we will not know whether we need it
2541 until we have seen all the input files, and the first time the
2542 main linker code calls BFD after examining all the input files
2543 (size_dynamic_sections) the input sections have already been
2544 mapped to the output sections. If the section turns out not to
2545 be needed, we can discard it later. We will never need this
2546 section when generating a shared object, since they do not use
2548 if (! bfd_link_pic (info))
2550 s = bfd_make_section_anyway_with_flags (abfd,
2551 (bed->default_use_rela_p
2552 ? ".rela.bss" : ".rel.bss"),
2553 flags | SEC_READONLY);
2556 || ! bfd_set_section_alignment (abfd, s, ptralign))
2564 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2567 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2568 struct elf_link_hash_entry *dir,
2569 struct elf_link_hash_entry *ind)
2571 struct elf_lm32_link_hash_entry * edir;
2572 struct elf_lm32_link_hash_entry * eind;
2574 edir = (struct elf_lm32_link_hash_entry *) dir;
2575 eind = (struct elf_lm32_link_hash_entry *) ind;
2577 if (eind->dyn_relocs != NULL)
2579 if (edir->dyn_relocs != NULL)
2581 struct elf_lm32_dyn_relocs **pp;
2582 struct elf_lm32_dyn_relocs *p;
2584 /* Add reloc counts against the indirect sym to the direct sym
2585 list. Merge any entries against the same section. */
2586 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2588 struct elf_lm32_dyn_relocs *q;
2590 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2591 if (q->sec == p->sec)
2593 q->pc_count += p->pc_count;
2594 q->count += p->count;
2601 *pp = edir->dyn_relocs;
2604 edir->dyn_relocs = eind->dyn_relocs;
2605 eind->dyn_relocs = NULL;
2608 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2612 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2614 if (!bfd_link_relocatable (info))
2616 if (!bfd_elf_stack_segment_size (output_bfd, info,
2617 "__stacksize", DEFAULT_STACK_SIZE))
2620 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2622 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2629 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2633 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2634 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2637 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2640 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2641 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2644 /* Copy the stack size. */
2645 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2646 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2648 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2650 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2651 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2653 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2655 /* Rewrite the phdrs, since we're only called after they were first written. */
2656 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2657 ->s->sizeof_ehdr, SEEK_SET) != 0
2658 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2659 elf_elfheader (obfd)->e_phnum) != 0)
2671 #define ELF_ARCH bfd_arch_lm32
2672 #define ELF_TARGET_ID LM32_ELF_DATA
2673 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2674 #define ELF_MAXPAGESIZE 0x1000
2676 #define TARGET_BIG_SYM lm32_elf32_vec
2677 #define TARGET_BIG_NAME "elf32-lm32"
2679 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2680 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2681 #define elf_info_to_howto lm32_info_to_howto_rela
2682 #define elf_info_to_howto_rel 0
2683 #define elf_backend_rela_normal 1
2684 #define elf_backend_object_p lm32_elf_object_p
2685 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2686 #define elf_backend_stack_align 8
2687 #define elf_backend_can_gc_sections 1
2688 #define elf_backend_can_refcount 1
2689 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2690 #define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook
2691 #define elf_backend_plt_readonly 1
2692 #define elf_backend_want_got_plt 1
2693 #define elf_backend_want_plt_sym 0
2694 #define elf_backend_got_header_size 12
2695 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2696 #define elf_backend_check_relocs lm32_elf_check_relocs
2697 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2698 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2699 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2700 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2701 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2702 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2703 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2704 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2705 #define elf_backend_relocate_section lm32_elf_relocate_section
2707 #include "elf32-target.h"
2709 #undef ELF_MAXPAGESIZE
2710 #define ELF_MAXPAGESIZE 0x4000
2713 #undef TARGET_BIG_SYM
2714 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2715 #undef TARGET_BIG_NAME
2716 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2718 #define elf32_bed elf32_lm32fdpic_bed
2720 #undef elf_backend_always_size_sections
2721 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2722 #undef bfd_elf32_bfd_copy_private_bfd_data
2723 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2725 #include "elf32-target.h"