1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2021 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., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
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 static bfd_reloc_status_type
rl78_special_reloc (bfd
*, arelent
*, asymbol
*, void *,
35 asection
*, bfd
*, char **);
37 /* FIXME: We could omit the SHIFT parameter, it is always zero. */
38 #define RL78_OP_REL(n,sz,bit,shift,complain,pcrel) \
39 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
40 rl78_special_reloc, "R_RL78_" #n, false, 0, ~0, false)
42 /* Note that the relocations around 0x7f are internal to this file;
43 feel free to move them as needed to avoid conflicts with published
44 relocation numbers. */
46 static reloc_howto_type rl78_elf_howto_table
[] =
48 RL78REL (NONE
, 3, 0, 0, dont
, false),
49 RL78REL (DIR32
, 2, 32, 0, signed, false),
50 RL78REL (DIR24S
, 2, 24, 0, signed, false),
51 RL78REL (DIR16
, 1, 16, 0, dont
, false),
52 RL78REL (DIR16U
, 1, 16, 0, unsigned, false),
53 RL78REL (DIR16S
, 1, 16, 0, signed, false),
54 RL78REL (DIR8
, 0, 8, 0, dont
, false),
55 RL78REL (DIR8U
, 0, 8, 0, unsigned, false),
56 RL78REL (DIR8S
, 0, 8, 0, signed, false),
57 RL78REL (DIR24S_PCREL
, 2, 24, 0, signed, true),
58 RL78REL (DIR16S_PCREL
, 1, 16, 0, signed, true),
59 RL78REL (DIR8S_PCREL
, 0, 8, 0, signed, true),
60 RL78REL (DIR16UL
, 1, 16, 2, unsigned, false),
61 RL78REL (DIR16UW
, 1, 16, 1, unsigned, false),
62 RL78REL (DIR8UL
, 0, 8, 2, unsigned, false),
63 RL78REL (DIR8UW
, 0, 8, 1, unsigned, false),
64 RL78REL (DIR32_REV
, 1, 16, 0, dont
, false),
65 RL78REL (DIR16_REV
, 1, 16, 0, dont
, false),
66 RL78REL (DIR3U_PCREL
, 0, 3, 0, dont
, true),
95 RL78REL (RH_RELAX
, 0, 0, 0, dont
, false),
98 RL78REL (RH_SADDR
, 0, 0, 0, dont
, false),
117 RL78_OP_REL (ABS32
, 2, 32, 0, dont
, false),
118 RL78_OP_REL (ABS24S
, 2, 24, 0, signed, false),
119 RL78_OP_REL (ABS16
, 1, 16, 0, dont
, false),
120 RL78_OP_REL (ABS16U
, 1, 16, 0, unsigned, false),
121 RL78_OP_REL (ABS16S
, 1, 16, 0, signed, false),
122 RL78_OP_REL (ABS8
, 0, 8, 0, dont
, false),
123 RL78_OP_REL (ABS8U
, 0, 8, 0, unsigned, false),
124 RL78_OP_REL (ABS8S
, 0, 8, 0, signed, false),
125 RL78_OP_REL (ABS24S_PCREL
, 2, 24, 0, signed, true),
126 RL78_OP_REL (ABS16S_PCREL
, 1, 16, 0, signed, true),
127 RL78_OP_REL (ABS8S_PCREL
, 0, 8, 0, signed, true),
128 RL78_OP_REL (ABS16UL
, 1, 16, 0, unsigned, false),
129 RL78_OP_REL (ABS16UW
, 1, 16, 0, unsigned, false),
130 RL78_OP_REL (ABS8UL
, 0, 8, 0, unsigned, false),
131 RL78_OP_REL (ABS8UW
, 0, 8, 0, unsigned, false),
132 RL78_OP_REL (ABS32_REV
, 2, 32, 0, dont
, false),
133 RL78_OP_REL (ABS16_REV
, 1, 16, 0, dont
, false),
135 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
185 RL78_OP_REL (SYM
, 2, 32, 0, dont
, false),
186 RL78_OP_REL (OPneg
, 2, 32, 0, dont
, false),
187 RL78_OP_REL (OPadd
, 2, 32, 0, dont
, false),
188 RL78_OP_REL (OPsub
, 2, 32, 0, dont
, false),
189 RL78_OP_REL (OPmul
, 2, 32, 0, dont
, false),
190 RL78_OP_REL (OPdiv
, 2, 32, 0, dont
, false),
191 RL78_OP_REL (OPshla
, 2, 32, 0, dont
, false),
192 RL78_OP_REL (OPshra
, 2, 32, 0, dont
, false),
193 RL78_OP_REL (OPsctsize
, 2, 32, 0, dont
, false),
198 RL78_OP_REL (OPscttop
, 2, 32, 0, dont
, false),
201 RL78_OP_REL (OPand
, 2, 32, 0, dont
, false),
202 RL78_OP_REL (OPor
, 2, 32, 0, dont
, false),
203 RL78_OP_REL (OPxor
, 2, 32, 0, dont
, false),
204 RL78_OP_REL (OPnot
, 2, 32, 0, dont
, false),
205 RL78_OP_REL (OPmod
, 2, 32, 0, dont
, false),
206 RL78_OP_REL (OPromtop
, 2, 32, 0, dont
, false),
207 RL78_OP_REL (OPramtop
, 2, 32, 0, dont
, false)
210 /* Map BFD reloc types to RL78 ELF reloc types. */
212 struct rl78_reloc_map
214 bfd_reloc_code_real_type bfd_reloc_val
;
215 unsigned int rl78_reloc_val
;
218 static const struct rl78_reloc_map rl78_reloc_map
[] =
220 { BFD_RELOC_NONE
, R_RL78_NONE
},
221 { BFD_RELOC_8
, R_RL78_DIR8S
},
222 { BFD_RELOC_16
, R_RL78_DIR16S
},
223 { BFD_RELOC_24
, R_RL78_DIR24S
},
224 { BFD_RELOC_32
, R_RL78_DIR32
},
225 { BFD_RELOC_RL78_16_OP
, R_RL78_DIR16
},
226 { BFD_RELOC_RL78_DIR3U_PCREL
, R_RL78_DIR3U_PCREL
},
227 { BFD_RELOC_8_PCREL
, R_RL78_DIR8S_PCREL
},
228 { BFD_RELOC_16_PCREL
, R_RL78_DIR16S_PCREL
},
229 { BFD_RELOC_24_PCREL
, R_RL78_DIR24S_PCREL
},
230 { BFD_RELOC_RL78_8U
, R_RL78_DIR8U
},
231 { BFD_RELOC_RL78_16U
, R_RL78_DIR16U
},
232 { BFD_RELOC_RL78_SYM
, R_RL78_SYM
},
233 { BFD_RELOC_RL78_OP_SUBTRACT
, R_RL78_OPsub
},
234 { BFD_RELOC_RL78_OP_NEG
, R_RL78_OPneg
},
235 { BFD_RELOC_RL78_OP_AND
, R_RL78_OPand
},
236 { BFD_RELOC_RL78_OP_SHRA
, R_RL78_OPshra
},
237 { BFD_RELOC_RL78_ABS8
, R_RL78_ABS8
},
238 { BFD_RELOC_RL78_ABS16
, R_RL78_ABS16
},
239 { BFD_RELOC_RL78_ABS16_REV
, R_RL78_ABS16_REV
},
240 { BFD_RELOC_RL78_ABS32
, R_RL78_ABS32
},
241 { BFD_RELOC_RL78_ABS32_REV
, R_RL78_ABS32_REV
},
242 { BFD_RELOC_RL78_ABS16UL
, R_RL78_ABS16UL
},
243 { BFD_RELOC_RL78_ABS16UW
, R_RL78_ABS16UW
},
244 { BFD_RELOC_RL78_ABS16U
, R_RL78_ABS16U
},
245 { BFD_RELOC_RL78_SADDR
, R_RL78_RH_SADDR
},
246 { BFD_RELOC_RL78_RELAX
, R_RL78_RH_RELAX
}
249 static reloc_howto_type
*
250 rl78_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
251 bfd_reloc_code_real_type code
)
255 if (code
== BFD_RELOC_RL78_32_OP
)
256 return rl78_elf_howto_table
+ R_RL78_DIR32
;
258 for (i
= ARRAY_SIZE (rl78_reloc_map
); i
--;)
259 if (rl78_reloc_map
[i
].bfd_reloc_val
== code
)
260 return rl78_elf_howto_table
+ rl78_reloc_map
[i
].rl78_reloc_val
;
265 static reloc_howto_type
*
266 rl78_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
, const char * r_name
)
270 for (i
= 0; i
< ARRAY_SIZE (rl78_elf_howto_table
); i
++)
271 if (rl78_elf_howto_table
[i
].name
!= NULL
272 && strcasecmp (rl78_elf_howto_table
[i
].name
, r_name
) == 0)
273 return rl78_elf_howto_table
+ i
;
278 /* Set the howto pointer for an RL78 ELF reloc. */
281 rl78_info_to_howto_rela (bfd
* abfd
,
283 Elf_Internal_Rela
* dst
)
287 r_type
= ELF32_R_TYPE (dst
->r_info
);
288 if (r_type
>= (unsigned int) R_RL78_max
)
290 /* xgettext:c-format */
291 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
293 bfd_set_error (bfd_error_bad_value
);
296 cache_ptr
->howto
= rl78_elf_howto_table
+ r_type
;
301 get_symbol_value (const char * name
,
302 struct bfd_link_info
* info
,
304 asection
* input_section
,
307 struct bfd_link_hash_entry
* h
;
312 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, true);
315 || (h
->type
!= bfd_link_hash_defined
316 && h
->type
!= bfd_link_hash_defweak
))
318 (*info
->callbacks
->undefined_symbol
)
319 (info
, name
, input_bfd
, input_section
, offset
, true);
323 return (h
->u
.def
.value
324 + h
->u
.def
.section
->output_section
->vma
325 + h
->u
.def
.section
->output_offset
);
329 get_romstart (struct bfd_link_info
* info
,
334 static bool cached
= false;
335 static bfd_vma cached_value
= 0;
339 cached_value
= get_symbol_value ("_start", info
, abfd
, sec
, offset
);
346 get_ramstart (struct bfd_link_info
* info
,
351 static bool cached
= false;
352 static bfd_vma cached_value
= 0;
356 cached_value
= get_symbol_value ("__datastart", info
, abfd
, sec
, offset
);
362 #define NUM_STACK_ENTRIES 16
363 static int32_t rl78_stack
[ NUM_STACK_ENTRIES
];
364 static unsigned int rl78_stack_top
;
366 #define RL78_STACK_PUSH(val) \
369 if (rl78_stack_top < NUM_STACK_ENTRIES) \
370 rl78_stack [rl78_stack_top ++] = (val); \
372 _bfd_error_handler (_("internal error: RL78 reloc stack overflow")); \
376 #define RL78_STACK_POP(dest) \
379 if (rl78_stack_top > 0) \
380 (dest) = rl78_stack [-- rl78_stack_top];\
383 _bfd_error_handler (_("internal error: RL78 reloc stack underflow")); \
389 /* Special handling for RL78 complex relocs. Returns the
390 value of the reloc, or 0 for relocs which do not generate
391 a result. SYMVAL is the value of the symbol for relocs
392 which use a symbolic argument. */
395 rl78_compute_complex_reloc (unsigned long r_type
,
397 asection
* input_section
)
407 case R_RL78_ABS24S_PCREL
:
408 case R_RL78_ABS16S_PCREL
:
409 case R_RL78_ABS8S_PCREL
:
410 RL78_STACK_POP (relocation
);
411 relocation
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
415 case R_RL78_ABS32_REV
:
417 case R_RL78_ABS16_REV
:
423 RL78_STACK_POP (relocation
);
428 RL78_STACK_POP (relocation
);
429 return relocation
>> 2;
433 RL78_STACK_POP (relocation
);
434 return relocation
>> 1;
436 /* The rest of the relocs compute values and then push them onto the stack. */
437 case R_RL78_OPramtop
:
438 case R_RL78_OPromtop
:
440 RL78_STACK_PUSH (symval
);
444 RL78_STACK_POP (tmp1
);
446 RL78_STACK_PUSH (tmp1
);
450 RL78_STACK_POP (tmp2
);
451 RL78_STACK_POP (tmp1
);
453 RL78_STACK_PUSH (tmp1
);
457 /* For the expression "A - B", the assembler pushes A,
458 then B, then OPSUB. So the first op we pop is B, not A. */
459 RL78_STACK_POP (tmp2
); /* B */
460 RL78_STACK_POP (tmp1
); /* A */
461 tmp1
-= tmp2
; /* A - B */
462 RL78_STACK_PUSH (tmp1
);
466 RL78_STACK_POP (tmp2
);
467 RL78_STACK_POP (tmp1
);
469 RL78_STACK_PUSH (tmp1
);
473 RL78_STACK_POP (tmp2
);
474 RL78_STACK_POP (tmp1
);
476 RL78_STACK_PUSH (tmp1
);
480 RL78_STACK_POP (tmp2
);
481 RL78_STACK_POP (tmp1
);
483 RL78_STACK_PUSH (tmp1
);
487 RL78_STACK_POP (tmp2
);
488 RL78_STACK_POP (tmp1
);
490 RL78_STACK_PUSH (tmp1
);
493 case R_RL78_OPsctsize
:
494 RL78_STACK_PUSH (input_section
->size
);
497 case R_RL78_OPscttop
:
498 RL78_STACK_PUSH (input_section
->output_section
->vma
);
502 RL78_STACK_POP (tmp2
);
503 RL78_STACK_POP (tmp1
);
505 RL78_STACK_PUSH (tmp1
);
509 RL78_STACK_POP (tmp2
);
510 RL78_STACK_POP (tmp1
);
512 RL78_STACK_PUSH (tmp1
);
516 RL78_STACK_POP (tmp2
);
517 RL78_STACK_POP (tmp1
);
519 RL78_STACK_PUSH (tmp1
);
523 RL78_STACK_POP (tmp1
);
525 RL78_STACK_PUSH (tmp1
);
529 RL78_STACK_POP (tmp2
);
530 RL78_STACK_POP (tmp1
);
532 RL78_STACK_PUSH (tmp1
);
537 #undef RL78_STACK_PUSH
538 #undef RL78_STACK_POP
540 #define OP(i) (contents[reloc->address + (i)])
542 static bfd_reloc_status_type
543 rl78_special_reloc (bfd
* input_bfd
,
547 asection
* input_section
,
548 bfd
* output_bfd ATTRIBUTE_UNUSED
,
549 char ** error_message ATTRIBUTE_UNUSED
)
551 bfd_reloc_status_type r
= bfd_reloc_ok
;
552 bfd_vma relocation
= 0;
553 unsigned long r_type
= reloc
->howto
->type
;
554 bfd_byte
* contents
= data
;
556 /* If necessary, compute the symbolic value of the relocation. */
560 relocation
= (symbol
->value
561 + symbol
->section
->output_section
->vma
562 + symbol
->section
->output_offset
566 case R_RL78_OPromtop
:
567 relocation
= get_romstart (NULL
, input_bfd
, input_section
,
571 case R_RL78_OPramtop
:
572 relocation
= get_ramstart (NULL
, input_bfd
, input_section
,
577 /* Get the value of the relocation. */
578 relocation
= rl78_compute_complex_reloc (r_type
, relocation
, input_section
);
580 /* If the relocation alters the contents of the section then apply it now.
581 Note - since this function is called from
582 bfd_generic_get_relocated_section_contents via bfd_perform_relocation,
583 and not from the linker, we do not perform any range checking. The
584 clients who are calling us are only interested in some relocated section
585 contents, and not any linkage problems that might occur later. */
590 OP (1) = relocation
>> 8;
591 OP (2) = relocation
>> 16;
592 OP (3) = relocation
>> 24;
595 case R_RL78_ABS32_REV
:
597 OP (2) = relocation
>> 8;
598 OP (1) = relocation
>> 16;
599 OP (0) = relocation
>> 24;
602 case R_RL78_ABS24S_PCREL
:
605 OP (1) = relocation
>> 8;
606 OP (2) = relocation
>> 16;
609 case R_RL78_ABS16_REV
:
611 OP (0) = relocation
>> 8;
614 case R_RL78_ABS16S_PCREL
:
621 OP (1) = relocation
>> 8;
624 case R_RL78_ABS8S_PCREL
:
641 #define OP(i) (contents[rel->r_offset + (i)])
643 /* Relocate an RL78 ELF section.
644 There is some attempt to make this function usable for many architectures,
645 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
646 if only to serve as a learning tool.
648 The RELOCATE_SECTION function is called by the new ELF backend linker
649 to handle the relocations for a section.
651 The relocs are always passed as Rela structures; if the section
652 actually uses Rel structures, the r_addend field will always be
655 This function is responsible for adjusting the section contents as
656 necessary, and (if using Rela relocs and generating a relocatable
657 output file) adjusting the reloc addend as necessary.
659 This function does not have to worry about setting the reloc
660 address or the reloc symbol index.
662 LOCAL_SYMS is a pointer to the swapped in local symbols.
664 LOCAL_SECTIONS is an array giving the section in the input file
665 corresponding to the st_shndx field of each local symbol.
667 The global hash table entry for the global symbols can be found
668 via elf_sym_hashes (input_bfd).
670 When generating relocatable output, this function must handle
671 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
672 going to be the section symbol corresponding to the output
673 section, which means that the addend must be adjusted
677 rl78_elf_relocate_section
679 struct bfd_link_info
* info
,
681 asection
* input_section
,
683 Elf_Internal_Rela
* relocs
,
684 Elf_Internal_Sym
* local_syms
,
685 asection
** local_sections
)
687 Elf_Internal_Shdr
* symtab_hdr
;
688 struct elf_link_hash_entry
** sym_hashes
;
689 Elf_Internal_Rela
* rel
;
690 Elf_Internal_Rela
* relend
;
693 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
694 sym_hashes
= elf_sym_hashes (input_bfd
);
695 relend
= relocs
+ input_section
->reloc_count
;
697 splt
= elf_hash_table (info
)->splt
;
699 for (rel
= relocs
; rel
< relend
; rel
++)
701 reloc_howto_type
*howto
;
702 unsigned long r_symndx
;
703 Elf_Internal_Sym
*sym
;
705 struct elf_link_hash_entry
*h
;
707 bfd_reloc_status_type r
;
708 const char *name
= NULL
;
709 bool unresolved_reloc
= true;
712 r_type
= ELF32_R_TYPE (rel
->r_info
);
713 r_symndx
= ELF32_R_SYM (rel
->r_info
);
715 howto
= rl78_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
721 if (r_symndx
< symtab_hdr
->sh_info
)
723 sym
= local_syms
+ r_symndx
;
724 sec
= local_sections
[r_symndx
];
725 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
727 name
= bfd_elf_string_from_elf_section
728 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
729 name
= sym
->st_name
== 0 ? bfd_section_name (sec
) : name
;
733 bool warned ATTRIBUTE_UNUSED
;
734 bool ignored ATTRIBUTE_UNUSED
;
736 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
737 r_symndx
, symtab_hdr
, sym_hashes
, h
,
738 sec
, relocation
, unresolved_reloc
,
741 name
= h
->root
.root
.string
;
744 if (sec
!= NULL
&& discarded_section (sec
))
745 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
746 rel
, 1, relend
, howto
, 0, contents
);
748 if (bfd_link_relocatable (info
))
750 /* This is a relocatable link. We don't have to change
751 anything, unless the reloc is against a section symbol,
752 in which case we have to adjust according to where the
753 section symbol winds up in the output section. */
754 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
755 rel
->r_addend
+= sec
->output_offset
;
759 switch (ELF32_R_TYPE (rel
->r_info
))
766 plt_offset
= &h
->plt
.offset
;
768 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
770 if (! valid_16bit_address (relocation
))
772 /* If this is the first time we've processed this symbol,
773 fill in the plt entry with the correct symbol address. */
774 if ((*plt_offset
& 1) == 0)
778 x
= 0x000000ec; /* br !!abs24 */
779 x
|= (relocation
<< 8) & 0xffffff00;
780 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
784 relocation
= (splt
->output_section
->vma
785 + splt
->output_offset
786 + (*plt_offset
& -2));
789 char *newname
= bfd_malloc (strlen(name
)+5);
790 strcpy (newname
, name
);
791 strcat(newname
, ".plt");
792 _bfd_generic_link_add_one_symbol (info
,
795 BSF_FUNCTION
| BSF_WEAK
,
808 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
809 /* If the symbol is undefined and weak
810 then the relocation resolves to zero. */
814 if (howto
->pc_relative
)
816 relocation
-= (input_section
->output_section
->vma
817 + input_section
->output_offset
819 relocation
-= bfd_get_reloc_size (howto
);
822 relocation
+= rel
->r_addend
;
827 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
829 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
835 case R_RL78_RH_RELAX
:
838 case R_RL78_DIR8S_PCREL
:
853 case R_RL78_DIR16S_PCREL
:
854 RANGE (-32768, 32767);
856 OP (1) = relocation
>> 8;
860 if ((relocation
& 0xf0000) == 0xf0000)
861 relocation
&= 0xffff;
862 RANGE (-32768, 65535);
864 OP (1) = relocation
>> 8;
870 OP (1) = relocation
>> 8;
874 RANGE (-32768, 65536);
876 OP (1) = relocation
>> 8;
879 case R_RL78_DIR16_REV
:
880 RANGE (-32768, 65536);
882 OP (0) = relocation
>> 8;
885 case R_RL78_DIR3U_PCREL
:
888 OP (0) |= relocation
& 0x07;
891 case R_RL78_DIR24S_PCREL
:
892 RANGE (-0x800000, 0x7fffff);
894 OP (1) = relocation
>> 8;
895 OP (2) = relocation
>> 16;
899 RANGE (-0x800000, 0x7fffff);
901 OP (1) = relocation
>> 8;
902 OP (2) = relocation
>> 16;
907 OP (1) = relocation
>> 8;
908 OP (2) = relocation
>> 16;
909 OP (3) = relocation
>> 24;
912 case R_RL78_DIR32_REV
:
914 OP (2) = relocation
>> 8;
915 OP (1) = relocation
>> 16;
916 OP (0) = relocation
>> 24;
920 RANGE (0xfff00, 0xfffff);
921 OP (0) = relocation
& 0xff;
924 case R_RL78_RH_SADDR
:
925 RANGE (0xffe20, 0xfff1f);
926 OP (0) = (relocation
- 0x20) & 0xff;
929 /* Complex reloc handling: */
931 case R_RL78_ABS32_REV
:
932 case R_RL78_ABS24S_PCREL
:
935 case R_RL78_ABS16_REV
:
936 case R_RL78_ABS16S_PCREL
:
945 case R_RL78_ABS8S_PCREL
:
954 case R_RL78_OPsctsize
:
955 case R_RL78_OPscttop
:
961 relocation
= rl78_compute_complex_reloc (r_type
, 0, input_section
);
967 OP (1) = relocation
>> 8;
968 OP (2) = relocation
>> 16;
969 OP (3) = relocation
>> 24;
972 case R_RL78_ABS32_REV
:
974 OP (2) = relocation
>> 8;
975 OP (1) = relocation
>> 16;
976 OP (0) = relocation
>> 24;
979 case R_RL78_ABS24S_PCREL
:
981 RANGE (-0x800000, 0x7fffff);
983 OP (1) = relocation
>> 8;
984 OP (2) = relocation
>> 16;
988 RANGE (-32768, 65535);
990 OP (1) = relocation
>> 8;
993 case R_RL78_ABS16_REV
:
994 RANGE (-32768, 65535);
996 OP (0) = relocation
>> 8;
999 case R_RL78_ABS16S_PCREL
:
1001 RANGE (-32768, 32767);
1002 OP (0) = relocation
;
1003 OP (1) = relocation
>> 8;
1007 case R_RL78_ABS16UL
:
1008 case R_RL78_ABS16UW
:
1010 OP (0) = relocation
;
1011 OP (1) = relocation
>> 8;
1016 OP (0) = relocation
;
1023 OP (0) = relocation
;
1026 case R_RL78_ABS8S_PCREL
:
1029 OP (0) = relocation
;
1038 if (r_symndx
< symtab_hdr
->sh_info
)
1039 relocation
= sec
->output_section
->vma
+ sec
->output_offset
1040 + sym
->st_value
+ rel
->r_addend
;
1042 && (h
->root
.type
== bfd_link_hash_defined
1043 || h
->root
.type
== bfd_link_hash_defweak
))
1044 relocation
= h
->root
.u
.def
.value
1045 + sec
->output_section
->vma
1046 + sec
->output_offset
1051 if (h
->root
.type
!= bfd_link_hash_undefweak
)
1053 (_("warning: RL78_SYM reloc with an unknown symbol"));
1055 (void) rl78_compute_complex_reloc (r_type
, relocation
, input_section
);
1058 case R_RL78_OPromtop
:
1059 relocation
= get_romstart (info
, input_bfd
, input_section
, rel
->r_offset
);
1060 (void) rl78_compute_complex_reloc (r_type
, relocation
, input_section
);
1063 case R_RL78_OPramtop
:
1064 relocation
= get_ramstart (info
, input_bfd
, input_section
, rel
->r_offset
);
1065 (void) rl78_compute_complex_reloc (r_type
, relocation
, input_section
);
1069 r
= bfd_reloc_notsupported
;
1073 if (r
!= bfd_reloc_ok
)
1075 const char * msg
= NULL
;
1079 case bfd_reloc_overflow
:
1080 /* Catch the case of a missing function declaration
1081 and emit a more helpful error message. */
1082 if (r_type
== R_RL78_DIR24S_PCREL
)
1083 /* xgettext:c-format */
1084 msg
= _("%pB(%pA): error: call to undefined function '%s'");
1086 (*info
->callbacks
->reloc_overflow
)
1087 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
1088 input_bfd
, input_section
, rel
->r_offset
);
1091 case bfd_reloc_undefined
:
1092 (*info
->callbacks
->undefined_symbol
)
1093 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, true);
1096 case bfd_reloc_other
:
1097 /* xgettext:c-format */
1098 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1101 case bfd_reloc_outofrange
:
1102 /* xgettext:c-format */
1103 msg
= _("%pB(%pA): internal error: out of range error");
1106 case bfd_reloc_notsupported
:
1107 /* xgettext:c-format */
1108 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1111 case bfd_reloc_dangerous
:
1112 /* xgettext:c-format */
1113 msg
= _("%pB(%pA): internal error: dangerous relocation");
1117 /* xgettext:c-format */
1118 msg
= _("%pB(%pA): internal error: unknown error");
1123 _bfd_error_handler (msg
, input_bfd
, input_section
, name
);
1130 /* Function to set the ELF flag bits. */
1133 rl78_elf_set_private_flags (bfd
* abfd
, flagword flags
)
1135 elf_elfheader (abfd
)->e_flags
= flags
;
1136 elf_flags_init (abfd
) = true;
1140 static bool no_warn_mismatch
= false;
1142 void bfd_elf32_rl78_set_target_flags (bool);
1145 bfd_elf32_rl78_set_target_flags (bool user_no_warn_mismatch
)
1147 no_warn_mismatch
= user_no_warn_mismatch
;
1151 rl78_cpu_name (flagword flags
)
1153 switch (flags
& E_FLAG_RL78_CPU_MASK
)
1156 case E_FLAG_RL78_G10
: return "G10";
1157 case E_FLAG_RL78_G13
: return "G13";
1158 case E_FLAG_RL78_G14
: return "G14";
1162 /* Merge backend specific data from an object file to the output
1163 object file when linking. */
1166 rl78_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
1168 bfd
*obfd
= info
->output_bfd
;
1173 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1174 old_flags
= elf_elfheader (obfd
)->e_flags
;
1176 if (!elf_flags_init (obfd
))
1178 /* First call, no flags set. */
1179 elf_flags_init (obfd
) = true;
1180 elf_elfheader (obfd
)->e_flags
= new_flags
;
1182 else if (old_flags
!= new_flags
)
1184 flagword changed_flags
= old_flags
^ new_flags
;
1186 if (changed_flags
& E_FLAG_RL78_CPU_MASK
)
1188 flagword out_cpu
= old_flags
& E_FLAG_RL78_CPU_MASK
;
1189 flagword in_cpu
= new_flags
& E_FLAG_RL78_CPU_MASK
;
1191 if (in_cpu
== E_FLAG_RL78_ANY_CPU
|| in_cpu
== out_cpu
)
1192 /* It does not matter what new_cpu may have. */;
1193 else if (out_cpu
== E_FLAG_RL78_ANY_CPU
)
1195 if (in_cpu
== E_FLAG_RL78_G10
)
1197 /* G10 files can only be linked with other G10 files.
1198 If the output is set to "any" this means that it is
1199 a G14 file that does not use hardware multiply/divide,
1200 but that is still incompatible with the G10 ABI. */
1204 /* xgettext:c-format */
1205 (_("RL78 ABI conflict: G10 file %pB cannot be linked"
1206 " with %s file %pB"),
1207 ibfd
, rl78_cpu_name (out_cpu
), obfd
);
1211 old_flags
&= ~ E_FLAG_RL78_CPU_MASK
;
1212 old_flags
|= in_cpu
;
1213 elf_elfheader (obfd
)->e_flags
= old_flags
;
1221 /* xgettext:c-format */
1222 (_("RL78 ABI conflict: cannot link %s file %pB with %s file %pB"),
1223 rl78_cpu_name (in_cpu
), ibfd
,
1224 rl78_cpu_name (out_cpu
), obfd
);
1228 if (changed_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
1231 (_("RL78 merge conflict: cannot link 32-bit and 64-bit objects together"));
1233 if (old_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
1234 /* xgettext:c-format */
1235 _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
1238 /* xgettext:c-format */
1239 _bfd_error_handler (_("- %pB is 64-bit, %pB is not"),
1249 rl78_elf_print_private_bfd_data (bfd
* abfd
, void * ptr
)
1251 FILE * file
= (FILE *) ptr
;
1254 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
1256 /* Print normal ELF private data. */
1257 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
1259 flags
= elf_elfheader (abfd
)->e_flags
;
1260 fprintf (file
, _("private flags = 0x%lx:"), (long) flags
);
1262 if (flags
& E_FLAG_RL78_CPU_MASK
)
1263 fprintf (file
, " [%s]", rl78_cpu_name (flags
));
1265 if (flags
& E_FLAG_RL78_64BIT_DOUBLES
)
1266 fprintf (file
, _(" [64-bit doubles]"));
1272 /* Return the MACH for an e_flags value. */
1275 elf32_rl78_machine (bfd
* abfd ATTRIBUTE_UNUSED
)
1277 return bfd_mach_rl78
;
1281 rl78_elf_object_p (bfd
* abfd
)
1283 bfd_default_set_arch_mach (abfd
, bfd_arch_rl78
,
1284 elf32_rl78_machine (abfd
));
1288 /* support PLT for 16-bit references to 24-bit functions. */
1290 /* We support 16-bit pointers to code above 64k by generating a thunk
1291 below 64k containing a JMP instruction to the final address. */
1294 rl78_elf_check_relocs
1296 struct bfd_link_info
* info
,
1298 const Elf_Internal_Rela
* relocs
)
1300 Elf_Internal_Shdr
* symtab_hdr
;
1301 struct elf_link_hash_entry
** sym_hashes
;
1302 const Elf_Internal_Rela
* rel
;
1303 const Elf_Internal_Rela
* rel_end
;
1304 bfd_vma
*local_plt_offsets
;
1308 if (bfd_link_relocatable (info
))
1311 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1312 sym_hashes
= elf_sym_hashes (abfd
);
1313 local_plt_offsets
= elf_local_got_offsets (abfd
);
1314 dynobj
= elf_hash_table(info
)->dynobj
;
1316 rel_end
= relocs
+ sec
->reloc_count
;
1317 for (rel
= relocs
; rel
< rel_end
; rel
++)
1319 struct elf_link_hash_entry
*h
;
1320 unsigned long r_symndx
;
1323 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1324 if (r_symndx
< symtab_hdr
->sh_info
)
1328 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1329 while (h
->root
.type
== bfd_link_hash_indirect
1330 || h
->root
.type
== bfd_link_hash_warning
)
1331 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1334 switch (ELF32_R_TYPE (rel
->r_info
))
1336 /* This relocation describes a 16-bit pointer to a function.
1337 We may need to allocate a thunk in low memory; reserve memory
1341 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1342 splt
= elf_hash_table (info
)->splt
;
1345 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1346 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
1347 | SEC_READONLY
| SEC_CODE
);
1348 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
1350 elf_hash_table (info
)->splt
= splt
;
1352 || !bfd_set_section_alignment (splt
, 1))
1357 offset
= &h
->plt
.offset
;
1360 if (local_plt_offsets
== NULL
)
1365 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
1366 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
1367 if (local_plt_offsets
== NULL
)
1369 elf_local_got_offsets (abfd
) = local_plt_offsets
;
1371 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
1372 local_plt_offsets
[i
] = (bfd_vma
) -1;
1374 offset
= &local_plt_offsets
[r_symndx
];
1377 if (*offset
== (bfd_vma
) -1)
1379 *offset
= splt
->size
;
1389 /* This must exist if dynobj is ever set. */
1392 rl78_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
1393 struct bfd_link_info
*info
)
1398 if (!elf_hash_table (info
)->dynamic_sections_created
)
1401 /* As an extra sanity check, verify that all plt entries have been
1402 filled in. However, relaxing might have changed the relocs so
1403 that some plt entries don't get filled in, so we have to skip
1404 this check if we're relaxing. Unfortunately, check_relocs is
1405 called before relaxation. */
1407 if (info
->relax_trip
> 0)
1410 dynobj
= elf_hash_table (info
)->dynobj
;
1411 splt
= elf_hash_table (info
)->splt
;
1412 if (dynobj
!= NULL
&& splt
!= NULL
)
1414 bfd_byte
*contents
= splt
->contents
;
1415 unsigned int i
, size
= splt
->size
;
1417 for (i
= 0; i
< size
; i
+= 4)
1419 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
1420 BFD_ASSERT (x
!= 0);
1428 rl78_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1429 struct bfd_link_info
*info
)
1434 if (bfd_link_relocatable (info
))
1437 dynobj
= elf_hash_table (info
)->dynobj
;
1441 splt
= elf_hash_table (info
)->splt
;
1442 BFD_ASSERT (splt
!= NULL
);
1444 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
1445 if (splt
->contents
== NULL
)
1453 /* Handle relaxing. */
1455 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1456 is within the low 64k, remove any entry for it in the plt. */
1458 struct relax_plt_data
1465 rl78_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1467 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1469 if (h
->plt
.offset
!= (bfd_vma
) -1)
1473 if (h
->root
.type
== bfd_link_hash_undefined
1474 || h
->root
.type
== bfd_link_hash_undefweak
)
1477 address
= (h
->root
.u
.def
.section
->output_section
->vma
1478 + h
->root
.u
.def
.section
->output_offset
1479 + h
->root
.u
.def
.value
);
1481 if (valid_16bit_address (address
))
1484 data
->splt
->size
-= 4;
1485 *data
->again
= true;
1492 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1493 previously had a plt entry, give it a new entry offset. */
1496 rl78_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1498 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1500 if (h
->plt
.offset
!= (bfd_vma
) -1)
1502 h
->plt
.offset
= *entry
;
1510 rl78_elf_relax_plt_section (bfd
*dynobj
,
1512 struct bfd_link_info
*info
,
1515 struct relax_plt_data relax_plt_data
;
1518 /* Assume nothing changes. */
1521 if (bfd_link_relocatable (info
))
1524 /* We only relax the .plt section at the moment. */
1525 if (dynobj
!= elf_hash_table (info
)->dynobj
1526 || strcmp (splt
->name
, ".plt") != 0)
1529 /* Quick check for an empty plt. */
1530 if (splt
->size
== 0)
1533 /* Map across all global symbols; see which ones happen to
1534 fall in the low 64k. */
1535 relax_plt_data
.splt
= splt
;
1536 relax_plt_data
.again
= again
;
1537 elf_link_hash_traverse (elf_hash_table (info
), rl78_relax_plt_check
,
1540 /* Likewise for local symbols, though that's somewhat less convenient
1541 as we have to walk the list of input bfds and swap in symbol data. */
1542 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1544 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1545 Elf_Internal_Shdr
*symtab_hdr
;
1546 Elf_Internal_Sym
*isymbuf
= NULL
;
1549 if (! local_plt_offsets
)
1552 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1553 if (symtab_hdr
->sh_info
!= 0)
1555 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1556 if (isymbuf
== NULL
)
1557 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1558 symtab_hdr
->sh_info
, 0,
1560 if (isymbuf
== NULL
)
1564 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1566 Elf_Internal_Sym
*isym
;
1570 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1573 isym
= &isymbuf
[idx
];
1574 if (isym
->st_shndx
== SHN_UNDEF
)
1576 else if (isym
->st_shndx
== SHN_ABS
)
1577 tsec
= bfd_abs_section_ptr
;
1578 else if (isym
->st_shndx
== SHN_COMMON
)
1579 tsec
= bfd_com_section_ptr
;
1581 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1583 address
= (tsec
->output_section
->vma
1584 + tsec
->output_offset
1586 if (valid_16bit_address (address
))
1588 local_plt_offsets
[idx
] = -1;
1595 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1597 if (! info
->keep_memory
)
1601 /* Cache the symbols for elf_link_input_bfd. */
1602 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1607 /* If we changed anything, walk the symbols again to reallocate
1608 .plt entry addresses. */
1609 if (*again
&& splt
->size
> 0)
1613 elf_link_hash_traverse (elf_hash_table (info
),
1614 rl78_relax_plt_realloc
, &entry
);
1616 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1618 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1619 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1622 if (! local_plt_offsets
)
1625 for (idx
= 0; idx
< nlocals
; ++idx
)
1626 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1628 local_plt_offsets
[idx
] = entry
;
1637 /* Delete some bytes from a section while relaxing. */
1640 elf32_rl78_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, int count
,
1641 Elf_Internal_Rela
*alignment_rel
, int force_snip
)
1643 Elf_Internal_Shdr
* symtab_hdr
;
1644 unsigned int sec_shndx
;
1645 bfd_byte
* contents
;
1646 Elf_Internal_Rela
* irel
;
1647 Elf_Internal_Rela
* irelend
;
1648 Elf_Internal_Sym
* isym
;
1649 Elf_Internal_Sym
* isymend
;
1651 unsigned int symcount
;
1652 struct elf_link_hash_entry
** sym_hashes
;
1653 struct elf_link_hash_entry
** end_hashes
;
1658 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1660 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1662 /* The deletion must stop at the next alignment boundary, if
1663 ALIGNMENT_REL is non-NULL. */
1666 toaddr
= alignment_rel
->r_offset
;
1668 irel
= elf_section_data (sec
)->relocs
;
1671 _bfd_elf_link_read_relocs (sec
->owner
, sec
, NULL
, NULL
, true);
1672 irel
= elf_section_data (sec
)->relocs
;
1675 irelend
= irel
+ sec
->reloc_count
;
1677 /* Actually delete the bytes. */
1678 memmove (contents
+ addr
, contents
+ addr
+ count
,
1679 (size_t) (toaddr
- addr
- count
));
1681 /* If we don't have an alignment marker to worry about, we can just
1682 shrink the section. Otherwise, we have to fill in the newly
1683 created gap with NOP insns (0x03). */
1687 memset (contents
+ toaddr
- count
, 0x03, count
);
1689 /* Adjust all the relocs. */
1690 for (; irel
&& irel
< irelend
; irel
++)
1692 /* Get the new reloc address. */
1693 if (irel
->r_offset
> addr
1694 && (irel
->r_offset
< toaddr
1695 || (force_snip
&& irel
->r_offset
== toaddr
)))
1696 irel
->r_offset
-= count
;
1698 /* If we see an ALIGN marker at the end of the gap, we move it
1699 to the beginning of the gap, since marking these gaps is what
1701 if (irel
->r_offset
== toaddr
1702 && ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
1703 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
1704 irel
->r_offset
-= count
;
1707 /* Adjust the local symbols defined in this section. */
1708 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1709 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1710 isymend
= isym
+ symtab_hdr
->sh_info
;
1712 for (; isym
< isymend
; isym
++)
1714 /* If the symbol is in the range of memory we just moved, we
1715 have to adjust its value. */
1716 if (isym
->st_shndx
== sec_shndx
1717 && isym
->st_value
> addr
1718 && isym
->st_value
< toaddr
)
1719 isym
->st_value
-= count
;
1721 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1722 *end* is in the moved bytes but it's *start* isn't), then we
1723 must adjust its size. */
1724 if (isym
->st_shndx
== sec_shndx
1725 && isym
->st_value
< addr
1726 && isym
->st_value
+ isym
->st_size
> addr
1727 && isym
->st_value
+ isym
->st_size
< toaddr
)
1728 isym
->st_size
-= count
;
1731 /* Now adjust the global symbols defined in this section. */
1732 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1733 - symtab_hdr
->sh_info
);
1734 sym_hashes
= elf_sym_hashes (abfd
);
1735 end_hashes
= sym_hashes
+ symcount
;
1737 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1739 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1741 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1742 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1743 && sym_hash
->root
.u
.def
.section
== sec
)
1745 /* As above, adjust the value if needed. */
1746 if (sym_hash
->root
.u
.def
.value
> addr
1747 && sym_hash
->root
.u
.def
.value
< toaddr
)
1748 sym_hash
->root
.u
.def
.value
-= count
;
1750 /* As above, adjust the size if needed. */
1751 if (sym_hash
->root
.u
.def
.value
< addr
1752 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1753 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1754 sym_hash
->size
-= count
;
1761 /* Used to sort relocs by address. If relocs have the same address,
1762 we maintain their relative order, except that R_RL78_RH_RELAX
1763 alignment relocs must be the first reloc for any given address. */
1766 reloc_bubblesort (Elf_Internal_Rela
* r
, int count
)
1772 /* This is almost a classic bubblesort. It's the slowest sort, but
1773 we're taking advantage of the fact that the relocations are
1774 mostly in order already (the assembler emits them that way) and
1775 we need relocs with the same address to remain in the same
1781 for (i
= 0; i
< count
- 1; i
++)
1783 if (r
[i
].r_offset
> r
[i
+ 1].r_offset
)
1785 else if (r
[i
].r_offset
< r
[i
+ 1].r_offset
)
1787 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1788 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ALIGN
))
1790 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1791 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ELIGN
)
1792 && !(ELF32_R_TYPE (r
[i
].r_info
) == R_RL78_RH_RELAX
1793 && (r
[i
].r_addend
& RL78_RELAXA_ALIGN
)))
1800 Elf_Internal_Rela tmp
;
1805 /* If we do move a reloc back, re-scan to see if it
1806 needs to be moved even further back. This avoids
1807 most of the O(n^2) behavior for our cases. */
1817 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1818 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1819 lrel, abfd, sec, link_info, scale)
1822 rl78_offset_for_reloc (bfd
* abfd
,
1823 Elf_Internal_Rela
* rel
,
1824 Elf_Internal_Shdr
* symtab_hdr
,
1825 bfd_byte
* shndx_buf ATTRIBUTE_UNUSED
,
1826 Elf_Internal_Sym
* intsyms
,
1827 Elf_Internal_Rela
** lrel
,
1829 asection
* input_section
,
1830 struct bfd_link_info
* info
,
1837 /* REL is the first of 1..N relocations. We compute the symbol
1838 value for each relocation, then combine them if needed. LREL
1839 gets a pointer to the last relocation used. */
1842 unsigned long r_type
;
1844 /* Get the value of the symbol referred to by the reloc. */
1845 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1847 /* A local symbol. */
1848 Elf_Internal_Sym
*isym
;
1851 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1853 if (isym
->st_shndx
== SHN_UNDEF
)
1854 ssec
= bfd_und_section_ptr
;
1855 else if (isym
->st_shndx
== SHN_ABS
)
1856 ssec
= bfd_abs_section_ptr
;
1857 else if (isym
->st_shndx
== SHN_COMMON
)
1858 ssec
= bfd_com_section_ptr
;
1860 ssec
= bfd_section_from_elf_index (abfd
,
1863 /* Initial symbol value. */
1864 symval
= isym
->st_value
;
1866 /* GAS may have made this symbol relative to a section, in
1867 which case, we have to add the addend to find the
1869 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
1870 symval
+= rel
->r_addend
;
1874 if ((ssec
->flags
& SEC_MERGE
)
1875 && ssec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1876 symval
= _bfd_merged_section_offset (abfd
, & ssec
,
1877 elf_section_data (ssec
)->sec_info
,
1881 /* Now make the offset relative to where the linker is putting it. */
1884 ssec
->output_section
->vma
+ ssec
->output_offset
;
1886 symval
+= rel
->r_addend
;
1891 struct elf_link_hash_entry
* h
;
1893 /* An external symbol. */
1894 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1895 h
= elf_sym_hashes (abfd
)[indx
];
1896 BFD_ASSERT (h
!= NULL
);
1898 if (h
->root
.type
!= bfd_link_hash_defined
1899 && h
->root
.type
!= bfd_link_hash_defweak
)
1901 /* This appears to be a reference to an undefined
1902 symbol. Just ignore it--it will be caught by the
1903 regular reloc processing. */
1909 symval
= (h
->root
.u
.def
.value
1910 + h
->root
.u
.def
.section
->output_section
->vma
1911 + h
->root
.u
.def
.section
->output_offset
);
1913 symval
+= rel
->r_addend
;
1916 r_type
= ELF32_R_TYPE (rel
->r_info
);
1920 (void) rl78_compute_complex_reloc (r_type
, symval
, input_section
);
1923 case R_RL78_OPromtop
:
1924 symval
= get_romstart (info
, input_bfd
, input_section
, rel
->r_offset
);
1925 (void) rl78_compute_complex_reloc (r_type
, symval
, input_section
);
1928 case R_RL78_OPramtop
:
1929 symval
= get_ramstart (info
, input_bfd
, input_section
, rel
->r_offset
);
1930 (void) rl78_compute_complex_reloc (r_type
, symval
, input_section
);
1940 case R_RL78_OPsctsize
:
1941 case R_RL78_OPscttop
:
1947 (void) rl78_compute_complex_reloc (r_type
, 0, input_section
);
1950 case R_RL78_DIR16UL
:
1952 case R_RL78_ABS16UL
:
1955 goto reloc_computes_value
;
1957 case R_RL78_DIR16UW
:
1959 case R_RL78_ABS16UW
:
1962 goto reloc_computes_value
;
1965 reloc_computes_value
:
1966 symval
= rl78_compute_complex_reloc (r_type
, symval
, input_section
);
1973 case R_RL78_DIR24S_PCREL
:
1974 case R_RL78_DIR16S_PCREL
:
1975 case R_RL78_DIR8S_PCREL
:
1986 int prefix
; /* or -1 for "no prefix" */
1987 int insn
; /* or -1 for "end of list" */
1988 int insn_for_saddr
; /* or -1 for "no alternative" */
1989 int insn_for_sfr
; /* or -1 for "no alternative" */
1990 } relax_addr16
[] = {
1991 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1992 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1993 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1994 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1996 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1997 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1998 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1999 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
2000 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
2001 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
2002 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
2003 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
2005 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
2006 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
2007 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
2008 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
2009 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
2011 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
2012 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
2013 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
2014 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
2016 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
2017 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
2018 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
2020 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
2021 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
2022 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
2023 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
2024 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
2025 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
2027 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
2029 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
2030 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
2031 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
2032 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
2033 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
2034 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
2035 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
2036 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
2038 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
2039 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
2040 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
2041 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
2042 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
2043 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
2044 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
2045 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
2050 /* Relax one section. */
2053 rl78_elf_relax_section (bfd
*abfd
,
2055 struct bfd_link_info
*link_info
,
2058 Elf_Internal_Shdr
* symtab_hdr
;
2059 Elf_Internal_Shdr
* shndx_hdr
;
2060 Elf_Internal_Rela
* internal_relocs
;
2061 Elf_Internal_Rela
* free_relocs
= NULL
;
2062 Elf_Internal_Rela
* irel
;
2063 Elf_Internal_Rela
* srel
;
2064 Elf_Internal_Rela
* irelend
;
2065 Elf_Internal_Rela
* next_alignment
;
2066 bfd_byte
* contents
= NULL
;
2067 bfd_byte
* free_contents
= NULL
;
2068 Elf_Internal_Sym
* intsyms
= NULL
;
2069 Elf_Internal_Sym
* free_intsyms
= NULL
;
2070 bfd_byte
* shndx_buf
= NULL
;
2072 bfd_vma symval ATTRIBUTE_UNUSED
= 0;
2073 int pcrel ATTRIBUTE_UNUSED
= 0;
2074 int code ATTRIBUTE_UNUSED
= 0;
2075 int section_alignment_glue
;
2078 if (abfd
== elf_hash_table (link_info
)->dynobj
2079 && strcmp (sec
->name
, ".plt") == 0)
2080 return rl78_elf_relax_plt_section (abfd
, sec
, link_info
, again
);
2082 /* Assume nothing changes. */
2085 /* We don't have to do anything for a relocatable link, if
2086 this section does not have relocs, or if this is not a
2088 if (bfd_link_relocatable (link_info
)
2089 || (sec
->flags
& SEC_RELOC
) == 0
2090 || sec
->reloc_count
== 0
2091 || (sec
->flags
& SEC_CODE
) == 0)
2094 symtab_hdr
= & elf_symtab_hdr (abfd
);
2095 if (elf_symtab_shndx_list (abfd
))
2096 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
2100 /* Get the section contents. */
2101 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2102 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2103 /* Go get them off disk. */
2106 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2108 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2111 /* Read this BFD's symbols. */
2112 /* Get cached copy if it exists. */
2113 if (symtab_hdr
->contents
!= NULL
)
2114 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2117 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
2118 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
2121 if (shndx_hdr
&& shndx_hdr
->sh_size
!= 0)
2125 if (_bfd_mul_overflow (symtab_hdr
->sh_info
,
2126 sizeof (Elf_External_Sym_Shndx
), &amt
))
2128 bfd_set_error (bfd_error_no_memory
);
2131 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0)
2133 shndx_buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2134 if (shndx_buf
== NULL
)
2136 shndx_hdr
->contents
= shndx_buf
;
2139 /* Get a copy of the native relocations. */
2140 internal_relocs
= (_bfd_elf_link_read_relocs
2141 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2142 link_info
->keep_memory
));
2143 if (internal_relocs
== NULL
)
2145 if (! link_info
->keep_memory
)
2146 free_relocs
= internal_relocs
;
2148 /* The RL_ relocs must be just before the operand relocs they go
2149 with, so we must sort them to guarantee this. We use bubblesort
2150 instead of qsort so we can guarantee that relocs with the same
2151 address remain in the same relative order. */
2152 reloc_bubblesort (internal_relocs
, sec
->reloc_count
);
2154 /* Walk through them looking for relaxing opportunities. */
2155 irelend
= internal_relocs
+ sec
->reloc_count
;
2158 /* This will either be NULL or a pointer to the next alignment
2160 next_alignment
= internal_relocs
;
2162 /* We calculate worst case shrinkage caused by alignment directives.
2163 No fool-proof, but better than either ignoring the problem or
2164 doing heavy duty analysis of all the alignment markers in all
2166 section_alignment_glue
= 0;
2167 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2168 if (ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
2169 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
2171 int this_glue
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2173 if (section_alignment_glue
< this_glue
)
2174 section_alignment_glue
= this_glue
;
2176 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2178 section_alignment_glue
*= 2;
2180 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2182 unsigned char *insn
;
2185 /* The insns we care about are all marked with one of these. */
2186 if (ELF32_R_TYPE (irel
->r_info
) != R_RL78_RH_RELAX
)
2189 if (irel
->r_addend
& RL78_RELAXA_ALIGN
2190 || next_alignment
== internal_relocs
)
2192 /* When we delete bytes, we need to maintain all the alignments
2193 indicated. In addition, we need to be careful about relaxing
2194 jumps across alignment boundaries - these displacements
2195 *grow* when we delete bytes. For now, don't shrink
2196 displacements across an alignment boundary, just in case.
2197 Note that this only affects relocations to the same
2199 next_alignment
+= 2;
2200 while (next_alignment
< irelend
2201 && (ELF32_R_TYPE (next_alignment
->r_info
) != R_RL78_RH_RELAX
2202 || !(next_alignment
->r_addend
& RL78_RELAXA_ELIGN
)))
2204 if (next_alignment
>= irelend
|| next_alignment
->r_offset
== 0)
2205 next_alignment
= NULL
;
2208 /* When we hit alignment markers, see if we've shrunk enough
2209 before them to reduce the gap without violating the alignment
2211 if (irel
->r_addend
& RL78_RELAXA_ALIGN
)
2213 /* At this point, the next relocation *should* be the ELIGN
2215 Elf_Internal_Rela
*erel
= irel
+ 1;
2216 unsigned int alignment
, nbytes
;
2218 if (ELF32_R_TYPE (erel
->r_info
) != R_RL78_RH_RELAX
)
2220 if (!(erel
->r_addend
& RL78_RELAXA_ELIGN
))
2223 alignment
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2225 if (erel
->r_offset
- irel
->r_offset
< alignment
)
2228 nbytes
= erel
->r_offset
- irel
->r_offset
;
2229 nbytes
/= alignment
;
2230 nbytes
*= alignment
;
2232 elf32_rl78_relax_delete_bytes (abfd
, sec
, erel
->r_offset
- nbytes
, nbytes
,
2233 next_alignment
, erel
->r_offset
== sec
->size
);
2239 if (irel
->r_addend
& RL78_RELAXA_ELIGN
)
2242 insn
= contents
+ irel
->r_offset
;
2244 nrelocs
= irel
->r_addend
& RL78_RELAXA_RNUM
;
2246 /* At this point, we have an insn that is a candidate for linker
2247 relaxation. There are NRELOCS relocs following that may be
2248 relaxed, although each reloc may be made of more than one
2249 reloc entry (such as gp-rel symbols). */
2251 /* Get the value of the symbol referred to by the reloc. Just
2252 in case this is the last reloc in the list, use the RL's
2253 addend to choose between this reloc (no addend) or the next
2254 (yes addend, which means at least one following reloc). */
2256 /* srel points to the "current" reloction for this insn -
2257 actually the last reloc for a given operand, which is the one
2258 we need to update. We check the relaxations in the same
2259 order that the relocations happen, so we'll just push it
2263 pc
= sec
->output_section
->vma
+ sec
->output_offset
2267 BFD_ASSERT (nrelocs > 0); \
2268 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2269 pcrel = symval - pc + srel->r_addend; \
2272 #define SNIPNR(offset, nbytes) \
2273 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2275 #define SNIP(offset, nbytes, newtype) \
2276 SNIPNR (offset, nbytes); \
2277 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2279 /* The order of these bit tests must match the order that the
2280 relocs appear in. Since we sorted those by offset, we can
2283 /*----------------------------------------------------------------------*/
2284 /* EF ad BR $rel8 pcrel
2285 ED al ah BR !abs16 abs
2286 EE al ah BR $!rel16 pcrel
2287 EC al ah as BR !!abs20 abs
2289 FD al ah CALL !abs16 abs
2290 FE al ah CALL $!rel16 pcrel
2291 FC al ah as CALL !!abs20 abs
2299 61 C8 EF ad SKC ; BR $rel8
2300 61 D8 EF ad SKNC ; BR $rel8
2301 61 E8 EF ad SKZ ; BR $rel8
2302 61 F8 EF ad SKNZ ; BR $rel8
2303 61 E3 EF ad SKH ; BR $rel8
2304 61 F3 EF ad SKNH ; BR $rel8
2307 if ((irel
->r_addend
& RL78_RELAXA_MASK
) == RL78_RELAXA_BRA
)
2309 /* SKIP opcodes that skip non-branches will have a relax tag
2310 but no corresponding symbol to relax against; we just
2312 if (irel
->r_addend
& RL78_RELAXA_RNUM
)
2321 case 0xde: /* BNC */
2322 case 0xdf: /* BNZ */
2323 if (insn
[1] == 0x03 && insn
[2] == 0xee /* BR */
2324 && (srel
->r_offset
- irel
->r_offset
) > 1) /* a B<c> without its own reloc */
2326 /* This is a "long" conditional as generated by gas:
2331 insn
[0] ^= 0x02; /* invert conditional */
2333 SNIP (1, 2, R_RL78_DIR8S_PCREL
);
2340 case 0xec: /* BR !!abs20 */
2347 SNIP (2, 2, R_RL78_DIR8S_PCREL
);
2350 else if (symval
< 65536)
2353 insn
[1] = symval
& 0xff;
2354 insn
[2] = symval
>> 8;
2355 SNIP (2, 1, R_RL78_DIR16U
);
2358 else if (pcrel
< 32767
2362 insn
[1] = pcrel
& 0xff;
2363 insn
[2] = pcrel
>> 8;
2364 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2369 case 0xee: /* BR $!pcrel16 */
2370 case 0xed: /* BR $!abs16 */
2376 SNIP (2, 1, R_RL78_DIR8S_PCREL
);
2381 case 0xfc: /* CALL !!abs20 */
2385 insn
[1] = symval
& 0xff;
2386 insn
[2] = symval
>> 8;
2387 SNIP (2, 1, R_RL78_DIR16U
);
2390 else if (pcrel
< 32767
2394 insn
[1] = pcrel
& 0xff;
2395 insn
[2] = pcrel
>> 8;
2396 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2401 case 0x61: /* PREFIX */
2402 /* For SKIP/BR, we change the BR opcode and delete the
2403 SKIP. That way, we don't have to find and change the
2404 relocation for the BR. */
2405 /* Note that, for the case where we're skipping some
2406 other insn, we have no "other" reloc but that's safe
2410 case 0xd3: /* BNH */
2412 if (insn
[2] == 0x03 && insn
[3] == 0xee
2413 && (srel
->r_offset
- irel
->r_offset
) > 2) /* a B<c> without its own reloc */
2415 /* Another long branch by gas:
2416 61 D3 03 EE ad.dr */
2420 insn
[1] ^= 0x10; /* invert conditional */
2422 SNIP (2, 2, R_RL78_DIR8S_PCREL
);
2429 case 0xc8: /* SKC */
2430 if (insn
[2] == 0xef)
2432 insn
[2] = 0xde; /* BNC */
2437 case 0xd8: /* SKNC */
2438 if (insn
[2] == 0xef)
2440 insn
[2] = 0xdc; /* BC */
2445 case 0xe8: /* SKZ */
2446 if (insn
[2] == 0xef)
2448 insn
[2] = 0xdf; /* BNZ */
2453 case 0xf8: /* SKNZ */
2454 if (insn
[2] == 0xef)
2456 insn
[2] = 0xdd; /* BZ */
2461 case 0xe3: /* SKH */
2462 if (insn
[2] == 0xef)
2464 insn
[2] = 0xd3; /* BNH */
2465 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2469 case 0xf3: /* SKNH */
2470 if (insn
[2] == 0xef)
2472 insn
[2] = 0xc3; /* BH */
2473 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2481 if ((irel
->r_addend
& RL78_RELAXA_MASK
) == RL78_RELAXA_ADDR16
2484 /*----------------------------------------------------------------------*/
2485 /* Some insns have both a 16-bit address operand and an 8-bit
2486 variant if the address is within a special range:
2488 Address 16-bit operand SADDR range SFR range
2489 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2490 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2492 The RELAX_ADDR16[] array has the insn encodings for the
2493 16-bit operand version, as well as the SFR and SADDR
2494 variants. We only need to replace the encodings and
2497 Note: we intentionally do not attempt to decode and skip
2498 any ES: prefix, as adding ES: means the addr16 (likely)
2499 no longer points to saddr/sfr space.
2509 if (0xffe20 <= symval
&& symval
<= 0xfffff)
2512 is_saddr
= (0xffe20 <= symval
&& symval
<= 0xfff1f);
2513 is_sfr
= (0xfff00 <= symval
&& symval
<= 0xfffff);
2515 for (idx
= 0; relax_addr16
[idx
].insn
!= -1; idx
++)
2517 if (relax_addr16
[idx
].prefix
!= -1
2518 && insn
[0] == relax_addr16
[idx
].prefix
2519 && insn
[1] == relax_addr16
[idx
].insn
)
2523 else if (relax_addr16
[idx
].prefix
== -1
2524 && insn
[0] == relax_addr16
[idx
].insn
)
2531 /* We have a matched insn, and poff is 0 or 1 depending
2532 on the base pattern size. */
2534 if (is_sfr
&& relax_addr16
[idx
].insn_for_sfr
!= -1)
2536 insn
[poff
] = relax_addr16
[idx
].insn_for_sfr
;
2537 SNIP (poff
+2, 1, R_RL78_RH_SFR
);
2540 else if (is_saddr
&& relax_addr16
[idx
].insn_for_saddr
!= -1)
2542 insn
[poff
] = relax_addr16
[idx
].insn_for_saddr
;
2543 SNIP (poff
+2, 1, R_RL78_RH_SADDR
);
2548 /*----------------------------------------------------------------------*/
2555 free (free_contents
);
2557 if (shndx_buf
!= NULL
)
2559 shndx_hdr
->contents
= NULL
;
2563 free (free_intsyms
);
2570 #define ELF_ARCH bfd_arch_rl78
2571 #define ELF_MACHINE_CODE EM_RL78
2572 #define ELF_MAXPAGESIZE 0x1000
2574 #define TARGET_LITTLE_SYM rl78_elf32_vec
2575 #define TARGET_LITTLE_NAME "elf32-rl78"
2577 #define elf_info_to_howto_rel NULL
2578 #define elf_info_to_howto rl78_info_to_howto_rela
2579 #define elf_backend_object_p rl78_elf_object_p
2580 #define elf_backend_relocate_section rl78_elf_relocate_section
2581 #define elf_symbol_leading_char ('_')
2582 #define elf_backend_can_gc_sections 1
2584 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2585 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2586 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2587 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2588 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2590 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2591 #define elf_backend_check_relocs rl78_elf_check_relocs
2592 #define elf_backend_always_size_sections \
2593 rl78_elf_always_size_sections
2594 #define elf_backend_finish_dynamic_sections \
2595 rl78_elf_finish_dynamic_sections
2597 #include "elf32-target.h"