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 (!_bfd_elf_add_dynamic_tags (output_bfd
, info
, relocs
))
2066 /* Allocate .rofixup section. */
2067 if (IS_FDPIC (output_bfd
))
2069 struct weak_symbol_list
*list_start
= NULL
, *list_end
= NULL
;
2070 int rgot_weak_count
= 0;
2073 /* Look for deleted sections. */
2074 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2076 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2080 /* Count relocs that need .rofixup entires. */
2081 Elf_Internal_Rela
*internal_relocs
, *end
;
2082 internal_relocs
= elf_section_data (s
)->relocs
;
2083 if (internal_relocs
== NULL
)
2084 internal_relocs
= (_bfd_elf_link_read_relocs (ibfd
, s
, NULL
, NULL
, FALSE
));
2085 if (internal_relocs
!= NULL
)
2087 end
= internal_relocs
+ s
->reloc_count
;
2088 while (internal_relocs
< end
)
2090 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2091 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
2092 unsigned long r_symndx
;
2093 struct elf_link_hash_entry
*h
;
2095 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2096 sym_hashes
= elf_sym_hashes (ibfd
);
2097 r_symndx
= ELF32_R_SYM (internal_relocs
->r_info
);
2099 if (r_symndx
< symtab_hdr
->sh_info
)
2104 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2105 while (h
->root
.type
== bfd_link_hash_indirect
2106 || h
->root
.type
== bfd_link_hash_warning
)
2107 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2110 /* Don't generate entries for weak symbols. */
2111 if (!h
|| (h
&& h
->root
.type
!= bfd_link_hash_undefweak
))
2113 if (!discarded_section (s
) && !((bfd_section_flags (s
) & SEC_ALLOC
) == 0))
2115 switch (ELF32_R_TYPE (internal_relocs
->r_info
))
2128 struct weak_symbol_list
*current
, *new_entry
;
2129 /* Is this symbol already in the list? */
2130 for (current
= list_start
; current
; current
= current
->next
)
2132 if (!strcmp (current
->name
, h
->root
.root
.string
))
2135 if (!current
&& !discarded_section (s
) && (bfd_section_flags (s
) & SEC_ALLOC
))
2137 /* Will this have an entry in the GOT. */
2138 if (ELF32_R_TYPE (internal_relocs
->r_info
) == R_LM32_16_GOT
)
2140 /* Create a new entry. */
2141 new_entry
= malloc (sizeof (struct weak_symbol_list
));
2144 new_entry
->name
= h
->root
.root
.string
;
2145 new_entry
->next
= NULL
;
2147 if (list_start
== NULL
)
2149 list_start
= new_entry
;
2150 list_end
= new_entry
;
2154 list_end
->next
= new_entry
;
2155 list_end
= new_entry
;
2157 /* Increase count of undefined weak symbols in the got. */
2173 list_end
= list_start
->next
;
2175 list_start
= list_end
;
2178 /* Size sections. */
2179 lm32fdpic_fixup32_section (info
)->size
2180 = (r32_count
+ (htab
->root
.sgot
->size
/ 4) - rgot_weak_count
+ 1) * 4;
2181 if (lm32fdpic_fixup32_section (info
)->size
== 0)
2182 lm32fdpic_fixup32_section (info
)->flags
|= SEC_EXCLUDE
;
2185 lm32fdpic_fixup32_section (info
)->contents
=
2186 bfd_zalloc (dynobj
, lm32fdpic_fixup32_section (info
)->size
);
2187 if (lm32fdpic_fixup32_section (info
)->contents
== NULL
)
2195 /* Create dynamic sections when linking against a dynamic object. */
2198 lm32_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2200 struct elf_lm32_link_hash_table
*htab
;
2201 flagword flags
, pltflags
;
2203 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2204 int ptralign
= 2; /* 32bit */
2206 htab
= lm32_elf_hash_table (info
);
2210 /* Make sure we have a GOT - For the case where we have a dynamic object
2211 but none of the relocs in check_relocs */
2212 if (!_bfd_elf_create_got_section (abfd
, info
))
2214 if (IS_FDPIC (abfd
) && (htab
->sfixup32
== NULL
))
2216 if (! create_rofixup_section (abfd
, info
))
2220 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2221 .rel[a].bss sections. */
2222 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2223 | SEC_LINKER_CREATED
);
2226 pltflags
|= SEC_CODE
;
2227 if (bed
->plt_not_loaded
)
2228 pltflags
&= ~ (SEC_LOAD
| SEC_HAS_CONTENTS
);
2229 if (bed
->plt_readonly
)
2230 pltflags
|= SEC_READONLY
;
2232 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
2233 htab
->root
.splt
= s
;
2235 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
2238 if (bed
->want_plt_sym
)
2240 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2242 struct bfd_link_hash_entry
*bh
= NULL
;
2243 struct elf_link_hash_entry
*h
;
2245 if (! (_bfd_generic_link_add_one_symbol
2246 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2247 (bfd_vma
) 0, NULL
, FALSE
,
2248 get_elf_backend_data (abfd
)->collect
, &bh
)))
2250 h
= (struct elf_link_hash_entry
*) bh
;
2252 h
->type
= STT_OBJECT
;
2253 htab
->root
.hplt
= h
;
2255 if (bfd_link_pic (info
)
2256 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2260 s
= bfd_make_section_anyway_with_flags (abfd
,
2261 bed
->default_use_rela_p
2262 ? ".rela.plt" : ".rel.plt",
2263 flags
| SEC_READONLY
);
2264 htab
->root
.srelplt
= s
;
2266 || !bfd_set_section_alignment (s
, ptralign
))
2269 if (htab
->root
.sgot
== NULL
2270 && !_bfd_elf_create_got_section (abfd
, info
))
2273 if (bed
->want_dynbss
)
2275 /* The .dynbss section is a place to put symbols which are defined
2276 by dynamic objects, are referenced by regular objects, and are
2277 not functions. We must allocate space for them in the process
2278 image and use a R_*_COPY reloc to tell the dynamic linker to
2279 initialize them at run time. The linker script puts the .dynbss
2280 section into the .bss section of the final image. */
2281 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2282 SEC_ALLOC
| SEC_LINKER_CREATED
);
2286 /* The .rel[a].bss section holds copy relocs. This section is not
2287 normally needed. We need to create it here, though, so that the
2288 linker will map it to an output section. We can't just create it
2289 only if we need it, because we will not know whether we need it
2290 until we have seen all the input files, and the first time the
2291 main linker code calls BFD after examining all the input files
2292 (size_dynamic_sections) the input sections have already been
2293 mapped to the output sections. If the section turns out not to
2294 be needed, we can discard it later. We will never need this
2295 section when generating a shared object, since they do not use
2297 if (! bfd_link_pic (info
))
2299 s
= bfd_make_section_anyway_with_flags (abfd
,
2300 (bed
->default_use_rela_p
2301 ? ".rela.bss" : ".rel.bss"),
2302 flags
| SEC_READONLY
);
2305 || !bfd_set_section_alignment (s
, ptralign
))
2314 lm32_elf_always_size_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2316 if (!bfd_link_relocatable (info
))
2318 if (!bfd_elf_stack_segment_size (output_bfd
, info
,
2319 "__stacksize", DEFAULT_STACK_SIZE
))
2322 asection
*sec
= bfd_get_section_by_name (output_bfd
, ".stack");
2324 sec
->size
= info
->stacksize
>= 0 ? info
->stacksize
: 0;
2331 lm32_elf_fdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2335 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2336 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2339 if (! _bfd_elf_copy_private_bfd_data (ibfd
, obfd
))
2342 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
2343 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
2346 /* Copy the stack size. */
2347 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
2348 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2350 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
2352 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
2353 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
2355 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
2357 /* Rewrite the phdrs, since we're only called after they were first written. */
2358 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
2359 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
2360 || get_elf_backend_data (obfd
)->s
->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
2361 elf_elfheader (obfd
)->e_phnum
) != 0)
2373 #define ELF_ARCH bfd_arch_lm32
2374 #define ELF_TARGET_ID LM32_ELF_DATA
2375 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2376 #define ELF_MAXPAGESIZE 0x1000
2378 #define TARGET_BIG_SYM lm32_elf32_vec
2379 #define TARGET_BIG_NAME "elf32-lm32"
2381 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2382 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2383 #define elf_info_to_howto lm32_info_to_howto_rela
2384 #define elf_info_to_howto_rel NULL
2385 #define elf_backend_rela_normal 1
2386 #define elf_backend_object_p lm32_elf_object_p
2387 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2388 #define elf_backend_stack_align 8
2389 #define elf_backend_can_gc_sections 1
2390 #define elf_backend_can_refcount 1
2391 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2392 #define elf_backend_plt_readonly 1
2393 #define elf_backend_want_got_plt 1
2394 #define elf_backend_want_plt_sym 0
2395 #define elf_backend_got_header_size 12
2396 #define elf_backend_dtrel_excludes_plt 1
2397 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2398 #define elf_backend_check_relocs lm32_elf_check_relocs
2399 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2400 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2401 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2402 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2403 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2404 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2405 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2406 #define elf_backend_relocate_section lm32_elf_relocate_section
2408 #include "elf32-target.h"
2410 #undef ELF_MAXPAGESIZE
2411 #define ELF_MAXPAGESIZE 0x4000
2414 #undef TARGET_BIG_SYM
2415 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2416 #undef TARGET_BIG_NAME
2417 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2419 #define elf32_bed elf32_lm32fdpic_bed
2421 #undef elf_backend_always_size_sections
2422 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2423 #undef bfd_elf32_bfd_copy_private_bfd_data
2424 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2426 #include "elf32-target.h"