1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011, 2012
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "bfd_stdint.h"
27 #include "libiberty.h"
29 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
31 #define RL78REL(n,sz,bit,shift,complain,pcrel) \
32 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
33 bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
35 /* Note that the relocations around 0x7f are internal to this file;
36 feel free to move them as needed to avoid conflicts with published
37 relocation numbers. */
39 static reloc_howto_type rl78_elf_howto_table
[] =
41 RL78REL (NONE
, 0, 0, 0, dont
, FALSE
),
42 RL78REL (DIR32
, 2, 32, 0, signed, FALSE
),
43 RL78REL (DIR24S
, 2, 24, 0, signed, FALSE
),
44 RL78REL (DIR16
, 1, 16, 0, dont
, FALSE
),
45 RL78REL (DIR16U
, 1, 16, 0, unsigned, FALSE
),
46 RL78REL (DIR16S
, 1, 16, 0, signed, FALSE
),
47 RL78REL (DIR8
, 0, 8, 0, dont
, FALSE
),
48 RL78REL (DIR8U
, 0, 8, 0, unsigned, FALSE
),
49 RL78REL (DIR8S
, 0, 8, 0, signed, FALSE
),
50 RL78REL (DIR24S_PCREL
, 2, 24, 0, signed, TRUE
),
51 RL78REL (DIR16S_PCREL
, 1, 16, 0, signed, TRUE
),
52 RL78REL (DIR8S_PCREL
, 0, 8, 0, signed, TRUE
),
53 RL78REL (DIR16UL
, 1, 16, 2, unsigned, FALSE
),
54 RL78REL (DIR16UW
, 1, 16, 1, unsigned, FALSE
),
55 RL78REL (DIR8UL
, 0, 8, 2, unsigned, FALSE
),
56 RL78REL (DIR8UW
, 0, 8, 1, unsigned, FALSE
),
57 RL78REL (DIR32_REV
, 1, 16, 0, dont
, FALSE
),
58 RL78REL (DIR16_REV
, 1, 16, 0, dont
, FALSE
),
59 RL78REL (DIR3U_PCREL
, 0, 3, 0, dont
, TRUE
),
88 RL78REL (RH_RELAX
, 0, 0, 0, dont
, FALSE
),
110 RL78REL (ABS32
, 2, 32, 0, dont
, FALSE
),
111 RL78REL (ABS24S
, 2, 24, 0, signed, FALSE
),
112 RL78REL (ABS16
, 1, 16, 0, dont
, FALSE
),
113 RL78REL (ABS16U
, 1, 16, 0, unsigned, FALSE
),
114 RL78REL (ABS16S
, 1, 16, 0, signed, FALSE
),
115 RL78REL (ABS8
, 0, 8, 0, dont
, FALSE
),
116 RL78REL (ABS8U
, 0, 8, 0, unsigned, FALSE
),
117 RL78REL (ABS8S
, 0, 8, 0, signed, FALSE
),
118 RL78REL (ABS24S_PCREL
, 2, 24, 0, signed, TRUE
),
119 RL78REL (ABS16S_PCREL
, 1, 16, 0, signed, TRUE
),
120 RL78REL (ABS8S_PCREL
, 0, 8, 0, signed, TRUE
),
121 RL78REL (ABS16UL
, 1, 16, 0, unsigned, FALSE
),
122 RL78REL (ABS16UW
, 1, 16, 0, unsigned, FALSE
),
123 RL78REL (ABS8UL
, 0, 8, 0, unsigned, FALSE
),
124 RL78REL (ABS8UW
, 0, 8, 0, unsigned, FALSE
),
125 RL78REL (ABS32_REV
, 2, 32, 0, dont
, FALSE
),
126 RL78REL (ABS16_REV
, 1, 16, 0, dont
, FALSE
),
128 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
178 RL78REL (SYM
, 2, 32, 0, dont
, FALSE
),
179 RL78REL (OPneg
, 2, 32, 0, dont
, FALSE
),
180 RL78REL (OPadd
, 2, 32, 0, dont
, FALSE
),
181 RL78REL (OPsub
, 2, 32, 0, dont
, FALSE
),
182 RL78REL (OPmul
, 2, 32, 0, dont
, FALSE
),
183 RL78REL (OPdiv
, 2, 32, 0, dont
, FALSE
),
184 RL78REL (OPshla
, 2, 32, 0, dont
, FALSE
),
185 RL78REL (OPshra
, 2, 32, 0, dont
, FALSE
),
186 RL78REL (OPsctsize
, 2, 32, 0, dont
, FALSE
),
191 RL78REL (OPscttop
, 2, 32, 0, dont
, FALSE
),
194 RL78REL (OPand
, 2, 32, 0, dont
, FALSE
),
195 RL78REL (OPor
, 2, 32, 0, dont
, FALSE
),
196 RL78REL (OPxor
, 2, 32, 0, dont
, FALSE
),
197 RL78REL (OPnot
, 2, 32, 0, dont
, FALSE
),
198 RL78REL (OPmod
, 2, 32, 0, dont
, FALSE
),
199 RL78REL (OPromtop
, 2, 32, 0, dont
, FALSE
),
200 RL78REL (OPramtop
, 2, 32, 0, dont
, FALSE
)
203 /* Map BFD reloc types to RL78 ELF reloc types. */
205 struct rl78_reloc_map
207 bfd_reloc_code_real_type bfd_reloc_val
;
208 unsigned int rl78_reloc_val
;
211 static const struct rl78_reloc_map rl78_reloc_map
[] =
213 { BFD_RELOC_NONE
, R_RL78_NONE
},
214 { BFD_RELOC_8
, R_RL78_DIR8S
},
215 { BFD_RELOC_16
, R_RL78_DIR16S
},
216 { BFD_RELOC_24
, R_RL78_DIR24S
},
217 { BFD_RELOC_32
, R_RL78_DIR32
},
218 { BFD_RELOC_RL78_16_OP
, R_RL78_DIR16
},
219 { BFD_RELOC_RL78_DIR3U_PCREL
, R_RL78_DIR3U_PCREL
},
220 { BFD_RELOC_8_PCREL
, R_RL78_DIR8S_PCREL
},
221 { BFD_RELOC_16_PCREL
, R_RL78_DIR16S_PCREL
},
222 { BFD_RELOC_24_PCREL
, R_RL78_DIR24S_PCREL
},
223 { BFD_RELOC_RL78_8U
, R_RL78_DIR8U
},
224 { BFD_RELOC_RL78_16U
, R_RL78_DIR16U
},
225 { BFD_RELOC_RL78_SYM
, R_RL78_SYM
},
226 { BFD_RELOC_RL78_OP_SUBTRACT
, R_RL78_OPsub
},
227 { BFD_RELOC_RL78_OP_NEG
, R_RL78_OPneg
},
228 { BFD_RELOC_RL78_OP_AND
, R_RL78_OPand
},
229 { BFD_RELOC_RL78_OP_SHRA
, R_RL78_OPshra
},
230 { BFD_RELOC_RL78_ABS8
, R_RL78_ABS8
},
231 { BFD_RELOC_RL78_ABS16
, R_RL78_ABS16
},
232 { BFD_RELOC_RL78_ABS16_REV
, R_RL78_ABS16_REV
},
233 { BFD_RELOC_RL78_ABS32
, R_RL78_ABS32
},
234 { BFD_RELOC_RL78_ABS32_REV
, R_RL78_ABS32_REV
},
235 { BFD_RELOC_RL78_ABS16UL
, R_RL78_ABS16UL
},
236 { BFD_RELOC_RL78_ABS16UW
, R_RL78_ABS16UW
},
237 { BFD_RELOC_RL78_ABS16U
, R_RL78_ABS16U
},
238 { BFD_RELOC_RL78_RELAX
, R_RL78_RH_RELAX
}
241 static reloc_howto_type
*
242 rl78_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
243 bfd_reloc_code_real_type code
)
247 if (code
== BFD_RELOC_RL78_32_OP
)
248 return rl78_elf_howto_table
+ R_RL78_DIR32
;
250 for (i
= ARRAY_SIZE (rl78_reloc_map
); --i
;)
251 if (rl78_reloc_map
[i
].bfd_reloc_val
== code
)
252 return rl78_elf_howto_table
+ rl78_reloc_map
[i
].rl78_reloc_val
;
257 static reloc_howto_type
*
258 rl78_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
, const char * r_name
)
262 for (i
= 0; i
< ARRAY_SIZE (rl78_elf_howto_table
); i
++)
263 if (rl78_elf_howto_table
[i
].name
!= NULL
264 && strcasecmp (rl78_elf_howto_table
[i
].name
, r_name
) == 0)
265 return rl78_elf_howto_table
+ i
;
270 /* Set the howto pointer for an RL78 ELF reloc. */
273 rl78_info_to_howto_rela (bfd
* abfd ATTRIBUTE_UNUSED
,
275 Elf_Internal_Rela
* dst
)
279 r_type
= ELF32_R_TYPE (dst
->r_info
);
280 BFD_ASSERT (r_type
< (unsigned int) R_RL78_max
);
281 cache_ptr
->howto
= rl78_elf_howto_table
+ r_type
;
285 get_symbol_value (const char * name
,
286 bfd_reloc_status_type
* status
,
287 struct bfd_link_info
* info
,
289 asection
* input_section
,
293 struct bfd_link_hash_entry
* h
;
295 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
298 || (h
->type
!= bfd_link_hash_defined
299 && h
->type
!= bfd_link_hash_defweak
))
300 * status
= info
->callbacks
->undefined_symbol
301 (info
, name
, input_bfd
, input_section
, offset
, TRUE
);
303 value
= (h
->u
.def
.value
304 + h
->u
.def
.section
->output_section
->vma
305 + h
->u
.def
.section
->output_offset
);
311 get_romstart (bfd_reloc_status_type
* status
,
312 struct bfd_link_info
* info
,
317 static bfd_boolean cached
= FALSE
;
318 static bfd_vma cached_value
= 0;
322 cached_value
= get_symbol_value ("_start", status
, info
, abfd
, sec
, offset
);
329 get_ramstart (bfd_reloc_status_type
* status
,
330 struct bfd_link_info
* info
,
335 static bfd_boolean cached
= FALSE
;
336 static bfd_vma cached_value
= 0;
340 cached_value
= get_symbol_value ("__datastart", status
, info
, abfd
, sec
, offset
);
346 #define NUM_STACK_ENTRIES 16
347 static int32_t rl78_stack
[ NUM_STACK_ENTRIES
];
348 static unsigned int rl78_stack_top
;
350 #define RL78_STACK_PUSH(val) \
353 if (rl78_stack_top < NUM_STACK_ENTRIES) \
354 rl78_stack [rl78_stack_top ++] = (val); \
356 r = bfd_reloc_dangerous; \
360 #define RL78_STACK_POP(dest) \
363 if (rl78_stack_top > 0) \
364 (dest) = rl78_stack [-- rl78_stack_top]; \
366 (dest) = 0, r = bfd_reloc_dangerous; \
370 /* Relocate an RL78 ELF section.
371 There is some attempt to make this function usable for many architectures,
372 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
373 if only to serve as a learning tool.
375 The RELOCATE_SECTION function is called by the new ELF backend linker
376 to handle the relocations for a section.
378 The relocs are always passed as Rela structures; if the section
379 actually uses Rel structures, the r_addend field will always be
382 This function is responsible for adjusting the section contents as
383 necessary, and (if using Rela relocs and generating a relocatable
384 output file) adjusting the reloc addend as necessary.
386 This function does not have to worry about setting the reloc
387 address or the reloc symbol index.
389 LOCAL_SYMS is a pointer to the swapped in local symbols.
391 LOCAL_SECTIONS is an array giving the section in the input file
392 corresponding to the st_shndx field of each local symbol.
394 The global hash table entry for the global symbols can be found
395 via elf_sym_hashes (input_bfd).
397 When generating relocatable output, this function must handle
398 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
399 going to be the section symbol corresponding to the output
400 section, which means that the addend must be adjusted
404 rl78_elf_relocate_section
406 struct bfd_link_info
* info
,
408 asection
* input_section
,
410 Elf_Internal_Rela
* relocs
,
411 Elf_Internal_Sym
* local_syms
,
412 asection
** local_sections
)
414 Elf_Internal_Shdr
* symtab_hdr
;
415 struct elf_link_hash_entry
** sym_hashes
;
416 Elf_Internal_Rela
* rel
;
417 Elf_Internal_Rela
* relend
;
421 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
422 sym_hashes
= elf_sym_hashes (input_bfd
);
423 relend
= relocs
+ input_section
->reloc_count
;
425 dynobj
= elf_hash_table (info
)->dynobj
;
428 splt
= bfd_get_linker_section (dynobj
, ".plt");
430 for (rel
= relocs
; rel
< relend
; rel
++)
432 reloc_howto_type
* howto
;
433 unsigned long r_symndx
;
434 Elf_Internal_Sym
* sym
;
436 struct elf_link_hash_entry
* h
;
438 bfd_reloc_status_type r
;
439 const char * name
= NULL
;
440 bfd_boolean unresolved_reloc
= TRUE
;
443 r_type
= ELF32_R_TYPE (rel
->r_info
);
444 r_symndx
= ELF32_R_SYM (rel
->r_info
);
446 howto
= rl78_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
452 if (r_symndx
< symtab_hdr
->sh_info
)
454 sym
= local_syms
+ r_symndx
;
455 sec
= local_sections
[r_symndx
];
456 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
458 name
= bfd_elf_string_from_elf_section
459 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
460 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
466 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
467 r_symndx
, symtab_hdr
, sym_hashes
, h
,
468 sec
, relocation
, unresolved_reloc
,
471 name
= h
->root
.root
.string
;
474 if (sec
!= NULL
&& discarded_section (sec
))
475 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
476 rel
, 1, relend
, howto
, 0, contents
);
478 if (info
->relocatable
)
480 /* This is a relocatable link. We don't have to change
481 anything, unless the reloc is against a section symbol,
482 in which case we have to adjust according to where the
483 section symbol winds up in the output section. */
484 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
485 rel
->r_addend
+= sec
->output_offset
;
489 switch (ELF32_R_TYPE (rel
->r_info
))
496 plt_offset
= &h
->plt
.offset
;
498 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
500 if (! valid_16bit_address (relocation
))
502 /* If this is the first time we've processed this symbol,
503 fill in the plt entry with the correct symbol address. */
504 if ((*plt_offset
& 1) == 0)
508 x
= 0x000000ec; /* br !!abs24 */
509 x
|= (relocation
<< 8) & 0xffffff00;
510 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
514 relocation
= (splt
->output_section
->vma
515 + splt
->output_offset
516 + (*plt_offset
& -2));
519 char *newname
= bfd_malloc (strlen(name
)+5);
520 strcpy (newname
, name
);
521 strcat(newname
, ".plt");
522 _bfd_generic_link_add_one_symbol (info
,
525 BSF_FUNCTION
| BSF_WEAK
,
538 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
539 /* If the symbol is undefined and weak
540 then the relocation resolves to zero. */
544 if (howto
->pc_relative
)
546 relocation
-= (input_section
->output_section
->vma
547 + input_section
->output_offset
549 relocation
-= bfd_get_reloc_size (howto
);
552 relocation
+= rel
->r_addend
;
557 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
558 #define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
559 #define OP(i) (contents[rel->r_offset + (i)])
561 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
567 case R_RL78_RH_RELAX
:
570 case R_RL78_DIR8S_PCREL
:
585 case R_RL78_DIR16S_PCREL
:
586 RANGE (-32768, 32767);
588 OP (1) = relocation
>> 8;
592 if ((relocation
& 0xf0000) == 0xf0000)
593 relocation
&= 0xffff;
594 RANGE (-32768, 65535);
596 OP (1) = relocation
>> 8;
602 OP (1) = relocation
>> 8;
606 RANGE (-32768, 65536);
608 OP (1) = relocation
>> 8;
611 case R_RL78_DIR16_REV
:
612 RANGE (-32768, 65536);
614 OP (0) = relocation
>> 8;
617 case R_RL78_DIR3U_PCREL
:
620 OP (0) |= relocation
& 0x07;
623 case R_RL78_DIR24S_PCREL
:
624 RANGE (-0x800000, 0x7fffff);
626 OP (1) = relocation
>> 8;
627 OP (2) = relocation
>> 16;
631 RANGE (-0x800000, 0x7fffff);
633 OP (1) = relocation
>> 8;
634 OP (2) = relocation
>> 16;
639 OP (1) = relocation
>> 8;
640 OP (2) = relocation
>> 16;
641 OP (3) = relocation
>> 24;
644 case R_RL78_DIR32_REV
:
646 OP (2) = relocation
>> 8;
647 OP (1) = relocation
>> 16;
648 OP (0) = relocation
>> 24;
652 RANGE (0xfff00, 0xfffff);
653 OP (0) = relocation
& 0xff;
656 case R_RL78_RH_SADDR
:
657 RANGE (0xffe20, 0xfff1f);
658 OP (0) = relocation
& 0xff;
661 /* Complex reloc handling: */
664 RL78_STACK_POP (relocation
);
666 OP (1) = relocation
>> 8;
667 OP (2) = relocation
>> 16;
668 OP (3) = relocation
>> 24;
671 case R_RL78_ABS32_REV
:
672 RL78_STACK_POP (relocation
);
674 OP (2) = relocation
>> 8;
675 OP (1) = relocation
>> 16;
676 OP (0) = relocation
>> 24;
679 case R_RL78_ABS24S_PCREL
:
681 RL78_STACK_POP (relocation
);
682 RANGE (-0x800000, 0x7fffff);
684 OP (1) = relocation
>> 8;
685 OP (2) = relocation
>> 16;
689 RL78_STACK_POP (relocation
);
690 RANGE (-32768, 65535);
692 OP (1) = relocation
>> 8;
695 case R_RL78_ABS16_REV
:
696 RL78_STACK_POP (relocation
);
697 RANGE (-32768, 65535);
699 OP (0) = relocation
>> 8;
702 case R_RL78_ABS16S_PCREL
:
704 RL78_STACK_POP (relocation
);
705 RANGE (-32768, 32767);
707 OP (1) = relocation
>> 8;
711 RL78_STACK_POP (relocation
);
714 OP (1) = relocation
>> 8;
718 RL78_STACK_POP (relocation
);
722 OP (1) = relocation
>> 8;
726 RL78_STACK_POP (relocation
);
730 OP (1) = relocation
>> 8;
734 RL78_STACK_POP (relocation
);
740 RL78_STACK_POP (relocation
);
746 RL78_STACK_POP (relocation
);
753 RL78_STACK_POP (relocation
);
759 case R_RL78_ABS8S_PCREL
:
761 RL78_STACK_POP (relocation
);
767 if (r_symndx
< symtab_hdr
->sh_info
)
768 RL78_STACK_PUSH (sec
->output_section
->vma
775 && (h
->root
.type
== bfd_link_hash_defined
776 || h
->root
.type
== bfd_link_hash_defweak
))
777 RL78_STACK_PUSH (h
->root
.u
.def
.value
778 + sec
->output_section
->vma
781 else if (h
->root
.type
== bfd_link_hash_undefweak
)
784 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
792 RL78_STACK_POP (tmp
);
794 RL78_STACK_PUSH (tmp
);
802 RL78_STACK_POP (tmp2
);
803 RL78_STACK_POP (tmp1
);
805 RL78_STACK_PUSH (tmp1
);
813 /* For the expression "A - B", the assembler pushes A,
814 then B, then OPSUB. So the first op we pop is B, not
816 RL78_STACK_POP (tmp2
); /* B */
817 RL78_STACK_POP (tmp1
); /* A */
818 tmp1
-= tmp2
; /* A - B */
819 RL78_STACK_PUSH (tmp1
);
827 RL78_STACK_POP (tmp2
);
828 RL78_STACK_POP (tmp1
);
830 RL78_STACK_PUSH (tmp1
);
838 RL78_STACK_POP (tmp2
);
839 RL78_STACK_POP (tmp1
);
841 RL78_STACK_PUSH (tmp1
);
849 RL78_STACK_POP (tmp2
);
850 RL78_STACK_POP (tmp1
);
852 RL78_STACK_PUSH (tmp1
);
860 RL78_STACK_POP (tmp2
);
861 RL78_STACK_POP (tmp1
);
863 RL78_STACK_PUSH (tmp1
);
867 case R_RL78_OPsctsize
:
868 RL78_STACK_PUSH (input_section
->size
);
871 case R_RL78_OPscttop
:
872 RL78_STACK_PUSH (input_section
->output_section
->vma
);
879 RL78_STACK_POP (tmp2
);
880 RL78_STACK_POP (tmp1
);
882 RL78_STACK_PUSH (tmp1
);
890 RL78_STACK_POP (tmp2
);
891 RL78_STACK_POP (tmp1
);
893 RL78_STACK_PUSH (tmp1
);
901 RL78_STACK_POP (tmp2
);
902 RL78_STACK_POP (tmp1
);
904 RL78_STACK_PUSH (tmp1
);
912 RL78_STACK_POP (tmp
);
914 RL78_STACK_PUSH (tmp
);
922 RL78_STACK_POP (tmp2
);
923 RL78_STACK_POP (tmp1
);
925 RL78_STACK_PUSH (tmp1
);
929 case R_RL78_OPromtop
:
930 RL78_STACK_PUSH (get_romstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
933 case R_RL78_OPramtop
:
934 RL78_STACK_PUSH (get_ramstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
938 r
= bfd_reloc_notsupported
;
942 if (r
!= bfd_reloc_ok
)
944 const char * msg
= NULL
;
948 case bfd_reloc_overflow
:
949 /* Catch the case of a missing function declaration
950 and emit a more helpful error message. */
951 if (r_type
== R_RL78_DIR24S_PCREL
)
952 msg
= _("%B(%A): error: call to undefined function '%s'");
954 r
= info
->callbacks
->reloc_overflow
955 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
956 input_bfd
, input_section
, rel
->r_offset
);
959 case bfd_reloc_undefined
:
960 r
= info
->callbacks
->undefined_symbol
961 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
965 case bfd_reloc_other
:
966 msg
= _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
969 case bfd_reloc_outofrange
:
970 msg
= _("%B(%A): internal error: out of range error");
973 case bfd_reloc_notsupported
:
974 msg
= _("%B(%A): internal error: unsupported relocation error");
977 case bfd_reloc_dangerous
:
978 msg
= _("%B(%A): internal error: dangerous relocation");
982 msg
= _("%B(%A): internal error: unknown error");
987 _bfd_error_handler (msg
, input_bfd
, input_section
, name
);
997 /* Function to set the ELF flag bits. */
1000 rl78_elf_set_private_flags (bfd
* abfd
, flagword flags
)
1002 elf_elfheader (abfd
)->e_flags
= flags
;
1003 elf_flags_init (abfd
) = TRUE
;
1007 static bfd_boolean no_warn_mismatch
= FALSE
;
1009 void bfd_elf32_rl78_set_target_flags (bfd_boolean
);
1012 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch
)
1014 no_warn_mismatch
= user_no_warn_mismatch
;
1017 /* Merge backend specific data from an object file to the output
1018 object file when linking. */
1021 rl78_elf_merge_private_bfd_data (bfd
* ibfd
, bfd
* obfd
)
1024 bfd_boolean error
= FALSE
;
1026 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1028 if (!elf_flags_init (obfd
))
1030 /* First call, no flags set. */
1031 elf_flags_init (obfd
) = TRUE
;
1032 elf_elfheader (obfd
)->e_flags
= new_flags
;
1039 rl78_elf_print_private_bfd_data (bfd
* abfd
, void * ptr
)
1041 FILE * file
= (FILE *) ptr
;
1044 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
1046 /* Print normal ELF private data. */
1047 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
1049 flags
= elf_elfheader (abfd
)->e_flags
;
1050 fprintf (file
, _("private flags = 0x%lx:"), (long) flags
);
1056 /* Return the MACH for an e_flags value. */
1059 elf32_rl78_machine (bfd
* abfd
)
1061 if ((elf_elfheader (abfd
)->e_flags
& EF_RL78_CPU_MASK
) == EF_RL78_CPU_RL78
)
1062 return bfd_mach_rl78
;
1068 rl78_elf_object_p (bfd
* abfd
)
1070 bfd_default_set_arch_mach (abfd
, bfd_arch_rl78
,
1071 elf32_rl78_machine (abfd
));
1077 rl78_dump_symtab (bfd
* abfd
, void * internal_syms
, void * external_syms
)
1080 Elf_Internal_Sym
* isymbuf
;
1081 Elf_Internal_Sym
* isymend
;
1082 Elf_Internal_Sym
* isym
;
1083 Elf_Internal_Shdr
* symtab_hdr
;
1084 bfd_boolean free_internal
= FALSE
, free_external
= FALSE
;
1086 char * st_info_stb_str
;
1087 char * st_other_str
;
1088 char * st_shndx_str
;
1090 if (! internal_syms
)
1092 internal_syms
= bfd_malloc (1000);
1095 if (! external_syms
)
1097 external_syms
= bfd_malloc (1000);
1101 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1102 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
1104 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1105 symtab_hdr
->sh_info
, 0,
1106 internal_syms
, external_syms
, NULL
);
1108 isymbuf
= internal_syms
;
1109 isymend
= isymbuf
+ locsymcount
;
1111 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1113 switch (ELF_ST_TYPE (isym
->st_info
))
1115 case STT_FUNC
: st_info_str
= "STT_FUNC";
1116 case STT_SECTION
: st_info_str
= "STT_SECTION";
1117 case STT_FILE
: st_info_str
= "STT_FILE";
1118 case STT_OBJECT
: st_info_str
= "STT_OBJECT";
1119 case STT_TLS
: st_info_str
= "STT_TLS";
1120 default: st_info_str
= "";
1122 switch (ELF_ST_BIND (isym
->st_info
))
1124 case STB_LOCAL
: st_info_stb_str
= "STB_LOCAL";
1125 case STB_GLOBAL
: st_info_stb_str
= "STB_GLOBAL";
1126 default: st_info_stb_str
= "";
1128 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1130 case STV_DEFAULT
: st_other_str
= "STV_DEFAULT";
1131 case STV_INTERNAL
: st_other_str
= "STV_INTERNAL";
1132 case STV_PROTECTED
: st_other_str
= "STV_PROTECTED";
1133 default: st_other_str
= "";
1135 switch (isym
->st_shndx
)
1137 case SHN_ABS
: st_shndx_str
= "SHN_ABS";
1138 case SHN_COMMON
: st_shndx_str
= "SHN_COMMON";
1139 case SHN_UNDEF
: st_shndx_str
= "SHN_UNDEF";
1140 default: st_shndx_str
= "";
1144 free (internal_syms
);
1146 free (external_syms
);
1150 rl78_get_reloc (long reloc
)
1152 if (0 <= reloc
&& reloc
< R_RL78_max
)
1153 return rl78_elf_howto_table
[reloc
].name
;
1159 /* support PLT for 16-bit references to 24-bit functions. */
1161 /* We support 16-bit pointers to code above 64k by generating a thunk
1162 below 64k containing a JMP instruction to the final address. */
1165 rl78_elf_check_relocs
1167 struct bfd_link_info
* info
,
1169 const Elf_Internal_Rela
* relocs
)
1171 Elf_Internal_Shdr
* symtab_hdr
;
1172 struct elf_link_hash_entry
** sym_hashes
;
1173 const Elf_Internal_Rela
* rel
;
1174 const Elf_Internal_Rela
* rel_end
;
1175 bfd_vma
*local_plt_offsets
;
1179 if (info
->relocatable
)
1182 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1183 sym_hashes
= elf_sym_hashes (abfd
);
1184 local_plt_offsets
= elf_local_got_offsets (abfd
);
1186 dynobj
= elf_hash_table(info
)->dynobj
;
1188 rel_end
= relocs
+ sec
->reloc_count
;
1189 for (rel
= relocs
; rel
< rel_end
; rel
++)
1191 struct elf_link_hash_entry
*h
;
1192 unsigned long r_symndx
;
1195 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1196 if (r_symndx
< symtab_hdr
->sh_info
)
1200 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1201 while (h
->root
.type
== bfd_link_hash_indirect
1202 || h
->root
.type
== bfd_link_hash_warning
)
1203 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1205 /* PR15323, ref flags aren't set for references in the same
1207 h
->root
.non_ir_ref
= 1;
1210 switch (ELF32_R_TYPE (rel
->r_info
))
1212 /* This relocation describes a 16-bit pointer to a function.
1213 We may need to allocate a thunk in low memory; reserve memory
1217 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1220 splt
= bfd_get_linker_section (dynobj
, ".plt");
1223 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1224 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
1225 | SEC_READONLY
| SEC_CODE
);
1226 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
1229 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
1235 offset
= &h
->plt
.offset
;
1238 if (local_plt_offsets
== NULL
)
1243 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
1244 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
1245 if (local_plt_offsets
== NULL
)
1247 elf_local_got_offsets (abfd
) = local_plt_offsets
;
1249 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
1250 local_plt_offsets
[i
] = (bfd_vma
) -1;
1252 offset
= &local_plt_offsets
[r_symndx
];
1255 if (*offset
== (bfd_vma
) -1)
1257 *offset
= splt
->size
;
1267 /* This must exist if dynobj is ever set. */
1270 rl78_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
1271 struct bfd_link_info
*info
)
1276 if (!elf_hash_table (info
)->dynamic_sections_created
)
1279 /* As an extra sanity check, verify that all plt entries have been
1280 filled in. However, relaxing might have changed the relocs so
1281 that some plt entries don't get filled in, so we have to skip
1282 this check if we're relaxing. Unfortunately, check_relocs is
1283 called before relaxation. */
1285 if (info
->relax_trip
> 0)
1288 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
1289 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
1291 bfd_byte
*contents
= splt
->contents
;
1292 unsigned int i
, size
= splt
->size
;
1294 for (i
= 0; i
< size
; i
+= 4)
1296 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
1297 BFD_ASSERT (x
!= 0);
1305 rl78_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1306 struct bfd_link_info
*info
)
1311 if (info
->relocatable
)
1314 dynobj
= elf_hash_table (info
)->dynobj
;
1318 splt
= bfd_get_linker_section (dynobj
, ".plt");
1319 BFD_ASSERT (splt
!= NULL
);
1321 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
1322 if (splt
->contents
== NULL
)
1330 /* Handle relaxing. */
1332 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1333 is within the low 64k, remove any entry for it in the plt. */
1335 struct relax_plt_data
1342 rl78_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1344 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1346 if (h
->plt
.offset
!= (bfd_vma
) -1)
1350 if (h
->root
.type
== bfd_link_hash_undefined
1351 || h
->root
.type
== bfd_link_hash_undefweak
)
1354 address
= (h
->root
.u
.def
.section
->output_section
->vma
1355 + h
->root
.u
.def
.section
->output_offset
1356 + h
->root
.u
.def
.value
);
1358 if (valid_16bit_address (address
))
1361 data
->splt
->size
-= 4;
1362 *data
->again
= TRUE
;
1369 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1370 previously had a plt entry, give it a new entry offset. */
1373 rl78_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1375 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1377 if (h
->plt
.offset
!= (bfd_vma
) -1)
1379 h
->plt
.offset
= *entry
;
1387 rl78_elf_relax_plt_section (bfd
*dynobj
,
1389 struct bfd_link_info
*info
,
1392 struct relax_plt_data relax_plt_data
;
1395 /* Assume nothing changes. */
1398 if (info
->relocatable
)
1401 /* We only relax the .plt section at the moment. */
1402 if (dynobj
!= elf_hash_table (info
)->dynobj
1403 || strcmp (splt
->name
, ".plt") != 0)
1406 /* Quick check for an empty plt. */
1407 if (splt
->size
== 0)
1410 /* Map across all global symbols; see which ones happen to
1411 fall in the low 64k. */
1412 relax_plt_data
.splt
= splt
;
1413 relax_plt_data
.again
= again
;
1414 elf_link_hash_traverse (elf_hash_table (info
), rl78_relax_plt_check
,
1417 /* Likewise for local symbols, though that's somewhat less convenient
1418 as we have to walk the list of input bfds and swap in symbol data. */
1419 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1421 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1422 Elf_Internal_Shdr
*symtab_hdr
;
1423 Elf_Internal_Sym
*isymbuf
= NULL
;
1426 if (! local_plt_offsets
)
1429 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1430 if (symtab_hdr
->sh_info
!= 0)
1432 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1433 if (isymbuf
== NULL
)
1434 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1435 symtab_hdr
->sh_info
, 0,
1437 if (isymbuf
== NULL
)
1441 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1443 Elf_Internal_Sym
*isym
;
1447 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1450 isym
= &isymbuf
[idx
];
1451 if (isym
->st_shndx
== SHN_UNDEF
)
1453 else if (isym
->st_shndx
== SHN_ABS
)
1454 tsec
= bfd_abs_section_ptr
;
1455 else if (isym
->st_shndx
== SHN_COMMON
)
1456 tsec
= bfd_com_section_ptr
;
1458 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1460 address
= (tsec
->output_section
->vma
1461 + tsec
->output_offset
1463 if (valid_16bit_address (address
))
1465 local_plt_offsets
[idx
] = -1;
1472 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1474 if (! info
->keep_memory
)
1478 /* Cache the symbols for elf_link_input_bfd. */
1479 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1484 /* If we changed anything, walk the symbols again to reallocate
1485 .plt entry addresses. */
1486 if (*again
&& splt
->size
> 0)
1490 elf_link_hash_traverse (elf_hash_table (info
),
1491 rl78_relax_plt_realloc
, &entry
);
1493 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1495 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1496 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1499 if (! local_plt_offsets
)
1502 for (idx
= 0; idx
< nlocals
; ++idx
)
1503 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1505 local_plt_offsets
[idx
] = entry
;
1514 /* Delete some bytes from a section while relaxing. */
1517 elf32_rl78_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, int count
,
1518 Elf_Internal_Rela
*alignment_rel
, int force_snip
)
1520 Elf_Internal_Shdr
* symtab_hdr
;
1521 unsigned int sec_shndx
;
1522 bfd_byte
* contents
;
1523 Elf_Internal_Rela
* irel
;
1524 Elf_Internal_Rela
* irelend
;
1525 Elf_Internal_Sym
* isym
;
1526 Elf_Internal_Sym
* isymend
;
1528 unsigned int symcount
;
1529 struct elf_link_hash_entry
** sym_hashes
;
1530 struct elf_link_hash_entry
** end_hashes
;
1535 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1537 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1539 /* The deletion must stop at the next alignment boundary, if
1540 ALIGNMENT_REL is non-NULL. */
1543 toaddr
= alignment_rel
->r_offset
;
1545 irel
= elf_section_data (sec
)->relocs
;
1546 irelend
= irel
+ sec
->reloc_count
;
1548 /* Actually delete the bytes. */
1549 memmove (contents
+ addr
, contents
+ addr
+ count
,
1550 (size_t) (toaddr
- addr
- count
));
1552 /* If we don't have an alignment marker to worry about, we can just
1553 shrink the section. Otherwise, we have to fill in the newly
1554 created gap with NOP insns (0x03). */
1558 memset (contents
+ toaddr
- count
, 0x03, count
);
1560 /* Adjust all the relocs. */
1561 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1563 /* Get the new reloc address. */
1564 if (irel
->r_offset
> addr
1565 && (irel
->r_offset
< toaddr
1566 || (force_snip
&& irel
->r_offset
== toaddr
)))
1567 irel
->r_offset
-= count
;
1569 /* If we see an ALIGN marker at the end of the gap, we move it
1570 to the beginning of the gap, since marking these gaps is what
1572 if (irel
->r_offset
== toaddr
1573 && ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
1574 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
1575 irel
->r_offset
-= count
;
1578 /* Adjust the local symbols defined in this section. */
1579 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1580 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1581 isymend
= isym
+ symtab_hdr
->sh_info
;
1583 for (; isym
< isymend
; isym
++)
1585 /* If the symbol is in the range of memory we just moved, we
1586 have to adjust its value. */
1587 if (isym
->st_shndx
== sec_shndx
1588 && isym
->st_value
> addr
1589 && isym
->st_value
< toaddr
)
1590 isym
->st_value
-= count
;
1592 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1593 *end* is in the moved bytes but it's *start* isn't), then we
1594 must adjust its size. */
1595 if (isym
->st_shndx
== sec_shndx
1596 && isym
->st_value
< addr
1597 && isym
->st_value
+ isym
->st_size
> addr
1598 && isym
->st_value
+ isym
->st_size
< toaddr
)
1599 isym
->st_size
-= count
;
1602 /* Now adjust the global symbols defined in this section. */
1603 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1604 - symtab_hdr
->sh_info
);
1605 sym_hashes
= elf_sym_hashes (abfd
);
1606 end_hashes
= sym_hashes
+ symcount
;
1608 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1610 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1612 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1613 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1614 && sym_hash
->root
.u
.def
.section
== sec
)
1616 /* As above, adjust the value if needed. */
1617 if (sym_hash
->root
.u
.def
.value
> addr
1618 && sym_hash
->root
.u
.def
.value
< toaddr
)
1619 sym_hash
->root
.u
.def
.value
-= count
;
1621 /* As above, adjust the size if needed. */
1622 if (sym_hash
->root
.u
.def
.value
< addr
1623 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1624 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1625 sym_hash
->size
-= count
;
1632 /* Used to sort relocs by address. If relocs have the same address,
1633 we maintain their relative order, except that R_RL78_RH_RELAX
1634 alignment relocs must be the first reloc for any given address. */
1637 reloc_bubblesort (Elf_Internal_Rela
* r
, int count
)
1641 bfd_boolean swappit
;
1643 /* This is almost a classic bubblesort. It's the slowest sort, but
1644 we're taking advantage of the fact that the relocations are
1645 mostly in order already (the assembler emits them that way) and
1646 we need relocs with the same address to remain in the same
1652 for (i
= 0; i
< count
- 1; i
++)
1654 if (r
[i
].r_offset
> r
[i
+ 1].r_offset
)
1656 else if (r
[i
].r_offset
< r
[i
+ 1].r_offset
)
1658 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1659 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ALIGN
))
1661 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RL78_RH_RELAX
1662 && (r
[i
+ 1].r_addend
& RL78_RELAXA_ELIGN
)
1663 && !(ELF32_R_TYPE (r
[i
].r_info
) == R_RL78_RH_RELAX
1664 && (r
[i
].r_addend
& RL78_RELAXA_ALIGN
)))
1671 Elf_Internal_Rela tmp
;
1676 /* If we do move a reloc back, re-scan to see if it
1677 needs to be moved even further back. This avoids
1678 most of the O(n^2) behavior for our cases. */
1688 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1689 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1690 lrel, abfd, sec, link_info, scale)
1693 rl78_offset_for_reloc (bfd
* abfd
,
1694 Elf_Internal_Rela
* rel
,
1695 Elf_Internal_Shdr
* symtab_hdr
,
1696 Elf_External_Sym_Shndx
* shndx_buf ATTRIBUTE_UNUSED
,
1697 Elf_Internal_Sym
* intsyms
,
1698 Elf_Internal_Rela
** lrel
,
1700 asection
* input_section
,
1701 struct bfd_link_info
* info
,
1705 bfd_reloc_status_type r
;
1709 /* REL is the first of 1..N relocations. We compute the symbol
1710 value for each relocation, then combine them if needed. LREL
1711 gets a pointer to the last relocation used. */
1716 /* Get the value of the symbol referred to by the reloc. */
1717 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1719 /* A local symbol. */
1720 Elf_Internal_Sym
*isym
;
1723 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1725 if (isym
->st_shndx
== SHN_UNDEF
)
1726 ssec
= bfd_und_section_ptr
;
1727 else if (isym
->st_shndx
== SHN_ABS
)
1728 ssec
= bfd_abs_section_ptr
;
1729 else if (isym
->st_shndx
== SHN_COMMON
)
1730 ssec
= bfd_com_section_ptr
;
1732 ssec
= bfd_section_from_elf_index (abfd
,
1735 /* Initial symbol value. */
1736 symval
= isym
->st_value
;
1738 /* GAS may have made this symbol relative to a section, in
1739 which case, we have to add the addend to find the
1741 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
1742 symval
+= rel
->r_addend
;
1746 if ((ssec
->flags
& SEC_MERGE
)
1747 && ssec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1748 symval
= _bfd_merged_section_offset (abfd
, & ssec
,
1749 elf_section_data (ssec
)->sec_info
,
1753 /* Now make the offset relative to where the linker is putting it. */
1756 ssec
->output_section
->vma
+ ssec
->output_offset
;
1758 symval
+= rel
->r_addend
;
1763 struct elf_link_hash_entry
* h
;
1765 /* An external symbol. */
1766 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1767 h
= elf_sym_hashes (abfd
)[indx
];
1768 BFD_ASSERT (h
!= NULL
);
1770 if (h
->root
.type
!= bfd_link_hash_defined
1771 && h
->root
.type
!= bfd_link_hash_defweak
)
1773 /* This appears to be a reference to an undefined
1774 symbol. Just ignore it--it will be caught by the
1775 regular reloc processing. */
1781 symval
= (h
->root
.u
.def
.value
1782 + h
->root
.u
.def
.section
->output_section
->vma
1783 + h
->root
.u
.def
.section
->output_offset
);
1785 symval
+= rel
->r_addend
;
1788 switch (ELF32_R_TYPE (rel
->r_info
))
1791 RL78_STACK_PUSH (symval
);
1795 RL78_STACK_POP (tmp1
);
1797 RL78_STACK_PUSH (tmp1
);
1801 RL78_STACK_POP (tmp1
);
1802 RL78_STACK_POP (tmp2
);
1804 RL78_STACK_PUSH (tmp1
);
1808 RL78_STACK_POP (tmp1
);
1809 RL78_STACK_POP (tmp2
);
1811 RL78_STACK_PUSH (tmp2
);
1815 RL78_STACK_POP (tmp1
);
1816 RL78_STACK_POP (tmp2
);
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 (tmp1
);
1836 RL78_STACK_POP (tmp1
);
1837 RL78_STACK_POP (tmp2
);
1839 RL78_STACK_PUSH (tmp1
);
1842 case R_RL78_OPsctsize
:
1843 RL78_STACK_PUSH (input_section
->size
);
1846 case R_RL78_OPscttop
:
1847 RL78_STACK_PUSH (input_section
->output_section
->vma
);
1851 RL78_STACK_POP (tmp1
);
1852 RL78_STACK_POP (tmp2
);
1854 RL78_STACK_PUSH (tmp1
);
1858 RL78_STACK_POP (tmp1
);
1859 RL78_STACK_POP (tmp2
);
1861 RL78_STACK_PUSH (tmp1
);
1865 RL78_STACK_POP (tmp1
);
1866 RL78_STACK_POP (tmp2
);
1868 RL78_STACK_PUSH (tmp1
);
1872 RL78_STACK_POP (tmp1
);
1874 RL78_STACK_PUSH (tmp1
);
1878 RL78_STACK_POP (tmp1
);
1879 RL78_STACK_POP (tmp2
);
1881 RL78_STACK_PUSH (tmp1
);
1884 case R_RL78_OPromtop
:
1885 RL78_STACK_PUSH (get_romstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
1888 case R_RL78_OPramtop
:
1889 RL78_STACK_PUSH (get_ramstart (&r
, info
, input_bfd
, input_section
, rel
->r_offset
));
1892 case R_RL78_DIR16UL
:
1894 case R_RL78_ABS16UL
:
1897 RL78_STACK_POP (symval
);
1903 case R_RL78_DIR16UW
:
1905 case R_RL78_ABS16UW
:
1908 RL78_STACK_POP (symval
);
1916 RL78_STACK_POP (symval
);
1927 int prefix
; /* or -1 for "no prefix" */
1928 int insn
; /* or -1 for "end of list" */
1929 int insn_for_saddr
; /* or -1 for "no alternative" */
1930 int insn_for_sfr
; /* or -1 for "no alternative" */
1931 } relax_addr16
[] = {
1932 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1933 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1934 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1935 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1937 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1938 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1939 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1940 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1941 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1942 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1943 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1944 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1946 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1947 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1948 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1949 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1950 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1952 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1953 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1954 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1955 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1957 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1958 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1959 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1961 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1962 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1963 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1964 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1965 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1966 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1968 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1970 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1971 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1972 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1973 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1974 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1975 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1976 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1977 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1979 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1980 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1981 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1982 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1983 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1984 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1985 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1986 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1991 /* Relax one section. */
1994 rl78_elf_relax_section
1997 struct bfd_link_info
* link_info
,
1998 bfd_boolean
* again
)
2000 Elf_Internal_Shdr
* symtab_hdr
;
2001 Elf_Internal_Shdr
* shndx_hdr
;
2002 Elf_Internal_Rela
* internal_relocs
;
2003 Elf_Internal_Rela
* free_relocs
= NULL
;
2004 Elf_Internal_Rela
* irel
;
2005 Elf_Internal_Rela
* srel
;
2006 Elf_Internal_Rela
* irelend
;
2007 Elf_Internal_Rela
* next_alignment
;
2008 bfd_byte
* contents
= NULL
;
2009 bfd_byte
* free_contents
= NULL
;
2010 Elf_Internal_Sym
* intsyms
= NULL
;
2011 Elf_Internal_Sym
* free_intsyms
= NULL
;
2012 Elf_External_Sym_Shndx
* shndx_buf
= NULL
;
2014 bfd_vma symval ATTRIBUTE_UNUSED
= 0;
2015 int pcrel ATTRIBUTE_UNUSED
= 0;
2016 int code ATTRIBUTE_UNUSED
= 0;
2017 int section_alignment_glue
;
2020 if (abfd
== elf_hash_table (link_info
)->dynobj
2021 && strcmp (sec
->name
, ".plt") == 0)
2022 return rl78_elf_relax_plt_section (abfd
, sec
, link_info
, again
);
2024 /* Assume nothing changes. */
2027 /* We don't have to do anything for a relocatable link, if
2028 this section does not have relocs, or if this is not a
2030 if (link_info
->relocatable
2031 || (sec
->flags
& SEC_RELOC
) == 0
2032 || sec
->reloc_count
== 0
2033 || (sec
->flags
& SEC_CODE
) == 0)
2036 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2037 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2039 /* Get the section contents. */
2040 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2041 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2042 /* Go get them off disk. */
2045 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2047 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2050 /* Read this BFD's symbols. */
2051 /* Get cached copy if it exists. */
2052 if (symtab_hdr
->contents
!= NULL
)
2053 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2056 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
2057 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
2060 if (shndx_hdr
->sh_size
!= 0)
2064 amt
= symtab_hdr
->sh_info
;
2065 amt
*= sizeof (Elf_External_Sym_Shndx
);
2066 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
2067 if (shndx_buf
== NULL
)
2069 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
2070 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
2072 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
2075 /* Get a copy of the native relocations. */
2076 internal_relocs
= (_bfd_elf_link_read_relocs
2077 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2078 link_info
->keep_memory
));
2079 if (internal_relocs
== NULL
)
2081 if (! link_info
->keep_memory
)
2082 free_relocs
= internal_relocs
;
2084 /* The RL_ relocs must be just before the operand relocs they go
2085 with, so we must sort them to guarantee this. We use bubblesort
2086 instead of qsort so we can guarantee that relocs with the same
2087 address remain in the same relative order. */
2088 reloc_bubblesort (internal_relocs
, sec
->reloc_count
);
2090 /* Walk through them looking for relaxing opportunities. */
2091 irelend
= internal_relocs
+ sec
->reloc_count
;
2094 /* This will either be NULL or a pointer to the next alignment
2096 next_alignment
= internal_relocs
;
2098 /* We calculate worst case shrinkage caused by alignment directives.
2099 No fool-proof, but better than either ignoring the problem or
2100 doing heavy duty analysis of all the alignment markers in all
2102 section_alignment_glue
= 0;
2103 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2104 if (ELF32_R_TYPE (irel
->r_info
) == R_RL78_RH_RELAX
2105 && irel
->r_addend
& RL78_RELAXA_ALIGN
)
2107 int this_glue
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2109 if (section_alignment_glue
< this_glue
)
2110 section_alignment_glue
= this_glue
;
2112 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2114 section_alignment_glue
*= 2;
2116 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2118 unsigned char *insn
;
2121 /* The insns we care about are all marked with one of these. */
2122 if (ELF32_R_TYPE (irel
->r_info
) != R_RL78_RH_RELAX
)
2125 if (irel
->r_addend
& RL78_RELAXA_ALIGN
2126 || next_alignment
== internal_relocs
)
2128 /* When we delete bytes, we need to maintain all the alignments
2129 indicated. In addition, we need to be careful about relaxing
2130 jumps across alignment boundaries - these displacements
2131 *grow* when we delete bytes. For now, don't shrink
2132 displacements across an alignment boundary, just in case.
2133 Note that this only affects relocations to the same
2135 next_alignment
+= 2;
2136 while (next_alignment
< irelend
2137 && (ELF32_R_TYPE (next_alignment
->r_info
) != R_RL78_RH_RELAX
2138 || !(next_alignment
->r_addend
& RL78_RELAXA_ELIGN
)))
2140 if (next_alignment
>= irelend
|| next_alignment
->r_offset
== 0)
2141 next_alignment
= NULL
;
2144 /* When we hit alignment markers, see if we've shrunk enough
2145 before them to reduce the gap without violating the alignment
2147 if (irel
->r_addend
& RL78_RELAXA_ALIGN
)
2149 /* At this point, the next relocation *should* be the ELIGN
2151 Elf_Internal_Rela
*erel
= irel
+ 1;
2152 unsigned int alignment
, nbytes
;
2154 if (ELF32_R_TYPE (erel
->r_info
) != R_RL78_RH_RELAX
)
2156 if (!(erel
->r_addend
& RL78_RELAXA_ELIGN
))
2159 alignment
= 1 << (irel
->r_addend
& RL78_RELAXA_ANUM
);
2161 if (erel
->r_offset
- irel
->r_offset
< alignment
)
2164 nbytes
= erel
->r_offset
- irel
->r_offset
;
2165 nbytes
/= alignment
;
2166 nbytes
*= alignment
;
2168 elf32_rl78_relax_delete_bytes (abfd
, sec
, erel
->r_offset
-nbytes
, nbytes
, next_alignment
,
2169 erel
->r_offset
== sec
->size
);
2175 if (irel
->r_addend
& RL78_RELAXA_ELIGN
)
2178 insn
= contents
+ irel
->r_offset
;
2180 nrelocs
= irel
->r_addend
& RL78_RELAXA_RNUM
;
2182 /* At this point, we have an insn that is a candidate for linker
2183 relaxation. There are NRELOCS relocs following that may be
2184 relaxed, although each reloc may be made of more than one
2185 reloc entry (such as gp-rel symbols). */
2187 /* Get the value of the symbol referred to by the reloc. Just
2188 in case this is the last reloc in the list, use the RL's
2189 addend to choose between this reloc (no addend) or the next
2190 (yes addend, which means at least one following reloc). */
2192 /* srel points to the "current" reloction for this insn -
2193 actually the last reloc for a given operand, which is the one
2194 we need to update. We check the relaxations in the same
2195 order that the relocations happen, so we'll just push it
2199 pc
= sec
->output_section
->vma
+ sec
->output_offset
2203 BFD_ASSERT (nrelocs > 0); \
2204 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2205 pcrel = symval - pc + srel->r_addend; \
2208 #define SNIPNR(offset, nbytes) \
2209 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2210 #define SNIP(offset, nbytes, newtype) \
2211 SNIPNR (offset, nbytes); \
2212 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2214 /* The order of these bit tests must match the order that the
2215 relocs appear in. Since we sorted those by offset, we can
2218 /*----------------------------------------------------------------------*/
2219 /* EF ad BR $rel8 pcrel
2220 ED al ah BR !abs16 abs
2221 EE al ah BR $!rel16 pcrel
2222 EC al ah as BR !!abs20 abs
2224 FD al ah CALL !abs16 abs
2225 FE al ah CALL $!rel16 pcrel
2226 FC al ah as CALL !!abs20 abs
2234 61 C8 EF ad SKC ; BR $rel8
2235 61 D8 EF ad SKNC ; BR $rel8
2236 61 E8 EF ad SKZ ; BR $rel8
2237 61 F8 EF ad SKNZ ; BR $rel8
2238 61 E3 EF ad SKH ; BR $rel8
2239 61 F3 EF ad SKNH ; BR $rel8
2242 if (irel
->r_addend
& RL78_RELAXA_BRA
)
2244 /* SKIP opcodes that skip non-branches will have a relax tag
2245 but no corresponding symbol to relax against; we just
2247 if (irel
->r_addend
& RL78_RELAXA_RNUM
)
2254 case 0xec: /* BR !!abs20 */
2261 SNIP (2, 2, R_RL78_DIR8S_PCREL
);
2264 else if (symval
< 65536)
2267 insn
[1] = symval
& 0xff;
2268 insn
[2] = symval
>> 8;
2269 SNIP (2, 1, R_RL78_DIR16S
);
2272 else if (pcrel
< 32767
2276 insn
[1] = pcrel
& 0xff;
2277 insn
[2] = pcrel
>> 8;
2278 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2283 case 0xee: /* BR $!pcrel16 */
2284 case 0xed: /* BR $!abs16 */
2290 SNIP (2, 1, R_RL78_DIR8S_PCREL
);
2295 case 0xfc: /* CALL !!abs20 */
2299 insn
[1] = symval
& 0xff;
2300 insn
[2] = symval
>> 8;
2301 SNIP (2, 1, R_RL78_DIR16S
);
2304 else if (pcrel
< 32767
2308 insn
[1] = pcrel
& 0xff;
2309 insn
[2] = pcrel
>> 8;
2310 SNIP (2, 1, R_RL78_DIR16S_PCREL
);
2315 case 0x61: /* PREFIX */
2316 /* For SKIP/BR, we change the BR opcode and delete the
2317 SKIP. That way, we don't have to find and change the
2318 relocation for the BR. */
2319 /* Note that, for the case where we're skipping some
2320 other insn, we have no "other" reloc but that's safe
2324 case 0xc8: /* SKC */
2325 if (insn
[2] == 0xef)
2327 insn
[2] = 0xde; /* BNC */
2332 case 0xd8: /* SKNC */
2333 if (insn
[2] == 0xef)
2335 insn
[2] = 0xdc; /* BC */
2340 case 0xe8: /* SKZ */
2341 if (insn
[2] == 0xef)
2343 insn
[2] = 0xdf; /* BNZ */
2348 case 0xf8: /* SKNZ */
2349 if (insn
[2] == 0xef)
2351 insn
[2] = 0xdd; /* BZ */
2356 case 0xe3: /* SKH */
2357 if (insn
[2] == 0xef)
2359 insn
[2] = 0xd3; /* BNH */
2360 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2364 case 0xf3: /* SKNH */
2365 if (insn
[2] == 0xef)
2367 insn
[2] = 0xc3; /* BH */
2368 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2377 if (irel
->r_addend
& RL78_RELAXA_ADDR16
)
2379 /*----------------------------------------------------------------------*/
2380 /* Some insns have both a 16-bit address operand and an 8-bit
2381 variant if the address is within a special range:
2383 Address 16-bit operand SADDR range SFR range
2384 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2385 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2387 The RELAX_ADDR16[] array has the insn encodings for the
2388 16-bit operand version, as well as the SFR and SADDR
2389 variants. We only need to replace the encodings and
2392 Note: we intentionally do not attempt to decode and skip
2393 any ES: prefix, as adding ES: means the addr16 (likely)
2394 no longer points to saddr/sfr space.
2404 if (0xffe20 <= symval
&& symval
<= 0xfffff)
2407 is_saddr
= (0xffe20 <= symval
&& symval
<= 0xfff1f);
2408 is_sfr
= (0xfff00 <= symval
&& symval
<= 0xfffff);
2410 for (idx
= 0; relax_addr16
[idx
].insn
!= -1; idx
++)
2412 if (relax_addr16
[idx
].prefix
!= -1
2413 && insn
[0] == relax_addr16
[idx
].prefix
2414 && insn
[1] == relax_addr16
[idx
].insn
)
2418 else if (relax_addr16
[idx
].prefix
== -1
2419 && insn
[0] == relax_addr16
[idx
].insn
)
2426 /* We have a matched insn, and poff is 0 or 1 depending
2427 on the base pattern size. */
2429 if (is_sfr
&& relax_addr16
[idx
].insn_for_sfr
!= -1)
2431 insn
[poff
] = relax_addr16
[idx
].insn_for_sfr
;
2432 SNIP (poff
+2, 1, R_RL78_RH_SFR
);
2435 else if (is_saddr
&& relax_addr16
[idx
].insn_for_saddr
!= -1)
2437 insn
[poff
] = relax_addr16
[idx
].insn_for_saddr
;
2438 SNIP (poff
+2, 1, R_RL78_RH_SADDR
);
2445 /*----------------------------------------------------------------------*/
2452 if (free_relocs
!= NULL
)
2455 if (free_contents
!= NULL
)
2456 free (free_contents
);
2458 if (shndx_buf
!= NULL
)
2460 shndx_hdr
->contents
= NULL
;
2464 if (free_intsyms
!= NULL
)
2465 free (free_intsyms
);
2472 #define ELF_ARCH bfd_arch_rl78
2473 #define ELF_MACHINE_CODE EM_RL78
2474 #define ELF_MAXPAGESIZE 0x1000
2476 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2477 #define TARGET_LITTLE_NAME "elf32-rl78"
2479 #define elf_info_to_howto_rel NULL
2480 #define elf_info_to_howto rl78_info_to_howto_rela
2481 #define elf_backend_object_p rl78_elf_object_p
2482 #define elf_backend_relocate_section rl78_elf_relocate_section
2483 #define elf_symbol_leading_char ('_')
2484 #define elf_backend_can_gc_sections 1
2486 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2487 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2488 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2489 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2490 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2492 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2493 #define elf_backend_check_relocs rl78_elf_check_relocs
2494 #define elf_backend_always_size_sections \
2495 rl78_elf_always_size_sections
2496 #define elf_backend_finish_dynamic_sections \
2497 rl78_elf_finish_dynamic_sections
2499 #include "elf32-target.h"