1 /* MIPS-specific support for ELF 2 Copyright (C) 1993-2020 Free Software Foundation, Inc. 3 4 Most of the information added by Ian Lance Taylor, Cygnus Support, 5 <ian@cygnus.com>. 6 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC. 7 <mark@codesourcery.com> 8 Traditional MIPS targets support added by Koundinya.K, Dansk Data 9 Elektronik & Operations Research Group. <kk@ddeorg.soft.net> 10 11 This file is part of BFD, the Binary File Descriptor library. 12 13 This program is free software; you can redistribute it and/or modify 14 it under the terms of the GNU General Public License as published by 15 the Free Software Foundation; either version 3 of the License, or 16 (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, 19 but WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 GNU General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 26 MA 02110-1301, USA. */ 27 28 29 /* This file handles functionality common to the different MIPS ABI's. */ 30 31 #include "sysdep.h" 32 #include "bfd.h" 33 #include "libbfd.h" 34 #include "libiberty.h" 35 #include "elf-bfd.h" 36 #include "ecoff-bfd.h" 37 #include "elfxx-mips.h" 38 #include "elf/mips.h" 39 #include "elf-vxworks.h" 40 #include "dwarf2.h" 41 42 /* Get the ECOFF swapping routines. */ 43 #include "coff/sym.h" 44 #include "coff/symconst.h" 45 #include "coff/ecoff.h" 46 #include "coff/mips.h" 47 48 #include "hashtab.h" 49 50 /* Types of TLS GOT entry. */ 51 enum mips_got_tls_type { 52 GOT_TLS_NONE, 53 GOT_TLS_GD, 54 GOT_TLS_LDM, 55 GOT_TLS_IE 56 }; 57 58 /* This structure is used to hold information about one GOT entry. 59 There are four types of entry: 60 61 (1) an absolute address 62 requires: abfd == NULL 63 fields: d.address 64 65 (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd 66 requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM 67 fields: abfd, symndx, d.addend, tls_type 68 69 (3) a SYMBOL address, where SYMBOL is not local to an input bfd 70 requires: abfd != NULL, symndx == -1 71 fields: d.h, tls_type 72 73 (4) a TLS LDM slot 74 requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM 75 fields: none; there's only one of these per GOT. */ 76 struct mips_got_entry 77 { 78 /* One input bfd that needs the GOT entry. */ 79 bfd *abfd; 80 /* The index of the symbol, as stored in the relocation r_info, if 81 we have a local symbol; -1 otherwise. */ 82 long symndx; 83 union 84 { 85 /* If abfd == NULL, an address that must be stored in the got. */ 86 bfd_vma address; 87 /* If abfd != NULL && symndx != -1, the addend of the relocation 88 that should be added to the symbol value. */ 89 bfd_vma addend; 90 /* If abfd != NULL && symndx == -1, the hash table entry 91 corresponding to a symbol in the GOT. The symbol's entry 92 is in the local area if h->global_got_area is GGA_NONE, 93 otherwise it is in the global area. */ 94 struct mips_elf_link_hash_entry *h; 95 } d; 96 97 /* The TLS type of this GOT entry. An LDM GOT entry will be a local 98 symbol entry with r_symndx == 0. */ 99 unsigned char tls_type; 100 101 /* True if we have filled in the GOT contents for a TLS entry, 102 and created the associated relocations. */ 103 unsigned char tls_initialized; 104 105 /* The offset from the beginning of the .got section to the entry 106 corresponding to this symbol+addend. If it's a global symbol 107 whose offset is yet to be decided, it's going to be -1. */ 108 long gotidx; 109 }; 110 111 /* This structure represents a GOT page reference from an input bfd. 112 Each instance represents a symbol + ADDEND, where the representation 113 of the symbol depends on whether it is local to the input bfd. 114 If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD. 115 Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry. 116 117 Page references with SYMNDX >= 0 always become page references 118 in the output. Page references with SYMNDX < 0 only become page 119 references if the symbol binds locally; in other cases, the page 120 reference decays to a global GOT reference. */ 121 struct mips_got_page_ref 122 { 123 long symndx; 124 union 125 { 126 struct mips_elf_link_hash_entry *h; 127 bfd *abfd; 128 } u; 129 bfd_vma addend; 130 }; 131 132 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND]. 133 The structures form a non-overlapping list that is sorted by increasing 134 MIN_ADDEND. */ 135 struct mips_got_page_range 136 { 137 struct mips_got_page_range *next; 138 bfd_signed_vma min_addend; 139 bfd_signed_vma max_addend; 140 }; 141 142 /* This structure describes the range of addends that are applied to page 143 relocations against a given section. */ 144 struct mips_got_page_entry 145 { 146 /* The section that these entries are based on. */ 147 asection *sec; 148 /* The ranges for this page entry. */ 149 struct mips_got_page_range *ranges; 150 /* The maximum number of page entries needed for RANGES. */ 151 bfd_vma num_pages; 152 }; 153 154 /* This structure is used to hold .got information when linking. */ 155 156 struct mips_got_info 157 { 158 /* The number of global .got entries. */ 159 unsigned int global_gotno; 160 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */ 161 unsigned int reloc_only_gotno; 162 /* The number of .got slots used for TLS. */ 163 unsigned int tls_gotno; 164 /* The first unused TLS .got entry. Used only during 165 mips_elf_initialize_tls_index. */ 166 unsigned int tls_assigned_gotno; 167 /* The number of local .got entries, eventually including page entries. */ 168 unsigned int local_gotno; 169 /* The maximum number of page entries needed. */ 170 unsigned int page_gotno; 171 /* The number of relocations needed for the GOT entries. */ 172 unsigned int relocs; 173 /* The first unused local .got entry. */ 174 unsigned int assigned_low_gotno; 175 /* The last unused local .got entry. */ 176 unsigned int assigned_high_gotno; 177 /* A hash table holding members of the got. */ 178 struct htab *got_entries; 179 /* A hash table holding mips_got_page_ref structures. */ 180 struct htab *got_page_refs; 181 /* A hash table of mips_got_page_entry structures. */ 182 struct htab *got_page_entries; 183 /* In multi-got links, a pointer to the next got (err, rather, most 184 of the time, it points to the previous got). */ 185 struct mips_got_info *next; 186 }; 187 188 /* Structure passed when merging bfds' gots. */ 189 190 struct mips_elf_got_per_bfd_arg 191 { 192 /* The output bfd. */ 193 bfd *obfd; 194 /* The link information. */ 195 struct bfd_link_info *info; 196 /* A pointer to the primary got, i.e., the one that's going to get 197 the implicit relocations from DT_MIPS_LOCAL_GOTNO and 198 DT_MIPS_GOTSYM. */ 199 struct mips_got_info *primary; 200 /* A non-primary got we're trying to merge with other input bfd's 201 gots. */ 202 struct mips_got_info *current; 203 /* The maximum number of got entries that can be addressed with a 204 16-bit offset. */ 205 unsigned int max_count; 206 /* The maximum number of page entries needed by each got. */ 207 unsigned int max_pages; 208 /* The total number of global entries which will live in the 209 primary got and be automatically relocated. This includes 210 those not referenced by the primary GOT but included in 211 the "master" GOT. */ 212 unsigned int global_count; 213 }; 214 215 /* A structure used to pass information to htab_traverse callbacks 216 when laying out the GOT. */ 217 218 struct mips_elf_traverse_got_arg 219 { 220 struct bfd_link_info *info; 221 struct mips_got_info *g; 222 int value; 223 }; 224 225 struct _mips_elf_section_data 226 { 227 struct bfd_elf_section_data elf; 228 union 229 { 230 bfd_byte *tdata; 231 } u; 232 }; 233 234 #define mips_elf_section_data(sec) \ 235 ((struct _mips_elf_section_data *) elf_section_data (sec)) 236 237 #define is_mips_elf(bfd) \ 238 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 239 && elf_tdata (bfd) != NULL \ 240 && elf_object_id (bfd) == MIPS_ELF_DATA) 241 242 /* The ABI says that every symbol used by dynamic relocations must have 243 a global GOT entry. Among other things, this provides the dynamic 244 linker with a free, directly-indexed cache. The GOT can therefore 245 contain symbols that are not referenced by GOT relocations themselves 246 (in other words, it may have symbols that are not referenced by things 247 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE). 248 249 GOT relocations are less likely to overflow if we put the associated 250 GOT entries towards the beginning. We therefore divide the global 251 GOT entries into two areas: "normal" and "reloc-only". Entries in 252 the first area can be used for both dynamic relocations and GP-relative 253 accesses, while those in the "reloc-only" area are for dynamic 254 relocations only. 255 256 These GGA_* ("Global GOT Area") values are organised so that lower 257 values are more general than higher values. Also, non-GGA_NONE 258 values are ordered by the position of the area in the GOT. */ 259 #define GGA_NORMAL 0 260 #define GGA_RELOC_ONLY 1 261 #define GGA_NONE 2 262 263 /* Information about a non-PIC interface to a PIC function. There are 264 two ways of creating these interfaces. The first is to add: 265 266 lui $25,%hi(func) 267 addiu $25,$25,%lo(func) 268 269 immediately before a PIC function "func". The second is to add: 270 271 lui $25,%hi(func) 272 j func 273 addiu $25,$25,%lo(func) 274 275 to a separate trampoline section. 276 277 Stubs of the first kind go in a new section immediately before the 278 target function. Stubs of the second kind go in a single section 279 pointed to by the hash table's "strampoline" field. */ 280 struct mips_elf_la25_stub { 281 /* The generated section that contains this stub. */ 282 asection *stub_section; 283 284 /* The offset of the stub from the start of STUB_SECTION. */ 285 bfd_vma offset; 286 287 /* One symbol for the original function. Its location is available 288 in H->root.root.u.def. */ 289 struct mips_elf_link_hash_entry *h; 290 }; 291 292 /* Macros for populating a mips_elf_la25_stub. */ 293 294 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */ 295 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */ 296 #define LA25_BC(VAL) (0xc8000000 | (((VAL) >> 2) & 0x3ffffff)) /* bc VAL */ 297 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */ 298 #define LA25_LUI_MICROMIPS(VAL) \ 299 (0x41b90000 | (VAL)) /* lui t9,VAL */ 300 #define LA25_J_MICROMIPS(VAL) \ 301 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */ 302 #define LA25_ADDIU_MICROMIPS(VAL) \ 303 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */ 304 305 /* This structure is passed to mips_elf_sort_hash_table_f when sorting 306 the dynamic symbols. */ 307 308 struct mips_elf_hash_sort_data 309 { 310 /* The symbol in the global GOT with the lowest dynamic symbol table 311 index. */ 312 struct elf_link_hash_entry *low; 313 /* The least dynamic symbol table index corresponding to a non-TLS 314 symbol with a GOT entry. */ 315 bfd_size_type min_got_dynindx; 316 /* The greatest dynamic symbol table index corresponding to a symbol 317 with a GOT entry that is not referenced (e.g., a dynamic symbol 318 with dynamic relocations pointing to it from non-primary GOTs). */ 319 bfd_size_type max_unref_got_dynindx; 320 /* The greatest dynamic symbol table index corresponding to a local 321 symbol. */ 322 bfd_size_type max_local_dynindx; 323 /* The greatest dynamic symbol table index corresponding to an external 324 symbol without a GOT entry. */ 325 bfd_size_type max_non_got_dynindx; 326 /* If non-NULL, output BFD for .MIPS.xhash finalization. */ 327 bfd *output_bfd; 328 /* If non-NULL, pointer to contents of .MIPS.xhash for filling in 329 real final dynindx. */ 330 bfd_byte *mipsxhash; 331 }; 332 333 /* We make up to two PLT entries if needed, one for standard MIPS code 334 and one for compressed code, either a MIPS16 or microMIPS one. We 335 keep a separate record of traditional lazy-binding stubs, for easier 336 processing. */ 337 338 struct plt_entry 339 { 340 /* Traditional SVR4 stub offset, or -1 if none. */ 341 bfd_vma stub_offset; 342 343 /* Standard PLT entry offset, or -1 if none. */ 344 bfd_vma mips_offset; 345 346 /* Compressed PLT entry offset, or -1 if none. */ 347 bfd_vma comp_offset; 348 349 /* The corresponding .got.plt index, or -1 if none. */ 350 bfd_vma gotplt_index; 351 352 /* Whether we need a standard PLT entry. */ 353 unsigned int need_mips : 1; 354 355 /* Whether we need a compressed PLT entry. */ 356 unsigned int need_comp : 1; 357 }; 358 359 /* The MIPS ELF linker needs additional information for each symbol in 360 the global hash table. */ 361 362 struct mips_elf_link_hash_entry 363 { 364 struct elf_link_hash_entry root; 365 366 /* External symbol information. */ 367 EXTR esym; 368 369 /* The la25 stub we have created for ths symbol, if any. */ 370 struct mips_elf_la25_stub *la25_stub; 371 372 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against 373 this symbol. */ 374 unsigned int possibly_dynamic_relocs; 375 376 /* If there is a stub that 32 bit functions should use to call this 377 16 bit function, this points to the section containing the stub. */ 378 asection *fn_stub; 379 380 /* If there is a stub that 16 bit functions should use to call this 381 32 bit function, this points to the section containing the stub. */ 382 asection *call_stub; 383 384 /* This is like the call_stub field, but it is used if the function 385 being called returns a floating point value. */ 386 asection *call_fp_stub; 387 388 /* If non-zero, location in .MIPS.xhash to write real final dynindx. */ 389 bfd_vma mipsxhash_loc; 390 391 /* The highest GGA_* value that satisfies all references to this symbol. */ 392 unsigned int global_got_area : 2; 393 394 /* True if all GOT relocations against this symbol are for calls. This is 395 a looser condition than no_fn_stub below, because there may be other 396 non-call non-GOT relocations against the symbol. */ 397 unsigned int got_only_for_calls : 1; 398 399 /* True if one of the relocations described by possibly_dynamic_relocs 400 is against a readonly section. */ 401 unsigned int readonly_reloc : 1; 402 403 /* True if there is a relocation against this symbol that must be 404 resolved by the static linker (in other words, if the relocation 405 cannot possibly be made dynamic). */ 406 unsigned int has_static_relocs : 1; 407 408 /* True if we must not create a .MIPS.stubs entry for this symbol. 409 This is set, for example, if there are relocations related to 410 taking the function's address, i.e. any but R_MIPS_CALL*16 ones. 411 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */ 412 unsigned int no_fn_stub : 1; 413 414 /* Whether we need the fn_stub; this is true if this symbol appears 415 in any relocs other than a 16 bit call. */ 416 unsigned int need_fn_stub : 1; 417 418 /* True if this symbol is referenced by branch relocations from 419 any non-PIC input file. This is used to determine whether an 420 la25 stub is required. */ 421 unsigned int has_nonpic_branches : 1; 422 423 /* Does this symbol need a traditional MIPS lazy-binding stub 424 (as opposed to a PLT entry)? */ 425 unsigned int needs_lazy_stub : 1; 426 427 /* Does this symbol resolve to a PLT entry? */ 428 unsigned int use_plt_entry : 1; 429 }; 430 431 /* MIPS ELF linker hash table. */ 432 433 struct mips_elf_link_hash_table 434 { 435 struct elf_link_hash_table root; 436 437 /* The number of .rtproc entries. */ 438 bfd_size_type procedure_count; 439 440 /* The size of the .compact_rel section (if SGI_COMPAT). */ 441 bfd_size_type compact_rel_size; 442 443 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry 444 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */ 445 bfd_boolean use_rld_obj_head; 446 447 /* The __rld_map or __rld_obj_head symbol. */ 448 struct elf_link_hash_entry *rld_symbol; 449 450 /* This is set if we see any mips16 stub sections. */ 451 bfd_boolean mips16_stubs_seen; 452 453 /* True if we can generate copy relocs and PLTs. */ 454 bfd_boolean use_plts_and_copy_relocs; 455 456 /* True if we can only use 32-bit microMIPS instructions. */ 457 bfd_boolean insn32; 458 459 /* True if we suppress checks for invalid branches between ISA modes. */ 460 bfd_boolean ignore_branch_isa; 461 462 /* True if we are targetting R6 compact branches. */ 463 bfd_boolean compact_branches; 464 465 /* True if we already reported the small-data section overflow. */ 466 bfd_boolean small_data_overflow_reported; 467 468 /* True if we use the special `__gnu_absolute_zero' symbol. */ 469 bfd_boolean use_absolute_zero; 470 471 /* True if we have been configured for a GNU target. */ 472 bfd_boolean gnu_target; 473 474 /* Shortcuts to some dynamic sections, or NULL if they are not 475 being used. */ 476 asection *srelplt2; 477 asection *sstubs; 478 479 /* The master GOT information. */ 480 struct mips_got_info *got_info; 481 482 /* The global symbol in the GOT with the lowest index in the dynamic 483 symbol table. */ 484 struct elf_link_hash_entry *global_gotsym; 485 486 /* The size of the PLT header in bytes. */ 487 bfd_vma plt_header_size; 488 489 /* The size of a standard PLT entry in bytes. */ 490 bfd_vma plt_mips_entry_size; 491 492 /* The size of a compressed PLT entry in bytes. */ 493 bfd_vma plt_comp_entry_size; 494 495 /* The offset of the next standard PLT entry to create. */ 496 bfd_vma plt_mips_offset; 497 498 /* The offset of the next compressed PLT entry to create. */ 499 bfd_vma plt_comp_offset; 500 501 /* The index of the next .got.plt entry to create. */ 502 bfd_vma plt_got_index; 503 504 /* The number of functions that need a lazy-binding stub. */ 505 bfd_vma lazy_stub_count; 506 507 /* The size of a function stub entry in bytes. */ 508 bfd_vma function_stub_size; 509 510 /* The number of reserved entries at the beginning of the GOT. */ 511 unsigned int reserved_gotno; 512 513 /* The section used for mips_elf_la25_stub trampolines. 514 See the comment above that structure for details. */ 515 asection *strampoline; 516 517 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset) 518 pairs. */ 519 htab_t la25_stubs; 520 521 /* A function FN (NAME, IS, OS) that creates a new input section 522 called NAME and links it to output section OS. If IS is nonnull, 523 the new section should go immediately before it, otherwise it 524 should go at the (current) beginning of OS. 525 526 The function returns the new section on success, otherwise it 527 returns null. */ 528 asection *(*add_stub_section) (const char *, asection *, asection *); 529 530 /* Is the PLT header compressed? */ 531 unsigned int plt_header_is_comp : 1; 532 }; 533 534 /* Get the MIPS ELF linker hash table from a link_info structure. */ 535 536 #define mips_elf_hash_table(p) \ 537 ((is_elf_hash_table ((p)->hash) \ 538 && elf_hash_table_id (elf_hash_table (p)) == MIPS_ELF_DATA) \ 539 ? (struct mips_elf_link_hash_table *) (p)->hash : NULL) 540 541 /* A structure used to communicate with htab_traverse callbacks. */ 542 struct mips_htab_traverse_info 543 { 544 /* The usual link-wide information. */ 545 struct bfd_link_info *info; 546 bfd *output_bfd; 547 548 /* Starts off FALSE and is set to TRUE if the link should be aborted. */ 549 bfd_boolean error; 550 }; 551 552 /* MIPS ELF private object data. */ 553 554 struct mips_elf_obj_tdata 555 { 556 /* Generic ELF private object data. */ 557 struct elf_obj_tdata root; 558 559 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */ 560 bfd *abi_fp_bfd; 561 562 /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output. */ 563 bfd *abi_msa_bfd; 564 565 /* The abiflags for this object. */ 566 Elf_Internal_ABIFlags_v0 abiflags; 567 bfd_boolean abiflags_valid; 568 569 /* The GOT requirements of input bfds. */ 570 struct mips_got_info *got; 571 572 /* Used by _bfd_mips_elf_find_nearest_line. The structure could be 573 included directly in this one, but there's no point to wasting 574 the memory just for the infrequently called find_nearest_line. */ 575 struct mips_elf_find_line *find_line_info; 576 577 /* An array of stub sections indexed by symbol number. */ 578 asection **local_stubs; 579 asection **local_call_stubs; 580 581 /* The Irix 5 support uses two virtual sections, which represent 582 text/data symbols defined in dynamic objects. */ 583 asymbol *elf_data_symbol; 584 asymbol *elf_text_symbol; 585 asection *elf_data_section; 586 asection *elf_text_section; 587 }; 588 589 /* Get MIPS ELF private object data from BFD's tdata. */ 590 591 #define mips_elf_tdata(bfd) \ 592 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any) 593 594 #define TLS_RELOC_P(r_type) \ 595 (r_type == R_MIPS_TLS_DTPMOD32 \ 596 || r_type == R_MIPS_TLS_DTPMOD64 \ 597 || r_type == R_MIPS_TLS_DTPREL32 \ 598 || r_type == R_MIPS_TLS_DTPREL64 \ 599 || r_type == R_MIPS_TLS_GD \ 600 || r_type == R_MIPS_TLS_LDM \ 601 || r_type == R_MIPS_TLS_DTPREL_HI16 \ 602 || r_type == R_MIPS_TLS_DTPREL_LO16 \ 603 || r_type == R_MIPS_TLS_GOTTPREL \ 604 || r_type == R_MIPS_TLS_TPREL32 \ 605 || r_type == R_MIPS_TLS_TPREL64 \ 606 || r_type == R_MIPS_TLS_TPREL_HI16 \ 607 || r_type == R_MIPS_TLS_TPREL_LO16 \ 608 || r_type == R_MIPS16_TLS_GD \ 609 || r_type == R_MIPS16_TLS_LDM \ 610 || r_type == R_MIPS16_TLS_DTPREL_HI16 \ 611 || r_type == R_MIPS16_TLS_DTPREL_LO16 \ 612 || r_type == R_MIPS16_TLS_GOTTPREL \ 613 || r_type == R_MIPS16_TLS_TPREL_HI16 \ 614 || r_type == R_MIPS16_TLS_TPREL_LO16 \ 615 || r_type == R_MICROMIPS_TLS_GD \ 616 || r_type == R_MICROMIPS_TLS_LDM \ 617 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \ 618 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \ 619 || r_type == R_MICROMIPS_TLS_GOTTPREL \ 620 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \ 621 || r_type == R_MICROMIPS_TLS_TPREL_LO16) 622 623 /* Structure used to pass information to mips_elf_output_extsym. */ 624 625 struct extsym_info 626 { 627 bfd *abfd; 628 struct bfd_link_info *info; 629 struct ecoff_debug_info *debug; 630 const struct ecoff_debug_swap *swap; 631 bfd_boolean failed; 632 }; 633 634 /* The names of the runtime procedure table symbols used on IRIX5. */ 635 636 static const char * const mips_elf_dynsym_rtproc_names[] = 637 { 638 "_procedure_table", 639 "_procedure_string_table", 640 "_procedure_table_size", 641 NULL 642 }; 643 644 /* These structures are used to generate the .compact_rel section on 645 IRIX5. */ 646 647 typedef struct 648 { 649 unsigned long id1; /* Always one? */ 650 unsigned long num; /* Number of compact relocation entries. */ 651 unsigned long id2; /* Always two? */ 652 unsigned long offset; /* The file offset of the first relocation. */ 653 unsigned long reserved0; /* Zero? */ 654 unsigned long reserved1; /* Zero? */ 655 } Elf32_compact_rel; 656 657 typedef struct 658 { 659 bfd_byte id1[4]; 660 bfd_byte num[4]; 661 bfd_byte id2[4]; 662 bfd_byte offset[4]; 663 bfd_byte reserved0[4]; 664 bfd_byte reserved1[4]; 665 } Elf32_External_compact_rel; 666 667 typedef struct 668 { 669 unsigned int ctype : 1; /* 1: long 0: short format. See below. */ 670 unsigned int rtype : 4; /* Relocation types. See below. */ 671 unsigned int dist2to : 8; 672 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */ 673 unsigned long konst; /* KONST field. See below. */ 674 unsigned long vaddr; /* VADDR to be relocated. */ 675 } Elf32_crinfo; 676 677 typedef struct 678 { 679 unsigned int ctype : 1; /* 1: long 0: short format. See below. */ 680 unsigned int rtype : 4; /* Relocation types. See below. */ 681 unsigned int dist2to : 8; 682 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */ 683 unsigned long konst; /* KONST field. See below. */ 684 } Elf32_crinfo2; 685 686 typedef struct 687 { 688 bfd_byte info[4]; 689 bfd_byte konst[4]; 690 bfd_byte vaddr[4]; 691 } Elf32_External_crinfo; 692 693 typedef struct 694 { 695 bfd_byte info[4]; 696 bfd_byte konst[4]; 697 } Elf32_External_crinfo2; 698 699 /* These are the constants used to swap the bitfields in a crinfo. */ 700 701 #define CRINFO_CTYPE (0x1U) 702 #define CRINFO_CTYPE_SH (31) 703 #define CRINFO_RTYPE (0xfU) 704 #define CRINFO_RTYPE_SH (27) 705 #define CRINFO_DIST2TO (0xffU) 706 #define CRINFO_DIST2TO_SH (19) 707 #define CRINFO_RELVADDR (0x7ffffU) 708 #define CRINFO_RELVADDR_SH (0) 709 710 /* A compact relocation info has long (3 words) or short (2 words) 711 formats. A short format doesn't have VADDR field and relvaddr 712 fields contains ((VADDR - vaddr of the previous entry) >> 2). */ 713 #define CRF_MIPS_LONG 1 714 #define CRF_MIPS_SHORT 0 715 716 /* There are 4 types of compact relocation at least. The value KONST 717 has different meaning for each type: 718 719 (type) (konst) 720 CT_MIPS_REL32 Address in data 721 CT_MIPS_WORD Address in word (XXX) 722 CT_MIPS_GPHI_LO GP - vaddr 723 CT_MIPS_JMPAD Address to jump 724 */ 725 726 #define CRT_MIPS_REL32 0xa 727 #define CRT_MIPS_WORD 0xb 728 #define CRT_MIPS_GPHI_LO 0xc 729 #define CRT_MIPS_JMPAD 0xd 730 731 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format)) 732 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type)) 733 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v)) 734 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2) 735 736 /* The structure of the runtime procedure descriptor created by the 737 loader for use by the static exception system. */ 738 739 typedef struct runtime_pdr { 740 bfd_vma adr; /* Memory address of start of procedure. */ 741 long regmask; /* Save register mask. */ 742 long regoffset; /* Save register offset. */ 743 long fregmask; /* Save floating point register mask. */ 744 long fregoffset; /* Save floating point register offset. */ 745 long frameoffset; /* Frame size. */ 746 short framereg; /* Frame pointer register. */ 747 short pcreg; /* Offset or reg of return pc. */ 748 long irpss; /* Index into the runtime string table. */ 749 long reserved; 750 struct exception_info *exception_info;/* Pointer to exception array. */ 751 } RPDR, *pRPDR; 752 #define cbRPDR sizeof (RPDR) 753 #define rpdNil ((pRPDR) 0) 754 755 static struct mips_got_entry *mips_elf_create_local_got_entry 756 (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long, 757 struct mips_elf_link_hash_entry *, int); 758 static bfd_boolean mips_elf_sort_hash_table_f 759 (struct mips_elf_link_hash_entry *, void *); 760 static bfd_vma mips_elf_high 761 (bfd_vma); 762 static bfd_boolean mips_elf_create_dynamic_relocation 763 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *, 764 struct mips_elf_link_hash_entry *, asection *, bfd_vma, 765 bfd_vma *, asection *); 766 static bfd_vma mips_elf_adjust_gp 767 (bfd *, struct mips_got_info *, bfd *); 768 769 /* This will be used when we sort the dynamic relocation records. */ 770 static bfd *reldyn_sorting_bfd; 771 772 /* True if ABFD is for CPUs with load interlocking that include 773 non-MIPS1 CPUs and R3900. */ 774 #define LOAD_INTERLOCKS_P(abfd) \ 775 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \ 776 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900)) 777 778 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL. 779 This should be safe for all architectures. We enable this predicate 780 for RM9000 for now. */ 781 #define JAL_TO_BAL_P(abfd) \ 782 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000) 783 784 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL. 785 This should be safe for all architectures. We enable this predicate for 786 all CPUs. */ 787 #define JALR_TO_BAL_P(abfd) 1 788 789 /* True if ABFD is for CPUs that are faster if JR is converted to B. 790 This should be safe for all architectures. We enable this predicate for 791 all CPUs. */ 792 #define JR_TO_B_P(abfd) 1 793 794 /* True if ABFD is a PIC object. */ 795 #define PIC_OBJECT_P(abfd) \ 796 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0) 797 798 /* Nonzero if ABFD is using the O32 ABI. */ 799 #define ABI_O32_P(abfd) \ 800 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32) 801 802 /* Nonzero if ABFD is using the N32 ABI. */ 803 #define ABI_N32_P(abfd) \ 804 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0) 805 806 /* Nonzero if ABFD is using the N64 ABI. */ 807 #define ABI_64_P(abfd) \ 808 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64) 809 810 /* Nonzero if ABFD is using NewABI conventions. */ 811 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd)) 812 813 /* Nonzero if ABFD has microMIPS code. */ 814 #define MICROMIPS_P(abfd) \ 815 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0) 816 817 /* Nonzero if ABFD is MIPS R6. */ 818 #define MIPSR6_P(abfd) \ 819 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \ 820 || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6) 821 822 /* The IRIX compatibility level we are striving for. */ 823 #define IRIX_COMPAT(abfd) \ 824 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd)) 825 826 /* Whether we are trying to be compatible with IRIX at all. */ 827 #define SGI_COMPAT(abfd) \ 828 (IRIX_COMPAT (abfd) != ict_none) 829 830 /* The name of the options section. */ 831 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \ 832 (NEWABI_P (abfd) ? ".MIPS.options" : ".options") 833 834 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section. 835 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */ 836 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \ 837 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0) 838 839 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section. */ 840 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \ 841 (strcmp (NAME, ".MIPS.abiflags") == 0) 842 843 /* Whether the section is readonly. */ 844 #define MIPS_ELF_READONLY_SECTION(sec) \ 845 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \ 846 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) 847 848 /* The name of the stub section. */ 849 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs" 850 851 /* The size of an external REL relocation. */ 852 #define MIPS_ELF_REL_SIZE(abfd) \ 853 (get_elf_backend_data (abfd)->s->sizeof_rel) 854 855 /* The size of an external RELA relocation. */ 856 #define MIPS_ELF_RELA_SIZE(abfd) \ 857 (get_elf_backend_data (abfd)->s->sizeof_rela) 858 859 /* The size of an external dynamic table entry. */ 860 #define MIPS_ELF_DYN_SIZE(abfd) \ 861 (get_elf_backend_data (abfd)->s->sizeof_dyn) 862 863 /* The size of a GOT entry. */ 864 #define MIPS_ELF_GOT_SIZE(abfd) \ 865 (get_elf_backend_data (abfd)->s->arch_size / 8) 866 867 /* The size of the .rld_map section. */ 868 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \ 869 (get_elf_backend_data (abfd)->s->arch_size / 8) 870 871 /* The size of a symbol-table entry. */ 872 #define MIPS_ELF_SYM_SIZE(abfd) \ 873 (get_elf_backend_data (abfd)->s->sizeof_sym) 874 875 /* The default alignment for sections, as a power of two. */ 876 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \ 877 (get_elf_backend_data (abfd)->s->log_file_align) 878 879 /* Get word-sized data. */ 880 #define MIPS_ELF_GET_WORD(abfd, ptr) \ 881 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr)) 882 883 /* Put out word-sized data. */ 884 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \ 885 (ABI_64_P (abfd) \ 886 ? bfd_put_64 (abfd, val, ptr) \ 887 : bfd_put_32 (abfd, val, ptr)) 888 889 /* The opcode for word-sized loads (LW or LD). */ 890 #define MIPS_ELF_LOAD_WORD(abfd) \ 891 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000) 892 893 /* Add a dynamic symbol table-entry. */ 894 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \ 895 _bfd_elf_add_dynamic_entry (info, tag, val) 896 897 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \ 898 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (abfd, rtype, rela)) 899 900 /* The name of the dynamic relocation section. */ 901 #define MIPS_ELF_REL_DYN_NAME(INFO) \ 902 (mips_elf_hash_table (INFO)->root.target_os == is_vxworks \ 903 ? ".rela.dyn" : ".rel.dyn") 904 905 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value 906 from smaller values. Start with zero, widen, *then* decrement. */ 907 #define MINUS_ONE (((bfd_vma)0) - 1) 908 #define MINUS_TWO (((bfd_vma)0) - 2) 909 910 /* The value to write into got[1] for SVR4 targets, to identify it is 911 a GNU object. The dynamic linker can then use got[1] to store the 912 module pointer. */ 913 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \ 914 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31)) 915 916 /* The offset of $gp from the beginning of the .got section. */ 917 #define ELF_MIPS_GP_OFFSET(INFO) \ 918 (mips_elf_hash_table (INFO)->root.target_os == is_vxworks \ 919 ? 0x0 : 0x7ff0) 920 921 /* The maximum size of the GOT for it to be addressable using 16-bit 922 offsets from $gp. */ 923 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff) 924 925 /* Instructions which appear in a stub. */ 926 #define STUB_LW(abfd) \ 927 ((ABI_64_P (abfd) \ 928 ? 0xdf998010 /* ld t9,0x8010(gp) */ \ 929 : 0x8f998010)) /* lw t9,0x8010(gp) */ 930 #define STUB_MOVE 0x03e07825 /* or t7,ra,zero */ 931 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */ 932 #define STUB_JALR 0x0320f809 /* jalr ra,t9 */ 933 #define STUB_JALRC 0xf8190000 /* jalrc ra,t9 */ 934 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */ 935 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */ 936 #define STUB_LI16S(abfd, VAL) \ 937 ((ABI_64_P (abfd) \ 938 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \ 939 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */ 940 941 /* Likewise for the microMIPS ASE. */ 942 #define STUB_LW_MICROMIPS(abfd) \ 943 (ABI_64_P (abfd) \ 944 ? 0xdf3c8010 /* ld t9,0x8010(gp) */ \ 945 : 0xff3c8010) /* lw t9,0x8010(gp) */ 946 #define STUB_MOVE_MICROMIPS 0x0dff /* move t7,ra */ 947 #define STUB_MOVE32_MICROMIPS 0x001f7a90 /* or t7,ra,zero */ 948 #define STUB_LUI_MICROMIPS(VAL) \ 949 (0x41b80000 + (VAL)) /* lui t8,VAL */ 950 #define STUB_JALR_MICROMIPS 0x45d9 /* jalr t9 */ 951 #define STUB_JALR32_MICROMIPS 0x03f90f3c /* jalr ra,t9 */ 952 #define STUB_ORI_MICROMIPS(VAL) \ 953 (0x53180000 + (VAL)) /* ori t8,t8,VAL */ 954 #define STUB_LI16U_MICROMIPS(VAL) \ 955 (0x53000000 + (VAL)) /* ori t8,zero,VAL unsigned */ 956 #define STUB_LI16S_MICROMIPS(abfd, VAL) \ 957 (ABI_64_P (abfd) \ 958 ? 0x5f000000 + (VAL) /* daddiu t8,zero,VAL sign extended */ \ 959 : 0x33000000 + (VAL)) /* addiu t8,zero,VAL sign extended */ 960 961 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16 962 #define MIPS_FUNCTION_STUB_BIG_SIZE 20 963 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12 964 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16 965 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16 966 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20 967 968 /* The name of the dynamic interpreter. This is put in the .interp 969 section. */ 970 971 #define ELF_DYNAMIC_INTERPRETER(abfd) \ 972 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \ 973 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \ 974 : "/usr/lib/libc.so.1") 975 976 #ifdef BFD64 977 #define MNAME(bfd,pre,pos) \ 978 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos)) 979 #define ELF_R_SYM(bfd, i) \ 980 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i)) 981 #define ELF_R_TYPE(bfd, i) \ 982 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i)) 983 #define ELF_R_INFO(bfd, s, t) \ 984 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t)) 985 #else 986 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos) 987 #define ELF_R_SYM(bfd, i) \ 988 (ELF32_R_SYM (i)) 989 #define ELF_R_TYPE(bfd, i) \ 990 (ELF32_R_TYPE (i)) 991 #define ELF_R_INFO(bfd, s, t) \ 992 (ELF32_R_INFO (s, t)) 993 #endif 994 995 /* The mips16 compiler uses a couple of special sections to handle 996 floating point arguments. 997 998 Section names that look like .mips16.fn.FNNAME contain stubs that 999 copy floating point arguments from the fp regs to the gp regs and 1000 then jump to FNNAME. If any 32 bit function calls FNNAME, the 1001 call should be redirected to the stub instead. If no 32 bit 1002 function calls FNNAME, the stub should be discarded. We need to 1003 consider any reference to the function, not just a call, because 1004 if the address of the function is taken we will need the stub, 1005 since the address might be passed to a 32 bit function. 1006 1007 Section names that look like .mips16.call.FNNAME contain stubs 1008 that copy floating point arguments from the gp regs to the fp 1009 regs and then jump to FNNAME. If FNNAME is a 32 bit function, 1010 then any 16 bit function that calls FNNAME should be redirected 1011 to the stub instead. If FNNAME is not a 32 bit function, the 1012 stub should be discarded. 1013 1014 .mips16.call.fp.FNNAME sections are similar, but contain stubs 1015 which call FNNAME and then copy the return value from the fp regs 1016 to the gp regs. These stubs store the return value in $18 while 1017 calling FNNAME; any function which might call one of these stubs 1018 must arrange to save $18 around the call. (This case is not 1019 needed for 32 bit functions that call 16 bit functions, because 1020 16 bit functions always return floating point values in both 1021 $f0/$f1 and $2/$3.) 1022 1023 Note that in all cases FNNAME might be defined statically. 1024 Therefore, FNNAME is not used literally. Instead, the relocation 1025 information will indicate which symbol the section is for. 1026 1027 We record any stubs that we find in the symbol table. */ 1028 1029 #define FN_STUB ".mips16.fn." 1030 #define CALL_STUB ".mips16.call." 1031 #define CALL_FP_STUB ".mips16.call.fp." 1032 1033 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB) 1034 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB) 1035 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB) 1036 1037 /* The format of the first PLT entry in an O32 executable. */ 1038 static const bfd_vma mips_o32_exec_plt0_entry[] = 1039 { 1040 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */ 1041 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */ 1042 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */ 1043 0x031cc023, /* subu $24, $24, $28 */ 1044 0x03e07825, /* or t7, ra, zero */ 1045 0x0018c082, /* srl $24, $24, 2 */ 1046 0x0320f809, /* jalr $25 */ 1047 0x2718fffe /* subu $24, $24, 2 */ 1048 }; 1049 1050 /* The format of the first PLT entry in an O32 executable using compact 1051 jumps. */ 1052 static const bfd_vma mipsr6_o32_exec_plt0_entry_compact[] = 1053 { 1054 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */ 1055 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */ 1056 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */ 1057 0x031cc023, /* subu $24, $24, $28 */ 1058 0x03e07821, /* move $15, $31 # 32-bit move (addu) */ 1059 0x0018c082, /* srl $24, $24, 2 */ 1060 0x2718fffe, /* subu $24, $24, 2 */ 1061 0xf8190000 /* jalrc $25 */ 1062 }; 1063 1064 /* The format of the first PLT entry in an N32 executable. Different 1065 because gp ($28) is not available; we use t2 ($14) instead. */ 1066 static const bfd_vma mips_n32_exec_plt0_entry[] = 1067 { 1068 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */ 1069 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */ 1070 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */ 1071 0x030ec023, /* subu $24, $24, $14 */ 1072 0x03e07825, /* or t7, ra, zero */ 1073 0x0018c082, /* srl $24, $24, 2 */ 1074 0x0320f809, /* jalr $25 */ 1075 0x2718fffe /* subu $24, $24, 2 */ 1076 }; 1077 1078 /* The format of the first PLT entry in an N32 executable using compact 1079 jumps. Different because gp ($28) is not available; we use t2 ($14) 1080 instead. */ 1081 static const bfd_vma mipsr6_n32_exec_plt0_entry_compact[] = 1082 { 1083 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */ 1084 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */ 1085 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */ 1086 0x030ec023, /* subu $24, $24, $14 */ 1087 0x03e07821, /* move $15, $31 # 32-bit move (addu) */ 1088 0x0018c082, /* srl $24, $24, 2 */ 1089 0x2718fffe, /* subu $24, $24, 2 */ 1090 0xf8190000 /* jalrc $25 */ 1091 }; 1092 1093 /* The format of the first PLT entry in an N64 executable. Different 1094 from N32 because of the increased size of GOT entries. */ 1095 static const bfd_vma mips_n64_exec_plt0_entry[] = 1096 { 1097 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */ 1098 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */ 1099 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */ 1100 0x030ec023, /* subu $24, $24, $14 */ 1101 0x03e07825, /* or t7, ra, zero */ 1102 0x0018c0c2, /* srl $24, $24, 3 */ 1103 0x0320f809, /* jalr $25 */ 1104 0x2718fffe /* subu $24, $24, 2 */ 1105 }; 1106 1107 /* The format of the first PLT entry in an N64 executable using compact 1108 jumps. Different from N32 because of the increased size of GOT 1109 entries. */ 1110 static const bfd_vma mipsr6_n64_exec_plt0_entry_compact[] = 1111 { 1112 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */ 1113 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */ 1114 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */ 1115 0x030ec023, /* subu $24, $24, $14 */ 1116 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */ 1117 0x0018c0c2, /* srl $24, $24, 3 */ 1118 0x2718fffe, /* subu $24, $24, 2 */ 1119 0xf8190000 /* jalrc $25 */ 1120 }; 1121 1122 1123 /* The format of the microMIPS first PLT entry in an O32 executable. 1124 We rely on v0 ($2) rather than t8 ($24) to contain the address 1125 of the GOTPLT entry handled, so this stub may only be used when 1126 all the subsequent PLT entries are microMIPS code too. 1127 1128 The trailing NOP is for alignment and correct disassembly only. */ 1129 static const bfd_vma micromips_o32_exec_plt0_entry[] = 1130 { 1131 0x7980, 0x0000, /* addiupc $3, (&GOTPLT[0]) - . */ 1132 0xff23, 0x0000, /* lw $25, 0($3) */ 1133 0x0535, /* subu $2, $2, $3 */ 1134 0x2525, /* srl $2, $2, 2 */ 1135 0x3302, 0xfffe, /* subu $24, $2, 2 */ 1136 0x0dff, /* move $15, $31 */ 1137 0x45f9, /* jalrs $25 */ 1138 0x0f83, /* move $28, $3 */ 1139 0x0c00 /* nop */ 1140 }; 1141 1142 /* The format of the microMIPS first PLT entry in an O32 executable 1143 in the insn32 mode. */ 1144 static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] = 1145 { 1146 0x41bc, 0x0000, /* lui $28, %hi(&GOTPLT[0]) */ 1147 0xff3c, 0x0000, /* lw $25, %lo(&GOTPLT[0])($28) */ 1148 0x339c, 0x0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */ 1149 0x0398, 0xc1d0, /* subu $24, $24, $28 */ 1150 0x001f, 0x7a90, /* or $15, $31, zero */ 1151 0x0318, 0x1040, /* srl $24, $24, 2 */ 1152 0x03f9, 0x0f3c, /* jalr $25 */ 1153 0x3318, 0xfffe /* subu $24, $24, 2 */ 1154 }; 1155 1156 /* The format of subsequent standard PLT entries. */ 1157 static const bfd_vma mips_exec_plt_entry[] = 1158 { 1159 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */ 1160 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */ 1161 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */ 1162 0x03200008 /* jr $25 */ 1163 }; 1164 1165 static const bfd_vma mipsr6_exec_plt_entry[] = 1166 { 1167 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */ 1168 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */ 1169 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */ 1170 0x03200009 /* jr $25 */ 1171 }; 1172 1173 static const bfd_vma mipsr6_exec_plt_entry_compact[] = 1174 { 1175 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */ 1176 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */ 1177 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */ 1178 0xd8190000 /* jic $25, 0 */ 1179 }; 1180 1181 /* The format of subsequent MIPS16 o32 PLT entries. We use v0 ($2) 1182 and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not 1183 directly addressable. */ 1184 static const bfd_vma mips16_o32_exec_plt_entry[] = 1185 { 1186 0xb203, /* lw $2, 12($pc) */ 1187 0x9a60, /* lw $3, 0($2) */ 1188 0x651a, /* move $24, $2 */ 1189 0xeb00, /* jr $3 */ 1190 0x653b, /* move $25, $3 */ 1191 0x6500, /* nop */ 1192 0x0000, 0x0000 /* .word (.got.plt entry) */ 1193 }; 1194 1195 /* The format of subsequent microMIPS o32 PLT entries. We use v0 ($2) 1196 as a temporary because t8 ($24) is not addressable with ADDIUPC. */ 1197 static const bfd_vma micromips_o32_exec_plt_entry[] = 1198 { 1199 0x7900, 0x0000, /* addiupc $2, (.got.plt entry) - . */ 1200 0xff22, 0x0000, /* lw $25, 0($2) */ 1201 0x4599, /* jr $25 */ 1202 0x0f02 /* move $24, $2 */ 1203 }; 1204 1205 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode. */ 1206 static const bfd_vma micromips_insn32_o32_exec_plt_entry[] = 1207 { 1208 0x41af, 0x0000, /* lui $15, %hi(.got.plt entry) */ 1209 0xff2f, 0x0000, /* lw $25, %lo(.got.plt entry)($15) */ 1210 0x0019, 0x0f3c, /* jr $25 */ 1211 0x330f, 0x0000 /* addiu $24, $15, %lo(.got.plt entry) */ 1212 }; 1213 1214 /* The format of the first PLT entry in a VxWorks executable. */ 1215 static const bfd_vma mips_vxworks_exec_plt0_entry[] = 1216 { 1217 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */ 1218 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */ 1219 0x8f390008, /* lw t9, 8(t9) */ 1220 0x00000000, /* nop */ 1221 0x03200008, /* jr t9 */ 1222 0x00000000 /* nop */ 1223 }; 1224 1225 /* The format of subsequent PLT entries. */ 1226 static const bfd_vma mips_vxworks_exec_plt_entry[] = 1227 { 1228 0x10000000, /* b .PLT_resolver */ 1229 0x24180000, /* li t8, <pltindex> */ 1230 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */ 1231 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */ 1232 0x8f390000, /* lw t9, 0(t9) */ 1233 0x00000000, /* nop */ 1234 0x03200008, /* jr t9 */ 1235 0x00000000 /* nop */ 1236 }; 1237 1238 /* The format of the first PLT entry in a VxWorks shared object. */ 1239 static const bfd_vma mips_vxworks_shared_plt0_entry[] = 1240 { 1241 0x8f990008, /* lw t9, 8(gp) */ 1242 0x00000000, /* nop */ 1243 0x03200008, /* jr t9 */ 1244 0x00000000, /* nop */ 1245 0x00000000, /* nop */ 1246 0x00000000 /* nop */ 1247 }; 1248 1249 /* The format of subsequent PLT entries. */ 1250 static const bfd_vma mips_vxworks_shared_plt_entry[] = 1251 { 1252 0x10000000, /* b .PLT_resolver */ 1253 0x24180000 /* li t8, <pltindex> */ 1254 }; 1255 1256 /* microMIPS 32-bit opcode helper installer. */ 1257 1258 static void 1259 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr) 1260 { 1261 bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr); 1262 bfd_put_16 (abfd, opcode & 0xffff, ptr + 2); 1263 } 1264 1265 /* microMIPS 32-bit opcode helper retriever. */ 1266 1267 static bfd_vma 1268 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr) 1269 { 1270 return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2); 1271 } 1272 1273 /* Look up an entry in a MIPS ELF linker hash table. */ 1274 1275 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \ 1276 ((struct mips_elf_link_hash_entry *) \ 1277 elf_link_hash_lookup (&(table)->root, (string), (create), \ 1278 (copy), (follow))) 1279 1280 /* Traverse a MIPS ELF linker hash table. */ 1281 1282 #define mips_elf_link_hash_traverse(table, func, info) \ 1283 (elf_link_hash_traverse \ 1284 (&(table)->root, \ 1285 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 1286 (info))) 1287 1288 /* Find the base offsets for thread-local storage in this object, 1289 for GD/LD and IE/LE respectively. */ 1290 1291 #define TP_OFFSET 0x7000 1292 #define DTP_OFFSET 0x8000 1293 1294 static bfd_vma 1295 dtprel_base (struct bfd_link_info *info) 1296 { 1297 /* If tls_sec is NULL, we should have signalled an error already. */ 1298 if (elf_hash_table (info)->tls_sec == NULL) 1299 return 0; 1300 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET; 1301 } 1302 1303 static bfd_vma 1304 tprel_base (struct bfd_link_info *info) 1305 { 1306 /* If tls_sec is NULL, we should have signalled an error already. */ 1307 if (elf_hash_table (info)->tls_sec == NULL) 1308 return 0; 1309 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET; 1310 } 1311 1312 /* Create an entry in a MIPS ELF linker hash table. */ 1313 1314 static struct bfd_hash_entry * 1315 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 1316 struct bfd_hash_table *table, const char *string) 1317 { 1318 struct mips_elf_link_hash_entry *ret = 1319 (struct mips_elf_link_hash_entry *) entry; 1320 1321 /* Allocate the structure if it has not already been allocated by a 1322 subclass. */ 1323 if (ret == NULL) 1324 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry)); 1325 if (ret == NULL) 1326 return (struct bfd_hash_entry *) ret; 1327 1328 /* Call the allocation method of the superclass. */ 1329 ret = ((struct mips_elf_link_hash_entry *) 1330 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 1331 table, string)); 1332 if (ret != NULL) 1333 { 1334 /* Set local fields. */ 1335 memset (&ret->esym, 0, sizeof (EXTR)); 1336 /* We use -2 as a marker to indicate that the information has 1337 not been set. -1 means there is no associated ifd. */ 1338 ret->esym.ifd = -2; 1339 ret->la25_stub = 0; 1340 ret->possibly_dynamic_relocs = 0; 1341 ret->fn_stub = NULL; 1342 ret->call_stub = NULL; 1343 ret->call_fp_stub = NULL; 1344 ret->mipsxhash_loc = 0; 1345 ret->global_got_area = GGA_NONE; 1346 ret->got_only_for_calls = TRUE; 1347 ret->readonly_reloc = FALSE; 1348 ret->has_static_relocs = FALSE; 1349 ret->no_fn_stub = FALSE; 1350 ret->need_fn_stub = FALSE; 1351 ret->has_nonpic_branches = FALSE; 1352 ret->needs_lazy_stub = FALSE; 1353 ret->use_plt_entry = FALSE; 1354 } 1355 1356 return (struct bfd_hash_entry *) ret; 1357 } 1358 1359 /* Allocate MIPS ELF private object data. */ 1360 1361 bfd_boolean 1362 _bfd_mips_elf_mkobject (bfd *abfd) 1363 { 1364 return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata), 1365 MIPS_ELF_DATA); 1366 } 1367 1368 bfd_boolean 1369 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec) 1370 { 1371 if (!sec->used_by_bfd) 1372 { 1373 struct _mips_elf_section_data *sdata; 1374 size_t amt = sizeof (*sdata); 1375 1376 sdata = bfd_zalloc (abfd, amt); 1377 if (sdata == NULL) 1378 return FALSE; 1379 sec->used_by_bfd = sdata; 1380 } 1381 1382 return _bfd_elf_new_section_hook (abfd, sec); 1383 } 1384 1385 /* Read ECOFF debugging information from a .mdebug section into a 1386 ecoff_debug_info structure. */ 1387 1388 bfd_boolean 1389 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section, 1390 struct ecoff_debug_info *debug) 1391 { 1392 HDRR *symhdr; 1393 const struct ecoff_debug_swap *swap; 1394 char *ext_hdr; 1395 1396 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 1397 memset (debug, 0, sizeof (*debug)); 1398 1399 ext_hdr = bfd_malloc (swap->external_hdr_size); 1400 if (ext_hdr == NULL && swap->external_hdr_size != 0) 1401 goto error_return; 1402 1403 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0, 1404 swap->external_hdr_size)) 1405 goto error_return; 1406 1407 symhdr = &debug->symbolic_header; 1408 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr); 1409 1410 /* The symbolic header contains absolute file offsets and sizes to 1411 read. */ 1412 #define READ(ptr, offset, count, size, type) \ 1413 do \ 1414 { \ 1415 size_t amt; \ 1416 debug->ptr = NULL; \ 1417 if (symhdr->count == 0) \ 1418 break; \ 1419 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \ 1420 { \ 1421 bfd_set_error (bfd_error_file_too_big); \ 1422 goto error_return; \ 1423 } \ 1424 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0) \ 1425 goto error_return; \ 1426 debug->ptr = (type) _bfd_malloc_and_read (abfd, amt, amt); \ 1427 if (debug->ptr == NULL) \ 1428 goto error_return; \ 1429 } while (0) 1430 1431 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *); 1432 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); 1433 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); 1434 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); 1435 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); 1436 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), 1437 union aux_ext *); 1438 READ (ss, cbSsOffset, issMax, sizeof (char), char *); 1439 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *); 1440 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); 1441 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); 1442 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *); 1443 #undef READ 1444 1445 debug->fdr = NULL; 1446 1447 return TRUE; 1448 1449 error_return: 1450 free (ext_hdr); 1451 free (debug->line); 1452 free (debug->external_dnr); 1453 free (debug->external_pdr); 1454 free (debug->external_sym); 1455 free (debug->external_opt); 1456 free (debug->external_aux); 1457 free (debug->ss); 1458 free (debug->ssext); 1459 free (debug->external_fdr); 1460 free (debug->external_rfd); 1461 free (debug->external_ext); 1462 return FALSE; 1463 } 1464 1465 /* Swap RPDR (runtime procedure table entry) for output. */ 1466 1467 static void 1468 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex) 1469 { 1470 H_PUT_S32 (abfd, in->adr, ex->p_adr); 1471 H_PUT_32 (abfd, in->regmask, ex->p_regmask); 1472 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset); 1473 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask); 1474 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset); 1475 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset); 1476 1477 H_PUT_16 (abfd, in->framereg, ex->p_framereg); 1478 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg); 1479 1480 H_PUT_32 (abfd, in->irpss, ex->p_irpss); 1481 } 1482 1483 /* Create a runtime procedure table from the .mdebug section. */ 1484 1485 static bfd_boolean 1486 mips_elf_create_procedure_table (void *handle, bfd *abfd, 1487 struct bfd_link_info *info, asection *s, 1488 struct ecoff_debug_info *debug) 1489 { 1490 const struct ecoff_debug_swap *swap; 1491 HDRR *hdr = &debug->symbolic_header; 1492 RPDR *rpdr, *rp; 1493 struct rpdr_ext *erp; 1494 void *rtproc; 1495 struct pdr_ext *epdr; 1496 struct sym_ext *esym; 1497 char *ss, **sv; 1498 char *str; 1499 bfd_size_type size; 1500 bfd_size_type count; 1501 unsigned long sindex; 1502 unsigned long i; 1503 PDR pdr; 1504 SYMR sym; 1505 const char *no_name_func = _("static procedure (no name)"); 1506 1507 epdr = NULL; 1508 rpdr = NULL; 1509 esym = NULL; 1510 ss = NULL; 1511 sv = NULL; 1512 1513 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 1514 1515 sindex = strlen (no_name_func) + 1; 1516 count = hdr->ipdMax; 1517 if (count > 0) 1518 { 1519 size = swap->external_pdr_size; 1520 1521 epdr = bfd_malloc (size * count); 1522 if (epdr == NULL) 1523 goto error_return; 1524 1525 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr)) 1526 goto error_return; 1527 1528 size = sizeof (RPDR); 1529 rp = rpdr = bfd_malloc (size * count); 1530 if (rpdr == NULL) 1531 goto error_return; 1532 1533 size = sizeof (char *); 1534 sv = bfd_malloc (size * count); 1535 if (sv == NULL) 1536 goto error_return; 1537 1538 count = hdr->isymMax; 1539 size = swap->external_sym_size; 1540 esym = bfd_malloc (size * count); 1541 if (esym == NULL) 1542 goto error_return; 1543 1544 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym)) 1545 goto error_return; 1546 1547 count = hdr->issMax; 1548 ss = bfd_malloc (count); 1549 if (ss == NULL) 1550 goto error_return; 1551 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss)) 1552 goto error_return; 1553 1554 count = hdr->ipdMax; 1555 for (i = 0; i < (unsigned long) count; i++, rp++) 1556 { 1557 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr); 1558 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym); 1559 rp->adr = sym.value; 1560 rp->regmask = pdr.regmask; 1561 rp->regoffset = pdr.regoffset; 1562 rp->fregmask = pdr.fregmask; 1563 rp->fregoffset = pdr.fregoffset; 1564 rp->frameoffset = pdr.frameoffset; 1565 rp->framereg = pdr.framereg; 1566 rp->pcreg = pdr.pcreg; 1567 rp->irpss = sindex; 1568 sv[i] = ss + sym.iss; 1569 sindex += strlen (sv[i]) + 1; 1570 } 1571 } 1572 1573 size = sizeof (struct rpdr_ext) * (count + 2) + sindex; 1574 size = BFD_ALIGN (size, 16); 1575 rtproc = bfd_alloc (abfd, size); 1576 if (rtproc == NULL) 1577 { 1578 mips_elf_hash_table (info)->procedure_count = 0; 1579 goto error_return; 1580 } 1581 1582 mips_elf_hash_table (info)->procedure_count = count + 2; 1583 1584 erp = rtproc; 1585 memset (erp, 0, sizeof (struct rpdr_ext)); 1586 erp++; 1587 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2); 1588 strcpy (str, no_name_func); 1589 str += strlen (no_name_func) + 1; 1590 for (i = 0; i < count; i++) 1591 { 1592 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i); 1593 strcpy (str, sv[i]); 1594 str += strlen (sv[i]) + 1; 1595 } 1596 H_PUT_S32 (abfd, -1, (erp + count)->p_adr); 1597 1598 /* Set the size and contents of .rtproc section. */ 1599 s->size = size; 1600 s->contents = rtproc; 1601 1602 /* Skip this section later on (I don't think this currently 1603 matters, but someday it might). */ 1604 s->map_head.link_order = NULL; 1605 1606 free (epdr); 1607 free (rpdr); 1608 free (esym); 1609 free (ss); 1610 free (sv); 1611 return TRUE; 1612 1613 error_return: 1614 free (epdr); 1615 free (rpdr); 1616 free (esym); 1617 free (ss); 1618 free (sv); 1619 return FALSE; 1620 } 1621 1622 /* We're going to create a stub for H. Create a symbol for the stub's 1623 value and size, to help make the disassembly easier to read. */ 1624 1625 static bfd_boolean 1626 mips_elf_create_stub_symbol (struct bfd_link_info *info, 1627 struct mips_elf_link_hash_entry *h, 1628 const char *prefix, asection *s, bfd_vma value, 1629 bfd_vma size) 1630 { 1631 bfd_boolean micromips_p = ELF_ST_IS_MICROMIPS (h->root.other); 1632 struct bfd_link_hash_entry *bh; 1633 struct elf_link_hash_entry *elfh; 1634 char *name; 1635 bfd_boolean res; 1636 1637 if (micromips_p) 1638 value |= 1; 1639 1640 /* Create a new symbol. */ 1641 name = concat (prefix, h->root.root.root.string, NULL); 1642 bh = NULL; 1643 res = _bfd_generic_link_add_one_symbol (info, s->owner, name, 1644 BSF_LOCAL, s, value, NULL, 1645 TRUE, FALSE, &bh); 1646 free (name); 1647 if (! res) 1648 return FALSE; 1649 1650 /* Make it a local function. */ 1651 elfh = (struct elf_link_hash_entry *) bh; 1652 elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC); 1653 elfh->size = size; 1654 elfh->forced_local = 1; 1655 if (micromips_p) 1656 elfh->other = ELF_ST_SET_MICROMIPS (elfh->other); 1657 return TRUE; 1658 } 1659 1660 /* We're about to redefine H. Create a symbol to represent H's 1661 current value and size, to help make the disassembly easier 1662 to read. */ 1663 1664 static bfd_boolean 1665 mips_elf_create_shadow_symbol (struct bfd_link_info *info, 1666 struct mips_elf_link_hash_entry *h, 1667 const char *prefix) 1668 { 1669 struct bfd_link_hash_entry *bh; 1670 struct elf_link_hash_entry *elfh; 1671 char *name; 1672 asection *s; 1673 bfd_vma value; 1674 bfd_boolean res; 1675 1676 /* Read the symbol's value. */ 1677 BFD_ASSERT (h->root.root.type == bfd_link_hash_defined 1678 || h->root.root.type == bfd_link_hash_defweak); 1679 s = h->root.root.u.def.section; 1680 value = h->root.root.u.def.value; 1681 1682 /* Create a new symbol. */ 1683 name = concat (prefix, h->root.root.root.string, NULL); 1684 bh = NULL; 1685 res = _bfd_generic_link_add_one_symbol (info, s->owner, name, 1686 BSF_LOCAL, s, value, NULL, 1687 TRUE, FALSE, &bh); 1688 free (name); 1689 if (! res) 1690 return FALSE; 1691 1692 /* Make it local and copy the other attributes from H. */ 1693 elfh = (struct elf_link_hash_entry *) bh; 1694 elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type)); 1695 elfh->other = h->root.other; 1696 elfh->size = h->root.size; 1697 elfh->forced_local = 1; 1698 return TRUE; 1699 } 1700 1701 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16 1702 function rather than to a hard-float stub. */ 1703 1704 static bfd_boolean 1705 section_allows_mips16_refs_p (asection *section) 1706 { 1707 const char *name; 1708 1709 name = bfd_section_name (section); 1710 return (FN_STUB_P (name) 1711 || CALL_STUB_P (name) 1712 || CALL_FP_STUB_P (name) 1713 || strcmp (name, ".pdr") == 0); 1714 } 1715 1716 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16 1717 stub section of some kind. Return the R_SYMNDX of the target 1718 function, or 0 if we can't decide which function that is. */ 1719 1720 static unsigned long 1721 mips16_stub_symndx (const struct elf_backend_data *bed, 1722 asection *sec ATTRIBUTE_UNUSED, 1723 const Elf_Internal_Rela *relocs, 1724 const Elf_Internal_Rela *relend) 1725 { 1726 int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel; 1727 const Elf_Internal_Rela *rel; 1728 1729 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent 1730 one in a compound relocation. */ 1731 for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel) 1732 if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE) 1733 return ELF_R_SYM (sec->owner, rel->r_info); 1734 1735 /* Otherwise trust the first relocation, whatever its kind. This is 1736 the traditional behavior. */ 1737 if (relocs < relend) 1738 return ELF_R_SYM (sec->owner, relocs->r_info); 1739 1740 return 0; 1741 } 1742 1743 /* Check the mips16 stubs for a particular symbol, and see if we can 1744 discard them. */ 1745 1746 static void 1747 mips_elf_check_mips16_stubs (struct bfd_link_info *info, 1748 struct mips_elf_link_hash_entry *h) 1749 { 1750 /* Dynamic symbols must use the standard call interface, in case other 1751 objects try to call them. */ 1752 if (h->fn_stub != NULL 1753 && h->root.dynindx != -1) 1754 { 1755 mips_elf_create_shadow_symbol (info, h, ".mips16."); 1756 h->need_fn_stub = TRUE; 1757 } 1758 1759 if (h->fn_stub != NULL 1760 && ! h->need_fn_stub) 1761 { 1762 /* We don't need the fn_stub; the only references to this symbol 1763 are 16 bit calls. Clobber the size to 0 to prevent it from 1764 being included in the link. */ 1765 h->fn_stub->size = 0; 1766 h->fn_stub->flags &= ~SEC_RELOC; 1767 h->fn_stub->reloc_count = 0; 1768 h->fn_stub->flags |= SEC_EXCLUDE; 1769 h->fn_stub->output_section = bfd_abs_section_ptr; 1770 } 1771 1772 if (h->call_stub != NULL 1773 && ELF_ST_IS_MIPS16 (h->root.other)) 1774 { 1775 /* We don't need the call_stub; this is a 16 bit function, so 1776 calls from other 16 bit functions are OK. Clobber the size 1777 to 0 to prevent it from being included in the link. */ 1778 h->call_stub->size = 0; 1779 h->call_stub->flags &= ~SEC_RELOC; 1780 h->call_stub->reloc_count = 0; 1781 h->call_stub->flags |= SEC_EXCLUDE; 1782 h->call_stub->output_section = bfd_abs_section_ptr; 1783 } 1784 1785 if (h->call_fp_stub != NULL 1786 && ELF_ST_IS_MIPS16 (h->root.other)) 1787 { 1788 /* We don't need the call_stub; this is a 16 bit function, so 1789 calls from other 16 bit functions are OK. Clobber the size 1790 to 0 to prevent it from being included in the link. */ 1791 h->call_fp_stub->size = 0; 1792 h->call_fp_stub->flags &= ~SEC_RELOC; 1793 h->call_fp_stub->reloc_count = 0; 1794 h->call_fp_stub->flags |= SEC_EXCLUDE; 1795 h->call_fp_stub->output_section = bfd_abs_section_ptr; 1796 } 1797 } 1798 1799 /* Hashtable callbacks for mips_elf_la25_stubs. */ 1800 1801 static hashval_t 1802 mips_elf_la25_stub_hash (const void *entry_) 1803 { 1804 const struct mips_elf_la25_stub *entry; 1805 1806 entry = (struct mips_elf_la25_stub *) entry_; 1807 return entry->h->root.root.u.def.section->id 1808 + entry->h->root.root.u.def.value; 1809 } 1810 1811 static int 1812 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_) 1813 { 1814 const struct mips_elf_la25_stub *entry1, *entry2; 1815 1816 entry1 = (struct mips_elf_la25_stub *) entry1_; 1817 entry2 = (struct mips_elf_la25_stub *) entry2_; 1818 return ((entry1->h->root.root.u.def.section 1819 == entry2->h->root.root.u.def.section) 1820 && (entry1->h->root.root.u.def.value 1821 == entry2->h->root.root.u.def.value)); 1822 } 1823 1824 /* Called by the linker to set up the la25 stub-creation code. FN is 1825 the linker's implementation of add_stub_function. Return true on 1826 success. */ 1827 1828 bfd_boolean 1829 _bfd_mips_elf_init_stubs (struct bfd_link_info *info, 1830 asection *(*fn) (const char *, asection *, 1831 asection *)) 1832 { 1833 struct mips_elf_link_hash_table *htab; 1834 1835 htab = mips_elf_hash_table (info); 1836 if (htab == NULL) 1837 return FALSE; 1838 1839 htab->add_stub_section = fn; 1840 htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash, 1841 mips_elf_la25_stub_eq, NULL); 1842 if (htab->la25_stubs == NULL) 1843 return FALSE; 1844 1845 return TRUE; 1846 } 1847 1848 /* Return true if H is a locally-defined PIC function, in the sense 1849 that it or its fn_stub might need $25 to be valid on entry. 1850 Note that MIPS16 functions set up $gp using PC-relative instructions, 1851 so they themselves never need $25 to be valid. Only non-MIPS16 1852 entry points are of interest here. */ 1853 1854 static bfd_boolean 1855 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h) 1856 { 1857 return ((h->root.root.type == bfd_link_hash_defined 1858 || h->root.root.type == bfd_link_hash_defweak) 1859 && h->root.def_regular 1860 && !bfd_is_abs_section (h->root.root.u.def.section) 1861 && !bfd_is_und_section (h->root.root.u.def.section) 1862 && (!ELF_ST_IS_MIPS16 (h->root.other) 1863 || (h->fn_stub && h->need_fn_stub)) 1864 && (PIC_OBJECT_P (h->root.root.u.def.section->owner) 1865 || ELF_ST_IS_MIPS_PIC (h->root.other))); 1866 } 1867 1868 /* Set *SEC to the input section that contains the target of STUB. 1869 Return the offset of the target from the start of that section. */ 1870 1871 static bfd_vma 1872 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub, 1873 asection **sec) 1874 { 1875 if (ELF_ST_IS_MIPS16 (stub->h->root.other)) 1876 { 1877 BFD_ASSERT (stub->h->need_fn_stub); 1878 *sec = stub->h->fn_stub; 1879 return 0; 1880 } 1881 else 1882 { 1883 *sec = stub->h->root.root.u.def.section; 1884 return stub->h->root.root.u.def.value; 1885 } 1886 } 1887 1888 /* STUB describes an la25 stub that we have decided to implement 1889 by inserting an LUI/ADDIU pair before the target function. 1890 Create the section and redirect the function symbol to it. */ 1891 1892 static bfd_boolean 1893 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub, 1894 struct bfd_link_info *info) 1895 { 1896 struct mips_elf_link_hash_table *htab; 1897 char *name; 1898 asection *s, *input_section; 1899 unsigned int align; 1900 1901 htab = mips_elf_hash_table (info); 1902 if (htab == NULL) 1903 return FALSE; 1904 1905 /* Create a unique name for the new section. */ 1906 name = bfd_malloc (11 + sizeof (".text.stub.")); 1907 if (name == NULL) 1908 return FALSE; 1909 sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs)); 1910 1911 /* Create the section. */ 1912 mips_elf_get_la25_target (stub, &input_section); 1913 s = htab->add_stub_section (name, input_section, 1914 input_section->output_section); 1915 if (s == NULL) 1916 return FALSE; 1917 1918 /* Make sure that any padding goes before the stub. */ 1919 align = input_section->alignment_power; 1920 if (!bfd_set_section_alignment (s, align)) 1921 return FALSE; 1922 if (align > 3) 1923 s->size = (1 << align) - 8; 1924 1925 /* Create a symbol for the stub. */ 1926 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8); 1927 stub->stub_section = s; 1928 stub->offset = s->size; 1929 1930 /* Allocate room for it. */ 1931 s->size += 8; 1932 return TRUE; 1933 } 1934 1935 /* STUB describes an la25 stub that we have decided to implement 1936 with a separate trampoline. Allocate room for it and redirect 1937 the function symbol to it. */ 1938 1939 static bfd_boolean 1940 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub, 1941 struct bfd_link_info *info) 1942 { 1943 struct mips_elf_link_hash_table *htab; 1944 asection *s; 1945 1946 htab = mips_elf_hash_table (info); 1947 if (htab == NULL) 1948 return FALSE; 1949 1950 /* Create a trampoline section, if we haven't already. */ 1951 s = htab->strampoline; 1952 if (s == NULL) 1953 { 1954 asection *input_section = stub->h->root.root.u.def.section; 1955 s = htab->add_stub_section (".text", NULL, 1956 input_section->output_section); 1957 if (s == NULL || !bfd_set_section_alignment (s, 4)) 1958 return FALSE; 1959 htab->strampoline = s; 1960 } 1961 1962 /* Create a symbol for the stub. */ 1963 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16); 1964 stub->stub_section = s; 1965 stub->offset = s->size; 1966 1967 /* Allocate room for it. */ 1968 s->size += 16; 1969 return TRUE; 1970 } 1971 1972 /* H describes a symbol that needs an la25 stub. Make sure that an 1973 appropriate stub exists and point H at it. */ 1974 1975 static bfd_boolean 1976 mips_elf_add_la25_stub (struct bfd_link_info *info, 1977 struct mips_elf_link_hash_entry *h) 1978 { 1979 struct mips_elf_link_hash_table *htab; 1980 struct mips_elf_la25_stub search, *stub; 1981 bfd_boolean use_trampoline_p; 1982 asection *s; 1983 bfd_vma value; 1984 void **slot; 1985 1986 /* Describe the stub we want. */ 1987 search.stub_section = NULL; 1988 search.offset = 0; 1989 search.h = h; 1990 1991 /* See if we've already created an equivalent stub. */ 1992 htab = mips_elf_hash_table (info); 1993 if (htab == NULL) 1994 return FALSE; 1995 1996 slot = htab_find_slot (htab->la25_stubs, &search, INSERT); 1997 if (slot == NULL) 1998 return FALSE; 1999 2000 stub = (struct mips_elf_la25_stub *) *slot; 2001 if (stub != NULL) 2002 { 2003 /* We can reuse the existing stub. */ 2004 h->la25_stub = stub; 2005 return TRUE; 2006 } 2007 2008 /* Create a permanent copy of ENTRY and add it to the hash table. */ 2009 stub = bfd_malloc (sizeof (search)); 2010 if (stub == NULL) 2011 return FALSE; 2012 *stub = search; 2013 *slot = stub; 2014 2015 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning 2016 of the section and if we would need no more than 2 nops. */ 2017 value = mips_elf_get_la25_target (stub, &s); 2018 if (ELF_ST_IS_MICROMIPS (stub->h->root.other)) 2019 value &= ~1; 2020 use_trampoline_p = (value != 0 || s->alignment_power > 4); 2021 2022 h->la25_stub = stub; 2023 return (use_trampoline_p 2024 ? mips_elf_add_la25_trampoline (stub, info) 2025 : mips_elf_add_la25_intro (stub, info)); 2026 } 2027 2028 /* A mips_elf_link_hash_traverse callback that is called before sizing 2029 sections. DATA points to a mips_htab_traverse_info structure. */ 2030 2031 static bfd_boolean 2032 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data) 2033 { 2034 struct mips_htab_traverse_info *hti; 2035 2036 hti = (struct mips_htab_traverse_info *) data; 2037 if (!bfd_link_relocatable (hti->info)) 2038 mips_elf_check_mips16_stubs (hti->info, h); 2039 2040 if (mips_elf_local_pic_function_p (h)) 2041 { 2042 /* PR 12845: If H is in a section that has been garbage 2043 collected it will have its output section set to *ABS*. */ 2044 if (bfd_is_abs_section (h->root.root.u.def.section->output_section)) 2045 return TRUE; 2046 2047 /* H is a function that might need $25 to be valid on entry. 2048 If we're creating a non-PIC relocatable object, mark H as 2049 being PIC. If we're creating a non-relocatable object with 2050 non-PIC branches and jumps to H, make sure that H has an la25 2051 stub. */ 2052 if (bfd_link_relocatable (hti->info)) 2053 { 2054 if (!PIC_OBJECT_P (hti->output_bfd)) 2055 h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other); 2056 } 2057 else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h)) 2058 { 2059 hti->error = TRUE; 2060 return FALSE; 2061 } 2062 } 2063 return TRUE; 2064 } 2065 2066 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions. 2067 Most mips16 instructions are 16 bits, but these instructions 2068 are 32 bits. 2069 2070 The format of these instructions is: 2071 2072 +--------------+--------------------------------+ 2073 | JALX | X| Imm 20:16 | Imm 25:21 | 2074 +--------------+--------------------------------+ 2075 | Immediate 15:0 | 2076 +-----------------------------------------------+ 2077 2078 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx. 2079 Note that the immediate value in the first word is swapped. 2080 2081 When producing a relocatable object file, R_MIPS16_26 is 2082 handled mostly like R_MIPS_26. In particular, the addend is 2083 stored as a straight 26-bit value in a 32-bit instruction. 2084 (gas makes life simpler for itself by never adjusting a 2085 R_MIPS16_26 reloc to be against a section, so the addend is 2086 always zero). However, the 32 bit instruction is stored as 2 2087 16-bit values, rather than a single 32-bit value. In a 2088 big-endian file, the result is the same; in a little-endian 2089 file, the two 16-bit halves of the 32 bit value are swapped. 2090 This is so that a disassembler can recognize the jal 2091 instruction. 2092 2093 When doing a final link, R_MIPS16_26 is treated as a 32 bit 2094 instruction stored as two 16-bit values. The addend A is the 2095 contents of the targ26 field. The calculation is the same as 2096 R_MIPS_26. When storing the calculated value, reorder the 2097 immediate value as shown above, and don't forget to store the 2098 value as two 16-bit values. 2099 2100 To put it in MIPS ABI terms, the relocation field is T-targ26-16, 2101 defined as 2102 2103 big-endian: 2104 +--------+----------------------+ 2105 | | | 2106 | | targ26-16 | 2107 |31 26|25 0| 2108 +--------+----------------------+ 2109 2110 little-endian: 2111 +----------+------+-------------+ 2112 | | | | 2113 | sub1 | | sub2 | 2114 |0 9|10 15|16 31| 2115 +----------+--------------------+ 2116 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is 2117 ((sub1 << 16) | sub2)). 2118 2119 When producing a relocatable object file, the calculation is 2120 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 2121 When producing a fully linked file, the calculation is 2122 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 2123 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) 2124 2125 The table below lists the other MIPS16 instruction relocations. 2126 Each one is calculated in the same way as the non-MIPS16 relocation 2127 given on the right, but using the extended MIPS16 layout of 16-bit 2128 immediate fields: 2129 2130 R_MIPS16_GPREL R_MIPS_GPREL16 2131 R_MIPS16_GOT16 R_MIPS_GOT16 2132 R_MIPS16_CALL16 R_MIPS_CALL16 2133 R_MIPS16_HI16 R_MIPS_HI16 2134 R_MIPS16_LO16 R_MIPS_LO16 2135 2136 A typical instruction will have a format like this: 2137 2138 +--------------+--------------------------------+ 2139 | EXTEND | Imm 10:5 | Imm 15:11 | 2140 +--------------+--------------------------------+ 2141 | Major | rx | ry | Imm 4:0 | 2142 +--------------+--------------------------------+ 2143 2144 EXTEND is the five bit value 11110. Major is the instruction 2145 opcode. 2146 2147 All we need to do here is shuffle the bits appropriately. 2148 As above, the two 16-bit halves must be swapped on a 2149 little-endian system. 2150 2151 Finally R_MIPS16_PC16_S1 corresponds to R_MIPS_PC16, however the 2152 relocatable field is shifted by 1 rather than 2 and the same bit 2153 shuffling is done as with the relocations above. */ 2154 2155 static inline bfd_boolean 2156 mips16_reloc_p (int r_type) 2157 { 2158 switch (r_type) 2159 { 2160 case R_MIPS16_26: 2161 case R_MIPS16_GPREL: 2162 case R_MIPS16_GOT16: 2163 case R_MIPS16_CALL16: 2164 case R_MIPS16_HI16: 2165 case R_MIPS16_LO16: 2166 case R_MIPS16_TLS_GD: 2167 case R_MIPS16_TLS_LDM: 2168 case R_MIPS16_TLS_DTPREL_HI16: 2169 case R_MIPS16_TLS_DTPREL_LO16: 2170 case R_MIPS16_TLS_GOTTPREL: 2171 case R_MIPS16_TLS_TPREL_HI16: 2172 case R_MIPS16_TLS_TPREL_LO16: 2173 case R_MIPS16_PC16_S1: 2174 return TRUE; 2175 2176 default: 2177 return FALSE; 2178 } 2179 } 2180 2181 /* Check if a microMIPS reloc. */ 2182 2183 static inline bfd_boolean 2184 micromips_reloc_p (unsigned int r_type) 2185 { 2186 return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max; 2187 } 2188 2189 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped 2190 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1 2191 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */ 2192 2193 static inline bfd_boolean 2194 micromips_reloc_shuffle_p (unsigned int r_type) 2195 { 2196 return (micromips_reloc_p (r_type) 2197 && r_type != R_MICROMIPS_PC7_S1 2198 && r_type != R_MICROMIPS_PC10_S1); 2199 } 2200 2201 static inline bfd_boolean 2202 got16_reloc_p (int r_type) 2203 { 2204 return (r_type == R_MIPS_GOT16 2205 || r_type == R_MIPS16_GOT16 2206 || r_type == R_MICROMIPS_GOT16); 2207 } 2208 2209 static inline bfd_boolean 2210 call16_reloc_p (int r_type) 2211 { 2212 return (r_type == R_MIPS_CALL16 2213 || r_type == R_MIPS16_CALL16 2214 || r_type == R_MICROMIPS_CALL16); 2215 } 2216 2217 static inline bfd_boolean 2218 got_disp_reloc_p (unsigned int r_type) 2219 { 2220 return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP; 2221 } 2222 2223 static inline bfd_boolean 2224 got_page_reloc_p (unsigned int r_type) 2225 { 2226 return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE; 2227 } 2228 2229 static inline bfd_boolean 2230 got_lo16_reloc_p (unsigned int r_type) 2231 { 2232 return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16; 2233 } 2234 2235 static inline bfd_boolean 2236 call_hi16_reloc_p (unsigned int r_type) 2237 { 2238 return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16; 2239 } 2240 2241 static inline bfd_boolean 2242 call_lo16_reloc_p (unsigned int r_type) 2243 { 2244 return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16; 2245 } 2246 2247 static inline bfd_boolean 2248 hi16_reloc_p (int r_type) 2249 { 2250 return (r_type == R_MIPS_HI16 2251 || r_type == R_MIPS16_HI16 2252 || r_type == R_MICROMIPS_HI16 2253 || r_type == R_MIPS_PCHI16); 2254 } 2255 2256 static inline bfd_boolean 2257 lo16_reloc_p (int r_type) 2258 { 2259 return (r_type == R_MIPS_LO16 2260 || r_type == R_MIPS16_LO16 2261 || r_type == R_MICROMIPS_LO16 2262 || r_type == R_MIPS_PCLO16); 2263 } 2264 2265 static inline bfd_boolean 2266 mips16_call_reloc_p (int r_type) 2267 { 2268 return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16; 2269 } 2270 2271 static inline bfd_boolean 2272 jal_reloc_p (int r_type) 2273 { 2274 return (r_type == R_MIPS_26 2275 || r_type == R_MIPS16_26 2276 || r_type == R_MICROMIPS_26_S1); 2277 } 2278 2279 static inline bfd_boolean 2280 b_reloc_p (int r_type) 2281 { 2282 return (r_type == R_MIPS_PC26_S2 2283 || r_type == R_MIPS_PC21_S2 2284 || r_type == R_MIPS_PC16 2285 || r_type == R_MIPS_GNU_REL16_S2 2286 || r_type == R_MIPS16_PC16_S1 2287 || r_type == R_MICROMIPS_PC16_S1 2288 || r_type == R_MICROMIPS_PC10_S1 2289 || r_type == R_MICROMIPS_PC7_S1); 2290 } 2291 2292 static inline bfd_boolean 2293 aligned_pcrel_reloc_p (int r_type) 2294 { 2295 return (r_type == R_MIPS_PC18_S3 2296 || r_type == R_MIPS_PC19_S2); 2297 } 2298 2299 static inline bfd_boolean 2300 branch_reloc_p (int r_type) 2301 { 2302 return (r_type == R_MIPS_26 2303 || r_type == R_MIPS_PC26_S2 2304 || r_type == R_MIPS_PC21_S2 2305 || r_type == R_MIPS_PC16 2306 || r_type == R_MIPS_GNU_REL16_S2); 2307 } 2308 2309 static inline bfd_boolean 2310 mips16_branch_reloc_p (int r_type) 2311 { 2312 return (r_type == R_MIPS16_26 2313 || r_type == R_MIPS16_PC16_S1); 2314 } 2315 2316 static inline bfd_boolean 2317 micromips_branch_reloc_p (int r_type) 2318 { 2319 return (r_type == R_MICROMIPS_26_S1 2320 || r_type == R_MICROMIPS_PC16_S1 2321 || r_type == R_MICROMIPS_PC10_S1 2322 || r_type == R_MICROMIPS_PC7_S1); 2323 } 2324 2325 static inline bfd_boolean 2326 tls_gd_reloc_p (unsigned int r_type) 2327 { 2328 return (r_type == R_MIPS_TLS_GD 2329 || r_type == R_MIPS16_TLS_GD 2330 || r_type == R_MICROMIPS_TLS_GD); 2331 } 2332 2333 static inline bfd_boolean 2334 tls_ldm_reloc_p (unsigned int r_type) 2335 { 2336 return (r_type == R_MIPS_TLS_LDM 2337 || r_type == R_MIPS16_TLS_LDM 2338 || r_type == R_MICROMIPS_TLS_LDM); 2339 } 2340 2341 static inline bfd_boolean 2342 tls_gottprel_reloc_p (unsigned int r_type) 2343 { 2344 return (r_type == R_MIPS_TLS_GOTTPREL 2345 || r_type == R_MIPS16_TLS_GOTTPREL 2346 || r_type == R_MICROMIPS_TLS_GOTTPREL); 2347 } 2348 2349 void 2350 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type, 2351 bfd_boolean jal_shuffle, bfd_byte *data) 2352 { 2353 bfd_vma first, second, val; 2354 2355 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type)) 2356 return; 2357 2358 /* Pick up the first and second halfwords of the instruction. */ 2359 first = bfd_get_16 (abfd, data); 2360 second = bfd_get_16 (abfd, data + 2); 2361 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle)) 2362 val = first << 16 | second; 2363 else if (r_type != R_MIPS16_26) 2364 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11) 2365 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f)); 2366 else 2367 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11) 2368 | ((first & 0x1f) << 21) | second); 2369 bfd_put_32 (abfd, val, data); 2370 } 2371 2372 void 2373 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type, 2374 bfd_boolean jal_shuffle, bfd_byte *data) 2375 { 2376 bfd_vma first, second, val; 2377 2378 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type)) 2379 return; 2380 2381 val = bfd_get_32 (abfd, data); 2382 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle)) 2383 { 2384 second = val & 0xffff; 2385 first = val >> 16; 2386 } 2387 else if (r_type != R_MIPS16_26) 2388 { 2389 second = ((val >> 11) & 0xffe0) | (val & 0x1f); 2390 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0); 2391 } 2392 else 2393 { 2394 second = val & 0xffff; 2395 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0) 2396 | ((val >> 21) & 0x1f); 2397 } 2398 bfd_put_16 (abfd, second, data + 2); 2399 bfd_put_16 (abfd, first, data); 2400 } 2401 2402 bfd_reloc_status_type 2403 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol, 2404 arelent *reloc_entry, asection *input_section, 2405 bfd_boolean relocatable, void *data, bfd_vma gp) 2406 { 2407 bfd_vma relocation; 2408 bfd_signed_vma val; 2409 bfd_reloc_status_type status; 2410 2411 if (bfd_is_com_section (symbol->section)) 2412 relocation = 0; 2413 else 2414 relocation = symbol->value; 2415 2416 relocation += symbol->section->output_section->vma; 2417 relocation += symbol->section->output_offset; 2418 2419 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 2420 return bfd_reloc_outofrange; 2421 2422 /* Set val to the offset into the section or symbol. */ 2423 val = reloc_entry->addend; 2424 2425 _bfd_mips_elf_sign_extend (val, 16); 2426 2427 /* Adjust val for the final section location and GP value. If we 2428 are producing relocatable output, we don't want to do this for 2429 an external symbol. */ 2430 if (! relocatable 2431 || (symbol->flags & BSF_SECTION_SYM) != 0) 2432 val += relocation - gp; 2433 2434 if (reloc_entry->howto->partial_inplace) 2435 { 2436 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val, 2437 (bfd_byte *) data 2438 + reloc_entry->address); 2439 if (status != bfd_reloc_ok) 2440 return status; 2441 } 2442 else 2443 reloc_entry->addend = val; 2444 2445 if (relocatable) 2446 reloc_entry->address += input_section->output_offset; 2447 2448 return bfd_reloc_ok; 2449 } 2450 2451 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or 2452 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section 2453 that contains the relocation field and DATA points to the start of 2454 INPUT_SECTION. */ 2455 2456 struct mips_hi16 2457 { 2458 struct mips_hi16 *next; 2459 bfd_byte *data; 2460 asection *input_section; 2461 arelent rel; 2462 }; 2463 2464 /* FIXME: This should not be a static variable. */ 2465 2466 static struct mips_hi16 *mips_hi16_list; 2467 2468 /* A howto special_function for REL *HI16 relocations. We can only 2469 calculate the correct value once we've seen the partnering 2470 *LO16 relocation, so just save the information for later. 2471 2472 The ABI requires that the *LO16 immediately follow the *HI16. 2473 However, as a GNU extension, we permit an arbitrary number of 2474 *HI16s to be associated with a single *LO16. This significantly 2475 simplies the relocation handling in gcc. */ 2476 2477 bfd_reloc_status_type 2478 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry, 2479 asymbol *symbol ATTRIBUTE_UNUSED, void *data, 2480 asection *input_section, bfd *output_bfd, 2481 char **error_message ATTRIBUTE_UNUSED) 2482 { 2483 struct mips_hi16 *n; 2484 2485 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 2486 return bfd_reloc_outofrange; 2487 2488 n = bfd_malloc (sizeof *n); 2489 if (n == NULL) 2490 return bfd_reloc_outofrange; 2491 2492 n->next = mips_hi16_list; 2493 n->data = data; 2494 n->input_section = input_section; 2495 n->rel = *reloc_entry; 2496 mips_hi16_list = n; 2497 2498 if (output_bfd != NULL) 2499 reloc_entry->address += input_section->output_offset; 2500 2501 return bfd_reloc_ok; 2502 } 2503 2504 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just 2505 like any other 16-bit relocation when applied to global symbols, but is 2506 treated in the same as R_MIPS_HI16 when applied to local symbols. */ 2507 2508 bfd_reloc_status_type 2509 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2510 void *data, asection *input_section, 2511 bfd *output_bfd, char **error_message) 2512 { 2513 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0 2514 || bfd_is_und_section (bfd_asymbol_section (symbol)) 2515 || bfd_is_com_section (bfd_asymbol_section (symbol))) 2516 /* The relocation is against a global symbol. */ 2517 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2518 input_section, output_bfd, 2519 error_message); 2520 2521 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data, 2522 input_section, output_bfd, error_message); 2523 } 2524 2525 /* A howto special_function for REL *LO16 relocations. The *LO16 itself 2526 is a straightforward 16 bit inplace relocation, but we must deal with 2527 any partnering high-part relocations as well. */ 2528 2529 bfd_reloc_status_type 2530 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 2531 void *data, asection *input_section, 2532 bfd *output_bfd, char **error_message) 2533 { 2534 bfd_vma vallo; 2535 bfd_byte *location = (bfd_byte *) data + reloc_entry->address; 2536 2537 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 2538 return bfd_reloc_outofrange; 2539 2540 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE, 2541 location); 2542 vallo = bfd_get_32 (abfd, location); 2543 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE, 2544 location); 2545 2546 while (mips_hi16_list != NULL) 2547 { 2548 bfd_reloc_status_type ret; 2549 struct mips_hi16 *hi; 2550 2551 hi = mips_hi16_list; 2552 2553 /* R_MIPS*_GOT16 relocations are something of a special case. We 2554 want to install the addend in the same way as for a R_MIPS*_HI16 2555 relocation (with a rightshift of 16). However, since GOT16 2556 relocations can also be used with global symbols, their howto 2557 has a rightshift of 0. */ 2558 if (hi->rel.howto->type == R_MIPS_GOT16) 2559 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE); 2560 else if (hi->rel.howto->type == R_MIPS16_GOT16) 2561 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE); 2562 else if (hi->rel.howto->type == R_MICROMIPS_GOT16) 2563 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE); 2564 2565 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any 2566 carry or borrow will induce a change of +1 or -1 in the high part. */ 2567 hi->rel.addend += (vallo + 0x8000) & 0xffff; 2568 2569 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data, 2570 hi->input_section, output_bfd, 2571 error_message); 2572 if (ret != bfd_reloc_ok) 2573 return ret; 2574 2575 mips_hi16_list = hi->next; 2576 free (hi); 2577 } 2578 2579 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2580 input_section, output_bfd, 2581 error_message); 2582 } 2583 2584 /* A generic howto special_function. This calculates and installs the 2585 relocation itself, thus avoiding the oft-discussed problems in 2586 bfd_perform_relocation and bfd_install_relocation. */ 2587 2588 bfd_reloc_status_type 2589 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry, 2590 asymbol *symbol, void *data ATTRIBUTE_UNUSED, 2591 asection *input_section, bfd *output_bfd, 2592 char **error_message ATTRIBUTE_UNUSED) 2593 { 2594 bfd_signed_vma val; 2595 bfd_reloc_status_type status; 2596 bfd_boolean relocatable; 2597 2598 relocatable = (output_bfd != NULL); 2599 2600 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 2601 return bfd_reloc_outofrange; 2602 2603 /* Build up the field adjustment in VAL. */ 2604 val = 0; 2605 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0) 2606 { 2607 /* Either we're calculating the final field value or we have a 2608 relocation against a section symbol. Add in the section's 2609 offset or address. */ 2610 val += symbol->section->output_section->vma; 2611 val += symbol->section->output_offset; 2612 } 2613 2614 if (!relocatable) 2615 { 2616 /* We're calculating the final field value. Add in the symbol's value 2617 and, if pc-relative, subtract the address of the field itself. */ 2618 val += symbol->value; 2619 if (reloc_entry->howto->pc_relative) 2620 { 2621 val -= input_section->output_section->vma; 2622 val -= input_section->output_offset; 2623 val -= reloc_entry->address; 2624 } 2625 } 2626 2627 /* VAL is now the final adjustment. If we're keeping this relocation 2628 in the output file, and if the relocation uses a separate addend, 2629 we just need to add VAL to that addend. Otherwise we need to add 2630 VAL to the relocation field itself. */ 2631 if (relocatable && !reloc_entry->howto->partial_inplace) 2632 reloc_entry->addend += val; 2633 else 2634 { 2635 bfd_byte *location = (bfd_byte *) data + reloc_entry->address; 2636 2637 /* Add in the separate addend, if any. */ 2638 val += reloc_entry->addend; 2639 2640 /* Add VAL to the relocation field. */ 2641 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE, 2642 location); 2643 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val, 2644 location); 2645 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE, 2646 location); 2647 2648 if (status != bfd_reloc_ok) 2649 return status; 2650 } 2651 2652 if (relocatable) 2653 reloc_entry->address += input_section->output_offset; 2654 2655 return bfd_reloc_ok; 2656 } 2657 2658 /* Swap an entry in a .gptab section. Note that these routines rely 2659 on the equivalence of the two elements of the union. */ 2660 2661 static void 2662 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex, 2663 Elf32_gptab *in) 2664 { 2665 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value); 2666 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes); 2667 } 2668 2669 static void 2670 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in, 2671 Elf32_External_gptab *ex) 2672 { 2673 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value); 2674 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes); 2675 } 2676 2677 static void 2678 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in, 2679 Elf32_External_compact_rel *ex) 2680 { 2681 H_PUT_32 (abfd, in->id1, ex->id1); 2682 H_PUT_32 (abfd, in->num, ex->num); 2683 H_PUT_32 (abfd, in->id2, ex->id2); 2684 H_PUT_32 (abfd, in->offset, ex->offset); 2685 H_PUT_32 (abfd, in->reserved0, ex->reserved0); 2686 H_PUT_32 (abfd, in->reserved1, ex->reserved1); 2687 } 2688 2689 static void 2690 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in, 2691 Elf32_External_crinfo *ex) 2692 { 2693 unsigned long l; 2694 2695 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH) 2696 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH) 2697 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH) 2698 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH)); 2699 H_PUT_32 (abfd, l, ex->info); 2700 H_PUT_32 (abfd, in->konst, ex->konst); 2701 H_PUT_32 (abfd, in->vaddr, ex->vaddr); 2702 } 2703 2704 /* A .reginfo section holds a single Elf32_RegInfo structure. These 2705 routines swap this structure in and out. They are used outside of 2706 BFD, so they are globally visible. */ 2707 2708 void 2709 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex, 2710 Elf32_RegInfo *in) 2711 { 2712 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask); 2713 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]); 2714 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]); 2715 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]); 2716 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]); 2717 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value); 2718 } 2719 2720 void 2721 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in, 2722 Elf32_External_RegInfo *ex) 2723 { 2724 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask); 2725 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]); 2726 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]); 2727 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]); 2728 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]); 2729 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value); 2730 } 2731 2732 /* In the 64 bit ABI, the .MIPS.options section holds register 2733 information in an Elf64_Reginfo structure. These routines swap 2734 them in and out. They are globally visible because they are used 2735 outside of BFD. These routines are here so that gas can call them 2736 without worrying about whether the 64 bit ABI has been included. */ 2737 2738 void 2739 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex, 2740 Elf64_Internal_RegInfo *in) 2741 { 2742 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask); 2743 in->ri_pad = H_GET_32 (abfd, ex->ri_pad); 2744 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]); 2745 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]); 2746 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]); 2747 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]); 2748 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value); 2749 } 2750 2751 void 2752 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in, 2753 Elf64_External_RegInfo *ex) 2754 { 2755 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask); 2756 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad); 2757 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]); 2758 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]); 2759 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]); 2760 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]); 2761 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value); 2762 } 2763 2764 /* Swap in an options header. */ 2765 2766 void 2767 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex, 2768 Elf_Internal_Options *in) 2769 { 2770 in->kind = H_GET_8 (abfd, ex->kind); 2771 in->size = H_GET_8 (abfd, ex->size); 2772 in->section = H_GET_16 (abfd, ex->section); 2773 in->info = H_GET_32 (abfd, ex->info); 2774 } 2775 2776 /* Swap out an options header. */ 2777 2778 void 2779 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in, 2780 Elf_External_Options *ex) 2781 { 2782 H_PUT_8 (abfd, in->kind, ex->kind); 2783 H_PUT_8 (abfd, in->size, ex->size); 2784 H_PUT_16 (abfd, in->section, ex->section); 2785 H_PUT_32 (abfd, in->info, ex->info); 2786 } 2787 2788 /* Swap in an abiflags structure. */ 2789 2790 void 2791 bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd, 2792 const Elf_External_ABIFlags_v0 *ex, 2793 Elf_Internal_ABIFlags_v0 *in) 2794 { 2795 in->version = H_GET_16 (abfd, ex->version); 2796 in->isa_level = H_GET_8 (abfd, ex->isa_level); 2797 in->isa_rev = H_GET_8 (abfd, ex->isa_rev); 2798 in->gpr_size = H_GET_8 (abfd, ex->gpr_size); 2799 in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size); 2800 in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size); 2801 in->fp_abi = H_GET_8 (abfd, ex->fp_abi); 2802 in->isa_ext = H_GET_32 (abfd, ex->isa_ext); 2803 in->ases = H_GET_32 (abfd, ex->ases); 2804 in->flags1 = H_GET_32 (abfd, ex->flags1); 2805 in->flags2 = H_GET_32 (abfd, ex->flags2); 2806 } 2807 2808 /* Swap out an abiflags structure. */ 2809 2810 void 2811 bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd, 2812 const Elf_Internal_ABIFlags_v0 *in, 2813 Elf_External_ABIFlags_v0 *ex) 2814 { 2815 H_PUT_16 (abfd, in->version, ex->version); 2816 H_PUT_8 (abfd, in->isa_level, ex->isa_level); 2817 H_PUT_8 (abfd, in->isa_rev, ex->isa_rev); 2818 H_PUT_8 (abfd, in->gpr_size, ex->gpr_size); 2819 H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size); 2820 H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size); 2821 H_PUT_8 (abfd, in->fp_abi, ex->fp_abi); 2822 H_PUT_32 (abfd, in->isa_ext, ex->isa_ext); 2823 H_PUT_32 (abfd, in->ases, ex->ases); 2824 H_PUT_32 (abfd, in->flags1, ex->flags1); 2825 H_PUT_32 (abfd, in->flags2, ex->flags2); 2826 } 2827 2828 /* This function is called via qsort() to sort the dynamic relocation 2829 entries by increasing r_symndx value. */ 2830 2831 static int 2832 sort_dynamic_relocs (const void *arg1, const void *arg2) 2833 { 2834 Elf_Internal_Rela int_reloc1; 2835 Elf_Internal_Rela int_reloc2; 2836 int diff; 2837 2838 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1); 2839 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2); 2840 2841 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info); 2842 if (diff != 0) 2843 return diff; 2844 2845 if (int_reloc1.r_offset < int_reloc2.r_offset) 2846 return -1; 2847 if (int_reloc1.r_offset > int_reloc2.r_offset) 2848 return 1; 2849 return 0; 2850 } 2851 2852 /* Like sort_dynamic_relocs, but used for elf64 relocations. */ 2853 2854 static int 2855 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED, 2856 const void *arg2 ATTRIBUTE_UNUSED) 2857 { 2858 #ifdef BFD64 2859 Elf_Internal_Rela int_reloc1[3]; 2860 Elf_Internal_Rela int_reloc2[3]; 2861 2862 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in) 2863 (reldyn_sorting_bfd, arg1, int_reloc1); 2864 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in) 2865 (reldyn_sorting_bfd, arg2, int_reloc2); 2866 2867 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info)) 2868 return -1; 2869 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info)) 2870 return 1; 2871 2872 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset) 2873 return -1; 2874 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset) 2875 return 1; 2876 return 0; 2877 #else 2878 abort (); 2879 #endif 2880 } 2881 2882 2883 /* This routine is used to write out ECOFF debugging external symbol 2884 information. It is called via mips_elf_link_hash_traverse. The 2885 ECOFF external symbol information must match the ELF external 2886 symbol information. Unfortunately, at this point we don't know 2887 whether a symbol is required by reloc information, so the two 2888 tables may wind up being different. We must sort out the external 2889 symbol information before we can set the final size of the .mdebug 2890 section, and we must set the size of the .mdebug section before we 2891 can relocate any sections, and we can't know which symbols are 2892 required by relocation until we relocate the sections. 2893 Fortunately, it is relatively unlikely that any symbol will be 2894 stripped but required by a reloc. In particular, it can not happen 2895 when generating a final executable. */ 2896 2897 static bfd_boolean 2898 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data) 2899 { 2900 struct extsym_info *einfo = data; 2901 bfd_boolean strip; 2902 asection *sec, *output_section; 2903 2904 if (h->root.indx == -2) 2905 strip = FALSE; 2906 else if ((h->root.def_dynamic 2907 || h->root.ref_dynamic 2908 || h->root.type == bfd_link_hash_new) 2909 && !h->root.def_regular 2910 && !h->root.ref_regular) 2911 strip = TRUE; 2912 else if (einfo->info->strip == strip_all 2913 || (einfo->info->strip == strip_some 2914 && bfd_hash_lookup (einfo->info->keep_hash, 2915 h->root.root.root.string, 2916 FALSE, FALSE) == NULL)) 2917 strip = TRUE; 2918 else 2919 strip = FALSE; 2920 2921 if (strip) 2922 return TRUE; 2923 2924 if (h->esym.ifd == -2) 2925 { 2926 h->esym.jmptbl = 0; 2927 h->esym.cobol_main = 0; 2928 h->esym.weakext = 0; 2929 h->esym.reserved = 0; 2930 h->esym.ifd = ifdNil; 2931 h->esym.asym.value = 0; 2932 h->esym.asym.st = stGlobal; 2933 2934 if (h->root.root.type == bfd_link_hash_undefined 2935 || h->root.root.type == bfd_link_hash_undefweak) 2936 { 2937 const char *name; 2938 2939 /* Use undefined class. Also, set class and type for some 2940 special symbols. */ 2941 name = h->root.root.root.string; 2942 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0 2943 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0) 2944 { 2945 h->esym.asym.sc = scData; 2946 h->esym.asym.st = stLabel; 2947 h->esym.asym.value = 0; 2948 } 2949 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0) 2950 { 2951 h->esym.asym.sc = scAbs; 2952 h->esym.asym.st = stLabel; 2953 h->esym.asym.value = 2954 mips_elf_hash_table (einfo->info)->procedure_count; 2955 } 2956 else 2957 h->esym.asym.sc = scUndefined; 2958 } 2959 else if (h->root.root.type != bfd_link_hash_defined 2960 && h->root.root.type != bfd_link_hash_defweak) 2961 h->esym.asym.sc = scAbs; 2962 else 2963 { 2964 const char *name; 2965 2966 sec = h->root.root.u.def.section; 2967 output_section = sec->output_section; 2968 2969 /* When making a shared library and symbol h is the one from 2970 the another shared library, OUTPUT_SECTION may be null. */ 2971 if (output_section == NULL) 2972 h->esym.asym.sc = scUndefined; 2973 else 2974 { 2975 name = bfd_section_name (output_section); 2976 2977 if (strcmp (name, ".text") == 0) 2978 h->esym.asym.sc = scText; 2979 else if (strcmp (name, ".data") == 0) 2980 h->esym.asym.sc = scData; 2981 else if (strcmp (name, ".sdata") == 0) 2982 h->esym.asym.sc = scSData; 2983 else if (strcmp (name, ".rodata") == 0 2984 || strcmp (name, ".rdata") == 0) 2985 h->esym.asym.sc = scRData; 2986 else if (strcmp (name, ".bss") == 0) 2987 h->esym.asym.sc = scBss; 2988 else if (strcmp (name, ".sbss") == 0) 2989 h->esym.asym.sc = scSBss; 2990 else if (strcmp (name, ".init") == 0) 2991 h->esym.asym.sc = scInit; 2992 else if (strcmp (name, ".fini") == 0) 2993 h->esym.asym.sc = scFini; 2994 else 2995 h->esym.asym.sc = scAbs; 2996 } 2997 } 2998 2999 h->esym.asym.reserved = 0; 3000 h->esym.asym.index = indexNil; 3001 } 3002 3003 if (h->root.root.type == bfd_link_hash_common) 3004 h->esym.asym.value = h->root.root.u.c.size; 3005 else if (h->root.root.type == bfd_link_hash_defined 3006 || h->root.root.type == bfd_link_hash_defweak) 3007 { 3008 if (h->esym.asym.sc == scCommon) 3009 h->esym.asym.sc = scBss; 3010 else if (h->esym.asym.sc == scSCommon) 3011 h->esym.asym.sc = scSBss; 3012 3013 sec = h->root.root.u.def.section; 3014 output_section = sec->output_section; 3015 if (output_section != NULL) 3016 h->esym.asym.value = (h->root.root.u.def.value 3017 + sec->output_offset 3018 + output_section->vma); 3019 else 3020 h->esym.asym.value = 0; 3021 } 3022 else 3023 { 3024 struct mips_elf_link_hash_entry *hd = h; 3025 3026 while (hd->root.root.type == bfd_link_hash_indirect) 3027 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link; 3028 3029 if (hd->needs_lazy_stub) 3030 { 3031 BFD_ASSERT (hd->root.plt.plist != NULL); 3032 BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE); 3033 /* Set type and value for a symbol with a function stub. */ 3034 h->esym.asym.st = stProc; 3035 sec = hd->root.root.u.def.section; 3036 if (sec == NULL) 3037 h->esym.asym.value = 0; 3038 else 3039 { 3040 output_section = sec->output_section; 3041 if (output_section != NULL) 3042 h->esym.asym.value = (hd->root.plt.plist->stub_offset 3043 + sec->output_offset 3044 + output_section->vma); 3045 else 3046 h->esym.asym.value = 0; 3047 } 3048 } 3049 } 3050 3051 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap, 3052 h->root.root.root.string, 3053 &h->esym)) 3054 { 3055 einfo->failed = TRUE; 3056 return FALSE; 3057 } 3058 3059 return TRUE; 3060 } 3061 3062 /* A comparison routine used to sort .gptab entries. */ 3063 3064 static int 3065 gptab_compare (const void *p1, const void *p2) 3066 { 3067 const Elf32_gptab *a1 = p1; 3068 const Elf32_gptab *a2 = p2; 3069 3070 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value; 3071 } 3072 3073 /* Functions to manage the got entry hash table. */ 3074 3075 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit 3076 hash number. */ 3077 3078 static INLINE hashval_t 3079 mips_elf_hash_bfd_vma (bfd_vma addr) 3080 { 3081 #ifdef BFD64 3082 return addr + (addr >> 32); 3083 #else 3084 return addr; 3085 #endif 3086 } 3087 3088 static hashval_t 3089 mips_elf_got_entry_hash (const void *entry_) 3090 { 3091 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_; 3092 3093 return (entry->symndx 3094 + ((entry->tls_type == GOT_TLS_LDM) << 18) 3095 + (entry->tls_type == GOT_TLS_LDM ? 0 3096 : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address) 3097 : entry->symndx >= 0 ? (entry->abfd->id 3098 + mips_elf_hash_bfd_vma (entry->d.addend)) 3099 : entry->d.h->root.root.root.hash)); 3100 } 3101 3102 static int 3103 mips_elf_got_entry_eq (const void *entry1, const void *entry2) 3104 { 3105 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1; 3106 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2; 3107 3108 return (e1->symndx == e2->symndx 3109 && e1->tls_type == e2->tls_type 3110 && (e1->tls_type == GOT_TLS_LDM ? TRUE 3111 : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address 3112 : e1->symndx >= 0 ? (e1->abfd == e2->abfd 3113 && e1->d.addend == e2->d.addend) 3114 : e2->abfd && e1->d.h == e2->d.h)); 3115 } 3116 3117 static hashval_t 3118 mips_got_page_ref_hash (const void *ref_) 3119 { 3120 const struct mips_got_page_ref *ref; 3121 3122 ref = (const struct mips_got_page_ref *) ref_; 3123 return ((ref->symndx >= 0 3124 ? (hashval_t) (ref->u.abfd->id + ref->symndx) 3125 : ref->u.h->root.root.root.hash) 3126 + mips_elf_hash_bfd_vma (ref->addend)); 3127 } 3128 3129 static int 3130 mips_got_page_ref_eq (const void *ref1_, const void *ref2_) 3131 { 3132 const struct mips_got_page_ref *ref1, *ref2; 3133 3134 ref1 = (const struct mips_got_page_ref *) ref1_; 3135 ref2 = (const struct mips_got_page_ref *) ref2_; 3136 return (ref1->symndx == ref2->symndx 3137 && (ref1->symndx < 0 3138 ? ref1->u.h == ref2->u.h 3139 : ref1->u.abfd == ref2->u.abfd) 3140 && ref1->addend == ref2->addend); 3141 } 3142 3143 static hashval_t 3144 mips_got_page_entry_hash (const void *entry_) 3145 { 3146 const struct mips_got_page_entry *entry; 3147 3148 entry = (const struct mips_got_page_entry *) entry_; 3149 return entry->sec->id; 3150 } 3151 3152 static int 3153 mips_got_page_entry_eq (const void *entry1_, const void *entry2_) 3154 { 3155 const struct mips_got_page_entry *entry1, *entry2; 3156 3157 entry1 = (const struct mips_got_page_entry *) entry1_; 3158 entry2 = (const struct mips_got_page_entry *) entry2_; 3159 return entry1->sec == entry2->sec; 3160 } 3161 3162 /* Create and return a new mips_got_info structure. */ 3163 3164 static struct mips_got_info * 3165 mips_elf_create_got_info (bfd *abfd) 3166 { 3167 struct mips_got_info *g; 3168 3169 g = bfd_zalloc (abfd, sizeof (struct mips_got_info)); 3170 if (g == NULL) 3171 return NULL; 3172 3173 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash, 3174 mips_elf_got_entry_eq, NULL); 3175 if (g->got_entries == NULL) 3176 return NULL; 3177 3178 g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash, 3179 mips_got_page_ref_eq, NULL); 3180 if (g->got_page_refs == NULL) 3181 return NULL; 3182 3183 return g; 3184 } 3185 3186 /* Return the GOT info for input bfd ABFD, trying to create a new one if 3187 CREATE_P and if ABFD doesn't already have a GOT. */ 3188 3189 static struct mips_got_info * 3190 mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p) 3191 { 3192 struct mips_elf_obj_tdata *tdata; 3193 3194 if (!is_mips_elf (abfd)) 3195 return NULL; 3196 3197 tdata = mips_elf_tdata (abfd); 3198 if (!tdata->got && create_p) 3199 tdata->got = mips_elf_create_got_info (abfd); 3200 return tdata->got; 3201 } 3202 3203 /* Record that ABFD should use output GOT G. */ 3204 3205 static void 3206 mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g) 3207 { 3208 struct mips_elf_obj_tdata *tdata; 3209 3210 BFD_ASSERT (is_mips_elf (abfd)); 3211 tdata = mips_elf_tdata (abfd); 3212 if (tdata->got) 3213 { 3214 /* The GOT structure itself and the hash table entries are 3215 allocated to a bfd, but the hash tables aren't. */ 3216 htab_delete (tdata->got->got_entries); 3217 htab_delete (tdata->got->got_page_refs); 3218 if (tdata->got->got_page_entries) 3219 htab_delete (tdata->got->got_page_entries); 3220 } 3221 tdata->got = g; 3222 } 3223 3224 /* Return the dynamic relocation section. If it doesn't exist, try to 3225 create a new it if CREATE_P, otherwise return NULL. Also return NULL 3226 if creation fails. */ 3227 3228 static asection * 3229 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p) 3230 { 3231 const char *dname; 3232 asection *sreloc; 3233 bfd *dynobj; 3234 3235 dname = MIPS_ELF_REL_DYN_NAME (info); 3236 dynobj = elf_hash_table (info)->dynobj; 3237 sreloc = bfd_get_linker_section (dynobj, dname); 3238 if (sreloc == NULL && create_p) 3239 { 3240 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname, 3241 (SEC_ALLOC 3242 | SEC_LOAD 3243 | SEC_HAS_CONTENTS 3244 | SEC_IN_MEMORY 3245 | SEC_LINKER_CREATED 3246 | SEC_READONLY)); 3247 if (sreloc == NULL 3248 || !bfd_set_section_alignment (sreloc, 3249 MIPS_ELF_LOG_FILE_ALIGN (dynobj))) 3250 return NULL; 3251 } 3252 return sreloc; 3253 } 3254 3255 /* Return the GOT_TLS_* type required by relocation type R_TYPE. */ 3256 3257 static int 3258 mips_elf_reloc_tls_type (unsigned int r_type) 3259 { 3260 if (tls_gd_reloc_p (r_type)) 3261 return GOT_TLS_GD; 3262 3263 if (tls_ldm_reloc_p (r_type)) 3264 return GOT_TLS_LDM; 3265 3266 if (tls_gottprel_reloc_p (r_type)) 3267 return GOT_TLS_IE; 3268 3269 return GOT_TLS_NONE; 3270 } 3271 3272 /* Return the number of GOT slots needed for GOT TLS type TYPE. */ 3273 3274 static int 3275 mips_tls_got_entries (unsigned int type) 3276 { 3277 switch (type) 3278 { 3279 case GOT_TLS_GD: 3280 case GOT_TLS_LDM: 3281 return 2; 3282 3283 case GOT_TLS_IE: 3284 return 1; 3285 3286 case GOT_TLS_NONE: 3287 return 0; 3288 } 3289 abort (); 3290 } 3291 3292 /* Count the number of relocations needed for a TLS GOT entry, with 3293 access types from TLS_TYPE, and symbol H (or a local symbol if H 3294 is NULL). */ 3295 3296 static int 3297 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type, 3298 struct elf_link_hash_entry *h) 3299 { 3300 int indx = 0; 3301 bfd_boolean need_relocs = FALSE; 3302 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created; 3303 3304 if (h != NULL 3305 && h->dynindx != -1 3306 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 3307 && (bfd_link_dll (info) || !SYMBOL_REFERENCES_LOCAL (info, h))) 3308 indx = h->dynindx; 3309 3310 if ((bfd_link_dll (info) || indx != 0) 3311 && (h == NULL 3312 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3313 || h->root.type != bfd_link_hash_undefweak)) 3314 need_relocs = TRUE; 3315 3316 if (!need_relocs) 3317 return 0; 3318 3319 switch (tls_type) 3320 { 3321 case GOT_TLS_GD: 3322 return indx != 0 ? 2 : 1; 3323 3324 case GOT_TLS_IE: 3325 return 1; 3326 3327 case GOT_TLS_LDM: 3328 return bfd_link_dll (info) ? 1 : 0; 3329 3330 default: 3331 return 0; 3332 } 3333 } 3334 3335 /* Add the number of GOT entries and TLS relocations required by ENTRY 3336 to G. */ 3337 3338 static void 3339 mips_elf_count_got_entry (struct bfd_link_info *info, 3340 struct mips_got_info *g, 3341 struct mips_got_entry *entry) 3342 { 3343 if (entry->tls_type) 3344 { 3345 g->tls_gotno += mips_tls_got_entries (entry->tls_type); 3346 g->relocs += mips_tls_got_relocs (info, entry->tls_type, 3347 entry->symndx < 0 3348 ? &entry->d.h->root : NULL); 3349 } 3350 else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE) 3351 g->local_gotno += 1; 3352 else 3353 g->global_gotno += 1; 3354 } 3355 3356 /* Output a simple dynamic relocation into SRELOC. */ 3357 3358 static void 3359 mips_elf_output_dynamic_relocation (bfd *output_bfd, 3360 asection *sreloc, 3361 unsigned long reloc_index, 3362 unsigned long indx, 3363 int r_type, 3364 bfd_vma offset) 3365 { 3366 Elf_Internal_Rela rel[3]; 3367 3368 memset (rel, 0, sizeof (rel)); 3369 3370 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type); 3371 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset; 3372 3373 if (ABI_64_P (output_bfd)) 3374 { 3375 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out) 3376 (output_bfd, &rel[0], 3377 (sreloc->contents 3378 + reloc_index * sizeof (Elf64_Mips_External_Rel))); 3379 } 3380 else 3381 bfd_elf32_swap_reloc_out 3382 (output_bfd, &rel[0], 3383 (sreloc->contents 3384 + reloc_index * sizeof (Elf32_External_Rel))); 3385 } 3386 3387 /* Initialize a set of TLS GOT entries for one symbol. */ 3388 3389 static void 3390 mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info, 3391 struct mips_got_entry *entry, 3392 struct mips_elf_link_hash_entry *h, 3393 bfd_vma value) 3394 { 3395 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created; 3396 struct mips_elf_link_hash_table *htab; 3397 int indx; 3398 asection *sreloc, *sgot; 3399 bfd_vma got_offset, got_offset2; 3400 bfd_boolean need_relocs = FALSE; 3401 3402 htab = mips_elf_hash_table (info); 3403 if (htab == NULL) 3404 return; 3405 3406 sgot = htab->root.sgot; 3407 3408 indx = 0; 3409 if (h != NULL 3410 && h->root.dynindx != -1 3411 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), &h->root) 3412 && (bfd_link_dll (info) || !SYMBOL_REFERENCES_LOCAL (info, &h->root))) 3413 indx = h->root.dynindx; 3414 3415 if (entry->tls_initialized) 3416 return; 3417 3418 if ((bfd_link_dll (info) || indx != 0) 3419 && (h == NULL 3420 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT 3421 || h->root.type != bfd_link_hash_undefweak)) 3422 need_relocs = TRUE; 3423 3424 /* MINUS_ONE means the symbol is not defined in this object. It may not 3425 be defined at all; assume that the value doesn't matter in that 3426 case. Otherwise complain if we would use the value. */ 3427 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs) 3428 || h->root.root.type == bfd_link_hash_undefweak); 3429 3430 /* Emit necessary relocations. */ 3431 sreloc = mips_elf_rel_dyn_section (info, FALSE); 3432 got_offset = entry->gotidx; 3433 3434 switch (entry->tls_type) 3435 { 3436 case GOT_TLS_GD: 3437 /* General Dynamic. */ 3438 got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd); 3439 3440 if (need_relocs) 3441 { 3442 mips_elf_output_dynamic_relocation 3443 (abfd, sreloc, sreloc->reloc_count++, indx, 3444 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32, 3445 sgot->output_offset + sgot->output_section->vma + got_offset); 3446 3447 if (indx) 3448 mips_elf_output_dynamic_relocation 3449 (abfd, sreloc, sreloc->reloc_count++, indx, 3450 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32, 3451 sgot->output_offset + sgot->output_section->vma + got_offset2); 3452 else 3453 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info), 3454 sgot->contents + got_offset2); 3455 } 3456 else 3457 { 3458 MIPS_ELF_PUT_WORD (abfd, 1, 3459 sgot->contents + got_offset); 3460 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info), 3461 sgot->contents + got_offset2); 3462 } 3463 break; 3464 3465 case GOT_TLS_IE: 3466 /* Initial Exec model. */ 3467 if (need_relocs) 3468 { 3469 if (indx == 0) 3470 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma, 3471 sgot->contents + got_offset); 3472 else 3473 MIPS_ELF_PUT_WORD (abfd, 0, 3474 sgot->contents + got_offset); 3475 3476 mips_elf_output_dynamic_relocation 3477 (abfd, sreloc, sreloc->reloc_count++, indx, 3478 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32, 3479 sgot->output_offset + sgot->output_section->vma + got_offset); 3480 } 3481 else 3482 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info), 3483 sgot->contents + got_offset); 3484 break; 3485 3486 case GOT_TLS_LDM: 3487 /* The initial offset is zero, and the LD offsets will include the 3488 bias by DTP_OFFSET. */ 3489 MIPS_ELF_PUT_WORD (abfd, 0, 3490 sgot->contents + got_offset 3491 + MIPS_ELF_GOT_SIZE (abfd)); 3492 3493 if (!bfd_link_dll (info)) 3494 MIPS_ELF_PUT_WORD (abfd, 1, 3495 sgot->contents + got_offset); 3496 else 3497 mips_elf_output_dynamic_relocation 3498 (abfd, sreloc, sreloc->reloc_count++, indx, 3499 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32, 3500 sgot->output_offset + sgot->output_section->vma + got_offset); 3501 break; 3502 3503 default: 3504 abort (); 3505 } 3506 3507 entry->tls_initialized = TRUE; 3508 } 3509 3510 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry 3511 for global symbol H. .got.plt comes before the GOT, so the offset 3512 will be negative. */ 3513 3514 static bfd_vma 3515 mips_elf_gotplt_index (struct bfd_link_info *info, 3516 struct elf_link_hash_entry *h) 3517 { 3518 bfd_vma got_address, got_value; 3519 struct mips_elf_link_hash_table *htab; 3520 3521 htab = mips_elf_hash_table (info); 3522 BFD_ASSERT (htab != NULL); 3523 3524 BFD_ASSERT (h->plt.plist != NULL); 3525 BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE); 3526 3527 /* Calculate the address of the associated .got.plt entry. */ 3528 got_address = (htab->root.sgotplt->output_section->vma 3529 + htab->root.sgotplt->output_offset 3530 + (h->plt.plist->gotplt_index 3531 * MIPS_ELF_GOT_SIZE (info->output_bfd))); 3532 3533 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */ 3534 got_value = (htab->root.hgot->root.u.def.section->output_section->vma 3535 + htab->root.hgot->root.u.def.section->output_offset 3536 + htab->root.hgot->root.u.def.value); 3537 3538 return got_address - got_value; 3539 } 3540 3541 /* Return the GOT offset for address VALUE. If there is not yet a GOT 3542 entry for this value, create one. If R_SYMNDX refers to a TLS symbol, 3543 create a TLS GOT entry instead. Return -1 if no satisfactory GOT 3544 offset can be found. */ 3545 3546 static bfd_vma 3547 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 3548 bfd_vma value, unsigned long r_symndx, 3549 struct mips_elf_link_hash_entry *h, int r_type) 3550 { 3551 struct mips_elf_link_hash_table *htab; 3552 struct mips_got_entry *entry; 3553 3554 htab = mips_elf_hash_table (info); 3555 BFD_ASSERT (htab != NULL); 3556 3557 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 3558 r_symndx, h, r_type); 3559 if (!entry) 3560 return MINUS_ONE; 3561 3562 if (entry->tls_type) 3563 mips_elf_initialize_tls_slots (abfd, info, entry, h, value); 3564 return entry->gotidx; 3565 } 3566 3567 /* Return the GOT index of global symbol H in the primary GOT. */ 3568 3569 static bfd_vma 3570 mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info, 3571 struct elf_link_hash_entry *h) 3572 { 3573 struct mips_elf_link_hash_table *htab; 3574 long global_got_dynindx; 3575 struct mips_got_info *g; 3576 bfd_vma got_index; 3577 3578 htab = mips_elf_hash_table (info); 3579 BFD_ASSERT (htab != NULL); 3580 3581 global_got_dynindx = 0; 3582 if (htab->global_gotsym != NULL) 3583 global_got_dynindx = htab->global_gotsym->dynindx; 3584 3585 /* Once we determine the global GOT entry with the lowest dynamic 3586 symbol table index, we must put all dynamic symbols with greater 3587 indices into the primary GOT. That makes it easy to calculate the 3588 GOT offset. */ 3589 BFD_ASSERT (h->dynindx >= global_got_dynindx); 3590 g = mips_elf_bfd_got (obfd, FALSE); 3591 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno) 3592 * MIPS_ELF_GOT_SIZE (obfd)); 3593 BFD_ASSERT (got_index < htab->root.sgot->size); 3594 3595 return got_index; 3596 } 3597 3598 /* Return the GOT index for the global symbol indicated by H, which is 3599 referenced by a relocation of type R_TYPE in IBFD. */ 3600 3601 static bfd_vma 3602 mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd, 3603 struct elf_link_hash_entry *h, int r_type) 3604 { 3605 struct mips_elf_link_hash_table *htab; 3606 struct mips_got_info *g; 3607 struct mips_got_entry lookup, *entry; 3608 bfd_vma gotidx; 3609 3610 htab = mips_elf_hash_table (info); 3611 BFD_ASSERT (htab != NULL); 3612 3613 g = mips_elf_bfd_got (ibfd, FALSE); 3614 BFD_ASSERT (g); 3615 3616 lookup.tls_type = mips_elf_reloc_tls_type (r_type); 3617 if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE)) 3618 return mips_elf_primary_global_got_index (obfd, info, h); 3619 3620 lookup.abfd = ibfd; 3621 lookup.symndx = -1; 3622 lookup.d.h = (struct mips_elf_link_hash_entry *) h; 3623 entry = htab_find (g->got_entries, &lookup); 3624 BFD_ASSERT (entry); 3625 3626 gotidx = entry->gotidx; 3627 BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size); 3628 3629 if (lookup.tls_type) 3630 { 3631 bfd_vma value = MINUS_ONE; 3632 3633 if ((h->root.type == bfd_link_hash_defined 3634 || h->root.type == bfd_link_hash_defweak) 3635 && h->root.u.def.section->output_section) 3636 value = (h->root.u.def.value 3637 + h->root.u.def.section->output_offset 3638 + h->root.u.def.section->output_section->vma); 3639 3640 mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value); 3641 } 3642 return gotidx; 3643 } 3644 3645 /* Find a GOT page entry that points to within 32KB of VALUE. These 3646 entries are supposed to be placed at small offsets in the GOT, i.e., 3647 within 32KB of GP. Return the index of the GOT entry, or -1 if no 3648 entry could be created. If OFFSETP is nonnull, use it to return the 3649 offset of the GOT entry from VALUE. */ 3650 3651 static bfd_vma 3652 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 3653 bfd_vma value, bfd_vma *offsetp) 3654 { 3655 bfd_vma page, got_index; 3656 struct mips_got_entry *entry; 3657 3658 page = (value + 0x8000) & ~(bfd_vma) 0xffff; 3659 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0, 3660 NULL, R_MIPS_GOT_PAGE); 3661 3662 if (!entry) 3663 return MINUS_ONE; 3664 3665 got_index = entry->gotidx; 3666 3667 if (offsetp) 3668 *offsetp = value - entry->d.address; 3669 3670 return got_index; 3671 } 3672 3673 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE. 3674 EXTERNAL is true if the relocation was originally against a global 3675 symbol that binds locally. */ 3676 3677 static bfd_vma 3678 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 3679 bfd_vma value, bfd_boolean external) 3680 { 3681 struct mips_got_entry *entry; 3682 3683 /* GOT16 relocations against local symbols are followed by a LO16 3684 relocation; those against global symbols are not. Thus if the 3685 symbol was originally local, the GOT16 relocation should load the 3686 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */ 3687 if (! external) 3688 value = mips_elf_high (value) << 16; 3689 3690 /* It doesn't matter whether the original relocation was R_MIPS_GOT16, 3691 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the 3692 same in all cases. */ 3693 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0, 3694 NULL, R_MIPS_GOT16); 3695 if (entry) 3696 return entry->gotidx; 3697 else 3698 return MINUS_ONE; 3699 } 3700 3701 /* Returns the offset for the entry at the INDEXth position 3702 in the GOT. */ 3703 3704 static bfd_vma 3705 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd, 3706 bfd *input_bfd, bfd_vma got_index) 3707 { 3708 struct mips_elf_link_hash_table *htab; 3709 asection *sgot; 3710 bfd_vma gp; 3711 3712 htab = mips_elf_hash_table (info); 3713 BFD_ASSERT (htab != NULL); 3714 3715 sgot = htab->root.sgot; 3716 gp = _bfd_get_gp_value (output_bfd) 3717 + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd); 3718 3719 return sgot->output_section->vma + sgot->output_offset + got_index - gp; 3720 } 3721 3722 /* Create and return a local GOT entry for VALUE, which was calculated 3723 from a symbol belonging to INPUT_SECTON. Return NULL if it could not 3724 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry 3725 instead. */ 3726 3727 static struct mips_got_entry * 3728 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info, 3729 bfd *ibfd, bfd_vma value, 3730 unsigned long r_symndx, 3731 struct mips_elf_link_hash_entry *h, 3732 int r_type) 3733 { 3734 struct mips_got_entry lookup, *entry; 3735 void **loc; 3736 struct mips_got_info *g; 3737 struct mips_elf_link_hash_table *htab; 3738 bfd_vma gotidx; 3739 3740 htab = mips_elf_hash_table (info); 3741 BFD_ASSERT (htab != NULL); 3742 3743 g = mips_elf_bfd_got (ibfd, FALSE); 3744 if (g == NULL) 3745 { 3746 g = mips_elf_bfd_got (abfd, FALSE); 3747 BFD_ASSERT (g != NULL); 3748 } 3749 3750 /* This function shouldn't be called for symbols that live in the global 3751 area of the GOT. */ 3752 BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE); 3753 3754 lookup.tls_type = mips_elf_reloc_tls_type (r_type); 3755 if (lookup.tls_type) 3756 { 3757 lookup.abfd = ibfd; 3758 if (tls_ldm_reloc_p (r_type)) 3759 { 3760 lookup.symndx = 0; 3761 lookup.d.addend = 0; 3762 } 3763 else if (h == NULL) 3764 { 3765 lookup.symndx = r_symndx; 3766 lookup.d.addend = 0; 3767 } 3768 else 3769 { 3770 lookup.symndx = -1; 3771 lookup.d.h = h; 3772 } 3773 3774 entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup); 3775 BFD_ASSERT (entry); 3776 3777 gotidx = entry->gotidx; 3778 BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size); 3779 3780 return entry; 3781 } 3782 3783 lookup.abfd = NULL; 3784 lookup.symndx = -1; 3785 lookup.d.address = value; 3786 loc = htab_find_slot (g->got_entries, &lookup, INSERT); 3787 if (!loc) 3788 return NULL; 3789 3790 entry = (struct mips_got_entry *) *loc; 3791 if (entry) 3792 return entry; 3793 3794 if (g->assigned_low_gotno > g->assigned_high_gotno) 3795 { 3796 /* We didn't allocate enough space in the GOT. */ 3797 _bfd_error_handler 3798 (_("not enough GOT space for local GOT entries")); 3799 bfd_set_error (bfd_error_bad_value); 3800 return NULL; 3801 } 3802 3803 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry)); 3804 if (!entry) 3805 return NULL; 3806 3807 if (got16_reloc_p (r_type) 3808 || call16_reloc_p (r_type) 3809 || got_page_reloc_p (r_type) 3810 || got_disp_reloc_p (r_type)) 3811 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++; 3812 else 3813 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--; 3814 3815 *entry = lookup; 3816 *loc = entry; 3817 3818 MIPS_ELF_PUT_WORD (abfd, value, htab->root.sgot->contents + entry->gotidx); 3819 3820 /* These GOT entries need a dynamic relocation on VxWorks. */ 3821 if (htab->root.target_os == is_vxworks) 3822 { 3823 Elf_Internal_Rela outrel; 3824 asection *s; 3825 bfd_byte *rloc; 3826 bfd_vma got_address; 3827 3828 s = mips_elf_rel_dyn_section (info, FALSE); 3829 got_address = (htab->root.sgot->output_section->vma 3830 + htab->root.sgot->output_offset 3831 + entry->gotidx); 3832 3833 rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela)); 3834 outrel.r_offset = got_address; 3835 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32); 3836 outrel.r_addend = value; 3837 bfd_elf32_swap_reloca_out (abfd, &outrel, rloc); 3838 } 3839 3840 return entry; 3841 } 3842 3843 /* Return the number of dynamic section symbols required by OUTPUT_BFD. 3844 The number might be exact or a worst-case estimate, depending on how 3845 much information is available to elf_backend_omit_section_dynsym at 3846 the current linking stage. */ 3847 3848 static bfd_size_type 3849 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info) 3850 { 3851 bfd_size_type count; 3852 3853 count = 0; 3854 if (bfd_link_pic (info) 3855 || elf_hash_table (info)->is_relocatable_executable) 3856 { 3857 asection *p; 3858 const struct elf_backend_data *bed; 3859 3860 bed = get_elf_backend_data (output_bfd); 3861 for (p = output_bfd->sections; p ; p = p->next) 3862 if ((p->flags & SEC_EXCLUDE) == 0 3863 && (p->flags & SEC_ALLOC) != 0 3864 && elf_hash_table (info)->dynamic_relocs 3865 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p)) 3866 ++count; 3867 } 3868 return count; 3869 } 3870 3871 /* Sort the dynamic symbol table so that symbols that need GOT entries 3872 appear towards the end. */ 3873 3874 static bfd_boolean 3875 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info) 3876 { 3877 struct mips_elf_link_hash_table *htab; 3878 struct mips_elf_hash_sort_data hsd; 3879 struct mips_got_info *g; 3880 3881 htab = mips_elf_hash_table (info); 3882 BFD_ASSERT (htab != NULL); 3883 3884 if (htab->root.dynsymcount == 0) 3885 return TRUE; 3886 3887 g = htab->got_info; 3888 if (g == NULL) 3889 return TRUE; 3890 3891 hsd.low = NULL; 3892 hsd.max_unref_got_dynindx 3893 = hsd.min_got_dynindx 3894 = (htab->root.dynsymcount - g->reloc_only_gotno); 3895 /* Add 1 to local symbol indices to account for the mandatory NULL entry 3896 at the head of the table; see `_bfd_elf_link_renumber_dynsyms'. */ 3897 hsd.max_local_dynindx = count_section_dynsyms (abfd, info) + 1; 3898 hsd.max_non_got_dynindx = htab->root.local_dynsymcount + 1; 3899 hsd.output_bfd = abfd; 3900 if (htab->root.dynobj != NULL 3901 && htab->root.dynamic_sections_created 3902 && info->emit_gnu_hash) 3903 { 3904 asection *s = bfd_get_linker_section (htab->root.dynobj, ".MIPS.xhash"); 3905 BFD_ASSERT (s != NULL); 3906 hsd.mipsxhash = s->contents; 3907 BFD_ASSERT (hsd.mipsxhash != NULL); 3908 } 3909 else 3910 hsd.mipsxhash = NULL; 3911 mips_elf_link_hash_traverse (htab, mips_elf_sort_hash_table_f, &hsd); 3912 3913 /* There should have been enough room in the symbol table to 3914 accommodate both the GOT and non-GOT symbols. */ 3915 BFD_ASSERT (hsd.max_local_dynindx <= htab->root.local_dynsymcount + 1); 3916 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx); 3917 BFD_ASSERT (hsd.max_unref_got_dynindx == htab->root.dynsymcount); 3918 BFD_ASSERT (htab->root.dynsymcount - hsd.min_got_dynindx == g->global_gotno); 3919 3920 /* Now we know which dynamic symbol has the lowest dynamic symbol 3921 table index in the GOT. */ 3922 htab->global_gotsym = hsd.low; 3923 3924 return TRUE; 3925 } 3926 3927 /* If H needs a GOT entry, assign it the highest available dynamic 3928 index. Otherwise, assign it the lowest available dynamic 3929 index. */ 3930 3931 static bfd_boolean 3932 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data) 3933 { 3934 struct mips_elf_hash_sort_data *hsd = data; 3935 3936 /* Symbols without dynamic symbol table entries aren't interesting 3937 at all. */ 3938 if (h->root.dynindx == -1) 3939 return TRUE; 3940 3941 switch (h->global_got_area) 3942 { 3943 case GGA_NONE: 3944 if (h->root.forced_local) 3945 h->root.dynindx = hsd->max_local_dynindx++; 3946 else 3947 h->root.dynindx = hsd->max_non_got_dynindx++; 3948 break; 3949 3950 case GGA_NORMAL: 3951 h->root.dynindx = --hsd->min_got_dynindx; 3952 hsd->low = (struct elf_link_hash_entry *) h; 3953 break; 3954 3955 case GGA_RELOC_ONLY: 3956 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx) 3957 hsd->low = (struct elf_link_hash_entry *) h; 3958 h->root.dynindx = hsd->max_unref_got_dynindx++; 3959 break; 3960 } 3961 3962 /* Populate the .MIPS.xhash translation table entry with 3963 the symbol dynindx. */ 3964 if (h->mipsxhash_loc != 0 && hsd->mipsxhash != NULL) 3965 bfd_put_32 (hsd->output_bfd, h->root.dynindx, 3966 hsd->mipsxhash + h->mipsxhash_loc); 3967 3968 return TRUE; 3969 } 3970 3971 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP 3972 (which is owned by the caller and shouldn't be added to the 3973 hash table directly). */ 3974 3975 static bfd_boolean 3976 mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd, 3977 struct mips_got_entry *lookup) 3978 { 3979 struct mips_elf_link_hash_table *htab; 3980 struct mips_got_entry *entry; 3981 struct mips_got_info *g; 3982 void **loc, **bfd_loc; 3983 3984 /* Make sure there's a slot for this entry in the master GOT. */ 3985 htab = mips_elf_hash_table (info); 3986 g = htab->got_info; 3987 loc = htab_find_slot (g->got_entries, lookup, INSERT); 3988 if (!loc) 3989 return FALSE; 3990 3991 /* Populate the entry if it isn't already. */ 3992 entry = (struct mips_got_entry *) *loc; 3993 if (!entry) 3994 { 3995 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry)); 3996 if (!entry) 3997 return FALSE; 3998 3999 lookup->tls_initialized = FALSE; 4000 lookup->gotidx = -1; 4001 *entry = *lookup; 4002 *loc = entry; 4003 } 4004 4005 /* Reuse the same GOT entry for the BFD's GOT. */ 4006 g = mips_elf_bfd_got (abfd, TRUE); 4007 if (!g) 4008 return FALSE; 4009 4010 bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT); 4011 if (!bfd_loc) 4012 return FALSE; 4013 4014 if (!*bfd_loc) 4015 *bfd_loc = entry; 4016 return TRUE; 4017 } 4018 4019 /* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT 4020 entry for it. FOR_CALL is true if the caller is only interested in 4021 using the GOT entry for calls. */ 4022 4023 static bfd_boolean 4024 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h, 4025 bfd *abfd, struct bfd_link_info *info, 4026 bfd_boolean for_call, int r_type) 4027 { 4028 struct mips_elf_link_hash_table *htab; 4029 struct mips_elf_link_hash_entry *hmips; 4030 struct mips_got_entry entry; 4031 unsigned char tls_type; 4032 4033 htab = mips_elf_hash_table (info); 4034 BFD_ASSERT (htab != NULL); 4035 4036 hmips = (struct mips_elf_link_hash_entry *) h; 4037 if (!for_call) 4038 hmips->got_only_for_calls = FALSE; 4039 4040 /* A global symbol in the GOT must also be in the dynamic symbol 4041 table. */ 4042 if (h->dynindx == -1) 4043 { 4044 switch (ELF_ST_VISIBILITY (h->other)) 4045 { 4046 case STV_INTERNAL: 4047 case STV_HIDDEN: 4048 _bfd_mips_elf_hide_symbol (info, h, TRUE); 4049 break; 4050 } 4051 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 4052 return FALSE; 4053 } 4054 4055 tls_type = mips_elf_reloc_tls_type (r_type); 4056 if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL) 4057 hmips->global_got_area = GGA_NORMAL; 4058 4059 entry.abfd = abfd; 4060 entry.symndx = -1; 4061 entry.d.h = (struct mips_elf_link_hash_entry *) h; 4062 entry.tls_type = tls_type; 4063 return mips_elf_record_got_entry (info, abfd, &entry); 4064 } 4065 4066 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND, 4067 where SYMNDX is a local symbol. Reserve a GOT entry for it. */ 4068 4069 static bfd_boolean 4070 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend, 4071 struct bfd_link_info *info, int r_type) 4072 { 4073 struct mips_elf_link_hash_table *htab; 4074 struct mips_got_info *g; 4075 struct mips_got_entry entry; 4076 4077 htab = mips_elf_hash_table (info); 4078 BFD_ASSERT (htab != NULL); 4079 4080 g = htab->got_info; 4081 BFD_ASSERT (g != NULL); 4082 4083 entry.abfd = abfd; 4084 entry.symndx = symndx; 4085 entry.d.addend = addend; 4086 entry.tls_type = mips_elf_reloc_tls_type (r_type); 4087 return mips_elf_record_got_entry (info, abfd, &entry); 4088 } 4089 4090 /* Record that ABFD has a page relocation against SYMNDX + ADDEND. 4091 H is the symbol's hash table entry, or null if SYMNDX is local 4092 to ABFD. */ 4093 4094 static bfd_boolean 4095 mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd, 4096 long symndx, struct elf_link_hash_entry *h, 4097 bfd_signed_vma addend) 4098 { 4099 struct mips_elf_link_hash_table *htab; 4100 struct mips_got_info *g1, *g2; 4101 struct mips_got_page_ref lookup, *entry; 4102 void **loc, **bfd_loc; 4103 4104 htab = mips_elf_hash_table (info); 4105 BFD_ASSERT (htab != NULL); 4106 4107 g1 = htab->got_info; 4108 BFD_ASSERT (g1 != NULL); 4109 4110 if (h) 4111 { 4112 lookup.symndx = -1; 4113 lookup.u.h = (struct mips_elf_link_hash_entry *) h; 4114 } 4115 else 4116 { 4117 lookup.symndx = symndx; 4118 lookup.u.abfd = abfd; 4119 } 4120 lookup.addend = addend; 4121 loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT); 4122 if (loc == NULL) 4123 return FALSE; 4124 4125 entry = (struct mips_got_page_ref *) *loc; 4126 if (!entry) 4127 { 4128 entry = bfd_alloc (abfd, sizeof (*entry)); 4129 if (!entry) 4130 return FALSE; 4131 4132 *entry = lookup; 4133 *loc = entry; 4134 } 4135 4136 /* Add the same entry to the BFD's GOT. */ 4137 g2 = mips_elf_bfd_got (abfd, TRUE); 4138 if (!g2) 4139 return FALSE; 4140 4141 bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT); 4142 if (!bfd_loc) 4143 return FALSE; 4144 4145 if (!*bfd_loc) 4146 *bfd_loc = entry; 4147 4148 return TRUE; 4149 } 4150 4151 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */ 4152 4153 static void 4154 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info, 4155 unsigned int n) 4156 { 4157 asection *s; 4158 struct mips_elf_link_hash_table *htab; 4159 4160 htab = mips_elf_hash_table (info); 4161 BFD_ASSERT (htab != NULL); 4162 4163 s = mips_elf_rel_dyn_section (info, FALSE); 4164 BFD_ASSERT (s != NULL); 4165 4166 if (htab->root.target_os == is_vxworks) 4167 s->size += n * MIPS_ELF_RELA_SIZE (abfd); 4168 else 4169 { 4170 if (s->size == 0) 4171 { 4172 /* Make room for a null element. */ 4173 s->size += MIPS_ELF_REL_SIZE (abfd); 4174 ++s->reloc_count; 4175 } 4176 s->size += n * MIPS_ELF_REL_SIZE (abfd); 4177 } 4178 } 4179 4180 /* A htab_traverse callback for GOT entries, with DATA pointing to a 4181 mips_elf_traverse_got_arg structure. Count the number of GOT 4182 entries and TLS relocs. Set DATA->value to true if we need 4183 to resolve indirect or warning symbols and then recreate the GOT. */ 4184 4185 static int 4186 mips_elf_check_recreate_got (void **entryp, void *data) 4187 { 4188 struct mips_got_entry *entry; 4189 struct mips_elf_traverse_got_arg *arg; 4190 4191 entry = (struct mips_got_entry *) *entryp; 4192 arg = (struct mips_elf_traverse_got_arg *) data; 4193 if (entry->abfd != NULL && entry->symndx == -1) 4194 { 4195 struct mips_elf_link_hash_entry *h; 4196 4197 h = entry->d.h; 4198 if (h->root.root.type == bfd_link_hash_indirect 4199 || h->root.root.type == bfd_link_hash_warning) 4200 { 4201 arg->value = TRUE; 4202 return 0; 4203 } 4204 } 4205 mips_elf_count_got_entry (arg->info, arg->g, entry); 4206 return 1; 4207 } 4208 4209 /* A htab_traverse callback for GOT entries, with DATA pointing to a 4210 mips_elf_traverse_got_arg structure. Add all entries to DATA->g, 4211 converting entries for indirect and warning symbols into entries 4212 for the target symbol. Set DATA->g to null on error. */ 4213 4214 static int 4215 mips_elf_recreate_got (void **entryp, void *data) 4216 { 4217 struct mips_got_entry new_entry, *entry; 4218 struct mips_elf_traverse_got_arg *arg; 4219 void **slot; 4220 4221 entry = (struct mips_got_entry *) *entryp; 4222 arg = (struct mips_elf_traverse_got_arg *) data; 4223 if (entry->abfd != NULL 4224 && entry->symndx == -1 4225 && (entry->d.h->root.root.type == bfd_link_hash_indirect 4226 || entry->d.h->root.root.type == bfd_link_hash_warning)) 4227 { 4228 struct mips_elf_link_hash_entry *h; 4229 4230 new_entry = *entry; 4231 entry = &new_entry; 4232 h = entry->d.h; 4233 do 4234 { 4235 BFD_ASSERT (h->global_got_area == GGA_NONE); 4236 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 4237 } 4238 while (h->root.root.type == bfd_link_hash_indirect 4239 || h->root.root.type == bfd_link_hash_warning); 4240 entry->d.h = h; 4241 } 4242 slot = htab_find_slot (arg->g->got_entries, entry, INSERT); 4243 if (slot == NULL) 4244 { 4245 arg->g = NULL; 4246 return 0; 4247 } 4248 if (*slot == NULL) 4249 { 4250 if (entry == &new_entry) 4251 { 4252 entry = bfd_alloc (entry->abfd, sizeof (*entry)); 4253 if (!entry) 4254 { 4255 arg->g = NULL; 4256 return 0; 4257 } 4258 *entry = new_entry; 4259 } 4260 *slot = entry; 4261 mips_elf_count_got_entry (arg->info, arg->g, entry); 4262 } 4263 return 1; 4264 } 4265 4266 /* Return the maximum number of GOT page entries required for RANGE. */ 4267 4268 static bfd_vma 4269 mips_elf_pages_for_range (const struct mips_got_page_range *range) 4270 { 4271 return (range->max_addend - range->min_addend + 0x1ffff) >> 16; 4272 } 4273 4274 /* Record that G requires a page entry that can reach SEC + ADDEND. */ 4275 4276 static bfd_boolean 4277 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg, 4278 asection *sec, bfd_signed_vma addend) 4279 { 4280 struct mips_got_info *g = arg->g; 4281 struct mips_got_page_entry lookup, *entry; 4282 struct mips_got_page_range **range_ptr, *range; 4283 bfd_vma old_pages, new_pages; 4284 void **loc; 4285 4286 /* Find the mips_got_page_entry hash table entry for this section. */ 4287 lookup.sec = sec; 4288 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT); 4289 if (loc == NULL) 4290 return FALSE; 4291 4292 /* Create a mips_got_page_entry if this is the first time we've 4293 seen the section. */ 4294 entry = (struct mips_got_page_entry *) *loc; 4295 if (!entry) 4296 { 4297 entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry)); 4298 if (!entry) 4299 return FALSE; 4300 4301 entry->sec = sec; 4302 *loc = entry; 4303 } 4304 4305 /* Skip over ranges whose maximum extent cannot share a page entry 4306 with ADDEND. */ 4307 range_ptr = &entry->ranges; 4308 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff) 4309 range_ptr = &(*range_ptr)->next; 4310 4311 /* If we scanned to the end of the list, or found a range whose 4312 minimum extent cannot share a page entry with ADDEND, create 4313 a new singleton range. */ 4314 range = *range_ptr; 4315 if (!range || addend < range->min_addend - 0xffff) 4316 { 4317 range = bfd_zalloc (arg->info->output_bfd, sizeof (*range)); 4318 if (!range) 4319 return FALSE; 4320 4321 range->next = *range_ptr; 4322 range->min_addend = addend; 4323 range->max_addend = addend; 4324 4325 *range_ptr = range; 4326 entry->num_pages++; 4327 g->page_gotno++; 4328 return TRUE; 4329 } 4330 4331 /* Remember how many pages the old range contributed. */ 4332 old_pages = mips_elf_pages_for_range (range); 4333 4334 /* Update the ranges. */ 4335 if (addend < range->min_addend) 4336 range->min_addend = addend; 4337 else if (addend > range->max_addend) 4338 { 4339 if (range->next && addend >= range->next->min_addend - 0xffff) 4340 { 4341 old_pages += mips_elf_pages_for_range (range->next); 4342 range->max_addend = range->next->max_addend; 4343 range->next = range->next->next; 4344 } 4345 else 4346 range->max_addend = addend; 4347 } 4348 4349 /* Record any change in the total estimate. */ 4350 new_pages = mips_elf_pages_for_range (range); 4351 if (old_pages != new_pages) 4352 { 4353 entry->num_pages += new_pages - old_pages; 4354 g->page_gotno += new_pages - old_pages; 4355 } 4356 4357 return TRUE; 4358 } 4359 4360 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref 4361 and for which DATA points to a mips_elf_traverse_got_arg. Work out 4362 whether the page reference described by *REFP needs a GOT page entry, 4363 and record that entry in DATA->g if so. Set DATA->g to null on failure. */ 4364 4365 static bfd_boolean 4366 mips_elf_resolve_got_page_ref (void **refp, void *data) 4367 { 4368 struct mips_got_page_ref *ref; 4369 struct mips_elf_traverse_got_arg *arg; 4370 struct mips_elf_link_hash_table *htab; 4371 asection *sec; 4372 bfd_vma addend; 4373 4374 ref = (struct mips_got_page_ref *) *refp; 4375 arg = (struct mips_elf_traverse_got_arg *) data; 4376 htab = mips_elf_hash_table (arg->info); 4377 4378 if (ref->symndx < 0) 4379 { 4380 struct mips_elf_link_hash_entry *h; 4381 4382 /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries. */ 4383 h = ref->u.h; 4384 if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root)) 4385 return 1; 4386 4387 /* Ignore undefined symbols; we'll issue an error later if 4388 appropriate. */ 4389 if (!((h->root.root.type == bfd_link_hash_defined 4390 || h->root.root.type == bfd_link_hash_defweak) 4391 && h->root.root.u.def.section)) 4392 return 1; 4393 4394 sec = h->root.root.u.def.section; 4395 addend = h->root.root.u.def.value + ref->addend; 4396 } 4397 else 4398 { 4399 Elf_Internal_Sym *isym; 4400 4401 /* Read in the symbol. */ 4402 isym = bfd_sym_from_r_symndx (&htab->root.sym_cache, ref->u.abfd, 4403 ref->symndx); 4404 if (isym == NULL) 4405 { 4406 arg->g = NULL; 4407 return 0; 4408 } 4409 4410 /* Get the associated input section. */ 4411 sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx); 4412 if (sec == NULL) 4413 { 4414 arg->g = NULL; 4415 return 0; 4416 } 4417 4418 /* If this is a mergable section, work out the section and offset 4419 of the merged data. For section symbols, the addend specifies 4420 of the offset _of_ the first byte in the data, otherwise it 4421 specifies the offset _from_ the first byte. */ 4422 if (sec->flags & SEC_MERGE) 4423 { 4424 void *secinfo; 4425 4426 secinfo = elf_section_data (sec)->sec_info; 4427 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION) 4428 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo, 4429 isym->st_value + ref->addend); 4430 else 4431 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo, 4432 isym->st_value) + ref->addend; 4433 } 4434 else 4435 addend = isym->st_value + ref->addend; 4436 } 4437 if (!mips_elf_record_got_page_entry (arg, sec, addend)) 4438 { 4439 arg->g = NULL; 4440 return 0; 4441 } 4442 return 1; 4443 } 4444 4445 /* If any entries in G->got_entries are for indirect or warning symbols, 4446 replace them with entries for the target symbol. Convert g->got_page_refs 4447 into got_page_entry structures and estimate the number of page entries 4448 that they require. */ 4449 4450 static bfd_boolean 4451 mips_elf_resolve_final_got_entries (struct bfd_link_info *info, 4452 struct mips_got_info *g) 4453 { 4454 struct mips_elf_traverse_got_arg tga; 4455 struct mips_got_info oldg; 4456 4457 oldg = *g; 4458 4459 tga.info = info; 4460 tga.g = g; 4461 tga.value = FALSE; 4462 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga); 4463 if (tga.value) 4464 { 4465 *g = oldg; 4466 g->got_entries = htab_create (htab_size (oldg.got_entries), 4467 mips_elf_got_entry_hash, 4468 mips_elf_got_entry_eq, NULL); 4469 if (!g->got_entries) 4470 return FALSE; 4471 4472 htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga); 4473 if (!tga.g) 4474 return FALSE; 4475 4476 htab_delete (oldg.got_entries); 4477 } 4478 4479 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash, 4480 mips_got_page_entry_eq, NULL); 4481 if (g->got_page_entries == NULL) 4482 return FALSE; 4483 4484 tga.info = info; 4485 tga.g = g; 4486 htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga); 4487 4488 return TRUE; 4489 } 4490 4491 /* Return true if a GOT entry for H should live in the local rather than 4492 global GOT area. */ 4493 4494 static bfd_boolean 4495 mips_use_local_got_p (struct bfd_link_info *info, 4496 struct mips_elf_link_hash_entry *h) 4497 { 4498 /* Symbols that aren't in the dynamic symbol table must live in the 4499 local GOT. This includes symbols that are completely undefined 4500 and which therefore don't bind locally. We'll report undefined 4501 symbols later if appropriate. */ 4502 if (h->root.dynindx == -1) 4503 return TRUE; 4504 4505 /* Absolute symbols, if ever they need a GOT entry, cannot ever go 4506 to the local GOT, as they would be implicitly relocated by the 4507 base address by the dynamic loader. */ 4508 if (bfd_is_abs_symbol (&h->root.root)) 4509 return FALSE; 4510 4511 /* Symbols that bind locally can (and in the case of forced-local 4512 symbols, must) live in the local GOT. */ 4513 if (h->got_only_for_calls 4514 ? SYMBOL_CALLS_LOCAL (info, &h->root) 4515 : SYMBOL_REFERENCES_LOCAL (info, &h->root)) 4516 return TRUE; 4517 4518 /* If this is an executable that must provide a definition of the symbol, 4519 either though PLTs or copy relocations, then that address should go in 4520 the local rather than global GOT. */ 4521 if (bfd_link_executable (info) && h->has_static_relocs) 4522 return TRUE; 4523 4524 return FALSE; 4525 } 4526 4527 /* A mips_elf_link_hash_traverse callback for which DATA points to the 4528 link_info structure. Decide whether the hash entry needs an entry in 4529 the global part of the primary GOT, setting global_got_area accordingly. 4530 Count the number of global symbols that are in the primary GOT only 4531 because they have relocations against them (reloc_only_gotno). */ 4532 4533 static int 4534 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data) 4535 { 4536 struct bfd_link_info *info; 4537 struct mips_elf_link_hash_table *htab; 4538 struct mips_got_info *g; 4539 4540 info = (struct bfd_link_info *) data; 4541 htab = mips_elf_hash_table (info); 4542 g = htab->got_info; 4543 if (h->global_got_area != GGA_NONE) 4544 { 4545 /* Make a final decision about whether the symbol belongs in the 4546 local or global GOT. */ 4547 if (mips_use_local_got_p (info, h)) 4548 /* The symbol belongs in the local GOT. We no longer need this 4549 entry if it was only used for relocations; those relocations 4550 will be against the null or section symbol instead of H. */ 4551 h->global_got_area = GGA_NONE; 4552 else if (htab->root.target_os == is_vxworks 4553 && h->got_only_for_calls 4554 && h->root.plt.plist->mips_offset != MINUS_ONE) 4555 /* On VxWorks, calls can refer directly to the .got.plt entry; 4556 they don't need entries in the regular GOT. .got.plt entries 4557 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */ 4558 h->global_got_area = GGA_NONE; 4559 else if (h->global_got_area == GGA_RELOC_ONLY) 4560 { 4561 g->reloc_only_gotno++; 4562 g->global_gotno++; 4563 } 4564 } 4565 return 1; 4566 } 4567 4568 /* A htab_traverse callback for GOT entries. Add each one to the GOT 4569 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */ 4570 4571 static int 4572 mips_elf_add_got_entry (void **entryp, void *data) 4573 { 4574 struct mips_got_entry *entry; 4575 struct mips_elf_traverse_got_arg *arg; 4576 void **slot; 4577 4578 entry = (struct mips_got_entry *) *entryp; 4579 arg = (struct mips_elf_traverse_got_arg *) data; 4580 slot = htab_find_slot (arg->g->got_entries, entry, INSERT); 4581 if (!slot) 4582 { 4583 arg->g = NULL; 4584 return 0; 4585 } 4586 if (!*slot) 4587 { 4588 *slot = entry; 4589 mips_elf_count_got_entry (arg->info, arg->g, entry); 4590 } 4591 return 1; 4592 } 4593 4594 /* A htab_traverse callback for GOT page entries. Add each one to the GOT 4595 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */ 4596 4597 static int 4598 mips_elf_add_got_page_entry (void **entryp, void *data) 4599 { 4600 struct mips_got_page_entry *entry; 4601 struct mips_elf_traverse_got_arg *arg; 4602 void **slot; 4603 4604 entry = (struct mips_got_page_entry *) *entryp; 4605 arg = (struct mips_elf_traverse_got_arg *) data; 4606 slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT); 4607 if (!slot) 4608 { 4609 arg->g = NULL; 4610 return 0; 4611 } 4612 if (!*slot) 4613 { 4614 *slot = entry; 4615 arg->g->page_gotno += entry->num_pages; 4616 } 4617 return 1; 4618 } 4619 4620 /* Consider merging FROM, which is ABFD's GOT, into TO. Return -1 if 4621 this would lead to overflow, 1 if they were merged successfully, 4622 and 0 if a merge failed due to lack of memory. (These values are chosen 4623 so that nonnegative return values can be returned by a htab_traverse 4624 callback.) */ 4625 4626 static int 4627 mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from, 4628 struct mips_got_info *to, 4629 struct mips_elf_got_per_bfd_arg *arg) 4630 { 4631 struct mips_elf_traverse_got_arg tga; 4632 unsigned int estimate; 4633 4634 /* Work out how many page entries we would need for the combined GOT. */ 4635 estimate = arg->max_pages; 4636 if (estimate >= from->page_gotno + to->page_gotno) 4637 estimate = from->page_gotno + to->page_gotno; 4638 4639 /* And conservatively estimate how many local and TLS entries 4640 would be needed. */ 4641 estimate += from->local_gotno + to->local_gotno; 4642 estimate += from->tls_gotno + to->tls_gotno; 4643 4644 /* If we're merging with the primary got, any TLS relocations will 4645 come after the full set of global entries. Otherwise estimate those 4646 conservatively as well. */ 4647 if (to == arg->primary && from->tls_gotno + to->tls_gotno) 4648 estimate += arg->global_count; 4649 else 4650 estimate += from->global_gotno + to->global_gotno; 4651 4652 /* Bail out if the combined GOT might be too big. */ 4653 if (estimate > arg->max_count) 4654 return -1; 4655 4656 /* Transfer the bfd's got information from FROM to TO. */ 4657 tga.info = arg->info; 4658 tga.g = to; 4659 htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga); 4660 if (!tga.g) 4661 return 0; 4662 4663 htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga); 4664 if (!tga.g) 4665 return 0; 4666 4667 mips_elf_replace_bfd_got (abfd, to); 4668 return 1; 4669 } 4670 4671 /* Attempt to merge GOT G, which belongs to ABFD. Try to use as much 4672 as possible of the primary got, since it doesn't require explicit 4673 dynamic relocations, but don't use bfds that would reference global 4674 symbols out of the addressable range. Failing the primary got, 4675 attempt to merge with the current got, or finish the current got 4676 and then make make the new got current. */ 4677 4678 static bfd_boolean 4679 mips_elf_merge_got (bfd *abfd, struct mips_got_info *g, 4680 struct mips_elf_got_per_bfd_arg *arg) 4681 { 4682 unsigned int estimate; 4683 int result; 4684 4685 if (!mips_elf_resolve_final_got_entries (arg->info, g)) 4686 return FALSE; 4687 4688 /* Work out the number of page, local and TLS entries. */ 4689 estimate = arg->max_pages; 4690 if (estimate > g->page_gotno) 4691 estimate = g->page_gotno; 4692 estimate += g->local_gotno + g->tls_gotno; 4693 4694 /* We place TLS GOT entries after both locals and globals. The globals 4695 for the primary GOT may overflow the normal GOT size limit, so be 4696 sure not to merge a GOT which requires TLS with the primary GOT in that 4697 case. This doesn't affect non-primary GOTs. */ 4698 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno); 4699 4700 if (estimate <= arg->max_count) 4701 { 4702 /* If we don't have a primary GOT, use it as 4703 a starting point for the primary GOT. */ 4704 if (!arg->primary) 4705 { 4706 arg->primary = g; 4707 return TRUE; 4708 } 4709 4710 /* Try merging with the primary GOT. */ 4711 result = mips_elf_merge_got_with (abfd, g, arg->primary, arg); 4712 if (result >= 0) 4713 return result; 4714 } 4715 4716 /* If we can merge with the last-created got, do it. */ 4717 if (arg->current) 4718 { 4719 result = mips_elf_merge_got_with (abfd, g, arg->current, arg); 4720 if (result >= 0) 4721 return result; 4722 } 4723 4724 /* Well, we couldn't merge, so create a new GOT. Don't check if it 4725 fits; if it turns out that it doesn't, we'll get relocation 4726 overflows anyway. */ 4727 g->next = arg->current; 4728 arg->current = g; 4729 4730 return TRUE; 4731 } 4732 4733 /* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx 4734 to GOTIDX, duplicating the entry if it has already been assigned 4735 an index in a different GOT. */ 4736 4737 static bfd_boolean 4738 mips_elf_set_gotidx (void **entryp, long gotidx) 4739 { 4740 struct mips_got_entry *entry; 4741 4742 entry = (struct mips_got_entry *) *entryp; 4743 if (entry->gotidx > 0) 4744 { 4745 struct mips_got_entry *new_entry; 4746 4747 new_entry = bfd_alloc (entry->abfd, sizeof (*entry)); 4748 if (!new_entry) 4749 return FALSE; 4750 4751 *new_entry = *entry; 4752 *entryp = new_entry; 4753 entry = new_entry; 4754 } 4755 entry->gotidx = gotidx; 4756 return TRUE; 4757 } 4758 4759 /* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a 4760 mips_elf_traverse_got_arg in which DATA->value is the size of one 4761 GOT entry. Set DATA->g to null on failure. */ 4762 4763 static int 4764 mips_elf_initialize_tls_index (void **entryp, void *data) 4765 { 4766 struct mips_got_entry *entry; 4767 struct mips_elf_traverse_got_arg *arg; 4768 4769 /* We're only interested in TLS symbols. */ 4770 entry = (struct mips_got_entry *) *entryp; 4771 if (entry->tls_type == GOT_TLS_NONE) 4772 return 1; 4773 4774 arg = (struct mips_elf_traverse_got_arg *) data; 4775 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno)) 4776 { 4777 arg->g = NULL; 4778 return 0; 4779 } 4780 4781 /* Account for the entries we've just allocated. */ 4782 arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type); 4783 return 1; 4784 } 4785 4786 /* A htab_traverse callback for GOT entries, where DATA points to a 4787 mips_elf_traverse_got_arg. Set the global_got_area of each global 4788 symbol to DATA->value. */ 4789 4790 static int 4791 mips_elf_set_global_got_area (void **entryp, void *data) 4792 { 4793 struct mips_got_entry *entry; 4794 struct mips_elf_traverse_got_arg *arg; 4795 4796 entry = (struct mips_got_entry *) *entryp; 4797 arg = (struct mips_elf_traverse_got_arg *) data; 4798 if (entry->abfd != NULL 4799 && entry->symndx == -1 4800 && entry->d.h->global_got_area != GGA_NONE) 4801 entry->d.h->global_got_area = arg->value; 4802 return 1; 4803 } 4804 4805 /* A htab_traverse callback for secondary GOT entries, where DATA points 4806 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries 4807 and record the number of relocations they require. DATA->value is 4808 the size of one GOT entry. Set DATA->g to null on failure. */ 4809 4810 static int 4811 mips_elf_set_global_gotidx (void **entryp, void *data) 4812 { 4813 struct mips_got_entry *entry; 4814 struct mips_elf_traverse_got_arg *arg; 4815 4816 entry = (struct mips_got_entry *) *entryp; 4817 arg = (struct mips_elf_traverse_got_arg *) data; 4818 if (entry->abfd != NULL 4819 && entry->symndx == -1 4820 && entry->d.h->global_got_area != GGA_NONE) 4821 { 4822 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno)) 4823 { 4824 arg->g = NULL; 4825 return 0; 4826 } 4827 arg->g->assigned_low_gotno += 1; 4828 4829 if (bfd_link_pic (arg->info) 4830 || (elf_hash_table (arg->info)->dynamic_sections_created 4831 && entry->d.h->root.def_dynamic 4832 && !entry->d.h->root.def_regular)) 4833 arg->g->relocs += 1; 4834 } 4835 4836 return 1; 4837 } 4838 4839 /* A htab_traverse callback for GOT entries for which DATA is the 4840 bfd_link_info. Forbid any global symbols from having traditional 4841 lazy-binding stubs. */ 4842 4843 static int 4844 mips_elf_forbid_lazy_stubs (void **entryp, void *data) 4845 { 4846 struct bfd_link_info *info; 4847 struct mips_elf_link_hash_table *htab; 4848 struct mips_got_entry *entry; 4849 4850 entry = (struct mips_got_entry *) *entryp; 4851 info = (struct bfd_link_info *) data; 4852 htab = mips_elf_hash_table (info); 4853 BFD_ASSERT (htab != NULL); 4854 4855 if (entry->abfd != NULL 4856 && entry->symndx == -1 4857 && entry->d.h->needs_lazy_stub) 4858 { 4859 entry->d.h->needs_lazy_stub = FALSE; 4860 htab->lazy_stub_count--; 4861 } 4862 4863 return 1; 4864 } 4865 4866 /* Return the offset of an input bfd IBFD's GOT from the beginning of 4867 the primary GOT. */ 4868 static bfd_vma 4869 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd) 4870 { 4871 if (!g->next) 4872 return 0; 4873 4874 g = mips_elf_bfd_got (ibfd, FALSE); 4875 if (! g) 4876 return 0; 4877 4878 BFD_ASSERT (g->next); 4879 4880 g = g->next; 4881 4882 return (g->local_gotno + g->global_gotno + g->tls_gotno) 4883 * MIPS_ELF_GOT_SIZE (abfd); 4884 } 4885 4886 /* Turn a single GOT that is too big for 16-bit addressing into 4887 a sequence of GOTs, each one 16-bit addressable. */ 4888 4889 static bfd_boolean 4890 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info, 4891 asection *got, bfd_size_type pages) 4892 { 4893 struct mips_elf_link_hash_table *htab; 4894 struct mips_elf_got_per_bfd_arg got_per_bfd_arg; 4895 struct mips_elf_traverse_got_arg tga; 4896 struct mips_got_info *g, *gg; 4897 unsigned int assign, needed_relocs; 4898 bfd *dynobj, *ibfd; 4899 4900 dynobj = elf_hash_table (info)->dynobj; 4901 htab = mips_elf_hash_table (info); 4902 BFD_ASSERT (htab != NULL); 4903 4904 g = htab->got_info; 4905 4906 got_per_bfd_arg.obfd = abfd; 4907 got_per_bfd_arg.info = info; 4908 got_per_bfd_arg.current = NULL; 4909 got_per_bfd_arg.primary = NULL; 4910 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info) 4911 / MIPS_ELF_GOT_SIZE (abfd)) 4912 - htab->reserved_gotno); 4913 got_per_bfd_arg.max_pages = pages; 4914 /* The number of globals that will be included in the primary GOT. 4915 See the calls to mips_elf_set_global_got_area below for more 4916 information. */ 4917 got_per_bfd_arg.global_count = g->global_gotno; 4918 4919 /* Try to merge the GOTs of input bfds together, as long as they 4920 don't seem to exceed the maximum GOT size, choosing one of them 4921 to be the primary GOT. */ 4922 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 4923 { 4924 gg = mips_elf_bfd_got (ibfd, FALSE); 4925 if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg)) 4926 return FALSE; 4927 } 4928 4929 /* If we do not find any suitable primary GOT, create an empty one. */ 4930 if (got_per_bfd_arg.primary == NULL) 4931 g->next = mips_elf_create_got_info (abfd); 4932 else 4933 g->next = got_per_bfd_arg.primary; 4934 g->next->next = got_per_bfd_arg.current; 4935 4936 /* GG is now the master GOT, and G is the primary GOT. */ 4937 gg = g; 4938 g = g->next; 4939 4940 /* Map the output bfd to the primary got. That's what we're going 4941 to use for bfds that use GOT16 or GOT_PAGE relocations that we 4942 didn't mark in check_relocs, and we want a quick way to find it. 4943 We can't just use gg->next because we're going to reverse the 4944 list. */ 4945 mips_elf_replace_bfd_got (abfd, g); 4946 4947 /* Every symbol that is referenced in a dynamic relocation must be 4948 present in the primary GOT, so arrange for them to appear after 4949 those that are actually referenced. */ 4950 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno; 4951 g->global_gotno = gg->global_gotno; 4952 4953 tga.info = info; 4954 tga.value = GGA_RELOC_ONLY; 4955 htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga); 4956 tga.value = GGA_NORMAL; 4957 htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga); 4958 4959 /* Now go through the GOTs assigning them offset ranges. 4960 [assigned_low_gotno, local_gotno[ will be set to the range of local 4961 entries in each GOT. We can then compute the end of a GOT by 4962 adding local_gotno to global_gotno. We reverse the list and make 4963 it circular since then we'll be able to quickly compute the 4964 beginning of a GOT, by computing the end of its predecessor. To 4965 avoid special cases for the primary GOT, while still preserving 4966 assertions that are valid for both single- and multi-got links, 4967 we arrange for the main got struct to have the right number of 4968 global entries, but set its local_gotno such that the initial 4969 offset of the primary GOT is zero. Remember that the primary GOT 4970 will become the last item in the circular linked list, so it 4971 points back to the master GOT. */ 4972 gg->local_gotno = -g->global_gotno; 4973 gg->global_gotno = g->global_gotno; 4974 gg->tls_gotno = 0; 4975 assign = 0; 4976 gg->next = gg; 4977 4978 do 4979 { 4980 struct mips_got_info *gn; 4981 4982 assign += htab->reserved_gotno; 4983 g->assigned_low_gotno = assign; 4984 g->local_gotno += assign; 4985 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno); 4986 g->assigned_high_gotno = g->local_gotno - 1; 4987 assign = g->local_gotno + g->global_gotno + g->tls_gotno; 4988 4989 /* Take g out of the direct list, and push it onto the reversed 4990 list that gg points to. g->next is guaranteed to be nonnull after 4991 this operation, as required by mips_elf_initialize_tls_index. */ 4992 gn = g->next; 4993 g->next = gg->next; 4994 gg->next = g; 4995 4996 /* Set up any TLS entries. We always place the TLS entries after 4997 all non-TLS entries. */ 4998 g->tls_assigned_gotno = g->local_gotno + g->global_gotno; 4999 tga.g = g; 5000 tga.value = MIPS_ELF_GOT_SIZE (abfd); 5001 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga); 5002 if (!tga.g) 5003 return FALSE; 5004 BFD_ASSERT (g->tls_assigned_gotno == assign); 5005 5006 /* Move onto the next GOT. It will be a secondary GOT if nonull. */ 5007 g = gn; 5008 5009 /* Forbid global symbols in every non-primary GOT from having 5010 lazy-binding stubs. */ 5011 if (g) 5012 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info); 5013 } 5014 while (g); 5015 5016 got->size = assign * MIPS_ELF_GOT_SIZE (abfd); 5017 5018 needed_relocs = 0; 5019 for (g = gg->next; g && g->next != gg; g = g->next) 5020 { 5021 unsigned int save_assign; 5022 5023 /* Assign offsets to global GOT entries and count how many 5024 relocations they need. */ 5025 save_assign = g->assigned_low_gotno; 5026 g->assigned_low_gotno = g->local_gotno; 5027 tga.info = info; 5028 tga.value = MIPS_ELF_GOT_SIZE (abfd); 5029 tga.g = g; 5030 htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga); 5031 if (!tga.g) 5032 return FALSE; 5033 BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno); 5034 g->assigned_low_gotno = save_assign; 5035 5036 if (bfd_link_pic (info)) 5037 { 5038 g->relocs += g->local_gotno - g->assigned_low_gotno; 5039 BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno 5040 + g->next->global_gotno 5041 + g->next->tls_gotno 5042 + htab->reserved_gotno); 5043 } 5044 needed_relocs += g->relocs; 5045 } 5046 needed_relocs += g->relocs; 5047 5048 if (needed_relocs) 5049 mips_elf_allocate_dynamic_relocations (dynobj, info, 5050 needed_relocs); 5051 5052 return TRUE; 5053 } 5054 5055 5056 /* Returns the first relocation of type r_type found, beginning with 5057 RELOCATION. RELEND is one-past-the-end of the relocation table. */ 5058 5059 static const Elf_Internal_Rela * 5060 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type, 5061 const Elf_Internal_Rela *relocation, 5062 const Elf_Internal_Rela *relend) 5063 { 5064 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info); 5065 5066 while (relocation < relend) 5067 { 5068 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type 5069 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx) 5070 return relocation; 5071 5072 ++relocation; 5073 } 5074 5075 /* We didn't find it. */ 5076 return NULL; 5077 } 5078 5079 /* Return whether an input relocation is against a local symbol. */ 5080 5081 static bfd_boolean 5082 mips_elf_local_relocation_p (bfd *input_bfd, 5083 const Elf_Internal_Rela *relocation, 5084 asection **local_sections) 5085 { 5086 unsigned long r_symndx; 5087 Elf_Internal_Shdr *symtab_hdr; 5088 size_t extsymoff; 5089 5090 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info); 5091 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 5092 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info; 5093 5094 if (r_symndx < extsymoff) 5095 return TRUE; 5096 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL) 5097 return TRUE; 5098 5099 return FALSE; 5100 } 5101 5102 /* Sign-extend VALUE, which has the indicated number of BITS. */ 5103 5104 bfd_vma 5105 _bfd_mips_elf_sign_extend (bfd_vma value, int bits) 5106 { 5107 if (value & ((bfd_vma) 1 << (bits - 1))) 5108 /* VALUE is negative. */ 5109 value |= ((bfd_vma) - 1) << bits; 5110 5111 return value; 5112 } 5113 5114 /* Return non-zero if the indicated VALUE has overflowed the maximum 5115 range expressible by a signed number with the indicated number of 5116 BITS. */ 5117 5118 static bfd_boolean 5119 mips_elf_overflow_p (bfd_vma value, int bits) 5120 { 5121 bfd_signed_vma svalue = (bfd_signed_vma) value; 5122 5123 if (svalue > (1 << (bits - 1)) - 1) 5124 /* The value is too big. */ 5125 return TRUE; 5126 else if (svalue < -(1 << (bits - 1))) 5127 /* The value is too small. */ 5128 return TRUE; 5129 5130 /* All is well. */ 5131 return FALSE; 5132 } 5133 5134 /* Calculate the %high function. */ 5135 5136 static bfd_vma 5137 mips_elf_high (bfd_vma value) 5138 { 5139 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff; 5140 } 5141 5142 /* Calculate the %higher function. */ 5143 5144 static bfd_vma 5145 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED) 5146 { 5147 #ifdef BFD64 5148 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff; 5149 #else 5150 abort (); 5151 return MINUS_ONE; 5152 #endif 5153 } 5154 5155 /* Calculate the %highest function. */ 5156 5157 static bfd_vma 5158 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED) 5159 { 5160 #ifdef BFD64 5161 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff; 5162 #else 5163 abort (); 5164 return MINUS_ONE; 5165 #endif 5166 } 5167 5168 /* Create the .compact_rel section. */ 5169 5170 static bfd_boolean 5171 mips_elf_create_compact_rel_section 5172 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED) 5173 { 5174 flagword flags; 5175 register asection *s; 5176 5177 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL) 5178 { 5179 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED 5180 | SEC_READONLY); 5181 5182 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags); 5183 if (s == NULL 5184 || !bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd))) 5185 return FALSE; 5186 5187 s->size = sizeof (Elf32_External_compact_rel); 5188 } 5189 5190 return TRUE; 5191 } 5192 5193 /* Create the .got section to hold the global offset table. */ 5194 5195 static bfd_boolean 5196 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 5197 { 5198 flagword flags; 5199 register asection *s; 5200 struct elf_link_hash_entry *h; 5201 struct bfd_link_hash_entry *bh; 5202 struct mips_elf_link_hash_table *htab; 5203 5204 htab = mips_elf_hash_table (info); 5205 BFD_ASSERT (htab != NULL); 5206 5207 /* This function may be called more than once. */ 5208 if (htab->root.sgot) 5209 return TRUE; 5210 5211 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 5212 | SEC_LINKER_CREATED); 5213 5214 /* We have to use an alignment of 2**4 here because this is hardcoded 5215 in the function stub generation and in the linker script. */ 5216 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 5217 if (s == NULL 5218 || !bfd_set_section_alignment (s, 4)) 5219 return FALSE; 5220 htab->root.sgot = s; 5221 5222 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the 5223 linker script because we don't want to define the symbol if we 5224 are not creating a global offset table. */ 5225 bh = NULL; 5226 if (! (_bfd_generic_link_add_one_symbol 5227 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, 5228 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 5229 return FALSE; 5230 5231 h = (struct elf_link_hash_entry *) bh; 5232 h->non_elf = 0; 5233 h->def_regular = 1; 5234 h->type = STT_OBJECT; 5235 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN; 5236 elf_hash_table (info)->hgot = h; 5237 5238 if (bfd_link_pic (info) 5239 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 5240 return FALSE; 5241 5242 htab->got_info = mips_elf_create_got_info (abfd); 5243 mips_elf_section_data (s)->elf.this_hdr.sh_flags 5244 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL; 5245 5246 /* We also need a .got.plt section when generating PLTs. */ 5247 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", 5248 SEC_ALLOC | SEC_LOAD 5249 | SEC_HAS_CONTENTS 5250 | SEC_IN_MEMORY 5251 | SEC_LINKER_CREATED); 5252 if (s == NULL) 5253 return FALSE; 5254 htab->root.sgotplt = s; 5255 5256 return TRUE; 5257 } 5258 5259 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or 5260 __GOTT_INDEX__ symbols. These symbols are only special for 5261 shared objects; they are not used in executables. */ 5262 5263 static bfd_boolean 5264 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h) 5265 { 5266 return (mips_elf_hash_table (info)->root.target_os == is_vxworks 5267 && bfd_link_pic (info) 5268 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0 5269 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0)); 5270 } 5271 5272 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might 5273 require an la25 stub. See also mips_elf_local_pic_function_p, 5274 which determines whether the destination function ever requires a 5275 stub. */ 5276 5277 static bfd_boolean 5278 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type, 5279 bfd_boolean target_is_16_bit_code_p) 5280 { 5281 /* We specifically ignore branches and jumps from EF_PIC objects, 5282 where the onus is on the compiler or programmer to perform any 5283 necessary initialization of $25. Sometimes such initialization 5284 is unnecessary; for example, -mno-shared functions do not use 5285 the incoming value of $25, and may therefore be called directly. */ 5286 if (PIC_OBJECT_P (input_bfd)) 5287 return FALSE; 5288 5289 switch (r_type) 5290 { 5291 case R_MIPS_26: 5292 case R_MIPS_PC16: 5293 case R_MIPS_PC21_S2: 5294 case R_MIPS_PC26_S2: 5295 case R_MICROMIPS_26_S1: 5296 case R_MICROMIPS_PC7_S1: 5297 case R_MICROMIPS_PC10_S1: 5298 case R_MICROMIPS_PC16_S1: 5299 case R_MICROMIPS_PC23_S2: 5300 return TRUE; 5301 5302 case R_MIPS16_26: 5303 return !target_is_16_bit_code_p; 5304 5305 default: 5306 return FALSE; 5307 } 5308 } 5309 5310 /* Obtain the field relocated by RELOCATION. */ 5311 5312 static bfd_vma 5313 mips_elf_obtain_contents (reloc_howto_type *howto, 5314 const Elf_Internal_Rela *relocation, 5315 bfd *input_bfd, bfd_byte *contents) 5316 { 5317 bfd_vma x = 0; 5318 bfd_byte *location = contents + relocation->r_offset; 5319 unsigned int size = bfd_get_reloc_size (howto); 5320 5321 /* Obtain the bytes. */ 5322 if (size != 0) 5323 x = bfd_get (8 * size, input_bfd, location); 5324 5325 return x; 5326 } 5327 5328 /* Store the field relocated by RELOCATION. */ 5329 5330 static void 5331 mips_elf_store_contents (reloc_howto_type *howto, 5332 const Elf_Internal_Rela *relocation, 5333 bfd *input_bfd, bfd_byte *contents, bfd_vma x) 5334 { 5335 bfd_byte *location = contents + relocation->r_offset; 5336 unsigned int size = bfd_get_reloc_size (howto); 5337 5338 /* Put the value into the output. */ 5339 if (size != 0) 5340 bfd_put (8 * size, input_bfd, x, location); 5341 } 5342 5343 /* Try to patch a load from GOT instruction in CONTENTS pointed to by 5344 RELOCATION described by HOWTO, with a move of 0 to the load target 5345 register, returning TRUE if that is successful and FALSE otherwise. 5346 If DOIT is FALSE, then only determine it patching is possible and 5347 return status without actually changing CONTENTS. 5348 */ 5349 5350 static bfd_boolean 5351 mips_elf_nullify_got_load (bfd *input_bfd, bfd_byte *contents, 5352 const Elf_Internal_Rela *relocation, 5353 reloc_howto_type *howto, bfd_boolean doit) 5354 { 5355 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info); 5356 bfd_byte *location = contents + relocation->r_offset; 5357 bfd_boolean nullified = TRUE; 5358 bfd_vma x; 5359 5360 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location); 5361 5362 /* Obtain the current value. */ 5363 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents); 5364 5365 /* Note that in the unshuffled MIPS16 encoding RX is at bits [21:19] 5366 while RY is at bits [18:16] of the combined 32-bit instruction word. */ 5367 if (mips16_reloc_p (r_type) 5368 && (((x >> 22) & 0x3ff) == 0x3d3 /* LW */ 5369 || ((x >> 22) & 0x3ff) == 0x3c7)) /* LD */ 5370 x = (0x3cdU << 22) | (x & (7 << 16)) << 3; /* LI */ 5371 else if (micromips_reloc_p (r_type) 5372 && ((x >> 26) & 0x37) == 0x37) /* LW/LD */ 5373 x = (0xc << 26) | (x & (0x1f << 21)); /* ADDIU */ 5374 else if (((x >> 26) & 0x3f) == 0x23 /* LW */ 5375 || ((x >> 26) & 0x3f) == 0x37) /* LD */ 5376 x = (0x9 << 26) | (x & (0x1f << 16)); /* ADDIU */ 5377 else 5378 nullified = FALSE; 5379 5380 /* Put the value into the output. */ 5381 if (doit && nullified) 5382 mips_elf_store_contents (howto, relocation, input_bfd, contents, x); 5383 5384 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, FALSE, location); 5385 5386 return nullified; 5387 } 5388 5389 /* Calculate the value produced by the RELOCATION (which comes from 5390 the INPUT_BFD). The ADDEND is the addend to use for this 5391 RELOCATION; RELOCATION->R_ADDEND is ignored. 5392 5393 The result of the relocation calculation is stored in VALUEP. 5394 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field 5395 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa. 5396 5397 This function returns bfd_reloc_continue if the caller need take no 5398 further action regarding this relocation, bfd_reloc_notsupported if 5399 something goes dramatically wrong, bfd_reloc_overflow if an 5400 overflow occurs, and bfd_reloc_ok to indicate success. */ 5401 5402 static bfd_reloc_status_type 5403 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd, 5404 asection *input_section, bfd_byte *contents, 5405 struct bfd_link_info *info, 5406 const Elf_Internal_Rela *relocation, 5407 bfd_vma addend, reloc_howto_type *howto, 5408 Elf_Internal_Sym *local_syms, 5409 asection **local_sections, bfd_vma *valuep, 5410 const char **namep, 5411 bfd_boolean *cross_mode_jump_p, 5412 bfd_boolean save_addend) 5413 { 5414 /* The eventual value we will return. */ 5415 bfd_vma value; 5416 /* The address of the symbol against which the relocation is 5417 occurring. */ 5418 bfd_vma symbol = 0; 5419 /* The final GP value to be used for the relocatable, executable, or 5420 shared object file being produced. */ 5421 bfd_vma gp; 5422 /* The place (section offset or address) of the storage unit being 5423 relocated. */ 5424 bfd_vma p; 5425 /* The value of GP used to create the relocatable object. */ 5426 bfd_vma gp0; 5427 /* The offset into the global offset table at which the address of 5428 the relocation entry symbol, adjusted by the addend, resides 5429 during execution. */ 5430 bfd_vma g = MINUS_ONE; 5431 /* The section in which the symbol referenced by the relocation is 5432 located. */ 5433 asection *sec = NULL; 5434 struct mips_elf_link_hash_entry *h = NULL; 5435 /* TRUE if the symbol referred to by this relocation is a local 5436 symbol. */ 5437 bfd_boolean local_p, was_local_p; 5438 /* TRUE if the symbol referred to by this relocation is a section 5439 symbol. */ 5440 bfd_boolean section_p = FALSE; 5441 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */ 5442 bfd_boolean gp_disp_p = FALSE; 5443 /* TRUE if the symbol referred to by this relocation is 5444 "__gnu_local_gp". */ 5445 bfd_boolean gnu_local_gp_p = FALSE; 5446 Elf_Internal_Shdr *symtab_hdr; 5447 size_t extsymoff; 5448 unsigned long r_symndx; 5449 int r_type; 5450 /* TRUE if overflow occurred during the calculation of the 5451 relocation value. */ 5452 bfd_boolean overflowed_p; 5453 /* TRUE if this relocation refers to a MIPS16 function. */ 5454 bfd_boolean target_is_16_bit_code_p = FALSE; 5455 bfd_boolean target_is_micromips_code_p = FALSE; 5456 struct mips_elf_link_hash_table *htab; 5457 bfd *dynobj; 5458 bfd_boolean resolved_to_zero; 5459 5460 dynobj = elf_hash_table (info)->dynobj; 5461 htab = mips_elf_hash_table (info); 5462 BFD_ASSERT (htab != NULL); 5463 5464 /* Parse the relocation. */ 5465 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info); 5466 r_type = ELF_R_TYPE (input_bfd, relocation->r_info); 5467 p = (input_section->output_section->vma 5468 + input_section->output_offset 5469 + relocation->r_offset); 5470 5471 /* Assume that there will be no overflow. */ 5472 overflowed_p = FALSE; 5473 5474 /* Figure out whether or not the symbol is local, and get the offset 5475 used in the array of hash table entries. */ 5476 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 5477 local_p = mips_elf_local_relocation_p (input_bfd, relocation, 5478 local_sections); 5479 was_local_p = local_p; 5480 if (! elf_bad_symtab (input_bfd)) 5481 extsymoff = symtab_hdr->sh_info; 5482 else 5483 { 5484 /* The symbol table does not follow the rule that local symbols 5485 must come before globals. */ 5486 extsymoff = 0; 5487 } 5488 5489 /* Figure out the value of the symbol. */ 5490 if (local_p) 5491 { 5492 bfd_boolean micromips_p = MICROMIPS_P (abfd); 5493 Elf_Internal_Sym *sym; 5494 5495 sym = local_syms + r_symndx; 5496 sec = local_sections[r_symndx]; 5497 5498 section_p = ELF_ST_TYPE (sym->st_info) == STT_SECTION; 5499 5500 symbol = sec->output_section->vma + sec->output_offset; 5501 if (!section_p || (sec->flags & SEC_MERGE)) 5502 symbol += sym->st_value; 5503 if ((sec->flags & SEC_MERGE) && section_p) 5504 { 5505 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend); 5506 addend -= symbol; 5507 addend += sec->output_section->vma + sec->output_offset; 5508 } 5509 5510 /* MIPS16/microMIPS text labels should be treated as odd. */ 5511 if (ELF_ST_IS_COMPRESSED (sym->st_other)) 5512 ++symbol; 5513 5514 /* Record the name of this symbol, for our caller. */ 5515 *namep = bfd_elf_string_from_elf_section (input_bfd, 5516 symtab_hdr->sh_link, 5517 sym->st_name); 5518 if (*namep == NULL || **namep == '\0') 5519 *namep = bfd_section_name (sec); 5520 5521 /* For relocations against a section symbol and ones against no 5522 symbol (absolute relocations) infer the ISA mode from the addend. */ 5523 if (section_p || r_symndx == STN_UNDEF) 5524 { 5525 target_is_16_bit_code_p = (addend & 1) && !micromips_p; 5526 target_is_micromips_code_p = (addend & 1) && micromips_p; 5527 } 5528 /* For relocations against an absolute symbol infer the ISA mode 5529 from the value of the symbol plus addend. */ 5530 else if (bfd_is_abs_section (sec)) 5531 { 5532 target_is_16_bit_code_p = ((symbol + addend) & 1) && !micromips_p; 5533 target_is_micromips_code_p = ((symbol + addend) & 1) && micromips_p; 5534 } 5535 /* Otherwise just use the regular symbol annotation available. */ 5536 else 5537 { 5538 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other); 5539 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other); 5540 } 5541 } 5542 else 5543 { 5544 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */ 5545 5546 /* For global symbols we look up the symbol in the hash-table. */ 5547 h = ((struct mips_elf_link_hash_entry *) 5548 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]); 5549 /* Find the real hash-table entry for this symbol. */ 5550 while (h->root.root.type == bfd_link_hash_indirect 5551 || h->root.root.type == bfd_link_hash_warning) 5552 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 5553 5554 /* Record the name of this symbol, for our caller. */ 5555 *namep = h->root.root.root.string; 5556 5557 /* See if this is the special _gp_disp symbol. Note that such a 5558 symbol must always be a global symbol. */ 5559 if (strcmp (*namep, "_gp_disp") == 0 5560 && ! NEWABI_P (input_bfd)) 5561 { 5562 /* Relocations against _gp_disp are permitted only with 5563 R_MIPS_HI16 and R_MIPS_LO16 relocations. */ 5564 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type)) 5565 return bfd_reloc_notsupported; 5566 5567 gp_disp_p = TRUE; 5568 } 5569 /* See if this is the special _gp symbol. Note that such a 5570 symbol must always be a global symbol. */ 5571 else if (strcmp (*namep, "__gnu_local_gp") == 0) 5572 gnu_local_gp_p = TRUE; 5573 5574 5575 /* If this symbol is defined, calculate its address. Note that 5576 _gp_disp is a magic symbol, always implicitly defined by the 5577 linker, so it's inappropriate to check to see whether or not 5578 its defined. */ 5579 else if ((h->root.root.type == bfd_link_hash_defined 5580 || h->root.root.type == bfd_link_hash_defweak) 5581 && h->root.root.u.def.section) 5582 { 5583 sec = h->root.root.u.def.section; 5584 if (sec->output_section) 5585 symbol = (h->root.root.u.def.value 5586 + sec->output_section->vma 5587 + sec->output_offset); 5588 else 5589 symbol = h->root.root.u.def.value; 5590 } 5591 else if (h->root.root.type == bfd_link_hash_undefweak) 5592 /* We allow relocations against undefined weak symbols, giving 5593 it the value zero, so that you can undefined weak functions 5594 and check to see if they exist by looking at their 5595 addresses. */ 5596 symbol = 0; 5597 else if (info->unresolved_syms_in_objects == RM_IGNORE 5598 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT) 5599 symbol = 0; 5600 else if (strcmp (*namep, SGI_COMPAT (input_bfd) 5601 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0) 5602 { 5603 /* If this is a dynamic link, we should have created a 5604 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol 5605 in _bfd_mips_elf_create_dynamic_sections. 5606 Otherwise, we should define the symbol with a value of 0. 5607 FIXME: It should probably get into the symbol table 5608 somehow as well. */ 5609 BFD_ASSERT (! bfd_link_pic (info)); 5610 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL); 5611 symbol = 0; 5612 } 5613 else if (ELF_MIPS_IS_OPTIONAL (h->root.other)) 5614 { 5615 /* This is an optional symbol - an Irix specific extension to the 5616 ELF spec. Ignore it for now. 5617 XXX - FIXME - there is more to the spec for OPTIONAL symbols 5618 than simply ignoring them, but we do not handle this for now. 5619 For information see the "64-bit ELF Object File Specification" 5620 which is available from here: 5621 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */ 5622 symbol = 0; 5623 } 5624 else 5625 { 5626 bfd_boolean reject_undefined 5627 = (info->unresolved_syms_in_objects == RM_DIAGNOSE 5628 && !info->warn_unresolved_syms) 5629 || ELF_ST_VISIBILITY (h->root.other) != STV_DEFAULT; 5630 5631 info->callbacks->undefined_symbol 5632 (info, h->root.root.root.string, input_bfd, 5633 input_section, relocation->r_offset, reject_undefined); 5634 5635 if (reject_undefined) 5636 return bfd_reloc_undefined; 5637 5638 symbol = 0; 5639 } 5640 5641 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other); 5642 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other); 5643 } 5644 5645 /* If this is a reference to a 16-bit function with a stub, we need 5646 to redirect the relocation to the stub unless: 5647 5648 (a) the relocation is for a MIPS16 JAL; 5649 5650 (b) the relocation is for a MIPS16 PIC call, and there are no 5651 non-MIPS16 uses of the GOT slot; or 5652 5653 (c) the section allows direct references to MIPS16 functions. */ 5654 if (r_type != R_MIPS16_26 5655 && !bfd_link_relocatable (info) 5656 && ((h != NULL 5657 && h->fn_stub != NULL 5658 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub)) 5659 || (local_p 5660 && mips_elf_tdata (input_bfd)->local_stubs != NULL 5661 && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL)) 5662 && !section_allows_mips16_refs_p (input_section)) 5663 { 5664 /* This is a 32- or 64-bit call to a 16-bit function. We should 5665 have already noticed that we were going to need the 5666 stub. */ 5667 if (local_p) 5668 { 5669 sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx]; 5670 value = 0; 5671 } 5672 else 5673 { 5674 BFD_ASSERT (h->need_fn_stub); 5675 if (h->la25_stub) 5676 { 5677 /* If a LA25 header for the stub itself exists, point to the 5678 prepended LUI/ADDIU sequence. */ 5679 sec = h->la25_stub->stub_section; 5680 value = h->la25_stub->offset; 5681 } 5682 else 5683 { 5684 sec = h->fn_stub; 5685 value = 0; 5686 } 5687 } 5688 5689 symbol = sec->output_section->vma + sec->output_offset + value; 5690 /* The target is 16-bit, but the stub isn't. */ 5691 target_is_16_bit_code_p = FALSE; 5692 } 5693 /* If this is a MIPS16 call with a stub, that is made through the PLT or 5694 to a standard MIPS function, we need to redirect the call to the stub. 5695 Note that we specifically exclude R_MIPS16_CALL16 from this behavior; 5696 indirect calls should use an indirect stub instead. */ 5697 else if (r_type == R_MIPS16_26 && !bfd_link_relocatable (info) 5698 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL)) 5699 || (local_p 5700 && mips_elf_tdata (input_bfd)->local_call_stubs != NULL 5701 && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL)) 5702 && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p)) 5703 { 5704 if (local_p) 5705 sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx]; 5706 else 5707 { 5708 /* If both call_stub and call_fp_stub are defined, we can figure 5709 out which one to use by checking which one appears in the input 5710 file. */ 5711 if (h->call_stub != NULL && h->call_fp_stub != NULL) 5712 { 5713 asection *o; 5714 5715 sec = NULL; 5716 for (o = input_bfd->sections; o != NULL; o = o->next) 5717 { 5718 if (CALL_FP_STUB_P (bfd_section_name (o))) 5719 { 5720 sec = h->call_fp_stub; 5721 break; 5722 } 5723 } 5724 if (sec == NULL) 5725 sec = h->call_stub; 5726 } 5727 else if (h->call_stub != NULL) 5728 sec = h->call_stub; 5729 else 5730 sec = h->call_fp_stub; 5731 } 5732 5733 BFD_ASSERT (sec->size > 0); 5734 symbol = sec->output_section->vma + sec->output_offset; 5735 } 5736 /* If this is a direct call to a PIC function, redirect to the 5737 non-PIC stub. */ 5738 else if (h != NULL && h->la25_stub 5739 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type, 5740 target_is_16_bit_code_p)) 5741 { 5742 symbol = (h->la25_stub->stub_section->output_section->vma 5743 + h->la25_stub->stub_section->output_offset 5744 + h->la25_stub->offset); 5745 if (ELF_ST_IS_MICROMIPS (h->root.other)) 5746 symbol |= 1; 5747 } 5748 /* For direct MIPS16 and microMIPS calls make sure the compressed PLT 5749 entry is used if a standard PLT entry has also been made. In this 5750 case the symbol will have been set by mips_elf_set_plt_sym_value 5751 to point to the standard PLT entry, so redirect to the compressed 5752 one. */ 5753 else if ((mips16_branch_reloc_p (r_type) 5754 || micromips_branch_reloc_p (r_type)) 5755 && !bfd_link_relocatable (info) 5756 && h != NULL 5757 && h->use_plt_entry 5758 && h->root.plt.plist->comp_offset != MINUS_ONE 5759 && h->root.plt.plist->mips_offset != MINUS_ONE) 5760 { 5761 bfd_boolean micromips_p = MICROMIPS_P (abfd); 5762 5763 sec = htab->root.splt; 5764 symbol = (sec->output_section->vma 5765 + sec->output_offset 5766 + htab->plt_header_size 5767 + htab->plt_mips_offset 5768 + h->root.plt.plist->comp_offset 5769 + 1); 5770 5771 target_is_16_bit_code_p = !micromips_p; 5772 target_is_micromips_code_p = micromips_p; 5773 } 5774 5775 /* Make sure MIPS16 and microMIPS are not used together. */ 5776 if ((mips16_branch_reloc_p (r_type) && target_is_micromips_code_p) 5777 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p)) 5778 { 5779 _bfd_error_handler 5780 (_("MIPS16 and microMIPS functions cannot call each other")); 5781 return bfd_reloc_notsupported; 5782 } 5783 5784 /* Calls from 16-bit code to 32-bit code and vice versa require the 5785 mode change. However, we can ignore calls to undefined weak symbols, 5786 which should never be executed at runtime. This exception is important 5787 because the assembly writer may have "known" that any definition of the 5788 symbol would be 16-bit code, and that direct jumps were therefore 5789 acceptable. */ 5790 *cross_mode_jump_p = (!bfd_link_relocatable (info) 5791 && !(h && h->root.root.type == bfd_link_hash_undefweak) 5792 && ((mips16_branch_reloc_p (r_type) 5793 && !target_is_16_bit_code_p) 5794 || (micromips_branch_reloc_p (r_type) 5795 && !target_is_micromips_code_p) 5796 || ((branch_reloc_p (r_type) 5797 || r_type == R_MIPS_JALR) 5798 && (target_is_16_bit_code_p 5799 || target_is_micromips_code_p)))); 5800 5801 resolved_to_zero = (h != NULL 5802 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->root)); 5803 5804 switch (r_type) 5805 { 5806 case R_MIPS16_CALL16: 5807 case R_MIPS16_GOT16: 5808 case R_MIPS_CALL16: 5809 case R_MIPS_GOT16: 5810 case R_MIPS_GOT_PAGE: 5811 case R_MIPS_GOT_DISP: 5812 case R_MIPS_GOT_LO16: 5813 case R_MIPS_CALL_LO16: 5814 case R_MICROMIPS_CALL16: 5815 case R_MICROMIPS_GOT16: 5816 case R_MICROMIPS_GOT_PAGE: 5817 case R_MICROMIPS_GOT_DISP: 5818 case R_MICROMIPS_GOT_LO16: 5819 case R_MICROMIPS_CALL_LO16: 5820 if (resolved_to_zero 5821 && !bfd_link_relocatable (info) 5822 && mips_elf_nullify_got_load (input_bfd, contents, 5823 relocation, howto, TRUE)) 5824 return bfd_reloc_continue; 5825 5826 /* Fall through. */ 5827 case R_MIPS_GOT_HI16: 5828 case R_MIPS_CALL_HI16: 5829 case R_MICROMIPS_GOT_HI16: 5830 case R_MICROMIPS_CALL_HI16: 5831 if (resolved_to_zero 5832 && htab->use_absolute_zero 5833 && bfd_link_pic (info)) 5834 { 5835 /* Redirect to the special `__gnu_absolute_zero' symbol. */ 5836 h = mips_elf_link_hash_lookup (htab, "__gnu_absolute_zero", 5837 FALSE, FALSE, FALSE); 5838 BFD_ASSERT (h != NULL); 5839 } 5840 break; 5841 } 5842 5843 local_p = (h == NULL || mips_use_local_got_p (info, h)); 5844 5845 gp0 = _bfd_get_gp_value (input_bfd); 5846 gp = _bfd_get_gp_value (abfd); 5847 if (htab->got_info) 5848 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd); 5849 5850 if (gnu_local_gp_p) 5851 symbol = gp; 5852 5853 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent 5854 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the 5855 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */ 5856 if (got_page_reloc_p (r_type) && !local_p) 5857 { 5858 r_type = (micromips_reloc_p (r_type) 5859 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP); 5860 addend = 0; 5861 } 5862 5863 /* If we haven't already determined the GOT offset, and we're going 5864 to need it, get it now. */ 5865 switch (r_type) 5866 { 5867 case R_MIPS16_CALL16: 5868 case R_MIPS16_GOT16: 5869 case R_MIPS_CALL16: 5870 case R_MIPS_GOT16: 5871 case R_MIPS_GOT_DISP: 5872 case R_MIPS_GOT_HI16: 5873 case R_MIPS_CALL_HI16: 5874 case R_MIPS_GOT_LO16: 5875 case R_MIPS_CALL_LO16: 5876 case R_MICROMIPS_CALL16: 5877 case R_MICROMIPS_GOT16: 5878 case R_MICROMIPS_GOT_DISP: 5879 case R_MICROMIPS_GOT_HI16: 5880 case R_MICROMIPS_CALL_HI16: 5881 case R_MICROMIPS_GOT_LO16: 5882 case R_MICROMIPS_CALL_LO16: 5883 case R_MIPS_TLS_GD: 5884 case R_MIPS_TLS_GOTTPREL: 5885 case R_MIPS_TLS_LDM: 5886 case R_MIPS16_TLS_GD: 5887 case R_MIPS16_TLS_GOTTPREL: 5888 case R_MIPS16_TLS_LDM: 5889 case R_MICROMIPS_TLS_GD: 5890 case R_MICROMIPS_TLS_GOTTPREL: 5891 case R_MICROMIPS_TLS_LDM: 5892 /* Find the index into the GOT where this value is located. */ 5893 if (tls_ldm_reloc_p (r_type)) 5894 { 5895 g = mips_elf_local_got_index (abfd, input_bfd, info, 5896 0, 0, NULL, r_type); 5897 if (g == MINUS_ONE) 5898 return bfd_reloc_outofrange; 5899 } 5900 else if (!local_p) 5901 { 5902 /* On VxWorks, CALL relocations should refer to the .got.plt 5903 entry, which is initialized to point at the PLT stub. */ 5904 if (htab->root.target_os == is_vxworks 5905 && (call_hi16_reloc_p (r_type) 5906 || call_lo16_reloc_p (r_type) 5907 || call16_reloc_p (r_type))) 5908 { 5909 BFD_ASSERT (addend == 0); 5910 BFD_ASSERT (h->root.needs_plt); 5911 g = mips_elf_gotplt_index (info, &h->root); 5912 } 5913 else 5914 { 5915 BFD_ASSERT (addend == 0); 5916 g = mips_elf_global_got_index (abfd, info, input_bfd, 5917 &h->root, r_type); 5918 if (!TLS_RELOC_P (r_type) 5919 && !elf_hash_table (info)->dynamic_sections_created) 5920 /* This is a static link. We must initialize the GOT entry. */ 5921 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->root.sgot->contents + g); 5922 } 5923 } 5924 else if (htab->root.target_os != is_vxworks 5925 && (call16_reloc_p (r_type) || got16_reloc_p (r_type))) 5926 /* The calculation below does not involve "g". */ 5927 break; 5928 else 5929 { 5930 g = mips_elf_local_got_index (abfd, input_bfd, info, 5931 symbol + addend, r_symndx, h, r_type); 5932 if (g == MINUS_ONE) 5933 return bfd_reloc_outofrange; 5934 } 5935 5936 /* Convert GOT indices to actual offsets. */ 5937 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g); 5938 break; 5939 } 5940 5941 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__ 5942 symbols are resolved by the loader. Add them to .rela.dyn. */ 5943 if (h != NULL && is_gott_symbol (info, &h->root)) 5944 { 5945 Elf_Internal_Rela outrel; 5946 bfd_byte *loc; 5947 asection *s; 5948 5949 s = mips_elf_rel_dyn_section (info, FALSE); 5950 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 5951 5952 outrel.r_offset = (input_section->output_section->vma 5953 + input_section->output_offset 5954 + relocation->r_offset); 5955 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type); 5956 outrel.r_addend = addend; 5957 bfd_elf32_swap_reloca_out (abfd, &outrel, loc); 5958 5959 /* If we've written this relocation for a readonly section, 5960 we need to set DF_TEXTREL again, so that we do not delete the 5961 DT_TEXTREL tag. */ 5962 if (MIPS_ELF_READONLY_SECTION (input_section)) 5963 info->flags |= DF_TEXTREL; 5964 5965 *valuep = 0; 5966 return bfd_reloc_ok; 5967 } 5968 5969 /* Figure out what kind of relocation is being performed. */ 5970 switch (r_type) 5971 { 5972 case R_MIPS_NONE: 5973 return bfd_reloc_continue; 5974 5975 case R_MIPS_16: 5976 if (howto->partial_inplace) 5977 addend = _bfd_mips_elf_sign_extend (addend, 16); 5978 value = symbol + addend; 5979 overflowed_p = mips_elf_overflow_p (value, 16); 5980 break; 5981 5982 case R_MIPS_32: 5983 case R_MIPS_REL32: 5984 case R_MIPS_64: 5985 if ((bfd_link_pic (info) 5986 || (htab->root.dynamic_sections_created 5987 && h != NULL 5988 && h->root.def_dynamic 5989 && !h->root.def_regular 5990 && !h->has_static_relocs)) 5991 && r_symndx != STN_UNDEF 5992 && (h == NULL 5993 || h->root.root.type != bfd_link_hash_undefweak 5994 || (ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT 5995 && !resolved_to_zero)) 5996 && (input_section->flags & SEC_ALLOC) != 0) 5997 { 5998 /* If we're creating a shared library, then we can't know 5999 where the symbol will end up. So, we create a relocation 6000 record in the output, and leave the job up to the dynamic 6001 linker. We must do the same for executable references to 6002 shared library symbols, unless we've decided to use copy 6003 relocs or PLTs instead. */ 6004 value = addend; 6005 if (!mips_elf_create_dynamic_relocation (abfd, 6006 info, 6007 relocation, 6008 h, 6009 sec, 6010 symbol, 6011 &value, 6012 input_section)) 6013 return bfd_reloc_undefined; 6014 } 6015 else 6016 { 6017 if (r_type != R_MIPS_REL32) 6018 value = symbol + addend; 6019 else 6020 value = addend; 6021 } 6022 value &= howto->dst_mask; 6023 break; 6024 6025 case R_MIPS_PC32: 6026 value = symbol + addend - p; 6027 value &= howto->dst_mask; 6028 break; 6029 6030 case R_MIPS16_26: 6031 /* The calculation for R_MIPS16_26 is just the same as for an 6032 R_MIPS_26. It's only the storage of the relocated field into 6033 the output file that's different. That's handled in 6034 mips_elf_perform_relocation. So, we just fall through to the 6035 R_MIPS_26 case here. */ 6036 case R_MIPS_26: 6037 case R_MICROMIPS_26_S1: 6038 { 6039 unsigned int shift; 6040 6041 /* Shift is 2, unusually, for microMIPS JALX. */ 6042 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2; 6043 6044 if (howto->partial_inplace && !section_p) 6045 value = _bfd_mips_elf_sign_extend (addend, 26 + shift); 6046 else 6047 value = addend; 6048 value += symbol; 6049 6050 /* Make sure the target of a jump is suitably aligned. Bit 0 must 6051 be the correct ISA mode selector except for weak undefined 6052 symbols. */ 6053 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6054 && (*cross_mode_jump_p 6055 ? (value & 3) != (r_type == R_MIPS_26) 6056 : (value & ((1 << shift) - 1)) != (r_type != R_MIPS_26))) 6057 return bfd_reloc_outofrange; 6058 6059 value >>= shift; 6060 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6061 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift)); 6062 value &= howto->dst_mask; 6063 } 6064 break; 6065 6066 case R_MIPS_TLS_DTPREL_HI16: 6067 case R_MIPS16_TLS_DTPREL_HI16: 6068 case R_MICROMIPS_TLS_DTPREL_HI16: 6069 value = (mips_elf_high (addend + symbol - dtprel_base (info)) 6070 & howto->dst_mask); 6071 break; 6072 6073 case R_MIPS_TLS_DTPREL_LO16: 6074 case R_MIPS_TLS_DTPREL32: 6075 case R_MIPS_TLS_DTPREL64: 6076 case R_MIPS16_TLS_DTPREL_LO16: 6077 case R_MICROMIPS_TLS_DTPREL_LO16: 6078 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask; 6079 break; 6080 6081 case R_MIPS_TLS_TPREL_HI16: 6082 case R_MIPS16_TLS_TPREL_HI16: 6083 case R_MICROMIPS_TLS_TPREL_HI16: 6084 value = (mips_elf_high (addend + symbol - tprel_base (info)) 6085 & howto->dst_mask); 6086 break; 6087 6088 case R_MIPS_TLS_TPREL_LO16: 6089 case R_MIPS_TLS_TPREL32: 6090 case R_MIPS_TLS_TPREL64: 6091 case R_MIPS16_TLS_TPREL_LO16: 6092 case R_MICROMIPS_TLS_TPREL_LO16: 6093 value = (symbol + addend - tprel_base (info)) & howto->dst_mask; 6094 break; 6095 6096 case R_MIPS_HI16: 6097 case R_MIPS16_HI16: 6098 case R_MICROMIPS_HI16: 6099 if (!gp_disp_p) 6100 { 6101 value = mips_elf_high (addend + symbol); 6102 value &= howto->dst_mask; 6103 } 6104 else 6105 { 6106 /* For MIPS16 ABI code we generate this sequence 6107 0: li $v0,%hi(_gp_disp) 6108 4: addiupc $v1,%lo(_gp_disp) 6109 8: sll $v0,16 6110 12: addu $v0,$v1 6111 14: move $gp,$v0 6112 So the offsets of hi and lo relocs are the same, but the 6113 base $pc is that used by the ADDIUPC instruction at $t9 + 4. 6114 ADDIUPC clears the low two bits of the instruction address, 6115 so the base is ($t9 + 4) & ~3. */ 6116 if (r_type == R_MIPS16_HI16) 6117 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3)); 6118 /* The microMIPS .cpload sequence uses the same assembly 6119 instructions as the traditional psABI version, but the 6120 incoming $t9 has the low bit set. */ 6121 else if (r_type == R_MICROMIPS_HI16) 6122 value = mips_elf_high (addend + gp - p - 1); 6123 else 6124 value = mips_elf_high (addend + gp - p); 6125 } 6126 break; 6127 6128 case R_MIPS_LO16: 6129 case R_MIPS16_LO16: 6130 case R_MICROMIPS_LO16: 6131 case R_MICROMIPS_HI0_LO16: 6132 if (!gp_disp_p) 6133 value = (symbol + addend) & howto->dst_mask; 6134 else 6135 { 6136 /* See the comment for R_MIPS16_HI16 above for the reason 6137 for this conditional. */ 6138 if (r_type == R_MIPS16_LO16) 6139 value = addend + gp - (p & ~(bfd_vma) 0x3); 6140 else if (r_type == R_MICROMIPS_LO16 6141 || r_type == R_MICROMIPS_HI0_LO16) 6142 value = addend + gp - p + 3; 6143 else 6144 value = addend + gp - p + 4; 6145 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation 6146 for overflow. But, on, say, IRIX5, relocations against 6147 _gp_disp are normally generated from the .cpload 6148 pseudo-op. It generates code that normally looks like 6149 this: 6150 6151 lui $gp,%hi(_gp_disp) 6152 addiu $gp,$gp,%lo(_gp_disp) 6153 addu $gp,$gp,$t9 6154 6155 Here $t9 holds the address of the function being called, 6156 as required by the MIPS ELF ABI. The R_MIPS_LO16 6157 relocation can easily overflow in this situation, but the 6158 R_MIPS_HI16 relocation will handle the overflow. 6159 Therefore, we consider this a bug in the MIPS ABI, and do 6160 not check for overflow here. */ 6161 } 6162 break; 6163 6164 case R_MIPS_LITERAL: 6165 case R_MICROMIPS_LITERAL: 6166 /* Because we don't merge literal sections, we can handle this 6167 just like R_MIPS_GPREL16. In the long run, we should merge 6168 shared literals, and then we will need to additional work 6169 here. */ 6170 6171 /* Fall through. */ 6172 6173 case R_MIPS16_GPREL: 6174 /* The R_MIPS16_GPREL performs the same calculation as 6175 R_MIPS_GPREL16, but stores the relocated bits in a different 6176 order. We don't need to do anything special here; the 6177 differences are handled in mips_elf_perform_relocation. */ 6178 case R_MIPS_GPREL16: 6179 case R_MICROMIPS_GPREL7_S2: 6180 case R_MICROMIPS_GPREL16: 6181 /* Only sign-extend the addend if it was extracted from the 6182 instruction. If the addend was separate, leave it alone, 6183 otherwise we may lose significant bits. */ 6184 if (howto->partial_inplace) 6185 addend = _bfd_mips_elf_sign_extend (addend, 16); 6186 value = symbol + addend - gp; 6187 /* If the symbol was local, any earlier relocatable links will 6188 have adjusted its addend with the gp offset, so compensate 6189 for that now. Don't do it for symbols forced local in this 6190 link, though, since they won't have had the gp offset applied 6191 to them before. */ 6192 if (was_local_p) 6193 value += gp0; 6194 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6195 overflowed_p = mips_elf_overflow_p (value, 16); 6196 break; 6197 6198 case R_MIPS16_GOT16: 6199 case R_MIPS16_CALL16: 6200 case R_MIPS_GOT16: 6201 case R_MIPS_CALL16: 6202 case R_MICROMIPS_GOT16: 6203 case R_MICROMIPS_CALL16: 6204 /* VxWorks does not have separate local and global semantics for 6205 R_MIPS*_GOT16; every relocation evaluates to "G". */ 6206 if (htab->root.target_os != is_vxworks && local_p) 6207 { 6208 value = mips_elf_got16_entry (abfd, input_bfd, info, 6209 symbol + addend, !was_local_p); 6210 if (value == MINUS_ONE) 6211 return bfd_reloc_outofrange; 6212 value 6213 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value); 6214 overflowed_p = mips_elf_overflow_p (value, 16); 6215 break; 6216 } 6217 6218 /* Fall through. */ 6219 6220 case R_MIPS_TLS_GD: 6221 case R_MIPS_TLS_GOTTPREL: 6222 case R_MIPS_TLS_LDM: 6223 case R_MIPS_GOT_DISP: 6224 case R_MIPS16_TLS_GD: 6225 case R_MIPS16_TLS_GOTTPREL: 6226 case R_MIPS16_TLS_LDM: 6227 case R_MICROMIPS_TLS_GD: 6228 case R_MICROMIPS_TLS_GOTTPREL: 6229 case R_MICROMIPS_TLS_LDM: 6230 case R_MICROMIPS_GOT_DISP: 6231 value = g; 6232 overflowed_p = mips_elf_overflow_p (value, 16); 6233 break; 6234 6235 case R_MIPS_GPREL32: 6236 value = (addend + symbol + gp0 - gp); 6237 if (!save_addend) 6238 value &= howto->dst_mask; 6239 break; 6240 6241 case R_MIPS_PC16: 6242 case R_MIPS_GNU_REL16_S2: 6243 if (howto->partial_inplace) 6244 addend = _bfd_mips_elf_sign_extend (addend, 18); 6245 6246 /* No need to exclude weak undefined symbols here as they resolve 6247 to 0 and never set `*cross_mode_jump_p', so this alignment check 6248 will never trigger for them. */ 6249 if (*cross_mode_jump_p 6250 ? ((symbol + addend) & 3) != 1 6251 : ((symbol + addend) & 3) != 0) 6252 return bfd_reloc_outofrange; 6253 6254 value = symbol + addend - p; 6255 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6256 overflowed_p = mips_elf_overflow_p (value, 18); 6257 value >>= howto->rightshift; 6258 value &= howto->dst_mask; 6259 break; 6260 6261 case R_MIPS16_PC16_S1: 6262 if (howto->partial_inplace) 6263 addend = _bfd_mips_elf_sign_extend (addend, 17); 6264 6265 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6266 && (*cross_mode_jump_p 6267 ? ((symbol + addend) & 3) != 0 6268 : ((symbol + addend) & 1) == 0)) 6269 return bfd_reloc_outofrange; 6270 6271 value = symbol + addend - p; 6272 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6273 overflowed_p = mips_elf_overflow_p (value, 17); 6274 value >>= howto->rightshift; 6275 value &= howto->dst_mask; 6276 break; 6277 6278 case R_MIPS_PC21_S2: 6279 if (howto->partial_inplace) 6280 addend = _bfd_mips_elf_sign_extend (addend, 23); 6281 6282 if ((symbol + addend) & 3) 6283 return bfd_reloc_outofrange; 6284 6285 value = symbol + addend - p; 6286 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6287 overflowed_p = mips_elf_overflow_p (value, 23); 6288 value >>= howto->rightshift; 6289 value &= howto->dst_mask; 6290 break; 6291 6292 case R_MIPS_PC26_S2: 6293 if (howto->partial_inplace) 6294 addend = _bfd_mips_elf_sign_extend (addend, 28); 6295 6296 if ((symbol + addend) & 3) 6297 return bfd_reloc_outofrange; 6298 6299 value = symbol + addend - p; 6300 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6301 overflowed_p = mips_elf_overflow_p (value, 28); 6302 value >>= howto->rightshift; 6303 value &= howto->dst_mask; 6304 break; 6305 6306 case R_MIPS_PC18_S3: 6307 if (howto->partial_inplace) 6308 addend = _bfd_mips_elf_sign_extend (addend, 21); 6309 6310 if ((symbol + addend) & 7) 6311 return bfd_reloc_outofrange; 6312 6313 value = symbol + addend - ((p | 7) ^ 7); 6314 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6315 overflowed_p = mips_elf_overflow_p (value, 21); 6316 value >>= howto->rightshift; 6317 value &= howto->dst_mask; 6318 break; 6319 6320 case R_MIPS_PC19_S2: 6321 if (howto->partial_inplace) 6322 addend = _bfd_mips_elf_sign_extend (addend, 21); 6323 6324 if ((symbol + addend) & 3) 6325 return bfd_reloc_outofrange; 6326 6327 value = symbol + addend - p; 6328 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6329 overflowed_p = mips_elf_overflow_p (value, 21); 6330 value >>= howto->rightshift; 6331 value &= howto->dst_mask; 6332 break; 6333 6334 case R_MIPS_PCHI16: 6335 value = mips_elf_high (symbol + addend - p); 6336 value &= howto->dst_mask; 6337 break; 6338 6339 case R_MIPS_PCLO16: 6340 if (howto->partial_inplace) 6341 addend = _bfd_mips_elf_sign_extend (addend, 16); 6342 value = symbol + addend - p; 6343 value &= howto->dst_mask; 6344 break; 6345 6346 case R_MICROMIPS_PC7_S1: 6347 if (howto->partial_inplace) 6348 addend = _bfd_mips_elf_sign_extend (addend, 8); 6349 6350 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6351 && (*cross_mode_jump_p 6352 ? ((symbol + addend + 2) & 3) != 0 6353 : ((symbol + addend + 2) & 1) == 0)) 6354 return bfd_reloc_outofrange; 6355 6356 value = symbol + addend - p; 6357 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6358 overflowed_p = mips_elf_overflow_p (value, 8); 6359 value >>= howto->rightshift; 6360 value &= howto->dst_mask; 6361 break; 6362 6363 case R_MICROMIPS_PC10_S1: 6364 if (howto->partial_inplace) 6365 addend = _bfd_mips_elf_sign_extend (addend, 11); 6366 6367 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6368 && (*cross_mode_jump_p 6369 ? ((symbol + addend + 2) & 3) != 0 6370 : ((symbol + addend + 2) & 1) == 0)) 6371 return bfd_reloc_outofrange; 6372 6373 value = symbol + addend - p; 6374 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6375 overflowed_p = mips_elf_overflow_p (value, 11); 6376 value >>= howto->rightshift; 6377 value &= howto->dst_mask; 6378 break; 6379 6380 case R_MICROMIPS_PC16_S1: 6381 if (howto->partial_inplace) 6382 addend = _bfd_mips_elf_sign_extend (addend, 17); 6383 6384 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6385 && (*cross_mode_jump_p 6386 ? ((symbol + addend) & 3) != 0 6387 : ((symbol + addend) & 1) == 0)) 6388 return bfd_reloc_outofrange; 6389 6390 value = symbol + addend - p; 6391 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6392 overflowed_p = mips_elf_overflow_p (value, 17); 6393 value >>= howto->rightshift; 6394 value &= howto->dst_mask; 6395 break; 6396 6397 case R_MICROMIPS_PC23_S2: 6398 if (howto->partial_inplace) 6399 addend = _bfd_mips_elf_sign_extend (addend, 25); 6400 value = symbol + addend - ((p | 3) ^ 3); 6401 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak) 6402 overflowed_p = mips_elf_overflow_p (value, 25); 6403 value >>= howto->rightshift; 6404 value &= howto->dst_mask; 6405 break; 6406 6407 case R_MIPS_GOT_HI16: 6408 case R_MIPS_CALL_HI16: 6409 case R_MICROMIPS_GOT_HI16: 6410 case R_MICROMIPS_CALL_HI16: 6411 /* We're allowed to handle these two relocations identically. 6412 The dynamic linker is allowed to handle the CALL relocations 6413 differently by creating a lazy evaluation stub. */ 6414 value = g; 6415 value = mips_elf_high (value); 6416 value &= howto->dst_mask; 6417 break; 6418 6419 case R_MIPS_GOT_LO16: 6420 case R_MIPS_CALL_LO16: 6421 case R_MICROMIPS_GOT_LO16: 6422 case R_MICROMIPS_CALL_LO16: 6423 value = g & howto->dst_mask; 6424 break; 6425 6426 case R_MIPS_GOT_PAGE: 6427 case R_MICROMIPS_GOT_PAGE: 6428 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL); 6429 if (value == MINUS_ONE) 6430 return bfd_reloc_outofrange; 6431 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value); 6432 overflowed_p = mips_elf_overflow_p (value, 16); 6433 break; 6434 6435 case R_MIPS_GOT_OFST: 6436 case R_MICROMIPS_GOT_OFST: 6437 if (local_p) 6438 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value); 6439 else 6440 value = addend; 6441 overflowed_p = mips_elf_overflow_p (value, 16); 6442 break; 6443 6444 case R_MIPS_SUB: 6445 case R_MICROMIPS_SUB: 6446 value = symbol - addend; 6447 value &= howto->dst_mask; 6448 break; 6449 6450 case R_MIPS_HIGHER: 6451 case R_MICROMIPS_HIGHER: 6452 value = mips_elf_higher (addend + symbol); 6453 value &= howto->dst_mask; 6454 break; 6455 6456 case R_MIPS_HIGHEST: 6457 case R_MICROMIPS_HIGHEST: 6458 value = mips_elf_highest (addend + symbol); 6459 value &= howto->dst_mask; 6460 break; 6461 6462 case R_MIPS_SCN_DISP: 6463 case R_MICROMIPS_SCN_DISP: 6464 value = symbol + addend - sec->output_offset; 6465 value &= howto->dst_mask; 6466 break; 6467 6468 case R_MIPS_JALR: 6469 case R_MICROMIPS_JALR: 6470 /* This relocation is only a hint. In some cases, we optimize 6471 it into a bal instruction. But we don't try to optimize 6472 when the symbol does not resolve locally. */ 6473 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root)) 6474 return bfd_reloc_continue; 6475 /* We can't optimize cross-mode jumps either. */ 6476 if (*cross_mode_jump_p) 6477 return bfd_reloc_continue; 6478 value = symbol + addend; 6479 /* Neither we can non-instruction-aligned targets. */ 6480 if (r_type == R_MIPS_JALR ? (value & 3) != 0 : (value & 1) == 0) 6481 return bfd_reloc_continue; 6482 break; 6483 6484 case R_MIPS_PJUMP: 6485 case R_MIPS_GNU_VTINHERIT: 6486 case R_MIPS_GNU_VTENTRY: 6487 /* We don't do anything with these at present. */ 6488 return bfd_reloc_continue; 6489 6490 default: 6491 /* An unrecognized relocation type. */ 6492 return bfd_reloc_notsupported; 6493 } 6494 6495 /* Store the VALUE for our caller. */ 6496 *valuep = value; 6497 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok; 6498 } 6499 6500 /* It has been determined that the result of the RELOCATION is the 6501 VALUE. Use HOWTO to place VALUE into the output file at the 6502 appropriate position. The SECTION is the section to which the 6503 relocation applies. 6504 CROSS_MODE_JUMP_P is true if the relocation field 6505 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa. 6506 6507 Returns FALSE if anything goes wrong. */ 6508 6509 static bfd_boolean 6510 mips_elf_perform_relocation (struct bfd_link_info *info, 6511 reloc_howto_type *howto, 6512 const Elf_Internal_Rela *relocation, 6513 bfd_vma value, bfd *input_bfd, 6514 asection *input_section, bfd_byte *contents, 6515 bfd_boolean cross_mode_jump_p) 6516 { 6517 bfd_vma x; 6518 bfd_byte *location; 6519 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info); 6520 6521 /* Figure out where the relocation is occurring. */ 6522 location = contents + relocation->r_offset; 6523 6524 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location); 6525 6526 /* Obtain the current value. */ 6527 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents); 6528 6529 /* Clear the field we are setting. */ 6530 x &= ~howto->dst_mask; 6531 6532 /* Set the field. */ 6533 x |= (value & howto->dst_mask); 6534 6535 /* Detect incorrect JALX usage. If required, turn JAL or BAL into JALX. */ 6536 if (!cross_mode_jump_p && jal_reloc_p (r_type)) 6537 { 6538 bfd_vma opcode = x >> 26; 6539 6540 if (r_type == R_MIPS16_26 ? opcode == 0x7 6541 : r_type == R_MICROMIPS_26_S1 ? opcode == 0x3c 6542 : opcode == 0x1d) 6543 { 6544 info->callbacks->einfo 6545 (_("%X%H: unsupported JALX to the same ISA mode\n"), 6546 input_bfd, input_section, relocation->r_offset); 6547 return TRUE; 6548 } 6549 } 6550 if (cross_mode_jump_p && jal_reloc_p (r_type)) 6551 { 6552 bfd_boolean ok; 6553 bfd_vma opcode = x >> 26; 6554 bfd_vma jalx_opcode; 6555 6556 /* Check to see if the opcode is already JAL or JALX. */ 6557 if (r_type == R_MIPS16_26) 6558 { 6559 ok = ((opcode == 0x6) || (opcode == 0x7)); 6560 jalx_opcode = 0x7; 6561 } 6562 else if (r_type == R_MICROMIPS_26_S1) 6563 { 6564 ok = ((opcode == 0x3d) || (opcode == 0x3c)); 6565 jalx_opcode = 0x3c; 6566 } 6567 else 6568 { 6569 ok = ((opcode == 0x3) || (opcode == 0x1d)); 6570 jalx_opcode = 0x1d; 6571 } 6572 6573 /* If the opcode is not JAL or JALX, there's a problem. We cannot 6574 convert J or JALS to JALX. */ 6575 if (!ok) 6576 { 6577 info->callbacks->einfo 6578 (_("%X%H: unsupported jump between ISA modes; " 6579 "consider recompiling with interlinking enabled\n"), 6580 input_bfd, input_section, relocation->r_offset); 6581 return TRUE; 6582 } 6583 6584 /* Make this the JALX opcode. */ 6585 x = (x & ~(0x3fu << 26)) | (jalx_opcode << 26); 6586 } 6587 else if (cross_mode_jump_p && b_reloc_p (r_type)) 6588 { 6589 bfd_boolean ok = FALSE; 6590 bfd_vma opcode = x >> 16; 6591 bfd_vma jalx_opcode = 0; 6592 bfd_vma sign_bit = 0; 6593 bfd_vma addr; 6594 bfd_vma dest; 6595 6596 if (r_type == R_MICROMIPS_PC16_S1) 6597 { 6598 ok = opcode == 0x4060; 6599 jalx_opcode = 0x3c; 6600 sign_bit = 0x10000; 6601 value <<= 1; 6602 } 6603 else if (r_type == R_MIPS_PC16 || r_type == R_MIPS_GNU_REL16_S2) 6604 { 6605 ok = opcode == 0x411; 6606 jalx_opcode = 0x1d; 6607 sign_bit = 0x20000; 6608 value <<= 2; 6609 } 6610 6611 if (ok && !bfd_link_pic (info)) 6612 { 6613 addr = (input_section->output_section->vma 6614 + input_section->output_offset 6615 + relocation->r_offset 6616 + 4); 6617 dest = (addr 6618 + (((value & ((sign_bit << 1) - 1)) ^ sign_bit) - sign_bit)); 6619 6620 if ((addr >> 28) << 28 != (dest >> 28) << 28) 6621 { 6622 info->callbacks->einfo 6623 (_("%X%H: cannot convert branch between ISA modes " 6624 "to JALX: relocation out of range\n"), 6625 input_bfd, input_section, relocation->r_offset); 6626 return TRUE; 6627 } 6628 6629 /* Make this the JALX opcode. */ 6630 x = ((dest >> 2) & 0x3ffffff) | jalx_opcode << 26; 6631 } 6632 else if (!mips_elf_hash_table (info)->ignore_branch_isa) 6633 { 6634 info->callbacks->einfo 6635 (_("%X%H: unsupported branch between ISA modes\n"), 6636 input_bfd, input_section, relocation->r_offset); 6637 return TRUE; 6638 } 6639 } 6640 6641 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in 6642 range. */ 6643 if (!bfd_link_relocatable (info) 6644 && !cross_mode_jump_p 6645 && ((JAL_TO_BAL_P (input_bfd) 6646 && r_type == R_MIPS_26 6647 && (x >> 26) == 0x3) /* jal addr */ 6648 || (JALR_TO_BAL_P (input_bfd) 6649 && r_type == R_MIPS_JALR 6650 && x == 0x0320f809) /* jalr t9 */ 6651 || (JR_TO_B_P (input_bfd) 6652 && r_type == R_MIPS_JALR 6653 && (x & ~1) == 0x03200008))) /* jr t9 / jalr zero, t9 */ 6654 { 6655 bfd_vma addr; 6656 bfd_vma dest; 6657 bfd_signed_vma off; 6658 6659 addr = (input_section->output_section->vma 6660 + input_section->output_offset 6661 + relocation->r_offset 6662 + 4); 6663 if (r_type == R_MIPS_26) 6664 dest = (value << 2) | ((addr >> 28) << 28); 6665 else 6666 dest = value; 6667 off = dest - addr; 6668 if (off <= 0x1ffff && off >= -0x20000) 6669 { 6670 if ((x & ~1) == 0x03200008) /* jr t9 / jalr zero, t9 */ 6671 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */ 6672 else 6673 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */ 6674 } 6675 } 6676 6677 /* Put the value into the output. */ 6678 mips_elf_store_contents (howto, relocation, input_bfd, contents, x); 6679 6680 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !bfd_link_relocatable (info), 6681 location); 6682 6683 return TRUE; 6684 } 6685 6686 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL 6687 is the original relocation, which is now being transformed into a 6688 dynamic relocation. The ADDENDP is adjusted if necessary; the 6689 caller should store the result in place of the original addend. */ 6690 6691 static bfd_boolean 6692 mips_elf_create_dynamic_relocation (bfd *output_bfd, 6693 struct bfd_link_info *info, 6694 const Elf_Internal_Rela *rel, 6695 struct mips_elf_link_hash_entry *h, 6696 asection *sec, bfd_vma symbol, 6697 bfd_vma *addendp, asection *input_section) 6698 { 6699 Elf_Internal_Rela outrel[3]; 6700 asection *sreloc; 6701 bfd *dynobj; 6702 int r_type; 6703 long indx; 6704 bfd_boolean defined_p; 6705 struct mips_elf_link_hash_table *htab; 6706 6707 htab = mips_elf_hash_table (info); 6708 BFD_ASSERT (htab != NULL); 6709 6710 r_type = ELF_R_TYPE (output_bfd, rel->r_info); 6711 dynobj = elf_hash_table (info)->dynobj; 6712 sreloc = mips_elf_rel_dyn_section (info, FALSE); 6713 BFD_ASSERT (sreloc != NULL); 6714 BFD_ASSERT (sreloc->contents != NULL); 6715 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd) 6716 < sreloc->size); 6717 6718 outrel[0].r_offset = 6719 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset); 6720 if (ABI_64_P (output_bfd)) 6721 { 6722 outrel[1].r_offset = 6723 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset); 6724 outrel[2].r_offset = 6725 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset); 6726 } 6727 6728 if (outrel[0].r_offset == MINUS_ONE) 6729 /* The relocation field has been deleted. */ 6730 return TRUE; 6731 6732 if (outrel[0].r_offset == MINUS_TWO) 6733 { 6734 /* The relocation field has been converted into a relative value of 6735 some sort. Functions like _bfd_elf_write_section_eh_frame expect 6736 the field to be fully relocated, so add in the symbol's value. */ 6737 *addendp += symbol; 6738 return TRUE; 6739 } 6740 6741 /* We must now calculate the dynamic symbol table index to use 6742 in the relocation. */ 6743 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root)) 6744 { 6745 BFD_ASSERT (htab->root.target_os == is_vxworks 6746 || h->global_got_area != GGA_NONE); 6747 indx = h->root.dynindx; 6748 if (SGI_COMPAT (output_bfd)) 6749 defined_p = h->root.def_regular; 6750 else 6751 /* ??? glibc's ld.so just adds the final GOT entry to the 6752 relocation field. It therefore treats relocs against 6753 defined symbols in the same way as relocs against 6754 undefined symbols. */ 6755 defined_p = FALSE; 6756 } 6757 else 6758 { 6759 if (sec != NULL && bfd_is_abs_section (sec)) 6760 indx = 0; 6761 else if (sec == NULL || sec->owner == NULL) 6762 { 6763 bfd_set_error (bfd_error_bad_value); 6764 return FALSE; 6765 } 6766 else 6767 { 6768 indx = elf_section_data (sec->output_section)->dynindx; 6769 if (indx == 0) 6770 { 6771 asection *osec = htab->root.text_index_section; 6772 indx = elf_section_data (osec)->dynindx; 6773 } 6774 if (indx == 0) 6775 abort (); 6776 } 6777 6778 /* Instead of generating a relocation using the section 6779 symbol, we may as well make it a fully relative 6780 relocation. We want to avoid generating relocations to 6781 local symbols because we used to generate them 6782 incorrectly, without adding the original symbol value, 6783 which is mandated by the ABI for section symbols. In 6784 order to give dynamic loaders and applications time to 6785 phase out the incorrect use, we refrain from emitting 6786 section-relative relocations. It's not like they're 6787 useful, after all. This should be a bit more efficient 6788 as well. */ 6789 /* ??? Although this behavior is compatible with glibc's ld.so, 6790 the ABI says that relocations against STN_UNDEF should have 6791 a symbol value of 0. Irix rld honors this, so relocations 6792 against STN_UNDEF have no effect. */ 6793 if (!SGI_COMPAT (output_bfd)) 6794 indx = 0; 6795 defined_p = TRUE; 6796 } 6797 6798 /* If the relocation was previously an absolute relocation and 6799 this symbol will not be referred to by the relocation, we must 6800 adjust it by the value we give it in the dynamic symbol table. 6801 Otherwise leave the job up to the dynamic linker. */ 6802 if (defined_p && r_type != R_MIPS_REL32) 6803 *addendp += symbol; 6804 6805 if (htab->root.target_os == is_vxworks) 6806 /* VxWorks uses non-relative relocations for this. */ 6807 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32); 6808 else 6809 /* The relocation is always an REL32 relocation because we don't 6810 know where the shared library will wind up at load-time. */ 6811 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx, 6812 R_MIPS_REL32); 6813 6814 /* For strict adherence to the ABI specification, we should 6815 generate a R_MIPS_64 relocation record by itself before the 6816 _REL32/_64 record as well, such that the addend is read in as 6817 a 64-bit value (REL32 is a 32-bit relocation, after all). 6818 However, since none of the existing ELF64 MIPS dynamic 6819 loaders seems to care, we don't waste space with these 6820 artificial relocations. If this turns out to not be true, 6821 mips_elf_allocate_dynamic_relocation() should be tweaked so 6822 as to make room for a pair of dynamic relocations per 6823 invocation if ABI_64_P, and here we should generate an 6824 additional relocation record with R_MIPS_64 by itself for a 6825 NULL symbol before this relocation record. */ 6826 outrel[1].r_info = ELF_R_INFO (output_bfd, 0, 6827 ABI_64_P (output_bfd) 6828 ? R_MIPS_64 6829 : R_MIPS_NONE); 6830 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE); 6831 6832 /* Adjust the output offset of the relocation to reference the 6833 correct location in the output file. */ 6834 outrel[0].r_offset += (input_section->output_section->vma 6835 + input_section->output_offset); 6836 outrel[1].r_offset += (input_section->output_section->vma 6837 + input_section->output_offset); 6838 outrel[2].r_offset += (input_section->output_section->vma 6839 + input_section->output_offset); 6840 6841 /* Put the relocation back out. We have to use the special 6842 relocation outputter in the 64-bit case since the 64-bit 6843 relocation format is non-standard. */ 6844 if (ABI_64_P (output_bfd)) 6845 { 6846 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out) 6847 (output_bfd, &outrel[0], 6848 (sreloc->contents 6849 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel))); 6850 } 6851 else if (htab->root.target_os == is_vxworks) 6852 { 6853 /* VxWorks uses RELA rather than REL dynamic relocations. */ 6854 outrel[0].r_addend = *addendp; 6855 bfd_elf32_swap_reloca_out 6856 (output_bfd, &outrel[0], 6857 (sreloc->contents 6858 + sreloc->reloc_count * sizeof (Elf32_External_Rela))); 6859 } 6860 else 6861 bfd_elf32_swap_reloc_out 6862 (output_bfd, &outrel[0], 6863 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel))); 6864 6865 /* We've now added another relocation. */ 6866 ++sreloc->reloc_count; 6867 6868 /* Make sure the output section is writable. The dynamic linker 6869 will be writing to it. */ 6870 elf_section_data (input_section->output_section)->this_hdr.sh_flags 6871 |= SHF_WRITE; 6872 6873 /* On IRIX5, make an entry of compact relocation info. */ 6874 if (IRIX_COMPAT (output_bfd) == ict_irix5) 6875 { 6876 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel"); 6877 bfd_byte *cr; 6878 6879 if (scpt) 6880 { 6881 Elf32_crinfo cptrel; 6882 6883 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG); 6884 cptrel.vaddr = (rel->r_offset 6885 + input_section->output_section->vma 6886 + input_section->output_offset); 6887 if (r_type == R_MIPS_REL32) 6888 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32); 6889 else 6890 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD); 6891 mips_elf_set_cr_dist2to (cptrel, 0); 6892 cptrel.konst = *addendp; 6893 6894 cr = (scpt->contents 6895 + sizeof (Elf32_External_compact_rel)); 6896 mips_elf_set_cr_relvaddr (cptrel, 0); 6897 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel, 6898 ((Elf32_External_crinfo *) cr 6899 + scpt->reloc_count)); 6900 ++scpt->reloc_count; 6901 } 6902 } 6903 6904 /* If we've written this relocation for a readonly section, 6905 we need to set DF_TEXTREL again, so that we do not delete the 6906 DT_TEXTREL tag. */ 6907 if (MIPS_ELF_READONLY_SECTION (input_section)) 6908 info->flags |= DF_TEXTREL; 6909 6910 return TRUE; 6911 } 6912 6913 /* Return the MACH for a MIPS e_flags value. */ 6914 6915 unsigned long 6916 _bfd_elf_mips_mach (flagword flags) 6917 { 6918 switch (flags & EF_MIPS_MACH) 6919 { 6920 case E_MIPS_MACH_3900: 6921 return bfd_mach_mips3900; 6922 6923 case E_MIPS_MACH_4010: 6924 return bfd_mach_mips4010; 6925 6926 case E_MIPS_MACH_4100: 6927 return bfd_mach_mips4100; 6928 6929 case E_MIPS_MACH_4111: 6930 return bfd_mach_mips4111; 6931 6932 case E_MIPS_MACH_4120: 6933 return bfd_mach_mips4120; 6934 6935 case E_MIPS_MACH_4650: 6936 return bfd_mach_mips4650; 6937 6938 case E_MIPS_MACH_5400: 6939 return bfd_mach_mips5400; 6940 6941 case E_MIPS_MACH_5500: 6942 return bfd_mach_mips5500; 6943 6944 case E_MIPS_MACH_5900: 6945 return bfd_mach_mips5900; 6946 6947 case E_MIPS_MACH_9000: 6948 return bfd_mach_mips9000; 6949 6950 case E_MIPS_MACH_SB1: 6951 return bfd_mach_mips_sb1; 6952 6953 case E_MIPS_MACH_LS2E: 6954 return bfd_mach_mips_loongson_2e; 6955 6956 case E_MIPS_MACH_LS2F: 6957 return bfd_mach_mips_loongson_2f; 6958 6959 case E_MIPS_MACH_GS464: 6960 return bfd_mach_mips_gs464; 6961 6962 case E_MIPS_MACH_GS464E: 6963 return bfd_mach_mips_gs464e; 6964 6965 case E_MIPS_MACH_GS264E: 6966 return bfd_mach_mips_gs264e; 6967 6968 case E_MIPS_MACH_OCTEON3: 6969 return bfd_mach_mips_octeon3; 6970 6971 case E_MIPS_MACH_OCTEON2: 6972 return bfd_mach_mips_octeon2; 6973 6974 case E_MIPS_MACH_OCTEON: 6975 return bfd_mach_mips_octeon; 6976 6977 case E_MIPS_MACH_XLR: 6978 return bfd_mach_mips_xlr; 6979 6980 case E_MIPS_MACH_IAMR2: 6981 return bfd_mach_mips_interaptiv_mr2; 6982 6983 default: 6984 switch (flags & EF_MIPS_ARCH) 6985 { 6986 default: 6987 case E_MIPS_ARCH_1: 6988 return bfd_mach_mips3000; 6989 6990 case E_MIPS_ARCH_2: 6991 return bfd_mach_mips6000; 6992 6993 case E_MIPS_ARCH_3: 6994 return bfd_mach_mips4000; 6995 6996 case E_MIPS_ARCH_4: 6997 return bfd_mach_mips8000; 6998 6999 case E_MIPS_ARCH_5: 7000 return bfd_mach_mips5; 7001 7002 case E_MIPS_ARCH_32: 7003 return bfd_mach_mipsisa32; 7004 7005 case E_MIPS_ARCH_64: 7006 return bfd_mach_mipsisa64; 7007 7008 case E_MIPS_ARCH_32R2: 7009 return bfd_mach_mipsisa32r2; 7010 7011 case E_MIPS_ARCH_64R2: 7012 return bfd_mach_mipsisa64r2; 7013 7014 case E_MIPS_ARCH_32R6: 7015 return bfd_mach_mipsisa32r6; 7016 7017 case E_MIPS_ARCH_64R6: 7018 return bfd_mach_mipsisa64r6; 7019 } 7020 } 7021 7022 return 0; 7023 } 7024 7025 /* Return printable name for ABI. */ 7026 7027 static INLINE char * 7028 elf_mips_abi_name (bfd *abfd) 7029 { 7030 flagword flags; 7031 7032 flags = elf_elfheader (abfd)->e_flags; 7033 switch (flags & EF_MIPS_ABI) 7034 { 7035 case 0: 7036 if (ABI_N32_P (abfd)) 7037 return "N32"; 7038 else if (ABI_64_P (abfd)) 7039 return "64"; 7040 else 7041 return "none"; 7042 case E_MIPS_ABI_O32: 7043 return "O32"; 7044 case E_MIPS_ABI_O64: 7045 return "O64"; 7046 case E_MIPS_ABI_EABI32: 7047 return "EABI32"; 7048 case E_MIPS_ABI_EABI64: 7049 return "EABI64"; 7050 default: 7051 return "unknown abi"; 7052 } 7053 } 7054 7055 /* MIPS ELF uses two common sections. One is the usual one, and the 7056 other is for small objects. All the small objects are kept 7057 together, and then referenced via the gp pointer, which yields 7058 faster assembler code. This is what we use for the small common 7059 section. This approach is copied from ecoff.c. */ 7060 static asection mips_elf_scom_section; 7061 static asymbol mips_elf_scom_symbol; 7062 static asymbol *mips_elf_scom_symbol_ptr; 7063 7064 /* MIPS ELF also uses an acommon section, which represents an 7065 allocated common symbol which may be overridden by a 7066 definition in a shared library. */ 7067 static asection mips_elf_acom_section; 7068 static asymbol mips_elf_acom_symbol; 7069 static asymbol *mips_elf_acom_symbol_ptr; 7070 7071 /* This is used for both the 32-bit and the 64-bit ABI. */ 7072 7073 void 7074 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym) 7075 { 7076 elf_symbol_type *elfsym; 7077 7078 /* Handle the special MIPS section numbers that a symbol may use. */ 7079 elfsym = (elf_symbol_type *) asym; 7080 switch (elfsym->internal_elf_sym.st_shndx) 7081 { 7082 case SHN_MIPS_ACOMMON: 7083 /* This section is used in a dynamically linked executable file. 7084 It is an allocated common section. The dynamic linker can 7085 either resolve these symbols to something in a shared 7086 library, or it can just leave them here. For our purposes, 7087 we can consider these symbols to be in a new section. */ 7088 if (mips_elf_acom_section.name == NULL) 7089 { 7090 /* Initialize the acommon section. */ 7091 mips_elf_acom_section.name = ".acommon"; 7092 mips_elf_acom_section.flags = SEC_ALLOC; 7093 mips_elf_acom_section.output_section = &mips_elf_acom_section; 7094 mips_elf_acom_section.symbol = &mips_elf_acom_symbol; 7095 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr; 7096 mips_elf_acom_symbol.name = ".acommon"; 7097 mips_elf_acom_symbol.flags = BSF_SECTION_SYM; 7098 mips_elf_acom_symbol.section = &mips_elf_acom_section; 7099 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol; 7100 } 7101 asym->section = &mips_elf_acom_section; 7102 break; 7103 7104 case SHN_COMMON: 7105 /* Common symbols less than the GP size are automatically 7106 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */ 7107 if (asym->value > elf_gp_size (abfd) 7108 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS 7109 || IRIX_COMPAT (abfd) == ict_irix6) 7110 break; 7111 /* Fall through. */ 7112 case SHN_MIPS_SCOMMON: 7113 if (mips_elf_scom_section.name == NULL) 7114 { 7115 /* Initialize the small common section. */ 7116 mips_elf_scom_section.name = ".scommon"; 7117 mips_elf_scom_section.flags = SEC_IS_COMMON | SEC_SMALL_DATA; 7118 mips_elf_scom_section.output_section = &mips_elf_scom_section; 7119 mips_elf_scom_section.symbol = &mips_elf_scom_symbol; 7120 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr; 7121 mips_elf_scom_symbol.name = ".scommon"; 7122 mips_elf_scom_symbol.flags = BSF_SECTION_SYM; 7123 mips_elf_scom_symbol.section = &mips_elf_scom_section; 7124 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol; 7125 } 7126 asym->section = &mips_elf_scom_section; 7127 asym->value = elfsym->internal_elf_sym.st_size; 7128 break; 7129 7130 case SHN_MIPS_SUNDEFINED: 7131 asym->section = bfd_und_section_ptr; 7132 break; 7133 7134 case SHN_MIPS_TEXT: 7135 { 7136 asection *section = bfd_get_section_by_name (abfd, ".text"); 7137 7138 if (section != NULL) 7139 { 7140 asym->section = section; 7141 /* MIPS_TEXT is a bit special, the address is not an offset 7142 to the base of the .text section. So subtract the section 7143 base address to make it an offset. */ 7144 asym->value -= section->vma; 7145 } 7146 } 7147 break; 7148 7149 case SHN_MIPS_DATA: 7150 { 7151 asection *section = bfd_get_section_by_name (abfd, ".data"); 7152 7153 if (section != NULL) 7154 { 7155 asym->section = section; 7156 /* MIPS_DATA is a bit special, the address is not an offset 7157 to the base of the .data section. So subtract the section 7158 base address to make it an offset. */ 7159 asym->value -= section->vma; 7160 } 7161 } 7162 break; 7163 } 7164 7165 /* If this is an odd-valued function symbol, assume it's a MIPS16 7166 or microMIPS one. */ 7167 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC 7168 && (asym->value & 1) != 0) 7169 { 7170 asym->value--; 7171 if (MICROMIPS_P (abfd)) 7172 elfsym->internal_elf_sym.st_other 7173 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other); 7174 else 7175 elfsym->internal_elf_sym.st_other 7176 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other); 7177 } 7178 } 7179 7180 /* Implement elf_backend_eh_frame_address_size. This differs from 7181 the default in the way it handles EABI64. 7182 7183 EABI64 was originally specified as an LP64 ABI, and that is what 7184 -mabi=eabi normally gives on a 64-bit target. However, gcc has 7185 historically accepted the combination of -mabi=eabi and -mlong32, 7186 and this ILP32 variation has become semi-official over time. 7187 Both forms use elf32 and have pointer-sized FDE addresses. 7188 7189 If an EABI object was generated by GCC 4.0 or above, it will have 7190 an empty .gcc_compiled_longXX section, where XX is the size of longs 7191 in bits. Unfortunately, ILP32 objects generated by earlier compilers 7192 have no special marking to distinguish them from LP64 objects. 7193 7194 We don't want users of the official LP64 ABI to be punished for the 7195 existence of the ILP32 variant, but at the same time, we don't want 7196 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects. 7197 We therefore take the following approach: 7198 7199 - If ABFD contains a .gcc_compiled_longXX section, use it to 7200 determine the pointer size. 7201 7202 - Otherwise check the type of the first relocation. Assume that 7203 the LP64 ABI is being used if the relocation is of type R_MIPS_64. 7204 7205 - Otherwise punt. 7206 7207 The second check is enough to detect LP64 objects generated by pre-4.0 7208 compilers because, in the kind of output generated by those compilers, 7209 the first relocation will be associated with either a CIE personality 7210 routine or an FDE start address. Furthermore, the compilers never 7211 used a special (non-pointer) encoding for this ABI. 7212 7213 Checking the relocation type should also be safe because there is no 7214 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never 7215 did so. */ 7216 7217 unsigned int 7218 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, const asection *sec) 7219 { 7220 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 7221 return 8; 7222 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64) 7223 { 7224 bfd_boolean long32_p, long64_p; 7225 7226 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0; 7227 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0; 7228 if (long32_p && long64_p) 7229 return 0; 7230 if (long32_p) 7231 return 4; 7232 if (long64_p) 7233 return 8; 7234 7235 if (sec->reloc_count > 0 7236 && elf_section_data (sec)->relocs != NULL 7237 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info) 7238 == R_MIPS_64)) 7239 return 8; 7240 7241 return 0; 7242 } 7243 return 4; 7244 } 7245 7246 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP 7247 relocations against two unnamed section symbols to resolve to the 7248 same address. For example, if we have code like: 7249 7250 lw $4,%got_disp(.data)($gp) 7251 lw $25,%got_disp(.text)($gp) 7252 jalr $25 7253 7254 then the linker will resolve both relocations to .data and the program 7255 will jump there rather than to .text. 7256 7257 We can work around this problem by giving names to local section symbols. 7258 This is also what the MIPSpro tools do. */ 7259 7260 bfd_boolean 7261 _bfd_mips_elf_name_local_section_symbols (bfd *abfd) 7262 { 7263 return elf_elfheader (abfd)->e_type == ET_REL && SGI_COMPAT (abfd); 7264 } 7265 7266 /* Work over a section just before writing it out. This routine is 7267 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize 7268 sections that need the SHF_MIPS_GPREL flag by name; there has to be 7269 a better way. */ 7270 7271 bfd_boolean 7272 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr) 7273 { 7274 if (hdr->sh_type == SHT_MIPS_REGINFO 7275 && hdr->sh_size > 0) 7276 { 7277 bfd_byte buf[4]; 7278 7279 BFD_ASSERT (hdr->contents == NULL); 7280 7281 if (hdr->sh_size != sizeof (Elf32_External_RegInfo)) 7282 { 7283 _bfd_error_handler 7284 (_("%pB: incorrect `.reginfo' section size; " 7285 "expected %" PRIu64 ", got %" PRIu64), 7286 abfd, (uint64_t) sizeof (Elf32_External_RegInfo), 7287 (uint64_t) hdr->sh_size); 7288 bfd_set_error (bfd_error_bad_value); 7289 return FALSE; 7290 } 7291 7292 if (bfd_seek (abfd, 7293 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4, 7294 SEEK_SET) != 0) 7295 return FALSE; 7296 H_PUT_32 (abfd, elf_gp (abfd), buf); 7297 if (bfd_bwrite (buf, 4, abfd) != 4) 7298 return FALSE; 7299 } 7300 7301 if (hdr->sh_type == SHT_MIPS_OPTIONS 7302 && hdr->bfd_section != NULL 7303 && mips_elf_section_data (hdr->bfd_section) != NULL 7304 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL) 7305 { 7306 bfd_byte *contents, *l, *lend; 7307 7308 /* We stored the section contents in the tdata field in the 7309 set_section_contents routine. We save the section contents 7310 so that we don't have to read them again. 7311 At this point we know that elf_gp is set, so we can look 7312 through the section contents to see if there is an 7313 ODK_REGINFO structure. */ 7314 7315 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata; 7316 l = contents; 7317 lend = contents + hdr->sh_size; 7318 while (l + sizeof (Elf_External_Options) <= lend) 7319 { 7320 Elf_Internal_Options intopt; 7321 7322 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l, 7323 &intopt); 7324 if (intopt.size < sizeof (Elf_External_Options)) 7325 { 7326 _bfd_error_handler 7327 /* xgettext:c-format */ 7328 (_("%pB: warning: bad `%s' option size %u smaller than" 7329 " its header"), 7330 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size); 7331 break; 7332 } 7333 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO) 7334 { 7335 bfd_byte buf[8]; 7336 7337 if (bfd_seek (abfd, 7338 (hdr->sh_offset 7339 + (l - contents) 7340 + sizeof (Elf_External_Options) 7341 + (sizeof (Elf64_External_RegInfo) - 8)), 7342 SEEK_SET) != 0) 7343 return FALSE; 7344 H_PUT_64 (abfd, elf_gp (abfd), buf); 7345 if (bfd_bwrite (buf, 8, abfd) != 8) 7346 return FALSE; 7347 } 7348 else if (intopt.kind == ODK_REGINFO) 7349 { 7350 bfd_byte buf[4]; 7351 7352 if (bfd_seek (abfd, 7353 (hdr->sh_offset 7354 + (l - contents) 7355 + sizeof (Elf_External_Options) 7356 + (sizeof (Elf32_External_RegInfo) - 4)), 7357 SEEK_SET) != 0) 7358 return FALSE; 7359 H_PUT_32 (abfd, elf_gp (abfd), buf); 7360 if (bfd_bwrite (buf, 4, abfd) != 4) 7361 return FALSE; 7362 } 7363 l += intopt.size; 7364 } 7365 } 7366 7367 if (hdr->bfd_section != NULL) 7368 { 7369 const char *name = bfd_section_name (hdr->bfd_section); 7370 7371 /* .sbss is not handled specially here because the GNU/Linux 7372 prelinker can convert .sbss from NOBITS to PROGBITS and 7373 changing it back to NOBITS breaks the binary. The entry in 7374 _bfd_mips_elf_special_sections will ensure the correct flags 7375 are set on .sbss if BFD creates it without reading it from an 7376 input file, and without special handling here the flags set 7377 on it in an input file will be followed. */ 7378 if (strcmp (name, ".sdata") == 0 7379 || strcmp (name, ".lit8") == 0 7380 || strcmp (name, ".lit4") == 0) 7381 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL; 7382 else if (strcmp (name, ".srdata") == 0) 7383 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL; 7384 else if (strcmp (name, ".compact_rel") == 0) 7385 hdr->sh_flags = 0; 7386 else if (strcmp (name, ".rtproc") == 0) 7387 { 7388 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0) 7389 { 7390 unsigned int adjust; 7391 7392 adjust = hdr->sh_size % hdr->sh_addralign; 7393 if (adjust != 0) 7394 hdr->sh_size += hdr->sh_addralign - adjust; 7395 } 7396 } 7397 } 7398 7399 return TRUE; 7400 } 7401 7402 /* Handle a MIPS specific section when reading an object file. This 7403 is called when elfcode.h finds a section with an unknown type. 7404 This routine supports both the 32-bit and 64-bit ELF ABI. */ 7405 7406 bfd_boolean 7407 _bfd_mips_elf_section_from_shdr (bfd *abfd, 7408 Elf_Internal_Shdr *hdr, 7409 const char *name, 7410 int shindex) 7411 { 7412 flagword flags = 0; 7413 7414 /* There ought to be a place to keep ELF backend specific flags, but 7415 at the moment there isn't one. We just keep track of the 7416 sections by their name, instead. Fortunately, the ABI gives 7417 suggested names for all the MIPS specific sections, so we will 7418 probably get away with this. */ 7419 switch (hdr->sh_type) 7420 { 7421 case SHT_MIPS_LIBLIST: 7422 if (strcmp (name, ".liblist") != 0) 7423 return FALSE; 7424 break; 7425 case SHT_MIPS_MSYM: 7426 if (strcmp (name, ".msym") != 0) 7427 return FALSE; 7428 break; 7429 case SHT_MIPS_CONFLICT: 7430 if (strcmp (name, ".conflict") != 0) 7431 return FALSE; 7432 break; 7433 case SHT_MIPS_GPTAB: 7434 if (! CONST_STRNEQ (name, ".gptab.")) 7435 return FALSE; 7436 break; 7437 case SHT_MIPS_UCODE: 7438 if (strcmp (name, ".ucode") != 0) 7439 return FALSE; 7440 break; 7441 case SHT_MIPS_DEBUG: 7442 if (strcmp (name, ".mdebug") != 0) 7443 return FALSE; 7444 flags = SEC_DEBUGGING; 7445 break; 7446 case SHT_MIPS_REGINFO: 7447 if (strcmp (name, ".reginfo") != 0 7448 || hdr->sh_size != sizeof (Elf32_External_RegInfo)) 7449 return FALSE; 7450 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE); 7451 break; 7452 case SHT_MIPS_IFACE: 7453 if (strcmp (name, ".MIPS.interfaces") != 0) 7454 return FALSE; 7455 break; 7456 case SHT_MIPS_CONTENT: 7457 if (! CONST_STRNEQ (name, ".MIPS.content")) 7458 return FALSE; 7459 break; 7460 case SHT_MIPS_OPTIONS: 7461 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name)) 7462 return FALSE; 7463 break; 7464 case SHT_MIPS_ABIFLAGS: 7465 if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name)) 7466 return FALSE; 7467 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE); 7468 break; 7469 case SHT_MIPS_DWARF: 7470 if (! CONST_STRNEQ (name, ".debug_") 7471 && ! CONST_STRNEQ (name, ".zdebug_")) 7472 return FALSE; 7473 break; 7474 case SHT_MIPS_SYMBOL_LIB: 7475 if (strcmp (name, ".MIPS.symlib") != 0) 7476 return FALSE; 7477 break; 7478 case SHT_MIPS_EVENTS: 7479 if (! CONST_STRNEQ (name, ".MIPS.events") 7480 && ! CONST_STRNEQ (name, ".MIPS.post_rel")) 7481 return FALSE; 7482 break; 7483 case SHT_MIPS_XHASH: 7484 if (strcmp (name, ".MIPS.xhash") != 0) 7485 return FALSE; 7486 default: 7487 break; 7488 } 7489 7490 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 7491 return FALSE; 7492 7493 if (hdr->sh_flags & SHF_MIPS_GPREL) 7494 flags |= SEC_SMALL_DATA; 7495 7496 if (flags) 7497 { 7498 if (!bfd_set_section_flags (hdr->bfd_section, 7499 (bfd_section_flags (hdr->bfd_section) 7500 | flags))) 7501 return FALSE; 7502 } 7503 7504 if (hdr->sh_type == SHT_MIPS_ABIFLAGS) 7505 { 7506 Elf_External_ABIFlags_v0 ext; 7507 7508 if (! bfd_get_section_contents (abfd, hdr->bfd_section, 7509 &ext, 0, sizeof ext)) 7510 return FALSE; 7511 bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext, 7512 &mips_elf_tdata (abfd)->abiflags); 7513 if (mips_elf_tdata (abfd)->abiflags.version != 0) 7514 return FALSE; 7515 mips_elf_tdata (abfd)->abiflags_valid = TRUE; 7516 } 7517 7518 /* FIXME: We should record sh_info for a .gptab section. */ 7519 7520 /* For a .reginfo section, set the gp value in the tdata information 7521 from the contents of this section. We need the gp value while 7522 processing relocs, so we just get it now. The .reginfo section 7523 is not used in the 64-bit MIPS ELF ABI. */ 7524 if (hdr->sh_type == SHT_MIPS_REGINFO) 7525 { 7526 Elf32_External_RegInfo ext; 7527 Elf32_RegInfo s; 7528 7529 if (! bfd_get_section_contents (abfd, hdr->bfd_section, 7530 &ext, 0, sizeof ext)) 7531 return FALSE; 7532 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s); 7533 elf_gp (abfd) = s.ri_gp_value; 7534 } 7535 7536 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and 7537 set the gp value based on what we find. We may see both 7538 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case, 7539 they should agree. */ 7540 if (hdr->sh_type == SHT_MIPS_OPTIONS) 7541 { 7542 bfd_byte *contents, *l, *lend; 7543 7544 contents = bfd_malloc (hdr->sh_size); 7545 if (contents == NULL) 7546 return FALSE; 7547 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents, 7548 0, hdr->sh_size)) 7549 { 7550 free (contents); 7551 return FALSE; 7552 } 7553 l = contents; 7554 lend = contents + hdr->sh_size; 7555 while (l + sizeof (Elf_External_Options) <= lend) 7556 { 7557 Elf_Internal_Options intopt; 7558 7559 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l, 7560 &intopt); 7561 if (intopt.size < sizeof (Elf_External_Options)) 7562 { 7563 _bfd_error_handler 7564 /* xgettext:c-format */ 7565 (_("%pB: warning: bad `%s' option size %u smaller than" 7566 " its header"), 7567 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size); 7568 break; 7569 } 7570 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO) 7571 { 7572 Elf64_Internal_RegInfo intreg; 7573 7574 bfd_mips_elf64_swap_reginfo_in 7575 (abfd, 7576 ((Elf64_External_RegInfo *) 7577 (l + sizeof (Elf_External_Options))), 7578 &intreg); 7579 elf_gp (abfd) = intreg.ri_gp_value; 7580 } 7581 else if (intopt.kind == ODK_REGINFO) 7582 { 7583 Elf32_RegInfo intreg; 7584 7585 bfd_mips_elf32_swap_reginfo_in 7586 (abfd, 7587 ((Elf32_External_RegInfo *) 7588 (l + sizeof (Elf_External_Options))), 7589 &intreg); 7590 elf_gp (abfd) = intreg.ri_gp_value; 7591 } 7592 l += intopt.size; 7593 } 7594 free (contents); 7595 } 7596 7597 return TRUE; 7598 } 7599 7600 /* Set the correct type for a MIPS ELF section. We do this by the 7601 section name, which is a hack, but ought to work. This routine is 7602 used by both the 32-bit and the 64-bit ABI. */ 7603 7604 bfd_boolean 7605 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec) 7606 { 7607 const char *name = bfd_section_name (sec); 7608 7609 if (strcmp (name, ".liblist") == 0) 7610 { 7611 hdr->sh_type = SHT_MIPS_LIBLIST; 7612 hdr->sh_info = sec->size / sizeof (Elf32_Lib); 7613 /* The sh_link field is set in final_write_processing. */ 7614 } 7615 else if (strcmp (name, ".conflict") == 0) 7616 hdr->sh_type = SHT_MIPS_CONFLICT; 7617 else if (CONST_STRNEQ (name, ".gptab.")) 7618 { 7619 hdr->sh_type = SHT_MIPS_GPTAB; 7620 hdr->sh_entsize = sizeof (Elf32_External_gptab); 7621 /* The sh_info field is set in final_write_processing. */ 7622 } 7623 else if (strcmp (name, ".ucode") == 0) 7624 hdr->sh_type = SHT_MIPS_UCODE; 7625 else if (strcmp (name, ".mdebug") == 0) 7626 { 7627 hdr->sh_type = SHT_MIPS_DEBUG; 7628 /* In a shared object on IRIX 5.3, the .mdebug section has an 7629 entsize of 0. FIXME: Does this matter? */ 7630 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0) 7631 hdr->sh_entsize = 0; 7632 else 7633 hdr->sh_entsize = 1; 7634 } 7635 else if (strcmp (name, ".reginfo") == 0) 7636 { 7637 hdr->sh_type = SHT_MIPS_REGINFO; 7638 /* In a shared object on IRIX 5.3, the .reginfo section has an 7639 entsize of 0x18. FIXME: Does this matter? */ 7640 if (SGI_COMPAT (abfd)) 7641 { 7642 if ((abfd->flags & DYNAMIC) != 0) 7643 hdr->sh_entsize = sizeof (Elf32_External_RegInfo); 7644 else 7645 hdr->sh_entsize = 1; 7646 } 7647 else 7648 hdr->sh_entsize = sizeof (Elf32_External_RegInfo); 7649 } 7650 else if (SGI_COMPAT (abfd) 7651 && (strcmp (name, ".hash") == 0 7652 || strcmp (name, ".dynamic") == 0 7653 || strcmp (name, ".dynstr") == 0)) 7654 { 7655 if (SGI_COMPAT (abfd)) 7656 hdr->sh_entsize = 0; 7657 #if 0 7658 /* This isn't how the IRIX6 linker behaves. */ 7659 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES; 7660 #endif 7661 } 7662 else if (strcmp (name, ".got") == 0 7663 || strcmp (name, ".srdata") == 0 7664 || strcmp (name, ".sdata") == 0 7665 || strcmp (name, ".sbss") == 0 7666 || strcmp (name, ".lit4") == 0 7667 || strcmp (name, ".lit8") == 0) 7668 hdr->sh_flags |= SHF_MIPS_GPREL; 7669 else if (strcmp (name, ".MIPS.interfaces") == 0) 7670 { 7671 hdr->sh_type = SHT_MIPS_IFACE; 7672 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 7673 } 7674 else if (CONST_STRNEQ (name, ".MIPS.content")) 7675 { 7676 hdr->sh_type = SHT_MIPS_CONTENT; 7677 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 7678 /* The sh_info field is set in final_write_processing. */ 7679 } 7680 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name)) 7681 { 7682 hdr->sh_type = SHT_MIPS_OPTIONS; 7683 hdr->sh_entsize = 1; 7684 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 7685 } 7686 else if (CONST_STRNEQ (name, ".MIPS.abiflags")) 7687 { 7688 hdr->sh_type = SHT_MIPS_ABIFLAGS; 7689 hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0); 7690 } 7691 else if (CONST_STRNEQ (name, ".debug_") 7692 || CONST_STRNEQ (name, ".zdebug_")) 7693 { 7694 hdr->sh_type = SHT_MIPS_DWARF; 7695 7696 /* Irix facilities such as libexc expect a single .debug_frame 7697 per executable, the system ones have NOSTRIP set and the linker 7698 doesn't merge sections with different flags so ... */ 7699 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame")) 7700 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 7701 } 7702 else if (strcmp (name, ".MIPS.symlib") == 0) 7703 { 7704 hdr->sh_type = SHT_MIPS_SYMBOL_LIB; 7705 /* The sh_link and sh_info fields are set in 7706 final_write_processing. */ 7707 } 7708 else if (CONST_STRNEQ (name, ".MIPS.events") 7709 || CONST_STRNEQ (name, ".MIPS.post_rel")) 7710 { 7711 hdr->sh_type = SHT_MIPS_EVENTS; 7712 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 7713 /* The sh_link field is set in final_write_processing. */ 7714 } 7715 else if (strcmp (name, ".msym") == 0) 7716 { 7717 hdr->sh_type = SHT_MIPS_MSYM; 7718 hdr->sh_flags |= SHF_ALLOC; 7719 hdr->sh_entsize = 8; 7720 } 7721 else if (strcmp (name, ".MIPS.xhash") == 0) 7722 { 7723 hdr->sh_type = SHT_MIPS_XHASH; 7724 hdr->sh_flags |= SHF_ALLOC; 7725 hdr->sh_entsize = get_elf_backend_data(abfd)->s->arch_size == 64 ? 0 : 4; 7726 } 7727 7728 /* The generic elf_fake_sections will set up REL_HDR using the default 7729 kind of relocations. We used to set up a second header for the 7730 non-default kind of relocations here, but only NewABI would use 7731 these, and the IRIX ld doesn't like resulting empty RELA sections. 7732 Thus we create those header only on demand now. */ 7733 7734 return TRUE; 7735 } 7736 7737 /* Given a BFD section, try to locate the corresponding ELF section 7738 index. This is used by both the 32-bit and the 64-bit ABI. 7739 Actually, it's not clear to me that the 64-bit ABI supports these, 7740 but for non-PIC objects we will certainly want support for at least 7741 the .scommon section. */ 7742 7743 bfd_boolean 7744 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 7745 asection *sec, int *retval) 7746 { 7747 if (strcmp (bfd_section_name (sec), ".scommon") == 0) 7748 { 7749 *retval = SHN_MIPS_SCOMMON; 7750 return TRUE; 7751 } 7752 if (strcmp (bfd_section_name (sec), ".acommon") == 0) 7753 { 7754 *retval = SHN_MIPS_ACOMMON; 7755 return TRUE; 7756 } 7757 return FALSE; 7758 } 7759 7760 /* Hook called by the linker routine which adds symbols from an object 7761 file. We must handle the special MIPS section numbers here. */ 7762 7763 bfd_boolean 7764 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, 7765 Elf_Internal_Sym *sym, const char **namep, 7766 flagword *flagsp ATTRIBUTE_UNUSED, 7767 asection **secp, bfd_vma *valp) 7768 { 7769 if (SGI_COMPAT (abfd) 7770 && (abfd->flags & DYNAMIC) != 0 7771 && strcmp (*namep, "_rld_new_interface") == 0) 7772 { 7773 /* Skip IRIX5 rld entry name. */ 7774 *namep = NULL; 7775 return TRUE; 7776 } 7777 7778 /* Shared objects may have a dynamic symbol '_gp_disp' defined as 7779 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp 7780 by setting a DT_NEEDED for the shared object. Since _gp_disp is 7781 a magic symbol resolved by the linker, we ignore this bogus definition 7782 of _gp_disp. New ABI objects do not suffer from this problem so this 7783 is not done for them. */ 7784 if (!NEWABI_P(abfd) 7785 && (sym->st_shndx == SHN_ABS) 7786 && (strcmp (*namep, "_gp_disp") == 0)) 7787 { 7788 *namep = NULL; 7789 return TRUE; 7790 } 7791 7792 switch (sym->st_shndx) 7793 { 7794 case SHN_COMMON: 7795 /* Common symbols less than the GP size are automatically 7796 treated as SHN_MIPS_SCOMMON symbols. */ 7797 if (sym->st_size > elf_gp_size (abfd) 7798 || ELF_ST_TYPE (sym->st_info) == STT_TLS 7799 || IRIX_COMPAT (abfd) == ict_irix6) 7800 break; 7801 /* Fall through. */ 7802 case SHN_MIPS_SCOMMON: 7803 *secp = bfd_make_section_old_way (abfd, ".scommon"); 7804 (*secp)->flags |= SEC_IS_COMMON | SEC_SMALL_DATA; 7805 *valp = sym->st_size; 7806 break; 7807 7808 case SHN_MIPS_TEXT: 7809 /* This section is used in a shared object. */ 7810 if (mips_elf_tdata (abfd)->elf_text_section == NULL) 7811 { 7812 asymbol *elf_text_symbol; 7813 asection *elf_text_section; 7814 size_t amt = sizeof (asection); 7815 7816 elf_text_section = bfd_zalloc (abfd, amt); 7817 if (elf_text_section == NULL) 7818 return FALSE; 7819 7820 amt = sizeof (asymbol); 7821 elf_text_symbol = bfd_zalloc (abfd, amt); 7822 if (elf_text_symbol == NULL) 7823 return FALSE; 7824 7825 /* Initialize the section. */ 7826 7827 mips_elf_tdata (abfd)->elf_text_section = elf_text_section; 7828 mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol; 7829 7830 elf_text_section->symbol = elf_text_symbol; 7831 elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol; 7832 7833 elf_text_section->name = ".text"; 7834 elf_text_section->flags = SEC_NO_FLAGS; 7835 elf_text_section->output_section = NULL; 7836 elf_text_section->owner = abfd; 7837 elf_text_symbol->name = ".text"; 7838 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC; 7839 elf_text_symbol->section = elf_text_section; 7840 } 7841 /* This code used to do *secp = bfd_und_section_ptr if 7842 bfd_link_pic (info). I don't know why, and that doesn't make sense, 7843 so I took it out. */ 7844 *secp = mips_elf_tdata (abfd)->elf_text_section; 7845 break; 7846 7847 case SHN_MIPS_ACOMMON: 7848 /* Fall through. XXX Can we treat this as allocated data? */ 7849 case SHN_MIPS_DATA: 7850 /* This section is used in a shared object. */ 7851 if (mips_elf_tdata (abfd)->elf_data_section == NULL) 7852 { 7853 asymbol *elf_data_symbol; 7854 asection *elf_data_section; 7855 size_t amt = sizeof (asection); 7856 7857 elf_data_section = bfd_zalloc (abfd, amt); 7858 if (elf_data_section == NULL) 7859 return FALSE; 7860 7861 amt = sizeof (asymbol); 7862 elf_data_symbol = bfd_zalloc (abfd, amt); 7863 if (elf_data_symbol == NULL) 7864 return FALSE; 7865 7866 /* Initialize the section. */ 7867 7868 mips_elf_tdata (abfd)->elf_data_section = elf_data_section; 7869 mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol; 7870 7871 elf_data_section->symbol = elf_data_symbol; 7872 elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol; 7873 7874 elf_data_section->name = ".data"; 7875 elf_data_section->flags = SEC_NO_FLAGS; 7876 elf_data_section->output_section = NULL; 7877 elf_data_section->owner = abfd; 7878 elf_data_symbol->name = ".data"; 7879 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC; 7880 elf_data_symbol->section = elf_data_section; 7881 } 7882 /* This code used to do *secp = bfd_und_section_ptr if 7883 bfd_link_pic (info). I don't know why, and that doesn't make sense, 7884 so I took it out. */ 7885 *secp = mips_elf_tdata (abfd)->elf_data_section; 7886 break; 7887 7888 case SHN_MIPS_SUNDEFINED: 7889 *secp = bfd_und_section_ptr; 7890 break; 7891 } 7892 7893 if (SGI_COMPAT (abfd) 7894 && ! bfd_link_pic (info) 7895 && info->output_bfd->xvec == abfd->xvec 7896 && strcmp (*namep, "__rld_obj_head") == 0) 7897 { 7898 struct elf_link_hash_entry *h; 7899 struct bfd_link_hash_entry *bh; 7900 7901 /* Mark __rld_obj_head as dynamic. */ 7902 bh = NULL; 7903 if (! (_bfd_generic_link_add_one_symbol 7904 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE, 7905 get_elf_backend_data (abfd)->collect, &bh))) 7906 return FALSE; 7907 7908 h = (struct elf_link_hash_entry *) bh; 7909 h->non_elf = 0; 7910 h->def_regular = 1; 7911 h->type = STT_OBJECT; 7912 7913 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 7914 return FALSE; 7915 7916 mips_elf_hash_table (info)->use_rld_obj_head = TRUE; 7917 mips_elf_hash_table (info)->rld_symbol = h; 7918 } 7919 7920 /* If this is a mips16 text symbol, add 1 to the value to make it 7921 odd. This will cause something like .word SYM to come up with 7922 the right value when it is loaded into the PC. */ 7923 if (ELF_ST_IS_COMPRESSED (sym->st_other)) 7924 ++*valp; 7925 7926 return TRUE; 7927 } 7928 7929 /* This hook function is called before the linker writes out a global 7930 symbol. We mark symbols as small common if appropriate. This is 7931 also where we undo the increment of the value for a mips16 symbol. */ 7932 7933 int 7934 _bfd_mips_elf_link_output_symbol_hook 7935 (struct bfd_link_info *info ATTRIBUTE_UNUSED, 7936 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym, 7937 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 7938 { 7939 /* If we see a common symbol, which implies a relocatable link, then 7940 if a symbol was small common in an input file, mark it as small 7941 common in the output file. */ 7942 if (sym->st_shndx == SHN_COMMON 7943 && strcmp (input_sec->name, ".scommon") == 0) 7944 sym->st_shndx = SHN_MIPS_SCOMMON; 7945 7946 if (ELF_ST_IS_COMPRESSED (sym->st_other)) 7947 sym->st_value &= ~1; 7948 7949 return 1; 7950 } 7951 7952 /* Functions for the dynamic linker. */ 7953 7954 /* Create dynamic sections when linking against a dynamic object. */ 7955 7956 bfd_boolean 7957 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 7958 { 7959 struct elf_link_hash_entry *h; 7960 struct bfd_link_hash_entry *bh; 7961 flagword flags; 7962 register asection *s; 7963 const char * const *namep; 7964 struct mips_elf_link_hash_table *htab; 7965 7966 htab = mips_elf_hash_table (info); 7967 BFD_ASSERT (htab != NULL); 7968 7969 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 7970 | SEC_LINKER_CREATED | SEC_READONLY); 7971 7972 /* The psABI requires a read-only .dynamic section, but the VxWorks 7973 EABI doesn't. */ 7974 if (htab->root.target_os != is_vxworks) 7975 { 7976 s = bfd_get_linker_section (abfd, ".dynamic"); 7977 if (s != NULL) 7978 { 7979 if (!bfd_set_section_flags (s, flags)) 7980 return FALSE; 7981 } 7982 } 7983 7984 /* We need to create .got section. */ 7985 if (!mips_elf_create_got_section (abfd, info)) 7986 return FALSE; 7987 7988 if (! mips_elf_rel_dyn_section (info, TRUE)) 7989 return FALSE; 7990 7991 /* Create .stub section. */ 7992 s = bfd_make_section_anyway_with_flags (abfd, 7993 MIPS_ELF_STUB_SECTION_NAME (abfd), 7994 flags | SEC_CODE); 7995 if (s == NULL 7996 || !bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd))) 7997 return FALSE; 7998 htab->sstubs = s; 7999 8000 if (!mips_elf_hash_table (info)->use_rld_obj_head 8001 && bfd_link_executable (info) 8002 && bfd_get_linker_section (abfd, ".rld_map") == NULL) 8003 { 8004 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map", 8005 flags &~ (flagword) SEC_READONLY); 8006 if (s == NULL 8007 || !bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd))) 8008 return FALSE; 8009 } 8010 8011 /* Create .MIPS.xhash section. */ 8012 if (info->emit_gnu_hash) 8013 s = bfd_make_section_anyway_with_flags (abfd, ".MIPS.xhash", 8014 flags | SEC_READONLY); 8015 8016 /* On IRIX5, we adjust add some additional symbols and change the 8017 alignments of several sections. There is no ABI documentation 8018 indicating that this is necessary on IRIX6, nor any evidence that 8019 the linker takes such action. */ 8020 if (IRIX_COMPAT (abfd) == ict_irix5) 8021 { 8022 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++) 8023 { 8024 bh = NULL; 8025 if (! (_bfd_generic_link_add_one_symbol 8026 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0, 8027 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 8028 return FALSE; 8029 8030 h = (struct elf_link_hash_entry *) bh; 8031 h->mark = 1; 8032 h->non_elf = 0; 8033 h->def_regular = 1; 8034 h->type = STT_SECTION; 8035 8036 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8037 return FALSE; 8038 } 8039 8040 /* We need to create a .compact_rel section. */ 8041 if (SGI_COMPAT (abfd)) 8042 { 8043 if (!mips_elf_create_compact_rel_section (abfd, info)) 8044 return FALSE; 8045 } 8046 8047 /* Change alignments of some sections. */ 8048 s = bfd_get_linker_section (abfd, ".hash"); 8049 if (s != NULL) 8050 bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 8051 8052 s = bfd_get_linker_section (abfd, ".dynsym"); 8053 if (s != NULL) 8054 bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 8055 8056 s = bfd_get_linker_section (abfd, ".dynstr"); 8057 if (s != NULL) 8058 bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 8059 8060 /* ??? */ 8061 s = bfd_get_section_by_name (abfd, ".reginfo"); 8062 if (s != NULL) 8063 bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 8064 8065 s = bfd_get_linker_section (abfd, ".dynamic"); 8066 if (s != NULL) 8067 bfd_set_section_alignment (s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 8068 } 8069 8070 if (bfd_link_executable (info)) 8071 { 8072 const char *name; 8073 8074 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING"; 8075 bh = NULL; 8076 if (!(_bfd_generic_link_add_one_symbol 8077 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0, 8078 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 8079 return FALSE; 8080 8081 h = (struct elf_link_hash_entry *) bh; 8082 h->non_elf = 0; 8083 h->def_regular = 1; 8084 h->type = STT_SECTION; 8085 8086 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8087 return FALSE; 8088 8089 if (! mips_elf_hash_table (info)->use_rld_obj_head) 8090 { 8091 /* __rld_map is a four byte word located in the .data section 8092 and is filled in by the rtld to contain a pointer to 8093 the _r_debug structure. Its symbol value will be set in 8094 _bfd_mips_elf_finish_dynamic_symbol. */ 8095 s = bfd_get_linker_section (abfd, ".rld_map"); 8096 BFD_ASSERT (s != NULL); 8097 8098 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP"; 8099 bh = NULL; 8100 if (!(_bfd_generic_link_add_one_symbol 8101 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE, 8102 get_elf_backend_data (abfd)->collect, &bh))) 8103 return FALSE; 8104 8105 h = (struct elf_link_hash_entry *) bh; 8106 h->non_elf = 0; 8107 h->def_regular = 1; 8108 h->type = STT_OBJECT; 8109 8110 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 8111 return FALSE; 8112 mips_elf_hash_table (info)->rld_symbol = h; 8113 } 8114 } 8115 8116 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections. 8117 Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol. */ 8118 if (!_bfd_elf_create_dynamic_sections (abfd, info)) 8119 return FALSE; 8120 8121 /* Do the usual VxWorks handling. */ 8122 if (htab->root.target_os == is_vxworks 8123 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) 8124 return FALSE; 8125 8126 return TRUE; 8127 } 8128 8129 /* Return true if relocation REL against section SEC is a REL rather than 8130 RELA relocation. RELOCS is the first relocation in the section and 8131 ABFD is the bfd that contains SEC. */ 8132 8133 static bfd_boolean 8134 mips_elf_rel_relocation_p (bfd *abfd, asection *sec, 8135 const Elf_Internal_Rela *relocs, 8136 const Elf_Internal_Rela *rel) 8137 { 8138 Elf_Internal_Shdr *rel_hdr; 8139 const struct elf_backend_data *bed; 8140 8141 /* To determine which flavor of relocation this is, we depend on the 8142 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */ 8143 rel_hdr = elf_section_data (sec)->rel.hdr; 8144 if (rel_hdr == NULL) 8145 return FALSE; 8146 bed = get_elf_backend_data (abfd); 8147 return ((size_t) (rel - relocs) 8148 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel); 8149 } 8150 8151 /* Read the addend for REL relocation REL, which belongs to bfd ABFD. 8152 HOWTO is the relocation's howto and CONTENTS points to the contents 8153 of the section that REL is against. */ 8154 8155 static bfd_vma 8156 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel, 8157 reloc_howto_type *howto, bfd_byte *contents) 8158 { 8159 bfd_byte *location; 8160 unsigned int r_type; 8161 bfd_vma addend; 8162 bfd_vma bytes; 8163 8164 r_type = ELF_R_TYPE (abfd, rel->r_info); 8165 location = contents + rel->r_offset; 8166 8167 /* Get the addend, which is stored in the input file. */ 8168 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location); 8169 bytes = mips_elf_obtain_contents (howto, rel, abfd, contents); 8170 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location); 8171 8172 addend = bytes & howto->src_mask; 8173 8174 /* Shift is 2, unusually, for microMIPS JALX. Adjust the addend 8175 accordingly. */ 8176 if (r_type == R_MICROMIPS_26_S1 && (bytes >> 26) == 0x3c) 8177 addend <<= 1; 8178 8179 return addend; 8180 } 8181 8182 /* REL is a relocation in ABFD that needs a partnering LO16 relocation 8183 and *ADDEND is the addend for REL itself. Look for the LO16 relocation 8184 and update *ADDEND with the final addend. Return true on success 8185 or false if the LO16 could not be found. RELEND is the exclusive 8186 upper bound on the relocations for REL's section. */ 8187 8188 static bfd_boolean 8189 mips_elf_add_lo16_rel_addend (bfd *abfd, 8190 const Elf_Internal_Rela *rel, 8191 const Elf_Internal_Rela *relend, 8192 bfd_byte *contents, bfd_vma *addend) 8193 { 8194 unsigned int r_type, lo16_type; 8195 const Elf_Internal_Rela *lo16_relocation; 8196 reloc_howto_type *lo16_howto; 8197 bfd_vma l; 8198 8199 r_type = ELF_R_TYPE (abfd, rel->r_info); 8200 if (mips16_reloc_p (r_type)) 8201 lo16_type = R_MIPS16_LO16; 8202 else if (micromips_reloc_p (r_type)) 8203 lo16_type = R_MICROMIPS_LO16; 8204 else if (r_type == R_MIPS_PCHI16) 8205 lo16_type = R_MIPS_PCLO16; 8206 else 8207 lo16_type = R_MIPS_LO16; 8208 8209 /* The combined value is the sum of the HI16 addend, left-shifted by 8210 sixteen bits, and the LO16 addend, sign extended. (Usually, the 8211 code does a `lui' of the HI16 value, and then an `addiu' of the 8212 LO16 value.) 8213 8214 Scan ahead to find a matching LO16 relocation. 8215 8216 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must 8217 be immediately following. However, for the IRIX6 ABI, the next 8218 relocation may be a composed relocation consisting of several 8219 relocations for the same address. In that case, the R_MIPS_LO16 8220 relocation may occur as one of these. We permit a similar 8221 extension in general, as that is useful for GCC. 8222 8223 In some cases GCC dead code elimination removes the LO16 but keeps 8224 the corresponding HI16. This is strictly speaking a violation of 8225 the ABI but not immediately harmful. */ 8226 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend); 8227 if (lo16_relocation == NULL) 8228 return FALSE; 8229 8230 /* Obtain the addend kept there. */ 8231 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE); 8232 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents); 8233 8234 l <<= lo16_howto->rightshift; 8235 l = _bfd_mips_elf_sign_extend (l, 16); 8236 8237 *addend <<= 16; 8238 *addend += l; 8239 return TRUE; 8240 } 8241 8242 /* Try to read the contents of section SEC in bfd ABFD. Return true and 8243 store the contents in *CONTENTS on success. Assume that *CONTENTS 8244 already holds the contents if it is nonull on entry. */ 8245 8246 static bfd_boolean 8247 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents) 8248 { 8249 if (*contents) 8250 return TRUE; 8251 8252 /* Get cached copy if it exists. */ 8253 if (elf_section_data (sec)->this_hdr.contents != NULL) 8254 { 8255 *contents = elf_section_data (sec)->this_hdr.contents; 8256 return TRUE; 8257 } 8258 8259 return bfd_malloc_and_get_section (abfd, sec, contents); 8260 } 8261 8262 /* Make a new PLT record to keep internal data. */ 8263 8264 static struct plt_entry * 8265 mips_elf_make_plt_record (bfd *abfd) 8266 { 8267 struct plt_entry *entry; 8268 8269 entry = bfd_zalloc (abfd, sizeof (*entry)); 8270 if (entry == NULL) 8271 return NULL; 8272 8273 entry->stub_offset = MINUS_ONE; 8274 entry->mips_offset = MINUS_ONE; 8275 entry->comp_offset = MINUS_ONE; 8276 entry->gotplt_index = MINUS_ONE; 8277 return entry; 8278 } 8279 8280 /* Define the special `__gnu_absolute_zero' symbol. We only need this 8281 for PIC code, as otherwise there is no load-time relocation involved 8282 and local GOT entries whose value is zero at static link time will 8283 retain their value at load time. */ 8284 8285 static bfd_boolean 8286 mips_elf_define_absolute_zero (bfd *abfd, struct bfd_link_info *info, 8287 struct mips_elf_link_hash_table *htab, 8288 unsigned int r_type) 8289 { 8290 union 8291 { 8292 struct elf_link_hash_entry *eh; 8293 struct bfd_link_hash_entry *bh; 8294 } 8295 hzero; 8296 8297 BFD_ASSERT (!htab->use_absolute_zero); 8298 BFD_ASSERT (bfd_link_pic (info)); 8299 8300 hzero.bh = NULL; 8301 if (!_bfd_generic_link_add_one_symbol (info, abfd, "__gnu_absolute_zero", 8302 BSF_GLOBAL, bfd_abs_section_ptr, 0, 8303 NULL, FALSE, FALSE, &hzero.bh)) 8304 return FALSE; 8305 8306 BFD_ASSERT (hzero.bh != NULL); 8307 hzero.eh->size = 0; 8308 hzero.eh->type = STT_NOTYPE; 8309 hzero.eh->other = STV_PROTECTED; 8310 hzero.eh->def_regular = 1; 8311 hzero.eh->non_elf = 0; 8312 8313 if (!mips_elf_record_global_got_symbol (hzero.eh, abfd, info, TRUE, r_type)) 8314 return FALSE; 8315 8316 htab->use_absolute_zero = TRUE; 8317 8318 return TRUE; 8319 } 8320 8321 /* Look through the relocs for a section during the first phase, and 8322 allocate space in the global offset table and record the need for 8323 standard MIPS and compressed procedure linkage table entries. */ 8324 8325 bfd_boolean 8326 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 8327 asection *sec, const Elf_Internal_Rela *relocs) 8328 { 8329 const char *name; 8330 bfd *dynobj; 8331 Elf_Internal_Shdr *symtab_hdr; 8332 struct elf_link_hash_entry **sym_hashes; 8333 size_t extsymoff; 8334 const Elf_Internal_Rela *rel; 8335 const Elf_Internal_Rela *rel_end; 8336 asection *sreloc; 8337 const struct elf_backend_data *bed; 8338 struct mips_elf_link_hash_table *htab; 8339 bfd_byte *contents; 8340 bfd_vma addend; 8341 reloc_howto_type *howto; 8342 8343 if (bfd_link_relocatable (info)) 8344 return TRUE; 8345 8346 htab = mips_elf_hash_table (info); 8347 BFD_ASSERT (htab != NULL); 8348 8349 dynobj = elf_hash_table (info)->dynobj; 8350 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 8351 sym_hashes = elf_sym_hashes (abfd); 8352 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info; 8353 8354 bed = get_elf_backend_data (abfd); 8355 rel_end = relocs + sec->reloc_count; 8356 8357 /* Check for the mips16 stub sections. */ 8358 8359 name = bfd_section_name (sec); 8360 if (FN_STUB_P (name)) 8361 { 8362 unsigned long r_symndx; 8363 8364 /* Look at the relocation information to figure out which symbol 8365 this is for. */ 8366 8367 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end); 8368 if (r_symndx == 0) 8369 { 8370 _bfd_error_handler 8371 /* xgettext:c-format */ 8372 (_("%pB: warning: cannot determine the target function for" 8373 " stub section `%s'"), 8374 abfd, name); 8375 bfd_set_error (bfd_error_bad_value); 8376 return FALSE; 8377 } 8378 8379 if (r_symndx < extsymoff 8380 || sym_hashes[r_symndx - extsymoff] == NULL) 8381 { 8382 asection *o; 8383 8384 /* This stub is for a local symbol. This stub will only be 8385 needed if there is some relocation in this BFD, other 8386 than a 16 bit function call, which refers to this symbol. */ 8387 for (o = abfd->sections; o != NULL; o = o->next) 8388 { 8389 Elf_Internal_Rela *sec_relocs; 8390 const Elf_Internal_Rela *r, *rend; 8391 8392 /* We can ignore stub sections when looking for relocs. */ 8393 if ((o->flags & SEC_RELOC) == 0 8394 || o->reloc_count == 0 8395 || section_allows_mips16_refs_p (o)) 8396 continue; 8397 8398 sec_relocs 8399 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 8400 info->keep_memory); 8401 if (sec_relocs == NULL) 8402 return FALSE; 8403 8404 rend = sec_relocs + o->reloc_count; 8405 for (r = sec_relocs; r < rend; r++) 8406 if (ELF_R_SYM (abfd, r->r_info) == r_symndx 8407 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info))) 8408 break; 8409 8410 if (elf_section_data (o)->relocs != sec_relocs) 8411 free (sec_relocs); 8412 8413 if (r < rend) 8414 break; 8415 } 8416 8417 if (o == NULL) 8418 { 8419 /* There is no non-call reloc for this stub, so we do 8420 not need it. Since this function is called before 8421 the linker maps input sections to output sections, we 8422 can easily discard it by setting the SEC_EXCLUDE 8423 flag. */ 8424 sec->flags |= SEC_EXCLUDE; 8425 return TRUE; 8426 } 8427 8428 /* Record this stub in an array of local symbol stubs for 8429 this BFD. */ 8430 if (mips_elf_tdata (abfd)->local_stubs == NULL) 8431 { 8432 unsigned long symcount; 8433 asection **n; 8434 bfd_size_type amt; 8435 8436 if (elf_bad_symtab (abfd)) 8437 symcount = NUM_SHDR_ENTRIES (symtab_hdr); 8438 else 8439 symcount = symtab_hdr->sh_info; 8440 amt = symcount * sizeof (asection *); 8441 n = bfd_zalloc (abfd, amt); 8442 if (n == NULL) 8443 return FALSE; 8444 mips_elf_tdata (abfd)->local_stubs = n; 8445 } 8446 8447 sec->flags |= SEC_KEEP; 8448 mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec; 8449 8450 /* We don't need to set mips16_stubs_seen in this case. 8451 That flag is used to see whether we need to look through 8452 the global symbol table for stubs. We don't need to set 8453 it here, because we just have a local stub. */ 8454 } 8455 else 8456 { 8457 struct mips_elf_link_hash_entry *h; 8458 8459 h = ((struct mips_elf_link_hash_entry *) 8460 sym_hashes[r_symndx - extsymoff]); 8461 8462 while (h->root.root.type == bfd_link_hash_indirect 8463 || h->root.root.type == bfd_link_hash_warning) 8464 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 8465 8466 /* H is the symbol this stub is for. */ 8467 8468 /* If we already have an appropriate stub for this function, we 8469 don't need another one, so we can discard this one. Since 8470 this function is called before the linker maps input sections 8471 to output sections, we can easily discard it by setting the 8472 SEC_EXCLUDE flag. */ 8473 if (h->fn_stub != NULL) 8474 { 8475 sec->flags |= SEC_EXCLUDE; 8476 return TRUE; 8477 } 8478 8479 sec->flags |= SEC_KEEP; 8480 h->fn_stub = sec; 8481 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE; 8482 } 8483 } 8484 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name)) 8485 { 8486 unsigned long r_symndx; 8487 struct mips_elf_link_hash_entry *h; 8488 asection **loc; 8489 8490 /* Look at the relocation information to figure out which symbol 8491 this is for. */ 8492 8493 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end); 8494 if (r_symndx == 0) 8495 { 8496 _bfd_error_handler 8497 /* xgettext:c-format */ 8498 (_("%pB: warning: cannot determine the target function for" 8499 " stub section `%s'"), 8500 abfd, name); 8501 bfd_set_error (bfd_error_bad_value); 8502 return FALSE; 8503 } 8504 8505 if (r_symndx < extsymoff 8506 || sym_hashes[r_symndx - extsymoff] == NULL) 8507 { 8508 asection *o; 8509 8510 /* This stub is for a local symbol. This stub will only be 8511 needed if there is some relocation (R_MIPS16_26) in this BFD 8512 that refers to this symbol. */ 8513 for (o = abfd->sections; o != NULL; o = o->next) 8514 { 8515 Elf_Internal_Rela *sec_relocs; 8516 const Elf_Internal_Rela *r, *rend; 8517 8518 /* We can ignore stub sections when looking for relocs. */ 8519 if ((o->flags & SEC_RELOC) == 0 8520 || o->reloc_count == 0 8521 || section_allows_mips16_refs_p (o)) 8522 continue; 8523 8524 sec_relocs 8525 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 8526 info->keep_memory); 8527 if (sec_relocs == NULL) 8528 return FALSE; 8529 8530 rend = sec_relocs + o->reloc_count; 8531 for (r = sec_relocs; r < rend; r++) 8532 if (ELF_R_SYM (abfd, r->r_info) == r_symndx 8533 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26) 8534 break; 8535 8536 if (elf_section_data (o)->relocs != sec_relocs) 8537 free (sec_relocs); 8538 8539 if (r < rend) 8540 break; 8541 } 8542 8543 if (o == NULL) 8544 { 8545 /* There is no non-call reloc for this stub, so we do 8546 not need it. Since this function is called before 8547 the linker maps input sections to output sections, we 8548 can easily discard it by setting the SEC_EXCLUDE 8549 flag. */ 8550 sec->flags |= SEC_EXCLUDE; 8551 return TRUE; 8552 } 8553 8554 /* Record this stub in an array of local symbol call_stubs for 8555 this BFD. */ 8556 if (mips_elf_tdata (abfd)->local_call_stubs == NULL) 8557 { 8558 unsigned long symcount; 8559 asection **n; 8560 bfd_size_type amt; 8561 8562 if (elf_bad_symtab (abfd)) 8563 symcount = NUM_SHDR_ENTRIES (symtab_hdr); 8564 else 8565 symcount = symtab_hdr->sh_info; 8566 amt = symcount * sizeof (asection *); 8567 n = bfd_zalloc (abfd, amt); 8568 if (n == NULL) 8569 return FALSE; 8570 mips_elf_tdata (abfd)->local_call_stubs = n; 8571 } 8572 8573 sec->flags |= SEC_KEEP; 8574 mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec; 8575 8576 /* We don't need to set mips16_stubs_seen in this case. 8577 That flag is used to see whether we need to look through 8578 the global symbol table for stubs. We don't need to set 8579 it here, because we just have a local stub. */ 8580 } 8581 else 8582 { 8583 h = ((struct mips_elf_link_hash_entry *) 8584 sym_hashes[r_symndx - extsymoff]); 8585 8586 /* H is the symbol this stub is for. */ 8587 8588 if (CALL_FP_STUB_P (name)) 8589 loc = &h->call_fp_stub; 8590 else 8591 loc = &h->call_stub; 8592 8593 /* If we already have an appropriate stub for this function, we 8594 don't need another one, so we can discard this one. Since 8595 this function is called before the linker maps input sections 8596 to output sections, we can easily discard it by setting the 8597 SEC_EXCLUDE flag. */ 8598 if (*loc != NULL) 8599 { 8600 sec->flags |= SEC_EXCLUDE; 8601 return TRUE; 8602 } 8603 8604 sec->flags |= SEC_KEEP; 8605 *loc = sec; 8606 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE; 8607 } 8608 } 8609 8610 sreloc = NULL; 8611 contents = NULL; 8612 for (rel = relocs; rel < rel_end; ++rel) 8613 { 8614 unsigned long r_symndx; 8615 unsigned int r_type; 8616 struct elf_link_hash_entry *h; 8617 bfd_boolean can_make_dynamic_p; 8618 bfd_boolean call_reloc_p; 8619 bfd_boolean constrain_symbol_p; 8620 8621 r_symndx = ELF_R_SYM (abfd, rel->r_info); 8622 r_type = ELF_R_TYPE (abfd, rel->r_info); 8623 8624 if (r_symndx < extsymoff) 8625 h = NULL; 8626 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr)) 8627 { 8628 _bfd_error_handler 8629 /* xgettext:c-format */ 8630 (_("%pB: malformed reloc detected for section %s"), 8631 abfd, name); 8632 bfd_set_error (bfd_error_bad_value); 8633 return FALSE; 8634 } 8635 else 8636 { 8637 h = sym_hashes[r_symndx - extsymoff]; 8638 if (h != NULL) 8639 { 8640 while (h->root.type == bfd_link_hash_indirect 8641 || h->root.type == bfd_link_hash_warning) 8642 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8643 } 8644 } 8645 8646 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this 8647 relocation into a dynamic one. */ 8648 can_make_dynamic_p = FALSE; 8649 8650 /* Set CALL_RELOC_P to true if the relocation is for a call, 8651 and if pointer equality therefore doesn't matter. */ 8652 call_reloc_p = FALSE; 8653 8654 /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation 8655 into account when deciding how to define the symbol. */ 8656 constrain_symbol_p = TRUE; 8657 8658 switch (r_type) 8659 { 8660 case R_MIPS_CALL16: 8661 case R_MIPS_CALL_HI16: 8662 case R_MIPS_CALL_LO16: 8663 case R_MIPS16_CALL16: 8664 case R_MICROMIPS_CALL16: 8665 case R_MICROMIPS_CALL_HI16: 8666 case R_MICROMIPS_CALL_LO16: 8667 call_reloc_p = TRUE; 8668 /* Fall through. */ 8669 8670 case R_MIPS_GOT16: 8671 case R_MIPS_GOT_LO16: 8672 case R_MIPS_GOT_PAGE: 8673 case R_MIPS_GOT_DISP: 8674 case R_MIPS16_GOT16: 8675 case R_MICROMIPS_GOT16: 8676 case R_MICROMIPS_GOT_LO16: 8677 case R_MICROMIPS_GOT_PAGE: 8678 case R_MICROMIPS_GOT_DISP: 8679 /* If we have a symbol that will resolve to zero at static link 8680 time and it is used by a GOT relocation applied to code we 8681 cannot relax to an immediate zero load, then we will be using 8682 the special `__gnu_absolute_zero' symbol whose value is zero 8683 at dynamic load time. We ignore HI16-type GOT relocations at 8684 this stage, because their handling will depend entirely on 8685 the corresponding LO16-type GOT relocation. */ 8686 if (!call_hi16_reloc_p (r_type) 8687 && h != NULL 8688 && bfd_link_pic (info) 8689 && !htab->use_absolute_zero 8690 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 8691 { 8692 bfd_boolean rel_reloc; 8693 8694 if (!mips_elf_get_section_contents (abfd, sec, &contents)) 8695 return FALSE; 8696 8697 rel_reloc = mips_elf_rel_relocation_p (abfd, sec, relocs, rel); 8698 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, !rel_reloc); 8699 8700 if (!mips_elf_nullify_got_load (abfd, contents, rel, howto, 8701 FALSE)) 8702 if (!mips_elf_define_absolute_zero (abfd, info, htab, r_type)) 8703 return FALSE; 8704 } 8705 8706 /* Fall through. */ 8707 case R_MIPS_GOT_HI16: 8708 case R_MIPS_GOT_OFST: 8709 case R_MIPS_TLS_GOTTPREL: 8710 case R_MIPS_TLS_GD: 8711 case R_MIPS_TLS_LDM: 8712 case R_MIPS16_TLS_GOTTPREL: 8713 case R_MIPS16_TLS_GD: 8714 case R_MIPS16_TLS_LDM: 8715 case R_MICROMIPS_GOT_HI16: 8716 case R_MICROMIPS_GOT_OFST: 8717 case R_MICROMIPS_TLS_GOTTPREL: 8718 case R_MICROMIPS_TLS_GD: 8719 case R_MICROMIPS_TLS_LDM: 8720 if (dynobj == NULL) 8721 elf_hash_table (info)->dynobj = dynobj = abfd; 8722 if (!mips_elf_create_got_section (dynobj, info)) 8723 return FALSE; 8724 if (htab->root.target_os == is_vxworks 8725 && !bfd_link_pic (info)) 8726 { 8727 _bfd_error_handler 8728 /* xgettext:c-format */ 8729 (_("%pB: GOT reloc at %#" PRIx64 " not expected in executables"), 8730 abfd, (uint64_t) rel->r_offset); 8731 bfd_set_error (bfd_error_bad_value); 8732 return FALSE; 8733 } 8734 can_make_dynamic_p = TRUE; 8735 break; 8736 8737 case R_MIPS_NONE: 8738 case R_MIPS_JALR: 8739 case R_MICROMIPS_JALR: 8740 /* These relocations have empty fields and are purely there to 8741 provide link information. The symbol value doesn't matter. */ 8742 constrain_symbol_p = FALSE; 8743 break; 8744 8745 case R_MIPS_GPREL16: 8746 case R_MIPS_GPREL32: 8747 case R_MIPS16_GPREL: 8748 case R_MICROMIPS_GPREL16: 8749 /* GP-relative relocations always resolve to a definition in a 8750 regular input file, ignoring the one-definition rule. This is 8751 important for the GP setup sequence in NewABI code, which 8752 always resolves to a local function even if other relocations 8753 against the symbol wouldn't. */ 8754 constrain_symbol_p = FALSE; 8755 break; 8756 8757 case R_MIPS_32: 8758 case R_MIPS_REL32: 8759 case R_MIPS_64: 8760 /* In VxWorks executables, references to external symbols 8761 must be handled using copy relocs or PLT entries; it is not 8762 possible to convert this relocation into a dynamic one. 8763 8764 For executables that use PLTs and copy-relocs, we have a 8765 choice between converting the relocation into a dynamic 8766 one or using copy relocations or PLT entries. It is 8767 usually better to do the former, unless the relocation is 8768 against a read-only section. */ 8769 if ((bfd_link_pic (info) 8770 || (h != NULL 8771 && htab->root.target_os != is_vxworks 8772 && strcmp (h->root.root.string, "__gnu_local_gp") != 0 8773 && !(!info->nocopyreloc 8774 && !PIC_OBJECT_P (abfd) 8775 && MIPS_ELF_READONLY_SECTION (sec)))) 8776 && (sec->flags & SEC_ALLOC) != 0) 8777 { 8778 can_make_dynamic_p = TRUE; 8779 if (dynobj == NULL) 8780 elf_hash_table (info)->dynobj = dynobj = abfd; 8781 } 8782 break; 8783 8784 case R_MIPS_26: 8785 case R_MIPS_PC16: 8786 case R_MIPS_PC21_S2: 8787 case R_MIPS_PC26_S2: 8788 case R_MIPS16_26: 8789 case R_MIPS16_PC16_S1: 8790 case R_MICROMIPS_26_S1: 8791 case R_MICROMIPS_PC7_S1: 8792 case R_MICROMIPS_PC10_S1: 8793 case R_MICROMIPS_PC16_S1: 8794 case R_MICROMIPS_PC23_S2: 8795 call_reloc_p = TRUE; 8796 break; 8797 } 8798 8799 if (h) 8800 { 8801 if (constrain_symbol_p) 8802 { 8803 if (!can_make_dynamic_p) 8804 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1; 8805 8806 if (!call_reloc_p) 8807 h->pointer_equality_needed = 1; 8808 8809 /* We must not create a stub for a symbol that has 8810 relocations related to taking the function's address. 8811 This doesn't apply to VxWorks, where CALL relocs refer 8812 to a .got.plt entry instead of a normal .got entry. */ 8813 if (htab->root.target_os != is_vxworks 8814 && (!can_make_dynamic_p || !call_reloc_p)) 8815 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE; 8816 } 8817 8818 /* Relocations against the special VxWorks __GOTT_BASE__ and 8819 __GOTT_INDEX__ symbols must be left to the loader. Allocate 8820 room for them in .rela.dyn. */ 8821 if (is_gott_symbol (info, h)) 8822 { 8823 if (sreloc == NULL) 8824 { 8825 sreloc = mips_elf_rel_dyn_section (info, TRUE); 8826 if (sreloc == NULL) 8827 return FALSE; 8828 } 8829 mips_elf_allocate_dynamic_relocations (dynobj, info, 1); 8830 if (MIPS_ELF_READONLY_SECTION (sec)) 8831 /* We tell the dynamic linker that there are 8832 relocations against the text segment. */ 8833 info->flags |= DF_TEXTREL; 8834 } 8835 } 8836 else if (call_lo16_reloc_p (r_type) 8837 || got_lo16_reloc_p (r_type) 8838 || got_disp_reloc_p (r_type) 8839 || (got16_reloc_p (r_type) 8840 && htab->root.target_os == is_vxworks)) 8841 { 8842 /* We may need a local GOT entry for this relocation. We 8843 don't count R_MIPS_GOT_PAGE because we can estimate the 8844 maximum number of pages needed by looking at the size of 8845 the segment. Similar comments apply to R_MIPS*_GOT16 and 8846 R_MIPS*_CALL16, except on VxWorks, where GOT relocations 8847 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or 8848 R_MIPS_CALL_HI16 because these are always followed by an 8849 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */ 8850 if (!mips_elf_record_local_got_symbol (abfd, r_symndx, 8851 rel->r_addend, info, r_type)) 8852 return FALSE; 8853 } 8854 8855 if (h != NULL 8856 && mips_elf_relocation_needs_la25_stub (abfd, r_type, 8857 ELF_ST_IS_MIPS16 (h->other))) 8858 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE; 8859 8860 switch (r_type) 8861 { 8862 case R_MIPS_CALL16: 8863 case R_MIPS16_CALL16: 8864 case R_MICROMIPS_CALL16: 8865 if (h == NULL) 8866 { 8867 _bfd_error_handler 8868 /* xgettext:c-format */ 8869 (_("%pB: CALL16 reloc at %#" PRIx64 " not against global symbol"), 8870 abfd, (uint64_t) rel->r_offset); 8871 bfd_set_error (bfd_error_bad_value); 8872 return FALSE; 8873 } 8874 /* Fall through. */ 8875 8876 case R_MIPS_CALL_HI16: 8877 case R_MIPS_CALL_LO16: 8878 case R_MICROMIPS_CALL_HI16: 8879 case R_MICROMIPS_CALL_LO16: 8880 if (h != NULL) 8881 { 8882 /* Make sure there is room in the regular GOT to hold the 8883 function's address. We may eliminate it in favour of 8884 a .got.plt entry later; see mips_elf_count_got_symbols. */ 8885 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE, 8886 r_type)) 8887 return FALSE; 8888 8889 /* We need a stub, not a plt entry for the undefined 8890 function. But we record it as if it needs plt. See 8891 _bfd_elf_adjust_dynamic_symbol. */ 8892 h->needs_plt = 1; 8893 h->type = STT_FUNC; 8894 } 8895 break; 8896 8897 case R_MIPS_GOT_PAGE: 8898 case R_MICROMIPS_GOT_PAGE: 8899 case R_MIPS16_GOT16: 8900 case R_MIPS_GOT16: 8901 case R_MIPS_GOT_HI16: 8902 case R_MIPS_GOT_LO16: 8903 case R_MICROMIPS_GOT16: 8904 case R_MICROMIPS_GOT_HI16: 8905 case R_MICROMIPS_GOT_LO16: 8906 if (!h || got_page_reloc_p (r_type)) 8907 { 8908 /* This relocation needs (or may need, if h != NULL) a 8909 page entry in the GOT. For R_MIPS_GOT_PAGE we do not 8910 know for sure until we know whether the symbol is 8911 preemptible. */ 8912 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel)) 8913 { 8914 if (!mips_elf_get_section_contents (abfd, sec, &contents)) 8915 return FALSE; 8916 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE); 8917 addend = mips_elf_read_rel_addend (abfd, rel, 8918 howto, contents); 8919 if (got16_reloc_p (r_type)) 8920 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end, 8921 contents, &addend); 8922 else 8923 addend <<= howto->rightshift; 8924 } 8925 else 8926 addend = rel->r_addend; 8927 if (!mips_elf_record_got_page_ref (info, abfd, r_symndx, 8928 h, addend)) 8929 return FALSE; 8930 8931 if (h) 8932 { 8933 struct mips_elf_link_hash_entry *hmips = 8934 (struct mips_elf_link_hash_entry *) h; 8935 8936 /* This symbol is definitely not overridable. */ 8937 if (hmips->root.def_regular 8938 && ! (bfd_link_pic (info) && ! info->symbolic 8939 && ! hmips->root.forced_local)) 8940 h = NULL; 8941 } 8942 } 8943 /* If this is a global, overridable symbol, GOT_PAGE will 8944 decay to GOT_DISP, so we'll need a GOT entry for it. */ 8945 /* Fall through. */ 8946 8947 case R_MIPS_GOT_DISP: 8948 case R_MICROMIPS_GOT_DISP: 8949 if (h && !mips_elf_record_global_got_symbol (h, abfd, info, 8950 FALSE, r_type)) 8951 return FALSE; 8952 break; 8953 8954 case R_MIPS_TLS_GOTTPREL: 8955 case R_MIPS16_TLS_GOTTPREL: 8956 case R_MICROMIPS_TLS_GOTTPREL: 8957 if (bfd_link_pic (info)) 8958 info->flags |= DF_STATIC_TLS; 8959 /* Fall through */ 8960 8961 case R_MIPS_TLS_LDM: 8962 case R_MIPS16_TLS_LDM: 8963 case R_MICROMIPS_TLS_LDM: 8964 if (tls_ldm_reloc_p (r_type)) 8965 { 8966 r_symndx = STN_UNDEF; 8967 h = NULL; 8968 } 8969 /* Fall through */ 8970 8971 case R_MIPS_TLS_GD: 8972 case R_MIPS16_TLS_GD: 8973 case R_MICROMIPS_TLS_GD: 8974 /* This symbol requires a global offset table entry, or two 8975 for TLS GD relocations. */ 8976 if (h != NULL) 8977 { 8978 if (!mips_elf_record_global_got_symbol (h, abfd, info, 8979 FALSE, r_type)) 8980 return FALSE; 8981 } 8982 else 8983 { 8984 if (!mips_elf_record_local_got_symbol (abfd, r_symndx, 8985 rel->r_addend, 8986 info, r_type)) 8987 return FALSE; 8988 } 8989 break; 8990 8991 case R_MIPS_32: 8992 case R_MIPS_REL32: 8993 case R_MIPS_64: 8994 /* In VxWorks executables, references to external symbols 8995 are handled using copy relocs or PLT stubs, so there's 8996 no need to add a .rela.dyn entry for this relocation. */ 8997 if (can_make_dynamic_p) 8998 { 8999 if (sreloc == NULL) 9000 { 9001 sreloc = mips_elf_rel_dyn_section (info, TRUE); 9002 if (sreloc == NULL) 9003 return FALSE; 9004 } 9005 if (bfd_link_pic (info) && h == NULL) 9006 { 9007 /* When creating a shared object, we must copy these 9008 reloc types into the output file as R_MIPS_REL32 9009 relocs. Make room for this reloc in .rel(a).dyn. */ 9010 mips_elf_allocate_dynamic_relocations (dynobj, info, 1); 9011 if (MIPS_ELF_READONLY_SECTION (sec)) 9012 /* We tell the dynamic linker that there are 9013 relocations against the text segment. */ 9014 info->flags |= DF_TEXTREL; 9015 } 9016 else 9017 { 9018 struct mips_elf_link_hash_entry *hmips; 9019 9020 /* For a shared object, we must copy this relocation 9021 unless the symbol turns out to be undefined and 9022 weak with non-default visibility, in which case 9023 it will be left as zero. 9024 9025 We could elide R_MIPS_REL32 for locally binding symbols 9026 in shared libraries, but do not yet do so. 9027 9028 For an executable, we only need to copy this 9029 reloc if the symbol is defined in a dynamic 9030 object. */ 9031 hmips = (struct mips_elf_link_hash_entry *) h; 9032 ++hmips->possibly_dynamic_relocs; 9033 if (MIPS_ELF_READONLY_SECTION (sec)) 9034 /* We need it to tell the dynamic linker if there 9035 are relocations against the text segment. */ 9036 hmips->readonly_reloc = TRUE; 9037 } 9038 } 9039 9040 if (SGI_COMPAT (abfd)) 9041 mips_elf_hash_table (info)->compact_rel_size += 9042 sizeof (Elf32_External_crinfo); 9043 break; 9044 9045 case R_MIPS_26: 9046 case R_MIPS_GPREL16: 9047 case R_MIPS_LITERAL: 9048 case R_MIPS_GPREL32: 9049 case R_MICROMIPS_26_S1: 9050 case R_MICROMIPS_GPREL16: 9051 case R_MICROMIPS_LITERAL: 9052 case R_MICROMIPS_GPREL7_S2: 9053 if (SGI_COMPAT (abfd)) 9054 mips_elf_hash_table (info)->compact_rel_size += 9055 sizeof (Elf32_External_crinfo); 9056 break; 9057 9058 /* This relocation describes the C++ object vtable hierarchy. 9059 Reconstruct it for later use during GC. */ 9060 case R_MIPS_GNU_VTINHERIT: 9061 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 9062 return FALSE; 9063 break; 9064 9065 /* This relocation describes which C++ vtable entries are actually 9066 used. Record for later use during GC. */ 9067 case R_MIPS_GNU_VTENTRY: 9068 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 9069 return FALSE; 9070 break; 9071 9072 default: 9073 break; 9074 } 9075 9076 /* Record the need for a PLT entry. At this point we don't know 9077 yet if we are going to create a PLT in the first place, but 9078 we only record whether the relocation requires a standard MIPS 9079 or a compressed code entry anyway. If we don't make a PLT after 9080 all, then we'll just ignore these arrangements. Likewise if 9081 a PLT entry is not created because the symbol is satisfied 9082 locally. */ 9083 if (h != NULL 9084 && (branch_reloc_p (r_type) 9085 || mips16_branch_reloc_p (r_type) 9086 || micromips_branch_reloc_p (r_type)) 9087 && !SYMBOL_CALLS_LOCAL (info, h)) 9088 { 9089 if (h->plt.plist == NULL) 9090 h->plt.plist = mips_elf_make_plt_record (abfd); 9091 if (h->plt.plist == NULL) 9092 return FALSE; 9093 9094 if (branch_reloc_p (r_type)) 9095 h->plt.plist->need_mips = TRUE; 9096 else 9097 h->plt.plist->need_comp = TRUE; 9098 } 9099 9100 /* See if this reloc would need to refer to a MIPS16 hard-float stub, 9101 if there is one. We only need to handle global symbols here; 9102 we decide whether to keep or delete stubs for local symbols 9103 when processing the stub's relocations. */ 9104 if (h != NULL 9105 && !mips16_call_reloc_p (r_type) 9106 && !section_allows_mips16_refs_p (sec)) 9107 { 9108 struct mips_elf_link_hash_entry *mh; 9109 9110 mh = (struct mips_elf_link_hash_entry *) h; 9111 mh->need_fn_stub = TRUE; 9112 } 9113 9114 /* Refuse some position-dependent relocations when creating a 9115 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're 9116 not PIC, but we can create dynamic relocations and the result 9117 will be fine. Also do not refuse R_MIPS_LO16, which can be 9118 combined with R_MIPS_GOT16. */ 9119 if (bfd_link_pic (info)) 9120 { 9121 switch (r_type) 9122 { 9123 case R_MIPS_TLS_TPREL_HI16: 9124 case R_MIPS16_TLS_TPREL_HI16: 9125 case R_MICROMIPS_TLS_TPREL_HI16: 9126 case R_MIPS_TLS_TPREL_LO16: 9127 case R_MIPS16_TLS_TPREL_LO16: 9128 case R_MICROMIPS_TLS_TPREL_LO16: 9129 /* These are okay in PIE, but not in a shared library. */ 9130 if (bfd_link_executable (info)) 9131 break; 9132 9133 /* FALLTHROUGH */ 9134 9135 case R_MIPS16_HI16: 9136 case R_MIPS_HI16: 9137 case R_MIPS_HIGHER: 9138 case R_MIPS_HIGHEST: 9139 case R_MICROMIPS_HI16: 9140 case R_MICROMIPS_HIGHER: 9141 case R_MICROMIPS_HIGHEST: 9142 /* Don't refuse a high part relocation if it's against 9143 no symbol (e.g. part of a compound relocation). */ 9144 if (r_symndx == STN_UNDEF) 9145 break; 9146 9147 /* Likewise an absolute symbol. */ 9148 if (h != NULL && bfd_is_abs_symbol (&h->root)) 9149 break; 9150 9151 /* R_MIPS_HI16 against _gp_disp is used for $gp setup, 9152 and has a special meaning. */ 9153 if (!NEWABI_P (abfd) && h != NULL 9154 && strcmp (h->root.root.string, "_gp_disp") == 0) 9155 break; 9156 9157 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */ 9158 if (is_gott_symbol (info, h)) 9159 break; 9160 9161 /* FALLTHROUGH */ 9162 9163 case R_MIPS16_26: 9164 case R_MIPS_26: 9165 case R_MICROMIPS_26_S1: 9166 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, NEWABI_P (abfd)); 9167 /* An error for unsupported relocations is raised as part 9168 of the above search, so we can skip the following. */ 9169 if (howto != NULL) 9170 info->callbacks->einfo 9171 /* xgettext:c-format */ 9172 (_("%X%H: relocation %s against `%s' cannot be used" 9173 " when making a shared object; recompile with -fPIC\n"), 9174 abfd, sec, rel->r_offset, howto->name, 9175 (h) ? h->root.root.string : "a local symbol"); 9176 break; 9177 default: 9178 break; 9179 } 9180 } 9181 } 9182 9183 return TRUE; 9184 } 9185 9186 /* Allocate space for global sym dynamic relocs. */ 9187 9188 static bfd_boolean 9189 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 9190 { 9191 struct bfd_link_info *info = inf; 9192 bfd *dynobj; 9193 struct mips_elf_link_hash_entry *hmips; 9194 struct mips_elf_link_hash_table *htab; 9195 9196 htab = mips_elf_hash_table (info); 9197 BFD_ASSERT (htab != NULL); 9198 9199 dynobj = elf_hash_table (info)->dynobj; 9200 hmips = (struct mips_elf_link_hash_entry *) h; 9201 9202 /* VxWorks executables are handled elsewhere; we only need to 9203 allocate relocations in shared objects. */ 9204 if (htab->root.target_os == is_vxworks && !bfd_link_pic (info)) 9205 return TRUE; 9206 9207 /* Ignore indirect symbols. All relocations against such symbols 9208 will be redirected to the target symbol. */ 9209 if (h->root.type == bfd_link_hash_indirect) 9210 return TRUE; 9211 9212 /* If this symbol is defined in a dynamic object, or we are creating 9213 a shared library, we will need to copy any R_MIPS_32 or 9214 R_MIPS_REL32 relocs against it into the output file. */ 9215 if (! bfd_link_relocatable (info) 9216 && hmips->possibly_dynamic_relocs != 0 9217 && (h->root.type == bfd_link_hash_defweak 9218 || (!h->def_regular && !ELF_COMMON_DEF_P (h)) 9219 || bfd_link_pic (info))) 9220 { 9221 bfd_boolean do_copy = TRUE; 9222 9223 if (h->root.type == bfd_link_hash_undefweak) 9224 { 9225 /* Do not copy relocations for undefined weak symbols that 9226 we are not going to export. */ 9227 if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 9228 do_copy = FALSE; 9229 9230 /* Make sure undefined weak symbols are output as a dynamic 9231 symbol in PIEs. */ 9232 else if (h->dynindx == -1 && !h->forced_local) 9233 { 9234 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 9235 return FALSE; 9236 } 9237 } 9238 9239 if (do_copy) 9240 { 9241 /* Even though we don't directly need a GOT entry for this symbol, 9242 the SVR4 psABI requires it to have a dynamic symbol table 9243 index greater that DT_MIPS_GOTSYM if there are dynamic 9244 relocations against it. 9245 9246 VxWorks does not enforce the same mapping between the GOT 9247 and the symbol table, so the same requirement does not 9248 apply there. */ 9249 if (htab->root.target_os != is_vxworks) 9250 { 9251 if (hmips->global_got_area > GGA_RELOC_ONLY) 9252 hmips->global_got_area = GGA_RELOC_ONLY; 9253 hmips->got_only_for_calls = FALSE; 9254 } 9255 9256 mips_elf_allocate_dynamic_relocations 9257 (dynobj, info, hmips->possibly_dynamic_relocs); 9258 if (hmips->readonly_reloc) 9259 /* We tell the dynamic linker that there are relocations 9260 against the text segment. */ 9261 info->flags |= DF_TEXTREL; 9262 } 9263 } 9264 9265 return TRUE; 9266 } 9267 9268 /* Adjust a symbol defined by a dynamic object and referenced by a 9269 regular object. The current definition is in some section of the 9270 dynamic object, but we're not including those sections. We have to 9271 change the definition to something the rest of the link can 9272 understand. */ 9273 9274 bfd_boolean 9275 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 9276 struct elf_link_hash_entry *h) 9277 { 9278 bfd *dynobj; 9279 struct mips_elf_link_hash_entry *hmips; 9280 struct mips_elf_link_hash_table *htab; 9281 asection *s, *srel; 9282 9283 htab = mips_elf_hash_table (info); 9284 BFD_ASSERT (htab != NULL); 9285 9286 dynobj = elf_hash_table (info)->dynobj; 9287 hmips = (struct mips_elf_link_hash_entry *) h; 9288 9289 /* Make sure we know what is going on here. */ 9290 if (dynobj == NULL 9291 || (! h->needs_plt 9292 && ! h->is_weakalias 9293 && (! h->def_dynamic 9294 || ! h->ref_regular 9295 || h->def_regular))) 9296 { 9297 if (h->type == STT_GNU_IFUNC) 9298 _bfd_error_handler (_("IFUNC symbol %s in dynamic symbol table - IFUNCS are not supported"), 9299 h->root.root.string); 9300 else 9301 _bfd_error_handler (_("non-dynamic symbol %s in dynamic symbol table"), 9302 h->root.root.string); 9303 return TRUE; 9304 } 9305 9306 hmips = (struct mips_elf_link_hash_entry *) h; 9307 9308 /* If there are call relocations against an externally-defined symbol, 9309 see whether we can create a MIPS lazy-binding stub for it. We can 9310 only do this if all references to the function are through call 9311 relocations, and in that case, the traditional lazy-binding stubs 9312 are much more efficient than PLT entries. 9313 9314 Traditional stubs are only available on SVR4 psABI-based systems; 9315 VxWorks always uses PLTs instead. */ 9316 if (htab->root.target_os != is_vxworks 9317 && h->needs_plt 9318 && !hmips->no_fn_stub) 9319 { 9320 if (! elf_hash_table (info)->dynamic_sections_created) 9321 return TRUE; 9322 9323 /* If this symbol is not defined in a regular file, then set 9324 the symbol to the stub location. This is required to make 9325 function pointers compare as equal between the normal 9326 executable and the shared library. */ 9327 if (!h->def_regular 9328 && !bfd_is_abs_section (htab->sstubs->output_section)) 9329 { 9330 hmips->needs_lazy_stub = TRUE; 9331 htab->lazy_stub_count++; 9332 return TRUE; 9333 } 9334 } 9335 /* As above, VxWorks requires PLT entries for externally-defined 9336 functions that are only accessed through call relocations. 9337 9338 Both VxWorks and non-VxWorks targets also need PLT entries if there 9339 are static-only relocations against an externally-defined function. 9340 This can technically occur for shared libraries if there are 9341 branches to the symbol, although it is unlikely that this will be 9342 used in practice due to the short ranges involved. It can occur 9343 for any relative or absolute relocation in executables; in that 9344 case, the PLT entry becomes the function's canonical address. */ 9345 else if (((h->needs_plt && !hmips->no_fn_stub) 9346 || (h->type == STT_FUNC && hmips->has_static_relocs)) 9347 && htab->use_plts_and_copy_relocs 9348 && !SYMBOL_CALLS_LOCAL (info, h) 9349 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 9350 && h->root.type == bfd_link_hash_undefweak)) 9351 { 9352 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd); 9353 bfd_boolean newabi_p = NEWABI_P (info->output_bfd); 9354 9355 /* If this is the first symbol to need a PLT entry, then make some 9356 basic setup. Also work out PLT entry sizes. We'll need them 9357 for PLT offset calculations. */ 9358 if (htab->plt_mips_offset + htab->plt_comp_offset == 0) 9359 { 9360 BFD_ASSERT (htab->root.sgotplt->size == 0); 9361 BFD_ASSERT (htab->plt_got_index == 0); 9362 9363 /* If we're using the PLT additions to the psABI, each PLT 9364 entry is 16 bytes and the PLT0 entry is 32 bytes. 9365 Encourage better cache usage by aligning. We do this 9366 lazily to avoid pessimizing traditional objects. */ 9367 if (htab->root.target_os != is_vxworks 9368 && !bfd_set_section_alignment (htab->root.splt, 5)) 9369 return FALSE; 9370 9371 /* Make sure that .got.plt is word-aligned. We do this lazily 9372 for the same reason as above. */ 9373 if (!bfd_set_section_alignment (htab->root.sgotplt, 9374 MIPS_ELF_LOG_FILE_ALIGN (dynobj))) 9375 return FALSE; 9376 9377 /* On non-VxWorks targets, the first two entries in .got.plt 9378 are reserved. */ 9379 if (htab->root.target_os != is_vxworks) 9380 htab->plt_got_index 9381 += (get_elf_backend_data (dynobj)->got_header_size 9382 / MIPS_ELF_GOT_SIZE (dynobj)); 9383 9384 /* On VxWorks, also allocate room for the header's 9385 .rela.plt.unloaded entries. */ 9386 if (htab->root.target_os == is_vxworks 9387 && !bfd_link_pic (info)) 9388 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela); 9389 9390 /* Now work out the sizes of individual PLT entries. */ 9391 if (htab->root.target_os == is_vxworks 9392 && bfd_link_pic (info)) 9393 htab->plt_mips_entry_size 9394 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry); 9395 else if (htab->root.target_os == is_vxworks) 9396 htab->plt_mips_entry_size 9397 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry); 9398 else if (newabi_p) 9399 htab->plt_mips_entry_size 9400 = 4 * ARRAY_SIZE (mips_exec_plt_entry); 9401 else if (!micromips_p) 9402 { 9403 htab->plt_mips_entry_size 9404 = 4 * ARRAY_SIZE (mips_exec_plt_entry); 9405 htab->plt_comp_entry_size 9406 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry); 9407 } 9408 else if (htab->insn32) 9409 { 9410 htab->plt_mips_entry_size 9411 = 4 * ARRAY_SIZE (mips_exec_plt_entry); 9412 htab->plt_comp_entry_size 9413 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry); 9414 } 9415 else 9416 { 9417 htab->plt_mips_entry_size 9418 = 4 * ARRAY_SIZE (mips_exec_plt_entry); 9419 htab->plt_comp_entry_size 9420 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry); 9421 } 9422 } 9423 9424 if (h->plt.plist == NULL) 9425 h->plt.plist = mips_elf_make_plt_record (dynobj); 9426 if (h->plt.plist == NULL) 9427 return FALSE; 9428 9429 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks, 9430 n32 or n64, so always use a standard entry there. 9431 9432 If the symbol has a MIPS16 call stub and gets a PLT entry, then 9433 all MIPS16 calls will go via that stub, and there is no benefit 9434 to having a MIPS16 entry. And in the case of call_stub a 9435 standard entry actually has to be used as the stub ends with a J 9436 instruction. */ 9437 if (newabi_p 9438 || htab->root.target_os == is_vxworks 9439 || hmips->call_stub 9440 || hmips->call_fp_stub) 9441 { 9442 h->plt.plist->need_mips = TRUE; 9443 h->plt.plist->need_comp = FALSE; 9444 } 9445 9446 /* Otherwise, if there are no direct calls to the function, we 9447 have a free choice of whether to use standard or compressed 9448 entries. Prefer microMIPS entries if the object is known to 9449 contain microMIPS code, so that it becomes possible to create 9450 pure microMIPS binaries. Prefer standard entries otherwise, 9451 because MIPS16 ones are no smaller and are usually slower. */ 9452 if (!h->plt.plist->need_mips && !h->plt.plist->need_comp) 9453 { 9454 if (micromips_p) 9455 h->plt.plist->need_comp = TRUE; 9456 else 9457 h->plt.plist->need_mips = TRUE; 9458 } 9459 9460 if (h->plt.plist->need_mips) 9461 { 9462 h->plt.plist->mips_offset = htab->plt_mips_offset; 9463 htab->plt_mips_offset += htab->plt_mips_entry_size; 9464 } 9465 if (h->plt.plist->need_comp) 9466 { 9467 h->plt.plist->comp_offset = htab->plt_comp_offset; 9468 htab->plt_comp_offset += htab->plt_comp_entry_size; 9469 } 9470 9471 /* Reserve the corresponding .got.plt entry now too. */ 9472 h->plt.plist->gotplt_index = htab->plt_got_index++; 9473 9474 /* If the output file has no definition of the symbol, set the 9475 symbol's value to the address of the stub. */ 9476 if (!bfd_link_pic (info) && !h->def_regular) 9477 hmips->use_plt_entry = TRUE; 9478 9479 /* Make room for the R_MIPS_JUMP_SLOT relocation. */ 9480 htab->root.srelplt->size += (htab->root.target_os == is_vxworks 9481 ? MIPS_ELF_RELA_SIZE (dynobj) 9482 : MIPS_ELF_REL_SIZE (dynobj)); 9483 9484 /* Make room for the .rela.plt.unloaded relocations. */ 9485 if (htab->root.target_os == is_vxworks && !bfd_link_pic (info)) 9486 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela); 9487 9488 /* All relocations against this symbol that could have been made 9489 dynamic will now refer to the PLT entry instead. */ 9490 hmips->possibly_dynamic_relocs = 0; 9491 9492 return TRUE; 9493 } 9494 9495 /* If this is a weak symbol, and there is a real definition, the 9496 processor independent code will have arranged for us to see the 9497 real definition first, and we can just use the same value. */ 9498 if (h->is_weakalias) 9499 { 9500 struct elf_link_hash_entry *def = weakdef (h); 9501 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 9502 h->root.u.def.section = def->root.u.def.section; 9503 h->root.u.def.value = def->root.u.def.value; 9504 return TRUE; 9505 } 9506 9507 /* Otherwise, there is nothing further to do for symbols defined 9508 in regular objects. */ 9509 if (h->def_regular) 9510 return TRUE; 9511 9512 /* There's also nothing more to do if we'll convert all relocations 9513 against this symbol into dynamic relocations. */ 9514 if (!hmips->has_static_relocs) 9515 return TRUE; 9516 9517 /* We're now relying on copy relocations. Complain if we have 9518 some that we can't convert. */ 9519 if (!htab->use_plts_and_copy_relocs || bfd_link_pic (info)) 9520 { 9521 _bfd_error_handler (_("non-dynamic relocations refer to " 9522 "dynamic symbol %s"), 9523 h->root.root.string); 9524 bfd_set_error (bfd_error_bad_value); 9525 return FALSE; 9526 } 9527 9528 /* We must allocate the symbol in our .dynbss section, which will 9529 become part of the .bss section of the executable. There will be 9530 an entry for this symbol in the .dynsym section. The dynamic 9531 object will contain position independent code, so all references 9532 from the dynamic object to this symbol will go through the global 9533 offset table. The dynamic linker will use the .dynsym entry to 9534 determine the address it must put in the global offset table, so 9535 both the dynamic object and the regular object will refer to the 9536 same memory location for the variable. */ 9537 9538 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 9539 { 9540 s = htab->root.sdynrelro; 9541 srel = htab->root.sreldynrelro; 9542 } 9543 else 9544 { 9545 s = htab->root.sdynbss; 9546 srel = htab->root.srelbss; 9547 } 9548 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 9549 { 9550 if (htab->root.target_os == is_vxworks) 9551 srel->size += sizeof (Elf32_External_Rela); 9552 else 9553 mips_elf_allocate_dynamic_relocations (dynobj, info, 1); 9554 h->needs_copy = 1; 9555 } 9556 9557 /* All relocations against this symbol that could have been made 9558 dynamic will now refer to the local copy instead. */ 9559 hmips->possibly_dynamic_relocs = 0; 9560 9561 return _bfd_elf_adjust_dynamic_copy (info, h, s); 9562 } 9563 9564 /* This function is called after all the input files have been read, 9565 and the input sections have been assigned to output sections. We 9566 check for any mips16 stub sections that we can discard. */ 9567 9568 bfd_boolean 9569 _bfd_mips_elf_always_size_sections (bfd *output_bfd, 9570 struct bfd_link_info *info) 9571 { 9572 asection *sect; 9573 struct mips_elf_link_hash_table *htab; 9574 struct mips_htab_traverse_info hti; 9575 9576 htab = mips_elf_hash_table (info); 9577 BFD_ASSERT (htab != NULL); 9578 9579 /* The .reginfo section has a fixed size. */ 9580 sect = bfd_get_section_by_name (output_bfd, ".reginfo"); 9581 if (sect != NULL) 9582 { 9583 bfd_set_section_size (sect, sizeof (Elf32_External_RegInfo)); 9584 sect->flags |= SEC_FIXED_SIZE | SEC_HAS_CONTENTS; 9585 } 9586 9587 /* The .MIPS.abiflags section has a fixed size. */ 9588 sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags"); 9589 if (sect != NULL) 9590 { 9591 bfd_set_section_size (sect, sizeof (Elf_External_ABIFlags_v0)); 9592 sect->flags |= SEC_FIXED_SIZE | SEC_HAS_CONTENTS; 9593 } 9594 9595 hti.info = info; 9596 hti.output_bfd = output_bfd; 9597 hti.error = FALSE; 9598 mips_elf_link_hash_traverse (mips_elf_hash_table (info), 9599 mips_elf_check_symbols, &hti); 9600 if (hti.error) 9601 return FALSE; 9602 9603 return TRUE; 9604 } 9605 9606 /* If the link uses a GOT, lay it out and work out its size. */ 9607 9608 static bfd_boolean 9609 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info) 9610 { 9611 bfd *dynobj; 9612 asection *s; 9613 struct mips_got_info *g; 9614 bfd_size_type loadable_size = 0; 9615 bfd_size_type page_gotno; 9616 bfd *ibfd; 9617 struct mips_elf_traverse_got_arg tga; 9618 struct mips_elf_link_hash_table *htab; 9619 9620 htab = mips_elf_hash_table (info); 9621 BFD_ASSERT (htab != NULL); 9622 9623 s = htab->root.sgot; 9624 if (s == NULL) 9625 return TRUE; 9626 9627 dynobj = elf_hash_table (info)->dynobj; 9628 g = htab->got_info; 9629 9630 /* Allocate room for the reserved entries. VxWorks always reserves 9631 3 entries; other objects only reserve 2 entries. */ 9632 BFD_ASSERT (g->assigned_low_gotno == 0); 9633 if (htab->root.target_os == is_vxworks) 9634 htab->reserved_gotno = 3; 9635 else 9636 htab->reserved_gotno = 2; 9637 g->local_gotno += htab->reserved_gotno; 9638 g->assigned_low_gotno = htab->reserved_gotno; 9639 9640 /* Decide which symbols need to go in the global part of the GOT and 9641 count the number of reloc-only GOT symbols. */ 9642 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info); 9643 9644 if (!mips_elf_resolve_final_got_entries (info, g)) 9645 return FALSE; 9646 9647 /* Calculate the total loadable size of the output. That 9648 will give us the maximum number of GOT_PAGE entries 9649 required. */ 9650 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 9651 { 9652 asection *subsection; 9653 9654 for (subsection = ibfd->sections; 9655 subsection; 9656 subsection = subsection->next) 9657 { 9658 if ((subsection->flags & SEC_ALLOC) == 0) 9659 continue; 9660 loadable_size += ((subsection->size + 0xf) 9661 &~ (bfd_size_type) 0xf); 9662 } 9663 } 9664 9665 if (htab->root.target_os == is_vxworks) 9666 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16 9667 relocations against local symbols evaluate to "G", and the EABI does 9668 not include R_MIPS_GOT_PAGE. */ 9669 page_gotno = 0; 9670 else 9671 /* Assume there are two loadable segments consisting of contiguous 9672 sections. Is 5 enough? */ 9673 page_gotno = (loadable_size >> 16) + 5; 9674 9675 /* Choose the smaller of the two page estimates; both are intended to be 9676 conservative. */ 9677 if (page_gotno > g->page_gotno) 9678 page_gotno = g->page_gotno; 9679 9680 g->local_gotno += page_gotno; 9681 g->assigned_high_gotno = g->local_gotno - 1; 9682 9683 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd); 9684 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd); 9685 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd); 9686 9687 /* VxWorks does not support multiple GOTs. It initializes $gp to 9688 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the 9689 dynamic loader. */ 9690 if (htab->root.target_os != is_vxworks 9691 && s->size > MIPS_ELF_GOT_MAX_SIZE (info)) 9692 { 9693 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno)) 9694 return FALSE; 9695 } 9696 else 9697 { 9698 /* Record that all bfds use G. This also has the effect of freeing 9699 the per-bfd GOTs, which we no longer need. */ 9700 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 9701 if (mips_elf_bfd_got (ibfd, FALSE)) 9702 mips_elf_replace_bfd_got (ibfd, g); 9703 mips_elf_replace_bfd_got (output_bfd, g); 9704 9705 /* Set up TLS entries. */ 9706 g->tls_assigned_gotno = g->global_gotno + g->local_gotno; 9707 tga.info = info; 9708 tga.g = g; 9709 tga.value = MIPS_ELF_GOT_SIZE (output_bfd); 9710 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga); 9711 if (!tga.g) 9712 return FALSE; 9713 BFD_ASSERT (g->tls_assigned_gotno 9714 == g->global_gotno + g->local_gotno + g->tls_gotno); 9715 9716 /* Each VxWorks GOT entry needs an explicit relocation. */ 9717 if (htab->root.target_os == is_vxworks && bfd_link_pic (info)) 9718 g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno; 9719 9720 /* Allocate room for the TLS relocations. */ 9721 if (g->relocs) 9722 mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs); 9723 } 9724 9725 return TRUE; 9726 } 9727 9728 /* Estimate the size of the .MIPS.stubs section. */ 9729 9730 static void 9731 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info) 9732 { 9733 struct mips_elf_link_hash_table *htab; 9734 bfd_size_type dynsymcount; 9735 9736 htab = mips_elf_hash_table (info); 9737 BFD_ASSERT (htab != NULL); 9738 9739 if (htab->lazy_stub_count == 0) 9740 return; 9741 9742 /* IRIX rld assumes that a function stub isn't at the end of the .text 9743 section, so add a dummy entry to the end. */ 9744 htab->lazy_stub_count++; 9745 9746 /* Get a worst-case estimate of the number of dynamic symbols needed. 9747 At this point, dynsymcount does not account for section symbols 9748 and count_section_dynsyms may overestimate the number that will 9749 be needed. */ 9750 dynsymcount = (elf_hash_table (info)->dynsymcount 9751 + count_section_dynsyms (output_bfd, info)); 9752 9753 /* Determine the size of one stub entry. There's no disadvantage 9754 from using microMIPS code here, so for the sake of pure-microMIPS 9755 binaries we prefer it whenever there's any microMIPS code in 9756 output produced at all. This has a benefit of stubs being 9757 shorter by 4 bytes each too, unless in the insn32 mode. */ 9758 if (!MICROMIPS_P (output_bfd)) 9759 htab->function_stub_size = (dynsymcount > 0x10000 9760 ? MIPS_FUNCTION_STUB_BIG_SIZE 9761 : MIPS_FUNCTION_STUB_NORMAL_SIZE); 9762 else if (htab->insn32) 9763 htab->function_stub_size = (dynsymcount > 0x10000 9764 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 9765 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE); 9766 else 9767 htab->function_stub_size = (dynsymcount > 0x10000 9768 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE 9769 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE); 9770 9771 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size; 9772 } 9773 9774 /* A mips_elf_link_hash_traverse callback for which DATA points to a 9775 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding 9776 stub, allocate an entry in the stubs section. */ 9777 9778 static bfd_boolean 9779 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data) 9780 { 9781 struct mips_htab_traverse_info *hti = data; 9782 struct mips_elf_link_hash_table *htab; 9783 struct bfd_link_info *info; 9784 bfd *output_bfd; 9785 9786 info = hti->info; 9787 output_bfd = hti->output_bfd; 9788 htab = mips_elf_hash_table (info); 9789 BFD_ASSERT (htab != NULL); 9790 9791 if (h->needs_lazy_stub) 9792 { 9793 bfd_boolean micromips_p = MICROMIPS_P (output_bfd); 9794 unsigned int other = micromips_p ? STO_MICROMIPS : 0; 9795 bfd_vma isa_bit = micromips_p; 9796 9797 BFD_ASSERT (htab->root.dynobj != NULL); 9798 if (h->root.plt.plist == NULL) 9799 h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner); 9800 if (h->root.plt.plist == NULL) 9801 { 9802 hti->error = TRUE; 9803 return FALSE; 9804 } 9805 h->root.root.u.def.section = htab->sstubs; 9806 h->root.root.u.def.value = htab->sstubs->size + isa_bit; 9807 h->root.plt.plist->stub_offset = htab->sstubs->size; 9808 h->root.other = other; 9809 htab->sstubs->size += htab->function_stub_size; 9810 } 9811 return TRUE; 9812 } 9813 9814 /* Allocate offsets in the stubs section to each symbol that needs one. 9815 Set the final size of the .MIPS.stub section. */ 9816 9817 static bfd_boolean 9818 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info) 9819 { 9820 bfd *output_bfd = info->output_bfd; 9821 bfd_boolean micromips_p = MICROMIPS_P (output_bfd); 9822 unsigned int other = micromips_p ? STO_MICROMIPS : 0; 9823 bfd_vma isa_bit = micromips_p; 9824 struct mips_elf_link_hash_table *htab; 9825 struct mips_htab_traverse_info hti; 9826 struct elf_link_hash_entry *h; 9827 bfd *dynobj; 9828 9829 htab = mips_elf_hash_table (info); 9830 BFD_ASSERT (htab != NULL); 9831 9832 if (htab->lazy_stub_count == 0) 9833 return TRUE; 9834 9835 htab->sstubs->size = 0; 9836 hti.info = info; 9837 hti.output_bfd = output_bfd; 9838 hti.error = FALSE; 9839 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti); 9840 if (hti.error) 9841 return FALSE; 9842 htab->sstubs->size += htab->function_stub_size; 9843 BFD_ASSERT (htab->sstubs->size 9844 == htab->lazy_stub_count * htab->function_stub_size); 9845 9846 dynobj = elf_hash_table (info)->dynobj; 9847 BFD_ASSERT (dynobj != NULL); 9848 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_"); 9849 if (h == NULL) 9850 return FALSE; 9851 h->root.u.def.value = isa_bit; 9852 h->other = other; 9853 h->type = STT_FUNC; 9854 9855 return TRUE; 9856 } 9857 9858 /* A mips_elf_link_hash_traverse callback for which DATA points to a 9859 bfd_link_info. If H uses the address of a PLT entry as the value 9860 of the symbol, then set the entry in the symbol table now. Prefer 9861 a standard MIPS PLT entry. */ 9862 9863 static bfd_boolean 9864 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data) 9865 { 9866 struct bfd_link_info *info = data; 9867 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd); 9868 struct mips_elf_link_hash_table *htab; 9869 unsigned int other; 9870 bfd_vma isa_bit; 9871 bfd_vma val; 9872 9873 htab = mips_elf_hash_table (info); 9874 BFD_ASSERT (htab != NULL); 9875 9876 if (h->use_plt_entry) 9877 { 9878 BFD_ASSERT (h->root.plt.plist != NULL); 9879 BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE 9880 || h->root.plt.plist->comp_offset != MINUS_ONE); 9881 9882 val = htab->plt_header_size; 9883 if (h->root.plt.plist->mips_offset != MINUS_ONE) 9884 { 9885 isa_bit = 0; 9886 val += h->root.plt.plist->mips_offset; 9887 other = 0; 9888 } 9889 else 9890 { 9891 isa_bit = 1; 9892 val += htab->plt_mips_offset + h->root.plt.plist->comp_offset; 9893 other = micromips_p ? STO_MICROMIPS : STO_MIPS16; 9894 } 9895 val += isa_bit; 9896 /* For VxWorks, point at the PLT load stub rather than the lazy 9897 resolution stub; this stub will become the canonical function 9898 address. */ 9899 if (htab->root.target_os == is_vxworks) 9900 val += 8; 9901 9902 h->root.root.u.def.section = htab->root.splt; 9903 h->root.root.u.def.value = val; 9904 h->root.other = other; 9905 } 9906 9907 return TRUE; 9908 } 9909 9910 /* Set the sizes of the dynamic sections. */ 9911 9912 bfd_boolean 9913 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd, 9914 struct bfd_link_info *info) 9915 { 9916 bfd *dynobj; 9917 asection *s, *sreldyn; 9918 bfd_boolean reltext; 9919 struct mips_elf_link_hash_table *htab; 9920 9921 htab = mips_elf_hash_table (info); 9922 BFD_ASSERT (htab != NULL); 9923 dynobj = elf_hash_table (info)->dynobj; 9924 BFD_ASSERT (dynobj != NULL); 9925 9926 if (elf_hash_table (info)->dynamic_sections_created) 9927 { 9928 /* Set the contents of the .interp section to the interpreter. */ 9929 if (bfd_link_executable (info) && !info->nointerp) 9930 { 9931 s = bfd_get_linker_section (dynobj, ".interp"); 9932 BFD_ASSERT (s != NULL); 9933 s->size 9934 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1; 9935 s->contents 9936 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd); 9937 } 9938 9939 /* Figure out the size of the PLT header if we know that we 9940 are using it. For the sake of cache alignment always use 9941 a standard header whenever any standard entries are present 9942 even if microMIPS entries are present as well. This also 9943 lets the microMIPS header rely on the value of $v0 only set 9944 by microMIPS entries, for a small size reduction. 9945 9946 Set symbol table entry values for symbols that use the 9947 address of their PLT entry now that we can calculate it. 9948 9949 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we 9950 haven't already in _bfd_elf_create_dynamic_sections. */ 9951 if (htab->root.splt && htab->plt_mips_offset + htab->plt_comp_offset != 0) 9952 { 9953 bfd_boolean micromips_p = (MICROMIPS_P (output_bfd) 9954 && !htab->plt_mips_offset); 9955 unsigned int other = micromips_p ? STO_MICROMIPS : 0; 9956 bfd_vma isa_bit = micromips_p; 9957 struct elf_link_hash_entry *h; 9958 bfd_vma size; 9959 9960 BFD_ASSERT (htab->use_plts_and_copy_relocs); 9961 BFD_ASSERT (htab->root.sgotplt->size == 0); 9962 BFD_ASSERT (htab->root.splt->size == 0); 9963 9964 if (htab->root.target_os == is_vxworks && bfd_link_pic (info)) 9965 size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry); 9966 else if (htab->root.target_os == is_vxworks) 9967 size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry); 9968 else if (ABI_64_P (output_bfd)) 9969 size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry); 9970 else if (ABI_N32_P (output_bfd)) 9971 size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry); 9972 else if (!micromips_p) 9973 size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry); 9974 else if (htab->insn32) 9975 size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); 9976 else 9977 size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry); 9978 9979 htab->plt_header_is_comp = micromips_p; 9980 htab->plt_header_size = size; 9981 htab->root.splt->size = (size 9982 + htab->plt_mips_offset 9983 + htab->plt_comp_offset); 9984 htab->root.sgotplt->size = (htab->plt_got_index 9985 * MIPS_ELF_GOT_SIZE (dynobj)); 9986 9987 mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info); 9988 9989 if (htab->root.hplt == NULL) 9990 { 9991 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.splt, 9992 "_PROCEDURE_LINKAGE_TABLE_"); 9993 htab->root.hplt = h; 9994 if (h == NULL) 9995 return FALSE; 9996 } 9997 9998 h = htab->root.hplt; 9999 h->root.u.def.value = isa_bit; 10000 h->other = other; 10001 h->type = STT_FUNC; 10002 } 10003 } 10004 10005 /* Allocate space for global sym dynamic relocs. */ 10006 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 10007 10008 mips_elf_estimate_stub_size (output_bfd, info); 10009 10010 if (!mips_elf_lay_out_got (output_bfd, info)) 10011 return FALSE; 10012 10013 mips_elf_lay_out_lazy_stubs (info); 10014 10015 /* The check_relocs and adjust_dynamic_symbol entry points have 10016 determined the sizes of the various dynamic sections. Allocate 10017 memory for them. */ 10018 reltext = FALSE; 10019 for (s = dynobj->sections; s != NULL; s = s->next) 10020 { 10021 const char *name; 10022 10023 /* It's OK to base decisions on the section name, because none 10024 of the dynobj section names depend upon the input files. */ 10025 name = bfd_section_name (s); 10026 10027 if ((s->flags & SEC_LINKER_CREATED) == 0) 10028 continue; 10029 10030 if (CONST_STRNEQ (name, ".rel")) 10031 { 10032 if (s->size != 0) 10033 { 10034 const char *outname; 10035 asection *target; 10036 10037 /* If this relocation section applies to a read only 10038 section, then we probably need a DT_TEXTREL entry. 10039 If the relocation section is .rel(a).dyn, we always 10040 assert a DT_TEXTREL entry rather than testing whether 10041 there exists a relocation to a read only section or 10042 not. */ 10043 outname = bfd_section_name (s->output_section); 10044 target = bfd_get_section_by_name (output_bfd, outname + 4); 10045 if ((target != NULL 10046 && (target->flags & SEC_READONLY) != 0 10047 && (target->flags & SEC_ALLOC) != 0) 10048 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0) 10049 reltext = TRUE; 10050 10051 /* We use the reloc_count field as a counter if we need 10052 to copy relocs into the output file. */ 10053 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0) 10054 s->reloc_count = 0; 10055 10056 /* If combreloc is enabled, elf_link_sort_relocs() will 10057 sort relocations, but in a different way than we do, 10058 and before we're done creating relocations. Also, it 10059 will move them around between input sections' 10060 relocation's contents, so our sorting would be 10061 broken, so don't let it run. */ 10062 info->combreloc = 0; 10063 } 10064 } 10065 else if (bfd_link_executable (info) 10066 && ! mips_elf_hash_table (info)->use_rld_obj_head 10067 && CONST_STRNEQ (name, ".rld_map")) 10068 { 10069 /* We add a room for __rld_map. It will be filled in by the 10070 rtld to contain a pointer to the _r_debug structure. */ 10071 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd); 10072 } 10073 else if (SGI_COMPAT (output_bfd) 10074 && CONST_STRNEQ (name, ".compact_rel")) 10075 s->size += mips_elf_hash_table (info)->compact_rel_size; 10076 else if (s == htab->root.splt) 10077 { 10078 /* If the last PLT entry has a branch delay slot, allocate 10079 room for an extra nop to fill the delay slot. This is 10080 for CPUs without load interlocking. */ 10081 if (! LOAD_INTERLOCKS_P (output_bfd) 10082 && htab->root.target_os != is_vxworks 10083 && s->size > 0) 10084 s->size += 4; 10085 } 10086 else if (! CONST_STRNEQ (name, ".init") 10087 && s != htab->root.sgot 10088 && s != htab->root.sgotplt 10089 && s != htab->sstubs 10090 && s != htab->root.sdynbss 10091 && s != htab->root.sdynrelro) 10092 { 10093 /* It's not one of our sections, so don't allocate space. */ 10094 continue; 10095 } 10096 10097 if (s->size == 0) 10098 { 10099 s->flags |= SEC_EXCLUDE; 10100 continue; 10101 } 10102 10103 if ((s->flags & SEC_HAS_CONTENTS) == 0) 10104 continue; 10105 10106 /* Allocate memory for the section contents. */ 10107 s->contents = bfd_zalloc (dynobj, s->size); 10108 if (s->contents == NULL) 10109 { 10110 bfd_set_error (bfd_error_no_memory); 10111 return FALSE; 10112 } 10113 } 10114 10115 if (elf_hash_table (info)->dynamic_sections_created) 10116 { 10117 /* Add some entries to the .dynamic section. We fill in the 10118 values later, in _bfd_mips_elf_finish_dynamic_sections, but we 10119 must add the entries now so that we get the correct size for 10120 the .dynamic section. */ 10121 10122 /* SGI object has the equivalence of DT_DEBUG in the 10123 DT_MIPS_RLD_MAP entry. This must come first because glibc 10124 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools 10125 may only look at the first one they see. */ 10126 if (!bfd_link_pic (info) 10127 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0)) 10128 return FALSE; 10129 10130 if (bfd_link_executable (info) 10131 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0)) 10132 return FALSE; 10133 10134 /* The DT_DEBUG entry may be filled in by the dynamic linker and 10135 used by the debugger. */ 10136 if (bfd_link_executable (info) 10137 && !SGI_COMPAT (output_bfd) 10138 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) 10139 return FALSE; 10140 10141 if (reltext 10142 && (SGI_COMPAT (output_bfd) 10143 || htab->root.target_os == is_vxworks)) 10144 info->flags |= DF_TEXTREL; 10145 10146 if ((info->flags & DF_TEXTREL) != 0) 10147 { 10148 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0)) 10149 return FALSE; 10150 10151 /* Clear the DF_TEXTREL flag. It will be set again if we 10152 write out an actual text relocation; we may not, because 10153 at this point we do not know whether e.g. any .eh_frame 10154 absolute relocations have been converted to PC-relative. */ 10155 info->flags &= ~DF_TEXTREL; 10156 } 10157 10158 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0)) 10159 return FALSE; 10160 10161 sreldyn = mips_elf_rel_dyn_section (info, FALSE); 10162 if (htab->root.target_os == is_vxworks) 10163 { 10164 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not 10165 use any of the DT_MIPS_* tags. */ 10166 if (sreldyn && sreldyn->size > 0) 10167 { 10168 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0)) 10169 return FALSE; 10170 10171 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0)) 10172 return FALSE; 10173 10174 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0)) 10175 return FALSE; 10176 } 10177 } 10178 else 10179 { 10180 if (sreldyn && sreldyn->size > 0 10181 && !bfd_is_abs_section (sreldyn->output_section)) 10182 { 10183 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0)) 10184 return FALSE; 10185 10186 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0)) 10187 return FALSE; 10188 10189 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0)) 10190 return FALSE; 10191 } 10192 10193 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0)) 10194 return FALSE; 10195 10196 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0)) 10197 return FALSE; 10198 10199 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0)) 10200 return FALSE; 10201 10202 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0)) 10203 return FALSE; 10204 10205 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0)) 10206 return FALSE; 10207 10208 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0)) 10209 return FALSE; 10210 10211 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0)) 10212 return FALSE; 10213 10214 if (info->emit_gnu_hash 10215 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_XHASH, 0)) 10216 return FALSE; 10217 10218 if (IRIX_COMPAT (dynobj) == ict_irix5 10219 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0)) 10220 return FALSE; 10221 10222 if (IRIX_COMPAT (dynobj) == ict_irix6 10223 && (bfd_get_section_by_name 10224 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj))) 10225 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0)) 10226 return FALSE; 10227 } 10228 if (htab->root.splt->size > 0) 10229 { 10230 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0)) 10231 return FALSE; 10232 10233 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0)) 10234 return FALSE; 10235 10236 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0)) 10237 return FALSE; 10238 10239 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0)) 10240 return FALSE; 10241 } 10242 if (htab->root.target_os == is_vxworks 10243 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 10244 return FALSE; 10245 } 10246 10247 return TRUE; 10248 } 10249 10250 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD. 10251 Adjust its R_ADDEND field so that it is correct for the output file. 10252 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols 10253 and sections respectively; both use symbol indexes. */ 10254 10255 static void 10256 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info, 10257 bfd *input_bfd, Elf_Internal_Sym *local_syms, 10258 asection **local_sections, Elf_Internal_Rela *rel) 10259 { 10260 unsigned int r_type, r_symndx; 10261 Elf_Internal_Sym *sym; 10262 asection *sec; 10263 10264 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections)) 10265 { 10266 r_type = ELF_R_TYPE (output_bfd, rel->r_info); 10267 if (gprel16_reloc_p (r_type) 10268 || r_type == R_MIPS_GPREL32 10269 || literal_reloc_p (r_type)) 10270 { 10271 rel->r_addend += _bfd_get_gp_value (input_bfd); 10272 rel->r_addend -= _bfd_get_gp_value (output_bfd); 10273 } 10274 10275 r_symndx = ELF_R_SYM (output_bfd, rel->r_info); 10276 sym = local_syms + r_symndx; 10277 10278 /* Adjust REL's addend to account for section merging. */ 10279 if (!bfd_link_relocatable (info)) 10280 { 10281 sec = local_sections[r_symndx]; 10282 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 10283 } 10284 10285 /* This would normally be done by the rela_normal code in elflink.c. */ 10286 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 10287 rel->r_addend += local_sections[r_symndx]->output_offset; 10288 } 10289 } 10290 10291 /* Handle relocations against symbols from removed linkonce sections, 10292 or sections discarded by a linker script. We use this wrapper around 10293 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs 10294 on 64-bit ELF targets. In this case for any relocation handled, which 10295 always be the first in a triplet, the remaining two have to be processed 10296 together with the first, even if they are R_MIPS_NONE. It is the symbol 10297 index referred by the first reloc that applies to all the three and the 10298 remaining two never refer to an object symbol. And it is the final 10299 relocation (the last non-null one) that determines the output field of 10300 the whole relocation so retrieve the corresponding howto structure for 10301 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION. 10302 10303 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue" 10304 and therefore requires to be pasted in a loop. It also defines a block 10305 and does not protect any of its arguments, hence the extra brackets. */ 10306 10307 static void 10308 mips_reloc_against_discarded_section (bfd *output_bfd, 10309 struct bfd_link_info *info, 10310 bfd *input_bfd, asection *input_section, 10311 Elf_Internal_Rela **rel, 10312 const Elf_Internal_Rela **relend, 10313 bfd_boolean rel_reloc, 10314 reloc_howto_type *howto, 10315 bfd_byte *contents) 10316 { 10317 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 10318 int count = bed->s->int_rels_per_ext_rel; 10319 unsigned int r_type; 10320 int i; 10321 10322 for (i = count - 1; i > 0; i--) 10323 { 10324 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info); 10325 if (r_type != R_MIPS_NONE) 10326 { 10327 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc); 10328 break; 10329 } 10330 } 10331 do 10332 { 10333 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 10334 (*rel), count, (*relend), 10335 howto, i, contents); 10336 } 10337 while (0); 10338 } 10339 10340 /* Relocate a MIPS ELF section. */ 10341 10342 bfd_boolean 10343 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 10344 bfd *input_bfd, asection *input_section, 10345 bfd_byte *contents, Elf_Internal_Rela *relocs, 10346 Elf_Internal_Sym *local_syms, 10347 asection **local_sections) 10348 { 10349 Elf_Internal_Rela *rel; 10350 const Elf_Internal_Rela *relend; 10351 bfd_vma addend = 0; 10352 bfd_boolean use_saved_addend_p = FALSE; 10353 10354 relend = relocs + input_section->reloc_count; 10355 for (rel = relocs; rel < relend; ++rel) 10356 { 10357 const char *name; 10358 bfd_vma value = 0; 10359 reloc_howto_type *howto; 10360 bfd_boolean cross_mode_jump_p = FALSE; 10361 /* TRUE if the relocation is a RELA relocation, rather than a 10362 REL relocation. */ 10363 bfd_boolean rela_relocation_p = TRUE; 10364 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info); 10365 const char *msg; 10366 unsigned long r_symndx; 10367 asection *sec; 10368 Elf_Internal_Shdr *symtab_hdr; 10369 struct elf_link_hash_entry *h; 10370 bfd_boolean rel_reloc; 10371 10372 rel_reloc = (NEWABI_P (input_bfd) 10373 && mips_elf_rel_relocation_p (input_bfd, input_section, 10374 relocs, rel)); 10375 /* Find the relocation howto for this relocation. */ 10376 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc); 10377 10378 r_symndx = ELF_R_SYM (input_bfd, rel->r_info); 10379 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 10380 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections)) 10381 { 10382 sec = local_sections[r_symndx]; 10383 h = NULL; 10384 } 10385 else 10386 { 10387 unsigned long extsymoff; 10388 10389 extsymoff = 0; 10390 if (!elf_bad_symtab (input_bfd)) 10391 extsymoff = symtab_hdr->sh_info; 10392 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff]; 10393 while (h->root.type == bfd_link_hash_indirect 10394 || h->root.type == bfd_link_hash_warning) 10395 h = (struct elf_link_hash_entry *) h->root.u.i.link; 10396 10397 sec = NULL; 10398 if (h->root.type == bfd_link_hash_defined 10399 || h->root.type == bfd_link_hash_defweak) 10400 sec = h->root.u.def.section; 10401 } 10402 10403 if (sec != NULL && discarded_section (sec)) 10404 { 10405 mips_reloc_against_discarded_section (output_bfd, info, input_bfd, 10406 input_section, &rel, &relend, 10407 rel_reloc, howto, contents); 10408 continue; 10409 } 10410 10411 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd)) 10412 { 10413 /* Some 32-bit code uses R_MIPS_64. In particular, people use 10414 64-bit code, but make sure all their addresses are in the 10415 lowermost or uppermost 32-bit section of the 64-bit address 10416 space. Thus, when they use an R_MIPS_64 they mean what is 10417 usually meant by R_MIPS_32, with the exception that the 10418 stored value is sign-extended to 64 bits. */ 10419 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE); 10420 10421 /* On big-endian systems, we need to lie about the position 10422 of the reloc. */ 10423 if (bfd_big_endian (input_bfd)) 10424 rel->r_offset += 4; 10425 } 10426 10427 if (!use_saved_addend_p) 10428 { 10429 /* If these relocations were originally of the REL variety, 10430 we must pull the addend out of the field that will be 10431 relocated. Otherwise, we simply use the contents of the 10432 RELA relocation. */ 10433 if (mips_elf_rel_relocation_p (input_bfd, input_section, 10434 relocs, rel)) 10435 { 10436 rela_relocation_p = FALSE; 10437 addend = mips_elf_read_rel_addend (input_bfd, rel, 10438 howto, contents); 10439 if (hi16_reloc_p (r_type) 10440 || (got16_reloc_p (r_type) 10441 && mips_elf_local_relocation_p (input_bfd, rel, 10442 local_sections))) 10443 { 10444 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend, 10445 contents, &addend)) 10446 { 10447 if (h) 10448 name = h->root.root.string; 10449 else 10450 name = bfd_elf_sym_name (input_bfd, symtab_hdr, 10451 local_syms + r_symndx, 10452 sec); 10453 _bfd_error_handler 10454 /* xgettext:c-format */ 10455 (_("%pB: can't find matching LO16 reloc against `%s'" 10456 " for %s at %#" PRIx64 " in section `%pA'"), 10457 input_bfd, name, 10458 howto->name, (uint64_t) rel->r_offset, input_section); 10459 } 10460 } 10461 else 10462 addend <<= howto->rightshift; 10463 } 10464 else 10465 addend = rel->r_addend; 10466 mips_elf_adjust_addend (output_bfd, info, input_bfd, 10467 local_syms, local_sections, rel); 10468 } 10469 10470 if (bfd_link_relocatable (info)) 10471 { 10472 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd) 10473 && bfd_big_endian (input_bfd)) 10474 rel->r_offset -= 4; 10475 10476 if (!rela_relocation_p && rel->r_addend) 10477 { 10478 addend += rel->r_addend; 10479 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type)) 10480 addend = mips_elf_high (addend); 10481 else if (r_type == R_MIPS_HIGHER) 10482 addend = mips_elf_higher (addend); 10483 else if (r_type == R_MIPS_HIGHEST) 10484 addend = mips_elf_highest (addend); 10485 else 10486 addend >>= howto->rightshift; 10487 10488 /* We use the source mask, rather than the destination 10489 mask because the place to which we are writing will be 10490 source of the addend in the final link. */ 10491 addend &= howto->src_mask; 10492 10493 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)) 10494 /* See the comment above about using R_MIPS_64 in the 32-bit 10495 ABI. Here, we need to update the addend. It would be 10496 possible to get away with just using the R_MIPS_32 reloc 10497 but for endianness. */ 10498 { 10499 bfd_vma sign_bits; 10500 bfd_vma low_bits; 10501 bfd_vma high_bits; 10502 10503 if (addend & ((bfd_vma) 1 << 31)) 10504 #ifdef BFD64 10505 sign_bits = ((bfd_vma) 1 << 32) - 1; 10506 #else 10507 sign_bits = -1; 10508 #endif 10509 else 10510 sign_bits = 0; 10511 10512 /* If we don't know that we have a 64-bit type, 10513 do two separate stores. */ 10514 if (bfd_big_endian (input_bfd)) 10515 { 10516 /* Store the sign-bits (which are most significant) 10517 first. */ 10518 low_bits = sign_bits; 10519 high_bits = addend; 10520 } 10521 else 10522 { 10523 low_bits = addend; 10524 high_bits = sign_bits; 10525 } 10526 bfd_put_32 (input_bfd, low_bits, 10527 contents + rel->r_offset); 10528 bfd_put_32 (input_bfd, high_bits, 10529 contents + rel->r_offset + 4); 10530 continue; 10531 } 10532 10533 if (! mips_elf_perform_relocation (info, howto, rel, addend, 10534 input_bfd, input_section, 10535 contents, FALSE)) 10536 return FALSE; 10537 } 10538 10539 /* Go on to the next relocation. */ 10540 continue; 10541 } 10542 10543 /* In the N32 and 64-bit ABIs there may be multiple consecutive 10544 relocations for the same offset. In that case we are 10545 supposed to treat the output of each relocation as the addend 10546 for the next. */ 10547 if (rel + 1 < relend 10548 && rel->r_offset == rel[1].r_offset 10549 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE) 10550 use_saved_addend_p = TRUE; 10551 else 10552 use_saved_addend_p = FALSE; 10553 10554 /* Figure out what value we are supposed to relocate. */ 10555 switch (mips_elf_calculate_relocation (output_bfd, input_bfd, 10556 input_section, contents, 10557 info, rel, addend, howto, 10558 local_syms, local_sections, 10559 &value, &name, &cross_mode_jump_p, 10560 use_saved_addend_p)) 10561 { 10562 case bfd_reloc_continue: 10563 /* There's nothing to do. */ 10564 continue; 10565 10566 case bfd_reloc_undefined: 10567 /* mips_elf_calculate_relocation already called the 10568 undefined_symbol callback. There's no real point in 10569 trying to perform the relocation at this point, so we 10570 just skip ahead to the next relocation. */ 10571 continue; 10572 10573 case bfd_reloc_notsupported: 10574 msg = _("internal error: unsupported relocation error"); 10575 info->callbacks->warning 10576 (info, msg, name, input_bfd, input_section, rel->r_offset); 10577 return FALSE; 10578 10579 case bfd_reloc_overflow: 10580 if (use_saved_addend_p) 10581 /* Ignore overflow until we reach the last relocation for 10582 a given location. */ 10583 ; 10584 else 10585 { 10586 struct mips_elf_link_hash_table *htab; 10587 10588 htab = mips_elf_hash_table (info); 10589 BFD_ASSERT (htab != NULL); 10590 BFD_ASSERT (name != NULL); 10591 if (!htab->small_data_overflow_reported 10592 && (gprel16_reloc_p (howto->type) 10593 || literal_reloc_p (howto->type))) 10594 { 10595 msg = _("small-data section exceeds 64KB;" 10596 " lower small-data size limit (see option -G)"); 10597 10598 htab->small_data_overflow_reported = TRUE; 10599 (*info->callbacks->einfo) ("%P: %s\n", msg); 10600 } 10601 (*info->callbacks->reloc_overflow) 10602 (info, NULL, name, howto->name, (bfd_vma) 0, 10603 input_bfd, input_section, rel->r_offset); 10604 } 10605 break; 10606 10607 case bfd_reloc_ok: 10608 break; 10609 10610 case bfd_reloc_outofrange: 10611 msg = NULL; 10612 if (jal_reloc_p (howto->type)) 10613 msg = (cross_mode_jump_p 10614 ? _("cannot convert a jump to JALX " 10615 "for a non-word-aligned address") 10616 : (howto->type == R_MIPS16_26 10617 ? _("jump to a non-word-aligned address") 10618 : _("jump to a non-instruction-aligned address"))); 10619 else if (b_reloc_p (howto->type)) 10620 msg = (cross_mode_jump_p 10621 ? _("cannot convert a branch to JALX " 10622 "for a non-word-aligned address") 10623 : _("branch to a non-instruction-aligned address")); 10624 else if (aligned_pcrel_reloc_p (howto->type)) 10625 msg = _("PC-relative load from unaligned address"); 10626 if (msg) 10627 { 10628 info->callbacks->einfo 10629 ("%X%H: %s\n", input_bfd, input_section, rel->r_offset, msg); 10630 break; 10631 } 10632 /* Fall through. */ 10633 10634 default: 10635 abort (); 10636 break; 10637 } 10638 10639 /* If we've got another relocation for the address, keep going 10640 until we reach the last one. */ 10641 if (use_saved_addend_p) 10642 { 10643 addend = value; 10644 continue; 10645 } 10646 10647 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)) 10648 /* See the comment above about using R_MIPS_64 in the 32-bit 10649 ABI. Until now, we've been using the HOWTO for R_MIPS_32; 10650 that calculated the right value. Now, however, we 10651 sign-extend the 32-bit result to 64-bits, and store it as a 10652 64-bit value. We are especially generous here in that we 10653 go to extreme lengths to support this usage on systems with 10654 only a 32-bit VMA. */ 10655 { 10656 bfd_vma sign_bits; 10657 bfd_vma low_bits; 10658 bfd_vma high_bits; 10659 10660 if (value & ((bfd_vma) 1 << 31)) 10661 #ifdef BFD64 10662 sign_bits = ((bfd_vma) 1 << 32) - 1; 10663 #else 10664 sign_bits = -1; 10665 #endif 10666 else 10667 sign_bits = 0; 10668 10669 /* If we don't know that we have a 64-bit type, 10670 do two separate stores. */ 10671 if (bfd_big_endian (input_bfd)) 10672 { 10673 /* Undo what we did above. */ 10674 rel->r_offset -= 4; 10675 /* Store the sign-bits (which are most significant) 10676 first. */ 10677 low_bits = sign_bits; 10678 high_bits = value; 10679 } 10680 else 10681 { 10682 low_bits = value; 10683 high_bits = sign_bits; 10684 } 10685 bfd_put_32 (input_bfd, low_bits, 10686 contents + rel->r_offset); 10687 bfd_put_32 (input_bfd, high_bits, 10688 contents + rel->r_offset + 4); 10689 continue; 10690 } 10691 10692 /* Actually perform the relocation. */ 10693 if (! mips_elf_perform_relocation (info, howto, rel, value, 10694 input_bfd, input_section, 10695 contents, cross_mode_jump_p)) 10696 return FALSE; 10697 } 10698 10699 return TRUE; 10700 } 10701 10702 /* A function that iterates over each entry in la25_stubs and fills 10703 in the code for each one. DATA points to a mips_htab_traverse_info. */ 10704 10705 static int 10706 mips_elf_create_la25_stub (void **slot, void *data) 10707 { 10708 struct mips_htab_traverse_info *hti; 10709 struct mips_elf_link_hash_table *htab; 10710 struct mips_elf_la25_stub *stub; 10711 asection *s; 10712 bfd_byte *loc; 10713 bfd_vma offset, target, target_high, target_low; 10714 bfd_vma branch_pc; 10715 bfd_signed_vma pcrel_offset = 0; 10716 10717 stub = (struct mips_elf_la25_stub *) *slot; 10718 hti = (struct mips_htab_traverse_info *) data; 10719 htab = mips_elf_hash_table (hti->info); 10720 BFD_ASSERT (htab != NULL); 10721 10722 /* Create the section contents, if we haven't already. */ 10723 s = stub->stub_section; 10724 loc = s->contents; 10725 if (loc == NULL) 10726 { 10727 loc = bfd_malloc (s->size); 10728 if (loc == NULL) 10729 { 10730 hti->error = TRUE; 10731 return FALSE; 10732 } 10733 s->contents = loc; 10734 } 10735 10736 /* Work out where in the section this stub should go. */ 10737 offset = stub->offset; 10738 10739 /* We add 8 here to account for the LUI/ADDIU instructions 10740 before the branch instruction. This cannot be moved down to 10741 where pcrel_offset is calculated as 's' is updated in 10742 mips_elf_get_la25_target. */ 10743 branch_pc = s->output_section->vma + s->output_offset + offset + 8; 10744 10745 /* Work out the target address. */ 10746 target = mips_elf_get_la25_target (stub, &s); 10747 target += s->output_section->vma + s->output_offset; 10748 10749 target_high = ((target + 0x8000) >> 16) & 0xffff; 10750 target_low = (target & 0xffff); 10751 10752 /* Calculate the PC of the compact branch instruction (for the case where 10753 compact branches are used for either microMIPSR6 or MIPSR6 with 10754 compact branches. Add 4-bytes to account for BC using the PC of the 10755 next instruction as the base. */ 10756 pcrel_offset = target - (branch_pc + 4); 10757 10758 if (stub->stub_section != htab->strampoline) 10759 { 10760 /* This is a simple LUI/ADDIU stub. Zero out the beginning 10761 of the section and write the two instructions at the end. */ 10762 memset (loc, 0, offset); 10763 loc += offset; 10764 if (ELF_ST_IS_MICROMIPS (stub->h->root.other)) 10765 { 10766 bfd_put_micromips_32 (hti->output_bfd, 10767 LA25_LUI_MICROMIPS (target_high), 10768 loc); 10769 bfd_put_micromips_32 (hti->output_bfd, 10770 LA25_ADDIU_MICROMIPS (target_low), 10771 loc + 4); 10772 } 10773 else 10774 { 10775 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc); 10776 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4); 10777 } 10778 } 10779 else 10780 { 10781 /* This is trampoline. */ 10782 loc += offset; 10783 if (ELF_ST_IS_MICROMIPS (stub->h->root.other)) 10784 { 10785 bfd_put_micromips_32 (hti->output_bfd, 10786 LA25_LUI_MICROMIPS (target_high), loc); 10787 bfd_put_micromips_32 (hti->output_bfd, 10788 LA25_J_MICROMIPS (target), loc + 4); 10789 bfd_put_micromips_32 (hti->output_bfd, 10790 LA25_ADDIU_MICROMIPS (target_low), loc + 8); 10791 bfd_put_32 (hti->output_bfd, 0, loc + 12); 10792 } 10793 else 10794 { 10795 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc); 10796 if (MIPSR6_P (hti->output_bfd) && htab->compact_branches) 10797 { 10798 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4); 10799 bfd_put_32 (hti->output_bfd, LA25_BC (pcrel_offset), loc + 8); 10800 } 10801 else 10802 { 10803 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4); 10804 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8); 10805 } 10806 bfd_put_32 (hti->output_bfd, 0, loc + 12); 10807 } 10808 } 10809 return TRUE; 10810 } 10811 10812 /* If NAME is one of the special IRIX6 symbols defined by the linker, 10813 adjust it appropriately now. */ 10814 10815 static void 10816 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED, 10817 const char *name, Elf_Internal_Sym *sym) 10818 { 10819 /* The linker script takes care of providing names and values for 10820 these, but we must place them into the right sections. */ 10821 static const char* const text_section_symbols[] = { 10822 "_ftext", 10823 "_etext", 10824 "__dso_displacement", 10825 "__elf_header", 10826 "__program_header_table", 10827 NULL 10828 }; 10829 10830 static const char* const data_section_symbols[] = { 10831 "_fdata", 10832 "_edata", 10833 "_end", 10834 "_fbss", 10835 NULL 10836 }; 10837 10838 const char* const *p; 10839 int i; 10840 10841 for (i = 0; i < 2; ++i) 10842 for (p = (i == 0) ? text_section_symbols : data_section_symbols; 10843 *p; 10844 ++p) 10845 if (strcmp (*p, name) == 0) 10846 { 10847 /* All of these symbols are given type STT_SECTION by the 10848 IRIX6 linker. */ 10849 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 10850 sym->st_other = STO_PROTECTED; 10851 10852 /* The IRIX linker puts these symbols in special sections. */ 10853 if (i == 0) 10854 sym->st_shndx = SHN_MIPS_TEXT; 10855 else 10856 sym->st_shndx = SHN_MIPS_DATA; 10857 10858 break; 10859 } 10860 } 10861 10862 /* Finish up dynamic symbol handling. We set the contents of various 10863 dynamic sections here. */ 10864 10865 bfd_boolean 10866 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd, 10867 struct bfd_link_info *info, 10868 struct elf_link_hash_entry *h, 10869 Elf_Internal_Sym *sym) 10870 { 10871 bfd *dynobj; 10872 asection *sgot; 10873 struct mips_got_info *g, *gg; 10874 const char *name; 10875 int idx; 10876 struct mips_elf_link_hash_table *htab; 10877 struct mips_elf_link_hash_entry *hmips; 10878 10879 htab = mips_elf_hash_table (info); 10880 BFD_ASSERT (htab != NULL); 10881 dynobj = elf_hash_table (info)->dynobj; 10882 hmips = (struct mips_elf_link_hash_entry *) h; 10883 10884 BFD_ASSERT (htab->root.target_os != is_vxworks); 10885 10886 if (h->plt.plist != NULL 10887 && (h->plt.plist->mips_offset != MINUS_ONE 10888 || h->plt.plist->comp_offset != MINUS_ONE)) 10889 { 10890 /* We've decided to create a PLT entry for this symbol. */ 10891 bfd_byte *loc; 10892 bfd_vma header_address, got_address; 10893 bfd_vma got_address_high, got_address_low, load; 10894 bfd_vma got_index; 10895 bfd_vma isa_bit; 10896 10897 got_index = h->plt.plist->gotplt_index; 10898 10899 BFD_ASSERT (htab->use_plts_and_copy_relocs); 10900 BFD_ASSERT (h->dynindx != -1); 10901 BFD_ASSERT (htab->root.splt != NULL); 10902 BFD_ASSERT (got_index != MINUS_ONE); 10903 BFD_ASSERT (!h->def_regular); 10904 10905 /* Calculate the address of the PLT header. */ 10906 isa_bit = htab->plt_header_is_comp; 10907 header_address = (htab->root.splt->output_section->vma 10908 + htab->root.splt->output_offset + isa_bit); 10909 10910 /* Calculate the address of the .got.plt entry. */ 10911 got_address = (htab->root.sgotplt->output_section->vma 10912 + htab->root.sgotplt->output_offset 10913 + got_index * MIPS_ELF_GOT_SIZE (dynobj)); 10914 10915 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff; 10916 got_address_low = got_address & 0xffff; 10917 10918 /* The PLT sequence is not safe for N64 if .got.plt entry's address 10919 cannot be loaded in two instructions. */ 10920 if (ABI_64_P (output_bfd) 10921 && ((got_address + 0x80008000) & ~(bfd_vma) 0xffffffff) != 0) 10922 { 10923 _bfd_error_handler 10924 /* xgettext:c-format */ 10925 (_("%pB: `%pA' entry VMA of %#" PRIx64 " outside the 32-bit range " 10926 "supported; consider using `-Ttext-segment=...'"), 10927 output_bfd, 10928 htab->root.sgotplt->output_section, 10929 (int64_t) got_address); 10930 bfd_set_error (bfd_error_no_error); 10931 return FALSE; 10932 } 10933 10934 /* Initially point the .got.plt entry at the PLT header. */ 10935 loc = (htab->root.sgotplt->contents 10936 + got_index * MIPS_ELF_GOT_SIZE (dynobj)); 10937 if (ABI_64_P (output_bfd)) 10938 bfd_put_64 (output_bfd, header_address, loc); 10939 else 10940 bfd_put_32 (output_bfd, header_address, loc); 10941 10942 /* Now handle the PLT itself. First the standard entry (the order 10943 does not matter, we just have to pick one). */ 10944 if (h->plt.plist->mips_offset != MINUS_ONE) 10945 { 10946 const bfd_vma *plt_entry; 10947 bfd_vma plt_offset; 10948 10949 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset; 10950 10951 BFD_ASSERT (plt_offset <= htab->root.splt->size); 10952 10953 /* Find out where the .plt entry should go. */ 10954 loc = htab->root.splt->contents + plt_offset; 10955 10956 /* Pick the load opcode. */ 10957 load = MIPS_ELF_LOAD_WORD (output_bfd); 10958 10959 /* Fill in the PLT entry itself. */ 10960 10961 if (MIPSR6_P (output_bfd)) 10962 plt_entry = htab->compact_branches ? mipsr6_exec_plt_entry_compact 10963 : mipsr6_exec_plt_entry; 10964 else 10965 plt_entry = mips_exec_plt_entry; 10966 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc); 10967 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, 10968 loc + 4); 10969 10970 if (! LOAD_INTERLOCKS_P (output_bfd) 10971 || (MIPSR6_P (output_bfd) && htab->compact_branches)) 10972 { 10973 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8); 10974 bfd_put_32 (output_bfd, plt_entry[3], loc + 12); 10975 } 10976 else 10977 { 10978 bfd_put_32 (output_bfd, plt_entry[3], loc + 8); 10979 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, 10980 loc + 12); 10981 } 10982 } 10983 10984 /* Now the compressed entry. They come after any standard ones. */ 10985 if (h->plt.plist->comp_offset != MINUS_ONE) 10986 { 10987 bfd_vma plt_offset; 10988 10989 plt_offset = (htab->plt_header_size + htab->plt_mips_offset 10990 + h->plt.plist->comp_offset); 10991 10992 BFD_ASSERT (plt_offset <= htab->root.splt->size); 10993 10994 /* Find out where the .plt entry should go. */ 10995 loc = htab->root.splt->contents + plt_offset; 10996 10997 /* Fill in the PLT entry itself. */ 10998 if (!MICROMIPS_P (output_bfd)) 10999 { 11000 const bfd_vma *plt_entry = mips16_o32_exec_plt_entry; 11001 11002 bfd_put_16 (output_bfd, plt_entry[0], loc); 11003 bfd_put_16 (output_bfd, plt_entry[1], loc + 2); 11004 bfd_put_16 (output_bfd, plt_entry[2], loc + 4); 11005 bfd_put_16 (output_bfd, plt_entry[3], loc + 6); 11006 bfd_put_16 (output_bfd, plt_entry[4], loc + 8); 11007 bfd_put_16 (output_bfd, plt_entry[5], loc + 10); 11008 bfd_put_32 (output_bfd, got_address, loc + 12); 11009 } 11010 else if (htab->insn32) 11011 { 11012 const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry; 11013 11014 bfd_put_16 (output_bfd, plt_entry[0], loc); 11015 bfd_put_16 (output_bfd, got_address_high, loc + 2); 11016 bfd_put_16 (output_bfd, plt_entry[2], loc + 4); 11017 bfd_put_16 (output_bfd, got_address_low, loc + 6); 11018 bfd_put_16 (output_bfd, plt_entry[4], loc + 8); 11019 bfd_put_16 (output_bfd, plt_entry[5], loc + 10); 11020 bfd_put_16 (output_bfd, plt_entry[6], loc + 12); 11021 bfd_put_16 (output_bfd, got_address_low, loc + 14); 11022 } 11023 else 11024 { 11025 const bfd_vma *plt_entry = micromips_o32_exec_plt_entry; 11026 bfd_signed_vma gotpc_offset; 11027 bfd_vma loc_address; 11028 11029 BFD_ASSERT (got_address % 4 == 0); 11030 11031 loc_address = (htab->root.splt->output_section->vma 11032 + htab->root.splt->output_offset + plt_offset); 11033 gotpc_offset = got_address - ((loc_address | 3) ^ 3); 11034 11035 /* ADDIUPC has a span of +/-16MB, check we're in range. */ 11036 if (gotpc_offset + 0x1000000 >= 0x2000000) 11037 { 11038 _bfd_error_handler 11039 /* xgettext:c-format */ 11040 (_("%pB: `%pA' offset of %" PRId64 " from `%pA' " 11041 "beyond the range of ADDIUPC"), 11042 output_bfd, 11043 htab->root.sgotplt->output_section, 11044 (int64_t) gotpc_offset, 11045 htab->root.splt->output_section); 11046 bfd_set_error (bfd_error_no_error); 11047 return FALSE; 11048 } 11049 bfd_put_16 (output_bfd, 11050 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc); 11051 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2); 11052 bfd_put_16 (output_bfd, plt_entry[2], loc + 4); 11053 bfd_put_16 (output_bfd, plt_entry[3], loc + 6); 11054 bfd_put_16 (output_bfd, plt_entry[4], loc + 8); 11055 bfd_put_16 (output_bfd, plt_entry[5], loc + 10); 11056 } 11057 } 11058 11059 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */ 11060 mips_elf_output_dynamic_relocation (output_bfd, htab->root.srelplt, 11061 got_index - 2, h->dynindx, 11062 R_MIPS_JUMP_SLOT, got_address); 11063 11064 /* We distinguish between PLT entries and lazy-binding stubs by 11065 giving the former an st_other value of STO_MIPS_PLT. Set the 11066 flag and leave the value if there are any relocations in the 11067 binary where pointer equality matters. */ 11068 sym->st_shndx = SHN_UNDEF; 11069 if (h->pointer_equality_needed) 11070 sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other); 11071 else 11072 { 11073 sym->st_value = 0; 11074 sym->st_other = 0; 11075 } 11076 } 11077 11078 if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE) 11079 { 11080 /* We've decided to create a lazy-binding stub. */ 11081 bfd_boolean micromips_p = MICROMIPS_P (output_bfd); 11082 unsigned int other = micromips_p ? STO_MICROMIPS : 0; 11083 bfd_vma stub_size = htab->function_stub_size; 11084 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE]; 11085 bfd_vma isa_bit = micromips_p; 11086 bfd_vma stub_big_size; 11087 11088 if (!micromips_p) 11089 stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE; 11090 else if (htab->insn32) 11091 stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE; 11092 else 11093 stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE; 11094 11095 /* This symbol has a stub. Set it up. */ 11096 11097 BFD_ASSERT (h->dynindx != -1); 11098 11099 BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff); 11100 11101 /* Values up to 2^31 - 1 are allowed. Larger values would cause 11102 sign extension at runtime in the stub, resulting in a negative 11103 index value. */ 11104 if (h->dynindx & ~0x7fffffff) 11105 return FALSE; 11106 11107 /* Fill the stub. */ 11108 if (micromips_p) 11109 { 11110 idx = 0; 11111 bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd), 11112 stub + idx); 11113 idx += 4; 11114 if (htab->insn32) 11115 { 11116 bfd_put_micromips_32 (output_bfd, 11117 STUB_MOVE32_MICROMIPS, stub + idx); 11118 idx += 4; 11119 } 11120 else 11121 { 11122 bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx); 11123 idx += 2; 11124 } 11125 if (stub_size == stub_big_size) 11126 { 11127 long dynindx_hi = (h->dynindx >> 16) & 0x7fff; 11128 11129 bfd_put_micromips_32 (output_bfd, 11130 STUB_LUI_MICROMIPS (dynindx_hi), 11131 stub + idx); 11132 idx += 4; 11133 } 11134 if (htab->insn32) 11135 { 11136 bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS, 11137 stub + idx); 11138 idx += 4; 11139 } 11140 else 11141 { 11142 bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx); 11143 idx += 2; 11144 } 11145 11146 /* If a large stub is not required and sign extension is not a 11147 problem, then use legacy code in the stub. */ 11148 if (stub_size == stub_big_size) 11149 bfd_put_micromips_32 (output_bfd, 11150 STUB_ORI_MICROMIPS (h->dynindx & 0xffff), 11151 stub + idx); 11152 else if (h->dynindx & ~0x7fff) 11153 bfd_put_micromips_32 (output_bfd, 11154 STUB_LI16U_MICROMIPS (h->dynindx & 0xffff), 11155 stub + idx); 11156 else 11157 bfd_put_micromips_32 (output_bfd, 11158 STUB_LI16S_MICROMIPS (output_bfd, 11159 h->dynindx), 11160 stub + idx); 11161 } 11162 else 11163 { 11164 idx = 0; 11165 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx); 11166 idx += 4; 11167 bfd_put_32 (output_bfd, STUB_MOVE, stub + idx); 11168 idx += 4; 11169 if (stub_size == stub_big_size) 11170 { 11171 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff), 11172 stub + idx); 11173 idx += 4; 11174 } 11175 11176 if (!(MIPSR6_P (output_bfd) && htab->compact_branches)) 11177 { 11178 bfd_put_32 (output_bfd, STUB_JALR, stub + idx); 11179 idx += 4; 11180 } 11181 11182 /* If a large stub is not required and sign extension is not a 11183 problem, then use legacy code in the stub. */ 11184 if (stub_size == stub_big_size) 11185 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), 11186 stub + idx); 11187 else if (h->dynindx & ~0x7fff) 11188 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), 11189 stub + idx); 11190 else 11191 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx), 11192 stub + idx); 11193 idx += 4; 11194 11195 if (MIPSR6_P (output_bfd) && htab->compact_branches) 11196 bfd_put_32 (output_bfd, STUB_JALRC, stub + idx); 11197 } 11198 11199 BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size); 11200 memcpy (htab->sstubs->contents + h->plt.plist->stub_offset, 11201 stub, stub_size); 11202 11203 /* Mark the symbol as undefined. stub_offset != -1 occurs 11204 only for the referenced symbol. */ 11205 sym->st_shndx = SHN_UNDEF; 11206 11207 /* The run-time linker uses the st_value field of the symbol 11208 to reset the global offset table entry for this external 11209 to its stub address when unlinking a shared object. */ 11210 sym->st_value = (htab->sstubs->output_section->vma 11211 + htab->sstubs->output_offset 11212 + h->plt.plist->stub_offset 11213 + isa_bit); 11214 sym->st_other = other; 11215 } 11216 11217 /* If we have a MIPS16 function with a stub, the dynamic symbol must 11218 refer to the stub, since only the stub uses the standard calling 11219 conventions. */ 11220 if (h->dynindx != -1 && hmips->fn_stub != NULL) 11221 { 11222 BFD_ASSERT (hmips->need_fn_stub); 11223 sym->st_value = (hmips->fn_stub->output_section->vma 11224 + hmips->fn_stub->output_offset); 11225 sym->st_size = hmips->fn_stub->size; 11226 sym->st_other = ELF_ST_VISIBILITY (sym->st_other); 11227 } 11228 11229 BFD_ASSERT (h->dynindx != -1 11230 || h->forced_local); 11231 11232 sgot = htab->root.sgot; 11233 g = htab->got_info; 11234 BFD_ASSERT (g != NULL); 11235 11236 /* Run through the global symbol table, creating GOT entries for all 11237 the symbols that need them. */ 11238 if (hmips->global_got_area != GGA_NONE) 11239 { 11240 bfd_vma offset; 11241 bfd_vma value; 11242 11243 value = sym->st_value; 11244 offset = mips_elf_primary_global_got_index (output_bfd, info, h); 11245 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset); 11246 } 11247 11248 if (hmips->global_got_area != GGA_NONE && g->next) 11249 { 11250 struct mips_got_entry e, *p; 11251 bfd_vma entry; 11252 bfd_vma offset; 11253 11254 gg = g; 11255 11256 e.abfd = output_bfd; 11257 e.symndx = -1; 11258 e.d.h = hmips; 11259 e.tls_type = GOT_TLS_NONE; 11260 11261 for (g = g->next; g->next != gg; g = g->next) 11262 { 11263 if (g->got_entries 11264 && (p = (struct mips_got_entry *) htab_find (g->got_entries, 11265 &e))) 11266 { 11267 offset = p->gotidx; 11268 BFD_ASSERT (offset > 0 && offset < htab->root.sgot->size); 11269 if (bfd_link_pic (info) 11270 || (elf_hash_table (info)->dynamic_sections_created 11271 && p->d.h != NULL 11272 && p->d.h->root.def_dynamic 11273 && !p->d.h->root.def_regular)) 11274 { 11275 /* Create an R_MIPS_REL32 relocation for this entry. Due to 11276 the various compatibility problems, it's easier to mock 11277 up an R_MIPS_32 or R_MIPS_64 relocation and leave 11278 mips_elf_create_dynamic_relocation to calculate the 11279 appropriate addend. */ 11280 Elf_Internal_Rela rel[3]; 11281 11282 memset (rel, 0, sizeof (rel)); 11283 if (ABI_64_P (output_bfd)) 11284 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64); 11285 else 11286 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32); 11287 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset; 11288 11289 entry = 0; 11290 if (! (mips_elf_create_dynamic_relocation 11291 (output_bfd, info, rel, 11292 e.d.h, NULL, sym->st_value, &entry, sgot))) 11293 return FALSE; 11294 } 11295 else 11296 entry = sym->st_value; 11297 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset); 11298 } 11299 } 11300 } 11301 11302 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 11303 name = h->root.root.string; 11304 if (h == elf_hash_table (info)->hdynamic 11305 || h == elf_hash_table (info)->hgot) 11306 sym->st_shndx = SHN_ABS; 11307 else if (strcmp (name, "_DYNAMIC_LINK") == 0 11308 || strcmp (name, "_DYNAMIC_LINKING") == 0) 11309 { 11310 sym->st_shndx = SHN_ABS; 11311 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 11312 sym->st_value = 1; 11313 } 11314 else if (SGI_COMPAT (output_bfd)) 11315 { 11316 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0 11317 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0) 11318 { 11319 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 11320 sym->st_other = STO_PROTECTED; 11321 sym->st_value = 0; 11322 sym->st_shndx = SHN_MIPS_DATA; 11323 } 11324 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0) 11325 { 11326 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 11327 sym->st_other = STO_PROTECTED; 11328 sym->st_value = mips_elf_hash_table (info)->procedure_count; 11329 sym->st_shndx = SHN_ABS; 11330 } 11331 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) 11332 { 11333 if (h->type == STT_FUNC) 11334 sym->st_shndx = SHN_MIPS_TEXT; 11335 else if (h->type == STT_OBJECT) 11336 sym->st_shndx = SHN_MIPS_DATA; 11337 } 11338 } 11339 11340 /* Emit a copy reloc, if needed. */ 11341 if (h->needs_copy) 11342 { 11343 asection *s; 11344 bfd_vma symval; 11345 11346 BFD_ASSERT (h->dynindx != -1); 11347 BFD_ASSERT (htab->use_plts_and_copy_relocs); 11348 11349 s = mips_elf_rel_dyn_section (info, FALSE); 11350 symval = (h->root.u.def.section->output_section->vma 11351 + h->root.u.def.section->output_offset 11352 + h->root.u.def.value); 11353 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++, 11354 h->dynindx, R_MIPS_COPY, symval); 11355 } 11356 11357 /* Handle the IRIX6-specific symbols. */ 11358 if (IRIX_COMPAT (output_bfd) == ict_irix6) 11359 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym); 11360 11361 /* Keep dynamic compressed symbols odd. This allows the dynamic linker 11362 to treat compressed symbols like any other. */ 11363 if (ELF_ST_IS_MIPS16 (sym->st_other)) 11364 { 11365 BFD_ASSERT (sym->st_value & 1); 11366 sym->st_other -= STO_MIPS16; 11367 } 11368 else if (ELF_ST_IS_MICROMIPS (sym->st_other)) 11369 { 11370 BFD_ASSERT (sym->st_value & 1); 11371 sym->st_other -= STO_MICROMIPS; 11372 } 11373 11374 return TRUE; 11375 } 11376 11377 /* Likewise, for VxWorks. */ 11378 11379 bfd_boolean 11380 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd, 11381 struct bfd_link_info *info, 11382 struct elf_link_hash_entry *h, 11383 Elf_Internal_Sym *sym) 11384 { 11385 bfd *dynobj; 11386 asection *sgot; 11387 struct mips_got_info *g; 11388 struct mips_elf_link_hash_table *htab; 11389 struct mips_elf_link_hash_entry *hmips; 11390 11391 htab = mips_elf_hash_table (info); 11392 BFD_ASSERT (htab != NULL); 11393 dynobj = elf_hash_table (info)->dynobj; 11394 hmips = (struct mips_elf_link_hash_entry *) h; 11395 11396 if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE) 11397 { 11398 bfd_byte *loc; 11399 bfd_vma plt_address, got_address, got_offset, branch_offset; 11400 Elf_Internal_Rela rel; 11401 static const bfd_vma *plt_entry; 11402 bfd_vma gotplt_index; 11403 bfd_vma plt_offset; 11404 11405 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset; 11406 gotplt_index = h->plt.plist->gotplt_index; 11407 11408 BFD_ASSERT (h->dynindx != -1); 11409 BFD_ASSERT (htab->root.splt != NULL); 11410 BFD_ASSERT (gotplt_index != MINUS_ONE); 11411 BFD_ASSERT (plt_offset <= htab->root.splt->size); 11412 11413 /* Calculate the address of the .plt entry. */ 11414 plt_address = (htab->root.splt->output_section->vma 11415 + htab->root.splt->output_offset 11416 + plt_offset); 11417 11418 /* Calculate the address of the .got.plt entry. */ 11419 got_address = (htab->root.sgotplt->output_section->vma 11420 + htab->root.sgotplt->output_offset 11421 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)); 11422 11423 /* Calculate the offset of the .got.plt entry from 11424 _GLOBAL_OFFSET_TABLE_. */ 11425 got_offset = mips_elf_gotplt_index (info, h); 11426 11427 /* Calculate the offset for the branch at the start of the PLT 11428 entry. The branch jumps to the beginning of .plt. */ 11429 branch_offset = -(plt_offset / 4 + 1) & 0xffff; 11430 11431 /* Fill in the initial value of the .got.plt entry. */ 11432 bfd_put_32 (output_bfd, plt_address, 11433 (htab->root.sgotplt->contents 11434 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd))); 11435 11436 /* Find out where the .plt entry should go. */ 11437 loc = htab->root.splt->contents + plt_offset; 11438 11439 if (bfd_link_pic (info)) 11440 { 11441 plt_entry = mips_vxworks_shared_plt_entry; 11442 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc); 11443 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4); 11444 } 11445 else 11446 { 11447 bfd_vma got_address_high, got_address_low; 11448 11449 plt_entry = mips_vxworks_exec_plt_entry; 11450 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff; 11451 got_address_low = got_address & 0xffff; 11452 11453 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc); 11454 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4); 11455 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8); 11456 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12); 11457 bfd_put_32 (output_bfd, plt_entry[4], loc + 16); 11458 bfd_put_32 (output_bfd, plt_entry[5], loc + 20); 11459 bfd_put_32 (output_bfd, plt_entry[6], loc + 24); 11460 bfd_put_32 (output_bfd, plt_entry[7], loc + 28); 11461 11462 loc = (htab->srelplt2->contents 11463 + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela)); 11464 11465 /* Emit a relocation for the .got.plt entry. */ 11466 rel.r_offset = got_address; 11467 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32); 11468 rel.r_addend = plt_offset; 11469 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11470 11471 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */ 11472 loc += sizeof (Elf32_External_Rela); 11473 rel.r_offset = plt_address + 8; 11474 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 11475 rel.r_addend = got_offset; 11476 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11477 11478 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */ 11479 loc += sizeof (Elf32_External_Rela); 11480 rel.r_offset += 4; 11481 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 11482 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11483 } 11484 11485 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */ 11486 loc = (htab->root.srelplt->contents 11487 + gotplt_index * sizeof (Elf32_External_Rela)); 11488 rel.r_offset = got_address; 11489 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT); 11490 rel.r_addend = 0; 11491 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11492 11493 if (!h->def_regular) 11494 sym->st_shndx = SHN_UNDEF; 11495 } 11496 11497 BFD_ASSERT (h->dynindx != -1 || h->forced_local); 11498 11499 sgot = htab->root.sgot; 11500 g = htab->got_info; 11501 BFD_ASSERT (g != NULL); 11502 11503 /* See if this symbol has an entry in the GOT. */ 11504 if (hmips->global_got_area != GGA_NONE) 11505 { 11506 bfd_vma offset; 11507 Elf_Internal_Rela outrel; 11508 bfd_byte *loc; 11509 asection *s; 11510 11511 /* Install the symbol value in the GOT. */ 11512 offset = mips_elf_primary_global_got_index (output_bfd, info, h); 11513 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset); 11514 11515 /* Add a dynamic relocation for it. */ 11516 s = mips_elf_rel_dyn_section (info, FALSE); 11517 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela)); 11518 outrel.r_offset = (sgot->output_section->vma 11519 + sgot->output_offset 11520 + offset); 11521 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32); 11522 outrel.r_addend = 0; 11523 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc); 11524 } 11525 11526 /* Emit a copy reloc, if needed. */ 11527 if (h->needs_copy) 11528 { 11529 Elf_Internal_Rela rel; 11530 asection *srel; 11531 bfd_byte *loc; 11532 11533 BFD_ASSERT (h->dynindx != -1); 11534 11535 rel.r_offset = (h->root.u.def.section->output_section->vma 11536 + h->root.u.def.section->output_offset 11537 + h->root.u.def.value); 11538 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY); 11539 rel.r_addend = 0; 11540 if (h->root.u.def.section == htab->root.sdynrelro) 11541 srel = htab->root.sreldynrelro; 11542 else 11543 srel = htab->root.srelbss; 11544 loc = srel->contents + srel->reloc_count * sizeof (Elf32_External_Rela); 11545 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11546 ++srel->reloc_count; 11547 } 11548 11549 /* If this is a mips16/microMIPS symbol, force the value to be even. */ 11550 if (ELF_ST_IS_COMPRESSED (sym->st_other)) 11551 sym->st_value &= ~1; 11552 11553 return TRUE; 11554 } 11555 11556 /* Write out a plt0 entry to the beginning of .plt. */ 11557 11558 static bfd_boolean 11559 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info) 11560 { 11561 bfd_byte *loc; 11562 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low; 11563 static const bfd_vma *plt_entry; 11564 struct mips_elf_link_hash_table *htab; 11565 11566 htab = mips_elf_hash_table (info); 11567 BFD_ASSERT (htab != NULL); 11568 11569 if (ABI_64_P (output_bfd)) 11570 plt_entry = (htab->compact_branches 11571 ? mipsr6_n64_exec_plt0_entry_compact 11572 : mips_n64_exec_plt0_entry); 11573 else if (ABI_N32_P (output_bfd)) 11574 plt_entry = (htab->compact_branches 11575 ? mipsr6_n32_exec_plt0_entry_compact 11576 : mips_n32_exec_plt0_entry); 11577 else if (!htab->plt_header_is_comp) 11578 plt_entry = (htab->compact_branches 11579 ? mipsr6_o32_exec_plt0_entry_compact 11580 : mips_o32_exec_plt0_entry); 11581 else if (htab->insn32) 11582 plt_entry = micromips_insn32_o32_exec_plt0_entry; 11583 else 11584 plt_entry = micromips_o32_exec_plt0_entry; 11585 11586 /* Calculate the value of .got.plt. */ 11587 gotplt_value = (htab->root.sgotplt->output_section->vma 11588 + htab->root.sgotplt->output_offset); 11589 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff; 11590 gotplt_value_low = gotplt_value & 0xffff; 11591 11592 /* The PLT sequence is not safe for N64 if .got.plt's address can 11593 not be loaded in two instructions. */ 11594 if (ABI_64_P (output_bfd) 11595 && ((gotplt_value + 0x80008000) & ~(bfd_vma) 0xffffffff) != 0) 11596 { 11597 _bfd_error_handler 11598 /* xgettext:c-format */ 11599 (_("%pB: `%pA' start VMA of %#" PRIx64 " outside the 32-bit range " 11600 "supported; consider using `-Ttext-segment=...'"), 11601 output_bfd, 11602 htab->root.sgotplt->output_section, 11603 (int64_t) gotplt_value); 11604 bfd_set_error (bfd_error_no_error); 11605 return FALSE; 11606 } 11607 11608 /* Install the PLT header. */ 11609 loc = htab->root.splt->contents; 11610 if (plt_entry == micromips_o32_exec_plt0_entry) 11611 { 11612 bfd_vma gotpc_offset; 11613 bfd_vma loc_address; 11614 size_t i; 11615 11616 BFD_ASSERT (gotplt_value % 4 == 0); 11617 11618 loc_address = (htab->root.splt->output_section->vma 11619 + htab->root.splt->output_offset); 11620 gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3); 11621 11622 /* ADDIUPC has a span of +/-16MB, check we're in range. */ 11623 if (gotpc_offset + 0x1000000 >= 0x2000000) 11624 { 11625 _bfd_error_handler 11626 /* xgettext:c-format */ 11627 (_("%pB: `%pA' offset of %" PRId64 " from `%pA' " 11628 "beyond the range of ADDIUPC"), 11629 output_bfd, 11630 htab->root.sgotplt->output_section, 11631 (int64_t) gotpc_offset, 11632 htab->root.splt->output_section); 11633 bfd_set_error (bfd_error_no_error); 11634 return FALSE; 11635 } 11636 bfd_put_16 (output_bfd, 11637 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc); 11638 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2); 11639 for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++) 11640 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2)); 11641 } 11642 else if (plt_entry == micromips_insn32_o32_exec_plt0_entry) 11643 { 11644 size_t i; 11645 11646 bfd_put_16 (output_bfd, plt_entry[0], loc); 11647 bfd_put_16 (output_bfd, gotplt_value_high, loc + 2); 11648 bfd_put_16 (output_bfd, plt_entry[2], loc + 4); 11649 bfd_put_16 (output_bfd, gotplt_value_low, loc + 6); 11650 bfd_put_16 (output_bfd, plt_entry[4], loc + 8); 11651 bfd_put_16 (output_bfd, gotplt_value_low, loc + 10); 11652 for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++) 11653 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2)); 11654 } 11655 else 11656 { 11657 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc); 11658 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4); 11659 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8); 11660 bfd_put_32 (output_bfd, plt_entry[3], loc + 12); 11661 bfd_put_32 (output_bfd, plt_entry[4], loc + 16); 11662 bfd_put_32 (output_bfd, plt_entry[5], loc + 20); 11663 bfd_put_32 (output_bfd, plt_entry[6], loc + 24); 11664 bfd_put_32 (output_bfd, plt_entry[7], loc + 28); 11665 } 11666 11667 return TRUE; 11668 } 11669 11670 /* Install the PLT header for a VxWorks executable and finalize the 11671 contents of .rela.plt.unloaded. */ 11672 11673 static void 11674 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info) 11675 { 11676 Elf_Internal_Rela rela; 11677 bfd_byte *loc; 11678 bfd_vma got_value, got_value_high, got_value_low, plt_address; 11679 static const bfd_vma *plt_entry; 11680 struct mips_elf_link_hash_table *htab; 11681 11682 htab = mips_elf_hash_table (info); 11683 BFD_ASSERT (htab != NULL); 11684 11685 plt_entry = mips_vxworks_exec_plt0_entry; 11686 11687 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */ 11688 got_value = (htab->root.hgot->root.u.def.section->output_section->vma 11689 + htab->root.hgot->root.u.def.section->output_offset 11690 + htab->root.hgot->root.u.def.value); 11691 11692 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff; 11693 got_value_low = got_value & 0xffff; 11694 11695 /* Calculate the address of the PLT header. */ 11696 plt_address = (htab->root.splt->output_section->vma 11697 + htab->root.splt->output_offset); 11698 11699 /* Install the PLT header. */ 11700 loc = htab->root.splt->contents; 11701 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc); 11702 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4); 11703 bfd_put_32 (output_bfd, plt_entry[2], loc + 8); 11704 bfd_put_32 (output_bfd, plt_entry[3], loc + 12); 11705 bfd_put_32 (output_bfd, plt_entry[4], loc + 16); 11706 bfd_put_32 (output_bfd, plt_entry[5], loc + 20); 11707 11708 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */ 11709 loc = htab->srelplt2->contents; 11710 rela.r_offset = plt_address; 11711 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 11712 rela.r_addend = 0; 11713 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 11714 loc += sizeof (Elf32_External_Rela); 11715 11716 /* Output the relocation for the following addiu of 11717 %lo(_GLOBAL_OFFSET_TABLE_). */ 11718 rela.r_offset += 4; 11719 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 11720 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 11721 loc += sizeof (Elf32_External_Rela); 11722 11723 /* Fix up the remaining relocations. They may have the wrong 11724 symbol index for _G_O_T_ or _P_L_T_ depending on the order 11725 in which symbols were output. */ 11726 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 11727 { 11728 Elf_Internal_Rela rel; 11729 11730 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 11731 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32); 11732 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11733 loc += sizeof (Elf32_External_Rela); 11734 11735 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 11736 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 11737 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11738 loc += sizeof (Elf32_External_Rela); 11739 11740 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 11741 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 11742 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 11743 loc += sizeof (Elf32_External_Rela); 11744 } 11745 } 11746 11747 /* Install the PLT header for a VxWorks shared library. */ 11748 11749 static void 11750 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info) 11751 { 11752 unsigned int i; 11753 struct mips_elf_link_hash_table *htab; 11754 11755 htab = mips_elf_hash_table (info); 11756 BFD_ASSERT (htab != NULL); 11757 11758 /* We just need to copy the entry byte-by-byte. */ 11759 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++) 11760 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i], 11761 htab->root.splt->contents + i * 4); 11762 } 11763 11764 /* Finish up the dynamic sections. */ 11765 11766 bfd_boolean 11767 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd, 11768 struct bfd_link_info *info) 11769 { 11770 bfd *dynobj; 11771 asection *sdyn; 11772 asection *sgot; 11773 struct mips_got_info *gg, *g; 11774 struct mips_elf_link_hash_table *htab; 11775 11776 htab = mips_elf_hash_table (info); 11777 BFD_ASSERT (htab != NULL); 11778 11779 dynobj = elf_hash_table (info)->dynobj; 11780 11781 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 11782 11783 sgot = htab->root.sgot; 11784 gg = htab->got_info; 11785 11786 if (elf_hash_table (info)->dynamic_sections_created) 11787 { 11788 bfd_byte *b; 11789 int dyn_to_skip = 0, dyn_skipped = 0; 11790 11791 BFD_ASSERT (sdyn != NULL); 11792 BFD_ASSERT (gg != NULL); 11793 11794 g = mips_elf_bfd_got (output_bfd, FALSE); 11795 BFD_ASSERT (g != NULL); 11796 11797 for (b = sdyn->contents; 11798 b < sdyn->contents + sdyn->size; 11799 b += MIPS_ELF_DYN_SIZE (dynobj)) 11800 { 11801 Elf_Internal_Dyn dyn; 11802 const char *name; 11803 size_t elemsize; 11804 asection *s; 11805 bfd_boolean swap_out_p; 11806 11807 /* Read in the current dynamic entry. */ 11808 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 11809 11810 /* Assume that we're going to modify it and write it out. */ 11811 swap_out_p = TRUE; 11812 11813 switch (dyn.d_tag) 11814 { 11815 case DT_RELENT: 11816 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj); 11817 break; 11818 11819 case DT_RELAENT: 11820 BFD_ASSERT (htab->root.target_os == is_vxworks); 11821 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj); 11822 break; 11823 11824 case DT_STRSZ: 11825 /* Rewrite DT_STRSZ. */ 11826 dyn.d_un.d_val = 11827 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 11828 break; 11829 11830 case DT_PLTGOT: 11831 s = htab->root.sgot; 11832 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11833 break; 11834 11835 case DT_MIPS_PLTGOT: 11836 s = htab->root.sgotplt; 11837 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11838 break; 11839 11840 case DT_MIPS_RLD_VERSION: 11841 dyn.d_un.d_val = 1; /* XXX */ 11842 break; 11843 11844 case DT_MIPS_FLAGS: 11845 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */ 11846 break; 11847 11848 case DT_MIPS_TIME_STAMP: 11849 { 11850 time_t t; 11851 time (&t); 11852 dyn.d_un.d_val = t; 11853 } 11854 break; 11855 11856 case DT_MIPS_ICHECKSUM: 11857 /* XXX FIXME: */ 11858 swap_out_p = FALSE; 11859 break; 11860 11861 case DT_MIPS_IVERSION: 11862 /* XXX FIXME: */ 11863 swap_out_p = FALSE; 11864 break; 11865 11866 case DT_MIPS_BASE_ADDRESS: 11867 s = output_bfd->sections; 11868 BFD_ASSERT (s != NULL); 11869 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff; 11870 break; 11871 11872 case DT_MIPS_LOCAL_GOTNO: 11873 dyn.d_un.d_val = g->local_gotno; 11874 break; 11875 11876 case DT_MIPS_UNREFEXTNO: 11877 /* The index into the dynamic symbol table which is the 11878 entry of the first external symbol that is not 11879 referenced within the same object. */ 11880 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1; 11881 break; 11882 11883 case DT_MIPS_GOTSYM: 11884 if (htab->global_gotsym) 11885 { 11886 dyn.d_un.d_val = htab->global_gotsym->dynindx; 11887 break; 11888 } 11889 /* In case if we don't have global got symbols we default 11890 to setting DT_MIPS_GOTSYM to the same value as 11891 DT_MIPS_SYMTABNO. */ 11892 /* Fall through. */ 11893 11894 case DT_MIPS_SYMTABNO: 11895 name = ".dynsym"; 11896 elemsize = MIPS_ELF_SYM_SIZE (output_bfd); 11897 s = bfd_get_linker_section (dynobj, name); 11898 11899 if (s != NULL) 11900 dyn.d_un.d_val = s->size / elemsize; 11901 else 11902 dyn.d_un.d_val = 0; 11903 break; 11904 11905 case DT_MIPS_HIPAGENO: 11906 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno; 11907 break; 11908 11909 case DT_MIPS_RLD_MAP: 11910 { 11911 struct elf_link_hash_entry *h; 11912 h = mips_elf_hash_table (info)->rld_symbol; 11913 if (!h) 11914 { 11915 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj); 11916 swap_out_p = FALSE; 11917 break; 11918 } 11919 s = h->root.u.def.section; 11920 11921 /* The MIPS_RLD_MAP tag stores the absolute address of the 11922 debug pointer. */ 11923 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset 11924 + h->root.u.def.value); 11925 } 11926 break; 11927 11928 case DT_MIPS_RLD_MAP_REL: 11929 { 11930 struct elf_link_hash_entry *h; 11931 bfd_vma dt_addr, rld_addr; 11932 h = mips_elf_hash_table (info)->rld_symbol; 11933 if (!h) 11934 { 11935 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj); 11936 swap_out_p = FALSE; 11937 break; 11938 } 11939 s = h->root.u.def.section; 11940 11941 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug 11942 pointer, relative to the address of the tag. */ 11943 dt_addr = (sdyn->output_section->vma + sdyn->output_offset 11944 + (b - sdyn->contents)); 11945 rld_addr = (s->output_section->vma + s->output_offset 11946 + h->root.u.def.value); 11947 dyn.d_un.d_ptr = rld_addr - dt_addr; 11948 } 11949 break; 11950 11951 case DT_MIPS_OPTIONS: 11952 s = (bfd_get_section_by_name 11953 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd))); 11954 dyn.d_un.d_ptr = s->vma; 11955 break; 11956 11957 case DT_PLTREL: 11958 BFD_ASSERT (htab->use_plts_and_copy_relocs); 11959 if (htab->root.target_os == is_vxworks) 11960 dyn.d_un.d_val = DT_RELA; 11961 else 11962 dyn.d_un.d_val = DT_REL; 11963 break; 11964 11965 case DT_PLTRELSZ: 11966 BFD_ASSERT (htab->use_plts_and_copy_relocs); 11967 dyn.d_un.d_val = htab->root.srelplt->size; 11968 break; 11969 11970 case DT_JMPREL: 11971 BFD_ASSERT (htab->use_plts_and_copy_relocs); 11972 dyn.d_un.d_ptr = (htab->root.srelplt->output_section->vma 11973 + htab->root.srelplt->output_offset); 11974 break; 11975 11976 case DT_TEXTREL: 11977 /* If we didn't need any text relocations after all, delete 11978 the dynamic tag. */ 11979 if (!(info->flags & DF_TEXTREL)) 11980 { 11981 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj); 11982 swap_out_p = FALSE; 11983 } 11984 break; 11985 11986 case DT_FLAGS: 11987 /* If we didn't need any text relocations after all, clear 11988 DF_TEXTREL from DT_FLAGS. */ 11989 if (!(info->flags & DF_TEXTREL)) 11990 dyn.d_un.d_val &= ~DF_TEXTREL; 11991 else 11992 swap_out_p = FALSE; 11993 break; 11994 11995 case DT_MIPS_XHASH: 11996 name = ".MIPS.xhash"; 11997 s = bfd_get_linker_section (dynobj, name); 11998 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 11999 break; 12000 12001 default: 12002 swap_out_p = FALSE; 12003 if (htab->root.target_os == is_vxworks 12004 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 12005 swap_out_p = TRUE; 12006 break; 12007 } 12008 12009 if (swap_out_p || dyn_skipped) 12010 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) 12011 (dynobj, &dyn, b - dyn_skipped); 12012 12013 if (dyn_to_skip) 12014 { 12015 dyn_skipped += dyn_to_skip; 12016 dyn_to_skip = 0; 12017 } 12018 } 12019 12020 /* Wipe out any trailing entries if we shifted down a dynamic tag. */ 12021 if (dyn_skipped > 0) 12022 memset (b - dyn_skipped, 0, dyn_skipped); 12023 } 12024 12025 if (sgot != NULL && sgot->size > 0 12026 && !bfd_is_abs_section (sgot->output_section)) 12027 { 12028 if (htab->root.target_os == is_vxworks) 12029 { 12030 /* The first entry of the global offset table points to the 12031 ".dynamic" section. The second is initialized by the 12032 loader and contains the shared library identifier. 12033 The third is also initialized by the loader and points 12034 to the lazy resolution stub. */ 12035 MIPS_ELF_PUT_WORD (output_bfd, 12036 sdyn->output_offset + sdyn->output_section->vma, 12037 sgot->contents); 12038 MIPS_ELF_PUT_WORD (output_bfd, 0, 12039 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd)); 12040 MIPS_ELF_PUT_WORD (output_bfd, 0, 12041 sgot->contents 12042 + 2 * MIPS_ELF_GOT_SIZE (output_bfd)); 12043 } 12044 else 12045 { 12046 /* The first entry of the global offset table will be filled at 12047 runtime. The second entry will be used by some runtime loaders. 12048 This isn't the case of IRIX rld. */ 12049 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents); 12050 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd), 12051 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd)); 12052 } 12053 12054 elf_section_data (sgot->output_section)->this_hdr.sh_entsize 12055 = MIPS_ELF_GOT_SIZE (output_bfd); 12056 } 12057 12058 /* Generate dynamic relocations for the non-primary gots. */ 12059 if (gg != NULL && gg->next) 12060 { 12061 Elf_Internal_Rela rel[3]; 12062 bfd_vma addend = 0; 12063 12064 memset (rel, 0, sizeof (rel)); 12065 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32); 12066 12067 for (g = gg->next; g->next != gg; g = g->next) 12068 { 12069 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno 12070 + g->next->tls_gotno; 12071 12072 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents 12073 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd)); 12074 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd), 12075 sgot->contents 12076 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd)); 12077 12078 if (! bfd_link_pic (info)) 12079 continue; 12080 12081 for (; got_index < g->local_gotno; got_index++) 12082 { 12083 if (got_index >= g->assigned_low_gotno 12084 && got_index <= g->assigned_high_gotno) 12085 continue; 12086 12087 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset 12088 = got_index * MIPS_ELF_GOT_SIZE (output_bfd); 12089 if (!(mips_elf_create_dynamic_relocation 12090 (output_bfd, info, rel, NULL, 12091 bfd_abs_section_ptr, 12092 0, &addend, sgot))) 12093 return FALSE; 12094 BFD_ASSERT (addend == 0); 12095 } 12096 } 12097 } 12098 12099 /* The generation of dynamic relocations for the non-primary gots 12100 adds more dynamic relocations. We cannot count them until 12101 here. */ 12102 12103 if (elf_hash_table (info)->dynamic_sections_created) 12104 { 12105 bfd_byte *b; 12106 bfd_boolean swap_out_p; 12107 12108 BFD_ASSERT (sdyn != NULL); 12109 12110 for (b = sdyn->contents; 12111 b < sdyn->contents + sdyn->size; 12112 b += MIPS_ELF_DYN_SIZE (dynobj)) 12113 { 12114 Elf_Internal_Dyn dyn; 12115 asection *s; 12116 12117 /* Read in the current dynamic entry. */ 12118 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 12119 12120 /* Assume that we're going to modify it and write it out. */ 12121 swap_out_p = TRUE; 12122 12123 switch (dyn.d_tag) 12124 { 12125 case DT_RELSZ: 12126 /* Reduce DT_RELSZ to account for any relocations we 12127 decided not to make. This is for the n64 irix rld, 12128 which doesn't seem to apply any relocations if there 12129 are trailing null entries. */ 12130 s = mips_elf_rel_dyn_section (info, FALSE); 12131 dyn.d_un.d_val = (s->reloc_count 12132 * (ABI_64_P (output_bfd) 12133 ? sizeof (Elf64_Mips_External_Rel) 12134 : sizeof (Elf32_External_Rel))); 12135 /* Adjust the section size too. Tools like the prelinker 12136 can reasonably expect the values to the same. */ 12137 BFD_ASSERT (!bfd_is_abs_section (s->output_section)); 12138 elf_section_data (s->output_section)->this_hdr.sh_size 12139 = dyn.d_un.d_val; 12140 break; 12141 12142 default: 12143 swap_out_p = FALSE; 12144 break; 12145 } 12146 12147 if (swap_out_p) 12148 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) 12149 (dynobj, &dyn, b); 12150 } 12151 } 12152 12153 { 12154 asection *s; 12155 Elf32_compact_rel cpt; 12156 12157 if (SGI_COMPAT (output_bfd)) 12158 { 12159 /* Write .compact_rel section out. */ 12160 s = bfd_get_linker_section (dynobj, ".compact_rel"); 12161 if (s != NULL) 12162 { 12163 cpt.id1 = 1; 12164 cpt.num = s->reloc_count; 12165 cpt.id2 = 2; 12166 cpt.offset = (s->output_section->filepos 12167 + sizeof (Elf32_External_compact_rel)); 12168 cpt.reserved0 = 0; 12169 cpt.reserved1 = 0; 12170 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt, 12171 ((Elf32_External_compact_rel *) 12172 s->contents)); 12173 12174 /* Clean up a dummy stub function entry in .text. */ 12175 if (htab->sstubs != NULL 12176 && htab->sstubs->contents != NULL) 12177 { 12178 file_ptr dummy_offset; 12179 12180 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size); 12181 dummy_offset = htab->sstubs->size - htab->function_stub_size; 12182 memset (htab->sstubs->contents + dummy_offset, 0, 12183 htab->function_stub_size); 12184 } 12185 } 12186 } 12187 12188 /* The psABI says that the dynamic relocations must be sorted in 12189 increasing order of r_symndx. The VxWorks EABI doesn't require 12190 this, and because the code below handles REL rather than RELA 12191 relocations, using it for VxWorks would be outright harmful. */ 12192 if (htab->root.target_os != is_vxworks) 12193 { 12194 s = mips_elf_rel_dyn_section (info, FALSE); 12195 if (s != NULL 12196 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd)) 12197 { 12198 reldyn_sorting_bfd = output_bfd; 12199 12200 if (ABI_64_P (output_bfd)) 12201 qsort ((Elf64_External_Rel *) s->contents + 1, 12202 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel), 12203 sort_dynamic_relocs_64); 12204 else 12205 qsort ((Elf32_External_Rel *) s->contents + 1, 12206 s->reloc_count - 1, sizeof (Elf32_External_Rel), 12207 sort_dynamic_relocs); 12208 } 12209 } 12210 } 12211 12212 if (htab->root.splt && htab->root.splt->size > 0) 12213 { 12214 if (htab->root.target_os == is_vxworks) 12215 { 12216 if (bfd_link_pic (info)) 12217 mips_vxworks_finish_shared_plt (output_bfd, info); 12218 else 12219 mips_vxworks_finish_exec_plt (output_bfd, info); 12220 } 12221 else 12222 { 12223 BFD_ASSERT (!bfd_link_pic (info)); 12224 if (!mips_finish_exec_plt (output_bfd, info)) 12225 return FALSE; 12226 } 12227 } 12228 return TRUE; 12229 } 12230 12231 12232 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */ 12233 12234 static void 12235 mips_set_isa_flags (bfd *abfd) 12236 { 12237 flagword val; 12238 12239 switch (bfd_get_mach (abfd)) 12240 { 12241 default: 12242 if (ABI_N32_P (abfd) || ABI_64_P (abfd)) 12243 val = E_MIPS_ARCH_3; 12244 else 12245 val = E_MIPS_ARCH_1; 12246 break; 12247 12248 case bfd_mach_mips3000: 12249 val = E_MIPS_ARCH_1; 12250 break; 12251 12252 case bfd_mach_mips3900: 12253 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900; 12254 break; 12255 12256 case bfd_mach_mips6000: 12257 val = E_MIPS_ARCH_2; 12258 break; 12259 12260 case bfd_mach_mips4010: 12261 val = E_MIPS_ARCH_2 | E_MIPS_MACH_4010; 12262 break; 12263 12264 case bfd_mach_mips4000: 12265 case bfd_mach_mips4300: 12266 case bfd_mach_mips4400: 12267 case bfd_mach_mips4600: 12268 val = E_MIPS_ARCH_3; 12269 break; 12270 12271 case bfd_mach_mips4100: 12272 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100; 12273 break; 12274 12275 case bfd_mach_mips4111: 12276 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111; 12277 break; 12278 12279 case bfd_mach_mips4120: 12280 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120; 12281 break; 12282 12283 case bfd_mach_mips4650: 12284 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650; 12285 break; 12286 12287 case bfd_mach_mips5400: 12288 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400; 12289 break; 12290 12291 case bfd_mach_mips5500: 12292 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500; 12293 break; 12294 12295 case bfd_mach_mips5900: 12296 val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900; 12297 break; 12298 12299 case bfd_mach_mips9000: 12300 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000; 12301 break; 12302 12303 case bfd_mach_mips5000: 12304 case bfd_mach_mips7000: 12305 case bfd_mach_mips8000: 12306 case bfd_mach_mips10000: 12307 case bfd_mach_mips12000: 12308 case bfd_mach_mips14000: 12309 case bfd_mach_mips16000: 12310 val = E_MIPS_ARCH_4; 12311 break; 12312 12313 case bfd_mach_mips5: 12314 val = E_MIPS_ARCH_5; 12315 break; 12316 12317 case bfd_mach_mips_loongson_2e: 12318 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E; 12319 break; 12320 12321 case bfd_mach_mips_loongson_2f: 12322 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F; 12323 break; 12324 12325 case bfd_mach_mips_sb1: 12326 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1; 12327 break; 12328 12329 case bfd_mach_mips_gs464: 12330 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS464; 12331 break; 12332 12333 case bfd_mach_mips_gs464e: 12334 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS464E; 12335 break; 12336 12337 case bfd_mach_mips_gs264e: 12338 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_GS264E; 12339 break; 12340 12341 case bfd_mach_mips_octeon: 12342 case bfd_mach_mips_octeonp: 12343 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON; 12344 break; 12345 12346 case bfd_mach_mips_octeon3: 12347 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3; 12348 break; 12349 12350 case bfd_mach_mips_xlr: 12351 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR; 12352 break; 12353 12354 case bfd_mach_mips_octeon2: 12355 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2; 12356 break; 12357 12358 case bfd_mach_mipsisa32: 12359 val = E_MIPS_ARCH_32; 12360 break; 12361 12362 case bfd_mach_mipsisa64: 12363 val = E_MIPS_ARCH_64; 12364 break; 12365 12366 case bfd_mach_mipsisa32r2: 12367 case bfd_mach_mipsisa32r3: 12368 case bfd_mach_mipsisa32r5: 12369 val = E_MIPS_ARCH_32R2; 12370 break; 12371 12372 case bfd_mach_mips_interaptiv_mr2: 12373 val = E_MIPS_ARCH_32R2 | E_MIPS_MACH_IAMR2; 12374 break; 12375 12376 case bfd_mach_mipsisa64r2: 12377 case bfd_mach_mipsisa64r3: 12378 case bfd_mach_mipsisa64r5: 12379 val = E_MIPS_ARCH_64R2; 12380 break; 12381 12382 case bfd_mach_mipsisa32r6: 12383 val = E_MIPS_ARCH_32R6; 12384 break; 12385 12386 case bfd_mach_mipsisa64r6: 12387 val = E_MIPS_ARCH_64R6; 12388 break; 12389 } 12390 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH); 12391 elf_elfheader (abfd)->e_flags |= val; 12392 12393 } 12394 12395 12396 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset. 12397 Don't do so for code sections. We want to keep ordering of HI16/LO16 12398 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame 12399 relocs to be sorted. */ 12400 12401 bfd_boolean 12402 _bfd_mips_elf_sort_relocs_p (asection *sec) 12403 { 12404 return (sec->flags & SEC_CODE) == 0; 12405 } 12406 12407 12408 /* The final processing done just before writing out a MIPS ELF object 12409 file. This gets the MIPS architecture right based on the machine 12410 number. This is used by both the 32-bit and the 64-bit ABI. */ 12411 12412 void 12413 _bfd_mips_final_write_processing (bfd *abfd) 12414 { 12415 unsigned int i; 12416 Elf_Internal_Shdr **hdrpp; 12417 const char *name; 12418 asection *sec; 12419 12420 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former 12421 is nonzero. This is for compatibility with old objects, which used 12422 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */ 12423 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0) 12424 mips_set_isa_flags (abfd); 12425 12426 /* Set the sh_info field for .gptab sections and other appropriate 12427 info for each special section. */ 12428 for (i = 1, hdrpp = elf_elfsections (abfd) + 1; 12429 i < elf_numsections (abfd); 12430 i++, hdrpp++) 12431 { 12432 switch ((*hdrpp)->sh_type) 12433 { 12434 case SHT_MIPS_MSYM: 12435 case SHT_MIPS_LIBLIST: 12436 sec = bfd_get_section_by_name (abfd, ".dynstr"); 12437 if (sec != NULL) 12438 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 12439 break; 12440 12441 case SHT_MIPS_GPTAB: 12442 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 12443 name = bfd_section_name ((*hdrpp)->bfd_section); 12444 BFD_ASSERT (name != NULL 12445 && CONST_STRNEQ (name, ".gptab.")); 12446 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1); 12447 BFD_ASSERT (sec != NULL); 12448 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx; 12449 break; 12450 12451 case SHT_MIPS_CONTENT: 12452 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 12453 name = bfd_section_name ((*hdrpp)->bfd_section); 12454 BFD_ASSERT (name != NULL 12455 && CONST_STRNEQ (name, ".MIPS.content")); 12456 sec = bfd_get_section_by_name (abfd, 12457 name + sizeof ".MIPS.content" - 1); 12458 BFD_ASSERT (sec != NULL); 12459 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 12460 break; 12461 12462 case SHT_MIPS_SYMBOL_LIB: 12463 sec = bfd_get_section_by_name (abfd, ".dynsym"); 12464 if (sec != NULL) 12465 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 12466 sec = bfd_get_section_by_name (abfd, ".liblist"); 12467 if (sec != NULL) 12468 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx; 12469 break; 12470 12471 case SHT_MIPS_EVENTS: 12472 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 12473 name = bfd_section_name ((*hdrpp)->bfd_section); 12474 BFD_ASSERT (name != NULL); 12475 if (CONST_STRNEQ (name, ".MIPS.events")) 12476 sec = bfd_get_section_by_name (abfd, 12477 name + sizeof ".MIPS.events" - 1); 12478 else 12479 { 12480 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel")); 12481 sec = bfd_get_section_by_name (abfd, 12482 (name 12483 + sizeof ".MIPS.post_rel" - 1)); 12484 } 12485 BFD_ASSERT (sec != NULL); 12486 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 12487 break; 12488 12489 case SHT_MIPS_XHASH: 12490 sec = bfd_get_section_by_name (abfd, ".dynsym"); 12491 if (sec != NULL) 12492 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 12493 } 12494 } 12495 } 12496 12497 bfd_boolean 12498 _bfd_mips_elf_final_write_processing (bfd *abfd) 12499 { 12500 _bfd_mips_final_write_processing (abfd); 12501 return _bfd_elf_final_write_processing (abfd); 12502 } 12503 12504 /* When creating an IRIX5 executable, we need REGINFO and RTPROC 12505 segments. */ 12506 12507 int 12508 _bfd_mips_elf_additional_program_headers (bfd *abfd, 12509 struct bfd_link_info *info ATTRIBUTE_UNUSED) 12510 { 12511 asection *s; 12512 int ret = 0; 12513 12514 /* See if we need a PT_MIPS_REGINFO segment. */ 12515 s = bfd_get_section_by_name (abfd, ".reginfo"); 12516 if (s && (s->flags & SEC_LOAD)) 12517 ++ret; 12518 12519 /* See if we need a PT_MIPS_ABIFLAGS segment. */ 12520 if (bfd_get_section_by_name (abfd, ".MIPS.abiflags")) 12521 ++ret; 12522 12523 /* See if we need a PT_MIPS_OPTIONS segment. */ 12524 if (IRIX_COMPAT (abfd) == ict_irix6 12525 && bfd_get_section_by_name (abfd, 12526 MIPS_ELF_OPTIONS_SECTION_NAME (abfd))) 12527 ++ret; 12528 12529 /* See if we need a PT_MIPS_RTPROC segment. */ 12530 if (IRIX_COMPAT (abfd) == ict_irix5 12531 && bfd_get_section_by_name (abfd, ".dynamic") 12532 && bfd_get_section_by_name (abfd, ".mdebug")) 12533 ++ret; 12534 12535 /* Allocate a PT_NULL header in dynamic objects. See 12536 _bfd_mips_elf_modify_segment_map for details. */ 12537 if (!SGI_COMPAT (abfd) 12538 && bfd_get_section_by_name (abfd, ".dynamic")) 12539 ++ret; 12540 12541 return ret; 12542 } 12543 12544 /* Modify the segment map for an IRIX5 executable. */ 12545 12546 bfd_boolean 12547 _bfd_mips_elf_modify_segment_map (bfd *abfd, 12548 struct bfd_link_info *info) 12549 { 12550 asection *s; 12551 struct elf_segment_map *m, **pm; 12552 size_t amt; 12553 12554 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO 12555 segment. */ 12556 s = bfd_get_section_by_name (abfd, ".reginfo"); 12557 if (s != NULL && (s->flags & SEC_LOAD) != 0) 12558 { 12559 for (m = elf_seg_map (abfd); m != NULL; m = m->next) 12560 if (m->p_type == PT_MIPS_REGINFO) 12561 break; 12562 if (m == NULL) 12563 { 12564 amt = sizeof *m; 12565 m = bfd_zalloc (abfd, amt); 12566 if (m == NULL) 12567 return FALSE; 12568 12569 m->p_type = PT_MIPS_REGINFO; 12570 m->count = 1; 12571 m->sections[0] = s; 12572 12573 /* We want to put it after the PHDR and INTERP segments. */ 12574 pm = &elf_seg_map (abfd); 12575 while (*pm != NULL 12576 && ((*pm)->p_type == PT_PHDR 12577 || (*pm)->p_type == PT_INTERP)) 12578 pm = &(*pm)->next; 12579 12580 m->next = *pm; 12581 *pm = m; 12582 } 12583 } 12584 12585 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS 12586 segment. */ 12587 s = bfd_get_section_by_name (abfd, ".MIPS.abiflags"); 12588 if (s != NULL && (s->flags & SEC_LOAD) != 0) 12589 { 12590 for (m = elf_seg_map (abfd); m != NULL; m = m->next) 12591 if (m->p_type == PT_MIPS_ABIFLAGS) 12592 break; 12593 if (m == NULL) 12594 { 12595 amt = sizeof *m; 12596 m = bfd_zalloc (abfd, amt); 12597 if (m == NULL) 12598 return FALSE; 12599 12600 m->p_type = PT_MIPS_ABIFLAGS; 12601 m->count = 1; 12602 m->sections[0] = s; 12603 12604 /* We want to put it after the PHDR and INTERP segments. */ 12605 pm = &elf_seg_map (abfd); 12606 while (*pm != NULL 12607 && ((*pm)->p_type == PT_PHDR 12608 || (*pm)->p_type == PT_INTERP)) 12609 pm = &(*pm)->next; 12610 12611 m->next = *pm; 12612 *pm = m; 12613 } 12614 } 12615 12616 /* For IRIX 6, we don't have .mdebug sections, nor does anything but 12617 .dynamic end up in PT_DYNAMIC. However, we do have to insert a 12618 PT_MIPS_OPTIONS segment immediately following the program header 12619 table. */ 12620 if (NEWABI_P (abfd) 12621 /* On non-IRIX6 new abi, we'll have already created a segment 12622 for this section, so don't create another. I'm not sure this 12623 is not also the case for IRIX 6, but I can't test it right 12624 now. */ 12625 && IRIX_COMPAT (abfd) == ict_irix6) 12626 { 12627 for (s = abfd->sections; s; s = s->next) 12628 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS) 12629 break; 12630 12631 if (s) 12632 { 12633 struct elf_segment_map *options_segment; 12634 12635 pm = &elf_seg_map (abfd); 12636 while (*pm != NULL 12637 && ((*pm)->p_type == PT_PHDR 12638 || (*pm)->p_type == PT_INTERP)) 12639 pm = &(*pm)->next; 12640 12641 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS) 12642 { 12643 amt = sizeof (struct elf_segment_map); 12644 options_segment = bfd_zalloc (abfd, amt); 12645 options_segment->next = *pm; 12646 options_segment->p_type = PT_MIPS_OPTIONS; 12647 options_segment->p_flags = PF_R; 12648 options_segment->p_flags_valid = TRUE; 12649 options_segment->count = 1; 12650 options_segment->sections[0] = s; 12651 *pm = options_segment; 12652 } 12653 } 12654 } 12655 else 12656 { 12657 if (IRIX_COMPAT (abfd) == ict_irix5) 12658 { 12659 /* If there are .dynamic and .mdebug sections, we make a room 12660 for the RTPROC header. FIXME: Rewrite without section names. */ 12661 if (bfd_get_section_by_name (abfd, ".interp") == NULL 12662 && bfd_get_section_by_name (abfd, ".dynamic") != NULL 12663 && bfd_get_section_by_name (abfd, ".mdebug") != NULL) 12664 { 12665 for (m = elf_seg_map (abfd); m != NULL; m = m->next) 12666 if (m->p_type == PT_MIPS_RTPROC) 12667 break; 12668 if (m == NULL) 12669 { 12670 amt = sizeof *m; 12671 m = bfd_zalloc (abfd, amt); 12672 if (m == NULL) 12673 return FALSE; 12674 12675 m->p_type = PT_MIPS_RTPROC; 12676 12677 s = bfd_get_section_by_name (abfd, ".rtproc"); 12678 if (s == NULL) 12679 { 12680 m->count = 0; 12681 m->p_flags = 0; 12682 m->p_flags_valid = 1; 12683 } 12684 else 12685 { 12686 m->count = 1; 12687 m->sections[0] = s; 12688 } 12689 12690 /* We want to put it after the DYNAMIC segment. */ 12691 pm = &elf_seg_map (abfd); 12692 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC) 12693 pm = &(*pm)->next; 12694 if (*pm != NULL) 12695 pm = &(*pm)->next; 12696 12697 m->next = *pm; 12698 *pm = m; 12699 } 12700 } 12701 } 12702 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic, 12703 .dynstr, .dynsym, and .hash sections, and everything in 12704 between. */ 12705 for (pm = &elf_seg_map (abfd); *pm != NULL; 12706 pm = &(*pm)->next) 12707 if ((*pm)->p_type == PT_DYNAMIC) 12708 break; 12709 m = *pm; 12710 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section. 12711 glibc's dynamic linker has traditionally derived the number of 12712 tags from the p_filesz field, and sometimes allocates stack 12713 arrays of that size. An overly-big PT_DYNAMIC segment can 12714 be actively harmful in such cases. Making PT_DYNAMIC contain 12715 other sections can also make life hard for the prelinker, 12716 which might move one of the other sections to a different 12717 PT_LOAD segment. */ 12718 if (SGI_COMPAT (abfd) 12719 && m != NULL 12720 && m->count == 1 12721 && strcmp (m->sections[0]->name, ".dynamic") == 0) 12722 { 12723 static const char *sec_names[] = 12724 { 12725 ".dynamic", ".dynstr", ".dynsym", ".hash" 12726 }; 12727 bfd_vma low, high; 12728 unsigned int i, c; 12729 struct elf_segment_map *n; 12730 12731 low = ~(bfd_vma) 0; 12732 high = 0; 12733 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++) 12734 { 12735 s = bfd_get_section_by_name (abfd, sec_names[i]); 12736 if (s != NULL && (s->flags & SEC_LOAD) != 0) 12737 { 12738 bfd_size_type sz; 12739 12740 if (low > s->vma) 12741 low = s->vma; 12742 sz = s->size; 12743 if (high < s->vma + sz) 12744 high = s->vma + sz; 12745 } 12746 } 12747 12748 c = 0; 12749 for (s = abfd->sections; s != NULL; s = s->next) 12750 if ((s->flags & SEC_LOAD) != 0 12751 && s->vma >= low 12752 && s->vma + s->size <= high) 12753 ++c; 12754 12755 amt = sizeof *n - sizeof (asection *) + c * sizeof (asection *); 12756 n = bfd_zalloc (abfd, amt); 12757 if (n == NULL) 12758 return FALSE; 12759 *n = *m; 12760 n->count = c; 12761 12762 i = 0; 12763 for (s = abfd->sections; s != NULL; s = s->next) 12764 { 12765 if ((s->flags & SEC_LOAD) != 0 12766 && s->vma >= low 12767 && s->vma + s->size <= high) 12768 { 12769 n->sections[i] = s; 12770 ++i; 12771 } 12772 } 12773 12774 *pm = n; 12775 } 12776 } 12777 12778 /* Allocate a spare program header in dynamic objects so that tools 12779 like the prelinker can add an extra PT_LOAD entry. 12780 12781 If the prelinker needs to make room for a new PT_LOAD entry, its 12782 standard procedure is to move the first (read-only) sections into 12783 the new (writable) segment. However, the MIPS ABI requires 12784 .dynamic to be in a read-only segment, and the section will often 12785 start within sizeof (ElfNN_Phdr) bytes of the last program header. 12786 12787 Although the prelinker could in principle move .dynamic to a 12788 writable segment, it seems better to allocate a spare program 12789 header instead, and avoid the need to move any sections. 12790 There is a long tradition of allocating spare dynamic tags, 12791 so allocating a spare program header seems like a natural 12792 extension. 12793 12794 If INFO is NULL, we may be copying an already prelinked binary 12795 with objcopy or strip, so do not add this header. */ 12796 if (info != NULL 12797 && !SGI_COMPAT (abfd) 12798 && bfd_get_section_by_name (abfd, ".dynamic")) 12799 { 12800 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next) 12801 if ((*pm)->p_type == PT_NULL) 12802 break; 12803 if (*pm == NULL) 12804 { 12805 m = bfd_zalloc (abfd, sizeof (*m)); 12806 if (m == NULL) 12807 return FALSE; 12808 12809 m->p_type = PT_NULL; 12810 *pm = m; 12811 } 12812 } 12813 12814 return TRUE; 12815 } 12816 12817 /* Return the section that should be marked against GC for a given 12818 relocation. */ 12819 12820 asection * 12821 _bfd_mips_elf_gc_mark_hook (asection *sec, 12822 struct bfd_link_info *info, 12823 Elf_Internal_Rela *rel, 12824 struct elf_link_hash_entry *h, 12825 Elf_Internal_Sym *sym) 12826 { 12827 /* ??? Do mips16 stub sections need to be handled special? */ 12828 12829 if (h != NULL) 12830 switch (ELF_R_TYPE (sec->owner, rel->r_info)) 12831 { 12832 case R_MIPS_GNU_VTINHERIT: 12833 case R_MIPS_GNU_VTENTRY: 12834 return NULL; 12835 } 12836 12837 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 12838 } 12839 12840 /* Prevent .MIPS.abiflags from being discarded with --gc-sections. */ 12841 12842 bfd_boolean 12843 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info, 12844 elf_gc_mark_hook_fn gc_mark_hook) 12845 { 12846 bfd *sub; 12847 12848 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook); 12849 12850 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 12851 { 12852 asection *o; 12853 12854 if (! is_mips_elf (sub)) 12855 continue; 12856 12857 for (o = sub->sections; o != NULL; o = o->next) 12858 if (!o->gc_mark 12859 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P (bfd_section_name (o))) 12860 { 12861 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook)) 12862 return FALSE; 12863 } 12864 } 12865 12866 return TRUE; 12867 } 12868 12869 /* Copy data from a MIPS ELF indirect symbol to its direct symbol, 12870 hiding the old indirect symbol. Process additional relocation 12871 information. Also called for weakdefs, in which case we just let 12872 _bfd_elf_link_hash_copy_indirect copy the flags for us. */ 12873 12874 void 12875 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info, 12876 struct elf_link_hash_entry *dir, 12877 struct elf_link_hash_entry *ind) 12878 { 12879 struct mips_elf_link_hash_entry *dirmips, *indmips; 12880 12881 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 12882 12883 dirmips = (struct mips_elf_link_hash_entry *) dir; 12884 indmips = (struct mips_elf_link_hash_entry *) ind; 12885 /* Any absolute non-dynamic relocations against an indirect or weak 12886 definition will be against the target symbol. */ 12887 if (indmips->has_static_relocs) 12888 dirmips->has_static_relocs = TRUE; 12889 12890 if (ind->root.type != bfd_link_hash_indirect) 12891 return; 12892 12893 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs; 12894 if (indmips->readonly_reloc) 12895 dirmips->readonly_reloc = TRUE; 12896 if (indmips->no_fn_stub) 12897 dirmips->no_fn_stub = TRUE; 12898 if (indmips->fn_stub) 12899 { 12900 dirmips->fn_stub = indmips->fn_stub; 12901 indmips->fn_stub = NULL; 12902 } 12903 if (indmips->need_fn_stub) 12904 { 12905 dirmips->need_fn_stub = TRUE; 12906 indmips->need_fn_stub = FALSE; 12907 } 12908 if (indmips->call_stub) 12909 { 12910 dirmips->call_stub = indmips->call_stub; 12911 indmips->call_stub = NULL; 12912 } 12913 if (indmips->call_fp_stub) 12914 { 12915 dirmips->call_fp_stub = indmips->call_fp_stub; 12916 indmips->call_fp_stub = NULL; 12917 } 12918 if (indmips->global_got_area < dirmips->global_got_area) 12919 dirmips->global_got_area = indmips->global_got_area; 12920 if (indmips->global_got_area < GGA_NONE) 12921 indmips->global_got_area = GGA_NONE; 12922 if (indmips->has_nonpic_branches) 12923 dirmips->has_nonpic_branches = TRUE; 12924 } 12925 12926 /* Take care of the special `__gnu_absolute_zero' symbol and ignore attempts 12927 to hide it. It has to remain global (it will also be protected) so as to 12928 be assigned a global GOT entry, which will then remain unchanged at load 12929 time. */ 12930 12931 void 12932 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info, 12933 struct elf_link_hash_entry *entry, 12934 bfd_boolean force_local) 12935 { 12936 struct mips_elf_link_hash_table *htab; 12937 12938 htab = mips_elf_hash_table (info); 12939 BFD_ASSERT (htab != NULL); 12940 if (htab->use_absolute_zero 12941 && strcmp (entry->root.root.string, "__gnu_absolute_zero") == 0) 12942 return; 12943 12944 _bfd_elf_link_hash_hide_symbol (info, entry, force_local); 12945 } 12946 12947 #define PDR_SIZE 32 12948 12949 bfd_boolean 12950 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 12951 struct bfd_link_info *info) 12952 { 12953 asection *o; 12954 bfd_boolean ret = FALSE; 12955 unsigned char *tdata; 12956 size_t i, skip; 12957 12958 o = bfd_get_section_by_name (abfd, ".pdr"); 12959 if (! o) 12960 return FALSE; 12961 if (o->size == 0) 12962 return FALSE; 12963 if (o->size % PDR_SIZE != 0) 12964 return FALSE; 12965 if (o->output_section != NULL 12966 && bfd_is_abs_section (o->output_section)) 12967 return FALSE; 12968 12969 tdata = bfd_zmalloc (o->size / PDR_SIZE); 12970 if (! tdata) 12971 return FALSE; 12972 12973 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 12974 info->keep_memory); 12975 if (!cookie->rels) 12976 { 12977 free (tdata); 12978 return FALSE; 12979 } 12980 12981 cookie->rel = cookie->rels; 12982 cookie->relend = cookie->rels + o->reloc_count; 12983 12984 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++) 12985 { 12986 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie)) 12987 { 12988 tdata[i] = 1; 12989 skip ++; 12990 } 12991 } 12992 12993 if (skip != 0) 12994 { 12995 mips_elf_section_data (o)->u.tdata = tdata; 12996 if (o->rawsize == 0) 12997 o->rawsize = o->size; 12998 o->size -= skip * PDR_SIZE; 12999 ret = TRUE; 13000 } 13001 else 13002 free (tdata); 13003 13004 if (! info->keep_memory) 13005 free (cookie->rels); 13006 13007 return ret; 13008 } 13009 13010 bfd_boolean 13011 _bfd_mips_elf_ignore_discarded_relocs (asection *sec) 13012 { 13013 if (strcmp (sec->name, ".pdr") == 0) 13014 return TRUE; 13015 return FALSE; 13016 } 13017 13018 bfd_boolean 13019 _bfd_mips_elf_write_section (bfd *output_bfd, 13020 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 13021 asection *sec, bfd_byte *contents) 13022 { 13023 bfd_byte *to, *from, *end; 13024 int i; 13025 13026 if (strcmp (sec->name, ".pdr") != 0) 13027 return FALSE; 13028 13029 if (mips_elf_section_data (sec)->u.tdata == NULL) 13030 return FALSE; 13031 13032 to = contents; 13033 end = contents + sec->size; 13034 for (from = contents, i = 0; 13035 from < end; 13036 from += PDR_SIZE, i++) 13037 { 13038 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1) 13039 continue; 13040 if (to != from) 13041 memcpy (to, from, PDR_SIZE); 13042 to += PDR_SIZE; 13043 } 13044 bfd_set_section_contents (output_bfd, sec->output_section, contents, 13045 sec->output_offset, sec->size); 13046 return TRUE; 13047 } 13048 13049 /* microMIPS code retains local labels for linker relaxation. Omit them 13050 from output by default for clarity. */ 13051 13052 bfd_boolean 13053 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym) 13054 { 13055 return _bfd_elf_is_local_label_name (abfd, sym->name); 13056 } 13057 13058 /* MIPS ELF uses a special find_nearest_line routine in order the 13059 handle the ECOFF debugging information. */ 13060 13061 struct mips_elf_find_line 13062 { 13063 struct ecoff_debug_info d; 13064 struct ecoff_find_line i; 13065 }; 13066 13067 bfd_boolean 13068 _bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols, 13069 asection *section, bfd_vma offset, 13070 const char **filename_ptr, 13071 const char **functionname_ptr, 13072 unsigned int *line_ptr, 13073 unsigned int *discriminator_ptr) 13074 { 13075 asection *msec; 13076 13077 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset, 13078 filename_ptr, functionname_ptr, 13079 line_ptr, discriminator_ptr, 13080 dwarf_debug_sections, 13081 &elf_tdata (abfd)->dwarf2_find_line_info) 13082 == 1) 13083 return TRUE; 13084 13085 if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset, 13086 filename_ptr, functionname_ptr, 13087 line_ptr)) 13088 { 13089 if (!*functionname_ptr) 13090 _bfd_elf_find_function (abfd, symbols, section, offset, 13091 *filename_ptr ? NULL : filename_ptr, 13092 functionname_ptr); 13093 return TRUE; 13094 } 13095 13096 msec = bfd_get_section_by_name (abfd, ".mdebug"); 13097 if (msec != NULL) 13098 { 13099 flagword origflags; 13100 struct mips_elf_find_line *fi; 13101 const struct ecoff_debug_swap * const swap = 13102 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 13103 13104 /* If we are called during a link, mips_elf_final_link may have 13105 cleared the SEC_HAS_CONTENTS field. We force it back on here 13106 if appropriate (which it normally will be). */ 13107 origflags = msec->flags; 13108 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS) 13109 msec->flags |= SEC_HAS_CONTENTS; 13110 13111 fi = mips_elf_tdata (abfd)->find_line_info; 13112 if (fi == NULL) 13113 { 13114 bfd_size_type external_fdr_size; 13115 char *fraw_src; 13116 char *fraw_end; 13117 struct fdr *fdr_ptr; 13118 bfd_size_type amt = sizeof (struct mips_elf_find_line); 13119 13120 fi = bfd_zalloc (abfd, amt); 13121 if (fi == NULL) 13122 { 13123 msec->flags = origflags; 13124 return FALSE; 13125 } 13126 13127 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d)) 13128 { 13129 msec->flags = origflags; 13130 return FALSE; 13131 } 13132 13133 /* Swap in the FDR information. */ 13134 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr); 13135 fi->d.fdr = bfd_alloc (abfd, amt); 13136 if (fi->d.fdr == NULL) 13137 { 13138 msec->flags = origflags; 13139 return FALSE; 13140 } 13141 external_fdr_size = swap->external_fdr_size; 13142 fdr_ptr = fi->d.fdr; 13143 fraw_src = (char *) fi->d.external_fdr; 13144 fraw_end = (fraw_src 13145 + fi->d.symbolic_header.ifdMax * external_fdr_size); 13146 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) 13147 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr); 13148 13149 mips_elf_tdata (abfd)->find_line_info = fi; 13150 13151 /* Note that we don't bother to ever free this information. 13152 find_nearest_line is either called all the time, as in 13153 objdump -l, so the information should be saved, or it is 13154 rarely called, as in ld error messages, so the memory 13155 wasted is unimportant. Still, it would probably be a 13156 good idea for free_cached_info to throw it away. */ 13157 } 13158 13159 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap, 13160 &fi->i, filename_ptr, functionname_ptr, 13161 line_ptr)) 13162 { 13163 msec->flags = origflags; 13164 return TRUE; 13165 } 13166 13167 msec->flags = origflags; 13168 } 13169 13170 /* Fall back on the generic ELF find_nearest_line routine. */ 13171 13172 return _bfd_elf_find_nearest_line (abfd, symbols, section, offset, 13173 filename_ptr, functionname_ptr, 13174 line_ptr, discriminator_ptr); 13175 } 13176 13177 bfd_boolean 13178 _bfd_mips_elf_find_inliner_info (bfd *abfd, 13179 const char **filename_ptr, 13180 const char **functionname_ptr, 13181 unsigned int *line_ptr) 13182 { 13183 bfd_boolean found; 13184 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 13185 functionname_ptr, line_ptr, 13186 & elf_tdata (abfd)->dwarf2_find_line_info); 13187 return found; 13188 } 13189 13190 13191 /* When are writing out the .options or .MIPS.options section, 13192 remember the bytes we are writing out, so that we can install the 13193 GP value in the section_processing routine. */ 13194 13195 bfd_boolean 13196 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section, 13197 const void *location, 13198 file_ptr offset, bfd_size_type count) 13199 { 13200 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name)) 13201 { 13202 bfd_byte *c; 13203 13204 if (elf_section_data (section) == NULL) 13205 { 13206 size_t amt = sizeof (struct bfd_elf_section_data); 13207 section->used_by_bfd = bfd_zalloc (abfd, amt); 13208 if (elf_section_data (section) == NULL) 13209 return FALSE; 13210 } 13211 c = mips_elf_section_data (section)->u.tdata; 13212 if (c == NULL) 13213 { 13214 c = bfd_zalloc (abfd, section->size); 13215 if (c == NULL) 13216 return FALSE; 13217 mips_elf_section_data (section)->u.tdata = c; 13218 } 13219 13220 memcpy (c + offset, location, count); 13221 } 13222 13223 return _bfd_elf_set_section_contents (abfd, section, location, offset, 13224 count); 13225 } 13226 13227 /* This is almost identical to bfd_generic_get_... except that some 13228 MIPS relocations need to be handled specially. Sigh. */ 13229 13230 bfd_byte * 13231 _bfd_elf_mips_get_relocated_section_contents 13232 (bfd *abfd, 13233 struct bfd_link_info *link_info, 13234 struct bfd_link_order *link_order, 13235 bfd_byte *data, 13236 bfd_boolean relocatable, 13237 asymbol **symbols) 13238 { 13239 /* Get enough memory to hold the stuff */ 13240 bfd *input_bfd = link_order->u.indirect.section->owner; 13241 asection *input_section = link_order->u.indirect.section; 13242 bfd_size_type sz; 13243 13244 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 13245 arelent **reloc_vector = NULL; 13246 long reloc_count; 13247 13248 if (reloc_size < 0) 13249 goto error_return; 13250 13251 reloc_vector = bfd_malloc (reloc_size); 13252 if (reloc_vector == NULL && reloc_size != 0) 13253 goto error_return; 13254 13255 /* read in the section */ 13256 sz = input_section->rawsize ? input_section->rawsize : input_section->size; 13257 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz)) 13258 goto error_return; 13259 13260 reloc_count = bfd_canonicalize_reloc (input_bfd, 13261 input_section, 13262 reloc_vector, 13263 symbols); 13264 if (reloc_count < 0) 13265 goto error_return; 13266 13267 if (reloc_count > 0) 13268 { 13269 arelent **parent; 13270 /* for mips */ 13271 int gp_found; 13272 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */ 13273 13274 { 13275 struct bfd_hash_entry *h; 13276 struct bfd_link_hash_entry *lh; 13277 /* Skip all this stuff if we aren't mixing formats. */ 13278 if (abfd && input_bfd 13279 && abfd->xvec == input_bfd->xvec) 13280 lh = 0; 13281 else 13282 { 13283 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE); 13284 lh = (struct bfd_link_hash_entry *) h; 13285 } 13286 lookup: 13287 if (lh) 13288 { 13289 switch (lh->type) 13290 { 13291 case bfd_link_hash_undefined: 13292 case bfd_link_hash_undefweak: 13293 case bfd_link_hash_common: 13294 gp_found = 0; 13295 break; 13296 case bfd_link_hash_defined: 13297 case bfd_link_hash_defweak: 13298 gp_found = 1; 13299 gp = lh->u.def.value; 13300 break; 13301 case bfd_link_hash_indirect: 13302 case bfd_link_hash_warning: 13303 lh = lh->u.i.link; 13304 /* @@FIXME ignoring warning for now */ 13305 goto lookup; 13306 case bfd_link_hash_new: 13307 default: 13308 abort (); 13309 } 13310 } 13311 else 13312 gp_found = 0; 13313 } 13314 /* end mips */ 13315 for (parent = reloc_vector; *parent != NULL; parent++) 13316 { 13317 char *error_message = NULL; 13318 bfd_reloc_status_type r; 13319 13320 /* Specific to MIPS: Deal with relocation types that require 13321 knowing the gp of the output bfd. */ 13322 asymbol *sym = *(*parent)->sym_ptr_ptr; 13323 13324 /* If we've managed to find the gp and have a special 13325 function for the relocation then go ahead, else default 13326 to the generic handling. */ 13327 if (gp_found 13328 && (*parent)->howto->special_function 13329 == _bfd_mips_elf32_gprel16_reloc) 13330 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent, 13331 input_section, relocatable, 13332 data, gp); 13333 else 13334 r = bfd_perform_relocation (input_bfd, *parent, data, 13335 input_section, 13336 relocatable ? abfd : NULL, 13337 &error_message); 13338 13339 if (relocatable) 13340 { 13341 asection *os = input_section->output_section; 13342 13343 /* A partial link, so keep the relocs */ 13344 os->orelocation[os->reloc_count] = *parent; 13345 os->reloc_count++; 13346 } 13347 13348 if (r != bfd_reloc_ok) 13349 { 13350 switch (r) 13351 { 13352 case bfd_reloc_undefined: 13353 (*link_info->callbacks->undefined_symbol) 13354 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 13355 input_bfd, input_section, (*parent)->address, TRUE); 13356 break; 13357 case bfd_reloc_dangerous: 13358 BFD_ASSERT (error_message != NULL); 13359 (*link_info->callbacks->reloc_dangerous) 13360 (link_info, error_message, 13361 input_bfd, input_section, (*parent)->address); 13362 break; 13363 case bfd_reloc_overflow: 13364 (*link_info->callbacks->reloc_overflow) 13365 (link_info, NULL, 13366 bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 13367 (*parent)->howto->name, (*parent)->addend, 13368 input_bfd, input_section, (*parent)->address); 13369 break; 13370 case bfd_reloc_outofrange: 13371 default: 13372 abort (); 13373 break; 13374 } 13375 13376 } 13377 } 13378 } 13379 free (reloc_vector); 13380 return data; 13381 13382 error_return: 13383 free (reloc_vector); 13384 return NULL; 13385 } 13386 13387 static bfd_boolean 13388 mips_elf_relax_delete_bytes (bfd *abfd, 13389 asection *sec, bfd_vma addr, int count) 13390 { 13391 Elf_Internal_Shdr *symtab_hdr; 13392 unsigned int sec_shndx; 13393 bfd_byte *contents; 13394 Elf_Internal_Rela *irel, *irelend; 13395 Elf_Internal_Sym *isym; 13396 Elf_Internal_Sym *isymend; 13397 struct elf_link_hash_entry **sym_hashes; 13398 struct elf_link_hash_entry **end_hashes; 13399 struct elf_link_hash_entry **start_hashes; 13400 unsigned int symcount; 13401 13402 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 13403 contents = elf_section_data (sec)->this_hdr.contents; 13404 13405 irel = elf_section_data (sec)->relocs; 13406 irelend = irel + sec->reloc_count; 13407 13408 /* Actually delete the bytes. */ 13409 memmove (contents + addr, contents + addr + count, 13410 (size_t) (sec->size - addr - count)); 13411 sec->size -= count; 13412 13413 /* Adjust all the relocs. */ 13414 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 13415 { 13416 /* Get the new reloc address. */ 13417 if (irel->r_offset > addr) 13418 irel->r_offset -= count; 13419 } 13420 13421 BFD_ASSERT (addr % 2 == 0); 13422 BFD_ASSERT (count % 2 == 0); 13423 13424 /* Adjust the local symbols defined in this section. */ 13425 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 13426 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 13427 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 13428 if (isym->st_shndx == sec_shndx && isym->st_value > addr) 13429 isym->st_value -= count; 13430 13431 /* Now adjust the global symbols defined in this section. */ 13432 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 13433 - symtab_hdr->sh_info); 13434 sym_hashes = start_hashes = elf_sym_hashes (abfd); 13435 end_hashes = sym_hashes + symcount; 13436 13437 for (; sym_hashes < end_hashes; sym_hashes++) 13438 { 13439 struct elf_link_hash_entry *sym_hash = *sym_hashes; 13440 13441 if ((sym_hash->root.type == bfd_link_hash_defined 13442 || sym_hash->root.type == bfd_link_hash_defweak) 13443 && sym_hash->root.u.def.section == sec) 13444 { 13445 bfd_vma value = sym_hash->root.u.def.value; 13446 13447 if (ELF_ST_IS_MICROMIPS (sym_hash->other)) 13448 value &= MINUS_TWO; 13449 if (value > addr) 13450 sym_hash->root.u.def.value -= count; 13451 } 13452 } 13453 13454 return TRUE; 13455 } 13456 13457 13458 /* Opcodes needed for microMIPS relaxation as found in 13459 opcodes/micromips-opc.c. */ 13460 13461 struct opcode_descriptor { 13462 unsigned long match; 13463 unsigned long mask; 13464 }; 13465 13466 /* The $ra register aka $31. */ 13467 13468 #define RA 31 13469 13470 /* 32-bit instruction format register fields. */ 13471 13472 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f) 13473 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f) 13474 13475 /* Check if a 5-bit register index can be abbreviated to 3 bits. */ 13476 13477 #define OP16_VALID_REG(r) \ 13478 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17)) 13479 13480 13481 /* 32-bit and 16-bit branches. */ 13482 13483 static const struct opcode_descriptor b_insns_32[] = { 13484 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */ 13485 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */ 13486 { 0, 0 } /* End marker for find_match(). */ 13487 }; 13488 13489 static const struct opcode_descriptor bc_insn_32 = 13490 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 }; 13491 13492 static const struct opcode_descriptor bz_insn_32 = 13493 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 }; 13494 13495 static const struct opcode_descriptor bzal_insn_32 = 13496 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 }; 13497 13498 static const struct opcode_descriptor beq_insn_32 = 13499 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 }; 13500 13501 static const struct opcode_descriptor b_insn_16 = 13502 { /* "b", "mD", */ 0xcc00, 0xfc00 }; 13503 13504 static const struct opcode_descriptor bz_insn_16 = 13505 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 }; 13506 13507 13508 /* 32-bit and 16-bit branch EQ and NE zero. */ 13509 13510 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the 13511 eq and second the ne. This convention is used when replacing a 13512 32-bit BEQ/BNE with the 16-bit version. */ 13513 13514 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16) 13515 13516 static const struct opcode_descriptor bz_rs_insns_32[] = { 13517 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 }, 13518 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 }, 13519 { 0, 0 } /* End marker for find_match(). */ 13520 }; 13521 13522 static const struct opcode_descriptor bz_rt_insns_32[] = { 13523 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 }, 13524 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 }, 13525 { 0, 0 } /* End marker for find_match(). */ 13526 }; 13527 13528 static const struct opcode_descriptor bzc_insns_32[] = { 13529 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 }, 13530 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 }, 13531 { 0, 0 } /* End marker for find_match(). */ 13532 }; 13533 13534 static const struct opcode_descriptor bz_insns_16[] = { 13535 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 }, 13536 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 }, 13537 { 0, 0 } /* End marker for find_match(). */ 13538 }; 13539 13540 /* Switch between a 5-bit register index and its 3-bit shorthand. */ 13541 13542 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2) 13543 #define BZ16_REG_FIELD(r) (((r) & 7) << 7) 13544 13545 13546 /* 32-bit instructions with a delay slot. */ 13547 13548 static const struct opcode_descriptor jal_insn_32_bd16 = 13549 { /* "jals", "a", */ 0x74000000, 0xfc000000 }; 13550 13551 static const struct opcode_descriptor jal_insn_32_bd32 = 13552 { /* "jal", "a", */ 0xf4000000, 0xfc000000 }; 13553 13554 static const struct opcode_descriptor jal_x_insn_32_bd32 = 13555 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 }; 13556 13557 static const struct opcode_descriptor j_insn_32 = 13558 { /* "j", "a", */ 0xd4000000, 0xfc000000 }; 13559 13560 static const struct opcode_descriptor jalr_insn_32 = 13561 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff }; 13562 13563 /* This table can be compacted, because no opcode replacement is made. */ 13564 13565 static const struct opcode_descriptor ds_insns_32_bd16[] = { 13566 { /* "jals", "a", */ 0x74000000, 0xfc000000 }, 13567 13568 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff }, 13569 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 }, 13570 13571 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 }, 13572 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 }, 13573 { /* "j", "a", */ 0xd4000000, 0xfc000000 }, 13574 { 0, 0 } /* End marker for find_match(). */ 13575 }; 13576 13577 /* This table can be compacted, because no opcode replacement is made. */ 13578 13579 static const struct opcode_descriptor ds_insns_32_bd32[] = { 13580 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 }, 13581 13582 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff }, 13583 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 }, 13584 { 0, 0 } /* End marker for find_match(). */ 13585 }; 13586 13587 13588 /* 16-bit instructions with a delay slot. */ 13589 13590 static const struct opcode_descriptor jalr_insn_16_bd16 = 13591 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 }; 13592 13593 static const struct opcode_descriptor jalr_insn_16_bd32 = 13594 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 }; 13595 13596 static const struct opcode_descriptor jr_insn_16 = 13597 { /* "jr", "mj", */ 0x4580, 0xffe0 }; 13598 13599 #define JR16_REG(opcode) ((opcode) & 0x1f) 13600 13601 /* This table can be compacted, because no opcode replacement is made. */ 13602 13603 static const struct opcode_descriptor ds_insns_16_bd16[] = { 13604 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 }, 13605 13606 { /* "b", "mD", */ 0xcc00, 0xfc00 }, 13607 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 }, 13608 { /* "jr", "mj", */ 0x4580, 0xffe0 }, 13609 { 0, 0 } /* End marker for find_match(). */ 13610 }; 13611 13612 13613 /* LUI instruction. */ 13614 13615 static const struct opcode_descriptor lui_insn = 13616 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 }; 13617 13618 13619 /* ADDIU instruction. */ 13620 13621 static const struct opcode_descriptor addiu_insn = 13622 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 }; 13623 13624 static const struct opcode_descriptor addiupc_insn = 13625 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 }; 13626 13627 #define ADDIUPC_REG_FIELD(r) \ 13628 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23) 13629 13630 13631 /* Relaxable instructions in a JAL delay slot: MOVE. */ 13632 13633 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves 13634 (ADDU, OR) have rd in 15:11 and rs in 10:16. */ 13635 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f) 13636 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f) 13637 13638 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5) 13639 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) ) 13640 13641 static const struct opcode_descriptor move_insns_32[] = { 13642 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */ 13643 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */ 13644 { 0, 0 } /* End marker for find_match(). */ 13645 }; 13646 13647 static const struct opcode_descriptor move_insn_16 = 13648 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 }; 13649 13650 13651 /* NOP instructions. */ 13652 13653 static const struct opcode_descriptor nop_insn_32 = 13654 { /* "nop", "", */ 0x00000000, 0xffffffff }; 13655 13656 static const struct opcode_descriptor nop_insn_16 = 13657 { /* "nop", "", */ 0x0c00, 0xffff }; 13658 13659 13660 /* Instruction match support. */ 13661 13662 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match) 13663 13664 static int 13665 find_match (unsigned long opcode, const struct opcode_descriptor insn[]) 13666 { 13667 unsigned long indx; 13668 13669 for (indx = 0; insn[indx].mask != 0; indx++) 13670 if (MATCH (opcode, insn[indx])) 13671 return indx; 13672 13673 return -1; 13674 } 13675 13676 13677 /* Branch and delay slot decoding support. */ 13678 13679 /* If PTR points to what *might* be a 16-bit branch or jump, then 13680 return the minimum length of its delay slot, otherwise return 0. 13681 Non-zero results are not definitive as we might be checking against 13682 the second half of another instruction. */ 13683 13684 static int 13685 check_br16_dslot (bfd *abfd, bfd_byte *ptr) 13686 { 13687 unsigned long opcode; 13688 int bdsize; 13689 13690 opcode = bfd_get_16 (abfd, ptr); 13691 if (MATCH (opcode, jalr_insn_16_bd32) != 0) 13692 /* 16-bit branch/jump with a 32-bit delay slot. */ 13693 bdsize = 4; 13694 else if (MATCH (opcode, jalr_insn_16_bd16) != 0 13695 || find_match (opcode, ds_insns_16_bd16) >= 0) 13696 /* 16-bit branch/jump with a 16-bit delay slot. */ 13697 bdsize = 2; 13698 else 13699 /* No delay slot. */ 13700 bdsize = 0; 13701 13702 return bdsize; 13703 } 13704 13705 /* If PTR points to what *might* be a 32-bit branch or jump, then 13706 return the minimum length of its delay slot, otherwise return 0. 13707 Non-zero results are not definitive as we might be checking against 13708 the second half of another instruction. */ 13709 13710 static int 13711 check_br32_dslot (bfd *abfd, bfd_byte *ptr) 13712 { 13713 unsigned long opcode; 13714 int bdsize; 13715 13716 opcode = bfd_get_micromips_32 (abfd, ptr); 13717 if (find_match (opcode, ds_insns_32_bd32) >= 0) 13718 /* 32-bit branch/jump with a 32-bit delay slot. */ 13719 bdsize = 4; 13720 else if (find_match (opcode, ds_insns_32_bd16) >= 0) 13721 /* 32-bit branch/jump with a 16-bit delay slot. */ 13722 bdsize = 2; 13723 else 13724 /* No delay slot. */ 13725 bdsize = 0; 13726 13727 return bdsize; 13728 } 13729 13730 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot 13731 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */ 13732 13733 static bfd_boolean 13734 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg) 13735 { 13736 unsigned long opcode; 13737 13738 opcode = bfd_get_16 (abfd, ptr); 13739 if (MATCH (opcode, b_insn_16) 13740 /* B16 */ 13741 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode)) 13742 /* JR16 */ 13743 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode)) 13744 /* BEQZ16, BNEZ16 */ 13745 || (MATCH (opcode, jalr_insn_16_bd32) 13746 /* JALR16 */ 13747 && reg != JR16_REG (opcode) && reg != RA)) 13748 return TRUE; 13749 13750 return FALSE; 13751 } 13752 13753 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG, 13754 then return TRUE, otherwise FALSE. */ 13755 13756 static bfd_boolean 13757 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg) 13758 { 13759 unsigned long opcode; 13760 13761 opcode = bfd_get_micromips_32 (abfd, ptr); 13762 if (MATCH (opcode, j_insn_32) 13763 /* J */ 13764 || MATCH (opcode, bc_insn_32) 13765 /* BC1F, BC1T, BC2F, BC2T */ 13766 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA) 13767 /* JAL, JALX */ 13768 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode)) 13769 /* BGEZ, BGTZ, BLEZ, BLTZ */ 13770 || (MATCH (opcode, bzal_insn_32) 13771 /* BGEZAL, BLTZAL */ 13772 && reg != OP32_SREG (opcode) && reg != RA) 13773 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32)) 13774 /* JALR, JALR.HB, BEQ, BNE */ 13775 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode))) 13776 return TRUE; 13777 13778 return FALSE; 13779 } 13780 13781 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS, 13782 IRELEND) at OFFSET indicate that there must be a compact branch there, 13783 then return TRUE, otherwise FALSE. */ 13784 13785 static bfd_boolean 13786 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset, 13787 const Elf_Internal_Rela *internal_relocs, 13788 const Elf_Internal_Rela *irelend) 13789 { 13790 const Elf_Internal_Rela *irel; 13791 unsigned long opcode; 13792 13793 opcode = bfd_get_micromips_32 (abfd, ptr); 13794 if (find_match (opcode, bzc_insns_32) < 0) 13795 return FALSE; 13796 13797 for (irel = internal_relocs; irel < irelend; irel++) 13798 if (irel->r_offset == offset 13799 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1) 13800 return TRUE; 13801 13802 return FALSE; 13803 } 13804 13805 /* Bitsize checking. */ 13806 #define IS_BITSIZE(val, N) \ 13807 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \ 13808 - (1ULL << ((N) - 1))) == (val)) 13809 13810 13811 bfd_boolean 13812 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec, 13813 struct bfd_link_info *link_info, 13814 bfd_boolean *again) 13815 { 13816 bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32; 13817 Elf_Internal_Shdr *symtab_hdr; 13818 Elf_Internal_Rela *internal_relocs; 13819 Elf_Internal_Rela *irel, *irelend; 13820 bfd_byte *contents = NULL; 13821 Elf_Internal_Sym *isymbuf = NULL; 13822 13823 /* Assume nothing changes. */ 13824 *again = FALSE; 13825 13826 /* We don't have to do anything for a relocatable link, if 13827 this section does not have relocs, or if this is not a 13828 code section. */ 13829 13830 if (bfd_link_relocatable (link_info) 13831 || (sec->flags & SEC_RELOC) == 0 13832 || sec->reloc_count == 0 13833 || (sec->flags & SEC_CODE) == 0) 13834 return TRUE; 13835 13836 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 13837 13838 /* Get a copy of the native relocations. */ 13839 internal_relocs = (_bfd_elf_link_read_relocs 13840 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 13841 link_info->keep_memory)); 13842 if (internal_relocs == NULL) 13843 goto error_return; 13844 13845 /* Walk through them looking for relaxing opportunities. */ 13846 irelend = internal_relocs + sec->reloc_count; 13847 for (irel = internal_relocs; irel < irelend; irel++) 13848 { 13849 unsigned long r_symndx = ELF32_R_SYM (irel->r_info); 13850 unsigned int r_type = ELF32_R_TYPE (irel->r_info); 13851 bfd_boolean target_is_micromips_code_p; 13852 unsigned long opcode; 13853 bfd_vma symval; 13854 bfd_vma pcrval; 13855 bfd_byte *ptr; 13856 int fndopc; 13857 13858 /* The number of bytes to delete for relaxation and from where 13859 to delete these bytes starting at irel->r_offset. */ 13860 int delcnt = 0; 13861 int deloff = 0; 13862 13863 /* If this isn't something that can be relaxed, then ignore 13864 this reloc. */ 13865 if (r_type != R_MICROMIPS_HI16 13866 && r_type != R_MICROMIPS_PC16_S1 13867 && r_type != R_MICROMIPS_26_S1) 13868 continue; 13869 13870 /* Get the section contents if we haven't done so already. */ 13871 if (contents == NULL) 13872 { 13873 /* Get cached copy if it exists. */ 13874 if (elf_section_data (sec)->this_hdr.contents != NULL) 13875 contents = elf_section_data (sec)->this_hdr.contents; 13876 /* Go get them off disk. */ 13877 else if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 13878 goto error_return; 13879 } 13880 ptr = contents + irel->r_offset; 13881 13882 /* Read this BFD's local symbols if we haven't done so already. */ 13883 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 13884 { 13885 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 13886 if (isymbuf == NULL) 13887 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 13888 symtab_hdr->sh_info, 0, 13889 NULL, NULL, NULL); 13890 if (isymbuf == NULL) 13891 goto error_return; 13892 } 13893 13894 /* Get the value of the symbol referred to by the reloc. */ 13895 if (r_symndx < symtab_hdr->sh_info) 13896 { 13897 /* A local symbol. */ 13898 Elf_Internal_Sym *isym; 13899 asection *sym_sec; 13900 13901 isym = isymbuf + r_symndx; 13902 if (isym->st_shndx == SHN_UNDEF) 13903 sym_sec = bfd_und_section_ptr; 13904 else if (isym->st_shndx == SHN_ABS) 13905 sym_sec = bfd_abs_section_ptr; 13906 else if (isym->st_shndx == SHN_COMMON) 13907 sym_sec = bfd_com_section_ptr; 13908 else 13909 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 13910 symval = (isym->st_value 13911 + sym_sec->output_section->vma 13912 + sym_sec->output_offset); 13913 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other); 13914 } 13915 else 13916 { 13917 unsigned long indx; 13918 struct elf_link_hash_entry *h; 13919 13920 /* An external symbol. */ 13921 indx = r_symndx - symtab_hdr->sh_info; 13922 h = elf_sym_hashes (abfd)[indx]; 13923 BFD_ASSERT (h != NULL); 13924 13925 if (h->root.type != bfd_link_hash_defined 13926 && h->root.type != bfd_link_hash_defweak) 13927 /* This appears to be a reference to an undefined 13928 symbol. Just ignore it -- it will be caught by the 13929 regular reloc processing. */ 13930 continue; 13931 13932 symval = (h->root.u.def.value 13933 + h->root.u.def.section->output_section->vma 13934 + h->root.u.def.section->output_offset); 13935 target_is_micromips_code_p = (!h->needs_plt 13936 && ELF_ST_IS_MICROMIPS (h->other)); 13937 } 13938 13939 13940 /* For simplicity of coding, we are going to modify the 13941 section contents, the section relocs, and the BFD symbol 13942 table. We must tell the rest of the code not to free up this 13943 information. It would be possible to instead create a table 13944 of changes which have to be made, as is done in coff-mips.c; 13945 that would be more work, but would require less memory when 13946 the linker is run. */ 13947 13948 /* Only 32-bit instructions relaxed. */ 13949 if (irel->r_offset + 4 > sec->size) 13950 continue; 13951 13952 opcode = bfd_get_micromips_32 (abfd, ptr); 13953 13954 /* This is the pc-relative distance from the instruction the 13955 relocation is applied to, to the symbol referred. */ 13956 pcrval = (symval 13957 - (sec->output_section->vma + sec->output_offset) 13958 - irel->r_offset); 13959 13960 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation 13961 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or 13962 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is 13963 13964 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25)) 13965 13966 where pcrval has first to be adjusted to apply against the LO16 13967 location (we make the adjustment later on, when we have figured 13968 out the offset). */ 13969 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn)) 13970 { 13971 bfd_boolean bzc = FALSE; 13972 unsigned long nextopc; 13973 unsigned long reg; 13974 bfd_vma offset; 13975 13976 /* Give up if the previous reloc was a HI16 against this symbol 13977 too. */ 13978 if (irel > internal_relocs 13979 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16 13980 && ELF32_R_SYM (irel[-1].r_info) == r_symndx) 13981 continue; 13982 13983 /* Or if the next reloc is not a LO16 against this symbol. */ 13984 if (irel + 1 >= irelend 13985 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16 13986 || ELF32_R_SYM (irel[1].r_info) != r_symndx) 13987 continue; 13988 13989 /* Or if the second next reloc is a LO16 against this symbol too. */ 13990 if (irel + 2 >= irelend 13991 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16 13992 && ELF32_R_SYM (irel[2].r_info) == r_symndx) 13993 continue; 13994 13995 /* See if the LUI instruction *might* be in a branch delay slot. 13996 We check whether what looks like a 16-bit branch or jump is 13997 actually an immediate argument to a compact branch, and let 13998 it through if so. */ 13999 if (irel->r_offset >= 2 14000 && check_br16_dslot (abfd, ptr - 2) 14001 && !(irel->r_offset >= 4 14002 && (bzc = check_relocated_bzc (abfd, 14003 ptr - 4, irel->r_offset - 4, 14004 internal_relocs, irelend)))) 14005 continue; 14006 if (irel->r_offset >= 4 14007 && !bzc 14008 && check_br32_dslot (abfd, ptr - 4)) 14009 continue; 14010 14011 reg = OP32_SREG (opcode); 14012 14013 /* We only relax adjacent instructions or ones separated with 14014 a branch or jump that has a delay slot. The branch or jump 14015 must not fiddle with the register used to hold the address. 14016 Subtract 4 for the LUI itself. */ 14017 offset = irel[1].r_offset - irel[0].r_offset; 14018 switch (offset - 4) 14019 { 14020 case 0: 14021 break; 14022 case 2: 14023 if (check_br16 (abfd, ptr + 4, reg)) 14024 break; 14025 continue; 14026 case 4: 14027 if (check_br32 (abfd, ptr + 4, reg)) 14028 break; 14029 continue; 14030 default: 14031 continue; 14032 } 14033 14034 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset); 14035 14036 /* Give up unless the same register is used with both 14037 relocations. */ 14038 if (OP32_SREG (nextopc) != reg) 14039 continue; 14040 14041 /* Now adjust pcrval, subtracting the offset to the LO16 reloc 14042 and rounding up to take masking of the two LSBs into account. */ 14043 pcrval = ((pcrval - offset + 3) | 3) ^ 3; 14044 14045 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */ 14046 if (IS_BITSIZE (symval, 16)) 14047 { 14048 /* Fix the relocation's type. */ 14049 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16); 14050 14051 /* Instructions using R_MICROMIPS_LO16 have the base or 14052 source register in bits 20:16. This register becomes $0 14053 (zero) as the result of the R_MICROMIPS_HI16 being 0. */ 14054 nextopc &= ~0x001f0000; 14055 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff, 14056 contents + irel[1].r_offset); 14057 } 14058 14059 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2. 14060 We add 4 to take LUI deletion into account while checking 14061 the PC-relative distance. */ 14062 else if (symval % 4 == 0 14063 && IS_BITSIZE (pcrval + 4, 25) 14064 && MATCH (nextopc, addiu_insn) 14065 && OP32_TREG (nextopc) == OP32_SREG (nextopc) 14066 && OP16_VALID_REG (OP32_TREG (nextopc))) 14067 { 14068 /* Fix the relocation's type. */ 14069 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2); 14070 14071 /* Replace ADDIU with the ADDIUPC version. */ 14072 nextopc = (addiupc_insn.match 14073 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc))); 14074 14075 bfd_put_micromips_32 (abfd, nextopc, 14076 contents + irel[1].r_offset); 14077 } 14078 14079 /* Can't do anything, give up, sigh... */ 14080 else 14081 continue; 14082 14083 /* Fix the relocation's type. */ 14084 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE); 14085 14086 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */ 14087 delcnt = 4; 14088 deloff = 0; 14089 } 14090 14091 /* Compact branch relaxation -- due to the multitude of macros 14092 employed by the compiler/assembler, compact branches are not 14093 always generated. Obviously, this can/will be fixed elsewhere, 14094 but there is no drawback in double checking it here. */ 14095 else if (r_type == R_MICROMIPS_PC16_S1 14096 && irel->r_offset + 5 < sec->size 14097 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0 14098 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0) 14099 && ((!insn32 14100 && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4), 14101 nop_insn_16) ? 2 : 0)) 14102 || (irel->r_offset + 7 < sec->size 14103 && (delcnt = MATCH (bfd_get_micromips_32 (abfd, 14104 ptr + 4), 14105 nop_insn_32) ? 4 : 0)))) 14106 { 14107 unsigned long reg; 14108 14109 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode); 14110 14111 /* Replace BEQZ/BNEZ with the compact version. */ 14112 opcode = (bzc_insns_32[fndopc].match 14113 | BZC32_REG_FIELD (reg) 14114 | (opcode & 0xffff)); /* Addend value. */ 14115 14116 bfd_put_micromips_32 (abfd, opcode, ptr); 14117 14118 /* Delete the delay slot NOP: two or four bytes from 14119 irel->offset + 4; delcnt has already been set above. */ 14120 deloff = 4; 14121 } 14122 14123 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need 14124 to check the distance from the next instruction, so subtract 2. */ 14125 else if (!insn32 14126 && r_type == R_MICROMIPS_PC16_S1 14127 && IS_BITSIZE (pcrval - 2, 11) 14128 && find_match (opcode, b_insns_32) >= 0) 14129 { 14130 /* Fix the relocation's type. */ 14131 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1); 14132 14133 /* Replace the 32-bit opcode with a 16-bit opcode. */ 14134 bfd_put_16 (abfd, 14135 (b_insn_16.match 14136 | (opcode & 0x3ff)), /* Addend value. */ 14137 ptr); 14138 14139 /* Delete 2 bytes from irel->r_offset + 2. */ 14140 delcnt = 2; 14141 deloff = 2; 14142 } 14143 14144 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need 14145 to check the distance from the next instruction, so subtract 2. */ 14146 else if (!insn32 14147 && r_type == R_MICROMIPS_PC16_S1 14148 && IS_BITSIZE (pcrval - 2, 8) 14149 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0 14150 && OP16_VALID_REG (OP32_SREG (opcode))) 14151 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0 14152 && OP16_VALID_REG (OP32_TREG (opcode))))) 14153 { 14154 unsigned long reg; 14155 14156 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode); 14157 14158 /* Fix the relocation's type. */ 14159 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1); 14160 14161 /* Replace the 32-bit opcode with a 16-bit opcode. */ 14162 bfd_put_16 (abfd, 14163 (bz_insns_16[fndopc].match 14164 | BZ16_REG_FIELD (reg) 14165 | (opcode & 0x7f)), /* Addend value. */ 14166 ptr); 14167 14168 /* Delete 2 bytes from irel->r_offset + 2. */ 14169 delcnt = 2; 14170 deloff = 2; 14171 } 14172 14173 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */ 14174 else if (!insn32 14175 && r_type == R_MICROMIPS_26_S1 14176 && target_is_micromips_code_p 14177 && irel->r_offset + 7 < sec->size 14178 && MATCH (opcode, jal_insn_32_bd32)) 14179 { 14180 unsigned long n32opc; 14181 bfd_boolean relaxed = FALSE; 14182 14183 n32opc = bfd_get_micromips_32 (abfd, ptr + 4); 14184 14185 if (MATCH (n32opc, nop_insn_32)) 14186 { 14187 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */ 14188 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4); 14189 14190 relaxed = TRUE; 14191 } 14192 else if (find_match (n32opc, move_insns_32) >= 0) 14193 { 14194 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */ 14195 bfd_put_16 (abfd, 14196 (move_insn_16.match 14197 | MOVE16_RD_FIELD (MOVE32_RD (n32opc)) 14198 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))), 14199 ptr + 4); 14200 14201 relaxed = TRUE; 14202 } 14203 /* Other 32-bit instructions relaxable to 16-bit 14204 instructions will be handled here later. */ 14205 14206 if (relaxed) 14207 { 14208 /* JAL with 32-bit delay slot that is changed to a JALS 14209 with 16-bit delay slot. */ 14210 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr); 14211 14212 /* Delete 2 bytes from irel->r_offset + 6. */ 14213 delcnt = 2; 14214 deloff = 6; 14215 } 14216 } 14217 14218 if (delcnt != 0) 14219 { 14220 /* Note that we've changed the relocs, section contents, etc. */ 14221 elf_section_data (sec)->relocs = internal_relocs; 14222 elf_section_data (sec)->this_hdr.contents = contents; 14223 symtab_hdr->contents = (unsigned char *) isymbuf; 14224 14225 /* Delete bytes depending on the delcnt and deloff. */ 14226 if (!mips_elf_relax_delete_bytes (abfd, sec, 14227 irel->r_offset + deloff, delcnt)) 14228 goto error_return; 14229 14230 /* That will change things, so we should relax again. 14231 Note that this is not required, and it may be slow. */ 14232 *again = TRUE; 14233 } 14234 } 14235 14236 if (isymbuf != NULL 14237 && symtab_hdr->contents != (unsigned char *) isymbuf) 14238 { 14239 if (! link_info->keep_memory) 14240 free (isymbuf); 14241 else 14242 { 14243 /* Cache the symbols for elf_link_input_bfd. */ 14244 symtab_hdr->contents = (unsigned char *) isymbuf; 14245 } 14246 } 14247 14248 if (contents != NULL 14249 && elf_section_data (sec)->this_hdr.contents != contents) 14250 { 14251 if (! link_info->keep_memory) 14252 free (contents); 14253 else 14254 { 14255 /* Cache the section contents for elf_link_input_bfd. */ 14256 elf_section_data (sec)->this_hdr.contents = contents; 14257 } 14258 } 14259 14260 if (elf_section_data (sec)->relocs != internal_relocs) 14261 free (internal_relocs); 14262 14263 return TRUE; 14264 14265 error_return: 14266 if (symtab_hdr->contents != (unsigned char *) isymbuf) 14267 free (isymbuf); 14268 if (elf_section_data (sec)->this_hdr.contents != contents) 14269 free (contents); 14270 if (elf_section_data (sec)->relocs != internal_relocs) 14271 free (internal_relocs); 14272 14273 return FALSE; 14274 } 14275 14276 /* Create a MIPS ELF linker hash table. */ 14277 14278 struct bfd_link_hash_table * 14279 _bfd_mips_elf_link_hash_table_create (bfd *abfd) 14280 { 14281 struct mips_elf_link_hash_table *ret; 14282 size_t amt = sizeof (struct mips_elf_link_hash_table); 14283 14284 ret = bfd_zmalloc (amt); 14285 if (ret == NULL) 14286 return NULL; 14287 14288 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 14289 mips_elf_link_hash_newfunc, 14290 sizeof (struct mips_elf_link_hash_entry), 14291 MIPS_ELF_DATA)) 14292 { 14293 free (ret); 14294 return NULL; 14295 } 14296 ret->root.init_plt_refcount.plist = NULL; 14297 ret->root.init_plt_offset.plist = NULL; 14298 14299 return &ret->root.root; 14300 } 14301 14302 /* Likewise, but indicate that the target is VxWorks. */ 14303 14304 struct bfd_link_hash_table * 14305 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd) 14306 { 14307 struct bfd_link_hash_table *ret; 14308 14309 ret = _bfd_mips_elf_link_hash_table_create (abfd); 14310 if (ret) 14311 { 14312 struct mips_elf_link_hash_table *htab; 14313 14314 htab = (struct mips_elf_link_hash_table *) ret; 14315 htab->use_plts_and_copy_relocs = TRUE; 14316 } 14317 return ret; 14318 } 14319 14320 /* A function that the linker calls if we are allowed to use PLTs 14321 and copy relocs. */ 14322 14323 void 14324 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info) 14325 { 14326 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE; 14327 } 14328 14329 /* A function that the linker calls to select between all or only 14330 32-bit microMIPS instructions, and between making or ignoring 14331 branch relocation checks for invalid transitions between ISA modes. 14332 Also record whether we have been configured for a GNU target. */ 14333 14334 void 14335 _bfd_mips_elf_linker_flags (struct bfd_link_info *info, bfd_boolean insn32, 14336 bfd_boolean ignore_branch_isa, 14337 bfd_boolean gnu_target) 14338 { 14339 mips_elf_hash_table (info)->insn32 = insn32; 14340 mips_elf_hash_table (info)->ignore_branch_isa = ignore_branch_isa; 14341 mips_elf_hash_table (info)->gnu_target = gnu_target; 14342 } 14343 14344 /* A function that the linker calls to enable use of compact branches in 14345 linker generated code for MIPSR6. */ 14346 14347 void 14348 _bfd_mips_elf_compact_branches (struct bfd_link_info *info, bfd_boolean on) 14349 { 14350 mips_elf_hash_table (info)->compact_branches = on; 14351 } 14352 14353 14354 /* Structure for saying that BFD machine EXTENSION extends BASE. */ 14355 14356 struct mips_mach_extension 14357 { 14358 unsigned long extension, base; 14359 }; 14360 14361 14362 /* An array describing how BFD machines relate to one another. The entries 14363 are ordered topologically with MIPS I extensions listed last. */ 14364 14365 static const struct mips_mach_extension mips_mach_extensions[] = 14366 { 14367 /* MIPS64r2 extensions. */ 14368 { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 }, 14369 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp }, 14370 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon }, 14371 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 }, 14372 { bfd_mach_mips_gs264e, bfd_mach_mips_gs464e }, 14373 { bfd_mach_mips_gs464e, bfd_mach_mips_gs464 }, 14374 { bfd_mach_mips_gs464, bfd_mach_mipsisa64r2 }, 14375 14376 /* MIPS64 extensions. */ 14377 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 }, 14378 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 }, 14379 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 }, 14380 14381 /* MIPS V extensions. */ 14382 { bfd_mach_mipsisa64, bfd_mach_mips5 }, 14383 14384 /* R10000 extensions. */ 14385 { bfd_mach_mips12000, bfd_mach_mips10000 }, 14386 { bfd_mach_mips14000, bfd_mach_mips10000 }, 14387 { bfd_mach_mips16000, bfd_mach_mips10000 }, 14388 14389 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core 14390 vr5400 ISA, but doesn't include the multimedia stuff. It seems 14391 better to allow vr5400 and vr5500 code to be merged anyway, since 14392 many libraries will just use the core ISA. Perhaps we could add 14393 some sort of ASE flag if this ever proves a problem. */ 14394 { bfd_mach_mips5500, bfd_mach_mips5400 }, 14395 { bfd_mach_mips5400, bfd_mach_mips5000 }, 14396 14397 /* MIPS IV extensions. */ 14398 { bfd_mach_mips5, bfd_mach_mips8000 }, 14399 { bfd_mach_mips10000, bfd_mach_mips8000 }, 14400 { bfd_mach_mips5000, bfd_mach_mips8000 }, 14401 { bfd_mach_mips7000, bfd_mach_mips8000 }, 14402 { bfd_mach_mips9000, bfd_mach_mips8000 }, 14403 14404 /* VR4100 extensions. */ 14405 { bfd_mach_mips4120, bfd_mach_mips4100 }, 14406 { bfd_mach_mips4111, bfd_mach_mips4100 }, 14407 14408 /* MIPS III extensions. */ 14409 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 }, 14410 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 }, 14411 { bfd_mach_mips8000, bfd_mach_mips4000 }, 14412 { bfd_mach_mips4650, bfd_mach_mips4000 }, 14413 { bfd_mach_mips4600, bfd_mach_mips4000 }, 14414 { bfd_mach_mips4400, bfd_mach_mips4000 }, 14415 { bfd_mach_mips4300, bfd_mach_mips4000 }, 14416 { bfd_mach_mips4100, bfd_mach_mips4000 }, 14417 { bfd_mach_mips5900, bfd_mach_mips4000 }, 14418 14419 /* MIPS32r3 extensions. */ 14420 { bfd_mach_mips_interaptiv_mr2, bfd_mach_mipsisa32r3 }, 14421 14422 /* MIPS32r2 extensions. */ 14423 { bfd_mach_mipsisa32r3, bfd_mach_mipsisa32r2 }, 14424 14425 /* MIPS32 extensions. */ 14426 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 }, 14427 14428 /* MIPS II extensions. */ 14429 { bfd_mach_mips4000, bfd_mach_mips6000 }, 14430 { bfd_mach_mipsisa32, bfd_mach_mips6000 }, 14431 { bfd_mach_mips4010, bfd_mach_mips6000 }, 14432 14433 /* MIPS I extensions. */ 14434 { bfd_mach_mips6000, bfd_mach_mips3000 }, 14435 { bfd_mach_mips3900, bfd_mach_mips3000 } 14436 }; 14437 14438 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */ 14439 14440 static bfd_boolean 14441 mips_mach_extends_p (unsigned long base, unsigned long extension) 14442 { 14443 size_t i; 14444 14445 if (extension == base) 14446 return TRUE; 14447 14448 if (base == bfd_mach_mipsisa32 14449 && mips_mach_extends_p (bfd_mach_mipsisa64, extension)) 14450 return TRUE; 14451 14452 if (base == bfd_mach_mipsisa32r2 14453 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension)) 14454 return TRUE; 14455 14456 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++) 14457 if (extension == mips_mach_extensions[i].extension) 14458 { 14459 extension = mips_mach_extensions[i].base; 14460 if (extension == base) 14461 return TRUE; 14462 } 14463 14464 return FALSE; 14465 } 14466 14467 /* Return the BFD mach for each .MIPS.abiflags ISA Extension. */ 14468 14469 static unsigned long 14470 bfd_mips_isa_ext_mach (unsigned int isa_ext) 14471 { 14472 switch (isa_ext) 14473 { 14474 case AFL_EXT_3900: return bfd_mach_mips3900; 14475 case AFL_EXT_4010: return bfd_mach_mips4010; 14476 case AFL_EXT_4100: return bfd_mach_mips4100; 14477 case AFL_EXT_4111: return bfd_mach_mips4111; 14478 case AFL_EXT_4120: return bfd_mach_mips4120; 14479 case AFL_EXT_4650: return bfd_mach_mips4650; 14480 case AFL_EXT_5400: return bfd_mach_mips5400; 14481 case AFL_EXT_5500: return bfd_mach_mips5500; 14482 case AFL_EXT_5900: return bfd_mach_mips5900; 14483 case AFL_EXT_10000: return bfd_mach_mips10000; 14484 case AFL_EXT_LOONGSON_2E: return bfd_mach_mips_loongson_2e; 14485 case AFL_EXT_LOONGSON_2F: return bfd_mach_mips_loongson_2f; 14486 case AFL_EXT_SB1: return bfd_mach_mips_sb1; 14487 case AFL_EXT_OCTEON: return bfd_mach_mips_octeon; 14488 case AFL_EXT_OCTEONP: return bfd_mach_mips_octeonp; 14489 case AFL_EXT_OCTEON2: return bfd_mach_mips_octeon2; 14490 case AFL_EXT_XLR: return bfd_mach_mips_xlr; 14491 default: return bfd_mach_mips3000; 14492 } 14493 } 14494 14495 /* Return the .MIPS.abiflags value representing each ISA Extension. */ 14496 14497 unsigned int 14498 bfd_mips_isa_ext (bfd *abfd) 14499 { 14500 switch (bfd_get_mach (abfd)) 14501 { 14502 case bfd_mach_mips3900: return AFL_EXT_3900; 14503 case bfd_mach_mips4010: return AFL_EXT_4010; 14504 case bfd_mach_mips4100: return AFL_EXT_4100; 14505 case bfd_mach_mips4111: return AFL_EXT_4111; 14506 case bfd_mach_mips4120: return AFL_EXT_4120; 14507 case bfd_mach_mips4650: return AFL_EXT_4650; 14508 case bfd_mach_mips5400: return AFL_EXT_5400; 14509 case bfd_mach_mips5500: return AFL_EXT_5500; 14510 case bfd_mach_mips5900: return AFL_EXT_5900; 14511 case bfd_mach_mips10000: return AFL_EXT_10000; 14512 case bfd_mach_mips_loongson_2e: return AFL_EXT_LOONGSON_2E; 14513 case bfd_mach_mips_loongson_2f: return AFL_EXT_LOONGSON_2F; 14514 case bfd_mach_mips_sb1: return AFL_EXT_SB1; 14515 case bfd_mach_mips_octeon: return AFL_EXT_OCTEON; 14516 case bfd_mach_mips_octeonp: return AFL_EXT_OCTEONP; 14517 case bfd_mach_mips_octeon3: return AFL_EXT_OCTEON3; 14518 case bfd_mach_mips_octeon2: return AFL_EXT_OCTEON2; 14519 case bfd_mach_mips_xlr: return AFL_EXT_XLR; 14520 case bfd_mach_mips_interaptiv_mr2: 14521 return AFL_EXT_INTERAPTIV_MR2; 14522 default: return 0; 14523 } 14524 } 14525 14526 /* Encode ISA level and revision as a single value. */ 14527 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV)) 14528 14529 /* Decode a single value into level and revision. */ 14530 #define ISA_LEVEL(LEVREV) ((LEVREV) >> 3) 14531 #define ISA_REV(LEVREV) ((LEVREV) & 0x7) 14532 14533 /* Update the isa_level, isa_rev, isa_ext fields of abiflags. */ 14534 14535 static void 14536 update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags) 14537 { 14538 int new_isa = 0; 14539 switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) 14540 { 14541 case E_MIPS_ARCH_1: new_isa = LEVEL_REV (1, 0); break; 14542 case E_MIPS_ARCH_2: new_isa = LEVEL_REV (2, 0); break; 14543 case E_MIPS_ARCH_3: new_isa = LEVEL_REV (3, 0); break; 14544 case E_MIPS_ARCH_4: new_isa = LEVEL_REV (4, 0); break; 14545 case E_MIPS_ARCH_5: new_isa = LEVEL_REV (5, 0); break; 14546 case E_MIPS_ARCH_32: new_isa = LEVEL_REV (32, 1); break; 14547 case E_MIPS_ARCH_32R2: new_isa = LEVEL_REV (32, 2); break; 14548 case E_MIPS_ARCH_32R6: new_isa = LEVEL_REV (32, 6); break; 14549 case E_MIPS_ARCH_64: new_isa = LEVEL_REV (64, 1); break; 14550 case E_MIPS_ARCH_64R2: new_isa = LEVEL_REV (64, 2); break; 14551 case E_MIPS_ARCH_64R6: new_isa = LEVEL_REV (64, 6); break; 14552 default: 14553 _bfd_error_handler 14554 /* xgettext:c-format */ 14555 (_("%pB: unknown architecture %s"), 14556 abfd, bfd_printable_name (abfd)); 14557 } 14558 14559 if (new_isa > LEVEL_REV (abiflags->isa_level, abiflags->isa_rev)) 14560 { 14561 abiflags->isa_level = ISA_LEVEL (new_isa); 14562 abiflags->isa_rev = ISA_REV (new_isa); 14563 } 14564 14565 /* Update the isa_ext if ABFD describes a further extension. */ 14566 if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags->isa_ext), 14567 bfd_get_mach (abfd))) 14568 abiflags->isa_ext = bfd_mips_isa_ext (abfd); 14569 } 14570 14571 /* Return true if the given ELF header flags describe a 32-bit binary. */ 14572 14573 static bfd_boolean 14574 mips_32bit_flags_p (flagword flags) 14575 { 14576 return ((flags & EF_MIPS_32BITMODE) != 0 14577 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32 14578 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32 14579 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1 14580 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2 14581 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32 14582 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2 14583 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6); 14584 } 14585 14586 /* Infer the content of the ABI flags based on the elf header. */ 14587 14588 static void 14589 infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags) 14590 { 14591 obj_attribute *in_attr; 14592 14593 memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0)); 14594 update_mips_abiflags_isa (abfd, abiflags); 14595 14596 if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags)) 14597 abiflags->gpr_size = AFL_REG_32; 14598 else 14599 abiflags->gpr_size = AFL_REG_64; 14600 14601 abiflags->cpr1_size = AFL_REG_NONE; 14602 14603 in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU]; 14604 abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i; 14605 14606 if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE 14607 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX 14608 || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE 14609 && abiflags->gpr_size == AFL_REG_32)) 14610 abiflags->cpr1_size = AFL_REG_32; 14611 else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE 14612 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64 14613 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A) 14614 abiflags->cpr1_size = AFL_REG_64; 14615 14616 abiflags->cpr2_size = AFL_REG_NONE; 14617 14618 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX) 14619 abiflags->ases |= AFL_ASE_MDMX; 14620 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16) 14621 abiflags->ases |= AFL_ASE_MIPS16; 14622 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) 14623 abiflags->ases |= AFL_ASE_MICROMIPS; 14624 14625 if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY 14626 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT 14627 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A 14628 && abiflags->isa_level >= 32 14629 && abiflags->ases != AFL_ASE_LOONGSON_EXT) 14630 abiflags->flags1 |= AFL_FLAGS1_ODDSPREG; 14631 } 14632 14633 /* We need to use a special link routine to handle the .reginfo and 14634 the .mdebug sections. We need to merge all instances of these 14635 sections together, not write them all out sequentially. */ 14636 14637 bfd_boolean 14638 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info) 14639 { 14640 asection *o; 14641 struct bfd_link_order *p; 14642 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec; 14643 asection *rtproc_sec, *abiflags_sec; 14644 Elf32_RegInfo reginfo; 14645 struct ecoff_debug_info debug; 14646 struct mips_htab_traverse_info hti; 14647 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 14648 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap; 14649 HDRR *symhdr = &debug.symbolic_header; 14650 void *mdebug_handle = NULL; 14651 asection *s; 14652 EXTR esym; 14653 unsigned int i; 14654 bfd_size_type amt; 14655 struct mips_elf_link_hash_table *htab; 14656 14657 static const char * const secname[] = 14658 { 14659 ".text", ".init", ".fini", ".data", 14660 ".rodata", ".sdata", ".sbss", ".bss" 14661 }; 14662 static const int sc[] = 14663 { 14664 scText, scInit, scFini, scData, 14665 scRData, scSData, scSBss, scBss 14666 }; 14667 14668 htab = mips_elf_hash_table (info); 14669 BFD_ASSERT (htab != NULL); 14670 14671 /* Sort the dynamic symbols so that those with GOT entries come after 14672 those without. */ 14673 if (!mips_elf_sort_hash_table (abfd, info)) 14674 return FALSE; 14675 14676 /* Create any scheduled LA25 stubs. */ 14677 hti.info = info; 14678 hti.output_bfd = abfd; 14679 hti.error = FALSE; 14680 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti); 14681 if (hti.error) 14682 return FALSE; 14683 14684 /* Get a value for the GP register. */ 14685 if (elf_gp (abfd) == 0) 14686 { 14687 struct bfd_link_hash_entry *h; 14688 14689 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 14690 if (h != NULL && h->type == bfd_link_hash_defined) 14691 elf_gp (abfd) = (h->u.def.value 14692 + h->u.def.section->output_section->vma 14693 + h->u.def.section->output_offset); 14694 else if (htab->root.target_os == is_vxworks 14695 && (h = bfd_link_hash_lookup (info->hash, 14696 "_GLOBAL_OFFSET_TABLE_", 14697 FALSE, FALSE, TRUE)) 14698 && h->type == bfd_link_hash_defined) 14699 elf_gp (abfd) = (h->u.def.section->output_section->vma 14700 + h->u.def.section->output_offset 14701 + h->u.def.value); 14702 else if (bfd_link_relocatable (info)) 14703 { 14704 bfd_vma lo = MINUS_ONE; 14705 14706 /* Find the GP-relative section with the lowest offset. */ 14707 for (o = abfd->sections; o != NULL; o = o->next) 14708 if (o->vma < lo 14709 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL)) 14710 lo = o->vma; 14711 14712 /* And calculate GP relative to that. */ 14713 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info); 14714 } 14715 else 14716 { 14717 /* If the relocate_section function needs to do a reloc 14718 involving the GP value, it should make a reloc_dangerous 14719 callback to warn that GP is not defined. */ 14720 } 14721 } 14722 14723 /* Go through the sections and collect the .reginfo and .mdebug 14724 information. */ 14725 abiflags_sec = NULL; 14726 reginfo_sec = NULL; 14727 mdebug_sec = NULL; 14728 gptab_data_sec = NULL; 14729 gptab_bss_sec = NULL; 14730 for (o = abfd->sections; o != NULL; o = o->next) 14731 { 14732 if (strcmp (o->name, ".MIPS.abiflags") == 0) 14733 { 14734 /* We have found the .MIPS.abiflags section in the output file. 14735 Look through all the link_orders comprising it and remove them. 14736 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */ 14737 for (p = o->map_head.link_order; p != NULL; p = p->next) 14738 { 14739 asection *input_section; 14740 14741 if (p->type != bfd_indirect_link_order) 14742 { 14743 if (p->type == bfd_data_link_order) 14744 continue; 14745 abort (); 14746 } 14747 14748 input_section = p->u.indirect.section; 14749 14750 /* Hack: reset the SEC_HAS_CONTENTS flag so that 14751 elf_link_input_bfd ignores this section. */ 14752 input_section->flags &= ~SEC_HAS_CONTENTS; 14753 } 14754 14755 /* Size has been set in _bfd_mips_elf_always_size_sections. */ 14756 BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0)); 14757 14758 /* Skip this section later on (I don't think this currently 14759 matters, but someday it might). */ 14760 o->map_head.link_order = NULL; 14761 14762 abiflags_sec = o; 14763 } 14764 14765 if (strcmp (o->name, ".reginfo") == 0) 14766 { 14767 memset (®info, 0, sizeof reginfo); 14768 14769 /* We have found the .reginfo section in the output file. 14770 Look through all the link_orders comprising it and merge 14771 the information together. */ 14772 for (p = o->map_head.link_order; p != NULL; p = p->next) 14773 { 14774 asection *input_section; 14775 bfd *input_bfd; 14776 Elf32_External_RegInfo ext; 14777 Elf32_RegInfo sub; 14778 bfd_size_type sz; 14779 14780 if (p->type != bfd_indirect_link_order) 14781 { 14782 if (p->type == bfd_data_link_order) 14783 continue; 14784 abort (); 14785 } 14786 14787 input_section = p->u.indirect.section; 14788 input_bfd = input_section->owner; 14789 14790 sz = (input_section->size < sizeof (ext) 14791 ? input_section->size : sizeof (ext)); 14792 memset (&ext, 0, sizeof (ext)); 14793 if (! bfd_get_section_contents (input_bfd, input_section, 14794 &ext, 0, sz)) 14795 return FALSE; 14796 14797 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub); 14798 14799 reginfo.ri_gprmask |= sub.ri_gprmask; 14800 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0]; 14801 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1]; 14802 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2]; 14803 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3]; 14804 14805 /* ri_gp_value is set by the function 14806 `_bfd_mips_elf_section_processing' when the section is 14807 finally written out. */ 14808 14809 /* Hack: reset the SEC_HAS_CONTENTS flag so that 14810 elf_link_input_bfd ignores this section. */ 14811 input_section->flags &= ~SEC_HAS_CONTENTS; 14812 } 14813 14814 /* Size has been set in _bfd_mips_elf_always_size_sections. */ 14815 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo)); 14816 14817 /* Skip this section later on (I don't think this currently 14818 matters, but someday it might). */ 14819 o->map_head.link_order = NULL; 14820 14821 reginfo_sec = o; 14822 } 14823 14824 if (strcmp (o->name, ".mdebug") == 0) 14825 { 14826 struct extsym_info einfo; 14827 bfd_vma last; 14828 14829 /* We have found the .mdebug section in the output file. 14830 Look through all the link_orders comprising it and merge 14831 the information together. */ 14832 symhdr->magic = swap->sym_magic; 14833 /* FIXME: What should the version stamp be? */ 14834 symhdr->vstamp = 0; 14835 symhdr->ilineMax = 0; 14836 symhdr->cbLine = 0; 14837 symhdr->idnMax = 0; 14838 symhdr->ipdMax = 0; 14839 symhdr->isymMax = 0; 14840 symhdr->ioptMax = 0; 14841 symhdr->iauxMax = 0; 14842 symhdr->issMax = 0; 14843 symhdr->issExtMax = 0; 14844 symhdr->ifdMax = 0; 14845 symhdr->crfd = 0; 14846 symhdr->iextMax = 0; 14847 14848 /* We accumulate the debugging information itself in the 14849 debug_info structure. */ 14850 debug.line = NULL; 14851 debug.external_dnr = NULL; 14852 debug.external_pdr = NULL; 14853 debug.external_sym = NULL; 14854 debug.external_opt = NULL; 14855 debug.external_aux = NULL; 14856 debug.ss = NULL; 14857 debug.ssext = debug.ssext_end = NULL; 14858 debug.external_fdr = NULL; 14859 debug.external_rfd = NULL; 14860 debug.external_ext = debug.external_ext_end = NULL; 14861 14862 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info); 14863 if (mdebug_handle == NULL) 14864 return FALSE; 14865 14866 esym.jmptbl = 0; 14867 esym.cobol_main = 0; 14868 esym.weakext = 0; 14869 esym.reserved = 0; 14870 esym.ifd = ifdNil; 14871 esym.asym.iss = issNil; 14872 esym.asym.st = stLocal; 14873 esym.asym.reserved = 0; 14874 esym.asym.index = indexNil; 14875 last = 0; 14876 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++) 14877 { 14878 esym.asym.sc = sc[i]; 14879 s = bfd_get_section_by_name (abfd, secname[i]); 14880 if (s != NULL) 14881 { 14882 esym.asym.value = s->vma; 14883 last = s->vma + s->size; 14884 } 14885 else 14886 esym.asym.value = last; 14887 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap, 14888 secname[i], &esym)) 14889 return FALSE; 14890 } 14891 14892 for (p = o->map_head.link_order; p != NULL; p = p->next) 14893 { 14894 asection *input_section; 14895 bfd *input_bfd; 14896 const struct ecoff_debug_swap *input_swap; 14897 struct ecoff_debug_info input_debug; 14898 char *eraw_src; 14899 char *eraw_end; 14900 14901 if (p->type != bfd_indirect_link_order) 14902 { 14903 if (p->type == bfd_data_link_order) 14904 continue; 14905 abort (); 14906 } 14907 14908 input_section = p->u.indirect.section; 14909 input_bfd = input_section->owner; 14910 14911 if (!is_mips_elf (input_bfd)) 14912 { 14913 /* I don't know what a non MIPS ELF bfd would be 14914 doing with a .mdebug section, but I don't really 14915 want to deal with it. */ 14916 continue; 14917 } 14918 14919 input_swap = (get_elf_backend_data (input_bfd) 14920 ->elf_backend_ecoff_debug_swap); 14921 14922 BFD_ASSERT (p->size == input_section->size); 14923 14924 /* The ECOFF linking code expects that we have already 14925 read in the debugging information and set up an 14926 ecoff_debug_info structure, so we do that now. */ 14927 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section, 14928 &input_debug)) 14929 return FALSE; 14930 14931 if (! (bfd_ecoff_debug_accumulate 14932 (mdebug_handle, abfd, &debug, swap, input_bfd, 14933 &input_debug, input_swap, info))) 14934 return FALSE; 14935 14936 /* Loop through the external symbols. For each one with 14937 interesting information, try to find the symbol in 14938 the linker global hash table and save the information 14939 for the output external symbols. */ 14940 eraw_src = input_debug.external_ext; 14941 eraw_end = (eraw_src 14942 + (input_debug.symbolic_header.iextMax 14943 * input_swap->external_ext_size)); 14944 for (; 14945 eraw_src < eraw_end; 14946 eraw_src += input_swap->external_ext_size) 14947 { 14948 EXTR ext; 14949 const char *name; 14950 struct mips_elf_link_hash_entry *h; 14951 14952 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext); 14953 if (ext.asym.sc == scNil 14954 || ext.asym.sc == scUndefined 14955 || ext.asym.sc == scSUndefined) 14956 continue; 14957 14958 name = input_debug.ssext + ext.asym.iss; 14959 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info), 14960 name, FALSE, FALSE, TRUE); 14961 if (h == NULL || h->esym.ifd != -2) 14962 continue; 14963 14964 if (ext.ifd != -1) 14965 { 14966 BFD_ASSERT (ext.ifd 14967 < input_debug.symbolic_header.ifdMax); 14968 ext.ifd = input_debug.ifdmap[ext.ifd]; 14969 } 14970 14971 h->esym = ext; 14972 } 14973 14974 /* Free up the information we just read. */ 14975 free (input_debug.line); 14976 free (input_debug.external_dnr); 14977 free (input_debug.external_pdr); 14978 free (input_debug.external_sym); 14979 free (input_debug.external_opt); 14980 free (input_debug.external_aux); 14981 free (input_debug.ss); 14982 free (input_debug.ssext); 14983 free (input_debug.external_fdr); 14984 free (input_debug.external_rfd); 14985 free (input_debug.external_ext); 14986 14987 /* Hack: reset the SEC_HAS_CONTENTS flag so that 14988 elf_link_input_bfd ignores this section. */ 14989 input_section->flags &= ~SEC_HAS_CONTENTS; 14990 } 14991 14992 if (SGI_COMPAT (abfd) && bfd_link_pic (info)) 14993 { 14994 /* Create .rtproc section. */ 14995 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc"); 14996 if (rtproc_sec == NULL) 14997 { 14998 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY 14999 | SEC_LINKER_CREATED | SEC_READONLY); 15000 15001 rtproc_sec = bfd_make_section_anyway_with_flags (abfd, 15002 ".rtproc", 15003 flags); 15004 if (rtproc_sec == NULL 15005 || !bfd_set_section_alignment (rtproc_sec, 4)) 15006 return FALSE; 15007 } 15008 15009 if (! mips_elf_create_procedure_table (mdebug_handle, abfd, 15010 info, rtproc_sec, 15011 &debug)) 15012 return FALSE; 15013 } 15014 15015 /* Build the external symbol information. */ 15016 einfo.abfd = abfd; 15017 einfo.info = info; 15018 einfo.debug = &debug; 15019 einfo.swap = swap; 15020 einfo.failed = FALSE; 15021 mips_elf_link_hash_traverse (mips_elf_hash_table (info), 15022 mips_elf_output_extsym, &einfo); 15023 if (einfo.failed) 15024 return FALSE; 15025 15026 /* Set the size of the .mdebug section. */ 15027 o->size = bfd_ecoff_debug_size (abfd, &debug, swap); 15028 15029 /* Skip this section later on (I don't think this currently 15030 matters, but someday it might). */ 15031 o->map_head.link_order = NULL; 15032 15033 mdebug_sec = o; 15034 } 15035 15036 if (CONST_STRNEQ (o->name, ".gptab.")) 15037 { 15038 const char *subname; 15039 unsigned int c; 15040 Elf32_gptab *tab; 15041 Elf32_External_gptab *ext_tab; 15042 unsigned int j; 15043 15044 /* The .gptab.sdata and .gptab.sbss sections hold 15045 information describing how the small data area would 15046 change depending upon the -G switch. These sections 15047 not used in executables files. */ 15048 if (! bfd_link_relocatable (info)) 15049 { 15050 for (p = o->map_head.link_order; p != NULL; p = p->next) 15051 { 15052 asection *input_section; 15053 15054 if (p->type != bfd_indirect_link_order) 15055 { 15056 if (p->type == bfd_data_link_order) 15057 continue; 15058 abort (); 15059 } 15060 15061 input_section = p->u.indirect.section; 15062 15063 /* Hack: reset the SEC_HAS_CONTENTS flag so that 15064 elf_link_input_bfd ignores this section. */ 15065 input_section->flags &= ~SEC_HAS_CONTENTS; 15066 } 15067 15068 /* Skip this section later on (I don't think this 15069 currently matters, but someday it might). */ 15070 o->map_head.link_order = NULL; 15071 15072 /* Really remove the section. */ 15073 bfd_section_list_remove (abfd, o); 15074 --abfd->section_count; 15075 15076 continue; 15077 } 15078 15079 /* There is one gptab for initialized data, and one for 15080 uninitialized data. */ 15081 if (strcmp (o->name, ".gptab.sdata") == 0) 15082 gptab_data_sec = o; 15083 else if (strcmp (o->name, ".gptab.sbss") == 0) 15084 gptab_bss_sec = o; 15085 else 15086 { 15087 _bfd_error_handler 15088 /* xgettext:c-format */ 15089 (_("%pB: illegal section name `%pA'"), abfd, o); 15090 bfd_set_error (bfd_error_nonrepresentable_section); 15091 return FALSE; 15092 } 15093 15094 /* The linker script always combines .gptab.data and 15095 .gptab.sdata into .gptab.sdata, and likewise for 15096 .gptab.bss and .gptab.sbss. It is possible that there is 15097 no .sdata or .sbss section in the output file, in which 15098 case we must change the name of the output section. */ 15099 subname = o->name + sizeof ".gptab" - 1; 15100 if (bfd_get_section_by_name (abfd, subname) == NULL) 15101 { 15102 if (o == gptab_data_sec) 15103 o->name = ".gptab.data"; 15104 else 15105 o->name = ".gptab.bss"; 15106 subname = o->name + sizeof ".gptab" - 1; 15107 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL); 15108 } 15109 15110 /* Set up the first entry. */ 15111 c = 1; 15112 amt = c * sizeof (Elf32_gptab); 15113 tab = bfd_malloc (amt); 15114 if (tab == NULL) 15115 return FALSE; 15116 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd); 15117 tab[0].gt_header.gt_unused = 0; 15118 15119 /* Combine the input sections. */ 15120 for (p = o->map_head.link_order; p != NULL; p = p->next) 15121 { 15122 asection *input_section; 15123 bfd *input_bfd; 15124 bfd_size_type size; 15125 unsigned long last; 15126 bfd_size_type gpentry; 15127 15128 if (p->type != bfd_indirect_link_order) 15129 { 15130 if (p->type == bfd_data_link_order) 15131 continue; 15132 abort (); 15133 } 15134 15135 input_section = p->u.indirect.section; 15136 input_bfd = input_section->owner; 15137 15138 /* Combine the gptab entries for this input section one 15139 by one. We know that the input gptab entries are 15140 sorted by ascending -G value. */ 15141 size = input_section->size; 15142 last = 0; 15143 for (gpentry = sizeof (Elf32_External_gptab); 15144 gpentry < size; 15145 gpentry += sizeof (Elf32_External_gptab)) 15146 { 15147 Elf32_External_gptab ext_gptab; 15148 Elf32_gptab int_gptab; 15149 unsigned long val; 15150 unsigned long add; 15151 bfd_boolean exact; 15152 unsigned int look; 15153 15154 if (! (bfd_get_section_contents 15155 (input_bfd, input_section, &ext_gptab, gpentry, 15156 sizeof (Elf32_External_gptab)))) 15157 { 15158 free (tab); 15159 return FALSE; 15160 } 15161 15162 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab, 15163 &int_gptab); 15164 val = int_gptab.gt_entry.gt_g_value; 15165 add = int_gptab.gt_entry.gt_bytes - last; 15166 15167 exact = FALSE; 15168 for (look = 1; look < c; look++) 15169 { 15170 if (tab[look].gt_entry.gt_g_value >= val) 15171 tab[look].gt_entry.gt_bytes += add; 15172 15173 if (tab[look].gt_entry.gt_g_value == val) 15174 exact = TRUE; 15175 } 15176 15177 if (! exact) 15178 { 15179 Elf32_gptab *new_tab; 15180 unsigned int max; 15181 15182 /* We need a new table entry. */ 15183 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab); 15184 new_tab = bfd_realloc (tab, amt); 15185 if (new_tab == NULL) 15186 { 15187 free (tab); 15188 return FALSE; 15189 } 15190 tab = new_tab; 15191 tab[c].gt_entry.gt_g_value = val; 15192 tab[c].gt_entry.gt_bytes = add; 15193 15194 /* Merge in the size for the next smallest -G 15195 value, since that will be implied by this new 15196 value. */ 15197 max = 0; 15198 for (look = 1; look < c; look++) 15199 { 15200 if (tab[look].gt_entry.gt_g_value < val 15201 && (max == 0 15202 || (tab[look].gt_entry.gt_g_value 15203 > tab[max].gt_entry.gt_g_value))) 15204 max = look; 15205 } 15206 if (max != 0) 15207 tab[c].gt_entry.gt_bytes += 15208 tab[max].gt_entry.gt_bytes; 15209 15210 ++c; 15211 } 15212 15213 last = int_gptab.gt_entry.gt_bytes; 15214 } 15215 15216 /* Hack: reset the SEC_HAS_CONTENTS flag so that 15217 elf_link_input_bfd ignores this section. */ 15218 input_section->flags &= ~SEC_HAS_CONTENTS; 15219 } 15220 15221 /* The table must be sorted by -G value. */ 15222 if (c > 2) 15223 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare); 15224 15225 /* Swap out the table. */ 15226 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab); 15227 ext_tab = bfd_alloc (abfd, amt); 15228 if (ext_tab == NULL) 15229 { 15230 free (tab); 15231 return FALSE; 15232 } 15233 15234 for (j = 0; j < c; j++) 15235 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j); 15236 free (tab); 15237 15238 o->size = c * sizeof (Elf32_External_gptab); 15239 o->contents = (bfd_byte *) ext_tab; 15240 15241 /* Skip this section later on (I don't think this currently 15242 matters, but someday it might). */ 15243 o->map_head.link_order = NULL; 15244 } 15245 } 15246 15247 /* Invoke the regular ELF backend linker to do all the work. */ 15248 if (!bfd_elf_final_link (abfd, info)) 15249 return FALSE; 15250 15251 /* Now write out the computed sections. */ 15252 15253 if (abiflags_sec != NULL) 15254 { 15255 Elf_External_ABIFlags_v0 ext; 15256 Elf_Internal_ABIFlags_v0 *abiflags; 15257 15258 abiflags = &mips_elf_tdata (abfd)->abiflags; 15259 15260 /* Set up the abiflags if no valid input sections were found. */ 15261 if (!mips_elf_tdata (abfd)->abiflags_valid) 15262 { 15263 infer_mips_abiflags (abfd, abiflags); 15264 mips_elf_tdata (abfd)->abiflags_valid = TRUE; 15265 } 15266 bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext); 15267 if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext)) 15268 return FALSE; 15269 } 15270 15271 if (reginfo_sec != NULL) 15272 { 15273 Elf32_External_RegInfo ext; 15274 15275 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext); 15276 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext)) 15277 return FALSE; 15278 } 15279 15280 if (mdebug_sec != NULL) 15281 { 15282 BFD_ASSERT (abfd->output_has_begun); 15283 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug, 15284 swap, info, 15285 mdebug_sec->filepos)) 15286 return FALSE; 15287 15288 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info); 15289 } 15290 15291 if (gptab_data_sec != NULL) 15292 { 15293 if (! bfd_set_section_contents (abfd, gptab_data_sec, 15294 gptab_data_sec->contents, 15295 0, gptab_data_sec->size)) 15296 return FALSE; 15297 } 15298 15299 if (gptab_bss_sec != NULL) 15300 { 15301 if (! bfd_set_section_contents (abfd, gptab_bss_sec, 15302 gptab_bss_sec->contents, 15303 0, gptab_bss_sec->size)) 15304 return FALSE; 15305 } 15306 15307 if (SGI_COMPAT (abfd)) 15308 { 15309 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc"); 15310 if (rtproc_sec != NULL) 15311 { 15312 if (! bfd_set_section_contents (abfd, rtproc_sec, 15313 rtproc_sec->contents, 15314 0, rtproc_sec->size)) 15315 return FALSE; 15316 } 15317 } 15318 15319 return TRUE; 15320 } 15321 15322 /* Merge object file header flags from IBFD into OBFD. Raise an error 15323 if there are conflicting settings. */ 15324 15325 static bfd_boolean 15326 mips_elf_merge_obj_e_flags (bfd *ibfd, struct bfd_link_info *info) 15327 { 15328 bfd *obfd = info->output_bfd; 15329 struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd); 15330 flagword old_flags; 15331 flagword new_flags; 15332 bfd_boolean ok; 15333 15334 new_flags = elf_elfheader (ibfd)->e_flags; 15335 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER; 15336 old_flags = elf_elfheader (obfd)->e_flags; 15337 15338 /* Check flag compatibility. */ 15339 15340 new_flags &= ~EF_MIPS_NOREORDER; 15341 old_flags &= ~EF_MIPS_NOREORDER; 15342 15343 /* Some IRIX 6 BSD-compatibility objects have this bit set. It 15344 doesn't seem to matter. */ 15345 new_flags &= ~EF_MIPS_XGOT; 15346 old_flags &= ~EF_MIPS_XGOT; 15347 15348 /* MIPSpro generates ucode info in n64 objects. Again, we should 15349 just be able to ignore this. */ 15350 new_flags &= ~EF_MIPS_UCODE; 15351 old_flags &= ~EF_MIPS_UCODE; 15352 15353 /* DSOs should only be linked with CPIC code. */ 15354 if ((ibfd->flags & DYNAMIC) != 0) 15355 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC; 15356 15357 if (new_flags == old_flags) 15358 return TRUE; 15359 15360 ok = TRUE; 15361 15362 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0) 15363 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)) 15364 { 15365 _bfd_error_handler 15366 (_("%pB: warning: linking abicalls files with non-abicalls files"), 15367 ibfd); 15368 ok = TRUE; 15369 } 15370 15371 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) 15372 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC; 15373 if (! (new_flags & EF_MIPS_PIC)) 15374 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC; 15375 15376 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC); 15377 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC); 15378 15379 /* Compare the ISAs. */ 15380 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags)) 15381 { 15382 _bfd_error_handler 15383 (_("%pB: linking 32-bit code with 64-bit code"), 15384 ibfd); 15385 ok = FALSE; 15386 } 15387 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd))) 15388 { 15389 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */ 15390 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd))) 15391 { 15392 /* Copy the architecture info from IBFD to OBFD. Also copy 15393 the 32-bit flag (if set) so that we continue to recognise 15394 OBFD as a 32-bit binary. */ 15395 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd)); 15396 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH); 15397 elf_elfheader (obfd)->e_flags 15398 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 15399 15400 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */ 15401 update_mips_abiflags_isa (obfd, &out_tdata->abiflags); 15402 15403 /* Copy across the ABI flags if OBFD doesn't use them 15404 and if that was what caused us to treat IBFD as 32-bit. */ 15405 if ((old_flags & EF_MIPS_ABI) == 0 15406 && mips_32bit_flags_p (new_flags) 15407 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI)) 15408 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI; 15409 } 15410 else 15411 { 15412 /* The ISAs aren't compatible. */ 15413 _bfd_error_handler 15414 /* xgettext:c-format */ 15415 (_("%pB: linking %s module with previous %s modules"), 15416 ibfd, 15417 bfd_printable_name (ibfd), 15418 bfd_printable_name (obfd)); 15419 ok = FALSE; 15420 } 15421 } 15422 15423 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 15424 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 15425 15426 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it 15427 does set EI_CLASS differently from any 32-bit ABI. */ 15428 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI) 15429 || (elf_elfheader (ibfd)->e_ident[EI_CLASS] 15430 != elf_elfheader (obfd)->e_ident[EI_CLASS])) 15431 { 15432 /* Only error if both are set (to different values). */ 15433 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI)) 15434 || (elf_elfheader (ibfd)->e_ident[EI_CLASS] 15435 != elf_elfheader (obfd)->e_ident[EI_CLASS])) 15436 { 15437 _bfd_error_handler 15438 /* xgettext:c-format */ 15439 (_("%pB: ABI mismatch: linking %s module with previous %s modules"), 15440 ibfd, 15441 elf_mips_abi_name (ibfd), 15442 elf_mips_abi_name (obfd)); 15443 ok = FALSE; 15444 } 15445 new_flags &= ~EF_MIPS_ABI; 15446 old_flags &= ~EF_MIPS_ABI; 15447 } 15448 15449 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together 15450 and allow arbitrary mixing of the remaining ASEs (retain the union). */ 15451 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE)) 15452 { 15453 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS; 15454 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS; 15455 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16; 15456 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16; 15457 int micro_mis = old_m16 && new_micro; 15458 int m16_mis = old_micro && new_m16; 15459 15460 if (m16_mis || micro_mis) 15461 { 15462 _bfd_error_handler 15463 /* xgettext:c-format */ 15464 (_("%pB: ASE mismatch: linking %s module with previous %s modules"), 15465 ibfd, 15466 m16_mis ? "MIPS16" : "microMIPS", 15467 m16_mis ? "microMIPS" : "MIPS16"); 15468 ok = FALSE; 15469 } 15470 15471 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE; 15472 15473 new_flags &= ~ EF_MIPS_ARCH_ASE; 15474 old_flags &= ~ EF_MIPS_ARCH_ASE; 15475 } 15476 15477 /* Compare NaN encodings. */ 15478 if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008)) 15479 { 15480 /* xgettext:c-format */ 15481 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"), 15482 ibfd, 15483 (new_flags & EF_MIPS_NAN2008 15484 ? "-mnan=2008" : "-mnan=legacy"), 15485 (old_flags & EF_MIPS_NAN2008 15486 ? "-mnan=2008" : "-mnan=legacy")); 15487 ok = FALSE; 15488 new_flags &= ~EF_MIPS_NAN2008; 15489 old_flags &= ~EF_MIPS_NAN2008; 15490 } 15491 15492 /* Compare FP64 state. */ 15493 if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64)) 15494 { 15495 /* xgettext:c-format */ 15496 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"), 15497 ibfd, 15498 (new_flags & EF_MIPS_FP64 15499 ? "-mfp64" : "-mfp32"), 15500 (old_flags & EF_MIPS_FP64 15501 ? "-mfp64" : "-mfp32")); 15502 ok = FALSE; 15503 new_flags &= ~EF_MIPS_FP64; 15504 old_flags &= ~EF_MIPS_FP64; 15505 } 15506 15507 /* Warn about any other mismatches */ 15508 if (new_flags != old_flags) 15509 { 15510 /* xgettext:c-format */ 15511 _bfd_error_handler 15512 (_("%pB: uses different e_flags (%#x) fields than previous modules " 15513 "(%#x)"), 15514 ibfd, new_flags, old_flags); 15515 ok = FALSE; 15516 } 15517 15518 return ok; 15519 } 15520 15521 /* Merge object attributes from IBFD into OBFD. Raise an error if 15522 there are conflicting attributes. */ 15523 static bfd_boolean 15524 mips_elf_merge_obj_attributes (bfd *ibfd, struct bfd_link_info *info) 15525 { 15526 bfd *obfd = info->output_bfd; 15527 obj_attribute *in_attr; 15528 obj_attribute *out_attr; 15529 bfd *abi_fp_bfd; 15530 bfd *abi_msa_bfd; 15531 15532 abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd; 15533 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 15534 if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY) 15535 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd; 15536 15537 abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd; 15538 if (!abi_msa_bfd 15539 && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY) 15540 mips_elf_tdata (obfd)->abi_msa_bfd = ibfd; 15541 15542 if (!elf_known_obj_attributes_proc (obfd)[0].i) 15543 { 15544 /* This is the first object. Copy the attributes. */ 15545 _bfd_elf_copy_obj_attributes (ibfd, obfd); 15546 15547 /* Use the Tag_null value to indicate the attributes have been 15548 initialized. */ 15549 elf_known_obj_attributes_proc (obfd)[0].i = 1; 15550 15551 return TRUE; 15552 } 15553 15554 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge 15555 non-conflicting ones. */ 15556 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 15557 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i) 15558 { 15559 int out_fp, in_fp; 15560 15561 out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i; 15562 in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i; 15563 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1; 15564 if (out_fp == Val_GNU_MIPS_ABI_FP_ANY) 15565 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp; 15566 else if (out_fp == Val_GNU_MIPS_ABI_FP_XX 15567 && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE 15568 || in_fp == Val_GNU_MIPS_ABI_FP_64 15569 || in_fp == Val_GNU_MIPS_ABI_FP_64A)) 15570 { 15571 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd; 15572 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i; 15573 } 15574 else if (in_fp == Val_GNU_MIPS_ABI_FP_XX 15575 && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE 15576 || out_fp == Val_GNU_MIPS_ABI_FP_64 15577 || out_fp == Val_GNU_MIPS_ABI_FP_64A)) 15578 /* Keep the current setting. */; 15579 else if (out_fp == Val_GNU_MIPS_ABI_FP_64A 15580 && in_fp == Val_GNU_MIPS_ABI_FP_64) 15581 { 15582 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd; 15583 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i; 15584 } 15585 else if (in_fp == Val_GNU_MIPS_ABI_FP_64A 15586 && out_fp == Val_GNU_MIPS_ABI_FP_64) 15587 /* Keep the current setting. */; 15588 else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY) 15589 { 15590 const char *out_string, *in_string; 15591 15592 out_string = _bfd_mips_fp_abi_string (out_fp); 15593 in_string = _bfd_mips_fp_abi_string (in_fp); 15594 /* First warn about cases involving unrecognised ABIs. */ 15595 if (!out_string && !in_string) 15596 /* xgettext:c-format */ 15597 _bfd_error_handler 15598 (_("warning: %pB uses unknown floating point ABI %d " 15599 "(set by %pB), %pB uses unknown floating point ABI %d"), 15600 obfd, out_fp, abi_fp_bfd, ibfd, in_fp); 15601 else if (!out_string) 15602 _bfd_error_handler 15603 /* xgettext:c-format */ 15604 (_("warning: %pB uses unknown floating point ABI %d " 15605 "(set by %pB), %pB uses %s"), 15606 obfd, out_fp, abi_fp_bfd, ibfd, in_string); 15607 else if (!in_string) 15608 _bfd_error_handler 15609 /* xgettext:c-format */ 15610 (_("warning: %pB uses %s (set by %pB), " 15611 "%pB uses unknown floating point ABI %d"), 15612 obfd, out_string, abi_fp_bfd, ibfd, in_fp); 15613 else 15614 { 15615 /* If one of the bfds is soft-float, the other must be 15616 hard-float. The exact choice of hard-float ABI isn't 15617 really relevant to the error message. */ 15618 if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT) 15619 out_string = "-mhard-float"; 15620 else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT) 15621 in_string = "-mhard-float"; 15622 _bfd_error_handler 15623 /* xgettext:c-format */ 15624 (_("warning: %pB uses %s (set by %pB), %pB uses %s"), 15625 obfd, out_string, abi_fp_bfd, ibfd, in_string); 15626 } 15627 } 15628 } 15629 15630 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge 15631 non-conflicting ones. */ 15632 if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i) 15633 { 15634 out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1; 15635 if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY) 15636 out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i; 15637 else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY) 15638 switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i) 15639 { 15640 case Val_GNU_MIPS_ABI_MSA_128: 15641 _bfd_error_handler 15642 /* xgettext:c-format */ 15643 (_("warning: %pB uses %s (set by %pB), " 15644 "%pB uses unknown MSA ABI %d"), 15645 obfd, "-mmsa", abi_msa_bfd, 15646 ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i); 15647 break; 15648 15649 default: 15650 switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i) 15651 { 15652 case Val_GNU_MIPS_ABI_MSA_128: 15653 _bfd_error_handler 15654 /* xgettext:c-format */ 15655 (_("warning: %pB uses unknown MSA ABI %d " 15656 "(set by %pB), %pB uses %s"), 15657 obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i, 15658 abi_msa_bfd, ibfd, "-mmsa"); 15659 break; 15660 15661 default: 15662 _bfd_error_handler 15663 /* xgettext:c-format */ 15664 (_("warning: %pB uses unknown MSA ABI %d " 15665 "(set by %pB), %pB uses unknown MSA ABI %d"), 15666 obfd, out_attr[Tag_GNU_MIPS_ABI_MSA].i, 15667 abi_msa_bfd, ibfd, in_attr[Tag_GNU_MIPS_ABI_MSA].i); 15668 break; 15669 } 15670 } 15671 } 15672 15673 /* Merge Tag_compatibility attributes and any common GNU ones. */ 15674 return _bfd_elf_merge_object_attributes (ibfd, info); 15675 } 15676 15677 /* Merge object ABI flags from IBFD into OBFD. Raise an error if 15678 there are conflicting settings. */ 15679 15680 static bfd_boolean 15681 mips_elf_merge_obj_abiflags (bfd *ibfd, bfd *obfd) 15682 { 15683 obj_attribute *out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 15684 struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd); 15685 struct mips_elf_obj_tdata *in_tdata = mips_elf_tdata (ibfd); 15686 15687 /* Update the output abiflags fp_abi using the computed fp_abi. */ 15688 out_tdata->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i; 15689 15690 #define max(a, b) ((a) > (b) ? (a) : (b)) 15691 /* Merge abiflags. */ 15692 out_tdata->abiflags.isa_level = max (out_tdata->abiflags.isa_level, 15693 in_tdata->abiflags.isa_level); 15694 out_tdata->abiflags.isa_rev = max (out_tdata->abiflags.isa_rev, 15695 in_tdata->abiflags.isa_rev); 15696 out_tdata->abiflags.gpr_size = max (out_tdata->abiflags.gpr_size, 15697 in_tdata->abiflags.gpr_size); 15698 out_tdata->abiflags.cpr1_size = max (out_tdata->abiflags.cpr1_size, 15699 in_tdata->abiflags.cpr1_size); 15700 out_tdata->abiflags.cpr2_size = max (out_tdata->abiflags.cpr2_size, 15701 in_tdata->abiflags.cpr2_size); 15702 #undef max 15703 out_tdata->abiflags.ases |= in_tdata->abiflags.ases; 15704 out_tdata->abiflags.flags1 |= in_tdata->abiflags.flags1; 15705 15706 return TRUE; 15707 } 15708 15709 /* Merge backend specific data from an object file to the output 15710 object file when linking. */ 15711 15712 bfd_boolean 15713 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 15714 { 15715 bfd *obfd = info->output_bfd; 15716 struct mips_elf_obj_tdata *out_tdata; 15717 struct mips_elf_obj_tdata *in_tdata; 15718 bfd_boolean null_input_bfd = TRUE; 15719 asection *sec; 15720 bfd_boolean ok; 15721 15722 /* Check if we have the same endianness. */ 15723 if (! _bfd_generic_verify_endian_match (ibfd, info)) 15724 { 15725 _bfd_error_handler 15726 (_("%pB: endianness incompatible with that of the selected emulation"), 15727 ibfd); 15728 return FALSE; 15729 } 15730 15731 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd)) 15732 return TRUE; 15733 15734 in_tdata = mips_elf_tdata (ibfd); 15735 out_tdata = mips_elf_tdata (obfd); 15736 15737 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0) 15738 { 15739 _bfd_error_handler 15740 (_("%pB: ABI is incompatible with that of the selected emulation"), 15741 ibfd); 15742 return FALSE; 15743 } 15744 15745 /* Check to see if the input BFD actually contains any sections. If not, 15746 then it has no attributes, and its flags may not have been initialized 15747 either, but it cannot actually cause any incompatibility. */ 15748 /* FIXME: This excludes any input shared library from consideration. */ 15749 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 15750 { 15751 /* Ignore synthetic sections and empty .text, .data and .bss sections 15752 which are automatically generated by gas. Also ignore fake 15753 (s)common sections, since merely defining a common symbol does 15754 not affect compatibility. */ 15755 if ((sec->flags & SEC_IS_COMMON) == 0 15756 && strcmp (sec->name, ".reginfo") 15757 && strcmp (sec->name, ".mdebug") 15758 && (sec->size != 0 15759 || (strcmp (sec->name, ".text") 15760 && strcmp (sec->name, ".data") 15761 && strcmp (sec->name, ".bss")))) 15762 { 15763 null_input_bfd = FALSE; 15764 break; 15765 } 15766 } 15767 if (null_input_bfd) 15768 return TRUE; 15769 15770 /* Populate abiflags using existing information. */ 15771 if (in_tdata->abiflags_valid) 15772 { 15773 obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 15774 Elf_Internal_ABIFlags_v0 in_abiflags; 15775 Elf_Internal_ABIFlags_v0 abiflags; 15776 15777 /* Set up the FP ABI attribute from the abiflags if it is not already 15778 set. */ 15779 if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY) 15780 in_attr[Tag_GNU_MIPS_ABI_FP].i = in_tdata->abiflags.fp_abi; 15781 15782 infer_mips_abiflags (ibfd, &abiflags); 15783 in_abiflags = in_tdata->abiflags; 15784 15785 /* It is not possible to infer the correct ISA revision 15786 for R3 or R5 so drop down to R2 for the checks. */ 15787 if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5) 15788 in_abiflags.isa_rev = 2; 15789 15790 if (LEVEL_REV (in_abiflags.isa_level, in_abiflags.isa_rev) 15791 < LEVEL_REV (abiflags.isa_level, abiflags.isa_rev)) 15792 _bfd_error_handler 15793 (_("%pB: warning: inconsistent ISA between e_flags and " 15794 ".MIPS.abiflags"), ibfd); 15795 if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY 15796 && in_abiflags.fp_abi != abiflags.fp_abi) 15797 _bfd_error_handler 15798 (_("%pB: warning: inconsistent FP ABI between .gnu.attributes and " 15799 ".MIPS.abiflags"), ibfd); 15800 if ((in_abiflags.ases & abiflags.ases) != abiflags.ases) 15801 _bfd_error_handler 15802 (_("%pB: warning: inconsistent ASEs between e_flags and " 15803 ".MIPS.abiflags"), ibfd); 15804 /* The isa_ext is allowed to be an extension of what can be inferred 15805 from e_flags. */ 15806 if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags.isa_ext), 15807 bfd_mips_isa_ext_mach (in_abiflags.isa_ext))) 15808 _bfd_error_handler 15809 (_("%pB: warning: inconsistent ISA extensions between e_flags and " 15810 ".MIPS.abiflags"), ibfd); 15811 if (in_abiflags.flags2 != 0) 15812 _bfd_error_handler 15813 (_("%pB: warning: unexpected flag in the flags2 field of " 15814 ".MIPS.abiflags (0x%lx)"), ibfd, 15815 in_abiflags.flags2); 15816 } 15817 else 15818 { 15819 infer_mips_abiflags (ibfd, &in_tdata->abiflags); 15820 in_tdata->abiflags_valid = TRUE; 15821 } 15822 15823 if (!out_tdata->abiflags_valid) 15824 { 15825 /* Copy input abiflags if output abiflags are not already valid. */ 15826 out_tdata->abiflags = in_tdata->abiflags; 15827 out_tdata->abiflags_valid = TRUE; 15828 } 15829 15830 if (! elf_flags_init (obfd)) 15831 { 15832 elf_flags_init (obfd) = TRUE; 15833 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 15834 elf_elfheader (obfd)->e_ident[EI_CLASS] 15835 = elf_elfheader (ibfd)->e_ident[EI_CLASS]; 15836 15837 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 15838 && (bfd_get_arch_info (obfd)->the_default 15839 || mips_mach_extends_p (bfd_get_mach (obfd), 15840 bfd_get_mach (ibfd)))) 15841 { 15842 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 15843 bfd_get_mach (ibfd))) 15844 return FALSE; 15845 15846 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */ 15847 update_mips_abiflags_isa (obfd, &out_tdata->abiflags); 15848 } 15849 15850 ok = TRUE; 15851 } 15852 else 15853 ok = mips_elf_merge_obj_e_flags (ibfd, info); 15854 15855 ok = mips_elf_merge_obj_attributes (ibfd, info) && ok; 15856 15857 ok = mips_elf_merge_obj_abiflags (ibfd, obfd) && ok; 15858 15859 if (!ok) 15860 { 15861 bfd_set_error (bfd_error_bad_value); 15862 return FALSE; 15863 } 15864 15865 return TRUE; 15866 } 15867 15868 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */ 15869 15870 bfd_boolean 15871 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags) 15872 { 15873 BFD_ASSERT (!elf_flags_init (abfd) 15874 || elf_elfheader (abfd)->e_flags == flags); 15875 15876 elf_elfheader (abfd)->e_flags = flags; 15877 elf_flags_init (abfd) = TRUE; 15878 return TRUE; 15879 } 15880 15881 char * 15882 _bfd_mips_elf_get_target_dtag (bfd_vma dtag) 15883 { 15884 switch (dtag) 15885 { 15886 default: return ""; 15887 case DT_MIPS_RLD_VERSION: 15888 return "MIPS_RLD_VERSION"; 15889 case DT_MIPS_TIME_STAMP: 15890 return "MIPS_TIME_STAMP"; 15891 case DT_MIPS_ICHECKSUM: 15892 return "MIPS_ICHECKSUM"; 15893 case DT_MIPS_IVERSION: 15894 return "MIPS_IVERSION"; 15895 case DT_MIPS_FLAGS: 15896 return "MIPS_FLAGS"; 15897 case DT_MIPS_BASE_ADDRESS: 15898 return "MIPS_BASE_ADDRESS"; 15899 case DT_MIPS_MSYM: 15900 return "MIPS_MSYM"; 15901 case DT_MIPS_CONFLICT: 15902 return "MIPS_CONFLICT"; 15903 case DT_MIPS_LIBLIST: 15904 return "MIPS_LIBLIST"; 15905 case DT_MIPS_LOCAL_GOTNO: 15906 return "MIPS_LOCAL_GOTNO"; 15907 case DT_MIPS_CONFLICTNO: 15908 return "MIPS_CONFLICTNO"; 15909 case DT_MIPS_LIBLISTNO: 15910 return "MIPS_LIBLISTNO"; 15911 case DT_MIPS_SYMTABNO: 15912 return "MIPS_SYMTABNO"; 15913 case DT_MIPS_UNREFEXTNO: 15914 return "MIPS_UNREFEXTNO"; 15915 case DT_MIPS_GOTSYM: 15916 return "MIPS_GOTSYM"; 15917 case DT_MIPS_HIPAGENO: 15918 return "MIPS_HIPAGENO"; 15919 case DT_MIPS_RLD_MAP: 15920 return "MIPS_RLD_MAP"; 15921 case DT_MIPS_RLD_MAP_REL: 15922 return "MIPS_RLD_MAP_REL"; 15923 case DT_MIPS_DELTA_CLASS: 15924 return "MIPS_DELTA_CLASS"; 15925 case DT_MIPS_DELTA_CLASS_NO: 15926 return "MIPS_DELTA_CLASS_NO"; 15927 case DT_MIPS_DELTA_INSTANCE: 15928 return "MIPS_DELTA_INSTANCE"; 15929 case DT_MIPS_DELTA_INSTANCE_NO: 15930 return "MIPS_DELTA_INSTANCE_NO"; 15931 case DT_MIPS_DELTA_RELOC: 15932 return "MIPS_DELTA_RELOC"; 15933 case DT_MIPS_DELTA_RELOC_NO: 15934 return "MIPS_DELTA_RELOC_NO"; 15935 case DT_MIPS_DELTA_SYM: 15936 return "MIPS_DELTA_SYM"; 15937 case DT_MIPS_DELTA_SYM_NO: 15938 return "MIPS_DELTA_SYM_NO"; 15939 case DT_MIPS_DELTA_CLASSSYM: 15940 return "MIPS_DELTA_CLASSSYM"; 15941 case DT_MIPS_DELTA_CLASSSYM_NO: 15942 return "MIPS_DELTA_CLASSSYM_NO"; 15943 case DT_MIPS_CXX_FLAGS: 15944 return "MIPS_CXX_FLAGS"; 15945 case DT_MIPS_PIXIE_INIT: 15946 return "MIPS_PIXIE_INIT"; 15947 case DT_MIPS_SYMBOL_LIB: 15948 return "MIPS_SYMBOL_LIB"; 15949 case DT_MIPS_LOCALPAGE_GOTIDX: 15950 return "MIPS_LOCALPAGE_GOTIDX"; 15951 case DT_MIPS_LOCAL_GOTIDX: 15952 return "MIPS_LOCAL_GOTIDX"; 15953 case DT_MIPS_HIDDEN_GOTIDX: 15954 return "MIPS_HIDDEN_GOTIDX"; 15955 case DT_MIPS_PROTECTED_GOTIDX: 15956 return "MIPS_PROTECTED_GOT_IDX"; 15957 case DT_MIPS_OPTIONS: 15958 return "MIPS_OPTIONS"; 15959 case DT_MIPS_INTERFACE: 15960 return "MIPS_INTERFACE"; 15961 case DT_MIPS_DYNSTR_ALIGN: 15962 return "DT_MIPS_DYNSTR_ALIGN"; 15963 case DT_MIPS_INTERFACE_SIZE: 15964 return "DT_MIPS_INTERFACE_SIZE"; 15965 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: 15966 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR"; 15967 case DT_MIPS_PERF_SUFFIX: 15968 return "DT_MIPS_PERF_SUFFIX"; 15969 case DT_MIPS_COMPACT_SIZE: 15970 return "DT_MIPS_COMPACT_SIZE"; 15971 case DT_MIPS_GP_VALUE: 15972 return "DT_MIPS_GP_VALUE"; 15973 case DT_MIPS_AUX_DYNAMIC: 15974 return "DT_MIPS_AUX_DYNAMIC"; 15975 case DT_MIPS_PLTGOT: 15976 return "DT_MIPS_PLTGOT"; 15977 case DT_MIPS_RWPLT: 15978 return "DT_MIPS_RWPLT"; 15979 case DT_MIPS_XHASH: 15980 return "DT_MIPS_XHASH"; 15981 } 15982 } 15983 15984 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if 15985 not known. */ 15986 15987 const char * 15988 _bfd_mips_fp_abi_string (int fp) 15989 { 15990 switch (fp) 15991 { 15992 /* These strings aren't translated because they're simply 15993 option lists. */ 15994 case Val_GNU_MIPS_ABI_FP_DOUBLE: 15995 return "-mdouble-float"; 15996 15997 case Val_GNU_MIPS_ABI_FP_SINGLE: 15998 return "-msingle-float"; 15999 16000 case Val_GNU_MIPS_ABI_FP_SOFT: 16001 return "-msoft-float"; 16002 16003 case Val_GNU_MIPS_ABI_FP_OLD_64: 16004 return _("-mips32r2 -mfp64 (12 callee-saved)"); 16005 16006 case Val_GNU_MIPS_ABI_FP_XX: 16007 return "-mfpxx"; 16008 16009 case Val_GNU_MIPS_ABI_FP_64: 16010 return "-mgp32 -mfp64"; 16011 16012 case Val_GNU_MIPS_ABI_FP_64A: 16013 return "-mgp32 -mfp64 -mno-odd-spreg"; 16014 16015 default: 16016 return 0; 16017 } 16018 } 16019 16020 static void 16021 print_mips_ases (FILE *file, unsigned int mask) 16022 { 16023 if (mask & AFL_ASE_DSP) 16024 fputs ("\n\tDSP ASE", file); 16025 if (mask & AFL_ASE_DSPR2) 16026 fputs ("\n\tDSP R2 ASE", file); 16027 if (mask & AFL_ASE_DSPR3) 16028 fputs ("\n\tDSP R3 ASE", file); 16029 if (mask & AFL_ASE_EVA) 16030 fputs ("\n\tEnhanced VA Scheme", file); 16031 if (mask & AFL_ASE_MCU) 16032 fputs ("\n\tMCU (MicroController) ASE", file); 16033 if (mask & AFL_ASE_MDMX) 16034 fputs ("\n\tMDMX ASE", file); 16035 if (mask & AFL_ASE_MIPS3D) 16036 fputs ("\n\tMIPS-3D ASE", file); 16037 if (mask & AFL_ASE_MT) 16038 fputs ("\n\tMT ASE", file); 16039 if (mask & AFL_ASE_SMARTMIPS) 16040 fputs ("\n\tSmartMIPS ASE", file); 16041 if (mask & AFL_ASE_VIRT) 16042 fputs ("\n\tVZ ASE", file); 16043 if (mask & AFL_ASE_MSA) 16044 fputs ("\n\tMSA ASE", file); 16045 if (mask & AFL_ASE_MIPS16) 16046 fputs ("\n\tMIPS16 ASE", file); 16047 if (mask & AFL_ASE_MICROMIPS) 16048 fputs ("\n\tMICROMIPS ASE", file); 16049 if (mask & AFL_ASE_XPA) 16050 fputs ("\n\tXPA ASE", file); 16051 if (mask & AFL_ASE_MIPS16E2) 16052 fputs ("\n\tMIPS16e2 ASE", file); 16053 if (mask & AFL_ASE_CRC) 16054 fputs ("\n\tCRC ASE", file); 16055 if (mask & AFL_ASE_GINV) 16056 fputs ("\n\tGINV ASE", file); 16057 if (mask & AFL_ASE_LOONGSON_MMI) 16058 fputs ("\n\tLoongson MMI ASE", file); 16059 if (mask & AFL_ASE_LOONGSON_CAM) 16060 fputs ("\n\tLoongson CAM ASE", file); 16061 if (mask & AFL_ASE_LOONGSON_EXT) 16062 fputs ("\n\tLoongson EXT ASE", file); 16063 if (mask & AFL_ASE_LOONGSON_EXT2) 16064 fputs ("\n\tLoongson EXT2 ASE", file); 16065 if (mask == 0) 16066 fprintf (file, "\n\t%s", _("None")); 16067 else if ((mask & ~AFL_ASE_MASK) != 0) 16068 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK); 16069 } 16070 16071 static void 16072 print_mips_isa_ext (FILE *file, unsigned int isa_ext) 16073 { 16074 switch (isa_ext) 16075 { 16076 case 0: 16077 fputs (_("None"), file); 16078 break; 16079 case AFL_EXT_XLR: 16080 fputs ("RMI XLR", file); 16081 break; 16082 case AFL_EXT_OCTEON3: 16083 fputs ("Cavium Networks Octeon3", file); 16084 break; 16085 case AFL_EXT_OCTEON2: 16086 fputs ("Cavium Networks Octeon2", file); 16087 break; 16088 case AFL_EXT_OCTEONP: 16089 fputs ("Cavium Networks OcteonP", file); 16090 break; 16091 case AFL_EXT_OCTEON: 16092 fputs ("Cavium Networks Octeon", file); 16093 break; 16094 case AFL_EXT_5900: 16095 fputs ("Toshiba R5900", file); 16096 break; 16097 case AFL_EXT_4650: 16098 fputs ("MIPS R4650", file); 16099 break; 16100 case AFL_EXT_4010: 16101 fputs ("LSI R4010", file); 16102 break; 16103 case AFL_EXT_4100: 16104 fputs ("NEC VR4100", file); 16105 break; 16106 case AFL_EXT_3900: 16107 fputs ("Toshiba R3900", file); 16108 break; 16109 case AFL_EXT_10000: 16110 fputs ("MIPS R10000", file); 16111 break; 16112 case AFL_EXT_SB1: 16113 fputs ("Broadcom SB-1", file); 16114 break; 16115 case AFL_EXT_4111: 16116 fputs ("NEC VR4111/VR4181", file); 16117 break; 16118 case AFL_EXT_4120: 16119 fputs ("NEC VR4120", file); 16120 break; 16121 case AFL_EXT_5400: 16122 fputs ("NEC VR5400", file); 16123 break; 16124 case AFL_EXT_5500: 16125 fputs ("NEC VR5500", file); 16126 break; 16127 case AFL_EXT_LOONGSON_2E: 16128 fputs ("ST Microelectronics Loongson 2E", file); 16129 break; 16130 case AFL_EXT_LOONGSON_2F: 16131 fputs ("ST Microelectronics Loongson 2F", file); 16132 break; 16133 case AFL_EXT_INTERAPTIV_MR2: 16134 fputs ("Imagination interAptiv MR2", file); 16135 break; 16136 default: 16137 fprintf (file, "%s (%d)", _("Unknown"), isa_ext); 16138 break; 16139 } 16140 } 16141 16142 static void 16143 print_mips_fp_abi_value (FILE *file, int val) 16144 { 16145 switch (val) 16146 { 16147 case Val_GNU_MIPS_ABI_FP_ANY: 16148 fprintf (file, _("Hard or soft float\n")); 16149 break; 16150 case Val_GNU_MIPS_ABI_FP_DOUBLE: 16151 fprintf (file, _("Hard float (double precision)\n")); 16152 break; 16153 case Val_GNU_MIPS_ABI_FP_SINGLE: 16154 fprintf (file, _("Hard float (single precision)\n")); 16155 break; 16156 case Val_GNU_MIPS_ABI_FP_SOFT: 16157 fprintf (file, _("Soft float\n")); 16158 break; 16159 case Val_GNU_MIPS_ABI_FP_OLD_64: 16160 fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n")); 16161 break; 16162 case Val_GNU_MIPS_ABI_FP_XX: 16163 fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n")); 16164 break; 16165 case Val_GNU_MIPS_ABI_FP_64: 16166 fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n")); 16167 break; 16168 case Val_GNU_MIPS_ABI_FP_64A: 16169 fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n")); 16170 break; 16171 default: 16172 fprintf (file, "??? (%d)\n", val); 16173 break; 16174 } 16175 } 16176 16177 static int 16178 get_mips_reg_size (int reg_size) 16179 { 16180 return (reg_size == AFL_REG_NONE) ? 0 16181 : (reg_size == AFL_REG_32) ? 32 16182 : (reg_size == AFL_REG_64) ? 64 16183 : (reg_size == AFL_REG_128) ? 128 16184 : -1; 16185 } 16186 16187 bfd_boolean 16188 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr) 16189 { 16190 FILE *file = ptr; 16191 16192 BFD_ASSERT (abfd != NULL && ptr != NULL); 16193 16194 /* Print normal ELF private data. */ 16195 _bfd_elf_print_private_bfd_data (abfd, ptr); 16196 16197 /* xgettext:c-format */ 16198 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 16199 16200 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32) 16201 fprintf (file, _(" [abi=O32]")); 16202 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64) 16203 fprintf (file, _(" [abi=O64]")); 16204 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32) 16205 fprintf (file, _(" [abi=EABI32]")); 16206 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64) 16207 fprintf (file, _(" [abi=EABI64]")); 16208 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI)) 16209 fprintf (file, _(" [abi unknown]")); 16210 else if (ABI_N32_P (abfd)) 16211 fprintf (file, _(" [abi=N32]")); 16212 else if (ABI_64_P (abfd)) 16213 fprintf (file, _(" [abi=64]")); 16214 else 16215 fprintf (file, _(" [no abi set]")); 16216 16217 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1) 16218 fprintf (file, " [mips1]"); 16219 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2) 16220 fprintf (file, " [mips2]"); 16221 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3) 16222 fprintf (file, " [mips3]"); 16223 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4) 16224 fprintf (file, " [mips4]"); 16225 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5) 16226 fprintf (file, " [mips5]"); 16227 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32) 16228 fprintf (file, " [mips32]"); 16229 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64) 16230 fprintf (file, " [mips64]"); 16231 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2) 16232 fprintf (file, " [mips32r2]"); 16233 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2) 16234 fprintf (file, " [mips64r2]"); 16235 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6) 16236 fprintf (file, " [mips32r6]"); 16237 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6) 16238 fprintf (file, " [mips64r6]"); 16239 else 16240 fprintf (file, _(" [unknown ISA]")); 16241 16242 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX) 16243 fprintf (file, " [mdmx]"); 16244 16245 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16) 16246 fprintf (file, " [mips16]"); 16247 16248 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) 16249 fprintf (file, " [micromips]"); 16250 16251 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008) 16252 fprintf (file, " [nan2008]"); 16253 16254 if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64) 16255 fprintf (file, " [old fp64]"); 16256 16257 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE) 16258 fprintf (file, " [32bitmode]"); 16259 else 16260 fprintf (file, _(" [not 32bitmode]")); 16261 16262 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER) 16263 fprintf (file, " [noreorder]"); 16264 16265 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) 16266 fprintf (file, " [PIC]"); 16267 16268 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC) 16269 fprintf (file, " [CPIC]"); 16270 16271 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT) 16272 fprintf (file, " [XGOT]"); 16273 16274 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE) 16275 fprintf (file, " [UCODE]"); 16276 16277 fputc ('\n', file); 16278 16279 if (mips_elf_tdata (abfd)->abiflags_valid) 16280 { 16281 Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags; 16282 fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version); 16283 fprintf (file, "\nISA: MIPS%d", abiflags->isa_level); 16284 if (abiflags->isa_rev > 1) 16285 fprintf (file, "r%d", abiflags->isa_rev); 16286 fprintf (file, "\nGPR size: %d", 16287 get_mips_reg_size (abiflags->gpr_size)); 16288 fprintf (file, "\nCPR1 size: %d", 16289 get_mips_reg_size (abiflags->cpr1_size)); 16290 fprintf (file, "\nCPR2 size: %d", 16291 get_mips_reg_size (abiflags->cpr2_size)); 16292 fputs ("\nFP ABI: ", file); 16293 print_mips_fp_abi_value (file, abiflags->fp_abi); 16294 fputs ("ISA Extension: ", file); 16295 print_mips_isa_ext (file, abiflags->isa_ext); 16296 fputs ("\nASEs:", file); 16297 print_mips_ases (file, abiflags->ases); 16298 fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1); 16299 fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2); 16300 fputc ('\n', file); 16301 } 16302 16303 return TRUE; 16304 } 16305 16306 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] = 16307 { 16308 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 16309 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 16310 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 }, 16311 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 16312 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 16313 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 }, 16314 { STRING_COMMA_LEN (".MIPS.xhash"), 0, SHT_MIPS_XHASH, SHF_ALLOC }, 16315 { NULL, 0, 0, 0, 0 } 16316 }; 16317 16318 /* Merge non visibility st_other attributes. Ensure that the 16319 STO_OPTIONAL flag is copied into h->other, even if this is not a 16320 definiton of the symbol. */ 16321 void 16322 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, 16323 const Elf_Internal_Sym *isym, 16324 bfd_boolean definition, 16325 bfd_boolean dynamic ATTRIBUTE_UNUSED) 16326 { 16327 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0) 16328 { 16329 unsigned char other; 16330 16331 other = (definition ? isym->st_other : h->other); 16332 other &= ~ELF_ST_VISIBILITY (-1); 16333 h->other = other | ELF_ST_VISIBILITY (h->other); 16334 } 16335 16336 if (!definition 16337 && ELF_MIPS_IS_OPTIONAL (isym->st_other)) 16338 h->other |= STO_OPTIONAL; 16339 } 16340 16341 /* Decide whether an undefined symbol is special and can be ignored. 16342 This is the case for OPTIONAL symbols on IRIX. */ 16343 bfd_boolean 16344 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h) 16345 { 16346 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE; 16347 } 16348 16349 bfd_boolean 16350 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym) 16351 { 16352 return (sym->st_shndx == SHN_COMMON 16353 || sym->st_shndx == SHN_MIPS_ACOMMON 16354 || sym->st_shndx == SHN_MIPS_SCOMMON); 16355 } 16356 16357 /* Return address for Ith PLT stub in section PLT, for relocation REL 16358 or (bfd_vma) -1 if it should not be included. */ 16359 16360 bfd_vma 16361 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt, 16362 const arelent *rel ATTRIBUTE_UNUSED) 16363 { 16364 return (plt->vma 16365 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry) 16366 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry)); 16367 } 16368 16369 /* Build a table of synthetic symbols to represent the PLT. As with MIPS16 16370 and microMIPS PLT slots we may have a many-to-one mapping between .plt 16371 and .got.plt and also the slots may be of a different size each we walk 16372 the PLT manually fetching instructions and matching them against known 16373 patterns. To make things easier standard MIPS slots, if any, always come 16374 first. As we don't create proper ELF symbols we use the UDATA.I member 16375 of ASYMBOL to carry ISA annotation. The encoding used is the same as 16376 with the ST_OTHER member of the ELF symbol. */ 16377 16378 long 16379 _bfd_mips_elf_get_synthetic_symtab (bfd *abfd, 16380 long symcount ATTRIBUTE_UNUSED, 16381 asymbol **syms ATTRIBUTE_UNUSED, 16382 long dynsymcount, asymbol **dynsyms, 16383 asymbol **ret) 16384 { 16385 static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_"; 16386 static const char microsuffix[] = "@micromipsplt"; 16387 static const char m16suffix[] = "@mips16plt"; 16388 static const char mipssuffix[] = "@plt"; 16389 16390 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 16391 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 16392 bfd_boolean micromips_p = MICROMIPS_P (abfd); 16393 Elf_Internal_Shdr *hdr; 16394 bfd_byte *plt_data; 16395 bfd_vma plt_offset; 16396 unsigned int other; 16397 bfd_vma entry_size; 16398 bfd_vma plt0_size; 16399 asection *relplt; 16400 bfd_vma opcode; 16401 asection *plt; 16402 asymbol *send; 16403 size_t size; 16404 char *names; 16405 long counti; 16406 arelent *p; 16407 asymbol *s; 16408 char *nend; 16409 long count; 16410 long pi; 16411 long i; 16412 long n; 16413 16414 *ret = NULL; 16415 16416 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0) 16417 return 0; 16418 16419 relplt = bfd_get_section_by_name (abfd, ".rel.plt"); 16420 if (relplt == NULL) 16421 return 0; 16422 16423 hdr = &elf_section_data (relplt)->this_hdr; 16424 if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL) 16425 return 0; 16426 16427 plt = bfd_get_section_by_name (abfd, ".plt"); 16428 if (plt == NULL) 16429 return 0; 16430 16431 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 16432 if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE)) 16433 return -1; 16434 p = relplt->relocation; 16435 16436 /* Calculating the exact amount of space required for symbols would 16437 require two passes over the PLT, so just pessimise assuming two 16438 PLT slots per relocation. */ 16439 count = relplt->size / hdr->sh_entsize; 16440 counti = count * bed->s->int_rels_per_ext_rel; 16441 size = 2 * count * sizeof (asymbol); 16442 size += count * (sizeof (mipssuffix) + 16443 (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix))); 16444 for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel) 16445 size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name); 16446 16447 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */ 16448 size += sizeof (asymbol) + sizeof (pltname); 16449 16450 if (!bfd_malloc_and_get_section (abfd, plt, &plt_data)) 16451 return -1; 16452 16453 if (plt->size < 16) 16454 return -1; 16455 16456 s = *ret = bfd_malloc (size); 16457 if (s == NULL) 16458 return -1; 16459 send = s + 2 * count + 1; 16460 16461 names = (char *) send; 16462 nend = (char *) s + size; 16463 n = 0; 16464 16465 opcode = bfd_get_micromips_32 (abfd, plt_data + 12); 16466 if (opcode == 0x3302fffe) 16467 { 16468 if (!micromips_p) 16469 return -1; 16470 plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry); 16471 other = STO_MICROMIPS; 16472 } 16473 else if (opcode == 0x0398c1d0) 16474 { 16475 if (!micromips_p) 16476 return -1; 16477 plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); 16478 other = STO_MICROMIPS; 16479 } 16480 else 16481 { 16482 plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry); 16483 other = 0; 16484 } 16485 16486 s->the_bfd = abfd; 16487 s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL; 16488 s->section = plt; 16489 s->value = 0; 16490 s->name = names; 16491 s->udata.i = other; 16492 memcpy (names, pltname, sizeof (pltname)); 16493 names += sizeof (pltname); 16494 ++s, ++n; 16495 16496 pi = 0; 16497 for (plt_offset = plt0_size; 16498 plt_offset + 8 <= plt->size && s < send; 16499 plt_offset += entry_size) 16500 { 16501 bfd_vma gotplt_addr; 16502 const char *suffix; 16503 bfd_vma gotplt_hi; 16504 bfd_vma gotplt_lo; 16505 size_t suffixlen; 16506 16507 opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4); 16508 16509 /* Check if the second word matches the expected MIPS16 instruction. */ 16510 if (opcode == 0x651aeb00) 16511 { 16512 if (micromips_p) 16513 return -1; 16514 /* Truncated table??? */ 16515 if (plt_offset + 16 > plt->size) 16516 break; 16517 gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12); 16518 entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry); 16519 suffixlen = sizeof (m16suffix); 16520 suffix = m16suffix; 16521 other = STO_MIPS16; 16522 } 16523 /* Likewise the expected microMIPS instruction (no insn32 mode). */ 16524 else if (opcode == 0xff220000) 16525 { 16526 if (!micromips_p) 16527 return -1; 16528 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f; 16529 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff; 16530 gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18; 16531 gotplt_lo <<= 2; 16532 gotplt_addr = gotplt_hi + gotplt_lo; 16533 gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3; 16534 entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry); 16535 suffixlen = sizeof (microsuffix); 16536 suffix = microsuffix; 16537 other = STO_MICROMIPS; 16538 } 16539 /* Likewise the expected microMIPS instruction (insn32 mode). */ 16540 else if ((opcode & 0xffff0000) == 0xff2f0000) 16541 { 16542 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff; 16543 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff; 16544 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16; 16545 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000; 16546 gotplt_addr = gotplt_hi + gotplt_lo; 16547 entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry); 16548 suffixlen = sizeof (microsuffix); 16549 suffix = microsuffix; 16550 other = STO_MICROMIPS; 16551 } 16552 /* Otherwise assume standard MIPS code. */ 16553 else 16554 { 16555 gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff; 16556 gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff; 16557 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16; 16558 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000; 16559 gotplt_addr = gotplt_hi + gotplt_lo; 16560 entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry); 16561 suffixlen = sizeof (mipssuffix); 16562 suffix = mipssuffix; 16563 other = 0; 16564 } 16565 /* Truncated table??? */ 16566 if (plt_offset + entry_size > plt->size) 16567 break; 16568 16569 for (i = 0; 16570 i < count && p[pi].address != gotplt_addr; 16571 i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti); 16572 16573 if (i < count) 16574 { 16575 size_t namelen; 16576 size_t len; 16577 16578 *s = **p[pi].sym_ptr_ptr; 16579 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 16580 we are defining a symbol, ensure one of them is set. */ 16581 if ((s->flags & BSF_LOCAL) == 0) 16582 s->flags |= BSF_GLOBAL; 16583 s->flags |= BSF_SYNTHETIC; 16584 s->section = plt; 16585 s->value = plt_offset; 16586 s->name = names; 16587 s->udata.i = other; 16588 16589 len = strlen ((*p[pi].sym_ptr_ptr)->name); 16590 namelen = len + suffixlen; 16591 if (names + namelen > nend) 16592 break; 16593 16594 memcpy (names, (*p[pi].sym_ptr_ptr)->name, len); 16595 names += len; 16596 memcpy (names, suffix, suffixlen); 16597 names += suffixlen; 16598 16599 ++s, ++n; 16600 pi = (pi + bed->s->int_rels_per_ext_rel) % counti; 16601 } 16602 } 16603 16604 free (plt_data); 16605 16606 return n; 16607 } 16608 16609 /* Return the ABI flags associated with ABFD if available. */ 16610 16611 Elf_Internal_ABIFlags_v0 * 16612 bfd_mips_elf_get_abiflags (bfd *abfd) 16613 { 16614 struct mips_elf_obj_tdata *tdata = mips_elf_tdata (abfd); 16615 16616 return tdata->abiflags_valid ? &tdata->abiflags : NULL; 16617 } 16618 16619 /* MIPS libc ABI versions, used with the EI_ABIVERSION ELF file header 16620 field. Taken from `libc-abis.h' generated at GNU libc build time. 16621 Using a MIPS_ prefix as other libc targets use different values. */ 16622 enum 16623 { 16624 MIPS_LIBC_ABI_DEFAULT = 0, 16625 MIPS_LIBC_ABI_MIPS_PLT, 16626 MIPS_LIBC_ABI_UNIQUE, 16627 MIPS_LIBC_ABI_MIPS_O32_FP64, 16628 MIPS_LIBC_ABI_ABSOLUTE, 16629 MIPS_LIBC_ABI_XHASH, 16630 MIPS_LIBC_ABI_MAX 16631 }; 16632 16633 bfd_boolean 16634 _bfd_mips_init_file_header (bfd *abfd, struct bfd_link_info *link_info) 16635 { 16636 struct mips_elf_link_hash_table *htab = NULL; 16637 Elf_Internal_Ehdr *i_ehdrp; 16638 16639 if (!_bfd_elf_init_file_header (abfd, link_info)) 16640 return FALSE; 16641 16642 i_ehdrp = elf_elfheader (abfd); 16643 if (link_info) 16644 { 16645 htab = mips_elf_hash_table (link_info); 16646 BFD_ASSERT (htab != NULL); 16647 } 16648 16649 if (htab != NULL 16650 && htab->use_plts_and_copy_relocs 16651 && htab->root.target_os != is_vxworks) 16652 i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_MIPS_PLT; 16653 16654 if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64 16655 || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A) 16656 i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_MIPS_O32_FP64; 16657 16658 /* Mark that we need support for absolute symbols in the dynamic loader. */ 16659 if (htab != NULL && htab->use_absolute_zero && htab->gnu_target) 16660 i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_ABSOLUTE; 16661 16662 /* Mark that we need support for .MIPS.xhash in the dynamic linker, 16663 if it is the only hash section that will be created. */ 16664 if (link_info && link_info->emit_gnu_hash && !link_info->emit_hash) 16665 i_ehdrp->e_ident[EI_ABIVERSION] = MIPS_LIBC_ABI_XHASH; 16666 return TRUE; 16667 } 16668 16669 int 16670 _bfd_mips_elf_compact_eh_encoding 16671 (struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 16672 { 16673 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 16674 } 16675 16676 /* Return the opcode for can't unwind. */ 16677 16678 int 16679 _bfd_mips_elf_cant_unwind_opcode 16680 (struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 16681 { 16682 return COMPACT_EH_CANT_UNWIND_OPCODE; 16683 } 16684 16685 /* Record a position XLAT_LOC in the xlat translation table, associated with 16686 the hash entry H. The entry in the translation table will later be 16687 populated with the real symbol dynindx. */ 16688 16689 void 16690 _bfd_mips_elf_record_xhash_symbol (struct elf_link_hash_entry *h, 16691 bfd_vma xlat_loc) 16692 { 16693 struct mips_elf_link_hash_entry *hmips; 16694 16695 hmips = (struct mips_elf_link_hash_entry *) h; 16696 hmips->mipsxhash_loc = xlat_loc; 16697 } 16698