elf32-h8300.c revision 1.1.1.1.2.1
1 /* BFD back-end for Renesas H8/300 ELF binaries. 2 Copyright (C) 1993-2015 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 "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/h8.h" 26 27 static reloc_howto_type *elf32_h8_reloc_type_lookup 28 (bfd *abfd, bfd_reloc_code_real_type code); 29 static void elf32_h8_info_to_howto 30 (bfd *, arelent *, Elf_Internal_Rela *); 31 static void elf32_h8_info_to_howto_rel 32 (bfd *, arelent *, Elf_Internal_Rela *); 33 static unsigned long elf32_h8_mach (flagword); 34 static void elf32_h8_final_write_processing (bfd *, bfd_boolean); 35 static bfd_boolean elf32_h8_object_p (bfd *); 36 static bfd_boolean elf32_h8_merge_private_bfd_data (bfd *, bfd *); 37 static bfd_boolean elf32_h8_relax_section 38 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *); 39 static bfd_boolean elf32_h8_relax_delete_bytes 40 (bfd *, asection *, bfd_vma, int); 41 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma); 42 static bfd_byte *elf32_h8_get_relocated_section_contents 43 (bfd *, struct bfd_link_info *, struct bfd_link_order *, 44 bfd_byte *, bfd_boolean, asymbol **); 45 static bfd_reloc_status_type elf32_h8_final_link_relocate 46 (unsigned long, bfd *, bfd *, asection *, 47 bfd_byte *, bfd_vma, bfd_vma, bfd_vma, 48 struct bfd_link_info *, asection *, int); 49 static bfd_boolean elf32_h8_relocate_section 50 (bfd *, struct bfd_link_info *, bfd *, asection *, 51 bfd_byte *, Elf_Internal_Rela *, 52 Elf_Internal_Sym *, asection **); 53 static bfd_reloc_status_type special 54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 55 56 /* This does not include any relocation information, but should be 57 good enough for GDB or objdump to read the file. */ 58 59 static reloc_howto_type h8_elf_howto_table[] = 60 { 61 #define R_H8_NONE_X 0 62 HOWTO (R_H8_NONE, /* type */ 63 0, /* rightshift */ 64 3, /* size (0 = byte, 1 = short, 2 = long) */ 65 0, /* bitsize */ 66 FALSE, /* pc_relative */ 67 0, /* bitpos */ 68 complain_overflow_dont,/* complain_on_overflow */ 69 special, /* special_function */ 70 "R_H8_NONE", /* name */ 71 FALSE, /* partial_inplace */ 72 0, /* src_mask */ 73 0, /* dst_mask */ 74 FALSE), /* pcrel_offset */ 75 #define R_H8_DIR32_X (R_H8_NONE_X + 1) 76 HOWTO (R_H8_DIR32, /* type */ 77 0, /* rightshift */ 78 2, /* size (0 = byte, 1 = short, 2 = long) */ 79 32, /* bitsize */ 80 FALSE, /* pc_relative */ 81 0, /* bitpos */ 82 complain_overflow_dont,/* complain_on_overflow */ 83 special, /* special_function */ 84 "R_H8_DIR32", /* name */ 85 FALSE, /* partial_inplace */ 86 0, /* src_mask */ 87 0xffffffff, /* dst_mask */ 88 FALSE), /* pcrel_offset */ 89 #define R_H8_DIR16_X (R_H8_DIR32_X + 1) 90 HOWTO (R_H8_DIR16, /* type */ 91 0, /* rightshift */ 92 1, /* size (0 = byte, 1 = short, 2 = long) */ 93 16, /* bitsize */ 94 FALSE, /* pc_relative */ 95 0, /* bitpos */ 96 complain_overflow_dont,/* complain_on_overflow */ 97 special, /* special_function */ 98 "R_H8_DIR16", /* name */ 99 FALSE, /* partial_inplace */ 100 0, /* src_mask */ 101 0x0000ffff, /* dst_mask */ 102 FALSE), /* pcrel_offset */ 103 #define R_H8_DIR8_X (R_H8_DIR16_X + 1) 104 HOWTO (R_H8_DIR8, /* type */ 105 0, /* rightshift */ 106 0, /* size (0 = byte, 1 = short, 2 = long) */ 107 8, /* bitsize */ 108 FALSE, /* pc_relative */ 109 0, /* bitpos */ 110 complain_overflow_dont,/* complain_on_overflow */ 111 special, /* special_function */ 112 "R_H8_DIR8", /* name */ 113 FALSE, /* partial_inplace */ 114 0, /* src_mask */ 115 0x000000ff, /* dst_mask */ 116 FALSE), /* pcrel_offset */ 117 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1) 118 HOWTO (R_H8_DIR16A8, /* type */ 119 0, /* rightshift */ 120 1, /* size (0 = byte, 1 = short, 2 = long) */ 121 16, /* bitsize */ 122 FALSE, /* pc_relative */ 123 0, /* bitpos */ 124 complain_overflow_bitfield, /* complain_on_overflow */ 125 special, /* special_function */ 126 "R_H8_DIR16A8", /* name */ 127 FALSE, /* partial_inplace */ 128 0, /* src_mask */ 129 0x0000ffff, /* dst_mask */ 130 FALSE), /* pcrel_offset */ 131 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1) 132 HOWTO (R_H8_DIR16R8, /* type */ 133 0, /* rightshift */ 134 1, /* size (0 = byte, 1 = short, 2 = long) */ 135 16, /* bitsize */ 136 FALSE, /* pc_relative */ 137 0, /* bitpos */ 138 complain_overflow_bitfield, /* complain_on_overflow */ 139 special, /* special_function */ 140 "R_H8_DIR16R8", /* name */ 141 FALSE, /* partial_inplace */ 142 0, /* src_mask */ 143 0x0000ffff, /* dst_mask */ 144 FALSE), /* pcrel_offset */ 145 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1) 146 HOWTO (R_H8_DIR24A8, /* type */ 147 0, /* rightshift */ 148 2, /* size (0 = byte, 1 = short, 2 = long) */ 149 24, /* bitsize */ 150 FALSE, /* pc_relative */ 151 0, /* bitpos */ 152 complain_overflow_bitfield, /* complain_on_overflow */ 153 special, /* special_function */ 154 "R_H8_DIR24A8", /* name */ 155 TRUE, /* partial_inplace */ 156 0xff000000, /* src_mask */ 157 0x00ffffff, /* dst_mask */ 158 FALSE), /* pcrel_offset */ 159 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1) 160 HOWTO (R_H8_DIR24R8, /* type */ 161 0, /* rightshift */ 162 2, /* size (0 = byte, 1 = short, 2 = long) */ 163 24, /* bitsize */ 164 FALSE, /* pc_relative */ 165 0, /* bitpos */ 166 complain_overflow_bitfield, /* complain_on_overflow */ 167 special, /* special_function */ 168 "R_H8_DIR24R8", /* name */ 169 TRUE, /* partial_inplace */ 170 0xff000000, /* src_mask */ 171 0x00ffffff, /* dst_mask */ 172 FALSE), /* pcrel_offset */ 173 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1) 174 HOWTO (R_H8_DIR32A16, /* type */ 175 0, /* rightshift */ 176 2, /* size (0 = byte, 1 = short, 2 = long) */ 177 32, /* bitsize */ 178 FALSE, /* pc_relative */ 179 0, /* bitpos */ 180 complain_overflow_dont,/* complain_on_overflow */ 181 special, /* special_function */ 182 "R_H8_DIR32A16", /* name */ 183 FALSE, /* partial_inplace */ 184 0, /* src_mask */ 185 0xffffffff, /* dst_mask */ 186 FALSE), /* pcrel_offset */ 187 #define R_H8_DISP32A16_X (R_H8_DIR32A16_X + 1) 188 HOWTO (R_H8_DISP32A16, /* type */ 189 0, /* rightshift */ 190 2, /* size (0 = byte, 1 = short, 2 = long) */ 191 32, /* bitsize */ 192 FALSE, /* pc_relative */ 193 0, /* bitpos */ 194 complain_overflow_dont,/* complain_on_overflow */ 195 special, /* special_function */ 196 "R_H8_DISP32A16", /* name */ 197 FALSE, /* partial_inplace */ 198 0, /* src_mask */ 199 0xffffffff, /* dst_mask */ 200 FALSE), /* pcrel_offset */ 201 #define R_H8_PCREL16_X (R_H8_DISP32A16_X + 1) 202 HOWTO (R_H8_PCREL16, /* type */ 203 0, /* rightshift */ 204 1, /* size (0 = byte, 1 = short, 2 = long) */ 205 16, /* bitsize */ 206 TRUE, /* pc_relative */ 207 0, /* bitpos */ 208 complain_overflow_signed,/* complain_on_overflow */ 209 special, /* special_function */ 210 "R_H8_PCREL16", /* name */ 211 FALSE, /* partial_inplace */ 212 0xffff, /* src_mask */ 213 0xffff, /* dst_mask */ 214 TRUE), /* pcrel_offset */ 215 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1) 216 HOWTO (R_H8_PCREL8, /* type */ 217 0, /* rightshift */ 218 0, /* size (0 = byte, 1 = short, 2 = long) */ 219 8, /* bitsize */ 220 TRUE, /* pc_relative */ 221 0, /* bitpos */ 222 complain_overflow_signed,/* complain_on_overflow */ 223 special, /* special_function */ 224 "R_H8_PCREL8", /* name */ 225 FALSE, /* partial_inplace */ 226 0xff, /* src_mask */ 227 0xff, /* dst_mask */ 228 TRUE), /* pcrel_offset */ 229 }; 230 231 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */ 232 233 struct elf_reloc_map { 234 bfd_reloc_code_real_type bfd_reloc_val; 235 unsigned char howto_index; 236 }; 237 238 /* An array mapping BFD reloc codes to H8 ELF relocs. */ 239 240 static const struct elf_reloc_map h8_reloc_map[] = { 241 { BFD_RELOC_NONE, R_H8_NONE_X }, 242 { BFD_RELOC_32, R_H8_DIR32_X }, 243 { BFD_RELOC_16, R_H8_DIR16_X }, 244 { BFD_RELOC_8, R_H8_DIR8_X }, 245 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X }, 246 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X }, 247 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X }, 248 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X }, 249 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X }, 250 { BFD_RELOC_H8_DISP32A16, R_H8_DISP32A16_X }, 251 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X }, 252 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X }, 253 }; 254 255 256 static reloc_howto_type * 257 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 258 bfd_reloc_code_real_type code) 259 { 260 unsigned int i; 261 262 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++) 263 { 264 if (h8_reloc_map[i].bfd_reloc_val == code) 265 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index]; 266 } 267 return NULL; 268 } 269 270 static reloc_howto_type * 271 elf32_h8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 272 const char *r_name) 273 { 274 unsigned int i; 275 276 for (i = 0; 277 i < sizeof (h8_elf_howto_table) / sizeof (h8_elf_howto_table[0]); 278 i++) 279 if (h8_elf_howto_table[i].name != NULL 280 && strcasecmp (h8_elf_howto_table[i].name, r_name) == 0) 281 return &h8_elf_howto_table[i]; 282 283 return NULL; 284 } 285 286 static void 287 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc, 288 Elf_Internal_Rela *elf_reloc) 289 { 290 unsigned int r; 291 unsigned int i; 292 293 r = ELF32_R_TYPE (elf_reloc->r_info); 294 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++) 295 if (h8_elf_howto_table[i].type == r) 296 { 297 bfd_reloc->howto = &h8_elf_howto_table[i]; 298 return; 299 } 300 abort (); 301 } 302 303 static void 304 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc, 305 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED) 306 { 307 unsigned int r; 308 309 abort (); 310 r = ELF32_R_TYPE (elf_reloc->r_info); 311 bfd_reloc->howto = &h8_elf_howto_table[r]; 312 } 313 314 /* Special handling for H8/300 relocs. 315 We only come here for pcrel stuff and return normally if not an -r link. 316 When doing -r, we can't do any arithmetic for the pcrel stuff, because 317 we support relaxing on the H8/300 series chips. */ 318 static bfd_reloc_status_type 319 special (bfd *abfd ATTRIBUTE_UNUSED, 320 arelent *reloc_entry ATTRIBUTE_UNUSED, 321 asymbol *symbol ATTRIBUTE_UNUSED, 322 void * data ATTRIBUTE_UNUSED, 323 asection *input_section ATTRIBUTE_UNUSED, 324 bfd *output_bfd, 325 char **error_message ATTRIBUTE_UNUSED) 326 { 327 if (output_bfd == (bfd *) NULL) 328 return bfd_reloc_continue; 329 330 /* Adjust the reloc address to that in the output section. */ 331 reloc_entry->address += input_section->output_offset; 332 return bfd_reloc_ok; 333 } 334 335 /* Perform a relocation as part of a final link. */ 336 static bfd_reloc_status_type 337 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd, 338 bfd *output_bfd ATTRIBUTE_UNUSED, 339 asection *input_section ATTRIBUTE_UNUSED, 340 bfd_byte *contents, bfd_vma offset, 341 bfd_vma value, bfd_vma addend, 342 struct bfd_link_info *info ATTRIBUTE_UNUSED, 343 asection *sym_sec ATTRIBUTE_UNUSED, 344 int is_local ATTRIBUTE_UNUSED) 345 { 346 bfd_byte *hit_data = contents + offset; 347 348 switch (r_type) 349 { 350 case R_H8_NONE: 351 return bfd_reloc_ok; 352 353 case R_H8_DIR32: 354 case R_H8_DIR32A16: 355 case R_H8_DISP32A16: 356 case R_H8_DIR24A8: 357 value += addend; 358 bfd_put_32 (input_bfd, value, hit_data); 359 return bfd_reloc_ok; 360 361 case R_H8_DIR16: 362 case R_H8_DIR16A8: 363 case R_H8_DIR16R8: 364 value += addend; 365 bfd_put_16 (input_bfd, value, hit_data); 366 return bfd_reloc_ok; 367 368 /* AKA R_RELBYTE */ 369 case R_H8_DIR8: 370 value += addend; 371 372 bfd_put_8 (input_bfd, value, hit_data); 373 return bfd_reloc_ok; 374 375 case R_H8_DIR24R8: 376 value += addend; 377 378 /* HIT_DATA is the address for the first byte for the relocated 379 value. Subtract 1 so that we can manipulate the data in 32-bit 380 hunks. */ 381 hit_data--; 382 383 /* Clear out the top byte in value. */ 384 value &= 0xffffff; 385 386 /* Retrieve the type byte for value from the section contents. */ 387 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000); 388 389 /* Now scribble it out in one 32-bit hunk. */ 390 bfd_put_32 (input_bfd, value, hit_data); 391 return bfd_reloc_ok; 392 393 case R_H8_PCREL16: 394 value -= (input_section->output_section->vma 395 + input_section->output_offset); 396 value -= offset; 397 value += addend; 398 399 /* The value is relative to the start of the instruction, 400 not the relocation offset. Subtract 2 to account for 401 this minor issue. */ 402 value -= 2; 403 404 bfd_put_16 (input_bfd, value, hit_data); 405 return bfd_reloc_ok; 406 407 case R_H8_PCREL8: 408 value -= (input_section->output_section->vma 409 + input_section->output_offset); 410 value -= offset; 411 value += addend; 412 413 /* The value is relative to the start of the instruction, 414 not the relocation offset. Subtract 1 to account for 415 this minor issue. */ 416 value -= 1; 417 418 bfd_put_8 (input_bfd, value, hit_data); 419 return bfd_reloc_ok; 420 421 default: 422 return bfd_reloc_notsupported; 423 } 424 } 425 426 /* Relocate an H8 ELF section. */ 428 static bfd_boolean 429 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 430 bfd *input_bfd, asection *input_section, 431 bfd_byte *contents, Elf_Internal_Rela *relocs, 432 Elf_Internal_Sym *local_syms, 433 asection **local_sections) 434 { 435 Elf_Internal_Shdr *symtab_hdr; 436 struct elf_link_hash_entry **sym_hashes; 437 Elf_Internal_Rela *rel, *relend; 438 439 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 440 sym_hashes = elf_sym_hashes (input_bfd); 441 442 rel = relocs; 443 relend = relocs + input_section->reloc_count; 444 for (; rel < relend; rel++) 445 { 446 unsigned int r_type; 447 unsigned long r_symndx; 448 Elf_Internal_Sym *sym; 449 asection *sec; 450 struct elf_link_hash_entry *h; 451 bfd_vma relocation; 452 bfd_reloc_status_type r; 453 arelent bfd_reloc; 454 reloc_howto_type *howto; 455 456 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel); 457 howto = bfd_reloc.howto; 458 459 r_symndx = ELF32_R_SYM (rel->r_info); 460 r_type = ELF32_R_TYPE (rel->r_info); 461 h = NULL; 462 sym = NULL; 463 sec = NULL; 464 if (r_symndx < symtab_hdr->sh_info) 465 { 466 sym = local_syms + r_symndx; 467 sec = local_sections[r_symndx]; 468 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 469 } 470 else 471 { 472 bfd_boolean unresolved_reloc, warned, ignored; 473 474 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 475 r_symndx, symtab_hdr, sym_hashes, 476 h, sec, relocation, 477 unresolved_reloc, warned, ignored); 478 } 479 480 if (sec != NULL && discarded_section (sec)) 481 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 482 rel, 1, relend, howto, 0, contents); 483 484 if (bfd_link_relocatable (info)) 485 continue; 486 487 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd, 488 input_section, 489 contents, rel->r_offset, 490 relocation, rel->r_addend, 491 info, sec, h == NULL); 492 493 if (r != bfd_reloc_ok) 494 { 495 const char *name; 496 const char *msg = (const char *) 0; 497 498 if (h != NULL) 499 name = h->root.root.string; 500 else 501 { 502 name = (bfd_elf_string_from_elf_section 503 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 504 if (name == NULL || *name == '\0') 505 name = bfd_section_name (input_bfd, sec); 506 } 507 508 switch (r) 509 { 510 case bfd_reloc_overflow: 511 if (! ((*info->callbacks->reloc_overflow) 512 (info, (h ? &h->root : NULL), name, howto->name, 513 (bfd_vma) 0, input_bfd, input_section, 514 rel->r_offset))) 515 return FALSE; 516 break; 517 518 case bfd_reloc_undefined: 519 if (! ((*info->callbacks->undefined_symbol) 520 (info, name, input_bfd, input_section, 521 rel->r_offset, TRUE))) 522 return FALSE; 523 break; 524 525 case bfd_reloc_outofrange: 526 msg = _("internal error: out of range error"); 527 goto common_error; 528 529 case bfd_reloc_notsupported: 530 msg = _("internal error: unsupported relocation error"); 531 goto common_error; 532 533 case bfd_reloc_dangerous: 534 msg = _("internal error: dangerous error"); 535 goto common_error; 536 537 default: 538 msg = _("internal error: unknown error"); 539 /* fall through */ 540 541 common_error: 542 if (!((*info->callbacks->warning) 543 (info, msg, name, input_bfd, input_section, 544 rel->r_offset))) 545 return FALSE; 546 break; 547 } 548 } 549 } 550 551 return TRUE; 552 } 553 554 /* Object files encode the specific H8 model they were compiled 555 for in the ELF flags field. 556 557 Examine that field and return the proper BFD machine type for 558 the object file. */ 559 static unsigned long 560 elf32_h8_mach (flagword flags) 561 { 562 switch (flags & EF_H8_MACH) 563 { 564 case E_H8_MACH_H8300: 565 default: 566 return bfd_mach_h8300; 567 568 case E_H8_MACH_H8300H: 569 return bfd_mach_h8300h; 570 571 case E_H8_MACH_H8300S: 572 return bfd_mach_h8300s; 573 574 case E_H8_MACH_H8300HN: 575 return bfd_mach_h8300hn; 576 577 case E_H8_MACH_H8300SN: 578 return bfd_mach_h8300sn; 579 580 case E_H8_MACH_H8300SX: 581 return bfd_mach_h8300sx; 582 583 case E_H8_MACH_H8300SXN: 584 return bfd_mach_h8300sxn; 585 } 586 } 587 588 /* The final processing done just before writing out a H8 ELF object 589 file. We use this opportunity to encode the BFD machine type 590 into the flags field in the object file. */ 591 592 static void 593 elf32_h8_final_write_processing (bfd *abfd, 594 bfd_boolean linker ATTRIBUTE_UNUSED) 595 { 596 unsigned long val; 597 598 switch (bfd_get_mach (abfd)) 599 { 600 default: 601 case bfd_mach_h8300: 602 val = E_H8_MACH_H8300; 603 break; 604 605 case bfd_mach_h8300h: 606 val = E_H8_MACH_H8300H; 607 break; 608 609 case bfd_mach_h8300s: 610 val = E_H8_MACH_H8300S; 611 break; 612 613 case bfd_mach_h8300hn: 614 val = E_H8_MACH_H8300HN; 615 break; 616 617 case bfd_mach_h8300sn: 618 val = E_H8_MACH_H8300SN; 619 break; 620 621 case bfd_mach_h8300sx: 622 val = E_H8_MACH_H8300SX; 623 break; 624 625 case bfd_mach_h8300sxn: 626 val = E_H8_MACH_H8300SXN; 627 break; 628 } 629 630 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH); 631 elf_elfheader (abfd)->e_flags |= val; 632 } 633 634 /* Return nonzero if ABFD represents a valid H8 ELF object file; also 635 record the encoded machine type found in the ELF flags. */ 636 637 static bfd_boolean 638 elf32_h8_object_p (bfd *abfd) 639 { 640 bfd_default_set_arch_mach (abfd, bfd_arch_h8300, 641 elf32_h8_mach (elf_elfheader (abfd)->e_flags)); 642 return TRUE; 643 } 644 645 /* Merge backend specific data from an object file to the output 646 object file when linking. The only data we need to copy at this 647 time is the architecture/machine information. */ 648 649 static bfd_boolean 650 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 651 { 652 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 653 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 654 return TRUE; 655 656 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 657 && bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 658 { 659 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 660 bfd_get_mach (ibfd))) 661 return FALSE; 662 } 663 664 return TRUE; 665 } 666 667 /* This function handles relaxing for the H8.. 668 669 There are a few relaxing opportunities available on the H8: 670 671 jmp/jsr:24 -> bra/bsr:8 2 bytes 672 The jmp may be completely eliminated if the previous insn is a 673 conditional branch to the insn after the jump. In that case 674 we invert the branch and delete the jump and save 4 bytes. 675 676 bCC:16 -> bCC:8 2 bytes 677 bsr:16 -> bsr:8 2 bytes 678 679 bset:16 -> bset:8 2 bytes 680 bset:24/32 -> bset:8 4 bytes 681 (also applicable to other bit manipulation instructions) 682 683 mov.b:16 -> mov.b:8 2 bytes 684 mov.b:24/32 -> mov.b:8 4 bytes 685 686 bset:24/32 -> bset:16 2 bytes 687 (also applicable to other bit manipulation instructions) 688 689 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes 690 691 mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes. */ 692 693 static bfd_boolean 694 elf32_h8_relax_section (bfd *abfd, asection *sec, 695 struct bfd_link_info *link_info, bfd_boolean *again) 696 { 697 Elf_Internal_Shdr *symtab_hdr; 698 Elf_Internal_Rela *internal_relocs; 699 Elf_Internal_Rela *irel, *irelend; 700 bfd_byte *contents = NULL; 701 Elf_Internal_Sym *isymbuf = NULL; 702 static asection *last_input_section = NULL; 703 static Elf_Internal_Rela *last_reloc = NULL; 704 705 /* Assume nothing changes. */ 706 *again = FALSE; 707 708 /* We don't have to do anything for a relocatable link, if 709 this section does not have relocs, or if this is not a 710 code section. */ 711 if (bfd_link_relocatable (link_info) 712 || (sec->flags & SEC_RELOC) == 0 713 || sec->reloc_count == 0 714 || (sec->flags & SEC_CODE) == 0) 715 return TRUE; 716 717 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 718 719 /* Get a copy of the native relocations. */ 720 internal_relocs = (_bfd_elf_link_read_relocs 721 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 722 link_info->keep_memory)); 723 if (internal_relocs == NULL) 724 goto error_return; 725 726 if (sec != last_input_section) 727 last_reloc = NULL; 728 729 last_input_section = sec; 730 731 /* Walk through the relocs looking for relaxing opportunities. */ 732 irelend = internal_relocs + sec->reloc_count; 733 for (irel = internal_relocs; irel < irelend; irel++) 734 { 735 bfd_vma symval; 736 737 { 738 arelent bfd_reloc; 739 740 elf32_h8_info_to_howto (abfd, &bfd_reloc, irel); 741 } 742 /* Keep track of the previous reloc so that we can delete 743 some long jumps created by the compiler. */ 744 if (irel != internal_relocs) 745 last_reloc = irel - 1; 746 747 switch(ELF32_R_TYPE (irel->r_info)) 748 { 749 case R_H8_DIR24R8: 750 case R_H8_PCREL16: 751 case R_H8_DIR16A8: 752 case R_H8_DIR24A8: 753 case R_H8_DIR32A16: 754 case R_H8_DISP32A16: 755 break; 756 default: 757 continue; 758 } 759 760 /* Get the section contents if we haven't done so already. */ 761 if (contents == NULL) 762 { 763 /* Get cached copy if it exists. */ 764 if (elf_section_data (sec)->this_hdr.contents != NULL) 765 contents = elf_section_data (sec)->this_hdr.contents; 766 else 767 { 768 /* Go get them off disk. */ 769 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 770 goto error_return; 771 } 772 } 773 774 /* Read this BFD's local symbols if we haven't done so already. */ 775 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 776 { 777 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 778 if (isymbuf == NULL) 779 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 780 symtab_hdr->sh_info, 0, 781 NULL, NULL, NULL); 782 if (isymbuf == NULL) 783 goto error_return; 784 } 785 786 /* Get the value of the symbol referred to by the reloc. */ 787 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 788 { 789 /* A local symbol. */ 790 Elf_Internal_Sym *isym; 791 asection *sym_sec; 792 793 isym = isymbuf + ELF32_R_SYM (irel->r_info); 794 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 795 symval = isym->st_value; 796 /* If the reloc is absolute, it will not have 797 a symbol or section associated with it. */ 798 if (sym_sec) 799 symval += sym_sec->output_section->vma 800 + sym_sec->output_offset; 801 } 802 else 803 { 804 unsigned long indx; 805 struct elf_link_hash_entry *h; 806 807 /* An external symbol. */ 808 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 809 h = elf_sym_hashes (abfd)[indx]; 810 BFD_ASSERT (h != NULL); 811 if (h->root.type != bfd_link_hash_defined 812 && h->root.type != bfd_link_hash_defweak) 813 { 814 /* This appears to be a reference to an undefined 815 symbol. Just ignore it--it will be caught by the 816 regular reloc processing. */ 817 continue; 818 } 819 820 symval = (h->root.u.def.value 821 + h->root.u.def.section->output_section->vma 822 + h->root.u.def.section->output_offset); 823 } 824 825 /* For simplicity of coding, we are going to modify the section 826 contents, the section relocs, and the BFD symbol table. We 827 must tell the rest of the code not to free up this 828 information. It would be possible to instead create a table 829 of changes which have to be made, as is done in coff-mips.c; 830 that would be more work, but would require less memory when 831 the linker is run. */ 832 switch (ELF32_R_TYPE (irel->r_info)) 833 { 834 /* Try to turn a 24-bit absolute branch/call into an 8-bit 835 pc-relative branch/call. */ 836 case R_H8_DIR24R8: 837 { 838 bfd_vma value = symval + irel->r_addend; 839 bfd_vma dot, gap; 840 841 /* Get the address of this instruction. */ 842 dot = (sec->output_section->vma 843 + sec->output_offset + irel->r_offset - 1); 844 845 /* Compute the distance from this insn to the branch target. */ 846 gap = value - dot; 847 848 /* If the distance is within -126..+130 inclusive, then we can 849 relax this jump. +130 is valid since the target will move 850 two bytes closer if we do relax this branch. */ 851 if ((int) gap >= -126 && (int) gap <= 130) 852 { 853 unsigned char code; 854 855 /* Note that we've changed the relocs, section contents, 856 etc. */ 857 elf_section_data (sec)->relocs = internal_relocs; 858 elf_section_data (sec)->this_hdr.contents = contents; 859 symtab_hdr->contents = (unsigned char *) isymbuf; 860 861 /* Get the instruction code being relaxed. */ 862 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 863 864 /* If the previous instruction conditionally jumped around 865 this instruction, we may be able to reverse the condition 866 and redirect the previous instruction to the target of 867 this instruction. 868 869 Such sequences are used by the compiler to deal with 870 long conditional branches. 871 872 Only perform this optimisation for jumps (code 0x5a) not 873 subroutine calls, as otherwise it could transform: 874 875 mov.w r0,r0 876 beq .L1 877 jsr @_bar 878 .L1: rts 879 _bar: rts 880 into: 881 mov.w r0,r0 882 bne _bar 883 rts 884 _bar: rts 885 886 which changes the call (jsr) into a branch (bne). */ 887 if (code == 0x5a /* jmp24. */ 888 && (int) gap <= 130 889 && (int) gap >= -128 890 && last_reloc 891 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8 892 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info) 893 { 894 bfd_vma last_value; 895 asection *last_sym_sec; 896 Elf_Internal_Sym *last_sym; 897 898 /* We will need to examine the symbol used by the 899 previous relocation. */ 900 901 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info); 902 last_sym_sec 903 = bfd_section_from_elf_index (abfd, last_sym->st_shndx); 904 last_value = (last_sym->st_value 905 + last_sym_sec->output_section->vma 906 + last_sym_sec->output_offset); 907 908 /* Verify that the previous relocation was for a 909 branch around this instruction and that no symbol 910 exists at the current location. */ 911 if (last_value == dot + 4 912 && last_reloc->r_offset + 2 == irel->r_offset 913 && ! elf32_h8_symbol_address_p (abfd, sec, dot)) 914 { 915 /* We can eliminate this jump. Twiddle the 916 previous relocation as necessary. */ 917 irel->r_info 918 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 919 ELF32_R_TYPE (R_H8_NONE)); 920 921 last_reloc->r_info 922 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 923 ELF32_R_TYPE (R_H8_PCREL8)); 924 last_reloc->r_addend = irel->r_addend; 925 926 code = bfd_get_8 (abfd, 927 contents + last_reloc->r_offset - 1); 928 code ^= 1; 929 bfd_put_8 (abfd, 930 code, 931 contents + last_reloc->r_offset - 1); 932 933 /* Delete four bytes of data. */ 934 if (!elf32_h8_relax_delete_bytes (abfd, sec, 935 irel->r_offset - 1, 936 4)) 937 goto error_return; 938 939 *again = TRUE; 940 break; 941 } 942 } 943 944 if (code == 0x5e) 945 /* This is jsr24 */ 946 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1); /* bsr8. */ 947 else if (code == 0x5a) 948 /* This is jmp24 */ 949 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1); /* bra8. */ 950 else 951 abort (); 952 953 /* Fix the relocation's type. */ 954 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 955 R_H8_PCREL8); 956 957 /* Delete two bytes of data. */ 958 if (!elf32_h8_relax_delete_bytes (abfd, sec, 959 irel->r_offset + 1, 2)) 960 goto error_return; 961 962 /* That will change things, so, we should relax again. 963 Note that this is not required, and it may be slow. */ 964 *again = TRUE; 965 } 966 break; 967 } 968 969 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative 970 branch. */ 971 case R_H8_PCREL16: 972 { 973 bfd_vma value = symval + irel->r_addend; 974 bfd_vma dot; 975 bfd_vma gap; 976 977 /* Get the address of this instruction. */ 978 dot = (sec->output_section->vma 979 + sec->output_offset 980 + irel->r_offset - 2); 981 982 gap = value - dot; 983 984 /* If the distance is within -126..+130 inclusive, then we can 985 relax this jump. +130 is valid since the target will move 986 two bytes closer if we do relax this branch. */ 987 if ((int) gap >= -126 && (int) gap <= 130) 988 { 989 unsigned char code; 990 991 /* Note that we've changed the relocs, section contents, 992 etc. */ 993 elf_section_data (sec)->relocs = internal_relocs; 994 elf_section_data (sec)->this_hdr.contents = contents; 995 symtab_hdr->contents = (unsigned char *) isymbuf; 996 997 /* Get the opcode. */ 998 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 999 1000 if (code == 0x58) 1001 { 1002 /* bCC:16 -> bCC:8 */ 1003 /* Get the second byte of the original insn, which 1004 contains the condition code. */ 1005 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 1006 1007 /* Compute the first byte of the relaxed 1008 instruction. The original sequence 0x58 0xX0 1009 is relaxed to 0x4X, where X represents the 1010 condition code. */ 1011 code &= 0xf0; 1012 code >>= 4; 1013 code |= 0x40; 1014 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8. */ 1015 } 1016 else if (code == 0x5c) /* bsr16. */ 1017 /* This is bsr. */ 1018 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2); /* bsr8. */ 1019 else 1020 /* Might be MOVSD. */ 1021 break; 1022 1023 /* Fix the relocation's type. */ 1024 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1025 R_H8_PCREL8); 1026 irel->r_offset--; 1027 1028 /* Delete two bytes of data. */ 1029 if (!elf32_h8_relax_delete_bytes (abfd, sec, 1030 irel->r_offset + 1, 2)) 1031 goto error_return; 1032 1033 /* That will change things, so, we should relax again. 1034 Note that this is not required, and it may be slow. */ 1035 *again = TRUE; 1036 } 1037 break; 1038 } 1039 1040 /* This is a 16-bit absolute address in one of the following 1041 instructions: 1042 1043 "band", "bclr", "biand", "bild", "bior", "bist", "bixor", 1044 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and 1045 "mov.b" 1046 1047 We may relax this into an 8-bit absolute address if it's in 1048 the right range. */ 1049 case R_H8_DIR16A8: 1050 { 1051 bfd_vma value; 1052 1053 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend); 1054 if (value >= 0xffffff00u) 1055 { 1056 unsigned char code; 1057 unsigned char temp_code; 1058 1059 /* Note that we've changed the relocs, section contents, 1060 etc. */ 1061 elf_section_data (sec)->relocs = internal_relocs; 1062 elf_section_data (sec)->this_hdr.contents = contents; 1063 symtab_hdr->contents = (unsigned char *) isymbuf; 1064 1065 /* Get the opcode. */ 1066 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 1067 1068 /* All instructions with R_H8_DIR16A8 start with 1069 0x6a. */ 1070 if (code != 0x6a) 1071 abort (); 1072 1073 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 1074 /* If this is a mov.b instruction, clear the lower 1075 nibble, which contains the source/destination 1076 register number. */ 1077 if ((temp_code & 0x10) != 0x10) 1078 temp_code &= 0xf0; 1079 1080 switch (temp_code) 1081 { 1082 case 0x00: 1083 /* This is mov.b @aa:16,Rd. */ 1084 bfd_put_8 (abfd, (code & 0xf) | 0x20, 1085 contents + irel->r_offset - 2); 1086 break; 1087 case 0x80: 1088 /* This is mov.b Rs,@aa:16. */ 1089 bfd_put_8 (abfd, (code & 0xf) | 0x30, 1090 contents + irel->r_offset - 2); 1091 break; 1092 case 0x18: 1093 /* This is a bit-maniputation instruction that 1094 stores one bit into memory, one of "bclr", 1095 "bist", "bnot", "bset", and "bst". */ 1096 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2); 1097 break; 1098 case 0x10: 1099 /* This is a bit-maniputation instruction that 1100 loads one bit from memory, one of "band", 1101 "biand", "bild", "bior", "bixor", "bld", "bor", 1102 "btst", and "bxor". */ 1103 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2); 1104 break; 1105 default: 1106 abort (); 1107 } 1108 1109 /* Fix the relocation's type. */ 1110 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1111 R_H8_DIR8); 1112 1113 /* Move the relocation. */ 1114 irel->r_offset--; 1115 1116 /* Delete two bytes of data. */ 1117 if (!elf32_h8_relax_delete_bytes (abfd, sec, 1118 irel->r_offset + 1, 2)) 1119 goto error_return; 1120 1121 /* That will change things, so, we should relax again. 1122 Note that this is not required, and it may be slow. */ 1123 *again = TRUE; 1124 } 1125 break; 1126 } 1127 1128 /* This is a 24-bit absolute address in one of the following 1129 instructions: 1130 1131 "band", "bclr", "biand", "bild", "bior", "bist", "bixor", 1132 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and 1133 "mov.b" 1134 1135 We may relax this into an 8-bit absolute address if it's in 1136 the right range. */ 1137 case R_H8_DIR24A8: 1138 { 1139 bfd_vma value; 1140 1141 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend); 1142 if (value >= 0xffffff00u) 1143 { 1144 unsigned char code; 1145 unsigned char temp_code; 1146 1147 /* Note that we've changed the relocs, section contents, 1148 etc. */ 1149 elf_section_data (sec)->relocs = internal_relocs; 1150 elf_section_data (sec)->this_hdr.contents = contents; 1151 symtab_hdr->contents = (unsigned char *) isymbuf; 1152 1153 /* Get the opcode. */ 1154 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 1155 1156 /* All instructions with R_H8_DIR24A8 start with 1157 0x6a. */ 1158 if (code != 0x6a) 1159 abort (); 1160 1161 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 1162 1163 /* If this is a mov.b instruction, clear the lower 1164 nibble, which contains the source/destination 1165 register number. */ 1166 if ((temp_code & 0x30) != 0x30) 1167 temp_code &= 0xf0; 1168 1169 switch (temp_code) 1170 { 1171 case 0x20: 1172 /* This is mov.b @aa:24/32,Rd. */ 1173 bfd_put_8 (abfd, (code & 0xf) | 0x20, 1174 contents + irel->r_offset - 2); 1175 break; 1176 case 0xa0: 1177 /* This is mov.b Rs,@aa:24/32. */ 1178 bfd_put_8 (abfd, (code & 0xf) | 0x30, 1179 contents + irel->r_offset - 2); 1180 break; 1181 case 0x38: 1182 /* This is a bit-maniputation instruction that 1183 stores one bit into memory, one of "bclr", 1184 "bist", "bnot", "bset", and "bst". */ 1185 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2); 1186 break; 1187 case 0x30: 1188 /* This is a bit-maniputation instruction that 1189 loads one bit from memory, one of "band", 1190 "biand", "bild", "bior", "bixor", "bld", "bor", 1191 "btst", and "bxor". */ 1192 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2); 1193 break; 1194 default: 1195 abort(); 1196 } 1197 1198 /* Fix the relocation's type. */ 1199 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1200 R_H8_DIR8); 1201 irel->r_offset--; 1202 1203 /* Delete four bytes of data. */ 1204 if (!elf32_h8_relax_delete_bytes (abfd, sec, 1205 irel->r_offset + 1, 4)) 1206 goto error_return; 1207 1208 /* That will change things, so, we should relax again. 1209 Note that this is not required, and it may be slow. */ 1210 *again = TRUE; 1211 break; 1212 } 1213 } 1214 1215 /* Fall through. */ 1216 1217 /* This is a 24-/32-bit absolute address in one of the 1218 following instructions: 1219 1220 "band", "bclr", "biand", "bild", "bior", "bist", 1221 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst", 1222 "bxor", "ldc.w", "stc.w" and "mov.[bwl]" 1223 1224 We may relax this into an 16-bit absolute address if it's 1225 in the right range. */ 1226 case R_H8_DIR32A16: 1227 { 1228 bfd_vma value; 1229 1230 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend); 1231 if (value <= 0x7fff || value >= 0xffff8000u) 1232 { 1233 unsigned char code; 1234 unsigned char op0, op1, op2, op3; 1235 unsigned char *op_ptr; 1236 1237 /* Note that we've changed the relocs, section contents, 1238 etc. */ 1239 elf_section_data (sec)->relocs = internal_relocs; 1240 elf_section_data (sec)->this_hdr.contents = contents; 1241 symtab_hdr->contents = (unsigned char *) isymbuf; 1242 1243 if (irel->r_offset >= 4) 1244 { 1245 /* Check for 4-byte MOVA relaxation (SH-specific). */ 1246 int second_reloc = 0; 1247 1248 op_ptr = contents + irel->r_offset - 4; 1249 1250 if (last_reloc) 1251 { 1252 arelent bfd_reloc; 1253 reloc_howto_type *h; 1254 bfd_vma last_reloc_size; 1255 1256 elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc); 1257 h = bfd_reloc.howto; 1258 last_reloc_size = 1 << h->size; 1259 if (last_reloc->r_offset + last_reloc_size 1260 == irel->r_offset) 1261 { 1262 op_ptr -= last_reloc_size; 1263 second_reloc = 1; 1264 } 1265 } 1266 1267 if (irel + 1 < irelend) 1268 { 1269 Elf_Internal_Rela *next_reloc = irel + 1; 1270 arelent bfd_reloc; 1271 reloc_howto_type *h; 1272 bfd_vma next_reloc_size; 1273 1274 elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc); 1275 h = bfd_reloc.howto; 1276 next_reloc_size = 1 << h->size; 1277 if (next_reloc->r_offset + next_reloc_size 1278 == irel->r_offset) 1279 { 1280 op_ptr -= next_reloc_size; 1281 second_reloc = 1; 1282 } 1283 } 1284 1285 op0 = bfd_get_8 (abfd, op_ptr + 0); 1286 op1 = bfd_get_8 (abfd, op_ptr + 1); 1287 op2 = bfd_get_8 (abfd, op_ptr + 2); 1288 op3 = bfd_get_8 (abfd, op_ptr + 3); 1289 1290 if (op0 == 0x01 1291 && (op1 & 0xdf) == 0x5f 1292 && (op2 & 0x40) == 0x40 1293 && (op3 & 0x80) == 0x80) 1294 { 1295 if ((op2 & 0x08) == 0) 1296 second_reloc = 1; 1297 1298 if (second_reloc) 1299 { 1300 op3 &= ~0x08; 1301 bfd_put_8 (abfd, op3, op_ptr + 3); 1302 } 1303 else 1304 { 1305 op2 &= ~0x08; 1306 bfd_put_8 (abfd, op2, op_ptr + 2); 1307 } 1308 goto r_h8_dir32a16_common; 1309 } 1310 } 1311 1312 /* Now check for short version of MOVA. (SH-specific) */ 1313 op_ptr = contents + irel->r_offset - 2; 1314 op0 = bfd_get_8 (abfd, op_ptr + 0); 1315 op1 = bfd_get_8 (abfd, op_ptr + 1); 1316 1317 if (op0 == 0x7a 1318 && (op1 & 0x88) == 0x80) 1319 { 1320 op1 |= 0x08; 1321 bfd_put_8 (abfd, op1, op_ptr + 1); 1322 goto r_h8_dir32a16_common; 1323 } 1324 1325 /* Get the opcode. */ 1326 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 1327 1328 /* Fix the opcode. For all the instructions that 1329 belong to this relaxation, we simply need to turn 1330 off bit 0x20 in the previous byte. */ 1331 code &= ~0x20; 1332 1333 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 1334 1335 r_h8_dir32a16_common: 1336 /* Fix the relocation's type. */ 1337 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1338 R_H8_DIR16); 1339 1340 /* Delete two bytes of data. */ 1341 if (!elf32_h8_relax_delete_bytes (abfd, sec, 1342 irel->r_offset + 1, 2)) 1343 goto error_return; 1344 1345 /* That will change things, so, we should relax again. 1346 Note that this is not required, and it may be slow. */ 1347 *again = TRUE; 1348 } 1349 break; /* case R_H8_DIR32A16 */ 1350 } 1351 1352 case R_H8_DISP32A16: 1353 /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes 1354 It is assured that instruction uses at least 4 bytes opcode before 1355 reloc entry addressing mode "register indirect with displacement" 1356 relaxing options (all saving 4 bytes): 1357 0x78 0sss0000 0x6A 0010dddd disp:32 mov.b @(d:32,ERs),Rd -> 1358 0x6E 0sssdddd disp:16 mov.b @(d:16,ERs),Rd 1359 0x78 0sss0000 0x6B 0010dddd disp:32 mov.w @(d:32,ERs),Rd -> 1360 0x6F 0sssdddd disp:16 mov.w @(d:16,ERs),Rd 1361 0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32 mov.l @(d:32,ERs),ERd -> 1362 0x01 0x00 0x6F 0sss0ddd disp:16 mov.l @(d:16,ERs),ERd 1363 1364 0x78 0ddd0000 0x6A 1010ssss disp:32 mov.b Rs,@(d:32,ERd) -> 1365 0x6E 1dddssss disp:16 mov.b Rs,@(d:16,ERd) 1366 0x78 0ddd0000 0x6B 1010ssss disp:32 mov.w Rs,@(d:32,ERd) -> 1367 0x6F 1dddssss disp:16 mov.w Rs,@(d:16,ERd) 1368 0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32 mov.l ERs,@(d:32,ERd) -> 1369 0x01 0x00 0x6F 1ddd0sss disp:16 mov.l ERs,@(d:16,ERd) 1370 mov.l prefix 0x01 0x00 can be left as is and mov.l handled same 1371 as mov.w/ */ 1372 { 1373 bfd_vma value; 1374 1375 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend); 1376 if (value <= 0x7fff || value >= 0xffff8000u) 1377 { 1378 unsigned char op0, op1, op2, op3, op0n, op1n; 1379 int relax = 0; 1380 1381 /* Note that we've changed the relocs, section contents, 1382 etc. */ 1383 elf_section_data (sec)->relocs = internal_relocs; 1384 elf_section_data (sec)->this_hdr.contents = contents; 1385 symtab_hdr->contents = (unsigned char *) isymbuf; 1386 1387 if (irel->r_offset >= 4) 1388 { 1389 op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4); 1390 op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3); 1391 op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2); 1392 op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1); 1393 1394 if (op0 == 0x78) 1395 { 1396 switch(op2) 1397 { 1398 case 0x6A: 1399 if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20) 1400 { 1401 /* mov.b. */ 1402 op0n = 0x6E; 1403 relax = 1; 1404 } 1405 break; 1406 case 0x6B: 1407 if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20) 1408 { 1409 /* mov.w/l. */ 1410 op0n = 0x6F; 1411 relax = 1; 1412 } 1413 break; 1414 default: 1415 break; 1416 } 1417 } 1418 } 1419 1420 if (relax) 1421 { 1422 op1n = (op3 & 0x8F) | (op1 & 0x70); 1423 bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4); 1424 bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3); 1425 1426 /* Fix the relocation's type. */ 1427 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16); 1428 irel->r_offset -= 2; 1429 1430 /* Delete four bytes of data. */ 1431 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4)) 1432 goto error_return; 1433 1434 /* That will change things, so, we should relax again. 1435 Note that this is not required, and it may be slow. */ 1436 *again = TRUE; 1437 } 1438 } 1439 } 1440 break; 1441 1442 default: 1443 break; 1444 } 1445 } 1446 1447 if (isymbuf != NULL 1448 && symtab_hdr->contents != (unsigned char *) isymbuf) 1449 { 1450 if (! link_info->keep_memory) 1451 free (isymbuf); 1452 else 1453 symtab_hdr->contents = (unsigned char *) isymbuf; 1454 } 1455 1456 if (contents != NULL 1457 && elf_section_data (sec)->this_hdr.contents != contents) 1458 { 1459 if (! link_info->keep_memory) 1460 free (contents); 1461 else 1462 { 1463 /* Cache the section contents for elf_link_input_bfd. */ 1464 elf_section_data (sec)->this_hdr.contents = contents; 1465 } 1466 } 1467 1468 if (internal_relocs != NULL 1469 && elf_section_data (sec)->relocs != internal_relocs) 1470 free (internal_relocs); 1471 1472 return TRUE; 1473 1474 error_return: 1475 if (isymbuf != NULL 1476 && symtab_hdr->contents != (unsigned char *) isymbuf) 1477 free (isymbuf); 1478 if (contents != NULL 1479 && elf_section_data (sec)->this_hdr.contents != contents) 1480 free (contents); 1481 if (internal_relocs != NULL 1482 && elf_section_data (sec)->relocs != internal_relocs) 1483 free (internal_relocs); 1484 return FALSE; 1485 } 1486 1487 /* Delete some bytes from a section while relaxing. */ 1488 1489 static bfd_boolean 1490 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count) 1491 { 1492 Elf_Internal_Shdr *symtab_hdr; 1493 unsigned int sec_shndx; 1494 bfd_byte *contents; 1495 Elf_Internal_Rela *irel, *irelend; 1496 Elf_Internal_Sym *isym; 1497 Elf_Internal_Sym *isymend; 1498 bfd_vma toaddr; 1499 struct elf_link_hash_entry **sym_hashes; 1500 struct elf_link_hash_entry **end_hashes; 1501 unsigned int symcount; 1502 1503 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1504 1505 contents = elf_section_data (sec)->this_hdr.contents; 1506 1507 toaddr = sec->size; 1508 1509 irel = elf_section_data (sec)->relocs; 1510 irelend = irel + sec->reloc_count; 1511 1512 /* Actually delete the bytes. */ 1513 memmove (contents + addr, contents + addr + count, 1514 (size_t) (toaddr - addr - count)); 1515 sec->size -= count; 1516 1517 /* Adjust all the relocs. */ 1518 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 1519 { 1520 /* Get the new reloc address. */ 1521 if ((irel->r_offset > addr 1522 && irel->r_offset <= toaddr)) 1523 irel->r_offset -= count; 1524 } 1525 1526 /* Adjust the local symbols defined in this section. */ 1527 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1528 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1529 isymend = isym + symtab_hdr->sh_info; 1530 for (; isym < isymend; isym++) 1531 { 1532 if (isym->st_shndx == sec_shndx 1533 && isym->st_value > addr 1534 && isym->st_value <= toaddr) 1535 isym->st_value -= count; 1536 } 1537 1538 /* Now adjust the global symbols defined in this section. */ 1539 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1540 - symtab_hdr->sh_info); 1541 sym_hashes = elf_sym_hashes (abfd); 1542 end_hashes = sym_hashes + symcount; 1543 for (; sym_hashes < end_hashes; sym_hashes++) 1544 { 1545 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1546 1547 if ((sym_hash->root.type == bfd_link_hash_defined 1548 || sym_hash->root.type == bfd_link_hash_defweak) 1549 && sym_hash->root.u.def.section == sec 1550 && sym_hash->root.u.def.value > addr 1551 && sym_hash->root.u.def.value <= toaddr) 1552 sym_hash->root.u.def.value -= count; 1553 } 1554 1555 return TRUE; 1556 } 1557 1558 /* Return TRUE if a symbol exists at the given address, else return 1559 FALSE. */ 1560 static bfd_boolean 1561 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr) 1562 { 1563 Elf_Internal_Shdr *symtab_hdr; 1564 unsigned int sec_shndx; 1565 Elf_Internal_Sym *isym; 1566 Elf_Internal_Sym *isymend; 1567 struct elf_link_hash_entry **sym_hashes; 1568 struct elf_link_hash_entry **end_hashes; 1569 unsigned int symcount; 1570 1571 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 1572 1573 /* Examine all the symbols. */ 1574 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1575 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 1576 isymend = isym + symtab_hdr->sh_info; 1577 for (; isym < isymend; isym++) 1578 { 1579 if (isym->st_shndx == sec_shndx 1580 && isym->st_value == addr) 1581 return TRUE; 1582 } 1583 1584 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1585 - symtab_hdr->sh_info); 1586 sym_hashes = elf_sym_hashes (abfd); 1587 end_hashes = sym_hashes + symcount; 1588 for (; sym_hashes < end_hashes; sym_hashes++) 1589 { 1590 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1591 if ((sym_hash->root.type == bfd_link_hash_defined 1592 || sym_hash->root.type == bfd_link_hash_defweak) 1593 && sym_hash->root.u.def.section == sec 1594 && sym_hash->root.u.def.value == addr) 1595 return TRUE; 1596 } 1597 1598 return FALSE; 1599 } 1600 1601 /* This is a version of bfd_generic_get_relocated_section_contents 1602 which uses elf32_h8_relocate_section. */ 1603 1604 static bfd_byte * 1605 elf32_h8_get_relocated_section_contents (bfd *output_bfd, 1606 struct bfd_link_info *link_info, 1607 struct bfd_link_order *link_order, 1608 bfd_byte *data, 1609 bfd_boolean relocatable, 1610 asymbol **symbols) 1611 { 1612 Elf_Internal_Shdr *symtab_hdr; 1613 asection *input_section = link_order->u.indirect.section; 1614 bfd *input_bfd = input_section->owner; 1615 asection **sections = NULL; 1616 Elf_Internal_Rela *internal_relocs = NULL; 1617 Elf_Internal_Sym *isymbuf = NULL; 1618 1619 /* We only need to handle the case of relaxing, or of having a 1620 particular set of section contents, specially. */ 1621 if (relocatable 1622 || elf_section_data (input_section)->this_hdr.contents == NULL) 1623 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1624 link_order, data, 1625 relocatable, 1626 symbols); 1627 1628 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1629 1630 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 1631 (size_t) input_section->size); 1632 1633 if ((input_section->flags & SEC_RELOC) != 0 1634 && input_section->reloc_count > 0) 1635 { 1636 asection **secpp; 1637 Elf_Internal_Sym *isym, *isymend; 1638 bfd_size_type amt; 1639 1640 internal_relocs = (_bfd_elf_link_read_relocs 1641 (input_bfd, input_section, NULL, 1642 (Elf_Internal_Rela *) NULL, FALSE)); 1643 if (internal_relocs == NULL) 1644 goto error_return; 1645 1646 if (symtab_hdr->sh_info != 0) 1647 { 1648 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1649 if (isymbuf == NULL) 1650 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 1651 symtab_hdr->sh_info, 0, 1652 NULL, NULL, NULL); 1653 if (isymbuf == NULL) 1654 goto error_return; 1655 } 1656 1657 amt = symtab_hdr->sh_info; 1658 amt *= sizeof (asection *); 1659 sections = (asection **) bfd_malloc (amt); 1660 if (sections == NULL && amt != 0) 1661 goto error_return; 1662 1663 isymend = isymbuf + symtab_hdr->sh_info; 1664 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 1665 { 1666 asection *isec; 1667 1668 if (isym->st_shndx == SHN_UNDEF) 1669 isec = bfd_und_section_ptr; 1670 else if (isym->st_shndx == SHN_ABS) 1671 isec = bfd_abs_section_ptr; 1672 else if (isym->st_shndx == SHN_COMMON) 1673 isec = bfd_com_section_ptr; 1674 else 1675 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 1676 1677 *secpp = isec; 1678 } 1679 1680 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd, 1681 input_section, data, internal_relocs, 1682 isymbuf, sections)) 1683 goto error_return; 1684 1685 if (sections != NULL) 1686 free (sections); 1687 if (isymbuf != NULL 1688 && symtab_hdr->contents != (unsigned char *) isymbuf) 1689 free (isymbuf); 1690 if (elf_section_data (input_section)->relocs != internal_relocs) 1691 free (internal_relocs); 1692 } 1693 1694 return data; 1695 1696 error_return: 1697 if (sections != NULL) 1698 free (sections); 1699 if (isymbuf != NULL 1700 && symtab_hdr->contents != (unsigned char *) isymbuf) 1701 free (isymbuf); 1702 if (internal_relocs != NULL 1703 && elf_section_data (input_section)->relocs != internal_relocs) 1704 free (internal_relocs); 1705 return NULL; 1706 } 1707 1708 1709 #define TARGET_BIG_SYM h8300_elf32_vec 1710 #define TARGET_BIG_NAME "elf32-h8300" 1711 #define ELF_ARCH bfd_arch_h8300 1712 #define ELF_MACHINE_CODE EM_H8_300 1713 #define ELF_MAXPAGESIZE 0x1 1714 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup 1715 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup 1716 #define elf_info_to_howto elf32_h8_info_to_howto 1717 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel 1718 1719 /* So we can set/examine bits in e_flags to get the specific 1720 H8 architecture in use. */ 1721 #define elf_backend_final_write_processing \ 1722 elf32_h8_final_write_processing 1723 #define elf_backend_object_p \ 1724 elf32_h8_object_p 1725 #define bfd_elf32_bfd_merge_private_bfd_data \ 1726 elf32_h8_merge_private_bfd_data 1727 1728 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h 1729 defaults to using _bfd_generic_link_hash_table_create, but 1730 bfd_elf_size_dynamic_sections uses 1731 dynobj = elf_hash_table (info)->dynobj; 1732 and thus requires an elf hash table. */ 1733 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create 1734 1735 /* Use an H8 specific linker, not the ELF generic linker. */ 1736 #define elf_backend_relocate_section elf32_h8_relocate_section 1737 #define elf_backend_rela_normal 1 1738 #define elf_backend_can_gc_sections 1 1739 1740 /* And relaxing stuff. */ 1741 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section 1742 #define bfd_elf32_bfd_get_relocated_section_contents \ 1743 elf32_h8_get_relocated_section_contents 1744 1745 #define elf_symbol_leading_char '_' 1746 1747 #include "elf32-target.h" 1748 1749 #undef TARGET_BIG_SYM 1750 #define TARGET_BIG_SYM h8300_elf32_linux_vec 1751 #undef TARGET_BIG_NAME 1752 #define TARGET_BIG_NAME "elf32-h8300-linux" 1753 #undef elf_symbol_leading_char 1754 #define elf32_bed elf32_h8300_linux_bed 1755 1756 #include "elf32-target.h" 1757
Indexes created Wed Mar 25 00:23:37 UTC 2026