1/* MIPS-specific support for ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 5 Most of the information added by Ian Lance Taylor, Cygnus Support, 6 <ian@cygnus.com>. 7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC. 8 <mark@codesourcery.com> 9 Traditional MIPS targets support added by Koundinya.K, Dansk Data 10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net> 11 12 This file is part of BFD, the Binary File Descriptor library. 13 14 This program is free software; you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation; either version 2 of the License, or 17 (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, 20 but WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 GNU General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 27 28/* This file handles functionality common to the different MIPS ABI's. */ 29 30#include "bfd.h" 31#include "sysdep.h" 32#include "libbfd.h" 33#include "libiberty.h" 34#include "elf-bfd.h" 35#include "elfxx-mips.h" 36#include "elf/mips.h" 37#include "elf-vxworks.h" 38 39/* Get the ECOFF swapping routines. */ 40#include "coff/sym.h" 41#include "coff/symconst.h" 42#include "coff/ecoff.h" 43#include "coff/mips.h" 44 45#include "hashtab.h" 46 47/* This structure is used to hold information about one GOT entry. 48 There are three types of entry: 49 50 (1) absolute addresses 51 (abfd == NULL) 52 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd 53 (abfd != NULL, symndx >= 0) 54 (3) global and forced-local symbols 55 (abfd != NULL, symndx == -1) 56 57 Type (3) entries are treated differently for different types of GOT. 58 In the "master" GOT -- i.e. the one that describes every GOT 59 reference needed in the link -- the mips_got_entry is keyed on both 60 the symbol and the input bfd that references it. If it turns out 61 that we need multiple GOTs, we can then use this information to 62 create separate GOTs for each input bfd. 63 64 However, we want each of these separate GOTs to have at most one 65 entry for a given symbol, so their type (3) entries are keyed only 66 on the symbol. The input bfd given by the "abfd" field is somewhat 67 arbitrary in this case. 68 69 This means that when there are multiple GOTs, each GOT has a unique 70 mips_got_entry for every symbol within it. We can therefore use the 71 mips_got_entry fields (tls_type and gotidx) to track the symbol's 72 GOT index. 73 74 However, if it turns out that we need only a single GOT, we continue 75 to use the master GOT to describe it. There may therefore be several 76 mips_got_entries for the same symbol, each with a different input bfd. 77 We want to make sure that each symbol gets a unique GOT entry, so when 78 there's a single GOT, we use the symbol's hash entry, not the 79 mips_got_entry fields, to track a symbol's GOT index. */ 80struct mips_got_entry 81{ 82 /* The input bfd in which the symbol is defined. */ 83 bfd *abfd; 84 /* The index of the symbol, as stored in the relocation r_info, if 85 we have a local symbol; -1 otherwise. */ 86 long symndx; 87 union 88 { 89 /* If abfd == NULL, an address that must be stored in the got. */ 90 bfd_vma address; 91 /* If abfd != NULL && symndx != -1, the addend of the relocation 92 that should be added to the symbol value. */ 93 bfd_vma addend; 94 /* If abfd != NULL && symndx == -1, the hash table entry 95 corresponding to a global symbol in the got (or, local, if 96 h->forced_local). */ 97 struct mips_elf_link_hash_entry *h; 98 } d; 99 100 /* The TLS types included in this GOT entry (specifically, GD and 101 IE). The GD and IE flags can be added as we encounter new 102 relocations. LDM can also be set; it will always be alone, not 103 combined with any GD or IE flags. An LDM GOT entry will be 104 a local symbol entry with r_symndx == 0. */ 105 unsigned char tls_type; 106 107 /* The offset from the beginning of the .got section to the entry 108 corresponding to this symbol+addend. If it's a global symbol 109 whose offset is yet to be decided, it's going to be -1. */ 110 long gotidx; 111}; 112 113/* This structure is used to hold .got information when linking. */ 114 115struct mips_got_info 116{ 117 /* The global symbol in the GOT with the lowest index in the dynamic 118 symbol table. */ 119 struct elf_link_hash_entry *global_gotsym; 120 /* The number of global .got entries. */ 121 unsigned int global_gotno; 122 /* The number of .got slots used for TLS. */ 123 unsigned int tls_gotno; 124 /* The first unused TLS .got entry. Used only during 125 mips_elf_initialize_tls_index. */ 126 unsigned int tls_assigned_gotno; 127 /* The number of local .got entries. */ 128 unsigned int local_gotno; 129 /* The number of local .got entries we have used. */ 130 unsigned int assigned_gotno; 131 /* A hash table holding members of the got. */ 132 struct htab *got_entries; 133 /* A hash table mapping input bfds to other mips_got_info. NULL 134 unless multi-got was necessary. */ 135 struct htab *bfd2got; 136 /* In multi-got links, a pointer to the next got (err, rather, most 137 of the time, it points to the previous got). */ 138 struct mips_got_info *next; 139 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE 140 for none, or MINUS_TWO for not yet assigned. This is needed 141 because a single-GOT link may have multiple hash table entries 142 for the LDM. It does not get initialized in multi-GOT mode. */ 143 bfd_vma tls_ldm_offset; 144}; 145 146/* Map an input bfd to a got in a multi-got link. */ 147 148struct mips_elf_bfd2got_hash { 149 bfd *bfd; 150 struct mips_got_info *g; 151}; 152 153/* Structure passed when traversing the bfd2got hash table, used to 154 create and merge bfd's gots. */ 155 156struct mips_elf_got_per_bfd_arg 157{ 158 /* A hashtable that maps bfds to gots. */ 159 htab_t bfd2got; 160 /* The output bfd. */ 161 bfd *obfd; 162 /* The link information. */ 163 struct bfd_link_info *info; 164 /* A pointer to the primary got, i.e., the one that's going to get 165 the implicit relocations from DT_MIPS_LOCAL_GOTNO and 166 DT_MIPS_GOTSYM. */ 167 struct mips_got_info *primary; 168 /* A non-primary got we're trying to merge with other input bfd's 169 gots. */ 170 struct mips_got_info *current; 171 /* The maximum number of got entries that can be addressed with a 172 16-bit offset. */ 173 unsigned int max_count; 174 /* The number of local and global entries in the primary got. */ 175 unsigned int primary_count; 176 /* The number of local and global entries in the current got. */ 177 unsigned int current_count; 178 /* The total number of global entries which will live in the 179 primary got and be automatically relocated. This includes 180 those not referenced by the primary GOT but included in 181 the "master" GOT. */ 182 unsigned int global_count; 183}; 184 185/* Another structure used to pass arguments for got entries traversal. */ 186 187struct mips_elf_set_global_got_offset_arg 188{ 189 struct mips_got_info *g; 190 int value; 191 unsigned int needed_relocs; 192 struct bfd_link_info *info; 193}; 194 195/* A structure used to count TLS relocations or GOT entries, for GOT 196 entry or ELF symbol table traversal. */ 197 198struct mips_elf_count_tls_arg 199{ 200 struct bfd_link_info *info; 201 unsigned int needed; 202}; 203 204struct _mips_elf_section_data 205{ 206 struct bfd_elf_section_data elf; 207 union 208 { 209 struct mips_got_info *got_info; 210 bfd_byte *tdata; 211 } u; 212}; 213 214#define mips_elf_section_data(sec) \ 215 ((struct _mips_elf_section_data *) elf_section_data (sec)) 216 217/* This structure is passed to mips_elf_sort_hash_table_f when sorting 218 the dynamic symbols. */ 219 220struct mips_elf_hash_sort_data 221{ 222 /* The symbol in the global GOT with the lowest dynamic symbol table 223 index. */ 224 struct elf_link_hash_entry *low; 225 /* The least dynamic symbol table index corresponding to a non-TLS 226 symbol with a GOT entry. */ 227 long min_got_dynindx; 228 /* The greatest dynamic symbol table index corresponding to a symbol 229 with a GOT entry that is not referenced (e.g., a dynamic symbol 230 with dynamic relocations pointing to it from non-primary GOTs). */ 231 long max_unref_got_dynindx; 232 /* The greatest dynamic symbol table index not corresponding to a 233 symbol without a GOT entry. */ 234 long max_non_got_dynindx; 235}; 236 237/* The MIPS ELF linker needs additional information for each symbol in 238 the global hash table. */ 239 240struct mips_elf_link_hash_entry 241{ 242 struct elf_link_hash_entry root; 243 244 /* External symbol information. */ 245 EXTR esym; 246 247 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against 248 this symbol. */ 249 unsigned int possibly_dynamic_relocs; 250 251 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against 252 a readonly section. */ 253 bfd_boolean readonly_reloc; 254 255 /* We must not create a stub for a symbol that has relocations 256 related to taking the function's address, i.e. any but 257 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition", 258 p. 4-20. */ 259 bfd_boolean no_fn_stub; 260 261 /* If there is a stub that 32 bit functions should use to call this 262 16 bit function, this points to the section containing the stub. */ 263 asection *fn_stub; 264 265 /* Whether we need the fn_stub; this is set if this symbol appears 266 in any relocs other than a 16 bit call. */ 267 bfd_boolean need_fn_stub; 268 269 /* If there is a stub that 16 bit functions should use to call this 270 32 bit function, this points to the section containing the stub. */ 271 asection *call_stub; 272 273 /* This is like the call_stub field, but it is used if the function 274 being called returns a floating point value. */ 275 asection *call_fp_stub; 276 277 /* Are we forced local? This will only be set if we have converted 278 the initial global GOT entry to a local GOT entry. */ 279 bfd_boolean forced_local; 280 281 /* Are we referenced by some kind of relocation? */ 282 bfd_boolean is_relocation_target; 283 284 /* Are we referenced by branch relocations? */ 285 bfd_boolean is_branch_target; 286 287#define GOT_NORMAL 0 288#define GOT_TLS_GD 1 289#define GOT_TLS_LDM 2 290#define GOT_TLS_IE 4 291#define GOT_TLS_OFFSET_DONE 0x40 292#define GOT_TLS_DONE 0x80 293 unsigned char tls_type; 294 /* This is only used in single-GOT mode; in multi-GOT mode there 295 is one mips_got_entry per GOT entry, so the offset is stored 296 there. In single-GOT mode there may be many mips_got_entry 297 structures all referring to the same GOT slot. It might be 298 possible to use root.got.offset instead, but that field is 299 overloaded already. */ 300 bfd_vma tls_got_offset; 301}; 302 303/* MIPS ELF linker hash table. */ 304 305struct mips_elf_link_hash_table 306{ 307 struct elf_link_hash_table root; 308#if 0 309 /* We no longer use this. */ 310 /* String section indices for the dynamic section symbols. */ 311 bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES]; 312#endif 313 /* The number of .rtproc entries. */ 314 bfd_size_type procedure_count; 315 /* The size of the .compact_rel section (if SGI_COMPAT). */ 316 bfd_size_type compact_rel_size; 317 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic 318 entry is set to the address of __rld_obj_head as in IRIX5. */ 319 bfd_boolean use_rld_obj_head; 320 /* This is the value of the __rld_map or __rld_obj_head symbol. */ 321 bfd_vma rld_value; 322 /* This is set if we see any mips16 stub sections. */ 323 bfd_boolean mips16_stubs_seen; 324 /* True if we're generating code for VxWorks. */ 325 bfd_boolean is_vxworks; 326 /* Shortcuts to some dynamic sections, or NULL if they are not 327 being used. */ 328 asection *srelbss; 329 asection *sdynbss; 330 asection *srelplt; 331 asection *srelplt2; 332 asection *sgotplt; 333 asection *splt; 334 /* The size of the PLT header in bytes (VxWorks only). */ 335 bfd_vma plt_header_size; 336 /* The size of a PLT entry in bytes (VxWorks only). */ 337 bfd_vma plt_entry_size; 338 /* The size of a function stub entry in bytes. */ 339 bfd_vma function_stub_size; 340}; 341 342#define TLS_RELOC_P(r_type) \ 343 (r_type == R_MIPS_TLS_DTPMOD32 \ 344 || r_type == R_MIPS_TLS_DTPMOD64 \ 345 || r_type == R_MIPS_TLS_DTPREL32 \ 346 || r_type == R_MIPS_TLS_DTPREL64 \ 347 || r_type == R_MIPS_TLS_GD \ 348 || r_type == R_MIPS_TLS_LDM \ 349 || r_type == R_MIPS_TLS_DTPREL_HI16 \ 350 || r_type == R_MIPS_TLS_DTPREL_LO16 \ 351 || r_type == R_MIPS_TLS_GOTTPREL \ 352 || r_type == R_MIPS_TLS_TPREL32 \ 353 || r_type == R_MIPS_TLS_TPREL64 \ 354 || r_type == R_MIPS_TLS_TPREL_HI16 \ 355 || r_type == R_MIPS_TLS_TPREL_LO16) 356 357/* Structure used to pass information to mips_elf_output_extsym. */ 358 359struct extsym_info 360{ 361 bfd *abfd; 362 struct bfd_link_info *info; 363 struct ecoff_debug_info *debug; 364 const struct ecoff_debug_swap *swap; 365 bfd_boolean failed; 366}; 367 368/* The names of the runtime procedure table symbols used on IRIX5. */ 369 370static const char * const mips_elf_dynsym_rtproc_names[] = 371{ 372 "_procedure_table", 373 "_procedure_string_table", 374 "_procedure_table_size", 375 NULL 376}; 377 378/* These structures are used to generate the .compact_rel section on 379 IRIX5. */ 380 381typedef struct 382{ 383 unsigned long id1; /* Always one? */ 384 unsigned long num; /* Number of compact relocation entries. */ 385 unsigned long id2; /* Always two? */ 386 unsigned long offset; /* The file offset of the first relocation. */ 387 unsigned long reserved0; /* Zero? */ 388 unsigned long reserved1; /* Zero? */ 389} Elf32_compact_rel; 390 391typedef struct 392{ 393 bfd_byte id1[4]; 394 bfd_byte num[4]; 395 bfd_byte id2[4]; 396 bfd_byte offset[4]; 397 bfd_byte reserved0[4]; 398 bfd_byte reserved1[4]; 399} Elf32_External_compact_rel; 400 401typedef struct 402{ 403 unsigned int ctype : 1; /* 1: long 0: short format. See below. */ 404 unsigned int rtype : 4; /* Relocation types. See below. */ 405 unsigned int dist2to : 8; 406 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */ 407 unsigned long konst; /* KONST field. See below. */ 408 unsigned long vaddr; /* VADDR to be relocated. */ 409} Elf32_crinfo; 410 411typedef struct 412{ 413 unsigned int ctype : 1; /* 1: long 0: short format. See below. */ 414 unsigned int rtype : 4; /* Relocation types. See below. */ 415 unsigned int dist2to : 8; 416 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */ 417 unsigned long konst; /* KONST field. See below. */ 418} Elf32_crinfo2; 419 420typedef struct 421{ 422 bfd_byte info[4]; 423 bfd_byte konst[4]; 424 bfd_byte vaddr[4]; 425} Elf32_External_crinfo; 426 427typedef struct 428{ 429 bfd_byte info[4]; 430 bfd_byte konst[4]; 431} Elf32_External_crinfo2; 432 433/* These are the constants used to swap the bitfields in a crinfo. */ 434 435#define CRINFO_CTYPE (0x1) 436#define CRINFO_CTYPE_SH (31) 437#define CRINFO_RTYPE (0xf) 438#define CRINFO_RTYPE_SH (27) 439#define CRINFO_DIST2TO (0xff) 440#define CRINFO_DIST2TO_SH (19) 441#define CRINFO_RELVADDR (0x7ffff) 442#define CRINFO_RELVADDR_SH (0) 443 444/* A compact relocation info has long (3 words) or short (2 words) 445 formats. A short format doesn't have VADDR field and relvaddr 446 fields contains ((VADDR - vaddr of the previous entry) >> 2). */ 447#define CRF_MIPS_LONG 1 448#define CRF_MIPS_SHORT 0 449 450/* There are 4 types of compact relocation at least. The value KONST 451 has different meaning for each type: 452 453 (type) (konst) 454 CT_MIPS_REL32 Address in data 455 CT_MIPS_WORD Address in word (XXX) 456 CT_MIPS_GPHI_LO GP - vaddr 457 CT_MIPS_JMPAD Address to jump 458 */ 459 460#define CRT_MIPS_REL32 0xa 461#define CRT_MIPS_WORD 0xb 462#define CRT_MIPS_GPHI_LO 0xc 463#define CRT_MIPS_JMPAD 0xd 464 465#define mips_elf_set_cr_format(x,format) ((x).ctype = (format)) 466#define mips_elf_set_cr_type(x,type) ((x).rtype = (type)) 467#define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v)) 468#define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2) 469 470/* The structure of the runtime procedure descriptor created by the 471 loader for use by the static exception system. */ 472 473typedef struct runtime_pdr { 474 bfd_vma adr; /* Memory address of start of procedure. */ 475 long regmask; /* Save register mask. */ 476 long regoffset; /* Save register offset. */ 477 long fregmask; /* Save floating point register mask. */ 478 long fregoffset; /* Save floating point register offset. */ 479 long frameoffset; /* Frame size. */ 480 short framereg; /* Frame pointer register. */ 481 short pcreg; /* Offset or reg of return pc. */ 482 long irpss; /* Index into the runtime string table. */ 483 long reserved; 484 struct exception_info *exception_info;/* Pointer to exception array. */ 485} RPDR, *pRPDR; 486#define cbRPDR sizeof (RPDR) 487#define rpdNil ((pRPDR) 0) 488 489static struct mips_got_entry *mips_elf_create_local_got_entry 490 (bfd *, struct bfd_link_info *, bfd *, struct mips_got_info *, asection *, 491 asection *, bfd_vma, unsigned long, struct mips_elf_link_hash_entry *, int); 492static bfd_boolean mips_elf_sort_hash_table_f 493 (struct mips_elf_link_hash_entry *, void *); 494static bfd_vma mips_elf_high 495 (bfd_vma); 496static bfd_boolean mips_elf_stub_section_p 497 (bfd *, asection *); 498static bfd_boolean mips_elf_create_dynamic_relocation 499 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *, 500 struct mips_elf_link_hash_entry *, asection *, bfd_vma, 501 bfd_vma *, asection *); 502static hashval_t mips_elf_got_entry_hash 503 (const void *); 504static bfd_vma mips_elf_adjust_gp 505 (bfd *, struct mips_got_info *, bfd *); 506static struct mips_got_info *mips_elf_got_for_ibfd 507 (struct mips_got_info *, bfd *); 508 509/* This will be used when we sort the dynamic relocation records. */ 510static bfd *reldyn_sorting_bfd; 511 512/* Nonzero if ABFD is using the N32 ABI. */ 513#define ABI_N32_P(abfd) \ 514 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0) 515 516/* Nonzero if ABFD is using the N64 ABI. */ 517#define ABI_64_P(abfd) \ 518 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64) 519 520/* Nonzero if ABFD is using NewABI conventions. */ 521#define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd)) 522 523/* The IRIX compatibility level we are striving for. */ 524#define IRIX_COMPAT(abfd) \ 525 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd)) 526 527/* Whether we are trying to be compatible with IRIX at all. */ 528#define SGI_COMPAT(abfd) \ 529 (IRIX_COMPAT (abfd) != ict_none) 530 531/* The name of the options section. */ 532#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \ 533 (NEWABI_P (abfd) ? ".MIPS.options" : ".options") 534 535/* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section. 536 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */ 537#define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \ 538 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0) 539 540/* Whether the section is readonly. */ 541#define MIPS_ELF_READONLY_SECTION(sec) \ 542 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \ 543 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) 544 545/* The name of the stub section. */ 546#define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs" 547 548/* The size of an external REL relocation. */ 549#define MIPS_ELF_REL_SIZE(abfd) \ 550 (get_elf_backend_data (abfd)->s->sizeof_rel) 551 552/* The size of an external RELA relocation. */ 553#define MIPS_ELF_RELA_SIZE(abfd) \ 554 (get_elf_backend_data (abfd)->s->sizeof_rela) 555 556/* The size of an external dynamic table entry. */ 557#define MIPS_ELF_DYN_SIZE(abfd) \ 558 (get_elf_backend_data (abfd)->s->sizeof_dyn) 559 560/* The size of a GOT entry. */ 561#define MIPS_ELF_GOT_SIZE(abfd) \ 562 (get_elf_backend_data (abfd)->s->arch_size / 8) 563 564/* The size of a symbol-table entry. */ 565#define MIPS_ELF_SYM_SIZE(abfd) \ 566 (get_elf_backend_data (abfd)->s->sizeof_sym) 567 568/* The default alignment for sections, as a power of two. */ 569#define MIPS_ELF_LOG_FILE_ALIGN(abfd) \ 570 (get_elf_backend_data (abfd)->s->log_file_align) 571 572/* Get word-sized data. */ 573#define MIPS_ELF_GET_WORD(abfd, ptr) \ 574 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr)) 575 576/* Put out word-sized data. */ 577#define MIPS_ELF_PUT_WORD(abfd, val, ptr) \ 578 (ABI_64_P (abfd) \ 579 ? bfd_put_64 (abfd, val, ptr) \ 580 : bfd_put_32 (abfd, val, ptr)) 581 582/* Add a dynamic symbol table-entry. */ 583#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \ 584 _bfd_elf_add_dynamic_entry (info, tag, val) 585 586#define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \ 587 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela)) 588 589/* Determine whether the internal relocation of index REL_IDX is REL 590 (zero) or RELA (non-zero). The assumption is that, if there are 591 two relocation sections for this section, one of them is REL and 592 the other is RELA. If the index of the relocation we're testing is 593 in range for the first relocation section, check that the external 594 relocation size is that for RELA. It is also assumed that, if 595 rel_idx is not in range for the first section, and this first 596 section contains REL relocs, then the relocation is in the second 597 section, that is RELA. */ 598#define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \ 599 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \ 600 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \ 601 > (bfd_vma)(rel_idx)) \ 602 == (elf_section_data (sec)->rel_hdr.sh_entsize \ 603 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \ 604 : sizeof (Elf32_External_Rela)))) 605 606/* The name of the dynamic relocation section. */ 607#define MIPS_ELF_REL_DYN_NAME(INFO) \ 608 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn") 609 610/* In case we're on a 32-bit machine, construct a 64-bit "-1" value 611 from smaller values. Start with zero, widen, *then* decrement. */ 612#define MINUS_ONE (((bfd_vma)0) - 1) 613#define MINUS_TWO (((bfd_vma)0) - 2) 614 615/* The number of local .got entries we reserve. */ 616#define MIPS_RESERVED_GOTNO(INFO) \ 617 (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2) 618 619/* The offset of $gp from the beginning of the .got section. */ 620#define ELF_MIPS_GP_OFFSET(INFO) \ 621 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0) 622 623/* The maximum size of the GOT for it to be addressable using 16-bit 624 offsets from $gp. */ 625#define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff) 626 627/* Instructions which appear in a stub. */ 628#define STUB_LW(abfd) \ 629 ((ABI_64_P (abfd) \ 630 ? 0xdf998010 /* ld t9,0x8010(gp) */ \ 631 : 0x8f998010)) /* lw t9,0x8010(gp) */ 632#define STUB_MOVE(abfd) \ 633 ((ABI_64_P (abfd) \ 634 ? 0x03e0782d /* daddu t7,ra */ \ 635 : 0x03e07821)) /* addu t7,ra */ 636#define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */ 637#define STUB_JALR 0x0320f809 /* jalr t9,ra */ 638#define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */ 639#define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */ 640#define STUB_LI16S(abfd, VAL) \ 641 ((ABI_64_P (abfd) \ 642 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \ 643 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */ 644 645#define MIPS_FUNCTION_STUB_NORMAL_SIZE 16 646#define MIPS_FUNCTION_STUB_BIG_SIZE 20 647 648/* The name of the dynamic interpreter. This is put in the .interp 649 section. */ 650 651#define ELF_DYNAMIC_INTERPRETER(abfd) \ 652 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \ 653 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \ 654 : "/usr/lib/libc.so.1") 655 656#ifdef BFD64 657#define MNAME(bfd,pre,pos) \ 658 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos)) 659#define ELF_R_SYM(bfd, i) \ 660 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i)) 661#define ELF_R_TYPE(bfd, i) \ 662 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i)) 663#define ELF_R_INFO(bfd, s, t) \ 664 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t)) 665#else 666#define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos) 667#define ELF_R_SYM(bfd, i) \ 668 (ELF32_R_SYM (i)) 669#define ELF_R_TYPE(bfd, i) \ 670 (ELF32_R_TYPE (i)) 671#define ELF_R_INFO(bfd, s, t) \ 672 (ELF32_R_INFO (s, t)) 673#endif 674 675 /* The mips16 compiler uses a couple of special sections to handle 676 floating point arguments. 677 678 Section names that look like .mips16.fn.FNNAME contain stubs that 679 copy floating point arguments from the fp regs to the gp regs and 680 then jump to FNNAME. If any 32 bit function calls FNNAME, the 681 call should be redirected to the stub instead. If no 32 bit 682 function calls FNNAME, the stub should be discarded. We need to 683 consider any reference to the function, not just a call, because 684 if the address of the function is taken we will need the stub, 685 since the address might be passed to a 32 bit function. 686 687 Section names that look like .mips16.call.FNNAME contain stubs 688 that copy floating point arguments from the gp regs to the fp 689 regs and then jump to FNNAME. If FNNAME is a 32 bit function, 690 then any 16 bit function that calls FNNAME should be redirected 691 to the stub instead. If FNNAME is not a 32 bit function, the 692 stub should be discarded. 693 694 .mips16.call.fp.FNNAME sections are similar, but contain stubs 695 which call FNNAME and then copy the return value from the fp regs 696 to the gp regs. These stubs store the return value in $18 while 697 calling FNNAME; any function which might call one of these stubs 698 must arrange to save $18 around the call. (This case is not 699 needed for 32 bit functions that call 16 bit functions, because 700 16 bit functions always return floating point values in both 701 $f0/$f1 and $2/$3.) 702 703 Note that in all cases FNNAME might be defined statically. 704 Therefore, FNNAME is not used literally. Instead, the relocation 705 information will indicate which symbol the section is for. 706 707 We record any stubs that we find in the symbol table. */ 708 709#define FN_STUB ".mips16.fn." 710#define CALL_STUB ".mips16.call." 711#define CALL_FP_STUB ".mips16.call.fp." 712 713/* The format of the first PLT entry in a VxWorks executable. */ 714static const bfd_vma mips_vxworks_exec_plt0_entry[] = { 715 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */ 716 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */ 717 0x8f390008, /* lw t9, 8(t9) */ 718 0x00000000, /* nop */ 719 0x03200008, /* jr t9 */ 720 0x00000000 /* nop */ 721}; 722 723/* The format of subsequent PLT entries. */ 724static const bfd_vma mips_vxworks_exec_plt_entry[] = { 725 0x10000000, /* b .PLT_resolver */ 726 0x24180000, /* li t8, <pltindex> */ 727 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */ 728 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */ 729 0x8f390000, /* lw t9, 0(t9) */ 730 0x00000000, /* nop */ 731 0x03200008, /* jr t9 */ 732 0x00000000 /* nop */ 733}; 734 735/* The format of the first PLT entry in a VxWorks shared object. */ 736static const bfd_vma mips_vxworks_shared_plt0_entry[] = { 737 0x8f990008, /* lw t9, 8(gp) */ 738 0x00000000, /* nop */ 739 0x03200008, /* jr t9 */ 740 0x00000000, /* nop */ 741 0x00000000, /* nop */ 742 0x00000000 /* nop */ 743}; 744 745/* The format of subsequent PLT entries. */ 746static const bfd_vma mips_vxworks_shared_plt_entry[] = { 747 0x10000000, /* b .PLT_resolver */ 748 0x24180000 /* li t8, <pltindex> */ 749}; 750 751/* Look up an entry in a MIPS ELF linker hash table. */ 752 753#define mips_elf_link_hash_lookup(table, string, create, copy, follow) \ 754 ((struct mips_elf_link_hash_entry *) \ 755 elf_link_hash_lookup (&(table)->root, (string), (create), \ 756 (copy), (follow))) 757 758/* Traverse a MIPS ELF linker hash table. */ 759 760#define mips_elf_link_hash_traverse(table, func, info) \ 761 (elf_link_hash_traverse \ 762 (&(table)->root, \ 763 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 764 (info))) 765 766/* Get the MIPS ELF linker hash table from a link_info structure. */ 767 768#define mips_elf_hash_table(p) \ 769 ((struct mips_elf_link_hash_table *) ((p)->hash)) 770 771/* Find the base offsets for thread-local storage in this object, 772 for GD/LD and IE/LE respectively. */ 773 774#define TP_OFFSET 0x7000 775#define DTP_OFFSET 0x8000 776 777static bfd_vma 778dtprel_base (struct bfd_link_info *info) 779{ 780 /* If tls_sec is NULL, we should have signalled an error already. */ 781 if (elf_hash_table (info)->tls_sec == NULL) 782 return 0; 783 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET; 784} 785 786static bfd_vma 787tprel_base (struct bfd_link_info *info) 788{ 789 /* If tls_sec is NULL, we should have signalled an error already. */ 790 if (elf_hash_table (info)->tls_sec == NULL) 791 return 0; 792 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET; 793} 794 795/* Create an entry in a MIPS ELF linker hash table. */ 796 797static struct bfd_hash_entry * 798mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 799 struct bfd_hash_table *table, const char *string) 800{ 801 struct mips_elf_link_hash_entry *ret = 802 (struct mips_elf_link_hash_entry *) entry; 803 804 /* Allocate the structure if it has not already been allocated by a 805 subclass. */ 806 if (ret == NULL) 807 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry)); 808 if (ret == NULL) 809 return (struct bfd_hash_entry *) ret; 810 811 /* Call the allocation method of the superclass. */ 812 ret = ((struct mips_elf_link_hash_entry *) 813 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 814 table, string)); 815 if (ret != NULL) 816 { 817 /* Set local fields. */ 818 memset (&ret->esym, 0, sizeof (EXTR)); 819 /* We use -2 as a marker to indicate that the information has 820 not been set. -1 means there is no associated ifd. */ 821 ret->esym.ifd = -2; 822 ret->possibly_dynamic_relocs = 0; 823 ret->readonly_reloc = FALSE; 824 ret->no_fn_stub = FALSE; 825 ret->fn_stub = NULL; 826 ret->need_fn_stub = FALSE; 827 ret->call_stub = NULL; 828 ret->call_fp_stub = NULL; 829 ret->forced_local = FALSE; 830 ret->is_branch_target = FALSE; 831 ret->is_relocation_target = FALSE; 832 ret->tls_type = GOT_NORMAL; 833 } 834 835 return (struct bfd_hash_entry *) ret; 836} 837 838bfd_boolean 839_bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec) 840{ 841 struct _mips_elf_section_data *sdata; 842 bfd_size_type amt = sizeof (*sdata); 843 844 sdata = bfd_zalloc (abfd, amt); 845 if (sdata == NULL) 846 return FALSE; 847 sec->used_by_bfd = sdata; 848 849 return _bfd_elf_new_section_hook (abfd, sec); 850} 851 852/* Read ECOFF debugging information from a .mdebug section into a 853 ecoff_debug_info structure. */ 854 855bfd_boolean 856_bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section, 857 struct ecoff_debug_info *debug) 858{ 859 HDRR *symhdr; 860 const struct ecoff_debug_swap *swap; 861 char *ext_hdr; 862 863 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 864 memset (debug, 0, sizeof (*debug)); 865 866 ext_hdr = bfd_malloc (swap->external_hdr_size); 867 if (ext_hdr == NULL && swap->external_hdr_size != 0) 868 goto error_return; 869 870 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0, 871 swap->external_hdr_size)) 872 goto error_return; 873 874 symhdr = &debug->symbolic_header; 875 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr); 876 877 /* The symbolic header contains absolute file offsets and sizes to 878 read. */ 879#define READ(ptr, offset, count, size, type) \ 880 if (symhdr->count == 0) \ 881 debug->ptr = NULL; \ 882 else \ 883 { \ 884 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \ 885 debug->ptr = bfd_malloc (amt); \ 886 if (debug->ptr == NULL) \ 887 goto error_return; \ 888 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \ 889 || bfd_bread (debug->ptr, amt, abfd) != amt) \ 890 goto error_return; \ 891 } 892 893 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *); 894 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); 895 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); 896 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); 897 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); 898 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), 899 union aux_ext *); 900 READ (ss, cbSsOffset, issMax, sizeof (char), char *); 901 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *); 902 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); 903 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); 904 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *); 905#undef READ 906 907 debug->fdr = NULL; 908 909 return TRUE; 910 911 error_return: 912 if (ext_hdr != NULL) 913 free (ext_hdr); 914 if (debug->line != NULL) 915 free (debug->line); 916 if (debug->external_dnr != NULL) 917 free (debug->external_dnr); 918 if (debug->external_pdr != NULL) 919 free (debug->external_pdr); 920 if (debug->external_sym != NULL) 921 free (debug->external_sym); 922 if (debug->external_opt != NULL) 923 free (debug->external_opt); 924 if (debug->external_aux != NULL) 925 free (debug->external_aux); 926 if (debug->ss != NULL) 927 free (debug->ss); 928 if (debug->ssext != NULL) 929 free (debug->ssext); 930 if (debug->external_fdr != NULL) 931 free (debug->external_fdr); 932 if (debug->external_rfd != NULL) 933 free (debug->external_rfd); 934 if (debug->external_ext != NULL) 935 free (debug->external_ext); 936 return FALSE; 937} 938 939/* Swap RPDR (runtime procedure table entry) for output. */ 940 941static void 942ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex) 943{ 944 H_PUT_S32 (abfd, in->adr, ex->p_adr); 945 H_PUT_32 (abfd, in->regmask, ex->p_regmask); 946 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset); 947 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask); 948 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset); 949 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset); 950 951 H_PUT_16 (abfd, in->framereg, ex->p_framereg); 952 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg); 953 954 H_PUT_32 (abfd, in->irpss, ex->p_irpss); 955} 956 957/* Create a runtime procedure table from the .mdebug section. */ 958 959static bfd_boolean 960mips_elf_create_procedure_table (void *handle, bfd *abfd, 961 struct bfd_link_info *info, asection *s, 962 struct ecoff_debug_info *debug) 963{ 964 const struct ecoff_debug_swap *swap; 965 HDRR *hdr = &debug->symbolic_header; 966 RPDR *rpdr, *rp; 967 struct rpdr_ext *erp; 968 void *rtproc; 969 struct pdr_ext *epdr; 970 struct sym_ext *esym; 971 char *ss, **sv; 972 char *str; 973 bfd_size_type size; 974 bfd_size_type count; 975 unsigned long sindex; 976 unsigned long i; 977 PDR pdr; 978 SYMR sym; 979 const char *no_name_func = _("static procedure (no name)"); 980 981 epdr = NULL; 982 rpdr = NULL; 983 esym = NULL; 984 ss = NULL; 985 sv = NULL; 986 987 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 988 989 sindex = strlen (no_name_func) + 1; 990 count = hdr->ipdMax; 991 if (count > 0) 992 { 993 size = swap->external_pdr_size; 994 995 epdr = bfd_malloc (size * count); 996 if (epdr == NULL) 997 goto error_return; 998 999 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr)) 1000 goto error_return; 1001 1002 size = sizeof (RPDR); 1003 rp = rpdr = bfd_malloc (size * count); 1004 if (rpdr == NULL) 1005 goto error_return; 1006 1007 size = sizeof (char *); 1008 sv = bfd_malloc (size * count); 1009 if (sv == NULL) 1010 goto error_return; 1011 1012 count = hdr->isymMax; 1013 size = swap->external_sym_size; 1014 esym = bfd_malloc (size * count); 1015 if (esym == NULL) 1016 goto error_return; 1017 1018 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym)) 1019 goto error_return; 1020 1021 count = hdr->issMax; 1022 ss = bfd_malloc (count); 1023 if (ss == NULL) 1024 goto error_return; 1025 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss)) 1026 goto error_return; 1027 1028 count = hdr->ipdMax; 1029 for (i = 0; i < (unsigned long) count; i++, rp++) 1030 { 1031 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr); 1032 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym); 1033 rp->adr = sym.value; 1034 rp->regmask = pdr.regmask; 1035 rp->regoffset = pdr.regoffset; 1036 rp->fregmask = pdr.fregmask; 1037 rp->fregoffset = pdr.fregoffset; 1038 rp->frameoffset = pdr.frameoffset; 1039 rp->framereg = pdr.framereg; 1040 rp->pcreg = pdr.pcreg; 1041 rp->irpss = sindex; 1042 sv[i] = ss + sym.iss; 1043 sindex += strlen (sv[i]) + 1; 1044 } 1045 } 1046 1047 size = sizeof (struct rpdr_ext) * (count + 2) + sindex; 1048 size = BFD_ALIGN (size, 16); 1049 rtproc = bfd_alloc (abfd, size); 1050 if (rtproc == NULL) 1051 { 1052 mips_elf_hash_table (info)->procedure_count = 0; 1053 goto error_return; 1054 } 1055 1056 mips_elf_hash_table (info)->procedure_count = count + 2; 1057 1058 erp = rtproc; 1059 memset (erp, 0, sizeof (struct rpdr_ext)); 1060 erp++; 1061 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2); 1062 strcpy (str, no_name_func); 1063 str += strlen (no_name_func) + 1; 1064 for (i = 0; i < count; i++) 1065 { 1066 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i); 1067 strcpy (str, sv[i]); 1068 str += strlen (sv[i]) + 1; 1069 } 1070 H_PUT_S32 (abfd, -1, (erp + count)->p_adr); 1071 1072 /* Set the size and contents of .rtproc section. */ 1073 s->size = size; 1074 s->contents = rtproc; 1075 1076 /* Skip this section later on (I don't think this currently 1077 matters, but someday it might). */ 1078 s->map_head.link_order = NULL; 1079 1080 if (epdr != NULL) 1081 free (epdr); 1082 if (rpdr != NULL) 1083 free (rpdr); 1084 if (esym != NULL) 1085 free (esym); 1086 if (ss != NULL) 1087 free (ss); 1088 if (sv != NULL) 1089 free (sv); 1090 1091 return TRUE; 1092 1093 error_return: 1094 if (epdr != NULL) 1095 free (epdr); 1096 if (rpdr != NULL) 1097 free (rpdr); 1098 if (esym != NULL) 1099 free (esym); 1100 if (ss != NULL) 1101 free (ss); 1102 if (sv != NULL) 1103 free (sv); 1104 return FALSE; 1105} 1106 1107/* Check the mips16 stubs for a particular symbol, and see if we can 1108 discard them. */ 1109 1110static bfd_boolean 1111mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h, 1112 void *data ATTRIBUTE_UNUSED) 1113{ 1114 if (h->root.root.type == bfd_link_hash_warning) 1115 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 1116 1117 if (h->fn_stub != NULL 1118 && ! h->need_fn_stub) 1119 { 1120 /* We don't need the fn_stub; the only references to this symbol 1121 are 16 bit calls. Clobber the size to 0 to prevent it from 1122 being included in the link. */ 1123 h->fn_stub->size = 0; 1124 h->fn_stub->flags &= ~SEC_RELOC; 1125 h->fn_stub->reloc_count = 0; 1126 h->fn_stub->flags |= SEC_EXCLUDE; 1127 } 1128 1129 if (h->call_stub != NULL 1130 && h->root.other == STO_MIPS16) 1131 { 1132 /* We don't need the call_stub; this is a 16 bit function, so 1133 calls from other 16 bit functions are OK. Clobber the size 1134 to 0 to prevent it from being included in the link. */ 1135 h->call_stub->size = 0; 1136 h->call_stub->flags &= ~SEC_RELOC; 1137 h->call_stub->reloc_count = 0; 1138 h->call_stub->flags |= SEC_EXCLUDE; 1139 } 1140 1141 if (h->call_fp_stub != NULL 1142 && h->root.other == STO_MIPS16) 1143 { 1144 /* We don't need the call_stub; this is a 16 bit function, so 1145 calls from other 16 bit functions are OK. Clobber the size 1146 to 0 to prevent it from being included in the link. */ 1147 h->call_fp_stub->size = 0; 1148 h->call_fp_stub->flags &= ~SEC_RELOC; 1149 h->call_fp_stub->reloc_count = 0; 1150 h->call_fp_stub->flags |= SEC_EXCLUDE; 1151 } 1152 1153 return TRUE; 1154} 1155 1156/* R_MIPS16_26 is used for the mips16 jal and jalx instructions. 1157 Most mips16 instructions are 16 bits, but these instructions 1158 are 32 bits. 1159 1160 The format of these instructions is: 1161 1162 +--------------+--------------------------------+ 1163 | JALX | X| Imm 20:16 | Imm 25:21 | 1164 +--------------+--------------------------------+ 1165 | Immediate 15:0 | 1166 +-----------------------------------------------+ 1167 1168 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx. 1169 Note that the immediate value in the first word is swapped. 1170 1171 When producing a relocatable object file, R_MIPS16_26 is 1172 handled mostly like R_MIPS_26. In particular, the addend is 1173 stored as a straight 26-bit value in a 32-bit instruction. 1174 (gas makes life simpler for itself by never adjusting a 1175 R_MIPS16_26 reloc to be against a section, so the addend is 1176 always zero). However, the 32 bit instruction is stored as 2 1177 16-bit values, rather than a single 32-bit value. In a 1178 big-endian file, the result is the same; in a little-endian 1179 file, the two 16-bit halves of the 32 bit value are swapped. 1180 This is so that a disassembler can recognize the jal 1181 instruction. 1182 1183 When doing a final link, R_MIPS16_26 is treated as a 32 bit 1184 instruction stored as two 16-bit values. The addend A is the 1185 contents of the targ26 field. The calculation is the same as 1186 R_MIPS_26. When storing the calculated value, reorder the 1187 immediate value as shown above, and don't forget to store the 1188 value as two 16-bit values. 1189 1190 To put it in MIPS ABI terms, the relocation field is T-targ26-16, 1191 defined as 1192 1193 big-endian: 1194 +--------+----------------------+ 1195 | | | 1196 | | targ26-16 | 1197 |31 26|25 0| 1198 +--------+----------------------+ 1199 1200 little-endian: 1201 +----------+------+-------------+ 1202 | | | | 1203 | sub1 | | sub2 | 1204 |0 9|10 15|16 31| 1205 +----------+--------------------+ 1206 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is 1207 ((sub1 << 16) | sub2)). 1208 1209 When producing a relocatable object file, the calculation is 1210 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 1211 When producing a fully linked file, the calculation is 1212 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2) 1213 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) 1214 1215 R_MIPS16_GPREL is used for GP-relative addressing in mips16 1216 mode. A typical instruction will have a format like this: 1217 1218 +--------------+--------------------------------+ 1219 | EXTEND | Imm 10:5 | Imm 15:11 | 1220 +--------------+--------------------------------+ 1221 | Major | rx | ry | Imm 4:0 | 1222 +--------------+--------------------------------+ 1223 1224 EXTEND is the five bit value 11110. Major is the instruction 1225 opcode. 1226 1227 This is handled exactly like R_MIPS_GPREL16, except that the 1228 addend is retrieved and stored as shown in this diagram; that 1229 is, the Imm fields above replace the V-rel16 field. 1230 1231 All we need to do here is shuffle the bits appropriately. As 1232 above, the two 16-bit halves must be swapped on a 1233 little-endian system. 1234 1235 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to 1236 access data when neither GP-relative nor PC-relative addressing 1237 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16, 1238 except that the addend is retrieved and stored as shown above 1239 for R_MIPS16_GPREL. 1240 */ 1241void 1242_bfd_mips16_elf_reloc_unshuffle (bfd *abfd, int r_type, 1243 bfd_boolean jal_shuffle, bfd_byte *data) 1244{ 1245 bfd_vma extend, insn, val; 1246 1247 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL 1248 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16) 1249 return; 1250 1251 /* Pick up the mips16 extend instruction and the real instruction. */ 1252 extend = bfd_get_16 (abfd, data); 1253 insn = bfd_get_16 (abfd, data + 2); 1254 if (r_type == R_MIPS16_26) 1255 { 1256 if (jal_shuffle) 1257 val = ((extend & 0xfc00) << 16) | ((extend & 0x3e0) << 11) 1258 | ((extend & 0x1f) << 21) | insn; 1259 else 1260 val = extend << 16 | insn; 1261 } 1262 else 1263 val = ((extend & 0xf800) << 16) | ((insn & 0xffe0) << 11) 1264 | ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f); 1265 bfd_put_32 (abfd, val, data); 1266} 1267 1268void 1269_bfd_mips16_elf_reloc_shuffle (bfd *abfd, int r_type, 1270 bfd_boolean jal_shuffle, bfd_byte *data) 1271{ 1272 bfd_vma extend, insn, val; 1273 1274 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL 1275 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16) 1276 return; 1277 1278 val = bfd_get_32 (abfd, data); 1279 if (r_type == R_MIPS16_26) 1280 { 1281 if (jal_shuffle) 1282 { 1283 insn = val & 0xffff; 1284 extend = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0) 1285 | ((val >> 21) & 0x1f); 1286 } 1287 else 1288 { 1289 insn = val & 0xffff; 1290 extend = val >> 16; 1291 } 1292 } 1293 else 1294 { 1295 insn = ((val >> 11) & 0xffe0) | (val & 0x1f); 1296 extend = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0); 1297 } 1298 bfd_put_16 (abfd, insn, data + 2); 1299 bfd_put_16 (abfd, extend, data); 1300} 1301 1302bfd_reloc_status_type 1303_bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol, 1304 arelent *reloc_entry, asection *input_section, 1305 bfd_boolean relocatable, void *data, bfd_vma gp) 1306{ 1307 bfd_vma relocation; 1308 bfd_signed_vma val; 1309 bfd_reloc_status_type status; 1310 1311 if (bfd_is_com_section (symbol->section)) 1312 relocation = 0; 1313 else 1314 relocation = symbol->value; 1315 1316 relocation += symbol->section->output_section->vma; 1317 relocation += symbol->section->output_offset; 1318 1319 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1320 return bfd_reloc_outofrange; 1321 1322 /* Set val to the offset into the section or symbol. */ 1323 val = reloc_entry->addend; 1324 1325 _bfd_mips_elf_sign_extend (val, 16); 1326 1327 /* Adjust val for the final section location and GP value. If we 1328 are producing relocatable output, we don't want to do this for 1329 an external symbol. */ 1330 if (! relocatable 1331 || (symbol->flags & BSF_SECTION_SYM) != 0) 1332 val += relocation - gp; 1333 1334 if (reloc_entry->howto->partial_inplace) 1335 { 1336 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val, 1337 (bfd_byte *) data 1338 + reloc_entry->address); 1339 if (status != bfd_reloc_ok) 1340 return status; 1341 } 1342 else 1343 reloc_entry->addend = val; 1344 1345 if (relocatable) 1346 reloc_entry->address += input_section->output_offset; 1347 1348 return bfd_reloc_ok; 1349} 1350 1351/* Used to store a REL high-part relocation such as R_MIPS_HI16 or 1352 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section 1353 that contains the relocation field and DATA points to the start of 1354 INPUT_SECTION. */ 1355 1356struct mips_hi16 1357{ 1358 struct mips_hi16 *next; 1359 bfd_byte *data; 1360 asection *input_section; 1361 arelent rel; 1362}; 1363 1364/* FIXME: This should not be a static variable. */ 1365 1366static struct mips_hi16 *mips_hi16_list; 1367 1368/* A howto special_function for REL *HI16 relocations. We can only 1369 calculate the correct value once we've seen the partnering 1370 *LO16 relocation, so just save the information for later. 1371 1372 The ABI requires that the *LO16 immediately follow the *HI16. 1373 However, as a GNU extension, we permit an arbitrary number of 1374 *HI16s to be associated with a single *LO16. This significantly 1375 simplies the relocation handling in gcc. */ 1376 1377bfd_reloc_status_type 1378_bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry, 1379 asymbol *symbol ATTRIBUTE_UNUSED, void *data, 1380 asection *input_section, bfd *output_bfd, 1381 char **error_message ATTRIBUTE_UNUSED) 1382{ 1383 struct mips_hi16 *n; 1384 1385 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1386 return bfd_reloc_outofrange; 1387 1388 n = bfd_malloc (sizeof *n); 1389 if (n == NULL) 1390 return bfd_reloc_outofrange; 1391 1392 n->next = mips_hi16_list; 1393 n->data = data; 1394 n->input_section = input_section; 1395 n->rel = *reloc_entry; 1396 mips_hi16_list = n; 1397 1398 if (output_bfd != NULL) 1399 reloc_entry->address += input_section->output_offset; 1400 1401 return bfd_reloc_ok; 1402} 1403 1404/* A howto special_function for REL R_MIPS_GOT16 relocations. This is just 1405 like any other 16-bit relocation when applied to global symbols, but is 1406 treated in the same as R_MIPS_HI16 when applied to local symbols. */ 1407 1408bfd_reloc_status_type 1409_bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 1410 void *data, asection *input_section, 1411 bfd *output_bfd, char **error_message) 1412{ 1413 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0 1414 || bfd_is_und_section (bfd_get_section (symbol)) 1415 || bfd_is_com_section (bfd_get_section (symbol))) 1416 /* The relocation is against a global symbol. */ 1417 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data, 1418 input_section, output_bfd, 1419 error_message); 1420 1421 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data, 1422 input_section, output_bfd, error_message); 1423} 1424 1425/* A howto special_function for REL *LO16 relocations. The *LO16 itself 1426 is a straightforward 16 bit inplace relocation, but we must deal with 1427 any partnering high-part relocations as well. */ 1428 1429bfd_reloc_status_type 1430_bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 1431 void *data, asection *input_section, 1432 bfd *output_bfd, char **error_message) 1433{ 1434 bfd_vma vallo; 1435 bfd_byte *location = (bfd_byte *) data + reloc_entry->address; 1436 1437 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1438 return bfd_reloc_outofrange; 1439 1440 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE, 1441 location); 1442 vallo = bfd_get_32 (abfd, location); 1443 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE, 1444 location); 1445 1446 while (mips_hi16_list != NULL) 1447 { 1448 bfd_reloc_status_type ret; 1449 struct mips_hi16 *hi; 1450 1451 hi = mips_hi16_list; 1452 1453 /* R_MIPS_GOT16 relocations are something of a special case. We 1454 want to install the addend in the same way as for a R_MIPS_HI16 1455 relocation (with a rightshift of 16). However, since GOT16 1456 relocations can also be used with global symbols, their howto 1457 has a rightshift of 0. */ 1458 if (hi->rel.howto->type == R_MIPS_GOT16) 1459 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE); 1460 1461 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any 1462 carry or borrow will induce a change of +1 or -1 in the high part. */ 1463 hi->rel.addend += (vallo + 0x8000) & 0xffff; 1464 1465 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data, 1466 hi->input_section, output_bfd, 1467 error_message); 1468 if (ret != bfd_reloc_ok) 1469 return ret; 1470 1471 mips_hi16_list = hi->next; 1472 free (hi); 1473 } 1474 1475 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data, 1476 input_section, output_bfd, 1477 error_message); 1478} 1479 1480/* A generic howto special_function. This calculates and installs the 1481 relocation itself, thus avoiding the oft-discussed problems in 1482 bfd_perform_relocation and bfd_install_relocation. */ 1483 1484bfd_reloc_status_type 1485_bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry, 1486 asymbol *symbol, void *data ATTRIBUTE_UNUSED, 1487 asection *input_section, bfd *output_bfd, 1488 char **error_message ATTRIBUTE_UNUSED) 1489{ 1490 bfd_signed_vma val; 1491 bfd_reloc_status_type status; 1492 bfd_boolean relocatable; 1493 1494 relocatable = (output_bfd != NULL); 1495 1496 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1497 return bfd_reloc_outofrange; 1498 1499 /* Build up the field adjustment in VAL. */ 1500 val = 0; 1501 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0) 1502 { 1503 /* Either we're calculating the final field value or we have a 1504 relocation against a section symbol. Add in the section's 1505 offset or address. */ 1506 val += symbol->section->output_section->vma; 1507 val += symbol->section->output_offset; 1508 } 1509 1510 if (!relocatable) 1511 { 1512 /* We're calculating the final field value. Add in the symbol's value 1513 and, if pc-relative, subtract the address of the field itself. */ 1514 val += symbol->value; 1515 if (reloc_entry->howto->pc_relative) 1516 { 1517 val -= input_section->output_section->vma; 1518 val -= input_section->output_offset; 1519 val -= reloc_entry->address; 1520 } 1521 } 1522 1523 /* VAL is now the final adjustment. If we're keeping this relocation 1524 in the output file, and if the relocation uses a separate addend, 1525 we just need to add VAL to that addend. Otherwise we need to add 1526 VAL to the relocation field itself. */ 1527 if (relocatable && !reloc_entry->howto->partial_inplace) 1528 reloc_entry->addend += val; 1529 else 1530 { 1531 bfd_byte *location = (bfd_byte *) data + reloc_entry->address; 1532 1533 /* Add in the separate addend, if any. */ 1534 val += reloc_entry->addend; 1535 1536 /* Add VAL to the relocation field. */ 1537 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE, 1538 location); 1539 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val, 1540 location); 1541 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE, 1542 location); 1543 1544 if (status != bfd_reloc_ok) 1545 return status; 1546 } 1547 1548 if (relocatable) 1549 reloc_entry->address += input_section->output_offset; 1550 1551 return bfd_reloc_ok; 1552} 1553 1554/* Swap an entry in a .gptab section. Note that these routines rely 1555 on the equivalence of the two elements of the union. */ 1556 1557static void 1558bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex, 1559 Elf32_gptab *in) 1560{ 1561 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value); 1562 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes); 1563} 1564 1565static void 1566bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in, 1567 Elf32_External_gptab *ex) 1568{ 1569 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value); 1570 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes); 1571} 1572 1573static void 1574bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in, 1575 Elf32_External_compact_rel *ex) 1576{ 1577 H_PUT_32 (abfd, in->id1, ex->id1); 1578 H_PUT_32 (abfd, in->num, ex->num); 1579 H_PUT_32 (abfd, in->id2, ex->id2); 1580 H_PUT_32 (abfd, in->offset, ex->offset); 1581 H_PUT_32 (abfd, in->reserved0, ex->reserved0); 1582 H_PUT_32 (abfd, in->reserved1, ex->reserved1); 1583} 1584 1585static void 1586bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in, 1587 Elf32_External_crinfo *ex) 1588{ 1589 unsigned long l; 1590 1591 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH) 1592 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH) 1593 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH) 1594 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH)); 1595 H_PUT_32 (abfd, l, ex->info); 1596 H_PUT_32 (abfd, in->konst, ex->konst); 1597 H_PUT_32 (abfd, in->vaddr, ex->vaddr); 1598} 1599 1600/* A .reginfo section holds a single Elf32_RegInfo structure. These 1601 routines swap this structure in and out. They are used outside of 1602 BFD, so they are globally visible. */ 1603 1604void 1605bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex, 1606 Elf32_RegInfo *in) 1607{ 1608 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask); 1609 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]); 1610 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]); 1611 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]); 1612 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]); 1613 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value); 1614} 1615 1616void 1617bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in, 1618 Elf32_External_RegInfo *ex) 1619{ 1620 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask); 1621 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]); 1622 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]); 1623 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]); 1624 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]); 1625 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value); 1626} 1627 1628/* In the 64 bit ABI, the .MIPS.options section holds register 1629 information in an Elf64_Reginfo structure. These routines swap 1630 them in and out. They are globally visible because they are used 1631 outside of BFD. These routines are here so that gas can call them 1632 without worrying about whether the 64 bit ABI has been included. */ 1633 1634void 1635bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex, 1636 Elf64_Internal_RegInfo *in) 1637{ 1638 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask); 1639 in->ri_pad = H_GET_32 (abfd, ex->ri_pad); 1640 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]); 1641 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]); 1642 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]); 1643 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]); 1644 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value); 1645} 1646 1647void 1648bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in, 1649 Elf64_External_RegInfo *ex) 1650{ 1651 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask); 1652 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad); 1653 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]); 1654 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]); 1655 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]); 1656 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]); 1657 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value); 1658} 1659 1660/* Swap in an options header. */ 1661 1662void 1663bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex, 1664 Elf_Internal_Options *in) 1665{ 1666 in->kind = H_GET_8 (abfd, ex->kind); 1667 in->size = H_GET_8 (abfd, ex->size); 1668 in->section = H_GET_16 (abfd, ex->section); 1669 in->info = H_GET_32 (abfd, ex->info); 1670} 1671 1672/* Swap out an options header. */ 1673 1674void 1675bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in, 1676 Elf_External_Options *ex) 1677{ 1678 H_PUT_8 (abfd, in->kind, ex->kind); 1679 H_PUT_8 (abfd, in->size, ex->size); 1680 H_PUT_16 (abfd, in->section, ex->section); 1681 H_PUT_32 (abfd, in->info, ex->info); 1682} 1683 1684/* This function is called via qsort() to sort the dynamic relocation 1685 entries by increasing r_symndx value. */ 1686 1687static int 1688sort_dynamic_relocs (const void *arg1, const void *arg2) 1689{ 1690 Elf_Internal_Rela int_reloc1; 1691 Elf_Internal_Rela int_reloc2; 1692 1693 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1); 1694 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2); 1695 1696 return ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info); 1697} 1698 1699/* Like sort_dynamic_relocs, but used for elf64 relocations. */ 1700 1701static int 1702sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED, 1703 const void *arg2 ATTRIBUTE_UNUSED) 1704{ 1705#ifdef BFD64 1706 Elf_Internal_Rela int_reloc1[3]; 1707 Elf_Internal_Rela int_reloc2[3]; 1708 1709 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in) 1710 (reldyn_sorting_bfd, arg1, int_reloc1); 1711 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in) 1712 (reldyn_sorting_bfd, arg2, int_reloc2); 1713 1714 return (ELF64_R_SYM (int_reloc1[0].r_info) 1715 - ELF64_R_SYM (int_reloc2[0].r_info)); 1716#else 1717 abort (); 1718#endif 1719} 1720 1721 1722/* This routine is used to write out ECOFF debugging external symbol 1723 information. It is called via mips_elf_link_hash_traverse. The 1724 ECOFF external symbol information must match the ELF external 1725 symbol information. Unfortunately, at this point we don't know 1726 whether a symbol is required by reloc information, so the two 1727 tables may wind up being different. We must sort out the external 1728 symbol information before we can set the final size of the .mdebug 1729 section, and we must set the size of the .mdebug section before we 1730 can relocate any sections, and we can't know which symbols are 1731 required by relocation until we relocate the sections. 1732 Fortunately, it is relatively unlikely that any symbol will be 1733 stripped but required by a reloc. In particular, it can not happen 1734 when generating a final executable. */ 1735 1736static bfd_boolean 1737mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data) 1738{ 1739 struct extsym_info *einfo = data; 1740 bfd_boolean strip; 1741 asection *sec, *output_section; 1742 1743 if (h->root.root.type == bfd_link_hash_warning) 1744 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 1745 1746 if (h->root.indx == -2) 1747 strip = FALSE; 1748 else if ((h->root.def_dynamic 1749 || h->root.ref_dynamic 1750 || h->root.type == bfd_link_hash_new) 1751 && !h->root.def_regular 1752 && !h->root.ref_regular) 1753 strip = TRUE; 1754 else if (einfo->info->strip == strip_all 1755 || (einfo->info->strip == strip_some 1756 && bfd_hash_lookup (einfo->info->keep_hash, 1757 h->root.root.root.string, 1758 FALSE, FALSE) == NULL)) 1759 strip = TRUE; 1760 else 1761 strip = FALSE; 1762 1763 if (strip) 1764 return TRUE; 1765 1766 if (h->esym.ifd == -2) 1767 { 1768 h->esym.jmptbl = 0; 1769 h->esym.cobol_main = 0; 1770 h->esym.weakext = 0; 1771 h->esym.reserved = 0; 1772 h->esym.ifd = ifdNil; 1773 h->esym.asym.value = 0; 1774 h->esym.asym.st = stGlobal; 1775 1776 if (h->root.root.type == bfd_link_hash_undefined 1777 || h->root.root.type == bfd_link_hash_undefweak) 1778 { 1779 const char *name; 1780 1781 /* Use undefined class. Also, set class and type for some 1782 special symbols. */ 1783 name = h->root.root.root.string; 1784 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0 1785 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0) 1786 { 1787 h->esym.asym.sc = scData; 1788 h->esym.asym.st = stLabel; 1789 h->esym.asym.value = 0; 1790 } 1791 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0) 1792 { 1793 h->esym.asym.sc = scAbs; 1794 h->esym.asym.st = stLabel; 1795 h->esym.asym.value = 1796 mips_elf_hash_table (einfo->info)->procedure_count; 1797 } 1798 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd)) 1799 { 1800 h->esym.asym.sc = scAbs; 1801 h->esym.asym.st = stLabel; 1802 h->esym.asym.value = elf_gp (einfo->abfd); 1803 } 1804 else 1805 h->esym.asym.sc = scUndefined; 1806 } 1807 else if (h->root.root.type != bfd_link_hash_defined 1808 && h->root.root.type != bfd_link_hash_defweak) 1809 h->esym.asym.sc = scAbs; 1810 else 1811 { 1812 const char *name; 1813 1814 sec = h->root.root.u.def.section; 1815 output_section = sec->output_section; 1816 1817 /* When making a shared library and symbol h is the one from 1818 the another shared library, OUTPUT_SECTION may be null. */ 1819 if (output_section == NULL) 1820 h->esym.asym.sc = scUndefined; 1821 else 1822 { 1823 name = bfd_section_name (output_section->owner, output_section); 1824 1825 if (strcmp (name, ".text") == 0) 1826 h->esym.asym.sc = scText; 1827 else if (strcmp (name, ".data") == 0) 1828 h->esym.asym.sc = scData; 1829 else if (strcmp (name, ".sdata") == 0) 1830 h->esym.asym.sc = scSData; 1831 else if (strcmp (name, ".rodata") == 0 1832 || strcmp (name, ".rdata") == 0) 1833 h->esym.asym.sc = scRData; 1834 else if (strcmp (name, ".bss") == 0) 1835 h->esym.asym.sc = scBss; 1836 else if (strcmp (name, ".sbss") == 0) 1837 h->esym.asym.sc = scSBss; 1838 else if (strcmp (name, ".init") == 0) 1839 h->esym.asym.sc = scInit; 1840 else if (strcmp (name, ".fini") == 0) 1841 h->esym.asym.sc = scFini; 1842 else 1843 h->esym.asym.sc = scAbs; 1844 } 1845 } 1846 1847 h->esym.asym.reserved = 0; 1848 h->esym.asym.index = indexNil; 1849 } 1850 1851 if (h->root.root.type == bfd_link_hash_common) 1852 h->esym.asym.value = h->root.root.u.c.size; 1853 else if (h->root.root.type == bfd_link_hash_defined 1854 || h->root.root.type == bfd_link_hash_defweak) 1855 { 1856 if (h->esym.asym.sc == scCommon) 1857 h->esym.asym.sc = scBss; 1858 else if (h->esym.asym.sc == scSCommon) 1859 h->esym.asym.sc = scSBss; 1860 1861 sec = h->root.root.u.def.section; 1862 output_section = sec->output_section; 1863 if (output_section != NULL) 1864 h->esym.asym.value = (h->root.root.u.def.value 1865 + sec->output_offset 1866 + output_section->vma); 1867 else 1868 h->esym.asym.value = 0; 1869 } 1870 else if (h->root.needs_plt) 1871 { 1872 struct mips_elf_link_hash_entry *hd = h; 1873 bfd_boolean no_fn_stub = h->no_fn_stub; 1874 1875 while (hd->root.root.type == bfd_link_hash_indirect) 1876 { 1877 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link; 1878 no_fn_stub = no_fn_stub || hd->no_fn_stub; 1879 } 1880 1881 if (!no_fn_stub) 1882 { 1883 /* Set type and value for a symbol with a function stub. */ 1884 h->esym.asym.st = stProc; 1885 sec = hd->root.root.u.def.section; 1886 if (sec == NULL) 1887 h->esym.asym.value = 0; 1888 else 1889 { 1890 output_section = sec->output_section; 1891 if (output_section != NULL) 1892 h->esym.asym.value = (hd->root.plt.offset 1893 + sec->output_offset 1894 + output_section->vma); 1895 else 1896 h->esym.asym.value = 0; 1897 } 1898 } 1899 } 1900 1901 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap, 1902 h->root.root.root.string, 1903 &h->esym)) 1904 { 1905 einfo->failed = TRUE; 1906 return FALSE; 1907 } 1908 1909 return TRUE; 1910} 1911 1912/* A comparison routine used to sort .gptab entries. */ 1913 1914static int 1915gptab_compare (const void *p1, const void *p2) 1916{ 1917 const Elf32_gptab *a1 = p1; 1918 const Elf32_gptab *a2 = p2; 1919 1920 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value; 1921} 1922 1923/* Functions to manage the got entry hash table. */ 1924 1925/* Use all 64 bits of a bfd_vma for the computation of a 32-bit 1926 hash number. */ 1927 1928static INLINE hashval_t 1929mips_elf_hash_bfd_vma (bfd_vma addr) 1930{ 1931#ifdef BFD64 1932 return addr + (addr >> 32); 1933#else 1934 return addr; 1935#endif 1936} 1937 1938/* got_entries only match if they're identical, except for gotidx, so 1939 use all fields to compute the hash, and compare the appropriate 1940 union members. */ 1941 1942static hashval_t 1943mips_elf_got_entry_hash (const void *entry_) 1944{ 1945 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_; 1946 1947 return entry->symndx 1948 + ((entry->tls_type & GOT_TLS_LDM) << 17) 1949 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address) 1950 : entry->abfd->id 1951 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend) 1952 : entry->d.h->root.root.root.hash)); 1953} 1954 1955static int 1956mips_elf_got_entry_eq (const void *entry1, const void *entry2) 1957{ 1958 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1; 1959 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2; 1960 1961 /* An LDM entry can only match another LDM entry. */ 1962 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM) 1963 return 0; 1964 1965 return e1->abfd == e2->abfd && e1->symndx == e2->symndx 1966 && (! e1->abfd ? e1->d.address == e2->d.address 1967 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend 1968 : e1->d.h == e2->d.h); 1969} 1970 1971/* multi_got_entries are still a match in the case of global objects, 1972 even if the input bfd in which they're referenced differs, so the 1973 hash computation and compare functions are adjusted 1974 accordingly. */ 1975 1976static hashval_t 1977mips_elf_multi_got_entry_hash (const void *entry_) 1978{ 1979 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_; 1980 1981 return entry->symndx 1982 + (! entry->abfd 1983 ? mips_elf_hash_bfd_vma (entry->d.address) 1984 : entry->symndx >= 0 1985 ? ((entry->tls_type & GOT_TLS_LDM) 1986 ? (GOT_TLS_LDM << 17) 1987 : (entry->abfd->id 1988 + mips_elf_hash_bfd_vma (entry->d.addend))) 1989 : entry->d.h->root.root.root.hash); 1990} 1991 1992static int 1993mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2) 1994{ 1995 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1; 1996 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2; 1997 1998 /* Any two LDM entries match. */ 1999 if (e1->tls_type & e2->tls_type & GOT_TLS_LDM) 2000 return 1; 2001 2002 /* Nothing else matches an LDM entry. */ 2003 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM) 2004 return 0; 2005 2006 return e1->symndx == e2->symndx 2007 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend 2008 : e1->abfd == NULL || e2->abfd == NULL 2009 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address 2010 : e1->d.h == e2->d.h); 2011} 2012 2013/* Return the dynamic relocation section. If it doesn't exist, try to 2014 create a new it if CREATE_P, otherwise return NULL. Also return NULL 2015 if creation fails. */ 2016 2017static asection * 2018mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p) 2019{ 2020 const char *dname; 2021 asection *sreloc; 2022 bfd *dynobj; 2023 2024 dname = MIPS_ELF_REL_DYN_NAME (info); 2025 dynobj = elf_hash_table (info)->dynobj; 2026 sreloc = bfd_get_section_by_name (dynobj, dname); 2027 if (sreloc == NULL && create_p) 2028 { 2029 sreloc = bfd_make_section_with_flags (dynobj, dname, 2030 (SEC_ALLOC 2031 | SEC_LOAD 2032 | SEC_HAS_CONTENTS 2033 | SEC_IN_MEMORY 2034 | SEC_LINKER_CREATED 2035 | SEC_READONLY)); 2036 if (sreloc == NULL 2037 || ! bfd_set_section_alignment (dynobj, sreloc, 2038 MIPS_ELF_LOG_FILE_ALIGN (dynobj))) 2039 return NULL; 2040 } 2041 return sreloc; 2042} 2043 2044/* Returns the GOT section for ABFD. */ 2045 2046static asection * 2047mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded) 2048{ 2049 asection *sgot = bfd_get_section_by_name (abfd, ".got"); 2050 if (sgot == NULL 2051 || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0)) 2052 return NULL; 2053 return sgot; 2054} 2055 2056/* Returns the GOT information associated with the link indicated by 2057 INFO. If SGOTP is non-NULL, it is filled in with the GOT 2058 section. */ 2059 2060static struct mips_got_info * 2061mips_elf_got_info (bfd *abfd, asection **sgotp) 2062{ 2063 asection *sgot; 2064 struct mips_got_info *g; 2065 2066 sgot = mips_elf_got_section (abfd, TRUE); 2067 BFD_ASSERT (sgot != NULL); 2068 BFD_ASSERT (mips_elf_section_data (sgot) != NULL); 2069 g = mips_elf_section_data (sgot)->u.got_info; 2070 BFD_ASSERT (g != NULL); 2071 2072 if (sgotp) 2073 *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL; 2074 2075 return g; 2076} 2077 2078/* Count the number of relocations needed for a TLS GOT entry, with 2079 access types from TLS_TYPE, and symbol H (or a local symbol if H 2080 is NULL). */ 2081 2082static int 2083mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type, 2084 struct elf_link_hash_entry *h) 2085{ 2086 int indx = 0; 2087 int ret = 0; 2088 bfd_boolean need_relocs = FALSE; 2089 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created; 2090 2091 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 2092 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h))) 2093 indx = h->dynindx; 2094 2095 if ((info->shared || indx != 0) 2096 && (h == NULL 2097 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2098 || h->root.type != bfd_link_hash_undefweak)) 2099 need_relocs = TRUE; 2100 2101 if (!need_relocs) 2102 return FALSE; 2103 2104 if (tls_type & GOT_TLS_GD) 2105 { 2106 ret++; 2107 if (indx != 0) 2108 ret++; 2109 } 2110 2111 if (tls_type & GOT_TLS_IE) 2112 ret++; 2113 2114 if ((tls_type & GOT_TLS_LDM) && info->shared) 2115 ret++; 2116 2117 return ret; 2118} 2119 2120/* Count the number of TLS relocations required for the GOT entry in 2121 ARG1, if it describes a local symbol. */ 2122 2123static int 2124mips_elf_count_local_tls_relocs (void **arg1, void *arg2) 2125{ 2126 struct mips_got_entry *entry = * (struct mips_got_entry **) arg1; 2127 struct mips_elf_count_tls_arg *arg = arg2; 2128 2129 if (entry->abfd != NULL && entry->symndx != -1) 2130 arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL); 2131 2132 return 1; 2133} 2134 2135/* Count the number of TLS GOT entries required for the global (or 2136 forced-local) symbol in ARG1. */ 2137 2138static int 2139mips_elf_count_global_tls_entries (void *arg1, void *arg2) 2140{ 2141 struct mips_elf_link_hash_entry *hm 2142 = (struct mips_elf_link_hash_entry *) arg1; 2143 struct mips_elf_count_tls_arg *arg = arg2; 2144 2145 if (hm->tls_type & GOT_TLS_GD) 2146 arg->needed += 2; 2147 if (hm->tls_type & GOT_TLS_IE) 2148 arg->needed += 1; 2149 2150 return 1; 2151} 2152 2153/* Count the number of TLS relocations required for the global (or 2154 forced-local) symbol in ARG1. */ 2155 2156static int 2157mips_elf_count_global_tls_relocs (void *arg1, void *arg2) 2158{ 2159 struct mips_elf_link_hash_entry *hm 2160 = (struct mips_elf_link_hash_entry *) arg1; 2161 struct mips_elf_count_tls_arg *arg = arg2; 2162 2163 arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root); 2164 2165 return 1; 2166} 2167 2168/* Output a simple dynamic relocation into SRELOC. */ 2169 2170static void 2171mips_elf_output_dynamic_relocation (bfd *output_bfd, 2172 asection *sreloc, 2173 unsigned long indx, 2174 int r_type, 2175 bfd_vma offset) 2176{ 2177 Elf_Internal_Rela rel[3]; 2178 2179 memset (rel, 0, sizeof (rel)); 2180 2181 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type); 2182 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset; 2183 2184 if (ABI_64_P (output_bfd)) 2185 { 2186 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out) 2187 (output_bfd, &rel[0], 2188 (sreloc->contents 2189 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel))); 2190 } 2191 else 2192 bfd_elf32_swap_reloc_out 2193 (output_bfd, &rel[0], 2194 (sreloc->contents 2195 + sreloc->reloc_count * sizeof (Elf32_External_Rel))); 2196 ++sreloc->reloc_count; 2197} 2198 2199/* Initialize a set of TLS GOT entries for one symbol. */ 2200 2201static void 2202mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset, 2203 unsigned char *tls_type_p, 2204 struct bfd_link_info *info, 2205 struct mips_elf_link_hash_entry *h, 2206 bfd_vma value) 2207{ 2208 int indx; 2209 asection *sreloc, *sgot; 2210 bfd_vma offset, offset2; 2211 bfd *dynobj; 2212 bfd_boolean need_relocs = FALSE; 2213 2214 dynobj = elf_hash_table (info)->dynobj; 2215 sgot = mips_elf_got_section (dynobj, FALSE); 2216 2217 indx = 0; 2218 if (h != NULL) 2219 { 2220 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created; 2221 2222 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root) 2223 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root))) 2224 indx = h->root.dynindx; 2225 } 2226 2227 if (*tls_type_p & GOT_TLS_DONE) 2228 return; 2229 2230 if ((info->shared || indx != 0) 2231 && (h == NULL 2232 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT 2233 || h->root.type != bfd_link_hash_undefweak)) 2234 need_relocs = TRUE; 2235 2236 /* MINUS_ONE means the symbol is not defined in this object. It may not 2237 be defined at all; assume that the value doesn't matter in that 2238 case. Otherwise complain if we would use the value. */ 2239 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs) 2240 || h->root.root.type == bfd_link_hash_undefweak); 2241 2242 /* Emit necessary relocations. */ 2243 sreloc = mips_elf_rel_dyn_section (info, FALSE); 2244 2245 /* General Dynamic. */ 2246 if (*tls_type_p & GOT_TLS_GD) 2247 { 2248 offset = got_offset; 2249 offset2 = offset + MIPS_ELF_GOT_SIZE (abfd); 2250 2251 if (need_relocs) 2252 { 2253 mips_elf_output_dynamic_relocation 2254 (abfd, sreloc, indx, 2255 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32, 2256 sgot->output_offset + sgot->output_section->vma + offset); 2257 2258 if (indx) 2259 mips_elf_output_dynamic_relocation 2260 (abfd, sreloc, indx, 2261 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32, 2262 sgot->output_offset + sgot->output_section->vma + offset2); 2263 else 2264 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info), 2265 sgot->contents + offset2); 2266 } 2267 else 2268 { 2269 MIPS_ELF_PUT_WORD (abfd, 1, 2270 sgot->contents + offset); 2271 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info), 2272 sgot->contents + offset2); 2273 } 2274 2275 got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd); 2276 } 2277 2278 /* Initial Exec model. */ 2279 if (*tls_type_p & GOT_TLS_IE) 2280 { 2281 offset = got_offset; 2282 2283 if (need_relocs) 2284 { 2285 if (indx == 0) 2286 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma, 2287 sgot->contents + offset); 2288 else 2289 MIPS_ELF_PUT_WORD (abfd, 0, 2290 sgot->contents + offset); 2291 2292 mips_elf_output_dynamic_relocation 2293 (abfd, sreloc, indx, 2294 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32, 2295 sgot->output_offset + sgot->output_section->vma + offset); 2296 } 2297 else 2298 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info), 2299 sgot->contents + offset); 2300 } 2301 2302 if (*tls_type_p & GOT_TLS_LDM) 2303 { 2304 /* The initial offset is zero, and the LD offsets will include the 2305 bias by DTP_OFFSET. */ 2306 MIPS_ELF_PUT_WORD (abfd, 0, 2307 sgot->contents + got_offset 2308 + MIPS_ELF_GOT_SIZE (abfd)); 2309 2310 if (!info->shared) 2311 MIPS_ELF_PUT_WORD (abfd, 1, 2312 sgot->contents + got_offset); 2313 else 2314 mips_elf_output_dynamic_relocation 2315 (abfd, sreloc, indx, 2316 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32, 2317 sgot->output_offset + sgot->output_section->vma + got_offset); 2318 } 2319 2320 *tls_type_p |= GOT_TLS_DONE; 2321} 2322 2323/* Return the GOT index to use for a relocation of type R_TYPE against 2324 a symbol accessed using TLS_TYPE models. The GOT entries for this 2325 symbol in this GOT start at GOT_INDEX. This function initializes the 2326 GOT entries and corresponding relocations. */ 2327 2328static bfd_vma 2329mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type, 2330 int r_type, struct bfd_link_info *info, 2331 struct mips_elf_link_hash_entry *h, bfd_vma symbol) 2332{ 2333 BFD_ASSERT (r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MIPS_TLS_GD 2334 || r_type == R_MIPS_TLS_LDM); 2335 2336 mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol); 2337 2338 if (r_type == R_MIPS_TLS_GOTTPREL) 2339 { 2340 BFD_ASSERT (*tls_type & GOT_TLS_IE); 2341 if (*tls_type & GOT_TLS_GD) 2342 return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd); 2343 else 2344 return got_index; 2345 } 2346 2347 if (r_type == R_MIPS_TLS_GD) 2348 { 2349 BFD_ASSERT (*tls_type & GOT_TLS_GD); 2350 return got_index; 2351 } 2352 2353 if (r_type == R_MIPS_TLS_LDM) 2354 { 2355 BFD_ASSERT (*tls_type & GOT_TLS_LDM); 2356 return got_index; 2357 } 2358 2359 return got_index; 2360} 2361 2362/* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry 2363 for global symbol H. .got.plt comes before the GOT, so the offset 2364 will be negative. */ 2365 2366static bfd_vma 2367mips_elf_gotplt_index (struct bfd_link_info *info, 2368 struct elf_link_hash_entry *h) 2369{ 2370 bfd_vma plt_index, got_address, got_value; 2371 struct mips_elf_link_hash_table *htab; 2372 2373 htab = mips_elf_hash_table (info); 2374 BFD_ASSERT (h->plt.offset != (bfd_vma) -1); 2375 2376 /* Calculate the index of the symbol's PLT entry. */ 2377 plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size; 2378 2379 /* Calculate the address of the associated .got.plt entry. */ 2380 got_address = (htab->sgotplt->output_section->vma 2381 + htab->sgotplt->output_offset 2382 + plt_index * 4); 2383 2384 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */ 2385 got_value = (htab->root.hgot->root.u.def.section->output_section->vma 2386 + htab->root.hgot->root.u.def.section->output_offset 2387 + htab->root.hgot->root.u.def.value); 2388 2389 return got_address - got_value; 2390} 2391 2392/* Return the GOT offset for address VALUE, which was derived from 2393 a symbol belonging to INPUT_SECTION. If there is not yet a GOT 2394 entry for this value, create one. If R_SYMNDX refers to a TLS symbol, 2395 create a TLS GOT entry instead. Return -1 if no satisfactory GOT 2396 offset can be found. */ 2397 2398static bfd_vma 2399mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 2400 asection *input_section, bfd_vma value, 2401 unsigned long r_symndx, 2402 struct mips_elf_link_hash_entry *h, int r_type) 2403{ 2404 asection *sgot; 2405 struct mips_got_info *g; 2406 struct mips_got_entry *entry; 2407 2408 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot); 2409 2410 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot, 2411 input_section, value, 2412 r_symndx, h, r_type); 2413 if (!entry) 2414 return MINUS_ONE; 2415 2416 if (TLS_RELOC_P (r_type)) 2417 { 2418 if (entry->symndx == -1 && g->next == NULL) 2419 /* A type (3) entry in the single-GOT case. We use the symbol's 2420 hash table entry to track the index. */ 2421 return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type, 2422 r_type, info, h, value); 2423 else 2424 return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type, 2425 r_type, info, h, value); 2426 } 2427 else 2428 return entry->gotidx; 2429} 2430 2431/* Returns the GOT index for the global symbol indicated by H. */ 2432 2433static bfd_vma 2434mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h, 2435 int r_type, struct bfd_link_info *info) 2436{ 2437 bfd_vma index; 2438 asection *sgot; 2439 struct mips_got_info *g, *gg; 2440 long global_got_dynindx = 0; 2441 2442 gg = g = mips_elf_got_info (abfd, &sgot); 2443 if (g->bfd2got && ibfd) 2444 { 2445 struct mips_got_entry e, *p; 2446 2447 BFD_ASSERT (h->dynindx >= 0); 2448 2449 g = mips_elf_got_for_ibfd (g, ibfd); 2450 if (g->next != gg || TLS_RELOC_P (r_type)) 2451 { 2452 e.abfd = ibfd; 2453 e.symndx = -1; 2454 e.d.h = (struct mips_elf_link_hash_entry *)h; 2455 e.tls_type = 0; 2456 2457 p = htab_find (g->got_entries, &e); 2458 2459 BFD_ASSERT (p->gotidx > 0); 2460 2461 if (TLS_RELOC_P (r_type)) 2462 { 2463 bfd_vma value = MINUS_ONE; 2464 if ((h->root.type == bfd_link_hash_defined 2465 || h->root.type == bfd_link_hash_defweak) 2466 && h->root.u.def.section->output_section) 2467 value = (h->root.u.def.value 2468 + h->root.u.def.section->output_offset 2469 + h->root.u.def.section->output_section->vma); 2470 2471 return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type, 2472 info, e.d.h, value); 2473 } 2474 else 2475 return p->gotidx; 2476 } 2477 } 2478 2479 if (gg->global_gotsym != NULL) 2480 global_got_dynindx = gg->global_gotsym->dynindx; 2481 2482 if (TLS_RELOC_P (r_type)) 2483 { 2484 struct mips_elf_link_hash_entry *hm 2485 = (struct mips_elf_link_hash_entry *) h; 2486 bfd_vma value = MINUS_ONE; 2487 2488 if ((h->root.type == bfd_link_hash_defined 2489 || h->root.type == bfd_link_hash_defweak) 2490 && h->root.u.def.section->output_section) 2491 value = (h->root.u.def.value 2492 + h->root.u.def.section->output_offset 2493 + h->root.u.def.section->output_section->vma); 2494 2495 index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type, 2496 r_type, info, hm, value); 2497 } 2498 else 2499 { 2500 /* Once we determine the global GOT entry with the lowest dynamic 2501 symbol table index, we must put all dynamic symbols with greater 2502 indices into the GOT. That makes it easy to calculate the GOT 2503 offset. */ 2504 BFD_ASSERT (h->dynindx >= global_got_dynindx); 2505 index = ((h->dynindx - global_got_dynindx + g->local_gotno) 2506 * MIPS_ELF_GOT_SIZE (abfd)); 2507 } 2508 BFD_ASSERT (index < sgot->size); 2509 2510 return index; 2511} 2512 2513/* Find a GOT page entry that points to within 32KB of VALUE, which was 2514 calculated from a symbol belonging to INPUT_SECTION. These entries 2515 are supposed to be placed at small offsets in the GOT, i.e., within 2516 32KB of GP. Return the index of the GOT entry, or -1 if no entry 2517 could be created. If OFFSETP is nonnull, use it to return the 2518 offset of the GOT entry from VALUE. */ 2519 2520static bfd_vma 2521mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 2522 asection *input_section, bfd_vma value, bfd_vma *offsetp) 2523{ 2524 asection *sgot; 2525 struct mips_got_info *g; 2526 bfd_vma page, index; 2527 struct mips_got_entry *entry; 2528 2529 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot); 2530 2531 page = (value + 0x8000) & ~(bfd_vma) 0xffff; 2532 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot, 2533 input_section, page, 0, 2534 NULL, R_MIPS_GOT_PAGE); 2535 2536 if (!entry) 2537 return MINUS_ONE; 2538 2539 index = entry->gotidx; 2540 2541 if (offsetp) 2542 *offsetp = value - entry->d.address; 2543 2544 return index; 2545} 2546 2547/* Find a local GOT entry for an R_MIPS_GOT16 relocation against VALUE, 2548 which was calculated from a symbol belonging to INPUT_SECTION. 2549 EXTERNAL is true if the relocation was against a global symbol 2550 that has been forced local. */ 2551 2552static bfd_vma 2553mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 2554 asection *input_section, bfd_vma value, 2555 bfd_boolean external) 2556{ 2557 asection *sgot; 2558 struct mips_got_info *g; 2559 struct mips_got_entry *entry; 2560 2561 /* GOT16 relocations against local symbols are followed by a LO16 2562 relocation; those against global symbols are not. Thus if the 2563 symbol was originally local, the GOT16 relocation should load the 2564 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */ 2565 if (! external) 2566 value = mips_elf_high (value) << 16; 2567 2568 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot); 2569 2570 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot, 2571 input_section, value, 0, 2572 NULL, R_MIPS_GOT16); 2573 if (entry) 2574 return entry->gotidx; 2575 else 2576 return MINUS_ONE; 2577} 2578 2579/* Returns the offset for the entry at the INDEXth position 2580 in the GOT. */ 2581 2582static bfd_vma 2583mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd, 2584 bfd *input_bfd, bfd_vma index) 2585{ 2586 asection *sgot; 2587 bfd_vma gp; 2588 struct mips_got_info *g; 2589 2590 g = mips_elf_got_info (dynobj, &sgot); 2591 gp = _bfd_get_gp_value (output_bfd) 2592 + mips_elf_adjust_gp (output_bfd, g, input_bfd); 2593 2594 return sgot->output_section->vma + sgot->output_offset + index - gp; 2595} 2596 2597/* Create and return a local GOT entry for VALUE, which was calculated 2598 from a symbol belonging to INPUT_SECTON. Return NULL if it could not 2599 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry 2600 instead. */ 2601 2602static struct mips_got_entry * 2603mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info, 2604 bfd *ibfd, struct mips_got_info *gg, 2605 asection *sgot, asection *input_section, 2606 bfd_vma value, unsigned long r_symndx, 2607 struct mips_elf_link_hash_entry *h, 2608 int r_type) 2609{ 2610 struct mips_got_entry entry, **loc; 2611 struct mips_got_info *g; 2612 struct mips_elf_link_hash_table *htab; 2613 2614 htab = mips_elf_hash_table (info); 2615 2616 entry.abfd = NULL; 2617 entry.symndx = -1; 2618 entry.d.address = value; 2619 entry.tls_type = 0; 2620 2621 g = mips_elf_got_for_ibfd (gg, ibfd); 2622 if (g == NULL) 2623 { 2624 g = mips_elf_got_for_ibfd (gg, abfd); 2625 BFD_ASSERT (g != NULL); 2626 } 2627 2628 /* We might have a symbol, H, if it has been forced local. Use the 2629 global entry then. It doesn't matter whether an entry is local 2630 or global for TLS, since the dynamic linker does not 2631 automatically relocate TLS GOT entries. */ 2632 BFD_ASSERT (h == NULL || h->root.forced_local); 2633 if (TLS_RELOC_P (r_type)) 2634 { 2635 struct mips_got_entry *p; 2636 2637 entry.abfd = ibfd; 2638 if (r_type == R_MIPS_TLS_LDM) 2639 { 2640 entry.tls_type = GOT_TLS_LDM; 2641 entry.symndx = 0; 2642 entry.d.addend = 0; 2643 } 2644 else if (h == NULL) 2645 { 2646 entry.symndx = r_symndx; 2647 entry.d.addend = 0; 2648 } 2649 else 2650 entry.d.h = h; 2651 2652 p = (struct mips_got_entry *) 2653 htab_find (g->got_entries, &entry); 2654 2655 BFD_ASSERT (p); 2656 return p; 2657 } 2658 2659 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry, 2660 INSERT); 2661 if (*loc) 2662 return *loc; 2663 2664 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++; 2665 entry.tls_type = 0; 2666 2667 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry); 2668 2669 if (! *loc) 2670 return NULL; 2671 2672 memcpy (*loc, &entry, sizeof entry); 2673 2674 if (g->assigned_gotno >= g->local_gotno) 2675 { 2676 (*loc)->gotidx = -1; 2677 /* We didn't allocate enough space in the GOT. */ 2678 (*_bfd_error_handler) 2679 (_("not enough GOT space for local GOT entries")); 2680 bfd_set_error (bfd_error_bad_value); 2681 return NULL; 2682 } 2683 2684 MIPS_ELF_PUT_WORD (abfd, value, 2685 (sgot->contents + entry.gotidx)); 2686 2687 /* These GOT entries need a dynamic relocation on VxWorks. Because 2688 the offset between segments is not fixed, the relocation must be 2689 against a symbol in the same segment as the original symbol. 2690 The easiest way to do this is to take INPUT_SECTION's output 2691 section and emit a relocation against its section symbol. */ 2692 if (htab->is_vxworks) 2693 { 2694 Elf_Internal_Rela outrel; 2695 asection *s, *output_section; 2696 bfd_byte *loc; 2697 bfd_vma got_address; 2698 int dynindx; 2699 2700 s = mips_elf_rel_dyn_section (info, FALSE); 2701 output_section = input_section->output_section; 2702 dynindx = elf_section_data (output_section)->dynindx; 2703 got_address = (sgot->output_section->vma 2704 + sgot->output_offset 2705 + entry.gotidx); 2706 2707 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela)); 2708 outrel.r_offset = got_address; 2709 outrel.r_info = ELF32_R_INFO (dynindx, R_MIPS_32); 2710 outrel.r_addend = value - output_section->vma; 2711 bfd_elf32_swap_reloca_out (abfd, &outrel, loc); 2712 } 2713 2714 return *loc; 2715} 2716 2717/* Sort the dynamic symbol table so that symbols that need GOT entries 2718 appear towards the end. This reduces the amount of GOT space 2719 required. MAX_LOCAL is used to set the number of local symbols 2720 known to be in the dynamic symbol table. During 2721 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the 2722 section symbols are added and the count is higher. */ 2723 2724static bfd_boolean 2725mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local) 2726{ 2727 struct mips_elf_hash_sort_data hsd; 2728 struct mips_got_info *g; 2729 bfd *dynobj; 2730 2731 dynobj = elf_hash_table (info)->dynobj; 2732 2733 g = mips_elf_got_info (dynobj, NULL); 2734 2735 hsd.low = NULL; 2736 hsd.max_unref_got_dynindx = 2737 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount 2738 /* In the multi-got case, assigned_gotno of the master got_info 2739 indicate the number of entries that aren't referenced in the 2740 primary GOT, but that must have entries because there are 2741 dynamic relocations that reference it. Since they aren't 2742 referenced, we move them to the end of the GOT, so that they 2743 don't prevent other entries that are referenced from getting 2744 too large offsets. */ 2745 - (g->next ? g->assigned_gotno : 0); 2746 hsd.max_non_got_dynindx = max_local; 2747 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *) 2748 elf_hash_table (info)), 2749 mips_elf_sort_hash_table_f, 2750 &hsd); 2751 2752 /* There should have been enough room in the symbol table to 2753 accommodate both the GOT and non-GOT symbols. */ 2754 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx); 2755 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx 2756 <= elf_hash_table (info)->dynsymcount); 2757 2758 /* Now we know which dynamic symbol has the lowest dynamic symbol 2759 table index in the GOT. */ 2760 g->global_gotsym = hsd.low; 2761 2762 return TRUE; 2763} 2764 2765/* If H needs a GOT entry, assign it the highest available dynamic 2766 index. Otherwise, assign it the lowest available dynamic 2767 index. */ 2768 2769static bfd_boolean 2770mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data) 2771{ 2772 struct mips_elf_hash_sort_data *hsd = data; 2773 2774 if (h->root.root.type == bfd_link_hash_warning) 2775 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 2776 2777 /* Symbols without dynamic symbol table entries aren't interesting 2778 at all. */ 2779 if (h->root.dynindx == -1) 2780 return TRUE; 2781 2782 /* Global symbols that need GOT entries that are not explicitly 2783 referenced are marked with got offset 2. Those that are 2784 referenced get a 1, and those that don't need GOT entries get 2785 -1. */ 2786 if (h->root.got.offset == 2) 2787 { 2788 BFD_ASSERT (h->tls_type == GOT_NORMAL); 2789 2790 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx) 2791 hsd->low = (struct elf_link_hash_entry *) h; 2792 h->root.dynindx = hsd->max_unref_got_dynindx++; 2793 } 2794 else if (h->root.got.offset != 1) 2795 h->root.dynindx = hsd->max_non_got_dynindx++; 2796 else 2797 { 2798 BFD_ASSERT (h->tls_type == GOT_NORMAL); 2799 2800 h->root.dynindx = --hsd->min_got_dynindx; 2801 hsd->low = (struct elf_link_hash_entry *) h; 2802 } 2803 2804 return TRUE; 2805} 2806 2807/* If H is a symbol that needs a global GOT entry, but has a dynamic 2808 symbol table index lower than any we've seen to date, record it for 2809 posterity. */ 2810 2811static bfd_boolean 2812mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h, 2813 bfd *abfd, struct bfd_link_info *info, 2814 struct mips_got_info *g, 2815 unsigned char tls_flag) 2816{ 2817 struct mips_got_entry entry, **loc; 2818 2819 /* A global symbol in the GOT must also be in the dynamic symbol 2820 table. */ 2821 if (h->dynindx == -1) 2822 { 2823 switch (ELF_ST_VISIBILITY (h->other)) 2824 { 2825 case STV_INTERNAL: 2826 case STV_HIDDEN: 2827 _bfd_mips_elf_hide_symbol (info, h, TRUE); 2828 break; 2829 } 2830 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 2831 return FALSE; 2832 } 2833 2834 /* Make sure we have a GOT to put this entry into. */ 2835 BFD_ASSERT (g != NULL); 2836 2837 entry.abfd = abfd; 2838 entry.symndx = -1; 2839 entry.d.h = (struct mips_elf_link_hash_entry *) h; 2840 entry.tls_type = 0; 2841 2842 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry, 2843 INSERT); 2844 2845 /* If we've already marked this entry as needing GOT space, we don't 2846 need to do it again. */ 2847 if (*loc) 2848 { 2849 (*loc)->tls_type |= tls_flag; 2850 return TRUE; 2851 } 2852 2853 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry); 2854 2855 if (! *loc) 2856 return FALSE; 2857 2858 entry.gotidx = -1; 2859 entry.tls_type = tls_flag; 2860 2861 memcpy (*loc, &entry, sizeof entry); 2862 2863 if (h->got.offset != MINUS_ONE) 2864 return TRUE; 2865 2866 /* By setting this to a value other than -1, we are indicating that 2867 there needs to be a GOT entry for H. Avoid using zero, as the 2868 generic ELF copy_indirect_symbol tests for <= 0. */ 2869 if (tls_flag == 0) 2870 h->got.offset = 1; 2871 2872 return TRUE; 2873} 2874 2875/* Reserve space in G for a GOT entry containing the value of symbol 2876 SYMNDX in input bfd ABDF, plus ADDEND. */ 2877 2878static bfd_boolean 2879mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend, 2880 struct mips_got_info *g, 2881 unsigned char tls_flag) 2882{ 2883 struct mips_got_entry entry, **loc; 2884 2885 entry.abfd = abfd; 2886 entry.symndx = symndx; 2887 entry.d.addend = addend; 2888 entry.tls_type = tls_flag; 2889 loc = (struct mips_got_entry **) 2890 htab_find_slot (g->got_entries, &entry, INSERT); 2891 2892 if (*loc) 2893 { 2894 if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD)) 2895 { 2896 g->tls_gotno += 2; 2897 (*loc)->tls_type |= tls_flag; 2898 } 2899 else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE)) 2900 { 2901 g->tls_gotno += 1; 2902 (*loc)->tls_type |= tls_flag; 2903 } 2904 return TRUE; 2905 } 2906 2907 if (tls_flag != 0) 2908 { 2909 entry.gotidx = -1; 2910 entry.tls_type = tls_flag; 2911 if (tls_flag == GOT_TLS_IE) 2912 g->tls_gotno += 1; 2913 else if (tls_flag == GOT_TLS_GD) 2914 g->tls_gotno += 2; 2915 else if (g->tls_ldm_offset == MINUS_ONE) 2916 { 2917 g->tls_ldm_offset = MINUS_TWO; 2918 g->tls_gotno += 2; 2919 } 2920 } 2921 else 2922 { 2923 entry.gotidx = g->local_gotno++; 2924 entry.tls_type = 0; 2925 } 2926 2927 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry); 2928 2929 if (! *loc) 2930 return FALSE; 2931 2932 memcpy (*loc, &entry, sizeof entry); 2933 2934 return TRUE; 2935} 2936 2937/* Compute the hash value of the bfd in a bfd2got hash entry. */ 2938 2939static hashval_t 2940mips_elf_bfd2got_entry_hash (const void *entry_) 2941{ 2942 const struct mips_elf_bfd2got_hash *entry 2943 = (struct mips_elf_bfd2got_hash *)entry_; 2944 2945 return entry->bfd->id; 2946} 2947 2948/* Check whether two hash entries have the same bfd. */ 2949 2950static int 2951mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2) 2952{ 2953 const struct mips_elf_bfd2got_hash *e1 2954 = (const struct mips_elf_bfd2got_hash *)entry1; 2955 const struct mips_elf_bfd2got_hash *e2 2956 = (const struct mips_elf_bfd2got_hash *)entry2; 2957 2958 return e1->bfd == e2->bfd; 2959} 2960 2961/* In a multi-got link, determine the GOT to be used for IBFD. G must 2962 be the master GOT data. */ 2963 2964static struct mips_got_info * 2965mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd) 2966{ 2967 struct mips_elf_bfd2got_hash e, *p; 2968 2969 if (! g->bfd2got) 2970 return g; 2971 2972 e.bfd = ibfd; 2973 p = htab_find (g->bfd2got, &e); 2974 return p ? p->g : NULL; 2975} 2976 2977/* Create one separate got for each bfd that has entries in the global 2978 got, such that we can tell how many local and global entries each 2979 bfd requires. */ 2980 2981static int 2982mips_elf_make_got_per_bfd (void **entryp, void *p) 2983{ 2984 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp; 2985 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p; 2986 htab_t bfd2got = arg->bfd2got; 2987 struct mips_got_info *g; 2988 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot; 2989 void **bfdgotp; 2990 2991 /* Find the got_info for this GOT entry's input bfd. Create one if 2992 none exists. */ 2993 bfdgot_entry.bfd = entry->abfd; 2994 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT); 2995 bfdgot = (struct mips_elf_bfd2got_hash *)*bfdgotp; 2996 2997 if (bfdgot != NULL) 2998 g = bfdgot->g; 2999 else 3000 { 3001 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc 3002 (arg->obfd, sizeof (struct mips_elf_bfd2got_hash)); 3003 3004 if (bfdgot == NULL) 3005 { 3006 arg->obfd = 0; 3007 return 0; 3008 } 3009 3010 *bfdgotp = bfdgot; 3011 3012 bfdgot->bfd = entry->abfd; 3013 bfdgot->g = g = (struct mips_got_info *) 3014 bfd_alloc (arg->obfd, sizeof (struct mips_got_info)); 3015 if (g == NULL) 3016 { 3017 arg->obfd = 0; 3018 return 0; 3019 } 3020 3021 g->global_gotsym = NULL; 3022 g->global_gotno = 0; 3023 g->local_gotno = 0; 3024 g->assigned_gotno = -1; 3025 g->tls_gotno = 0; 3026 g->tls_assigned_gotno = 0; 3027 g->tls_ldm_offset = MINUS_ONE; 3028 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash, 3029 mips_elf_multi_got_entry_eq, NULL); 3030 if (g->got_entries == NULL) 3031 { 3032 arg->obfd = 0; 3033 return 0; 3034 } 3035 3036 g->bfd2got = NULL; 3037 g->next = NULL; 3038 } 3039 3040 /* Insert the GOT entry in the bfd's got entry hash table. */ 3041 entryp = htab_find_slot (g->got_entries, entry, INSERT); 3042 if (*entryp != NULL) 3043 return 1; 3044 3045 *entryp = entry; 3046 3047 if (entry->tls_type) 3048 { 3049 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM)) 3050 g->tls_gotno += 2; 3051 if (entry->tls_type & GOT_TLS_IE) 3052 g->tls_gotno += 1; 3053 } 3054 else if (entry->symndx >= 0 || entry->d.h->forced_local) 3055 ++g->local_gotno; 3056 else 3057 ++g->global_gotno; 3058 3059 return 1; 3060} 3061 3062/* Attempt to merge gots of different input bfds. Try to use as much 3063 as possible of the primary got, since it doesn't require explicit 3064 dynamic relocations, but don't use bfds that would reference global 3065 symbols out of the addressable range. Failing the primary got, 3066 attempt to merge with the current got, or finish the current got 3067 and then make make the new got current. */ 3068 3069static int 3070mips_elf_merge_gots (void **bfd2got_, void *p) 3071{ 3072 struct mips_elf_bfd2got_hash *bfd2got 3073 = (struct mips_elf_bfd2got_hash *)*bfd2got_; 3074 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p; 3075 unsigned int lcount = bfd2got->g->local_gotno; 3076 unsigned int gcount = bfd2got->g->global_gotno; 3077 unsigned int tcount = bfd2got->g->tls_gotno; 3078 unsigned int maxcnt = arg->max_count; 3079 bfd_boolean too_many_for_tls = FALSE; 3080 3081 /* We place TLS GOT entries after both locals and globals. The globals 3082 for the primary GOT may overflow the normal GOT size limit, so be 3083 sure not to merge a GOT which requires TLS with the primary GOT in that 3084 case. This doesn't affect non-primary GOTs. */ 3085 if (tcount > 0) 3086 { 3087 unsigned int primary_total = lcount + tcount + arg->global_count; 3088 if (primary_total * MIPS_ELF_GOT_SIZE (bfd2got->bfd) 3089 >= MIPS_ELF_GOT_MAX_SIZE (arg->info)) 3090 too_many_for_tls = TRUE; 3091 } 3092 3093 /* If we don't have a primary GOT and this is not too big, use it as 3094 a starting point for the primary GOT. */ 3095 if (! arg->primary && lcount + gcount + tcount <= maxcnt 3096 && ! too_many_for_tls) 3097 { 3098 arg->primary = bfd2got->g; 3099 arg->primary_count = lcount + gcount; 3100 } 3101 /* If it looks like we can merge this bfd's entries with those of 3102 the primary, merge them. The heuristics is conservative, but we 3103 don't have to squeeze it too hard. */ 3104 else if (arg->primary && ! too_many_for_tls 3105 && (arg->primary_count + lcount + gcount + tcount) <= maxcnt) 3106 { 3107 struct mips_got_info *g = bfd2got->g; 3108 int old_lcount = arg->primary->local_gotno; 3109 int old_gcount = arg->primary->global_gotno; 3110 int old_tcount = arg->primary->tls_gotno; 3111 3112 bfd2got->g = arg->primary; 3113 3114 htab_traverse (g->got_entries, 3115 mips_elf_make_got_per_bfd, 3116 arg); 3117 if (arg->obfd == NULL) 3118 return 0; 3119 3120 htab_delete (g->got_entries); 3121 /* We don't have to worry about releasing memory of the actual 3122 got entries, since they're all in the master got_entries hash 3123 table anyway. */ 3124 3125 BFD_ASSERT (old_lcount + lcount >= arg->primary->local_gotno); 3126 BFD_ASSERT (old_gcount + gcount >= arg->primary->global_gotno); 3127 BFD_ASSERT (old_tcount + tcount >= arg->primary->tls_gotno); 3128 3129 arg->primary_count = arg->primary->local_gotno 3130 + arg->primary->global_gotno + arg->primary->tls_gotno; 3131 } 3132 /* If we can merge with the last-created got, do it. */ 3133 else if (arg->current 3134 && arg->current_count + lcount + gcount + tcount <= maxcnt) 3135 { 3136 struct mips_got_info *g = bfd2got->g; 3137 int old_lcount = arg->current->local_gotno; 3138 int old_gcount = arg->current->global_gotno; 3139 int old_tcount = arg->current->tls_gotno; 3140 3141 bfd2got->g = arg->current; 3142 3143 htab_traverse (g->got_entries, 3144 mips_elf_make_got_per_bfd, 3145 arg); 3146 if (arg->obfd == NULL) 3147 return 0; 3148 3149 htab_delete (g->got_entries); 3150 3151 BFD_ASSERT (old_lcount + lcount >= arg->current->local_gotno); 3152 BFD_ASSERT (old_gcount + gcount >= arg->current->global_gotno); 3153 BFD_ASSERT (old_tcount + tcount >= arg->current->tls_gotno); 3154 3155 arg->current_count = arg->current->local_gotno 3156 + arg->current->global_gotno + arg->current->tls_gotno; 3157 } 3158 /* Well, we couldn't merge, so create a new GOT. Don't check if it 3159 fits; if it turns out that it doesn't, we'll get relocation 3160 overflows anyway. */ 3161 else 3162 { 3163 bfd2got->g->next = arg->current; 3164 arg->current = bfd2got->g; 3165 3166 arg->current_count = lcount + gcount + 2 * tcount; 3167 } 3168 3169 return 1; 3170} 3171 3172/* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field 3173 is null iff there is just a single GOT. */ 3174 3175static int 3176mips_elf_initialize_tls_index (void **entryp, void *p) 3177{ 3178 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp; 3179 struct mips_got_info *g = p; 3180 bfd_vma next_index; 3181 3182 /* We're only interested in TLS symbols. */ 3183 if (entry->tls_type == 0) 3184 return 1; 3185 3186 next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno; 3187 3188 if (entry->symndx == -1 && g->next == NULL) 3189 { 3190 /* A type (3) got entry in the single-GOT case. We use the symbol's 3191 hash table entry to track its index. */ 3192 if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE) 3193 return 1; 3194 entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE; 3195 entry->d.h->tls_got_offset = next_index; 3196 } 3197 else 3198 { 3199 if (entry->tls_type & GOT_TLS_LDM) 3200 { 3201 /* There are separate mips_got_entry objects for each input bfd 3202 that requires an LDM entry. Make sure that all LDM entries in 3203 a GOT resolve to the same index. */ 3204 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE) 3205 { 3206 entry->gotidx = g->tls_ldm_offset; 3207 return 1; 3208 } 3209 g->tls_ldm_offset = next_index; 3210 } 3211 entry->gotidx = next_index; 3212 } 3213 3214 /* Account for the entries we've just allocated. */ 3215 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM)) 3216 g->tls_assigned_gotno += 2; 3217 if (entry->tls_type & GOT_TLS_IE) 3218 g->tls_assigned_gotno += 1; 3219 3220 return 1; 3221} 3222 3223/* If passed a NULL mips_got_info in the argument, set the marker used 3224 to tell whether a global symbol needs a got entry (in the primary 3225 got) to the given VALUE. 3226 3227 If passed a pointer G to a mips_got_info in the argument (it must 3228 not be the primary GOT), compute the offset from the beginning of 3229 the (primary) GOT section to the entry in G corresponding to the 3230 global symbol. G's assigned_gotno must contain the index of the 3231 first available global GOT entry in G. VALUE must contain the size 3232 of a GOT entry in bytes. For each global GOT entry that requires a 3233 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is 3234 marked as not eligible for lazy resolution through a function 3235 stub. */ 3236static int 3237mips_elf_set_global_got_offset (void **entryp, void *p) 3238{ 3239 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp; 3240 struct mips_elf_set_global_got_offset_arg *arg 3241 = (struct mips_elf_set_global_got_offset_arg *)p; 3242 struct mips_got_info *g = arg->g; 3243 3244 if (g && entry->tls_type != GOT_NORMAL) 3245 arg->needed_relocs += 3246 mips_tls_got_relocs (arg->info, entry->tls_type, 3247 entry->symndx == -1 ? &entry->d.h->root : NULL); 3248 3249 if (entry->abfd != NULL && entry->symndx == -1 3250 && entry->d.h->root.dynindx != -1 3251 && entry->d.h->tls_type == GOT_NORMAL) 3252 { 3253 if (g) 3254 { 3255 BFD_ASSERT (g->global_gotsym == NULL); 3256 3257 entry->gotidx = arg->value * (long) g->assigned_gotno++; 3258 if (arg->info->shared 3259 || (elf_hash_table (arg->info)->dynamic_sections_created 3260 && entry->d.h->root.def_dynamic 3261 && !entry->d.h->root.def_regular)) 3262 ++arg->needed_relocs; 3263 } 3264 else 3265 entry->d.h->root.got.offset = arg->value; 3266 } 3267 3268 return 1; 3269} 3270 3271/* Mark any global symbols referenced in the GOT we are iterating over 3272 as inelligible for lazy resolution stubs. */ 3273static int 3274mips_elf_set_no_stub (void **entryp, void *p ATTRIBUTE_UNUSED) 3275{ 3276 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp; 3277 3278 if (entry->abfd != NULL 3279 && entry->symndx == -1 3280 && entry->d.h->root.dynindx != -1) 3281 entry->d.h->no_fn_stub = TRUE; 3282 3283 return 1; 3284} 3285 3286/* Follow indirect and warning hash entries so that each got entry 3287 points to the final symbol definition. P must point to a pointer 3288 to the hash table we're traversing. Since this traversal may 3289 modify the hash table, we set this pointer to NULL to indicate 3290 we've made a potentially-destructive change to the hash table, so 3291 the traversal must be restarted. */ 3292static int 3293mips_elf_resolve_final_got_entry (void **entryp, void *p) 3294{ 3295 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp; 3296 htab_t got_entries = *(htab_t *)p; 3297 3298 if (entry->abfd != NULL && entry->symndx == -1) 3299 { 3300 struct mips_elf_link_hash_entry *h = entry->d.h; 3301 3302 while (h->root.root.type == bfd_link_hash_indirect 3303 || h->root.root.type == bfd_link_hash_warning) 3304 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 3305 3306 if (entry->d.h == h) 3307 return 1; 3308 3309 entry->d.h = h; 3310 3311 /* If we can't find this entry with the new bfd hash, re-insert 3312 it, and get the traversal restarted. */ 3313 if (! htab_find (got_entries, entry)) 3314 { 3315 htab_clear_slot (got_entries, entryp); 3316 entryp = htab_find_slot (got_entries, entry, INSERT); 3317 if (! *entryp) 3318 *entryp = entry; 3319 /* Abort the traversal, since the whole table may have 3320 moved, and leave it up to the parent to restart the 3321 process. */ 3322 *(htab_t *)p = NULL; 3323 return 0; 3324 } 3325 /* We might want to decrement the global_gotno count, but it's 3326 either too early or too late for that at this point. */ 3327 } 3328 3329 return 1; 3330} 3331 3332/* Turn indirect got entries in a got_entries table into their final 3333 locations. */ 3334static void 3335mips_elf_resolve_final_got_entries (struct mips_got_info *g) 3336{ 3337 htab_t got_entries; 3338 3339 do 3340 { 3341 got_entries = g->got_entries; 3342 3343 htab_traverse (got_entries, 3344 mips_elf_resolve_final_got_entry, 3345 &got_entries); 3346 } 3347 while (got_entries == NULL); 3348} 3349 3350/* Return the offset of an input bfd IBFD's GOT from the beginning of 3351 the primary GOT. */ 3352static bfd_vma 3353mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd) 3354{ 3355 if (g->bfd2got == NULL) 3356 return 0; 3357 3358 g = mips_elf_got_for_ibfd (g, ibfd); 3359 if (! g) 3360 return 0; 3361 3362 BFD_ASSERT (g->next); 3363 3364 g = g->next; 3365 3366 return (g->local_gotno + g->global_gotno + g->tls_gotno) 3367 * MIPS_ELF_GOT_SIZE (abfd); 3368} 3369 3370/* Turn a single GOT that is too big for 16-bit addressing into 3371 a sequence of GOTs, each one 16-bit addressable. */ 3372 3373static bfd_boolean 3374mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info, 3375 struct mips_got_info *g, asection *got, 3376 bfd_size_type pages) 3377{ 3378 struct mips_elf_got_per_bfd_arg got_per_bfd_arg; 3379 struct mips_elf_set_global_got_offset_arg set_got_offset_arg; 3380 struct mips_got_info *gg; 3381 unsigned int assign; 3382 3383 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash, 3384 mips_elf_bfd2got_entry_eq, NULL); 3385 if (g->bfd2got == NULL) 3386 return FALSE; 3387 3388 got_per_bfd_arg.bfd2got = g->bfd2got; 3389 got_per_bfd_arg.obfd = abfd; 3390 got_per_bfd_arg.info = info; 3391 3392 /* Count how many GOT entries each input bfd requires, creating a 3393 map from bfd to got info while at that. */ 3394 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg); 3395 if (got_per_bfd_arg.obfd == NULL) 3396 return FALSE; 3397 3398 got_per_bfd_arg.current = NULL; 3399 got_per_bfd_arg.primary = NULL; 3400 /* Taking out PAGES entries is a worst-case estimate. We could 3401 compute the maximum number of pages that each separate input bfd 3402 uses, but it's probably not worth it. */ 3403 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info) 3404 / MIPS_ELF_GOT_SIZE (abfd)) 3405 - MIPS_RESERVED_GOTNO (info) - pages); 3406 /* The number of globals that will be included in the primary GOT. 3407 See the calls to mips_elf_set_global_got_offset below for more 3408 information. */ 3409 got_per_bfd_arg.global_count = g->global_gotno; 3410 3411 /* Try to merge the GOTs of input bfds together, as long as they 3412 don't seem to exceed the maximum GOT size, choosing one of them 3413 to be the primary GOT. */ 3414 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg); 3415 if (got_per_bfd_arg.obfd == NULL) 3416 return FALSE; 3417 3418 /* If we do not find any suitable primary GOT, create an empty one. */ 3419 if (got_per_bfd_arg.primary == NULL) 3420 { 3421 g->next = (struct mips_got_info *) 3422 bfd_alloc (abfd, sizeof (struct mips_got_info)); 3423 if (g->next == NULL) 3424 return FALSE; 3425 3426 g->next->global_gotsym = NULL; 3427 g->next->global_gotno = 0; 3428 g->next->local_gotno = 0; 3429 g->next->tls_gotno = 0; 3430 g->next->assigned_gotno = 0; 3431 g->next->tls_assigned_gotno = 0; 3432 g->next->tls_ldm_offset = MINUS_ONE; 3433 g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash, 3434 mips_elf_multi_got_entry_eq, 3435 NULL); 3436 if (g->next->got_entries == NULL) 3437 return FALSE; 3438 g->next->bfd2got = NULL; 3439 } 3440 else 3441 g->next = got_per_bfd_arg.primary; 3442 g->next->next = got_per_bfd_arg.current; 3443 3444 /* GG is now the master GOT, and G is the primary GOT. */ 3445 gg = g; 3446 g = g->next; 3447 3448 /* Map the output bfd to the primary got. That's what we're going 3449 to use for bfds that use GOT16 or GOT_PAGE relocations that we 3450 didn't mark in check_relocs, and we want a quick way to find it. 3451 We can't just use gg->next because we're going to reverse the 3452 list. */ 3453 { 3454 struct mips_elf_bfd2got_hash *bfdgot; 3455 void **bfdgotp; 3456 3457 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc 3458 (abfd, sizeof (struct mips_elf_bfd2got_hash)); 3459 3460 if (bfdgot == NULL) 3461 return FALSE; 3462 3463 bfdgot->bfd = abfd; 3464 bfdgot->g = g; 3465 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT); 3466 3467 BFD_ASSERT (*bfdgotp == NULL); 3468 *bfdgotp = bfdgot; 3469 } 3470 3471 /* The IRIX dynamic linker requires every symbol that is referenced 3472 in a dynamic relocation to be present in the primary GOT, so 3473 arrange for them to appear after those that are actually 3474 referenced. 3475 3476 GNU/Linux could very well do without it, but it would slow down 3477 the dynamic linker, since it would have to resolve every dynamic 3478 symbol referenced in other GOTs more than once, without help from 3479 the cache. Also, knowing that every external symbol has a GOT 3480 helps speed up the resolution of local symbols too, so GNU/Linux 3481 follows IRIX's practice. 3482 3483 The number 2 is used by mips_elf_sort_hash_table_f to count 3484 global GOT symbols that are unreferenced in the primary GOT, with 3485 an initial dynamic index computed from gg->assigned_gotno, where 3486 the number of unreferenced global entries in the primary GOT is 3487 preserved. */ 3488 if (1) 3489 { 3490 gg->assigned_gotno = gg->global_gotno - g->global_gotno; 3491 g->global_gotno = gg->global_gotno; 3492 set_got_offset_arg.value = 2; 3493 } 3494 else 3495 { 3496 /* This could be used for dynamic linkers that don't optimize 3497 symbol resolution while applying relocations so as to use 3498 primary GOT entries or assuming the symbol is locally-defined. 3499 With this code, we assign lower dynamic indices to global 3500 symbols that are not referenced in the primary GOT, so that 3501 their entries can be omitted. */ 3502 gg->assigned_gotno = 0; 3503 set_got_offset_arg.value = -1; 3504 } 3505 3506 /* Reorder dynamic symbols as described above (which behavior 3507 depends on the setting of VALUE). */ 3508 set_got_offset_arg.g = NULL; 3509 htab_traverse (gg->got_entries, mips_elf_set_global_got_offset, 3510 &set_got_offset_arg); 3511 set_got_offset_arg.value = 1; 3512 htab_traverse (g->got_entries, mips_elf_set_global_got_offset, 3513 &set_got_offset_arg); 3514 if (! mips_elf_sort_hash_table (info, 1)) 3515 return FALSE; 3516 3517 /* Now go through the GOTs assigning them offset ranges. 3518 [assigned_gotno, local_gotno[ will be set to the range of local 3519 entries in each GOT. We can then compute the end of a GOT by 3520 adding local_gotno to global_gotno. We reverse the list and make 3521 it circular since then we'll be able to quickly compute the 3522 beginning of a GOT, by computing the end of its predecessor. To 3523 avoid special cases for the primary GOT, while still preserving 3524 assertions that are valid for both single- and multi-got links, 3525 we arrange for the main got struct to have the right number of 3526 global entries, but set its local_gotno such that the initial 3527 offset of the primary GOT is zero. Remember that the primary GOT 3528 will become the last item in the circular linked list, so it 3529 points back to the master GOT. */ 3530 gg->local_gotno = -g->global_gotno; 3531 gg->global_gotno = g->global_gotno; 3532 gg->tls_gotno = 0; 3533 assign = 0; 3534 gg->next = gg; 3535 3536 do 3537 { 3538 struct mips_got_info *gn; 3539 3540 assign += MIPS_RESERVED_GOTNO (info); 3541 g->assigned_gotno = assign; 3542 g->local_gotno += assign + pages; 3543 assign = g->local_gotno + g->global_gotno + g->tls_gotno; 3544 3545 /* Take g out of the direct list, and push it onto the reversed 3546 list that gg points to. g->next is guaranteed to be nonnull after 3547 this operation, as required by mips_elf_initialize_tls_index. */ 3548 gn = g->next; 3549 g->next = gg->next; 3550 gg->next = g; 3551 3552 /* Set up any TLS entries. We always place the TLS entries after 3553 all non-TLS entries. */ 3554 g->tls_assigned_gotno = g->local_gotno + g->global_gotno; 3555 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g); 3556 3557 /* Move onto the next GOT. It will be a secondary GOT if nonull. */ 3558 g = gn; 3559 3560 /* Mark global symbols in every non-primary GOT as ineligible for 3561 stubs. */ 3562 if (g) 3563 htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL); 3564 } 3565 while (g); 3566 3567 got->size = (gg->next->local_gotno 3568 + gg->next->global_gotno 3569 + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd); 3570 3571 return TRUE; 3572} 3573 3574 3575/* Returns the first relocation of type r_type found, beginning with 3576 RELOCATION. RELEND is one-past-the-end of the relocation table. */ 3577 3578static const Elf_Internal_Rela * 3579mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type, 3580 const Elf_Internal_Rela *relocation, 3581 const Elf_Internal_Rela *relend) 3582{ 3583 while (relocation < relend) 3584 { 3585 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type) 3586 return relocation; 3587 3588 ++relocation; 3589 } 3590 3591 /* We didn't find it. */ 3592 bfd_set_error (bfd_error_bad_value); 3593 return NULL; 3594} 3595 3596/* Return whether a relocation is against a local symbol. */ 3597 3598static bfd_boolean 3599mips_elf_local_relocation_p (bfd *input_bfd, 3600 const Elf_Internal_Rela *relocation, 3601 asection **local_sections, 3602 bfd_boolean check_forced) 3603{ 3604 unsigned long r_symndx; 3605 Elf_Internal_Shdr *symtab_hdr; 3606 struct mips_elf_link_hash_entry *h; 3607 size_t extsymoff; 3608 3609 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info); 3610 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3611 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info; 3612 3613 if (r_symndx < extsymoff) 3614 return TRUE; 3615 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL) 3616 return TRUE; 3617 3618 if (check_forced) 3619 { 3620 /* Look up the hash table to check whether the symbol 3621 was forced local. */ 3622 h = (struct mips_elf_link_hash_entry *) 3623 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]; 3624 /* Find the real hash-table entry for this symbol. */ 3625 while (h->root.root.type == bfd_link_hash_indirect 3626 || h->root.root.type == bfd_link_hash_warning) 3627 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 3628 if (h->root.forced_local) 3629 return TRUE; 3630 } 3631 3632 return FALSE; 3633} 3634 3635/* Sign-extend VALUE, which has the indicated number of BITS. */ 3636 3637bfd_vma 3638_bfd_mips_elf_sign_extend (bfd_vma value, int bits) 3639{ 3640 if (value & ((bfd_vma) 1 << (bits - 1))) 3641 /* VALUE is negative. */ 3642 value |= ((bfd_vma) - 1) << bits; 3643 3644 return value; 3645} 3646 3647/* Return non-zero if the indicated VALUE has overflowed the maximum 3648 range expressible by a signed number with the indicated number of 3649 BITS. */ 3650 3651static bfd_boolean 3652mips_elf_overflow_p (bfd_vma value, int bits) 3653{ 3654 bfd_signed_vma svalue = (bfd_signed_vma) value; 3655 3656 if (svalue > (1 << (bits - 1)) - 1) 3657 /* The value is too big. */ 3658 return TRUE; 3659 else if (svalue < -(1 << (bits - 1))) 3660 /* The value is too small. */ 3661 return TRUE; 3662 3663 /* All is well. */ 3664 return FALSE; 3665} 3666 3667/* Calculate the %high function. */ 3668 3669static bfd_vma 3670mips_elf_high (bfd_vma value) 3671{ 3672 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff; 3673} 3674 3675/* Calculate the %higher function. */ 3676 3677static bfd_vma 3678mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED) 3679{ 3680#ifdef BFD64 3681 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff; 3682#else 3683 abort (); 3684 return MINUS_ONE; 3685#endif 3686} 3687 3688/* Calculate the %highest function. */ 3689 3690static bfd_vma 3691mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED) 3692{ 3693#ifdef BFD64 3694 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff; 3695#else 3696 abort (); 3697 return MINUS_ONE; 3698#endif 3699} 3700 3701/* Create the .compact_rel section. */ 3702 3703static bfd_boolean 3704mips_elf_create_compact_rel_section 3705 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED) 3706{ 3707 flagword flags; 3708 register asection *s; 3709 3710 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL) 3711 { 3712 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED 3713 | SEC_READONLY); 3714 3715 s = bfd_make_section_with_flags (abfd, ".compact_rel", flags); 3716 if (s == NULL 3717 || ! bfd_set_section_alignment (abfd, s, 3718 MIPS_ELF_LOG_FILE_ALIGN (abfd))) 3719 return FALSE; 3720 3721 s->size = sizeof (Elf32_External_compact_rel); 3722 } 3723 3724 return TRUE; 3725} 3726 3727/* Create the .got section to hold the global offset table. */ 3728 3729static bfd_boolean 3730mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info, 3731 bfd_boolean maybe_exclude) 3732{ 3733 flagword flags; 3734 register asection *s; 3735 struct elf_link_hash_entry *h; 3736 struct bfd_link_hash_entry *bh; 3737 struct mips_got_info *g; 3738 bfd_size_type amt; 3739 struct mips_elf_link_hash_table *htab; 3740 3741 htab = mips_elf_hash_table (info); 3742 3743 /* This function may be called more than once. */ 3744 s = mips_elf_got_section (abfd, TRUE); 3745 if (s) 3746 { 3747 if (! maybe_exclude) 3748 s->flags &= ~SEC_EXCLUDE; 3749 return TRUE; 3750 } 3751 3752 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3753 | SEC_LINKER_CREATED); 3754 3755 if (maybe_exclude) 3756 flags |= SEC_EXCLUDE; 3757 3758 /* We have to use an alignment of 2**4 here because this is hardcoded 3759 in the function stub generation and in the linker script. */ 3760 s = bfd_make_section_with_flags (abfd, ".got", flags); 3761 if (s == NULL 3762 || ! bfd_set_section_alignment (abfd, s, 4)) 3763 return FALSE; 3764 3765 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the 3766 linker script because we don't want to define the symbol if we 3767 are not creating a global offset table. */ 3768 bh = NULL; 3769 if (! (_bfd_generic_link_add_one_symbol 3770 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, 3771 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 3772 return FALSE; 3773 3774 h = (struct elf_link_hash_entry *) bh; 3775 h->non_elf = 0; 3776 h->def_regular = 1; 3777 h->type = STT_OBJECT; 3778 elf_hash_table (info)->hgot = h; 3779 3780 if (info->shared 3781 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 3782 return FALSE; 3783 3784 amt = sizeof (struct mips_got_info); 3785 g = bfd_alloc (abfd, amt); 3786 if (g == NULL) 3787 return FALSE; 3788 g->global_gotsym = NULL; 3789 g->global_gotno = 0; 3790 g->tls_gotno = 0; 3791 g->local_gotno = MIPS_RESERVED_GOTNO (info); 3792 g->assigned_gotno = MIPS_RESERVED_GOTNO (info); 3793 g->bfd2got = NULL; 3794 g->next = NULL; 3795 g->tls_ldm_offset = MINUS_ONE; 3796 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash, 3797 mips_elf_got_entry_eq, NULL); 3798 if (g->got_entries == NULL) 3799 return FALSE; 3800 mips_elf_section_data (s)->u.got_info = g; 3801 mips_elf_section_data (s)->elf.this_hdr.sh_flags 3802 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL; 3803 3804 /* VxWorks also needs a .got.plt section. */ 3805 if (htab->is_vxworks) 3806 { 3807 s = bfd_make_section_with_flags (abfd, ".got.plt", 3808 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 3809 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3810 if (s == NULL || !bfd_set_section_alignment (abfd, s, 4)) 3811 return FALSE; 3812 3813 htab->sgotplt = s; 3814 } 3815 return TRUE; 3816} 3817 3818/* Return true if H refers to the special VxWorks __GOTT_BASE__ or 3819 __GOTT_INDEX__ symbols. These symbols are only special for 3820 shared objects; they are not used in executables. */ 3821 3822static bfd_boolean 3823is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h) 3824{ 3825 return (mips_elf_hash_table (info)->is_vxworks 3826 && info->shared 3827 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0 3828 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0)); 3829} 3830 3831/* Calculate the value produced by the RELOCATION (which comes from 3832 the INPUT_BFD). The ADDEND is the addend to use for this 3833 RELOCATION; RELOCATION->R_ADDEND is ignored. 3834 3835 The result of the relocation calculation is stored in VALUEP. 3836 REQUIRE_JALXP indicates whether or not the opcode used with this 3837 relocation must be JALX. 3838 3839 This function returns bfd_reloc_continue if the caller need take no 3840 further action regarding this relocation, bfd_reloc_notsupported if 3841 something goes dramatically wrong, bfd_reloc_overflow if an 3842 overflow occurs, and bfd_reloc_ok to indicate success. */ 3843 3844static bfd_reloc_status_type 3845mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd, 3846 asection *input_section, 3847 struct bfd_link_info *info, 3848 const Elf_Internal_Rela *relocation, 3849 bfd_vma addend, reloc_howto_type *howto, 3850 Elf_Internal_Sym *local_syms, 3851 asection **local_sections, bfd_vma *valuep, 3852 const char **namep, bfd_boolean *require_jalxp, 3853 bfd_boolean save_addend) 3854{ 3855 /* The eventual value we will return. */ 3856 bfd_vma value; 3857 /* The address of the symbol against which the relocation is 3858 occurring. */ 3859 bfd_vma symbol = 0; 3860 /* The final GP value to be used for the relocatable, executable, or 3861 shared object file being produced. */ 3862 bfd_vma gp = MINUS_ONE; 3863 /* The place (section offset or address) of the storage unit being 3864 relocated. */ 3865 bfd_vma p; 3866 /* The value of GP used to create the relocatable object. */ 3867 bfd_vma gp0 = MINUS_ONE; 3868 /* The offset into the global offset table at which the address of 3869 the relocation entry symbol, adjusted by the addend, resides 3870 during execution. */ 3871 bfd_vma g = MINUS_ONE; 3872 /* The section in which the symbol referenced by the relocation is 3873 located. */ 3874 asection *sec = NULL; 3875 struct mips_elf_link_hash_entry *h = NULL; 3876 /* TRUE if the symbol referred to by this relocation is a local 3877 symbol. */ 3878 bfd_boolean local_p, was_local_p; 3879 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */ 3880 bfd_boolean gp_disp_p = FALSE; 3881 /* TRUE if the symbol referred to by this relocation is 3882 "__gnu_local_gp". */ 3883 bfd_boolean gnu_local_gp_p = FALSE; 3884 Elf_Internal_Shdr *symtab_hdr; 3885 size_t extsymoff; 3886 unsigned long r_symndx; 3887 int r_type; 3888 /* TRUE if overflow occurred during the calculation of the 3889 relocation value. */ 3890 bfd_boolean overflowed_p; 3891 /* TRUE if this relocation refers to a MIPS16 function. */ 3892 bfd_boolean target_is_16_bit_code_p = FALSE; 3893 struct mips_elf_link_hash_table *htab; 3894 bfd *dynobj; 3895 3896 dynobj = elf_hash_table (info)->dynobj; 3897 htab = mips_elf_hash_table (info); 3898 3899 /* Parse the relocation. */ 3900 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info); 3901 r_type = ELF_R_TYPE (input_bfd, relocation->r_info); 3902 p = (input_section->output_section->vma 3903 + input_section->output_offset 3904 + relocation->r_offset); 3905 3906 /* Assume that there will be no overflow. */ 3907 overflowed_p = FALSE; 3908 3909 /* Figure out whether or not the symbol is local, and get the offset 3910 used in the array of hash table entries. */ 3911 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3912 local_p = mips_elf_local_relocation_p (input_bfd, relocation, 3913 local_sections, FALSE); 3914 was_local_p = local_p; 3915 if (! elf_bad_symtab (input_bfd)) 3916 extsymoff = symtab_hdr->sh_info; 3917 else 3918 { 3919 /* The symbol table does not follow the rule that local symbols 3920 must come before globals. */ 3921 extsymoff = 0; 3922 } 3923 3924 /* Figure out the value of the symbol. */ 3925 if (local_p) 3926 { 3927 Elf_Internal_Sym *sym; 3928 3929 sym = local_syms + r_symndx; 3930 sec = local_sections[r_symndx]; 3931 3932 symbol = sec->output_section->vma + sec->output_offset; 3933 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION 3934 || (sec->flags & SEC_MERGE)) 3935 symbol += sym->st_value; 3936 if ((sec->flags & SEC_MERGE) 3937 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 3938 { 3939 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend); 3940 addend -= symbol; 3941 addend += sec->output_section->vma + sec->output_offset; 3942 } 3943 3944 /* MIPS16 text labels should be treated as odd. */ 3945 if (sym->st_other == STO_MIPS16) 3946 ++symbol; 3947 3948 /* Record the name of this symbol, for our caller. */ 3949 *namep = bfd_elf_string_from_elf_section (input_bfd, 3950 symtab_hdr->sh_link, 3951 sym->st_name); 3952 if (*namep == '\0') 3953 *namep = bfd_section_name (input_bfd, sec); 3954 3955 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16); 3956 } 3957 else 3958 { 3959 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */ 3960 3961 /* For global symbols we look up the symbol in the hash-table. */ 3962 h = ((struct mips_elf_link_hash_entry *) 3963 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]); 3964 /* Find the real hash-table entry for this symbol. */ 3965 while (h->root.root.type == bfd_link_hash_indirect 3966 || h->root.root.type == bfd_link_hash_warning) 3967 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 3968 3969 /* Record the name of this symbol, for our caller. */ 3970 *namep = h->root.root.root.string; 3971 3972 /* See if this is the special _gp_disp symbol. Note that such a 3973 symbol must always be a global symbol. */ 3974 if (strcmp (*namep, "_gp_disp") == 0 3975 && ! NEWABI_P (input_bfd)) 3976 { 3977 /* Relocations against _gp_disp are permitted only with 3978 R_MIPS_HI16 and R_MIPS_LO16 relocations. */ 3979 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16 3980 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16) 3981 return bfd_reloc_notsupported; 3982 3983 gp_disp_p = TRUE; 3984 } 3985 /* See if this is the special _gp symbol. Note that such a 3986 symbol must always be a global symbol. */ 3987 else if (strcmp (*namep, "__gnu_local_gp") == 0) 3988 gnu_local_gp_p = TRUE; 3989 3990 3991 /* If this symbol is defined, calculate its address. Note that 3992 _gp_disp is a magic symbol, always implicitly defined by the 3993 linker, so it's inappropriate to check to see whether or not 3994 its defined. */ 3995 else if ((h->root.root.type == bfd_link_hash_defined 3996 || h->root.root.type == bfd_link_hash_defweak) 3997 && h->root.root.u.def.section) 3998 { 3999 sec = h->root.root.u.def.section; 4000 if (sec->output_section) 4001 symbol = (h->root.root.u.def.value 4002 + sec->output_section->vma 4003 + sec->output_offset); 4004 else 4005 symbol = h->root.root.u.def.value; 4006 } 4007 else if (h->root.root.type == bfd_link_hash_undefweak) 4008 /* We allow relocations against undefined weak symbols, giving 4009 it the value zero, so that you can undefined weak functions 4010 and check to see if they exist by looking at their 4011 addresses. */ 4012 symbol = 0; 4013 else if (info->unresolved_syms_in_objects == RM_IGNORE 4014 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT) 4015 symbol = 0; 4016 else if (strcmp (*namep, SGI_COMPAT (input_bfd) 4017 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0) 4018 { 4019 /* If this is a dynamic link, we should have created a 4020 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol 4021 in in _bfd_mips_elf_create_dynamic_sections. 4022 Otherwise, we should define the symbol with a value of 0. 4023 FIXME: It should probably get into the symbol table 4024 somehow as well. */ 4025 BFD_ASSERT (! info->shared); 4026 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL); 4027 symbol = 0; 4028 } 4029 else if (ELF_MIPS_IS_OPTIONAL (h->root.other)) 4030 { 4031 /* This is an optional symbol - an Irix specific extension to the 4032 ELF spec. Ignore it for now. 4033 XXX - FIXME - there is more to the spec for OPTIONAL symbols 4034 than simply ignoring them, but we do not handle this for now. 4035 For information see the "64-bit ELF Object File Specification" 4036 which is available from here: 4037 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */ 4038 symbol = 0; 4039 } 4040 else 4041 { 4042 if (! ((*info->callbacks->undefined_symbol) 4043 (info, h->root.root.root.string, input_bfd, 4044 input_section, relocation->r_offset, 4045 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR) 4046 || ELF_ST_VISIBILITY (h->root.other)))) 4047 return bfd_reloc_undefined; 4048 symbol = 0; 4049 } 4050 4051 target_is_16_bit_code_p = (h->root.other == STO_MIPS16); 4052 } 4053 4054 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we 4055 need to redirect the call to the stub, unless we're already *in* 4056 a stub. */ 4057 if (r_type != R_MIPS16_26 && !info->relocatable 4058 && ((h != NULL && h->fn_stub != NULL) 4059 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL 4060 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL)) 4061 && !mips_elf_stub_section_p (input_bfd, input_section)) 4062 { 4063 /* This is a 32- or 64-bit call to a 16-bit function. We should 4064 have already noticed that we were going to need the 4065 stub. */ 4066 if (local_p) 4067 sec = elf_tdata (input_bfd)->local_stubs[r_symndx]; 4068 else 4069 { 4070 BFD_ASSERT (h->need_fn_stub); 4071 sec = h->fn_stub; 4072 } 4073 4074 symbol = sec->output_section->vma + sec->output_offset; 4075 } 4076 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we 4077 need to redirect the call to the stub. */ 4078 else if (r_type == R_MIPS16_26 && !info->relocatable 4079 && h != NULL 4080 && (h->call_stub != NULL || h->call_fp_stub != NULL) 4081 && !target_is_16_bit_code_p) 4082 { 4083 /* If both call_stub and call_fp_stub are defined, we can figure 4084 out which one to use by seeing which one appears in the input 4085 file. */ 4086 if (h->call_stub != NULL && h->call_fp_stub != NULL) 4087 { 4088 asection *o; 4089 4090 sec = NULL; 4091 for (o = input_bfd->sections; o != NULL; o = o->next) 4092 { 4093 if (strncmp (bfd_get_section_name (input_bfd, o), 4094 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0) 4095 { 4096 sec = h->call_fp_stub; 4097 break; 4098 } 4099 } 4100 if (sec == NULL) 4101 sec = h->call_stub; 4102 } 4103 else if (h->call_stub != NULL) 4104 sec = h->call_stub; 4105 else 4106 sec = h->call_fp_stub; 4107 4108 BFD_ASSERT (sec->size > 0); 4109 symbol = sec->output_section->vma + sec->output_offset; 4110 } 4111 4112 /* Calls from 16-bit code to 32-bit code and vice versa require the 4113 special jalx instruction. */ 4114 *require_jalxp = (!info->relocatable 4115 && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p) 4116 || ((r_type == R_MIPS_26) && target_is_16_bit_code_p))); 4117 4118 local_p = mips_elf_local_relocation_p (input_bfd, relocation, 4119 local_sections, TRUE); 4120 4121 /* If we haven't already determined the GOT offset, or the GP value, 4122 and we're going to need it, get it now. */ 4123 switch (r_type) 4124 { 4125 case R_MIPS_GOT_PAGE: 4126 case R_MIPS_GOT_OFST: 4127 /* We need to decay to GOT_DISP/addend if the symbol doesn't 4128 bind locally. */ 4129 local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1); 4130 if (local_p || r_type == R_MIPS_GOT_OFST) 4131 break; 4132 /* Fall through. */ 4133 4134 case R_MIPS_CALL16: 4135 case R_MIPS_GOT16: 4136 case R_MIPS_GOT_DISP: 4137 case R_MIPS_GOT_HI16: 4138 case R_MIPS_CALL_HI16: 4139 case R_MIPS_GOT_LO16: 4140 case R_MIPS_CALL_LO16: 4141 case R_MIPS_TLS_GD: 4142 case R_MIPS_TLS_GOTTPREL: 4143 case R_MIPS_TLS_LDM: 4144 /* Find the index into the GOT where this value is located. */ 4145 if (r_type == R_MIPS_TLS_LDM) 4146 { 4147 g = mips_elf_local_got_index (abfd, input_bfd, info, 4148 sec, 0, 0, NULL, r_type); 4149 if (g == MINUS_ONE) 4150 return bfd_reloc_outofrange; 4151 } 4152 else if (!local_p) 4153 { 4154 /* On VxWorks, CALL relocations should refer to the .got.plt 4155 entry, which is initialized to point at the PLT stub. */ 4156 if (htab->is_vxworks 4157 && (r_type == R_MIPS_CALL_HI16 4158 || r_type == R_MIPS_CALL_LO16 4159 || r_type == R_MIPS_CALL16)) 4160 { 4161 BFD_ASSERT (addend == 0); 4162 BFD_ASSERT (h->root.needs_plt); 4163 g = mips_elf_gotplt_index (info, &h->root); 4164 } 4165 else 4166 { 4167 /* GOT_PAGE may take a non-zero addend, that is ignored in a 4168 GOT_PAGE relocation that decays to GOT_DISP because the 4169 symbol turns out to be global. The addend is then added 4170 as GOT_OFST. */ 4171 BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE); 4172 g = mips_elf_global_got_index (dynobj, input_bfd, 4173 &h->root, r_type, info); 4174 if (h->tls_type == GOT_NORMAL 4175 && (! elf_hash_table(info)->dynamic_sections_created 4176 || (info->shared 4177 && (info->symbolic || h->root.forced_local) 4178 && h->root.def_regular))) 4179 { 4180 /* This is a static link or a -Bsymbolic link. The 4181 symbol is defined locally, or was forced to be local. 4182 We must initialize this entry in the GOT. */ 4183 asection *sgot = mips_elf_got_section (dynobj, FALSE); 4184 MIPS_ELF_PUT_WORD (dynobj, symbol, sgot->contents + g); 4185 } 4186 } 4187 } 4188 else if (!htab->is_vxworks 4189 && (r_type == R_MIPS_CALL16 || (r_type == R_MIPS_GOT16))) 4190 /* The calculation below does not involve "g". */ 4191 break; 4192 else 4193 { 4194 g = mips_elf_local_got_index (abfd, input_bfd, info, sec, 4195 symbol + addend, r_symndx, h, r_type); 4196 if (g == MINUS_ONE) 4197 return bfd_reloc_outofrange; 4198 } 4199 4200 /* Convert GOT indices to actual offsets. */ 4201 g = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, g); 4202 break; 4203 4204 case R_MIPS_HI16: 4205 case R_MIPS_LO16: 4206 case R_MIPS_GPREL16: 4207 case R_MIPS_GPREL32: 4208 case R_MIPS_LITERAL: 4209 case R_MIPS16_HI16: 4210 case R_MIPS16_LO16: 4211 case R_MIPS16_GPREL: 4212 gp0 = _bfd_get_gp_value (input_bfd); 4213 gp = _bfd_get_gp_value (abfd); 4214 if (dynobj) 4215 gp += mips_elf_adjust_gp (abfd, mips_elf_got_info (dynobj, NULL), 4216 input_bfd); 4217 break; 4218 4219 default: 4220 break; 4221 } 4222 4223 if (gnu_local_gp_p) 4224 symbol = gp; 4225 4226 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__ 4227 symbols are resolved by the loader. Add them to .rela.dyn. */ 4228 if (h != NULL && is_gott_symbol (info, &h->root)) 4229 { 4230 Elf_Internal_Rela outrel; 4231 bfd_byte *loc; 4232 asection *s; 4233 4234 s = mips_elf_rel_dyn_section (info, FALSE); 4235 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 4236 4237 outrel.r_offset = (input_section->output_section->vma 4238 + input_section->output_offset 4239 + relocation->r_offset); 4240 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type); 4241 outrel.r_addend = addend; 4242 bfd_elf32_swap_reloca_out (abfd, &outrel, loc); 4243 *valuep = 0; 4244 return bfd_reloc_ok; 4245 } 4246 4247 /* Figure out what kind of relocation is being performed. */ 4248 switch (r_type) 4249 { 4250 case R_MIPS_NONE: 4251 return bfd_reloc_continue; 4252 4253 case R_MIPS_16: 4254 value = symbol + _bfd_mips_elf_sign_extend (addend, 16); 4255 overflowed_p = mips_elf_overflow_p (value, 16); 4256 break; 4257 4258 case R_MIPS_32: 4259 case R_MIPS_REL32: 4260 case R_MIPS_64: 4261 if ((info->shared 4262 || (!htab->is_vxworks 4263 && htab->root.dynamic_sections_created 4264 && h != NULL 4265 && h->root.def_dynamic 4266 && !h->root.def_regular)) 4267 && r_symndx != 0 4268 && (input_section->flags & SEC_ALLOC) != 0) 4269 { 4270 /* If we're creating a shared library, or this relocation is 4271 against a symbol in a shared library, then we can't know 4272 where the symbol will end up. So, we create a relocation 4273 record in the output, and leave the job up to the dynamic 4274 linker. 4275 4276 In VxWorks executables, references to external symbols 4277 are handled using copy relocs or PLT stubs, so there's 4278 no need to add a dynamic relocation here. */ 4279 value = addend; 4280 if (!mips_elf_create_dynamic_relocation (abfd, 4281 info, 4282 relocation, 4283 h, 4284 sec, 4285 symbol, 4286 &value, 4287 input_section)) 4288 return bfd_reloc_undefined; 4289 } 4290 else 4291 { 4292 if (r_type != R_MIPS_REL32) 4293 value = symbol + addend; 4294 else 4295 value = addend; 4296 } 4297 value &= howto->dst_mask; 4298 break; 4299 4300 case R_MIPS_PC32: 4301 value = symbol + addend - p; 4302 value &= howto->dst_mask; 4303 break; 4304 4305 case R_MIPS16_26: 4306 /* The calculation for R_MIPS16_26 is just the same as for an 4307 R_MIPS_26. It's only the storage of the relocated field into 4308 the output file that's different. That's handled in 4309 mips_elf_perform_relocation. So, we just fall through to the 4310 R_MIPS_26 case here. */ 4311 case R_MIPS_26: 4312 if (local_p) 4313 value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2; 4314 else 4315 { 4316 value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2; 4317 if (h->root.root.type != bfd_link_hash_undefweak) 4318 overflowed_p = (value >> 26) != ((p + 4) >> 28); 4319 } 4320 value &= howto->dst_mask; 4321 break; 4322 4323 case R_MIPS_TLS_DTPREL_HI16: 4324 value = (mips_elf_high (addend + symbol - dtprel_base (info)) 4325 & howto->dst_mask); 4326 break; 4327 4328 case R_MIPS_TLS_DTPREL_LO16: 4329 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask; 4330 break; 4331 4332 case R_MIPS_TLS_TPREL_HI16: 4333 value = (mips_elf_high (addend + symbol - tprel_base (info)) 4334 & howto->dst_mask); 4335 break; 4336 4337 case R_MIPS_TLS_TPREL_LO16: 4338 value = (symbol + addend - tprel_base (info)) & howto->dst_mask; 4339 break; 4340 4341 case R_MIPS_HI16: 4342 case R_MIPS16_HI16: 4343 if (!gp_disp_p) 4344 { 4345 value = mips_elf_high (addend + symbol); 4346 value &= howto->dst_mask; 4347 } 4348 else 4349 { 4350 /* For MIPS16 ABI code we generate this sequence 4351 0: li $v0,%hi(_gp_disp) 4352 4: addiupc $v1,%lo(_gp_disp) 4353 8: sll $v0,16 4354 12: addu $v0,$v1 4355 14: move $gp,$v0 4356 So the offsets of hi and lo relocs are the same, but the 4357 $pc is four higher than $t9 would be, so reduce 4358 both reloc addends by 4. */ 4359 if (r_type == R_MIPS16_HI16) 4360 value = mips_elf_high (addend + gp - p - 4); 4361 else 4362 value = mips_elf_high (addend + gp - p); 4363 overflowed_p = mips_elf_overflow_p (value, 16); 4364 } 4365 break; 4366 4367 case R_MIPS_LO16: 4368 case R_MIPS16_LO16: 4369 if (!gp_disp_p) 4370 value = (symbol + addend) & howto->dst_mask; 4371 else 4372 { 4373 /* See the comment for R_MIPS16_HI16 above for the reason 4374 for this conditional. */ 4375 if (r_type == R_MIPS16_LO16) 4376 value = addend + gp - p; 4377 else 4378 value = addend + gp - p + 4; 4379 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation 4380 for overflow. But, on, say, IRIX5, relocations against 4381 _gp_disp are normally generated from the .cpload 4382 pseudo-op. It generates code that normally looks like 4383 this: 4384 4385 lui $gp,%hi(_gp_disp) 4386 addiu $gp,$gp,%lo(_gp_disp) 4387 addu $gp,$gp,$t9 4388 4389 Here $t9 holds the address of the function being called, 4390 as required by the MIPS ELF ABI. The R_MIPS_LO16 4391 relocation can easily overflow in this situation, but the 4392 R_MIPS_HI16 relocation will handle the overflow. 4393 Therefore, we consider this a bug in the MIPS ABI, and do 4394 not check for overflow here. */ 4395 } 4396 break; 4397 4398 case R_MIPS_LITERAL: 4399 /* Because we don't merge literal sections, we can handle this 4400 just like R_MIPS_GPREL16. In the long run, we should merge 4401 shared literals, and then we will need to additional work 4402 here. */ 4403 4404 /* Fall through. */ 4405 4406 case R_MIPS16_GPREL: 4407 /* The R_MIPS16_GPREL performs the same calculation as 4408 R_MIPS_GPREL16, but stores the relocated bits in a different 4409 order. We don't need to do anything special here; the 4410 differences are handled in mips_elf_perform_relocation. */ 4411 case R_MIPS_GPREL16: 4412 /* Only sign-extend the addend if it was extracted from the 4413 instruction. If the addend was separate, leave it alone, 4414 otherwise we may lose significant bits. */ 4415 if (howto->partial_inplace) 4416 addend = _bfd_mips_elf_sign_extend (addend, 16); 4417 value = symbol + addend - gp; 4418 /* If the symbol was local, any earlier relocatable links will 4419 have adjusted its addend with the gp offset, so compensate 4420 for that now. Don't do it for symbols forced local in this 4421 link, though, since they won't have had the gp offset applied 4422 to them before. */ 4423 if (was_local_p) 4424 value += gp0; 4425 overflowed_p = mips_elf_overflow_p (value, 16); 4426 break; 4427 4428 case R_MIPS_GOT16: 4429 case R_MIPS_CALL16: 4430 /* VxWorks does not have separate local and global semantics for 4431 R_MIPS_GOT16; every relocation evaluates to "G". */ 4432 if (!htab->is_vxworks && local_p) 4433 { 4434 bfd_boolean forced; 4435 4436 forced = ! mips_elf_local_relocation_p (input_bfd, relocation, 4437 local_sections, FALSE); 4438 value = mips_elf_got16_entry (abfd, input_bfd, info, sec, 4439 symbol + addend, forced); 4440 if (value == MINUS_ONE) 4441 return bfd_reloc_outofrange; 4442 value 4443 = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, value); 4444 overflowed_p = mips_elf_overflow_p (value, 16); 4445 break; 4446 } 4447 4448 /* Fall through. */ 4449 4450 case R_MIPS_TLS_GD: 4451 case R_MIPS_TLS_GOTTPREL: 4452 case R_MIPS_TLS_LDM: 4453 case R_MIPS_GOT_DISP: 4454 got_disp: 4455 value = g; 4456 overflowed_p = mips_elf_overflow_p (value, 16); 4457 break; 4458 4459 case R_MIPS_GPREL32: 4460 value = (addend + symbol + gp0 - gp); 4461 if (!save_addend) 4462 value &= howto->dst_mask; 4463 break; 4464 4465 case R_MIPS_PC16: 4466 case R_MIPS_GNU_REL16_S2: 4467 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p; 4468 overflowed_p = mips_elf_overflow_p (value, 18); 4469 value = (value >> 2) & howto->dst_mask; 4470 break; 4471 4472 case R_MIPS_GOT_HI16: 4473 case R_MIPS_CALL_HI16: 4474 /* We're allowed to handle these two relocations identically. 4475 The dynamic linker is allowed to handle the CALL relocations 4476 differently by creating a lazy evaluation stub. */ 4477 value = g; 4478 value = mips_elf_high (value); 4479 value &= howto->dst_mask; 4480 break; 4481 4482 case R_MIPS_GOT_LO16: 4483 case R_MIPS_CALL_LO16: 4484 value = g & howto->dst_mask; 4485 break; 4486 4487 case R_MIPS_GOT_PAGE: 4488 /* GOT_PAGE relocations that reference non-local symbols decay 4489 to GOT_DISP. The corresponding GOT_OFST relocation decays to 4490 0. */ 4491 if (! local_p) 4492 goto got_disp; 4493 value = mips_elf_got_page (abfd, input_bfd, info, sec, 4494 symbol + addend, NULL); 4495 if (value == MINUS_ONE) 4496 return bfd_reloc_outofrange; 4497 value = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, value); 4498 overflowed_p = mips_elf_overflow_p (value, 16); 4499 break; 4500 4501 case R_MIPS_GOT_OFST: 4502 if (local_p) 4503 mips_elf_got_page (abfd, input_bfd, info, sec, 4504 symbol + addend, &value); 4505 else 4506 value = addend; 4507 overflowed_p = mips_elf_overflow_p (value, 16); 4508 break; 4509 4510 case R_MIPS_SUB: 4511 value = symbol - addend; 4512 value &= howto->dst_mask; 4513 break; 4514 4515 case R_MIPS_HIGHER: 4516 value = mips_elf_higher (addend + symbol); 4517 value &= howto->dst_mask; 4518 break; 4519 4520 case R_MIPS_HIGHEST: 4521 value = mips_elf_highest (addend + symbol); 4522 value &= howto->dst_mask; 4523 break; 4524 4525 case R_MIPS_SCN_DISP: 4526 value = symbol + addend - sec->output_offset; 4527 value &= howto->dst_mask; 4528 break; 4529 4530 case R_MIPS_JALR: 4531 /* This relocation is only a hint. In some cases, we optimize 4532 it into a bal instruction. But we don't try to optimize 4533 branches to the PLT; that will wind up wasting time. */ 4534 if (h != NULL && h->root.plt.offset != (bfd_vma) -1) 4535 return bfd_reloc_continue; 4536 value = symbol + addend; 4537 break; 4538 4539 case R_MIPS_PJUMP: 4540 case R_MIPS_GNU_VTINHERIT: 4541 case R_MIPS_GNU_VTENTRY: 4542 /* We don't do anything with these at present. */ 4543 return bfd_reloc_continue; 4544 4545 default: 4546 /* An unrecognized relocation type. */ 4547 return bfd_reloc_notsupported; 4548 } 4549 4550 /* Store the VALUE for our caller. */ 4551 *valuep = value; 4552 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok; 4553} 4554 4555/* Obtain the field relocated by RELOCATION. */ 4556 4557static bfd_vma 4558mips_elf_obtain_contents (reloc_howto_type *howto, 4559 const Elf_Internal_Rela *relocation, 4560 bfd *input_bfd, bfd_byte *contents) 4561{ 4562 bfd_vma x; 4563 bfd_byte *location = contents + relocation->r_offset; 4564 4565 /* Obtain the bytes. */ 4566 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location); 4567 4568 return x; 4569} 4570 4571/* It has been determined that the result of the RELOCATION is the 4572 VALUE. Use HOWTO to place VALUE into the output file at the 4573 appropriate position. The SECTION is the section to which the 4574 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used 4575 for the relocation must be either JAL or JALX, and it is 4576 unconditionally converted to JALX. 4577 4578 Returns FALSE if anything goes wrong. */ 4579 4580static bfd_boolean 4581mips_elf_perform_relocation (struct bfd_link_info *info, 4582 reloc_howto_type *howto, 4583 const Elf_Internal_Rela *relocation, 4584 bfd_vma value, bfd *input_bfd, 4585 asection *input_section, bfd_byte *contents, 4586 bfd_boolean require_jalx) 4587{ 4588 bfd_vma x; 4589 bfd_byte *location; 4590 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info); 4591 4592 /* Figure out where the relocation is occurring. */ 4593 location = contents + relocation->r_offset; 4594 4595 _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location); 4596 4597 /* Obtain the current value. */ 4598 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents); 4599 4600 /* Clear the field we are setting. */ 4601 x &= ~howto->dst_mask; 4602 4603 /* Set the field. */ 4604 x |= (value & howto->dst_mask); 4605 4606 /* If required, turn JAL into JALX. */ 4607 if (require_jalx) 4608 { 4609 bfd_boolean ok; 4610 bfd_vma opcode = x >> 26; 4611 bfd_vma jalx_opcode; 4612 4613 /* Check to see if the opcode is already JAL or JALX. */ 4614 if (r_type == R_MIPS16_26) 4615 { 4616 ok = ((opcode == 0x6) || (opcode == 0x7)); 4617 jalx_opcode = 0x7; 4618 } 4619 else 4620 { 4621 ok = ((opcode == 0x3) || (opcode == 0x1d)); 4622 jalx_opcode = 0x1d; 4623 } 4624 4625 /* If the opcode is not JAL or JALX, there's a problem. */ 4626 if (!ok) 4627 { 4628 (*_bfd_error_handler) 4629 (_("%B: %A+0x%lx: jump to stub routine which is not jal"), 4630 input_bfd, 4631 input_section, 4632 (unsigned long) relocation->r_offset); 4633 bfd_set_error (bfd_error_bad_value); 4634 return FALSE; 4635 } 4636 4637 /* Make this the JALX opcode. */ 4638 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26); 4639 } 4640 4641 /* On the RM9000, bal is faster than jal, because bal uses branch 4642 prediction hardware. If we are linking for the RM9000, and we 4643 see jal, and bal fits, use it instead. Note that this 4644 transformation should be safe for all architectures. */ 4645 if (bfd_get_mach (input_bfd) == bfd_mach_mips9000 4646 && !info->relocatable 4647 && !require_jalx 4648 && ((r_type == R_MIPS_26 && (x >> 26) == 0x3) /* jal addr */ 4649 || (r_type == R_MIPS_JALR && x == 0x0320f809))) /* jalr t9 */ 4650 { 4651 bfd_vma addr; 4652 bfd_vma dest; 4653 bfd_signed_vma off; 4654 4655 addr = (input_section->output_section->vma 4656 + input_section->output_offset 4657 + relocation->r_offset 4658 + 4); 4659 if (r_type == R_MIPS_26) 4660 dest = (value << 2) | ((addr >> 28) << 28); 4661 else 4662 dest = value; 4663 off = dest - addr; 4664 if (off <= 0x1ffff && off >= -0x20000) 4665 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */ 4666 } 4667 4668 /* Put the value into the output. */ 4669 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location); 4670 4671 _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, !info->relocatable, 4672 location); 4673 4674 return TRUE; 4675} 4676 4677/* Returns TRUE if SECTION is a MIPS16 stub section. */ 4678 4679static bfd_boolean 4680mips_elf_stub_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *section) 4681{ 4682 const char *name = bfd_get_section_name (abfd, section); 4683 4684 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0 4685 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0 4686 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0); 4687} 4688 4689/* Add room for N relocations to the .rel(a).dyn section in ABFD. */ 4690 4691static void 4692mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info, 4693 unsigned int n) 4694{ 4695 asection *s; 4696 struct mips_elf_link_hash_table *htab; 4697 4698 htab = mips_elf_hash_table (info); 4699 s = mips_elf_rel_dyn_section (info, FALSE); 4700 BFD_ASSERT (s != NULL); 4701 4702 if (htab->is_vxworks) 4703 s->size += n * MIPS_ELF_RELA_SIZE (abfd); 4704 else 4705 { 4706 if (s->size == 0) 4707 { 4708 /* Make room for a null element. */ 4709 s->size += MIPS_ELF_REL_SIZE (abfd); 4710 ++s->reloc_count; 4711 } 4712 s->size += n * MIPS_ELF_REL_SIZE (abfd); 4713 } 4714} 4715 4716/* Create a rel.dyn relocation for the dynamic linker to resolve. REL 4717 is the original relocation, which is now being transformed into a 4718 dynamic relocation. The ADDENDP is adjusted if necessary; the 4719 caller should store the result in place of the original addend. */ 4720 4721static bfd_boolean 4722mips_elf_create_dynamic_relocation (bfd *output_bfd, 4723 struct bfd_link_info *info, 4724 const Elf_Internal_Rela *rel, 4725 struct mips_elf_link_hash_entry *h, 4726 asection *sec, bfd_vma symbol, 4727 bfd_vma *addendp, asection *input_section) 4728{ 4729 Elf_Internal_Rela outrel[3]; 4730 asection *sreloc; 4731 bfd *dynobj; 4732 int r_type; 4733 long indx; 4734 bfd_boolean defined_p; 4735 struct mips_elf_link_hash_table *htab; 4736 4737 htab = mips_elf_hash_table (info); 4738 r_type = ELF_R_TYPE (output_bfd, rel->r_info); 4739 dynobj = elf_hash_table (info)->dynobj; 4740 sreloc = mips_elf_rel_dyn_section (info, FALSE); 4741 BFD_ASSERT (sreloc != NULL); 4742 BFD_ASSERT (sreloc->contents != NULL); 4743 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd) 4744 < sreloc->size); 4745 4746 outrel[0].r_offset = 4747 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset); 4748 outrel[1].r_offset = 4749 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset); 4750 outrel[2].r_offset = 4751 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset); 4752 4753 if (outrel[0].r_offset == MINUS_ONE) 4754 /* The relocation field has been deleted. */ 4755 return TRUE; 4756 4757 if (outrel[0].r_offset == MINUS_TWO) 4758 { 4759 /* The relocation field has been converted into a relative value of 4760 some sort. Functions like _bfd_elf_write_section_eh_frame expect 4761 the field to be fully relocated, so add in the symbol's value. */ 4762 *addendp += symbol; 4763 return TRUE; 4764 } 4765 4766 /* We must now calculate the dynamic symbol table index to use 4767 in the relocation. */ 4768 if (h != NULL 4769 && (!h->root.def_regular 4770 || (info->shared && !info->symbolic && !h->root.forced_local))) 4771 { 4772 indx = h->root.dynindx; 4773 if (SGI_COMPAT (output_bfd)) 4774 defined_p = h->root.def_regular; 4775 else 4776 /* ??? glibc's ld.so just adds the final GOT entry to the 4777 relocation field. It therefore treats relocs against 4778 defined symbols in the same way as relocs against 4779 undefined symbols. */ 4780 defined_p = FALSE; 4781 } 4782 else 4783 { 4784 if (sec != NULL && bfd_is_abs_section (sec)) 4785 indx = 0; 4786 else if (sec == NULL || sec->owner == NULL) 4787 { 4788 bfd_set_error (bfd_error_bad_value); 4789 return FALSE; 4790 } 4791 else 4792 { 4793 indx = elf_section_data (sec->output_section)->dynindx; 4794 if (indx == 0) 4795 abort (); 4796 } 4797 4798 /* Instead of generating a relocation using the section 4799 symbol, we may as well make it a fully relative 4800 relocation. We want to avoid generating relocations to 4801 local symbols because we used to generate them 4802 incorrectly, without adding the original symbol value, 4803 which is mandated by the ABI for section symbols. In 4804 order to give dynamic loaders and applications time to 4805 phase out the incorrect use, we refrain from emitting 4806 section-relative relocations. It's not like they're 4807 useful, after all. This should be a bit more efficient 4808 as well. */ 4809 /* ??? Although this behavior is compatible with glibc's ld.so, 4810 the ABI says that relocations against STN_UNDEF should have 4811 a symbol value of 0. Irix rld honors this, so relocations 4812 against STN_UNDEF have no effect. */ 4813 if (!SGI_COMPAT (output_bfd)) 4814 indx = 0; 4815 defined_p = TRUE; 4816 } 4817 4818 /* If the relocation was previously an absolute relocation and 4819 this symbol will not be referred to by the relocation, we must 4820 adjust it by the value we give it in the dynamic symbol table. 4821 Otherwise leave the job up to the dynamic linker. */ 4822 if (defined_p && r_type != R_MIPS_REL32) 4823 *addendp += symbol; 4824 4825 if (htab->is_vxworks) 4826 /* VxWorks uses non-relative relocations for this. */ 4827 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32); 4828 else 4829 /* The relocation is always an REL32 relocation because we don't 4830 know where the shared library will wind up at load-time. */ 4831 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx, 4832 R_MIPS_REL32); 4833 4834 /* For strict adherence to the ABI specification, we should 4835 generate a R_MIPS_64 relocation record by itself before the 4836 _REL32/_64 record as well, such that the addend is read in as 4837 a 64-bit value (REL32 is a 32-bit relocation, after all). 4838 However, since none of the existing ELF64 MIPS dynamic 4839 loaders seems to care, we don't waste space with these 4840 artificial relocations. If this turns out to not be true, 4841 mips_elf_allocate_dynamic_relocation() should be tweaked so 4842 as to make room for a pair of dynamic relocations per 4843 invocation if ABI_64_P, and here we should generate an 4844 additional relocation record with R_MIPS_64 by itself for a 4845 NULL symbol before this relocation record. */ 4846 outrel[1].r_info = ELF_R_INFO (output_bfd, 0, 4847 ABI_64_P (output_bfd) 4848 ? R_MIPS_64 4849 : R_MIPS_NONE); 4850 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE); 4851 4852 /* Adjust the output offset of the relocation to reference the 4853 correct location in the output file. */ 4854 outrel[0].r_offset += (input_section->output_section->vma 4855 + input_section->output_offset); 4856 outrel[1].r_offset += (input_section->output_section->vma 4857 + input_section->output_offset); 4858 outrel[2].r_offset += (input_section->output_section->vma 4859 + input_section->output_offset); 4860 4861 /* Put the relocation back out. We have to use the special 4862 relocation outputter in the 64-bit case since the 64-bit 4863 relocation format is non-standard. */ 4864 if (ABI_64_P (output_bfd)) 4865 { 4866 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out) 4867 (output_bfd, &outrel[0], 4868 (sreloc->contents 4869 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel))); 4870 } 4871 else if (htab->is_vxworks) 4872 { 4873 /* VxWorks uses RELA rather than REL dynamic relocations. */ 4874 outrel[0].r_addend = *addendp; 4875 bfd_elf32_swap_reloca_out 4876 (output_bfd, &outrel[0], 4877 (sreloc->contents 4878 + sreloc->reloc_count * sizeof (Elf32_External_Rela))); 4879 } 4880 else 4881 bfd_elf32_swap_reloc_out 4882 (output_bfd, &outrel[0], 4883 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel))); 4884 4885 /* We've now added another relocation. */ 4886 ++sreloc->reloc_count; 4887 4888 /* Make sure the output section is writable. The dynamic linker 4889 will be writing to it. */ 4890 elf_section_data (input_section->output_section)->this_hdr.sh_flags 4891 |= SHF_WRITE; 4892 4893 /* On IRIX5, make an entry of compact relocation info. */ 4894 if (IRIX_COMPAT (output_bfd) == ict_irix5) 4895 { 4896 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel"); 4897 bfd_byte *cr; 4898 4899 if (scpt) 4900 { 4901 Elf32_crinfo cptrel; 4902 4903 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG); 4904 cptrel.vaddr = (rel->r_offset 4905 + input_section->output_section->vma 4906 + input_section->output_offset); 4907 if (r_type == R_MIPS_REL32) 4908 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32); 4909 else 4910 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD); 4911 mips_elf_set_cr_dist2to (cptrel, 0); 4912 cptrel.konst = *addendp; 4913 4914 cr = (scpt->contents 4915 + sizeof (Elf32_External_compact_rel)); 4916 mips_elf_set_cr_relvaddr (cptrel, 0); 4917 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel, 4918 ((Elf32_External_crinfo *) cr 4919 + scpt->reloc_count)); 4920 ++scpt->reloc_count; 4921 } 4922 } 4923 4924 /* If we've written this relocation for a readonly section, 4925 we need to set DF_TEXTREL again, so that we do not delete the 4926 DT_TEXTREL tag. */ 4927 if (MIPS_ELF_READONLY_SECTION (input_section)) 4928 info->flags |= DF_TEXTREL; 4929 4930 return TRUE; 4931} 4932 4933/* Return the MACH for a MIPS e_flags value. */ 4934 4935unsigned long 4936_bfd_elf_mips_mach (flagword flags) 4937{ 4938 switch (flags & EF_MIPS_MACH) 4939 { 4940 case E_MIPS_MACH_3900: 4941 return bfd_mach_mips3900; 4942 4943 case E_MIPS_MACH_4010: 4944 return bfd_mach_mips4010; 4945 4946 case E_MIPS_MACH_4100: 4947 return bfd_mach_mips4100; 4948 4949 case E_MIPS_MACH_4111: 4950 return bfd_mach_mips4111; 4951 4952 case E_MIPS_MACH_4120: 4953 return bfd_mach_mips4120; 4954 4955 case E_MIPS_MACH_4650: 4956 return bfd_mach_mips4650; 4957 4958 case E_MIPS_MACH_5400: 4959 return bfd_mach_mips5400; 4960 4961 case E_MIPS_MACH_5500: 4962 return bfd_mach_mips5500; 4963 4964 case E_MIPS_MACH_9000: 4965 return bfd_mach_mips9000; 4966 4967 case E_MIPS_MACH_SB1: 4968 return bfd_mach_mips_sb1; 4969 4970 default: 4971 switch (flags & EF_MIPS_ARCH) 4972 { 4973 default: 4974 case E_MIPS_ARCH_1: 4975 return bfd_mach_mips3000; 4976 break; 4977 4978 case E_MIPS_ARCH_2: 4979 return bfd_mach_mips6000; 4980 break; 4981 4982 case E_MIPS_ARCH_3: 4983 return bfd_mach_mips4000; 4984 break; 4985 4986 case E_MIPS_ARCH_4: 4987 return bfd_mach_mips8000; 4988 break; 4989 4990 case E_MIPS_ARCH_5: 4991 return bfd_mach_mips5; 4992 break; 4993 4994 case E_MIPS_ARCH_32: 4995 return bfd_mach_mipsisa32; 4996 break; 4997 4998 case E_MIPS_ARCH_64: 4999 return bfd_mach_mipsisa64; 5000 break; 5001 5002 case E_MIPS_ARCH_32R2: 5003 return bfd_mach_mipsisa32r2; 5004 break; 5005 5006 case E_MIPS_ARCH_64R2: 5007 return bfd_mach_mipsisa64r2; 5008 break; 5009 } 5010 } 5011 5012 return 0; 5013} 5014 5015/* Return printable name for ABI. */ 5016 5017static INLINE char * 5018elf_mips_abi_name (bfd *abfd) 5019{ 5020 flagword flags; 5021 5022 flags = elf_elfheader (abfd)->e_flags; 5023 switch (flags & EF_MIPS_ABI) 5024 { 5025 case 0: 5026 if (ABI_N32_P (abfd)) 5027 return "N32"; 5028 else if (ABI_64_P (abfd)) 5029 return "64"; 5030 else 5031 return "none"; 5032 case E_MIPS_ABI_O32: 5033 return "O32"; 5034 case E_MIPS_ABI_O64: 5035 return "O64"; 5036 case E_MIPS_ABI_EABI32: 5037 return "EABI32"; 5038 case E_MIPS_ABI_EABI64: 5039 return "EABI64"; 5040 default: 5041 return "unknown abi"; 5042 } 5043} 5044 5045/* MIPS ELF uses two common sections. One is the usual one, and the 5046 other is for small objects. All the small objects are kept 5047 together, and then referenced via the gp pointer, which yields 5048 faster assembler code. This is what we use for the small common 5049 section. This approach is copied from ecoff.c. */ 5050static asection mips_elf_scom_section; 5051static asymbol mips_elf_scom_symbol; 5052static asymbol *mips_elf_scom_symbol_ptr; 5053 5054/* MIPS ELF also uses an acommon section, which represents an 5055 allocated common symbol which may be overridden by a 5056 definition in a shared library. */ 5057static asection mips_elf_acom_section; 5058static asymbol mips_elf_acom_symbol; 5059static asymbol *mips_elf_acom_symbol_ptr; 5060 5061/* Handle the special MIPS section numbers that a symbol may use. 5062 This is used for both the 32-bit and the 64-bit ABI. */ 5063 5064void 5065_bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym) 5066{ 5067 elf_symbol_type *elfsym; 5068 5069 elfsym = (elf_symbol_type *) asym; 5070 switch (elfsym->internal_elf_sym.st_shndx) 5071 { 5072 case SHN_MIPS_ACOMMON: 5073 /* This section is used in a dynamically linked executable file. 5074 It is an allocated common section. The dynamic linker can 5075 either resolve these symbols to something in a shared 5076 library, or it can just leave them here. For our purposes, 5077 we can consider these symbols to be in a new section. */ 5078 if (mips_elf_acom_section.name == NULL) 5079 { 5080 /* Initialize the acommon section. */ 5081 mips_elf_acom_section.name = ".acommon"; 5082 mips_elf_acom_section.flags = SEC_ALLOC; 5083 mips_elf_acom_section.output_section = &mips_elf_acom_section; 5084 mips_elf_acom_section.symbol = &mips_elf_acom_symbol; 5085 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr; 5086 mips_elf_acom_symbol.name = ".acommon"; 5087 mips_elf_acom_symbol.flags = BSF_SECTION_SYM; 5088 mips_elf_acom_symbol.section = &mips_elf_acom_section; 5089 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol; 5090 } 5091 asym->section = &mips_elf_acom_section; 5092 break; 5093 5094 case SHN_COMMON: 5095 /* Common symbols less than the GP size are automatically 5096 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */ 5097 if (asym->value > elf_gp_size (abfd) 5098 || IRIX_COMPAT (abfd) == ict_irix6) 5099 break; 5100 /* Fall through. */ 5101 case SHN_MIPS_SCOMMON: 5102 if (mips_elf_scom_section.name == NULL) 5103 { 5104 /* Initialize the small common section. */ 5105 mips_elf_scom_section.name = ".scommon"; 5106 mips_elf_scom_section.flags = SEC_IS_COMMON; 5107 mips_elf_scom_section.output_section = &mips_elf_scom_section; 5108 mips_elf_scom_section.symbol = &mips_elf_scom_symbol; 5109 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr; 5110 mips_elf_scom_symbol.name = ".scommon"; 5111 mips_elf_scom_symbol.flags = BSF_SECTION_SYM; 5112 mips_elf_scom_symbol.section = &mips_elf_scom_section; 5113 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol; 5114 } 5115 asym->section = &mips_elf_scom_section; 5116 asym->value = elfsym->internal_elf_sym.st_size; 5117 break; 5118 5119 case SHN_MIPS_SUNDEFINED: 5120 asym->section = bfd_und_section_ptr; 5121 break; 5122 5123 case SHN_MIPS_TEXT: 5124 { 5125 asection *section = bfd_get_section_by_name (abfd, ".text"); 5126 5127 BFD_ASSERT (SGI_COMPAT (abfd)); 5128 if (section != NULL) 5129 { 5130 asym->section = section; 5131 /* MIPS_TEXT is a bit special, the address is not an offset 5132 to the base of the .text section. So substract the section 5133 base address to make it an offset. */ 5134 asym->value -= section->vma; 5135 } 5136 } 5137 break; 5138 5139 case SHN_MIPS_DATA: 5140 { 5141 asection *section = bfd_get_section_by_name (abfd, ".data"); 5142 5143 BFD_ASSERT (SGI_COMPAT (abfd)); 5144 if (section != NULL) 5145 { 5146 asym->section = section; 5147 /* MIPS_DATA is a bit special, the address is not an offset 5148 to the base of the .data section. So substract the section 5149 base address to make it an offset. */ 5150 asym->value -= section->vma; 5151 } 5152 } 5153 break; 5154 } 5155} 5156 5157/* Implement elf_backend_eh_frame_address_size. This differs from 5158 the default in the way it handles EABI64. 5159 5160 EABI64 was originally specified as an LP64 ABI, and that is what 5161 -mabi=eabi normally gives on a 64-bit target. However, gcc has 5162 historically accepted the combination of -mabi=eabi and -mlong32, 5163 and this ILP32 variation has become semi-official over time. 5164 Both forms use elf32 and have pointer-sized FDE addresses. 5165 5166 If an EABI object was generated by GCC 4.0 or above, it will have 5167 an empty .gcc_compiled_longXX section, where XX is the size of longs 5168 in bits. Unfortunately, ILP32 objects generated by earlier compilers 5169 have no special marking to distinguish them from LP64 objects. 5170 5171 We don't want users of the official LP64 ABI to be punished for the 5172 existence of the ILP32 variant, but at the same time, we don't want 5173 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects. 5174 We therefore take the following approach: 5175 5176 - If ABFD contains a .gcc_compiled_longXX section, use it to 5177 determine the pointer size. 5178 5179 - Otherwise check the type of the first relocation. Assume that 5180 the LP64 ABI is being used if the relocation is of type R_MIPS_64. 5181 5182 - Otherwise punt. 5183 5184 The second check is enough to detect LP64 objects generated by pre-4.0 5185 compilers because, in the kind of output generated by those compilers, 5186 the first relocation will be associated with either a CIE personality 5187 routine or an FDE start address. Furthermore, the compilers never 5188 used a special (non-pointer) encoding for this ABI. 5189 5190 Checking the relocation type should also be safe because there is no 5191 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never 5192 did so. */ 5193 5194unsigned int 5195_bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec) 5196{ 5197 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 5198 return 8; 5199 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64) 5200 { 5201 bfd_boolean long32_p, long64_p; 5202 5203 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0; 5204 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0; 5205 if (long32_p && long64_p) 5206 return 0; 5207 if (long32_p) 5208 return 4; 5209 if (long64_p) 5210 return 8; 5211 5212 if (sec->reloc_count > 0 5213 && elf_section_data (sec)->relocs != NULL 5214 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info) 5215 == R_MIPS_64)) 5216 return 8; 5217 5218 return 0; 5219 } 5220 return 4; 5221} 5222 5223/* There appears to be a bug in the MIPSpro linker that causes GOT_DISP 5224 relocations against two unnamed section symbols to resolve to the 5225 same address. For example, if we have code like: 5226 5227 lw $4,%got_disp(.data)($gp) 5228 lw $25,%got_disp(.text)($gp) 5229 jalr $25 5230 5231 then the linker will resolve both relocations to .data and the program 5232 will jump there rather than to .text. 5233 5234 We can work around this problem by giving names to local section symbols. 5235 This is also what the MIPSpro tools do. */ 5236 5237bfd_boolean 5238_bfd_mips_elf_name_local_section_symbols (bfd *abfd) 5239{ 5240 return SGI_COMPAT (abfd); 5241} 5242 5243/* Work over a section just before writing it out. This routine is 5244 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize 5245 sections that need the SHF_MIPS_GPREL flag by name; there has to be 5246 a better way. */ 5247 5248bfd_boolean 5249_bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr) 5250{ 5251 if (hdr->sh_type == SHT_MIPS_REGINFO 5252 && hdr->sh_size > 0) 5253 { 5254 bfd_byte buf[4]; 5255 5256 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo)); 5257 BFD_ASSERT (hdr->contents == NULL); 5258 5259 if (bfd_seek (abfd, 5260 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4, 5261 SEEK_SET) != 0) 5262 return FALSE; 5263 H_PUT_32 (abfd, elf_gp (abfd), buf); 5264 if (bfd_bwrite (buf, 4, abfd) != 4) 5265 return FALSE; 5266 } 5267 5268 if (hdr->sh_type == SHT_MIPS_OPTIONS 5269 && hdr->bfd_section != NULL 5270 && mips_elf_section_data (hdr->bfd_section) != NULL 5271 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL) 5272 { 5273 bfd_byte *contents, *l, *lend; 5274 5275 /* We stored the section contents in the tdata field in the 5276 set_section_contents routine. We save the section contents 5277 so that we don't have to read them again. 5278 At this point we know that elf_gp is set, so we can look 5279 through the section contents to see if there is an 5280 ODK_REGINFO structure. */ 5281 5282 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata; 5283 l = contents; 5284 lend = contents + hdr->sh_size; 5285 while (l + sizeof (Elf_External_Options) <= lend) 5286 { 5287 Elf_Internal_Options intopt; 5288 5289 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l, 5290 &intopt); 5291 if (intopt.size < sizeof (Elf_External_Options)) 5292 { 5293 (*_bfd_error_handler) 5294 (_("%B: Warning: bad `%s' option size %u smaller than its header"), 5295 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size); 5296 break; 5297 } 5298 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO) 5299 { 5300 bfd_byte buf[8]; 5301 5302 if (bfd_seek (abfd, 5303 (hdr->sh_offset 5304 + (l - contents) 5305 + sizeof (Elf_External_Options) 5306 + (sizeof (Elf64_External_RegInfo) - 8)), 5307 SEEK_SET) != 0) 5308 return FALSE; 5309 H_PUT_64 (abfd, elf_gp (abfd), buf); 5310 if (bfd_bwrite (buf, 8, abfd) != 8) 5311 return FALSE; 5312 } 5313 else if (intopt.kind == ODK_REGINFO) 5314 { 5315 bfd_byte buf[4]; 5316 5317 if (bfd_seek (abfd, 5318 (hdr->sh_offset 5319 + (l - contents) 5320 + sizeof (Elf_External_Options) 5321 + (sizeof (Elf32_External_RegInfo) - 4)), 5322 SEEK_SET) != 0) 5323 return FALSE; 5324 H_PUT_32 (abfd, elf_gp (abfd), buf); 5325 if (bfd_bwrite (buf, 4, abfd) != 4) 5326 return FALSE; 5327 } 5328 l += intopt.size; 5329 } 5330 } 5331 5332 if (hdr->bfd_section != NULL) 5333 { 5334 const char *name = bfd_get_section_name (abfd, hdr->bfd_section); 5335 5336 if (strcmp (name, ".sdata") == 0 5337 || strcmp (name, ".lit8") == 0 5338 || strcmp (name, ".lit4") == 0) 5339 { 5340 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL; 5341 hdr->sh_type = SHT_PROGBITS; 5342 } 5343 else if (strcmp (name, ".sbss") == 0) 5344 { 5345 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL; 5346 hdr->sh_type = SHT_NOBITS; 5347 } 5348 else if (strcmp (name, ".srdata") == 0) 5349 { 5350 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL; 5351 hdr->sh_type = SHT_PROGBITS; 5352 } 5353 else if (strcmp (name, ".compact_rel") == 0) 5354 { 5355 hdr->sh_flags = 0; 5356 hdr->sh_type = SHT_PROGBITS; 5357 } 5358 else if (strcmp (name, ".rtproc") == 0) 5359 { 5360 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0) 5361 { 5362 unsigned int adjust; 5363 5364 adjust = hdr->sh_size % hdr->sh_addralign; 5365 if (adjust != 0) 5366 hdr->sh_size += hdr->sh_addralign - adjust; 5367 } 5368 } 5369 } 5370 5371 return TRUE; 5372} 5373 5374/* Handle a MIPS specific section when reading an object file. This 5375 is called when elfcode.h finds a section with an unknown type. 5376 This routine supports both the 32-bit and 64-bit ELF ABI. 5377 5378 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure 5379 how to. */ 5380 5381bfd_boolean 5382_bfd_mips_elf_section_from_shdr (bfd *abfd, 5383 Elf_Internal_Shdr *hdr, 5384 const char *name, 5385 int shindex) 5386{ 5387 flagword flags = 0; 5388 5389 /* There ought to be a place to keep ELF backend specific flags, but 5390 at the moment there isn't one. We just keep track of the 5391 sections by their name, instead. Fortunately, the ABI gives 5392 suggested names for all the MIPS specific sections, so we will 5393 probably get away with this. */ 5394 switch (hdr->sh_type) 5395 { 5396 case SHT_MIPS_LIBLIST: 5397 if (strcmp (name, ".liblist") != 0) 5398 return FALSE; 5399 break; 5400 case SHT_MIPS_MSYM: 5401 if (strcmp (name, ".msym") != 0) 5402 return FALSE; 5403 break; 5404 case SHT_MIPS_CONFLICT: 5405 if (strcmp (name, ".conflict") != 0) 5406 return FALSE; 5407 break; 5408 case SHT_MIPS_GPTAB: 5409 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0) 5410 return FALSE; 5411 break; 5412 case SHT_MIPS_UCODE: 5413 if (strcmp (name, ".ucode") != 0) 5414 return FALSE; 5415 break; 5416 case SHT_MIPS_DEBUG: 5417 if (strcmp (name, ".mdebug") != 0) 5418 return FALSE; 5419 flags = SEC_DEBUGGING; 5420 break; 5421 case SHT_MIPS_REGINFO: 5422 if (strcmp (name, ".reginfo") != 0 5423 || hdr->sh_size != sizeof (Elf32_External_RegInfo)) 5424 return FALSE; 5425 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE); 5426 break; 5427 case SHT_MIPS_IFACE: 5428 if (strcmp (name, ".MIPS.interfaces") != 0) 5429 return FALSE; 5430 break; 5431 case SHT_MIPS_CONTENT: 5432 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0) 5433 return FALSE; 5434 break; 5435 case SHT_MIPS_OPTIONS: 5436 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name)) 5437 return FALSE; 5438 break; 5439 case SHT_MIPS_DWARF: 5440 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0) 5441 return FALSE; 5442 break; 5443 case SHT_MIPS_SYMBOL_LIB: 5444 if (strcmp (name, ".MIPS.symlib") != 0) 5445 return FALSE; 5446 break; 5447 case SHT_MIPS_EVENTS: 5448 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0 5449 && strncmp (name, ".MIPS.post_rel", 5450 sizeof ".MIPS.post_rel" - 1) != 0) 5451 return FALSE; 5452 break; 5453 default: 5454 break; 5455 } 5456 5457 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 5458 return FALSE; 5459 5460 if (flags) 5461 { 5462 if (! bfd_set_section_flags (abfd, hdr->bfd_section, 5463 (bfd_get_section_flags (abfd, 5464 hdr->bfd_section) 5465 | flags))) 5466 return FALSE; 5467 } 5468 5469 /* FIXME: We should record sh_info for a .gptab section. */ 5470 5471 /* For a .reginfo section, set the gp value in the tdata information 5472 from the contents of this section. We need the gp value while 5473 processing relocs, so we just get it now. The .reginfo section 5474 is not used in the 64-bit MIPS ELF ABI. */ 5475 if (hdr->sh_type == SHT_MIPS_REGINFO) 5476 { 5477 Elf32_External_RegInfo ext; 5478 Elf32_RegInfo s; 5479 5480 if (! bfd_get_section_contents (abfd, hdr->bfd_section, 5481 &ext, 0, sizeof ext)) 5482 return FALSE; 5483 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s); 5484 elf_gp (abfd) = s.ri_gp_value; 5485 } 5486 5487 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and 5488 set the gp value based on what we find. We may see both 5489 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case, 5490 they should agree. */ 5491 if (hdr->sh_type == SHT_MIPS_OPTIONS) 5492 { 5493 bfd_byte *contents, *l, *lend; 5494 5495 contents = bfd_malloc (hdr->sh_size); 5496 if (contents == NULL) 5497 return FALSE; 5498 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents, 5499 0, hdr->sh_size)) 5500 { 5501 free (contents); 5502 return FALSE; 5503 } 5504 l = contents; 5505 lend = contents + hdr->sh_size; 5506 while (l + sizeof (Elf_External_Options) <= lend) 5507 { 5508 Elf_Internal_Options intopt; 5509 5510 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l, 5511 &intopt); 5512 if (intopt.size < sizeof (Elf_External_Options)) 5513 { 5514 (*_bfd_error_handler) 5515 (_("%B: Warning: bad `%s' option size %u smaller than its header"), 5516 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size); 5517 break; 5518 } 5519 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO) 5520 { 5521 Elf64_Internal_RegInfo intreg; 5522 5523 bfd_mips_elf64_swap_reginfo_in 5524 (abfd, 5525 ((Elf64_External_RegInfo *) 5526 (l + sizeof (Elf_External_Options))), 5527 &intreg); 5528 elf_gp (abfd) = intreg.ri_gp_value; 5529 } 5530 else if (intopt.kind == ODK_REGINFO) 5531 { 5532 Elf32_RegInfo intreg; 5533 5534 bfd_mips_elf32_swap_reginfo_in 5535 (abfd, 5536 ((Elf32_External_RegInfo *) 5537 (l + sizeof (Elf_External_Options))), 5538 &intreg); 5539 elf_gp (abfd) = intreg.ri_gp_value; 5540 } 5541 l += intopt.size; 5542 } 5543 free (contents); 5544 } 5545 5546 return TRUE; 5547} 5548 5549/* Set the correct type for a MIPS ELF section. We do this by the 5550 section name, which is a hack, but ought to work. This routine is 5551 used by both the 32-bit and the 64-bit ABI. */ 5552 5553bfd_boolean 5554_bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec) 5555{ 5556 register const char *name; 5557 unsigned int sh_type; 5558 5559 name = bfd_get_section_name (abfd, sec); 5560 sh_type = hdr->sh_type; 5561 5562 if (strcmp (name, ".liblist") == 0) 5563 { 5564 hdr->sh_type = SHT_MIPS_LIBLIST; 5565 hdr->sh_info = sec->size / sizeof (Elf32_Lib); 5566 /* The sh_link field is set in final_write_processing. */ 5567 } 5568 else if (strcmp (name, ".conflict") == 0) 5569 hdr->sh_type = SHT_MIPS_CONFLICT; 5570 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0) 5571 { 5572 hdr->sh_type = SHT_MIPS_GPTAB; 5573 hdr->sh_entsize = sizeof (Elf32_External_gptab); 5574 /* The sh_info field is set in final_write_processing. */ 5575 } 5576 else if (strcmp (name, ".ucode") == 0) 5577 hdr->sh_type = SHT_MIPS_UCODE; 5578 else if (strcmp (name, ".mdebug") == 0) 5579 { 5580 hdr->sh_type = SHT_MIPS_DEBUG; 5581 /* In a shared object on IRIX 5.3, the .mdebug section has an 5582 entsize of 0. FIXME: Does this matter? */ 5583 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0) 5584 hdr->sh_entsize = 0; 5585 else 5586 hdr->sh_entsize = 1; 5587 } 5588 else if (strcmp (name, ".reginfo") == 0) 5589 { 5590 hdr->sh_type = SHT_MIPS_REGINFO; 5591 /* In a shared object on IRIX 5.3, the .reginfo section has an 5592 entsize of 0x18. FIXME: Does this matter? */ 5593 if (SGI_COMPAT (abfd)) 5594 { 5595 if ((abfd->flags & DYNAMIC) != 0) 5596 hdr->sh_entsize = sizeof (Elf32_External_RegInfo); 5597 else 5598 hdr->sh_entsize = 1; 5599 } 5600 else 5601 hdr->sh_entsize = sizeof (Elf32_External_RegInfo); 5602 } 5603 else if (SGI_COMPAT (abfd) 5604 && (strcmp (name, ".hash") == 0 5605 || strcmp (name, ".dynamic") == 0 5606 || strcmp (name, ".dynstr") == 0)) 5607 { 5608 if (SGI_COMPAT (abfd)) 5609 hdr->sh_entsize = 0; 5610#if 0 5611 /* This isn't how the IRIX6 linker behaves. */ 5612 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES; 5613#endif 5614 } 5615 else if (strcmp (name, ".got") == 0 5616 || strcmp (name, ".srdata") == 0 5617 || strcmp (name, ".sdata") == 0 5618 || strcmp (name, ".sbss") == 0 5619 || strcmp (name, ".lit4") == 0 5620 || strcmp (name, ".lit8") == 0) 5621 hdr->sh_flags |= SHF_MIPS_GPREL; 5622 else if (strcmp (name, ".MIPS.interfaces") == 0) 5623 { 5624 hdr->sh_type = SHT_MIPS_IFACE; 5625 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 5626 } 5627 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0) 5628 { 5629 hdr->sh_type = SHT_MIPS_CONTENT; 5630 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 5631 /* The sh_info field is set in final_write_processing. */ 5632 } 5633 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name)) 5634 { 5635 hdr->sh_type = SHT_MIPS_OPTIONS; 5636 hdr->sh_entsize = 1; 5637 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 5638 } 5639 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0) 5640 hdr->sh_type = SHT_MIPS_DWARF; 5641 else if (strcmp (name, ".MIPS.symlib") == 0) 5642 { 5643 hdr->sh_type = SHT_MIPS_SYMBOL_LIB; 5644 /* The sh_link and sh_info fields are set in 5645 final_write_processing. */ 5646 } 5647 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0 5648 || strncmp (name, ".MIPS.post_rel", 5649 sizeof ".MIPS.post_rel" - 1) == 0) 5650 { 5651 hdr->sh_type = SHT_MIPS_EVENTS; 5652 hdr->sh_flags |= SHF_MIPS_NOSTRIP; 5653 /* The sh_link field is set in final_write_processing. */ 5654 } 5655 else if (strcmp (name, ".msym") == 0) 5656 { 5657 hdr->sh_type = SHT_MIPS_MSYM; 5658 hdr->sh_flags |= SHF_ALLOC; 5659 hdr->sh_entsize = 8; 5660 } 5661 5662 /* In the unlikely event a special section is empty it has to lose its 5663 special meaning. This may happen e.g. when using `strip' with the 5664 "--only-keep-debug" option. */ 5665 if (sec->size > 0 && !(sec->flags & SEC_HAS_CONTENTS)) 5666 hdr->sh_type = sh_type; 5667 5668 /* The generic elf_fake_sections will set up REL_HDR using the default 5669 kind of relocations. We used to set up a second header for the 5670 non-default kind of relocations here, but only NewABI would use 5671 these, and the IRIX ld doesn't like resulting empty RELA sections. 5672 Thus we create those header only on demand now. */ 5673 5674 return TRUE; 5675} 5676 5677/* Given a BFD section, try to locate the corresponding ELF section 5678 index. This is used by both the 32-bit and the 64-bit ABI. 5679 Actually, it's not clear to me that the 64-bit ABI supports these, 5680 but for non-PIC objects we will certainly want support for at least 5681 the .scommon section. */ 5682 5683bfd_boolean 5684_bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 5685 asection *sec, int *retval) 5686{ 5687 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0) 5688 { 5689 *retval = SHN_MIPS_SCOMMON; 5690 return TRUE; 5691 } 5692 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0) 5693 { 5694 *retval = SHN_MIPS_ACOMMON; 5695 return TRUE; 5696 } 5697 return FALSE; 5698} 5699 5700/* Hook called by the linker routine which adds symbols from an object 5701 file. We must handle the special MIPS section numbers here. */ 5702 5703bfd_boolean 5704_bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info, 5705 Elf_Internal_Sym *sym, const char **namep, 5706 flagword *flagsp ATTRIBUTE_UNUSED, 5707 asection **secp, bfd_vma *valp) 5708{ 5709 if (SGI_COMPAT (abfd) 5710 && (abfd->flags & DYNAMIC) != 0 5711 && strcmp (*namep, "_rld_new_interface") == 0) 5712 { 5713 /* Skip IRIX5 rld entry name. */ 5714 *namep = NULL; 5715 return TRUE; 5716 } 5717 5718 /* Shared objects may have a dynamic symbol '_gp_disp' defined as 5719 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp 5720 by setting a DT_NEEDED for the shared object. Since _gp_disp is 5721 a magic symbol resolved by the linker, we ignore this bogus definition 5722 of _gp_disp. New ABI objects do not suffer from this problem so this 5723 is not done for them. */ 5724 if (!NEWABI_P(abfd) 5725 && (sym->st_shndx == SHN_ABS) 5726 && (strcmp (*namep, "_gp_disp") == 0)) 5727 { 5728 *namep = NULL; 5729 return TRUE; 5730 } 5731 5732 switch (sym->st_shndx) 5733 { 5734 case SHN_COMMON: 5735 /* Common symbols less than the GP size are automatically 5736 treated as SHN_MIPS_SCOMMON symbols. */ 5737 if (sym->st_size > elf_gp_size (abfd) 5738 || IRIX_COMPAT (abfd) == ict_irix6) 5739 break; 5740 /* Fall through. */ 5741 case SHN_MIPS_SCOMMON: 5742 *secp = bfd_make_section_old_way (abfd, ".scommon"); 5743 (*secp)->flags |= SEC_IS_COMMON; 5744 *valp = sym->st_size; 5745 break; 5746 5747 case SHN_MIPS_TEXT: 5748 /* This section is used in a shared object. */ 5749 if (elf_tdata (abfd)->elf_text_section == NULL) 5750 { 5751 asymbol *elf_text_symbol; 5752 asection *elf_text_section; 5753 bfd_size_type amt = sizeof (asection); 5754 5755 elf_text_section = bfd_zalloc (abfd, amt); 5756 if (elf_text_section == NULL) 5757 return FALSE; 5758 5759 amt = sizeof (asymbol); 5760 elf_text_symbol = bfd_zalloc (abfd, amt); 5761 if (elf_text_symbol == NULL) 5762 return FALSE; 5763 5764 /* Initialize the section. */ 5765 5766 elf_tdata (abfd)->elf_text_section = elf_text_section; 5767 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol; 5768 5769 elf_text_section->symbol = elf_text_symbol; 5770 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol; 5771 5772 elf_text_section->name = ".text"; 5773 elf_text_section->flags = SEC_NO_FLAGS; 5774 elf_text_section->output_section = NULL; 5775 elf_text_section->owner = abfd; 5776 elf_text_symbol->name = ".text"; 5777 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC; 5778 elf_text_symbol->section = elf_text_section; 5779 } 5780 /* This code used to do *secp = bfd_und_section_ptr if 5781 info->shared. I don't know why, and that doesn't make sense, 5782 so I took it out. */ 5783 *secp = elf_tdata (abfd)->elf_text_section; 5784 break; 5785 5786 case SHN_MIPS_ACOMMON: 5787 /* Fall through. XXX Can we treat this as allocated data? */ 5788 case SHN_MIPS_DATA: 5789 /* This section is used in a shared object. */ 5790 if (elf_tdata (abfd)->elf_data_section == NULL) 5791 { 5792 asymbol *elf_data_symbol; 5793 asection *elf_data_section; 5794 bfd_size_type amt = sizeof (asection); 5795 5796 elf_data_section = bfd_zalloc (abfd, amt); 5797 if (elf_data_section == NULL) 5798 return FALSE; 5799 5800 amt = sizeof (asymbol); 5801 elf_data_symbol = bfd_zalloc (abfd, amt); 5802 if (elf_data_symbol == NULL) 5803 return FALSE; 5804 5805 /* Initialize the section. */ 5806 5807 elf_tdata (abfd)->elf_data_section = elf_data_section; 5808 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol; 5809 5810 elf_data_section->symbol = elf_data_symbol; 5811 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol; 5812 5813 elf_data_section->name = ".data"; 5814 elf_data_section->flags = SEC_NO_FLAGS; 5815 elf_data_section->output_section = NULL; 5816 elf_data_section->owner = abfd; 5817 elf_data_symbol->name = ".data"; 5818 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC; 5819 elf_data_symbol->section = elf_data_section; 5820 } 5821 /* This code used to do *secp = bfd_und_section_ptr if 5822 info->shared. I don't know why, and that doesn't make sense, 5823 so I took it out. */ 5824 *secp = elf_tdata (abfd)->elf_data_section; 5825 break; 5826 5827 case SHN_MIPS_SUNDEFINED: 5828 *secp = bfd_und_section_ptr; 5829 break; 5830 } 5831 5832 if (SGI_COMPAT (abfd) 5833 && ! info->shared 5834 && info->hash->creator == abfd->xvec 5835 && strcmp (*namep, "__rld_obj_head") == 0) 5836 { 5837 struct elf_link_hash_entry *h; 5838 struct bfd_link_hash_entry *bh; 5839 5840 /* Mark __rld_obj_head as dynamic. */ 5841 bh = NULL; 5842 if (! (_bfd_generic_link_add_one_symbol 5843 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE, 5844 get_elf_backend_data (abfd)->collect, &bh))) 5845 return FALSE; 5846 5847 h = (struct elf_link_hash_entry *) bh; 5848 h->non_elf = 0; 5849 h->def_regular = 1; 5850 h->type = STT_OBJECT; 5851 5852 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5853 return FALSE; 5854 5855 mips_elf_hash_table (info)->use_rld_obj_head = TRUE; 5856 } 5857 5858 /* If this is a mips16 text symbol, add 1 to the value to make it 5859 odd. This will cause something like .word SYM to come up with 5860 the right value when it is loaded into the PC. */ 5861 if (sym->st_other == STO_MIPS16) 5862 ++*valp; 5863 5864 return TRUE; 5865} 5866 5867/* This hook function is called before the linker writes out a global 5868 symbol. We mark symbols as small common if appropriate. This is 5869 also where we undo the increment of the value for a mips16 symbol. */ 5870 5871bfd_boolean 5872_bfd_mips_elf_link_output_symbol_hook 5873 (struct bfd_link_info *info ATTRIBUTE_UNUSED, 5874 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym, 5875 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 5876{ 5877 /* If we see a common symbol, which implies a relocatable link, then 5878 if a symbol was small common in an input file, mark it as small 5879 common in the output file. */ 5880 if (sym->st_shndx == SHN_COMMON 5881 && strcmp (input_sec->name, ".scommon") == 0) 5882 sym->st_shndx = SHN_MIPS_SCOMMON; 5883 5884 if (sym->st_other == STO_MIPS16) 5885 sym->st_value &= ~1; 5886 5887 return TRUE; 5888} 5889 5890/* Functions for the dynamic linker. */ 5891 5892/* Create dynamic sections when linking against a dynamic object. */ 5893 5894bfd_boolean 5895_bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 5896{ 5897 struct elf_link_hash_entry *h; 5898 struct bfd_link_hash_entry *bh; 5899 flagword flags; 5900 register asection *s; 5901 const char * const *namep; 5902 struct mips_elf_link_hash_table *htab; 5903 5904 htab = mips_elf_hash_table (info); 5905 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 5906 | SEC_LINKER_CREATED | SEC_READONLY); 5907 5908 /* The psABI requires a read-only .dynamic section, but the VxWorks 5909 EABI doesn't. */ 5910 if (!htab->is_vxworks) 5911 { 5912 s = bfd_get_section_by_name (abfd, ".dynamic"); 5913 if (s != NULL) 5914 { 5915 if (! bfd_set_section_flags (abfd, s, flags)) 5916 return FALSE; 5917 } 5918 } 5919 5920 /* We need to create .got section. */ 5921 if (! mips_elf_create_got_section (abfd, info, FALSE)) 5922 return FALSE; 5923 5924 if (! mips_elf_rel_dyn_section (info, TRUE)) 5925 return FALSE; 5926 5927 /* Create .stub section. */ 5928 if (bfd_get_section_by_name (abfd, 5929 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL) 5930 { 5931 s = bfd_make_section_with_flags (abfd, 5932 MIPS_ELF_STUB_SECTION_NAME (abfd), 5933 flags | SEC_CODE); 5934 if (s == NULL 5935 || ! bfd_set_section_alignment (abfd, s, 5936 MIPS_ELF_LOG_FILE_ALIGN (abfd))) 5937 return FALSE; 5938 } 5939 5940 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none) 5941 && !info->shared 5942 && bfd_get_section_by_name (abfd, ".rld_map") == NULL) 5943 { 5944 s = bfd_make_section_with_flags (abfd, ".rld_map", 5945 flags &~ (flagword) SEC_READONLY); 5946 if (s == NULL 5947 || ! bfd_set_section_alignment (abfd, s, 5948 MIPS_ELF_LOG_FILE_ALIGN (abfd))) 5949 return FALSE; 5950 } 5951 5952 /* On IRIX5, we adjust add some additional symbols and change the 5953 alignments of several sections. There is no ABI documentation 5954 indicating that this is necessary on IRIX6, nor any evidence that 5955 the linker takes such action. */ 5956 if (IRIX_COMPAT (abfd) == ict_irix5) 5957 { 5958 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++) 5959 { 5960 bh = NULL; 5961 if (! (_bfd_generic_link_add_one_symbol 5962 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0, 5963 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 5964 return FALSE; 5965 5966 h = (struct elf_link_hash_entry *) bh; 5967 h->non_elf = 0; 5968 h->def_regular = 1; 5969 h->type = STT_SECTION; 5970 5971 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5972 return FALSE; 5973 } 5974 5975 /* We need to create a .compact_rel section. */ 5976 if (SGI_COMPAT (abfd)) 5977 { 5978 if (!mips_elf_create_compact_rel_section (abfd, info)) 5979 return FALSE; 5980 } 5981 5982 /* Change alignments of some sections. */ 5983 s = bfd_get_section_by_name (abfd, ".hash"); 5984 if (s != NULL) 5985 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 5986 s = bfd_get_section_by_name (abfd, ".dynsym"); 5987 if (s != NULL) 5988 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 5989 s = bfd_get_section_by_name (abfd, ".dynstr"); 5990 if (s != NULL) 5991 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 5992 s = bfd_get_section_by_name (abfd, ".reginfo"); 5993 if (s != NULL) 5994 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 5995 s = bfd_get_section_by_name (abfd, ".dynamic"); 5996 if (s != NULL) 5997 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd)); 5998 } 5999 6000 if (!info->shared) 6001 { 6002 const char *name; 6003 6004 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING"; 6005 bh = NULL; 6006 if (!(_bfd_generic_link_add_one_symbol 6007 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0, 6008 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 6009 return FALSE; 6010 6011 h = (struct elf_link_hash_entry *) bh; 6012 h->non_elf = 0; 6013 h->def_regular = 1; 6014 h->type = STT_SECTION; 6015 6016 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6017 return FALSE; 6018 6019 if (! mips_elf_hash_table (info)->use_rld_obj_head) 6020 { 6021 /* __rld_map is a four byte word located in the .data section 6022 and is filled in by the rtld to contain a pointer to 6023 the _r_debug structure. Its symbol value will be set in 6024 _bfd_mips_elf_finish_dynamic_symbol. */ 6025 s = bfd_get_section_by_name (abfd, ".rld_map"); 6026 BFD_ASSERT (s != NULL); 6027 6028 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP"; 6029 bh = NULL; 6030 if (!(_bfd_generic_link_add_one_symbol 6031 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE, 6032 get_elf_backend_data (abfd)->collect, &bh))) 6033 return FALSE; 6034 6035 h = (struct elf_link_hash_entry *) bh; 6036 h->non_elf = 0; 6037 h->def_regular = 1; 6038 h->type = STT_OBJECT; 6039 6040 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6041 return FALSE; 6042 } 6043 } 6044 6045 if (htab->is_vxworks) 6046 { 6047 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections. 6048 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */ 6049 if (!_bfd_elf_create_dynamic_sections (abfd, info)) 6050 return FALSE; 6051 6052 /* Cache the sections created above. */ 6053 htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss"); 6054 htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss"); 6055 htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt"); 6056 htab->splt = bfd_get_section_by_name (abfd, ".plt"); 6057 if (!htab->sdynbss 6058 || (!htab->srelbss && !info->shared) 6059 || !htab->srelplt 6060 || !htab->splt) 6061 abort (); 6062 6063 /* Do the usual VxWorks handling. */ 6064 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) 6065 return FALSE; 6066 6067 /* Work out the PLT sizes. */ 6068 if (info->shared) 6069 { 6070 htab->plt_header_size 6071 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry); 6072 htab->plt_entry_size 6073 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry); 6074 } 6075 else 6076 { 6077 htab->plt_header_size 6078 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry); 6079 htab->plt_entry_size 6080 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry); 6081 } 6082 } 6083 6084 return TRUE; 6085} 6086 6087/* Look through the relocs for a section during the first phase, and 6088 allocate space in the global offset table. */ 6089 6090bfd_boolean 6091_bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 6092 asection *sec, const Elf_Internal_Rela *relocs) 6093{ 6094 const char *name; 6095 bfd *dynobj; 6096 Elf_Internal_Shdr *symtab_hdr; 6097 struct elf_link_hash_entry **sym_hashes; 6098 struct mips_got_info *g; 6099 size_t extsymoff; 6100 const Elf_Internal_Rela *rel; 6101 const Elf_Internal_Rela *rel_end; 6102 asection *sgot; 6103 asection *sreloc; 6104 const struct elf_backend_data *bed; 6105 struct mips_elf_link_hash_table *htab; 6106 6107 if (info->relocatable) 6108 return TRUE; 6109 6110 htab = mips_elf_hash_table (info); 6111 dynobj = elf_hash_table (info)->dynobj; 6112 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 6113 sym_hashes = elf_sym_hashes (abfd); 6114 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info; 6115 6116 /* Check for the mips16 stub sections. */ 6117 6118 name = bfd_get_section_name (abfd, sec); 6119 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0) 6120 { 6121 unsigned long r_symndx; 6122 6123 /* Look at the relocation information to figure out which symbol 6124 this is for. */ 6125 6126 r_symndx = ELF_R_SYM (abfd, relocs->r_info); 6127 6128 if (r_symndx < extsymoff 6129 || sym_hashes[r_symndx - extsymoff] == NULL) 6130 { 6131 asection *o; 6132 6133 /* This stub is for a local symbol. This stub will only be 6134 needed if there is some relocation in this BFD, other 6135 than a 16 bit function call, which refers to this symbol. */ 6136 for (o = abfd->sections; o != NULL; o = o->next) 6137 { 6138 Elf_Internal_Rela *sec_relocs; 6139 const Elf_Internal_Rela *r, *rend; 6140 6141 /* We can ignore stub sections when looking for relocs. */ 6142 if ((o->flags & SEC_RELOC) == 0 6143 || o->reloc_count == 0 6144 || strncmp (bfd_get_section_name (abfd, o), FN_STUB, 6145 sizeof FN_STUB - 1) == 0 6146 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB, 6147 sizeof CALL_STUB - 1) == 0 6148 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB, 6149 sizeof CALL_FP_STUB - 1) == 0) 6150 continue; 6151 6152 sec_relocs 6153 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 6154 info->keep_memory); 6155 if (sec_relocs == NULL) 6156 return FALSE; 6157 6158 rend = sec_relocs + o->reloc_count; 6159 for (r = sec_relocs; r < rend; r++) 6160 if (ELF_R_SYM (abfd, r->r_info) == r_symndx 6161 && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26) 6162 break; 6163 6164 if (elf_section_data (o)->relocs != sec_relocs) 6165 free (sec_relocs); 6166 6167 if (r < rend) 6168 break; 6169 } 6170 6171 if (o == NULL) 6172 { 6173 /* There is no non-call reloc for this stub, so we do 6174 not need it. Since this function is called before 6175 the linker maps input sections to output sections, we 6176 can easily discard it by setting the SEC_EXCLUDE 6177 flag. */ 6178 sec->flags |= SEC_EXCLUDE; 6179 return TRUE; 6180 } 6181 6182 /* Record this stub in an array of local symbol stubs for 6183 this BFD. */ 6184 if (elf_tdata (abfd)->local_stubs == NULL) 6185 { 6186 unsigned long symcount; 6187 asection **n; 6188 bfd_size_type amt; 6189 6190 if (elf_bad_symtab (abfd)) 6191 symcount = NUM_SHDR_ENTRIES (symtab_hdr); 6192 else 6193 symcount = symtab_hdr->sh_info; 6194 amt = symcount * sizeof (asection *); 6195 n = bfd_zalloc (abfd, amt); 6196 if (n == NULL) 6197 return FALSE; 6198 elf_tdata (abfd)->local_stubs = n; 6199 } 6200 6201 elf_tdata (abfd)->local_stubs[r_symndx] = sec; 6202 6203 /* We don't need to set mips16_stubs_seen in this case. 6204 That flag is used to see whether we need to look through 6205 the global symbol table for stubs. We don't need to set 6206 it here, because we just have a local stub. */ 6207 } 6208 else 6209 { 6210 struct mips_elf_link_hash_entry *h; 6211 6212 h = ((struct mips_elf_link_hash_entry *) 6213 sym_hashes[r_symndx - extsymoff]); 6214 6215 while (h->root.root.type == bfd_link_hash_indirect 6216 || h->root.root.type == bfd_link_hash_warning) 6217 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 6218 6219 /* H is the symbol this stub is for. */ 6220 6221 h->fn_stub = sec; 6222 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE; 6223 } 6224 } 6225 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0 6226 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0) 6227 { 6228 unsigned long r_symndx; 6229 struct mips_elf_link_hash_entry *h; 6230 asection **loc; 6231 6232 /* Look at the relocation information to figure out which symbol 6233 this is for. */ 6234 6235 r_symndx = ELF_R_SYM (abfd, relocs->r_info); 6236 6237 if (r_symndx < extsymoff 6238 || sym_hashes[r_symndx - extsymoff] == NULL) 6239 { 6240 /* This stub was actually built for a static symbol defined 6241 in the same file. We assume that all static symbols in 6242 mips16 code are themselves mips16, so we can simply 6243 discard this stub. Since this function is called before 6244 the linker maps input sections to output sections, we can 6245 easily discard it by setting the SEC_EXCLUDE flag. */ 6246 sec->flags |= SEC_EXCLUDE; 6247 return TRUE; 6248 } 6249 6250 h = ((struct mips_elf_link_hash_entry *) 6251 sym_hashes[r_symndx - extsymoff]); 6252 6253 /* H is the symbol this stub is for. */ 6254 6255 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0) 6256 loc = &h->call_fp_stub; 6257 else 6258 loc = &h->call_stub; 6259 6260 /* If we already have an appropriate stub for this function, we 6261 don't need another one, so we can discard this one. Since 6262 this function is called before the linker maps input sections 6263 to output sections, we can easily discard it by setting the 6264 SEC_EXCLUDE flag. We can also discard this section if we 6265 happen to already know that this is a mips16 function; it is 6266 not necessary to check this here, as it is checked later, but 6267 it is slightly faster to check now. */ 6268 if (*loc != NULL || h->root.other == STO_MIPS16) 6269 { 6270 sec->flags |= SEC_EXCLUDE; 6271 return TRUE; 6272 } 6273 6274 *loc = sec; 6275 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE; 6276 } 6277 6278 if (dynobj == NULL) 6279 { 6280 sgot = NULL; 6281 g = NULL; 6282 } 6283 else 6284 { 6285 sgot = mips_elf_got_section (dynobj, FALSE); 6286 if (sgot == NULL) 6287 g = NULL; 6288 else 6289 { 6290 BFD_ASSERT (mips_elf_section_data (sgot) != NULL); 6291 g = mips_elf_section_data (sgot)->u.got_info; 6292 BFD_ASSERT (g != NULL); 6293 } 6294 } 6295 6296 sreloc = NULL; 6297 bed = get_elf_backend_data (abfd); 6298 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel; 6299 for (rel = relocs; rel < rel_end; ++rel) 6300 { 6301 unsigned long r_symndx; 6302 unsigned int r_type; 6303 struct elf_link_hash_entry *h; 6304 6305 r_symndx = ELF_R_SYM (abfd, rel->r_info); 6306 r_type = ELF_R_TYPE (abfd, rel->r_info); 6307 6308 if (r_symndx < extsymoff) 6309 h = NULL; 6310 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr)) 6311 { 6312 (*_bfd_error_handler) 6313 (_("%B: Malformed reloc detected for section %s"), 6314 abfd, name); 6315 bfd_set_error (bfd_error_bad_value); 6316 return FALSE; 6317 } 6318 else 6319 { 6320 h = sym_hashes[r_symndx - extsymoff]; 6321 6322 /* This may be an indirect symbol created because of a version. */ 6323 if (h != NULL) 6324 { 6325 while (h->root.type == bfd_link_hash_indirect) 6326 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6327 } 6328 } 6329 6330 /* Some relocs require a global offset table. */ 6331 if (dynobj == NULL || sgot == NULL) 6332 { 6333 switch (r_type) 6334 { 6335 case R_MIPS_GOT16: 6336 case R_MIPS_CALL16: 6337 case R_MIPS_CALL_HI16: 6338 case R_MIPS_CALL_LO16: 6339 case R_MIPS_GOT_HI16: 6340 case R_MIPS_GOT_LO16: 6341 case R_MIPS_GOT_PAGE: 6342 case R_MIPS_GOT_OFST: 6343 case R_MIPS_GOT_DISP: 6344 case R_MIPS_TLS_GOTTPREL: 6345 case R_MIPS_TLS_GD: 6346 case R_MIPS_TLS_LDM: 6347 if (dynobj == NULL) 6348 elf_hash_table (info)->dynobj = dynobj = abfd; 6349 if (! mips_elf_create_got_section (dynobj, info, FALSE)) 6350 return FALSE; 6351 g = mips_elf_got_info (dynobj, &sgot); 6352 if (htab->is_vxworks && !info->shared) 6353 { 6354 (*_bfd_error_handler) 6355 (_("%B: GOT reloc at 0x%lx not expected in executables"), 6356 abfd, (unsigned long) rel->r_offset); 6357 bfd_set_error (bfd_error_bad_value); 6358 return FALSE; 6359 } 6360 break; 6361 6362 case R_MIPS_32: 6363 case R_MIPS_REL32: 6364 case R_MIPS_64: 6365 /* In VxWorks executables, references to external symbols 6366 are handled using copy relocs or PLT stubs, so there's 6367 no need to add a dynamic relocation here. */ 6368 if (dynobj == NULL 6369 && (info->shared || (h != NULL && !htab->is_vxworks)) 6370 && (sec->flags & SEC_ALLOC) != 0) 6371 elf_hash_table (info)->dynobj = dynobj = abfd; 6372 break; 6373 6374 default: 6375 break; 6376 } 6377 } 6378 6379 if (h) 6380 { 6381 ((struct mips_elf_link_hash_entry *) h)->is_relocation_target = TRUE; 6382 6383 /* Relocations against the special VxWorks __GOTT_BASE__ and 6384 __GOTT_INDEX__ symbols must be left to the loader. Allocate 6385 room for them in .rela.dyn. */ 6386 if (is_gott_symbol (info, h)) 6387 { 6388 if (sreloc == NULL) 6389 { 6390 sreloc = mips_elf_rel_dyn_section (info, TRUE); 6391 if (sreloc == NULL) 6392 return FALSE; 6393 } 6394 mips_elf_allocate_dynamic_relocations (dynobj, info, 1); 6395 } 6396 } 6397 else if (r_type == R_MIPS_CALL_LO16 6398 || r_type == R_MIPS_GOT_LO16 6399 || r_type == R_MIPS_GOT_DISP 6400 || (r_type == R_MIPS_GOT16 && htab->is_vxworks)) 6401 { 6402 /* We may need a local GOT entry for this relocation. We 6403 don't count R_MIPS_GOT_PAGE because we can estimate the 6404 maximum number of pages needed by looking at the size of 6405 the segment. Similar comments apply to R_MIPS_GOT16 and 6406 R_MIPS_CALL16, except on VxWorks, where GOT relocations 6407 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or 6408 R_MIPS_CALL_HI16 because these are always followed by an 6409 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */ 6410 if (! mips_elf_record_local_got_symbol (abfd, r_symndx, 6411 rel->r_addend, g, 0)) 6412 return FALSE; 6413 } 6414 6415 switch (r_type) 6416 { 6417 case R_MIPS_CALL16: 6418 if (h == NULL) 6419 { 6420 (*_bfd_error_handler) 6421 (_("%B: CALL16 reloc at 0x%lx not against global symbol"), 6422 abfd, (unsigned long) rel->r_offset); 6423 bfd_set_error (bfd_error_bad_value); 6424 return FALSE; 6425 } 6426 /* Fall through. */ 6427 6428 case R_MIPS_CALL_HI16: 6429 case R_MIPS_CALL_LO16: 6430 if (h != NULL) 6431 { 6432 /* VxWorks call relocations point the function's .got.plt 6433 entry, which will be allocated by adjust_dynamic_symbol. 6434 Otherwise, this symbol requires a global GOT entry. */ 6435 if (!htab->is_vxworks 6436 && !mips_elf_record_global_got_symbol (h, abfd, info, g, 0)) 6437 return FALSE; 6438 6439 /* We need a stub, not a plt entry for the undefined 6440 function. But we record it as if it needs plt. See 6441 _bfd_elf_adjust_dynamic_symbol. */ 6442 h->needs_plt = 1; 6443 h->type = STT_FUNC; 6444 } 6445 break; 6446 6447 case R_MIPS_GOT_PAGE: 6448 /* If this is a global, overridable symbol, GOT_PAGE will 6449 decay to GOT_DISP, so we'll need a GOT entry for it. */ 6450 if (h == NULL) 6451 break; 6452 else 6453 { 6454 struct mips_elf_link_hash_entry *hmips = 6455 (struct mips_elf_link_hash_entry *) h; 6456 6457 while (hmips->root.root.type == bfd_link_hash_indirect 6458 || hmips->root.root.type == bfd_link_hash_warning) 6459 hmips = (struct mips_elf_link_hash_entry *) 6460 hmips->root.root.u.i.link; 6461 6462 if (hmips->root.def_regular 6463 && ! (info->shared && ! info->symbolic 6464 && ! hmips->root.forced_local)) 6465 break; 6466 } 6467 /* Fall through. */ 6468 6469 case R_MIPS_GOT16: 6470 case R_MIPS_GOT_HI16: 6471 case R_MIPS_GOT_LO16: 6472 case R_MIPS_GOT_DISP: 6473 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, 0)) 6474 return FALSE; 6475 break; 6476 6477 case R_MIPS_TLS_GOTTPREL: 6478 if (info->shared) 6479 info->flags |= DF_STATIC_TLS; 6480 /* Fall through */ 6481 6482 case R_MIPS_TLS_LDM: 6483 if (r_type == R_MIPS_TLS_LDM) 6484 { 6485 r_symndx = 0; 6486 h = NULL; 6487 } 6488 /* Fall through */ 6489 6490 case R_MIPS_TLS_GD: 6491 /* This symbol requires a global offset table entry, or two 6492 for TLS GD relocations. */ 6493 { 6494 unsigned char flag = (r_type == R_MIPS_TLS_GD 6495 ? GOT_TLS_GD 6496 : r_type == R_MIPS_TLS_LDM 6497 ? GOT_TLS_LDM 6498 : GOT_TLS_IE); 6499 if (h != NULL) 6500 { 6501 struct mips_elf_link_hash_entry *hmips = 6502 (struct mips_elf_link_hash_entry *) h; 6503 hmips->tls_type |= flag; 6504 6505 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, flag)) 6506 return FALSE; 6507 } 6508 else 6509 { 6510 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != 0); 6511 6512 if (! mips_elf_record_local_got_symbol (abfd, r_symndx, 6513 rel->r_addend, g, flag)) 6514 return FALSE; 6515 } 6516 } 6517 break; 6518 6519 case R_MIPS_32: 6520 case R_MIPS_REL32: 6521 case R_MIPS_64: 6522 /* In VxWorks executables, references to external symbols 6523 are handled using copy relocs or PLT stubs, so there's 6524 no need to add a .rela.dyn entry for this relocation. */ 6525 if ((info->shared || (h != NULL && !htab->is_vxworks)) 6526 && (sec->flags & SEC_ALLOC) != 0) 6527 { 6528 if (sreloc == NULL) 6529 { 6530 sreloc = mips_elf_rel_dyn_section (info, TRUE); 6531 if (sreloc == NULL) 6532 return FALSE; 6533 } 6534 if (info->shared) 6535 { 6536 /* When creating a shared object, we must copy these 6537 reloc types into the output file as R_MIPS_REL32 6538 relocs. Make room for this reloc in .rel(a).dyn. */ 6539 mips_elf_allocate_dynamic_relocations (dynobj, info, 1); 6540 if (MIPS_ELF_READONLY_SECTION (sec)) 6541 /* We tell the dynamic linker that there are 6542 relocations against the text segment. */ 6543 info->flags |= DF_TEXTREL; 6544 } 6545 else 6546 { 6547 struct mips_elf_link_hash_entry *hmips; 6548 6549 /* We only need to copy this reloc if the symbol is 6550 defined in a dynamic object. */ 6551 hmips = (struct mips_elf_link_hash_entry *) h; 6552 ++hmips->possibly_dynamic_relocs; 6553 if (MIPS_ELF_READONLY_SECTION (sec)) 6554 /* We need it to tell the dynamic linker if there 6555 are relocations against the text segment. */ 6556 hmips->readonly_reloc = TRUE; 6557 } 6558 6559 /* Even though we don't directly need a GOT entry for 6560 this symbol, a symbol must have a dynamic symbol 6561 table index greater that DT_MIPS_GOTSYM if there are 6562 dynamic relocations against it. This does not apply 6563 to VxWorks, which does not have the usual coupling 6564 between global GOT entries and .dynsym entries. */ 6565 if (h != NULL && !htab->is_vxworks) 6566 { 6567 if (dynobj == NULL) 6568 elf_hash_table (info)->dynobj = dynobj = abfd; 6569 if (! mips_elf_create_got_section (dynobj, info, TRUE)) 6570 return FALSE; 6571 g = mips_elf_got_info (dynobj, &sgot); 6572 if (! mips_elf_record_global_got_symbol (h, abfd, info, g, 0)) 6573 return FALSE; 6574 } 6575 } 6576 6577 if (SGI_COMPAT (abfd)) 6578 mips_elf_hash_table (info)->compact_rel_size += 6579 sizeof (Elf32_External_crinfo); 6580 break; 6581 6582 case R_MIPS_PC16: 6583 if (h) 6584 ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE; 6585 break; 6586 6587 case R_MIPS_26: 6588 if (h) 6589 ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE; 6590 /* Fall through. */ 6591 6592 case R_MIPS_GPREL16: 6593 case R_MIPS_LITERAL: 6594 case R_MIPS_GPREL32: 6595 if (SGI_COMPAT (abfd)) 6596 mips_elf_hash_table (info)->compact_rel_size += 6597 sizeof (Elf32_External_crinfo); 6598 break; 6599 6600 /* This relocation describes the C++ object vtable hierarchy. 6601 Reconstruct it for later use during GC. */ 6602 case R_MIPS_GNU_VTINHERIT: 6603 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 6604 return FALSE; 6605 break; 6606 6607 /* This relocation describes which C++ vtable entries are actually 6608 used. Record for later use during GC. */ 6609 case R_MIPS_GNU_VTENTRY: 6610 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 6611 return FALSE; 6612 break; 6613 6614 default: 6615 break; 6616 } 6617 6618 /* We must not create a stub for a symbol that has relocations 6619 related to taking the function's address. This doesn't apply to 6620 VxWorks, where CALL relocs refer to a .got.plt entry instead of 6621 a normal .got entry. */ 6622 if (!htab->is_vxworks && h != NULL) 6623 switch (r_type) 6624 { 6625 default: 6626 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE; 6627 break; 6628 case R_MIPS_CALL16: 6629 case R_MIPS_CALL_HI16: 6630 case R_MIPS_CALL_LO16: 6631 case R_MIPS_JALR: 6632 break; 6633 } 6634 6635 /* If this reloc is not a 16 bit call, and it has a global 6636 symbol, then we will need the fn_stub if there is one. 6637 References from a stub section do not count. */ 6638 if (h != NULL 6639 && r_type != R_MIPS16_26 6640 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB, 6641 sizeof FN_STUB - 1) != 0 6642 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB, 6643 sizeof CALL_STUB - 1) != 0 6644 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB, 6645 sizeof CALL_FP_STUB - 1) != 0) 6646 { 6647 struct mips_elf_link_hash_entry *mh; 6648 6649 mh = (struct mips_elf_link_hash_entry *) h; 6650 mh->need_fn_stub = TRUE; 6651 } 6652 } 6653 6654 return TRUE; 6655} 6656 6657bfd_boolean 6658_bfd_mips_relax_section (bfd *abfd, asection *sec, 6659 struct bfd_link_info *link_info, 6660 bfd_boolean *again) 6661{ 6662 Elf_Internal_Rela *internal_relocs; 6663 Elf_Internal_Rela *irel, *irelend; 6664 Elf_Internal_Shdr *symtab_hdr; 6665 bfd_byte *contents = NULL; 6666 size_t extsymoff; 6667 bfd_boolean changed_contents = FALSE; 6668 bfd_vma sec_start = sec->output_section->vma + sec->output_offset; 6669 Elf_Internal_Sym *isymbuf = NULL; 6670 6671 /* We are not currently changing any sizes, so only one pass. */ 6672 *again = FALSE; 6673 6674 if (link_info->relocatable) 6675 return TRUE; 6676 6677 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, 6678 link_info->keep_memory); 6679 if (internal_relocs == NULL) 6680 return TRUE; 6681 6682 irelend = internal_relocs + sec->reloc_count 6683 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel; 6684 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 6685 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info; 6686 6687 for (irel = internal_relocs; irel < irelend; irel++) 6688 { 6689 bfd_vma symval; 6690 bfd_signed_vma sym_offset; 6691 unsigned int r_type; 6692 unsigned long r_symndx; 6693 asection *sym_sec; 6694 unsigned long instruction; 6695 6696 /* Turn jalr into bgezal, and jr into beq, if they're marked 6697 with a JALR relocation, that indicate where they jump to. 6698 This saves some pipeline bubbles. */ 6699 r_type = ELF_R_TYPE (abfd, irel->r_info); 6700 if (r_type != R_MIPS_JALR) 6701 continue; 6702 6703 r_symndx = ELF_R_SYM (abfd, irel->r_info); 6704 /* Compute the address of the jump target. */ 6705 if (r_symndx >= extsymoff) 6706 { 6707 struct mips_elf_link_hash_entry *h 6708 = ((struct mips_elf_link_hash_entry *) 6709 elf_sym_hashes (abfd) [r_symndx - extsymoff]); 6710 6711 while (h->root.root.type == bfd_link_hash_indirect 6712 || h->root.root.type == bfd_link_hash_warning) 6713 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link; 6714 6715 /* If a symbol is undefined, or if it may be overridden, 6716 skip it. */ 6717 if (! ((h->root.root.type == bfd_link_hash_defined 6718 || h->root.root.type == bfd_link_hash_defweak) 6719 && h->root.root.u.def.section) 6720 || (link_info->shared && ! link_info->symbolic 6721 && !h->root.forced_local)) 6722 continue; 6723 6724 sym_sec = h->root.root.u.def.section; 6725 if (sym_sec->output_section) 6726 symval = (h->root.root.u.def.value 6727 + sym_sec->output_section->vma 6728 + sym_sec->output_offset); 6729 else 6730 symval = h->root.root.u.def.value; 6731 } 6732 else 6733 { 6734 Elf_Internal_Sym *isym; 6735 6736 /* Read this BFD's symbols if we haven't done so already. */ 6737 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 6738 { 6739 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 6740 if (isymbuf == NULL) 6741 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 6742 symtab_hdr->sh_info, 0, 6743 NULL, NULL, NULL); 6744 if (isymbuf == NULL) 6745 goto relax_return; 6746 } 6747 6748 isym = isymbuf + r_symndx; 6749 if (isym->st_shndx == SHN_UNDEF) 6750 continue; 6751 else if (isym->st_shndx == SHN_ABS) 6752 sym_sec = bfd_abs_section_ptr; 6753 else if (isym->st_shndx == SHN_COMMON) 6754 sym_sec = bfd_com_section_ptr; 6755 else 6756 sym_sec 6757 = bfd_section_from_elf_index (abfd, isym->st_shndx); 6758 symval = isym->st_value 6759 + sym_sec->output_section->vma 6760 + sym_sec->output_offset; 6761 } 6762 6763 /* Compute branch offset, from delay slot of the jump to the 6764 branch target. */ 6765 sym_offset = (symval + irel->r_addend) 6766 - (sec_start + irel->r_offset + 4); 6767 6768 /* Branch offset must be properly aligned. */ 6769 if ((sym_offset & 3) != 0) 6770 continue; 6771 6772 sym_offset >>= 2; 6773 6774 /* Check that it's in range. */ 6775 if (sym_offset < -0x8000 || sym_offset >= 0x8000) 6776 continue; 6777 6778 /* Get the section contents if we haven't done so already. */ 6779 if (contents == NULL) 6780 { 6781 /* Get cached copy if it exists. */ 6782 if (elf_section_data (sec)->this_hdr.contents != NULL) 6783 contents = elf_section_data (sec)->this_hdr.contents; 6784 else 6785 { 6786 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 6787 goto relax_return; 6788 } 6789 } 6790 6791 instruction = bfd_get_32 (abfd, contents + irel->r_offset); 6792 6793 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */ 6794 if ((instruction & 0xfc1fffff) == 0x0000f809) 6795 instruction = 0x04110000; 6796 /* If it was jr <reg>, turn it into b <target>. */ 6797 else if ((instruction & 0xfc1fffff) == 0x00000008) 6798 instruction = 0x10000000; 6799 else 6800 continue; 6801 6802 instruction |= (sym_offset & 0xffff); 6803 bfd_put_32 (abfd, instruction, contents + irel->r_offset); 6804 changed_contents = TRUE; 6805 } 6806 6807 if (contents != NULL 6808 && elf_section_data (sec)->this_hdr.contents != contents) 6809 { 6810 if (!changed_contents && !link_info->keep_memory) 6811 free (contents); 6812 else 6813 { 6814 /* Cache the section contents for elf_link_input_bfd. */ 6815 elf_section_data (sec)->this_hdr.contents = contents; 6816 } 6817 } 6818 return TRUE; 6819 6820 relax_return: 6821 if (contents != NULL 6822 && elf_section_data (sec)->this_hdr.contents != contents) 6823 free (contents); 6824 return FALSE; 6825} 6826 6827/* Adjust a symbol defined by a dynamic object and referenced by a 6828 regular object. The current definition is in some section of the 6829 dynamic object, but we're not including those sections. We have to 6830 change the definition to something the rest of the link can 6831 understand. */ 6832 6833bfd_boolean 6834_bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 6835 struct elf_link_hash_entry *h) 6836{ 6837 bfd *dynobj; 6838 struct mips_elf_link_hash_entry *hmips; 6839 asection *s; 6840 struct mips_elf_link_hash_table *htab; 6841 6842 htab = mips_elf_hash_table (info); 6843 dynobj = elf_hash_table (info)->dynobj; 6844 6845 /* Make sure we know what is going on here. */ 6846 BFD_ASSERT (dynobj != NULL 6847 && (h->needs_plt 6848 || h->u.weakdef != NULL 6849 || (h->def_dynamic 6850 && h->ref_regular 6851 && !h->def_regular))); 6852 6853 /* If this symbol is defined in a dynamic object, we need to copy 6854 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output 6855 file. */ 6856 hmips = (struct mips_elf_link_hash_entry *) h; 6857 if (! info->relocatable 6858 && hmips->possibly_dynamic_relocs != 0 6859 && (h->root.type == bfd_link_hash_defweak 6860 || !h->def_regular)) 6861 { 6862 mips_elf_allocate_dynamic_relocations 6863 (dynobj, info, hmips->possibly_dynamic_relocs); 6864 if (hmips->readonly_reloc) 6865 /* We tell the dynamic linker that there are relocations 6866 against the text segment. */ 6867 info->flags |= DF_TEXTREL; 6868 } 6869 6870 /* For a function, create a stub, if allowed. */ 6871 if (! hmips->no_fn_stub 6872 && h->needs_plt) 6873 { 6874 if (! elf_hash_table (info)->dynamic_sections_created) 6875 return TRUE; 6876 6877 /* If this symbol is not defined in a regular file, then set 6878 the symbol to the stub location. This is required to make 6879 function pointers compare as equal between the normal 6880 executable and the shared library. */ 6881 if (!h->def_regular) 6882 { 6883 /* We need .stub section. */ 6884 s = bfd_get_section_by_name (dynobj, 6885 MIPS_ELF_STUB_SECTION_NAME (dynobj)); 6886 BFD_ASSERT (s != NULL); 6887 6888 h->root.u.def.section = s; 6889 h->root.u.def.value = s->size; 6890 6891 /* XXX Write this stub address somewhere. */ 6892 h->plt.offset = s->size; 6893 6894 /* Make room for this stub code. */ 6895 s->size += htab->function_stub_size; 6896 6897 /* The last half word of the stub will be filled with the index 6898 of this symbol in .dynsym section. */ 6899 return TRUE; 6900 } 6901 } 6902 else if ((h->type == STT_FUNC) 6903 && !h->needs_plt) 6904 { 6905 /* This will set the entry for this symbol in the GOT to 0, and 6906 the dynamic linker will take care of this. */ 6907 h->root.u.def.value = 0; 6908 return TRUE; 6909 } 6910 6911 /* If this is a weak symbol, and there is a real definition, the 6912 processor independent code will have arranged for us to see the 6913 real definition first, and we can just use the same value. */ 6914 if (h->u.weakdef != NULL) 6915 { 6916 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 6917 || h->u.weakdef->root.type == bfd_link_hash_defweak); 6918 h->root.u.def.section = h->u.weakdef->root.u.def.section; 6919 h->root.u.def.value = h->u.weakdef->root.u.def.value; 6920 return TRUE; 6921 } 6922 6923 /* This is a reference to a symbol defined by a dynamic object which 6924 is not a function. */ 6925 6926 return TRUE; 6927} 6928 6929/* Likewise, for VxWorks. */ 6930 6931bfd_boolean 6932_bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info *info, 6933 struct elf_link_hash_entry *h) 6934{ 6935 bfd *dynobj; 6936 struct mips_elf_link_hash_entry *hmips; 6937 struct mips_elf_link_hash_table *htab; 6938 unsigned int power_of_two; 6939 6940 htab = mips_elf_hash_table (info); 6941 dynobj = elf_hash_table (info)->dynobj; 6942 hmips = (struct mips_elf_link_hash_entry *) h; 6943 6944 /* Make sure we know what is going on here. */ 6945 BFD_ASSERT (dynobj != NULL 6946 && (h->needs_plt 6947 || h->needs_copy 6948 || h->u.weakdef != NULL 6949 || (h->def_dynamic 6950 && h->ref_regular 6951 && !h->def_regular))); 6952 6953 /* If the symbol is defined by a dynamic object, we need a PLT stub if 6954 either (a) we want to branch to the symbol or (b) we're linking an 6955 executable that needs a canonical function address. In the latter 6956 case, the canonical address will be the address of the executable's 6957 load stub. */ 6958 if ((hmips->is_branch_target 6959 || (!info->shared 6960 && h->type == STT_FUNC 6961 && hmips->is_relocation_target)) 6962 && h->def_dynamic 6963 && h->ref_regular 6964 && !h->def_regular 6965 && !h->forced_local) 6966 h->needs_plt = 1; 6967 6968 /* Locally-binding symbols do not need a PLT stub; we can refer to 6969 the functions directly. */ 6970 else if (h->needs_plt 6971 && (SYMBOL_CALLS_LOCAL (info, h) 6972 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 6973 && h->root.type == bfd_link_hash_undefweak))) 6974 { 6975 h->needs_plt = 0; 6976 return TRUE; 6977 } 6978 6979 if (h->needs_plt) 6980 { 6981 /* If this is the first symbol to need a PLT entry, allocate room 6982 for the header, and for the header's .rela.plt.unloaded entries. */ 6983 if (htab->splt->size == 0) 6984 { 6985 htab->splt->size += htab->plt_header_size; 6986 if (!info->shared) 6987 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela); 6988 } 6989 6990 /* Assign the next .plt entry to this symbol. */ 6991 h->plt.offset = htab->splt->size; 6992 htab->splt->size += htab->plt_entry_size; 6993 6994 /* If the output file has no definition of the symbol, set the 6995 symbol's value to the address of the stub. For executables, 6996 point at the PLT load stub rather than the lazy resolution stub; 6997 this stub will become the canonical function address. */ 6998 if (!h->def_regular) 6999 { 7000 h->root.u.def.section = htab->splt; 7001 h->root.u.def.value = h->plt.offset; 7002 if (!info->shared) 7003 h->root.u.def.value += 8; 7004 } 7005 7006 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */ 7007 htab->sgotplt->size += 4; 7008 htab->srelplt->size += sizeof (Elf32_External_Rela); 7009 7010 /* Make room for the .rela.plt.unloaded relocations. */ 7011 if (!info->shared) 7012 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela); 7013 7014 return TRUE; 7015 } 7016 7017 /* If a function symbol is defined by a dynamic object, and we do not 7018 need a PLT stub for it, the symbol's value should be zero. */ 7019 if (h->type == STT_FUNC 7020 && h->def_dynamic 7021 && h->ref_regular 7022 && !h->def_regular) 7023 { 7024 h->root.u.def.value = 0; 7025 return TRUE; 7026 } 7027 7028 /* If this is a weak symbol, and there is a real definition, the 7029 processor independent code will have arranged for us to see the 7030 real definition first, and we can just use the same value. */ 7031 if (h->u.weakdef != NULL) 7032 { 7033 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 7034 || h->u.weakdef->root.type == bfd_link_hash_defweak); 7035 h->root.u.def.section = h->u.weakdef->root.u.def.section; 7036 h->root.u.def.value = h->u.weakdef->root.u.def.value; 7037 return TRUE; 7038 } 7039 7040 /* This is a reference to a symbol defined by a dynamic object which 7041 is not a function. */ 7042 if (info->shared) 7043 return TRUE; 7044 7045 /* We must allocate the symbol in our .dynbss section, which will 7046 become part of the .bss section of the executable. There will be 7047 an entry for this symbol in the .dynsym section. The dynamic 7048 object will contain position independent code, so all references 7049 from the dynamic object to this symbol will go through the global 7050 offset table. The dynamic linker will use the .dynsym entry to 7051 determine the address it must put in the global offset table, so 7052 both the dynamic object and the regular object will refer to the 7053 same memory location for the variable. */ 7054 7055 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 7056 { 7057 htab->srelbss->size += sizeof (Elf32_External_Rela); 7058 h->needs_copy = 1; 7059 } 7060 7061 /* We need to figure out the alignment required for this symbol. */ 7062 power_of_two = bfd_log2 (h->size); 7063 if (power_of_two > 4) 7064 power_of_two = 4; 7065 7066 /* Apply the required alignment. */ 7067 htab->sdynbss->size = BFD_ALIGN (htab->sdynbss->size, 7068 (bfd_size_type) 1 << power_of_two); 7069 if (power_of_two > bfd_get_section_alignment (dynobj, htab->sdynbss) 7070 && !bfd_set_section_alignment (dynobj, htab->sdynbss, power_of_two)) 7071 return FALSE; 7072 7073 /* Define the symbol as being at this point in the section. */ 7074 h->root.u.def.section = htab->sdynbss; 7075 h->root.u.def.value = htab->sdynbss->size; 7076 7077 /* Increment the section size to make room for the symbol. */ 7078 htab->sdynbss->size += h->size; 7079 7080 return TRUE; 7081} 7082 7083/* Return the number of dynamic section symbols required by OUTPUT_BFD. 7084 The number might be exact or a worst-case estimate, depending on how 7085 much information is available to elf_backend_omit_section_dynsym at 7086 the current linking stage. */ 7087 7088static bfd_size_type 7089count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info) 7090{ 7091 bfd_size_type count; 7092 7093 count = 0; 7094 if (info->shared) 7095 { 7096 asection *p; 7097 const struct elf_backend_data *bed; 7098 7099 bed = get_elf_backend_data (output_bfd); 7100 for (p = output_bfd->sections; p ; p = p->next) 7101 if ((p->flags & SEC_EXCLUDE) == 0 7102 && (p->flags & SEC_ALLOC) != 0 7103 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p)) 7104 ++count; 7105 } 7106 return count; 7107} 7108 7109/* This function is called after all the input files have been read, 7110 and the input sections have been assigned to output sections. We 7111 check for any mips16 stub sections that we can discard. */ 7112 7113bfd_boolean 7114_bfd_mips_elf_always_size_sections (bfd *output_bfd, 7115 struct bfd_link_info *info) 7116{ 7117 asection *ri; 7118 7119 bfd *dynobj; 7120 asection *s; 7121 struct mips_got_info *g; 7122 int i; 7123 bfd_size_type loadable_size = 0; 7124 bfd_size_type local_gotno; 7125 bfd_size_type dynsymcount; 7126 bfd *sub; 7127 struct mips_elf_count_tls_arg count_tls_arg; 7128 struct mips_elf_link_hash_table *htab; 7129 7130 htab = mips_elf_hash_table (info); 7131 7132 /* The .reginfo section has a fixed size. */ 7133 ri = bfd_get_section_by_name (output_bfd, ".reginfo"); 7134 if (ri != NULL) 7135 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo)); 7136 7137 if (! (info->relocatable 7138 || ! mips_elf_hash_table (info)->mips16_stubs_seen)) 7139 mips_elf_link_hash_traverse (mips_elf_hash_table (info), 7140 mips_elf_check_mips16_stubs, NULL); 7141 7142 dynobj = elf_hash_table (info)->dynobj; 7143 if (dynobj == NULL) 7144 /* Relocatable links don't have it. */ 7145 return TRUE; 7146 7147 g = mips_elf_got_info (dynobj, &s); 7148 if (s == NULL) 7149 return TRUE; 7150 7151 /* Calculate the total loadable size of the output. That 7152 will give us the maximum number of GOT_PAGE entries 7153 required. */ 7154 for (sub = info->input_bfds; sub; sub = sub->link_next) 7155 { 7156 asection *subsection; 7157 7158 for (subsection = sub->sections; 7159 subsection; 7160 subsection = subsection->next) 7161 { 7162 if ((subsection->flags & SEC_ALLOC) == 0) 7163 continue; 7164 loadable_size += ((subsection->size + 0xf) 7165 &~ (bfd_size_type) 0xf); 7166 } 7167 } 7168 7169 /* There has to be a global GOT entry for every symbol with 7170 a dynamic symbol table index of DT_MIPS_GOTSYM or 7171 higher. Therefore, it make sense to put those symbols 7172 that need GOT entries at the end of the symbol table. We 7173 do that here. */ 7174 if (! mips_elf_sort_hash_table (info, 1)) 7175 return FALSE; 7176 7177 if (g->global_gotsym != NULL) 7178 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx; 7179 else 7180 /* If there are no global symbols, or none requiring 7181 relocations, then GLOBAL_GOTSYM will be NULL. */ 7182 i = 0; 7183 7184 /* Get a worst-case estimate of the number of dynamic symbols needed. 7185 At this point, dynsymcount does not account for section symbols 7186 and count_section_dynsyms may overestimate the number that will 7187 be needed. */ 7188 dynsymcount = (elf_hash_table (info)->dynsymcount 7189 + count_section_dynsyms (output_bfd, info)); 7190 7191 /* Determine the size of one stub entry. */ 7192 htab->function_stub_size = (dynsymcount > 0x10000 7193 ? MIPS_FUNCTION_STUB_BIG_SIZE 7194 : MIPS_FUNCTION_STUB_NORMAL_SIZE); 7195 7196 /* In the worst case, we'll get one stub per dynamic symbol, plus 7197 one to account for the dummy entry at the end required by IRIX 7198 rld. */ 7199 loadable_size += htab->function_stub_size * (i + 1); 7200 7201 if (htab->is_vxworks) 7202 /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16 7203 relocations against local symbols evaluate to "G", and the EABI does 7204 not include R_MIPS_GOT_PAGE. */ 7205 local_gotno = 0; 7206 else 7207 /* Assume there are two loadable segments consisting of contiguous 7208 sections. Is 5 enough? */ 7209 local_gotno = (loadable_size >> 16) + 5; 7210 7211 g->local_gotno += local_gotno; 7212 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd); 7213 7214 g->global_gotno = i; 7215 s->size += i * MIPS_ELF_GOT_SIZE (output_bfd); 7216 7217 /* We need to calculate tls_gotno for global symbols at this point 7218 instead of building it up earlier, to avoid doublecounting 7219 entries for one global symbol from multiple input files. */ 7220 count_tls_arg.info = info; 7221 count_tls_arg.needed = 0; 7222 elf_link_hash_traverse (elf_hash_table (info), 7223 mips_elf_count_global_tls_entries, 7224 &count_tls_arg); 7225 g->tls_gotno += count_tls_arg.needed; 7226 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd); 7227 7228 mips_elf_resolve_final_got_entries (g); 7229 7230 /* VxWorks does not support multiple GOTs. It initializes $gp to 7231 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the 7232 dynamic loader. */ 7233 if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info)) 7234 { 7235 if (! mips_elf_multi_got (output_bfd, info, g, s, local_gotno)) 7236 return FALSE; 7237 } 7238 else 7239 { 7240 /* Set up TLS entries for the first GOT. */ 7241 g->tls_assigned_gotno = g->global_gotno + g->local_gotno; 7242 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g); 7243 } 7244 7245 return TRUE; 7246} 7247 7248/* Set the sizes of the dynamic sections. */ 7249 7250bfd_boolean 7251_bfd_mips_elf_size_dynamic_sections (bfd *output_bfd, 7252 struct bfd_link_info *info) 7253{ 7254 bfd *dynobj; 7255 asection *s, *sreldyn; 7256 bfd_boolean reltext; 7257 struct mips_elf_link_hash_table *htab; 7258 7259 htab = mips_elf_hash_table (info); 7260 dynobj = elf_hash_table (info)->dynobj; 7261 BFD_ASSERT (dynobj != NULL); 7262 7263 if (elf_hash_table (info)->dynamic_sections_created) 7264 { 7265 /* Set the contents of the .interp section to the interpreter. */ 7266 if (info->executable) 7267 { 7268 s = bfd_get_section_by_name (dynobj, ".interp"); 7269 BFD_ASSERT (s != NULL); 7270 s->size 7271 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1; 7272 s->contents 7273 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd); 7274 } 7275 } 7276 7277 /* The check_relocs and adjust_dynamic_symbol entry points have 7278 determined the sizes of the various dynamic sections. Allocate 7279 memory for them. */ 7280 reltext = FALSE; 7281 sreldyn = NULL; 7282 for (s = dynobj->sections; s != NULL; s = s->next) 7283 { 7284 const char *name; 7285 7286 /* It's OK to base decisions on the section name, because none 7287 of the dynobj section names depend upon the input files. */ 7288 name = bfd_get_section_name (dynobj, s); 7289 7290 if ((s->flags & SEC_LINKER_CREATED) == 0) 7291 continue; 7292 7293 if (strncmp (name, ".rel", 4) == 0) 7294 { 7295 if (s->size != 0) 7296 { 7297 const char *outname; 7298 asection *target; 7299 7300 /* If this relocation section applies to a read only 7301 section, then we probably need a DT_TEXTREL entry. 7302 If the relocation section is .rel(a).dyn, we always 7303 assert a DT_TEXTREL entry rather than testing whether 7304 there exists a relocation to a read only section or 7305 not. */ 7306 outname = bfd_get_section_name (output_bfd, 7307 s->output_section); 7308 target = bfd_get_section_by_name (output_bfd, outname + 4); 7309 if ((target != NULL 7310 && (target->flags & SEC_READONLY) != 0 7311 && (target->flags & SEC_ALLOC) != 0) 7312 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0) 7313 reltext = TRUE; 7314 7315 /* We use the reloc_count field as a counter if we need 7316 to copy relocs into the output file. */ 7317 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0) 7318 s->reloc_count = 0; 7319 7320 /* If combreloc is enabled, elf_link_sort_relocs() will 7321 sort relocations, but in a different way than we do, 7322 and before we're done creating relocations. Also, it 7323 will move them around between input sections' 7324 relocation's contents, so our sorting would be 7325 broken, so don't let it run. */ 7326 info->combreloc = 0; 7327 } 7328 } 7329 else if (htab->is_vxworks && strcmp (name, ".got") == 0) 7330 { 7331 /* Executables do not need a GOT. */ 7332 if (info->shared) 7333 { 7334 /* Allocate relocations for all but the reserved entries. */ 7335 struct mips_got_info *g; 7336 unsigned int count; 7337 7338 g = mips_elf_got_info (dynobj, NULL); 7339 count = (g->global_gotno 7340 + g->local_gotno 7341 - MIPS_RESERVED_GOTNO (info)); 7342 mips_elf_allocate_dynamic_relocations (dynobj, info, count); 7343 } 7344 } 7345 else if (!htab->is_vxworks && strncmp (name, ".got", 4) == 0) 7346 { 7347 /* _bfd_mips_elf_always_size_sections() has already done 7348 most of the work, but some symbols may have been mapped 7349 to versions that we must now resolve in the got_entries 7350 hash tables. */ 7351 struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL); 7352 struct mips_got_info *g = gg; 7353 struct mips_elf_set_global_got_offset_arg set_got_offset_arg; 7354 unsigned int needed_relocs = 0; 7355 7356 if (gg->next) 7357 { 7358 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd); 7359 set_got_offset_arg.info = info; 7360 7361 /* NOTE 2005-02-03: How can this call, or the next, ever 7362 find any indirect entries to resolve? They were all 7363 resolved in mips_elf_multi_got. */ 7364 mips_elf_resolve_final_got_entries (gg); 7365 for (g = gg->next; g && g->next != gg; g = g->next) 7366 { 7367 unsigned int save_assign; 7368 7369 mips_elf_resolve_final_got_entries (g); 7370 7371 /* Assign offsets to global GOT entries. */ 7372 save_assign = g->assigned_gotno; 7373 g->assigned_gotno = g->local_gotno; 7374 set_got_offset_arg.g = g; 7375 set_got_offset_arg.needed_relocs = 0; 7376 htab_traverse (g->got_entries, 7377 mips_elf_set_global_got_offset, 7378 &set_got_offset_arg); 7379 needed_relocs += set_got_offset_arg.needed_relocs; 7380 BFD_ASSERT (g->assigned_gotno - g->local_gotno 7381 <= g->global_gotno); 7382 7383 g->assigned_gotno = save_assign; 7384 if (info->shared) 7385 { 7386 needed_relocs += g->local_gotno - g->assigned_gotno; 7387 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno 7388 + g->next->global_gotno 7389 + g->next->tls_gotno 7390 + MIPS_RESERVED_GOTNO (info)); 7391 } 7392 } 7393 } 7394 else 7395 { 7396 struct mips_elf_count_tls_arg arg; 7397 arg.info = info; 7398 arg.needed = 0; 7399 7400 htab_traverse (gg->got_entries, mips_elf_count_local_tls_relocs, 7401 &arg); 7402 elf_link_hash_traverse (elf_hash_table (info), 7403 mips_elf_count_global_tls_relocs, 7404 &arg); 7405 7406 needed_relocs += arg.needed; 7407 } 7408 7409 if (needed_relocs) 7410 mips_elf_allocate_dynamic_relocations (dynobj, info, 7411 needed_relocs); 7412 } 7413 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0) 7414 { 7415 /* IRIX rld assumes that the function stub isn't at the end 7416 of .text section. So put a dummy. XXX */ 7417 s->size += htab->function_stub_size; 7418 } 7419 else if (! info->shared 7420 && ! mips_elf_hash_table (info)->use_rld_obj_head 7421 && strncmp (name, ".rld_map", 8) == 0) 7422 { 7423 /* We add a room for __rld_map. It will be filled in by the 7424 rtld to contain a pointer to the _r_debug structure. */ 7425 s->size += 4; 7426 } 7427 else if (SGI_COMPAT (output_bfd) 7428 && strncmp (name, ".compact_rel", 12) == 0) 7429 s->size += mips_elf_hash_table (info)->compact_rel_size; 7430 else if (strncmp (name, ".init", 5) != 0 7431 && s != htab->sgotplt 7432 && s != htab->splt) 7433 { 7434 /* It's not one of our sections, so don't allocate space. */ 7435 continue; 7436 } 7437 7438 if (s->size == 0) 7439 { 7440 s->flags |= SEC_EXCLUDE; 7441 continue; 7442 } 7443 7444 if ((s->flags & SEC_HAS_CONTENTS) == 0) 7445 continue; 7446 7447 /* Allocate memory for this section last, since we may increase its 7448 size above. */ 7449 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) == 0) 7450 { 7451 sreldyn = s; 7452 continue; 7453 } 7454 7455 /* Allocate memory for the section contents. */ 7456 s->contents = bfd_zalloc (dynobj, s->size); 7457 if (s->contents == NULL) 7458 { 7459 bfd_set_error (bfd_error_no_memory); 7460 return FALSE; 7461 } 7462 } 7463 7464 /* Allocate memory for the .rel(a).dyn section. */ 7465 if (sreldyn != NULL) 7466 { 7467 sreldyn->contents = bfd_zalloc (dynobj, sreldyn->size); 7468 if (sreldyn->contents == NULL) 7469 { 7470 bfd_set_error (bfd_error_no_memory); 7471 return FALSE; 7472 } 7473 } 7474 7475 if (elf_hash_table (info)->dynamic_sections_created) 7476 { 7477 /* Add some entries to the .dynamic section. We fill in the 7478 values later, in _bfd_mips_elf_finish_dynamic_sections, but we 7479 must add the entries now so that we get the correct size for 7480 the .dynamic section. The DT_DEBUG entry is filled in by the 7481 dynamic linker and used by the debugger. */ 7482 if (! info->shared) 7483 { 7484 /* SGI object has the equivalence of DT_DEBUG in the 7485 DT_MIPS_RLD_MAP entry. */ 7486 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0)) 7487 return FALSE; 7488 if (!SGI_COMPAT (output_bfd)) 7489 { 7490 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) 7491 return FALSE; 7492 } 7493 } 7494 else 7495 { 7496 /* Shared libraries on traditional mips have DT_DEBUG. */ 7497 if (!SGI_COMPAT (output_bfd)) 7498 { 7499 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) 7500 return FALSE; 7501 } 7502 } 7503 7504 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks)) 7505 info->flags |= DF_TEXTREL; 7506 7507 if ((info->flags & DF_TEXTREL) != 0) 7508 { 7509 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0)) 7510 return FALSE; 7511 7512 /* Clear the DF_TEXTREL flag. It will be set again if we 7513 write out an actual text relocation; we may not, because 7514 at this point we do not know whether e.g. any .eh_frame 7515 absolute relocations have been converted to PC-relative. */ 7516 info->flags &= ~DF_TEXTREL; 7517 } 7518 7519 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0)) 7520 return FALSE; 7521 7522 if (htab->is_vxworks) 7523 { 7524 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not 7525 use any of the DT_MIPS_* tags. */ 7526 if (mips_elf_rel_dyn_section (info, FALSE)) 7527 { 7528 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0)) 7529 return FALSE; 7530 7531 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0)) 7532 return FALSE; 7533 7534 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0)) 7535 return FALSE; 7536 } 7537 if (htab->splt->size > 0) 7538 { 7539 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0)) 7540 return FALSE; 7541 7542 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0)) 7543 return FALSE; 7544 7545 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0)) 7546 return FALSE; 7547 } 7548 } 7549 else 7550 { 7551 if (mips_elf_rel_dyn_section (info, FALSE)) 7552 { 7553 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0)) 7554 return FALSE; 7555 7556 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0)) 7557 return FALSE; 7558 7559 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0)) 7560 return FALSE; 7561 } 7562 7563 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0)) 7564 return FALSE; 7565 7566 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0)) 7567 return FALSE; 7568 7569 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0)) 7570 return FALSE; 7571 7572 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0)) 7573 return FALSE; 7574 7575 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0)) 7576 return FALSE; 7577 7578 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0)) 7579 return FALSE; 7580 7581 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0)) 7582 return FALSE; 7583 7584 if (IRIX_COMPAT (dynobj) == ict_irix5 7585 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0)) 7586 return FALSE; 7587 7588 if (IRIX_COMPAT (dynobj) == ict_irix6 7589 && (bfd_get_section_by_name 7590 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj))) 7591 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0)) 7592 return FALSE; 7593 } 7594 } 7595 7596 return TRUE; 7597} 7598 7599/* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD. 7600 Adjust its R_ADDEND field so that it is correct for the output file. 7601 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols 7602 and sections respectively; both use symbol indexes. */ 7603 7604static void 7605mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info, 7606 bfd *input_bfd, Elf_Internal_Sym *local_syms, 7607 asection **local_sections, Elf_Internal_Rela *rel) 7608{ 7609 unsigned int r_type, r_symndx; 7610 Elf_Internal_Sym *sym; 7611 asection *sec; 7612 7613 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE)) 7614 { 7615 r_type = ELF_R_TYPE (output_bfd, rel->r_info); 7616 if (r_type == R_MIPS16_GPREL 7617 || r_type == R_MIPS_GPREL16 7618 || r_type == R_MIPS_GPREL32 7619 || r_type == R_MIPS_LITERAL) 7620 { 7621 rel->r_addend += _bfd_get_gp_value (input_bfd); 7622 rel->r_addend -= _bfd_get_gp_value (output_bfd); 7623 } 7624 7625 r_symndx = ELF_R_SYM (output_bfd, rel->r_info); 7626 sym = local_syms + r_symndx; 7627 7628 /* Adjust REL's addend to account for section merging. */ 7629 if (!info->relocatable) 7630 { 7631 sec = local_sections[r_symndx]; 7632 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 7633 } 7634 7635 /* This would normally be done by the rela_normal code in elflink.c. */ 7636 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 7637 rel->r_addend += local_sections[r_symndx]->output_offset; 7638 } 7639} 7640 7641/* Relocate a MIPS ELF section. */ 7642 7643bfd_boolean 7644_bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 7645 bfd *input_bfd, asection *input_section, 7646 bfd_byte *contents, Elf_Internal_Rela *relocs, 7647 Elf_Internal_Sym *local_syms, 7648 asection **local_sections) 7649{ 7650 Elf_Internal_Rela *rel; 7651 const Elf_Internal_Rela *relend; 7652 bfd_vma addend = 0; 7653 bfd_boolean use_saved_addend_p = FALSE; 7654 const struct elf_backend_data *bed; 7655 7656 bed = get_elf_backend_data (output_bfd); 7657 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel; 7658 for (rel = relocs; rel < relend; ++rel) 7659 { 7660 const char *name; 7661 bfd_vma value = 0; 7662 reloc_howto_type *howto; 7663 bfd_boolean require_jalx; 7664 /* TRUE if the relocation is a RELA relocation, rather than a 7665 REL relocation. */ 7666 bfd_boolean rela_relocation_p = TRUE; 7667 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info); 7668 const char *msg; 7669 7670 /* Find the relocation howto for this relocation. */ 7671 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd)) 7672 { 7673 /* Some 32-bit code uses R_MIPS_64. In particular, people use 7674 64-bit code, but make sure all their addresses are in the 7675 lowermost or uppermost 32-bit section of the 64-bit address 7676 space. Thus, when they use an R_MIPS_64 they mean what is 7677 usually meant by R_MIPS_32, with the exception that the 7678 stored value is sign-extended to 64 bits. */ 7679 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE); 7680 7681 /* On big-endian systems, we need to lie about the position 7682 of the reloc. */ 7683 if (bfd_big_endian (input_bfd)) 7684 rel->r_offset += 4; 7685 } 7686 else 7687 /* NewABI defaults to RELA relocations. */ 7688 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, 7689 NEWABI_P (input_bfd) 7690 && (MIPS_RELOC_RELA_P 7691 (input_bfd, input_section, 7692 rel - relocs))); 7693 7694 if (!use_saved_addend_p) 7695 { 7696 Elf_Internal_Shdr *rel_hdr; 7697 7698 /* If these relocations were originally of the REL variety, 7699 we must pull the addend out of the field that will be 7700 relocated. Otherwise, we simply use the contents of the 7701 RELA relocation. To determine which flavor or relocation 7702 this is, we depend on the fact that the INPUT_SECTION's 7703 REL_HDR is read before its REL_HDR2. */ 7704 rel_hdr = &elf_section_data (input_section)->rel_hdr; 7705 if ((size_t) (rel - relocs) 7706 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel)) 7707 rel_hdr = elf_section_data (input_section)->rel_hdr2; 7708 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd)) 7709 { 7710 bfd_byte *location = contents + rel->r_offset; 7711 7712 /* Note that this is a REL relocation. */ 7713 rela_relocation_p = FALSE; 7714 7715 /* Get the addend, which is stored in the input file. */ 7716 _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE, 7717 location); 7718 addend = mips_elf_obtain_contents (howto, rel, input_bfd, 7719 contents); 7720 _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, FALSE, 7721 location); 7722 7723 addend &= howto->src_mask; 7724 7725 /* For some kinds of relocations, the ADDEND is a 7726 combination of the addend stored in two different 7727 relocations. */ 7728 if (r_type == R_MIPS_HI16 || r_type == R_MIPS16_HI16 7729 || (r_type == R_MIPS_GOT16 7730 && mips_elf_local_relocation_p (input_bfd, rel, 7731 local_sections, FALSE))) 7732 { 7733 bfd_vma l; 7734 const Elf_Internal_Rela *lo16_relocation; 7735 reloc_howto_type *lo16_howto; 7736 bfd_byte *lo16_location; 7737 int lo16_type; 7738 7739 if (r_type == R_MIPS16_HI16) 7740 lo16_type = R_MIPS16_LO16; 7741 else 7742 lo16_type = R_MIPS_LO16; 7743 7744 /* The combined value is the sum of the HI16 addend, 7745 left-shifted by sixteen bits, and the LO16 7746 addend, sign extended. (Usually, the code does 7747 a `lui' of the HI16 value, and then an `addiu' of 7748 the LO16 value.) 7749 7750 Scan ahead to find a matching LO16 relocation. 7751 7752 According to the MIPS ELF ABI, the R_MIPS_LO16 7753 relocation must be immediately following. 7754 However, for the IRIX6 ABI, the next relocation 7755 may be a composed relocation consisting of 7756 several relocations for the same address. In 7757 that case, the R_MIPS_LO16 relocation may occur 7758 as one of these. We permit a similar extension 7759 in general, as that is useful for GCC. */ 7760 lo16_relocation = mips_elf_next_relocation (input_bfd, 7761 lo16_type, 7762 rel, relend); 7763 if (lo16_relocation == NULL) 7764 return FALSE; 7765 7766 lo16_location = contents + lo16_relocation->r_offset; 7767 7768 /* Obtain the addend kept there. */ 7769 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, 7770 lo16_type, FALSE); 7771 _bfd_mips16_elf_reloc_unshuffle (input_bfd, lo16_type, FALSE, 7772 lo16_location); 7773 l = mips_elf_obtain_contents (lo16_howto, lo16_relocation, 7774 input_bfd, contents); 7775 _bfd_mips16_elf_reloc_shuffle (input_bfd, lo16_type, FALSE, 7776 lo16_location); 7777 l &= lo16_howto->src_mask; 7778 l <<= lo16_howto->rightshift; 7779 l = _bfd_mips_elf_sign_extend (l, 16); 7780 7781 addend <<= 16; 7782 7783 /* Compute the combined addend. */ 7784 addend += l; 7785 } 7786 else 7787 addend <<= howto->rightshift; 7788 } 7789 else 7790 addend = rel->r_addend; 7791 mips_elf_adjust_addend (output_bfd, info, input_bfd, 7792 local_syms, local_sections, rel); 7793 } 7794 7795 if (info->relocatable) 7796 { 7797 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd) 7798 && bfd_big_endian (input_bfd)) 7799 rel->r_offset -= 4; 7800 7801 if (!rela_relocation_p && rel->r_addend) 7802 { 7803 addend += rel->r_addend; 7804 if (r_type == R_MIPS_HI16 7805 || r_type == R_MIPS_GOT16) 7806 addend = mips_elf_high (addend); 7807 else if (r_type == R_MIPS_HIGHER) 7808 addend = mips_elf_higher (addend); 7809 else if (r_type == R_MIPS_HIGHEST) 7810 addend = mips_elf_highest (addend); 7811 else 7812 addend >>= howto->rightshift; 7813 7814 /* We use the source mask, rather than the destination 7815 mask because the place to which we are writing will be 7816 source of the addend in the final link. */ 7817 addend &= howto->src_mask; 7818 7819 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)) 7820 /* See the comment above about using R_MIPS_64 in the 32-bit 7821 ABI. Here, we need to update the addend. It would be 7822 possible to get away with just using the R_MIPS_32 reloc 7823 but for endianness. */ 7824 { 7825 bfd_vma sign_bits; 7826 bfd_vma low_bits; 7827 bfd_vma high_bits; 7828 7829 if (addend & ((bfd_vma) 1 << 31)) 7830#ifdef BFD64 7831 sign_bits = ((bfd_vma) 1 << 32) - 1; 7832#else 7833 sign_bits = -1; 7834#endif 7835 else 7836 sign_bits = 0; 7837 7838 /* If we don't know that we have a 64-bit type, 7839 do two separate stores. */ 7840 if (bfd_big_endian (input_bfd)) 7841 { 7842 /* Store the sign-bits (which are most significant) 7843 first. */ 7844 low_bits = sign_bits; 7845 high_bits = addend; 7846 } 7847 else 7848 { 7849 low_bits = addend; 7850 high_bits = sign_bits; 7851 } 7852 bfd_put_32 (input_bfd, low_bits, 7853 contents + rel->r_offset); 7854 bfd_put_32 (input_bfd, high_bits, 7855 contents + rel->r_offset + 4); 7856 continue; 7857 } 7858 7859 if (! mips_elf_perform_relocation (info, howto, rel, addend, 7860 input_bfd, input_section, 7861 contents, FALSE)) 7862 return FALSE; 7863 } 7864 7865 /* Go on to the next relocation. */ 7866 continue; 7867 } 7868 7869 /* In the N32 and 64-bit ABIs there may be multiple consecutive 7870 relocations for the same offset. In that case we are 7871 supposed to treat the output of each relocation as the addend 7872 for the next. */ 7873 if (rel + 1 < relend 7874 && rel->r_offset == rel[1].r_offset 7875 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE) 7876 use_saved_addend_p = TRUE; 7877 else 7878 use_saved_addend_p = FALSE; 7879 7880 /* Figure out what value we are supposed to relocate. */ 7881 switch (mips_elf_calculate_relocation (output_bfd, input_bfd, 7882 input_section, info, rel, 7883 addend, howto, local_syms, 7884 local_sections, &value, 7885 &name, &require_jalx, 7886 use_saved_addend_p)) 7887 { 7888 case bfd_reloc_continue: 7889 /* There's nothing to do. */ 7890 continue; 7891 7892 case bfd_reloc_undefined: 7893 /* mips_elf_calculate_relocation already called the 7894 undefined_symbol callback. There's no real point in 7895 trying to perform the relocation at this point, so we 7896 just skip ahead to the next relocation. */ 7897 continue; 7898 7899 case bfd_reloc_notsupported: 7900 msg = _("internal error: unsupported relocation error"); 7901 info->callbacks->warning 7902 (info, msg, name, input_bfd, input_section, rel->r_offset); 7903 return FALSE; 7904 7905 case bfd_reloc_overflow: 7906 if (use_saved_addend_p) 7907 /* Ignore overflow until we reach the last relocation for 7908 a given location. */ 7909 ; 7910 else 7911 { 7912 BFD_ASSERT (name != NULL); 7913 if (! ((*info->callbacks->reloc_overflow) 7914 (info, NULL, name, howto->name, (bfd_vma) 0, 7915 input_bfd, input_section, rel->r_offset))) 7916 return FALSE; 7917 } 7918 break; 7919 7920 case bfd_reloc_ok: 7921 break; 7922 7923 default: 7924 abort (); 7925 break; 7926 } 7927 7928 /* If we've got another relocation for the address, keep going 7929 until we reach the last one. */ 7930 if (use_saved_addend_p) 7931 { 7932 addend = value; 7933 continue; 7934 } 7935 7936 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)) 7937 /* See the comment above about using R_MIPS_64 in the 32-bit 7938 ABI. Until now, we've been using the HOWTO for R_MIPS_32; 7939 that calculated the right value. Now, however, we 7940 sign-extend the 32-bit result to 64-bits, and store it as a 7941 64-bit value. We are especially generous here in that we 7942 go to extreme lengths to support this usage on systems with 7943 only a 32-bit VMA. */ 7944 { 7945 bfd_vma sign_bits; 7946 bfd_vma low_bits; 7947 bfd_vma high_bits; 7948 7949 if (value & ((bfd_vma) 1 << 31)) 7950#ifdef BFD64 7951 sign_bits = ((bfd_vma) 1 << 32) - 1; 7952#else 7953 sign_bits = -1; 7954#endif 7955 else 7956 sign_bits = 0; 7957 7958 /* If we don't know that we have a 64-bit type, 7959 do two separate stores. */ 7960 if (bfd_big_endian (input_bfd)) 7961 { 7962 /* Undo what we did above. */ 7963 rel->r_offset -= 4; 7964 /* Store the sign-bits (which are most significant) 7965 first. */ 7966 low_bits = sign_bits; 7967 high_bits = value; 7968 } 7969 else 7970 { 7971 low_bits = value; 7972 high_bits = sign_bits; 7973 } 7974 bfd_put_32 (input_bfd, low_bits, 7975 contents + rel->r_offset); 7976 bfd_put_32 (input_bfd, high_bits, 7977 contents + rel->r_offset + 4); 7978 continue; 7979 } 7980 7981 /* Actually perform the relocation. */ 7982 if (! mips_elf_perform_relocation (info, howto, rel, value, 7983 input_bfd, input_section, 7984 contents, require_jalx)) 7985 return FALSE; 7986 } 7987 7988 return TRUE; 7989} 7990 7991/* If NAME is one of the special IRIX6 symbols defined by the linker, 7992 adjust it appropriately now. */ 7993 7994static void 7995mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED, 7996 const char *name, Elf_Internal_Sym *sym) 7997{ 7998 /* The linker script takes care of providing names and values for 7999 these, but we must place them into the right sections. */ 8000 static const char* const text_section_symbols[] = { 8001 "_ftext", 8002 "_etext", 8003 "__dso_displacement", 8004 "__elf_header", 8005 "__program_header_table", 8006 NULL 8007 }; 8008 8009 static const char* const data_section_symbols[] = { 8010 "_fdata", 8011 "_edata", 8012 "_end", 8013 "_fbss", 8014 NULL 8015 }; 8016 8017 const char* const *p; 8018 int i; 8019 8020 for (i = 0; i < 2; ++i) 8021 for (p = (i == 0) ? text_section_symbols : data_section_symbols; 8022 *p; 8023 ++p) 8024 if (strcmp (*p, name) == 0) 8025 { 8026 /* All of these symbols are given type STT_SECTION by the 8027 IRIX6 linker. */ 8028 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 8029 sym->st_other = STO_PROTECTED; 8030 8031 /* The IRIX linker puts these symbols in special sections. */ 8032 if (i == 0) 8033 sym->st_shndx = SHN_MIPS_TEXT; 8034 else 8035 sym->st_shndx = SHN_MIPS_DATA; 8036 8037 break; 8038 } 8039} 8040 8041/* Finish up dynamic symbol handling. We set the contents of various 8042 dynamic sections here. */ 8043 8044bfd_boolean 8045_bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd, 8046 struct bfd_link_info *info, 8047 struct elf_link_hash_entry *h, 8048 Elf_Internal_Sym *sym) 8049{ 8050 bfd *dynobj; 8051 asection *sgot; 8052 struct mips_got_info *g, *gg; 8053 const char *name; 8054 int idx; 8055 struct mips_elf_link_hash_table *htab; 8056 8057 htab = mips_elf_hash_table (info); 8058 dynobj = elf_hash_table (info)->dynobj; 8059 8060 if (h->plt.offset != MINUS_ONE) 8061 { 8062 asection *s; 8063 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE]; 8064 8065 /* This symbol has a stub. Set it up. */ 8066 8067 BFD_ASSERT (h->dynindx != -1); 8068 8069 s = bfd_get_section_by_name (dynobj, 8070 MIPS_ELF_STUB_SECTION_NAME (dynobj)); 8071 BFD_ASSERT (s != NULL); 8072 8073 BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE) 8074 || (h->dynindx <= 0xffff)); 8075 8076 /* Values up to 2^31 - 1 are allowed. Larger values would cause 8077 sign extension at runtime in the stub, resulting in a negative 8078 index value. */ 8079 if (h->dynindx & ~0x7fffffff) 8080 return FALSE; 8081 8082 /* Fill the stub. */ 8083 idx = 0; 8084 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx); 8085 idx += 4; 8086 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx); 8087 idx += 4; 8088 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE) 8089 { 8090 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff), 8091 stub + idx); 8092 idx += 4; 8093 } 8094 bfd_put_32 (output_bfd, STUB_JALR, stub + idx); 8095 idx += 4; 8096 8097 /* If a large stub is not required and sign extension is not a 8098 problem, then use legacy code in the stub. */ 8099 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE) 8100 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx); 8101 else if (h->dynindx & ~0x7fff) 8102 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx); 8103 else 8104 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx), 8105 stub + idx); 8106 8107 BFD_ASSERT (h->plt.offset <= s->size); 8108 memcpy (s->contents + h->plt.offset, stub, htab->function_stub_size); 8109 8110 /* Mark the symbol as undefined. plt.offset != -1 occurs 8111 only for the referenced symbol. */ 8112 sym->st_shndx = SHN_UNDEF; 8113 8114 /* The run-time linker uses the st_value field of the symbol 8115 to reset the global offset table entry for this external 8116 to its stub address when unlinking a shared object. */ 8117 sym->st_value = (s->output_section->vma + s->output_offset 8118 + h->plt.offset); 8119 } 8120 8121 BFD_ASSERT (h->dynindx != -1 8122 || h->forced_local); 8123 8124 sgot = mips_elf_got_section (dynobj, FALSE); 8125 BFD_ASSERT (sgot != NULL); 8126 BFD_ASSERT (mips_elf_section_data (sgot) != NULL); 8127 g = mips_elf_section_data (sgot)->u.got_info; 8128 BFD_ASSERT (g != NULL); 8129 8130 /* Run through the global symbol table, creating GOT entries for all 8131 the symbols that need them. */ 8132 if (g->global_gotsym != NULL 8133 && h->dynindx >= g->global_gotsym->dynindx) 8134 { 8135 bfd_vma offset; 8136 bfd_vma value; 8137 8138 value = sym->st_value; 8139 offset = mips_elf_global_got_index (dynobj, output_bfd, h, R_MIPS_GOT16, info); 8140 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset); 8141 } 8142 8143 if (g->next && h->dynindx != -1 && h->type != STT_TLS) 8144 { 8145 struct mips_got_entry e, *p; 8146 bfd_vma entry; 8147 bfd_vma offset; 8148 8149 gg = g; 8150 8151 e.abfd = output_bfd; 8152 e.symndx = -1; 8153 e.d.h = (struct mips_elf_link_hash_entry *)h; 8154 e.tls_type = 0; 8155 8156 for (g = g->next; g->next != gg; g = g->next) 8157 { 8158 if (g->got_entries 8159 && (p = (struct mips_got_entry *) htab_find (g->got_entries, 8160 &e))) 8161 { 8162 offset = p->gotidx; 8163 if (info->shared 8164 || (elf_hash_table (info)->dynamic_sections_created 8165 && p->d.h != NULL 8166 && p->d.h->root.def_dynamic 8167 && !p->d.h->root.def_regular)) 8168 { 8169 /* Create an R_MIPS_REL32 relocation for this entry. Due to 8170 the various compatibility problems, it's easier to mock 8171 up an R_MIPS_32 or R_MIPS_64 relocation and leave 8172 mips_elf_create_dynamic_relocation to calculate the 8173 appropriate addend. */ 8174 Elf_Internal_Rela rel[3]; 8175 8176 memset (rel, 0, sizeof (rel)); 8177 if (ABI_64_P (output_bfd)) 8178 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64); 8179 else 8180 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32); 8181 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset; 8182 8183 entry = 0; 8184 if (! (mips_elf_create_dynamic_relocation 8185 (output_bfd, info, rel, 8186 e.d.h, NULL, sym->st_value, &entry, sgot))) 8187 return FALSE; 8188 } 8189 else 8190 entry = sym->st_value; 8191 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset); 8192 } 8193 } 8194 } 8195 8196 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 8197 name = h->root.root.string; 8198 if (strcmp (name, "_DYNAMIC") == 0 8199 || h == elf_hash_table (info)->hgot) 8200 sym->st_shndx = SHN_ABS; 8201 else if (strcmp (name, "_DYNAMIC_LINK") == 0 8202 || strcmp (name, "_DYNAMIC_LINKING") == 0) 8203 { 8204 sym->st_shndx = SHN_ABS; 8205 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 8206 sym->st_value = 1; 8207 } 8208 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd)) 8209 { 8210 sym->st_shndx = SHN_ABS; 8211 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 8212 sym->st_value = elf_gp (output_bfd); 8213 } 8214 else if (SGI_COMPAT (output_bfd)) 8215 { 8216 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0 8217 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0) 8218 { 8219 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 8220 sym->st_other = STO_PROTECTED; 8221 sym->st_value = 0; 8222 sym->st_shndx = SHN_MIPS_DATA; 8223 } 8224 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0) 8225 { 8226 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 8227 sym->st_other = STO_PROTECTED; 8228 sym->st_value = mips_elf_hash_table (info)->procedure_count; 8229 sym->st_shndx = SHN_ABS; 8230 } 8231 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) 8232 { 8233 if (h->type == STT_FUNC) 8234 sym->st_shndx = SHN_MIPS_TEXT; 8235 else if (h->type == STT_OBJECT) 8236 sym->st_shndx = SHN_MIPS_DATA; 8237 } 8238 } 8239 8240 /* Handle the IRIX6-specific symbols. */ 8241 if (IRIX_COMPAT (output_bfd) == ict_irix6) 8242 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym); 8243 8244 if (! info->shared) 8245 { 8246 if (! mips_elf_hash_table (info)->use_rld_obj_head 8247 && (strcmp (name, "__rld_map") == 0 8248 || strcmp (name, "__RLD_MAP") == 0)) 8249 { 8250 asection *s = bfd_get_section_by_name (dynobj, ".rld_map"); 8251 BFD_ASSERT (s != NULL); 8252 sym->st_value = s->output_section->vma + s->output_offset; 8253 bfd_put_32 (output_bfd, 0, s->contents); 8254 if (mips_elf_hash_table (info)->rld_value == 0) 8255 mips_elf_hash_table (info)->rld_value = sym->st_value; 8256 } 8257 else if (mips_elf_hash_table (info)->use_rld_obj_head 8258 && strcmp (name, "__rld_obj_head") == 0) 8259 { 8260 /* IRIX6 does not use a .rld_map section. */ 8261 if (IRIX_COMPAT (output_bfd) == ict_irix5 8262 || IRIX_COMPAT (output_bfd) == ict_none) 8263 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map") 8264 != NULL); 8265 mips_elf_hash_table (info)->rld_value = sym->st_value; 8266 } 8267 } 8268 8269 /* If this is a mips16 symbol, force the value to be even. */ 8270 if (sym->st_other == STO_MIPS16) 8271 sym->st_value &= ~1; 8272 8273 return TRUE; 8274} 8275 8276/* Likewise, for VxWorks. */ 8277 8278bfd_boolean 8279_bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd, 8280 struct bfd_link_info *info, 8281 struct elf_link_hash_entry *h, 8282 Elf_Internal_Sym *sym) 8283{ 8284 bfd *dynobj; 8285 asection *sgot; 8286 struct mips_got_info *g; 8287 struct mips_elf_link_hash_table *htab; 8288 8289 htab = mips_elf_hash_table (info); 8290 dynobj = elf_hash_table (info)->dynobj; 8291 8292 if (h->plt.offset != (bfd_vma) -1) 8293 { 8294 bfd_byte *loc; 8295 bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset; 8296 Elf_Internal_Rela rel; 8297 static const bfd_vma *plt_entry; 8298 8299 BFD_ASSERT (h->dynindx != -1); 8300 BFD_ASSERT (htab->splt != NULL); 8301 BFD_ASSERT (h->plt.offset <= htab->splt->size); 8302 8303 /* Calculate the address of the .plt entry. */ 8304 plt_address = (htab->splt->output_section->vma 8305 + htab->splt->output_offset 8306 + h->plt.offset); 8307 8308 /* Calculate the index of the entry. */ 8309 plt_index = ((h->plt.offset - htab->plt_header_size) 8310 / htab->plt_entry_size); 8311 8312 /* Calculate the address of the .got.plt entry. */ 8313 got_address = (htab->sgotplt->output_section->vma 8314 + htab->sgotplt->output_offset 8315 + plt_index * 4); 8316 8317 /* Calculate the offset of the .got.plt entry from 8318 _GLOBAL_OFFSET_TABLE_. */ 8319 got_offset = mips_elf_gotplt_index (info, h); 8320 8321 /* Calculate the offset for the branch at the start of the PLT 8322 entry. The branch jumps to the beginning of .plt. */ 8323 branch_offset = -(h->plt.offset / 4 + 1) & 0xffff; 8324 8325 /* Fill in the initial value of the .got.plt entry. */ 8326 bfd_put_32 (output_bfd, plt_address, 8327 htab->sgotplt->contents + plt_index * 4); 8328 8329 /* Find out where the .plt entry should go. */ 8330 loc = htab->splt->contents + h->plt.offset; 8331 8332 if (info->shared) 8333 { 8334 plt_entry = mips_vxworks_shared_plt_entry; 8335 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc); 8336 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4); 8337 } 8338 else 8339 { 8340 bfd_vma got_address_high, got_address_low; 8341 8342 plt_entry = mips_vxworks_exec_plt_entry; 8343 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff; 8344 got_address_low = got_address & 0xffff; 8345 8346 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc); 8347 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4); 8348 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8); 8349 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12); 8350 bfd_put_32 (output_bfd, plt_entry[4], loc + 16); 8351 bfd_put_32 (output_bfd, plt_entry[5], loc + 20); 8352 bfd_put_32 (output_bfd, plt_entry[6], loc + 24); 8353 bfd_put_32 (output_bfd, plt_entry[7], loc + 28); 8354 8355 loc = (htab->srelplt2->contents 8356 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela)); 8357 8358 /* Emit a relocation for the .got.plt entry. */ 8359 rel.r_offset = got_address; 8360 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32); 8361 rel.r_addend = h->plt.offset; 8362 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8363 8364 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */ 8365 loc += sizeof (Elf32_External_Rela); 8366 rel.r_offset = plt_address + 8; 8367 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 8368 rel.r_addend = got_offset; 8369 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8370 8371 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */ 8372 loc += sizeof (Elf32_External_Rela); 8373 rel.r_offset += 4; 8374 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 8375 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8376 } 8377 8378 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */ 8379 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela); 8380 rel.r_offset = got_address; 8381 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT); 8382 rel.r_addend = 0; 8383 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8384 8385 if (!h->def_regular) 8386 sym->st_shndx = SHN_UNDEF; 8387 } 8388 8389 BFD_ASSERT (h->dynindx != -1 || h->forced_local); 8390 8391 sgot = mips_elf_got_section (dynobj, FALSE); 8392 BFD_ASSERT (sgot != NULL); 8393 BFD_ASSERT (mips_elf_section_data (sgot) != NULL); 8394 g = mips_elf_section_data (sgot)->u.got_info; 8395 BFD_ASSERT (g != NULL); 8396 8397 /* See if this symbol has an entry in the GOT. */ 8398 if (g->global_gotsym != NULL 8399 && h->dynindx >= g->global_gotsym->dynindx) 8400 { 8401 bfd_vma offset; 8402 Elf_Internal_Rela outrel; 8403 bfd_byte *loc; 8404 asection *s; 8405 8406 /* Install the symbol value in the GOT. */ 8407 offset = mips_elf_global_got_index (dynobj, output_bfd, h, 8408 R_MIPS_GOT16, info); 8409 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset); 8410 8411 /* Add a dynamic relocation for it. */ 8412 s = mips_elf_rel_dyn_section (info, FALSE); 8413 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela)); 8414 outrel.r_offset = (sgot->output_section->vma 8415 + sgot->output_offset 8416 + offset); 8417 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32); 8418 outrel.r_addend = 0; 8419 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc); 8420 } 8421 8422 /* Emit a copy reloc, if needed. */ 8423 if (h->needs_copy) 8424 { 8425 Elf_Internal_Rela rel; 8426 8427 BFD_ASSERT (h->dynindx != -1); 8428 8429 rel.r_offset = (h->root.u.def.section->output_section->vma 8430 + h->root.u.def.section->output_offset 8431 + h->root.u.def.value); 8432 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY); 8433 rel.r_addend = 0; 8434 bfd_elf32_swap_reloca_out (output_bfd, &rel, 8435 htab->srelbss->contents 8436 + (htab->srelbss->reloc_count 8437 * sizeof (Elf32_External_Rela))); 8438 ++htab->srelbss->reloc_count; 8439 } 8440 8441 /* If this is a mips16 symbol, force the value to be even. */ 8442 if (sym->st_other == STO_MIPS16) 8443 sym->st_value &= ~1; 8444 8445 return TRUE; 8446} 8447 8448/* Install the PLT header for a VxWorks executable and finalize the 8449 contents of .rela.plt.unloaded. */ 8450 8451static void 8452mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info) 8453{ 8454 Elf_Internal_Rela rela; 8455 bfd_byte *loc; 8456 bfd_vma got_value, got_value_high, got_value_low, plt_address; 8457 static const bfd_vma *plt_entry; 8458 struct mips_elf_link_hash_table *htab; 8459 8460 htab = mips_elf_hash_table (info); 8461 plt_entry = mips_vxworks_exec_plt0_entry; 8462 8463 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */ 8464 got_value = (htab->root.hgot->root.u.def.section->output_section->vma 8465 + htab->root.hgot->root.u.def.section->output_offset 8466 + htab->root.hgot->root.u.def.value); 8467 8468 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff; 8469 got_value_low = got_value & 0xffff; 8470 8471 /* Calculate the address of the PLT header. */ 8472 plt_address = htab->splt->output_section->vma + htab->splt->output_offset; 8473 8474 /* Install the PLT header. */ 8475 loc = htab->splt->contents; 8476 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc); 8477 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4); 8478 bfd_put_32 (output_bfd, plt_entry[2], loc + 8); 8479 bfd_put_32 (output_bfd, plt_entry[3], loc + 12); 8480 bfd_put_32 (output_bfd, plt_entry[4], loc + 16); 8481 bfd_put_32 (output_bfd, plt_entry[5], loc + 20); 8482 8483 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */ 8484 loc = htab->srelplt2->contents; 8485 rela.r_offset = plt_address; 8486 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 8487 rela.r_addend = 0; 8488 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 8489 loc += sizeof (Elf32_External_Rela); 8490 8491 /* Output the relocation for the following addiu of 8492 %lo(_GLOBAL_OFFSET_TABLE_). */ 8493 rela.r_offset += 4; 8494 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 8495 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 8496 loc += sizeof (Elf32_External_Rela); 8497 8498 /* Fix up the remaining relocations. They may have the wrong 8499 symbol index for _G_O_T_ or _P_L_T_ depending on the order 8500 in which symbols were output. */ 8501 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 8502 { 8503 Elf_Internal_Rela rel; 8504 8505 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 8506 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32); 8507 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8508 loc += sizeof (Elf32_External_Rela); 8509 8510 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 8511 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16); 8512 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8513 loc += sizeof (Elf32_External_Rela); 8514 8515 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel); 8516 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16); 8517 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 8518 loc += sizeof (Elf32_External_Rela); 8519 } 8520} 8521 8522/* Install the PLT header for a VxWorks shared library. */ 8523 8524static void 8525mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info) 8526{ 8527 unsigned int i; 8528 struct mips_elf_link_hash_table *htab; 8529 8530 htab = mips_elf_hash_table (info); 8531 8532 /* We just need to copy the entry byte-by-byte. */ 8533 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++) 8534 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i], 8535 htab->splt->contents + i * 4); 8536} 8537 8538/* Finish up the dynamic sections. */ 8539 8540bfd_boolean 8541_bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd, 8542 struct bfd_link_info *info) 8543{ 8544 bfd *dynobj; 8545 asection *sdyn; 8546 asection *sgot; 8547 struct mips_got_info *gg, *g; 8548 struct mips_elf_link_hash_table *htab; 8549 8550 htab = mips_elf_hash_table (info); 8551 dynobj = elf_hash_table (info)->dynobj; 8552 8553 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 8554 8555 sgot = mips_elf_got_section (dynobj, FALSE); 8556 if (sgot == NULL) 8557 gg = g = NULL; 8558 else 8559 { 8560 BFD_ASSERT (mips_elf_section_data (sgot) != NULL); 8561 gg = mips_elf_section_data (sgot)->u.got_info; 8562 BFD_ASSERT (gg != NULL); 8563 g = mips_elf_got_for_ibfd (gg, output_bfd); 8564 BFD_ASSERT (g != NULL); 8565 } 8566 8567 if (elf_hash_table (info)->dynamic_sections_created) 8568 { 8569 bfd_byte *b; 8570 int dyn_to_skip = 0, dyn_skipped = 0; 8571 8572 BFD_ASSERT (sdyn != NULL); 8573 BFD_ASSERT (g != NULL); 8574 8575 for (b = sdyn->contents; 8576 b < sdyn->contents + sdyn->size; 8577 b += MIPS_ELF_DYN_SIZE (dynobj)) 8578 { 8579 Elf_Internal_Dyn dyn; 8580 const char *name; 8581 size_t elemsize; 8582 asection *s; 8583 bfd_boolean swap_out_p; 8584 8585 /* Read in the current dynamic entry. */ 8586 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 8587 8588 /* Assume that we're going to modify it and write it out. */ 8589 swap_out_p = TRUE; 8590 8591 switch (dyn.d_tag) 8592 { 8593 case DT_RELENT: 8594 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj); 8595 break; 8596 8597 case DT_RELAENT: 8598 BFD_ASSERT (htab->is_vxworks); 8599 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj); 8600 break; 8601 8602 case DT_STRSZ: 8603 /* Rewrite DT_STRSZ. */ 8604 dyn.d_un.d_val = 8605 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 8606 break; 8607 8608 case DT_PLTGOT: 8609 name = ".got"; 8610 if (htab->is_vxworks) 8611 { 8612 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning 8613 of the ".got" section in DYNOBJ. */ 8614 s = bfd_get_section_by_name (dynobj, name); 8615 BFD_ASSERT (s != NULL); 8616 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 8617 } 8618 else 8619 { 8620 s = bfd_get_section_by_name (output_bfd, name); 8621 BFD_ASSERT (s != NULL); 8622 dyn.d_un.d_ptr = s->vma; 8623 } 8624 break; 8625 8626 case DT_MIPS_RLD_VERSION: 8627 dyn.d_un.d_val = 1; /* XXX */ 8628 break; 8629 8630 case DT_MIPS_FLAGS: 8631 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */ 8632 break; 8633 8634 case DT_MIPS_TIME_STAMP: 8635 { 8636 time_t t; 8637 time (&t); 8638 dyn.d_un.d_val = t; 8639 } 8640 break; 8641 8642 case DT_MIPS_ICHECKSUM: 8643 /* XXX FIXME: */ 8644 swap_out_p = FALSE; 8645 break; 8646 8647 case DT_MIPS_IVERSION: 8648 /* XXX FIXME: */ 8649 swap_out_p = FALSE; 8650 break; 8651 8652 case DT_MIPS_BASE_ADDRESS: 8653 s = output_bfd->sections; 8654 BFD_ASSERT (s != NULL); 8655 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff; 8656 break; 8657 8658 case DT_MIPS_LOCAL_GOTNO: 8659 dyn.d_un.d_val = g->local_gotno; 8660 break; 8661 8662 case DT_MIPS_UNREFEXTNO: 8663 /* The index into the dynamic symbol table which is the 8664 entry of the first external symbol that is not 8665 referenced within the same object. */ 8666 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1; 8667 break; 8668 8669 case DT_MIPS_GOTSYM: 8670 if (gg->global_gotsym) 8671 { 8672 dyn.d_un.d_val = gg->global_gotsym->dynindx; 8673 break; 8674 } 8675 /* In case if we don't have global got symbols we default 8676 to setting DT_MIPS_GOTSYM to the same value as 8677 DT_MIPS_SYMTABNO, so we just fall through. */ 8678 8679 case DT_MIPS_SYMTABNO: 8680 name = ".dynsym"; 8681 elemsize = MIPS_ELF_SYM_SIZE (output_bfd); 8682 s = bfd_get_section_by_name (output_bfd, name); 8683 BFD_ASSERT (s != NULL); 8684 8685 dyn.d_un.d_val = s->size / elemsize; 8686 break; 8687 8688 case DT_MIPS_HIPAGENO: 8689 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO (info); 8690 break; 8691 8692 case DT_MIPS_RLD_MAP: 8693 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value; 8694 break; 8695 8696 case DT_MIPS_OPTIONS: 8697 s = (bfd_get_section_by_name 8698 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd))); 8699 dyn.d_un.d_ptr = s->vma; 8700 break; 8701 8702 case DT_RELASZ: 8703 BFD_ASSERT (htab->is_vxworks); 8704 /* The count does not include the JUMP_SLOT relocations. */ 8705 if (htab->srelplt) 8706 dyn.d_un.d_val -= htab->srelplt->size; 8707 break; 8708 8709 case DT_PLTREL: 8710 BFD_ASSERT (htab->is_vxworks); 8711 dyn.d_un.d_val = DT_RELA; 8712 break; 8713 8714 case DT_PLTRELSZ: 8715 BFD_ASSERT (htab->is_vxworks); 8716 dyn.d_un.d_val = htab->srelplt->size; 8717 break; 8718 8719 case DT_JMPREL: 8720 BFD_ASSERT (htab->is_vxworks); 8721 dyn.d_un.d_val = (htab->srelplt->output_section->vma 8722 + htab->srelplt->output_offset); 8723 break; 8724 8725 case DT_TEXTREL: 8726 /* If we didn't need any text relocations after all, delete 8727 the dynamic tag. */ 8728 if (!(info->flags & DF_TEXTREL)) 8729 { 8730 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj); 8731 swap_out_p = FALSE; 8732 } 8733 break; 8734 8735 case DT_FLAGS: 8736 /* If we didn't need any text relocations after all, clear 8737 DF_TEXTREL from DT_FLAGS. */ 8738 if (!(info->flags & DF_TEXTREL)) 8739 dyn.d_un.d_val &= ~DF_TEXTREL; 8740 else 8741 swap_out_p = FALSE; 8742 break; 8743 8744 default: 8745 swap_out_p = FALSE; 8746 break; 8747 } 8748 8749 if (swap_out_p || dyn_skipped) 8750 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) 8751 (dynobj, &dyn, b - dyn_skipped); 8752 8753 if (dyn_to_skip) 8754 { 8755 dyn_skipped += dyn_to_skip; 8756 dyn_to_skip = 0; 8757 } 8758 } 8759 8760 /* Wipe out any trailing entries if we shifted down a dynamic tag. */ 8761 if (dyn_skipped > 0) 8762 memset (b - dyn_skipped, 0, dyn_skipped); 8763 } 8764 8765 if (sgot != NULL && sgot->size > 0) 8766 { 8767 if (htab->is_vxworks) 8768 { 8769 /* The first entry of the global offset table points to the 8770 ".dynamic" section. The second is initialized by the 8771 loader and contains the shared library identifier. 8772 The third is also initialized by the loader and points 8773 to the lazy resolution stub. */ 8774 MIPS_ELF_PUT_WORD (output_bfd, 8775 sdyn->output_offset + sdyn->output_section->vma, 8776 sgot->contents); 8777 MIPS_ELF_PUT_WORD (output_bfd, 0, 8778 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd)); 8779 MIPS_ELF_PUT_WORD (output_bfd, 0, 8780 sgot->contents 8781 + 2 * MIPS_ELF_GOT_SIZE (output_bfd)); 8782 } 8783 else 8784 { 8785 /* The first entry of the global offset table will be filled at 8786 runtime. The second entry will be used by some runtime loaders. 8787 This isn't the case of IRIX rld. */ 8788 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents); 8789 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000, 8790 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd)); 8791 } 8792 } 8793 8794 if (sgot != NULL) 8795 elf_section_data (sgot->output_section)->this_hdr.sh_entsize 8796 = MIPS_ELF_GOT_SIZE (output_bfd); 8797 8798 /* Generate dynamic relocations for the non-primary gots. */ 8799 if (gg != NULL && gg->next) 8800 { 8801 Elf_Internal_Rela rel[3]; 8802 bfd_vma addend = 0; 8803 8804 memset (rel, 0, sizeof (rel)); 8805 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32); 8806 8807 for (g = gg->next; g->next != gg; g = g->next) 8808 { 8809 bfd_vma index = g->next->local_gotno + g->next->global_gotno 8810 + g->next->tls_gotno; 8811 8812 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents 8813 + index++ * MIPS_ELF_GOT_SIZE (output_bfd)); 8814 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents 8815 + index++ * MIPS_ELF_GOT_SIZE (output_bfd)); 8816 8817 if (! info->shared) 8818 continue; 8819 8820 while (index < g->assigned_gotno) 8821 { 8822 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset 8823 = index++ * MIPS_ELF_GOT_SIZE (output_bfd); 8824 if (!(mips_elf_create_dynamic_relocation 8825 (output_bfd, info, rel, NULL, 8826 bfd_abs_section_ptr, 8827 0, &addend, sgot))) 8828 return FALSE; 8829 BFD_ASSERT (addend == 0); 8830 } 8831 } 8832 } 8833 8834 /* The generation of dynamic relocations for the non-primary gots 8835 adds more dynamic relocations. We cannot count them until 8836 here. */ 8837 8838 if (elf_hash_table (info)->dynamic_sections_created) 8839 { 8840 bfd_byte *b; 8841 bfd_boolean swap_out_p; 8842 8843 BFD_ASSERT (sdyn != NULL); 8844 8845 for (b = sdyn->contents; 8846 b < sdyn->contents + sdyn->size; 8847 b += MIPS_ELF_DYN_SIZE (dynobj)) 8848 { 8849 Elf_Internal_Dyn dyn; 8850 asection *s; 8851 8852 /* Read in the current dynamic entry. */ 8853 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 8854 8855 /* Assume that we're going to modify it and write it out. */ 8856 swap_out_p = TRUE; 8857 8858 switch (dyn.d_tag) 8859 { 8860 case DT_RELSZ: 8861 /* Reduce DT_RELSZ to account for any relocations we 8862 decided not to make. This is for the n64 irix rld, 8863 which doesn't seem to apply any relocations if there 8864 are trailing null entries. */ 8865 s = mips_elf_rel_dyn_section (info, FALSE); 8866 dyn.d_un.d_val = (s->reloc_count 8867 * (ABI_64_P (output_bfd) 8868 ? sizeof (Elf64_Mips_External_Rel) 8869 : sizeof (Elf32_External_Rel))); 8870 break; 8871 8872 default: 8873 swap_out_p = FALSE; 8874 break; 8875 } 8876 8877 if (swap_out_p) 8878 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) 8879 (dynobj, &dyn, b); 8880 } 8881 } 8882 8883 { 8884 asection *s; 8885 Elf32_compact_rel cpt; 8886 8887 if (SGI_COMPAT (output_bfd)) 8888 { 8889 /* Write .compact_rel section out. */ 8890 s = bfd_get_section_by_name (dynobj, ".compact_rel"); 8891 if (s != NULL) 8892 { 8893 cpt.id1 = 1; 8894 cpt.num = s->reloc_count; 8895 cpt.id2 = 2; 8896 cpt.offset = (s->output_section->filepos 8897 + sizeof (Elf32_External_compact_rel)); 8898 cpt.reserved0 = 0; 8899 cpt.reserved1 = 0; 8900 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt, 8901 ((Elf32_External_compact_rel *) 8902 s->contents)); 8903 8904 /* Clean up a dummy stub function entry in .text. */ 8905 s = bfd_get_section_by_name (dynobj, 8906 MIPS_ELF_STUB_SECTION_NAME (dynobj)); 8907 if (s != NULL) 8908 { 8909 file_ptr dummy_offset; 8910 8911 BFD_ASSERT (s->size >= htab->function_stub_size); 8912 dummy_offset = s->size - htab->function_stub_size; 8913 memset (s->contents + dummy_offset, 0, 8914 htab->function_stub_size); 8915 } 8916 } 8917 } 8918 8919 /* The psABI says that the dynamic relocations must be sorted in 8920 increasing order of r_symndx. The VxWorks EABI doesn't require 8921 this, and because the code below handles REL rather than RELA 8922 relocations, using it for VxWorks would be outright harmful. */ 8923 if (!htab->is_vxworks) 8924 { 8925 s = mips_elf_rel_dyn_section (info, FALSE); 8926 if (s != NULL 8927 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd)) 8928 { 8929 reldyn_sorting_bfd = output_bfd; 8930 8931 if (ABI_64_P (output_bfd)) 8932 qsort ((Elf64_External_Rel *) s->contents + 1, 8933 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel), 8934 sort_dynamic_relocs_64); 8935 else 8936 qsort ((Elf32_External_Rel *) s->contents + 1, 8937 s->reloc_count - 1, sizeof (Elf32_External_Rel), 8938 sort_dynamic_relocs); 8939 } 8940 } 8941 } 8942 8943 if (htab->is_vxworks && htab->splt->size > 0) 8944 { 8945 if (info->shared) 8946 mips_vxworks_finish_shared_plt (output_bfd, info); 8947 else 8948 mips_vxworks_finish_exec_plt (output_bfd, info); 8949 } 8950 return TRUE; 8951} 8952 8953 8954/* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */ 8955 8956static void 8957mips_set_isa_flags (bfd *abfd) 8958{ 8959 flagword val; 8960 8961 switch (bfd_get_mach (abfd)) 8962 { 8963 default: 8964 case bfd_mach_mips3000: 8965 val = E_MIPS_ARCH_1; 8966 break; 8967 8968 case bfd_mach_mips3900: 8969 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900; 8970 break; 8971 8972 case bfd_mach_mips6000: 8973 val = E_MIPS_ARCH_2; 8974 break; 8975 8976 case bfd_mach_mips4000: 8977 case bfd_mach_mips4300: 8978 case bfd_mach_mips4400: 8979 case bfd_mach_mips4600: 8980 val = E_MIPS_ARCH_3; 8981 break; 8982 8983 case bfd_mach_mips4010: 8984 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010; 8985 break; 8986 8987 case bfd_mach_mips4100: 8988 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100; 8989 break; 8990 8991 case bfd_mach_mips4111: 8992 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111; 8993 break; 8994 8995 case bfd_mach_mips4120: 8996 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120; 8997 break; 8998 8999 case bfd_mach_mips4650: 9000 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650; 9001 break; 9002 9003 case bfd_mach_mips5400: 9004 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400; 9005 break; 9006 9007 case bfd_mach_mips5500: 9008 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500; 9009 break; 9010 9011 case bfd_mach_mips9000: 9012 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000; 9013 break; 9014 9015 case bfd_mach_mips5000: 9016 case bfd_mach_mips7000: 9017 case bfd_mach_mips8000: 9018 case bfd_mach_mips10000: 9019 case bfd_mach_mips12000: 9020 val = E_MIPS_ARCH_4; 9021 break; 9022 9023 case bfd_mach_mips5: 9024 val = E_MIPS_ARCH_5; 9025 break; 9026 9027 case bfd_mach_mips_sb1: 9028 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1; 9029 break; 9030 9031 case bfd_mach_mipsisa32: 9032 val = E_MIPS_ARCH_32; 9033 break; 9034 9035 case bfd_mach_mipsisa64: 9036 val = E_MIPS_ARCH_64; 9037 break; 9038 9039 case bfd_mach_mipsisa32r2: 9040 val = E_MIPS_ARCH_32R2; 9041 break; 9042 9043 case bfd_mach_mipsisa64r2: 9044 val = E_MIPS_ARCH_64R2; 9045 break; 9046 } 9047 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH); 9048 elf_elfheader (abfd)->e_flags |= val; 9049 9050} 9051 9052 9053/* The final processing done just before writing out a MIPS ELF object 9054 file. This gets the MIPS architecture right based on the machine 9055 number. This is used by both the 32-bit and the 64-bit ABI. */ 9056 9057void 9058_bfd_mips_elf_final_write_processing (bfd *abfd, 9059 bfd_boolean linker ATTRIBUTE_UNUSED) 9060{ 9061 unsigned int i; 9062 Elf_Internal_Shdr **hdrpp; 9063 const char *name; 9064 asection *sec; 9065 9066 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former 9067 is nonzero. This is for compatibility with old objects, which used 9068 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */ 9069 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0) 9070 mips_set_isa_flags (abfd); 9071 9072 /* Set the sh_info field for .gptab sections and other appropriate 9073 info for each special section. */ 9074 for (i = 1, hdrpp = elf_elfsections (abfd) + 1; 9075 i < elf_numsections (abfd); 9076 i++, hdrpp++) 9077 { 9078 switch ((*hdrpp)->sh_type) 9079 { 9080 case SHT_MIPS_MSYM: 9081 case SHT_MIPS_LIBLIST: 9082 sec = bfd_get_section_by_name (abfd, ".dynstr"); 9083 if (sec != NULL) 9084 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 9085 break; 9086 9087 case SHT_MIPS_GPTAB: 9088 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 9089 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section); 9090 BFD_ASSERT (name != NULL 9091 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0); 9092 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1); 9093 BFD_ASSERT (sec != NULL); 9094 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx; 9095 break; 9096 9097 case SHT_MIPS_CONTENT: 9098 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 9099 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section); 9100 BFD_ASSERT (name != NULL 9101 && strncmp (name, ".MIPS.content", 9102 sizeof ".MIPS.content" - 1) == 0); 9103 sec = bfd_get_section_by_name (abfd, 9104 name + sizeof ".MIPS.content" - 1); 9105 BFD_ASSERT (sec != NULL); 9106 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 9107 break; 9108 9109 case SHT_MIPS_SYMBOL_LIB: 9110 sec = bfd_get_section_by_name (abfd, ".dynsym"); 9111 if (sec != NULL) 9112 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 9113 sec = bfd_get_section_by_name (abfd, ".liblist"); 9114 if (sec != NULL) 9115 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx; 9116 break; 9117 9118 case SHT_MIPS_EVENTS: 9119 BFD_ASSERT ((*hdrpp)->bfd_section != NULL); 9120 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section); 9121 BFD_ASSERT (name != NULL); 9122 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0) 9123 sec = bfd_get_section_by_name (abfd, 9124 name + sizeof ".MIPS.events" - 1); 9125 else 9126 { 9127 BFD_ASSERT (strncmp (name, ".MIPS.post_rel", 9128 sizeof ".MIPS.post_rel" - 1) == 0); 9129 sec = bfd_get_section_by_name (abfd, 9130 (name 9131 + sizeof ".MIPS.post_rel" - 1)); 9132 } 9133 BFD_ASSERT (sec != NULL); 9134 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx; 9135 break; 9136 9137 } 9138 } 9139} 9140 9141/* When creating an IRIX5 executable, we need REGINFO and RTPROC 9142 segments. */ 9143 9144int 9145_bfd_mips_elf_additional_program_headers (bfd *abfd) 9146{ 9147 asection *s; 9148 int ret = 0; 9149 9150 /* See if we need a PT_MIPS_REGINFO segment. */ 9151 s = bfd_get_section_by_name (abfd, ".reginfo"); 9152 if (s && (s->flags & SEC_LOAD)) 9153 ++ret; 9154 9155 /* See if we need a PT_MIPS_OPTIONS segment. */ 9156 if (IRIX_COMPAT (abfd) == ict_irix6 9157 && bfd_get_section_by_name (abfd, 9158 MIPS_ELF_OPTIONS_SECTION_NAME (abfd))) 9159 ++ret; 9160 9161 /* See if we need a PT_MIPS_RTPROC segment. */ 9162 if (IRIX_COMPAT (abfd) == ict_irix5 9163 && bfd_get_section_by_name (abfd, ".dynamic") 9164 && bfd_get_section_by_name (abfd, ".mdebug")) 9165 ++ret; 9166 9167 return ret; 9168} 9169 9170/* Modify the segment map for an IRIX5 executable. */ 9171 9172bfd_boolean 9173_bfd_mips_elf_modify_segment_map (bfd *abfd, 9174 struct bfd_link_info *info ATTRIBUTE_UNUSED) 9175{ 9176 asection *s; 9177 struct elf_segment_map *m, **pm; 9178 bfd_size_type amt; 9179 9180 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO 9181 segment. */ 9182 s = bfd_get_section_by_name (abfd, ".reginfo"); 9183 if (s != NULL && (s->flags & SEC_LOAD) != 0) 9184 { 9185 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 9186 if (m->p_type == PT_MIPS_REGINFO) 9187 break; 9188 if (m == NULL) 9189 { 9190 amt = sizeof *m; 9191 m = bfd_zalloc (abfd, amt); 9192 if (m == NULL) 9193 return FALSE; 9194 9195 m->p_type = PT_MIPS_REGINFO; 9196 m->count = 1; 9197 m->sections[0] = s; 9198 9199 /* We want to put it after the PHDR and INTERP segments. */ 9200 pm = &elf_tdata (abfd)->segment_map; 9201 while (*pm != NULL 9202 && ((*pm)->p_type == PT_PHDR 9203 || (*pm)->p_type == PT_INTERP)) 9204 pm = &(*pm)->next; 9205 9206 m->next = *pm; 9207 *pm = m; 9208 } 9209 } 9210 9211 /* For IRIX 6, we don't have .mdebug sections, nor does anything but 9212 .dynamic end up in PT_DYNAMIC. However, we do have to insert a 9213 PT_MIPS_OPTIONS segment immediately following the program header 9214 table. */ 9215 if (NEWABI_P (abfd) 9216 /* On non-IRIX6 new abi, we'll have already created a segment 9217 for this section, so don't create another. I'm not sure this 9218 is not also the case for IRIX 6, but I can't test it right 9219 now. */ 9220 && IRIX_COMPAT (abfd) == ict_irix6) 9221 { 9222 for (s = abfd->sections; s; s = s->next) 9223 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS) 9224 break; 9225 9226 if (s) 9227 { 9228 struct elf_segment_map *options_segment; 9229 9230 pm = &elf_tdata (abfd)->segment_map; 9231 while (*pm != NULL 9232 && ((*pm)->p_type == PT_PHDR 9233 || (*pm)->p_type == PT_INTERP)) 9234 pm = &(*pm)->next; 9235 9236 amt = sizeof (struct elf_segment_map); 9237 options_segment = bfd_zalloc (abfd, amt); 9238 options_segment->next = *pm; 9239 options_segment->p_type = PT_MIPS_OPTIONS; 9240 options_segment->p_flags = PF_R; 9241 options_segment->p_flags_valid = TRUE; 9242 options_segment->count = 1; 9243 options_segment->sections[0] = s; 9244 *pm = options_segment; 9245 } 9246 } 9247 else 9248 { 9249 if (IRIX_COMPAT (abfd) == ict_irix5) 9250 { 9251 /* If there are .dynamic and .mdebug sections, we make a room 9252 for the RTPROC header. FIXME: Rewrite without section names. */ 9253 if (bfd_get_section_by_name (abfd, ".interp") == NULL 9254 && bfd_get_section_by_name (abfd, ".dynamic") != NULL 9255 && bfd_get_section_by_name (abfd, ".mdebug") != NULL) 9256 { 9257 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 9258 if (m->p_type == PT_MIPS_RTPROC) 9259 break; 9260 if (m == NULL) 9261 { 9262 amt = sizeof *m; 9263 m = bfd_zalloc (abfd, amt); 9264 if (m == NULL) 9265 return FALSE; 9266 9267 m->p_type = PT_MIPS_RTPROC; 9268 9269 s = bfd_get_section_by_name (abfd, ".rtproc"); 9270 if (s == NULL) 9271 { 9272 m->count = 0; 9273 m->p_flags = 0; 9274 m->p_flags_valid = 1; 9275 } 9276 else 9277 { 9278 m->count = 1; 9279 m->sections[0] = s; 9280 } 9281 9282 /* We want to put it after the DYNAMIC segment. */ 9283 pm = &elf_tdata (abfd)->segment_map; 9284 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC) 9285 pm = &(*pm)->next; 9286 if (*pm != NULL) 9287 pm = &(*pm)->next; 9288 9289 m->next = *pm; 9290 *pm = m; 9291 } 9292 } 9293 } 9294 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic, 9295 .dynstr, .dynsym, and .hash sections, and everything in 9296 between. */ 9297 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; 9298 pm = &(*pm)->next) 9299 if ((*pm)->p_type == PT_DYNAMIC) 9300 break; 9301 m = *pm; 9302 if (m != NULL && IRIX_COMPAT (abfd) == ict_none) 9303 { 9304 /* For a normal mips executable the permissions for the PT_DYNAMIC 9305 segment are read, write and execute. We do that here since 9306 the code in elf.c sets only the read permission. This matters 9307 sometimes for the dynamic linker. */ 9308 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL) 9309 { 9310 m->p_flags = PF_R | PF_W | PF_X; 9311 m->p_flags_valid = 1; 9312 } 9313 } 9314 if (m != NULL 9315 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0) 9316 { 9317 static const char *sec_names[] = 9318 { 9319 ".dynamic", ".dynstr", ".dynsym", ".hash" 9320 }; 9321 bfd_vma low, high; 9322 unsigned int i, c; 9323 struct elf_segment_map *n; 9324 9325 low = ~(bfd_vma) 0; 9326 high = 0; 9327 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++) 9328 { 9329 s = bfd_get_section_by_name (abfd, sec_names[i]); 9330 if (s != NULL && (s->flags & SEC_LOAD) != 0) 9331 { 9332 bfd_size_type sz; 9333 9334 if (low > s->vma) 9335 low = s->vma; 9336 sz = s->size; 9337 if (high < s->vma + sz) 9338 high = s->vma + sz; 9339 } 9340 } 9341 9342 c = 0; 9343 for (s = abfd->sections; s != NULL; s = s->next) 9344 if ((s->flags & SEC_LOAD) != 0 9345 && s->vma >= low 9346 && s->vma + s->size <= high) 9347 ++c; 9348 9349 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *); 9350 n = bfd_zalloc (abfd, amt); 9351 if (n == NULL) 9352 return FALSE; 9353 *n = *m; 9354 n->count = c; 9355 9356 i = 0; 9357 for (s = abfd->sections; s != NULL; s = s->next) 9358 { 9359 if ((s->flags & SEC_LOAD) != 0 9360 && s->vma >= low 9361 && s->vma + s->size <= high) 9362 { 9363 n->sections[i] = s; 9364 ++i; 9365 } 9366 } 9367 9368 *pm = n; 9369 } 9370 } 9371 9372 return TRUE; 9373} 9374 9375/* Return the section that should be marked against GC for a given 9376 relocation. */ 9377 9378asection * 9379_bfd_mips_elf_gc_mark_hook (asection *sec, 9380 struct bfd_link_info *info ATTRIBUTE_UNUSED, 9381 Elf_Internal_Rela *rel, 9382 struct elf_link_hash_entry *h, 9383 Elf_Internal_Sym *sym) 9384{ 9385 /* ??? Do mips16 stub sections need to be handled special? */ 9386 9387 if (h != NULL) 9388 { 9389 switch (ELF_R_TYPE (sec->owner, rel->r_info)) 9390 { 9391 case R_MIPS_GNU_VTINHERIT: 9392 case R_MIPS_GNU_VTENTRY: 9393 break; 9394 9395 default: 9396 switch (h->root.type) 9397 { 9398 case bfd_link_hash_defined: 9399 case bfd_link_hash_defweak: 9400 return h->root.u.def.section; 9401 9402 case bfd_link_hash_common: 9403 return h->root.u.c.p->section; 9404 9405 default: 9406 break; 9407 } 9408 } 9409 } 9410 else 9411 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 9412 9413 return NULL; 9414} 9415 9416/* Update the got entry reference counts for the section being removed. */ 9417 9418bfd_boolean 9419_bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED, 9420 struct bfd_link_info *info ATTRIBUTE_UNUSED, 9421 asection *sec ATTRIBUTE_UNUSED, 9422 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED) 9423{ 9424#if 0 9425 Elf_Internal_Shdr *symtab_hdr; 9426 struct elf_link_hash_entry **sym_hashes; 9427 bfd_signed_vma *local_got_refcounts; 9428 const Elf_Internal_Rela *rel, *relend; 9429 unsigned long r_symndx; 9430 struct elf_link_hash_entry *h; 9431 9432 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 9433 sym_hashes = elf_sym_hashes (abfd); 9434 local_got_refcounts = elf_local_got_refcounts (abfd); 9435 9436 relend = relocs + sec->reloc_count; 9437 for (rel = relocs; rel < relend; rel++) 9438 switch (ELF_R_TYPE (abfd, rel->r_info)) 9439 { 9440 case R_MIPS_GOT16: 9441 case R_MIPS_CALL16: 9442 case R_MIPS_CALL_HI16: 9443 case R_MIPS_CALL_LO16: 9444 case R_MIPS_GOT_HI16: 9445 case R_MIPS_GOT_LO16: 9446 case R_MIPS_GOT_DISP: 9447 case R_MIPS_GOT_PAGE: 9448 case R_MIPS_GOT_OFST: 9449 /* ??? It would seem that the existing MIPS code does no sort 9450 of reference counting or whatnot on its GOT and PLT entries, 9451 so it is not possible to garbage collect them at this time. */ 9452 break; 9453 9454 default: 9455 break; 9456 } 9457#endif 9458 9459 return TRUE; 9460} 9461 9462/* Copy data from a MIPS ELF indirect symbol to its direct symbol, 9463 hiding the old indirect symbol. Process additional relocation 9464 information. Also called for weakdefs, in which case we just let 9465 _bfd_elf_link_hash_copy_indirect copy the flags for us. */ 9466 9467void 9468_bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info, 9469 struct elf_link_hash_entry *dir, 9470 struct elf_link_hash_entry *ind) 9471{ 9472 struct mips_elf_link_hash_entry *dirmips, *indmips; 9473 9474 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 9475 9476 if (ind->root.type != bfd_link_hash_indirect) 9477 return; 9478 9479 dirmips = (struct mips_elf_link_hash_entry *) dir; 9480 indmips = (struct mips_elf_link_hash_entry *) ind; 9481 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs; 9482 if (indmips->readonly_reloc) 9483 dirmips->readonly_reloc = TRUE; 9484 if (indmips->no_fn_stub) 9485 dirmips->no_fn_stub = TRUE; 9486 9487 if (dirmips->tls_type == 0) 9488 dirmips->tls_type = indmips->tls_type; 9489} 9490 9491void 9492_bfd_mips_elf_hide_symbol (struct bfd_link_info *info, 9493 struct elf_link_hash_entry *entry, 9494 bfd_boolean force_local) 9495{ 9496 bfd *dynobj; 9497 asection *got; 9498 struct mips_got_info *g; 9499 struct mips_elf_link_hash_entry *h; 9500 9501 h = (struct mips_elf_link_hash_entry *) entry; 9502 if (h->forced_local) 9503 return; 9504 h->forced_local = force_local; 9505 9506 dynobj = elf_hash_table (info)->dynobj; 9507 if (dynobj != NULL && force_local && h->root.type != STT_TLS 9508 && (got = mips_elf_got_section (dynobj, FALSE)) != NULL 9509 && (g = mips_elf_section_data (got)->u.got_info) != NULL) 9510 { 9511 if (g->next) 9512 { 9513 struct mips_got_entry e; 9514 struct mips_got_info *gg = g; 9515 9516 /* Since we're turning what used to be a global symbol into a 9517 local one, bump up the number of local entries of each GOT 9518 that had an entry for it. This will automatically decrease 9519 the number of global entries, since global_gotno is actually 9520 the upper limit of global entries. */ 9521 e.abfd = dynobj; 9522 e.symndx = -1; 9523 e.d.h = h; 9524 e.tls_type = 0; 9525 9526 for (g = g->next; g != gg; g = g->next) 9527 if (htab_find (g->got_entries, &e)) 9528 { 9529 BFD_ASSERT (g->global_gotno > 0); 9530 g->local_gotno++; 9531 g->global_gotno--; 9532 } 9533 9534 /* If this was a global symbol forced into the primary GOT, we 9535 no longer need an entry for it. We can't release the entry 9536 at this point, but we must at least stop counting it as one 9537 of the symbols that required a forced got entry. */ 9538 if (h->root.got.offset == 2) 9539 { 9540 BFD_ASSERT (gg->assigned_gotno > 0); 9541 gg->assigned_gotno--; 9542 } 9543 } 9544 else if (g->global_gotno == 0 && g->global_gotsym == NULL) 9545 /* If we haven't got through GOT allocation yet, just bump up the 9546 number of local entries, as this symbol won't be counted as 9547 global. */ 9548 g->local_gotno++; 9549 else if (h->root.got.offset == 1) 9550 { 9551 /* If we're past non-multi-GOT allocation and this symbol had 9552 been marked for a global got entry, give it a local entry 9553 instead. */ 9554 BFD_ASSERT (g->global_gotno > 0); 9555 g->local_gotno++; 9556 g->global_gotno--; 9557 } 9558 } 9559 9560 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local); 9561} 9562 9563#define PDR_SIZE 32 9564 9565bfd_boolean 9566_bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 9567 struct bfd_link_info *info) 9568{ 9569 asection *o; 9570 bfd_boolean ret = FALSE; 9571 unsigned char *tdata; 9572 size_t i, skip; 9573 9574 o = bfd_get_section_by_name (abfd, ".pdr"); 9575 if (! o) 9576 return FALSE; 9577 if (o->size == 0) 9578 return FALSE; 9579 if (o->size % PDR_SIZE != 0) 9580 return FALSE; 9581 if (o->output_section != NULL 9582 && bfd_is_abs_section (o->output_section)) 9583 return FALSE; 9584 9585 tdata = bfd_zmalloc (o->size / PDR_SIZE); 9586 if (! tdata) 9587 return FALSE; 9588 9589 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, 9590 info->keep_memory); 9591 if (!cookie->rels) 9592 { 9593 free (tdata); 9594 return FALSE; 9595 } 9596 9597 cookie->rel = cookie->rels; 9598 cookie->relend = cookie->rels + o->reloc_count; 9599 9600 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++) 9601 { 9602 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie)) 9603 { 9604 tdata[i] = 1; 9605 skip ++; 9606 } 9607 } 9608 9609 if (skip != 0) 9610 { 9611 mips_elf_section_data (o)->u.tdata = tdata; 9612 o->size -= skip * PDR_SIZE; 9613 ret = TRUE; 9614 } 9615 else 9616 free (tdata); 9617 9618 if (! info->keep_memory) 9619 free (cookie->rels); 9620 9621 return ret; 9622} 9623 9624bfd_boolean 9625_bfd_mips_elf_ignore_discarded_relocs (asection *sec) 9626{ 9627 if (strcmp (sec->name, ".pdr") == 0) 9628 return TRUE; 9629 return FALSE; 9630} 9631 9632bfd_boolean 9633_bfd_mips_elf_write_section (bfd *output_bfd, asection *sec, 9634 bfd_byte *contents) 9635{ 9636 bfd_byte *to, *from, *end; 9637 int i; 9638 9639 if (strcmp (sec->name, ".pdr") != 0) 9640 return FALSE; 9641 9642 if (mips_elf_section_data (sec)->u.tdata == NULL) 9643 return FALSE; 9644 9645 to = contents; 9646 end = contents + sec->size; 9647 for (from = contents, i = 0; 9648 from < end; 9649 from += PDR_SIZE, i++) 9650 { 9651 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1) 9652 continue; 9653 if (to != from) 9654 memcpy (to, from, PDR_SIZE); 9655 to += PDR_SIZE; 9656 } 9657 bfd_set_section_contents (output_bfd, sec->output_section, contents, 9658 sec->output_offset, sec->size); 9659 return TRUE; 9660} 9661 9662/* MIPS ELF uses a special find_nearest_line routine in order the 9663 handle the ECOFF debugging information. */ 9664 9665struct mips_elf_find_line 9666{ 9667 struct ecoff_debug_info d; 9668 struct ecoff_find_line i; 9669}; 9670 9671bfd_boolean 9672_bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section, 9673 asymbol **symbols, bfd_vma offset, 9674 const char **filename_ptr, 9675 const char **functionname_ptr, 9676 unsigned int *line_ptr) 9677{ 9678 asection *msec; 9679 9680 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset, 9681 filename_ptr, functionname_ptr, 9682 line_ptr)) 9683 return TRUE; 9684 9685 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, 9686 filename_ptr, functionname_ptr, 9687 line_ptr, ABI_64_P (abfd) ? 8 : 0, 9688 &elf_tdata (abfd)->dwarf2_find_line_info)) 9689 return TRUE; 9690 9691 msec = bfd_get_section_by_name (abfd, ".mdebug"); 9692 if (msec != NULL) 9693 { 9694 flagword origflags; 9695 struct mips_elf_find_line *fi; 9696 const struct ecoff_debug_swap * const swap = 9697 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 9698 9699 /* If we are called during a link, mips_elf_final_link may have 9700 cleared the SEC_HAS_CONTENTS field. We force it back on here 9701 if appropriate (which it normally will be). */ 9702 origflags = msec->flags; 9703 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS) 9704 msec->flags |= SEC_HAS_CONTENTS; 9705 9706 fi = elf_tdata (abfd)->find_line_info; 9707 if (fi == NULL) 9708 { 9709 bfd_size_type external_fdr_size; 9710 char *fraw_src; 9711 char *fraw_end; 9712 struct fdr *fdr_ptr; 9713 bfd_size_type amt = sizeof (struct mips_elf_find_line); 9714 9715 fi = bfd_zalloc (abfd, amt); 9716 if (fi == NULL) 9717 { 9718 msec->flags = origflags; 9719 return FALSE; 9720 } 9721 9722 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d)) 9723 { 9724 msec->flags = origflags; 9725 return FALSE; 9726 } 9727 9728 /* Swap in the FDR information. */ 9729 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr); 9730 fi->d.fdr = bfd_alloc (abfd, amt); 9731 if (fi->d.fdr == NULL) 9732 { 9733 msec->flags = origflags; 9734 return FALSE; 9735 } 9736 external_fdr_size = swap->external_fdr_size; 9737 fdr_ptr = fi->d.fdr; 9738 fraw_src = (char *) fi->d.external_fdr; 9739 fraw_end = (fraw_src 9740 + fi->d.symbolic_header.ifdMax * external_fdr_size); 9741 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) 9742 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr); 9743 9744 elf_tdata (abfd)->find_line_info = fi; 9745 9746 /* Note that we don't bother to ever free this information. 9747 find_nearest_line is either called all the time, as in 9748 objdump -l, so the information should be saved, or it is 9749 rarely called, as in ld error messages, so the memory 9750 wasted is unimportant. Still, it would probably be a 9751 good idea for free_cached_info to throw it away. */ 9752 } 9753 9754 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap, 9755 &fi->i, filename_ptr, functionname_ptr, 9756 line_ptr)) 9757 { 9758 msec->flags = origflags; 9759 return TRUE; 9760 } 9761 9762 msec->flags = origflags; 9763 } 9764 9765 /* Fall back on the generic ELF find_nearest_line routine. */ 9766 9767 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset, 9768 filename_ptr, functionname_ptr, 9769 line_ptr); 9770} 9771 9772bfd_boolean 9773_bfd_mips_elf_find_inliner_info (bfd *abfd, 9774 const char **filename_ptr, 9775 const char **functionname_ptr, 9776 unsigned int *line_ptr) 9777{ 9778 bfd_boolean found; 9779 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 9780 functionname_ptr, line_ptr, 9781 & elf_tdata (abfd)->dwarf2_find_line_info); 9782 return found; 9783} 9784 9785 9786/* When are writing out the .options or .MIPS.options section, 9787 remember the bytes we are writing out, so that we can install the 9788 GP value in the section_processing routine. */ 9789 9790bfd_boolean 9791_bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section, 9792 const void *location, 9793 file_ptr offset, bfd_size_type count) 9794{ 9795 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name)) 9796 { 9797 bfd_byte *c; 9798 9799 if (elf_section_data (section) == NULL) 9800 { 9801 bfd_size_type amt = sizeof (struct bfd_elf_section_data); 9802 section->used_by_bfd = bfd_zalloc (abfd, amt); 9803 if (elf_section_data (section) == NULL) 9804 return FALSE; 9805 } 9806 c = mips_elf_section_data (section)->u.tdata; 9807 if (c == NULL) 9808 { 9809 c = bfd_zalloc (abfd, section->size); 9810 if (c == NULL) 9811 return FALSE; 9812 mips_elf_section_data (section)->u.tdata = c; 9813 } 9814 9815 memcpy (c + offset, location, count); 9816 } 9817 9818 return _bfd_elf_set_section_contents (abfd, section, location, offset, 9819 count); 9820} 9821 9822/* This is almost identical to bfd_generic_get_... except that some 9823 MIPS relocations need to be handled specially. Sigh. */ 9824 9825bfd_byte * 9826_bfd_elf_mips_get_relocated_section_contents 9827 (bfd *abfd, 9828 struct bfd_link_info *link_info, 9829 struct bfd_link_order *link_order, 9830 bfd_byte *data, 9831 bfd_boolean relocatable, 9832 asymbol **symbols) 9833{ 9834 /* Get enough memory to hold the stuff */ 9835 bfd *input_bfd = link_order->u.indirect.section->owner; 9836 asection *input_section = link_order->u.indirect.section; 9837 bfd_size_type sz; 9838 9839 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 9840 arelent **reloc_vector = NULL; 9841 long reloc_count; 9842 9843 if (reloc_size < 0) 9844 goto error_return; 9845 9846 reloc_vector = bfd_malloc (reloc_size); 9847 if (reloc_vector == NULL && reloc_size != 0) 9848 goto error_return; 9849 9850 /* read in the section */ 9851 sz = input_section->rawsize ? input_section->rawsize : input_section->size; 9852 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz)) 9853 goto error_return; 9854 9855 reloc_count = bfd_canonicalize_reloc (input_bfd, 9856 input_section, 9857 reloc_vector, 9858 symbols); 9859 if (reloc_count < 0) 9860 goto error_return; 9861 9862 if (reloc_count > 0) 9863 { 9864 arelent **parent; 9865 /* for mips */ 9866 int gp_found; 9867 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */ 9868 9869 { 9870 struct bfd_hash_entry *h; 9871 struct bfd_link_hash_entry *lh; 9872 /* Skip all this stuff if we aren't mixing formats. */ 9873 if (abfd && input_bfd 9874 && abfd->xvec == input_bfd->xvec) 9875 lh = 0; 9876 else 9877 { 9878 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE); 9879 lh = (struct bfd_link_hash_entry *) h; 9880 } 9881 lookup: 9882 if (lh) 9883 { 9884 switch (lh->type) 9885 { 9886 case bfd_link_hash_undefined: 9887 case bfd_link_hash_undefweak: 9888 case bfd_link_hash_common: 9889 gp_found = 0; 9890 break; 9891 case bfd_link_hash_defined: 9892 case bfd_link_hash_defweak: 9893 gp_found = 1; 9894 gp = lh->u.def.value; 9895 break; 9896 case bfd_link_hash_indirect: 9897 case bfd_link_hash_warning: 9898 lh = lh->u.i.link; 9899 /* @@FIXME ignoring warning for now */ 9900 goto lookup; 9901 case bfd_link_hash_new: 9902 default: 9903 abort (); 9904 } 9905 } 9906 else 9907 gp_found = 0; 9908 } 9909 /* end mips */ 9910 for (parent = reloc_vector; *parent != NULL; parent++) 9911 { 9912 char *error_message = NULL; 9913 bfd_reloc_status_type r; 9914 9915 /* Specific to MIPS: Deal with relocation types that require 9916 knowing the gp of the output bfd. */ 9917 asymbol *sym = *(*parent)->sym_ptr_ptr; 9918 9919 /* If we've managed to find the gp and have a special 9920 function for the relocation then go ahead, else default 9921 to the generic handling. */ 9922 if (gp_found 9923 && (*parent)->howto->special_function 9924 == _bfd_mips_elf32_gprel16_reloc) 9925 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent, 9926 input_section, relocatable, 9927 data, gp); 9928 else 9929 r = bfd_perform_relocation (input_bfd, *parent, data, 9930 input_section, 9931 relocatable ? abfd : NULL, 9932 &error_message); 9933 9934 if (relocatable) 9935 { 9936 asection *os = input_section->output_section; 9937 9938 /* A partial link, so keep the relocs */ 9939 os->orelocation[os->reloc_count] = *parent; 9940 os->reloc_count++; 9941 } 9942 9943 if (r != bfd_reloc_ok) 9944 { 9945 switch (r) 9946 { 9947 case bfd_reloc_undefined: 9948 if (!((*link_info->callbacks->undefined_symbol) 9949 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 9950 input_bfd, input_section, (*parent)->address, TRUE))) 9951 goto error_return; 9952 break; 9953 case bfd_reloc_dangerous: 9954 BFD_ASSERT (error_message != NULL); 9955 if (!((*link_info->callbacks->reloc_dangerous) 9956 (link_info, error_message, input_bfd, input_section, 9957 (*parent)->address))) 9958 goto error_return; 9959 break; 9960 case bfd_reloc_overflow: 9961 if (!((*link_info->callbacks->reloc_overflow) 9962 (link_info, NULL, 9963 bfd_asymbol_name (*(*parent)->sym_ptr_ptr), 9964 (*parent)->howto->name, (*parent)->addend, 9965 input_bfd, input_section, (*parent)->address))) 9966 goto error_return; 9967 break; 9968 case bfd_reloc_outofrange: 9969 default: 9970 abort (); 9971 break; 9972 } 9973 9974 } 9975 } 9976 } 9977 if (reloc_vector != NULL) 9978 free (reloc_vector); 9979 return data; 9980 9981error_return: 9982 if (reloc_vector != NULL) 9983 free (reloc_vector); 9984 return NULL; 9985} 9986 9987/* Create a MIPS ELF linker hash table. */ 9988 9989struct bfd_link_hash_table * 9990_bfd_mips_elf_link_hash_table_create (bfd *abfd) 9991{ 9992 struct mips_elf_link_hash_table *ret; 9993 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table); 9994 9995 ret = bfd_malloc (amt); 9996 if (ret == NULL) 9997 return NULL; 9998 9999 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 10000 mips_elf_link_hash_newfunc, 10001 sizeof (struct mips_elf_link_hash_entry))) 10002 { 10003 free (ret); 10004 return NULL; 10005 } 10006 10007#if 0 10008 /* We no longer use this. */ 10009 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++) 10010 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1; 10011#endif 10012 ret->procedure_count = 0; 10013 ret->compact_rel_size = 0; 10014 ret->use_rld_obj_head = FALSE; 10015 ret->rld_value = 0; 10016 ret->mips16_stubs_seen = FALSE; 10017 ret->is_vxworks = FALSE; 10018 ret->srelbss = NULL; 10019 ret->sdynbss = NULL; 10020 ret->srelplt = NULL; 10021 ret->srelplt2 = NULL; 10022 ret->sgotplt = NULL; 10023 ret->splt = NULL; 10024 ret->plt_header_size = 0; 10025 ret->plt_entry_size = 0; 10026 ret->function_stub_size = 0; 10027 10028 return &ret->root.root; 10029} 10030 10031/* Likewise, but indicate that the target is VxWorks. */ 10032 10033struct bfd_link_hash_table * 10034_bfd_mips_vxworks_link_hash_table_create (bfd *abfd) 10035{ 10036 struct bfd_link_hash_table *ret; 10037 10038 ret = _bfd_mips_elf_link_hash_table_create (abfd); 10039 if (ret) 10040 { 10041 struct mips_elf_link_hash_table *htab; 10042 10043 htab = (struct mips_elf_link_hash_table *) ret; 10044 htab->is_vxworks = 1; 10045 } 10046 return ret; 10047} 10048 10049/* We need to use a special link routine to handle the .reginfo and 10050 the .mdebug sections. We need to merge all instances of these 10051 sections together, not write them all out sequentially. */ 10052 10053bfd_boolean 10054_bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info) 10055{ 10056 asection *o; 10057 struct bfd_link_order *p; 10058 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec; 10059 asection *rtproc_sec; 10060 Elf32_RegInfo reginfo; 10061 struct ecoff_debug_info debug; 10062 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 10063 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap; 10064 HDRR *symhdr = &debug.symbolic_header; 10065 void *mdebug_handle = NULL; 10066 asection *s; 10067 EXTR esym; 10068 unsigned int i; 10069 bfd_size_type amt; 10070 struct mips_elf_link_hash_table *htab; 10071 10072 static const char * const secname[] = 10073 { 10074 ".text", ".init", ".fini", ".data", 10075 ".rodata", ".sdata", ".sbss", ".bss" 10076 }; 10077 static const int sc[] = 10078 { 10079 scText, scInit, scFini, scData, 10080 scRData, scSData, scSBss, scBss 10081 }; 10082 10083 /* We'd carefully arranged the dynamic symbol indices, and then the 10084 generic size_dynamic_sections renumbered them out from under us. 10085 Rather than trying somehow to prevent the renumbering, just do 10086 the sort again. */ 10087 htab = mips_elf_hash_table (info); 10088 if (elf_hash_table (info)->dynamic_sections_created) 10089 { 10090 bfd *dynobj; 10091 asection *got; 10092 struct mips_got_info *g; 10093 bfd_size_type dynsecsymcount; 10094 10095 /* When we resort, we must tell mips_elf_sort_hash_table what 10096 the lowest index it may use is. That's the number of section 10097 symbols we're going to add. The generic ELF linker only 10098 adds these symbols when building a shared object. Note that 10099 we count the sections after (possibly) removing the .options 10100 section above. */ 10101 10102 dynsecsymcount = count_section_dynsyms (abfd, info); 10103 if (! mips_elf_sort_hash_table (info, dynsecsymcount + 1)) 10104 return FALSE; 10105 10106 /* Make sure we didn't grow the global .got region. */ 10107 dynobj = elf_hash_table (info)->dynobj; 10108 got = mips_elf_got_section (dynobj, FALSE); 10109 g = mips_elf_section_data (got)->u.got_info; 10110 10111 if (g->global_gotsym != NULL) 10112 BFD_ASSERT ((elf_hash_table (info)->dynsymcount 10113 - g->global_gotsym->dynindx) 10114 <= g->global_gotno); 10115 } 10116 10117 /* Get a value for the GP register. */ 10118 if (elf_gp (abfd) == 0) 10119 { 10120 struct bfd_link_hash_entry *h; 10121 10122 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 10123 if (h != NULL && h->type == bfd_link_hash_defined) 10124 elf_gp (abfd) = (h->u.def.value 10125 + h->u.def.section->output_section->vma 10126 + h->u.def.section->output_offset); 10127 else if (htab->is_vxworks 10128 && (h = bfd_link_hash_lookup (info->hash, 10129 "_GLOBAL_OFFSET_TABLE_", 10130 FALSE, FALSE, TRUE)) 10131 && h->type == bfd_link_hash_defined) 10132 elf_gp (abfd) = (h->u.def.section->output_section->vma 10133 + h->u.def.section->output_offset 10134 + h->u.def.value); 10135 else if (info->relocatable) 10136 { 10137 bfd_vma lo = MINUS_ONE; 10138 10139 /* Find the GP-relative section with the lowest offset. */ 10140 for (o = abfd->sections; o != NULL; o = o->next) 10141 if (o->vma < lo 10142 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL)) 10143 lo = o->vma; 10144 10145 /* And calculate GP relative to that. */ 10146 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info); 10147 } 10148 else 10149 { 10150 /* If the relocate_section function needs to do a reloc 10151 involving the GP value, it should make a reloc_dangerous 10152 callback to warn that GP is not defined. */ 10153 } 10154 } 10155 10156 /* Go through the sections and collect the .reginfo and .mdebug 10157 information. */ 10158 reginfo_sec = NULL; 10159 mdebug_sec = NULL; 10160 gptab_data_sec = NULL; 10161 gptab_bss_sec = NULL; 10162 for (o = abfd->sections; o != NULL; o = o->next) 10163 { 10164 if (strcmp (o->name, ".reginfo") == 0) 10165 { 10166 memset (®info, 0, sizeof reginfo); 10167 10168 /* We have found the .reginfo section in the output file. 10169 Look through all the link_orders comprising it and merge 10170 the information together. */ 10171 for (p = o->map_head.link_order; p != NULL; p = p->next) 10172 { 10173 asection *input_section; 10174 bfd *input_bfd; 10175 Elf32_External_RegInfo ext; 10176 Elf32_RegInfo sub; 10177 10178 if (p->type != bfd_indirect_link_order) 10179 { 10180 if (p->type == bfd_data_link_order) 10181 continue; 10182 abort (); 10183 } 10184 10185 input_section = p->u.indirect.section; 10186 input_bfd = input_section->owner; 10187 10188 if (! bfd_get_section_contents (input_bfd, input_section, 10189 &ext, 0, sizeof ext)) 10190 return FALSE; 10191 10192 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub); 10193 10194 reginfo.ri_gprmask |= sub.ri_gprmask; 10195 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0]; 10196 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1]; 10197 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2]; 10198 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3]; 10199 10200 /* ri_gp_value is set by the function 10201 mips_elf32_section_processing when the section is 10202 finally written out. */ 10203 10204 /* Hack: reset the SEC_HAS_CONTENTS flag so that 10205 elf_link_input_bfd ignores this section. */ 10206 input_section->flags &= ~SEC_HAS_CONTENTS; 10207 } 10208 10209 /* Size has been set in _bfd_mips_elf_always_size_sections. */ 10210 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo)); 10211 10212 /* Skip this section later on (I don't think this currently 10213 matters, but someday it might). */ 10214 o->map_head.link_order = NULL; 10215 10216 reginfo_sec = o; 10217 } 10218 10219 if (strcmp (o->name, ".mdebug") == 0) 10220 { 10221 struct extsym_info einfo; 10222 bfd_vma last; 10223 10224 /* We have found the .mdebug section in the output file. 10225 Look through all the link_orders comprising it and merge 10226 the information together. */ 10227 symhdr->magic = swap->sym_magic; 10228 /* FIXME: What should the version stamp be? */ 10229 symhdr->vstamp = 0; 10230 symhdr->ilineMax = 0; 10231 symhdr->cbLine = 0; 10232 symhdr->idnMax = 0; 10233 symhdr->ipdMax = 0; 10234 symhdr->isymMax = 0; 10235 symhdr->ioptMax = 0; 10236 symhdr->iauxMax = 0; 10237 symhdr->issMax = 0; 10238 symhdr->issExtMax = 0; 10239 symhdr->ifdMax = 0; 10240 symhdr->crfd = 0; 10241 symhdr->iextMax = 0; 10242 10243 /* We accumulate the debugging information itself in the 10244 debug_info structure. */ 10245 debug.line = NULL; 10246 debug.external_dnr = NULL; 10247 debug.external_pdr = NULL; 10248 debug.external_sym = NULL; 10249 debug.external_opt = NULL; 10250 debug.external_aux = NULL; 10251 debug.ss = NULL; 10252 debug.ssext = debug.ssext_end = NULL; 10253 debug.external_fdr = NULL; 10254 debug.external_rfd = NULL; 10255 debug.external_ext = debug.external_ext_end = NULL; 10256 10257 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info); 10258 if (mdebug_handle == NULL) 10259 return FALSE; 10260 10261 esym.jmptbl = 0; 10262 esym.cobol_main = 0; 10263 esym.weakext = 0; 10264 esym.reserved = 0; 10265 esym.ifd = ifdNil; 10266 esym.asym.iss = issNil; 10267 esym.asym.st = stLocal; 10268 esym.asym.reserved = 0; 10269 esym.asym.index = indexNil; 10270 last = 0; 10271 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++) 10272 { 10273 esym.asym.sc = sc[i]; 10274 s = bfd_get_section_by_name (abfd, secname[i]); 10275 if (s != NULL) 10276 { 10277 esym.asym.value = s->vma; 10278 last = s->vma + s->size; 10279 } 10280 else 10281 esym.asym.value = last; 10282 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap, 10283 secname[i], &esym)) 10284 return FALSE; 10285 } 10286 10287 for (p = o->map_head.link_order; p != NULL; p = p->next) 10288 { 10289 asection *input_section; 10290 bfd *input_bfd; 10291 const struct ecoff_debug_swap *input_swap; 10292 struct ecoff_debug_info input_debug; 10293 char *eraw_src; 10294 char *eraw_end; 10295 10296 if (p->type != bfd_indirect_link_order) 10297 { 10298 if (p->type == bfd_data_link_order) 10299 continue; 10300 abort (); 10301 } 10302 10303 input_section = p->u.indirect.section; 10304 input_bfd = input_section->owner; 10305 10306 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour 10307 || (get_elf_backend_data (input_bfd) 10308 ->elf_backend_ecoff_debug_swap) == NULL) 10309 { 10310 /* I don't know what a non MIPS ELF bfd would be 10311 doing with a .mdebug section, but I don't really 10312 want to deal with it. */ 10313 continue; 10314 } 10315 10316 input_swap = (get_elf_backend_data (input_bfd) 10317 ->elf_backend_ecoff_debug_swap); 10318 10319 BFD_ASSERT (p->size == input_section->size); 10320 10321 /* The ECOFF linking code expects that we have already 10322 read in the debugging information and set up an 10323 ecoff_debug_info structure, so we do that now. */ 10324 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section, 10325 &input_debug)) 10326 return FALSE; 10327 10328 if (! (bfd_ecoff_debug_accumulate 10329 (mdebug_handle, abfd, &debug, swap, input_bfd, 10330 &input_debug, input_swap, info))) 10331 return FALSE; 10332 10333 /* Loop through the external symbols. For each one with 10334 interesting information, try to find the symbol in 10335 the linker global hash table and save the information 10336 for the output external symbols. */ 10337 eraw_src = input_debug.external_ext; 10338 eraw_end = (eraw_src 10339 + (input_debug.symbolic_header.iextMax 10340 * input_swap->external_ext_size)); 10341 for (; 10342 eraw_src < eraw_end; 10343 eraw_src += input_swap->external_ext_size) 10344 { 10345 EXTR ext; 10346 const char *name; 10347 struct mips_elf_link_hash_entry *h; 10348 10349 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext); 10350 if (ext.asym.sc == scNil 10351 || ext.asym.sc == scUndefined 10352 || ext.asym.sc == scSUndefined) 10353 continue; 10354 10355 name = input_debug.ssext + ext.asym.iss; 10356 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info), 10357 name, FALSE, FALSE, TRUE); 10358 if (h == NULL || h->esym.ifd != -2) 10359 continue; 10360 10361 if (ext.ifd != -1) 10362 { 10363 BFD_ASSERT (ext.ifd 10364 < input_debug.symbolic_header.ifdMax); 10365 ext.ifd = input_debug.ifdmap[ext.ifd]; 10366 } 10367 10368 h->esym = ext; 10369 } 10370 10371 /* Free up the information we just read. */ 10372 free (input_debug.line); 10373 free (input_debug.external_dnr); 10374 free (input_debug.external_pdr); 10375 free (input_debug.external_sym); 10376 free (input_debug.external_opt); 10377 free (input_debug.external_aux); 10378 free (input_debug.ss); 10379 free (input_debug.ssext); 10380 free (input_debug.external_fdr); 10381 free (input_debug.external_rfd); 10382 free (input_debug.external_ext); 10383 10384 /* Hack: reset the SEC_HAS_CONTENTS flag so that 10385 elf_link_input_bfd ignores this section. */ 10386 input_section->flags &= ~SEC_HAS_CONTENTS; 10387 } 10388 10389 if (SGI_COMPAT (abfd) && info->shared) 10390 { 10391 /* Create .rtproc section. */ 10392 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc"); 10393 if (rtproc_sec == NULL) 10394 { 10395 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY 10396 | SEC_LINKER_CREATED | SEC_READONLY); 10397 10398 rtproc_sec = bfd_make_section_with_flags (abfd, 10399 ".rtproc", 10400 flags); 10401 if (rtproc_sec == NULL 10402 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4)) 10403 return FALSE; 10404 } 10405 10406 if (! mips_elf_create_procedure_table (mdebug_handle, abfd, 10407 info, rtproc_sec, 10408 &debug)) 10409 return FALSE; 10410 } 10411 10412 /* Build the external symbol information. */ 10413 einfo.abfd = abfd; 10414 einfo.info = info; 10415 einfo.debug = &debug; 10416 einfo.swap = swap; 10417 einfo.failed = FALSE; 10418 mips_elf_link_hash_traverse (mips_elf_hash_table (info), 10419 mips_elf_output_extsym, &einfo); 10420 if (einfo.failed) 10421 return FALSE; 10422 10423 /* Set the size of the .mdebug section. */ 10424 o->size = bfd_ecoff_debug_size (abfd, &debug, swap); 10425 10426 /* Skip this section later on (I don't think this currently 10427 matters, but someday it might). */ 10428 o->map_head.link_order = NULL; 10429 10430 mdebug_sec = o; 10431 } 10432 10433 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0) 10434 { 10435 const char *subname; 10436 unsigned int c; 10437 Elf32_gptab *tab; 10438 Elf32_External_gptab *ext_tab; 10439 unsigned int j; 10440 10441 /* The .gptab.sdata and .gptab.sbss sections hold 10442 information describing how the small data area would 10443 change depending upon the -G switch. These sections 10444 not used in executables files. */ 10445 if (! info->relocatable) 10446 { 10447 for (p = o->map_head.link_order; p != NULL; p = p->next) 10448 { 10449 asection *input_section; 10450 10451 if (p->type != bfd_indirect_link_order) 10452 { 10453 if (p->type == bfd_data_link_order) 10454 continue; 10455 abort (); 10456 } 10457 10458 input_section = p->u.indirect.section; 10459 10460 /* Hack: reset the SEC_HAS_CONTENTS flag so that 10461 elf_link_input_bfd ignores this section. */ 10462 input_section->flags &= ~SEC_HAS_CONTENTS; 10463 } 10464 10465 /* Skip this section later on (I don't think this 10466 currently matters, but someday it might). */ 10467 o->map_head.link_order = NULL; 10468 10469 /* Really remove the section. */ 10470 bfd_section_list_remove (abfd, o); 10471 --abfd->section_count; 10472 10473 continue; 10474 } 10475 10476 /* There is one gptab for initialized data, and one for 10477 uninitialized data. */ 10478 if (strcmp (o->name, ".gptab.sdata") == 0) 10479 gptab_data_sec = o; 10480 else if (strcmp (o->name, ".gptab.sbss") == 0) 10481 gptab_bss_sec = o; 10482 else 10483 { 10484 (*_bfd_error_handler) 10485 (_("%s: illegal section name `%s'"), 10486 bfd_get_filename (abfd), o->name); 10487 bfd_set_error (bfd_error_nonrepresentable_section); 10488 return FALSE; 10489 } 10490 10491 /* The linker script always combines .gptab.data and 10492 .gptab.sdata into .gptab.sdata, and likewise for 10493 .gptab.bss and .gptab.sbss. It is possible that there is 10494 no .sdata or .sbss section in the output file, in which 10495 case we must change the name of the output section. */ 10496 subname = o->name + sizeof ".gptab" - 1; 10497 if (bfd_get_section_by_name (abfd, subname) == NULL) 10498 { 10499 if (o == gptab_data_sec) 10500 o->name = ".gptab.data"; 10501 else 10502 o->name = ".gptab.bss"; 10503 subname = o->name + sizeof ".gptab" - 1; 10504 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL); 10505 } 10506 10507 /* Set up the first entry. */ 10508 c = 1; 10509 amt = c * sizeof (Elf32_gptab); 10510 tab = bfd_malloc (amt); 10511 if (tab == NULL) 10512 return FALSE; 10513 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd); 10514 tab[0].gt_header.gt_unused = 0; 10515 10516 /* Combine the input sections. */ 10517 for (p = o->map_head.link_order; p != NULL; p = p->next) 10518 { 10519 asection *input_section; 10520 bfd *input_bfd; 10521 bfd_size_type size; 10522 unsigned long last; 10523 bfd_size_type gpentry; 10524 10525 if (p->type != bfd_indirect_link_order) 10526 { 10527 if (p->type == bfd_data_link_order) 10528 continue; 10529 abort (); 10530 } 10531 10532 input_section = p->u.indirect.section; 10533 input_bfd = input_section->owner; 10534 10535 /* Combine the gptab entries for this input section one 10536 by one. We know that the input gptab entries are 10537 sorted by ascending -G value. */ 10538 size = input_section->size; 10539 last = 0; 10540 for (gpentry = sizeof (Elf32_External_gptab); 10541 gpentry < size; 10542 gpentry += sizeof (Elf32_External_gptab)) 10543 { 10544 Elf32_External_gptab ext_gptab; 10545 Elf32_gptab int_gptab; 10546 unsigned long val; 10547 unsigned long add; 10548 bfd_boolean exact; 10549 unsigned int look; 10550 10551 if (! (bfd_get_section_contents 10552 (input_bfd, input_section, &ext_gptab, gpentry, 10553 sizeof (Elf32_External_gptab)))) 10554 { 10555 free (tab); 10556 return FALSE; 10557 } 10558 10559 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab, 10560 &int_gptab); 10561 val = int_gptab.gt_entry.gt_g_value; 10562 add = int_gptab.gt_entry.gt_bytes - last; 10563 10564 exact = FALSE; 10565 for (look = 1; look < c; look++) 10566 { 10567 if (tab[look].gt_entry.gt_g_value >= val) 10568 tab[look].gt_entry.gt_bytes += add; 10569 10570 if (tab[look].gt_entry.gt_g_value == val) 10571 exact = TRUE; 10572 } 10573 10574 if (! exact) 10575 { 10576 Elf32_gptab *new_tab; 10577 unsigned int max; 10578 10579 /* We need a new table entry. */ 10580 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab); 10581 new_tab = bfd_realloc (tab, amt); 10582 if (new_tab == NULL) 10583 { 10584 free (tab); 10585 return FALSE; 10586 } 10587 tab = new_tab; 10588 tab[c].gt_entry.gt_g_value = val; 10589 tab[c].gt_entry.gt_bytes = add; 10590 10591 /* Merge in the size for the next smallest -G 10592 value, since that will be implied by this new 10593 value. */ 10594 max = 0; 10595 for (look = 1; look < c; look++) 10596 { 10597 if (tab[look].gt_entry.gt_g_value < val 10598 && (max == 0 10599 || (tab[look].gt_entry.gt_g_value 10600 > tab[max].gt_entry.gt_g_value))) 10601 max = look; 10602 } 10603 if (max != 0) 10604 tab[c].gt_entry.gt_bytes += 10605 tab[max].gt_entry.gt_bytes; 10606 10607 ++c; 10608 } 10609 10610 last = int_gptab.gt_entry.gt_bytes; 10611 } 10612 10613 /* Hack: reset the SEC_HAS_CONTENTS flag so that 10614 elf_link_input_bfd ignores this section. */ 10615 input_section->flags &= ~SEC_HAS_CONTENTS; 10616 } 10617 10618 /* The table must be sorted by -G value. */ 10619 if (c > 2) 10620 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare); 10621 10622 /* Swap out the table. */ 10623 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab); 10624 ext_tab = bfd_alloc (abfd, amt); 10625 if (ext_tab == NULL) 10626 { 10627 free (tab); 10628 return FALSE; 10629 } 10630 10631 for (j = 0; j < c; j++) 10632 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j); 10633 free (tab); 10634 10635 o->size = c * sizeof (Elf32_External_gptab); 10636 o->contents = (bfd_byte *) ext_tab; 10637 10638 /* Skip this section later on (I don't think this currently 10639 matters, but someday it might). */ 10640 o->map_head.link_order = NULL; 10641 } 10642 } 10643 10644 /* Invoke the regular ELF backend linker to do all the work. */ 10645 if (!bfd_elf_final_link (abfd, info)) 10646 return FALSE; 10647 10648 /* Now write out the computed sections. */ 10649 10650 if (reginfo_sec != NULL) 10651 { 10652 Elf32_External_RegInfo ext; 10653 10654 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext); 10655 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext)) 10656 return FALSE; 10657 } 10658 10659 if (mdebug_sec != NULL) 10660 { 10661 BFD_ASSERT (abfd->output_has_begun); 10662 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug, 10663 swap, info, 10664 mdebug_sec->filepos)) 10665 return FALSE; 10666 10667 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info); 10668 } 10669 10670 if (gptab_data_sec != NULL) 10671 { 10672 if (! bfd_set_section_contents (abfd, gptab_data_sec, 10673 gptab_data_sec->contents, 10674 0, gptab_data_sec->size)) 10675 return FALSE; 10676 } 10677 10678 if (gptab_bss_sec != NULL) 10679 { 10680 if (! bfd_set_section_contents (abfd, gptab_bss_sec, 10681 gptab_bss_sec->contents, 10682 0, gptab_bss_sec->size)) 10683 return FALSE; 10684 } 10685 10686 if (SGI_COMPAT (abfd)) 10687 { 10688 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc"); 10689 if (rtproc_sec != NULL) 10690 { 10691 if (! bfd_set_section_contents (abfd, rtproc_sec, 10692 rtproc_sec->contents, 10693 0, rtproc_sec->size)) 10694 return FALSE; 10695 } 10696 } 10697 10698 return TRUE; 10699} 10700 10701/* Structure for saying that BFD machine EXTENSION extends BASE. */ 10702 10703struct mips_mach_extension { 10704 unsigned long extension, base; 10705}; 10706 10707 10708/* An array describing how BFD machines relate to one another. The entries 10709 are ordered topologically with MIPS I extensions listed last. */ 10710 10711static const struct mips_mach_extension mips_mach_extensions[] = { 10712 /* MIPS64 extensions. */ 10713 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 }, 10714 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 }, 10715 10716 /* MIPS V extensions. */ 10717 { bfd_mach_mipsisa64, bfd_mach_mips5 }, 10718 10719 /* R10000 extensions. */ 10720 { bfd_mach_mips12000, bfd_mach_mips10000 }, 10721 10722 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core 10723 vr5400 ISA, but doesn't include the multimedia stuff. It seems 10724 better to allow vr5400 and vr5500 code to be merged anyway, since 10725 many libraries will just use the core ISA. Perhaps we could add 10726 some sort of ASE flag if this ever proves a problem. */ 10727 { bfd_mach_mips5500, bfd_mach_mips5400 }, 10728 { bfd_mach_mips5400, bfd_mach_mips5000 }, 10729 10730 /* MIPS IV extensions. */ 10731 { bfd_mach_mips5, bfd_mach_mips8000 }, 10732 { bfd_mach_mips10000, bfd_mach_mips8000 }, 10733 { bfd_mach_mips5000, bfd_mach_mips8000 }, 10734 { bfd_mach_mips7000, bfd_mach_mips8000 }, 10735 { bfd_mach_mips9000, bfd_mach_mips8000 }, 10736 10737 /* VR4100 extensions. */ 10738 { bfd_mach_mips4120, bfd_mach_mips4100 }, 10739 { bfd_mach_mips4111, bfd_mach_mips4100 }, 10740 10741 /* MIPS III extensions. */ 10742 { bfd_mach_mips8000, bfd_mach_mips4000 }, 10743 { bfd_mach_mips4650, bfd_mach_mips4000 }, 10744 { bfd_mach_mips4600, bfd_mach_mips4000 }, 10745 { bfd_mach_mips4400, bfd_mach_mips4000 }, 10746 { bfd_mach_mips4300, bfd_mach_mips4000 }, 10747 { bfd_mach_mips4100, bfd_mach_mips4000 }, 10748 { bfd_mach_mips4010, bfd_mach_mips4000 }, 10749 10750 /* MIPS32 extensions. */ 10751 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 }, 10752 10753 /* MIPS II extensions. */ 10754 { bfd_mach_mips4000, bfd_mach_mips6000 }, 10755 { bfd_mach_mipsisa32, bfd_mach_mips6000 }, 10756 10757 /* MIPS I extensions. */ 10758 { bfd_mach_mips6000, bfd_mach_mips3000 }, 10759 { bfd_mach_mips3900, bfd_mach_mips3000 } 10760}; 10761 10762 10763/* Return true if bfd machine EXTENSION is an extension of machine BASE. */ 10764 10765static bfd_boolean 10766mips_mach_extends_p (unsigned long base, unsigned long extension) 10767{ 10768 size_t i; 10769 10770 if (extension == base) 10771 return TRUE; 10772 10773 if (base == bfd_mach_mipsisa32 10774 && mips_mach_extends_p (bfd_mach_mipsisa64, extension)) 10775 return TRUE; 10776 10777 if (base == bfd_mach_mipsisa32r2 10778 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension)) 10779 return TRUE; 10780 10781 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++) 10782 if (extension == mips_mach_extensions[i].extension) 10783 { 10784 extension = mips_mach_extensions[i].base; 10785 if (extension == base) 10786 return TRUE; 10787 } 10788 10789 return FALSE; 10790} 10791 10792 10793/* Return true if the given ELF header flags describe a 32-bit binary. */ 10794 10795static bfd_boolean 10796mips_32bit_flags_p (flagword flags) 10797{ 10798 return ((flags & EF_MIPS_32BITMODE) != 0 10799 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32 10800 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32 10801 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1 10802 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2 10803 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32 10804 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2); 10805} 10806 10807 10808/* Merge backend specific data from an object file to the output 10809 object file when linking. */ 10810 10811bfd_boolean 10812_bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 10813{ 10814 flagword old_flags; 10815 flagword new_flags; 10816 bfd_boolean ok; 10817 bfd_boolean null_input_bfd = TRUE; 10818 asection *sec; 10819 10820 /* Check if we have the same endianess */ 10821 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 10822 { 10823 (*_bfd_error_handler) 10824 (_("%B: endianness incompatible with that of the selected emulation"), 10825 ibfd); 10826 return FALSE; 10827 } 10828 10829 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 10830 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 10831 return TRUE; 10832 10833 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0) 10834 { 10835 (*_bfd_error_handler) 10836 (_("%B: ABI is incompatible with that of the selected emulation"), 10837 ibfd); 10838 return FALSE; 10839 } 10840 10841 new_flags = elf_elfheader (ibfd)->e_flags; 10842 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER; 10843 old_flags = elf_elfheader (obfd)->e_flags; 10844 10845 if (! elf_flags_init (obfd)) 10846 { 10847 elf_flags_init (obfd) = TRUE; 10848 elf_elfheader (obfd)->e_flags = new_flags; 10849 elf_elfheader (obfd)->e_ident[EI_CLASS] 10850 = elf_elfheader (ibfd)->e_ident[EI_CLASS]; 10851 10852 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 10853 && bfd_get_arch_info (obfd)->the_default) 10854 { 10855 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 10856 bfd_get_mach (ibfd))) 10857 return FALSE; 10858 } 10859 10860 return TRUE; 10861 } 10862 10863 /* Check flag compatibility. */ 10864 10865 new_flags &= ~EF_MIPS_NOREORDER; 10866 old_flags &= ~EF_MIPS_NOREORDER; 10867 10868 /* Some IRIX 6 BSD-compatibility objects have this bit set. It 10869 doesn't seem to matter. */ 10870 new_flags &= ~EF_MIPS_XGOT; 10871 old_flags &= ~EF_MIPS_XGOT; 10872 10873 /* MIPSpro generates ucode info in n64 objects. Again, we should 10874 just be able to ignore this. */ 10875 new_flags &= ~EF_MIPS_UCODE; 10876 old_flags &= ~EF_MIPS_UCODE; 10877 10878 /* Don't care about the PIC flags from dynamic objects; they are 10879 PIC by design. */ 10880 if ((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0 10881 && (ibfd->flags & DYNAMIC) != 0) 10882 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC); 10883 10884 if (new_flags == old_flags) 10885 return TRUE; 10886 10887 /* Check to see if the input BFD actually contains any sections. 10888 If not, its flags may not have been initialised either, but it cannot 10889 actually cause any incompatibility. */ 10890 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 10891 { 10892 /* Ignore synthetic sections and empty .text, .data and .bss sections 10893 which are automatically generated by gas. */ 10894 if (strcmp (sec->name, ".reginfo") 10895 && strcmp (sec->name, ".mdebug") 10896 && (sec->size != 0 10897 || (strcmp (sec->name, ".text") 10898 && strcmp (sec->name, ".data") 10899 && strcmp (sec->name, ".bss")))) 10900 { 10901 null_input_bfd = FALSE; 10902 break; 10903 } 10904 } 10905 if (null_input_bfd) 10906 return TRUE; 10907 10908 ok = TRUE; 10909 10910 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0) 10911 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)) 10912 { 10913 (*_bfd_error_handler) 10914 (_("%B: warning: linking PIC files with non-PIC files"), 10915 ibfd); 10916 ok = TRUE; 10917 } 10918 10919 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) 10920 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC; 10921 if (! (new_flags & EF_MIPS_PIC)) 10922 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC; 10923 10924 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC); 10925 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC); 10926 10927 /* Compare the ISAs. */ 10928 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags)) 10929 { 10930 (*_bfd_error_handler) 10931 (_("%B: linking 32-bit code with 64-bit code"), 10932 ibfd); 10933 ok = FALSE; 10934 } 10935 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd))) 10936 { 10937 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */ 10938 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd))) 10939 { 10940 /* Copy the architecture info from IBFD to OBFD. Also copy 10941 the 32-bit flag (if set) so that we continue to recognise 10942 OBFD as a 32-bit binary. */ 10943 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd)); 10944 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH); 10945 elf_elfheader (obfd)->e_flags 10946 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 10947 10948 /* Copy across the ABI flags if OBFD doesn't use them 10949 and if that was what caused us to treat IBFD as 32-bit. */ 10950 if ((old_flags & EF_MIPS_ABI) == 0 10951 && mips_32bit_flags_p (new_flags) 10952 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI)) 10953 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI; 10954 } 10955 else 10956 { 10957 /* The ISAs aren't compatible. */ 10958 (*_bfd_error_handler) 10959 (_("%B: linking %s module with previous %s modules"), 10960 ibfd, 10961 bfd_printable_name (ibfd), 10962 bfd_printable_name (obfd)); 10963 ok = FALSE; 10964 } 10965 } 10966 10967 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 10968 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE); 10969 10970 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it 10971 does set EI_CLASS differently from any 32-bit ABI. */ 10972 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI) 10973 || (elf_elfheader (ibfd)->e_ident[EI_CLASS] 10974 != elf_elfheader (obfd)->e_ident[EI_CLASS])) 10975 { 10976 /* Only error if both are set (to different values). */ 10977 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI)) 10978 || (elf_elfheader (ibfd)->e_ident[EI_CLASS] 10979 != elf_elfheader (obfd)->e_ident[EI_CLASS])) 10980 { 10981 (*_bfd_error_handler) 10982 (_("%B: ABI mismatch: linking %s module with previous %s modules"), 10983 ibfd, 10984 elf_mips_abi_name (ibfd), 10985 elf_mips_abi_name (obfd)); 10986 ok = FALSE; 10987 } 10988 new_flags &= ~EF_MIPS_ABI; 10989 old_flags &= ~EF_MIPS_ABI; 10990 } 10991 10992 /* For now, allow arbitrary mixing of ASEs (retain the union). */ 10993 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE)) 10994 { 10995 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE; 10996 10997 new_flags &= ~ EF_MIPS_ARCH_ASE; 10998 old_flags &= ~ EF_MIPS_ARCH_ASE; 10999 } 11000 11001 /* Warn about any other mismatches */ 11002 if (new_flags != old_flags) 11003 { 11004 (*_bfd_error_handler) 11005 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), 11006 ibfd, (unsigned long) new_flags, 11007 (unsigned long) old_flags); 11008 ok = FALSE; 11009 } 11010 11011 if (! ok) 11012 { 11013 bfd_set_error (bfd_error_bad_value); 11014 return FALSE; 11015 } 11016 11017 return TRUE; 11018} 11019 11020/* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */ 11021 11022bfd_boolean 11023_bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags) 11024{ 11025 BFD_ASSERT (!elf_flags_init (abfd) 11026 || elf_elfheader (abfd)->e_flags == flags); 11027 11028 elf_elfheader (abfd)->e_flags = flags; 11029 elf_flags_init (abfd) = TRUE; 11030 return TRUE; 11031} 11032 11033bfd_boolean 11034_bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr) 11035{ 11036 FILE *file = ptr; 11037 11038 BFD_ASSERT (abfd != NULL && ptr != NULL); 11039 11040 /* Print normal ELF private data. */ 11041 _bfd_elf_print_private_bfd_data (abfd, ptr); 11042 11043 /* xgettext:c-format */ 11044 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 11045 11046 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32) 11047 fprintf (file, _(" [abi=O32]")); 11048 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64) 11049 fprintf (file, _(" [abi=O64]")); 11050 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32) 11051 fprintf (file, _(" [abi=EABI32]")); 11052 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64) 11053 fprintf (file, _(" [abi=EABI64]")); 11054 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI)) 11055 fprintf (file, _(" [abi unknown]")); 11056 else if (ABI_N32_P (abfd)) 11057 fprintf (file, _(" [abi=N32]")); 11058 else if (ABI_64_P (abfd)) 11059 fprintf (file, _(" [abi=64]")); 11060 else 11061 fprintf (file, _(" [no abi set]")); 11062 11063 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1) 11064 fprintf (file, _(" [mips1]")); 11065 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2) 11066 fprintf (file, _(" [mips2]")); 11067 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3) 11068 fprintf (file, _(" [mips3]")); 11069 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4) 11070 fprintf (file, _(" [mips4]")); 11071 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5) 11072 fprintf (file, _(" [mips5]")); 11073 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32) 11074 fprintf (file, _(" [mips32]")); 11075 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64) 11076 fprintf (file, _(" [mips64]")); 11077 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2) 11078 fprintf (file, _(" [mips32r2]")); 11079 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2) 11080 fprintf (file, _(" [mips64r2]")); 11081 else 11082 fprintf (file, _(" [unknown ISA]")); 11083 11084 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX) 11085 fprintf (file, _(" [mdmx]")); 11086 11087 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16) 11088 fprintf (file, _(" [mips16]")); 11089 11090 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE) 11091 fprintf (file, _(" [32bitmode]")); 11092 else 11093 fprintf (file, _(" [not 32bitmode]")); 11094 11095 fputc ('\n', file); 11096 11097 return TRUE; 11098} 11099 11100const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] = 11101{ 11102 { ".lit4", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 11103 { ".lit8", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 11104 { ".mdebug", 7, 0, SHT_MIPS_DEBUG, 0 }, 11105 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 11106 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL }, 11107 { ".ucode", 6, 0, SHT_MIPS_UCODE, 0 }, 11108 { NULL, 0, 0, 0, 0 } 11109}; 11110 11111/* Ensure that the STO_OPTIONAL flag is copied into h->other, 11112 even if this is not a defintion of the symbol. */ 11113void 11114_bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h, 11115 const Elf_Internal_Sym *isym, 11116 bfd_boolean definition, 11117 bfd_boolean dynamic ATTRIBUTE_UNUSED) 11118{ 11119 if (! definition 11120 && ELF_MIPS_IS_OPTIONAL (isym->st_other)) 11121 h->other |= STO_OPTIONAL; 11122} 11123 11124/* Decide whether an undefined symbol is special and can be ignored. 11125 This is the case for OPTIONAL symbols on IRIX. */ 11126bfd_boolean 11127_bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h) 11128{ 11129 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE; 11130} 11131