1 /* M32R-specific support for 32-bit ELF.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
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 2 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, MA 02110-1301, USA. */
27 static bfd_reloc_status_type m32r_elf_10_pcrel_reloc
28 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
29 static bfd_reloc_status_type m32r_elf_do_10_pcrel_reloc
30 PARAMS ((bfd *, reloc_howto_type *, asection *,
31 bfd_byte *, bfd_vma, asection *, bfd_vma, bfd_vma));
32 static bfd_reloc_status_type m32r_elf_hi16_reloc
33 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
34 static void m32r_elf_relocate_hi16
35 PARAMS ((bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *,
36 bfd_byte *, bfd_vma));
37 bfd_reloc_status_type m32r_elf_lo16_reloc
38 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39 bfd_reloc_status_type m32r_elf_generic_reloc
40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
41 static bfd_reloc_status_type m32r_elf_sda16_reloc
42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
44 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
45 static void m32r_info_to_howto_rel
46 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
47 static void m32r_info_to_howto
48 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
49 bfd_boolean _bfd_m32r_elf_section_from_bfd_section
50 PARAMS ((bfd *, asection *, int *));
51 void _bfd_m32r_elf_symbol_processing
52 PARAMS ((bfd *, asymbol *));
53 static bfd_boolean m32r_elf_add_symbol_hook
54 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
55 const char **, flagword *, asection **, bfd_vma *));
56 static bfd_boolean m32r_elf_relocate_section
57 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
58 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
59 static bfd_reloc_status_type m32r_elf_final_sda_base
60 PARAMS ((bfd *, struct bfd_link_info *, const char **, bfd_vma *));
61 static bfd_boolean m32r_elf_object_p
63 static void m32r_elf_final_write_processing
64 PARAMS ((bfd *, bfd_boolean));
65 static bfd_boolean m32r_elf_set_private_flags
66 PARAMS ((bfd *, flagword));
67 static bfd_boolean m32r_elf_merge_private_bfd_data
68 PARAMS ((bfd *, bfd *));
69 static bfd_boolean m32r_elf_print_private_bfd_data
70 PARAMS ((bfd *, PTR));
71 static bfd_boolean m32r_elf_gc_sweep_hook
72 PARAMS ((bfd *, struct bfd_link_info *, asection *,
73 const Elf_Internal_Rela *));
74 static bfd_boolean m32r_elf_check_relocs
75 PARAMS ((bfd *, struct bfd_link_info *, asection *,
76 const Elf_Internal_Rela *));
78 static bfd_boolean m32r_elf_adjust_dynamic_symbol
79 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
80 static bfd_boolean m32r_elf_size_dynamic_sections
81 PARAMS ((bfd *, struct bfd_link_info *));
83 asection * m32r_elf_gc_mark_hook
84 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
85 struct elf_link_hash_entry *, Elf_Internal_Sym *));
87 static bfd_boolean m32r_elf_create_dynamic_sections
88 PARAMS ((bfd *, struct bfd_link_info *));
90 static bfd_boolean m32r_elf_finish_dynamic_sections
91 PARAMS ((bfd *, struct bfd_link_info *));
93 static bfd_boolean m32r_elf_finish_dynamic_symbol
94 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
97 static bfd_boolean allocate_dynrelocs
98 PARAMS ((struct elf_link_hash_entry *, PTR));
99 static bfd_boolean readonly_dynrelocs
100 PARAMS ((struct elf_link_hash_entry *, PTR));
101 static enum elf_reloc_type_class m32r_elf_reloc_type_class
102 PARAMS ((const Elf_Internal_Rela *));
103 static bfd_boolean m32r_elf_fake_sections
104 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
106 #define NOP_INSN 0x7000
107 #define MAKE_PARALLEL(insn) ((insn) | 0x8000)
109 /* Use REL instead of RELA to save space.
110 This only saves space in libraries and object files, but perhaps
111 relocs will be put in ROM? All in all though, REL relocs are a pain
118 /* Use RELA. But use REL to link old objects for backwords compatibility. */
120 /* Functions for the M32R ELF linker. */
122 /* The name of the dynamic interpreter. This is put in the .interp
125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
127 /* The nop opcode we use. */
129 #define M32R_NOP 0x7000f000
131 #define PLT_EMPTY 0x10101010 /* RIE -> RIE */
133 /* The size in bytes of an entry in the procedure linkage table. */
135 #define PLT_ENTRY_SIZE 20
136 #define PLT_HEADER_SIZE 20
138 /* The first one entries in a procedure linkage table are reserved,
139 and the initial contents are unimportant (we zero them out).
140 Subsequent entries look like this. */
142 #define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */
143 #define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */
144 #define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */
145 #define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */
146 #define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
148 #define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */
149 #define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */
150 #define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */
151 #define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */
152 #define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
154 #define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */
155 #define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */
156 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */
157 #define PLT_ENTRY_WORD1b 0x86e60000 /* or3 r6, r6, #low(.name_in_GOT) */
158 #define PLT_ENTRY_WORD2 0x26c61fc6 /* ld r6, @r6 -> jmp r6 */
159 #define PLT_ENTRY_WORD3 0xe5000000 /* ld24 r5, $offset */
160 #define PLT_ENTRY_WORD4 0xff000000 /* bra .plt0. */
163 static reloc_howto_type m32r_elf_howto_table[] =
165 /* This reloc does nothing. */
166 HOWTO (R_M32R_NONE, /* type */
168 2, /* size (0 = byte, 1 = short, 2 = long) */
170 FALSE, /* pc_relative */
172 complain_overflow_bitfield, /* complain_on_overflow */
173 bfd_elf_generic_reloc, /* special_function */
174 "R_M32R_NONE", /* name */
175 FALSE, /* partial_inplace */
178 FALSE), /* pcrel_offset */
180 /* A 16 bit absolute relocation. */
181 HOWTO (R_M32R_16, /* type */
183 1, /* size (0 = byte, 1 = short, 2 = long) */
185 FALSE, /* pc_relative */
187 complain_overflow_bitfield, /* complain_on_overflow */
188 m32r_elf_generic_reloc,/* special_function */
189 "R_M32R_16", /* name */
190 TRUE, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE), /* pcrel_offset */
195 /* A 32 bit absolute relocation. */
196 HOWTO (R_M32R_32, /* type */
198 2, /* size (0 = byte, 1 = short, 2 = long) */
200 FALSE, /* pc_relative */
202 complain_overflow_bitfield, /* complain_on_overflow */
203 m32r_elf_generic_reloc,/* special_function */
204 "R_M32R_32", /* name */
205 TRUE, /* partial_inplace */
206 0xffffffff, /* src_mask */
207 0xffffffff, /* dst_mask */
208 FALSE), /* pcrel_offset */
210 /* A 24 bit address. */
211 HOWTO (R_M32R_24, /* type */
213 2, /* size (0 = byte, 1 = short, 2 = long) */
215 FALSE, /* pc_relative */
217 complain_overflow_unsigned, /* complain_on_overflow */
218 m32r_elf_generic_reloc,/* special_function */
219 "R_M32R_24", /* name */
220 TRUE, /* partial_inplace */
221 0xffffff, /* src_mask */
222 0xffffff, /* dst_mask */
223 FALSE), /* pcrel_offset */
225 /* An PC Relative 10-bit relocation, shifted by 2.
226 This reloc is complicated because relocations are relative to pc & -4.
227 i.e. branches in the right insn slot use the address of the left insn
229 /* ??? It's not clear whether this should have partial_inplace set or not.
230 Branch relaxing in the assembler can store the addend in the insn,
231 and if bfd_install_relocation gets called the addend may get added
233 HOWTO (R_M32R_10_PCREL, /* type */
235 1, /* size (0 = byte, 1 = short, 2 = long) */
237 TRUE, /* pc_relative */
239 complain_overflow_signed, /* complain_on_overflow */
240 m32r_elf_10_pcrel_reloc, /* special_function */
241 "R_M32R_10_PCREL", /* name */
242 FALSE, /* partial_inplace */
245 TRUE), /* pcrel_offset */
247 /* A relative 18 bit relocation, right shifted by 2. */
248 HOWTO (R_M32R_18_PCREL, /* type */
250 2, /* size (0 = byte, 1 = short, 2 = long) */
252 TRUE, /* pc_relative */
254 complain_overflow_signed, /* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_M32R_18_PCREL", /* name */
257 FALSE, /* partial_inplace */
258 0xffff, /* src_mask */
259 0xffff, /* dst_mask */
260 TRUE), /* pcrel_offset */
262 /* A relative 26 bit relocation, right shifted by 2. */
263 /* ??? It's not clear whether this should have partial_inplace set or not.
264 Branch relaxing in the assembler can store the addend in the insn,
265 and if bfd_install_relocation gets called the addend may get added
267 HOWTO (R_M32R_26_PCREL, /* type */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
271 TRUE, /* pc_relative */
273 complain_overflow_signed, /* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_M32R_26_PCREL", /* name */
276 FALSE, /* partial_inplace */
277 0xffffff, /* src_mask */
278 0xffffff, /* dst_mask */
279 TRUE), /* pcrel_offset */
281 /* High 16 bits of address when lower 16 is or'd in. */
282 HOWTO (R_M32R_HI16_ULO, /* type */
284 2, /* size (0 = byte, 1 = short, 2 = long) */
286 FALSE, /* pc_relative */
288 complain_overflow_dont, /* complain_on_overflow */
289 m32r_elf_hi16_reloc, /* special_function */
290 "R_M32R_HI16_ULO", /* name */
291 TRUE, /* partial_inplace */
292 0x0000ffff, /* src_mask */
293 0x0000ffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
296 /* High 16 bits of address when lower 16 is added in. */
297 HOWTO (R_M32R_HI16_SLO, /* type */
299 2, /* size (0 = byte, 1 = short, 2 = long) */
301 FALSE, /* pc_relative */
303 complain_overflow_dont, /* complain_on_overflow */
304 m32r_elf_hi16_reloc, /* special_function */
305 "R_M32R_HI16_SLO", /* name */
306 TRUE, /* partial_inplace */
307 0x0000ffff, /* src_mask */
308 0x0000ffff, /* dst_mask */
309 FALSE), /* pcrel_offset */
311 /* Lower 16 bits of address. */
312 HOWTO (R_M32R_LO16, /* type */
314 2, /* size (0 = byte, 1 = short, 2 = long) */
316 FALSE, /* pc_relative */
318 complain_overflow_dont, /* complain_on_overflow */
319 m32r_elf_lo16_reloc, /* special_function */
320 "R_M32R_LO16", /* name */
321 TRUE, /* partial_inplace */
322 0x0000ffff, /* src_mask */
323 0x0000ffff, /* dst_mask */
324 FALSE), /* pcrel_offset */
326 /* Small data area 16 bits offset. */
327 HOWTO (R_M32R_SDA16, /* type */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
331 FALSE, /* pc_relative */
333 complain_overflow_signed, /* complain_on_overflow */
334 m32r_elf_sda16_reloc, /* special_function */
335 "R_M32R_SDA16", /* name */
336 TRUE, /* partial_inplace */ /* FIXME: correct? */
337 0x0000ffff, /* src_mask */
338 0x0000ffff, /* dst_mask */
339 FALSE), /* pcrel_offset */
341 /* GNU extension to record C++ vtable hierarchy */
342 HOWTO (R_M32R_GNU_VTINHERIT, /* type */
344 2, /* size (0 = byte, 1 = short, 2 = long) */
346 FALSE, /* pc_relative */
348 complain_overflow_dont, /* complain_on_overflow */
349 NULL, /* special_function */
350 "R_M32R_GNU_VTINHERIT", /* name */
351 FALSE, /* partial_inplace */
354 FALSE), /* pcrel_offset */
356 /* GNU extension to record C++ vtable member usage */
357 HOWTO (R_M32R_GNU_VTENTRY, /* type */
359 2, /* size (0 = byte, 1 = short, 2 = long) */
361 FALSE, /* pc_relative */
363 complain_overflow_dont, /* complain_on_overflow */
364 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
365 "R_M32R_GNU_VTENTRY", /* name */
366 FALSE, /* partial_inplace */
369 FALSE), /* pcrel_offset */
392 /* A 16 bit absolute relocation. */
393 HOWTO (R_M32R_16_RELA, /* type */
395 1, /* 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_M32R_16_RELA", /* name */
402 FALSE, /* partial_inplace */
403 0xffff, /* src_mask */
404 0xffff, /* dst_mask */
405 FALSE), /* pcrel_offset */
407 /* A 32 bit absolute relocation. */
408 HOWTO (R_M32R_32_RELA, /* type */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
412 FALSE, /* pc_relative */
414 complain_overflow_bitfield, /* complain_on_overflow */
415 bfd_elf_generic_reloc,/* special_function */
416 "R_M32R_32_RELA", /* name */
417 FALSE, /* partial_inplace */
418 0xffffffff, /* src_mask */
419 0xffffffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
422 /* A 24 bit address. */
423 HOWTO (R_M32R_24_RELA, /* type */
425 2, /* size (0 = byte, 1 = short, 2 = long) */
427 FALSE, /* pc_relative */
429 complain_overflow_unsigned, /* complain_on_overflow */
430 bfd_elf_generic_reloc,/* special_function */
431 "R_M32R_24_RELA", /* name */
432 FALSE, /* partial_inplace */
433 0xffffff, /* src_mask */
434 0xffffff, /* dst_mask */
435 FALSE), /* pcrel_offset */
437 HOWTO (R_M32R_10_PCREL_RELA, /* type */
439 1, /* size (0 = byte, 1 = short, 2 = long) */
441 TRUE, /* pc_relative */
443 complain_overflow_signed, /* complain_on_overflow */
444 m32r_elf_10_pcrel_reloc, /* special_function */
445 "R_M32R_10_PCREL_RELA",/* name */
446 FALSE, /* partial_inplace */
449 TRUE), /* pcrel_offset */
451 /* A relative 18 bit relocation, right shifted by 2. */
452 HOWTO (R_M32R_18_PCREL_RELA, /* type */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
456 TRUE, /* pc_relative */
458 complain_overflow_signed, /* complain_on_overflow */
459 bfd_elf_generic_reloc, /* special_function */
460 "R_M32R_18_PCREL_RELA",/* name */
461 FALSE, /* partial_inplace */
462 0xffff, /* src_mask */
463 0xffff, /* dst_mask */
464 TRUE), /* pcrel_offset */
466 /* A relative 26 bit relocation, right shifted by 2. */
467 HOWTO (R_M32R_26_PCREL_RELA, /* type */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
471 TRUE, /* pc_relative */
473 complain_overflow_signed, /* complain_on_overflow */
474 bfd_elf_generic_reloc, /* special_function */
475 "R_M32R_26_PCREL_RELA",/* name */
476 FALSE, /* partial_inplace */
477 0xffffff, /* src_mask */
478 0xffffff, /* dst_mask */
479 TRUE), /* pcrel_offset */
481 /* High 16 bits of address when lower 16 is or'd in. */
482 HOWTO (R_M32R_HI16_ULO_RELA, /* type */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
486 FALSE, /* pc_relative */
488 complain_overflow_dont, /* complain_on_overflow */
489 bfd_elf_generic_reloc, /* special_function */
490 "R_M32R_HI16_ULO_RELA",/* name */
491 FALSE, /* partial_inplace */
492 0x0000ffff, /* src_mask */
493 0x0000ffff, /* dst_mask */
494 FALSE), /* pcrel_offset */
496 /* High 16 bits of address when lower 16 is added in. */
497 HOWTO (R_M32R_HI16_SLO_RELA, /* type */
499 2, /* size (0 = byte, 1 = short, 2 = long) */
501 FALSE, /* pc_relative */
503 complain_overflow_dont, /* complain_on_overflow */
504 bfd_elf_generic_reloc, /* special_function */
505 "R_M32R_HI16_SLO_RELA",/* name */
506 FALSE, /* partial_inplace */
507 0x0000ffff, /* src_mask */
508 0x0000ffff, /* dst_mask */
509 FALSE), /* pcrel_offset */
511 /* Lower 16 bits of address. */
512 HOWTO (R_M32R_LO16_RELA, /* type */
514 2, /* size (0 = byte, 1 = short, 2 = long) */
516 FALSE, /* pc_relative */
518 complain_overflow_dont, /* complain_on_overflow */
519 bfd_elf_generic_reloc, /* special_function */
520 "R_M32R_LO16_RELA", /* name */
521 FALSE, /* partial_inplace */
522 0x0000ffff, /* src_mask */
523 0x0000ffff, /* dst_mask */
524 FALSE), /* pcrel_offset */
526 /* Small data area 16 bits offset. */
527 HOWTO (R_M32R_SDA16_RELA, /* type */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
531 FALSE, /* pc_relative */
533 complain_overflow_signed, /* complain_on_overflow */
534 bfd_elf_generic_reloc, /* special_function */
535 "R_M32R_SDA16_RELA", /* name */
536 TRUE, /* partial_inplace */ /* FIXME: correct? */
537 0x0000ffff, /* src_mask */
538 0x0000ffff, /* dst_mask */
539 FALSE), /* pcrel_offset */
541 /* GNU extension to record C++ vtable hierarchy */
542 HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */
544 2, /* size (0 = byte, 1 = short, 2 = long) */
546 FALSE, /* pc_relative */
548 complain_overflow_dont, /* complain_on_overflow */
549 NULL, /* special_function */
550 "R_M32R_RELA_GNU_VTINHERIT", /* name */
551 FALSE, /* partial_inplace */
554 FALSE), /* pcrel_offset */
556 /* GNU extension to record C++ vtable member usage */
557 HOWTO (R_M32R_RELA_GNU_VTENTRY, /* type */
559 2, /* size (0 = byte, 1 = short, 2 = long) */
561 FALSE, /* pc_relative */
563 complain_overflow_dont, /* complain_on_overflow */
564 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
565 "R_M32R_RELA_GNU_VTENTRY", /* name */
566 FALSE, /* partial_inplace */
569 FALSE), /* pcrel_offset */
575 /* Like R_M32R_24, but referring to the GOT table entry for
577 HOWTO (R_M32R_GOT24, /* type */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
581 FALSE, /* pc_relative */
583 complain_overflow_unsigned, /* complain_on_overflow */
584 bfd_elf_generic_reloc, /* special_function */
585 "R_M32R_GOT24", /* name */
586 FALSE, /* partial_inplace */
587 0xffffff, /* src_mask */
588 0xffffff, /* dst_mask */
589 FALSE), /* pcrel_offset */
591 /* Like R_M32R_PCREL, but referring to the procedure linkage table
592 entry for the symbol. */
593 HOWTO (R_M32R_26_PLTREL, /* type */
595 2, /* size (0 = byte, 1 = short, 2 = long) */
597 TRUE, /* pc_relative */
599 complain_overflow_signed, /* complain_on_overflow */
600 bfd_elf_generic_reloc, /* special_function */
601 "R_M32R_26_PLTREL", /* name */
602 FALSE, /* partial_inplace */
603 0xffffff, /* src_mask */
604 0xffffff, /* dst_mask */
605 TRUE), /* pcrel_offset */
607 /* This is used only by the dynamic linker. The symbol should exist
608 both in the object being run and in some shared library. The
609 dynamic linker copies the data addressed by the symbol from the
610 shared library into the object, because the object being
611 run has to have the data at some particular address. */
612 HOWTO (R_M32R_COPY, /* type */
614 2, /* size (0 = byte, 1 = short, 2 = long) */
616 FALSE, /* pc_relative */
618 complain_overflow_bitfield, /* complain_on_overflow */
619 bfd_elf_generic_reloc, /* special_function */
620 "R_M32R_COPY", /* name */
621 FALSE, /* partial_inplace */
622 0xffffffff, /* src_mask */
623 0xffffffff, /* dst_mask */
624 FALSE), /* pcrel_offset */
626 /* Like R_M32R_24, but used when setting global offset table
628 HOWTO (R_M32R_GLOB_DAT, /* type */
630 2, /* size (0 = byte, 1 = short, 2 = long) */
632 FALSE, /* pc_relative */
634 complain_overflow_bitfield, /* complain_on_overflow */
635 bfd_elf_generic_reloc, /* special_function */
636 "R_M32R_GLOB_DAT", /* name */
637 FALSE, /* partial_inplace */
638 0xffffffff, /* src_mask */
639 0xffffffff, /* dst_mask */
640 FALSE), /* pcrel_offset */
642 /* Marks a procedure linkage table entry for a symbol. */
643 HOWTO (R_M32R_JMP_SLOT, /* type */
645 2, /* size (0 = byte, 1 = short, 2 = long) */
647 FALSE, /* pc_relative */
649 complain_overflow_bitfield, /* complain_on_overflow */
650 bfd_elf_generic_reloc, /* special_function */
651 "R_M32R_JMP_SLOT", /* name */
652 FALSE, /* partial_inplace */
653 0xffffffff, /* src_mask */
654 0xffffffff, /* dst_mask */
655 FALSE), /* pcrel_offset */
657 /* Used only by the dynamic linker. When the object is run, this
658 longword is set to the load address of the object, plus the
660 HOWTO (R_M32R_RELATIVE, /* type */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
664 FALSE, /* pc_relative */
666 complain_overflow_bitfield, /* complain_on_overflow */
667 bfd_elf_generic_reloc, /* special_function */
668 "R_M32R_RELATIVE", /* name */
669 FALSE, /* partial_inplace */
670 0xffffffff, /* src_mask */
671 0xffffffff, /* dst_mask */
672 FALSE), /* pcrel_offset */
674 HOWTO (R_M32R_GOTOFF, /* type */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
678 FALSE, /* pc_relative */
680 complain_overflow_bitfield, /* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_M32R_GOTOFF", /* name */
683 FALSE, /* partial_inplace */
684 0xffffff, /* src_mask */
685 0xffffff, /* dst_mask */
686 FALSE), /* pcrel_offset */
688 /* An PC Relative 24-bit relocation used when setting PIC offset
690 HOWTO (R_M32R_GOTPC24, /* type */
692 2, /* size (0 = byte, 1 = short, 2 = long) */
694 TRUE, /* pc_relative */
696 complain_overflow_unsigned, /* complain_on_overflow */
697 bfd_elf_generic_reloc, /* special_function */
698 "R_M32R_GOTPC24", /* name */
699 FALSE, /* partial_inplace */
700 0xffffff, /* src_mask */
701 0xffffff, /* dst_mask */
702 TRUE), /* pcrel_offset */
704 /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for
706 HOWTO (R_M32R_GOT16_HI_ULO, /* type */
708 2, /* size (0 = byte, 1 = short, 2 = long) */
710 FALSE, /* pc_relative */
712 complain_overflow_dont, /* complain_on_overflow */
713 bfd_elf_generic_reloc, /* special_function */
714 "R_M32R_GOT16_HI_ULO", /* name */
715 FALSE, /* partial_inplace */
716 0x0000ffff, /* src_mask */
717 0x0000ffff, /* dst_mask */
718 FALSE), /* pcrel_offset */
720 /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for
722 HOWTO (R_M32R_GOT16_HI_SLO, /* type */
724 2, /* size (0 = byte, 1 = short, 2 = long) */
726 FALSE, /* pc_relative */
728 complain_overflow_dont, /* complain_on_overflow */
729 bfd_elf_generic_reloc, /* special_function */
730 "R_M32R_GOT16_HI_SLO", /* name */
731 FALSE, /* partial_inplace */
732 0x0000ffff, /* src_mask */
733 0x0000ffff, /* dst_mask */
734 FALSE), /* pcrel_offset */
736 /* Like R_M32R_LO16, but referring to the GOT table entry for
738 HOWTO (R_M32R_GOT16_LO, /* type */
740 2, /* size (0 = byte, 1 = short, 2 = long) */
742 FALSE, /* pc_relative */
744 complain_overflow_dont, /* complain_on_overflow */
745 bfd_elf_generic_reloc, /* special_function */
746 "R_M32R_GOT16_LO", /* name */
747 FALSE, /* partial_inplace */
748 0x0000ffff, /* src_mask */
749 0x0000ffff, /* dst_mask */
750 FALSE), /* pcrel_offset */
752 /* An PC Relative relocation used when setting PIC offset table register.
753 Like R_M32R_HI16_ULO, but referring to the GOT table entry for
755 HOWTO (R_M32R_GOTPC_HI_ULO, /* type */
757 2, /* size (0 = byte, 1 = short, 2 = long) */
759 FALSE, /* pc_relative */
761 complain_overflow_dont, /* complain_on_overflow */
762 bfd_elf_generic_reloc, /* special_function */
763 "R_M32R_GOTPC_HI_ULO", /* name */
764 FALSE, /* partial_inplace */
765 0x0000ffff, /* src_mask */
766 0x0000ffff, /* dst_mask */
767 TRUE), /* pcrel_offset */
769 /* An PC Relative relocation used when setting PIC offset table register.
770 Like R_M32R_HI16_SLO, but referring to the GOT table entry for
772 HOWTO (R_M32R_GOTPC_HI_SLO, /* type */
774 2, /* size (0 = byte, 1 = short, 2 = long) */
776 FALSE, /* pc_relative */
778 complain_overflow_dont, /* complain_on_overflow */
779 bfd_elf_generic_reloc, /* special_function */
780 "R_M32R_GOTPC_HI_SLO", /* name */
781 FALSE, /* partial_inplace */
782 0x0000ffff, /* src_mask */
783 0x0000ffff, /* dst_mask */
784 TRUE), /* pcrel_offset */
786 /* An PC Relative relocation used when setting PIC offset table register.
787 Like R_M32R_LO16, but referring to the GOT table entry for
789 HOWTO (R_M32R_GOTPC_LO, /* type */
791 2, /* size (0 = byte, 1 = short, 2 = long) */
793 FALSE, /* pc_relative */
795 complain_overflow_dont, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* special_function */
797 "R_M32R_GOTPC_LO", /* name */
798 FALSE, /* partial_inplace */
799 0x0000ffff, /* src_mask */
800 0x0000ffff, /* dst_mask */
801 TRUE), /* pcrel_offset */
803 HOWTO (R_M32R_GOTOFF_HI_ULO, /* type */
805 2, /* size (0 = byte, 1 = short, 2 = long) */
807 FALSE, /* pc_relative */
809 complain_overflow_dont, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* special_function */
811 "R_M32R_GOTOFF_HI_ULO",/* name */
812 FALSE, /* partial_inplace */
813 0x0000ffff, /* src_mask */
814 0x0000ffff, /* dst_mask */
815 FALSE), /* pcrel_offset */
817 HOWTO (R_M32R_GOTOFF_HI_SLO, /* type */
819 2, /* size (0 = byte, 1 = short, 2 = long) */
821 FALSE, /* pc_relative */
823 complain_overflow_dont, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
825 "R_M32R_GOTOFF_HI_SLO",/* name */
826 FALSE, /* partial_inplace */
827 0x0000ffff, /* src_mask */
828 0x0000ffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
831 HOWTO (R_M32R_GOTOFF_LO, /* type */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
835 FALSE, /* pc_relative */
837 complain_overflow_dont, /* complain_on_overflow */
838 bfd_elf_generic_reloc, /* special_function */
839 "R_M32R_GOTOFF_LO", /* name */
840 FALSE, /* partial_inplace */
841 0x0000ffff, /* src_mask */
842 0x0000ffff, /* dst_mask */
843 FALSE), /* pcrel_offset */
846 /* Handle the R_M32R_10_PCREL reloc. */
848 static bfd_reloc_status_type
849 m32r_elf_10_pcrel_reloc (abfd, reloc_entry, symbol, data,
850 input_section, output_bfd, error_message)
852 arelent * reloc_entry;
855 asection * input_section;
857 char ** error_message ATTRIBUTE_UNUSED;
859 /* This part is from bfd_elf_generic_reloc. */
860 if (output_bfd != (bfd *) NULL
861 && (symbol->flags & BSF_SECTION_SYM) == 0
862 && (! reloc_entry->howto->partial_inplace
863 || reloc_entry->addend == 0))
865 reloc_entry->address += input_section->output_offset;
869 if (output_bfd != NULL)
871 /* FIXME: See bfd_perform_relocation. Is this right? */
872 return bfd_reloc_continue;
875 return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
877 data, reloc_entry->address,
880 + symbol->section->output_section->vma
881 + symbol->section->output_offset),
882 reloc_entry->addend);
885 /* Utility to actually perform an R_M32R_10_PCREL reloc. */
887 static bfd_reloc_status_type
888 m32r_elf_do_10_pcrel_reloc (abfd, howto, input_section, data, offset,
889 symbol_section, symbol_value, addend)
891 reloc_howto_type *howto;
892 asection *input_section;
895 asection *symbol_section ATTRIBUTE_UNUSED;
896 bfd_vma symbol_value;
899 bfd_signed_vma relocation;
901 bfd_reloc_status_type status;
903 /* Sanity check the address (offset in section). */
904 if (offset > bfd_get_section_limit (abfd, input_section))
905 return bfd_reloc_outofrange;
907 relocation = symbol_value + addend;
908 /* Make it pc relative. */
909 relocation -= (input_section->output_section->vma
910 + input_section->output_offset);
911 /* These jumps mask off the lower two bits of the current address
912 before doing pcrel calculations. */
913 relocation -= (offset & -(bfd_vma) 4);
915 if (relocation < -0x200 || relocation > 0x1ff)
916 status = bfd_reloc_overflow;
918 status = bfd_reloc_ok;
920 x = bfd_get_16 (abfd, data + offset);
921 relocation >>= howto->rightshift;
922 relocation <<= howto->bitpos;
923 x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
924 bfd_put_16 (abfd, (bfd_vma) x, data + offset);
929 /* Handle the R_M32R_HI16_[SU]LO relocs.
930 HI16_SLO is for the add3 and load/store with displacement instructions.
931 HI16_ULO is for the or3 instruction.
932 For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
933 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
934 we must add one to the high 16 bytes (which will get subtracted off when
935 the low 16 bits are added).
936 These relocs have to be done in combination with an R_M32R_LO16 reloc
937 because there is a carry from the LO16 to the HI16. Here we just save
938 the information we need; we do the actual relocation when we see the LO16.
939 This code is copied from the elf32-mips.c. We also support an arbitrary
940 number of HI16 relocs to be associated with a single LO16 reloc. The
941 assembler sorts the relocs to ensure each HI16 immediately precedes its
942 LO16. However if there are multiple copies, the assembler may not find
943 the real LO16 so it picks the first one it finds. */
947 struct m32r_hi16 *next;
952 /* FIXME: This should not be a static variable. */
954 static struct m32r_hi16 *m32r_hi16_list;
956 static bfd_reloc_status_type
957 m32r_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
958 input_section, output_bfd, error_message)
959 bfd *abfd ATTRIBUTE_UNUSED;
960 arelent *reloc_entry;
963 asection *input_section;
965 char **error_message ATTRIBUTE_UNUSED;
967 bfd_reloc_status_type ret;
971 /* This part is from bfd_elf_generic_reloc.
972 If we're relocating, and this an external symbol, we don't want
973 to change anything. */
974 if (output_bfd != (bfd *) NULL
975 && (symbol->flags & BSF_SECTION_SYM) == 0
976 && reloc_entry->addend == 0)
978 reloc_entry->address += input_section->output_offset;
982 /* Sanity check the address (offset in section). */
983 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
984 return bfd_reloc_outofrange;
987 if (bfd_is_und_section (symbol->section)
988 && output_bfd == (bfd *) NULL)
989 ret = bfd_reloc_undefined;
991 if (bfd_is_com_section (symbol->section))
994 relocation = symbol->value;
996 relocation += symbol->section->output_section->vma;
997 relocation += symbol->section->output_offset;
998 relocation += reloc_entry->addend;
1000 /* Save the information, and let LO16 do the actual relocation. */
1001 n = (struct m32r_hi16 *) bfd_malloc ((bfd_size_type) sizeof *n);
1003 return bfd_reloc_outofrange;
1004 n->addr = (bfd_byte *) data + reloc_entry->address;
1005 n->addend = relocation;
1006 n->next = m32r_hi16_list;
1009 if (output_bfd != (bfd *) NULL)
1010 reloc_entry->address += input_section->output_offset;
1015 /* Handle an M32R ELF HI16 reloc. */
1018 m32r_elf_relocate_hi16 (input_bfd, type, relhi, rello, contents, addend)
1021 Elf_Internal_Rela *relhi;
1022 Elf_Internal_Rela *rello;
1029 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
1031 addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
1032 if (type == R_M32R_HI16_SLO)
1033 addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
1037 addend += ((insn & 0xffff) << 16) + addlo;
1039 /* Reaccount for sign extension of low part. */
1040 if (type == R_M32R_HI16_SLO
1041 && (addend & 0x8000) != 0)
1044 bfd_put_32 (input_bfd,
1045 (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
1046 contents + relhi->r_offset);
1049 /* Do an R_M32R_LO16 relocation. This is a straightforward 16 bit
1050 inplace relocation; this function exists in order to do the
1051 R_M32R_HI16_[SU]LO relocation described above. */
1053 bfd_reloc_status_type
1054 m32r_elf_lo16_reloc (input_bfd, reloc_entry, symbol, data,
1055 input_section, output_bfd, error_message)
1057 arelent *reloc_entry;
1060 asection *input_section;
1062 char **error_message;
1064 /* This part is from bfd_elf_generic_reloc.
1065 If we're relocating, and this an external symbol, we don't want
1066 to change anything. */
1067 if (output_bfd != (bfd *) NULL
1068 && (symbol->flags & BSF_SECTION_SYM) == 0
1069 && reloc_entry->addend == 0)
1071 reloc_entry->address += input_section->output_offset;
1072 return bfd_reloc_ok;
1075 if (m32r_hi16_list != NULL)
1077 struct m32r_hi16 *l;
1084 unsigned long vallo;
1085 struct m32r_hi16 *next;
1087 /* Do the HI16 relocation. Note that we actually don't need
1088 to know anything about the LO16 itself, except where to
1089 find the low 16 bits of the addend needed by the LO16. */
1090 insn = bfd_get_32 (input_bfd, l->addr);
1091 vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
1092 & 0xffff) ^ 0x8000) - 0x8000;
1093 val = ((insn & 0xffff) << 16) + vallo;
1096 /* Reaccount for sign extension of low part. */
1097 if ((val & 0x8000) != 0)
1100 insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
1101 bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
1108 m32r_hi16_list = NULL;
1111 /* Now do the LO16 reloc in the usual way.
1112 ??? It would be nice to call bfd_elf_generic_reloc here,
1113 but we have partial_inplace set. bfd_elf_generic_reloc will
1114 pass the handling back to bfd_install_relocation which will install
1115 a section relative addend which is wrong. */
1116 return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
1117 input_section, output_bfd, error_message);
1120 /* Do generic partial_inplace relocation.
1121 This is a local replacement for bfd_elf_generic_reloc. */
1123 bfd_reloc_status_type
1124 m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
1125 input_section, output_bfd, error_message)
1127 arelent *reloc_entry;
1130 asection *input_section;
1132 char **error_message ATTRIBUTE_UNUSED;
1134 bfd_reloc_status_type ret;
1136 bfd_byte *inplace_address;
1138 /* This part is from bfd_elf_generic_reloc.
1139 If we're relocating, and this an external symbol, we don't want
1140 to change anything. */
1141 if (output_bfd != (bfd *) NULL
1142 && (symbol->flags & BSF_SECTION_SYM) == 0
1143 && reloc_entry->addend == 0)
1145 reloc_entry->address += input_section->output_offset;
1146 return bfd_reloc_ok;
1149 /* Now do the reloc in the usual way.
1150 ??? It would be nice to call bfd_elf_generic_reloc here,
1151 but we have partial_inplace set. bfd_elf_generic_reloc will
1152 pass the handling back to bfd_install_relocation which will install
1153 a section relative addend which is wrong. */
1155 /* Sanity check the address (offset in section). */
1156 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
1157 return bfd_reloc_outofrange;
1160 if (bfd_is_und_section (symbol->section)
1161 && output_bfd == (bfd *) NULL)
1162 ret = bfd_reloc_undefined;
1164 if (bfd_is_com_section (symbol->section)
1165 || output_bfd != (bfd *) NULL)
1168 relocation = symbol->value;
1170 /* Only do this for a final link. */
1171 if (output_bfd == (bfd *) NULL)
1173 relocation += symbol->section->output_section->vma;
1174 relocation += symbol->section->output_offset;
1177 relocation += reloc_entry->addend;
1178 inplace_address = (bfd_byte *) data + reloc_entry->address;
1181 x = ( (x & ~reloc_entry->howto->dst_mask) | \
1182 (((x & reloc_entry->howto->src_mask) + relocation) & \
1183 reloc_entry->howto->dst_mask))
1185 switch (reloc_entry->howto->size)
1189 short x = bfd_get_16 (input_bfd, inplace_address);
1191 bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
1196 unsigned long x = bfd_get_32 (input_bfd, inplace_address);
1198 bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
1205 if (output_bfd != (bfd *) NULL)
1206 reloc_entry->address += input_section->output_offset;
1211 /* Handle the R_M32R_SDA16 reloc.
1212 This reloc is used to compute the address of objects in the small data area
1213 and to perform loads and stores from that area.
1214 The lower 16 bits are sign extended and added to the register specified
1215 in the instruction, which is assumed to point to _SDA_BASE_. */
1217 static bfd_reloc_status_type
1218 m32r_elf_sda16_reloc (abfd, reloc_entry, symbol, data,
1219 input_section, output_bfd, error_message)
1220 bfd *abfd ATTRIBUTE_UNUSED;
1221 arelent *reloc_entry;
1223 PTR data ATTRIBUTE_UNUSED;
1224 asection *input_section;
1226 char **error_message ATTRIBUTE_UNUSED;
1228 /* This part is from bfd_elf_generic_reloc. */
1229 if (output_bfd != (bfd *) NULL
1230 && (symbol->flags & BSF_SECTION_SYM) == 0
1231 && (! reloc_entry->howto->partial_inplace
1232 || reloc_entry->addend == 0))
1234 reloc_entry->address += input_section->output_offset;
1235 return bfd_reloc_ok;
1238 if (output_bfd != NULL)
1240 /* FIXME: See bfd_perform_relocation. Is this right? */
1241 return bfd_reloc_continue;
1244 /* FIXME: not sure what to do here yet. But then again, the linker
1245 may never call us. */
1249 /* Map BFD reloc types to M32R ELF reloc types. */
1251 struct m32r_reloc_map
1253 bfd_reloc_code_real_type bfd_reloc_val;
1254 unsigned char elf_reloc_val;
1257 #ifdef USE_M32R_OLD_RELOC
1258 static const struct m32r_reloc_map m32r_reloc_map_old[] =
1260 { BFD_RELOC_NONE, R_M32R_NONE },
1261 { BFD_RELOC_16, R_M32R_16 },
1262 { BFD_RELOC_32, R_M32R_32 },
1263 { BFD_RELOC_M32R_24, R_M32R_24 },
1264 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
1265 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
1266 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
1267 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
1268 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
1269 { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
1270 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
1271 { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
1272 { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
1275 static const struct m32r_reloc_map m32r_reloc_map[] =
1277 { BFD_RELOC_NONE, R_M32R_NONE },
1278 { BFD_RELOC_16, R_M32R_16_RELA },
1279 { BFD_RELOC_32, R_M32R_32_RELA },
1280 { BFD_RELOC_M32R_24, R_M32R_24_RELA },
1281 { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA },
1282 { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA },
1283 { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA },
1284 { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA },
1285 { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA },
1286 { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA },
1287 { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
1288 { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
1289 { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
1291 { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
1292 { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
1293 { BFD_RELOC_M32R_COPY, R_M32R_COPY },
1294 { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT },
1295 { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT },
1296 { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE },
1297 { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF },
1298 { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 },
1299 { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO },
1300 { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO },
1301 { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO },
1302 { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO },
1303 { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO },
1304 { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO },
1305 { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO },
1306 { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO },
1307 { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO },
1311 static reloc_howto_type *
1312 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1313 bfd *abfd ATTRIBUTE_UNUSED;
1314 bfd_reloc_code_real_type code;
1318 #ifdef USE_M32R_OLD_RELOC
1320 i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map);
1323 if (m32r_reloc_map_old[i].bfd_reloc_val == code)
1324 return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val];
1326 #else /* ! USE_M32R_OLD_RELOC */
1329 i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
1332 if (m32r_reloc_map[i].bfd_reloc_val == code)
1333 return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
1340 /* Set the howto pointer for an M32R ELF reloc. */
1343 m32r_info_to_howto_rel (abfd, cache_ptr, dst)
1344 bfd *abfd ATTRIBUTE_UNUSED;
1346 Elf_Internal_Rela *dst;
1348 unsigned int r_type;
1350 r_type = ELF32_R_TYPE (dst->r_info);
1351 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) <= (unsigned int) R_M32R_GNU_VTENTRY);
1352 cache_ptr->howto = &m32r_elf_howto_table[r_type];
1356 m32r_info_to_howto (abfd, cache_ptr, dst)
1357 bfd *abfd ATTRIBUTE_UNUSED;
1359 Elf_Internal_Rela *dst;
1361 BFD_ASSERT ((ELF32_R_TYPE(dst->r_info) == (unsigned int) R_M32R_NONE)
1362 || ((ELF32_R_TYPE(dst->r_info) > (unsigned int) R_M32R_GNU_VTENTRY)
1363 && (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_M32R_max)));
1364 cache_ptr->howto = &m32r_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
1368 /* Given a BFD section, try to locate the corresponding ELF section
1372 _bfd_m32r_elf_section_from_bfd_section (abfd, sec, retval)
1373 bfd *abfd ATTRIBUTE_UNUSED;
1377 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1379 *retval = SHN_M32R_SCOMMON;
1385 /* M32R ELF uses two common sections. One is the usual one, and the other
1386 is for small objects. All the small objects are kept together, and then
1387 referenced via one register, which yields faster assembler code. It is
1388 up to the compiler to emit an instruction to load the register with
1389 _SDA_BASE. This is what we use for the small common section. This
1390 approach is copied from elf32-mips.c. */
1391 static asection m32r_elf_scom_section;
1392 static asymbol m32r_elf_scom_symbol;
1393 static asymbol *m32r_elf_scom_symbol_ptr;
1395 /* Handle the special M32R section numbers that a symbol may use. */
1398 _bfd_m32r_elf_symbol_processing (abfd, asym)
1399 bfd *abfd ATTRIBUTE_UNUSED;
1402 elf_symbol_type *elfsym;
1404 elfsym = (elf_symbol_type *) asym;
1406 switch (elfsym->internal_elf_sym.st_shndx)
1408 case SHN_M32R_SCOMMON:
1409 if (m32r_elf_scom_section.name == NULL)
1411 /* Initialize the small common section. */
1412 m32r_elf_scom_section.name = ".scommon";
1413 m32r_elf_scom_section.flags = SEC_IS_COMMON;
1414 m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
1415 m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
1416 m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
1417 m32r_elf_scom_symbol.name = ".scommon";
1418 m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
1419 m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
1420 m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
1422 asym->section = &m32r_elf_scom_section;
1423 asym->value = elfsym->internal_elf_sym.st_size;
1428 /* Hook called by the linker routine which adds symbols from an object
1429 file. We must handle the special M32R section numbers here.
1430 We also keep watching for whether we need to create the sdata special
1434 m32r_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1436 struct bfd_link_info *info;
1437 Elf_Internal_Sym *sym;
1439 flagword *flagsp ATTRIBUTE_UNUSED;
1443 if (! info->relocatable
1444 && (*namep)[0] == '_' && (*namep)[1] == 'S'
1445 && strcmp (*namep, "_SDA_BASE_") == 0
1446 && is_elf_hash_table (info->hash))
1448 /* This is simpler than using _bfd_elf_create_linker_section
1449 (our needs are simpler than ppc's needs). Also
1450 _bfd_elf_create_linker_section currently has a bug where if a .sdata
1451 section already exists a new one is created that follows it which
1452 screws of _SDA_BASE_ address calcs because output_offset != 0. */
1453 struct elf_link_hash_entry *h;
1454 struct bfd_link_hash_entry *bh;
1455 asection *s = bfd_get_section_by_name (abfd, ".sdata");
1457 /* The following code was cobbled from elf32-ppc.c and elflink.c. */
1461 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1462 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1464 s = bfd_make_section_anyway_with_flags (abfd, ".sdata",
1468 bfd_set_section_alignment (abfd, s, 2);
1471 bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
1472 FALSE, FALSE, FALSE);
1474 if ((bh == NULL || bh->type == bfd_link_hash_undefined)
1475 && !(_bfd_generic_link_add_one_symbol (info,
1481 (const char *) NULL,
1483 get_elf_backend_data (abfd)->collect,
1486 h = (struct elf_link_hash_entry *) bh;
1487 h->type = STT_OBJECT;
1490 switch (sym->st_shndx)
1492 case SHN_M32R_SCOMMON:
1493 *secp = bfd_make_section_old_way (abfd, ".scommon");
1494 (*secp)->flags |= SEC_IS_COMMON;
1495 *valp = sym->st_size;
1502 /* We have to figure out the SDA_BASE value, so that we can adjust the
1503 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
1504 BFD. If we can't find it, we're stuck. We cache it in the ELF
1505 target data. We don't need to adjust the symbol value for an
1506 external symbol if we are producing relocatable output. */
1508 static bfd_reloc_status_type
1509 m32r_elf_final_sda_base (output_bfd, info, error_message, psb)
1511 struct bfd_link_info *info;
1512 const char **error_message;
1515 if (elf_gp (output_bfd) == 0)
1517 struct bfd_link_hash_entry *h;
1519 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
1520 if (h != (struct bfd_link_hash_entry *) NULL
1521 && h->type == bfd_link_hash_defined)
1522 elf_gp (output_bfd) = (h->u.def.value
1523 + h->u.def.section->output_section->vma
1524 + h->u.def.section->output_offset);
1527 /* Only get the error once. */
1528 *psb = elf_gp (output_bfd) = 4;
1530 (const char *) _("SDA relocation when _SDA_BASE_ not defined");
1531 return bfd_reloc_dangerous;
1534 *psb = elf_gp (output_bfd);
1535 return bfd_reloc_ok;
1538 /* Return size of a PLT entry. */
1539 #define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE
1541 /* The m32r linker needs to keep track of the number of relocs that it
1542 decides to copy in check_relocs for each symbol. This is so that
1543 it can discard PC relative relocs if it doesn't need them when
1544 linking with -Bsymbolic. We store the information in a field
1545 extending the regular ELF linker hash table. */
1547 /* This structure keeps track of the number of PC relative relocs we
1548 have copied for a given symbol. */
1550 struct elf_m32r_pcrel_relocs_copied
1553 struct elf_m32r_pcrel_relocs_copied *next;
1554 /* A section in dynobj. */
1556 /* Number of relocs copied in this section. */
1557 bfd_size_type count;
1560 /* The sh linker needs to keep track of the number of relocs that it
1561 decides to copy as dynamic relocs in check_relocs for each symbol.
1562 This is so that it can later discard them if they are found to be
1563 unnecessary. We store the information in a field extending the
1564 regular ELF linker hash table. */
1566 struct elf_m32r_dyn_relocs
1568 struct elf_m32r_dyn_relocs *next;
1570 /* The input section of the reloc. */
1573 /* Total number of relocs copied for the input section. */
1574 bfd_size_type count;
1576 /* Number of pc-relative relocs copied for the input section. */
1577 bfd_size_type pc_count;
1581 /* m32r ELF linker hash entry. */
1583 struct elf_m32r_link_hash_entry
1585 struct elf_link_hash_entry root;
1587 /* Track dynamic relocs copied for this symbol. */
1588 struct elf_m32r_dyn_relocs *dyn_relocs;
1590 // bfd_signed_vma gotplt_refcount;
1592 /* Number of PC relative relocs copied for this symbol. */
1593 /* struct elf_m32r_pcrel_relocs_copied *pcrel_relocs_copied; FIXME */
1596 /* m32r ELF linker hash table. */
1598 struct elf_m32r_link_hash_table
1600 struct elf_link_hash_table root;
1602 /* Short-cuts to get to dynamic linker sections. */
1611 /* Small local sym to section mapping cache. */
1612 struct sym_sec_cache sym_sec;
1615 /* Traverse an m32r ELF linker hash table. */
1617 #define m32r_elf_link_hash_traverse(table, func, info) \
1618 (elf_link_hash_traverse \
1620 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
1623 /* Get the m32r ELF linker hash table from a link_info structure. */
1626 #define m32r_elf_hash_table(p) \
1627 ((struct elf_m32r_link_hash_table *) ((p)->hash))
1629 /* Create an entry in an m32r ELF linker hash table. */
1630 static struct bfd_hash_entry *
1631 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *, struct bfd_hash_table *,
1634 static struct bfd_hash_entry *
1635 m32r_elf_link_hash_newfunc (entry, table, string)
1636 struct bfd_hash_entry *entry;
1637 struct bfd_hash_table *table;
1640 struct elf_m32r_link_hash_entry *ret =
1641 (struct elf_m32r_link_hash_entry *) entry;
1643 /* Allocate the structure if it has not already been allocated by a
1645 if (ret == (struct elf_m32r_link_hash_entry *) NULL)
1646 ret = ((struct elf_m32r_link_hash_entry *)
1647 bfd_hash_allocate (table,
1648 sizeof (struct elf_m32r_link_hash_entry)));
1649 if (ret == (struct elf_m32r_link_hash_entry *) NULL)
1650 return (struct bfd_hash_entry *) ret;
1652 /* Call the allocation method of the superclass. */
1653 ret = ((struct elf_m32r_link_hash_entry *)
1654 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1656 if (ret != (struct elf_m32r_link_hash_entry *) NULL)
1658 struct elf_m32r_link_hash_entry *eh;
1660 eh = (struct elf_m32r_link_hash_entry *) ret;
1661 eh->dyn_relocs = NULL;
1662 // eh->gotplt_refcount = 0;
1663 /* eh->pcrel_relocs_copied = NULL; FIXME */
1666 return (struct bfd_hash_entry *) ret;
1669 /* Create an m32r ELF linker hash table. */
1670 static struct bfd_link_hash_table *m32r_elf_link_hash_table_create (bfd *);
1672 static struct bfd_link_hash_table *
1673 m32r_elf_link_hash_table_create (abfd)
1676 struct elf_m32r_link_hash_table *ret;
1677 bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1679 ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt);
1680 if (ret == (struct elf_m32r_link_hash_table *) NULL)
1683 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
1684 m32r_elf_link_hash_newfunc))
1691 ret->sgotplt = NULL;
1692 ret->srelgot = NULL;
1694 ret->srelplt = NULL;
1695 ret->sdynbss = NULL;
1696 ret->srelbss = NULL;
1697 ret->sym_sec.abfd = NULL;
1699 return &ret->root.root;
1702 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1703 shortcuts to them in our hash table. */
1704 static bfd_boolean create_got_section (bfd *, struct bfd_link_info *);
1707 create_got_section (dynobj, info)
1709 struct bfd_link_info *info;
1711 struct elf_m32r_link_hash_table *htab;
1713 if (! _bfd_elf_create_got_section (dynobj, info))
1716 htab = m32r_elf_hash_table (info);
1717 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1718 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1719 if (! htab->sgot || ! htab->sgotplt)
1722 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
1727 | SEC_LINKER_CREATED
1729 if (htab->srelgot == NULL
1730 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1736 /* Create dynamic sections when linking against a dynamic object. */
1739 m32r_elf_create_dynamic_sections (abfd, info)
1741 struct bfd_link_info *info;
1743 struct elf_m32r_link_hash_table *htab;
1744 flagword flags, pltflags;
1745 register asection *s;
1746 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1747 int ptralign = 2; /* 32bit */
1749 htab = m32r_elf_hash_table (info);
1751 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1752 .rel[a].bss sections. */
1754 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1755 | SEC_LINKER_CREATED);
1758 pltflags |= SEC_CODE;
1759 if (bed->plt_not_loaded)
1760 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1761 if (bed->plt_readonly)
1762 pltflags |= SEC_READONLY;
1764 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1767 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1770 if (bed->want_plt_sym)
1772 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1774 struct bfd_link_hash_entry *bh = NULL;
1775 struct elf_link_hash_entry *h;
1776 if (! (_bfd_generic_link_add_one_symbol
1777 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1778 (bfd_vma) 0, (const char *) NULL, FALSE,
1779 get_elf_backend_data (abfd)->collect, &bh)))
1781 h = (struct elf_link_hash_entry *) bh;
1783 h->type = STT_OBJECT;
1786 && ! bfd_elf_link_record_dynamic_symbol (info, h))
1790 s = bfd_make_section_with_flags (abfd,
1791 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1792 flags | SEC_READONLY);
1795 || ! bfd_set_section_alignment (abfd, s, ptralign))
1798 if (htab->sgot == NULL
1799 && ! create_got_section (abfd, info))
1803 const char *secname;
1808 for (sec = abfd->sections; sec; sec = sec->next)
1810 secflags = bfd_get_section_flags (abfd, sec);
1811 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1812 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1814 secname = bfd_get_section_name (abfd, sec);
1815 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1816 strcpy (relname, ".rela");
1817 strcat (relname, secname);
1818 if (bfd_get_section_by_name (abfd, secname))
1820 s = bfd_make_section_with_flags (abfd, relname,
1821 flags | SEC_READONLY);
1823 || ! bfd_set_section_alignment (abfd, s, ptralign))
1828 if (bed->want_dynbss)
1830 /* The .dynbss section is a place to put symbols which are defined
1831 by dynamic objects, are referenced by regular objects, and are
1832 not functions. We must allocate space for them in the process
1833 image and use a R_*_COPY reloc to tell the dynamic linker to
1834 initialize them at run time. The linker script puts the .dynbss
1835 section into the .bss section of the final image. */
1836 s = bfd_make_section_with_flags (abfd, ".dynbss",
1837 SEC_ALLOC | SEC_LINKER_CREATED);
1841 /* The .rel[a].bss section holds copy relocs. This section is not
1842 normally needed. We need to create it here, though, so that the
1843 linker will map it to an output section. We can't just create it
1844 only if we need it, because we will not know whether we need it
1845 until we have seen all the input files, and the first time the
1846 main linker code calls BFD after examining all the input files
1847 (size_dynamic_sections) the input sections have already been
1848 mapped to the output sections. If the section turns out not to
1849 be needed, we can discard it later. We will never need this
1850 section when generating a shared object, since they do not use
1854 s = bfd_make_section_with_flags (abfd,
1855 (bed->default_use_rela_p
1856 ? ".rela.bss" : ".rel.bss"),
1857 flags | SEC_READONLY);
1860 || ! bfd_set_section_alignment (abfd, s, ptralign))
1868 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1869 static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *,
1870 struct elf_link_hash_entry *,
1871 struct elf_link_hash_entry *);
1874 m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
1875 struct elf_link_hash_entry *dir,
1876 struct elf_link_hash_entry *ind)
1878 struct elf_m32r_link_hash_entry *edir, *eind;
1880 edir = (struct elf_m32r_link_hash_entry *) dir;
1881 eind = (struct elf_m32r_link_hash_entry *) ind;
1883 if (eind->dyn_relocs != NULL)
1885 if (edir->dyn_relocs != NULL)
1887 struct elf_m32r_dyn_relocs **pp;
1888 struct elf_m32r_dyn_relocs *p;
1890 if (ind->root.type == bfd_link_hash_indirect)
1893 /* Add reloc counts against the weak sym to the strong sym
1894 list. Merge any entries against the same section. */
1895 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1897 struct elf_m32r_dyn_relocs *q;
1899 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1900 if (q->sec == p->sec)
1902 q->pc_count += p->pc_count;
1903 q->count += p->count;
1910 *pp = edir->dyn_relocs;
1913 edir->dyn_relocs = eind->dyn_relocs;
1914 eind->dyn_relocs = NULL;
1917 // if (ind->root.type == bfd_link_hash_indirect
1918 // && dir->got.refcount <= 0)
1920 // edir->tls_type = eind->tls_type;
1921 // eind->tls_type = GOT_UNKNOWN;
1923 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
1927 /* Adjust a symbol defined by a dynamic object and referenced by a
1928 regular object. The current definition is in some section of the
1929 dynamic object, but we're not including those sections. We have to
1930 change the definition to something the rest of the link can
1934 m32r_elf_adjust_dynamic_symbol (info, h)
1935 struct bfd_link_info *info;
1936 struct elf_link_hash_entry *h;
1938 struct elf_m32r_link_hash_table *htab;
1939 struct elf_m32r_link_hash_entry *eh;
1940 struct elf_m32r_dyn_relocs *p;
1943 unsigned int power_of_two;
1946 printf("m32r_elf_adjust_dynamic_symbol()\n");
1949 dynobj = elf_hash_table (info)->dynobj;
1951 /* Make sure we know what is going on here. */
1952 BFD_ASSERT (dynobj != NULL
1954 || h->u.weakdef != NULL
1957 && !h->def_regular)));
1960 /* If this is a function, put it in the procedure linkage table. We
1961 will fill in the contents of the procedure linkage table later,
1962 when we know the address of the .got section. */
1963 if (h->type == STT_FUNC
1969 && h->root.type != bfd_link_hash_undefweak
1970 && h->root.type != bfd_link_hash_undefined)
1972 /* This case can occur if we saw a PLT reloc in an input
1973 file, but the symbol was never referred to by a dynamic
1974 object. In such a case, we don't actually need to build
1975 a procedure linkage table, and we can just do a PCREL
1977 h->plt.offset = (bfd_vma) -1;
1984 h->plt.offset = (bfd_vma) -1;
1986 /* If this is a weak symbol, and there is a real definition, the
1987 processor independent code will have arranged for us to see the
1988 real definition first, and we can just use the same value. */
1989 if (h->u.weakdef != NULL)
1991 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1992 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1993 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1994 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1998 /* This is a reference to a symbol defined by a dynamic object which
1999 is not a function. */
2001 /* If we are creating a shared library, we must presume that the
2002 only references to the symbol are via the global offset table.
2003 For such cases we need not do anything here; the relocations will
2004 be handled correctly by relocate_section. */
2008 /* If there are no references to this symbol that do not use the
2009 GOT, we don't need to generate a copy reloc. */
2010 if (!h->non_got_ref)
2013 /* If -z nocopyreloc was given, we won't generate them either. */
2014 if (info->nocopyreloc)
2020 eh = (struct elf_m32r_link_hash_entry *) h;
2021 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2023 s = p->sec->output_section;
2024 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
2028 /* If we didn't find any dynamic relocs in sections which needs the
2029 copy reloc, then we'll be keeping the dynamic relocs and avoiding
2037 /* We must allocate the symbol in our .dynbss section, which will
2038 become part of the .bss section of the executable. There will be
2039 an entry for this symbol in the .dynsym section. The dynamic
2040 object will contain position independent code, so all references
2041 from the dynamic object to this symbol will go through the global
2042 offset table. The dynamic linker will use the .dynsym entry to
2043 determine the address it must put in the global offset table, so
2044 both the dynamic object and the regular object will refer to the
2045 same memory location for the variable. */
2047 htab = m32r_elf_hash_table (info);
2049 BFD_ASSERT (s != NULL);
2051 /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
2052 to copy the initial value out of the dynamic object and into the
2053 runtime process image. We need to remember the offset into the
2054 .rela.bss section we are going to use. */
2055 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2059 srel = htab->srelbss;
2060 BFD_ASSERT (srel != NULL);
2061 srel->size += sizeof (Elf32_External_Rela);
2065 /* We need to figure out the alignment required for this symbol. I
2066 have no idea how ELF linkers handle this. */
2067 power_of_two = bfd_log2 (h->size);
2068 if (power_of_two > 3)
2071 /* Apply the required alignment. */
2072 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2073 if (power_of_two > bfd_get_section_alignment (dynobj, s))
2075 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2079 /* Define the symbol as being at this point in the section. */
2080 h->root.u.def.section = s;
2081 h->root.u.def.value = s->size;
2083 /* Increment the section size to make room for the symbol. */
2089 /* Allocate space in .plt, .got and associated reloc sections for
2093 allocate_dynrelocs (h, inf)
2094 struct elf_link_hash_entry *h;
2097 struct bfd_link_info *info;
2098 struct elf_m32r_link_hash_table *htab;
2099 struct elf_m32r_link_hash_entry *eh;
2100 struct elf_m32r_dyn_relocs *p;
2102 if (h->root.type == bfd_link_hash_indirect)
2105 if (h->root.type == bfd_link_hash_warning)
2106 /* When warning symbols are created, they **replace** the "real"
2107 entry in the hash table, thus we never get to see the real
2108 symbol in a hash traversal. So look at it now. */
2109 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2111 info = (struct bfd_link_info *) inf;
2112 htab = m32r_elf_hash_table (info);
2114 eh = (struct elf_m32r_link_hash_entry *) h;
2115 // if ((h->got.refcount > 0
2116 // || h->forced_local)
2117 // && eh->gotplt_refcount > 0)
2119 // /* The symbol has been forced local, or we have some direct got refs,
2120 // so treat all the gotplt refs as got refs. */
2121 // h->got.refcount += eh->gotplt_refcount;
2122 // if (h->plt.refcount >= eh->gotplt_refcount)
2123 // h->plt.refcount -= eh->gotplt_refcount;
2126 if (htab->root.dynamic_sections_created
2127 && h->plt.refcount > 0)
2129 /* Make sure this symbol is output as a dynamic symbol.
2130 Undefined weak syms won't yet be marked as dynamic. */
2131 if (h->dynindx == -1
2132 && !h->forced_local)
2134 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2138 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2140 asection *s = htab->splt;
2142 /* If this is the first .plt entry, make room for the special
2145 s->size += PLT_ENTRY_SIZE;
2147 h->plt.offset = s->size;
2149 /* If this symbol is not defined in a regular file, and we are
2150 not generating a shared library, then set the symbol to this
2151 location in the .plt. This is required to make function
2152 pointers compare as equal between the normal executable and
2153 the shared library. */
2157 h->root.u.def.section = s;
2158 h->root.u.def.value = h->plt.offset;
2161 /* Make room for this entry. */
2162 s->size += PLT_ENTRY_SIZE;
2164 /* We also need to make an entry in the .got.plt section, which
2165 will be placed in the .got section by the linker script. */
2166 htab->sgotplt->size += 4;
2168 /* We also need to make an entry in the .rel.plt section. */
2169 htab->srelplt->size += sizeof (Elf32_External_Rela);
2173 h->plt.offset = (bfd_vma) -1;
2179 h->plt.offset = (bfd_vma) -1;
2183 if (h->got.refcount > 0)
2188 /* Make sure this symbol is output as a dynamic symbol.
2189 Undefined weak syms won't yet be marked as dynamic. */
2190 if (h->dynindx == -1
2191 && !h->forced_local)
2193 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2199 h->got.offset = s->size;
2201 dyn = htab->root.dynamic_sections_created;
2202 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2203 htab->srelgot->size += sizeof (Elf32_External_Rela);
2206 h->got.offset = (bfd_vma) -1;
2208 if (eh->dyn_relocs == NULL)
2211 /* In the shared -Bsymbolic case, discard space allocated for
2212 dynamic pc-relative relocs against symbols which turn out to be
2213 defined in regular objects. For the normal shared case, discard
2214 space for pc-relative relocs that have become local due to symbol
2215 visibility changes. */
2223 struct elf_m32r_dyn_relocs **pp;
2224 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2226 p->count -= p->pc_count;
2237 /* For the non-shared case, discard space for relocs against
2238 symbols which turn out to need copy relocs or are not
2244 || (htab->root.dynamic_sections_created
2245 && (h->root.type == bfd_link_hash_undefweak
2246 || h->root.type == bfd_link_hash_undefined))))
2248 /* Make sure this symbol is output as a dynamic symbol.
2249 Undefined weak syms won't yet be marked as dynamic. */
2250 if (h->dynindx == -1
2251 && !h->forced_local)
2253 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2257 /* If that succeeded, we know we'll be keeping all the
2259 if (h->dynindx != -1)
2263 eh->dyn_relocs = NULL;
2268 /* Finally, allocate space. */
2269 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2271 asection *sreloc = elf_section_data (p->sec)->sreloc;
2272 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2277 /* Find any dynamic relocs that apply to read-only sections. */
2280 readonly_dynrelocs (h, inf)
2281 struct elf_link_hash_entry *h;
2284 struct elf_m32r_link_hash_entry *eh;
2285 struct elf_m32r_dyn_relocs *p;
2287 if (h->root.type == bfd_link_hash_warning)
2288 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2290 eh = (struct elf_m32r_link_hash_entry *) h;
2291 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2293 asection *s = p->sec->output_section;
2295 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2297 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2299 info->flags |= DF_TEXTREL;
2301 /* Not an error, just cut short the traversal. */
2308 /* Set the sizes of the dynamic sections. */
2311 m32r_elf_size_dynamic_sections (output_bfd, info)
2312 bfd *output_bfd ATTRIBUTE_UNUSED;
2313 struct bfd_link_info *info;
2315 struct elf_m32r_link_hash_table *htab;
2322 printf("m32r_elf_size_dynamic_sections()\n");
2325 htab = m32r_elf_hash_table (info);
2326 dynobj = htab->root.dynobj;
2327 BFD_ASSERT (dynobj != NULL);
2329 if (htab->root.dynamic_sections_created)
2331 /* Set the contents of the .interp section to the interpreter. */
2334 s = bfd_get_section_by_name (dynobj, ".interp");
2335 BFD_ASSERT (s != NULL);
2336 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2337 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2341 /* Set up .got offsets for local syms, and space for local dynamic
2343 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2345 bfd_signed_vma *local_got;
2346 bfd_signed_vma *end_local_got;
2347 bfd_size_type locsymcount;
2348 Elf_Internal_Shdr *symtab_hdr;
2351 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2354 for (s = ibfd->sections; s != NULL; s = s->next)
2356 struct elf_m32r_dyn_relocs *p;
2358 for (p = ((struct elf_m32r_dyn_relocs *)
2359 elf_section_data (s)->local_dynrel);
2363 if (! bfd_is_abs_section (p->sec)
2364 && bfd_is_abs_section (p->sec->output_section))
2366 /* Input section has been discarded, either because
2367 it is a copy of a linkonce section or due to
2368 linker script /DISCARD/, so we'll be discarding
2371 else if (p->count != 0)
2373 srel = elf_section_data (p->sec)->sreloc;
2374 srel->size += p->count * sizeof (Elf32_External_Rela);
2375 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2376 info->flags |= DF_TEXTREL;
2381 local_got = elf_local_got_refcounts (ibfd);
2385 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2386 locsymcount = symtab_hdr->sh_info;
2387 end_local_got = local_got + locsymcount;
2389 srel = htab->srelgot;
2390 for (; local_got < end_local_got; ++local_got)
2394 *local_got = s->size;
2397 srel->size += sizeof (Elf32_External_Rela);
2400 *local_got = (bfd_vma) -1;
2404 /* Allocate global sym .plt and .got entries, and space for global
2405 sym dynamic relocs. */
2406 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
2408 /* We now have determined the sizes of the various dynamic sections.
2409 Allocate memory for them. */
2411 for (s = dynobj->sections; s != NULL; s = s->next)
2413 if ((s->flags & SEC_LINKER_CREATED) == 0)
2418 || s == htab->sgotplt)
2420 /* Strip this section if we don't need it; see the
2423 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
2425 if (s->size != 0 && s != htab->srelplt)
2428 /* We use the reloc_count field as a counter if we need
2429 to copy relocs into the output file. */
2434 /* It's not one of our sections, so don't allocate space. */
2440 /* If we don't need this section, strip it from the
2441 output file. This is mostly to handle .rela.bss and
2442 .rela.plt. We must create both sections in
2443 create_dynamic_sections, because they must be created
2444 before the linker maps input sections to output
2445 sections. The linker does that before
2446 adjust_dynamic_symbol is called, and it is that
2447 function which decides whether anything needs to go
2448 into these sections. */
2449 s->flags |= SEC_EXCLUDE;
2453 /* Allocate memory for the section contents. We use bfd_zalloc
2454 here in case unused entries are not reclaimed before the
2455 section's contents are written out. This should not happen,
2456 but this way if it does, we get a R_M32R_NONE reloc instead
2458 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2459 if (s->contents == NULL)
2463 if (htab->root.dynamic_sections_created)
2465 /* Add some entries to the .dynamic section. We fill in the
2466 values later, in m32r_elf_finish_dynamic_sections, but we
2467 must add the entries now so that we get the correct size for
2468 the .dynamic section. The DT_DEBUG entry is filled in by the
2469 dynamic linker and used by the debugger. */
2470 #define add_dynamic_entry(TAG, VAL) \
2471 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2475 if (! add_dynamic_entry (DT_DEBUG, 0))
2479 if (htab->splt->size != 0)
2481 if (! add_dynamic_entry (DT_PLTGOT, 0)
2482 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2483 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2484 || ! add_dynamic_entry (DT_JMPREL, 0))
2490 if (! add_dynamic_entry (DT_RELA, 0)
2491 || ! add_dynamic_entry (DT_RELASZ, 0)
2492 || ! add_dynamic_entry (DT_RELAENT,
2493 sizeof (Elf32_External_Rela)))
2496 /* If any dynamic relocs apply to a read-only section,
2497 then we need a DT_TEXTREL entry. */
2498 if ((info->flags & DF_TEXTREL) == 0)
2499 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2502 if ((info->flags & DF_TEXTREL) != 0)
2504 if (! add_dynamic_entry (DT_TEXTREL, 0))
2509 #undef add_dynamic_entry
2513 /* Relocate an M32R/D ELF section.
2514 There is some attempt to make this function usable for many architectures,
2515 both for RELA and REL type relocs, if only to serve as a learning tool.
2517 The RELOCATE_SECTION function is called by the new ELF backend linker
2518 to handle the relocations for a section.
2520 The relocs are always passed as Rela structures; if the section
2521 actually uses Rel structures, the r_addend field will always be
2524 This function is responsible for adjust the section contents as
2525 necessary, and (if using Rela relocs and generating a
2526 relocatable output file) adjusting the reloc addend as
2529 This function does not have to worry about setting the reloc
2530 address or the reloc symbol index.
2532 LOCAL_SYMS is a pointer to the swapped in local symbols.
2534 LOCAL_SECTIONS is an array giving the section in the input file
2535 corresponding to the st_shndx field of each local symbol.
2537 The global hash table entry for the global symbols can be found
2538 via elf_sym_hashes (input_bfd).
2540 When generating relocatable output, this function must handle
2541 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2542 going to be the section symbol corresponding to the output
2543 section, which means that the addend must be adjusted
2547 m32r_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2548 contents, relocs, local_syms, local_sections)
2549 bfd *output_bfd ATTRIBUTE_UNUSED;
2550 struct bfd_link_info *info;
2552 asection *input_section;
2554 Elf_Internal_Rela *relocs;
2555 Elf_Internal_Sym *local_syms;
2556 asection **local_sections;
2558 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2559 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2560 Elf_Internal_Rela *rel, *relend;
2561 /* Assume success. */
2562 bfd_boolean ret = TRUE;
2564 struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2566 bfd_vma *local_got_offsets;
2567 asection *sgot, *splt, *sreloc;
2568 bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2570 dynobj = htab->root.dynobj;
2571 local_got_offsets = elf_local_got_offsets (input_bfd);
2578 relend = relocs + input_section->reloc_count;
2579 for (; rel < relend; rel++)
2582 reloc_howto_type *howto;
2583 unsigned long r_symndx;
2584 struct elf_link_hash_entry *h;
2585 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2586 ensure it's zero (we use REL relocs, not RELA). Therefore this
2587 should be assigning zero to `addend', but for clarity we use
2589 bfd_vma addend = rel->r_addend;
2590 bfd_vma offset = rel->r_offset;
2591 Elf_Internal_Sym *sym;
2593 const char *sym_name;
2594 bfd_reloc_status_type r;
2595 const char *errmsg = NULL;
2596 bfd_boolean use_rel = FALSE;
2599 r_type = ELF32_R_TYPE (rel->r_info);
2600 if (r_type < 0 || r_type >= (int) R_M32R_max)
2602 (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2605 bfd_set_error (bfd_error_bad_value);
2610 if (r_type == R_M32R_GNU_VTENTRY
2611 || r_type == R_M32R_GNU_VTINHERIT
2612 || r_type == R_M32R_NONE
2613 || r_type == R_M32R_RELA_GNU_VTENTRY
2614 || r_type == R_M32R_RELA_GNU_VTINHERIT)
2617 if (r_type <= R_M32R_GNU_VTENTRY)
2620 howto = m32r_elf_howto_table + r_type;
2621 r_symndx = ELF32_R_SYM (rel->r_info);
2623 if (info->relocatable && use_rel)
2625 /* This is a relocatable link. We don't have to change
2626 anything, unless the reloc is against a section symbol,
2627 in which case we have to adjust according to where the
2628 section symbol winds up in the output section. */
2630 if (r_symndx >= symtab_hdr->sh_info)
2632 /* External symbol. */
2637 sym = local_syms + r_symndx;
2638 sym_name = "<local symbol>";
2639 /* STT_SECTION: symbol is associated with a section. */
2640 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2642 /* Symbol isn't associated with a section. Nothing to do. */
2646 sec = local_sections[r_symndx];
2647 addend += sec->output_offset + sym->st_value;
2649 /* If partial_inplace, we need to store any additional addend
2650 back in the section. */
2651 if (! howto->partial_inplace)
2653 /* ??? Here is a nice place to call a special_function
2655 if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2656 r = _bfd_relocate_contents (howto, input_bfd,
2657 addend, contents + offset);
2660 Elf_Internal_Rela *lorel;
2662 /* We allow an arbitrary number of HI16 relocs before the
2663 LO16 reloc. This permits gcc to emit the HI and LO relocs
2665 for (lorel = rel + 1;
2667 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2668 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2672 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2674 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2679 r = _bfd_relocate_contents (howto, input_bfd,
2680 addend, contents + offset);
2687 /* This is a final link. */
2692 if (r_symndx < symtab_hdr->sh_info)
2695 sym = local_syms + r_symndx;
2696 sec = local_sections[r_symndx];
2697 sym_name = "<local symbol>";
2701 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2702 addend = rel->r_addend;
2704 if (info->relocatable)
2706 /* This is a relocatable link. We don't have to change
2707 anything, unless the reloc is against a section symbol,
2708 in which case we have to adjust according to where the
2709 section symbol winds up in the output section. */
2710 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2711 rel->r_addend += sec->output_offset + sym->st_value;
2718 relocation = (sec->output_section->vma
2719 + sec->output_offset
2725 /* External symbol. */
2726 if (info->relocatable && !use_rel)
2729 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2730 while (h->root.type == bfd_link_hash_indirect
2731 || h->root.type == bfd_link_hash_warning)
2732 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2733 sym_name = h->root.root.string;
2735 if (h->root.type == bfd_link_hash_defined
2736 || h->root.type == bfd_link_hash_defweak)
2739 sec = h->root.u.def.section;
2741 dyn = htab->root.dynamic_sections_created;
2742 sec = h->root.u.def.section;
2743 if (r_type == R_M32R_GOTPC24
2744 || (r_type == R_M32R_GOTPC_HI_ULO
2745 || r_type == R_M32R_GOTPC_HI_SLO
2746 || r_type == R_M32R_GOTPC_LO)
2747 || (r_type == R_M32R_26_PLTREL
2748 && h->plt.offset != (bfd_vma) -1)
2749 || ((r_type == R_M32R_GOT24
2750 || r_type == R_M32R_GOT16_HI_ULO
2751 || r_type == R_M32R_GOT16_HI_SLO
2752 || r_type == R_M32R_GOT16_LO)
2753 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2756 || (! info->symbolic && h->dynindx != -1)
2757 || !h->def_regular))
2759 && ((! info->symbolic && h->dynindx != -1)
2761 && (((r_type == R_M32R_16_RELA
2762 || r_type == R_M32R_32_RELA
2763 || r_type == R_M32R_24_RELA
2764 || r_type == R_M32R_HI16_ULO_RELA
2765 || r_type == R_M32R_HI16_SLO_RELA
2766 || r_type == R_M32R_LO16_RELA)
2767 && !h->forced_local)
2768 || r_type == R_M32R_10_PCREL_RELA
2769 || r_type == R_M32R_18_PCREL_RELA
2770 || r_type == R_M32R_26_PCREL_RELA)
2771 && ((input_section->flags & SEC_ALLOC) != 0
2772 /* DWARF will emit R_M32R_16(24,32) relocations
2773 in its sections against symbols defined
2774 externally in shared libraries. We can't do
2775 anything with them here. */
2776 || ((input_section->flags & SEC_DEBUGGING) != 0
2777 && h->def_dynamic))))
2779 /* In these cases, we don't need the relocation
2780 value. We check specially because in some
2781 obscure cases sec->output_section will be NULL. */
2784 else if (sec->output_section == NULL)
2786 (*_bfd_error_handler)
2787 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
2788 bfd_get_filename (input_bfd), h->root.root.string,
2789 bfd_get_section_name (input_bfd, input_section));
2794 relocation = (h->root.u.def.value
2795 + sec->output_section->vma
2796 + sec->output_offset);
2798 else if (h->root.type == bfd_link_hash_undefweak)
2800 else if (info->unresolved_syms_in_objects == RM_IGNORE
2801 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2805 if (! ((*info->callbacks->undefined_symbol)
2806 (info, h->root.root.string, input_bfd,
2807 input_section, offset,
2808 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2809 || ELF_ST_VISIBILITY (h->other)))))
2815 /* Sanity check the address. */
2816 if (offset > high_address)
2818 r = bfd_reloc_outofrange;
2822 switch ((int) r_type)
2825 /* Relocation is relative to the start of the global offset
2826 table (for ld24 rx, #uimm24). eg access at label+addend
2828 ld24 rx. #label@GOTOFF + addend
2831 BFD_ASSERT (sgot != NULL);
2833 relocation = -(relocation - sgot->output_section->vma);
2834 rel->r_addend = -rel->r_addend;
2837 case R_M32R_GOTOFF_HI_ULO:
2838 case R_M32R_GOTOFF_HI_SLO:
2839 case R_M32R_GOTOFF_LO:
2840 BFD_ASSERT (sgot != NULL);
2842 relocation -= sgot->output_section->vma;
2844 if ((r_type == R_M32R_GOTOFF_HI_SLO)
2845 && ((relocation + rel->r_addend) & 0x8000))
2846 rel->r_addend += 0x10000;
2849 case R_M32R_GOTPC24:
2850 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2851 ld24 rx,#_GLOBAL_OFFSET_TABLE_
2853 relocation = sgot->output_section->vma;
2856 case R_M32R_GOTPC_HI_ULO:
2857 case R_M32R_GOTPC_HI_SLO:
2858 case R_M32R_GOTPC_LO:
2860 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2862 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2863 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2866 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2867 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2869 relocation = sgot->output_section->vma;
2870 relocation -= (input_section->output_section->vma
2871 + input_section->output_offset
2873 if ((r_type == R_M32R_GOTPC_HI_SLO)
2874 && ((relocation + rel->r_addend) & 0x8000))
2875 rel->r_addend += 0x10000;
2879 case R_M32R_GOT16_HI_ULO:
2880 case R_M32R_GOT16_HI_SLO:
2881 case R_M32R_GOT16_LO:
2884 /* Relocation is to the entry for this symbol in the global
2886 BFD_ASSERT (sgot != NULL);
2893 off = h->got.offset;
2894 BFD_ASSERT (off != (bfd_vma) -1);
2896 dyn = htab->root.dynamic_sections_created;
2897 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2904 /* This is actually a static link, or it is a
2905 -Bsymbolic link and the symbol is defined
2906 locally, or the symbol was forced to be local
2907 because of a version file. We must initialize
2908 this entry in the global offset table. Since the
2909 offset must always be a multiple of 4, we use the
2910 least significant bit to record whether we have
2911 initialized it already.
2913 When doing a dynamic link, we create a .rela.got
2914 relocation entry to initialize the value. This
2915 is done in the finish_dynamic_symbol routine. */
2920 bfd_put_32 (output_bfd, relocation,
2921 sgot->contents + off);
2926 relocation = sgot->output_offset + off;
2933 BFD_ASSERT (local_got_offsets != NULL
2934 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2936 off = local_got_offsets[r_symndx];
2938 /* The offset must always be a multiple of 4. We use
2939 the least significant bit to record whether we have
2940 already processed this entry. */
2945 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2950 Elf_Internal_Rela outrel;
2952 /* We need to generate a R_M32R_RELATIVE reloc
2953 for the dynamic linker. */
2954 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2955 BFD_ASSERT (srelgot != NULL);
2957 outrel.r_offset = (sgot->output_section->vma
2958 + sgot->output_offset
2960 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2961 outrel.r_addend = relocation;
2962 loc = srelgot->contents;
2963 loc += srelgot->reloc_count * sizeof(Elf32_External_Rela);
2964 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2965 ++srelgot->reloc_count;
2968 local_got_offsets[r_symndx] |= 1;
2971 relocation = sgot->output_offset + off;
2973 if ((r_type == R_M32R_GOT16_HI_SLO)
2974 && ((relocation + rel->r_addend) & 0x8000))
2975 rel->r_addend += 0x10000;
2979 case R_M32R_26_PLTREL:
2980 /* Relocation is to the entry for this symbol in the
2981 procedure linkage table. */
2983 /* The native assembler will generate a 26_PLTREL reloc
2984 for a local symbol if you assemble a call from one
2985 section to another when using -K pic. */
2989 //if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2990 // || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2992 if (h->forced_local)
2995 if (h->plt.offset == (bfd_vma) -1)
2997 /* We didn't make a PLT entry for this symbol. This
2998 happens when statically linking PIC code, or when
2999 using -Bsymbolic. */
3003 relocation = (splt->output_section->vma
3004 + splt->output_offset
3008 case R_M32R_HI16_SLO_RELA:
3010 if ((relocation + rel->r_addend) & 0x8000)
3012 rel->r_addend += 0x10000;
3016 case R_M32R_16_RELA:
3017 case R_M32R_24_RELA:
3018 case R_M32R_32_RELA:
3019 case R_M32R_18_PCREL_RELA:
3020 case R_M32R_26_PCREL_RELA:
3021 case R_M32R_HI16_ULO_RELA:
3022 case R_M32R_LO16_RELA:
3025 && (input_section->flags & SEC_ALLOC) != 0
3026 && ((r_type != R_M32R_18_PCREL_RELA
3027 && r_type != R_M32R_26_PCREL_RELA)
3030 && (! info->symbolic
3031 || !h->def_regular))))
3033 Elf_Internal_Rela outrel;
3034 bfd_boolean skip, relocate;
3037 /* When generating a shared object, these relocations
3038 are copied into the output file to be resolved at run
3045 name = (bfd_elf_string_from_elf_section
3047 elf_elfheader (input_bfd)->e_shstrndx,
3048 elf_section_data (input_section)->rel_hdr.sh_name));
3052 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3053 && strcmp (bfd_get_section_name (input_bfd,
3057 sreloc = bfd_get_section_by_name (dynobj, name);
3058 BFD_ASSERT (sreloc != NULL);
3064 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3068 if (outrel.r_offset == (bfd_vma) -1)
3070 else if (outrel.r_offset == (bfd_vma) -2)
3071 skip = TRUE, relocate = TRUE;
3072 outrel.r_offset += (input_section->output_section->vma
3073 + input_section->output_offset);
3076 memset (&outrel, 0, sizeof outrel);
3077 else if (r_type == R_M32R_18_PCREL_RELA
3078 || r_type == R_M32R_26_PCREL_RELA)
3080 BFD_ASSERT (h != NULL && h->dynindx != -1);
3081 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3082 outrel.r_addend = rel->r_addend;
3086 /* h->dynindx may be -1 if this symbol was marked to
3089 || ((info->symbolic || h->dynindx == -1)
3093 outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3094 outrel.r_addend = relocation + rel->r_addend;
3098 BFD_ASSERT (h->dynindx != -1);
3099 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3100 outrel.r_addend = relocation + rel->r_addend;
3104 loc = sreloc->contents;
3105 loc += sreloc->reloc_count * sizeof(Elf32_External_Rela);
3106 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
3107 ++sreloc->reloc_count;
3109 /* If this reloc is against an external symbol, we do
3110 not want to fiddle with the addend. Otherwise, we
3111 need to include the symbol value so that it becomes
3112 an addend for the dynamic reloc. */
3118 case (int) R_M32R_10_PCREL :
3119 r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
3121 sec, relocation, addend);
3124 case (int) R_M32R_HI16_SLO :
3125 case (int) R_M32R_HI16_ULO :
3127 Elf_Internal_Rela *lorel;
3129 /* We allow an arbitrary number of HI16 relocs before the
3130 LO16 reloc. This permits gcc to emit the HI and LO relocs
3132 for (lorel = rel + 1;
3134 && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
3135 || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
3139 && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
3141 m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
3142 contents, relocation + addend);
3146 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3148 relocation, addend);
3153 case (int) R_M32R_SDA16_RELA:
3154 case (int) R_M32R_SDA16 :
3158 BFD_ASSERT (sec != NULL);
3159 name = bfd_get_section_name (abfd, sec);
3161 if (strcmp (name, ".sdata") == 0
3162 || strcmp (name, ".sbss") == 0
3163 || strcmp (name, ".scommon") == 0)
3166 bfd *out_bfd = sec->output_section->owner;
3168 r = m32r_elf_final_sda_base (out_bfd, info,
3171 if (r != bfd_reloc_ok)
3177 /* At this point `relocation' contains the object's
3179 relocation -= sda_base;
3180 /* Now it contains the offset from _SDA_BASE_. */
3184 (*_bfd_error_handler)
3185 (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3189 m32r_elf_howto_table[(int) r_type].name);
3190 /*bfd_set_error (bfd_error_bad_value); ??? why? */
3197 default : /* OLD_M32R_RELOC */
3199 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3201 relocation, addend);
3205 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3206 contents, rel->r_offset,
3207 relocation, rel->r_addend);
3213 if (r != bfd_reloc_ok)
3215 /* FIXME: This should be generic enough to go in a utility. */
3219 name = h->root.root.string;
3222 name = (bfd_elf_string_from_elf_section
3223 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3224 if (name == NULL || *name == '\0')
3225 name = bfd_section_name (input_bfd, sec);
3233 case bfd_reloc_overflow:
3234 if (! ((*info->callbacks->reloc_overflow)
3235 (info, (h ? &h->root : NULL), name, howto->name,
3236 (bfd_vma) 0, input_bfd, input_section, offset)))
3240 case bfd_reloc_undefined:
3241 if (! ((*info->callbacks->undefined_symbol)
3242 (info, name, input_bfd, input_section,
3247 case bfd_reloc_outofrange:
3248 errmsg = _("internal error: out of range error");
3251 case bfd_reloc_notsupported:
3252 errmsg = _("internal error: unsupported relocation error");
3255 case bfd_reloc_dangerous:
3256 errmsg = _("internal error: dangerous error");
3260 errmsg = _("internal error: unknown error");
3264 if (!((*info->callbacks->warning)
3265 (info, errmsg, name, input_bfd, input_section,
3276 /* Finish up dynamic symbol handling. We set the contents of various
3277 dynamic sections here. */
3279 m32r_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
3281 struct bfd_link_info *info;
3282 struct elf_link_hash_entry *h;
3283 Elf_Internal_Sym *sym;
3285 struct elf_m32r_link_hash_table *htab;
3290 printf("m32r_elf_finish_dynamic_symbol()\n");
3293 htab = m32r_elf_hash_table (info);
3294 dynobj = htab->root.dynobj;
3296 if (h->plt.offset != (bfd_vma) -1)
3304 Elf_Internal_Rela rela;
3306 /* This symbol has an entry in the procedure linkage table. Set
3309 BFD_ASSERT (h->dynindx != -1);
3312 sgot = htab->sgotplt;
3313 srela = htab->srelplt;
3314 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3316 /* Get the index in the procedure linkage table which
3317 corresponds to this symbol. This is the index of this symbol
3318 in all the symbols for which we are making plt entries. The
3319 first entry in the procedure linkage table is reserved. */
3320 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3322 /* Get the offset into the .got table of the entry that
3323 corresponds to this function. Each .got entry is 4 bytes.
3324 The first three are reserved. */
3325 got_offset = (plt_index + 3) * 4;
3327 /* Fill in the entry in the procedure linkage table. */
3330 bfd_put_32 (output_bfd,
3332 + (((sgot->output_section->vma
3333 + sgot->output_offset
3334 + got_offset) >> 16) & 0xffff)),
3335 splt->contents + h->plt.offset);
3336 bfd_put_32 (output_bfd,
3338 + ((sgot->output_section->vma
3339 + sgot->output_offset
3340 + got_offset) & 0xffff)),
3341 splt->contents + h->plt.offset + 4);
3342 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3343 splt->contents + h->plt.offset + 8);
3344 bfd_put_32 (output_bfd,
3346 + plt_index * sizeof (Elf32_External_Rela)),
3347 splt->contents + h->plt.offset + 12);
3348 bfd_put_32 (output_bfd,
3350 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3351 splt->contents + h->plt.offset + 16);
3355 bfd_put_32 (output_bfd,
3356 PLT_ENTRY_WORD0 + got_offset,
3357 splt->contents + h->plt.offset);
3358 bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3359 splt->contents + h->plt.offset + 4);
3360 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3361 splt->contents + h->plt.offset + 8);
3362 bfd_put_32 (output_bfd,
3364 + plt_index * sizeof (Elf32_External_Rela)),
3365 splt->contents + h->plt.offset + 12);
3366 bfd_put_32 (output_bfd,
3368 + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3369 splt->contents + h->plt.offset + 16);
3372 /* Fill in the entry in the global offset table. */
3373 bfd_put_32 (output_bfd,
3374 (splt->output_section->vma
3375 + splt->output_offset
3377 + 12), /* same offset */
3378 sgot->contents + got_offset);
3380 /* Fill in the entry in the .rela.plt section. */
3381 rela.r_offset = (sgot->output_section->vma
3382 + sgot->output_offset
3384 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3386 loc = srela->contents;
3387 loc += plt_index * sizeof(Elf32_External_Rela);
3388 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3390 if (!h->def_regular)
3392 /* Mark the symbol as undefined, rather than as defined in
3393 the .plt section. Leave the value alone. */
3394 sym->st_shndx = SHN_UNDEF;
3398 if (h->got.offset != (bfd_vma) -1)
3402 Elf_Internal_Rela rela;
3404 /* This symbol has an entry in the global offset table. Set it
3408 srela = htab->srelgot;
3409 BFD_ASSERT (sgot != NULL && srela != NULL);
3411 rela.r_offset = (sgot->output_section->vma
3412 + sgot->output_offset
3413 + (h->got.offset &~ 1));
3415 /* If this is a -Bsymbolic link, and the symbol is defined
3416 locally, we just want to emit a RELATIVE reloc. Likewise if
3417 the symbol was forced to be local because of a version file.
3418 The entry in the global offset table will already have been
3419 initialized in the relocate_section function. */
3426 rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3427 rela.r_addend = (h->root.u.def.value
3428 + h->root.u.def.section->output_section->vma
3429 + h->root.u.def.section->output_offset);
3433 BFD_ASSERT((h->got.offset & 1) == 0);
3434 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3435 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3439 loc = srela->contents;
3440 loc += srela->reloc_count * sizeof(Elf32_External_Rela);
3441 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3442 ++srela->reloc_count;
3448 Elf_Internal_Rela rela;
3450 /* This symbols needs a copy reloc. Set it up. */
3452 BFD_ASSERT (h->dynindx != -1
3453 && (h->root.type == bfd_link_hash_defined
3454 || h->root.type == bfd_link_hash_defweak));
3456 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3458 BFD_ASSERT (s != NULL);
3460 rela.r_offset = (h->root.u.def.value
3461 + h->root.u.def.section->output_section->vma
3462 + h->root.u.def.section->output_offset);
3463 rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3466 loc += s->reloc_count * sizeof(Elf32_External_Rela);
3467 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3471 /* Mark some specially defined symbols as absolute. */
3472 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3473 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3474 sym->st_shndx = SHN_ABS;
3480 /* Finish up the dynamic sections. */
3483 m32r_elf_finish_dynamic_sections (output_bfd, info)
3485 struct bfd_link_info *info;
3487 struct elf_m32r_link_hash_table *htab;
3493 printf("m32r_elf_finish_dynamic_sections()\n");
3496 htab = m32r_elf_hash_table (info);
3497 dynobj = htab->root.dynobj;
3499 sgot = htab->sgotplt;
3500 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3502 if (htab->root.dynamic_sections_created)
3505 Elf32_External_Dyn *dyncon, *dynconend;
3507 BFD_ASSERT (sgot != NULL && sdyn != NULL);
3509 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3510 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3512 for (; dyncon < dynconend; dyncon++)
3514 Elf_Internal_Dyn dyn;
3518 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3527 s = htab->sgot->output_section;
3531 s = htab->srelplt->output_section;
3533 BFD_ASSERT (s != NULL);
3534 dyn.d_un.d_ptr = s->vma;
3535 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3539 s = htab->srelplt->output_section;
3540 BFD_ASSERT (s != NULL);
3541 dyn.d_un.d_val = s->size;
3542 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3546 /* My reading of the SVR4 ABI indicates that the
3547 procedure linkage table relocs (DT_JMPREL) should be
3548 included in the overall relocs (DT_RELA). This is
3549 what Solaris does. However, UnixWare can not handle
3550 that case. Therefore, we override the DT_RELASZ entry
3551 here to make it not include the JMPREL relocs. Since
3552 the linker script arranges for .rela.plt to follow all
3553 other relocation sections, we don't have to worry
3554 about changing the DT_RELA entry. */
3555 if (htab->srelplt != NULL)
3557 s = htab->srelplt->output_section;
3558 dyn.d_un.d_val -= s->size;
3560 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3565 /* Fill in the first entry in the procedure linkage table. */
3567 if (splt && splt->size > 0)
3571 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3572 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3573 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3574 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3575 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3580 /* addr = .got + 4 */
3581 addr = sgot->output_section->vma + sgot->output_offset + 4;
3582 bfd_put_32 (output_bfd,
3583 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3585 bfd_put_32 (output_bfd,
3586 PLT0_ENTRY_WORD1 | (addr & 0xffff),
3587 splt->contents + 4);
3588 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3589 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3590 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3593 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3598 /* Fill in the first three entries in the global offset table. */
3599 if (sgot && sgot->size > 0)
3602 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3604 bfd_put_32 (output_bfd,
3605 sdyn->output_section->vma + sdyn->output_offset,
3607 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3608 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3610 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3617 /* Set the right machine number. */
3619 m32r_elf_object_p (abfd)
3622 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3625 case E_M32R_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r); break;
3626 case E_M32RX_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3627 case E_M32R2_ARCH: (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3632 /* Store the machine number in the flags field. */
3634 m32r_elf_final_write_processing (abfd, linker)
3636 bfd_boolean linker ATTRIBUTE_UNUSED;
3640 switch (bfd_get_mach (abfd))
3643 case bfd_mach_m32r: val = E_M32R_ARCH; break;
3644 case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3645 case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3648 elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3649 elf_elfheader (abfd)->e_flags |= val;
3652 /* Function to keep M32R specific file flags. */
3654 m32r_elf_set_private_flags (abfd, flags)
3658 BFD_ASSERT (!elf_flags_init (abfd)
3659 || elf_elfheader (abfd)->e_flags == flags);
3661 elf_elfheader (abfd)->e_flags = flags;
3662 elf_flags_init (abfd) = TRUE;
3666 /* Merge backend specific data from an object file to the output
3667 object file when linking. */
3669 m32r_elf_merge_private_bfd_data (ibfd, obfd)
3676 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3677 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3680 in_flags = elf_elfheader (ibfd)->e_flags;
3681 out_flags = elf_elfheader (obfd)->e_flags;
3683 if (! elf_flags_init (obfd))
3685 /* If the input is the default architecture then do not
3686 bother setting the flags for the output architecture,
3687 instead allow future merges to do this. If no future
3688 merges ever set these flags then they will retain their
3689 unitialised values, which surprise surprise, correspond
3690 to the default values. */
3691 if (bfd_get_arch_info (ibfd)->the_default)
3694 elf_flags_init (obfd) = TRUE;
3695 elf_elfheader (obfd)->e_flags = in_flags;
3697 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3698 && bfd_get_arch_info (obfd)->the_default)
3700 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3706 /* Check flag compatibility. */
3707 if (in_flags == out_flags)
3710 if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3712 if ( ((in_flags & EF_M32R_ARCH) != E_M32R_ARCH)
3713 || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3714 || ((in_flags & EF_M32R_ARCH) == E_M32R2_ARCH))
3716 (*_bfd_error_handler)
3717 (_("%B: Instruction set mismatch with previous modules"), ibfd);
3719 bfd_set_error (bfd_error_bad_value);
3727 /* Display the flags field */
3729 m32r_elf_print_private_bfd_data (abfd, ptr)
3733 FILE * file = (FILE *) ptr;
3735 BFD_ASSERT (abfd != NULL && ptr != NULL);
3737 _bfd_elf_print_private_bfd_data (abfd, ptr);
3739 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3741 switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3744 case E_M32R_ARCH: fprintf (file, _(": m32r instructions")); break;
3745 case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3746 case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3755 m32r_elf_gc_mark_hook (sec, info, rel, h, sym)
3757 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3758 Elf_Internal_Rela *rel;
3759 struct elf_link_hash_entry *h;
3760 Elf_Internal_Sym *sym;
3764 switch (ELF32_R_TYPE (rel->r_info))
3766 case R_M32R_GNU_VTINHERIT:
3767 case R_M32R_GNU_VTENTRY:
3768 case R_M32R_RELA_GNU_VTINHERIT:
3769 case R_M32R_RELA_GNU_VTENTRY:
3773 switch (h->root.type)
3775 case bfd_link_hash_defined:
3776 case bfd_link_hash_defweak:
3777 return h->root.u.def.section;
3779 case bfd_link_hash_common:
3780 return h->root.u.c.p->section;
3788 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
3794 m32r_elf_gc_sweep_hook (abfd, info, sec, relocs)
3795 bfd *abfd ATTRIBUTE_UNUSED;
3796 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3797 asection *sec ATTRIBUTE_UNUSED;
3798 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
3800 /* Update the got entry reference counts for the section being removed. */
3801 Elf_Internal_Shdr *symtab_hdr;
3802 struct elf_link_hash_entry **sym_hashes;
3803 bfd_signed_vma *local_got_refcounts;
3804 const Elf_Internal_Rela *rel, *relend;
3806 elf_section_data (sec)->local_dynrel = NULL;
3808 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3809 sym_hashes = elf_sym_hashes (abfd);
3810 local_got_refcounts = elf_local_got_refcounts (abfd);
3812 relend = relocs + sec->reloc_count;
3813 for (rel = relocs; rel < relend; rel++)
3815 unsigned long r_symndx;
3816 struct elf_link_hash_entry *h = NULL;
3818 r_symndx = ELF32_R_SYM (rel->r_info);
3819 if (r_symndx >= symtab_hdr->sh_info)
3821 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3822 while (h->root.type == bfd_link_hash_indirect
3823 || h->root.type == bfd_link_hash_warning)
3824 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3827 switch (ELF32_R_TYPE (rel->r_info))
3829 case R_M32R_GOT16_HI_ULO:
3830 case R_M32R_GOT16_HI_SLO:
3831 case R_M32R_GOT16_LO:
3833 case R_M32R_GOTOFF_HI_ULO:
3834 case R_M32R_GOTOFF_HI_SLO:
3835 case R_M32R_GOTOFF_LO:
3837 case R_M32R_GOTPC_HI_ULO:
3838 case R_M32R_GOTPC_HI_SLO:
3839 case R_M32R_GOTPC_LO:
3840 case R_M32R_GOTPC24:
3843 if (h->got.refcount > 0)
3848 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3849 local_got_refcounts[r_symndx]--;
3853 case R_M32R_16_RELA:
3854 case R_M32R_24_RELA:
3855 case R_M32R_32_RELA:
3856 case R_M32R_HI16_ULO_RELA:
3857 case R_M32R_HI16_SLO_RELA:
3858 case R_M32R_LO16_RELA:
3859 case R_M32R_SDA16_RELA:
3860 case R_M32R_18_PCREL_RELA:
3861 case R_M32R_26_PCREL_RELA:
3864 struct elf_m32r_link_hash_entry *eh;
3865 struct elf_m32r_dyn_relocs **pp;
3866 struct elf_m32r_dyn_relocs *p;
3868 if (!info->shared && h->plt.refcount > 0)
3869 h->plt.refcount -= 1;
3871 eh = (struct elf_m32r_link_hash_entry *) h;
3873 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3876 if (ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3877 || ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA)
3887 case R_M32R_26_PLTREL:
3890 if (h->plt.refcount > 0)
3903 /* Look through the relocs for a section during the first phase.
3904 Since we don't do .gots or .plts, we just need to consider the
3905 virtual table relocs for gc. */
3908 m32r_elf_check_relocs (abfd, info, sec, relocs)
3910 struct bfd_link_info *info;
3912 const Elf_Internal_Rela *relocs;
3914 Elf_Internal_Shdr *symtab_hdr;
3915 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3916 const Elf_Internal_Rela *rel;
3917 const Elf_Internal_Rela *rel_end;
3918 struct elf_m32r_link_hash_table *htab;
3920 bfd_vma *local_got_offsets;
3921 asection *sgot, *srelgot, *sreloc;
3923 if (info->relocatable)
3926 sgot = srelgot = sreloc = NULL;
3928 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3929 sym_hashes = elf_sym_hashes (abfd);
3930 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
3931 if (!elf_bad_symtab (abfd))
3932 sym_hashes_end -= symtab_hdr->sh_info;
3934 htab = m32r_elf_hash_table (info);
3935 dynobj = htab->root.dynobj;
3936 local_got_offsets = elf_local_got_offsets (abfd);
3938 rel_end = relocs + sec->reloc_count;
3939 for (rel = relocs; rel < rel_end; rel++)
3942 struct elf_link_hash_entry *h;
3943 unsigned long r_symndx;
3945 r_symndx = ELF32_R_SYM (rel->r_info);
3946 r_type = ELF32_R_TYPE (rel->r_info);
3947 if (r_symndx < symtab_hdr->sh_info)
3950 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3952 /* Some relocs require a global offset table. */
3953 if (htab->sgot == NULL)
3957 case R_M32R_GOT16_HI_ULO:
3958 case R_M32R_GOT16_HI_SLO:
3960 case R_M32R_GOTOFF_HI_ULO:
3961 case R_M32R_GOTOFF_HI_SLO:
3962 case R_M32R_GOTOFF_LO:
3963 case R_M32R_GOT16_LO:
3964 case R_M32R_GOTPC24:
3965 case R_M32R_GOTPC_HI_ULO:
3966 case R_M32R_GOTPC_HI_SLO:
3967 case R_M32R_GOTPC_LO:
3970 htab->root.dynobj = dynobj = abfd;
3971 if (! create_got_section (dynobj, info))
3982 case R_M32R_GOT16_HI_ULO:
3983 case R_M32R_GOT16_HI_SLO:
3984 case R_M32R_GOT16_LO:
3988 h->got.refcount += 1;
3991 bfd_signed_vma *local_got_refcounts;
3993 /* This is a global offset table entry for a local
3995 local_got_refcounts = elf_local_got_refcounts (abfd);
3996 if (local_got_refcounts == NULL)
4000 size = symtab_hdr->sh_info;
4001 size *= sizeof (bfd_signed_vma);
4002 local_got_refcounts = ((bfd_signed_vma *)
4003 bfd_zalloc (abfd, size));
4004 if (local_got_refcounts == NULL)
4006 elf_local_got_refcounts (abfd) = local_got_refcounts;
4008 local_got_refcounts[r_symndx] += 1;
4012 case R_M32R_26_PLTREL:
4013 /* This symbol requires a procedure linkage table entry. We
4014 actually build the entry in adjust_dynamic_symbol,
4015 because this might be a case of linking PIC code without
4016 linking in any dynamic objects, in which case we don't
4017 need to generate a procedure linkage table after all. */
4019 /* If this is a local symbol, we resolve it directly without
4020 creating a procedure linkage table entry. */
4024 if (h->forced_local)
4028 h->plt.refcount += 1;
4031 case R_M32R_16_RELA:
4032 case R_M32R_24_RELA:
4033 case R_M32R_32_RELA:
4034 case R_M32R_HI16_ULO_RELA:
4035 case R_M32R_HI16_SLO_RELA:
4036 case R_M32R_LO16_RELA:
4037 case R_M32R_SDA16_RELA:
4038 case R_M32R_18_PCREL_RELA:
4039 case R_M32R_26_PCREL_RELA:
4041 if (h != NULL && !info->shared)
4044 h->plt.refcount += 1;
4047 /* If we are creating a shared library, and this is a reloc
4048 against a global symbol, or a non PC relative reloc
4049 against a local symbol, then we need to copy the reloc
4050 into the shared library. However, if we are linking with
4051 -Bsymbolic, we do not need to copy a reloc against a
4052 global symbol which is defined in an object we are
4053 including in the link (i.e., DEF_REGULAR is set). At
4054 this point we have not seen all the input files, so it is
4055 possible that DEF_REGULAR is not set now but will be set
4056 later (it is never cleared). We account for that
4057 possibility below by storing information in the
4058 dyn_relocs field of the hash table entry. A similar
4059 situation occurs when creating shared libraries and symbol
4060 visibility changes render the symbol local.
4062 If on the other hand, we are creating an executable, we
4063 may need to keep relocations for symbols satisfied by a
4064 dynamic library if we manage to avoid copy relocs for the
4067 && (sec->flags & SEC_ALLOC) != 0
4068 && ((r_type != R_M32R_26_PCREL_RELA
4069 && r_type != R_M32R_18_PCREL_RELA)
4071 && (! info->symbolic
4072 || h->root.type == bfd_link_hash_defweak
4073 || !h->def_regular))))
4075 && (sec->flags & SEC_ALLOC) != 0
4077 && (h->root.type == bfd_link_hash_defweak
4078 || !h->def_regular)))
4080 struct elf_m32r_dyn_relocs *p;
4081 struct elf_m32r_dyn_relocs **head;
4084 htab->root.dynobj = dynobj = abfd;
4086 /* When creating a shared object, we must copy these
4087 relocs into the output file. We create a reloc
4088 section in dynobj and make room for the reloc. */
4093 name = (bfd_elf_string_from_elf_section
4095 elf_elfheader (abfd)->e_shstrndx,
4096 elf_section_data (sec)->rel_hdr.sh_name));
4100 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4101 && strcmp (bfd_get_section_name (abfd, sec),
4104 sreloc = bfd_get_section_by_name (dynobj, name);
4109 flags = (SEC_HAS_CONTENTS | SEC_READONLY
4110 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4111 if ((sec->flags & SEC_ALLOC) != 0)
4112 flags |= SEC_ALLOC | SEC_LOAD;
4113 sreloc = bfd_make_section_with_flags (dynobj,
4117 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
4120 elf_section_data (sec)->sreloc = sreloc;
4123 /* If this is a global symbol, we count the number of
4124 relocations we need for this symbol. */
4126 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
4131 /* Track dynamic relocs needed for local syms too. */
4132 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4137 head = ((struct elf_m32r_dyn_relocs **)
4138 &elf_section_data (s)->local_dynrel);
4142 if (p == NULL || p->sec != sec)
4144 bfd_size_type amt = sizeof (*p);
4145 p = ((struct elf_m32r_dyn_relocs *) bfd_alloc (dynobj, amt));
4156 if (ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
4157 || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA)
4162 /* This relocation describes the C++ object vtable hierarchy.
4163 Reconstruct it for later use during GC. */
4164 case R_M32R_RELA_GNU_VTINHERIT:
4165 case R_M32R_GNU_VTINHERIT:
4166 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4170 /* This relocation describes which C++ vtable entries are actually
4171 used. Record for later use during GC. */
4172 case R_M32R_GNU_VTENTRY:
4173 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4176 case R_M32R_RELA_GNU_VTENTRY:
4177 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4186 static struct bfd_elf_special_section const
4187 m32r_elf_special_sections_s[] =
4189 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4190 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
4191 { NULL, 0, 0, 0, 0 }
4194 static struct bfd_elf_special_section const *
4195 m32r_elf_special_sections[27] =
4215 m32r_elf_special_sections_s, /* 's' */
4227 m32r_elf_fake_sections (abfd, hdr, sec)
4229 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
4232 register const char *name;
4234 name = bfd_get_section_name (abfd, sec);
4236 /* The generic elf_fake_sections will set up REL_HDR using the
4237 default kind of relocations. But, we may actually need both
4238 kinds of relocations, so we set up the second header here.
4240 This is not necessary for the O32 ABI since that only uses Elf32_Rel
4241 relocations (cf. System V ABI, MIPS RISC Processor Supplement,
4242 3rd Edition, p. 4-17). It breaks the IRIX 5/6 32-bit ld, since one
4243 of the resulting empty .rela.<section> sections starts with
4244 sh_offset == object size, and ld doesn't allow that. While the check
4245 is arguably bogus for empty or SHT_NOBITS sections, it can easily be
4246 avoided by not emitting those useless sections in the first place. */
4247 if ((sec->flags & SEC_RELOC) != 0)
4249 struct bfd_elf_section_data *esd;
4250 bfd_size_type amt = sizeof (Elf_Internal_Shdr);
4252 esd = elf_section_data (sec);
4253 BFD_ASSERT (esd->rel_hdr2 == NULL);
4254 esd->rel_hdr2 = (Elf_Internal_Shdr *) bfd_zalloc (abfd, amt);
4257 _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
4264 static enum elf_reloc_type_class
4265 m32r_elf_reloc_type_class (rela)
4266 const Elf_Internal_Rela *rela;
4268 switch ((int) ELF32_R_TYPE (rela->r_info))
4270 case R_M32R_RELATIVE:
4271 return reloc_class_relative;
4272 case R_M32R_JMP_SLOT:
4273 return reloc_class_plt;
4275 return reloc_class_copy;
4277 return reloc_class_normal;
4281 #define ELF_ARCH bfd_arch_m32r
4282 #define ELF_MACHINE_CODE EM_M32R
4283 #define ELF_MACHINE_ALT1 EM_CYGNUS_M32R
4284 #define ELF_MAXPAGESIZE 0x1 /* Explicitly requested by Mitsubishi. */
4286 #define TARGET_BIG_SYM bfd_elf32_m32r_vec
4287 #define TARGET_BIG_NAME "elf32-m32r"
4288 #define TARGET_LITTLE_SYM bfd_elf32_m32rle_vec
4289 #define TARGET_LITTLE_NAME "elf32-m32rle"
4291 #define elf_info_to_howto m32r_info_to_howto
4292 #define elf_info_to_howto_rel m32r_info_to_howto_rel
4293 #define elf_backend_section_from_bfd_section _bfd_m32r_elf_section_from_bfd_section
4294 #define elf_backend_symbol_processing _bfd_m32r_elf_symbol_processing
4295 #define elf_backend_add_symbol_hook m32r_elf_add_symbol_hook
4296 #define elf_backend_relocate_section m32r_elf_relocate_section
4297 #define elf_backend_gc_mark_hook m32r_elf_gc_mark_hook
4298 #define elf_backend_gc_sweep_hook m32r_elf_gc_sweep_hook
4299 #define elf_backend_check_relocs m32r_elf_check_relocs
4301 #define elf_backend_create_dynamic_sections m32r_elf_create_dynamic_sections
4302 #define bfd_elf32_bfd_link_hash_table_create m32r_elf_link_hash_table_create
4303 #define elf_backend_size_dynamic_sections m32r_elf_size_dynamic_sections
4304 #define elf_backend_finish_dynamic_sections m32r_elf_finish_dynamic_sections
4305 #define elf_backend_adjust_dynamic_symbol m32r_elf_adjust_dynamic_symbol
4306 #define elf_backend_finish_dynamic_symbol m32r_elf_finish_dynamic_symbol
4307 #define elf_backend_reloc_type_class m32r_elf_reloc_type_class
4308 #define elf_backend_copy_indirect_symbol m32r_elf_copy_indirect_symbol
4310 #define elf_backend_can_gc_sections 1
4312 #define elf_backend_rela_normal 1
4314 #define elf_backend_can_refcount 1
4315 #define elf_backend_want_got_plt 1
4316 #define elf_backend_plt_readonly 1
4317 #define elf_backend_want_plt_sym 0
4318 #define elf_backend_got_header_size 12
4320 #define elf_backend_may_use_rel_p 1
4321 #ifdef USE_M32R_OLD_RELOC
4322 #define elf_backend_default_use_rela_p 0
4323 #define elf_backend_may_use_rela_p 0
4325 #define elf_backend_default_use_rela_p 1
4326 #define elf_backend_may_use_rela_p 1
4327 #define elf_backend_fake_sections m32r_elf_fake_sections
4330 #define elf_backend_object_p m32r_elf_object_p
4331 #define elf_backend_final_write_processing m32r_elf_final_write_processing
4332 #define bfd_elf32_bfd_merge_private_bfd_data m32r_elf_merge_private_bfd_data
4333 #define bfd_elf32_bfd_set_private_flags m32r_elf_set_private_flags
4334 #define bfd_elf32_bfd_print_private_bfd_data m32r_elf_print_private_bfd_data
4335 #define elf_backend_special_sections m32r_elf_special_sections
4337 #include "elf32-target.h"
4339 #undef ELF_MAXPAGESIZE
4340 #define ELF_MAXPAGESIZE 0x1000
4342 #undef TARGET_BIG_SYM
4343 #define TARGET_BIG_SYM bfd_elf32_m32rlin_vec
4344 #undef TARGET_BIG_NAME
4345 #define TARGET_BIG_NAME "elf32-m32r-linux"
4346 #undef TARGET_LITTLE_SYM
4347 #define TARGET_LITTLE_SYM bfd_elf32_m32rlelin_vec
4348 #undef TARGET_LITTLE_NAME
4349 #define TARGET_LITTLE_NAME "elf32-m32rle-linux"
4351 #define elf32_bed elf32_m32r_lin_bed
4353 #include "elf32-target.h"