1 /* Renesas RX specific support for 32-bit ELF.
2 Copyright (C) 2008-2015 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "bfd_stdint.h"
26 #include "libiberty.h"
29 #define RX_OPCODE_BIG_ENDIAN 0
31 /* This is a meta-target that's used only with objcopy, to avoid the
32 endian-swap we would otherwise get. We check for this in
34 const bfd_target rx_elf32_be_ns_vec;
35 const bfd_target rx_elf32_be_vec;
38 char * rx_get_reloc (long);
39 void rx_dump_symtab (bfd *, void *, void *);
42 #define RXREL(n,sz,bit,shift,complain,pcrel) \
43 HOWTO (R_RX_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
44 bfd_elf_generic_reloc, "R_RX_" #n, FALSE, 0, ~0, FALSE)
46 /* Note that the relocations around 0x7f are internal to this file;
47 feel free to move them as needed to avoid conflicts with published
48 relocation numbers. */
50 static reloc_howto_type rx_elf_howto_table [] =
52 RXREL (NONE, 3, 0, 0, dont, FALSE),
53 RXREL (DIR32, 2, 32, 0, signed, FALSE),
54 RXREL (DIR24S, 2, 24, 0, signed, FALSE),
55 RXREL (DIR16, 1, 16, 0, dont, FALSE),
56 RXREL (DIR16U, 1, 16, 0, unsigned, FALSE),
57 RXREL (DIR16S, 1, 16, 0, signed, FALSE),
58 RXREL (DIR8, 0, 8, 0, dont, FALSE),
59 RXREL (DIR8U, 0, 8, 0, unsigned, FALSE),
60 RXREL (DIR8S, 0, 8, 0, signed, FALSE),
61 RXREL (DIR24S_PCREL, 2, 24, 0, signed, TRUE),
62 RXREL (DIR16S_PCREL, 1, 16, 0, signed, TRUE),
63 RXREL (DIR8S_PCREL, 0, 8, 0, signed, TRUE),
64 RXREL (DIR16UL, 1, 16, 2, unsigned, FALSE),
65 RXREL (DIR16UW, 1, 16, 1, unsigned, FALSE),
66 RXREL (DIR8UL, 0, 8, 2, unsigned, FALSE),
67 RXREL (DIR8UW, 0, 8, 1, unsigned, FALSE),
68 RXREL (DIR32_REV, 1, 16, 0, dont, FALSE),
69 RXREL (DIR16_REV, 1, 16, 0, dont, FALSE),
70 RXREL (DIR3U_PCREL, 0, 3, 0, dont, TRUE),
86 RXREL (RH_3_PCREL, 0, 3, 0, signed, TRUE),
87 RXREL (RH_16_OP, 1, 16, 0, signed, FALSE),
88 RXREL (RH_24_OP, 2, 24, 0, signed, FALSE),
89 RXREL (RH_32_OP, 2, 32, 0, signed, FALSE),
90 RXREL (RH_24_UNS, 2, 24, 0, unsigned, FALSE),
91 RXREL (RH_8_NEG, 0, 8, 0, signed, FALSE),
92 RXREL (RH_16_NEG, 1, 16, 0, signed, FALSE),
93 RXREL (RH_24_NEG, 2, 24, 0, signed, FALSE),
94 RXREL (RH_32_NEG, 2, 32, 0, signed, FALSE),
95 RXREL (RH_DIFF, 2, 32, 0, signed, FALSE),
96 RXREL (RH_GPRELB, 1, 16, 0, unsigned, FALSE),
97 RXREL (RH_GPRELW, 1, 16, 0, unsigned, FALSE),
98 RXREL (RH_GPRELL, 1, 16, 0, unsigned, FALSE),
99 RXREL (RH_RELAX, 0, 0, 0, dont, FALSE),
121 RXREL (ABS32, 2, 32, 0, dont, FALSE),
122 RXREL (ABS24S, 2, 24, 0, signed, FALSE),
123 RXREL (ABS16, 1, 16, 0, dont, FALSE),
124 RXREL (ABS16U, 1, 16, 0, unsigned, FALSE),
125 RXREL (ABS16S, 1, 16, 0, signed, FALSE),
126 RXREL (ABS8, 0, 8, 0, dont, FALSE),
127 RXREL (ABS8U, 0, 8, 0, unsigned, FALSE),
128 RXREL (ABS8S, 0, 8, 0, signed, FALSE),
129 RXREL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
130 RXREL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
131 RXREL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
132 RXREL (ABS16UL, 1, 16, 0, unsigned, FALSE),
133 RXREL (ABS16UW, 1, 16, 0, unsigned, FALSE),
134 RXREL (ABS8UL, 0, 8, 0, unsigned, FALSE),
135 RXREL (ABS8UW, 0, 8, 0, unsigned, FALSE),
136 RXREL (ABS32_REV, 2, 32, 0, dont, FALSE),
137 RXREL (ABS16_REV, 1, 16, 0, dont, FALSE),
139 #define STACK_REL_P(x) ((x) <= R_RX_ABS16_REV && (x) >= R_RX_ABS32)
180 /* These are internal. */
181 /* A 5-bit unsigned displacement to a B/W/L address, at bit position 8/12. */
182 /* ---- ---- 4--- 3210. */
183 #define R_RX_RH_ABS5p8B 0x78
184 RXREL (RH_ABS5p8B, 0, 0, 0, dont, FALSE),
185 #define R_RX_RH_ABS5p8W 0x79
186 RXREL (RH_ABS5p8W, 0, 0, 0, dont, FALSE),
187 #define R_RX_RH_ABS5p8L 0x7a
188 RXREL (RH_ABS5p8L, 0, 0, 0, dont, FALSE),
189 /* A 5-bit unsigned displacement to a B/W/L address, at bit position 5/12. */
190 /* ---- -432 1--- 0---. */
191 #define R_RX_RH_ABS5p5B 0x7b
192 RXREL (RH_ABS5p5B, 0, 0, 0, dont, FALSE),
193 #define R_RX_RH_ABS5p5W 0x7c
194 RXREL (RH_ABS5p5W, 0, 0, 0, dont, FALSE),
195 #define R_RX_RH_ABS5p5L 0x7d
196 RXREL (RH_ABS5p5L, 0, 0, 0, dont, FALSE),
197 /* A 4-bit unsigned immediate at bit position 8. */
198 #define R_RX_RH_UIMM4p8 0x7e
199 RXREL (RH_UIMM4p8, 0, 0, 0, dont, FALSE),
200 /* A 4-bit negative unsigned immediate at bit position 8. */
201 #define R_RX_RH_UNEG4p8 0x7f
202 RXREL (RH_UNEG4p8, 0, 0, 0, dont, FALSE),
203 /* End of internal relocs. */
205 RXREL (SYM, 2, 32, 0, dont, FALSE),
206 RXREL (OPneg, 2, 32, 0, dont, FALSE),
207 RXREL (OPadd, 2, 32, 0, dont, FALSE),
208 RXREL (OPsub, 2, 32, 0, dont, FALSE),
209 RXREL (OPmul, 2, 32, 0, dont, FALSE),
210 RXREL (OPdiv, 2, 32, 0, dont, FALSE),
211 RXREL (OPshla, 2, 32, 0, dont, FALSE),
212 RXREL (OPshra, 2, 32, 0, dont, FALSE),
213 RXREL (OPsctsize, 2, 32, 0, dont, FALSE),
214 RXREL (OPscttop, 2, 32, 0, dont, FALSE),
215 RXREL (OPand, 2, 32, 0, dont, FALSE),
216 RXREL (OPor, 2, 32, 0, dont, FALSE),
217 RXREL (OPxor, 2, 32, 0, dont, FALSE),
218 RXREL (OPnot, 2, 32, 0, dont, FALSE),
219 RXREL (OPmod, 2, 32, 0, dont, FALSE),
220 RXREL (OPromtop, 2, 32, 0, dont, FALSE),
221 RXREL (OPramtop, 2, 32, 0, dont, FALSE)
224 /* Map BFD reloc types to RX ELF reloc types. */
228 bfd_reloc_code_real_type bfd_reloc_val;
229 unsigned int rx_reloc_val;
232 static const struct rx_reloc_map rx_reloc_map [] =
234 { BFD_RELOC_NONE, R_RX_NONE },
235 { BFD_RELOC_8, R_RX_DIR8S },
236 { BFD_RELOC_16, R_RX_DIR16S },
237 { BFD_RELOC_24, R_RX_DIR24S },
238 { BFD_RELOC_32, R_RX_DIR32 },
239 { BFD_RELOC_RX_16_OP, R_RX_DIR16 },
240 { BFD_RELOC_RX_DIR3U_PCREL, R_RX_DIR3U_PCREL },
241 { BFD_RELOC_8_PCREL, R_RX_DIR8S_PCREL },
242 { BFD_RELOC_16_PCREL, R_RX_DIR16S_PCREL },
243 { BFD_RELOC_24_PCREL, R_RX_DIR24S_PCREL },
244 { BFD_RELOC_RX_8U, R_RX_DIR8U },
245 { BFD_RELOC_RX_16U, R_RX_DIR16U },
246 { BFD_RELOC_RX_24U, R_RX_RH_24_UNS },
247 { BFD_RELOC_RX_NEG8, R_RX_RH_8_NEG },
248 { BFD_RELOC_RX_NEG16, R_RX_RH_16_NEG },
249 { BFD_RELOC_RX_NEG24, R_RX_RH_24_NEG },
250 { BFD_RELOC_RX_NEG32, R_RX_RH_32_NEG },
251 { BFD_RELOC_RX_DIFF, R_RX_RH_DIFF },
252 { BFD_RELOC_RX_GPRELB, R_RX_RH_GPRELB },
253 { BFD_RELOC_RX_GPRELW, R_RX_RH_GPRELW },
254 { BFD_RELOC_RX_GPRELL, R_RX_RH_GPRELL },
255 { BFD_RELOC_RX_RELAX, R_RX_RH_RELAX },
256 { BFD_RELOC_RX_SYM, R_RX_SYM },
257 { BFD_RELOC_RX_OP_SUBTRACT, R_RX_OPsub },
258 { BFD_RELOC_RX_OP_NEG, R_RX_OPneg },
259 { BFD_RELOC_RX_ABS8, R_RX_ABS8 },
260 { BFD_RELOC_RX_ABS16, R_RX_ABS16 },
261 { BFD_RELOC_RX_ABS16_REV, R_RX_ABS16_REV },
262 { BFD_RELOC_RX_ABS32, R_RX_ABS32 },
263 { BFD_RELOC_RX_ABS32_REV, R_RX_ABS32_REV },
264 { BFD_RELOC_RX_ABS16UL, R_RX_ABS16UL },
265 { BFD_RELOC_RX_ABS16UW, R_RX_ABS16UW },
266 { BFD_RELOC_RX_ABS16U, R_RX_ABS16U }
269 #define BIGE(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
271 static reloc_howto_type *
272 rx_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
273 bfd_reloc_code_real_type code)
277 if (code == BFD_RELOC_RX_32_OP)
278 return rx_elf_howto_table + R_RX_DIR32;
280 for (i = ARRAY_SIZE (rx_reloc_map); i--;)
281 if (rx_reloc_map [i].bfd_reloc_val == code)
282 return rx_elf_howto_table + rx_reloc_map[i].rx_reloc_val;
287 static reloc_howto_type *
288 rx_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
292 for (i = 0; i < ARRAY_SIZE (rx_elf_howto_table); i++)
293 if (rx_elf_howto_table[i].name != NULL
294 && strcasecmp (rx_elf_howto_table[i].name, r_name) == 0)
295 return rx_elf_howto_table + i;
300 /* Set the howto pointer for an RX ELF reloc. */
303 rx_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
305 Elf_Internal_Rela * dst)
309 r_type = ELF32_R_TYPE (dst->r_info);
310 if (r_type >= (unsigned int) R_RX_max)
312 _bfd_error_handler (_("%B: invalid RX reloc number: %d"), abfd, r_type);
315 cache_ptr->howto = rx_elf_howto_table + r_type;
319 get_symbol_value (const char * name,
320 bfd_reloc_status_type * status,
321 struct bfd_link_info * info,
323 asection * input_section,
327 struct bfd_link_hash_entry * h;
329 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
332 || (h->type != bfd_link_hash_defined
333 && h->type != bfd_link_hash_defweak))
334 * status = info->callbacks->undefined_symbol
335 (info, name, input_bfd, input_section, offset, TRUE);
337 value = (h->u.def.value
338 + h->u.def.section->output_section->vma
339 + h->u.def.section->output_offset);
344 get_symbol_value_maybe (const char * name,
345 struct bfd_link_info * info)
348 struct bfd_link_hash_entry * h;
350 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
353 || (h->type != bfd_link_hash_defined
354 && h->type != bfd_link_hash_defweak))
357 value = (h->u.def.value
358 + h->u.def.section->output_section->vma
359 + h->u.def.section->output_offset);
365 get_gp (bfd_reloc_status_type * status,
366 struct bfd_link_info * info,
371 static bfd_boolean cached = FALSE;
372 static bfd_vma cached_value = 0;
376 cached_value = get_symbol_value ("__gp", status, info, abfd, sec, offset);
383 get_romstart (bfd_reloc_status_type * status,
384 struct bfd_link_info * info,
389 static bfd_boolean cached = FALSE;
390 static bfd_vma cached_value = 0;
394 cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
401 get_ramstart (bfd_reloc_status_type * status,
402 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", status, 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)
556 bfd_reloc_status_type tstat = 0;
558 if (table_default_cache != name)
561 /* All relocs for a given table should be to the same
562 (weak) default symbol) so we can use it to detect a
563 cache miss. We use the offset into the table to find
564 the "real" symbol. Calculate and store the table's
567 table_default_cache = name;
569 /* We have already done error checking in rx_table_find(). */
571 buf = (char *) malloc (13 + strlen (name + 20));
573 sprintf (buf, "$tablestart$%s", name + 20);
575 table_start_cache = get_symbol_value (buf,
582 sprintf (buf, "$tableend$%s", name + 20);
584 table_end_cache = get_symbol_value (buf,
594 entry_vma = (input_section->output_section->vma
595 + input_section->output_offset
598 if (table_end_cache <= entry_vma || entry_vma < table_start_cache)
600 _bfd_error_handler (_("%B:%A: table entry %s outside table"),
601 input_bfd, input_section,
604 else if ((int) (entry_vma - table_start_cache) % 4)
606 _bfd_error_handler (_("%B:%A: table entry %s not word-aligned within table"),
607 input_bfd, input_section,
612 idx = (int) (entry_vma - table_start_cache) / 4;
614 /* This will look like $tableentry$<N>$<name> */
615 buf = (char *) malloc (12 + 20 + strlen (name + 20));
616 sprintf (buf, "$tableentry$%d$%s", idx, name + 20);
618 h = (struct elf_link_hash_entry *) bfd_link_hash_lookup (info->hash, buf, FALSE, FALSE, TRUE);
622 relocation = (h->root.u.def.value
623 + h->root.u.def.section->output_section->vma
624 + h->root.u.def.section->output_offset);;
631 if (sec != NULL && discarded_section (sec))
632 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
633 rel, 1, relend, howto, 0, contents);
635 if (info->relocatable)
637 /* This is a relocatable link. We don't have to change
638 anything, unless the reloc is against a section symbol,
639 in which case we have to adjust according to where the
640 section symbol winds up in the output section. */
641 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
642 rel->r_addend += sec->output_offset;
646 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
647 /* If the symbol is undefined and weak
648 then the relocation resolves to zero. */
652 if (howto->pc_relative)
654 relocation -= (input_section->output_section->vma
655 + input_section->output_offset
657 if (r_type != R_RX_RH_3_PCREL
658 && r_type != R_RX_DIR3U_PCREL)
662 relocation += rel->r_addend;
667 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
668 #define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
669 #define OP(i) (contents[rel->r_offset + (i)])
670 #define WARN_REDHAT(type) \
671 _bfd_error_handler (_("%B:%A: Warning: deprecated Red Hat reloc " type " detected against: %s."), \
672 input_bfd, input_section, name)
674 /* Check for unsafe relocs in PID mode. These are any relocs where
675 an absolute address is being computed. There are special cases
676 for relocs against symbols that are known to be referenced in
677 crt0.o before the PID base address register has been initialised. */
678 #define UNSAFE_FOR_PID \
683 && sec->flags & SEC_READONLY \
684 && !(input_section->flags & SEC_DEBUGGING) \
685 && strcmp (name, "__pid_base") != 0 \
686 && strcmp (name, "__gp") != 0 \
687 && strcmp (name, "__romdatastart") != 0 \
689 _bfd_error_handler (_("%B(%A): unsafe PID relocation %s at 0x%08lx (against %s in %s)"), \
690 input_bfd, input_section, howto->name, \
691 input_section->output_section->vma + input_section->output_offset + rel->r_offset, \
696 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
705 case R_RX_RH_3_PCREL:
706 WARN_REDHAT ("RX_RH_3_PCREL");
709 OP (0) |= relocation & 0x07;
713 WARN_REDHAT ("RX_RH_8_NEG");
714 relocation = - relocation;
715 case R_RX_DIR8S_PCREL:
734 WARN_REDHAT ("RX_RH_16_NEG");
735 relocation = - relocation;
736 case R_RX_DIR16S_PCREL:
738 RANGE (-32768, 32767);
739 #if RX_OPCODE_BIG_ENDIAN
742 OP (1) = relocation >> 8;
747 WARN_REDHAT ("RX_RH_16_OP");
749 RANGE (-32768, 32767);
750 #if RX_OPCODE_BIG_ENDIAN
752 OP (0) = relocation >> 8;
755 OP (1) = relocation >> 8;
761 RANGE (-32768, 65535);
762 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
765 OP (0) = relocation >> 8;
770 OP (1) = relocation >> 8;
777 #if RX_OPCODE_BIG_ENDIAN
779 OP (0) = relocation >> 8;
782 OP (1) = relocation >> 8;
788 RANGE (-32768, 65536);
789 #if RX_OPCODE_BIG_ENDIAN
791 OP (0) = relocation >> 8;
794 OP (1) = relocation >> 8;
800 RANGE (-32768, 65536);
801 #if RX_OPCODE_BIG_ENDIAN
803 OP (1) = relocation >> 8;
806 OP (0) = relocation >> 8;
810 case R_RX_DIR3U_PCREL:
813 OP (0) |= relocation & 0x07;
818 WARN_REDHAT ("RX_RH_24_NEG");
819 relocation = - relocation;
820 case R_RX_DIR24S_PCREL:
821 RANGE (-0x800000, 0x7fffff);
822 #if RX_OPCODE_BIG_ENDIAN
824 OP (1) = relocation >> 8;
825 OP (0) = relocation >> 16;
828 OP (1) = relocation >> 8;
829 OP (2) = relocation >> 16;
835 WARN_REDHAT ("RX_RH_24_OP");
836 RANGE (-0x800000, 0x7fffff);
837 #if RX_OPCODE_BIG_ENDIAN
839 OP (1) = relocation >> 8;
840 OP (0) = relocation >> 16;
843 OP (1) = relocation >> 8;
844 OP (2) = relocation >> 16;
850 RANGE (-0x800000, 0x7fffff);
851 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
854 OP (1) = relocation >> 8;
855 OP (0) = relocation >> 16;
860 OP (1) = relocation >> 8;
861 OP (2) = relocation >> 16;
867 WARN_REDHAT ("RX_RH_24_UNS");
869 #if RX_OPCODE_BIG_ENDIAN
871 OP (1) = relocation >> 8;
872 OP (0) = relocation >> 16;
875 OP (1) = relocation >> 8;
876 OP (2) = relocation >> 16;
882 WARN_REDHAT ("RX_RH_32_NEG");
883 relocation = - relocation;
884 #if RX_OPCODE_BIG_ENDIAN
886 OP (2) = relocation >> 8;
887 OP (1) = relocation >> 16;
888 OP (0) = relocation >> 24;
891 OP (1) = relocation >> 8;
892 OP (2) = relocation >> 16;
893 OP (3) = relocation >> 24;
899 WARN_REDHAT ("RX_RH_32_OP");
900 #if RX_OPCODE_BIG_ENDIAN
902 OP (2) = relocation >> 8;
903 OP (1) = relocation >> 16;
904 OP (0) = relocation >> 24;
907 OP (1) = relocation >> 8;
908 OP (2) = relocation >> 16;
909 OP (3) = relocation >> 24;
914 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
917 OP (2) = relocation >> 8;
918 OP (1) = relocation >> 16;
919 OP (0) = relocation >> 24;
924 OP (1) = relocation >> 8;
925 OP (2) = relocation >> 16;
926 OP (3) = relocation >> 24;
931 if (BIGE (output_bfd))
934 OP (1) = relocation >> 8;
935 OP (2) = relocation >> 16;
936 OP (3) = relocation >> 24;
941 OP (2) = relocation >> 8;
942 OP (1) = relocation >> 16;
943 OP (0) = relocation >> 24;
950 WARN_REDHAT ("RX_RH_DIFF");
951 val = bfd_get_32 (output_bfd, & OP (0));
953 bfd_put_32 (output_bfd, val, & OP (0));
958 WARN_REDHAT ("RX_RH_GPRELB");
959 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
961 #if RX_OPCODE_BIG_ENDIAN
963 OP (0) = relocation >> 8;
966 OP (1) = relocation >> 8;
971 WARN_REDHAT ("RX_RH_GPRELW");
972 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
976 #if RX_OPCODE_BIG_ENDIAN
978 OP (0) = relocation >> 8;
981 OP (1) = relocation >> 8;
986 WARN_REDHAT ("RX_RH_GPRELL");
987 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
991 #if RX_OPCODE_BIG_ENDIAN
993 OP (0) = relocation >> 8;
996 OP (1) = relocation >> 8;
1000 /* Internal relocations just for relaxation: */
1001 case R_RX_RH_ABS5p5B:
1002 RX_STACK_POP (relocation);
1005 OP (0) |= relocation >> 2;
1007 OP (1) |= (relocation << 6) & 0x80;
1008 OP (1) |= (relocation << 3) & 0x08;
1011 case R_RX_RH_ABS5p5W:
1012 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_ABS5p5L:
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_ABS5p8B:
1036 RX_STACK_POP (relocation);
1039 OP (0) |= (relocation << 3) & 0x80;
1040 OP (0) |= relocation & 0x0f;
1043 case R_RX_RH_ABS5p8W:
1044 RX_STACK_POP (relocation);
1049 OP (0) |= (relocation << 3) & 0x80;
1050 OP (0) |= relocation & 0x0f;
1053 case R_RX_RH_ABS5p8L:
1054 RX_STACK_POP (relocation);
1059 OP (0) |= (relocation << 3) & 0x80;
1060 OP (0) |= relocation & 0x0f;
1063 case R_RX_RH_UIMM4p8:
1066 OP (0) |= relocation << 4;
1069 case R_RX_RH_UNEG4p8:
1072 OP (0) |= (-relocation) << 4;
1075 /* Complex reloc handling: */
1079 RX_STACK_POP (relocation);
1080 #if RX_OPCODE_BIG_ENDIAN
1081 OP (3) = relocation;
1082 OP (2) = relocation >> 8;
1083 OP (1) = relocation >> 16;
1084 OP (0) = relocation >> 24;
1086 OP (0) = relocation;
1087 OP (1) = relocation >> 8;
1088 OP (2) = relocation >> 16;
1089 OP (3) = relocation >> 24;
1093 case R_RX_ABS32_REV:
1095 RX_STACK_POP (relocation);
1096 #if RX_OPCODE_BIG_ENDIAN
1097 OP (0) = relocation;
1098 OP (1) = relocation >> 8;
1099 OP (2) = relocation >> 16;
1100 OP (3) = relocation >> 24;
1102 OP (3) = relocation;
1103 OP (2) = relocation >> 8;
1104 OP (1) = relocation >> 16;
1105 OP (0) = relocation >> 24;
1109 case R_RX_ABS24S_PCREL:
1112 RX_STACK_POP (relocation);
1113 RANGE (-0x800000, 0x7fffff);
1114 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1116 OP (2) = relocation;
1117 OP (1) = relocation >> 8;
1118 OP (0) = relocation >> 16;
1122 OP (0) = relocation;
1123 OP (1) = relocation >> 8;
1124 OP (2) = relocation >> 16;
1130 RX_STACK_POP (relocation);
1131 RANGE (-32768, 65535);
1132 #if RX_OPCODE_BIG_ENDIAN
1133 OP (1) = relocation;
1134 OP (0) = relocation >> 8;
1136 OP (0) = relocation;
1137 OP (1) = relocation >> 8;
1141 case R_RX_ABS16_REV:
1143 RX_STACK_POP (relocation);
1144 RANGE (-32768, 65535);
1145 #if RX_OPCODE_BIG_ENDIAN
1146 OP (0) = relocation;
1147 OP (1) = relocation >> 8;
1149 OP (1) = relocation;
1150 OP (0) = relocation >> 8;
1154 case R_RX_ABS16S_PCREL:
1156 RX_STACK_POP (relocation);
1157 RANGE (-32768, 32767);
1158 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1160 OP (1) = relocation;
1161 OP (0) = relocation >> 8;
1165 OP (0) = relocation;
1166 OP (1) = relocation >> 8;
1172 RX_STACK_POP (relocation);
1174 #if RX_OPCODE_BIG_ENDIAN
1175 OP (1) = relocation;
1176 OP (0) = relocation >> 8;
1178 OP (0) = relocation;
1179 OP (1) = relocation >> 8;
1185 RX_STACK_POP (relocation);
1188 #if RX_OPCODE_BIG_ENDIAN
1189 OP (1) = relocation;
1190 OP (0) = relocation >> 8;
1192 OP (0) = relocation;
1193 OP (1) = relocation >> 8;
1199 RX_STACK_POP (relocation);
1202 #if RX_OPCODE_BIG_ENDIAN
1203 OP (1) = relocation;
1204 OP (0) = relocation >> 8;
1206 OP (0) = relocation;
1207 OP (1) = relocation >> 8;
1213 RX_STACK_POP (relocation);
1215 OP (0) = relocation;
1220 RX_STACK_POP (relocation);
1222 OP (0) = relocation;
1227 RX_STACK_POP (relocation);
1230 OP (0) = relocation;
1235 RX_STACK_POP (relocation);
1238 OP (0) = relocation;
1243 case R_RX_ABS8S_PCREL:
1244 RX_STACK_POP (relocation);
1246 OP (0) = relocation;
1250 if (r_symndx < symtab_hdr->sh_info)
1251 RX_STACK_PUSH (sec->output_section->vma
1252 + sec->output_offset
1258 && (h->root.type == bfd_link_hash_defined
1259 || h->root.type == bfd_link_hash_defweak))
1260 RX_STACK_PUSH (h->root.u.def.value
1261 + sec->output_section->vma
1262 + sec->output_offset
1265 _bfd_error_handler (_("Warning: RX_SYM reloc with an unknown symbol"));
1273 saw_subtract = TRUE;
1276 RX_STACK_PUSH (tmp);
1284 RX_STACK_POP (tmp1);
1285 RX_STACK_POP (tmp2);
1287 RX_STACK_PUSH (tmp1);
1295 saw_subtract = TRUE;
1296 RX_STACK_POP (tmp1);
1297 RX_STACK_POP (tmp2);
1299 RX_STACK_PUSH (tmp2);
1307 RX_STACK_POP (tmp1);
1308 RX_STACK_POP (tmp2);
1310 RX_STACK_PUSH (tmp1);
1318 RX_STACK_POP (tmp1);
1319 RX_STACK_POP (tmp2);
1321 RX_STACK_PUSH (tmp1);
1329 RX_STACK_POP (tmp1);
1330 RX_STACK_POP (tmp2);
1332 RX_STACK_PUSH (tmp1);
1340 RX_STACK_POP (tmp1);
1341 RX_STACK_POP (tmp2);
1343 RX_STACK_PUSH (tmp1);
1347 case R_RX_OPsctsize:
1348 RX_STACK_PUSH (input_section->size);
1352 RX_STACK_PUSH (input_section->output_section->vma);
1359 RX_STACK_POP (tmp1);
1360 RX_STACK_POP (tmp2);
1362 RX_STACK_PUSH (tmp1);
1370 RX_STACK_POP (tmp1);
1371 RX_STACK_POP (tmp2);
1373 RX_STACK_PUSH (tmp1);
1381 RX_STACK_POP (tmp1);
1382 RX_STACK_POP (tmp2);
1384 RX_STACK_PUSH (tmp1);
1394 RX_STACK_PUSH (tmp);
1402 RX_STACK_POP (tmp1);
1403 RX_STACK_POP (tmp2);
1405 RX_STACK_PUSH (tmp1);
1410 RX_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1414 RX_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1418 r = bfd_reloc_notsupported;
1422 if (r != bfd_reloc_ok)
1424 const char * msg = NULL;
1428 case bfd_reloc_overflow:
1429 /* Catch the case of a missing function declaration
1430 and emit a more helpful error message. */
1431 if (r_type == R_RX_DIR24S_PCREL)
1432 msg = _("%B(%A): error: call to undefined function '%s'");
1434 r = info->callbacks->reloc_overflow
1435 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
1436 input_bfd, input_section, rel->r_offset);
1439 case bfd_reloc_undefined:
1440 r = info->callbacks->undefined_symbol
1441 (info, name, input_bfd, input_section, rel->r_offset,
1445 case bfd_reloc_other:
1446 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1449 case bfd_reloc_outofrange:
1450 msg = _("%B(%A): internal error: out of range error");
1453 case bfd_reloc_notsupported:
1454 msg = _("%B(%A): internal error: unsupported relocation error");
1457 case bfd_reloc_dangerous:
1458 msg = _("%B(%A): internal error: dangerous relocation");
1462 msg = _("%B(%A): internal error: unknown error");
1467 _bfd_error_handler (msg, input_bfd, input_section, name);
1477 /* Relaxation Support. */
1479 /* Progression of relocations from largest operand size to smallest
1483 next_smaller_reloc (int r)
1487 case R_RX_DIR32: return R_RX_DIR24S;
1488 case R_RX_DIR24S: return R_RX_DIR16S;
1489 case R_RX_DIR16S: return R_RX_DIR8S;
1490 case R_RX_DIR8S: return R_RX_NONE;
1492 case R_RX_DIR16: return R_RX_DIR8;
1493 case R_RX_DIR8: return R_RX_NONE;
1495 case R_RX_DIR16U: return R_RX_DIR8U;
1496 case R_RX_DIR8U: return R_RX_NONE;
1498 case R_RX_DIR24S_PCREL: return R_RX_DIR16S_PCREL;
1499 case R_RX_DIR16S_PCREL: return R_RX_DIR8S_PCREL;
1500 case R_RX_DIR8S_PCREL: return R_RX_DIR3U_PCREL;
1502 case R_RX_DIR16UL: return R_RX_DIR8UL;
1503 case R_RX_DIR8UL: return R_RX_NONE;
1504 case R_RX_DIR16UW: return R_RX_DIR8UW;
1505 case R_RX_DIR8UW: return R_RX_NONE;
1507 case R_RX_RH_32_OP: return R_RX_RH_24_OP;
1508 case R_RX_RH_24_OP: return R_RX_RH_16_OP;
1509 case R_RX_RH_16_OP: return R_RX_DIR8;
1511 case R_RX_ABS32: return R_RX_ABS24S;
1512 case R_RX_ABS24S: return R_RX_ABS16S;
1513 case R_RX_ABS16: return R_RX_ABS8;
1514 case R_RX_ABS16U: return R_RX_ABS8U;
1515 case R_RX_ABS16S: return R_RX_ABS8S;
1516 case R_RX_ABS8: return R_RX_NONE;
1517 case R_RX_ABS8U: return R_RX_NONE;
1518 case R_RX_ABS8S: return R_RX_NONE;
1519 case R_RX_ABS24S_PCREL: return R_RX_ABS16S_PCREL;
1520 case R_RX_ABS16S_PCREL: return R_RX_ABS8S_PCREL;
1521 case R_RX_ABS8S_PCREL: return R_RX_NONE;
1522 case R_RX_ABS16UL: return R_RX_ABS8UL;
1523 case R_RX_ABS16UW: return R_RX_ABS8UW;
1524 case R_RX_ABS8UL: return R_RX_NONE;
1525 case R_RX_ABS8UW: return R_RX_NONE;
1530 /* Delete some bytes from a section while relaxing. */
1533 elf32_rx_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1534 Elf_Internal_Rela *alignment_rel, int force_snip)
1536 Elf_Internal_Shdr * symtab_hdr;
1537 unsigned int sec_shndx;
1538 bfd_byte * contents;
1539 Elf_Internal_Rela * irel;
1540 Elf_Internal_Rela * irelend;
1541 Elf_Internal_Sym * isym;
1542 Elf_Internal_Sym * isymend;
1544 unsigned int symcount;
1545 struct elf_link_hash_entry ** sym_hashes;
1546 struct elf_link_hash_entry ** end_hashes;
1551 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1553 contents = elf_section_data (sec)->this_hdr.contents;
1555 /* The deletion must stop at the next alignment boundary, if
1556 ALIGNMENT_REL is non-NULL. */
1559 toaddr = alignment_rel->r_offset;
1561 irel = elf_section_data (sec)->relocs;
1562 irelend = irel + sec->reloc_count;
1564 if (irel == NULL && sec->reloc_count > 0)
1566 /* If the relocs have not been kept in the section data
1567 structure (because -no-keep-memory was used) then
1569 irel = (_bfd_elf_link_read_relocs
1570 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, FALSE));
1572 /* FIXME: Return FALSE instead ? */
1576 /* Actually delete the bytes. */
1577 memmove (contents + addr, contents + addr + count,
1578 (size_t) (toaddr - addr - count));
1580 /* If we don't have an alignment marker to worry about, we can just
1581 shrink the section. Otherwise, we have to fill in the newly
1582 created gap with NOP insns (0x03). */
1586 memset (contents + toaddr - count, 0x03, count);
1588 /* Adjust all the relocs. */
1589 for (; irel < irelend; irel++)
1591 /* Get the new reloc address. */
1592 if (irel->r_offset > addr
1593 && (irel->r_offset < toaddr
1594 || (force_snip && irel->r_offset == toaddr)))
1595 irel->r_offset -= count;
1597 /* If we see an ALIGN marker at the end of the gap, we move it
1598 to the beginning of the gap, since marking these gaps is what
1600 if (irel->r_offset == toaddr
1601 && ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
1602 && irel->r_addend & RX_RELAXA_ALIGN)
1603 irel->r_offset -= count;
1606 /* Adjust the local symbols defined in this section. */
1607 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1608 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1609 isymend = isym + symtab_hdr->sh_info;
1611 for (; isym < isymend; isym++)
1613 /* If the symbol is in the range of memory we just moved, we
1614 have to adjust its value. */
1615 if (isym->st_shndx == sec_shndx
1616 && isym->st_value > addr
1617 && isym->st_value < toaddr)
1618 isym->st_value -= count;
1620 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1621 *end* is in the moved bytes but it's *start* isn't), then we
1622 must adjust its size. */
1623 if (isym->st_shndx == sec_shndx
1624 && isym->st_value < addr
1625 && isym->st_value + isym->st_size > addr
1626 && isym->st_value + isym->st_size < toaddr)
1627 isym->st_size -= count;
1630 /* Now adjust the global symbols defined in this section. */
1631 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1632 - symtab_hdr->sh_info);
1633 sym_hashes = elf_sym_hashes (abfd);
1634 end_hashes = sym_hashes + symcount;
1636 for (; sym_hashes < end_hashes; sym_hashes++)
1638 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1640 if ((sym_hash->root.type == bfd_link_hash_defined
1641 || sym_hash->root.type == bfd_link_hash_defweak)
1642 && sym_hash->root.u.def.section == sec)
1644 /* As above, adjust the value if needed. */
1645 if (sym_hash->root.u.def.value > addr
1646 && sym_hash->root.u.def.value < toaddr)
1647 sym_hash->root.u.def.value -= count;
1649 /* As above, adjust the size if needed. */
1650 if (sym_hash->root.u.def.value < addr
1651 && sym_hash->root.u.def.value + sym_hash->size > addr
1652 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1653 sym_hash->size -= count;
1660 /* Used to sort relocs by address. If relocs have the same address,
1661 we maintain their relative order, except that R_RX_RH_RELAX
1662 alignment relocs must be the first reloc for any given address. */
1665 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1669 bfd_boolean swappit;
1671 /* This is almost a classic bubblesort. It's the slowest sort, but
1672 we're taking advantage of the fact that the relocations are
1673 mostly in order already (the assembler emits them that way) and
1674 we need relocs with the same address to remain in the same
1680 for (i = 0; i < count - 1; i ++)
1682 if (r[i].r_offset > r[i + 1].r_offset)
1684 else if (r[i].r_offset < r[i + 1].r_offset)
1686 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1687 && (r[i + 1].r_addend & RX_RELAXA_ALIGN))
1689 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1690 && (r[i + 1].r_addend & RX_RELAXA_ELIGN)
1691 && !(ELF32_R_TYPE (r[i].r_info) == R_RX_RH_RELAX
1692 && (r[i].r_addend & RX_RELAXA_ALIGN)))
1699 Elf_Internal_Rela tmp;
1704 /* If we do move a reloc back, re-scan to see if it
1705 needs to be moved even further back. This avoids
1706 most of the O(n^2) behavior for our cases. */
1716 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1717 rx_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1718 lrel, abfd, sec, link_info, scale)
1721 rx_offset_for_reloc (bfd * abfd,
1722 Elf_Internal_Rela * rel,
1723 Elf_Internal_Shdr * symtab_hdr,
1724 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1725 Elf_Internal_Sym * intsyms,
1726 Elf_Internal_Rela ** lrel,
1728 asection * input_section,
1729 struct bfd_link_info * info,
1733 bfd_reloc_status_type r;
1737 /* REL is the first of 1..N relocations. We compute the symbol
1738 value for each relocation, then combine them if needed. LREL
1739 gets a pointer to the last relocation used. */
1744 /* Get the value of the symbol referred to by the reloc. */
1745 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1747 /* A local symbol. */
1748 Elf_Internal_Sym *isym;
1751 isym = intsyms + ELF32_R_SYM (rel->r_info);
1753 if (isym->st_shndx == SHN_UNDEF)
1754 ssec = bfd_und_section_ptr;
1755 else if (isym->st_shndx == SHN_ABS)
1756 ssec = bfd_abs_section_ptr;
1757 else if (isym->st_shndx == SHN_COMMON)
1758 ssec = bfd_com_section_ptr;
1760 ssec = bfd_section_from_elf_index (abfd,
1763 /* Initial symbol value. */
1764 symval = isym->st_value;
1766 /* GAS may have made this symbol relative to a section, in
1767 which case, we have to add the addend to find the
1769 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1770 symval += rel->r_addend;
1774 if ((ssec->flags & SEC_MERGE)
1775 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1776 symval = _bfd_merged_section_offset (abfd, & ssec,
1777 elf_section_data (ssec)->sec_info,
1781 /* Now make the offset relative to where the linker is putting it. */
1784 ssec->output_section->vma + ssec->output_offset;
1786 symval += rel->r_addend;
1791 struct elf_link_hash_entry * h;
1793 /* An external symbol. */
1794 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1795 h = elf_sym_hashes (abfd)[indx];
1796 BFD_ASSERT (h != NULL);
1798 if (h->root.type != bfd_link_hash_defined
1799 && h->root.type != bfd_link_hash_defweak)
1801 /* This appears to be a reference to an undefined
1802 symbol. Just ignore it--it will be caught by the
1803 regular reloc processing. */
1809 symval = (h->root.u.def.value
1810 + h->root.u.def.section->output_section->vma
1811 + h->root.u.def.section->output_offset);
1813 symval += rel->r_addend;
1816 switch (ELF32_R_TYPE (rel->r_info))
1819 RX_STACK_PUSH (symval);
1823 RX_STACK_POP (tmp1);
1825 RX_STACK_PUSH (tmp1);
1829 RX_STACK_POP (tmp1);
1830 RX_STACK_POP (tmp2);
1832 RX_STACK_PUSH (tmp1);
1836 RX_STACK_POP (tmp1);
1837 RX_STACK_POP (tmp2);
1839 RX_STACK_PUSH (tmp2);
1843 RX_STACK_POP (tmp1);
1844 RX_STACK_POP (tmp2);
1846 RX_STACK_PUSH (tmp1);
1850 RX_STACK_POP (tmp1);
1851 RX_STACK_POP (tmp2);
1853 RX_STACK_PUSH (tmp1);
1857 RX_STACK_POP (tmp1);
1858 RX_STACK_POP (tmp2);
1860 RX_STACK_PUSH (tmp1);
1864 RX_STACK_POP (tmp1);
1865 RX_STACK_POP (tmp2);
1867 RX_STACK_PUSH (tmp1);
1870 case R_RX_OPsctsize:
1871 RX_STACK_PUSH (input_section->size);
1875 RX_STACK_PUSH (input_section->output_section->vma);
1879 RX_STACK_POP (tmp1);
1880 RX_STACK_POP (tmp2);
1882 RX_STACK_PUSH (tmp1);
1886 RX_STACK_POP (tmp1);
1887 RX_STACK_POP (tmp2);
1889 RX_STACK_PUSH (tmp1);
1893 RX_STACK_POP (tmp1);
1894 RX_STACK_POP (tmp2);
1896 RX_STACK_PUSH (tmp1);
1900 RX_STACK_POP (tmp1);
1902 RX_STACK_PUSH (tmp1);
1906 RX_STACK_POP (tmp1);
1907 RX_STACK_POP (tmp2);
1909 RX_STACK_PUSH (tmp1);
1913 RX_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1917 RX_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1925 RX_STACK_POP (symval);
1936 RX_STACK_POP (symval);
1944 RX_STACK_POP (symval);
1955 move_reloc (Elf_Internal_Rela * irel, Elf_Internal_Rela * srel, int delta)
1957 bfd_vma old_offset = srel->r_offset;
1960 while (irel <= srel)
1962 if (irel->r_offset == old_offset)
1963 irel->r_offset += delta;
1968 /* Relax one section. */
1971 elf32_rx_relax_section (bfd * abfd,
1973 struct bfd_link_info * link_info,
1974 bfd_boolean * again,
1975 bfd_boolean allow_pcrel3)
1977 Elf_Internal_Shdr * symtab_hdr;
1978 Elf_Internal_Shdr * shndx_hdr;
1979 Elf_Internal_Rela * internal_relocs;
1980 Elf_Internal_Rela * free_relocs = NULL;
1981 Elf_Internal_Rela * irel;
1982 Elf_Internal_Rela * srel;
1983 Elf_Internal_Rela * irelend;
1984 Elf_Internal_Rela * next_alignment;
1985 Elf_Internal_Rela * prev_alignment;
1986 bfd_byte * contents = NULL;
1987 bfd_byte * free_contents = NULL;
1988 Elf_Internal_Sym * intsyms = NULL;
1989 Elf_Internal_Sym * free_intsyms = NULL;
1990 Elf_External_Sym_Shndx * shndx_buf = NULL;
1996 int section_alignment_glue;
1997 /* how much to scale the relocation by - 1, 2, or 4. */
2000 /* Assume nothing changes. */
2003 /* We don't have to do anything for a relocatable link, if
2004 this section does not have relocs, or if this is not a
2006 if (link_info->relocatable
2007 || (sec->flags & SEC_RELOC) == 0
2008 || sec->reloc_count == 0
2009 || (sec->flags & SEC_CODE) == 0)
2012 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2013 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2015 sec_start = sec->output_section->vma + sec->output_offset;
2017 /* Get the section contents. */
2018 if (elf_section_data (sec)->this_hdr.contents != NULL)
2019 contents = elf_section_data (sec)->this_hdr.contents;
2020 /* Go get them off disk. */
2023 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2025 elf_section_data (sec)->this_hdr.contents = contents;
2028 /* Read this BFD's symbols. */
2029 /* Get cached copy if it exists. */
2030 if (symtab_hdr->contents != NULL)
2031 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2034 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2035 symtab_hdr->contents = (bfd_byte *) intsyms;
2038 if (shndx_hdr->sh_size != 0)
2042 amt = symtab_hdr->sh_info;
2043 amt *= sizeof (Elf_External_Sym_Shndx);
2044 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2045 if (shndx_buf == NULL)
2047 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2048 || bfd_bread (shndx_buf, amt, abfd) != amt)
2050 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2053 /* Get a copy of the native relocations. */
2054 internal_relocs = (_bfd_elf_link_read_relocs
2055 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2056 link_info->keep_memory));
2057 if (internal_relocs == NULL)
2059 if (! link_info->keep_memory)
2060 free_relocs = internal_relocs;
2062 /* The RL_ relocs must be just before the operand relocs they go
2063 with, so we must sort them to guarantee this. We use bubblesort
2064 instead of qsort so we can guarantee that relocs with the same
2065 address remain in the same relative order. */
2066 reloc_bubblesort (internal_relocs, sec->reloc_count);
2068 /* Walk through them looking for relaxing opportunities. */
2069 irelend = internal_relocs + sec->reloc_count;
2071 /* This will either be NULL or a pointer to the next alignment
2073 next_alignment = internal_relocs;
2074 /* This will be the previous alignment, although at first it points
2075 to the first real relocation. */
2076 prev_alignment = internal_relocs;
2078 /* We calculate worst case shrinkage caused by alignment directives.
2079 No fool-proof, but better than either ignoring the problem or
2080 doing heavy duty analysis of all the alignment markers in all
2082 section_alignment_glue = 0;
2083 for (irel = internal_relocs; irel < irelend; irel++)
2084 if (ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
2085 && irel->r_addend & RX_RELAXA_ALIGN)
2087 int this_glue = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2089 if (section_alignment_glue < this_glue)
2090 section_alignment_glue = this_glue;
2092 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2094 section_alignment_glue *= 2;
2096 for (irel = internal_relocs; irel < irelend; irel++)
2098 unsigned char *insn;
2101 /* The insns we care about are all marked with one of these. */
2102 if (ELF32_R_TYPE (irel->r_info) != R_RX_RH_RELAX)
2105 if (irel->r_addend & RX_RELAXA_ALIGN
2106 || next_alignment == internal_relocs)
2108 /* When we delete bytes, we need to maintain all the alignments
2109 indicated. In addition, we need to be careful about relaxing
2110 jumps across alignment boundaries - these displacements
2111 *grow* when we delete bytes. For now, don't shrink
2112 displacements across an alignment boundary, just in case.
2113 Note that this only affects relocations to the same
2115 prev_alignment = next_alignment;
2116 next_alignment += 2;
2117 while (next_alignment < irelend
2118 && (ELF32_R_TYPE (next_alignment->r_info) != R_RX_RH_RELAX
2119 || !(next_alignment->r_addend & RX_RELAXA_ELIGN)))
2121 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2122 next_alignment = NULL;
2125 /* When we hit alignment markers, see if we've shrunk enough
2126 before them to reduce the gap without violating the alignment
2128 if (irel->r_addend & RX_RELAXA_ALIGN)
2130 /* At this point, the next relocation *should* be the ELIGN
2132 Elf_Internal_Rela *erel = irel + 1;
2133 unsigned int alignment, nbytes;
2135 if (ELF32_R_TYPE (erel->r_info) != R_RX_RH_RELAX)
2137 if (!(erel->r_addend & RX_RELAXA_ELIGN))
2140 alignment = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2142 if (erel->r_offset - irel->r_offset < alignment)
2145 nbytes = erel->r_offset - irel->r_offset;
2146 nbytes /= alignment;
2147 nbytes *= alignment;
2149 elf32_rx_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2150 erel->r_offset == sec->size);
2156 if (irel->r_addend & RX_RELAXA_ELIGN)
2159 insn = contents + irel->r_offset;
2161 nrelocs = irel->r_addend & RX_RELAXA_RNUM;
2163 /* At this point, we have an insn that is a candidate for linker
2164 relaxation. There are NRELOCS relocs following that may be
2165 relaxed, although each reloc may be made of more than one
2166 reloc entry (such as gp-rel symbols). */
2168 /* Get the value of the symbol referred to by the reloc. Just
2169 in case this is the last reloc in the list, use the RL's
2170 addend to choose between this reloc (no addend) or the next
2171 (yes addend, which means at least one following reloc). */
2173 /* srel points to the "current" reloction for this insn -
2174 actually the last reloc for a given operand, which is the one
2175 we need to update. We check the relaxations in the same
2176 order that the relocations happen, so we'll just push it
2180 pc = sec->output_section->vma + sec->output_offset
2184 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2185 pcrel = symval - pc + srel->r_addend; \
2188 #define SNIPNR(offset, nbytes) \
2189 elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2190 #define SNIP(offset, nbytes, newtype) \
2191 SNIPNR (offset, nbytes); \
2192 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2194 /* The order of these bit tests must match the order that the
2195 relocs appear in. Since we sorted those by offset, we can
2198 /* Note that the numbers in, say, DSP6 are the bit offsets of
2199 the code fields that describe the operand. Bits number 0 for
2200 the MSB of insn[0]. */
2207 if (irel->r_addend & RX_RELAXA_DSP6)
2212 if (code == 2 && symval/scale <= 255)
2214 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2217 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2218 if (newrel != ELF32_R_TYPE (srel->r_info))
2220 SNIP (3, 1, newrel);
2225 else if (code == 1 && symval == 0)
2228 SNIP (2, 1, R_RX_NONE);
2232 /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst. */
2233 else if (code == 1 && symval/scale <= 31
2234 /* Decodable bits. */
2235 && (insn[0] & 0xcc) == 0xcc
2237 && (insn[0] & 0x30) != 0x30
2238 /* Register MSBs. */
2239 && (insn[1] & 0x88) == 0x00)
2243 insn[0] = 0x88 | (insn[0] & 0x30);
2244 /* The register fields are in the right place already. */
2246 /* We can't relax this new opcode. */
2249 switch ((insn[0] & 0x30) >> 4)
2252 newrel = R_RX_RH_ABS5p5B;
2255 newrel = R_RX_RH_ABS5p5W;
2258 newrel = R_RX_RH_ABS5p5L;
2262 move_reloc (irel, srel, -2);
2263 SNIP (2, 1, newrel);
2266 /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst. */
2267 else if (code == 1 && symval/scale <= 31
2268 /* Decodable bits. */
2269 && (insn[0] & 0xf8) == 0x58
2270 /* Register MSBs. */
2271 && (insn[1] & 0x88) == 0x00)
2275 insn[0] = 0xb0 | ((insn[0] & 0x04) << 1);
2276 /* The register fields are in the right place already. */
2278 /* We can't relax this new opcode. */
2281 switch ((insn[0] & 0x08) >> 3)
2284 newrel = R_RX_RH_ABS5p5B;
2287 newrel = R_RX_RH_ABS5p5W;
2291 move_reloc (irel, srel, -2);
2292 SNIP (2, 1, newrel);
2296 /* A DSP4 operand always follows a DSP6 operand, even if there's
2297 no relocation for it. We have to read the code out of the
2298 opcode to calculate the offset of the operand. */
2299 if (irel->r_addend & RX_RELAXA_DSP4)
2301 int code6, offset = 0;
2305 code6 = insn[0] & 0x03;
2308 case 0: offset = 2; break;
2309 case 1: offset = 3; break;
2310 case 2: offset = 4; break;
2311 case 3: offset = 2; break;
2314 code = (insn[0] & 0x0c) >> 2;
2316 if (code == 2 && symval / scale <= 255)
2318 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2322 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2323 if (newrel != ELF32_R_TYPE (srel->r_info))
2325 SNIP (offset+1, 1, newrel);
2330 else if (code == 1 && symval == 0)
2333 SNIP (offset, 1, R_RX_NONE);
2336 /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */
2337 else if (code == 1 && symval/scale <= 31
2338 /* Decodable bits. */
2339 && (insn[0] & 0xc3) == 0xc3
2341 && (insn[0] & 0x30) != 0x30
2342 /* Register MSBs. */
2343 && (insn[1] & 0x88) == 0x00)
2347 insn[0] = 0x80 | (insn[0] & 0x30);
2348 /* The register fields are in the right place already. */
2350 /* We can't relax this new opcode. */
2353 switch ((insn[0] & 0x30) >> 4)
2356 newrel = R_RX_RH_ABS5p5B;
2359 newrel = R_RX_RH_ABS5p5W;
2362 newrel = R_RX_RH_ABS5p5L;
2366 move_reloc (irel, srel, -2);
2367 SNIP (2, 1, newrel);
2371 /* These always occur alone, but the offset depends on whether
2372 it's a MEMEX opcode (0x06) or not. */
2373 if (irel->r_addend & RX_RELAXA_DSP14)
2378 if (insn[0] == 0x06)
2385 if (code == 2 && symval / scale <= 255)
2387 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2391 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2392 if (newrel != ELF32_R_TYPE (srel->r_info))
2394 SNIP (offset, 1, newrel);
2398 else if (code == 1 && symval == 0)
2401 SNIP (offset, 1, R_RX_NONE);
2412 /* These always occur alone. */
2413 if (irel->r_addend & RX_RELAXA_IMM6)
2419 /* These relocations sign-extend, so we must do signed compares. */
2420 ssymval = (long) symval;
2422 code = insn[0] & 0x03;
2424 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2426 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2430 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2431 if (newrel != ELF32_R_TYPE (srel->r_info))
2433 SNIP (2, 1, newrel);
2438 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
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 /* Special case UIMM8 format: CMP #uimm8,Rdst. */
2453 else if (code == 2 && ssymval <= 255 && ssymval >= 16
2454 /* Decodable bits. */
2455 && (insn[0] & 0xfc) == 0x74
2456 /* Decodable bits. */
2457 && ((insn[1] & 0xf0) == 0x00))
2462 insn[1] = 0x50 | (insn[1] & 0x0f);
2464 /* We can't relax this new opcode. */
2467 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2468 newrel = R_RX_ABS8U;
2470 newrel = R_RX_DIR8U;
2472 SNIP (2, 1, newrel);
2476 else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2478 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2482 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2483 if (newrel != ELF32_R_TYPE (srel->r_info))
2485 SNIP (2, 1, newrel);
2490 /* Special case UIMM4 format: CMP, MUL, AND, OR. */
2491 else if (code == 1 && ssymval <= 15 && ssymval >= 0
2492 /* Decodable bits and immediate type. */
2494 /* Decodable bits. */
2495 && (insn[1] & 0xc0) == 0x00)
2497 static const int newop[4] = { 1, 3, 4, 5 };
2499 insn[0] = 0x60 | newop[insn[1] >> 4];
2500 /* The register number doesn't move. */
2502 /* We can't relax this new opcode. */
2505 move_reloc (irel, srel, -1);
2507 SNIP (2, 1, R_RX_RH_UIMM4p8);
2511 /* Special case UIMM4 format: ADD -> ADD/SUB. */
2512 else if (code == 1 && ssymval <= 15 && ssymval >= -15
2513 /* Decodable bits and immediate type. */
2515 /* Same register for source and destination. */
2516 && ((insn[1] >> 4) == (insn[1] & 0x0f)))
2520 /* Note that we can't turn "add $0,Rs" into a NOP
2521 because the flags need to be set right. */
2525 insn[0] = 0x60; /* Subtract. */
2526 newrel = R_RX_RH_UNEG4p8;
2530 insn[0] = 0x62; /* Add. */
2531 newrel = R_RX_RH_UIMM4p8;
2534 /* The register number is in the right place. */
2536 /* We can't relax this new opcode. */
2539 move_reloc (irel, srel, -1);
2541 SNIP (2, 1, newrel);
2546 /* These are either matched with a DSP6 (2-byte base) or an id24
2548 if (irel->r_addend & RX_RELAXA_IMM12)
2550 int dspcode, offset = 0;
2555 if ((insn[0] & 0xfc) == 0xfc)
2556 dspcode = 1; /* Just something with one byte operand. */
2558 dspcode = insn[0] & 3;
2561 case 0: offset = 2; break;
2562 case 1: offset = 3; break;
2563 case 2: offset = 4; break;
2564 case 3: offset = 2; break;
2567 /* These relocations sign-extend, so we must do signed compares. */
2568 ssymval = (long) symval;
2570 code = (insn[1] >> 2) & 3;
2571 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2573 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2577 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2578 if (newrel != ELF32_R_TYPE (srel->r_info))
2580 SNIP (offset, 1, newrel);
2585 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
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 /* Special case UIMM8 format: MOV #uimm8,Rdst. */
2600 else if (code == 2 && ssymval <= 255 && ssymval >= 16
2601 /* Decodable bits. */
2603 /* Decodable bits. */
2604 && ((insn[1] & 0x03) == 0x02))
2609 insn[1] = 0x40 | (insn[1] >> 4);
2611 /* We can't relax this new opcode. */
2614 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2615 newrel = R_RX_ABS8U;
2617 newrel = R_RX_DIR8U;
2619 SNIP (2, 1, newrel);
2623 else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2625 unsigned int newrel = ELF32_R_TYPE(srel->r_info);
2629 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2630 if (newrel != ELF32_R_TYPE(srel->r_info))
2632 SNIP (offset, 1, newrel);
2637 /* Special case UIMM4 format: MOV #uimm4,Rdst. */
2638 else if (code == 1 && ssymval <= 15 && ssymval >= 0
2639 /* Decodable bits. */
2641 /* Decodable bits. */
2642 && ((insn[1] & 0x03) == 0x02))
2645 insn[1] = insn[1] >> 4;
2647 /* We can't relax this new opcode. */
2650 move_reloc (irel, srel, -1);
2652 SNIP (2, 1, R_RX_RH_UIMM4p8);
2657 if (irel->r_addend & RX_RELAXA_BRA)
2659 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2661 int alignment_glue = 0;
2665 /* Branches over alignment chunks are problematic, as
2666 deleting bytes here makes the branch *further* away. We
2667 can be agressive with branches within this alignment
2668 block, but not branches outside it. */
2669 if ((prev_alignment == NULL
2670 || symval < (bfd_vma)(sec_start + prev_alignment->r_offset))
2671 && (next_alignment == NULL
2672 || symval > (bfd_vma)(sec_start + next_alignment->r_offset)))
2673 alignment_glue = section_alignment_glue;
2675 if (ELF32_R_TYPE(srel[1].r_info) == R_RX_RH_RELAX
2676 && srel[1].r_addend & RX_RELAXA_BRA
2677 && srel[1].r_offset < irel->r_offset + pcrel)
2680 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2682 /* The values we compare PCREL with are not what you'd
2683 expect; they're off by a little to compensate for (1)
2684 where the reloc is relative to the insn, and (2) how much
2685 the insn is going to change when we relax it. */
2687 /* These we have to decode. */
2690 case 0x04: /* BRA pcdsp:24 */
2691 if (-32768 + alignment_glue <= pcrel
2692 && pcrel <= 32765 - alignment_glue)
2695 SNIP (3, 1, newrel);
2700 case 0x38: /* BRA pcdsp:16 */
2701 if (-128 + alignment_glue <= pcrel
2702 && pcrel <= 127 - alignment_glue)
2705 SNIP (2, 1, newrel);
2710 case 0x2e: /* BRA pcdsp:8 */
2711 /* Note that there's a risk here of shortening things so
2712 much that we no longer fit this reloc; it *should*
2713 only happen when you branch across a branch, and that
2714 branch also devolves into BRA.S. "Real" code should
2716 if (max_pcrel3 + alignment_glue <= pcrel
2717 && pcrel <= 10 - alignment_glue
2721 SNIP (1, 1, newrel);
2722 move_reloc (irel, srel, -1);
2727 case 0x05: /* BSR pcdsp:24 */
2728 if (-32768 + alignment_glue <= pcrel
2729 && pcrel <= 32765 - alignment_glue)
2732 SNIP (1, 1, newrel);
2737 case 0x3a: /* BEQ.W pcdsp:16 */
2738 case 0x3b: /* BNE.W pcdsp:16 */
2739 if (-128 + alignment_glue <= pcrel
2740 && pcrel <= 127 - alignment_glue)
2742 insn[0] = 0x20 | (insn[0] & 1);
2743 SNIP (1, 1, newrel);
2748 case 0x20: /* BEQ.B pcdsp:8 */
2749 case 0x21: /* BNE.B pcdsp:8 */
2750 if (max_pcrel3 + alignment_glue <= pcrel
2751 && pcrel - alignment_glue <= 10
2754 insn[0] = 0x10 | ((insn[0] & 1) << 3);
2755 SNIP (1, 1, newrel);
2756 move_reloc (irel, srel, -1);
2761 case 0x16: /* synthetic BNE dsp24 */
2762 case 0x1e: /* synthetic BEQ dsp24 */
2763 if (-32767 + alignment_glue <= pcrel
2764 && pcrel <= 32766 - alignment_glue
2767 if (insn[0] == 0x16)
2771 /* We snip out the bytes at the end else the reloc
2772 will get moved too, and too much. */
2773 SNIP (3, 2, newrel);
2774 move_reloc (irel, srel, -1);
2780 /* Special case - synthetic conditional branches, pcrel24.
2781 Note that EQ and NE have been handled above. */
2782 if ((insn[0] & 0xf0) == 0x20
2785 && srel->r_offset != irel->r_offset + 1
2786 && -32767 + alignment_glue <= pcrel
2787 && pcrel <= 32766 - alignment_glue)
2791 SNIP (5, 1, newrel);
2795 /* Special case - synthetic conditional branches, pcrel16 */
2796 if ((insn[0] & 0xf0) == 0x20
2799 && srel->r_offset != irel->r_offset + 1
2800 && -127 + alignment_glue <= pcrel
2801 && pcrel <= 126 - alignment_glue)
2803 int cond = (insn[0] & 0x0f) ^ 0x01;
2805 insn[0] = 0x20 | cond;
2806 /* By moving the reloc first, we avoid having
2807 delete_bytes move it also. */
2808 move_reloc (irel, srel, -2);
2809 SNIP (2, 3, newrel);
2814 BFD_ASSERT (nrelocs == 0);
2816 /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can
2817 use MOV.bwl #uimm:8, dsp:5[r7] format. This is tricky
2818 because it may have one or two relocations. */
2819 if ((insn[0] & 0xfc) == 0xf8
2820 && (insn[1] & 0x80) == 0x00
2821 && (insn[0] & 0x03) != 0x03)
2823 int dcode, icode, reg, ioff, dscale, ilen;
2824 bfd_vma disp_val = 0;
2826 Elf_Internal_Rela * disp_rel = 0;
2827 Elf_Internal_Rela * imm_rel = 0;
2832 dcode = insn[0] & 0x03;
2833 icode = (insn[1] >> 2) & 0x03;
2834 reg = (insn[1] >> 4) & 0x0f;
2836 ioff = dcode == 1 ? 3 : dcode == 2 ? 4 : 2;
2838 /* Figure out what the dispacement is. */
2839 if (dcode == 1 || dcode == 2)
2841 /* There's a displacement. See if there's a reloc for it. */
2842 if (srel[1].r_offset == irel->r_offset + 2)
2854 #if RX_OPCODE_BIG_ENDIAN
2855 disp_val = insn[2] * 256 + insn[3];
2857 disp_val = insn[2] + insn[3] * 256;
2860 switch (insn[1] & 3)
2876 /* Figure out what the immediate is. */
2877 if (srel[1].r_offset == irel->r_offset + ioff)
2880 imm_val = (long) symval;
2885 unsigned char * ip = insn + ioff;
2890 /* For byte writes, we don't sign extend. Makes the math easier later. */
2894 imm_val = (char) ip[0];
2897 #if RX_OPCODE_BIG_ENDIAN
2898 imm_val = ((char) ip[0] << 8) | ip[1];
2900 imm_val = ((char) ip[1] << 8) | ip[0];
2904 #if RX_OPCODE_BIG_ENDIAN
2905 imm_val = ((char) ip[0] << 16) | (ip[1] << 8) | ip[2];
2907 imm_val = ((char) ip[2] << 16) | (ip[1] << 8) | ip[0];
2911 #if RX_OPCODE_BIG_ENDIAN
2912 imm_val = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3];
2914 imm_val = (ip[3] << 24) | (ip[2] << 16) | (ip[1] << 8) | ip[0];
2948 /* The shortcut happens when the immediate is 0..255,
2949 register r0 to r7, and displacement (scaled) 0..31. */
2951 if (0 <= imm_val && imm_val <= 255
2952 && 0 <= reg && reg <= 7
2953 && disp_val / dscale <= 31)
2955 insn[0] = 0x3c | (insn[1] & 0x03);
2956 insn[1] = (((disp_val / dscale) << 3) & 0x80) | (reg << 4) | ((disp_val/dscale) & 0x0f);
2961 int newrel = R_RX_NONE;
2966 newrel = R_RX_RH_ABS5p8B;
2969 newrel = R_RX_RH_ABS5p8W;
2972 newrel = R_RX_RH_ABS5p8L;
2975 disp_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (disp_rel->r_info), newrel);
2976 move_reloc (irel, disp_rel, -1);
2980 imm_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (imm_rel->r_info), R_RX_DIR8U);
2981 move_reloc (disp_rel ? disp_rel : irel,
2983 irel->r_offset - imm_rel->r_offset + 2);
2986 SNIPNR (3, ilen - 3);
2989 /* We can't relax this new opcode. */
2995 /* We can't reliably relax branches to DIR3U_PCREL unless we know
2996 whatever they're branching over won't shrink any more. If we're
2997 basically done here, do one more pass just for branches - but
2998 don't request a pass after that one! */
2999 if (!*again && !allow_pcrel3)
3001 bfd_boolean ignored;
3003 elf32_rx_relax_section (abfd, sec, link_info, &ignored, TRUE);
3009 if (free_relocs != NULL)
3012 if (free_contents != NULL)
3013 free (free_contents);
3015 if (shndx_buf != NULL)
3017 shndx_hdr->contents = NULL;
3021 if (free_intsyms != NULL)
3022 free (free_intsyms);
3028 elf32_rx_relax_section_wrapper (bfd * abfd,
3030 struct bfd_link_info * link_info,
3031 bfd_boolean * again)
3033 return elf32_rx_relax_section (abfd, sec, link_info, again, FALSE);
3036 /* Function to set the ELF flag bits. */
3039 rx_elf_set_private_flags (bfd * abfd, flagword flags)
3041 elf_elfheader (abfd)->e_flags = flags;
3042 elf_flags_init (abfd) = TRUE;
3046 static bfd_boolean no_warn_mismatch = FALSE;
3047 static bfd_boolean ignore_lma = TRUE;
3049 void bfd_elf32_rx_set_target_flags (bfd_boolean, bfd_boolean);
3052 bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch,
3053 bfd_boolean user_ignore_lma)
3055 no_warn_mismatch = user_no_warn_mismatch;
3056 ignore_lma = user_ignore_lma;
3059 /* Converts FLAGS into a descriptive string.
3060 Returns a static pointer. */
3063 describe_flags (flagword flags)
3065 static char buf [128];
3069 if (flags & E_FLAG_RX_64BIT_DOUBLES)
3070 strcat (buf, "64-bit doubles");
3072 strcat (buf, "32-bit doubles");
3074 if (flags & E_FLAG_RX_DSP)
3075 strcat (buf, ", dsp");
3077 strcat (buf, ", no dsp");
3079 if (flags & E_FLAG_RX_PID)
3080 strcat (buf, ", pid");
3082 strcat (buf, ", no pid");
3084 if (flags & E_FLAG_RX_ABI)
3085 strcat (buf, ", RX ABI");
3087 strcat (buf, ", GCC ABI");
3092 /* Merge backend specific data from an object file to the output
3093 object file when linking. */
3096 rx_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3100 bfd_boolean error = FALSE;
3102 new_flags = elf_elfheader (ibfd)->e_flags;
3103 old_flags = elf_elfheader (obfd)->e_flags;
3105 if (!elf_flags_init (obfd))
3107 /* First call, no flags set. */
3108 elf_flags_init (obfd) = TRUE;
3109 elf_elfheader (obfd)->e_flags = new_flags;
3111 else if (old_flags != new_flags)
3113 flagword known_flags;
3115 known_flags = E_FLAG_RX_ABI | E_FLAG_RX_64BIT_DOUBLES
3116 | E_FLAG_RX_DSP | E_FLAG_RX_PID;
3118 if ((old_flags ^ new_flags) & known_flags)
3120 /* Only complain if flag bits we care about do not match.
3121 Other bits may be set, since older binaries did use some
3122 deprecated flags. */
3123 if (no_warn_mismatch)
3125 elf_elfheader (obfd)->e_flags = (new_flags | old_flags) & known_flags;
3129 _bfd_error_handler ("There is a conflict merging the ELF header flags from %s",
3130 bfd_get_filename (ibfd));
3131 _bfd_error_handler (" the input file's flags: %s",
3132 describe_flags (new_flags));
3133 _bfd_error_handler (" the output file's flags: %s",
3134 describe_flags (old_flags));
3139 elf_elfheader (obfd)->e_flags = new_flags & known_flags;
3143 bfd_set_error (bfd_error_bad_value);
3149 rx_elf_print_private_bfd_data (bfd * abfd, void * ptr)
3151 FILE * file = (FILE *) ptr;
3154 BFD_ASSERT (abfd != NULL && ptr != NULL);
3156 /* Print normal ELF private data. */
3157 _bfd_elf_print_private_bfd_data (abfd, ptr);
3159 flags = elf_elfheader (abfd)->e_flags;
3160 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
3162 fprintf (file, "%s", describe_flags (flags));
3166 /* Return the MACH for an e_flags value. */
3169 elf32_rx_machine (bfd * abfd ATTRIBUTE_UNUSED)
3171 #if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_...
3172 Need to sort out how these flag bits are used.
3173 For now we assume that the flags are OK. */
3174 if ((elf_elfheader (abfd)->e_flags & EF_RX_CPU_MASK) == EF_RX_CPU_RX)
3182 rx_elf_object_p (bfd * abfd)
3186 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
3187 int nphdrs = elf_elfheader (abfd)->e_phnum;
3189 static int saw_be = FALSE;
3191 /* We never want to automatically choose the non-swapping big-endian
3192 target. The user can only get that explicitly, such as with -I
3194 if (abfd->xvec == &rx_elf32_be_ns_vec
3195 && abfd->target_defaulted)
3198 /* BFD->target_defaulted is not set to TRUE when a target is chosen
3199 as a fallback, so we check for "scanning" to know when to stop
3200 using the non-swapping target. */
3201 if (abfd->xvec == &rx_elf32_be_ns_vec
3204 if (abfd->xvec == &rx_elf32_be_vec)
3207 bfd_default_set_arch_mach (abfd, bfd_arch_rx,
3208 elf32_rx_machine (abfd));
3210 /* For each PHDR in the object, we must find some section that
3211 corresponds (based on matching file offsets) and use its VMA
3212 information to reconstruct the p_vaddr field we clobbered when we
3214 for (i=0; i<nphdrs; i++)
3216 for (u=0; u<elf_tdata(abfd)->num_elf_sections; u++)
3218 Elf_Internal_Shdr *sec = elf_tdata(abfd)->elf_sect_ptr[u];
3220 if (phdr[i].p_filesz
3221 && phdr[i].p_offset <= (bfd_vma) sec->sh_offset
3222 && (bfd_vma)sec->sh_offset <= phdr[i].p_offset + (phdr[i].p_filesz - 1))
3224 /* Found one! The difference between the two addresses,
3225 plus the difference between the two file offsets, is
3226 enough information to reconstruct the lma. */
3228 /* Example where they aren't:
3229 PHDR[1] = lma fffc0100 offset 00002010 size 00000100
3230 SEC[6] = vma 00000050 offset 00002050 size 00000040
3232 The correct LMA for the section is fffc0140 + (2050-2010).
3235 phdr[i].p_vaddr = sec->sh_addr + (sec->sh_offset - phdr[i].p_offset);
3240 /* We must update the bfd sections as well, so we don't stop
3242 bsec = abfd->sections;
3245 if (phdr[i].p_filesz
3246 && phdr[i].p_vaddr <= bsec->vma
3247 && bsec->vma <= phdr[i].p_vaddr + (phdr[i].p_filesz - 1))
3249 bsec->lma = phdr[i].p_paddr + (bsec->vma - phdr[i].p_vaddr);
3261 rx_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
3264 Elf_Internal_Sym * isymbuf;
3265 Elf_Internal_Sym * isymend;
3266 Elf_Internal_Sym * isym;
3267 Elf_Internal_Shdr * symtab_hdr;
3268 bfd_boolean free_internal = FALSE, free_external = FALSE;
3270 char * st_info_stb_str;
3271 char * st_other_str;
3272 char * st_shndx_str;
3274 if (! internal_syms)
3276 internal_syms = bfd_malloc (1000);
3279 if (! external_syms)
3281 external_syms = bfd_malloc (1000);
3285 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3286 locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3288 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3289 symtab_hdr->sh_info, 0,
3290 internal_syms, external_syms, NULL);
3292 isymbuf = internal_syms;
3293 isymend = isymbuf + locsymcount;
3295 for (isym = isymbuf ; isym < isymend ; isym++)
3297 switch (ELF_ST_TYPE (isym->st_info))
3299 case STT_FUNC: st_info_str = "STT_FUNC"; break;
3300 case STT_SECTION: st_info_str = "STT_SECTION"; break;
3301 case STT_FILE: st_info_str = "STT_FILE"; break;
3302 case STT_OBJECT: st_info_str = "STT_OBJECT"; break;
3303 case STT_TLS: st_info_str = "STT_TLS"; break;
3304 default: st_info_str = "";
3306 switch (ELF_ST_BIND (isym->st_info))
3308 case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; break;
3309 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; break;
3310 default: st_info_stb_str = "";
3312 switch (ELF_ST_VISIBILITY (isym->st_other))
3314 case STV_DEFAULT: st_other_str = "STV_DEFAULT"; break;
3315 case STV_INTERNAL: st_other_str = "STV_INTERNAL"; break;
3316 case STV_PROTECTED: st_other_str = "STV_PROTECTED"; break;
3317 default: st_other_str = "";
3319 switch (isym->st_shndx)
3321 case SHN_ABS: st_shndx_str = "SHN_ABS"; break;
3322 case SHN_COMMON: st_shndx_str = "SHN_COMMON"; break;
3323 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; break;
3324 default: st_shndx_str = "";
3327 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
3328 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
3330 (unsigned long) isym->st_value,
3331 (unsigned long) isym->st_size,
3333 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
3335 isym->st_info, st_info_str, st_info_stb_str,
3336 isym->st_other, st_other_str,
3337 isym->st_shndx, st_shndx_str);
3340 free (internal_syms);
3342 free (external_syms);
3346 rx_get_reloc (long reloc)
3348 if (0 <= reloc && reloc < R_RX_max)
3349 return rx_elf_howto_table[reloc].name;
3355 /* We must take care to keep the on-disk copy of any code sections
3356 that are fully linked swapped if the target is big endian, to match
3357 the Renesas tools. */
3359 /* The rule is: big endian object that are final-link executables,
3360 have code sections stored with 32-bit words swapped relative to
3361 what you'd get by default. */
3364 rx_get_section_contents (bfd * abfd,
3368 bfd_size_type count)
3370 int exec = (abfd->flags & EXEC_P) ? 1 : 0;
3371 int s_code = (section->flags & SEC_CODE) ? 1 : 0;
3375 fprintf (stderr, "dj: get %ld %ld from %s %s e%d sc%d %08lx:%08lx\n",
3376 (long) offset, (long) count, section->name,
3377 bfd_big_endian(abfd) ? "be" : "le",
3378 exec, s_code, (long unsigned) section->filepos,
3379 (long unsigned) offset);
3382 if (exec && s_code && bfd_big_endian (abfd))
3384 char * cloc = (char *) location;
3385 bfd_size_type cnt, end_cnt;
3389 /* Fetch and swap unaligned bytes at the beginning. */
3394 rv = _bfd_generic_get_section_contents (abfd, section, buf,
3399 bfd_putb32 (bfd_getl32 (buf), buf);
3401 cnt = 4 - (offset % 4);
3405 memcpy (location, buf + (offset % 4), cnt);
3412 end_cnt = count % 4;
3414 /* Fetch and swap the middle bytes. */
3417 rv = _bfd_generic_get_section_contents (abfd, section, cloc, offset,
3422 for (cnt = count; cnt >= 4; cnt -= 4, cloc += 4)
3423 bfd_putb32 (bfd_getl32 (cloc), cloc);
3426 /* Fetch and swap the end bytes. */
3431 /* Fetch the end bytes. */
3432 rv = _bfd_generic_get_section_contents (abfd, section, buf,
3433 offset + count - end_cnt, 4);
3437 bfd_putb32 (bfd_getl32 (buf), buf);
3438 memcpy (cloc, buf, end_cnt);
3442 rv = _bfd_generic_get_section_contents (abfd, section, location, offset, count);
3449 rx2_set_section_contents (bfd * abfd,
3451 const void * location,
3453 bfd_size_type count)
3457 fprintf (stderr, " set sec %s %08x loc %p offset %#x count %#x\n",
3458 section->name, (unsigned) section->vma, location, (int) offset, (int) count);
3459 for (i = 0; i < count; i++)
3461 if (i % 16 == 0 && i > 0)
3462 fprintf (stderr, "\n");
3464 if (i % 16 && i % 4 == 0)
3465 fprintf (stderr, " ");
3468 fprintf (stderr, " %08x:", (int) (section->vma + offset + i));
3470 fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3472 fprintf (stderr, "\n");
3474 return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3476 #define _bfd_elf_set_section_contents rx2_set_section_contents
3480 rx_set_section_contents (bfd * abfd,
3482 const void * location,
3484 bfd_size_type count)
3486 bfd_boolean exec = (abfd->flags & EXEC_P) ? TRUE : FALSE;
3487 bfd_boolean s_code = (section->flags & SEC_CODE) ? TRUE : FALSE;
3489 char * swapped_data = NULL;
3491 bfd_vma caddr = section->vma + offset;
3493 bfd_size_type scount;
3498 fprintf (stderr, "\ndj: set %ld %ld to %s %s e%d sc%d\n",
3499 (long) offset, (long) count, section->name,
3500 bfd_big_endian (abfd) ? "be" : "le",
3503 for (i = 0; i < count; i++)
3505 int a = section->vma + offset + i;
3507 if (a % 16 == 0 && a > 0)
3508 fprintf (stderr, "\n");
3510 if (a % 16 && a % 4 == 0)
3511 fprintf (stderr, " ");
3513 if (a % 16 == 0 || i == 0)
3514 fprintf (stderr, " %08x:", (int) (section->vma + offset + i));
3516 fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3519 fprintf (stderr, "\n");
3522 if (! exec || ! s_code || ! bfd_big_endian (abfd))
3523 return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3525 while (count > 0 && caddr > 0 && caddr % 4)
3529 case 0: faddr = offset + 3; break;
3530 case 1: faddr = offset + 1; break;
3531 case 2: faddr = offset - 1; break;
3532 case 3: faddr = offset - 3; break;
3535 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3545 scount = (int)(count / 4) * 4;
3548 char * cloc = (char *) location;
3550 swapped_data = (char *) bfd_alloc (abfd, count);
3552 for (i = 0; i < count; i += 4)
3554 bfd_vma v = bfd_getl32 (cloc + i);
3555 bfd_putb32 (v, swapped_data + i);
3558 rv = _bfd_elf_set_section_contents (abfd, section, swapped_data, offset, scount);
3570 caddr = section->vma + offset;
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;
3580 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3595 rx_final_link (bfd * abfd, struct bfd_link_info * info)
3599 for (o = abfd->sections; o != NULL; o = o->next)
3602 fprintf (stderr, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n",
3603 o->name, o->flags, o->vma, o->lma, o->size, o->rawsize);
3605 if (o->flags & SEC_CODE
3606 && bfd_big_endian (abfd)
3610 fprintf (stderr, "adjusting...\n");
3612 o->size += 4 - (o->size % 4);
3616 return bfd_elf_final_link (abfd, info);
3620 elf32_rx_modify_program_headers (bfd * abfd ATTRIBUTE_UNUSED,
3621 struct bfd_link_info * info ATTRIBUTE_UNUSED)
3623 const struct elf_backend_data * bed;
3624 struct elf_obj_tdata * tdata;
3625 Elf_Internal_Phdr * phdr;
3629 bed = get_elf_backend_data (abfd);
3630 tdata = elf_tdata (abfd);
3632 count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
3635 for (i = count; i-- != 0;)
3636 if (phdr[i].p_type == PT_LOAD)
3638 /* The Renesas tools expect p_paddr to be zero. However,
3639 there is no other way to store the writable data in ROM for
3640 startup initialization. So, we let the linker *think*
3641 we're using paddr and vaddr the "usual" way, but at the
3642 last minute we move the paddr into the vaddr (which is what
3643 the simulator uses) and zero out paddr. Note that this
3644 does not affect the section headers, just the program
3645 headers. We hope. */
3646 phdr[i].p_vaddr = phdr[i].p_paddr;
3647 #if 0 /* If we zero out p_paddr, then the LMA in the section table
3649 phdr[i].p_paddr = 0;
3656 /* The default literal sections should always be marked as "code" (i.e.,
3657 SHF_EXECINSTR). This is particularly important for big-endian mode
3658 when we do not want their contents byte reversed. */
3659 static const struct bfd_elf_special_section elf32_rx_special_sections[] =
3661 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3662 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3663 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3664 { NULL, 0, 0, 0, 0 }
3669 struct bfd_link_info *info;
3670 bfd_vma table_start;
3672 bfd_vma *table_handlers;
3673 bfd_vma table_default_handler;
3674 struct bfd_link_hash_entry **table_entries;
3675 struct bfd_link_hash_entry *table_default_entry;
3680 rx_table_find (struct bfd_hash_entry *vent, void *vinfo)
3682 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3683 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3684 const char *name; /* of the symbol we've found */
3688 const char *tname; /* name of the table */
3689 bfd_vma start_addr, end_addr;
3691 struct bfd_link_hash_entry * h;
3693 /* We're looking for globally defined symbols of the form
3694 $tablestart$<NAME>. */
3695 if (ent->type != bfd_link_hash_defined
3696 && ent->type != bfd_link_hash_defweak)
3699 name = ent->root.string;
3700 sec = ent->u.def.section;
3703 if (strncmp (name, "$tablestart$", 12))
3706 sec->flags |= SEC_KEEP;
3710 start_addr = ent->u.def.value;
3712 /* At this point, we can't build the table but we can (and must)
3713 find all the related symbols and mark their sections as SEC_KEEP
3714 so we don't garbage collect them. */
3716 buf = (char *) malloc (12 + 10 + strlen (tname));
3718 sprintf (buf, "$tableend$%s", tname);
3719 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3720 if (!h || (h->type != bfd_link_hash_defined
3721 && h->type != bfd_link_hash_defweak))
3723 _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"),
3724 abfd, sec, name, buf);
3728 if (h->u.def.section != ent->u.def.section)
3730 _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"),
3731 h->u.def.section->owner, h->u.def.section,
3736 end_addr = h->u.def.value;
3738 sprintf (buf, "$tableentry$default$%s", tname);
3739 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3740 if (h && (h->type == bfd_link_hash_defined
3741 || h->type == bfd_link_hash_defweak))
3743 h->u.def.section->flags |= SEC_KEEP;
3746 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3748 sprintf (buf, "$tableentry$%d$%s", idx, tname);
3749 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3750 if (h && (h->type == bfd_link_hash_defined
3751 || h->type == bfd_link_hash_defweak))
3753 h->u.def.section->flags |= SEC_KEEP;
3757 /* Return TRUE to keep scanning, FALSE to end the traversal. */
3761 /* We need to check for table entry symbols and build the tables, and
3762 we need to do it before the linker does garbage collection. This function is
3763 called once per input object file. */
3766 (bfd * abfd ATTRIBUTE_UNUSED,
3767 struct bfd_link_info * info ATTRIBUTE_UNUSED)
3769 RX_Table_Info stuff;
3773 bfd_hash_traverse (&(info->hash->table), rx_table_find, &stuff);
3780 rx_table_map_2 (struct bfd_hash_entry *vent, void *vinfo)
3782 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3783 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3788 /* See if the symbol ENT has an address listed in the table, and
3789 isn't a debug/special symbol. If so, put it in the table. */
3791 if (ent->type != bfd_link_hash_defined
3792 && ent->type != bfd_link_hash_defweak)
3795 name = ent->root.string;
3797 if (name[0] == '$' || name[0] == '.' || name[0] < ' ')
3800 addr = (ent->u.def.value
3801 + ent->u.def.section->output_section->vma
3802 + ent->u.def.section->output_offset);
3804 for (idx = 0; idx < info->table_size; idx ++)
3805 if (addr == info->table_handlers[idx])
3806 info->table_entries[idx] = ent;
3808 if (addr == info->table_default_handler)
3809 info->table_default_entry = ent;
3815 rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
3817 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3818 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3819 const char *name; /* of the symbol we've found */
3821 const char *tname; /* name of the table */
3822 bfd_vma start_addr, end_addr;
3824 struct bfd_link_hash_entry * h;
3827 /* We're looking for globally defined symbols of the form
3828 $tablestart$<NAME>. */
3829 if (ent->type != bfd_link_hash_defined
3830 && ent->type != bfd_link_hash_defweak)
3833 name = ent->root.string;
3835 if (strncmp (name, "$tablestart$", 12))
3839 start_addr = (ent->u.def.value
3840 + ent->u.def.section->output_section->vma
3841 + ent->u.def.section->output_offset);
3843 buf = (char *) malloc (12 + 10 + strlen (tname));
3845 sprintf (buf, "$tableend$%s", tname);
3846 end_addr = get_symbol_value_maybe (buf, info->info);
3848 sprintf (buf, "$tableentry$default$%s", tname);
3849 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3852 info->table_default_handler = (h->u.def.value
3853 + h->u.def.section->output_section->vma
3854 + h->u.def.section->output_offset);
3857 /* Zero is a valid handler address! */
3858 info->table_default_handler = (bfd_vma) (-1);
3859 info->table_default_entry = NULL;
3861 info->table_start = start_addr;
3862 info->table_size = (int) (end_addr - start_addr) / 4;
3863 info->table_handlers = (bfd_vma *) malloc (info->table_size * sizeof (bfd_vma));
3864 info->table_entries = (struct bfd_link_hash_entry **) malloc (info->table_size * sizeof (struct bfd_link_hash_entry));
3866 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3868 sprintf (buf, "$tableentry$%d$%s", idx, tname);
3869 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3870 if (h && (h->type == bfd_link_hash_defined
3871 || h->type == bfd_link_hash_defweak))
3873 info->table_handlers[idx] = (h->u.def.value
3874 + h->u.def.section->output_section->vma
3875 + h->u.def.section->output_offset);
3878 info->table_handlers[idx] = info->table_default_handler;
3879 info->table_entries[idx] = NULL;
3884 bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info);
3886 fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n",
3887 tname, info->table_size, start_addr);
3889 if (info->table_default_entry)
3890 fprintf (info->mapfile, " default handler is: %s at 0x%08" BFD_VMA_FMT "x\n",
3891 info->table_default_entry->root.string,
3892 info->table_default_handler);
3893 else if (info->table_default_handler != (bfd_vma)(-1))
3894 fprintf (info->mapfile, " default handler is at 0x%08" BFD_VMA_FMT "x\n",
3895 info->table_default_handler);
3897 fprintf (info->mapfile, " no default handler\n");
3900 for (idx = 0; idx < info->table_size; idx ++)
3902 if (info->table_handlers[idx] == info->table_default_handler)
3905 fprintf (info->mapfile, " . . .\n");
3911 fprintf (info->mapfile, " 0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx);
3913 if (info->table_handlers[idx] == (bfd_vma) (-1))
3914 fprintf (info->mapfile, "(no handler found)\n");
3916 else if (info->table_handlers[idx] == info->table_default_handler)
3918 if (info->table_default_entry)
3919 fprintf (info->mapfile, "(default)\n");
3921 fprintf (info->mapfile, "(default)\n");
3924 else if (info->table_entries[idx])
3926 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string);
3931 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]);
3935 fprintf (info->mapfile, " . . .\n");
3941 rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfile)
3943 /* We scan the symbol table looking for $tableentry$'s, and for
3944 each, try to deduce which handlers go with which entries. */
3946 RX_Table_Info stuff;
3950 stuff.mapfile = mapfile;
3951 bfd_hash_traverse (&(info->hash->table), rx_table_map, &stuff);
3955 #define ELF_ARCH bfd_arch_rx
3956 #define ELF_MACHINE_CODE EM_RX
3957 #define ELF_MAXPAGESIZE 0x1000
3959 #define TARGET_BIG_SYM rx_elf32_be_vec
3960 #define TARGET_BIG_NAME "elf32-rx-be"
3962 #define TARGET_LITTLE_SYM rx_elf32_le_vec
3963 #define TARGET_LITTLE_NAME "elf32-rx-le"
3965 #define elf_info_to_howto_rel NULL
3966 #define elf_info_to_howto rx_info_to_howto_rela
3967 #define elf_backend_object_p rx_elf_object_p
3968 #define elf_backend_relocate_section rx_elf_relocate_section
3969 #define elf_symbol_leading_char ('_')
3970 #define elf_backend_can_gc_sections 1
3971 #define elf_backend_modify_program_headers elf32_rx_modify_program_headers
3973 #define bfd_elf32_bfd_reloc_type_lookup rx_reloc_type_lookup
3974 #define bfd_elf32_bfd_reloc_name_lookup rx_reloc_name_lookup
3975 #define bfd_elf32_bfd_set_private_flags rx_elf_set_private_flags
3976 #define bfd_elf32_bfd_merge_private_bfd_data rx_elf_merge_private_bfd_data
3977 #define bfd_elf32_bfd_print_private_bfd_data rx_elf_print_private_bfd_data
3978 #define bfd_elf32_get_section_contents rx_get_section_contents
3979 #define bfd_elf32_set_section_contents rx_set_section_contents
3980 #define bfd_elf32_bfd_final_link rx_final_link
3981 #define bfd_elf32_bfd_relax_section elf32_rx_relax_section_wrapper
3982 #define elf_backend_special_sections elf32_rx_special_sections
3983 #define elf_backend_check_directives rx_check_directives
3985 #include "elf32-target.h"
3987 /* We define a second big-endian target that doesn't have the custom
3988 section get/set hooks, for times when we want to preserve the
3989 pre-swapped .text sections (like objcopy). */
3991 #undef TARGET_BIG_SYM
3992 #define TARGET_BIG_SYM rx_elf32_be_ns_vec
3993 #undef TARGET_BIG_NAME
3994 #define TARGET_BIG_NAME "elf32-rx-be-ns"
3995 #undef TARGET_LITTLE_SYM
3997 #undef bfd_elf32_get_section_contents
3998 #undef bfd_elf32_set_section_contents
4001 #define elf32_bed elf32_rx_be_ns_bed
4003 #include "elf32-target.h"