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 /* Adjust a symbol defined by a dynamic object and referenced by a
1603 regular object. The current definition is in some section of the
1604 dynamic object, but we're not including those sections. We have to
1605 change the definition to something the rest of the link can
1609 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1610 struct elf_link_hash_entry
*h
)
1612 struct elf_lm32_link_hash_table
*htab
;
1616 dynobj
= elf_hash_table (info
)->dynobj
;
1618 /* Make sure we know what is going on here. */
1619 BFD_ASSERT (dynobj
!= NULL
1624 && !h
->def_regular
)));
1626 /* If this is a function, put it in the procedure linkage table. We
1627 will fill in the contents of the procedure linkage table later,
1628 when we know the address of the .got section. */
1629 if (h
->type
== STT_FUNC
1632 if (! bfd_link_pic (info
)
1635 && h
->root
.type
!= bfd_link_hash_undefweak
1636 && h
->root
.type
!= bfd_link_hash_undefined
)
1638 /* This case can occur if we saw a PLT reloc in an input
1639 file, but the symbol was never referred to by a dynamic
1640 object. In such a case, we don't actually need to build
1641 a procedure linkage table, and we can just do a PCREL
1643 h
->plt
.offset
= (bfd_vma
) -1;
1650 h
->plt
.offset
= (bfd_vma
) -1;
1652 /* If this is a weak symbol, and there is a real definition, the
1653 processor independent code will have arranged for us to see the
1654 real definition first, and we can just use the same value. */
1655 if (h
->is_weakalias
)
1657 struct elf_link_hash_entry
*def
= weakdef (h
);
1658 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1659 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1660 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1664 /* This is a reference to a symbol defined by a dynamic object which
1665 is not a function. */
1667 /* If we are creating a shared library, we must presume that the
1668 only references to the symbol are via the global offset table.
1669 For such cases we need not do anything here; the relocations will
1670 be handled correctly by relocate_section. */
1671 if (bfd_link_pic (info
))
1674 /* If there are no references to this symbol that do not use the
1675 GOT, we don't need to generate a copy reloc. */
1676 if (!h
->non_got_ref
)
1679 /* If -z nocopyreloc was given, we won't generate them either. */
1680 if (0 && info
->nocopyreloc
)
1686 /* If we don't find any dynamic relocs in read-only sections, then
1687 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1688 if (0 && !_bfd_elf_readonly_dynrelocs (h
))
1694 /* We must allocate the symbol in our .dynbss section, which will
1695 become part of the .bss section of the executable. There will be
1696 an entry for this symbol in the .dynsym section. The dynamic
1697 object will contain position independent code, so all references
1698 from the dynamic object to this symbol will go through the global
1699 offset table. The dynamic linker will use the .dynsym entry to
1700 determine the address it must put in the global offset table, so
1701 both the dynamic object and the regular object will refer to the
1702 same memory location for the variable. */
1704 htab
= lm32_elf_hash_table (info
);
1709 BFD_ASSERT (s
!= NULL
);
1711 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1712 to copy the initial value out of the dynamic object and into the
1713 runtime process image. We need to remember the offset into the
1714 .rela.bss section we are going to use. */
1715 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1719 srel
= htab
->srelbss
;
1720 BFD_ASSERT (srel
!= NULL
);
1721 srel
->size
+= sizeof (Elf32_External_Rela
);
1725 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1728 /* Allocate space in .plt, .got and associated reloc sections for
1732 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1734 struct bfd_link_info
*info
;
1735 struct elf_lm32_link_hash_table
*htab
;
1736 struct elf_dyn_relocs
*p
;
1738 if (h
->root
.type
== bfd_link_hash_indirect
)
1741 info
= (struct bfd_link_info
*) inf
;
1742 htab
= lm32_elf_hash_table (info
);
1746 if (htab
->root
.dynamic_sections_created
1747 && h
->plt
.refcount
> 0)
1749 /* Make sure this symbol is output as a dynamic symbol.
1750 Undefined weak syms won't yet be marked as dynamic. */
1751 if (h
->dynindx
== -1
1752 && !h
->forced_local
)
1754 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1758 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1760 asection
*s
= htab
->root
.splt
;
1762 /* If this is the first .plt entry, make room for the special
1765 s
->size
+= PLT_ENTRY_SIZE
;
1767 h
->plt
.offset
= s
->size
;
1769 /* If this symbol is not defined in a regular file, and we are
1770 not generating a shared library, then set the symbol to this
1771 location in the .plt. This is required to make function
1772 pointers compare as equal between the normal executable and
1773 the shared library. */
1774 if (! bfd_link_pic (info
)
1777 h
->root
.u
.def
.section
= s
;
1778 h
->root
.u
.def
.value
= h
->plt
.offset
;
1781 /* Make room for this entry. */
1782 s
->size
+= PLT_ENTRY_SIZE
;
1784 /* We also need to make an entry in the .got.plt section, which
1785 will be placed in the .got section by the linker script. */
1786 htab
->root
.sgotplt
->size
+= 4;
1788 /* We also need to make an entry in the .rel.plt section. */
1789 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1793 h
->plt
.offset
= (bfd_vma
) -1;
1799 h
->plt
.offset
= (bfd_vma
) -1;
1803 if (h
->got
.refcount
> 0)
1808 /* Make sure this symbol is output as a dynamic symbol.
1809 Undefined weak syms won't yet be marked as dynamic. */
1810 if (h
->dynindx
== -1
1811 && !h
->forced_local
)
1813 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1817 s
= htab
->root
.sgot
;
1819 h
->got
.offset
= s
->size
;
1821 dyn
= htab
->root
.dynamic_sections_created
;
1822 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1823 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1826 h
->got
.offset
= (bfd_vma
) -1;
1828 if (h
->dyn_relocs
== NULL
)
1831 /* In the shared -Bsymbolic case, discard space allocated for
1832 dynamic pc-relative relocs against symbols which turn out to be
1833 defined in regular objects. For the normal shared case, discard
1834 space for pc-relative relocs that have become local due to symbol
1835 visibility changes. */
1837 if (bfd_link_pic (info
))
1843 struct elf_dyn_relocs
**pp
;
1845 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
;)
1847 p
->count
-= p
->pc_count
;
1856 /* Also discard relocs on undefined weak syms with non-default
1858 if (h
->dyn_relocs
!= NULL
1859 && h
->root
.type
== bfd_link_hash_undefweak
)
1861 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1862 h
->dyn_relocs
= NULL
;
1864 /* Make sure undefined weak symbols are output as a dynamic
1866 else if (h
->dynindx
== -1
1867 && !h
->forced_local
)
1869 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1876 /* For the non-shared case, discard space for relocs against
1877 symbols which turn out to need copy relocs or are not
1883 || (htab
->root
.dynamic_sections_created
1884 && (h
->root
.type
== bfd_link_hash_undefweak
1885 || h
->root
.type
== bfd_link_hash_undefined
))))
1887 /* Make sure this symbol is output as a dynamic symbol.
1888 Undefined weak syms won't yet be marked as dynamic. */
1889 if (h
->dynindx
== -1
1890 && !h
->forced_local
)
1892 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1896 /* If that succeeded, we know we'll be keeping all the
1898 if (h
->dynindx
!= -1)
1902 h
->dyn_relocs
= NULL
;
1907 /* Finally, allocate space. */
1908 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1910 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1911 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1917 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1918 read-only sections. */
1921 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1925 if (h
->root
.type
== bfd_link_hash_indirect
)
1928 sec
= _bfd_elf_readonly_dynrelocs (h
);
1931 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1933 info
->flags
|= DF_TEXTREL
;
1934 info
->callbacks
->minfo
1935 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1936 sec
->owner
, h
->root
.root
.string
, sec
);
1938 /* Not an error, just cut short the traversal. */
1944 /* Set the sizes of the dynamic sections. */
1947 lm32_elf_size_dynamic_sections (bfd
*output_bfd
,
1948 struct bfd_link_info
*info
)
1950 struct elf_lm32_link_hash_table
*htab
;
1956 htab
= lm32_elf_hash_table (info
);
1960 dynobj
= htab
->root
.dynobj
;
1961 BFD_ASSERT (dynobj
!= NULL
);
1963 if (htab
->root
.dynamic_sections_created
)
1965 /* Set the contents of the .interp section to the interpreter. */
1966 if (bfd_link_executable (info
) && !info
->nointerp
)
1968 s
= bfd_get_linker_section (dynobj
, ".interp");
1969 BFD_ASSERT (s
!= NULL
);
1970 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1971 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1975 /* Set up .got offsets for local syms, and space for local dynamic
1977 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1979 bfd_signed_vma
*local_got
;
1980 bfd_signed_vma
*end_local_got
;
1981 bfd_size_type locsymcount
;
1982 Elf_Internal_Shdr
*symtab_hdr
;
1985 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1988 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1990 struct elf_dyn_relocs
*p
;
1992 for (p
= ((struct elf_dyn_relocs
*)
1993 elf_section_data (s
)->local_dynrel
);
1997 if (! bfd_is_abs_section (p
->sec
)
1998 && bfd_is_abs_section (p
->sec
->output_section
))
2000 /* Input section has been discarded, either because
2001 it is a copy of a linkonce section or due to
2002 linker script /DISCARD/, so we'll be discarding
2005 else if (p
->count
!= 0)
2007 srel
= elf_section_data (p
->sec
)->sreloc
;
2008 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2009 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2010 info
->flags
|= DF_TEXTREL
;
2015 local_got
= elf_local_got_refcounts (ibfd
);
2019 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2020 locsymcount
= symtab_hdr
->sh_info
;
2021 end_local_got
= local_got
+ locsymcount
;
2022 s
= htab
->root
.sgot
;
2023 srel
= htab
->root
.srelgot
;
2024 for (; local_got
< end_local_got
; ++local_got
)
2028 *local_got
= s
->size
;
2030 if (bfd_link_pic (info
))
2031 srel
->size
+= sizeof (Elf32_External_Rela
);
2034 *local_got
= (bfd_vma
) -1;
2038 /* Allocate global sym .plt and .got entries, and space for global
2039 sym dynamic relocs. */
2040 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
2042 /* We now have determined the sizes of the various dynamic sections.
2043 Allocate memory for them. */
2045 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2047 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2050 if (s
== htab
->root
.splt
2051 || s
== htab
->root
.sgot
2052 || s
== htab
->root
.sgotplt
2053 || s
== htab
->sdynbss
)
2055 /* Strip this section if we don't need it; see the
2058 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
2060 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
)
2063 /* We use the reloc_count field as a counter if we need
2064 to copy relocs into the output file. */
2068 /* It's not one of our sections, so don't allocate space. */
2073 /* If we don't need this section, strip it from the
2074 output file. This is mostly to handle .rela.bss and
2075 .rela.plt. We must create both sections in
2076 create_dynamic_sections, because they must be created
2077 before the linker maps input sections to output
2078 sections. The linker does that before
2079 adjust_dynamic_symbol is called, and it is that
2080 function which decides whether anything needs to go
2081 into these sections. */
2082 s
->flags
|= SEC_EXCLUDE
;
2086 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2089 /* Allocate memory for the section contents. We use bfd_zalloc
2090 here in case unused entries are not reclaimed before the
2091 section's contents are written out. This should not happen,
2092 but this way if it does, we get a R_LM32_NONE reloc instead
2094 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2095 if (s
->contents
== NULL
)
2099 if (htab
->root
.dynamic_sections_created
)
2101 /* Add some entries to the .dynamic section. We fill in the
2102 values later, in lm32_elf_finish_dynamic_sections, but we
2103 must add the entries now so that we get the correct size for
2104 the .dynamic section. The DT_DEBUG entry is filled in by the
2105 dynamic linker and used by the debugger. */
2106 #define add_dynamic_entry(TAG, VAL) \
2107 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2109 if (bfd_link_executable (info
))
2111 if (! add_dynamic_entry (DT_DEBUG
, 0))
2115 if (htab
->root
.splt
->size
!= 0)
2117 if (! add_dynamic_entry (DT_PLTGOT
, 0)
2118 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
2119 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2120 || ! add_dynamic_entry (DT_JMPREL
, 0))
2126 if (! add_dynamic_entry (DT_RELA
, 0)
2127 || ! add_dynamic_entry (DT_RELASZ
, 0)
2128 || ! add_dynamic_entry (DT_RELAENT
,
2129 sizeof (Elf32_External_Rela
)))
2132 /* If any dynamic relocs apply to a read-only section,
2133 then we need a DT_TEXTREL entry. */
2134 if ((info
->flags
& DF_TEXTREL
) == 0)
2135 elf_link_hash_traverse (&htab
->root
, maybe_set_textrel
, info
);
2137 if ((info
->flags
& DF_TEXTREL
) != 0)
2139 if (! add_dynamic_entry (DT_TEXTREL
, 0))
2144 #undef add_dynamic_entry
2146 /* Allocate .rofixup section. */
2147 if (IS_FDPIC (output_bfd
))
2149 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2150 int rgot_weak_count
= 0;
2153 /* Look for deleted sections. */
2154 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2156 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2160 /* Count relocs that need .rofixup entires. */
2161 Elf_Internal_Rela
*internal_relocs
, *end
;
2162 internal_relocs
= elf_section_data (s
)->relocs
;
2163 if (internal_relocs
== NULL
)
2164 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2165 if (internal_relocs
!= NULL
)
2167 end
= internal_relocs
+ s
->reloc_count
;
2168 while (internal_relocs
< end
)
2170 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2171 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2172 unsigned long r_symndx
;
2173 struct elf_link_hash_entry
*h
;
2175 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2176 sym_hashes
= elf_sym_hashes (ibfd
);
2177 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2179 if (r_symndx
< symtab_hdr
->sh_info
)
2184 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2185 while (h
->root
.type
== bfd_link_hash_indirect
2186 || h
->root
.type
== bfd_link_hash_warning
)
2187 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2190 /* Don't generate entries for weak symbols. */
2191 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2193 if (!discarded_section (s
) && !((bfd_section_flags (s
) & SEC_ALLOC
) == 0))
2195 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2208 struct weak_symbol_list
*current
, *new_entry
;
2209 /* Is this symbol already in the list? */
2210 for (current
= list_start
; current
; current
= current
->next
)
2212 if (!strcmp (current
->name
, h
->root
.root
.string
))
2215 if (!current
&& !discarded_section (s
) && (bfd_section_flags (s
) & SEC_ALLOC
))
2217 /* Will this have an entry in the GOT. */
2218 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2220 /* Create a new entry. */
2221 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2224 new_entry
->name
= h
->root
.root
.string
;
2225 new_entry
->next
= NULL
;
2227 if (list_start
== NULL
)
2229 list_start
= new_entry
;
2230 list_end
= new_entry
;
2234 list_end
->next
= new_entry
;
2235 list_end
= new_entry
;
2237 /* Increase count of undefined weak symbols in the got. */
2253 list_end
= list_start
->next
;
2255 list_start
= list_end
;
2258 /* Size sections. */
2259 lm32fdpic_fixup32_section (info
)->size
2260 = (r32_count
+ (htab
->root
.sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2261 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2262 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2265 lm32fdpic_fixup32_section (info
)->contents
=
2266 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2267 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2275 /* Create dynamic sections when linking against a dynamic object. */
2278 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2280 struct elf_lm32_link_hash_table
*htab
;
2281 flagword flags
, pltflags
;
2283 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2284 int ptralign
= 2; /* 32bit */
2286 htab
= lm32_elf_hash_table (info
);
2290 /* Make sure we have a GOT - For the case where we have a dynamic object
2291 but none of the relocs in check_relocs */
2292 if (!_bfd_elf_create_got_section (abfd
, info
))
2294 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2296 if (! create_rofixup_section (abfd
, info
))
2300 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2301 .rel[a].bss sections. */
2302 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2303 | SEC_LINKER_CREATED
);
2306 pltflags
|= SEC_CODE
;
2307 if (bed
->plt_not_loaded
)
2308 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2309 if (bed
->plt_readonly
)
2310 pltflags
|= SEC_READONLY
;
2312 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2313 htab
->root
.splt
= s
;
2315 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2318 if (bed
->want_plt_sym
)
2320 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2322 struct bfd_link_hash_entry
*bh
= NULL
;
2323 struct elf_link_hash_entry
*h
;
2325 if (! (_bfd_generic_link_add_one_symbol
2326 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2327 (bfd_vma
) 0, NULL
, FALSE
,
2328 get_elf_backend_data (abfd
)->collect
, &bh
)))
2330 h
= (struct elf_link_hash_entry
*) bh
;
2332 h
->type
= STT_OBJECT
;
2333 htab
->root
.hplt
= h
;
2335 if (bfd_link_pic (info
)
2336 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2340 s
= bfd_make_section_anyway_with_flags (abfd
,
2341 bed
->default_use_rela_p
2342 ? ".rela.plt" : ".rel.plt",
2343 flags
| SEC_READONLY
);
2344 htab
->root
.srelplt
= s
;
2346 || !bfd_set_section_alignment (s
, ptralign
))
2349 if (htab
->root
.sgot
== NULL
2350 && !_bfd_elf_create_got_section (abfd
, info
))
2353 if (bed
->want_dynbss
)
2355 /* The .dynbss section is a place to put symbols which are defined
2356 by dynamic objects, are referenced by regular objects, and are
2357 not functions. We must allocate space for them in the process
2358 image and use a R_*_COPY reloc to tell the dynamic linker to
2359 initialize them at run time. The linker script puts the .dynbss
2360 section into the .bss section of the final image. */
2361 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2362 SEC_ALLOC
| SEC_LINKER_CREATED
);
2366 /* The .rel[a].bss section holds copy relocs. This section is not
2367 normally needed. We need to create it here, though, so that the
2368 linker will map it to an output section. We can't just create it
2369 only if we need it, because we will not know whether we need it
2370 until we have seen all the input files, and the first time the
2371 main linker code calls BFD after examining all the input files
2372 (size_dynamic_sections) the input sections have already been
2373 mapped to the output sections. If the section turns out not to
2374 be needed, we can discard it later. We will never need this
2375 section when generating a shared object, since they do not use
2377 if (! bfd_link_pic (info
))
2379 s
= bfd_make_section_anyway_with_flags (abfd
,
2380 (bed
->default_use_rela_p
2381 ? ".rela.bss" : ".rel.bss"),
2382 flags
| SEC_READONLY
);
2385 || !bfd_set_section_alignment (s
, ptralign
))
2393 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2396 lm32_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
2397 struct elf_link_hash_entry
*dir
,
2398 struct elf_link_hash_entry
*ind
)
2400 if (ind
->dyn_relocs
!= NULL
)
2402 if (dir
->dyn_relocs
!= NULL
)
2404 struct elf_dyn_relocs
**pp
;
2405 struct elf_dyn_relocs
*p
;
2407 /* Add reloc counts against the indirect sym to the direct sym
2408 list. Merge any entries against the same section. */
2409 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
;)
2411 struct elf_dyn_relocs
*q
;
2413 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
2414 if (q
->sec
== p
->sec
)
2416 q
->pc_count
+= p
->pc_count
;
2417 q
->count
+= p
->count
;
2424 *pp
= dir
->dyn_relocs
;
2427 dir
->dyn_relocs
= ind
->dyn_relocs
;
2428 ind
->dyn_relocs
= NULL
;
2431 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
2435 lm32_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2437 if (!bfd_link_relocatable (info
))
2439 if (!bfd_elf_stack_segment_size (output_bfd
, info
,
2440 "__stacksize", DEFAULT_STACK_SIZE
))
2443 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2445 sec
->size
= info
->stacksize
>= 0 ? info
->stacksize
: 0;
2452 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2456 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2457 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2460 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
2463 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2464 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2467 /* Copy the stack size. */
2468 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2469 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2471 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2473 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2474 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2476 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2478 /* Rewrite the phdrs, since we're only called after they were first written. */
2479 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2480 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2481 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2482 elf_elfheader (obfd
)->e_phnum
) != 0)
2494 #define ELF_ARCH bfd_arch_lm32
2495 #define ELF_TARGET_ID LM32_ELF_DATA
2496 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2497 #define ELF_MAXPAGESIZE 0x1000
2499 #define TARGET_BIG_SYM lm32_elf32_vec
2500 #define TARGET_BIG_NAME "elf32-lm32"
2502 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2503 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2504 #define elf_info_to_howto lm32_info_to_howto_rela
2505 #define elf_info_to_howto_rel NULL
2506 #define elf_backend_rela_normal 1
2507 #define elf_backend_object_p lm32_elf_object_p
2508 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2509 #define elf_backend_stack_align 8
2510 #define elf_backend_can_gc_sections 1
2511 #define elf_backend_can_refcount 1
2512 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2513 #define elf_backend_plt_readonly 1
2514 #define elf_backend_want_got_plt 1
2515 #define elf_backend_want_plt_sym 0
2516 #define elf_backend_got_header_size 12
2517 #define elf_backend_dtrel_excludes_plt 1
2518 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2519 #define elf_backend_check_relocs lm32_elf_check_relocs
2520 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2521 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2522 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2523 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2524 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2525 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2526 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2527 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2528 #define elf_backend_relocate_section lm32_elf_relocate_section
2530 #include "elf32-target.h"
2532 #undef ELF_MAXPAGESIZE
2533 #define ELF_MAXPAGESIZE 0x4000
2536 #undef TARGET_BIG_SYM
2537 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2538 #undef TARGET_BIG_NAME
2539 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2541 #define elf32_bed elf32_lm32fdpic_bed
2543 #undef elf_backend_always_size_sections
2544 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2545 #undef bfd_elf32_bfd_copy_private_bfd_data
2546 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2548 #include "elf32-target.h"