1 /* Matsushita 10300 specific support for 32-bit ELF 2 Copyright (C) 1996-2016 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/mn10300.h" 26 #include "libiberty.h" 27 28 /* The mn10300 linker needs to keep track of the number of relocs that 29 it decides to copy in check_relocs for each symbol. This is so 30 that it can discard PC relative relocs if it doesn't need them when 31 linking with -Bsymbolic. We store the information in a field 32 extending the regular ELF linker hash table. */ 33 34 struct elf32_mn10300_link_hash_entry 35 { 36 /* The basic elf link hash table entry. */ 37 struct elf_link_hash_entry root; 38 39 /* For function symbols, the number of times this function is 40 called directly (ie by name). */ 41 unsigned int direct_calls; 42 43 /* For function symbols, the size of this function's stack 44 (if <= 255 bytes). We stuff this into "call" instructions 45 to this target when it's valid and profitable to do so. 46 47 This does not include stack allocated by movm! */ 48 unsigned char stack_size; 49 50 /* For function symbols, arguments (if any) for movm instruction 51 in the prologue. We stuff this value into "call" instructions 52 to the target when it's valid and profitable to do so. */ 53 unsigned char movm_args; 54 55 /* For function symbols, the amount of stack space that would be allocated 56 by the movm instruction. This is redundant with movm_args, but we 57 add it to the hash table to avoid computing it over and over. */ 58 unsigned char movm_stack_size; 59 60 /* When set, convert all "call" instructions to this target into "calls" 61 instructions. */ 62 #define MN10300_CONVERT_CALL_TO_CALLS 0x1 63 64 /* Used to mark functions which have had redundant parts of their 65 prologue deleted. */ 66 #define MN10300_DELETED_PROLOGUE_BYTES 0x2 67 unsigned char flags; 68 69 /* Calculated value. */ 70 bfd_vma value; 71 72 #define GOT_UNKNOWN 0 73 #define GOT_NORMAL 1 74 #define GOT_TLS_GD 2 75 #define GOT_TLS_LD 3 76 #define GOT_TLS_IE 4 77 /* Used to distinguish GOT entries for TLS types from normal GOT entries. */ 78 unsigned char tls_type; 79 }; 80 81 /* We derive a hash table from the main elf linker hash table so 82 we can store state variables and a secondary hash table without 83 resorting to global variables. */ 84 struct elf32_mn10300_link_hash_table 85 { 86 /* The main hash table. */ 87 struct elf_link_hash_table root; 88 89 /* A hash table for static functions. We could derive a new hash table 90 instead of using the full elf32_mn10300_link_hash_table if we wanted 91 to save some memory. */ 92 struct elf32_mn10300_link_hash_table *static_hash_table; 93 94 /* Random linker state flags. */ 95 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1 96 char flags; 97 struct 98 { 99 bfd_signed_vma refcount; 100 bfd_vma offset; 101 char got_allocated; 102 char rel_emitted; 103 } tls_ldm_got; 104 }; 105 106 #define elf_mn10300_hash_entry(ent) ((struct elf32_mn10300_link_hash_entry *)(ent)) 107 108 struct elf_mn10300_obj_tdata 109 { 110 struct elf_obj_tdata root; 111 112 /* tls_type for each local got entry. */ 113 char * local_got_tls_type; 114 }; 115 116 #define elf_mn10300_tdata(abfd) \ 117 ((struct elf_mn10300_obj_tdata *) (abfd)->tdata.any) 118 119 #define elf_mn10300_local_got_tls_type(abfd) \ 120 (elf_mn10300_tdata (abfd)->local_got_tls_type) 121 122 #ifndef streq 123 #define streq(a, b) (strcmp ((a),(b)) == 0) 124 #endif 125 126 /* For MN10300 linker hash table. */ 127 128 /* Get the MN10300 ELF linker hash table from a link_info structure. */ 129 130 #define elf32_mn10300_hash_table(p) \ 131 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 132 == MN10300_ELF_DATA ? ((struct elf32_mn10300_link_hash_table *) ((p)->hash)) : NULL) 133 134 #define elf32_mn10300_link_hash_traverse(table, func, info) \ 135 (elf_link_hash_traverse \ 136 (&(table)->root, \ 137 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 138 (info))) 139 140 static reloc_howto_type elf_mn10300_howto_table[] = 141 { 142 /* Dummy relocation. Does nothing. */ 143 HOWTO (R_MN10300_NONE, 144 0, 145 3, 146 0, 147 FALSE, 148 0, 149 complain_overflow_dont, 150 bfd_elf_generic_reloc, 151 "R_MN10300_NONE", 152 FALSE, 153 0, 154 0, 155 FALSE), 156 /* Standard 32 bit reloc. */ 157 HOWTO (R_MN10300_32, 158 0, 159 2, 160 32, 161 FALSE, 162 0, 163 complain_overflow_bitfield, 164 bfd_elf_generic_reloc, 165 "R_MN10300_32", 166 FALSE, 167 0xffffffff, 168 0xffffffff, 169 FALSE), 170 /* Standard 16 bit reloc. */ 171 HOWTO (R_MN10300_16, 172 0, 173 1, 174 16, 175 FALSE, 176 0, 177 complain_overflow_bitfield, 178 bfd_elf_generic_reloc, 179 "R_MN10300_16", 180 FALSE, 181 0xffff, 182 0xffff, 183 FALSE), 184 /* Standard 8 bit reloc. */ 185 HOWTO (R_MN10300_8, 186 0, 187 0, 188 8, 189 FALSE, 190 0, 191 complain_overflow_bitfield, 192 bfd_elf_generic_reloc, 193 "R_MN10300_8", 194 FALSE, 195 0xff, 196 0xff, 197 FALSE), 198 /* Standard 32bit pc-relative reloc. */ 199 HOWTO (R_MN10300_PCREL32, 200 0, 201 2, 202 32, 203 TRUE, 204 0, 205 complain_overflow_bitfield, 206 bfd_elf_generic_reloc, 207 "R_MN10300_PCREL32", 208 FALSE, 209 0xffffffff, 210 0xffffffff, 211 TRUE), 212 /* Standard 16bit pc-relative reloc. */ 213 HOWTO (R_MN10300_PCREL16, 214 0, 215 1, 216 16, 217 TRUE, 218 0, 219 complain_overflow_bitfield, 220 bfd_elf_generic_reloc, 221 "R_MN10300_PCREL16", 222 FALSE, 223 0xffff, 224 0xffff, 225 TRUE), 226 /* Standard 8 pc-relative reloc. */ 227 HOWTO (R_MN10300_PCREL8, 228 0, 229 0, 230 8, 231 TRUE, 232 0, 233 complain_overflow_bitfield, 234 bfd_elf_generic_reloc, 235 "R_MN10300_PCREL8", 236 FALSE, 237 0xff, 238 0xff, 239 TRUE), 240 241 /* GNU extension to record C++ vtable hierarchy. */ 242 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */ 243 0, /* rightshift */ 244 0, /* size (0 = byte, 1 = short, 2 = long) */ 245 0, /* bitsize */ 246 FALSE, /* pc_relative */ 247 0, /* bitpos */ 248 complain_overflow_dont, /* complain_on_overflow */ 249 NULL, /* special_function */ 250 "R_MN10300_GNU_VTINHERIT", /* name */ 251 FALSE, /* partial_inplace */ 252 0, /* src_mask */ 253 0, /* dst_mask */ 254 FALSE), /* pcrel_offset */ 255 256 /* GNU extension to record C++ vtable member usage */ 257 HOWTO (R_MN10300_GNU_VTENTRY, /* type */ 258 0, /* rightshift */ 259 0, /* size (0 = byte, 1 = short, 2 = long) */ 260 0, /* bitsize */ 261 FALSE, /* pc_relative */ 262 0, /* bitpos */ 263 complain_overflow_dont, /* complain_on_overflow */ 264 NULL, /* special_function */ 265 "R_MN10300_GNU_VTENTRY", /* name */ 266 FALSE, /* partial_inplace */ 267 0, /* src_mask */ 268 0, /* dst_mask */ 269 FALSE), /* pcrel_offset */ 270 271 /* Standard 24 bit reloc. */ 272 HOWTO (R_MN10300_24, 273 0, 274 2, 275 24, 276 FALSE, 277 0, 278 complain_overflow_bitfield, 279 bfd_elf_generic_reloc, 280 "R_MN10300_24", 281 FALSE, 282 0xffffff, 283 0xffffff, 284 FALSE), 285 HOWTO (R_MN10300_GOTPC32, /* type */ 286 0, /* rightshift */ 287 2, /* size (0 = byte, 1 = short, 2 = long) */ 288 32, /* bitsize */ 289 TRUE, /* pc_relative */ 290 0, /* bitpos */ 291 complain_overflow_bitfield, /* complain_on_overflow */ 292 bfd_elf_generic_reloc, /* */ 293 "R_MN10300_GOTPC32", /* name */ 294 FALSE, /* partial_inplace */ 295 0xffffffff, /* src_mask */ 296 0xffffffff, /* dst_mask */ 297 TRUE), /* pcrel_offset */ 298 299 HOWTO (R_MN10300_GOTPC16, /* type */ 300 0, /* rightshift */ 301 1, /* size (0 = byte, 1 = short, 2 = long) */ 302 16, /* bitsize */ 303 TRUE, /* pc_relative */ 304 0, /* bitpos */ 305 complain_overflow_bitfield, /* complain_on_overflow */ 306 bfd_elf_generic_reloc, /* */ 307 "R_MN10300_GOTPC16", /* name */ 308 FALSE, /* partial_inplace */ 309 0xffff, /* src_mask */ 310 0xffff, /* dst_mask */ 311 TRUE), /* pcrel_offset */ 312 313 HOWTO (R_MN10300_GOTOFF32, /* type */ 314 0, /* rightshift */ 315 2, /* size (0 = byte, 1 = short, 2 = long) */ 316 32, /* bitsize */ 317 FALSE, /* pc_relative */ 318 0, /* bitpos */ 319 complain_overflow_bitfield, /* complain_on_overflow */ 320 bfd_elf_generic_reloc, /* */ 321 "R_MN10300_GOTOFF32", /* name */ 322 FALSE, /* partial_inplace */ 323 0xffffffff, /* src_mask */ 324 0xffffffff, /* dst_mask */ 325 FALSE), /* pcrel_offset */ 326 327 HOWTO (R_MN10300_GOTOFF24, /* type */ 328 0, /* rightshift */ 329 2, /* size (0 = byte, 1 = short, 2 = long) */ 330 24, /* bitsize */ 331 FALSE, /* pc_relative */ 332 0, /* bitpos */ 333 complain_overflow_bitfield, /* complain_on_overflow */ 334 bfd_elf_generic_reloc, /* */ 335 "R_MN10300_GOTOFF24", /* name */ 336 FALSE, /* partial_inplace */ 337 0xffffff, /* src_mask */ 338 0xffffff, /* dst_mask */ 339 FALSE), /* pcrel_offset */ 340 341 HOWTO (R_MN10300_GOTOFF16, /* type */ 342 0, /* rightshift */ 343 1, /* size (0 = byte, 1 = short, 2 = long) */ 344 16, /* bitsize */ 345 FALSE, /* pc_relative */ 346 0, /* bitpos */ 347 complain_overflow_bitfield, /* complain_on_overflow */ 348 bfd_elf_generic_reloc, /* */ 349 "R_MN10300_GOTOFF16", /* name */ 350 FALSE, /* partial_inplace */ 351 0xffff, /* src_mask */ 352 0xffff, /* dst_mask */ 353 FALSE), /* pcrel_offset */ 354 355 HOWTO (R_MN10300_PLT32, /* type */ 356 0, /* rightshift */ 357 2, /* size (0 = byte, 1 = short, 2 = long) */ 358 32, /* bitsize */ 359 TRUE, /* pc_relative */ 360 0, /* bitpos */ 361 complain_overflow_bitfield, /* complain_on_overflow */ 362 bfd_elf_generic_reloc, /* */ 363 "R_MN10300_PLT32", /* name */ 364 FALSE, /* partial_inplace */ 365 0xffffffff, /* src_mask */ 366 0xffffffff, /* dst_mask */ 367 TRUE), /* pcrel_offset */ 368 369 HOWTO (R_MN10300_PLT16, /* type */ 370 0, /* rightshift */ 371 1, /* size (0 = byte, 1 = short, 2 = long) */ 372 16, /* bitsize */ 373 TRUE, /* pc_relative */ 374 0, /* bitpos */ 375 complain_overflow_bitfield, /* complain_on_overflow */ 376 bfd_elf_generic_reloc, /* */ 377 "R_MN10300_PLT16", /* name */ 378 FALSE, /* partial_inplace */ 379 0xffff, /* src_mask */ 380 0xffff, /* dst_mask */ 381 TRUE), /* pcrel_offset */ 382 383 HOWTO (R_MN10300_GOT32, /* type */ 384 0, /* rightshift */ 385 2, /* size (0 = byte, 1 = short, 2 = long) */ 386 32, /* bitsize */ 387 FALSE, /* pc_relative */ 388 0, /* bitpos */ 389 complain_overflow_bitfield, /* complain_on_overflow */ 390 bfd_elf_generic_reloc, /* */ 391 "R_MN10300_GOT32", /* name */ 392 FALSE, /* partial_inplace */ 393 0xffffffff, /* src_mask */ 394 0xffffffff, /* dst_mask */ 395 FALSE), /* pcrel_offset */ 396 397 HOWTO (R_MN10300_GOT24, /* type */ 398 0, /* rightshift */ 399 2, /* size (0 = byte, 1 = short, 2 = long) */ 400 24, /* bitsize */ 401 FALSE, /* pc_relative */ 402 0, /* bitpos */ 403 complain_overflow_bitfield, /* complain_on_overflow */ 404 bfd_elf_generic_reloc, /* */ 405 "R_MN10300_GOT24", /* name */ 406 FALSE, /* partial_inplace */ 407 0xffffffff, /* src_mask */ 408 0xffffffff, /* dst_mask */ 409 FALSE), /* pcrel_offset */ 410 411 HOWTO (R_MN10300_GOT16, /* type */ 412 0, /* rightshift */ 413 1, /* size (0 = byte, 1 = short, 2 = long) */ 414 16, /* bitsize */ 415 FALSE, /* pc_relative */ 416 0, /* bitpos */ 417 complain_overflow_bitfield, /* complain_on_overflow */ 418 bfd_elf_generic_reloc, /* */ 419 "R_MN10300_GOT16", /* name */ 420 FALSE, /* partial_inplace */ 421 0xffffffff, /* src_mask */ 422 0xffffffff, /* dst_mask */ 423 FALSE), /* pcrel_offset */ 424 425 HOWTO (R_MN10300_COPY, /* type */ 426 0, /* rightshift */ 427 2, /* size (0 = byte, 1 = short, 2 = long) */ 428 32, /* bitsize */ 429 FALSE, /* pc_relative */ 430 0, /* bitpos */ 431 complain_overflow_bitfield, /* complain_on_overflow */ 432 bfd_elf_generic_reloc, /* */ 433 "R_MN10300_COPY", /* name */ 434 FALSE, /* partial_inplace */ 435 0xffffffff, /* src_mask */ 436 0xffffffff, /* dst_mask */ 437 FALSE), /* pcrel_offset */ 438 439 HOWTO (R_MN10300_GLOB_DAT, /* type */ 440 0, /* rightshift */ 441 2, /* size (0 = byte, 1 = short, 2 = long) */ 442 32, /* bitsize */ 443 FALSE, /* pc_relative */ 444 0, /* bitpos */ 445 complain_overflow_bitfield, /* complain_on_overflow */ 446 bfd_elf_generic_reloc, /* */ 447 "R_MN10300_GLOB_DAT", /* name */ 448 FALSE, /* partial_inplace */ 449 0xffffffff, /* src_mask */ 450 0xffffffff, /* dst_mask */ 451 FALSE), /* pcrel_offset */ 452 453 HOWTO (R_MN10300_JMP_SLOT, /* type */ 454 0, /* rightshift */ 455 2, /* size (0 = byte, 1 = short, 2 = long) */ 456 32, /* bitsize */ 457 FALSE, /* pc_relative */ 458 0, /* bitpos */ 459 complain_overflow_bitfield, /* complain_on_overflow */ 460 bfd_elf_generic_reloc, /* */ 461 "R_MN10300_JMP_SLOT", /* name */ 462 FALSE, /* partial_inplace */ 463 0xffffffff, /* src_mask */ 464 0xffffffff, /* dst_mask */ 465 FALSE), /* pcrel_offset */ 466 467 HOWTO (R_MN10300_RELATIVE, /* type */ 468 0, /* rightshift */ 469 2, /* size (0 = byte, 1 = short, 2 = long) */ 470 32, /* bitsize */ 471 FALSE, /* pc_relative */ 472 0, /* bitpos */ 473 complain_overflow_bitfield, /* complain_on_overflow */ 474 bfd_elf_generic_reloc, /* */ 475 "R_MN10300_RELATIVE", /* name */ 476 FALSE, /* partial_inplace */ 477 0xffffffff, /* src_mask */ 478 0xffffffff, /* dst_mask */ 479 FALSE), /* pcrel_offset */ 480 481 HOWTO (R_MN10300_TLS_GD, /* type */ 482 0, /* rightshift */ 483 2, /* size (0 = byte, 1 = short, 2 = long) */ 484 32, /* bitsize */ 485 FALSE, /* pc_relative */ 486 0, /* bitpos */ 487 complain_overflow_bitfield, /* complain_on_overflow */ 488 bfd_elf_generic_reloc, /* */ 489 "R_MN10300_TLS_GD", /* name */ 490 FALSE, /* partial_inplace */ 491 0xffffffff, /* src_mask */ 492 0xffffffff, /* dst_mask */ 493 FALSE), /* pcrel_offset */ 494 495 HOWTO (R_MN10300_TLS_LD, /* type */ 496 0, /* rightshift */ 497 2, /* size (0 = byte, 1 = short, 2 = long) */ 498 32, /* bitsize */ 499 FALSE, /* pc_relative */ 500 0, /* bitpos */ 501 complain_overflow_bitfield, /* complain_on_overflow */ 502 bfd_elf_generic_reloc, /* */ 503 "R_MN10300_TLS_LD", /* name */ 504 FALSE, /* partial_inplace */ 505 0xffffffff, /* src_mask */ 506 0xffffffff, /* dst_mask */ 507 FALSE), /* pcrel_offset */ 508 509 HOWTO (R_MN10300_TLS_LDO, /* type */ 510 0, /* rightshift */ 511 2, /* size (0 = byte, 1 = short, 2 = long) */ 512 32, /* bitsize */ 513 FALSE, /* pc_relative */ 514 0, /* bitpos */ 515 complain_overflow_bitfield, /* complain_on_overflow */ 516 bfd_elf_generic_reloc, /* */ 517 "R_MN10300_TLS_LDO", /* name */ 518 FALSE, /* partial_inplace */ 519 0xffffffff, /* src_mask */ 520 0xffffffff, /* dst_mask */ 521 FALSE), /* pcrel_offset */ 522 523 HOWTO (R_MN10300_TLS_GOTIE, /* type */ 524 0, /* rightshift */ 525 2, /* size (0 = byte, 1 = short, 2 = long) */ 526 32, /* bitsize */ 527 FALSE, /* pc_relative */ 528 0, /* bitpos */ 529 complain_overflow_bitfield, /* complain_on_overflow */ 530 bfd_elf_generic_reloc, /* */ 531 "R_MN10300_TLS_GOTIE", /* name */ 532 FALSE, /* partial_inplace */ 533 0xffffffff, /* src_mask */ 534 0xffffffff, /* dst_mask */ 535 FALSE), /* pcrel_offset */ 536 537 HOWTO (R_MN10300_TLS_IE, /* type */ 538 0, /* rightshift */ 539 2, /* size (0 = byte, 1 = short, 2 = long) */ 540 32, /* bitsize */ 541 FALSE, /* pc_relative */ 542 0, /* bitpos */ 543 complain_overflow_bitfield, /* complain_on_overflow */ 544 bfd_elf_generic_reloc, /* */ 545 "R_MN10300_TLS_IE", /* name */ 546 FALSE, /* partial_inplace */ 547 0xffffffff, /* src_mask */ 548 0xffffffff, /* dst_mask */ 549 FALSE), /* pcrel_offset */ 550 551 HOWTO (R_MN10300_TLS_LE, /* type */ 552 0, /* rightshift */ 553 2, /* size (0 = byte, 1 = short, 2 = long) */ 554 32, /* bitsize */ 555 FALSE, /* pc_relative */ 556 0, /* bitpos */ 557 complain_overflow_bitfield, /* complain_on_overflow */ 558 bfd_elf_generic_reloc, /* */ 559 "R_MN10300_TLS_LE", /* name */ 560 FALSE, /* partial_inplace */ 561 0xffffffff, /* src_mask */ 562 0xffffffff, /* dst_mask */ 563 FALSE), /* pcrel_offset */ 564 565 HOWTO (R_MN10300_TLS_DTPMOD, /* type */ 566 0, /* rightshift */ 567 2, /* size (0 = byte, 1 = short, 2 = long) */ 568 32, /* bitsize */ 569 FALSE, /* pc_relative */ 570 0, /* bitpos */ 571 complain_overflow_bitfield, /* complain_on_overflow */ 572 bfd_elf_generic_reloc, /* */ 573 "R_MN10300_TLS_DTPMOD", /* name */ 574 FALSE, /* partial_inplace */ 575 0xffffffff, /* src_mask */ 576 0xffffffff, /* dst_mask */ 577 FALSE), /* pcrel_offset */ 578 579 HOWTO (R_MN10300_TLS_DTPOFF, /* type */ 580 0, /* rightshift */ 581 2, /* size (0 = byte, 1 = short, 2 = long) */ 582 32, /* bitsize */ 583 FALSE, /* pc_relative */ 584 0, /* bitpos */ 585 complain_overflow_bitfield, /* complain_on_overflow */ 586 bfd_elf_generic_reloc, /* */ 587 "R_MN10300_TLS_DTPOFF", /* name */ 588 FALSE, /* partial_inplace */ 589 0xffffffff, /* src_mask */ 590 0xffffffff, /* dst_mask */ 591 FALSE), /* pcrel_offset */ 592 593 HOWTO (R_MN10300_TLS_TPOFF, /* type */ 594 0, /* rightshift */ 595 2, /* size (0 = byte, 1 = short, 2 = long) */ 596 32, /* bitsize */ 597 FALSE, /* pc_relative */ 598 0, /* bitpos */ 599 complain_overflow_bitfield, /* complain_on_overflow */ 600 bfd_elf_generic_reloc, /* */ 601 "R_MN10300_TLS_TPOFF", /* name */ 602 FALSE, /* partial_inplace */ 603 0xffffffff, /* src_mask */ 604 0xffffffff, /* dst_mask */ 605 FALSE), /* pcrel_offset */ 606 607 HOWTO (R_MN10300_SYM_DIFF, /* type */ 608 0, /* rightshift */ 609 2, /* size (0 = byte, 1 = short, 2 = long) */ 610 32, /* bitsize */ 611 FALSE, /* pc_relative */ 612 0, /* bitpos */ 613 complain_overflow_dont,/* complain_on_overflow */ 614 NULL, /* special handler. */ 615 "R_MN10300_SYM_DIFF", /* name */ 616 FALSE, /* partial_inplace */ 617 0xffffffff, /* src_mask */ 618 0xffffffff, /* dst_mask */ 619 FALSE), /* pcrel_offset */ 620 621 HOWTO (R_MN10300_ALIGN, /* type */ 622 0, /* rightshift */ 623 0, /* size (0 = byte, 1 = short, 2 = long) */ 624 32, /* bitsize */ 625 FALSE, /* pc_relative */ 626 0, /* bitpos */ 627 complain_overflow_dont,/* complain_on_overflow */ 628 NULL, /* special handler. */ 629 "R_MN10300_ALIGN", /* name */ 630 FALSE, /* partial_inplace */ 631 0, /* src_mask */ 632 0, /* dst_mask */ 633 FALSE) /* pcrel_offset */ 634 }; 635 636 struct mn10300_reloc_map 637 { 638 bfd_reloc_code_real_type bfd_reloc_val; 639 unsigned char elf_reloc_val; 640 }; 641 642 static const struct mn10300_reloc_map mn10300_reloc_map[] = 643 { 644 { BFD_RELOC_NONE, R_MN10300_NONE, }, 645 { BFD_RELOC_32, R_MN10300_32, }, 646 { BFD_RELOC_16, R_MN10300_16, }, 647 { BFD_RELOC_8, R_MN10300_8, }, 648 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, }, 649 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, }, 650 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, }, 651 { BFD_RELOC_24, R_MN10300_24, }, 652 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT }, 653 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY }, 654 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 }, 655 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 }, 656 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 }, 657 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 }, 658 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 }, 659 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 }, 660 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 }, 661 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 }, 662 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 }, 663 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 }, 664 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY }, 665 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT }, 666 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT }, 667 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE }, 668 { BFD_RELOC_MN10300_TLS_GD, R_MN10300_TLS_GD }, 669 { BFD_RELOC_MN10300_TLS_LD, R_MN10300_TLS_LD }, 670 { BFD_RELOC_MN10300_TLS_LDO, R_MN10300_TLS_LDO }, 671 { BFD_RELOC_MN10300_TLS_GOTIE, R_MN10300_TLS_GOTIE }, 672 { BFD_RELOC_MN10300_TLS_IE, R_MN10300_TLS_IE }, 673 { BFD_RELOC_MN10300_TLS_LE, R_MN10300_TLS_LE }, 674 { BFD_RELOC_MN10300_TLS_DTPMOD, R_MN10300_TLS_DTPMOD }, 675 { BFD_RELOC_MN10300_TLS_DTPOFF, R_MN10300_TLS_DTPOFF }, 676 { BFD_RELOC_MN10300_TLS_TPOFF, R_MN10300_TLS_TPOFF }, 677 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF }, 678 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN } 679 }; 680 681 /* Create the GOT section. */ 682 683 static bfd_boolean 684 _bfd_mn10300_elf_create_got_section (bfd * abfd, 685 struct bfd_link_info * info) 686 { 687 flagword flags; 688 flagword pltflags; 689 asection * s; 690 struct elf_link_hash_entry * h; 691 const struct elf_backend_data * bed = get_elf_backend_data (abfd); 692 struct elf_link_hash_table *htab; 693 int ptralign; 694 695 /* This function may be called more than once. */ 696 htab = elf_hash_table (info); 697 if (htab->sgot != NULL) 698 return TRUE; 699 700 switch (bed->s->arch_size) 701 { 702 case 32: 703 ptralign = 2; 704 break; 705 706 case 64: 707 ptralign = 3; 708 break; 709 710 default: 711 bfd_set_error (bfd_error_bad_value); 712 return FALSE; 713 } 714 715 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 716 | SEC_LINKER_CREATED); 717 718 pltflags = flags; 719 pltflags |= SEC_CODE; 720 if (bed->plt_not_loaded) 721 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS); 722 if (bed->plt_readonly) 723 pltflags |= SEC_READONLY; 724 725 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags); 726 htab->splt = s; 727 if (s == NULL 728 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 729 return FALSE; 730 731 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 732 .plt section. */ 733 if (bed->want_plt_sym) 734 { 735 h = _bfd_elf_define_linkage_sym (abfd, info, s, 736 "_PROCEDURE_LINKAGE_TABLE_"); 737 htab->hplt = h; 738 if (h == NULL) 739 return FALSE; 740 } 741 742 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 743 htab->sgot = s; 744 if (s == NULL 745 || ! bfd_set_section_alignment (abfd, s, ptralign)) 746 return FALSE; 747 748 if (bed->want_got_plt) 749 { 750 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 751 htab->sgotplt = s; 752 if (s == NULL 753 || ! bfd_set_section_alignment (abfd, s, ptralign)) 754 return FALSE; 755 } 756 757 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 758 (or .got.plt) section. We don't do this in the linker script 759 because we don't want to define the symbol if we are not creating 760 a global offset table. */ 761 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_"); 762 htab->hgot = h; 763 if (h == NULL) 764 return FALSE; 765 766 /* The first bit of the global offset table is the header. */ 767 s->size += bed->got_header_size; 768 769 return TRUE; 770 } 771 772 static reloc_howto_type * 773 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 774 bfd_reloc_code_real_type code) 775 { 776 unsigned int i; 777 778 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;) 779 if (mn10300_reloc_map[i].bfd_reloc_val == code) 780 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val]; 781 782 return NULL; 783 } 784 785 static reloc_howto_type * 786 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 787 const char *r_name) 788 { 789 unsigned int i; 790 791 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;) 792 if (elf_mn10300_howto_table[i].name != NULL 793 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0) 794 return elf_mn10300_howto_table + i; 795 796 return NULL; 797 } 798 799 /* Set the howto pointer for an MN10300 ELF reloc. */ 800 801 static void 802 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 803 arelent *cache_ptr, 804 Elf_Internal_Rela *dst) 805 { 806 unsigned int r_type; 807 808 r_type = ELF32_R_TYPE (dst->r_info); 809 if (r_type >= R_MN10300_MAX) 810 { 811 (*_bfd_error_handler) (_("%B: unrecognised MN10300 reloc number: %d"), 812 abfd, r_type); 813 bfd_set_error (bfd_error_bad_value); 814 r_type = R_MN10300_NONE; 815 } 816 cache_ptr->howto = elf_mn10300_howto_table + r_type; 817 } 818 819 static int 820 elf_mn10300_tls_transition (struct bfd_link_info * info, 821 int r_type, 822 struct elf_link_hash_entry * h, 823 asection * sec, 824 bfd_boolean counting) 825 { 826 bfd_boolean is_local; 827 828 if (r_type == R_MN10300_TLS_GD 829 && h != NULL 830 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE) 831 return R_MN10300_TLS_GOTIE; 832 833 if (bfd_link_pic (info)) 834 return r_type; 835 836 if (! (sec->flags & SEC_CODE)) 837 return r_type; 838 839 if (! counting && h != NULL && ! elf_hash_table (info)->dynamic_sections_created) 840 is_local = TRUE; 841 else 842 is_local = SYMBOL_CALLS_LOCAL (info, h); 843 844 /* For the main program, these are the transitions we do. */ 845 switch (r_type) 846 { 847 case R_MN10300_TLS_GD: return is_local ? R_MN10300_TLS_LE : R_MN10300_TLS_GOTIE; 848 case R_MN10300_TLS_LD: return R_MN10300_NONE; 849 case R_MN10300_TLS_LDO: return R_MN10300_TLS_LE; 850 case R_MN10300_TLS_IE: 851 case R_MN10300_TLS_GOTIE: return is_local ? R_MN10300_TLS_LE : r_type; 852 } 853 854 return r_type; 855 } 856 857 /* Return the relocation value for @tpoff relocation 858 if STT_TLS virtual address is ADDRESS. */ 859 860 static bfd_vma 861 dtpoff (struct bfd_link_info * info, bfd_vma address) 862 { 863 struct elf_link_hash_table *htab = elf_hash_table (info); 864 865 /* If tls_sec is NULL, we should have signalled an error already. */ 866 if (htab->tls_sec == NULL) 867 return 0; 868 return address - htab->tls_sec->vma; 869 } 870 871 /* Return the relocation value for @tpoff relocation 872 if STT_TLS virtual address is ADDRESS. */ 873 874 static bfd_vma 875 tpoff (struct bfd_link_info * info, bfd_vma address) 876 { 877 struct elf_link_hash_table *htab = elf_hash_table (info); 878 879 /* If tls_sec is NULL, we should have signalled an error already. */ 880 if (htab->tls_sec == NULL) 881 return 0; 882 return address - (htab->tls_size + htab->tls_sec->vma); 883 } 884 885 /* Returns nonzero if there's a R_MN10300_PLT32 reloc that we now need 886 to skip, after this one. The actual value is the offset between 887 this reloc and the PLT reloc. */ 888 889 static int 890 mn10300_do_tls_transition (bfd * input_bfd, 891 unsigned int r_type, 892 unsigned int tls_r_type, 893 bfd_byte * contents, 894 bfd_vma offset) 895 { 896 bfd_byte *op = contents + offset; 897 int gotreg = 0; 898 899 #define TLS_PAIR(r1,r2) ((r1) * R_MN10300_MAX + (r2)) 900 901 /* This is common to all GD/LD transitions, so break it out. */ 902 if (r_type == R_MN10300_TLS_GD 903 || r_type == R_MN10300_TLS_LD) 904 { 905 op -= 2; 906 /* mov imm,d0. */ 907 BFD_ASSERT (bfd_get_8 (input_bfd, op) == 0xFC); 908 BFD_ASSERT (bfd_get_8 (input_bfd, op + 1) == 0xCC); 909 /* add aN,d0. */ 910 BFD_ASSERT (bfd_get_8 (input_bfd, op + 6) == 0xF1); 911 gotreg = (bfd_get_8 (input_bfd, op + 7) & 0x0c) >> 2; 912 /* Call. */ 913 BFD_ASSERT (bfd_get_8 (input_bfd, op + 8) == 0xDD); 914 } 915 916 switch (TLS_PAIR (r_type, tls_r_type)) 917 { 918 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_GOTIE): 919 { 920 /* Keep track of which register we put GOTptr in. */ 921 /* mov (_x@indntpoff,a2),a0. */ 922 memcpy (op, "\xFC\x20\x00\x00\x00\x00", 6); 923 op[1] |= gotreg; 924 /* add e2,a0. */ 925 memcpy (op+6, "\xF9\x78\x28", 3); 926 /* or 0x00000000, d0 - six byte nop. */ 927 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6); 928 } 929 return 7; 930 931 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_LE): 932 { 933 /* Register is *always* a0. */ 934 /* mov _x@tpoff,a0. */ 935 memcpy (op, "\xFC\xDC\x00\x00\x00\x00", 6); 936 /* add e2,a0. */ 937 memcpy (op+6, "\xF9\x78\x28", 3); 938 /* or 0x00000000, d0 - six byte nop. */ 939 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6); 940 } 941 return 7; 942 case TLS_PAIR (R_MN10300_TLS_LD, R_MN10300_NONE): 943 { 944 /* Register is *always* a0. */ 945 /* mov e2,a0. */ 946 memcpy (op, "\xF5\x88", 2); 947 /* or 0x00000000, d0 - six byte nop. */ 948 memcpy (op+2, "\xFC\xE4\x00\x00\x00\x00", 6); 949 /* or 0x00000000, e2 - seven byte nop. */ 950 memcpy (op+8, "\xFE\x19\x22\x00\x00\x00\x00", 7); 951 } 952 return 7; 953 954 case TLS_PAIR (R_MN10300_TLS_LDO, R_MN10300_TLS_LE): 955 /* No changes needed, just the reloc change. */ 956 return 0; 957 958 /* These are a little tricky, because we have to detect which 959 opcode is being used (they're different sizes, with the reloc 960 at different offsets within the opcode) and convert each 961 accordingly, copying the operands as needed. The conversions 962 we do are as follows (IE,GOTIE,LE): 963 964 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn 965 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn 966 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn 967 968 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An 969 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An 970 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An 971 972 1111 1110 0000 1110 Rnnn Xxxx [-- abs32 --] MOV (x@indntpoff),Rn 973 1111 1110 0000 1010 Rnnn Rmmm [-- abs32 --] MOV (x@indntpoff,Rm),Rn 974 1111 1110 0000 1000 Rnnn Xxxx [-- abs32 --] MOV x@tpoff,Rn 975 976 Since the GOT pointer is always $a2, we assume the last 977 normally won't happen, but let's be paranoid and plan for the 978 day that GCC optimizes it somewhow. */ 979 980 case TLS_PAIR (R_MN10300_TLS_IE, R_MN10300_TLS_LE): 981 if (op[-2] == 0xFC) 982 { 983 op -= 2; 984 if ((op[1] & 0xFC) == 0xA4) /* Dn */ 985 { 986 op[1] &= 0x03; /* Leaves Dn. */ 987 op[1] |= 0xCC; 988 } 989 else /* An */ 990 { 991 op[1] &= 0x03; /* Leaves An. */ 992 op[1] |= 0xDC; 993 } 994 } 995 else if (op[-3] == 0xFE) 996 op[-2] = 0x08; 997 else 998 abort (); 999 break; 1000 1001 case TLS_PAIR (R_MN10300_TLS_GOTIE, R_MN10300_TLS_LE): 1002 if (op[-2] == 0xFC) 1003 { 1004 op -= 2; 1005 if ((op[1] & 0xF0) == 0x00) /* Dn */ 1006 { 1007 op[1] &= 0x0C; /* Leaves Dn. */ 1008 op[1] >>= 2; 1009 op[1] |= 0xCC; 1010 } 1011 else /* An */ 1012 { 1013 op[1] &= 0x0C; /* Leaves An. */ 1014 op[1] >>= 2; 1015 op[1] |= 0xDC; 1016 } 1017 } 1018 else if (op[-3] == 0xFE) 1019 op[-2] = 0x08; 1020 else 1021 abort (); 1022 break; 1023 1024 default: 1025 (*_bfd_error_handler) 1026 (_("%s: Unsupported transition from %s to %s"), 1027 bfd_get_filename (input_bfd), 1028 elf_mn10300_howto_table[r_type].name, 1029 elf_mn10300_howto_table[tls_r_type].name); 1030 break; 1031 } 1032 #undef TLS_PAIR 1033 return 0; 1034 } 1035 1036 /* Look through the relocs for a section during the first phase. 1037 Since we don't do .gots or .plts, we just need to consider the 1038 virtual table relocs for gc. */ 1039 1040 static bfd_boolean 1041 mn10300_elf_check_relocs (bfd *abfd, 1042 struct bfd_link_info *info, 1043 asection *sec, 1044 const Elf_Internal_Rela *relocs) 1045 { 1046 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info); 1047 bfd_boolean sym_diff_reloc_seen; 1048 Elf_Internal_Shdr *symtab_hdr; 1049 Elf_Internal_Sym * isymbuf = NULL; 1050 struct elf_link_hash_entry **sym_hashes; 1051 const Elf_Internal_Rela *rel; 1052 const Elf_Internal_Rela *rel_end; 1053 bfd * dynobj; 1054 bfd_vma * local_got_offsets; 1055 asection * sgot; 1056 asection * srelgot; 1057 asection * sreloc; 1058 bfd_boolean result = FALSE; 1059 1060 sgot = NULL; 1061 srelgot = NULL; 1062 sreloc = NULL; 1063 1064 if (bfd_link_relocatable (info)) 1065 return TRUE; 1066 1067 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1068 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 1069 sym_hashes = elf_sym_hashes (abfd); 1070 1071 dynobj = elf_hash_table (info)->dynobj; 1072 local_got_offsets = elf_local_got_offsets (abfd); 1073 rel_end = relocs + sec->reloc_count; 1074 sym_diff_reloc_seen = FALSE; 1075 1076 for (rel = relocs; rel < rel_end; rel++) 1077 { 1078 struct elf_link_hash_entry *h; 1079 unsigned long r_symndx; 1080 unsigned int r_type; 1081 int tls_type = GOT_NORMAL; 1082 1083 r_symndx = ELF32_R_SYM (rel->r_info); 1084 if (r_symndx < symtab_hdr->sh_info) 1085 h = NULL; 1086 else 1087 { 1088 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1089 while (h->root.type == bfd_link_hash_indirect 1090 || h->root.type == bfd_link_hash_warning) 1091 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1092 1093 /* PR15323, ref flags aren't set for references in the same 1094 object. */ 1095 h->root.non_ir_ref = 1; 1096 } 1097 1098 r_type = ELF32_R_TYPE (rel->r_info); 1099 r_type = elf_mn10300_tls_transition (info, r_type, h, sec, TRUE); 1100 1101 /* Some relocs require a global offset table. */ 1102 if (dynobj == NULL) 1103 { 1104 switch (r_type) 1105 { 1106 case R_MN10300_GOT32: 1107 case R_MN10300_GOT24: 1108 case R_MN10300_GOT16: 1109 case R_MN10300_GOTOFF32: 1110 case R_MN10300_GOTOFF24: 1111 case R_MN10300_GOTOFF16: 1112 case R_MN10300_GOTPC32: 1113 case R_MN10300_GOTPC16: 1114 case R_MN10300_TLS_GD: 1115 case R_MN10300_TLS_LD: 1116 case R_MN10300_TLS_GOTIE: 1117 case R_MN10300_TLS_IE: 1118 elf_hash_table (info)->dynobj = dynobj = abfd; 1119 if (! _bfd_mn10300_elf_create_got_section (dynobj, info)) 1120 goto fail; 1121 break; 1122 1123 default: 1124 break; 1125 } 1126 } 1127 1128 switch (r_type) 1129 { 1130 /* This relocation describes the C++ object vtable hierarchy. 1131 Reconstruct it for later use during GC. */ 1132 case R_MN10300_GNU_VTINHERIT: 1133 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1134 goto fail; 1135 break; 1136 1137 /* This relocation describes which C++ vtable entries are actually 1138 used. Record for later use during GC. */ 1139 case R_MN10300_GNU_VTENTRY: 1140 BFD_ASSERT (h != NULL); 1141 if (h != NULL 1142 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1143 goto fail; 1144 break; 1145 1146 case R_MN10300_TLS_LD: 1147 htab->tls_ldm_got.refcount ++; 1148 tls_type = GOT_TLS_LD; 1149 1150 if (htab->tls_ldm_got.got_allocated) 1151 break; 1152 goto create_got; 1153 1154 case R_MN10300_TLS_IE: 1155 case R_MN10300_TLS_GOTIE: 1156 if (bfd_link_pic (info)) 1157 info->flags |= DF_STATIC_TLS; 1158 /* Fall through */ 1159 1160 case R_MN10300_TLS_GD: 1161 case R_MN10300_GOT32: 1162 case R_MN10300_GOT24: 1163 case R_MN10300_GOT16: 1164 create_got: 1165 /* This symbol requires a global offset table entry. */ 1166 1167 switch (r_type) 1168 { 1169 case R_MN10300_TLS_IE: 1170 case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break; 1171 case R_MN10300_TLS_GD: tls_type = GOT_TLS_GD; break; 1172 default: tls_type = GOT_NORMAL; break; 1173 } 1174 1175 if (sgot == NULL) 1176 { 1177 sgot = htab->root.sgot; 1178 BFD_ASSERT (sgot != NULL); 1179 } 1180 1181 if (srelgot == NULL 1182 && (h != NULL || bfd_link_pic (info))) 1183 { 1184 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1185 if (srelgot == NULL) 1186 { 1187 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1188 | SEC_IN_MEMORY | SEC_LINKER_CREATED 1189 | SEC_READONLY); 1190 srelgot = bfd_make_section_anyway_with_flags (dynobj, 1191 ".rela.got", 1192 flags); 1193 if (srelgot == NULL 1194 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 1195 goto fail; 1196 } 1197 } 1198 1199 if (r_type == R_MN10300_TLS_LD) 1200 { 1201 htab->tls_ldm_got.offset = sgot->size; 1202 htab->tls_ldm_got.got_allocated ++; 1203 } 1204 else if (h != NULL) 1205 { 1206 if (elf_mn10300_hash_entry (h)->tls_type != tls_type 1207 && elf_mn10300_hash_entry (h)->tls_type != GOT_UNKNOWN) 1208 { 1209 if (tls_type == GOT_TLS_IE 1210 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_GD) 1211 /* No change - this is ok. */; 1212 else if (tls_type == GOT_TLS_GD 1213 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE) 1214 /* Transition GD->IE. */ 1215 tls_type = GOT_TLS_IE; 1216 else 1217 (*_bfd_error_handler) 1218 (_("%B: %s' accessed both as normal and thread local symbol"), 1219 abfd, h ? h->root.root.string : "<local>"); 1220 } 1221 1222 elf_mn10300_hash_entry (h)->tls_type = tls_type; 1223 1224 if (h->got.offset != (bfd_vma) -1) 1225 /* We have already allocated space in the .got. */ 1226 break; 1227 1228 h->got.offset = sgot->size; 1229 1230 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL 1231 /* Make sure this symbol is output as a dynamic symbol. */ 1232 && h->dynindx == -1) 1233 { 1234 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1235 goto fail; 1236 } 1237 1238 srelgot->size += sizeof (Elf32_External_Rela); 1239 if (r_type == R_MN10300_TLS_GD) 1240 srelgot->size += sizeof (Elf32_External_Rela); 1241 } 1242 else 1243 { 1244 /* This is a global offset table entry for a local 1245 symbol. */ 1246 if (local_got_offsets == NULL) 1247 { 1248 size_t size; 1249 unsigned int i; 1250 1251 size = symtab_hdr->sh_info * (sizeof (bfd_vma) + sizeof (char)); 1252 local_got_offsets = bfd_alloc (abfd, size); 1253 1254 if (local_got_offsets == NULL) 1255 goto fail; 1256 1257 elf_local_got_offsets (abfd) = local_got_offsets; 1258 elf_mn10300_local_got_tls_type (abfd) 1259 = (char *) (local_got_offsets + symtab_hdr->sh_info); 1260 1261 for (i = 0; i < symtab_hdr->sh_info; i++) 1262 local_got_offsets[i] = (bfd_vma) -1; 1263 } 1264 1265 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 1266 /* We have already allocated space in the .got. */ 1267 break; 1268 1269 local_got_offsets[r_symndx] = sgot->size; 1270 1271 if (bfd_link_pic (info)) 1272 { 1273 /* If we are generating a shared object, we need to 1274 output a R_MN10300_RELATIVE reloc so that the dynamic 1275 linker can adjust this GOT entry. */ 1276 srelgot->size += sizeof (Elf32_External_Rela); 1277 1278 if (r_type == R_MN10300_TLS_GD) 1279 /* And a R_MN10300_TLS_DTPOFF reloc as well. */ 1280 srelgot->size += sizeof (Elf32_External_Rela); 1281 } 1282 1283 elf_mn10300_local_got_tls_type (abfd) [r_symndx] = tls_type; 1284 } 1285 1286 sgot->size += 4; 1287 if (r_type == R_MN10300_TLS_GD 1288 || r_type == R_MN10300_TLS_LD) 1289 sgot->size += 4; 1290 1291 goto need_shared_relocs; 1292 1293 case R_MN10300_PLT32: 1294 case R_MN10300_PLT16: 1295 /* This symbol requires a procedure linkage table entry. We 1296 actually build the entry in adjust_dynamic_symbol, 1297 because this might be a case of linking PIC code which is 1298 never referenced by a dynamic object, in which case we 1299 don't need to generate a procedure linkage table entry 1300 after all. */ 1301 1302 /* If this is a local symbol, we resolve it directly without 1303 creating a procedure linkage table entry. */ 1304 if (h == NULL) 1305 continue; 1306 1307 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL 1308 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN) 1309 break; 1310 1311 h->needs_plt = 1; 1312 break; 1313 1314 case R_MN10300_24: 1315 case R_MN10300_16: 1316 case R_MN10300_8: 1317 case R_MN10300_PCREL32: 1318 case R_MN10300_PCREL16: 1319 case R_MN10300_PCREL8: 1320 if (h != NULL) 1321 h->non_got_ref = 1; 1322 break; 1323 1324 case R_MN10300_SYM_DIFF: 1325 sym_diff_reloc_seen = TRUE; 1326 break; 1327 1328 case R_MN10300_32: 1329 if (h != NULL) 1330 h->non_got_ref = 1; 1331 1332 need_shared_relocs: 1333 /* If we are creating a shared library, then we 1334 need to copy the reloc into the shared library. */ 1335 if (bfd_link_pic (info) 1336 && (sec->flags & SEC_ALLOC) != 0 1337 /* Do not generate a dynamic reloc for a 1338 reloc associated with a SYM_DIFF operation. */ 1339 && ! sym_diff_reloc_seen) 1340 { 1341 asection * sym_section = NULL; 1342 1343 /* Find the section containing the 1344 symbol involved in the relocation. */ 1345 if (h == NULL) 1346 { 1347 Elf_Internal_Sym * isym; 1348 1349 if (isymbuf == NULL) 1350 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1351 symtab_hdr->sh_info, 0, 1352 NULL, NULL, NULL); 1353 if (isymbuf) 1354 { 1355 isym = isymbuf + r_symndx; 1356 /* All we care about is whether this local symbol is absolute. */ 1357 if (isym->st_shndx == SHN_ABS) 1358 sym_section = bfd_abs_section_ptr; 1359 } 1360 } 1361 else 1362 { 1363 if (h->root.type == bfd_link_hash_defined 1364 || h->root.type == bfd_link_hash_defweak) 1365 sym_section = h->root.u.def.section; 1366 } 1367 1368 /* If the symbol is absolute then the relocation can 1369 be resolved during linking and there is no need for 1370 a dynamic reloc. */ 1371 if (sym_section != bfd_abs_section_ptr) 1372 { 1373 /* When creating a shared object, we must copy these 1374 reloc types into the output file. We create a reloc 1375 section in dynobj and make room for this reloc. */ 1376 if (sreloc == NULL) 1377 { 1378 sreloc = _bfd_elf_make_dynamic_reloc_section 1379 (sec, dynobj, 2, abfd, /*rela?*/ TRUE); 1380 if (sreloc == NULL) 1381 goto fail; 1382 } 1383 1384 sreloc->size += sizeof (Elf32_External_Rela); 1385 } 1386 } 1387 1388 break; 1389 } 1390 1391 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF) 1392 sym_diff_reloc_seen = FALSE; 1393 } 1394 1395 result = TRUE; 1396 fail: 1397 if (isymbuf != NULL) 1398 free (isymbuf); 1399 1400 return result; 1401 } 1402 1403 /* Return the section that should be marked against GC for a given 1404 relocation. */ 1405 1406 static asection * 1407 mn10300_elf_gc_mark_hook (asection *sec, 1408 struct bfd_link_info *info, 1409 Elf_Internal_Rela *rel, 1410 struct elf_link_hash_entry *h, 1411 Elf_Internal_Sym *sym) 1412 { 1413 if (h != NULL) 1414 switch (ELF32_R_TYPE (rel->r_info)) 1415 { 1416 case R_MN10300_GNU_VTINHERIT: 1417 case R_MN10300_GNU_VTENTRY: 1418 return NULL; 1419 } 1420 1421 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1422 } 1423 1424 /* Perform a relocation as part of a final link. */ 1425 1426 static bfd_reloc_status_type 1427 mn10300_elf_final_link_relocate (reloc_howto_type *howto, 1428 bfd *input_bfd, 1429 bfd *output_bfd ATTRIBUTE_UNUSED, 1430 asection *input_section, 1431 bfd_byte *contents, 1432 bfd_vma offset, 1433 bfd_vma value, 1434 bfd_vma addend, 1435 struct elf_link_hash_entry * h, 1436 unsigned long symndx, 1437 struct bfd_link_info *info, 1438 asection *sym_sec ATTRIBUTE_UNUSED, 1439 int is_local ATTRIBUTE_UNUSED) 1440 { 1441 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info); 1442 static asection * sym_diff_section; 1443 static bfd_vma sym_diff_value; 1444 bfd_boolean is_sym_diff_reloc; 1445 unsigned long r_type = howto->type; 1446 bfd_byte * hit_data = contents + offset; 1447 bfd * dynobj; 1448 asection * sgot; 1449 asection * splt; 1450 asection * sreloc; 1451 1452 dynobj = elf_hash_table (info)->dynobj; 1453 sgot = NULL; 1454 splt = NULL; 1455 sreloc = NULL; 1456 1457 switch (r_type) 1458 { 1459 case R_MN10300_24: 1460 case R_MN10300_16: 1461 case R_MN10300_8: 1462 case R_MN10300_PCREL8: 1463 case R_MN10300_PCREL16: 1464 case R_MN10300_PCREL32: 1465 case R_MN10300_GOTOFF32: 1466 case R_MN10300_GOTOFF24: 1467 case R_MN10300_GOTOFF16: 1468 if (bfd_link_pic (info) 1469 && (input_section->flags & SEC_ALLOC) != 0 1470 && h != NULL 1471 && ! SYMBOL_REFERENCES_LOCAL (info, h)) 1472 return bfd_reloc_dangerous; 1473 case R_MN10300_GOT32: 1474 /* Issue 2052223: 1475 Taking the address of a protected function in a shared library 1476 is illegal. Issue an error message here. */ 1477 if (bfd_link_pic (info) 1478 && (input_section->flags & SEC_ALLOC) != 0 1479 && h != NULL 1480 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED 1481 && (h->type == STT_FUNC || h->type == STT_GNU_IFUNC) 1482 && ! SYMBOL_REFERENCES_LOCAL (info, h)) 1483 return bfd_reloc_dangerous; 1484 } 1485 1486 is_sym_diff_reloc = FALSE; 1487 if (sym_diff_section != NULL) 1488 { 1489 BFD_ASSERT (sym_diff_section == input_section); 1490 1491 switch (r_type) 1492 { 1493 case R_MN10300_32: 1494 case R_MN10300_24: 1495 case R_MN10300_16: 1496 case R_MN10300_8: 1497 value -= sym_diff_value; 1498 /* If we are computing a 32-bit value for the location lists 1499 and the result is 0 then we add one to the value. A zero 1500 value can result because of linker relaxation deleteing 1501 prologue instructions and using a value of 1 (for the begin 1502 and end offsets in the location list entry) results in a 1503 nul entry which does not prevent the following entries from 1504 being parsed. */ 1505 if (r_type == R_MN10300_32 1506 && value == 0 1507 && strcmp (input_section->name, ".debug_loc") == 0) 1508 value = 1; 1509 sym_diff_section = NULL; 1510 is_sym_diff_reloc = TRUE; 1511 break; 1512 1513 default: 1514 sym_diff_section = NULL; 1515 break; 1516 } 1517 } 1518 1519 switch (r_type) 1520 { 1521 case R_MN10300_SYM_DIFF: 1522 BFD_ASSERT (addend == 0); 1523 /* Cache the input section and value. 1524 The offset is unreliable, since relaxation may 1525 have reduced the following reloc's offset. */ 1526 sym_diff_section = input_section; 1527 sym_diff_value = value; 1528 return bfd_reloc_ok; 1529 1530 case R_MN10300_ALIGN: 1531 case R_MN10300_NONE: 1532 return bfd_reloc_ok; 1533 1534 case R_MN10300_32: 1535 if (bfd_link_pic (info) 1536 /* Do not generate relocs when an R_MN10300_32 has been used 1537 with an R_MN10300_SYM_DIFF to compute a difference of two 1538 symbols. */ 1539 && is_sym_diff_reloc == FALSE 1540 /* Also, do not generate a reloc when the symbol associated 1541 with the R_MN10300_32 reloc is absolute - there is no 1542 need for a run time computation in this case. */ 1543 && sym_sec != bfd_abs_section_ptr 1544 /* If the section is not going to be allocated at load time 1545 then there is no need to generate relocs for it. */ 1546 && (input_section->flags & SEC_ALLOC) != 0) 1547 { 1548 Elf_Internal_Rela outrel; 1549 bfd_boolean skip, relocate; 1550 1551 /* When generating a shared object, these relocations are 1552 copied into the output file to be resolved at run 1553 time. */ 1554 if (sreloc == NULL) 1555 { 1556 sreloc = _bfd_elf_get_dynamic_reloc_section 1557 (input_bfd, input_section, /*rela?*/ TRUE); 1558 if (sreloc == NULL) 1559 return FALSE; 1560 } 1561 1562 skip = FALSE; 1563 1564 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info, 1565 input_section, offset); 1566 if (outrel.r_offset == (bfd_vma) -1) 1567 skip = TRUE; 1568 1569 outrel.r_offset += (input_section->output_section->vma 1570 + input_section->output_offset); 1571 1572 if (skip) 1573 { 1574 memset (&outrel, 0, sizeof outrel); 1575 relocate = FALSE; 1576 } 1577 else 1578 { 1579 /* h->dynindx may be -1 if this symbol was marked to 1580 become local. */ 1581 if (h == NULL 1582 || SYMBOL_REFERENCES_LOCAL (info, h)) 1583 { 1584 relocate = TRUE; 1585 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE); 1586 outrel.r_addend = value + addend; 1587 } 1588 else 1589 { 1590 BFD_ASSERT (h->dynindx != -1); 1591 relocate = FALSE; 1592 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32); 1593 outrel.r_addend = value + addend; 1594 } 1595 } 1596 1597 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1598 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents) 1599 + sreloc->reloc_count)); 1600 ++sreloc->reloc_count; 1601 1602 /* If this reloc is against an external symbol, we do 1603 not want to fiddle with the addend. Otherwise, we 1604 need to include the symbol value so that it becomes 1605 an addend for the dynamic reloc. */ 1606 if (! relocate) 1607 return bfd_reloc_ok; 1608 } 1609 value += addend; 1610 bfd_put_32 (input_bfd, value, hit_data); 1611 return bfd_reloc_ok; 1612 1613 case R_MN10300_24: 1614 value += addend; 1615 1616 if ((long) value > 0x7fffff || (long) value < -0x800000) 1617 return bfd_reloc_overflow; 1618 1619 bfd_put_8 (input_bfd, value & 0xff, hit_data); 1620 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1); 1621 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2); 1622 return bfd_reloc_ok; 1623 1624 case R_MN10300_16: 1625 value += addend; 1626 1627 if ((long) value > 0x7fff || (long) value < -0x8000) 1628 return bfd_reloc_overflow; 1629 1630 bfd_put_16 (input_bfd, value, hit_data); 1631 return bfd_reloc_ok; 1632 1633 case R_MN10300_8: 1634 value += addend; 1635 1636 if ((long) value > 0x7f || (long) value < -0x80) 1637 return bfd_reloc_overflow; 1638 1639 bfd_put_8 (input_bfd, value, hit_data); 1640 return bfd_reloc_ok; 1641 1642 case R_MN10300_PCREL8: 1643 value -= (input_section->output_section->vma 1644 + input_section->output_offset); 1645 value -= offset; 1646 value += addend; 1647 1648 if ((long) value > 0x7f || (long) value < -0x80) 1649 return bfd_reloc_overflow; 1650 1651 bfd_put_8 (input_bfd, value, hit_data); 1652 return bfd_reloc_ok; 1653 1654 case R_MN10300_PCREL16: 1655 value -= (input_section->output_section->vma 1656 + input_section->output_offset); 1657 value -= offset; 1658 value += addend; 1659 1660 if ((long) value > 0x7fff || (long) value < -0x8000) 1661 return bfd_reloc_overflow; 1662 1663 bfd_put_16 (input_bfd, value, hit_data); 1664 return bfd_reloc_ok; 1665 1666 case R_MN10300_PCREL32: 1667 value -= (input_section->output_section->vma 1668 + input_section->output_offset); 1669 value -= offset; 1670 value += addend; 1671 1672 bfd_put_32 (input_bfd, value, hit_data); 1673 return bfd_reloc_ok; 1674 1675 case R_MN10300_GNU_VTINHERIT: 1676 case R_MN10300_GNU_VTENTRY: 1677 return bfd_reloc_ok; 1678 1679 case R_MN10300_GOTPC32: 1680 if (dynobj == NULL) 1681 return bfd_reloc_dangerous; 1682 1683 /* Use global offset table as symbol value. */ 1684 value = htab->root.sgot->output_section->vma; 1685 value -= (input_section->output_section->vma 1686 + input_section->output_offset); 1687 value -= offset; 1688 value += addend; 1689 1690 bfd_put_32 (input_bfd, value, hit_data); 1691 return bfd_reloc_ok; 1692 1693 case R_MN10300_GOTPC16: 1694 if (dynobj == NULL) 1695 return bfd_reloc_dangerous; 1696 1697 /* Use global offset table as symbol value. */ 1698 value = htab->root.sgot->output_section->vma; 1699 value -= (input_section->output_section->vma 1700 + input_section->output_offset); 1701 value -= offset; 1702 value += addend; 1703 1704 if ((long) value > 0x7fff || (long) value < -0x8000) 1705 return bfd_reloc_overflow; 1706 1707 bfd_put_16 (input_bfd, value, hit_data); 1708 return bfd_reloc_ok; 1709 1710 case R_MN10300_GOTOFF32: 1711 if (dynobj == NULL) 1712 return bfd_reloc_dangerous; 1713 1714 value -= htab->root.sgot->output_section->vma; 1715 value += addend; 1716 1717 bfd_put_32 (input_bfd, value, hit_data); 1718 return bfd_reloc_ok; 1719 1720 case R_MN10300_GOTOFF24: 1721 if (dynobj == NULL) 1722 return bfd_reloc_dangerous; 1723 1724 value -= htab->root.sgot->output_section->vma; 1725 value += addend; 1726 1727 if ((long) value > 0x7fffff || (long) value < -0x800000) 1728 return bfd_reloc_overflow; 1729 1730 bfd_put_8 (input_bfd, value, hit_data); 1731 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1); 1732 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2); 1733 return bfd_reloc_ok; 1734 1735 case R_MN10300_GOTOFF16: 1736 if (dynobj == NULL) 1737 return bfd_reloc_dangerous; 1738 1739 value -= htab->root.sgot->output_section->vma; 1740 value += addend; 1741 1742 if ((long) value > 0x7fff || (long) value < -0x8000) 1743 return bfd_reloc_overflow; 1744 1745 bfd_put_16 (input_bfd, value, hit_data); 1746 return bfd_reloc_ok; 1747 1748 case R_MN10300_PLT32: 1749 if (h != NULL 1750 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL 1751 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN 1752 && h->plt.offset != (bfd_vma) -1) 1753 { 1754 if (dynobj == NULL) 1755 return bfd_reloc_dangerous; 1756 1757 splt = htab->root.splt; 1758 value = (splt->output_section->vma 1759 + splt->output_offset 1760 + h->plt.offset) - value; 1761 } 1762 1763 value -= (input_section->output_section->vma 1764 + input_section->output_offset); 1765 value -= offset; 1766 value += addend; 1767 1768 bfd_put_32 (input_bfd, value, hit_data); 1769 return bfd_reloc_ok; 1770 1771 case R_MN10300_PLT16: 1772 if (h != NULL 1773 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL 1774 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN 1775 && h->plt.offset != (bfd_vma) -1) 1776 { 1777 if (dynobj == NULL) 1778 return bfd_reloc_dangerous; 1779 1780 splt = htab->root.splt; 1781 value = (splt->output_section->vma 1782 + splt->output_offset 1783 + h->plt.offset) - value; 1784 } 1785 1786 value -= (input_section->output_section->vma 1787 + input_section->output_offset); 1788 value -= offset; 1789 value += addend; 1790 1791 if ((long) value > 0x7fff || (long) value < -0x8000) 1792 return bfd_reloc_overflow; 1793 1794 bfd_put_16 (input_bfd, value, hit_data); 1795 return bfd_reloc_ok; 1796 1797 case R_MN10300_TLS_LDO: 1798 value = dtpoff (info, value); 1799 bfd_put_32 (input_bfd, value + addend, hit_data); 1800 return bfd_reloc_ok; 1801 1802 case R_MN10300_TLS_LE: 1803 value = tpoff (info, value); 1804 bfd_put_32 (input_bfd, value + addend, hit_data); 1805 return bfd_reloc_ok; 1806 1807 case R_MN10300_TLS_LD: 1808 if (dynobj == NULL) 1809 return bfd_reloc_dangerous; 1810 1811 sgot = htab->root.sgot; 1812 BFD_ASSERT (sgot != NULL); 1813 value = htab->tls_ldm_got.offset + sgot->output_offset; 1814 bfd_put_32 (input_bfd, value, hit_data); 1815 1816 if (!htab->tls_ldm_got.rel_emitted) 1817 { 1818 asection * srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1819 Elf_Internal_Rela rel; 1820 1821 BFD_ASSERT (srelgot != NULL); 1822 htab->tls_ldm_got.rel_emitted ++; 1823 rel.r_offset = (sgot->output_section->vma 1824 + sgot->output_offset 1825 + htab->tls_ldm_got.offset); 1826 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset); 1827 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset+4); 1828 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD); 1829 rel.r_addend = 0; 1830 bfd_elf32_swap_reloca_out (output_bfd, & rel, 1831 (bfd_byte *) ((Elf32_External_Rela *) srelgot->contents 1832 + srelgot->reloc_count)); 1833 ++ srelgot->reloc_count; 1834 } 1835 1836 return bfd_reloc_ok; 1837 1838 case R_MN10300_TLS_GOTIE: 1839 value = tpoff (info, value); 1840 /* Fall Through. */ 1841 1842 case R_MN10300_TLS_GD: 1843 case R_MN10300_TLS_IE: 1844 case R_MN10300_GOT32: 1845 case R_MN10300_GOT24: 1846 case R_MN10300_GOT16: 1847 if (dynobj == NULL) 1848 return bfd_reloc_dangerous; 1849 1850 sgot = htab->root.sgot; 1851 if (r_type == R_MN10300_TLS_GD) 1852 value = dtpoff (info, value); 1853 1854 if (h != NULL) 1855 { 1856 bfd_vma off; 1857 1858 off = h->got.offset; 1859 /* Offsets in the GOT are allocated in check_relocs 1860 which is not called for shared libraries... */ 1861 if (off == (bfd_vma) -1) 1862 off = 0; 1863 1864 if (sgot->contents != NULL 1865 && (! elf_hash_table (info)->dynamic_sections_created 1866 || SYMBOL_REFERENCES_LOCAL (info, h))) 1867 /* This is actually a static link, or it is a 1868 -Bsymbolic link and the symbol is defined 1869 locally, or the symbol was forced to be local 1870 because of a version file. We must initialize 1871 this entry in the global offset table. 1872 1873 When doing a dynamic link, we create a .rela.got 1874 relocation entry to initialize the value. This 1875 is done in the finish_dynamic_symbol routine. */ 1876 bfd_put_32 (output_bfd, value, 1877 sgot->contents + off); 1878 1879 value = sgot->output_offset + off; 1880 } 1881 else 1882 { 1883 bfd_vma off; 1884 1885 off = elf_local_got_offsets (input_bfd)[symndx]; 1886 1887 if (off & 1) 1888 bfd_put_32 (output_bfd, value, sgot->contents + (off & ~ 1)); 1889 else 1890 { 1891 bfd_put_32 (output_bfd, value, sgot->contents + off); 1892 1893 if (bfd_link_pic (info)) 1894 { 1895 asection * srelgot; 1896 Elf_Internal_Rela outrel; 1897 1898 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 1899 BFD_ASSERT (srelgot != NULL); 1900 1901 outrel.r_offset = (sgot->output_section->vma 1902 + sgot->output_offset 1903 + off); 1904 switch (r_type) 1905 { 1906 case R_MN10300_TLS_GD: 1907 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPOFF); 1908 outrel.r_offset = (sgot->output_section->vma 1909 + sgot->output_offset 1910 + off + 4); 1911 bfd_elf32_swap_reloca_out (output_bfd, & outrel, 1912 (bfd_byte *) (((Elf32_External_Rela *) 1913 srelgot->contents) 1914 + srelgot->reloc_count)); 1915 ++ srelgot->reloc_count; 1916 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD); 1917 break; 1918 case R_MN10300_TLS_GOTIE: 1919 case R_MN10300_TLS_IE: 1920 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF); 1921 break; 1922 default: 1923 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE); 1924 break; 1925 } 1926 1927 outrel.r_addend = value; 1928 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1929 (bfd_byte *) (((Elf32_External_Rela *) 1930 srelgot->contents) 1931 + srelgot->reloc_count)); 1932 ++ srelgot->reloc_count; 1933 elf_local_got_offsets (input_bfd)[symndx] |= 1; 1934 } 1935 1936 value = sgot->output_offset + (off & ~(bfd_vma) 1); 1937 } 1938 } 1939 1940 value += addend; 1941 1942 if (r_type == R_MN10300_TLS_IE) 1943 { 1944 value += sgot->output_section->vma; 1945 bfd_put_32 (input_bfd, value, hit_data); 1946 return bfd_reloc_ok; 1947 } 1948 else if (r_type == R_MN10300_TLS_GOTIE 1949 || r_type == R_MN10300_TLS_GD 1950 || r_type == R_MN10300_TLS_LD) 1951 { 1952 bfd_put_32 (input_bfd, value, hit_data); 1953 return bfd_reloc_ok; 1954 } 1955 else if (r_type == R_MN10300_GOT32) 1956 { 1957 bfd_put_32 (input_bfd, value, hit_data); 1958 return bfd_reloc_ok; 1959 } 1960 else if (r_type == R_MN10300_GOT24) 1961 { 1962 if ((long) value > 0x7fffff || (long) value < -0x800000) 1963 return bfd_reloc_overflow; 1964 1965 bfd_put_8 (input_bfd, value & 0xff, hit_data); 1966 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1); 1967 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2); 1968 return bfd_reloc_ok; 1969 } 1970 else if (r_type == R_MN10300_GOT16) 1971 { 1972 if ((long) value > 0x7fff || (long) value < -0x8000) 1973 return bfd_reloc_overflow; 1974 1975 bfd_put_16 (input_bfd, value, hit_data); 1976 return bfd_reloc_ok; 1977 } 1978 /* Fall through. */ 1979 1980 default: 1981 return bfd_reloc_notsupported; 1982 } 1983 } 1984 1985 /* Relocate an MN10300 ELF section. */ 1987 1988 static bfd_boolean 1989 mn10300_elf_relocate_section (bfd *output_bfd, 1990 struct bfd_link_info *info, 1991 bfd *input_bfd, 1992 asection *input_section, 1993 bfd_byte *contents, 1994 Elf_Internal_Rela *relocs, 1995 Elf_Internal_Sym *local_syms, 1996 asection **local_sections) 1997 { 1998 Elf_Internal_Shdr *symtab_hdr; 1999 struct elf_link_hash_entry **sym_hashes; 2000 Elf_Internal_Rela *rel, *relend; 2001 Elf_Internal_Rela * trel; 2002 2003 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2004 sym_hashes = elf_sym_hashes (input_bfd); 2005 2006 rel = relocs; 2007 relend = relocs + input_section->reloc_count; 2008 for (; rel < relend; rel++) 2009 { 2010 int r_type; 2011 reloc_howto_type *howto; 2012 unsigned long r_symndx; 2013 Elf_Internal_Sym *sym; 2014 asection *sec; 2015 struct elf32_mn10300_link_hash_entry *h; 2016 bfd_vma relocation; 2017 bfd_reloc_status_type r; 2018 int tls_r_type; 2019 bfd_boolean unresolved_reloc = FALSE; 2020 bfd_boolean warned, ignored; 2021 struct elf_link_hash_entry * hh; 2022 2023 relocation = 0; 2024 r_symndx = ELF32_R_SYM (rel->r_info); 2025 r_type = ELF32_R_TYPE (rel->r_info); 2026 howto = elf_mn10300_howto_table + r_type; 2027 2028 /* Just skip the vtable gc relocs. */ 2029 if (r_type == R_MN10300_GNU_VTINHERIT 2030 || r_type == R_MN10300_GNU_VTENTRY) 2031 continue; 2032 2033 h = NULL; 2034 sym = NULL; 2035 sec = NULL; 2036 if (r_symndx < symtab_hdr->sh_info) 2037 hh = NULL; 2038 else 2039 { 2040 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2041 r_symndx, symtab_hdr, sym_hashes, 2042 hh, sec, relocation, 2043 unresolved_reloc, warned, ignored); 2044 } 2045 h = elf_mn10300_hash_entry (hh); 2046 2047 tls_r_type = elf_mn10300_tls_transition (info, r_type, hh, input_section, 0); 2048 if (tls_r_type != r_type) 2049 { 2050 bfd_boolean had_plt; 2051 2052 had_plt = mn10300_do_tls_transition (input_bfd, r_type, tls_r_type, 2053 contents, rel->r_offset); 2054 r_type = tls_r_type; 2055 howto = elf_mn10300_howto_table + r_type; 2056 2057 if (had_plt) 2058 for (trel = rel+1; trel < relend; trel++) 2059 if ((ELF32_R_TYPE (trel->r_info) == R_MN10300_PLT32 2060 || ELF32_R_TYPE (trel->r_info) == R_MN10300_PCREL32) 2061 && rel->r_offset + had_plt == trel->r_offset) 2062 trel->r_info = ELF32_R_INFO (0, R_MN10300_NONE); 2063 } 2064 2065 if (r_symndx < symtab_hdr->sh_info) 2066 { 2067 sym = local_syms + r_symndx; 2068 sec = local_sections[r_symndx]; 2069 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2070 } 2071 else 2072 { 2073 if ((h->root.root.type == bfd_link_hash_defined 2074 || h->root.root.type == bfd_link_hash_defweak) 2075 && ( r_type == R_MN10300_GOTPC32 2076 || r_type == R_MN10300_GOTPC16 2077 || (( r_type == R_MN10300_PLT32 2078 || r_type == R_MN10300_PLT16) 2079 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL 2080 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN 2081 && h->root.plt.offset != (bfd_vma) -1) 2082 || (( r_type == R_MN10300_GOT32 2083 || r_type == R_MN10300_GOT24 2084 || r_type == R_MN10300_TLS_GD 2085 || r_type == R_MN10300_TLS_LD 2086 || r_type == R_MN10300_TLS_GOTIE 2087 || r_type == R_MN10300_TLS_IE 2088 || r_type == R_MN10300_GOT16) 2089 && elf_hash_table (info)->dynamic_sections_created 2090 && !SYMBOL_REFERENCES_LOCAL (info, hh)) 2091 || (r_type == R_MN10300_32 2092 /* _32 relocs in executables force _COPY relocs, 2093 such that the address of the symbol ends up 2094 being local. */ 2095 && !bfd_link_executable (info) 2096 && !SYMBOL_REFERENCES_LOCAL (info, hh) 2097 && ((input_section->flags & SEC_ALLOC) != 0 2098 /* DWARF will emit R_MN10300_32 relocations 2099 in its sections against symbols defined 2100 externally in shared libraries. We can't 2101 do anything with them here. */ 2102 || ((input_section->flags & SEC_DEBUGGING) != 0 2103 && h->root.def_dynamic))))) 2104 /* In these cases, we don't need the relocation 2105 value. We check specially because in some 2106 obscure cases sec->output_section will be NULL. */ 2107 relocation = 0; 2108 2109 else if (!bfd_link_relocatable (info) && unresolved_reloc 2110 && _bfd_elf_section_offset (output_bfd, info, input_section, 2111 rel->r_offset) != (bfd_vma) -1) 2112 2113 (*_bfd_error_handler) 2114 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 2115 input_bfd, 2116 input_section, 2117 (long) rel->r_offset, 2118 howto->name, 2119 h->root.root.root.string); 2120 } 2121 2122 if (sec != NULL && discarded_section (sec)) 2123 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2124 rel, 1, relend, howto, 0, contents); 2125 2126 if (bfd_link_relocatable (info)) 2127 continue; 2128 2129 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd, 2130 input_section, 2131 contents, rel->r_offset, 2132 relocation, rel->r_addend, 2133 (struct elf_link_hash_entry *) h, 2134 r_symndx, 2135 info, sec, h == NULL); 2136 2137 if (r != bfd_reloc_ok) 2138 { 2139 const char *name; 2140 const char *msg = NULL; 2141 2142 if (h != NULL) 2143 name = h->root.root.root.string; 2144 else 2145 { 2146 name = (bfd_elf_string_from_elf_section 2147 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 2148 if (name == NULL || *name == '\0') 2149 name = bfd_section_name (input_bfd, sec); 2150 } 2151 2152 switch (r) 2153 { 2154 case bfd_reloc_overflow: 2155 (*info->callbacks->reloc_overflow) 2156 (info, (h ? &h->root.root : NULL), name, howto->name, 2157 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 2158 break; 2159 2160 case bfd_reloc_undefined: 2161 (*info->callbacks->undefined_symbol) 2162 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 2163 break; 2164 2165 case bfd_reloc_outofrange: 2166 msg = _("internal error: out of range error"); 2167 goto common_error; 2168 2169 case bfd_reloc_notsupported: 2170 msg = _("internal error: unsupported relocation error"); 2171 goto common_error; 2172 2173 case bfd_reloc_dangerous: 2174 if (r_type == R_MN10300_PCREL32) 2175 msg = _("error: inappropriate relocation type for shared" 2176 " library (did you forget -fpic?)"); 2177 else if (r_type == R_MN10300_GOT32) 2178 msg = _("%B: taking the address of protected function" 2179 " '%s' cannot be done when making a shared library"); 2180 else 2181 msg = _("internal error: suspicious relocation type used" 2182 " in shared library"); 2183 goto common_error; 2184 2185 default: 2186 msg = _("internal error: unknown error"); 2187 /* Fall through. */ 2188 2189 common_error: 2190 _bfd_error_handler (msg, input_bfd, name); 2191 bfd_set_error (bfd_error_bad_value); 2192 return FALSE; 2193 } 2194 } 2195 } 2196 2197 return TRUE; 2198 } 2199 2200 /* Finish initializing one hash table entry. */ 2201 2202 static bfd_boolean 2203 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry, 2204 void * in_args) 2205 { 2206 struct elf32_mn10300_link_hash_entry *entry; 2207 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args; 2208 unsigned int byte_count = 0; 2209 2210 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry; 2211 2212 /* If we already know we want to convert "call" to "calls" for calls 2213 to this symbol, then return now. */ 2214 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS) 2215 return TRUE; 2216 2217 /* If there are no named calls to this symbol, or there's nothing we 2218 can move from the function itself into the "call" instruction, 2219 then note that all "call" instructions should be converted into 2220 "calls" instructions and return. If a symbol is available for 2221 dynamic symbol resolution (overridable or overriding), avoid 2222 custom calling conventions. */ 2223 if (entry->direct_calls == 0 2224 || (entry->stack_size == 0 && entry->movm_args == 0) 2225 || (elf_hash_table (link_info)->dynamic_sections_created 2226 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL 2227 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN)) 2228 { 2229 /* Make a note that we should convert "call" instructions to "calls" 2230 instructions for calls to this symbol. */ 2231 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS; 2232 return TRUE; 2233 } 2234 2235 /* We may be able to move some instructions from the function itself into 2236 the "call" instruction. Count how many bytes we might be able to 2237 eliminate in the function itself. */ 2238 2239 /* A movm instruction is two bytes. */ 2240 if (entry->movm_args) 2241 byte_count += 2; 2242 2243 /* Count the insn to allocate stack space too. */ 2244 if (entry->stack_size > 0) 2245 { 2246 if (entry->stack_size <= 128) 2247 byte_count += 3; 2248 else 2249 byte_count += 4; 2250 } 2251 2252 /* If using "call" will result in larger code, then turn all 2253 the associated "call" instructions into "calls" instructions. */ 2254 if (byte_count < entry->direct_calls) 2255 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS; 2256 2257 /* This routine never fails. */ 2258 return TRUE; 2259 } 2260 2261 /* Used to count hash table entries. */ 2262 2263 static bfd_boolean 2264 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED, 2265 void * in_args) 2266 { 2267 int *count = (int *) in_args; 2268 2269 (*count) ++; 2270 return TRUE; 2271 } 2272 2273 /* Used to enumerate hash table entries into a linear array. */ 2274 2275 static bfd_boolean 2276 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry, 2277 void * in_args) 2278 { 2279 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args; 2280 2281 **ptr = gen_entry; 2282 (*ptr) ++; 2283 return TRUE; 2284 } 2285 2286 /* Used to sort the array created by the above. */ 2287 2288 static int 2289 sort_by_value (const void *va, const void *vb) 2290 { 2291 struct elf32_mn10300_link_hash_entry *a 2292 = *(struct elf32_mn10300_link_hash_entry **) va; 2293 struct elf32_mn10300_link_hash_entry *b 2294 = *(struct elf32_mn10300_link_hash_entry **) vb; 2295 2296 return a->value - b->value; 2297 } 2298 2299 /* Compute the stack size and movm arguments for the function 2300 referred to by HASH at address ADDR in section with 2301 contents CONTENTS, store the information in the hash table. */ 2302 2303 static void 2304 compute_function_info (bfd *abfd, 2305 struct elf32_mn10300_link_hash_entry *hash, 2306 bfd_vma addr, 2307 unsigned char *contents) 2308 { 2309 unsigned char byte1, byte2; 2310 /* We only care about a very small subset of the possible prologue 2311 sequences here. Basically we look for: 2312 2313 movm [d2,d3,a2,a3],sp (optional) 2314 add <size>,sp (optional, and only for sizes which fit in an unsigned 2315 8 bit number) 2316 2317 If we find anything else, we quit. */ 2318 2319 /* Look for movm [regs],sp. */ 2320 byte1 = bfd_get_8 (abfd, contents + addr); 2321 byte2 = bfd_get_8 (abfd, contents + addr + 1); 2322 2323 if (byte1 == 0xcf) 2324 { 2325 hash->movm_args = byte2; 2326 addr += 2; 2327 byte1 = bfd_get_8 (abfd, contents + addr); 2328 byte2 = bfd_get_8 (abfd, contents + addr + 1); 2329 } 2330 2331 /* Now figure out how much stack space will be allocated by the movm 2332 instruction. We need this kept separate from the function's normal 2333 stack space. */ 2334 if (hash->movm_args) 2335 { 2336 /* Space for d2. */ 2337 if (hash->movm_args & 0x80) 2338 hash->movm_stack_size += 4; 2339 2340 /* Space for d3. */ 2341 if (hash->movm_args & 0x40) 2342 hash->movm_stack_size += 4; 2343 2344 /* Space for a2. */ 2345 if (hash->movm_args & 0x20) 2346 hash->movm_stack_size += 4; 2347 2348 /* Space for a3. */ 2349 if (hash->movm_args & 0x10) 2350 hash->movm_stack_size += 4; 2351 2352 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */ 2353 if (hash->movm_args & 0x08) 2354 hash->movm_stack_size += 8 * 4; 2355 2356 if (bfd_get_mach (abfd) == bfd_mach_am33 2357 || bfd_get_mach (abfd) == bfd_mach_am33_2) 2358 { 2359 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */ 2360 if (hash->movm_args & 0x1) 2361 hash->movm_stack_size += 6 * 4; 2362 2363 /* exreg1 space. e4, e5, e6, e7 */ 2364 if (hash->movm_args & 0x2) 2365 hash->movm_stack_size += 4 * 4; 2366 2367 /* exreg0 space. e2, e3 */ 2368 if (hash->movm_args & 0x4) 2369 hash->movm_stack_size += 2 * 4; 2370 } 2371 } 2372 2373 /* Now look for the two stack adjustment variants. */ 2374 if (byte1 == 0xf8 && byte2 == 0xfe) 2375 { 2376 int temp = bfd_get_8 (abfd, contents + addr + 2); 2377 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80; 2378 2379 hash->stack_size = -temp; 2380 } 2381 else if (byte1 == 0xfa && byte2 == 0xfe) 2382 { 2383 int temp = bfd_get_16 (abfd, contents + addr + 2); 2384 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000; 2385 temp = -temp; 2386 2387 if (temp < 255) 2388 hash->stack_size = temp; 2389 } 2390 2391 /* If the total stack to be allocated by the call instruction is more 2392 than 255 bytes, then we can't remove the stack adjustment by using 2393 "call" (we might still be able to remove the "movm" instruction. */ 2394 if (hash->stack_size + hash->movm_stack_size > 255) 2395 hash->stack_size = 0; 2396 } 2397 2398 /* Delete some bytes from a section while relaxing. */ 2399 2400 static bfd_boolean 2401 mn10300_elf_relax_delete_bytes (bfd *abfd, 2402 asection *sec, 2403 bfd_vma addr, 2404 int count) 2405 { 2406 Elf_Internal_Shdr *symtab_hdr; 2407 unsigned int sec_shndx; 2408 bfd_byte *contents; 2409 Elf_Internal_Rela *irel, *irelend; 2410 Elf_Internal_Rela *irelalign; 2411 bfd_vma toaddr; 2412 Elf_Internal_Sym *isym, *isymend; 2413 struct elf_link_hash_entry **sym_hashes; 2414 struct elf_link_hash_entry **end_hashes; 2415 unsigned int symcount; 2416 2417 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 2418 2419 contents = elf_section_data (sec)->this_hdr.contents; 2420 2421 irelalign = NULL; 2422 toaddr = sec->size; 2423 2424 irel = elf_section_data (sec)->relocs; 2425 irelend = irel + sec->reloc_count; 2426 2427 if (sec->reloc_count > 0) 2428 { 2429 /* If there is an align reloc at the end of the section ignore it. 2430 GAS creates these relocs for reasons of its own, and they just 2431 serve to keep the section artifically inflated. */ 2432 if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN) 2433 --irelend; 2434 2435 /* The deletion must stop at the next ALIGN reloc for an aligment 2436 power larger than, or not a multiple of, the number of bytes we 2437 are deleting. */ 2438 for (; irel < irelend; irel++) 2439 { 2440 int alignment = 1 << irel->r_addend; 2441 2442 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN 2443 && irel->r_offset > addr 2444 && irel->r_offset < toaddr 2445 && (count < alignment 2446 || alignment % count != 0)) 2447 { 2448 irelalign = irel; 2449 toaddr = irel->r_offset; 2450 break; 2451 } 2452 } 2453 } 2454 2455 /* Actually delete the bytes. */ 2456 memmove (contents + addr, contents + addr + count, 2457 (size_t) (toaddr - addr - count)); 2458 2459 /* Adjust the section's size if we are shrinking it, or else 2460 pad the bytes between the end of the shrunken region and 2461 the start of the next region with NOP codes. */ 2462 if (irelalign == NULL) 2463 { 2464 sec->size -= count; 2465 /* Include symbols at the end of the section, but 2466 not at the end of a sub-region of the section. */ 2467 toaddr ++; 2468 } 2469 else 2470 { 2471 int i; 2472 2473 #define NOP_OPCODE 0xcb 2474 2475 for (i = 0; i < count; i ++) 2476 bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i); 2477 } 2478 2479 /* Adjust all the relocs. */ 2480 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 2481 { 2482 /* Get the new reloc address. */ 2483 if ((irel->r_offset > addr 2484 && irel->r_offset < toaddr) 2485 || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN 2486 && irel->r_offset == toaddr)) 2487 irel->r_offset -= count; 2488 } 2489 2490 /* Adjust the local symbols in the section, reducing their value 2491 by the number of bytes deleted. Note - symbols within the deleted 2492 region are moved to the address of the start of the region, which 2493 actually means that they will address the byte beyond the end of 2494 the region once the deletion has been completed. */ 2495 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2496 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 2497 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 2498 { 2499 if (isym->st_shndx == sec_shndx 2500 && isym->st_value > addr 2501 && isym->st_value < toaddr) 2502 { 2503 if (isym->st_value < addr + count) 2504 isym->st_value = addr; 2505 else 2506 isym->st_value -= count; 2507 } 2508 /* Adjust the function symbol's size as well. */ 2509 else if (isym->st_shndx == sec_shndx 2510 && ELF_ST_TYPE (isym->st_info) == STT_FUNC 2511 && isym->st_value + isym->st_size > addr 2512 && isym->st_value + isym->st_size < toaddr) 2513 isym->st_size -= count; 2514 } 2515 2516 /* Now adjust the global symbols defined in this section. */ 2517 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2518 - symtab_hdr->sh_info); 2519 sym_hashes = elf_sym_hashes (abfd); 2520 end_hashes = sym_hashes + symcount; 2521 for (; sym_hashes < end_hashes; sym_hashes++) 2522 { 2523 struct elf_link_hash_entry *sym_hash = *sym_hashes; 2524 2525 if ((sym_hash->root.type == bfd_link_hash_defined 2526 || sym_hash->root.type == bfd_link_hash_defweak) 2527 && sym_hash->root.u.def.section == sec 2528 && sym_hash->root.u.def.value > addr 2529 && sym_hash->root.u.def.value < toaddr) 2530 { 2531 if (sym_hash->root.u.def.value < addr + count) 2532 sym_hash->root.u.def.value = addr; 2533 else 2534 sym_hash->root.u.def.value -= count; 2535 } 2536 /* Adjust the function symbol's size as well. */ 2537 else if (sym_hash->root.type == bfd_link_hash_defined 2538 && sym_hash->root.u.def.section == sec 2539 && sym_hash->type == STT_FUNC 2540 && sym_hash->root.u.def.value + sym_hash->size > addr 2541 && sym_hash->root.u.def.value + sym_hash->size < toaddr) 2542 sym_hash->size -= count; 2543 } 2544 2545 /* See if we can move the ALIGN reloc forward. 2546 We have adjusted r_offset for it already. */ 2547 if (irelalign != NULL) 2548 { 2549 bfd_vma alignto, alignaddr; 2550 2551 if ((int) irelalign->r_addend > 0) 2552 { 2553 /* This is the old address. */ 2554 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend); 2555 /* This is where the align points to now. */ 2556 alignaddr = BFD_ALIGN (irelalign->r_offset, 2557 1 << irelalign->r_addend); 2558 if (alignaddr < alignto) 2559 /* Tail recursion. */ 2560 return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr, 2561 (int) (alignto - alignaddr)); 2562 } 2563 } 2564 2565 return TRUE; 2566 } 2567 2568 /* Return TRUE if a symbol exists at the given address, else return 2569 FALSE. */ 2570 2571 static bfd_boolean 2572 mn10300_elf_symbol_address_p (bfd *abfd, 2573 asection *sec, 2574 Elf_Internal_Sym *isym, 2575 bfd_vma addr) 2576 { 2577 Elf_Internal_Shdr *symtab_hdr; 2578 unsigned int sec_shndx; 2579 Elf_Internal_Sym *isymend; 2580 struct elf_link_hash_entry **sym_hashes; 2581 struct elf_link_hash_entry **end_hashes; 2582 unsigned int symcount; 2583 2584 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 2585 2586 /* Examine all the symbols. */ 2587 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2588 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 2589 if (isym->st_shndx == sec_shndx 2590 && isym->st_value == addr) 2591 return TRUE; 2592 2593 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2594 - symtab_hdr->sh_info); 2595 sym_hashes = elf_sym_hashes (abfd); 2596 end_hashes = sym_hashes + symcount; 2597 for (; sym_hashes < end_hashes; sym_hashes++) 2598 { 2599 struct elf_link_hash_entry *sym_hash = *sym_hashes; 2600 2601 if ((sym_hash->root.type == bfd_link_hash_defined 2602 || sym_hash->root.type == bfd_link_hash_defweak) 2603 && sym_hash->root.u.def.section == sec 2604 && sym_hash->root.u.def.value == addr) 2605 return TRUE; 2606 } 2607 2608 return FALSE; 2609 } 2610 2611 /* This function handles relaxing for the mn10300. 2612 2613 There are quite a few relaxing opportunities available on the mn10300: 2614 2615 * calls:32 -> calls:16 2 bytes 2616 * call:32 -> call:16 2 bytes 2617 2618 * call:32 -> calls:32 1 byte 2619 * call:16 -> calls:16 1 byte 2620 * These are done anytime using "calls" would result 2621 in smaller code, or when necessary to preserve the 2622 meaning of the program. 2623 2624 * call:32 varies 2625 * call:16 2626 * In some circumstances we can move instructions 2627 from a function prologue into a "call" instruction. 2628 This is only done if the resulting code is no larger 2629 than the original code. 2630 2631 * jmp:32 -> jmp:16 2 bytes 2632 * jmp:16 -> bra:8 1 byte 2633 2634 * If the previous instruction is a conditional branch 2635 around the jump/bra, we may be able to reverse its condition 2636 and change its target to the jump's target. The jump/bra 2637 can then be deleted. 2 bytes 2638 2639 * mov abs32 -> mov abs16 1 or 2 bytes 2640 2641 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes 2642 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes 2643 2644 * Most instructions which accept d32 can relax to d16 1 or 2 bytes 2645 - Most instructions which accept d16 can relax to d8 1 or 2 bytes 2646 2647 We don't handle imm16->imm8 or d16->d8 as they're very rare 2648 and somewhat more difficult to support. */ 2649 2650 static bfd_boolean 2651 mn10300_elf_relax_section (bfd *abfd, 2652 asection *sec, 2653 struct bfd_link_info *link_info, 2654 bfd_boolean *again) 2655 { 2656 Elf_Internal_Shdr *symtab_hdr; 2657 Elf_Internal_Rela *internal_relocs = NULL; 2658 Elf_Internal_Rela *irel, *irelend; 2659 bfd_byte *contents = NULL; 2660 Elf_Internal_Sym *isymbuf = NULL; 2661 struct elf32_mn10300_link_hash_table *hash_table; 2662 asection *section = sec; 2663 bfd_vma align_gap_adjustment; 2664 2665 if (bfd_link_relocatable (link_info)) 2666 (*link_info->callbacks->einfo) 2667 (_("%P%F: --relax and -r may not be used together\n")); 2668 2669 /* Assume nothing changes. */ 2670 *again = FALSE; 2671 2672 /* We need a pointer to the mn10300 specific hash table. */ 2673 hash_table = elf32_mn10300_hash_table (link_info); 2674 if (hash_table == NULL) 2675 return FALSE; 2676 2677 /* Initialize fields in each hash table entry the first time through. */ 2678 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0) 2679 { 2680 bfd *input_bfd; 2681 2682 /* Iterate over all the input bfds. */ 2683 for (input_bfd = link_info->input_bfds; 2684 input_bfd != NULL; 2685 input_bfd = input_bfd->link.next) 2686 { 2687 /* We're going to need all the symbols for each bfd. */ 2688 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2689 if (symtab_hdr->sh_info != 0) 2690 { 2691 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 2692 if (isymbuf == NULL) 2693 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 2694 symtab_hdr->sh_info, 0, 2695 NULL, NULL, NULL); 2696 if (isymbuf == NULL) 2697 goto error_return; 2698 } 2699 2700 /* Iterate over each section in this bfd. */ 2701 for (section = input_bfd->sections; 2702 section != NULL; 2703 section = section->next) 2704 { 2705 struct elf32_mn10300_link_hash_entry *hash; 2706 asection *sym_sec = NULL; 2707 const char *sym_name; 2708 char *new_name; 2709 2710 /* If there's nothing to do in this section, skip it. */ 2711 if (! ((section->flags & SEC_RELOC) != 0 2712 && section->reloc_count != 0)) 2713 continue; 2714 if ((section->flags & SEC_ALLOC) == 0) 2715 continue; 2716 2717 /* Get cached copy of section contents if it exists. */ 2718 if (elf_section_data (section)->this_hdr.contents != NULL) 2719 contents = elf_section_data (section)->this_hdr.contents; 2720 else if (section->size != 0) 2721 { 2722 /* Go get them off disk. */ 2723 if (!bfd_malloc_and_get_section (input_bfd, section, 2724 &contents)) 2725 goto error_return; 2726 } 2727 else 2728 contents = NULL; 2729 2730 /* If there aren't any relocs, then there's nothing to do. */ 2731 if ((section->flags & SEC_RELOC) != 0 2732 && section->reloc_count != 0) 2733 { 2734 /* Get a copy of the native relocations. */ 2735 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section, 2736 NULL, NULL, 2737 link_info->keep_memory); 2738 if (internal_relocs == NULL) 2739 goto error_return; 2740 2741 /* Now examine each relocation. */ 2742 irel = internal_relocs; 2743 irelend = irel + section->reloc_count; 2744 for (; irel < irelend; irel++) 2745 { 2746 long r_type; 2747 unsigned long r_index; 2748 unsigned char code; 2749 2750 r_type = ELF32_R_TYPE (irel->r_info); 2751 r_index = ELF32_R_SYM (irel->r_info); 2752 2753 if (r_type < 0 || r_type >= (int) R_MN10300_MAX) 2754 goto error_return; 2755 2756 /* We need the name and hash table entry of the target 2757 symbol! */ 2758 hash = NULL; 2759 sym_sec = NULL; 2760 2761 if (r_index < symtab_hdr->sh_info) 2762 { 2763 /* A local symbol. */ 2764 Elf_Internal_Sym *isym; 2765 struct elf_link_hash_table *elftab; 2766 bfd_size_type amt; 2767 2768 isym = isymbuf + r_index; 2769 if (isym->st_shndx == SHN_UNDEF) 2770 sym_sec = bfd_und_section_ptr; 2771 else if (isym->st_shndx == SHN_ABS) 2772 sym_sec = bfd_abs_section_ptr; 2773 else if (isym->st_shndx == SHN_COMMON) 2774 sym_sec = bfd_com_section_ptr; 2775 else 2776 sym_sec 2777 = bfd_section_from_elf_index (input_bfd, 2778 isym->st_shndx); 2779 2780 sym_name 2781 = bfd_elf_string_from_elf_section (input_bfd, 2782 (symtab_hdr 2783 ->sh_link), 2784 isym->st_name); 2785 2786 /* If it isn't a function, then we don't care 2787 about it. */ 2788 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC) 2789 continue; 2790 2791 /* Tack on an ID so we can uniquely identify this 2792 local symbol in the global hash table. */ 2793 amt = strlen (sym_name) + 10; 2794 new_name = bfd_malloc (amt); 2795 if (new_name == NULL) 2796 goto error_return; 2797 2798 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id); 2799 sym_name = new_name; 2800 2801 elftab = &hash_table->static_hash_table->root; 2802 hash = ((struct elf32_mn10300_link_hash_entry *) 2803 elf_link_hash_lookup (elftab, sym_name, 2804 TRUE, TRUE, FALSE)); 2805 free (new_name); 2806 } 2807 else 2808 { 2809 r_index -= symtab_hdr->sh_info; 2810 hash = (struct elf32_mn10300_link_hash_entry *) 2811 elf_sym_hashes (input_bfd)[r_index]; 2812 } 2813 2814 sym_name = hash->root.root.root.string; 2815 if ((section->flags & SEC_CODE) != 0) 2816 { 2817 /* If this is not a "call" instruction, then we 2818 should convert "call" instructions to "calls" 2819 instructions. */ 2820 code = bfd_get_8 (input_bfd, 2821 contents + irel->r_offset - 1); 2822 if (code != 0xdd && code != 0xcd) 2823 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS; 2824 } 2825 2826 /* If this is a jump/call, then bump the 2827 direct_calls counter. Else force "call" to 2828 "calls" conversions. */ 2829 if (r_type == R_MN10300_PCREL32 2830 || r_type == R_MN10300_PLT32 2831 || r_type == R_MN10300_PLT16 2832 || r_type == R_MN10300_PCREL16) 2833 hash->direct_calls++; 2834 else 2835 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS; 2836 } 2837 } 2838 2839 /* Now look at the actual contents to get the stack size, 2840 and a list of what registers were saved in the prologue 2841 (ie movm_args). */ 2842 if ((section->flags & SEC_CODE) != 0) 2843 { 2844 Elf_Internal_Sym *isym, *isymend; 2845 unsigned int sec_shndx; 2846 struct elf_link_hash_entry **hashes; 2847 struct elf_link_hash_entry **end_hashes; 2848 unsigned int symcount; 2849 2850 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd, 2851 section); 2852 2853 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 2854 - symtab_hdr->sh_info); 2855 hashes = elf_sym_hashes (input_bfd); 2856 end_hashes = hashes + symcount; 2857 2858 /* Look at each function defined in this section and 2859 update info for that function. */ 2860 isymend = isymbuf + symtab_hdr->sh_info; 2861 for (isym = isymbuf; isym < isymend; isym++) 2862 { 2863 if (isym->st_shndx == sec_shndx 2864 && ELF_ST_TYPE (isym->st_info) == STT_FUNC) 2865 { 2866 struct elf_link_hash_table *elftab; 2867 bfd_size_type amt; 2868 struct elf_link_hash_entry **lhashes = hashes; 2869 2870 /* Skip a local symbol if it aliases a 2871 global one. */ 2872 for (; lhashes < end_hashes; lhashes++) 2873 { 2874 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes; 2875 if ((hash->root.root.type == bfd_link_hash_defined 2876 || hash->root.root.type == bfd_link_hash_defweak) 2877 && hash->root.root.u.def.section == section 2878 && hash->root.type == STT_FUNC 2879 && hash->root.root.u.def.value == isym->st_value) 2880 break; 2881 } 2882 if (lhashes != end_hashes) 2883 continue; 2884 2885 if (isym->st_shndx == SHN_UNDEF) 2886 sym_sec = bfd_und_section_ptr; 2887 else if (isym->st_shndx == SHN_ABS) 2888 sym_sec = bfd_abs_section_ptr; 2889 else if (isym->st_shndx == SHN_COMMON) 2890 sym_sec = bfd_com_section_ptr; 2891 else 2892 sym_sec 2893 = bfd_section_from_elf_index (input_bfd, 2894 isym->st_shndx); 2895 2896 sym_name = (bfd_elf_string_from_elf_section 2897 (input_bfd, symtab_hdr->sh_link, 2898 isym->st_name)); 2899 2900 /* Tack on an ID so we can uniquely identify this 2901 local symbol in the global hash table. */ 2902 amt = strlen (sym_name) + 10; 2903 new_name = bfd_malloc (amt); 2904 if (new_name == NULL) 2905 goto error_return; 2906 2907 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id); 2908 sym_name = new_name; 2909 2910 elftab = &hash_table->static_hash_table->root; 2911 hash = ((struct elf32_mn10300_link_hash_entry *) 2912 elf_link_hash_lookup (elftab, sym_name, 2913 TRUE, TRUE, FALSE)); 2914 free (new_name); 2915 compute_function_info (input_bfd, hash, 2916 isym->st_value, contents); 2917 hash->value = isym->st_value; 2918 } 2919 } 2920 2921 for (; hashes < end_hashes; hashes++) 2922 { 2923 hash = (struct elf32_mn10300_link_hash_entry *) *hashes; 2924 if ((hash->root.root.type == bfd_link_hash_defined 2925 || hash->root.root.type == bfd_link_hash_defweak) 2926 && hash->root.root.u.def.section == section 2927 && hash->root.type == STT_FUNC) 2928 compute_function_info (input_bfd, hash, 2929 (hash)->root.root.u.def.value, 2930 contents); 2931 } 2932 } 2933 2934 /* Cache or free any memory we allocated for the relocs. */ 2935 if (internal_relocs != NULL 2936 && elf_section_data (section)->relocs != internal_relocs) 2937 free (internal_relocs); 2938 internal_relocs = NULL; 2939 2940 /* Cache or free any memory we allocated for the contents. */ 2941 if (contents != NULL 2942 && elf_section_data (section)->this_hdr.contents != contents) 2943 { 2944 if (! link_info->keep_memory) 2945 free (contents); 2946 else 2947 { 2948 /* Cache the section contents for elf_link_input_bfd. */ 2949 elf_section_data (section)->this_hdr.contents = contents; 2950 } 2951 } 2952 contents = NULL; 2953 } 2954 2955 /* Cache or free any memory we allocated for the symbols. */ 2956 if (isymbuf != NULL 2957 && symtab_hdr->contents != (unsigned char *) isymbuf) 2958 { 2959 if (! link_info->keep_memory) 2960 free (isymbuf); 2961 else 2962 { 2963 /* Cache the symbols for elf_link_input_bfd. */ 2964 symtab_hdr->contents = (unsigned char *) isymbuf; 2965 } 2966 } 2967 isymbuf = NULL; 2968 } 2969 2970 /* Now iterate on each symbol in the hash table and perform 2971 the final initialization steps on each. */ 2972 elf32_mn10300_link_hash_traverse (hash_table, 2973 elf32_mn10300_finish_hash_table_entry, 2974 link_info); 2975 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table, 2976 elf32_mn10300_finish_hash_table_entry, 2977 link_info); 2978 2979 { 2980 /* This section of code collects all our local symbols, sorts 2981 them by value, and looks for multiple symbols referring to 2982 the same address. For those symbols, the flags are merged. 2983 At this point, the only flag that can be set is 2984 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags 2985 together. */ 2986 int static_count = 0, i; 2987 struct elf32_mn10300_link_hash_entry **entries; 2988 struct elf32_mn10300_link_hash_entry **ptr; 2989 2990 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table, 2991 elf32_mn10300_count_hash_table_entries, 2992 &static_count); 2993 2994 entries = bfd_malloc (static_count * sizeof (* ptr)); 2995 2996 ptr = entries; 2997 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table, 2998 elf32_mn10300_list_hash_table_entries, 2999 & ptr); 3000 3001 qsort (entries, static_count, sizeof (entries[0]), sort_by_value); 3002 3003 for (i = 0; i < static_count - 1; i++) 3004 if (entries[i]->value && entries[i]->value == entries[i+1]->value) 3005 { 3006 int v = entries[i]->flags; 3007 int j; 3008 3009 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++) 3010 v |= entries[j]->flags; 3011 3012 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++) 3013 entries[j]->flags = v; 3014 3015 i = j - 1; 3016 } 3017 } 3018 3019 /* All entries in the hash table are fully initialized. */ 3020 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED; 3021 3022 /* Now that everything has been initialized, go through each 3023 code section and delete any prologue insns which will be 3024 redundant because their operations will be performed by 3025 a "call" instruction. */ 3026 for (input_bfd = link_info->input_bfds; 3027 input_bfd != NULL; 3028 input_bfd = input_bfd->link.next) 3029 { 3030 /* We're going to need all the local symbols for each bfd. */ 3031 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3032 if (symtab_hdr->sh_info != 0) 3033 { 3034 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 3035 if (isymbuf == NULL) 3036 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 3037 symtab_hdr->sh_info, 0, 3038 NULL, NULL, NULL); 3039 if (isymbuf == NULL) 3040 goto error_return; 3041 } 3042 3043 /* Walk over each section in this bfd. */ 3044 for (section = input_bfd->sections; 3045 section != NULL; 3046 section = section->next) 3047 { 3048 unsigned int sec_shndx; 3049 Elf_Internal_Sym *isym, *isymend; 3050 struct elf_link_hash_entry **hashes; 3051 struct elf_link_hash_entry **end_hashes; 3052 unsigned int symcount; 3053 3054 /* Skip non-code sections and empty sections. */ 3055 if ((section->flags & SEC_CODE) == 0 || section->size == 0) 3056 continue; 3057 3058 if (section->reloc_count != 0) 3059 { 3060 /* Get a copy of the native relocations. */ 3061 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section, 3062 NULL, NULL, 3063 link_info->keep_memory); 3064 if (internal_relocs == NULL) 3065 goto error_return; 3066 } 3067 3068 /* Get cached copy of section contents if it exists. */ 3069 if (elf_section_data (section)->this_hdr.contents != NULL) 3070 contents = elf_section_data (section)->this_hdr.contents; 3071 else 3072 { 3073 /* Go get them off disk. */ 3074 if (!bfd_malloc_and_get_section (input_bfd, section, 3075 &contents)) 3076 goto error_return; 3077 } 3078 3079 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd, 3080 section); 3081 3082 /* Now look for any function in this section which needs 3083 insns deleted from its prologue. */ 3084 isymend = isymbuf + symtab_hdr->sh_info; 3085 for (isym = isymbuf; isym < isymend; isym++) 3086 { 3087 struct elf32_mn10300_link_hash_entry *sym_hash; 3088 asection *sym_sec = NULL; 3089 const char *sym_name; 3090 char *new_name; 3091 struct elf_link_hash_table *elftab; 3092 bfd_size_type amt; 3093 3094 if (isym->st_shndx != sec_shndx) 3095 continue; 3096 3097 if (isym->st_shndx == SHN_UNDEF) 3098 sym_sec = bfd_und_section_ptr; 3099 else if (isym->st_shndx == SHN_ABS) 3100 sym_sec = bfd_abs_section_ptr; 3101 else if (isym->st_shndx == SHN_COMMON) 3102 sym_sec = bfd_com_section_ptr; 3103 else 3104 sym_sec 3105 = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 3106 3107 sym_name 3108 = bfd_elf_string_from_elf_section (input_bfd, 3109 symtab_hdr->sh_link, 3110 isym->st_name); 3111 3112 /* Tack on an ID so we can uniquely identify this 3113 local symbol in the global hash table. */ 3114 amt = strlen (sym_name) + 10; 3115 new_name = bfd_malloc (amt); 3116 if (new_name == NULL) 3117 goto error_return; 3118 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id); 3119 sym_name = new_name; 3120 3121 elftab = & hash_table->static_hash_table->root; 3122 sym_hash = (struct elf32_mn10300_link_hash_entry *) 3123 elf_link_hash_lookup (elftab, sym_name, 3124 FALSE, FALSE, FALSE); 3125 3126 free (new_name); 3127 if (sym_hash == NULL) 3128 continue; 3129 3130 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS) 3131 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES)) 3132 { 3133 int bytes = 0; 3134 3135 /* Note that we've changed things. */ 3136 elf_section_data (section)->relocs = internal_relocs; 3137 elf_section_data (section)->this_hdr.contents = contents; 3138 symtab_hdr->contents = (unsigned char *) isymbuf; 3139 3140 /* Count how many bytes we're going to delete. */ 3141 if (sym_hash->movm_args) 3142 bytes += 2; 3143 3144 if (sym_hash->stack_size > 0) 3145 { 3146 if (sym_hash->stack_size <= 128) 3147 bytes += 3; 3148 else 3149 bytes += 4; 3150 } 3151 3152 /* Note that we've deleted prologue bytes for this 3153 function. */ 3154 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES; 3155 3156 /* Actually delete the bytes. */ 3157 if (!mn10300_elf_relax_delete_bytes (input_bfd, 3158 section, 3159 isym->st_value, 3160 bytes)) 3161 goto error_return; 3162 3163 /* Something changed. Not strictly necessary, but 3164 may lead to more relaxing opportunities. */ 3165 *again = TRUE; 3166 } 3167 } 3168 3169 /* Look for any global functions in this section which 3170 need insns deleted from their prologues. */ 3171 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 3172 - symtab_hdr->sh_info); 3173 hashes = elf_sym_hashes (input_bfd); 3174 end_hashes = hashes + symcount; 3175 for (; hashes < end_hashes; hashes++) 3176 { 3177 struct elf32_mn10300_link_hash_entry *sym_hash; 3178 3179 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes; 3180 if ((sym_hash->root.root.type == bfd_link_hash_defined 3181 || sym_hash->root.root.type == bfd_link_hash_defweak) 3182 && sym_hash->root.root.u.def.section == section 3183 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS) 3184 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES)) 3185 { 3186 int bytes = 0; 3187 bfd_vma symval; 3188 struct elf_link_hash_entry **hh; 3189 3190 /* Note that we've changed things. */ 3191 elf_section_data (section)->relocs = internal_relocs; 3192 elf_section_data (section)->this_hdr.contents = contents; 3193 symtab_hdr->contents = (unsigned char *) isymbuf; 3194 3195 /* Count how many bytes we're going to delete. */ 3196 if (sym_hash->movm_args) 3197 bytes += 2; 3198 3199 if (sym_hash->stack_size > 0) 3200 { 3201 if (sym_hash->stack_size <= 128) 3202 bytes += 3; 3203 else 3204 bytes += 4; 3205 } 3206 3207 /* Note that we've deleted prologue bytes for this 3208 function. */ 3209 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES; 3210 3211 /* Actually delete the bytes. */ 3212 symval = sym_hash->root.root.u.def.value; 3213 if (!mn10300_elf_relax_delete_bytes (input_bfd, 3214 section, 3215 symval, 3216 bytes)) 3217 goto error_return; 3218 3219 /* There may be other C++ functions symbols with the same 3220 address. If so then mark these as having had their 3221 prologue bytes deleted as well. */ 3222 for (hh = elf_sym_hashes (input_bfd); hh < end_hashes; hh++) 3223 { 3224 struct elf32_mn10300_link_hash_entry *h; 3225 3226 h = (struct elf32_mn10300_link_hash_entry *) * hh; 3227 3228 if (h != sym_hash 3229 && (h->root.root.type == bfd_link_hash_defined 3230 || h->root.root.type == bfd_link_hash_defweak) 3231 && h->root.root.u.def.section == section 3232 && ! (h->flags & MN10300_CONVERT_CALL_TO_CALLS) 3233 && h->root.root.u.def.value == symval 3234 && h->root.type == STT_FUNC) 3235 h->flags |= MN10300_DELETED_PROLOGUE_BYTES; 3236 } 3237 3238 /* Something changed. Not strictly necessary, but 3239 may lead to more relaxing opportunities. */ 3240 *again = TRUE; 3241 } 3242 } 3243 3244 /* Cache or free any memory we allocated for the relocs. */ 3245 if (internal_relocs != NULL 3246 && elf_section_data (section)->relocs != internal_relocs) 3247 free (internal_relocs); 3248 internal_relocs = NULL; 3249 3250 /* Cache or free any memory we allocated for the contents. */ 3251 if (contents != NULL 3252 && elf_section_data (section)->this_hdr.contents != contents) 3253 { 3254 if (! link_info->keep_memory) 3255 free (contents); 3256 else 3257 /* Cache the section contents for elf_link_input_bfd. */ 3258 elf_section_data (section)->this_hdr.contents = contents; 3259 } 3260 contents = NULL; 3261 } 3262 3263 /* Cache or free any memory we allocated for the symbols. */ 3264 if (isymbuf != NULL 3265 && symtab_hdr->contents != (unsigned char *) isymbuf) 3266 { 3267 if (! link_info->keep_memory) 3268 free (isymbuf); 3269 else 3270 /* Cache the symbols for elf_link_input_bfd. */ 3271 symtab_hdr->contents = (unsigned char *) isymbuf; 3272 } 3273 isymbuf = NULL; 3274 } 3275 } 3276 3277 /* (Re)initialize for the basic instruction shortening/relaxing pass. */ 3278 contents = NULL; 3279 internal_relocs = NULL; 3280 isymbuf = NULL; 3281 /* For error_return. */ 3282 section = sec; 3283 3284 /* We don't have to do anything for a relocatable link, if 3285 this section does not have relocs, or if this is not a 3286 code section. */ 3287 if (bfd_link_relocatable (link_info) 3288 || (sec->flags & SEC_RELOC) == 0 3289 || sec->reloc_count == 0 3290 || (sec->flags & SEC_CODE) == 0) 3291 return TRUE; 3292 3293 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3294 3295 /* Get a copy of the native relocations. */ 3296 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 3297 link_info->keep_memory); 3298 if (internal_relocs == NULL) 3299 goto error_return; 3300 3301 /* Scan for worst case alignment gap changes. Note that this logic 3302 is not ideal; what we should do is run this scan for every 3303 opcode/address range and adjust accordingly, but that's 3304 expensive. Worst case is that for an alignment of N bytes, we 3305 move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc 3306 all before it. Plus, this still doesn't cover cross-section 3307 jumps with section alignment. */ 3308 irelend = internal_relocs + sec->reloc_count; 3309 align_gap_adjustment = 0; 3310 for (irel = internal_relocs; irel < irelend; irel++) 3311 { 3312 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN) 3313 { 3314 bfd_vma adj = 1 << irel->r_addend; 3315 bfd_vma aend = irel->r_offset; 3316 3317 aend = BFD_ALIGN (aend, 1 << irel->r_addend); 3318 adj = 2 * adj - adj - 1; 3319 3320 /* Record the biggest adjustmnet. Skip any alignment at the 3321 end of our section. */ 3322 if (align_gap_adjustment < adj 3323 && aend < sec->output_section->vma + sec->output_offset + sec->size) 3324 align_gap_adjustment = adj; 3325 } 3326 } 3327 3328 /* Walk through them looking for relaxing opportunities. */ 3329 irelend = internal_relocs + sec->reloc_count; 3330 for (irel = internal_relocs; irel < irelend; irel++) 3331 { 3332 bfd_vma symval; 3333 bfd_signed_vma jump_offset; 3334 asection *sym_sec = NULL; 3335 struct elf32_mn10300_link_hash_entry *h = NULL; 3336 3337 /* If this isn't something that can be relaxed, then ignore 3338 this reloc. */ 3339 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE 3340 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8 3341 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX) 3342 continue; 3343 3344 /* Get the section contents if we haven't done so already. */ 3345 if (contents == NULL) 3346 { 3347 /* Get cached copy if it exists. */ 3348 if (elf_section_data (sec)->this_hdr.contents != NULL) 3349 contents = elf_section_data (sec)->this_hdr.contents; 3350 else 3351 { 3352 /* Go get them off disk. */ 3353 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 3354 goto error_return; 3355 } 3356 } 3357 3358 /* Read this BFD's symbols if we haven't done so already. */ 3359 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 3360 { 3361 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 3362 if (isymbuf == NULL) 3363 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 3364 symtab_hdr->sh_info, 0, 3365 NULL, NULL, NULL); 3366 if (isymbuf == NULL) 3367 goto error_return; 3368 } 3369 3370 /* Get the value of the symbol referred to by the reloc. */ 3371 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 3372 { 3373 Elf_Internal_Sym *isym; 3374 const char *sym_name; 3375 char *new_name; 3376 3377 /* A local symbol. */ 3378 isym = isymbuf + ELF32_R_SYM (irel->r_info); 3379 if (isym->st_shndx == SHN_UNDEF) 3380 sym_sec = bfd_und_section_ptr; 3381 else if (isym->st_shndx == SHN_ABS) 3382 sym_sec = bfd_abs_section_ptr; 3383 else if (isym->st_shndx == SHN_COMMON) 3384 sym_sec = bfd_com_section_ptr; 3385 else 3386 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 3387 3388 sym_name = bfd_elf_string_from_elf_section (abfd, 3389 symtab_hdr->sh_link, 3390 isym->st_name); 3391 3392 if ((sym_sec->flags & SEC_MERGE) 3393 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE) 3394 { 3395 symval = isym->st_value; 3396 3397 /* GAS may reduce relocations against symbols in SEC_MERGE 3398 sections to a relocation against the section symbol when 3399 the original addend was zero. When the reloc is against 3400 a section symbol we should include the addend in the 3401 offset passed to _bfd_merged_section_offset, since the 3402 location of interest is the original symbol. On the 3403 other hand, an access to "sym+addend" where "sym" is not 3404 a section symbol should not include the addend; Such an 3405 access is presumed to be an offset from "sym"; The 3406 location of interest is just "sym". */ 3407 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 3408 symval += irel->r_addend; 3409 3410 symval = _bfd_merged_section_offset (abfd, & sym_sec, 3411 elf_section_data (sym_sec)->sec_info, 3412 symval); 3413 3414 if (ELF_ST_TYPE (isym->st_info) != STT_SECTION) 3415 symval += irel->r_addend; 3416 3417 symval += sym_sec->output_section->vma 3418 + sym_sec->output_offset - irel->r_addend; 3419 } 3420 else 3421 symval = (isym->st_value 3422 + sym_sec->output_section->vma 3423 + sym_sec->output_offset); 3424 3425 /* Tack on an ID so we can uniquely identify this 3426 local symbol in the global hash table. */ 3427 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10); 3428 if (new_name == NULL) 3429 goto error_return; 3430 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id); 3431 sym_name = new_name; 3432 3433 h = (struct elf32_mn10300_link_hash_entry *) 3434 elf_link_hash_lookup (&hash_table->static_hash_table->root, 3435 sym_name, FALSE, FALSE, FALSE); 3436 free (new_name); 3437 } 3438 else 3439 { 3440 unsigned long indx; 3441 3442 /* An external symbol. */ 3443 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 3444 h = (struct elf32_mn10300_link_hash_entry *) 3445 (elf_sym_hashes (abfd)[indx]); 3446 BFD_ASSERT (h != NULL); 3447 if (h->root.root.type != bfd_link_hash_defined 3448 && h->root.root.type != bfd_link_hash_defweak) 3449 /* This appears to be a reference to an undefined 3450 symbol. Just ignore it--it will be caught by the 3451 regular reloc processing. */ 3452 continue; 3453 3454 /* Check for a reference to a discarded symbol and ignore it. */ 3455 if (h->root.root.u.def.section->output_section == NULL) 3456 continue; 3457 3458 sym_sec = h->root.root.u.def.section->output_section; 3459 3460 symval = (h->root.root.u.def.value 3461 + h->root.root.u.def.section->output_section->vma 3462 + h->root.root.u.def.section->output_offset); 3463 } 3464 3465 /* For simplicity of coding, we are going to modify the section 3466 contents, the section relocs, and the BFD symbol table. We 3467 must tell the rest of the code not to free up this 3468 information. It would be possible to instead create a table 3469 of changes which have to be made, as is done in coff-mips.c; 3470 that would be more work, but would require less memory when 3471 the linker is run. */ 3472 3473 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative 3474 branch/call, also deal with "call" -> "calls" conversions and 3475 insertion of prologue data into "call" instructions. */ 3476 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32 3477 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32) 3478 { 3479 bfd_vma value = symval; 3480 3481 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32 3482 && h != NULL 3483 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL 3484 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN 3485 && h->root.plt.offset != (bfd_vma) -1) 3486 { 3487 asection * splt; 3488 3489 splt = hash_table->root.splt; 3490 value = ((splt->output_section->vma 3491 + splt->output_offset 3492 + h->root.plt.offset) 3493 - (sec->output_section->vma 3494 + sec->output_offset 3495 + irel->r_offset)); 3496 } 3497 3498 /* If we've got a "call" instruction that needs to be turned 3499 into a "calls" instruction, do so now. It saves a byte. */ 3500 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS)) 3501 { 3502 unsigned char code; 3503 3504 /* Get the opcode. */ 3505 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3506 3507 /* Make sure we're working with a "call" instruction! */ 3508 if (code == 0xdd) 3509 { 3510 /* Note that we've changed the relocs, section contents, 3511 etc. */ 3512 elf_section_data (sec)->relocs = internal_relocs; 3513 elf_section_data (sec)->this_hdr.contents = contents; 3514 symtab_hdr->contents = (unsigned char *) isymbuf; 3515 3516 /* Fix the opcode. */ 3517 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1); 3518 bfd_put_8 (abfd, 0xff, contents + irel->r_offset); 3519 3520 /* Fix irel->r_offset and irel->r_addend. */ 3521 irel->r_offset += 1; 3522 irel->r_addend += 1; 3523 3524 /* Delete one byte of data. */ 3525 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3526 irel->r_offset + 3, 1)) 3527 goto error_return; 3528 3529 /* That will change things, so, we should relax again. 3530 Note that this is not required, and it may be slow. */ 3531 *again = TRUE; 3532 } 3533 } 3534 else if (h) 3535 { 3536 /* We've got a "call" instruction which needs some data 3537 from target function filled in. */ 3538 unsigned char code; 3539 3540 /* Get the opcode. */ 3541 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3542 3543 /* Insert data from the target function into the "call" 3544 instruction if needed. */ 3545 if (code == 0xdd) 3546 { 3547 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4); 3548 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size, 3549 contents + irel->r_offset + 5); 3550 } 3551 } 3552 3553 /* Deal with pc-relative gunk. */ 3554 value -= (sec->output_section->vma + sec->output_offset); 3555 value -= irel->r_offset; 3556 value += irel->r_addend; 3557 3558 /* See if the value will fit in 16 bits, note the high value is 3559 0x7fff + 2 as the target will be two bytes closer if we are 3560 able to relax, if it's in the same section. */ 3561 if (sec->output_section == sym_sec->output_section) 3562 jump_offset = 0x8001; 3563 else 3564 jump_offset = 0x7fff; 3565 3566 /* Account for jumps across alignment boundaries using 3567 align_gap_adjustment. */ 3568 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment 3569 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment)) 3570 { 3571 unsigned char code; 3572 3573 /* Get the opcode. */ 3574 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3575 3576 if (code != 0xdc && code != 0xdd && code != 0xff) 3577 continue; 3578 3579 /* Note that we've changed the relocs, section contents, etc. */ 3580 elf_section_data (sec)->relocs = internal_relocs; 3581 elf_section_data (sec)->this_hdr.contents = contents; 3582 symtab_hdr->contents = (unsigned char *) isymbuf; 3583 3584 /* Fix the opcode. */ 3585 if (code == 0xdc) 3586 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1); 3587 else if (code == 0xdd) 3588 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1); 3589 else if (code == 0xff) 3590 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2); 3591 3592 /* Fix the relocation's type. */ 3593 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 3594 (ELF32_R_TYPE (irel->r_info) 3595 == (int) R_MN10300_PLT32) 3596 ? R_MN10300_PLT16 : 3597 R_MN10300_PCREL16); 3598 3599 /* Delete two bytes of data. */ 3600 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3601 irel->r_offset + 1, 2)) 3602 goto error_return; 3603 3604 /* That will change things, so, we should relax again. 3605 Note that this is not required, and it may be slow. */ 3606 *again = TRUE; 3607 } 3608 } 3609 3610 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative 3611 branch. */ 3612 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16) 3613 { 3614 bfd_vma value = symval; 3615 3616 /* If we've got a "call" instruction that needs to be turned 3617 into a "calls" instruction, do so now. It saves a byte. */ 3618 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS)) 3619 { 3620 unsigned char code; 3621 3622 /* Get the opcode. */ 3623 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3624 3625 /* Make sure we're working with a "call" instruction! */ 3626 if (code == 0xcd) 3627 { 3628 /* Note that we've changed the relocs, section contents, 3629 etc. */ 3630 elf_section_data (sec)->relocs = internal_relocs; 3631 elf_section_data (sec)->this_hdr.contents = contents; 3632 symtab_hdr->contents = (unsigned char *) isymbuf; 3633 3634 /* Fix the opcode. */ 3635 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1); 3636 bfd_put_8 (abfd, 0xff, contents + irel->r_offset); 3637 3638 /* Fix irel->r_offset and irel->r_addend. */ 3639 irel->r_offset += 1; 3640 irel->r_addend += 1; 3641 3642 /* Delete one byte of data. */ 3643 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3644 irel->r_offset + 1, 1)) 3645 goto error_return; 3646 3647 /* That will change things, so, we should relax again. 3648 Note that this is not required, and it may be slow. */ 3649 *again = TRUE; 3650 } 3651 } 3652 else if (h) 3653 { 3654 unsigned char code; 3655 3656 /* Get the opcode. */ 3657 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3658 3659 /* Insert data from the target function into the "call" 3660 instruction if needed. */ 3661 if (code == 0xcd) 3662 { 3663 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2); 3664 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size, 3665 contents + irel->r_offset + 3); 3666 } 3667 } 3668 3669 /* Deal with pc-relative gunk. */ 3670 value -= (sec->output_section->vma + sec->output_offset); 3671 value -= irel->r_offset; 3672 value += irel->r_addend; 3673 3674 /* See if the value will fit in 8 bits, note the high value is 3675 0x7f + 1 as the target will be one bytes closer if we are 3676 able to relax. */ 3677 if ((long) value < 0x80 && (long) value > -0x80) 3678 { 3679 unsigned char code; 3680 3681 /* Get the opcode. */ 3682 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3683 3684 if (code != 0xcc) 3685 continue; 3686 3687 /* Note that we've changed the relocs, section contents, etc. */ 3688 elf_section_data (sec)->relocs = internal_relocs; 3689 elf_section_data (sec)->this_hdr.contents = contents; 3690 symtab_hdr->contents = (unsigned char *) isymbuf; 3691 3692 /* Fix the opcode. */ 3693 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1); 3694 3695 /* Fix the relocation's type. */ 3696 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 3697 R_MN10300_PCREL8); 3698 3699 /* Delete one byte of data. */ 3700 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3701 irel->r_offset + 1, 1)) 3702 goto error_return; 3703 3704 /* That will change things, so, we should relax again. 3705 Note that this is not required, and it may be slow. */ 3706 *again = TRUE; 3707 } 3708 } 3709 3710 /* Try to eliminate an unconditional 8 bit pc-relative branch 3711 which immediately follows a conditional 8 bit pc-relative 3712 branch around the unconditional branch. 3713 3714 original: new: 3715 bCC lab1 bCC' lab2 3716 bra lab2 3717 lab1: lab1: 3718 3719 This happens when the bCC can't reach lab2 at assembly time, 3720 but due to other relaxations it can reach at link time. */ 3721 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8) 3722 { 3723 Elf_Internal_Rela *nrel; 3724 bfd_vma value = symval; 3725 unsigned char code; 3726 3727 /* Deal with pc-relative gunk. */ 3728 value -= (sec->output_section->vma + sec->output_offset); 3729 value -= irel->r_offset; 3730 value += irel->r_addend; 3731 3732 /* Do nothing if this reloc is the last byte in the section. */ 3733 if (irel->r_offset == sec->size) 3734 continue; 3735 3736 /* See if the next instruction is an unconditional pc-relative 3737 branch, more often than not this test will fail, so we 3738 test it first to speed things up. */ 3739 code = bfd_get_8 (abfd, contents + irel->r_offset + 1); 3740 if (code != 0xca) 3741 continue; 3742 3743 /* Also make sure the next relocation applies to the next 3744 instruction and that it's a pc-relative 8 bit branch. */ 3745 nrel = irel + 1; 3746 if (nrel == irelend 3747 || irel->r_offset + 2 != nrel->r_offset 3748 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8) 3749 continue; 3750 3751 /* Make sure our destination immediately follows the 3752 unconditional branch. */ 3753 if (symval != (sec->output_section->vma + sec->output_offset 3754 + irel->r_offset + 3)) 3755 continue; 3756 3757 /* Now make sure we are a conditional branch. This may not 3758 be necessary, but why take the chance. 3759 3760 Note these checks assume that R_MN10300_PCREL8 relocs 3761 only occur on bCC and bCCx insns. If they occured 3762 elsewhere, we'd need to know the start of this insn 3763 for this check to be accurate. */ 3764 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 3765 if (code != 0xc0 && code != 0xc1 && code != 0xc2 3766 && code != 0xc3 && code != 0xc4 && code != 0xc5 3767 && code != 0xc6 && code != 0xc7 && code != 0xc8 3768 && code != 0xc9 && code != 0xe8 && code != 0xe9 3769 && code != 0xea && code != 0xeb) 3770 continue; 3771 3772 /* We also have to be sure there is no symbol/label 3773 at the unconditional branch. */ 3774 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf, 3775 irel->r_offset + 1)) 3776 continue; 3777 3778 /* Note that we've changed the relocs, section contents, etc. */ 3779 elf_section_data (sec)->relocs = internal_relocs; 3780 elf_section_data (sec)->this_hdr.contents = contents; 3781 symtab_hdr->contents = (unsigned char *) isymbuf; 3782 3783 /* Reverse the condition of the first branch. */ 3784 switch (code) 3785 { 3786 case 0xc8: 3787 code = 0xc9; 3788 break; 3789 case 0xc9: 3790 code = 0xc8; 3791 break; 3792 case 0xc0: 3793 code = 0xc2; 3794 break; 3795 case 0xc2: 3796 code = 0xc0; 3797 break; 3798 case 0xc3: 3799 code = 0xc1; 3800 break; 3801 case 0xc1: 3802 code = 0xc3; 3803 break; 3804 case 0xc4: 3805 code = 0xc6; 3806 break; 3807 case 0xc6: 3808 code = 0xc4; 3809 break; 3810 case 0xc7: 3811 code = 0xc5; 3812 break; 3813 case 0xc5: 3814 code = 0xc7; 3815 break; 3816 case 0xe8: 3817 code = 0xe9; 3818 break; 3819 case 0x9d: 3820 code = 0xe8; 3821 break; 3822 case 0xea: 3823 code = 0xeb; 3824 break; 3825 case 0xeb: 3826 code = 0xea; 3827 break; 3828 } 3829 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 3830 3831 /* Set the reloc type and symbol for the first branch 3832 from the second branch. */ 3833 irel->r_info = nrel->r_info; 3834 3835 /* Make the reloc for the second branch a null reloc. */ 3836 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info), 3837 R_MN10300_NONE); 3838 3839 /* Delete two bytes of data. */ 3840 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3841 irel->r_offset + 1, 2)) 3842 goto error_return; 3843 3844 /* That will change things, so, we should relax again. 3845 Note that this is not required, and it may be slow. */ 3846 *again = TRUE; 3847 } 3848 3849 /* Try to turn a 24 immediate, displacement or absolute address 3850 into a 8 immediate, displacement or absolute address. */ 3851 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24) 3852 { 3853 bfd_vma value = symval; 3854 value += irel->r_addend; 3855 3856 /* See if the value will fit in 8 bits. */ 3857 if ((long) value < 0x7f && (long) value > -0x80) 3858 { 3859 unsigned char code; 3860 3861 /* AM33 insns which have 24 operands are 6 bytes long and 3862 will have 0xfd as the first byte. */ 3863 3864 /* Get the first opcode. */ 3865 code = bfd_get_8 (abfd, contents + irel->r_offset - 3); 3866 3867 if (code == 0xfd) 3868 { 3869 /* Get the second opcode. */ 3870 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 3871 3872 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit 3873 equivalent instructions exists. */ 3874 if (code != 0x6b && code != 0x7b 3875 && code != 0x8b && code != 0x9b 3876 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08 3877 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b 3878 || (code & 0x0f) == 0x0e)) 3879 { 3880 /* Not safe if the high bit is on as relaxing may 3881 move the value out of high mem and thus not fit 3882 in a signed 8bit value. This is currently over 3883 conservative. */ 3884 if ((value & 0x80) == 0) 3885 { 3886 /* Note that we've changed the relocation contents, 3887 etc. */ 3888 elf_section_data (sec)->relocs = internal_relocs; 3889 elf_section_data (sec)->this_hdr.contents = contents; 3890 symtab_hdr->contents = (unsigned char *) isymbuf; 3891 3892 /* Fix the opcode. */ 3893 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3); 3894 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 3895 3896 /* Fix the relocation's type. */ 3897 irel->r_info = 3898 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 3899 R_MN10300_8); 3900 3901 /* Delete two bytes of data. */ 3902 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 3903 irel->r_offset + 1, 2)) 3904 goto error_return; 3905 3906 /* That will change things, so, we should relax 3907 again. Note that this is not required, and it 3908 may be slow. */ 3909 *again = TRUE; 3910 break; 3911 } 3912 } 3913 } 3914 } 3915 } 3916 3917 /* Try to turn a 32bit immediate, displacement or absolute address 3918 into a 16bit immediate, displacement or absolute address. */ 3919 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32 3920 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32 3921 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32) 3922 { 3923 bfd_vma value = symval; 3924 3925 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32) 3926 { 3927 asection * sgot; 3928 3929 sgot = hash_table->root.sgot; 3930 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32) 3931 { 3932 value = sgot->output_offset; 3933 3934 if (h) 3935 value += h->root.got.offset; 3936 else 3937 value += (elf_local_got_offsets 3938 (abfd)[ELF32_R_SYM (irel->r_info)]); 3939 } 3940 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32) 3941 value -= sgot->output_section->vma; 3942 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32) 3943 value = (sgot->output_section->vma 3944 - (sec->output_section->vma 3945 + sec->output_offset 3946 + irel->r_offset)); 3947 else 3948 abort (); 3949 } 3950 3951 value += irel->r_addend; 3952 3953 /* See if the value will fit in 24 bits. 3954 We allow any 16bit match here. We prune those we can't 3955 handle below. */ 3956 if ((long) value < 0x7fffff && (long) value > -0x800000) 3957 { 3958 unsigned char code; 3959 3960 /* AM33 insns which have 32bit operands are 7 bytes long and 3961 will have 0xfe as the first byte. */ 3962 3963 /* Get the first opcode. */ 3964 code = bfd_get_8 (abfd, contents + irel->r_offset - 3); 3965 3966 if (code == 0xfe) 3967 { 3968 /* Get the second opcode. */ 3969 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 3970 3971 /* All the am33 32 -> 24 relaxing possibilities. */ 3972 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit 3973 equivalent instructions exists. */ 3974 if (code != 0x6b && code != 0x7b 3975 && code != 0x8b && code != 0x9b 3976 && (ELF32_R_TYPE (irel->r_info) 3977 != (int) R_MN10300_GOTPC32) 3978 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08 3979 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b 3980 || (code & 0x0f) == 0x0e)) 3981 { 3982 /* Not safe if the high bit is on as relaxing may 3983 move the value out of high mem and thus not fit 3984 in a signed 16bit value. This is currently over 3985 conservative. */ 3986 if ((value & 0x8000) == 0) 3987 { 3988 /* Note that we've changed the relocation contents, 3989 etc. */ 3990 elf_section_data (sec)->relocs = internal_relocs; 3991 elf_section_data (sec)->this_hdr.contents = contents; 3992 symtab_hdr->contents = (unsigned char *) isymbuf; 3993 3994 /* Fix the opcode. */ 3995 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3); 3996 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 3997 3998 /* Fix the relocation's type. */ 3999 irel->r_info = 4000 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4001 (ELF32_R_TYPE (irel->r_info) 4002 == (int) R_MN10300_GOTOFF32) 4003 ? R_MN10300_GOTOFF24 4004 : (ELF32_R_TYPE (irel->r_info) 4005 == (int) R_MN10300_GOT32) 4006 ? R_MN10300_GOT24 : 4007 R_MN10300_24); 4008 4009 /* Delete one byte of data. */ 4010 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4011 irel->r_offset + 3, 1)) 4012 goto error_return; 4013 4014 /* That will change things, so, we should relax 4015 again. Note that this is not required, and it 4016 may be slow. */ 4017 *again = TRUE; 4018 break; 4019 } 4020 } 4021 } 4022 } 4023 4024 /* See if the value will fit in 16 bits. 4025 We allow any 16bit match here. We prune those we can't 4026 handle below. */ 4027 if ((long) value < 0x7fff && (long) value > -0x8000) 4028 { 4029 unsigned char code; 4030 4031 /* Most insns which have 32bit operands are 6 bytes long; 4032 exceptions are pcrel insns and bit insns. 4033 4034 We handle pcrel insns above. We don't bother trying 4035 to handle the bit insns here. 4036 4037 The first byte of the remaining insns will be 0xfc. */ 4038 4039 /* Get the first opcode. */ 4040 code = bfd_get_8 (abfd, contents + irel->r_offset - 2); 4041 4042 if (code != 0xfc) 4043 continue; 4044 4045 /* Get the second opcode. */ 4046 code = bfd_get_8 (abfd, contents + irel->r_offset - 1); 4047 4048 if ((code & 0xf0) < 0x80) 4049 switch (code & 0xf0) 4050 { 4051 /* mov (d32,am),dn -> mov (d32,am),dn 4052 mov dm,(d32,am) -> mov dn,(d32,am) 4053 mov (d32,am),an -> mov (d32,am),an 4054 mov dm,(d32,am) -> mov dn,(d32,am) 4055 movbu (d32,am),dn -> movbu (d32,am),dn 4056 movbu dm,(d32,am) -> movbu dn,(d32,am) 4057 movhu (d32,am),dn -> movhu (d32,am),dn 4058 movhu dm,(d32,am) -> movhu dn,(d32,am) */ 4059 case 0x00: 4060 case 0x10: 4061 case 0x20: 4062 case 0x30: 4063 case 0x40: 4064 case 0x50: 4065 case 0x60: 4066 case 0x70: 4067 /* Not safe if the high bit is on as relaxing may 4068 move the value out of high mem and thus not fit 4069 in a signed 16bit value. */ 4070 if (code == 0xcc 4071 && (value & 0x8000)) 4072 continue; 4073 4074 /* Note that we've changed the relocation contents, etc. */ 4075 elf_section_data (sec)->relocs = internal_relocs; 4076 elf_section_data (sec)->this_hdr.contents = contents; 4077 symtab_hdr->contents = (unsigned char *) isymbuf; 4078 4079 /* Fix the opcode. */ 4080 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2); 4081 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 4082 4083 /* Fix the relocation's type. */ 4084 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4085 (ELF32_R_TYPE (irel->r_info) 4086 == (int) R_MN10300_GOTOFF32) 4087 ? R_MN10300_GOTOFF16 4088 : (ELF32_R_TYPE (irel->r_info) 4089 == (int) R_MN10300_GOT32) 4090 ? R_MN10300_GOT16 4091 : (ELF32_R_TYPE (irel->r_info) 4092 == (int) R_MN10300_GOTPC32) 4093 ? R_MN10300_GOTPC16 : 4094 R_MN10300_16); 4095 4096 /* Delete two bytes of data. */ 4097 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4098 irel->r_offset + 2, 2)) 4099 goto error_return; 4100 4101 /* That will change things, so, we should relax again. 4102 Note that this is not required, and it may be slow. */ 4103 *again = TRUE; 4104 break; 4105 } 4106 else if ((code & 0xf0) == 0x80 4107 || (code & 0xf0) == 0x90) 4108 switch (code & 0xf3) 4109 { 4110 /* mov dn,(abs32) -> mov dn,(abs16) 4111 movbu dn,(abs32) -> movbu dn,(abs16) 4112 movhu dn,(abs32) -> movhu dn,(abs16) */ 4113 case 0x81: 4114 case 0x82: 4115 case 0x83: 4116 /* Note that we've changed the relocation contents, etc. */ 4117 elf_section_data (sec)->relocs = internal_relocs; 4118 elf_section_data (sec)->this_hdr.contents = contents; 4119 symtab_hdr->contents = (unsigned char *) isymbuf; 4120 4121 if ((code & 0xf3) == 0x81) 4122 code = 0x01 + (code & 0x0c); 4123 else if ((code & 0xf3) == 0x82) 4124 code = 0x02 + (code & 0x0c); 4125 else if ((code & 0xf3) == 0x83) 4126 code = 0x03 + (code & 0x0c); 4127 else 4128 abort (); 4129 4130 /* Fix the opcode. */ 4131 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 4132 4133 /* Fix the relocation's type. */ 4134 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4135 (ELF32_R_TYPE (irel->r_info) 4136 == (int) R_MN10300_GOTOFF32) 4137 ? R_MN10300_GOTOFF16 4138 : (ELF32_R_TYPE (irel->r_info) 4139 == (int) R_MN10300_GOT32) 4140 ? R_MN10300_GOT16 4141 : (ELF32_R_TYPE (irel->r_info) 4142 == (int) R_MN10300_GOTPC32) 4143 ? R_MN10300_GOTPC16 : 4144 R_MN10300_16); 4145 4146 /* The opcode got shorter too, so we have to fix the 4147 addend and offset too! */ 4148 irel->r_offset -= 1; 4149 4150 /* Delete three bytes of data. */ 4151 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4152 irel->r_offset + 1, 3)) 4153 goto error_return; 4154 4155 /* That will change things, so, we should relax again. 4156 Note that this is not required, and it may be slow. */ 4157 *again = TRUE; 4158 break; 4159 4160 /* mov am,(abs32) -> mov am,(abs16) 4161 mov am,(d32,sp) -> mov am,(d16,sp) 4162 mov dm,(d32,sp) -> mov dm,(d32,sp) 4163 movbu dm,(d32,sp) -> movbu dm,(d32,sp) 4164 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */ 4165 case 0x80: 4166 case 0x90: 4167 case 0x91: 4168 case 0x92: 4169 case 0x93: 4170 /* sp-based offsets are zero-extended. */ 4171 if (code >= 0x90 && code <= 0x93 4172 && (long) value < 0) 4173 continue; 4174 4175 /* Note that we've changed the relocation contents, etc. */ 4176 elf_section_data (sec)->relocs = internal_relocs; 4177 elf_section_data (sec)->this_hdr.contents = contents; 4178 symtab_hdr->contents = (unsigned char *) isymbuf; 4179 4180 /* Fix the opcode. */ 4181 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2); 4182 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 4183 4184 /* Fix the relocation's type. */ 4185 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4186 (ELF32_R_TYPE (irel->r_info) 4187 == (int) R_MN10300_GOTOFF32) 4188 ? R_MN10300_GOTOFF16 4189 : (ELF32_R_TYPE (irel->r_info) 4190 == (int) R_MN10300_GOT32) 4191 ? R_MN10300_GOT16 4192 : (ELF32_R_TYPE (irel->r_info) 4193 == (int) R_MN10300_GOTPC32) 4194 ? R_MN10300_GOTPC16 : 4195 R_MN10300_16); 4196 4197 /* Delete two bytes of data. */ 4198 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4199 irel->r_offset + 2, 2)) 4200 goto error_return; 4201 4202 /* That will change things, so, we should relax again. 4203 Note that this is not required, and it may be slow. */ 4204 *again = TRUE; 4205 break; 4206 } 4207 else if ((code & 0xf0) < 0xf0) 4208 switch (code & 0xfc) 4209 { 4210 /* mov imm32,dn -> mov imm16,dn 4211 mov imm32,an -> mov imm16,an 4212 mov (abs32),dn -> mov (abs16),dn 4213 movbu (abs32),dn -> movbu (abs16),dn 4214 movhu (abs32),dn -> movhu (abs16),dn */ 4215 case 0xcc: 4216 case 0xdc: 4217 case 0xa4: 4218 case 0xa8: 4219 case 0xac: 4220 /* Not safe if the high bit is on as relaxing may 4221 move the value out of high mem and thus not fit 4222 in a signed 16bit value. */ 4223 if (code == 0xcc 4224 && (value & 0x8000)) 4225 continue; 4226 4227 /* "mov imm16, an" zero-extends the immediate. */ 4228 if ((code & 0xfc) == 0xdc 4229 && (long) value < 0) 4230 continue; 4231 4232 /* Note that we've changed the relocation contents, etc. */ 4233 elf_section_data (sec)->relocs = internal_relocs; 4234 elf_section_data (sec)->this_hdr.contents = contents; 4235 symtab_hdr->contents = (unsigned char *) isymbuf; 4236 4237 if ((code & 0xfc) == 0xcc) 4238 code = 0x2c + (code & 0x03); 4239 else if ((code & 0xfc) == 0xdc) 4240 code = 0x24 + (code & 0x03); 4241 else if ((code & 0xfc) == 0xa4) 4242 code = 0x30 + (code & 0x03); 4243 else if ((code & 0xfc) == 0xa8) 4244 code = 0x34 + (code & 0x03); 4245 else if ((code & 0xfc) == 0xac) 4246 code = 0x38 + (code & 0x03); 4247 else 4248 abort (); 4249 4250 /* Fix the opcode. */ 4251 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); 4252 4253 /* Fix the relocation's type. */ 4254 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4255 (ELF32_R_TYPE (irel->r_info) 4256 == (int) R_MN10300_GOTOFF32) 4257 ? R_MN10300_GOTOFF16 4258 : (ELF32_R_TYPE (irel->r_info) 4259 == (int) R_MN10300_GOT32) 4260 ? R_MN10300_GOT16 4261 : (ELF32_R_TYPE (irel->r_info) 4262 == (int) R_MN10300_GOTPC32) 4263 ? R_MN10300_GOTPC16 : 4264 R_MN10300_16); 4265 4266 /* The opcode got shorter too, so we have to fix the 4267 addend and offset too! */ 4268 irel->r_offset -= 1; 4269 4270 /* Delete three bytes of data. */ 4271 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4272 irel->r_offset + 1, 3)) 4273 goto error_return; 4274 4275 /* That will change things, so, we should relax again. 4276 Note that this is not required, and it may be slow. */ 4277 *again = TRUE; 4278 break; 4279 4280 /* mov (abs32),an -> mov (abs16),an 4281 mov (d32,sp),an -> mov (d16,sp),an 4282 mov (d32,sp),dn -> mov (d16,sp),dn 4283 movbu (d32,sp),dn -> movbu (d16,sp),dn 4284 movhu (d32,sp),dn -> movhu (d16,sp),dn 4285 add imm32,dn -> add imm16,dn 4286 cmp imm32,dn -> cmp imm16,dn 4287 add imm32,an -> add imm16,an 4288 cmp imm32,an -> cmp imm16,an 4289 and imm32,dn -> and imm16,dn 4290 or imm32,dn -> or imm16,dn 4291 xor imm32,dn -> xor imm16,dn 4292 btst imm32,dn -> btst imm16,dn */ 4293 4294 case 0xa0: 4295 case 0xb0: 4296 case 0xb1: 4297 case 0xb2: 4298 case 0xb3: 4299 case 0xc0: 4300 case 0xc8: 4301 4302 case 0xd0: 4303 case 0xd8: 4304 case 0xe0: 4305 case 0xe1: 4306 case 0xe2: 4307 case 0xe3: 4308 /* cmp imm16, an zero-extends the immediate. */ 4309 if (code == 0xdc 4310 && (long) value < 0) 4311 continue; 4312 4313 /* So do sp-based offsets. */ 4314 if (code >= 0xb0 && code <= 0xb3 4315 && (long) value < 0) 4316 continue; 4317 4318 /* Note that we've changed the relocation contents, etc. */ 4319 elf_section_data (sec)->relocs = internal_relocs; 4320 elf_section_data (sec)->this_hdr.contents = contents; 4321 symtab_hdr->contents = (unsigned char *) isymbuf; 4322 4323 /* Fix the opcode. */ 4324 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2); 4325 bfd_put_8 (abfd, code, contents + irel->r_offset - 1); 4326 4327 /* Fix the relocation's type. */ 4328 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4329 (ELF32_R_TYPE (irel->r_info) 4330 == (int) R_MN10300_GOTOFF32) 4331 ? R_MN10300_GOTOFF16 4332 : (ELF32_R_TYPE (irel->r_info) 4333 == (int) R_MN10300_GOT32) 4334 ? R_MN10300_GOT16 4335 : (ELF32_R_TYPE (irel->r_info) 4336 == (int) R_MN10300_GOTPC32) 4337 ? R_MN10300_GOTPC16 : 4338 R_MN10300_16); 4339 4340 /* Delete two bytes of data. */ 4341 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4342 irel->r_offset + 2, 2)) 4343 goto error_return; 4344 4345 /* That will change things, so, we should relax again. 4346 Note that this is not required, and it may be slow. */ 4347 *again = TRUE; 4348 break; 4349 } 4350 else if (code == 0xfe) 4351 { 4352 /* add imm32,sp -> add imm16,sp */ 4353 4354 /* Note that we've changed the relocation contents, etc. */ 4355 elf_section_data (sec)->relocs = internal_relocs; 4356 elf_section_data (sec)->this_hdr.contents = contents; 4357 symtab_hdr->contents = (unsigned char *) isymbuf; 4358 4359 /* Fix the opcode. */ 4360 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2); 4361 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1); 4362 4363 /* Fix the relocation's type. */ 4364 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 4365 (ELF32_R_TYPE (irel->r_info) 4366 == (int) R_MN10300_GOT32) 4367 ? R_MN10300_GOT16 4368 : (ELF32_R_TYPE (irel->r_info) 4369 == (int) R_MN10300_GOTOFF32) 4370 ? R_MN10300_GOTOFF16 4371 : (ELF32_R_TYPE (irel->r_info) 4372 == (int) R_MN10300_GOTPC32) 4373 ? R_MN10300_GOTPC16 : 4374 R_MN10300_16); 4375 4376 /* Delete two bytes of data. */ 4377 if (!mn10300_elf_relax_delete_bytes (abfd, sec, 4378 irel->r_offset + 2, 2)) 4379 goto error_return; 4380 4381 /* That will change things, so, we should relax again. 4382 Note that this is not required, and it may be slow. */ 4383 *again = TRUE; 4384 break; 4385 } 4386 } 4387 } 4388 } 4389 4390 if (isymbuf != NULL 4391 && symtab_hdr->contents != (unsigned char *) isymbuf) 4392 { 4393 if (! link_info->keep_memory) 4394 free (isymbuf); 4395 else 4396 { 4397 /* Cache the symbols for elf_link_input_bfd. */ 4398 symtab_hdr->contents = (unsigned char *) isymbuf; 4399 } 4400 } 4401 4402 if (contents != NULL 4403 && elf_section_data (sec)->this_hdr.contents != contents) 4404 { 4405 if (! link_info->keep_memory) 4406 free (contents); 4407 else 4408 { 4409 /* Cache the section contents for elf_link_input_bfd. */ 4410 elf_section_data (sec)->this_hdr.contents = contents; 4411 } 4412 } 4413 4414 if (internal_relocs != NULL 4415 && elf_section_data (sec)->relocs != internal_relocs) 4416 free (internal_relocs); 4417 4418 return TRUE; 4419 4420 error_return: 4421 if (isymbuf != NULL 4422 && symtab_hdr->contents != (unsigned char *) isymbuf) 4423 free (isymbuf); 4424 if (contents != NULL 4425 && elf_section_data (section)->this_hdr.contents != contents) 4426 free (contents); 4427 if (internal_relocs != NULL 4428 && elf_section_data (section)->relocs != internal_relocs) 4429 free (internal_relocs); 4430 4431 return FALSE; 4432 } 4433 4434 /* This is a version of bfd_generic_get_relocated_section_contents 4435 which uses mn10300_elf_relocate_section. */ 4436 4437 static bfd_byte * 4438 mn10300_elf_get_relocated_section_contents (bfd *output_bfd, 4439 struct bfd_link_info *link_info, 4440 struct bfd_link_order *link_order, 4441 bfd_byte *data, 4442 bfd_boolean relocatable, 4443 asymbol **symbols) 4444 { 4445 Elf_Internal_Shdr *symtab_hdr; 4446 asection *input_section = link_order->u.indirect.section; 4447 bfd *input_bfd = input_section->owner; 4448 asection **sections = NULL; 4449 Elf_Internal_Rela *internal_relocs = NULL; 4450 Elf_Internal_Sym *isymbuf = NULL; 4451 4452 /* We only need to handle the case of relaxing, or of having a 4453 particular set of section contents, specially. */ 4454 if (relocatable 4455 || elf_section_data (input_section)->this_hdr.contents == NULL) 4456 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 4457 link_order, data, 4458 relocatable, 4459 symbols); 4460 4461 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 4462 4463 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 4464 (size_t) input_section->size); 4465 4466 if ((input_section->flags & SEC_RELOC) != 0 4467 && input_section->reloc_count > 0) 4468 { 4469 asection **secpp; 4470 Elf_Internal_Sym *isym, *isymend; 4471 bfd_size_type amt; 4472 4473 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section, 4474 NULL, NULL, FALSE); 4475 if (internal_relocs == NULL) 4476 goto error_return; 4477 4478 if (symtab_hdr->sh_info != 0) 4479 { 4480 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 4481 if (isymbuf == NULL) 4482 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 4483 symtab_hdr->sh_info, 0, 4484 NULL, NULL, NULL); 4485 if (isymbuf == NULL) 4486 goto error_return; 4487 } 4488 4489 amt = symtab_hdr->sh_info; 4490 amt *= sizeof (asection *); 4491 sections = bfd_malloc (amt); 4492 if (sections == NULL && amt != 0) 4493 goto error_return; 4494 4495 isymend = isymbuf + symtab_hdr->sh_info; 4496 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 4497 { 4498 asection *isec; 4499 4500 if (isym->st_shndx == SHN_UNDEF) 4501 isec = bfd_und_section_ptr; 4502 else if (isym->st_shndx == SHN_ABS) 4503 isec = bfd_abs_section_ptr; 4504 else if (isym->st_shndx == SHN_COMMON) 4505 isec = bfd_com_section_ptr; 4506 else 4507 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 4508 4509 *secpp = isec; 4510 } 4511 4512 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd, 4513 input_section, data, internal_relocs, 4514 isymbuf, sections)) 4515 goto error_return; 4516 4517 if (sections != NULL) 4518 free (sections); 4519 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 4520 free (isymbuf); 4521 if (internal_relocs != elf_section_data (input_section)->relocs) 4522 free (internal_relocs); 4523 } 4524 4525 return data; 4526 4527 error_return: 4528 if (sections != NULL) 4529 free (sections); 4530 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 4531 free (isymbuf); 4532 if (internal_relocs != NULL 4533 && internal_relocs != elf_section_data (input_section)->relocs) 4534 free (internal_relocs); 4535 return NULL; 4536 } 4537 4538 /* Assorted hash table functions. */ 4539 4540 /* Initialize an entry in the link hash table. */ 4541 4542 /* Create an entry in an MN10300 ELF linker hash table. */ 4543 4544 static struct bfd_hash_entry * 4545 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry, 4546 struct bfd_hash_table *table, 4547 const char *string) 4548 { 4549 struct elf32_mn10300_link_hash_entry *ret = 4550 (struct elf32_mn10300_link_hash_entry *) entry; 4551 4552 /* Allocate the structure if it has not already been allocated by a 4553 subclass. */ 4554 if (ret == NULL) 4555 ret = (struct elf32_mn10300_link_hash_entry *) 4556 bfd_hash_allocate (table, sizeof (* ret)); 4557 if (ret == NULL) 4558 return (struct bfd_hash_entry *) ret; 4559 4560 /* Call the allocation method of the superclass. */ 4561 ret = (struct elf32_mn10300_link_hash_entry *) 4562 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 4563 table, string); 4564 if (ret != NULL) 4565 { 4566 ret->direct_calls = 0; 4567 ret->stack_size = 0; 4568 ret->movm_args = 0; 4569 ret->movm_stack_size = 0; 4570 ret->flags = 0; 4571 ret->value = 0; 4572 ret->tls_type = GOT_UNKNOWN; 4573 } 4574 4575 return (struct bfd_hash_entry *) ret; 4576 } 4577 4578 static void 4579 _bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info, 4580 struct elf_link_hash_entry * dir, 4581 struct elf_link_hash_entry * ind) 4582 { 4583 struct elf32_mn10300_link_hash_entry * edir; 4584 struct elf32_mn10300_link_hash_entry * eind; 4585 4586 edir = elf_mn10300_hash_entry (dir); 4587 eind = elf_mn10300_hash_entry (ind); 4588 4589 if (ind->root.type == bfd_link_hash_indirect 4590 && dir->got.refcount <= 0) 4591 { 4592 edir->tls_type = eind->tls_type; 4593 eind->tls_type = GOT_UNKNOWN; 4594 } 4595 edir->direct_calls = eind->direct_calls; 4596 edir->stack_size = eind->stack_size; 4597 edir->movm_args = eind->movm_args; 4598 edir->movm_stack_size = eind->movm_stack_size; 4599 edir->flags = eind->flags; 4600 4601 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 4602 } 4603 4604 /* Destroy an mn10300 ELF linker hash table. */ 4605 4606 static void 4607 elf32_mn10300_link_hash_table_free (bfd *obfd) 4608 { 4609 struct elf32_mn10300_link_hash_table *ret 4610 = (struct elf32_mn10300_link_hash_table *) obfd->link.hash; 4611 4612 obfd->link.hash = &ret->static_hash_table->root.root; 4613 _bfd_elf_link_hash_table_free (obfd); 4614 obfd->is_linker_output = TRUE; 4615 obfd->link.hash = &ret->root.root; 4616 _bfd_elf_link_hash_table_free (obfd); 4617 } 4618 4619 /* Create an mn10300 ELF linker hash table. */ 4620 4621 static struct bfd_link_hash_table * 4622 elf32_mn10300_link_hash_table_create (bfd *abfd) 4623 { 4624 struct elf32_mn10300_link_hash_table *ret; 4625 bfd_size_type amt = sizeof (* ret); 4626 4627 ret = bfd_zmalloc (amt); 4628 if (ret == NULL) 4629 return NULL; 4630 4631 amt = sizeof (struct elf_link_hash_table); 4632 ret->static_hash_table = bfd_zmalloc (amt); 4633 if (ret->static_hash_table == NULL) 4634 { 4635 free (ret); 4636 return NULL; 4637 } 4638 4639 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd, 4640 elf32_mn10300_link_hash_newfunc, 4641 sizeof (struct elf32_mn10300_link_hash_entry), 4642 MN10300_ELF_DATA)) 4643 { 4644 free (ret->static_hash_table); 4645 free (ret); 4646 return NULL; 4647 } 4648 4649 abfd->is_linker_output = FALSE; 4650 abfd->link.hash = NULL; 4651 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 4652 elf32_mn10300_link_hash_newfunc, 4653 sizeof (struct elf32_mn10300_link_hash_entry), 4654 MN10300_ELF_DATA)) 4655 { 4656 abfd->is_linker_output = TRUE; 4657 abfd->link.hash = &ret->static_hash_table->root.root; 4658 _bfd_elf_link_hash_table_free (abfd); 4659 free (ret); 4660 return NULL; 4661 } 4662 ret->root.root.hash_table_free = elf32_mn10300_link_hash_table_free; 4663 4664 ret->tls_ldm_got.offset = -1; 4665 4666 return & ret->root.root; 4667 } 4668 4669 static unsigned long 4670 elf_mn10300_mach (flagword flags) 4671 { 4672 switch (flags & EF_MN10300_MACH) 4673 { 4674 case E_MN10300_MACH_MN10300: 4675 default: 4676 return bfd_mach_mn10300; 4677 4678 case E_MN10300_MACH_AM33: 4679 return bfd_mach_am33; 4680 4681 case E_MN10300_MACH_AM33_2: 4682 return bfd_mach_am33_2; 4683 } 4684 } 4685 4686 /* The final processing done just before writing out a MN10300 ELF object 4687 file. This gets the MN10300 architecture right based on the machine 4688 number. */ 4689 4690 static void 4691 _bfd_mn10300_elf_final_write_processing (bfd *abfd, 4692 bfd_boolean linker ATTRIBUTE_UNUSED) 4693 { 4694 unsigned long val; 4695 4696 switch (bfd_get_mach (abfd)) 4697 { 4698 default: 4699 case bfd_mach_mn10300: 4700 val = E_MN10300_MACH_MN10300; 4701 break; 4702 4703 case bfd_mach_am33: 4704 val = E_MN10300_MACH_AM33; 4705 break; 4706 4707 case bfd_mach_am33_2: 4708 val = E_MN10300_MACH_AM33_2; 4709 break; 4710 } 4711 4712 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH); 4713 elf_elfheader (abfd)->e_flags |= val; 4714 } 4715 4716 static bfd_boolean 4717 _bfd_mn10300_elf_object_p (bfd *abfd) 4718 { 4719 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300, 4720 elf_mn10300_mach (elf_elfheader (abfd)->e_flags)); 4721 return TRUE; 4722 } 4723 4724 /* Merge backend specific data from an object file to the output 4725 object file when linking. */ 4726 4727 static bfd_boolean 4728 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4729 { 4730 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4731 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4732 return TRUE; 4733 4734 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4735 && bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 4736 { 4737 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 4738 bfd_get_mach (ibfd))) 4739 return FALSE; 4740 } 4741 4742 return TRUE; 4743 } 4744 4745 #define PLT0_ENTRY_SIZE 15 4746 #define PLT_ENTRY_SIZE 20 4747 #define PIC_PLT_ENTRY_SIZE 24 4748 4749 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] = 4750 { 4751 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */ 4752 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */ 4753 0xf0, 0xf4, /* jmp (a0) */ 4754 }; 4755 4756 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] = 4757 { 4758 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */ 4759 0xf0, 0xf4, /* jmp (a0) */ 4760 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */ 4761 0xdc, 0, 0, 0, 0, /* jmp .plt0 */ 4762 }; 4763 4764 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] = 4765 { 4766 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */ 4767 0xf0, 0xf4, /* jmp (a0) */ 4768 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */ 4769 0xf8, 0x22, 8, /* mov (8,a2),a0 */ 4770 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */ 4771 0xf0, 0xf4, /* jmp (a0) */ 4772 }; 4773 4774 /* Return size of the first PLT entry. */ 4775 #define elf_mn10300_sizeof_plt0(info) \ 4776 (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE) 4777 4778 /* Return size of a PLT entry. */ 4779 #define elf_mn10300_sizeof_plt(info) \ 4780 (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE) 4781 4782 /* Return offset of the PLT0 address in an absolute PLT entry. */ 4783 #define elf_mn10300_plt_plt0_offset(info) 16 4784 4785 /* Return offset of the linker in PLT0 entry. */ 4786 #define elf_mn10300_plt0_linker_offset(info) 2 4787 4788 /* Return offset of the GOT id in PLT0 entry. */ 4789 #define elf_mn10300_plt0_gotid_offset(info) 9 4790 4791 /* Return offset of the temporary in PLT entry. */ 4792 #define elf_mn10300_plt_temp_offset(info) 8 4793 4794 /* Return offset of the symbol in PLT entry. */ 4795 #define elf_mn10300_plt_symbol_offset(info) 2 4796 4797 /* Return offset of the relocation in PLT entry. */ 4798 #define elf_mn10300_plt_reloc_offset(info) 11 4799 4800 /* The name of the dynamic interpreter. This is put in the .interp 4801 section. */ 4802 4803 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 4804 4805 /* Create dynamic sections when linking against a dynamic object. */ 4806 4807 static bfd_boolean 4808 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 4809 { 4810 flagword flags; 4811 asection * s; 4812 const struct elf_backend_data * bed = get_elf_backend_data (abfd); 4813 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info); 4814 int ptralign = 0; 4815 4816 switch (bed->s->arch_size) 4817 { 4818 case 32: 4819 ptralign = 2; 4820 break; 4821 4822 case 64: 4823 ptralign = 3; 4824 break; 4825 4826 default: 4827 bfd_set_error (bfd_error_bad_value); 4828 return FALSE; 4829 } 4830 4831 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 4832 .rel[a].bss sections. */ 4833 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 4834 | SEC_LINKER_CREATED); 4835 4836 s = bfd_make_section_anyway_with_flags (abfd, 4837 (bed->default_use_rela_p 4838 ? ".rela.plt" : ".rel.plt"), 4839 flags | SEC_READONLY); 4840 htab->root.srelplt = s; 4841 if (s == NULL 4842 || ! bfd_set_section_alignment (abfd, s, ptralign)) 4843 return FALSE; 4844 4845 if (! _bfd_mn10300_elf_create_got_section (abfd, info)) 4846 return FALSE; 4847 4848 if (bed->want_dynbss) 4849 { 4850 /* The .dynbss section is a place to put symbols which are defined 4851 by dynamic objects, are referenced by regular objects, and are 4852 not functions. We must allocate space for them in the process 4853 image and use a R_*_COPY reloc to tell the dynamic linker to 4854 initialize them at run time. The linker script puts the .dynbss 4855 section into the .bss section of the final image. */ 4856 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 4857 SEC_ALLOC | SEC_LINKER_CREATED); 4858 if (s == NULL) 4859 return FALSE; 4860 4861 /* The .rel[a].bss section holds copy relocs. This section is not 4862 normally needed. We need to create it here, though, so that the 4863 linker will map it to an output section. We can't just create it 4864 only if we need it, because we will not know whether we need it 4865 until we have seen all the input files, and the first time the 4866 main linker code calls BFD after examining all the input files 4867 (size_dynamic_sections) the input sections have already been 4868 mapped to the output sections. If the section turns out not to 4869 be needed, we can discard it later. We will never need this 4870 section when generating a shared object, since they do not use 4871 copy relocs. */ 4872 if (! bfd_link_pic (info)) 4873 { 4874 s = bfd_make_section_anyway_with_flags (abfd, 4875 (bed->default_use_rela_p 4876 ? ".rela.bss" : ".rel.bss"), 4877 flags | SEC_READONLY); 4878 if (s == NULL 4879 || ! bfd_set_section_alignment (abfd, s, ptralign)) 4880 return FALSE; 4881 } 4882 } 4883 4884 return TRUE; 4885 } 4886 4887 /* Adjust a symbol defined by a dynamic object and referenced by a 4889 regular object. The current definition is in some section of the 4890 dynamic object, but we're not including those sections. We have to 4891 change the definition to something the rest of the link can 4892 understand. */ 4893 4894 static bfd_boolean 4895 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info, 4896 struct elf_link_hash_entry * h) 4897 { 4898 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info); 4899 bfd * dynobj; 4900 asection * s; 4901 4902 dynobj = htab->root.dynobj; 4903 4904 /* Make sure we know what is going on here. */ 4905 BFD_ASSERT (dynobj != NULL 4906 && (h->needs_plt 4907 || h->u.weakdef != NULL 4908 || (h->def_dynamic 4909 && h->ref_regular 4910 && !h->def_regular))); 4911 4912 /* If this is a function, put it in the procedure linkage table. We 4913 will fill in the contents of the procedure linkage table later, 4914 when we know the address of the .got section. */ 4915 if (h->type == STT_FUNC 4916 || h->needs_plt) 4917 { 4918 if (! bfd_link_pic (info) 4919 && !h->def_dynamic 4920 && !h->ref_dynamic) 4921 { 4922 /* This case can occur if we saw a PLT reloc in an input 4923 file, but the symbol was never referred to by a dynamic 4924 object. In such a case, we don't actually need to build 4925 a procedure linkage table, and we can just do a REL32 4926 reloc instead. */ 4927 BFD_ASSERT (h->needs_plt); 4928 return TRUE; 4929 } 4930 4931 /* Make sure this symbol is output as a dynamic symbol. */ 4932 if (h->dynindx == -1) 4933 { 4934 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4935 return FALSE; 4936 } 4937 4938 s = htab->root.splt; 4939 BFD_ASSERT (s != NULL); 4940 4941 /* If this is the first .plt entry, make room for the special 4942 first entry. */ 4943 if (s->size == 0) 4944 s->size += elf_mn10300_sizeof_plt0 (info); 4945 4946 /* If this symbol is not defined in a regular file, and we are 4947 not generating a shared library, then set the symbol to this 4948 location in the .plt. This is required to make function 4949 pointers compare as equal between the normal executable and 4950 the shared library. */ 4951 if (! bfd_link_pic (info) 4952 && !h->def_regular) 4953 { 4954 h->root.u.def.section = s; 4955 h->root.u.def.value = s->size; 4956 } 4957 4958 h->plt.offset = s->size; 4959 4960 /* Make room for this entry. */ 4961 s->size += elf_mn10300_sizeof_plt (info); 4962 4963 /* We also need to make an entry in the .got.plt section, which 4964 will be placed in the .got section by the linker script. */ 4965 s = htab->root.sgotplt; 4966 BFD_ASSERT (s != NULL); 4967 s->size += 4; 4968 4969 /* We also need to make an entry in the .rela.plt section. */ 4970 s = bfd_get_linker_section (dynobj, ".rela.plt"); 4971 BFD_ASSERT (s != NULL); 4972 s->size += sizeof (Elf32_External_Rela); 4973 4974 return TRUE; 4975 } 4976 4977 /* If this is a weak symbol, and there is a real definition, the 4978 processor independent code will have arranged for us to see the 4979 real definition first, and we can just use the same value. */ 4980 if (h->u.weakdef != NULL) 4981 { 4982 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 4983 || h->u.weakdef->root.type == bfd_link_hash_defweak); 4984 h->root.u.def.section = h->u.weakdef->root.u.def.section; 4985 h->root.u.def.value = h->u.weakdef->root.u.def.value; 4986 return TRUE; 4987 } 4988 4989 /* This is a reference to a symbol defined by a dynamic object which 4990 is not a function. */ 4991 4992 /* If we are creating a shared library, we must presume that the 4993 only references to the symbol are via the global offset table. 4994 For such cases we need not do anything here; the relocations will 4995 be handled correctly by relocate_section. */ 4996 if (bfd_link_pic (info)) 4997 return TRUE; 4998 4999 /* If there are no references to this symbol that do not use the 5000 GOT, we don't need to generate a copy reloc. */ 5001 if (!h->non_got_ref) 5002 return TRUE; 5003 5004 /* We must allocate the symbol in our .dynbss section, which will 5005 become part of the .bss section of the executable. There will be 5006 an entry for this symbol in the .dynsym section. The dynamic 5007 object will contain position independent code, so all references 5008 from the dynamic object to this symbol will go through the global 5009 offset table. The dynamic linker will use the .dynsym entry to 5010 determine the address it must put in the global offset table, so 5011 both the dynamic object and the regular object will refer to the 5012 same memory location for the variable. */ 5013 5014 s = bfd_get_linker_section (dynobj, ".dynbss"); 5015 BFD_ASSERT (s != NULL); 5016 5017 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to 5018 copy the initial value out of the dynamic object and into the 5019 runtime process image. We need to remember the offset into the 5020 .rela.bss section we are going to use. */ 5021 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 5022 { 5023 asection * srel; 5024 5025 srel = bfd_get_linker_section (dynobj, ".rela.bss"); 5026 BFD_ASSERT (srel != NULL); 5027 srel->size += sizeof (Elf32_External_Rela); 5028 h->needs_copy = 1; 5029 } 5030 5031 return _bfd_elf_adjust_dynamic_copy (info, h, s); 5032 } 5033 5034 /* Set the sizes of the dynamic sections. */ 5035 5036 static bfd_boolean 5037 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd, 5038 struct bfd_link_info * info) 5039 { 5040 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info); 5041 bfd * dynobj; 5042 asection * s; 5043 bfd_boolean plt; 5044 bfd_boolean relocs; 5045 bfd_boolean reltext; 5046 5047 dynobj = htab->root.dynobj; 5048 BFD_ASSERT (dynobj != NULL); 5049 5050 if (elf_hash_table (info)->dynamic_sections_created) 5051 { 5052 /* Set the contents of the .interp section to the interpreter. */ 5053 if (bfd_link_executable (info)) 5054 { 5055 s = bfd_get_linker_section (dynobj, ".interp"); 5056 BFD_ASSERT (s != NULL); 5057 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 5058 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 5059 } 5060 } 5061 else 5062 { 5063 /* We may have created entries in the .rela.got section. 5064 However, if we are not creating the dynamic sections, we will 5065 not actually use these entries. Reset the size of .rela.got, 5066 which will cause it to get stripped from the output file 5067 below. */ 5068 s = htab->root.sgot; 5069 if (s != NULL) 5070 s->size = 0; 5071 } 5072 5073 if (htab->tls_ldm_got.refcount > 0) 5074 { 5075 s = bfd_get_linker_section (dynobj, ".rela.got"); 5076 BFD_ASSERT (s != NULL); 5077 s->size += sizeof (Elf32_External_Rela); 5078 } 5079 5080 /* The check_relocs and adjust_dynamic_symbol entry points have 5081 determined the sizes of the various dynamic sections. Allocate 5082 memory for them. */ 5083 plt = FALSE; 5084 relocs = FALSE; 5085 reltext = FALSE; 5086 for (s = dynobj->sections; s != NULL; s = s->next) 5087 { 5088 const char * name; 5089 5090 if ((s->flags & SEC_LINKER_CREATED) == 0) 5091 continue; 5092 5093 /* It's OK to base decisions on the section name, because none 5094 of the dynobj section names depend upon the input files. */ 5095 name = bfd_get_section_name (dynobj, s); 5096 5097 if (streq (name, ".plt")) 5098 { 5099 /* Remember whether there is a PLT. */ 5100 plt = s->size != 0; 5101 } 5102 else if (CONST_STRNEQ (name, ".rela")) 5103 { 5104 if (s->size != 0) 5105 { 5106 asection * target; 5107 5108 /* Remember whether there are any reloc sections other 5109 than .rela.plt. */ 5110 if (! streq (name, ".rela.plt")) 5111 { 5112 const char * outname; 5113 5114 relocs = TRUE; 5115 5116 /* If this relocation section applies to a read only 5117 section, then we probably need a DT_TEXTREL 5118 entry. The entries in the .rela.plt section 5119 really apply to the .got section, which we 5120 created ourselves and so know is not readonly. */ 5121 outname = bfd_get_section_name (output_bfd, 5122 s->output_section); 5123 target = bfd_get_section_by_name (output_bfd, outname + 5); 5124 if (target != NULL 5125 && (target->flags & SEC_READONLY) != 0 5126 && (target->flags & SEC_ALLOC) != 0) 5127 reltext = TRUE; 5128 } 5129 5130 /* We use the reloc_count field as a counter if we need 5131 to copy relocs into the output file. */ 5132 s->reloc_count = 0; 5133 } 5134 } 5135 else if (! CONST_STRNEQ (name, ".got") 5136 && ! streq (name, ".dynbss")) 5137 /* It's not one of our sections, so don't allocate space. */ 5138 continue; 5139 5140 if (s->size == 0) 5141 { 5142 /* If we don't need this section, strip it from the 5143 output file. This is mostly to handle .rela.bss and 5144 .rela.plt. We must create both sections in 5145 create_dynamic_sections, because they must be created 5146 before the linker maps input sections to output 5147 sections. The linker does that before 5148 adjust_dynamic_symbol is called, and it is that 5149 function which decides whether anything needs to go 5150 into these sections. */ 5151 s->flags |= SEC_EXCLUDE; 5152 continue; 5153 } 5154 5155 if ((s->flags & SEC_HAS_CONTENTS) == 0) 5156 continue; 5157 5158 /* Allocate memory for the section contents. We use bfd_zalloc 5159 here in case unused entries are not reclaimed before the 5160 section's contents are written out. This should not happen, 5161 but this way if it does, we get a R_MN10300_NONE reloc 5162 instead of garbage. */ 5163 s->contents = bfd_zalloc (dynobj, s->size); 5164 if (s->contents == NULL) 5165 return FALSE; 5166 } 5167 5168 if (elf_hash_table (info)->dynamic_sections_created) 5169 { 5170 /* Add some entries to the .dynamic section. We fill in the 5171 values later, in _bfd_mn10300_elf_finish_dynamic_sections, 5172 but we must add the entries now so that we get the correct 5173 size for the .dynamic section. The DT_DEBUG entry is filled 5174 in by the dynamic linker and used by the debugger. */ 5175 if (! bfd_link_pic (info)) 5176 { 5177 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0)) 5178 return FALSE; 5179 } 5180 5181 if (plt) 5182 { 5183 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0) 5184 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) 5185 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA) 5186 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)) 5187 return FALSE; 5188 } 5189 5190 if (relocs) 5191 { 5192 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0) 5193 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0) 5194 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT, 5195 sizeof (Elf32_External_Rela))) 5196 return FALSE; 5197 } 5198 5199 if (reltext) 5200 { 5201 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0)) 5202 return FALSE; 5203 } 5204 } 5205 5206 return TRUE; 5207 } 5208 5209 /* Finish up dynamic symbol handling. We set the contents of various 5210 dynamic sections here. */ 5211 5212 static bfd_boolean 5213 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd, 5214 struct bfd_link_info * info, 5215 struct elf_link_hash_entry * h, 5216 Elf_Internal_Sym * sym) 5217 { 5218 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info); 5219 bfd * dynobj; 5220 5221 dynobj = htab->root.dynobj; 5222 5223 if (h->plt.offset != (bfd_vma) -1) 5224 { 5225 asection * splt; 5226 asection * sgot; 5227 asection * srel; 5228 bfd_vma plt_index; 5229 bfd_vma got_offset; 5230 Elf_Internal_Rela rel; 5231 5232 /* This symbol has an entry in the procedure linkage table. Set 5233 it up. */ 5234 5235 BFD_ASSERT (h->dynindx != -1); 5236 5237 splt = htab->root.splt; 5238 sgot = htab->root.sgotplt; 5239 srel = bfd_get_linker_section (dynobj, ".rela.plt"); 5240 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 5241 5242 /* Get the index in the procedure linkage table which 5243 corresponds to this symbol. This is the index of this symbol 5244 in all the symbols for which we are making plt entries. The 5245 first entry in the procedure linkage table is reserved. */ 5246 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info)) 5247 / elf_mn10300_sizeof_plt (info)); 5248 5249 /* Get the offset into the .got table of the entry that 5250 corresponds to this function. Each .got entry is 4 bytes. 5251 The first three are reserved. */ 5252 got_offset = (plt_index + 3) * 4; 5253 5254 /* Fill in the entry in the procedure linkage table. */ 5255 if (! bfd_link_pic (info)) 5256 { 5257 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry, 5258 elf_mn10300_sizeof_plt (info)); 5259 bfd_put_32 (output_bfd, 5260 (sgot->output_section->vma 5261 + sgot->output_offset 5262 + got_offset), 5263 (splt->contents + h->plt.offset 5264 + elf_mn10300_plt_symbol_offset (info))); 5265 5266 bfd_put_32 (output_bfd, 5267 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)), 5268 (splt->contents + h->plt.offset 5269 + elf_mn10300_plt_plt0_offset (info))); 5270 } 5271 else 5272 { 5273 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry, 5274 elf_mn10300_sizeof_plt (info)); 5275 5276 bfd_put_32 (output_bfd, got_offset, 5277 (splt->contents + h->plt.offset 5278 + elf_mn10300_plt_symbol_offset (info))); 5279 } 5280 5281 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela), 5282 (splt->contents + h->plt.offset 5283 + elf_mn10300_plt_reloc_offset (info))); 5284 5285 /* Fill in the entry in the global offset table. */ 5286 bfd_put_32 (output_bfd, 5287 (splt->output_section->vma 5288 + splt->output_offset 5289 + h->plt.offset 5290 + elf_mn10300_plt_temp_offset (info)), 5291 sgot->contents + got_offset); 5292 5293 /* Fill in the entry in the .rela.plt section. */ 5294 rel.r_offset = (sgot->output_section->vma 5295 + sgot->output_offset 5296 + got_offset); 5297 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT); 5298 rel.r_addend = 0; 5299 bfd_elf32_swap_reloca_out (output_bfd, &rel, 5300 (bfd_byte *) ((Elf32_External_Rela *) srel->contents 5301 + plt_index)); 5302 5303 if (!h->def_regular) 5304 /* Mark the symbol as undefined, rather than as defined in 5305 the .plt section. Leave the value alone. */ 5306 sym->st_shndx = SHN_UNDEF; 5307 } 5308 5309 if (h->got.offset != (bfd_vma) -1) 5310 { 5311 asection * sgot; 5312 asection * srel; 5313 Elf_Internal_Rela rel; 5314 5315 /* This symbol has an entry in the global offset table. Set it up. */ 5316 sgot = htab->root.sgot; 5317 srel = bfd_get_linker_section (dynobj, ".rela.got"); 5318 BFD_ASSERT (sgot != NULL && srel != NULL); 5319 5320 rel.r_offset = (sgot->output_section->vma 5321 + sgot->output_offset 5322 + (h->got.offset & ~1)); 5323 5324 switch (elf_mn10300_hash_entry (h)->tls_type) 5325 { 5326 case GOT_TLS_GD: 5327 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 5328 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset + 4); 5329 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPMOD); 5330 rel.r_addend = 0; 5331 bfd_elf32_swap_reloca_out (output_bfd, & rel, 5332 (bfd_byte *) ((Elf32_External_Rela *) srel->contents 5333 + srel->reloc_count)); 5334 ++ srel->reloc_count; 5335 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPOFF); 5336 rel.r_offset += 4; 5337 rel.r_addend = 0; 5338 break; 5339 5340 case GOT_TLS_IE: 5341 /* We originally stored the addend in the GOT, but at this 5342 point, we want to move it to the reloc instead as that's 5343 where the dynamic linker wants it. */ 5344 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + h->got.offset); 5345 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 5346 if (h->dynindx == -1) 5347 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF); 5348 else 5349 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_TPOFF); 5350 break; 5351 5352 default: 5353 /* If this is a -Bsymbolic link, and the symbol is defined 5354 locally, we just want to emit a RELATIVE reloc. Likewise if 5355 the symbol was forced to be local because of a version file. 5356 The entry in the global offset table will already have been 5357 initialized in the relocate_section function. */ 5358 if (bfd_link_pic (info) 5359 && (info->symbolic || h->dynindx == -1) 5360 && h->def_regular) 5361 { 5362 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE); 5363 rel.r_addend = (h->root.u.def.value 5364 + h->root.u.def.section->output_section->vma 5365 + h->root.u.def.section->output_offset); 5366 } 5367 else 5368 { 5369 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 5370 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT); 5371 rel.r_addend = 0; 5372 } 5373 } 5374 5375 if (ELF32_R_TYPE (rel.r_info) != R_MN10300_NONE) 5376 { 5377 bfd_elf32_swap_reloca_out (output_bfd, &rel, 5378 (bfd_byte *) ((Elf32_External_Rela *) srel->contents 5379 + srel->reloc_count)); 5380 ++ srel->reloc_count; 5381 } 5382 } 5383 5384 if (h->needs_copy) 5385 { 5386 asection * s; 5387 Elf_Internal_Rela rel; 5388 5389 /* This symbol needs a copy reloc. Set it up. */ 5390 BFD_ASSERT (h->dynindx != -1 5391 && (h->root.type == bfd_link_hash_defined 5392 || h->root.type == bfd_link_hash_defweak)); 5393 5394 s = bfd_get_linker_section (dynobj, ".rela.bss"); 5395 BFD_ASSERT (s != NULL); 5396 5397 rel.r_offset = (h->root.u.def.value 5398 + h->root.u.def.section->output_section->vma 5399 + h->root.u.def.section->output_offset); 5400 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY); 5401 rel.r_addend = 0; 5402 bfd_elf32_swap_reloca_out (output_bfd, & rel, 5403 (bfd_byte *) ((Elf32_External_Rela *) s->contents 5404 + s->reloc_count)); 5405 ++ s->reloc_count; 5406 } 5407 5408 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 5409 if (h == elf_hash_table (info)->hdynamic 5410 || h == elf_hash_table (info)->hgot) 5411 sym->st_shndx = SHN_ABS; 5412 5413 return TRUE; 5414 } 5415 5416 /* Finish up the dynamic sections. */ 5417 5418 static bfd_boolean 5419 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd, 5420 struct bfd_link_info * info) 5421 { 5422 bfd * dynobj; 5423 asection * sgot; 5424 asection * sdyn; 5425 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info); 5426 5427 dynobj = htab->root.dynobj; 5428 sgot = htab->root.sgotplt; 5429 BFD_ASSERT (sgot != NULL); 5430 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 5431 5432 if (elf_hash_table (info)->dynamic_sections_created) 5433 { 5434 asection * splt; 5435 Elf32_External_Dyn * dyncon; 5436 Elf32_External_Dyn * dynconend; 5437 5438 BFD_ASSERT (sdyn != NULL); 5439 5440 dyncon = (Elf32_External_Dyn *) sdyn->contents; 5441 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 5442 5443 for (; dyncon < dynconend; dyncon++) 5444 { 5445 Elf_Internal_Dyn dyn; 5446 const char * name; 5447 asection * s; 5448 5449 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 5450 5451 switch (dyn.d_tag) 5452 { 5453 default: 5454 break; 5455 5456 case DT_PLTGOT: 5457 name = ".got"; 5458 goto get_vma; 5459 5460 case DT_JMPREL: 5461 name = ".rela.plt"; 5462 get_vma: 5463 s = bfd_get_linker_section (dynobj, name); 5464 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 5465 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5466 break; 5467 5468 case DT_PLTRELSZ: 5469 s = bfd_get_linker_section (dynobj, ".rela.plt"); 5470 dyn.d_un.d_val = s->size; 5471 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5472 break; 5473 5474 case DT_RELASZ: 5475 /* My reading of the SVR4 ABI indicates that the 5476 procedure linkage table relocs (DT_JMPREL) should be 5477 included in the overall relocs (DT_RELA). This is 5478 what Solaris does. However, UnixWare can not handle 5479 that case. Therefore, we override the DT_RELASZ entry 5480 here to make it not include the JMPREL relocs. Since 5481 the linker script arranges for .rela.plt to follow all 5482 other relocation sections, we don't have to worry 5483 about changing the DT_RELA entry. */ 5484 s = bfd_get_linker_section (dynobj, ".rela.plt"); 5485 if (s != NULL) 5486 dyn.d_un.d_val -= s->size; 5487 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5488 break; 5489 } 5490 } 5491 5492 /* Fill in the first entry in the procedure linkage table. */ 5493 splt = htab->root.splt; 5494 if (splt && splt->size > 0) 5495 { 5496 if (bfd_link_pic (info)) 5497 { 5498 memcpy (splt->contents, elf_mn10300_pic_plt_entry, 5499 elf_mn10300_sizeof_plt (info)); 5500 } 5501 else 5502 { 5503 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE); 5504 bfd_put_32 (output_bfd, 5505 sgot->output_section->vma + sgot->output_offset + 4, 5506 splt->contents + elf_mn10300_plt0_gotid_offset (info)); 5507 bfd_put_32 (output_bfd, 5508 sgot->output_section->vma + sgot->output_offset + 8, 5509 splt->contents + elf_mn10300_plt0_linker_offset (info)); 5510 } 5511 5512 /* UnixWare sets the entsize of .plt to 4, although that doesn't 5513 really seem like the right value. */ 5514 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 5515 5516 /* UnixWare sets the entsize of .plt to 4, but this is incorrect 5517 as it means that the size of the PLT0 section (15 bytes) is not 5518 a multiple of the sh_entsize. Some ELF tools flag this as an 5519 error. We could pad PLT0 to 16 bytes, but that would introduce 5520 compatibilty issues with previous toolchains, so instead we 5521 just set the entry size to 1. */ 5522 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1; 5523 } 5524 } 5525 5526 /* Fill in the first three entries in the global offset table. */ 5527 if (sgot->size > 0) 5528 { 5529 if (sdyn == NULL) 5530 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 5531 else 5532 bfd_put_32 (output_bfd, 5533 sdyn->output_section->vma + sdyn->output_offset, 5534 sgot->contents); 5535 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 5536 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 5537 } 5538 5539 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 5540 5541 return TRUE; 5542 } 5543 5544 /* Classify relocation types, such that combreloc can sort them 5545 properly. */ 5546 5547 static enum elf_reloc_type_class 5548 _bfd_mn10300_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 5549 const asection *rel_sec ATTRIBUTE_UNUSED, 5550 const Elf_Internal_Rela *rela) 5551 { 5552 switch ((int) ELF32_R_TYPE (rela->r_info)) 5553 { 5554 case R_MN10300_RELATIVE: return reloc_class_relative; 5555 case R_MN10300_JMP_SLOT: return reloc_class_plt; 5556 case R_MN10300_COPY: return reloc_class_copy; 5557 default: return reloc_class_normal; 5558 } 5559 } 5560 5561 /* Allocate space for an MN10300 extension to the bfd elf data structure. */ 5562 5563 static bfd_boolean 5564 mn10300_elf_mkobject (bfd *abfd) 5565 { 5566 return bfd_elf_allocate_object (abfd, sizeof (struct elf_mn10300_obj_tdata), 5567 MN10300_ELF_DATA); 5568 } 5569 5570 #define bfd_elf32_mkobject mn10300_elf_mkobject 5571 5572 #ifndef ELF_ARCH 5573 #define TARGET_LITTLE_SYM mn10300_elf32_vec 5574 #define TARGET_LITTLE_NAME "elf32-mn10300" 5575 #define ELF_ARCH bfd_arch_mn10300 5576 #define ELF_TARGET_ID MN10300_ELF_DATA 5577 #define ELF_MACHINE_CODE EM_MN10300 5578 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300 5579 #define ELF_MAXPAGESIZE 0x1000 5580 #endif 5581 5582 #define elf_info_to_howto mn10300_info_to_howto 5583 #define elf_info_to_howto_rel 0 5584 #define elf_backend_can_gc_sections 1 5585 #define elf_backend_rela_normal 1 5586 #define elf_backend_check_relocs mn10300_elf_check_relocs 5587 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook 5588 #define elf_backend_relocate_section mn10300_elf_relocate_section 5589 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section 5590 #define bfd_elf32_bfd_get_relocated_section_contents \ 5591 mn10300_elf_get_relocated_section_contents 5592 #define bfd_elf32_bfd_link_hash_table_create \ 5593 elf32_mn10300_link_hash_table_create 5594 5595 #ifndef elf_symbol_leading_char 5596 #define elf_symbol_leading_char '_' 5597 #endif 5598 5599 /* So we can set bits in e_flags. */ 5600 #define elf_backend_final_write_processing \ 5601 _bfd_mn10300_elf_final_write_processing 5602 #define elf_backend_object_p _bfd_mn10300_elf_object_p 5603 5604 #define bfd_elf32_bfd_merge_private_bfd_data \ 5605 _bfd_mn10300_elf_merge_private_bfd_data 5606 5607 #define elf_backend_can_gc_sections 1 5608 #define elf_backend_create_dynamic_sections \ 5609 _bfd_mn10300_elf_create_dynamic_sections 5610 #define elf_backend_adjust_dynamic_symbol \ 5611 _bfd_mn10300_elf_adjust_dynamic_symbol 5612 #define elf_backend_size_dynamic_sections \ 5613 _bfd_mn10300_elf_size_dynamic_sections 5614 #define elf_backend_omit_section_dynsym \ 5615 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 5616 #define elf_backend_finish_dynamic_symbol \ 5617 _bfd_mn10300_elf_finish_dynamic_symbol 5618 #define elf_backend_finish_dynamic_sections \ 5619 _bfd_mn10300_elf_finish_dynamic_sections 5620 #define elf_backend_copy_indirect_symbol \ 5621 _bfd_mn10300_copy_indirect_symbol 5622 #define elf_backend_reloc_type_class \ 5623 _bfd_mn10300_elf_reloc_type_class 5624 5625 #define elf_backend_want_got_plt 1 5626 #define elf_backend_plt_readonly 1 5627 #define elf_backend_want_plt_sym 0 5628 #define elf_backend_got_header_size 12 5629 5630 #include "elf32-target.h" 5631
