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