1/* Renesas RX specific support for 32-bit ELF. 2 Copyright (C) 2008-2017 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 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. 10 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. 15 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. */ 19 20#include "sysdep.h" 21#include "bfd.h" 22#include "bfd_stdint.h" 23#include "libbfd.h" 24#include "elf-bfd.h" 25#include "elf/rx.h" 26#include "libiberty.h" 27#include "elf32-rx.h" 28 29#define RX_OPCODE_BIG_ENDIAN 0 30 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 33 rx_elf_object_p(). */ 34const bfd_target rx_elf32_be_ns_vec; 35const bfd_target rx_elf32_be_vec; 36 37#ifdef DEBUG 38char * rx_get_reloc (long); 39void rx_dump_symtab (bfd *, void *, void *); 40#endif 41 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) 45 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. */ 49 50static reloc_howto_type rx_elf_howto_table [] = 51{ 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), 71 72 EMPTY_HOWTO (0x13), 73 EMPTY_HOWTO (0x14), 74 EMPTY_HOWTO (0x15), 75 EMPTY_HOWTO (0x16), 76 EMPTY_HOWTO (0x17), 77 EMPTY_HOWTO (0x18), 78 EMPTY_HOWTO (0x19), 79 EMPTY_HOWTO (0x1a), 80 EMPTY_HOWTO (0x1b), 81 EMPTY_HOWTO (0x1c), 82 EMPTY_HOWTO (0x1d), 83 EMPTY_HOWTO (0x1e), 84 EMPTY_HOWTO (0x1f), 85 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), 100 101 EMPTY_HOWTO (0x2e), 102 EMPTY_HOWTO (0x2f), 103 EMPTY_HOWTO (0x30), 104 EMPTY_HOWTO (0x31), 105 EMPTY_HOWTO (0x32), 106 EMPTY_HOWTO (0x33), 107 EMPTY_HOWTO (0x34), 108 EMPTY_HOWTO (0x35), 109 EMPTY_HOWTO (0x36), 110 EMPTY_HOWTO (0x37), 111 EMPTY_HOWTO (0x38), 112 EMPTY_HOWTO (0x39), 113 EMPTY_HOWTO (0x3a), 114 EMPTY_HOWTO (0x3b), 115 EMPTY_HOWTO (0x3c), 116 EMPTY_HOWTO (0x3d), 117 EMPTY_HOWTO (0x3e), 118 EMPTY_HOWTO (0x3f), 119 EMPTY_HOWTO (0x40), 120 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), 138 139#define STACK_REL_P(x) ((x) <= R_RX_ABS16_REV && (x) >= R_RX_ABS32) 140 141 EMPTY_HOWTO (0x52), 142 EMPTY_HOWTO (0x53), 143 EMPTY_HOWTO (0x54), 144 EMPTY_HOWTO (0x55), 145 EMPTY_HOWTO (0x56), 146 EMPTY_HOWTO (0x57), 147 EMPTY_HOWTO (0x58), 148 EMPTY_HOWTO (0x59), 149 EMPTY_HOWTO (0x5a), 150 EMPTY_HOWTO (0x5b), 151 EMPTY_HOWTO (0x5c), 152 EMPTY_HOWTO (0x5d), 153 EMPTY_HOWTO (0x5e), 154 EMPTY_HOWTO (0x5f), 155 EMPTY_HOWTO (0x60), 156 EMPTY_HOWTO (0x61), 157 EMPTY_HOWTO (0x62), 158 EMPTY_HOWTO (0x63), 159 EMPTY_HOWTO (0x64), 160 EMPTY_HOWTO (0x65), 161 EMPTY_HOWTO (0x66), 162 EMPTY_HOWTO (0x67), 163 EMPTY_HOWTO (0x68), 164 EMPTY_HOWTO (0x69), 165 EMPTY_HOWTO (0x6a), 166 EMPTY_HOWTO (0x6b), 167 EMPTY_HOWTO (0x6c), 168 EMPTY_HOWTO (0x6d), 169 EMPTY_HOWTO (0x6e), 170 EMPTY_HOWTO (0x6f), 171 EMPTY_HOWTO (0x70), 172 EMPTY_HOWTO (0x71), 173 EMPTY_HOWTO (0x72), 174 EMPTY_HOWTO (0x73), 175 EMPTY_HOWTO (0x74), 176 EMPTY_HOWTO (0x75), 177 EMPTY_HOWTO (0x76), 178 EMPTY_HOWTO (0x77), 179 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. */ 204 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) 222}; 223 224/* Map BFD reloc types to RX ELF reloc types. */ 225 226struct rx_reloc_map 227{ 228 bfd_reloc_code_real_type bfd_reloc_val; 229 unsigned int rx_reloc_val; 230}; 231 232static const struct rx_reloc_map rx_reloc_map [] = 233{ 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 } 267}; 268 269#define BIGE(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG) 270 271static reloc_howto_type * 272rx_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 273 bfd_reloc_code_real_type code) 274{ 275 unsigned int i; 276 277 if (code == BFD_RELOC_RX_32_OP) 278 return rx_elf_howto_table + R_RX_DIR32; 279 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; 283 284 return NULL; 285} 286 287static reloc_howto_type * 288rx_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name) 289{ 290 unsigned int i; 291 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; 296 297 return NULL; 298} 299 300/* Set the howto pointer for an RX ELF reloc. */ 301 302static void 303rx_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 304 arelent * cache_ptr, 305 Elf_Internal_Rela * dst) 306{ 307 unsigned int r_type; 308 309 r_type = ELF32_R_TYPE (dst->r_info); 310 if (r_type >= (unsigned int) R_RX_max) 311 { 312 /* xgettext:c-format */ 313 _bfd_error_handler (_("%B: invalid RX reloc number: %d"), abfd, r_type); 314 r_type = 0; 315 } 316 cache_ptr->howto = rx_elf_howto_table + r_type; 317} 318 319static bfd_vma 320get_symbol_value (const char * name, 321 struct bfd_link_info * info, 322 bfd * input_bfd, 323 asection * input_section, 324 int offset) 325{ 326 bfd_vma value = 0; 327 struct bfd_link_hash_entry * h; 328 329 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); 330 331 if (h == NULL 332 || (h->type != bfd_link_hash_defined 333 && h->type != bfd_link_hash_defweak)) 334 (*info->callbacks->undefined_symbol) 335 (info, name, input_bfd, input_section, offset, TRUE); 336 else 337 value = (h->u.def.value 338 + h->u.def.section->output_section->vma 339 + h->u.def.section->output_offset); 340 341 return value; 342} 343 344static bfd_vma 345get_symbol_value_maybe (const char * name, 346 struct bfd_link_info * info) 347{ 348 bfd_vma value = 0; 349 struct bfd_link_hash_entry * h; 350 351 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); 352 353 if (h == NULL 354 || (h->type != bfd_link_hash_defined 355 && h->type != bfd_link_hash_defweak)) 356 return 0; 357 else 358 value = (h->u.def.value 359 + h->u.def.section->output_section->vma 360 + h->u.def.section->output_offset); 361 362 return value; 363} 364 365static bfd_vma 366get_gp (struct bfd_link_info * info, 367 bfd * abfd, 368 asection * sec, 369 int offset) 370{ 371 static bfd_boolean cached = FALSE; 372 static bfd_vma cached_value = 0; 373 374 if (!cached) 375 { 376 cached_value = get_symbol_value ("__gp", info, abfd, sec, offset); 377 cached = TRUE; 378 } 379 return cached_value; 380} 381 382static bfd_vma 383get_romstart (struct bfd_link_info * info, 384 bfd * abfd, 385 asection * sec, 386 int offset) 387{ 388 static bfd_boolean cached = FALSE; 389 static bfd_vma cached_value = 0; 390 391 if (!cached) 392 { 393 cached_value = get_symbol_value ("_start", info, abfd, sec, offset); 394 cached = TRUE; 395 } 396 return cached_value; 397} 398 399static bfd_vma 400get_ramstart (struct bfd_link_info * info, 401 bfd * abfd, 402 asection * sec, 403 int offset) 404{ 405 static bfd_boolean cached = FALSE; 406 static bfd_vma cached_value = 0; 407 408 if (!cached) 409 { 410 cached_value = get_symbol_value ("__datastart", info, abfd, sec, offset); 411 cached = TRUE; 412 } 413 return cached_value; 414} 415 416#define NUM_STACK_ENTRIES 16 417static int32_t rx_stack [ NUM_STACK_ENTRIES ]; 418static unsigned int rx_stack_top; 419 420#define RX_STACK_PUSH(val) \ 421 do \ 422 { \ 423 if (rx_stack_top < NUM_STACK_ENTRIES) \ 424 rx_stack [rx_stack_top ++] = (val); \ 425 else \ 426 r = bfd_reloc_dangerous; \ 427 } \ 428 while (0) 429 430#define RX_STACK_POP(dest) \ 431 do \ 432 { \ 433 if (rx_stack_top > 0) \ 434 (dest) = rx_stack [-- rx_stack_top]; \ 435 else \ 436 (dest) = 0, r = bfd_reloc_dangerous; \ 437 } \ 438 while (0) 439 440/* Relocate an RX ELF section. 441 There is some attempt to make this function usable for many architectures, 442 both USE_REL and USE_RELA ['twould be nice if such a critter existed], 443 if only to serve as a learning tool. 444 445 The RELOCATE_SECTION function is called by the new ELF backend linker 446 to handle the relocations for a section. 447 448 The relocs are always passed as Rela structures; if the section 449 actually uses Rel structures, the r_addend field will always be 450 zero. 451 452 This function is responsible for adjusting the section contents as 453 necessary, and (if using Rela relocs and generating a relocatable 454 output file) adjusting the reloc addend as necessary. 455 456 This function does not have to worry about setting the reloc 457 address or the reloc symbol index. 458 459 LOCAL_SYMS is a pointer to the swapped in local symbols. 460 461 LOCAL_SECTIONS is an array giving the section in the input file 462 corresponding to the st_shndx field of each local symbol. 463 464 The global hash table entry for the global symbols can be found 465 via elf_sym_hashes (input_bfd). 466 467 When generating relocatable output, this function must handle 468 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 469 going to be the section symbol corresponding to the output 470 section, which means that the addend must be adjusted 471 accordingly. */ 472 473static bfd_boolean 474rx_elf_relocate_section 475 (bfd * output_bfd, 476 struct bfd_link_info * info, 477 bfd * input_bfd, 478 asection * input_section, 479 bfd_byte * contents, 480 Elf_Internal_Rela * relocs, 481 Elf_Internal_Sym * local_syms, 482 asection ** local_sections) 483{ 484 Elf_Internal_Shdr * symtab_hdr; 485 struct elf_link_hash_entry ** sym_hashes; 486 Elf_Internal_Rela * rel; 487 Elf_Internal_Rela * relend; 488 bfd_boolean pid_mode; 489 bfd_boolean saw_subtract = FALSE; 490 const char * table_default_cache = NULL; 491 bfd_vma table_start_cache = 0; 492 bfd_vma table_end_cache = 0; 493 494 if (elf_elfheader (output_bfd)->e_flags & E_FLAG_RX_PID) 495 pid_mode = TRUE; 496 else 497 pid_mode = FALSE; 498 499 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 500 sym_hashes = elf_sym_hashes (input_bfd); 501 relend = relocs + input_section->reloc_count; 502 for (rel = relocs; rel < relend; rel ++) 503 { 504 reloc_howto_type * howto; 505 unsigned long r_symndx; 506 Elf_Internal_Sym * sym; 507 asection * sec; 508 struct elf_link_hash_entry * h; 509 bfd_vma relocation; 510 bfd_reloc_status_type r; 511 const char * name = NULL; 512 bfd_boolean unresolved_reloc = TRUE; 513 int r_type; 514 515 r_type = ELF32_R_TYPE (rel->r_info); 516 r_symndx = ELF32_R_SYM (rel->r_info); 517 518 howto = rx_elf_howto_table + ELF32_R_TYPE (rel->r_info); 519 h = NULL; 520 sym = NULL; 521 sec = NULL; 522 relocation = 0; 523 524 if (rx_stack_top == 0) 525 saw_subtract = FALSE; 526 527 if (r_symndx < symtab_hdr->sh_info) 528 { 529 sym = local_syms + r_symndx; 530 sec = local_sections [r_symndx]; 531 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel); 532 533 name = bfd_elf_string_from_elf_section 534 (input_bfd, symtab_hdr->sh_link, sym->st_name); 535 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name; 536 } 537 else 538 { 539 bfd_boolean warned, ignored; 540 541 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 542 r_symndx, symtab_hdr, sym_hashes, h, 543 sec, relocation, unresolved_reloc, 544 warned, ignored); 545 546 name = h->root.root.string; 547 } 548 549 if (strncmp (name, "$tableentry$default$", 20) == 0) 550 { 551 bfd_vma entry_vma; 552 int idx; 553 char *buf; 554 555 if (table_default_cache != name) 556 { 557 558 /* All relocs for a given table should be to the same 559 (weak) default symbol) so we can use it to detect a 560 cache miss. We use the offset into the table to find 561 the "real" symbol. Calculate and store the table's 562 offset here. */ 563 564 table_default_cache = name; 565 566 /* We have already done error checking in rx_table_find(). */ 567 568 buf = (char *) malloc (13 + strlen (name + 20)); 569 570 sprintf (buf, "$tablestart$%s", name + 20); 571 table_start_cache = get_symbol_value (buf, 572 info, 573 input_bfd, 574 input_section, 575 rel->r_offset); 576 577 sprintf (buf, "$tableend$%s", name + 20); 578 table_end_cache = get_symbol_value (buf, 579 info, 580 input_bfd, 581 input_section, 582 rel->r_offset); 583 584 free (buf); 585 } 586 587 entry_vma = (input_section->output_section->vma 588 + input_section->output_offset 589 + rel->r_offset); 590 591 if (table_end_cache <= entry_vma || entry_vma < table_start_cache) 592 { 593 /* xgettext:c-format */ 594 _bfd_error_handler (_("%B:%A: table entry %s outside table"), 595 input_bfd, input_section, 596 name); 597 } 598 else if ((int) (entry_vma - table_start_cache) % 4) 599 { 600 /* xgettext:c-format */ 601 _bfd_error_handler (_("%B:%A: table entry %s not word-aligned within table"), 602 input_bfd, input_section, 603 name); 604 } 605 else 606 { 607 idx = (int) (entry_vma - table_start_cache) / 4; 608 609 /* This will look like $tableentry$<N>$<name> */ 610 buf = (char *) malloc (12 + 20 + strlen (name + 20)); 611 sprintf (buf, "$tableentry$%d$%s", idx, name + 20); 612 613 h = (struct elf_link_hash_entry *) bfd_link_hash_lookup (info->hash, buf, FALSE, FALSE, TRUE); 614 615 if (h) 616 { 617 relocation = (h->root.u.def.value 618 + h->root.u.def.section->output_section->vma 619 + h->root.u.def.section->output_offset);; 620 } 621 622 free (buf); 623 } 624 } 625 626 if (sec != NULL && discarded_section (sec)) 627 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 628 rel, 1, relend, howto, 0, contents); 629 630 if (bfd_link_relocatable (info)) 631 { 632 /* This is a relocatable link. We don't have to change 633 anything, unless the reloc is against a section symbol, 634 in which case we have to adjust according to where the 635 section symbol winds up in the output section. */ 636 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 637 rel->r_addend += sec->output_offset; 638 continue; 639 } 640 641 if (h != NULL && h->root.type == bfd_link_hash_undefweak) 642 /* If the symbol is undefined and weak 643 then the relocation resolves to zero. */ 644 relocation = 0; 645 else 646 { 647 if (howto->pc_relative) 648 { 649 relocation -= (input_section->output_section->vma 650 + input_section->output_offset 651 + rel->r_offset); 652 if (r_type != R_RX_RH_3_PCREL 653 && r_type != R_RX_DIR3U_PCREL) 654 relocation ++; 655 } 656 657 relocation += rel->r_addend; 658 } 659 660 r = bfd_reloc_ok; 661 662#define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow 663#define ALIGN(m) if (relocation & m) r = bfd_reloc_other; 664#define OP(i) (contents[rel->r_offset + (i)]) 665#define WARN_REDHAT(type) \ 666 /* xgettext:c-format */ \ 667 _bfd_error_handler (_("%B:%A: Warning: deprecated Red Hat reloc " type " detected against: %s."), \ 668 input_bfd, input_section, name) 669 670 /* Check for unsafe relocs in PID mode. These are any relocs where 671 an absolute address is being computed. There are special cases 672 for relocs against symbols that are known to be referenced in 673 crt0.o before the PID base address register has been initialised. */ 674#define UNSAFE_FOR_PID \ 675 do \ 676 { \ 677 if (pid_mode \ 678 && sec != NULL \ 679 && sec->flags & SEC_READONLY \ 680 && !(input_section->flags & SEC_DEBUGGING) \ 681 && strcmp (name, "__pid_base") != 0 \ 682 && strcmp (name, "__gp") != 0 \ 683 && strcmp (name, "__romdatastart") != 0 \ 684 && !saw_subtract) \ 685 /* xgettext:c-format */ \ 686 _bfd_error_handler (_("%B(%A): unsafe PID relocation %s at 0x%08lx (against %s in %s)"), \ 687 input_bfd, input_section, howto->name, \ 688 input_section->output_section->vma + input_section->output_offset + rel->r_offset, \ 689 name, sec->name); \ 690 } \ 691 while (0) 692 693 /* Opcode relocs are always big endian. Data relocs are bi-endian. */ 694 switch (r_type) 695 { 696 case R_RX_NONE: 697 break; 698 699 case R_RX_RH_RELAX: 700 break; 701 702 case R_RX_RH_3_PCREL: 703 WARN_REDHAT ("RX_RH_3_PCREL"); 704 RANGE (3, 10); 705 OP (0) &= 0xf8; 706 OP (0) |= relocation & 0x07; 707 break; 708 709 case R_RX_RH_8_NEG: 710 WARN_REDHAT ("RX_RH_8_NEG"); 711 relocation = - relocation; 712 /* Fall through. */ 713 case R_RX_DIR8S_PCREL: 714 UNSAFE_FOR_PID; 715 RANGE (-128, 127); 716 OP (0) = relocation; 717 break; 718 719 case R_RX_DIR8S: 720 UNSAFE_FOR_PID; 721 RANGE (-128, 255); 722 OP (0) = relocation; 723 break; 724 725 case R_RX_DIR8U: 726 UNSAFE_FOR_PID; 727 RANGE (0, 255); 728 OP (0) = relocation; 729 break; 730 731 case R_RX_RH_16_NEG: 732 WARN_REDHAT ("RX_RH_16_NEG"); 733 relocation = - relocation; 734 /* Fall through. */ 735 case R_RX_DIR16S_PCREL: 736 UNSAFE_FOR_PID; 737 RANGE (-32768, 32767); 738#if RX_OPCODE_BIG_ENDIAN 739#else 740 OP (0) = relocation; 741 OP (1) = relocation >> 8; 742#endif 743 break; 744 745 case R_RX_RH_16_OP: 746 WARN_REDHAT ("RX_RH_16_OP"); 747 UNSAFE_FOR_PID; 748 RANGE (-32768, 32767); 749#if RX_OPCODE_BIG_ENDIAN 750 OP (1) = relocation; 751 OP (0) = relocation >> 8; 752#else 753 OP (0) = relocation; 754 OP (1) = relocation >> 8; 755#endif 756 break; 757 758 case R_RX_DIR16S: 759 UNSAFE_FOR_PID; 760 RANGE (-32768, 65535); 761 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE)) 762 { 763 OP (1) = relocation; 764 OP (0) = relocation >> 8; 765 } 766 else 767 { 768 OP (0) = relocation; 769 OP (1) = relocation >> 8; 770 } 771 break; 772 773 case R_RX_DIR16U: 774 UNSAFE_FOR_PID; 775 RANGE (0, 65536); 776#if RX_OPCODE_BIG_ENDIAN 777 OP (1) = relocation; 778 OP (0) = relocation >> 8; 779#else 780 OP (0) = relocation; 781 OP (1) = relocation >> 8; 782#endif 783 break; 784 785 case R_RX_DIR16: 786 UNSAFE_FOR_PID; 787 RANGE (-32768, 65536); 788#if RX_OPCODE_BIG_ENDIAN 789 OP (1) = relocation; 790 OP (0) = relocation >> 8; 791#else 792 OP (0) = relocation; 793 OP (1) = relocation >> 8; 794#endif 795 break; 796 797 case R_RX_DIR16_REV: 798 UNSAFE_FOR_PID; 799 RANGE (-32768, 65536); 800#if RX_OPCODE_BIG_ENDIAN 801 OP (0) = relocation; 802 OP (1) = relocation >> 8; 803#else 804 OP (1) = relocation; 805 OP (0) = relocation >> 8; 806#endif 807 break; 808 809 case R_RX_DIR3U_PCREL: 810 RANGE (3, 10); 811 OP (0) &= 0xf8; 812 OP (0) |= relocation & 0x07; 813 break; 814 815 case R_RX_RH_24_NEG: 816 UNSAFE_FOR_PID; 817 WARN_REDHAT ("RX_RH_24_NEG"); 818 relocation = - relocation; 819 /* Fall through. */ 820 case R_RX_DIR24S_PCREL: 821 RANGE (-0x800000, 0x7fffff); 822#if RX_OPCODE_BIG_ENDIAN 823 OP (2) = relocation; 824 OP (1) = relocation >> 8; 825 OP (0) = relocation >> 16; 826#else 827 OP (0) = relocation; 828 OP (1) = relocation >> 8; 829 OP (2) = relocation >> 16; 830#endif 831 break; 832 833 case R_RX_RH_24_OP: 834 UNSAFE_FOR_PID; 835 WARN_REDHAT ("RX_RH_24_OP"); 836 RANGE (-0x800000, 0x7fffff); 837#if RX_OPCODE_BIG_ENDIAN 838 OP (2) = relocation; 839 OP (1) = relocation >> 8; 840 OP (0) = relocation >> 16; 841#else 842 OP (0) = relocation; 843 OP (1) = relocation >> 8; 844 OP (2) = relocation >> 16; 845#endif 846 break; 847 848 case R_RX_DIR24S: 849 UNSAFE_FOR_PID; 850 RANGE (-0x800000, 0x7fffff); 851 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE)) 852 { 853 OP (2) = relocation; 854 OP (1) = relocation >> 8; 855 OP (0) = relocation >> 16; 856 } 857 else 858 { 859 OP (0) = relocation; 860 OP (1) = relocation >> 8; 861 OP (2) = relocation >> 16; 862 } 863 break; 864 865 case R_RX_RH_24_UNS: 866 UNSAFE_FOR_PID; 867 WARN_REDHAT ("RX_RH_24_UNS"); 868 RANGE (0, 0xffffff); 869#if RX_OPCODE_BIG_ENDIAN 870 OP (2) = relocation; 871 OP (1) = relocation >> 8; 872 OP (0) = relocation >> 16; 873#else 874 OP (0) = relocation; 875 OP (1) = relocation >> 8; 876 OP (2) = relocation >> 16; 877#endif 878 break; 879 880 case R_RX_RH_32_NEG: 881 UNSAFE_FOR_PID; 882 WARN_REDHAT ("RX_RH_32_NEG"); 883 relocation = - relocation; 884#if RX_OPCODE_BIG_ENDIAN 885 OP (3) = relocation; 886 OP (2) = relocation >> 8; 887 OP (1) = relocation >> 16; 888 OP (0) = relocation >> 24; 889#else 890 OP (0) = relocation; 891 OP (1) = relocation >> 8; 892 OP (2) = relocation >> 16; 893 OP (3) = relocation >> 24; 894#endif 895 break; 896 897 case R_RX_RH_32_OP: 898 UNSAFE_FOR_PID; 899 WARN_REDHAT ("RX_RH_32_OP"); 900#if RX_OPCODE_BIG_ENDIAN 901 OP (3) = relocation; 902 OP (2) = relocation >> 8; 903 OP (1) = relocation >> 16; 904 OP (0) = relocation >> 24; 905#else 906 OP (0) = relocation; 907 OP (1) = relocation >> 8; 908 OP (2) = relocation >> 16; 909 OP (3) = relocation >> 24; 910#endif 911 break; 912 913 case R_RX_DIR32: 914 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE)) 915 { 916 OP (3) = relocation; 917 OP (2) = relocation >> 8; 918 OP (1) = relocation >> 16; 919 OP (0) = relocation >> 24; 920 } 921 else 922 { 923 OP (0) = relocation; 924 OP (1) = relocation >> 8; 925 OP (2) = relocation >> 16; 926 OP (3) = relocation >> 24; 927 } 928 break; 929 930 case R_RX_DIR32_REV: 931 if (BIGE (output_bfd)) 932 { 933 OP (0) = relocation; 934 OP (1) = relocation >> 8; 935 OP (2) = relocation >> 16; 936 OP (3) = relocation >> 24; 937 } 938 else 939 { 940 OP (3) = relocation; 941 OP (2) = relocation >> 8; 942 OP (1) = relocation >> 16; 943 OP (0) = relocation >> 24; 944 } 945 break; 946 947 case R_RX_RH_DIFF: 948 { 949 bfd_vma val; 950 WARN_REDHAT ("RX_RH_DIFF"); 951 val = bfd_get_32 (output_bfd, & OP (0)); 952 val -= relocation; 953 bfd_put_32 (output_bfd, val, & OP (0)); 954 } 955 break; 956 957 case R_RX_RH_GPRELB: 958 WARN_REDHAT ("RX_RH_GPRELB"); 959 relocation -= get_gp (info, input_bfd, input_section, rel->r_offset); 960 RANGE (0, 65535); 961#if RX_OPCODE_BIG_ENDIAN 962 OP (1) = relocation; 963 OP (0) = relocation >> 8; 964#else 965 OP (0) = relocation; 966 OP (1) = relocation >> 8; 967#endif 968 break; 969 970 case R_RX_RH_GPRELW: 971 WARN_REDHAT ("RX_RH_GPRELW"); 972 relocation -= get_gp (info, input_bfd, input_section, rel->r_offset); 973 ALIGN (1); 974 relocation >>= 1; 975 RANGE (0, 65535); 976#if RX_OPCODE_BIG_ENDIAN 977 OP (1) = relocation; 978 OP (0) = relocation >> 8; 979#else 980 OP (0) = relocation; 981 OP (1) = relocation >> 8; 982#endif 983 break; 984 985 case R_RX_RH_GPRELL: 986 WARN_REDHAT ("RX_RH_GPRELL"); 987 relocation -= get_gp (info, input_bfd, input_section, rel->r_offset); 988 ALIGN (3); 989 relocation >>= 2; 990 RANGE (0, 65535); 991#if RX_OPCODE_BIG_ENDIAN 992 OP (1) = relocation; 993 OP (0) = relocation >> 8; 994#else 995 OP (0) = relocation; 996 OP (1) = relocation >> 8; 997#endif 998 break; 999 1000 /* Internal relocations just for relaxation: */ 1001 case R_RX_RH_ABS5p5B: 1002 RX_STACK_POP (relocation); 1003 RANGE (0, 31); 1004 OP (0) &= 0xf8; 1005 OP (0) |= relocation >> 2; 1006 OP (1) &= 0x77; 1007 OP (1) |= (relocation << 6) & 0x80; 1008 OP (1) |= (relocation << 3) & 0x08; 1009 break; 1010 1011 case R_RX_RH_ABS5p5W: 1012 RX_STACK_POP (relocation); 1013 RANGE (0, 62); 1014 ALIGN (1); 1015 relocation >>= 1; 1016 OP (0) &= 0xf8; 1017 OP (0) |= relocation >> 2; 1018 OP (1) &= 0x77; 1019 OP (1) |= (relocation << 6) & 0x80; 1020 OP (1) |= (relocation << 3) & 0x08; 1021 break; 1022 1023 case R_RX_RH_ABS5p5L: 1024 RX_STACK_POP (relocation); 1025 RANGE (0, 124); 1026 ALIGN (3); 1027 relocation >>= 2; 1028 OP (0) &= 0xf8; 1029 OP (0) |= relocation >> 2; 1030 OP (1) &= 0x77; 1031 OP (1) |= (relocation << 6) & 0x80; 1032 OP (1) |= (relocation << 3) & 0x08; 1033 break; 1034 1035 case R_RX_RH_ABS5p8B: 1036 RX_STACK_POP (relocation); 1037 RANGE (0, 31); 1038 OP (0) &= 0x70; 1039 OP (0) |= (relocation << 3) & 0x80; 1040 OP (0) |= relocation & 0x0f; 1041 break; 1042 1043 case R_RX_RH_ABS5p8W: 1044 RX_STACK_POP (relocation); 1045 RANGE (0, 62); 1046 ALIGN (1); 1047 relocation >>= 1; 1048 OP (0) &= 0x70; 1049 OP (0) |= (relocation << 3) & 0x80; 1050 OP (0) |= relocation & 0x0f; 1051 break; 1052 1053 case R_RX_RH_ABS5p8L: 1054 RX_STACK_POP (relocation); 1055 RANGE (0, 124); 1056 ALIGN (3); 1057 relocation >>= 2; 1058 OP (0) &= 0x70; 1059 OP (0) |= (relocation << 3) & 0x80; 1060 OP (0) |= relocation & 0x0f; 1061 break; 1062 1063 case R_RX_RH_UIMM4p8: 1064 RANGE (0, 15); 1065 OP (0) &= 0x0f; 1066 OP (0) |= relocation << 4; 1067 break; 1068 1069 case R_RX_RH_UNEG4p8: 1070 RANGE (-15, 0); 1071 OP (0) &= 0x0f; 1072 OP (0) |= (-relocation) << 4; 1073 break; 1074 1075 /* Complex reloc handling: */ 1076 1077 case R_RX_ABS32: 1078 UNSAFE_FOR_PID; 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; 1085#else 1086 OP (0) = relocation; 1087 OP (1) = relocation >> 8; 1088 OP (2) = relocation >> 16; 1089 OP (3) = relocation >> 24; 1090#endif 1091 break; 1092 1093 case R_RX_ABS32_REV: 1094 UNSAFE_FOR_PID; 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; 1101#else 1102 OP (3) = relocation; 1103 OP (2) = relocation >> 8; 1104 OP (1) = relocation >> 16; 1105 OP (0) = relocation >> 24; 1106#endif 1107 break; 1108 1109 case R_RX_ABS24S_PCREL: 1110 case R_RX_ABS24S: 1111 UNSAFE_FOR_PID; 1112 RX_STACK_POP (relocation); 1113 RANGE (-0x800000, 0x7fffff); 1114 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE)) 1115 { 1116 OP (2) = relocation; 1117 OP (1) = relocation >> 8; 1118 OP (0) = relocation >> 16; 1119 } 1120 else 1121 { 1122 OP (0) = relocation; 1123 OP (1) = relocation >> 8; 1124 OP (2) = relocation >> 16; 1125 } 1126 break; 1127 1128 case R_RX_ABS16: 1129 UNSAFE_FOR_PID; 1130 RX_STACK_POP (relocation); 1131 RANGE (-32768, 65535); 1132#if RX_OPCODE_BIG_ENDIAN 1133 OP (1) = relocation; 1134 OP (0) = relocation >> 8; 1135#else 1136 OP (0) = relocation; 1137 OP (1) = relocation >> 8; 1138#endif 1139 break; 1140 1141 case R_RX_ABS16_REV: 1142 UNSAFE_FOR_PID; 1143 RX_STACK_POP (relocation); 1144 RANGE (-32768, 65535); 1145#if RX_OPCODE_BIG_ENDIAN 1146 OP (0) = relocation; 1147 OP (1) = relocation >> 8; 1148#else 1149 OP (1) = relocation; 1150 OP (0) = relocation >> 8; 1151#endif 1152 break; 1153 1154 case R_RX_ABS16S_PCREL: 1155 case R_RX_ABS16S: 1156 RX_STACK_POP (relocation); 1157 RANGE (-32768, 32767); 1158 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE)) 1159 { 1160 OP (1) = relocation; 1161 OP (0) = relocation >> 8; 1162 } 1163 else 1164 { 1165 OP (0) = relocation; 1166 OP (1) = relocation >> 8; 1167 } 1168 break; 1169 1170 case R_RX_ABS16U: 1171 UNSAFE_FOR_PID; 1172 RX_STACK_POP (relocation); 1173 RANGE (0, 65536); 1174#if RX_OPCODE_BIG_ENDIAN 1175 OP (1) = relocation; 1176 OP (0) = relocation >> 8; 1177#else 1178 OP (0) = relocation; 1179 OP (1) = relocation >> 8; 1180#endif 1181 break; 1182 1183 case R_RX_ABS16UL: 1184 UNSAFE_FOR_PID; 1185 RX_STACK_POP (relocation); 1186 relocation >>= 2; 1187 RANGE (0, 65536); 1188#if RX_OPCODE_BIG_ENDIAN 1189 OP (1) = relocation; 1190 OP (0) = relocation >> 8; 1191#else 1192 OP (0) = relocation; 1193 OP (1) = relocation >> 8; 1194#endif 1195 break; 1196 1197 case R_RX_ABS16UW: 1198 UNSAFE_FOR_PID; 1199 RX_STACK_POP (relocation); 1200 relocation >>= 1; 1201 RANGE (0, 65536); 1202#if RX_OPCODE_BIG_ENDIAN 1203 OP (1) = relocation; 1204 OP (0) = relocation >> 8; 1205#else 1206 OP (0) = relocation; 1207 OP (1) = relocation >> 8; 1208#endif 1209 break; 1210 1211 case R_RX_ABS8: 1212 UNSAFE_FOR_PID; 1213 RX_STACK_POP (relocation); 1214 RANGE (-128, 255); 1215 OP (0) = relocation; 1216 break; 1217 1218 case R_RX_ABS8U: 1219 UNSAFE_FOR_PID; 1220 RX_STACK_POP (relocation); 1221 RANGE (0, 255); 1222 OP (0) = relocation; 1223 break; 1224 1225 case R_RX_ABS8UL: 1226 UNSAFE_FOR_PID; 1227 RX_STACK_POP (relocation); 1228 relocation >>= 2; 1229 RANGE (0, 255); 1230 OP (0) = relocation; 1231 break; 1232 1233 case R_RX_ABS8UW: 1234 UNSAFE_FOR_PID; 1235 RX_STACK_POP (relocation); 1236 relocation >>= 1; 1237 RANGE (0, 255); 1238 OP (0) = relocation; 1239 break; 1240 1241 case R_RX_ABS8S: 1242 UNSAFE_FOR_PID; 1243 /* Fall through. */ 1244 case R_RX_ABS8S_PCREL: 1245 RX_STACK_POP (relocation); 1246 RANGE (-128, 127); 1247 OP (0) = relocation; 1248 break; 1249 1250 case R_RX_SYM: 1251 if (r_symndx < symtab_hdr->sh_info) 1252 RX_STACK_PUSH (sec->output_section->vma 1253 + sec->output_offset 1254 + sym->st_value 1255 + rel->r_addend); 1256 else 1257 { 1258 if (h != NULL 1259 && (h->root.type == bfd_link_hash_defined 1260 || h->root.type == bfd_link_hash_defweak)) 1261 RX_STACK_PUSH (h->root.u.def.value 1262 + sec->output_section->vma 1263 + sec->output_offset 1264 + rel->r_addend); 1265 else 1266 _bfd_error_handler (_("Warning: RX_SYM reloc with an unknown symbol")); 1267 } 1268 break; 1269 1270 case R_RX_OPneg: 1271 { 1272 int32_t tmp; 1273 1274 saw_subtract = TRUE; 1275 RX_STACK_POP (tmp); 1276 tmp = - tmp; 1277 RX_STACK_PUSH (tmp); 1278 } 1279 break; 1280 1281 case R_RX_OPadd: 1282 { 1283 int32_t tmp1, tmp2; 1284 1285 RX_STACK_POP (tmp1); 1286 RX_STACK_POP (tmp2); 1287 tmp1 += tmp2; 1288 RX_STACK_PUSH (tmp1); 1289 } 1290 break; 1291 1292 case R_RX_OPsub: 1293 { 1294 int32_t tmp1, tmp2; 1295 1296 saw_subtract = TRUE; 1297 RX_STACK_POP (tmp1); 1298 RX_STACK_POP (tmp2); 1299 tmp2 -= tmp1; 1300 RX_STACK_PUSH (tmp2); 1301 } 1302 break; 1303 1304 case R_RX_OPmul: 1305 { 1306 int32_t tmp1, tmp2; 1307 1308 RX_STACK_POP (tmp1); 1309 RX_STACK_POP (tmp2); 1310 tmp1 *= tmp2; 1311 RX_STACK_PUSH (tmp1); 1312 } 1313 break; 1314 1315 case R_RX_OPdiv: 1316 { 1317 int32_t tmp1, tmp2; 1318 1319 RX_STACK_POP (tmp1); 1320 RX_STACK_POP (tmp2); 1321 tmp1 /= tmp2; 1322 RX_STACK_PUSH (tmp1); 1323 } 1324 break; 1325 1326 case R_RX_OPshla: 1327 { 1328 int32_t tmp1, tmp2; 1329 1330 RX_STACK_POP (tmp1); 1331 RX_STACK_POP (tmp2); 1332 tmp1 <<= tmp2; 1333 RX_STACK_PUSH (tmp1); 1334 } 1335 break; 1336 1337 case R_RX_OPshra: 1338 { 1339 int32_t tmp1, tmp2; 1340 1341 RX_STACK_POP (tmp1); 1342 RX_STACK_POP (tmp2); 1343 tmp1 >>= tmp2; 1344 RX_STACK_PUSH (tmp1); 1345 } 1346 break; 1347 1348 case R_RX_OPsctsize: 1349 RX_STACK_PUSH (input_section->size); 1350 break; 1351 1352 case R_RX_OPscttop: 1353 RX_STACK_PUSH (input_section->output_section->vma); 1354 break; 1355 1356 case R_RX_OPand: 1357 { 1358 int32_t tmp1, tmp2; 1359 1360 RX_STACK_POP (tmp1); 1361 RX_STACK_POP (tmp2); 1362 tmp1 &= tmp2; 1363 RX_STACK_PUSH (tmp1); 1364 } 1365 break; 1366 1367 case R_RX_OPor: 1368 { 1369 int32_t tmp1, tmp2; 1370 1371 RX_STACK_POP (tmp1); 1372 RX_STACK_POP (tmp2); 1373 tmp1 |= tmp2; 1374 RX_STACK_PUSH (tmp1); 1375 } 1376 break; 1377 1378 case R_RX_OPxor: 1379 { 1380 int32_t tmp1, tmp2; 1381 1382 RX_STACK_POP (tmp1); 1383 RX_STACK_POP (tmp2); 1384 tmp1 ^= tmp2; 1385 RX_STACK_PUSH (tmp1); 1386 } 1387 break; 1388 1389 case R_RX_OPnot: 1390 { 1391 int32_t tmp; 1392 1393 RX_STACK_POP (tmp); 1394 tmp = ~ tmp; 1395 RX_STACK_PUSH (tmp); 1396 } 1397 break; 1398 1399 case R_RX_OPmod: 1400 { 1401 int32_t tmp1, tmp2; 1402 1403 RX_STACK_POP (tmp1); 1404 RX_STACK_POP (tmp2); 1405 tmp1 %= tmp2; 1406 RX_STACK_PUSH (tmp1); 1407 } 1408 break; 1409 1410 case R_RX_OPromtop: 1411 RX_STACK_PUSH (get_romstart (info, input_bfd, input_section, rel->r_offset)); 1412 break; 1413 1414 case R_RX_OPramtop: 1415 RX_STACK_PUSH (get_ramstart (info, input_bfd, input_section, rel->r_offset)); 1416 break; 1417 1418 default: 1419 r = bfd_reloc_notsupported; 1420 break; 1421 } 1422 1423 if (r != bfd_reloc_ok) 1424 { 1425 const char * msg = NULL; 1426 1427 switch (r) 1428 { 1429 case bfd_reloc_overflow: 1430 /* Catch the case of a missing function declaration 1431 and emit a more helpful error message. */ 1432 if (r_type == R_RX_DIR24S_PCREL) 1433 /* xgettext:c-format */ 1434 msg = _("%B(%A): error: call to undefined function '%s'"); 1435 else 1436 (*info->callbacks->reloc_overflow) 1437 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, 1438 input_bfd, input_section, rel->r_offset); 1439 break; 1440 1441 case bfd_reloc_undefined: 1442 (*info->callbacks->undefined_symbol) 1443 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 1444 break; 1445 1446 case bfd_reloc_other: 1447 /* xgettext:c-format */ 1448 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area"); 1449 break; 1450 1451 case bfd_reloc_outofrange: 1452 /* xgettext:c-format */ 1453 msg = _("%B(%A): internal error: out of range error"); 1454 break; 1455 1456 case bfd_reloc_notsupported: 1457 /* xgettext:c-format */ 1458 msg = _("%B(%A): internal error: unsupported relocation error"); 1459 break; 1460 1461 case bfd_reloc_dangerous: 1462 /* xgettext:c-format */ 1463 msg = _("%B(%A): internal error: dangerous relocation"); 1464 break; 1465 1466 default: 1467 /* xgettext:c-format */ 1468 msg = _("%B(%A): internal error: unknown error"); 1469 break; 1470 } 1471 1472 if (msg) 1473 _bfd_error_handler (msg, input_bfd, input_section, name); 1474 } 1475 } 1476 1477 return TRUE; 1478} 1479 1480/* Relaxation Support. */ 1481 1482/* Progression of relocations from largest operand size to smallest 1483 operand size. */ 1484 1485static int 1486next_smaller_reloc (int r) 1487{ 1488 switch (r) 1489 { 1490 case R_RX_DIR32: return R_RX_DIR24S; 1491 case R_RX_DIR24S: return R_RX_DIR16S; 1492 case R_RX_DIR16S: return R_RX_DIR8S; 1493 case R_RX_DIR8S: return R_RX_NONE; 1494 1495 case R_RX_DIR16: return R_RX_DIR8; 1496 case R_RX_DIR8: return R_RX_NONE; 1497 1498 case R_RX_DIR16U: return R_RX_DIR8U; 1499 case R_RX_DIR8U: return R_RX_NONE; 1500 1501 case R_RX_DIR24S_PCREL: return R_RX_DIR16S_PCREL; 1502 case R_RX_DIR16S_PCREL: return R_RX_DIR8S_PCREL; 1503 case R_RX_DIR8S_PCREL: return R_RX_DIR3U_PCREL; 1504 1505 case R_RX_DIR16UL: return R_RX_DIR8UL; 1506 case R_RX_DIR8UL: return R_RX_NONE; 1507 case R_RX_DIR16UW: return R_RX_DIR8UW; 1508 case R_RX_DIR8UW: return R_RX_NONE; 1509 1510 case R_RX_RH_32_OP: return R_RX_RH_24_OP; 1511 case R_RX_RH_24_OP: return R_RX_RH_16_OP; 1512 case R_RX_RH_16_OP: return R_RX_DIR8; 1513 1514 case R_RX_ABS32: return R_RX_ABS24S; 1515 case R_RX_ABS24S: return R_RX_ABS16S; 1516 case R_RX_ABS16: return R_RX_ABS8; 1517 case R_RX_ABS16U: return R_RX_ABS8U; 1518 case R_RX_ABS16S: return R_RX_ABS8S; 1519 case R_RX_ABS8: return R_RX_NONE; 1520 case R_RX_ABS8U: return R_RX_NONE; 1521 case R_RX_ABS8S: return R_RX_NONE; 1522 case R_RX_ABS24S_PCREL: return R_RX_ABS16S_PCREL; 1523 case R_RX_ABS16S_PCREL: return R_RX_ABS8S_PCREL; 1524 case R_RX_ABS8S_PCREL: return R_RX_NONE; 1525 case R_RX_ABS16UL: return R_RX_ABS8UL; 1526 case R_RX_ABS16UW: return R_RX_ABS8UW; 1527 case R_RX_ABS8UL: return R_RX_NONE; 1528 case R_RX_ABS8UW: return R_RX_NONE; 1529 } 1530 return r; 1531}; 1532 1533/* Delete some bytes from a section while relaxing. */ 1534 1535static bfd_boolean 1536elf32_rx_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count, 1537 Elf_Internal_Rela *alignment_rel, int force_snip, 1538 Elf_Internal_Rela *irelstart) 1539{ 1540 Elf_Internal_Shdr * symtab_hdr; 1541 unsigned int sec_shndx; 1542 bfd_byte * contents; 1543 Elf_Internal_Rela * irel; 1544 Elf_Internal_Rela * irelend; 1545 Elf_Internal_Sym * isym; 1546 Elf_Internal_Sym * isymend; 1547 bfd_vma toaddr; 1548 unsigned int symcount; 1549 struct elf_link_hash_entry ** sym_hashes; 1550 struct elf_link_hash_entry ** end_hashes; 1551 1552 if (!alignment_rel) 1553 force_snip = 1; 1554 1555 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1556 1557 contents = elf_section_data (sec)->this_hdr.contents; 1558 1559 /* The deletion must stop at the next alignment boundary, if 1560 ALIGNMENT_REL is non-NULL. */ 1561 toaddr = sec->size; 1562 if (alignment_rel) 1563 toaddr = alignment_rel->r_offset; 1564 1565 BFD_ASSERT (toaddr > addr); 1566 1567 /* Actually delete the bytes. */ 1568 memmove (contents + addr, contents + addr + count, 1569 (size_t) (toaddr - addr - count)); 1570 1571 /* If we don't have an alignment marker to worry about, we can just 1572 shrink the section. Otherwise, we have to fill in the newly 1573 created gap with NOP insns (0x03). */ 1574 if (force_snip) 1575 sec->size -= count; 1576 else 1577 memset (contents + toaddr - count, 0x03, count); 1578 1579 irel = irelstart; 1580 BFD_ASSERT (irel != NULL || sec->reloc_count == 0); 1581 irelend = irel + sec->reloc_count; 1582 1583 /* Adjust all the relocs. */ 1584 for (; irel < irelend; irel++) 1585 { 1586 /* Get the new reloc address. */ 1587 if (irel->r_offset > addr 1588 && (irel->r_offset < toaddr 1589 || (force_snip && irel->r_offset == toaddr))) 1590 irel->r_offset -= count; 1591 1592 /* If we see an ALIGN marker at the end of the gap, we move it 1593 to the beginning of the gap, since marking these gaps is what 1594 they're for. */ 1595 if (irel->r_offset == toaddr 1596 && ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX 1597 && irel->r_addend & RX_RELAXA_ALIGN) 1598 irel->r_offset -= count; 1599 } 1600 1601 /* Adjust the local symbols defined in this section. */ 1602 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1603 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1604 isymend = isym + symtab_hdr->sh_info; 1605 1606 for (; isym < isymend; isym++) 1607 { 1608 /* If the symbol is in the range of memory we just moved, we 1609 have to adjust its value. */ 1610 if (isym->st_shndx == sec_shndx 1611 && isym->st_value > addr 1612 && isym->st_value < toaddr) 1613 isym->st_value -= count; 1614 1615 /* If the symbol *spans* the bytes we just deleted (i.e. it's 1616 *end* is in the moved bytes but it's *start* isn't), then we 1617 must adjust its size. */ 1618 if (isym->st_shndx == sec_shndx 1619 && isym->st_value < addr 1620 && isym->st_value + isym->st_size > addr 1621 && isym->st_value + isym->st_size < toaddr) 1622 isym->st_size -= count; 1623 } 1624 1625 /* Now adjust the global symbols defined in this section. */ 1626 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1627 - symtab_hdr->sh_info); 1628 sym_hashes = elf_sym_hashes (abfd); 1629 end_hashes = sym_hashes + symcount; 1630 1631 for (; sym_hashes < end_hashes; sym_hashes++) 1632 { 1633 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1634 1635 if ((sym_hash->root.type == bfd_link_hash_defined 1636 || sym_hash->root.type == bfd_link_hash_defweak) 1637 && sym_hash->root.u.def.section == sec) 1638 { 1639 /* As above, adjust the value if needed. */ 1640 if (sym_hash->root.u.def.value > addr 1641 && sym_hash->root.u.def.value < toaddr) 1642 sym_hash->root.u.def.value -= count; 1643 1644 /* As above, adjust the size if needed. */ 1645 if (sym_hash->root.u.def.value < addr 1646 && sym_hash->root.u.def.value + sym_hash->size > addr 1647 && sym_hash->root.u.def.value + sym_hash->size < toaddr) 1648 sym_hash->size -= count; 1649 } 1650 } 1651 1652 return TRUE; 1653} 1654 1655/* Used to sort relocs by address. If relocs have the same address, 1656 we maintain their relative order, except that R_RX_RH_RELAX 1657 alignment relocs must be the first reloc for any given address. */ 1658 1659static void 1660reloc_bubblesort (Elf_Internal_Rela * r, int count) 1661{ 1662 int i; 1663 bfd_boolean again; 1664 bfd_boolean swappit; 1665 1666 /* This is almost a classic bubblesort. It's the slowest sort, but 1667 we're taking advantage of the fact that the relocations are 1668 mostly in order already (the assembler emits them that way) and 1669 we need relocs with the same address to remain in the same 1670 relative order. */ 1671 again = TRUE; 1672 while (again) 1673 { 1674 again = FALSE; 1675 for (i = 0; i < count - 1; i ++) 1676 { 1677 if (r[i].r_offset > r[i + 1].r_offset) 1678 swappit = TRUE; 1679 else if (r[i].r_offset < r[i + 1].r_offset) 1680 swappit = FALSE; 1681 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX 1682 && (r[i + 1].r_addend & RX_RELAXA_ALIGN)) 1683 swappit = TRUE; 1684 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX 1685 && (r[i + 1].r_addend & RX_RELAXA_ELIGN) 1686 && !(ELF32_R_TYPE (r[i].r_info) == R_RX_RH_RELAX 1687 && (r[i].r_addend & RX_RELAXA_ALIGN))) 1688 swappit = TRUE; 1689 else 1690 swappit = FALSE; 1691 1692 if (swappit) 1693 { 1694 Elf_Internal_Rela tmp; 1695 1696 tmp = r[i]; 1697 r[i] = r[i + 1]; 1698 r[i + 1] = tmp; 1699 /* If we do move a reloc back, re-scan to see if it 1700 needs to be moved even further back. This avoids 1701 most of the O(n^2) behavior for our cases. */ 1702 if (i > 0) 1703 i -= 2; 1704 again = TRUE; 1705 } 1706 } 1707 } 1708} 1709 1710 1711#define OFFSET_FOR_RELOC(rel, lrel, scale) \ 1712 rx_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \ 1713 lrel, abfd, sec, link_info, scale) 1714 1715static bfd_vma 1716rx_offset_for_reloc (bfd * abfd, 1717 Elf_Internal_Rela * rel, 1718 Elf_Internal_Shdr * symtab_hdr, 1719 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED, 1720 Elf_Internal_Sym * intsyms, 1721 Elf_Internal_Rela ** lrel, 1722 bfd * input_bfd, 1723 asection * input_section, 1724 struct bfd_link_info * info, 1725 int * scale) 1726{ 1727 bfd_vma symval; 1728 bfd_reloc_status_type r; 1729 1730 *scale = 1; 1731 1732 /* REL is the first of 1..N relocations. We compute the symbol 1733 value for each relocation, then combine them if needed. LREL 1734 gets a pointer to the last relocation used. */ 1735 while (1) 1736 { 1737 int32_t tmp1, tmp2; 1738 1739 /* Get the value of the symbol referred to by the reloc. */ 1740 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info) 1741 { 1742 /* A local symbol. */ 1743 Elf_Internal_Sym *isym; 1744 asection *ssec; 1745 1746 isym = intsyms + ELF32_R_SYM (rel->r_info); 1747 1748 if (isym->st_shndx == SHN_UNDEF) 1749 ssec = bfd_und_section_ptr; 1750 else if (isym->st_shndx == SHN_ABS) 1751 ssec = bfd_abs_section_ptr; 1752 else if (isym->st_shndx == SHN_COMMON) 1753 ssec = bfd_com_section_ptr; 1754 else 1755 ssec = bfd_section_from_elf_index (abfd, 1756 isym->st_shndx); 1757 1758 /* Initial symbol value. */ 1759 symval = isym->st_value; 1760 1761 /* GAS may have made this symbol relative to a section, in 1762 which case, we have to add the addend to find the 1763 symbol. */ 1764 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 1765 symval += rel->r_addend; 1766 1767 if (ssec) 1768 { 1769 if ((ssec->flags & SEC_MERGE) 1770 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE) 1771 symval = _bfd_merged_section_offset (abfd, & ssec, 1772 elf_section_data (ssec)->sec_info, 1773 symval); 1774 } 1775 1776 /* Now make the offset relative to where the linker is putting it. */ 1777 if (ssec) 1778 symval += 1779 ssec->output_section->vma + ssec->output_offset; 1780 1781 symval += rel->r_addend; 1782 } 1783 else 1784 { 1785 unsigned long indx; 1786 struct elf_link_hash_entry * h; 1787 1788 /* An external symbol. */ 1789 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info; 1790 h = elf_sym_hashes (abfd)[indx]; 1791 BFD_ASSERT (h != NULL); 1792 1793 if (h->root.type != bfd_link_hash_defined 1794 && h->root.type != bfd_link_hash_defweak) 1795 { 1796 /* This appears to be a reference to an undefined 1797 symbol. Just ignore it--it will be caught by the 1798 regular reloc processing. */ 1799 if (lrel) 1800 *lrel = rel; 1801 return 0; 1802 } 1803 1804 symval = (h->root.u.def.value 1805 + h->root.u.def.section->output_section->vma 1806 + h->root.u.def.section->output_offset); 1807 1808 symval += rel->r_addend; 1809 } 1810 1811 switch (ELF32_R_TYPE (rel->r_info)) 1812 { 1813 case R_RX_SYM: 1814 RX_STACK_PUSH (symval); 1815 break; 1816 1817 case R_RX_OPneg: 1818 RX_STACK_POP (tmp1); 1819 tmp1 = - tmp1; 1820 RX_STACK_PUSH (tmp1); 1821 break; 1822 1823 case R_RX_OPadd: 1824 RX_STACK_POP (tmp1); 1825 RX_STACK_POP (tmp2); 1826 tmp1 += tmp2; 1827 RX_STACK_PUSH (tmp1); 1828 break; 1829 1830 case R_RX_OPsub: 1831 RX_STACK_POP (tmp1); 1832 RX_STACK_POP (tmp2); 1833 tmp2 -= tmp1; 1834 RX_STACK_PUSH (tmp2); 1835 break; 1836 1837 case R_RX_OPmul: 1838 RX_STACK_POP (tmp1); 1839 RX_STACK_POP (tmp2); 1840 tmp1 *= tmp2; 1841 RX_STACK_PUSH (tmp1); 1842 break; 1843 1844 case R_RX_OPdiv: 1845 RX_STACK_POP (tmp1); 1846 RX_STACK_POP (tmp2); 1847 tmp1 /= tmp2; 1848 RX_STACK_PUSH (tmp1); 1849 break; 1850 1851 case R_RX_OPshla: 1852 RX_STACK_POP (tmp1); 1853 RX_STACK_POP (tmp2); 1854 tmp1 <<= tmp2; 1855 RX_STACK_PUSH (tmp1); 1856 break; 1857 1858 case R_RX_OPshra: 1859 RX_STACK_POP (tmp1); 1860 RX_STACK_POP (tmp2); 1861 tmp1 >>= tmp2; 1862 RX_STACK_PUSH (tmp1); 1863 break; 1864 1865 case R_RX_OPsctsize: 1866 RX_STACK_PUSH (input_section->size); 1867 break; 1868 1869 case R_RX_OPscttop: 1870 RX_STACK_PUSH (input_section->output_section->vma); 1871 break; 1872 1873 case R_RX_OPand: 1874 RX_STACK_POP (tmp1); 1875 RX_STACK_POP (tmp2); 1876 tmp1 &= tmp2; 1877 RX_STACK_PUSH (tmp1); 1878 break; 1879 1880 case R_RX_OPor: 1881 RX_STACK_POP (tmp1); 1882 RX_STACK_POP (tmp2); 1883 tmp1 |= tmp2; 1884 RX_STACK_PUSH (tmp1); 1885 break; 1886 1887 case R_RX_OPxor: 1888 RX_STACK_POP (tmp1); 1889 RX_STACK_POP (tmp2); 1890 tmp1 ^= tmp2; 1891 RX_STACK_PUSH (tmp1); 1892 break; 1893 1894 case R_RX_OPnot: 1895 RX_STACK_POP (tmp1); 1896 tmp1 = ~ tmp1; 1897 RX_STACK_PUSH (tmp1); 1898 break; 1899 1900 case R_RX_OPmod: 1901 RX_STACK_POP (tmp1); 1902 RX_STACK_POP (tmp2); 1903 tmp1 %= tmp2; 1904 RX_STACK_PUSH (tmp1); 1905 break; 1906 1907 case R_RX_OPromtop: 1908 RX_STACK_PUSH (get_romstart (info, input_bfd, input_section, rel->r_offset)); 1909 break; 1910 1911 case R_RX_OPramtop: 1912 RX_STACK_PUSH (get_ramstart (info, input_bfd, input_section, rel->r_offset)); 1913 break; 1914 1915 case R_RX_DIR16UL: 1916 case R_RX_DIR8UL: 1917 case R_RX_ABS16UL: 1918 case R_RX_ABS8UL: 1919 if (rx_stack_top) 1920 RX_STACK_POP (symval); 1921 if (lrel) 1922 *lrel = rel; 1923 *scale = 4; 1924 return symval; 1925 1926 case R_RX_DIR16UW: 1927 case R_RX_DIR8UW: 1928 case R_RX_ABS16UW: 1929 case R_RX_ABS8UW: 1930 if (rx_stack_top) 1931 RX_STACK_POP (symval); 1932 if (lrel) 1933 *lrel = rel; 1934 *scale = 2; 1935 return symval; 1936 1937 default: 1938 if (rx_stack_top) 1939 RX_STACK_POP (symval); 1940 if (lrel) 1941 *lrel = rel; 1942 return symval; 1943 } 1944 1945 rel ++; 1946 } 1947 /* FIXME. */ 1948 (void) r; 1949} 1950 1951static void 1952move_reloc (Elf_Internal_Rela * irel, Elf_Internal_Rela * srel, int delta) 1953{ 1954 bfd_vma old_offset = srel->r_offset; 1955 1956 irel ++; 1957 while (irel <= srel) 1958 { 1959 if (irel->r_offset == old_offset) 1960 irel->r_offset += delta; 1961 irel ++; 1962 } 1963} 1964 1965/* Relax one section. */ 1966 1967static bfd_boolean 1968elf32_rx_relax_section (bfd * abfd, 1969 asection * sec, 1970 struct bfd_link_info * link_info, 1971 bfd_boolean * again, 1972 bfd_boolean allow_pcrel3) 1973{ 1974 Elf_Internal_Shdr * symtab_hdr; 1975 Elf_Internal_Shdr * shndx_hdr; 1976 Elf_Internal_Rela * internal_relocs; 1977 Elf_Internal_Rela * irel; 1978 Elf_Internal_Rela * srel; 1979 Elf_Internal_Rela * irelend; 1980 Elf_Internal_Rela * next_alignment; 1981 Elf_Internal_Rela * prev_alignment; 1982 bfd_byte * contents = NULL; 1983 bfd_byte * free_contents = NULL; 1984 Elf_Internal_Sym * intsyms = NULL; 1985 Elf_Internal_Sym * free_intsyms = NULL; 1986 Elf_External_Sym_Shndx * shndx_buf = NULL; 1987 bfd_vma pc; 1988 bfd_vma sec_start; 1989 bfd_vma symval = 0; 1990 int pcrel = 0; 1991 int code = 0; 1992 int section_alignment_glue; 1993 /* how much to scale the relocation by - 1, 2, or 4. */ 1994 int scale; 1995 1996 /* Assume nothing changes. */ 1997 *again = FALSE; 1998 1999 /* We don't have to do anything for a relocatable link, if 2000 this section does not have relocs, or if this is not a 2001 code section. */ 2002 if (bfd_link_relocatable (link_info) 2003 || (sec->flags & SEC_RELOC) == 0 2004 || sec->reloc_count == 0 2005 || (sec->flags & SEC_CODE) == 0) 2006 return TRUE; 2007 2008 symtab_hdr = & elf_symtab_hdr (abfd); 2009 if (elf_symtab_shndx_list (abfd)) 2010 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr; 2011 else 2012 shndx_hdr = NULL; 2013 2014 sec_start = sec->output_section->vma + sec->output_offset; 2015 2016 /* Get the section contents. */ 2017 if (elf_section_data (sec)->this_hdr.contents != NULL) 2018 contents = elf_section_data (sec)->this_hdr.contents; 2019 /* Go get them off disk. */ 2020 else 2021 { 2022 if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 2023 goto error_return; 2024 elf_section_data (sec)->this_hdr.contents = contents; 2025 } 2026 2027 /* Read this BFD's symbols. */ 2028 /* Get cached copy if it exists. */ 2029 if (symtab_hdr->contents != NULL) 2030 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 2031 else 2032 { 2033 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL); 2034 symtab_hdr->contents = (bfd_byte *) intsyms; 2035 } 2036 2037 if (shndx_hdr && shndx_hdr->sh_size != 0) 2038 { 2039 bfd_size_type amt; 2040 2041 amt = symtab_hdr->sh_info; 2042 amt *= sizeof (Elf_External_Sym_Shndx); 2043 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 2044 if (shndx_buf == NULL) 2045 goto error_return; 2046 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0 2047 || bfd_bread (shndx_buf, amt, abfd) != amt) 2048 goto error_return; 2049 shndx_hdr->contents = (bfd_byte *) shndx_buf; 2050 } 2051 2052 /* Get a copy of the native relocations. */ 2053 /* Note - we ignore the setting of link_info->keep_memory when reading 2054 in these relocs. We have to maintain a permanent copy of the relocs 2055 because we are going to walk over them multiple times, adjusting them 2056 as bytes are deleted from the section, and with this relaxation 2057 function itself being called multiple times on the same section... */ 2058 internal_relocs = _bfd_elf_link_read_relocs 2059 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, TRUE); 2060 if (internal_relocs == NULL) 2061 goto error_return; 2062 2063 /* The RL_ relocs must be just before the operand relocs they go 2064 with, so we must sort them to guarantee this. We use bubblesort 2065 instead of qsort so we can guarantee that relocs with the same 2066 address remain in the same relative order. */ 2067 reloc_bubblesort (internal_relocs, sec->reloc_count); 2068 2069 /* Walk through them looking for relaxing opportunities. */ 2070 irelend = internal_relocs + sec->reloc_count; 2071 2072 /* This will either be NULL or a pointer to the next alignment 2073 relocation. */ 2074 next_alignment = internal_relocs; 2075 /* This will be the previous alignment, although at first it points 2076 to the first real relocation. */ 2077 prev_alignment = internal_relocs; 2078 2079 /* We calculate worst case shrinkage caused by alignment directives. 2080 No fool-proof, but better than either ignoring the problem or 2081 doing heavy duty analysis of all the alignment markers in all 2082 input sections. */ 2083 section_alignment_glue = 0; 2084 for (irel = internal_relocs; irel < irelend; irel++) 2085 if (ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX 2086 && irel->r_addend & RX_RELAXA_ALIGN) 2087 { 2088 int this_glue = 1 << (irel->r_addend & RX_RELAXA_ANUM); 2089 2090 if (section_alignment_glue < this_glue) 2091 section_alignment_glue = this_glue; 2092 } 2093 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte 2094 shrinkage. */ 2095 section_alignment_glue *= 2; 2096 2097 for (irel = internal_relocs; irel < irelend; irel++) 2098 { 2099 unsigned char *insn; 2100 int nrelocs; 2101 2102 /* The insns we care about are all marked with one of these. */ 2103 if (ELF32_R_TYPE (irel->r_info) != R_RX_RH_RELAX) 2104 continue; 2105 2106 if (irel->r_addend & RX_RELAXA_ALIGN 2107 || next_alignment == internal_relocs) 2108 { 2109 /* When we delete bytes, we need to maintain all the alignments 2110 indicated. In addition, we need to be careful about relaxing 2111 jumps across alignment boundaries - these displacements 2112 *grow* when we delete bytes. For now, don't shrink 2113 displacements across an alignment boundary, just in case. 2114 Note that this only affects relocations to the same 2115 section. */ 2116 prev_alignment = next_alignment; 2117 next_alignment += 2; 2118 while (next_alignment < irelend 2119 && (ELF32_R_TYPE (next_alignment->r_info) != R_RX_RH_RELAX 2120 || !(next_alignment->r_addend & RX_RELAXA_ELIGN))) 2121 next_alignment ++; 2122 if (next_alignment >= irelend || next_alignment->r_offset == 0) 2123 next_alignment = NULL; 2124 } 2125 2126 /* When we hit alignment markers, see if we've shrunk enough 2127 before them to reduce the gap without violating the alignment 2128 requirements. */ 2129 if (irel->r_addend & RX_RELAXA_ALIGN) 2130 { 2131 /* At this point, the next relocation *should* be the ELIGN 2132 end marker. */ 2133 Elf_Internal_Rela *erel = irel + 1; 2134 unsigned int alignment, nbytes; 2135 2136 if (ELF32_R_TYPE (erel->r_info) != R_RX_RH_RELAX) 2137 continue; 2138 if (!(erel->r_addend & RX_RELAXA_ELIGN)) 2139 continue; 2140 2141 alignment = 1 << (irel->r_addend & RX_RELAXA_ANUM); 2142 2143 if (erel->r_offset - irel->r_offset < alignment) 2144 continue; 2145 2146 nbytes = erel->r_offset - irel->r_offset; 2147 nbytes /= alignment; 2148 nbytes *= alignment; 2149 2150 elf32_rx_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment, 2151 erel->r_offset == sec->size, internal_relocs); 2152 *again = TRUE; 2153 2154 continue; 2155 } 2156 2157 if (irel->r_addend & RX_RELAXA_ELIGN) 2158 continue; 2159 2160 insn = contents + irel->r_offset; 2161 2162 nrelocs = irel->r_addend & RX_RELAXA_RNUM; 2163 2164 /* At this point, we have an insn that is a candidate for linker 2165 relaxation. There are NRELOCS relocs following that may be 2166 relaxed, although each reloc may be made of more than one 2167 reloc entry (such as gp-rel symbols). */ 2168 2169 /* Get the value of the symbol referred to by the reloc. Just 2170 in case this is the last reloc in the list, use the RL's 2171 addend to choose between this reloc (no addend) or the next 2172 (yes addend, which means at least one following reloc). */ 2173 2174 /* srel points to the "current" reloction for this insn - 2175 actually the last reloc for a given operand, which is the one 2176 we need to update. We check the relaxations in the same 2177 order that the relocations happen, so we'll just push it 2178 along as we go. */ 2179 srel = irel; 2180 2181 pc = sec->output_section->vma + sec->output_offset 2182 + srel->r_offset; 2183 2184#define GET_RELOC \ 2185 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \ 2186 pcrel = symval - pc + srel->r_addend; \ 2187 nrelocs --; 2188 2189#define SNIPNR(offset, nbytes) \ 2190 elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0, internal_relocs); 2191#define SNIP(offset, nbytes, newtype) \ 2192 SNIPNR (offset, nbytes); \ 2193 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype) 2194 2195 /* The order of these bit tests must match the order that the 2196 relocs appear in. Since we sorted those by offset, we can 2197 predict them. */ 2198 2199 /* Note that the numbers in, say, DSP6 are the bit offsets of 2200 the code fields that describe the operand. Bits number 0 for 2201 the MSB of insn[0]. */ 2202 2203 /* DSP* codes: 2204 0 00 [reg] 2205 1 01 dsp:8[reg] 2206 2 10 dsp:16[reg] 2207 3 11 reg */ 2208 if (irel->r_addend & RX_RELAXA_DSP6) 2209 { 2210 GET_RELOC; 2211 2212 code = insn[0] & 3; 2213 if (code == 2 && symval/scale <= 255) 2214 { 2215 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2216 insn[0] &= 0xfc; 2217 insn[0] |= 0x01; 2218 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2219 if (newrel != ELF32_R_TYPE (srel->r_info)) 2220 { 2221 SNIP (3, 1, newrel); 2222 *again = TRUE; 2223 } 2224 } 2225 2226 else if (code == 1 && symval == 0) 2227 { 2228 insn[0] &= 0xfc; 2229 SNIP (2, 1, R_RX_NONE); 2230 *again = TRUE; 2231 } 2232 2233 /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst. */ 2234 else if (code == 1 && symval/scale <= 31 2235 /* Decodable bits. */ 2236 && (insn[0] & 0xcc) == 0xcc 2237 /* Width. */ 2238 && (insn[0] & 0x30) != 0x30 2239 /* Register MSBs. */ 2240 && (insn[1] & 0x88) == 0x00) 2241 { 2242 int newrel = 0; 2243 2244 insn[0] = 0x88 | (insn[0] & 0x30); 2245 /* The register fields are in the right place already. */ 2246 2247 /* We can't relax this new opcode. */ 2248 irel->r_addend = 0; 2249 2250 switch ((insn[0] & 0x30) >> 4) 2251 { 2252 case 0: 2253 newrel = R_RX_RH_ABS5p5B; 2254 break; 2255 case 1: 2256 newrel = R_RX_RH_ABS5p5W; 2257 break; 2258 case 2: 2259 newrel = R_RX_RH_ABS5p5L; 2260 break; 2261 } 2262 2263 move_reloc (irel, srel, -2); 2264 SNIP (2, 1, newrel); 2265 } 2266 2267 /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst. */ 2268 else if (code == 1 && symval/scale <= 31 2269 /* Decodable bits. */ 2270 && (insn[0] & 0xf8) == 0x58 2271 /* Register MSBs. */ 2272 && (insn[1] & 0x88) == 0x00) 2273 { 2274 int newrel = 0; 2275 2276 insn[0] = 0xb0 | ((insn[0] & 0x04) << 1); 2277 /* The register fields are in the right place already. */ 2278 2279 /* We can't relax this new opcode. */ 2280 irel->r_addend = 0; 2281 2282 switch ((insn[0] & 0x08) >> 3) 2283 { 2284 case 0: 2285 newrel = R_RX_RH_ABS5p5B; 2286 break; 2287 case 1: 2288 newrel = R_RX_RH_ABS5p5W; 2289 break; 2290 } 2291 2292 move_reloc (irel, srel, -2); 2293 SNIP (2, 1, newrel); 2294 } 2295 } 2296 2297 /* A DSP4 operand always follows a DSP6 operand, even if there's 2298 no relocation for it. We have to read the code out of the 2299 opcode to calculate the offset of the operand. */ 2300 if (irel->r_addend & RX_RELAXA_DSP4) 2301 { 2302 int code6, offset = 0; 2303 2304 GET_RELOC; 2305 2306 code6 = insn[0] & 0x03; 2307 switch (code6) 2308 { 2309 case 0: offset = 2; break; 2310 case 1: offset = 3; break; 2311 case 2: offset = 4; break; 2312 case 3: offset = 2; break; 2313 } 2314 2315 code = (insn[0] & 0x0c) >> 2; 2316 2317 if (code == 2 && symval / scale <= 255) 2318 { 2319 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2320 2321 insn[0] &= 0xf3; 2322 insn[0] |= 0x04; 2323 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2324 if (newrel != ELF32_R_TYPE (srel->r_info)) 2325 { 2326 SNIP (offset+1, 1, newrel); 2327 *again = TRUE; 2328 } 2329 } 2330 2331 else if (code == 1 && symval == 0) 2332 { 2333 insn[0] &= 0xf3; 2334 SNIP (offset, 1, R_RX_NONE); 2335 *again = TRUE; 2336 } 2337 /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */ 2338 else if (code == 1 && symval/scale <= 31 2339 /* Decodable bits. */ 2340 && (insn[0] & 0xc3) == 0xc3 2341 /* Width. */ 2342 && (insn[0] & 0x30) != 0x30 2343 /* Register MSBs. */ 2344 && (insn[1] & 0x88) == 0x00) 2345 { 2346 int newrel = 0; 2347 2348 insn[0] = 0x80 | (insn[0] & 0x30); 2349 /* The register fields are in the right place already. */ 2350 2351 /* We can't relax this new opcode. */ 2352 irel->r_addend = 0; 2353 2354 switch ((insn[0] & 0x30) >> 4) 2355 { 2356 case 0: 2357 newrel = R_RX_RH_ABS5p5B; 2358 break; 2359 case 1: 2360 newrel = R_RX_RH_ABS5p5W; 2361 break; 2362 case 2: 2363 newrel = R_RX_RH_ABS5p5L; 2364 break; 2365 } 2366 2367 move_reloc (irel, srel, -2); 2368 SNIP (2, 1, newrel); 2369 } 2370 } 2371 2372 /* These always occur alone, but the offset depends on whether 2373 it's a MEMEX opcode (0x06) or not. */ 2374 if (irel->r_addend & RX_RELAXA_DSP14) 2375 { 2376 int offset; 2377 GET_RELOC; 2378 2379 if (insn[0] == 0x06) 2380 offset = 3; 2381 else 2382 offset = 4; 2383 2384 code = insn[1] & 3; 2385 2386 if (code == 2 && symval / scale <= 255) 2387 { 2388 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2389 2390 insn[1] &= 0xfc; 2391 insn[1] |= 0x01; 2392 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2393 if (newrel != ELF32_R_TYPE (srel->r_info)) 2394 { 2395 SNIP (offset, 1, newrel); 2396 *again = TRUE; 2397 } 2398 } 2399 else if (code == 1 && symval == 0) 2400 { 2401 insn[1] &= 0xfc; 2402 SNIP (offset, 1, R_RX_NONE); 2403 *again = TRUE; 2404 } 2405 } 2406 2407 /* IMM* codes: 2408 0 00 imm:32 2409 1 01 simm:8 2410 2 10 simm:16 2411 3 11 simm:24. */ 2412 2413 /* These always occur alone. */ 2414 if (irel->r_addend & RX_RELAXA_IMM6) 2415 { 2416 long ssymval; 2417 2418 GET_RELOC; 2419 2420 /* These relocations sign-extend, so we must do signed compares. */ 2421 ssymval = (long) symval; 2422 2423 code = insn[0] & 0x03; 2424 2425 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608) 2426 { 2427 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2428 2429 insn[0] &= 0xfc; 2430 insn[0] |= 0x03; 2431 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2432 if (newrel != ELF32_R_TYPE (srel->r_info)) 2433 { 2434 SNIP (2, 1, newrel); 2435 *again = TRUE; 2436 } 2437 } 2438 2439 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768) 2440 { 2441 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2442 2443 insn[0] &= 0xfc; 2444 insn[0] |= 0x02; 2445 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2446 if (newrel != ELF32_R_TYPE (srel->r_info)) 2447 { 2448 SNIP (2, 1, newrel); 2449 *again = TRUE; 2450 } 2451 } 2452 2453 /* Special case UIMM8 format: CMP #uimm8,Rdst. */ 2454 else if (code == 2 && ssymval <= 255 && ssymval >= 16 2455 /* Decodable bits. */ 2456 && (insn[0] & 0xfc) == 0x74 2457 /* Decodable bits. */ 2458 && ((insn[1] & 0xf0) == 0x00)) 2459 { 2460 int newrel; 2461 2462 insn[0] = 0x75; 2463 insn[1] = 0x50 | (insn[1] & 0x0f); 2464 2465 /* We can't relax this new opcode. */ 2466 irel->r_addend = 0; 2467 2468 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info))) 2469 newrel = R_RX_ABS8U; 2470 else 2471 newrel = R_RX_DIR8U; 2472 2473 SNIP (2, 1, newrel); 2474 *again = TRUE; 2475 } 2476 2477 else if (code == 2 && ssymval <= 127 && ssymval >= -128) 2478 { 2479 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2480 2481 insn[0] &= 0xfc; 2482 insn[0] |= 0x01; 2483 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2484 if (newrel != ELF32_R_TYPE (srel->r_info)) 2485 { 2486 SNIP (2, 1, newrel); 2487 *again = TRUE; 2488 } 2489 } 2490 2491 /* Special case UIMM4 format: CMP, MUL, AND, OR. */ 2492 else if (code == 1 && ssymval <= 15 && ssymval >= 0 2493 /* Decodable bits and immediate type. */ 2494 && insn[0] == 0x75 2495 /* Decodable bits. */ 2496 && (insn[1] & 0xc0) == 0x00) 2497 { 2498 static const int newop[4] = { 1, 3, 4, 5 }; 2499 2500 insn[0] = 0x60 | newop[insn[1] >> 4]; 2501 /* The register number doesn't move. */ 2502 2503 /* We can't relax this new opcode. */ 2504 irel->r_addend = 0; 2505 2506 move_reloc (irel, srel, -1); 2507 2508 SNIP (2, 1, R_RX_RH_UIMM4p8); 2509 *again = TRUE; 2510 } 2511 2512 /* Special case UIMM4 format: ADD -> ADD/SUB. */ 2513 else if (code == 1 && ssymval <= 15 && ssymval >= -15 2514 /* Decodable bits and immediate type. */ 2515 && insn[0] == 0x71 2516 /* Same register for source and destination. */ 2517 && ((insn[1] >> 4) == (insn[1] & 0x0f))) 2518 { 2519 int newrel; 2520 2521 /* Note that we can't turn "add $0,Rs" into a NOP 2522 because the flags need to be set right. */ 2523 2524 if (ssymval < 0) 2525 { 2526 insn[0] = 0x60; /* Subtract. */ 2527 newrel = R_RX_RH_UNEG4p8; 2528 } 2529 else 2530 { 2531 insn[0] = 0x62; /* Add. */ 2532 newrel = R_RX_RH_UIMM4p8; 2533 } 2534 2535 /* The register number is in the right place. */ 2536 2537 /* We can't relax this new opcode. */ 2538 irel->r_addend = 0; 2539 2540 move_reloc (irel, srel, -1); 2541 2542 SNIP (2, 1, newrel); 2543 *again = TRUE; 2544 } 2545 } 2546 2547 /* These are either matched with a DSP6 (2-byte base) or an id24 2548 (3-byte base). */ 2549 if (irel->r_addend & RX_RELAXA_IMM12) 2550 { 2551 int dspcode, offset = 0; 2552 long ssymval; 2553 2554 GET_RELOC; 2555 2556 if ((insn[0] & 0xfc) == 0xfc) 2557 dspcode = 1; /* Just something with one byte operand. */ 2558 else 2559 dspcode = insn[0] & 3; 2560 switch (dspcode) 2561 { 2562 case 0: offset = 2; break; 2563 case 1: offset = 3; break; 2564 case 2: offset = 4; break; 2565 case 3: offset = 2; break; 2566 } 2567 2568 /* These relocations sign-extend, so we must do signed compares. */ 2569 ssymval = (long) symval; 2570 2571 code = (insn[1] >> 2) & 3; 2572 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608) 2573 { 2574 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2575 2576 insn[1] &= 0xf3; 2577 insn[1] |= 0x0c; 2578 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2579 if (newrel != ELF32_R_TYPE (srel->r_info)) 2580 { 2581 SNIP (offset, 1, newrel); 2582 *again = TRUE; 2583 } 2584 } 2585 2586 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768) 2587 { 2588 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2589 2590 insn[1] &= 0xf3; 2591 insn[1] |= 0x08; 2592 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2593 if (newrel != ELF32_R_TYPE (srel->r_info)) 2594 { 2595 SNIP (offset, 1, newrel); 2596 *again = TRUE; 2597 } 2598 } 2599 2600 /* Special case UIMM8 format: MOV #uimm8,Rdst. */ 2601 else if (code == 2 && ssymval <= 255 && ssymval >= 16 2602 /* Decodable bits. */ 2603 && insn[0] == 0xfb 2604 /* Decodable bits. */ 2605 && ((insn[1] & 0x03) == 0x02)) 2606 { 2607 int newrel; 2608 2609 insn[0] = 0x75; 2610 insn[1] = 0x40 | (insn[1] >> 4); 2611 2612 /* We can't relax this new opcode. */ 2613 irel->r_addend = 0; 2614 2615 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info))) 2616 newrel = R_RX_ABS8U; 2617 else 2618 newrel = R_RX_DIR8U; 2619 2620 SNIP (2, 1, newrel); 2621 *again = TRUE; 2622 } 2623 2624 else if (code == 2 && ssymval <= 127 && ssymval >= -128) 2625 { 2626 unsigned int newrel = ELF32_R_TYPE(srel->r_info); 2627 2628 insn[1] &= 0xf3; 2629 insn[1] |= 0x04; 2630 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2631 if (newrel != ELF32_R_TYPE(srel->r_info)) 2632 { 2633 SNIP (offset, 1, newrel); 2634 *again = TRUE; 2635 } 2636 } 2637 2638 /* Special case UIMM4 format: MOV #uimm4,Rdst. */ 2639 else if (code == 1 && ssymval <= 15 && ssymval >= 0 2640 /* Decodable bits. */ 2641 && insn[0] == 0xfb 2642 /* Decodable bits. */ 2643 && ((insn[1] & 0x03) == 0x02)) 2644 { 2645 insn[0] = 0x66; 2646 insn[1] = insn[1] >> 4; 2647 2648 /* We can't relax this new opcode. */ 2649 irel->r_addend = 0; 2650 2651 move_reloc (irel, srel, -1); 2652 2653 SNIP (2, 1, R_RX_RH_UIMM4p8); 2654 *again = TRUE; 2655 } 2656 } 2657 2658 if (irel->r_addend & RX_RELAXA_BRA) 2659 { 2660 unsigned int newrel = ELF32_R_TYPE (srel->r_info); 2661 int max_pcrel3 = 4; 2662 int alignment_glue = 0; 2663 2664 GET_RELOC; 2665 2666 /* Branches over alignment chunks are problematic, as 2667 deleting bytes here makes the branch *further* away. We 2668 can be agressive with branches within this alignment 2669 block, but not branches outside it. */ 2670 if ((prev_alignment == NULL 2671 || symval < (bfd_vma)(sec_start + prev_alignment->r_offset)) 2672 && (next_alignment == NULL 2673 || symval > (bfd_vma)(sec_start + next_alignment->r_offset))) 2674 alignment_glue = section_alignment_glue; 2675 2676 if (ELF32_R_TYPE(srel[1].r_info) == R_RX_RH_RELAX 2677 && srel[1].r_addend & RX_RELAXA_BRA 2678 && srel[1].r_offset < irel->r_offset + pcrel) 2679 max_pcrel3 ++; 2680 2681 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info)); 2682 2683 /* The values we compare PCREL with are not what you'd 2684 expect; they're off by a little to compensate for (1) 2685 where the reloc is relative to the insn, and (2) how much 2686 the insn is going to change when we relax it. */ 2687 2688 /* These we have to decode. */ 2689 switch (insn[0]) 2690 { 2691 case 0x04: /* BRA pcdsp:24 */ 2692 if (-32768 + alignment_glue <= pcrel 2693 && pcrel <= 32765 - alignment_glue) 2694 { 2695 insn[0] = 0x38; 2696 SNIP (3, 1, newrel); 2697 *again = TRUE; 2698 } 2699 break; 2700 2701 case 0x38: /* BRA pcdsp:16 */ 2702 if (-128 + alignment_glue <= pcrel 2703 && pcrel <= 127 - alignment_glue) 2704 { 2705 insn[0] = 0x2e; 2706 SNIP (2, 1, newrel); 2707 *again = TRUE; 2708 } 2709 break; 2710 2711 case 0x2e: /* BRA pcdsp:8 */ 2712 /* Note that there's a risk here of shortening things so 2713 much that we no longer fit this reloc; it *should* 2714 only happen when you branch across a branch, and that 2715 branch also devolves into BRA.S. "Real" code should 2716 be OK. */ 2717 if (max_pcrel3 + alignment_glue <= pcrel 2718 && pcrel <= 10 - alignment_glue 2719 && allow_pcrel3) 2720 { 2721 insn[0] = 0x08; 2722 SNIP (1, 1, newrel); 2723 move_reloc (irel, srel, -1); 2724 *again = TRUE; 2725 } 2726 break; 2727 2728 case 0x05: /* BSR pcdsp:24 */ 2729 if (-32768 + alignment_glue <= pcrel 2730 && pcrel <= 32765 - alignment_glue) 2731 { 2732 insn[0] = 0x39; 2733 SNIP (1, 1, newrel); 2734 *again = TRUE; 2735 } 2736 break; 2737 2738 case 0x3a: /* BEQ.W pcdsp:16 */ 2739 case 0x3b: /* BNE.W pcdsp:16 */ 2740 if (-128 + alignment_glue <= pcrel 2741 && pcrel <= 127 - alignment_glue) 2742 { 2743 insn[0] = 0x20 | (insn[0] & 1); 2744 SNIP (1, 1, newrel); 2745 *again = TRUE; 2746 } 2747 break; 2748 2749 case 0x20: /* BEQ.B pcdsp:8 */ 2750 case 0x21: /* BNE.B pcdsp:8 */ 2751 if (max_pcrel3 + alignment_glue <= pcrel 2752 && pcrel - alignment_glue <= 10 2753 && allow_pcrel3) 2754 { 2755 insn[0] = 0x10 | ((insn[0] & 1) << 3); 2756 SNIP (1, 1, newrel); 2757 move_reloc (irel, srel, -1); 2758 *again = TRUE; 2759 } 2760 break; 2761 2762 case 0x16: /* synthetic BNE dsp24 */ 2763 case 0x1e: /* synthetic BEQ dsp24 */ 2764 if (-32767 + alignment_glue <= pcrel 2765 && pcrel <= 32766 - alignment_glue 2766 && insn[1] == 0x04) 2767 { 2768 if (insn[0] == 0x16) 2769 insn[0] = 0x3b; 2770 else 2771 insn[0] = 0x3a; 2772 /* We snip out the bytes at the end else the reloc 2773 will get moved too, and too much. */ 2774 SNIP (3, 2, newrel); 2775 move_reloc (irel, srel, -1); 2776 *again = TRUE; 2777 } 2778 break; 2779 } 2780 2781 /* Special case - synthetic conditional branches, pcrel24. 2782 Note that EQ and NE have been handled above. */ 2783 if ((insn[0] & 0xf0) == 0x20 2784 && insn[1] == 0x06 2785 && insn[2] == 0x04 2786 && srel->r_offset != irel->r_offset + 1 2787 && -32767 + alignment_glue <= pcrel 2788 && pcrel <= 32766 - alignment_glue) 2789 { 2790 insn[1] = 0x05; 2791 insn[2] = 0x38; 2792 SNIP (5, 1, newrel); 2793 *again = TRUE; 2794 } 2795 2796 /* Special case - synthetic conditional branches, pcrel16 */ 2797 if ((insn[0] & 0xf0) == 0x20 2798 && insn[1] == 0x05 2799 && insn[2] == 0x38 2800 && srel->r_offset != irel->r_offset + 1 2801 && -127 + alignment_glue <= pcrel 2802 && pcrel <= 126 - alignment_glue) 2803 { 2804 int cond = (insn[0] & 0x0f) ^ 0x01; 2805 2806 insn[0] = 0x20 | cond; 2807 /* By moving the reloc first, we avoid having 2808 delete_bytes move it also. */ 2809 move_reloc (irel, srel, -2); 2810 SNIP (2, 3, newrel); 2811 *again = TRUE; 2812 } 2813 } 2814 2815 BFD_ASSERT (nrelocs == 0); 2816 2817 /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can 2818 use MOV.bwl #uimm:8, dsp:5[r7] format. This is tricky 2819 because it may have one or two relocations. */ 2820 if ((insn[0] & 0xfc) == 0xf8 2821 && (insn[1] & 0x80) == 0x00 2822 && (insn[0] & 0x03) != 0x03) 2823 { 2824 int dcode, icode, reg, ioff, dscale, ilen; 2825 bfd_vma disp_val = 0; 2826 long imm_val = 0; 2827 Elf_Internal_Rela * disp_rel = 0; 2828 Elf_Internal_Rela * imm_rel = 0; 2829 2830 /* Reset this. */ 2831 srel = irel; 2832 2833 dcode = insn[0] & 0x03; 2834 icode = (insn[1] >> 2) & 0x03; 2835 reg = (insn[1] >> 4) & 0x0f; 2836 2837 ioff = dcode == 1 ? 3 : dcode == 2 ? 4 : 2; 2838 2839 /* Figure out what the dispacement is. */ 2840 if (dcode == 1 || dcode == 2) 2841 { 2842 /* There's a displacement. See if there's a reloc for it. */ 2843 if (srel[1].r_offset == irel->r_offset + 2) 2844 { 2845 GET_RELOC; 2846 disp_val = symval; 2847 disp_rel = srel; 2848 } 2849 else 2850 { 2851 if (dcode == 1) 2852 disp_val = insn[2]; 2853 else 2854 { 2855#if RX_OPCODE_BIG_ENDIAN 2856 disp_val = insn[2] * 256 + insn[3]; 2857#else 2858 disp_val = insn[2] + insn[3] * 256; 2859#endif 2860 } 2861 switch (insn[1] & 3) 2862 { 2863 case 1: 2864 disp_val *= 2; 2865 scale = 2; 2866 break; 2867 case 2: 2868 disp_val *= 4; 2869 scale = 4; 2870 break; 2871 } 2872 } 2873 } 2874 2875 dscale = scale; 2876 2877 /* Figure out what the immediate is. */ 2878 if (srel[1].r_offset == irel->r_offset + ioff) 2879 { 2880 GET_RELOC; 2881 imm_val = (long) symval; 2882 imm_rel = srel; 2883 } 2884 else 2885 { 2886 unsigned char * ip = insn + ioff; 2887 2888 switch (icode) 2889 { 2890 case 1: 2891 /* For byte writes, we don't sign extend. Makes the math easier later. */ 2892 if (scale == 1) 2893 imm_val = ip[0]; 2894 else 2895 imm_val = (char) ip[0]; 2896 break; 2897 case 2: 2898#if RX_OPCODE_BIG_ENDIAN 2899 imm_val = ((char) ip[0] << 8) | ip[1]; 2900#else 2901 imm_val = ((char) ip[1] << 8) | ip[0]; 2902#endif 2903 break; 2904 case 3: 2905#if RX_OPCODE_BIG_ENDIAN 2906 imm_val = ((char) ip[0] << 16) | (ip[1] << 8) | ip[2]; 2907#else 2908 imm_val = ((char) ip[2] << 16) | (ip[1] << 8) | ip[0]; 2909#endif 2910 break; 2911 case 0: 2912#if RX_OPCODE_BIG_ENDIAN 2913 imm_val = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3]; 2914#else 2915 imm_val = (ip[3] << 24) | (ip[2] << 16) | (ip[1] << 8) | ip[0]; 2916#endif 2917 break; 2918 } 2919 } 2920 2921 ilen = 2; 2922 2923 switch (dcode) 2924 { 2925 case 1: 2926 ilen += 1; 2927 break; 2928 case 2: 2929 ilen += 2; 2930 break; 2931 } 2932 2933 switch (icode) 2934 { 2935 case 1: 2936 ilen += 1; 2937 break; 2938 case 2: 2939 ilen += 2; 2940 break; 2941 case 3: 2942 ilen += 3; 2943 break; 2944 case 4: 2945 ilen += 4; 2946 break; 2947 } 2948 2949 /* The shortcut happens when the immediate is 0..255, 2950 register r0 to r7, and displacement (scaled) 0..31. */ 2951 2952 if (0 <= imm_val && imm_val <= 255 2953 && 0 <= reg && reg <= 7 2954 && disp_val / dscale <= 31) 2955 { 2956 insn[0] = 0x3c | (insn[1] & 0x03); 2957 insn[1] = (((disp_val / dscale) << 3) & 0x80) | (reg << 4) | ((disp_val/dscale) & 0x0f); 2958 insn[2] = imm_val; 2959 2960 if (disp_rel) 2961 { 2962 int newrel = R_RX_NONE; 2963 2964 switch (dscale) 2965 { 2966 case 1: 2967 newrel = R_RX_RH_ABS5p8B; 2968 break; 2969 case 2: 2970 newrel = R_RX_RH_ABS5p8W; 2971 break; 2972 case 4: 2973 newrel = R_RX_RH_ABS5p8L; 2974 break; 2975 } 2976 disp_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (disp_rel->r_info), newrel); 2977 move_reloc (irel, disp_rel, -1); 2978 } 2979 if (imm_rel) 2980 { 2981 imm_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (imm_rel->r_info), R_RX_DIR8U); 2982 move_reloc (disp_rel ? disp_rel : irel, 2983 imm_rel, 2984 irel->r_offset - imm_rel->r_offset + 2); 2985 } 2986 2987 SNIPNR (3, ilen - 3); 2988 *again = TRUE; 2989 2990 /* We can't relax this new opcode. */ 2991 irel->r_addend = 0; 2992 } 2993 } 2994 } 2995 2996 /* We can't reliably relax branches to DIR3U_PCREL unless we know 2997 whatever they're branching over won't shrink any more. If we're 2998 basically done here, do one more pass just for branches - but 2999 don't request a pass after that one! */ 3000 if (!*again && !allow_pcrel3) 3001 { 3002 bfd_boolean ignored; 3003 3004 elf32_rx_relax_section (abfd, sec, link_info, &ignored, TRUE); 3005 } 3006 3007 return TRUE; 3008 3009 error_return: 3010 if (free_contents != NULL) 3011 free (free_contents); 3012 3013 if (shndx_buf != NULL) 3014 { 3015 shndx_hdr->contents = NULL; 3016 free (shndx_buf); 3017 } 3018 3019 if (free_intsyms != NULL) 3020 free (free_intsyms); 3021 3022 return FALSE; 3023} 3024 3025static bfd_boolean 3026elf32_rx_relax_section_wrapper (bfd * abfd, 3027 asection * sec, 3028 struct bfd_link_info * link_info, 3029 bfd_boolean * again) 3030{ 3031 return elf32_rx_relax_section (abfd, sec, link_info, again, FALSE); 3032} 3033 3034/* Function to set the ELF flag bits. */ 3035 3036static bfd_boolean 3037rx_elf_set_private_flags (bfd * abfd, flagword flags) 3038{ 3039 elf_elfheader (abfd)->e_flags = flags; 3040 elf_flags_init (abfd) = TRUE; 3041 return TRUE; 3042} 3043 3044static bfd_boolean no_warn_mismatch = FALSE; 3045static bfd_boolean ignore_lma = TRUE; 3046 3047void bfd_elf32_rx_set_target_flags (bfd_boolean, bfd_boolean); 3048 3049void 3050bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch, 3051 bfd_boolean user_ignore_lma) 3052{ 3053 no_warn_mismatch = user_no_warn_mismatch; 3054 ignore_lma = user_ignore_lma; 3055} 3056 3057/* Converts FLAGS into a descriptive string. 3058 Returns a static pointer. */ 3059 3060static const char * 3061describe_flags (flagword flags) 3062{ 3063 static char buf [128]; 3064 3065 buf[0] = 0; 3066 3067 if (flags & E_FLAG_RX_64BIT_DOUBLES) 3068 strcat (buf, "64-bit doubles"); 3069 else 3070 strcat (buf, "32-bit doubles"); 3071 3072 if (flags & E_FLAG_RX_DSP) 3073 strcat (buf, ", dsp"); 3074 else 3075 strcat (buf, ", no dsp"); 3076 3077 if (flags & E_FLAG_RX_PID) 3078 strcat (buf, ", pid"); 3079 else 3080 strcat (buf, ", no pid"); 3081 3082 if (flags & E_FLAG_RX_ABI) 3083 strcat (buf, ", RX ABI"); 3084 else 3085 strcat (buf, ", GCC ABI"); 3086 3087 if (flags & E_FLAG_RX_SINSNS_SET) 3088 strcat (buf, flags & E_FLAG_RX_SINSNS_YES ? ", uses String instructions" : ", bans String instructions"); 3089 3090 return buf; 3091} 3092 3093/* Merge backend specific data from an object file to the output 3094 object file when linking. */ 3095 3096static bfd_boolean 3097rx_elf_merge_private_bfd_data (bfd * ibfd, struct bfd_link_info *info) 3098{ 3099 bfd *obfd = info->output_bfd; 3100 flagword old_flags; 3101 flagword new_flags; 3102 bfd_boolean error = FALSE; 3103 3104 new_flags = elf_elfheader (ibfd)->e_flags; 3105 old_flags = elf_elfheader (obfd)->e_flags; 3106 3107 if (!elf_flags_init (obfd)) 3108 { 3109 /* First call, no flags set. */ 3110 elf_flags_init (obfd) = TRUE; 3111 elf_elfheader (obfd)->e_flags = new_flags; 3112 } 3113 else if (old_flags != new_flags) 3114 { 3115 flagword known_flags; 3116 3117 if (old_flags & E_FLAG_RX_SINSNS_SET) 3118 { 3119 if ((new_flags & E_FLAG_RX_SINSNS_SET) == 0) 3120 { 3121 new_flags &= ~ E_FLAG_RX_SINSNS_MASK; 3122 new_flags |= (old_flags & E_FLAG_RX_SINSNS_MASK); 3123 } 3124 } 3125 else if (new_flags & E_FLAG_RX_SINSNS_SET) 3126 { 3127 old_flags &= ~ E_FLAG_RX_SINSNS_MASK; 3128 old_flags |= (new_flags & E_FLAG_RX_SINSNS_MASK); 3129 } 3130 3131 known_flags = E_FLAG_RX_ABI | E_FLAG_RX_64BIT_DOUBLES 3132 | E_FLAG_RX_DSP | E_FLAG_RX_PID | E_FLAG_RX_SINSNS_MASK; 3133 3134 if ((old_flags ^ new_flags) & known_flags) 3135 { 3136 /* Only complain if flag bits we care about do not match. 3137 Other bits may be set, since older binaries did use some 3138 deprecated flags. */ 3139 if (no_warn_mismatch) 3140 { 3141 elf_elfheader (obfd)->e_flags = (new_flags | old_flags) & known_flags; 3142 } 3143 else 3144 { 3145 _bfd_error_handler (_("There is a conflict merging the ELF header flags from %s"), 3146 bfd_get_filename (ibfd)); 3147 _bfd_error_handler (_(" the input file's flags: %s"), 3148 describe_flags (new_flags)); 3149 _bfd_error_handler (_(" the output file's flags: %s"), 3150 describe_flags (old_flags)); 3151 error = TRUE; 3152 } 3153 } 3154 else 3155 elf_elfheader (obfd)->e_flags = new_flags & known_flags; 3156 } 3157 3158 if (error) 3159 bfd_set_error (bfd_error_bad_value); 3160 3161 return !error; 3162} 3163 3164static bfd_boolean 3165rx_elf_print_private_bfd_data (bfd * abfd, void * ptr) 3166{ 3167 FILE * file = (FILE *) ptr; 3168 flagword flags; 3169 3170 BFD_ASSERT (abfd != NULL && ptr != NULL); 3171 3172 /* Print normal ELF private data. */ 3173 _bfd_elf_print_private_bfd_data (abfd, ptr); 3174 3175 flags = elf_elfheader (abfd)->e_flags; 3176 fprintf (file, _("private flags = 0x%lx:"), (long) flags); 3177 3178 fprintf (file, "%s", describe_flags (flags)); 3179 return TRUE; 3180} 3181 3182/* Return the MACH for an e_flags value. */ 3183 3184static int 3185elf32_rx_machine (bfd * abfd ATTRIBUTE_UNUSED) 3186{ 3187#if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_... 3188 Need to sort out how these flag bits are used. 3189 For now we assume that the flags are OK. */ 3190 if ((elf_elfheader (abfd)->e_flags & EF_RX_CPU_MASK) == EF_RX_CPU_RX) 3191#endif 3192 return bfd_mach_rx; 3193 3194 return 0; 3195} 3196 3197static bfd_boolean 3198rx_elf_object_p (bfd * abfd) 3199{ 3200 int i; 3201 unsigned int u; 3202 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr; 3203 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd); 3204 int nphdrs = ehdr->e_phnum; 3205 sec_ptr bsec; 3206 static int saw_be = FALSE; 3207 bfd_vma end_phdroff; 3208 3209 /* We never want to automatically choose the non-swapping big-endian 3210 target. The user can only get that explicitly, such as with -I 3211 and objcopy. */ 3212 if (abfd->xvec == &rx_elf32_be_ns_vec 3213 && abfd->target_defaulted) 3214 return FALSE; 3215 3216 /* BFD->target_defaulted is not set to TRUE when a target is chosen 3217 as a fallback, so we check for "scanning" to know when to stop 3218 using the non-swapping target. */ 3219 if (abfd->xvec == &rx_elf32_be_ns_vec 3220 && saw_be) 3221 return FALSE; 3222 if (abfd->xvec == &rx_elf32_be_vec) 3223 saw_be = TRUE; 3224 3225 bfd_default_set_arch_mach (abfd, bfd_arch_rx, 3226 elf32_rx_machine (abfd)); 3227 3228 /* For each PHDR in the object, we must find some section that 3229 corresponds (based on matching file offsets) and use its VMA 3230 information to reconstruct the p_vaddr field we clobbered when we 3231 wrote it out. */ 3232 /* If PT_LOAD headers include the ELF file header or program headers 3233 then the PT_LOAD header does not start with some section contents. 3234 Making adjustments based on the difference between sh_offset and 3235 p_offset is nonsense in such cases. Exclude them. Note that 3236 since standard linker scripts for RX do not use SIZEOF_HEADERS, 3237 the linker won't normally create PT_LOAD segments covering the 3238 headers so this is mainly for passing the ld testsuite. 3239 FIXME. Why are we looking at non-PT_LOAD headers here? */ 3240 end_phdroff = ehdr->e_ehsize; 3241 if (ehdr->e_phoff != 0) 3242 end_phdroff = ehdr->e_phoff + nphdrs * ehdr->e_phentsize; 3243 for (i=0; i<nphdrs; i++) 3244 { 3245 for (u=0; u<elf_tdata(abfd)->num_elf_sections; u++) 3246 { 3247 Elf_Internal_Shdr *sec = elf_tdata(abfd)->elf_sect_ptr[u]; 3248 3249 if (phdr[i].p_filesz 3250 && phdr[i].p_offset >= end_phdroff 3251 && phdr[i].p_offset <= (bfd_vma) sec->sh_offset 3252 && sec->sh_size > 0 3253 && sec->sh_type != SHT_NOBITS 3254 && (bfd_vma)sec->sh_offset <= phdr[i].p_offset + (phdr[i].p_filesz - 1)) 3255 { 3256 /* Found one! The difference between the two addresses, 3257 plus the difference between the two file offsets, is 3258 enough information to reconstruct the lma. */ 3259 3260 /* Example where they aren't: 3261 PHDR[1] = lma fffc0100 offset 00002010 size 00000100 3262 SEC[6] = vma 00000050 offset 00002050 size 00000040 3263 3264 The correct LMA for the section is fffc0140 + (2050-2010). 3265 */ 3266 3267 phdr[i].p_vaddr = sec->sh_addr + (sec->sh_offset - phdr[i].p_offset); 3268 break; 3269 } 3270 } 3271 3272 /* We must update the bfd sections as well, so we don't stop 3273 with one match. */ 3274 bsec = abfd->sections; 3275 while (bsec) 3276 { 3277 if (phdr[i].p_filesz 3278 && phdr[i].p_vaddr <= bsec->vma 3279 && bsec->vma <= phdr[i].p_vaddr + (phdr[i].p_filesz - 1)) 3280 { 3281 bsec->lma = phdr[i].p_paddr + (bsec->vma - phdr[i].p_vaddr); 3282 } 3283 bsec = bsec->next; 3284 } 3285 } 3286 3287 return TRUE; 3288} 3289 3290 3291#ifdef DEBUG 3292void 3293rx_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms) 3294{ 3295 size_t locsymcount; 3296 Elf_Internal_Sym * isymbuf; 3297 Elf_Internal_Sym * isymend; 3298 Elf_Internal_Sym * isym; 3299 Elf_Internal_Shdr * symtab_hdr; 3300 bfd_boolean free_internal = FALSE, free_external = FALSE; 3301 char * st_info_str; 3302 char * st_info_stb_str; 3303 char * st_other_str; 3304 char * st_shndx_str; 3305 3306 if (! internal_syms) 3307 { 3308 internal_syms = bfd_malloc (1000); 3309 free_internal = 1; 3310 } 3311 if (! external_syms) 3312 { 3313 external_syms = bfd_malloc (1000); 3314 free_external = 1; 3315 } 3316 3317 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3318 locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3319 if (free_internal) 3320 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 3321 symtab_hdr->sh_info, 0, 3322 internal_syms, external_syms, NULL); 3323 else 3324 isymbuf = internal_syms; 3325 isymend = isymbuf + locsymcount; 3326 3327 for (isym = isymbuf ; isym < isymend ; isym++) 3328 { 3329 switch (ELF_ST_TYPE (isym->st_info)) 3330 { 3331 case STT_FUNC: st_info_str = "STT_FUNC"; break; 3332 case STT_SECTION: st_info_str = "STT_SECTION"; break; 3333 case STT_FILE: st_info_str = "STT_FILE"; break; 3334 case STT_OBJECT: st_info_str = "STT_OBJECT"; break; 3335 case STT_TLS: st_info_str = "STT_TLS"; break; 3336 default: st_info_str = ""; 3337 } 3338 switch (ELF_ST_BIND (isym->st_info)) 3339 { 3340 case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; break; 3341 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; break; 3342 default: st_info_stb_str = ""; 3343 } 3344 switch (ELF_ST_VISIBILITY (isym->st_other)) 3345 { 3346 case STV_DEFAULT: st_other_str = "STV_DEFAULT"; break; 3347 case STV_INTERNAL: st_other_str = "STV_INTERNAL"; break; 3348 case STV_PROTECTED: st_other_str = "STV_PROTECTED"; break; 3349 default: st_other_str = ""; 3350 } 3351 switch (isym->st_shndx) 3352 { 3353 case SHN_ABS: st_shndx_str = "SHN_ABS"; break; 3354 case SHN_COMMON: st_shndx_str = "SHN_COMMON"; break; 3355 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; break; 3356 default: st_shndx_str = ""; 3357 } 3358 3359 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s " 3360 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n", 3361 isym, 3362 (unsigned long) isym->st_value, 3363 (unsigned long) isym->st_size, 3364 isym->st_name, 3365 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link, 3366 isym->st_name), 3367 isym->st_info, st_info_str, st_info_stb_str, 3368 isym->st_other, st_other_str, 3369 isym->st_shndx, st_shndx_str); 3370 } 3371 if (free_internal) 3372 free (internal_syms); 3373 if (free_external) 3374 free (external_syms); 3375} 3376 3377char * 3378rx_get_reloc (long reloc) 3379{ 3380 if (0 <= reloc && reloc < R_RX_max) 3381 return rx_elf_howto_table[reloc].name; 3382 return ""; 3383} 3384#endif /* DEBUG */ 3385 3386 3387/* We must take care to keep the on-disk copy of any code sections 3388 that are fully linked swapped if the target is big endian, to match 3389 the Renesas tools. */ 3390 3391/* The rule is: big endian object that are final-link executables, 3392 have code sections stored with 32-bit words swapped relative to 3393 what you'd get by default. */ 3394 3395static bfd_boolean 3396rx_get_section_contents (bfd * abfd, 3397 sec_ptr section, 3398 void * location, 3399 file_ptr offset, 3400 bfd_size_type count) 3401{ 3402 int exec = (abfd->flags & EXEC_P) ? 1 : 0; 3403 int s_code = (section->flags & SEC_CODE) ? 1 : 0; 3404 bfd_boolean rv; 3405 3406#ifdef DJDEBUG 3407 fprintf (stderr, "dj: get %ld %ld from %s %s e%d sc%d %08lx:%08lx\n", 3408 (long) offset, (long) count, section->name, 3409 bfd_big_endian(abfd) ? "be" : "le", 3410 exec, s_code, (long unsigned) section->filepos, 3411 (long unsigned) offset); 3412#endif 3413 3414 if (exec && s_code && bfd_big_endian (abfd)) 3415 { 3416 char * cloc = (char *) location; 3417 bfd_size_type cnt, end_cnt; 3418 3419 rv = TRUE; 3420 3421 /* Fetch and swap unaligned bytes at the beginning. */ 3422 if (offset % 4) 3423 { 3424 char buf[4]; 3425 3426 rv = _bfd_generic_get_section_contents (abfd, section, buf, 3427 (offset & -4), 4); 3428 if (!rv) 3429 return FALSE; 3430 3431 bfd_putb32 (bfd_getl32 (buf), buf); 3432 3433 cnt = 4 - (offset % 4); 3434 if (cnt > count) 3435 cnt = count; 3436 3437 memcpy (location, buf + (offset % 4), cnt); 3438 3439 count -= cnt; 3440 offset += cnt; 3441 cloc += count; 3442 } 3443 3444 end_cnt = count % 4; 3445 3446 /* Fetch and swap the middle bytes. */ 3447 if (count >= 4) 3448 { 3449 rv = _bfd_generic_get_section_contents (abfd, section, cloc, offset, 3450 count - end_cnt); 3451 if (!rv) 3452 return FALSE; 3453 3454 for (cnt = count; cnt >= 4; cnt -= 4, cloc += 4) 3455 bfd_putb32 (bfd_getl32 (cloc), cloc); 3456 } 3457 3458 /* Fetch and swap the end bytes. */ 3459 if (end_cnt > 0) 3460 { 3461 char buf[4]; 3462 3463 /* Fetch the end bytes. */ 3464 rv = _bfd_generic_get_section_contents (abfd, section, buf, 3465 offset + count - end_cnt, 4); 3466 if (!rv) 3467 return FALSE; 3468 3469 bfd_putb32 (bfd_getl32 (buf), buf); 3470 memcpy (cloc, buf, end_cnt); 3471 } 3472 } 3473 else 3474 rv = _bfd_generic_get_section_contents (abfd, section, location, offset, count); 3475 3476 return rv; 3477} 3478 3479#ifdef DJDEBUG 3480static bfd_boolean 3481rx2_set_section_contents (bfd * abfd, 3482 sec_ptr section, 3483 const void * location, 3484 file_ptr offset, 3485 bfd_size_type count) 3486{ 3487 bfd_size_type i; 3488 3489 fprintf (stderr, " set sec %s %08x loc %p offset %#x count %#x\n", 3490 section->name, (unsigned) section->vma, location, (int) offset, (int) count); 3491 for (i = 0; i < count; i++) 3492 { 3493 if (i % 16 == 0 && i > 0) 3494 fprintf (stderr, "\n"); 3495 3496 if (i % 16 && i % 4 == 0) 3497 fprintf (stderr, " "); 3498 3499 if (i % 16 == 0) 3500 fprintf (stderr, " %08x:", (int) (section->vma + offset + i)); 3501 3502 fprintf (stderr, " %02x", ((unsigned char *) location)[i]); 3503 } 3504 fprintf (stderr, "\n"); 3505 3506 return _bfd_elf_set_section_contents (abfd, section, location, offset, count); 3507} 3508#define _bfd_elf_set_section_contents rx2_set_section_contents 3509#endif 3510 3511static bfd_boolean 3512rx_set_section_contents (bfd * abfd, 3513 sec_ptr section, 3514 const void * location, 3515 file_ptr offset, 3516 bfd_size_type count) 3517{ 3518 bfd_boolean exec = (abfd->flags & EXEC_P) ? TRUE : FALSE; 3519 bfd_boolean s_code = (section->flags & SEC_CODE) ? TRUE : FALSE; 3520 bfd_boolean rv; 3521 char * swapped_data = NULL; 3522 bfd_size_type i; 3523 bfd_vma caddr = section->vma + offset; 3524 file_ptr faddr = 0; 3525 bfd_size_type scount; 3526 3527#ifdef DJDEBUG 3528 bfd_size_type i; 3529 3530 fprintf (stderr, "\ndj: set %ld %ld to %s %s e%d sc%d\n", 3531 (long) offset, (long) count, section->name, 3532 bfd_big_endian (abfd) ? "be" : "le", 3533 exec, s_code); 3534 3535 for (i = 0; i < count; i++) 3536 { 3537 int a = section->vma + offset + i; 3538 3539 if (a % 16 == 0 && a > 0) 3540 fprintf (stderr, "\n"); 3541 3542 if (a % 16 && a % 4 == 0) 3543 fprintf (stderr, " "); 3544 3545 if (a % 16 == 0 || i == 0) 3546 fprintf (stderr, " %08x:", (int) (section->vma + offset + i)); 3547 3548 fprintf (stderr, " %02x", ((unsigned char *) location)[i]); 3549 } 3550 3551 fprintf (stderr, "\n"); 3552#endif 3553 3554 if (! exec || ! s_code || ! bfd_big_endian (abfd)) 3555 return _bfd_elf_set_section_contents (abfd, section, location, offset, count); 3556 3557 while (count > 0 && caddr > 0 && caddr % 4) 3558 { 3559 switch (caddr % 4) 3560 { 3561 case 0: faddr = offset + 3; break; 3562 case 1: faddr = offset + 1; break; 3563 case 2: faddr = offset - 1; break; 3564 case 3: faddr = offset - 3; break; 3565 } 3566 3567 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1); 3568 if (! rv) 3569 return rv; 3570 3571 location = (bfd_byte *) location + 1; 3572 offset ++; 3573 count --; 3574 caddr ++; 3575 } 3576 3577 scount = (int)(count / 4) * 4; 3578 if (scount > 0) 3579 { 3580 char * cloc = (char *) location; 3581 3582 swapped_data = (char *) bfd_alloc (abfd, count); 3583 3584 for (i = 0; i < count; i += 4) 3585 { 3586 bfd_vma v = bfd_getl32 (cloc + i); 3587 bfd_putb32 (v, swapped_data + i); 3588 } 3589 3590 rv = _bfd_elf_set_section_contents (abfd, section, swapped_data, offset, scount); 3591 3592 if (!rv) 3593 return rv; 3594 } 3595 3596 count -= scount; 3597 location = (bfd_byte *) location + scount; 3598 offset += scount; 3599 3600 if (count > 0) 3601 { 3602 caddr = section->vma + offset; 3603 while (count > 0) 3604 { 3605 switch (caddr % 4) 3606 { 3607 case 0: faddr = offset + 3; break; 3608 case 1: faddr = offset + 1; break; 3609 case 2: faddr = offset - 1; break; 3610 case 3: faddr = offset - 3; break; 3611 } 3612 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1); 3613 if (! rv) 3614 return rv; 3615 3616 location = (bfd_byte *) location + 1; 3617 offset ++; 3618 count --; 3619 caddr ++; 3620 } 3621 } 3622 3623 return TRUE; 3624} 3625 3626static bfd_boolean 3627rx_final_link (bfd * abfd, struct bfd_link_info * info) 3628{ 3629 asection * o; 3630 3631 for (o = abfd->sections; o != NULL; o = o->next) 3632 { 3633#ifdef DJDEBUG 3634 fprintf (stderr, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n", 3635 o->name, o->flags, o->vma, o->lma, o->size, o->rawsize); 3636#endif 3637 if (o->flags & SEC_CODE 3638 && bfd_big_endian (abfd) 3639 && o->size % 4) 3640 { 3641#ifdef DJDEBUG 3642 fprintf (stderr, "adjusting...\n"); 3643#endif 3644 o->size += 4 - (o->size % 4); 3645 } 3646 } 3647 3648 return bfd_elf_final_link (abfd, info); 3649} 3650 3651static bfd_boolean 3652elf32_rx_modify_program_headers (bfd * abfd ATTRIBUTE_UNUSED, 3653 struct bfd_link_info * info ATTRIBUTE_UNUSED) 3654{ 3655 const struct elf_backend_data * bed; 3656 struct elf_obj_tdata * tdata; 3657 Elf_Internal_Phdr * phdr; 3658 unsigned int count; 3659 unsigned int i; 3660 3661 bed = get_elf_backend_data (abfd); 3662 tdata = elf_tdata (abfd); 3663 phdr = tdata->phdr; 3664 count = elf_program_header_size (abfd) / bed->s->sizeof_phdr; 3665 3666 if (ignore_lma) 3667 for (i = count; i-- != 0;) 3668 if (phdr[i].p_type == PT_LOAD) 3669 { 3670 /* The Renesas tools expect p_paddr to be zero. However, 3671 there is no other way to store the writable data in ROM for 3672 startup initialization. So, we let the linker *think* 3673 we're using paddr and vaddr the "usual" way, but at the 3674 last minute we move the paddr into the vaddr (which is what 3675 the simulator uses) and zero out paddr. Note that this 3676 does not affect the section headers, just the program 3677 headers. We hope. */ 3678 phdr[i].p_vaddr = phdr[i].p_paddr; 3679#if 0 /* If we zero out p_paddr, then the LMA in the section table 3680 becomes wrong. */ 3681 phdr[i].p_paddr = 0; 3682#endif 3683 } 3684 3685 return TRUE; 3686} 3687 3688/* The default literal sections should always be marked as "code" (i.e., 3689 SHF_EXECINSTR). This is particularly important for big-endian mode 3690 when we do not want their contents byte reversed. */ 3691static const struct bfd_elf_special_section elf32_rx_special_sections[] = 3692{ 3693 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR }, 3694 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_EXECINSTR }, 3695 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR }, 3696 { NULL, 0, 0, 0, 0 } 3697}; 3698 3699typedef struct { 3700 bfd *abfd; 3701 struct bfd_link_info *info; 3702 bfd_vma table_start; 3703 int table_size; 3704 bfd_vma *table_handlers; 3705 bfd_vma table_default_handler; 3706 struct bfd_link_hash_entry **table_entries; 3707 struct bfd_link_hash_entry *table_default_entry; 3708 FILE *mapfile; 3709} RX_Table_Info; 3710 3711static bfd_boolean 3712rx_table_find (struct bfd_hash_entry *vent, void *vinfo) 3713{ 3714 RX_Table_Info *info = (RX_Table_Info *)vinfo; 3715 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent; 3716 const char *name; /* of the symbol we've found */ 3717 asection *sec; 3718 struct bfd *abfd; 3719 int idx; 3720 const char *tname; /* name of the table */ 3721 bfd_vma start_addr, end_addr; 3722 char *buf; 3723 struct bfd_link_hash_entry * h; 3724 3725 /* We're looking for globally defined symbols of the form 3726 $tablestart$<NAME>. */ 3727 if (ent->type != bfd_link_hash_defined 3728 && ent->type != bfd_link_hash_defweak) 3729 return TRUE; 3730 3731 name = ent->root.string; 3732 sec = ent->u.def.section; 3733 abfd = sec->owner; 3734 3735 if (strncmp (name, "$tablestart$", 12)) 3736 return TRUE; 3737 3738 sec->flags |= SEC_KEEP; 3739 3740 tname = name + 12; 3741 3742 start_addr = ent->u.def.value; 3743 3744 /* At this point, we can't build the table but we can (and must) 3745 find all the related symbols and mark their sections as SEC_KEEP 3746 so we don't garbage collect them. */ 3747 3748 buf = (char *) malloc (12 + 10 + strlen (tname)); 3749 3750 sprintf (buf, "$tableend$%s", tname); 3751 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE); 3752 if (!h || (h->type != bfd_link_hash_defined 3753 && h->type != bfd_link_hash_defweak)) 3754 { 3755 /* xgettext:c-format */ 3756 _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"), 3757 abfd, sec, name, buf); 3758 return TRUE; 3759 } 3760 3761 if (h->u.def.section != ent->u.def.section) 3762 { 3763 /* xgettext:c-format */ 3764 _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"), 3765 h->u.def.section->owner, h->u.def.section, 3766 name, buf); 3767 return TRUE; 3768 } 3769 3770 end_addr = h->u.def.value; 3771 3772 sprintf (buf, "$tableentry$default$%s", tname); 3773 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE); 3774 if (h && (h->type == bfd_link_hash_defined 3775 || h->type == bfd_link_hash_defweak)) 3776 { 3777 h->u.def.section->flags |= SEC_KEEP; 3778 } 3779 3780 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++) 3781 { 3782 sprintf (buf, "$tableentry$%d$%s", idx, tname); 3783 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE); 3784 if (h && (h->type == bfd_link_hash_defined 3785 || h->type == bfd_link_hash_defweak)) 3786 { 3787 h->u.def.section->flags |= SEC_KEEP; 3788 } 3789 } 3790 3791 /* Return TRUE to keep scanning, FALSE to end the traversal. */ 3792 return TRUE; 3793} 3794 3795/* We need to check for table entry symbols and build the tables, and 3796 we need to do it before the linker does garbage collection. This function is 3797 called once per input object file. */ 3798static bfd_boolean 3799rx_check_directives 3800 (bfd * abfd ATTRIBUTE_UNUSED, 3801 struct bfd_link_info * info ATTRIBUTE_UNUSED) 3802{ 3803 RX_Table_Info stuff; 3804 3805 stuff.abfd = abfd; 3806 stuff.info = info; 3807 bfd_hash_traverse (&(info->hash->table), rx_table_find, &stuff); 3808 3809 return TRUE; 3810} 3811 3812 3813static bfd_boolean 3814rx_table_map_2 (struct bfd_hash_entry *vent, void *vinfo) 3815{ 3816 RX_Table_Info *info = (RX_Table_Info *)vinfo; 3817 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent; 3818 int idx; 3819 const char *name; 3820 bfd_vma addr; 3821 3822 /* See if the symbol ENT has an address listed in the table, and 3823 isn't a debug/special symbol. If so, put it in the table. */ 3824 3825 if (ent->type != bfd_link_hash_defined 3826 && ent->type != bfd_link_hash_defweak) 3827 return TRUE; 3828 3829 name = ent->root.string; 3830 3831 if (name[0] == '$' || name[0] == '.' || name[0] < ' ') 3832 return TRUE; 3833 3834 addr = (ent->u.def.value 3835 + ent->u.def.section->output_section->vma 3836 + ent->u.def.section->output_offset); 3837 3838 for (idx = 0; idx < info->table_size; idx ++) 3839 if (addr == info->table_handlers[idx]) 3840 info->table_entries[idx] = ent; 3841 3842 if (addr == info->table_default_handler) 3843 info->table_default_entry = ent; 3844 3845 return TRUE; 3846} 3847 3848static bfd_boolean 3849rx_table_map (struct bfd_hash_entry *vent, void *vinfo) 3850{ 3851 RX_Table_Info *info = (RX_Table_Info *)vinfo; 3852 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent; 3853 const char *name; /* of the symbol we've found */ 3854 int idx; 3855 const char *tname; /* name of the table */ 3856 bfd_vma start_addr, end_addr; 3857 char *buf; 3858 struct bfd_link_hash_entry * h; 3859 int need_elipses; 3860 3861 /* We're looking for globally defined symbols of the form 3862 $tablestart$<NAME>. */ 3863 if (ent->type != bfd_link_hash_defined 3864 && ent->type != bfd_link_hash_defweak) 3865 return TRUE; 3866 3867 name = ent->root.string; 3868 3869 if (strncmp (name, "$tablestart$", 12)) 3870 return TRUE; 3871 3872 tname = name + 12; 3873 start_addr = (ent->u.def.value 3874 + ent->u.def.section->output_section->vma 3875 + ent->u.def.section->output_offset); 3876 3877 buf = (char *) malloc (12 + 10 + strlen (tname)); 3878 3879 sprintf (buf, "$tableend$%s", tname); 3880 end_addr = get_symbol_value_maybe (buf, info->info); 3881 3882 sprintf (buf, "$tableentry$default$%s", tname); 3883 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE); 3884 if (h) 3885 { 3886 info->table_default_handler = (h->u.def.value 3887 + h->u.def.section->output_section->vma 3888 + h->u.def.section->output_offset); 3889 } 3890 else 3891 /* Zero is a valid handler address! */ 3892 info->table_default_handler = (bfd_vma) (-1); 3893 info->table_default_entry = NULL; 3894 3895 info->table_start = start_addr; 3896 info->table_size = (int) (end_addr - start_addr) / 4; 3897 info->table_handlers = (bfd_vma *) malloc (info->table_size * sizeof (bfd_vma)); 3898 info->table_entries = (struct bfd_link_hash_entry **) malloc (info->table_size * sizeof (struct bfd_link_hash_entry)); 3899 3900 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++) 3901 { 3902 sprintf (buf, "$tableentry$%d$%s", idx, tname); 3903 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE); 3904 if (h && (h->type == bfd_link_hash_defined 3905 || h->type == bfd_link_hash_defweak)) 3906 { 3907 info->table_handlers[idx] = (h->u.def.value 3908 + h->u.def.section->output_section->vma 3909 + h->u.def.section->output_offset); 3910 } 3911 else 3912 info->table_handlers[idx] = info->table_default_handler; 3913 info->table_entries[idx] = NULL; 3914 } 3915 3916 free (buf); 3917 3918 bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info); 3919 3920 fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n", 3921 tname, info->table_size, start_addr); 3922 3923 if (info->table_default_entry) 3924 fprintf (info->mapfile, " default handler is: %s at 0x%08" BFD_VMA_FMT "x\n", 3925 info->table_default_entry->root.string, 3926 info->table_default_handler); 3927 else if (info->table_default_handler != (bfd_vma)(-1)) 3928 fprintf (info->mapfile, " default handler is at 0x%08" BFD_VMA_FMT "x\n", 3929 info->table_default_handler); 3930 else 3931 fprintf (info->mapfile, " no default handler\n"); 3932 3933 need_elipses = 1; 3934 for (idx = 0; idx < info->table_size; idx ++) 3935 { 3936 if (info->table_handlers[idx] == info->table_default_handler) 3937 { 3938 if (need_elipses) 3939 fprintf (info->mapfile, " . . .\n"); 3940 need_elipses = 0; 3941 continue; 3942 } 3943 need_elipses = 1; 3944 3945 fprintf (info->mapfile, " 0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx); 3946 3947 if (info->table_handlers[idx] == (bfd_vma) (-1)) 3948 fprintf (info->mapfile, "(no handler found)\n"); 3949 3950 else if (info->table_handlers[idx] == info->table_default_handler) 3951 { 3952 if (info->table_default_entry) 3953 fprintf (info->mapfile, "(default)\n"); 3954 else 3955 fprintf (info->mapfile, "(default)\n"); 3956 } 3957 3958 else if (info->table_entries[idx]) 3959 { 3960 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string); 3961 } 3962 3963 else 3964 { 3965 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]); 3966 } 3967 } 3968 if (need_elipses) 3969 fprintf (info->mapfile, " . . .\n"); 3970 3971 return TRUE; 3972} 3973 3974void 3975rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfile) 3976{ 3977 /* We scan the symbol table looking for $tableentry$'s, and for 3978 each, try to deduce which handlers go with which entries. */ 3979 3980 RX_Table_Info stuff; 3981 3982 stuff.abfd = obfd; 3983 stuff.info = info; 3984 stuff.mapfile = mapfile; 3985 bfd_hash_traverse (&(info->hash->table), rx_table_map, &stuff); 3986} 3987 3988 3989#define ELF_ARCH bfd_arch_rx 3990#define ELF_MACHINE_CODE EM_RX 3991#define ELF_MAXPAGESIZE 0x1000 3992 3993#define TARGET_BIG_SYM rx_elf32_be_vec 3994#define TARGET_BIG_NAME "elf32-rx-be" 3995 3996#define TARGET_LITTLE_SYM rx_elf32_le_vec 3997#define TARGET_LITTLE_NAME "elf32-rx-le" 3998 3999#define elf_info_to_howto_rel NULL 4000#define elf_info_to_howto rx_info_to_howto_rela 4001#define elf_backend_object_p rx_elf_object_p 4002#define elf_backend_relocate_section rx_elf_relocate_section 4003#define elf_symbol_leading_char ('_') 4004#define elf_backend_can_gc_sections 1 4005#define elf_backend_modify_program_headers elf32_rx_modify_program_headers 4006 4007#define bfd_elf32_bfd_reloc_type_lookup rx_reloc_type_lookup 4008#define bfd_elf32_bfd_reloc_name_lookup rx_reloc_name_lookup 4009#define bfd_elf32_bfd_set_private_flags rx_elf_set_private_flags 4010#define bfd_elf32_bfd_merge_private_bfd_data rx_elf_merge_private_bfd_data 4011#define bfd_elf32_bfd_print_private_bfd_data rx_elf_print_private_bfd_data 4012#define bfd_elf32_get_section_contents rx_get_section_contents 4013#define bfd_elf32_set_section_contents rx_set_section_contents 4014#define bfd_elf32_bfd_final_link rx_final_link 4015#define bfd_elf32_bfd_relax_section elf32_rx_relax_section_wrapper 4016#define elf_backend_special_sections elf32_rx_special_sections 4017#define elf_backend_check_directives rx_check_directives 4018 4019#include "elf32-target.h" 4020 4021/* We define a second big-endian target that doesn't have the custom 4022 section get/set hooks, for times when we want to preserve the 4023 pre-swapped .text sections (like objcopy). */ 4024 4025#undef TARGET_BIG_SYM 4026#define TARGET_BIG_SYM rx_elf32_be_ns_vec 4027#undef TARGET_BIG_NAME 4028#define TARGET_BIG_NAME "elf32-rx-be-ns" 4029#undef TARGET_LITTLE_SYM 4030 4031#undef bfd_elf32_get_section_contents 4032#undef bfd_elf32_set_section_contents 4033 4034#undef elf32_bed 4035#define elf32_bed elf32_rx_be_ns_bed 4036 4037#include "elf32-target.h" 4038