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