1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2020 Free Software Foundation, Inc.
3 Contributed by Jon Beniston <jon@beniston.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #define DEFAULT_STACK_SIZE 0x20000
30 #define PLT_ENTRY_SIZE 20
32 #define PLT0_ENTRY_WORD0 0
33 #define PLT0_ENTRY_WORD1 0
34 #define PLT0_ENTRY_WORD2 0
35 #define PLT0_ENTRY_WORD3 0
36 #define PLT0_ENTRY_WORD4 0
38 #define PLT0_PIC_ENTRY_WORD0 0
39 #define PLT0_PIC_ENTRY_WORD1 0
40 #define PLT0_PIC_ENTRY_WORD2 0
41 #define PLT0_PIC_ENTRY_WORD3 0
42 #define PLT0_PIC_ENTRY_WORD4 0
44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
46 extern const bfd_target lm32_elf32_fdpic_vec
;
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
53 /* lm32 ELF linker hash table. */
55 struct elf_lm32_link_hash_table
57 struct elf_link_hash_table root
;
59 /* Short-cuts to get to dynamic linker sections. */
67 /* Get the lm32 ELF linker hash table from a link_info structure. */
69 #define lm32_elf_hash_table(p) \
70 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
71 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
73 #define lm32fdpic_got_section(info) \
74 (lm32_elf_hash_table (info)->root.sgot)
75 #define lm32fdpic_gotrel_section(info) \
76 (lm32_elf_hash_table (info)->root.srelgot)
77 #define lm32fdpic_fixup32_section(info) \
78 (lm32_elf_hash_table (info)->sfixup32)
80 struct weak_symbol_list
83 struct weak_symbol_list
*next
;
86 /* Create an lm32 ELF linker hash table. */
88 static struct bfd_link_hash_table
*
89 lm32_elf_link_hash_table_create (bfd
*abfd
)
91 struct elf_lm32_link_hash_table
*ret
;
92 size_t amt
= sizeof (struct elf_lm32_link_hash_table
);
94 ret
= bfd_zmalloc (amt
);
98 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
99 _bfd_elf_link_hash_newfunc
,
100 sizeof (struct elf_link_hash_entry
),
107 return &ret
->root
.root
;
110 /* Add a fixup to the ROFIXUP section. */
113 _lm32fdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma relocation
)
115 bfd_vma fixup_offset
;
117 if (rofixup
->flags
& SEC_EXCLUDE
)
120 fixup_offset
= rofixup
->reloc_count
* 4;
121 if (rofixup
->contents
)
123 BFD_ASSERT (fixup_offset
< rofixup
->size
);
124 if (fixup_offset
< rofixup
->size
)
125 bfd_put_32 (output_bfd
, relocation
, rofixup
->contents
+ fixup_offset
);
127 rofixup
->reloc_count
++;
132 /* Create .rofixup sections in DYNOBJ, and set up
133 shortcuts to them in our hash table. */
136 create_rofixup_section (bfd
*dynobj
, struct bfd_link_info
*info
)
138 struct elf_lm32_link_hash_table
*htab
;
139 htab
= lm32_elf_hash_table (info
);
144 /* Fixup section for R_LM32_32 relocs. */
145 lm32fdpic_fixup32_section (info
)
146 = bfd_make_section_anyway_with_flags (dynobj
,
154 if (lm32fdpic_fixup32_section (info
) == NULL
155 || !bfd_set_section_alignment (lm32fdpic_fixup32_section (info
), 2))
161 static reloc_howto_type lm32_elf_howto_table
[] =
163 /* This reloc does nothing. */
164 HOWTO (R_LM32_NONE
, /* type */
166 3, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE
, /* pc_relative */
170 complain_overflow_dont
, /* complain_on_overflow */
171 bfd_elf_generic_reloc
, /* special_function */
172 "R_LM32_NONE", /* name */
173 FALSE
, /* partial_inplace */
176 FALSE
), /* pcrel_offset */
178 /* An 8 bit absolute relocation. */
179 HOWTO (R_LM32_8
, /* type */
181 0, /* size (0 = byte, 1 = short, 2 = long) */
183 FALSE
, /* pc_relative */
185 complain_overflow_bitfield
,/* complain_on_overflow */
186 bfd_elf_generic_reloc
, /* special_function */
187 "R_LM32_8", /* name */
188 FALSE
, /* partial_inplace */
191 FALSE
), /* pcrel_offset */
193 /* A 16 bit absolute relocation. */
194 HOWTO (R_LM32_16
, /* type */
196 1, /* size (0 = byte, 1 = short, 2 = long) */
198 FALSE
, /* pc_relative */
200 complain_overflow_bitfield
,/* complain_on_overflow */
201 bfd_elf_generic_reloc
, /* special_function */
202 "R_LM32_16", /* name */
203 FALSE
, /* partial_inplace */
205 0xffff, /* dst_mask */
206 FALSE
), /* pcrel_offset */
208 /* A 32 bit absolute relocation. */
209 HOWTO (R_LM32_32
, /* type */
211 2, /* size (0 = byte, 1 = short, 2 = long) */
213 FALSE
, /* pc_relative */
215 complain_overflow_bitfield
,/* complain_on_overflow */
216 bfd_elf_generic_reloc
, /* special_function */
217 "R_LM32_32", /* name */
218 FALSE
, /* partial_inplace */
220 0xffffffff, /* dst_mask */
221 FALSE
), /* pcrel_offset */
223 HOWTO (R_LM32_HI16
, /* type */
225 2, /* size (0 = byte, 1 = short, 2 = long) */
227 FALSE
, /* pc_relative */
229 complain_overflow_bitfield
,/* complain_on_overflow */
230 bfd_elf_generic_reloc
, /* special_function */
231 "R_LM32_HI16", /* name */
232 FALSE
, /* partial_inplace */
234 0xffff, /* dst_mask */
235 FALSE
), /* pcrel_offset */
237 HOWTO (R_LM32_LO16
, /* type */
239 2, /* size (0 = byte, 1 = short, 2 = long) */
241 FALSE
, /* pc_relative */
243 complain_overflow_dont
, /* complain_on_overflow */
244 bfd_elf_generic_reloc
, /* special_function */
245 "R_LM32_LO16", /* name */
246 FALSE
, /* partial_inplace */
248 0xffff, /* dst_mask */
249 FALSE
), /* pcrel_offset */
251 HOWTO (R_LM32_GPREL16
, /* type */
253 2, /* size (0 = byte, 1 = short, 2 = long) */
255 FALSE
, /* pc_relative */
257 complain_overflow_dont
, /* complain_on_overflow */
258 lm32_elf_gprel_reloc
, /* special_function */
259 "R_LM32_GPREL16", /* name */
260 FALSE
, /* partial_inplace */
262 0xffff, /* dst_mask */
263 FALSE
), /* pcrel_offset */
265 HOWTO (R_LM32_CALL
, /* type */
267 2, /* size (0 = byte, 1 = short, 2 = long) */
269 TRUE
, /* pc_relative */
271 complain_overflow_signed
, /* complain_on_overflow */
272 bfd_elf_generic_reloc
, /* special_function */
273 "R_LM32_CALL", /* name */
274 FALSE
, /* partial_inplace */
276 0x3ffffff, /* dst_mask */
277 TRUE
), /* pcrel_offset */
279 HOWTO (R_LM32_BRANCH
, /* type */
281 2, /* size (0 = byte, 1 = short, 2 = long) */
283 TRUE
, /* pc_relative */
285 complain_overflow_signed
, /* complain_on_overflow */
286 bfd_elf_generic_reloc
, /* special_function */
287 "R_LM32_BRANCH", /* name */
288 FALSE
, /* partial_inplace */
290 0xffff, /* dst_mask */
291 TRUE
), /* pcrel_offset */
293 /* GNU extension to record C++ vtable hierarchy. */
294 HOWTO (R_LM32_GNU_VTINHERIT
, /* type */
296 2, /* size (0 = byte, 1 = short, 2 = long) */
298 FALSE
, /* pc_relative */
300 complain_overflow_dont
, /* complain_on_overflow */
301 NULL
, /* special_function */
302 "R_LM32_GNU_VTINHERIT", /* name */
303 FALSE
, /* partial_inplace */
306 FALSE
), /* pcrel_offset */
308 /* GNU extension to record C++ vtable member usage. */
309 HOWTO (R_LM32_GNU_VTENTRY
, /* type */
311 2, /* size (0 = byte, 1 = short, 2 = long) */
313 FALSE
, /* pc_relative */
315 complain_overflow_dont
, /* complain_on_overflow */
316 _bfd_elf_rel_vtable_reloc_fn
,/* special_function */
317 "R_LM32_GNU_VTENTRY", /* name */
318 FALSE
, /* partial_inplace */
321 FALSE
), /* pcrel_offset */
323 HOWTO (R_LM32_16_GOT
, /* type */
325 2, /* size (0 = byte, 1 = short, 2 = long) */
327 FALSE
, /* pc_relative */
329 complain_overflow_signed
, /* complain_on_overflow */
330 bfd_elf_generic_reloc
, /* special_function */
331 "R_LM32_16_GOT", /* name */
332 FALSE
, /* partial_inplace */
334 0xffff, /* dst_mask */
335 FALSE
), /* pcrel_offset */
337 HOWTO (R_LM32_GOTOFF_HI16
, /* type */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
341 FALSE
, /* pc_relative */
343 complain_overflow_dont
, /* complain_on_overflow */
344 bfd_elf_generic_reloc
, /* special_function */
345 "R_LM32_GOTOFF_HI16", /* name */
346 FALSE
, /* partial_inplace */
347 0xffff, /* src_mask */
348 0xffff, /* dst_mask */
349 FALSE
), /* pcrel_offset */
351 HOWTO (R_LM32_GOTOFF_LO16
, /* type */
353 2, /* size (0 = byte, 1 = short, 2 = long) */
355 FALSE
, /* pc_relative */
357 complain_overflow_dont
, /* complain_on_overflow */
358 bfd_elf_generic_reloc
, /* special_function */
359 "R_LM32_GOTOFF_LO16", /* name */
360 FALSE
, /* partial_inplace */
361 0xffff, /* src_mask */
362 0xffff, /* dst_mask */
363 FALSE
), /* pcrel_offset */
365 HOWTO (R_LM32_COPY
, /* type */
367 2, /* size (0 = byte, 1 = short, 2 = long) */
369 FALSE
, /* pc_relative */
371 complain_overflow_bitfield
, /* complain_on_overflow */
372 bfd_elf_generic_reloc
, /* special_function */
373 "R_LM32_COPY", /* name */
374 FALSE
, /* partial_inplace */
375 0xffffffff, /* src_mask */
376 0xffffffff, /* dst_mask */
377 FALSE
), /* pcrel_offset */
379 HOWTO (R_LM32_GLOB_DAT
, /* type */
381 2, /* size (0 = byte, 1 = short, 2 = long) */
383 FALSE
, /* pc_relative */
385 complain_overflow_bitfield
, /* complain_on_overflow */
386 bfd_elf_generic_reloc
, /* special_function */
387 "R_LM32_GLOB_DAT", /* name */
388 FALSE
, /* partial_inplace */
389 0xffffffff, /* src_mask */
390 0xffffffff, /* dst_mask */
391 FALSE
), /* pcrel_offset */
393 HOWTO (R_LM32_JMP_SLOT
, /* type */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
397 FALSE
, /* pc_relative */
399 complain_overflow_bitfield
, /* complain_on_overflow */
400 bfd_elf_generic_reloc
, /* special_function */
401 "R_LM32_JMP_SLOT", /* name */
402 FALSE
, /* partial_inplace */
403 0xffffffff, /* src_mask */
404 0xffffffff, /* dst_mask */
405 FALSE
), /* pcrel_offset */
407 HOWTO (R_LM32_RELATIVE
, /* type */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
411 FALSE
, /* pc_relative */
413 complain_overflow_bitfield
, /* complain_on_overflow */
414 bfd_elf_generic_reloc
, /* special_function */
415 "R_LM32_RELATIVE", /* name */
416 FALSE
, /* partial_inplace */
417 0xffffffff, /* src_mask */
418 0xffffffff, /* dst_mask */
419 FALSE
), /* pcrel_offset */
423 /* Map BFD reloc types to lm32 ELF reloc types. */
425 struct lm32_reloc_map
427 bfd_reloc_code_real_type bfd_reloc_val
;
428 unsigned char elf_reloc_val
;
431 static const struct lm32_reloc_map lm32_reloc_map
[] =
433 { BFD_RELOC_NONE
, R_LM32_NONE
},
434 { BFD_RELOC_8
, R_LM32_8
},
435 { BFD_RELOC_16
, R_LM32_16
},
436 { BFD_RELOC_32
, R_LM32_32
},
437 { BFD_RELOC_HI16
, R_LM32_HI16
},
438 { BFD_RELOC_LO16
, R_LM32_LO16
},
439 { BFD_RELOC_GPREL16
, R_LM32_GPREL16
},
440 { BFD_RELOC_LM32_CALL
, R_LM32_CALL
},
441 { BFD_RELOC_LM32_BRANCH
, R_LM32_BRANCH
},
442 { BFD_RELOC_VTABLE_INHERIT
, R_LM32_GNU_VTINHERIT
},
443 { BFD_RELOC_VTABLE_ENTRY
, R_LM32_GNU_VTENTRY
},
444 { BFD_RELOC_LM32_16_GOT
, R_LM32_16_GOT
},
445 { BFD_RELOC_LM32_GOTOFF_HI16
, R_LM32_GOTOFF_HI16
},
446 { BFD_RELOC_LM32_GOTOFF_LO16
, R_LM32_GOTOFF_LO16
},
447 { BFD_RELOC_LM32_COPY
, R_LM32_COPY
},
448 { BFD_RELOC_LM32_GLOB_DAT
, R_LM32_GLOB_DAT
},
449 { BFD_RELOC_LM32_JMP_SLOT
, R_LM32_JMP_SLOT
},
450 { BFD_RELOC_LM32_RELATIVE
, R_LM32_RELATIVE
},
453 static reloc_howto_type
*
454 lm32_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
455 bfd_reloc_code_real_type code
)
459 for (i
= 0; i
< sizeof (lm32_reloc_map
) / sizeof (lm32_reloc_map
[0]); i
++)
460 if (lm32_reloc_map
[i
].bfd_reloc_val
== code
)
461 return &lm32_elf_howto_table
[lm32_reloc_map
[i
].elf_reloc_val
];
465 static reloc_howto_type
*
466 lm32_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
472 i
< sizeof (lm32_elf_howto_table
) / sizeof (lm32_elf_howto_table
[0]);
474 if (lm32_elf_howto_table
[i
].name
!= NULL
475 && strcasecmp (lm32_elf_howto_table
[i
].name
, r_name
) == 0)
476 return &lm32_elf_howto_table
[i
];
482 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
485 lm32_info_to_howto_rela (bfd
*abfd
,
487 Elf_Internal_Rela
*dst
)
491 r_type
= ELF32_R_TYPE (dst
->r_info
);
492 if (r_type
>= (unsigned int) R_LM32_max
)
494 /* xgettext:c-format */
495 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
497 bfd_set_error (bfd_error_bad_value
);
500 cache_ptr
->howto
= &lm32_elf_howto_table
[r_type
];
504 /* Set the right machine number for an Lattice Mico32 ELF file. */
507 lm32_elf_object_p (bfd
*abfd
)
509 return bfd_default_set_arch_mach (abfd
, bfd_arch_lm32
, bfd_mach_lm32
);
512 /* Set machine type flags just before file is written out. */
515 lm32_elf_final_write_processing (bfd
*abfd
)
517 elf_elfheader (abfd
)->e_machine
= EM_LATTICEMICO32
;
518 elf_elfheader (abfd
)->e_flags
&=~ EF_LM32_MACH
;
519 switch (bfd_get_mach (abfd
))
522 elf_elfheader (abfd
)->e_flags
|= E_LM32_MACH
;
527 return _bfd_elf_final_write_processing (abfd
);
530 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
531 dangerous relocation. */
534 lm32_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
540 /* If we've already figured out what GP will be, just return it. */
541 *pgp
= _bfd_get_gp_value (output_bfd
);
545 count
= bfd_get_symcount (output_bfd
);
546 sym
= bfd_get_outsymbols (output_bfd
);
548 /* The linker script will have created a symbol named `_gp' with the
549 appropriate value. */
554 for (i
= 0; i
< count
; i
++, sym
++)
558 name
= bfd_asymbol_name (*sym
);
559 if (*name
== '_' && strcmp (name
, "_gp") == 0)
561 *pgp
= bfd_asymbol_value (*sym
);
562 _bfd_set_gp_value (output_bfd
, *pgp
);
570 /* Only get the error once. */
572 _bfd_set_gp_value (output_bfd
, *pgp
);
579 /* We have to figure out the gp value, so that we can adjust the
580 symbol value correctly. We look up the symbol _gp in the output
581 BFD. If we can't find it, we're stuck. We cache it in the ELF
582 target data. We don't need to adjust the symbol value for an
583 external symbol if we are producing relocatable output. */
585 static bfd_reloc_status_type
586 lm32_elf_final_gp (bfd
*output_bfd
, asymbol
*symbol
, bfd_boolean relocatable
,
587 char **error_message
, bfd_vma
*pgp
)
589 if (bfd_is_und_section (symbol
->section
) && !relocatable
)
592 return bfd_reloc_undefined
;
595 *pgp
= _bfd_get_gp_value (output_bfd
);
596 if (*pgp
== 0 && (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0))
600 /* Make up a value. */
601 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
602 _bfd_set_gp_value (output_bfd
, *pgp
);
604 else if (!lm32_elf_assign_gp (output_bfd
, pgp
))
608 _("global pointer relative relocation when _gp not defined");
609 return bfd_reloc_dangerous
;
616 static bfd_reloc_status_type
617 lm32_elf_do_gprel_relocate (bfd
*abfd
,
618 reloc_howto_type
*howto
,
619 asection
*input_section ATTRIBUTE_UNUSED
,
622 bfd_vma symbol_value
,
625 return _bfd_final_link_relocate (howto
, abfd
, input_section
,
626 data
, offset
, symbol_value
, addend
);
629 static bfd_reloc_status_type
630 lm32_elf_gprel_reloc (bfd
*abfd
,
631 arelent
*reloc_entry
,
634 asection
*input_section
,
640 bfd_reloc_status_type r
;
642 if (output_bfd
!= (bfd
*) NULL
643 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
644 && (!reloc_entry
->howto
->partial_inplace
|| reloc_entry
->addend
== 0))
646 reloc_entry
->address
+= input_section
->output_offset
;
650 if (output_bfd
!= NULL
)
653 relocation
= symbol
->value
654 + symbol
->section
->output_section
->vma
+ symbol
->section
->output_offset
;
657 lm32_elf_final_gp (abfd
, symbol
, FALSE
, msg
, &gp
)) == bfd_reloc_ok
)
659 relocation
= relocation
+ reloc_entry
->addend
- gp
;
660 reloc_entry
->addend
= 0;
661 if ((signed) relocation
< -32768 || (signed) relocation
> 32767)
663 *msg
= _("global pointer relative address out of range");
664 r
= bfd_reloc_outofrange
;
668 r
= lm32_elf_do_gprel_relocate (abfd
, reloc_entry
->howto
,
670 data
, reloc_entry
->address
,
671 relocation
, reloc_entry
->addend
);
678 /* Find the segment number in which OSEC, and output section, is
682 _lm32fdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
684 struct elf_segment_map
*m
;
685 Elf_Internal_Phdr
*p
;
687 /* Find the segment that contains the output_section. */
688 for (m
= elf_seg_map (output_bfd
), p
= elf_tdata (output_bfd
)->phdr
;
694 for (i
= m
->count
- 1; i
>= 0; i
--)
695 if (m
->sections
[i
] == osec
)
702 return p
- elf_tdata (output_bfd
)->phdr
;
705 /* Determine if an output section is read-only. */
707 inline static bfd_boolean
708 _lm32fdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
710 unsigned seg
= _lm32fdpic_osec_to_segment (output_bfd
, osec
);
712 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
715 /* Relocate a section */
718 lm32_elf_relocate_section (bfd
*output_bfd
,
719 struct bfd_link_info
*info
,
721 asection
*input_section
,
723 Elf_Internal_Rela
*relocs
,
724 Elf_Internal_Sym
*local_syms
,
725 asection
**local_sections
)
727 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
728 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
729 Elf_Internal_Rela
*rel
, *relend
;
730 struct elf_lm32_link_hash_table
*htab
= lm32_elf_hash_table (info
);
731 bfd_vma
*local_got_offsets
;
737 local_got_offsets
= elf_local_got_offsets (input_bfd
);
739 sgot
= htab
->root
.sgot
;
741 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
742 sym_hashes
= elf_sym_hashes (input_bfd
);
745 relend
= relocs
+ input_section
->reloc_count
;
746 for (; rel
< relend
; rel
++)
748 reloc_howto_type
*howto
;
750 unsigned long r_symndx
;
751 Elf_Internal_Sym
*sym
;
753 struct elf_link_hash_entry
*h
;
756 bfd_reloc_status_type r
;
757 const char *name
= NULL
;
759 r_symndx
= ELF32_R_SYM (rel
->r_info
);
760 r_type
= ELF32_R_TYPE (rel
->r_info
);
762 if (r_type
== R_LM32_GNU_VTENTRY
763 || r_type
== R_LM32_GNU_VTINHERIT
)
770 howto
= lm32_elf_howto_table
+ r_type
;
772 if (r_symndx
< symtab_hdr
->sh_info
)
774 /* It's a local symbol. */
775 sym
= local_syms
+ r_symndx
;
776 sec
= local_sections
[r_symndx
];
777 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
778 name
= bfd_elf_string_from_elf_section
779 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
780 name
= name
== NULL
? bfd_section_name (sec
) : name
;
784 /* It's a global symbol. */
785 bfd_boolean unresolved_reloc
;
786 bfd_boolean warned
, ignored
;
788 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
789 r_symndx
, symtab_hdr
, sym_hashes
,
791 unresolved_reloc
, warned
, ignored
);
792 name
= h
->root
.root
.string
;
795 if (sec
!= NULL
&& discarded_section (sec
))
796 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
797 rel
, 1, relend
, howto
, 0, contents
);
799 if (bfd_link_relocatable (info
))
801 /* This is a relocatable link. We don't have to change
802 anything, unless the reloc is against a section symbol,
803 in which case we have to adjust according to where the
804 section symbol winds up in the output section. */
805 if (sym
== NULL
|| ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
808 /* If partial_inplace, we need to store any additional addend
809 back in the section. */
810 if (! howto
->partial_inplace
)
813 /* Shouldn't reach here. */
822 if (!lm32_elf_assign_gp (output_bfd
, &gp
))
823 r
= bfd_reloc_dangerous
;
826 relocation
= relocation
+ rel
->r_addend
- gp
;
828 if ((signed)relocation
< -32768 || (signed)relocation
> 32767)
829 r
= bfd_reloc_outofrange
;
832 r
= _bfd_final_link_relocate (howto
, input_bfd
,
833 input_section
, contents
,
834 rel
->r_offset
, relocation
,
840 /* Relocation is to the entry for this symbol in the global
842 BFD_ASSERT (sgot
!= NULL
);
849 BFD_ASSERT (off
!= (bfd_vma
) -1);
851 dyn
= htab
->root
.dynamic_sections_created
;
852 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
855 || (bfd_link_pic (info
)
861 /* This is actually a static link, or it is a
862 -Bsymbolic link and the symbol is defined
863 locally, or the symbol was forced to be local
864 because of a version file. We must initialize
865 this entry in the global offset table. Since the
866 offset must always be a multiple of 4, we use the
867 least significant bit to record whether we have
868 initialized it already.
870 When doing a dynamic link, we create a .rela.got
871 relocation entry to initialize the value. This
872 is done in the finish_dynamic_symbol routine. */
877 /* Write entry in GOT */
878 bfd_put_32 (output_bfd
, relocation
,
879 sgot
->contents
+ off
);
880 /* Create entry in .rofixup pointing to GOT entry. */
881 if (IS_FDPIC (output_bfd
) && h
->root
.type
!= bfd_link_hash_undefweak
)
883 _lm32fdpic_add_rofixup (output_bfd
,
884 lm32fdpic_fixup32_section
886 sgot
->output_section
->vma
887 + sgot
->output_offset
890 /* Mark GOT entry as having been written. */
895 relocation
= sgot
->output_offset
+ off
;
902 BFD_ASSERT (local_got_offsets
!= NULL
903 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
905 /* Get offset into GOT table. */
906 off
= local_got_offsets
[r_symndx
];
908 /* The offset must always be a multiple of 4. We use
909 the least significant bit to record whether we have
910 already processed this entry. */
915 /* Write entry in GOT. */
916 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
917 /* Create entry in .rofixup pointing to GOT entry. */
918 if (IS_FDPIC (output_bfd
))
920 _lm32fdpic_add_rofixup (output_bfd
,
921 lm32fdpic_fixup32_section
923 sgot
->output_section
->vma
924 + sgot
->output_offset
928 if (bfd_link_pic (info
))
931 Elf_Internal_Rela outrel
;
933 /* We need to generate a R_LM32_RELATIVE reloc
934 for the dynamic linker. */
935 srelgot
= htab
->root
.srelgot
;
936 BFD_ASSERT (srelgot
!= NULL
);
938 outrel
.r_offset
= (sgot
->output_section
->vma
939 + sgot
->output_offset
941 outrel
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
942 outrel
.r_addend
= relocation
;
943 loc
= srelgot
->contents
;
944 loc
+= srelgot
->reloc_count
* sizeof (Elf32_External_Rela
);
945 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,loc
);
946 ++srelgot
->reloc_count
;
949 local_got_offsets
[r_symndx
] |= 1;
953 relocation
= sgot
->output_offset
+ off
;
956 /* Addend should be zero. */
957 if (rel
->r_addend
!= 0)
959 (_("internal error: addend should be zero for %s"),
962 r
= _bfd_final_link_relocate (howto
,
971 case R_LM32_GOTOFF_LO16
:
972 case R_LM32_GOTOFF_HI16
:
973 /* Relocation is offset from GOT. */
974 BFD_ASSERT (sgot
!= NULL
);
975 relocation
-= sgot
->output_section
->vma
;
976 /* Account for sign-extension. */
977 if ((r_type
== R_LM32_GOTOFF_HI16
)
978 && ((relocation
+ rel
->r_addend
) & 0x8000))
979 rel
->r_addend
+= 0x10000;
980 r
= _bfd_final_link_relocate (howto
,
990 if (IS_FDPIC (output_bfd
))
992 if ((!h
) || (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
994 /* Only create .rofixup entries for relocs in loadable sections. */
995 if ((bfd_section_flags (input_section
->output_section
)
996 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
999 /* Check address to be modified is writable. */
1000 if (_lm32fdpic_osec_readonly_p (output_bfd
,
1004 info
->callbacks
->warning
1006 _("cannot emit dynamic relocations in read-only section"),
1007 name
, input_bfd
, input_section
, rel
->r_offset
);
1010 /* Create entry in .rofixup section. */
1011 _lm32fdpic_add_rofixup (output_bfd
,
1012 lm32fdpic_fixup32_section (info
),
1013 input_section
->output_section
->vma
1014 + input_section
->output_offset
1022 r
= _bfd_final_link_relocate (howto
,
1033 if (r
!= bfd_reloc_ok
)
1035 const char *msg
= NULL
;
1038 if (! lm32_info_to_howto_rela (input_bfd
, &bfd_reloc
, rel
))
1040 howto
= bfd_reloc
.howto
;
1043 name
= h
->root
.root
.string
;
1046 name
= (bfd_elf_string_from_elf_section
1047 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1048 if (name
== NULL
|| *name
== '\0')
1049 name
= bfd_section_name (sec
);
1054 case bfd_reloc_overflow
:
1056 && (h
->root
.type
== bfd_link_hash_undefweak
))
1058 (*info
->callbacks
->reloc_overflow
)
1059 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1060 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1063 case bfd_reloc_undefined
:
1064 (*info
->callbacks
->undefined_symbol
)
1065 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1068 case bfd_reloc_outofrange
:
1069 msg
= _("internal error: out of range error");
1072 case bfd_reloc_notsupported
:
1073 msg
= _("internal error: unsupported relocation error");
1076 case bfd_reloc_dangerous
:
1077 msg
= _("internal error: dangerous error");
1081 msg
= _("internal error: unknown error");
1085 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1086 input_section
, rel
->r_offset
);
1096 lm32_elf_gc_mark_hook (asection
*sec
,
1097 struct bfd_link_info
*info
,
1098 Elf_Internal_Rela
*rel
,
1099 struct elf_link_hash_entry
*h
,
1100 Elf_Internal_Sym
*sym
)
1103 switch (ELF32_R_TYPE (rel
->r_info
))
1105 case R_LM32_GNU_VTINHERIT
:
1106 case R_LM32_GNU_VTENTRY
:
1110 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1113 /* Look through the relocs for a section during the first phase. */
1116 lm32_elf_check_relocs (bfd
*abfd
,
1117 struct bfd_link_info
*info
,
1119 const Elf_Internal_Rela
*relocs
)
1121 Elf_Internal_Shdr
*symtab_hdr
;
1122 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
1123 const Elf_Internal_Rela
*rel
;
1124 const Elf_Internal_Rela
*rel_end
;
1125 struct elf_lm32_link_hash_table
*htab
;
1128 if (bfd_link_relocatable (info
))
1131 /* Don't do anything special with non-loaded, non-alloced sections.
1132 In particular, any relocs in such sections should not affect GOT
1133 and PLT reference counting (ie. we don't allow them to create GOT
1134 or PLT entries), there's no possibility or desire to optimize TLS
1135 relocs, and there's not much point in propagating relocs to shared
1136 libs that the dynamic linker won't relocate. */
1137 if ((sec
->flags
& SEC_ALLOC
) == 0)
1140 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1141 sym_hashes
= elf_sym_hashes (abfd
);
1142 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
1143 if (!elf_bad_symtab (abfd
))
1144 sym_hashes_end
-= symtab_hdr
->sh_info
;
1146 htab
= lm32_elf_hash_table (info
);
1150 dynobj
= htab
->root
.dynobj
;
1152 rel_end
= relocs
+ sec
->reloc_count
;
1153 for (rel
= relocs
; rel
< rel_end
; rel
++)
1156 struct elf_link_hash_entry
*h
;
1157 unsigned long r_symndx
;
1159 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1160 r_type
= ELF32_R_TYPE (rel
->r_info
);
1161 if (r_symndx
< symtab_hdr
->sh_info
)
1165 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1166 while (h
->root
.type
== bfd_link_hash_indirect
1167 || h
->root
.type
== bfd_link_hash_warning
)
1168 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1171 /* Some relocs require a global offset table. */
1172 if (htab
->root
.sgot
== NULL
)
1177 case R_LM32_GOTOFF_HI16
:
1178 case R_LM32_GOTOFF_LO16
:
1180 htab
->root
.dynobj
= dynobj
= abfd
;
1181 if (!_bfd_elf_create_got_section (dynobj
, info
))
1187 /* Some relocs require a rofixup table. */
1188 if (IS_FDPIC (abfd
))
1193 /* FDPIC requires a GOT if there is a .rofixup section
1194 (Normal ELF doesn't). */
1196 htab
->root
.dynobj
= dynobj
= abfd
;
1197 if (!_bfd_elf_create_got_section (dynobj
, info
))
1199 /* Create .rofixup section */
1200 if (htab
->sfixup32
== NULL
)
1202 if (! create_rofixup_section (dynobj
, info
))
1207 case R_LM32_GOTOFF_HI16
:
1208 case R_LM32_GOTOFF_LO16
:
1209 /* Create .rofixup section. */
1210 if (htab
->sfixup32
== NULL
)
1213 htab
->root
.dynobj
= dynobj
= abfd
;
1214 if (! create_rofixup_section (dynobj
, info
))
1225 h
->got
.refcount
+= 1;
1228 bfd_signed_vma
*local_got_refcounts
;
1230 /* This is a global offset table entry for a local symbol. */
1231 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1232 if (local_got_refcounts
== NULL
)
1236 size
= symtab_hdr
->sh_info
;
1237 size
*= sizeof (bfd_signed_vma
);
1238 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1239 if (local_got_refcounts
== NULL
)
1241 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1243 local_got_refcounts
[r_symndx
] += 1;
1247 /* This relocation describes the C++ object vtable hierarchy.
1248 Reconstruct it for later use during GC. */
1249 case R_LM32_GNU_VTINHERIT
:
1250 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1254 /* This relocation describes which C++ vtable entries are actually
1255 used. Record for later use during GC. */
1256 case R_LM32_GNU_VTENTRY
:
1257 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1267 /* Finish up the dynamic sections. */
1270 lm32_elf_finish_dynamic_sections (bfd
*output_bfd
,
1271 struct bfd_link_info
*info
)
1273 struct elf_lm32_link_hash_table
*htab
;
1278 htab
= lm32_elf_hash_table (info
);
1282 dynobj
= htab
->root
.dynobj
;
1284 sgot
= htab
->root
.sgotplt
;
1285 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1287 if (htab
->root
.dynamic_sections_created
)
1290 Elf32_External_Dyn
*dyncon
, *dynconend
;
1292 BFD_ASSERT (sgot
!= NULL
&& sdyn
!= NULL
);
1294 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1295 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
1297 for (; dyncon
< dynconend
; dyncon
++)
1299 Elf_Internal_Dyn dyn
;
1302 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1310 s
= htab
->root
.sgotplt
;
1313 s
= htab
->root
.srelplt
;
1315 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1316 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1320 s
= htab
->root
.srelplt
;
1321 dyn
.d_un
.d_val
= s
->size
;
1322 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1327 /* Fill in the first entry in the procedure linkage table. */
1328 splt
= htab
->root
.splt
;
1329 if (splt
&& splt
->size
> 0)
1331 if (bfd_link_pic (info
))
1333 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD0
, splt
->contents
);
1334 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD1
, splt
->contents
+ 4);
1335 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD2
, splt
->contents
+ 8);
1336 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD3
, splt
->contents
+ 12);
1337 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD4
, splt
->contents
+ 16);
1342 /* addr = .got + 4 */
1343 addr
= sgot
->output_section
->vma
+ sgot
->output_offset
+ 4;
1344 bfd_put_32 (output_bfd
,
1345 PLT0_ENTRY_WORD0
| ((addr
>> 16) & 0xffff),
1347 bfd_put_32 (output_bfd
,
1348 PLT0_ENTRY_WORD1
| (addr
& 0xffff),
1349 splt
->contents
+ 4);
1350 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD2
, splt
->contents
+ 8);
1351 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD3
, splt
->contents
+ 12);
1352 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD4
, splt
->contents
+ 16);
1355 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1360 /* Fill in the first three entries in the global offset table. */
1361 if (sgot
&& sgot
->size
> 0)
1364 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1366 bfd_put_32 (output_bfd
,
1367 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1369 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1370 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1372 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1373 if (elf_section_data (sgot
->output_section
) != NULL
)
1374 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1377 if (lm32fdpic_fixup32_section (info
))
1379 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
1380 bfd_vma got_value
= hgot
->root
.u
.def
.value
1381 + hgot
->root
.u
.def
.section
->output_section
->vma
1382 + hgot
->root
.u
.def
.section
->output_offset
;
1383 struct bfd_link_hash_entry
*hend
;
1385 /* Last entry is pointer to GOT. */
1386 _lm32fdpic_add_rofixup (output_bfd
, lm32fdpic_fixup32_section (info
), got_value
);
1388 /* Check we wrote enough entries. */
1389 if (lm32fdpic_fixup32_section (info
)->size
1390 != (lm32fdpic_fixup32_section (info
)->reloc_count
* 4))
1393 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1395 (int64_t) (lm32fdpic_fixup32_section (info
)->size
/ 4),
1396 lm32fdpic_fixup32_section (info
)->reloc_count
);
1400 hend
= bfd_link_hash_lookup (info
->hash
, "__ROFIXUP_END__",
1401 FALSE
, FALSE
, TRUE
);
1403 && (hend
->type
== bfd_link_hash_defined
1404 || hend
->type
== bfd_link_hash_defweak
)
1405 && hend
->u
.def
.section
->output_section
!= NULL
)
1408 lm32fdpic_fixup32_section (info
)->output_section
->vma
1409 + lm32fdpic_fixup32_section (info
)->output_offset
1410 + lm32fdpic_fixup32_section (info
)->size
1411 - hend
->u
.def
.section
->output_section
->vma
1412 - hend
->u
.def
.section
->output_offset
;
1413 BFD_ASSERT (hend
->u
.def
.value
== value
);
1414 if (hend
->u
.def
.value
!= value
)
1417 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1418 PRId64
" != %" PRId64
,
1419 (int64_t) hend
->u
.def
.value
, (int64_t) value
);
1428 /* Finish up dynamic symbol handling. We set the contents of various
1429 dynamic sections here. */
1432 lm32_elf_finish_dynamic_symbol (bfd
*output_bfd
,
1433 struct bfd_link_info
*info
,
1434 struct elf_link_hash_entry
*h
,
1435 Elf_Internal_Sym
*sym
)
1437 struct elf_lm32_link_hash_table
*htab
;
1440 htab
= lm32_elf_hash_table (info
);
1444 if (h
->plt
.offset
!= (bfd_vma
) -1)
1452 Elf_Internal_Rela rela
;
1454 /* This symbol has an entry in the procedure linkage table. Set
1456 BFD_ASSERT (h
->dynindx
!= -1);
1458 splt
= htab
->root
.splt
;
1459 sgot
= htab
->root
.sgotplt
;
1460 srela
= htab
->root
.srelplt
;
1461 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1463 /* Get the index in the procedure linkage table which
1464 corresponds to this symbol. This is the index of this symbol
1465 in all the symbols for which we are making plt entries. The
1466 first entry in the procedure linkage table is reserved. */
1467 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1469 /* Get the offset into the .got table of the entry that
1470 corresponds to this function. Each .got entry is 4 bytes.
1471 The first three are reserved. */
1472 got_offset
= (plt_index
+ 3) * 4;
1474 /* Fill in the entry in the procedure linkage table. */
1475 if (! bfd_link_pic (info
))
1484 /* Fill in the entry in the global offset table. */
1485 bfd_put_32 (output_bfd
,
1486 (splt
->output_section
->vma
1487 + splt
->output_offset
1489 + 12), /* same offset */
1490 sgot
->contents
+ got_offset
);
1492 /* Fill in the entry in the .rela.plt section. */
1493 rela
.r_offset
= (sgot
->output_section
->vma
1494 + sgot
->output_offset
1496 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_JMP_SLOT
);
1498 loc
= srela
->contents
;
1499 loc
+= plt_index
* sizeof (Elf32_External_Rela
);
1500 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1502 if (!h
->def_regular
)
1504 /* Mark the symbol as undefined, rather than as defined in
1505 the .plt section. Leave the value alone. */
1506 sym
->st_shndx
= SHN_UNDEF
;
1511 if (h
->got
.offset
!= (bfd_vma
) -1)
1515 Elf_Internal_Rela rela
;
1517 /* This symbol has an entry in the global offset table. Set it
1519 sgot
= htab
->root
.sgot
;
1520 srela
= htab
->root
.srelgot
;
1521 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1523 rela
.r_offset
= (sgot
->output_section
->vma
1524 + sgot
->output_offset
1525 + (h
->got
.offset
&~ 1));
1527 /* If this is a -Bsymbolic link, and the symbol is defined
1528 locally, we just want to emit a RELATIVE reloc. Likewise if
1529 the symbol was forced to be local because of a version file.
1530 The entry in the global offset table will already have been
1531 initialized in the relocate_section function. */
1532 if (bfd_link_pic (info
)
1538 rela
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
1539 rela
.r_addend
= (h
->root
.u
.def
.value
1540 + h
->root
.u
.def
.section
->output_section
->vma
1541 + h
->root
.u
.def
.section
->output_offset
);
1545 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
1546 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1547 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_GLOB_DAT
);
1551 loc
= srela
->contents
;
1552 loc
+= srela
->reloc_count
* sizeof (Elf32_External_Rela
);
1553 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1554 ++srela
->reloc_count
;
1560 Elf_Internal_Rela rela
;
1562 /* This symbols needs a copy reloc. Set it up. */
1563 BFD_ASSERT (h
->dynindx
!= -1
1564 && (h
->root
.type
== bfd_link_hash_defined
1565 || h
->root
.type
== bfd_link_hash_defweak
));
1567 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
1568 BFD_ASSERT (s
!= NULL
);
1570 rela
.r_offset
= (h
->root
.u
.def
.value
1571 + h
->root
.u
.def
.section
->output_section
->vma
1572 + h
->root
.u
.def
.section
->output_offset
);
1573 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_COPY
);
1576 loc
+= s
->reloc_count
* sizeof (Elf32_External_Rela
);
1577 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1581 /* Mark some specially defined symbols as absolute. */
1582 if (h
== htab
->root
.hdynamic
|| h
== htab
->root
.hgot
)
1583 sym
->st_shndx
= SHN_ABS
;
1588 static enum elf_reloc_type_class
1589 lm32_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1590 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1591 const Elf_Internal_Rela
*rela
)
1593 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1595 case R_LM32_RELATIVE
: return reloc_class_relative
;
1596 case R_LM32_JMP_SLOT
: return reloc_class_plt
;
1597 case R_LM32_COPY
: return reloc_class_copy
;
1598 default: return reloc_class_normal
;
1602 /* Find dynamic relocs for H that apply to read-only sections. */
1605 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
1607 struct elf_dyn_relocs
*p
;
1609 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1611 asection
*s
= p
->sec
->output_section
;
1613 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1619 /* Adjust a symbol defined by a dynamic object and referenced by a
1620 regular object. The current definition is in some section of the
1621 dynamic object, but we're not including those sections. We have to
1622 change the definition to something the rest of the link can
1626 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1627 struct elf_link_hash_entry
*h
)
1629 struct elf_lm32_link_hash_table
*htab
;
1633 dynobj
= elf_hash_table (info
)->dynobj
;
1635 /* Make sure we know what is going on here. */
1636 BFD_ASSERT (dynobj
!= NULL
1641 && !h
->def_regular
)));
1643 /* If this is a function, put it in the procedure linkage table. We
1644 will fill in the contents of the procedure linkage table later,
1645 when we know the address of the .got section. */
1646 if (h
->type
== STT_FUNC
1649 if (! bfd_link_pic (info
)
1652 && h
->root
.type
!= bfd_link_hash_undefweak
1653 && h
->root
.type
!= bfd_link_hash_undefined
)
1655 /* This case can occur if we saw a PLT reloc in an input
1656 file, but the symbol was never referred to by a dynamic
1657 object. In such a case, we don't actually need to build
1658 a procedure linkage table, and we can just do a PCREL
1660 h
->plt
.offset
= (bfd_vma
) -1;
1667 h
->plt
.offset
= (bfd_vma
) -1;
1669 /* If this is a weak symbol, and there is a real definition, the
1670 processor independent code will have arranged for us to see the
1671 real definition first, and we can just use the same value. */
1672 if (h
->is_weakalias
)
1674 struct elf_link_hash_entry
*def
= weakdef (h
);
1675 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1676 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1677 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1681 /* This is a reference to a symbol defined by a dynamic object which
1682 is not a function. */
1684 /* If we are creating a shared library, we must presume that the
1685 only references to the symbol are via the global offset table.
1686 For such cases we need not do anything here; the relocations will
1687 be handled correctly by relocate_section. */
1688 if (bfd_link_pic (info
))
1691 /* If there are no references to this symbol that do not use the
1692 GOT, we don't need to generate a copy reloc. */
1693 if (!h
->non_got_ref
)
1696 /* If -z nocopyreloc was given, we won't generate them either. */
1697 if (0 && info
->nocopyreloc
)
1703 /* If we don't find any dynamic relocs in read-only sections, then
1704 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1705 if (0 && !readonly_dynrelocs (h
))
1711 /* We must allocate the symbol in our .dynbss section, which will
1712 become part of the .bss section of the executable. There will be
1713 an entry for this symbol in the .dynsym section. The dynamic
1714 object will contain position independent code, so all references
1715 from the dynamic object to this symbol will go through the global
1716 offset table. The dynamic linker will use the .dynsym entry to
1717 determine the address it must put in the global offset table, so
1718 both the dynamic object and the regular object will refer to the
1719 same memory location for the variable. */
1721 htab
= lm32_elf_hash_table (info
);
1726 BFD_ASSERT (s
!= NULL
);
1728 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1729 to copy the initial value out of the dynamic object and into the
1730 runtime process image. We need to remember the offset into the
1731 .rela.bss section we are going to use. */
1732 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1736 srel
= htab
->srelbss
;
1737 BFD_ASSERT (srel
!= NULL
);
1738 srel
->size
+= sizeof (Elf32_External_Rela
);
1742 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1745 /* Allocate space in .plt, .got and associated reloc sections for
1749 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1751 struct bfd_link_info
*info
;
1752 struct elf_lm32_link_hash_table
*htab
;
1753 struct elf_dyn_relocs
*p
;
1755 if (h
->root
.type
== bfd_link_hash_indirect
)
1758 info
= (struct bfd_link_info
*) inf
;
1759 htab
= lm32_elf_hash_table (info
);
1763 if (htab
->root
.dynamic_sections_created
1764 && h
->plt
.refcount
> 0)
1766 /* Make sure this symbol is output as a dynamic symbol.
1767 Undefined weak syms won't yet be marked as dynamic. */
1768 if (h
->dynindx
== -1
1769 && !h
->forced_local
)
1771 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1775 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1777 asection
*s
= htab
->root
.splt
;
1779 /* If this is the first .plt entry, make room for the special
1782 s
->size
+= PLT_ENTRY_SIZE
;
1784 h
->plt
.offset
= s
->size
;
1786 /* If this symbol is not defined in a regular file, and we are
1787 not generating a shared library, then set the symbol to this
1788 location in the .plt. This is required to make function
1789 pointers compare as equal between the normal executable and
1790 the shared library. */
1791 if (! bfd_link_pic (info
)
1794 h
->root
.u
.def
.section
= s
;
1795 h
->root
.u
.def
.value
= h
->plt
.offset
;
1798 /* Make room for this entry. */
1799 s
->size
+= PLT_ENTRY_SIZE
;
1801 /* We also need to make an entry in the .got.plt section, which
1802 will be placed in the .got section by the linker script. */
1803 htab
->root
.sgotplt
->size
+= 4;
1805 /* We also need to make an entry in the .rel.plt section. */
1806 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1810 h
->plt
.offset
= (bfd_vma
) -1;
1816 h
->plt
.offset
= (bfd_vma
) -1;
1820 if (h
->got
.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 s
= htab
->root
.sgot
;
1836 h
->got
.offset
= s
->size
;
1838 dyn
= htab
->root
.dynamic_sections_created
;
1839 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1840 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1843 h
->got
.offset
= (bfd_vma
) -1;
1845 if (h
->dyn_relocs
== NULL
)
1848 /* In the shared -Bsymbolic case, discard space allocated for
1849 dynamic pc-relative relocs against symbols which turn out to be
1850 defined in regular objects. For the normal shared case, discard
1851 space for pc-relative relocs that have become local due to symbol
1852 visibility changes. */
1854 if (bfd_link_pic (info
))
1860 struct elf_dyn_relocs
**pp
;
1862 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
;)
1864 p
->count
-= p
->pc_count
;
1873 /* Also discard relocs on undefined weak syms with non-default
1875 if (h
->dyn_relocs
!= NULL
1876 && h
->root
.type
== bfd_link_hash_undefweak
)
1878 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1879 h
->dyn_relocs
= NULL
;
1881 /* Make sure undefined weak symbols are output as a dynamic
1883 else if (h
->dynindx
== -1
1884 && !h
->forced_local
)
1886 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1893 /* For the non-shared case, discard space for relocs against
1894 symbols which turn out to need copy relocs or are not
1900 || (htab
->root
.dynamic_sections_created
1901 && (h
->root
.type
== bfd_link_hash_undefweak
1902 || h
->root
.type
== bfd_link_hash_undefined
))))
1904 /* Make sure this symbol is output as a dynamic symbol.
1905 Undefined weak syms won't yet be marked as dynamic. */
1906 if (h
->dynindx
== -1
1907 && !h
->forced_local
)
1909 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1913 /* If that succeeded, we know we'll be keeping all the
1915 if (h
->dynindx
!= -1)
1919 h
->dyn_relocs
= NULL
;
1924 /* Finally, allocate space. */
1925 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1927 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1928 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1934 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1935 read-only sections. */
1938 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1942 if (h
->root
.type
== bfd_link_hash_indirect
)
1945 sec
= readonly_dynrelocs (h
);
1948 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1950 info
->flags
|= DF_TEXTREL
;
1951 info
->callbacks
->minfo
1952 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1953 sec
->owner
, h
->root
.root
.string
, sec
);
1955 /* Not an error, just cut short the traversal. */
1961 /* Set the sizes of the dynamic sections. */
1964 lm32_elf_size_dynamic_sections (bfd
*output_bfd
,
1965 struct bfd_link_info
*info
)
1967 struct elf_lm32_link_hash_table
*htab
;
1973 htab
= lm32_elf_hash_table (info
);
1977 dynobj
= htab
->root
.dynobj
;
1978 BFD_ASSERT (dynobj
!= NULL
);
1980 if (htab
->root
.dynamic_sections_created
)
1982 /* Set the contents of the .interp section to the interpreter. */
1983 if (bfd_link_executable (info
) && !info
->nointerp
)
1985 s
= bfd_get_linker_section (dynobj
, ".interp");
1986 BFD_ASSERT (s
!= NULL
);
1987 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1988 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1992 /* Set up .got offsets for local syms, and space for local dynamic
1994 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1996 bfd_signed_vma
*local_got
;
1997 bfd_signed_vma
*end_local_got
;
1998 bfd_size_type locsymcount
;
1999 Elf_Internal_Shdr
*symtab_hdr
;
2002 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2005 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2007 struct elf_dyn_relocs
*p
;
2009 for (p
= ((struct elf_dyn_relocs
*)
2010 elf_section_data (s
)->local_dynrel
);
2014 if (! bfd_is_abs_section (p
->sec
)
2015 && bfd_is_abs_section (p
->sec
->output_section
))
2017 /* Input section has been discarded, either because
2018 it is a copy of a linkonce section or due to
2019 linker script /DISCARD/, so we'll be discarding
2022 else if (p
->count
!= 0)
2024 srel
= elf_section_data (p
->sec
)->sreloc
;
2025 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2026 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2027 info
->flags
|= DF_TEXTREL
;
2032 local_got
= elf_local_got_refcounts (ibfd
);
2036 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2037 locsymcount
= symtab_hdr
->sh_info
;
2038 end_local_got
= local_got
+ locsymcount
;
2039 s
= htab
->root
.sgot
;
2040 srel
= htab
->root
.srelgot
;
2041 for (; local_got
< end_local_got
; ++local_got
)
2045 *local_got
= s
->size
;
2047 if (bfd_link_pic (info
))
2048 srel
->size
+= sizeof (Elf32_External_Rela
);
2051 *local_got
= (bfd_vma
) -1;
2055 /* Allocate global sym .plt and .got entries, and space for global
2056 sym dynamic relocs. */
2057 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
2059 /* We now have determined the sizes of the various dynamic sections.
2060 Allocate memory for them. */
2062 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2064 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2067 if (s
== htab
->root
.splt
2068 || s
== htab
->root
.sgot
2069 || s
== htab
->root
.sgotplt
2070 || s
== htab
->sdynbss
)
2072 /* Strip this section if we don't need it; see the
2075 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
2077 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
)
2080 /* We use the reloc_count field as a counter if we need
2081 to copy relocs into the output file. */
2085 /* It's not one of our sections, so don't allocate space. */
2090 /* If we don't need this section, strip it from the
2091 output file. This is mostly to handle .rela.bss and
2092 .rela.plt. We must create both sections in
2093 create_dynamic_sections, because they must be created
2094 before the linker maps input sections to output
2095 sections. The linker does that before
2096 adjust_dynamic_symbol is called, and it is that
2097 function which decides whether anything needs to go
2098 into these sections. */
2099 s
->flags
|= SEC_EXCLUDE
;
2103 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2106 /* Allocate memory for the section contents. We use bfd_zalloc
2107 here in case unused entries are not reclaimed before the
2108 section's contents are written out. This should not happen,
2109 but this way if it does, we get a R_LM32_NONE reloc instead
2111 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2112 if (s
->contents
== NULL
)
2116 if (htab
->root
.dynamic_sections_created
)
2118 /* Add some entries to the .dynamic section. We fill in the
2119 values later, in lm32_elf_finish_dynamic_sections, but we
2120 must add the entries now so that we get the correct size for
2121 the .dynamic section. The DT_DEBUG entry is filled in by the
2122 dynamic linker and used by the debugger. */
2123 #define add_dynamic_entry(TAG, VAL) \
2124 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2126 if (bfd_link_executable (info
))
2128 if (! add_dynamic_entry (DT_DEBUG
, 0))
2132 if (htab
->root
.splt
->size
!= 0)
2134 if (! add_dynamic_entry (DT_PLTGOT
, 0)
2135 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
2136 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2137 || ! add_dynamic_entry (DT_JMPREL
, 0))
2143 if (! add_dynamic_entry (DT_RELA
, 0)
2144 || ! add_dynamic_entry (DT_RELASZ
, 0)
2145 || ! add_dynamic_entry (DT_RELAENT
,
2146 sizeof (Elf32_External_Rela
)))
2149 /* If any dynamic relocs apply to a read-only section,
2150 then we need a DT_TEXTREL entry. */
2151 if ((info
->flags
& DF_TEXTREL
) == 0)
2152 elf_link_hash_traverse (&htab
->root
, maybe_set_textrel
, info
);
2154 if ((info
->flags
& DF_TEXTREL
) != 0)
2156 if (! add_dynamic_entry (DT_TEXTREL
, 0))
2161 #undef add_dynamic_entry
2163 /* Allocate .rofixup section. */
2164 if (IS_FDPIC (output_bfd
))
2166 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2167 int rgot_weak_count
= 0;
2170 /* Look for deleted sections. */
2171 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2173 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2177 /* Count relocs that need .rofixup entires. */
2178 Elf_Internal_Rela
*internal_relocs
, *end
;
2179 internal_relocs
= elf_section_data (s
)->relocs
;
2180 if (internal_relocs
== NULL
)
2181 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2182 if (internal_relocs
!= NULL
)
2184 end
= internal_relocs
+ s
->reloc_count
;
2185 while (internal_relocs
< end
)
2187 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2188 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2189 unsigned long r_symndx
;
2190 struct elf_link_hash_entry
*h
;
2192 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2193 sym_hashes
= elf_sym_hashes (ibfd
);
2194 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2196 if (r_symndx
< symtab_hdr
->sh_info
)
2201 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2202 while (h
->root
.type
== bfd_link_hash_indirect
2203 || h
->root
.type
== bfd_link_hash_warning
)
2204 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2207 /* Don't generate entries for weak symbols. */
2208 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2210 if (!discarded_section (s
) && !((bfd_section_flags (s
) & SEC_ALLOC
) == 0))
2212 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2225 struct weak_symbol_list
*current
, *new_entry
;
2226 /* Is this symbol already in the list? */
2227 for (current
= list_start
; current
; current
= current
->next
)
2229 if (!strcmp (current
->name
, h
->root
.root
.string
))
2232 if (!current
&& !discarded_section (s
) && (bfd_section_flags (s
) & SEC_ALLOC
))
2234 /* Will this have an entry in the GOT. */
2235 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2237 /* Create a new entry. */
2238 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2241 new_entry
->name
= h
->root
.root
.string
;
2242 new_entry
->next
= NULL
;
2244 if (list_start
== NULL
)
2246 list_start
= new_entry
;
2247 list_end
= new_entry
;
2251 list_end
->next
= new_entry
;
2252 list_end
= new_entry
;
2254 /* Increase count of undefined weak symbols in the got. */
2270 list_end
= list_start
->next
;
2272 list_start
= list_end
;
2275 /* Size sections. */
2276 lm32fdpic_fixup32_section (info
)->size
2277 = (r32_count
+ (htab
->root
.sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2278 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2279 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2282 lm32fdpic_fixup32_section (info
)->contents
=
2283 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2284 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2292 /* Create dynamic sections when linking against a dynamic object. */
2295 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2297 struct elf_lm32_link_hash_table
*htab
;
2298 flagword flags
, pltflags
;
2300 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2301 int ptralign
= 2; /* 32bit */
2303 htab
= lm32_elf_hash_table (info
);
2307 /* Make sure we have a GOT - For the case where we have a dynamic object
2308 but none of the relocs in check_relocs */
2309 if (!_bfd_elf_create_got_section (abfd
, info
))
2311 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2313 if (! create_rofixup_section (abfd
, info
))
2317 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2318 .rel[a].bss sections. */
2319 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2320 | SEC_LINKER_CREATED
);
2323 pltflags
|= SEC_CODE
;
2324 if (bed
->plt_not_loaded
)
2325 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2326 if (bed
->plt_readonly
)
2327 pltflags
|= SEC_READONLY
;
2329 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2330 htab
->root
.splt
= s
;
2332 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2335 if (bed
->want_plt_sym
)
2337 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2339 struct bfd_link_hash_entry
*bh
= NULL
;
2340 struct elf_link_hash_entry
*h
;
2342 if (! (_bfd_generic_link_add_one_symbol
2343 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2344 (bfd_vma
) 0, NULL
, FALSE
,
2345 get_elf_backend_data (abfd
)->collect
, &bh
)))
2347 h
= (struct elf_link_hash_entry
*) bh
;
2349 h
->type
= STT_OBJECT
;
2350 htab
->root
.hplt
= h
;
2352 if (bfd_link_pic (info
)
2353 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2357 s
= bfd_make_section_anyway_with_flags (abfd
,
2358 bed
->default_use_rela_p
2359 ? ".rela.plt" : ".rel.plt",
2360 flags
| SEC_READONLY
);
2361 htab
->root
.srelplt
= s
;
2363 || !bfd_set_section_alignment (s
, ptralign
))
2366 if (htab
->root
.sgot
== NULL
2367 && !_bfd_elf_create_got_section (abfd
, info
))
2370 if (bed
->want_dynbss
)
2372 /* The .dynbss section is a place to put symbols which are defined
2373 by dynamic objects, are referenced by regular objects, and are
2374 not functions. We must allocate space for them in the process
2375 image and use a R_*_COPY reloc to tell the dynamic linker to
2376 initialize them at run time. The linker script puts the .dynbss
2377 section into the .bss section of the final image. */
2378 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2379 SEC_ALLOC
| SEC_LINKER_CREATED
);
2383 /* The .rel[a].bss section holds copy relocs. This section is not
2384 normally needed. We need to create it here, though, so that the
2385 linker will map it to an output section. We can't just create it
2386 only if we need it, because we will not know whether we need it
2387 until we have seen all the input files, and the first time the
2388 main linker code calls BFD after examining all the input files
2389 (size_dynamic_sections) the input sections have already been
2390 mapped to the output sections. If the section turns out not to
2391 be needed, we can discard it later. We will never need this
2392 section when generating a shared object, since they do not use
2394 if (! bfd_link_pic (info
))
2396 s
= bfd_make_section_anyway_with_flags (abfd
,
2397 (bed
->default_use_rela_p
2398 ? ".rela.bss" : ".rel.bss"),
2399 flags
| SEC_READONLY
);
2402 || !bfd_set_section_alignment (s
, ptralign
))
2410 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2413 lm32_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
2414 struct elf_link_hash_entry
*dir
,
2415 struct elf_link_hash_entry
*ind
)
2417 if (ind
->dyn_relocs
!= NULL
)
2419 if (dir
->dyn_relocs
!= NULL
)
2421 struct elf_dyn_relocs
**pp
;
2422 struct elf_dyn_relocs
*p
;
2424 /* Add reloc counts against the indirect sym to the direct sym
2425 list. Merge any entries against the same section. */
2426 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
;)
2428 struct elf_dyn_relocs
*q
;
2430 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
2431 if (q
->sec
== p
->sec
)
2433 q
->pc_count
+= p
->pc_count
;
2434 q
->count
+= p
->count
;
2441 *pp
= dir
->dyn_relocs
;
2444 dir
->dyn_relocs
= ind
->dyn_relocs
;
2445 ind
->dyn_relocs
= NULL
;
2448 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
2452 lm32_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2454 if (!bfd_link_relocatable (info
))
2456 if (!bfd_elf_stack_segment_size (output_bfd
, info
,
2457 "__stacksize", DEFAULT_STACK_SIZE
))
2460 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2462 sec
->size
= info
->stacksize
>= 0 ? info
->stacksize
: 0;
2469 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2473 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2474 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2477 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
2480 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2481 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2484 /* Copy the stack size. */
2485 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2486 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2488 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2490 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2491 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2493 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2495 /* Rewrite the phdrs, since we're only called after they were first written. */
2496 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2497 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2498 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2499 elf_elfheader (obfd
)->e_phnum
) != 0)
2511 #define ELF_ARCH bfd_arch_lm32
2512 #define ELF_TARGET_ID LM32_ELF_DATA
2513 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2514 #define ELF_MAXPAGESIZE 0x1000
2516 #define TARGET_BIG_SYM lm32_elf32_vec
2517 #define TARGET_BIG_NAME "elf32-lm32"
2519 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2520 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2521 #define elf_info_to_howto lm32_info_to_howto_rela
2522 #define elf_info_to_howto_rel NULL
2523 #define elf_backend_rela_normal 1
2524 #define elf_backend_object_p lm32_elf_object_p
2525 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2526 #define elf_backend_stack_align 8
2527 #define elf_backend_can_gc_sections 1
2528 #define elf_backend_can_refcount 1
2529 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2530 #define elf_backend_plt_readonly 1
2531 #define elf_backend_want_got_plt 1
2532 #define elf_backend_want_plt_sym 0
2533 #define elf_backend_got_header_size 12
2534 #define elf_backend_dtrel_excludes_plt 1
2535 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2536 #define elf_backend_check_relocs lm32_elf_check_relocs
2537 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2538 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2539 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2540 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2541 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2542 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2543 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2544 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2545 #define elf_backend_relocate_section lm32_elf_relocate_section
2547 #include "elf32-target.h"
2549 #undef ELF_MAXPAGESIZE
2550 #define ELF_MAXPAGESIZE 0x4000
2553 #undef TARGET_BIG_SYM
2554 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2555 #undef TARGET_BIG_NAME
2556 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2558 #define elf32_bed elf32_lm32fdpic_bed
2560 #undef elf_backend_always_size_sections
2561 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2562 #undef bfd_elf32_bfd_copy_private_bfd_data
2563 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2565 #include "elf32-target.h"