1 /* Motorola 68HC11/HC12-specific support for 32-bit ELF 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 3 Free Software Foundation, Inc. 4 Contributed by Stephane Carrez (stcarrez@nerim.fr) 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include "bfd.h" 25 #include "bfdlink.h" 26 #include "libbfd.h" 27 #include "elf-bfd.h" 28 #include "elf32-m68hc1x.h" 29 #include "elf/m68hc11.h" 30 #include "opcode/m68hc11.h" 31 32 33 #define m68hc12_stub_hash_lookup(table, string, create, copy) \ 34 ((struct elf32_m68hc11_stub_hash_entry *) \ 35 bfd_hash_lookup ((table), (string), (create), (copy))) 36 37 static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub 38 (const char *stub_name, 39 asection *section, 40 struct m68hc11_elf_link_hash_table *htab); 41 42 static struct bfd_hash_entry *stub_hash_newfunc 43 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); 44 45 static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info, 46 const char* name, bfd_vma value, 47 asection* sec); 48 49 static bfd_boolean m68hc11_elf_export_one_stub 50 (struct bfd_hash_entry *gen_entry, void *in_arg); 51 52 static void scan_sections_for_abi (bfd*, asection*, PTR); 53 54 struct m68hc11_scan_param 55 { 56 struct m68hc11_page_info* pinfo; 57 bfd_boolean use_memory_banks; 58 }; 59 60 61 /* Create a 68HC11/68HC12 ELF linker hash table. */ 62 63 struct m68hc11_elf_link_hash_table* 64 m68hc11_elf_hash_table_create (bfd *abfd) 65 { 66 struct m68hc11_elf_link_hash_table *ret; 67 bfd_size_type amt = sizeof (struct m68hc11_elf_link_hash_table); 68 69 ret = (struct m68hc11_elf_link_hash_table *) bfd_malloc (amt); 70 if (ret == (struct m68hc11_elf_link_hash_table *) NULL) 71 return NULL; 72 73 memset (ret, 0, amt); 74 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 75 _bfd_elf_link_hash_newfunc, 76 sizeof (struct elf_link_hash_entry))) 77 { 78 free (ret); 79 return NULL; 80 } 81 82 /* Init the stub hash table too. */ 83 amt = sizeof (struct bfd_hash_table); 84 ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt); 85 if (ret->stub_hash_table == NULL) 86 { 87 free (ret); 88 return NULL; 89 } 90 if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc, 91 sizeof (struct elf32_m68hc11_stub_hash_entry))) 92 return NULL; 93 94 ret->stub_bfd = NULL; 95 ret->stub_section = 0; 96 ret->add_stub_section = NULL; 97 ret->sym_sec.abfd = NULL; 98 99 return ret; 100 } 101 102 /* Free the derived linker hash table. */ 103 104 void 105 m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table *hash) 106 { 107 struct m68hc11_elf_link_hash_table *ret 108 = (struct m68hc11_elf_link_hash_table *) hash; 109 110 bfd_hash_table_free (ret->stub_hash_table); 111 free (ret->stub_hash_table); 112 _bfd_generic_link_hash_table_free (hash); 113 } 114 115 /* Assorted hash table functions. */ 116 117 /* Initialize an entry in the stub hash table. */ 118 119 static struct bfd_hash_entry * 120 stub_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table, 121 const char *string) 122 { 123 /* Allocate the structure if it has not already been allocated by a 124 subclass. */ 125 if (entry == NULL) 126 { 127 entry = bfd_hash_allocate (table, 128 sizeof (struct elf32_m68hc11_stub_hash_entry)); 129 if (entry == NULL) 130 return entry; 131 } 132 133 /* Call the allocation method of the superclass. */ 134 entry = bfd_hash_newfunc (entry, table, string); 135 if (entry != NULL) 136 { 137 struct elf32_m68hc11_stub_hash_entry *eh; 138 139 /* Initialize the local fields. */ 140 eh = (struct elf32_m68hc11_stub_hash_entry *) entry; 141 eh->stub_sec = NULL; 142 eh->stub_offset = 0; 143 eh->target_value = 0; 144 eh->target_section = NULL; 145 } 146 147 return entry; 148 } 149 150 /* Add a new stub entry to the stub hash. Not all fields of the new 151 stub entry are initialised. */ 152 153 static struct elf32_m68hc11_stub_hash_entry * 154 m68hc12_add_stub (const char *stub_name, asection *section, 155 struct m68hc11_elf_link_hash_table *htab) 156 { 157 struct elf32_m68hc11_stub_hash_entry *stub_entry; 158 159 /* Enter this entry into the linker stub hash table. */ 160 stub_entry = m68hc12_stub_hash_lookup (htab->stub_hash_table, stub_name, 161 TRUE, FALSE); 162 if (stub_entry == NULL) 163 { 164 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"), 165 section->owner, stub_name); 166 return NULL; 167 } 168 169 if (htab->stub_section == 0) 170 { 171 htab->stub_section = (*htab->add_stub_section) (".tramp", 172 htab->tramp_section); 173 } 174 175 stub_entry->stub_sec = htab->stub_section; 176 stub_entry->stub_offset = 0; 177 return stub_entry; 178 } 179 180 /* Hook called by the linker routine which adds symbols from an object 181 file. We use it for identify far symbols and force a loading of 182 the trampoline handler. */ 183 184 bfd_boolean 185 elf32_m68hc11_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, 186 Elf_Internal_Sym *sym, 187 const char **namep ATTRIBUTE_UNUSED, 188 flagword *flagsp ATTRIBUTE_UNUSED, 189 asection **secp ATTRIBUTE_UNUSED, 190 bfd_vma *valp ATTRIBUTE_UNUSED) 191 { 192 if (sym->st_other & STO_M68HC12_FAR) 193 { 194 struct elf_link_hash_entry *h; 195 196 h = (struct elf_link_hash_entry *) 197 bfd_link_hash_lookup (info->hash, "__far_trampoline", 198 FALSE, FALSE, FALSE); 199 if (h == NULL) 200 { 201 struct bfd_link_hash_entry* entry = NULL; 202 203 _bfd_generic_link_add_one_symbol (info, abfd, 204 "__far_trampoline", 205 BSF_GLOBAL, 206 bfd_und_section_ptr, 207 (bfd_vma) 0, (const char*) NULL, 208 FALSE, FALSE, &entry); 209 } 210 211 } 212 return TRUE; 213 } 214 215 /* External entry points for sizing and building linker stubs. */ 216 217 /* Set up various things so that we can make a list of input sections 218 for each output section included in the link. Returns -1 on error, 219 0 when no stubs will be needed, and 1 on success. */ 220 221 int 222 elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info) 223 { 224 bfd *input_bfd; 225 unsigned int bfd_count; 226 int top_id, top_index; 227 asection *section; 228 asection **input_list, **list; 229 bfd_size_type amt; 230 asection *text_section; 231 struct m68hc11_elf_link_hash_table *htab; 232 233 htab = m68hc11_elf_hash_table (info); 234 235 if (bfd_get_flavour (info->output_bfd) != bfd_target_elf_flavour) 236 return 0; 237 238 /* Count the number of input BFDs and find the top input section id. 239 Also search for an existing ".tramp" section so that we know 240 where generated trampolines must go. Default to ".text" if we 241 can't find it. */ 242 htab->tramp_section = 0; 243 text_section = 0; 244 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0; 245 input_bfd != NULL; 246 input_bfd = input_bfd->link_next) 247 { 248 bfd_count += 1; 249 for (section = input_bfd->sections; 250 section != NULL; 251 section = section->next) 252 { 253 const char* name = bfd_get_section_name (input_bfd, section); 254 255 if (!strcmp (name, ".tramp")) 256 htab->tramp_section = section; 257 258 if (!strcmp (name, ".text")) 259 text_section = section; 260 261 if (top_id < section->id) 262 top_id = section->id; 263 } 264 } 265 htab->bfd_count = bfd_count; 266 if (htab->tramp_section == 0) 267 htab->tramp_section = text_section; 268 269 /* We can't use output_bfd->section_count here to find the top output 270 section index as some sections may have been removed, and 271 strip_excluded_output_sections doesn't renumber the indices. */ 272 for (section = output_bfd->sections, top_index = 0; 273 section != NULL; 274 section = section->next) 275 { 276 if (top_index < section->index) 277 top_index = section->index; 278 } 279 280 htab->top_index = top_index; 281 amt = sizeof (asection *) * (top_index + 1); 282 input_list = (asection **) bfd_malloc (amt); 283 htab->input_list = input_list; 284 if (input_list == NULL) 285 return -1; 286 287 /* For sections we aren't interested in, mark their entries with a 288 value we can check later. */ 289 list = input_list + top_index; 290 do 291 *list = bfd_abs_section_ptr; 292 while (list-- != input_list); 293 294 for (section = output_bfd->sections; 295 section != NULL; 296 section = section->next) 297 { 298 if ((section->flags & SEC_CODE) != 0) 299 input_list[section->index] = NULL; 300 } 301 302 return 1; 303 } 304 305 /* Determine and set the size of the stub section for a final link. 306 307 The basic idea here is to examine all the relocations looking for 308 PC-relative calls to a target that is unreachable with a "bl" 309 instruction. */ 310 311 bfd_boolean 312 elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd, 313 struct bfd_link_info *info, 314 asection * (*add_stub_section) (const char*, asection*)) 315 { 316 bfd *input_bfd; 317 asection *section; 318 Elf_Internal_Sym *local_syms, **all_local_syms; 319 unsigned int bfd_indx, bfd_count; 320 bfd_size_type amt; 321 asection *stub_sec; 322 323 struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info); 324 325 /* Stash our params away. */ 326 htab->stub_bfd = stub_bfd; 327 htab->add_stub_section = add_stub_section; 328 329 /* Count the number of input BFDs and find the top input section id. */ 330 for (input_bfd = info->input_bfds, bfd_count = 0; 331 input_bfd != NULL; 332 input_bfd = input_bfd->link_next) 333 { 334 bfd_count += 1; 335 } 336 337 /* We want to read in symbol extension records only once. To do this 338 we need to read in the local symbols in parallel and save them for 339 later use; so hold pointers to the local symbols in an array. */ 340 amt = sizeof (Elf_Internal_Sym *) * bfd_count; 341 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt); 342 if (all_local_syms == NULL) 343 return FALSE; 344 345 /* Walk over all the input BFDs, swapping in local symbols. */ 346 for (input_bfd = info->input_bfds, bfd_indx = 0; 347 input_bfd != NULL; 348 input_bfd = input_bfd->link_next, bfd_indx++) 349 { 350 Elf_Internal_Shdr *symtab_hdr; 351 352 /* We'll need the symbol table in a second. */ 353 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 354 if (symtab_hdr->sh_info == 0) 355 continue; 356 357 /* We need an array of the local symbols attached to the input bfd. */ 358 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents; 359 if (local_syms == NULL) 360 { 361 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 362 symtab_hdr->sh_info, 0, 363 NULL, NULL, NULL); 364 /* Cache them for elf_link_input_bfd. */ 365 symtab_hdr->contents = (unsigned char *) local_syms; 366 } 367 if (local_syms == NULL) 368 { 369 free (all_local_syms); 370 return FALSE; 371 } 372 373 all_local_syms[bfd_indx] = local_syms; 374 } 375 376 for (input_bfd = info->input_bfds, bfd_indx = 0; 377 input_bfd != NULL; 378 input_bfd = input_bfd->link_next, bfd_indx++) 379 { 380 Elf_Internal_Shdr *symtab_hdr; 381 Elf_Internal_Sym *local_syms; 382 struct elf_link_hash_entry ** sym_hashes; 383 384 sym_hashes = elf_sym_hashes (input_bfd); 385 386 /* We'll need the symbol table in a second. */ 387 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 388 if (symtab_hdr->sh_info == 0) 389 continue; 390 391 local_syms = all_local_syms[bfd_indx]; 392 393 /* Walk over each section attached to the input bfd. */ 394 for (section = input_bfd->sections; 395 section != NULL; 396 section = section->next) 397 { 398 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 399 400 /* If there aren't any relocs, then there's nothing more 401 to do. */ 402 if ((section->flags & SEC_RELOC) == 0 403 || section->reloc_count == 0) 404 continue; 405 406 /* If this section is a link-once section that will be 407 discarded, then don't create any stubs. */ 408 if (section->output_section == NULL 409 || section->output_section->owner != output_bfd) 410 continue; 411 412 /* Get the relocs. */ 413 internal_relocs 414 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, 415 (Elf_Internal_Rela *) NULL, 416 info->keep_memory); 417 if (internal_relocs == NULL) 418 goto error_ret_free_local; 419 420 /* Now examine each relocation. */ 421 irela = internal_relocs; 422 irelaend = irela + section->reloc_count; 423 for (; irela < irelaend; irela++) 424 { 425 unsigned int r_type, r_indx; 426 struct elf32_m68hc11_stub_hash_entry *stub_entry; 427 asection *sym_sec; 428 bfd_vma sym_value; 429 struct elf_link_hash_entry *hash; 430 const char *stub_name; 431 Elf_Internal_Sym *sym; 432 433 r_type = ELF32_R_TYPE (irela->r_info); 434 435 /* Only look at 16-bit relocs. */ 436 if (r_type != (unsigned int) R_M68HC11_16) 437 continue; 438 439 /* Now determine the call target, its name, value, 440 section. */ 441 r_indx = ELF32_R_SYM (irela->r_info); 442 if (r_indx < symtab_hdr->sh_info) 443 { 444 /* It's a local symbol. */ 445 Elf_Internal_Shdr *hdr; 446 bfd_boolean is_far; 447 448 sym = local_syms + r_indx; 449 is_far = (sym && (sym->st_other & STO_M68HC12_FAR)); 450 if (!is_far) 451 continue; 452 453 if (sym->st_shndx >= elf_numsections (input_bfd)) 454 sym_sec = NULL; 455 else 456 { 457 hdr = elf_elfsections (input_bfd)[sym->st_shndx]; 458 sym_sec = hdr->bfd_section; 459 } 460 stub_name = (bfd_elf_string_from_elf_section 461 (input_bfd, symtab_hdr->sh_link, 462 sym->st_name)); 463 sym_value = sym->st_value; 464 hash = NULL; 465 } 466 else 467 { 468 /* It's an external symbol. */ 469 int e_indx; 470 471 e_indx = r_indx - symtab_hdr->sh_info; 472 hash = (struct elf_link_hash_entry *) 473 (sym_hashes[e_indx]); 474 475 while (hash->root.type == bfd_link_hash_indirect 476 || hash->root.type == bfd_link_hash_warning) 477 hash = ((struct elf_link_hash_entry *) 478 hash->root.u.i.link); 479 480 if (hash->root.type == bfd_link_hash_defined 481 || hash->root.type == bfd_link_hash_defweak 482 || hash->root.type == bfd_link_hash_new) 483 { 484 if (!(hash->other & STO_M68HC12_FAR)) 485 continue; 486 } 487 else if (hash->root.type == bfd_link_hash_undefweak) 488 { 489 continue; 490 } 491 else if (hash->root.type == bfd_link_hash_undefined) 492 { 493 continue; 494 } 495 else 496 { 497 bfd_set_error (bfd_error_bad_value); 498 goto error_ret_free_internal; 499 } 500 sym_sec = hash->root.u.def.section; 501 sym_value = hash->root.u.def.value; 502 stub_name = hash->root.root.string; 503 } 504 505 if (!stub_name) 506 goto error_ret_free_internal; 507 508 stub_entry = m68hc12_stub_hash_lookup 509 (htab->stub_hash_table, 510 stub_name, 511 FALSE, FALSE); 512 if (stub_entry == NULL) 513 { 514 if (add_stub_section == 0) 515 continue; 516 517 stub_entry = m68hc12_add_stub (stub_name, section, htab); 518 if (stub_entry == NULL) 519 { 520 error_ret_free_internal: 521 if (elf_section_data (section)->relocs == NULL) 522 free (internal_relocs); 523 goto error_ret_free_local; 524 } 525 } 526 527 stub_entry->target_value = sym_value; 528 stub_entry->target_section = sym_sec; 529 } 530 531 /* We're done with the internal relocs, free them. */ 532 if (elf_section_data (section)->relocs == NULL) 533 free (internal_relocs); 534 } 535 } 536 537 if (add_stub_section) 538 { 539 /* OK, we've added some stubs. Find out the new size of the 540 stub sections. */ 541 for (stub_sec = htab->stub_bfd->sections; 542 stub_sec != NULL; 543 stub_sec = stub_sec->next) 544 { 545 stub_sec->size = 0; 546 } 547 548 bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab); 549 } 550 free (all_local_syms); 551 return TRUE; 552 553 error_ret_free_local: 554 free (all_local_syms); 555 return FALSE; 556 } 557 558 /* Export the trampoline addresses in the symbol table. */ 559 static bfd_boolean 560 m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 561 { 562 struct bfd_link_info *info; 563 struct m68hc11_elf_link_hash_table *htab; 564 struct elf32_m68hc11_stub_hash_entry *stub_entry; 565 char* name; 566 bfd_boolean result; 567 568 info = (struct bfd_link_info *) in_arg; 569 htab = m68hc11_elf_hash_table (info); 570 571 /* Massage our args to the form they really have. */ 572 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry; 573 574 /* Generate the trampoline according to HC11 or HC12. */ 575 result = (* htab->build_one_stub) (gen_entry, in_arg); 576 577 /* Make a printable name that does not conflict with the real function. */ 578 name = alloca (strlen (stub_entry->root.string) + 16); 579 sprintf (name, "tramp.%s", stub_entry->root.string); 580 581 /* Export the symbol for debugging/disassembling. */ 582 m68hc11_elf_set_symbol (htab->stub_bfd, info, name, 583 stub_entry->stub_offset, 584 stub_entry->stub_sec); 585 return result; 586 } 587 588 /* Export a symbol or set its value and section. */ 589 static void 590 m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info, 591 const char *name, bfd_vma value, asection *sec) 592 { 593 struct elf_link_hash_entry *h; 594 595 h = (struct elf_link_hash_entry *) 596 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE); 597 if (h == NULL) 598 { 599 _bfd_generic_link_add_one_symbol (info, abfd, 600 name, 601 BSF_GLOBAL, 602 sec, 603 value, 604 (const char*) NULL, 605 TRUE, FALSE, NULL); 606 } 607 else 608 { 609 h->root.type = bfd_link_hash_defined; 610 h->root.u.def.value = value; 611 h->root.u.def.section = sec; 612 } 613 } 614 615 616 /* Build all the stubs associated with the current output file. The 617 stubs are kept in a hash table attached to the main linker hash 618 table. This function is called via m68hc12elf_finish in the 619 linker. */ 620 621 bfd_boolean 622 elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info) 623 { 624 asection *stub_sec; 625 struct bfd_hash_table *table; 626 struct m68hc11_elf_link_hash_table *htab; 627 struct m68hc11_scan_param param; 628 629 m68hc11_elf_get_bank_parameters (info); 630 htab = m68hc11_elf_hash_table (info); 631 632 for (stub_sec = htab->stub_bfd->sections; 633 stub_sec != NULL; 634 stub_sec = stub_sec->next) 635 { 636 bfd_size_type size; 637 638 /* Allocate memory to hold the linker stubs. */ 639 size = stub_sec->size; 640 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size); 641 if (stub_sec->contents == NULL && size != 0) 642 return FALSE; 643 stub_sec->size = 0; 644 } 645 646 /* Build the stubs as directed by the stub hash table. */ 647 table = htab->stub_hash_table; 648 bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info); 649 650 /* Scan the output sections to see if we use the memory banks. 651 If so, export the symbols that define how the memory banks 652 are mapped. This is used by gdb and the simulator to obtain 653 the information. It can be used by programs to burn the eprom 654 at the good addresses. */ 655 param.use_memory_banks = FALSE; 656 param.pinfo = &htab->pinfo; 657 bfd_map_over_sections (abfd, scan_sections_for_abi, ¶m); 658 if (param.use_memory_banks) 659 { 660 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME, 661 htab->pinfo.bank_physical, 662 bfd_abs_section_ptr); 663 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME, 664 htab->pinfo.bank_virtual, 665 bfd_abs_section_ptr); 666 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME, 667 htab->pinfo.bank_size, 668 bfd_abs_section_ptr); 669 } 670 671 return TRUE; 672 } 673 674 void 675 m68hc11_elf_get_bank_parameters (struct bfd_link_info *info) 676 { 677 unsigned i; 678 struct m68hc11_page_info *pinfo; 679 struct bfd_link_hash_entry *h; 680 681 pinfo = &m68hc11_elf_hash_table (info)->pinfo; 682 if (pinfo->bank_param_initialized) 683 return; 684 685 pinfo->bank_virtual = M68HC12_BANK_VIRT; 686 pinfo->bank_mask = M68HC12_BANK_MASK; 687 pinfo->bank_physical = M68HC12_BANK_BASE; 688 pinfo->bank_shift = M68HC12_BANK_SHIFT; 689 pinfo->bank_size = 1 << M68HC12_BANK_SHIFT; 690 691 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME, 692 FALSE, FALSE, TRUE); 693 if (h != (struct bfd_link_hash_entry*) NULL 694 && h->type == bfd_link_hash_defined) 695 pinfo->bank_physical = (h->u.def.value 696 + h->u.def.section->output_section->vma 697 + h->u.def.section->output_offset); 698 699 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME, 700 FALSE, FALSE, TRUE); 701 if (h != (struct bfd_link_hash_entry*) NULL 702 && h->type == bfd_link_hash_defined) 703 pinfo->bank_virtual = (h->u.def.value 704 + h->u.def.section->output_section->vma 705 + h->u.def.section->output_offset); 706 707 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME, 708 FALSE, FALSE, TRUE); 709 if (h != (struct bfd_link_hash_entry*) NULL 710 && h->type == bfd_link_hash_defined) 711 pinfo->bank_size = (h->u.def.value 712 + h->u.def.section->output_section->vma 713 + h->u.def.section->output_offset); 714 715 pinfo->bank_shift = 0; 716 for (i = pinfo->bank_size; i != 0; i >>= 1) 717 pinfo->bank_shift++; 718 pinfo->bank_shift--; 719 pinfo->bank_mask = (1 << pinfo->bank_shift) - 1; 720 pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size; 721 pinfo->bank_param_initialized = 1; 722 723 h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE, 724 FALSE, TRUE); 725 if (h != (struct bfd_link_hash_entry*) NULL 726 && h->type == bfd_link_hash_defined) 727 pinfo->trampoline_addr = (h->u.def.value 728 + h->u.def.section->output_section->vma 729 + h->u.def.section->output_offset); 730 } 731 732 /* Return 1 if the address is in banked memory. 733 This can be applied to a virtual address and to a physical address. */ 734 int 735 m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr) 736 { 737 if (addr >= pinfo->bank_virtual) 738 return 1; 739 740 if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end) 741 return 1; 742 743 return 0; 744 } 745 746 /* Return the physical address seen by the processor, taking 747 into account banked memory. */ 748 bfd_vma 749 m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr) 750 { 751 if (addr < pinfo->bank_virtual) 752 return addr; 753 754 /* Map the address to the memory bank. */ 755 addr -= pinfo->bank_virtual; 756 addr &= pinfo->bank_mask; 757 addr += pinfo->bank_physical; 758 return addr; 759 } 760 761 /* Return the page number corresponding to an address in banked memory. */ 762 bfd_vma 763 m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr) 764 { 765 if (addr < pinfo->bank_virtual) 766 return 0; 767 768 /* Map the address to the memory bank. */ 769 addr -= pinfo->bank_virtual; 770 addr >>= pinfo->bank_shift; 771 addr &= 0x0ff; 772 return addr; 773 } 774 775 /* This function is used for relocs which are only used for relaxing, 776 which the linker should otherwise ignore. */ 777 778 bfd_reloc_status_type 779 m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, 780 arelent *reloc_entry, 781 asymbol *symbol ATTRIBUTE_UNUSED, 782 void *data ATTRIBUTE_UNUSED, 783 asection *input_section, 784 bfd *output_bfd, 785 char **error_message ATTRIBUTE_UNUSED) 786 { 787 if (output_bfd != NULL) 788 reloc_entry->address += input_section->output_offset; 789 return bfd_reloc_ok; 790 } 791 792 bfd_reloc_status_type 793 m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED, 794 arelent *reloc_entry, 795 asymbol *symbol, 796 void *data ATTRIBUTE_UNUSED, 797 asection *input_section, 798 bfd *output_bfd, 799 char **error_message ATTRIBUTE_UNUSED) 800 { 801 if (output_bfd != (bfd *) NULL 802 && (symbol->flags & BSF_SECTION_SYM) == 0 803 && (! reloc_entry->howto->partial_inplace 804 || reloc_entry->addend == 0)) 805 { 806 reloc_entry->address += input_section->output_offset; 807 return bfd_reloc_ok; 808 } 809 810 if (output_bfd != NULL) 811 return bfd_reloc_continue; 812 813 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 814 return bfd_reloc_outofrange; 815 816 abort(); 817 } 818 819 /* Look through the relocs for a section during the first phase. 820 Since we don't do .gots or .plts, we just need to consider the 821 virtual table relocs for gc. */ 822 823 bfd_boolean 824 elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info, 825 asection *sec, const Elf_Internal_Rela *relocs) 826 { 827 Elf_Internal_Shdr * symtab_hdr; 828 struct elf_link_hash_entry ** sym_hashes; 829 const Elf_Internal_Rela * rel; 830 const Elf_Internal_Rela * rel_end; 831 832 if (info->relocatable) 833 return TRUE; 834 835 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 836 sym_hashes = elf_sym_hashes (abfd); 837 rel_end = relocs + sec->reloc_count; 838 839 for (rel = relocs; rel < rel_end; rel++) 840 { 841 struct elf_link_hash_entry * h; 842 unsigned long r_symndx; 843 844 r_symndx = ELF32_R_SYM (rel->r_info); 845 846 if (r_symndx < symtab_hdr->sh_info) 847 h = NULL; 848 else 849 { 850 h = sym_hashes [r_symndx - symtab_hdr->sh_info]; 851 while (h->root.type == bfd_link_hash_indirect 852 || h->root.type == bfd_link_hash_warning) 853 h = (struct elf_link_hash_entry *) h->root.u.i.link; 854 } 855 856 switch (ELF32_R_TYPE (rel->r_info)) 857 { 858 /* This relocation describes the C++ object vtable hierarchy. 859 Reconstruct it for later use during GC. */ 860 case R_M68HC11_GNU_VTINHERIT: 861 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 862 return FALSE; 863 break; 864 865 /* This relocation describes which C++ vtable entries are actually 866 used. Record for later use during GC. */ 867 case R_M68HC11_GNU_VTENTRY: 868 BFD_ASSERT (h != NULL); 869 if (h != NULL 870 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 871 return FALSE; 872 break; 873 } 874 } 875 876 return TRUE; 877 } 878 879 /* Relocate a 68hc11/68hc12 ELF section. */ 880 bfd_boolean 881 elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, 882 struct bfd_link_info *info, 883 bfd *input_bfd, asection *input_section, 884 bfd_byte *contents, Elf_Internal_Rela *relocs, 885 Elf_Internal_Sym *local_syms, 886 asection **local_sections) 887 { 888 Elf_Internal_Shdr *symtab_hdr; 889 struct elf_link_hash_entry **sym_hashes; 890 Elf_Internal_Rela *rel, *relend; 891 const char *name = NULL; 892 struct m68hc11_page_info *pinfo; 893 const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd); 894 895 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 896 sym_hashes = elf_sym_hashes (input_bfd); 897 898 /* Get memory bank parameters. */ 899 m68hc11_elf_get_bank_parameters (info); 900 pinfo = &m68hc11_elf_hash_table (info)->pinfo; 901 902 rel = relocs; 903 relend = relocs + input_section->reloc_count; 904 for (; rel < relend; rel++) 905 { 906 int r_type; 907 arelent arel; 908 reloc_howto_type *howto; 909 unsigned long r_symndx; 910 Elf_Internal_Sym *sym; 911 asection *sec; 912 bfd_vma relocation = 0; 913 bfd_reloc_status_type r = bfd_reloc_undefined; 914 bfd_vma phys_page; 915 bfd_vma phys_addr; 916 bfd_vma insn_addr; 917 bfd_vma insn_page; 918 bfd_boolean is_far = FALSE; 919 struct elf_link_hash_entry *h; 920 const char* stub_name = 0; 921 922 r_symndx = ELF32_R_SYM (rel->r_info); 923 r_type = ELF32_R_TYPE (rel->r_info); 924 925 if (r_type == R_M68HC11_GNU_VTENTRY 926 || r_type == R_M68HC11_GNU_VTINHERIT ) 927 continue; 928 929 (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel); 930 howto = arel.howto; 931 932 h = NULL; 933 sym = NULL; 934 sec = NULL; 935 if (r_symndx < symtab_hdr->sh_info) 936 { 937 sym = local_syms + r_symndx; 938 sec = local_sections[r_symndx]; 939 relocation = (sec->output_section->vma 940 + sec->output_offset 941 + sym->st_value); 942 is_far = (sym && (sym->st_other & STO_M68HC12_FAR)); 943 if (is_far) 944 stub_name = (bfd_elf_string_from_elf_section 945 (input_bfd, symtab_hdr->sh_link, 946 sym->st_name)); 947 } 948 else 949 { 950 bfd_boolean unresolved_reloc, warned; 951 952 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 953 r_symndx, symtab_hdr, sym_hashes, 954 h, sec, relocation, unresolved_reloc, 955 warned); 956 957 is_far = (h && (h->other & STO_M68HC12_FAR)); 958 stub_name = h->root.root.string; 959 } 960 961 if (sec != NULL && elf_discarded_section (sec)) 962 { 963 /* For relocs against symbols from removed linkonce sections, 964 or sections discarded by a linker script, we just want the 965 section contents zeroed. Avoid any special processing. */ 966 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 967 rel->r_info = 0; 968 rel->r_addend = 0; 969 continue; 970 } 971 972 if (info->relocatable) 973 { 974 /* This is a relocatable link. We don't have to change 975 anything, unless the reloc is against a section symbol, 976 in which case we have to adjust according to where the 977 section symbol winds up in the output section. */ 978 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 979 rel->r_addend += sec->output_offset; 980 continue; 981 } 982 983 if (h != NULL) 984 name = h->root.root.string; 985 else 986 { 987 name = (bfd_elf_string_from_elf_section 988 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 989 if (name == NULL || *name == '\0') 990 name = bfd_section_name (input_bfd, sec); 991 } 992 993 if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16) 994 { 995 struct elf32_m68hc11_stub_hash_entry* stub; 996 struct m68hc11_elf_link_hash_table *htab; 997 998 htab = m68hc11_elf_hash_table (info); 999 stub = m68hc12_stub_hash_lookup (htab->stub_hash_table, 1000 name, FALSE, FALSE); 1001 if (stub) 1002 { 1003 relocation = stub->stub_offset 1004 + stub->stub_sec->output_section->vma 1005 + stub->stub_sec->output_offset; 1006 is_far = FALSE; 1007 } 1008 } 1009 1010 /* Do the memory bank mapping. */ 1011 phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend); 1012 phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend); 1013 switch (r_type) 1014 { 1015 case R_M68HC11_24: 1016 /* Reloc used by 68HC12 call instruction. */ 1017 bfd_put_16 (input_bfd, phys_addr, 1018 (bfd_byte*) contents + rel->r_offset); 1019 bfd_put_8 (input_bfd, phys_page, 1020 (bfd_byte*) contents + rel->r_offset + 2); 1021 r = bfd_reloc_ok; 1022 r_type = R_M68HC11_NONE; 1023 break; 1024 1025 case R_M68HC11_NONE: 1026 r = bfd_reloc_ok; 1027 break; 1028 1029 case R_M68HC11_LO16: 1030 /* Reloc generated by %addr(expr) gas to obtain the 1031 address as mapped in the memory bank window. */ 1032 relocation = phys_addr; 1033 break; 1034 1035 case R_M68HC11_PAGE: 1036 /* Reloc generated by %page(expr) gas to obtain the 1037 page number associated with the address. */ 1038 relocation = phys_page; 1039 break; 1040 1041 case R_M68HC11_16: 1042 /* Get virtual address of instruction having the relocation. */ 1043 if (is_far) 1044 { 1045 const char* msg; 1046 char* buf; 1047 msg = _("Reference to the far symbol `%s' using a wrong " 1048 "relocation may result in incorrect execution"); 1049 buf = alloca (strlen (msg) + strlen (name) + 10); 1050 sprintf (buf, msg, name); 1051 1052 (* info->callbacks->warning) 1053 (info, buf, name, input_bfd, NULL, rel->r_offset); 1054 } 1055 1056 /* Get virtual address of instruction having the relocation. */ 1057 insn_addr = input_section->output_section->vma 1058 + input_section->output_offset 1059 + rel->r_offset; 1060 1061 insn_page = m68hc11_phys_page (pinfo, insn_addr); 1062 1063 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend) 1064 && m68hc11_addr_is_banked (pinfo, insn_addr) 1065 && phys_page != insn_page) 1066 { 1067 const char* msg; 1068 char* buf; 1069 1070 msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank " 1071 "as current banked address [%lx:%04lx] (%lx)"); 1072 1073 buf = alloca (strlen (msg) + 128); 1074 sprintf (buf, msg, phys_page, phys_addr, 1075 (long) (relocation + rel->r_addend), 1076 insn_page, m68hc11_phys_addr (pinfo, insn_addr), 1077 (long) (insn_addr)); 1078 if (!((*info->callbacks->warning) 1079 (info, buf, name, input_bfd, input_section, 1080 rel->r_offset))) 1081 return FALSE; 1082 break; 1083 } 1084 if (phys_page != 0 && insn_page == 0) 1085 { 1086 const char* msg; 1087 char* buf; 1088 1089 msg = _("reference to a banked address [%lx:%04lx] in the " 1090 "normal address space at %04lx"); 1091 1092 buf = alloca (strlen (msg) + 128); 1093 sprintf (buf, msg, phys_page, phys_addr, insn_addr); 1094 if (!((*info->callbacks->warning) 1095 (info, buf, name, input_bfd, input_section, 1096 insn_addr))) 1097 return FALSE; 1098 1099 relocation = phys_addr; 1100 break; 1101 } 1102 1103 /* If this is a banked address use the phys_addr so that 1104 we stay in the banked window. */ 1105 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)) 1106 relocation = phys_addr; 1107 break; 1108 } 1109 if (r_type != R_M68HC11_NONE) 1110 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1111 contents, rel->r_offset, 1112 relocation, rel->r_addend); 1113 1114 if (r != bfd_reloc_ok) 1115 { 1116 const char * msg = (const char *) 0; 1117 1118 switch (r) 1119 { 1120 case bfd_reloc_overflow: 1121 if (!((*info->callbacks->reloc_overflow) 1122 (info, NULL, name, howto->name, (bfd_vma) 0, 1123 input_bfd, input_section, rel->r_offset))) 1124 return FALSE; 1125 break; 1126 1127 case bfd_reloc_undefined: 1128 if (!((*info->callbacks->undefined_symbol) 1129 (info, name, input_bfd, input_section, 1130 rel->r_offset, TRUE))) 1131 return FALSE; 1132 break; 1133 1134 case bfd_reloc_outofrange: 1135 msg = _ ("internal error: out of range error"); 1136 goto common_error; 1137 1138 case bfd_reloc_notsupported: 1139 msg = _ ("internal error: unsupported relocation error"); 1140 goto common_error; 1141 1142 case bfd_reloc_dangerous: 1143 msg = _ ("internal error: dangerous error"); 1144 goto common_error; 1145 1146 default: 1147 msg = _ ("internal error: unknown error"); 1148 /* fall through */ 1149 1150 common_error: 1151 if (!((*info->callbacks->warning) 1152 (info, msg, name, input_bfd, input_section, 1153 rel->r_offset))) 1154 return FALSE; 1155 break; 1156 } 1157 } 1158 } 1159 1160 return TRUE; 1161 } 1162 1163 1164 1165 /* Set and control ELF flags in ELF header. */ 1166 1167 bfd_boolean 1168 _bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags) 1169 { 1170 BFD_ASSERT (!elf_flags_init (abfd) 1171 || elf_elfheader (abfd)->e_flags == flags); 1172 1173 elf_elfheader (abfd)->e_flags = flags; 1174 elf_flags_init (abfd) = TRUE; 1175 return TRUE; 1176 } 1177 1178 /* Merge backend specific data from an object file to the output 1179 object file when linking. */ 1180 1181 bfd_boolean 1182 _bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 1183 { 1184 flagword old_flags; 1185 flagword new_flags; 1186 bfd_boolean ok = TRUE; 1187 1188 /* Check if we have the same endianess */ 1189 if (!_bfd_generic_verify_endian_match (ibfd, obfd)) 1190 return FALSE; 1191 1192 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1193 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1194 return TRUE; 1195 1196 new_flags = elf_elfheader (ibfd)->e_flags; 1197 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI; 1198 old_flags = elf_elfheader (obfd)->e_flags; 1199 1200 if (! elf_flags_init (obfd)) 1201 { 1202 elf_flags_init (obfd) = TRUE; 1203 elf_elfheader (obfd)->e_flags = new_flags; 1204 elf_elfheader (obfd)->e_ident[EI_CLASS] 1205 = elf_elfheader (ibfd)->e_ident[EI_CLASS]; 1206 1207 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 1208 && bfd_get_arch_info (obfd)->the_default) 1209 { 1210 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 1211 bfd_get_mach (ibfd))) 1212 return FALSE; 1213 } 1214 1215 return TRUE; 1216 } 1217 1218 /* Check ABI compatibility. */ 1219 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32)) 1220 { 1221 (*_bfd_error_handler) 1222 (_("%B: linking files compiled for 16-bit integers (-mshort) " 1223 "and others for 32-bit integers"), ibfd); 1224 ok = FALSE; 1225 } 1226 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64)) 1227 { 1228 (*_bfd_error_handler) 1229 (_("%B: linking files compiled for 32-bit double (-fshort-double) " 1230 "and others for 64-bit double"), ibfd); 1231 ok = FALSE; 1232 } 1233 1234 /* Processor compatibility. */ 1235 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags)) 1236 { 1237 (*_bfd_error_handler) 1238 (_("%B: linking files compiled for HCS12 with " 1239 "others compiled for HC12"), ibfd); 1240 ok = FALSE; 1241 } 1242 new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK) 1243 | (EF_M68HC11_MERGE_MACH (new_flags, old_flags))); 1244 1245 elf_elfheader (obfd)->e_flags = new_flags; 1246 1247 new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK); 1248 old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK); 1249 1250 /* Warn about any other mismatches */ 1251 if (new_flags != old_flags) 1252 { 1253 (*_bfd_error_handler) 1254 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), 1255 ibfd, (unsigned long) new_flags, (unsigned long) old_flags); 1256 ok = FALSE; 1257 } 1258 1259 if (! ok) 1260 { 1261 bfd_set_error (bfd_error_bad_value); 1262 return FALSE; 1263 } 1264 1265 return TRUE; 1266 } 1267 1268 bfd_boolean 1269 _bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr) 1270 { 1271 FILE *file = (FILE *) ptr; 1272 1273 BFD_ASSERT (abfd != NULL && ptr != NULL); 1274 1275 /* Print normal ELF private data. */ 1276 _bfd_elf_print_private_bfd_data (abfd, ptr); 1277 1278 /* xgettext:c-format */ 1279 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 1280 1281 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32) 1282 fprintf (file, _("[abi=32-bit int, ")); 1283 else 1284 fprintf (file, _("[abi=16-bit int, ")); 1285 1286 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64) 1287 fprintf (file, _("64-bit double, ")); 1288 else 1289 fprintf (file, _("32-bit double, ")); 1290 1291 if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0) 1292 fprintf (file, _("cpu=HC11]")); 1293 else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH) 1294 fprintf (file, _("cpu=HCS12]")); 1295 else 1296 fprintf (file, _("cpu=HC12]")); 1297 1298 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS) 1299 fprintf (file, _(" [memory=bank-model]")); 1300 else 1301 fprintf (file, _(" [memory=flat]")); 1302 1303 fputc ('\n', file); 1304 1305 return TRUE; 1306 } 1307 1308 static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED, 1309 asection *asect, void *arg) 1310 { 1311 struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg; 1312 1313 if (asect->vma >= p->pinfo->bank_virtual) 1314 p->use_memory_banks = TRUE; 1315 } 1316 1317 /* Tweak the OSABI field of the elf header. */ 1318 1319 void 1320 elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info) 1321 { 1322 struct m68hc11_scan_param param; 1323 1324 if (link_info == 0) 1325 return; 1326 1327 m68hc11_elf_get_bank_parameters (link_info); 1328 1329 param.use_memory_banks = FALSE; 1330 param.pinfo = &m68hc11_elf_hash_table (link_info)->pinfo; 1331 bfd_map_over_sections (abfd, scan_sections_for_abi, ¶m); 1332 if (param.use_memory_banks) 1333 { 1334 Elf_Internal_Ehdr * i_ehdrp; 1335 1336 i_ehdrp = elf_elfheader (abfd); 1337 i_ehdrp->e_flags |= E_M68HC12_BANKS; 1338 } 1339 } 1340 1341