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