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