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 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1132 sym_hashes
= elf_sym_hashes (abfd
);
1133 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
1134 if (!elf_bad_symtab (abfd
))
1135 sym_hashes_end
-= symtab_hdr
->sh_info
;
1137 htab
= lm32_elf_hash_table (info
);
1141 dynobj
= htab
->root
.dynobj
;
1143 rel_end
= relocs
+ sec
->reloc_count
;
1144 for (rel
= relocs
; rel
< rel_end
; rel
++)
1147 struct elf_link_hash_entry
*h
;
1148 unsigned long r_symndx
;
1150 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1151 r_type
= ELF32_R_TYPE (rel
->r_info
);
1152 if (r_symndx
< symtab_hdr
->sh_info
)
1156 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1157 while (h
->root
.type
== bfd_link_hash_indirect
1158 || h
->root
.type
== bfd_link_hash_warning
)
1159 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1162 /* Some relocs require a global offset table. */
1163 if (htab
->root
.sgot
== NULL
)
1168 case R_LM32_GOTOFF_HI16
:
1169 case R_LM32_GOTOFF_LO16
:
1171 htab
->root
.dynobj
= dynobj
= abfd
;
1172 if (!_bfd_elf_create_got_section (dynobj
, info
))
1178 /* Some relocs require a rofixup table. */
1179 if (IS_FDPIC (abfd
))
1184 /* FDPIC requires a GOT if there is a .rofixup section
1185 (Normal ELF doesn't). */
1187 htab
->root
.dynobj
= dynobj
= abfd
;
1188 if (!_bfd_elf_create_got_section (dynobj
, info
))
1190 /* Create .rofixup section */
1191 if (htab
->sfixup32
== NULL
)
1193 if (! create_rofixup_section (dynobj
, info
))
1198 case R_LM32_GOTOFF_HI16
:
1199 case R_LM32_GOTOFF_LO16
:
1200 /* Create .rofixup section. */
1201 if (htab
->sfixup32
== NULL
)
1204 htab
->root
.dynobj
= dynobj
= abfd
;
1205 if (! create_rofixup_section (dynobj
, info
))
1216 h
->got
.refcount
+= 1;
1219 bfd_signed_vma
*local_got_refcounts
;
1221 /* This is a global offset table entry for a local symbol. */
1222 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1223 if (local_got_refcounts
== NULL
)
1227 size
= symtab_hdr
->sh_info
;
1228 size
*= sizeof (bfd_signed_vma
);
1229 local_got_refcounts
= bfd_zalloc (abfd
, size
);
1230 if (local_got_refcounts
== NULL
)
1232 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1234 local_got_refcounts
[r_symndx
] += 1;
1238 /* This relocation describes the C++ object vtable hierarchy.
1239 Reconstruct it for later use during GC. */
1240 case R_LM32_GNU_VTINHERIT
:
1241 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1245 /* This relocation describes which C++ vtable entries are actually
1246 used. Record for later use during GC. */
1247 case R_LM32_GNU_VTENTRY
:
1248 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1258 /* Finish up the dynamic sections. */
1261 lm32_elf_finish_dynamic_sections (bfd
*output_bfd
,
1262 struct bfd_link_info
*info
)
1264 struct elf_lm32_link_hash_table
*htab
;
1269 htab
= lm32_elf_hash_table (info
);
1273 dynobj
= htab
->root
.dynobj
;
1275 sgot
= htab
->root
.sgotplt
;
1276 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
1278 if (htab
->root
.dynamic_sections_created
)
1281 Elf32_External_Dyn
*dyncon
, *dynconend
;
1283 BFD_ASSERT (sgot
!= NULL
&& sdyn
!= NULL
);
1285 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1286 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
1288 for (; dyncon
< dynconend
; dyncon
++)
1290 Elf_Internal_Dyn dyn
;
1293 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1301 s
= htab
->root
.sgotplt
;
1304 s
= htab
->root
.srelplt
;
1306 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
1307 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1311 s
= htab
->root
.srelplt
;
1312 dyn
.d_un
.d_val
= s
->size
;
1313 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1318 /* Fill in the first entry in the procedure linkage table. */
1319 splt
= htab
->root
.splt
;
1320 if (splt
&& splt
->size
> 0)
1322 if (bfd_link_pic (info
))
1324 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD0
, splt
->contents
);
1325 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD1
, splt
->contents
+ 4);
1326 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD2
, splt
->contents
+ 8);
1327 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD3
, splt
->contents
+ 12);
1328 bfd_put_32 (output_bfd
, PLT0_PIC_ENTRY_WORD4
, splt
->contents
+ 16);
1333 /* addr = .got + 4 */
1334 addr
= sgot
->output_section
->vma
+ sgot
->output_offset
+ 4;
1335 bfd_put_32 (output_bfd
,
1336 PLT0_ENTRY_WORD0
| ((addr
>> 16) & 0xffff),
1338 bfd_put_32 (output_bfd
,
1339 PLT0_ENTRY_WORD1
| (addr
& 0xffff),
1340 splt
->contents
+ 4);
1341 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD2
, splt
->contents
+ 8);
1342 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD3
, splt
->contents
+ 12);
1343 bfd_put_32 (output_bfd
, PLT0_ENTRY_WORD4
, splt
->contents
+ 16);
1346 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1351 /* Fill in the first three entries in the global offset table. */
1352 if (sgot
&& sgot
->size
> 0)
1355 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1357 bfd_put_32 (output_bfd
,
1358 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1360 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
1361 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
1363 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1364 if (elf_section_data (sgot
->output_section
) != NULL
)
1365 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1368 if (lm32fdpic_fixup32_section (info
))
1370 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
1371 bfd_vma got_value
= hgot
->root
.u
.def
.value
1372 + hgot
->root
.u
.def
.section
->output_section
->vma
1373 + hgot
->root
.u
.def
.section
->output_offset
;
1374 struct bfd_link_hash_entry
*hend
;
1376 /* Last entry is pointer to GOT. */
1377 _lm32fdpic_add_rofixup (output_bfd
, lm32fdpic_fixup32_section (info
), got_value
);
1379 /* Check we wrote enough entries. */
1380 if (lm32fdpic_fixup32_section (info
)->size
1381 != (lm32fdpic_fixup32_section (info
)->reloc_count
* 4))
1384 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1386 (int64_t) (lm32fdpic_fixup32_section (info
)->size
/ 4),
1387 lm32fdpic_fixup32_section (info
)->reloc_count
);
1391 hend
= bfd_link_hash_lookup (info
->hash
, "__ROFIXUP_END__",
1392 FALSE
, FALSE
, TRUE
);
1394 && (hend
->type
== bfd_link_hash_defined
1395 || hend
->type
== bfd_link_hash_defweak
)
1396 && hend
->u
.def
.section
->output_section
!= NULL
)
1399 lm32fdpic_fixup32_section (info
)->output_section
->vma
1400 + lm32fdpic_fixup32_section (info
)->output_offset
1401 + lm32fdpic_fixup32_section (info
)->size
1402 - hend
->u
.def
.section
->output_section
->vma
1403 - hend
->u
.def
.section
->output_offset
;
1404 BFD_ASSERT (hend
->u
.def
.value
== value
);
1405 if (hend
->u
.def
.value
!= value
)
1408 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1409 PRId64
" != %" PRId64
,
1410 (int64_t) hend
->u
.def
.value
, (int64_t) value
);
1419 /* Finish up dynamic symbol handling. We set the contents of various
1420 dynamic sections here. */
1423 lm32_elf_finish_dynamic_symbol (bfd
*output_bfd
,
1424 struct bfd_link_info
*info
,
1425 struct elf_link_hash_entry
*h
,
1426 Elf_Internal_Sym
*sym
)
1428 struct elf_lm32_link_hash_table
*htab
;
1431 htab
= lm32_elf_hash_table (info
);
1435 if (h
->plt
.offset
!= (bfd_vma
) -1)
1443 Elf_Internal_Rela rela
;
1445 /* This symbol has an entry in the procedure linkage table. Set
1447 BFD_ASSERT (h
->dynindx
!= -1);
1449 splt
= htab
->root
.splt
;
1450 sgot
= htab
->root
.sgotplt
;
1451 srela
= htab
->root
.srelplt
;
1452 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1454 /* Get the index in the procedure linkage table which
1455 corresponds to this symbol. This is the index of this symbol
1456 in all the symbols for which we are making plt entries. The
1457 first entry in the procedure linkage table is reserved. */
1458 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1460 /* Get the offset into the .got table of the entry that
1461 corresponds to this function. Each .got entry is 4 bytes.
1462 The first three are reserved. */
1463 got_offset
= (plt_index
+ 3) * 4;
1465 /* Fill in the entry in the procedure linkage table. */
1466 if (! bfd_link_pic (info
))
1475 /* Fill in the entry in the global offset table. */
1476 bfd_put_32 (output_bfd
,
1477 (splt
->output_section
->vma
1478 + splt
->output_offset
1480 + 12), /* same offset */
1481 sgot
->contents
+ got_offset
);
1483 /* Fill in the entry in the .rela.plt section. */
1484 rela
.r_offset
= (sgot
->output_section
->vma
1485 + sgot
->output_offset
1487 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_JMP_SLOT
);
1489 loc
= srela
->contents
;
1490 loc
+= plt_index
* sizeof (Elf32_External_Rela
);
1491 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1493 if (!h
->def_regular
)
1495 /* Mark the symbol as undefined, rather than as defined in
1496 the .plt section. Leave the value alone. */
1497 sym
->st_shndx
= SHN_UNDEF
;
1502 if (h
->got
.offset
!= (bfd_vma
) -1)
1506 Elf_Internal_Rela rela
;
1508 /* This symbol has an entry in the global offset table. Set it
1510 sgot
= htab
->root
.sgot
;
1511 srela
= htab
->root
.srelgot
;
1512 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1514 rela
.r_offset
= (sgot
->output_section
->vma
1515 + sgot
->output_offset
1516 + (h
->got
.offset
&~ 1));
1518 /* If this is a -Bsymbolic link, and the symbol is defined
1519 locally, we just want to emit a RELATIVE reloc. Likewise if
1520 the symbol was forced to be local because of a version file.
1521 The entry in the global offset table will already have been
1522 initialized in the relocate_section function. */
1523 if (bfd_link_pic (info
)
1529 rela
.r_info
= ELF32_R_INFO (0, R_LM32_RELATIVE
);
1530 rela
.r_addend
= (h
->root
.u
.def
.value
1531 + h
->root
.u
.def
.section
->output_section
->vma
1532 + h
->root
.u
.def
.section
->output_offset
);
1536 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
1537 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1538 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_GLOB_DAT
);
1542 loc
= srela
->contents
;
1543 loc
+= srela
->reloc_count
* sizeof (Elf32_External_Rela
);
1544 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1545 ++srela
->reloc_count
;
1551 Elf_Internal_Rela rela
;
1553 /* This symbols needs a copy reloc. Set it up. */
1554 BFD_ASSERT (h
->dynindx
!= -1
1555 && (h
->root
.type
== bfd_link_hash_defined
1556 || h
->root
.type
== bfd_link_hash_defweak
));
1558 s
= bfd_get_linker_section (htab
->root
.dynobj
, ".rela.bss");
1559 BFD_ASSERT (s
!= NULL
);
1561 rela
.r_offset
= (h
->root
.u
.def
.value
1562 + h
->root
.u
.def
.section
->output_section
->vma
1563 + h
->root
.u
.def
.section
->output_offset
);
1564 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_LM32_COPY
);
1567 loc
+= s
->reloc_count
* sizeof (Elf32_External_Rela
);
1568 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
1572 /* Mark some specially defined symbols as absolute. */
1573 if (h
== htab
->root
.hdynamic
|| h
== htab
->root
.hgot
)
1574 sym
->st_shndx
= SHN_ABS
;
1579 static enum elf_reloc_type_class
1580 lm32_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1581 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1582 const Elf_Internal_Rela
*rela
)
1584 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1586 case R_LM32_RELATIVE
: return reloc_class_relative
;
1587 case R_LM32_JMP_SLOT
: return reloc_class_plt
;
1588 case R_LM32_COPY
: return reloc_class_copy
;
1589 default: return reloc_class_normal
;
1593 /* Adjust a symbol defined by a dynamic object and referenced by a
1594 regular object. The current definition is in some section of the
1595 dynamic object, but we're not including those sections. We have to
1596 change the definition to something the rest of the link can
1600 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1601 struct elf_link_hash_entry
*h
)
1603 struct elf_lm32_link_hash_table
*htab
;
1607 dynobj
= elf_hash_table (info
)->dynobj
;
1609 /* Make sure we know what is going on here. */
1610 BFD_ASSERT (dynobj
!= NULL
1615 && !h
->def_regular
)));
1617 /* If this is a function, put it in the procedure linkage table. We
1618 will fill in the contents of the procedure linkage table later,
1619 when we know the address of the .got section. */
1620 if (h
->type
== STT_FUNC
1623 if (! bfd_link_pic (info
)
1626 && h
->root
.type
!= bfd_link_hash_undefweak
1627 && h
->root
.type
!= bfd_link_hash_undefined
)
1629 /* This case can occur if we saw a PLT reloc in an input
1630 file, but the symbol was never referred to by a dynamic
1631 object. In such a case, we don't actually need to build
1632 a procedure linkage table, and we can just do a PCREL
1634 h
->plt
.offset
= (bfd_vma
) -1;
1641 h
->plt
.offset
= (bfd_vma
) -1;
1643 /* If this is a weak symbol, and there is a real definition, the
1644 processor independent code will have arranged for us to see the
1645 real definition first, and we can just use the same value. */
1646 if (h
->is_weakalias
)
1648 struct elf_link_hash_entry
*def
= weakdef (h
);
1649 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1650 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1651 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1655 /* This is a reference to a symbol defined by a dynamic object which
1656 is not a function. */
1658 /* If we are creating a shared library, we must presume that the
1659 only references to the symbol are via the global offset table.
1660 For such cases we need not do anything here; the relocations will
1661 be handled correctly by relocate_section. */
1662 if (bfd_link_pic (info
))
1665 /* If there are no references to this symbol that do not use the
1666 GOT, we don't need to generate a copy reloc. */
1667 if (!h
->non_got_ref
)
1670 /* If -z nocopyreloc was given, we won't generate them either. */
1671 if (0 && info
->nocopyreloc
)
1677 /* If we don't find any dynamic relocs in read-only sections, then
1678 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1679 if (0 && !_bfd_elf_readonly_dynrelocs (h
))
1685 /* We must allocate the symbol in our .dynbss section, which will
1686 become part of the .bss section of the executable. There will be
1687 an entry for this symbol in the .dynsym section. The dynamic
1688 object will contain position independent code, so all references
1689 from the dynamic object to this symbol will go through the global
1690 offset table. The dynamic linker will use the .dynsym entry to
1691 determine the address it must put in the global offset table, so
1692 both the dynamic object and the regular object will refer to the
1693 same memory location for the variable. */
1695 htab
= lm32_elf_hash_table (info
);
1700 BFD_ASSERT (s
!= NULL
);
1702 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1703 to copy the initial value out of the dynamic object and into the
1704 runtime process image. We need to remember the offset into the
1705 .rela.bss section we are going to use. */
1706 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1710 srel
= htab
->srelbss
;
1711 BFD_ASSERT (srel
!= NULL
);
1712 srel
->size
+= sizeof (Elf32_External_Rela
);
1716 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1719 /* Allocate space in .plt, .got and associated reloc sections for
1723 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1725 struct bfd_link_info
*info
;
1726 struct elf_lm32_link_hash_table
*htab
;
1727 struct elf_dyn_relocs
*p
;
1729 if (h
->root
.type
== bfd_link_hash_indirect
)
1732 info
= (struct bfd_link_info
*) inf
;
1733 htab
= lm32_elf_hash_table (info
);
1737 if (htab
->root
.dynamic_sections_created
1738 && h
->plt
.refcount
> 0)
1740 /* Make sure this symbol is output as a dynamic symbol.
1741 Undefined weak syms won't yet be marked as dynamic. */
1742 if (h
->dynindx
== -1
1743 && !h
->forced_local
)
1745 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1749 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1751 asection
*s
= htab
->root
.splt
;
1753 /* If this is the first .plt entry, make room for the special
1756 s
->size
+= PLT_ENTRY_SIZE
;
1758 h
->plt
.offset
= s
->size
;
1760 /* If this symbol is not defined in a regular file, and we are
1761 not generating a shared library, then set the symbol to this
1762 location in the .plt. This is required to make function
1763 pointers compare as equal between the normal executable and
1764 the shared library. */
1765 if (! bfd_link_pic (info
)
1768 h
->root
.u
.def
.section
= s
;
1769 h
->root
.u
.def
.value
= h
->plt
.offset
;
1772 /* Make room for this entry. */
1773 s
->size
+= PLT_ENTRY_SIZE
;
1775 /* We also need to make an entry in the .got.plt section, which
1776 will be placed in the .got section by the linker script. */
1777 htab
->root
.sgotplt
->size
+= 4;
1779 /* We also need to make an entry in the .rel.plt section. */
1780 htab
->root
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1784 h
->plt
.offset
= (bfd_vma
) -1;
1790 h
->plt
.offset
= (bfd_vma
) -1;
1794 if (h
->got
.refcount
> 0)
1799 /* Make sure this symbol is output as a dynamic symbol.
1800 Undefined weak syms won't yet be marked as dynamic. */
1801 if (h
->dynindx
== -1
1802 && !h
->forced_local
)
1804 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1808 s
= htab
->root
.sgot
;
1810 h
->got
.offset
= s
->size
;
1812 dyn
= htab
->root
.dynamic_sections_created
;
1813 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1814 htab
->root
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1817 h
->got
.offset
= (bfd_vma
) -1;
1819 if (h
->dyn_relocs
== NULL
)
1822 /* In the shared -Bsymbolic case, discard space allocated for
1823 dynamic pc-relative relocs against symbols which turn out to be
1824 defined in regular objects. For the normal shared case, discard
1825 space for pc-relative relocs that have become local due to symbol
1826 visibility changes. */
1828 if (bfd_link_pic (info
))
1834 struct elf_dyn_relocs
**pp
;
1836 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
;)
1838 p
->count
-= p
->pc_count
;
1847 /* Also discard relocs on undefined weak syms with non-default
1849 if (h
->dyn_relocs
!= NULL
1850 && h
->root
.type
== bfd_link_hash_undefweak
)
1852 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1853 h
->dyn_relocs
= NULL
;
1855 /* Make sure undefined weak symbols are output as a dynamic
1857 else if (h
->dynindx
== -1
1858 && !h
->forced_local
)
1860 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1867 /* For the non-shared case, discard space for relocs against
1868 symbols which turn out to need copy relocs or are not
1874 || (htab
->root
.dynamic_sections_created
1875 && (h
->root
.type
== bfd_link_hash_undefweak
1876 || h
->root
.type
== bfd_link_hash_undefined
))))
1878 /* Make sure this symbol is output as a dynamic symbol.
1879 Undefined weak syms won't yet be marked as dynamic. */
1880 if (h
->dynindx
== -1
1881 && !h
->forced_local
)
1883 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1887 /* If that succeeded, we know we'll be keeping all the
1889 if (h
->dynindx
!= -1)
1893 h
->dyn_relocs
= NULL
;
1898 /* Finally, allocate space. */
1899 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1901 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1902 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1908 /* Set the sizes of the dynamic sections. */
1911 lm32_elf_size_dynamic_sections (bfd
*output_bfd
,
1912 struct bfd_link_info
*info
)
1914 struct elf_lm32_link_hash_table
*htab
;
1920 htab
= lm32_elf_hash_table (info
);
1924 dynobj
= htab
->root
.dynobj
;
1925 BFD_ASSERT (dynobj
!= NULL
);
1927 if (htab
->root
.dynamic_sections_created
)
1929 /* Set the contents of the .interp section to the interpreter. */
1930 if (bfd_link_executable (info
) && !info
->nointerp
)
1932 s
= bfd_get_linker_section (dynobj
, ".interp");
1933 BFD_ASSERT (s
!= NULL
);
1934 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1935 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1939 /* Set up .got offsets for local syms, and space for local dynamic
1941 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1943 bfd_signed_vma
*local_got
;
1944 bfd_signed_vma
*end_local_got
;
1945 bfd_size_type locsymcount
;
1946 Elf_Internal_Shdr
*symtab_hdr
;
1949 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1952 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1954 struct elf_dyn_relocs
*p
;
1956 for (p
= ((struct elf_dyn_relocs
*)
1957 elf_section_data (s
)->local_dynrel
);
1961 if (! bfd_is_abs_section (p
->sec
)
1962 && bfd_is_abs_section (p
->sec
->output_section
))
1964 /* Input section has been discarded, either because
1965 it is a copy of a linkonce section or due to
1966 linker script /DISCARD/, so we'll be discarding
1969 else if (p
->count
!= 0)
1971 srel
= elf_section_data (p
->sec
)->sreloc
;
1972 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1973 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1974 info
->flags
|= DF_TEXTREL
;
1979 local_got
= elf_local_got_refcounts (ibfd
);
1983 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1984 locsymcount
= symtab_hdr
->sh_info
;
1985 end_local_got
= local_got
+ locsymcount
;
1986 s
= htab
->root
.sgot
;
1987 srel
= htab
->root
.srelgot
;
1988 for (; local_got
< end_local_got
; ++local_got
)
1992 *local_got
= s
->size
;
1994 if (bfd_link_pic (info
))
1995 srel
->size
+= sizeof (Elf32_External_Rela
);
1998 *local_got
= (bfd_vma
) -1;
2002 /* Allocate global sym .plt and .got entries, and space for global
2003 sym dynamic relocs. */
2004 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
2006 /* We now have determined the sizes of the various dynamic sections.
2007 Allocate memory for them. */
2009 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2011 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2014 if (s
== htab
->root
.splt
2015 || s
== htab
->root
.sgot
2016 || s
== htab
->root
.sgotplt
2017 || s
== htab
->sdynbss
)
2019 /* Strip this section if we don't need it; see the
2022 else if (CONST_STRNEQ (bfd_section_name (s
), ".rela"))
2024 if (s
->size
!= 0 && s
!= htab
->root
.srelplt
)
2027 /* We use the reloc_count field as a counter if we need
2028 to copy relocs into the output file. */
2032 /* It's not one of our sections, so don't allocate space. */
2037 /* If we don't need this section, strip it from the
2038 output file. This is mostly to handle .rela.bss and
2039 .rela.plt. We must create both sections in
2040 create_dynamic_sections, because they must be created
2041 before the linker maps input sections to output
2042 sections. The linker does that before
2043 adjust_dynamic_symbol is called, and it is that
2044 function which decides whether anything needs to go
2045 into these sections. */
2046 s
->flags
|= SEC_EXCLUDE
;
2050 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2053 /* Allocate memory for the section contents. We use bfd_zalloc
2054 here in case unused entries are not reclaimed before the
2055 section's contents are written out. This should not happen,
2056 but this way if it does, we get a R_LM32_NONE reloc instead
2058 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
2059 if (s
->contents
== NULL
)
2063 if (htab
->root
.dynamic_sections_created
)
2065 /* Add some entries to the .dynamic section. We fill in the
2066 values later, in lm32_elf_finish_dynamic_sections, but we
2067 must add the entries now so that we get the correct size for
2068 the .dynamic section. The DT_DEBUG entry is filled in by the
2069 dynamic linker and used by the debugger. */
2070 #define add_dynamic_entry(TAG, VAL) \
2071 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2073 if (bfd_link_executable (info
))
2075 if (! add_dynamic_entry (DT_DEBUG
, 0))
2079 if (htab
->root
.splt
->size
!= 0)
2081 if (! add_dynamic_entry (DT_PLTGOT
, 0)
2082 || ! add_dynamic_entry (DT_PLTRELSZ
, 0)
2083 || ! add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2084 || ! add_dynamic_entry (DT_JMPREL
, 0))
2090 if (! add_dynamic_entry (DT_RELA
, 0)
2091 || ! add_dynamic_entry (DT_RELASZ
, 0)
2092 || ! add_dynamic_entry (DT_RELAENT
,
2093 sizeof (Elf32_External_Rela
)))
2096 /* If any dynamic relocs apply to a read-only section,
2097 then we need a DT_TEXTREL entry. */
2098 if ((info
->flags
& DF_TEXTREL
) == 0)
2099 elf_link_hash_traverse (&htab
->root
,
2100 _bfd_elf_maybe_set_textrel
, info
);
2102 if ((info
->flags
& DF_TEXTREL
) != 0)
2104 if (! add_dynamic_entry (DT_TEXTREL
, 0))
2109 #undef add_dynamic_entry
2111 /* Allocate .rofixup section. */
2112 if (IS_FDPIC (output_bfd
))
2114 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2115 int rgot_weak_count
= 0;
2118 /* Look for deleted sections. */
2119 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2121 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2125 /* Count relocs that need .rofixup entires. */
2126 Elf_Internal_Rela
*internal_relocs
, *end
;
2127 internal_relocs
= elf_section_data (s
)->relocs
;
2128 if (internal_relocs
== NULL
)
2129 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2130 if (internal_relocs
!= NULL
)
2132 end
= internal_relocs
+ s
->reloc_count
;
2133 while (internal_relocs
< end
)
2135 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2136 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2137 unsigned long r_symndx
;
2138 struct elf_link_hash_entry
*h
;
2140 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2141 sym_hashes
= elf_sym_hashes (ibfd
);
2142 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2144 if (r_symndx
< symtab_hdr
->sh_info
)
2149 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2150 while (h
->root
.type
== bfd_link_hash_indirect
2151 || h
->root
.type
== bfd_link_hash_warning
)
2152 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2155 /* Don't generate entries for weak symbols. */
2156 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2158 if (!discarded_section (s
) && !((bfd_section_flags (s
) & SEC_ALLOC
) == 0))
2160 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2173 struct weak_symbol_list
*current
, *new_entry
;
2174 /* Is this symbol already in the list? */
2175 for (current
= list_start
; current
; current
= current
->next
)
2177 if (!strcmp (current
->name
, h
->root
.root
.string
))
2180 if (!current
&& !discarded_section (s
) && (bfd_section_flags (s
) & SEC_ALLOC
))
2182 /* Will this have an entry in the GOT. */
2183 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2185 /* Create a new entry. */
2186 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2189 new_entry
->name
= h
->root
.root
.string
;
2190 new_entry
->next
= NULL
;
2192 if (list_start
== NULL
)
2194 list_start
= new_entry
;
2195 list_end
= new_entry
;
2199 list_end
->next
= new_entry
;
2200 list_end
= new_entry
;
2202 /* Increase count of undefined weak symbols in the got. */
2218 list_end
= list_start
->next
;
2220 list_start
= list_end
;
2223 /* Size sections. */
2224 lm32fdpic_fixup32_section (info
)->size
2225 = (r32_count
+ (htab
->root
.sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2226 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2227 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2230 lm32fdpic_fixup32_section (info
)->contents
=
2231 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2232 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2240 /* Create dynamic sections when linking against a dynamic object. */
2243 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2245 struct elf_lm32_link_hash_table
*htab
;
2246 flagword flags
, pltflags
;
2248 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2249 int ptralign
= 2; /* 32bit */
2251 htab
= lm32_elf_hash_table (info
);
2255 /* Make sure we have a GOT - For the case where we have a dynamic object
2256 but none of the relocs in check_relocs */
2257 if (!_bfd_elf_create_got_section (abfd
, info
))
2259 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2261 if (! create_rofixup_section (abfd
, info
))
2265 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2266 .rel[a].bss sections. */
2267 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2268 | SEC_LINKER_CREATED
);
2271 pltflags
|= SEC_CODE
;
2272 if (bed
->plt_not_loaded
)
2273 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2274 if (bed
->plt_readonly
)
2275 pltflags
|= SEC_READONLY
;
2277 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2278 htab
->root
.splt
= s
;
2280 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2283 if (bed
->want_plt_sym
)
2285 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2287 struct bfd_link_hash_entry
*bh
= NULL
;
2288 struct elf_link_hash_entry
*h
;
2290 if (! (_bfd_generic_link_add_one_symbol
2291 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2292 (bfd_vma
) 0, NULL
, FALSE
,
2293 get_elf_backend_data (abfd
)->collect
, &bh
)))
2295 h
= (struct elf_link_hash_entry
*) bh
;
2297 h
->type
= STT_OBJECT
;
2298 htab
->root
.hplt
= h
;
2300 if (bfd_link_pic (info
)
2301 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2305 s
= bfd_make_section_anyway_with_flags (abfd
,
2306 bed
->default_use_rela_p
2307 ? ".rela.plt" : ".rel.plt",
2308 flags
| SEC_READONLY
);
2309 htab
->root
.srelplt
= s
;
2311 || !bfd_set_section_alignment (s
, ptralign
))
2314 if (htab
->root
.sgot
== NULL
2315 && !_bfd_elf_create_got_section (abfd
, info
))
2318 if (bed
->want_dynbss
)
2320 /* The .dynbss section is a place to put symbols which are defined
2321 by dynamic objects, are referenced by regular objects, and are
2322 not functions. We must allocate space for them in the process
2323 image and use a R_*_COPY reloc to tell the dynamic linker to
2324 initialize them at run time. The linker script puts the .dynbss
2325 section into the .bss section of the final image. */
2326 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2327 SEC_ALLOC
| SEC_LINKER_CREATED
);
2331 /* The .rel[a].bss section holds copy relocs. This section is not
2332 normally needed. We need to create it here, though, so that the
2333 linker will map it to an output section. We can't just create it
2334 only if we need it, because we will not know whether we need it
2335 until we have seen all the input files, and the first time the
2336 main linker code calls BFD after examining all the input files
2337 (size_dynamic_sections) the input sections have already been
2338 mapped to the output sections. If the section turns out not to
2339 be needed, we can discard it later. We will never need this
2340 section when generating a shared object, since they do not use
2342 if (! bfd_link_pic (info
))
2344 s
= bfd_make_section_anyway_with_flags (abfd
,
2345 (bed
->default_use_rela_p
2346 ? ".rela.bss" : ".rel.bss"),
2347 flags
| SEC_READONLY
);
2350 || !bfd_set_section_alignment (s
, ptralign
))
2359 lm32_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2361 if (!bfd_link_relocatable (info
))
2363 if (!bfd_elf_stack_segment_size (output_bfd
, info
,
2364 "__stacksize", DEFAULT_STACK_SIZE
))
2367 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2369 sec
->size
= info
->stacksize
>= 0 ? info
->stacksize
: 0;
2376 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2380 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2381 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2384 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
2387 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2388 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2391 /* Copy the stack size. */
2392 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2393 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2395 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2397 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2398 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2400 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2402 /* Rewrite the phdrs, since we're only called after they were first written. */
2403 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2404 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2405 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2406 elf_elfheader (obfd
)->e_phnum
) != 0)
2418 #define ELF_ARCH bfd_arch_lm32
2419 #define ELF_TARGET_ID LM32_ELF_DATA
2420 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2421 #define ELF_MAXPAGESIZE 0x1000
2423 #define TARGET_BIG_SYM lm32_elf32_vec
2424 #define TARGET_BIG_NAME "elf32-lm32"
2426 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2427 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2428 #define elf_info_to_howto lm32_info_to_howto_rela
2429 #define elf_info_to_howto_rel NULL
2430 #define elf_backend_rela_normal 1
2431 #define elf_backend_object_p lm32_elf_object_p
2432 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2433 #define elf_backend_stack_align 8
2434 #define elf_backend_can_gc_sections 1
2435 #define elf_backend_can_refcount 1
2436 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2437 #define elf_backend_plt_readonly 1
2438 #define elf_backend_want_got_plt 1
2439 #define elf_backend_want_plt_sym 0
2440 #define elf_backend_got_header_size 12
2441 #define elf_backend_dtrel_excludes_plt 1
2442 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2443 #define elf_backend_check_relocs lm32_elf_check_relocs
2444 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2445 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2446 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2447 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2448 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2449 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2450 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2451 #define elf_backend_relocate_section lm32_elf_relocate_section
2453 #include "elf32-target.h"
2455 #undef ELF_MAXPAGESIZE
2456 #define ELF_MAXPAGESIZE 0x4000
2459 #undef TARGET_BIG_SYM
2460 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2461 #undef TARGET_BIG_NAME
2462 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2464 #define elf32_bed elf32_lm32fdpic_bed
2466 #undef elf_backend_always_size_sections
2467 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2468 #undef bfd_elf32_bfd_copy_private_bfd_data
2469 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2471 #include "elf32-target.h"