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