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