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
RL78_STACK_POP (tmp2);
814
RL78_STACK_POP (tmp1);
816
RL78_STACK_PUSH (tmp2);
824
RL78_STACK_POP (tmp2);
825
RL78_STACK_POP (tmp1);
827
RL78_STACK_PUSH (tmp1);
835
RL78_STACK_POP (tmp2);
836
RL78_STACK_POP (tmp1);
838
RL78_STACK_PUSH (tmp1);
846
RL78_STACK_POP (tmp2);
847
RL78_STACK_POP (tmp1);
849
RL78_STACK_PUSH (tmp1);
857
RL78_STACK_POP (tmp2);
858
RL78_STACK_POP (tmp1);
860
RL78_STACK_PUSH (tmp1);
864
case R_RL78_OPsctsize:
865
RL78_STACK_PUSH (input_section->size);
868
case R_RL78_OPscttop:
869
RL78_STACK_PUSH (input_section->output_section->vma);
876
RL78_STACK_POP (tmp2);
877
RL78_STACK_POP (tmp1);
879
RL78_STACK_PUSH (tmp1);
887
RL78_STACK_POP (tmp2);
888
RL78_STACK_POP (tmp1);
890
RL78_STACK_PUSH (tmp1);
898
RL78_STACK_POP (tmp2);
899
RL78_STACK_POP (tmp1);
901
RL78_STACK_PUSH (tmp1);
909
RL78_STACK_POP (tmp);
911
RL78_STACK_PUSH (tmp);
919
RL78_STACK_POP (tmp2);
920
RL78_STACK_POP (tmp1);
922
RL78_STACK_PUSH (tmp1);
926
case R_RL78_OPromtop:
927
RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
930
case R_RL78_OPramtop:
931
RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
935
r = bfd_reloc_notsupported;
939
if (r != bfd_reloc_ok)
941
const char * msg = NULL;
945
case bfd_reloc_overflow:
946
/* Catch the case of a missing function declaration
947
and emit a more helpful error message. */
948
if (r_type == R_RL78_DIR24S_PCREL)
949
msg = _("%B(%A): error: call to undefined function '%s'");
951
r = info->callbacks->reloc_overflow
952
(info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
953
input_bfd, input_section, rel->r_offset);
956
case bfd_reloc_undefined:
957
r = info->callbacks->undefined_symbol
958
(info, name, input_bfd, input_section, rel->r_offset,
962
case bfd_reloc_other:
963
msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
966
case bfd_reloc_outofrange:
967
msg = _("%B(%A): internal error: out of range error");
970
case bfd_reloc_notsupported:
971
msg = _("%B(%A): internal error: unsupported relocation error");
974
case bfd_reloc_dangerous:
975
msg = _("%B(%A): internal error: dangerous relocation");
979
msg = _("%B(%A): internal error: unknown error");
984
_bfd_error_handler (msg, input_bfd, input_section, name);
994
/* Function to set the ELF flag bits. */
997
rl78_elf_set_private_flags (bfd * abfd, flagword flags)
999
elf_elfheader (abfd)->e_flags = flags;
1000
elf_flags_init (abfd) = TRUE;
1004
static bfd_boolean no_warn_mismatch = FALSE;
1006
void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1009
bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1011
no_warn_mismatch = user_no_warn_mismatch;
1014
/* Merge backend specific data from an object file to the output
1015
object file when linking. */
1018
rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1021
bfd_boolean error = FALSE;
1023
new_flags = elf_elfheader (ibfd)->e_flags;
1025
if (!elf_flags_init (obfd))
1027
/* First call, no flags set. */
1028
elf_flags_init (obfd) = TRUE;
1029
elf_elfheader (obfd)->e_flags = new_flags;
1036
rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1038
FILE * file = (FILE *) ptr;
1041
BFD_ASSERT (abfd != NULL && ptr != NULL);
1043
/* Print normal ELF private data. */
1044
_bfd_elf_print_private_bfd_data (abfd, ptr);
1046
flags = elf_elfheader (abfd)->e_flags;
1047
fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1053
/* Return the MACH for an e_flags value. */
1056
elf32_rl78_machine (bfd * abfd)
1058
if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1059
return bfd_mach_rl78;
1065
rl78_elf_object_p (bfd * abfd)
1067
bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1068
elf32_rl78_machine (abfd));
1074
rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1077
Elf_Internal_Sym * isymbuf;
1078
Elf_Internal_Sym * isymend;
1079
Elf_Internal_Sym * isym;
1080
Elf_Internal_Shdr * symtab_hdr;
1081
bfd_boolean free_internal = FALSE, free_external = FALSE;
1083
char * st_info_stb_str;
1084
char * st_other_str;
1085
char * st_shndx_str;
1087
if (! internal_syms)
1089
internal_syms = bfd_malloc (1000);
1092
if (! external_syms)
1094
external_syms = bfd_malloc (1000);
1098
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1099
locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1101
isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1102
symtab_hdr->sh_info, 0,
1103
internal_syms, external_syms, NULL);
1105
isymbuf = internal_syms;
1106
isymend = isymbuf + locsymcount;
1108
for (isym = isymbuf ; isym < isymend ; isym++)
1110
switch (ELF_ST_TYPE (isym->st_info))
1112
case STT_FUNC: st_info_str = "STT_FUNC";
1113
case STT_SECTION: st_info_str = "STT_SECTION";
1114
case STT_FILE: st_info_str = "STT_FILE";
1115
case STT_OBJECT: st_info_str = "STT_OBJECT";
1116
case STT_TLS: st_info_str = "STT_TLS";
1117
default: st_info_str = "";
1119
switch (ELF_ST_BIND (isym->st_info))
1121
case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1122
case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1123
default: st_info_stb_str = "";
1125
switch (ELF_ST_VISIBILITY (isym->st_other))
1127
case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1128
case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1129
case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1130
default: st_other_str = "";
1132
switch (isym->st_shndx)
1134
case SHN_ABS: st_shndx_str = "SHN_ABS";
1135
case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1136
case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1137
default: st_shndx_str = "";
1141
free (internal_syms);
1143
free (external_syms);
1147
rl78_get_reloc (long reloc)
1149
if (0 <= reloc && reloc < R_RL78_max)
1150
return rl78_elf_howto_table[reloc].name;
1156
/* support PLT for 16-bit references to 24-bit functions. */
1158
/* We support 16-bit pointers to code above 64k by generating a thunk
1159
below 64k containing a JMP instruction to the final address. */
1162
rl78_elf_check_relocs
1164
struct bfd_link_info * info,
1166
const Elf_Internal_Rela * relocs)
1168
Elf_Internal_Shdr * symtab_hdr;
1169
struct elf_link_hash_entry ** sym_hashes;
1170
const Elf_Internal_Rela * rel;
1171
const Elf_Internal_Rela * rel_end;
1172
bfd_vma *local_plt_offsets;
1176
if (info->relocatable)
1179
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1180
sym_hashes = elf_sym_hashes (abfd);
1181
local_plt_offsets = elf_local_got_offsets (abfd);
1183
dynobj = elf_hash_table(info)->dynobj;
1185
rel_end = relocs + sec->reloc_count;
1186
for (rel = relocs; rel < rel_end; rel++)
1188
struct elf_link_hash_entry *h;
1189
unsigned long r_symndx;
1192
r_symndx = ELF32_R_SYM (rel->r_info);
1193
if (r_symndx < symtab_hdr->sh_info)
1197
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1198
while (h->root.type == bfd_link_hash_indirect
1199
|| h->root.type == bfd_link_hash_warning)
1200
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1202
/* PR15323, ref flags aren't set for references in the same
1204
h->root.non_ir_ref = 1;
1207
switch (ELF32_R_TYPE (rel->r_info))
1209
/* This relocation describes a 16-bit pointer to a function.
1210
We may need to allocate a thunk in low memory; reserve memory
1214
elf_hash_table (info)->dynobj = dynobj = abfd;
1217
splt = bfd_get_linker_section (dynobj, ".plt");
1220
flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1221
| SEC_IN_MEMORY | SEC_LINKER_CREATED
1222
| SEC_READONLY | SEC_CODE);
1223
splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1226
|| ! bfd_set_section_alignment (dynobj, splt, 1))
1232
offset = &h->plt.offset;
1235
if (local_plt_offsets == NULL)
1240
size = symtab_hdr->sh_info * sizeof (bfd_vma);
1241
local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1242
if (local_plt_offsets == NULL)
1244
elf_local_got_offsets (abfd) = local_plt_offsets;
1246
for (i = 0; i < symtab_hdr->sh_info; i++)
1247
local_plt_offsets[i] = (bfd_vma) -1;
1249
offset = &local_plt_offsets[r_symndx];
1252
if (*offset == (bfd_vma) -1)
1254
*offset = splt->size;
1264
/* This must exist if dynobj is ever set. */
1267
rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1268
struct bfd_link_info *info)
1273
if (!elf_hash_table (info)->dynamic_sections_created)
1276
/* As an extra sanity check, verify that all plt entries have been
1277
filled in. However, relaxing might have changed the relocs so
1278
that some plt entries don't get filled in, so we have to skip
1279
this check if we're relaxing. Unfortunately, check_relocs is
1280
called before relaxation. */
1282
if (info->relax_trip > 0)
1285
if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1286
&& (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
1288
bfd_byte *contents = splt->contents;
1289
unsigned int i, size = splt->size;
1291
for (i = 0; i < size; i += 4)
1293
unsigned int x = bfd_get_32 (dynobj, contents + i);
1294
BFD_ASSERT (x != 0);
1302
rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1303
struct bfd_link_info *info)
1308
if (info->relocatable)
1311
dynobj = elf_hash_table (info)->dynobj;
1315
splt = bfd_get_linker_section (dynobj, ".plt");
1316
BFD_ASSERT (splt != NULL);
1318
splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1319
if (splt->contents == NULL)
1327
/* Handle relaxing. */
1329
/* A subroutine of rl78_elf_relax_section. If the global symbol H
1330
is within the low 64k, remove any entry for it in the plt. */
1332
struct relax_plt_data
1339
rl78_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
1341
struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1343
if (h->plt.offset != (bfd_vma) -1)
1347
if (h->root.type == bfd_link_hash_undefined
1348
|| h->root.type == bfd_link_hash_undefweak)
1351
address = (h->root.u.def.section->output_section->vma
1352
+ h->root.u.def.section->output_offset
1353
+ h->root.u.def.value);
1355
if (valid_16bit_address (address))
1358
data->splt->size -= 4;
1359
*data->again = TRUE;
1366
/* A subroutine of rl78_elf_relax_section. If the global symbol H
1367
previously had a plt entry, give it a new entry offset. */
1370
rl78_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
1372
bfd_vma *entry = (bfd_vma *) xdata;
1374
if (h->plt.offset != (bfd_vma) -1)
1376
h->plt.offset = *entry;
1384
rl78_elf_relax_plt_section (bfd *dynobj,
1386
struct bfd_link_info *info,
1389
struct relax_plt_data relax_plt_data;
1392
/* Assume nothing changes. */
1395
if (info->relocatable)
1398
/* We only relax the .plt section at the moment. */
1399
if (dynobj != elf_hash_table (info)->dynobj
1400
|| strcmp (splt->name, ".plt") != 0)
1403
/* Quick check for an empty plt. */
1404
if (splt->size == 0)
1407
/* Map across all global symbols; see which ones happen to
1408
fall in the low 64k. */
1409
relax_plt_data.splt = splt;
1410
relax_plt_data.again = again;
1411
elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1414
/* Likewise for local symbols, though that's somewhat less convenient
1415
as we have to walk the list of input bfds and swap in symbol data. */
1416
for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1418
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1419
Elf_Internal_Shdr *symtab_hdr;
1420
Elf_Internal_Sym *isymbuf = NULL;
1423
if (! local_plt_offsets)
1426
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1427
if (symtab_hdr->sh_info != 0)
1429
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1430
if (isymbuf == NULL)
1431
isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1432
symtab_hdr->sh_info, 0,
1434
if (isymbuf == NULL)
1438
for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1440
Elf_Internal_Sym *isym;
1444
if (local_plt_offsets[idx] == (bfd_vma) -1)
1447
isym = &isymbuf[idx];
1448
if (isym->st_shndx == SHN_UNDEF)
1450
else if (isym->st_shndx == SHN_ABS)
1451
tsec = bfd_abs_section_ptr;
1452
else if (isym->st_shndx == SHN_COMMON)
1453
tsec = bfd_com_section_ptr;
1455
tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1457
address = (tsec->output_section->vma
1458
+ tsec->output_offset
1460
if (valid_16bit_address (address))
1462
local_plt_offsets[idx] = -1;
1469
&& symtab_hdr->contents != (unsigned char *) isymbuf)
1471
if (! info->keep_memory)
1475
/* Cache the symbols for elf_link_input_bfd. */
1476
symtab_hdr->contents = (unsigned char *) isymbuf;
1481
/* If we changed anything, walk the symbols again to reallocate
1482
.plt entry addresses. */
1483
if (*again && splt->size > 0)
1487
elf_link_hash_traverse (elf_hash_table (info),
1488
rl78_relax_plt_realloc, &entry);
1490
for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1492
bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1493
unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1496
if (! local_plt_offsets)
1499
for (idx = 0; idx < nlocals; ++idx)
1500
if (local_plt_offsets[idx] != (bfd_vma) -1)
1502
local_plt_offsets[idx] = entry;
1511
/* Delete some bytes from a section while relaxing. */
1514
elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1515
Elf_Internal_Rela *alignment_rel, int force_snip)
1517
Elf_Internal_Shdr * symtab_hdr;
1518
unsigned int sec_shndx;
1519
bfd_byte * contents;
1520
Elf_Internal_Rela * irel;
1521
Elf_Internal_Rela * irelend;
1522
Elf_Internal_Sym * isym;
1523
Elf_Internal_Sym * isymend;
1525
unsigned int symcount;
1526
struct elf_link_hash_entry ** sym_hashes;
1527
struct elf_link_hash_entry ** end_hashes;
1532
sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1534
contents = elf_section_data (sec)->this_hdr.contents;
1536
/* The deletion must stop at the next alignment boundary, if
1537
ALIGNMENT_REL is non-NULL. */
1540
toaddr = alignment_rel->r_offset;
1542
irel = elf_section_data (sec)->relocs;
1543
irelend = irel + sec->reloc_count;
1545
/* Actually delete the bytes. */
1546
memmove (contents + addr, contents + addr + count,
1547
(size_t) (toaddr - addr - count));
1549
/* If we don't have an alignment marker to worry about, we can just
1550
shrink the section. Otherwise, we have to fill in the newly
1551
created gap with NOP insns (0x03). */
1555
memset (contents + toaddr - count, 0x03, count);
1557
/* Adjust all the relocs. */
1558
for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1560
/* Get the new reloc address. */
1561
if (irel->r_offset > addr
1562
&& (irel->r_offset < toaddr
1563
|| (force_snip && irel->r_offset == toaddr)))
1564
irel->r_offset -= count;
1566
/* If we see an ALIGN marker at the end of the gap, we move it
1567
to the beginning of the gap, since marking these gaps is what
1569
if (irel->r_offset == toaddr
1570
&& ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1571
&& irel->r_addend & RL78_RELAXA_ALIGN)
1572
irel->r_offset -= count;
1575
/* Adjust the local symbols defined in this section. */
1576
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1577
isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1578
isymend = isym + symtab_hdr->sh_info;
1580
for (; isym < isymend; isym++)
1582
/* If the symbol is in the range of memory we just moved, we
1583
have to adjust its value. */
1584
if (isym->st_shndx == sec_shndx
1585
&& isym->st_value > addr
1586
&& isym->st_value < toaddr)
1587
isym->st_value -= count;
1589
/* If the symbol *spans* the bytes we just deleted (i.e. it's
1590
*end* is in the moved bytes but it's *start* isn't), then we
1591
must adjust its size. */
1592
if (isym->st_shndx == sec_shndx
1593
&& isym->st_value < addr
1594
&& isym->st_value + isym->st_size > addr
1595
&& isym->st_value + isym->st_size < toaddr)
1596
isym->st_size -= count;
1599
/* Now adjust the global symbols defined in this section. */
1600
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1601
- symtab_hdr->sh_info);
1602
sym_hashes = elf_sym_hashes (abfd);
1603
end_hashes = sym_hashes + symcount;
1605
for (; sym_hashes < end_hashes; sym_hashes++)
1607
struct elf_link_hash_entry *sym_hash = *sym_hashes;
1609
if ((sym_hash->root.type == bfd_link_hash_defined
1610
|| sym_hash->root.type == bfd_link_hash_defweak)
1611
&& sym_hash->root.u.def.section == sec)
1613
/* As above, adjust the value if needed. */
1614
if (sym_hash->root.u.def.value > addr
1615
&& sym_hash->root.u.def.value < toaddr)
1616
sym_hash->root.u.def.value -= count;
1618
/* As above, adjust the size if needed. */
1619
if (sym_hash->root.u.def.value < addr
1620
&& sym_hash->root.u.def.value + sym_hash->size > addr
1621
&& sym_hash->root.u.def.value + sym_hash->size < toaddr)
1622
sym_hash->size -= count;
1629
/* Used to sort relocs by address. If relocs have the same address,
1630
we maintain their relative order, except that R_RL78_RH_RELAX
1631
alignment relocs must be the first reloc for any given address. */
1634
reloc_bubblesort (Elf_Internal_Rela * r, int count)
1638
bfd_boolean swappit;
1640
/* This is almost a classic bubblesort. It's the slowest sort, but
1641
we're taking advantage of the fact that the relocations are
1642
mostly in order already (the assembler emits them that way) and
1643
we need relocs with the same address to remain in the same
1649
for (i = 0; i < count - 1; i ++)
1651
if (r[i].r_offset > r[i + 1].r_offset)
1653
else if (r[i].r_offset < r[i + 1].r_offset)
1655
else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1656
&& (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1658
else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1659
&& (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1660
&& !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1661
&& (r[i].r_addend & RL78_RELAXA_ALIGN)))
1668
Elf_Internal_Rela tmp;
1673
/* If we do move a reloc back, re-scan to see if it
1674
needs to be moved even further back. This avoids
1675
most of the O(n^2) behavior for our cases. */
1685
#define OFFSET_FOR_RELOC(rel, lrel, scale) \
1686
rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1687
lrel, abfd, sec, link_info, scale)
1690
rl78_offset_for_reloc (bfd * abfd,
1691
Elf_Internal_Rela * rel,
1692
Elf_Internal_Shdr * symtab_hdr,
1693
Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1694
Elf_Internal_Sym * intsyms,
1695
Elf_Internal_Rela ** lrel,
1697
asection * input_section,
1698
struct bfd_link_info * info,
1702
bfd_reloc_status_type r;
1706
/* REL is the first of 1..N relocations. We compute the symbol
1707
value for each relocation, then combine them if needed. LREL
1708
gets a pointer to the last relocation used. */
1713
/* Get the value of the symbol referred to by the reloc. */
1714
if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1716
/* A local symbol. */
1717
Elf_Internal_Sym *isym;
1720
isym = intsyms + ELF32_R_SYM (rel->r_info);
1722
if (isym->st_shndx == SHN_UNDEF)
1723
ssec = bfd_und_section_ptr;
1724
else if (isym->st_shndx == SHN_ABS)
1725
ssec = bfd_abs_section_ptr;
1726
else if (isym->st_shndx == SHN_COMMON)
1727
ssec = bfd_com_section_ptr;
1729
ssec = bfd_section_from_elf_index (abfd,
1732
/* Initial symbol value. */
1733
symval = isym->st_value;
1735
/* GAS may have made this symbol relative to a section, in
1736
which case, we have to add the addend to find the
1738
if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1739
symval += rel->r_addend;
1743
if ((ssec->flags & SEC_MERGE)
1744
&& ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1745
symval = _bfd_merged_section_offset (abfd, & ssec,
1746
elf_section_data (ssec)->sec_info,
1750
/* Now make the offset relative to where the linker is putting it. */
1753
ssec->output_section->vma + ssec->output_offset;
1755
symval += rel->r_addend;
1760
struct elf_link_hash_entry * h;
1762
/* An external symbol. */
1763
indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1764
h = elf_sym_hashes (abfd)[indx];
1765
BFD_ASSERT (h != NULL);
1767
if (h->root.type != bfd_link_hash_defined
1768
&& h->root.type != bfd_link_hash_defweak)
1770
/* This appears to be a reference to an undefined
1771
symbol. Just ignore it--it will be caught by the
1772
regular reloc processing. */
1778
symval = (h->root.u.def.value
1779
+ h->root.u.def.section->output_section->vma
1780
+ h->root.u.def.section->output_offset);
1782
symval += rel->r_addend;
1785
switch (ELF32_R_TYPE (rel->r_info))
1788
RL78_STACK_PUSH (symval);
1792
RL78_STACK_POP (tmp1);
1794
RL78_STACK_PUSH (tmp1);
1798
RL78_STACK_POP (tmp1);
1799
RL78_STACK_POP (tmp2);
1801
RL78_STACK_PUSH (tmp1);
1805
RL78_STACK_POP (tmp1);
1806
RL78_STACK_POP (tmp2);
1808
RL78_STACK_PUSH (tmp2);
1812
RL78_STACK_POP (tmp1);
1813
RL78_STACK_POP (tmp2);
1815
RL78_STACK_PUSH (tmp1);
1819
RL78_STACK_POP (tmp1);
1820
RL78_STACK_POP (tmp2);
1822
RL78_STACK_PUSH (tmp1);
1826
RL78_STACK_POP (tmp1);
1827
RL78_STACK_POP (tmp2);
1829
RL78_STACK_PUSH (tmp1);
1833
RL78_STACK_POP (tmp1);
1834
RL78_STACK_POP (tmp2);
1836
RL78_STACK_PUSH (tmp1);
1839
case R_RL78_OPsctsize:
1840
RL78_STACK_PUSH (input_section->size);
1843
case R_RL78_OPscttop:
1844
RL78_STACK_PUSH (input_section->output_section->vma);
1848
RL78_STACK_POP (tmp1);
1849
RL78_STACK_POP (tmp2);
1851
RL78_STACK_PUSH (tmp1);
1855
RL78_STACK_POP (tmp1);
1856
RL78_STACK_POP (tmp2);
1858
RL78_STACK_PUSH (tmp1);
1862
RL78_STACK_POP (tmp1);
1863
RL78_STACK_POP (tmp2);
1865
RL78_STACK_PUSH (tmp1);
1869
RL78_STACK_POP (tmp1);
1871
RL78_STACK_PUSH (tmp1);
1875
RL78_STACK_POP (tmp1);
1876
RL78_STACK_POP (tmp2);
1878
RL78_STACK_PUSH (tmp1);
1881
case R_RL78_OPromtop:
1882
RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1885
case R_RL78_OPramtop:
1886
RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1889
case R_RL78_DIR16UL:
1891
case R_RL78_ABS16UL:
1894
RL78_STACK_POP (symval);
1900
case R_RL78_DIR16UW:
1902
case R_RL78_ABS16UW:
1905
RL78_STACK_POP (symval);
1913
RL78_STACK_POP (symval);
1924
int prefix; /* or -1 for "no prefix" */
1925
int insn; /* or -1 for "end of list" */
1926
int insn_for_saddr; /* or -1 for "no alternative" */
1927
int insn_for_sfr; /* or -1 for "no alternative" */
1928
} relax_addr16[] = {
1929
{ -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1930
{ -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1931
{ -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1932
{ -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1934
{ -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1935
{ -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1936
{ -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1937
{ -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1938
{ -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1939
{ -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1940
{ -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1941
{ -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1943
{ -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1944
{ -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1945
{ -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1946
{ -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1947
{ -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1949
{ -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1950
{ -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1951
{ -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1952
{ -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1954
{ -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1955
{ -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1956
{ -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1958
{ -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1959
{ -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1960
{ -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1961
{ -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1962
{ -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1963
{ -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1965
{ 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1967
{ 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1968
{ 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1969
{ 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1970
{ 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1971
{ 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1972
{ 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1973
{ 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1974
{ 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1976
{ 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1977
{ 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1978
{ 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1979
{ 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1980
{ 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1981
{ 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1982
{ 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1983
{ 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1988
/* Relax one section. */
1991
rl78_elf_relax_section
1994
struct bfd_link_info * link_info,
1995
bfd_boolean * again)
1997
Elf_Internal_Shdr * symtab_hdr;
1998
Elf_Internal_Shdr * shndx_hdr;
1999
Elf_Internal_Rela * internal_relocs;
2000
Elf_Internal_Rela * free_relocs = NULL;
2001
Elf_Internal_Rela * irel;
2002
Elf_Internal_Rela * srel;
2003
Elf_Internal_Rela * irelend;
2004
Elf_Internal_Rela * next_alignment;
2005
bfd_byte * contents = NULL;
2006
bfd_byte * free_contents = NULL;
2007
Elf_Internal_Sym * intsyms = NULL;
2008
Elf_Internal_Sym * free_intsyms = NULL;
2009
Elf_External_Sym_Shndx * shndx_buf = NULL;
2011
bfd_vma symval ATTRIBUTE_UNUSED = 0;
2012
int pcrel ATTRIBUTE_UNUSED = 0;
2013
int code ATTRIBUTE_UNUSED = 0;
2014
int section_alignment_glue;
2017
if (abfd == elf_hash_table (link_info)->dynobj
2018
&& strcmp (sec->name, ".plt") == 0)
2019
return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2021
/* Assume nothing changes. */
2024
/* We don't have to do anything for a relocatable link, if
2025
this section does not have relocs, or if this is not a
2027
if (link_info->relocatable
2028
|| (sec->flags & SEC_RELOC) == 0
2029
|| sec->reloc_count == 0
2030
|| (sec->flags & SEC_CODE) == 0)
2033
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2034
shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2036
/* Get the section contents. */
2037
if (elf_section_data (sec)->this_hdr.contents != NULL)
2038
contents = elf_section_data (sec)->this_hdr.contents;
2039
/* Go get them off disk. */
2042
if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2044
elf_section_data (sec)->this_hdr.contents = contents;
2047
/* Read this BFD's symbols. */
2048
/* Get cached copy if it exists. */
2049
if (symtab_hdr->contents != NULL)
2050
intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2053
intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2054
symtab_hdr->contents = (bfd_byte *) intsyms;
2057
if (shndx_hdr->sh_size != 0)
2061
amt = symtab_hdr->sh_info;
2062
amt *= sizeof (Elf_External_Sym_Shndx);
2063
shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2064
if (shndx_buf == NULL)
2066
if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2067
|| bfd_bread (shndx_buf, amt, abfd) != amt)
2069
shndx_hdr->contents = (bfd_byte *) shndx_buf;
2072
/* Get a copy of the native relocations. */
2073
internal_relocs = (_bfd_elf_link_read_relocs
2074
(abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2075
link_info->keep_memory));
2076
if (internal_relocs == NULL)
2078
if (! link_info->keep_memory)
2079
free_relocs = internal_relocs;
2081
/* The RL_ relocs must be just before the operand relocs they go
2082
with, so we must sort them to guarantee this. We use bubblesort
2083
instead of qsort so we can guarantee that relocs with the same
2084
address remain in the same relative order. */
2085
reloc_bubblesort (internal_relocs, sec->reloc_count);
2087
/* Walk through them looking for relaxing opportunities. */
2088
irelend = internal_relocs + sec->reloc_count;
2091
/* This will either be NULL or a pointer to the next alignment
2093
next_alignment = internal_relocs;
2095
/* We calculate worst case shrinkage caused by alignment directives.
2096
No fool-proof, but better than either ignoring the problem or
2097
doing heavy duty analysis of all the alignment markers in all
2099
section_alignment_glue = 0;
2100
for (irel = internal_relocs; irel < irelend; irel++)
2101
if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2102
&& irel->r_addend & RL78_RELAXA_ALIGN)
2104
int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2106
if (section_alignment_glue < this_glue)
2107
section_alignment_glue = this_glue;
2109
/* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2111
section_alignment_glue *= 2;
2113
for (irel = internal_relocs; irel < irelend; irel++)
2115
unsigned char *insn;
2118
/* The insns we care about are all marked with one of these. */
2119
if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2122
if (irel->r_addend & RL78_RELAXA_ALIGN
2123
|| next_alignment == internal_relocs)
2125
/* When we delete bytes, we need to maintain all the alignments
2126
indicated. In addition, we need to be careful about relaxing
2127
jumps across alignment boundaries - these displacements
2128
*grow* when we delete bytes. For now, don't shrink
2129
displacements across an alignment boundary, just in case.
2130
Note that this only affects relocations to the same
2132
next_alignment += 2;
2133
while (next_alignment < irelend
2134
&& (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2135
|| !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2137
if (next_alignment >= irelend || next_alignment->r_offset == 0)
2138
next_alignment = NULL;
2141
/* When we hit alignment markers, see if we've shrunk enough
2142
before them to reduce the gap without violating the alignment
2144
if (irel->r_addend & RL78_RELAXA_ALIGN)
2146
/* At this point, the next relocation *should* be the ELIGN
2148
Elf_Internal_Rela *erel = irel + 1;
2149
unsigned int alignment, nbytes;
2151
if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2153
if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2156
alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2158
if (erel->r_offset - irel->r_offset < alignment)
2161
nbytes = erel->r_offset - irel->r_offset;
2162
nbytes /= alignment;
2163
nbytes *= alignment;
2165
elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2166
erel->r_offset == sec->size);
2172
if (irel->r_addend & RL78_RELAXA_ELIGN)
2175
insn = contents + irel->r_offset;
2177
nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2179
/* At this point, we have an insn that is a candidate for linker
2180
relaxation. There are NRELOCS relocs following that may be
2181
relaxed, although each reloc may be made of more than one
2182
reloc entry (such as gp-rel symbols). */
2184
/* Get the value of the symbol referred to by the reloc. Just
2185
in case this is the last reloc in the list, use the RL's
2186
addend to choose between this reloc (no addend) or the next
2187
(yes addend, which means at least one following reloc). */
2189
/* srel points to the "current" reloction for this insn -
2190
actually the last reloc for a given operand, which is the one
2191
we need to update. We check the relaxations in the same
2192
order that the relocations happen, so we'll just push it
2196
pc = sec->output_section->vma + sec->output_offset
2200
BFD_ASSERT (nrelocs > 0); \
2201
symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2202
pcrel = symval - pc + srel->r_addend; \
2205
#define SNIPNR(offset, nbytes) \
2206
elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2207
#define SNIP(offset, nbytes, newtype) \
2208
SNIPNR (offset, nbytes); \
2209
srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2211
/* The order of these bit tests must match the order that the
2212
relocs appear in. Since we sorted those by offset, we can
2215
/*----------------------------------------------------------------------*/
2216
/* EF ad BR $rel8 pcrel
2217
ED al ah BR !abs16 abs
2218
EE al ah BR $!rel16 pcrel
2219
EC al ah as BR !!abs20 abs
2221
FD al ah CALL !abs16 abs
2222
FE al ah CALL $!rel16 pcrel
2223
FC al ah as CALL !!abs20 abs
2231
61 C8 EF ad SKC ; BR $rel8
2232
61 D8 EF ad SKNC ; BR $rel8
2233
61 E8 EF ad SKZ ; BR $rel8
2234
61 F8 EF ad SKNZ ; BR $rel8
2235
61 E3 EF ad SKH ; BR $rel8
2236
61 F3 EF ad SKNH ; BR $rel8
2239
if (irel->r_addend & RL78_RELAXA_BRA)
2241
/* SKIP opcodes that skip non-branches will have a relax tag
2242
but no corresponding symbol to relax against; we just
2244
if (irel->r_addend & RL78_RELAXA_RNUM)
2251
case 0xec: /* BR !!abs20 */
2258
SNIP (2, 2, R_RL78_DIR8S_PCREL);
2261
else if (symval < 65536)
2264
insn[1] = symval & 0xff;
2265
insn[2] = symval >> 8;
2266
SNIP (2, 1, R_RL78_DIR16S);
2269
else if (pcrel < 32767
2273
insn[1] = pcrel & 0xff;
2274
insn[2] = pcrel >> 8;
2275
SNIP (2, 1, R_RL78_DIR16S_PCREL);
2280
case 0xee: /* BR $!pcrel16 */
2281
case 0xed: /* BR $!abs16 */
2287
SNIP (2, 1, R_RL78_DIR8S_PCREL);
2292
case 0xfc: /* CALL !!abs20 */
2296
insn[1] = symval & 0xff;
2297
insn[2] = symval >> 8;
2298
SNIP (2, 1, R_RL78_DIR16S);
2301
else if (pcrel < 32767
2305
insn[1] = pcrel & 0xff;
2306
insn[2] = pcrel >> 8;
2307
SNIP (2, 1, R_RL78_DIR16S_PCREL);
2312
case 0x61: /* PREFIX */
2313
/* For SKIP/BR, we change the BR opcode and delete the
2314
SKIP. That way, we don't have to find and change the
2315
relocation for the BR. */
2316
/* Note that, for the case where we're skipping some
2317
other insn, we have no "other" reloc but that's safe
2321
case 0xc8: /* SKC */
2322
if (insn[2] == 0xef)
2324
insn[2] = 0xde; /* BNC */
2329
case 0xd8: /* SKNC */
2330
if (insn[2] == 0xef)
2332
insn[2] = 0xdc; /* BC */
2337
case 0xe8: /* SKZ */
2338
if (insn[2] == 0xef)
2340
insn[2] = 0xdf; /* BNZ */
2345
case 0xf8: /* SKNZ */
2346
if (insn[2] == 0xef)
2348
insn[2] = 0xdd; /* BZ */
2353
case 0xe3: /* SKH */
2354
if (insn[2] == 0xef)
2356
insn[2] = 0xd3; /* BNH */
2357
SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2361
case 0xf3: /* SKNH */
2362
if (insn[2] == 0xef)
2364
insn[2] = 0xc3; /* BH */
2365
SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2374
if (irel->r_addend & RL78_RELAXA_ADDR16)
2376
/*----------------------------------------------------------------------*/
2377
/* Some insns have both a 16-bit address operand and an 8-bit
2378
variant if the address is within a special range:
2380
Address 16-bit operand SADDR range SFR range
2381
FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2382
FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2384
The RELAX_ADDR16[] array has the insn encodings for the
2385
16-bit operand version, as well as the SFR and SADDR
2386
variants. We only need to replace the encodings and
2389
Note: we intentionally do not attempt to decode and skip
2390
any ES: prefix, as adding ES: means the addr16 (likely)
2391
no longer points to saddr/sfr space.
2401
if (0xffe20 <= symval && symval <= 0xfffff)
2404
is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2405
is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2407
for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2409
if (relax_addr16[idx].prefix != -1
2410
&& insn[0] == relax_addr16[idx].prefix
2411
&& insn[1] == relax_addr16[idx].insn)
2415
else if (relax_addr16[idx].prefix == -1
2416
&& insn[0] == relax_addr16[idx].insn)
2423
/* We have a matched insn, and poff is 0 or 1 depending
2424
on the base pattern size. */
2426
if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2428
insn[poff] = relax_addr16[idx].insn_for_sfr;
2429
SNIP (poff+2, 1, R_RL78_RH_SFR);
2432
else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2434
insn[poff] = relax_addr16[idx].insn_for_saddr;
2435
SNIP (poff+2, 1, R_RL78_RH_SADDR);
2442
/*----------------------------------------------------------------------*/
2449
if (free_relocs != NULL)
2452
if (free_contents != NULL)
2453
free (free_contents);
2455
if (shndx_buf != NULL)
2457
shndx_hdr->contents = NULL;
2461
if (free_intsyms != NULL)
2462
free (free_intsyms);
2469
#define ELF_ARCH bfd_arch_rl78
2470
#define ELF_MACHINE_CODE EM_RL78
2471
#define ELF_MAXPAGESIZE 0x1000
2473
#define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2474
#define TARGET_LITTLE_NAME "elf32-rl78"
2476
#define elf_info_to_howto_rel NULL
2477
#define elf_info_to_howto rl78_info_to_howto_rela
2478
#define elf_backend_object_p rl78_elf_object_p
2479
#define elf_backend_relocate_section rl78_elf_relocate_section
2480
#define elf_symbol_leading_char ('_')
2481
#define elf_backend_can_gc_sections 1
2483
#define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2484
#define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2485
#define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2486
#define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2487
#define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2489
#define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2490
#define elf_backend_check_relocs rl78_elf_check_relocs
2491
#define elf_backend_always_size_sections \
2492
rl78_elf_always_size_sections
2493
#define elf_backend_finish_dynamic_sections \
2494
rl78_elf_finish_dynamic_sections
2496
#include "elf32-target.h"
added
removed
binutils-2.23.52.20130611/bfd/elf32-rl78.c
