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