1// mips.cc -- mips target support for gold. 2 3// Copyright (C) 2011-2017 Free Software Foundation, Inc. 4// Written by Sasa Stankovic <sasa.stankovic@imgtec.com> 5// and Aleksandar Simeonov <aleksandar.simeonov@rt-rk.com>. 6// This file contains borrowed and adapted code from bfd/elfxx-mips.c. 7 8// This file is part of gold. 9 10// This program is free software; you can redistribute it and/or modify 11// it under the terms of the GNU General Public License as published by 12// the Free Software Foundation; either version 3 of the License, or 13// (at your option) any later version. 14 15// This program is distributed in the hope that it will be useful, 16// but WITHOUT ANY WARRANTY; without even the implied warranty of 17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18// GNU General Public License for more details. 19 20// You should have received a copy of the GNU General Public License 21// along with this program; if not, write to the Free Software 22// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 23// MA 02110-1301, USA. 24 25#include "gold.h" 26 27#include <algorithm> 28#include <set> 29#include <sstream> 30#include "demangle.h" 31 32#include "elfcpp.h" 33#include "parameters.h" 34#include "reloc.h" 35#include "mips.h" 36#include "object.h" 37#include "symtab.h" 38#include "layout.h" 39#include "output.h" 40#include "copy-relocs.h" 41#include "target.h" 42#include "target-reloc.h" 43#include "target-select.h" 44#include "tls.h" 45#include "errors.h" 46#include "gc.h" 47#include "attributes.h" 48#include "nacl.h" 49 50namespace 51{ 52using namespace gold; 53 54template<int size, bool big_endian> 55class Mips_output_data_plt; 56 57template<int size, bool big_endian> 58class Mips_output_data_got; 59 60template<int size, bool big_endian> 61class Target_mips; 62 63template<int size, bool big_endian> 64class Mips_output_section_reginfo; 65 66template<int size, bool big_endian> 67class Mips_output_data_la25_stub; 68 69template<int size, bool big_endian> 70class Mips_output_data_mips_stubs; 71 72template<int size> 73class Mips_symbol; 74 75template<int size, bool big_endian> 76class Mips_got_info; 77 78template<int size, bool big_endian> 79class Mips_relobj; 80 81class Mips16_stub_section_base; 82 83template<int size, bool big_endian> 84class Mips16_stub_section; 85 86// The ABI says that every symbol used by dynamic relocations must have 87// a global GOT entry. Among other things, this provides the dynamic 88// linker with a free, directly-indexed cache. The GOT can therefore 89// contain symbols that are not referenced by GOT relocations themselves 90// (in other words, it may have symbols that are not referenced by things 91// like R_MIPS_GOT16 and R_MIPS_GOT_PAGE). 92 93// GOT relocations are less likely to overflow if we put the associated 94// GOT entries towards the beginning. We therefore divide the global 95// GOT entries into two areas: "normal" and "reloc-only". Entries in 96// the first area can be used for both dynamic relocations and GP-relative 97// accesses, while those in the "reloc-only" area are for dynamic 98// relocations only. 99 100// These GGA_* ("Global GOT Area") values are organised so that lower 101// values are more general than higher values. Also, non-GGA_NONE 102// values are ordered by the position of the area in the GOT. 103 104enum Global_got_area 105{ 106 GGA_NORMAL = 0, 107 GGA_RELOC_ONLY = 1, 108 GGA_NONE = 2 109}; 110 111// The types of GOT entries needed for this platform. 112// These values are exposed to the ABI in an incremental link. 113// Do not renumber existing values without changing the version 114// number of the .gnu_incremental_inputs section. 115enum Got_type 116{ 117 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol 118 GOT_TYPE_TLS_OFFSET = 1, // GOT entry for TLS offset 119 GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair 120 121 // GOT entries for multi-GOT. We support up to 1024 GOTs in multi-GOT links. 122 GOT_TYPE_STANDARD_MULTIGOT = 3, 123 GOT_TYPE_TLS_OFFSET_MULTIGOT = GOT_TYPE_STANDARD_MULTIGOT + 1024, 124 GOT_TYPE_TLS_PAIR_MULTIGOT = GOT_TYPE_TLS_OFFSET_MULTIGOT + 1024 125}; 126 127// TLS type of GOT entry. 128enum Got_tls_type 129{ 130 GOT_TLS_NONE = 0, 131 GOT_TLS_GD = 1, 132 GOT_TLS_LDM = 2, 133 GOT_TLS_IE = 4 134}; 135 136// Values found in the r_ssym field of a relocation entry. 137enum Special_relocation_symbol 138{ 139 RSS_UNDEF = 0, // None - value is zero. 140 RSS_GP = 1, // Value of GP. 141 RSS_GP0 = 2, // Value of GP in object being relocated. 142 RSS_LOC = 3 // Address of location being relocated. 143}; 144 145// Whether the section is readonly. 146static inline bool 147is_readonly_section(Output_section* output_section) 148{ 149 elfcpp::Elf_Xword section_flags = output_section->flags(); 150 elfcpp::Elf_Word section_type = output_section->type(); 151 152 if (section_type == elfcpp::SHT_NOBITS) 153 return false; 154 155 if (section_flags & elfcpp::SHF_WRITE) 156 return false; 157 158 return true; 159} 160 161// Return TRUE if a relocation of type R_TYPE from OBJECT might 162// require an la25 stub. See also local_pic_function, which determines 163// whether the destination function ever requires a stub. 164template<int size, bool big_endian> 165static inline bool 166relocation_needs_la25_stub(Mips_relobj<size, big_endian>* object, 167 unsigned int r_type, bool target_is_16_bit_code) 168{ 169 // We specifically ignore branches and jumps from EF_PIC objects, 170 // where the onus is on the compiler or programmer to perform any 171 // necessary initialization of $25. Sometimes such initialization 172 // is unnecessary; for example, -mno-shared functions do not use 173 // the incoming value of $25, and may therefore be called directly. 174 if (object->is_pic()) 175 return false; 176 177 switch (r_type) 178 { 179 case elfcpp::R_MIPS_26: 180 case elfcpp::R_MIPS_PC16: 181 case elfcpp::R_MIPS_PC21_S2: 182 case elfcpp::R_MIPS_PC26_S2: 183 case elfcpp::R_MICROMIPS_26_S1: 184 case elfcpp::R_MICROMIPS_PC7_S1: 185 case elfcpp::R_MICROMIPS_PC10_S1: 186 case elfcpp::R_MICROMIPS_PC16_S1: 187 case elfcpp::R_MICROMIPS_PC23_S2: 188 return true; 189 190 case elfcpp::R_MIPS16_26: 191 return !target_is_16_bit_code; 192 193 default: 194 return false; 195 } 196} 197 198// Return true if SYM is a locally-defined PIC function, in the sense 199// that it or its fn_stub might need $25 to be valid on entry. 200// Note that MIPS16 functions set up $gp using PC-relative instructions, 201// so they themselves never need $25 to be valid. Only non-MIPS16 202// entry points are of interest here. 203template<int size, bool big_endian> 204static inline bool 205local_pic_function(Mips_symbol<size>* sym) 206{ 207 bool def_regular = (sym->source() == Symbol::FROM_OBJECT 208 && !sym->object()->is_dynamic() 209 && !sym->is_undefined()); 210 211 if (sym->is_defined() && def_regular) 212 { 213 Mips_relobj<size, big_endian>* object = 214 static_cast<Mips_relobj<size, big_endian>*>(sym->object()); 215 216 if ((object->is_pic() || sym->is_pic()) 217 && (!sym->is_mips16() 218 || (sym->has_mips16_fn_stub() && sym->need_fn_stub()))) 219 return true; 220 } 221 return false; 222} 223 224static inline bool 225hi16_reloc(int r_type) 226{ 227 return (r_type == elfcpp::R_MIPS_HI16 228 || r_type == elfcpp::R_MIPS16_HI16 229 || r_type == elfcpp::R_MICROMIPS_HI16 230 || r_type == elfcpp::R_MIPS_PCHI16); 231} 232 233static inline bool 234lo16_reloc(int r_type) 235{ 236 return (r_type == elfcpp::R_MIPS_LO16 237 || r_type == elfcpp::R_MIPS16_LO16 238 || r_type == elfcpp::R_MICROMIPS_LO16 239 || r_type == elfcpp::R_MIPS_PCLO16); 240} 241 242static inline bool 243got16_reloc(unsigned int r_type) 244{ 245 return (r_type == elfcpp::R_MIPS_GOT16 246 || r_type == elfcpp::R_MIPS16_GOT16 247 || r_type == elfcpp::R_MICROMIPS_GOT16); 248} 249 250static inline bool 251call_lo16_reloc(unsigned int r_type) 252{ 253 return (r_type == elfcpp::R_MIPS_CALL_LO16 254 || r_type == elfcpp::R_MICROMIPS_CALL_LO16); 255} 256 257static inline bool 258got_lo16_reloc(unsigned int r_type) 259{ 260 return (r_type == elfcpp::R_MIPS_GOT_LO16 261 || r_type == elfcpp::R_MICROMIPS_GOT_LO16); 262} 263 264static inline bool 265eh_reloc(unsigned int r_type) 266{ 267 return (r_type == elfcpp::R_MIPS_EH); 268} 269 270static inline bool 271got_disp_reloc(unsigned int r_type) 272{ 273 return (r_type == elfcpp::R_MIPS_GOT_DISP 274 || r_type == elfcpp::R_MICROMIPS_GOT_DISP); 275} 276 277static inline bool 278got_page_reloc(unsigned int r_type) 279{ 280 return (r_type == elfcpp::R_MIPS_GOT_PAGE 281 || r_type == elfcpp::R_MICROMIPS_GOT_PAGE); 282} 283 284static inline bool 285tls_gd_reloc(unsigned int r_type) 286{ 287 return (r_type == elfcpp::R_MIPS_TLS_GD 288 || r_type == elfcpp::R_MIPS16_TLS_GD 289 || r_type == elfcpp::R_MICROMIPS_TLS_GD); 290} 291 292static inline bool 293tls_gottprel_reloc(unsigned int r_type) 294{ 295 return (r_type == elfcpp::R_MIPS_TLS_GOTTPREL 296 || r_type == elfcpp::R_MIPS16_TLS_GOTTPREL 297 || r_type == elfcpp::R_MICROMIPS_TLS_GOTTPREL); 298} 299 300static inline bool 301tls_ldm_reloc(unsigned int r_type) 302{ 303 return (r_type == elfcpp::R_MIPS_TLS_LDM 304 || r_type == elfcpp::R_MIPS16_TLS_LDM 305 || r_type == elfcpp::R_MICROMIPS_TLS_LDM); 306} 307 308static inline bool 309mips16_call_reloc(unsigned int r_type) 310{ 311 return (r_type == elfcpp::R_MIPS16_26 312 || r_type == elfcpp::R_MIPS16_CALL16); 313} 314 315static inline bool 316jal_reloc(unsigned int r_type) 317{ 318 return (r_type == elfcpp::R_MIPS_26 319 || r_type == elfcpp::R_MIPS16_26 320 || r_type == elfcpp::R_MICROMIPS_26_S1); 321} 322 323static inline bool 324micromips_branch_reloc(unsigned int r_type) 325{ 326 return (r_type == elfcpp::R_MICROMIPS_26_S1 327 || r_type == elfcpp::R_MICROMIPS_PC16_S1 328 || r_type == elfcpp::R_MICROMIPS_PC10_S1 329 || r_type == elfcpp::R_MICROMIPS_PC7_S1); 330} 331 332// Check if R_TYPE is a MIPS16 reloc. 333static inline bool 334mips16_reloc(unsigned int r_type) 335{ 336 switch (r_type) 337 { 338 case elfcpp::R_MIPS16_26: 339 case elfcpp::R_MIPS16_GPREL: 340 case elfcpp::R_MIPS16_GOT16: 341 case elfcpp::R_MIPS16_CALL16: 342 case elfcpp::R_MIPS16_HI16: 343 case elfcpp::R_MIPS16_LO16: 344 case elfcpp::R_MIPS16_TLS_GD: 345 case elfcpp::R_MIPS16_TLS_LDM: 346 case elfcpp::R_MIPS16_TLS_DTPREL_HI16: 347 case elfcpp::R_MIPS16_TLS_DTPREL_LO16: 348 case elfcpp::R_MIPS16_TLS_GOTTPREL: 349 case elfcpp::R_MIPS16_TLS_TPREL_HI16: 350 case elfcpp::R_MIPS16_TLS_TPREL_LO16: 351 return true; 352 353 default: 354 return false; 355 } 356} 357 358// Check if R_TYPE is a microMIPS reloc. 359static inline bool 360micromips_reloc(unsigned int r_type) 361{ 362 switch (r_type) 363 { 364 case elfcpp::R_MICROMIPS_26_S1: 365 case elfcpp::R_MICROMIPS_HI16: 366 case elfcpp::R_MICROMIPS_LO16: 367 case elfcpp::R_MICROMIPS_GPREL16: 368 case elfcpp::R_MICROMIPS_LITERAL: 369 case elfcpp::R_MICROMIPS_GOT16: 370 case elfcpp::R_MICROMIPS_PC7_S1: 371 case elfcpp::R_MICROMIPS_PC10_S1: 372 case elfcpp::R_MICROMIPS_PC16_S1: 373 case elfcpp::R_MICROMIPS_CALL16: 374 case elfcpp::R_MICROMIPS_GOT_DISP: 375 case elfcpp::R_MICROMIPS_GOT_PAGE: 376 case elfcpp::R_MICROMIPS_GOT_OFST: 377 case elfcpp::R_MICROMIPS_GOT_HI16: 378 case elfcpp::R_MICROMIPS_GOT_LO16: 379 case elfcpp::R_MICROMIPS_SUB: 380 case elfcpp::R_MICROMIPS_HIGHER: 381 case elfcpp::R_MICROMIPS_HIGHEST: 382 case elfcpp::R_MICROMIPS_CALL_HI16: 383 case elfcpp::R_MICROMIPS_CALL_LO16: 384 case elfcpp::R_MICROMIPS_SCN_DISP: 385 case elfcpp::R_MICROMIPS_JALR: 386 case elfcpp::R_MICROMIPS_HI0_LO16: 387 case elfcpp::R_MICROMIPS_TLS_GD: 388 case elfcpp::R_MICROMIPS_TLS_LDM: 389 case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16: 390 case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16: 391 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 392 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16: 393 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16: 394 case elfcpp::R_MICROMIPS_GPREL7_S2: 395 case elfcpp::R_MICROMIPS_PC23_S2: 396 return true; 397 398 default: 399 return false; 400 } 401} 402 403static inline bool 404is_matching_lo16_reloc(unsigned int high_reloc, unsigned int lo16_reloc) 405{ 406 switch (high_reloc) 407 { 408 case elfcpp::R_MIPS_HI16: 409 case elfcpp::R_MIPS_GOT16: 410 return lo16_reloc == elfcpp::R_MIPS_LO16; 411 case elfcpp::R_MIPS_PCHI16: 412 return lo16_reloc == elfcpp::R_MIPS_PCLO16; 413 case elfcpp::R_MIPS16_HI16: 414 case elfcpp::R_MIPS16_GOT16: 415 return lo16_reloc == elfcpp::R_MIPS16_LO16; 416 case elfcpp::R_MICROMIPS_HI16: 417 case elfcpp::R_MICROMIPS_GOT16: 418 return lo16_reloc == elfcpp::R_MICROMIPS_LO16; 419 default: 420 return false; 421 } 422} 423 424// This class is used to hold information about one GOT entry. 425// There are three types of entry: 426// 427// (1) a SYMBOL + OFFSET address, where SYMBOL is local to an input object 428// (object != NULL, symndx >= 0, tls_type != GOT_TLS_LDM) 429// (2) a SYMBOL address, where SYMBOL is not local to an input object 430// (sym != NULL, symndx == -1) 431// (3) a TLS LDM slot (there's only one of these per GOT.) 432// (object != NULL, symndx == 0, tls_type == GOT_TLS_LDM) 433 434template<int size, bool big_endian> 435class Mips_got_entry 436{ 437 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 438 439 public: 440 Mips_got_entry(Mips_relobj<size, big_endian>* object, unsigned int symndx, 441 Mips_address addend, unsigned char tls_type, 442 unsigned int shndx, bool is_section_symbol) 443 : addend_(addend), symndx_(symndx), tls_type_(tls_type), 444 is_section_symbol_(is_section_symbol), shndx_(shndx) 445 { this->d.object = object; } 446 447 Mips_got_entry(Mips_symbol<size>* sym, unsigned char tls_type) 448 : addend_(0), symndx_(-1U), tls_type_(tls_type), 449 is_section_symbol_(false), shndx_(-1U) 450 { this->d.sym = sym; } 451 452 // Return whether this entry is for a local symbol. 453 bool 454 is_for_local_symbol() const 455 { return this->symndx_ != -1U; } 456 457 // Return whether this entry is for a global symbol. 458 bool 459 is_for_global_symbol() const 460 { return this->symndx_ == -1U; } 461 462 // Return the hash of this entry. 463 size_t 464 hash() const 465 { 466 if (this->tls_type_ == GOT_TLS_LDM) 467 return this->symndx_ + (1 << 18); 468 469 size_t name_hash_value = gold::string_hash<char>( 470 (this->symndx_ != -1U) 471 ? this->d.object->name().c_str() 472 : this->d.sym->name()); 473 size_t addend = this->addend_; 474 return name_hash_value ^ this->symndx_ ^ addend; 475 } 476 477 // Return whether this entry is equal to OTHER. 478 bool 479 equals(Mips_got_entry<size, big_endian>* other) const 480 { 481 if (this->tls_type_ == GOT_TLS_LDM) 482 return true; 483 484 return ((this->tls_type_ == other->tls_type_) 485 && (this->symndx_ == other->symndx_) 486 && ((this->symndx_ != -1U) 487 ? (this->d.object == other->d.object) 488 : (this->d.sym == other->d.sym)) 489 && (this->addend_ == other->addend_)); 490 } 491 492 // Return input object that needs this GOT entry. 493 Mips_relobj<size, big_endian>* 494 object() const 495 { 496 gold_assert(this->symndx_ != -1U); 497 return this->d.object; 498 } 499 500 // Return local symbol index for local GOT entries. 501 unsigned int 502 symndx() const 503 { 504 gold_assert(this->symndx_ != -1U); 505 return this->symndx_; 506 } 507 508 // Return the relocation addend for local GOT entries. 509 Mips_address 510 addend() const 511 { return this->addend_; } 512 513 // Return global symbol for global GOT entries. 514 Mips_symbol<size>* 515 sym() const 516 { 517 gold_assert(this->symndx_ == -1U); 518 return this->d.sym; 519 } 520 521 // Return whether this is a TLS GOT entry. 522 bool 523 is_tls_entry() const 524 { return this->tls_type_ != GOT_TLS_NONE; } 525 526 // Return TLS type of this GOT entry. 527 unsigned char 528 tls_type() const 529 { return this->tls_type_; } 530 531 // Return section index of the local symbol for local GOT entries. 532 unsigned int 533 shndx() const 534 { return this->shndx_; } 535 536 // Return whether this is a STT_SECTION symbol. 537 bool 538 is_section_symbol() const 539 { return this->is_section_symbol_; } 540 541 private: 542 // The addend. 543 Mips_address addend_; 544 545 // The index of the symbol if we have a local symbol; -1 otherwise. 546 unsigned int symndx_; 547 548 union 549 { 550 // The input object for local symbols that needs the GOT entry. 551 Mips_relobj<size, big_endian>* object; 552 // If symndx == -1, the global symbol corresponding to this GOT entry. The 553 // symbol's entry is in the local area if mips_sym->global_got_area is 554 // GGA_NONE, otherwise it is in the global area. 555 Mips_symbol<size>* sym; 556 } d; 557 558 // The TLS type of this GOT entry. An LDM GOT entry will be a local 559 // symbol entry with r_symndx == 0. 560 unsigned char tls_type_; 561 562 // Whether this is a STT_SECTION symbol. 563 bool is_section_symbol_; 564 565 // For local GOT entries, section index of the local symbol. 566 unsigned int shndx_; 567}; 568 569// Hash for Mips_got_entry. 570 571template<int size, bool big_endian> 572class Mips_got_entry_hash 573{ 574 public: 575 size_t 576 operator()(Mips_got_entry<size, big_endian>* entry) const 577 { return entry->hash(); } 578}; 579 580// Equality for Mips_got_entry. 581 582template<int size, bool big_endian> 583class Mips_got_entry_eq 584{ 585 public: 586 bool 587 operator()(Mips_got_entry<size, big_endian>* e1, 588 Mips_got_entry<size, big_endian>* e2) const 589 { return e1->equals(e2); } 590}; 591 592// Hash for Mips_symbol. 593 594template<int size> 595class Mips_symbol_hash 596{ 597 public: 598 size_t 599 operator()(Mips_symbol<size>* sym) const 600 { return sym->hash(); } 601}; 602 603// Got_page_range. This class describes a range of addends: [MIN_ADDEND, 604// MAX_ADDEND]. The instances form a non-overlapping list that is sorted by 605// increasing MIN_ADDEND. 606 607struct Got_page_range 608{ 609 Got_page_range() 610 : next(NULL), min_addend(0), max_addend(0) 611 { } 612 613 Got_page_range* next; 614 int min_addend; 615 int max_addend; 616 617 // Return the maximum number of GOT page entries required. 618 int 619 get_max_pages() 620 { return (this->max_addend - this->min_addend + 0x1ffff) >> 16; } 621}; 622 623// Got_page_entry. This class describes the range of addends that are applied 624// to page relocations against a given symbol. 625 626struct Got_page_entry 627{ 628 Got_page_entry() 629 : object(NULL), symndx(-1U), ranges(NULL), num_pages(0) 630 { } 631 632 Got_page_entry(Object* object_, unsigned int symndx_) 633 : object(object_), symndx(symndx_), ranges(NULL), num_pages(0) 634 { } 635 636 // The input object that needs the GOT page entry. 637 Object* object; 638 // The index of the symbol, as stored in the relocation r_info. 639 unsigned int symndx; 640 // The ranges for this page entry. 641 Got_page_range* ranges; 642 // The maximum number of page entries needed for RANGES. 643 unsigned int num_pages; 644}; 645 646// Hash for Got_page_entry. 647 648struct Got_page_entry_hash 649{ 650 size_t 651 operator()(Got_page_entry* entry) const 652 { return reinterpret_cast<uintptr_t>(entry->object) + entry->symndx; } 653}; 654 655// Equality for Got_page_entry. 656 657struct Got_page_entry_eq 658{ 659 bool 660 operator()(Got_page_entry* entry1, Got_page_entry* entry2) const 661 { 662 return entry1->object == entry2->object && entry1->symndx == entry2->symndx; 663 } 664}; 665 666// This class is used to hold .got information when linking. 667 668template<int size, bool big_endian> 669class Mips_got_info 670{ 671 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 672 typedef Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian> 673 Reloc_section; 674 typedef Unordered_map<unsigned int, unsigned int> Got_page_offsets; 675 676 // Unordered set of GOT entries. 677 typedef Unordered_set<Mips_got_entry<size, big_endian>*, 678 Mips_got_entry_hash<size, big_endian>, 679 Mips_got_entry_eq<size, big_endian> > Got_entry_set; 680 681 // Unordered set of GOT page entries. 682 typedef Unordered_set<Got_page_entry*, 683 Got_page_entry_hash, Got_page_entry_eq> Got_page_entry_set; 684 685 // Unordered set of global GOT entries. 686 typedef Unordered_set<Mips_symbol<size>*, Mips_symbol_hash<size> > 687 Global_got_entry_set; 688 689 public: 690 Mips_got_info() 691 : local_gotno_(0), page_gotno_(0), global_gotno_(0), reloc_only_gotno_(0), 692 tls_gotno_(0), tls_ldm_offset_(-1U), global_got_symbols_(), 693 got_entries_(), got_page_entries_(), got_page_offset_start_(0), 694 got_page_offset_next_(0), got_page_offsets_(), next_(NULL), index_(-1U), 695 offset_(0) 696 { } 697 698 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol 699 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT. 700 void 701 record_local_got_symbol(Mips_relobj<size, big_endian>* object, 702 unsigned int symndx, Mips_address addend, 703 unsigned int r_type, unsigned int shndx, 704 bool is_section_symbol); 705 706 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM, 707 // in OBJECT. FOR_CALL is true if the caller is only interested in 708 // using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic 709 // relocation. 710 void 711 record_global_got_symbol(Mips_symbol<size>* mips_sym, 712 Mips_relobj<size, big_endian>* object, 713 unsigned int r_type, bool dyn_reloc, bool for_call); 714 715 // Add ENTRY to master GOT and to OBJECT's GOT. 716 void 717 record_got_entry(Mips_got_entry<size, big_endian>* entry, 718 Mips_relobj<size, big_endian>* object); 719 720 // Record that OBJECT has a page relocation against symbol SYMNDX and 721 // that ADDEND is the addend for that relocation. 722 void 723 record_got_page_entry(Mips_relobj<size, big_endian>* object, 724 unsigned int symndx, int addend); 725 726 // Create all entries that should be in the local part of the GOT. 727 void 728 add_local_entries(Target_mips<size, big_endian>* target, Layout* layout); 729 730 // Create GOT page entries. 731 void 732 add_page_entries(Target_mips<size, big_endian>* target, Layout* layout); 733 734 // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY. 735 void 736 add_global_entries(Target_mips<size, big_endian>* target, Layout* layout, 737 unsigned int non_reloc_only_global_gotno); 738 739 // Create global GOT entries that should be in the GGA_RELOC_ONLY area. 740 void 741 add_reloc_only_entries(Mips_output_data_got<size, big_endian>* got); 742 743 // Create TLS GOT entries. 744 void 745 add_tls_entries(Target_mips<size, big_endian>* target, Layout* layout); 746 747 // Decide whether the symbol needs an entry in the global part of the primary 748 // GOT, setting global_got_area accordingly. Count the number of global 749 // symbols that are in the primary GOT only because they have dynamic 750 // relocations R_MIPS_REL32 against them (reloc_only_gotno). 751 void 752 count_got_symbols(Symbol_table* symtab); 753 754 // Return the offset of GOT page entry for VALUE. 755 unsigned int 756 get_got_page_offset(Mips_address value, 757 Mips_output_data_got<size, big_endian>* got); 758 759 // Count the number of GOT entries required. 760 void 761 count_got_entries(); 762 763 // Count the number of GOT entries required by ENTRY. Accumulate the result. 764 void 765 count_got_entry(Mips_got_entry<size, big_endian>* entry); 766 767 // Add FROM's GOT entries. 768 void 769 add_got_entries(Mips_got_info<size, big_endian>* from); 770 771 // Add FROM's GOT page entries. 772 void 773 add_got_page_entries(Mips_got_info<size, big_endian>* from); 774 775 // Return GOT size. 776 unsigned int 777 got_size() const 778 { return ((2 + this->local_gotno_ + this->page_gotno_ + this->global_gotno_ 779 + this->tls_gotno_) * size/8); 780 } 781 782 // Return the number of local GOT entries. 783 unsigned int 784 local_gotno() const 785 { return this->local_gotno_; } 786 787 // Return the maximum number of page GOT entries needed. 788 unsigned int 789 page_gotno() const 790 { return this->page_gotno_; } 791 792 // Return the number of global GOT entries. 793 unsigned int 794 global_gotno() const 795 { return this->global_gotno_; } 796 797 // Set the number of global GOT entries. 798 void 799 set_global_gotno(unsigned int global_gotno) 800 { this->global_gotno_ = global_gotno; } 801 802 // Return the number of GGA_RELOC_ONLY global GOT entries. 803 unsigned int 804 reloc_only_gotno() const 805 { return this->reloc_only_gotno_; } 806 807 // Return the number of TLS GOT entries. 808 unsigned int 809 tls_gotno() const 810 { return this->tls_gotno_; } 811 812 // Return the GOT type for this GOT. Used for multi-GOT links only. 813 unsigned int 814 multigot_got_type(unsigned int got_type) const 815 { 816 switch (got_type) 817 { 818 case GOT_TYPE_STANDARD: 819 return GOT_TYPE_STANDARD_MULTIGOT + this->index_; 820 case GOT_TYPE_TLS_OFFSET: 821 return GOT_TYPE_TLS_OFFSET_MULTIGOT + this->index_; 822 case GOT_TYPE_TLS_PAIR: 823 return GOT_TYPE_TLS_PAIR_MULTIGOT + this->index_; 824 default: 825 gold_unreachable(); 826 } 827 } 828 829 // Remove lazy-binding stubs for global symbols in this GOT. 830 void 831 remove_lazy_stubs(Target_mips<size, big_endian>* target); 832 833 // Return offset of this GOT from the start of .got section. 834 unsigned int 835 offset() const 836 { return this->offset_; } 837 838 // Set offset of this GOT from the start of .got section. 839 void 840 set_offset(unsigned int offset) 841 { this->offset_ = offset; } 842 843 // Set index of this GOT in multi-GOT links. 844 void 845 set_index(unsigned int index) 846 { this->index_ = index; } 847 848 // Return next GOT in multi-GOT links. 849 Mips_got_info<size, big_endian>* 850 next() const 851 { return this->next_; } 852 853 // Set next GOT in multi-GOT links. 854 void 855 set_next(Mips_got_info<size, big_endian>* next) 856 { this->next_ = next; } 857 858 // Return the offset of TLS LDM entry for this GOT. 859 unsigned int 860 tls_ldm_offset() const 861 { return this->tls_ldm_offset_; } 862 863 // Set the offset of TLS LDM entry for this GOT. 864 void 865 set_tls_ldm_offset(unsigned int tls_ldm_offset) 866 { this->tls_ldm_offset_ = tls_ldm_offset; } 867 868 Global_got_entry_set& 869 global_got_symbols() 870 { return this->global_got_symbols_; } 871 872 // Return the GOT_TLS_* type required by relocation type R_TYPE. 873 static int 874 mips_elf_reloc_tls_type(unsigned int r_type) 875 { 876 if (tls_gd_reloc(r_type)) 877 return GOT_TLS_GD; 878 879 if (tls_ldm_reloc(r_type)) 880 return GOT_TLS_LDM; 881 882 if (tls_gottprel_reloc(r_type)) 883 return GOT_TLS_IE; 884 885 return GOT_TLS_NONE; 886 } 887 888 // Return the number of GOT slots needed for GOT TLS type TYPE. 889 static int 890 mips_tls_got_entries(unsigned int type) 891 { 892 switch (type) 893 { 894 case GOT_TLS_GD: 895 case GOT_TLS_LDM: 896 return 2; 897 898 case GOT_TLS_IE: 899 return 1; 900 901 case GOT_TLS_NONE: 902 return 0; 903 904 default: 905 gold_unreachable(); 906 } 907 } 908 909 private: 910 // The number of local GOT entries. 911 unsigned int local_gotno_; 912 // The maximum number of page GOT entries needed. 913 unsigned int page_gotno_; 914 // The number of global GOT entries. 915 unsigned int global_gotno_; 916 // The number of global GOT entries that are in the GGA_RELOC_ONLY area. 917 unsigned int reloc_only_gotno_; 918 // The number of TLS GOT entries. 919 unsigned int tls_gotno_; 920 // The offset of TLS LDM entry for this GOT. 921 unsigned int tls_ldm_offset_; 922 // All symbols that have global GOT entry. 923 Global_got_entry_set global_got_symbols_; 924 // A hash table holding GOT entries. 925 Got_entry_set got_entries_; 926 // A hash table of GOT page entries. 927 Got_page_entry_set got_page_entries_; 928 // The offset of first GOT page entry for this GOT. 929 unsigned int got_page_offset_start_; 930 // The offset of next available GOT page entry for this GOT. 931 unsigned int got_page_offset_next_; 932 // A hash table that maps GOT page entry value to the GOT offset where 933 // the entry is located. 934 Got_page_offsets got_page_offsets_; 935 // In multi-GOT links, a pointer to the next GOT. 936 Mips_got_info<size, big_endian>* next_; 937 // Index of this GOT in multi-GOT links. 938 unsigned int index_; 939 // The offset of this GOT in multi-GOT links. 940 unsigned int offset_; 941}; 942 943// This is a helper class used during relocation scan. It records GOT16 addend. 944 945template<int size, bool big_endian> 946struct got16_addend 947{ 948 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 949 950 got16_addend(const Sized_relobj_file<size, big_endian>* _object, 951 unsigned int _shndx, unsigned int _r_type, unsigned int _r_sym, 952 Mips_address _addend) 953 : object(_object), shndx(_shndx), r_type(_r_type), r_sym(_r_sym), 954 addend(_addend) 955 { } 956 957 const Sized_relobj_file<size, big_endian>* object; 958 unsigned int shndx; 959 unsigned int r_type; 960 unsigned int r_sym; 961 Mips_address addend; 962}; 963 964// .MIPS.abiflags section content 965 966template<bool big_endian> 967struct Mips_abiflags 968{ 969 typedef typename elfcpp::Swap<8, big_endian>::Valtype Valtype8; 970 typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype16; 971 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32; 972 973 Mips_abiflags() 974 : version(0), isa_level(0), isa_rev(0), gpr_size(0), cpr1_size(0), 975 cpr2_size(0), fp_abi(0), isa_ext(0), ases(0), flags1(0), flags2(0) 976 { } 977 978 // Version of flags structure. 979 Valtype16 version; 980 // The level of the ISA: 1-5, 32, 64. 981 Valtype8 isa_level; 982 // The revision of ISA: 0 for MIPS V and below, 1-n otherwise. 983 Valtype8 isa_rev; 984 // The size of general purpose registers. 985 Valtype8 gpr_size; 986 // The size of co-processor 1 registers. 987 Valtype8 cpr1_size; 988 // The size of co-processor 2 registers. 989 Valtype8 cpr2_size; 990 // The floating-point ABI. 991 Valtype8 fp_abi; 992 // Processor-specific extension. 993 Valtype32 isa_ext; 994 // Mask of ASEs used. 995 Valtype32 ases; 996 // Mask of general flags. 997 Valtype32 flags1; 998 Valtype32 flags2; 999}; 1000 1001// Mips_symbol class. Holds additional symbol information needed for Mips. 1002 1003template<int size> 1004class Mips_symbol : public Sized_symbol<size> 1005{ 1006 public: 1007 Mips_symbol() 1008 : need_fn_stub_(false), has_nonpic_branches_(false), la25_stub_offset_(-1U), 1009 has_static_relocs_(false), no_lazy_stub_(false), lazy_stub_offset_(0), 1010 pointer_equality_needed_(false), global_got_area_(GGA_NONE), 1011 global_gotoffset_(-1U), got_only_for_calls_(true), has_lazy_stub_(false), 1012 needs_mips_plt_(false), needs_comp_plt_(false), mips_plt_offset_(-1U), 1013 comp_plt_offset_(-1U), mips16_fn_stub_(NULL), mips16_call_stub_(NULL), 1014 mips16_call_fp_stub_(NULL), applied_secondary_got_fixup_(false) 1015 { } 1016 1017 // Return whether this is a MIPS16 symbol. 1018 bool 1019 is_mips16() const 1020 { 1021 // (st_other & STO_MIPS16) == STO_MIPS16 1022 return ((this->nonvis() & (elfcpp::STO_MIPS16 >> 2)) 1023 == elfcpp::STO_MIPS16 >> 2); 1024 } 1025 1026 // Return whether this is a microMIPS symbol. 1027 bool 1028 is_micromips() const 1029 { 1030 // (st_other & STO_MIPS_ISA) == STO_MICROMIPS 1031 return ((this->nonvis() & (elfcpp::STO_MIPS_ISA >> 2)) 1032 == elfcpp::STO_MICROMIPS >> 2); 1033 } 1034 1035 // Return whether the symbol needs MIPS16 fn_stub. 1036 bool 1037 need_fn_stub() const 1038 { return this->need_fn_stub_; } 1039 1040 // Set that the symbol needs MIPS16 fn_stub. 1041 void 1042 set_need_fn_stub() 1043 { this->need_fn_stub_ = true; } 1044 1045 // Return whether this symbol is referenced by branch relocations from 1046 // any non-PIC input file. 1047 bool 1048 has_nonpic_branches() const 1049 { return this->has_nonpic_branches_; } 1050 1051 // Set that this symbol is referenced by branch relocations from 1052 // any non-PIC input file. 1053 void 1054 set_has_nonpic_branches() 1055 { this->has_nonpic_branches_ = true; } 1056 1057 // Return the offset of the la25 stub for this symbol from the start of the 1058 // la25 stub section. 1059 unsigned int 1060 la25_stub_offset() const 1061 { return this->la25_stub_offset_; } 1062 1063 // Set the offset of the la25 stub for this symbol from the start of the 1064 // la25 stub section. 1065 void 1066 set_la25_stub_offset(unsigned int offset) 1067 { this->la25_stub_offset_ = offset; } 1068 1069 // Return whether the symbol has la25 stub. This is true if this symbol is 1070 // for a PIC function, and there are non-PIC branches and jumps to it. 1071 bool 1072 has_la25_stub() const 1073 { return this->la25_stub_offset_ != -1U; } 1074 1075 // Return whether there is a relocation against this symbol that must be 1076 // resolved by the static linker (that is, the relocation cannot possibly 1077 // be made dynamic). 1078 bool 1079 has_static_relocs() const 1080 { return this->has_static_relocs_; } 1081 1082 // Set that there is a relocation against this symbol that must be resolved 1083 // by the static linker (that is, the relocation cannot possibly be made 1084 // dynamic). 1085 void 1086 set_has_static_relocs() 1087 { this->has_static_relocs_ = true; } 1088 1089 // Return whether we must not create a lazy-binding stub for this symbol. 1090 bool 1091 no_lazy_stub() const 1092 { return this->no_lazy_stub_; } 1093 1094 // Set that we must not create a lazy-binding stub for this symbol. 1095 void 1096 set_no_lazy_stub() 1097 { this->no_lazy_stub_ = true; } 1098 1099 // Return the offset of the lazy-binding stub for this symbol from the start 1100 // of .MIPS.stubs section. 1101 unsigned int 1102 lazy_stub_offset() const 1103 { return this->lazy_stub_offset_; } 1104 1105 // Set the offset of the lazy-binding stub for this symbol from the start 1106 // of .MIPS.stubs section. 1107 void 1108 set_lazy_stub_offset(unsigned int offset) 1109 { this->lazy_stub_offset_ = offset; } 1110 1111 // Return whether there are any relocations for this symbol where 1112 // pointer equality matters. 1113 bool 1114 pointer_equality_needed() const 1115 { return this->pointer_equality_needed_; } 1116 1117 // Set that there are relocations for this symbol where pointer equality 1118 // matters. 1119 void 1120 set_pointer_equality_needed() 1121 { this->pointer_equality_needed_ = true; } 1122 1123 // Return global GOT area where this symbol in located. 1124 Global_got_area 1125 global_got_area() const 1126 { return this->global_got_area_; } 1127 1128 // Set global GOT area where this symbol in located. 1129 void 1130 set_global_got_area(Global_got_area global_got_area) 1131 { this->global_got_area_ = global_got_area; } 1132 1133 // Return the global GOT offset for this symbol. For multi-GOT links, this 1134 // returns the offset from the start of .got section to the first GOT entry 1135 // for the symbol. Note that in multi-GOT links the symbol can have entry 1136 // in more than one GOT. 1137 unsigned int 1138 global_gotoffset() const 1139 { return this->global_gotoffset_; } 1140 1141 // Set the global GOT offset for this symbol. Note that in multi-GOT links 1142 // the symbol can have entry in more than one GOT. This method will set 1143 // the offset only if it is less than current offset. 1144 void 1145 set_global_gotoffset(unsigned int offset) 1146 { 1147 if (this->global_gotoffset_ == -1U || offset < this->global_gotoffset_) 1148 this->global_gotoffset_ = offset; 1149 } 1150 1151 // Return whether all GOT relocations for this symbol are for calls. 1152 bool 1153 got_only_for_calls() const 1154 { return this->got_only_for_calls_; } 1155 1156 // Set that there is a GOT relocation for this symbol that is not for call. 1157 void 1158 set_got_not_only_for_calls() 1159 { this->got_only_for_calls_ = false; } 1160 1161 // Return whether this is a PIC symbol. 1162 bool 1163 is_pic() const 1164 { 1165 // (st_other & STO_MIPS_FLAGS) == STO_MIPS_PIC 1166 return ((this->nonvis() & (elfcpp::STO_MIPS_FLAGS >> 2)) 1167 == (elfcpp::STO_MIPS_PIC >> 2)); 1168 } 1169 1170 // Set the flag in st_other field that marks this symbol as PIC. 1171 void 1172 set_pic() 1173 { 1174 if (this->is_mips16()) 1175 // (st_other & ~(STO_MIPS16 | STO_MIPS_FLAGS)) | STO_MIPS_PIC 1176 this->set_nonvis((this->nonvis() 1177 & ~((elfcpp::STO_MIPS16 >> 2) 1178 | (elfcpp::STO_MIPS_FLAGS >> 2))) 1179 | (elfcpp::STO_MIPS_PIC >> 2)); 1180 else 1181 // (other & ~STO_MIPS_FLAGS) | STO_MIPS_PIC 1182 this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS >> 2)) 1183 | (elfcpp::STO_MIPS_PIC >> 2)); 1184 } 1185 1186 // Set the flag in st_other field that marks this symbol as PLT. 1187 void 1188 set_mips_plt() 1189 { 1190 if (this->is_mips16()) 1191 // (st_other & (STO_MIPS16 | ~STO_MIPS_FLAGS)) | STO_MIPS_PLT 1192 this->set_nonvis((this->nonvis() 1193 & ((elfcpp::STO_MIPS16 >> 2) 1194 | ~(elfcpp::STO_MIPS_FLAGS >> 2))) 1195 | (elfcpp::STO_MIPS_PLT >> 2)); 1196 1197 else 1198 // (st_other & ~STO_MIPS_FLAGS) | STO_MIPS_PLT 1199 this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS >> 2)) 1200 | (elfcpp::STO_MIPS_PLT >> 2)); 1201 } 1202 1203 // Downcast a base pointer to a Mips_symbol pointer. 1204 static Mips_symbol<size>* 1205 as_mips_sym(Symbol* sym) 1206 { return static_cast<Mips_symbol<size>*>(sym); } 1207 1208 // Downcast a base pointer to a Mips_symbol pointer. 1209 static const Mips_symbol<size>* 1210 as_mips_sym(const Symbol* sym) 1211 { return static_cast<const Mips_symbol<size>*>(sym); } 1212 1213 // Return whether the symbol has lazy-binding stub. 1214 bool 1215 has_lazy_stub() const 1216 { return this->has_lazy_stub_; } 1217 1218 // Set whether the symbol has lazy-binding stub. 1219 void 1220 set_has_lazy_stub(bool has_lazy_stub) 1221 { this->has_lazy_stub_ = has_lazy_stub; } 1222 1223 // Return whether the symbol needs a standard PLT entry. 1224 bool 1225 needs_mips_plt() const 1226 { return this->needs_mips_plt_; } 1227 1228 // Set whether the symbol needs a standard PLT entry. 1229 void 1230 set_needs_mips_plt(bool needs_mips_plt) 1231 { this->needs_mips_plt_ = needs_mips_plt; } 1232 1233 // Return whether the symbol needs a compressed (MIPS16 or microMIPS) PLT 1234 // entry. 1235 bool 1236 needs_comp_plt() const 1237 { return this->needs_comp_plt_; } 1238 1239 // Set whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry. 1240 void 1241 set_needs_comp_plt(bool needs_comp_plt) 1242 { this->needs_comp_plt_ = needs_comp_plt; } 1243 1244 // Return standard PLT entry offset, or -1 if none. 1245 unsigned int 1246 mips_plt_offset() const 1247 { return this->mips_plt_offset_; } 1248 1249 // Set standard PLT entry offset. 1250 void 1251 set_mips_plt_offset(unsigned int mips_plt_offset) 1252 { this->mips_plt_offset_ = mips_plt_offset; } 1253 1254 // Return whether the symbol has standard PLT entry. 1255 bool 1256 has_mips_plt_offset() const 1257 { return this->mips_plt_offset_ != -1U; } 1258 1259 // Return compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none. 1260 unsigned int 1261 comp_plt_offset() const 1262 { return this->comp_plt_offset_; } 1263 1264 // Set compressed (MIPS16 or microMIPS) PLT entry offset. 1265 void 1266 set_comp_plt_offset(unsigned int comp_plt_offset) 1267 { this->comp_plt_offset_ = comp_plt_offset; } 1268 1269 // Return whether the symbol has compressed (MIPS16 or microMIPS) PLT entry. 1270 bool 1271 has_comp_plt_offset() const 1272 { return this->comp_plt_offset_ != -1U; } 1273 1274 // Return MIPS16 fn stub for a symbol. 1275 template<bool big_endian> 1276 Mips16_stub_section<size, big_endian>* 1277 get_mips16_fn_stub() const 1278 { 1279 return static_cast<Mips16_stub_section<size, big_endian>*>(mips16_fn_stub_); 1280 } 1281 1282 // Set MIPS16 fn stub for a symbol. 1283 void 1284 set_mips16_fn_stub(Mips16_stub_section_base* stub) 1285 { this->mips16_fn_stub_ = stub; } 1286 1287 // Return whether symbol has MIPS16 fn stub. 1288 bool 1289 has_mips16_fn_stub() const 1290 { return this->mips16_fn_stub_ != NULL; } 1291 1292 // Return MIPS16 call stub for a symbol. 1293 template<bool big_endian> 1294 Mips16_stub_section<size, big_endian>* 1295 get_mips16_call_stub() const 1296 { 1297 return static_cast<Mips16_stub_section<size, big_endian>*>( 1298 mips16_call_stub_); 1299 } 1300 1301 // Set MIPS16 call stub for a symbol. 1302 void 1303 set_mips16_call_stub(Mips16_stub_section_base* stub) 1304 { this->mips16_call_stub_ = stub; } 1305 1306 // Return whether symbol has MIPS16 call stub. 1307 bool 1308 has_mips16_call_stub() const 1309 { return this->mips16_call_stub_ != NULL; } 1310 1311 // Return MIPS16 call_fp stub for a symbol. 1312 template<bool big_endian> 1313 Mips16_stub_section<size, big_endian>* 1314 get_mips16_call_fp_stub() const 1315 { 1316 return static_cast<Mips16_stub_section<size, big_endian>*>( 1317 mips16_call_fp_stub_); 1318 } 1319 1320 // Set MIPS16 call_fp stub for a symbol. 1321 void 1322 set_mips16_call_fp_stub(Mips16_stub_section_base* stub) 1323 { this->mips16_call_fp_stub_ = stub; } 1324 1325 // Return whether symbol has MIPS16 call_fp stub. 1326 bool 1327 has_mips16_call_fp_stub() const 1328 { return this->mips16_call_fp_stub_ != NULL; } 1329 1330 bool 1331 get_applied_secondary_got_fixup() const 1332 { return applied_secondary_got_fixup_; } 1333 1334 void 1335 set_applied_secondary_got_fixup() 1336 { this->applied_secondary_got_fixup_ = true; } 1337 1338 // Return the hash of this symbol. 1339 size_t 1340 hash() const 1341 { 1342 return gold::string_hash<char>(this->name()); 1343 } 1344 1345 private: 1346 // Whether the symbol needs MIPS16 fn_stub. This is true if this symbol 1347 // appears in any relocs other than a 16 bit call. 1348 bool need_fn_stub_; 1349 1350 // True if this symbol is referenced by branch relocations from 1351 // any non-PIC input file. This is used to determine whether an 1352 // la25 stub is required. 1353 bool has_nonpic_branches_; 1354 1355 // The offset of the la25 stub for this symbol from the start of the 1356 // la25 stub section. 1357 unsigned int la25_stub_offset_; 1358 1359 // True if there is a relocation against this symbol that must be 1360 // resolved by the static linker (that is, the relocation cannot 1361 // possibly be made dynamic). 1362 bool has_static_relocs_; 1363 1364 // Whether we must not create a lazy-binding stub for this symbol. 1365 // This is true if the symbol has relocations related to taking the 1366 // function's address. 1367 bool no_lazy_stub_; 1368 1369 // The offset of the lazy-binding stub for this symbol from the start of 1370 // .MIPS.stubs section. 1371 unsigned int lazy_stub_offset_; 1372 1373 // True if there are any relocations for this symbol where pointer equality 1374 // matters. 1375 bool pointer_equality_needed_; 1376 1377 // Global GOT area where this symbol in located, or GGA_NONE if symbol is not 1378 // in the global part of the GOT. 1379 Global_got_area global_got_area_; 1380 1381 // The global GOT offset for this symbol. For multi-GOT links, this is offset 1382 // from the start of .got section to the first GOT entry for the symbol. 1383 // Note that in multi-GOT links the symbol can have entry in more than one GOT. 1384 unsigned int global_gotoffset_; 1385 1386 // Whether all GOT relocations for this symbol are for calls. 1387 bool got_only_for_calls_; 1388 // Whether the symbol has lazy-binding stub. 1389 bool has_lazy_stub_; 1390 // Whether the symbol needs a standard PLT entry. 1391 bool needs_mips_plt_; 1392 // Whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry. 1393 bool needs_comp_plt_; 1394 // Standard PLT entry offset, or -1 if none. 1395 unsigned int mips_plt_offset_; 1396 // Compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none. 1397 unsigned int comp_plt_offset_; 1398 // MIPS16 fn stub for a symbol. 1399 Mips16_stub_section_base* mips16_fn_stub_; 1400 // MIPS16 call stub for a symbol. 1401 Mips16_stub_section_base* mips16_call_stub_; 1402 // MIPS16 call_fp stub for a symbol. 1403 Mips16_stub_section_base* mips16_call_fp_stub_; 1404 1405 bool applied_secondary_got_fixup_; 1406}; 1407 1408// Mips16_stub_section class. 1409 1410// The mips16 compiler uses a couple of special sections to handle 1411// floating point arguments. 1412 1413// Section names that look like .mips16.fn.FNNAME contain stubs that 1414// copy floating point arguments from the fp regs to the gp regs and 1415// then jump to FNNAME. If any 32 bit function calls FNNAME, the 1416// call should be redirected to the stub instead. If no 32 bit 1417// function calls FNNAME, the stub should be discarded. We need to 1418// consider any reference to the function, not just a call, because 1419// if the address of the function is taken we will need the stub, 1420// since the address might be passed to a 32 bit function. 1421 1422// Section names that look like .mips16.call.FNNAME contain stubs 1423// that copy floating point arguments from the gp regs to the fp 1424// regs and then jump to FNNAME. If FNNAME is a 32 bit function, 1425// then any 16 bit function that calls FNNAME should be redirected 1426// to the stub instead. If FNNAME is not a 32 bit function, the 1427// stub should be discarded. 1428 1429// .mips16.call.fp.FNNAME sections are similar, but contain stubs 1430// which call FNNAME and then copy the return value from the fp regs 1431// to the gp regs. These stubs store the return address in $18 while 1432// calling FNNAME; any function which might call one of these stubs 1433// must arrange to save $18 around the call. (This case is not 1434// needed for 32 bit functions that call 16 bit functions, because 1435// 16 bit functions always return floating point values in both 1436// $f0/$f1 and $2/$3.) 1437 1438// Note that in all cases FNNAME might be defined statically. 1439// Therefore, FNNAME is not used literally. Instead, the relocation 1440// information will indicate which symbol the section is for. 1441 1442// We record any stubs that we find in the symbol table. 1443 1444// TODO(sasa): All mips16 stub sections should be emitted in the .text section. 1445 1446class Mips16_stub_section_base { }; 1447 1448template<int size, bool big_endian> 1449class Mips16_stub_section : public Mips16_stub_section_base 1450{ 1451 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 1452 1453 public: 1454 Mips16_stub_section(Mips_relobj<size, big_endian>* object, unsigned int shndx) 1455 : object_(object), shndx_(shndx), r_sym_(0), gsym_(NULL), 1456 found_r_mips_none_(false) 1457 { 1458 gold_assert(object->is_mips16_fn_stub_section(shndx) 1459 || object->is_mips16_call_stub_section(shndx) 1460 || object->is_mips16_call_fp_stub_section(shndx)); 1461 } 1462 1463 // Return the object of this stub section. 1464 Mips_relobj<size, big_endian>* 1465 object() const 1466 { return this->object_; } 1467 1468 // Return the size of a section. 1469 uint64_t 1470 section_size() const 1471 { return this->object_->section_size(this->shndx_); } 1472 1473 // Return section index of this stub section. 1474 unsigned int 1475 shndx() const 1476 { return this->shndx_; } 1477 1478 // Return symbol index, if stub is for a local function. 1479 unsigned int 1480 r_sym() const 1481 { return this->r_sym_; } 1482 1483 // Return symbol, if stub is for a global function. 1484 Mips_symbol<size>* 1485 gsym() const 1486 { return this->gsym_; } 1487 1488 // Return whether stub is for a local function. 1489 bool 1490 is_for_local_function() const 1491 { return this->gsym_ == NULL; } 1492 1493 // This method is called when a new relocation R_TYPE for local symbol R_SYM 1494 // is found in the stub section. Try to find stub target. 1495 void 1496 new_local_reloc_found(unsigned int r_type, unsigned int r_sym) 1497 { 1498 // To find target symbol for this stub, trust the first R_MIPS_NONE 1499 // relocation, if any. Otherwise trust the first relocation, whatever 1500 // its kind. 1501 if (this->found_r_mips_none_) 1502 return; 1503 if (r_type == elfcpp::R_MIPS_NONE) 1504 { 1505 this->r_sym_ = r_sym; 1506 this->gsym_ = NULL; 1507 this->found_r_mips_none_ = true; 1508 } 1509 else if (!is_target_found()) 1510 this->r_sym_ = r_sym; 1511 } 1512 1513 // This method is called when a new relocation R_TYPE for global symbol GSYM 1514 // is found in the stub section. Try to find stub target. 1515 void 1516 new_global_reloc_found(unsigned int r_type, Mips_symbol<size>* gsym) 1517 { 1518 // To find target symbol for this stub, trust the first R_MIPS_NONE 1519 // relocation, if any. Otherwise trust the first relocation, whatever 1520 // its kind. 1521 if (this->found_r_mips_none_) 1522 return; 1523 if (r_type == elfcpp::R_MIPS_NONE) 1524 { 1525 this->gsym_ = gsym; 1526 this->r_sym_ = 0; 1527 this->found_r_mips_none_ = true; 1528 } 1529 else if (!is_target_found()) 1530 this->gsym_ = gsym; 1531 } 1532 1533 // Return whether we found the stub target. 1534 bool 1535 is_target_found() const 1536 { return this->r_sym_ != 0 || this->gsym_ != NULL; } 1537 1538 // Return whether this is a fn stub. 1539 bool 1540 is_fn_stub() const 1541 { return this->object_->is_mips16_fn_stub_section(this->shndx_); } 1542 1543 // Return whether this is a call stub. 1544 bool 1545 is_call_stub() const 1546 { return this->object_->is_mips16_call_stub_section(this->shndx_); } 1547 1548 // Return whether this is a call_fp stub. 1549 bool 1550 is_call_fp_stub() const 1551 { return this->object_->is_mips16_call_fp_stub_section(this->shndx_); } 1552 1553 // Return the output address. 1554 Mips_address 1555 output_address() const 1556 { 1557 return (this->object_->output_section(this->shndx_)->address() 1558 + this->object_->output_section_offset(this->shndx_)); 1559 } 1560 1561 private: 1562 // The object of this stub section. 1563 Mips_relobj<size, big_endian>* object_; 1564 // The section index of this stub section. 1565 unsigned int shndx_; 1566 // The symbol index, if stub is for a local function. 1567 unsigned int r_sym_; 1568 // The symbol, if stub is for a global function. 1569 Mips_symbol<size>* gsym_; 1570 // True if we found R_MIPS_NONE relocation in this stub. 1571 bool found_r_mips_none_; 1572}; 1573 1574// Mips_relobj class. 1575 1576template<int size, bool big_endian> 1577class Mips_relobj : public Sized_relobj_file<size, big_endian> 1578{ 1579 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 1580 typedef std::map<unsigned int, Mips16_stub_section<size, big_endian>*> 1581 Mips16_stubs_int_map; 1582 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 1583 1584 public: 1585 Mips_relobj(const std::string& name, Input_file* input_file, off_t offset, 1586 const typename elfcpp::Ehdr<size, big_endian>& ehdr) 1587 : Sized_relobj_file<size, big_endian>(name, input_file, offset, ehdr), 1588 processor_specific_flags_(0), local_symbol_is_mips16_(), 1589 local_symbol_is_micromips_(), mips16_stub_sections_(), 1590 local_non_16bit_calls_(), local_16bit_calls_(), local_mips16_fn_stubs_(), 1591 local_mips16_call_stubs_(), gp_(0), has_reginfo_section_(false), 1592 got_info_(NULL), section_is_mips16_fn_stub_(), 1593 section_is_mips16_call_stub_(), section_is_mips16_call_fp_stub_(), 1594 pdr_shndx_(-1U), attributes_section_data_(NULL), abiflags_(NULL), 1595 gprmask_(0), cprmask1_(0), cprmask2_(0), cprmask3_(0), cprmask4_(0) 1596 { 1597 this->is_pic_ = (ehdr.get_e_flags() & elfcpp::EF_MIPS_PIC) != 0; 1598 this->is_n32_ = elfcpp::abi_n32(ehdr.get_e_flags()); 1599 } 1600 1601 ~Mips_relobj() 1602 { delete this->attributes_section_data_; } 1603 1604 // Downcast a base pointer to a Mips_relobj pointer. This is 1605 // not type-safe but we only use Mips_relobj not the base class. 1606 static Mips_relobj<size, big_endian>* 1607 as_mips_relobj(Relobj* relobj) 1608 { return static_cast<Mips_relobj<size, big_endian>*>(relobj); } 1609 1610 // Downcast a base pointer to a Mips_relobj pointer. This is 1611 // not type-safe but we only use Mips_relobj not the base class. 1612 static const Mips_relobj<size, big_endian>* 1613 as_mips_relobj(const Relobj* relobj) 1614 { return static_cast<const Mips_relobj<size, big_endian>*>(relobj); } 1615 1616 // Processor-specific flags in ELF file header. This is valid only after 1617 // reading symbols. 1618 elfcpp::Elf_Word 1619 processor_specific_flags() const 1620 { return this->processor_specific_flags_; } 1621 1622 // Whether a local symbol is MIPS16 symbol. R_SYM is the symbol table 1623 // index. This is only valid after do_count_local_symbol is called. 1624 bool 1625 local_symbol_is_mips16(unsigned int r_sym) const 1626 { 1627 gold_assert(r_sym < this->local_symbol_is_mips16_.size()); 1628 return this->local_symbol_is_mips16_[r_sym]; 1629 } 1630 1631 // Whether a local symbol is microMIPS symbol. R_SYM is the symbol table 1632 // index. This is only valid after do_count_local_symbol is called. 1633 bool 1634 local_symbol_is_micromips(unsigned int r_sym) const 1635 { 1636 gold_assert(r_sym < this->local_symbol_is_micromips_.size()); 1637 return this->local_symbol_is_micromips_[r_sym]; 1638 } 1639 1640 // Get or create MIPS16 stub section. 1641 Mips16_stub_section<size, big_endian>* 1642 get_mips16_stub_section(unsigned int shndx) 1643 { 1644 typename Mips16_stubs_int_map::const_iterator it = 1645 this->mips16_stub_sections_.find(shndx); 1646 if (it != this->mips16_stub_sections_.end()) 1647 return (*it).second; 1648 1649 Mips16_stub_section<size, big_endian>* stub_section = 1650 new Mips16_stub_section<size, big_endian>(this, shndx); 1651 this->mips16_stub_sections_.insert( 1652 std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>( 1653 stub_section->shndx(), stub_section)); 1654 return stub_section; 1655 } 1656 1657 // Return MIPS16 fn stub section for local symbol R_SYM, or NULL if this 1658 // object doesn't have fn stub for R_SYM. 1659 Mips16_stub_section<size, big_endian>* 1660 get_local_mips16_fn_stub(unsigned int r_sym) const 1661 { 1662 typename Mips16_stubs_int_map::const_iterator it = 1663 this->local_mips16_fn_stubs_.find(r_sym); 1664 if (it != this->local_mips16_fn_stubs_.end()) 1665 return (*it).second; 1666 return NULL; 1667 } 1668 1669 // Record that this object has MIPS16 fn stub for local symbol. This method 1670 // is only called if we decided not to discard the stub. 1671 void 1672 add_local_mips16_fn_stub(Mips16_stub_section<size, big_endian>* stub) 1673 { 1674 gold_assert(stub->is_for_local_function()); 1675 unsigned int r_sym = stub->r_sym(); 1676 this->local_mips16_fn_stubs_.insert( 1677 std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>( 1678 r_sym, stub)); 1679 } 1680 1681 // Return MIPS16 call stub section for local symbol R_SYM, or NULL if this 1682 // object doesn't have call stub for R_SYM. 1683 Mips16_stub_section<size, big_endian>* 1684 get_local_mips16_call_stub(unsigned int r_sym) const 1685 { 1686 typename Mips16_stubs_int_map::const_iterator it = 1687 this->local_mips16_call_stubs_.find(r_sym); 1688 if (it != this->local_mips16_call_stubs_.end()) 1689 return (*it).second; 1690 return NULL; 1691 } 1692 1693 // Record that this object has MIPS16 call stub for local symbol. This method 1694 // is only called if we decided not to discard the stub. 1695 void 1696 add_local_mips16_call_stub(Mips16_stub_section<size, big_endian>* stub) 1697 { 1698 gold_assert(stub->is_for_local_function()); 1699 unsigned int r_sym = stub->r_sym(); 1700 this->local_mips16_call_stubs_.insert( 1701 std::pair<unsigned int, Mips16_stub_section<size, big_endian>*>( 1702 r_sym, stub)); 1703 } 1704 1705 // Record that we found "non 16-bit" call relocation against local symbol 1706 // SYMNDX. This reloc would need to refer to a MIPS16 fn stub, if there 1707 // is one. 1708 void 1709 add_local_non_16bit_call(unsigned int symndx) 1710 { this->local_non_16bit_calls_.insert(symndx); } 1711 1712 // Return true if there is any "non 16-bit" call relocation against local 1713 // symbol SYMNDX in this object. 1714 bool 1715 has_local_non_16bit_call_relocs(unsigned int symndx) 1716 { 1717 return (this->local_non_16bit_calls_.find(symndx) 1718 != this->local_non_16bit_calls_.end()); 1719 } 1720 1721 // Record that we found 16-bit call relocation R_MIPS16_26 against local 1722 // symbol SYMNDX. Local MIPS16 call or call_fp stubs will only be needed 1723 // if there is some R_MIPS16_26 relocation that refers to the stub symbol. 1724 void 1725 add_local_16bit_call(unsigned int symndx) 1726 { this->local_16bit_calls_.insert(symndx); } 1727 1728 // Return true if there is any 16-bit call relocation R_MIPS16_26 against local 1729 // symbol SYMNDX in this object. 1730 bool 1731 has_local_16bit_call_relocs(unsigned int symndx) 1732 { 1733 return (this->local_16bit_calls_.find(symndx) 1734 != this->local_16bit_calls_.end()); 1735 } 1736 1737 // Get gp value that was used to create this object. 1738 Mips_address 1739 gp_value() const 1740 { return this->gp_; } 1741 1742 // Return whether the object is a PIC object. 1743 bool 1744 is_pic() const 1745 { return this->is_pic_; } 1746 1747 // Return whether the object uses N32 ABI. 1748 bool 1749 is_n32() const 1750 { return this->is_n32_; } 1751 1752 // Return whether the object uses N64 ABI. 1753 bool 1754 is_n64() const 1755 { return size == 64; } 1756 1757 // Return whether the object uses NewABI conventions. 1758 bool 1759 is_newabi() const 1760 { return this->is_n32() || this->is_n64(); } 1761 1762 // Return Mips_got_info for this object. 1763 Mips_got_info<size, big_endian>* 1764 get_got_info() const 1765 { return this->got_info_; } 1766 1767 // Return Mips_got_info for this object. Create new info if it doesn't exist. 1768 Mips_got_info<size, big_endian>* 1769 get_or_create_got_info() 1770 { 1771 if (!this->got_info_) 1772 this->got_info_ = new Mips_got_info<size, big_endian>(); 1773 return this->got_info_; 1774 } 1775 1776 // Set Mips_got_info for this object. 1777 void 1778 set_got_info(Mips_got_info<size, big_endian>* got_info) 1779 { this->got_info_ = got_info; } 1780 1781 // Whether a section SHDNX is a MIPS16 stub section. This is only valid 1782 // after do_read_symbols is called. 1783 bool 1784 is_mips16_stub_section(unsigned int shndx) 1785 { 1786 return (is_mips16_fn_stub_section(shndx) 1787 || is_mips16_call_stub_section(shndx) 1788 || is_mips16_call_fp_stub_section(shndx)); 1789 } 1790 1791 // Return TRUE if relocations in section SHNDX can refer directly to a 1792 // MIPS16 function rather than to a hard-float stub. This is only valid 1793 // after do_read_symbols is called. 1794 bool 1795 section_allows_mips16_refs(unsigned int shndx) 1796 { 1797 return (this->is_mips16_stub_section(shndx) || shndx == this->pdr_shndx_); 1798 } 1799 1800 // Whether a section SHDNX is a MIPS16 fn stub section. This is only valid 1801 // after do_read_symbols is called. 1802 bool 1803 is_mips16_fn_stub_section(unsigned int shndx) 1804 { 1805 gold_assert(shndx < this->section_is_mips16_fn_stub_.size()); 1806 return this->section_is_mips16_fn_stub_[shndx]; 1807 } 1808 1809 // Whether a section SHDNX is a MIPS16 call stub section. This is only valid 1810 // after do_read_symbols is called. 1811 bool 1812 is_mips16_call_stub_section(unsigned int shndx) 1813 { 1814 gold_assert(shndx < this->section_is_mips16_call_stub_.size()); 1815 return this->section_is_mips16_call_stub_[shndx]; 1816 } 1817 1818 // Whether a section SHDNX is a MIPS16 call_fp stub section. This is only 1819 // valid after do_read_symbols is called. 1820 bool 1821 is_mips16_call_fp_stub_section(unsigned int shndx) 1822 { 1823 gold_assert(shndx < this->section_is_mips16_call_fp_stub_.size()); 1824 return this->section_is_mips16_call_fp_stub_[shndx]; 1825 } 1826 1827 // Discard MIPS16 stub secions that are not needed. 1828 void 1829 discard_mips16_stub_sections(Symbol_table* symtab); 1830 1831 // Return whether there is a .reginfo section. 1832 bool 1833 has_reginfo_section() const 1834 { return this->has_reginfo_section_; } 1835 1836 // Return gprmask from the .reginfo section of this object. 1837 Valtype 1838 gprmask() const 1839 { return this->gprmask_; } 1840 1841 // Return cprmask1 from the .reginfo section of this object. 1842 Valtype 1843 cprmask1() const 1844 { return this->cprmask1_; } 1845 1846 // Return cprmask2 from the .reginfo section of this object. 1847 Valtype 1848 cprmask2() const 1849 { return this->cprmask2_; } 1850 1851 // Return cprmask3 from the .reginfo section of this object. 1852 Valtype 1853 cprmask3() const 1854 { return this->cprmask3_; } 1855 1856 // Return cprmask4 from the .reginfo section of this object. 1857 Valtype 1858 cprmask4() const 1859 { return this->cprmask4_; } 1860 1861 // This is the contents of the .MIPS.abiflags section if there is one. 1862 Mips_abiflags<big_endian>* 1863 abiflags() 1864 { return this->abiflags_; } 1865 1866 // This is the contents of the .gnu.attribute section if there is one. 1867 const Attributes_section_data* 1868 attributes_section_data() const 1869 { return this->attributes_section_data_; } 1870 1871 protected: 1872 // Count the local symbols. 1873 void 1874 do_count_local_symbols(Stringpool_template<char>*, 1875 Stringpool_template<char>*); 1876 1877 // Read the symbol information. 1878 void 1879 do_read_symbols(Read_symbols_data* sd); 1880 1881 private: 1882 // The name of the options section. 1883 const char* mips_elf_options_section_name() 1884 { return this->is_newabi() ? ".MIPS.options" : ".options"; } 1885 1886 // processor-specific flags in ELF file header. 1887 elfcpp::Elf_Word processor_specific_flags_; 1888 1889 // Bit vector to tell if a local symbol is a MIPS16 symbol or not. 1890 // This is only valid after do_count_local_symbol is called. 1891 std::vector<bool> local_symbol_is_mips16_; 1892 1893 // Bit vector to tell if a local symbol is a microMIPS symbol or not. 1894 // This is only valid after do_count_local_symbol is called. 1895 std::vector<bool> local_symbol_is_micromips_; 1896 1897 // Map from section index to the MIPS16 stub for that section. This contains 1898 // all stubs found in this object. 1899 Mips16_stubs_int_map mips16_stub_sections_; 1900 1901 // Local symbols that have "non 16-bit" call relocation. This relocation 1902 // would need to refer to a MIPS16 fn stub, if there is one. 1903 std::set<unsigned int> local_non_16bit_calls_; 1904 1905 // Local symbols that have 16-bit call relocation R_MIPS16_26. Local MIPS16 1906 // call or call_fp stubs will only be needed if there is some R_MIPS16_26 1907 // relocation that refers to the stub symbol. 1908 std::set<unsigned int> local_16bit_calls_; 1909 1910 // Map from local symbol index to the MIPS16 fn stub for that symbol. 1911 // This contains only the stubs that we decided not to discard. 1912 Mips16_stubs_int_map local_mips16_fn_stubs_; 1913 1914 // Map from local symbol index to the MIPS16 call stub for that symbol. 1915 // This contains only the stubs that we decided not to discard. 1916 Mips16_stubs_int_map local_mips16_call_stubs_; 1917 1918 // gp value that was used to create this object. 1919 Mips_address gp_; 1920 // Whether the object is a PIC object. 1921 bool is_pic_ : 1; 1922 // Whether the object uses N32 ABI. 1923 bool is_n32_ : 1; 1924 // Whether the object contains a .reginfo section. 1925 bool has_reginfo_section_ : 1; 1926 // The Mips_got_info for this object. 1927 Mips_got_info<size, big_endian>* got_info_; 1928 1929 // Bit vector to tell if a section is a MIPS16 fn stub section or not. 1930 // This is only valid after do_read_symbols is called. 1931 std::vector<bool> section_is_mips16_fn_stub_; 1932 1933 // Bit vector to tell if a section is a MIPS16 call stub section or not. 1934 // This is only valid after do_read_symbols is called. 1935 std::vector<bool> section_is_mips16_call_stub_; 1936 1937 // Bit vector to tell if a section is a MIPS16 call_fp stub section or not. 1938 // This is only valid after do_read_symbols is called. 1939 std::vector<bool> section_is_mips16_call_fp_stub_; 1940 1941 // .pdr section index. 1942 unsigned int pdr_shndx_; 1943 1944 // Object attributes if there is a .gnu.attributes section or NULL. 1945 Attributes_section_data* attributes_section_data_; 1946 1947 // Object abiflags if there is a .MIPS.abiflags section or NULL. 1948 Mips_abiflags<big_endian>* abiflags_; 1949 1950 // gprmask from the .reginfo section of this object. 1951 Valtype gprmask_; 1952 // cprmask1 from the .reginfo section of this object. 1953 Valtype cprmask1_; 1954 // cprmask2 from the .reginfo section of this object. 1955 Valtype cprmask2_; 1956 // cprmask3 from the .reginfo section of this object. 1957 Valtype cprmask3_; 1958 // cprmask4 from the .reginfo section of this object. 1959 Valtype cprmask4_; 1960}; 1961 1962// Mips_output_data_got class. 1963 1964template<int size, bool big_endian> 1965class Mips_output_data_got : public Output_data_got<size, big_endian> 1966{ 1967 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 1968 typedef Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian> 1969 Reloc_section; 1970 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 1971 1972 public: 1973 Mips_output_data_got(Target_mips<size, big_endian>* target, 1974 Symbol_table* symtab, Layout* layout) 1975 : Output_data_got<size, big_endian>(), target_(target), 1976 symbol_table_(symtab), layout_(layout), static_relocs_(), got_view_(NULL), 1977 first_global_got_dynsym_index_(-1U), primary_got_(NULL), 1978 secondary_got_relocs_() 1979 { 1980 this->master_got_info_ = new Mips_got_info<size, big_endian>(); 1981 this->set_addralign(16); 1982 } 1983 1984 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol 1985 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT. 1986 void 1987 record_local_got_symbol(Mips_relobj<size, big_endian>* object, 1988 unsigned int symndx, Mips_address addend, 1989 unsigned int r_type, unsigned int shndx, 1990 bool is_section_symbol) 1991 { 1992 this->master_got_info_->record_local_got_symbol(object, symndx, addend, 1993 r_type, shndx, 1994 is_section_symbol); 1995 } 1996 1997 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM, 1998 // in OBJECT. FOR_CALL is true if the caller is only interested in 1999 // using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic 2000 // relocation. 2001 void 2002 record_global_got_symbol(Mips_symbol<size>* mips_sym, 2003 Mips_relobj<size, big_endian>* object, 2004 unsigned int r_type, bool dyn_reloc, bool for_call) 2005 { 2006 this->master_got_info_->record_global_got_symbol(mips_sym, object, r_type, 2007 dyn_reloc, for_call); 2008 } 2009 2010 // Record that OBJECT has a page relocation against symbol SYMNDX and 2011 // that ADDEND is the addend for that relocation. 2012 void 2013 record_got_page_entry(Mips_relobj<size, big_endian>* object, 2014 unsigned int symndx, int addend) 2015 { this->master_got_info_->record_got_page_entry(object, symndx, addend); } 2016 2017 // Add a static entry for the GOT entry at OFFSET. GSYM is a global 2018 // symbol and R_TYPE is the code of a dynamic relocation that needs to be 2019 // applied in a static link. 2020 void 2021 add_static_reloc(unsigned int got_offset, unsigned int r_type, 2022 Mips_symbol<size>* gsym) 2023 { this->static_relocs_.push_back(Static_reloc(got_offset, r_type, gsym)); } 2024 2025 // Add a static reloc for the GOT entry at OFFSET. RELOBJ is an object 2026 // defining a local symbol with INDEX. R_TYPE is the code of a dynamic 2027 // relocation that needs to be applied in a static link. 2028 void 2029 add_static_reloc(unsigned int got_offset, unsigned int r_type, 2030 Sized_relobj_file<size, big_endian>* relobj, 2031 unsigned int index) 2032 { 2033 this->static_relocs_.push_back(Static_reloc(got_offset, r_type, relobj, 2034 index)); 2035 } 2036 2037 // Record that global symbol GSYM has R_TYPE dynamic relocation in the 2038 // secondary GOT at OFFSET. 2039 void 2040 add_secondary_got_reloc(unsigned int got_offset, unsigned int r_type, 2041 Mips_symbol<size>* gsym) 2042 { 2043 this->secondary_got_relocs_.push_back(Static_reloc(got_offset, 2044 r_type, gsym)); 2045 } 2046 2047 // Update GOT entry at OFFSET with VALUE. 2048 void 2049 update_got_entry(unsigned int offset, Mips_address value) 2050 { 2051 elfcpp::Swap<size, big_endian>::writeval(this->got_view_ + offset, value); 2052 } 2053 2054 // Return the number of entries in local part of the GOT. This includes 2055 // local entries, page entries and 2 reserved entries. 2056 unsigned int 2057 get_local_gotno() const 2058 { 2059 if (!this->multi_got()) 2060 { 2061 return (2 + this->master_got_info_->local_gotno() 2062 + this->master_got_info_->page_gotno()); 2063 } 2064 else 2065 return 2 + this->primary_got_->local_gotno() + this->primary_got_->page_gotno(); 2066 } 2067 2068 // Return dynamic symbol table index of the first symbol with global GOT 2069 // entry. 2070 unsigned int 2071 first_global_got_dynsym_index() const 2072 { return this->first_global_got_dynsym_index_; } 2073 2074 // Set dynamic symbol table index of the first symbol with global GOT entry. 2075 void 2076 set_first_global_got_dynsym_index(unsigned int index) 2077 { this->first_global_got_dynsym_index_ = index; } 2078 2079 // Lay out the GOT. Add local, global and TLS entries. If GOT is 2080 // larger than 64K, create multi-GOT. 2081 void 2082 lay_out_got(Layout* layout, Symbol_table* symtab, 2083 const Input_objects* input_objects); 2084 2085 // Create multi-GOT. For every GOT, add local, global and TLS entries. 2086 void 2087 lay_out_multi_got(Layout* layout, const Input_objects* input_objects); 2088 2089 // Attempt to merge GOTs of different input objects. 2090 void 2091 merge_gots(const Input_objects* input_objects); 2092 2093 // Consider merging FROM, which is OBJECT's GOT, into TO. Return false if 2094 // this would lead to overflow, true if they were merged successfully. 2095 bool 2096 merge_got_with(Mips_got_info<size, big_endian>* from, 2097 Mips_relobj<size, big_endian>* object, 2098 Mips_got_info<size, big_endian>* to); 2099 2100 // Return the offset of GOT page entry for VALUE. For multi-GOT links, 2101 // use OBJECT's GOT. 2102 unsigned int 2103 get_got_page_offset(Mips_address value, 2104 const Mips_relobj<size, big_endian>* object) 2105 { 2106 Mips_got_info<size, big_endian>* g = (!this->multi_got() 2107 ? this->master_got_info_ 2108 : object->get_got_info()); 2109 gold_assert(g != NULL); 2110 return g->get_got_page_offset(value, this); 2111 } 2112 2113 // Return the GOT offset of type GOT_TYPE of the global symbol 2114 // GSYM. For multi-GOT links, use OBJECT's GOT. 2115 unsigned int got_offset(const Symbol* gsym, unsigned int got_type, 2116 Mips_relobj<size, big_endian>* object) const 2117 { 2118 if (!this->multi_got()) 2119 return gsym->got_offset(got_type); 2120 else 2121 { 2122 Mips_got_info<size, big_endian>* g = object->get_got_info(); 2123 gold_assert(g != NULL); 2124 return gsym->got_offset(g->multigot_got_type(got_type)); 2125 } 2126 } 2127 2128 // Return the GOT offset of type GOT_TYPE of the local symbol 2129 // SYMNDX. 2130 unsigned int 2131 got_offset(unsigned int symndx, unsigned int got_type, 2132 Sized_relobj_file<size, big_endian>* object, 2133 uint64_t addend) const 2134 { return object->local_got_offset(symndx, got_type, addend); } 2135 2136 // Return the offset of TLS LDM entry. For multi-GOT links, use OBJECT's GOT. 2137 unsigned int 2138 tls_ldm_offset(Mips_relobj<size, big_endian>* object) const 2139 { 2140 Mips_got_info<size, big_endian>* g = (!this->multi_got() 2141 ? this->master_got_info_ 2142 : object->get_got_info()); 2143 gold_assert(g != NULL); 2144 return g->tls_ldm_offset(); 2145 } 2146 2147 // Set the offset of TLS LDM entry. For multi-GOT links, use OBJECT's GOT. 2148 void 2149 set_tls_ldm_offset(unsigned int tls_ldm_offset, 2150 Mips_relobj<size, big_endian>* object) 2151 { 2152 Mips_got_info<size, big_endian>* g = (!this->multi_got() 2153 ? this->master_got_info_ 2154 : object->get_got_info()); 2155 gold_assert(g != NULL); 2156 g->set_tls_ldm_offset(tls_ldm_offset); 2157 } 2158 2159 // Return true for multi-GOT links. 2160 bool 2161 multi_got() const 2162 { return this->primary_got_ != NULL; } 2163 2164 // Return the offset of OBJECT's GOT from the start of .got section. 2165 unsigned int 2166 get_got_offset(const Mips_relobj<size, big_endian>* object) 2167 { 2168 if (!this->multi_got()) 2169 return 0; 2170 else 2171 { 2172 Mips_got_info<size, big_endian>* g = object->get_got_info(); 2173 return g != NULL ? g->offset() : 0; 2174 } 2175 } 2176 2177 // Create global GOT entries that should be in the GGA_RELOC_ONLY area. 2178 void 2179 add_reloc_only_entries() 2180 { this->master_got_info_->add_reloc_only_entries(this); } 2181 2182 // Return offset of the primary GOT's entry for global symbol. 2183 unsigned int 2184 get_primary_got_offset(const Mips_symbol<size>* sym) const 2185 { 2186 gold_assert(sym->global_got_area() != GGA_NONE); 2187 return (this->get_local_gotno() + sym->dynsym_index() 2188 - this->first_global_got_dynsym_index()) * size/8; 2189 } 2190 2191 // For the entry at offset GOT_OFFSET, return its offset from the gp. 2192 // Input argument GOT_OFFSET is always global offset from the start of 2193 // .got section, for both single and multi-GOT links. 2194 // For single GOT links, this returns GOT_OFFSET - 0x7FF0. For multi-GOT 2195 // links, the return value is object_got_offset - 0x7FF0, where 2196 // object_got_offset is offset in the OBJECT's GOT. 2197 int 2198 gp_offset(unsigned int got_offset, 2199 const Mips_relobj<size, big_endian>* object) const 2200 { 2201 return (this->address() + got_offset 2202 - this->target_->adjusted_gp_value(object)); 2203 } 2204 2205 protected: 2206 // Write out the GOT table. 2207 void 2208 do_write(Output_file*); 2209 2210 private: 2211 2212 // This class represent dynamic relocations that need to be applied by 2213 // gold because we are using TLS relocations in a static link. 2214 class Static_reloc 2215 { 2216 public: 2217 Static_reloc(unsigned int got_offset, unsigned int r_type, 2218 Mips_symbol<size>* gsym) 2219 : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(true) 2220 { this->u_.global.symbol = gsym; } 2221 2222 Static_reloc(unsigned int got_offset, unsigned int r_type, 2223 Sized_relobj_file<size, big_endian>* relobj, unsigned int index) 2224 : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(false) 2225 { 2226 this->u_.local.relobj = relobj; 2227 this->u_.local.index = index; 2228 } 2229 2230 // Return the GOT offset. 2231 unsigned int 2232 got_offset() const 2233 { return this->got_offset_; } 2234 2235 // Relocation type. 2236 unsigned int 2237 r_type() const 2238 { return this->r_type_; } 2239 2240 // Whether the symbol is global or not. 2241 bool 2242 symbol_is_global() const 2243 { return this->symbol_is_global_; } 2244 2245 // For a relocation against a global symbol, the global symbol. 2246 Mips_symbol<size>* 2247 symbol() const 2248 { 2249 gold_assert(this->symbol_is_global_); 2250 return this->u_.global.symbol; 2251 } 2252 2253 // For a relocation against a local symbol, the defining object. 2254 Sized_relobj_file<size, big_endian>* 2255 relobj() const 2256 { 2257 gold_assert(!this->symbol_is_global_); 2258 return this->u_.local.relobj; 2259 } 2260 2261 // For a relocation against a local symbol, the local symbol index. 2262 unsigned int 2263 index() const 2264 { 2265 gold_assert(!this->symbol_is_global_); 2266 return this->u_.local.index; 2267 } 2268 2269 private: 2270 // GOT offset of the entry to which this relocation is applied. 2271 unsigned int got_offset_; 2272 // Type of relocation. 2273 unsigned int r_type_; 2274 // Whether this relocation is against a global symbol. 2275 bool symbol_is_global_; 2276 // A global or local symbol. 2277 union 2278 { 2279 struct 2280 { 2281 // For a global symbol, the symbol itself. 2282 Mips_symbol<size>* symbol; 2283 } global; 2284 struct 2285 { 2286 // For a local symbol, the object defining object. 2287 Sized_relobj_file<size, big_endian>* relobj; 2288 // For a local symbol, the symbol index. 2289 unsigned int index; 2290 } local; 2291 } u_; 2292 }; 2293 2294 // The target. 2295 Target_mips<size, big_endian>* target_; 2296 // The symbol table. 2297 Symbol_table* symbol_table_; 2298 // The layout. 2299 Layout* layout_; 2300 // Static relocs to be applied to the GOT. 2301 std::vector<Static_reloc> static_relocs_; 2302 // .got section view. 2303 unsigned char* got_view_; 2304 // The dynamic symbol table index of the first symbol with global GOT entry. 2305 unsigned int first_global_got_dynsym_index_; 2306 // The master GOT information. 2307 Mips_got_info<size, big_endian>* master_got_info_; 2308 // The primary GOT information. 2309 Mips_got_info<size, big_endian>* primary_got_; 2310 // Secondary GOT fixups. 2311 std::vector<Static_reloc> secondary_got_relocs_; 2312}; 2313 2314// A class to handle LA25 stubs - non-PIC interface to a PIC function. There are 2315// two ways of creating these interfaces. The first is to add: 2316// 2317// lui $25,%hi(func) 2318// j func 2319// addiu $25,$25,%lo(func) 2320// 2321// to a separate trampoline section. The second is to add: 2322// 2323// lui $25,%hi(func) 2324// addiu $25,$25,%lo(func) 2325// 2326// immediately before a PIC function "func", but only if a function is at the 2327// beginning of the section, and the section is not too heavily aligned (i.e we 2328// would need to add no more than 2 nops before the stub.) 2329// 2330// We only create stubs of the first type. 2331 2332template<int size, bool big_endian> 2333class Mips_output_data_la25_stub : public Output_section_data 2334{ 2335 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 2336 2337 public: 2338 Mips_output_data_la25_stub() 2339 : Output_section_data(size == 32 ? 4 : 8), symbols_() 2340 { } 2341 2342 // Create LA25 stub for a symbol. 2343 void 2344 create_la25_stub(Symbol_table* symtab, Target_mips<size, big_endian>* target, 2345 Mips_symbol<size>* gsym); 2346 2347 // Return output address of a stub. 2348 Mips_address 2349 stub_address(const Mips_symbol<size>* sym) const 2350 { 2351 gold_assert(sym->has_la25_stub()); 2352 return this->address() + sym->la25_stub_offset(); 2353 } 2354 2355 protected: 2356 void 2357 do_adjust_output_section(Output_section* os) 2358 { os->set_entsize(0); } 2359 2360 private: 2361 // Template for standard LA25 stub. 2362 static const uint32_t la25_stub_entry[]; 2363 // Template for microMIPS LA25 stub. 2364 static const uint32_t la25_stub_micromips_entry[]; 2365 2366 // Set the final size. 2367 void 2368 set_final_data_size() 2369 { this->set_data_size(this->symbols_.size() * 16); } 2370 2371 // Create a symbol for SYM stub's value and size, to help make the 2372 // disassembly easier to read. 2373 void 2374 create_stub_symbol(Mips_symbol<size>* sym, Symbol_table* symtab, 2375 Target_mips<size, big_endian>* target, uint64_t symsize); 2376 2377 // Write to a map file. 2378 void 2379 do_print_to_mapfile(Mapfile* mapfile) const 2380 { mapfile->print_output_data(this, _(".LA25.stubs")); } 2381 2382 // Write out the LA25 stub section. 2383 void 2384 do_write(Output_file*); 2385 2386 // Symbols that have LA25 stubs. 2387 std::vector<Mips_symbol<size>*> symbols_; 2388}; 2389 2390// MIPS-specific relocation writer. 2391 2392template<int sh_type, bool dynamic, int size, bool big_endian> 2393struct Mips_output_reloc_writer; 2394 2395template<int sh_type, bool dynamic, bool big_endian> 2396struct Mips_output_reloc_writer<sh_type, dynamic, 32, big_endian> 2397{ 2398 typedef Output_reloc<sh_type, dynamic, 32, big_endian> Output_reloc_type; 2399 typedef std::vector<Output_reloc_type> Relocs; 2400 2401 static void 2402 write(typename Relocs::const_iterator p, unsigned char* pov) 2403 { p->write(pov); } 2404}; 2405 2406template<int sh_type, bool dynamic, bool big_endian> 2407struct Mips_output_reloc_writer<sh_type, dynamic, 64, big_endian> 2408{ 2409 typedef Output_reloc<sh_type, dynamic, 64, big_endian> Output_reloc_type; 2410 typedef std::vector<Output_reloc_type> Relocs; 2411 2412 static void 2413 write(typename Relocs::const_iterator p, unsigned char* pov) 2414 { 2415 elfcpp::Mips64_rel_write<big_endian> orel(pov); 2416 orel.put_r_offset(p->get_address()); 2417 orel.put_r_sym(p->get_symbol_index()); 2418 orel.put_r_ssym(RSS_UNDEF); 2419 orel.put_r_type(p->type()); 2420 if (p->type() == elfcpp::R_MIPS_REL32) 2421 orel.put_r_type2(elfcpp::R_MIPS_64); 2422 else 2423 orel.put_r_type2(elfcpp::R_MIPS_NONE); 2424 orel.put_r_type3(elfcpp::R_MIPS_NONE); 2425 } 2426}; 2427 2428template<int sh_type, bool dynamic, int size, bool big_endian> 2429class Mips_output_data_reloc : public Output_data_reloc<sh_type, dynamic, 2430 size, big_endian> 2431{ 2432 public: 2433 Mips_output_data_reloc(bool sort_relocs) 2434 : Output_data_reloc<sh_type, dynamic, size, big_endian>(sort_relocs) 2435 { } 2436 2437 protected: 2438 // Write out the data. 2439 void 2440 do_write(Output_file* of) 2441 { 2442 typedef Mips_output_reloc_writer<sh_type, dynamic, size, 2443 big_endian> Writer; 2444 this->template do_write_generic<Writer>(of); 2445 } 2446}; 2447 2448 2449// A class to handle the PLT data. 2450 2451template<int size, bool big_endian> 2452class Mips_output_data_plt : public Output_section_data 2453{ 2454 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 2455 typedef Mips_output_data_reloc<elfcpp::SHT_REL, true, 2456 size, big_endian> Reloc_section; 2457 2458 public: 2459 // Create the PLT section. The ordinary .got section is an argument, 2460 // since we need to refer to the start. 2461 Mips_output_data_plt(Layout* layout, Output_data_space* got_plt, 2462 Target_mips<size, big_endian>* target) 2463 : Output_section_data(size == 32 ? 4 : 8), got_plt_(got_plt), symbols_(), 2464 plt_mips_offset_(0), plt_comp_offset_(0), plt_header_size_(0), 2465 target_(target) 2466 { 2467 this->rel_ = new Reloc_section(false); 2468 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, 2469 elfcpp::SHF_ALLOC, this->rel_, 2470 ORDER_DYNAMIC_PLT_RELOCS, false); 2471 } 2472 2473 // Add an entry to the PLT for a symbol referenced by r_type relocation. 2474 void 2475 add_entry(Mips_symbol<size>* gsym, unsigned int r_type); 2476 2477 // Return the .rel.plt section data. 2478 Reloc_section* 2479 rel_plt() const 2480 { return this->rel_; } 2481 2482 // Return the number of PLT entries. 2483 unsigned int 2484 entry_count() const 2485 { return this->symbols_.size(); } 2486 2487 // Return the offset of the first non-reserved PLT entry. 2488 unsigned int 2489 first_plt_entry_offset() const 2490 { return sizeof(plt0_entry_o32); } 2491 2492 // Return the size of a PLT entry. 2493 unsigned int 2494 plt_entry_size() const 2495 { return sizeof(plt_entry); } 2496 2497 // Set final PLT offsets. For each symbol, determine whether standard or 2498 // compressed (MIPS16 or microMIPS) PLT entry is used. 2499 void 2500 set_plt_offsets(); 2501 2502 // Return the offset of the first standard PLT entry. 2503 unsigned int 2504 first_mips_plt_offset() const 2505 { return this->plt_header_size_; } 2506 2507 // Return the offset of the first compressed PLT entry. 2508 unsigned int 2509 first_comp_plt_offset() const 2510 { return this->plt_header_size_ + this->plt_mips_offset_; } 2511 2512 // Return whether there are any standard PLT entries. 2513 bool 2514 has_standard_entries() const 2515 { return this->plt_mips_offset_ > 0; } 2516 2517 // Return the output address of standard PLT entry. 2518 Mips_address 2519 mips_entry_address(const Mips_symbol<size>* sym) const 2520 { 2521 gold_assert (sym->has_mips_plt_offset()); 2522 return (this->address() + this->first_mips_plt_offset() 2523 + sym->mips_plt_offset()); 2524 } 2525 2526 // Return the output address of compressed (MIPS16 or microMIPS) PLT entry. 2527 Mips_address 2528 comp_entry_address(const Mips_symbol<size>* sym) const 2529 { 2530 gold_assert (sym->has_comp_plt_offset()); 2531 return (this->address() + this->first_comp_plt_offset() 2532 + sym->comp_plt_offset()); 2533 } 2534 2535 protected: 2536 void 2537 do_adjust_output_section(Output_section* os) 2538 { os->set_entsize(0); } 2539 2540 // Write to a map file. 2541 void 2542 do_print_to_mapfile(Mapfile* mapfile) const 2543 { mapfile->print_output_data(this, _(".plt")); } 2544 2545 private: 2546 // Template for the first PLT entry. 2547 static const uint32_t plt0_entry_o32[]; 2548 static const uint32_t plt0_entry_n32[]; 2549 static const uint32_t plt0_entry_n64[]; 2550 static const uint32_t plt0_entry_micromips_o32[]; 2551 static const uint32_t plt0_entry_micromips32_o32[]; 2552 2553 // Template for subsequent PLT entries. 2554 static const uint32_t plt_entry[]; 2555 static const uint32_t plt_entry_r6[]; 2556 static const uint32_t plt_entry_mips16_o32[]; 2557 static const uint32_t plt_entry_micromips_o32[]; 2558 static const uint32_t plt_entry_micromips32_o32[]; 2559 2560 // Set the final size. 2561 void 2562 set_final_data_size() 2563 { 2564 this->set_data_size(this->plt_header_size_ + this->plt_mips_offset_ 2565 + this->plt_comp_offset_); 2566 } 2567 2568 // Write out the PLT data. 2569 void 2570 do_write(Output_file*); 2571 2572 // Return whether the plt header contains microMIPS code. For the sake of 2573 // cache alignment always use a standard header whenever any standard entries 2574 // are present even if microMIPS entries are present as well. This also lets 2575 // the microMIPS header rely on the value of $v0 only set by microMIPS 2576 // entries, for a small size reduction. 2577 bool 2578 is_plt_header_compressed() const 2579 { 2580 gold_assert(this->plt_mips_offset_ + this->plt_comp_offset_ != 0); 2581 return this->target_->is_output_micromips() && this->plt_mips_offset_ == 0; 2582 } 2583 2584 // Return the size of the PLT header. 2585 unsigned int 2586 get_plt_header_size() const 2587 { 2588 if (this->target_->is_output_n64()) 2589 return 4 * sizeof(plt0_entry_n64) / sizeof(plt0_entry_n64[0]); 2590 else if (this->target_->is_output_n32()) 2591 return 4 * sizeof(plt0_entry_n32) / sizeof(plt0_entry_n32[0]); 2592 else if (!this->is_plt_header_compressed()) 2593 return 4 * sizeof(plt0_entry_o32) / sizeof(plt0_entry_o32[0]); 2594 else if (this->target_->use_32bit_micromips_instructions()) 2595 return (2 * sizeof(plt0_entry_micromips32_o32) 2596 / sizeof(plt0_entry_micromips32_o32[0])); 2597 else 2598 return (2 * sizeof(plt0_entry_micromips_o32) 2599 / sizeof(plt0_entry_micromips_o32[0])); 2600 } 2601 2602 // Return the PLT header entry. 2603 const uint32_t* 2604 get_plt_header_entry() const 2605 { 2606 if (this->target_->is_output_n64()) 2607 return plt0_entry_n64; 2608 else if (this->target_->is_output_n32()) 2609 return plt0_entry_n32; 2610 else if (!this->is_plt_header_compressed()) 2611 return plt0_entry_o32; 2612 else if (this->target_->use_32bit_micromips_instructions()) 2613 return plt0_entry_micromips32_o32; 2614 else 2615 return plt0_entry_micromips_o32; 2616 } 2617 2618 // Return the size of the standard PLT entry. 2619 unsigned int 2620 standard_plt_entry_size() const 2621 { return 4 * sizeof(plt_entry) / sizeof(plt_entry[0]); } 2622 2623 // Return the size of the compressed PLT entry. 2624 unsigned int 2625 compressed_plt_entry_size() const 2626 { 2627 gold_assert(!this->target_->is_output_newabi()); 2628 2629 if (!this->target_->is_output_micromips()) 2630 return (2 * sizeof(plt_entry_mips16_o32) 2631 / sizeof(plt_entry_mips16_o32[0])); 2632 else if (this->target_->use_32bit_micromips_instructions()) 2633 return (2 * sizeof(plt_entry_micromips32_o32) 2634 / sizeof(plt_entry_micromips32_o32[0])); 2635 else 2636 return (2 * sizeof(plt_entry_micromips_o32) 2637 / sizeof(plt_entry_micromips_o32[0])); 2638 } 2639 2640 // The reloc section. 2641 Reloc_section* rel_; 2642 // The .got.plt section. 2643 Output_data_space* got_plt_; 2644 // Symbols that have PLT entry. 2645 std::vector<Mips_symbol<size>*> symbols_; 2646 // The offset of the next standard PLT entry to create. 2647 unsigned int plt_mips_offset_; 2648 // The offset of the next compressed PLT entry to create. 2649 unsigned int plt_comp_offset_; 2650 // The size of the PLT header in bytes. 2651 unsigned int plt_header_size_; 2652 // The target. 2653 Target_mips<size, big_endian>* target_; 2654}; 2655 2656// A class to handle the .MIPS.stubs data. 2657 2658template<int size, bool big_endian> 2659class Mips_output_data_mips_stubs : public Output_section_data 2660{ 2661 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 2662 2663 // Unordered set of .MIPS.stubs entries. 2664 typedef Unordered_set<Mips_symbol<size>*, Mips_symbol_hash<size> > 2665 Mips_stubs_entry_set; 2666 2667 public: 2668 Mips_output_data_mips_stubs(Target_mips<size, big_endian>* target) 2669 : Output_section_data(size == 32 ? 4 : 8), symbols_(), dynsym_count_(-1U), 2670 stub_offsets_are_set_(false), target_(target) 2671 { } 2672 2673 // Create entry for a symbol. 2674 void 2675 make_entry(Mips_symbol<size>*); 2676 2677 // Remove entry for a symbol. 2678 void 2679 remove_entry(Mips_symbol<size>* gsym); 2680 2681 // Set stub offsets for symbols. This method expects that the number of 2682 // entries in dynamic symbol table is set. 2683 void 2684 set_lazy_stub_offsets(); 2685 2686 void 2687 set_needs_dynsym_value(); 2688 2689 // Set the number of entries in dynamic symbol table. 2690 void 2691 set_dynsym_count(unsigned int dynsym_count) 2692 { this->dynsym_count_ = dynsym_count; } 2693 2694 // Return maximum size of the stub, ie. the stub size if the dynamic symbol 2695 // count is greater than 0x10000. If the dynamic symbol count is less than 2696 // 0x10000, the stub will be 4 bytes smaller. 2697 // There's no disadvantage from using microMIPS code here, so for the sake of 2698 // pure-microMIPS binaries we prefer it whenever there's any microMIPS code in 2699 // output produced at all. This has a benefit of stubs being shorter by 2700 // 4 bytes each too, unless in the insn32 mode. 2701 unsigned int 2702 stub_max_size() const 2703 { 2704 if (!this->target_->is_output_micromips() 2705 || this->target_->use_32bit_micromips_instructions()) 2706 return 20; 2707 else 2708 return 16; 2709 } 2710 2711 // Return the size of the stub. This method expects that the final dynsym 2712 // count is set. 2713 unsigned int 2714 stub_size() const 2715 { 2716 gold_assert(this->dynsym_count_ != -1U); 2717 if (this->dynsym_count_ > 0x10000) 2718 return this->stub_max_size(); 2719 else 2720 return this->stub_max_size() - 4; 2721 } 2722 2723 // Return output address of a stub. 2724 Mips_address 2725 stub_address(const Mips_symbol<size>* sym) const 2726 { 2727 gold_assert(sym->has_lazy_stub()); 2728 return this->address() + sym->lazy_stub_offset(); 2729 } 2730 2731 protected: 2732 void 2733 do_adjust_output_section(Output_section* os) 2734 { os->set_entsize(0); } 2735 2736 // Write to a map file. 2737 void 2738 do_print_to_mapfile(Mapfile* mapfile) const 2739 { mapfile->print_output_data(this, _(".MIPS.stubs")); } 2740 2741 private: 2742 static const uint32_t lazy_stub_normal_1[]; 2743 static const uint32_t lazy_stub_normal_1_n64[]; 2744 static const uint32_t lazy_stub_normal_2[]; 2745 static const uint32_t lazy_stub_normal_2_n64[]; 2746 static const uint32_t lazy_stub_big[]; 2747 static const uint32_t lazy_stub_big_n64[]; 2748 2749 static const uint32_t lazy_stub_micromips_normal_1[]; 2750 static const uint32_t lazy_stub_micromips_normal_1_n64[]; 2751 static const uint32_t lazy_stub_micromips_normal_2[]; 2752 static const uint32_t lazy_stub_micromips_normal_2_n64[]; 2753 static const uint32_t lazy_stub_micromips_big[]; 2754 static const uint32_t lazy_stub_micromips_big_n64[]; 2755 2756 static const uint32_t lazy_stub_micromips32_normal_1[]; 2757 static const uint32_t lazy_stub_micromips32_normal_1_n64[]; 2758 static const uint32_t lazy_stub_micromips32_normal_2[]; 2759 static const uint32_t lazy_stub_micromips32_normal_2_n64[]; 2760 static const uint32_t lazy_stub_micromips32_big[]; 2761 static const uint32_t lazy_stub_micromips32_big_n64[]; 2762 2763 // Set the final size. 2764 void 2765 set_final_data_size() 2766 { this->set_data_size(this->symbols_.size() * this->stub_max_size()); } 2767 2768 // Write out the .MIPS.stubs data. 2769 void 2770 do_write(Output_file*); 2771 2772 // .MIPS.stubs symbols 2773 Mips_stubs_entry_set symbols_; 2774 // Number of entries in dynamic symbol table. 2775 unsigned int dynsym_count_; 2776 // Whether the stub offsets are set. 2777 bool stub_offsets_are_set_; 2778 // The target. 2779 Target_mips<size, big_endian>* target_; 2780}; 2781 2782// This class handles Mips .reginfo output section. 2783 2784template<int size, bool big_endian> 2785class Mips_output_section_reginfo : public Output_section_data 2786{ 2787 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 2788 2789 public: 2790 Mips_output_section_reginfo(Target_mips<size, big_endian>* target, 2791 Valtype gprmask, Valtype cprmask1, 2792 Valtype cprmask2, Valtype cprmask3, 2793 Valtype cprmask4) 2794 : Output_section_data(24, 4, true), target_(target), 2795 gprmask_(gprmask), cprmask1_(cprmask1), cprmask2_(cprmask2), 2796 cprmask3_(cprmask3), cprmask4_(cprmask4) 2797 { } 2798 2799 protected: 2800 // Write to a map file. 2801 void 2802 do_print_to_mapfile(Mapfile* mapfile) const 2803 { mapfile->print_output_data(this, _(".reginfo")); } 2804 2805 // Write out reginfo section. 2806 void 2807 do_write(Output_file* of); 2808 2809 private: 2810 Target_mips<size, big_endian>* target_; 2811 2812 // gprmask of the output .reginfo section. 2813 Valtype gprmask_; 2814 // cprmask1 of the output .reginfo section. 2815 Valtype cprmask1_; 2816 // cprmask2 of the output .reginfo section. 2817 Valtype cprmask2_; 2818 // cprmask3 of the output .reginfo section. 2819 Valtype cprmask3_; 2820 // cprmask4 of the output .reginfo section. 2821 Valtype cprmask4_; 2822}; 2823 2824// This class handles .MIPS.abiflags output section. 2825 2826template<int size, bool big_endian> 2827class Mips_output_section_abiflags : public Output_section_data 2828{ 2829 public: 2830 Mips_output_section_abiflags(const Mips_abiflags<big_endian>& abiflags) 2831 : Output_section_data(24, 8, true), abiflags_(abiflags) 2832 { } 2833 2834 protected: 2835 // Write to a map file. 2836 void 2837 do_print_to_mapfile(Mapfile* mapfile) const 2838 { mapfile->print_output_data(this, _(".MIPS.abiflags")); } 2839 2840 void 2841 do_write(Output_file* of); 2842 2843 private: 2844 const Mips_abiflags<big_endian>& abiflags_; 2845}; 2846 2847// The MIPS target has relocation types which default handling of relocatable 2848// relocation cannot process. So we have to extend the default code. 2849 2850template<bool big_endian, typename Classify_reloc> 2851class Mips_scan_relocatable_relocs : 2852 public Default_scan_relocatable_relocs<Classify_reloc> 2853{ 2854 public: 2855 // Return the strategy to use for a local symbol which is a section 2856 // symbol, given the relocation type. 2857 inline Relocatable_relocs::Reloc_strategy 2858 local_section_strategy(unsigned int r_type, Relobj* object) 2859 { 2860 if (Classify_reloc::sh_type == elfcpp::SHT_RELA) 2861 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA; 2862 else 2863 { 2864 switch (r_type) 2865 { 2866 case elfcpp::R_MIPS_26: 2867 return Relocatable_relocs::RELOC_SPECIAL; 2868 2869 default: 2870 return Default_scan_relocatable_relocs<Classify_reloc>:: 2871 local_section_strategy(r_type, object); 2872 } 2873 } 2874 } 2875}; 2876 2877// Mips_copy_relocs class. The only difference from the base class is the 2878// method emit_mips, which should be called instead of Copy_reloc_entry::emit. 2879// Mips cannot convert all relocation types to dynamic relocs. If a reloc 2880// cannot be made dynamic, a COPY reloc is emitted. 2881 2882template<int sh_type, int size, bool big_endian> 2883class Mips_copy_relocs : public Copy_relocs<sh_type, size, big_endian> 2884{ 2885 public: 2886 Mips_copy_relocs() 2887 : Copy_relocs<sh_type, size, big_endian>(elfcpp::R_MIPS_COPY) 2888 { } 2889 2890 // Emit any saved relocations which turn out to be needed. This is 2891 // called after all the relocs have been scanned. 2892 void 2893 emit_mips(Output_data_reloc<sh_type, true, size, big_endian>*, 2894 Symbol_table*, Layout*, Target_mips<size, big_endian>*); 2895 2896 private: 2897 typedef typename Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry 2898 Copy_reloc_entry; 2899 2900 // Emit this reloc if appropriate. This is called after we have 2901 // scanned all the relocations, so we know whether we emitted a 2902 // COPY relocation for SYM_. 2903 void 2904 emit_entry(Copy_reloc_entry& entry, 2905 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section, 2906 Symbol_table* symtab, Layout* layout, 2907 Target_mips<size, big_endian>* target); 2908}; 2909 2910 2911// Return true if the symbol SYM should be considered to resolve local 2912// to the current module, and false otherwise. The logic is taken from 2913// GNU ld's method _bfd_elf_symbol_refs_local_p. 2914static bool 2915symbol_refs_local(const Symbol* sym, bool has_dynsym_entry, 2916 bool local_protected) 2917{ 2918 // If it's a local sym, of course we resolve locally. 2919 if (sym == NULL) 2920 return true; 2921 2922 // STV_HIDDEN or STV_INTERNAL ones must be local. 2923 if (sym->visibility() == elfcpp::STV_HIDDEN 2924 || sym->visibility() == elfcpp::STV_INTERNAL) 2925 return true; 2926 2927 // If we don't have a definition in a regular file, then we can't 2928 // resolve locally. The sym is either undefined or dynamic. 2929 if (sym->source() != Symbol::FROM_OBJECT || sym->object()->is_dynamic() 2930 || sym->is_undefined()) 2931 return false; 2932 2933 // Forced local symbols resolve locally. 2934 if (sym->is_forced_local()) 2935 return true; 2936 2937 // As do non-dynamic symbols. 2938 if (!has_dynsym_entry) 2939 return true; 2940 2941 // At this point, we know the symbol is defined and dynamic. In an 2942 // executable it must resolve locally, likewise when building symbolic 2943 // shared libraries. 2944 if (parameters->options().output_is_executable() 2945 || parameters->options().Bsymbolic()) 2946 return true; 2947 2948 // Now deal with defined dynamic symbols in shared libraries. Ones 2949 // with default visibility might not resolve locally. 2950 if (sym->visibility() == elfcpp::STV_DEFAULT) 2951 return false; 2952 2953 // STV_PROTECTED non-function symbols are local. 2954 if (sym->type() != elfcpp::STT_FUNC) 2955 return true; 2956 2957 // Function pointer equality tests may require that STV_PROTECTED 2958 // symbols be treated as dynamic symbols. If the address of a 2959 // function not defined in an executable is set to that function's 2960 // plt entry in the executable, then the address of the function in 2961 // a shared library must also be the plt entry in the executable. 2962 return local_protected; 2963} 2964 2965// Return TRUE if references to this symbol always reference the symbol in this 2966// object. 2967static bool 2968symbol_references_local(const Symbol* sym, bool has_dynsym_entry) 2969{ 2970 return symbol_refs_local(sym, has_dynsym_entry, false); 2971} 2972 2973// Return TRUE if calls to this symbol always call the version in this object. 2974static bool 2975symbol_calls_local(const Symbol* sym, bool has_dynsym_entry) 2976{ 2977 return symbol_refs_local(sym, has_dynsym_entry, true); 2978} 2979 2980// Compare GOT offsets of two symbols. 2981 2982template<int size, bool big_endian> 2983static bool 2984got_offset_compare(Symbol* sym1, Symbol* sym2) 2985{ 2986 Mips_symbol<size>* mips_sym1 = Mips_symbol<size>::as_mips_sym(sym1); 2987 Mips_symbol<size>* mips_sym2 = Mips_symbol<size>::as_mips_sym(sym2); 2988 unsigned int area1 = mips_sym1->global_got_area(); 2989 unsigned int area2 = mips_sym2->global_got_area(); 2990 gold_assert(area1 != GGA_NONE && area1 != GGA_NONE); 2991 2992 // GGA_NORMAL entries always come before GGA_RELOC_ONLY. 2993 if (area1 != area2) 2994 return area1 < area2; 2995 2996 return mips_sym1->global_gotoffset() < mips_sym2->global_gotoffset(); 2997} 2998 2999// This method divides dynamic symbols into symbols that have GOT entry, and 3000// symbols that don't have GOT entry. It also sorts symbols with the GOT entry. 3001// Mips ABI requires that symbols with the GOT entry must be at the end of 3002// dynamic symbol table, and the order in dynamic symbol table must match the 3003// order in GOT. 3004 3005template<int size, bool big_endian> 3006static void 3007reorder_dyn_symbols(std::vector<Symbol*>* dyn_symbols, 3008 std::vector<Symbol*>* non_got_symbols, 3009 std::vector<Symbol*>* got_symbols) 3010{ 3011 for (std::vector<Symbol*>::iterator p = dyn_symbols->begin(); 3012 p != dyn_symbols->end(); 3013 ++p) 3014 { 3015 Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(*p); 3016 if (mips_sym->global_got_area() == GGA_NORMAL 3017 || mips_sym->global_got_area() == GGA_RELOC_ONLY) 3018 got_symbols->push_back(mips_sym); 3019 else 3020 non_got_symbols->push_back(mips_sym); 3021 } 3022 3023 std::sort(got_symbols->begin(), got_symbols->end(), 3024 got_offset_compare<size, big_endian>); 3025} 3026 3027// Functor class for processing the global symbol table. 3028 3029template<int size, bool big_endian> 3030class Symbol_visitor_check_symbols 3031{ 3032 public: 3033 Symbol_visitor_check_symbols(Target_mips<size, big_endian>* target, 3034 Layout* layout, Symbol_table* symtab) 3035 : target_(target), layout_(layout), symtab_(symtab) 3036 { } 3037 3038 void 3039 operator()(Sized_symbol<size>* sym) 3040 { 3041 Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(sym); 3042 if (local_pic_function<size, big_endian>(mips_sym)) 3043 { 3044 // SYM is a function that might need $25 to be valid on entry. 3045 // If we're creating a non-PIC relocatable object, mark SYM as 3046 // being PIC. If we're creating a non-relocatable object with 3047 // non-PIC branches and jumps to SYM, make sure that SYM has an la25 3048 // stub. 3049 if (parameters->options().relocatable()) 3050 { 3051 if (!parameters->options().output_is_position_independent()) 3052 mips_sym->set_pic(); 3053 } 3054 else if (mips_sym->has_nonpic_branches()) 3055 { 3056 this->target_->la25_stub_section(layout_) 3057 ->create_la25_stub(this->symtab_, this->target_, mips_sym); 3058 } 3059 } 3060 } 3061 3062 private: 3063 Target_mips<size, big_endian>* target_; 3064 Layout* layout_; 3065 Symbol_table* symtab_; 3066}; 3067 3068// Relocation types, parameterized by SHT_REL vs. SHT_RELA, size, 3069// and endianness. The relocation format for MIPS-64 is non-standard. 3070 3071template<int sh_type, int size, bool big_endian> 3072struct Mips_reloc_types; 3073 3074template<bool big_endian> 3075struct Mips_reloc_types<elfcpp::SHT_REL, 32, big_endian> 3076{ 3077 typedef typename elfcpp::Rel<32, big_endian> Reloc; 3078 typedef typename elfcpp::Rel_write<32, big_endian> Reloc_write; 3079 3080 static typename elfcpp::Elf_types<32>::Elf_Swxword 3081 get_r_addend(const Reloc*) 3082 { return 0; } 3083 3084 static inline void 3085 set_reloc_addend(Reloc_write*, 3086 typename elfcpp::Elf_types<32>::Elf_Swxword) 3087 { gold_unreachable(); } 3088}; 3089 3090template<bool big_endian> 3091struct Mips_reloc_types<elfcpp::SHT_RELA, 32, big_endian> 3092{ 3093 typedef typename elfcpp::Rela<32, big_endian> Reloc; 3094 typedef typename elfcpp::Rela_write<32, big_endian> Reloc_write; 3095 3096 static typename elfcpp::Elf_types<32>::Elf_Swxword 3097 get_r_addend(const Reloc* reloc) 3098 { return reloc->get_r_addend(); } 3099 3100 static inline void 3101 set_reloc_addend(Reloc_write* p, 3102 typename elfcpp::Elf_types<32>::Elf_Swxword val) 3103 { p->put_r_addend(val); } 3104}; 3105 3106template<bool big_endian> 3107struct Mips_reloc_types<elfcpp::SHT_REL, 64, big_endian> 3108{ 3109 typedef typename elfcpp::Mips64_rel<big_endian> Reloc; 3110 typedef typename elfcpp::Mips64_rel_write<big_endian> Reloc_write; 3111 3112 static typename elfcpp::Elf_types<64>::Elf_Swxword 3113 get_r_addend(const Reloc*) 3114 { return 0; } 3115 3116 static inline void 3117 set_reloc_addend(Reloc_write*, 3118 typename elfcpp::Elf_types<64>::Elf_Swxword) 3119 { gold_unreachable(); } 3120}; 3121 3122template<bool big_endian> 3123struct Mips_reloc_types<elfcpp::SHT_RELA, 64, big_endian> 3124{ 3125 typedef typename elfcpp::Mips64_rela<big_endian> Reloc; 3126 typedef typename elfcpp::Mips64_rela_write<big_endian> Reloc_write; 3127 3128 static typename elfcpp::Elf_types<64>::Elf_Swxword 3129 get_r_addend(const Reloc* reloc) 3130 { return reloc->get_r_addend(); } 3131 3132 static inline void 3133 set_reloc_addend(Reloc_write* p, 3134 typename elfcpp::Elf_types<64>::Elf_Swxword val) 3135 { p->put_r_addend(val); } 3136}; 3137 3138// Forward declaration. 3139static unsigned int 3140mips_get_size_for_reloc(unsigned int, Relobj*); 3141 3142// A class for inquiring about properties of a relocation, 3143// used while scanning relocs during a relocatable link and 3144// garbage collection. 3145 3146template<int sh_type_, int size, bool big_endian> 3147class Mips_classify_reloc; 3148 3149template<int sh_type_, bool big_endian> 3150class Mips_classify_reloc<sh_type_, 32, big_endian> : 3151 public gold::Default_classify_reloc<sh_type_, 32, big_endian> 3152{ 3153 public: 3154 typedef typename Mips_reloc_types<sh_type_, 32, big_endian>::Reloc 3155 Reltype; 3156 typedef typename Mips_reloc_types<sh_type_, 32, big_endian>::Reloc_write 3157 Reltype_write; 3158 3159 // Return the symbol referred to by the relocation. 3160 static inline unsigned int 3161 get_r_sym(const Reltype* reloc) 3162 { return elfcpp::elf_r_sym<32>(reloc->get_r_info()); } 3163 3164 // Return the type of the relocation. 3165 static inline unsigned int 3166 get_r_type(const Reltype* reloc) 3167 { return elfcpp::elf_r_type<32>(reloc->get_r_info()); } 3168 3169 static inline unsigned int 3170 get_r_type2(const Reltype*) 3171 { return 0; } 3172 3173 static inline unsigned int 3174 get_r_type3(const Reltype*) 3175 { return 0; } 3176 3177 static inline unsigned int 3178 get_r_ssym(const Reltype*) 3179 { return 0; } 3180 3181 // Return the explicit addend of the relocation (return 0 for SHT_REL). 3182 static inline unsigned int 3183 get_r_addend(const Reltype* reloc) 3184 { 3185 if (sh_type_ == elfcpp::SHT_REL) 3186 return 0; 3187 return Mips_reloc_types<sh_type_, 32, big_endian>::get_r_addend(reloc); 3188 } 3189 3190 // Write the r_info field to a new reloc, using the r_info field from 3191 // the original reloc, replacing the r_sym field with R_SYM. 3192 static inline void 3193 put_r_info(Reltype_write* new_reloc, Reltype* reloc, unsigned int r_sym) 3194 { 3195 unsigned int r_type = elfcpp::elf_r_type<32>(reloc->get_r_info()); 3196 new_reloc->put_r_info(elfcpp::elf_r_info<32>(r_sym, r_type)); 3197 } 3198 3199 // Write the r_addend field to a new reloc. 3200 static inline void 3201 put_r_addend(Reltype_write* to, 3202 typename elfcpp::Elf_types<32>::Elf_Swxword addend) 3203 { Mips_reloc_types<sh_type_, 32, big_endian>::set_reloc_addend(to, addend); } 3204 3205 // Return the size of the addend of the relocation (only used for SHT_REL). 3206 static unsigned int 3207 get_size_for_reloc(unsigned int r_type, Relobj* obj) 3208 { return mips_get_size_for_reloc(r_type, obj); } 3209}; 3210 3211template<int sh_type_, bool big_endian> 3212class Mips_classify_reloc<sh_type_, 64, big_endian> : 3213 public gold::Default_classify_reloc<sh_type_, 64, big_endian> 3214{ 3215 public: 3216 typedef typename Mips_reloc_types<sh_type_, 64, big_endian>::Reloc 3217 Reltype; 3218 typedef typename Mips_reloc_types<sh_type_, 64, big_endian>::Reloc_write 3219 Reltype_write; 3220 3221 // Return the symbol referred to by the relocation. 3222 static inline unsigned int 3223 get_r_sym(const Reltype* reloc) 3224 { return reloc->get_r_sym(); } 3225 3226 // Return the r_type of the relocation. 3227 static inline unsigned int 3228 get_r_type(const Reltype* reloc) 3229 { return reloc->get_r_type(); } 3230 3231 // Return the r_type2 of the relocation. 3232 static inline unsigned int 3233 get_r_type2(const Reltype* reloc) 3234 { return reloc->get_r_type2(); } 3235 3236 // Return the r_type3 of the relocation. 3237 static inline unsigned int 3238 get_r_type3(const Reltype* reloc) 3239 { return reloc->get_r_type3(); } 3240 3241 // Return the special symbol of the relocation. 3242 static inline unsigned int 3243 get_r_ssym(const Reltype* reloc) 3244 { return reloc->get_r_ssym(); } 3245 3246 // Return the explicit addend of the relocation (return 0 for SHT_REL). 3247 static inline typename elfcpp::Elf_types<64>::Elf_Swxword 3248 get_r_addend(const Reltype* reloc) 3249 { 3250 if (sh_type_ == elfcpp::SHT_REL) 3251 return 0; 3252 return Mips_reloc_types<sh_type_, 64, big_endian>::get_r_addend(reloc); 3253 } 3254 3255 // Write the r_info field to a new reloc, using the r_info field from 3256 // the original reloc, replacing the r_sym field with R_SYM. 3257 static inline void 3258 put_r_info(Reltype_write* new_reloc, Reltype* reloc, unsigned int r_sym) 3259 { 3260 new_reloc->put_r_sym(r_sym); 3261 new_reloc->put_r_ssym(reloc->get_r_ssym()); 3262 new_reloc->put_r_type3(reloc->get_r_type3()); 3263 new_reloc->put_r_type2(reloc->get_r_type2()); 3264 new_reloc->put_r_type(reloc->get_r_type()); 3265 } 3266 3267 // Write the r_addend field to a new reloc. 3268 static inline void 3269 put_r_addend(Reltype_write* to, 3270 typename elfcpp::Elf_types<64>::Elf_Swxword addend) 3271 { Mips_reloc_types<sh_type_, 64, big_endian>::set_reloc_addend(to, addend); } 3272 3273 // Return the size of the addend of the relocation (only used for SHT_REL). 3274 static unsigned int 3275 get_size_for_reloc(unsigned int r_type, Relobj* obj) 3276 { return mips_get_size_for_reloc(r_type, obj); } 3277}; 3278 3279template<int size, bool big_endian> 3280class Target_mips : public Sized_target<size, big_endian> 3281{ 3282 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 3283 typedef Mips_output_data_reloc<elfcpp::SHT_REL, true, size, big_endian> 3284 Reloc_section; 3285 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32; 3286 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 3287 typedef typename Mips_reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc 3288 Reltype; 3289 typedef typename Mips_reloc_types<elfcpp::SHT_RELA, size, big_endian>::Reloc 3290 Relatype; 3291 3292 public: 3293 Target_mips(const Target::Target_info* info = &mips_info) 3294 : Sized_target<size, big_endian>(info), got_(NULL), gp_(NULL), plt_(NULL), 3295 got_plt_(NULL), rel_dyn_(NULL), rld_map_(NULL), copy_relocs_(), 3296 dyn_relocs_(), la25_stub_(NULL), mips_mach_extensions_(), 3297 mips_stubs_(NULL), attributes_section_data_(NULL), abiflags_(NULL), 3298 mach_(0), layout_(NULL), got16_addends_(), has_abiflags_section_(false), 3299 entry_symbol_is_compressed_(false), insn32_(false) 3300 { 3301 this->add_machine_extensions(); 3302 } 3303 3304 // The offset of $gp from the beginning of the .got section. 3305 static const unsigned int MIPS_GP_OFFSET = 0x7ff0; 3306 3307 // The maximum size of the GOT for it to be addressable using 16-bit 3308 // offsets from $gp. 3309 static const unsigned int MIPS_GOT_MAX_SIZE = MIPS_GP_OFFSET + 0x7fff; 3310 3311 // Make a new symbol table entry for the Mips target. 3312 Sized_symbol<size>* 3313 make_symbol(const char*, elfcpp::STT, Object*, unsigned int, uint64_t) 3314 { return new Mips_symbol<size>(); } 3315 3316 // Process the relocations to determine unreferenced sections for 3317 // garbage collection. 3318 void 3319 gc_process_relocs(Symbol_table* symtab, 3320 Layout* layout, 3321 Sized_relobj_file<size, big_endian>* object, 3322 unsigned int data_shndx, 3323 unsigned int sh_type, 3324 const unsigned char* prelocs, 3325 size_t reloc_count, 3326 Output_section* output_section, 3327 bool needs_special_offset_handling, 3328 size_t local_symbol_count, 3329 const unsigned char* plocal_symbols); 3330 3331 // Scan the relocations to look for symbol adjustments. 3332 void 3333 scan_relocs(Symbol_table* symtab, 3334 Layout* layout, 3335 Sized_relobj_file<size, big_endian>* object, 3336 unsigned int data_shndx, 3337 unsigned int sh_type, 3338 const unsigned char* prelocs, 3339 size_t reloc_count, 3340 Output_section* output_section, 3341 bool needs_special_offset_handling, 3342 size_t local_symbol_count, 3343 const unsigned char* plocal_symbols); 3344 3345 // Finalize the sections. 3346 void 3347 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*); 3348 3349 // Relocate a section. 3350 void 3351 relocate_section(const Relocate_info<size, big_endian>*, 3352 unsigned int sh_type, 3353 const unsigned char* prelocs, 3354 size_t reloc_count, 3355 Output_section* output_section, 3356 bool needs_special_offset_handling, 3357 unsigned char* view, 3358 Mips_address view_address, 3359 section_size_type view_size, 3360 const Reloc_symbol_changes*); 3361 3362 // Scan the relocs during a relocatable link. 3363 void 3364 scan_relocatable_relocs(Symbol_table* symtab, 3365 Layout* layout, 3366 Sized_relobj_file<size, big_endian>* object, 3367 unsigned int data_shndx, 3368 unsigned int sh_type, 3369 const unsigned char* prelocs, 3370 size_t reloc_count, 3371 Output_section* output_section, 3372 bool needs_special_offset_handling, 3373 size_t local_symbol_count, 3374 const unsigned char* plocal_symbols, 3375 Relocatable_relocs*); 3376 3377 // Scan the relocs for --emit-relocs. 3378 void 3379 emit_relocs_scan(Symbol_table* symtab, 3380 Layout* layout, 3381 Sized_relobj_file<size, big_endian>* object, 3382 unsigned int data_shndx, 3383 unsigned int sh_type, 3384 const unsigned char* prelocs, 3385 size_t reloc_count, 3386 Output_section* output_section, 3387 bool needs_special_offset_handling, 3388 size_t local_symbol_count, 3389 const unsigned char* plocal_syms, 3390 Relocatable_relocs* rr); 3391 3392 // Emit relocations for a section. 3393 void 3394 relocate_relocs(const Relocate_info<size, big_endian>*, 3395 unsigned int sh_type, 3396 const unsigned char* prelocs, 3397 size_t reloc_count, 3398 Output_section* output_section, 3399 typename elfcpp::Elf_types<size>::Elf_Off 3400 offset_in_output_section, 3401 unsigned char* view, 3402 Mips_address view_address, 3403 section_size_type view_size, 3404 unsigned char* reloc_view, 3405 section_size_type reloc_view_size); 3406 3407 // Perform target-specific processing in a relocatable link. This is 3408 // only used if we use the relocation strategy RELOC_SPECIAL. 3409 void 3410 relocate_special_relocatable(const Relocate_info<size, big_endian>* relinfo, 3411 unsigned int sh_type, 3412 const unsigned char* preloc_in, 3413 size_t relnum, 3414 Output_section* output_section, 3415 typename elfcpp::Elf_types<size>::Elf_Off 3416 offset_in_output_section, 3417 unsigned char* view, 3418 Mips_address view_address, 3419 section_size_type view_size, 3420 unsigned char* preloc_out); 3421 3422 // Return whether SYM is defined by the ABI. 3423 bool 3424 do_is_defined_by_abi(const Symbol* sym) const 3425 { 3426 return ((strcmp(sym->name(), "__gnu_local_gp") == 0) 3427 || (strcmp(sym->name(), "_gp_disp") == 0) 3428 || (strcmp(sym->name(), "___tls_get_addr") == 0)); 3429 } 3430 3431 // Return the number of entries in the GOT. 3432 unsigned int 3433 got_entry_count() const 3434 { 3435 if (!this->has_got_section()) 3436 return 0; 3437 return this->got_size() / (size/8); 3438 } 3439 3440 // Return the number of entries in the PLT. 3441 unsigned int 3442 plt_entry_count() const 3443 { 3444 if (this->plt_ == NULL) 3445 return 0; 3446 return this->plt_->entry_count(); 3447 } 3448 3449 // Return the offset of the first non-reserved PLT entry. 3450 unsigned int 3451 first_plt_entry_offset() const 3452 { return this->plt_->first_plt_entry_offset(); } 3453 3454 // Return the size of each PLT entry. 3455 unsigned int 3456 plt_entry_size() const 3457 { return this->plt_->plt_entry_size(); } 3458 3459 // Get the GOT section, creating it if necessary. 3460 Mips_output_data_got<size, big_endian>* 3461 got_section(Symbol_table*, Layout*); 3462 3463 // Get the GOT section. 3464 Mips_output_data_got<size, big_endian>* 3465 got_section() const 3466 { 3467 gold_assert(this->got_ != NULL); 3468 return this->got_; 3469 } 3470 3471 // Get the .MIPS.stubs section, creating it if necessary. 3472 Mips_output_data_mips_stubs<size, big_endian>* 3473 mips_stubs_section(Layout* layout); 3474 3475 // Get the .MIPS.stubs section. 3476 Mips_output_data_mips_stubs<size, big_endian>* 3477 mips_stubs_section() const 3478 { 3479 gold_assert(this->mips_stubs_ != NULL); 3480 return this->mips_stubs_; 3481 } 3482 3483 // Get the LA25 stub section, creating it if necessary. 3484 Mips_output_data_la25_stub<size, big_endian>* 3485 la25_stub_section(Layout*); 3486 3487 // Get the LA25 stub section. 3488 Mips_output_data_la25_stub<size, big_endian>* 3489 la25_stub_section() 3490 { 3491 gold_assert(this->la25_stub_ != NULL); 3492 return this->la25_stub_; 3493 } 3494 3495 // Get gp value. It has the value of .got + 0x7FF0. 3496 Mips_address 3497 gp_value() const 3498 { 3499 if (this->gp_ != NULL) 3500 return this->gp_->value(); 3501 return 0; 3502 } 3503 3504 // Get gp value. It has the value of .got + 0x7FF0. Adjust it for 3505 // multi-GOT links so that OBJECT's GOT + 0x7FF0 is returned. 3506 Mips_address 3507 adjusted_gp_value(const Mips_relobj<size, big_endian>* object) 3508 { 3509 if (this->gp_ == NULL) 3510 return 0; 3511 3512 bool multi_got = false; 3513 if (this->has_got_section()) 3514 multi_got = this->got_section()->multi_got(); 3515 if (!multi_got) 3516 return this->gp_->value(); 3517 else 3518 return this->gp_->value() + this->got_section()->get_got_offset(object); 3519 } 3520 3521 // Get the dynamic reloc section, creating it if necessary. 3522 Reloc_section* 3523 rel_dyn_section(Layout*); 3524 3525 bool 3526 do_has_custom_set_dynsym_indexes() const 3527 { return true; } 3528 3529 // Don't emit input .reginfo/.MIPS.abiflags sections to 3530 // output .reginfo/.MIPS.abiflags. 3531 bool 3532 do_should_include_section(elfcpp::Elf_Word sh_type) const 3533 { 3534 return ((sh_type != elfcpp::SHT_MIPS_REGINFO) 3535 && (sh_type != elfcpp::SHT_MIPS_ABIFLAGS)); 3536 } 3537 3538 // Set the dynamic symbol indexes. INDEX is the index of the first 3539 // global dynamic symbol. Pointers to the symbols are stored into the 3540 // vector SYMS. The names are added to DYNPOOL. This returns an 3541 // updated dynamic symbol index. 3542 unsigned int 3543 do_set_dynsym_indexes(std::vector<Symbol*>* dyn_symbols, unsigned int index, 3544 std::vector<Symbol*>* syms, Stringpool* dynpool, 3545 Versions* versions, Symbol_table* symtab) const; 3546 3547 // Remove .MIPS.stubs entry for a symbol. 3548 void 3549 remove_lazy_stub_entry(Mips_symbol<size>* sym) 3550 { 3551 if (this->mips_stubs_ != NULL) 3552 this->mips_stubs_->remove_entry(sym); 3553 } 3554 3555 // The value to write into got[1] for SVR4 targets, to identify it is 3556 // a GNU object. The dynamic linker can then use got[1] to store the 3557 // module pointer. 3558 uint64_t 3559 mips_elf_gnu_got1_mask() 3560 { 3561 if (this->is_output_n64()) 3562 return (uint64_t)1 << 63; 3563 else 3564 return 1 << 31; 3565 } 3566 3567 // Whether the output has microMIPS code. This is valid only after 3568 // merge_obj_e_flags() is called. 3569 bool 3570 is_output_micromips() const 3571 { 3572 gold_assert(this->are_processor_specific_flags_set()); 3573 return elfcpp::is_micromips(this->processor_specific_flags()); 3574 } 3575 3576 // Whether the output uses N32 ABI. This is valid only after 3577 // merge_obj_e_flags() is called. 3578 bool 3579 is_output_n32() const 3580 { 3581 gold_assert(this->are_processor_specific_flags_set()); 3582 return elfcpp::abi_n32(this->processor_specific_flags()); 3583 } 3584 3585 // Whether the output uses R6 ISA. This is valid only after 3586 // merge_obj_e_flags() is called. 3587 bool 3588 is_output_r6() const 3589 { 3590 gold_assert(this->are_processor_specific_flags_set()); 3591 return elfcpp::r6_isa(this->processor_specific_flags()); 3592 } 3593 3594 // Whether the output uses N64 ABI. 3595 bool 3596 is_output_n64() const 3597 { return size == 64; } 3598 3599 // Whether the output uses NEWABI. This is valid only after 3600 // merge_obj_e_flags() is called. 3601 bool 3602 is_output_newabi() const 3603 { return this->is_output_n32() || this->is_output_n64(); } 3604 3605 // Whether we can only use 32-bit microMIPS instructions. 3606 bool 3607 use_32bit_micromips_instructions() const 3608 { return this->insn32_; } 3609 3610 // Return the r_sym field from a relocation. 3611 unsigned int 3612 get_r_sym(const unsigned char* preloc) const 3613 { 3614 // Since REL and RELA relocs share the same structure through 3615 // the r_info field, we can just use REL here. 3616 Reltype rel(preloc); 3617 return Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian>:: 3618 get_r_sym(&rel); 3619 } 3620 3621 protected: 3622 // Return the value to use for a dynamic symbol which requires special 3623 // treatment. This is how we support equality comparisons of function 3624 // pointers across shared library boundaries, as described in the 3625 // processor specific ABI supplement. 3626 uint64_t 3627 do_dynsym_value(const Symbol* gsym) const; 3628 3629 // Make an ELF object. 3630 Object* 3631 do_make_elf_object(const std::string&, Input_file*, off_t, 3632 const elfcpp::Ehdr<size, big_endian>& ehdr); 3633 3634 Object* 3635 do_make_elf_object(const std::string&, Input_file*, off_t, 3636 const elfcpp::Ehdr<size, !big_endian>&) 3637 { gold_unreachable(); } 3638 3639 // Adjust ELF file header. 3640 void 3641 do_adjust_elf_header(unsigned char* view, int len); 3642 3643 // Get the custom dynamic tag value. 3644 unsigned int 3645 do_dynamic_tag_custom_value(elfcpp::DT) const; 3646 3647 // Adjust the value written to the dynamic symbol table. 3648 virtual void 3649 do_adjust_dyn_symbol(const Symbol* sym, unsigned char* view) const 3650 { 3651 elfcpp::Sym<size, big_endian> isym(view); 3652 elfcpp::Sym_write<size, big_endian> osym(view); 3653 const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(sym); 3654 3655 // Keep dynamic compressed symbols odd. This allows the dynamic linker 3656 // to treat compressed symbols like any other. 3657 Mips_address value = isym.get_st_value(); 3658 if (mips_sym->is_mips16() && value != 0) 3659 { 3660 if (!mips_sym->has_mips16_fn_stub()) 3661 value |= 1; 3662 else 3663 { 3664 // If we have a MIPS16 function with a stub, the dynamic symbol 3665 // must refer to the stub, since only the stub uses the standard 3666 // calling conventions. Stub contains MIPS32 code, so don't add +1 3667 // in this case. 3668 3669 // There is a code which does this in the method 3670 // Target_mips::do_dynsym_value, but that code will only be 3671 // executed if the symbol is from dynobj. 3672 // TODO(sasa): GNU ld also changes the value in non-dynamic symbol 3673 // table. 3674 3675 Mips16_stub_section<size, big_endian>* fn_stub = 3676 mips_sym->template get_mips16_fn_stub<big_endian>(); 3677 value = fn_stub->output_address(); 3678 osym.put_st_size(fn_stub->section_size()); 3679 } 3680 3681 osym.put_st_value(value); 3682 osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), 3683 mips_sym->nonvis() - (elfcpp::STO_MIPS16 >> 2))); 3684 } 3685 else if ((mips_sym->is_micromips() 3686 // Stubs are always microMIPS if there is any microMIPS code in 3687 // the output. 3688 || (this->is_output_micromips() && mips_sym->has_lazy_stub())) 3689 && value != 0) 3690 { 3691 osym.put_st_value(value | 1); 3692 osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), 3693 mips_sym->nonvis() - (elfcpp::STO_MICROMIPS >> 2))); 3694 } 3695 } 3696 3697 private: 3698 // The class which scans relocations. 3699 class Scan 3700 { 3701 public: 3702 Scan() 3703 { } 3704 3705 static inline int 3706 get_reference_flags(unsigned int r_type); 3707 3708 inline void 3709 local(Symbol_table* symtab, Layout* layout, Target_mips* target, 3710 Sized_relobj_file<size, big_endian>* object, 3711 unsigned int data_shndx, 3712 Output_section* output_section, 3713 const Reltype& reloc, unsigned int r_type, 3714 const elfcpp::Sym<size, big_endian>& lsym, 3715 bool is_discarded); 3716 3717 inline void 3718 local(Symbol_table* symtab, Layout* layout, Target_mips* target, 3719 Sized_relobj_file<size, big_endian>* object, 3720 unsigned int data_shndx, 3721 Output_section* output_section, 3722 const Relatype& reloc, unsigned int r_type, 3723 const elfcpp::Sym<size, big_endian>& lsym, 3724 bool is_discarded); 3725 3726 inline void 3727 local(Symbol_table* symtab, Layout* layout, Target_mips* target, 3728 Sized_relobj_file<size, big_endian>* object, 3729 unsigned int data_shndx, 3730 Output_section* output_section, 3731 const Relatype* rela, 3732 const Reltype* rel, 3733 unsigned int rel_type, 3734 unsigned int r_type, 3735 const elfcpp::Sym<size, big_endian>& lsym, 3736 bool is_discarded); 3737 3738 inline void 3739 global(Symbol_table* symtab, Layout* layout, Target_mips* target, 3740 Sized_relobj_file<size, big_endian>* object, 3741 unsigned int data_shndx, 3742 Output_section* output_section, 3743 const Reltype& reloc, unsigned int r_type, 3744 Symbol* gsym); 3745 3746 inline void 3747 global(Symbol_table* symtab, Layout* layout, Target_mips* target, 3748 Sized_relobj_file<size, big_endian>* object, 3749 unsigned int data_shndx, 3750 Output_section* output_section, 3751 const Relatype& reloc, unsigned int r_type, 3752 Symbol* gsym); 3753 3754 inline void 3755 global(Symbol_table* symtab, Layout* layout, Target_mips* target, 3756 Sized_relobj_file<size, big_endian>* object, 3757 unsigned int data_shndx, 3758 Output_section* output_section, 3759 const Relatype* rela, 3760 const Reltype* rel, 3761 unsigned int rel_type, 3762 unsigned int r_type, 3763 Symbol* gsym); 3764 3765 inline bool 3766 local_reloc_may_be_function_pointer(Symbol_table* , Layout*, 3767 Target_mips*, 3768 Sized_relobj_file<size, big_endian>*, 3769 unsigned int, 3770 Output_section*, 3771 const Reltype&, 3772 unsigned int, 3773 const elfcpp::Sym<size, big_endian>&) 3774 { return false; } 3775 3776 inline bool 3777 global_reloc_may_be_function_pointer(Symbol_table*, Layout*, 3778 Target_mips*, 3779 Sized_relobj_file<size, big_endian>*, 3780 unsigned int, 3781 Output_section*, 3782 const Reltype&, 3783 unsigned int, Symbol*) 3784 { return false; } 3785 3786 inline bool 3787 local_reloc_may_be_function_pointer(Symbol_table*, Layout*, 3788 Target_mips*, 3789 Sized_relobj_file<size, big_endian>*, 3790 unsigned int, 3791 Output_section*, 3792 const Relatype&, 3793 unsigned int, 3794 const elfcpp::Sym<size, big_endian>&) 3795 { return false; } 3796 3797 inline bool 3798 global_reloc_may_be_function_pointer(Symbol_table*, Layout*, 3799 Target_mips*, 3800 Sized_relobj_file<size, big_endian>*, 3801 unsigned int, 3802 Output_section*, 3803 const Relatype&, 3804 unsigned int, Symbol*) 3805 { return false; } 3806 private: 3807 static void 3808 unsupported_reloc_local(Sized_relobj_file<size, big_endian>*, 3809 unsigned int r_type); 3810 3811 static void 3812 unsupported_reloc_global(Sized_relobj_file<size, big_endian>*, 3813 unsigned int r_type, Symbol*); 3814 }; 3815 3816 // The class which implements relocation. 3817 class Relocate 3818 { 3819 public: 3820 Relocate() 3821 { } 3822 3823 ~Relocate() 3824 { } 3825 3826 // Return whether a R_MIPS_32/R_MIPS_64 relocation needs to be applied. 3827 inline bool 3828 should_apply_static_reloc(const Mips_symbol<size>* gsym, 3829 unsigned int r_type, 3830 Output_section* output_section, 3831 Target_mips* target); 3832 3833 // Do a relocation. Return false if the caller should not issue 3834 // any warnings about this relocation. 3835 inline bool 3836 relocate(const Relocate_info<size, big_endian>*, unsigned int, 3837 Target_mips*, Output_section*, size_t, const unsigned char*, 3838 const Sized_symbol<size>*, const Symbol_value<size>*, 3839 unsigned char*, Mips_address, section_size_type); 3840 }; 3841 3842 // This POD class holds the dynamic relocations that should be emitted instead 3843 // of R_MIPS_32, R_MIPS_REL32 and R_MIPS_64 relocations. We will emit these 3844 // relocations if it turns out that the symbol does not have static 3845 // relocations. 3846 class Dyn_reloc 3847 { 3848 public: 3849 Dyn_reloc(Mips_symbol<size>* sym, unsigned int r_type, 3850 Mips_relobj<size, big_endian>* relobj, unsigned int shndx, 3851 Output_section* output_section, Mips_address r_offset) 3852 : sym_(sym), r_type_(r_type), relobj_(relobj), 3853 shndx_(shndx), output_section_(output_section), 3854 r_offset_(r_offset) 3855 { } 3856 3857 // Emit this reloc if appropriate. This is called after we have 3858 // scanned all the relocations, so we know whether the symbol has 3859 // static relocations. 3860 void 3861 emit(Reloc_section* rel_dyn, Mips_output_data_got<size, big_endian>* got, 3862 Symbol_table* symtab) 3863 { 3864 if (!this->sym_->has_static_relocs()) 3865 { 3866 got->record_global_got_symbol(this->sym_, this->relobj_, 3867 this->r_type_, true, false); 3868 if (!symbol_references_local(this->sym_, 3869 this->sym_->should_add_dynsym_entry(symtab))) 3870 rel_dyn->add_global(this->sym_, this->r_type_, 3871 this->output_section_, this->relobj_, 3872 this->shndx_, this->r_offset_); 3873 else 3874 rel_dyn->add_symbolless_global_addend(this->sym_, this->r_type_, 3875 this->output_section_, this->relobj_, 3876 this->shndx_, this->r_offset_); 3877 } 3878 } 3879 3880 private: 3881 Mips_symbol<size>* sym_; 3882 unsigned int r_type_; 3883 Mips_relobj<size, big_endian>* relobj_; 3884 unsigned int shndx_; 3885 Output_section* output_section_; 3886 Mips_address r_offset_; 3887 }; 3888 3889 // Adjust TLS relocation type based on the options and whether this 3890 // is a local symbol. 3891 static tls::Tls_optimization 3892 optimize_tls_reloc(bool is_final, int r_type); 3893 3894 // Return whether there is a GOT section. 3895 bool 3896 has_got_section() const 3897 { return this->got_ != NULL; } 3898 3899 // Check whether the given ELF header flags describe a 32-bit binary. 3900 bool 3901 mips_32bit_flags(elfcpp::Elf_Word); 3902 3903 enum Mips_mach { 3904 mach_mips3000 = 3000, 3905 mach_mips3900 = 3900, 3906 mach_mips4000 = 4000, 3907 mach_mips4010 = 4010, 3908 mach_mips4100 = 4100, 3909 mach_mips4111 = 4111, 3910 mach_mips4120 = 4120, 3911 mach_mips4300 = 4300, 3912 mach_mips4400 = 4400, 3913 mach_mips4600 = 4600, 3914 mach_mips4650 = 4650, 3915 mach_mips5000 = 5000, 3916 mach_mips5400 = 5400, 3917 mach_mips5500 = 5500, 3918 mach_mips5900 = 5900, 3919 mach_mips6000 = 6000, 3920 mach_mips7000 = 7000, 3921 mach_mips8000 = 8000, 3922 mach_mips9000 = 9000, 3923 mach_mips10000 = 10000, 3924 mach_mips12000 = 12000, 3925 mach_mips14000 = 14000, 3926 mach_mips16000 = 16000, 3927 mach_mips16 = 16, 3928 mach_mips5 = 5, 3929 mach_mips_loongson_2e = 3001, 3930 mach_mips_loongson_2f = 3002, 3931 mach_mips_loongson_3a = 3003, 3932 mach_mips_sb1 = 12310201, // octal 'SB', 01 3933 mach_mips_octeon = 6501, 3934 mach_mips_octeonp = 6601, 3935 mach_mips_octeon2 = 6502, 3936 mach_mips_octeon3 = 6503, 3937 mach_mips_xlr = 887682, // decimal 'XLR' 3938 mach_mipsisa32 = 32, 3939 mach_mipsisa32r2 = 33, 3940 mach_mipsisa32r3 = 34, 3941 mach_mipsisa32r5 = 36, 3942 mach_mipsisa32r6 = 37, 3943 mach_mipsisa64 = 64, 3944 mach_mipsisa64r2 = 65, 3945 mach_mipsisa64r3 = 66, 3946 mach_mipsisa64r5 = 68, 3947 mach_mipsisa64r6 = 69, 3948 mach_mips_micromips = 96 3949 }; 3950 3951 // Return the MACH for a MIPS e_flags value. 3952 unsigned int 3953 elf_mips_mach(elfcpp::Elf_Word); 3954 3955 // Return the MACH for each .MIPS.abiflags ISA Extension. 3956 unsigned int 3957 mips_isa_ext_mach(unsigned int); 3958 3959 // Return the .MIPS.abiflags value representing each ISA Extension. 3960 unsigned int 3961 mips_isa_ext(unsigned int); 3962 3963 // Update the isa_level, isa_rev, isa_ext fields of abiflags. 3964 void 3965 update_abiflags_isa(const std::string&, elfcpp::Elf_Word, 3966 Mips_abiflags<big_endian>*); 3967 3968 // Infer the content of the ABI flags based on the elf header. 3969 void 3970 infer_abiflags(Mips_relobj<size, big_endian>*, Mips_abiflags<big_endian>*); 3971 3972 // Create abiflags from elf header or from .MIPS.abiflags section. 3973 void 3974 create_abiflags(Mips_relobj<size, big_endian>*, Mips_abiflags<big_endian>*); 3975 3976 // Return the meaning of fp_abi, or "unknown" if not known. 3977 const char* 3978 fp_abi_string(int); 3979 3980 // Select fp_abi. 3981 int 3982 select_fp_abi(const std::string&, int, int); 3983 3984 // Merge attributes from input object. 3985 void 3986 merge_obj_attributes(const std::string&, const Attributes_section_data*); 3987 3988 // Merge abiflags from input object. 3989 void 3990 merge_obj_abiflags(const std::string&, Mips_abiflags<big_endian>*); 3991 3992 // Check whether machine EXTENSION is an extension of machine BASE. 3993 bool 3994 mips_mach_extends(unsigned int, unsigned int); 3995 3996 // Merge file header flags from input object. 3997 void 3998 merge_obj_e_flags(const std::string&, elfcpp::Elf_Word); 3999 4000 // Encode ISA level and revision as a single value. 4001 int 4002 level_rev(unsigned char isa_level, unsigned char isa_rev) const 4003 { return (isa_level << 3) | isa_rev; } 4004 4005 // True if we are linking for CPUs that are faster if JAL is converted to BAL. 4006 static inline bool 4007 jal_to_bal() 4008 { return false; } 4009 4010 // True if we are linking for CPUs that are faster if JALR is converted to 4011 // BAL. This should be safe for all architectures. We enable this predicate 4012 // for all CPUs. 4013 static inline bool 4014 jalr_to_bal() 4015 { return true; } 4016 4017 // True if we are linking for CPUs that are faster if JR is converted to B. 4018 // This should be safe for all architectures. We enable this predicate for 4019 // all CPUs. 4020 static inline bool 4021 jr_to_b() 4022 { return true; } 4023 4024 // Return the size of the GOT section. 4025 section_size_type 4026 got_size() const 4027 { 4028 gold_assert(this->got_ != NULL); 4029 return this->got_->data_size(); 4030 } 4031 4032 // Create a PLT entry for a global symbol referenced by r_type relocation. 4033 void 4034 make_plt_entry(Symbol_table*, Layout*, Mips_symbol<size>*, 4035 unsigned int r_type); 4036 4037 // Get the PLT section. 4038 Mips_output_data_plt<size, big_endian>* 4039 plt_section() const 4040 { 4041 gold_assert(this->plt_ != NULL); 4042 return this->plt_; 4043 } 4044 4045 // Get the GOT PLT section. 4046 const Mips_output_data_plt<size, big_endian>* 4047 got_plt_section() const 4048 { 4049 gold_assert(this->got_plt_ != NULL); 4050 return this->got_plt_; 4051 } 4052 4053 // Copy a relocation against a global symbol. 4054 void 4055 copy_reloc(Symbol_table* symtab, Layout* layout, 4056 Sized_relobj_file<size, big_endian>* object, 4057 unsigned int shndx, Output_section* output_section, 4058 Symbol* sym, unsigned int r_type, Mips_address r_offset) 4059 { 4060 this->copy_relocs_.copy_reloc(symtab, layout, 4061 symtab->get_sized_symbol<size>(sym), 4062 object, shndx, output_section, 4063 r_type, r_offset, 0, 4064 this->rel_dyn_section(layout)); 4065 } 4066 4067 void 4068 dynamic_reloc(Mips_symbol<size>* sym, unsigned int r_type, 4069 Mips_relobj<size, big_endian>* relobj, 4070 unsigned int shndx, Output_section* output_section, 4071 Mips_address r_offset) 4072 { 4073 this->dyn_relocs_.push_back(Dyn_reloc(sym, r_type, relobj, shndx, 4074 output_section, r_offset)); 4075 } 4076 4077 // Calculate value of _gp symbol. 4078 void 4079 set_gp(Layout*, Symbol_table*); 4080 4081 const char* 4082 elf_mips_abi_name(elfcpp::Elf_Word e_flags); 4083 const char* 4084 elf_mips_mach_name(elfcpp::Elf_Word e_flags); 4085 4086 // Adds entries that describe how machines relate to one another. The entries 4087 // are ordered topologically with MIPS I extensions listed last. First 4088 // element is extension, second element is base. 4089 void 4090 add_machine_extensions() 4091 { 4092 // MIPS64r2 extensions. 4093 this->add_extension(mach_mips_octeon3, mach_mips_octeon2); 4094 this->add_extension(mach_mips_octeon2, mach_mips_octeonp); 4095 this->add_extension(mach_mips_octeonp, mach_mips_octeon); 4096 this->add_extension(mach_mips_octeon, mach_mipsisa64r2); 4097 this->add_extension(mach_mips_loongson_3a, mach_mipsisa64r2); 4098 4099 // MIPS64 extensions. 4100 this->add_extension(mach_mipsisa64r2, mach_mipsisa64); 4101 this->add_extension(mach_mips_sb1, mach_mipsisa64); 4102 this->add_extension(mach_mips_xlr, mach_mipsisa64); 4103 4104 // MIPS V extensions. 4105 this->add_extension(mach_mipsisa64, mach_mips5); 4106 4107 // R10000 extensions. 4108 this->add_extension(mach_mips12000, mach_mips10000); 4109 this->add_extension(mach_mips14000, mach_mips10000); 4110 this->add_extension(mach_mips16000, mach_mips10000); 4111 4112 // R5000 extensions. Note: the vr5500 ISA is an extension of the core 4113 // vr5400 ISA, but doesn't include the multimedia stuff. It seems 4114 // better to allow vr5400 and vr5500 code to be merged anyway, since 4115 // many libraries will just use the core ISA. Perhaps we could add 4116 // some sort of ASE flag if this ever proves a problem. 4117 this->add_extension(mach_mips5500, mach_mips5400); 4118 this->add_extension(mach_mips5400, mach_mips5000); 4119 4120 // MIPS IV extensions. 4121 this->add_extension(mach_mips5, mach_mips8000); 4122 this->add_extension(mach_mips10000, mach_mips8000); 4123 this->add_extension(mach_mips5000, mach_mips8000); 4124 this->add_extension(mach_mips7000, mach_mips8000); 4125 this->add_extension(mach_mips9000, mach_mips8000); 4126 4127 // VR4100 extensions. 4128 this->add_extension(mach_mips4120, mach_mips4100); 4129 this->add_extension(mach_mips4111, mach_mips4100); 4130 4131 // MIPS III extensions. 4132 this->add_extension(mach_mips_loongson_2e, mach_mips4000); 4133 this->add_extension(mach_mips_loongson_2f, mach_mips4000); 4134 this->add_extension(mach_mips8000, mach_mips4000); 4135 this->add_extension(mach_mips4650, mach_mips4000); 4136 this->add_extension(mach_mips4600, mach_mips4000); 4137 this->add_extension(mach_mips4400, mach_mips4000); 4138 this->add_extension(mach_mips4300, mach_mips4000); 4139 this->add_extension(mach_mips4100, mach_mips4000); 4140 this->add_extension(mach_mips4010, mach_mips4000); 4141 this->add_extension(mach_mips5900, mach_mips4000); 4142 4143 // MIPS32 extensions. 4144 this->add_extension(mach_mipsisa32r2, mach_mipsisa32); 4145 4146 // MIPS II extensions. 4147 this->add_extension(mach_mips4000, mach_mips6000); 4148 this->add_extension(mach_mipsisa32, mach_mips6000); 4149 4150 // MIPS I extensions. 4151 this->add_extension(mach_mips6000, mach_mips3000); 4152 this->add_extension(mach_mips3900, mach_mips3000); 4153 } 4154 4155 // Add value to MIPS extenstions. 4156 void 4157 add_extension(unsigned int base, unsigned int extension) 4158 { 4159 std::pair<unsigned int, unsigned int> ext(base, extension); 4160 this->mips_mach_extensions_.push_back(ext); 4161 } 4162 4163 // Return the number of entries in the .dynsym section. 4164 unsigned int get_dt_mips_symtabno() const 4165 { 4166 return ((unsigned int)(this->layout_->dynsym_section()->data_size() 4167 / elfcpp::Elf_sizes<size>::sym_size)); 4168 // TODO(sasa): Entry size is MIPS_ELF_SYM_SIZE. 4169 } 4170 4171 // Information about this specific target which we pass to the 4172 // general Target structure. 4173 static const Target::Target_info mips_info; 4174 // The GOT section. 4175 Mips_output_data_got<size, big_endian>* got_; 4176 // gp symbol. It has the value of .got + 0x7FF0. 4177 Sized_symbol<size>* gp_; 4178 // The PLT section. 4179 Mips_output_data_plt<size, big_endian>* plt_; 4180 // The GOT PLT section. 4181 Output_data_space* got_plt_; 4182 // The dynamic reloc section. 4183 Reloc_section* rel_dyn_; 4184 // The .rld_map section. 4185 Output_data_zero_fill* rld_map_; 4186 // Relocs saved to avoid a COPY reloc. 4187 Mips_copy_relocs<elfcpp::SHT_REL, size, big_endian> copy_relocs_; 4188 4189 // A list of dyn relocs to be saved. 4190 std::vector<Dyn_reloc> dyn_relocs_; 4191 4192 // The LA25 stub section. 4193 Mips_output_data_la25_stub<size, big_endian>* la25_stub_; 4194 // Architecture extensions. 4195 std::vector<std::pair<unsigned int, unsigned int> > mips_mach_extensions_; 4196 // .MIPS.stubs 4197 Mips_output_data_mips_stubs<size, big_endian>* mips_stubs_; 4198 4199 // Attributes section data in output. 4200 Attributes_section_data* attributes_section_data_; 4201 // .MIPS.abiflags section data in output. 4202 Mips_abiflags<big_endian>* abiflags_; 4203 4204 unsigned int mach_; 4205 Layout* layout_; 4206 4207 typename std::list<got16_addend<size, big_endian> > got16_addends_; 4208 4209 // Whether there is an input .MIPS.abiflags section. 4210 bool has_abiflags_section_; 4211 4212 // Whether the entry symbol is mips16 or micromips. 4213 bool entry_symbol_is_compressed_; 4214 4215 // Whether we can use only 32-bit microMIPS instructions. 4216 // TODO(sasa): This should be a linker option. 4217 bool insn32_; 4218}; 4219 4220// Helper structure for R_MIPS*_HI16/LO16 and R_MIPS*_GOT16/LO16 relocations. 4221// It records high part of the relocation pair. 4222 4223template<int size, bool big_endian> 4224struct reloc_high 4225{ 4226 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 4227 4228 reloc_high(unsigned char* _view, const Mips_relobj<size, big_endian>* _object, 4229 const Symbol_value<size>* _psymval, Mips_address _addend, 4230 unsigned int _r_type, unsigned int _r_sym, bool _extract_addend, 4231 Mips_address _address = 0, bool _gp_disp = false) 4232 : view(_view), object(_object), psymval(_psymval), addend(_addend), 4233 r_type(_r_type), r_sym(_r_sym), extract_addend(_extract_addend), 4234 address(_address), gp_disp(_gp_disp) 4235 { } 4236 4237 unsigned char* view; 4238 const Mips_relobj<size, big_endian>* object; 4239 const Symbol_value<size>* psymval; 4240 Mips_address addend; 4241 unsigned int r_type; 4242 unsigned int r_sym; 4243 bool extract_addend; 4244 Mips_address address; 4245 bool gp_disp; 4246}; 4247 4248template<int size, bool big_endian> 4249class Mips_relocate_functions : public Relocate_functions<size, big_endian> 4250{ 4251 typedef typename elfcpp::Elf_types<size>::Elf_Addr Mips_address; 4252 typedef typename elfcpp::Swap<size, big_endian>::Valtype Valtype; 4253 typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype16; 4254 typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype32; 4255 typedef typename elfcpp::Swap<64, big_endian>::Valtype Valtype64; 4256 4257 public: 4258 typedef enum 4259 { 4260 STATUS_OKAY, // No error during relocation. 4261 STATUS_OVERFLOW, // Relocation overflow. 4262 STATUS_BAD_RELOC, // Relocation cannot be applied. 4263 STATUS_PCREL_UNALIGNED // Unaligned PC-relative relocation. 4264 } Status; 4265 4266 private: 4267 typedef Relocate_functions<size, big_endian> Base; 4268 typedef Mips_relocate_functions<size, big_endian> This; 4269 4270 static typename std::list<reloc_high<size, big_endian> > hi16_relocs; 4271 static typename std::list<reloc_high<size, big_endian> > got16_relocs; 4272 static typename std::list<reloc_high<size, big_endian> > pchi16_relocs; 4273 4274 template<int valsize> 4275 static inline typename This::Status 4276 check_overflow(Valtype value) 4277 { 4278 if (size == 32) 4279 return (Bits<valsize>::has_overflow32(value) 4280 ? This::STATUS_OVERFLOW 4281 : This::STATUS_OKAY); 4282 4283 return (Bits<valsize>::has_overflow(value) 4284 ? This::STATUS_OVERFLOW 4285 : This::STATUS_OKAY); 4286 } 4287 4288 static inline bool 4289 should_shuffle_micromips_reloc(unsigned int r_type) 4290 { 4291 return (micromips_reloc(r_type) 4292 && r_type != elfcpp::R_MICROMIPS_PC7_S1 4293 && r_type != elfcpp::R_MICROMIPS_PC10_S1); 4294 } 4295 4296 public: 4297 // R_MIPS16_26 is used for the mips16 jal and jalx instructions. 4298 // Most mips16 instructions are 16 bits, but these instructions 4299 // are 32 bits. 4300 // 4301 // The format of these instructions is: 4302 // 4303 // +--------------+--------------------------------+ 4304 // | JALX | X| Imm 20:16 | Imm 25:21 | 4305 // +--------------+--------------------------------+ 4306 // | Immediate 15:0 | 4307 // +-----------------------------------------------+ 4308 // 4309 // JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx. 4310 // Note that the immediate value in the first word is swapped. 4311 // 4312 // When producing a relocatable object file, R_MIPS16_26 is 4313 // handled mostly like R_MIPS_26. In particular, the addend is 4314 // stored as a straight 26-bit value in a 32-bit instruction. 4315 // (gas makes life simpler for itself by never adjusting a 4316 // R_MIPS16_26 reloc to be against a section, so the addend is 4317 // always zero). However, the 32 bit instruction is stored as 2 4318 // 16-bit values, rather than a single 32-bit value. In a 4319 // big-endian file, the result is the same; in a little-endian 4320 // file, the two 16-bit halves of the 32 bit value are swapped. 4321 // This is so that a disassembler can recognize the jal 4322 // instruction. 4323 // 4324 // When doing a final link, R_MIPS16_26 is treated as a 32 bit 4325 // instruction stored as two 16-bit values. The addend A is the 4326 // contents of the targ26 field. The calculation is the same as 4327 // R_MIPS_26. When storing the calculated value, reorder the 4328 // immediate value as shown above, and don't forget to store the 4329 // value as two 16-bit values. 4330 // 4331 // To put it in MIPS ABI terms, the relocation field is T-targ26-16, 4332 // defined as 4333 // 4334 // big-endian: 4335 // +--------+----------------------+ 4336 // | | | 4337 // | | targ26-16 | 4338 // |31 26|25 0| 4339 // +--------+----------------------+ 4340 // 4341 // little-endian: 4342 // +----------+------+-------------+ 4343 // | | | | 4344 // | sub1 | | sub2 | 4345 // |0 9|10 15|16 31| 4346 // +----------+--------------------+ 4347 // where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is 4348 // ((sub1 << 16) | sub2)). 4349 // 4350 // When producing a relocatable object file, the calculation is 4351 // (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 4352 // When producing a fully linked file, the calculation is 4353 // let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 4354 // ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) 4355 // 4356 // The table below lists the other MIPS16 instruction relocations. 4357 // Each one is calculated in the same way as the non-MIPS16 relocation 4358 // given on the right, but using the extended MIPS16 layout of 16-bit 4359 // immediate fields: 4360 // 4361 // R_MIPS16_GPREL R_MIPS_GPREL16 4362 // R_MIPS16_GOT16 R_MIPS_GOT16 4363 // R_MIPS16_CALL16 R_MIPS_CALL16 4364 // R_MIPS16_HI16 R_MIPS_HI16 4365 // R_MIPS16_LO16 R_MIPS_LO16 4366 // 4367 // A typical instruction will have a format like this: 4368 // 4369 // +--------------+--------------------------------+ 4370 // | EXTEND | Imm 10:5 | Imm 15:11 | 4371 // +--------------+--------------------------------+ 4372 // | Major | rx | ry | Imm 4:0 | 4373 // +--------------+--------------------------------+ 4374 // 4375 // EXTEND is the five bit value 11110. Major is the instruction 4376 // opcode. 4377 // 4378 // All we need to do here is shuffle the bits appropriately. 4379 // As above, the two 16-bit halves must be swapped on a 4380 // little-endian system. 4381 4382 // Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped 4383 // on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1 4384 // and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. 4385 4386 static void 4387 mips_reloc_unshuffle(unsigned char* view, unsigned int r_type, 4388 bool jal_shuffle) 4389 { 4390 if (!mips16_reloc(r_type) 4391 && !should_shuffle_micromips_reloc(r_type)) 4392 return; 4393 4394 // Pick up the first and second halfwords of the instruction. 4395 Valtype16 first = elfcpp::Swap<16, big_endian>::readval(view); 4396 Valtype16 second = elfcpp::Swap<16, big_endian>::readval(view + 2); 4397 Valtype32 val; 4398 4399 if (micromips_reloc(r_type) 4400 || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle)) 4401 val = first << 16 | second; 4402 else if (r_type != elfcpp::R_MIPS16_26) 4403 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11) 4404 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f)); 4405 else 4406 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11) 4407 | ((first & 0x1f) << 21) | second); 4408 4409 elfcpp::Swap<32, big_endian>::writeval(view, val); 4410 } 4411 4412 static void 4413 mips_reloc_shuffle(unsigned char* view, unsigned int r_type, bool jal_shuffle) 4414 { 4415 if (!mips16_reloc(r_type) 4416 && !should_shuffle_micromips_reloc(r_type)) 4417 return; 4418 4419 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 4420 Valtype16 first, second; 4421 4422 if (micromips_reloc(r_type) 4423 || (r_type == elfcpp::R_MIPS16_26 && !jal_shuffle)) 4424 { 4425 second = val & 0xffff; 4426 first = val >> 16; 4427 } 4428 else if (r_type != elfcpp::R_MIPS16_26) 4429 { 4430 second = ((val >> 11) & 0xffe0) | (val & 0x1f); 4431 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0); 4432 } 4433 else 4434 { 4435 second = val & 0xffff; 4436 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0) 4437 | ((val >> 21) & 0x1f); 4438 } 4439 4440 elfcpp::Swap<16, big_endian>::writeval(view + 2, second); 4441 elfcpp::Swap<16, big_endian>::writeval(view, first); 4442 } 4443 4444 // R_MIPS_16: S + sign-extend(A) 4445 static inline typename This::Status 4446 rel16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4447 const Symbol_value<size>* psymval, Mips_address addend_a, 4448 bool extract_addend, bool calculate_only, Valtype* calculated_value) 4449 { 4450 Valtype16* wv = reinterpret_cast<Valtype16*>(view); 4451 Valtype16 val = elfcpp::Swap<16, big_endian>::readval(wv); 4452 4453 Valtype addend = (extract_addend ? Bits<16>::sign_extend32(val) 4454 : addend_a); 4455 4456 Valtype x = psymval->value(object, addend); 4457 val = Bits<16>::bit_select32(val, x, 0xffffU); 4458 4459 if (calculate_only) 4460 { 4461 *calculated_value = x; 4462 return This::STATUS_OKAY; 4463 } 4464 else 4465 elfcpp::Swap<16, big_endian>::writeval(wv, val); 4466 4467 return check_overflow<16>(x); 4468 } 4469 4470 // R_MIPS_32: S + A 4471 static inline typename This::Status 4472 rel32(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4473 const Symbol_value<size>* psymval, Mips_address addend_a, 4474 bool extract_addend, bool calculate_only, Valtype* calculated_value) 4475 { 4476 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4477 Valtype addend = (extract_addend 4478 ? elfcpp::Swap<32, big_endian>::readval(wv) 4479 : addend_a); 4480 Valtype x = psymval->value(object, addend); 4481 4482 if (calculate_only) 4483 *calculated_value = x; 4484 else 4485 elfcpp::Swap<32, big_endian>::writeval(wv, x); 4486 4487 return This::STATUS_OKAY; 4488 } 4489 4490 // R_MIPS_JALR, R_MICROMIPS_JALR 4491 static inline typename This::Status 4492 reljalr(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4493 const Symbol_value<size>* psymval, Mips_address address, 4494 Mips_address addend_a, bool extract_addend, bool cross_mode_jump, 4495 unsigned int r_type, bool jalr_to_bal, bool jr_to_b, 4496 bool calculate_only, Valtype* calculated_value) 4497 { 4498 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4499 Valtype addend = extract_addend ? 0 : addend_a; 4500 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4501 4502 // Try converting J(AL)R to B(AL), if the target is in range. 4503 if (!parameters->options().relocatable() 4504 && r_type == elfcpp::R_MIPS_JALR 4505 && !cross_mode_jump 4506 && ((jalr_to_bal && val == 0x0320f809) // jalr t9 4507 || (jr_to_b && val == 0x03200008))) // jr t9 4508 { 4509 int offset = psymval->value(object, addend) - (address + 4); 4510 if (!Bits<18>::has_overflow32(offset)) 4511 { 4512 if (val == 0x03200008) // jr t9 4513 val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff); // b addr 4514 else 4515 val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr 4516 } 4517 } 4518 4519 if (calculate_only) 4520 *calculated_value = val; 4521 else 4522 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4523 4524 return This::STATUS_OKAY; 4525 } 4526 4527 // R_MIPS_PC32: S + A - P 4528 static inline typename This::Status 4529 relpc32(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4530 const Symbol_value<size>* psymval, Mips_address address, 4531 Mips_address addend_a, bool extract_addend, bool calculate_only, 4532 Valtype* calculated_value) 4533 { 4534 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4535 Valtype addend = (extract_addend 4536 ? elfcpp::Swap<32, big_endian>::readval(wv) 4537 : addend_a); 4538 Valtype x = psymval->value(object, addend) - address; 4539 4540 if (calculate_only) 4541 *calculated_value = x; 4542 else 4543 elfcpp::Swap<32, big_endian>::writeval(wv, x); 4544 4545 return This::STATUS_OKAY; 4546 } 4547 4548 // R_MIPS_26, R_MIPS16_26, R_MICROMIPS_26_S1 4549 static inline typename This::Status 4550 rel26(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4551 const Symbol_value<size>* psymval, Mips_address address, 4552 bool local, Mips_address addend_a, bool extract_addend, 4553 const Symbol* gsym, bool cross_mode_jump, unsigned int r_type, 4554 bool jal_to_bal, bool calculate_only, Valtype* calculated_value) 4555 { 4556 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4557 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4558 4559 Valtype addend; 4560 if (extract_addend) 4561 { 4562 if (r_type == elfcpp::R_MICROMIPS_26_S1) 4563 addend = (val & 0x03ffffff) << 1; 4564 else 4565 addend = (val & 0x03ffffff) << 2; 4566 } 4567 else 4568 addend = addend_a; 4569 4570 // Make sure the target of JALX is word-aligned. Bit 0 must be 4571 // the correct ISA mode selector and bit 1 must be 0. 4572 if (!calculate_only && cross_mode_jump 4573 && (psymval->value(object, 0) & 3) != (r_type == elfcpp::R_MIPS_26)) 4574 { 4575 gold_warning(_("JALX to a non-word-aligned address")); 4576 return This::STATUS_BAD_RELOC; 4577 } 4578 4579 // Shift is 2, unusually, for microMIPS JALX. 4580 unsigned int shift = 4581 (!cross_mode_jump && r_type == elfcpp::R_MICROMIPS_26_S1) ? 1 : 2; 4582 4583 Valtype x; 4584 if (local) 4585 x = addend | ((address + 4) & (0xfc000000 << shift)); 4586 else 4587 { 4588 if (shift == 1) 4589 x = Bits<27>::sign_extend32(addend); 4590 else 4591 x = Bits<28>::sign_extend32(addend); 4592 } 4593 x = psymval->value(object, x) >> shift; 4594 4595 if (!calculate_only && !local && !gsym->is_weak_undefined()) 4596 { 4597 if ((x >> 26) != ((address + 4) >> (26 + shift))) 4598 { 4599 gold_error(_("relocation truncated to fit: %u against '%s'"), 4600 r_type, gsym->name()); 4601 return This::STATUS_OVERFLOW; 4602 } 4603 } 4604 4605 val = Bits<32>::bit_select32(val, x, 0x03ffffff); 4606 4607 // If required, turn JAL into JALX. 4608 if (cross_mode_jump) 4609 { 4610 bool ok; 4611 Valtype32 opcode = val >> 26; 4612 Valtype32 jalx_opcode; 4613 4614 // Check to see if the opcode is already JAL or JALX. 4615 if (r_type == elfcpp::R_MIPS16_26) 4616 { 4617 ok = (opcode == 0x6) || (opcode == 0x7); 4618 jalx_opcode = 0x7; 4619 } 4620 else if (r_type == elfcpp::R_MICROMIPS_26_S1) 4621 { 4622 ok = (opcode == 0x3d) || (opcode == 0x3c); 4623 jalx_opcode = 0x3c; 4624 } 4625 else 4626 { 4627 ok = (opcode == 0x3) || (opcode == 0x1d); 4628 jalx_opcode = 0x1d; 4629 } 4630 4631 // If the opcode is not JAL or JALX, there's a problem. We cannot 4632 // convert J or JALS to JALX. 4633 if (!calculate_only && !ok) 4634 { 4635 gold_error(_("Unsupported jump between ISA modes; consider " 4636 "recompiling with interlinking enabled.")); 4637 return This::STATUS_BAD_RELOC; 4638 } 4639 4640 // Make this the JALX opcode. 4641 val = (val & ~(0x3f << 26)) | (jalx_opcode << 26); 4642 } 4643 4644 // Try converting JAL to BAL, if the target is in range. 4645 if (!parameters->options().relocatable() 4646 && !cross_mode_jump 4647 && ((jal_to_bal 4648 && r_type == elfcpp::R_MIPS_26 4649 && (val >> 26) == 0x3))) // jal addr 4650 { 4651 Valtype32 dest = (x << 2) | (((address + 4) >> 28) << 28); 4652 int offset = dest - (address + 4); 4653 if (!Bits<18>::has_overflow32(offset)) 4654 { 4655 if (val == 0x03200008) // jr t9 4656 val = 0x10000000 | (((Valtype32)offset >> 2) & 0xffff); // b addr 4657 else 4658 val = 0x04110000 | (((Valtype32)offset >> 2) & 0xffff); //bal addr 4659 } 4660 } 4661 4662 if (calculate_only) 4663 *calculated_value = val; 4664 else 4665 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4666 4667 return This::STATUS_OKAY; 4668 } 4669 4670 // R_MIPS_PC16 4671 static inline typename This::Status 4672 relpc16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4673 const Symbol_value<size>* psymval, Mips_address address, 4674 Mips_address addend_a, bool extract_addend, bool calculate_only, 4675 Valtype* calculated_value) 4676 { 4677 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4678 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4679 4680 Valtype addend = (extract_addend 4681 ? Bits<18>::sign_extend32((val & 0xffff) << 2) 4682 : addend_a); 4683 4684 Valtype x = psymval->value(object, addend) - address; 4685 val = Bits<16>::bit_select32(val, x >> 2, 0xffff); 4686 4687 if (calculate_only) 4688 { 4689 *calculated_value = x >> 2; 4690 return This::STATUS_OKAY; 4691 } 4692 else 4693 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4694 4695 if (psymval->value(object, addend) & 3) 4696 return This::STATUS_PCREL_UNALIGNED; 4697 4698 return check_overflow<18>(x); 4699 } 4700 4701 // R_MIPS_PC21_S2 4702 static inline typename This::Status 4703 relpc21(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4704 const Symbol_value<size>* psymval, Mips_address address, 4705 Mips_address addend_a, bool extract_addend, bool calculate_only, 4706 Valtype* calculated_value) 4707 { 4708 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4709 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4710 4711 Valtype addend = (extract_addend 4712 ? Bits<23>::sign_extend32((val & 0x1fffff) << 2) 4713 : addend_a); 4714 4715 Valtype x = psymval->value(object, addend) - address; 4716 val = Bits<21>::bit_select32(val, x >> 2, 0x1fffff); 4717 4718 if (calculate_only) 4719 { 4720 *calculated_value = x >> 2; 4721 return This::STATUS_OKAY; 4722 } 4723 else 4724 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4725 4726 if (psymval->value(object, addend) & 3) 4727 return This::STATUS_PCREL_UNALIGNED; 4728 4729 return check_overflow<23>(x); 4730 } 4731 4732 // R_MIPS_PC26_S2 4733 static inline typename This::Status 4734 relpc26(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4735 const Symbol_value<size>* psymval, Mips_address address, 4736 Mips_address addend_a, bool extract_addend, bool calculate_only, 4737 Valtype* calculated_value) 4738 { 4739 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4740 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4741 4742 Valtype addend = (extract_addend 4743 ? Bits<28>::sign_extend32((val & 0x3ffffff) << 2) 4744 : addend_a); 4745 4746 Valtype x = psymval->value(object, addend) - address; 4747 val = Bits<26>::bit_select32(val, x >> 2, 0x3ffffff); 4748 4749 if (calculate_only) 4750 { 4751 *calculated_value = x >> 2; 4752 return This::STATUS_OKAY; 4753 } 4754 else 4755 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4756 4757 if (psymval->value(object, addend) & 3) 4758 return This::STATUS_PCREL_UNALIGNED; 4759 4760 return check_overflow<28>(x); 4761 } 4762 4763 // R_MIPS_PC18_S3 4764 static inline typename This::Status 4765 relpc18(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4766 const Symbol_value<size>* psymval, Mips_address address, 4767 Mips_address addend_a, bool extract_addend, bool calculate_only, 4768 Valtype* calculated_value) 4769 { 4770 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4771 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4772 4773 Valtype addend = (extract_addend 4774 ? Bits<21>::sign_extend32((val & 0x3ffff) << 3) 4775 : addend_a); 4776 4777 Valtype x = psymval->value(object, addend) - ((address | 7) ^ 7); 4778 val = Bits<18>::bit_select32(val, x >> 3, 0x3ffff); 4779 4780 if (calculate_only) 4781 { 4782 *calculated_value = x >> 3; 4783 return This::STATUS_OKAY; 4784 } 4785 else 4786 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4787 4788 if (psymval->value(object, addend) & 7) 4789 return This::STATUS_PCREL_UNALIGNED; 4790 4791 return check_overflow<21>(x); 4792 } 4793 4794 // R_MIPS_PC19_S2 4795 static inline typename This::Status 4796 relpc19(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4797 const Symbol_value<size>* psymval, Mips_address address, 4798 Mips_address addend_a, bool extract_addend, bool calculate_only, 4799 Valtype* calculated_value) 4800 { 4801 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4802 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4803 4804 Valtype addend = (extract_addend 4805 ? Bits<21>::sign_extend32((val & 0x7ffff) << 2) 4806 : addend_a); 4807 4808 Valtype x = psymval->value(object, addend) - address; 4809 val = Bits<19>::bit_select32(val, x >> 2, 0x7ffff); 4810 4811 if (calculate_only) 4812 { 4813 *calculated_value = x >> 2; 4814 return This::STATUS_OKAY; 4815 } 4816 else 4817 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4818 4819 if (psymval->value(object, addend) & 3) 4820 return This::STATUS_PCREL_UNALIGNED; 4821 4822 return check_overflow<21>(x); 4823 } 4824 4825 // R_MIPS_PCHI16 4826 static inline typename This::Status 4827 relpchi16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4828 const Symbol_value<size>* psymval, Mips_address addend, 4829 Mips_address address, unsigned int r_sym, bool extract_addend) 4830 { 4831 // Record the relocation. It will be resolved when we find pclo16 part. 4832 pchi16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval, 4833 addend, 0, r_sym, extract_addend, address)); 4834 return This::STATUS_OKAY; 4835 } 4836 4837 // R_MIPS_PCHI16 4838 static inline typename This::Status 4839 do_relpchi16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4840 const Symbol_value<size>* psymval, Mips_address addend_hi, 4841 Mips_address address, bool extract_addend, Valtype32 addend_lo, 4842 bool calculate_only, Valtype* calculated_value) 4843 { 4844 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4845 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4846 4847 Valtype addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo 4848 : addend_hi); 4849 4850 Valtype value = psymval->value(object, addend) - address; 4851 Valtype x = ((value + 0x8000) >> 16) & 0xffff; 4852 val = Bits<32>::bit_select32(val, x, 0xffff); 4853 4854 if (calculate_only) 4855 *calculated_value = x; 4856 else 4857 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4858 4859 return This::STATUS_OKAY; 4860 } 4861 4862 // R_MIPS_PCLO16 4863 static inline typename This::Status 4864 relpclo16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4865 const Symbol_value<size>* psymval, Mips_address addend_a, 4866 bool extract_addend, Mips_address address, unsigned int r_sym, 4867 unsigned int rel_type, bool calculate_only, 4868 Valtype* calculated_value) 4869 { 4870 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4871 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4872 4873 Valtype addend = (extract_addend ? Bits<16>::sign_extend32(val & 0xffff) 4874 : addend_a); 4875 4876 if (rel_type == elfcpp::SHT_REL) 4877 { 4878 // Resolve pending R_MIPS_PCHI16 relocations. 4879 typename std::list<reloc_high<size, big_endian> >::iterator it = 4880 pchi16_relocs.begin(); 4881 while (it != pchi16_relocs.end()) 4882 { 4883 reloc_high<size, big_endian> pchi16 = *it; 4884 if (pchi16.r_sym == r_sym) 4885 { 4886 do_relpchi16(pchi16.view, pchi16.object, pchi16.psymval, 4887 pchi16.addend, pchi16.address, 4888 pchi16.extract_addend, addend, calculate_only, 4889 calculated_value); 4890 it = pchi16_relocs.erase(it); 4891 } 4892 else 4893 ++it; 4894 } 4895 } 4896 4897 // Resolve R_MIPS_PCLO16 relocation. 4898 Valtype x = psymval->value(object, addend) - address; 4899 val = Bits<32>::bit_select32(val, x, 0xffff); 4900 4901 if (calculate_only) 4902 *calculated_value = x; 4903 else 4904 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4905 4906 return This::STATUS_OKAY; 4907 } 4908 4909 // R_MICROMIPS_PC7_S1 4910 static inline typename This::Status 4911 relmicromips_pc7_s1(unsigned char* view, 4912 const Mips_relobj<size, big_endian>* object, 4913 const Symbol_value<size>* psymval, Mips_address address, 4914 Mips_address addend_a, bool extract_addend, 4915 bool calculate_only, Valtype* calculated_value) 4916 { 4917 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4918 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4919 4920 Valtype addend = extract_addend ? Bits<8>::sign_extend32((val & 0x7f) << 1) 4921 : addend_a; 4922 4923 Valtype x = psymval->value(object, addend) - address; 4924 val = Bits<16>::bit_select32(val, x >> 1, 0x7f); 4925 4926 if (calculate_only) 4927 { 4928 *calculated_value = x >> 1; 4929 return This::STATUS_OKAY; 4930 } 4931 else 4932 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4933 4934 return check_overflow<8>(x); 4935 } 4936 4937 // R_MICROMIPS_PC10_S1 4938 static inline typename This::Status 4939 relmicromips_pc10_s1(unsigned char* view, 4940 const Mips_relobj<size, big_endian>* object, 4941 const Symbol_value<size>* psymval, Mips_address address, 4942 Mips_address addend_a, bool extract_addend, 4943 bool calculate_only, Valtype* calculated_value) 4944 { 4945 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4946 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4947 4948 Valtype addend = (extract_addend 4949 ? Bits<11>::sign_extend32((val & 0x3ff) << 1) 4950 : addend_a); 4951 4952 Valtype x = psymval->value(object, addend) - address; 4953 val = Bits<16>::bit_select32(val, x >> 1, 0x3ff); 4954 4955 if (calculate_only) 4956 { 4957 *calculated_value = x >> 1; 4958 return This::STATUS_OKAY; 4959 } 4960 else 4961 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4962 4963 return check_overflow<11>(x); 4964 } 4965 4966 // R_MICROMIPS_PC16_S1 4967 static inline typename This::Status 4968 relmicromips_pc16_s1(unsigned char* view, 4969 const Mips_relobj<size, big_endian>* object, 4970 const Symbol_value<size>* psymval, Mips_address address, 4971 Mips_address addend_a, bool extract_addend, 4972 bool calculate_only, Valtype* calculated_value) 4973 { 4974 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 4975 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 4976 4977 Valtype addend = (extract_addend 4978 ? Bits<17>::sign_extend32((val & 0xffff) << 1) 4979 : addend_a); 4980 4981 Valtype x = psymval->value(object, addend) - address; 4982 val = Bits<16>::bit_select32(val, x >> 1, 0xffff); 4983 4984 if (calculate_only) 4985 { 4986 *calculated_value = x >> 1; 4987 return This::STATUS_OKAY; 4988 } 4989 else 4990 elfcpp::Swap<32, big_endian>::writeval(wv, val); 4991 4992 return check_overflow<17>(x); 4993 } 4994 4995 // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16, 4996 static inline typename This::Status 4997 relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 4998 const Symbol_value<size>* psymval, Mips_address addend, 4999 Mips_address address, bool gp_disp, unsigned int r_type, 5000 unsigned int r_sym, bool extract_addend) 5001 { 5002 // Record the relocation. It will be resolved when we find lo16 part. 5003 hi16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval, 5004 addend, r_type, r_sym, extract_addend, address, 5005 gp_disp)); 5006 return This::STATUS_OKAY; 5007 } 5008 5009 // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16, 5010 static inline typename This::Status 5011 do_relhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5012 const Symbol_value<size>* psymval, Mips_address addend_hi, 5013 Mips_address address, bool is_gp_disp, unsigned int r_type, 5014 bool extract_addend, Valtype32 addend_lo, 5015 Target_mips<size, big_endian>* target, bool calculate_only, 5016 Valtype* calculated_value) 5017 { 5018 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5019 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5020 5021 Valtype addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo 5022 : addend_hi); 5023 5024 Valtype32 value; 5025 if (!is_gp_disp) 5026 value = psymval->value(object, addend); 5027 else 5028 { 5029 // For MIPS16 ABI code we generate this sequence 5030 // 0: li $v0,%hi(_gp_disp) 5031 // 4: addiupc $v1,%lo(_gp_disp) 5032 // 8: sll $v0,16 5033 // 12: addu $v0,$v1 5034 // 14: move $gp,$v0 5035 // So the offsets of hi and lo relocs are the same, but the 5036 // base $pc is that used by the ADDIUPC instruction at $t9 + 4. 5037 // ADDIUPC clears the low two bits of the instruction address, 5038 // so the base is ($t9 + 4) & ~3. 5039 Valtype32 gp_disp; 5040 if (r_type == elfcpp::R_MIPS16_HI16) 5041 gp_disp = (target->adjusted_gp_value(object) 5042 - ((address + 4) & ~0x3)); 5043 // The microMIPS .cpload sequence uses the same assembly 5044 // instructions as the traditional psABI version, but the 5045 // incoming $t9 has the low bit set. 5046 else if (r_type == elfcpp::R_MICROMIPS_HI16) 5047 gp_disp = target->adjusted_gp_value(object) - address - 1; 5048 else 5049 gp_disp = target->adjusted_gp_value(object) - address; 5050 value = gp_disp + addend; 5051 } 5052 Valtype x = ((value + 0x8000) >> 16) & 0xffff; 5053 val = Bits<32>::bit_select32(val, x, 0xffff); 5054 5055 if (calculate_only) 5056 { 5057 *calculated_value = x; 5058 return This::STATUS_OKAY; 5059 } 5060 else 5061 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5062 5063 return (is_gp_disp ? check_overflow<16>(x) 5064 : This::STATUS_OKAY); 5065 } 5066 5067 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16 5068 static inline typename This::Status 5069 relgot16_local(unsigned char* view, 5070 const Mips_relobj<size, big_endian>* object, 5071 const Symbol_value<size>* psymval, Mips_address addend_a, 5072 bool extract_addend, unsigned int r_type, unsigned int r_sym) 5073 { 5074 // Record the relocation. It will be resolved when we find lo16 part. 5075 got16_relocs.push_back(reloc_high<size, big_endian>(view, object, psymval, 5076 addend_a, r_type, r_sym, extract_addend)); 5077 return This::STATUS_OKAY; 5078 } 5079 5080 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16 5081 static inline typename This::Status 5082 do_relgot16_local(unsigned char* view, 5083 const Mips_relobj<size, big_endian>* object, 5084 const Symbol_value<size>* psymval, Mips_address addend_hi, 5085 bool extract_addend, Valtype32 addend_lo, 5086 Target_mips<size, big_endian>* target, bool calculate_only, 5087 Valtype* calculated_value) 5088 { 5089 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5090 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5091 5092 Valtype addend = (extract_addend ? ((val & 0xffff) << 16) + addend_lo 5093 : addend_hi); 5094 5095 // Find GOT page entry. 5096 Mips_address value = ((psymval->value(object, addend) + 0x8000) >> 16) 5097 & 0xffff; 5098 value <<= 16; 5099 unsigned int got_offset = 5100 target->got_section()->get_got_page_offset(value, object); 5101 5102 // Resolve the relocation. 5103 Valtype x = target->got_section()->gp_offset(got_offset, object); 5104 val = Bits<32>::bit_select32(val, x, 0xffff); 5105 5106 if (calculate_only) 5107 { 5108 *calculated_value = x; 5109 return This::STATUS_OKAY; 5110 } 5111 else 5112 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5113 5114 return check_overflow<16>(x); 5115 } 5116 5117 // R_MIPS_LO16, R_MIPS16_LO16, R_MICROMIPS_LO16, R_MICROMIPS_HI0_LO16 5118 static inline typename This::Status 5119 rello16(Target_mips<size, big_endian>* target, unsigned char* view, 5120 const Mips_relobj<size, big_endian>* object, 5121 const Symbol_value<size>* psymval, Mips_address addend_a, 5122 bool extract_addend, Mips_address address, bool is_gp_disp, 5123 unsigned int r_type, unsigned int r_sym, unsigned int rel_type, 5124 bool calculate_only, Valtype* calculated_value) 5125 { 5126 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5127 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5128 5129 Valtype addend = (extract_addend ? Bits<16>::sign_extend32(val & 0xffff) 5130 : addend_a); 5131 5132 if (rel_type == elfcpp::SHT_REL) 5133 { 5134 typename This::Status reloc_status = This::STATUS_OKAY; 5135 // Resolve pending R_MIPS_HI16 relocations. 5136 typename std::list<reloc_high<size, big_endian> >::iterator it = 5137 hi16_relocs.begin(); 5138 while (it != hi16_relocs.end()) 5139 { 5140 reloc_high<size, big_endian> hi16 = *it; 5141 if (hi16.r_sym == r_sym 5142 && is_matching_lo16_reloc(hi16.r_type, r_type)) 5143 { 5144 mips_reloc_unshuffle(hi16.view, hi16.r_type, false); 5145 reloc_status = do_relhi16(hi16.view, hi16.object, hi16.psymval, 5146 hi16.addend, hi16.address, hi16.gp_disp, 5147 hi16.r_type, hi16.extract_addend, addend, 5148 target, calculate_only, calculated_value); 5149 mips_reloc_shuffle(hi16.view, hi16.r_type, false); 5150 if (reloc_status == This::STATUS_OVERFLOW) 5151 return This::STATUS_OVERFLOW; 5152 it = hi16_relocs.erase(it); 5153 } 5154 else 5155 ++it; 5156 } 5157 5158 // Resolve pending local R_MIPS_GOT16 relocations. 5159 typename std::list<reloc_high<size, big_endian> >::iterator it2 = 5160 got16_relocs.begin(); 5161 while (it2 != got16_relocs.end()) 5162 { 5163 reloc_high<size, big_endian> got16 = *it2; 5164 if (got16.r_sym == r_sym 5165 && is_matching_lo16_reloc(got16.r_type, r_type)) 5166 { 5167 mips_reloc_unshuffle(got16.view, got16.r_type, false); 5168 5169 reloc_status = do_relgot16_local(got16.view, got16.object, 5170 got16.psymval, got16.addend, 5171 got16.extract_addend, addend, target, 5172 calculate_only, calculated_value); 5173 5174 mips_reloc_shuffle(got16.view, got16.r_type, false); 5175 if (reloc_status == This::STATUS_OVERFLOW) 5176 return This::STATUS_OVERFLOW; 5177 it2 = got16_relocs.erase(it2); 5178 } 5179 else 5180 ++it2; 5181 } 5182 } 5183 5184 // Resolve R_MIPS_LO16 relocation. 5185 Valtype x; 5186 if (!is_gp_disp) 5187 x = psymval->value(object, addend); 5188 else 5189 { 5190 // See the comment for R_MIPS16_HI16 above for the reason 5191 // for this conditional. 5192 Valtype32 gp_disp; 5193 if (r_type == elfcpp::R_MIPS16_LO16) 5194 gp_disp = target->adjusted_gp_value(object) - (address & ~0x3); 5195 else if (r_type == elfcpp::R_MICROMIPS_LO16 5196 || r_type == elfcpp::R_MICROMIPS_HI0_LO16) 5197 gp_disp = target->adjusted_gp_value(object) - address + 3; 5198 else 5199 gp_disp = target->adjusted_gp_value(object) - address + 4; 5200 // The MIPS ABI requires checking the R_MIPS_LO16 relocation 5201 // for overflow. Relocations against _gp_disp are normally 5202 // generated from the .cpload pseudo-op. It generates code 5203 // that normally looks like this: 5204 5205 // lui $gp,%hi(_gp_disp) 5206 // addiu $gp,$gp,%lo(_gp_disp) 5207 // addu $gp,$gp,$t9 5208 5209 // Here $t9 holds the address of the function being called, 5210 // as required by the MIPS ELF ABI. The R_MIPS_LO16 5211 // relocation can easily overflow in this situation, but the 5212 // R_MIPS_HI16 relocation will handle the overflow. 5213 // Therefore, we consider this a bug in the MIPS ABI, and do 5214 // not check for overflow here. 5215 x = gp_disp + addend; 5216 } 5217 val = Bits<32>::bit_select32(val, x, 0xffff); 5218 5219 if (calculate_only) 5220 *calculated_value = x; 5221 else 5222 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5223 5224 return This::STATUS_OKAY; 5225 } 5226 5227 // R_MIPS_CALL16, R_MIPS16_CALL16, R_MICROMIPS_CALL16 5228 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16 5229 // R_MIPS_TLS_GD, R_MIPS16_TLS_GD, R_MICROMIPS_TLS_GD 5230 // R_MIPS_TLS_GOTTPREL, R_MIPS16_TLS_GOTTPREL, R_MICROMIPS_TLS_GOTTPREL 5231 // R_MIPS_TLS_LDM, R_MIPS16_TLS_LDM, R_MICROMIPS_TLS_LDM 5232 // R_MIPS_GOT_DISP, R_MICROMIPS_GOT_DISP 5233 static inline typename This::Status 5234 relgot(unsigned char* view, int gp_offset, bool calculate_only, 5235 Valtype* calculated_value) 5236 { 5237 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5238 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5239 Valtype x = gp_offset; 5240 val = Bits<32>::bit_select32(val, x, 0xffff); 5241 5242 if (calculate_only) 5243 { 5244 *calculated_value = x; 5245 return This::STATUS_OKAY; 5246 } 5247 else 5248 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5249 5250 return check_overflow<16>(x); 5251 } 5252 5253 // R_MIPS_EH 5254 static inline typename This::Status 5255 releh(unsigned char* view, int gp_offset, bool calculate_only, 5256 Valtype* calculated_value) 5257 { 5258 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5259 Valtype x = gp_offset; 5260 5261 if (calculate_only) 5262 { 5263 *calculated_value = x; 5264 return This::STATUS_OKAY; 5265 } 5266 else 5267 elfcpp::Swap<32, big_endian>::writeval(wv, x); 5268 5269 return check_overflow<32>(x); 5270 } 5271 5272 // R_MIPS_GOT_PAGE, R_MICROMIPS_GOT_PAGE 5273 static inline typename This::Status 5274 relgotpage(Target_mips<size, big_endian>* target, unsigned char* view, 5275 const Mips_relobj<size, big_endian>* object, 5276 const Symbol_value<size>* psymval, Mips_address addend_a, 5277 bool extract_addend, bool calculate_only, 5278 Valtype* calculated_value) 5279 { 5280 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5281 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 5282 Valtype addend = extract_addend ? val & 0xffff : addend_a; 5283 5284 // Find a GOT page entry that points to within 32KB of symbol + addend. 5285 Mips_address value = (psymval->value(object, addend) + 0x8000) & ~0xffff; 5286 unsigned int got_offset = 5287 target->got_section()->get_got_page_offset(value, object); 5288 5289 Valtype x = target->got_section()->gp_offset(got_offset, object); 5290 val = Bits<32>::bit_select32(val, x, 0xffff); 5291 5292 if (calculate_only) 5293 { 5294 *calculated_value = x; 5295 return This::STATUS_OKAY; 5296 } 5297 else 5298 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5299 5300 return check_overflow<16>(x); 5301 } 5302 5303 // R_MIPS_GOT_OFST, R_MICROMIPS_GOT_OFST 5304 static inline typename This::Status 5305 relgotofst(Target_mips<size, big_endian>* target, unsigned char* view, 5306 const Mips_relobj<size, big_endian>* object, 5307 const Symbol_value<size>* psymval, Mips_address addend_a, 5308 bool extract_addend, bool local, bool calculate_only, 5309 Valtype* calculated_value) 5310 { 5311 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5312 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 5313 Valtype addend = extract_addend ? val & 0xffff : addend_a; 5314 5315 // For a local symbol, find a GOT page entry that points to within 32KB of 5316 // symbol + addend. Relocation value is the offset of the GOT page entry's 5317 // value from symbol + addend. 5318 // For a global symbol, relocation value is addend. 5319 Valtype x; 5320 if (local) 5321 { 5322 // Find GOT page entry. 5323 Mips_address value = ((psymval->value(object, addend) + 0x8000) 5324 & ~0xffff); 5325 target->got_section()->get_got_page_offset(value, object); 5326 5327 x = psymval->value(object, addend) - value; 5328 } 5329 else 5330 x = addend; 5331 val = Bits<32>::bit_select32(val, x, 0xffff); 5332 5333 if (calculate_only) 5334 { 5335 *calculated_value = x; 5336 return This::STATUS_OKAY; 5337 } 5338 else 5339 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5340 5341 return check_overflow<16>(x); 5342 } 5343 5344 // R_MIPS_GOT_HI16, R_MIPS_CALL_HI16, 5345 // R_MICROMIPS_GOT_HI16, R_MICROMIPS_CALL_HI16 5346 static inline typename This::Status 5347 relgot_hi16(unsigned char* view, int gp_offset, bool calculate_only, 5348 Valtype* calculated_value) 5349 { 5350 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5351 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5352 Valtype x = gp_offset; 5353 x = ((x + 0x8000) >> 16) & 0xffff; 5354 val = Bits<32>::bit_select32(val, x, 0xffff); 5355 5356 if (calculate_only) 5357 *calculated_value = x; 5358 else 5359 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5360 5361 return This::STATUS_OKAY; 5362 } 5363 5364 // R_MIPS_GOT_LO16, R_MIPS_CALL_LO16, 5365 // R_MICROMIPS_GOT_LO16, R_MICROMIPS_CALL_LO16 5366 static inline typename This::Status 5367 relgot_lo16(unsigned char* view, int gp_offset, bool calculate_only, 5368 Valtype* calculated_value) 5369 { 5370 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5371 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5372 Valtype x = gp_offset; 5373 val = Bits<32>::bit_select32(val, x, 0xffff); 5374 5375 if (calculate_only) 5376 *calculated_value = x; 5377 else 5378 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5379 5380 return This::STATUS_OKAY; 5381 } 5382 5383 // R_MIPS_GPREL16, R_MIPS16_GPREL, R_MIPS_LITERAL, R_MICROMIPS_LITERAL 5384 // R_MICROMIPS_GPREL7_S2, R_MICROMIPS_GPREL16 5385 static inline typename This::Status 5386 relgprel(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5387 const Symbol_value<size>* psymval, Mips_address gp, 5388 Mips_address addend_a, bool extract_addend, bool local, 5389 unsigned int r_type, bool calculate_only, 5390 Valtype* calculated_value) 5391 { 5392 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5393 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5394 5395 Valtype addend; 5396 if (extract_addend) 5397 { 5398 if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2) 5399 addend = (val & 0x7f) << 2; 5400 else 5401 addend = val & 0xffff; 5402 // Only sign-extend the addend if it was extracted from the 5403 // instruction. If the addend was separate, leave it alone, 5404 // otherwise we may lose significant bits. 5405 addend = Bits<16>::sign_extend32(addend); 5406 } 5407 else 5408 addend = addend_a; 5409 5410 Valtype x = psymval->value(object, addend) - gp; 5411 5412 // If the symbol was local, any earlier relocatable links will 5413 // have adjusted its addend with the gp offset, so compensate 5414 // for that now. Don't do it for symbols forced local in this 5415 // link, though, since they won't have had the gp offset applied 5416 // to them before. 5417 if (local) 5418 x += object->gp_value(); 5419 5420 if (r_type == elfcpp::R_MICROMIPS_GPREL7_S2) 5421 val = Bits<32>::bit_select32(val, x, 0x7f); 5422 else 5423 val = Bits<32>::bit_select32(val, x, 0xffff); 5424 5425 if (calculate_only) 5426 { 5427 *calculated_value = x; 5428 return This::STATUS_OKAY; 5429 } 5430 else 5431 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5432 5433 if (check_overflow<16>(x) == This::STATUS_OVERFLOW) 5434 { 5435 gold_error(_("small-data section exceeds 64KB; lower small-data size " 5436 "limit (see option -G)")); 5437 return This::STATUS_OVERFLOW; 5438 } 5439 return This::STATUS_OKAY; 5440 } 5441 5442 // R_MIPS_GPREL32 5443 static inline typename This::Status 5444 relgprel32(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5445 const Symbol_value<size>* psymval, Mips_address gp, 5446 Mips_address addend_a, bool extract_addend, bool calculate_only, 5447 Valtype* calculated_value) 5448 { 5449 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5450 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5451 Valtype addend = extract_addend ? val : addend_a; 5452 5453 // R_MIPS_GPREL32 relocations are defined for local symbols only. 5454 Valtype x = psymval->value(object, addend) + object->gp_value() - gp; 5455 5456 if (calculate_only) 5457 *calculated_value = x; 5458 else 5459 elfcpp::Swap<32, big_endian>::writeval(wv, x); 5460 5461 return This::STATUS_OKAY; 5462 } 5463 5464 // R_MIPS_TLS_TPREL_HI16, R_MIPS16_TLS_TPREL_HI16, R_MICROMIPS_TLS_TPREL_HI16 5465 // R_MIPS_TLS_DTPREL_HI16, R_MIPS16_TLS_DTPREL_HI16, 5466 // R_MICROMIPS_TLS_DTPREL_HI16 5467 static inline typename This::Status 5468 tlsrelhi16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5469 const Symbol_value<size>* psymval, Valtype32 tp_offset, 5470 Mips_address addend_a, bool extract_addend, bool calculate_only, 5471 Valtype* calculated_value) 5472 { 5473 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5474 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5475 Valtype addend = extract_addend ? val & 0xffff : addend_a; 5476 5477 // tls symbol values are relative to tls_segment()->vaddr() 5478 Valtype x = ((psymval->value(object, addend) - tp_offset) + 0x8000) >> 16; 5479 val = Bits<32>::bit_select32(val, x, 0xffff); 5480 5481 if (calculate_only) 5482 *calculated_value = x; 5483 else 5484 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5485 5486 return This::STATUS_OKAY; 5487 } 5488 5489 // R_MIPS_TLS_TPREL_LO16, R_MIPS16_TLS_TPREL_LO16, R_MICROMIPS_TLS_TPREL_LO16, 5490 // R_MIPS_TLS_DTPREL_LO16, R_MIPS16_TLS_DTPREL_LO16, 5491 // R_MICROMIPS_TLS_DTPREL_LO16, 5492 static inline typename This::Status 5493 tlsrello16(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5494 const Symbol_value<size>* psymval, Valtype32 tp_offset, 5495 Mips_address addend_a, bool extract_addend, bool calculate_only, 5496 Valtype* calculated_value) 5497 { 5498 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5499 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5500 Valtype addend = extract_addend ? val & 0xffff : addend_a; 5501 5502 // tls symbol values are relative to tls_segment()->vaddr() 5503 Valtype x = psymval->value(object, addend) - tp_offset; 5504 val = Bits<32>::bit_select32(val, x, 0xffff); 5505 5506 if (calculate_only) 5507 *calculated_value = x; 5508 else 5509 elfcpp::Swap<32, big_endian>::writeval(wv, val); 5510 5511 return This::STATUS_OKAY; 5512 } 5513 5514 // R_MIPS_TLS_TPREL32, R_MIPS_TLS_TPREL64, 5515 // R_MIPS_TLS_DTPREL32, R_MIPS_TLS_DTPREL64 5516 static inline typename This::Status 5517 tlsrel32(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5518 const Symbol_value<size>* psymval, Valtype32 tp_offset, 5519 Mips_address addend_a, bool extract_addend, bool calculate_only, 5520 Valtype* calculated_value) 5521 { 5522 Valtype32* wv = reinterpret_cast<Valtype32*>(view); 5523 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(wv); 5524 Valtype addend = extract_addend ? val : addend_a; 5525 5526 // tls symbol values are relative to tls_segment()->vaddr() 5527 Valtype x = psymval->value(object, addend) - tp_offset; 5528 5529 if (calculate_only) 5530 *calculated_value = x; 5531 else 5532 elfcpp::Swap<32, big_endian>::writeval(wv, x); 5533 5534 return This::STATUS_OKAY; 5535 } 5536 5537 // R_MIPS_SUB, R_MICROMIPS_SUB 5538 static inline typename This::Status 5539 relsub(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5540 const Symbol_value<size>* psymval, Mips_address addend_a, 5541 bool extract_addend, bool calculate_only, Valtype* calculated_value) 5542 { 5543 Valtype64* wv = reinterpret_cast<Valtype64*>(view); 5544 Valtype64 addend = (extract_addend 5545 ? elfcpp::Swap<64, big_endian>::readval(wv) 5546 : addend_a); 5547 5548 Valtype64 x = psymval->value(object, -addend); 5549 if (calculate_only) 5550 *calculated_value = x; 5551 else 5552 elfcpp::Swap<64, big_endian>::writeval(wv, x); 5553 5554 return This::STATUS_OKAY; 5555 } 5556 5557 // R_MIPS_64: S + A 5558 static inline typename This::Status 5559 rel64(unsigned char* view, const Mips_relobj<size, big_endian>* object, 5560 const Symbol_value<size>* psymval, Mips_address addend_a, 5561 bool extract_addend, bool calculate_only, Valtype* calculated_value, 5562 bool apply_addend_only) 5563 { 5564 Valtype64* wv = reinterpret_cast<Valtype64*>(view); 5565 Valtype64 addend = (extract_addend 5566 ? elfcpp::Swap<64, big_endian>::readval(wv) 5567 : addend_a); 5568 5569 Valtype64 x = psymval->value(object, addend); 5570 if (calculate_only) 5571 *calculated_value = x; 5572 else 5573 { 5574 if (apply_addend_only) 5575 x = addend; 5576 elfcpp::Swap<64, big_endian>::writeval(wv, x); 5577 } 5578 5579 return This::STATUS_OKAY; 5580 } 5581 5582}; 5583 5584template<int size, bool big_endian> 5585typename std::list<reloc_high<size, big_endian> > 5586 Mips_relocate_functions<size, big_endian>::hi16_relocs; 5587 5588template<int size, bool big_endian> 5589typename std::list<reloc_high<size, big_endian> > 5590 Mips_relocate_functions<size, big_endian>::got16_relocs; 5591 5592template<int size, bool big_endian> 5593typename std::list<reloc_high<size, big_endian> > 5594 Mips_relocate_functions<size, big_endian>::pchi16_relocs; 5595 5596// Mips_got_info methods. 5597 5598// Reserve GOT entry for a GOT relocation of type R_TYPE against symbol 5599// SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT. 5600 5601template<int size, bool big_endian> 5602void 5603Mips_got_info<size, big_endian>::record_local_got_symbol( 5604 Mips_relobj<size, big_endian>* object, unsigned int symndx, 5605 Mips_address addend, unsigned int r_type, unsigned int shndx, 5606 bool is_section_symbol) 5607{ 5608 Mips_got_entry<size, big_endian>* entry = 5609 new Mips_got_entry<size, big_endian>(object, symndx, addend, 5610 mips_elf_reloc_tls_type(r_type), 5611 shndx, is_section_symbol); 5612 this->record_got_entry(entry, object); 5613} 5614 5615// Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM, 5616// in OBJECT. FOR_CALL is true if the caller is only interested in 5617// using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic 5618// relocation. 5619 5620template<int size, bool big_endian> 5621void 5622Mips_got_info<size, big_endian>::record_global_got_symbol( 5623 Mips_symbol<size>* mips_sym, Mips_relobj<size, big_endian>* object, 5624 unsigned int r_type, bool dyn_reloc, bool for_call) 5625{ 5626 if (!for_call) 5627 mips_sym->set_got_not_only_for_calls(); 5628 5629 // A global symbol in the GOT must also be in the dynamic symbol table. 5630 if (!mips_sym->needs_dynsym_entry() && !mips_sym->is_forced_local()) 5631 { 5632 switch (mips_sym->visibility()) 5633 { 5634 case elfcpp::STV_INTERNAL: 5635 case elfcpp::STV_HIDDEN: 5636 mips_sym->set_is_forced_local(); 5637 break; 5638 default: 5639 mips_sym->set_needs_dynsym_entry(); 5640 break; 5641 } 5642 } 5643 5644 unsigned char tls_type = mips_elf_reloc_tls_type(r_type); 5645 if (tls_type == GOT_TLS_NONE) 5646 this->global_got_symbols_.insert(mips_sym); 5647 5648 if (dyn_reloc) 5649 { 5650 if (mips_sym->global_got_area() == GGA_NONE) 5651 mips_sym->set_global_got_area(GGA_RELOC_ONLY); 5652 return; 5653 } 5654 5655 Mips_got_entry<size, big_endian>* entry = 5656 new Mips_got_entry<size, big_endian>(mips_sym, tls_type); 5657 5658 this->record_got_entry(entry, object); 5659} 5660 5661// Add ENTRY to master GOT and to OBJECT's GOT. 5662 5663template<int size, bool big_endian> 5664void 5665Mips_got_info<size, big_endian>::record_got_entry( 5666 Mips_got_entry<size, big_endian>* entry, 5667 Mips_relobj<size, big_endian>* object) 5668{ 5669 this->got_entries_.insert(entry); 5670 5671 // Create the GOT entry for the OBJECT's GOT. 5672 Mips_got_info<size, big_endian>* g = object->get_or_create_got_info(); 5673 Mips_got_entry<size, big_endian>* entry2 = 5674 new Mips_got_entry<size, big_endian>(*entry); 5675 5676 g->got_entries_.insert(entry2); 5677} 5678 5679// Record that OBJECT has a page relocation against symbol SYMNDX and 5680// that ADDEND is the addend for that relocation. 5681// This function creates an upper bound on the number of GOT slots 5682// required; no attempt is made to combine references to non-overridable 5683// global symbols across multiple input files. 5684 5685template<int size, bool big_endian> 5686void 5687Mips_got_info<size, big_endian>::record_got_page_entry( 5688 Mips_relobj<size, big_endian>* object, unsigned int symndx, int addend) 5689{ 5690 struct Got_page_range **range_ptr, *range; 5691 int old_pages, new_pages; 5692 5693 // Find the Got_page_entry for this symbol. 5694 Got_page_entry* entry = new Got_page_entry(object, symndx); 5695 typename Got_page_entry_set::iterator it = 5696 this->got_page_entries_.find(entry); 5697 if (it != this->got_page_entries_.end()) 5698 entry = *it; 5699 else 5700 this->got_page_entries_.insert(entry); 5701 5702 // Add the same entry to the OBJECT's GOT. 5703 Got_page_entry* entry2 = NULL; 5704 Mips_got_info<size, big_endian>* g2 = object->get_or_create_got_info(); 5705 if (g2->got_page_entries_.find(entry) == g2->got_page_entries_.end()) 5706 { 5707 entry2 = new Got_page_entry(*entry); 5708 g2->got_page_entries_.insert(entry2); 5709 } 5710 5711 // Skip over ranges whose maximum extent cannot share a page entry 5712 // with ADDEND. 5713 range_ptr = &entry->ranges; 5714 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff) 5715 range_ptr = &(*range_ptr)->next; 5716 5717 // If we scanned to the end of the list, or found a range whose 5718 // minimum extent cannot share a page entry with ADDEND, create 5719 // a new singleton range. 5720 range = *range_ptr; 5721 if (!range || addend < range->min_addend - 0xffff) 5722 { 5723 range = new Got_page_range(); 5724 range->next = *range_ptr; 5725 range->min_addend = addend; 5726 range->max_addend = addend; 5727 5728 *range_ptr = range; 5729 ++entry->num_pages; 5730 if (entry2 != NULL) 5731 ++entry2->num_pages; 5732 ++this->page_gotno_; 5733 ++g2->page_gotno_; 5734 return; 5735 } 5736 5737 // Remember how many pages the old range contributed. 5738 old_pages = range->get_max_pages(); 5739 5740 // Update the ranges. 5741 if (addend < range->min_addend) 5742 range->min_addend = addend; 5743 else if (addend > range->max_addend) 5744 { 5745 if (range->next && addend >= range->next->min_addend - 0xffff) 5746 { 5747 old_pages += range->next->get_max_pages(); 5748 range->max_addend = range->next->max_addend; 5749 range->next = range->next->next; 5750 } 5751 else 5752 range->max_addend = addend; 5753 } 5754 5755 // Record any change in the total estimate. 5756 new_pages = range->get_max_pages(); 5757 if (old_pages != new_pages) 5758 { 5759 entry->num_pages += new_pages - old_pages; 5760 if (entry2 != NULL) 5761 entry2->num_pages += new_pages - old_pages; 5762 this->page_gotno_ += new_pages - old_pages; 5763 g2->page_gotno_ += new_pages - old_pages; 5764 } 5765} 5766 5767// Create all entries that should be in the local part of the GOT. 5768 5769template<int size, bool big_endian> 5770void 5771Mips_got_info<size, big_endian>::add_local_entries( 5772 Target_mips<size, big_endian>* target, Layout* layout) 5773{ 5774 Mips_output_data_got<size, big_endian>* got = target->got_section(); 5775 // First two GOT entries are reserved. The first entry will be filled at 5776 // runtime. The second entry will be used by some runtime loaders. 5777 got->add_constant(0); 5778 got->add_constant(target->mips_elf_gnu_got1_mask()); 5779 5780 for (typename Got_entry_set::iterator 5781 p = this->got_entries_.begin(); 5782 p != this->got_entries_.end(); 5783 ++p) 5784 { 5785 Mips_got_entry<size, big_endian>* entry = *p; 5786 if (entry->is_for_local_symbol() && !entry->is_tls_entry()) 5787 { 5788 got->add_local(entry->object(), entry->symndx(), 5789 GOT_TYPE_STANDARD, entry->addend()); 5790 unsigned int got_offset = entry->object()->local_got_offset( 5791 entry->symndx(), GOT_TYPE_STANDARD, entry->addend()); 5792 if (got->multi_got() && this->index_ > 0 5793 && parameters->options().output_is_position_independent()) 5794 { 5795 if (!entry->is_section_symbol()) 5796 target->rel_dyn_section(layout)->add_local(entry->object(), 5797 entry->symndx(), elfcpp::R_MIPS_REL32, got, got_offset); 5798 else 5799 target->rel_dyn_section(layout)->add_symbolless_local_addend( 5800 entry->object(), entry->symndx(), elfcpp::R_MIPS_REL32, 5801 got, got_offset); 5802 } 5803 } 5804 } 5805 5806 this->add_page_entries(target, layout); 5807 5808 // Add global entries that should be in the local area. 5809 for (typename Got_entry_set::iterator 5810 p = this->got_entries_.begin(); 5811 p != this->got_entries_.end(); 5812 ++p) 5813 { 5814 Mips_got_entry<size, big_endian>* entry = *p; 5815 if (!entry->is_for_global_symbol()) 5816 continue; 5817 5818 Mips_symbol<size>* mips_sym = entry->sym(); 5819 if (mips_sym->global_got_area() == GGA_NONE && !entry->is_tls_entry()) 5820 { 5821 unsigned int got_type; 5822 if (!got->multi_got()) 5823 got_type = GOT_TYPE_STANDARD; 5824 else 5825 got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_; 5826 if (got->add_global(mips_sym, got_type)) 5827 { 5828 mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type)); 5829 if (got->multi_got() && this->index_ > 0 5830 && parameters->options().output_is_position_independent()) 5831 target->rel_dyn_section(layout)->add_symbolless_global_addend( 5832 mips_sym, elfcpp::R_MIPS_REL32, got, 5833 mips_sym->got_offset(got_type)); 5834 } 5835 } 5836 } 5837} 5838 5839// Create GOT page entries. 5840 5841template<int size, bool big_endian> 5842void 5843Mips_got_info<size, big_endian>::add_page_entries( 5844 Target_mips<size, big_endian>* target, Layout* layout) 5845{ 5846 if (this->page_gotno_ == 0) 5847 return; 5848 5849 Mips_output_data_got<size, big_endian>* got = target->got_section(); 5850 this->got_page_offset_start_ = got->add_constant(0); 5851 if (got->multi_got() && this->index_ > 0 5852 && parameters->options().output_is_position_independent()) 5853 target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got, 5854 this->got_page_offset_start_); 5855 int num_entries = this->page_gotno_; 5856 unsigned int prev_offset = this->got_page_offset_start_; 5857 while (--num_entries > 0) 5858 { 5859 unsigned int next_offset = got->add_constant(0); 5860 if (got->multi_got() && this->index_ > 0 5861 && parameters->options().output_is_position_independent()) 5862 target->rel_dyn_section(layout)->add_absolute(elfcpp::R_MIPS_REL32, got, 5863 next_offset); 5864 gold_assert(next_offset == prev_offset + size/8); 5865 prev_offset = next_offset; 5866 } 5867 this->got_page_offset_next_ = this->got_page_offset_start_; 5868} 5869 5870// Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY. 5871 5872template<int size, bool big_endian> 5873void 5874Mips_got_info<size, big_endian>::add_global_entries( 5875 Target_mips<size, big_endian>* target, Layout* layout, 5876 unsigned int non_reloc_only_global_gotno) 5877{ 5878 Mips_output_data_got<size, big_endian>* got = target->got_section(); 5879 // Add GGA_NORMAL entries. 5880 unsigned int count = 0; 5881 for (typename Got_entry_set::iterator 5882 p = this->got_entries_.begin(); 5883 p != this->got_entries_.end(); 5884 ++p) 5885 { 5886 Mips_got_entry<size, big_endian>* entry = *p; 5887 if (!entry->is_for_global_symbol()) 5888 continue; 5889 5890 Mips_symbol<size>* mips_sym = entry->sym(); 5891 if (mips_sym->global_got_area() != GGA_NORMAL) 5892 continue; 5893 5894 unsigned int got_type; 5895 if (!got->multi_got()) 5896 got_type = GOT_TYPE_STANDARD; 5897 else 5898 // In multi-GOT links, global symbol can be in both primary and 5899 // secondary GOT(s). By creating custom GOT type 5900 // (GOT_TYPE_STANDARD_MULTIGOT + got_index) we ensure that symbol 5901 // is added to secondary GOT(s). 5902 got_type = GOT_TYPE_STANDARD_MULTIGOT + this->index_; 5903 if (!got->add_global(mips_sym, got_type)) 5904 continue; 5905 5906 mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type)); 5907 if (got->multi_got() && this->index_ == 0) 5908 count++; 5909 if (got->multi_got() && this->index_ > 0) 5910 { 5911 if (parameters->options().output_is_position_independent() 5912 || (!parameters->doing_static_link() 5913 && mips_sym->is_from_dynobj() && !mips_sym->is_undefined())) 5914 { 5915 target->rel_dyn_section(layout)->add_global( 5916 mips_sym, elfcpp::R_MIPS_REL32, got, 5917 mips_sym->got_offset(got_type)); 5918 got->add_secondary_got_reloc(mips_sym->got_offset(got_type), 5919 elfcpp::R_MIPS_REL32, mips_sym); 5920 } 5921 } 5922 } 5923 5924 if (!got->multi_got() || this->index_ == 0) 5925 { 5926 if (got->multi_got()) 5927 { 5928 // We need to allocate space in the primary GOT for GGA_NORMAL entries 5929 // of secondary GOTs, to ensure that GOT offsets of GGA_RELOC_ONLY 5930 // entries correspond to dynamic symbol indexes. 5931 while (count < non_reloc_only_global_gotno) 5932 { 5933 got->add_constant(0); 5934 ++count; 5935 } 5936 } 5937 5938 // Add GGA_RELOC_ONLY entries. 5939 got->add_reloc_only_entries(); 5940 } 5941} 5942 5943// Create global GOT entries that should be in the GGA_RELOC_ONLY area. 5944 5945template<int size, bool big_endian> 5946void 5947Mips_got_info<size, big_endian>::add_reloc_only_entries( 5948 Mips_output_data_got<size, big_endian>* got) 5949{ 5950 for (typename Global_got_entry_set::iterator 5951 p = this->global_got_symbols_.begin(); 5952 p != this->global_got_symbols_.end(); 5953 ++p) 5954 { 5955 Mips_symbol<size>* mips_sym = *p; 5956 if (mips_sym->global_got_area() == GGA_RELOC_ONLY) 5957 { 5958 unsigned int got_type; 5959 if (!got->multi_got()) 5960 got_type = GOT_TYPE_STANDARD; 5961 else 5962 got_type = GOT_TYPE_STANDARD_MULTIGOT; 5963 if (got->add_global(mips_sym, got_type)) 5964 mips_sym->set_global_gotoffset(mips_sym->got_offset(got_type)); 5965 } 5966 } 5967} 5968 5969// Create TLS GOT entries. 5970 5971template<int size, bool big_endian> 5972void 5973Mips_got_info<size, big_endian>::add_tls_entries( 5974 Target_mips<size, big_endian>* target, Layout* layout) 5975{ 5976 Mips_output_data_got<size, big_endian>* got = target->got_section(); 5977 // Add local tls entries. 5978 for (typename Got_entry_set::iterator 5979 p = this->got_entries_.begin(); 5980 p != this->got_entries_.end(); 5981 ++p) 5982 { 5983 Mips_got_entry<size, big_endian>* entry = *p; 5984 if (!entry->is_tls_entry() || !entry->is_for_local_symbol()) 5985 continue; 5986 5987 if (entry->tls_type() == GOT_TLS_GD) 5988 { 5989 unsigned int got_type = GOT_TYPE_TLS_PAIR; 5990 unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32 5991 : elfcpp::R_MIPS_TLS_DTPMOD64); 5992 unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32 5993 : elfcpp::R_MIPS_TLS_DTPREL64); 5994 5995 if (!parameters->doing_static_link()) 5996 { 5997 got->add_local_pair_with_rel(entry->object(), entry->symndx(), 5998 entry->shndx(), got_type, 5999 target->rel_dyn_section(layout), 6000 r_type1, entry->addend()); 6001 unsigned int got_offset = 6002 entry->object()->local_got_offset(entry->symndx(), got_type, 6003 entry->addend()); 6004 got->add_static_reloc(got_offset + size/8, r_type2, 6005 entry->object(), entry->symndx()); 6006 } 6007 else 6008 { 6009 // We are doing a static link. Mark it as belong to module 1, 6010 // the executable. 6011 unsigned int got_offset = got->add_constant(1); 6012 entry->object()->set_local_got_offset(entry->symndx(), got_type, 6013 got_offset, 6014 entry->addend()); 6015 got->add_constant(0); 6016 got->add_static_reloc(got_offset + size/8, r_type2, 6017 entry->object(), entry->symndx()); 6018 } 6019 } 6020 else if (entry->tls_type() == GOT_TLS_IE) 6021 { 6022 unsigned int got_type = GOT_TYPE_TLS_OFFSET; 6023 unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32 6024 : elfcpp::R_MIPS_TLS_TPREL64); 6025 if (!parameters->doing_static_link()) 6026 got->add_local_with_rel(entry->object(), entry->symndx(), got_type, 6027 target->rel_dyn_section(layout), r_type, 6028 entry->addend()); 6029 else 6030 { 6031 got->add_local(entry->object(), entry->symndx(), got_type, 6032 entry->addend()); 6033 unsigned int got_offset = 6034 entry->object()->local_got_offset(entry->symndx(), got_type, 6035 entry->addend()); 6036 got->add_static_reloc(got_offset, r_type, entry->object(), 6037 entry->symndx()); 6038 } 6039 } 6040 else if (entry->tls_type() == GOT_TLS_LDM) 6041 { 6042 unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32 6043 : elfcpp::R_MIPS_TLS_DTPMOD64); 6044 unsigned int got_offset; 6045 if (!parameters->doing_static_link()) 6046 { 6047 got_offset = got->add_constant(0); 6048 target->rel_dyn_section(layout)->add_local( 6049 entry->object(), 0, r_type, got, got_offset); 6050 } 6051 else 6052 // We are doing a static link. Just mark it as belong to module 1, 6053 // the executable. 6054 got_offset = got->add_constant(1); 6055 6056 got->add_constant(0); 6057 got->set_tls_ldm_offset(got_offset, entry->object()); 6058 } 6059 else 6060 gold_unreachable(); 6061 } 6062 6063 // Add global tls entries. 6064 for (typename Got_entry_set::iterator 6065 p = this->got_entries_.begin(); 6066 p != this->got_entries_.end(); 6067 ++p) 6068 { 6069 Mips_got_entry<size, big_endian>* entry = *p; 6070 if (!entry->is_tls_entry() || !entry->is_for_global_symbol()) 6071 continue; 6072 6073 Mips_symbol<size>* mips_sym = entry->sym(); 6074 if (entry->tls_type() == GOT_TLS_GD) 6075 { 6076 unsigned int got_type; 6077 if (!got->multi_got()) 6078 got_type = GOT_TYPE_TLS_PAIR; 6079 else 6080 got_type = GOT_TYPE_TLS_PAIR_MULTIGOT + this->index_; 6081 unsigned int r_type1 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPMOD32 6082 : elfcpp::R_MIPS_TLS_DTPMOD64); 6083 unsigned int r_type2 = (size == 32 ? elfcpp::R_MIPS_TLS_DTPREL32 6084 : elfcpp::R_MIPS_TLS_DTPREL64); 6085 if (!parameters->doing_static_link()) 6086 got->add_global_pair_with_rel(mips_sym, got_type, 6087 target->rel_dyn_section(layout), r_type1, r_type2); 6088 else 6089 { 6090 // Add a GOT pair for for R_MIPS_TLS_GD. The creates a pair of 6091 // GOT entries. The first one is initialized to be 1, which is the 6092 // module index for the main executable and the second one 0. A 6093 // reloc of the type R_MIPS_TLS_DTPREL32/64 will be created for 6094 // the second GOT entry and will be applied by gold. 6095 unsigned int got_offset = got->add_constant(1); 6096 mips_sym->set_got_offset(got_type, got_offset); 6097 got->add_constant(0); 6098 got->add_static_reloc(got_offset + size/8, r_type2, mips_sym); 6099 } 6100 } 6101 else if (entry->tls_type() == GOT_TLS_IE) 6102 { 6103 unsigned int got_type; 6104 if (!got->multi_got()) 6105 got_type = GOT_TYPE_TLS_OFFSET; 6106 else 6107 got_type = GOT_TYPE_TLS_OFFSET_MULTIGOT + this->index_; 6108 unsigned int r_type = (size == 32 ? elfcpp::R_MIPS_TLS_TPREL32 6109 : elfcpp::R_MIPS_TLS_TPREL64); 6110 if (!parameters->doing_static_link()) 6111 got->add_global_with_rel(mips_sym, got_type, 6112 target->rel_dyn_section(layout), r_type); 6113 else 6114 { 6115 got->add_global(mips_sym, got_type); 6116 unsigned int got_offset = mips_sym->got_offset(got_type); 6117 got->add_static_reloc(got_offset, r_type, mips_sym); 6118 } 6119 } 6120 else 6121 gold_unreachable(); 6122 } 6123} 6124 6125// Decide whether the symbol needs an entry in the global part of the primary 6126// GOT, setting global_got_area accordingly. Count the number of global 6127// symbols that are in the primary GOT only because they have dynamic 6128// relocations R_MIPS_REL32 against them (reloc_only_gotno). 6129 6130template<int size, bool big_endian> 6131void 6132Mips_got_info<size, big_endian>::count_got_symbols(Symbol_table* symtab) 6133{ 6134 for (typename Global_got_entry_set::iterator 6135 p = this->global_got_symbols_.begin(); 6136 p != this->global_got_symbols_.end(); 6137 ++p) 6138 { 6139 Mips_symbol<size>* sym = *p; 6140 // Make a final decision about whether the symbol belongs in the 6141 // local or global GOT. Symbols that bind locally can (and in the 6142 // case of forced-local symbols, must) live in the local GOT. 6143 // Those that are aren't in the dynamic symbol table must also 6144 // live in the local GOT. 6145 6146 if (!sym->should_add_dynsym_entry(symtab) 6147 || (sym->got_only_for_calls() 6148 ? symbol_calls_local(sym, sym->should_add_dynsym_entry(symtab)) 6149 : symbol_references_local(sym, 6150 sym->should_add_dynsym_entry(symtab)))) 6151 // The symbol belongs in the local GOT. We no longer need this 6152 // entry if it was only used for relocations; those relocations 6153 // will be against the null or section symbol instead. 6154 sym->set_global_got_area(GGA_NONE); 6155 else if (sym->global_got_area() == GGA_RELOC_ONLY) 6156 { 6157 ++this->reloc_only_gotno_; 6158 ++this->global_gotno_ ; 6159 } 6160 } 6161} 6162 6163// Return the offset of GOT page entry for VALUE. Initialize the entry with 6164// VALUE if it is not initialized. 6165 6166template<int size, bool big_endian> 6167unsigned int 6168Mips_got_info<size, big_endian>::get_got_page_offset(Mips_address value, 6169 Mips_output_data_got<size, big_endian>* got) 6170{ 6171 typename Got_page_offsets::iterator it = this->got_page_offsets_.find(value); 6172 if (it != this->got_page_offsets_.end()) 6173 return it->second; 6174 6175 gold_assert(this->got_page_offset_next_ < this->got_page_offset_start_ 6176 + (size/8) * this->page_gotno_); 6177 6178 unsigned int got_offset = this->got_page_offset_next_; 6179 this->got_page_offsets_[value] = got_offset; 6180 this->got_page_offset_next_ += size/8; 6181 got->update_got_entry(got_offset, value); 6182 return got_offset; 6183} 6184 6185// Remove lazy-binding stubs for global symbols in this GOT. 6186 6187template<int size, bool big_endian> 6188void 6189Mips_got_info<size, big_endian>::remove_lazy_stubs( 6190 Target_mips<size, big_endian>* target) 6191{ 6192 for (typename Got_entry_set::iterator 6193 p = this->got_entries_.begin(); 6194 p != this->got_entries_.end(); 6195 ++p) 6196 { 6197 Mips_got_entry<size, big_endian>* entry = *p; 6198 if (entry->is_for_global_symbol()) 6199 target->remove_lazy_stub_entry(entry->sym()); 6200 } 6201} 6202 6203// Count the number of GOT entries required. 6204 6205template<int size, bool big_endian> 6206void 6207Mips_got_info<size, big_endian>::count_got_entries() 6208{ 6209 for (typename Got_entry_set::iterator 6210 p = this->got_entries_.begin(); 6211 p != this->got_entries_.end(); 6212 ++p) 6213 { 6214 this->count_got_entry(*p); 6215 } 6216} 6217 6218// Count the number of GOT entries required by ENTRY. Accumulate the result. 6219 6220template<int size, bool big_endian> 6221void 6222Mips_got_info<size, big_endian>::count_got_entry( 6223 Mips_got_entry<size, big_endian>* entry) 6224{ 6225 if (entry->is_tls_entry()) 6226 this->tls_gotno_ += mips_tls_got_entries(entry->tls_type()); 6227 else if (entry->is_for_local_symbol() 6228 || entry->sym()->global_got_area() == GGA_NONE) 6229 ++this->local_gotno_; 6230 else 6231 ++this->global_gotno_; 6232} 6233 6234// Add FROM's GOT entries. 6235 6236template<int size, bool big_endian> 6237void 6238Mips_got_info<size, big_endian>::add_got_entries( 6239 Mips_got_info<size, big_endian>* from) 6240{ 6241 for (typename Got_entry_set::iterator 6242 p = from->got_entries_.begin(); 6243 p != from->got_entries_.end(); 6244 ++p) 6245 { 6246 Mips_got_entry<size, big_endian>* entry = *p; 6247 if (this->got_entries_.find(entry) == this->got_entries_.end()) 6248 { 6249 Mips_got_entry<size, big_endian>* entry2 = 6250 new Mips_got_entry<size, big_endian>(*entry); 6251 this->got_entries_.insert(entry2); 6252 this->count_got_entry(entry); 6253 } 6254 } 6255} 6256 6257// Add FROM's GOT page entries. 6258 6259template<int size, bool big_endian> 6260void 6261Mips_got_info<size, big_endian>::add_got_page_entries( 6262 Mips_got_info<size, big_endian>* from) 6263{ 6264 for (typename Got_page_entry_set::iterator 6265 p = from->got_page_entries_.begin(); 6266 p != from->got_page_entries_.end(); 6267 ++p) 6268 { 6269 Got_page_entry* entry = *p; 6270 if (this->got_page_entries_.find(entry) == this->got_page_entries_.end()) 6271 { 6272 Got_page_entry* entry2 = new Got_page_entry(*entry); 6273 this->got_page_entries_.insert(entry2); 6274 this->page_gotno_ += entry->num_pages; 6275 } 6276 } 6277} 6278 6279// Mips_output_data_got methods. 6280 6281// Lay out the GOT. Add local, global and TLS entries. If GOT is 6282// larger than 64K, create multi-GOT. 6283 6284template<int size, bool big_endian> 6285void 6286Mips_output_data_got<size, big_endian>::lay_out_got(Layout* layout, 6287 Symbol_table* symtab, const Input_objects* input_objects) 6288{ 6289 // Decide which symbols need to go in the global part of the GOT and 6290 // count the number of reloc-only GOT symbols. 6291 this->master_got_info_->count_got_symbols(symtab); 6292 6293 // Count the number of GOT entries. 6294 this->master_got_info_->count_got_entries(); 6295 6296 unsigned int got_size = this->master_got_info_->got_size(); 6297 if (got_size > Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE) 6298 this->lay_out_multi_got(layout, input_objects); 6299 else 6300 { 6301 // Record that all objects use single GOT. 6302 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 6303 p != input_objects->relobj_end(); 6304 ++p) 6305 { 6306 Mips_relobj<size, big_endian>* object = 6307 Mips_relobj<size, big_endian>::as_mips_relobj(*p); 6308 if (object->get_got_info() != NULL) 6309 object->set_got_info(this->master_got_info_); 6310 } 6311 6312 this->master_got_info_->add_local_entries(this->target_, layout); 6313 this->master_got_info_->add_global_entries(this->target_, layout, 6314 /*not used*/-1U); 6315 this->master_got_info_->add_tls_entries(this->target_, layout); 6316 } 6317} 6318 6319// Create multi-GOT. For every GOT, add local, global and TLS entries. 6320 6321template<int size, bool big_endian> 6322void 6323Mips_output_data_got<size, big_endian>::lay_out_multi_got(Layout* layout, 6324 const Input_objects* input_objects) 6325{ 6326 // Try to merge the GOTs of input objects together, as long as they 6327 // don't seem to exceed the maximum GOT size, choosing one of them 6328 // to be the primary GOT. 6329 this->merge_gots(input_objects); 6330 6331 // Every symbol that is referenced in a dynamic relocation must be 6332 // present in the primary GOT. 6333 this->primary_got_->set_global_gotno(this->master_got_info_->global_gotno()); 6334 6335 // Add GOT entries. 6336 unsigned int i = 0; 6337 unsigned int offset = 0; 6338 Mips_got_info<size, big_endian>* g = this->primary_got_; 6339 do 6340 { 6341 g->set_index(i); 6342 g->set_offset(offset); 6343 6344 g->add_local_entries(this->target_, layout); 6345 if (i == 0) 6346 g->add_global_entries(this->target_, layout, 6347 (this->master_got_info_->global_gotno() 6348 - this->master_got_info_->reloc_only_gotno())); 6349 else 6350 g->add_global_entries(this->target_, layout, /*not used*/-1U); 6351 g->add_tls_entries(this->target_, layout); 6352 6353 // Forbid global symbols in every non-primary GOT from having 6354 // lazy-binding stubs. 6355 if (i > 0) 6356 g->remove_lazy_stubs(this->target_); 6357 6358 ++i; 6359 offset += g->got_size(); 6360 g = g->next(); 6361 } 6362 while (g); 6363} 6364 6365// Attempt to merge GOTs of different input objects. Try to use as much as 6366// possible of the primary GOT, since it doesn't require explicit dynamic 6367// relocations, but don't use objects that would reference global symbols 6368// out of the addressable range. Failing the primary GOT, attempt to merge 6369// with the current GOT, or finish the current GOT and then make make the new 6370// GOT current. 6371 6372template<int size, bool big_endian> 6373void 6374Mips_output_data_got<size, big_endian>::merge_gots( 6375 const Input_objects* input_objects) 6376{ 6377 gold_assert(this->primary_got_ == NULL); 6378 Mips_got_info<size, big_endian>* current = NULL; 6379 6380 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 6381 p != input_objects->relobj_end(); 6382 ++p) 6383 { 6384 Mips_relobj<size, big_endian>* object = 6385 Mips_relobj<size, big_endian>::as_mips_relobj(*p); 6386 6387 Mips_got_info<size, big_endian>* g = object->get_got_info(); 6388 if (g == NULL) 6389 continue; 6390 6391 g->count_got_entries(); 6392 6393 // Work out the number of page, local and TLS entries. 6394 unsigned int estimate = this->master_got_info_->page_gotno(); 6395 if (estimate > g->page_gotno()) 6396 estimate = g->page_gotno(); 6397 estimate += g->local_gotno() + g->tls_gotno(); 6398 6399 // We place TLS GOT entries after both locals and globals. The globals 6400 // for the primary GOT may overflow the normal GOT size limit, so be 6401 // sure not to merge a GOT which requires TLS with the primary GOT in that 6402 // case. This doesn't affect non-primary GOTs. 6403 estimate += (g->tls_gotno() > 0 ? this->master_got_info_->global_gotno() 6404 : g->global_gotno()); 6405 6406 unsigned int max_count = 6407 Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2; 6408 if (estimate <= max_count) 6409 { 6410 // If we don't have a primary GOT, use it as 6411 // a starting point for the primary GOT. 6412 if (!this->primary_got_) 6413 { 6414 this->primary_got_ = g; 6415 continue; 6416 } 6417 6418 // Try merging with the primary GOT. 6419 if (this->merge_got_with(g, object, this->primary_got_)) 6420 continue; 6421 } 6422 6423 // If we can merge with the last-created GOT, do it. 6424 if (current && this->merge_got_with(g, object, current)) 6425 continue; 6426 6427 // Well, we couldn't merge, so create a new GOT. Don't check if it 6428 // fits; if it turns out that it doesn't, we'll get relocation 6429 // overflows anyway. 6430 g->set_next(current); 6431 current = g; 6432 } 6433 6434 // If we do not find any suitable primary GOT, create an empty one. 6435 if (this->primary_got_ == NULL) 6436 this->primary_got_ = new Mips_got_info<size, big_endian>(); 6437 6438 // Link primary GOT with secondary GOTs. 6439 this->primary_got_->set_next(current); 6440} 6441 6442// Consider merging FROM, which is OBJECT's GOT, into TO. Return false if 6443// this would lead to overflow, true if they were merged successfully. 6444 6445template<int size, bool big_endian> 6446bool 6447Mips_output_data_got<size, big_endian>::merge_got_with( 6448 Mips_got_info<size, big_endian>* from, 6449 Mips_relobj<size, big_endian>* object, 6450 Mips_got_info<size, big_endian>* to) 6451{ 6452 // Work out how many page entries we would need for the combined GOT. 6453 unsigned int estimate = this->master_got_info_->page_gotno(); 6454 if (estimate >= from->page_gotno() + to->page_gotno()) 6455 estimate = from->page_gotno() + to->page_gotno(); 6456 6457 // Conservatively estimate how many local and TLS entries would be needed. 6458 estimate += from->local_gotno() + to->local_gotno(); 6459 estimate += from->tls_gotno() + to->tls_gotno(); 6460 6461 // If we're merging with the primary got, any TLS relocations will 6462 // come after the full set of global entries. Otherwise estimate those 6463 // conservatively as well. 6464 if (to == this->primary_got_ && (from->tls_gotno() + to->tls_gotno()) > 0) 6465 estimate += this->master_got_info_->global_gotno(); 6466 else 6467 estimate += from->global_gotno() + to->global_gotno(); 6468 6469 // Bail out if the combined GOT might be too big. 6470 unsigned int max_count = 6471 Target_mips<size, big_endian>::MIPS_GOT_MAX_SIZE / (size/8) - 2; 6472 if (estimate > max_count) 6473 return false; 6474 6475 // Transfer the object's GOT information from FROM to TO. 6476 to->add_got_entries(from); 6477 to->add_got_page_entries(from); 6478 6479 // Record that OBJECT should use output GOT TO. 6480 object->set_got_info(to); 6481 6482 return true; 6483} 6484 6485// Write out the GOT. 6486 6487template<int size, bool big_endian> 6488void 6489Mips_output_data_got<size, big_endian>::do_write(Output_file* of) 6490{ 6491 typedef Unordered_set<Mips_symbol<size>*, Mips_symbol_hash<size> > 6492 Mips_stubs_entry_set; 6493 6494 // Call parent to write out GOT. 6495 Output_data_got<size, big_endian>::do_write(of); 6496 6497 const off_t offset = this->offset(); 6498 const section_size_type oview_size = 6499 convert_to_section_size_type(this->data_size()); 6500 unsigned char* const oview = of->get_output_view(offset, oview_size); 6501 6502 // Needed for fixing values of .got section. 6503 this->got_view_ = oview; 6504 6505 // Write lazy stub addresses. 6506 for (typename Mips_stubs_entry_set::iterator 6507 p = this->master_got_info_->global_got_symbols().begin(); 6508 p != this->master_got_info_->global_got_symbols().end(); 6509 ++p) 6510 { 6511 Mips_symbol<size>* mips_sym = *p; 6512 if (mips_sym->has_lazy_stub()) 6513 { 6514 Valtype* wv = reinterpret_cast<Valtype*>( 6515 oview + this->get_primary_got_offset(mips_sym)); 6516 Valtype value = 6517 this->target_->mips_stubs_section()->stub_address(mips_sym); 6518 elfcpp::Swap<size, big_endian>::writeval(wv, value); 6519 } 6520 } 6521 6522 // Add +1 to GGA_NONE nonzero MIPS16 and microMIPS entries. 6523 for (typename Mips_stubs_entry_set::iterator 6524 p = this->master_got_info_->global_got_symbols().begin(); 6525 p != this->master_got_info_->global_got_symbols().end(); 6526 ++p) 6527 { 6528 Mips_symbol<size>* mips_sym = *p; 6529 if (!this->multi_got() 6530 && (mips_sym->is_mips16() || mips_sym->is_micromips()) 6531 && mips_sym->global_got_area() == GGA_NONE 6532 && mips_sym->has_got_offset(GOT_TYPE_STANDARD)) 6533 { 6534 Valtype* wv = reinterpret_cast<Valtype*>( 6535 oview + mips_sym->got_offset(GOT_TYPE_STANDARD)); 6536 Valtype value = elfcpp::Swap<size, big_endian>::readval(wv); 6537 if (value != 0) 6538 { 6539 value |= 1; 6540 elfcpp::Swap<size, big_endian>::writeval(wv, value); 6541 } 6542 } 6543 } 6544 6545 if (!this->secondary_got_relocs_.empty()) 6546 { 6547 // Fixup for the secondary GOT R_MIPS_REL32 relocs. For global 6548 // secondary GOT entries with non-zero initial value copy the value 6549 // to the corresponding primary GOT entry, and set the secondary GOT 6550 // entry to zero. 6551 // TODO(sasa): This is workaround. It needs to be investigated further. 6552 6553 for (size_t i = 0; i < this->secondary_got_relocs_.size(); ++i) 6554 { 6555 Static_reloc& reloc(this->secondary_got_relocs_[i]); 6556 if (reloc.symbol_is_global()) 6557 { 6558 Mips_symbol<size>* gsym = reloc.symbol(); 6559 gold_assert(gsym != NULL); 6560 6561 unsigned got_offset = reloc.got_offset(); 6562 gold_assert(got_offset < oview_size); 6563 6564 // Find primary GOT entry. 6565 Valtype* wv_prim = reinterpret_cast<Valtype*>( 6566 oview + this->get_primary_got_offset(gsym)); 6567 6568 // Find secondary GOT entry. 6569 Valtype* wv_sec = reinterpret_cast<Valtype*>(oview + got_offset); 6570 6571 Valtype value = elfcpp::Swap<size, big_endian>::readval(wv_sec); 6572 if (value != 0) 6573 { 6574 elfcpp::Swap<size, big_endian>::writeval(wv_prim, value); 6575 elfcpp::Swap<size, big_endian>::writeval(wv_sec, 0); 6576 gsym->set_applied_secondary_got_fixup(); 6577 } 6578 } 6579 } 6580 6581 of->write_output_view(offset, oview_size, oview); 6582 } 6583 6584 // We are done if there is no fix up. 6585 if (this->static_relocs_.empty()) 6586 return; 6587 6588 Output_segment* tls_segment = this->layout_->tls_segment(); 6589 gold_assert(tls_segment != NULL); 6590 6591 for (size_t i = 0; i < this->static_relocs_.size(); ++i) 6592 { 6593 Static_reloc& reloc(this->static_relocs_[i]); 6594 6595 Mips_address value; 6596 if (!reloc.symbol_is_global()) 6597 { 6598 Sized_relobj_file<size, big_endian>* object = reloc.relobj(); 6599 const Symbol_value<size>* psymval = 6600 object->local_symbol(reloc.index()); 6601 6602 // We are doing static linking. Issue an error and skip this 6603 // relocation if the symbol is undefined or in a discarded_section. 6604 bool is_ordinary; 6605 unsigned int shndx = psymval->input_shndx(&is_ordinary); 6606 if ((shndx == elfcpp::SHN_UNDEF) 6607 || (is_ordinary 6608 && shndx != elfcpp::SHN_UNDEF 6609 && !object->is_section_included(shndx) 6610 && !this->symbol_table_->is_section_folded(object, shndx))) 6611 { 6612 gold_error(_("undefined or discarded local symbol %u from " 6613 " object %s in GOT"), 6614 reloc.index(), reloc.relobj()->name().c_str()); 6615 continue; 6616 } 6617 6618 value = psymval->value(object, 0); 6619 } 6620 else 6621 { 6622 const Mips_symbol<size>* gsym = reloc.symbol(); 6623 gold_assert(gsym != NULL); 6624 6625 // We are doing static linking. Issue an error and skip this 6626 // relocation if the symbol is undefined or in a discarded_section 6627 // unless it is a weakly_undefined symbol. 6628 if ((gsym->is_defined_in_discarded_section() || gsym->is_undefined()) 6629 && !gsym->is_weak_undefined()) 6630 { 6631 gold_error(_("undefined or discarded symbol %s in GOT"), 6632 gsym->name()); 6633 continue; 6634 } 6635 6636 if (!gsym->is_weak_undefined()) 6637 value = gsym->value(); 6638 else 6639 value = 0; 6640 } 6641 6642 unsigned got_offset = reloc.got_offset(); 6643 gold_assert(got_offset < oview_size); 6644 6645 Valtype* wv = reinterpret_cast<Valtype*>(oview + got_offset); 6646 Valtype x; 6647 6648 switch (reloc.r_type()) 6649 { 6650 case elfcpp::R_MIPS_TLS_DTPMOD32: 6651 case elfcpp::R_MIPS_TLS_DTPMOD64: 6652 x = value; 6653 break; 6654 case elfcpp::R_MIPS_TLS_DTPREL32: 6655 case elfcpp::R_MIPS_TLS_DTPREL64: 6656 x = value - elfcpp::DTP_OFFSET; 6657 break; 6658 case elfcpp::R_MIPS_TLS_TPREL32: 6659 case elfcpp::R_MIPS_TLS_TPREL64: 6660 x = value - elfcpp::TP_OFFSET; 6661 break; 6662 default: 6663 gold_unreachable(); 6664 break; 6665 } 6666 6667 elfcpp::Swap<size, big_endian>::writeval(wv, x); 6668 } 6669 6670 of->write_output_view(offset, oview_size, oview); 6671} 6672 6673// Mips_relobj methods. 6674 6675// Count the local symbols. The Mips backend needs to know if a symbol 6676// is a MIPS16 or microMIPS function or not. For global symbols, it is easy 6677// because the Symbol object keeps the ELF symbol type and st_other field. 6678// For local symbol it is harder because we cannot access this information. 6679// So we override the do_count_local_symbol in parent and scan local symbols to 6680// mark MIPS16 and microMIPS functions. This is not the most efficient way but 6681// I do not want to slow down other ports by calling a per symbol target hook 6682// inside Sized_relobj_file<size, big_endian>::do_count_local_symbols. 6683 6684template<int size, bool big_endian> 6685void 6686Mips_relobj<size, big_endian>::do_count_local_symbols( 6687 Stringpool_template<char>* pool, 6688 Stringpool_template<char>* dynpool) 6689{ 6690 // Ask parent to count the local symbols. 6691 Sized_relobj_file<size, big_endian>::do_count_local_symbols(pool, dynpool); 6692 const unsigned int loccount = this->local_symbol_count(); 6693 if (loccount == 0) 6694 return; 6695 6696 // Initialize the mips16 and micromips function bit-vector. 6697 this->local_symbol_is_mips16_.resize(loccount, false); 6698 this->local_symbol_is_micromips_.resize(loccount, false); 6699 6700 // Read the symbol table section header. 6701 const unsigned int symtab_shndx = this->symtab_shndx(); 6702 elfcpp::Shdr<size, big_endian> 6703 symtabshdr(this, this->elf_file()->section_header(symtab_shndx)); 6704 gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); 6705 6706 // Read the local symbols. 6707 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 6708 gold_assert(loccount == symtabshdr.get_sh_info()); 6709 off_t locsize = loccount * sym_size; 6710 const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), 6711 locsize, true, true); 6712 6713 // Loop over the local symbols and mark any MIPS16 or microMIPS local symbols. 6714 6715 // Skip the first dummy symbol. 6716 psyms += sym_size; 6717 for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) 6718 { 6719 elfcpp::Sym<size, big_endian> sym(psyms); 6720 unsigned char st_other = sym.get_st_other(); 6721 this->local_symbol_is_mips16_[i] = elfcpp::elf_st_is_mips16(st_other); 6722 this->local_symbol_is_micromips_[i] = 6723 elfcpp::elf_st_is_micromips(st_other); 6724 } 6725} 6726 6727// Read the symbol information. 6728 6729template<int size, bool big_endian> 6730void 6731Mips_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd) 6732{ 6733 // Call parent class to read symbol information. 6734 this->base_read_symbols(sd); 6735 6736 // Read processor-specific flags in ELF file header. 6737 const unsigned char* pehdr = this->get_view(elfcpp::file_header_offset, 6738 elfcpp::Elf_sizes<size>::ehdr_size, 6739 true, false); 6740 elfcpp::Ehdr<size, big_endian> ehdr(pehdr); 6741 this->processor_specific_flags_ = ehdr.get_e_flags(); 6742 6743 // Get the section names. 6744 const unsigned char* pnamesu = sd->section_names->data(); 6745 const char* pnames = reinterpret_cast<const char*>(pnamesu); 6746 6747 // Initialize the mips16 stub section bit-vectors. 6748 this->section_is_mips16_fn_stub_.resize(this->shnum(), false); 6749 this->section_is_mips16_call_stub_.resize(this->shnum(), false); 6750 this->section_is_mips16_call_fp_stub_.resize(this->shnum(), false); 6751 6752 const size_t shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 6753 const unsigned char* pshdrs = sd->section_headers->data(); 6754 const unsigned char* ps = pshdrs + shdr_size; 6755 for (unsigned int i = 1; i < this->shnum(); ++i, ps += shdr_size) 6756 { 6757 elfcpp::Shdr<size, big_endian> shdr(ps); 6758 6759 if (shdr.get_sh_type() == elfcpp::SHT_MIPS_REGINFO) 6760 { 6761 this->has_reginfo_section_ = true; 6762 // Read the gp value that was used to create this object. We need the 6763 // gp value while processing relocs. The .reginfo section is not used 6764 // in the 64-bit MIPS ELF ABI. 6765 section_offset_type section_offset = shdr.get_sh_offset(); 6766 section_size_type section_size = 6767 convert_to_section_size_type(shdr.get_sh_size()); 6768 const unsigned char* view = 6769 this->get_view(section_offset, section_size, true, false); 6770 6771 this->gp_ = elfcpp::Swap<size, big_endian>::readval(view + 20); 6772 6773 // Read the rest of .reginfo. 6774 this->gprmask_ = elfcpp::Swap<size, big_endian>::readval(view); 6775 this->cprmask1_ = elfcpp::Swap<size, big_endian>::readval(view + 4); 6776 this->cprmask2_ = elfcpp::Swap<size, big_endian>::readval(view + 8); 6777 this->cprmask3_ = elfcpp::Swap<size, big_endian>::readval(view + 12); 6778 this->cprmask4_ = elfcpp::Swap<size, big_endian>::readval(view + 16); 6779 } 6780 6781 if (shdr.get_sh_type() == elfcpp::SHT_GNU_ATTRIBUTES) 6782 { 6783 gold_assert(this->attributes_section_data_ == NULL); 6784 section_offset_type section_offset = shdr.get_sh_offset(); 6785 section_size_type section_size = 6786 convert_to_section_size_type(shdr.get_sh_size()); 6787 const unsigned char* view = 6788 this->get_view(section_offset, section_size, true, false); 6789 this->attributes_section_data_ = 6790 new Attributes_section_data(view, section_size); 6791 } 6792 6793 if (shdr.get_sh_type() == elfcpp::SHT_MIPS_ABIFLAGS) 6794 { 6795 gold_assert(this->abiflags_ == NULL); 6796 section_offset_type section_offset = shdr.get_sh_offset(); 6797 section_size_type section_size = 6798 convert_to_section_size_type(shdr.get_sh_size()); 6799 const unsigned char* view = 6800 this->get_view(section_offset, section_size, true, false); 6801 this->abiflags_ = new Mips_abiflags<big_endian>(); 6802 6803 this->abiflags_->version = 6804 elfcpp::Swap<16, big_endian>::readval(view); 6805 if (this->abiflags_->version != 0) 6806 { 6807 gold_error(_("%s: .MIPS.abiflags section has " 6808 "unsupported version %u"), 6809 this->name().c_str(), 6810 this->abiflags_->version); 6811 break; 6812 } 6813 this->abiflags_->isa_level = 6814 elfcpp::Swap<8, big_endian>::readval(view + 2); 6815 this->abiflags_->isa_rev = 6816 elfcpp::Swap<8, big_endian>::readval(view + 3); 6817 this->abiflags_->gpr_size = 6818 elfcpp::Swap<8, big_endian>::readval(view + 4); 6819 this->abiflags_->cpr1_size = 6820 elfcpp::Swap<8, big_endian>::readval(view + 5); 6821 this->abiflags_->cpr2_size = 6822 elfcpp::Swap<8, big_endian>::readval(view + 6); 6823 this->abiflags_->fp_abi = 6824 elfcpp::Swap<8, big_endian>::readval(view + 7); 6825 this->abiflags_->isa_ext = 6826 elfcpp::Swap<32, big_endian>::readval(view + 8); 6827 this->abiflags_->ases = 6828 elfcpp::Swap<32, big_endian>::readval(view + 12); 6829 this->abiflags_->flags1 = 6830 elfcpp::Swap<32, big_endian>::readval(view + 16); 6831 this->abiflags_->flags2 = 6832 elfcpp::Swap<32, big_endian>::readval(view + 20); 6833 } 6834 6835 // In the 64-bit ABI, .MIPS.options section holds register information. 6836 // A SHT_MIPS_OPTIONS section contains a series of options, each of which 6837 // starts with this header: 6838 // 6839 // typedef struct 6840 // { 6841 // // Type of option. 6842 // unsigned char kind[1]; 6843 // // Size of option descriptor, including header. 6844 // unsigned char size[1]; 6845 // // Section index of affected section, or 0 for global option. 6846 // unsigned char section[2]; 6847 // // Information specific to this kind of option. 6848 // unsigned char info[4]; 6849 // }; 6850 // 6851 // For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and set 6852 // the gp value based on what we find. We may see both SHT_MIPS_REGINFO 6853 // and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case, they should agree. 6854 6855 if (shdr.get_sh_type() == elfcpp::SHT_MIPS_OPTIONS) 6856 { 6857 section_offset_type section_offset = shdr.get_sh_offset(); 6858 section_size_type section_size = 6859 convert_to_section_size_type(shdr.get_sh_size()); 6860 const unsigned char* view = 6861 this->get_view(section_offset, section_size, true, false); 6862 const unsigned char* end = view + section_size; 6863 6864 while (view + 8 <= end) 6865 { 6866 unsigned char kind = elfcpp::Swap<8, big_endian>::readval(view); 6867 unsigned char sz = elfcpp::Swap<8, big_endian>::readval(view + 1); 6868 if (sz < 8) 6869 { 6870 gold_error(_("%s: Warning: bad `%s' option size %u smaller " 6871 "than its header"), 6872 this->name().c_str(), 6873 this->mips_elf_options_section_name(), sz); 6874 break; 6875 } 6876 6877 if (this->is_n64() && kind == elfcpp::ODK_REGINFO) 6878 { 6879 // In the 64 bit ABI, an ODK_REGINFO option is the following 6880 // structure. The info field of the options header is not 6881 // used. 6882 // 6883 // typedef struct 6884 // { 6885 // // Mask of general purpose registers used. 6886 // unsigned char ri_gprmask[4]; 6887 // // Padding. 6888 // unsigned char ri_pad[4]; 6889 // // Mask of co-processor registers used. 6890 // unsigned char ri_cprmask[4][4]; 6891 // // GP register value for this object file. 6892 // unsigned char ri_gp_value[8]; 6893 // }; 6894 6895 this->gp_ = elfcpp::Swap<size, big_endian>::readval(view 6896 + 32); 6897 } 6898 else if (kind == elfcpp::ODK_REGINFO) 6899 { 6900 // In the 32 bit ABI, an ODK_REGINFO option is the following 6901 // structure. The info field of the options header is not 6902 // used. The same structure is used in .reginfo section. 6903 // 6904 // typedef struct 6905 // { 6906 // unsigned char ri_gprmask[4]; 6907 // unsigned char ri_cprmask[4][4]; 6908 // unsigned char ri_gp_value[4]; 6909 // }; 6910 6911 this->gp_ = elfcpp::Swap<size, big_endian>::readval(view 6912 + 28); 6913 } 6914 view += sz; 6915 } 6916 } 6917 6918 const char* name = pnames + shdr.get_sh_name(); 6919 this->section_is_mips16_fn_stub_[i] = is_prefix_of(".mips16.fn", name); 6920 this->section_is_mips16_call_stub_[i] = 6921 is_prefix_of(".mips16.call.", name); 6922 this->section_is_mips16_call_fp_stub_[i] = 6923 is_prefix_of(".mips16.call.fp.", name); 6924 6925 if (strcmp(name, ".pdr") == 0) 6926 { 6927 gold_assert(this->pdr_shndx_ == -1U); 6928 this->pdr_shndx_ = i; 6929 } 6930 } 6931} 6932 6933// Discard MIPS16 stub secions that are not needed. 6934 6935template<int size, bool big_endian> 6936void 6937Mips_relobj<size, big_endian>::discard_mips16_stub_sections(Symbol_table* symtab) 6938{ 6939 for (typename Mips16_stubs_int_map::const_iterator 6940 it = this->mips16_stub_sections_.begin(); 6941 it != this->mips16_stub_sections_.end(); ++it) 6942 { 6943 Mips16_stub_section<size, big_endian>* stub_section = it->second; 6944 if (!stub_section->is_target_found()) 6945 { 6946 gold_error(_("no relocation found in mips16 stub section '%s'"), 6947 stub_section->object() 6948 ->section_name(stub_section->shndx()).c_str()); 6949 } 6950 6951 bool discard = false; 6952 if (stub_section->is_for_local_function()) 6953 { 6954 if (stub_section->is_fn_stub()) 6955 { 6956 // This stub is for a local symbol. This stub will only 6957 // be needed if there is some relocation in this object, 6958 // other than a 16 bit function call, which refers to this 6959 // symbol. 6960 if (!this->has_local_non_16bit_call_relocs(stub_section->r_sym())) 6961 discard = true; 6962 else 6963 this->add_local_mips16_fn_stub(stub_section); 6964 } 6965 else 6966 { 6967 // This stub is for a local symbol. This stub will only 6968 // be needed if there is some relocation (R_MIPS16_26) in 6969 // this object that refers to this symbol. 6970 gold_assert(stub_section->is_call_stub() 6971 || stub_section->is_call_fp_stub()); 6972 if (!this->has_local_16bit_call_relocs(stub_section->r_sym())) 6973 discard = true; 6974 else 6975 this->add_local_mips16_call_stub(stub_section); 6976 } 6977 } 6978 else 6979 { 6980 Mips_symbol<size>* gsym = stub_section->gsym(); 6981 if (stub_section->is_fn_stub()) 6982 { 6983 if (gsym->has_mips16_fn_stub()) 6984 // We already have a stub for this function. 6985 discard = true; 6986 else 6987 { 6988 gsym->set_mips16_fn_stub(stub_section); 6989 if (gsym->should_add_dynsym_entry(symtab)) 6990 { 6991 // If we have a MIPS16 function with a stub, the 6992 // dynamic symbol must refer to the stub, since only 6993 // the stub uses the standard calling conventions. 6994 gsym->set_need_fn_stub(); 6995 if (gsym->is_from_dynobj()) 6996 gsym->set_needs_dynsym_value(); 6997 } 6998 } 6999 if (!gsym->need_fn_stub()) 7000 discard = true; 7001 } 7002 else if (stub_section->is_call_stub()) 7003 { 7004 if (gsym->is_mips16()) 7005 // We don't need the call_stub; this is a 16 bit 7006 // function, so calls from other 16 bit functions are 7007 // OK. 7008 discard = true; 7009 else if (gsym->has_mips16_call_stub()) 7010 // We already have a stub for this function. 7011 discard = true; 7012 else 7013 gsym->set_mips16_call_stub(stub_section); 7014 } 7015 else 7016 { 7017 gold_assert(stub_section->is_call_fp_stub()); 7018 if (gsym->is_mips16()) 7019 // We don't need the call_stub; this is a 16 bit 7020 // function, so calls from other 16 bit functions are 7021 // OK. 7022 discard = true; 7023 else if (gsym->has_mips16_call_fp_stub()) 7024 // We already have a stub for this function. 7025 discard = true; 7026 else 7027 gsym->set_mips16_call_fp_stub(stub_section); 7028 } 7029 } 7030 if (discard) 7031 this->set_output_section(stub_section->shndx(), NULL); 7032 } 7033} 7034 7035// Mips_output_data_la25_stub methods. 7036 7037// Template for standard LA25 stub. 7038template<int size, bool big_endian> 7039const uint32_t 7040Mips_output_data_la25_stub<size, big_endian>::la25_stub_entry[] = 7041{ 7042 0x3c190000, // lui $25,%hi(func) 7043 0x08000000, // j func 7044 0x27390000, // add $25,$25,%lo(func) 7045 0x00000000 // nop 7046}; 7047 7048// Template for microMIPS LA25 stub. 7049template<int size, bool big_endian> 7050const uint32_t 7051Mips_output_data_la25_stub<size, big_endian>::la25_stub_micromips_entry[] = 7052{ 7053 0x41b9, 0x0000, // lui t9,%hi(func) 7054 0xd400, 0x0000, // j func 7055 0x3339, 0x0000, // addiu t9,t9,%lo(func) 7056 0x0000, 0x0000 // nop 7057}; 7058 7059// Create la25 stub for a symbol. 7060 7061template<int size, bool big_endian> 7062void 7063Mips_output_data_la25_stub<size, big_endian>::create_la25_stub( 7064 Symbol_table* symtab, Target_mips<size, big_endian>* target, 7065 Mips_symbol<size>* gsym) 7066{ 7067 if (!gsym->has_la25_stub()) 7068 { 7069 gsym->set_la25_stub_offset(this->symbols_.size() * 16); 7070 this->symbols_.push_back(gsym); 7071 this->create_stub_symbol(gsym, symtab, target, 16); 7072 } 7073} 7074 7075// Create a symbol for SYM stub's value and size, to help make the disassembly 7076// easier to read. 7077 7078template<int size, bool big_endian> 7079void 7080Mips_output_data_la25_stub<size, big_endian>::create_stub_symbol( 7081 Mips_symbol<size>* sym, Symbol_table* symtab, 7082 Target_mips<size, big_endian>* target, uint64_t symsize) 7083{ 7084 std::string name(".pic."); 7085 name += sym->name(); 7086 7087 unsigned int offset = sym->la25_stub_offset(); 7088 if (sym->is_micromips()) 7089 offset |= 1; 7090 7091 // Make it a local function. 7092 Symbol* new_sym = symtab->define_in_output_data(name.c_str(), NULL, 7093 Symbol_table::PREDEFINED, 7094 target->la25_stub_section(), 7095 offset, symsize, elfcpp::STT_FUNC, 7096 elfcpp::STB_LOCAL, 7097 elfcpp::STV_DEFAULT, 0, 7098 false, false); 7099 new_sym->set_is_forced_local(); 7100} 7101 7102// Write out la25 stubs. This uses the hand-coded instructions above, 7103// and adjusts them as needed. 7104 7105template<int size, bool big_endian> 7106void 7107Mips_output_data_la25_stub<size, big_endian>::do_write(Output_file* of) 7108{ 7109 const off_t offset = this->offset(); 7110 const section_size_type oview_size = 7111 convert_to_section_size_type(this->data_size()); 7112 unsigned char* const oview = of->get_output_view(offset, oview_size); 7113 7114 for (typename std::vector<Mips_symbol<size>*>::iterator 7115 p = this->symbols_.begin(); 7116 p != this->symbols_.end(); 7117 ++p) 7118 { 7119 Mips_symbol<size>* sym = *p; 7120 unsigned char* pov = oview + sym->la25_stub_offset(); 7121 7122 Mips_address target = sym->value(); 7123 if (!sym->is_micromips()) 7124 { 7125 elfcpp::Swap<32, big_endian>::writeval(pov, 7126 la25_stub_entry[0] | (((target + 0x8000) >> 16) & 0xffff)); 7127 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 7128 la25_stub_entry[1] | ((target >> 2) & 0x3ffffff)); 7129 elfcpp::Swap<32, big_endian>::writeval(pov + 8, 7130 la25_stub_entry[2] | (target & 0xffff)); 7131 elfcpp::Swap<32, big_endian>::writeval(pov + 12, la25_stub_entry[3]); 7132 } 7133 else 7134 { 7135 target |= 1; 7136 // First stub instruction. Paste high 16-bits of the target. 7137 elfcpp::Swap<16, big_endian>::writeval(pov, 7138 la25_stub_micromips_entry[0]); 7139 elfcpp::Swap<16, big_endian>::writeval(pov + 2, 7140 ((target + 0x8000) >> 16) & 0xffff); 7141 // Second stub instruction. Paste low 26-bits of the target, shifted 7142 // right by 1. 7143 elfcpp::Swap<16, big_endian>::writeval(pov + 4, 7144 la25_stub_micromips_entry[2] | ((target >> 17) & 0x3ff)); 7145 elfcpp::Swap<16, big_endian>::writeval(pov + 6, 7146 la25_stub_micromips_entry[3] | ((target >> 1) & 0xffff)); 7147 // Third stub instruction. Paste low 16-bits of the target. 7148 elfcpp::Swap<16, big_endian>::writeval(pov + 8, 7149 la25_stub_micromips_entry[4]); 7150 elfcpp::Swap<16, big_endian>::writeval(pov + 10, target & 0xffff); 7151 // Fourth stub instruction. 7152 elfcpp::Swap<16, big_endian>::writeval(pov + 12, 7153 la25_stub_micromips_entry[6]); 7154 elfcpp::Swap<16, big_endian>::writeval(pov + 14, 7155 la25_stub_micromips_entry[7]); 7156 } 7157 } 7158 7159 of->write_output_view(offset, oview_size, oview); 7160} 7161 7162// Mips_output_data_plt methods. 7163 7164// The format of the first PLT entry in an O32 executable. 7165template<int size, bool big_endian> 7166const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_o32[] = 7167{ 7168 0x3c1c0000, // lui $28, %hi(&GOTPLT[0]) 7169 0x8f990000, // lw $25, %lo(&GOTPLT[0])($28) 7170 0x279c0000, // addiu $28, $28, %lo(&GOTPLT[0]) 7171 0x031cc023, // subu $24, $24, $28 7172 0x03e07825, // or $15, $31, zero 7173 0x0018c082, // srl $24, $24, 2 7174 0x0320f809, // jalr $25 7175 0x2718fffe // subu $24, $24, 2 7176}; 7177 7178// The format of the first PLT entry in an N32 executable. Different 7179// because gp ($28) is not available; we use t2 ($14) instead. 7180template<int size, bool big_endian> 7181const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n32[] = 7182{ 7183 0x3c0e0000, // lui $14, %hi(&GOTPLT[0]) 7184 0x8dd90000, // lw $25, %lo(&GOTPLT[0])($14) 7185 0x25ce0000, // addiu $14, $14, %lo(&GOTPLT[0]) 7186 0x030ec023, // subu $24, $24, $14 7187 0x03e07825, // or $15, $31, zero 7188 0x0018c082, // srl $24, $24, 2 7189 0x0320f809, // jalr $25 7190 0x2718fffe // subu $24, $24, 2 7191}; 7192 7193// The format of the first PLT entry in an N64 executable. Different 7194// from N32 because of the increased size of GOT entries. 7195template<int size, bool big_endian> 7196const uint32_t Mips_output_data_plt<size, big_endian>::plt0_entry_n64[] = 7197{ 7198 0x3c0e0000, // lui $14, %hi(&GOTPLT[0]) 7199 0xddd90000, // ld $25, %lo(&GOTPLT[0])($14) 7200 0x25ce0000, // addiu $14, $14, %lo(&GOTPLT[0]) 7201 0x030ec023, // subu $24, $24, $14 7202 0x03e07825, // or $15, $31, zero 7203 0x0018c0c2, // srl $24, $24, 3 7204 0x0320f809, // jalr $25 7205 0x2718fffe // subu $24, $24, 2 7206}; 7207 7208// The format of the microMIPS first PLT entry in an O32 executable. 7209// We rely on v0 ($2) rather than t8 ($24) to contain the address 7210// of the GOTPLT entry handled, so this stub may only be used when 7211// all the subsequent PLT entries are microMIPS code too. 7212// 7213// The trailing NOP is for alignment and correct disassembly only. 7214template<int size, bool big_endian> 7215const uint32_t Mips_output_data_plt<size, big_endian>:: 7216plt0_entry_micromips_o32[] = 7217{ 7218 0x7980, 0x0000, // addiupc $3, (&GOTPLT[0]) - . 7219 0xff23, 0x0000, // lw $25, 0($3) 7220 0x0535, // subu $2, $2, $3 7221 0x2525, // srl $2, $2, 2 7222 0x3302, 0xfffe, // subu $24, $2, 2 7223 0x0dff, // move $15, $31 7224 0x45f9, // jalrs $25 7225 0x0f83, // move $28, $3 7226 0x0c00 // nop 7227}; 7228 7229// The format of the microMIPS first PLT entry in an O32 executable 7230// in the insn32 mode. 7231template<int size, bool big_endian> 7232const uint32_t Mips_output_data_plt<size, big_endian>:: 7233plt0_entry_micromips32_o32[] = 7234{ 7235 0x41bc, 0x0000, // lui $28, %hi(&GOTPLT[0]) 7236 0xff3c, 0x0000, // lw $25, %lo(&GOTPLT[0])($28) 7237 0x339c, 0x0000, // addiu $28, $28, %lo(&GOTPLT[0]) 7238 0x0398, 0xc1d0, // subu $24, $24, $28 7239 0x001f, 0x7a90, // or $15, $31, zero 7240 0x0318, 0x1040, // srl $24, $24, 2 7241 0x03f9, 0x0f3c, // jalr $25 7242 0x3318, 0xfffe // subu $24, $24, 2 7243}; 7244 7245// The format of subsequent standard entries in the PLT. 7246template<int size, bool big_endian> 7247const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry[] = 7248{ 7249 0x3c0f0000, // lui $15, %hi(.got.plt entry) 7250 0x01f90000, // l[wd] $25, %lo(.got.plt entry)($15) 7251 0x03200008, // jr $25 7252 0x25f80000 // addiu $24, $15, %lo(.got.plt entry) 7253}; 7254 7255// The format of subsequent R6 PLT entries. 7256template<int size, bool big_endian> 7257const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry_r6[] = 7258{ 7259 0x3c0f0000, // lui $15, %hi(.got.plt entry) 7260 0x01f90000, // l[wd] $25, %lo(.got.plt entry)($15) 7261 0x03200009, // jr $25 7262 0x25f80000 // addiu $24, $15, %lo(.got.plt entry) 7263}; 7264 7265// The format of subsequent MIPS16 o32 PLT entries. We use v1 ($3) as a 7266// temporary because t8 ($24) and t9 ($25) are not directly addressable. 7267// Note that this differs from the GNU ld which uses both v0 ($2) and v1 ($3). 7268// We cannot use v0 because MIPS16 call stubs from the CS toolchain expect 7269// target function address in register v0. 7270template<int size, bool big_endian> 7271const uint32_t Mips_output_data_plt<size, big_endian>::plt_entry_mips16_o32[] = 7272{ 7273 0xb303, // lw $3, 12($pc) 7274 0x651b, // move $24, $3 7275 0x9b60, // lw $3, 0($3) 7276 0xeb00, // jr $3 7277 0x653b, // move $25, $3 7278 0x6500, // nop 7279 0x0000, 0x0000 // .word (.got.plt entry) 7280}; 7281 7282// The format of subsequent microMIPS o32 PLT entries. We use v0 ($2) 7283// as a temporary because t8 ($24) is not addressable with ADDIUPC. 7284template<int size, bool big_endian> 7285const uint32_t Mips_output_data_plt<size, big_endian>:: 7286plt_entry_micromips_o32[] = 7287{ 7288 0x7900, 0x0000, // addiupc $2, (.got.plt entry) - . 7289 0xff22, 0x0000, // lw $25, 0($2) 7290 0x4599, // jr $25 7291 0x0f02 // move $24, $2 7292}; 7293 7294// The format of subsequent microMIPS o32 PLT entries in the insn32 mode. 7295template<int size, bool big_endian> 7296const uint32_t Mips_output_data_plt<size, big_endian>:: 7297plt_entry_micromips32_o32[] = 7298{ 7299 0x41af, 0x0000, // lui $15, %hi(.got.plt entry) 7300 0xff2f, 0x0000, // lw $25, %lo(.got.plt entry)($15) 7301 0x0019, 0x0f3c, // jr $25 7302 0x330f, 0x0000 // addiu $24, $15, %lo(.got.plt entry) 7303}; 7304 7305// Add an entry to the PLT for a symbol referenced by r_type relocation. 7306 7307template<int size, bool big_endian> 7308void 7309Mips_output_data_plt<size, big_endian>::add_entry(Mips_symbol<size>* gsym, 7310 unsigned int r_type) 7311{ 7312 gold_assert(!gsym->has_plt_offset()); 7313 7314 // Final PLT offset for a symbol will be set in method set_plt_offsets(). 7315 gsym->set_plt_offset(this->entry_count() * sizeof(plt_entry) 7316 + sizeof(plt0_entry_o32)); 7317 this->symbols_.push_back(gsym); 7318 7319 // Record whether the relocation requires a standard MIPS 7320 // or a compressed code entry. 7321 if (jal_reloc(r_type)) 7322 { 7323 if (r_type == elfcpp::R_MIPS_26) 7324 gsym->set_needs_mips_plt(true); 7325 else 7326 gsym->set_needs_comp_plt(true); 7327 } 7328 7329 section_offset_type got_offset = this->got_plt_->current_data_size(); 7330 7331 // Every PLT entry needs a GOT entry which points back to the PLT 7332 // entry (this will be changed by the dynamic linker, normally 7333 // lazily when the function is called). 7334 this->got_plt_->set_current_data_size(got_offset + size/8); 7335 7336 gsym->set_needs_dynsym_entry(); 7337 this->rel_->add_global(gsym, elfcpp::R_MIPS_JUMP_SLOT, this->got_plt_, 7338 got_offset); 7339} 7340 7341// Set final PLT offsets. For each symbol, determine whether standard or 7342// compressed (MIPS16 or microMIPS) PLT entry is used. 7343 7344template<int size, bool big_endian> 7345void 7346Mips_output_data_plt<size, big_endian>::set_plt_offsets() 7347{ 7348 // The sizes of individual PLT entries. 7349 unsigned int plt_mips_entry_size = this->standard_plt_entry_size(); 7350 unsigned int plt_comp_entry_size = (!this->target_->is_output_newabi() 7351 ? this->compressed_plt_entry_size() : 0); 7352 7353 for (typename std::vector<Mips_symbol<size>*>::const_iterator 7354 p = this->symbols_.begin(); p != this->symbols_.end(); ++p) 7355 { 7356 Mips_symbol<size>* mips_sym = *p; 7357 7358 // There are no defined MIPS16 or microMIPS PLT entries for n32 or n64, 7359 // so always use a standard entry there. 7360 // 7361 // If the symbol has a MIPS16 call stub and gets a PLT entry, then 7362 // all MIPS16 calls will go via that stub, and there is no benefit 7363 // to having a MIPS16 entry. And in the case of call_stub a 7364 // standard entry actually has to be used as the stub ends with a J 7365 // instruction. 7366 if (this->target_->is_output_newabi() 7367 || mips_sym->has_mips16_call_stub() 7368 || mips_sym->has_mips16_call_fp_stub()) 7369 { 7370 mips_sym->set_needs_mips_plt(true); 7371 mips_sym->set_needs_comp_plt(false); 7372 } 7373 7374 // Otherwise, if there are no direct calls to the function, we 7375 // have a free choice of whether to use standard or compressed 7376 // entries. Prefer microMIPS entries if the object is known to 7377 // contain microMIPS code, so that it becomes possible to create 7378 // pure microMIPS binaries. Prefer standard entries otherwise, 7379 // because MIPS16 ones are no smaller and are usually slower. 7380 if (!mips_sym->needs_mips_plt() && !mips_sym->needs_comp_plt()) 7381 { 7382 if (this->target_->is_output_micromips()) 7383 mips_sym->set_needs_comp_plt(true); 7384 else 7385 mips_sym->set_needs_mips_plt(true); 7386 } 7387 7388 if (mips_sym->needs_mips_plt()) 7389 { 7390 mips_sym->set_mips_plt_offset(this->plt_mips_offset_); 7391 this->plt_mips_offset_ += plt_mips_entry_size; 7392 } 7393 if (mips_sym->needs_comp_plt()) 7394 { 7395 mips_sym->set_comp_plt_offset(this->plt_comp_offset_); 7396 this->plt_comp_offset_ += plt_comp_entry_size; 7397 } 7398 } 7399 7400 // Figure out the size of the PLT header if we know that we are using it. 7401 if (this->plt_mips_offset_ + this->plt_comp_offset_ != 0) 7402 this->plt_header_size_ = this->get_plt_header_size(); 7403} 7404 7405// Write out the PLT. This uses the hand-coded instructions above, 7406// and adjusts them as needed. 7407 7408template<int size, bool big_endian> 7409void 7410Mips_output_data_plt<size, big_endian>::do_write(Output_file* of) 7411{ 7412 const off_t offset = this->offset(); 7413 const section_size_type oview_size = 7414 convert_to_section_size_type(this->data_size()); 7415 unsigned char* const oview = of->get_output_view(offset, oview_size); 7416 7417 const off_t gotplt_file_offset = this->got_plt_->offset(); 7418 const section_size_type gotplt_size = 7419 convert_to_section_size_type(this->got_plt_->data_size()); 7420 unsigned char* const gotplt_view = of->get_output_view(gotplt_file_offset, 7421 gotplt_size); 7422 unsigned char* pov = oview; 7423 7424 Mips_address plt_address = this->address(); 7425 7426 // Calculate the address of .got.plt. 7427 Mips_address gotplt_addr = this->got_plt_->address(); 7428 Mips_address gotplt_addr_high = ((gotplt_addr + 0x8000) >> 16) & 0xffff; 7429 Mips_address gotplt_addr_low = gotplt_addr & 0xffff; 7430 7431 // The PLT sequence is not safe for N64 if .got.plt's address can 7432 // not be loaded in two instructions. 7433 gold_assert((gotplt_addr & ~(Mips_address) 0x7fffffff) == 0 7434 || ~(gotplt_addr | 0x7fffffff) == 0); 7435 7436 // Write the PLT header. 7437 const uint32_t* plt0_entry = this->get_plt_header_entry(); 7438 if (plt0_entry == plt0_entry_micromips_o32) 7439 { 7440 // Write microMIPS PLT header. 7441 gold_assert(gotplt_addr % 4 == 0); 7442 7443 Mips_address gotpc_offset = gotplt_addr - ((plt_address | 3) ^ 3); 7444 7445 // ADDIUPC has a span of +/-16MB, check we're in range. 7446 if (gotpc_offset + 0x1000000 >= 0x2000000) 7447 { 7448 gold_error(_(".got.plt offset of %ld from .plt beyond the range of " 7449 "ADDIUPC"), (long)gotpc_offset); 7450 return; 7451 } 7452 7453 elfcpp::Swap<16, big_endian>::writeval(pov, 7454 plt0_entry[0] | ((gotpc_offset >> 18) & 0x7f)); 7455 elfcpp::Swap<16, big_endian>::writeval(pov + 2, 7456 (gotpc_offset >> 2) & 0xffff); 7457 pov += 4; 7458 for (unsigned int i = 2; 7459 i < (sizeof(plt0_entry_micromips_o32) 7460 / sizeof(plt0_entry_micromips_o32[0])); 7461 i++) 7462 { 7463 elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]); 7464 pov += 2; 7465 } 7466 } 7467 else if (plt0_entry == plt0_entry_micromips32_o32) 7468 { 7469 // Write microMIPS PLT header in insn32 mode. 7470 elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[0]); 7471 elfcpp::Swap<16, big_endian>::writeval(pov + 2, gotplt_addr_high); 7472 elfcpp::Swap<16, big_endian>::writeval(pov + 4, plt0_entry[2]); 7473 elfcpp::Swap<16, big_endian>::writeval(pov + 6, gotplt_addr_low); 7474 elfcpp::Swap<16, big_endian>::writeval(pov + 8, plt0_entry[4]); 7475 elfcpp::Swap<16, big_endian>::writeval(pov + 10, gotplt_addr_low); 7476 pov += 12; 7477 for (unsigned int i = 6; 7478 i < (sizeof(plt0_entry_micromips32_o32) 7479 / sizeof(plt0_entry_micromips32_o32[0])); 7480 i++) 7481 { 7482 elfcpp::Swap<16, big_endian>::writeval(pov, plt0_entry[i]); 7483 pov += 2; 7484 } 7485 } 7486 else 7487 { 7488 // Write standard PLT header. 7489 elfcpp::Swap<32, big_endian>::writeval(pov, 7490 plt0_entry[0] | gotplt_addr_high); 7491 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 7492 plt0_entry[1] | gotplt_addr_low); 7493 elfcpp::Swap<32, big_endian>::writeval(pov + 8, 7494 plt0_entry[2] | gotplt_addr_low); 7495 pov += 12; 7496 for (int i = 3; i < 8; i++) 7497 { 7498 elfcpp::Swap<32, big_endian>::writeval(pov, plt0_entry[i]); 7499 pov += 4; 7500 } 7501 } 7502 7503 7504 unsigned char* gotplt_pov = gotplt_view; 7505 unsigned int got_entry_size = size/8; // TODO(sasa): MIPS_ELF_GOT_SIZE 7506 7507 // The first two entries in .got.plt are reserved. 7508 elfcpp::Swap<size, big_endian>::writeval(gotplt_pov, 0); 7509 elfcpp::Swap<size, big_endian>::writeval(gotplt_pov + got_entry_size, 0); 7510 7511 unsigned int gotplt_offset = 2 * got_entry_size; 7512 gotplt_pov += 2 * got_entry_size; 7513 7514 // Calculate the address of the PLT header. 7515 Mips_address header_address = (plt_address 7516 + (this->is_plt_header_compressed() ? 1 : 0)); 7517 7518 // Initialize compressed PLT area view. 7519 unsigned char* pov2 = pov + this->plt_mips_offset_; 7520 7521 // Write the PLT entries. 7522 for (typename std::vector<Mips_symbol<size>*>::const_iterator 7523 p = this->symbols_.begin(); 7524 p != this->symbols_.end(); 7525 ++p, gotplt_pov += got_entry_size, gotplt_offset += got_entry_size) 7526 { 7527 Mips_symbol<size>* mips_sym = *p; 7528 7529 // Calculate the address of the .got.plt entry. 7530 uint32_t gotplt_entry_addr = (gotplt_addr + gotplt_offset); 7531 uint32_t gotplt_entry_addr_hi = (((gotplt_entry_addr + 0x8000) >> 16) 7532 & 0xffff); 7533 uint32_t gotplt_entry_addr_lo = gotplt_entry_addr & 0xffff; 7534 7535 // Initially point the .got.plt entry at the PLT header. 7536 if (this->target_->is_output_n64()) 7537 elfcpp::Swap<64, big_endian>::writeval(gotplt_pov, header_address); 7538 else 7539 elfcpp::Swap<32, big_endian>::writeval(gotplt_pov, header_address); 7540 7541 // Now handle the PLT itself. First the standard entry. 7542 if (mips_sym->has_mips_plt_offset()) 7543 { 7544 // Pick the load opcode (LW or LD). 7545 uint64_t load = this->target_->is_output_n64() ? 0xdc000000 7546 : 0x8c000000; 7547 7548 const uint32_t* entry = this->target_->is_output_r6() ? plt_entry_r6 7549 : plt_entry; 7550 7551 // Fill in the PLT entry itself. 7552 elfcpp::Swap<32, big_endian>::writeval(pov, 7553 entry[0] | gotplt_entry_addr_hi); 7554 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 7555 entry[1] | gotplt_entry_addr_lo | load); 7556 elfcpp::Swap<32, big_endian>::writeval(pov + 8, entry[2]); 7557 elfcpp::Swap<32, big_endian>::writeval(pov + 12, 7558 entry[3] | gotplt_entry_addr_lo); 7559 pov += 16; 7560 } 7561 7562 // Now the compressed entry. They come after any standard ones. 7563 if (mips_sym->has_comp_plt_offset()) 7564 { 7565 if (!this->target_->is_output_micromips()) 7566 { 7567 // Write MIPS16 PLT entry. 7568 const uint32_t* plt_entry = plt_entry_mips16_o32; 7569 7570 elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]); 7571 elfcpp::Swap<16, big_endian>::writeval(pov2 + 2, plt_entry[1]); 7572 elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]); 7573 elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]); 7574 elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]); 7575 elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]); 7576 elfcpp::Swap<32, big_endian>::writeval(pov2 + 12, 7577 gotplt_entry_addr); 7578 pov2 += 16; 7579 } 7580 else if (this->target_->use_32bit_micromips_instructions()) 7581 { 7582 // Write microMIPS PLT entry in insn32 mode. 7583 const uint32_t* plt_entry = plt_entry_micromips32_o32; 7584 7585 elfcpp::Swap<16, big_endian>::writeval(pov2, plt_entry[0]); 7586 elfcpp::Swap<16, big_endian>::writeval(pov2 + 2, 7587 gotplt_entry_addr_hi); 7588 elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]); 7589 elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, 7590 gotplt_entry_addr_lo); 7591 elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]); 7592 elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]); 7593 elfcpp::Swap<16, big_endian>::writeval(pov2 + 12, plt_entry[6]); 7594 elfcpp::Swap<16, big_endian>::writeval(pov2 + 14, 7595 gotplt_entry_addr_lo); 7596 pov2 += 16; 7597 } 7598 else 7599 { 7600 // Write microMIPS PLT entry. 7601 const uint32_t* plt_entry = plt_entry_micromips_o32; 7602 7603 gold_assert(gotplt_entry_addr % 4 == 0); 7604 7605 Mips_address loc_address = plt_address + pov2 - oview; 7606 int gotpc_offset = gotplt_entry_addr - ((loc_address | 3) ^ 3); 7607 7608 // ADDIUPC has a span of +/-16MB, check we're in range. 7609 if (gotpc_offset + 0x1000000 >= 0x2000000) 7610 { 7611 gold_error(_(".got.plt offset of %ld from .plt beyond the " 7612 "range of ADDIUPC"), (long)gotpc_offset); 7613 return; 7614 } 7615 7616 elfcpp::Swap<16, big_endian>::writeval(pov2, 7617 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f)); 7618 elfcpp::Swap<16, big_endian>::writeval( 7619 pov2 + 2, (gotpc_offset >> 2) & 0xffff); 7620 elfcpp::Swap<16, big_endian>::writeval(pov2 + 4, plt_entry[2]); 7621 elfcpp::Swap<16, big_endian>::writeval(pov2 + 6, plt_entry[3]); 7622 elfcpp::Swap<16, big_endian>::writeval(pov2 + 8, plt_entry[4]); 7623 elfcpp::Swap<16, big_endian>::writeval(pov2 + 10, plt_entry[5]); 7624 pov2 += 12; 7625 } 7626 } 7627 } 7628 7629 // Check the number of bytes written for standard entries. 7630 gold_assert(static_cast<section_size_type>( 7631 pov - oview - this->plt_header_size_) == this->plt_mips_offset_); 7632 // Check the number of bytes written for compressed entries. 7633 gold_assert((static_cast<section_size_type>(pov2 - pov) 7634 == this->plt_comp_offset_)); 7635 // Check the total number of bytes written. 7636 gold_assert(static_cast<section_size_type>(pov2 - oview) == oview_size); 7637 7638 gold_assert(static_cast<section_size_type>(gotplt_pov - gotplt_view) 7639 == gotplt_size); 7640 7641 of->write_output_view(offset, oview_size, oview); 7642 of->write_output_view(gotplt_file_offset, gotplt_size, gotplt_view); 7643} 7644 7645// Mips_output_data_mips_stubs methods. 7646 7647// The format of the lazy binding stub when dynamic symbol count is less than 7648// 64K, dynamic symbol index is less than 32K, and ABI is not N64. 7649template<int size, bool big_endian> 7650const uint32_t 7651Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1[4] = 7652{ 7653 0x8f998010, // lw t9,0x8010(gp) 7654 0x03e07825, // or t7,ra,zero 7655 0x0320f809, // jalr t9,ra 7656 0x24180000 // addiu t8,zero,DYN_INDEX sign extended 7657}; 7658 7659// The format of the lazy binding stub when dynamic symbol count is less than 7660// 64K, dynamic symbol index is less than 32K, and ABI is N64. 7661template<int size, bool big_endian> 7662const uint32_t 7663Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_1_n64[4] = 7664{ 7665 0xdf998010, // ld t9,0x8010(gp) 7666 0x03e07825, // or t7,ra,zero 7667 0x0320f809, // jalr t9,ra 7668 0x64180000 // daddiu t8,zero,DYN_INDEX sign extended 7669}; 7670 7671// The format of the lazy binding stub when dynamic symbol count is less than 7672// 64K, dynamic symbol index is between 32K and 64K, and ABI is not N64. 7673template<int size, bool big_endian> 7674const uint32_t 7675Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2[4] = 7676{ 7677 0x8f998010, // lw t9,0x8010(gp) 7678 0x03e07825, // or t7,ra,zero 7679 0x0320f809, // jalr t9,ra 7680 0x34180000 // ori t8,zero,DYN_INDEX unsigned 7681}; 7682 7683// The format of the lazy binding stub when dynamic symbol count is less than 7684// 64K, dynamic symbol index is between 32K and 64K, and ABI is N64. 7685template<int size, bool big_endian> 7686const uint32_t 7687Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_normal_2_n64[4] = 7688{ 7689 0xdf998010, // ld t9,0x8010(gp) 7690 0x03e07825, // or t7,ra,zero 7691 0x0320f809, // jalr t9,ra 7692 0x34180000 // ori t8,zero,DYN_INDEX unsigned 7693}; 7694 7695// The format of the lazy binding stub when dynamic symbol count is greater than 7696// 64K, and ABI is not N64. 7697template<int size, bool big_endian> 7698const uint32_t Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big[5] = 7699{ 7700 0x8f998010, // lw t9,0x8010(gp) 7701 0x03e07825, // or t7,ra,zero 7702 0x3c180000, // lui t8,DYN_INDEX 7703 0x0320f809, // jalr t9,ra 7704 0x37180000 // ori t8,t8,DYN_INDEX 7705}; 7706 7707// The format of the lazy binding stub when dynamic symbol count is greater than 7708// 64K, and ABI is N64. 7709template<int size, bool big_endian> 7710const uint32_t 7711Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_big_n64[5] = 7712{ 7713 0xdf998010, // ld t9,0x8010(gp) 7714 0x03e07825, // or t7,ra,zero 7715 0x3c180000, // lui t8,DYN_INDEX 7716 0x0320f809, // jalr t9,ra 7717 0x37180000 // ori t8,t8,DYN_INDEX 7718}; 7719 7720// microMIPS stubs. 7721 7722// The format of the microMIPS lazy binding stub when dynamic symbol count is 7723// less than 64K, dynamic symbol index is less than 32K, and ABI is not N64. 7724template<int size, bool big_endian> 7725const uint32_t 7726Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_1[] = 7727{ 7728 0xff3c, 0x8010, // lw t9,0x8010(gp) 7729 0x0dff, // move t7,ra 7730 0x45d9, // jalr t9 7731 0x3300, 0x0000 // addiu t8,zero,DYN_INDEX sign extended 7732}; 7733 7734// The format of the microMIPS lazy binding stub when dynamic symbol count is 7735// less than 64K, dynamic symbol index is less than 32K, and ABI is N64. 7736template<int size, bool big_endian> 7737const uint32_t 7738Mips_output_data_mips_stubs<size, big_endian>:: 7739lazy_stub_micromips_normal_1_n64[] = 7740{ 7741 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7742 0x0dff, // move t7,ra 7743 0x45d9, // jalr t9 7744 0x5f00, 0x0000 // daddiu t8,zero,DYN_INDEX sign extended 7745}; 7746 7747// The format of the microMIPS lazy binding stub when dynamic symbol 7748// count is less than 64K, dynamic symbol index is between 32K and 64K, 7749// and ABI is not N64. 7750template<int size, bool big_endian> 7751const uint32_t 7752Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_normal_2[] = 7753{ 7754 0xff3c, 0x8010, // lw t9,0x8010(gp) 7755 0x0dff, // move t7,ra 7756 0x45d9, // jalr t9 7757 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned 7758}; 7759 7760// The format of the microMIPS lazy binding stub when dynamic symbol 7761// count is less than 64K, dynamic symbol index is between 32K and 64K, 7762// and ABI is N64. 7763template<int size, bool big_endian> 7764const uint32_t 7765Mips_output_data_mips_stubs<size, big_endian>:: 7766lazy_stub_micromips_normal_2_n64[] = 7767{ 7768 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7769 0x0dff, // move t7,ra 7770 0x45d9, // jalr t9 7771 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned 7772}; 7773 7774// The format of the microMIPS lazy binding stub when dynamic symbol count is 7775// greater than 64K, and ABI is not N64. 7776template<int size, bool big_endian> 7777const uint32_t 7778Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big[] = 7779{ 7780 0xff3c, 0x8010, // lw t9,0x8010(gp) 7781 0x0dff, // move t7,ra 7782 0x41b8, 0x0000, // lui t8,DYN_INDEX 7783 0x45d9, // jalr t9 7784 0x5318, 0x0000 // ori t8,t8,DYN_INDEX 7785}; 7786 7787// The format of the microMIPS lazy binding stub when dynamic symbol count is 7788// greater than 64K, and ABI is N64. 7789template<int size, bool big_endian> 7790const uint32_t 7791Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips_big_n64[] = 7792{ 7793 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7794 0x0dff, // move t7,ra 7795 0x41b8, 0x0000, // lui t8,DYN_INDEX 7796 0x45d9, // jalr t9 7797 0x5318, 0x0000 // ori t8,t8,DYN_INDEX 7798}; 7799 7800// 32-bit microMIPS stubs. 7801 7802// The format of the microMIPS lazy binding stub when dynamic symbol count is 7803// less than 64K, dynamic symbol index is less than 32K, ABI is not N64, and we 7804// can use only 32-bit instructions. 7805template<int size, bool big_endian> 7806const uint32_t 7807Mips_output_data_mips_stubs<size, big_endian>:: 7808lazy_stub_micromips32_normal_1[] = 7809{ 7810 0xff3c, 0x8010, // lw t9,0x8010(gp) 7811 0x001f, 0x7a90, // or t7,ra,zero 7812 0x03f9, 0x0f3c, // jalr ra,t9 7813 0x3300, 0x0000 // addiu t8,zero,DYN_INDEX sign extended 7814}; 7815 7816// The format of the microMIPS lazy binding stub when dynamic symbol count is 7817// less than 64K, dynamic symbol index is less than 32K, ABI is N64, and we can 7818// use only 32-bit instructions. 7819template<int size, bool big_endian> 7820const uint32_t 7821Mips_output_data_mips_stubs<size, big_endian>:: 7822lazy_stub_micromips32_normal_1_n64[] = 7823{ 7824 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7825 0x001f, 0x7a90, // or t7,ra,zero 7826 0x03f9, 0x0f3c, // jalr ra,t9 7827 0x5f00, 0x0000 // daddiu t8,zero,DYN_INDEX sign extended 7828}; 7829 7830// The format of the microMIPS lazy binding stub when dynamic symbol 7831// count is less than 64K, dynamic symbol index is between 32K and 64K, 7832// ABI is not N64, and we can use only 32-bit instructions. 7833template<int size, bool big_endian> 7834const uint32_t 7835Mips_output_data_mips_stubs<size, big_endian>:: 7836lazy_stub_micromips32_normal_2[] = 7837{ 7838 0xff3c, 0x8010, // lw t9,0x8010(gp) 7839 0x001f, 0x7a90, // or t7,ra,zero 7840 0x03f9, 0x0f3c, // jalr ra,t9 7841 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned 7842}; 7843 7844// The format of the microMIPS lazy binding stub when dynamic symbol 7845// count is less than 64K, dynamic symbol index is between 32K and 64K, 7846// ABI is N64, and we can use only 32-bit instructions. 7847template<int size, bool big_endian> 7848const uint32_t 7849Mips_output_data_mips_stubs<size, big_endian>:: 7850lazy_stub_micromips32_normal_2_n64[] = 7851{ 7852 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7853 0x001f, 0x7a90, // or t7,ra,zero 7854 0x03f9, 0x0f3c, // jalr ra,t9 7855 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned 7856}; 7857 7858// The format of the microMIPS lazy binding stub when dynamic symbol count is 7859// greater than 64K, ABI is not N64, and we can use only 32-bit instructions. 7860template<int size, bool big_endian> 7861const uint32_t 7862Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big[] = 7863{ 7864 0xff3c, 0x8010, // lw t9,0x8010(gp) 7865 0x001f, 0x7a90, // or t7,ra,zero 7866 0x41b8, 0x0000, // lui t8,DYN_INDEX 7867 0x03f9, 0x0f3c, // jalr ra,t9 7868 0x5318, 0x0000 // ori t8,t8,DYN_INDEX 7869}; 7870 7871// The format of the microMIPS lazy binding stub when dynamic symbol count is 7872// greater than 64K, ABI is N64, and we can use only 32-bit instructions. 7873template<int size, bool big_endian> 7874const uint32_t 7875Mips_output_data_mips_stubs<size, big_endian>::lazy_stub_micromips32_big_n64[] = 7876{ 7877 0xdf3c, 0x8010, // ld t9,0x8010(gp) 7878 0x001f, 0x7a90, // or t7,ra,zero 7879 0x41b8, 0x0000, // lui t8,DYN_INDEX 7880 0x03f9, 0x0f3c, // jalr ra,t9 7881 0x5318, 0x0000 // ori t8,t8,DYN_INDEX 7882}; 7883 7884// Create entry for a symbol. 7885 7886template<int size, bool big_endian> 7887void 7888Mips_output_data_mips_stubs<size, big_endian>::make_entry( 7889 Mips_symbol<size>* gsym) 7890{ 7891 if (!gsym->has_lazy_stub() && !gsym->has_plt_offset()) 7892 { 7893 this->symbols_.insert(gsym); 7894 gsym->set_has_lazy_stub(true); 7895 } 7896} 7897 7898// Remove entry for a symbol. 7899 7900template<int size, bool big_endian> 7901void 7902Mips_output_data_mips_stubs<size, big_endian>::remove_entry( 7903 Mips_symbol<size>* gsym) 7904{ 7905 if (gsym->has_lazy_stub()) 7906 { 7907 this->symbols_.erase(gsym); 7908 gsym->set_has_lazy_stub(false); 7909 } 7910} 7911 7912// Set stub offsets for symbols. This method expects that the number of 7913// entries in dynamic symbol table is set. 7914 7915template<int size, bool big_endian> 7916void 7917Mips_output_data_mips_stubs<size, big_endian>::set_lazy_stub_offsets() 7918{ 7919 gold_assert(this->dynsym_count_ != -1U); 7920 7921 if (this->stub_offsets_are_set_) 7922 return; 7923 7924 unsigned int stub_size = this->stub_size(); 7925 unsigned int offset = 0; 7926 for (typename Mips_stubs_entry_set::const_iterator 7927 p = this->symbols_.begin(); 7928 p != this->symbols_.end(); 7929 ++p, offset += stub_size) 7930 { 7931 Mips_symbol<size>* mips_sym = *p; 7932 mips_sym->set_lazy_stub_offset(offset); 7933 } 7934 this->stub_offsets_are_set_ = true; 7935} 7936 7937template<int size, bool big_endian> 7938void 7939Mips_output_data_mips_stubs<size, big_endian>::set_needs_dynsym_value() 7940{ 7941 for (typename Mips_stubs_entry_set::const_iterator 7942 p = this->symbols_.begin(); p != this->symbols_.end(); ++p) 7943 { 7944 Mips_symbol<size>* sym = *p; 7945 if (sym->is_from_dynobj()) 7946 sym->set_needs_dynsym_value(); 7947 } 7948} 7949 7950// Write out the .MIPS.stubs. This uses the hand-coded instructions and 7951// adjusts them as needed. 7952 7953template<int size, bool big_endian> 7954void 7955Mips_output_data_mips_stubs<size, big_endian>::do_write(Output_file* of) 7956{ 7957 const off_t offset = this->offset(); 7958 const section_size_type oview_size = 7959 convert_to_section_size_type(this->data_size()); 7960 unsigned char* const oview = of->get_output_view(offset, oview_size); 7961 7962 bool big_stub = this->dynsym_count_ > 0x10000; 7963 7964 unsigned char* pov = oview; 7965 for (typename Mips_stubs_entry_set::const_iterator 7966 p = this->symbols_.begin(); p != this->symbols_.end(); ++p) 7967 { 7968 Mips_symbol<size>* sym = *p; 7969 const uint32_t* lazy_stub; 7970 bool n64 = this->target_->is_output_n64(); 7971 7972 if (!this->target_->is_output_micromips()) 7973 { 7974 // Write standard (non-microMIPS) stub. 7975 if (!big_stub) 7976 { 7977 if (sym->dynsym_index() & ~0x7fff) 7978 // Dynsym index is between 32K and 64K. 7979 lazy_stub = n64 ? lazy_stub_normal_2_n64 : lazy_stub_normal_2; 7980 else 7981 // Dynsym index is less than 32K. 7982 lazy_stub = n64 ? lazy_stub_normal_1_n64 : lazy_stub_normal_1; 7983 } 7984 else 7985 lazy_stub = n64 ? lazy_stub_big_n64 : lazy_stub_big; 7986 7987 unsigned int i = 0; 7988 elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]); 7989 elfcpp::Swap<32, big_endian>::writeval(pov + 4, lazy_stub[i + 1]); 7990 pov += 8; 7991 7992 i += 2; 7993 if (big_stub) 7994 { 7995 // LUI instruction of the big stub. Paste high 16 bits of the 7996 // dynsym index. 7997 elfcpp::Swap<32, big_endian>::writeval(pov, 7998 lazy_stub[i] | ((sym->dynsym_index() >> 16) & 0x7fff)); 7999 pov += 4; 8000 i += 1; 8001 } 8002 elfcpp::Swap<32, big_endian>::writeval(pov, lazy_stub[i]); 8003 // Last stub instruction. Paste low 16 bits of the dynsym index. 8004 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 8005 lazy_stub[i + 1] | (sym->dynsym_index() & 0xffff)); 8006 pov += 8; 8007 } 8008 else if (this->target_->use_32bit_micromips_instructions()) 8009 { 8010 // Write microMIPS stub in insn32 mode. 8011 if (!big_stub) 8012 { 8013 if (sym->dynsym_index() & ~0x7fff) 8014 // Dynsym index is between 32K and 64K. 8015 lazy_stub = n64 ? lazy_stub_micromips32_normal_2_n64 8016 : lazy_stub_micromips32_normal_2; 8017 else 8018 // Dynsym index is less than 32K. 8019 lazy_stub = n64 ? lazy_stub_micromips32_normal_1_n64 8020 : lazy_stub_micromips32_normal_1; 8021 } 8022 else 8023 lazy_stub = n64 ? lazy_stub_micromips32_big_n64 8024 : lazy_stub_micromips32_big; 8025 8026 unsigned int i = 0; 8027 // First stub instruction. We emit 32-bit microMIPS instructions by 8028 // emitting two 16-bit parts because on microMIPS the 16-bit part of 8029 // the instruction where the opcode is must always come first, for 8030 // both little and big endian. 8031 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8032 elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]); 8033 // Second stub instruction. 8034 elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]); 8035 elfcpp::Swap<16, big_endian>::writeval(pov + 6, lazy_stub[i + 3]); 8036 pov += 8; 8037 i += 4; 8038 if (big_stub) 8039 { 8040 // LUI instruction of the big stub. Paste high 16 bits of the 8041 // dynsym index. 8042 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8043 elfcpp::Swap<16, big_endian>::writeval(pov + 2, 8044 (sym->dynsym_index() >> 16) & 0x7fff); 8045 pov += 4; 8046 i += 2; 8047 } 8048 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8049 elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]); 8050 // Last stub instruction. Paste low 16 bits of the dynsym index. 8051 elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]); 8052 elfcpp::Swap<16, big_endian>::writeval(pov + 6, 8053 sym->dynsym_index() & 0xffff); 8054 pov += 8; 8055 } 8056 else 8057 { 8058 // Write microMIPS stub. 8059 if (!big_stub) 8060 { 8061 if (sym->dynsym_index() & ~0x7fff) 8062 // Dynsym index is between 32K and 64K. 8063 lazy_stub = n64 ? lazy_stub_micromips_normal_2_n64 8064 : lazy_stub_micromips_normal_2; 8065 else 8066 // Dynsym index is less than 32K. 8067 lazy_stub = n64 ? lazy_stub_micromips_normal_1_n64 8068 : lazy_stub_micromips_normal_1; 8069 } 8070 else 8071 lazy_stub = n64 ? lazy_stub_micromips_big_n64 8072 : lazy_stub_micromips_big; 8073 8074 unsigned int i = 0; 8075 // First stub instruction. We emit 32-bit microMIPS instructions by 8076 // emitting two 16-bit parts because on microMIPS the 16-bit part of 8077 // the instruction where the opcode is must always come first, for 8078 // both little and big endian. 8079 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8080 elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]); 8081 // Second stub instruction. 8082 elfcpp::Swap<16, big_endian>::writeval(pov + 4, lazy_stub[i + 2]); 8083 pov += 6; 8084 i += 3; 8085 if (big_stub) 8086 { 8087 // LUI instruction of the big stub. Paste high 16 bits of the 8088 // dynsym index. 8089 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8090 elfcpp::Swap<16, big_endian>::writeval(pov + 2, 8091 (sym->dynsym_index() >> 16) & 0x7fff); 8092 pov += 4; 8093 i += 2; 8094 } 8095 elfcpp::Swap<16, big_endian>::writeval(pov, lazy_stub[i]); 8096 // Last stub instruction. Paste low 16 bits of the dynsym index. 8097 elfcpp::Swap<16, big_endian>::writeval(pov + 2, lazy_stub[i + 1]); 8098 elfcpp::Swap<16, big_endian>::writeval(pov + 4, 8099 sym->dynsym_index() & 0xffff); 8100 pov += 6; 8101 } 8102 } 8103 8104 // We always allocate 20 bytes for every stub, because final dynsym count is 8105 // not known in method do_finalize_sections. There are 4 unused bytes per 8106 // stub if final dynsym count is less than 0x10000. 8107 unsigned int used = pov - oview; 8108 unsigned int unused = big_stub ? 0 : this->symbols_.size() * 4; 8109 gold_assert(static_cast<section_size_type>(used + unused) == oview_size); 8110 8111 // Fill the unused space with zeroes. 8112 // TODO(sasa): Can we strip unused bytes during the relaxation? 8113 if (unused > 0) 8114 memset(pov, 0, unused); 8115 8116 of->write_output_view(offset, oview_size, oview); 8117} 8118 8119// Mips_output_section_reginfo methods. 8120 8121template<int size, bool big_endian> 8122void 8123Mips_output_section_reginfo<size, big_endian>::do_write(Output_file* of) 8124{ 8125 off_t offset = this->offset(); 8126 off_t data_size = this->data_size(); 8127 8128 unsigned char* view = of->get_output_view(offset, data_size); 8129 elfcpp::Swap<size, big_endian>::writeval(view, this->gprmask_); 8130 elfcpp::Swap<size, big_endian>::writeval(view + 4, this->cprmask1_); 8131 elfcpp::Swap<size, big_endian>::writeval(view + 8, this->cprmask2_); 8132 elfcpp::Swap<size, big_endian>::writeval(view + 12, this->cprmask3_); 8133 elfcpp::Swap<size, big_endian>::writeval(view + 16, this->cprmask4_); 8134 // Write the gp value. 8135 elfcpp::Swap<size, big_endian>::writeval(view + 20, 8136 this->target_->gp_value()); 8137 8138 of->write_output_view(offset, data_size, view); 8139} 8140 8141// Mips_output_section_abiflags methods. 8142 8143template<int size, bool big_endian> 8144void 8145Mips_output_section_abiflags<size, big_endian>::do_write(Output_file* of) 8146{ 8147 off_t offset = this->offset(); 8148 off_t data_size = this->data_size(); 8149 8150 unsigned char* view = of->get_output_view(offset, data_size); 8151 elfcpp::Swap<16, big_endian>::writeval(view, this->abiflags_.version); 8152 elfcpp::Swap<8, big_endian>::writeval(view + 2, this->abiflags_.isa_level); 8153 elfcpp::Swap<8, big_endian>::writeval(view + 3, this->abiflags_.isa_rev); 8154 elfcpp::Swap<8, big_endian>::writeval(view + 4, this->abiflags_.gpr_size); 8155 elfcpp::Swap<8, big_endian>::writeval(view + 5, this->abiflags_.cpr1_size); 8156 elfcpp::Swap<8, big_endian>::writeval(view + 6, this->abiflags_.cpr2_size); 8157 elfcpp::Swap<8, big_endian>::writeval(view + 7, this->abiflags_.fp_abi); 8158 elfcpp::Swap<32, big_endian>::writeval(view + 8, this->abiflags_.isa_ext); 8159 elfcpp::Swap<32, big_endian>::writeval(view + 12, this->abiflags_.ases); 8160 elfcpp::Swap<32, big_endian>::writeval(view + 16, this->abiflags_.flags1); 8161 elfcpp::Swap<32, big_endian>::writeval(view + 20, this->abiflags_.flags2); 8162 8163 of->write_output_view(offset, data_size, view); 8164} 8165 8166// Mips_copy_relocs methods. 8167 8168// Emit any saved relocs. 8169 8170template<int sh_type, int size, bool big_endian> 8171void 8172Mips_copy_relocs<sh_type, size, big_endian>::emit_mips( 8173 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section, 8174 Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target) 8175{ 8176 for (typename Copy_relocs<sh_type, size, big_endian>:: 8177 Copy_reloc_entries::iterator p = this->entries_.begin(); 8178 p != this->entries_.end(); 8179 ++p) 8180 emit_entry(*p, reloc_section, symtab, layout, target); 8181 8182 // We no longer need the saved information. 8183 this->entries_.clear(); 8184} 8185 8186// Emit the reloc if appropriate. 8187 8188template<int sh_type, int size, bool big_endian> 8189void 8190Mips_copy_relocs<sh_type, size, big_endian>::emit_entry( 8191 Copy_reloc_entry& entry, 8192 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section, 8193 Symbol_table* symtab, Layout* layout, Target_mips<size, big_endian>* target) 8194{ 8195 // If the symbol is no longer defined in a dynamic object, then we 8196 // emitted a COPY relocation, and we do not want to emit this 8197 // dynamic relocation. 8198 if (!entry.sym_->is_from_dynobj()) 8199 return; 8200 8201 bool can_make_dynamic = (entry.reloc_type_ == elfcpp::R_MIPS_32 8202 || entry.reloc_type_ == elfcpp::R_MIPS_REL32 8203 || entry.reloc_type_ == elfcpp::R_MIPS_64); 8204 8205 Mips_symbol<size>* sym = Mips_symbol<size>::as_mips_sym(entry.sym_); 8206 if (can_make_dynamic && !sym->has_static_relocs()) 8207 { 8208 Mips_relobj<size, big_endian>* object = 8209 Mips_relobj<size, big_endian>::as_mips_relobj(entry.relobj_); 8210 target->got_section(symtab, layout)->record_global_got_symbol( 8211 sym, object, entry.reloc_type_, true, false); 8212 if (!symbol_references_local(sym, sym->should_add_dynsym_entry(symtab))) 8213 target->rel_dyn_section(layout)->add_global(sym, elfcpp::R_MIPS_REL32, 8214 entry.output_section_, entry.relobj_, entry.shndx_, entry.address_); 8215 else 8216 target->rel_dyn_section(layout)->add_symbolless_global_addend( 8217 sym, elfcpp::R_MIPS_REL32, entry.output_section_, entry.relobj_, 8218 entry.shndx_, entry.address_); 8219 } 8220 else 8221 this->make_copy_reloc(symtab, layout, 8222 static_cast<Sized_symbol<size>*>(entry.sym_), 8223 entry.relobj_, 8224 reloc_section); 8225} 8226 8227// Target_mips methods. 8228 8229// Return the value to use for a dynamic symbol which requires special 8230// treatment. This is how we support equality comparisons of function 8231// pointers across shared library boundaries, as described in the 8232// processor specific ABI supplement. 8233 8234template<int size, bool big_endian> 8235uint64_t 8236Target_mips<size, big_endian>::do_dynsym_value(const Symbol* gsym) const 8237{ 8238 uint64_t value = 0; 8239 const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym); 8240 8241 if (!mips_sym->has_lazy_stub()) 8242 { 8243 if (mips_sym->has_plt_offset()) 8244 { 8245 // We distinguish between PLT entries and lazy-binding stubs by 8246 // giving the former an st_other value of STO_MIPS_PLT. Set the 8247 // value to the stub address if there are any relocations in the 8248 // binary where pointer equality matters. 8249 if (mips_sym->pointer_equality_needed()) 8250 { 8251 // Prefer a standard MIPS PLT entry. 8252 if (mips_sym->has_mips_plt_offset()) 8253 value = this->plt_section()->mips_entry_address(mips_sym); 8254 else 8255 value = this->plt_section()->comp_entry_address(mips_sym) + 1; 8256 } 8257 else 8258 value = 0; 8259 } 8260 } 8261 else 8262 { 8263 // First, set stub offsets for symbols. This method expects that the 8264 // number of entries in dynamic symbol table is set. 8265 this->mips_stubs_section()->set_lazy_stub_offsets(); 8266 8267 // The run-time linker uses the st_value field of the symbol 8268 // to reset the global offset table entry for this external 8269 // to its stub address when unlinking a shared object. 8270 value = this->mips_stubs_section()->stub_address(mips_sym); 8271 } 8272 8273 if (mips_sym->has_mips16_fn_stub()) 8274 { 8275 // If we have a MIPS16 function with a stub, the dynamic symbol must 8276 // refer to the stub, since only the stub uses the standard calling 8277 // conventions. 8278 value = mips_sym->template 8279 get_mips16_fn_stub<big_endian>()->output_address(); 8280 } 8281 8282 return value; 8283} 8284 8285// Get the dynamic reloc section, creating it if necessary. It's always 8286// .rel.dyn, even for MIPS64. 8287 8288template<int size, bool big_endian> 8289typename Target_mips<size, big_endian>::Reloc_section* 8290Target_mips<size, big_endian>::rel_dyn_section(Layout* layout) 8291{ 8292 if (this->rel_dyn_ == NULL) 8293 { 8294 gold_assert(layout != NULL); 8295 this->rel_dyn_ = new Reloc_section(parameters->options().combreloc()); 8296 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL, 8297 elfcpp::SHF_ALLOC, this->rel_dyn_, 8298 ORDER_DYNAMIC_RELOCS, false); 8299 8300 // First entry in .rel.dyn has to be null. 8301 // This is hack - we define dummy output data and set its address to 0, 8302 // and define absolute R_MIPS_NONE relocation with offset 0 against it. 8303 // This ensures that the entry is null. 8304 Output_data* od = new Output_data_zero_fill(0, 0); 8305 od->set_address(0); 8306 this->rel_dyn_->add_absolute(elfcpp::R_MIPS_NONE, od, 0); 8307 } 8308 return this->rel_dyn_; 8309} 8310 8311// Get the GOT section, creating it if necessary. 8312 8313template<int size, bool big_endian> 8314Mips_output_data_got<size, big_endian>* 8315Target_mips<size, big_endian>::got_section(Symbol_table* symtab, 8316 Layout* layout) 8317{ 8318 if (this->got_ == NULL) 8319 { 8320 gold_assert(symtab != NULL && layout != NULL); 8321 8322 this->got_ = new Mips_output_data_got<size, big_endian>(this, symtab, 8323 layout); 8324 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, 8325 (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE | 8326 elfcpp::SHF_MIPS_GPREL), 8327 this->got_, ORDER_DATA, false); 8328 8329 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section. 8330 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL, 8331 Symbol_table::PREDEFINED, 8332 this->got_, 8333 0, 0, elfcpp::STT_OBJECT, 8334 elfcpp::STB_GLOBAL, 8335 elfcpp::STV_DEFAULT, 0, 8336 false, false); 8337 } 8338 8339 return this->got_; 8340} 8341 8342// Calculate value of _gp symbol. 8343 8344template<int size, bool big_endian> 8345void 8346Target_mips<size, big_endian>::set_gp(Layout* layout, Symbol_table* symtab) 8347{ 8348 if (this->gp_ != NULL) 8349 return; 8350 8351 Output_data* section = layout->find_output_section(".got"); 8352 if (section == NULL) 8353 { 8354 // If there is no .got section, gp should be based on .sdata. 8355 // TODO(sasa): This is probably not needed. This was needed for older 8356 // MIPS architectures which accessed both GOT and .sdata section using 8357 // gp-relative addressing. Modern Mips Linux ELF architectures don't 8358 // access .sdata using gp-relative addressing. 8359 for (Layout::Section_list::const_iterator 8360 p = layout->section_list().begin(); 8361 p != layout->section_list().end(); 8362 ++p) 8363 { 8364 if (strcmp((*p)->name(), ".sdata") == 0) 8365 { 8366 section = *p; 8367 break; 8368 } 8369 } 8370 } 8371 8372 Sized_symbol<size>* gp = 8373 static_cast<Sized_symbol<size>*>(symtab->lookup("_gp")); 8374 if (gp != NULL) 8375 { 8376 if (gp->source() != Symbol::IS_CONSTANT && section != NULL) 8377 gp->init_output_data(gp->name(), NULL, section, MIPS_GP_OFFSET, 0, 8378 elfcpp::STT_OBJECT, 8379 elfcpp::STB_GLOBAL, 8380 elfcpp::STV_DEFAULT, 0, 8381 false, false); 8382 this->gp_ = gp; 8383 } 8384 else if (section != NULL) 8385 { 8386 gp = static_cast<Sized_symbol<size>*>(symtab->define_in_output_data( 8387 "_gp", NULL, Symbol_table::PREDEFINED, 8388 section, MIPS_GP_OFFSET, 0, 8389 elfcpp::STT_OBJECT, 8390 elfcpp::STB_GLOBAL, 8391 elfcpp::STV_DEFAULT, 8392 0, false, false)); 8393 this->gp_ = gp; 8394 } 8395} 8396 8397// Set the dynamic symbol indexes. INDEX is the index of the first 8398// global dynamic symbol. Pointers to the symbols are stored into the 8399// vector SYMS. The names are added to DYNPOOL. This returns an 8400// updated dynamic symbol index. 8401 8402template<int size, bool big_endian> 8403unsigned int 8404Target_mips<size, big_endian>::do_set_dynsym_indexes( 8405 std::vector<Symbol*>* dyn_symbols, unsigned int index, 8406 std::vector<Symbol*>* syms, Stringpool* dynpool, 8407 Versions* versions, Symbol_table* symtab) const 8408{ 8409 std::vector<Symbol*> non_got_symbols; 8410 std::vector<Symbol*> got_symbols; 8411 8412 reorder_dyn_symbols<size, big_endian>(dyn_symbols, &non_got_symbols, 8413 &got_symbols); 8414 8415 for (std::vector<Symbol*>::iterator p = non_got_symbols.begin(); 8416 p != non_got_symbols.end(); 8417 ++p) 8418 { 8419 Symbol* sym = *p; 8420 8421 // Note that SYM may already have a dynamic symbol index, since 8422 // some symbols appear more than once in the symbol table, with 8423 // and without a version. 8424 8425 if (!sym->has_dynsym_index()) 8426 { 8427 sym->set_dynsym_index(index); 8428 ++index; 8429 syms->push_back(sym); 8430 dynpool->add(sym->name(), false, NULL); 8431 8432 // Record any version information. 8433 if (sym->version() != NULL) 8434 versions->record_version(symtab, dynpool, sym); 8435 8436 // If the symbol is defined in a dynamic object and is 8437 // referenced in a regular object, then mark the dynamic 8438 // object as needed. This is used to implement --as-needed. 8439 if (sym->is_from_dynobj() && sym->in_reg()) 8440 sym->object()->set_is_needed(); 8441 } 8442 } 8443 8444 for (std::vector<Symbol*>::iterator p = got_symbols.begin(); 8445 p != got_symbols.end(); 8446 ++p) 8447 { 8448 Symbol* sym = *p; 8449 if (!sym->has_dynsym_index()) 8450 { 8451 // Record any version information. 8452 if (sym->version() != NULL) 8453 versions->record_version(symtab, dynpool, sym); 8454 } 8455 } 8456 8457 index = versions->finalize(symtab, index, syms); 8458 8459 int got_sym_count = 0; 8460 for (std::vector<Symbol*>::iterator p = got_symbols.begin(); 8461 p != got_symbols.end(); 8462 ++p) 8463 { 8464 Symbol* sym = *p; 8465 8466 if (!sym->has_dynsym_index()) 8467 { 8468 ++got_sym_count; 8469 sym->set_dynsym_index(index); 8470 ++index; 8471 syms->push_back(sym); 8472 dynpool->add(sym->name(), false, NULL); 8473 8474 // If the symbol is defined in a dynamic object and is 8475 // referenced in a regular object, then mark the dynamic 8476 // object as needed. This is used to implement --as-needed. 8477 if (sym->is_from_dynobj() && sym->in_reg()) 8478 sym->object()->set_is_needed(); 8479 } 8480 } 8481 8482 // Set index of the first symbol that has .got entry. 8483 this->got_->set_first_global_got_dynsym_index( 8484 got_sym_count > 0 ? index - got_sym_count : -1U); 8485 8486 if (this->mips_stubs_ != NULL) 8487 this->mips_stubs_->set_dynsym_count(index); 8488 8489 return index; 8490} 8491 8492// Create a PLT entry for a global symbol referenced by r_type relocation. 8493 8494template<int size, bool big_endian> 8495void 8496Target_mips<size, big_endian>::make_plt_entry(Symbol_table* symtab, 8497 Layout* layout, 8498 Mips_symbol<size>* gsym, 8499 unsigned int r_type) 8500{ 8501 if (gsym->has_lazy_stub() || gsym->has_plt_offset()) 8502 return; 8503 8504 if (this->plt_ == NULL) 8505 { 8506 // Create the GOT section first. 8507 this->got_section(symtab, layout); 8508 8509 this->got_plt_ = new Output_data_space(4, "** GOT PLT"); 8510 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS, 8511 (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE), 8512 this->got_plt_, ORDER_DATA, false); 8513 8514 // The first two entries are reserved. 8515 this->got_plt_->set_current_data_size(2 * size/8); 8516 8517 this->plt_ = new Mips_output_data_plt<size, big_endian>(layout, 8518 this->got_plt_, 8519 this); 8520 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, 8521 (elfcpp::SHF_ALLOC 8522 | elfcpp::SHF_EXECINSTR), 8523 this->plt_, ORDER_PLT, false); 8524 8525 // Make the sh_info field of .rel.plt point to .plt. 8526 Output_section* rel_plt_os = this->plt_->rel_plt()->output_section(); 8527 rel_plt_os->set_info_section(this->plt_->output_section()); 8528 } 8529 8530 this->plt_->add_entry(gsym, r_type); 8531} 8532 8533 8534// Get the .MIPS.stubs section, creating it if necessary. 8535 8536template<int size, bool big_endian> 8537Mips_output_data_mips_stubs<size, big_endian>* 8538Target_mips<size, big_endian>::mips_stubs_section(Layout* layout) 8539{ 8540 if (this->mips_stubs_ == NULL) 8541 { 8542 this->mips_stubs_ = 8543 new Mips_output_data_mips_stubs<size, big_endian>(this); 8544 layout->add_output_section_data(".MIPS.stubs", elfcpp::SHT_PROGBITS, 8545 (elfcpp::SHF_ALLOC 8546 | elfcpp::SHF_EXECINSTR), 8547 this->mips_stubs_, ORDER_PLT, false); 8548 } 8549 return this->mips_stubs_; 8550} 8551 8552// Get the LA25 stub section, creating it if necessary. 8553 8554template<int size, bool big_endian> 8555Mips_output_data_la25_stub<size, big_endian>* 8556Target_mips<size, big_endian>::la25_stub_section(Layout* layout) 8557{ 8558 if (this->la25_stub_ == NULL) 8559 { 8560 this->la25_stub_ = new Mips_output_data_la25_stub<size, big_endian>(); 8561 layout->add_output_section_data(".text", elfcpp::SHT_PROGBITS, 8562 (elfcpp::SHF_ALLOC 8563 | elfcpp::SHF_EXECINSTR), 8564 this->la25_stub_, ORDER_TEXT, false); 8565 } 8566 return this->la25_stub_; 8567} 8568 8569// Process the relocations to determine unreferenced sections for 8570// garbage collection. 8571 8572template<int size, bool big_endian> 8573void 8574Target_mips<size, big_endian>::gc_process_relocs( 8575 Symbol_table* symtab, 8576 Layout* layout, 8577 Sized_relobj_file<size, big_endian>* object, 8578 unsigned int data_shndx, 8579 unsigned int sh_type, 8580 const unsigned char* prelocs, 8581 size_t reloc_count, 8582 Output_section* output_section, 8583 bool needs_special_offset_handling, 8584 size_t local_symbol_count, 8585 const unsigned char* plocal_symbols) 8586{ 8587 typedef Target_mips<size, big_endian> Mips; 8588 8589 if (sh_type == elfcpp::SHT_REL) 8590 { 8591 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 8592 Classify_reloc; 8593 8594 gold::gc_process_relocs<size, big_endian, Mips, Scan, Classify_reloc>( 8595 symtab, 8596 layout, 8597 this, 8598 object, 8599 data_shndx, 8600 prelocs, 8601 reloc_count, 8602 output_section, 8603 needs_special_offset_handling, 8604 local_symbol_count, 8605 plocal_symbols); 8606 } 8607 else if (sh_type == elfcpp::SHT_RELA) 8608 { 8609 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 8610 Classify_reloc; 8611 8612 gold::gc_process_relocs<size, big_endian, Mips, Scan, Classify_reloc>( 8613 symtab, 8614 layout, 8615 this, 8616 object, 8617 data_shndx, 8618 prelocs, 8619 reloc_count, 8620 output_section, 8621 needs_special_offset_handling, 8622 local_symbol_count, 8623 plocal_symbols); 8624 } 8625 else 8626 gold_unreachable(); 8627} 8628 8629// Scan relocations for a section. 8630 8631template<int size, bool big_endian> 8632void 8633Target_mips<size, big_endian>::scan_relocs( 8634 Symbol_table* symtab, 8635 Layout* layout, 8636 Sized_relobj_file<size, big_endian>* object, 8637 unsigned int data_shndx, 8638 unsigned int sh_type, 8639 const unsigned char* prelocs, 8640 size_t reloc_count, 8641 Output_section* output_section, 8642 bool needs_special_offset_handling, 8643 size_t local_symbol_count, 8644 const unsigned char* plocal_symbols) 8645{ 8646 typedef Target_mips<size, big_endian> Mips; 8647 8648 if (sh_type == elfcpp::SHT_REL) 8649 { 8650 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 8651 Classify_reloc; 8652 8653 gold::scan_relocs<size, big_endian, Mips, Scan, Classify_reloc>( 8654 symtab, 8655 layout, 8656 this, 8657 object, 8658 data_shndx, 8659 prelocs, 8660 reloc_count, 8661 output_section, 8662 needs_special_offset_handling, 8663 local_symbol_count, 8664 plocal_symbols); 8665 } 8666 else if (sh_type == elfcpp::SHT_RELA) 8667 { 8668 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 8669 Classify_reloc; 8670 8671 gold::scan_relocs<size, big_endian, Mips, Scan, Classify_reloc>( 8672 symtab, 8673 layout, 8674 this, 8675 object, 8676 data_shndx, 8677 prelocs, 8678 reloc_count, 8679 output_section, 8680 needs_special_offset_handling, 8681 local_symbol_count, 8682 plocal_symbols); 8683 } 8684} 8685 8686template<int size, bool big_endian> 8687bool 8688Target_mips<size, big_endian>::mips_32bit_flags(elfcpp::Elf_Word flags) 8689{ 8690 return ((flags & elfcpp::EF_MIPS_32BITMODE) != 0 8691 || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_O32 8692 || (flags & elfcpp::EF_MIPS_ABI) == elfcpp::E_MIPS_ABI_EABI32 8693 || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_1 8694 || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_2 8695 || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32 8696 || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32R2 8697 || (flags & elfcpp::EF_MIPS_ARCH) == elfcpp::E_MIPS_ARCH_32R6); 8698} 8699 8700// Return the MACH for a MIPS e_flags value. 8701template<int size, bool big_endian> 8702unsigned int 8703Target_mips<size, big_endian>::elf_mips_mach(elfcpp::Elf_Word flags) 8704{ 8705 switch (flags & elfcpp::EF_MIPS_MACH) 8706 { 8707 case elfcpp::E_MIPS_MACH_3900: 8708 return mach_mips3900; 8709 8710 case elfcpp::E_MIPS_MACH_4010: 8711 return mach_mips4010; 8712 8713 case elfcpp::E_MIPS_MACH_4100: 8714 return mach_mips4100; 8715 8716 case elfcpp::E_MIPS_MACH_4111: 8717 return mach_mips4111; 8718 8719 case elfcpp::E_MIPS_MACH_4120: 8720 return mach_mips4120; 8721 8722 case elfcpp::E_MIPS_MACH_4650: 8723 return mach_mips4650; 8724 8725 case elfcpp::E_MIPS_MACH_5400: 8726 return mach_mips5400; 8727 8728 case elfcpp::E_MIPS_MACH_5500: 8729 return mach_mips5500; 8730 8731 case elfcpp::E_MIPS_MACH_5900: 8732 return mach_mips5900; 8733 8734 case elfcpp::E_MIPS_MACH_9000: 8735 return mach_mips9000; 8736 8737 case elfcpp::E_MIPS_MACH_SB1: 8738 return mach_mips_sb1; 8739 8740 case elfcpp::E_MIPS_MACH_LS2E: 8741 return mach_mips_loongson_2e; 8742 8743 case elfcpp::E_MIPS_MACH_LS2F: 8744 return mach_mips_loongson_2f; 8745 8746 case elfcpp::E_MIPS_MACH_LS3A: 8747 return mach_mips_loongson_3a; 8748 8749 case elfcpp::E_MIPS_MACH_OCTEON3: 8750 return mach_mips_octeon3; 8751 8752 case elfcpp::E_MIPS_MACH_OCTEON2: 8753 return mach_mips_octeon2; 8754 8755 case elfcpp::E_MIPS_MACH_OCTEON: 8756 return mach_mips_octeon; 8757 8758 case elfcpp::E_MIPS_MACH_XLR: 8759 return mach_mips_xlr; 8760 8761 default: 8762 switch (flags & elfcpp::EF_MIPS_ARCH) 8763 { 8764 default: 8765 case elfcpp::E_MIPS_ARCH_1: 8766 return mach_mips3000; 8767 8768 case elfcpp::E_MIPS_ARCH_2: 8769 return mach_mips6000; 8770 8771 case elfcpp::E_MIPS_ARCH_3: 8772 return mach_mips4000; 8773 8774 case elfcpp::E_MIPS_ARCH_4: 8775 return mach_mips8000; 8776 8777 case elfcpp::E_MIPS_ARCH_5: 8778 return mach_mips5; 8779 8780 case elfcpp::E_MIPS_ARCH_32: 8781 return mach_mipsisa32; 8782 8783 case elfcpp::E_MIPS_ARCH_64: 8784 return mach_mipsisa64; 8785 8786 case elfcpp::E_MIPS_ARCH_32R2: 8787 return mach_mipsisa32r2; 8788 8789 case elfcpp::E_MIPS_ARCH_32R6: 8790 return mach_mipsisa32r6; 8791 8792 case elfcpp::E_MIPS_ARCH_64R2: 8793 return mach_mipsisa64r2; 8794 8795 case elfcpp::E_MIPS_ARCH_64R6: 8796 return mach_mipsisa64r6; 8797 } 8798 } 8799 8800 return 0; 8801} 8802 8803// Return the MACH for each .MIPS.abiflags ISA Extension. 8804 8805template<int size, bool big_endian> 8806unsigned int 8807Target_mips<size, big_endian>::mips_isa_ext_mach(unsigned int isa_ext) 8808{ 8809 switch (isa_ext) 8810 { 8811 case elfcpp::AFL_EXT_3900: 8812 return mach_mips3900; 8813 8814 case elfcpp::AFL_EXT_4010: 8815 return mach_mips4010; 8816 8817 case elfcpp::AFL_EXT_4100: 8818 return mach_mips4100; 8819 8820 case elfcpp::AFL_EXT_4111: 8821 return mach_mips4111; 8822 8823 case elfcpp::AFL_EXT_4120: 8824 return mach_mips4120; 8825 8826 case elfcpp::AFL_EXT_4650: 8827 return mach_mips4650; 8828 8829 case elfcpp::AFL_EXT_5400: 8830 return mach_mips5400; 8831 8832 case elfcpp::AFL_EXT_5500: 8833 return mach_mips5500; 8834 8835 case elfcpp::AFL_EXT_5900: 8836 return mach_mips5900; 8837 8838 case elfcpp::AFL_EXT_10000: 8839 return mach_mips10000; 8840 8841 case elfcpp::AFL_EXT_LOONGSON_2E: 8842 return mach_mips_loongson_2e; 8843 8844 case elfcpp::AFL_EXT_LOONGSON_2F: 8845 return mach_mips_loongson_2f; 8846 8847 case elfcpp::AFL_EXT_LOONGSON_3A: 8848 return mach_mips_loongson_3a; 8849 8850 case elfcpp::AFL_EXT_SB1: 8851 return mach_mips_sb1; 8852 8853 case elfcpp::AFL_EXT_OCTEON: 8854 return mach_mips_octeon; 8855 8856 case elfcpp::AFL_EXT_OCTEONP: 8857 return mach_mips_octeonp; 8858 8859 case elfcpp::AFL_EXT_OCTEON2: 8860 return mach_mips_octeon2; 8861 8862 case elfcpp::AFL_EXT_XLR: 8863 return mach_mips_xlr; 8864 8865 default: 8866 return mach_mips3000; 8867 } 8868} 8869 8870// Return the .MIPS.abiflags value representing each ISA Extension. 8871 8872template<int size, bool big_endian> 8873unsigned int 8874Target_mips<size, big_endian>::mips_isa_ext(unsigned int mips_mach) 8875{ 8876 switch (mips_mach) 8877 { 8878 case mach_mips3900: 8879 return elfcpp::AFL_EXT_3900; 8880 8881 case mach_mips4010: 8882 return elfcpp::AFL_EXT_4010; 8883 8884 case mach_mips4100: 8885 return elfcpp::AFL_EXT_4100; 8886 8887 case mach_mips4111: 8888 return elfcpp::AFL_EXT_4111; 8889 8890 case mach_mips4120: 8891 return elfcpp::AFL_EXT_4120; 8892 8893 case mach_mips4650: 8894 return elfcpp::AFL_EXT_4650; 8895 8896 case mach_mips5400: 8897 return elfcpp::AFL_EXT_5400; 8898 8899 case mach_mips5500: 8900 return elfcpp::AFL_EXT_5500; 8901 8902 case mach_mips5900: 8903 return elfcpp::AFL_EXT_5900; 8904 8905 case mach_mips10000: 8906 return elfcpp::AFL_EXT_10000; 8907 8908 case mach_mips_loongson_2e: 8909 return elfcpp::AFL_EXT_LOONGSON_2E; 8910 8911 case mach_mips_loongson_2f: 8912 return elfcpp::AFL_EXT_LOONGSON_2F; 8913 8914 case mach_mips_loongson_3a: 8915 return elfcpp::AFL_EXT_LOONGSON_3A; 8916 8917 case mach_mips_sb1: 8918 return elfcpp::AFL_EXT_SB1; 8919 8920 case mach_mips_octeon: 8921 return elfcpp::AFL_EXT_OCTEON; 8922 8923 case mach_mips_octeonp: 8924 return elfcpp::AFL_EXT_OCTEONP; 8925 8926 case mach_mips_octeon3: 8927 return elfcpp::AFL_EXT_OCTEON3; 8928 8929 case mach_mips_octeon2: 8930 return elfcpp::AFL_EXT_OCTEON2; 8931 8932 case mach_mips_xlr: 8933 return elfcpp::AFL_EXT_XLR; 8934 8935 default: 8936 return 0; 8937 } 8938} 8939 8940// Update the isa_level, isa_rev, isa_ext fields of abiflags. 8941 8942template<int size, bool big_endian> 8943void 8944Target_mips<size, big_endian>::update_abiflags_isa(const std::string& name, 8945 elfcpp::Elf_Word e_flags, Mips_abiflags<big_endian>* abiflags) 8946{ 8947 int new_isa = 0; 8948 switch (e_flags & elfcpp::EF_MIPS_ARCH) 8949 { 8950 case elfcpp::E_MIPS_ARCH_1: 8951 new_isa = this->level_rev(1, 0); 8952 break; 8953 case elfcpp::E_MIPS_ARCH_2: 8954 new_isa = this->level_rev(2, 0); 8955 break; 8956 case elfcpp::E_MIPS_ARCH_3: 8957 new_isa = this->level_rev(3, 0); 8958 break; 8959 case elfcpp::E_MIPS_ARCH_4: 8960 new_isa = this->level_rev(4, 0); 8961 break; 8962 case elfcpp::E_MIPS_ARCH_5: 8963 new_isa = this->level_rev(5, 0); 8964 break; 8965 case elfcpp::E_MIPS_ARCH_32: 8966 new_isa = this->level_rev(32, 1); 8967 break; 8968 case elfcpp::E_MIPS_ARCH_32R2: 8969 new_isa = this->level_rev(32, 2); 8970 break; 8971 case elfcpp::E_MIPS_ARCH_32R6: 8972 new_isa = this->level_rev(32, 6); 8973 break; 8974 case elfcpp::E_MIPS_ARCH_64: 8975 new_isa = this->level_rev(64, 1); 8976 break; 8977 case elfcpp::E_MIPS_ARCH_64R2: 8978 new_isa = this->level_rev(64, 2); 8979 break; 8980 case elfcpp::E_MIPS_ARCH_64R6: 8981 new_isa = this->level_rev(64, 6); 8982 break; 8983 default: 8984 gold_error(_("%s: Unknown architecture %s"), name.c_str(), 8985 this->elf_mips_mach_name(e_flags)); 8986 } 8987 8988 if (new_isa > this->level_rev(abiflags->isa_level, abiflags->isa_rev)) 8989 { 8990 // Decode a single value into level and revision. 8991 abiflags->isa_level = new_isa >> 3; 8992 abiflags->isa_rev = new_isa & 0x7; 8993 } 8994 8995 // Update the isa_ext if needed. 8996 if (this->mips_mach_extends(this->mips_isa_ext_mach(abiflags->isa_ext), 8997 this->elf_mips_mach(e_flags))) 8998 abiflags->isa_ext = this->mips_isa_ext(this->elf_mips_mach(e_flags)); 8999} 9000 9001// Infer the content of the ABI flags based on the elf header. 9002 9003template<int size, bool big_endian> 9004void 9005Target_mips<size, big_endian>::infer_abiflags( 9006 Mips_relobj<size, big_endian>* relobj, Mips_abiflags<big_endian>* abiflags) 9007{ 9008 const Attributes_section_data* pasd = relobj->attributes_section_data(); 9009 int attr_fp_abi = elfcpp::Val_GNU_MIPS_ABI_FP_ANY; 9010 elfcpp::Elf_Word e_flags = relobj->processor_specific_flags(); 9011 9012 this->update_abiflags_isa(relobj->name(), e_flags, abiflags); 9013 if (pasd != NULL) 9014 { 9015 // Read fp_abi from the .gnu.attribute section. 9016 const Object_attribute* attr = 9017 pasd->known_attributes(Object_attribute::OBJ_ATTR_GNU); 9018 attr_fp_abi = attr[elfcpp::Tag_GNU_MIPS_ABI_FP].int_value(); 9019 } 9020 9021 abiflags->fp_abi = attr_fp_abi; 9022 abiflags->cpr1_size = elfcpp::AFL_REG_NONE; 9023 abiflags->cpr2_size = elfcpp::AFL_REG_NONE; 9024 abiflags->gpr_size = this->mips_32bit_flags(e_flags) ? elfcpp::AFL_REG_32 9025 : elfcpp::AFL_REG_64; 9026 9027 if (abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_SINGLE 9028 || abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_XX 9029 || (abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE 9030 && abiflags->gpr_size == elfcpp::AFL_REG_32)) 9031 abiflags->cpr1_size = elfcpp::AFL_REG_32; 9032 else if (abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE 9033 || abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_64 9034 || abiflags->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_64A) 9035 abiflags->cpr1_size = elfcpp::AFL_REG_64; 9036 9037 if (e_flags & elfcpp::EF_MIPS_ARCH_ASE_MDMX) 9038 abiflags->ases |= elfcpp::AFL_ASE_MDMX; 9039 if (e_flags & elfcpp::EF_MIPS_ARCH_ASE_M16) 9040 abiflags->ases |= elfcpp::AFL_ASE_MIPS16; 9041 if (e_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS) 9042 abiflags->ases |= elfcpp::AFL_ASE_MICROMIPS; 9043 9044 if (abiflags->fp_abi != elfcpp::Val_GNU_MIPS_ABI_FP_ANY 9045 && abiflags->fp_abi != elfcpp::Val_GNU_MIPS_ABI_FP_SOFT 9046 && abiflags->fp_abi != elfcpp::Val_GNU_MIPS_ABI_FP_64A 9047 && abiflags->isa_level >= 32 9048 && abiflags->isa_ext != elfcpp::AFL_EXT_LOONGSON_3A) 9049 abiflags->flags1 |= elfcpp::AFL_FLAGS1_ODDSPREG; 9050} 9051 9052// Create abiflags from elf header or from .MIPS.abiflags section. 9053 9054template<int size, bool big_endian> 9055void 9056Target_mips<size, big_endian>::create_abiflags( 9057 Mips_relobj<size, big_endian>* relobj, 9058 Mips_abiflags<big_endian>* abiflags) 9059{ 9060 Mips_abiflags<big_endian>* sec_abiflags = relobj->abiflags(); 9061 Mips_abiflags<big_endian> header_abiflags; 9062 9063 this->infer_abiflags(relobj, &header_abiflags); 9064 9065 if (sec_abiflags == NULL) 9066 { 9067 // If there is no input .MIPS.abiflags section, use abiflags created 9068 // from elf header. 9069 *abiflags = header_abiflags; 9070 return; 9071 } 9072 9073 this->has_abiflags_section_ = true; 9074 9075 // It is not possible to infer the correct ISA revision for R3 or R5 9076 // so drop down to R2 for the checks. 9077 unsigned char isa_rev = sec_abiflags->isa_rev; 9078 if (isa_rev == 3 || isa_rev == 5) 9079 isa_rev = 2; 9080 9081 // Check compatibility between abiflags created from elf header 9082 // and abiflags from .MIPS.abiflags section in this object file. 9083 if (this->level_rev(sec_abiflags->isa_level, isa_rev) 9084 < this->level_rev(header_abiflags.isa_level, header_abiflags.isa_rev)) 9085 gold_warning(_("%s: Inconsistent ISA between e_flags and .MIPS.abiflags"), 9086 relobj->name().c_str()); 9087 if (header_abiflags.fp_abi != elfcpp::Val_GNU_MIPS_ABI_FP_ANY 9088 && sec_abiflags->fp_abi != header_abiflags.fp_abi) 9089 gold_warning(_("%s: Inconsistent FP ABI between .gnu.attributes and " 9090 ".MIPS.abiflags"), relobj->name().c_str()); 9091 if ((sec_abiflags->ases & header_abiflags.ases) != header_abiflags.ases) 9092 gold_warning(_("%s: Inconsistent ASEs between e_flags and .MIPS.abiflags"), 9093 relobj->name().c_str()); 9094 // The isa_ext is allowed to be an extension of what can be inferred 9095 // from e_flags. 9096 if (!this->mips_mach_extends(this->mips_isa_ext_mach(header_abiflags.isa_ext), 9097 this->mips_isa_ext_mach(sec_abiflags->isa_ext))) 9098 gold_warning(_("%s: Inconsistent ISA extensions between e_flags and " 9099 ".MIPS.abiflags"), relobj->name().c_str()); 9100 if (sec_abiflags->flags2 != 0) 9101 gold_warning(_("%s: Unexpected flag in the flags2 field of " 9102 ".MIPS.abiflags (0x%x)"), relobj->name().c_str(), 9103 sec_abiflags->flags2); 9104 // Use abiflags from .MIPS.abiflags section. 9105 *abiflags = *sec_abiflags; 9106} 9107 9108// Return the meaning of fp_abi, or "unknown" if not known. 9109 9110template<int size, bool big_endian> 9111const char* 9112Target_mips<size, big_endian>::fp_abi_string(int fp) 9113{ 9114 switch (fp) 9115 { 9116 case elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE: 9117 return "-mdouble-float"; 9118 case elfcpp::Val_GNU_MIPS_ABI_FP_SINGLE: 9119 return "-msingle-float"; 9120 case elfcpp::Val_GNU_MIPS_ABI_FP_SOFT: 9121 return "-msoft-float"; 9122 case elfcpp::Val_GNU_MIPS_ABI_FP_OLD_64: 9123 return _("-mips32r2 -mfp64 (12 callee-saved)"); 9124 case elfcpp::Val_GNU_MIPS_ABI_FP_XX: 9125 return "-mfpxx"; 9126 case elfcpp::Val_GNU_MIPS_ABI_FP_64: 9127 return "-mgp32 -mfp64"; 9128 case elfcpp::Val_GNU_MIPS_ABI_FP_64A: 9129 return "-mgp32 -mfp64 -mno-odd-spreg"; 9130 default: 9131 return "unknown"; 9132 } 9133} 9134 9135// Select fp_abi. 9136 9137template<int size, bool big_endian> 9138int 9139Target_mips<size, big_endian>::select_fp_abi(const std::string& name, int in_fp, 9140 int out_fp) 9141{ 9142 if (in_fp == out_fp) 9143 return out_fp; 9144 9145 if (out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_ANY) 9146 return in_fp; 9147 else if (out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_XX 9148 && (in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE 9149 || in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64 9150 || in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64A)) 9151 return in_fp; 9152 else if (in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_XX 9153 && (out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE 9154 || out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64 9155 || out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64A)) 9156 return out_fp; // Keep the current setting. 9157 else if (out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64A 9158 && in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64) 9159 return in_fp; 9160 else if (in_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64A 9161 && out_fp == elfcpp::Val_GNU_MIPS_ABI_FP_64) 9162 return out_fp; // Keep the current setting. 9163 else if (in_fp != elfcpp::Val_GNU_MIPS_ABI_FP_ANY) 9164 gold_warning(_("%s: FP ABI %s is incompatible with %s"), name.c_str(), 9165 fp_abi_string(in_fp), fp_abi_string(out_fp)); 9166 return out_fp; 9167} 9168 9169// Merge attributes from input object. 9170 9171template<int size, bool big_endian> 9172void 9173Target_mips<size, big_endian>::merge_obj_attributes(const std::string& name, 9174 const Attributes_section_data* pasd) 9175{ 9176 // Return if there is no attributes section data. 9177 if (pasd == NULL) 9178 return; 9179 9180 // If output has no object attributes, just copy. 9181 if (this->attributes_section_data_ == NULL) 9182 { 9183 this->attributes_section_data_ = new Attributes_section_data(*pasd); 9184 return; 9185 } 9186 9187 Object_attribute* out_attr = this->attributes_section_data_->known_attributes( 9188 Object_attribute::OBJ_ATTR_GNU); 9189 9190 out_attr[elfcpp::Tag_GNU_MIPS_ABI_FP].set_type(1); 9191 out_attr[elfcpp::Tag_GNU_MIPS_ABI_FP].set_int_value(this->abiflags_->fp_abi); 9192 9193 // Merge Tag_compatibility attributes and any common GNU ones. 9194 this->attributes_section_data_->merge(name.c_str(), pasd); 9195} 9196 9197// Merge abiflags from input object. 9198 9199template<int size, bool big_endian> 9200void 9201Target_mips<size, big_endian>::merge_obj_abiflags(const std::string& name, 9202 Mips_abiflags<big_endian>* in_abiflags) 9203{ 9204 // If output has no abiflags, just copy. 9205 if (this->abiflags_ == NULL) 9206 { 9207 this->abiflags_ = new Mips_abiflags<big_endian>(*in_abiflags); 9208 return; 9209 } 9210 9211 this->abiflags_->fp_abi = this->select_fp_abi(name, in_abiflags->fp_abi, 9212 this->abiflags_->fp_abi); 9213 9214 // Merge abiflags. 9215 this->abiflags_->isa_level = std::max(this->abiflags_->isa_level, 9216 in_abiflags->isa_level); 9217 this->abiflags_->isa_rev = std::max(this->abiflags_->isa_rev, 9218 in_abiflags->isa_rev); 9219 this->abiflags_->gpr_size = std::max(this->abiflags_->gpr_size, 9220 in_abiflags->gpr_size); 9221 this->abiflags_->cpr1_size = std::max(this->abiflags_->cpr1_size, 9222 in_abiflags->cpr1_size); 9223 this->abiflags_->cpr2_size = std::max(this->abiflags_->cpr2_size, 9224 in_abiflags->cpr2_size); 9225 this->abiflags_->ases |= in_abiflags->ases; 9226 this->abiflags_->flags1 |= in_abiflags->flags1; 9227} 9228 9229// Check whether machine EXTENSION is an extension of machine BASE. 9230template<int size, bool big_endian> 9231bool 9232Target_mips<size, big_endian>::mips_mach_extends(unsigned int base, 9233 unsigned int extension) 9234{ 9235 if (extension == base) 9236 return true; 9237 9238 if ((base == mach_mipsisa32) 9239 && this->mips_mach_extends(mach_mipsisa64, extension)) 9240 return true; 9241 9242 if ((base == mach_mipsisa32r2) 9243 && this->mips_mach_extends(mach_mipsisa64r2, extension)) 9244 return true; 9245 9246 for (unsigned int i = 0; i < this->mips_mach_extensions_.size(); ++i) 9247 if (extension == this->mips_mach_extensions_[i].first) 9248 { 9249 extension = this->mips_mach_extensions_[i].second; 9250 if (extension == base) 9251 return true; 9252 } 9253 9254 return false; 9255} 9256 9257// Merge file header flags from input object. 9258 9259template<int size, bool big_endian> 9260void 9261Target_mips<size, big_endian>::merge_obj_e_flags(const std::string& name, 9262 elfcpp::Elf_Word in_flags) 9263{ 9264 // If flags are not set yet, just copy them. 9265 if (!this->are_processor_specific_flags_set()) 9266 { 9267 this->set_processor_specific_flags(in_flags); 9268 this->mach_ = this->elf_mips_mach(in_flags); 9269 return; 9270 } 9271 9272 elfcpp::Elf_Word new_flags = in_flags; 9273 elfcpp::Elf_Word old_flags = this->processor_specific_flags(); 9274 elfcpp::Elf_Word merged_flags = this->processor_specific_flags(); 9275 merged_flags |= new_flags & elfcpp::EF_MIPS_NOREORDER; 9276 9277 // Check flag compatibility. 9278 new_flags &= ~elfcpp::EF_MIPS_NOREORDER; 9279 old_flags &= ~elfcpp::EF_MIPS_NOREORDER; 9280 9281 // Some IRIX 6 BSD-compatibility objects have this bit set. It 9282 // doesn't seem to matter. 9283 new_flags &= ~elfcpp::EF_MIPS_XGOT; 9284 old_flags &= ~elfcpp::EF_MIPS_XGOT; 9285 9286 // MIPSpro generates ucode info in n64 objects. Again, we should 9287 // just be able to ignore this. 9288 new_flags &= ~elfcpp::EF_MIPS_UCODE; 9289 old_flags &= ~elfcpp::EF_MIPS_UCODE; 9290 9291 if (new_flags == old_flags) 9292 { 9293 this->set_processor_specific_flags(merged_flags); 9294 return; 9295 } 9296 9297 if (((new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0) 9298 != ((old_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) != 0)) 9299 gold_warning(_("%s: linking abicalls files with non-abicalls files"), 9300 name.c_str()); 9301 9302 if (new_flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) 9303 merged_flags |= elfcpp::EF_MIPS_CPIC; 9304 if (!(new_flags & elfcpp::EF_MIPS_PIC)) 9305 merged_flags &= ~elfcpp::EF_MIPS_PIC; 9306 9307 new_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC); 9308 old_flags &= ~(elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC); 9309 9310 // Compare the ISAs. 9311 if (mips_32bit_flags(old_flags) != mips_32bit_flags(new_flags)) 9312 gold_error(_("%s: linking 32-bit code with 64-bit code"), name.c_str()); 9313 else if (!this->mips_mach_extends(this->elf_mips_mach(in_flags), this->mach_)) 9314 { 9315 // Output ISA isn't the same as, or an extension of, input ISA. 9316 if (this->mips_mach_extends(this->mach_, this->elf_mips_mach(in_flags))) 9317 { 9318 // Copy the architecture info from input object to output. Also copy 9319 // the 32-bit flag (if set) so that we continue to recognise 9320 // output as a 32-bit binary. 9321 this->mach_ = this->elf_mips_mach(in_flags); 9322 merged_flags &= ~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH); 9323 merged_flags |= (new_flags & (elfcpp::EF_MIPS_ARCH 9324 | elfcpp::EF_MIPS_MACH | elfcpp::EF_MIPS_32BITMODE)); 9325 9326 // Update the ABI flags isa_level, isa_rev, isa_ext fields. 9327 this->update_abiflags_isa(name, merged_flags, this->abiflags_); 9328 9329 // Copy across the ABI flags if output doesn't use them 9330 // and if that was what caused us to treat input object as 32-bit. 9331 if ((old_flags & elfcpp::EF_MIPS_ABI) == 0 9332 && this->mips_32bit_flags(new_flags) 9333 && !this->mips_32bit_flags(new_flags & ~elfcpp::EF_MIPS_ABI)) 9334 merged_flags |= new_flags & elfcpp::EF_MIPS_ABI; 9335 } 9336 else 9337 // The ISAs aren't compatible. 9338 gold_error(_("%s: linking %s module with previous %s modules"), 9339 name.c_str(), this->elf_mips_mach_name(in_flags), 9340 this->elf_mips_mach_name(merged_flags)); 9341 } 9342 9343 new_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH 9344 | elfcpp::EF_MIPS_32BITMODE)); 9345 old_flags &= (~(elfcpp::EF_MIPS_ARCH | elfcpp::EF_MIPS_MACH 9346 | elfcpp::EF_MIPS_32BITMODE)); 9347 9348 // Compare ABIs. 9349 if ((new_flags & elfcpp::EF_MIPS_ABI) != (old_flags & elfcpp::EF_MIPS_ABI)) 9350 { 9351 // Only error if both are set (to different values). 9352 if ((new_flags & elfcpp::EF_MIPS_ABI) 9353 && (old_flags & elfcpp::EF_MIPS_ABI)) 9354 gold_error(_("%s: ABI mismatch: linking %s module with " 9355 "previous %s modules"), name.c_str(), 9356 this->elf_mips_abi_name(in_flags), 9357 this->elf_mips_abi_name(merged_flags)); 9358 9359 new_flags &= ~elfcpp::EF_MIPS_ABI; 9360 old_flags &= ~elfcpp::EF_MIPS_ABI; 9361 } 9362 9363 // Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together 9364 // and allow arbitrary mixing of the remaining ASEs (retain the union). 9365 if ((new_flags & elfcpp::EF_MIPS_ARCH_ASE) 9366 != (old_flags & elfcpp::EF_MIPS_ARCH_ASE)) 9367 { 9368 int old_micro = old_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS; 9369 int new_micro = new_flags & elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS; 9370 int old_m16 = old_flags & elfcpp::EF_MIPS_ARCH_ASE_M16; 9371 int new_m16 = new_flags & elfcpp::EF_MIPS_ARCH_ASE_M16; 9372 int micro_mis = old_m16 && new_micro; 9373 int m16_mis = old_micro && new_m16; 9374 9375 if (m16_mis || micro_mis) 9376 gold_error(_("%s: ASE mismatch: linking %s module with " 9377 "previous %s modules"), name.c_str(), 9378 m16_mis ? "MIPS16" : "microMIPS", 9379 m16_mis ? "microMIPS" : "MIPS16"); 9380 9381 merged_flags |= new_flags & elfcpp::EF_MIPS_ARCH_ASE; 9382 9383 new_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE; 9384 old_flags &= ~ elfcpp::EF_MIPS_ARCH_ASE; 9385 } 9386 9387 // Compare NaN encodings. 9388 if ((new_flags & elfcpp::EF_MIPS_NAN2008) != (old_flags & elfcpp::EF_MIPS_NAN2008)) 9389 { 9390 gold_error(_("%s: linking %s module with previous %s modules"), 9391 name.c_str(), 9392 (new_flags & elfcpp::EF_MIPS_NAN2008 9393 ? "-mnan=2008" : "-mnan=legacy"), 9394 (old_flags & elfcpp::EF_MIPS_NAN2008 9395 ? "-mnan=2008" : "-mnan=legacy")); 9396 9397 new_flags &= ~elfcpp::EF_MIPS_NAN2008; 9398 old_flags &= ~elfcpp::EF_MIPS_NAN2008; 9399 } 9400 9401 // Compare FP64 state. 9402 if ((new_flags & elfcpp::EF_MIPS_FP64) != (old_flags & elfcpp::EF_MIPS_FP64)) 9403 { 9404 gold_error(_("%s: linking %s module with previous %s modules"), 9405 name.c_str(), 9406 (new_flags & elfcpp::EF_MIPS_FP64 9407 ? "-mfp64" : "-mfp32"), 9408 (old_flags & elfcpp::EF_MIPS_FP64 9409 ? "-mfp64" : "-mfp32")); 9410 9411 new_flags &= ~elfcpp::EF_MIPS_FP64; 9412 old_flags &= ~elfcpp::EF_MIPS_FP64; 9413 } 9414 9415 // Warn about any other mismatches. 9416 if (new_flags != old_flags) 9417 gold_error(_("%s: uses different e_flags (0x%x) fields than previous " 9418 "modules (0x%x)"), name.c_str(), new_flags, old_flags); 9419 9420 this->set_processor_specific_flags(merged_flags); 9421} 9422 9423// Adjust ELF file header. 9424 9425template<int size, bool big_endian> 9426void 9427Target_mips<size, big_endian>::do_adjust_elf_header( 9428 unsigned char* view, 9429 int len) 9430{ 9431 gold_assert(len == elfcpp::Elf_sizes<size>::ehdr_size); 9432 9433 elfcpp::Ehdr<size, big_endian> ehdr(view); 9434 unsigned char e_ident[elfcpp::EI_NIDENT]; 9435 elfcpp::Elf_Word flags = this->processor_specific_flags(); 9436 memcpy(e_ident, ehdr.get_e_ident(), elfcpp::EI_NIDENT); 9437 9438 unsigned char ei_abiversion = 0; 9439 elfcpp::Elf_Half type = ehdr.get_e_type(); 9440 if (type == elfcpp::ET_EXEC 9441 && parameters->options().copyreloc() 9442 && (flags & (elfcpp::EF_MIPS_PIC | elfcpp::EF_MIPS_CPIC)) 9443 == elfcpp::EF_MIPS_CPIC) 9444 ei_abiversion = 1; 9445 9446 if (this->abiflags_ != NULL 9447 && (this->abiflags_->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_64 9448 || this->abiflags_->fp_abi == elfcpp::Val_GNU_MIPS_ABI_FP_64A)) 9449 ei_abiversion = 3; 9450 9451 e_ident[elfcpp::EI_ABIVERSION] = ei_abiversion; 9452 elfcpp::Ehdr_write<size, big_endian> oehdr(view); 9453 oehdr.put_e_ident(e_ident); 9454 9455 if (this->entry_symbol_is_compressed_) 9456 oehdr.put_e_entry(ehdr.get_e_entry() + 1); 9457} 9458 9459// do_make_elf_object to override the same function in the base class. 9460// We need to use a target-specific sub-class of 9461// Sized_relobj_file<size, big_endian> to store Mips specific information. 9462// Hence we need to have our own ELF object creation. 9463 9464template<int size, bool big_endian> 9465Object* 9466Target_mips<size, big_endian>::do_make_elf_object( 9467 const std::string& name, 9468 Input_file* input_file, 9469 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) 9470{ 9471 int et = ehdr.get_e_type(); 9472 // ET_EXEC files are valid input for --just-symbols/-R, 9473 // and we treat them as relocatable objects. 9474 if (et == elfcpp::ET_REL 9475 || (et == elfcpp::ET_EXEC && input_file->just_symbols())) 9476 { 9477 Mips_relobj<size, big_endian>* obj = 9478 new Mips_relobj<size, big_endian>(name, input_file, offset, ehdr); 9479 obj->setup(); 9480 return obj; 9481 } 9482 else if (et == elfcpp::ET_DYN) 9483 { 9484 // TODO(sasa): Should we create Mips_dynobj? 9485 return Target::do_make_elf_object(name, input_file, offset, ehdr); 9486 } 9487 else 9488 { 9489 gold_error(_("%s: unsupported ELF file type %d"), 9490 name.c_str(), et); 9491 return NULL; 9492 } 9493} 9494 9495// Finalize the sections. 9496 9497template <int size, bool big_endian> 9498void 9499Target_mips<size, big_endian>::do_finalize_sections(Layout* layout, 9500 const Input_objects* input_objects, 9501 Symbol_table* symtab) 9502{ 9503 // Add +1 to MIPS16 and microMIPS init_ and _fini symbols so that DT_INIT and 9504 // DT_FINI have correct values. 9505 Mips_symbol<size>* init = static_cast<Mips_symbol<size>*>( 9506 symtab->lookup(parameters->options().init())); 9507 if (init != NULL && (init->is_mips16() || init->is_micromips())) 9508 init->set_value(init->value() | 1); 9509 Mips_symbol<size>* fini = static_cast<Mips_symbol<size>*>( 9510 symtab->lookup(parameters->options().fini())); 9511 if (fini != NULL && (fini->is_mips16() || fini->is_micromips())) 9512 fini->set_value(fini->value() | 1); 9513 9514 // Check whether the entry symbol is mips16 or micromips. This is needed to 9515 // adjust entry address in ELF header. 9516 Mips_symbol<size>* entry = 9517 static_cast<Mips_symbol<size>*>(symtab->lookup(this->entry_symbol_name())); 9518 this->entry_symbol_is_compressed_ = (entry != NULL && (entry->is_mips16() 9519 || entry->is_micromips())); 9520 9521 if (!parameters->doing_static_link() 9522 && (strcmp(parameters->options().hash_style(), "gnu") == 0 9523 || strcmp(parameters->options().hash_style(), "both") == 0)) 9524 { 9525 // .gnu.hash and the MIPS ABI require .dynsym to be sorted in different 9526 // ways. .gnu.hash needs symbols to be grouped by hash code whereas the 9527 // MIPS ABI requires a mapping between the GOT and the symbol table. 9528 gold_error(".gnu.hash is incompatible with the MIPS ABI"); 9529 } 9530 9531 // Check whether the final section that was scanned has HI16 or GOT16 9532 // relocations without the corresponding LO16 part. 9533 if (this->got16_addends_.size() > 0) 9534 gold_error("Can't find matching LO16 reloc"); 9535 9536 // Set _gp value. 9537 this->set_gp(layout, symtab); 9538 9539 // Check for any mips16 stub sections that we can discard. 9540 if (!parameters->options().relocatable()) 9541 { 9542 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 9543 p != input_objects->relobj_end(); 9544 ++p) 9545 { 9546 Mips_relobj<size, big_endian>* object = 9547 Mips_relobj<size, big_endian>::as_mips_relobj(*p); 9548 object->discard_mips16_stub_sections(symtab); 9549 } 9550 } 9551 9552 Valtype gprmask = 0; 9553 Valtype cprmask1 = 0; 9554 Valtype cprmask2 = 0; 9555 Valtype cprmask3 = 0; 9556 Valtype cprmask4 = 0; 9557 bool has_reginfo_section = false; 9558 9559 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 9560 p != input_objects->relobj_end(); 9561 ++p) 9562 { 9563 Mips_relobj<size, big_endian>* relobj = 9564 Mips_relobj<size, big_endian>::as_mips_relobj(*p); 9565 9566 // Merge .reginfo contents of input objects. 9567 if (relobj->has_reginfo_section()) 9568 { 9569 has_reginfo_section = true; 9570 gprmask |= relobj->gprmask(); 9571 cprmask1 |= relobj->cprmask1(); 9572 cprmask2 |= relobj->cprmask2(); 9573 cprmask3 |= relobj->cprmask3(); 9574 cprmask4 |= relobj->cprmask4(); 9575 } 9576 9577 Input_file::Format format = relobj->input_file()->format(); 9578 if (format != Input_file::FORMAT_ELF) 9579 continue; 9580 9581 // If all input sections will be discarded, don't use this object 9582 // file for merging processor specific flags. 9583 bool should_merge_processor_specific_flags = false; 9584 9585 for (unsigned int i = 1; i < relobj->shnum(); ++i) 9586 if (relobj->output_section(i) != NULL) 9587 { 9588 should_merge_processor_specific_flags = true; 9589 break; 9590 } 9591 9592 if (!should_merge_processor_specific_flags) 9593 continue; 9594 9595 // Merge processor specific flags. 9596 Mips_abiflags<big_endian> in_abiflags; 9597 9598 this->create_abiflags(relobj, &in_abiflags); 9599 this->merge_obj_e_flags(relobj->name(), 9600 relobj->processor_specific_flags()); 9601 this->merge_obj_abiflags(relobj->name(), &in_abiflags); 9602 this->merge_obj_attributes(relobj->name(), 9603 relobj->attributes_section_data()); 9604 } 9605 9606 // Create a .gnu.attributes section if we have merged any attributes 9607 // from inputs. 9608 if (this->attributes_section_data_ != NULL) 9609 { 9610 Output_attributes_section_data* attributes_section = 9611 new Output_attributes_section_data(*this->attributes_section_data_); 9612 layout->add_output_section_data(".gnu.attributes", 9613 elfcpp::SHT_GNU_ATTRIBUTES, 0, 9614 attributes_section, ORDER_INVALID, false); 9615 } 9616 9617 // Create .MIPS.abiflags output section if there is an input section. 9618 if (this->has_abiflags_section_) 9619 { 9620 Mips_output_section_abiflags<size, big_endian>* abiflags_section = 9621 new Mips_output_section_abiflags<size, big_endian>(*this->abiflags_); 9622 9623 Output_section* os = 9624 layout->add_output_section_data(".MIPS.abiflags", 9625 elfcpp::SHT_MIPS_ABIFLAGS, 9626 elfcpp::SHF_ALLOC, 9627 abiflags_section, ORDER_INVALID, false); 9628 9629 if (!parameters->options().relocatable() && os != NULL) 9630 { 9631 Output_segment* abiflags_segment = 9632 layout->make_output_segment(elfcpp::PT_MIPS_ABIFLAGS, elfcpp::PF_R); 9633 abiflags_segment->add_output_section_to_nonload(os, elfcpp::PF_R); 9634 } 9635 } 9636 9637 if (has_reginfo_section && !parameters->options().gc_sections()) 9638 { 9639 // Create .reginfo output section. 9640 Mips_output_section_reginfo<size, big_endian>* reginfo_section = 9641 new Mips_output_section_reginfo<size, big_endian>(this, gprmask, 9642 cprmask1, cprmask2, 9643 cprmask3, cprmask4); 9644 9645 Output_section* os = 9646 layout->add_output_section_data(".reginfo", elfcpp::SHT_MIPS_REGINFO, 9647 elfcpp::SHF_ALLOC, reginfo_section, 9648 ORDER_INVALID, false); 9649 9650 if (!parameters->options().relocatable() && os != NULL) 9651 { 9652 Output_segment* reginfo_segment = 9653 layout->make_output_segment(elfcpp::PT_MIPS_REGINFO, 9654 elfcpp::PF_R); 9655 reginfo_segment->add_output_section_to_nonload(os, elfcpp::PF_R); 9656 } 9657 } 9658 9659 if (this->plt_ != NULL) 9660 { 9661 // Set final PLT offsets for symbols. 9662 this->plt_section()->set_plt_offsets(); 9663 9664 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section. 9665 // Set STO_MICROMIPS flag if the output has microMIPS code, but only if 9666 // there are no standard PLT entries present. 9667 unsigned char nonvis = 0; 9668 if (this->is_output_micromips() 9669 && !this->plt_section()->has_standard_entries()) 9670 nonvis = elfcpp::STO_MICROMIPS >> 2; 9671 symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL, 9672 Symbol_table::PREDEFINED, 9673 this->plt_, 9674 0, 0, elfcpp::STT_FUNC, 9675 elfcpp::STB_LOCAL, 9676 elfcpp::STV_DEFAULT, nonvis, 9677 false, false); 9678 } 9679 9680 if (this->mips_stubs_ != NULL) 9681 { 9682 // Define _MIPS_STUBS_ at the start of the .MIPS.stubs section. 9683 unsigned char nonvis = 0; 9684 if (this->is_output_micromips()) 9685 nonvis = elfcpp::STO_MICROMIPS >> 2; 9686 symtab->define_in_output_data("_MIPS_STUBS_", NULL, 9687 Symbol_table::PREDEFINED, 9688 this->mips_stubs_, 9689 0, 0, elfcpp::STT_FUNC, 9690 elfcpp::STB_LOCAL, 9691 elfcpp::STV_DEFAULT, nonvis, 9692 false, false); 9693 } 9694 9695 if (!parameters->options().relocatable() && !parameters->doing_static_link()) 9696 // In case there is no .got section, create one. 9697 this->got_section(symtab, layout); 9698 9699 // Emit any relocs we saved in an attempt to avoid generating COPY 9700 // relocs. 9701 if (this->copy_relocs_.any_saved_relocs()) 9702 this->copy_relocs_.emit_mips(this->rel_dyn_section(layout), symtab, layout, 9703 this); 9704 9705 // Emit dynamic relocs. 9706 for (typename std::vector<Dyn_reloc>::iterator p = this->dyn_relocs_.begin(); 9707 p != this->dyn_relocs_.end(); 9708 ++p) 9709 p->emit(this->rel_dyn_section(layout), this->got_section(), symtab); 9710 9711 if (this->has_got_section()) 9712 this->got_section()->lay_out_got(layout, symtab, input_objects); 9713 9714 if (this->mips_stubs_ != NULL) 9715 this->mips_stubs_->set_needs_dynsym_value(); 9716 9717 // Check for functions that might need $25 to be valid on entry. 9718 // TODO(sasa): Can we do this without iterating over all symbols? 9719 typedef Symbol_visitor_check_symbols<size, big_endian> Symbol_visitor; 9720 symtab->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(this, layout, 9721 symtab)); 9722 9723 // Add NULL segment. 9724 if (!parameters->options().relocatable()) 9725 layout->make_output_segment(elfcpp::PT_NULL, 0); 9726 9727 // Fill in some more dynamic tags. 9728 // TODO(sasa): Add more dynamic tags. 9729 const Reloc_section* rel_plt = (this->plt_ == NULL 9730 ? NULL : this->plt_->rel_plt()); 9731 layout->add_target_dynamic_tags(true, this->got_, rel_plt, 9732 this->rel_dyn_, true, false); 9733 9734 Output_data_dynamic* const odyn = layout->dynamic_data(); 9735 if (odyn != NULL 9736 && !parameters->options().relocatable() 9737 && !parameters->doing_static_link()) 9738 { 9739 unsigned int d_val; 9740 // This element holds a 32-bit version id for the Runtime 9741 // Linker Interface. This will start at integer value 1. 9742 d_val = 0x01; 9743 odyn->add_constant(elfcpp::DT_MIPS_RLD_VERSION, d_val); 9744 9745 // Dynamic flags 9746 d_val = elfcpp::RHF_NOTPOT; 9747 odyn->add_constant(elfcpp::DT_MIPS_FLAGS, d_val); 9748 9749 // Save layout for using when emitting custom dynamic tags. 9750 this->layout_ = layout; 9751 9752 // This member holds the base address of the segment. 9753 odyn->add_custom(elfcpp::DT_MIPS_BASE_ADDRESS); 9754 9755 // This member holds the number of entries in the .dynsym section. 9756 odyn->add_custom(elfcpp::DT_MIPS_SYMTABNO); 9757 9758 // This member holds the index of the first dynamic symbol 9759 // table entry that corresponds to an entry in the global offset table. 9760 odyn->add_custom(elfcpp::DT_MIPS_GOTSYM); 9761 9762 // This member holds the number of local GOT entries. 9763 odyn->add_constant(elfcpp::DT_MIPS_LOCAL_GOTNO, 9764 this->got_->get_local_gotno()); 9765 9766 if (this->plt_ != NULL) 9767 // DT_MIPS_PLTGOT dynamic tag 9768 odyn->add_section_address(elfcpp::DT_MIPS_PLTGOT, this->got_plt_); 9769 9770 if (!parameters->options().shared()) 9771 { 9772 this->rld_map_ = new Output_data_zero_fill(size / 8, size / 8); 9773 9774 layout->add_output_section_data(".rld_map", elfcpp::SHT_PROGBITS, 9775 (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE), 9776 this->rld_map_, ORDER_INVALID, false); 9777 9778 // __RLD_MAP will be filled in by the runtime loader to contain 9779 // a pointer to the _r_debug structure. 9780 Symbol* rld_map = symtab->define_in_output_data("__RLD_MAP", NULL, 9781 Symbol_table::PREDEFINED, 9782 this->rld_map_, 9783 0, 0, elfcpp::STT_OBJECT, 9784 elfcpp::STB_GLOBAL, 9785 elfcpp::STV_DEFAULT, 0, 9786 false, false); 9787 9788 if (!rld_map->is_forced_local()) 9789 rld_map->set_needs_dynsym_entry(); 9790 9791 if (!parameters->options().pie()) 9792 // This member holds the absolute address of the debug pointer. 9793 odyn->add_section_address(elfcpp::DT_MIPS_RLD_MAP, this->rld_map_); 9794 else 9795 // This member holds the offset to the debug pointer, 9796 // relative to the address of the tag. 9797 odyn->add_custom(elfcpp::DT_MIPS_RLD_MAP_REL); 9798 } 9799 } 9800} 9801 9802// Get the custom dynamic tag value. 9803template<int size, bool big_endian> 9804unsigned int 9805Target_mips<size, big_endian>::do_dynamic_tag_custom_value(elfcpp::DT tag) const 9806{ 9807 switch (tag) 9808 { 9809 case elfcpp::DT_MIPS_BASE_ADDRESS: 9810 { 9811 // The base address of the segment. 9812 // At this point, the segment list has been sorted into final order, 9813 // so just return vaddr of the first readable PT_LOAD segment. 9814 Output_segment* seg = 9815 this->layout_->find_output_segment(elfcpp::PT_LOAD, elfcpp::PF_R, 0); 9816 gold_assert(seg != NULL); 9817 return seg->vaddr(); 9818 } 9819 9820 case elfcpp::DT_MIPS_SYMTABNO: 9821 // The number of entries in the .dynsym section. 9822 return this->get_dt_mips_symtabno(); 9823 9824 case elfcpp::DT_MIPS_GOTSYM: 9825 { 9826 // The index of the first dynamic symbol table entry that corresponds 9827 // to an entry in the GOT. 9828 if (this->got_->first_global_got_dynsym_index() != -1U) 9829 return this->got_->first_global_got_dynsym_index(); 9830 else 9831 // In case if we don't have global GOT symbols we default to setting 9832 // DT_MIPS_GOTSYM to the same value as DT_MIPS_SYMTABNO. 9833 return this->get_dt_mips_symtabno(); 9834 } 9835 9836 case elfcpp::DT_MIPS_RLD_MAP_REL: 9837 { 9838 // The MIPS_RLD_MAP_REL tag stores the offset to the debug pointer, 9839 // relative to the address of the tag. 9840 Output_data_dynamic* const odyn = this->layout_->dynamic_data(); 9841 unsigned int entry_offset = 9842 odyn->get_entry_offset(elfcpp::DT_MIPS_RLD_MAP_REL); 9843 gold_assert(entry_offset != -1U); 9844 return this->rld_map_->address() - (odyn->address() + entry_offset); 9845 } 9846 default: 9847 gold_error(_("Unknown dynamic tag 0x%x"), (unsigned int)tag); 9848 } 9849 9850 return (unsigned int)-1; 9851} 9852 9853// Relocate section data. 9854 9855template<int size, bool big_endian> 9856void 9857Target_mips<size, big_endian>::relocate_section( 9858 const Relocate_info<size, big_endian>* relinfo, 9859 unsigned int sh_type, 9860 const unsigned char* prelocs, 9861 size_t reloc_count, 9862 Output_section* output_section, 9863 bool needs_special_offset_handling, 9864 unsigned char* view, 9865 Mips_address address, 9866 section_size_type view_size, 9867 const Reloc_symbol_changes* reloc_symbol_changes) 9868{ 9869 typedef Target_mips<size, big_endian> Mips; 9870 typedef typename Target_mips<size, big_endian>::Relocate Mips_relocate; 9871 9872 if (sh_type == elfcpp::SHT_REL) 9873 { 9874 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 9875 Classify_reloc; 9876 9877 gold::relocate_section<size, big_endian, Mips, Mips_relocate, 9878 gold::Default_comdat_behavior, Classify_reloc>( 9879 relinfo, 9880 this, 9881 prelocs, 9882 reloc_count, 9883 output_section, 9884 needs_special_offset_handling, 9885 view, 9886 address, 9887 view_size, 9888 reloc_symbol_changes); 9889 } 9890 else if (sh_type == elfcpp::SHT_RELA) 9891 { 9892 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 9893 Classify_reloc; 9894 9895 gold::relocate_section<size, big_endian, Mips, Mips_relocate, 9896 gold::Default_comdat_behavior, Classify_reloc>( 9897 relinfo, 9898 this, 9899 prelocs, 9900 reloc_count, 9901 output_section, 9902 needs_special_offset_handling, 9903 view, 9904 address, 9905 view_size, 9906 reloc_symbol_changes); 9907 } 9908} 9909 9910// Return the size of a relocation while scanning during a relocatable 9911// link. 9912 9913unsigned int 9914mips_get_size_for_reloc(unsigned int r_type, Relobj* object) 9915{ 9916 switch (r_type) 9917 { 9918 case elfcpp::R_MIPS_NONE: 9919 case elfcpp::R_MIPS_TLS_DTPMOD64: 9920 case elfcpp::R_MIPS_TLS_DTPREL64: 9921 case elfcpp::R_MIPS_TLS_TPREL64: 9922 return 0; 9923 9924 case elfcpp::R_MIPS_32: 9925 case elfcpp::R_MIPS_TLS_DTPMOD32: 9926 case elfcpp::R_MIPS_TLS_DTPREL32: 9927 case elfcpp::R_MIPS_TLS_TPREL32: 9928 case elfcpp::R_MIPS_REL32: 9929 case elfcpp::R_MIPS_PC32: 9930 case elfcpp::R_MIPS_GPREL32: 9931 case elfcpp::R_MIPS_JALR: 9932 case elfcpp::R_MIPS_EH: 9933 return 4; 9934 9935 case elfcpp::R_MIPS_16: 9936 case elfcpp::R_MIPS_HI16: 9937 case elfcpp::R_MIPS_LO16: 9938 case elfcpp::R_MIPS_GPREL16: 9939 case elfcpp::R_MIPS16_HI16: 9940 case elfcpp::R_MIPS16_LO16: 9941 case elfcpp::R_MIPS_PC16: 9942 case elfcpp::R_MIPS_PCHI16: 9943 case elfcpp::R_MIPS_PCLO16: 9944 case elfcpp::R_MIPS_GOT16: 9945 case elfcpp::R_MIPS16_GOT16: 9946 case elfcpp::R_MIPS_CALL16: 9947 case elfcpp::R_MIPS16_CALL16: 9948 case elfcpp::R_MIPS_GOT_HI16: 9949 case elfcpp::R_MIPS_CALL_HI16: 9950 case elfcpp::R_MIPS_GOT_LO16: 9951 case elfcpp::R_MIPS_CALL_LO16: 9952 case elfcpp::R_MIPS_TLS_DTPREL_HI16: 9953 case elfcpp::R_MIPS_TLS_DTPREL_LO16: 9954 case elfcpp::R_MIPS_TLS_TPREL_HI16: 9955 case elfcpp::R_MIPS_TLS_TPREL_LO16: 9956 case elfcpp::R_MIPS16_GPREL: 9957 case elfcpp::R_MIPS_GOT_DISP: 9958 case elfcpp::R_MIPS_LITERAL: 9959 case elfcpp::R_MIPS_GOT_PAGE: 9960 case elfcpp::R_MIPS_GOT_OFST: 9961 case elfcpp::R_MIPS_TLS_GD: 9962 case elfcpp::R_MIPS_TLS_LDM: 9963 case elfcpp::R_MIPS_TLS_GOTTPREL: 9964 return 2; 9965 9966 // These relocations are not byte sized 9967 case elfcpp::R_MIPS_26: 9968 case elfcpp::R_MIPS16_26: 9969 case elfcpp::R_MIPS_PC21_S2: 9970 case elfcpp::R_MIPS_PC26_S2: 9971 case elfcpp::R_MIPS_PC18_S3: 9972 case elfcpp::R_MIPS_PC19_S2: 9973 return 4; 9974 9975 case elfcpp::R_MIPS_COPY: 9976 case elfcpp::R_MIPS_JUMP_SLOT: 9977 object->error(_("unexpected reloc %u in object file"), r_type); 9978 return 0; 9979 9980 default: 9981 object->error(_("unsupported reloc %u in object file"), r_type); 9982 return 0; 9983 } 9984} 9985 9986// Scan the relocs during a relocatable link. 9987 9988template<int size, bool big_endian> 9989void 9990Target_mips<size, big_endian>::scan_relocatable_relocs( 9991 Symbol_table* symtab, 9992 Layout* layout, 9993 Sized_relobj_file<size, big_endian>* object, 9994 unsigned int data_shndx, 9995 unsigned int sh_type, 9996 const unsigned char* prelocs, 9997 size_t reloc_count, 9998 Output_section* output_section, 9999 bool needs_special_offset_handling, 10000 size_t local_symbol_count, 10001 const unsigned char* plocal_symbols, 10002 Relocatable_relocs* rr) 10003{ 10004 if (sh_type == elfcpp::SHT_REL) 10005 { 10006 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 10007 Classify_reloc; 10008 typedef Mips_scan_relocatable_relocs<big_endian, Classify_reloc> 10009 Scan_relocatable_relocs; 10010 10011 gold::scan_relocatable_relocs<size, big_endian, Scan_relocatable_relocs>( 10012 symtab, 10013 layout, 10014 object, 10015 data_shndx, 10016 prelocs, 10017 reloc_count, 10018 output_section, 10019 needs_special_offset_handling, 10020 local_symbol_count, 10021 plocal_symbols, 10022 rr); 10023 } 10024 else if (sh_type == elfcpp::SHT_RELA) 10025 { 10026 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 10027 Classify_reloc; 10028 typedef Mips_scan_relocatable_relocs<big_endian, Classify_reloc> 10029 Scan_relocatable_relocs; 10030 10031 gold::scan_relocatable_relocs<size, big_endian, Scan_relocatable_relocs>( 10032 symtab, 10033 layout, 10034 object, 10035 data_shndx, 10036 prelocs, 10037 reloc_count, 10038 output_section, 10039 needs_special_offset_handling, 10040 local_symbol_count, 10041 plocal_symbols, 10042 rr); 10043 } 10044 else 10045 gold_unreachable(); 10046} 10047 10048// Scan the relocs for --emit-relocs. 10049 10050template<int size, bool big_endian> 10051void 10052Target_mips<size, big_endian>::emit_relocs_scan( 10053 Symbol_table* symtab, 10054 Layout* layout, 10055 Sized_relobj_file<size, big_endian>* object, 10056 unsigned int data_shndx, 10057 unsigned int sh_type, 10058 const unsigned char* prelocs, 10059 size_t reloc_count, 10060 Output_section* output_section, 10061 bool needs_special_offset_handling, 10062 size_t local_symbol_count, 10063 const unsigned char* plocal_syms, 10064 Relocatable_relocs* rr) 10065{ 10066 if (sh_type == elfcpp::SHT_REL) 10067 { 10068 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 10069 Classify_reloc; 10070 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 10071 Emit_relocs_strategy; 10072 10073 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>( 10074 symtab, 10075 layout, 10076 object, 10077 data_shndx, 10078 prelocs, 10079 reloc_count, 10080 output_section, 10081 needs_special_offset_handling, 10082 local_symbol_count, 10083 plocal_syms, 10084 rr); 10085 } 10086 else if (sh_type == elfcpp::SHT_RELA) 10087 { 10088 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 10089 Classify_reloc; 10090 typedef gold::Default_emit_relocs_strategy<Classify_reloc> 10091 Emit_relocs_strategy; 10092 10093 gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>( 10094 symtab, 10095 layout, 10096 object, 10097 data_shndx, 10098 prelocs, 10099 reloc_count, 10100 output_section, 10101 needs_special_offset_handling, 10102 local_symbol_count, 10103 plocal_syms, 10104 rr); 10105 } 10106 else 10107 gold_unreachable(); 10108} 10109 10110// Emit relocations for a section. 10111 10112template<int size, bool big_endian> 10113void 10114Target_mips<size, big_endian>::relocate_relocs( 10115 const Relocate_info<size, big_endian>* relinfo, 10116 unsigned int sh_type, 10117 const unsigned char* prelocs, 10118 size_t reloc_count, 10119 Output_section* output_section, 10120 typename elfcpp::Elf_types<size>::Elf_Off 10121 offset_in_output_section, 10122 unsigned char* view, 10123 Mips_address view_address, 10124 section_size_type view_size, 10125 unsigned char* reloc_view, 10126 section_size_type reloc_view_size) 10127{ 10128 if (sh_type == elfcpp::SHT_REL) 10129 { 10130 typedef Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian> 10131 Classify_reloc; 10132 10133 gold::relocate_relocs<size, big_endian, Classify_reloc>( 10134 relinfo, 10135 prelocs, 10136 reloc_count, 10137 output_section, 10138 offset_in_output_section, 10139 view, 10140 view_address, 10141 view_size, 10142 reloc_view, 10143 reloc_view_size); 10144 } 10145 else if (sh_type == elfcpp::SHT_RELA) 10146 { 10147 typedef Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian> 10148 Classify_reloc; 10149 10150 gold::relocate_relocs<size, big_endian, Classify_reloc>( 10151 relinfo, 10152 prelocs, 10153 reloc_count, 10154 output_section, 10155 offset_in_output_section, 10156 view, 10157 view_address, 10158 view_size, 10159 reloc_view, 10160 reloc_view_size); 10161 } 10162 else 10163 gold_unreachable(); 10164} 10165 10166// Perform target-specific processing in a relocatable link. This is 10167// only used if we use the relocation strategy RELOC_SPECIAL. 10168 10169template<int size, bool big_endian> 10170void 10171Target_mips<size, big_endian>::relocate_special_relocatable( 10172 const Relocate_info<size, big_endian>* relinfo, 10173 unsigned int sh_type, 10174 const unsigned char* preloc_in, 10175 size_t relnum, 10176 Output_section* output_section, 10177 typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section, 10178 unsigned char* view, 10179 Mips_address view_address, 10180 section_size_type, 10181 unsigned char* preloc_out) 10182{ 10183 // We can only handle REL type relocation sections. 10184 gold_assert(sh_type == elfcpp::SHT_REL); 10185 10186 typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc 10187 Reltype; 10188 typedef typename Reloc_types<elfcpp::SHT_REL, size, big_endian>::Reloc_write 10189 Reltype_write; 10190 10191 typedef Mips_relocate_functions<size, big_endian> Reloc_funcs; 10192 10193 const Mips_address invalid_address = static_cast<Mips_address>(0) - 1; 10194 10195 Mips_relobj<size, big_endian>* object = 10196 Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object); 10197 const unsigned int local_count = object->local_symbol_count(); 10198 10199 Reltype reloc(preloc_in); 10200 Reltype_write reloc_write(preloc_out); 10201 10202 elfcpp::Elf_types<32>::Elf_WXword r_info = reloc.get_r_info(); 10203 const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); 10204 const unsigned int r_type = elfcpp::elf_r_type<size>(r_info); 10205 10206 // Get the new symbol index. 10207 // We only use RELOC_SPECIAL strategy in local relocations. 10208 gold_assert(r_sym < local_count); 10209 10210 // We are adjusting a section symbol. We need to find 10211 // the symbol table index of the section symbol for 10212 // the output section corresponding to input section 10213 // in which this symbol is defined. 10214 bool is_ordinary; 10215 unsigned int shndx = object->local_symbol_input_shndx(r_sym, &is_ordinary); 10216 gold_assert(is_ordinary); 10217 Output_section* os = object->output_section(shndx); 10218 gold_assert(os != NULL); 10219 gold_assert(os->needs_symtab_index()); 10220 unsigned int new_symndx = os->symtab_index(); 10221 10222 // Get the new offset--the location in the output section where 10223 // this relocation should be applied. 10224 10225 Mips_address offset = reloc.get_r_offset(); 10226 Mips_address new_offset; 10227 if (offset_in_output_section != invalid_address) 10228 new_offset = offset + offset_in_output_section; 10229 else 10230 { 10231 section_offset_type sot_offset = 10232 convert_types<section_offset_type, Mips_address>(offset); 10233 section_offset_type new_sot_offset = 10234 output_section->output_offset(object, relinfo->data_shndx, 10235 sot_offset); 10236 gold_assert(new_sot_offset != -1); 10237 new_offset = new_sot_offset; 10238 } 10239 10240 // In an object file, r_offset is an offset within the section. 10241 // In an executable or dynamic object, generated by 10242 // --emit-relocs, r_offset is an absolute address. 10243 if (!parameters->options().relocatable()) 10244 { 10245 new_offset += view_address; 10246 if (offset_in_output_section != invalid_address) 10247 new_offset -= offset_in_output_section; 10248 } 10249 10250 reloc_write.put_r_offset(new_offset); 10251 reloc_write.put_r_info(elfcpp::elf_r_info<32>(new_symndx, r_type)); 10252 10253 // Handle the reloc addend. 10254 // The relocation uses a section symbol in the input file. 10255 // We are adjusting it to use a section symbol in the output 10256 // file. The input section symbol refers to some address in 10257 // the input section. We need the relocation in the output 10258 // file to refer to that same address. This adjustment to 10259 // the addend is the same calculation we use for a simple 10260 // absolute relocation for the input section symbol. 10261 Valtype calculated_value = 0; 10262 const Symbol_value<size>* psymval = object->local_symbol(r_sym); 10263 10264 unsigned char* paddend = view + offset; 10265 typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY; 10266 switch (r_type) 10267 { 10268 case elfcpp::R_MIPS_26: 10269 reloc_status = Reloc_funcs::rel26(paddend, object, psymval, 10270 offset_in_output_section, true, 0, sh_type == elfcpp::SHT_REL, NULL, 10271 false /*TODO(sasa): cross mode jump*/, r_type, this->jal_to_bal(), 10272 false, &calculated_value); 10273 break; 10274 10275 default: 10276 gold_unreachable(); 10277 } 10278 10279 // Report any errors. 10280 switch (reloc_status) 10281 { 10282 case Reloc_funcs::STATUS_OKAY: 10283 break; 10284 case Reloc_funcs::STATUS_OVERFLOW: 10285 gold_error_at_location(relinfo, relnum, reloc.get_r_offset(), 10286 _("relocation overflow")); 10287 break; 10288 case Reloc_funcs::STATUS_BAD_RELOC: 10289 gold_error_at_location(relinfo, relnum, reloc.get_r_offset(), 10290 _("unexpected opcode while processing relocation")); 10291 break; 10292 default: 10293 gold_unreachable(); 10294 } 10295} 10296 10297// Optimize the TLS relocation type based on what we know about the 10298// symbol. IS_FINAL is true if the final address of this symbol is 10299// known at link time. 10300 10301template<int size, bool big_endian> 10302tls::Tls_optimization 10303Target_mips<size, big_endian>::optimize_tls_reloc(bool, int) 10304{ 10305 // FIXME: Currently we do not do any TLS optimization. 10306 return tls::TLSOPT_NONE; 10307} 10308 10309// Scan a relocation for a local symbol. 10310 10311template<int size, bool big_endian> 10312inline void 10313Target_mips<size, big_endian>::Scan::local( 10314 Symbol_table* symtab, 10315 Layout* layout, 10316 Target_mips<size, big_endian>* target, 10317 Sized_relobj_file<size, big_endian>* object, 10318 unsigned int data_shndx, 10319 Output_section* output_section, 10320 const Relatype* rela, 10321 const Reltype* rel, 10322 unsigned int rel_type, 10323 unsigned int r_type, 10324 const elfcpp::Sym<size, big_endian>& lsym, 10325 bool is_discarded) 10326{ 10327 if (is_discarded) 10328 return; 10329 10330 Mips_address r_offset; 10331 unsigned int r_sym; 10332 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend; 10333 10334 if (rel_type == elfcpp::SHT_RELA) 10335 { 10336 r_offset = rela->get_r_offset(); 10337 r_sym = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 10338 get_r_sym(rela); 10339 r_addend = rela->get_r_addend(); 10340 } 10341 else 10342 { 10343 r_offset = rel->get_r_offset(); 10344 r_sym = Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian>:: 10345 get_r_sym(rel); 10346 r_addend = 0; 10347 } 10348 10349 Mips_relobj<size, big_endian>* mips_obj = 10350 Mips_relobj<size, big_endian>::as_mips_relobj(object); 10351 10352 if (mips_obj->is_mips16_stub_section(data_shndx)) 10353 { 10354 mips_obj->get_mips16_stub_section(data_shndx) 10355 ->new_local_reloc_found(r_type, r_sym); 10356 } 10357 10358 if (r_type == elfcpp::R_MIPS_NONE) 10359 // R_MIPS_NONE is used in mips16 stub sections, to define the target of the 10360 // mips16 stub. 10361 return; 10362 10363 if (!mips16_call_reloc(r_type) 10364 && !mips_obj->section_allows_mips16_refs(data_shndx)) 10365 // This reloc would need to refer to a MIPS16 hard-float stub, if 10366 // there is one. We ignore MIPS16 stub sections and .pdr section when 10367 // looking for relocs that would need to refer to MIPS16 stubs. 10368 mips_obj->add_local_non_16bit_call(r_sym); 10369 10370 if (r_type == elfcpp::R_MIPS16_26 10371 && !mips_obj->section_allows_mips16_refs(data_shndx)) 10372 mips_obj->add_local_16bit_call(r_sym); 10373 10374 switch (r_type) 10375 { 10376 case elfcpp::R_MIPS_GOT16: 10377 case elfcpp::R_MIPS_CALL16: 10378 case elfcpp::R_MIPS_CALL_HI16: 10379 case elfcpp::R_MIPS_CALL_LO16: 10380 case elfcpp::R_MIPS_GOT_HI16: 10381 case elfcpp::R_MIPS_GOT_LO16: 10382 case elfcpp::R_MIPS_GOT_PAGE: 10383 case elfcpp::R_MIPS_GOT_OFST: 10384 case elfcpp::R_MIPS_GOT_DISP: 10385 case elfcpp::R_MIPS_TLS_GOTTPREL: 10386 case elfcpp::R_MIPS_TLS_GD: 10387 case elfcpp::R_MIPS_TLS_LDM: 10388 case elfcpp::R_MIPS16_GOT16: 10389 case elfcpp::R_MIPS16_CALL16: 10390 case elfcpp::R_MIPS16_TLS_GOTTPREL: 10391 case elfcpp::R_MIPS16_TLS_GD: 10392 case elfcpp::R_MIPS16_TLS_LDM: 10393 case elfcpp::R_MICROMIPS_GOT16: 10394 case elfcpp::R_MICROMIPS_CALL16: 10395 case elfcpp::R_MICROMIPS_CALL_HI16: 10396 case elfcpp::R_MICROMIPS_CALL_LO16: 10397 case elfcpp::R_MICROMIPS_GOT_HI16: 10398 case elfcpp::R_MICROMIPS_GOT_LO16: 10399 case elfcpp::R_MICROMIPS_GOT_PAGE: 10400 case elfcpp::R_MICROMIPS_GOT_OFST: 10401 case elfcpp::R_MICROMIPS_GOT_DISP: 10402 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 10403 case elfcpp::R_MICROMIPS_TLS_GD: 10404 case elfcpp::R_MICROMIPS_TLS_LDM: 10405 case elfcpp::R_MIPS_EH: 10406 // We need a GOT section. 10407 target->got_section(symtab, layout); 10408 break; 10409 10410 default: 10411 break; 10412 } 10413 10414 if (call_lo16_reloc(r_type) 10415 || got_lo16_reloc(r_type) 10416 || got_disp_reloc(r_type) 10417 || eh_reloc(r_type)) 10418 { 10419 // We may need a local GOT entry for this relocation. We 10420 // don't count R_MIPS_GOT_PAGE because we can estimate the 10421 // maximum number of pages needed by looking at the size of 10422 // the segment. Similar comments apply to R_MIPS*_GOT16 and 10423 // R_MIPS*_CALL16. We don't count R_MIPS_GOT_HI16, or 10424 // R_MIPS_CALL_HI16 because these are always followed by an 10425 // R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. 10426 Mips_output_data_got<size, big_endian>* got = 10427 target->got_section(symtab, layout); 10428 bool is_section_symbol = lsym.get_st_type() == elfcpp::STT_SECTION; 10429 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type, -1U, 10430 is_section_symbol); 10431 } 10432 10433 switch (r_type) 10434 { 10435 case elfcpp::R_MIPS_CALL16: 10436 case elfcpp::R_MIPS16_CALL16: 10437 case elfcpp::R_MICROMIPS_CALL16: 10438 gold_error(_("CALL16 reloc at 0x%lx not against global symbol "), 10439 (unsigned long)r_offset); 10440 return; 10441 10442 case elfcpp::R_MIPS_GOT_PAGE: 10443 case elfcpp::R_MICROMIPS_GOT_PAGE: 10444 case elfcpp::R_MIPS16_GOT16: 10445 case elfcpp::R_MIPS_GOT16: 10446 case elfcpp::R_MIPS_GOT_HI16: 10447 case elfcpp::R_MIPS_GOT_LO16: 10448 case elfcpp::R_MICROMIPS_GOT16: 10449 case elfcpp::R_MICROMIPS_GOT_HI16: 10450 case elfcpp::R_MICROMIPS_GOT_LO16: 10451 { 10452 // This relocation needs a page entry in the GOT. 10453 // Get the section contents. 10454 section_size_type view_size = 0; 10455 const unsigned char* view = object->section_contents(data_shndx, 10456 &view_size, false); 10457 view += r_offset; 10458 10459 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 10460 Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff 10461 : r_addend); 10462 10463 if (rel_type == elfcpp::SHT_REL && got16_reloc(r_type)) 10464 target->got16_addends_.push_back(got16_addend<size, big_endian>( 10465 object, data_shndx, r_type, r_sym, addend)); 10466 else 10467 target->got_section()->record_got_page_entry(mips_obj, r_sym, addend); 10468 break; 10469 } 10470 10471 case elfcpp::R_MIPS_HI16: 10472 case elfcpp::R_MIPS_PCHI16: 10473 case elfcpp::R_MIPS16_HI16: 10474 case elfcpp::R_MICROMIPS_HI16: 10475 // Record the reloc so that we can check whether the corresponding LO16 10476 // part exists. 10477 if (rel_type == elfcpp::SHT_REL) 10478 target->got16_addends_.push_back(got16_addend<size, big_endian>( 10479 object, data_shndx, r_type, r_sym, 0)); 10480 break; 10481 10482 case elfcpp::R_MIPS_LO16: 10483 case elfcpp::R_MIPS_PCLO16: 10484 case elfcpp::R_MIPS16_LO16: 10485 case elfcpp::R_MICROMIPS_LO16: 10486 { 10487 if (rel_type != elfcpp::SHT_REL) 10488 break; 10489 10490 // Find corresponding GOT16/HI16 relocation. 10491 10492 // According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must 10493 // be immediately following. However, for the IRIX6 ABI, the next 10494 // relocation may be a composed relocation consisting of several 10495 // relocations for the same address. In that case, the R_MIPS_LO16 10496 // relocation may occur as one of these. We permit a similar 10497 // extension in general, as that is useful for GCC. 10498 10499 // In some cases GCC dead code elimination removes the LO16 but 10500 // keeps the corresponding HI16. This is strictly speaking a 10501 // violation of the ABI but not immediately harmful. 10502 10503 typename std::list<got16_addend<size, big_endian> >::iterator it = 10504 target->got16_addends_.begin(); 10505 while (it != target->got16_addends_.end()) 10506 { 10507 got16_addend<size, big_endian> _got16_addend = *it; 10508 10509 // TODO(sasa): Split got16_addends_ list into two lists - one for 10510 // GOT16 relocs and the other for HI16 relocs. 10511 10512 // Report an error if we find HI16 or GOT16 reloc from the 10513 // previous section without the matching LO16 part. 10514 if (_got16_addend.object != object 10515 || _got16_addend.shndx != data_shndx) 10516 { 10517 gold_error("Can't find matching LO16 reloc"); 10518 break; 10519 } 10520 10521 if (_got16_addend.r_sym != r_sym 10522 || !is_matching_lo16_reloc(_got16_addend.r_type, r_type)) 10523 { 10524 ++it; 10525 continue; 10526 } 10527 10528 // We found a matching HI16 or GOT16 reloc for this LO16 reloc. 10529 // For GOT16, we need to calculate combined addend and record GOT page 10530 // entry. 10531 if (got16_reloc(_got16_addend.r_type)) 10532 { 10533 10534 section_size_type view_size = 0; 10535 const unsigned char* view = object->section_contents(data_shndx, 10536 &view_size, 10537 false); 10538 view += r_offset; 10539 10540 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 10541 int32_t addend = Bits<16>::sign_extend32(val & 0xffff); 10542 10543 addend = (_got16_addend.addend << 16) + addend; 10544 target->got_section()->record_got_page_entry(mips_obj, r_sym, 10545 addend); 10546 } 10547 10548 it = target->got16_addends_.erase(it); 10549 } 10550 break; 10551 } 10552 } 10553 10554 switch (r_type) 10555 { 10556 case elfcpp::R_MIPS_32: 10557 case elfcpp::R_MIPS_REL32: 10558 case elfcpp::R_MIPS_64: 10559 { 10560 if (parameters->options().output_is_position_independent()) 10561 { 10562 // If building a shared library (or a position-independent 10563 // executable), we need to create a dynamic relocation for 10564 // this location. 10565 if (is_readonly_section(output_section)) 10566 break; 10567 Reloc_section* rel_dyn = target->rel_dyn_section(layout); 10568 rel_dyn->add_symbolless_local_addend(object, r_sym, 10569 elfcpp::R_MIPS_REL32, 10570 output_section, data_shndx, 10571 r_offset); 10572 } 10573 break; 10574 } 10575 10576 case elfcpp::R_MIPS_TLS_GOTTPREL: 10577 case elfcpp::R_MIPS16_TLS_GOTTPREL: 10578 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 10579 case elfcpp::R_MIPS_TLS_LDM: 10580 case elfcpp::R_MIPS16_TLS_LDM: 10581 case elfcpp::R_MICROMIPS_TLS_LDM: 10582 case elfcpp::R_MIPS_TLS_GD: 10583 case elfcpp::R_MIPS16_TLS_GD: 10584 case elfcpp::R_MICROMIPS_TLS_GD: 10585 { 10586 bool output_is_shared = parameters->options().shared(); 10587 const tls::Tls_optimization optimized_type 10588 = Target_mips<size, big_endian>::optimize_tls_reloc( 10589 !output_is_shared, r_type); 10590 switch (r_type) 10591 { 10592 case elfcpp::R_MIPS_TLS_GD: 10593 case elfcpp::R_MIPS16_TLS_GD: 10594 case elfcpp::R_MICROMIPS_TLS_GD: 10595 if (optimized_type == tls::TLSOPT_NONE) 10596 { 10597 // Create a pair of GOT entries for the module index and 10598 // dtv-relative offset. 10599 Mips_output_data_got<size, big_endian>* got = 10600 target->got_section(symtab, layout); 10601 unsigned int shndx = lsym.get_st_shndx(); 10602 bool is_ordinary; 10603 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary); 10604 if (!is_ordinary) 10605 { 10606 object->error(_("local symbol %u has bad shndx %u"), 10607 r_sym, shndx); 10608 break; 10609 } 10610 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type, 10611 shndx, false); 10612 } 10613 else 10614 { 10615 // FIXME: TLS optimization not supported yet. 10616 gold_unreachable(); 10617 } 10618 break; 10619 10620 case elfcpp::R_MIPS_TLS_LDM: 10621 case elfcpp::R_MIPS16_TLS_LDM: 10622 case elfcpp::R_MICROMIPS_TLS_LDM: 10623 if (optimized_type == tls::TLSOPT_NONE) 10624 { 10625 // We always record LDM symbols as local with index 0. 10626 target->got_section()->record_local_got_symbol(mips_obj, 0, 10627 r_addend, r_type, 10628 -1U, false); 10629 } 10630 else 10631 { 10632 // FIXME: TLS optimization not supported yet. 10633 gold_unreachable(); 10634 } 10635 break; 10636 case elfcpp::R_MIPS_TLS_GOTTPREL: 10637 case elfcpp::R_MIPS16_TLS_GOTTPREL: 10638 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 10639 layout->set_has_static_tls(); 10640 if (optimized_type == tls::TLSOPT_NONE) 10641 { 10642 // Create a GOT entry for the tp-relative offset. 10643 Mips_output_data_got<size, big_endian>* got = 10644 target->got_section(symtab, layout); 10645 got->record_local_got_symbol(mips_obj, r_sym, r_addend, r_type, 10646 -1U, false); 10647 } 10648 else 10649 { 10650 // FIXME: TLS optimization not supported yet. 10651 gold_unreachable(); 10652 } 10653 break; 10654 10655 default: 10656 gold_unreachable(); 10657 } 10658 } 10659 break; 10660 10661 default: 10662 break; 10663 } 10664 10665 // Refuse some position-dependent relocations when creating a 10666 // shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're 10667 // not PIC, but we can create dynamic relocations and the result 10668 // will be fine. Also do not refuse R_MIPS_LO16, which can be 10669 // combined with R_MIPS_GOT16. 10670 if (parameters->options().shared()) 10671 { 10672 switch (r_type) 10673 { 10674 case elfcpp::R_MIPS16_HI16: 10675 case elfcpp::R_MIPS_HI16: 10676 case elfcpp::R_MICROMIPS_HI16: 10677 // Don't refuse a high part relocation if it's against 10678 // no symbol (e.g. part of a compound relocation). 10679 if (r_sym == 0) 10680 break; 10681 // Fall through. 10682 10683 case elfcpp::R_MIPS16_26: 10684 case elfcpp::R_MIPS_26: 10685 case elfcpp::R_MICROMIPS_26_S1: 10686 gold_error(_("%s: relocation %u against `%s' can not be used when " 10687 "making a shared object; recompile with -fPIC"), 10688 object->name().c_str(), r_type, "a local symbol"); 10689 default: 10690 break; 10691 } 10692 } 10693} 10694 10695template<int size, bool big_endian> 10696inline void 10697Target_mips<size, big_endian>::Scan::local( 10698 Symbol_table* symtab, 10699 Layout* layout, 10700 Target_mips<size, big_endian>* target, 10701 Sized_relobj_file<size, big_endian>* object, 10702 unsigned int data_shndx, 10703 Output_section* output_section, 10704 const Reltype& reloc, 10705 unsigned int r_type, 10706 const elfcpp::Sym<size, big_endian>& lsym, 10707 bool is_discarded) 10708{ 10709 if (is_discarded) 10710 return; 10711 10712 local( 10713 symtab, 10714 layout, 10715 target, 10716 object, 10717 data_shndx, 10718 output_section, 10719 (const Relatype*) NULL, 10720 &reloc, 10721 elfcpp::SHT_REL, 10722 r_type, 10723 lsym, is_discarded); 10724} 10725 10726 10727template<int size, bool big_endian> 10728inline void 10729Target_mips<size, big_endian>::Scan::local( 10730 Symbol_table* symtab, 10731 Layout* layout, 10732 Target_mips<size, big_endian>* target, 10733 Sized_relobj_file<size, big_endian>* object, 10734 unsigned int data_shndx, 10735 Output_section* output_section, 10736 const Relatype& reloc, 10737 unsigned int r_type, 10738 const elfcpp::Sym<size, big_endian>& lsym, 10739 bool is_discarded) 10740{ 10741 if (is_discarded) 10742 return; 10743 10744 local( 10745 symtab, 10746 layout, 10747 target, 10748 object, 10749 data_shndx, 10750 output_section, 10751 &reloc, 10752 (const Reltype*) NULL, 10753 elfcpp::SHT_RELA, 10754 r_type, 10755 lsym, is_discarded); 10756} 10757 10758// Scan a relocation for a global symbol. 10759 10760template<int size, bool big_endian> 10761inline void 10762Target_mips<size, big_endian>::Scan::global( 10763 Symbol_table* symtab, 10764 Layout* layout, 10765 Target_mips<size, big_endian>* target, 10766 Sized_relobj_file<size, big_endian>* object, 10767 unsigned int data_shndx, 10768 Output_section* output_section, 10769 const Relatype* rela, 10770 const Reltype* rel, 10771 unsigned int rel_type, 10772 unsigned int r_type, 10773 Symbol* gsym) 10774{ 10775 Mips_address r_offset; 10776 unsigned int r_sym; 10777 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend; 10778 10779 if (rel_type == elfcpp::SHT_RELA) 10780 { 10781 r_offset = rela->get_r_offset(); 10782 r_sym = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 10783 get_r_sym(rela); 10784 r_addend = rela->get_r_addend(); 10785 } 10786 else 10787 { 10788 r_offset = rel->get_r_offset(); 10789 r_sym = Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian>:: 10790 get_r_sym(rel); 10791 r_addend = 0; 10792 } 10793 10794 Mips_relobj<size, big_endian>* mips_obj = 10795 Mips_relobj<size, big_endian>::as_mips_relobj(object); 10796 Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym); 10797 10798 if (mips_obj->is_mips16_stub_section(data_shndx)) 10799 { 10800 mips_obj->get_mips16_stub_section(data_shndx) 10801 ->new_global_reloc_found(r_type, mips_sym); 10802 } 10803 10804 if (r_type == elfcpp::R_MIPS_NONE) 10805 // R_MIPS_NONE is used in mips16 stub sections, to define the target of the 10806 // mips16 stub. 10807 return; 10808 10809 if (!mips16_call_reloc(r_type) 10810 && !mips_obj->section_allows_mips16_refs(data_shndx)) 10811 // This reloc would need to refer to a MIPS16 hard-float stub, if 10812 // there is one. We ignore MIPS16 stub sections and .pdr section when 10813 // looking for relocs that would need to refer to MIPS16 stubs. 10814 mips_sym->set_need_fn_stub(); 10815 10816 // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got 10817 // section. We check here to avoid creating a dynamic reloc against 10818 // _GLOBAL_OFFSET_TABLE_. 10819 if (!target->has_got_section() 10820 && strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0) 10821 target->got_section(symtab, layout); 10822 10823 // We need PLT entries if there are static-only relocations against 10824 // an externally-defined function. This can technically occur for 10825 // shared libraries if there are branches to the symbol, although it 10826 // is unlikely that this will be used in practice due to the short 10827 // ranges involved. It can occur for any relative or absolute relocation 10828 // in executables; in that case, the PLT entry becomes the function's 10829 // canonical address. 10830 bool static_reloc = false; 10831 10832 // Set CAN_MAKE_DYNAMIC to true if we can convert this 10833 // relocation into a dynamic one. 10834 bool can_make_dynamic = false; 10835 switch (r_type) 10836 { 10837 case elfcpp::R_MIPS_GOT16: 10838 case elfcpp::R_MIPS_CALL16: 10839 case elfcpp::R_MIPS_CALL_HI16: 10840 case elfcpp::R_MIPS_CALL_LO16: 10841 case elfcpp::R_MIPS_GOT_HI16: 10842 case elfcpp::R_MIPS_GOT_LO16: 10843 case elfcpp::R_MIPS_GOT_PAGE: 10844 case elfcpp::R_MIPS_GOT_OFST: 10845 case elfcpp::R_MIPS_GOT_DISP: 10846 case elfcpp::R_MIPS_TLS_GOTTPREL: 10847 case elfcpp::R_MIPS_TLS_GD: 10848 case elfcpp::R_MIPS_TLS_LDM: 10849 case elfcpp::R_MIPS16_GOT16: 10850 case elfcpp::R_MIPS16_CALL16: 10851 case elfcpp::R_MIPS16_TLS_GOTTPREL: 10852 case elfcpp::R_MIPS16_TLS_GD: 10853 case elfcpp::R_MIPS16_TLS_LDM: 10854 case elfcpp::R_MICROMIPS_GOT16: 10855 case elfcpp::R_MICROMIPS_CALL16: 10856 case elfcpp::R_MICROMIPS_CALL_HI16: 10857 case elfcpp::R_MICROMIPS_CALL_LO16: 10858 case elfcpp::R_MICROMIPS_GOT_HI16: 10859 case elfcpp::R_MICROMIPS_GOT_LO16: 10860 case elfcpp::R_MICROMIPS_GOT_PAGE: 10861 case elfcpp::R_MICROMIPS_GOT_OFST: 10862 case elfcpp::R_MICROMIPS_GOT_DISP: 10863 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 10864 case elfcpp::R_MICROMIPS_TLS_GD: 10865 case elfcpp::R_MICROMIPS_TLS_LDM: 10866 case elfcpp::R_MIPS_EH: 10867 // We need a GOT section. 10868 target->got_section(symtab, layout); 10869 break; 10870 10871 // This is just a hint; it can safely be ignored. Don't set 10872 // has_static_relocs for the corresponding symbol. 10873 case elfcpp::R_MIPS_JALR: 10874 case elfcpp::R_MICROMIPS_JALR: 10875 break; 10876 10877 case elfcpp::R_MIPS_GPREL16: 10878 case elfcpp::R_MIPS_GPREL32: 10879 case elfcpp::R_MIPS16_GPREL: 10880 case elfcpp::R_MICROMIPS_GPREL16: 10881 // TODO(sasa) 10882 // GP-relative relocations always resolve to a definition in a 10883 // regular input file, ignoring the one-definition rule. This is 10884 // important for the GP setup sequence in NewABI code, which 10885 // always resolves to a local function even if other relocations 10886 // against the symbol wouldn't. 10887 //constrain_symbol_p = FALSE; 10888 break; 10889 10890 case elfcpp::R_MIPS_32: 10891 case elfcpp::R_MIPS_REL32: 10892 case elfcpp::R_MIPS_64: 10893 if ((parameters->options().shared() 10894 || (strcmp(gsym->name(), "__gnu_local_gp") != 0 10895 && (!is_readonly_section(output_section) 10896 || mips_obj->is_pic()))) 10897 && (output_section->flags() & elfcpp::SHF_ALLOC) != 0) 10898 { 10899 if (r_type != elfcpp::R_MIPS_REL32) 10900 mips_sym->set_pointer_equality_needed(); 10901 can_make_dynamic = true; 10902 break; 10903 } 10904 // Fall through. 10905 10906 default: 10907 // Most static relocations require pointer equality, except 10908 // for branches. 10909 mips_sym->set_pointer_equality_needed(); 10910 // Fall through. 10911 10912 case elfcpp::R_MIPS_26: 10913 case elfcpp::R_MIPS_PC16: 10914 case elfcpp::R_MIPS_PC21_S2: 10915 case elfcpp::R_MIPS_PC26_S2: 10916 case elfcpp::R_MIPS16_26: 10917 case elfcpp::R_MICROMIPS_26_S1: 10918 case elfcpp::R_MICROMIPS_PC7_S1: 10919 case elfcpp::R_MICROMIPS_PC10_S1: 10920 case elfcpp::R_MICROMIPS_PC16_S1: 10921 case elfcpp::R_MICROMIPS_PC23_S2: 10922 static_reloc = true; 10923 mips_sym->set_has_static_relocs(); 10924 break; 10925 } 10926 10927 // If there are call relocations against an externally-defined symbol, 10928 // see whether we can create a MIPS lazy-binding stub for it. We can 10929 // only do this if all references to the function are through call 10930 // relocations, and in that case, the traditional lazy-binding stubs 10931 // are much more efficient than PLT entries. 10932 switch (r_type) 10933 { 10934 case elfcpp::R_MIPS16_CALL16: 10935 case elfcpp::R_MIPS_CALL16: 10936 case elfcpp::R_MIPS_CALL_HI16: 10937 case elfcpp::R_MIPS_CALL_LO16: 10938 case elfcpp::R_MIPS_JALR: 10939 case elfcpp::R_MICROMIPS_CALL16: 10940 case elfcpp::R_MICROMIPS_CALL_HI16: 10941 case elfcpp::R_MICROMIPS_CALL_LO16: 10942 case elfcpp::R_MICROMIPS_JALR: 10943 if (!mips_sym->no_lazy_stub()) 10944 { 10945 if ((mips_sym->needs_plt_entry() && mips_sym->is_from_dynobj()) 10946 // Calls from shared objects to undefined symbols of type 10947 // STT_NOTYPE need lazy-binding stub. 10948 || (mips_sym->is_undefined() && parameters->options().shared())) 10949 target->mips_stubs_section(layout)->make_entry(mips_sym); 10950 } 10951 break; 10952 default: 10953 { 10954 // We must not create a stub for a symbol that has relocations 10955 // related to taking the function's address. 10956 mips_sym->set_no_lazy_stub(); 10957 target->remove_lazy_stub_entry(mips_sym); 10958 break; 10959 } 10960 } 10961 10962 if (relocation_needs_la25_stub<size, big_endian>(mips_obj, r_type, 10963 mips_sym->is_mips16())) 10964 mips_sym->set_has_nonpic_branches(); 10965 10966 // R_MIPS_HI16 against _gp_disp is used for $gp setup, 10967 // and has a special meaning. 10968 bool gp_disp_against_hi16 = (!mips_obj->is_newabi() 10969 && strcmp(gsym->name(), "_gp_disp") == 0 10970 && (hi16_reloc(r_type) || lo16_reloc(r_type))); 10971 if (static_reloc && gsym->needs_plt_entry()) 10972 { 10973 target->make_plt_entry(symtab, layout, mips_sym, r_type); 10974 10975 // Since this is not a PC-relative relocation, we may be 10976 // taking the address of a function. In that case we need to 10977 // set the entry in the dynamic symbol table to the address of 10978 // the PLT entry. 10979 if (gsym->is_from_dynobj() && !parameters->options().shared()) 10980 { 10981 gsym->set_needs_dynsym_value(); 10982 // We distinguish between PLT entries and lazy-binding stubs by 10983 // giving the former an st_other value of STO_MIPS_PLT. Set the 10984 // flag if there are any relocations in the binary where pointer 10985 // equality matters. 10986 if (mips_sym->pointer_equality_needed()) 10987 mips_sym->set_mips_plt(); 10988 } 10989 } 10990 if ((static_reloc || can_make_dynamic) && !gp_disp_against_hi16) 10991 { 10992 // Absolute addressing relocations. 10993 // Make a dynamic relocation if necessary. 10994 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))) 10995 { 10996 if (gsym->may_need_copy_reloc()) 10997 { 10998 target->copy_reloc(symtab, layout, object, data_shndx, 10999 output_section, gsym, r_type, r_offset); 11000 } 11001 else if (can_make_dynamic) 11002 { 11003 // Create .rel.dyn section. 11004 target->rel_dyn_section(layout); 11005 target->dynamic_reloc(mips_sym, elfcpp::R_MIPS_REL32, mips_obj, 11006 data_shndx, output_section, r_offset); 11007 } 11008 else 11009 gold_error(_("non-dynamic relocations refer to dynamic symbol %s"), 11010 gsym->name()); 11011 } 11012 } 11013 11014 bool for_call = false; 11015 switch (r_type) 11016 { 11017 case elfcpp::R_MIPS_CALL16: 11018 case elfcpp::R_MIPS16_CALL16: 11019 case elfcpp::R_MICROMIPS_CALL16: 11020 case elfcpp::R_MIPS_CALL_HI16: 11021 case elfcpp::R_MIPS_CALL_LO16: 11022 case elfcpp::R_MICROMIPS_CALL_HI16: 11023 case elfcpp::R_MICROMIPS_CALL_LO16: 11024 for_call = true; 11025 // Fall through. 11026 11027 case elfcpp::R_MIPS16_GOT16: 11028 case elfcpp::R_MIPS_GOT16: 11029 case elfcpp::R_MIPS_GOT_HI16: 11030 case elfcpp::R_MIPS_GOT_LO16: 11031 case elfcpp::R_MICROMIPS_GOT16: 11032 case elfcpp::R_MICROMIPS_GOT_HI16: 11033 case elfcpp::R_MICROMIPS_GOT_LO16: 11034 case elfcpp::R_MIPS_GOT_DISP: 11035 case elfcpp::R_MICROMIPS_GOT_DISP: 11036 case elfcpp::R_MIPS_EH: 11037 { 11038 // The symbol requires a GOT entry. 11039 Mips_output_data_got<size, big_endian>* got = 11040 target->got_section(symtab, layout); 11041 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false, 11042 for_call); 11043 mips_sym->set_global_got_area(GGA_NORMAL); 11044 } 11045 break; 11046 11047 case elfcpp::R_MIPS_GOT_PAGE: 11048 case elfcpp::R_MICROMIPS_GOT_PAGE: 11049 { 11050 // This relocation needs a page entry in the GOT. 11051 // Get the section contents. 11052 section_size_type view_size = 0; 11053 const unsigned char* view = 11054 object->section_contents(data_shndx, &view_size, false); 11055 view += r_offset; 11056 11057 Valtype32 val = elfcpp::Swap<32, big_endian>::readval(view); 11058 Valtype32 addend = (rel_type == elfcpp::SHT_REL ? val & 0xffff 11059 : r_addend); 11060 Mips_output_data_got<size, big_endian>* got = 11061 target->got_section(symtab, layout); 11062 got->record_got_page_entry(mips_obj, r_sym, addend); 11063 11064 // If this is a global, overridable symbol, GOT_PAGE will 11065 // decay to GOT_DISP, so we'll need a GOT entry for it. 11066 bool def_regular = (mips_sym->source() == Symbol::FROM_OBJECT 11067 && !mips_sym->object()->is_dynamic() 11068 && !mips_sym->is_undefined()); 11069 if (!def_regular 11070 || (parameters->options().output_is_position_independent() 11071 && !parameters->options().Bsymbolic() 11072 && !mips_sym->is_forced_local())) 11073 { 11074 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false, 11075 for_call); 11076 mips_sym->set_global_got_area(GGA_NORMAL); 11077 } 11078 } 11079 break; 11080 11081 case elfcpp::R_MIPS_TLS_GOTTPREL: 11082 case elfcpp::R_MIPS16_TLS_GOTTPREL: 11083 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 11084 case elfcpp::R_MIPS_TLS_LDM: 11085 case elfcpp::R_MIPS16_TLS_LDM: 11086 case elfcpp::R_MICROMIPS_TLS_LDM: 11087 case elfcpp::R_MIPS_TLS_GD: 11088 case elfcpp::R_MIPS16_TLS_GD: 11089 case elfcpp::R_MICROMIPS_TLS_GD: 11090 { 11091 const bool is_final = gsym->final_value_is_known(); 11092 const tls::Tls_optimization optimized_type = 11093 Target_mips<size, big_endian>::optimize_tls_reloc(is_final, r_type); 11094 11095 switch (r_type) 11096 { 11097 case elfcpp::R_MIPS_TLS_GD: 11098 case elfcpp::R_MIPS16_TLS_GD: 11099 case elfcpp::R_MICROMIPS_TLS_GD: 11100 if (optimized_type == tls::TLSOPT_NONE) 11101 { 11102 // Create a pair of GOT entries for the module index and 11103 // dtv-relative offset. 11104 Mips_output_data_got<size, big_endian>* got = 11105 target->got_section(symtab, layout); 11106 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false, 11107 false); 11108 } 11109 else 11110 { 11111 // FIXME: TLS optimization not supported yet. 11112 gold_unreachable(); 11113 } 11114 break; 11115 11116 case elfcpp::R_MIPS_TLS_LDM: 11117 case elfcpp::R_MIPS16_TLS_LDM: 11118 case elfcpp::R_MICROMIPS_TLS_LDM: 11119 if (optimized_type == tls::TLSOPT_NONE) 11120 { 11121 // We always record LDM symbols as local with index 0. 11122 target->got_section()->record_local_got_symbol(mips_obj, 0, 11123 r_addend, r_type, 11124 -1U, false); 11125 } 11126 else 11127 { 11128 // FIXME: TLS optimization not supported yet. 11129 gold_unreachable(); 11130 } 11131 break; 11132 case elfcpp::R_MIPS_TLS_GOTTPREL: 11133 case elfcpp::R_MIPS16_TLS_GOTTPREL: 11134 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 11135 layout->set_has_static_tls(); 11136 if (optimized_type == tls::TLSOPT_NONE) 11137 { 11138 // Create a GOT entry for the tp-relative offset. 11139 Mips_output_data_got<size, big_endian>* got = 11140 target->got_section(symtab, layout); 11141 got->record_global_got_symbol(mips_sym, mips_obj, r_type, false, 11142 false); 11143 } 11144 else 11145 { 11146 // FIXME: TLS optimization not supported yet. 11147 gold_unreachable(); 11148 } 11149 break; 11150 11151 default: 11152 gold_unreachable(); 11153 } 11154 } 11155 break; 11156 case elfcpp::R_MIPS_COPY: 11157 case elfcpp::R_MIPS_JUMP_SLOT: 11158 // These are relocations which should only be seen by the 11159 // dynamic linker, and should never be seen here. 11160 gold_error(_("%s: unexpected reloc %u in object file"), 11161 object->name().c_str(), r_type); 11162 break; 11163 11164 default: 11165 break; 11166 } 11167 11168 // Refuse some position-dependent relocations when creating a 11169 // shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're 11170 // not PIC, but we can create dynamic relocations and the result 11171 // will be fine. Also do not refuse R_MIPS_LO16, which can be 11172 // combined with R_MIPS_GOT16. 11173 if (parameters->options().shared()) 11174 { 11175 switch (r_type) 11176 { 11177 case elfcpp::R_MIPS16_HI16: 11178 case elfcpp::R_MIPS_HI16: 11179 case elfcpp::R_MICROMIPS_HI16: 11180 // Don't refuse a high part relocation if it's against 11181 // no symbol (e.g. part of a compound relocation). 11182 if (r_sym == 0) 11183 break; 11184 11185 // R_MIPS_HI16 against _gp_disp is used for $gp setup, 11186 // and has a special meaning. 11187 if (!mips_obj->is_newabi() && strcmp(gsym->name(), "_gp_disp") == 0) 11188 break; 11189 // Fall through. 11190 11191 case elfcpp::R_MIPS16_26: 11192 case elfcpp::R_MIPS_26: 11193 case elfcpp::R_MICROMIPS_26_S1: 11194 gold_error(_("%s: relocation %u against `%s' can not be used when " 11195 "making a shared object; recompile with -fPIC"), 11196 object->name().c_str(), r_type, gsym->name()); 11197 default: 11198 break; 11199 } 11200 } 11201} 11202 11203template<int size, bool big_endian> 11204inline void 11205Target_mips<size, big_endian>::Scan::global( 11206 Symbol_table* symtab, 11207 Layout* layout, 11208 Target_mips<size, big_endian>* target, 11209 Sized_relobj_file<size, big_endian>* object, 11210 unsigned int data_shndx, 11211 Output_section* output_section, 11212 const Relatype& reloc, 11213 unsigned int r_type, 11214 Symbol* gsym) 11215{ 11216 global( 11217 symtab, 11218 layout, 11219 target, 11220 object, 11221 data_shndx, 11222 output_section, 11223 &reloc, 11224 (const Reltype*) NULL, 11225 elfcpp::SHT_RELA, 11226 r_type, 11227 gsym); 11228} 11229 11230template<int size, bool big_endian> 11231inline void 11232Target_mips<size, big_endian>::Scan::global( 11233 Symbol_table* symtab, 11234 Layout* layout, 11235 Target_mips<size, big_endian>* target, 11236 Sized_relobj_file<size, big_endian>* object, 11237 unsigned int data_shndx, 11238 Output_section* output_section, 11239 const Reltype& reloc, 11240 unsigned int r_type, 11241 Symbol* gsym) 11242{ 11243 global( 11244 symtab, 11245 layout, 11246 target, 11247 object, 11248 data_shndx, 11249 output_section, 11250 (const Relatype*) NULL, 11251 &reloc, 11252 elfcpp::SHT_REL, 11253 r_type, 11254 gsym); 11255} 11256 11257// Return whether a R_MIPS_32/R_MIPS64 relocation needs to be applied. 11258// In cases where Scan::local() or Scan::global() has created 11259// a dynamic relocation, the addend of the relocation is carried 11260// in the data, and we must not apply the static relocation. 11261 11262template<int size, bool big_endian> 11263inline bool 11264Target_mips<size, big_endian>::Relocate::should_apply_static_reloc( 11265 const Mips_symbol<size>* gsym, 11266 unsigned int r_type, 11267 Output_section* output_section, 11268 Target_mips* target) 11269{ 11270 // If the output section is not allocated, then we didn't call 11271 // scan_relocs, we didn't create a dynamic reloc, and we must apply 11272 // the reloc here. 11273 if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0) 11274 return true; 11275 11276 if (gsym == NULL) 11277 return true; 11278 else 11279 { 11280 // For global symbols, we use the same helper routines used in the 11281 // scan pass. 11282 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)) 11283 && !gsym->may_need_copy_reloc()) 11284 { 11285 // We have generated dynamic reloc (R_MIPS_REL32). 11286 11287 bool multi_got = false; 11288 if (target->has_got_section()) 11289 multi_got = target->got_section()->multi_got(); 11290 bool has_got_offset; 11291 if (!multi_got) 11292 has_got_offset = gsym->has_got_offset(GOT_TYPE_STANDARD); 11293 else 11294 has_got_offset = gsym->global_gotoffset() != -1U; 11295 if (!has_got_offset) 11296 return true; 11297 else 11298 // Apply the relocation only if the symbol is in the local got. 11299 // Do not apply the relocation if the symbol is in the global 11300 // got. 11301 return symbol_references_local(gsym, gsym->has_dynsym_index()); 11302 } 11303 else 11304 // We have not generated dynamic reloc. 11305 return true; 11306 } 11307} 11308 11309// Perform a relocation. 11310 11311template<int size, bool big_endian> 11312inline bool 11313Target_mips<size, big_endian>::Relocate::relocate( 11314 const Relocate_info<size, big_endian>* relinfo, 11315 unsigned int rel_type, 11316 Target_mips* target, 11317 Output_section* output_section, 11318 size_t relnum, 11319 const unsigned char* preloc, 11320 const Sized_symbol<size>* gsym, 11321 const Symbol_value<size>* psymval, 11322 unsigned char* view, 11323 Mips_address address, 11324 section_size_type) 11325{ 11326 Mips_address r_offset; 11327 unsigned int r_sym; 11328 unsigned int r_type; 11329 unsigned int r_type2; 11330 unsigned int r_type3; 11331 unsigned char r_ssym; 11332 typename elfcpp::Elf_types<size>::Elf_Swxword r_addend; 11333 11334 if (rel_type == elfcpp::SHT_RELA) 11335 { 11336 const Relatype rela(preloc); 11337 r_offset = rela.get_r_offset(); 11338 r_sym = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 11339 get_r_sym(&rela); 11340 r_type = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 11341 get_r_type(&rela); 11342 r_type2 = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 11343 get_r_type2(&rela); 11344 r_type3 = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 11345 get_r_type3(&rela); 11346 r_ssym = Mips_classify_reloc<elfcpp::SHT_RELA, size, big_endian>:: 11347 get_r_ssym(&rela); 11348 r_addend = rela.get_r_addend(); 11349 } 11350 else 11351 { 11352 const Reltype rel(preloc); 11353 r_offset = rel.get_r_offset(); 11354 r_sym = Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian>:: 11355 get_r_sym(&rel); 11356 r_type = Mips_classify_reloc<elfcpp::SHT_REL, size, big_endian>:: 11357 get_r_type(&rel); 11358 r_ssym = 0; 11359 r_type2 = 0; 11360 r_type3 = 0; 11361 r_addend = 0; 11362 } 11363 11364 typedef Mips_relocate_functions<size, big_endian> Reloc_funcs; 11365 typename Reloc_funcs::Status reloc_status = Reloc_funcs::STATUS_OKAY; 11366 11367 Mips_relobj<size, big_endian>* object = 11368 Mips_relobj<size, big_endian>::as_mips_relobj(relinfo->object); 11369 11370 bool target_is_16_bit_code = false; 11371 bool target_is_micromips_code = false; 11372 bool cross_mode_jump; 11373 11374 Symbol_value<size> symval; 11375 11376 const Mips_symbol<size>* mips_sym = Mips_symbol<size>::as_mips_sym(gsym); 11377 11378 bool changed_symbol_value = false; 11379 if (gsym == NULL) 11380 { 11381 target_is_16_bit_code = object->local_symbol_is_mips16(r_sym); 11382 target_is_micromips_code = object->local_symbol_is_micromips(r_sym); 11383 if (target_is_16_bit_code || target_is_micromips_code) 11384 { 11385 // MIPS16/microMIPS text labels should be treated as odd. 11386 symval.set_output_value(psymval->value(object, 1)); 11387 psymval = &symval; 11388 changed_symbol_value = true; 11389 } 11390 } 11391 else 11392 { 11393 target_is_16_bit_code = mips_sym->is_mips16(); 11394 target_is_micromips_code = mips_sym->is_micromips(); 11395 11396 // If this is a mips16/microMIPS text symbol, add 1 to the value to make 11397 // it odd. This will cause something like .word SYM to come up with 11398 // the right value when it is loaded into the PC. 11399 11400 if ((mips_sym->is_mips16() || mips_sym->is_micromips()) 11401 && psymval->value(object, 0) != 0) 11402 { 11403 symval.set_output_value(psymval->value(object, 0) | 1); 11404 psymval = &symval; 11405 changed_symbol_value = true; 11406 } 11407 11408 // Pick the value to use for symbols defined in shared objects. 11409 if (mips_sym->use_plt_offset(Scan::get_reference_flags(r_type)) 11410 || mips_sym->has_lazy_stub()) 11411 { 11412 Mips_address value; 11413 if (!mips_sym->has_lazy_stub()) 11414 { 11415 // Prefer a standard MIPS PLT entry. 11416 if (mips_sym->has_mips_plt_offset()) 11417 { 11418 value = target->plt_section()->mips_entry_address(mips_sym); 11419 target_is_micromips_code = false; 11420 target_is_16_bit_code = false; 11421 } 11422 else 11423 { 11424 value = (target->plt_section()->comp_entry_address(mips_sym) 11425 + 1); 11426 if (target->is_output_micromips()) 11427 target_is_micromips_code = true; 11428 else 11429 target_is_16_bit_code = true; 11430 } 11431 } 11432 else 11433 value = target->mips_stubs_section()->stub_address(mips_sym); 11434 11435 symval.set_output_value(value); 11436 psymval = &symval; 11437 } 11438 } 11439 11440 // TRUE if the symbol referred to by this relocation is "_gp_disp". 11441 // Note that such a symbol must always be a global symbol. 11442 bool gp_disp = (gsym != NULL && (strcmp(gsym->name(), "_gp_disp") == 0) 11443 && !object->is_newabi()); 11444 11445 // TRUE if the symbol referred to by this relocation is "__gnu_local_gp". 11446 // Note that such a symbol must always be a global symbol. 11447 bool gnu_local_gp = gsym && (strcmp(gsym->name(), "__gnu_local_gp") == 0); 11448 11449 11450 if (gp_disp) 11451 { 11452 if (!hi16_reloc(r_type) && !lo16_reloc(r_type)) 11453 gold_error_at_location(relinfo, relnum, r_offset, 11454 _("relocations against _gp_disp are permitted only" 11455 " with R_MIPS_HI16 and R_MIPS_LO16 relocations.")); 11456 } 11457 else if (gnu_local_gp) 11458 { 11459 // __gnu_local_gp is _gp symbol. 11460 symval.set_output_value(target->adjusted_gp_value(object)); 11461 psymval = &symval; 11462 } 11463 11464 // If this is a reference to a 16-bit function with a stub, we need 11465 // to redirect the relocation to the stub unless: 11466 // 11467 // (a) the relocation is for a MIPS16 JAL; 11468 // 11469 // (b) the relocation is for a MIPS16 PIC call, and there are no 11470 // non-MIPS16 uses of the GOT slot; or 11471 // 11472 // (c) the section allows direct references to MIPS16 functions. 11473 if (r_type != elfcpp::R_MIPS16_26 11474 && !parameters->options().relocatable() 11475 && ((mips_sym != NULL 11476 && mips_sym->has_mips16_fn_stub() 11477 && (r_type != elfcpp::R_MIPS16_CALL16 || mips_sym->need_fn_stub())) 11478 || (mips_sym == NULL 11479 && object->get_local_mips16_fn_stub(r_sym) != NULL)) 11480 && !object->section_allows_mips16_refs(relinfo->data_shndx)) 11481 { 11482 // This is a 32- or 64-bit call to a 16-bit function. We should 11483 // have already noticed that we were going to need the 11484 // stub. 11485 Mips_address value; 11486 if (mips_sym == NULL) 11487 value = object->get_local_mips16_fn_stub(r_sym)->output_address(); 11488 else 11489 { 11490 gold_assert(mips_sym->need_fn_stub()); 11491 if (mips_sym->has_la25_stub()) 11492 value = target->la25_stub_section()->stub_address(mips_sym); 11493 else 11494 { 11495 value = mips_sym->template 11496 get_mips16_fn_stub<big_endian>()->output_address(); 11497 } 11498 } 11499 symval.set_output_value(value); 11500 psymval = &symval; 11501 changed_symbol_value = true; 11502 11503 // The target is 16-bit, but the stub isn't. 11504 target_is_16_bit_code = false; 11505 } 11506 // If this is a MIPS16 call with a stub, that is made through the PLT or 11507 // to a standard MIPS function, we need to redirect the call to the stub. 11508 // Note that we specifically exclude R_MIPS16_CALL16 from this behavior; 11509 // indirect calls should use an indirect stub instead. 11510 else if (r_type == elfcpp::R_MIPS16_26 && !parameters->options().relocatable() 11511 && ((mips_sym != NULL 11512 && (mips_sym->has_mips16_call_stub() 11513 || mips_sym->has_mips16_call_fp_stub())) 11514 || (mips_sym == NULL 11515 && object->get_local_mips16_call_stub(r_sym) != NULL)) 11516 && ((mips_sym != NULL && mips_sym->has_plt_offset()) 11517 || !target_is_16_bit_code)) 11518 { 11519 Mips16_stub_section<size, big_endian>* call_stub; 11520 if (mips_sym == NULL) 11521 call_stub = object->get_local_mips16_call_stub(r_sym); 11522 else 11523 { 11524 // If both call_stub and call_fp_stub are defined, we can figure 11525 // out which one to use by checking which one appears in the input 11526 // file. 11527 if (mips_sym->has_mips16_call_stub() 11528 && mips_sym->has_mips16_call_fp_stub()) 11529 { 11530 call_stub = NULL; 11531 for (unsigned int i = 1; i < object->shnum(); ++i) 11532 { 11533 if (object->is_mips16_call_fp_stub_section(i)) 11534 { 11535 call_stub = mips_sym->template 11536 get_mips16_call_fp_stub<big_endian>(); 11537 break; 11538 } 11539 11540 } 11541 if (call_stub == NULL) 11542 call_stub = 11543 mips_sym->template get_mips16_call_stub<big_endian>(); 11544 } 11545 else if (mips_sym->has_mips16_call_stub()) 11546 call_stub = mips_sym->template get_mips16_call_stub<big_endian>(); 11547 else 11548 call_stub = mips_sym->template get_mips16_call_fp_stub<big_endian>(); 11549 } 11550 11551 symval.set_output_value(call_stub->output_address()); 11552 psymval = &symval; 11553 changed_symbol_value = true; 11554 } 11555 // If this is a direct call to a PIC function, redirect to the 11556 // non-PIC stub. 11557 else if (mips_sym != NULL 11558 && mips_sym->has_la25_stub() 11559 && relocation_needs_la25_stub<size, big_endian>( 11560 object, r_type, target_is_16_bit_code)) 11561 { 11562 Mips_address value = target->la25_stub_section()->stub_address(mips_sym); 11563 if (mips_sym->is_micromips()) 11564 value += 1; 11565 symval.set_output_value(value); 11566 psymval = &symval; 11567 } 11568 // For direct MIPS16 and microMIPS calls make sure the compressed PLT 11569 // entry is used if a standard PLT entry has also been made. 11570 else if ((r_type == elfcpp::R_MIPS16_26 11571 || r_type == elfcpp::R_MICROMIPS_26_S1) 11572 && !parameters->options().relocatable() 11573 && mips_sym != NULL 11574 && mips_sym->has_plt_offset() 11575 && mips_sym->has_comp_plt_offset() 11576 && mips_sym->has_mips_plt_offset()) 11577 { 11578 Mips_address value = (target->plt_section()->comp_entry_address(mips_sym) 11579 + 1); 11580 symval.set_output_value(value); 11581 psymval = &symval; 11582 11583 target_is_16_bit_code = !target->is_output_micromips(); 11584 target_is_micromips_code = target->is_output_micromips(); 11585 } 11586 11587 // Make sure MIPS16 and microMIPS are not used together. 11588 if ((r_type == elfcpp::R_MIPS16_26 && target_is_micromips_code) 11589 || (micromips_branch_reloc(r_type) && target_is_16_bit_code)) 11590 { 11591 gold_error(_("MIPS16 and microMIPS functions cannot call each other")); 11592 } 11593 11594 // Calls from 16-bit code to 32-bit code and vice versa require the 11595 // mode change. However, we can ignore calls to undefined weak symbols, 11596 // which should never be executed at runtime. This exception is important 11597 // because the assembly writer may have "known" that any definition of the 11598 // symbol would be 16-bit code, and that direct jumps were therefore 11599 // acceptable. 11600 cross_mode_jump = 11601 (!parameters->options().relocatable() 11602 && !(gsym != NULL && gsym->is_weak_undefined()) 11603 && ((r_type == elfcpp::R_MIPS16_26 && !target_is_16_bit_code) 11604 || (r_type == elfcpp::R_MICROMIPS_26_S1 && !target_is_micromips_code) 11605 || ((r_type == elfcpp::R_MIPS_26 || r_type == elfcpp::R_MIPS_JALR) 11606 && (target_is_16_bit_code || target_is_micromips_code)))); 11607 11608 bool local = (mips_sym == NULL 11609 || (mips_sym->got_only_for_calls() 11610 ? symbol_calls_local(mips_sym, mips_sym->has_dynsym_index()) 11611 : symbol_references_local(mips_sym, 11612 mips_sym->has_dynsym_index()))); 11613 11614 // Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent 11615 // to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the 11616 // corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. 11617 if (got_page_reloc(r_type) && !local) 11618 r_type = (micromips_reloc(r_type) ? elfcpp::R_MICROMIPS_GOT_DISP 11619 : elfcpp::R_MIPS_GOT_DISP); 11620 11621 unsigned int got_offset = 0; 11622 int gp_offset = 0; 11623 11624 bool calculate_only = false; 11625 Valtype calculated_value = 0; 11626 bool extract_addend = rel_type == elfcpp::SHT_REL; 11627 unsigned int r_types[3] = { r_type, r_type2, r_type3 }; 11628 11629 Reloc_funcs::mips_reloc_unshuffle(view, r_type, false); 11630 11631 // For Mips64 N64 ABI, there may be up to three operations specified per 11632 // record, by the fields r_type, r_type2, and r_type3. The first operation 11633 // takes its addend from the relocation record. Each subsequent operation 11634 // takes as its addend the result of the previous operation. 11635 // The first operation in a record which references a symbol uses the symbol 11636 // implied by r_sym. The next operation in a record which references a symbol 11637 // uses the special symbol value given by the r_ssym field. A third operation 11638 // in a record which references a symbol will assume a NULL symbol, 11639 // i.e. value zero. 11640 11641 // TODO(Vladimir) 11642 // Check if a record references to a symbol. 11643 for (unsigned int i = 0; i < 3; ++i) 11644 { 11645 if (r_types[i] == elfcpp::R_MIPS_NONE) 11646 break; 11647 11648 // TODO(Vladimir) 11649 // Check if the next relocation is for the same instruction. 11650 calculate_only = i == 2 ? false 11651 : r_types[i+1] != elfcpp::R_MIPS_NONE; 11652 11653 if (object->is_n64()) 11654 { 11655 if (i == 1) 11656 { 11657 // Handle special symbol for r_type2 relocation type. 11658 switch (r_ssym) 11659 { 11660 case RSS_UNDEF: 11661 symval.set_output_value(0); 11662 break; 11663 case RSS_GP: 11664 symval.set_output_value(target->gp_value()); 11665 break; 11666 case RSS_GP0: 11667 symval.set_output_value(object->gp_value()); 11668 break; 11669 case RSS_LOC: 11670 symval.set_output_value(address); 11671 break; 11672 default: 11673 gold_unreachable(); 11674 } 11675 psymval = &symval; 11676 } 11677 else if (i == 2) 11678 { 11679 // For r_type3 symbol value is 0. 11680 symval.set_output_value(0); 11681 } 11682 } 11683 11684 bool update_got_entry = false; 11685 switch (r_types[i]) 11686 { 11687 case elfcpp::R_MIPS_NONE: 11688 break; 11689 case elfcpp::R_MIPS_16: 11690 reloc_status = Reloc_funcs::rel16(view, object, psymval, r_addend, 11691 extract_addend, calculate_only, 11692 &calculated_value); 11693 break; 11694 11695 case elfcpp::R_MIPS_32: 11696 if (should_apply_static_reloc(mips_sym, r_types[i], output_section, 11697 target)) 11698 reloc_status = Reloc_funcs::rel32(view, object, psymval, r_addend, 11699 extract_addend, calculate_only, 11700 &calculated_value); 11701 if (mips_sym != NULL 11702 && (mips_sym->is_mips16() || mips_sym->is_micromips()) 11703 && mips_sym->global_got_area() == GGA_RELOC_ONLY) 11704 { 11705 // If mips_sym->has_mips16_fn_stub() is false, symbol value is 11706 // already updated by adding +1. 11707 if (mips_sym->has_mips16_fn_stub()) 11708 { 11709 gold_assert(mips_sym->need_fn_stub()); 11710 Mips16_stub_section<size, big_endian>* fn_stub = 11711 mips_sym->template get_mips16_fn_stub<big_endian>(); 11712 11713 symval.set_output_value(fn_stub->output_address()); 11714 psymval = &symval; 11715 } 11716 got_offset = mips_sym->global_gotoffset(); 11717 update_got_entry = true; 11718 } 11719 break; 11720 11721 case elfcpp::R_MIPS_64: 11722 if (should_apply_static_reloc(mips_sym, r_types[i], output_section, 11723 target)) 11724 reloc_status = Reloc_funcs::rel64(view, object, psymval, r_addend, 11725 extract_addend, calculate_only, 11726 &calculated_value, false); 11727 else if (target->is_output_n64() && r_addend != 0) 11728 // Only apply the addend. The static relocation was RELA, but the 11729 // dynamic relocation is REL, so we need to apply the addend. 11730 reloc_status = Reloc_funcs::rel64(view, object, psymval, r_addend, 11731 extract_addend, calculate_only, 11732 &calculated_value, true); 11733 break; 11734 case elfcpp::R_MIPS_REL32: 11735 gold_unreachable(); 11736 11737 case elfcpp::R_MIPS_PC32: 11738 reloc_status = Reloc_funcs::relpc32(view, object, psymval, address, 11739 r_addend, extract_addend, 11740 calculate_only, 11741 &calculated_value); 11742 break; 11743 11744 case elfcpp::R_MIPS16_26: 11745 // The calculation for R_MIPS16_26 is just the same as for an 11746 // R_MIPS_26. It's only the storage of the relocated field into 11747 // the output file that's different. So, we just fall through to the 11748 // R_MIPS_26 case here. 11749 case elfcpp::R_MIPS_26: 11750 case elfcpp::R_MICROMIPS_26_S1: 11751 reloc_status = Reloc_funcs::rel26(view, object, psymval, address, 11752 gsym == NULL, r_addend, extract_addend, gsym, cross_mode_jump, 11753 r_types[i], target->jal_to_bal(), calculate_only, 11754 &calculated_value); 11755 break; 11756 11757 case elfcpp::R_MIPS_HI16: 11758 case elfcpp::R_MIPS16_HI16: 11759 case elfcpp::R_MICROMIPS_HI16: 11760 if (rel_type == elfcpp::SHT_RELA) 11761 reloc_status = Reloc_funcs::do_relhi16(view, object, psymval, 11762 r_addend, address, 11763 gp_disp, r_types[i], 11764 extract_addend, 0, 11765 target, calculate_only, 11766 &calculated_value); 11767 else if (rel_type == elfcpp::SHT_REL) 11768 reloc_status = Reloc_funcs::relhi16(view, object, psymval, r_addend, 11769 address, gp_disp, r_types[i], 11770 r_sym, extract_addend); 11771 else 11772 gold_unreachable(); 11773 break; 11774 11775 case elfcpp::R_MIPS_LO16: 11776 case elfcpp::R_MIPS16_LO16: 11777 case elfcpp::R_MICROMIPS_LO16: 11778 case elfcpp::R_MICROMIPS_HI0_LO16: 11779 reloc_status = Reloc_funcs::rello16(target, view, object, psymval, 11780 r_addend, extract_addend, address, 11781 gp_disp, r_types[i], r_sym, 11782 rel_type, calculate_only, 11783 &calculated_value); 11784 break; 11785 11786 case elfcpp::R_MIPS_LITERAL: 11787 case elfcpp::R_MICROMIPS_LITERAL: 11788 // Because we don't merge literal sections, we can handle this 11789 // just like R_MIPS_GPREL16. In the long run, we should merge 11790 // shared literals, and then we will need to additional work 11791 // here. 11792 11793 // Fall through. 11794 11795 case elfcpp::R_MIPS_GPREL16: 11796 case elfcpp::R_MIPS16_GPREL: 11797 case elfcpp::R_MICROMIPS_GPREL7_S2: 11798 case elfcpp::R_MICROMIPS_GPREL16: 11799 reloc_status = Reloc_funcs::relgprel(view, object, psymval, 11800 target->adjusted_gp_value(object), 11801 r_addend, extract_addend, 11802 gsym == NULL, r_types[i], 11803 calculate_only, &calculated_value); 11804 break; 11805 11806 case elfcpp::R_MIPS_PC16: 11807 reloc_status = Reloc_funcs::relpc16(view, object, psymval, address, 11808 r_addend, extract_addend, 11809 calculate_only, 11810 &calculated_value); 11811 break; 11812 11813 case elfcpp::R_MIPS_PC21_S2: 11814 reloc_status = Reloc_funcs::relpc21(view, object, psymval, address, 11815 r_addend, extract_addend, 11816 calculate_only, 11817 &calculated_value); 11818 break; 11819 11820 case elfcpp::R_MIPS_PC26_S2: 11821 reloc_status = Reloc_funcs::relpc26(view, object, psymval, address, 11822 r_addend, extract_addend, 11823 calculate_only, 11824 &calculated_value); 11825 break; 11826 11827 case elfcpp::R_MIPS_PC18_S3: 11828 reloc_status = Reloc_funcs::relpc18(view, object, psymval, address, 11829 r_addend, extract_addend, 11830 calculate_only, 11831 &calculated_value); 11832 break; 11833 11834 case elfcpp::R_MIPS_PC19_S2: 11835 reloc_status = Reloc_funcs::relpc19(view, object, psymval, address, 11836 r_addend, extract_addend, 11837 calculate_only, 11838 &calculated_value); 11839 break; 11840 11841 case elfcpp::R_MIPS_PCHI16: 11842 if (rel_type == elfcpp::SHT_RELA) 11843 reloc_status = Reloc_funcs::do_relpchi16(view, object, psymval, 11844 r_addend, address, 11845 extract_addend, 0, 11846 calculate_only, 11847 &calculated_value); 11848 else if (rel_type == elfcpp::SHT_REL) 11849 reloc_status = Reloc_funcs::relpchi16(view, object, psymval, 11850 r_addend, address, r_sym, 11851 extract_addend); 11852 else 11853 gold_unreachable(); 11854 break; 11855 11856 case elfcpp::R_MIPS_PCLO16: 11857 reloc_status = Reloc_funcs::relpclo16(view, object, psymval, r_addend, 11858 extract_addend, address, r_sym, 11859 rel_type, calculate_only, 11860 &calculated_value); 11861 break; 11862 case elfcpp::R_MICROMIPS_PC7_S1: 11863 reloc_status = Reloc_funcs::relmicromips_pc7_s1(view, object, psymval, 11864 address, r_addend, 11865 extract_addend, 11866 calculate_only, 11867 &calculated_value); 11868 break; 11869 case elfcpp::R_MICROMIPS_PC10_S1: 11870 reloc_status = Reloc_funcs::relmicromips_pc10_s1(view, object, 11871 psymval, address, 11872 r_addend, extract_addend, 11873 calculate_only, 11874 &calculated_value); 11875 break; 11876 case elfcpp::R_MICROMIPS_PC16_S1: 11877 reloc_status = Reloc_funcs::relmicromips_pc16_s1(view, object, 11878 psymval, address, 11879 r_addend, extract_addend, 11880 calculate_only, 11881 &calculated_value); 11882 break; 11883 case elfcpp::R_MIPS_GPREL32: 11884 reloc_status = Reloc_funcs::relgprel32(view, object, psymval, 11885 target->adjusted_gp_value(object), 11886 r_addend, extract_addend, 11887 calculate_only, 11888 &calculated_value); 11889 break; 11890 case elfcpp::R_MIPS_GOT_HI16: 11891 case elfcpp::R_MIPS_CALL_HI16: 11892 case elfcpp::R_MICROMIPS_GOT_HI16: 11893 case elfcpp::R_MICROMIPS_CALL_HI16: 11894 if (gsym != NULL) 11895 got_offset = target->got_section()->got_offset(gsym, 11896 GOT_TYPE_STANDARD, 11897 object); 11898 else 11899 got_offset = target->got_section()->got_offset(r_sym, 11900 GOT_TYPE_STANDARD, 11901 object, r_addend); 11902 gp_offset = target->got_section()->gp_offset(got_offset, object); 11903 reloc_status = Reloc_funcs::relgot_hi16(view, gp_offset, 11904 calculate_only, 11905 &calculated_value); 11906 update_got_entry = changed_symbol_value; 11907 break; 11908 11909 case elfcpp::R_MIPS_GOT_LO16: 11910 case elfcpp::R_MIPS_CALL_LO16: 11911 case elfcpp::R_MICROMIPS_GOT_LO16: 11912 case elfcpp::R_MICROMIPS_CALL_LO16: 11913 if (gsym != NULL) 11914 got_offset = target->got_section()->got_offset(gsym, 11915 GOT_TYPE_STANDARD, 11916 object); 11917 else 11918 got_offset = target->got_section()->got_offset(r_sym, 11919 GOT_TYPE_STANDARD, 11920 object, r_addend); 11921 gp_offset = target->got_section()->gp_offset(got_offset, object); 11922 reloc_status = Reloc_funcs::relgot_lo16(view, gp_offset, 11923 calculate_only, 11924 &calculated_value); 11925 update_got_entry = changed_symbol_value; 11926 break; 11927 11928 case elfcpp::R_MIPS_GOT_DISP: 11929 case elfcpp::R_MICROMIPS_GOT_DISP: 11930 case elfcpp::R_MIPS_EH: 11931 if (gsym != NULL) 11932 got_offset = target->got_section()->got_offset(gsym, 11933 GOT_TYPE_STANDARD, 11934 object); 11935 else 11936 got_offset = target->got_section()->got_offset(r_sym, 11937 GOT_TYPE_STANDARD, 11938 object, r_addend); 11939 gp_offset = target->got_section()->gp_offset(got_offset, object); 11940 if (eh_reloc(r_types[i])) 11941 reloc_status = Reloc_funcs::releh(view, gp_offset, 11942 calculate_only, 11943 &calculated_value); 11944 else 11945 reloc_status = Reloc_funcs::relgot(view, gp_offset, 11946 calculate_only, 11947 &calculated_value); 11948 break; 11949 case elfcpp::R_MIPS_CALL16: 11950 case elfcpp::R_MIPS16_CALL16: 11951 case elfcpp::R_MICROMIPS_CALL16: 11952 gold_assert(gsym != NULL); 11953 got_offset = target->got_section()->got_offset(gsym, 11954 GOT_TYPE_STANDARD, 11955 object); 11956 gp_offset = target->got_section()->gp_offset(got_offset, object); 11957 reloc_status = Reloc_funcs::relgot(view, gp_offset, 11958 calculate_only, &calculated_value); 11959 // TODO(sasa): We should also initialize update_got_entry 11960 // in other place swhere relgot is called. 11961 update_got_entry = changed_symbol_value; 11962 break; 11963 11964 case elfcpp::R_MIPS_GOT16: 11965 case elfcpp::R_MIPS16_GOT16: 11966 case elfcpp::R_MICROMIPS_GOT16: 11967 if (gsym != NULL) 11968 { 11969 got_offset = target->got_section()->got_offset(gsym, 11970 GOT_TYPE_STANDARD, 11971 object); 11972 gp_offset = target->got_section()->gp_offset(got_offset, object); 11973 reloc_status = Reloc_funcs::relgot(view, gp_offset, 11974 calculate_only, 11975 &calculated_value); 11976 } 11977 else 11978 { 11979 if (rel_type == elfcpp::SHT_RELA) 11980 reloc_status = Reloc_funcs::do_relgot16_local(view, object, 11981 psymval, r_addend, 11982 extract_addend, 0, 11983 target, 11984 calculate_only, 11985 &calculated_value); 11986 else if (rel_type == elfcpp::SHT_REL) 11987 reloc_status = Reloc_funcs::relgot16_local(view, object, 11988 psymval, r_addend, 11989 extract_addend, 11990 r_types[i], r_sym); 11991 else 11992 gold_unreachable(); 11993 } 11994 update_got_entry = changed_symbol_value; 11995 break; 11996 11997 case elfcpp::R_MIPS_TLS_GD: 11998 case elfcpp::R_MIPS16_TLS_GD: 11999 case elfcpp::R_MICROMIPS_TLS_GD: 12000 if (gsym != NULL) 12001 got_offset = target->got_section()->got_offset(gsym, 12002 GOT_TYPE_TLS_PAIR, 12003 object); 12004 else 12005 got_offset = target->got_section()->got_offset(r_sym, 12006 GOT_TYPE_TLS_PAIR, 12007 object, r_addend); 12008 gp_offset = target->got_section()->gp_offset(got_offset, object); 12009 reloc_status = Reloc_funcs::relgot(view, gp_offset, calculate_only, 12010 &calculated_value); 12011 break; 12012 12013 case elfcpp::R_MIPS_TLS_GOTTPREL: 12014 case elfcpp::R_MIPS16_TLS_GOTTPREL: 12015 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 12016 if (gsym != NULL) 12017 got_offset = target->got_section()->got_offset(gsym, 12018 GOT_TYPE_TLS_OFFSET, 12019 object); 12020 else 12021 got_offset = target->got_section()->got_offset(r_sym, 12022 GOT_TYPE_TLS_OFFSET, 12023 object, r_addend); 12024 gp_offset = target->got_section()->gp_offset(got_offset, object); 12025 reloc_status = Reloc_funcs::relgot(view, gp_offset, calculate_only, 12026 &calculated_value); 12027 break; 12028 12029 case elfcpp::R_MIPS_TLS_LDM: 12030 case elfcpp::R_MIPS16_TLS_LDM: 12031 case elfcpp::R_MICROMIPS_TLS_LDM: 12032 // Relocate the field with the offset of the GOT entry for 12033 // the module index. 12034 got_offset = target->got_section()->tls_ldm_offset(object); 12035 gp_offset = target->got_section()->gp_offset(got_offset, object); 12036 reloc_status = Reloc_funcs::relgot(view, gp_offset, calculate_only, 12037 &calculated_value); 12038 break; 12039 12040 case elfcpp::R_MIPS_GOT_PAGE: 12041 case elfcpp::R_MICROMIPS_GOT_PAGE: 12042 reloc_status = Reloc_funcs::relgotpage(target, view, object, psymval, 12043 r_addend, extract_addend, 12044 calculate_only, 12045 &calculated_value); 12046 break; 12047 12048 case elfcpp::R_MIPS_GOT_OFST: 12049 case elfcpp::R_MICROMIPS_GOT_OFST: 12050 reloc_status = Reloc_funcs::relgotofst(target, view, object, psymval, 12051 r_addend, extract_addend, 12052 local, calculate_only, 12053 &calculated_value); 12054 break; 12055 12056 case elfcpp::R_MIPS_JALR: 12057 case elfcpp::R_MICROMIPS_JALR: 12058 // This relocation is only a hint. In some cases, we optimize 12059 // it into a bal instruction. But we don't try to optimize 12060 // when the symbol does not resolve locally. 12061 if (gsym == NULL 12062 || symbol_calls_local(gsym, gsym->has_dynsym_index())) 12063 reloc_status = Reloc_funcs::reljalr(view, object, psymval, address, 12064 r_addend, extract_addend, 12065 cross_mode_jump, r_types[i], 12066 target->jalr_to_bal(), 12067 target->jr_to_b(), 12068 calculate_only, 12069 &calculated_value); 12070 break; 12071 12072 case elfcpp::R_MIPS_TLS_DTPREL_HI16: 12073 case elfcpp::R_MIPS16_TLS_DTPREL_HI16: 12074 case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16: 12075 reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval, 12076 elfcpp::DTP_OFFSET, r_addend, 12077 extract_addend, calculate_only, 12078 &calculated_value); 12079 break; 12080 case elfcpp::R_MIPS_TLS_DTPREL_LO16: 12081 case elfcpp::R_MIPS16_TLS_DTPREL_LO16: 12082 case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16: 12083 reloc_status = Reloc_funcs::tlsrello16(view, object, psymval, 12084 elfcpp::DTP_OFFSET, r_addend, 12085 extract_addend, calculate_only, 12086 &calculated_value); 12087 break; 12088 case elfcpp::R_MIPS_TLS_DTPREL32: 12089 case elfcpp::R_MIPS_TLS_DTPREL64: 12090 reloc_status = Reloc_funcs::tlsrel32(view, object, psymval, 12091 elfcpp::DTP_OFFSET, r_addend, 12092 extract_addend, calculate_only, 12093 &calculated_value); 12094 break; 12095 case elfcpp::R_MIPS_TLS_TPREL_HI16: 12096 case elfcpp::R_MIPS16_TLS_TPREL_HI16: 12097 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16: 12098 reloc_status = Reloc_funcs::tlsrelhi16(view, object, psymval, 12099 elfcpp::TP_OFFSET, r_addend, 12100 extract_addend, calculate_only, 12101 &calculated_value); 12102 break; 12103 case elfcpp::R_MIPS_TLS_TPREL_LO16: 12104 case elfcpp::R_MIPS16_TLS_TPREL_LO16: 12105 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16: 12106 reloc_status = Reloc_funcs::tlsrello16(view, object, psymval, 12107 elfcpp::TP_OFFSET, r_addend, 12108 extract_addend, calculate_only, 12109 &calculated_value); 12110 break; 12111 case elfcpp::R_MIPS_TLS_TPREL32: 12112 case elfcpp::R_MIPS_TLS_TPREL64: 12113 reloc_status = Reloc_funcs::tlsrel32(view, object, psymval, 12114 elfcpp::TP_OFFSET, r_addend, 12115 extract_addend, calculate_only, 12116 &calculated_value); 12117 break; 12118 case elfcpp::R_MIPS_SUB: 12119 case elfcpp::R_MICROMIPS_SUB: 12120 reloc_status = Reloc_funcs::relsub(view, object, psymval, r_addend, 12121 extract_addend, 12122 calculate_only, &calculated_value); 12123 break; 12124 default: 12125 gold_error_at_location(relinfo, relnum, r_offset, 12126 _("unsupported reloc %u"), r_types[i]); 12127 break; 12128 } 12129 12130 if (update_got_entry) 12131 { 12132 Mips_output_data_got<size, big_endian>* got = target->got_section(); 12133 if (mips_sym != NULL && mips_sym->get_applied_secondary_got_fixup()) 12134 got->update_got_entry(got->get_primary_got_offset(mips_sym), 12135 psymval->value(object, 0)); 12136 else 12137 got->update_got_entry(got_offset, psymval->value(object, 0)); 12138 } 12139 12140 r_addend = calculated_value; 12141 } 12142 12143 bool jal_shuffle = jal_reloc(r_type) ? !parameters->options().relocatable() 12144 : false; 12145 Reloc_funcs::mips_reloc_shuffle(view, r_type, jal_shuffle); 12146 12147 // Report any errors. 12148 switch (reloc_status) 12149 { 12150 case Reloc_funcs::STATUS_OKAY: 12151 break; 12152 case Reloc_funcs::STATUS_OVERFLOW: 12153 gold_error_at_location(relinfo, relnum, r_offset, 12154 _("relocation overflow")); 12155 break; 12156 case Reloc_funcs::STATUS_BAD_RELOC: 12157 gold_error_at_location(relinfo, relnum, r_offset, 12158 _("unexpected opcode while processing relocation")); 12159 break; 12160 case Reloc_funcs::STATUS_PCREL_UNALIGNED: 12161 gold_error_at_location(relinfo, relnum, r_offset, 12162 _("unaligned PC-relative relocation")); 12163 break; 12164 default: 12165 gold_unreachable(); 12166 } 12167 12168 return true; 12169} 12170 12171// Get the Reference_flags for a particular relocation. 12172 12173template<int size, bool big_endian> 12174int 12175Target_mips<size, big_endian>::Scan::get_reference_flags( 12176 unsigned int r_type) 12177{ 12178 switch (r_type) 12179 { 12180 case elfcpp::R_MIPS_NONE: 12181 // No symbol reference. 12182 return 0; 12183 12184 case elfcpp::R_MIPS_16: 12185 case elfcpp::R_MIPS_32: 12186 case elfcpp::R_MIPS_64: 12187 case elfcpp::R_MIPS_HI16: 12188 case elfcpp::R_MIPS_LO16: 12189 case elfcpp::R_MIPS16_HI16: 12190 case elfcpp::R_MIPS16_LO16: 12191 case elfcpp::R_MICROMIPS_HI16: 12192 case elfcpp::R_MICROMIPS_LO16: 12193 return Symbol::ABSOLUTE_REF; 12194 12195 case elfcpp::R_MIPS_26: 12196 case elfcpp::R_MIPS16_26: 12197 case elfcpp::R_MICROMIPS_26_S1: 12198 return Symbol::FUNCTION_CALL | Symbol::ABSOLUTE_REF; 12199 12200 case elfcpp::R_MIPS_PC18_S3: 12201 case elfcpp::R_MIPS_PC19_S2: 12202 case elfcpp::R_MIPS_PCHI16: 12203 case elfcpp::R_MIPS_PCLO16: 12204 case elfcpp::R_MIPS_GPREL32: 12205 case elfcpp::R_MIPS_GPREL16: 12206 case elfcpp::R_MIPS_REL32: 12207 case elfcpp::R_MIPS16_GPREL: 12208 return Symbol::RELATIVE_REF; 12209 12210 case elfcpp::R_MIPS_PC16: 12211 case elfcpp::R_MIPS_PC32: 12212 case elfcpp::R_MIPS_PC21_S2: 12213 case elfcpp::R_MIPS_PC26_S2: 12214 case elfcpp::R_MIPS_JALR: 12215 case elfcpp::R_MICROMIPS_JALR: 12216 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF; 12217 12218 case elfcpp::R_MIPS_GOT16: 12219 case elfcpp::R_MIPS_CALL16: 12220 case elfcpp::R_MIPS_GOT_DISP: 12221 case elfcpp::R_MIPS_GOT_HI16: 12222 case elfcpp::R_MIPS_GOT_LO16: 12223 case elfcpp::R_MIPS_CALL_HI16: 12224 case elfcpp::R_MIPS_CALL_LO16: 12225 case elfcpp::R_MIPS_LITERAL: 12226 case elfcpp::R_MIPS_GOT_PAGE: 12227 case elfcpp::R_MIPS_GOT_OFST: 12228 case elfcpp::R_MIPS16_GOT16: 12229 case elfcpp::R_MIPS16_CALL16: 12230 case elfcpp::R_MICROMIPS_GOT16: 12231 case elfcpp::R_MICROMIPS_CALL16: 12232 case elfcpp::R_MICROMIPS_GOT_HI16: 12233 case elfcpp::R_MICROMIPS_GOT_LO16: 12234 case elfcpp::R_MICROMIPS_CALL_HI16: 12235 case elfcpp::R_MICROMIPS_CALL_LO16: 12236 case elfcpp::R_MIPS_EH: 12237 // Absolute in GOT. 12238 return Symbol::RELATIVE_REF; 12239 12240 case elfcpp::R_MIPS_TLS_DTPMOD32: 12241 case elfcpp::R_MIPS_TLS_DTPREL32: 12242 case elfcpp::R_MIPS_TLS_DTPMOD64: 12243 case elfcpp::R_MIPS_TLS_DTPREL64: 12244 case elfcpp::R_MIPS_TLS_GD: 12245 case elfcpp::R_MIPS_TLS_LDM: 12246 case elfcpp::R_MIPS_TLS_DTPREL_HI16: 12247 case elfcpp::R_MIPS_TLS_DTPREL_LO16: 12248 case elfcpp::R_MIPS_TLS_GOTTPREL: 12249 case elfcpp::R_MIPS_TLS_TPREL32: 12250 case elfcpp::R_MIPS_TLS_TPREL64: 12251 case elfcpp::R_MIPS_TLS_TPREL_HI16: 12252 case elfcpp::R_MIPS_TLS_TPREL_LO16: 12253 case elfcpp::R_MIPS16_TLS_GD: 12254 case elfcpp::R_MIPS16_TLS_GOTTPREL: 12255 case elfcpp::R_MICROMIPS_TLS_GD: 12256 case elfcpp::R_MICROMIPS_TLS_GOTTPREL: 12257 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16: 12258 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16: 12259 return Symbol::TLS_REF; 12260 12261 case elfcpp::R_MIPS_COPY: 12262 case elfcpp::R_MIPS_JUMP_SLOT: 12263 default: 12264 gold_unreachable(); 12265 // Not expected. We will give an error later. 12266 return 0; 12267 } 12268} 12269 12270// Report an unsupported relocation against a local symbol. 12271 12272template<int size, bool big_endian> 12273void 12274Target_mips<size, big_endian>::Scan::unsupported_reloc_local( 12275 Sized_relobj_file<size, big_endian>* object, 12276 unsigned int r_type) 12277{ 12278 gold_error(_("%s: unsupported reloc %u against local symbol"), 12279 object->name().c_str(), r_type); 12280} 12281 12282// Report an unsupported relocation against a global symbol. 12283 12284template<int size, bool big_endian> 12285void 12286Target_mips<size, big_endian>::Scan::unsupported_reloc_global( 12287 Sized_relobj_file<size, big_endian>* object, 12288 unsigned int r_type, 12289 Symbol* gsym) 12290{ 12291 gold_error(_("%s: unsupported reloc %u against global symbol %s"), 12292 object->name().c_str(), r_type, gsym->demangled_name().c_str()); 12293} 12294 12295// Return printable name for ABI. 12296template<int size, bool big_endian> 12297const char* 12298Target_mips<size, big_endian>::elf_mips_abi_name(elfcpp::Elf_Word e_flags) 12299{ 12300 switch (e_flags & elfcpp::EF_MIPS_ABI) 12301 { 12302 case 0: 12303 if ((e_flags & elfcpp::EF_MIPS_ABI2) != 0) 12304 return "N32"; 12305 else if (size == 64) 12306 return "64"; 12307 else 12308 return "none"; 12309 case elfcpp::E_MIPS_ABI_O32: 12310 return "O32"; 12311 case elfcpp::E_MIPS_ABI_O64: 12312 return "O64"; 12313 case elfcpp::E_MIPS_ABI_EABI32: 12314 return "EABI32"; 12315 case elfcpp::E_MIPS_ABI_EABI64: 12316 return "EABI64"; 12317 default: 12318 return "unknown abi"; 12319 } 12320} 12321 12322template<int size, bool big_endian> 12323const char* 12324Target_mips<size, big_endian>::elf_mips_mach_name(elfcpp::Elf_Word e_flags) 12325{ 12326 switch (e_flags & elfcpp::EF_MIPS_MACH) 12327 { 12328 case elfcpp::E_MIPS_MACH_3900: 12329 return "mips:3900"; 12330 case elfcpp::E_MIPS_MACH_4010: 12331 return "mips:4010"; 12332 case elfcpp::E_MIPS_MACH_4100: 12333 return "mips:4100"; 12334 case elfcpp::E_MIPS_MACH_4111: 12335 return "mips:4111"; 12336 case elfcpp::E_MIPS_MACH_4120: 12337 return "mips:4120"; 12338 case elfcpp::E_MIPS_MACH_4650: 12339 return "mips:4650"; 12340 case elfcpp::E_MIPS_MACH_5400: 12341 return "mips:5400"; 12342 case elfcpp::E_MIPS_MACH_5500: 12343 return "mips:5500"; 12344 case elfcpp::E_MIPS_MACH_5900: 12345 return "mips:5900"; 12346 case elfcpp::E_MIPS_MACH_SB1: 12347 return "mips:sb1"; 12348 case elfcpp::E_MIPS_MACH_9000: 12349 return "mips:9000"; 12350 case elfcpp::E_MIPS_MACH_LS2E: 12351 return "mips:loongson_2e"; 12352 case elfcpp::E_MIPS_MACH_LS2F: 12353 return "mips:loongson_2f"; 12354 case elfcpp::E_MIPS_MACH_LS3A: 12355 return "mips:loongson_3a"; 12356 case elfcpp::E_MIPS_MACH_OCTEON: 12357 return "mips:octeon"; 12358 case elfcpp::E_MIPS_MACH_OCTEON2: 12359 return "mips:octeon2"; 12360 case elfcpp::E_MIPS_MACH_OCTEON3: 12361 return "mips:octeon3"; 12362 case elfcpp::E_MIPS_MACH_XLR: 12363 return "mips:xlr"; 12364 default: 12365 switch (e_flags & elfcpp::EF_MIPS_ARCH) 12366 { 12367 default: 12368 case elfcpp::E_MIPS_ARCH_1: 12369 return "mips:3000"; 12370 12371 case elfcpp::E_MIPS_ARCH_2: 12372 return "mips:6000"; 12373 12374 case elfcpp::E_MIPS_ARCH_3: 12375 return "mips:4000"; 12376 12377 case elfcpp::E_MIPS_ARCH_4: 12378 return "mips:8000"; 12379 12380 case elfcpp::E_MIPS_ARCH_5: 12381 return "mips:mips5"; 12382 12383 case elfcpp::E_MIPS_ARCH_32: 12384 return "mips:isa32"; 12385 12386 case elfcpp::E_MIPS_ARCH_64: 12387 return "mips:isa64"; 12388 12389 case elfcpp::E_MIPS_ARCH_32R2: 12390 return "mips:isa32r2"; 12391 12392 case elfcpp::E_MIPS_ARCH_32R6: 12393 return "mips:isa32r6"; 12394 12395 case elfcpp::E_MIPS_ARCH_64R2: 12396 return "mips:isa64r2"; 12397 12398 case elfcpp::E_MIPS_ARCH_64R6: 12399 return "mips:isa64r6"; 12400 } 12401 } 12402 return "unknown CPU"; 12403} 12404 12405template<int size, bool big_endian> 12406const Target::Target_info Target_mips<size, big_endian>::mips_info = 12407{ 12408 size, // size 12409 big_endian, // is_big_endian 12410 elfcpp::EM_MIPS, // machine_code 12411 true, // has_make_symbol 12412 false, // has_resolve 12413 false, // has_code_fill 12414 true, // is_default_stack_executable 12415 false, // can_icf_inline_merge_sections 12416 '\0', // wrap_char 12417 size == 32 ? "/lib/ld.so.1" : "/lib64/ld.so.1", // dynamic_linker 12418 0x400000, // default_text_segment_address 12419 64 * 1024, // abi_pagesize (overridable by -z max-page-size) 12420 4 * 1024, // common_pagesize (overridable by -z common-page-size) 12421 false, // isolate_execinstr 12422 0, // rosegment_gap 12423 elfcpp::SHN_UNDEF, // small_common_shndx 12424 elfcpp::SHN_UNDEF, // large_common_shndx 12425 0, // small_common_section_flags 12426 0, // large_common_section_flags 12427 NULL, // attributes_section 12428 NULL, // attributes_vendor 12429 "__start", // entry_symbol_name 12430 32, // hash_entry_size 12431}; 12432 12433template<int size, bool big_endian> 12434class Target_mips_nacl : public Target_mips<size, big_endian> 12435{ 12436 public: 12437 Target_mips_nacl() 12438 : Target_mips<size, big_endian>(&mips_nacl_info) 12439 { } 12440 12441 private: 12442 static const Target::Target_info mips_nacl_info; 12443}; 12444 12445template<int size, bool big_endian> 12446const Target::Target_info Target_mips_nacl<size, big_endian>::mips_nacl_info = 12447{ 12448 size, // size 12449 big_endian, // is_big_endian 12450 elfcpp::EM_MIPS, // machine_code 12451 true, // has_make_symbol 12452 false, // has_resolve 12453 false, // has_code_fill 12454 true, // is_default_stack_executable 12455 false, // can_icf_inline_merge_sections 12456 '\0', // wrap_char 12457 "/lib/ld.so.1", // dynamic_linker 12458 0x20000, // default_text_segment_address 12459 0x10000, // abi_pagesize (overridable by -z max-page-size) 12460 0x10000, // common_pagesize (overridable by -z common-page-size) 12461 true, // isolate_execinstr 12462 0x10000000, // rosegment_gap 12463 elfcpp::SHN_UNDEF, // small_common_shndx 12464 elfcpp::SHN_UNDEF, // large_common_shndx 12465 0, // small_common_section_flags 12466 0, // large_common_section_flags 12467 NULL, // attributes_section 12468 NULL, // attributes_vendor 12469 "_start", // entry_symbol_name 12470 32, // hash_entry_size 12471}; 12472 12473// Target selector for Mips. Note this is never instantiated directly. 12474// It's only used in Target_selector_mips_nacl, below. 12475 12476template<int size, bool big_endian> 12477class Target_selector_mips : public Target_selector 12478{ 12479public: 12480 Target_selector_mips() 12481 : Target_selector(elfcpp::EM_MIPS, size, big_endian, 12482 (size == 64 ? 12483 (big_endian ? "elf64-tradbigmips" : "elf64-tradlittlemips") : 12484 (big_endian ? "elf32-tradbigmips" : "elf32-tradlittlemips")), 12485 (size == 64 ? 12486 (big_endian ? "elf64btsmip" : "elf64ltsmip") : 12487 (big_endian ? "elf32btsmip" : "elf32ltsmip"))) 12488 { } 12489 12490 Target* do_instantiate_target() 12491 { return new Target_mips<size, big_endian>(); } 12492}; 12493 12494template<int size, bool big_endian> 12495class Target_selector_mips_nacl 12496 : public Target_selector_nacl<Target_selector_mips<size, big_endian>, 12497 Target_mips_nacl<size, big_endian> > 12498{ 12499 public: 12500 Target_selector_mips_nacl() 12501 : Target_selector_nacl<Target_selector_mips<size, big_endian>, 12502 Target_mips_nacl<size, big_endian> >( 12503 // NaCl currently supports only MIPS32 little-endian. 12504 "mipsel", "elf32-tradlittlemips-nacl", "elf32-tradlittlemips-nacl") 12505 { } 12506}; 12507 12508Target_selector_mips_nacl<32, true> target_selector_mips32; 12509Target_selector_mips_nacl<32, false> target_selector_mips32el; 12510Target_selector_mips_nacl<64, true> target_selector_mips64; 12511Target_selector_mips_nacl<64, false> target_selector_mips64el; 12512 12513} // End anonymous namespace. 12514