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