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