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