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