1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry
*h
;
68 /* The TLS types included in this GOT entry (specifically, GD and
69 IE). The GD and IE flags can be added as we encounter new
70 relocations. LDM can also be set; it will always be alone, not
71 combined with any GD or IE flags. An LDM GOT entry will be
72 a local symbol entry with r_symndx == 0. */
73 unsigned char tls_type
;
75 /* The offset from the beginning of the .got section to the entry
76 corresponding to this symbol+addend. If it's a global symbol
77 whose offset is yet to be decided, it's going to be -1. */
81 /* This structure is used to hold .got information when linking. */
85 /* The global symbol in the GOT with the lowest index in the dynamic
87 struct elf_link_hash_entry
*global_gotsym
;
88 /* The number of global .got entries. */
89 unsigned int global_gotno
;
90 /* The number of .got slots used for TLS. */
91 unsigned int tls_gotno
;
92 /* The first unused TLS .got entry. Used only during
93 mips_elf_initialize_tls_index. */
94 unsigned int tls_assigned_gotno
;
95 /* The number of local .got entries. */
96 unsigned int local_gotno
;
97 /* The number of local .got entries we have used. */
98 unsigned int assigned_gotno
;
99 /* A hash table holding members of the got. */
100 struct htab
*got_entries
;
101 /* A hash table mapping input bfds to other mips_got_info. NULL
102 unless multi-got was necessary. */
103 struct htab
*bfd2got
;
104 /* In multi-got links, a pointer to the next got (err, rather, most
105 of the time, it points to the previous got). */
106 struct mips_got_info
*next
;
107 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
108 for none, or MINUS_TWO for not yet assigned. This is needed
109 because a single-GOT link may have multiple hash table entries
110 for the LDM. It does not get initialized in multi-GOT mode. */
111 bfd_vma tls_ldm_offset
;
114 /* Map an input bfd to a got in a multi-got link. */
116 struct mips_elf_bfd2got_hash
{
118 struct mips_got_info
*g
;
121 /* Structure passed when traversing the bfd2got hash table, used to
122 create and merge bfd's gots. */
124 struct mips_elf_got_per_bfd_arg
126 /* A hashtable that maps bfds to gots. */
128 /* The output bfd. */
130 /* The link information. */
131 struct bfd_link_info
*info
;
132 /* A pointer to the primary got, i.e., the one that's going to get
133 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
135 struct mips_got_info
*primary
;
136 /* A non-primary got we're trying to merge with other input bfd's
138 struct mips_got_info
*current
;
139 /* The maximum number of got entries that can be addressed with a
141 unsigned int max_count
;
142 /* The number of local and global entries in the primary got. */
143 unsigned int primary_count
;
144 /* The number of local and global entries in the current got. */
145 unsigned int current_count
;
146 /* The total number of global entries which will live in the
147 primary got and be automatically relocated. This includes
148 those not referenced by the primary GOT but included in
150 unsigned int global_count
;
153 /* Another structure used to pass arguments for got entries traversal. */
155 struct mips_elf_set_global_got_offset_arg
157 struct mips_got_info
*g
;
159 unsigned int needed_relocs
;
160 struct bfd_link_info
*info
;
163 /* A structure used to count TLS relocations or GOT entries, for GOT
164 entry or ELF symbol table traversal. */
166 struct mips_elf_count_tls_arg
168 struct bfd_link_info
*info
;
172 struct _mips_elf_section_data
174 struct bfd_elf_section_data elf
;
177 struct mips_got_info
*got_info
;
182 #define mips_elf_section_data(sec) \
183 ((struct _mips_elf_section_data *) elf_section_data (sec))
185 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
186 the dynamic symbols. */
188 struct mips_elf_hash_sort_data
190 /* The symbol in the global GOT with the lowest dynamic symbol table
192 struct elf_link_hash_entry
*low
;
193 /* The least dynamic symbol table index corresponding to a non-TLS
194 symbol with a GOT entry. */
195 long min_got_dynindx
;
196 /* The greatest dynamic symbol table index corresponding to a symbol
197 with a GOT entry that is not referenced (e.g., a dynamic symbol
198 with dynamic relocations pointing to it from non-primary GOTs). */
199 long max_unref_got_dynindx
;
200 /* The greatest dynamic symbol table index not corresponding to a
201 symbol without a GOT entry. */
202 long max_non_got_dynindx
;
205 /* The MIPS ELF linker needs additional information for each symbol in
206 the global hash table. */
208 struct mips_elf_link_hash_entry
210 struct elf_link_hash_entry root
;
212 /* External symbol information. */
215 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
217 unsigned int possibly_dynamic_relocs
;
219 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
220 a readonly section. */
221 bfd_boolean readonly_reloc
;
223 /* We must not create a stub for a symbol that has relocations
224 related to taking the function's address, i.e. any but
225 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
227 bfd_boolean no_fn_stub
;
229 /* If there is a stub that 32 bit functions should use to call this
230 16 bit function, this points to the section containing the stub. */
233 /* Whether we need the fn_stub; this is set if this symbol appears
234 in any relocs other than a 16 bit call. */
235 bfd_boolean need_fn_stub
;
237 /* If there is a stub that 16 bit functions should use to call this
238 32 bit function, this points to the section containing the stub. */
241 /* This is like the call_stub field, but it is used if the function
242 being called returns a floating point value. */
243 asection
*call_fp_stub
;
245 /* Are we forced local? .*/
246 bfd_boolean forced_local
;
250 #define GOT_TLS_LDM 2
252 #define GOT_TLS_OFFSET_DONE 0x40
253 #define GOT_TLS_DONE 0x80
254 unsigned char tls_type
;
255 /* This is only used in single-GOT mode; in multi-GOT mode there
256 is one mips_got_entry per GOT entry, so the offset is stored
257 there. In single-GOT mode there may be many mips_got_entry
258 structures all referring to the same GOT slot. It might be
259 possible to use root.got.offset instead, but that field is
260 overloaded already. */
261 bfd_vma tls_got_offset
;
264 /* MIPS ELF linker hash table. */
266 struct mips_elf_link_hash_table
268 struct elf_link_hash_table root
;
270 /* We no longer use this. */
271 /* String section indices for the dynamic section symbols. */
272 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
274 /* The number of .rtproc entries. */
275 bfd_size_type procedure_count
;
276 /* The size of the .compact_rel section (if SGI_COMPAT). */
277 bfd_size_type compact_rel_size
;
278 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
279 entry is set to the address of __rld_obj_head as in IRIX5. */
280 bfd_boolean use_rld_obj_head
;
281 /* This is the value of the __rld_map or __rld_obj_head symbol. */
283 /* This is set if we see any mips16 stub sections. */
284 bfd_boolean mips16_stubs_seen
;
287 #define TLS_RELOC_P(r_type) \
288 (r_type == R_MIPS_TLS_DTPMOD32 \
289 || r_type == R_MIPS_TLS_DTPMOD64 \
290 || r_type == R_MIPS_TLS_DTPREL32 \
291 || r_type == R_MIPS_TLS_DTPREL64 \
292 || r_type == R_MIPS_TLS_GD \
293 || r_type == R_MIPS_TLS_LDM \
294 || r_type == R_MIPS_TLS_DTPREL_HI16 \
295 || r_type == R_MIPS_TLS_DTPREL_LO16 \
296 || r_type == R_MIPS_TLS_GOTTPREL \
297 || r_type == R_MIPS_TLS_TPREL32 \
298 || r_type == R_MIPS_TLS_TPREL64 \
299 || r_type == R_MIPS_TLS_TPREL_HI16 \
300 || r_type == R_MIPS_TLS_TPREL_LO16)
302 /* Structure used to pass information to mips_elf_output_extsym. */
307 struct bfd_link_info
*info
;
308 struct ecoff_debug_info
*debug
;
309 const struct ecoff_debug_swap
*swap
;
313 /* The names of the runtime procedure table symbols used on IRIX5. */
315 static const char * const mips_elf_dynsym_rtproc_names
[] =
318 "_procedure_string_table",
319 "_procedure_table_size",
323 /* These structures are used to generate the .compact_rel section on
328 unsigned long id1
; /* Always one? */
329 unsigned long num
; /* Number of compact relocation entries. */
330 unsigned long id2
; /* Always two? */
331 unsigned long offset
; /* The file offset of the first relocation. */
332 unsigned long reserved0
; /* Zero? */
333 unsigned long reserved1
; /* Zero? */
342 bfd_byte reserved0
[4];
343 bfd_byte reserved1
[4];
344 } Elf32_External_compact_rel
;
348 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
349 unsigned int rtype
: 4; /* Relocation types. See below. */
350 unsigned int dist2to
: 8;
351 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
352 unsigned long konst
; /* KONST field. See below. */
353 unsigned long vaddr
; /* VADDR to be relocated. */
358 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
359 unsigned int rtype
: 4; /* Relocation types. See below. */
360 unsigned int dist2to
: 8;
361 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
362 unsigned long konst
; /* KONST field. See below. */
370 } Elf32_External_crinfo
;
376 } Elf32_External_crinfo2
;
378 /* These are the constants used to swap the bitfields in a crinfo. */
380 #define CRINFO_CTYPE (0x1)
381 #define CRINFO_CTYPE_SH (31)
382 #define CRINFO_RTYPE (0xf)
383 #define CRINFO_RTYPE_SH (27)
384 #define CRINFO_DIST2TO (0xff)
385 #define CRINFO_DIST2TO_SH (19)
386 #define CRINFO_RELVADDR (0x7ffff)
387 #define CRINFO_RELVADDR_SH (0)
389 /* A compact relocation info has long (3 words) or short (2 words)
390 formats. A short format doesn't have VADDR field and relvaddr
391 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
392 #define CRF_MIPS_LONG 1
393 #define CRF_MIPS_SHORT 0
395 /* There are 4 types of compact relocation at least. The value KONST
396 has different meaning for each type:
399 CT_MIPS_REL32 Address in data
400 CT_MIPS_WORD Address in word (XXX)
401 CT_MIPS_GPHI_LO GP - vaddr
402 CT_MIPS_JMPAD Address to jump
405 #define CRT_MIPS_REL32 0xa
406 #define CRT_MIPS_WORD 0xb
407 #define CRT_MIPS_GPHI_LO 0xc
408 #define CRT_MIPS_JMPAD 0xd
410 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
411 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
412 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
413 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
415 /* The structure of the runtime procedure descriptor created by the
416 loader for use by the static exception system. */
418 typedef struct runtime_pdr
{
419 bfd_vma adr
; /* Memory address of start of procedure. */
420 long regmask
; /* Save register mask. */
421 long regoffset
; /* Save register offset. */
422 long fregmask
; /* Save floating point register mask. */
423 long fregoffset
; /* Save floating point register offset. */
424 long frameoffset
; /* Frame size. */
425 short framereg
; /* Frame pointer register. */
426 short pcreg
; /* Offset or reg of return pc. */
427 long irpss
; /* Index into the runtime string table. */
429 struct exception_info
*exception_info
;/* Pointer to exception array. */
431 #define cbRPDR sizeof (RPDR)
432 #define rpdNil ((pRPDR) 0)
434 static struct mips_got_entry
*mips_elf_create_local_got_entry
435 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
, unsigned long,
436 struct mips_elf_link_hash_entry
*, int);
437 static bfd_boolean mips_elf_sort_hash_table_f
438 (struct mips_elf_link_hash_entry
*, void *);
439 static bfd_vma mips_elf_high
441 static bfd_boolean mips_elf_stub_section_p
443 static bfd_boolean mips_elf_create_dynamic_relocation
444 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
445 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
446 bfd_vma
*, asection
*);
447 static hashval_t mips_elf_got_entry_hash
449 static bfd_vma mips_elf_adjust_gp
450 (bfd
*, struct mips_got_info
*, bfd
*);
451 static struct mips_got_info
*mips_elf_got_for_ibfd
452 (struct mips_got_info
*, bfd
*);
454 /* This will be used when we sort the dynamic relocation records. */
455 static bfd
*reldyn_sorting_bfd
;
457 /* Nonzero if ABFD is using the N32 ABI. */
459 #define ABI_N32_P(abfd) \
460 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
462 /* Nonzero if ABFD is using the N64 ABI. */
463 #define ABI_64_P(abfd) \
464 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
466 /* Nonzero if ABFD is using NewABI conventions. */
467 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
469 /* The IRIX compatibility level we are striving for. */
470 #define IRIX_COMPAT(abfd) \
471 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
473 /* Whether we are trying to be compatible with IRIX at all. */
474 #define SGI_COMPAT(abfd) \
475 (IRIX_COMPAT (abfd) != ict_none)
477 /* The name of the options section. */
478 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
479 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
481 /* Whether the section is readonly. */
482 #define MIPS_ELF_READONLY_SECTION(sec) \
483 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
484 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
486 /* The name of the stub section. */
487 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
489 /* The size of an external REL relocation. */
490 #define MIPS_ELF_REL_SIZE(abfd) \
491 (get_elf_backend_data (abfd)->s->sizeof_rel)
493 /* The size of an external dynamic table entry. */
494 #define MIPS_ELF_DYN_SIZE(abfd) \
495 (get_elf_backend_data (abfd)->s->sizeof_dyn)
497 /* The size of a GOT entry. */
498 #define MIPS_ELF_GOT_SIZE(abfd) \
499 (get_elf_backend_data (abfd)->s->arch_size / 8)
501 /* The size of a symbol-table entry. */
502 #define MIPS_ELF_SYM_SIZE(abfd) \
503 (get_elf_backend_data (abfd)->s->sizeof_sym)
505 /* The default alignment for sections, as a power of two. */
506 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
507 (get_elf_backend_data (abfd)->s->log_file_align)
509 /* Get word-sized data. */
510 #define MIPS_ELF_GET_WORD(abfd, ptr) \
511 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
513 /* Put out word-sized data. */
514 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
516 ? bfd_put_64 (abfd, val, ptr) \
517 : bfd_put_32 (abfd, val, ptr))
519 /* Add a dynamic symbol table-entry. */
520 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
521 _bfd_elf_add_dynamic_entry (info, tag, val)
523 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
524 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
526 /* Determine whether the internal relocation of index REL_IDX is REL
527 (zero) or RELA (non-zero). The assumption is that, if there are
528 two relocation sections for this section, one of them is REL and
529 the other is RELA. If the index of the relocation we're testing is
530 in range for the first relocation section, check that the external
531 relocation size is that for RELA. It is also assumed that, if
532 rel_idx is not in range for the first section, and this first
533 section contains REL relocs, then the relocation is in the second
534 section, that is RELA. */
535 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
536 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
537 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
538 > (bfd_vma)(rel_idx)) \
539 == (elf_section_data (sec)->rel_hdr.sh_entsize \
540 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
541 : sizeof (Elf32_External_Rela))))
543 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
544 from smaller values. Start with zero, widen, *then* decrement. */
545 #define MINUS_ONE (((bfd_vma)0) - 1)
546 #define MINUS_TWO (((bfd_vma)0) - 2)
548 /* The number of local .got entries we reserve. */
549 #define MIPS_RESERVED_GOTNO (2)
551 /* The offset of $gp from the beginning of the .got section. */
552 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
554 /* The maximum size of the GOT for it to be addressable using 16-bit
556 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
558 /* Instructions which appear in a stub. */
559 #define STUB_LW(abfd) \
561 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
562 : 0x8f998010)) /* lw t9,0x8010(gp) */
563 #define STUB_MOVE(abfd) \
565 ? 0x03e0782d /* daddu t7,ra */ \
566 : 0x03e07821)) /* addu t7,ra */
567 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
568 #define STUB_LI16(abfd) \
570 ? 0x64180000 /* daddiu t8,zero,0 */ \
571 : 0x24180000)) /* addiu t8,zero,0 */
572 #define MIPS_FUNCTION_STUB_SIZE (16)
574 /* The name of the dynamic interpreter. This is put in the .interp
577 #define ELF_DYNAMIC_INTERPRETER(abfd) \
578 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
579 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
580 : "/usr/lib/libc.so.1")
583 #define MNAME(bfd,pre,pos) \
584 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
585 #define ELF_R_SYM(bfd, i) \
586 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
587 #define ELF_R_TYPE(bfd, i) \
588 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
589 #define ELF_R_INFO(bfd, s, t) \
590 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
592 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
593 #define ELF_R_SYM(bfd, i) \
595 #define ELF_R_TYPE(bfd, i) \
597 #define ELF_R_INFO(bfd, s, t) \
598 (ELF32_R_INFO (s, t))
601 /* The mips16 compiler uses a couple of special sections to handle
602 floating point arguments.
604 Section names that look like .mips16.fn.FNNAME contain stubs that
605 copy floating point arguments from the fp regs to the gp regs and
606 then jump to FNNAME. If any 32 bit function calls FNNAME, the
607 call should be redirected to the stub instead. If no 32 bit
608 function calls FNNAME, the stub should be discarded. We need to
609 consider any reference to the function, not just a call, because
610 if the address of the function is taken we will need the stub,
611 since the address might be passed to a 32 bit function.
613 Section names that look like .mips16.call.FNNAME contain stubs
614 that copy floating point arguments from the gp regs to the fp
615 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
616 then any 16 bit function that calls FNNAME should be redirected
617 to the stub instead. If FNNAME is not a 32 bit function, the
618 stub should be discarded.
620 .mips16.call.fp.FNNAME sections are similar, but contain stubs
621 which call FNNAME and then copy the return value from the fp regs
622 to the gp regs. These stubs store the return value in $18 while
623 calling FNNAME; any function which might call one of these stubs
624 must arrange to save $18 around the call. (This case is not
625 needed for 32 bit functions that call 16 bit functions, because
626 16 bit functions always return floating point values in both
629 Note that in all cases FNNAME might be defined statically.
630 Therefore, FNNAME is not used literally. Instead, the relocation
631 information will indicate which symbol the section is for.
633 We record any stubs that we find in the symbol table. */
635 #define FN_STUB ".mips16.fn."
636 #define CALL_STUB ".mips16.call."
637 #define CALL_FP_STUB ".mips16.call.fp."
639 /* Look up an entry in a MIPS ELF linker hash table. */
641 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
642 ((struct mips_elf_link_hash_entry *) \
643 elf_link_hash_lookup (&(table)->root, (string), (create), \
646 /* Traverse a MIPS ELF linker hash table. */
648 #define mips_elf_link_hash_traverse(table, func, info) \
649 (elf_link_hash_traverse \
651 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
654 /* Get the MIPS ELF linker hash table from a link_info structure. */
656 #define mips_elf_hash_table(p) \
657 ((struct mips_elf_link_hash_table *) ((p)->hash))
659 /* Find the base offsets for thread-local storage in this object,
660 for GD/LD and IE/LE respectively. */
662 #define TP_OFFSET 0x7000
663 #define DTP_OFFSET 0x8000
666 dtprel_base (struct bfd_link_info
*info
)
668 /* If tls_sec is NULL, we should have signalled an error already. */
669 if (elf_hash_table (info
)->tls_sec
== NULL
)
671 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
675 tprel_base (struct bfd_link_info
*info
)
677 /* If tls_sec is NULL, we should have signalled an error already. */
678 if (elf_hash_table (info
)->tls_sec
== NULL
)
680 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
683 /* Create an entry in a MIPS ELF linker hash table. */
685 static struct bfd_hash_entry
*
686 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
687 struct bfd_hash_table
*table
, const char *string
)
689 struct mips_elf_link_hash_entry
*ret
=
690 (struct mips_elf_link_hash_entry
*) entry
;
692 /* Allocate the structure if it has not already been allocated by a
695 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
697 return (struct bfd_hash_entry
*) ret
;
699 /* Call the allocation method of the superclass. */
700 ret
= ((struct mips_elf_link_hash_entry
*)
701 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
705 /* Set local fields. */
706 memset (&ret
->esym
, 0, sizeof (EXTR
));
707 /* We use -2 as a marker to indicate that the information has
708 not been set. -1 means there is no associated ifd. */
710 ret
->possibly_dynamic_relocs
= 0;
711 ret
->readonly_reloc
= FALSE
;
712 ret
->no_fn_stub
= FALSE
;
714 ret
->need_fn_stub
= FALSE
;
715 ret
->call_stub
= NULL
;
716 ret
->call_fp_stub
= NULL
;
717 ret
->forced_local
= FALSE
;
718 ret
->tls_type
= GOT_NORMAL
;
721 return (struct bfd_hash_entry
*) ret
;
725 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
727 struct _mips_elf_section_data
*sdata
;
728 bfd_size_type amt
= sizeof (*sdata
);
730 sdata
= bfd_zalloc (abfd
, amt
);
733 sec
->used_by_bfd
= sdata
;
735 return _bfd_elf_new_section_hook (abfd
, sec
);
738 /* Read ECOFF debugging information from a .mdebug section into a
739 ecoff_debug_info structure. */
742 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
743 struct ecoff_debug_info
*debug
)
746 const struct ecoff_debug_swap
*swap
;
749 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
750 memset (debug
, 0, sizeof (*debug
));
752 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
753 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
756 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
757 swap
->external_hdr_size
))
760 symhdr
= &debug
->symbolic_header
;
761 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
763 /* The symbolic header contains absolute file offsets and sizes to
765 #define READ(ptr, offset, count, size, type) \
766 if (symhdr->count == 0) \
770 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
771 debug->ptr = bfd_malloc (amt); \
772 if (debug->ptr == NULL) \
774 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
775 || bfd_bread (debug->ptr, amt, abfd) != amt) \
779 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
780 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
781 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
782 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
783 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
784 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
786 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
787 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
788 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
789 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
790 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
800 if (debug
->line
!= NULL
)
802 if (debug
->external_dnr
!= NULL
)
803 free (debug
->external_dnr
);
804 if (debug
->external_pdr
!= NULL
)
805 free (debug
->external_pdr
);
806 if (debug
->external_sym
!= NULL
)
807 free (debug
->external_sym
);
808 if (debug
->external_opt
!= NULL
)
809 free (debug
->external_opt
);
810 if (debug
->external_aux
!= NULL
)
811 free (debug
->external_aux
);
812 if (debug
->ss
!= NULL
)
814 if (debug
->ssext
!= NULL
)
816 if (debug
->external_fdr
!= NULL
)
817 free (debug
->external_fdr
);
818 if (debug
->external_rfd
!= NULL
)
819 free (debug
->external_rfd
);
820 if (debug
->external_ext
!= NULL
)
821 free (debug
->external_ext
);
825 /* Swap RPDR (runtime procedure table entry) for output. */
828 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
830 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
831 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
832 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
833 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
834 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
835 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
837 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
838 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
840 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
843 /* Create a runtime procedure table from the .mdebug section. */
846 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
847 struct bfd_link_info
*info
, asection
*s
,
848 struct ecoff_debug_info
*debug
)
850 const struct ecoff_debug_swap
*swap
;
851 HDRR
*hdr
= &debug
->symbolic_header
;
853 struct rpdr_ext
*erp
;
855 struct pdr_ext
*epdr
;
856 struct sym_ext
*esym
;
861 unsigned long sindex
;
865 const char *no_name_func
= _("static procedure (no name)");
873 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
875 sindex
= strlen (no_name_func
) + 1;
879 size
= swap
->external_pdr_size
;
881 epdr
= bfd_malloc (size
* count
);
885 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
888 size
= sizeof (RPDR
);
889 rp
= rpdr
= bfd_malloc (size
* count
);
893 size
= sizeof (char *);
894 sv
= bfd_malloc (size
* count
);
898 count
= hdr
->isymMax
;
899 size
= swap
->external_sym_size
;
900 esym
= bfd_malloc (size
* count
);
904 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
908 ss
= bfd_malloc (count
);
911 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
915 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
917 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
918 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
920 rp
->regmask
= pdr
.regmask
;
921 rp
->regoffset
= pdr
.regoffset
;
922 rp
->fregmask
= pdr
.fregmask
;
923 rp
->fregoffset
= pdr
.fregoffset
;
924 rp
->frameoffset
= pdr
.frameoffset
;
925 rp
->framereg
= pdr
.framereg
;
926 rp
->pcreg
= pdr
.pcreg
;
928 sv
[i
] = ss
+ sym
.iss
;
929 sindex
+= strlen (sv
[i
]) + 1;
933 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
934 size
= BFD_ALIGN (size
, 16);
935 rtproc
= bfd_alloc (abfd
, size
);
938 mips_elf_hash_table (info
)->procedure_count
= 0;
942 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
945 memset (erp
, 0, sizeof (struct rpdr_ext
));
947 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
948 strcpy (str
, no_name_func
);
949 str
+= strlen (no_name_func
) + 1;
950 for (i
= 0; i
< count
; i
++)
952 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
954 str
+= strlen (sv
[i
]) + 1;
956 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
958 /* Set the size and contents of .rtproc section. */
960 s
->contents
= rtproc
;
962 /* Skip this section later on (I don't think this currently
963 matters, but someday it might). */
964 s
->link_order_head
= NULL
;
993 /* Check the mips16 stubs for a particular symbol, and see if we can
997 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
998 void *data ATTRIBUTE_UNUSED
)
1000 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1001 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1003 if (h
->fn_stub
!= NULL
1004 && ! h
->need_fn_stub
)
1006 /* We don't need the fn_stub; the only references to this symbol
1007 are 16 bit calls. Clobber the size to 0 to prevent it from
1008 being included in the link. */
1009 h
->fn_stub
->size
= 0;
1010 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1011 h
->fn_stub
->reloc_count
= 0;
1012 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1015 if (h
->call_stub
!= NULL
1016 && h
->root
.other
== STO_MIPS16
)
1018 /* We don't need the call_stub; this is a 16 bit function, so
1019 calls from other 16 bit functions are OK. Clobber the size
1020 to 0 to prevent it from being included in the link. */
1021 h
->call_stub
->size
= 0;
1022 h
->call_stub
->flags
&= ~SEC_RELOC
;
1023 h
->call_stub
->reloc_count
= 0;
1024 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1027 if (h
->call_fp_stub
!= NULL
1028 && h
->root
.other
== STO_MIPS16
)
1030 /* We don't need the call_stub; this is a 16 bit function, so
1031 calls from other 16 bit functions are OK. Clobber the size
1032 to 0 to prevent it from being included in the link. */
1033 h
->call_fp_stub
->size
= 0;
1034 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1035 h
->call_fp_stub
->reloc_count
= 0;
1036 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1042 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1043 Most mips16 instructions are 16 bits, but these instructions
1046 The format of these instructions is:
1048 +--------------+--------------------------------+
1049 | JALX | X| Imm 20:16 | Imm 25:21 |
1050 +--------------+--------------------------------+
1052 +-----------------------------------------------+
1054 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1055 Note that the immediate value in the first word is swapped.
1057 When producing a relocatable object file, R_MIPS16_26 is
1058 handled mostly like R_MIPS_26. In particular, the addend is
1059 stored as a straight 26-bit value in a 32-bit instruction.
1060 (gas makes life simpler for itself by never adjusting a
1061 R_MIPS16_26 reloc to be against a section, so the addend is
1062 always zero). However, the 32 bit instruction is stored as 2
1063 16-bit values, rather than a single 32-bit value. In a
1064 big-endian file, the result is the same; in a little-endian
1065 file, the two 16-bit halves of the 32 bit value are swapped.
1066 This is so that a disassembler can recognize the jal
1069 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1070 instruction stored as two 16-bit values. The addend A is the
1071 contents of the targ26 field. The calculation is the same as
1072 R_MIPS_26. When storing the calculated value, reorder the
1073 immediate value as shown above, and don't forget to store the
1074 value as two 16-bit values.
1076 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1080 +--------+----------------------+
1084 +--------+----------------------+
1087 +----------+------+-------------+
1091 +----------+--------------------+
1092 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1093 ((sub1 << 16) | sub2)).
1095 When producing a relocatable object file, the calculation is
1096 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1097 When producing a fully linked file, the calculation is
1098 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1099 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1101 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1102 mode. A typical instruction will have a format like this:
1104 +--------------+--------------------------------+
1105 | EXTEND | Imm 10:5 | Imm 15:11 |
1106 +--------------+--------------------------------+
1107 | Major | rx | ry | Imm 4:0 |
1108 +--------------+--------------------------------+
1110 EXTEND is the five bit value 11110. Major is the instruction
1113 This is handled exactly like R_MIPS_GPREL16, except that the
1114 addend is retrieved and stored as shown in this diagram; that
1115 is, the Imm fields above replace the V-rel16 field.
1117 All we need to do here is shuffle the bits appropriately. As
1118 above, the two 16-bit halves must be swapped on a
1119 little-endian system.
1121 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1122 access data when neither GP-relative nor PC-relative addressing
1123 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1124 except that the addend is retrieved and stored as shown above
1128 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1129 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1131 bfd_vma extend
, insn
, val
;
1133 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1134 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1137 /* Pick up the mips16 extend instruction and the real instruction. */
1138 extend
= bfd_get_16 (abfd
, data
);
1139 insn
= bfd_get_16 (abfd
, data
+ 2);
1140 if (r_type
== R_MIPS16_26
)
1143 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1144 | ((extend
& 0x1f) << 21) | insn
;
1146 val
= extend
<< 16 | insn
;
1149 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1150 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1151 bfd_put_32 (abfd
, val
, data
);
1155 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1156 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1158 bfd_vma extend
, insn
, val
;
1160 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1161 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1164 val
= bfd_get_32 (abfd
, data
);
1165 if (r_type
== R_MIPS16_26
)
1169 insn
= val
& 0xffff;
1170 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1171 | ((val
>> 21) & 0x1f);
1175 insn
= val
& 0xffff;
1181 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1182 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1184 bfd_put_16 (abfd
, insn
, data
+ 2);
1185 bfd_put_16 (abfd
, extend
, data
);
1188 bfd_reloc_status_type
1189 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1190 arelent
*reloc_entry
, asection
*input_section
,
1191 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1195 bfd_reloc_status_type status
;
1197 if (bfd_is_com_section (symbol
->section
))
1200 relocation
= symbol
->value
;
1202 relocation
+= symbol
->section
->output_section
->vma
;
1203 relocation
+= symbol
->section
->output_offset
;
1205 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1206 return bfd_reloc_outofrange
;
1208 /* Set val to the offset into the section or symbol. */
1209 val
= reloc_entry
->addend
;
1211 _bfd_mips_elf_sign_extend (val
, 16);
1213 /* Adjust val for the final section location and GP value. If we
1214 are producing relocatable output, we don't want to do this for
1215 an external symbol. */
1217 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1218 val
+= relocation
- gp
;
1220 if (reloc_entry
->howto
->partial_inplace
)
1222 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1224 + reloc_entry
->address
);
1225 if (status
!= bfd_reloc_ok
)
1229 reloc_entry
->addend
= val
;
1232 reloc_entry
->address
+= input_section
->output_offset
;
1234 return bfd_reloc_ok
;
1237 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1238 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1239 that contains the relocation field and DATA points to the start of
1244 struct mips_hi16
*next
;
1246 asection
*input_section
;
1250 /* FIXME: This should not be a static variable. */
1252 static struct mips_hi16
*mips_hi16_list
;
1254 /* A howto special_function for REL *HI16 relocations. We can only
1255 calculate the correct value once we've seen the partnering
1256 *LO16 relocation, so just save the information for later.
1258 The ABI requires that the *LO16 immediately follow the *HI16.
1259 However, as a GNU extension, we permit an arbitrary number of
1260 *HI16s to be associated with a single *LO16. This significantly
1261 simplies the relocation handling in gcc. */
1263 bfd_reloc_status_type
1264 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1265 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1266 asection
*input_section
, bfd
*output_bfd
,
1267 char **error_message ATTRIBUTE_UNUSED
)
1269 struct mips_hi16
*n
;
1271 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1272 return bfd_reloc_outofrange
;
1274 n
= bfd_malloc (sizeof *n
);
1276 return bfd_reloc_outofrange
;
1278 n
->next
= mips_hi16_list
;
1280 n
->input_section
= input_section
;
1281 n
->rel
= *reloc_entry
;
1284 if (output_bfd
!= NULL
)
1285 reloc_entry
->address
+= input_section
->output_offset
;
1287 return bfd_reloc_ok
;
1290 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1291 like any other 16-bit relocation when applied to global symbols, but is
1292 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1294 bfd_reloc_status_type
1295 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1296 void *data
, asection
*input_section
,
1297 bfd
*output_bfd
, char **error_message
)
1299 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1300 || bfd_is_und_section (bfd_get_section (symbol
))
1301 || bfd_is_com_section (bfd_get_section (symbol
)))
1302 /* The relocation is against a global symbol. */
1303 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1304 input_section
, output_bfd
,
1307 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1308 input_section
, output_bfd
, error_message
);
1311 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1312 is a straightforward 16 bit inplace relocation, but we must deal with
1313 any partnering high-part relocations as well. */
1315 bfd_reloc_status_type
1316 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1317 void *data
, asection
*input_section
,
1318 bfd
*output_bfd
, char **error_message
)
1321 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1323 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1324 return bfd_reloc_outofrange
;
1326 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1328 vallo
= bfd_get_32 (abfd
, location
);
1329 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1332 while (mips_hi16_list
!= NULL
)
1334 bfd_reloc_status_type ret
;
1335 struct mips_hi16
*hi
;
1337 hi
= mips_hi16_list
;
1339 /* R_MIPS_GOT16 relocations are something of a special case. We
1340 want to install the addend in the same way as for a R_MIPS_HI16
1341 relocation (with a rightshift of 16). However, since GOT16
1342 relocations can also be used with global symbols, their howto
1343 has a rightshift of 0. */
1344 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1345 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1347 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1348 carry or borrow will induce a change of +1 or -1 in the high part. */
1349 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1351 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1352 hi
->input_section
, output_bfd
,
1354 if (ret
!= bfd_reloc_ok
)
1357 mips_hi16_list
= hi
->next
;
1361 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1362 input_section
, output_bfd
,
1366 /* A generic howto special_function. This calculates and installs the
1367 relocation itself, thus avoiding the oft-discussed problems in
1368 bfd_perform_relocation and bfd_install_relocation. */
1370 bfd_reloc_status_type
1371 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1372 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1373 asection
*input_section
, bfd
*output_bfd
,
1374 char **error_message ATTRIBUTE_UNUSED
)
1377 bfd_reloc_status_type status
;
1378 bfd_boolean relocatable
;
1380 relocatable
= (output_bfd
!= NULL
);
1382 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1383 return bfd_reloc_outofrange
;
1385 /* Build up the field adjustment in VAL. */
1387 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1389 /* Either we're calculating the final field value or we have a
1390 relocation against a section symbol. Add in the section's
1391 offset or address. */
1392 val
+= symbol
->section
->output_section
->vma
;
1393 val
+= symbol
->section
->output_offset
;
1398 /* We're calculating the final field value. Add in the symbol's value
1399 and, if pc-relative, subtract the address of the field itself. */
1400 val
+= symbol
->value
;
1401 if (reloc_entry
->howto
->pc_relative
)
1403 val
-= input_section
->output_section
->vma
;
1404 val
-= input_section
->output_offset
;
1405 val
-= reloc_entry
->address
;
1409 /* VAL is now the final adjustment. If we're keeping this relocation
1410 in the output file, and if the relocation uses a separate addend,
1411 we just need to add VAL to that addend. Otherwise we need to add
1412 VAL to the relocation field itself. */
1413 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1414 reloc_entry
->addend
+= val
;
1417 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1419 /* Add in the separate addend, if any. */
1420 val
+= reloc_entry
->addend
;
1422 /* Add VAL to the relocation field. */
1423 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1425 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1427 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1430 if (status
!= bfd_reloc_ok
)
1435 reloc_entry
->address
+= input_section
->output_offset
;
1437 return bfd_reloc_ok
;
1440 /* Swap an entry in a .gptab section. Note that these routines rely
1441 on the equivalence of the two elements of the union. */
1444 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1447 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1448 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1452 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1453 Elf32_External_gptab
*ex
)
1455 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1456 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1460 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1461 Elf32_External_compact_rel
*ex
)
1463 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1464 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1465 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1466 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1467 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1468 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1472 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1473 Elf32_External_crinfo
*ex
)
1477 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1478 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1479 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1480 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1481 H_PUT_32 (abfd
, l
, ex
->info
);
1482 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1483 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1486 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1487 routines swap this structure in and out. They are used outside of
1488 BFD, so they are globally visible. */
1491 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1494 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1495 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1496 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1497 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1498 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1499 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1503 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1504 Elf32_External_RegInfo
*ex
)
1506 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1507 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1508 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1509 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1510 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1511 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1514 /* In the 64 bit ABI, the .MIPS.options section holds register
1515 information in an Elf64_Reginfo structure. These routines swap
1516 them in and out. They are globally visible because they are used
1517 outside of BFD. These routines are here so that gas can call them
1518 without worrying about whether the 64 bit ABI has been included. */
1521 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1522 Elf64_Internal_RegInfo
*in
)
1524 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1525 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1526 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1527 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1528 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1529 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1530 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1534 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1535 Elf64_External_RegInfo
*ex
)
1537 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1538 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1539 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1540 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1541 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1542 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1543 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1546 /* Swap in an options header. */
1549 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1550 Elf_Internal_Options
*in
)
1552 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1553 in
->size
= H_GET_8 (abfd
, ex
->size
);
1554 in
->section
= H_GET_16 (abfd
, ex
->section
);
1555 in
->info
= H_GET_32 (abfd
, ex
->info
);
1558 /* Swap out an options header. */
1561 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1562 Elf_External_Options
*ex
)
1564 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1565 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1566 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1567 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1570 /* This function is called via qsort() to sort the dynamic relocation
1571 entries by increasing r_symndx value. */
1574 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1576 Elf_Internal_Rela int_reloc1
;
1577 Elf_Internal_Rela int_reloc2
;
1579 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1580 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1582 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1585 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1588 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1589 const void *arg2 ATTRIBUTE_UNUSED
)
1592 Elf_Internal_Rela int_reloc1
[3];
1593 Elf_Internal_Rela int_reloc2
[3];
1595 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1596 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1597 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1598 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1600 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1601 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1608 /* This routine is used to write out ECOFF debugging external symbol
1609 information. It is called via mips_elf_link_hash_traverse. The
1610 ECOFF external symbol information must match the ELF external
1611 symbol information. Unfortunately, at this point we don't know
1612 whether a symbol is required by reloc information, so the two
1613 tables may wind up being different. We must sort out the external
1614 symbol information before we can set the final size of the .mdebug
1615 section, and we must set the size of the .mdebug section before we
1616 can relocate any sections, and we can't know which symbols are
1617 required by relocation until we relocate the sections.
1618 Fortunately, it is relatively unlikely that any symbol will be
1619 stripped but required by a reloc. In particular, it can not happen
1620 when generating a final executable. */
1623 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1625 struct extsym_info
*einfo
= data
;
1627 asection
*sec
, *output_section
;
1629 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1630 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1632 if (h
->root
.indx
== -2)
1634 else if ((h
->root
.def_dynamic
1635 || h
->root
.ref_dynamic
1636 || h
->root
.type
== bfd_link_hash_new
)
1637 && !h
->root
.def_regular
1638 && !h
->root
.ref_regular
)
1640 else if (einfo
->info
->strip
== strip_all
1641 || (einfo
->info
->strip
== strip_some
1642 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1643 h
->root
.root
.root
.string
,
1644 FALSE
, FALSE
) == NULL
))
1652 if (h
->esym
.ifd
== -2)
1655 h
->esym
.cobol_main
= 0;
1656 h
->esym
.weakext
= 0;
1657 h
->esym
.reserved
= 0;
1658 h
->esym
.ifd
= ifdNil
;
1659 h
->esym
.asym
.value
= 0;
1660 h
->esym
.asym
.st
= stGlobal
;
1662 if (h
->root
.root
.type
== bfd_link_hash_undefined
1663 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1667 /* Use undefined class. Also, set class and type for some
1669 name
= h
->root
.root
.root
.string
;
1670 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1671 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1673 h
->esym
.asym
.sc
= scData
;
1674 h
->esym
.asym
.st
= stLabel
;
1675 h
->esym
.asym
.value
= 0;
1677 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1679 h
->esym
.asym
.sc
= scAbs
;
1680 h
->esym
.asym
.st
= stLabel
;
1681 h
->esym
.asym
.value
=
1682 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1684 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1686 h
->esym
.asym
.sc
= scAbs
;
1687 h
->esym
.asym
.st
= stLabel
;
1688 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1691 h
->esym
.asym
.sc
= scUndefined
;
1693 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1694 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1695 h
->esym
.asym
.sc
= scAbs
;
1700 sec
= h
->root
.root
.u
.def
.section
;
1701 output_section
= sec
->output_section
;
1703 /* When making a shared library and symbol h is the one from
1704 the another shared library, OUTPUT_SECTION may be null. */
1705 if (output_section
== NULL
)
1706 h
->esym
.asym
.sc
= scUndefined
;
1709 name
= bfd_section_name (output_section
->owner
, output_section
);
1711 if (strcmp (name
, ".text") == 0)
1712 h
->esym
.asym
.sc
= scText
;
1713 else if (strcmp (name
, ".data") == 0)
1714 h
->esym
.asym
.sc
= scData
;
1715 else if (strcmp (name
, ".sdata") == 0)
1716 h
->esym
.asym
.sc
= scSData
;
1717 else if (strcmp (name
, ".rodata") == 0
1718 || strcmp (name
, ".rdata") == 0)
1719 h
->esym
.asym
.sc
= scRData
;
1720 else if (strcmp (name
, ".bss") == 0)
1721 h
->esym
.asym
.sc
= scBss
;
1722 else if (strcmp (name
, ".sbss") == 0)
1723 h
->esym
.asym
.sc
= scSBss
;
1724 else if (strcmp (name
, ".init") == 0)
1725 h
->esym
.asym
.sc
= scInit
;
1726 else if (strcmp (name
, ".fini") == 0)
1727 h
->esym
.asym
.sc
= scFini
;
1729 h
->esym
.asym
.sc
= scAbs
;
1733 h
->esym
.asym
.reserved
= 0;
1734 h
->esym
.asym
.index
= indexNil
;
1737 if (h
->root
.root
.type
== bfd_link_hash_common
)
1738 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1739 else if (h
->root
.root
.type
== bfd_link_hash_defined
1740 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1742 if (h
->esym
.asym
.sc
== scCommon
)
1743 h
->esym
.asym
.sc
= scBss
;
1744 else if (h
->esym
.asym
.sc
== scSCommon
)
1745 h
->esym
.asym
.sc
= scSBss
;
1747 sec
= h
->root
.root
.u
.def
.section
;
1748 output_section
= sec
->output_section
;
1749 if (output_section
!= NULL
)
1750 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1751 + sec
->output_offset
1752 + output_section
->vma
);
1754 h
->esym
.asym
.value
= 0;
1756 else if (h
->root
.needs_plt
)
1758 struct mips_elf_link_hash_entry
*hd
= h
;
1759 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1761 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1763 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1764 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1769 /* Set type and value for a symbol with a function stub. */
1770 h
->esym
.asym
.st
= stProc
;
1771 sec
= hd
->root
.root
.u
.def
.section
;
1773 h
->esym
.asym
.value
= 0;
1776 output_section
= sec
->output_section
;
1777 if (output_section
!= NULL
)
1778 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1779 + sec
->output_offset
1780 + output_section
->vma
);
1782 h
->esym
.asym
.value
= 0;
1787 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1788 h
->root
.root
.root
.string
,
1791 einfo
->failed
= TRUE
;
1798 /* A comparison routine used to sort .gptab entries. */
1801 gptab_compare (const void *p1
, const void *p2
)
1803 const Elf32_gptab
*a1
= p1
;
1804 const Elf32_gptab
*a2
= p2
;
1806 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1809 /* Functions to manage the got entry hash table. */
1811 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1814 static INLINE hashval_t
1815 mips_elf_hash_bfd_vma (bfd_vma addr
)
1818 return addr
+ (addr
>> 32);
1824 /* got_entries only match if they're identical, except for gotidx, so
1825 use all fields to compute the hash, and compare the appropriate
1829 mips_elf_got_entry_hash (const void *entry_
)
1831 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1833 return entry
->symndx
1834 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
1835 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1837 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1838 : entry
->d
.h
->root
.root
.root
.hash
));
1842 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1844 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1845 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1847 /* An LDM entry can only match another LDM entry. */
1848 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
1851 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1852 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1853 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1854 : e1
->d
.h
== e2
->d
.h
);
1857 /* multi_got_entries are still a match in the case of global objects,
1858 even if the input bfd in which they're referenced differs, so the
1859 hash computation and compare functions are adjusted
1863 mips_elf_multi_got_entry_hash (const void *entry_
)
1865 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1867 return entry
->symndx
1869 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1870 : entry
->symndx
>= 0
1871 ? ((entry
->tls_type
& GOT_TLS_LDM
)
1872 ? (GOT_TLS_LDM
<< 17)
1874 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
1875 : entry
->d
.h
->root
.root
.root
.hash
);
1879 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1881 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1882 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1884 /* Any two LDM entries match. */
1885 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
1888 /* Nothing else matches an LDM entry. */
1889 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
1892 return e1
->symndx
== e2
->symndx
1893 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1894 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1895 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1896 : e1
->d
.h
== e2
->d
.h
);
1899 /* Returns the dynamic relocation section for DYNOBJ. */
1902 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1904 static const char dname
[] = ".rel.dyn";
1907 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1908 if (sreloc
== NULL
&& create_p
)
1910 sreloc
= bfd_make_section (dynobj
, dname
);
1912 || ! bfd_set_section_flags (dynobj
, sreloc
,
1917 | SEC_LINKER_CREATED
1919 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1920 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1926 /* Returns the GOT section for ABFD. */
1929 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1931 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1933 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1938 /* Returns the GOT information associated with the link indicated by
1939 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1942 static struct mips_got_info
*
1943 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1946 struct mips_got_info
*g
;
1948 sgot
= mips_elf_got_section (abfd
, TRUE
);
1949 BFD_ASSERT (sgot
!= NULL
);
1950 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1951 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1952 BFD_ASSERT (g
!= NULL
);
1955 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1960 /* Count the number of relocations needed for a TLS GOT entry, with
1961 access types from TLS_TYPE, and symbol H (or a local symbol if H
1965 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
1966 struct elf_link_hash_entry
*h
)
1970 bfd_boolean need_relocs
= FALSE
;
1971 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1973 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1974 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
1977 if ((info
->shared
|| indx
!= 0)
1979 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1980 || h
->root
.type
!= bfd_link_hash_undefweak
))
1986 if (tls_type
& GOT_TLS_GD
)
1993 if (tls_type
& GOT_TLS_IE
)
1996 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2002 /* Count the number of TLS relocations required for the GOT entry in
2003 ARG1, if it describes a local symbol. */
2006 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2008 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2009 struct mips_elf_count_tls_arg
*arg
= arg2
;
2011 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2012 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2017 /* Count the number of TLS GOT entries required for the global (or
2018 forced-local) symbol in ARG1. */
2021 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2023 struct mips_elf_link_hash_entry
*hm
2024 = (struct mips_elf_link_hash_entry
*) arg1
;
2025 struct mips_elf_count_tls_arg
*arg
= arg2
;
2027 if (hm
->tls_type
& GOT_TLS_GD
)
2029 if (hm
->tls_type
& GOT_TLS_IE
)
2035 /* Count the number of TLS relocations required for the global (or
2036 forced-local) symbol in ARG1. */
2039 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2041 struct mips_elf_link_hash_entry
*hm
2042 = (struct mips_elf_link_hash_entry
*) arg1
;
2043 struct mips_elf_count_tls_arg
*arg
= arg2
;
2045 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2050 /* Output a simple dynamic relocation into SRELOC. */
2053 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2059 Elf_Internal_Rela rel
[3];
2061 memset (rel
, 0, sizeof (rel
));
2063 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2064 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2066 if (ABI_64_P (output_bfd
))
2068 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2069 (output_bfd
, &rel
[0],
2071 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
2074 bfd_elf32_swap_reloc_out
2075 (output_bfd
, &rel
[0],
2077 + sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
2078 ++sreloc
->reloc_count
;
2081 /* Initialize a set of TLS GOT entries for one symbol. */
2084 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2085 unsigned char *tls_type_p
,
2086 struct bfd_link_info
*info
,
2087 struct mips_elf_link_hash_entry
*h
,
2091 asection
*sreloc
, *sgot
;
2092 bfd_vma offset
, offset2
;
2094 bfd_boolean need_relocs
= FALSE
;
2096 dynobj
= elf_hash_table (info
)->dynobj
;
2097 sgot
= mips_elf_got_section (dynobj
, FALSE
);
2102 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2104 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2105 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2106 indx
= h
->root
.dynindx
;
2109 if (*tls_type_p
& GOT_TLS_DONE
)
2112 if ((info
->shared
|| indx
!= 0)
2114 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2115 || h
->root
.type
!= bfd_link_hash_undefweak
))
2118 /* MINUS_ONE means the symbol is not defined in this object. It may not
2119 be defined at all; assume that the value doesn't matter in that
2120 case. Otherwise complain if we would use the value. */
2121 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2122 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2124 /* Emit necessary relocations. */
2125 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
2127 /* General Dynamic. */
2128 if (*tls_type_p
& GOT_TLS_GD
)
2130 offset
= got_offset
;
2131 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2135 mips_elf_output_dynamic_relocation
2136 (abfd
, sreloc
, indx
,
2137 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2138 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2141 mips_elf_output_dynamic_relocation
2142 (abfd
, sreloc
, indx
,
2143 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2144 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2146 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2147 sgot
->contents
+ offset2
);
2151 MIPS_ELF_PUT_WORD (abfd
, 1,
2152 sgot
->contents
+ offset
);
2153 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2154 sgot
->contents
+ offset2
);
2157 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2160 /* Initial Exec model. */
2161 if (*tls_type_p
& GOT_TLS_IE
)
2163 offset
= got_offset
;
2168 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2169 sgot
->contents
+ offset
);
2171 MIPS_ELF_PUT_WORD (abfd
, 0,
2172 sgot
->contents
+ offset
);
2174 mips_elf_output_dynamic_relocation
2175 (abfd
, sreloc
, indx
,
2176 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2177 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2180 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2181 sgot
->contents
+ offset
);
2184 if (*tls_type_p
& GOT_TLS_LDM
)
2186 /* The initial offset is zero, and the LD offsets will include the
2187 bias by DTP_OFFSET. */
2188 MIPS_ELF_PUT_WORD (abfd
, 0,
2189 sgot
->contents
+ got_offset
2190 + MIPS_ELF_GOT_SIZE (abfd
));
2193 MIPS_ELF_PUT_WORD (abfd
, 1,
2194 sgot
->contents
+ got_offset
);
2196 mips_elf_output_dynamic_relocation
2197 (abfd
, sreloc
, indx
,
2198 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2199 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2202 *tls_type_p
|= GOT_TLS_DONE
;
2205 /* Return the GOT index to use for a relocation of type R_TYPE against
2206 a symbol accessed using TLS_TYPE models. The GOT entries for this
2207 symbol in this GOT start at GOT_INDEX. This function initializes the
2208 GOT entries and corresponding relocations. */
2211 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2212 int r_type
, struct bfd_link_info
*info
,
2213 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2215 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2216 || r_type
== R_MIPS_TLS_LDM
);
2218 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2220 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2222 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2223 if (*tls_type
& GOT_TLS_GD
)
2224 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
2229 if (r_type
== R_MIPS_TLS_GD
)
2231 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
2235 if (r_type
== R_MIPS_TLS_LDM
)
2237 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
2244 /* Returns the GOT offset at which the indicated address can be found.
2245 If there is not yet a GOT entry for this value, create one. If
2246 R_SYMNDX refers to a TLS symbol, create a TLS GOT entry instead.
2247 Returns -1 if no satisfactory GOT offset can be found. */
2250 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2251 bfd_vma value
, unsigned long r_symndx
,
2252 struct mips_elf_link_hash_entry
*h
, int r_type
)
2255 struct mips_got_info
*g
;
2256 struct mips_got_entry
*entry
;
2258 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2260 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
,
2261 r_symndx
, h
, r_type
);
2265 if (TLS_RELOC_P (r_type
))
2266 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
, r_type
,
2269 return entry
->gotidx
;
2272 /* Returns the GOT index for the global symbol indicated by H. */
2275 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
2276 int r_type
, struct bfd_link_info
*info
)
2280 struct mips_got_info
*g
, *gg
;
2281 long global_got_dynindx
= 0;
2283 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
2284 if (g
->bfd2got
&& ibfd
)
2286 struct mips_got_entry e
, *p
;
2288 BFD_ASSERT (h
->dynindx
>= 0);
2290 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2291 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
2295 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2298 p
= htab_find (g
->got_entries
, &e
);
2300 BFD_ASSERT (p
->gotidx
> 0);
2302 if (TLS_RELOC_P (r_type
))
2304 bfd_vma value
= MINUS_ONE
;
2305 if ((h
->root
.type
== bfd_link_hash_defined
2306 || h
->root
.type
== bfd_link_hash_defweak
)
2307 && h
->root
.u
.def
.section
->output_section
)
2308 value
= (h
->root
.u
.def
.value
2309 + h
->root
.u
.def
.section
->output_offset
2310 + h
->root
.u
.def
.section
->output_section
->vma
);
2312 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
2313 info
, e
.d
.h
, value
);
2320 if (gg
->global_gotsym
!= NULL
)
2321 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2323 if (TLS_RELOC_P (r_type
))
2325 struct mips_elf_link_hash_entry
*hm
2326 = (struct mips_elf_link_hash_entry
*) h
;
2327 bfd_vma value
= MINUS_ONE
;
2329 if ((h
->root
.type
== bfd_link_hash_defined
2330 || h
->root
.type
== bfd_link_hash_defweak
)
2331 && h
->root
.u
.def
.section
->output_section
)
2332 value
= (h
->root
.u
.def
.value
2333 + h
->root
.u
.def
.section
->output_offset
2334 + h
->root
.u
.def
.section
->output_section
->vma
);
2336 index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
2337 r_type
, info
, hm
, value
);
2341 /* Once we determine the global GOT entry with the lowest dynamic
2342 symbol table index, we must put all dynamic symbols with greater
2343 indices into the GOT. That makes it easy to calculate the GOT
2345 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2346 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2347 * MIPS_ELF_GOT_SIZE (abfd
));
2349 BFD_ASSERT (index
< sgot
->size
);
2354 /* Find a GOT entry that is within 32KB of the VALUE. These entries
2355 are supposed to be placed at small offsets in the GOT, i.e.,
2356 within 32KB of GP. Return the index into the GOT for this page,
2357 and store the offset from this entry to the desired address in
2358 OFFSETP, if it is non-NULL. */
2361 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2362 bfd_vma value
, bfd_vma
*offsetp
)
2365 struct mips_got_info
*g
;
2367 struct mips_got_entry
*entry
;
2369 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2371 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
2373 & (~(bfd_vma
)0xffff), 0,
2374 NULL
, R_MIPS_GOT_PAGE
);
2379 index
= entry
->gotidx
;
2382 *offsetp
= value
- entry
->d
.address
;
2387 /* Find a GOT entry whose higher-order 16 bits are the same as those
2388 for value. Return the index into the GOT for this entry. */
2391 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2392 bfd_vma value
, bfd_boolean external
)
2395 struct mips_got_info
*g
;
2396 struct mips_got_entry
*entry
;
2400 /* Although the ABI says that it is "the high-order 16 bits" that we
2401 want, it is really the %high value. The complete value is
2402 calculated with a `addiu' of a LO16 relocation, just as with a
2404 value
= mips_elf_high (value
) << 16;
2407 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2409 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
, 0, NULL
,
2412 return entry
->gotidx
;
2417 /* Returns the offset for the entry at the INDEXth position
2421 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
2422 bfd
*input_bfd
, bfd_vma index
)
2426 struct mips_got_info
*g
;
2428 g
= mips_elf_got_info (dynobj
, &sgot
);
2429 gp
= _bfd_get_gp_value (output_bfd
)
2430 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2432 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2435 /* Create a local GOT entry for VALUE. Return the index of the entry,
2436 or -1 if it could not be created. If R_SYMNDX refers to a TLS symbol,
2437 create a TLS entry instead. */
2439 static struct mips_got_entry
*
2440 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2441 struct mips_got_info
*gg
,
2442 asection
*sgot
, bfd_vma value
,
2443 unsigned long r_symndx
,
2444 struct mips_elf_link_hash_entry
*h
,
2447 struct mips_got_entry entry
, **loc
;
2448 struct mips_got_info
*g
;
2452 entry
.d
.address
= value
;
2455 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2458 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2459 BFD_ASSERT (g
!= NULL
);
2462 /* We might have a symbol, H, if it has been forced local. Use the
2463 global entry then. It doesn't matter whether an entry is local
2464 or global for TLS, since the dynamic linker does not
2465 automatically relocate TLS GOT entries. */
2466 BFD_ASSERT (h
== NULL
|| h
->forced_local
);
2467 if (TLS_RELOC_P (r_type
))
2469 struct mips_got_entry
*p
;
2472 if (r_type
== R_MIPS_TLS_LDM
)
2474 entry
.tls_type
= GOT_TLS_LDM
;
2480 entry
.symndx
= r_symndx
;
2486 p
= (struct mips_got_entry
*)
2487 htab_find (g
->got_entries
, &entry
);
2493 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2498 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2501 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2506 memcpy (*loc
, &entry
, sizeof entry
);
2508 if (g
->assigned_gotno
>= g
->local_gotno
)
2510 (*loc
)->gotidx
= -1;
2511 /* We didn't allocate enough space in the GOT. */
2512 (*_bfd_error_handler
)
2513 (_("not enough GOT space for local GOT entries"));
2514 bfd_set_error (bfd_error_bad_value
);
2518 MIPS_ELF_PUT_WORD (abfd
, value
,
2519 (sgot
->contents
+ entry
.gotidx
));
2524 /* Sort the dynamic symbol table so that symbols that need GOT entries
2525 appear towards the end. This reduces the amount of GOT space
2526 required. MAX_LOCAL is used to set the number of local symbols
2527 known to be in the dynamic symbol table. During
2528 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2529 section symbols are added and the count is higher. */
2532 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2534 struct mips_elf_hash_sort_data hsd
;
2535 struct mips_got_info
*g
;
2538 dynobj
= elf_hash_table (info
)->dynobj
;
2540 g
= mips_elf_got_info (dynobj
, NULL
);
2543 hsd
.max_unref_got_dynindx
=
2544 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2545 /* In the multi-got case, assigned_gotno of the master got_info
2546 indicate the number of entries that aren't referenced in the
2547 primary GOT, but that must have entries because there are
2548 dynamic relocations that reference it. Since they aren't
2549 referenced, we move them to the end of the GOT, so that they
2550 don't prevent other entries that are referenced from getting
2551 too large offsets. */
2552 - (g
->next
? g
->assigned_gotno
: 0);
2553 hsd
.max_non_got_dynindx
= max_local
;
2554 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2555 elf_hash_table (info
)),
2556 mips_elf_sort_hash_table_f
,
2559 /* There should have been enough room in the symbol table to
2560 accommodate both the GOT and non-GOT symbols. */
2561 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2562 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2563 <= elf_hash_table (info
)->dynsymcount
);
2565 /* Now we know which dynamic symbol has the lowest dynamic symbol
2566 table index in the GOT. */
2567 g
->global_gotsym
= hsd
.low
;
2572 /* If H needs a GOT entry, assign it the highest available dynamic
2573 index. Otherwise, assign it the lowest available dynamic
2577 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2579 struct mips_elf_hash_sort_data
*hsd
= data
;
2581 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2582 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2584 /* Symbols without dynamic symbol table entries aren't interesting
2586 if (h
->root
.dynindx
== -1)
2589 /* Global symbols that need GOT entries that are not explicitly
2590 referenced are marked with got offset 2. Those that are
2591 referenced get a 1, and those that don't need GOT entries get
2593 if (h
->root
.got
.offset
== 2)
2595 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2597 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2598 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2599 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2601 else if (h
->root
.got
.offset
!= 1)
2602 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2605 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2607 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2608 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2614 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2615 symbol table index lower than any we've seen to date, record it for
2619 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2620 bfd
*abfd
, struct bfd_link_info
*info
,
2621 struct mips_got_info
*g
,
2622 unsigned char tls_flag
)
2624 struct mips_got_entry entry
, **loc
;
2626 /* A global symbol in the GOT must also be in the dynamic symbol
2628 if (h
->dynindx
== -1)
2630 switch (ELF_ST_VISIBILITY (h
->other
))
2634 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2637 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2643 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2646 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2649 /* If we've already marked this entry as needing GOT space, we don't
2650 need to do it again. */
2653 (*loc
)->tls_type
|= tls_flag
;
2657 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2663 entry
.tls_type
= tls_flag
;
2665 memcpy (*loc
, &entry
, sizeof entry
);
2667 if (h
->got
.offset
!= MINUS_ONE
)
2670 /* By setting this to a value other than -1, we are indicating that
2671 there needs to be a GOT entry for H. Avoid using zero, as the
2672 generic ELF copy_indirect_symbol tests for <= 0. */
2679 /* Reserve space in G for a GOT entry containing the value of symbol
2680 SYMNDX in input bfd ABDF, plus ADDEND. */
2683 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2684 struct mips_got_info
*g
,
2685 unsigned char tls_flag
)
2687 struct mips_got_entry entry
, **loc
;
2690 entry
.symndx
= symndx
;
2691 entry
.d
.addend
= addend
;
2692 entry
.tls_type
= tls_flag
;
2693 loc
= (struct mips_got_entry
**)
2694 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2698 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
2701 (*loc
)->tls_type
|= tls_flag
;
2703 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
2706 (*loc
)->tls_type
|= tls_flag
;
2714 entry
.tls_type
= tls_flag
;
2715 if (tls_flag
== GOT_TLS_IE
)
2717 else if (tls_flag
== GOT_TLS_GD
)
2719 else if (g
->tls_ldm_offset
== MINUS_ONE
)
2721 g
->tls_ldm_offset
= MINUS_TWO
;
2727 entry
.gotidx
= g
->local_gotno
++;
2731 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2736 memcpy (*loc
, &entry
, sizeof entry
);
2741 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2744 mips_elf_bfd2got_entry_hash (const void *entry_
)
2746 const struct mips_elf_bfd2got_hash
*entry
2747 = (struct mips_elf_bfd2got_hash
*)entry_
;
2749 return entry
->bfd
->id
;
2752 /* Check whether two hash entries have the same bfd. */
2755 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2757 const struct mips_elf_bfd2got_hash
*e1
2758 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2759 const struct mips_elf_bfd2got_hash
*e2
2760 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2762 return e1
->bfd
== e2
->bfd
;
2765 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2766 be the master GOT data. */
2768 static struct mips_got_info
*
2769 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2771 struct mips_elf_bfd2got_hash e
, *p
;
2777 p
= htab_find (g
->bfd2got
, &e
);
2778 return p
? p
->g
: NULL
;
2781 /* Create one separate got for each bfd that has entries in the global
2782 got, such that we can tell how many local and global entries each
2786 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2788 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2789 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2790 htab_t bfd2got
= arg
->bfd2got
;
2791 struct mips_got_info
*g
;
2792 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2795 /* Find the got_info for this GOT entry's input bfd. Create one if
2797 bfdgot_entry
.bfd
= entry
->abfd
;
2798 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2799 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2805 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2806 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2816 bfdgot
->bfd
= entry
->abfd
;
2817 bfdgot
->g
= g
= (struct mips_got_info
*)
2818 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2825 g
->global_gotsym
= NULL
;
2826 g
->global_gotno
= 0;
2828 g
->assigned_gotno
= -1;
2830 g
->tls_assigned_gotno
= 0;
2831 g
->tls_ldm_offset
= MINUS_ONE
;
2832 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2833 mips_elf_multi_got_entry_eq
, NULL
);
2834 if (g
->got_entries
== NULL
)
2844 /* Insert the GOT entry in the bfd's got entry hash table. */
2845 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2846 if (*entryp
!= NULL
)
2851 if (entry
->tls_type
)
2853 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
2855 if (entry
->tls_type
& GOT_TLS_IE
)
2858 else if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2866 /* Attempt to merge gots of different input bfds. Try to use as much
2867 as possible of the primary got, since it doesn't require explicit
2868 dynamic relocations, but don't use bfds that would reference global
2869 symbols out of the addressable range. Failing the primary got,
2870 attempt to merge with the current got, or finish the current got
2871 and then make make the new got current. */
2874 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2876 struct mips_elf_bfd2got_hash
*bfd2got
2877 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2878 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2879 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2880 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2881 unsigned int tcount
= bfd2got
->g
->tls_gotno
;
2882 unsigned int maxcnt
= arg
->max_count
;
2883 bfd_boolean too_many_for_tls
= FALSE
;
2885 /* We place TLS GOT entries after both locals and globals. The globals
2886 for the primary GOT may overflow the normal GOT size limit, so be
2887 sure not to merge a GOT which requires TLS with the primary GOT in that
2888 case. This doesn't affect non-primary GOTs. */
2891 unsigned int primary_total
= lcount
+ tcount
+ arg
->global_count
;
2892 if (primary_total
* MIPS_ELF_GOT_SIZE (bfd2got
->bfd
)
2893 >= MIPS_ELF_GOT_MAX_SIZE (bfd2got
->bfd
))
2894 too_many_for_tls
= TRUE
;
2897 /* If we don't have a primary GOT and this is not too big, use it as
2898 a starting point for the primary GOT. */
2899 if (! arg
->primary
&& lcount
+ gcount
+ tcount
<= maxcnt
2900 && ! too_many_for_tls
)
2902 arg
->primary
= bfd2got
->g
;
2903 arg
->primary_count
= lcount
+ gcount
;
2905 /* If it looks like we can merge this bfd's entries with those of
2906 the primary, merge them. The heuristics is conservative, but we
2907 don't have to squeeze it too hard. */
2908 else if (arg
->primary
&& ! too_many_for_tls
2909 && (arg
->primary_count
+ lcount
+ gcount
+ tcount
) <= maxcnt
)
2911 struct mips_got_info
*g
= bfd2got
->g
;
2912 int old_lcount
= arg
->primary
->local_gotno
;
2913 int old_gcount
= arg
->primary
->global_gotno
;
2914 int old_tcount
= arg
->primary
->tls_gotno
;
2916 bfd2got
->g
= arg
->primary
;
2918 htab_traverse (g
->got_entries
,
2919 mips_elf_make_got_per_bfd
,
2921 if (arg
->obfd
== NULL
)
2924 htab_delete (g
->got_entries
);
2925 /* We don't have to worry about releasing memory of the actual
2926 got entries, since they're all in the master got_entries hash
2929 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2930 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2931 BFD_ASSERT (old_tcount
+ tcount
>= arg
->primary
->tls_gotno
);
2933 arg
->primary_count
= arg
->primary
->local_gotno
2934 + arg
->primary
->global_gotno
+ arg
->primary
->tls_gotno
;
2936 /* If we can merge with the last-created got, do it. */
2937 else if (arg
->current
2938 && arg
->current_count
+ lcount
+ gcount
+ tcount
<= maxcnt
)
2940 struct mips_got_info
*g
= bfd2got
->g
;
2941 int old_lcount
= arg
->current
->local_gotno
;
2942 int old_gcount
= arg
->current
->global_gotno
;
2943 int old_tcount
= arg
->current
->tls_gotno
;
2945 bfd2got
->g
= arg
->current
;
2947 htab_traverse (g
->got_entries
,
2948 mips_elf_make_got_per_bfd
,
2950 if (arg
->obfd
== NULL
)
2953 htab_delete (g
->got_entries
);
2955 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2956 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2957 BFD_ASSERT (old_tcount
+ tcount
>= arg
->current
->tls_gotno
);
2959 arg
->current_count
= arg
->current
->local_gotno
2960 + arg
->current
->global_gotno
+ arg
->current
->tls_gotno
;
2962 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2963 fits; if it turns out that it doesn't, we'll get relocation
2964 overflows anyway. */
2967 bfd2got
->g
->next
= arg
->current
;
2968 arg
->current
= bfd2got
->g
;
2970 arg
->current_count
= lcount
+ gcount
+ 2 * tcount
;
2976 /* Set the TLS GOT index for the GOT entry in ENTRYP. */
2979 mips_elf_initialize_tls_index (void **entryp
, void *p
)
2981 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2982 struct mips_got_info
*g
= p
;
2984 /* We're only interested in TLS symbols. */
2985 if (entry
->tls_type
== 0)
2988 if (entry
->symndx
== -1)
2990 /* There may be multiple mips_got_entry structs for a global variable
2991 if there is just one GOT. Just do this once. */
2992 if (g
->next
== NULL
)
2994 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
2996 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
2999 else if (entry
->tls_type
& GOT_TLS_LDM
)
3001 /* Similarly, there may be multiple structs for the LDM entry. */
3002 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
3004 entry
->gotidx
= g
->tls_ldm_offset
;
3009 /* Initialize the GOT offset. */
3010 entry
->gotidx
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
3011 if (g
->next
== NULL
&& entry
->symndx
== -1)
3012 entry
->d
.h
->tls_got_offset
= entry
->gotidx
;
3014 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3015 g
->tls_assigned_gotno
+= 2;
3016 if (entry
->tls_type
& GOT_TLS_IE
)
3017 g
->tls_assigned_gotno
+= 1;
3019 if (entry
->tls_type
& GOT_TLS_LDM
)
3020 g
->tls_ldm_offset
= entry
->gotidx
;
3025 /* If passed a NULL mips_got_info in the argument, set the marker used
3026 to tell whether a global symbol needs a got entry (in the primary
3027 got) to the given VALUE.
3029 If passed a pointer G to a mips_got_info in the argument (it must
3030 not be the primary GOT), compute the offset from the beginning of
3031 the (primary) GOT section to the entry in G corresponding to the
3032 global symbol. G's assigned_gotno must contain the index of the
3033 first available global GOT entry in G. VALUE must contain the size
3034 of a GOT entry in bytes. For each global GOT entry that requires a
3035 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3036 marked as not eligible for lazy resolution through a function
3039 mips_elf_set_global_got_offset (void **entryp
, void *p
)
3041 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3042 struct mips_elf_set_global_got_offset_arg
*arg
3043 = (struct mips_elf_set_global_got_offset_arg
*)p
;
3044 struct mips_got_info
*g
= arg
->g
;
3046 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
3047 arg
->needed_relocs
+=
3048 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
3049 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
3051 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
3052 && entry
->d
.h
->root
.dynindx
!= -1
3053 && entry
->d
.h
->tls_type
== GOT_NORMAL
)
3057 BFD_ASSERT (g
->global_gotsym
== NULL
);
3059 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
3060 if (arg
->info
->shared
3061 || (elf_hash_table (arg
->info
)->dynamic_sections_created
3062 && entry
->d
.h
->root
.def_dynamic
3063 && !entry
->d
.h
->root
.def_regular
))
3064 ++arg
->needed_relocs
;
3067 entry
->d
.h
->root
.got
.offset
= arg
->value
;
3073 /* Mark any global symbols referenced in the GOT we are iterating over
3074 as inelligible for lazy resolution stubs. */
3076 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
3078 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3080 if (entry
->abfd
!= NULL
3081 && entry
->symndx
== -1
3082 && entry
->d
.h
->root
.dynindx
!= -1)
3083 entry
->d
.h
->no_fn_stub
= TRUE
;
3088 /* Follow indirect and warning hash entries so that each got entry
3089 points to the final symbol definition. P must point to a pointer
3090 to the hash table we're traversing. Since this traversal may
3091 modify the hash table, we set this pointer to NULL to indicate
3092 we've made a potentially-destructive change to the hash table, so
3093 the traversal must be restarted. */
3095 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
3097 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3098 htab_t got_entries
= *(htab_t
*)p
;
3100 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3102 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
3104 while (h
->root
.root
.type
== bfd_link_hash_indirect
3105 || h
->root
.root
.type
== bfd_link_hash_warning
)
3106 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3108 if (entry
->d
.h
== h
)
3113 /* If we can't find this entry with the new bfd hash, re-insert
3114 it, and get the traversal restarted. */
3115 if (! htab_find (got_entries
, entry
))
3117 htab_clear_slot (got_entries
, entryp
);
3118 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
3121 /* Abort the traversal, since the whole table may have
3122 moved, and leave it up to the parent to restart the
3124 *(htab_t
*)p
= NULL
;
3127 /* We might want to decrement the global_gotno count, but it's
3128 either too early or too late for that at this point. */
3134 /* Turn indirect got entries in a got_entries table into their final
3137 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3143 got_entries
= g
->got_entries
;
3145 htab_traverse (got_entries
,
3146 mips_elf_resolve_final_got_entry
,
3149 while (got_entries
== NULL
);
3152 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3155 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
3157 if (g
->bfd2got
== NULL
)
3160 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3164 BFD_ASSERT (g
->next
);
3168 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
3169 * MIPS_ELF_GOT_SIZE (abfd
);
3172 /* Turn a single GOT that is too big for 16-bit addressing into
3173 a sequence of GOTs, each one 16-bit addressable. */
3176 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
3177 struct mips_got_info
*g
, asection
*got
,
3178 bfd_size_type pages
)
3180 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
3181 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
3182 struct mips_got_info
*gg
;
3183 unsigned int assign
;
3185 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
3186 mips_elf_bfd2got_entry_eq
, NULL
);
3187 if (g
->bfd2got
== NULL
)
3190 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
3191 got_per_bfd_arg
.obfd
= abfd
;
3192 got_per_bfd_arg
.info
= info
;
3194 /* Count how many GOT entries each input bfd requires, creating a
3195 map from bfd to got info while at that. */
3196 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
3197 if (got_per_bfd_arg
.obfd
== NULL
)
3200 got_per_bfd_arg
.current
= NULL
;
3201 got_per_bfd_arg
.primary
= NULL
;
3202 /* Taking out PAGES entries is a worst-case estimate. We could
3203 compute the maximum number of pages that each separate input bfd
3204 uses, but it's probably not worth it. */
3205 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
3206 / MIPS_ELF_GOT_SIZE (abfd
))
3207 - MIPS_RESERVED_GOTNO
- pages
);
3208 /* The number of globals that will be included in the primary GOT.
3209 See the calls to mips_elf_set_global_got_offset below for more
3211 got_per_bfd_arg
.global_count
= g
->global_gotno
;
3213 /* Try to merge the GOTs of input bfds together, as long as they
3214 don't seem to exceed the maximum GOT size, choosing one of them
3215 to be the primary GOT. */
3216 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
3217 if (got_per_bfd_arg
.obfd
== NULL
)
3220 /* If we do not find any suitable primary GOT, create an empty one. */
3221 if (got_per_bfd_arg
.primary
== NULL
)
3223 g
->next
= (struct mips_got_info
*)
3224 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
3225 if (g
->next
== NULL
)
3228 g
->next
->global_gotsym
= NULL
;
3229 g
->next
->global_gotno
= 0;
3230 g
->next
->local_gotno
= 0;
3231 g
->next
->tls_gotno
= 0;
3232 g
->next
->assigned_gotno
= 0;
3233 g
->next
->tls_assigned_gotno
= 0;
3234 g
->next
->tls_ldm_offset
= MINUS_ONE
;
3235 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3236 mips_elf_multi_got_entry_eq
,
3238 if (g
->next
->got_entries
== NULL
)
3240 g
->next
->bfd2got
= NULL
;
3243 g
->next
= got_per_bfd_arg
.primary
;
3244 g
->next
->next
= got_per_bfd_arg
.current
;
3246 /* GG is now the master GOT, and G is the primary GOT. */
3250 /* Map the output bfd to the primary got. That's what we're going
3251 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3252 didn't mark in check_relocs, and we want a quick way to find it.
3253 We can't just use gg->next because we're going to reverse the
3256 struct mips_elf_bfd2got_hash
*bfdgot
;
3259 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3260 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
3267 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
3269 BFD_ASSERT (*bfdgotp
== NULL
);
3273 /* The IRIX dynamic linker requires every symbol that is referenced
3274 in a dynamic relocation to be present in the primary GOT, so
3275 arrange for them to appear after those that are actually
3278 GNU/Linux could very well do without it, but it would slow down
3279 the dynamic linker, since it would have to resolve every dynamic
3280 symbol referenced in other GOTs more than once, without help from
3281 the cache. Also, knowing that every external symbol has a GOT
3282 helps speed up the resolution of local symbols too, so GNU/Linux
3283 follows IRIX's practice.
3285 The number 2 is used by mips_elf_sort_hash_table_f to count
3286 global GOT symbols that are unreferenced in the primary GOT, with
3287 an initial dynamic index computed from gg->assigned_gotno, where
3288 the number of unreferenced global entries in the primary GOT is
3292 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
3293 g
->global_gotno
= gg
->global_gotno
;
3294 set_got_offset_arg
.value
= 2;
3298 /* This could be used for dynamic linkers that don't optimize
3299 symbol resolution while applying relocations so as to use
3300 primary GOT entries or assuming the symbol is locally-defined.
3301 With this code, we assign lower dynamic indices to global
3302 symbols that are not referenced in the primary GOT, so that
3303 their entries can be omitted. */
3304 gg
->assigned_gotno
= 0;
3305 set_got_offset_arg
.value
= -1;
3308 /* Reorder dynamic symbols as described above (which behavior
3309 depends on the setting of VALUE). */
3310 set_got_offset_arg
.g
= NULL
;
3311 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
3312 &set_got_offset_arg
);
3313 set_got_offset_arg
.value
= 1;
3314 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
3315 &set_got_offset_arg
);
3316 if (! mips_elf_sort_hash_table (info
, 1))
3319 /* Now go through the GOTs assigning them offset ranges.
3320 [assigned_gotno, local_gotno[ will be set to the range of local
3321 entries in each GOT. We can then compute the end of a GOT by
3322 adding local_gotno to global_gotno. We reverse the list and make
3323 it circular since then we'll be able to quickly compute the
3324 beginning of a GOT, by computing the end of its predecessor. To
3325 avoid special cases for the primary GOT, while still preserving
3326 assertions that are valid for both single- and multi-got links,
3327 we arrange for the main got struct to have the right number of
3328 global entries, but set its local_gotno such that the initial
3329 offset of the primary GOT is zero. Remember that the primary GOT
3330 will become the last item in the circular linked list, so it
3331 points back to the master GOT. */
3332 gg
->local_gotno
= -g
->global_gotno
;
3333 gg
->global_gotno
= g
->global_gotno
;
3340 struct mips_got_info
*gn
;
3342 assign
+= MIPS_RESERVED_GOTNO
;
3343 g
->assigned_gotno
= assign
;
3344 g
->local_gotno
+= assign
+ pages
;
3345 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
3347 /* Set up any TLS entries. We always place the TLS entries after
3348 all non-TLS entries. */
3349 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
3350 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
3352 /* Take g out of the direct list, and push it onto the reversed
3353 list that gg points to. */
3359 /* Mark global symbols in every non-primary GOT as ineligible for
3362 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
3366 got
->size
= (gg
->next
->local_gotno
3367 + gg
->next
->global_gotno
3368 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
3374 /* Returns the first relocation of type r_type found, beginning with
3375 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3377 static const Elf_Internal_Rela
*
3378 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
3379 const Elf_Internal_Rela
*relocation
,
3380 const Elf_Internal_Rela
*relend
)
3382 while (relocation
< relend
)
3384 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
3390 /* We didn't find it. */
3391 bfd_set_error (bfd_error_bad_value
);
3395 /* Return whether a relocation is against a local symbol. */
3398 mips_elf_local_relocation_p (bfd
*input_bfd
,
3399 const Elf_Internal_Rela
*relocation
,
3400 asection
**local_sections
,
3401 bfd_boolean check_forced
)
3403 unsigned long r_symndx
;
3404 Elf_Internal_Shdr
*symtab_hdr
;
3405 struct mips_elf_link_hash_entry
*h
;
3408 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3409 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3410 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
3412 if (r_symndx
< extsymoff
)
3414 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
3419 /* Look up the hash table to check whether the symbol
3420 was forced local. */
3421 h
= (struct mips_elf_link_hash_entry
*)
3422 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
3423 /* Find the real hash-table entry for this symbol. */
3424 while (h
->root
.root
.type
== bfd_link_hash_indirect
3425 || h
->root
.root
.type
== bfd_link_hash_warning
)
3426 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3427 if (h
->root
.forced_local
)
3434 /* Sign-extend VALUE, which has the indicated number of BITS. */
3437 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
3439 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
3440 /* VALUE is negative. */
3441 value
|= ((bfd_vma
) - 1) << bits
;
3446 /* Return non-zero if the indicated VALUE has overflowed the maximum
3447 range expressible by a signed number with the indicated number of
3451 mips_elf_overflow_p (bfd_vma value
, int bits
)
3453 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
3455 if (svalue
> (1 << (bits
- 1)) - 1)
3456 /* The value is too big. */
3458 else if (svalue
< -(1 << (bits
- 1)))
3459 /* The value is too small. */
3466 /* Calculate the %high function. */
3469 mips_elf_high (bfd_vma value
)
3471 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
3474 /* Calculate the %higher function. */
3477 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
3480 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
3487 /* Calculate the %highest function. */
3490 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
3493 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3500 /* Create the .compact_rel section. */
3503 mips_elf_create_compact_rel_section
3504 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3507 register asection
*s
;
3509 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
3511 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
3514 s
= bfd_make_section (abfd
, ".compact_rel");
3516 || ! bfd_set_section_flags (abfd
, s
, flags
)
3517 || ! bfd_set_section_alignment (abfd
, s
,
3518 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
3521 s
->size
= sizeof (Elf32_External_compact_rel
);
3527 /* Create the .got section to hold the global offset table. */
3530 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
3531 bfd_boolean maybe_exclude
)
3534 register asection
*s
;
3535 struct elf_link_hash_entry
*h
;
3536 struct bfd_link_hash_entry
*bh
;
3537 struct mips_got_info
*g
;
3540 /* This function may be called more than once. */
3541 s
= mips_elf_got_section (abfd
, TRUE
);
3544 if (! maybe_exclude
)
3545 s
->flags
&= ~SEC_EXCLUDE
;
3549 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3550 | SEC_LINKER_CREATED
);
3553 flags
|= SEC_EXCLUDE
;
3555 /* We have to use an alignment of 2**4 here because this is hardcoded
3556 in the function stub generation and in the linker script. */
3557 s
= bfd_make_section (abfd
, ".got");
3559 || ! bfd_set_section_flags (abfd
, s
, flags
)
3560 || ! bfd_set_section_alignment (abfd
, s
, 4))
3563 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3564 linker script because we don't want to define the symbol if we
3565 are not creating a global offset table. */
3567 if (! (_bfd_generic_link_add_one_symbol
3568 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
3569 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3572 h
= (struct elf_link_hash_entry
*) bh
;
3575 h
->type
= STT_OBJECT
;
3578 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3581 amt
= sizeof (struct mips_got_info
);
3582 g
= bfd_alloc (abfd
, amt
);
3585 g
->global_gotsym
= NULL
;
3586 g
->global_gotno
= 0;
3588 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
3589 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
3592 g
->tls_ldm_offset
= MINUS_ONE
;
3593 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3594 mips_elf_got_entry_eq
, NULL
);
3595 if (g
->got_entries
== NULL
)
3597 mips_elf_section_data (s
)->u
.got_info
= g
;
3598 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
3599 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3604 /* Calculate the value produced by the RELOCATION (which comes from
3605 the INPUT_BFD). The ADDEND is the addend to use for this
3606 RELOCATION; RELOCATION->R_ADDEND is ignored.
3608 The result of the relocation calculation is stored in VALUEP.
3609 REQUIRE_JALXP indicates whether or not the opcode used with this
3610 relocation must be JALX.
3612 This function returns bfd_reloc_continue if the caller need take no
3613 further action regarding this relocation, bfd_reloc_notsupported if
3614 something goes dramatically wrong, bfd_reloc_overflow if an
3615 overflow occurs, and bfd_reloc_ok to indicate success. */
3617 static bfd_reloc_status_type
3618 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3619 asection
*input_section
,
3620 struct bfd_link_info
*info
,
3621 const Elf_Internal_Rela
*relocation
,
3622 bfd_vma addend
, reloc_howto_type
*howto
,
3623 Elf_Internal_Sym
*local_syms
,
3624 asection
**local_sections
, bfd_vma
*valuep
,
3625 const char **namep
, bfd_boolean
*require_jalxp
,
3626 bfd_boolean save_addend
)
3628 /* The eventual value we will return. */
3630 /* The address of the symbol against which the relocation is
3633 /* The final GP value to be used for the relocatable, executable, or
3634 shared object file being produced. */
3635 bfd_vma gp
= MINUS_ONE
;
3636 /* The place (section offset or address) of the storage unit being
3639 /* The value of GP used to create the relocatable object. */
3640 bfd_vma gp0
= MINUS_ONE
;
3641 /* The offset into the global offset table at which the address of
3642 the relocation entry symbol, adjusted by the addend, resides
3643 during execution. */
3644 bfd_vma g
= MINUS_ONE
;
3645 /* The section in which the symbol referenced by the relocation is
3647 asection
*sec
= NULL
;
3648 struct mips_elf_link_hash_entry
*h
= NULL
;
3649 /* TRUE if the symbol referred to by this relocation is a local
3651 bfd_boolean local_p
, was_local_p
;
3652 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3653 bfd_boolean gp_disp_p
= FALSE
;
3654 /* TRUE if the symbol referred to by this relocation is
3655 "__gnu_local_gp". */
3656 bfd_boolean gnu_local_gp_p
= FALSE
;
3657 Elf_Internal_Shdr
*symtab_hdr
;
3659 unsigned long r_symndx
;
3661 /* TRUE if overflow occurred during the calculation of the
3662 relocation value. */
3663 bfd_boolean overflowed_p
;
3664 /* TRUE if this relocation refers to a MIPS16 function. */
3665 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3667 /* Parse the relocation. */
3668 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3669 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3670 p
= (input_section
->output_section
->vma
3671 + input_section
->output_offset
3672 + relocation
->r_offset
);
3674 /* Assume that there will be no overflow. */
3675 overflowed_p
= FALSE
;
3677 /* Figure out whether or not the symbol is local, and get the offset
3678 used in the array of hash table entries. */
3679 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3680 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3681 local_sections
, FALSE
);
3682 was_local_p
= local_p
;
3683 if (! elf_bad_symtab (input_bfd
))
3684 extsymoff
= symtab_hdr
->sh_info
;
3687 /* The symbol table does not follow the rule that local symbols
3688 must come before globals. */
3692 /* Figure out the value of the symbol. */
3695 Elf_Internal_Sym
*sym
;
3697 sym
= local_syms
+ r_symndx
;
3698 sec
= local_sections
[r_symndx
];
3700 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3701 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3702 || (sec
->flags
& SEC_MERGE
))
3703 symbol
+= sym
->st_value
;
3704 if ((sec
->flags
& SEC_MERGE
)
3705 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3707 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3709 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3712 /* MIPS16 text labels should be treated as odd. */
3713 if (sym
->st_other
== STO_MIPS16
)
3716 /* Record the name of this symbol, for our caller. */
3717 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3718 symtab_hdr
->sh_link
,
3721 *namep
= bfd_section_name (input_bfd
, sec
);
3723 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3727 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3729 /* For global symbols we look up the symbol in the hash-table. */
3730 h
= ((struct mips_elf_link_hash_entry
*)
3731 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3732 /* Find the real hash-table entry for this symbol. */
3733 while (h
->root
.root
.type
== bfd_link_hash_indirect
3734 || h
->root
.root
.type
== bfd_link_hash_warning
)
3735 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3737 /* Record the name of this symbol, for our caller. */
3738 *namep
= h
->root
.root
.root
.string
;
3740 /* See if this is the special _gp_disp symbol. Note that such a
3741 symbol must always be a global symbol. */
3742 if (strcmp (*namep
, "_gp_disp") == 0
3743 && ! NEWABI_P (input_bfd
))
3745 /* Relocations against _gp_disp are permitted only with
3746 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3747 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3748 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3749 return bfd_reloc_notsupported
;
3753 /* See if this is the special _gp symbol. Note that such a
3754 symbol must always be a global symbol. */
3755 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
3756 gnu_local_gp_p
= TRUE
;
3759 /* If this symbol is defined, calculate its address. Note that
3760 _gp_disp is a magic symbol, always implicitly defined by the
3761 linker, so it's inappropriate to check to see whether or not
3763 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3764 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3765 && h
->root
.root
.u
.def
.section
)
3767 sec
= h
->root
.root
.u
.def
.section
;
3768 if (sec
->output_section
)
3769 symbol
= (h
->root
.root
.u
.def
.value
3770 + sec
->output_section
->vma
3771 + sec
->output_offset
);
3773 symbol
= h
->root
.root
.u
.def
.value
;
3775 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3776 /* We allow relocations against undefined weak symbols, giving
3777 it the value zero, so that you can undefined weak functions
3778 and check to see if they exist by looking at their
3781 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3782 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3784 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
3785 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3787 /* If this is a dynamic link, we should have created a
3788 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3789 in in _bfd_mips_elf_create_dynamic_sections.
3790 Otherwise, we should define the symbol with a value of 0.
3791 FIXME: It should probably get into the symbol table
3793 BFD_ASSERT (! info
->shared
);
3794 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3799 if (! ((*info
->callbacks
->undefined_symbol
)
3800 (info
, h
->root
.root
.root
.string
, input_bfd
,
3801 input_section
, relocation
->r_offset
,
3802 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3803 || ELF_ST_VISIBILITY (h
->root
.other
))))
3804 return bfd_reloc_undefined
;
3808 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3811 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3812 need to redirect the call to the stub, unless we're already *in*
3814 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3815 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3816 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3817 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3818 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3820 /* This is a 32- or 64-bit call to a 16-bit function. We should
3821 have already noticed that we were going to need the
3824 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3827 BFD_ASSERT (h
->need_fn_stub
);
3831 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3833 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3834 need to redirect the call to the stub. */
3835 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3837 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3838 && !target_is_16_bit_code_p
)
3840 /* If both call_stub and call_fp_stub are defined, we can figure
3841 out which one to use by seeing which one appears in the input
3843 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3848 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3850 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3851 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3853 sec
= h
->call_fp_stub
;
3860 else if (h
->call_stub
!= NULL
)
3863 sec
= h
->call_fp_stub
;
3865 BFD_ASSERT (sec
->size
> 0);
3866 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3869 /* Calls from 16-bit code to 32-bit code and vice versa require the
3870 special jalx instruction. */
3871 *require_jalxp
= (!info
->relocatable
3872 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3873 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3875 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3876 local_sections
, TRUE
);
3878 /* If we haven't already determined the GOT offset, or the GP value,
3879 and we're going to need it, get it now. */
3882 case R_MIPS_GOT_PAGE
:
3883 case R_MIPS_GOT_OFST
:
3884 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3886 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3887 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3893 case R_MIPS_GOT_DISP
:
3894 case R_MIPS_GOT_HI16
:
3895 case R_MIPS_CALL_HI16
:
3896 case R_MIPS_GOT_LO16
:
3897 case R_MIPS_CALL_LO16
:
3899 case R_MIPS_TLS_GOTTPREL
:
3900 case R_MIPS_TLS_LDM
:
3901 /* Find the index into the GOT where this value is located. */
3902 if (r_type
== R_MIPS_TLS_LDM
)
3904 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
, 0, 0, NULL
,
3907 return bfd_reloc_outofrange
;
3911 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3912 GOT_PAGE relocation that decays to GOT_DISP because the
3913 symbol turns out to be global. The addend is then added
3915 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3916 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3918 (struct elf_link_hash_entry
*) h
,
3920 if (h
->tls_type
== GOT_NORMAL
3921 && (! elf_hash_table(info
)->dynamic_sections_created
3923 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3924 && h
->root
.def_regular
)))
3926 /* This is a static link or a -Bsymbolic link. The
3927 symbol is defined locally, or was forced to be local.
3928 We must initialize this entry in the GOT. */
3929 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3930 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3931 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3934 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3935 /* There's no need to create a local GOT entry here; the
3936 calculation for a local GOT16 entry does not involve G. */
3940 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3941 info
, symbol
+ addend
, r_symndx
, h
,
3944 return bfd_reloc_outofrange
;
3947 /* Convert GOT indices to actual offsets. */
3948 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3949 abfd
, input_bfd
, g
);
3954 case R_MIPS_GPREL16
:
3955 case R_MIPS_GPREL32
:
3956 case R_MIPS_LITERAL
:
3959 case R_MIPS16_GPREL
:
3960 gp0
= _bfd_get_gp_value (input_bfd
);
3961 gp
= _bfd_get_gp_value (abfd
);
3962 if (elf_hash_table (info
)->dynobj
)
3963 gp
+= mips_elf_adjust_gp (abfd
,
3965 (elf_hash_table (info
)->dynobj
, NULL
),
3976 /* Figure out what kind of relocation is being performed. */
3980 return bfd_reloc_continue
;
3983 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3984 overflowed_p
= mips_elf_overflow_p (value
, 16);
3991 || (elf_hash_table (info
)->dynamic_sections_created
3993 && h
->root
.def_dynamic
3994 && !h
->root
.def_regular
))
3996 && (input_section
->flags
& SEC_ALLOC
) != 0)
3998 /* If we're creating a shared library, or this relocation is
3999 against a symbol in a shared library, then we can't know
4000 where the symbol will end up. So, we create a relocation
4001 record in the output, and leave the job up to the dynamic
4004 if (!mips_elf_create_dynamic_relocation (abfd
,
4012 return bfd_reloc_undefined
;
4014 /* If we've written this we need to set DF_TEXTREL here. */
4015 if (MIPS_ELF_READONLY_SECTION (input_section
))
4016 info
->flags
|= DF_TEXTREL
;
4020 if (r_type
!= R_MIPS_REL32
)
4021 value
= symbol
+ addend
;
4025 value
&= howto
->dst_mask
;
4029 value
= symbol
+ addend
- p
;
4030 value
&= howto
->dst_mask
;
4033 case R_MIPS_GNU_REL16_S2
:
4034 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
4035 overflowed_p
= mips_elf_overflow_p (value
, 18);
4036 value
= (value
>> 2) & howto
->dst_mask
;
4040 /* The calculation for R_MIPS16_26 is just the same as for an
4041 R_MIPS_26. It's only the storage of the relocated field into
4042 the output file that's different. That's handled in
4043 mips_elf_perform_relocation. So, we just fall through to the
4044 R_MIPS_26 case here. */
4047 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
4050 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
4051 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
4052 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
4054 value
&= howto
->dst_mask
;
4057 case R_MIPS_TLS_DTPREL_HI16
:
4058 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
4062 case R_MIPS_TLS_DTPREL_LO16
:
4063 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
4066 case R_MIPS_TLS_TPREL_HI16
:
4067 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
4071 case R_MIPS_TLS_TPREL_LO16
:
4072 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
4079 value
= mips_elf_high (addend
+ symbol
);
4080 value
&= howto
->dst_mask
;
4084 /* For MIPS16 ABI code we generate this sequence
4085 0: li $v0,%hi(_gp_disp)
4086 4: addiupc $v1,%lo(_gp_disp)
4090 So the offsets of hi and lo relocs are the same, but the
4091 $pc is four higher than $t9 would be, so reduce
4092 both reloc addends by 4. */
4093 if (r_type
== R_MIPS16_HI16
)
4094 value
= mips_elf_high (addend
+ gp
- p
- 4);
4096 value
= mips_elf_high (addend
+ gp
- p
);
4097 overflowed_p
= mips_elf_overflow_p (value
, 16);
4104 value
= (symbol
+ addend
) & howto
->dst_mask
;
4107 /* See the comment for R_MIPS16_HI16 above for the reason
4108 for this conditional. */
4109 if (r_type
== R_MIPS16_LO16
)
4110 value
= addend
+ gp
- p
;
4112 value
= addend
+ gp
- p
+ 4;
4113 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4114 for overflow. But, on, say, IRIX5, relocations against
4115 _gp_disp are normally generated from the .cpload
4116 pseudo-op. It generates code that normally looks like
4119 lui $gp,%hi(_gp_disp)
4120 addiu $gp,$gp,%lo(_gp_disp)
4123 Here $t9 holds the address of the function being called,
4124 as required by the MIPS ELF ABI. The R_MIPS_LO16
4125 relocation can easily overflow in this situation, but the
4126 R_MIPS_HI16 relocation will handle the overflow.
4127 Therefore, we consider this a bug in the MIPS ABI, and do
4128 not check for overflow here. */
4132 case R_MIPS_LITERAL
:
4133 /* Because we don't merge literal sections, we can handle this
4134 just like R_MIPS_GPREL16. In the long run, we should merge
4135 shared literals, and then we will need to additional work
4140 case R_MIPS16_GPREL
:
4141 /* The R_MIPS16_GPREL performs the same calculation as
4142 R_MIPS_GPREL16, but stores the relocated bits in a different
4143 order. We don't need to do anything special here; the
4144 differences are handled in mips_elf_perform_relocation. */
4145 case R_MIPS_GPREL16
:
4146 /* Only sign-extend the addend if it was extracted from the
4147 instruction. If the addend was separate, leave it alone,
4148 otherwise we may lose significant bits. */
4149 if (howto
->partial_inplace
)
4150 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
4151 value
= symbol
+ addend
- gp
;
4152 /* If the symbol was local, any earlier relocatable links will
4153 have adjusted its addend with the gp offset, so compensate
4154 for that now. Don't do it for symbols forced local in this
4155 link, though, since they won't have had the gp offset applied
4159 overflowed_p
= mips_elf_overflow_p (value
, 16);
4168 /* The special case is when the symbol is forced to be local. We
4169 need the full address in the GOT since no R_MIPS_LO16 relocation
4171 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
4172 local_sections
, FALSE
);
4173 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
4174 symbol
+ addend
, forced
);
4175 if (value
== MINUS_ONE
)
4176 return bfd_reloc_outofrange
;
4178 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
4179 abfd
, input_bfd
, value
);
4180 overflowed_p
= mips_elf_overflow_p (value
, 16);
4187 case R_MIPS_TLS_GOTTPREL
:
4188 case R_MIPS_TLS_LDM
:
4189 case R_MIPS_GOT_DISP
:
4192 overflowed_p
= mips_elf_overflow_p (value
, 16);
4195 case R_MIPS_GPREL32
:
4196 value
= (addend
+ symbol
+ gp0
- gp
);
4198 value
&= howto
->dst_mask
;
4202 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
4203 overflowed_p
= mips_elf_overflow_p (value
, 16);
4206 case R_MIPS_GOT_HI16
:
4207 case R_MIPS_CALL_HI16
:
4208 /* We're allowed to handle these two relocations identically.
4209 The dynamic linker is allowed to handle the CALL relocations
4210 differently by creating a lazy evaluation stub. */
4212 value
= mips_elf_high (value
);
4213 value
&= howto
->dst_mask
;
4216 case R_MIPS_GOT_LO16
:
4217 case R_MIPS_CALL_LO16
:
4218 value
= g
& howto
->dst_mask
;
4221 case R_MIPS_GOT_PAGE
:
4222 /* GOT_PAGE relocations that reference non-local symbols decay
4223 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4227 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
4228 if (value
== MINUS_ONE
)
4229 return bfd_reloc_outofrange
;
4230 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
4231 abfd
, input_bfd
, value
);
4232 overflowed_p
= mips_elf_overflow_p (value
, 16);
4235 case R_MIPS_GOT_OFST
:
4237 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
4240 overflowed_p
= mips_elf_overflow_p (value
, 16);
4244 value
= symbol
- addend
;
4245 value
&= howto
->dst_mask
;
4249 value
= mips_elf_higher (addend
+ symbol
);
4250 value
&= howto
->dst_mask
;
4253 case R_MIPS_HIGHEST
:
4254 value
= mips_elf_highest (addend
+ symbol
);
4255 value
&= howto
->dst_mask
;
4258 case R_MIPS_SCN_DISP
:
4259 value
= symbol
+ addend
- sec
->output_offset
;
4260 value
&= howto
->dst_mask
;
4264 /* This relocation is only a hint. In some cases, we optimize
4265 it into a bal instruction. But we don't try to optimize
4266 branches to the PLT; that will wind up wasting time. */
4267 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
4268 return bfd_reloc_continue
;
4269 value
= symbol
+ addend
;
4273 case R_MIPS_GNU_VTINHERIT
:
4274 case R_MIPS_GNU_VTENTRY
:
4275 /* We don't do anything with these at present. */
4276 return bfd_reloc_continue
;
4279 /* An unrecognized relocation type. */
4280 return bfd_reloc_notsupported
;
4283 /* Store the VALUE for our caller. */
4285 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
4288 /* Obtain the field relocated by RELOCATION. */
4291 mips_elf_obtain_contents (reloc_howto_type
*howto
,
4292 const Elf_Internal_Rela
*relocation
,
4293 bfd
*input_bfd
, bfd_byte
*contents
)
4296 bfd_byte
*location
= contents
+ relocation
->r_offset
;
4298 /* Obtain the bytes. */
4299 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
4304 /* It has been determined that the result of the RELOCATION is the
4305 VALUE. Use HOWTO to place VALUE into the output file at the
4306 appropriate position. The SECTION is the section to which the
4307 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4308 for the relocation must be either JAL or JALX, and it is
4309 unconditionally converted to JALX.
4311 Returns FALSE if anything goes wrong. */
4314 mips_elf_perform_relocation (struct bfd_link_info
*info
,
4315 reloc_howto_type
*howto
,
4316 const Elf_Internal_Rela
*relocation
,
4317 bfd_vma value
, bfd
*input_bfd
,
4318 asection
*input_section
, bfd_byte
*contents
,
4319 bfd_boolean require_jalx
)
4323 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4325 /* Figure out where the relocation is occurring. */
4326 location
= contents
+ relocation
->r_offset
;
4328 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
4330 /* Obtain the current value. */
4331 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
4333 /* Clear the field we are setting. */
4334 x
&= ~howto
->dst_mask
;
4336 /* Set the field. */
4337 x
|= (value
& howto
->dst_mask
);
4339 /* If required, turn JAL into JALX. */
4343 bfd_vma opcode
= x
>> 26;
4344 bfd_vma jalx_opcode
;
4346 /* Check to see if the opcode is already JAL or JALX. */
4347 if (r_type
== R_MIPS16_26
)
4349 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
4354 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
4358 /* If the opcode is not JAL or JALX, there's a problem. */
4361 (*_bfd_error_handler
)
4362 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4365 (unsigned long) relocation
->r_offset
);
4366 bfd_set_error (bfd_error_bad_value
);
4370 /* Make this the JALX opcode. */
4371 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
4374 /* On the RM9000, bal is faster than jal, because bal uses branch
4375 prediction hardware. If we are linking for the RM9000, and we
4376 see jal, and bal fits, use it instead. Note that this
4377 transformation should be safe for all architectures. */
4378 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
4379 && !info
->relocatable
4381 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
4382 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
4388 addr
= (input_section
->output_section
->vma
4389 + input_section
->output_offset
4390 + relocation
->r_offset
4392 if (r_type
== R_MIPS_26
)
4393 dest
= (value
<< 2) | ((addr
>> 28) << 28);
4397 if (off
<= 0x1ffff && off
>= -0x20000)
4398 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
4401 /* Put the value into the output. */
4402 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
4404 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
4410 /* Returns TRUE if SECTION is a MIPS16 stub section. */
4413 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
4415 const char *name
= bfd_get_section_name (abfd
, section
);
4417 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
4418 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
4419 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
4422 /* Add room for N relocations to the .rel.dyn section in ABFD. */
4425 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
4429 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
4430 BFD_ASSERT (s
!= NULL
);
4434 /* Make room for a null element. */
4435 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4438 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4441 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
4442 is the original relocation, which is now being transformed into a
4443 dynamic relocation. The ADDENDP is adjusted if necessary; the
4444 caller should store the result in place of the original addend. */
4447 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
4448 struct bfd_link_info
*info
,
4449 const Elf_Internal_Rela
*rel
,
4450 struct mips_elf_link_hash_entry
*h
,
4451 asection
*sec
, bfd_vma symbol
,
4452 bfd_vma
*addendp
, asection
*input_section
)
4454 Elf_Internal_Rela outrel
[3];
4459 bfd_boolean defined_p
;
4461 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
4462 dynobj
= elf_hash_table (info
)->dynobj
;
4463 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
4464 BFD_ASSERT (sreloc
!= NULL
);
4465 BFD_ASSERT (sreloc
->contents
!= NULL
);
4466 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
4469 outrel
[0].r_offset
=
4470 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
4471 outrel
[1].r_offset
=
4472 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
4473 outrel
[2].r_offset
=
4474 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
4476 if (outrel
[0].r_offset
== MINUS_ONE
)
4477 /* The relocation field has been deleted. */
4480 if (outrel
[0].r_offset
== MINUS_TWO
)
4482 /* The relocation field has been converted into a relative value of
4483 some sort. Functions like _bfd_elf_write_section_eh_frame expect
4484 the field to be fully relocated, so add in the symbol's value. */
4489 /* We must now calculate the dynamic symbol table index to use
4490 in the relocation. */
4492 && (! info
->symbolic
|| !h
->root
.def_regular
)
4493 /* h->root.dynindx may be -1 if this symbol was marked to
4495 && h
->root
.dynindx
!= -1)
4497 indx
= h
->root
.dynindx
;
4498 if (SGI_COMPAT (output_bfd
))
4499 defined_p
= h
->root
.def_regular
;
4501 /* ??? glibc's ld.so just adds the final GOT entry to the
4502 relocation field. It therefore treats relocs against
4503 defined symbols in the same way as relocs against
4504 undefined symbols. */
4509 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
4511 else if (sec
== NULL
|| sec
->owner
== NULL
)
4513 bfd_set_error (bfd_error_bad_value
);
4518 indx
= elf_section_data (sec
->output_section
)->dynindx
;
4523 /* Instead of generating a relocation using the section
4524 symbol, we may as well make it a fully relative
4525 relocation. We want to avoid generating relocations to
4526 local symbols because we used to generate them
4527 incorrectly, without adding the original symbol value,
4528 which is mandated by the ABI for section symbols. In
4529 order to give dynamic loaders and applications time to
4530 phase out the incorrect use, we refrain from emitting
4531 section-relative relocations. It's not like they're
4532 useful, after all. This should be a bit more efficient
4534 /* ??? Although this behavior is compatible with glibc's ld.so,
4535 the ABI says that relocations against STN_UNDEF should have
4536 a symbol value of 0. Irix rld honors this, so relocations
4537 against STN_UNDEF have no effect. */
4538 if (!SGI_COMPAT (output_bfd
))
4543 /* If the relocation was previously an absolute relocation and
4544 this symbol will not be referred to by the relocation, we must
4545 adjust it by the value we give it in the dynamic symbol table.
4546 Otherwise leave the job up to the dynamic linker. */
4547 if (defined_p
&& r_type
!= R_MIPS_REL32
)
4550 /* The relocation is always an REL32 relocation because we don't
4551 know where the shared library will wind up at load-time. */
4552 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
4554 /* For strict adherence to the ABI specification, we should
4555 generate a R_MIPS_64 relocation record by itself before the
4556 _REL32/_64 record as well, such that the addend is read in as
4557 a 64-bit value (REL32 is a 32-bit relocation, after all).
4558 However, since none of the existing ELF64 MIPS dynamic
4559 loaders seems to care, we don't waste space with these
4560 artificial relocations. If this turns out to not be true,
4561 mips_elf_allocate_dynamic_relocation() should be tweaked so
4562 as to make room for a pair of dynamic relocations per
4563 invocation if ABI_64_P, and here we should generate an
4564 additional relocation record with R_MIPS_64 by itself for a
4565 NULL symbol before this relocation record. */
4566 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
4567 ABI_64_P (output_bfd
)
4570 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
4572 /* Adjust the output offset of the relocation to reference the
4573 correct location in the output file. */
4574 outrel
[0].r_offset
+= (input_section
->output_section
->vma
4575 + input_section
->output_offset
);
4576 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4577 + input_section
->output_offset
);
4578 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4579 + input_section
->output_offset
);
4581 /* Put the relocation back out. We have to use the special
4582 relocation outputter in the 64-bit case since the 64-bit
4583 relocation format is non-standard. */
4584 if (ABI_64_P (output_bfd
))
4586 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4587 (output_bfd
, &outrel
[0],
4589 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4592 bfd_elf32_swap_reloc_out
4593 (output_bfd
, &outrel
[0],
4594 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4596 /* We've now added another relocation. */
4597 ++sreloc
->reloc_count
;
4599 /* Make sure the output section is writable. The dynamic linker
4600 will be writing to it. */
4601 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4604 /* On IRIX5, make an entry of compact relocation info. */
4605 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
4607 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4612 Elf32_crinfo cptrel
;
4614 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4615 cptrel
.vaddr
= (rel
->r_offset
4616 + input_section
->output_section
->vma
4617 + input_section
->output_offset
);
4618 if (r_type
== R_MIPS_REL32
)
4619 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4621 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4622 mips_elf_set_cr_dist2to (cptrel
, 0);
4623 cptrel
.konst
= *addendp
;
4625 cr
= (scpt
->contents
4626 + sizeof (Elf32_External_compact_rel
));
4627 mips_elf_set_cr_relvaddr (cptrel
, 0);
4628 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4629 ((Elf32_External_crinfo
*) cr
4630 + scpt
->reloc_count
));
4631 ++scpt
->reloc_count
;
4638 /* Return the MACH for a MIPS e_flags value. */
4641 _bfd_elf_mips_mach (flagword flags
)
4643 switch (flags
& EF_MIPS_MACH
)
4645 case E_MIPS_MACH_3900
:
4646 return bfd_mach_mips3900
;
4648 case E_MIPS_MACH_4010
:
4649 return bfd_mach_mips4010
;
4651 case E_MIPS_MACH_4100
:
4652 return bfd_mach_mips4100
;
4654 case E_MIPS_MACH_4111
:
4655 return bfd_mach_mips4111
;
4657 case E_MIPS_MACH_4120
:
4658 return bfd_mach_mips4120
;
4660 case E_MIPS_MACH_4650
:
4661 return bfd_mach_mips4650
;
4663 case E_MIPS_MACH_5400
:
4664 return bfd_mach_mips5400
;
4666 case E_MIPS_MACH_5500
:
4667 return bfd_mach_mips5500
;
4669 case E_MIPS_MACH_9000
:
4670 return bfd_mach_mips9000
;
4672 case E_MIPS_MACH_SB1
:
4673 return bfd_mach_mips_sb1
;
4676 switch (flags
& EF_MIPS_ARCH
)
4680 return bfd_mach_mips3000
;
4684 return bfd_mach_mips6000
;
4688 return bfd_mach_mips4000
;
4692 return bfd_mach_mips8000
;
4696 return bfd_mach_mips5
;
4699 case E_MIPS_ARCH_32
:
4700 return bfd_mach_mipsisa32
;
4703 case E_MIPS_ARCH_64
:
4704 return bfd_mach_mipsisa64
;
4707 case E_MIPS_ARCH_32R2
:
4708 return bfd_mach_mipsisa32r2
;
4711 case E_MIPS_ARCH_64R2
:
4712 return bfd_mach_mipsisa64r2
;
4720 /* Return printable name for ABI. */
4722 static INLINE
char *
4723 elf_mips_abi_name (bfd
*abfd
)
4727 flags
= elf_elfheader (abfd
)->e_flags
;
4728 switch (flags
& EF_MIPS_ABI
)
4731 if (ABI_N32_P (abfd
))
4733 else if (ABI_64_P (abfd
))
4737 case E_MIPS_ABI_O32
:
4739 case E_MIPS_ABI_O64
:
4741 case E_MIPS_ABI_EABI32
:
4743 case E_MIPS_ABI_EABI64
:
4746 return "unknown abi";
4750 /* MIPS ELF uses two common sections. One is the usual one, and the
4751 other is for small objects. All the small objects are kept
4752 together, and then referenced via the gp pointer, which yields
4753 faster assembler code. This is what we use for the small common
4754 section. This approach is copied from ecoff.c. */
4755 static asection mips_elf_scom_section
;
4756 static asymbol mips_elf_scom_symbol
;
4757 static asymbol
*mips_elf_scom_symbol_ptr
;
4759 /* MIPS ELF also uses an acommon section, which represents an
4760 allocated common symbol which may be overridden by a
4761 definition in a shared library. */
4762 static asection mips_elf_acom_section
;
4763 static asymbol mips_elf_acom_symbol
;
4764 static asymbol
*mips_elf_acom_symbol_ptr
;
4766 /* Handle the special MIPS section numbers that a symbol may use.
4767 This is used for both the 32-bit and the 64-bit ABI. */
4770 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4772 elf_symbol_type
*elfsym
;
4774 elfsym
= (elf_symbol_type
*) asym
;
4775 switch (elfsym
->internal_elf_sym
.st_shndx
)
4777 case SHN_MIPS_ACOMMON
:
4778 /* This section is used in a dynamically linked executable file.
4779 It is an allocated common section. The dynamic linker can
4780 either resolve these symbols to something in a shared
4781 library, or it can just leave them here. For our purposes,
4782 we can consider these symbols to be in a new section. */
4783 if (mips_elf_acom_section
.name
== NULL
)
4785 /* Initialize the acommon section. */
4786 mips_elf_acom_section
.name
= ".acommon";
4787 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4788 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4789 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4790 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4791 mips_elf_acom_symbol
.name
= ".acommon";
4792 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4793 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4794 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4796 asym
->section
= &mips_elf_acom_section
;
4800 /* Common symbols less than the GP size are automatically
4801 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4802 if (asym
->value
> elf_gp_size (abfd
)
4803 || IRIX_COMPAT (abfd
) == ict_irix6
)
4806 case SHN_MIPS_SCOMMON
:
4807 if (mips_elf_scom_section
.name
== NULL
)
4809 /* Initialize the small common section. */
4810 mips_elf_scom_section
.name
= ".scommon";
4811 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4812 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4813 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4814 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4815 mips_elf_scom_symbol
.name
= ".scommon";
4816 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4817 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4818 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4820 asym
->section
= &mips_elf_scom_section
;
4821 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4824 case SHN_MIPS_SUNDEFINED
:
4825 asym
->section
= bfd_und_section_ptr
;
4830 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
4832 BFD_ASSERT (SGI_COMPAT (abfd
));
4833 if (section
!= NULL
)
4835 asym
->section
= section
;
4836 /* MIPS_TEXT is a bit special, the address is not an offset
4837 to the base of the .text section. So substract the section
4838 base address to make it an offset. */
4839 asym
->value
-= section
->vma
;
4846 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
4848 BFD_ASSERT (SGI_COMPAT (abfd
));
4849 if (section
!= NULL
)
4851 asym
->section
= section
;
4852 /* MIPS_DATA is a bit special, the address is not an offset
4853 to the base of the .data section. So substract the section
4854 base address to make it an offset. */
4855 asym
->value
-= section
->vma
;
4862 /* Implement elf_backend_eh_frame_address_size. This differs from
4863 the default in the way it handles EABI64.
4865 EABI64 was originally specified as an LP64 ABI, and that is what
4866 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4867 historically accepted the combination of -mabi=eabi and -mlong32,
4868 and this ILP32 variation has become semi-official over time.
4869 Both forms use elf32 and have pointer-sized FDE addresses.
4871 If an EABI object was generated by GCC 4.0 or above, it will have
4872 an empty .gcc_compiled_longXX section, where XX is the size of longs
4873 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4874 have no special marking to distinguish them from LP64 objects.
4876 We don't want users of the official LP64 ABI to be punished for the
4877 existence of the ILP32 variant, but at the same time, we don't want
4878 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4879 We therefore take the following approach:
4881 - If ABFD contains a .gcc_compiled_longXX section, use it to
4882 determine the pointer size.
4884 - Otherwise check the type of the first relocation. Assume that
4885 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4889 The second check is enough to detect LP64 objects generated by pre-4.0
4890 compilers because, in the kind of output generated by those compilers,
4891 the first relocation will be associated with either a CIE personality
4892 routine or an FDE start address. Furthermore, the compilers never
4893 used a special (non-pointer) encoding for this ABI.
4895 Checking the relocation type should also be safe because there is no
4896 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4900 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
4902 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
4904 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
4906 bfd_boolean long32_p
, long64_p
;
4908 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
4909 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
4910 if (long32_p
&& long64_p
)
4917 if (sec
->reloc_count
> 0
4918 && elf_section_data (sec
)->relocs
!= NULL
4919 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
4928 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4929 relocations against two unnamed section symbols to resolve to the
4930 same address. For example, if we have code like:
4932 lw $4,%got_disp(.data)($gp)
4933 lw $25,%got_disp(.text)($gp)
4936 then the linker will resolve both relocations to .data and the program
4937 will jump there rather than to .text.
4939 We can work around this problem by giving names to local section symbols.
4940 This is also what the MIPSpro tools do. */
4943 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4945 return SGI_COMPAT (abfd
);
4948 /* Work over a section just before writing it out. This routine is
4949 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4950 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4954 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4956 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4957 && hdr
->sh_size
> 0)
4961 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4962 BFD_ASSERT (hdr
->contents
== NULL
);
4965 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4968 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4969 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4973 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4974 && hdr
->bfd_section
!= NULL
4975 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4976 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4978 bfd_byte
*contents
, *l
, *lend
;
4980 /* We stored the section contents in the tdata field in the
4981 set_section_contents routine. We save the section contents
4982 so that we don't have to read them again.
4983 At this point we know that elf_gp is set, so we can look
4984 through the section contents to see if there is an
4985 ODK_REGINFO structure. */
4987 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4989 lend
= contents
+ hdr
->sh_size
;
4990 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4992 Elf_Internal_Options intopt
;
4994 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4996 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5003 + sizeof (Elf_External_Options
)
5004 + (sizeof (Elf64_External_RegInfo
) - 8)),
5007 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5008 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5011 else if (intopt
.kind
== ODK_REGINFO
)
5018 + sizeof (Elf_External_Options
)
5019 + (sizeof (Elf32_External_RegInfo
) - 4)),
5022 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5023 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5030 if (hdr
->bfd_section
!= NULL
)
5032 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5034 if (strcmp (name
, ".sdata") == 0
5035 || strcmp (name
, ".lit8") == 0
5036 || strcmp (name
, ".lit4") == 0)
5038 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5039 hdr
->sh_type
= SHT_PROGBITS
;
5041 else if (strcmp (name
, ".sbss") == 0)
5043 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5044 hdr
->sh_type
= SHT_NOBITS
;
5046 else if (strcmp (name
, ".srdata") == 0)
5048 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5049 hdr
->sh_type
= SHT_PROGBITS
;
5051 else if (strcmp (name
, ".compact_rel") == 0)
5054 hdr
->sh_type
= SHT_PROGBITS
;
5056 else if (strcmp (name
, ".rtproc") == 0)
5058 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5060 unsigned int adjust
;
5062 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5064 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5072 /* Handle a MIPS specific section when reading an object file. This
5073 is called when elfcode.h finds a section with an unknown type.
5074 This routine supports both the 32-bit and 64-bit ELF ABI.
5076 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5080 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5081 Elf_Internal_Shdr
*hdr
,
5087 /* There ought to be a place to keep ELF backend specific flags, but
5088 at the moment there isn't one. We just keep track of the
5089 sections by their name, instead. Fortunately, the ABI gives
5090 suggested names for all the MIPS specific sections, so we will
5091 probably get away with this. */
5092 switch (hdr
->sh_type
)
5094 case SHT_MIPS_LIBLIST
:
5095 if (strcmp (name
, ".liblist") != 0)
5099 if (strcmp (name
, ".msym") != 0)
5102 case SHT_MIPS_CONFLICT
:
5103 if (strcmp (name
, ".conflict") != 0)
5106 case SHT_MIPS_GPTAB
:
5107 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
5110 case SHT_MIPS_UCODE
:
5111 if (strcmp (name
, ".ucode") != 0)
5114 case SHT_MIPS_DEBUG
:
5115 if (strcmp (name
, ".mdebug") != 0)
5117 flags
= SEC_DEBUGGING
;
5119 case SHT_MIPS_REGINFO
:
5120 if (strcmp (name
, ".reginfo") != 0
5121 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5123 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5125 case SHT_MIPS_IFACE
:
5126 if (strcmp (name
, ".MIPS.interfaces") != 0)
5129 case SHT_MIPS_CONTENT
:
5130 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
5133 case SHT_MIPS_OPTIONS
:
5134 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
5137 case SHT_MIPS_DWARF
:
5138 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
5141 case SHT_MIPS_SYMBOL_LIB
:
5142 if (strcmp (name
, ".MIPS.symlib") != 0)
5145 case SHT_MIPS_EVENTS
:
5146 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
5147 && strncmp (name
, ".MIPS.post_rel",
5148 sizeof ".MIPS.post_rel" - 1) != 0)
5155 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5160 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5161 (bfd_get_section_flags (abfd
,
5167 /* FIXME: We should record sh_info for a .gptab section. */
5169 /* For a .reginfo section, set the gp value in the tdata information
5170 from the contents of this section. We need the gp value while
5171 processing relocs, so we just get it now. The .reginfo section
5172 is not used in the 64-bit MIPS ELF ABI. */
5173 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5175 Elf32_External_RegInfo ext
;
5178 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5179 &ext
, 0, sizeof ext
))
5181 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5182 elf_gp (abfd
) = s
.ri_gp_value
;
5185 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5186 set the gp value based on what we find. We may see both
5187 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5188 they should agree. */
5189 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5191 bfd_byte
*contents
, *l
, *lend
;
5193 contents
= bfd_malloc (hdr
->sh_size
);
5194 if (contents
== NULL
)
5196 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5203 lend
= contents
+ hdr
->sh_size
;
5204 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5206 Elf_Internal_Options intopt
;
5208 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5210 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5212 Elf64_Internal_RegInfo intreg
;
5214 bfd_mips_elf64_swap_reginfo_in
5216 ((Elf64_External_RegInfo
*)
5217 (l
+ sizeof (Elf_External_Options
))),
5219 elf_gp (abfd
) = intreg
.ri_gp_value
;
5221 else if (intopt
.kind
== ODK_REGINFO
)
5223 Elf32_RegInfo intreg
;
5225 bfd_mips_elf32_swap_reginfo_in
5227 ((Elf32_External_RegInfo
*)
5228 (l
+ sizeof (Elf_External_Options
))),
5230 elf_gp (abfd
) = intreg
.ri_gp_value
;
5240 /* Set the correct type for a MIPS ELF section. We do this by the
5241 section name, which is a hack, but ought to work. This routine is
5242 used by both the 32-bit and the 64-bit ABI. */
5245 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5247 register const char *name
;
5249 name
= bfd_get_section_name (abfd
, sec
);
5251 if (strcmp (name
, ".liblist") == 0)
5253 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5254 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5255 /* The sh_link field is set in final_write_processing. */
5257 else if (strcmp (name
, ".conflict") == 0)
5258 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5259 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
5261 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5262 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5263 /* The sh_info field is set in final_write_processing. */
5265 else if (strcmp (name
, ".ucode") == 0)
5266 hdr
->sh_type
= SHT_MIPS_UCODE
;
5267 else if (strcmp (name
, ".mdebug") == 0)
5269 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5270 /* In a shared object on IRIX 5.3, the .mdebug section has an
5271 entsize of 0. FIXME: Does this matter? */
5272 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5273 hdr
->sh_entsize
= 0;
5275 hdr
->sh_entsize
= 1;
5277 else if (strcmp (name
, ".reginfo") == 0)
5279 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5280 /* In a shared object on IRIX 5.3, the .reginfo section has an
5281 entsize of 0x18. FIXME: Does this matter? */
5282 if (SGI_COMPAT (abfd
))
5284 if ((abfd
->flags
& DYNAMIC
) != 0)
5285 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5287 hdr
->sh_entsize
= 1;
5290 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5292 else if (SGI_COMPAT (abfd
)
5293 && (strcmp (name
, ".hash") == 0
5294 || strcmp (name
, ".dynamic") == 0
5295 || strcmp (name
, ".dynstr") == 0))
5297 if (SGI_COMPAT (abfd
))
5298 hdr
->sh_entsize
= 0;
5300 /* This isn't how the IRIX6 linker behaves. */
5301 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5304 else if (strcmp (name
, ".got") == 0
5305 || strcmp (name
, ".srdata") == 0
5306 || strcmp (name
, ".sdata") == 0
5307 || strcmp (name
, ".sbss") == 0
5308 || strcmp (name
, ".lit4") == 0
5309 || strcmp (name
, ".lit8") == 0)
5310 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
5311 else if (strcmp (name
, ".MIPS.interfaces") == 0)
5313 hdr
->sh_type
= SHT_MIPS_IFACE
;
5314 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5316 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
5318 hdr
->sh_type
= SHT_MIPS_CONTENT
;
5319 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5320 /* The sh_info field is set in final_write_processing. */
5322 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
5324 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
5325 hdr
->sh_entsize
= 1;
5326 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5328 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
5329 hdr
->sh_type
= SHT_MIPS_DWARF
;
5330 else if (strcmp (name
, ".MIPS.symlib") == 0)
5332 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
5333 /* The sh_link and sh_info fields are set in
5334 final_write_processing. */
5336 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
5337 || strncmp (name
, ".MIPS.post_rel",
5338 sizeof ".MIPS.post_rel" - 1) == 0)
5340 hdr
->sh_type
= SHT_MIPS_EVENTS
;
5341 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5342 /* The sh_link field is set in final_write_processing. */
5344 else if (strcmp (name
, ".msym") == 0)
5346 hdr
->sh_type
= SHT_MIPS_MSYM
;
5347 hdr
->sh_flags
|= SHF_ALLOC
;
5348 hdr
->sh_entsize
= 8;
5351 /* The generic elf_fake_sections will set up REL_HDR using the default
5352 kind of relocations. We used to set up a second header for the
5353 non-default kind of relocations here, but only NewABI would use
5354 these, and the IRIX ld doesn't like resulting empty RELA sections.
5355 Thus we create those header only on demand now. */
5360 /* Given a BFD section, try to locate the corresponding ELF section
5361 index. This is used by both the 32-bit and the 64-bit ABI.
5362 Actually, it's not clear to me that the 64-bit ABI supports these,
5363 but for non-PIC objects we will certainly want support for at least
5364 the .scommon section. */
5367 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5368 asection
*sec
, int *retval
)
5370 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
5372 *retval
= SHN_MIPS_SCOMMON
;
5375 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
5377 *retval
= SHN_MIPS_ACOMMON
;
5383 /* Hook called by the linker routine which adds symbols from an object
5384 file. We must handle the special MIPS section numbers here. */
5387 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5388 Elf_Internal_Sym
*sym
, const char **namep
,
5389 flagword
*flagsp ATTRIBUTE_UNUSED
,
5390 asection
**secp
, bfd_vma
*valp
)
5392 if (SGI_COMPAT (abfd
)
5393 && (abfd
->flags
& DYNAMIC
) != 0
5394 && strcmp (*namep
, "_rld_new_interface") == 0)
5396 /* Skip IRIX5 rld entry name. */
5401 switch (sym
->st_shndx
)
5404 /* Common symbols less than the GP size are automatically
5405 treated as SHN_MIPS_SCOMMON symbols. */
5406 if (sym
->st_size
> elf_gp_size (abfd
)
5407 || IRIX_COMPAT (abfd
) == ict_irix6
)
5410 case SHN_MIPS_SCOMMON
:
5411 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
5412 (*secp
)->flags
|= SEC_IS_COMMON
;
5413 *valp
= sym
->st_size
;
5417 /* This section is used in a shared object. */
5418 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
5420 asymbol
*elf_text_symbol
;
5421 asection
*elf_text_section
;
5422 bfd_size_type amt
= sizeof (asection
);
5424 elf_text_section
= bfd_zalloc (abfd
, amt
);
5425 if (elf_text_section
== NULL
)
5428 amt
= sizeof (asymbol
);
5429 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
5430 if (elf_text_symbol
== NULL
)
5433 /* Initialize the section. */
5435 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
5436 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
5438 elf_text_section
->symbol
= elf_text_symbol
;
5439 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
5441 elf_text_section
->name
= ".text";
5442 elf_text_section
->flags
= SEC_NO_FLAGS
;
5443 elf_text_section
->output_section
= NULL
;
5444 elf_text_section
->owner
= abfd
;
5445 elf_text_symbol
->name
= ".text";
5446 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5447 elf_text_symbol
->section
= elf_text_section
;
5449 /* This code used to do *secp = bfd_und_section_ptr if
5450 info->shared. I don't know why, and that doesn't make sense,
5451 so I took it out. */
5452 *secp
= elf_tdata (abfd
)->elf_text_section
;
5455 case SHN_MIPS_ACOMMON
:
5456 /* Fall through. XXX Can we treat this as allocated data? */
5458 /* This section is used in a shared object. */
5459 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
5461 asymbol
*elf_data_symbol
;
5462 asection
*elf_data_section
;
5463 bfd_size_type amt
= sizeof (asection
);
5465 elf_data_section
= bfd_zalloc (abfd
, amt
);
5466 if (elf_data_section
== NULL
)
5469 amt
= sizeof (asymbol
);
5470 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
5471 if (elf_data_symbol
== NULL
)
5474 /* Initialize the section. */
5476 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
5477 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
5479 elf_data_section
->symbol
= elf_data_symbol
;
5480 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
5482 elf_data_section
->name
= ".data";
5483 elf_data_section
->flags
= SEC_NO_FLAGS
;
5484 elf_data_section
->output_section
= NULL
;
5485 elf_data_section
->owner
= abfd
;
5486 elf_data_symbol
->name
= ".data";
5487 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5488 elf_data_symbol
->section
= elf_data_section
;
5490 /* This code used to do *secp = bfd_und_section_ptr if
5491 info->shared. I don't know why, and that doesn't make sense,
5492 so I took it out. */
5493 *secp
= elf_tdata (abfd
)->elf_data_section
;
5496 case SHN_MIPS_SUNDEFINED
:
5497 *secp
= bfd_und_section_ptr
;
5501 if (SGI_COMPAT (abfd
)
5503 && info
->hash
->creator
== abfd
->xvec
5504 && strcmp (*namep
, "__rld_obj_head") == 0)
5506 struct elf_link_hash_entry
*h
;
5507 struct bfd_link_hash_entry
*bh
;
5509 /* Mark __rld_obj_head as dynamic. */
5511 if (! (_bfd_generic_link_add_one_symbol
5512 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
5513 get_elf_backend_data (abfd
)->collect
, &bh
)))
5516 h
= (struct elf_link_hash_entry
*) bh
;
5519 h
->type
= STT_OBJECT
;
5521 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5524 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
5527 /* If this is a mips16 text symbol, add 1 to the value to make it
5528 odd. This will cause something like .word SYM to come up with
5529 the right value when it is loaded into the PC. */
5530 if (sym
->st_other
== STO_MIPS16
)
5536 /* This hook function is called before the linker writes out a global
5537 symbol. We mark symbols as small common if appropriate. This is
5538 also where we undo the increment of the value for a mips16 symbol. */
5541 _bfd_mips_elf_link_output_symbol_hook
5542 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5543 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
5544 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
5546 /* If we see a common symbol, which implies a relocatable link, then
5547 if a symbol was small common in an input file, mark it as small
5548 common in the output file. */
5549 if (sym
->st_shndx
== SHN_COMMON
5550 && strcmp (input_sec
->name
, ".scommon") == 0)
5551 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
5553 if (sym
->st_other
== STO_MIPS16
)
5554 sym
->st_value
&= ~1;
5559 /* Functions for the dynamic linker. */
5561 /* Create dynamic sections when linking against a dynamic object. */
5564 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5566 struct elf_link_hash_entry
*h
;
5567 struct bfd_link_hash_entry
*bh
;
5569 register asection
*s
;
5570 const char * const *namep
;
5572 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5573 | SEC_LINKER_CREATED
| SEC_READONLY
);
5575 /* Mips ABI requests the .dynamic section to be read only. */
5576 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5579 if (! bfd_set_section_flags (abfd
, s
, flags
))
5583 /* We need to create .got section. */
5584 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
5587 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
5590 /* Create .stub section. */
5591 if (bfd_get_section_by_name (abfd
,
5592 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
5594 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
5596 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
5597 || ! bfd_set_section_alignment (abfd
, s
,
5598 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5602 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
5604 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
5606 s
= bfd_make_section (abfd
, ".rld_map");
5608 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
5609 || ! bfd_set_section_alignment (abfd
, s
,
5610 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5614 /* On IRIX5, we adjust add some additional symbols and change the
5615 alignments of several sections. There is no ABI documentation
5616 indicating that this is necessary on IRIX6, nor any evidence that
5617 the linker takes such action. */
5618 if (IRIX_COMPAT (abfd
) == ict_irix5
)
5620 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
5623 if (! (_bfd_generic_link_add_one_symbol
5624 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
5625 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5628 h
= (struct elf_link_hash_entry
*) bh
;
5631 h
->type
= STT_SECTION
;
5633 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5637 /* We need to create a .compact_rel section. */
5638 if (SGI_COMPAT (abfd
))
5640 if (!mips_elf_create_compact_rel_section (abfd
, info
))
5644 /* Change alignments of some sections. */
5645 s
= bfd_get_section_by_name (abfd
, ".hash");
5647 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5648 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5650 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5651 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5653 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5654 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5656 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5657 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5659 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5666 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5668 if (!(_bfd_generic_link_add_one_symbol
5669 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5670 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5673 h
= (struct elf_link_hash_entry
*) bh
;
5676 h
->type
= STT_SECTION
;
5678 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5681 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5683 /* __rld_map is a four byte word located in the .data section
5684 and is filled in by the rtld to contain a pointer to
5685 the _r_debug structure. Its symbol value will be set in
5686 _bfd_mips_elf_finish_dynamic_symbol. */
5687 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5688 BFD_ASSERT (s
!= NULL
);
5690 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5692 if (!(_bfd_generic_link_add_one_symbol
5693 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5694 get_elf_backend_data (abfd
)->collect
, &bh
)))
5697 h
= (struct elf_link_hash_entry
*) bh
;
5700 h
->type
= STT_OBJECT
;
5702 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5710 /* Look through the relocs for a section during the first phase, and
5711 allocate space in the global offset table. */
5714 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5715 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5719 Elf_Internal_Shdr
*symtab_hdr
;
5720 struct elf_link_hash_entry
**sym_hashes
;
5721 struct mips_got_info
*g
;
5723 const Elf_Internal_Rela
*rel
;
5724 const Elf_Internal_Rela
*rel_end
;
5727 const struct elf_backend_data
*bed
;
5729 if (info
->relocatable
)
5732 dynobj
= elf_hash_table (info
)->dynobj
;
5733 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5734 sym_hashes
= elf_sym_hashes (abfd
);
5735 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5737 /* Check for the mips16 stub sections. */
5739 name
= bfd_get_section_name (abfd
, sec
);
5740 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5742 unsigned long r_symndx
;
5744 /* Look at the relocation information to figure out which symbol
5747 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5749 if (r_symndx
< extsymoff
5750 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5754 /* This stub is for a local symbol. This stub will only be
5755 needed if there is some relocation in this BFD, other
5756 than a 16 bit function call, which refers to this symbol. */
5757 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5759 Elf_Internal_Rela
*sec_relocs
;
5760 const Elf_Internal_Rela
*r
, *rend
;
5762 /* We can ignore stub sections when looking for relocs. */
5763 if ((o
->flags
& SEC_RELOC
) == 0
5764 || o
->reloc_count
== 0
5765 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5766 sizeof FN_STUB
- 1) == 0
5767 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5768 sizeof CALL_STUB
- 1) == 0
5769 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5770 sizeof CALL_FP_STUB
- 1) == 0)
5774 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5776 if (sec_relocs
== NULL
)
5779 rend
= sec_relocs
+ o
->reloc_count
;
5780 for (r
= sec_relocs
; r
< rend
; r
++)
5781 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5782 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5785 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5794 /* There is no non-call reloc for this stub, so we do
5795 not need it. Since this function is called before
5796 the linker maps input sections to output sections, we
5797 can easily discard it by setting the SEC_EXCLUDE
5799 sec
->flags
|= SEC_EXCLUDE
;
5803 /* Record this stub in an array of local symbol stubs for
5805 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5807 unsigned long symcount
;
5811 if (elf_bad_symtab (abfd
))
5812 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5814 symcount
= symtab_hdr
->sh_info
;
5815 amt
= symcount
* sizeof (asection
*);
5816 n
= bfd_zalloc (abfd
, amt
);
5819 elf_tdata (abfd
)->local_stubs
= n
;
5822 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5824 /* We don't need to set mips16_stubs_seen in this case.
5825 That flag is used to see whether we need to look through
5826 the global symbol table for stubs. We don't need to set
5827 it here, because we just have a local stub. */
5831 struct mips_elf_link_hash_entry
*h
;
5833 h
= ((struct mips_elf_link_hash_entry
*)
5834 sym_hashes
[r_symndx
- extsymoff
]);
5836 /* H is the symbol this stub is for. */
5839 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5842 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5843 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5845 unsigned long r_symndx
;
5846 struct mips_elf_link_hash_entry
*h
;
5849 /* Look at the relocation information to figure out which symbol
5852 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5854 if (r_symndx
< extsymoff
5855 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5857 /* This stub was actually built for a static symbol defined
5858 in the same file. We assume that all static symbols in
5859 mips16 code are themselves mips16, so we can simply
5860 discard this stub. Since this function is called before
5861 the linker maps input sections to output sections, we can
5862 easily discard it by setting the SEC_EXCLUDE flag. */
5863 sec
->flags
|= SEC_EXCLUDE
;
5867 h
= ((struct mips_elf_link_hash_entry
*)
5868 sym_hashes
[r_symndx
- extsymoff
]);
5870 /* H is the symbol this stub is for. */
5872 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5873 loc
= &h
->call_fp_stub
;
5875 loc
= &h
->call_stub
;
5877 /* If we already have an appropriate stub for this function, we
5878 don't need another one, so we can discard this one. Since
5879 this function is called before the linker maps input sections
5880 to output sections, we can easily discard it by setting the
5881 SEC_EXCLUDE flag. We can also discard this section if we
5882 happen to already know that this is a mips16 function; it is
5883 not necessary to check this here, as it is checked later, but
5884 it is slightly faster to check now. */
5885 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5887 sec
->flags
|= SEC_EXCLUDE
;
5892 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5902 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5907 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5908 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5909 BFD_ASSERT (g
!= NULL
);
5914 bed
= get_elf_backend_data (abfd
);
5915 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5916 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5918 unsigned long r_symndx
;
5919 unsigned int r_type
;
5920 struct elf_link_hash_entry
*h
;
5922 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5923 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5925 if (r_symndx
< extsymoff
)
5927 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5929 (*_bfd_error_handler
)
5930 (_("%B: Malformed reloc detected for section %s"),
5932 bfd_set_error (bfd_error_bad_value
);
5937 h
= sym_hashes
[r_symndx
- extsymoff
];
5939 /* This may be an indirect symbol created because of a version. */
5942 while (h
->root
.type
== bfd_link_hash_indirect
)
5943 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5947 /* Some relocs require a global offset table. */
5948 if (dynobj
== NULL
|| sgot
== NULL
)
5954 case R_MIPS_CALL_HI16
:
5955 case R_MIPS_CALL_LO16
:
5956 case R_MIPS_GOT_HI16
:
5957 case R_MIPS_GOT_LO16
:
5958 case R_MIPS_GOT_PAGE
:
5959 case R_MIPS_GOT_OFST
:
5960 case R_MIPS_GOT_DISP
:
5962 case R_MIPS_TLS_LDM
:
5964 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5965 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5967 g
= mips_elf_got_info (dynobj
, &sgot
);
5974 && (info
->shared
|| h
!= NULL
)
5975 && (sec
->flags
& SEC_ALLOC
) != 0)
5976 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5984 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5985 || r_type
== R_MIPS_GOT_LO16
5986 || r_type
== R_MIPS_GOT_DISP
))
5988 /* We may need a local GOT entry for this relocation. We
5989 don't count R_MIPS_GOT_PAGE because we can estimate the
5990 maximum number of pages needed by looking at the size of
5991 the segment. Similar comments apply to R_MIPS_GOT16 and
5992 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5993 R_MIPS_CALL_HI16 because these are always followed by an
5994 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5995 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5996 rel
->r_addend
, g
, 0))
6005 (*_bfd_error_handler
)
6006 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6007 abfd
, (unsigned long) rel
->r_offset
);
6008 bfd_set_error (bfd_error_bad_value
);
6013 case R_MIPS_CALL_HI16
:
6014 case R_MIPS_CALL_LO16
:
6017 /* This symbol requires a global offset table entry. */
6018 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6021 /* We need a stub, not a plt entry for the undefined
6022 function. But we record it as if it needs plt. See
6023 _bfd_elf_adjust_dynamic_symbol. */
6029 case R_MIPS_GOT_PAGE
:
6030 /* If this is a global, overridable symbol, GOT_PAGE will
6031 decay to GOT_DISP, so we'll need a GOT entry for it. */
6036 struct mips_elf_link_hash_entry
*hmips
=
6037 (struct mips_elf_link_hash_entry
*) h
;
6039 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
6040 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
6041 hmips
= (struct mips_elf_link_hash_entry
*)
6042 hmips
->root
.root
.u
.i
.link
;
6044 if (hmips
->root
.def_regular
6045 && ! (info
->shared
&& ! info
->symbolic
6046 && ! hmips
->root
.forced_local
))
6052 case R_MIPS_GOT_HI16
:
6053 case R_MIPS_GOT_LO16
:
6054 case R_MIPS_GOT_DISP
:
6055 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6059 case R_MIPS_TLS_GOTTPREL
:
6061 info
->flags
|= DF_STATIC_TLS
;
6064 case R_MIPS_TLS_LDM
:
6065 if (r_type
== R_MIPS_TLS_LDM
)
6073 /* This symbol requires a global offset table entry, or two
6074 for TLS GD relocations. */
6076 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
6078 : r_type
== R_MIPS_TLS_LDM
6083 struct mips_elf_link_hash_entry
*hmips
=
6084 (struct mips_elf_link_hash_entry
*) h
;
6085 hmips
->tls_type
|= flag
;
6087 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, flag
))
6092 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
6094 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6095 rel
->r_addend
, g
, flag
))
6104 if ((info
->shared
|| h
!= NULL
)
6105 && (sec
->flags
& SEC_ALLOC
) != 0)
6109 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
6115 /* When creating a shared object, we must copy these
6116 reloc types into the output file as R_MIPS_REL32
6117 relocs. We make room for this reloc in the
6118 .rel.dyn reloc section. */
6119 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
6122 struct mips_elf_link_hash_entry
*hmips
;
6124 /* We only need to copy this reloc if the symbol is
6125 defined in a dynamic object. */
6126 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6127 ++hmips
->possibly_dynamic_relocs
;
6130 /* Even though we don't directly need a GOT entry for
6131 this symbol, a symbol must have a dynamic symbol
6132 table index greater that DT_MIPS_GOTSYM if there are
6133 dynamic relocations against it. */
6137 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6138 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
6140 g
= mips_elf_got_info (dynobj
, &sgot
);
6141 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6146 if (SGI_COMPAT (abfd
))
6147 mips_elf_hash_table (info
)->compact_rel_size
+=
6148 sizeof (Elf32_External_crinfo
);
6152 case R_MIPS_GPREL16
:
6153 case R_MIPS_LITERAL
:
6154 case R_MIPS_GPREL32
:
6155 if (SGI_COMPAT (abfd
))
6156 mips_elf_hash_table (info
)->compact_rel_size
+=
6157 sizeof (Elf32_External_crinfo
);
6160 /* This relocation describes the C++ object vtable hierarchy.
6161 Reconstruct it for later use during GC. */
6162 case R_MIPS_GNU_VTINHERIT
:
6163 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6167 /* This relocation describes which C++ vtable entries are actually
6168 used. Record for later use during GC. */
6169 case R_MIPS_GNU_VTENTRY
:
6170 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
6178 /* We must not create a stub for a symbol that has relocations
6179 related to taking the function's address. */
6185 struct mips_elf_link_hash_entry
*mh
;
6187 mh
= (struct mips_elf_link_hash_entry
*) h
;
6188 mh
->no_fn_stub
= TRUE
;
6192 case R_MIPS_CALL_HI16
:
6193 case R_MIPS_CALL_LO16
:
6198 /* If this reloc is not a 16 bit call, and it has a global
6199 symbol, then we will need the fn_stub if there is one.
6200 References from a stub section do not count. */
6202 && r_type
!= R_MIPS16_26
6203 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
6204 sizeof FN_STUB
- 1) != 0
6205 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
6206 sizeof CALL_STUB
- 1) != 0
6207 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
6208 sizeof CALL_FP_STUB
- 1) != 0)
6210 struct mips_elf_link_hash_entry
*mh
;
6212 mh
= (struct mips_elf_link_hash_entry
*) h
;
6213 mh
->need_fn_stub
= TRUE
;
6221 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
6222 struct bfd_link_info
*link_info
,
6225 Elf_Internal_Rela
*internal_relocs
;
6226 Elf_Internal_Rela
*irel
, *irelend
;
6227 Elf_Internal_Shdr
*symtab_hdr
;
6228 bfd_byte
*contents
= NULL
;
6230 bfd_boolean changed_contents
= FALSE
;
6231 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
6232 Elf_Internal_Sym
*isymbuf
= NULL
;
6234 /* We are not currently changing any sizes, so only one pass. */
6237 if (link_info
->relocatable
)
6240 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
6241 link_info
->keep_memory
);
6242 if (internal_relocs
== NULL
)
6245 irelend
= internal_relocs
+ sec
->reloc_count
6246 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
6247 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6248 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6250 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
6253 bfd_signed_vma sym_offset
;
6254 unsigned int r_type
;
6255 unsigned long r_symndx
;
6257 unsigned long instruction
;
6259 /* Turn jalr into bgezal, and jr into beq, if they're marked
6260 with a JALR relocation, that indicate where they jump to.
6261 This saves some pipeline bubbles. */
6262 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
6263 if (r_type
!= R_MIPS_JALR
)
6266 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
6267 /* Compute the address of the jump target. */
6268 if (r_symndx
>= extsymoff
)
6270 struct mips_elf_link_hash_entry
*h
6271 = ((struct mips_elf_link_hash_entry
*)
6272 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
6274 while (h
->root
.root
.type
== bfd_link_hash_indirect
6275 || h
->root
.root
.type
== bfd_link_hash_warning
)
6276 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6278 /* If a symbol is undefined, or if it may be overridden,
6280 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
6281 || h
->root
.root
.type
== bfd_link_hash_defweak
)
6282 && h
->root
.root
.u
.def
.section
)
6283 || (link_info
->shared
&& ! link_info
->symbolic
6284 && !h
->root
.forced_local
))
6287 sym_sec
= h
->root
.root
.u
.def
.section
;
6288 if (sym_sec
->output_section
)
6289 symval
= (h
->root
.root
.u
.def
.value
6290 + sym_sec
->output_section
->vma
6291 + sym_sec
->output_offset
);
6293 symval
= h
->root
.root
.u
.def
.value
;
6297 Elf_Internal_Sym
*isym
;
6299 /* Read this BFD's symbols if we haven't done so already. */
6300 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
6302 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6303 if (isymbuf
== NULL
)
6304 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
6305 symtab_hdr
->sh_info
, 0,
6307 if (isymbuf
== NULL
)
6311 isym
= isymbuf
+ r_symndx
;
6312 if (isym
->st_shndx
== SHN_UNDEF
)
6314 else if (isym
->st_shndx
== SHN_ABS
)
6315 sym_sec
= bfd_abs_section_ptr
;
6316 else if (isym
->st_shndx
== SHN_COMMON
)
6317 sym_sec
= bfd_com_section_ptr
;
6320 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
6321 symval
= isym
->st_value
6322 + sym_sec
->output_section
->vma
6323 + sym_sec
->output_offset
;
6326 /* Compute branch offset, from delay slot of the jump to the
6328 sym_offset
= (symval
+ irel
->r_addend
)
6329 - (sec_start
+ irel
->r_offset
+ 4);
6331 /* Branch offset must be properly aligned. */
6332 if ((sym_offset
& 3) != 0)
6337 /* Check that it's in range. */
6338 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
6341 /* Get the section contents if we haven't done so already. */
6342 if (contents
== NULL
)
6344 /* Get cached copy if it exists. */
6345 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6346 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6349 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6354 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
6356 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
6357 if ((instruction
& 0xfc1fffff) == 0x0000f809)
6358 instruction
= 0x04110000;
6359 /* If it was jr <reg>, turn it into b <target>. */
6360 else if ((instruction
& 0xfc1fffff) == 0x00000008)
6361 instruction
= 0x10000000;
6365 instruction
|= (sym_offset
& 0xffff);
6366 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
6367 changed_contents
= TRUE
;
6370 if (contents
!= NULL
6371 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6373 if (!changed_contents
&& !link_info
->keep_memory
)
6377 /* Cache the section contents for elf_link_input_bfd. */
6378 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6384 if (contents
!= NULL
6385 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6390 /* Adjust a symbol defined by a dynamic object and referenced by a
6391 regular object. The current definition is in some section of the
6392 dynamic object, but we're not including those sections. We have to
6393 change the definition to something the rest of the link can
6397 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6398 struct elf_link_hash_entry
*h
)
6401 struct mips_elf_link_hash_entry
*hmips
;
6404 dynobj
= elf_hash_table (info
)->dynobj
;
6406 /* Make sure we know what is going on here. */
6407 BFD_ASSERT (dynobj
!= NULL
6409 || h
->u
.weakdef
!= NULL
6412 && !h
->def_regular
)));
6414 /* If this symbol is defined in a dynamic object, we need to copy
6415 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6417 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6418 if (! info
->relocatable
6419 && hmips
->possibly_dynamic_relocs
!= 0
6420 && (h
->root
.type
== bfd_link_hash_defweak
6421 || !h
->def_regular
))
6424 sec
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6425 mips_elf_allocate_dynamic_relocations (dynobj
,
6426 hmips
->possibly_dynamic_relocs
);
6428 if (MIPS_ELF_READONLY_SECTION (sec
))
6429 /* We tell the dynamic linker that there are relocations
6430 against the text segment. */
6431 info
->flags
|= DF_TEXTREL
;
6434 /* For a function, create a stub, if allowed. */
6435 if (! hmips
->no_fn_stub
6438 if (! elf_hash_table (info
)->dynamic_sections_created
)
6441 /* If this symbol is not defined in a regular file, then set
6442 the symbol to the stub location. This is required to make
6443 function pointers compare as equal between the normal
6444 executable and the shared library. */
6445 if (!h
->def_regular
)
6447 /* We need .stub section. */
6448 s
= bfd_get_section_by_name (dynobj
,
6449 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6450 BFD_ASSERT (s
!= NULL
);
6452 h
->root
.u
.def
.section
= s
;
6453 h
->root
.u
.def
.value
= s
->size
;
6455 /* XXX Write this stub address somewhere. */
6456 h
->plt
.offset
= s
->size
;
6458 /* Make room for this stub code. */
6459 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6461 /* The last half word of the stub will be filled with the index
6462 of this symbol in .dynsym section. */
6466 else if ((h
->type
== STT_FUNC
)
6469 /* This will set the entry for this symbol in the GOT to 0, and
6470 the dynamic linker will take care of this. */
6471 h
->root
.u
.def
.value
= 0;
6475 /* If this is a weak symbol, and there is a real definition, the
6476 processor independent code will have arranged for us to see the
6477 real definition first, and we can just use the same value. */
6478 if (h
->u
.weakdef
!= NULL
)
6480 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
6481 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
6482 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
6483 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
6487 /* This is a reference to a symbol defined by a dynamic object which
6488 is not a function. */
6493 /* This function is called after all the input files have been read,
6494 and the input sections have been assigned to output sections. We
6495 check for any mips16 stub sections that we can discard. */
6498 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
6499 struct bfd_link_info
*info
)
6505 struct mips_got_info
*g
;
6507 bfd_size_type loadable_size
= 0;
6508 bfd_size_type local_gotno
;
6510 struct mips_elf_count_tls_arg count_tls_arg
;
6512 /* The .reginfo section has a fixed size. */
6513 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
6515 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
6517 if (! (info
->relocatable
6518 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
6519 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
6520 mips_elf_check_mips16_stubs
, NULL
);
6522 dynobj
= elf_hash_table (info
)->dynobj
;
6524 /* Relocatable links don't have it. */
6527 g
= mips_elf_got_info (dynobj
, &s
);
6531 /* Calculate the total loadable size of the output. That
6532 will give us the maximum number of GOT_PAGE entries
6534 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
6536 asection
*subsection
;
6538 for (subsection
= sub
->sections
;
6540 subsection
= subsection
->next
)
6542 if ((subsection
->flags
& SEC_ALLOC
) == 0)
6544 loadable_size
+= ((subsection
->size
+ 0xf)
6545 &~ (bfd_size_type
) 0xf);
6549 /* There has to be a global GOT entry for every symbol with
6550 a dynamic symbol table index of DT_MIPS_GOTSYM or
6551 higher. Therefore, it make sense to put those symbols
6552 that need GOT entries at the end of the symbol table. We
6554 if (! mips_elf_sort_hash_table (info
, 1))
6557 if (g
->global_gotsym
!= NULL
)
6558 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
6560 /* If there are no global symbols, or none requiring
6561 relocations, then GLOBAL_GOTSYM will be NULL. */
6564 /* In the worst case, we'll get one stub per dynamic symbol, plus
6565 one to account for the dummy entry at the end required by IRIX
6567 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
6569 /* Assume there are two loadable segments consisting of
6570 contiguous sections. Is 5 enough? */
6571 local_gotno
= (loadable_size
>> 16) + 5;
6573 g
->local_gotno
+= local_gotno
;
6574 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
6576 g
->global_gotno
= i
;
6577 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
6579 /* We need to calculate tls_gotno for global symbols at this point
6580 instead of building it up earlier, to avoid doublecounting
6581 entries for one global symbol from multiple input files. */
6582 count_tls_arg
.info
= info
;
6583 count_tls_arg
.needed
= 0;
6584 elf_link_hash_traverse (elf_hash_table (info
),
6585 mips_elf_count_global_tls_entries
,
6587 g
->tls_gotno
+= count_tls_arg
.needed
;
6588 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
6590 mips_elf_resolve_final_got_entries (g
);
6592 if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
))
6594 if (! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
6599 /* Set up TLS entries for the first GOT. */
6600 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
6601 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
6607 /* Set the sizes of the dynamic sections. */
6610 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
6611 struct bfd_link_info
*info
)
6615 bfd_boolean reltext
;
6617 dynobj
= elf_hash_table (info
)->dynobj
;
6618 BFD_ASSERT (dynobj
!= NULL
);
6620 if (elf_hash_table (info
)->dynamic_sections_created
)
6622 /* Set the contents of the .interp section to the interpreter. */
6623 if (info
->executable
)
6625 s
= bfd_get_section_by_name (dynobj
, ".interp");
6626 BFD_ASSERT (s
!= NULL
);
6628 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
6630 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
6634 /* The check_relocs and adjust_dynamic_symbol entry points have
6635 determined the sizes of the various dynamic sections. Allocate
6638 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
6643 /* It's OK to base decisions on the section name, because none
6644 of the dynobj section names depend upon the input files. */
6645 name
= bfd_get_section_name (dynobj
, s
);
6647 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
6652 if (strncmp (name
, ".rel", 4) == 0)
6656 /* We only strip the section if the output section name
6657 has the same name. Otherwise, there might be several
6658 input sections for this output section. FIXME: This
6659 code is probably not needed these days anyhow, since
6660 the linker now does not create empty output sections. */
6661 if (s
->output_section
!= NULL
6663 bfd_get_section_name (s
->output_section
->owner
,
6664 s
->output_section
)) == 0)
6669 const char *outname
;
6672 /* If this relocation section applies to a read only
6673 section, then we probably need a DT_TEXTREL entry.
6674 If the relocation section is .rel.dyn, we always
6675 assert a DT_TEXTREL entry rather than testing whether
6676 there exists a relocation to a read only section or
6678 outname
= bfd_get_section_name (output_bfd
,
6680 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
6682 && (target
->flags
& SEC_READONLY
) != 0
6683 && (target
->flags
& SEC_ALLOC
) != 0)
6684 || strcmp (outname
, ".rel.dyn") == 0)
6687 /* We use the reloc_count field as a counter if we need
6688 to copy relocs into the output file. */
6689 if (strcmp (name
, ".rel.dyn") != 0)
6692 /* If combreloc is enabled, elf_link_sort_relocs() will
6693 sort relocations, but in a different way than we do,
6694 and before we're done creating relocations. Also, it
6695 will move them around between input sections'
6696 relocation's contents, so our sorting would be
6697 broken, so don't let it run. */
6698 info
->combreloc
= 0;
6701 else if (strncmp (name
, ".got", 4) == 0)
6703 /* _bfd_mips_elf_always_size_sections() has already done
6704 most of the work, but some symbols may have been mapped
6705 to versions that we must now resolve in the got_entries
6707 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
6708 struct mips_got_info
*g
= gg
;
6709 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
6710 unsigned int needed_relocs
= 0;
6714 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6715 set_got_offset_arg
.info
= info
;
6717 /* NOTE 2005-02-03: How can this call, or the next, ever
6718 find any indirect entries to resolve? They were all
6719 resolved in mips_elf_multi_got. */
6720 mips_elf_resolve_final_got_entries (gg
);
6721 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6723 unsigned int save_assign
;
6725 mips_elf_resolve_final_got_entries (g
);
6727 /* Assign offsets to global GOT entries. */
6728 save_assign
= g
->assigned_gotno
;
6729 g
->assigned_gotno
= g
->local_gotno
;
6730 set_got_offset_arg
.g
= g
;
6731 set_got_offset_arg
.needed_relocs
= 0;
6732 htab_traverse (g
->got_entries
,
6733 mips_elf_set_global_got_offset
,
6734 &set_got_offset_arg
);
6735 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6736 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6737 <= g
->global_gotno
);
6739 g
->assigned_gotno
= save_assign
;
6742 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6743 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6744 + g
->next
->global_gotno
6745 + g
->next
->tls_gotno
6746 + MIPS_RESERVED_GOTNO
);
6752 struct mips_elf_count_tls_arg arg
;
6756 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
6758 elf_link_hash_traverse (elf_hash_table (info
),
6759 mips_elf_count_global_tls_relocs
,
6762 needed_relocs
+= arg
.needed
;
6766 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6768 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6770 /* IRIX rld assumes that the function stub isn't at the end
6771 of .text section. So put a dummy. XXX */
6772 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6774 else if (! info
->shared
6775 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6776 && strncmp (name
, ".rld_map", 8) == 0)
6778 /* We add a room for __rld_map. It will be filled in by the
6779 rtld to contain a pointer to the _r_debug structure. */
6782 else if (SGI_COMPAT (output_bfd
)
6783 && strncmp (name
, ".compact_rel", 12) == 0)
6784 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6785 else if (strncmp (name
, ".init", 5) != 0)
6787 /* It's not one of our sections, so don't allocate space. */
6793 _bfd_strip_section_from_output (info
, s
);
6797 /* Allocate memory for the section contents. */
6798 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
6799 if (s
->contents
== NULL
&& s
->size
!= 0)
6801 bfd_set_error (bfd_error_no_memory
);
6806 if (elf_hash_table (info
)->dynamic_sections_created
)
6808 /* Add some entries to the .dynamic section. We fill in the
6809 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6810 must add the entries now so that we get the correct size for
6811 the .dynamic section. The DT_DEBUG entry is filled in by the
6812 dynamic linker and used by the debugger. */
6815 /* SGI object has the equivalence of DT_DEBUG in the
6816 DT_MIPS_RLD_MAP entry. */
6817 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6819 if (!SGI_COMPAT (output_bfd
))
6821 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6827 /* Shared libraries on traditional mips have DT_DEBUG. */
6828 if (!SGI_COMPAT (output_bfd
))
6830 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6835 if (reltext
&& SGI_COMPAT (output_bfd
))
6836 info
->flags
|= DF_TEXTREL
;
6838 if ((info
->flags
& DF_TEXTREL
) != 0)
6840 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6844 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6847 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6849 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6852 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6855 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6859 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6862 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6865 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6868 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6871 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6874 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6877 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6880 if (IRIX_COMPAT (dynobj
) == ict_irix5
6881 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6884 if (IRIX_COMPAT (dynobj
) == ict_irix6
6885 && (bfd_get_section_by_name
6886 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6887 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6894 /* Relocate a MIPS ELF section. */
6897 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6898 bfd
*input_bfd
, asection
*input_section
,
6899 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6900 Elf_Internal_Sym
*local_syms
,
6901 asection
**local_sections
)
6903 Elf_Internal_Rela
*rel
;
6904 const Elf_Internal_Rela
*relend
;
6906 bfd_boolean use_saved_addend_p
= FALSE
;
6907 const struct elf_backend_data
*bed
;
6909 bed
= get_elf_backend_data (output_bfd
);
6910 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6911 for (rel
= relocs
; rel
< relend
; ++rel
)
6915 reloc_howto_type
*howto
;
6916 bfd_boolean require_jalx
;
6917 /* TRUE if the relocation is a RELA relocation, rather than a
6919 bfd_boolean rela_relocation_p
= TRUE
;
6920 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6923 /* Find the relocation howto for this relocation. */
6924 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6926 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6927 64-bit code, but make sure all their addresses are in the
6928 lowermost or uppermost 32-bit section of the 64-bit address
6929 space. Thus, when they use an R_MIPS_64 they mean what is
6930 usually meant by R_MIPS_32, with the exception that the
6931 stored value is sign-extended to 64 bits. */
6932 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6934 /* On big-endian systems, we need to lie about the position
6936 if (bfd_big_endian (input_bfd
))
6940 /* NewABI defaults to RELA relocations. */
6941 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6942 NEWABI_P (input_bfd
)
6943 && (MIPS_RELOC_RELA_P
6944 (input_bfd
, input_section
,
6947 if (!use_saved_addend_p
)
6949 Elf_Internal_Shdr
*rel_hdr
;
6951 /* If these relocations were originally of the REL variety,
6952 we must pull the addend out of the field that will be
6953 relocated. Otherwise, we simply use the contents of the
6954 RELA relocation. To determine which flavor or relocation
6955 this is, we depend on the fact that the INPUT_SECTION's
6956 REL_HDR is read before its REL_HDR2. */
6957 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6958 if ((size_t) (rel
- relocs
)
6959 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6960 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6961 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6963 bfd_byte
*location
= contents
+ rel
->r_offset
;
6965 /* Note that this is a REL relocation. */
6966 rela_relocation_p
= FALSE
;
6968 /* Get the addend, which is stored in the input file. */
6969 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
6971 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6973 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
6976 addend
&= howto
->src_mask
;
6978 /* For some kinds of relocations, the ADDEND is a
6979 combination of the addend stored in two different
6981 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
6982 || (r_type
== R_MIPS_GOT16
6983 && mips_elf_local_relocation_p (input_bfd
, rel
,
6984 local_sections
, FALSE
)))
6987 const Elf_Internal_Rela
*lo16_relocation
;
6988 reloc_howto_type
*lo16_howto
;
6989 bfd_byte
*lo16_location
;
6992 if (r_type
== R_MIPS16_HI16
)
6993 lo16_type
= R_MIPS16_LO16
;
6995 lo16_type
= R_MIPS_LO16
;
6997 /* The combined value is the sum of the HI16 addend,
6998 left-shifted by sixteen bits, and the LO16
6999 addend, sign extended. (Usually, the code does
7000 a `lui' of the HI16 value, and then an `addiu' of
7003 Scan ahead to find a matching LO16 relocation.
7005 According to the MIPS ELF ABI, the R_MIPS_LO16
7006 relocation must be immediately following.
7007 However, for the IRIX6 ABI, the next relocation
7008 may be a composed relocation consisting of
7009 several relocations for the same address. In
7010 that case, the R_MIPS_LO16 relocation may occur
7011 as one of these. We permit a similar extension
7012 in general, as that is useful for GCC. */
7013 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
7016 if (lo16_relocation
== NULL
)
7019 lo16_location
= contents
+ lo16_relocation
->r_offset
;
7021 /* Obtain the addend kept there. */
7022 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
7024 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
7026 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
7027 input_bfd
, contents
);
7028 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
7030 l
&= lo16_howto
->src_mask
;
7031 l
<<= lo16_howto
->rightshift
;
7032 l
= _bfd_mips_elf_sign_extend (l
, 16);
7036 /* Compute the combined addend. */
7040 addend
<<= howto
->rightshift
;
7043 addend
= rel
->r_addend
;
7046 if (info
->relocatable
)
7048 Elf_Internal_Sym
*sym
;
7049 unsigned long r_symndx
;
7051 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
7052 && bfd_big_endian (input_bfd
))
7055 /* Since we're just relocating, all we need to do is copy
7056 the relocations back out to the object file, unless
7057 they're against a section symbol, in which case we need
7058 to adjust by the section offset, or unless they're GP
7059 relative in which case we need to adjust by the amount
7060 that we're adjusting GP in this relocatable object. */
7062 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
7064 /* There's nothing to do for non-local relocations. */
7067 if (r_type
== R_MIPS16_GPREL
7068 || r_type
== R_MIPS_GPREL16
7069 || r_type
== R_MIPS_GPREL32
7070 || r_type
== R_MIPS_LITERAL
)
7071 addend
-= (_bfd_get_gp_value (output_bfd
)
7072 - _bfd_get_gp_value (input_bfd
));
7074 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
7075 sym
= local_syms
+ r_symndx
;
7076 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7077 /* Adjust the addend appropriately. */
7078 addend
+= local_sections
[r_symndx
]->output_offset
;
7080 if (rela_relocation_p
)
7081 /* If this is a RELA relocation, just update the addend. */
7082 rel
->r_addend
= addend
;
7085 if (r_type
== R_MIPS_HI16
7086 || r_type
== R_MIPS_GOT16
)
7087 addend
= mips_elf_high (addend
);
7088 else if (r_type
== R_MIPS_HIGHER
)
7089 addend
= mips_elf_higher (addend
);
7090 else if (r_type
== R_MIPS_HIGHEST
)
7091 addend
= mips_elf_highest (addend
);
7093 addend
>>= howto
->rightshift
;
7095 /* We use the source mask, rather than the destination
7096 mask because the place to which we are writing will be
7097 source of the addend in the final link. */
7098 addend
&= howto
->src_mask
;
7100 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7101 /* See the comment above about using R_MIPS_64 in the 32-bit
7102 ABI. Here, we need to update the addend. It would be
7103 possible to get away with just using the R_MIPS_32 reloc
7104 but for endianness. */
7110 if (addend
& ((bfd_vma
) 1 << 31))
7112 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7119 /* If we don't know that we have a 64-bit type,
7120 do two separate stores. */
7121 if (bfd_big_endian (input_bfd
))
7123 /* Store the sign-bits (which are most significant)
7125 low_bits
= sign_bits
;
7131 high_bits
= sign_bits
;
7133 bfd_put_32 (input_bfd
, low_bits
,
7134 contents
+ rel
->r_offset
);
7135 bfd_put_32 (input_bfd
, high_bits
,
7136 contents
+ rel
->r_offset
+ 4);
7140 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
7141 input_bfd
, input_section
,
7146 /* Go on to the next relocation. */
7150 /* In the N32 and 64-bit ABIs there may be multiple consecutive
7151 relocations for the same offset. In that case we are
7152 supposed to treat the output of each relocation as the addend
7154 if (rel
+ 1 < relend
7155 && rel
->r_offset
== rel
[1].r_offset
7156 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
7157 use_saved_addend_p
= TRUE
;
7159 use_saved_addend_p
= FALSE
;
7161 /* Figure out what value we are supposed to relocate. */
7162 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
7163 input_section
, info
, rel
,
7164 addend
, howto
, local_syms
,
7165 local_sections
, &value
,
7166 &name
, &require_jalx
,
7167 use_saved_addend_p
))
7169 case bfd_reloc_continue
:
7170 /* There's nothing to do. */
7173 case bfd_reloc_undefined
:
7174 /* mips_elf_calculate_relocation already called the
7175 undefined_symbol callback. There's no real point in
7176 trying to perform the relocation at this point, so we
7177 just skip ahead to the next relocation. */
7180 case bfd_reloc_notsupported
:
7181 msg
= _("internal error: unsupported relocation error");
7182 info
->callbacks
->warning
7183 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
7186 case bfd_reloc_overflow
:
7187 if (use_saved_addend_p
)
7188 /* Ignore overflow until we reach the last relocation for
7189 a given location. */
7193 BFD_ASSERT (name
!= NULL
);
7194 if (! ((*info
->callbacks
->reloc_overflow
)
7195 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
7196 input_bfd
, input_section
, rel
->r_offset
)))
7209 /* If we've got another relocation for the address, keep going
7210 until we reach the last one. */
7211 if (use_saved_addend_p
)
7217 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7218 /* See the comment above about using R_MIPS_64 in the 32-bit
7219 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7220 that calculated the right value. Now, however, we
7221 sign-extend the 32-bit result to 64-bits, and store it as a
7222 64-bit value. We are especially generous here in that we
7223 go to extreme lengths to support this usage on systems with
7224 only a 32-bit VMA. */
7230 if (value
& ((bfd_vma
) 1 << 31))
7232 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7239 /* If we don't know that we have a 64-bit type,
7240 do two separate stores. */
7241 if (bfd_big_endian (input_bfd
))
7243 /* Undo what we did above. */
7245 /* Store the sign-bits (which are most significant)
7247 low_bits
= sign_bits
;
7253 high_bits
= sign_bits
;
7255 bfd_put_32 (input_bfd
, low_bits
,
7256 contents
+ rel
->r_offset
);
7257 bfd_put_32 (input_bfd
, high_bits
,
7258 contents
+ rel
->r_offset
+ 4);
7262 /* Actually perform the relocation. */
7263 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
7264 input_bfd
, input_section
,
7265 contents
, require_jalx
))
7272 /* If NAME is one of the special IRIX6 symbols defined by the linker,
7273 adjust it appropriately now. */
7276 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
7277 const char *name
, Elf_Internal_Sym
*sym
)
7279 /* The linker script takes care of providing names and values for
7280 these, but we must place them into the right sections. */
7281 static const char* const text_section_symbols
[] = {
7284 "__dso_displacement",
7286 "__program_header_table",
7290 static const char* const data_section_symbols
[] = {
7298 const char* const *p
;
7301 for (i
= 0; i
< 2; ++i
)
7302 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
7305 if (strcmp (*p
, name
) == 0)
7307 /* All of these symbols are given type STT_SECTION by the
7309 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7310 sym
->st_other
= STO_PROTECTED
;
7312 /* The IRIX linker puts these symbols in special sections. */
7314 sym
->st_shndx
= SHN_MIPS_TEXT
;
7316 sym
->st_shndx
= SHN_MIPS_DATA
;
7322 /* Finish up dynamic symbol handling. We set the contents of various
7323 dynamic sections here. */
7326 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
7327 struct bfd_link_info
*info
,
7328 struct elf_link_hash_entry
*h
,
7329 Elf_Internal_Sym
*sym
)
7333 struct mips_got_info
*g
, *gg
;
7336 dynobj
= elf_hash_table (info
)->dynobj
;
7338 if (h
->plt
.offset
!= MINUS_ONE
)
7341 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
7343 /* This symbol has a stub. Set it up. */
7345 BFD_ASSERT (h
->dynindx
!= -1);
7347 s
= bfd_get_section_by_name (dynobj
,
7348 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7349 BFD_ASSERT (s
!= NULL
);
7351 /* FIXME: Can h->dynindex be more than 64K? */
7352 if (h
->dynindx
& 0xffff0000)
7355 /* Fill the stub. */
7356 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
7357 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
7358 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
7359 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
7361 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
7362 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
7364 /* Mark the symbol as undefined. plt.offset != -1 occurs
7365 only for the referenced symbol. */
7366 sym
->st_shndx
= SHN_UNDEF
;
7368 /* The run-time linker uses the st_value field of the symbol
7369 to reset the global offset table entry for this external
7370 to its stub address when unlinking a shared object. */
7371 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
7375 BFD_ASSERT (h
->dynindx
!= -1
7376 || h
->forced_local
);
7378 sgot
= mips_elf_got_section (dynobj
, FALSE
);
7379 BFD_ASSERT (sgot
!= NULL
);
7380 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
7381 g
= mips_elf_section_data (sgot
)->u
.got_info
;
7382 BFD_ASSERT (g
!= NULL
);
7384 /* Run through the global symbol table, creating GOT entries for all
7385 the symbols that need them. */
7386 if (g
->global_gotsym
!= NULL
7387 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
7392 value
= sym
->st_value
;
7393 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
, R_MIPS_GOT16
, info
);
7394 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
7397 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
7399 struct mips_got_entry e
, *p
;
7405 e
.abfd
= output_bfd
;
7407 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
7410 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
7413 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
7418 || (elf_hash_table (info
)->dynamic_sections_created
7420 && p
->d
.h
->root
.def_dynamic
7421 && !p
->d
.h
->root
.def_regular
))
7423 /* Create an R_MIPS_REL32 relocation for this entry. Due to
7424 the various compatibility problems, it's easier to mock
7425 up an R_MIPS_32 or R_MIPS_64 relocation and leave
7426 mips_elf_create_dynamic_relocation to calculate the
7427 appropriate addend. */
7428 Elf_Internal_Rela rel
[3];
7430 memset (rel
, 0, sizeof (rel
));
7431 if (ABI_64_P (output_bfd
))
7432 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
7434 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
7435 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
7438 if (! (mips_elf_create_dynamic_relocation
7439 (output_bfd
, info
, rel
,
7440 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
7444 entry
= sym
->st_value
;
7445 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
7450 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7451 name
= h
->root
.root
.string
;
7452 if (strcmp (name
, "_DYNAMIC") == 0
7453 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
7454 sym
->st_shndx
= SHN_ABS
;
7455 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
7456 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
7458 sym
->st_shndx
= SHN_ABS
;
7459 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7462 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
7464 sym
->st_shndx
= SHN_ABS
;
7465 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7466 sym
->st_value
= elf_gp (output_bfd
);
7468 else if (SGI_COMPAT (output_bfd
))
7470 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
7471 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
7473 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7474 sym
->st_other
= STO_PROTECTED
;
7476 sym
->st_shndx
= SHN_MIPS_DATA
;
7478 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
7480 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7481 sym
->st_other
= STO_PROTECTED
;
7482 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
7483 sym
->st_shndx
= SHN_ABS
;
7485 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
7487 if (h
->type
== STT_FUNC
)
7488 sym
->st_shndx
= SHN_MIPS_TEXT
;
7489 else if (h
->type
== STT_OBJECT
)
7490 sym
->st_shndx
= SHN_MIPS_DATA
;
7494 /* Handle the IRIX6-specific symbols. */
7495 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
7496 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
7500 if (! mips_elf_hash_table (info
)->use_rld_obj_head
7501 && (strcmp (name
, "__rld_map") == 0
7502 || strcmp (name
, "__RLD_MAP") == 0))
7504 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
7505 BFD_ASSERT (s
!= NULL
);
7506 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
7507 bfd_put_32 (output_bfd
, 0, s
->contents
);
7508 if (mips_elf_hash_table (info
)->rld_value
== 0)
7509 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
7511 else if (mips_elf_hash_table (info
)->use_rld_obj_head
7512 && strcmp (name
, "__rld_obj_head") == 0)
7514 /* IRIX6 does not use a .rld_map section. */
7515 if (IRIX_COMPAT (output_bfd
) == ict_irix5
7516 || IRIX_COMPAT (output_bfd
) == ict_none
)
7517 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
7519 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
7523 /* If this is a mips16 symbol, force the value to be even. */
7524 if (sym
->st_other
== STO_MIPS16
)
7525 sym
->st_value
&= ~1;
7530 /* Finish up the dynamic sections. */
7533 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
7534 struct bfd_link_info
*info
)
7539 struct mips_got_info
*gg
, *g
;
7541 dynobj
= elf_hash_table (info
)->dynobj
;
7543 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
7545 sgot
= mips_elf_got_section (dynobj
, FALSE
);
7550 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
7551 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
7552 BFD_ASSERT (gg
!= NULL
);
7553 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
7554 BFD_ASSERT (g
!= NULL
);
7557 if (elf_hash_table (info
)->dynamic_sections_created
)
7561 BFD_ASSERT (sdyn
!= NULL
);
7562 BFD_ASSERT (g
!= NULL
);
7564 for (b
= sdyn
->contents
;
7565 b
< sdyn
->contents
+ sdyn
->size
;
7566 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
7568 Elf_Internal_Dyn dyn
;
7572 bfd_boolean swap_out_p
;
7574 /* Read in the current dynamic entry. */
7575 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
7577 /* Assume that we're going to modify it and write it out. */
7583 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7584 BFD_ASSERT (s
!= NULL
);
7585 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
7589 /* Rewrite DT_STRSZ. */
7591 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7596 s
= bfd_get_section_by_name (output_bfd
, name
);
7597 BFD_ASSERT (s
!= NULL
);
7598 dyn
.d_un
.d_ptr
= s
->vma
;
7601 case DT_MIPS_RLD_VERSION
:
7602 dyn
.d_un
.d_val
= 1; /* XXX */
7606 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
7609 case DT_MIPS_TIME_STAMP
:
7610 time ((time_t *) &dyn
.d_un
.d_val
);
7613 case DT_MIPS_ICHECKSUM
:
7618 case DT_MIPS_IVERSION
:
7623 case DT_MIPS_BASE_ADDRESS
:
7624 s
= output_bfd
->sections
;
7625 BFD_ASSERT (s
!= NULL
);
7626 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
7629 case DT_MIPS_LOCAL_GOTNO
:
7630 dyn
.d_un
.d_val
= g
->local_gotno
;
7633 case DT_MIPS_UNREFEXTNO
:
7634 /* The index into the dynamic symbol table which is the
7635 entry of the first external symbol that is not
7636 referenced within the same object. */
7637 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
7640 case DT_MIPS_GOTSYM
:
7641 if (gg
->global_gotsym
)
7643 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
7646 /* In case if we don't have global got symbols we default
7647 to setting DT_MIPS_GOTSYM to the same value as
7648 DT_MIPS_SYMTABNO, so we just fall through. */
7650 case DT_MIPS_SYMTABNO
:
7652 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
7653 s
= bfd_get_section_by_name (output_bfd
, name
);
7654 BFD_ASSERT (s
!= NULL
);
7656 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
7659 case DT_MIPS_HIPAGENO
:
7660 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
7663 case DT_MIPS_RLD_MAP
:
7664 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
7667 case DT_MIPS_OPTIONS
:
7668 s
= (bfd_get_section_by_name
7669 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
7670 dyn
.d_un
.d_ptr
= s
->vma
;
7674 /* Reduce DT_RELSZ to account for any relocations we
7675 decided not to make. This is for the n64 irix rld,
7676 which doesn't seem to apply any relocations if there
7677 are trailing null entries. */
7678 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7679 dyn
.d_un
.d_val
= (s
->reloc_count
7680 * (ABI_64_P (output_bfd
)
7681 ? sizeof (Elf64_Mips_External_Rel
)
7682 : sizeof (Elf32_External_Rel
)));
7691 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
7696 /* The first entry of the global offset table will be filled at
7697 runtime. The second entry will be used by some runtime loaders.
7698 This isn't the case of IRIX rld. */
7699 if (sgot
!= NULL
&& sgot
->size
> 0)
7701 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
7702 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
7703 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7707 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7708 = MIPS_ELF_GOT_SIZE (output_bfd
);
7710 /* Generate dynamic relocations for the non-primary gots. */
7711 if (gg
!= NULL
&& gg
->next
)
7713 Elf_Internal_Rela rel
[3];
7716 memset (rel
, 0, sizeof (rel
));
7717 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7719 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7721 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
7722 + g
->next
->tls_gotno
;
7724 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7725 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7726 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7727 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7732 while (index
< g
->assigned_gotno
)
7734 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7735 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7736 if (!(mips_elf_create_dynamic_relocation
7737 (output_bfd
, info
, rel
, NULL
,
7738 bfd_abs_section_ptr
,
7741 BFD_ASSERT (addend
== 0);
7748 Elf32_compact_rel cpt
;
7750 if (SGI_COMPAT (output_bfd
))
7752 /* Write .compact_rel section out. */
7753 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7757 cpt
.num
= s
->reloc_count
;
7759 cpt
.offset
= (s
->output_section
->filepos
7760 + sizeof (Elf32_External_compact_rel
));
7763 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7764 ((Elf32_External_compact_rel
*)
7767 /* Clean up a dummy stub function entry in .text. */
7768 s
= bfd_get_section_by_name (dynobj
,
7769 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7772 file_ptr dummy_offset
;
7774 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE
);
7775 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE
;
7776 memset (s
->contents
+ dummy_offset
, 0,
7777 MIPS_FUNCTION_STUB_SIZE
);
7782 /* We need to sort the entries of the dynamic relocation section. */
7784 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7787 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7789 reldyn_sorting_bfd
= output_bfd
;
7791 if (ABI_64_P (output_bfd
))
7792 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7793 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7795 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7796 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7804 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7807 mips_set_isa_flags (bfd
*abfd
)
7811 switch (bfd_get_mach (abfd
))
7814 case bfd_mach_mips3000
:
7815 val
= E_MIPS_ARCH_1
;
7818 case bfd_mach_mips3900
:
7819 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7822 case bfd_mach_mips6000
:
7823 val
= E_MIPS_ARCH_2
;
7826 case bfd_mach_mips4000
:
7827 case bfd_mach_mips4300
:
7828 case bfd_mach_mips4400
:
7829 case bfd_mach_mips4600
:
7830 val
= E_MIPS_ARCH_3
;
7833 case bfd_mach_mips4010
:
7834 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7837 case bfd_mach_mips4100
:
7838 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7841 case bfd_mach_mips4111
:
7842 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7845 case bfd_mach_mips4120
:
7846 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7849 case bfd_mach_mips4650
:
7850 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7853 case bfd_mach_mips5400
:
7854 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7857 case bfd_mach_mips5500
:
7858 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7861 case bfd_mach_mips9000
:
7862 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
7865 case bfd_mach_mips5000
:
7866 case bfd_mach_mips7000
:
7867 case bfd_mach_mips8000
:
7868 case bfd_mach_mips10000
:
7869 case bfd_mach_mips12000
:
7870 val
= E_MIPS_ARCH_4
;
7873 case bfd_mach_mips5
:
7874 val
= E_MIPS_ARCH_5
;
7877 case bfd_mach_mips_sb1
:
7878 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7881 case bfd_mach_mipsisa32
:
7882 val
= E_MIPS_ARCH_32
;
7885 case bfd_mach_mipsisa64
:
7886 val
= E_MIPS_ARCH_64
;
7889 case bfd_mach_mipsisa32r2
:
7890 val
= E_MIPS_ARCH_32R2
;
7893 case bfd_mach_mipsisa64r2
:
7894 val
= E_MIPS_ARCH_64R2
;
7897 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7898 elf_elfheader (abfd
)->e_flags
|= val
;
7903 /* The final processing done just before writing out a MIPS ELF object
7904 file. This gets the MIPS architecture right based on the machine
7905 number. This is used by both the 32-bit and the 64-bit ABI. */
7908 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7909 bfd_boolean linker ATTRIBUTE_UNUSED
)
7912 Elf_Internal_Shdr
**hdrpp
;
7916 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7917 is nonzero. This is for compatibility with old objects, which used
7918 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7919 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7920 mips_set_isa_flags (abfd
);
7922 /* Set the sh_info field for .gptab sections and other appropriate
7923 info for each special section. */
7924 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7925 i
< elf_numsections (abfd
);
7928 switch ((*hdrpp
)->sh_type
)
7931 case SHT_MIPS_LIBLIST
:
7932 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7934 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7937 case SHT_MIPS_GPTAB
:
7938 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7939 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7940 BFD_ASSERT (name
!= NULL
7941 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7942 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7943 BFD_ASSERT (sec
!= NULL
);
7944 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7947 case SHT_MIPS_CONTENT
:
7948 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7949 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7950 BFD_ASSERT (name
!= NULL
7951 && strncmp (name
, ".MIPS.content",
7952 sizeof ".MIPS.content" - 1) == 0);
7953 sec
= bfd_get_section_by_name (abfd
,
7954 name
+ sizeof ".MIPS.content" - 1);
7955 BFD_ASSERT (sec
!= NULL
);
7956 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7959 case SHT_MIPS_SYMBOL_LIB
:
7960 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7962 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7963 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7965 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7968 case SHT_MIPS_EVENTS
:
7969 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7970 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7971 BFD_ASSERT (name
!= NULL
);
7972 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7973 sec
= bfd_get_section_by_name (abfd
,
7974 name
+ sizeof ".MIPS.events" - 1);
7977 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7978 sizeof ".MIPS.post_rel" - 1) == 0);
7979 sec
= bfd_get_section_by_name (abfd
,
7981 + sizeof ".MIPS.post_rel" - 1));
7983 BFD_ASSERT (sec
!= NULL
);
7984 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7991 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7995 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
8000 /* See if we need a PT_MIPS_REGINFO segment. */
8001 s
= bfd_get_section_by_name (abfd
, ".reginfo");
8002 if (s
&& (s
->flags
& SEC_LOAD
))
8005 /* See if we need a PT_MIPS_OPTIONS segment. */
8006 if (IRIX_COMPAT (abfd
) == ict_irix6
8007 && bfd_get_section_by_name (abfd
,
8008 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
8011 /* See if we need a PT_MIPS_RTPROC segment. */
8012 if (IRIX_COMPAT (abfd
) == ict_irix5
8013 && bfd_get_section_by_name (abfd
, ".dynamic")
8014 && bfd_get_section_by_name (abfd
, ".mdebug"))
8020 /* Modify the segment map for an IRIX5 executable. */
8023 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
8024 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
8027 struct elf_segment_map
*m
, **pm
;
8030 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
8032 s
= bfd_get_section_by_name (abfd
, ".reginfo");
8033 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
8035 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
8036 if (m
->p_type
== PT_MIPS_REGINFO
)
8041 m
= bfd_zalloc (abfd
, amt
);
8045 m
->p_type
= PT_MIPS_REGINFO
;
8049 /* We want to put it after the PHDR and INTERP segments. */
8050 pm
= &elf_tdata (abfd
)->segment_map
;
8052 && ((*pm
)->p_type
== PT_PHDR
8053 || (*pm
)->p_type
== PT_INTERP
))
8061 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
8062 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
8063 PT_MIPS_OPTIONS segment immediately following the program header
8066 /* On non-IRIX6 new abi, we'll have already created a segment
8067 for this section, so don't create another. I'm not sure this
8068 is not also the case for IRIX 6, but I can't test it right
8070 && IRIX_COMPAT (abfd
) == ict_irix6
)
8072 for (s
= abfd
->sections
; s
; s
= s
->next
)
8073 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
8078 struct elf_segment_map
*options_segment
;
8080 pm
= &elf_tdata (abfd
)->segment_map
;
8082 && ((*pm
)->p_type
== PT_PHDR
8083 || (*pm
)->p_type
== PT_INTERP
))
8086 amt
= sizeof (struct elf_segment_map
);
8087 options_segment
= bfd_zalloc (abfd
, amt
);
8088 options_segment
->next
= *pm
;
8089 options_segment
->p_type
= PT_MIPS_OPTIONS
;
8090 options_segment
->p_flags
= PF_R
;
8091 options_segment
->p_flags_valid
= TRUE
;
8092 options_segment
->count
= 1;
8093 options_segment
->sections
[0] = s
;
8094 *pm
= options_segment
;
8099 if (IRIX_COMPAT (abfd
) == ict_irix5
)
8101 /* If there are .dynamic and .mdebug sections, we make a room
8102 for the RTPROC header. FIXME: Rewrite without section names. */
8103 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
8104 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
8105 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
8107 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
8108 if (m
->p_type
== PT_MIPS_RTPROC
)
8113 m
= bfd_zalloc (abfd
, amt
);
8117 m
->p_type
= PT_MIPS_RTPROC
;
8119 s
= bfd_get_section_by_name (abfd
, ".rtproc");
8124 m
->p_flags_valid
= 1;
8132 /* We want to put it after the DYNAMIC segment. */
8133 pm
= &elf_tdata (abfd
)->segment_map
;
8134 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
8144 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
8145 .dynstr, .dynsym, and .hash sections, and everything in
8147 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
8149 if ((*pm
)->p_type
== PT_DYNAMIC
)
8152 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
8154 /* For a normal mips executable the permissions for the PT_DYNAMIC
8155 segment are read, write and execute. We do that here since
8156 the code in elf.c sets only the read permission. This matters
8157 sometimes for the dynamic linker. */
8158 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
8160 m
->p_flags
= PF_R
| PF_W
| PF_X
;
8161 m
->p_flags_valid
= 1;
8165 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
8167 static const char *sec_names
[] =
8169 ".dynamic", ".dynstr", ".dynsym", ".hash"
8173 struct elf_segment_map
*n
;
8177 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
8179 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
8180 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
8187 if (high
< s
->vma
+ sz
)
8193 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8194 if ((s
->flags
& SEC_LOAD
) != 0
8196 && s
->vma
+ s
->size
<= high
)
8199 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
8200 n
= bfd_zalloc (abfd
, amt
);
8207 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8209 if ((s
->flags
& SEC_LOAD
) != 0
8211 && s
->vma
+ s
->size
<= high
)
8225 /* Return the section that should be marked against GC for a given
8229 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
8230 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
8231 Elf_Internal_Rela
*rel
,
8232 struct elf_link_hash_entry
*h
,
8233 Elf_Internal_Sym
*sym
)
8235 /* ??? Do mips16 stub sections need to be handled special? */
8239 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
8241 case R_MIPS_GNU_VTINHERIT
:
8242 case R_MIPS_GNU_VTENTRY
:
8246 switch (h
->root
.type
)
8248 case bfd_link_hash_defined
:
8249 case bfd_link_hash_defweak
:
8250 return h
->root
.u
.def
.section
;
8252 case bfd_link_hash_common
:
8253 return h
->root
.u
.c
.p
->section
;
8261 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
8266 /* Update the got entry reference counts for the section being removed. */
8269 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
8270 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
8271 asection
*sec ATTRIBUTE_UNUSED
,
8272 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
8275 Elf_Internal_Shdr
*symtab_hdr
;
8276 struct elf_link_hash_entry
**sym_hashes
;
8277 bfd_signed_vma
*local_got_refcounts
;
8278 const Elf_Internal_Rela
*rel
, *relend
;
8279 unsigned long r_symndx
;
8280 struct elf_link_hash_entry
*h
;
8282 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8283 sym_hashes
= elf_sym_hashes (abfd
);
8284 local_got_refcounts
= elf_local_got_refcounts (abfd
);
8286 relend
= relocs
+ sec
->reloc_count
;
8287 for (rel
= relocs
; rel
< relend
; rel
++)
8288 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
8292 case R_MIPS_CALL_HI16
:
8293 case R_MIPS_CALL_LO16
:
8294 case R_MIPS_GOT_HI16
:
8295 case R_MIPS_GOT_LO16
:
8296 case R_MIPS_GOT_DISP
:
8297 case R_MIPS_GOT_PAGE
:
8298 case R_MIPS_GOT_OFST
:
8299 /* ??? It would seem that the existing MIPS code does no sort
8300 of reference counting or whatnot on its GOT and PLT entries,
8301 so it is not possible to garbage collect them at this time. */
8312 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
8313 hiding the old indirect symbol. Process additional relocation
8314 information. Also called for weakdefs, in which case we just let
8315 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
8318 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
8319 struct elf_link_hash_entry
*dir
,
8320 struct elf_link_hash_entry
*ind
)
8322 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
8324 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
8326 if (ind
->root
.type
!= bfd_link_hash_indirect
)
8329 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
8330 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
8331 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
8332 if (indmips
->readonly_reloc
)
8333 dirmips
->readonly_reloc
= TRUE
;
8334 if (indmips
->no_fn_stub
)
8335 dirmips
->no_fn_stub
= TRUE
;
8337 if (dirmips
->tls_type
== 0)
8338 dirmips
->tls_type
= indmips
->tls_type
;
8340 BFD_ASSERT (indmips
->tls_type
== 0);
8344 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
8345 struct elf_link_hash_entry
*entry
,
8346 bfd_boolean force_local
)
8350 struct mips_got_info
*g
;
8351 struct mips_elf_link_hash_entry
*h
;
8353 h
= (struct mips_elf_link_hash_entry
*) entry
;
8354 if (h
->forced_local
)
8356 h
->forced_local
= force_local
;
8358 dynobj
= elf_hash_table (info
)->dynobj
;
8359 if (dynobj
!= NULL
&& force_local
&& h
->root
.type
!= STT_TLS
)
8361 got
= mips_elf_got_section (dynobj
, FALSE
);
8362 g
= mips_elf_section_data (got
)->u
.got_info
;
8366 struct mips_got_entry e
;
8367 struct mips_got_info
*gg
= g
;
8369 /* Since we're turning what used to be a global symbol into a
8370 local one, bump up the number of local entries of each GOT
8371 that had an entry for it. This will automatically decrease
8372 the number of global entries, since global_gotno is actually
8373 the upper limit of global entries. */
8379 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
8380 if (htab_find (g
->got_entries
, &e
))
8382 BFD_ASSERT (g
->global_gotno
> 0);
8387 /* If this was a global symbol forced into the primary GOT, we
8388 no longer need an entry for it. We can't release the entry
8389 at this point, but we must at least stop counting it as one
8390 of the symbols that required a forced got entry. */
8391 if (h
->root
.got
.offset
== 2)
8393 BFD_ASSERT (gg
->assigned_gotno
> 0);
8394 gg
->assigned_gotno
--;
8397 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
8398 /* If we haven't got through GOT allocation yet, just bump up the
8399 number of local entries, as this symbol won't be counted as
8402 else if (h
->root
.got
.offset
== 1)
8404 /* If we're past non-multi-GOT allocation and this symbol had
8405 been marked for a global got entry, give it a local entry
8407 BFD_ASSERT (g
->global_gotno
> 0);
8413 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
8419 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
8420 struct bfd_link_info
*info
)
8423 bfd_boolean ret
= FALSE
;
8424 unsigned char *tdata
;
8427 o
= bfd_get_section_by_name (abfd
, ".pdr");
8432 if (o
->size
% PDR_SIZE
!= 0)
8434 if (o
->output_section
!= NULL
8435 && bfd_is_abs_section (o
->output_section
))
8438 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
8442 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
8450 cookie
->rel
= cookie
->rels
;
8451 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
8453 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
8455 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
8464 mips_elf_section_data (o
)->u
.tdata
= tdata
;
8465 o
->size
-= skip
* PDR_SIZE
;
8471 if (! info
->keep_memory
)
8472 free (cookie
->rels
);
8478 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
8480 if (strcmp (sec
->name
, ".pdr") == 0)
8486 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
8489 bfd_byte
*to
, *from
, *end
;
8492 if (strcmp (sec
->name
, ".pdr") != 0)
8495 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
8499 end
= contents
+ sec
->size
;
8500 for (from
= contents
, i
= 0;
8502 from
+= PDR_SIZE
, i
++)
8504 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
8507 memcpy (to
, from
, PDR_SIZE
);
8510 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
8511 sec
->output_offset
, sec
->size
);
8515 /* MIPS ELF uses a special find_nearest_line routine in order the
8516 handle the ECOFF debugging information. */
8518 struct mips_elf_find_line
8520 struct ecoff_debug_info d
;
8521 struct ecoff_find_line i
;
8525 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
8526 asymbol
**symbols
, bfd_vma offset
,
8527 const char **filename_ptr
,
8528 const char **functionname_ptr
,
8529 unsigned int *line_ptr
)
8533 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
8534 filename_ptr
, functionname_ptr
,
8538 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
8539 filename_ptr
, functionname_ptr
,
8540 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
8541 &elf_tdata (abfd
)->dwarf2_find_line_info
))
8544 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
8548 struct mips_elf_find_line
*fi
;
8549 const struct ecoff_debug_swap
* const swap
=
8550 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8552 /* If we are called during a link, mips_elf_final_link may have
8553 cleared the SEC_HAS_CONTENTS field. We force it back on here
8554 if appropriate (which it normally will be). */
8555 origflags
= msec
->flags
;
8556 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
8557 msec
->flags
|= SEC_HAS_CONTENTS
;
8559 fi
= elf_tdata (abfd
)->find_line_info
;
8562 bfd_size_type external_fdr_size
;
8565 struct fdr
*fdr_ptr
;
8566 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
8568 fi
= bfd_zalloc (abfd
, amt
);
8571 msec
->flags
= origflags
;
8575 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
8577 msec
->flags
= origflags
;
8581 /* Swap in the FDR information. */
8582 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
8583 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
8584 if (fi
->d
.fdr
== NULL
)
8586 msec
->flags
= origflags
;
8589 external_fdr_size
= swap
->external_fdr_size
;
8590 fdr_ptr
= fi
->d
.fdr
;
8591 fraw_src
= (char *) fi
->d
.external_fdr
;
8592 fraw_end
= (fraw_src
8593 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
8594 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
8595 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
8597 elf_tdata (abfd
)->find_line_info
= fi
;
8599 /* Note that we don't bother to ever free this information.
8600 find_nearest_line is either called all the time, as in
8601 objdump -l, so the information should be saved, or it is
8602 rarely called, as in ld error messages, so the memory
8603 wasted is unimportant. Still, it would probably be a
8604 good idea for free_cached_info to throw it away. */
8607 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
8608 &fi
->i
, filename_ptr
, functionname_ptr
,
8611 msec
->flags
= origflags
;
8615 msec
->flags
= origflags
;
8618 /* Fall back on the generic ELF find_nearest_line routine. */
8620 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
8621 filename_ptr
, functionname_ptr
,
8625 /* When are writing out the .options or .MIPS.options section,
8626 remember the bytes we are writing out, so that we can install the
8627 GP value in the section_processing routine. */
8630 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
8631 const void *location
,
8632 file_ptr offset
, bfd_size_type count
)
8634 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8638 if (elf_section_data (section
) == NULL
)
8640 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
8641 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
8642 if (elf_section_data (section
) == NULL
)
8645 c
= mips_elf_section_data (section
)->u
.tdata
;
8648 c
= bfd_zalloc (abfd
, section
->size
);
8651 mips_elf_section_data (section
)->u
.tdata
= c
;
8654 memcpy (c
+ offset
, location
, count
);
8657 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
8661 /* This is almost identical to bfd_generic_get_... except that some
8662 MIPS relocations need to be handled specially. Sigh. */
8665 _bfd_elf_mips_get_relocated_section_contents
8667 struct bfd_link_info
*link_info
,
8668 struct bfd_link_order
*link_order
,
8670 bfd_boolean relocatable
,
8673 /* Get enough memory to hold the stuff */
8674 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8675 asection
*input_section
= link_order
->u
.indirect
.section
;
8678 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8679 arelent
**reloc_vector
= NULL
;
8685 reloc_vector
= bfd_malloc (reloc_size
);
8686 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8689 /* read in the section */
8690 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
8691 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
8694 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8698 if (reloc_count
< 0)
8701 if (reloc_count
> 0)
8706 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8709 struct bfd_hash_entry
*h
;
8710 struct bfd_link_hash_entry
*lh
;
8711 /* Skip all this stuff if we aren't mixing formats. */
8712 if (abfd
&& input_bfd
8713 && abfd
->xvec
== input_bfd
->xvec
)
8717 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8718 lh
= (struct bfd_link_hash_entry
*) h
;
8725 case bfd_link_hash_undefined
:
8726 case bfd_link_hash_undefweak
:
8727 case bfd_link_hash_common
:
8730 case bfd_link_hash_defined
:
8731 case bfd_link_hash_defweak
:
8733 gp
= lh
->u
.def
.value
;
8735 case bfd_link_hash_indirect
:
8736 case bfd_link_hash_warning
:
8738 /* @@FIXME ignoring warning for now */
8740 case bfd_link_hash_new
:
8749 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8751 char *error_message
= NULL
;
8752 bfd_reloc_status_type r
;
8754 /* Specific to MIPS: Deal with relocation types that require
8755 knowing the gp of the output bfd. */
8756 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8757 if (bfd_is_abs_section (sym
->section
) && abfd
)
8759 /* The special_function wouldn't get called anyway. */
8763 /* The gp isn't there; let the special function code
8764 fall over on its own. */
8766 else if ((*parent
)->howto
->special_function
8767 == _bfd_mips_elf32_gprel16_reloc
)
8769 /* bypass special_function call */
8770 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8771 input_section
, relocatable
,
8773 goto skip_bfd_perform_relocation
;
8775 /* end mips specific stuff */
8777 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8778 relocatable
? abfd
: NULL
,
8780 skip_bfd_perform_relocation
:
8784 asection
*os
= input_section
->output_section
;
8786 /* A partial link, so keep the relocs */
8787 os
->orelocation
[os
->reloc_count
] = *parent
;
8791 if (r
!= bfd_reloc_ok
)
8795 case bfd_reloc_undefined
:
8796 if (!((*link_info
->callbacks
->undefined_symbol
)
8797 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8798 input_bfd
, input_section
, (*parent
)->address
,
8802 case bfd_reloc_dangerous
:
8803 BFD_ASSERT (error_message
!= NULL
);
8804 if (!((*link_info
->callbacks
->reloc_dangerous
)
8805 (link_info
, error_message
, input_bfd
, input_section
,
8806 (*parent
)->address
)))
8809 case bfd_reloc_overflow
:
8810 if (!((*link_info
->callbacks
->reloc_overflow
)
8812 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8813 (*parent
)->howto
->name
, (*parent
)->addend
,
8814 input_bfd
, input_section
, (*parent
)->address
)))
8817 case bfd_reloc_outofrange
:
8826 if (reloc_vector
!= NULL
)
8827 free (reloc_vector
);
8831 if (reloc_vector
!= NULL
)
8832 free (reloc_vector
);
8836 /* Create a MIPS ELF linker hash table. */
8838 struct bfd_link_hash_table
*
8839 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8841 struct mips_elf_link_hash_table
*ret
;
8842 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8844 ret
= bfd_malloc (amt
);
8848 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8849 mips_elf_link_hash_newfunc
))
8856 /* We no longer use this. */
8857 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8858 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8860 ret
->procedure_count
= 0;
8861 ret
->compact_rel_size
= 0;
8862 ret
->use_rld_obj_head
= FALSE
;
8864 ret
->mips16_stubs_seen
= FALSE
;
8866 return &ret
->root
.root
;
8869 /* We need to use a special link routine to handle the .reginfo and
8870 the .mdebug sections. We need to merge all instances of these
8871 sections together, not write them all out sequentially. */
8874 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8878 struct bfd_link_order
*p
;
8879 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8880 asection
*rtproc_sec
;
8881 Elf32_RegInfo reginfo
;
8882 struct ecoff_debug_info debug
;
8883 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8884 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
8885 HDRR
*symhdr
= &debug
.symbolic_header
;
8886 void *mdebug_handle
= NULL
;
8892 static const char * const secname
[] =
8894 ".text", ".init", ".fini", ".data",
8895 ".rodata", ".sdata", ".sbss", ".bss"
8897 static const int sc
[] =
8899 scText
, scInit
, scFini
, scData
,
8900 scRData
, scSData
, scSBss
, scBss
8903 /* We'd carefully arranged the dynamic symbol indices, and then the
8904 generic size_dynamic_sections renumbered them out from under us.
8905 Rather than trying somehow to prevent the renumbering, just do
8907 if (elf_hash_table (info
)->dynamic_sections_created
)
8911 struct mips_got_info
*g
;
8912 bfd_size_type dynsecsymcount
;
8914 /* When we resort, we must tell mips_elf_sort_hash_table what
8915 the lowest index it may use is. That's the number of section
8916 symbols we're going to add. The generic ELF linker only
8917 adds these symbols when building a shared object. Note that
8918 we count the sections after (possibly) removing the .options
8926 for (p
= abfd
->sections
; p
; p
= p
->next
)
8927 if ((p
->flags
& SEC_EXCLUDE
) == 0
8928 && (p
->flags
& SEC_ALLOC
) != 0
8929 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
8933 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
8936 /* Make sure we didn't grow the global .got region. */
8937 dynobj
= elf_hash_table (info
)->dynobj
;
8938 got
= mips_elf_got_section (dynobj
, FALSE
);
8939 g
= mips_elf_section_data (got
)->u
.got_info
;
8941 if (g
->global_gotsym
!= NULL
)
8942 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8943 - g
->global_gotsym
->dynindx
)
8944 <= g
->global_gotno
);
8947 /* Get a value for the GP register. */
8948 if (elf_gp (abfd
) == 0)
8950 struct bfd_link_hash_entry
*h
;
8952 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8953 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8954 elf_gp (abfd
) = (h
->u
.def
.value
8955 + h
->u
.def
.section
->output_section
->vma
8956 + h
->u
.def
.section
->output_offset
);
8957 else if (info
->relocatable
)
8959 bfd_vma lo
= MINUS_ONE
;
8961 /* Find the GP-relative section with the lowest offset. */
8962 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8964 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8967 /* And calculate GP relative to that. */
8968 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8972 /* If the relocate_section function needs to do a reloc
8973 involving the GP value, it should make a reloc_dangerous
8974 callback to warn that GP is not defined. */
8978 /* Go through the sections and collect the .reginfo and .mdebug
8982 gptab_data_sec
= NULL
;
8983 gptab_bss_sec
= NULL
;
8984 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8986 if (strcmp (o
->name
, ".reginfo") == 0)
8988 memset (®info
, 0, sizeof reginfo
);
8990 /* We have found the .reginfo section in the output file.
8991 Look through all the link_orders comprising it and merge
8992 the information together. */
8993 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8995 asection
*input_section
;
8997 Elf32_External_RegInfo ext
;
9000 if (p
->type
!= bfd_indirect_link_order
)
9002 if (p
->type
== bfd_data_link_order
)
9007 input_section
= p
->u
.indirect
.section
;
9008 input_bfd
= input_section
->owner
;
9010 if (! bfd_get_section_contents (input_bfd
, input_section
,
9011 &ext
, 0, sizeof ext
))
9014 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
9016 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
9017 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
9018 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
9019 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
9020 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
9022 /* ri_gp_value is set by the function
9023 mips_elf32_section_processing when the section is
9024 finally written out. */
9026 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9027 elf_link_input_bfd ignores this section. */
9028 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9031 /* Size has been set in _bfd_mips_elf_always_size_sections. */
9032 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
9034 /* Skip this section later on (I don't think this currently
9035 matters, but someday it might). */
9036 o
->link_order_head
= NULL
;
9041 if (strcmp (o
->name
, ".mdebug") == 0)
9043 struct extsym_info einfo
;
9046 /* We have found the .mdebug section in the output file.
9047 Look through all the link_orders comprising it and merge
9048 the information together. */
9049 symhdr
->magic
= swap
->sym_magic
;
9050 /* FIXME: What should the version stamp be? */
9052 symhdr
->ilineMax
= 0;
9056 symhdr
->isymMax
= 0;
9057 symhdr
->ioptMax
= 0;
9058 symhdr
->iauxMax
= 0;
9060 symhdr
->issExtMax
= 0;
9063 symhdr
->iextMax
= 0;
9065 /* We accumulate the debugging information itself in the
9066 debug_info structure. */
9068 debug
.external_dnr
= NULL
;
9069 debug
.external_pdr
= NULL
;
9070 debug
.external_sym
= NULL
;
9071 debug
.external_opt
= NULL
;
9072 debug
.external_aux
= NULL
;
9074 debug
.ssext
= debug
.ssext_end
= NULL
;
9075 debug
.external_fdr
= NULL
;
9076 debug
.external_rfd
= NULL
;
9077 debug
.external_ext
= debug
.external_ext_end
= NULL
;
9079 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
9080 if (mdebug_handle
== NULL
)
9084 esym
.cobol_main
= 0;
9088 esym
.asym
.iss
= issNil
;
9089 esym
.asym
.st
= stLocal
;
9090 esym
.asym
.reserved
= 0;
9091 esym
.asym
.index
= indexNil
;
9093 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
9095 esym
.asym
.sc
= sc
[i
];
9096 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
9099 esym
.asym
.value
= s
->vma
;
9100 last
= s
->vma
+ s
->size
;
9103 esym
.asym
.value
= last
;
9104 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
9109 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9111 asection
*input_section
;
9113 const struct ecoff_debug_swap
*input_swap
;
9114 struct ecoff_debug_info input_debug
;
9118 if (p
->type
!= bfd_indirect_link_order
)
9120 if (p
->type
== bfd_data_link_order
)
9125 input_section
= p
->u
.indirect
.section
;
9126 input_bfd
= input_section
->owner
;
9128 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
9129 || (get_elf_backend_data (input_bfd
)
9130 ->elf_backend_ecoff_debug_swap
) == NULL
)
9132 /* I don't know what a non MIPS ELF bfd would be
9133 doing with a .mdebug section, but I don't really
9134 want to deal with it. */
9138 input_swap
= (get_elf_backend_data (input_bfd
)
9139 ->elf_backend_ecoff_debug_swap
);
9141 BFD_ASSERT (p
->size
== input_section
->size
);
9143 /* The ECOFF linking code expects that we have already
9144 read in the debugging information and set up an
9145 ecoff_debug_info structure, so we do that now. */
9146 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
9150 if (! (bfd_ecoff_debug_accumulate
9151 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
9152 &input_debug
, input_swap
, info
)))
9155 /* Loop through the external symbols. For each one with
9156 interesting information, try to find the symbol in
9157 the linker global hash table and save the information
9158 for the output external symbols. */
9159 eraw_src
= input_debug
.external_ext
;
9160 eraw_end
= (eraw_src
9161 + (input_debug
.symbolic_header
.iextMax
9162 * input_swap
->external_ext_size
));
9164 eraw_src
< eraw_end
;
9165 eraw_src
+= input_swap
->external_ext_size
)
9169 struct mips_elf_link_hash_entry
*h
;
9171 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
9172 if (ext
.asym
.sc
== scNil
9173 || ext
.asym
.sc
== scUndefined
9174 || ext
.asym
.sc
== scSUndefined
)
9177 name
= input_debug
.ssext
+ ext
.asym
.iss
;
9178 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
9179 name
, FALSE
, FALSE
, TRUE
);
9180 if (h
== NULL
|| h
->esym
.ifd
!= -2)
9186 < input_debug
.symbolic_header
.ifdMax
);
9187 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
9193 /* Free up the information we just read. */
9194 free (input_debug
.line
);
9195 free (input_debug
.external_dnr
);
9196 free (input_debug
.external_pdr
);
9197 free (input_debug
.external_sym
);
9198 free (input_debug
.external_opt
);
9199 free (input_debug
.external_aux
);
9200 free (input_debug
.ss
);
9201 free (input_debug
.ssext
);
9202 free (input_debug
.external_fdr
);
9203 free (input_debug
.external_rfd
);
9204 free (input_debug
.external_ext
);
9206 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9207 elf_link_input_bfd ignores this section. */
9208 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9211 if (SGI_COMPAT (abfd
) && info
->shared
)
9213 /* Create .rtproc section. */
9214 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
9215 if (rtproc_sec
== NULL
)
9217 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
9218 | SEC_LINKER_CREATED
| SEC_READONLY
);
9220 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
9221 if (rtproc_sec
== NULL
9222 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
9223 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
9227 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
9233 /* Build the external symbol information. */
9236 einfo
.debug
= &debug
;
9238 einfo
.failed
= FALSE
;
9239 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
9240 mips_elf_output_extsym
, &einfo
);
9244 /* Set the size of the .mdebug section. */
9245 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
9247 /* Skip this section later on (I don't think this currently
9248 matters, but someday it might). */
9249 o
->link_order_head
= NULL
;
9254 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
9256 const char *subname
;
9259 Elf32_External_gptab
*ext_tab
;
9262 /* The .gptab.sdata and .gptab.sbss sections hold
9263 information describing how the small data area would
9264 change depending upon the -G switch. These sections
9265 not used in executables files. */
9266 if (! info
->relocatable
)
9268 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9270 asection
*input_section
;
9272 if (p
->type
!= bfd_indirect_link_order
)
9274 if (p
->type
== bfd_data_link_order
)
9279 input_section
= p
->u
.indirect
.section
;
9281 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9282 elf_link_input_bfd ignores this section. */
9283 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9286 /* Skip this section later on (I don't think this
9287 currently matters, but someday it might). */
9288 o
->link_order_head
= NULL
;
9290 /* Really remove the section. */
9291 for (secpp
= &abfd
->sections
;
9293 secpp
= &(*secpp
)->next
)
9295 bfd_section_list_remove (abfd
, secpp
);
9296 --abfd
->section_count
;
9301 /* There is one gptab for initialized data, and one for
9302 uninitialized data. */
9303 if (strcmp (o
->name
, ".gptab.sdata") == 0)
9305 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
9309 (*_bfd_error_handler
)
9310 (_("%s: illegal section name `%s'"),
9311 bfd_get_filename (abfd
), o
->name
);
9312 bfd_set_error (bfd_error_nonrepresentable_section
);
9316 /* The linker script always combines .gptab.data and
9317 .gptab.sdata into .gptab.sdata, and likewise for
9318 .gptab.bss and .gptab.sbss. It is possible that there is
9319 no .sdata or .sbss section in the output file, in which
9320 case we must change the name of the output section. */
9321 subname
= o
->name
+ sizeof ".gptab" - 1;
9322 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
9324 if (o
== gptab_data_sec
)
9325 o
->name
= ".gptab.data";
9327 o
->name
= ".gptab.bss";
9328 subname
= o
->name
+ sizeof ".gptab" - 1;
9329 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
9332 /* Set up the first entry. */
9334 amt
= c
* sizeof (Elf32_gptab
);
9335 tab
= bfd_malloc (amt
);
9338 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
9339 tab
[0].gt_header
.gt_unused
= 0;
9341 /* Combine the input sections. */
9342 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9344 asection
*input_section
;
9348 bfd_size_type gpentry
;
9350 if (p
->type
!= bfd_indirect_link_order
)
9352 if (p
->type
== bfd_data_link_order
)
9357 input_section
= p
->u
.indirect
.section
;
9358 input_bfd
= input_section
->owner
;
9360 /* Combine the gptab entries for this input section one
9361 by one. We know that the input gptab entries are
9362 sorted by ascending -G value. */
9363 size
= input_section
->size
;
9365 for (gpentry
= sizeof (Elf32_External_gptab
);
9367 gpentry
+= sizeof (Elf32_External_gptab
))
9369 Elf32_External_gptab ext_gptab
;
9370 Elf32_gptab int_gptab
;
9376 if (! (bfd_get_section_contents
9377 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
9378 sizeof (Elf32_External_gptab
))))
9384 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
9386 val
= int_gptab
.gt_entry
.gt_g_value
;
9387 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
9390 for (look
= 1; look
< c
; look
++)
9392 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
9393 tab
[look
].gt_entry
.gt_bytes
+= add
;
9395 if (tab
[look
].gt_entry
.gt_g_value
== val
)
9401 Elf32_gptab
*new_tab
;
9404 /* We need a new table entry. */
9405 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
9406 new_tab
= bfd_realloc (tab
, amt
);
9407 if (new_tab
== NULL
)
9413 tab
[c
].gt_entry
.gt_g_value
= val
;
9414 tab
[c
].gt_entry
.gt_bytes
= add
;
9416 /* Merge in the size for the next smallest -G
9417 value, since that will be implied by this new
9420 for (look
= 1; look
< c
; look
++)
9422 if (tab
[look
].gt_entry
.gt_g_value
< val
9424 || (tab
[look
].gt_entry
.gt_g_value
9425 > tab
[max
].gt_entry
.gt_g_value
)))
9429 tab
[c
].gt_entry
.gt_bytes
+=
9430 tab
[max
].gt_entry
.gt_bytes
;
9435 last
= int_gptab
.gt_entry
.gt_bytes
;
9438 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9439 elf_link_input_bfd ignores this section. */
9440 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9443 /* The table must be sorted by -G value. */
9445 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
9447 /* Swap out the table. */
9448 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
9449 ext_tab
= bfd_alloc (abfd
, amt
);
9450 if (ext_tab
== NULL
)
9456 for (j
= 0; j
< c
; j
++)
9457 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
9460 o
->size
= c
* sizeof (Elf32_External_gptab
);
9461 o
->contents
= (bfd_byte
*) ext_tab
;
9463 /* Skip this section later on (I don't think this currently
9464 matters, but someday it might). */
9465 o
->link_order_head
= NULL
;
9469 /* Invoke the regular ELF backend linker to do all the work. */
9470 if (!bfd_elf_final_link (abfd
, info
))
9473 /* Now write out the computed sections. */
9475 if (reginfo_sec
!= NULL
)
9477 Elf32_External_RegInfo ext
;
9479 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
9480 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
9484 if (mdebug_sec
!= NULL
)
9486 BFD_ASSERT (abfd
->output_has_begun
);
9487 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
9489 mdebug_sec
->filepos
))
9492 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
9495 if (gptab_data_sec
!= NULL
)
9497 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
9498 gptab_data_sec
->contents
,
9499 0, gptab_data_sec
->size
))
9503 if (gptab_bss_sec
!= NULL
)
9505 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
9506 gptab_bss_sec
->contents
,
9507 0, gptab_bss_sec
->size
))
9511 if (SGI_COMPAT (abfd
))
9513 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
9514 if (rtproc_sec
!= NULL
)
9516 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
9517 rtproc_sec
->contents
,
9518 0, rtproc_sec
->size
))
9526 /* Structure for saying that BFD machine EXTENSION extends BASE. */
9528 struct mips_mach_extension
{
9529 unsigned long extension
, base
;
9533 /* An array describing how BFD machines relate to one another. The entries
9534 are ordered topologically with MIPS I extensions listed last. */
9536 static const struct mips_mach_extension mips_mach_extensions
[] = {
9537 /* MIPS64 extensions. */
9538 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
9539 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
9541 /* MIPS V extensions. */
9542 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
9544 /* R10000 extensions. */
9545 { bfd_mach_mips12000
, bfd_mach_mips10000
},
9547 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
9548 vr5400 ISA, but doesn't include the multimedia stuff. It seems
9549 better to allow vr5400 and vr5500 code to be merged anyway, since
9550 many libraries will just use the core ISA. Perhaps we could add
9551 some sort of ASE flag if this ever proves a problem. */
9552 { bfd_mach_mips5500
, bfd_mach_mips5400
},
9553 { bfd_mach_mips5400
, bfd_mach_mips5000
},
9555 /* MIPS IV extensions. */
9556 { bfd_mach_mips5
, bfd_mach_mips8000
},
9557 { bfd_mach_mips10000
, bfd_mach_mips8000
},
9558 { bfd_mach_mips5000
, bfd_mach_mips8000
},
9559 { bfd_mach_mips7000
, bfd_mach_mips8000
},
9560 { bfd_mach_mips9000
, bfd_mach_mips8000
},
9562 /* VR4100 extensions. */
9563 { bfd_mach_mips4120
, bfd_mach_mips4100
},
9564 { bfd_mach_mips4111
, bfd_mach_mips4100
},
9566 /* MIPS III extensions. */
9567 { bfd_mach_mips8000
, bfd_mach_mips4000
},
9568 { bfd_mach_mips4650
, bfd_mach_mips4000
},
9569 { bfd_mach_mips4600
, bfd_mach_mips4000
},
9570 { bfd_mach_mips4400
, bfd_mach_mips4000
},
9571 { bfd_mach_mips4300
, bfd_mach_mips4000
},
9572 { bfd_mach_mips4100
, bfd_mach_mips4000
},
9573 { bfd_mach_mips4010
, bfd_mach_mips4000
},
9575 /* MIPS32 extensions. */
9576 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
9578 /* MIPS II extensions. */
9579 { bfd_mach_mips4000
, bfd_mach_mips6000
},
9580 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
9582 /* MIPS I extensions. */
9583 { bfd_mach_mips6000
, bfd_mach_mips3000
},
9584 { bfd_mach_mips3900
, bfd_mach_mips3000
}
9588 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
9591 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
9595 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
9596 if (extension
== mips_mach_extensions
[i
].extension
)
9597 extension
= mips_mach_extensions
[i
].base
;
9599 return extension
== base
;
9603 /* Return true if the given ELF header flags describe a 32-bit binary. */
9606 mips_32bit_flags_p (flagword flags
)
9608 return ((flags
& EF_MIPS_32BITMODE
) != 0
9609 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
9610 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
9611 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
9612 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
9613 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
9614 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
9618 /* Merge backend specific data from an object file to the output
9619 object file when linking. */
9622 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
9627 bfd_boolean null_input_bfd
= TRUE
;
9630 /* Check if we have the same endianess */
9631 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
9633 (*_bfd_error_handler
)
9634 (_("%B: endianness incompatible with that of the selected emulation"),
9639 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9640 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9643 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9645 (*_bfd_error_handler
)
9646 (_("%B: ABI is incompatible with that of the selected emulation"),
9651 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9652 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9653 old_flags
= elf_elfheader (obfd
)->e_flags
;
9655 if (! elf_flags_init (obfd
))
9657 elf_flags_init (obfd
) = TRUE
;
9658 elf_elfheader (obfd
)->e_flags
= new_flags
;
9659 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9660 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9662 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9663 && bfd_get_arch_info (obfd
)->the_default
)
9665 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9666 bfd_get_mach (ibfd
)))
9673 /* Check flag compatibility. */
9675 new_flags
&= ~EF_MIPS_NOREORDER
;
9676 old_flags
&= ~EF_MIPS_NOREORDER
;
9678 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9679 doesn't seem to matter. */
9680 new_flags
&= ~EF_MIPS_XGOT
;
9681 old_flags
&= ~EF_MIPS_XGOT
;
9683 /* MIPSpro generates ucode info in n64 objects. Again, we should
9684 just be able to ignore this. */
9685 new_flags
&= ~EF_MIPS_UCODE
;
9686 old_flags
&= ~EF_MIPS_UCODE
;
9688 if (new_flags
== old_flags
)
9691 /* Check to see if the input BFD actually contains any sections.
9692 If not, its flags may not have been initialised either, but it cannot
9693 actually cause any incompatibility. */
9694 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9696 /* Ignore synthetic sections and empty .text, .data and .bss sections
9697 which are automatically generated by gas. */
9698 if (strcmp (sec
->name
, ".reginfo")
9699 && strcmp (sec
->name
, ".mdebug")
9701 || (strcmp (sec
->name
, ".text")
9702 && strcmp (sec
->name
, ".data")
9703 && strcmp (sec
->name
, ".bss"))))
9705 null_input_bfd
= FALSE
;
9714 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9715 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9717 (*_bfd_error_handler
)
9718 (_("%B: warning: linking PIC files with non-PIC files"),
9723 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9724 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9725 if (! (new_flags
& EF_MIPS_PIC
))
9726 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9728 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9729 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9731 /* Compare the ISAs. */
9732 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9734 (*_bfd_error_handler
)
9735 (_("%B: linking 32-bit code with 64-bit code"),
9739 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9741 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9742 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9744 /* Copy the architecture info from IBFD to OBFD. Also copy
9745 the 32-bit flag (if set) so that we continue to recognise
9746 OBFD as a 32-bit binary. */
9747 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9748 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9749 elf_elfheader (obfd
)->e_flags
9750 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9752 /* Copy across the ABI flags if OBFD doesn't use them
9753 and if that was what caused us to treat IBFD as 32-bit. */
9754 if ((old_flags
& EF_MIPS_ABI
) == 0
9755 && mips_32bit_flags_p (new_flags
)
9756 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9757 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9761 /* The ISAs aren't compatible. */
9762 (*_bfd_error_handler
)
9763 (_("%B: linking %s module with previous %s modules"),
9765 bfd_printable_name (ibfd
),
9766 bfd_printable_name (obfd
));
9771 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9772 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9774 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9775 does set EI_CLASS differently from any 32-bit ABI. */
9776 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9777 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9778 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9780 /* Only error if both are set (to different values). */
9781 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9782 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9783 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9785 (*_bfd_error_handler
)
9786 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9788 elf_mips_abi_name (ibfd
),
9789 elf_mips_abi_name (obfd
));
9792 new_flags
&= ~EF_MIPS_ABI
;
9793 old_flags
&= ~EF_MIPS_ABI
;
9796 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9797 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9799 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9801 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9802 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9805 /* Warn about any other mismatches */
9806 if (new_flags
!= old_flags
)
9808 (*_bfd_error_handler
)
9809 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9810 ibfd
, (unsigned long) new_flags
,
9811 (unsigned long) old_flags
);
9817 bfd_set_error (bfd_error_bad_value
);
9824 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9827 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9829 BFD_ASSERT (!elf_flags_init (abfd
)
9830 || elf_elfheader (abfd
)->e_flags
== flags
);
9832 elf_elfheader (abfd
)->e_flags
= flags
;
9833 elf_flags_init (abfd
) = TRUE
;
9838 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9842 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9844 /* Print normal ELF private data. */
9845 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9847 /* xgettext:c-format */
9848 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9850 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9851 fprintf (file
, _(" [abi=O32]"));
9852 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9853 fprintf (file
, _(" [abi=O64]"));
9854 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9855 fprintf (file
, _(" [abi=EABI32]"));
9856 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9857 fprintf (file
, _(" [abi=EABI64]"));
9858 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9859 fprintf (file
, _(" [abi unknown]"));
9860 else if (ABI_N32_P (abfd
))
9861 fprintf (file
, _(" [abi=N32]"));
9862 else if (ABI_64_P (abfd
))
9863 fprintf (file
, _(" [abi=64]"));
9865 fprintf (file
, _(" [no abi set]"));
9867 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9868 fprintf (file
, _(" [mips1]"));
9869 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9870 fprintf (file
, _(" [mips2]"));
9871 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9872 fprintf (file
, _(" [mips3]"));
9873 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9874 fprintf (file
, _(" [mips4]"));
9875 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9876 fprintf (file
, _(" [mips5]"));
9877 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9878 fprintf (file
, _(" [mips32]"));
9879 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9880 fprintf (file
, _(" [mips64]"));
9881 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9882 fprintf (file
, _(" [mips32r2]"));
9883 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9884 fprintf (file
, _(" [mips64r2]"));
9886 fprintf (file
, _(" [unknown ISA]"));
9888 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9889 fprintf (file
, _(" [mdmx]"));
9891 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9892 fprintf (file
, _(" [mips16]"));
9894 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9895 fprintf (file
, _(" [32bitmode]"));
9897 fprintf (file
, _(" [not 32bitmode]"));
9904 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9906 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9907 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9908 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9909 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9910 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9911 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9912 { NULL
, 0, 0, 0, 0 }