1 /* Renesas RX specific support for 32-bit ELF.
2 Copyright (C) 2008-2018 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "bfd_stdint.h"
27 #include "libiberty.h"
30 #define RX_OPCODE_BIG_ENDIAN 0
32 /* This is a meta-target that's used only with objcopy, to avoid the
33 endian-swap we would otherwise get. We check for this in
35 const bfd_target rx_elf32_be_ns_vec
;
36 const bfd_target rx_elf32_be_vec
;
39 char * rx_get_reloc (long);
40 void rx_dump_symtab (bfd
*, void *, void *);
43 #define RXREL(n,sz,bit,shift,complain,pcrel) \
44 HOWTO (R_RX_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
45 bfd_elf_generic_reloc, "R_RX_" #n, FALSE, 0, ~0, FALSE)
47 /* Note that the relocations around 0x7f are internal to this file;
48 feel free to move them as needed to avoid conflicts with published
49 relocation numbers. */
51 static reloc_howto_type rx_elf_howto_table
[] =
53 RXREL (NONE
, 3, 0, 0, dont
, FALSE
),
54 RXREL (DIR32
, 2, 32, 0, signed, FALSE
),
55 RXREL (DIR24S
, 2, 24, 0, signed, FALSE
),
56 RXREL (DIR16
, 1, 16, 0, dont
, FALSE
),
57 RXREL (DIR16U
, 1, 16, 0, unsigned, FALSE
),
58 RXREL (DIR16S
, 1, 16, 0, signed, FALSE
),
59 RXREL (DIR8
, 0, 8, 0, dont
, FALSE
),
60 RXREL (DIR8U
, 0, 8, 0, unsigned, FALSE
),
61 RXREL (DIR8S
, 0, 8, 0, signed, FALSE
),
62 RXREL (DIR24S_PCREL
, 2, 24, 0, signed, TRUE
),
63 RXREL (DIR16S_PCREL
, 1, 16, 0, signed, TRUE
),
64 RXREL (DIR8S_PCREL
, 0, 8, 0, signed, TRUE
),
65 RXREL (DIR16UL
, 1, 16, 2, unsigned, FALSE
),
66 RXREL (DIR16UW
, 1, 16, 1, unsigned, FALSE
),
67 RXREL (DIR8UL
, 0, 8, 2, unsigned, FALSE
),
68 RXREL (DIR8UW
, 0, 8, 1, unsigned, FALSE
),
69 RXREL (DIR32_REV
, 1, 16, 0, dont
, FALSE
),
70 RXREL (DIR16_REV
, 1, 16, 0, dont
, FALSE
),
71 RXREL (DIR3U_PCREL
, 0, 3, 0, dont
, TRUE
),
87 RXREL (RH_3_PCREL
, 0, 3, 0, signed, TRUE
),
88 RXREL (RH_16_OP
, 1, 16, 0, signed, FALSE
),
89 RXREL (RH_24_OP
, 2, 24, 0, signed, FALSE
),
90 RXREL (RH_32_OP
, 2, 32, 0, signed, FALSE
),
91 RXREL (RH_24_UNS
, 2, 24, 0, unsigned, FALSE
),
92 RXREL (RH_8_NEG
, 0, 8, 0, signed, FALSE
),
93 RXREL (RH_16_NEG
, 1, 16, 0, signed, FALSE
),
94 RXREL (RH_24_NEG
, 2, 24, 0, signed, FALSE
),
95 RXREL (RH_32_NEG
, 2, 32, 0, signed, FALSE
),
96 RXREL (RH_DIFF
, 2, 32, 0, signed, FALSE
),
97 RXREL (RH_GPRELB
, 1, 16, 0, unsigned, FALSE
),
98 RXREL (RH_GPRELW
, 1, 16, 0, unsigned, FALSE
),
99 RXREL (RH_GPRELL
, 1, 16, 0, unsigned, FALSE
),
100 RXREL (RH_RELAX
, 0, 0, 0, dont
, FALSE
),
122 RXREL (ABS32
, 2, 32, 0, dont
, FALSE
),
123 RXREL (ABS24S
, 2, 24, 0, signed, FALSE
),
124 RXREL (ABS16
, 1, 16, 0, dont
, FALSE
),
125 RXREL (ABS16U
, 1, 16, 0, unsigned, FALSE
),
126 RXREL (ABS16S
, 1, 16, 0, signed, FALSE
),
127 RXREL (ABS8
, 0, 8, 0, dont
, FALSE
),
128 RXREL (ABS8U
, 0, 8, 0, unsigned, FALSE
),
129 RXREL (ABS8S
, 0, 8, 0, signed, FALSE
),
130 RXREL (ABS24S_PCREL
, 2, 24, 0, signed, TRUE
),
131 RXREL (ABS16S_PCREL
, 1, 16, 0, signed, TRUE
),
132 RXREL (ABS8S_PCREL
, 0, 8, 0, signed, TRUE
),
133 RXREL (ABS16UL
, 1, 16, 0, unsigned, FALSE
),
134 RXREL (ABS16UW
, 1, 16, 0, unsigned, FALSE
),
135 RXREL (ABS8UL
, 0, 8, 0, unsigned, FALSE
),
136 RXREL (ABS8UW
, 0, 8, 0, unsigned, FALSE
),
137 RXREL (ABS32_REV
, 2, 32, 0, dont
, FALSE
),
138 RXREL (ABS16_REV
, 1, 16, 0, dont
, FALSE
),
140 #define STACK_REL_P(x) ((x) <= R_RX_ABS16_REV && (x) >= R_RX_ABS32)
181 /* These are internal. */
182 /* A 5-bit unsigned displacement to a B/W/L address, at bit position 8/12. */
183 /* ---- ---- 4--- 3210. */
184 #define R_RX_RH_ABS5p8B 0x78
185 RXREL (RH_ABS5p8B
, 0, 0, 0, dont
, FALSE
),
186 #define R_RX_RH_ABS5p8W 0x79
187 RXREL (RH_ABS5p8W
, 0, 0, 0, dont
, FALSE
),
188 #define R_RX_RH_ABS5p8L 0x7a
189 RXREL (RH_ABS5p8L
, 0, 0, 0, dont
, FALSE
),
190 /* A 5-bit unsigned displacement to a B/W/L address, at bit position 5/12. */
191 /* ---- -432 1--- 0---. */
192 #define R_RX_RH_ABS5p5B 0x7b
193 RXREL (RH_ABS5p5B
, 0, 0, 0, dont
, FALSE
),
194 #define R_RX_RH_ABS5p5W 0x7c
195 RXREL (RH_ABS5p5W
, 0, 0, 0, dont
, FALSE
),
196 #define R_RX_RH_ABS5p5L 0x7d
197 RXREL (RH_ABS5p5L
, 0, 0, 0, dont
, FALSE
),
198 /* A 4-bit unsigned immediate at bit position 8. */
199 #define R_RX_RH_UIMM4p8 0x7e
200 RXREL (RH_UIMM4p8
, 0, 0, 0, dont
, FALSE
),
201 /* A 4-bit negative unsigned immediate at bit position 8. */
202 #define R_RX_RH_UNEG4p8 0x7f
203 RXREL (RH_UNEG4p8
, 0, 0, 0, dont
, FALSE
),
204 /* End of internal relocs. */
206 RXREL (SYM
, 2, 32, 0, dont
, FALSE
),
207 RXREL (OPneg
, 2, 32, 0, dont
, FALSE
),
208 RXREL (OPadd
, 2, 32, 0, dont
, FALSE
),
209 RXREL (OPsub
, 2, 32, 0, dont
, FALSE
),
210 RXREL (OPmul
, 2, 32, 0, dont
, FALSE
),
211 RXREL (OPdiv
, 2, 32, 0, dont
, FALSE
),
212 RXREL (OPshla
, 2, 32, 0, dont
, FALSE
),
213 RXREL (OPshra
, 2, 32, 0, dont
, FALSE
),
214 RXREL (OPsctsize
, 2, 32, 0, dont
, FALSE
),
215 RXREL (OPscttop
, 2, 32, 0, dont
, FALSE
),
216 RXREL (OPand
, 2, 32, 0, dont
, FALSE
),
217 RXREL (OPor
, 2, 32, 0, dont
, FALSE
),
218 RXREL (OPxor
, 2, 32, 0, dont
, FALSE
),
219 RXREL (OPnot
, 2, 32, 0, dont
, FALSE
),
220 RXREL (OPmod
, 2, 32, 0, dont
, FALSE
),
221 RXREL (OPromtop
, 2, 32, 0, dont
, FALSE
),
222 RXREL (OPramtop
, 2, 32, 0, dont
, FALSE
)
225 /* Map BFD reloc types to RX ELF reloc types. */
229 bfd_reloc_code_real_type bfd_reloc_val
;
230 unsigned int rx_reloc_val
;
233 static const struct rx_reloc_map rx_reloc_map
[] =
235 { BFD_RELOC_NONE
, R_RX_NONE
},
236 { BFD_RELOC_8
, R_RX_DIR8S
},
237 { BFD_RELOC_16
, R_RX_DIR16S
},
238 { BFD_RELOC_24
, R_RX_DIR24S
},
239 { BFD_RELOC_32
, R_RX_DIR32
},
240 { BFD_RELOC_RX_16_OP
, R_RX_DIR16
},
241 { BFD_RELOC_RX_DIR3U_PCREL
, R_RX_DIR3U_PCREL
},
242 { BFD_RELOC_8_PCREL
, R_RX_DIR8S_PCREL
},
243 { BFD_RELOC_16_PCREL
, R_RX_DIR16S_PCREL
},
244 { BFD_RELOC_24_PCREL
, R_RX_DIR24S_PCREL
},
245 { BFD_RELOC_RX_8U
, R_RX_DIR8U
},
246 { BFD_RELOC_RX_16U
, R_RX_DIR16U
},
247 { BFD_RELOC_RX_24U
, R_RX_RH_24_UNS
},
248 { BFD_RELOC_RX_NEG8
, R_RX_RH_8_NEG
},
249 { BFD_RELOC_RX_NEG16
, R_RX_RH_16_NEG
},
250 { BFD_RELOC_RX_NEG24
, R_RX_RH_24_NEG
},
251 { BFD_RELOC_RX_NEG32
, R_RX_RH_32_NEG
},
252 { BFD_RELOC_RX_DIFF
, R_RX_RH_DIFF
},
253 { BFD_RELOC_RX_GPRELB
, R_RX_RH_GPRELB
},
254 { BFD_RELOC_RX_GPRELW
, R_RX_RH_GPRELW
},
255 { BFD_RELOC_RX_GPRELL
, R_RX_RH_GPRELL
},
256 { BFD_RELOC_RX_RELAX
, R_RX_RH_RELAX
},
257 { BFD_RELOC_RX_SYM
, R_RX_SYM
},
258 { BFD_RELOC_RX_OP_SUBTRACT
, R_RX_OPsub
},
259 { BFD_RELOC_RX_OP_NEG
, R_RX_OPneg
},
260 { BFD_RELOC_RX_ABS8
, R_RX_ABS8
},
261 { BFD_RELOC_RX_ABS16
, R_RX_ABS16
},
262 { BFD_RELOC_RX_ABS16_REV
, R_RX_ABS16_REV
},
263 { BFD_RELOC_RX_ABS32
, R_RX_ABS32
},
264 { BFD_RELOC_RX_ABS32_REV
, R_RX_ABS32_REV
},
265 { BFD_RELOC_RX_ABS16UL
, R_RX_ABS16UL
},
266 { BFD_RELOC_RX_ABS16UW
, R_RX_ABS16UW
},
267 { BFD_RELOC_RX_ABS16U
, R_RX_ABS16U
}
270 #define BIGE(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
272 static reloc_howto_type
*
273 rx_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
274 bfd_reloc_code_real_type code
)
278 if (code
== BFD_RELOC_RX_32_OP
)
279 return rx_elf_howto_table
+ R_RX_DIR32
;
281 for (i
= ARRAY_SIZE (rx_reloc_map
); i
--;)
282 if (rx_reloc_map
[i
].bfd_reloc_val
== code
)
283 return rx_elf_howto_table
+ rx_reloc_map
[i
].rx_reloc_val
;
288 static reloc_howto_type
*
289 rx_reloc_name_lookup (bfd
* abfd ATTRIBUTE_UNUSED
, const char * r_name
)
293 for (i
= 0; i
< ARRAY_SIZE (rx_elf_howto_table
); i
++)
294 if (rx_elf_howto_table
[i
].name
!= NULL
295 && strcasecmp (rx_elf_howto_table
[i
].name
, r_name
) == 0)
296 return rx_elf_howto_table
+ i
;
301 /* Set the howto pointer for an RX ELF reloc. */
304 rx_info_to_howto_rela (bfd
*abfd
,
306 Elf_Internal_Rela
*dst
)
310 r_type
= ELF32_R_TYPE (dst
->r_info
);
311 if (r_type
>= (unsigned int) R_RX_max
)
313 /* xgettext:c-format */
314 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
318 cache_ptr
->howto
= rx_elf_howto_table
+ r_type
;
322 get_symbol_value (const char * name
,
323 struct bfd_link_info
* info
,
325 asection
* input_section
,
329 struct bfd_link_hash_entry
* h
;
331 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
334 || (h
->type
!= bfd_link_hash_defined
335 && h
->type
!= bfd_link_hash_defweak
))
336 (*info
->callbacks
->undefined_symbol
)
337 (info
, name
, input_bfd
, input_section
, offset
, TRUE
);
339 value
= (h
->u
.def
.value
340 + h
->u
.def
.section
->output_section
->vma
341 + h
->u
.def
.section
->output_offset
);
347 get_symbol_value_maybe (const char * name
,
348 struct bfd_link_info
* info
)
351 struct bfd_link_hash_entry
* h
;
353 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, TRUE
);
356 || (h
->type
!= bfd_link_hash_defined
357 && h
->type
!= bfd_link_hash_defweak
))
360 value
= (h
->u
.def
.value
361 + h
->u
.def
.section
->output_section
->vma
362 + h
->u
.def
.section
->output_offset
);
368 get_gp (struct bfd_link_info
* info
,
373 static bfd_boolean cached
= FALSE
;
374 static bfd_vma cached_value
= 0;
378 cached_value
= get_symbol_value ("__gp", info
, abfd
, sec
, offset
);
385 get_romstart (struct bfd_link_info
* info
,
390 static bfd_boolean cached
= FALSE
;
391 static bfd_vma cached_value
= 0;
395 cached_value
= get_symbol_value ("_start", info
, abfd
, sec
, offset
);
402 get_ramstart (struct bfd_link_info
* info
,
407 static bfd_boolean cached
= FALSE
;
408 static bfd_vma cached_value
= 0;
412 cached_value
= get_symbol_value ("__datastart", info
, abfd
, sec
, offset
);
418 #define NUM_STACK_ENTRIES 16
419 static int32_t rx_stack
[ NUM_STACK_ENTRIES
];
420 static unsigned int rx_stack_top
;
422 #define RX_STACK_PUSH(val) \
425 if (rx_stack_top < NUM_STACK_ENTRIES) \
426 rx_stack [rx_stack_top ++] = (val); \
428 r = bfd_reloc_dangerous; \
432 #define RX_STACK_POP(dest) \
435 if (rx_stack_top > 0) \
436 (dest) = rx_stack [-- rx_stack_top]; \
438 (dest) = 0, r = bfd_reloc_dangerous; \
442 /* Relocate an RX ELF section.
443 There is some attempt to make this function usable for many architectures,
444 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
445 if only to serve as a learning tool.
447 The RELOCATE_SECTION function is called by the new ELF backend linker
448 to handle the relocations for a section.
450 The relocs are always passed as Rela structures; if the section
451 actually uses Rel structures, the r_addend field will always be
454 This function is responsible for adjusting the section contents as
455 necessary, and (if using Rela relocs and generating a relocatable
456 output file) adjusting the reloc addend as necessary.
458 This function does not have to worry about setting the reloc
459 address or the reloc symbol index.
461 LOCAL_SYMS is a pointer to the swapped in local symbols.
463 LOCAL_SECTIONS is an array giving the section in the input file
464 corresponding to the st_shndx field of each local symbol.
466 The global hash table entry for the global symbols can be found
467 via elf_sym_hashes (input_bfd).
469 When generating relocatable output, this function must handle
470 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
471 going to be the section symbol corresponding to the output
472 section, which means that the addend must be adjusted
476 rx_elf_relocate_section
478 struct bfd_link_info
* info
,
480 asection
* input_section
,
482 Elf_Internal_Rela
* relocs
,
483 Elf_Internal_Sym
* local_syms
,
484 asection
** local_sections
)
486 Elf_Internal_Shdr
* symtab_hdr
;
487 struct elf_link_hash_entry
** sym_hashes
;
488 Elf_Internal_Rela
* rel
;
489 Elf_Internal_Rela
* relend
;
490 bfd_boolean pid_mode
;
491 bfd_boolean saw_subtract
= FALSE
;
492 const char * table_default_cache
= NULL
;
493 bfd_vma table_start_cache
= 0;
494 bfd_vma table_end_cache
= 0;
496 if (elf_elfheader (output_bfd
)->e_flags
& E_FLAG_RX_PID
)
501 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
502 sym_hashes
= elf_sym_hashes (input_bfd
);
503 relend
= relocs
+ input_section
->reloc_count
;
504 for (rel
= relocs
; rel
< relend
; rel
++)
506 reloc_howto_type
* howto
;
507 unsigned long r_symndx
;
508 Elf_Internal_Sym
* sym
;
510 struct elf_link_hash_entry
* h
;
512 bfd_reloc_status_type r
;
513 const char * name
= NULL
;
514 bfd_boolean unresolved_reloc
= TRUE
;
517 r_type
= ELF32_R_TYPE (rel
->r_info
);
518 r_symndx
= ELF32_R_SYM (rel
->r_info
);
520 howto
= rx_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
526 if (rx_stack_top
== 0)
527 saw_subtract
= FALSE
;
529 if (r_symndx
< symtab_hdr
->sh_info
)
531 sym
= local_syms
+ r_symndx
;
532 sec
= local_sections
[r_symndx
];
533 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
535 name
= bfd_elf_string_from_elf_section
536 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
537 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
541 bfd_boolean warned
, ignored
;
543 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
544 r_symndx
, symtab_hdr
, sym_hashes
, h
,
545 sec
, relocation
, unresolved_reloc
,
548 name
= h
->root
.root
.string
;
551 if (strncmp (name
, "$tableentry$default$", 20) == 0)
557 if (table_default_cache
!= name
)
560 /* All relocs for a given table should be to the same
561 (weak) default symbol) so we can use it to detect a
562 cache miss. We use the offset into the table to find
563 the "real" symbol. Calculate and store the table's
566 table_default_cache
= name
;
568 /* We have already done error checking in rx_table_find(). */
570 buf
= (char *) malloc (13 + strlen (name
+ 20));
572 sprintf (buf
, "$tablestart$%s", name
+ 20);
573 table_start_cache
= get_symbol_value (buf
,
579 sprintf (buf
, "$tableend$%s", name
+ 20);
580 table_end_cache
= get_symbol_value (buf
,
589 entry_vma
= (input_section
->output_section
->vma
590 + input_section
->output_offset
593 if (table_end_cache
<= entry_vma
|| entry_vma
< table_start_cache
)
595 /* xgettext:c-format */
596 _bfd_error_handler (_("%pB:%pA: table entry %s outside table"),
597 input_bfd
, input_section
,
600 else if ((int) (entry_vma
- table_start_cache
) % 4)
602 /* xgettext:c-format */
603 _bfd_error_handler (_("%pB:%pA: table entry %s not word-aligned within table"),
604 input_bfd
, input_section
,
609 idx
= (int) (entry_vma
- table_start_cache
) / 4;
611 /* This will look like $tableentry$<N>$<name> */
612 buf
= (char *) malloc (12 + 20 + strlen (name
+ 20));
613 sprintf (buf
, "$tableentry$%d$%s", idx
, name
+ 20);
615 h
= (struct elf_link_hash_entry
*) bfd_link_hash_lookup (info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
619 relocation
= (h
->root
.u
.def
.value
620 + h
->root
.u
.def
.section
->output_section
->vma
621 + h
->root
.u
.def
.section
->output_offset
);;
628 if (sec
!= NULL
&& discarded_section (sec
))
629 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
630 rel
, 1, relend
, howto
, 0, contents
);
632 if (bfd_link_relocatable (info
))
634 /* This is a relocatable link. We don't have to change
635 anything, unless the reloc is against a section symbol,
636 in which case we have to adjust according to where the
637 section symbol winds up in the output section. */
638 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
639 rel
->r_addend
+= sec
->output_offset
;
643 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
644 /* If the symbol is undefined and weak
645 then the relocation resolves to zero. */
649 if (howto
->pc_relative
)
651 relocation
-= (input_section
->output_section
->vma
652 + input_section
->output_offset
654 if (r_type
!= R_RX_RH_3_PCREL
655 && r_type
!= R_RX_DIR3U_PCREL
)
659 relocation
+= rel
->r_addend
;
665 if (a > (long) relocation || (long) relocation > b) \
666 r = bfd_reloc_overflow
668 if (relocation & m) \
671 (contents[rel->r_offset + (i)])
672 #define WARN_REDHAT(type) \
673 /* xgettext:c-format */ \
675 (_("%pB:%pA: warning: deprecated Red Hat reloc " \
676 "%s detected against: %s"), \
677 input_bfd, input_section, #type, name)
679 /* Check for unsafe relocs in PID mode. These are any relocs where
680 an absolute address is being computed. There are special cases
681 for relocs against symbols that are known to be referenced in
682 crt0.o before the PID base address register has been initialised. */
683 #define UNSAFE_FOR_PID \
688 && sec->flags & SEC_READONLY \
689 && !(input_section->flags & SEC_DEBUGGING) \
690 && strcmp (name, "__pid_base") != 0 \
691 && strcmp (name, "__gp") != 0 \
692 && strcmp (name, "__romdatastart") != 0 \
694 /* xgettext:c-format */ \
695 _bfd_error_handler (_("%pB(%pA): unsafe PID relocation %s " \
696 "at %#" PRIx64 " (against %s in %s)"), \
697 input_bfd, input_section, howto->name, \
698 (uint64_t) (input_section->output_section->vma \
699 + input_section->output_offset \
705 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
714 case R_RX_RH_3_PCREL
:
715 WARN_REDHAT ("RX_RH_3_PCREL");
718 OP (0) |= relocation
& 0x07;
722 WARN_REDHAT ("RX_RH_8_NEG");
723 relocation
= - relocation
;
725 case R_RX_DIR8S_PCREL
:
744 WARN_REDHAT ("RX_RH_16_NEG");
745 relocation
= - relocation
;
747 case R_RX_DIR16S_PCREL
:
749 RANGE (-32768, 32767);
750 #if RX_OPCODE_BIG_ENDIAN
753 OP (1) = relocation
>> 8;
758 WARN_REDHAT ("RX_RH_16_OP");
760 RANGE (-32768, 32767);
761 #if RX_OPCODE_BIG_ENDIAN
763 OP (0) = relocation
>> 8;
766 OP (1) = relocation
>> 8;
772 RANGE (-32768, 65535);
773 if (BIGE (output_bfd
) && !(input_section
->flags
& SEC_CODE
))
776 OP (0) = relocation
>> 8;
781 OP (1) = relocation
>> 8;
788 #if RX_OPCODE_BIG_ENDIAN
790 OP (0) = relocation
>> 8;
793 OP (1) = relocation
>> 8;
799 RANGE (-32768, 65536);
800 #if RX_OPCODE_BIG_ENDIAN
802 OP (0) = relocation
>> 8;
805 OP (1) = relocation
>> 8;
811 RANGE (-32768, 65536);
812 #if RX_OPCODE_BIG_ENDIAN
814 OP (1) = relocation
>> 8;
817 OP (0) = relocation
>> 8;
821 case R_RX_DIR3U_PCREL
:
824 OP (0) |= relocation
& 0x07;
829 WARN_REDHAT ("RX_RH_24_NEG");
830 relocation
= - relocation
;
832 case R_RX_DIR24S_PCREL
:
833 RANGE (-0x800000, 0x7fffff);
834 #if RX_OPCODE_BIG_ENDIAN
836 OP (1) = relocation
>> 8;
837 OP (0) = relocation
>> 16;
840 OP (1) = relocation
>> 8;
841 OP (2) = relocation
>> 16;
847 WARN_REDHAT ("RX_RH_24_OP");
848 RANGE (-0x800000, 0x7fffff);
849 #if RX_OPCODE_BIG_ENDIAN
851 OP (1) = relocation
>> 8;
852 OP (0) = relocation
>> 16;
855 OP (1) = relocation
>> 8;
856 OP (2) = relocation
>> 16;
862 RANGE (-0x800000, 0x7fffff);
863 if (BIGE (output_bfd
) && !(input_section
->flags
& SEC_CODE
))
866 OP (1) = relocation
>> 8;
867 OP (0) = relocation
>> 16;
872 OP (1) = relocation
>> 8;
873 OP (2) = relocation
>> 16;
879 WARN_REDHAT ("RX_RH_24_UNS");
881 #if RX_OPCODE_BIG_ENDIAN
883 OP (1) = relocation
>> 8;
884 OP (0) = relocation
>> 16;
887 OP (1) = relocation
>> 8;
888 OP (2) = relocation
>> 16;
894 WARN_REDHAT ("RX_RH_32_NEG");
895 relocation
= - relocation
;
896 #if RX_OPCODE_BIG_ENDIAN
898 OP (2) = relocation
>> 8;
899 OP (1) = relocation
>> 16;
900 OP (0) = relocation
>> 24;
903 OP (1) = relocation
>> 8;
904 OP (2) = relocation
>> 16;
905 OP (3) = relocation
>> 24;
911 WARN_REDHAT ("RX_RH_32_OP");
912 #if RX_OPCODE_BIG_ENDIAN
914 OP (2) = relocation
>> 8;
915 OP (1) = relocation
>> 16;
916 OP (0) = relocation
>> 24;
919 OP (1) = relocation
>> 8;
920 OP (2) = relocation
>> 16;
921 OP (3) = relocation
>> 24;
926 if (BIGE (output_bfd
) && !(input_section
->flags
& SEC_CODE
))
929 OP (2) = relocation
>> 8;
930 OP (1) = relocation
>> 16;
931 OP (0) = relocation
>> 24;
936 OP (1) = relocation
>> 8;
937 OP (2) = relocation
>> 16;
938 OP (3) = relocation
>> 24;
943 if (BIGE (output_bfd
))
946 OP (1) = relocation
>> 8;
947 OP (2) = relocation
>> 16;
948 OP (3) = relocation
>> 24;
953 OP (2) = relocation
>> 8;
954 OP (1) = relocation
>> 16;
955 OP (0) = relocation
>> 24;
962 WARN_REDHAT ("RX_RH_DIFF");
963 val
= bfd_get_32 (output_bfd
, & OP (0));
965 bfd_put_32 (output_bfd
, val
, & OP (0));
970 WARN_REDHAT ("RX_RH_GPRELB");
971 relocation
-= get_gp (info
, input_bfd
, input_section
, rel
->r_offset
);
973 #if RX_OPCODE_BIG_ENDIAN
975 OP (0) = relocation
>> 8;
978 OP (1) = relocation
>> 8;
983 WARN_REDHAT ("RX_RH_GPRELW");
984 relocation
-= get_gp (info
, input_bfd
, input_section
, rel
->r_offset
);
988 #if RX_OPCODE_BIG_ENDIAN
990 OP (0) = relocation
>> 8;
993 OP (1) = relocation
>> 8;
998 WARN_REDHAT ("RX_RH_GPRELL");
999 relocation
-= get_gp (info
, input_bfd
, input_section
, rel
->r_offset
);
1003 #if RX_OPCODE_BIG_ENDIAN
1004 OP (1) = relocation
;
1005 OP (0) = relocation
>> 8;
1007 OP (0) = relocation
;
1008 OP (1) = relocation
>> 8;
1012 /* Internal relocations just for relaxation: */
1013 case R_RX_RH_ABS5p5B
:
1014 RX_STACK_POP (relocation
);
1017 OP (0) |= relocation
>> 2;
1019 OP (1) |= (relocation
<< 6) & 0x80;
1020 OP (1) |= (relocation
<< 3) & 0x08;
1023 case R_RX_RH_ABS5p5W
:
1024 RX_STACK_POP (relocation
);
1029 OP (0) |= relocation
>> 2;
1031 OP (1) |= (relocation
<< 6) & 0x80;
1032 OP (1) |= (relocation
<< 3) & 0x08;
1035 case R_RX_RH_ABS5p5L
:
1036 RX_STACK_POP (relocation
);
1041 OP (0) |= relocation
>> 2;
1043 OP (1) |= (relocation
<< 6) & 0x80;
1044 OP (1) |= (relocation
<< 3) & 0x08;
1047 case R_RX_RH_ABS5p8B
:
1048 RX_STACK_POP (relocation
);
1051 OP (0) |= (relocation
<< 3) & 0x80;
1052 OP (0) |= relocation
& 0x0f;
1055 case R_RX_RH_ABS5p8W
:
1056 RX_STACK_POP (relocation
);
1061 OP (0) |= (relocation
<< 3) & 0x80;
1062 OP (0) |= relocation
& 0x0f;
1065 case R_RX_RH_ABS5p8L
:
1066 RX_STACK_POP (relocation
);
1071 OP (0) |= (relocation
<< 3) & 0x80;
1072 OP (0) |= relocation
& 0x0f;
1075 case R_RX_RH_UIMM4p8
:
1078 OP (0) |= relocation
<< 4;
1081 case R_RX_RH_UNEG4p8
:
1084 OP (0) |= (-relocation
) << 4;
1087 /* Complex reloc handling: */
1091 RX_STACK_POP (relocation
);
1092 #if RX_OPCODE_BIG_ENDIAN
1093 OP (3) = relocation
;
1094 OP (2) = relocation
>> 8;
1095 OP (1) = relocation
>> 16;
1096 OP (0) = relocation
>> 24;
1098 OP (0) = relocation
;
1099 OP (1) = relocation
>> 8;
1100 OP (2) = relocation
>> 16;
1101 OP (3) = relocation
>> 24;
1105 case R_RX_ABS32_REV
:
1107 RX_STACK_POP (relocation
);
1108 #if RX_OPCODE_BIG_ENDIAN
1109 OP (0) = relocation
;
1110 OP (1) = relocation
>> 8;
1111 OP (2) = relocation
>> 16;
1112 OP (3) = relocation
>> 24;
1114 OP (3) = relocation
;
1115 OP (2) = relocation
>> 8;
1116 OP (1) = relocation
>> 16;
1117 OP (0) = relocation
>> 24;
1121 case R_RX_ABS24S_PCREL
:
1124 RX_STACK_POP (relocation
);
1125 RANGE (-0x800000, 0x7fffff);
1126 if (BIGE (output_bfd
) && !(input_section
->flags
& SEC_CODE
))
1128 OP (2) = relocation
;
1129 OP (1) = relocation
>> 8;
1130 OP (0) = relocation
>> 16;
1134 OP (0) = relocation
;
1135 OP (1) = relocation
>> 8;
1136 OP (2) = relocation
>> 16;
1142 RX_STACK_POP (relocation
);
1143 RANGE (-32768, 65535);
1144 #if RX_OPCODE_BIG_ENDIAN
1145 OP (1) = relocation
;
1146 OP (0) = relocation
>> 8;
1148 OP (0) = relocation
;
1149 OP (1) = relocation
>> 8;
1153 case R_RX_ABS16_REV
:
1155 RX_STACK_POP (relocation
);
1156 RANGE (-32768, 65535);
1157 #if RX_OPCODE_BIG_ENDIAN
1158 OP (0) = relocation
;
1159 OP (1) = relocation
>> 8;
1161 OP (1) = relocation
;
1162 OP (0) = relocation
>> 8;
1166 case R_RX_ABS16S_PCREL
:
1168 RX_STACK_POP (relocation
);
1169 RANGE (-32768, 32767);
1170 if (BIGE (output_bfd
) && !(input_section
->flags
& SEC_CODE
))
1172 OP (1) = relocation
;
1173 OP (0) = relocation
>> 8;
1177 OP (0) = relocation
;
1178 OP (1) = relocation
>> 8;
1184 RX_STACK_POP (relocation
);
1186 #if RX_OPCODE_BIG_ENDIAN
1187 OP (1) = relocation
;
1188 OP (0) = relocation
>> 8;
1190 OP (0) = relocation
;
1191 OP (1) = relocation
>> 8;
1197 RX_STACK_POP (relocation
);
1200 #if RX_OPCODE_BIG_ENDIAN
1201 OP (1) = relocation
;
1202 OP (0) = relocation
>> 8;
1204 OP (0) = relocation
;
1205 OP (1) = relocation
>> 8;
1211 RX_STACK_POP (relocation
);
1214 #if RX_OPCODE_BIG_ENDIAN
1215 OP (1) = relocation
;
1216 OP (0) = relocation
>> 8;
1218 OP (0) = relocation
;
1219 OP (1) = relocation
>> 8;
1225 RX_STACK_POP (relocation
);
1227 OP (0) = relocation
;
1232 RX_STACK_POP (relocation
);
1234 OP (0) = relocation
;
1239 RX_STACK_POP (relocation
);
1242 OP (0) = relocation
;
1247 RX_STACK_POP (relocation
);
1250 OP (0) = relocation
;
1256 case R_RX_ABS8S_PCREL
:
1257 RX_STACK_POP (relocation
);
1259 OP (0) = relocation
;
1263 if (r_symndx
< symtab_hdr
->sh_info
)
1264 RX_STACK_PUSH (sec
->output_section
->vma
1265 + sec
->output_offset
1271 && (h
->root
.type
== bfd_link_hash_defined
1272 || h
->root
.type
== bfd_link_hash_defweak
))
1273 RX_STACK_PUSH (h
->root
.u
.def
.value
1274 + sec
->output_section
->vma
1275 + sec
->output_offset
1279 (_("warning: RX_SYM reloc with an unknown symbol"));
1287 saw_subtract
= TRUE
;
1290 RX_STACK_PUSH (tmp
);
1298 RX_STACK_POP (tmp1
);
1299 RX_STACK_POP (tmp2
);
1301 RX_STACK_PUSH (tmp1
);
1309 saw_subtract
= TRUE
;
1310 RX_STACK_POP (tmp1
);
1311 RX_STACK_POP (tmp2
);
1313 RX_STACK_PUSH (tmp2
);
1321 RX_STACK_POP (tmp1
);
1322 RX_STACK_POP (tmp2
);
1324 RX_STACK_PUSH (tmp1
);
1332 RX_STACK_POP (tmp1
);
1333 RX_STACK_POP (tmp2
);
1335 RX_STACK_PUSH (tmp1
);
1343 RX_STACK_POP (tmp1
);
1344 RX_STACK_POP (tmp2
);
1346 RX_STACK_PUSH (tmp1
);
1354 RX_STACK_POP (tmp1
);
1355 RX_STACK_POP (tmp2
);
1357 RX_STACK_PUSH (tmp1
);
1361 case R_RX_OPsctsize
:
1362 RX_STACK_PUSH (input_section
->size
);
1366 RX_STACK_PUSH (input_section
->output_section
->vma
);
1373 RX_STACK_POP (tmp1
);
1374 RX_STACK_POP (tmp2
);
1376 RX_STACK_PUSH (tmp1
);
1384 RX_STACK_POP (tmp1
);
1385 RX_STACK_POP (tmp2
);
1387 RX_STACK_PUSH (tmp1
);
1395 RX_STACK_POP (tmp1
);
1396 RX_STACK_POP (tmp2
);
1398 RX_STACK_PUSH (tmp1
);
1408 RX_STACK_PUSH (tmp
);
1416 RX_STACK_POP (tmp1
);
1417 RX_STACK_POP (tmp2
);
1419 RX_STACK_PUSH (tmp1
);
1424 RX_STACK_PUSH (get_romstart (info
, input_bfd
, input_section
, rel
->r_offset
));
1428 RX_STACK_PUSH (get_ramstart (info
, input_bfd
, input_section
, rel
->r_offset
));
1432 r
= bfd_reloc_notsupported
;
1436 if (r
!= bfd_reloc_ok
)
1438 const char * msg
= NULL
;
1442 case bfd_reloc_overflow
:
1443 /* Catch the case of a missing function declaration
1444 and emit a more helpful error message. */
1445 if (r_type
== R_RX_DIR24S_PCREL
)
1446 /* xgettext:c-format */
1447 msg
= _("%pB(%pA): error: call to undefined function '%s'");
1449 (*info
->callbacks
->reloc_overflow
)
1450 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
1451 input_bfd
, input_section
, rel
->r_offset
);
1454 case bfd_reloc_undefined
:
1455 (*info
->callbacks
->undefined_symbol
)
1456 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1459 case bfd_reloc_other
:
1460 /* xgettext:c-format */
1461 msg
= _("%pB(%pA): warning: unaligned access to symbol '%s' in the small data area");
1464 case bfd_reloc_outofrange
:
1465 /* xgettext:c-format */
1466 msg
= _("%pB(%pA): internal error: out of range error");
1469 case bfd_reloc_notsupported
:
1470 /* xgettext:c-format */
1471 msg
= _("%pB(%pA): internal error: unsupported relocation error");
1474 case bfd_reloc_dangerous
:
1475 /* xgettext:c-format */
1476 msg
= _("%pB(%pA): internal error: dangerous relocation");
1480 /* xgettext:c-format */
1481 msg
= _("%pB(%pA): internal error: unknown error");
1486 _bfd_error_handler (msg
, input_bfd
, input_section
, name
);
1493 /* Relaxation Support. */
1495 /* Progression of relocations from largest operand size to smallest
1499 next_smaller_reloc (int r
)
1503 case R_RX_DIR32
: return R_RX_DIR24S
;
1504 case R_RX_DIR24S
: return R_RX_DIR16S
;
1505 case R_RX_DIR16S
: return R_RX_DIR8S
;
1506 case R_RX_DIR8S
: return R_RX_NONE
;
1508 case R_RX_DIR16
: return R_RX_DIR8
;
1509 case R_RX_DIR8
: return R_RX_NONE
;
1511 case R_RX_DIR16U
: return R_RX_DIR8U
;
1512 case R_RX_DIR8U
: return R_RX_NONE
;
1514 case R_RX_DIR24S_PCREL
: return R_RX_DIR16S_PCREL
;
1515 case R_RX_DIR16S_PCREL
: return R_RX_DIR8S_PCREL
;
1516 case R_RX_DIR8S_PCREL
: return R_RX_DIR3U_PCREL
;
1518 case R_RX_DIR16UL
: return R_RX_DIR8UL
;
1519 case R_RX_DIR8UL
: return R_RX_NONE
;
1520 case R_RX_DIR16UW
: return R_RX_DIR8UW
;
1521 case R_RX_DIR8UW
: return R_RX_NONE
;
1523 case R_RX_RH_32_OP
: return R_RX_RH_24_OP
;
1524 case R_RX_RH_24_OP
: return R_RX_RH_16_OP
;
1525 case R_RX_RH_16_OP
: return R_RX_DIR8
;
1527 case R_RX_ABS32
: return R_RX_ABS24S
;
1528 case R_RX_ABS24S
: return R_RX_ABS16S
;
1529 case R_RX_ABS16
: return R_RX_ABS8
;
1530 case R_RX_ABS16U
: return R_RX_ABS8U
;
1531 case R_RX_ABS16S
: return R_RX_ABS8S
;
1532 case R_RX_ABS8
: return R_RX_NONE
;
1533 case R_RX_ABS8U
: return R_RX_NONE
;
1534 case R_RX_ABS8S
: return R_RX_NONE
;
1535 case R_RX_ABS24S_PCREL
: return R_RX_ABS16S_PCREL
;
1536 case R_RX_ABS16S_PCREL
: return R_RX_ABS8S_PCREL
;
1537 case R_RX_ABS8S_PCREL
: return R_RX_NONE
;
1538 case R_RX_ABS16UL
: return R_RX_ABS8UL
;
1539 case R_RX_ABS16UW
: return R_RX_ABS8UW
;
1540 case R_RX_ABS8UL
: return R_RX_NONE
;
1541 case R_RX_ABS8UW
: return R_RX_NONE
;
1546 /* Delete some bytes from a section while relaxing. */
1549 elf32_rx_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, int count
,
1550 Elf_Internal_Rela
*alignment_rel
, int force_snip
,
1551 Elf_Internal_Rela
*irelstart
)
1553 Elf_Internal_Shdr
* symtab_hdr
;
1554 unsigned int sec_shndx
;
1555 bfd_byte
* contents
;
1556 Elf_Internal_Rela
* irel
;
1557 Elf_Internal_Rela
* irelend
;
1558 Elf_Internal_Sym
* isym
;
1559 Elf_Internal_Sym
* isymend
;
1561 unsigned int symcount
;
1562 struct elf_link_hash_entry
** sym_hashes
;
1563 struct elf_link_hash_entry
** end_hashes
;
1568 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1570 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1572 /* The deletion must stop at the next alignment boundary, if
1573 ALIGNMENT_REL is non-NULL. */
1576 toaddr
= alignment_rel
->r_offset
;
1578 BFD_ASSERT (toaddr
> addr
);
1580 /* Actually delete the bytes. */
1581 memmove (contents
+ addr
, contents
+ addr
+ count
,
1582 (size_t) (toaddr
- addr
- count
));
1584 /* If we don't have an alignment marker to worry about, we can just
1585 shrink the section. Otherwise, we have to fill in the newly
1586 created gap with NOP insns (0x03). */
1590 memset (contents
+ toaddr
- count
, 0x03, count
);
1593 BFD_ASSERT (irel
!= NULL
|| sec
->reloc_count
== 0);
1594 irelend
= irel
+ sec
->reloc_count
;
1596 /* Adjust all the relocs. */
1597 for (; irel
< irelend
; irel
++)
1599 /* Get the new reloc address. */
1600 if (irel
->r_offset
> addr
1601 && (irel
->r_offset
< toaddr
1602 || (force_snip
&& irel
->r_offset
== toaddr
)))
1603 irel
->r_offset
-= count
;
1605 /* If we see an ALIGN marker at the end of the gap, we move it
1606 to the beginning of the gap, since marking these gaps is what
1608 if (irel
->r_offset
== toaddr
1609 && ELF32_R_TYPE (irel
->r_info
) == R_RX_RH_RELAX
1610 && irel
->r_addend
& RX_RELAXA_ALIGN
)
1611 irel
->r_offset
-= count
;
1614 /* Adjust the local symbols defined in this section. */
1615 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1616 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1617 isymend
= isym
+ symtab_hdr
->sh_info
;
1619 for (; isym
< isymend
; isym
++)
1621 /* If the symbol is in the range of memory we just moved, we
1622 have to adjust its value. */
1623 if (isym
->st_shndx
== sec_shndx
1624 && isym
->st_value
> addr
1625 && isym
->st_value
< toaddr
)
1626 isym
->st_value
-= count
;
1628 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1629 *end* is in the moved bytes but it's *start* isn't), then we
1630 must adjust its size. */
1631 if (isym
->st_shndx
== sec_shndx
1632 && isym
->st_value
< addr
1633 && isym
->st_value
+ isym
->st_size
> addr
1634 && isym
->st_value
+ isym
->st_size
< toaddr
)
1635 isym
->st_size
-= count
;
1638 /* Now adjust the global symbols defined in this section. */
1639 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1640 - symtab_hdr
->sh_info
);
1641 sym_hashes
= elf_sym_hashes (abfd
);
1642 end_hashes
= sym_hashes
+ symcount
;
1644 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1646 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1648 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1649 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1650 && sym_hash
->root
.u
.def
.section
== sec
)
1652 /* As above, adjust the value if needed. */
1653 if (sym_hash
->root
.u
.def
.value
> addr
1654 && sym_hash
->root
.u
.def
.value
< toaddr
)
1655 sym_hash
->root
.u
.def
.value
-= count
;
1657 /* As above, adjust the size if needed. */
1658 if (sym_hash
->root
.u
.def
.value
< addr
1659 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1660 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1661 sym_hash
->size
-= count
;
1668 /* Used to sort relocs by address. If relocs have the same address,
1669 we maintain their relative order, except that R_RX_RH_RELAX
1670 alignment relocs must be the first reloc for any given address. */
1673 reloc_bubblesort (Elf_Internal_Rela
* r
, int count
)
1677 bfd_boolean swappit
;
1679 /* This is almost a classic bubblesort. It's the slowest sort, but
1680 we're taking advantage of the fact that the relocations are
1681 mostly in order already (the assembler emits them that way) and
1682 we need relocs with the same address to remain in the same
1688 for (i
= 0; i
< count
- 1; i
++)
1690 if (r
[i
].r_offset
> r
[i
+ 1].r_offset
)
1692 else if (r
[i
].r_offset
< r
[i
+ 1].r_offset
)
1694 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RX_RH_RELAX
1695 && (r
[i
+ 1].r_addend
& RX_RELAXA_ALIGN
))
1697 else if (ELF32_R_TYPE (r
[i
+ 1].r_info
) == R_RX_RH_RELAX
1698 && (r
[i
+ 1].r_addend
& RX_RELAXA_ELIGN
)
1699 && !(ELF32_R_TYPE (r
[i
].r_info
) == R_RX_RH_RELAX
1700 && (r
[i
].r_addend
& RX_RELAXA_ALIGN
)))
1707 Elf_Internal_Rela tmp
;
1712 /* If we do move a reloc back, re-scan to see if it
1713 needs to be moved even further back. This avoids
1714 most of the O(n^2) behavior for our cases. */
1724 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1725 rx_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1726 lrel, abfd, sec, link_info, scale)
1729 rx_offset_for_reloc (bfd
* abfd
,
1730 Elf_Internal_Rela
* rel
,
1731 Elf_Internal_Shdr
* symtab_hdr
,
1732 Elf_External_Sym_Shndx
* shndx_buf ATTRIBUTE_UNUSED
,
1733 Elf_Internal_Sym
* intsyms
,
1734 Elf_Internal_Rela
** lrel
,
1736 asection
* input_section
,
1737 struct bfd_link_info
* info
,
1741 bfd_reloc_status_type r
;
1745 /* REL is the first of 1..N relocations. We compute the symbol
1746 value for each relocation, then combine them if needed. LREL
1747 gets a pointer to the last relocation used. */
1752 /* Get the value of the symbol referred to by the reloc. */
1753 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1755 /* A local symbol. */
1756 Elf_Internal_Sym
*isym
;
1759 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1761 if (isym
->st_shndx
== SHN_UNDEF
)
1762 ssec
= bfd_und_section_ptr
;
1763 else if (isym
->st_shndx
== SHN_ABS
)
1764 ssec
= bfd_abs_section_ptr
;
1765 else if (isym
->st_shndx
== SHN_COMMON
)
1766 ssec
= bfd_com_section_ptr
;
1768 ssec
= bfd_section_from_elf_index (abfd
,
1771 /* Initial symbol value. */
1772 symval
= isym
->st_value
;
1774 /* GAS may have made this symbol relative to a section, in
1775 which case, we have to add the addend to find the
1777 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
1778 symval
+= rel
->r_addend
;
1782 if ((ssec
->flags
& SEC_MERGE
)
1783 && ssec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1784 symval
= _bfd_merged_section_offset (abfd
, & ssec
,
1785 elf_section_data (ssec
)->sec_info
,
1789 /* Now make the offset relative to where the linker is putting it. */
1792 ssec
->output_section
->vma
+ ssec
->output_offset
;
1794 symval
+= rel
->r_addend
;
1799 struct elf_link_hash_entry
* h
;
1801 /* An external symbol. */
1802 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1803 h
= elf_sym_hashes (abfd
)[indx
];
1804 BFD_ASSERT (h
!= NULL
);
1806 if (h
->root
.type
!= bfd_link_hash_defined
1807 && h
->root
.type
!= bfd_link_hash_defweak
)
1809 /* This appears to be a reference to an undefined
1810 symbol. Just ignore it--it will be caught by the
1811 regular reloc processing. */
1817 symval
= (h
->root
.u
.def
.value
1818 + h
->root
.u
.def
.section
->output_section
->vma
1819 + h
->root
.u
.def
.section
->output_offset
);
1821 symval
+= rel
->r_addend
;
1824 switch (ELF32_R_TYPE (rel
->r_info
))
1827 RX_STACK_PUSH (symval
);
1831 RX_STACK_POP (tmp1
);
1833 RX_STACK_PUSH (tmp1
);
1837 RX_STACK_POP (tmp1
);
1838 RX_STACK_POP (tmp2
);
1840 RX_STACK_PUSH (tmp1
);
1844 RX_STACK_POP (tmp1
);
1845 RX_STACK_POP (tmp2
);
1847 RX_STACK_PUSH (tmp2
);
1851 RX_STACK_POP (tmp1
);
1852 RX_STACK_POP (tmp2
);
1854 RX_STACK_PUSH (tmp1
);
1858 RX_STACK_POP (tmp1
);
1859 RX_STACK_POP (tmp2
);
1861 RX_STACK_PUSH (tmp1
);
1865 RX_STACK_POP (tmp1
);
1866 RX_STACK_POP (tmp2
);
1868 RX_STACK_PUSH (tmp1
);
1872 RX_STACK_POP (tmp1
);
1873 RX_STACK_POP (tmp2
);
1875 RX_STACK_PUSH (tmp1
);
1878 case R_RX_OPsctsize
:
1879 RX_STACK_PUSH (input_section
->size
);
1883 RX_STACK_PUSH (input_section
->output_section
->vma
);
1887 RX_STACK_POP (tmp1
);
1888 RX_STACK_POP (tmp2
);
1890 RX_STACK_PUSH (tmp1
);
1894 RX_STACK_POP (tmp1
);
1895 RX_STACK_POP (tmp2
);
1897 RX_STACK_PUSH (tmp1
);
1901 RX_STACK_POP (tmp1
);
1902 RX_STACK_POP (tmp2
);
1904 RX_STACK_PUSH (tmp1
);
1908 RX_STACK_POP (tmp1
);
1910 RX_STACK_PUSH (tmp1
);
1914 RX_STACK_POP (tmp1
);
1915 RX_STACK_POP (tmp2
);
1917 RX_STACK_PUSH (tmp1
);
1921 RX_STACK_PUSH (get_romstart (info
, input_bfd
, input_section
, rel
->r_offset
));
1925 RX_STACK_PUSH (get_ramstart (info
, input_bfd
, input_section
, rel
->r_offset
));
1933 RX_STACK_POP (symval
);
1944 RX_STACK_POP (symval
);
1952 RX_STACK_POP (symval
);
1965 move_reloc (Elf_Internal_Rela
* irel
, Elf_Internal_Rela
* srel
, int delta
)
1967 bfd_vma old_offset
= srel
->r_offset
;
1970 while (irel
<= srel
)
1972 if (irel
->r_offset
== old_offset
)
1973 irel
->r_offset
+= delta
;
1978 /* Relax one section. */
1981 elf32_rx_relax_section (bfd
* abfd
,
1983 struct bfd_link_info
* link_info
,
1984 bfd_boolean
* again
,
1985 bfd_boolean allow_pcrel3
)
1987 Elf_Internal_Shdr
* symtab_hdr
;
1988 Elf_Internal_Shdr
* shndx_hdr
;
1989 Elf_Internal_Rela
* internal_relocs
;
1990 Elf_Internal_Rela
* irel
;
1991 Elf_Internal_Rela
* srel
;
1992 Elf_Internal_Rela
* irelend
;
1993 Elf_Internal_Rela
* next_alignment
;
1994 Elf_Internal_Rela
* prev_alignment
;
1995 bfd_byte
* contents
= NULL
;
1996 bfd_byte
* free_contents
= NULL
;
1997 Elf_Internal_Sym
* intsyms
= NULL
;
1998 Elf_Internal_Sym
* free_intsyms
= NULL
;
1999 Elf_External_Sym_Shndx
* shndx_buf
= NULL
;
2005 int section_alignment_glue
;
2006 /* how much to scale the relocation by - 1, 2, or 4. */
2009 /* Assume nothing changes. */
2012 /* We don't have to do anything for a relocatable link, if
2013 this section does not have relocs, or if this is not a
2015 if (bfd_link_relocatable (link_info
)
2016 || (sec
->flags
& SEC_RELOC
) == 0
2017 || sec
->reloc_count
== 0
2018 || (sec
->flags
& SEC_CODE
) == 0)
2021 symtab_hdr
= & elf_symtab_hdr (abfd
);
2022 if (elf_symtab_shndx_list (abfd
))
2023 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
2027 sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
2029 /* Get the section contents. */
2030 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2031 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2032 /* Go get them off disk. */
2035 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2037 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2040 /* Read this BFD's symbols. */
2041 /* Get cached copy if it exists. */
2042 if (symtab_hdr
->contents
!= NULL
)
2043 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2046 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
2047 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
2050 if (shndx_hdr
&& shndx_hdr
->sh_size
!= 0)
2054 amt
= symtab_hdr
->sh_info
;
2055 amt
*= sizeof (Elf_External_Sym_Shndx
);
2056 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
2057 if (shndx_buf
== NULL
)
2059 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
2060 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
2062 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
2065 /* Get a copy of the native relocations. */
2066 /* Note - we ignore the setting of link_info->keep_memory when reading
2067 in these relocs. We have to maintain a permanent copy of the relocs
2068 because we are going to walk over them multiple times, adjusting them
2069 as bytes are deleted from the section, and with this relaxation
2070 function itself being called multiple times on the same section... */
2071 internal_relocs
= _bfd_elf_link_read_relocs
2072 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
, TRUE
);
2073 if (internal_relocs
== NULL
)
2076 /* The RL_ relocs must be just before the operand relocs they go
2077 with, so we must sort them to guarantee this. We use bubblesort
2078 instead of qsort so we can guarantee that relocs with the same
2079 address remain in the same relative order. */
2080 reloc_bubblesort (internal_relocs
, sec
->reloc_count
);
2082 /* Walk through them looking for relaxing opportunities. */
2083 irelend
= internal_relocs
+ sec
->reloc_count
;
2085 /* This will either be NULL or a pointer to the next alignment
2087 next_alignment
= internal_relocs
;
2088 /* This will be the previous alignment, although at first it points
2089 to the first real relocation. */
2090 prev_alignment
= internal_relocs
;
2092 /* We calculate worst case shrinkage caused by alignment directives.
2093 No fool-proof, but better than either ignoring the problem or
2094 doing heavy duty analysis of all the alignment markers in all
2096 section_alignment_glue
= 0;
2097 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2098 if (ELF32_R_TYPE (irel
->r_info
) == R_RX_RH_RELAX
2099 && irel
->r_addend
& RX_RELAXA_ALIGN
)
2101 int this_glue
= 1 << (irel
->r_addend
& RX_RELAXA_ANUM
);
2103 if (section_alignment_glue
< this_glue
)
2104 section_alignment_glue
= this_glue
;
2106 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2108 section_alignment_glue
*= 2;
2110 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2112 unsigned char *insn
;
2115 /* The insns we care about are all marked with one of these. */
2116 if (ELF32_R_TYPE (irel
->r_info
) != R_RX_RH_RELAX
)
2119 if (irel
->r_addend
& RX_RELAXA_ALIGN
2120 || next_alignment
== internal_relocs
)
2122 /* When we delete bytes, we need to maintain all the alignments
2123 indicated. In addition, we need to be careful about relaxing
2124 jumps across alignment boundaries - these displacements
2125 *grow* when we delete bytes. For now, don't shrink
2126 displacements across an alignment boundary, just in case.
2127 Note that this only affects relocations to the same
2129 prev_alignment
= next_alignment
;
2130 next_alignment
+= 2;
2131 while (next_alignment
< irelend
2132 && (ELF32_R_TYPE (next_alignment
->r_info
) != R_RX_RH_RELAX
2133 || !(next_alignment
->r_addend
& RX_RELAXA_ELIGN
)))
2135 if (next_alignment
>= irelend
|| next_alignment
->r_offset
== 0)
2136 next_alignment
= NULL
;
2139 /* When we hit alignment markers, see if we've shrunk enough
2140 before them to reduce the gap without violating the alignment
2142 if (irel
->r_addend
& RX_RELAXA_ALIGN
)
2144 /* At this point, the next relocation *should* be the ELIGN
2146 Elf_Internal_Rela
*erel
= irel
+ 1;
2147 unsigned int alignment
, nbytes
;
2149 if (ELF32_R_TYPE (erel
->r_info
) != R_RX_RH_RELAX
)
2151 if (!(erel
->r_addend
& RX_RELAXA_ELIGN
))
2154 alignment
= 1 << (irel
->r_addend
& RX_RELAXA_ANUM
);
2156 if (erel
->r_offset
- irel
->r_offset
< alignment
)
2159 nbytes
= erel
->r_offset
- irel
->r_offset
;
2160 nbytes
/= alignment
;
2161 nbytes
*= alignment
;
2163 elf32_rx_relax_delete_bytes (abfd
, sec
, erel
->r_offset
-nbytes
, nbytes
, next_alignment
,
2164 erel
->r_offset
== sec
->size
, internal_relocs
);
2170 if (irel
->r_addend
& RX_RELAXA_ELIGN
)
2173 insn
= contents
+ irel
->r_offset
;
2175 nrelocs
= irel
->r_addend
& RX_RELAXA_RNUM
;
2177 /* At this point, we have an insn that is a candidate for linker
2178 relaxation. There are NRELOCS relocs following that may be
2179 relaxed, although each reloc may be made of more than one
2180 reloc entry (such as gp-rel symbols). */
2182 /* Get the value of the symbol referred to by the reloc. Just
2183 in case this is the last reloc in the list, use the RL's
2184 addend to choose between this reloc (no addend) or the next
2185 (yes addend, which means at least one following reloc). */
2187 /* srel points to the "current" reloction for this insn -
2188 actually the last reloc for a given operand, which is the one
2189 we need to update. We check the relaxations in the same
2190 order that the relocations happen, so we'll just push it
2194 pc
= sec
->output_section
->vma
+ sec
->output_offset
2198 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2199 pcrel = symval - pc + srel->r_addend; \
2202 #define SNIPNR(offset, nbytes) \
2203 elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0, internal_relocs);
2204 #define SNIP(offset, nbytes, newtype) \
2205 SNIPNR (offset, nbytes); \
2206 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2208 /* The order of these bit tests must match the order that the
2209 relocs appear in. Since we sorted those by offset, we can
2212 /* Note that the numbers in, say, DSP6 are the bit offsets of
2213 the code fields that describe the operand. Bits number 0 for
2214 the MSB of insn[0]. */
2221 if (irel
->r_addend
& RX_RELAXA_DSP6
)
2226 if (code
== 2 && symval
/scale
<= 255)
2228 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2231 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2232 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2234 SNIP (3, 1, newrel
);
2239 else if (code
== 1 && symval
== 0)
2242 SNIP (2, 1, R_RX_NONE
);
2246 /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst. */
2247 else if (code
== 1 && symval
/scale
<= 31
2248 /* Decodable bits. */
2249 && (insn
[0] & 0xcc) == 0xcc
2251 && (insn
[0] & 0x30) != 0x30
2252 /* Register MSBs. */
2253 && (insn
[1] & 0x88) == 0x00)
2257 insn
[0] = 0x88 | (insn
[0] & 0x30);
2258 /* The register fields are in the right place already. */
2260 /* We can't relax this new opcode. */
2263 switch ((insn
[0] & 0x30) >> 4)
2266 newrel
= R_RX_RH_ABS5p5B
;
2269 newrel
= R_RX_RH_ABS5p5W
;
2272 newrel
= R_RX_RH_ABS5p5L
;
2276 move_reloc (irel
, srel
, -2);
2277 SNIP (2, 1, newrel
);
2280 /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst. */
2281 else if (code
== 1 && symval
/scale
<= 31
2282 /* Decodable bits. */
2283 && (insn
[0] & 0xf8) == 0x58
2284 /* Register MSBs. */
2285 && (insn
[1] & 0x88) == 0x00)
2289 insn
[0] = 0xb0 | ((insn
[0] & 0x04) << 1);
2290 /* The register fields are in the right place already. */
2292 /* We can't relax this new opcode. */
2295 switch ((insn
[0] & 0x08) >> 3)
2298 newrel
= R_RX_RH_ABS5p5B
;
2301 newrel
= R_RX_RH_ABS5p5W
;
2305 move_reloc (irel
, srel
, -2);
2306 SNIP (2, 1, newrel
);
2310 /* A DSP4 operand always follows a DSP6 operand, even if there's
2311 no relocation for it. We have to read the code out of the
2312 opcode to calculate the offset of the operand. */
2313 if (irel
->r_addend
& RX_RELAXA_DSP4
)
2315 int code6
, offset
= 0;
2319 code6
= insn
[0] & 0x03;
2322 case 0: offset
= 2; break;
2323 case 1: offset
= 3; break;
2324 case 2: offset
= 4; break;
2325 case 3: offset
= 2; break;
2328 code
= (insn
[0] & 0x0c) >> 2;
2330 if (code
== 2 && symval
/ scale
<= 255)
2332 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2336 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2337 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2339 SNIP (offset
+1, 1, newrel
);
2344 else if (code
== 1 && symval
== 0)
2347 SNIP (offset
, 1, R_RX_NONE
);
2350 /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */
2351 else if (code
== 1 && symval
/scale
<= 31
2352 /* Decodable bits. */
2353 && (insn
[0] & 0xc3) == 0xc3
2355 && (insn
[0] & 0x30) != 0x30
2356 /* Register MSBs. */
2357 && (insn
[1] & 0x88) == 0x00)
2361 insn
[0] = 0x80 | (insn
[0] & 0x30);
2362 /* The register fields are in the right place already. */
2364 /* We can't relax this new opcode. */
2367 switch ((insn
[0] & 0x30) >> 4)
2370 newrel
= R_RX_RH_ABS5p5B
;
2373 newrel
= R_RX_RH_ABS5p5W
;
2376 newrel
= R_RX_RH_ABS5p5L
;
2380 move_reloc (irel
, srel
, -2);
2381 SNIP (2, 1, newrel
);
2385 /* These always occur alone, but the offset depends on whether
2386 it's a MEMEX opcode (0x06) or not. */
2387 if (irel
->r_addend
& RX_RELAXA_DSP14
)
2392 if (insn
[0] == 0x06)
2399 if (code
== 2 && symval
/ scale
<= 255)
2401 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2405 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2406 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2408 SNIP (offset
, 1, newrel
);
2412 else if (code
== 1 && symval
== 0)
2415 SNIP (offset
, 1, R_RX_NONE
);
2426 /* These always occur alone. */
2427 if (irel
->r_addend
& RX_RELAXA_IMM6
)
2433 /* These relocations sign-extend, so we must do signed compares. */
2434 ssymval
= (long) symval
;
2436 code
= insn
[0] & 0x03;
2438 if (code
== 0 && ssymval
<= 8388607 && ssymval
>= -8388608)
2440 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2444 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2445 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2447 SNIP (2, 1, newrel
);
2452 else if (code
== 3 && ssymval
<= 32767 && ssymval
>= -32768)
2454 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2458 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2459 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2461 SNIP (2, 1, newrel
);
2466 /* Special case UIMM8 format: CMP #uimm8,Rdst. */
2467 else if (code
== 2 && ssymval
<= 255 && ssymval
>= 16
2468 /* Decodable bits. */
2469 && (insn
[0] & 0xfc) == 0x74
2470 /* Decodable bits. */
2471 && ((insn
[1] & 0xf0) == 0x00))
2476 insn
[1] = 0x50 | (insn
[1] & 0x0f);
2478 /* We can't relax this new opcode. */
2481 if (STACK_REL_P (ELF32_R_TYPE (srel
->r_info
)))
2482 newrel
= R_RX_ABS8U
;
2484 newrel
= R_RX_DIR8U
;
2486 SNIP (2, 1, newrel
);
2490 else if (code
== 2 && ssymval
<= 127 && ssymval
>= -128)
2492 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2496 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2497 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2499 SNIP (2, 1, newrel
);
2504 /* Special case UIMM4 format: CMP, MUL, AND, OR. */
2505 else if (code
== 1 && ssymval
<= 15 && ssymval
>= 0
2506 /* Decodable bits and immediate type. */
2508 /* Decodable bits. */
2509 && (insn
[1] & 0xc0) == 0x00)
2511 static const int newop
[4] = { 1, 3, 4, 5 };
2513 insn
[0] = 0x60 | newop
[insn
[1] >> 4];
2514 /* The register number doesn't move. */
2516 /* We can't relax this new opcode. */
2519 move_reloc (irel
, srel
, -1);
2521 SNIP (2, 1, R_RX_RH_UIMM4p8
);
2525 /* Special case UIMM4 format: ADD -> ADD/SUB. */
2526 else if (code
== 1 && ssymval
<= 15 && ssymval
>= -15
2527 /* Decodable bits and immediate type. */
2529 /* Same register for source and destination. */
2530 && ((insn
[1] >> 4) == (insn
[1] & 0x0f)))
2534 /* Note that we can't turn "add $0,Rs" into a NOP
2535 because the flags need to be set right. */
2539 insn
[0] = 0x60; /* Subtract. */
2540 newrel
= R_RX_RH_UNEG4p8
;
2544 insn
[0] = 0x62; /* Add. */
2545 newrel
= R_RX_RH_UIMM4p8
;
2548 /* The register number is in the right place. */
2550 /* We can't relax this new opcode. */
2553 move_reloc (irel
, srel
, -1);
2555 SNIP (2, 1, newrel
);
2560 /* These are either matched with a DSP6 (2-byte base) or an id24
2562 if (irel
->r_addend
& RX_RELAXA_IMM12
)
2564 int dspcode
, offset
= 0;
2569 if ((insn
[0] & 0xfc) == 0xfc)
2570 dspcode
= 1; /* Just something with one byte operand. */
2572 dspcode
= insn
[0] & 3;
2575 case 0: offset
= 2; break;
2576 case 1: offset
= 3; break;
2577 case 2: offset
= 4; break;
2578 case 3: offset
= 2; break;
2581 /* These relocations sign-extend, so we must do signed compares. */
2582 ssymval
= (long) symval
;
2584 code
= (insn
[1] >> 2) & 3;
2585 if (code
== 0 && ssymval
<= 8388607 && ssymval
>= -8388608)
2587 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2591 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2592 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2594 SNIP (offset
, 1, newrel
);
2599 else if (code
== 3 && ssymval
<= 32767 && ssymval
>= -32768)
2601 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2605 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2606 if (newrel
!= ELF32_R_TYPE (srel
->r_info
))
2608 SNIP (offset
, 1, newrel
);
2613 /* Special case UIMM8 format: MOV #uimm8,Rdst. */
2614 else if (code
== 2 && ssymval
<= 255 && ssymval
>= 16
2615 /* Decodable bits. */
2617 /* Decodable bits. */
2618 && ((insn
[1] & 0x03) == 0x02))
2623 insn
[1] = 0x40 | (insn
[1] >> 4);
2625 /* We can't relax this new opcode. */
2628 if (STACK_REL_P (ELF32_R_TYPE (srel
->r_info
)))
2629 newrel
= R_RX_ABS8U
;
2631 newrel
= R_RX_DIR8U
;
2633 SNIP (2, 1, newrel
);
2637 else if (code
== 2 && ssymval
<= 127 && ssymval
>= -128)
2639 unsigned int newrel
= ELF32_R_TYPE(srel
->r_info
);
2643 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2644 if (newrel
!= ELF32_R_TYPE(srel
->r_info
))
2646 SNIP (offset
, 1, newrel
);
2651 /* Special case UIMM4 format: MOV #uimm4,Rdst. */
2652 else if (code
== 1 && ssymval
<= 15 && ssymval
>= 0
2653 /* Decodable bits. */
2655 /* Decodable bits. */
2656 && ((insn
[1] & 0x03) == 0x02))
2659 insn
[1] = insn
[1] >> 4;
2661 /* We can't relax this new opcode. */
2664 move_reloc (irel
, srel
, -1);
2666 SNIP (2, 1, R_RX_RH_UIMM4p8
);
2671 if (irel
->r_addend
& RX_RELAXA_BRA
)
2673 unsigned int newrel
= ELF32_R_TYPE (srel
->r_info
);
2675 int alignment_glue
= 0;
2679 /* Branches over alignment chunks are problematic, as
2680 deleting bytes here makes the branch *further* away. We
2681 can be agressive with branches within this alignment
2682 block, but not branches outside it. */
2683 if ((prev_alignment
== NULL
2684 || symval
< (bfd_vma
)(sec_start
+ prev_alignment
->r_offset
))
2685 && (next_alignment
== NULL
2686 || symval
> (bfd_vma
)(sec_start
+ next_alignment
->r_offset
)))
2687 alignment_glue
= section_alignment_glue
;
2689 if (ELF32_R_TYPE(srel
[1].r_info
) == R_RX_RH_RELAX
2690 && srel
[1].r_addend
& RX_RELAXA_BRA
2691 && srel
[1].r_offset
< irel
->r_offset
+ pcrel
)
2694 newrel
= next_smaller_reloc (ELF32_R_TYPE (srel
->r_info
));
2696 /* The values we compare PCREL with are not what you'd
2697 expect; they're off by a little to compensate for (1)
2698 where the reloc is relative to the insn, and (2) how much
2699 the insn is going to change when we relax it. */
2701 /* These we have to decode. */
2704 case 0x04: /* BRA pcdsp:24 */
2705 if (-32768 + alignment_glue
<= pcrel
2706 && pcrel
<= 32765 - alignment_glue
)
2709 SNIP (3, 1, newrel
);
2714 case 0x38: /* BRA pcdsp:16 */
2715 if (-128 + alignment_glue
<= pcrel
2716 && pcrel
<= 127 - alignment_glue
)
2719 SNIP (2, 1, newrel
);
2724 case 0x2e: /* BRA pcdsp:8 */
2725 /* Note that there's a risk here of shortening things so
2726 much that we no longer fit this reloc; it *should*
2727 only happen when you branch across a branch, and that
2728 branch also devolves into BRA.S. "Real" code should
2730 if (max_pcrel3
+ alignment_glue
<= pcrel
2731 && pcrel
<= 10 - alignment_glue
2735 SNIP (1, 1, newrel
);
2736 move_reloc (irel
, srel
, -1);
2741 case 0x05: /* BSR pcdsp:24 */
2742 if (-32768 + alignment_glue
<= pcrel
2743 && pcrel
<= 32765 - alignment_glue
)
2746 SNIP (1, 1, newrel
);
2751 case 0x3a: /* BEQ.W pcdsp:16 */
2752 case 0x3b: /* BNE.W pcdsp:16 */
2753 if (-128 + alignment_glue
<= pcrel
2754 && pcrel
<= 127 - alignment_glue
)
2756 insn
[0] = 0x20 | (insn
[0] & 1);
2757 SNIP (1, 1, newrel
);
2762 case 0x20: /* BEQ.B pcdsp:8 */
2763 case 0x21: /* BNE.B pcdsp:8 */
2764 if (max_pcrel3
+ alignment_glue
<= pcrel
2765 && pcrel
- alignment_glue
<= 10
2768 insn
[0] = 0x10 | ((insn
[0] & 1) << 3);
2769 SNIP (1, 1, newrel
);
2770 move_reloc (irel
, srel
, -1);
2775 case 0x16: /* synthetic BNE dsp24 */
2776 case 0x1e: /* synthetic BEQ dsp24 */
2777 if (-32767 + alignment_glue
<= pcrel
2778 && pcrel
<= 32766 - alignment_glue
2781 if (insn
[0] == 0x16)
2785 /* We snip out the bytes at the end else the reloc
2786 will get moved too, and too much. */
2787 SNIP (3, 2, newrel
);
2788 move_reloc (irel
, srel
, -1);
2794 /* Special case - synthetic conditional branches, pcrel24.
2795 Note that EQ and NE have been handled above. */
2796 if ((insn
[0] & 0xf0) == 0x20
2799 && srel
->r_offset
!= irel
->r_offset
+ 1
2800 && -32767 + alignment_glue
<= pcrel
2801 && pcrel
<= 32766 - alignment_glue
)
2805 SNIP (5, 1, newrel
);
2809 /* Special case - synthetic conditional branches, pcrel16 */
2810 if ((insn
[0] & 0xf0) == 0x20
2813 && srel
->r_offset
!= irel
->r_offset
+ 1
2814 && -127 + alignment_glue
<= pcrel
2815 && pcrel
<= 126 - alignment_glue
)
2817 int cond
= (insn
[0] & 0x0f) ^ 0x01;
2819 insn
[0] = 0x20 | cond
;
2820 /* By moving the reloc first, we avoid having
2821 delete_bytes move it also. */
2822 move_reloc (irel
, srel
, -2);
2823 SNIP (2, 3, newrel
);
2828 BFD_ASSERT (nrelocs
== 0);
2830 /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can
2831 use MOV.bwl #uimm:8, dsp:5[r7] format. This is tricky
2832 because it may have one or two relocations. */
2833 if ((insn
[0] & 0xfc) == 0xf8
2834 && (insn
[1] & 0x80) == 0x00
2835 && (insn
[0] & 0x03) != 0x03)
2837 int dcode
, icode
, reg
, ioff
, dscale
, ilen
;
2838 bfd_vma disp_val
= 0;
2840 Elf_Internal_Rela
* disp_rel
= 0;
2841 Elf_Internal_Rela
* imm_rel
= 0;
2846 dcode
= insn
[0] & 0x03;
2847 icode
= (insn
[1] >> 2) & 0x03;
2848 reg
= (insn
[1] >> 4) & 0x0f;
2850 ioff
= dcode
== 1 ? 3 : dcode
== 2 ? 4 : 2;
2852 /* Figure out what the dispacement is. */
2853 if (dcode
== 1 || dcode
== 2)
2855 /* There's a displacement. See if there's a reloc for it. */
2856 if (srel
[1].r_offset
== irel
->r_offset
+ 2)
2868 #if RX_OPCODE_BIG_ENDIAN
2869 disp_val
= insn
[2] * 256 + insn
[3];
2871 disp_val
= insn
[2] + insn
[3] * 256;
2874 switch (insn
[1] & 3)
2890 /* Figure out what the immediate is. */
2891 if (srel
[1].r_offset
== irel
->r_offset
+ ioff
)
2894 imm_val
= (long) symval
;
2899 unsigned char * ip
= insn
+ ioff
;
2904 /* For byte writes, we don't sign extend. Makes the math easier later. */
2908 imm_val
= (char) ip
[0];
2911 #if RX_OPCODE_BIG_ENDIAN
2912 imm_val
= ((char) ip
[0] << 8) | ip
[1];
2914 imm_val
= ((char) ip
[1] << 8) | ip
[0];
2918 #if RX_OPCODE_BIG_ENDIAN
2919 imm_val
= ((char) ip
[0] << 16) | (ip
[1] << 8) | ip
[2];
2921 imm_val
= ((char) ip
[2] << 16) | (ip
[1] << 8) | ip
[0];
2925 #if RX_OPCODE_BIG_ENDIAN
2926 imm_val
= (ip
[0] << 24) | (ip
[1] << 16) | (ip
[2] << 8) | ip
[3];
2928 imm_val
= (ip
[3] << 24) | (ip
[2] << 16) | (ip
[1] << 8) | ip
[0];
2962 /* The shortcut happens when the immediate is 0..255,
2963 register r0 to r7, and displacement (scaled) 0..31. */
2965 if (0 <= imm_val
&& imm_val
<= 255
2966 && 0 <= reg
&& reg
<= 7
2967 && disp_val
/ dscale
<= 31)
2969 insn
[0] = 0x3c | (insn
[1] & 0x03);
2970 insn
[1] = (((disp_val
/ dscale
) << 3) & 0x80) | (reg
<< 4) | ((disp_val
/dscale
) & 0x0f);
2975 int newrel
= R_RX_NONE
;
2980 newrel
= R_RX_RH_ABS5p8B
;
2983 newrel
= R_RX_RH_ABS5p8W
;
2986 newrel
= R_RX_RH_ABS5p8L
;
2989 disp_rel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (disp_rel
->r_info
), newrel
);
2990 move_reloc (irel
, disp_rel
, -1);
2994 imm_rel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (imm_rel
->r_info
), R_RX_DIR8U
);
2995 move_reloc (disp_rel
? disp_rel
: irel
,
2997 irel
->r_offset
- imm_rel
->r_offset
+ 2);
3000 SNIPNR (3, ilen
- 3);
3003 /* We can't relax this new opcode. */
3009 /* We can't reliably relax branches to DIR3U_PCREL unless we know
3010 whatever they're branching over won't shrink any more. If we're
3011 basically done here, do one more pass just for branches - but
3012 don't request a pass after that one! */
3013 if (!*again
&& !allow_pcrel3
)
3015 bfd_boolean ignored
;
3017 elf32_rx_relax_section (abfd
, sec
, link_info
, &ignored
, TRUE
);
3023 if (free_contents
!= NULL
)
3024 free (free_contents
);
3026 if (shndx_buf
!= NULL
)
3028 shndx_hdr
->contents
= NULL
;
3032 if (free_intsyms
!= NULL
)
3033 free (free_intsyms
);
3039 elf32_rx_relax_section_wrapper (bfd
* abfd
,
3041 struct bfd_link_info
* link_info
,
3042 bfd_boolean
* again
)
3044 return elf32_rx_relax_section (abfd
, sec
, link_info
, again
, FALSE
);
3047 /* Function to set the ELF flag bits. */
3050 rx_elf_set_private_flags (bfd
* abfd
, flagword flags
)
3052 elf_elfheader (abfd
)->e_flags
= flags
;
3053 elf_flags_init (abfd
) = TRUE
;
3057 static bfd_boolean no_warn_mismatch
= FALSE
;
3058 static bfd_boolean ignore_lma
= TRUE
;
3060 void bfd_elf32_rx_set_target_flags (bfd_boolean
, bfd_boolean
);
3063 bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch
,
3064 bfd_boolean user_ignore_lma
)
3066 no_warn_mismatch
= user_no_warn_mismatch
;
3067 ignore_lma
= user_ignore_lma
;
3070 /* Converts FLAGS into a descriptive string.
3071 Returns a static pointer. */
3074 describe_flags (flagword flags
)
3076 static char buf
[128];
3080 if (flags
& E_FLAG_RX_64BIT_DOUBLES
)
3081 strcat (buf
, "64-bit doubles");
3083 strcat (buf
, "32-bit doubles");
3085 if (flags
& E_FLAG_RX_DSP
)
3086 strcat (buf
, ", dsp");
3088 strcat (buf
, ", no dsp");
3090 if (flags
& E_FLAG_RX_PID
)
3091 strcat (buf
, ", pid");
3093 strcat (buf
, ", no pid");
3095 if (flags
& E_FLAG_RX_ABI
)
3096 strcat (buf
, ", RX ABI");
3098 strcat (buf
, ", GCC ABI");
3100 if (flags
& E_FLAG_RX_SINSNS_SET
)
3101 strcat (buf
, flags
& E_FLAG_RX_SINSNS_YES
? ", uses String instructions" : ", bans String instructions");
3106 /* Merge backend specific data from an object file to the output
3107 object file when linking. */
3110 rx_elf_merge_private_bfd_data (bfd
* ibfd
, struct bfd_link_info
*info
)
3112 bfd
*obfd
= info
->output_bfd
;
3115 bfd_boolean error
= FALSE
;
3117 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3118 old_flags
= elf_elfheader (obfd
)->e_flags
;
3120 if (!elf_flags_init (obfd
))
3122 /* First call, no flags set. */
3123 elf_flags_init (obfd
) = TRUE
;
3124 elf_elfheader (obfd
)->e_flags
= new_flags
;
3126 else if (old_flags
!= new_flags
)
3128 flagword known_flags
;
3130 if (old_flags
& E_FLAG_RX_SINSNS_SET
)
3132 if ((new_flags
& E_FLAG_RX_SINSNS_SET
) == 0)
3134 new_flags
&= ~ E_FLAG_RX_SINSNS_MASK
;
3135 new_flags
|= (old_flags
& E_FLAG_RX_SINSNS_MASK
);
3138 else if (new_flags
& E_FLAG_RX_SINSNS_SET
)
3140 old_flags
&= ~ E_FLAG_RX_SINSNS_MASK
;
3141 old_flags
|= (new_flags
& E_FLAG_RX_SINSNS_MASK
);
3144 known_flags
= E_FLAG_RX_ABI
| E_FLAG_RX_64BIT_DOUBLES
3145 | E_FLAG_RX_DSP
| E_FLAG_RX_PID
| E_FLAG_RX_SINSNS_MASK
;
3147 if ((old_flags
^ new_flags
) & known_flags
)
3149 /* Only complain if flag bits we care about do not match.
3150 Other bits may be set, since older binaries did use some
3151 deprecated flags. */
3152 if (no_warn_mismatch
)
3154 elf_elfheader (obfd
)->e_flags
= (new_flags
| old_flags
) & known_flags
;
3158 _bfd_error_handler (_("there is a conflict merging the"
3159 " ELF header flags from %pB"),
3161 _bfd_error_handler (_(" the input file's flags: %s"),
3162 describe_flags (new_flags
));
3163 _bfd_error_handler (_(" the output file's flags: %s"),
3164 describe_flags (old_flags
));
3169 elf_elfheader (obfd
)->e_flags
= new_flags
& known_flags
;
3173 bfd_set_error (bfd_error_bad_value
);
3179 rx_elf_print_private_bfd_data (bfd
* abfd
, void * ptr
)
3181 FILE * file
= (FILE *) ptr
;
3184 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
3186 /* Print normal ELF private data. */
3187 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
3189 flags
= elf_elfheader (abfd
)->e_flags
;
3190 fprintf (file
, _("private flags = 0x%lx:"), (long) flags
);
3192 fprintf (file
, "%s", describe_flags (flags
));
3196 /* Return the MACH for an e_flags value. */
3199 elf32_rx_machine (bfd
* abfd ATTRIBUTE_UNUSED
)
3201 #if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_...
3202 Need to sort out how these flag bits are used.
3203 For now we assume that the flags are OK. */
3204 if ((elf_elfheader (abfd
)->e_flags
& EF_RX_CPU_MASK
) == EF_RX_CPU_RX
)
3212 rx_elf_object_p (bfd
* abfd
)
3216 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
3217 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
3218 int nphdrs
= ehdr
->e_phnum
;
3220 static int saw_be
= FALSE
;
3221 bfd_vma end_phdroff
;
3223 /* We never want to automatically choose the non-swapping big-endian
3224 target. The user can only get that explicitly, such as with -I
3226 if (abfd
->xvec
== &rx_elf32_be_ns_vec
3227 && abfd
->target_defaulted
)
3230 /* BFD->target_defaulted is not set to TRUE when a target is chosen
3231 as a fallback, so we check for "scanning" to know when to stop
3232 using the non-swapping target. */
3233 if (abfd
->xvec
== &rx_elf32_be_ns_vec
3236 if (abfd
->xvec
== &rx_elf32_be_vec
)
3239 bfd_default_set_arch_mach (abfd
, bfd_arch_rx
,
3240 elf32_rx_machine (abfd
));
3242 /* For each PHDR in the object, we must find some section that
3243 corresponds (based on matching file offsets) and use its VMA
3244 information to reconstruct the p_vaddr field we clobbered when we
3246 /* If PT_LOAD headers include the ELF file header or program headers
3247 then the PT_LOAD header does not start with some section contents.
3248 Making adjustments based on the difference between sh_offset and
3249 p_offset is nonsense in such cases. Exclude them. Note that
3250 since standard linker scripts for RX do not use SIZEOF_HEADERS,
3251 the linker won't normally create PT_LOAD segments covering the
3252 headers so this is mainly for passing the ld testsuite.
3253 FIXME. Why are we looking at non-PT_LOAD headers here? */
3254 end_phdroff
= ehdr
->e_ehsize
;
3255 if (ehdr
->e_phoff
!= 0)
3256 end_phdroff
= ehdr
->e_phoff
+ nphdrs
* ehdr
->e_phentsize
;
3257 for (i
=0; i
<nphdrs
; i
++)
3259 for (u
=0; u
<elf_tdata(abfd
)->num_elf_sections
; u
++)
3261 Elf_Internal_Shdr
*sec
= elf_tdata(abfd
)->elf_sect_ptr
[u
];
3263 if (phdr
[i
].p_filesz
3264 && phdr
[i
].p_offset
>= end_phdroff
3265 && phdr
[i
].p_offset
<= (bfd_vma
) sec
->sh_offset
3267 && sec
->sh_type
!= SHT_NOBITS
3268 && (bfd_vma
)sec
->sh_offset
<= phdr
[i
].p_offset
+ (phdr
[i
].p_filesz
- 1))
3270 /* Found one! The difference between the two addresses,
3271 plus the difference between the two file offsets, is
3272 enough information to reconstruct the lma. */
3274 /* Example where they aren't:
3275 PHDR[1] = lma fffc0100 offset 00002010 size 00000100
3276 SEC[6] = vma 00000050 offset 00002050 size 00000040
3278 The correct LMA for the section is fffc0140 + (2050-2010).
3281 phdr
[i
].p_vaddr
= sec
->sh_addr
+ (sec
->sh_offset
- phdr
[i
].p_offset
);
3286 /* We must update the bfd sections as well, so we don't stop
3288 bsec
= abfd
->sections
;
3291 if (phdr
[i
].p_filesz
3292 && phdr
[i
].p_vaddr
<= bsec
->vma
3293 && bsec
->vma
<= phdr
[i
].p_vaddr
+ (phdr
[i
].p_filesz
- 1))
3295 bsec
->lma
= phdr
[i
].p_paddr
+ (bsec
->vma
- phdr
[i
].p_vaddr
);
3307 rx_dump_symtab (bfd
* abfd
, void * internal_syms
, void * external_syms
)
3310 Elf_Internal_Sym
* isymbuf
;
3311 Elf_Internal_Sym
* isymend
;
3312 Elf_Internal_Sym
* isym
;
3313 Elf_Internal_Shdr
* symtab_hdr
;
3314 bfd_boolean free_internal
= FALSE
, free_external
= FALSE
;
3316 char * st_info_stb_str
;
3317 char * st_other_str
;
3318 char * st_shndx_str
;
3320 if (! internal_syms
)
3322 internal_syms
= bfd_malloc (1000);
3325 if (! external_syms
)
3327 external_syms
= bfd_malloc (1000);
3331 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3332 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3334 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3335 symtab_hdr
->sh_info
, 0,
3336 internal_syms
, external_syms
, NULL
);
3338 isymbuf
= internal_syms
;
3339 isymend
= isymbuf
+ locsymcount
;
3341 for (isym
= isymbuf
; isym
< isymend
; isym
++)
3343 switch (ELF_ST_TYPE (isym
->st_info
))
3345 case STT_FUNC
: st_info_str
= "STT_FUNC"; break;
3346 case STT_SECTION
: st_info_str
= "STT_SECTION"; break;
3347 case STT_FILE
: st_info_str
= "STT_FILE"; break;
3348 case STT_OBJECT
: st_info_str
= "STT_OBJECT"; break;
3349 case STT_TLS
: st_info_str
= "STT_TLS"; break;
3350 default: st_info_str
= "";
3352 switch (ELF_ST_BIND (isym
->st_info
))
3354 case STB_LOCAL
: st_info_stb_str
= "STB_LOCAL"; break;
3355 case STB_GLOBAL
: st_info_stb_str
= "STB_GLOBAL"; break;
3356 default: st_info_stb_str
= "";
3358 switch (ELF_ST_VISIBILITY (isym
->st_other
))
3360 case STV_DEFAULT
: st_other_str
= "STV_DEFAULT"; break;
3361 case STV_INTERNAL
: st_other_str
= "STV_INTERNAL"; break;
3362 case STV_PROTECTED
: st_other_str
= "STV_PROTECTED"; break;
3363 default: st_other_str
= "";
3365 switch (isym
->st_shndx
)
3367 case SHN_ABS
: st_shndx_str
= "SHN_ABS"; break;
3368 case SHN_COMMON
: st_shndx_str
= "SHN_COMMON"; break;
3369 case SHN_UNDEF
: st_shndx_str
= "SHN_UNDEF"; break;
3370 default: st_shndx_str
= "";
3373 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
3374 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
3376 (unsigned long) isym
->st_value
,
3377 (unsigned long) isym
->st_size
,
3379 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
3381 isym
->st_info
, st_info_str
, st_info_stb_str
,
3382 isym
->st_other
, st_other_str
,
3383 isym
->st_shndx
, st_shndx_str
);
3386 free (internal_syms
);
3388 free (external_syms
);
3392 rx_get_reloc (long reloc
)
3394 if (0 <= reloc
&& reloc
< R_RX_max
)
3395 return rx_elf_howto_table
[reloc
].name
;
3401 /* We must take care to keep the on-disk copy of any code sections
3402 that are fully linked swapped if the target is big endian, to match
3403 the Renesas tools. */
3405 /* The rule is: big endian object that are final-link executables,
3406 have code sections stored with 32-bit words swapped relative to
3407 what you'd get by default. */
3410 rx_get_section_contents (bfd
* abfd
,
3414 bfd_size_type count
)
3416 int exec
= (abfd
->flags
& EXEC_P
) ? 1 : 0;
3417 int s_code
= (section
->flags
& SEC_CODE
) ? 1 : 0;
3421 fprintf (stderr
, "dj: get %ld %ld from %s %s e%d sc%d %08lx:%08lx\n",
3422 (long) offset
, (long) count
, section
->name
,
3423 bfd_big_endian(abfd
) ? "be" : "le",
3424 exec
, s_code
, (long unsigned) section
->filepos
,
3425 (long unsigned) offset
);
3428 if (exec
&& s_code
&& bfd_big_endian (abfd
))
3430 char * cloc
= (char *) location
;
3431 bfd_size_type cnt
, end_cnt
;
3435 /* Fetch and swap unaligned bytes at the beginning. */
3440 rv
= _bfd_generic_get_section_contents (abfd
, section
, buf
,
3445 bfd_putb32 (bfd_getl32 (buf
), buf
);
3447 cnt
= 4 - (offset
% 4);
3451 memcpy (location
, buf
+ (offset
% 4), cnt
);
3458 end_cnt
= count
% 4;
3460 /* Fetch and swap the middle bytes. */
3463 rv
= _bfd_generic_get_section_contents (abfd
, section
, cloc
, offset
,
3468 for (cnt
= count
; cnt
>= 4; cnt
-= 4, cloc
+= 4)
3469 bfd_putb32 (bfd_getl32 (cloc
), cloc
);
3472 /* Fetch and swap the end bytes. */
3477 /* Fetch the end bytes. */
3478 rv
= _bfd_generic_get_section_contents (abfd
, section
, buf
,
3479 offset
+ count
- end_cnt
, 4);
3483 bfd_putb32 (bfd_getl32 (buf
), buf
);
3484 memcpy (cloc
, buf
, end_cnt
);
3488 rv
= _bfd_generic_get_section_contents (abfd
, section
, location
, offset
, count
);
3495 rx2_set_section_contents (bfd
* abfd
,
3497 const void * location
,
3499 bfd_size_type count
)
3503 fprintf (stderr
, " set sec %s %08x loc %p offset %#x count %#x\n",
3504 section
->name
, (unsigned) section
->vma
, location
, (int) offset
, (int) count
);
3505 for (i
= 0; i
< count
; i
++)
3507 if (i
% 16 == 0 && i
> 0)
3508 fprintf (stderr
, "\n");
3510 if (i
% 16 && i
% 4 == 0)
3511 fprintf (stderr
, " ");
3514 fprintf (stderr
, " %08x:", (int) (section
->vma
+ offset
+ i
));
3516 fprintf (stderr
, " %02x", ((unsigned char *) location
)[i
]);
3518 fprintf (stderr
, "\n");
3520 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
);
3522 #define _bfd_elf_set_section_contents rx2_set_section_contents
3526 rx_set_section_contents (bfd
* abfd
,
3528 const void * location
,
3530 bfd_size_type count
)
3532 bfd_boolean exec
= (abfd
->flags
& EXEC_P
) ? TRUE
: FALSE
;
3533 bfd_boolean s_code
= (section
->flags
& SEC_CODE
) ? TRUE
: FALSE
;
3535 char * swapped_data
= NULL
;
3537 bfd_vma caddr
= section
->vma
+ offset
;
3539 bfd_size_type scount
;
3544 fprintf (stderr
, "\ndj: set %ld %ld to %s %s e%d sc%d\n",
3545 (long) offset
, (long) count
, section
->name
,
3546 bfd_big_endian (abfd
) ? "be" : "le",
3549 for (i
= 0; i
< count
; i
++)
3551 int a
= section
->vma
+ offset
+ i
;
3553 if (a
% 16 == 0 && a
> 0)
3554 fprintf (stderr
, "\n");
3556 if (a
% 16 && a
% 4 == 0)
3557 fprintf (stderr
, " ");
3559 if (a
% 16 == 0 || i
== 0)
3560 fprintf (stderr
, " %08x:", (int) (section
->vma
+ offset
+ i
));
3562 fprintf (stderr
, " %02x", ((unsigned char *) location
)[i
]);
3565 fprintf (stderr
, "\n");
3568 if (! exec
|| ! s_code
|| ! bfd_big_endian (abfd
))
3569 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
);
3571 while (count
> 0 && caddr
> 0 && caddr
% 4)
3575 case 0: faddr
= offset
+ 3; break;
3576 case 1: faddr
= offset
+ 1; break;
3577 case 2: faddr
= offset
- 1; break;
3578 case 3: faddr
= offset
- 3; break;
3581 rv
= _bfd_elf_set_section_contents (abfd
, section
, location
, faddr
, 1);
3585 location
= (bfd_byte
*) location
+ 1;
3591 scount
= (int)(count
/ 4) * 4;
3594 char * cloc
= (char *) location
;
3596 swapped_data
= (char *) bfd_alloc (abfd
, count
);
3598 for (i
= 0; i
< count
; i
+= 4)
3600 bfd_vma v
= bfd_getl32 (cloc
+ i
);
3601 bfd_putb32 (v
, swapped_data
+ i
);
3604 rv
= _bfd_elf_set_section_contents (abfd
, section
, swapped_data
, offset
, scount
);
3611 location
= (bfd_byte
*) location
+ scount
;
3616 caddr
= section
->vma
+ offset
;
3621 case 0: faddr
= offset
+ 3; break;
3622 case 1: faddr
= offset
+ 1; break;
3623 case 2: faddr
= offset
- 1; break;
3624 case 3: faddr
= offset
- 3; break;
3626 rv
= _bfd_elf_set_section_contents (abfd
, section
, location
, faddr
, 1);
3630 location
= (bfd_byte
*) location
+ 1;
3641 rx_final_link (bfd
* abfd
, struct bfd_link_info
* info
)
3645 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
3648 fprintf (stderr
, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n",
3649 o
->name
, o
->flags
, o
->vma
, o
->lma
, o
->size
, o
->rawsize
);
3651 if (o
->flags
& SEC_CODE
3652 && bfd_big_endian (abfd
)
3656 fprintf (stderr
, "adjusting...\n");
3658 o
->size
+= 4 - (o
->size
% 4);
3662 return bfd_elf_final_link (abfd
, info
);
3666 elf32_rx_modify_program_headers (bfd
* abfd ATTRIBUTE_UNUSED
,
3667 struct bfd_link_info
* info ATTRIBUTE_UNUSED
)
3669 const struct elf_backend_data
* bed
;
3670 struct elf_obj_tdata
* tdata
;
3671 Elf_Internal_Phdr
* phdr
;
3675 bed
= get_elf_backend_data (abfd
);
3676 tdata
= elf_tdata (abfd
);
3678 count
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
3681 for (i
= count
; i
-- != 0;)
3682 if (phdr
[i
].p_type
== PT_LOAD
)
3684 /* The Renesas tools expect p_paddr to be zero. However,
3685 there is no other way to store the writable data in ROM for
3686 startup initialization. So, we let the linker *think*
3687 we're using paddr and vaddr the "usual" way, but at the
3688 last minute we move the paddr into the vaddr (which is what
3689 the simulator uses) and zero out paddr. Note that this
3690 does not affect the section headers, just the program
3691 headers. We hope. */
3692 phdr
[i
].p_vaddr
= phdr
[i
].p_paddr
;
3693 #if 0 /* If we zero out p_paddr, then the LMA in the section table
3695 phdr
[i
].p_paddr
= 0;
3702 /* The default literal sections should always be marked as "code" (i.e.,
3703 SHF_EXECINSTR). This is particularly important for big-endian mode
3704 when we do not want their contents byte reversed. */
3705 static const struct bfd_elf_special_section elf32_rx_special_sections
[] =
3707 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_EXECINSTR
},
3708 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_EXECINSTR
},
3709 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_EXECINSTR
},
3710 { NULL
, 0, 0, 0, 0 }
3715 struct bfd_link_info
*info
;
3716 bfd_vma table_start
;
3718 bfd_vma
*table_handlers
;
3719 bfd_vma table_default_handler
;
3720 struct bfd_link_hash_entry
**table_entries
;
3721 struct bfd_link_hash_entry
*table_default_entry
;
3726 rx_table_find (struct bfd_hash_entry
*vent
, void *vinfo
)
3728 RX_Table_Info
*info
= (RX_Table_Info
*)vinfo
;
3729 struct bfd_link_hash_entry
*ent
= (struct bfd_link_hash_entry
*)vent
;
3730 const char *name
; /* of the symbol we've found */
3734 const char *tname
; /* name of the table */
3735 bfd_vma start_addr
, end_addr
;
3737 struct bfd_link_hash_entry
* h
;
3739 /* We're looking for globally defined symbols of the form
3740 $tablestart$<NAME>. */
3741 if (ent
->type
!= bfd_link_hash_defined
3742 && ent
->type
!= bfd_link_hash_defweak
)
3745 name
= ent
->root
.string
;
3746 sec
= ent
->u
.def
.section
;
3749 if (strncmp (name
, "$tablestart$", 12))
3752 sec
->flags
|= SEC_KEEP
;
3756 start_addr
= ent
->u
.def
.value
;
3758 /* At this point, we can't build the table but we can (and must)
3759 find all the related symbols and mark their sections as SEC_KEEP
3760 so we don't garbage collect them. */
3762 buf
= (char *) malloc (12 + 10 + strlen (tname
));
3764 sprintf (buf
, "$tableend$%s", tname
);
3765 h
= bfd_link_hash_lookup (info
->info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
3766 if (!h
|| (h
->type
!= bfd_link_hash_defined
3767 && h
->type
!= bfd_link_hash_defweak
))
3769 /* xgettext:c-format */
3770 _bfd_error_handler (_("%pB:%pA: table %s missing corresponding %s"),
3771 abfd
, sec
, name
, buf
);
3775 if (h
->u
.def
.section
!= ent
->u
.def
.section
)
3777 /* xgettext:c-format */
3778 _bfd_error_handler (_("%pB:%pA: %s and %s must be in the same input section"),
3779 h
->u
.def
.section
->owner
, h
->u
.def
.section
,
3784 end_addr
= h
->u
.def
.value
;
3786 sprintf (buf
, "$tableentry$default$%s", tname
);
3787 h
= bfd_link_hash_lookup (info
->info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
3788 if (h
&& (h
->type
== bfd_link_hash_defined
3789 || h
->type
== bfd_link_hash_defweak
))
3791 h
->u
.def
.section
->flags
|= SEC_KEEP
;
3794 for (idx
= 0; idx
< (int) (end_addr
- start_addr
) / 4; idx
++)
3796 sprintf (buf
, "$tableentry$%d$%s", idx
, tname
);
3797 h
= bfd_link_hash_lookup (info
->info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
3798 if (h
&& (h
->type
== bfd_link_hash_defined
3799 || h
->type
== bfd_link_hash_defweak
))
3801 h
->u
.def
.section
->flags
|= SEC_KEEP
;
3805 /* Return TRUE to keep scanning, FALSE to end the traversal. */
3809 /* We need to check for table entry symbols and build the tables, and
3810 we need to do it before the linker does garbage collection. This function is
3811 called once per input object file. */
3814 (bfd
* abfd ATTRIBUTE_UNUSED
,
3815 struct bfd_link_info
* info ATTRIBUTE_UNUSED
)
3817 RX_Table_Info stuff
;
3821 bfd_hash_traverse (&(info
->hash
->table
), rx_table_find
, &stuff
);
3828 rx_table_map_2 (struct bfd_hash_entry
*vent
, void *vinfo
)
3830 RX_Table_Info
*info
= (RX_Table_Info
*)vinfo
;
3831 struct bfd_link_hash_entry
*ent
= (struct bfd_link_hash_entry
*)vent
;
3836 /* See if the symbol ENT has an address listed in the table, and
3837 isn't a debug/special symbol. If so, put it in the table. */
3839 if (ent
->type
!= bfd_link_hash_defined
3840 && ent
->type
!= bfd_link_hash_defweak
)
3843 name
= ent
->root
.string
;
3845 if (name
[0] == '$' || name
[0] == '.' || name
[0] < ' ')
3848 addr
= (ent
->u
.def
.value
3849 + ent
->u
.def
.section
->output_section
->vma
3850 + ent
->u
.def
.section
->output_offset
);
3852 for (idx
= 0; idx
< info
->table_size
; idx
++)
3853 if (addr
== info
->table_handlers
[idx
])
3854 info
->table_entries
[idx
] = ent
;
3856 if (addr
== info
->table_default_handler
)
3857 info
->table_default_entry
= ent
;
3863 rx_table_map (struct bfd_hash_entry
*vent
, void *vinfo
)
3865 RX_Table_Info
*info
= (RX_Table_Info
*)vinfo
;
3866 struct bfd_link_hash_entry
*ent
= (struct bfd_link_hash_entry
*)vent
;
3867 const char *name
; /* of the symbol we've found */
3869 const char *tname
; /* name of the table */
3870 bfd_vma start_addr
, end_addr
;
3872 struct bfd_link_hash_entry
* h
;
3875 /* We're looking for globally defined symbols of the form
3876 $tablestart$<NAME>. */
3877 if (ent
->type
!= bfd_link_hash_defined
3878 && ent
->type
!= bfd_link_hash_defweak
)
3881 name
= ent
->root
.string
;
3883 if (strncmp (name
, "$tablestart$", 12))
3887 start_addr
= (ent
->u
.def
.value
3888 + ent
->u
.def
.section
->output_section
->vma
3889 + ent
->u
.def
.section
->output_offset
);
3891 buf
= (char *) malloc (12 + 10 + strlen (tname
));
3893 sprintf (buf
, "$tableend$%s", tname
);
3894 end_addr
= get_symbol_value_maybe (buf
, info
->info
);
3896 sprintf (buf
, "$tableentry$default$%s", tname
);
3897 h
= bfd_link_hash_lookup (info
->info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
3900 info
->table_default_handler
= (h
->u
.def
.value
3901 + h
->u
.def
.section
->output_section
->vma
3902 + h
->u
.def
.section
->output_offset
);
3905 /* Zero is a valid handler address! */
3906 info
->table_default_handler
= (bfd_vma
) (-1);
3907 info
->table_default_entry
= NULL
;
3909 info
->table_start
= start_addr
;
3910 info
->table_size
= (int) (end_addr
- start_addr
) / 4;
3911 info
->table_handlers
= (bfd_vma
*) malloc (info
->table_size
* sizeof (bfd_vma
));
3912 info
->table_entries
= (struct bfd_link_hash_entry
**) malloc (info
->table_size
* sizeof (struct bfd_link_hash_entry
));
3914 for (idx
= 0; idx
< (int) (end_addr
- start_addr
) / 4; idx
++)
3916 sprintf (buf
, "$tableentry$%d$%s", idx
, tname
);
3917 h
= bfd_link_hash_lookup (info
->info
->hash
, buf
, FALSE
, FALSE
, TRUE
);
3918 if (h
&& (h
->type
== bfd_link_hash_defined
3919 || h
->type
== bfd_link_hash_defweak
))
3921 info
->table_handlers
[idx
] = (h
->u
.def
.value
3922 + h
->u
.def
.section
->output_section
->vma
3923 + h
->u
.def
.section
->output_offset
);
3926 info
->table_handlers
[idx
] = info
->table_default_handler
;
3927 info
->table_entries
[idx
] = NULL
;
3932 bfd_hash_traverse (&(info
->info
->hash
->table
), rx_table_map_2
, info
);
3934 fprintf (info
->mapfile
, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT
"x\n\n",
3935 tname
, info
->table_size
, start_addr
);
3937 if (info
->table_default_entry
)
3938 fprintf (info
->mapfile
, " default handler is: %s at 0x%08" BFD_VMA_FMT
"x\n",
3939 info
->table_default_entry
->root
.string
,
3940 info
->table_default_handler
);
3941 else if (info
->table_default_handler
!= (bfd_vma
)(-1))
3942 fprintf (info
->mapfile
, " default handler is at 0x%08" BFD_VMA_FMT
"x\n",
3943 info
->table_default_handler
);
3945 fprintf (info
->mapfile
, " no default handler\n");
3948 for (idx
= 0; idx
< info
->table_size
; idx
++)
3950 if (info
->table_handlers
[idx
] == info
->table_default_handler
)
3953 fprintf (info
->mapfile
, " . . .\n");
3959 fprintf (info
->mapfile
, " 0x%08" BFD_VMA_FMT
"x [%3d] ", start_addr
+ 4 * idx
, idx
);
3961 if (info
->table_handlers
[idx
] == (bfd_vma
) (-1))
3962 fprintf (info
->mapfile
, "(no handler found)\n");
3964 else if (info
->table_handlers
[idx
] == info
->table_default_handler
)
3966 if (info
->table_default_entry
)
3967 fprintf (info
->mapfile
, "(default)\n");
3969 fprintf (info
->mapfile
, "(default)\n");
3972 else if (info
->table_entries
[idx
])
3974 fprintf (info
->mapfile
, "0x%08" BFD_VMA_FMT
"x %s\n", info
->table_handlers
[idx
], info
->table_entries
[idx
]->root
.string
);
3979 fprintf (info
->mapfile
, "0x%08" BFD_VMA_FMT
"x ???\n", info
->table_handlers
[idx
]);
3983 fprintf (info
->mapfile
, " . . .\n");
3989 rx_additional_link_map_text (bfd
*obfd
, struct bfd_link_info
*info
, FILE *mapfile
)
3991 /* We scan the symbol table looking for $tableentry$'s, and for
3992 each, try to deduce which handlers go with which entries. */
3994 RX_Table_Info stuff
;
3998 stuff
.mapfile
= mapfile
;
3999 bfd_hash_traverse (&(info
->hash
->table
), rx_table_map
, &stuff
);
4003 #define ELF_ARCH bfd_arch_rx
4004 #define ELF_MACHINE_CODE EM_RX
4005 #define ELF_MAXPAGESIZE 0x1000
4007 #define TARGET_BIG_SYM rx_elf32_be_vec
4008 #define TARGET_BIG_NAME "elf32-rx-be"
4010 #define TARGET_LITTLE_SYM rx_elf32_le_vec
4011 #define TARGET_LITTLE_NAME "elf32-rx-le"
4013 #define elf_info_to_howto_rel NULL
4014 #define elf_info_to_howto rx_info_to_howto_rela
4015 #define elf_backend_object_p rx_elf_object_p
4016 #define elf_backend_relocate_section rx_elf_relocate_section
4017 #define elf_symbol_leading_char ('_')
4018 #define elf_backend_can_gc_sections 1
4019 #define elf_backend_modify_program_headers elf32_rx_modify_program_headers
4021 #define bfd_elf32_bfd_reloc_type_lookup rx_reloc_type_lookup
4022 #define bfd_elf32_bfd_reloc_name_lookup rx_reloc_name_lookup
4023 #define bfd_elf32_bfd_set_private_flags rx_elf_set_private_flags
4024 #define bfd_elf32_bfd_merge_private_bfd_data rx_elf_merge_private_bfd_data
4025 #define bfd_elf32_bfd_print_private_bfd_data rx_elf_print_private_bfd_data
4026 #define bfd_elf32_get_section_contents rx_get_section_contents
4027 #define bfd_elf32_set_section_contents rx_set_section_contents
4028 #define bfd_elf32_bfd_final_link rx_final_link
4029 #define bfd_elf32_bfd_relax_section elf32_rx_relax_section_wrapper
4030 #define elf_backend_special_sections elf32_rx_special_sections
4031 #define elf_backend_check_directives rx_check_directives
4033 #include "elf32-target.h"
4035 /* We define a second big-endian target that doesn't have the custom
4036 section get/set hooks, for times when we want to preserve the
4037 pre-swapped .text sections (like objcopy). */
4039 #undef TARGET_BIG_SYM
4040 #define TARGET_BIG_SYM rx_elf32_be_ns_vec
4041 #undef TARGET_BIG_NAME
4042 #define TARGET_BIG_NAME "elf32-rx-be-ns"
4043 #undef TARGET_LITTLE_SYM
4045 #undef bfd_elf32_get_section_contents
4046 #undef bfd_elf32_set_section_contents
4049 #define elf32_bed elf32_rx_be_ns_bed
4051 #include "elf32-target.h"