1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2013 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "bfd_stdint.h"
26 #include "libiberty.h"
28 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
30 #define RL78REL(n,sz,bit,shift,complain,pcrel) \
31 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
32 bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
34 /* Note that the relocations around 0x7f are internal to this file;
35 feel free to move them as needed to avoid conflicts with published
36 relocation numbers. */
38 static reloc_howto_type rl78_elf_howto_table
[] =
40 RL78REL (NONE
, 0, 0, 0, dont
, FALSE
),
41 RL78REL (DIR32
, 2, 32, 0, signed, FALSE
),
42 RL78REL (DIR24S
, 2, 24, 0, signed, FALSE
),
43 RL78REL (DIR16
, 1, 16, 0, dont
, FALSE
),
44 RL78REL (DIR16U
, 1, 16, 0, unsigned, FALSE
),
45 RL78REL (DIR16S
, 1, 16, 0, signed, FALSE
),
46 RL78REL (DIR8
, 0, 8, 0, dont
, FALSE
),
47 RL78REL (DIR8U
, 0, 8, 0, unsigned, FALSE
),
48 RL78REL (DIR8S
, 0, 8, 0, signed, FALSE
),
49 RL78REL (DIR24S_PCREL
, 2, 24, 0, signed, TRUE
),
50 RL78REL (DIR16S_PCREL
, 1, 16, 0, signed, TRUE
),
51 RL78REL (DIR8S_PCREL
, 0, 8, 0, signed, TRUE
),
52 RL78REL (DIR16UL
, 1, 16, 2, unsigned, FALSE
),
53 RL78REL (DIR16UW
, 1, 16, 1, unsigned, FALSE
),
54 RL78REL (DIR8UL
, 0, 8, 2, unsigned, FALSE
),
55 RL78REL (DIR8UW
, 0, 8, 1, unsigned, FALSE
),
56 RL78REL (DIR32_REV
, 1, 16, 0, dont
, FALSE
),
57 RL78REL (DIR16_REV
, 1, 16, 0, dont
, FALSE
),
58 RL78REL (DIR3U_PCREL
, 0, 3, 0, dont
, TRUE
),
87 RL78REL (RH_RELAX
, 0, 0, 0, dont
, FALSE
),
109 RL78REL (ABS32
, 2, 32, 0, dont
, FALSE
),
110 RL78REL (ABS24S
, 2, 24, 0, signed, FALSE
),
111 RL78REL (ABS16
, 1, 16, 0, dont
, FALSE
),
112 RL78REL (ABS16U
, 1, 16, 0, unsigned, FALSE
),
113 RL78REL (ABS16S
, 1, 16, 0, signed, FALSE
),
114 RL78REL (ABS8
, 0, 8, 0, dont
, FALSE
),
115 RL78REL (ABS8U
, 0, 8, 0, unsigned, FALSE
),
116 RL78REL (ABS8S
, 0, 8, 0, signed, FALSE
),
117 RL78REL (ABS24S_PCREL
, 2, 24, 0, signed, TRUE
),
118 RL78REL (ABS16S_PCREL
, 1, 16, 0, signed, TRUE
),
119 RL78REL (ABS8S_PCREL
, 0, 8, 0, signed, TRUE
),
120 RL78REL (ABS16UL
, 1, 16, 0, unsigned, FALSE
),
121 RL78REL (ABS16UW
, 1, 16, 0, unsigned, FALSE
),
122 RL78REL (ABS8UL
, 0, 8, 0, unsigned, FALSE
),
123 RL78REL (ABS8UW
, 0, 8, 0, unsigned, FALSE
),
124 RL78REL (ABS32_REV
, 2, 32, 0, dont
, FALSE
),
125 RL78REL (ABS16_REV
, 1, 16, 0, dont
, FALSE
),
127 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
177 RL78REL (SYM
, 2, 32, 0, dont
, FALSE
),
178 RL78REL (OPneg
, 2, 32, 0, dont
, FALSE
),
179 RL78REL (OPadd
, 2, 32, 0, dont
, FALSE
),
180 RL78REL (OPsub
, 2, 32, 0, dont
, FALSE
),
181 RL78REL (OPmul
, 2, 32, 0, dont
, FALSE
),
182 RL78REL (OPdiv
, 2, 32, 0, dont
, FALSE
),
183 RL78REL (OPshla
, 2, 32, 0, dont
, FALSE
),
184 RL78REL (OPshra
, 2, 32, 0, dont
, FALSE
),
185 RL78REL (OPsctsize
, 2, 32, 0, dont
, FALSE
),
190 RL78REL (OPscttop
, 2, 32, 0, dont
, FALSE
),
193 RL78REL (OPand
, 2, 32, 0, dont
, FALSE
),
194 RL78REL (OPor
, 2, 32, 0, dont
, FALSE
),
195 RL78REL (OPxor
, 2, 32, 0, dont
, FALSE
),
196 RL78REL (OPnot
, 2, 32, 0, dont
, FALSE
),
197 RL78REL (OPmod
, 2, 32, 0, dont
, FALSE
),
198 RL78REL (OPromtop
, 2, 32, 0, dont
, FALSE
),
199 RL78REL (OPramtop
, 2, 32, 0, dont
, FALSE
)
202 /* Map BFD reloc types to RL78 ELF reloc types. */
204 struct rl78_reloc_map
206 bfd_reloc_code_real_type bfd_reloc_val
;
207 unsigned int rl78_reloc_val
;
210 static const struct rl78_reloc_map rl78_reloc_map
[] =
212 { BFD_RELOC_NONE
, R_RL78_NONE
},
213 { BFD_RELOC_8
, R_RL78_DIR8S
},
214 { BFD_RELOC_16
, R_RL78_DIR16S
},
215 { BFD_RELOC_24
, R_RL78_DIR24S
},
216 { BFD_RELOC_32
, R_RL78_DIR32
},
217 { BFD_RELOC_RL78_16_OP
, R_RL78_DIR16
},
218 { BFD_RELOC_RL78_DIR3U_PCREL
, R_RL78_DIR3U_PCREL
},
219 { BFD_RELOC_8_PCREL
, R_RL78_DIR8S_PCREL
},
220 { BFD_RELOC_16_PCREL
, R_RL78_DIR16S_PCREL
},
221 { BFD_RELOC_24_PCREL
, R_RL78_DIR24S_PCREL
},
222 { BFD_RELOC_RL78_8U
, R_RL78_DIR8U
},
223 { BFD_RELOC_RL78_16U
, R_RL78_DIR16U
},
224 { BFD_RELOC_RL78_SYM
, R_RL78_SYM
},
225 { BFD_RELOC_RL78_OP_SUBTRACT
, R_RL78_OPsub
},
226 { BFD_RELOC_RL78_OP_NEG
, R_RL78_OPneg
},
227 { BFD_RELOC_RL78_OP_AND
, R_RL78_OPand
},
228 { BFD_RELOC_RL78_OP_SHRA
, R_RL78_OPshra
},
229 { BFD_RELOC_RL78_ABS8
, R_RL78_ABS8
},
230 { BFD_RELOC_RL78_ABS16
, R_RL78_ABS16
},
231 { BFD_RELOC_RL78_ABS16_REV
, R_RL78_ABS16_REV
},
232 { BFD_RELOC_RL78_ABS32
, R_RL78_ABS32
},
233 { BFD_RELOC_RL78_ABS32_REV
, R_RL78_ABS32_REV
},
234 { BFD_RELOC_RL78_ABS16UL
, R_RL78_ABS16UL
},
235 { BFD_RELOC_RL78_ABS16UW
, R_RL78_ABS16UW
},
236 { BFD_RELOC_RL78_ABS16U
, R_RL78_ABS16U
},
237 { BFD_RELOC_RL78_RELAX
, R_RL78_RH_RELAX
}
240 static reloc_howto_type
*
241 rl78_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
242 bfd_reloc_code_real_type code
)
246 if (code
== BFD_RELOC_RL78_32_OP
)
247 return rl78_elf_howto_table
+ R_RL78_DIR32
;
249 for (i
= ARRAY_SIZE (rl78_reloc_map
); --i
;)
250 if (rl78_reloc_map
[i
].bfd_reloc_val
== code
)
251 return rl78_elf_howto_table
+ rl78_reloc_map
[i
].rl78_reloc_val
;
256 static reloc_howto_type
*
257 rl78_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
, const char * r_name
)
261 for (i
= 0; i
< ARRAY_SIZE (rl78_elf_howto_table
); i
++)
262 if (rl78_elf_howto_table
[i
].name
!= NULL
263 && strcasecmp (rl78_elf_howto_table
[i
].name
, r_name
) == 0)
264 return rl78_elf_howto_table
+ i
;
269 /* Set the howto pointer for an RL78 ELF reloc. */
272 rl78_info_to_howto_rela (bfd
* abfd ATTRIBUTE_UNUSED
,
274 Elf_Internal_Rela
* dst
)
278 r_type
= ELF32_R_TYPE (dst
->r_info
);
279 BFD_ASSERT (r_type
< (unsigned int) R_RL78_max
);
280 cache_ptr
->howto
= rl78_elf_howto_table
+ r_type
;
284 get_symbol_value (const char * name
,
285 bfd_reloc_status_type
* status
,
286 struct bfd_link_info
* info
,
288 asection
* input_section
,
292 struct bfd_link_hash_entry
* h
;
294 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
297 || (h
->type
!= bfd_link_hash_defined
298 && h
->type
!= bfd_link_hash_defweak
))
299 * status
= info
->callbacks
->undefined_symbol
300 (info
, name
, input_bfd
, input_section
, offset
, TRUE
);
302 value
= (h
->u
.def
.value
303 + h
->u
.def
.section
->output_section
->vma
304 + h
->u
.def
.section
->output_offset
);
310 get_romstart (bfd_reloc_status_type
* status
,
311 struct bfd_link_info
* info
,
316 static bfd_boolean cached
= FALSE
;
317 static bfd_vma cached_value
= 0;
321 cached_value
= get_symbol_value ("_start", status
, info
, abfd
, sec
, offset
);
328 get_ramstart (bfd_reloc_status_type
* status
,
329 struct bfd_link_info
* info
,
334 static bfd_boolean cached
= FALSE
;
335 static bfd_vma cached_value
= 0;
339 cached_value
= get_symbol_value ("__datastart", status
, info
, abfd
, sec
, offset
);
345 #define NUM_STACK_ENTRIES 16
346 static int32_t rl78_stack
[ NUM_STACK_ENTRIES
];
347 static unsigned int rl78_stack_top
;
349 #define RL78_STACK_PUSH(val) \
352 if (rl78_stack_top < NUM_STACK_ENTRIES) \
353 rl78_stack [rl78_stack_top ++] = (val); \
355 r = bfd_reloc_dangerous; \
359 #define RL78_STACK_POP(dest) \
362 if (rl78_stack_top > 0) \
363 (dest) = rl78_stack [-- rl78_stack_top]; \
365 (dest) = 0, r = bfd_reloc_dangerous; \
369 /* Relocate an RL78 ELF section.
370 There is some attempt to make this function usable for many architectures,
371 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
372 if only to serve as a learning tool.
374 The RELOCATE_SECTION function is called by the new ELF backend linker
375 to handle the relocations for a section.
377 The relocs are always passed as Rela structures; if the section
378 actually uses Rel structures, the r_addend field will always be
381 This function is responsible for adjusting the section contents as
382 necessary, and (if using Rela relocs and generating a relocatable
383 output file) adjusting the reloc addend as necessary.
385 This function does not have to worry about setting the reloc
386 address or the reloc symbol index.
388 LOCAL_SYMS is a pointer to the swapped in local symbols.
390 LOCAL_SECTIONS is an array giving the section in the input file
391 corresponding to the st_shndx field of each local symbol.
393 The global hash table entry for the global symbols can be found
394 via elf_sym_hashes (input_bfd).
396 When generating relocatable output, this function must handle
397 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
398 going to be the section symbol corresponding to the output
399 section, which means that the addend must be adjusted
403 rl78_elf_relocate_section
405 struct bfd_link_info
* info
,
407 asection
* input_section
,
409 Elf_Internal_Rela
* relocs
,
410 Elf_Internal_Sym
* local_syms
,
411 asection
** local_sections
)
413 Elf_Internal_Shdr
* symtab_hdr
;
414 struct elf_link_hash_entry
** sym_hashes
;
415 Elf_Internal_Rela
* rel
;
416 Elf_Internal_Rela
* relend
;
420 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
421 sym_hashes
= elf_sym_hashes (input_bfd
);
422 relend
= relocs
+ input_section
->reloc_count
;
424 dynobj
= elf_hash_table (info
)->dynobj
;
427 splt
= bfd_get_linker_section (dynobj
, ".plt");
429 for (rel
= relocs
; rel
< relend
; rel
++)
431 reloc_howto_type
* howto
;
432 unsigned long r_symndx
;
433 Elf_Internal_Sym
* sym
;
435 struct elf_link_hash_entry
* h
;
437 bfd_reloc_status_type r
;
438 const char * name
= NULL
;
439 bfd_boolean unresolved_reloc
= TRUE
;
442 r_type
= ELF32_R_TYPE (rel
->r_info
);
443 r_symndx
= ELF32_R_SYM (rel
->r_info
);
445 howto
= rl78_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
451 if (r_symndx
< symtab_hdr
->sh_info
)
453 sym
= local_syms
+ r_symndx
;
454 sec
= local_sections
[r_symndx
];
455 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
457 name
= bfd_elf_string_from_elf_section
458 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
459 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
465 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
466 r_symndx
, symtab_hdr
, sym_hashes
, h
,
467 sec
, relocation
, unresolved_reloc
,
470 name
= h
->root
.root
.string
;
473 if (sec
!= NULL
&& discarded_section (sec
))
474 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
475 rel
, 1, relend
, howto
, 0, contents
);
477 if (info
->relocatable
)
479 /* This is a relocatable link. We don't have to change
480 anything, unless the reloc is against a section symbol,
481 in which case we have to adjust according to where the
482 section symbol winds up in the output section. */
483 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
484 rel
->r_addend
+= sec
->output_offset
;
488 switch (ELF32_R_TYPE (rel
->r_info
))
495 plt_offset
= &h
->plt
.offset
;
497 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
499 if (! valid_16bit_address (relocation
))
501 /* If this is the first time we've processed this symbol,
502 fill in the plt entry with the correct symbol address. */
503 if ((*plt_offset
& 1) == 0)
507 x
= 0x000000ec; /* br !!abs24 */
508 x
|= (relocation
<< 8) & 0xffffff00;
509 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
513 relocation
= (splt
->output_section
->vma
514 + splt
->output_offset
515 + (*plt_offset
& -2));
518 char *newname
= bfd_malloc (strlen(name
)+5);
519 strcpy (newname
, name
);
520 strcat(newname
, ".plt");
521 _bfd_generic_link_add_one_symbol (info
,
524 BSF_FUNCTION
| BSF_WEAK
,
537 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
538 /* If the symbol is undefined and weak
539 then the relocation resolves to zero. */
543 if (howto
->pc_relative
)
545 relocation
-= (input_section
->output_section
->vma
546 + input_section
->output_offset
548 relocation
-= bfd_get_reloc_size (howto
);
551 relocation
+= rel
->r_addend
;
556 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
557 #define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
558 #define OP(i) (contents[rel->r_offset + (i)])
560 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
566 case R_RL78_RH_RELAX
:
569 case R_RL78_DIR8S_PCREL
:
584 case R_RL78_DIR16S_PCREL
:
585 RANGE (-32768, 32767);
587 OP (1) = relocation
>> 8;
591 if ((relocation
& 0xf0000) == 0xf0000)
592 relocation
&= 0xffff;
593 RANGE (-32768, 65535);
595 OP (1) = relocation
>> 8;
601 OP (1) = relocation
>> 8;
605 RANGE (-32768, 65536);
607 OP (1) = relocation
>> 8;
610 case R_RL78_DIR16_REV
:
611 RANGE (-32768, 65536);
613 OP (0) = relocation
>> 8;
616 case R_RL78_DIR3U_PCREL
:
619 OP (0) |= relocation
& 0x07;
622 case R_RL78_DIR24S_PCREL
:
623 RANGE (-0x800000, 0x7fffff);
625 OP (1) = relocation
>> 8;
626 OP (2) = relocation
>> 16;
630 RANGE (-0x800000, 0x7fffff);
632 OP (1) = relocation
>> 8;
633 OP (2) = relocation
>> 16;
638 OP (1) = relocation
>> 8;
639 OP (2) = relocation
>> 16;
640 OP (3) = relocation
>> 24;
643 case R_RL78_DIR32_REV
:
645 OP (2) = relocation
>> 8;
646 OP (1) = relocation
>> 16;
647 OP (0) = relocation
>> 24;
651 RANGE (0xfff00, 0xfffff);
652 OP (0) = relocation
& 0xff;
655 case R_RL78_RH_SADDR
:
656 RANGE (0xffe20, 0xfff1f);
657 OP (0) = relocation
& 0xff;
660 /* Complex reloc handling: */
663 RL78_STACK_POP (relocation
);
665 OP (1) = relocation
>> 8;
666 OP (2) = relocation
>> 16;
667 OP (3) = relocation
>> 24;
670 case R_RL78_ABS32_REV
:
671 RL78_STACK_POP (relocation
);
673 OP (2) = relocation
>> 8;
674 OP (1) = relocation
>> 16;
675 OP (0) = relocation
>> 24;
678 case R_RL78_ABS24S_PCREL
:
680 RL78_STACK_POP (relocation
);
681 RANGE (-0x800000, 0x7fffff);
683 OP (1) = relocation
>> 8;
684 OP (2) = relocation
>> 16;
688 RL78_STACK_POP (relocation
);
689 RANGE (-32768, 65535);
691 OP (1) = relocation
>> 8;
694 case R_RL78_ABS16_REV
:
695 RL78_STACK_POP (relocation
);
696 RANGE (-32768, 65535);
698 OP (0) = relocation
>> 8;
701 case R_RL78_ABS16S_PCREL
:
703 RL78_STACK_POP (relocation
);
704 RANGE (-32768, 32767);
706 OP (1) = relocation
>> 8;
710 RL78_STACK_POP (relocation
);
713 OP (1) = relocation
>> 8;
717 RL78_STACK_POP (relocation
);
721 OP (1) = relocation
>> 8;
725 RL78_STACK_POP (relocation
);
729 OP (1) = relocation
>> 8;
733 RL78_STACK_POP (relocation
);
739 RL78_STACK_POP (relocation
);
745 RL78_STACK_POP (relocation
);
752 RL78_STACK_POP (relocation
);
758 case R_RL78_ABS8S_PCREL
:
760 RL78_STACK_POP (relocation
);
766 if (r_symndx
< symtab_hdr
->sh_info
)
767 RL78_STACK_PUSH (sec
->output_section
->vma
774 && (h
->root
.type
== bfd_link_hash_defined
775 || h
->root
.type
== bfd_link_hash_defweak
))
776 RL78_STACK_PUSH (h
->root
.u
.def
.value
777 + sec
->output_section
->vma
780 else if (h
->root
.type
== bfd_link_hash_undefweak
)
783 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
791 RL78_STACK_POP (tmp
);
793 RL78_STACK_PUSH (tmp
);
801 RL78_STACK_POP (tmp2
);
802 RL78_STACK_POP (tmp1
);
804 RL78_STACK_PUSH (tmp1
);
812 /* For the expression "A - B", the assembler pushes A,
813 then B, then OPSUB. So the first op we pop is B, not
815 RL78_STACK_POP (tmp2
); /* B */
816 RL78_STACK_POP (tmp1
); /* A */
817 tmp1
-= tmp2
; /* A - B */
818 RL78_STACK_PUSH (tmp1
);
826 RL78_STACK_POP (tmp2
);
827 RL78_STACK_POP (tmp1
);
829 RL78_STACK_PUSH (tmp1
);
837 RL78_STACK_POP (tmp2
);
838 RL78_STACK_POP (tmp1
);
840 RL78_STACK_PUSH (tmp1
);
848 RL78_STACK_POP (tmp2
);
849 RL78_STACK_POP (tmp1
);
851 RL78_STACK_PUSH (tmp1
);
859 RL78_STACK_POP (tmp2
);
860 RL78_STACK_POP (tmp1
);
862 RL78_STACK_PUSH (tmp1
);
866 case R_RL78_OPsctsize
:
867 RL78_STACK_PUSH (input_section
->size
);
870 case R_RL78_OPscttop
:
871 RL78_STACK_PUSH (input_section
->output_section
->vma
);
878 RL78_STACK_POP (tmp2
);
879 RL78_STACK_POP (tmp1
);
881 RL78_STACK_PUSH (tmp1
);
889 RL78_STACK_POP (tmp2
);
890 RL78_STACK_POP (tmp1
);
892 RL78_STACK_PUSH (tmp1
);
900 RL78_STACK_POP (tmp2
);
901 RL78_STACK_POP (tmp1
);
903 RL78_STACK_PUSH (tmp1
);
911 RL78_STACK_POP (tmp
);
913 RL78_STACK_PUSH (tmp
);
921 RL78_STACK_POP (tmp2
);
922 RL78_STACK_POP (tmp1
);
924 RL78_STACK_PUSH (tmp1
);
928 case R_RL78_OPromtop
:
929 RL78_STACK_PUSH (get_romstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
932 case R_RL78_OPramtop
:
933 RL78_STACK_PUSH (get_ramstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
937 r
= bfd_reloc_notsupported
;
941 if (r
!= bfd_reloc_ok
)
943 const char * msg
= NULL
;
947 case bfd_reloc_overflow
:
948 /* Catch the case of a missing function declaration
949 and emit a more helpful error message. */
950 if (r_type
== R_RL78_DIR24S_PCREL
)
951 msg
= _("%B(%A): error: call to undefined function '%s'");
953 r
= info
->callbacks
->reloc_overflow
954 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
955 input_bfd
, input_section
, rel
->r_offset
);
958 case bfd_reloc_undefined
:
959 r
= info
->callbacks
->undefined_symbol
960 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
964 case bfd_reloc_other
:
965 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
968 case bfd_reloc_outofrange
:
969 msg
= _("%B(%A): internal error: out of range error");
972 case bfd_reloc_notsupported
:
973 msg
= _("%B(%A): internal error: unsupported relocation error");
976 case bfd_reloc_dangerous
:
977 msg
= _("%B(%A): internal error: dangerous relocation");
981 msg
= _("%B(%A): internal error: unknown error");
986 _bfd_error_handler (msg
, input_bfd
, input_section
, name
);
996 /* Function to set the ELF flag bits. */
999 rl78_elf_set_private_flags (bfd
* abfd
, flagword flags
)
1001 elf_elfheader (abfd
)->e_flags
= flags
;
1002 elf_flags_init (abfd
) = TRUE
;
1006 static bfd_boolean no_warn_mismatch
= FALSE
;
1008 void bfd_elf32_rl78_set_target_flags (bfd_boolean
);
1011 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch
)
1013 no_warn_mismatch
= user_no_warn_mismatch
;
1016 /* Merge backend specific data from an object file to the output
1017 object file when linking. */
1020 rl78_elf_merge_private_bfd_data (bfd
* ibfd
, bfd
* obfd
)
1024 bfd_boolean error
= FALSE
;
1026 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1027 old_flags
= elf_elfheader (obfd
)->e_flags
;
1029 if (!elf_flags_init (obfd
))
1031 /* First call, no flags set. */
1032 elf_flags_init (obfd
) = TRUE
;
1033 elf_elfheader (obfd
)->e_flags
= new_flags
;
1035 else if (old_flags
!= new_flags
)
1037 flagword changed_flags
= old_flags
^ new_flags
;
1039 if (changed_flags
& E_FLAG_RL78_G10
)
1041 (*_bfd_error_handler
)
1042 (_("RL78/G10 ABI conflict: cannot link G10 and non-G10 objects together"));
1044 if (old_flags
& E_FLAG_RL78_G10
)
1045 (*_bfd_error_handler
) (_("- %s is G10, %s is not"),
1046 bfd_get_filename (obfd
), bfd_get_filename (ibfd
));
1048 (*_bfd_error_handler
) (_("- %s is G10, %s is not"),
1049 bfd_get_filename (ibfd
), bfd_get_filename (obfd
));
1057 rl78_elf_print_private_bfd_data (bfd
* abfd
, void * ptr
)
1059 FILE * file
= (FILE *) ptr
;
1062 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
1064 /* Print normal ELF private data. */
1065 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
1067 flags
= elf_elfheader (abfd
)->e_flags
;
1068 fprintf (file
, _("private flags = 0x%lx:"), (long) flags
);
1070 if (flags
& E_FLAG_RL78_G10
)
1071 fprintf (file
, _(" [G10]"));
1077 /* Return the MACH for an e_flags value. */
1080 elf32_rl78_machine (bfd
* abfd
)
1082 if ((elf_elfheader (abfd
)->e_flags
& EF_RL78_CPU_MASK
) == EF_RL78_CPU_RL78
)
1083 return bfd_mach_rl78
;
1089 rl78_elf_object_p (bfd
* abfd
)
1091 bfd_default_set_arch_mach (abfd
, bfd_arch_rl78
,
1092 elf32_rl78_machine (abfd
));
1098 rl78_dump_symtab (bfd
* abfd
, void * internal_syms
, void * external_syms
)
1101 Elf_Internal_Sym
* isymbuf
;
1102 Elf_Internal_Sym
* isymend
;
1103 Elf_Internal_Sym
* isym
;
1104 Elf_Internal_Shdr
* symtab_hdr
;
1105 bfd_boolean free_internal
= FALSE
, free_external
= FALSE
;
1107 char * st_info_stb_str
;
1108 char * st_other_str
;
1109 char * st_shndx_str
;
1111 if (! internal_syms
)
1113 internal_syms
= bfd_malloc (1000);
1116 if (! external_syms
)
1118 external_syms
= bfd_malloc (1000);
1122 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1123 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
1125 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1126 symtab_hdr
->sh_info
, 0,
1127 internal_syms
, external_syms
, NULL
);
1129 isymbuf
= internal_syms
;
1130 isymend
= isymbuf
+ locsymcount
;
1132 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1134 switch (ELF_ST_TYPE (isym
->st_info
))
1136 case STT_FUNC
: st_info_str
= "STT_FUNC";
1137 case STT_SECTION
: st_info_str
= "STT_SECTION";
1138 case STT_FILE
: st_info_str
= "STT_FILE";
1139 case STT_OBJECT
: st_info_str
= "STT_OBJECT";
1140 case STT_TLS
: st_info_str
= "STT_TLS";
1141 default: st_info_str
= "";
1143 switch (ELF_ST_BIND (isym
->st_info
))
1145 case STB_LOCAL
: st_info_stb_str
= "STB_LOCAL";
1146 case STB_GLOBAL
: st_info_stb_str
= "STB_GLOBAL";
1147 default: st_info_stb_str
= "";
1149 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1151 case STV_DEFAULT
: st_other_str
= "STV_DEFAULT";
1152 case STV_INTERNAL
: st_other_str
= "STV_INTERNAL";
1153 case STV_PROTECTED
: st_other_str
= "STV_PROTECTED";
1154 default: st_other_str
= "";
1156 switch (isym
->st_shndx
)
1158 case SHN_ABS
: st_shndx_str
= "SHN_ABS";
1159 case SHN_COMMON
: st_shndx_str
= "SHN_COMMON";
1160 case SHN_UNDEF
: st_shndx_str
= "SHN_UNDEF";
1161 default: st_shndx_str
= "";
1165 free (internal_syms
);
1167 free (external_syms
);
1171 rl78_get_reloc (long reloc
)
1173 if (0 <= reloc
&& reloc
< R_RL78_max
)
1174 return rl78_elf_howto_table
[reloc
].name
;
1180 /* support PLT for 16-bit references to 24-bit functions. */
1182 /* We support 16-bit pointers to code above 64k by generating a thunk
1183 below 64k containing a JMP instruction to the final address. */
1186 rl78_elf_check_relocs
1188 struct bfd_link_info
* info
,
1190 const Elf_Internal_Rela
* relocs
)
1192 Elf_Internal_Shdr
* symtab_hdr
;
1193 struct elf_link_hash_entry
** sym_hashes
;
1194 const Elf_Internal_Rela
* rel
;
1195 const Elf_Internal_Rela
* rel_end
;
1196 bfd_vma
*local_plt_offsets
;
1200 if (info
->relocatable
)
1203 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1204 sym_hashes
= elf_sym_hashes (abfd
);
1205 local_plt_offsets
= elf_local_got_offsets (abfd
);
1207 dynobj
= elf_hash_table(info
)->dynobj
;
1209 rel_end
= relocs
+ sec
->reloc_count
;
1210 for (rel
= relocs
; rel
< rel_end
; rel
++)
1212 struct elf_link_hash_entry
*h
;
1213 unsigned long r_symndx
;
1216 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1217 if (r_symndx
< symtab_hdr
->sh_info
)
1221 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1222 while (h
->root
.type
== bfd_link_hash_indirect
1223 || h
->root
.type
== bfd_link_hash_warning
)
1224 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1226 /* PR15323, ref flags aren't set for references in the same
1228 h
->root
.non_ir_ref
= 1;
1231 switch (ELF32_R_TYPE (rel
->r_info
))
1233 /* This relocation describes a 16-bit pointer to a function.
1234 We may need to allocate a thunk in low memory; reserve memory
1238 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1241 splt
= bfd_get_linker_section (dynobj
, ".plt");
1244 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1245 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
1246 | SEC_READONLY
| SEC_CODE
);
1247 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
1250 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
1256 offset
= &h
->plt
.offset
;
1259 if (local_plt_offsets
== NULL
)
1264 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
1265 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
1266 if (local_plt_offsets
== NULL
)
1268 elf_local_got_offsets (abfd
) = local_plt_offsets
;
1270 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
1271 local_plt_offsets
[i
] = (bfd_vma
) -1;
1273 offset
= &local_plt_offsets
[r_symndx
];
1276 if (*offset
== (bfd_vma
) -1)
1278 *offset
= splt
->size
;
1288 /* This must exist if dynobj is ever set. */
1291 rl78_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
1292 struct bfd_link_info
*info
)
1297 if (!elf_hash_table (info
)->dynamic_sections_created
)
1300 /* As an extra sanity check, verify that all plt entries have been
1301 filled in. However, relaxing might have changed the relocs so
1302 that some plt entries don't get filled in, so we have to skip
1303 this check if we're relaxing. Unfortunately, check_relocs is
1304 called before relaxation. */
1306 if (info
->relax_trip
> 0)
1309 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
1310 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
1312 bfd_byte
*contents
= splt
->contents
;
1313 unsigned int i
, size
= splt
->size
;
1315 for (i
= 0; i
< size
; i
+= 4)
1317 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
1318 BFD_ASSERT (x
!= 0);
1326 rl78_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1327 struct bfd_link_info
*info
)
1332 if (info
->relocatable
)
1335 dynobj
= elf_hash_table (info
)->dynobj
;
1339 splt
= bfd_get_linker_section (dynobj
, ".plt");
1340 BFD_ASSERT (splt
!= NULL
);
1342 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
1343 if (splt
->contents
== NULL
)
1351 /* Handle relaxing. */
1353 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1354 is within the low 64k, remove any entry for it in the plt. */
1356 struct relax_plt_data
1363 rl78_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1365 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1367 if (h
->plt
.offset
!= (bfd_vma
) -1)
1371 if (h
->root
.type
== bfd_link_hash_undefined
1372 || h
->root
.type
== bfd_link_hash_undefweak
)
1375 address
= (h
->root
.u
.def
.section
->output_section
->vma
1376 + h
->root
.u
.def
.section
->output_offset
1377 + h
->root
.u
.def
.value
);
1379 if (valid_16bit_address (address
))
1382 data
->splt
->size
-= 4;
1383 *data
->again
= TRUE
;
1390 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1391 previously had a plt entry, give it a new entry offset. */
1394 rl78_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1396 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1398 if (h
->plt
.offset
!= (bfd_vma
) -1)
1400 h
->plt
.offset
= *entry
;
1408 rl78_elf_relax_plt_section (bfd
*dynobj
,
1410 struct bfd_link_info
*info
,
1413 struct relax_plt_data relax_plt_data
;
1416 /* Assume nothing changes. */
1419 if (info
->relocatable
)
1422 /* We only relax the .plt section at the moment. */
1423 if (dynobj
!= elf_hash_table (info
)->dynobj
1424 || strcmp (splt
->name
, ".plt") != 0)
1427 /* Quick check for an empty plt. */
1428 if (splt
->size
== 0)
1431 /* Map across all global symbols; see which ones happen to
1432 fall in the low 64k. */
1433 relax_plt_data
.splt
= splt
;
1434 relax_plt_data
.again
= again
;
1435 elf_link_hash_traverse (elf_hash_table (info
), rl78_relax_plt_check
,
1438 /* Likewise for local symbols, though that's somewhat less convenient
1439 as we have to walk the list of input bfds and swap in symbol data. */
1440 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1442 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1443 Elf_Internal_Shdr
*symtab_hdr
;
1444 Elf_Internal_Sym
*isymbuf
= NULL
;
1447 if (! local_plt_offsets
)
1450 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1451 if (symtab_hdr
->sh_info
!= 0)
1453 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1454 if (isymbuf
== NULL
)
1455 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1456 symtab_hdr
->sh_info
, 0,
1458 if (isymbuf
== NULL
)
1462 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1464 Elf_Internal_Sym
*isym
;
1468 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1471 isym
= &isymbuf
[idx
];
1472 if (isym
->st_shndx
== SHN_UNDEF
)
1474 else if (isym
->st_shndx
== SHN_ABS
)
1475 tsec
= bfd_abs_section_ptr
;
1476 else if (isym
->st_shndx
== SHN_COMMON
)
1477 tsec
= bfd_com_section_ptr
;
1479 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1481 address
= (tsec
->output_section
->vma
1482 + tsec
->output_offset
1484 if (valid_16bit_address (address
))
1486 local_plt_offsets
[idx
] = -1;
1493 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1495 if (! info
->keep_memory
)
1499 /* Cache the symbols for elf_link_input_bfd. */
1500 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1505 /* If we changed anything, walk the symbols again to reallocate
1506 .plt entry addresses. */
1507 if (*again
&& splt
->size
> 0)
1511 elf_link_hash_traverse (elf_hash_table (info
),
1512 rl78_relax_plt_realloc
, &entry
);
1514 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1516 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1517 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1520 if (! local_plt_offsets
)
1523 for (idx
= 0; idx
< nlocals
; ++idx
)
1524 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1526 local_plt_offsets
[idx
] = entry
;
1535 /* Delete some bytes from a section while relaxing. */
1538 elf32_rl78_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, int count
,
1539 Elf_Internal_Rela
*alignment_rel
, int force_snip
)
1541 Elf_Internal_Shdr
* symtab_hdr
;
1542 unsigned int sec_shndx
;
1543 bfd_byte
* contents
;
1544 Elf_Internal_Rela
* irel
;
1545 Elf_Internal_Rela
* irelend
;
1546 Elf_Internal_Sym
* isym
;
1547 Elf_Internal_Sym
* isymend
;
1549 unsigned int symcount
;
1550 struct elf_link_hash_entry
** sym_hashes
;
1551 struct elf_link_hash_entry
** end_hashes
;
1556 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1558 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1560 /* The deletion must stop at the next alignment boundary, if
1561 ALIGNMENT_REL is non-NULL. */
1564 toaddr
= alignment_rel
->r_offset
;
1566 irel
= elf_section_data (sec
)->relocs
;
1567 irelend
= irel
+ sec
->reloc_count
;
1569 /* Actually delete the bytes. */
1570 memmove (contents
+ addr
, contents
+ addr
+ count
,
1571 (size_t) (toaddr
- addr
- count
));
1573 /* If we don't have an alignment marker to worry about, we can just
1574 shrink the section. Otherwise, we have to fill in the newly
1575 created gap with NOP insns (0x03). */
1579 memset (contents
+ toaddr
- count
, 0x03, count
);
1581 /* Adjust all the relocs. */
1582 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1584 /* Get the new reloc address. */
1585 if (irel
->r_offset
> addr
1586 && (irel
->r_offset
< toaddr
1587 || (force_snip
&& irel
->r_offset
== toaddr
)))
1588 irel
->r_offset
-= count
;
1590 /* If we see an ALIGN marker at the end of the gap, we move it
1591 to the beginning of the gap, since marking these gaps is what
1593 if (irel
->r_offset
== toaddr
1594 && ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
1595 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
1596 irel
->r_offset
-= count
;
1599 /* Adjust the local symbols defined in this section. */
1600 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1601 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1602 isymend
= isym
+ symtab_hdr
->sh_info
;
1604 for (; isym
< isymend
; isym
++)
1606 /* If the symbol is in the range of memory we just moved, we
1607 have to adjust its value. */
1608 if (isym
->st_shndx
== sec_shndx
1609 && isym
->st_value
> addr
1610 && isym
->st_value
< toaddr
)
1611 isym
->st_value
-= count
;
1613 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1614 *end* is in the moved bytes but it's *start* isn't), then we
1615 must adjust its size. */
1616 if (isym
->st_shndx
== sec_shndx
1617 && isym
->st_value
< addr
1618 && isym
->st_value
+ isym
->st_size
> addr
1619 && isym
->st_value
+ isym
->st_size
< toaddr
)
1620 isym
->st_size
-= count
;
1623 /* Now adjust the global symbols defined in this section. */
1624 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1625 - symtab_hdr
->sh_info
);
1626 sym_hashes
= elf_sym_hashes (abfd
);
1627 end_hashes
= sym_hashes
+ symcount
;
1629 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1631 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1633 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1634 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1635 && sym_hash
->root
.u
.def
.section
== sec
)
1637 /* As above, adjust the value if needed. */
1638 if (sym_hash
->root
.u
.def
.value
> addr
1639 && sym_hash
->root
.u
.def
.value
< toaddr
)
1640 sym_hash
->root
.u
.def
.value
-= count
;
1642 /* As above, adjust the size if needed. */
1643 if (sym_hash
->root
.u
.def
.value
< addr
1644 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1645 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1646 sym_hash
->size
-= count
;
1653 /* Used to sort relocs by address. If relocs have the same address,
1654 we maintain their relative order, except that R_RL78_RH_RELAX
1655 alignment relocs must be the first reloc for any given address. */
1658 reloc_bubblesort (Elf_Internal_Rela
* r
, int count
)
1662 bfd_boolean swappit
;
1664 /* This is almost a classic bubblesort. It's the slowest sort, but
1665 we're taking advantage of the fact that the relocations are
1666 mostly in order already (the assembler emits them that way) and
1667 we need relocs with the same address to remain in the same
1673 for (i
= 0; i
< count
- 1; i
++)
1675 if (r
[i
].r_offset
> r
[i
+ 1].r_offset
)
1677 else if (r
[i
].r_offset
< r
[i
+ 1].r_offset
)
1679 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1680 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ALIGN
))
1682 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1683 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ELIGN
)
1684 && !(ELF32_R_TYPE (r
[i
].r_info
) == R_RL78_RH_RELAX
1685 && (r
[i
].r_addend
& RL78_RELAXA_ALIGN
)))
1692 Elf_Internal_Rela tmp
;
1697 /* If we do move a reloc back, re-scan to see if it
1698 needs to be moved even further back. This avoids
1699 most of the O(n^2) behavior for our cases. */
1709 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1710 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1711 lrel, abfd, sec, link_info, scale)
1714 rl78_offset_for_reloc (bfd
* abfd
,
1715 Elf_Internal_Rela
* rel
,
1716 Elf_Internal_Shdr
* symtab_hdr
,
1717 Elf_External_Sym_Shndx
* shndx_buf ATTRIBUTE_UNUSED
,
1718 Elf_Internal_Sym
* intsyms
,
1719 Elf_Internal_Rela
** lrel
,
1721 asection
* input_section
,
1722 struct bfd_link_info
* info
,
1726 bfd_reloc_status_type r
;
1730 /* REL is the first of 1..N relocations. We compute the symbol
1731 value for each relocation, then combine them if needed. LREL
1732 gets a pointer to the last relocation used. */
1737 /* Get the value of the symbol referred to by the reloc. */
1738 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1740 /* A local symbol. */
1741 Elf_Internal_Sym
*isym
;
1744 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1746 if (isym
->st_shndx
== SHN_UNDEF
)
1747 ssec
= bfd_und_section_ptr
;
1748 else if (isym
->st_shndx
== SHN_ABS
)
1749 ssec
= bfd_abs_section_ptr
;
1750 else if (isym
->st_shndx
== SHN_COMMON
)
1751 ssec
= bfd_com_section_ptr
;
1753 ssec
= bfd_section_from_elf_index (abfd
,
1756 /* Initial symbol value. */
1757 symval
= isym
->st_value
;
1759 /* GAS may have made this symbol relative to a section, in
1760 which case, we have to add the addend to find the
1762 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
1763 symval
+= rel
->r_addend
;
1767 if ((ssec
->flags
& SEC_MERGE
)
1768 && ssec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1769 symval
= _bfd_merged_section_offset (abfd
, & ssec
,
1770 elf_section_data (ssec
)->sec_info
,
1774 /* Now make the offset relative to where the linker is putting it. */
1777 ssec
->output_section
->vma
+ ssec
->output_offset
;
1779 symval
+= rel
->r_addend
;
1784 struct elf_link_hash_entry
* h
;
1786 /* An external symbol. */
1787 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1788 h
= elf_sym_hashes (abfd
)[indx
];
1789 BFD_ASSERT (h
!= NULL
);
1791 if (h
->root
.type
!= bfd_link_hash_defined
1792 && h
->root
.type
!= bfd_link_hash_defweak
)
1794 /* This appears to be a reference to an undefined
1795 symbol. Just ignore it--it will be caught by the
1796 regular reloc processing. */
1802 symval
= (h
->root
.u
.def
.value
1803 + h
->root
.u
.def
.section
->output_section
->vma
1804 + h
->root
.u
.def
.section
->output_offset
);
1806 symval
+= rel
->r_addend
;
1809 switch (ELF32_R_TYPE (rel
->r_info
))
1812 RL78_STACK_PUSH (symval
);
1816 RL78_STACK_POP (tmp1
);
1818 RL78_STACK_PUSH (tmp1
);
1822 RL78_STACK_POP (tmp1
);
1823 RL78_STACK_POP (tmp2
);
1825 RL78_STACK_PUSH (tmp1
);
1829 RL78_STACK_POP (tmp1
);
1830 RL78_STACK_POP (tmp2
);
1832 RL78_STACK_PUSH (tmp2
);
1836 RL78_STACK_POP (tmp1
);
1837 RL78_STACK_POP (tmp2
);
1839 RL78_STACK_PUSH (tmp1
);
1843 RL78_STACK_POP (tmp1
);
1844 RL78_STACK_POP (tmp2
);
1846 RL78_STACK_PUSH (tmp1
);
1850 RL78_STACK_POP (tmp1
);
1851 RL78_STACK_POP (tmp2
);
1853 RL78_STACK_PUSH (tmp1
);
1857 RL78_STACK_POP (tmp1
);
1858 RL78_STACK_POP (tmp2
);
1860 RL78_STACK_PUSH (tmp1
);
1863 case R_RL78_OPsctsize
:
1864 RL78_STACK_PUSH (input_section
->size
);
1867 case R_RL78_OPscttop
:
1868 RL78_STACK_PUSH (input_section
->output_section
->vma
);
1872 RL78_STACK_POP (tmp1
);
1873 RL78_STACK_POP (tmp2
);
1875 RL78_STACK_PUSH (tmp1
);
1879 RL78_STACK_POP (tmp1
);
1880 RL78_STACK_POP (tmp2
);
1882 RL78_STACK_PUSH (tmp1
);
1886 RL78_STACK_POP (tmp1
);
1887 RL78_STACK_POP (tmp2
);
1889 RL78_STACK_PUSH (tmp1
);
1893 RL78_STACK_POP (tmp1
);
1895 RL78_STACK_PUSH (tmp1
);
1899 RL78_STACK_POP (tmp1
);
1900 RL78_STACK_POP (tmp2
);
1902 RL78_STACK_PUSH (tmp1
);
1905 case R_RL78_OPromtop
:
1906 RL78_STACK_PUSH (get_romstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
1909 case R_RL78_OPramtop
:
1910 RL78_STACK_PUSH (get_ramstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
1913 case R_RL78_DIR16UL
:
1915 case R_RL78_ABS16UL
:
1918 RL78_STACK_POP (symval
);
1924 case R_RL78_DIR16UW
:
1926 case R_RL78_ABS16UW
:
1929 RL78_STACK_POP (symval
);
1937 RL78_STACK_POP (symval
);
1948 int prefix
; /* or -1 for "no prefix" */
1949 int insn
; /* or -1 for "end of list" */
1950 int insn_for_saddr
; /* or -1 for "no alternative" */
1951 int insn_for_sfr
; /* or -1 for "no alternative" */
1952 } relax_addr16
[] = {
1953 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1954 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1955 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1956 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1958 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1959 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1960 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1961 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1962 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1963 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1964 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1965 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1967 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1968 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1969 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1970 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1971 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1973 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1974 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1975 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1976 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1978 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1979 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1980 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1982 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1983 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1984 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1985 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1986 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1987 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1989 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1991 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1992 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1993 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1994 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1995 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1996 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1997 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1998 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
2000 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
2001 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
2002 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
2003 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
2004 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
2005 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
2006 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
2007 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
2012 /* Relax one section. */
2015 rl78_elf_relax_section
2018 struct bfd_link_info
* link_info
,
2019 bfd_boolean
* again
)
2021 Elf_Internal_Shdr
* symtab_hdr
;
2022 Elf_Internal_Shdr
* shndx_hdr
;
2023 Elf_Internal_Rela
* internal_relocs
;
2024 Elf_Internal_Rela
* free_relocs
= NULL
;
2025 Elf_Internal_Rela
* irel
;
2026 Elf_Internal_Rela
* srel
;
2027 Elf_Internal_Rela
* irelend
;
2028 Elf_Internal_Rela
* next_alignment
;
2029 bfd_byte
* contents
= NULL
;
2030 bfd_byte
* free_contents
= NULL
;
2031 Elf_Internal_Sym
* intsyms
= NULL
;
2032 Elf_Internal_Sym
* free_intsyms
= NULL
;
2033 Elf_External_Sym_Shndx
* shndx_buf
= NULL
;
2035 bfd_vma symval ATTRIBUTE_UNUSED
= 0;
2036 int pcrel ATTRIBUTE_UNUSED
= 0;
2037 int code ATTRIBUTE_UNUSED
= 0;
2038 int section_alignment_glue
;
2041 if (abfd
== elf_hash_table (link_info
)->dynobj
2042 && strcmp (sec
->name
, ".plt") == 0)
2043 return rl78_elf_relax_plt_section (abfd
, sec
, link_info
, again
);
2045 /* Assume nothing changes. */
2048 /* We don't have to do anything for a relocatable link, if
2049 this section does not have relocs, or if this is not a
2051 if (link_info
->relocatable
2052 || (sec
->flags
& SEC_RELOC
) == 0
2053 || sec
->reloc_count
== 0
2054 || (sec
->flags
& SEC_CODE
) == 0)
2057 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2058 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2060 /* Get the section contents. */
2061 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2062 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2063 /* Go get them off disk. */
2066 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2068 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2071 /* Read this BFD's symbols. */
2072 /* Get cached copy if it exists. */
2073 if (symtab_hdr
->contents
!= NULL
)
2074 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2077 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
2078 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
2081 if (shndx_hdr
->sh_size
!= 0)
2085 amt
= symtab_hdr
->sh_info
;
2086 amt
*= sizeof (Elf_External_Sym_Shndx
);
2087 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
2088 if (shndx_buf
== NULL
)
2090 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
2091 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
2093 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
2096 /* Get a copy of the native relocations. */
2097 internal_relocs
= (_bfd_elf_link_read_relocs
2098 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2099 link_info
->keep_memory
));
2100 if (internal_relocs
== NULL
)
2102 if (! link_info
->keep_memory
)
2103 free_relocs
= internal_relocs
;
2105 /* The RL_ relocs must be just before the operand relocs they go
2106 with, so we must sort them to guarantee this. We use bubblesort
2107 instead of qsort so we can guarantee that relocs with the same
2108 address remain in the same relative order. */
2109 reloc_bubblesort (internal_relocs
, sec
->reloc_count
);
2111 /* Walk through them looking for relaxing opportunities. */
2112 irelend
= internal_relocs
+ sec
->reloc_count
;
2115 /* This will either be NULL or a pointer to the next alignment
2117 next_alignment
= internal_relocs
;
2119 /* We calculate worst case shrinkage caused by alignment directives.
2120 No fool-proof, but better than either ignoring the problem or
2121 doing heavy duty analysis of all the alignment markers in all
2123 section_alignment_glue
= 0;
2124 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2125 if (ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
2126 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
2128 int this_glue
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2130 if (section_alignment_glue
< this_glue
)
2131 section_alignment_glue
= this_glue
;
2133 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2135 section_alignment_glue
*= 2;
2137 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2139 unsigned char *insn
;
2142 /* The insns we care about are all marked with one of these. */
2143 if (ELF32_R_TYPE (irel
->r_info
) != R_RL78_RH_RELAX
)
2146 if (irel
->r_addend
& RL78_RELAXA_ALIGN
2147 || next_alignment
== internal_relocs
)
2149 /* When we delete bytes, we need to maintain all the alignments
2150 indicated. In addition, we need to be careful about relaxing
2151 jumps across alignment boundaries - these displacements
2152 *grow* when we delete bytes. For now, don't shrink
2153 displacements across an alignment boundary, just in case.
2154 Note that this only affects relocations to the same
2156 next_alignment
+= 2;
2157 while (next_alignment
< irelend
2158 && (ELF32_R_TYPE (next_alignment
->r_info
) != R_RL78_RH_RELAX
2159 || !(next_alignment
->r_addend
& RL78_RELAXA_ELIGN
)))
2161 if (next_alignment
>= irelend
|| next_alignment
->r_offset
== 0)
2162 next_alignment
= NULL
;
2165 /* When we hit alignment markers, see if we've shrunk enough
2166 before them to reduce the gap without violating the alignment
2168 if (irel
->r_addend
& RL78_RELAXA_ALIGN
)
2170 /* At this point, the next relocation *should* be the ELIGN
2172 Elf_Internal_Rela
*erel
= irel
+ 1;
2173 unsigned int alignment
, nbytes
;
2175 if (ELF32_R_TYPE (erel
->r_info
) != R_RL78_RH_RELAX
)
2177 if (!(erel
->r_addend
& RL78_RELAXA_ELIGN
))
2180 alignment
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2182 if (erel
->r_offset
- irel
->r_offset
< alignment
)
2185 nbytes
= erel
->r_offset
- irel
->r_offset
;
2186 nbytes
/= alignment
;
2187 nbytes
*= alignment
;
2189 elf32_rl78_relax_delete_bytes (abfd
, sec
, erel
->r_offset
-nbytes
, nbytes
, next_alignment
,
2190 erel
->r_offset
== sec
->size
);
2196 if (irel
->r_addend
& RL78_RELAXA_ELIGN
)
2199 insn
= contents
+ irel
->r_offset
;
2201 nrelocs
= irel
->r_addend
& RL78_RELAXA_RNUM
;
2203 /* At this point, we have an insn that is a candidate for linker
2204 relaxation. There are NRELOCS relocs following that may be
2205 relaxed, although each reloc may be made of more than one
2206 reloc entry (such as gp-rel symbols). */
2208 /* Get the value of the symbol referred to by the reloc. Just
2209 in case this is the last reloc in the list, use the RL's
2210 addend to choose between this reloc (no addend) or the next
2211 (yes addend, which means at least one following reloc). */
2213 /* srel points to the "current" reloction for this insn -
2214 actually the last reloc for a given operand, which is the one
2215 we need to update. We check the relaxations in the same
2216 order that the relocations happen, so we'll just push it
2220 pc
= sec
->output_section
->vma
+ sec
->output_offset
2224 BFD_ASSERT (nrelocs > 0); \
2225 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2226 pcrel = symval - pc + srel->r_addend; \
2229 #define SNIPNR(offset, nbytes) \
2230 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2231 #define SNIP(offset, nbytes, newtype) \
2232 SNIPNR (offset, nbytes); \
2233 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2235 /* The order of these bit tests must match the order that the
2236 relocs appear in. Since we sorted those by offset, we can
2239 /*----------------------------------------------------------------------*/
2240 /* EF ad BR $rel8 pcrel
2241 ED al ah BR !abs16 abs
2242 EE al ah BR $!rel16 pcrel
2243 EC al ah as BR !!abs20 abs
2245 FD al ah CALL !abs16 abs
2246 FE al ah CALL $!rel16 pcrel
2247 FC al ah as CALL !!abs20 abs
2255 61 C8 EF ad SKC ; BR $rel8
2256 61 D8 EF ad SKNC ; BR $rel8
2257 61 E8 EF ad SKZ ; BR $rel8
2258 61 F8 EF ad SKNZ ; BR $rel8
2259 61 E3 EF ad SKH ; BR $rel8
2260 61 F3 EF ad SKNH ; BR $rel8
2263 if (irel
->r_addend
& RL78_RELAXA_BRA
)
2265 /* SKIP opcodes that skip non-branches will have a relax tag
2266 but no corresponding symbol to relax against; we just
2268 if (irel
->r_addend
& RL78_RELAXA_RNUM
)
2275 case 0xec: /* BR !!abs20 */
2282 SNIP (2, 2, R_RL78_DIR8S_PCREL
);
2285 else if (symval
< 65536)
2288 insn
[1] = symval
& 0xff;
2289 insn
[2] = symval
>> 8;
2290 SNIP (2, 1, R_RL78_DIR16S
);
2293 else if (pcrel
< 32767
2297 insn
[1] = pcrel
& 0xff;
2298 insn
[2] = pcrel
>> 8;
2299 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2304 case 0xee: /* BR $!pcrel16 */
2305 case 0xed: /* BR $!abs16 */
2311 SNIP (2, 1, R_RL78_DIR8S_PCREL
);
2316 case 0xfc: /* CALL !!abs20 */
2320 insn
[1] = symval
& 0xff;
2321 insn
[2] = symval
>> 8;
2322 SNIP (2, 1, R_RL78_DIR16S
);
2325 else if (pcrel
< 32767
2329 insn
[1] = pcrel
& 0xff;
2330 insn
[2] = pcrel
>> 8;
2331 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2336 case 0x61: /* PREFIX */
2337 /* For SKIP/BR, we change the BR opcode and delete the
2338 SKIP. That way, we don't have to find and change the
2339 relocation for the BR. */
2340 /* Note that, for the case where we're skipping some
2341 other insn, we have no "other" reloc but that's safe
2345 case 0xc8: /* SKC */
2346 if (insn
[2] == 0xef)
2348 insn
[2] = 0xde; /* BNC */
2353 case 0xd8: /* SKNC */
2354 if (insn
[2] == 0xef)
2356 insn
[2] = 0xdc; /* BC */
2361 case 0xe8: /* SKZ */
2362 if (insn
[2] == 0xef)
2364 insn
[2] = 0xdf; /* BNZ */
2369 case 0xf8: /* SKNZ */
2370 if (insn
[2] == 0xef)
2372 insn
[2] = 0xdd; /* BZ */
2377 case 0xe3: /* SKH */
2378 if (insn
[2] == 0xef)
2380 insn
[2] = 0xd3; /* BNH */
2381 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2385 case 0xf3: /* SKNH */
2386 if (insn
[2] == 0xef)
2388 insn
[2] = 0xc3; /* BH */
2389 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2398 if (irel
->r_addend
& RL78_RELAXA_ADDR16
)
2400 /*----------------------------------------------------------------------*/
2401 /* Some insns have both a 16-bit address operand and an 8-bit
2402 variant if the address is within a special range:
2404 Address 16-bit operand SADDR range SFR range
2405 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2406 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2408 The RELAX_ADDR16[] array has the insn encodings for the
2409 16-bit operand version, as well as the SFR and SADDR
2410 variants. We only need to replace the encodings and
2413 Note: we intentionally do not attempt to decode and skip
2414 any ES: prefix, as adding ES: means the addr16 (likely)
2415 no longer points to saddr/sfr space.
2425 if (0xffe20 <= symval
&& symval
<= 0xfffff)
2428 is_saddr
= (0xffe20 <= symval
&& symval
<= 0xfff1f);
2429 is_sfr
= (0xfff00 <= symval
&& symval
<= 0xfffff);
2431 for (idx
= 0; relax_addr16
[idx
].insn
!= -1; idx
++)
2433 if (relax_addr16
[idx
].prefix
!= -1
2434 && insn
[0] == relax_addr16
[idx
].prefix
2435 && insn
[1] == relax_addr16
[idx
].insn
)
2439 else if (relax_addr16
[idx
].prefix
== -1
2440 && insn
[0] == relax_addr16
[idx
].insn
)
2447 /* We have a matched insn, and poff is 0 or 1 depending
2448 on the base pattern size. */
2450 if (is_sfr
&& relax_addr16
[idx
].insn_for_sfr
!= -1)
2452 insn
[poff
] = relax_addr16
[idx
].insn_for_sfr
;
2453 SNIP (poff
+2, 1, R_RL78_RH_SFR
);
2456 else if (is_saddr
&& relax_addr16
[idx
].insn_for_saddr
!= -1)
2458 insn
[poff
] = relax_addr16
[idx
].insn_for_saddr
;
2459 SNIP (poff
+2, 1, R_RL78_RH_SADDR
);
2466 /*----------------------------------------------------------------------*/
2473 if (free_relocs
!= NULL
)
2476 if (free_contents
!= NULL
)
2477 free (free_contents
);
2479 if (shndx_buf
!= NULL
)
2481 shndx_hdr
->contents
= NULL
;
2485 if (free_intsyms
!= NULL
)
2486 free (free_intsyms
);
2493 #define ELF_ARCH bfd_arch_rl78
2494 #define ELF_MACHINE_CODE EM_RL78
2495 #define ELF_MAXPAGESIZE 0x1000
2497 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2498 #define TARGET_LITTLE_NAME "elf32-rl78"
2500 #define elf_info_to_howto_rel NULL
2501 #define elf_info_to_howto rl78_info_to_howto_rela
2502 #define elf_backend_object_p rl78_elf_object_p
2503 #define elf_backend_relocate_section rl78_elf_relocate_section
2504 #define elf_symbol_leading_char ('_')
2505 #define elf_backend_can_gc_sections 1
2507 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2508 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2509 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2510 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2511 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2513 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2514 #define elf_backend_check_relocs rl78_elf_check_relocs
2515 #define elf_backend_always_size_sections \
2516 rl78_elf_always_size_sections
2517 #define elf_backend_finish_dynamic_sections \
2518 rl78_elf_finish_dynamic_sections
2520 #include "elf32-target.h"