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 02110-1301, 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? This will only be set if we have converted
246 the initial global GOT entry to a local GOT entry. */
247 bfd_boolean forced_local
;
251 #define GOT_TLS_LDM 2
253 #define GOT_TLS_OFFSET_DONE 0x40
254 #define GOT_TLS_DONE 0x80
255 unsigned char tls_type
;
256 /* This is only used in single-GOT mode; in multi-GOT mode there
257 is one mips_got_entry per GOT entry, so the offset is stored
258 there. In single-GOT mode there may be many mips_got_entry
259 structures all referring to the same GOT slot. It might be
260 possible to use root.got.offset instead, but that field is
261 overloaded already. */
262 bfd_vma tls_got_offset
;
265 /* MIPS ELF linker hash table. */
267 struct mips_elf_link_hash_table
269 struct elf_link_hash_table root
;
271 /* We no longer use this. */
272 /* String section indices for the dynamic section symbols. */
273 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
275 /* The number of .rtproc entries. */
276 bfd_size_type procedure_count
;
277 /* The size of the .compact_rel section (if SGI_COMPAT). */
278 bfd_size_type compact_rel_size
;
279 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
280 entry is set to the address of __rld_obj_head as in IRIX5. */
281 bfd_boolean use_rld_obj_head
;
282 /* This is the value of the __rld_map or __rld_obj_head symbol. */
284 /* This is set if we see any mips16 stub sections. */
285 bfd_boolean mips16_stubs_seen
;
288 #define TLS_RELOC_P(r_type) \
289 (r_type == R_MIPS_TLS_DTPMOD32 \
290 || r_type == R_MIPS_TLS_DTPMOD64 \
291 || r_type == R_MIPS_TLS_DTPREL32 \
292 || r_type == R_MIPS_TLS_DTPREL64 \
293 || r_type == R_MIPS_TLS_GD \
294 || r_type == R_MIPS_TLS_LDM \
295 || r_type == R_MIPS_TLS_DTPREL_HI16 \
296 || r_type == R_MIPS_TLS_DTPREL_LO16 \
297 || r_type == R_MIPS_TLS_GOTTPREL \
298 || r_type == R_MIPS_TLS_TPREL32 \
299 || r_type == R_MIPS_TLS_TPREL64 \
300 || r_type == R_MIPS_TLS_TPREL_HI16 \
301 || r_type == R_MIPS_TLS_TPREL_LO16)
303 /* Structure used to pass information to mips_elf_output_extsym. */
308 struct bfd_link_info
*info
;
309 struct ecoff_debug_info
*debug
;
310 const struct ecoff_debug_swap
*swap
;
314 /* The names of the runtime procedure table symbols used on IRIX5. */
316 static const char * const mips_elf_dynsym_rtproc_names
[] =
319 "_procedure_string_table",
320 "_procedure_table_size",
324 /* These structures are used to generate the .compact_rel section on
329 unsigned long id1
; /* Always one? */
330 unsigned long num
; /* Number of compact relocation entries. */
331 unsigned long id2
; /* Always two? */
332 unsigned long offset
; /* The file offset of the first relocation. */
333 unsigned long reserved0
; /* Zero? */
334 unsigned long reserved1
; /* Zero? */
343 bfd_byte reserved0
[4];
344 bfd_byte reserved1
[4];
345 } Elf32_External_compact_rel
;
349 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
350 unsigned int rtype
: 4; /* Relocation types. See below. */
351 unsigned int dist2to
: 8;
352 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
353 unsigned long konst
; /* KONST field. See below. */
354 unsigned long vaddr
; /* VADDR to be relocated. */
359 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
360 unsigned int rtype
: 4; /* Relocation types. See below. */
361 unsigned int dist2to
: 8;
362 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
363 unsigned long konst
; /* KONST field. See below. */
371 } Elf32_External_crinfo
;
377 } Elf32_External_crinfo2
;
379 /* These are the constants used to swap the bitfields in a crinfo. */
381 #define CRINFO_CTYPE (0x1)
382 #define CRINFO_CTYPE_SH (31)
383 #define CRINFO_RTYPE (0xf)
384 #define CRINFO_RTYPE_SH (27)
385 #define CRINFO_DIST2TO (0xff)
386 #define CRINFO_DIST2TO_SH (19)
387 #define CRINFO_RELVADDR (0x7ffff)
388 #define CRINFO_RELVADDR_SH (0)
390 /* A compact relocation info has long (3 words) or short (2 words)
391 formats. A short format doesn't have VADDR field and relvaddr
392 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
393 #define CRF_MIPS_LONG 1
394 #define CRF_MIPS_SHORT 0
396 /* There are 4 types of compact relocation at least. The value KONST
397 has different meaning for each type:
400 CT_MIPS_REL32 Address in data
401 CT_MIPS_WORD Address in word (XXX)
402 CT_MIPS_GPHI_LO GP - vaddr
403 CT_MIPS_JMPAD Address to jump
406 #define CRT_MIPS_REL32 0xa
407 #define CRT_MIPS_WORD 0xb
408 #define CRT_MIPS_GPHI_LO 0xc
409 #define CRT_MIPS_JMPAD 0xd
411 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
412 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
413 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
414 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
416 /* The structure of the runtime procedure descriptor created by the
417 loader for use by the static exception system. */
419 typedef struct runtime_pdr
{
420 bfd_vma adr
; /* Memory address of start of procedure. */
421 long regmask
; /* Save register mask. */
422 long regoffset
; /* Save register offset. */
423 long fregmask
; /* Save floating point register mask. */
424 long fregoffset
; /* Save floating point register offset. */
425 long frameoffset
; /* Frame size. */
426 short framereg
; /* Frame pointer register. */
427 short pcreg
; /* Offset or reg of return pc. */
428 long irpss
; /* Index into the runtime string table. */
430 struct exception_info
*exception_info
;/* Pointer to exception array. */
432 #define cbRPDR sizeof (RPDR)
433 #define rpdNil ((pRPDR) 0)
435 static struct mips_got_entry
*mips_elf_create_local_got_entry
436 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
, unsigned long,
437 struct mips_elf_link_hash_entry
*, int);
438 static bfd_boolean mips_elf_sort_hash_table_f
439 (struct mips_elf_link_hash_entry
*, void *);
440 static bfd_vma mips_elf_high
442 static bfd_boolean mips_elf_stub_section_p
444 static bfd_boolean mips_elf_create_dynamic_relocation
445 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
446 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
447 bfd_vma
*, asection
*);
448 static hashval_t mips_elf_got_entry_hash
450 static bfd_vma mips_elf_adjust_gp
451 (bfd
*, struct mips_got_info
*, bfd
*);
452 static struct mips_got_info
*mips_elf_got_for_ibfd
453 (struct mips_got_info
*, bfd
*);
455 /* This will be used when we sort the dynamic relocation records. */
456 static bfd
*reldyn_sorting_bfd
;
458 /* Nonzero if ABFD is using the N32 ABI. */
460 #define ABI_N32_P(abfd) \
461 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
463 /* Nonzero if ABFD is using the N64 ABI. */
464 #define ABI_64_P(abfd) \
465 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
467 /* Nonzero if ABFD is using NewABI conventions. */
468 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
470 /* The IRIX compatibility level we are striving for. */
471 #define IRIX_COMPAT(abfd) \
472 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
474 /* Whether we are trying to be compatible with IRIX at all. */
475 #define SGI_COMPAT(abfd) \
476 (IRIX_COMPAT (abfd) != ict_none)
478 /* The name of the options section. */
479 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
480 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
482 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
483 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
484 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
485 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
487 /* The name of the stub section. */
488 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
490 /* The size of an external REL relocation. */
491 #define MIPS_ELF_REL_SIZE(abfd) \
492 (get_elf_backend_data (abfd)->s->sizeof_rel)
494 /* The size of an external dynamic table entry. */
495 #define MIPS_ELF_DYN_SIZE(abfd) \
496 (get_elf_backend_data (abfd)->s->sizeof_dyn)
498 /* The size of a GOT entry. */
499 #define MIPS_ELF_GOT_SIZE(abfd) \
500 (get_elf_backend_data (abfd)->s->arch_size / 8)
502 /* The size of a symbol-table entry. */
503 #define MIPS_ELF_SYM_SIZE(abfd) \
504 (get_elf_backend_data (abfd)->s->sizeof_sym)
506 /* The default alignment for sections, as a power of two. */
507 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
508 (get_elf_backend_data (abfd)->s->log_file_align)
510 /* Get word-sized data. */
511 #define MIPS_ELF_GET_WORD(abfd, ptr) \
512 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
514 /* Put out word-sized data. */
515 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
517 ? bfd_put_64 (abfd, val, ptr) \
518 : bfd_put_32 (abfd, val, ptr))
520 /* Add a dynamic symbol table-entry. */
521 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
522 _bfd_elf_add_dynamic_entry (info, tag, val)
524 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
525 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
527 /* Determine whether the internal relocation of index REL_IDX is REL
528 (zero) or RELA (non-zero). The assumption is that, if there are
529 two relocation sections for this section, one of them is REL and
530 the other is RELA. If the index of the relocation we're testing is
531 in range for the first relocation section, check that the external
532 relocation size is that for RELA. It is also assumed that, if
533 rel_idx is not in range for the first section, and this first
534 section contains REL relocs, then the relocation is in the second
535 section, that is RELA. */
536 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
537 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
538 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
539 > (bfd_vma)(rel_idx)) \
540 == (elf_section_data (sec)->rel_hdr.sh_entsize \
541 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
542 : sizeof (Elf32_External_Rela))))
544 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
545 from smaller values. Start with zero, widen, *then* decrement. */
546 #define MINUS_ONE (((bfd_vma)0) - 1)
547 #define MINUS_TWO (((bfd_vma)0) - 2)
549 /* The number of local .got entries we reserve. */
550 #define MIPS_RESERVED_GOTNO (2)
552 /* The offset of $gp from the beginning of the .got section. */
553 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
555 /* The maximum size of the GOT for it to be addressable using 16-bit
557 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
559 /* Instructions which appear in a stub. */
560 #define STUB_LW(abfd) \
562 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
563 : 0x8f998010)) /* lw t9,0x8010(gp) */
564 #define STUB_MOVE(abfd) \
566 ? 0x03e0782d /* daddu t7,ra */ \
567 : 0x03e07821)) /* addu t7,ra */
568 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
569 #define STUB_LI16(abfd) \
571 ? 0x64180000 /* daddiu t8,zero,0 */ \
572 : 0x24180000)) /* addiu t8,zero,0 */
573 #define MIPS_FUNCTION_STUB_SIZE (16)
575 /* The name of the dynamic interpreter. This is put in the .interp
578 #define ELF_DYNAMIC_INTERPRETER(abfd) \
579 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
580 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
581 : "/usr/lib/libc.so.1")
584 #define MNAME(bfd,pre,pos) \
585 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
586 #define ELF_R_SYM(bfd, i) \
587 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
588 #define ELF_R_TYPE(bfd, i) \
589 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
590 #define ELF_R_INFO(bfd, s, t) \
591 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
593 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
594 #define ELF_R_SYM(bfd, i) \
596 #define ELF_R_TYPE(bfd, i) \
598 #define ELF_R_INFO(bfd, s, t) \
599 (ELF32_R_INFO (s, t))
602 /* The mips16 compiler uses a couple of special sections to handle
603 floating point arguments.
605 Section names that look like .mips16.fn.FNNAME contain stubs that
606 copy floating point arguments from the fp regs to the gp regs and
607 then jump to FNNAME. If any 32 bit function calls FNNAME, the
608 call should be redirected to the stub instead. If no 32 bit
609 function calls FNNAME, the stub should be discarded. We need to
610 consider any reference to the function, not just a call, because
611 if the address of the function is taken we will need the stub,
612 since the address might be passed to a 32 bit function.
614 Section names that look like .mips16.call.FNNAME contain stubs
615 that copy floating point arguments from the gp regs to the fp
616 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
617 then any 16 bit function that calls FNNAME should be redirected
618 to the stub instead. If FNNAME is not a 32 bit function, the
619 stub should be discarded.
621 .mips16.call.fp.FNNAME sections are similar, but contain stubs
622 which call FNNAME and then copy the return value from the fp regs
623 to the gp regs. These stubs store the return value in $18 while
624 calling FNNAME; any function which might call one of these stubs
625 must arrange to save $18 around the call. (This case is not
626 needed for 32 bit functions that call 16 bit functions, because
627 16 bit functions always return floating point values in both
630 Note that in all cases FNNAME might be defined statically.
631 Therefore, FNNAME is not used literally. Instead, the relocation
632 information will indicate which symbol the section is for.
634 We record any stubs that we find in the symbol table. */
636 #define FN_STUB ".mips16.fn."
637 #define CALL_STUB ".mips16.call."
638 #define CALL_FP_STUB ".mips16.call.fp."
640 /* Look up an entry in a MIPS ELF linker hash table. */
642 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
643 ((struct mips_elf_link_hash_entry *) \
644 elf_link_hash_lookup (&(table)->root, (string), (create), \
647 /* Traverse a MIPS ELF linker hash table. */
649 #define mips_elf_link_hash_traverse(table, func, info) \
650 (elf_link_hash_traverse \
652 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
655 /* Get the MIPS ELF linker hash table from a link_info structure. */
657 #define mips_elf_hash_table(p) \
658 ((struct mips_elf_link_hash_table *) ((p)->hash))
660 /* Find the base offsets for thread-local storage in this object,
661 for GD/LD and IE/LE respectively. */
663 #define TP_OFFSET 0x7000
664 #define DTP_OFFSET 0x8000
667 dtprel_base (struct bfd_link_info
*info
)
669 /* If tls_sec is NULL, we should have signalled an error already. */
670 if (elf_hash_table (info
)->tls_sec
== NULL
)
672 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
676 tprel_base (struct bfd_link_info
*info
)
678 /* If tls_sec is NULL, we should have signalled an error already. */
679 if (elf_hash_table (info
)->tls_sec
== NULL
)
681 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
684 /* Create an entry in a MIPS ELF linker hash table. */
686 static struct bfd_hash_entry
*
687 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
688 struct bfd_hash_table
*table
, const char *string
)
690 struct mips_elf_link_hash_entry
*ret
=
691 (struct mips_elf_link_hash_entry
*) entry
;
693 /* Allocate the structure if it has not already been allocated by a
696 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
698 return (struct bfd_hash_entry
*) ret
;
700 /* Call the allocation method of the superclass. */
701 ret
= ((struct mips_elf_link_hash_entry
*)
702 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
706 /* Set local fields. */
707 memset (&ret
->esym
, 0, sizeof (EXTR
));
708 /* We use -2 as a marker to indicate that the information has
709 not been set. -1 means there is no associated ifd. */
711 ret
->possibly_dynamic_relocs
= 0;
712 ret
->readonly_reloc
= FALSE
;
713 ret
->no_fn_stub
= FALSE
;
715 ret
->need_fn_stub
= FALSE
;
716 ret
->call_stub
= NULL
;
717 ret
->call_fp_stub
= NULL
;
718 ret
->forced_local
= FALSE
;
719 ret
->tls_type
= GOT_NORMAL
;
722 return (struct bfd_hash_entry
*) ret
;
726 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
728 struct _mips_elf_section_data
*sdata
;
729 bfd_size_type amt
= sizeof (*sdata
);
731 sdata
= bfd_zalloc (abfd
, amt
);
734 sec
->used_by_bfd
= sdata
;
736 return _bfd_elf_new_section_hook (abfd
, sec
);
739 /* Read ECOFF debugging information from a .mdebug section into a
740 ecoff_debug_info structure. */
743 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
744 struct ecoff_debug_info
*debug
)
747 const struct ecoff_debug_swap
*swap
;
750 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
751 memset (debug
, 0, sizeof (*debug
));
753 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
754 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
757 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
758 swap
->external_hdr_size
))
761 symhdr
= &debug
->symbolic_header
;
762 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
764 /* The symbolic header contains absolute file offsets and sizes to
766 #define READ(ptr, offset, count, size, type) \
767 if (symhdr->count == 0) \
771 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
772 debug->ptr = bfd_malloc (amt); \
773 if (debug->ptr == NULL) \
775 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
776 || bfd_bread (debug->ptr, amt, abfd) != amt) \
780 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
781 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
782 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
783 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
784 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
785 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
787 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
788 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
789 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
790 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
791 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
801 if (debug
->line
!= NULL
)
803 if (debug
->external_dnr
!= NULL
)
804 free (debug
->external_dnr
);
805 if (debug
->external_pdr
!= NULL
)
806 free (debug
->external_pdr
);
807 if (debug
->external_sym
!= NULL
)
808 free (debug
->external_sym
);
809 if (debug
->external_opt
!= NULL
)
810 free (debug
->external_opt
);
811 if (debug
->external_aux
!= NULL
)
812 free (debug
->external_aux
);
813 if (debug
->ss
!= NULL
)
815 if (debug
->ssext
!= NULL
)
817 if (debug
->external_fdr
!= NULL
)
818 free (debug
->external_fdr
);
819 if (debug
->external_rfd
!= NULL
)
820 free (debug
->external_rfd
);
821 if (debug
->external_ext
!= NULL
)
822 free (debug
->external_ext
);
826 /* Swap RPDR (runtime procedure table entry) for output. */
829 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
831 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
832 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
833 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
834 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
835 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
836 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
838 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
839 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
841 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
844 /* Create a runtime procedure table from the .mdebug section. */
847 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
848 struct bfd_link_info
*info
, asection
*s
,
849 struct ecoff_debug_info
*debug
)
851 const struct ecoff_debug_swap
*swap
;
852 HDRR
*hdr
= &debug
->symbolic_header
;
854 struct rpdr_ext
*erp
;
856 struct pdr_ext
*epdr
;
857 struct sym_ext
*esym
;
862 unsigned long sindex
;
866 const char *no_name_func
= _("static procedure (no name)");
874 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
876 sindex
= strlen (no_name_func
) + 1;
880 size
= swap
->external_pdr_size
;
882 epdr
= bfd_malloc (size
* count
);
886 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
889 size
= sizeof (RPDR
);
890 rp
= rpdr
= bfd_malloc (size
* count
);
894 size
= sizeof (char *);
895 sv
= bfd_malloc (size
* count
);
899 count
= hdr
->isymMax
;
900 size
= swap
->external_sym_size
;
901 esym
= bfd_malloc (size
* count
);
905 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
909 ss
= bfd_malloc (count
);
912 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
916 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
918 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
919 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
921 rp
->regmask
= pdr
.regmask
;
922 rp
->regoffset
= pdr
.regoffset
;
923 rp
->fregmask
= pdr
.fregmask
;
924 rp
->fregoffset
= pdr
.fregoffset
;
925 rp
->frameoffset
= pdr
.frameoffset
;
926 rp
->framereg
= pdr
.framereg
;
927 rp
->pcreg
= pdr
.pcreg
;
929 sv
[i
] = ss
+ sym
.iss
;
930 sindex
+= strlen (sv
[i
]) + 1;
934 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
935 size
= BFD_ALIGN (size
, 16);
936 rtproc
= bfd_alloc (abfd
, size
);
939 mips_elf_hash_table (info
)->procedure_count
= 0;
943 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
946 memset (erp
, 0, sizeof (struct rpdr_ext
));
948 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
949 strcpy (str
, no_name_func
);
950 str
+= strlen (no_name_func
) + 1;
951 for (i
= 0; i
< count
; i
++)
953 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
955 str
+= strlen (sv
[i
]) + 1;
957 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
959 /* Set the size and contents of .rtproc section. */
961 s
->contents
= rtproc
;
963 /* Skip this section later on (I don't think this currently
964 matters, but someday it might). */
965 s
->link_order_head
= NULL
;
994 /* Check the mips16 stubs for a particular symbol, and see if we can
998 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
999 void *data ATTRIBUTE_UNUSED
)
1001 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1002 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1004 if (h
->fn_stub
!= NULL
1005 && ! h
->need_fn_stub
)
1007 /* We don't need the fn_stub; the only references to this symbol
1008 are 16 bit calls. Clobber the size to 0 to prevent it from
1009 being included in the link. */
1010 h
->fn_stub
->size
= 0;
1011 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1012 h
->fn_stub
->reloc_count
= 0;
1013 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1016 if (h
->call_stub
!= NULL
1017 && h
->root
.other
== STO_MIPS16
)
1019 /* We don't need the call_stub; this is a 16 bit function, so
1020 calls from other 16 bit functions are OK. Clobber the size
1021 to 0 to prevent it from being included in the link. */
1022 h
->call_stub
->size
= 0;
1023 h
->call_stub
->flags
&= ~SEC_RELOC
;
1024 h
->call_stub
->reloc_count
= 0;
1025 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1028 if (h
->call_fp_stub
!= NULL
1029 && h
->root
.other
== STO_MIPS16
)
1031 /* We don't need the call_stub; this is a 16 bit function, so
1032 calls from other 16 bit functions are OK. Clobber the size
1033 to 0 to prevent it from being included in the link. */
1034 h
->call_fp_stub
->size
= 0;
1035 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1036 h
->call_fp_stub
->reloc_count
= 0;
1037 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1043 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1044 Most mips16 instructions are 16 bits, but these instructions
1047 The format of these instructions is:
1049 +--------------+--------------------------------+
1050 | JALX | X| Imm 20:16 | Imm 25:21 |
1051 +--------------+--------------------------------+
1053 +-----------------------------------------------+
1055 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1056 Note that the immediate value in the first word is swapped.
1058 When producing a relocatable object file, R_MIPS16_26 is
1059 handled mostly like R_MIPS_26. In particular, the addend is
1060 stored as a straight 26-bit value in a 32-bit instruction.
1061 (gas makes life simpler for itself by never adjusting a
1062 R_MIPS16_26 reloc to be against a section, so the addend is
1063 always zero). However, the 32 bit instruction is stored as 2
1064 16-bit values, rather than a single 32-bit value. In a
1065 big-endian file, the result is the same; in a little-endian
1066 file, the two 16-bit halves of the 32 bit value are swapped.
1067 This is so that a disassembler can recognize the jal
1070 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1071 instruction stored as two 16-bit values. The addend A is the
1072 contents of the targ26 field. The calculation is the same as
1073 R_MIPS_26. When storing the calculated value, reorder the
1074 immediate value as shown above, and don't forget to store the
1075 value as two 16-bit values.
1077 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1081 +--------+----------------------+
1085 +--------+----------------------+
1088 +----------+------+-------------+
1092 +----------+--------------------+
1093 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1094 ((sub1 << 16) | sub2)).
1096 When producing a relocatable object file, the calculation is
1097 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1098 When producing a fully linked file, the calculation is
1099 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1100 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1102 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1103 mode. A typical instruction will have a format like this:
1105 +--------------+--------------------------------+
1106 | EXTEND | Imm 10:5 | Imm 15:11 |
1107 +--------------+--------------------------------+
1108 | Major | rx | ry | Imm 4:0 |
1109 +--------------+--------------------------------+
1111 EXTEND is the five bit value 11110. Major is the instruction
1114 This is handled exactly like R_MIPS_GPREL16, except that the
1115 addend is retrieved and stored as shown in this diagram; that
1116 is, the Imm fields above replace the V-rel16 field.
1118 All we need to do here is shuffle the bits appropriately. As
1119 above, the two 16-bit halves must be swapped on a
1120 little-endian system.
1122 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1123 access data when neither GP-relative nor PC-relative addressing
1124 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1125 except that the addend is retrieved and stored as shown above
1129 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1130 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1132 bfd_vma extend
, insn
, val
;
1134 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1135 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1138 /* Pick up the mips16 extend instruction and the real instruction. */
1139 extend
= bfd_get_16 (abfd
, data
);
1140 insn
= bfd_get_16 (abfd
, data
+ 2);
1141 if (r_type
== R_MIPS16_26
)
1144 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1145 | ((extend
& 0x1f) << 21) | insn
;
1147 val
= extend
<< 16 | insn
;
1150 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1151 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1152 bfd_put_32 (abfd
, val
, data
);
1156 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1157 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1159 bfd_vma extend
, insn
, val
;
1161 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1162 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1165 val
= bfd_get_32 (abfd
, data
);
1166 if (r_type
== R_MIPS16_26
)
1170 insn
= val
& 0xffff;
1171 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1172 | ((val
>> 21) & 0x1f);
1176 insn
= val
& 0xffff;
1182 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1183 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1185 bfd_put_16 (abfd
, insn
, data
+ 2);
1186 bfd_put_16 (abfd
, extend
, data
);
1189 bfd_reloc_status_type
1190 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1191 arelent
*reloc_entry
, asection
*input_section
,
1192 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1196 bfd_reloc_status_type status
;
1198 if (bfd_is_com_section (symbol
->section
))
1201 relocation
= symbol
->value
;
1203 relocation
+= symbol
->section
->output_section
->vma
;
1204 relocation
+= symbol
->section
->output_offset
;
1206 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1207 return bfd_reloc_outofrange
;
1209 /* Set val to the offset into the section or symbol. */
1210 val
= reloc_entry
->addend
;
1212 _bfd_mips_elf_sign_extend (val
, 16);
1214 /* Adjust val for the final section location and GP value. If we
1215 are producing relocatable output, we don't want to do this for
1216 an external symbol. */
1218 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1219 val
+= relocation
- gp
;
1221 if (reloc_entry
->howto
->partial_inplace
)
1223 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1225 + reloc_entry
->address
);
1226 if (status
!= bfd_reloc_ok
)
1230 reloc_entry
->addend
= val
;
1233 reloc_entry
->address
+= input_section
->output_offset
;
1235 return bfd_reloc_ok
;
1238 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1239 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1240 that contains the relocation field and DATA points to the start of
1245 struct mips_hi16
*next
;
1247 asection
*input_section
;
1251 /* FIXME: This should not be a static variable. */
1253 static struct mips_hi16
*mips_hi16_list
;
1255 /* A howto special_function for REL *HI16 relocations. We can only
1256 calculate the correct value once we've seen the partnering
1257 *LO16 relocation, so just save the information for later.
1259 The ABI requires that the *LO16 immediately follow the *HI16.
1260 However, as a GNU extension, we permit an arbitrary number of
1261 *HI16s to be associated with a single *LO16. This significantly
1262 simplies the relocation handling in gcc. */
1264 bfd_reloc_status_type
1265 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1266 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1267 asection
*input_section
, bfd
*output_bfd
,
1268 char **error_message ATTRIBUTE_UNUSED
)
1270 struct mips_hi16
*n
;
1272 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1273 return bfd_reloc_outofrange
;
1275 n
= bfd_malloc (sizeof *n
);
1277 return bfd_reloc_outofrange
;
1279 n
->next
= mips_hi16_list
;
1281 n
->input_section
= input_section
;
1282 n
->rel
= *reloc_entry
;
1285 if (output_bfd
!= NULL
)
1286 reloc_entry
->address
+= input_section
->output_offset
;
1288 return bfd_reloc_ok
;
1291 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1292 like any other 16-bit relocation when applied to global symbols, but is
1293 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1295 bfd_reloc_status_type
1296 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1297 void *data
, asection
*input_section
,
1298 bfd
*output_bfd
, char **error_message
)
1300 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1301 || bfd_is_und_section (bfd_get_section (symbol
))
1302 || bfd_is_com_section (bfd_get_section (symbol
)))
1303 /* The relocation is against a global symbol. */
1304 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1305 input_section
, output_bfd
,
1308 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1309 input_section
, output_bfd
, error_message
);
1312 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1313 is a straightforward 16 bit inplace relocation, but we must deal with
1314 any partnering high-part relocations as well. */
1316 bfd_reloc_status_type
1317 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1318 void *data
, asection
*input_section
,
1319 bfd
*output_bfd
, char **error_message
)
1322 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1324 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1325 return bfd_reloc_outofrange
;
1327 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1329 vallo
= bfd_get_32 (abfd
, location
);
1330 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1333 while (mips_hi16_list
!= NULL
)
1335 bfd_reloc_status_type ret
;
1336 struct mips_hi16
*hi
;
1338 hi
= mips_hi16_list
;
1340 /* R_MIPS_GOT16 relocations are something of a special case. We
1341 want to install the addend in the same way as for a R_MIPS_HI16
1342 relocation (with a rightshift of 16). However, since GOT16
1343 relocations can also be used with global symbols, their howto
1344 has a rightshift of 0. */
1345 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1346 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1348 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1349 carry or borrow will induce a change of +1 or -1 in the high part. */
1350 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1352 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1353 hi
->input_section
, output_bfd
,
1355 if (ret
!= bfd_reloc_ok
)
1358 mips_hi16_list
= hi
->next
;
1362 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1363 input_section
, output_bfd
,
1367 /* A generic howto special_function. This calculates and installs the
1368 relocation itself, thus avoiding the oft-discussed problems in
1369 bfd_perform_relocation and bfd_install_relocation. */
1371 bfd_reloc_status_type
1372 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1373 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1374 asection
*input_section
, bfd
*output_bfd
,
1375 char **error_message ATTRIBUTE_UNUSED
)
1378 bfd_reloc_status_type status
;
1379 bfd_boolean relocatable
;
1381 relocatable
= (output_bfd
!= NULL
);
1383 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1384 return bfd_reloc_outofrange
;
1386 /* Build up the field adjustment in VAL. */
1388 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1390 /* Either we're calculating the final field value or we have a
1391 relocation against a section symbol. Add in the section's
1392 offset or address. */
1393 val
+= symbol
->section
->output_section
->vma
;
1394 val
+= symbol
->section
->output_offset
;
1399 /* We're calculating the final field value. Add in the symbol's value
1400 and, if pc-relative, subtract the address of the field itself. */
1401 val
+= symbol
->value
;
1402 if (reloc_entry
->howto
->pc_relative
)
1404 val
-= input_section
->output_section
->vma
;
1405 val
-= input_section
->output_offset
;
1406 val
-= reloc_entry
->address
;
1410 /* VAL is now the final adjustment. If we're keeping this relocation
1411 in the output file, and if the relocation uses a separate addend,
1412 we just need to add VAL to that addend. Otherwise we need to add
1413 VAL to the relocation field itself. */
1414 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1415 reloc_entry
->addend
+= val
;
1418 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1420 /* Add in the separate addend, if any. */
1421 val
+= reloc_entry
->addend
;
1423 /* Add VAL to the relocation field. */
1424 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1426 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1428 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1431 if (status
!= bfd_reloc_ok
)
1436 reloc_entry
->address
+= input_section
->output_offset
;
1438 return bfd_reloc_ok
;
1441 /* Swap an entry in a .gptab section. Note that these routines rely
1442 on the equivalence of the two elements of the union. */
1445 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1448 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1449 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1453 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1454 Elf32_External_gptab
*ex
)
1456 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1457 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1461 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1462 Elf32_External_compact_rel
*ex
)
1464 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1465 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1466 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1467 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1468 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1469 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1473 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1474 Elf32_External_crinfo
*ex
)
1478 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1479 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1480 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1481 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1482 H_PUT_32 (abfd
, l
, ex
->info
);
1483 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1484 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1487 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1488 routines swap this structure in and out. They are used outside of
1489 BFD, so they are globally visible. */
1492 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1495 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1496 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1497 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1498 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1499 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1500 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1504 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1505 Elf32_External_RegInfo
*ex
)
1507 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1508 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1509 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1510 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1511 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1512 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1515 /* In the 64 bit ABI, the .MIPS.options section holds register
1516 information in an Elf64_Reginfo structure. These routines swap
1517 them in and out. They are globally visible because they are used
1518 outside of BFD. These routines are here so that gas can call them
1519 without worrying about whether the 64 bit ABI has been included. */
1522 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1523 Elf64_Internal_RegInfo
*in
)
1525 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1526 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1527 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1528 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1529 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1530 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1531 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1535 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1536 Elf64_External_RegInfo
*ex
)
1538 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1539 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1540 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1541 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1542 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1543 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1544 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1547 /* Swap in an options header. */
1550 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1551 Elf_Internal_Options
*in
)
1553 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1554 in
->size
= H_GET_8 (abfd
, ex
->size
);
1555 in
->section
= H_GET_16 (abfd
, ex
->section
);
1556 in
->info
= H_GET_32 (abfd
, ex
->info
);
1559 /* Swap out an options header. */
1562 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1563 Elf_External_Options
*ex
)
1565 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1566 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1567 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1568 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1571 /* This function is called via qsort() to sort the dynamic relocation
1572 entries by increasing r_symndx value. */
1575 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1577 Elf_Internal_Rela int_reloc1
;
1578 Elf_Internal_Rela int_reloc2
;
1580 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1581 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1583 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1586 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1589 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1590 const void *arg2 ATTRIBUTE_UNUSED
)
1593 Elf_Internal_Rela int_reloc1
[3];
1594 Elf_Internal_Rela int_reloc2
[3];
1596 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1597 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1598 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1599 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1601 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1602 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1609 /* This routine is used to write out ECOFF debugging external symbol
1610 information. It is called via mips_elf_link_hash_traverse. The
1611 ECOFF external symbol information must match the ELF external
1612 symbol information. Unfortunately, at this point we don't know
1613 whether a symbol is required by reloc information, so the two
1614 tables may wind up being different. We must sort out the external
1615 symbol information before we can set the final size of the .mdebug
1616 section, and we must set the size of the .mdebug section before we
1617 can relocate any sections, and we can't know which symbols are
1618 required by relocation until we relocate the sections.
1619 Fortunately, it is relatively unlikely that any symbol will be
1620 stripped but required by a reloc. In particular, it can not happen
1621 when generating a final executable. */
1624 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1626 struct extsym_info
*einfo
= data
;
1628 asection
*sec
, *output_section
;
1630 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1631 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1633 if (h
->root
.indx
== -2)
1635 else if ((h
->root
.def_dynamic
1636 || h
->root
.ref_dynamic
1637 || h
->root
.type
== bfd_link_hash_new
)
1638 && !h
->root
.def_regular
1639 && !h
->root
.ref_regular
)
1641 else if (einfo
->info
->strip
== strip_all
1642 || (einfo
->info
->strip
== strip_some
1643 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1644 h
->root
.root
.root
.string
,
1645 FALSE
, FALSE
) == NULL
))
1653 if (h
->esym
.ifd
== -2)
1656 h
->esym
.cobol_main
= 0;
1657 h
->esym
.weakext
= 0;
1658 h
->esym
.reserved
= 0;
1659 h
->esym
.ifd
= ifdNil
;
1660 h
->esym
.asym
.value
= 0;
1661 h
->esym
.asym
.st
= stGlobal
;
1663 if (h
->root
.root
.type
== bfd_link_hash_undefined
1664 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1668 /* Use undefined class. Also, set class and type for some
1670 name
= h
->root
.root
.root
.string
;
1671 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1672 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1674 h
->esym
.asym
.sc
= scData
;
1675 h
->esym
.asym
.st
= stLabel
;
1676 h
->esym
.asym
.value
= 0;
1678 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1680 h
->esym
.asym
.sc
= scAbs
;
1681 h
->esym
.asym
.st
= stLabel
;
1682 h
->esym
.asym
.value
=
1683 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1685 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1687 h
->esym
.asym
.sc
= scAbs
;
1688 h
->esym
.asym
.st
= stLabel
;
1689 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1692 h
->esym
.asym
.sc
= scUndefined
;
1694 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1695 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1696 h
->esym
.asym
.sc
= scAbs
;
1701 sec
= h
->root
.root
.u
.def
.section
;
1702 output_section
= sec
->output_section
;
1704 /* When making a shared library and symbol h is the one from
1705 the another shared library, OUTPUT_SECTION may be null. */
1706 if (output_section
== NULL
)
1707 h
->esym
.asym
.sc
= scUndefined
;
1710 name
= bfd_section_name (output_section
->owner
, output_section
);
1712 if (strcmp (name
, ".text") == 0)
1713 h
->esym
.asym
.sc
= scText
;
1714 else if (strcmp (name
, ".data") == 0)
1715 h
->esym
.asym
.sc
= scData
;
1716 else if (strcmp (name
, ".sdata") == 0)
1717 h
->esym
.asym
.sc
= scSData
;
1718 else if (strcmp (name
, ".rodata") == 0
1719 || strcmp (name
, ".rdata") == 0)
1720 h
->esym
.asym
.sc
= scRData
;
1721 else if (strcmp (name
, ".bss") == 0)
1722 h
->esym
.asym
.sc
= scBss
;
1723 else if (strcmp (name
, ".sbss") == 0)
1724 h
->esym
.asym
.sc
= scSBss
;
1725 else if (strcmp (name
, ".init") == 0)
1726 h
->esym
.asym
.sc
= scInit
;
1727 else if (strcmp (name
, ".fini") == 0)
1728 h
->esym
.asym
.sc
= scFini
;
1730 h
->esym
.asym
.sc
= scAbs
;
1734 h
->esym
.asym
.reserved
= 0;
1735 h
->esym
.asym
.index
= indexNil
;
1738 if (h
->root
.root
.type
== bfd_link_hash_common
)
1739 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1740 else if (h
->root
.root
.type
== bfd_link_hash_defined
1741 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1743 if (h
->esym
.asym
.sc
== scCommon
)
1744 h
->esym
.asym
.sc
= scBss
;
1745 else if (h
->esym
.asym
.sc
== scSCommon
)
1746 h
->esym
.asym
.sc
= scSBss
;
1748 sec
= h
->root
.root
.u
.def
.section
;
1749 output_section
= sec
->output_section
;
1750 if (output_section
!= NULL
)
1751 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1752 + sec
->output_offset
1753 + output_section
->vma
);
1755 h
->esym
.asym
.value
= 0;
1757 else if (h
->root
.needs_plt
)
1759 struct mips_elf_link_hash_entry
*hd
= h
;
1760 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1762 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1764 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1765 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1770 /* Set type and value for a symbol with a function stub. */
1771 h
->esym
.asym
.st
= stProc
;
1772 sec
= hd
->root
.root
.u
.def
.section
;
1774 h
->esym
.asym
.value
= 0;
1777 output_section
= sec
->output_section
;
1778 if (output_section
!= NULL
)
1779 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1780 + sec
->output_offset
1781 + output_section
->vma
);
1783 h
->esym
.asym
.value
= 0;
1788 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1789 h
->root
.root
.root
.string
,
1792 einfo
->failed
= TRUE
;
1799 /* A comparison routine used to sort .gptab entries. */
1802 gptab_compare (const void *p1
, const void *p2
)
1804 const Elf32_gptab
*a1
= p1
;
1805 const Elf32_gptab
*a2
= p2
;
1807 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1810 /* Functions to manage the got entry hash table. */
1812 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1815 static INLINE hashval_t
1816 mips_elf_hash_bfd_vma (bfd_vma addr
)
1819 return addr
+ (addr
>> 32);
1825 /* got_entries only match if they're identical, except for gotidx, so
1826 use all fields to compute the hash, and compare the appropriate
1830 mips_elf_got_entry_hash (const void *entry_
)
1832 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1834 return entry
->symndx
1835 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
1836 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1838 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1839 : entry
->d
.h
->root
.root
.root
.hash
));
1843 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1845 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1846 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1848 /* An LDM entry can only match another LDM entry. */
1849 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
1852 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1853 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1854 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1855 : e1
->d
.h
== e2
->d
.h
);
1858 /* multi_got_entries are still a match in the case of global objects,
1859 even if the input bfd in which they're referenced differs, so the
1860 hash computation and compare functions are adjusted
1864 mips_elf_multi_got_entry_hash (const void *entry_
)
1866 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1868 return entry
->symndx
1870 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1871 : entry
->symndx
>= 0
1872 ? ((entry
->tls_type
& GOT_TLS_LDM
)
1873 ? (GOT_TLS_LDM
<< 17)
1875 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
1876 : entry
->d
.h
->root
.root
.root
.hash
);
1880 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1882 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1883 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1885 /* Any two LDM entries match. */
1886 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
1889 /* Nothing else matches an LDM entry. */
1890 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
1893 return e1
->symndx
== e2
->symndx
1894 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1895 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1896 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1897 : e1
->d
.h
== e2
->d
.h
);
1900 /* Returns the dynamic relocation section for DYNOBJ. */
1903 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1905 static const char dname
[] = ".rel.dyn";
1908 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1909 if (sreloc
== NULL
&& create_p
)
1911 sreloc
= bfd_make_section (dynobj
, dname
);
1913 || ! bfd_set_section_flags (dynobj
, sreloc
,
1918 | SEC_LINKER_CREATED
1920 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1921 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1927 /* Returns the GOT section for ABFD. */
1930 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1932 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1934 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1939 /* Returns the GOT information associated with the link indicated by
1940 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1943 static struct mips_got_info
*
1944 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1947 struct mips_got_info
*g
;
1949 sgot
= mips_elf_got_section (abfd
, TRUE
);
1950 BFD_ASSERT (sgot
!= NULL
);
1951 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1952 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1953 BFD_ASSERT (g
!= NULL
);
1956 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1961 /* Count the number of relocations needed for a TLS GOT entry, with
1962 access types from TLS_TYPE, and symbol H (or a local symbol if H
1966 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
1967 struct elf_link_hash_entry
*h
)
1971 bfd_boolean need_relocs
= FALSE
;
1972 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1974 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1975 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
1978 if ((info
->shared
|| indx
!= 0)
1980 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1981 || h
->root
.type
!= bfd_link_hash_undefweak
))
1987 if (tls_type
& GOT_TLS_GD
)
1994 if (tls_type
& GOT_TLS_IE
)
1997 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2003 /* Count the number of TLS relocations required for the GOT entry in
2004 ARG1, if it describes a local symbol. */
2007 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2009 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2010 struct mips_elf_count_tls_arg
*arg
= arg2
;
2012 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2013 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2018 /* Count the number of TLS GOT entries required for the global (or
2019 forced-local) symbol in ARG1. */
2022 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2024 struct mips_elf_link_hash_entry
*hm
2025 = (struct mips_elf_link_hash_entry
*) arg1
;
2026 struct mips_elf_count_tls_arg
*arg
= arg2
;
2028 if (hm
->tls_type
& GOT_TLS_GD
)
2030 if (hm
->tls_type
& GOT_TLS_IE
)
2036 /* Count the number of TLS relocations required for the global (or
2037 forced-local) symbol in ARG1. */
2040 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2042 struct mips_elf_link_hash_entry
*hm
2043 = (struct mips_elf_link_hash_entry
*) arg1
;
2044 struct mips_elf_count_tls_arg
*arg
= arg2
;
2046 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2051 /* Output a simple dynamic relocation into SRELOC. */
2054 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2060 Elf_Internal_Rela rel
[3];
2062 memset (rel
, 0, sizeof (rel
));
2064 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2065 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2067 if (ABI_64_P (output_bfd
))
2069 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2070 (output_bfd
, &rel
[0],
2072 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
2075 bfd_elf32_swap_reloc_out
2076 (output_bfd
, &rel
[0],
2078 + sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
2079 ++sreloc
->reloc_count
;
2082 /* Initialize a set of TLS GOT entries for one symbol. */
2085 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2086 unsigned char *tls_type_p
,
2087 struct bfd_link_info
*info
,
2088 struct mips_elf_link_hash_entry
*h
,
2092 asection
*sreloc
, *sgot
;
2093 bfd_vma offset
, offset2
;
2095 bfd_boolean need_relocs
= FALSE
;
2097 dynobj
= elf_hash_table (info
)->dynobj
;
2098 sgot
= mips_elf_got_section (dynobj
, FALSE
);
2103 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2105 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2106 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2107 indx
= h
->root
.dynindx
;
2110 if (*tls_type_p
& GOT_TLS_DONE
)
2113 if ((info
->shared
|| indx
!= 0)
2115 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2116 || h
->root
.type
!= bfd_link_hash_undefweak
))
2119 /* MINUS_ONE means the symbol is not defined in this object. It may not
2120 be defined at all; assume that the value doesn't matter in that
2121 case. Otherwise complain if we would use the value. */
2122 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2123 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2125 /* Emit necessary relocations. */
2126 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
2128 /* General Dynamic. */
2129 if (*tls_type_p
& GOT_TLS_GD
)
2131 offset
= got_offset
;
2132 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2136 mips_elf_output_dynamic_relocation
2137 (abfd
, sreloc
, indx
,
2138 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2139 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2142 mips_elf_output_dynamic_relocation
2143 (abfd
, sreloc
, indx
,
2144 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2145 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2147 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2148 sgot
->contents
+ offset2
);
2152 MIPS_ELF_PUT_WORD (abfd
, 1,
2153 sgot
->contents
+ offset
);
2154 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2155 sgot
->contents
+ offset2
);
2158 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2161 /* Initial Exec model. */
2162 if (*tls_type_p
& GOT_TLS_IE
)
2164 offset
= got_offset
;
2169 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2170 sgot
->contents
+ offset
);
2172 MIPS_ELF_PUT_WORD (abfd
, 0,
2173 sgot
->contents
+ offset
);
2175 mips_elf_output_dynamic_relocation
2176 (abfd
, sreloc
, indx
,
2177 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2178 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2181 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2182 sgot
->contents
+ offset
);
2185 if (*tls_type_p
& GOT_TLS_LDM
)
2187 /* The initial offset is zero, and the LD offsets will include the
2188 bias by DTP_OFFSET. */
2189 MIPS_ELF_PUT_WORD (abfd
, 0,
2190 sgot
->contents
+ got_offset
2191 + MIPS_ELF_GOT_SIZE (abfd
));
2194 MIPS_ELF_PUT_WORD (abfd
, 1,
2195 sgot
->contents
+ got_offset
);
2197 mips_elf_output_dynamic_relocation
2198 (abfd
, sreloc
, indx
,
2199 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2200 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2203 *tls_type_p
|= GOT_TLS_DONE
;
2206 /* Return the GOT index to use for a relocation of type R_TYPE against
2207 a symbol accessed using TLS_TYPE models. The GOT entries for this
2208 symbol in this GOT start at GOT_INDEX. This function initializes the
2209 GOT entries and corresponding relocations. */
2212 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2213 int r_type
, struct bfd_link_info
*info
,
2214 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2216 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2217 || r_type
== R_MIPS_TLS_LDM
);
2219 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2221 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2223 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2224 if (*tls_type
& GOT_TLS_GD
)
2225 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
2230 if (r_type
== R_MIPS_TLS_GD
)
2232 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
2236 if (r_type
== R_MIPS_TLS_LDM
)
2238 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
2245 /* Returns the GOT offset at which the indicated address can be found.
2246 If there is not yet a GOT entry for this value, create one. If
2247 R_SYMNDX refers to a TLS symbol, create a TLS GOT entry instead.
2248 Returns -1 if no satisfactory GOT offset can be found. */
2251 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2252 bfd_vma value
, unsigned long r_symndx
,
2253 struct mips_elf_link_hash_entry
*h
, int r_type
)
2256 struct mips_got_info
*g
;
2257 struct mips_got_entry
*entry
;
2259 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2261 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
,
2262 r_symndx
, h
, r_type
);
2266 if (TLS_RELOC_P (r_type
))
2267 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
, r_type
,
2270 return entry
->gotidx
;
2273 /* Returns the GOT index for the global symbol indicated by H. */
2276 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
2277 int r_type
, struct bfd_link_info
*info
)
2281 struct mips_got_info
*g
, *gg
;
2282 long global_got_dynindx
= 0;
2284 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
2285 if (g
->bfd2got
&& ibfd
)
2287 struct mips_got_entry e
, *p
;
2289 BFD_ASSERT (h
->dynindx
>= 0);
2291 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2292 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
2296 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2299 p
= htab_find (g
->got_entries
, &e
);
2301 BFD_ASSERT (p
->gotidx
> 0);
2303 if (TLS_RELOC_P (r_type
))
2305 bfd_vma value
= MINUS_ONE
;
2306 if ((h
->root
.type
== bfd_link_hash_defined
2307 || h
->root
.type
== bfd_link_hash_defweak
)
2308 && h
->root
.u
.def
.section
->output_section
)
2309 value
= (h
->root
.u
.def
.value
2310 + h
->root
.u
.def
.section
->output_offset
2311 + h
->root
.u
.def
.section
->output_section
->vma
);
2313 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
2314 info
, e
.d
.h
, value
);
2321 if (gg
->global_gotsym
!= NULL
)
2322 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2324 if (TLS_RELOC_P (r_type
))
2326 struct mips_elf_link_hash_entry
*hm
2327 = (struct mips_elf_link_hash_entry
*) h
;
2328 bfd_vma value
= MINUS_ONE
;
2330 if ((h
->root
.type
== bfd_link_hash_defined
2331 || h
->root
.type
== bfd_link_hash_defweak
)
2332 && h
->root
.u
.def
.section
->output_section
)
2333 value
= (h
->root
.u
.def
.value
2334 + h
->root
.u
.def
.section
->output_offset
2335 + h
->root
.u
.def
.section
->output_section
->vma
);
2337 index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
2338 r_type
, info
, hm
, value
);
2342 /* Once we determine the global GOT entry with the lowest dynamic
2343 symbol table index, we must put all dynamic symbols with greater
2344 indices into the GOT. That makes it easy to calculate the GOT
2346 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2347 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2348 * MIPS_ELF_GOT_SIZE (abfd
));
2350 BFD_ASSERT (index
< sgot
->size
);
2355 /* Find a GOT entry that is within 32KB of the VALUE. These entries
2356 are supposed to be placed at small offsets in the GOT, i.e.,
2357 within 32KB of GP. Return the index into the GOT for this page,
2358 and store the offset from this entry to the desired address in
2359 OFFSETP, if it is non-NULL. */
2362 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2363 bfd_vma value
, bfd_vma
*offsetp
)
2366 struct mips_got_info
*g
;
2368 struct mips_got_entry
*entry
;
2370 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2372 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
2374 & (~(bfd_vma
)0xffff), 0,
2375 NULL
, R_MIPS_GOT_PAGE
);
2380 index
= entry
->gotidx
;
2383 *offsetp
= value
- entry
->d
.address
;
2388 /* Find a GOT entry whose higher-order 16 bits are the same as those
2389 for value. Return the index into the GOT for this entry. */
2392 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2393 bfd_vma value
, bfd_boolean external
)
2396 struct mips_got_info
*g
;
2397 struct mips_got_entry
*entry
;
2401 /* Although the ABI says that it is "the high-order 16 bits" that we
2402 want, it is really the %high value. The complete value is
2403 calculated with a `addiu' of a LO16 relocation, just as with a
2405 value
= mips_elf_high (value
) << 16;
2408 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2410 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
, 0, NULL
,
2413 return entry
->gotidx
;
2418 /* Returns the offset for the entry at the INDEXth position
2422 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
2423 bfd
*input_bfd
, bfd_vma index
)
2427 struct mips_got_info
*g
;
2429 g
= mips_elf_got_info (dynobj
, &sgot
);
2430 gp
= _bfd_get_gp_value (output_bfd
)
2431 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2433 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2436 /* Create a local GOT entry for VALUE. Return the index of the entry,
2437 or -1 if it could not be created. If R_SYMNDX refers to a TLS symbol,
2438 create a TLS entry instead. */
2440 static struct mips_got_entry
*
2441 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2442 struct mips_got_info
*gg
,
2443 asection
*sgot
, bfd_vma value
,
2444 unsigned long r_symndx
,
2445 struct mips_elf_link_hash_entry
*h
,
2448 struct mips_got_entry entry
, **loc
;
2449 struct mips_got_info
*g
;
2453 entry
.d
.address
= value
;
2456 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2459 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2460 BFD_ASSERT (g
!= NULL
);
2463 /* We might have a symbol, H, if it has been forced local. Use the
2464 global entry then. It doesn't matter whether an entry is local
2465 or global for TLS, since the dynamic linker does not
2466 automatically relocate TLS GOT entries. */
2467 BFD_ASSERT (h
== NULL
|| h
->root
.forced_local
);
2468 if (TLS_RELOC_P (r_type
))
2470 struct mips_got_entry
*p
;
2473 if (r_type
== R_MIPS_TLS_LDM
)
2475 entry
.tls_type
= GOT_TLS_LDM
;
2481 entry
.symndx
= r_symndx
;
2487 p
= (struct mips_got_entry
*)
2488 htab_find (g
->got_entries
, &entry
);
2494 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2499 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2502 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2507 memcpy (*loc
, &entry
, sizeof entry
);
2509 if (g
->assigned_gotno
>= g
->local_gotno
)
2511 (*loc
)->gotidx
= -1;
2512 /* We didn't allocate enough space in the GOT. */
2513 (*_bfd_error_handler
)
2514 (_("not enough GOT space for local GOT entries"));
2515 bfd_set_error (bfd_error_bad_value
);
2519 MIPS_ELF_PUT_WORD (abfd
, value
,
2520 (sgot
->contents
+ entry
.gotidx
));
2525 /* Sort the dynamic symbol table so that symbols that need GOT entries
2526 appear towards the end. This reduces the amount of GOT space
2527 required. MAX_LOCAL is used to set the number of local symbols
2528 known to be in the dynamic symbol table. During
2529 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2530 section symbols are added and the count is higher. */
2533 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2535 struct mips_elf_hash_sort_data hsd
;
2536 struct mips_got_info
*g
;
2539 dynobj
= elf_hash_table (info
)->dynobj
;
2541 g
= mips_elf_got_info (dynobj
, NULL
);
2544 hsd
.max_unref_got_dynindx
=
2545 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2546 /* In the multi-got case, assigned_gotno of the master got_info
2547 indicate the number of entries that aren't referenced in the
2548 primary GOT, but that must have entries because there are
2549 dynamic relocations that reference it. Since they aren't
2550 referenced, we move them to the end of the GOT, so that they
2551 don't prevent other entries that are referenced from getting
2552 too large offsets. */
2553 - (g
->next
? g
->assigned_gotno
: 0);
2554 hsd
.max_non_got_dynindx
= max_local
;
2555 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2556 elf_hash_table (info
)),
2557 mips_elf_sort_hash_table_f
,
2560 /* There should have been enough room in the symbol table to
2561 accommodate both the GOT and non-GOT symbols. */
2562 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2563 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2564 <= elf_hash_table (info
)->dynsymcount
);
2566 /* Now we know which dynamic symbol has the lowest dynamic symbol
2567 table index in the GOT. */
2568 g
->global_gotsym
= hsd
.low
;
2573 /* If H needs a GOT entry, assign it the highest available dynamic
2574 index. Otherwise, assign it the lowest available dynamic
2578 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2580 struct mips_elf_hash_sort_data
*hsd
= data
;
2582 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2583 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2585 /* Symbols without dynamic symbol table entries aren't interesting
2587 if (h
->root
.dynindx
== -1)
2590 /* Global symbols that need GOT entries that are not explicitly
2591 referenced are marked with got offset 2. Those that are
2592 referenced get a 1, and those that don't need GOT entries get
2594 if (h
->root
.got
.offset
== 2)
2596 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2598 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2599 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2600 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2602 else if (h
->root
.got
.offset
!= 1)
2603 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2606 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2608 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2609 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2615 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2616 symbol table index lower than any we've seen to date, record it for
2620 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2621 bfd
*abfd
, struct bfd_link_info
*info
,
2622 struct mips_got_info
*g
,
2623 unsigned char tls_flag
)
2625 struct mips_got_entry entry
, **loc
;
2627 /* A global symbol in the GOT must also be in the dynamic symbol
2629 if (h
->dynindx
== -1)
2631 switch (ELF_ST_VISIBILITY (h
->other
))
2635 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2638 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2644 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2647 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2650 /* If we've already marked this entry as needing GOT space, we don't
2651 need to do it again. */
2654 (*loc
)->tls_type
|= tls_flag
;
2658 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2664 entry
.tls_type
= tls_flag
;
2666 memcpy (*loc
, &entry
, sizeof entry
);
2668 if (h
->got
.offset
!= MINUS_ONE
)
2671 /* By setting this to a value other than -1, we are indicating that
2672 there needs to be a GOT entry for H. Avoid using zero, as the
2673 generic ELF copy_indirect_symbol tests for <= 0. */
2680 /* Reserve space in G for a GOT entry containing the value of symbol
2681 SYMNDX in input bfd ABDF, plus ADDEND. */
2684 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2685 struct mips_got_info
*g
,
2686 unsigned char tls_flag
)
2688 struct mips_got_entry entry
, **loc
;
2691 entry
.symndx
= symndx
;
2692 entry
.d
.addend
= addend
;
2693 entry
.tls_type
= tls_flag
;
2694 loc
= (struct mips_got_entry
**)
2695 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2699 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
2702 (*loc
)->tls_type
|= tls_flag
;
2704 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
2707 (*loc
)->tls_type
|= tls_flag
;
2715 entry
.tls_type
= tls_flag
;
2716 if (tls_flag
== GOT_TLS_IE
)
2718 else if (tls_flag
== GOT_TLS_GD
)
2720 else if (g
->tls_ldm_offset
== MINUS_ONE
)
2722 g
->tls_ldm_offset
= MINUS_TWO
;
2728 entry
.gotidx
= g
->local_gotno
++;
2732 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2737 memcpy (*loc
, &entry
, sizeof entry
);
2742 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2745 mips_elf_bfd2got_entry_hash (const void *entry_
)
2747 const struct mips_elf_bfd2got_hash
*entry
2748 = (struct mips_elf_bfd2got_hash
*)entry_
;
2750 return entry
->bfd
->id
;
2753 /* Check whether two hash entries have the same bfd. */
2756 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2758 const struct mips_elf_bfd2got_hash
*e1
2759 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2760 const struct mips_elf_bfd2got_hash
*e2
2761 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2763 return e1
->bfd
== e2
->bfd
;
2766 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2767 be the master GOT data. */
2769 static struct mips_got_info
*
2770 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2772 struct mips_elf_bfd2got_hash e
, *p
;
2778 p
= htab_find (g
->bfd2got
, &e
);
2779 return p
? p
->g
: NULL
;
2782 /* Create one separate got for each bfd that has entries in the global
2783 got, such that we can tell how many local and global entries each
2787 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2789 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2790 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2791 htab_t bfd2got
= arg
->bfd2got
;
2792 struct mips_got_info
*g
;
2793 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2796 /* Find the got_info for this GOT entry's input bfd. Create one if
2798 bfdgot_entry
.bfd
= entry
->abfd
;
2799 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2800 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2806 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2807 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2817 bfdgot
->bfd
= entry
->abfd
;
2818 bfdgot
->g
= g
= (struct mips_got_info
*)
2819 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2826 g
->global_gotsym
= NULL
;
2827 g
->global_gotno
= 0;
2829 g
->assigned_gotno
= -1;
2831 g
->tls_assigned_gotno
= 0;
2832 g
->tls_ldm_offset
= MINUS_ONE
;
2833 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2834 mips_elf_multi_got_entry_eq
, NULL
);
2835 if (g
->got_entries
== NULL
)
2845 /* Insert the GOT entry in the bfd's got entry hash table. */
2846 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2847 if (*entryp
!= NULL
)
2852 if (entry
->tls_type
)
2854 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
2856 if (entry
->tls_type
& GOT_TLS_IE
)
2859 else if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2867 /* Attempt to merge gots of different input bfds. Try to use as much
2868 as possible of the primary got, since it doesn't require explicit
2869 dynamic relocations, but don't use bfds that would reference global
2870 symbols out of the addressable range. Failing the primary got,
2871 attempt to merge with the current got, or finish the current got
2872 and then make make the new got current. */
2875 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2877 struct mips_elf_bfd2got_hash
*bfd2got
2878 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2879 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2880 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2881 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2882 unsigned int tcount
= bfd2got
->g
->tls_gotno
;
2883 unsigned int maxcnt
= arg
->max_count
;
2884 bfd_boolean too_many_for_tls
= FALSE
;
2886 /* We place TLS GOT entries after both locals and globals. The globals
2887 for the primary GOT may overflow the normal GOT size limit, so be
2888 sure not to merge a GOT which requires TLS with the primary GOT in that
2889 case. This doesn't affect non-primary GOTs. */
2892 unsigned int primary_total
= lcount
+ tcount
+ arg
->global_count
;
2893 if (primary_total
* MIPS_ELF_GOT_SIZE (bfd2got
->bfd
)
2894 >= MIPS_ELF_GOT_MAX_SIZE (bfd2got
->bfd
))
2895 too_many_for_tls
= TRUE
;
2898 /* If we don't have a primary GOT and this is not too big, use it as
2899 a starting point for the primary GOT. */
2900 if (! arg
->primary
&& lcount
+ gcount
+ tcount
<= maxcnt
2901 && ! too_many_for_tls
)
2903 arg
->primary
= bfd2got
->g
;
2904 arg
->primary_count
= lcount
+ gcount
;
2906 /* If it looks like we can merge this bfd's entries with those of
2907 the primary, merge them. The heuristics is conservative, but we
2908 don't have to squeeze it too hard. */
2909 else if (arg
->primary
&& ! too_many_for_tls
2910 && (arg
->primary_count
+ lcount
+ gcount
+ tcount
) <= maxcnt
)
2912 struct mips_got_info
*g
= bfd2got
->g
;
2913 int old_lcount
= arg
->primary
->local_gotno
;
2914 int old_gcount
= arg
->primary
->global_gotno
;
2915 int old_tcount
= arg
->primary
->tls_gotno
;
2917 bfd2got
->g
= arg
->primary
;
2919 htab_traverse (g
->got_entries
,
2920 mips_elf_make_got_per_bfd
,
2922 if (arg
->obfd
== NULL
)
2925 htab_delete (g
->got_entries
);
2926 /* We don't have to worry about releasing memory of the actual
2927 got entries, since they're all in the master got_entries hash
2930 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2931 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2932 BFD_ASSERT (old_tcount
+ tcount
>= arg
->primary
->tls_gotno
);
2934 arg
->primary_count
= arg
->primary
->local_gotno
2935 + arg
->primary
->global_gotno
+ arg
->primary
->tls_gotno
;
2937 /* If we can merge with the last-created got, do it. */
2938 else if (arg
->current
2939 && arg
->current_count
+ lcount
+ gcount
+ tcount
<= maxcnt
)
2941 struct mips_got_info
*g
= bfd2got
->g
;
2942 int old_lcount
= arg
->current
->local_gotno
;
2943 int old_gcount
= arg
->current
->global_gotno
;
2944 int old_tcount
= arg
->current
->tls_gotno
;
2946 bfd2got
->g
= arg
->current
;
2948 htab_traverse (g
->got_entries
,
2949 mips_elf_make_got_per_bfd
,
2951 if (arg
->obfd
== NULL
)
2954 htab_delete (g
->got_entries
);
2956 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2957 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2958 BFD_ASSERT (old_tcount
+ tcount
>= arg
->current
->tls_gotno
);
2960 arg
->current_count
= arg
->current
->local_gotno
2961 + arg
->current
->global_gotno
+ arg
->current
->tls_gotno
;
2963 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2964 fits; if it turns out that it doesn't, we'll get relocation
2965 overflows anyway. */
2968 bfd2got
->g
->next
= arg
->current
;
2969 arg
->current
= bfd2got
->g
;
2971 arg
->current_count
= lcount
+ gcount
+ 2 * tcount
;
2977 /* Set the TLS GOT index for the GOT entry in ENTRYP. */
2980 mips_elf_initialize_tls_index (void **entryp
, void *p
)
2982 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2983 struct mips_got_info
*g
= p
;
2985 /* We're only interested in TLS symbols. */
2986 if (entry
->tls_type
== 0)
2989 if (entry
->symndx
== -1)
2991 /* There may be multiple mips_got_entry structs for a global variable
2992 if there is just one GOT. Just do this once. */
2993 if (g
->next
== NULL
)
2995 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
2997 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
3000 else if (entry
->tls_type
& GOT_TLS_LDM
)
3002 /* Similarly, there may be multiple structs for the LDM entry. */
3003 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
3005 entry
->gotidx
= g
->tls_ldm_offset
;
3010 /* Initialize the GOT offset. */
3011 entry
->gotidx
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
3012 if (g
->next
== NULL
&& entry
->symndx
== -1)
3013 entry
->d
.h
->tls_got_offset
= entry
->gotidx
;
3015 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3016 g
->tls_assigned_gotno
+= 2;
3017 if (entry
->tls_type
& GOT_TLS_IE
)
3018 g
->tls_assigned_gotno
+= 1;
3020 if (entry
->tls_type
& GOT_TLS_LDM
)
3021 g
->tls_ldm_offset
= entry
->gotidx
;
3026 /* If passed a NULL mips_got_info in the argument, set the marker used
3027 to tell whether a global symbol needs a got entry (in the primary
3028 got) to the given VALUE.
3030 If passed a pointer G to a mips_got_info in the argument (it must
3031 not be the primary GOT), compute the offset from the beginning of
3032 the (primary) GOT section to the entry in G corresponding to the
3033 global symbol. G's assigned_gotno must contain the index of the
3034 first available global GOT entry in G. VALUE must contain the size
3035 of a GOT entry in bytes. For each global GOT entry that requires a
3036 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3037 marked as not eligible for lazy resolution through a function
3040 mips_elf_set_global_got_offset (void **entryp
, void *p
)
3042 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3043 struct mips_elf_set_global_got_offset_arg
*arg
3044 = (struct mips_elf_set_global_got_offset_arg
*)p
;
3045 struct mips_got_info
*g
= arg
->g
;
3047 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
3048 arg
->needed_relocs
+=
3049 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
3050 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
3052 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
3053 && entry
->d
.h
->root
.dynindx
!= -1
3054 && entry
->d
.h
->tls_type
== GOT_NORMAL
)
3058 BFD_ASSERT (g
->global_gotsym
== NULL
);
3060 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
3061 if (arg
->info
->shared
3062 || (elf_hash_table (arg
->info
)->dynamic_sections_created
3063 && entry
->d
.h
->root
.def_dynamic
3064 && !entry
->d
.h
->root
.def_regular
))
3065 ++arg
->needed_relocs
;
3068 entry
->d
.h
->root
.got
.offset
= arg
->value
;
3074 /* Mark any global symbols referenced in the GOT we are iterating over
3075 as inelligible for lazy resolution stubs. */
3077 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
3079 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3081 if (entry
->abfd
!= NULL
3082 && entry
->symndx
== -1
3083 && entry
->d
.h
->root
.dynindx
!= -1)
3084 entry
->d
.h
->no_fn_stub
= TRUE
;
3089 /* Follow indirect and warning hash entries so that each got entry
3090 points to the final symbol definition. P must point to a pointer
3091 to the hash table we're traversing. Since this traversal may
3092 modify the hash table, we set this pointer to NULL to indicate
3093 we've made a potentially-destructive change to the hash table, so
3094 the traversal must be restarted. */
3096 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
3098 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3099 htab_t got_entries
= *(htab_t
*)p
;
3101 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3103 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
3105 while (h
->root
.root
.type
== bfd_link_hash_indirect
3106 || h
->root
.root
.type
== bfd_link_hash_warning
)
3107 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3109 if (entry
->d
.h
== h
)
3114 /* If we can't find this entry with the new bfd hash, re-insert
3115 it, and get the traversal restarted. */
3116 if (! htab_find (got_entries
, entry
))
3118 htab_clear_slot (got_entries
, entryp
);
3119 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
3122 /* Abort the traversal, since the whole table may have
3123 moved, and leave it up to the parent to restart the
3125 *(htab_t
*)p
= NULL
;
3128 /* We might want to decrement the global_gotno count, but it's
3129 either too early or too late for that at this point. */
3135 /* Turn indirect got entries in a got_entries table into their final
3138 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3144 got_entries
= g
->got_entries
;
3146 htab_traverse (got_entries
,
3147 mips_elf_resolve_final_got_entry
,
3150 while (got_entries
== NULL
);
3153 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3156 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
3158 if (g
->bfd2got
== NULL
)
3161 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3165 BFD_ASSERT (g
->next
);
3169 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
3170 * MIPS_ELF_GOT_SIZE (abfd
);
3173 /* Turn a single GOT that is too big for 16-bit addressing into
3174 a sequence of GOTs, each one 16-bit addressable. */
3177 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
3178 struct mips_got_info
*g
, asection
*got
,
3179 bfd_size_type pages
)
3181 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
3182 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
3183 struct mips_got_info
*gg
;
3184 unsigned int assign
;
3186 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
3187 mips_elf_bfd2got_entry_eq
, NULL
);
3188 if (g
->bfd2got
== NULL
)
3191 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
3192 got_per_bfd_arg
.obfd
= abfd
;
3193 got_per_bfd_arg
.info
= info
;
3195 /* Count how many GOT entries each input bfd requires, creating a
3196 map from bfd to got info while at that. */
3197 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
3198 if (got_per_bfd_arg
.obfd
== NULL
)
3201 got_per_bfd_arg
.current
= NULL
;
3202 got_per_bfd_arg
.primary
= NULL
;
3203 /* Taking out PAGES entries is a worst-case estimate. We could
3204 compute the maximum number of pages that each separate input bfd
3205 uses, but it's probably not worth it. */
3206 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
3207 / MIPS_ELF_GOT_SIZE (abfd
))
3208 - MIPS_RESERVED_GOTNO
- pages
);
3209 /* The number of globals that will be included in the primary GOT.
3210 See the calls to mips_elf_set_global_got_offset below for more
3212 got_per_bfd_arg
.global_count
= g
->global_gotno
;
3214 /* Try to merge the GOTs of input bfds together, as long as they
3215 don't seem to exceed the maximum GOT size, choosing one of them
3216 to be the primary GOT. */
3217 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
3218 if (got_per_bfd_arg
.obfd
== NULL
)
3221 /* If we do not find any suitable primary GOT, create an empty one. */
3222 if (got_per_bfd_arg
.primary
== NULL
)
3224 g
->next
= (struct mips_got_info
*)
3225 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
3226 if (g
->next
== NULL
)
3229 g
->next
->global_gotsym
= NULL
;
3230 g
->next
->global_gotno
= 0;
3231 g
->next
->local_gotno
= 0;
3232 g
->next
->tls_gotno
= 0;
3233 g
->next
->assigned_gotno
= 0;
3234 g
->next
->tls_assigned_gotno
= 0;
3235 g
->next
->tls_ldm_offset
= MINUS_ONE
;
3236 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3237 mips_elf_multi_got_entry_eq
,
3239 if (g
->next
->got_entries
== NULL
)
3241 g
->next
->bfd2got
= NULL
;
3244 g
->next
= got_per_bfd_arg
.primary
;
3245 g
->next
->next
= got_per_bfd_arg
.current
;
3247 /* GG is now the master GOT, and G is the primary GOT. */
3251 /* Map the output bfd to the primary got. That's what we're going
3252 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3253 didn't mark in check_relocs, and we want a quick way to find it.
3254 We can't just use gg->next because we're going to reverse the
3257 struct mips_elf_bfd2got_hash
*bfdgot
;
3260 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3261 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
3268 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
3270 BFD_ASSERT (*bfdgotp
== NULL
);
3274 /* The IRIX dynamic linker requires every symbol that is referenced
3275 in a dynamic relocation to be present in the primary GOT, so
3276 arrange for them to appear after those that are actually
3279 GNU/Linux could very well do without it, but it would slow down
3280 the dynamic linker, since it would have to resolve every dynamic
3281 symbol referenced in other GOTs more than once, without help from
3282 the cache. Also, knowing that every external symbol has a GOT
3283 helps speed up the resolution of local symbols too, so GNU/Linux
3284 follows IRIX's practice.
3286 The number 2 is used by mips_elf_sort_hash_table_f to count
3287 global GOT symbols that are unreferenced in the primary GOT, with
3288 an initial dynamic index computed from gg->assigned_gotno, where
3289 the number of unreferenced global entries in the primary GOT is
3293 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
3294 g
->global_gotno
= gg
->global_gotno
;
3295 set_got_offset_arg
.value
= 2;
3299 /* This could be used for dynamic linkers that don't optimize
3300 symbol resolution while applying relocations so as to use
3301 primary GOT entries or assuming the symbol is locally-defined.
3302 With this code, we assign lower dynamic indices to global
3303 symbols that are not referenced in the primary GOT, so that
3304 their entries can be omitted. */
3305 gg
->assigned_gotno
= 0;
3306 set_got_offset_arg
.value
= -1;
3309 /* Reorder dynamic symbols as described above (which behavior
3310 depends on the setting of VALUE). */
3311 set_got_offset_arg
.g
= NULL
;
3312 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
3313 &set_got_offset_arg
);
3314 set_got_offset_arg
.value
= 1;
3315 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
3316 &set_got_offset_arg
);
3317 if (! mips_elf_sort_hash_table (info
, 1))
3320 /* Now go through the GOTs assigning them offset ranges.
3321 [assigned_gotno, local_gotno[ will be set to the range of local
3322 entries in each GOT. We can then compute the end of a GOT by
3323 adding local_gotno to global_gotno. We reverse the list and make
3324 it circular since then we'll be able to quickly compute the
3325 beginning of a GOT, by computing the end of its predecessor. To
3326 avoid special cases for the primary GOT, while still preserving
3327 assertions that are valid for both single- and multi-got links,
3328 we arrange for the main got struct to have the right number of
3329 global entries, but set its local_gotno such that the initial
3330 offset of the primary GOT is zero. Remember that the primary GOT
3331 will become the last item in the circular linked list, so it
3332 points back to the master GOT. */
3333 gg
->local_gotno
= -g
->global_gotno
;
3334 gg
->global_gotno
= g
->global_gotno
;
3341 struct mips_got_info
*gn
;
3343 assign
+= MIPS_RESERVED_GOTNO
;
3344 g
->assigned_gotno
= assign
;
3345 g
->local_gotno
+= assign
+ pages
;
3346 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
3348 /* Set up any TLS entries. We always place the TLS entries after
3349 all non-TLS entries. */
3350 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
3351 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
3353 /* Take g out of the direct list, and push it onto the reversed
3354 list that gg points to. */
3360 /* Mark global symbols in every non-primary GOT as ineligible for
3363 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
3367 got
->size
= (gg
->next
->local_gotno
3368 + gg
->next
->global_gotno
3369 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
3375 /* Returns the first relocation of type r_type found, beginning with
3376 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3378 static const Elf_Internal_Rela
*
3379 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
3380 const Elf_Internal_Rela
*relocation
,
3381 const Elf_Internal_Rela
*relend
)
3383 while (relocation
< relend
)
3385 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
3391 /* We didn't find it. */
3392 bfd_set_error (bfd_error_bad_value
);
3396 /* Return whether a relocation is against a local symbol. */
3399 mips_elf_local_relocation_p (bfd
*input_bfd
,
3400 const Elf_Internal_Rela
*relocation
,
3401 asection
**local_sections
,
3402 bfd_boolean check_forced
)
3404 unsigned long r_symndx
;
3405 Elf_Internal_Shdr
*symtab_hdr
;
3406 struct mips_elf_link_hash_entry
*h
;
3409 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3410 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3411 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
3413 if (r_symndx
< extsymoff
)
3415 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
3420 /* Look up the hash table to check whether the symbol
3421 was forced local. */
3422 h
= (struct mips_elf_link_hash_entry
*)
3423 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
3424 /* Find the real hash-table entry for this symbol. */
3425 while (h
->root
.root
.type
== bfd_link_hash_indirect
3426 || h
->root
.root
.type
== bfd_link_hash_warning
)
3427 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3428 if (h
->root
.forced_local
)
3435 /* Sign-extend VALUE, which has the indicated number of BITS. */
3438 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
3440 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
3441 /* VALUE is negative. */
3442 value
|= ((bfd_vma
) - 1) << bits
;
3447 /* Return non-zero if the indicated VALUE has overflowed the maximum
3448 range expressible by a signed number with the indicated number of
3452 mips_elf_overflow_p (bfd_vma value
, int bits
)
3454 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
3456 if (svalue
> (1 << (bits
- 1)) - 1)
3457 /* The value is too big. */
3459 else if (svalue
< -(1 << (bits
- 1)))
3460 /* The value is too small. */
3467 /* Calculate the %high function. */
3470 mips_elf_high (bfd_vma value
)
3472 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
3475 /* Calculate the %higher function. */
3478 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
3481 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
3488 /* Calculate the %highest function. */
3491 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
3494 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3501 /* Create the .compact_rel section. */
3504 mips_elf_create_compact_rel_section
3505 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3508 register asection
*s
;
3510 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
3512 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
3515 s
= bfd_make_section (abfd
, ".compact_rel");
3517 || ! bfd_set_section_flags (abfd
, s
, flags
)
3518 || ! bfd_set_section_alignment (abfd
, s
,
3519 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
3522 s
->size
= sizeof (Elf32_External_compact_rel
);
3528 /* Create the .got section to hold the global offset table. */
3531 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
3532 bfd_boolean maybe_exclude
)
3535 register asection
*s
;
3536 struct elf_link_hash_entry
*h
;
3537 struct bfd_link_hash_entry
*bh
;
3538 struct mips_got_info
*g
;
3541 /* This function may be called more than once. */
3542 s
= mips_elf_got_section (abfd
, TRUE
);
3545 if (! maybe_exclude
)
3546 s
->flags
&= ~SEC_EXCLUDE
;
3550 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3551 | SEC_LINKER_CREATED
);
3554 flags
|= SEC_EXCLUDE
;
3556 /* We have to use an alignment of 2**4 here because this is hardcoded
3557 in the function stub generation and in the linker script. */
3558 s
= bfd_make_section (abfd
, ".got");
3560 || ! bfd_set_section_flags (abfd
, s
, flags
)
3561 || ! bfd_set_section_alignment (abfd
, s
, 4))
3564 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3565 linker script because we don't want to define the symbol if we
3566 are not creating a global offset table. */
3568 if (! (_bfd_generic_link_add_one_symbol
3569 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
3570 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3573 h
= (struct elf_link_hash_entry
*) bh
;
3576 h
->type
= STT_OBJECT
;
3579 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3582 amt
= sizeof (struct mips_got_info
);
3583 g
= bfd_alloc (abfd
, amt
);
3586 g
->global_gotsym
= NULL
;
3587 g
->global_gotno
= 0;
3589 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
3590 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
3593 g
->tls_ldm_offset
= MINUS_ONE
;
3594 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3595 mips_elf_got_entry_eq
, NULL
);
3596 if (g
->got_entries
== NULL
)
3598 mips_elf_section_data (s
)->u
.got_info
= g
;
3599 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
3600 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3605 /* Calculate the value produced by the RELOCATION (which comes from
3606 the INPUT_BFD). The ADDEND is the addend to use for this
3607 RELOCATION; RELOCATION->R_ADDEND is ignored.
3609 The result of the relocation calculation is stored in VALUEP.
3610 REQUIRE_JALXP indicates whether or not the opcode used with this
3611 relocation must be JALX.
3613 This function returns bfd_reloc_continue if the caller need take no
3614 further action regarding this relocation, bfd_reloc_notsupported if
3615 something goes dramatically wrong, bfd_reloc_overflow if an
3616 overflow occurs, and bfd_reloc_ok to indicate success. */
3618 static bfd_reloc_status_type
3619 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3620 asection
*input_section
,
3621 struct bfd_link_info
*info
,
3622 const Elf_Internal_Rela
*relocation
,
3623 bfd_vma addend
, reloc_howto_type
*howto
,
3624 Elf_Internal_Sym
*local_syms
,
3625 asection
**local_sections
, bfd_vma
*valuep
,
3626 const char **namep
, bfd_boolean
*require_jalxp
,
3627 bfd_boolean save_addend
)
3629 /* The eventual value we will return. */
3631 /* The address of the symbol against which the relocation is
3634 /* The final GP value to be used for the relocatable, executable, or
3635 shared object file being produced. */
3636 bfd_vma gp
= MINUS_ONE
;
3637 /* The place (section offset or address) of the storage unit being
3640 /* The value of GP used to create the relocatable object. */
3641 bfd_vma gp0
= MINUS_ONE
;
3642 /* The offset into the global offset table at which the address of
3643 the relocation entry symbol, adjusted by the addend, resides
3644 during execution. */
3645 bfd_vma g
= MINUS_ONE
;
3646 /* The section in which the symbol referenced by the relocation is
3648 asection
*sec
= NULL
;
3649 struct mips_elf_link_hash_entry
*h
= NULL
;
3650 /* TRUE if the symbol referred to by this relocation is a local
3652 bfd_boolean local_p
, was_local_p
;
3653 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3654 bfd_boolean gp_disp_p
= FALSE
;
3655 /* TRUE if the symbol referred to by this relocation is
3656 "__gnu_local_gp". */
3657 bfd_boolean gnu_local_gp_p
= FALSE
;
3658 Elf_Internal_Shdr
*symtab_hdr
;
3660 unsigned long r_symndx
;
3662 /* TRUE if overflow occurred during the calculation of the
3663 relocation value. */
3664 bfd_boolean overflowed_p
;
3665 /* TRUE if this relocation refers to a MIPS16 function. */
3666 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3668 /* Parse the relocation. */
3669 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3670 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3671 p
= (input_section
->output_section
->vma
3672 + input_section
->output_offset
3673 + relocation
->r_offset
);
3675 /* Assume that there will be no overflow. */
3676 overflowed_p
= FALSE
;
3678 /* Figure out whether or not the symbol is local, and get the offset
3679 used in the array of hash table entries. */
3680 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3681 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3682 local_sections
, FALSE
);
3683 was_local_p
= local_p
;
3684 if (! elf_bad_symtab (input_bfd
))
3685 extsymoff
= symtab_hdr
->sh_info
;
3688 /* The symbol table does not follow the rule that local symbols
3689 must come before globals. */
3693 /* Figure out the value of the symbol. */
3696 Elf_Internal_Sym
*sym
;
3698 sym
= local_syms
+ r_symndx
;
3699 sec
= local_sections
[r_symndx
];
3701 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3702 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3703 || (sec
->flags
& SEC_MERGE
))
3704 symbol
+= sym
->st_value
;
3705 if ((sec
->flags
& SEC_MERGE
)
3706 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3708 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3710 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3713 /* MIPS16 text labels should be treated as odd. */
3714 if (sym
->st_other
== STO_MIPS16
)
3717 /* Record the name of this symbol, for our caller. */
3718 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3719 symtab_hdr
->sh_link
,
3722 *namep
= bfd_section_name (input_bfd
, sec
);
3724 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3728 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3730 /* For global symbols we look up the symbol in the hash-table. */
3731 h
= ((struct mips_elf_link_hash_entry
*)
3732 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3733 /* Find the real hash-table entry for this symbol. */
3734 while (h
->root
.root
.type
== bfd_link_hash_indirect
3735 || h
->root
.root
.type
== bfd_link_hash_warning
)
3736 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3738 /* Record the name of this symbol, for our caller. */
3739 *namep
= h
->root
.root
.root
.string
;
3741 /* See if this is the special _gp_disp symbol. Note that such a
3742 symbol must always be a global symbol. */
3743 if (strcmp (*namep
, "_gp_disp") == 0
3744 && ! NEWABI_P (input_bfd
))
3746 /* Relocations against _gp_disp are permitted only with
3747 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3748 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3749 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3750 return bfd_reloc_notsupported
;
3754 /* See if this is the special _gp symbol. Note that such a
3755 symbol must always be a global symbol. */
3756 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
3757 gnu_local_gp_p
= TRUE
;
3760 /* If this symbol is defined, calculate its address. Note that
3761 _gp_disp is a magic symbol, always implicitly defined by the
3762 linker, so it's inappropriate to check to see whether or not
3764 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3765 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3766 && h
->root
.root
.u
.def
.section
)
3768 sec
= h
->root
.root
.u
.def
.section
;
3769 if (sec
->output_section
)
3770 symbol
= (h
->root
.root
.u
.def
.value
3771 + sec
->output_section
->vma
3772 + sec
->output_offset
);
3774 symbol
= h
->root
.root
.u
.def
.value
;
3776 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3777 /* We allow relocations against undefined weak symbols, giving
3778 it the value zero, so that you can undefined weak functions
3779 and check to see if they exist by looking at their
3782 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3783 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3785 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
3786 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3788 /* If this is a dynamic link, we should have created a
3789 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3790 in in _bfd_mips_elf_create_dynamic_sections.
3791 Otherwise, we should define the symbol with a value of 0.
3792 FIXME: It should probably get into the symbol table
3794 BFD_ASSERT (! info
->shared
);
3795 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3800 if (! ((*info
->callbacks
->undefined_symbol
)
3801 (info
, h
->root
.root
.root
.string
, input_bfd
,
3802 input_section
, relocation
->r_offset
,
3803 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3804 || ELF_ST_VISIBILITY (h
->root
.other
))))
3805 return bfd_reloc_undefined
;
3809 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3812 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3813 need to redirect the call to the stub, unless we're already *in*
3815 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3816 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3817 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3818 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3819 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3821 /* This is a 32- or 64-bit call to a 16-bit function. We should
3822 have already noticed that we were going to need the
3825 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3828 BFD_ASSERT (h
->need_fn_stub
);
3832 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3834 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3835 need to redirect the call to the stub. */
3836 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3838 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3839 && !target_is_16_bit_code_p
)
3841 /* If both call_stub and call_fp_stub are defined, we can figure
3842 out which one to use by seeing which one appears in the input
3844 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3849 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3851 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3852 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3854 sec
= h
->call_fp_stub
;
3861 else if (h
->call_stub
!= NULL
)
3864 sec
= h
->call_fp_stub
;
3866 BFD_ASSERT (sec
->size
> 0);
3867 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3870 /* Calls from 16-bit code to 32-bit code and vice versa require the
3871 special jalx instruction. */
3872 *require_jalxp
= (!info
->relocatable
3873 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3874 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3876 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3877 local_sections
, TRUE
);
3879 /* If we haven't already determined the GOT offset, or the GP value,
3880 and we're going to need it, get it now. */
3883 case R_MIPS_GOT_PAGE
:
3884 case R_MIPS_GOT_OFST
:
3885 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3887 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3888 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3894 case R_MIPS_GOT_DISP
:
3895 case R_MIPS_GOT_HI16
:
3896 case R_MIPS_CALL_HI16
:
3897 case R_MIPS_GOT_LO16
:
3898 case R_MIPS_CALL_LO16
:
3900 case R_MIPS_TLS_GOTTPREL
:
3901 case R_MIPS_TLS_LDM
:
3902 /* Find the index into the GOT where this value is located. */
3903 if (r_type
== R_MIPS_TLS_LDM
)
3905 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
, 0, 0, NULL
,
3908 return bfd_reloc_outofrange
;
3912 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3913 GOT_PAGE relocation that decays to GOT_DISP because the
3914 symbol turns out to be global. The addend is then added
3916 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3917 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3919 (struct elf_link_hash_entry
*) h
,
3921 if (h
->tls_type
== GOT_NORMAL
3922 && (! elf_hash_table(info
)->dynamic_sections_created
3924 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3925 && h
->root
.def_regular
)))
3927 /* This is a static link or a -Bsymbolic link. The
3928 symbol is defined locally, or was forced to be local.
3929 We must initialize this entry in the GOT. */
3930 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3931 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3932 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3935 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3936 /* There's no need to create a local GOT entry here; the
3937 calculation for a local GOT16 entry does not involve G. */
3941 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3942 info
, symbol
+ addend
, r_symndx
, h
,
3945 return bfd_reloc_outofrange
;
3948 /* Convert GOT indices to actual offsets. */
3949 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3950 abfd
, input_bfd
, g
);
3955 case R_MIPS_GPREL16
:
3956 case R_MIPS_GPREL32
:
3957 case R_MIPS_LITERAL
:
3960 case R_MIPS16_GPREL
:
3961 gp0
= _bfd_get_gp_value (input_bfd
);
3962 gp
= _bfd_get_gp_value (abfd
);
3963 if (elf_hash_table (info
)->dynobj
)
3964 gp
+= mips_elf_adjust_gp (abfd
,
3966 (elf_hash_table (info
)->dynobj
, NULL
),
3977 /* Figure out what kind of relocation is being performed. */
3981 return bfd_reloc_continue
;
3984 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3985 overflowed_p
= mips_elf_overflow_p (value
, 16);
3992 || (elf_hash_table (info
)->dynamic_sections_created
3994 && h
->root
.def_dynamic
3995 && !h
->root
.def_regular
))
3997 && (input_section
->flags
& SEC_ALLOC
) != 0)
3999 /* If we're creating a shared library, or this relocation is
4000 against a symbol in a shared library, then we can't know
4001 where the symbol will end up. So, we create a relocation
4002 record in the output, and leave the job up to the dynamic
4005 if (!mips_elf_create_dynamic_relocation (abfd
,
4013 return bfd_reloc_undefined
;
4017 if (r_type
!= R_MIPS_REL32
)
4018 value
= symbol
+ addend
;
4022 value
&= howto
->dst_mask
;
4026 value
= symbol
+ addend
- p
;
4027 value
&= howto
->dst_mask
;
4030 case R_MIPS_GNU_REL16_S2
:
4031 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
4032 overflowed_p
= mips_elf_overflow_p (value
, 18);
4033 value
= (value
>> 2) & howto
->dst_mask
;
4037 /* The calculation for R_MIPS16_26 is just the same as for an
4038 R_MIPS_26. It's only the storage of the relocated field into
4039 the output file that's different. That's handled in
4040 mips_elf_perform_relocation. So, we just fall through to the
4041 R_MIPS_26 case here. */
4044 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
4047 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
4048 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
4049 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
4051 value
&= howto
->dst_mask
;
4054 case R_MIPS_TLS_DTPREL_HI16
:
4055 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
4059 case R_MIPS_TLS_DTPREL_LO16
:
4060 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
4063 case R_MIPS_TLS_TPREL_HI16
:
4064 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
4068 case R_MIPS_TLS_TPREL_LO16
:
4069 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
4076 value
= mips_elf_high (addend
+ symbol
);
4077 value
&= howto
->dst_mask
;
4081 /* For MIPS16 ABI code we generate this sequence
4082 0: li $v0,%hi(_gp_disp)
4083 4: addiupc $v1,%lo(_gp_disp)
4087 So the offsets of hi and lo relocs are the same, but the
4088 $pc is four higher than $t9 would be, so reduce
4089 both reloc addends by 4. */
4090 if (r_type
== R_MIPS16_HI16
)
4091 value
= mips_elf_high (addend
+ gp
- p
- 4);
4093 value
= mips_elf_high (addend
+ gp
- p
);
4094 overflowed_p
= mips_elf_overflow_p (value
, 16);
4101 value
= (symbol
+ addend
) & howto
->dst_mask
;
4104 /* See the comment for R_MIPS16_HI16 above for the reason
4105 for this conditional. */
4106 if (r_type
== R_MIPS16_LO16
)
4107 value
= addend
+ gp
- p
;
4109 value
= addend
+ gp
- p
+ 4;
4110 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4111 for overflow. But, on, say, IRIX5, relocations against
4112 _gp_disp are normally generated from the .cpload
4113 pseudo-op. It generates code that normally looks like
4116 lui $gp,%hi(_gp_disp)
4117 addiu $gp,$gp,%lo(_gp_disp)
4120 Here $t9 holds the address of the function being called,
4121 as required by the MIPS ELF ABI. The R_MIPS_LO16
4122 relocation can easily overflow in this situation, but the
4123 R_MIPS_HI16 relocation will handle the overflow.
4124 Therefore, we consider this a bug in the MIPS ABI, and do
4125 not check for overflow here. */
4129 case R_MIPS_LITERAL
:
4130 /* Because we don't merge literal sections, we can handle this
4131 just like R_MIPS_GPREL16. In the long run, we should merge
4132 shared literals, and then we will need to additional work
4137 case R_MIPS16_GPREL
:
4138 /* The R_MIPS16_GPREL performs the same calculation as
4139 R_MIPS_GPREL16, but stores the relocated bits in a different
4140 order. We don't need to do anything special here; the
4141 differences are handled in mips_elf_perform_relocation. */
4142 case R_MIPS_GPREL16
:
4143 /* Only sign-extend the addend if it was extracted from the
4144 instruction. If the addend was separate, leave it alone,
4145 otherwise we may lose significant bits. */
4146 if (howto
->partial_inplace
)
4147 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
4148 value
= symbol
+ addend
- gp
;
4149 /* If the symbol was local, any earlier relocatable links will
4150 have adjusted its addend with the gp offset, so compensate
4151 for that now. Don't do it for symbols forced local in this
4152 link, though, since they won't have had the gp offset applied
4156 overflowed_p
= mips_elf_overflow_p (value
, 16);
4165 /* The special case is when the symbol is forced to be local. We
4166 need the full address in the GOT since no R_MIPS_LO16 relocation
4168 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
4169 local_sections
, FALSE
);
4170 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
4171 symbol
+ addend
, forced
);
4172 if (value
== MINUS_ONE
)
4173 return bfd_reloc_outofrange
;
4175 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
4176 abfd
, input_bfd
, value
);
4177 overflowed_p
= mips_elf_overflow_p (value
, 16);
4184 case R_MIPS_TLS_GOTTPREL
:
4185 case R_MIPS_TLS_LDM
:
4186 case R_MIPS_GOT_DISP
:
4189 overflowed_p
= mips_elf_overflow_p (value
, 16);
4192 case R_MIPS_GPREL32
:
4193 value
= (addend
+ symbol
+ gp0
- gp
);
4195 value
&= howto
->dst_mask
;
4199 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
4200 overflowed_p
= mips_elf_overflow_p (value
, 16);
4203 case R_MIPS_GOT_HI16
:
4204 case R_MIPS_CALL_HI16
:
4205 /* We're allowed to handle these two relocations identically.
4206 The dynamic linker is allowed to handle the CALL relocations
4207 differently by creating a lazy evaluation stub. */
4209 value
= mips_elf_high (value
);
4210 value
&= howto
->dst_mask
;
4213 case R_MIPS_GOT_LO16
:
4214 case R_MIPS_CALL_LO16
:
4215 value
= g
& howto
->dst_mask
;
4218 case R_MIPS_GOT_PAGE
:
4219 /* GOT_PAGE relocations that reference non-local symbols decay
4220 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4224 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
4225 if (value
== MINUS_ONE
)
4226 return bfd_reloc_outofrange
;
4227 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
4228 abfd
, input_bfd
, value
);
4229 overflowed_p
= mips_elf_overflow_p (value
, 16);
4232 case R_MIPS_GOT_OFST
:
4234 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
4237 overflowed_p
= mips_elf_overflow_p (value
, 16);
4241 value
= symbol
- addend
;
4242 value
&= howto
->dst_mask
;
4246 value
= mips_elf_higher (addend
+ symbol
);
4247 value
&= howto
->dst_mask
;
4250 case R_MIPS_HIGHEST
:
4251 value
= mips_elf_highest (addend
+ symbol
);
4252 value
&= howto
->dst_mask
;
4255 case R_MIPS_SCN_DISP
:
4256 value
= symbol
+ addend
- sec
->output_offset
;
4257 value
&= howto
->dst_mask
;
4261 /* This relocation is only a hint. In some cases, we optimize
4262 it into a bal instruction. But we don't try to optimize
4263 branches to the PLT; that will wind up wasting time. */
4264 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
4265 return bfd_reloc_continue
;
4266 value
= symbol
+ addend
;
4270 case R_MIPS_GNU_VTINHERIT
:
4271 case R_MIPS_GNU_VTENTRY
:
4272 /* We don't do anything with these at present. */
4273 return bfd_reloc_continue
;
4276 /* An unrecognized relocation type. */
4277 return bfd_reloc_notsupported
;
4280 /* Store the VALUE for our caller. */
4282 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
4285 /* Obtain the field relocated by RELOCATION. */
4288 mips_elf_obtain_contents (reloc_howto_type
*howto
,
4289 const Elf_Internal_Rela
*relocation
,
4290 bfd
*input_bfd
, bfd_byte
*contents
)
4293 bfd_byte
*location
= contents
+ relocation
->r_offset
;
4295 /* Obtain the bytes. */
4296 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
4301 /* It has been determined that the result of the RELOCATION is the
4302 VALUE. Use HOWTO to place VALUE into the output file at the
4303 appropriate position. The SECTION is the section to which the
4304 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4305 for the relocation must be either JAL or JALX, and it is
4306 unconditionally converted to JALX.
4308 Returns FALSE if anything goes wrong. */
4311 mips_elf_perform_relocation (struct bfd_link_info
*info
,
4312 reloc_howto_type
*howto
,
4313 const Elf_Internal_Rela
*relocation
,
4314 bfd_vma value
, bfd
*input_bfd
,
4315 asection
*input_section
, bfd_byte
*contents
,
4316 bfd_boolean require_jalx
)
4320 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4322 /* Figure out where the relocation is occurring. */
4323 location
= contents
+ relocation
->r_offset
;
4325 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
4327 /* Obtain the current value. */
4328 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
4330 /* Clear the field we are setting. */
4331 x
&= ~howto
->dst_mask
;
4333 /* Set the field. */
4334 x
|= (value
& howto
->dst_mask
);
4336 /* If required, turn JAL into JALX. */
4340 bfd_vma opcode
= x
>> 26;
4341 bfd_vma jalx_opcode
;
4343 /* Check to see if the opcode is already JAL or JALX. */
4344 if (r_type
== R_MIPS16_26
)
4346 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
4351 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
4355 /* If the opcode is not JAL or JALX, there's a problem. */
4358 (*_bfd_error_handler
)
4359 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4362 (unsigned long) relocation
->r_offset
);
4363 bfd_set_error (bfd_error_bad_value
);
4367 /* Make this the JALX opcode. */
4368 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
4371 /* On the RM9000, bal is faster than jal, because bal uses branch
4372 prediction hardware. If we are linking for the RM9000, and we
4373 see jal, and bal fits, use it instead. Note that this
4374 transformation should be safe for all architectures. */
4375 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
4376 && !info
->relocatable
4378 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
4379 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
4385 addr
= (input_section
->output_section
->vma
4386 + input_section
->output_offset
4387 + relocation
->r_offset
4389 if (r_type
== R_MIPS_26
)
4390 dest
= (value
<< 2) | ((addr
>> 28) << 28);
4394 if (off
<= 0x1ffff && off
>= -0x20000)
4395 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
4398 /* Put the value into the output. */
4399 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
4401 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
4407 /* Returns TRUE if SECTION is a MIPS16 stub section. */
4410 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
4412 const char *name
= bfd_get_section_name (abfd
, section
);
4414 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
4415 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
4416 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
4419 /* Add room for N relocations to the .rel.dyn section in ABFD. */
4422 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
4426 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
4427 BFD_ASSERT (s
!= NULL
);
4431 /* Make room for a null element. */
4432 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4435 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4438 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
4439 is the original relocation, which is now being transformed into a
4440 dynamic relocation. The ADDENDP is adjusted if necessary; the
4441 caller should store the result in place of the original addend. */
4444 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
4445 struct bfd_link_info
*info
,
4446 const Elf_Internal_Rela
*rel
,
4447 struct mips_elf_link_hash_entry
*h
,
4448 asection
*sec
, bfd_vma symbol
,
4449 bfd_vma
*addendp
, asection
*input_section
)
4451 Elf_Internal_Rela outrel
[3];
4456 bfd_boolean defined_p
;
4458 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
4459 dynobj
= elf_hash_table (info
)->dynobj
;
4460 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
4461 BFD_ASSERT (sreloc
!= NULL
);
4462 BFD_ASSERT (sreloc
->contents
!= NULL
);
4463 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
4466 outrel
[0].r_offset
=
4467 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
4468 outrel
[1].r_offset
=
4469 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
4470 outrel
[2].r_offset
=
4471 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
4473 if (outrel
[0].r_offset
== MINUS_ONE
)
4474 /* The relocation field has been deleted. */
4477 if (outrel
[0].r_offset
== MINUS_TWO
)
4479 /* The relocation field has been converted into a relative value of
4480 some sort. Functions like _bfd_elf_write_section_eh_frame expect
4481 the field to be fully relocated, so add in the symbol's value. */
4486 /* We must now calculate the dynamic symbol table index to use
4487 in the relocation. */
4489 && (! info
->symbolic
|| !h
->root
.def_regular
)
4490 /* h->root.dynindx may be -1 if this symbol was marked to
4492 && h
->root
.dynindx
!= -1)
4494 indx
= h
->root
.dynindx
;
4495 if (SGI_COMPAT (output_bfd
))
4496 defined_p
= h
->root
.def_regular
;
4498 /* ??? glibc's ld.so just adds the final GOT entry to the
4499 relocation field. It therefore treats relocs against
4500 defined symbols in the same way as relocs against
4501 undefined symbols. */
4506 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
4508 else if (sec
== NULL
|| sec
->owner
== NULL
)
4510 bfd_set_error (bfd_error_bad_value
);
4515 indx
= elf_section_data (sec
->output_section
)->dynindx
;
4520 /* Instead of generating a relocation using the section
4521 symbol, we may as well make it a fully relative
4522 relocation. We want to avoid generating relocations to
4523 local symbols because we used to generate them
4524 incorrectly, without adding the original symbol value,
4525 which is mandated by the ABI for section symbols. In
4526 order to give dynamic loaders and applications time to
4527 phase out the incorrect use, we refrain from emitting
4528 section-relative relocations. It's not like they're
4529 useful, after all. This should be a bit more efficient
4531 /* ??? Although this behavior is compatible with glibc's ld.so,
4532 the ABI says that relocations against STN_UNDEF should have
4533 a symbol value of 0. Irix rld honors this, so relocations
4534 against STN_UNDEF have no effect. */
4535 if (!SGI_COMPAT (output_bfd
))
4540 /* If the relocation was previously an absolute relocation and
4541 this symbol will not be referred to by the relocation, we must
4542 adjust it by the value we give it in the dynamic symbol table.
4543 Otherwise leave the job up to the dynamic linker. */
4544 if (defined_p
&& r_type
!= R_MIPS_REL32
)
4547 /* The relocation is always an REL32 relocation because we don't
4548 know where the shared library will wind up at load-time. */
4549 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
4551 /* For strict adherence to the ABI specification, we should
4552 generate a R_MIPS_64 relocation record by itself before the
4553 _REL32/_64 record as well, such that the addend is read in as
4554 a 64-bit value (REL32 is a 32-bit relocation, after all).
4555 However, since none of the existing ELF64 MIPS dynamic
4556 loaders seems to care, we don't waste space with these
4557 artificial relocations. If this turns out to not be true,
4558 mips_elf_allocate_dynamic_relocation() should be tweaked so
4559 as to make room for a pair of dynamic relocations per
4560 invocation if ABI_64_P, and here we should generate an
4561 additional relocation record with R_MIPS_64 by itself for a
4562 NULL symbol before this relocation record. */
4563 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
4564 ABI_64_P (output_bfd
)
4567 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
4569 /* Adjust the output offset of the relocation to reference the
4570 correct location in the output file. */
4571 outrel
[0].r_offset
+= (input_section
->output_section
->vma
4572 + input_section
->output_offset
);
4573 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4574 + input_section
->output_offset
);
4575 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4576 + input_section
->output_offset
);
4578 /* Put the relocation back out. We have to use the special
4579 relocation outputter in the 64-bit case since the 64-bit
4580 relocation format is non-standard. */
4581 if (ABI_64_P (output_bfd
))
4583 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4584 (output_bfd
, &outrel
[0],
4586 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4589 bfd_elf32_swap_reloc_out
4590 (output_bfd
, &outrel
[0],
4591 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4593 /* We've now added another relocation. */
4594 ++sreloc
->reloc_count
;
4596 /* Make sure the output section is writable. The dynamic linker
4597 will be writing to it. */
4598 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4601 /* On IRIX5, make an entry of compact relocation info. */
4602 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
4604 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4609 Elf32_crinfo cptrel
;
4611 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4612 cptrel
.vaddr
= (rel
->r_offset
4613 + input_section
->output_section
->vma
4614 + input_section
->output_offset
);
4615 if (r_type
== R_MIPS_REL32
)
4616 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4618 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4619 mips_elf_set_cr_dist2to (cptrel
, 0);
4620 cptrel
.konst
= *addendp
;
4622 cr
= (scpt
->contents
4623 + sizeof (Elf32_External_compact_rel
));
4624 mips_elf_set_cr_relvaddr (cptrel
, 0);
4625 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4626 ((Elf32_External_crinfo
*) cr
4627 + scpt
->reloc_count
));
4628 ++scpt
->reloc_count
;
4635 /* Return the MACH for a MIPS e_flags value. */
4638 _bfd_elf_mips_mach (flagword flags
)
4640 switch (flags
& EF_MIPS_MACH
)
4642 case E_MIPS_MACH_3900
:
4643 return bfd_mach_mips3900
;
4645 case E_MIPS_MACH_4010
:
4646 return bfd_mach_mips4010
;
4648 case E_MIPS_MACH_4100
:
4649 return bfd_mach_mips4100
;
4651 case E_MIPS_MACH_4111
:
4652 return bfd_mach_mips4111
;
4654 case E_MIPS_MACH_4120
:
4655 return bfd_mach_mips4120
;
4657 case E_MIPS_MACH_4650
:
4658 return bfd_mach_mips4650
;
4660 case E_MIPS_MACH_5400
:
4661 return bfd_mach_mips5400
;
4663 case E_MIPS_MACH_5500
:
4664 return bfd_mach_mips5500
;
4666 case E_MIPS_MACH_9000
:
4667 return bfd_mach_mips9000
;
4669 case E_MIPS_MACH_SB1
:
4670 return bfd_mach_mips_sb1
;
4673 switch (flags
& EF_MIPS_ARCH
)
4677 return bfd_mach_mips3000
;
4681 return bfd_mach_mips6000
;
4685 return bfd_mach_mips4000
;
4689 return bfd_mach_mips8000
;
4693 return bfd_mach_mips5
;
4696 case E_MIPS_ARCH_32
:
4697 return bfd_mach_mipsisa32
;
4700 case E_MIPS_ARCH_64
:
4701 return bfd_mach_mipsisa64
;
4704 case E_MIPS_ARCH_32R2
:
4705 return bfd_mach_mipsisa32r2
;
4708 case E_MIPS_ARCH_64R2
:
4709 return bfd_mach_mipsisa64r2
;
4717 /* Return printable name for ABI. */
4719 static INLINE
char *
4720 elf_mips_abi_name (bfd
*abfd
)
4724 flags
= elf_elfheader (abfd
)->e_flags
;
4725 switch (flags
& EF_MIPS_ABI
)
4728 if (ABI_N32_P (abfd
))
4730 else if (ABI_64_P (abfd
))
4734 case E_MIPS_ABI_O32
:
4736 case E_MIPS_ABI_O64
:
4738 case E_MIPS_ABI_EABI32
:
4740 case E_MIPS_ABI_EABI64
:
4743 return "unknown abi";
4747 /* MIPS ELF uses two common sections. One is the usual one, and the
4748 other is for small objects. All the small objects are kept
4749 together, and then referenced via the gp pointer, which yields
4750 faster assembler code. This is what we use for the small common
4751 section. This approach is copied from ecoff.c. */
4752 static asection mips_elf_scom_section
;
4753 static asymbol mips_elf_scom_symbol
;
4754 static asymbol
*mips_elf_scom_symbol_ptr
;
4756 /* MIPS ELF also uses an acommon section, which represents an
4757 allocated common symbol which may be overridden by a
4758 definition in a shared library. */
4759 static asection mips_elf_acom_section
;
4760 static asymbol mips_elf_acom_symbol
;
4761 static asymbol
*mips_elf_acom_symbol_ptr
;
4763 /* Handle the special MIPS section numbers that a symbol may use.
4764 This is used for both the 32-bit and the 64-bit ABI. */
4767 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4769 elf_symbol_type
*elfsym
;
4771 elfsym
= (elf_symbol_type
*) asym
;
4772 switch (elfsym
->internal_elf_sym
.st_shndx
)
4774 case SHN_MIPS_ACOMMON
:
4775 /* This section is used in a dynamically linked executable file.
4776 It is an allocated common section. The dynamic linker can
4777 either resolve these symbols to something in a shared
4778 library, or it can just leave them here. For our purposes,
4779 we can consider these symbols to be in a new section. */
4780 if (mips_elf_acom_section
.name
== NULL
)
4782 /* Initialize the acommon section. */
4783 mips_elf_acom_section
.name
= ".acommon";
4784 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4785 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4786 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4787 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4788 mips_elf_acom_symbol
.name
= ".acommon";
4789 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4790 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4791 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4793 asym
->section
= &mips_elf_acom_section
;
4797 /* Common symbols less than the GP size are automatically
4798 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4799 if (asym
->value
> elf_gp_size (abfd
)
4800 || IRIX_COMPAT (abfd
) == ict_irix6
)
4803 case SHN_MIPS_SCOMMON
:
4804 if (mips_elf_scom_section
.name
== NULL
)
4806 /* Initialize the small common section. */
4807 mips_elf_scom_section
.name
= ".scommon";
4808 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4809 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4810 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4811 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4812 mips_elf_scom_symbol
.name
= ".scommon";
4813 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4814 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4815 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4817 asym
->section
= &mips_elf_scom_section
;
4818 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4821 case SHN_MIPS_SUNDEFINED
:
4822 asym
->section
= bfd_und_section_ptr
;
4827 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
4829 BFD_ASSERT (SGI_COMPAT (abfd
));
4830 if (section
!= NULL
)
4832 asym
->section
= section
;
4833 /* MIPS_TEXT is a bit special, the address is not an offset
4834 to the base of the .text section. So substract the section
4835 base address to make it an offset. */
4836 asym
->value
-= section
->vma
;
4843 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
4845 BFD_ASSERT (SGI_COMPAT (abfd
));
4846 if (section
!= NULL
)
4848 asym
->section
= section
;
4849 /* MIPS_DATA is a bit special, the address is not an offset
4850 to the base of the .data section. So substract the section
4851 base address to make it an offset. */
4852 asym
->value
-= section
->vma
;
4859 /* Implement elf_backend_eh_frame_address_size. This differs from
4860 the default in the way it handles EABI64.
4862 EABI64 was originally specified as an LP64 ABI, and that is what
4863 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4864 historically accepted the combination of -mabi=eabi and -mlong32,
4865 and this ILP32 variation has become semi-official over time.
4866 Both forms use elf32 and have pointer-sized FDE addresses.
4868 If an EABI object was generated by GCC 4.0 or above, it will have
4869 an empty .gcc_compiled_longXX section, where XX is the size of longs
4870 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4871 have no special marking to distinguish them from LP64 objects.
4873 We don't want users of the official LP64 ABI to be punished for the
4874 existence of the ILP32 variant, but at the same time, we don't want
4875 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4876 We therefore take the following approach:
4878 - If ABFD contains a .gcc_compiled_longXX section, use it to
4879 determine the pointer size.
4881 - Otherwise check the type of the first relocation. Assume that
4882 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4886 The second check is enough to detect LP64 objects generated by pre-4.0
4887 compilers because, in the kind of output generated by those compilers,
4888 the first relocation will be associated with either a CIE personality
4889 routine or an FDE start address. Furthermore, the compilers never
4890 used a special (non-pointer) encoding for this ABI.
4892 Checking the relocation type should also be safe because there is no
4893 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4897 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
4899 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
4901 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
4903 bfd_boolean long32_p
, long64_p
;
4905 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
4906 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
4907 if (long32_p
&& long64_p
)
4914 if (sec
->reloc_count
> 0
4915 && elf_section_data (sec
)->relocs
!= NULL
4916 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
4925 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4926 relocations against two unnamed section symbols to resolve to the
4927 same address. For example, if we have code like:
4929 lw $4,%got_disp(.data)($gp)
4930 lw $25,%got_disp(.text)($gp)
4933 then the linker will resolve both relocations to .data and the program
4934 will jump there rather than to .text.
4936 We can work around this problem by giving names to local section symbols.
4937 This is also what the MIPSpro tools do. */
4940 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4942 return SGI_COMPAT (abfd
);
4945 /* Work over a section just before writing it out. This routine is
4946 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4947 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4951 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4953 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4954 && hdr
->sh_size
> 0)
4958 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4959 BFD_ASSERT (hdr
->contents
== NULL
);
4962 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4965 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4966 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4970 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4971 && hdr
->bfd_section
!= NULL
4972 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4973 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4975 bfd_byte
*contents
, *l
, *lend
;
4977 /* We stored the section contents in the tdata field in the
4978 set_section_contents routine. We save the section contents
4979 so that we don't have to read them again.
4980 At this point we know that elf_gp is set, so we can look
4981 through the section contents to see if there is an
4982 ODK_REGINFO structure. */
4984 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4986 lend
= contents
+ hdr
->sh_size
;
4987 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4989 Elf_Internal_Options intopt
;
4991 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4993 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5000 + sizeof (Elf_External_Options
)
5001 + (sizeof (Elf64_External_RegInfo
) - 8)),
5004 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5005 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5008 else if (intopt
.kind
== ODK_REGINFO
)
5015 + sizeof (Elf_External_Options
)
5016 + (sizeof (Elf32_External_RegInfo
) - 4)),
5019 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5020 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5027 if (hdr
->bfd_section
!= NULL
)
5029 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5031 if (strcmp (name
, ".sdata") == 0
5032 || strcmp (name
, ".lit8") == 0
5033 || strcmp (name
, ".lit4") == 0)
5035 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5036 hdr
->sh_type
= SHT_PROGBITS
;
5038 else if (strcmp (name
, ".sbss") == 0)
5040 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5041 hdr
->sh_type
= SHT_NOBITS
;
5043 else if (strcmp (name
, ".srdata") == 0)
5045 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5046 hdr
->sh_type
= SHT_PROGBITS
;
5048 else if (strcmp (name
, ".compact_rel") == 0)
5051 hdr
->sh_type
= SHT_PROGBITS
;
5053 else if (strcmp (name
, ".rtproc") == 0)
5055 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5057 unsigned int adjust
;
5059 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5061 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5069 /* Handle a MIPS specific section when reading an object file. This
5070 is called when elfcode.h finds a section with an unknown type.
5071 This routine supports both the 32-bit and 64-bit ELF ABI.
5073 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5077 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5078 Elf_Internal_Shdr
*hdr
,
5084 /* There ought to be a place to keep ELF backend specific flags, but
5085 at the moment there isn't one. We just keep track of the
5086 sections by their name, instead. Fortunately, the ABI gives
5087 suggested names for all the MIPS specific sections, so we will
5088 probably get away with this. */
5089 switch (hdr
->sh_type
)
5091 case SHT_MIPS_LIBLIST
:
5092 if (strcmp (name
, ".liblist") != 0)
5096 if (strcmp (name
, ".msym") != 0)
5099 case SHT_MIPS_CONFLICT
:
5100 if (strcmp (name
, ".conflict") != 0)
5103 case SHT_MIPS_GPTAB
:
5104 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
5107 case SHT_MIPS_UCODE
:
5108 if (strcmp (name
, ".ucode") != 0)
5111 case SHT_MIPS_DEBUG
:
5112 if (strcmp (name
, ".mdebug") != 0)
5114 flags
= SEC_DEBUGGING
;
5116 case SHT_MIPS_REGINFO
:
5117 if (strcmp (name
, ".reginfo") != 0
5118 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5120 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5122 case SHT_MIPS_IFACE
:
5123 if (strcmp (name
, ".MIPS.interfaces") != 0)
5126 case SHT_MIPS_CONTENT
:
5127 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
5130 case SHT_MIPS_OPTIONS
:
5131 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5134 case SHT_MIPS_DWARF
:
5135 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
5138 case SHT_MIPS_SYMBOL_LIB
:
5139 if (strcmp (name
, ".MIPS.symlib") != 0)
5142 case SHT_MIPS_EVENTS
:
5143 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
5144 && strncmp (name
, ".MIPS.post_rel",
5145 sizeof ".MIPS.post_rel" - 1) != 0)
5152 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5157 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5158 (bfd_get_section_flags (abfd
,
5164 /* FIXME: We should record sh_info for a .gptab section. */
5166 /* For a .reginfo section, set the gp value in the tdata information
5167 from the contents of this section. We need the gp value while
5168 processing relocs, so we just get it now. The .reginfo section
5169 is not used in the 64-bit MIPS ELF ABI. */
5170 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5172 Elf32_External_RegInfo ext
;
5175 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5176 &ext
, 0, sizeof ext
))
5178 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5179 elf_gp (abfd
) = s
.ri_gp_value
;
5182 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5183 set the gp value based on what we find. We may see both
5184 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5185 they should agree. */
5186 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5188 bfd_byte
*contents
, *l
, *lend
;
5190 contents
= bfd_malloc (hdr
->sh_size
);
5191 if (contents
== NULL
)
5193 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5200 lend
= contents
+ hdr
->sh_size
;
5201 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5203 Elf_Internal_Options intopt
;
5205 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5207 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5209 Elf64_Internal_RegInfo intreg
;
5211 bfd_mips_elf64_swap_reginfo_in
5213 ((Elf64_External_RegInfo
*)
5214 (l
+ sizeof (Elf_External_Options
))),
5216 elf_gp (abfd
) = intreg
.ri_gp_value
;
5218 else if (intopt
.kind
== ODK_REGINFO
)
5220 Elf32_RegInfo intreg
;
5222 bfd_mips_elf32_swap_reginfo_in
5224 ((Elf32_External_RegInfo
*)
5225 (l
+ sizeof (Elf_External_Options
))),
5227 elf_gp (abfd
) = intreg
.ri_gp_value
;
5237 /* Set the correct type for a MIPS ELF section. We do this by the
5238 section name, which is a hack, but ought to work. This routine is
5239 used by both the 32-bit and the 64-bit ABI. */
5242 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5244 register const char *name
;
5246 name
= bfd_get_section_name (abfd
, sec
);
5248 if (strcmp (name
, ".liblist") == 0)
5250 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5251 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5252 /* The sh_link field is set in final_write_processing. */
5254 else if (strcmp (name
, ".conflict") == 0)
5255 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5256 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
5258 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5259 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5260 /* The sh_info field is set in final_write_processing. */
5262 else if (strcmp (name
, ".ucode") == 0)
5263 hdr
->sh_type
= SHT_MIPS_UCODE
;
5264 else if (strcmp (name
, ".mdebug") == 0)
5266 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5267 /* In a shared object on IRIX 5.3, the .mdebug section has an
5268 entsize of 0. FIXME: Does this matter? */
5269 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5270 hdr
->sh_entsize
= 0;
5272 hdr
->sh_entsize
= 1;
5274 else if (strcmp (name
, ".reginfo") == 0)
5276 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5277 /* In a shared object on IRIX 5.3, the .reginfo section has an
5278 entsize of 0x18. FIXME: Does this matter? */
5279 if (SGI_COMPAT (abfd
))
5281 if ((abfd
->flags
& DYNAMIC
) != 0)
5282 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5284 hdr
->sh_entsize
= 1;
5287 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5289 else if (SGI_COMPAT (abfd
)
5290 && (strcmp (name
, ".hash") == 0
5291 || strcmp (name
, ".dynamic") == 0
5292 || strcmp (name
, ".dynstr") == 0))
5294 if (SGI_COMPAT (abfd
))
5295 hdr
->sh_entsize
= 0;
5297 /* This isn't how the IRIX6 linker behaves. */
5298 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5301 else if (strcmp (name
, ".got") == 0
5302 || strcmp (name
, ".srdata") == 0
5303 || strcmp (name
, ".sdata") == 0
5304 || strcmp (name
, ".sbss") == 0
5305 || strcmp (name
, ".lit4") == 0
5306 || strcmp (name
, ".lit8") == 0)
5307 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
5308 else if (strcmp (name
, ".MIPS.interfaces") == 0)
5310 hdr
->sh_type
= SHT_MIPS_IFACE
;
5311 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5313 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
5315 hdr
->sh_type
= SHT_MIPS_CONTENT
;
5316 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5317 /* The sh_info field is set in final_write_processing. */
5319 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5321 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
5322 hdr
->sh_entsize
= 1;
5323 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5325 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
5326 hdr
->sh_type
= SHT_MIPS_DWARF
;
5327 else if (strcmp (name
, ".MIPS.symlib") == 0)
5329 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
5330 /* The sh_link and sh_info fields are set in
5331 final_write_processing. */
5333 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
5334 || strncmp (name
, ".MIPS.post_rel",
5335 sizeof ".MIPS.post_rel" - 1) == 0)
5337 hdr
->sh_type
= SHT_MIPS_EVENTS
;
5338 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5339 /* The sh_link field is set in final_write_processing. */
5341 else if (strcmp (name
, ".msym") == 0)
5343 hdr
->sh_type
= SHT_MIPS_MSYM
;
5344 hdr
->sh_flags
|= SHF_ALLOC
;
5345 hdr
->sh_entsize
= 8;
5348 /* The generic elf_fake_sections will set up REL_HDR using the default
5349 kind of relocations. We used to set up a second header for the
5350 non-default kind of relocations here, but only NewABI would use
5351 these, and the IRIX ld doesn't like resulting empty RELA sections.
5352 Thus we create those header only on demand now. */
5357 /* Given a BFD section, try to locate the corresponding ELF section
5358 index. This is used by both the 32-bit and the 64-bit ABI.
5359 Actually, it's not clear to me that the 64-bit ABI supports these,
5360 but for non-PIC objects we will certainly want support for at least
5361 the .scommon section. */
5364 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5365 asection
*sec
, int *retval
)
5367 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
5369 *retval
= SHN_MIPS_SCOMMON
;
5372 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
5374 *retval
= SHN_MIPS_ACOMMON
;
5380 /* Hook called by the linker routine which adds symbols from an object
5381 file. We must handle the special MIPS section numbers here. */
5384 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5385 Elf_Internal_Sym
*sym
, const char **namep
,
5386 flagword
*flagsp ATTRIBUTE_UNUSED
,
5387 asection
**secp
, bfd_vma
*valp
)
5389 if (SGI_COMPAT (abfd
)
5390 && (abfd
->flags
& DYNAMIC
) != 0
5391 && strcmp (*namep
, "_rld_new_interface") == 0)
5393 /* Skip IRIX5 rld entry name. */
5398 switch (sym
->st_shndx
)
5401 /* Common symbols less than the GP size are automatically
5402 treated as SHN_MIPS_SCOMMON symbols. */
5403 if (sym
->st_size
> elf_gp_size (abfd
)
5404 || IRIX_COMPAT (abfd
) == ict_irix6
)
5407 case SHN_MIPS_SCOMMON
:
5408 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
5409 (*secp
)->flags
|= SEC_IS_COMMON
;
5410 *valp
= sym
->st_size
;
5414 /* This section is used in a shared object. */
5415 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
5417 asymbol
*elf_text_symbol
;
5418 asection
*elf_text_section
;
5419 bfd_size_type amt
= sizeof (asection
);
5421 elf_text_section
= bfd_zalloc (abfd
, amt
);
5422 if (elf_text_section
== NULL
)
5425 amt
= sizeof (asymbol
);
5426 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
5427 if (elf_text_symbol
== NULL
)
5430 /* Initialize the section. */
5432 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
5433 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
5435 elf_text_section
->symbol
= elf_text_symbol
;
5436 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
5438 elf_text_section
->name
= ".text";
5439 elf_text_section
->flags
= SEC_NO_FLAGS
;
5440 elf_text_section
->output_section
= NULL
;
5441 elf_text_section
->owner
= abfd
;
5442 elf_text_symbol
->name
= ".text";
5443 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5444 elf_text_symbol
->section
= elf_text_section
;
5446 /* This code used to do *secp = bfd_und_section_ptr if
5447 info->shared. I don't know why, and that doesn't make sense,
5448 so I took it out. */
5449 *secp
= elf_tdata (abfd
)->elf_text_section
;
5452 case SHN_MIPS_ACOMMON
:
5453 /* Fall through. XXX Can we treat this as allocated data? */
5455 /* This section is used in a shared object. */
5456 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
5458 asymbol
*elf_data_symbol
;
5459 asection
*elf_data_section
;
5460 bfd_size_type amt
= sizeof (asection
);
5462 elf_data_section
= bfd_zalloc (abfd
, amt
);
5463 if (elf_data_section
== NULL
)
5466 amt
= sizeof (asymbol
);
5467 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
5468 if (elf_data_symbol
== NULL
)
5471 /* Initialize the section. */
5473 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
5474 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
5476 elf_data_section
->symbol
= elf_data_symbol
;
5477 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
5479 elf_data_section
->name
= ".data";
5480 elf_data_section
->flags
= SEC_NO_FLAGS
;
5481 elf_data_section
->output_section
= NULL
;
5482 elf_data_section
->owner
= abfd
;
5483 elf_data_symbol
->name
= ".data";
5484 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5485 elf_data_symbol
->section
= elf_data_section
;
5487 /* This code used to do *secp = bfd_und_section_ptr if
5488 info->shared. I don't know why, and that doesn't make sense,
5489 so I took it out. */
5490 *secp
= elf_tdata (abfd
)->elf_data_section
;
5493 case SHN_MIPS_SUNDEFINED
:
5494 *secp
= bfd_und_section_ptr
;
5498 if (SGI_COMPAT (abfd
)
5500 && info
->hash
->creator
== abfd
->xvec
5501 && strcmp (*namep
, "__rld_obj_head") == 0)
5503 struct elf_link_hash_entry
*h
;
5504 struct bfd_link_hash_entry
*bh
;
5506 /* Mark __rld_obj_head as dynamic. */
5508 if (! (_bfd_generic_link_add_one_symbol
5509 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
5510 get_elf_backend_data (abfd
)->collect
, &bh
)))
5513 h
= (struct elf_link_hash_entry
*) bh
;
5516 h
->type
= STT_OBJECT
;
5518 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5521 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
5524 /* If this is a mips16 text symbol, add 1 to the value to make it
5525 odd. This will cause something like .word SYM to come up with
5526 the right value when it is loaded into the PC. */
5527 if (sym
->st_other
== STO_MIPS16
)
5533 /* This hook function is called before the linker writes out a global
5534 symbol. We mark symbols as small common if appropriate. This is
5535 also where we undo the increment of the value for a mips16 symbol. */
5538 _bfd_mips_elf_link_output_symbol_hook
5539 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5540 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
5541 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
5543 /* If we see a common symbol, which implies a relocatable link, then
5544 if a symbol was small common in an input file, mark it as small
5545 common in the output file. */
5546 if (sym
->st_shndx
== SHN_COMMON
5547 && strcmp (input_sec
->name
, ".scommon") == 0)
5548 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
5550 if (sym
->st_other
== STO_MIPS16
)
5551 sym
->st_value
&= ~1;
5556 /* Functions for the dynamic linker. */
5558 /* Create dynamic sections when linking against a dynamic object. */
5561 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5563 struct elf_link_hash_entry
*h
;
5564 struct bfd_link_hash_entry
*bh
;
5566 register asection
*s
;
5567 const char * const *namep
;
5569 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5570 | SEC_LINKER_CREATED
| SEC_READONLY
);
5572 /* Mips ABI requests the .dynamic section to be read only. */
5573 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5576 if (! bfd_set_section_flags (abfd
, s
, flags
))
5580 /* We need to create .got section. */
5581 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
5584 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
5587 /* Create .stub section. */
5588 if (bfd_get_section_by_name (abfd
,
5589 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
5591 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
5593 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
5594 || ! bfd_set_section_alignment (abfd
, s
,
5595 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5599 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
5601 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
5603 s
= bfd_make_section (abfd
, ".rld_map");
5605 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
5606 || ! bfd_set_section_alignment (abfd
, s
,
5607 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5611 /* On IRIX5, we adjust add some additional symbols and change the
5612 alignments of several sections. There is no ABI documentation
5613 indicating that this is necessary on IRIX6, nor any evidence that
5614 the linker takes such action. */
5615 if (IRIX_COMPAT (abfd
) == ict_irix5
)
5617 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
5620 if (! (_bfd_generic_link_add_one_symbol
5621 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
5622 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5625 h
= (struct elf_link_hash_entry
*) bh
;
5628 h
->type
= STT_SECTION
;
5630 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5634 /* We need to create a .compact_rel section. */
5635 if (SGI_COMPAT (abfd
))
5637 if (!mips_elf_create_compact_rel_section (abfd
, info
))
5641 /* Change alignments of some sections. */
5642 s
= bfd_get_section_by_name (abfd
, ".hash");
5644 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5645 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5647 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5648 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5650 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5651 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5653 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5654 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5656 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5663 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5665 if (!(_bfd_generic_link_add_one_symbol
5666 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5667 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5670 h
= (struct elf_link_hash_entry
*) bh
;
5673 h
->type
= STT_SECTION
;
5675 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5678 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5680 /* __rld_map is a four byte word located in the .data section
5681 and is filled in by the rtld to contain a pointer to
5682 the _r_debug structure. Its symbol value will be set in
5683 _bfd_mips_elf_finish_dynamic_symbol. */
5684 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5685 BFD_ASSERT (s
!= NULL
);
5687 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5689 if (!(_bfd_generic_link_add_one_symbol
5690 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5691 get_elf_backend_data (abfd
)->collect
, &bh
)))
5694 h
= (struct elf_link_hash_entry
*) bh
;
5697 h
->type
= STT_OBJECT
;
5699 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5707 /* Look through the relocs for a section during the first phase, and
5708 allocate space in the global offset table. */
5711 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5712 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5716 Elf_Internal_Shdr
*symtab_hdr
;
5717 struct elf_link_hash_entry
**sym_hashes
;
5718 struct mips_got_info
*g
;
5720 const Elf_Internal_Rela
*rel
;
5721 const Elf_Internal_Rela
*rel_end
;
5724 const struct elf_backend_data
*bed
;
5726 if (info
->relocatable
)
5729 dynobj
= elf_hash_table (info
)->dynobj
;
5730 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5731 sym_hashes
= elf_sym_hashes (abfd
);
5732 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5734 /* Check for the mips16 stub sections. */
5736 name
= bfd_get_section_name (abfd
, sec
);
5737 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5739 unsigned long r_symndx
;
5741 /* Look at the relocation information to figure out which symbol
5744 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5746 if (r_symndx
< extsymoff
5747 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5751 /* This stub is for a local symbol. This stub will only be
5752 needed if there is some relocation in this BFD, other
5753 than a 16 bit function call, which refers to this symbol. */
5754 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5756 Elf_Internal_Rela
*sec_relocs
;
5757 const Elf_Internal_Rela
*r
, *rend
;
5759 /* We can ignore stub sections when looking for relocs. */
5760 if ((o
->flags
& SEC_RELOC
) == 0
5761 || o
->reloc_count
== 0
5762 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5763 sizeof FN_STUB
- 1) == 0
5764 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5765 sizeof CALL_STUB
- 1) == 0
5766 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5767 sizeof CALL_FP_STUB
- 1) == 0)
5771 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5773 if (sec_relocs
== NULL
)
5776 rend
= sec_relocs
+ o
->reloc_count
;
5777 for (r
= sec_relocs
; r
< rend
; r
++)
5778 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5779 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5782 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5791 /* There is no non-call reloc for this stub, so we do
5792 not need it. Since this function is called before
5793 the linker maps input sections to output sections, we
5794 can easily discard it by setting the SEC_EXCLUDE
5796 sec
->flags
|= SEC_EXCLUDE
;
5800 /* Record this stub in an array of local symbol stubs for
5802 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5804 unsigned long symcount
;
5808 if (elf_bad_symtab (abfd
))
5809 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5811 symcount
= symtab_hdr
->sh_info
;
5812 amt
= symcount
* sizeof (asection
*);
5813 n
= bfd_zalloc (abfd
, amt
);
5816 elf_tdata (abfd
)->local_stubs
= n
;
5819 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5821 /* We don't need to set mips16_stubs_seen in this case.
5822 That flag is used to see whether we need to look through
5823 the global symbol table for stubs. We don't need to set
5824 it here, because we just have a local stub. */
5828 struct mips_elf_link_hash_entry
*h
;
5830 h
= ((struct mips_elf_link_hash_entry
*)
5831 sym_hashes
[r_symndx
- extsymoff
]);
5833 /* H is the symbol this stub is for. */
5836 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5839 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5840 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5842 unsigned long r_symndx
;
5843 struct mips_elf_link_hash_entry
*h
;
5846 /* Look at the relocation information to figure out which symbol
5849 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5851 if (r_symndx
< extsymoff
5852 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5854 /* This stub was actually built for a static symbol defined
5855 in the same file. We assume that all static symbols in
5856 mips16 code are themselves mips16, so we can simply
5857 discard this stub. Since this function is called before
5858 the linker maps input sections to output sections, we can
5859 easily discard it by setting the SEC_EXCLUDE flag. */
5860 sec
->flags
|= SEC_EXCLUDE
;
5864 h
= ((struct mips_elf_link_hash_entry
*)
5865 sym_hashes
[r_symndx
- extsymoff
]);
5867 /* H is the symbol this stub is for. */
5869 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5870 loc
= &h
->call_fp_stub
;
5872 loc
= &h
->call_stub
;
5874 /* If we already have an appropriate stub for this function, we
5875 don't need another one, so we can discard this one. Since
5876 this function is called before the linker maps input sections
5877 to output sections, we can easily discard it by setting the
5878 SEC_EXCLUDE flag. We can also discard this section if we
5879 happen to already know that this is a mips16 function; it is
5880 not necessary to check this here, as it is checked later, but
5881 it is slightly faster to check now. */
5882 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5884 sec
->flags
|= SEC_EXCLUDE
;
5889 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5899 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5904 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5905 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5906 BFD_ASSERT (g
!= NULL
);
5911 bed
= get_elf_backend_data (abfd
);
5912 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5913 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5915 unsigned long r_symndx
;
5916 unsigned int r_type
;
5917 struct elf_link_hash_entry
*h
;
5919 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5920 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5922 if (r_symndx
< extsymoff
)
5924 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5926 (*_bfd_error_handler
)
5927 (_("%B: Malformed reloc detected for section %s"),
5929 bfd_set_error (bfd_error_bad_value
);
5934 h
= sym_hashes
[r_symndx
- extsymoff
];
5936 /* This may be an indirect symbol created because of a version. */
5939 while (h
->root
.type
== bfd_link_hash_indirect
)
5940 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5944 /* Some relocs require a global offset table. */
5945 if (dynobj
== NULL
|| sgot
== NULL
)
5951 case R_MIPS_CALL_HI16
:
5952 case R_MIPS_CALL_LO16
:
5953 case R_MIPS_GOT_HI16
:
5954 case R_MIPS_GOT_LO16
:
5955 case R_MIPS_GOT_PAGE
:
5956 case R_MIPS_GOT_OFST
:
5957 case R_MIPS_GOT_DISP
:
5959 case R_MIPS_TLS_LDM
:
5961 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5962 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5964 g
= mips_elf_got_info (dynobj
, &sgot
);
5971 && (info
->shared
|| h
!= NULL
)
5972 && (sec
->flags
& SEC_ALLOC
) != 0)
5973 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5981 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5982 || r_type
== R_MIPS_GOT_LO16
5983 || r_type
== R_MIPS_GOT_DISP
))
5985 /* We may need a local GOT entry for this relocation. We
5986 don't count R_MIPS_GOT_PAGE because we can estimate the
5987 maximum number of pages needed by looking at the size of
5988 the segment. Similar comments apply to R_MIPS_GOT16 and
5989 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5990 R_MIPS_CALL_HI16 because these are always followed by an
5991 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5992 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5993 rel
->r_addend
, g
, 0))
6002 (*_bfd_error_handler
)
6003 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6004 abfd
, (unsigned long) rel
->r_offset
);
6005 bfd_set_error (bfd_error_bad_value
);
6010 case R_MIPS_CALL_HI16
:
6011 case R_MIPS_CALL_LO16
:
6014 /* This symbol requires a global offset table entry. */
6015 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6018 /* We need a stub, not a plt entry for the undefined
6019 function. But we record it as if it needs plt. See
6020 _bfd_elf_adjust_dynamic_symbol. */
6026 case R_MIPS_GOT_PAGE
:
6027 /* If this is a global, overridable symbol, GOT_PAGE will
6028 decay to GOT_DISP, so we'll need a GOT entry for it. */
6033 struct mips_elf_link_hash_entry
*hmips
=
6034 (struct mips_elf_link_hash_entry
*) h
;
6036 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
6037 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
6038 hmips
= (struct mips_elf_link_hash_entry
*)
6039 hmips
->root
.root
.u
.i
.link
;
6041 if (hmips
->root
.def_regular
6042 && ! (info
->shared
&& ! info
->symbolic
6043 && ! hmips
->root
.forced_local
))
6049 case R_MIPS_GOT_HI16
:
6050 case R_MIPS_GOT_LO16
:
6051 case R_MIPS_GOT_DISP
:
6052 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6056 case R_MIPS_TLS_GOTTPREL
:
6058 info
->flags
|= DF_STATIC_TLS
;
6061 case R_MIPS_TLS_LDM
:
6062 if (r_type
== R_MIPS_TLS_LDM
)
6070 /* This symbol requires a global offset table entry, or two
6071 for TLS GD relocations. */
6073 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
6075 : r_type
== R_MIPS_TLS_LDM
6080 struct mips_elf_link_hash_entry
*hmips
=
6081 (struct mips_elf_link_hash_entry
*) h
;
6082 hmips
->tls_type
|= flag
;
6084 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, flag
))
6089 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
6091 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6092 rel
->r_addend
, g
, flag
))
6101 if ((info
->shared
|| h
!= NULL
)
6102 && (sec
->flags
& SEC_ALLOC
) != 0)
6106 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
6110 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
6113 /* When creating a shared object, we must copy these
6114 reloc types into the output file as R_MIPS_REL32
6115 relocs. We make room for this reloc in the
6116 .rel.dyn reloc section. */
6117 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
6118 if ((sec
->flags
& MIPS_READONLY_SECTION
)
6119 == MIPS_READONLY_SECTION
)
6120 /* We tell the dynamic linker that there are
6121 relocations against the text segment. */
6122 info
->flags
|= DF_TEXTREL
;
6126 struct mips_elf_link_hash_entry
*hmips
;
6128 /* We only need to copy this reloc if the symbol is
6129 defined in a dynamic object. */
6130 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6131 ++hmips
->possibly_dynamic_relocs
;
6132 if ((sec
->flags
& MIPS_READONLY_SECTION
)
6133 == MIPS_READONLY_SECTION
)
6134 /* We need it to tell the dynamic linker if there
6135 are relocations against the text segment. */
6136 hmips
->readonly_reloc
= TRUE
;
6139 /* Even though we don't directly need a GOT entry for
6140 this symbol, a symbol must have a dynamic symbol
6141 table index greater that DT_MIPS_GOTSYM if there are
6142 dynamic relocations against it. */
6146 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6147 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
6149 g
= mips_elf_got_info (dynobj
, &sgot
);
6150 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6155 if (SGI_COMPAT (abfd
))
6156 mips_elf_hash_table (info
)->compact_rel_size
+=
6157 sizeof (Elf32_External_crinfo
);
6161 case R_MIPS_GPREL16
:
6162 case R_MIPS_LITERAL
:
6163 case R_MIPS_GPREL32
:
6164 if (SGI_COMPAT (abfd
))
6165 mips_elf_hash_table (info
)->compact_rel_size
+=
6166 sizeof (Elf32_External_crinfo
);
6169 /* This relocation describes the C++ object vtable hierarchy.
6170 Reconstruct it for later use during GC. */
6171 case R_MIPS_GNU_VTINHERIT
:
6172 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6176 /* This relocation describes which C++ vtable entries are actually
6177 used. Record for later use during GC. */
6178 case R_MIPS_GNU_VTENTRY
:
6179 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
6187 /* We must not create a stub for a symbol that has relocations
6188 related to taking the function's address. */
6194 struct mips_elf_link_hash_entry
*mh
;
6196 mh
= (struct mips_elf_link_hash_entry
*) h
;
6197 mh
->no_fn_stub
= TRUE
;
6201 case R_MIPS_CALL_HI16
:
6202 case R_MIPS_CALL_LO16
:
6207 /* If this reloc is not a 16 bit call, and it has a global
6208 symbol, then we will need the fn_stub if there is one.
6209 References from a stub section do not count. */
6211 && r_type
!= R_MIPS16_26
6212 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
6213 sizeof FN_STUB
- 1) != 0
6214 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
6215 sizeof CALL_STUB
- 1) != 0
6216 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
6217 sizeof CALL_FP_STUB
- 1) != 0)
6219 struct mips_elf_link_hash_entry
*mh
;
6221 mh
= (struct mips_elf_link_hash_entry
*) h
;
6222 mh
->need_fn_stub
= TRUE
;
6230 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
6231 struct bfd_link_info
*link_info
,
6234 Elf_Internal_Rela
*internal_relocs
;
6235 Elf_Internal_Rela
*irel
, *irelend
;
6236 Elf_Internal_Shdr
*symtab_hdr
;
6237 bfd_byte
*contents
= NULL
;
6239 bfd_boolean changed_contents
= FALSE
;
6240 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
6241 Elf_Internal_Sym
*isymbuf
= NULL
;
6243 /* We are not currently changing any sizes, so only one pass. */
6246 if (link_info
->relocatable
)
6249 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
6250 link_info
->keep_memory
);
6251 if (internal_relocs
== NULL
)
6254 irelend
= internal_relocs
+ sec
->reloc_count
6255 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
6256 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6257 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6259 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
6262 bfd_signed_vma sym_offset
;
6263 unsigned int r_type
;
6264 unsigned long r_symndx
;
6266 unsigned long instruction
;
6268 /* Turn jalr into bgezal, and jr into beq, if they're marked
6269 with a JALR relocation, that indicate where they jump to.
6270 This saves some pipeline bubbles. */
6271 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
6272 if (r_type
!= R_MIPS_JALR
)
6275 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
6276 /* Compute the address of the jump target. */
6277 if (r_symndx
>= extsymoff
)
6279 struct mips_elf_link_hash_entry
*h
6280 = ((struct mips_elf_link_hash_entry
*)
6281 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
6283 while (h
->root
.root
.type
== bfd_link_hash_indirect
6284 || h
->root
.root
.type
== bfd_link_hash_warning
)
6285 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6287 /* If a symbol is undefined, or if it may be overridden,
6289 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
6290 || h
->root
.root
.type
== bfd_link_hash_defweak
)
6291 && h
->root
.root
.u
.def
.section
)
6292 || (link_info
->shared
&& ! link_info
->symbolic
6293 && !h
->root
.forced_local
))
6296 sym_sec
= h
->root
.root
.u
.def
.section
;
6297 if (sym_sec
->output_section
)
6298 symval
= (h
->root
.root
.u
.def
.value
6299 + sym_sec
->output_section
->vma
6300 + sym_sec
->output_offset
);
6302 symval
= h
->root
.root
.u
.def
.value
;
6306 Elf_Internal_Sym
*isym
;
6308 /* Read this BFD's symbols if we haven't done so already. */
6309 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
6311 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6312 if (isymbuf
== NULL
)
6313 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
6314 symtab_hdr
->sh_info
, 0,
6316 if (isymbuf
== NULL
)
6320 isym
= isymbuf
+ r_symndx
;
6321 if (isym
->st_shndx
== SHN_UNDEF
)
6323 else if (isym
->st_shndx
== SHN_ABS
)
6324 sym_sec
= bfd_abs_section_ptr
;
6325 else if (isym
->st_shndx
== SHN_COMMON
)
6326 sym_sec
= bfd_com_section_ptr
;
6329 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
6330 symval
= isym
->st_value
6331 + sym_sec
->output_section
->vma
6332 + sym_sec
->output_offset
;
6335 /* Compute branch offset, from delay slot of the jump to the
6337 sym_offset
= (symval
+ irel
->r_addend
)
6338 - (sec_start
+ irel
->r_offset
+ 4);
6340 /* Branch offset must be properly aligned. */
6341 if ((sym_offset
& 3) != 0)
6346 /* Check that it's in range. */
6347 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
6350 /* Get the section contents if we haven't done so already. */
6351 if (contents
== NULL
)
6353 /* Get cached copy if it exists. */
6354 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6355 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6358 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6363 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
6365 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
6366 if ((instruction
& 0xfc1fffff) == 0x0000f809)
6367 instruction
= 0x04110000;
6368 /* If it was jr <reg>, turn it into b <target>. */
6369 else if ((instruction
& 0xfc1fffff) == 0x00000008)
6370 instruction
= 0x10000000;
6374 instruction
|= (sym_offset
& 0xffff);
6375 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
6376 changed_contents
= TRUE
;
6379 if (contents
!= NULL
6380 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6382 if (!changed_contents
&& !link_info
->keep_memory
)
6386 /* Cache the section contents for elf_link_input_bfd. */
6387 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6393 if (contents
!= NULL
6394 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6399 /* Adjust a symbol defined by a dynamic object and referenced by a
6400 regular object. The current definition is in some section of the
6401 dynamic object, but we're not including those sections. We have to
6402 change the definition to something the rest of the link can
6406 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6407 struct elf_link_hash_entry
*h
)
6410 struct mips_elf_link_hash_entry
*hmips
;
6413 dynobj
= elf_hash_table (info
)->dynobj
;
6415 /* Make sure we know what is going on here. */
6416 BFD_ASSERT (dynobj
!= NULL
6418 || h
->u
.weakdef
!= NULL
6421 && !h
->def_regular
)));
6423 /* If this symbol is defined in a dynamic object, we need to copy
6424 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6426 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6427 if (! info
->relocatable
6428 && hmips
->possibly_dynamic_relocs
!= 0
6429 && (h
->root
.type
== bfd_link_hash_defweak
6430 || !h
->def_regular
))
6432 mips_elf_allocate_dynamic_relocations (dynobj
,
6433 hmips
->possibly_dynamic_relocs
);
6434 if (hmips
->readonly_reloc
)
6435 /* We tell the dynamic linker that there are relocations
6436 against the text segment. */
6437 info
->flags
|= DF_TEXTREL
;
6440 /* For a function, create a stub, if allowed. */
6441 if (! hmips
->no_fn_stub
6444 if (! elf_hash_table (info
)->dynamic_sections_created
)
6447 /* If this symbol is not defined in a regular file, then set
6448 the symbol to the stub location. This is required to make
6449 function pointers compare as equal between the normal
6450 executable and the shared library. */
6451 if (!h
->def_regular
)
6453 /* We need .stub section. */
6454 s
= bfd_get_section_by_name (dynobj
,
6455 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6456 BFD_ASSERT (s
!= NULL
);
6458 h
->root
.u
.def
.section
= s
;
6459 h
->root
.u
.def
.value
= s
->size
;
6461 /* XXX Write this stub address somewhere. */
6462 h
->plt
.offset
= s
->size
;
6464 /* Make room for this stub code. */
6465 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6467 /* The last half word of the stub will be filled with the index
6468 of this symbol in .dynsym section. */
6472 else if ((h
->type
== STT_FUNC
)
6475 /* This will set the entry for this symbol in the GOT to 0, and
6476 the dynamic linker will take care of this. */
6477 h
->root
.u
.def
.value
= 0;
6481 /* If this is a weak symbol, and there is a real definition, the
6482 processor independent code will have arranged for us to see the
6483 real definition first, and we can just use the same value. */
6484 if (h
->u
.weakdef
!= NULL
)
6486 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
6487 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
6488 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
6489 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
6493 /* This is a reference to a symbol defined by a dynamic object which
6494 is not a function. */
6499 /* This function is called after all the input files have been read,
6500 and the input sections have been assigned to output sections. We
6501 check for any mips16 stub sections that we can discard. */
6504 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
6505 struct bfd_link_info
*info
)
6511 struct mips_got_info
*g
;
6513 bfd_size_type loadable_size
= 0;
6514 bfd_size_type local_gotno
;
6516 struct mips_elf_count_tls_arg count_tls_arg
;
6518 /* The .reginfo section has a fixed size. */
6519 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
6521 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
6523 if (! (info
->relocatable
6524 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
6525 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
6526 mips_elf_check_mips16_stubs
, NULL
);
6528 dynobj
= elf_hash_table (info
)->dynobj
;
6530 /* Relocatable links don't have it. */
6533 g
= mips_elf_got_info (dynobj
, &s
);
6537 /* Calculate the total loadable size of the output. That
6538 will give us the maximum number of GOT_PAGE entries
6540 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
6542 asection
*subsection
;
6544 for (subsection
= sub
->sections
;
6546 subsection
= subsection
->next
)
6548 if ((subsection
->flags
& SEC_ALLOC
) == 0)
6550 loadable_size
+= ((subsection
->size
+ 0xf)
6551 &~ (bfd_size_type
) 0xf);
6555 /* There has to be a global GOT entry for every symbol with
6556 a dynamic symbol table index of DT_MIPS_GOTSYM or
6557 higher. Therefore, it make sense to put those symbols
6558 that need GOT entries at the end of the symbol table. We
6560 if (! mips_elf_sort_hash_table (info
, 1))
6563 if (g
->global_gotsym
!= NULL
)
6564 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
6566 /* If there are no global symbols, or none requiring
6567 relocations, then GLOBAL_GOTSYM will be NULL. */
6570 /* In the worst case, we'll get one stub per dynamic symbol, plus
6571 one to account for the dummy entry at the end required by IRIX
6573 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
6575 /* Assume there are two loadable segments consisting of
6576 contiguous sections. Is 5 enough? */
6577 local_gotno
= (loadable_size
>> 16) + 5;
6579 g
->local_gotno
+= local_gotno
;
6580 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
6582 g
->global_gotno
= i
;
6583 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
6585 /* We need to calculate tls_gotno for global symbols at this point
6586 instead of building it up earlier, to avoid doublecounting
6587 entries for one global symbol from multiple input files. */
6588 count_tls_arg
.info
= info
;
6589 count_tls_arg
.needed
= 0;
6590 elf_link_hash_traverse (elf_hash_table (info
),
6591 mips_elf_count_global_tls_entries
,
6593 g
->tls_gotno
+= count_tls_arg
.needed
;
6594 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
6596 mips_elf_resolve_final_got_entries (g
);
6598 if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
))
6600 if (! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
6605 /* Set up TLS entries for the first GOT. */
6606 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
6607 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
6613 /* Set the sizes of the dynamic sections. */
6616 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
6617 struct bfd_link_info
*info
)
6621 bfd_boolean reltext
;
6623 dynobj
= elf_hash_table (info
)->dynobj
;
6624 BFD_ASSERT (dynobj
!= NULL
);
6626 if (elf_hash_table (info
)->dynamic_sections_created
)
6628 /* Set the contents of the .interp section to the interpreter. */
6629 if (info
->executable
)
6631 s
= bfd_get_section_by_name (dynobj
, ".interp");
6632 BFD_ASSERT (s
!= NULL
);
6634 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
6636 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
6640 /* The check_relocs and adjust_dynamic_symbol entry points have
6641 determined the sizes of the various dynamic sections. Allocate
6644 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
6649 /* It's OK to base decisions on the section name, because none
6650 of the dynobj section names depend upon the input files. */
6651 name
= bfd_get_section_name (dynobj
, s
);
6653 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
6658 if (strncmp (name
, ".rel", 4) == 0)
6662 /* We only strip the section if the output section name
6663 has the same name. Otherwise, there might be several
6664 input sections for this output section. FIXME: This
6665 code is probably not needed these days anyhow, since
6666 the linker now does not create empty output sections. */
6667 if (s
->output_section
!= NULL
6669 bfd_get_section_name (s
->output_section
->owner
,
6670 s
->output_section
)) == 0)
6675 const char *outname
;
6678 /* If this relocation section applies to a read only
6679 section, then we probably need a DT_TEXTREL entry.
6680 If the relocation section is .rel.dyn, we always
6681 assert a DT_TEXTREL entry rather than testing whether
6682 there exists a relocation to a read only section or
6684 outname
= bfd_get_section_name (output_bfd
,
6686 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
6688 && (target
->flags
& SEC_READONLY
) != 0
6689 && (target
->flags
& SEC_ALLOC
) != 0)
6690 || strcmp (outname
, ".rel.dyn") == 0)
6693 /* We use the reloc_count field as a counter if we need
6694 to copy relocs into the output file. */
6695 if (strcmp (name
, ".rel.dyn") != 0)
6698 /* If combreloc is enabled, elf_link_sort_relocs() will
6699 sort relocations, but in a different way than we do,
6700 and before we're done creating relocations. Also, it
6701 will move them around between input sections'
6702 relocation's contents, so our sorting would be
6703 broken, so don't let it run. */
6704 info
->combreloc
= 0;
6707 else if (strncmp (name
, ".got", 4) == 0)
6709 /* _bfd_mips_elf_always_size_sections() has already done
6710 most of the work, but some symbols may have been mapped
6711 to versions that we must now resolve in the got_entries
6713 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
6714 struct mips_got_info
*g
= gg
;
6715 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
6716 unsigned int needed_relocs
= 0;
6720 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6721 set_got_offset_arg
.info
= info
;
6723 /* NOTE 2005-02-03: How can this call, or the next, ever
6724 find any indirect entries to resolve? They were all
6725 resolved in mips_elf_multi_got. */
6726 mips_elf_resolve_final_got_entries (gg
);
6727 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6729 unsigned int save_assign
;
6731 mips_elf_resolve_final_got_entries (g
);
6733 /* Assign offsets to global GOT entries. */
6734 save_assign
= g
->assigned_gotno
;
6735 g
->assigned_gotno
= g
->local_gotno
;
6736 set_got_offset_arg
.g
= g
;
6737 set_got_offset_arg
.needed_relocs
= 0;
6738 htab_traverse (g
->got_entries
,
6739 mips_elf_set_global_got_offset
,
6740 &set_got_offset_arg
);
6741 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6742 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6743 <= g
->global_gotno
);
6745 g
->assigned_gotno
= save_assign
;
6748 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6749 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6750 + g
->next
->global_gotno
6751 + g
->next
->tls_gotno
6752 + MIPS_RESERVED_GOTNO
);
6758 struct mips_elf_count_tls_arg arg
;
6762 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
6764 elf_link_hash_traverse (elf_hash_table (info
),
6765 mips_elf_count_global_tls_relocs
,
6768 needed_relocs
+= arg
.needed
;
6772 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6774 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6776 /* IRIX rld assumes that the function stub isn't at the end
6777 of .text section. So put a dummy. XXX */
6778 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6780 else if (! info
->shared
6781 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6782 && strncmp (name
, ".rld_map", 8) == 0)
6784 /* We add a room for __rld_map. It will be filled in by the
6785 rtld to contain a pointer to the _r_debug structure. */
6788 else if (SGI_COMPAT (output_bfd
)
6789 && strncmp (name
, ".compact_rel", 12) == 0)
6790 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6791 else if (strncmp (name
, ".init", 5) != 0)
6793 /* It's not one of our sections, so don't allocate space. */
6799 _bfd_strip_section_from_output (info
, s
);
6803 /* Allocate memory for the section contents. */
6804 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
6805 if (s
->contents
== NULL
&& s
->size
!= 0)
6807 bfd_set_error (bfd_error_no_memory
);
6812 if (elf_hash_table (info
)->dynamic_sections_created
)
6814 /* Add some entries to the .dynamic section. We fill in the
6815 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6816 must add the entries now so that we get the correct size for
6817 the .dynamic section. The DT_DEBUG entry is filled in by the
6818 dynamic linker and used by the debugger. */
6821 /* SGI object has the equivalence of DT_DEBUG in the
6822 DT_MIPS_RLD_MAP entry. */
6823 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6825 if (!SGI_COMPAT (output_bfd
))
6827 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6833 /* Shared libraries on traditional mips have DT_DEBUG. */
6834 if (!SGI_COMPAT (output_bfd
))
6836 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6841 if (reltext
&& SGI_COMPAT (output_bfd
))
6842 info
->flags
|= DF_TEXTREL
;
6844 if ((info
->flags
& DF_TEXTREL
) != 0)
6846 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6850 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6853 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6855 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6858 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6861 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6865 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6868 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6871 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6874 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6877 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6880 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6883 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6886 if (IRIX_COMPAT (dynobj
) == ict_irix5
6887 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6890 if (IRIX_COMPAT (dynobj
) == ict_irix6
6891 && (bfd_get_section_by_name
6892 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6893 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6900 /* Relocate a MIPS ELF section. */
6903 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6904 bfd
*input_bfd
, asection
*input_section
,
6905 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6906 Elf_Internal_Sym
*local_syms
,
6907 asection
**local_sections
)
6909 Elf_Internal_Rela
*rel
;
6910 const Elf_Internal_Rela
*relend
;
6912 bfd_boolean use_saved_addend_p
= FALSE
;
6913 const struct elf_backend_data
*bed
;
6915 bed
= get_elf_backend_data (output_bfd
);
6916 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6917 for (rel
= relocs
; rel
< relend
; ++rel
)
6921 reloc_howto_type
*howto
;
6922 bfd_boolean require_jalx
;
6923 /* TRUE if the relocation is a RELA relocation, rather than a
6925 bfd_boolean rela_relocation_p
= TRUE
;
6926 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6929 /* Find the relocation howto for this relocation. */
6930 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6932 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6933 64-bit code, but make sure all their addresses are in the
6934 lowermost or uppermost 32-bit section of the 64-bit address
6935 space. Thus, when they use an R_MIPS_64 they mean what is
6936 usually meant by R_MIPS_32, with the exception that the
6937 stored value is sign-extended to 64 bits. */
6938 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6940 /* On big-endian systems, we need to lie about the position
6942 if (bfd_big_endian (input_bfd
))
6946 /* NewABI defaults to RELA relocations. */
6947 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6948 NEWABI_P (input_bfd
)
6949 && (MIPS_RELOC_RELA_P
6950 (input_bfd
, input_section
,
6953 if (!use_saved_addend_p
)
6955 Elf_Internal_Shdr
*rel_hdr
;
6957 /* If these relocations were originally of the REL variety,
6958 we must pull the addend out of the field that will be
6959 relocated. Otherwise, we simply use the contents of the
6960 RELA relocation. To determine which flavor or relocation
6961 this is, we depend on the fact that the INPUT_SECTION's
6962 REL_HDR is read before its REL_HDR2. */
6963 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6964 if ((size_t) (rel
- relocs
)
6965 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6966 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6967 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6969 bfd_byte
*location
= contents
+ rel
->r_offset
;
6971 /* Note that this is a REL relocation. */
6972 rela_relocation_p
= FALSE
;
6974 /* Get the addend, which is stored in the input file. */
6975 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
6977 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6979 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
6982 addend
&= howto
->src_mask
;
6984 /* For some kinds of relocations, the ADDEND is a
6985 combination of the addend stored in two different
6987 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
6988 || (r_type
== R_MIPS_GOT16
6989 && mips_elf_local_relocation_p (input_bfd
, rel
,
6990 local_sections
, FALSE
)))
6993 const Elf_Internal_Rela
*lo16_relocation
;
6994 reloc_howto_type
*lo16_howto
;
6995 bfd_byte
*lo16_location
;
6998 if (r_type
== R_MIPS16_HI16
)
6999 lo16_type
= R_MIPS16_LO16
;
7001 lo16_type
= R_MIPS_LO16
;
7003 /* The combined value is the sum of the HI16 addend,
7004 left-shifted by sixteen bits, and the LO16
7005 addend, sign extended. (Usually, the code does
7006 a `lui' of the HI16 value, and then an `addiu' of
7009 Scan ahead to find a matching LO16 relocation.
7011 According to the MIPS ELF ABI, the R_MIPS_LO16
7012 relocation must be immediately following.
7013 However, for the IRIX6 ABI, the next relocation
7014 may be a composed relocation consisting of
7015 several relocations for the same address. In
7016 that case, the R_MIPS_LO16 relocation may occur
7017 as one of these. We permit a similar extension
7018 in general, as that is useful for GCC. */
7019 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
7022 if (lo16_relocation
== NULL
)
7025 lo16_location
= contents
+ lo16_relocation
->r_offset
;
7027 /* Obtain the addend kept there. */
7028 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
7030 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
7032 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
7033 input_bfd
, contents
);
7034 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
7036 l
&= lo16_howto
->src_mask
;
7037 l
<<= lo16_howto
->rightshift
;
7038 l
= _bfd_mips_elf_sign_extend (l
, 16);
7042 /* Compute the combined addend. */
7046 addend
<<= howto
->rightshift
;
7049 addend
= rel
->r_addend
;
7052 if (info
->relocatable
)
7054 Elf_Internal_Sym
*sym
;
7055 unsigned long r_symndx
;
7057 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
7058 && bfd_big_endian (input_bfd
))
7061 /* Since we're just relocating, all we need to do is copy
7062 the relocations back out to the object file, unless
7063 they're against a section symbol, in which case we need
7064 to adjust by the section offset, or unless they're GP
7065 relative in which case we need to adjust by the amount
7066 that we're adjusting GP in this relocatable object. */
7068 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
7070 /* There's nothing to do for non-local relocations. */
7073 if (r_type
== R_MIPS16_GPREL
7074 || r_type
== R_MIPS_GPREL16
7075 || r_type
== R_MIPS_GPREL32
7076 || r_type
== R_MIPS_LITERAL
)
7077 addend
-= (_bfd_get_gp_value (output_bfd
)
7078 - _bfd_get_gp_value (input_bfd
));
7080 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
7081 sym
= local_syms
+ r_symndx
;
7082 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7083 /* Adjust the addend appropriately. */
7084 addend
+= local_sections
[r_symndx
]->output_offset
;
7086 if (rela_relocation_p
)
7087 /* If this is a RELA relocation, just update the addend. */
7088 rel
->r_addend
= addend
;
7091 if (r_type
== R_MIPS_HI16
7092 || r_type
== R_MIPS_GOT16
)
7093 addend
= mips_elf_high (addend
);
7094 else if (r_type
== R_MIPS_HIGHER
)
7095 addend
= mips_elf_higher (addend
);
7096 else if (r_type
== R_MIPS_HIGHEST
)
7097 addend
= mips_elf_highest (addend
);
7099 addend
>>= howto
->rightshift
;
7101 /* We use the source mask, rather than the destination
7102 mask because the place to which we are writing will be
7103 source of the addend in the final link. */
7104 addend
&= howto
->src_mask
;
7106 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7107 /* See the comment above about using R_MIPS_64 in the 32-bit
7108 ABI. Here, we need to update the addend. It would be
7109 possible to get away with just using the R_MIPS_32 reloc
7110 but for endianness. */
7116 if (addend
& ((bfd_vma
) 1 << 31))
7118 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7125 /* If we don't know that we have a 64-bit type,
7126 do two separate stores. */
7127 if (bfd_big_endian (input_bfd
))
7129 /* Store the sign-bits (which are most significant)
7131 low_bits
= sign_bits
;
7137 high_bits
= sign_bits
;
7139 bfd_put_32 (input_bfd
, low_bits
,
7140 contents
+ rel
->r_offset
);
7141 bfd_put_32 (input_bfd
, high_bits
,
7142 contents
+ rel
->r_offset
+ 4);
7146 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
7147 input_bfd
, input_section
,
7152 /* Go on to the next relocation. */
7156 /* In the N32 and 64-bit ABIs there may be multiple consecutive
7157 relocations for the same offset. In that case we are
7158 supposed to treat the output of each relocation as the addend
7160 if (rel
+ 1 < relend
7161 && rel
->r_offset
== rel
[1].r_offset
7162 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
7163 use_saved_addend_p
= TRUE
;
7165 use_saved_addend_p
= FALSE
;
7167 /* Figure out what value we are supposed to relocate. */
7168 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
7169 input_section
, info
, rel
,
7170 addend
, howto
, local_syms
,
7171 local_sections
, &value
,
7172 &name
, &require_jalx
,
7173 use_saved_addend_p
))
7175 case bfd_reloc_continue
:
7176 /* There's nothing to do. */
7179 case bfd_reloc_undefined
:
7180 /* mips_elf_calculate_relocation already called the
7181 undefined_symbol callback. There's no real point in
7182 trying to perform the relocation at this point, so we
7183 just skip ahead to the next relocation. */
7186 case bfd_reloc_notsupported
:
7187 msg
= _("internal error: unsupported relocation error");
7188 info
->callbacks
->warning
7189 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
7192 case bfd_reloc_overflow
:
7193 if (use_saved_addend_p
)
7194 /* Ignore overflow until we reach the last relocation for
7195 a given location. */
7199 BFD_ASSERT (name
!= NULL
);
7200 if (! ((*info
->callbacks
->reloc_overflow
)
7201 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
7202 input_bfd
, input_section
, rel
->r_offset
)))
7215 /* If we've got another relocation for the address, keep going
7216 until we reach the last one. */
7217 if (use_saved_addend_p
)
7223 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7224 /* See the comment above about using R_MIPS_64 in the 32-bit
7225 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7226 that calculated the right value. Now, however, we
7227 sign-extend the 32-bit result to 64-bits, and store it as a
7228 64-bit value. We are especially generous here in that we
7229 go to extreme lengths to support this usage on systems with
7230 only a 32-bit VMA. */
7236 if (value
& ((bfd_vma
) 1 << 31))
7238 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7245 /* If we don't know that we have a 64-bit type,
7246 do two separate stores. */
7247 if (bfd_big_endian (input_bfd
))
7249 /* Undo what we did above. */
7251 /* Store the sign-bits (which are most significant)
7253 low_bits
= sign_bits
;
7259 high_bits
= sign_bits
;
7261 bfd_put_32 (input_bfd
, low_bits
,
7262 contents
+ rel
->r_offset
);
7263 bfd_put_32 (input_bfd
, high_bits
,
7264 contents
+ rel
->r_offset
+ 4);
7268 /* Actually perform the relocation. */
7269 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
7270 input_bfd
, input_section
,
7271 contents
, require_jalx
))
7278 /* If NAME is one of the special IRIX6 symbols defined by the linker,
7279 adjust it appropriately now. */
7282 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
7283 const char *name
, Elf_Internal_Sym
*sym
)
7285 /* The linker script takes care of providing names and values for
7286 these, but we must place them into the right sections. */
7287 static const char* const text_section_symbols
[] = {
7290 "__dso_displacement",
7292 "__program_header_table",
7296 static const char* const data_section_symbols
[] = {
7304 const char* const *p
;
7307 for (i
= 0; i
< 2; ++i
)
7308 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
7311 if (strcmp (*p
, name
) == 0)
7313 /* All of these symbols are given type STT_SECTION by the
7315 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7316 sym
->st_other
= STO_PROTECTED
;
7318 /* The IRIX linker puts these symbols in special sections. */
7320 sym
->st_shndx
= SHN_MIPS_TEXT
;
7322 sym
->st_shndx
= SHN_MIPS_DATA
;
7328 /* Finish up dynamic symbol handling. We set the contents of various
7329 dynamic sections here. */
7332 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
7333 struct bfd_link_info
*info
,
7334 struct elf_link_hash_entry
*h
,
7335 Elf_Internal_Sym
*sym
)
7339 struct mips_got_info
*g
, *gg
;
7342 dynobj
= elf_hash_table (info
)->dynobj
;
7344 if (h
->plt
.offset
!= MINUS_ONE
)
7347 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
7349 /* This symbol has a stub. Set it up. */
7351 BFD_ASSERT (h
->dynindx
!= -1);
7353 s
= bfd_get_section_by_name (dynobj
,
7354 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7355 BFD_ASSERT (s
!= NULL
);
7357 /* FIXME: Can h->dynindex be more than 64K? */
7358 if (h
->dynindx
& 0xffff0000)
7361 /* Fill the stub. */
7362 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
7363 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
7364 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
7365 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
7367 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
7368 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
7370 /* Mark the symbol as undefined. plt.offset != -1 occurs
7371 only for the referenced symbol. */
7372 sym
->st_shndx
= SHN_UNDEF
;
7374 /* The run-time linker uses the st_value field of the symbol
7375 to reset the global offset table entry for this external
7376 to its stub address when unlinking a shared object. */
7377 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
7381 BFD_ASSERT (h
->dynindx
!= -1
7382 || h
->forced_local
);
7384 sgot
= mips_elf_got_section (dynobj
, FALSE
);
7385 BFD_ASSERT (sgot
!= NULL
);
7386 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
7387 g
= mips_elf_section_data (sgot
)->u
.got_info
;
7388 BFD_ASSERT (g
!= NULL
);
7390 /* Run through the global symbol table, creating GOT entries for all
7391 the symbols that need them. */
7392 if (g
->global_gotsym
!= NULL
7393 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
7398 value
= sym
->st_value
;
7399 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
, R_MIPS_GOT16
, info
);
7400 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
7403 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
7405 struct mips_got_entry e
, *p
;
7411 e
.abfd
= output_bfd
;
7413 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
7416 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
7419 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
7424 || (elf_hash_table (info
)->dynamic_sections_created
7426 && p
->d
.h
->root
.def_dynamic
7427 && !p
->d
.h
->root
.def_regular
))
7429 /* Create an R_MIPS_REL32 relocation for this entry. Due to
7430 the various compatibility problems, it's easier to mock
7431 up an R_MIPS_32 or R_MIPS_64 relocation and leave
7432 mips_elf_create_dynamic_relocation to calculate the
7433 appropriate addend. */
7434 Elf_Internal_Rela rel
[3];
7436 memset (rel
, 0, sizeof (rel
));
7437 if (ABI_64_P (output_bfd
))
7438 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
7440 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
7441 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
7444 if (! (mips_elf_create_dynamic_relocation
7445 (output_bfd
, info
, rel
,
7446 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
7450 entry
= sym
->st_value
;
7451 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
7456 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7457 name
= h
->root
.root
.string
;
7458 if (strcmp (name
, "_DYNAMIC") == 0
7459 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
7460 sym
->st_shndx
= SHN_ABS
;
7461 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
7462 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
7464 sym
->st_shndx
= SHN_ABS
;
7465 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7468 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
7470 sym
->st_shndx
= SHN_ABS
;
7471 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7472 sym
->st_value
= elf_gp (output_bfd
);
7474 else if (SGI_COMPAT (output_bfd
))
7476 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
7477 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
7479 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7480 sym
->st_other
= STO_PROTECTED
;
7482 sym
->st_shndx
= SHN_MIPS_DATA
;
7484 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
7486 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7487 sym
->st_other
= STO_PROTECTED
;
7488 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
7489 sym
->st_shndx
= SHN_ABS
;
7491 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
7493 if (h
->type
== STT_FUNC
)
7494 sym
->st_shndx
= SHN_MIPS_TEXT
;
7495 else if (h
->type
== STT_OBJECT
)
7496 sym
->st_shndx
= SHN_MIPS_DATA
;
7500 /* Handle the IRIX6-specific symbols. */
7501 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
7502 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
7506 if (! mips_elf_hash_table (info
)->use_rld_obj_head
7507 && (strcmp (name
, "__rld_map") == 0
7508 || strcmp (name
, "__RLD_MAP") == 0))
7510 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
7511 BFD_ASSERT (s
!= NULL
);
7512 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
7513 bfd_put_32 (output_bfd
, 0, s
->contents
);
7514 if (mips_elf_hash_table (info
)->rld_value
== 0)
7515 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
7517 else if (mips_elf_hash_table (info
)->use_rld_obj_head
7518 && strcmp (name
, "__rld_obj_head") == 0)
7520 /* IRIX6 does not use a .rld_map section. */
7521 if (IRIX_COMPAT (output_bfd
) == ict_irix5
7522 || IRIX_COMPAT (output_bfd
) == ict_none
)
7523 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
7525 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
7529 /* If this is a mips16 symbol, force the value to be even. */
7530 if (sym
->st_other
== STO_MIPS16
)
7531 sym
->st_value
&= ~1;
7536 /* Finish up the dynamic sections. */
7539 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
7540 struct bfd_link_info
*info
)
7545 struct mips_got_info
*gg
, *g
;
7547 dynobj
= elf_hash_table (info
)->dynobj
;
7549 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
7551 sgot
= mips_elf_got_section (dynobj
, FALSE
);
7556 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
7557 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
7558 BFD_ASSERT (gg
!= NULL
);
7559 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
7560 BFD_ASSERT (g
!= NULL
);
7563 if (elf_hash_table (info
)->dynamic_sections_created
)
7567 BFD_ASSERT (sdyn
!= NULL
);
7568 BFD_ASSERT (g
!= NULL
);
7570 for (b
= sdyn
->contents
;
7571 b
< sdyn
->contents
+ sdyn
->size
;
7572 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
7574 Elf_Internal_Dyn dyn
;
7578 bfd_boolean swap_out_p
;
7580 /* Read in the current dynamic entry. */
7581 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
7583 /* Assume that we're going to modify it and write it out. */
7589 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7590 BFD_ASSERT (s
!= NULL
);
7591 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
7595 /* Rewrite DT_STRSZ. */
7597 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7602 s
= bfd_get_section_by_name (output_bfd
, name
);
7603 BFD_ASSERT (s
!= NULL
);
7604 dyn
.d_un
.d_ptr
= s
->vma
;
7607 case DT_MIPS_RLD_VERSION
:
7608 dyn
.d_un
.d_val
= 1; /* XXX */
7612 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
7615 case DT_MIPS_TIME_STAMP
:
7616 time ((time_t *) &dyn
.d_un
.d_val
);
7619 case DT_MIPS_ICHECKSUM
:
7624 case DT_MIPS_IVERSION
:
7629 case DT_MIPS_BASE_ADDRESS
:
7630 s
= output_bfd
->sections
;
7631 BFD_ASSERT (s
!= NULL
);
7632 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
7635 case DT_MIPS_LOCAL_GOTNO
:
7636 dyn
.d_un
.d_val
= g
->local_gotno
;
7639 case DT_MIPS_UNREFEXTNO
:
7640 /* The index into the dynamic symbol table which is the
7641 entry of the first external symbol that is not
7642 referenced within the same object. */
7643 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
7646 case DT_MIPS_GOTSYM
:
7647 if (gg
->global_gotsym
)
7649 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
7652 /* In case if we don't have global got symbols we default
7653 to setting DT_MIPS_GOTSYM to the same value as
7654 DT_MIPS_SYMTABNO, so we just fall through. */
7656 case DT_MIPS_SYMTABNO
:
7658 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
7659 s
= bfd_get_section_by_name (output_bfd
, name
);
7660 BFD_ASSERT (s
!= NULL
);
7662 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
7665 case DT_MIPS_HIPAGENO
:
7666 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
7669 case DT_MIPS_RLD_MAP
:
7670 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
7673 case DT_MIPS_OPTIONS
:
7674 s
= (bfd_get_section_by_name
7675 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
7676 dyn
.d_un
.d_ptr
= s
->vma
;
7680 /* Reduce DT_RELSZ to account for any relocations we
7681 decided not to make. This is for the n64 irix rld,
7682 which doesn't seem to apply any relocations if there
7683 are trailing null entries. */
7684 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7685 dyn
.d_un
.d_val
= (s
->reloc_count
7686 * (ABI_64_P (output_bfd
)
7687 ? sizeof (Elf64_Mips_External_Rel
)
7688 : sizeof (Elf32_External_Rel
)));
7697 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
7702 /* The first entry of the global offset table will be filled at
7703 runtime. The second entry will be used by some runtime loaders.
7704 This isn't the case of IRIX rld. */
7705 if (sgot
!= NULL
&& sgot
->size
> 0)
7707 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
7708 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
7709 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7713 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7714 = MIPS_ELF_GOT_SIZE (output_bfd
);
7716 /* Generate dynamic relocations for the non-primary gots. */
7717 if (gg
!= NULL
&& gg
->next
)
7719 Elf_Internal_Rela rel
[3];
7722 memset (rel
, 0, sizeof (rel
));
7723 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7725 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7727 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
7728 + g
->next
->tls_gotno
;
7730 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7731 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7732 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7733 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7738 while (index
< g
->assigned_gotno
)
7740 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7741 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7742 if (!(mips_elf_create_dynamic_relocation
7743 (output_bfd
, info
, rel
, NULL
,
7744 bfd_abs_section_ptr
,
7747 BFD_ASSERT (addend
== 0);
7754 Elf32_compact_rel cpt
;
7756 if (SGI_COMPAT (output_bfd
))
7758 /* Write .compact_rel section out. */
7759 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7763 cpt
.num
= s
->reloc_count
;
7765 cpt
.offset
= (s
->output_section
->filepos
7766 + sizeof (Elf32_External_compact_rel
));
7769 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7770 ((Elf32_External_compact_rel
*)
7773 /* Clean up a dummy stub function entry in .text. */
7774 s
= bfd_get_section_by_name (dynobj
,
7775 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7778 file_ptr dummy_offset
;
7780 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE
);
7781 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE
;
7782 memset (s
->contents
+ dummy_offset
, 0,
7783 MIPS_FUNCTION_STUB_SIZE
);
7788 /* We need to sort the entries of the dynamic relocation section. */
7790 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7793 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7795 reldyn_sorting_bfd
= output_bfd
;
7797 if (ABI_64_P (output_bfd
))
7798 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7799 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7801 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7802 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7810 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7813 mips_set_isa_flags (bfd
*abfd
)
7817 switch (bfd_get_mach (abfd
))
7820 case bfd_mach_mips3000
:
7821 val
= E_MIPS_ARCH_1
;
7824 case bfd_mach_mips3900
:
7825 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7828 case bfd_mach_mips6000
:
7829 val
= E_MIPS_ARCH_2
;
7832 case bfd_mach_mips4000
:
7833 case bfd_mach_mips4300
:
7834 case bfd_mach_mips4400
:
7835 case bfd_mach_mips4600
:
7836 val
= E_MIPS_ARCH_3
;
7839 case bfd_mach_mips4010
:
7840 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7843 case bfd_mach_mips4100
:
7844 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7847 case bfd_mach_mips4111
:
7848 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7851 case bfd_mach_mips4120
:
7852 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7855 case bfd_mach_mips4650
:
7856 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7859 case bfd_mach_mips5400
:
7860 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7863 case bfd_mach_mips5500
:
7864 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7867 case bfd_mach_mips9000
:
7868 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
7871 case bfd_mach_mips5000
:
7872 case bfd_mach_mips7000
:
7873 case bfd_mach_mips8000
:
7874 case bfd_mach_mips10000
:
7875 case bfd_mach_mips12000
:
7876 val
= E_MIPS_ARCH_4
;
7879 case bfd_mach_mips5
:
7880 val
= E_MIPS_ARCH_5
;
7883 case bfd_mach_mips_sb1
:
7884 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7887 case bfd_mach_mipsisa32
:
7888 val
= E_MIPS_ARCH_32
;
7891 case bfd_mach_mipsisa64
:
7892 val
= E_MIPS_ARCH_64
;
7895 case bfd_mach_mipsisa32r2
:
7896 val
= E_MIPS_ARCH_32R2
;
7899 case bfd_mach_mipsisa64r2
:
7900 val
= E_MIPS_ARCH_64R2
;
7903 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7904 elf_elfheader (abfd
)->e_flags
|= val
;
7909 /* The final processing done just before writing out a MIPS ELF object
7910 file. This gets the MIPS architecture right based on the machine
7911 number. This is used by both the 32-bit and the 64-bit ABI. */
7914 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7915 bfd_boolean linker ATTRIBUTE_UNUSED
)
7918 Elf_Internal_Shdr
**hdrpp
;
7922 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7923 is nonzero. This is for compatibility with old objects, which used
7924 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7925 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7926 mips_set_isa_flags (abfd
);
7928 /* Set the sh_info field for .gptab sections and other appropriate
7929 info for each special section. */
7930 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7931 i
< elf_numsections (abfd
);
7934 switch ((*hdrpp
)->sh_type
)
7937 case SHT_MIPS_LIBLIST
:
7938 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7940 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7943 case SHT_MIPS_GPTAB
:
7944 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7945 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7946 BFD_ASSERT (name
!= NULL
7947 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7948 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7949 BFD_ASSERT (sec
!= NULL
);
7950 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7953 case SHT_MIPS_CONTENT
:
7954 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7955 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7956 BFD_ASSERT (name
!= NULL
7957 && strncmp (name
, ".MIPS.content",
7958 sizeof ".MIPS.content" - 1) == 0);
7959 sec
= bfd_get_section_by_name (abfd
,
7960 name
+ sizeof ".MIPS.content" - 1);
7961 BFD_ASSERT (sec
!= NULL
);
7962 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7965 case SHT_MIPS_SYMBOL_LIB
:
7966 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7968 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7969 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7971 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7974 case SHT_MIPS_EVENTS
:
7975 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7976 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7977 BFD_ASSERT (name
!= NULL
);
7978 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7979 sec
= bfd_get_section_by_name (abfd
,
7980 name
+ sizeof ".MIPS.events" - 1);
7983 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7984 sizeof ".MIPS.post_rel" - 1) == 0);
7985 sec
= bfd_get_section_by_name (abfd
,
7987 + sizeof ".MIPS.post_rel" - 1));
7989 BFD_ASSERT (sec
!= NULL
);
7990 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7997 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
8001 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
8006 /* See if we need a PT_MIPS_REGINFO segment. */
8007 s
= bfd_get_section_by_name (abfd
, ".reginfo");
8008 if (s
&& (s
->flags
& SEC_LOAD
))
8011 /* See if we need a PT_MIPS_OPTIONS segment. */
8012 if (IRIX_COMPAT (abfd
) == ict_irix6
8013 && bfd_get_section_by_name (abfd
,
8014 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
8017 /* See if we need a PT_MIPS_RTPROC segment. */
8018 if (IRIX_COMPAT (abfd
) == ict_irix5
8019 && bfd_get_section_by_name (abfd
, ".dynamic")
8020 && bfd_get_section_by_name (abfd
, ".mdebug"))
8026 /* Modify the segment map for an IRIX5 executable. */
8029 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
8030 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
8033 struct elf_segment_map
*m
, **pm
;
8036 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
8038 s
= bfd_get_section_by_name (abfd
, ".reginfo");
8039 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
8041 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
8042 if (m
->p_type
== PT_MIPS_REGINFO
)
8047 m
= bfd_zalloc (abfd
, amt
);
8051 m
->p_type
= PT_MIPS_REGINFO
;
8055 /* We want to put it after the PHDR and INTERP segments. */
8056 pm
= &elf_tdata (abfd
)->segment_map
;
8058 && ((*pm
)->p_type
== PT_PHDR
8059 || (*pm
)->p_type
== PT_INTERP
))
8067 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
8068 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
8069 PT_MIPS_OPTIONS segment immediately following the program header
8072 /* On non-IRIX6 new abi, we'll have already created a segment
8073 for this section, so don't create another. I'm not sure this
8074 is not also the case for IRIX 6, but I can't test it right
8076 && IRIX_COMPAT (abfd
) == ict_irix6
)
8078 for (s
= abfd
->sections
; s
; s
= s
->next
)
8079 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
8084 struct elf_segment_map
*options_segment
;
8086 pm
= &elf_tdata (abfd
)->segment_map
;
8088 && ((*pm
)->p_type
== PT_PHDR
8089 || (*pm
)->p_type
== PT_INTERP
))
8092 amt
= sizeof (struct elf_segment_map
);
8093 options_segment
= bfd_zalloc (abfd
, amt
);
8094 options_segment
->next
= *pm
;
8095 options_segment
->p_type
= PT_MIPS_OPTIONS
;
8096 options_segment
->p_flags
= PF_R
;
8097 options_segment
->p_flags_valid
= TRUE
;
8098 options_segment
->count
= 1;
8099 options_segment
->sections
[0] = s
;
8100 *pm
= options_segment
;
8105 if (IRIX_COMPAT (abfd
) == ict_irix5
)
8107 /* If there are .dynamic and .mdebug sections, we make a room
8108 for the RTPROC header. FIXME: Rewrite without section names. */
8109 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
8110 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
8111 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
8113 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
8114 if (m
->p_type
== PT_MIPS_RTPROC
)
8119 m
= bfd_zalloc (abfd
, amt
);
8123 m
->p_type
= PT_MIPS_RTPROC
;
8125 s
= bfd_get_section_by_name (abfd
, ".rtproc");
8130 m
->p_flags_valid
= 1;
8138 /* We want to put it after the DYNAMIC segment. */
8139 pm
= &elf_tdata (abfd
)->segment_map
;
8140 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
8150 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
8151 .dynstr, .dynsym, and .hash sections, and everything in
8153 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
8155 if ((*pm
)->p_type
== PT_DYNAMIC
)
8158 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
8160 /* For a normal mips executable the permissions for the PT_DYNAMIC
8161 segment are read, write and execute. We do that here since
8162 the code in elf.c sets only the read permission. This matters
8163 sometimes for the dynamic linker. */
8164 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
8166 m
->p_flags
= PF_R
| PF_W
| PF_X
;
8167 m
->p_flags_valid
= 1;
8171 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
8173 static const char *sec_names
[] =
8175 ".dynamic", ".dynstr", ".dynsym", ".hash"
8179 struct elf_segment_map
*n
;
8183 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
8185 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
8186 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
8193 if (high
< s
->vma
+ sz
)
8199 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8200 if ((s
->flags
& SEC_LOAD
) != 0
8202 && s
->vma
+ s
->size
<= high
)
8205 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
8206 n
= bfd_zalloc (abfd
, amt
);
8213 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8215 if ((s
->flags
& SEC_LOAD
) != 0
8217 && s
->vma
+ s
->size
<= high
)
8231 /* Return the section that should be marked against GC for a given
8235 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
8236 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
8237 Elf_Internal_Rela
*rel
,
8238 struct elf_link_hash_entry
*h
,
8239 Elf_Internal_Sym
*sym
)
8241 /* ??? Do mips16 stub sections need to be handled special? */
8245 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
8247 case R_MIPS_GNU_VTINHERIT
:
8248 case R_MIPS_GNU_VTENTRY
:
8252 switch (h
->root
.type
)
8254 case bfd_link_hash_defined
:
8255 case bfd_link_hash_defweak
:
8256 return h
->root
.u
.def
.section
;
8258 case bfd_link_hash_common
:
8259 return h
->root
.u
.c
.p
->section
;
8267 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
8272 /* Update the got entry reference counts for the section being removed. */
8275 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
8276 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
8277 asection
*sec ATTRIBUTE_UNUSED
,
8278 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
8281 Elf_Internal_Shdr
*symtab_hdr
;
8282 struct elf_link_hash_entry
**sym_hashes
;
8283 bfd_signed_vma
*local_got_refcounts
;
8284 const Elf_Internal_Rela
*rel
, *relend
;
8285 unsigned long r_symndx
;
8286 struct elf_link_hash_entry
*h
;
8288 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8289 sym_hashes
= elf_sym_hashes (abfd
);
8290 local_got_refcounts
= elf_local_got_refcounts (abfd
);
8292 relend
= relocs
+ sec
->reloc_count
;
8293 for (rel
= relocs
; rel
< relend
; rel
++)
8294 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
8298 case R_MIPS_CALL_HI16
:
8299 case R_MIPS_CALL_LO16
:
8300 case R_MIPS_GOT_HI16
:
8301 case R_MIPS_GOT_LO16
:
8302 case R_MIPS_GOT_DISP
:
8303 case R_MIPS_GOT_PAGE
:
8304 case R_MIPS_GOT_OFST
:
8305 /* ??? It would seem that the existing MIPS code does no sort
8306 of reference counting or whatnot on its GOT and PLT entries,
8307 so it is not possible to garbage collect them at this time. */
8318 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
8319 hiding the old indirect symbol. Process additional relocation
8320 information. Also called for weakdefs, in which case we just let
8321 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
8324 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
8325 struct elf_link_hash_entry
*dir
,
8326 struct elf_link_hash_entry
*ind
)
8328 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
8330 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
8332 if (ind
->root
.type
!= bfd_link_hash_indirect
)
8335 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
8336 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
8337 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
8338 if (indmips
->readonly_reloc
)
8339 dirmips
->readonly_reloc
= TRUE
;
8340 if (indmips
->no_fn_stub
)
8341 dirmips
->no_fn_stub
= TRUE
;
8343 if (dirmips
->tls_type
== 0)
8344 dirmips
->tls_type
= indmips
->tls_type
;
8346 BFD_ASSERT (indmips
->tls_type
== 0);
8350 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
8351 struct elf_link_hash_entry
*entry
,
8352 bfd_boolean force_local
)
8356 struct mips_got_info
*g
;
8357 struct mips_elf_link_hash_entry
*h
;
8359 h
= (struct mips_elf_link_hash_entry
*) entry
;
8360 if (h
->forced_local
)
8362 h
->forced_local
= force_local
;
8364 dynobj
= elf_hash_table (info
)->dynobj
;
8365 if (dynobj
!= NULL
&& force_local
&& h
->root
.type
!= STT_TLS
)
8367 got
= mips_elf_got_section (dynobj
, FALSE
);
8368 g
= mips_elf_section_data (got
)->u
.got_info
;
8372 struct mips_got_entry e
;
8373 struct mips_got_info
*gg
= g
;
8375 /* Since we're turning what used to be a global symbol into a
8376 local one, bump up the number of local entries of each GOT
8377 that had an entry for it. This will automatically decrease
8378 the number of global entries, since global_gotno is actually
8379 the upper limit of global entries. */
8385 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
8386 if (htab_find (g
->got_entries
, &e
))
8388 BFD_ASSERT (g
->global_gotno
> 0);
8393 /* If this was a global symbol forced into the primary GOT, we
8394 no longer need an entry for it. We can't release the entry
8395 at this point, but we must at least stop counting it as one
8396 of the symbols that required a forced got entry. */
8397 if (h
->root
.got
.offset
== 2)
8399 BFD_ASSERT (gg
->assigned_gotno
> 0);
8400 gg
->assigned_gotno
--;
8403 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
8404 /* If we haven't got through GOT allocation yet, just bump up the
8405 number of local entries, as this symbol won't be counted as
8408 else if (h
->root
.got
.offset
== 1)
8410 /* If we're past non-multi-GOT allocation and this symbol had
8411 been marked for a global got entry, give it a local entry
8413 BFD_ASSERT (g
->global_gotno
> 0);
8419 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
8425 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
8426 struct bfd_link_info
*info
)
8429 bfd_boolean ret
= FALSE
;
8430 unsigned char *tdata
;
8433 o
= bfd_get_section_by_name (abfd
, ".pdr");
8438 if (o
->size
% PDR_SIZE
!= 0)
8440 if (o
->output_section
!= NULL
8441 && bfd_is_abs_section (o
->output_section
))
8444 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
8448 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
8456 cookie
->rel
= cookie
->rels
;
8457 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
8459 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
8461 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
8470 mips_elf_section_data (o
)->u
.tdata
= tdata
;
8471 o
->size
-= skip
* PDR_SIZE
;
8477 if (! info
->keep_memory
)
8478 free (cookie
->rels
);
8484 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
8486 if (strcmp (sec
->name
, ".pdr") == 0)
8492 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
8495 bfd_byte
*to
, *from
, *end
;
8498 if (strcmp (sec
->name
, ".pdr") != 0)
8501 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
8505 end
= contents
+ sec
->size
;
8506 for (from
= contents
, i
= 0;
8508 from
+= PDR_SIZE
, i
++)
8510 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
8513 memcpy (to
, from
, PDR_SIZE
);
8516 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
8517 sec
->output_offset
, sec
->size
);
8521 /* MIPS ELF uses a special find_nearest_line routine in order the
8522 handle the ECOFF debugging information. */
8524 struct mips_elf_find_line
8526 struct ecoff_debug_info d
;
8527 struct ecoff_find_line i
;
8531 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
8532 asymbol
**symbols
, bfd_vma offset
,
8533 const char **filename_ptr
,
8534 const char **functionname_ptr
,
8535 unsigned int *line_ptr
)
8539 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
8540 filename_ptr
, functionname_ptr
,
8544 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
8545 filename_ptr
, functionname_ptr
,
8546 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
8547 &elf_tdata (abfd
)->dwarf2_find_line_info
))
8550 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
8554 struct mips_elf_find_line
*fi
;
8555 const struct ecoff_debug_swap
* const swap
=
8556 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8558 /* If we are called during a link, mips_elf_final_link may have
8559 cleared the SEC_HAS_CONTENTS field. We force it back on here
8560 if appropriate (which it normally will be). */
8561 origflags
= msec
->flags
;
8562 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
8563 msec
->flags
|= SEC_HAS_CONTENTS
;
8565 fi
= elf_tdata (abfd
)->find_line_info
;
8568 bfd_size_type external_fdr_size
;
8571 struct fdr
*fdr_ptr
;
8572 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
8574 fi
= bfd_zalloc (abfd
, amt
);
8577 msec
->flags
= origflags
;
8581 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
8583 msec
->flags
= origflags
;
8587 /* Swap in the FDR information. */
8588 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
8589 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
8590 if (fi
->d
.fdr
== NULL
)
8592 msec
->flags
= origflags
;
8595 external_fdr_size
= swap
->external_fdr_size
;
8596 fdr_ptr
= fi
->d
.fdr
;
8597 fraw_src
= (char *) fi
->d
.external_fdr
;
8598 fraw_end
= (fraw_src
8599 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
8600 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
8601 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
8603 elf_tdata (abfd
)->find_line_info
= fi
;
8605 /* Note that we don't bother to ever free this information.
8606 find_nearest_line is either called all the time, as in
8607 objdump -l, so the information should be saved, or it is
8608 rarely called, as in ld error messages, so the memory
8609 wasted is unimportant. Still, it would probably be a
8610 good idea for free_cached_info to throw it away. */
8613 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
8614 &fi
->i
, filename_ptr
, functionname_ptr
,
8617 msec
->flags
= origflags
;
8621 msec
->flags
= origflags
;
8624 /* Fall back on the generic ELF find_nearest_line routine. */
8626 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
8627 filename_ptr
, functionname_ptr
,
8631 /* When are writing out the .options or .MIPS.options section,
8632 remember the bytes we are writing out, so that we can install the
8633 GP value in the section_processing routine. */
8636 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
8637 const void *location
,
8638 file_ptr offset
, bfd_size_type count
)
8640 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
8644 if (elf_section_data (section
) == NULL
)
8646 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
8647 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
8648 if (elf_section_data (section
) == NULL
)
8651 c
= mips_elf_section_data (section
)->u
.tdata
;
8654 c
= bfd_zalloc (abfd
, section
->size
);
8657 mips_elf_section_data (section
)->u
.tdata
= c
;
8660 memcpy (c
+ offset
, location
, count
);
8663 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
8667 /* This is almost identical to bfd_generic_get_... except that some
8668 MIPS relocations need to be handled specially. Sigh. */
8671 _bfd_elf_mips_get_relocated_section_contents
8673 struct bfd_link_info
*link_info
,
8674 struct bfd_link_order
*link_order
,
8676 bfd_boolean relocatable
,
8679 /* Get enough memory to hold the stuff */
8680 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8681 asection
*input_section
= link_order
->u
.indirect
.section
;
8684 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8685 arelent
**reloc_vector
= NULL
;
8691 reloc_vector
= bfd_malloc (reloc_size
);
8692 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8695 /* read in the section */
8696 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
8697 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
8700 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8704 if (reloc_count
< 0)
8707 if (reloc_count
> 0)
8712 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8715 struct bfd_hash_entry
*h
;
8716 struct bfd_link_hash_entry
*lh
;
8717 /* Skip all this stuff if we aren't mixing formats. */
8718 if (abfd
&& input_bfd
8719 && abfd
->xvec
== input_bfd
->xvec
)
8723 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8724 lh
= (struct bfd_link_hash_entry
*) h
;
8731 case bfd_link_hash_undefined
:
8732 case bfd_link_hash_undefweak
:
8733 case bfd_link_hash_common
:
8736 case bfd_link_hash_defined
:
8737 case bfd_link_hash_defweak
:
8739 gp
= lh
->u
.def
.value
;
8741 case bfd_link_hash_indirect
:
8742 case bfd_link_hash_warning
:
8744 /* @@FIXME ignoring warning for now */
8746 case bfd_link_hash_new
:
8755 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8757 char *error_message
= NULL
;
8758 bfd_reloc_status_type r
;
8760 /* Specific to MIPS: Deal with relocation types that require
8761 knowing the gp of the output bfd. */
8762 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8764 /* If we've managed to find the gp and have a special
8765 function for the relocation then go ahead, else default
8766 to the generic handling. */
8768 && (*parent
)->howto
->special_function
8769 == _bfd_mips_elf32_gprel16_reloc
)
8770 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8771 input_section
, relocatable
,
8774 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
8776 relocatable
? abfd
: NULL
,
8781 asection
*os
= input_section
->output_section
;
8783 /* A partial link, so keep the relocs */
8784 os
->orelocation
[os
->reloc_count
] = *parent
;
8788 if (r
!= bfd_reloc_ok
)
8792 case bfd_reloc_undefined
:
8793 if (!((*link_info
->callbacks
->undefined_symbol
)
8794 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8795 input_bfd
, input_section
, (*parent
)->address
,
8799 case bfd_reloc_dangerous
:
8800 BFD_ASSERT (error_message
!= NULL
);
8801 if (!((*link_info
->callbacks
->reloc_dangerous
)
8802 (link_info
, error_message
, input_bfd
, input_section
,
8803 (*parent
)->address
)))
8806 case bfd_reloc_overflow
:
8807 if (!((*link_info
->callbacks
->reloc_overflow
)
8809 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8810 (*parent
)->howto
->name
, (*parent
)->addend
,
8811 input_bfd
, input_section
, (*parent
)->address
)))
8814 case bfd_reloc_outofrange
:
8823 if (reloc_vector
!= NULL
)
8824 free (reloc_vector
);
8828 if (reloc_vector
!= NULL
)
8829 free (reloc_vector
);
8833 /* Create a MIPS ELF linker hash table. */
8835 struct bfd_link_hash_table
*
8836 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8838 struct mips_elf_link_hash_table
*ret
;
8839 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8841 ret
= bfd_malloc (amt
);
8845 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8846 mips_elf_link_hash_newfunc
))
8853 /* We no longer use this. */
8854 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8855 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8857 ret
->procedure_count
= 0;
8858 ret
->compact_rel_size
= 0;
8859 ret
->use_rld_obj_head
= FALSE
;
8861 ret
->mips16_stubs_seen
= FALSE
;
8863 return &ret
->root
.root
;
8866 /* We need to use a special link routine to handle the .reginfo and
8867 the .mdebug sections. We need to merge all instances of these
8868 sections together, not write them all out sequentially. */
8871 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8874 struct bfd_link_order
*p
;
8875 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8876 asection
*rtproc_sec
;
8877 Elf32_RegInfo reginfo
;
8878 struct ecoff_debug_info debug
;
8879 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8880 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
8881 HDRR
*symhdr
= &debug
.symbolic_header
;
8882 void *mdebug_handle
= NULL
;
8888 static const char * const secname
[] =
8890 ".text", ".init", ".fini", ".data",
8891 ".rodata", ".sdata", ".sbss", ".bss"
8893 static const int sc
[] =
8895 scText
, scInit
, scFini
, scData
,
8896 scRData
, scSData
, scSBss
, scBss
8899 /* We'd carefully arranged the dynamic symbol indices, and then the
8900 generic size_dynamic_sections renumbered them out from under us.
8901 Rather than trying somehow to prevent the renumbering, just do
8903 if (elf_hash_table (info
)->dynamic_sections_created
)
8907 struct mips_got_info
*g
;
8908 bfd_size_type dynsecsymcount
;
8910 /* When we resort, we must tell mips_elf_sort_hash_table what
8911 the lowest index it may use is. That's the number of section
8912 symbols we're going to add. The generic ELF linker only
8913 adds these symbols when building a shared object. Note that
8914 we count the sections after (possibly) removing the .options
8922 for (p
= abfd
->sections
; p
; p
= p
->next
)
8923 if ((p
->flags
& SEC_EXCLUDE
) == 0
8924 && (p
->flags
& SEC_ALLOC
) != 0
8925 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
8929 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
8932 /* Make sure we didn't grow the global .got region. */
8933 dynobj
= elf_hash_table (info
)->dynobj
;
8934 got
= mips_elf_got_section (dynobj
, FALSE
);
8935 g
= mips_elf_section_data (got
)->u
.got_info
;
8937 if (g
->global_gotsym
!= NULL
)
8938 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8939 - g
->global_gotsym
->dynindx
)
8940 <= g
->global_gotno
);
8943 /* Get a value for the GP register. */
8944 if (elf_gp (abfd
) == 0)
8946 struct bfd_link_hash_entry
*h
;
8948 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8949 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8950 elf_gp (abfd
) = (h
->u
.def
.value
8951 + h
->u
.def
.section
->output_section
->vma
8952 + h
->u
.def
.section
->output_offset
);
8953 else if (info
->relocatable
)
8955 bfd_vma lo
= MINUS_ONE
;
8957 /* Find the GP-relative section with the lowest offset. */
8958 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8960 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8963 /* And calculate GP relative to that. */
8964 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8968 /* If the relocate_section function needs to do a reloc
8969 involving the GP value, it should make a reloc_dangerous
8970 callback to warn that GP is not defined. */
8974 /* Go through the sections and collect the .reginfo and .mdebug
8978 gptab_data_sec
= NULL
;
8979 gptab_bss_sec
= NULL
;
8980 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8982 if (strcmp (o
->name
, ".reginfo") == 0)
8984 memset (®info
, 0, sizeof reginfo
);
8986 /* We have found the .reginfo section in the output file.
8987 Look through all the link_orders comprising it and merge
8988 the information together. */
8989 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8991 asection
*input_section
;
8993 Elf32_External_RegInfo ext
;
8996 if (p
->type
!= bfd_indirect_link_order
)
8998 if (p
->type
== bfd_data_link_order
)
9003 input_section
= p
->u
.indirect
.section
;
9004 input_bfd
= input_section
->owner
;
9006 if (! bfd_get_section_contents (input_bfd
, input_section
,
9007 &ext
, 0, sizeof ext
))
9010 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
9012 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
9013 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
9014 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
9015 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
9016 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
9018 /* ri_gp_value is set by the function
9019 mips_elf32_section_processing when the section is
9020 finally written out. */
9022 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9023 elf_link_input_bfd ignores this section. */
9024 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9027 /* Size has been set in _bfd_mips_elf_always_size_sections. */
9028 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
9030 /* Skip this section later on (I don't think this currently
9031 matters, but someday it might). */
9032 o
->link_order_head
= NULL
;
9037 if (strcmp (o
->name
, ".mdebug") == 0)
9039 struct extsym_info einfo
;
9042 /* We have found the .mdebug section in the output file.
9043 Look through all the link_orders comprising it and merge
9044 the information together. */
9045 symhdr
->magic
= swap
->sym_magic
;
9046 /* FIXME: What should the version stamp be? */
9048 symhdr
->ilineMax
= 0;
9052 symhdr
->isymMax
= 0;
9053 symhdr
->ioptMax
= 0;
9054 symhdr
->iauxMax
= 0;
9056 symhdr
->issExtMax
= 0;
9059 symhdr
->iextMax
= 0;
9061 /* We accumulate the debugging information itself in the
9062 debug_info structure. */
9064 debug
.external_dnr
= NULL
;
9065 debug
.external_pdr
= NULL
;
9066 debug
.external_sym
= NULL
;
9067 debug
.external_opt
= NULL
;
9068 debug
.external_aux
= NULL
;
9070 debug
.ssext
= debug
.ssext_end
= NULL
;
9071 debug
.external_fdr
= NULL
;
9072 debug
.external_rfd
= NULL
;
9073 debug
.external_ext
= debug
.external_ext_end
= NULL
;
9075 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
9076 if (mdebug_handle
== NULL
)
9080 esym
.cobol_main
= 0;
9084 esym
.asym
.iss
= issNil
;
9085 esym
.asym
.st
= stLocal
;
9086 esym
.asym
.reserved
= 0;
9087 esym
.asym
.index
= indexNil
;
9089 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
9091 esym
.asym
.sc
= sc
[i
];
9092 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
9095 esym
.asym
.value
= s
->vma
;
9096 last
= s
->vma
+ s
->size
;
9099 esym
.asym
.value
= last
;
9100 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
9105 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9107 asection
*input_section
;
9109 const struct ecoff_debug_swap
*input_swap
;
9110 struct ecoff_debug_info input_debug
;
9114 if (p
->type
!= bfd_indirect_link_order
)
9116 if (p
->type
== bfd_data_link_order
)
9121 input_section
= p
->u
.indirect
.section
;
9122 input_bfd
= input_section
->owner
;
9124 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
9125 || (get_elf_backend_data (input_bfd
)
9126 ->elf_backend_ecoff_debug_swap
) == NULL
)
9128 /* I don't know what a non MIPS ELF bfd would be
9129 doing with a .mdebug section, but I don't really
9130 want to deal with it. */
9134 input_swap
= (get_elf_backend_data (input_bfd
)
9135 ->elf_backend_ecoff_debug_swap
);
9137 BFD_ASSERT (p
->size
== input_section
->size
);
9139 /* The ECOFF linking code expects that we have already
9140 read in the debugging information and set up an
9141 ecoff_debug_info structure, so we do that now. */
9142 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
9146 if (! (bfd_ecoff_debug_accumulate
9147 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
9148 &input_debug
, input_swap
, info
)))
9151 /* Loop through the external symbols. For each one with
9152 interesting information, try to find the symbol in
9153 the linker global hash table and save the information
9154 for the output external symbols. */
9155 eraw_src
= input_debug
.external_ext
;
9156 eraw_end
= (eraw_src
9157 + (input_debug
.symbolic_header
.iextMax
9158 * input_swap
->external_ext_size
));
9160 eraw_src
< eraw_end
;
9161 eraw_src
+= input_swap
->external_ext_size
)
9165 struct mips_elf_link_hash_entry
*h
;
9167 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
9168 if (ext
.asym
.sc
== scNil
9169 || ext
.asym
.sc
== scUndefined
9170 || ext
.asym
.sc
== scSUndefined
)
9173 name
= input_debug
.ssext
+ ext
.asym
.iss
;
9174 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
9175 name
, FALSE
, FALSE
, TRUE
);
9176 if (h
== NULL
|| h
->esym
.ifd
!= -2)
9182 < input_debug
.symbolic_header
.ifdMax
);
9183 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
9189 /* Free up the information we just read. */
9190 free (input_debug
.line
);
9191 free (input_debug
.external_dnr
);
9192 free (input_debug
.external_pdr
);
9193 free (input_debug
.external_sym
);
9194 free (input_debug
.external_opt
);
9195 free (input_debug
.external_aux
);
9196 free (input_debug
.ss
);
9197 free (input_debug
.ssext
);
9198 free (input_debug
.external_fdr
);
9199 free (input_debug
.external_rfd
);
9200 free (input_debug
.external_ext
);
9202 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9203 elf_link_input_bfd ignores this section. */
9204 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9207 if (SGI_COMPAT (abfd
) && info
->shared
)
9209 /* Create .rtproc section. */
9210 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
9211 if (rtproc_sec
== NULL
)
9213 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
9214 | SEC_LINKER_CREATED
| SEC_READONLY
);
9216 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
9217 if (rtproc_sec
== NULL
9218 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
9219 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
9223 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
9229 /* Build the external symbol information. */
9232 einfo
.debug
= &debug
;
9234 einfo
.failed
= FALSE
;
9235 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
9236 mips_elf_output_extsym
, &einfo
);
9240 /* Set the size of the .mdebug section. */
9241 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
9243 /* Skip this section later on (I don't think this currently
9244 matters, but someday it might). */
9245 o
->link_order_head
= NULL
;
9250 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
9252 const char *subname
;
9255 Elf32_External_gptab
*ext_tab
;
9258 /* The .gptab.sdata and .gptab.sbss sections hold
9259 information describing how the small data area would
9260 change depending upon the -G switch. These sections
9261 not used in executables files. */
9262 if (! info
->relocatable
)
9264 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9266 asection
*input_section
;
9268 if (p
->type
!= bfd_indirect_link_order
)
9270 if (p
->type
== bfd_data_link_order
)
9275 input_section
= p
->u
.indirect
.section
;
9277 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9278 elf_link_input_bfd ignores this section. */
9279 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9282 /* Skip this section later on (I don't think this
9283 currently matters, but someday it might). */
9284 o
->link_order_head
= NULL
;
9286 /* Really remove the section. */
9287 bfd_section_list_remove (abfd
, o
);
9288 --abfd
->section_count
;
9293 /* There is one gptab for initialized data, and one for
9294 uninitialized data. */
9295 if (strcmp (o
->name
, ".gptab.sdata") == 0)
9297 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
9301 (*_bfd_error_handler
)
9302 (_("%s: illegal section name `%s'"),
9303 bfd_get_filename (abfd
), o
->name
);
9304 bfd_set_error (bfd_error_nonrepresentable_section
);
9308 /* The linker script always combines .gptab.data and
9309 .gptab.sdata into .gptab.sdata, and likewise for
9310 .gptab.bss and .gptab.sbss. It is possible that there is
9311 no .sdata or .sbss section in the output file, in which
9312 case we must change the name of the output section. */
9313 subname
= o
->name
+ sizeof ".gptab" - 1;
9314 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
9316 if (o
== gptab_data_sec
)
9317 o
->name
= ".gptab.data";
9319 o
->name
= ".gptab.bss";
9320 subname
= o
->name
+ sizeof ".gptab" - 1;
9321 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
9324 /* Set up the first entry. */
9326 amt
= c
* sizeof (Elf32_gptab
);
9327 tab
= bfd_malloc (amt
);
9330 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
9331 tab
[0].gt_header
.gt_unused
= 0;
9333 /* Combine the input sections. */
9334 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
9336 asection
*input_section
;
9340 bfd_size_type gpentry
;
9342 if (p
->type
!= bfd_indirect_link_order
)
9344 if (p
->type
== bfd_data_link_order
)
9349 input_section
= p
->u
.indirect
.section
;
9350 input_bfd
= input_section
->owner
;
9352 /* Combine the gptab entries for this input section one
9353 by one. We know that the input gptab entries are
9354 sorted by ascending -G value. */
9355 size
= input_section
->size
;
9357 for (gpentry
= sizeof (Elf32_External_gptab
);
9359 gpentry
+= sizeof (Elf32_External_gptab
))
9361 Elf32_External_gptab ext_gptab
;
9362 Elf32_gptab int_gptab
;
9368 if (! (bfd_get_section_contents
9369 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
9370 sizeof (Elf32_External_gptab
))))
9376 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
9378 val
= int_gptab
.gt_entry
.gt_g_value
;
9379 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
9382 for (look
= 1; look
< c
; look
++)
9384 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
9385 tab
[look
].gt_entry
.gt_bytes
+= add
;
9387 if (tab
[look
].gt_entry
.gt_g_value
== val
)
9393 Elf32_gptab
*new_tab
;
9396 /* We need a new table entry. */
9397 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
9398 new_tab
= bfd_realloc (tab
, amt
);
9399 if (new_tab
== NULL
)
9405 tab
[c
].gt_entry
.gt_g_value
= val
;
9406 tab
[c
].gt_entry
.gt_bytes
= add
;
9408 /* Merge in the size for the next smallest -G
9409 value, since that will be implied by this new
9412 for (look
= 1; look
< c
; look
++)
9414 if (tab
[look
].gt_entry
.gt_g_value
< val
9416 || (tab
[look
].gt_entry
.gt_g_value
9417 > tab
[max
].gt_entry
.gt_g_value
)))
9421 tab
[c
].gt_entry
.gt_bytes
+=
9422 tab
[max
].gt_entry
.gt_bytes
;
9427 last
= int_gptab
.gt_entry
.gt_bytes
;
9430 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9431 elf_link_input_bfd ignores this section. */
9432 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
9435 /* The table must be sorted by -G value. */
9437 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
9439 /* Swap out the table. */
9440 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
9441 ext_tab
= bfd_alloc (abfd
, amt
);
9442 if (ext_tab
== NULL
)
9448 for (j
= 0; j
< c
; j
++)
9449 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
9452 o
->size
= c
* sizeof (Elf32_External_gptab
);
9453 o
->contents
= (bfd_byte
*) ext_tab
;
9455 /* Skip this section later on (I don't think this currently
9456 matters, but someday it might). */
9457 o
->link_order_head
= NULL
;
9461 /* Invoke the regular ELF backend linker to do all the work. */
9462 if (!bfd_elf_final_link (abfd
, info
))
9465 /* Now write out the computed sections. */
9467 if (reginfo_sec
!= NULL
)
9469 Elf32_External_RegInfo ext
;
9471 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
9472 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
9476 if (mdebug_sec
!= NULL
)
9478 BFD_ASSERT (abfd
->output_has_begun
);
9479 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
9481 mdebug_sec
->filepos
))
9484 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
9487 if (gptab_data_sec
!= NULL
)
9489 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
9490 gptab_data_sec
->contents
,
9491 0, gptab_data_sec
->size
))
9495 if (gptab_bss_sec
!= NULL
)
9497 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
9498 gptab_bss_sec
->contents
,
9499 0, gptab_bss_sec
->size
))
9503 if (SGI_COMPAT (abfd
))
9505 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
9506 if (rtproc_sec
!= NULL
)
9508 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
9509 rtproc_sec
->contents
,
9510 0, rtproc_sec
->size
))
9518 /* Structure for saying that BFD machine EXTENSION extends BASE. */
9520 struct mips_mach_extension
{
9521 unsigned long extension
, base
;
9525 /* An array describing how BFD machines relate to one another. The entries
9526 are ordered topologically with MIPS I extensions listed last. */
9528 static const struct mips_mach_extension mips_mach_extensions
[] = {
9529 /* MIPS64 extensions. */
9530 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
9531 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
9533 /* MIPS V extensions. */
9534 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
9536 /* R10000 extensions. */
9537 { bfd_mach_mips12000
, bfd_mach_mips10000
},
9539 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
9540 vr5400 ISA, but doesn't include the multimedia stuff. It seems
9541 better to allow vr5400 and vr5500 code to be merged anyway, since
9542 many libraries will just use the core ISA. Perhaps we could add
9543 some sort of ASE flag if this ever proves a problem. */
9544 { bfd_mach_mips5500
, bfd_mach_mips5400
},
9545 { bfd_mach_mips5400
, bfd_mach_mips5000
},
9547 /* MIPS IV extensions. */
9548 { bfd_mach_mips5
, bfd_mach_mips8000
},
9549 { bfd_mach_mips10000
, bfd_mach_mips8000
},
9550 { bfd_mach_mips5000
, bfd_mach_mips8000
},
9551 { bfd_mach_mips7000
, bfd_mach_mips8000
},
9552 { bfd_mach_mips9000
, bfd_mach_mips8000
},
9554 /* VR4100 extensions. */
9555 { bfd_mach_mips4120
, bfd_mach_mips4100
},
9556 { bfd_mach_mips4111
, bfd_mach_mips4100
},
9558 /* MIPS III extensions. */
9559 { bfd_mach_mips8000
, bfd_mach_mips4000
},
9560 { bfd_mach_mips4650
, bfd_mach_mips4000
},
9561 { bfd_mach_mips4600
, bfd_mach_mips4000
},
9562 { bfd_mach_mips4400
, bfd_mach_mips4000
},
9563 { bfd_mach_mips4300
, bfd_mach_mips4000
},
9564 { bfd_mach_mips4100
, bfd_mach_mips4000
},
9565 { bfd_mach_mips4010
, bfd_mach_mips4000
},
9567 /* MIPS32 extensions. */
9568 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
9570 /* MIPS II extensions. */
9571 { bfd_mach_mips4000
, bfd_mach_mips6000
},
9572 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
9574 /* MIPS I extensions. */
9575 { bfd_mach_mips6000
, bfd_mach_mips3000
},
9576 { bfd_mach_mips3900
, bfd_mach_mips3000
}
9580 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
9583 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
9587 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
9588 if (extension
== mips_mach_extensions
[i
].extension
)
9589 extension
= mips_mach_extensions
[i
].base
;
9591 return extension
== base
;
9595 /* Return true if the given ELF header flags describe a 32-bit binary. */
9598 mips_32bit_flags_p (flagword flags
)
9600 return ((flags
& EF_MIPS_32BITMODE
) != 0
9601 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
9602 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
9603 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
9604 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
9605 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
9606 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
9610 /* Merge backend specific data from an object file to the output
9611 object file when linking. */
9614 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
9619 bfd_boolean null_input_bfd
= TRUE
;
9622 /* Check if we have the same endianess */
9623 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
9625 (*_bfd_error_handler
)
9626 (_("%B: endianness incompatible with that of the selected emulation"),
9631 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9632 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9635 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9637 (*_bfd_error_handler
)
9638 (_("%B: ABI is incompatible with that of the selected emulation"),
9643 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9644 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9645 old_flags
= elf_elfheader (obfd
)->e_flags
;
9647 if (! elf_flags_init (obfd
))
9649 elf_flags_init (obfd
) = TRUE
;
9650 elf_elfheader (obfd
)->e_flags
= new_flags
;
9651 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9652 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9654 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9655 && bfd_get_arch_info (obfd
)->the_default
)
9657 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9658 bfd_get_mach (ibfd
)))
9665 /* Check flag compatibility. */
9667 new_flags
&= ~EF_MIPS_NOREORDER
;
9668 old_flags
&= ~EF_MIPS_NOREORDER
;
9670 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9671 doesn't seem to matter. */
9672 new_flags
&= ~EF_MIPS_XGOT
;
9673 old_flags
&= ~EF_MIPS_XGOT
;
9675 /* MIPSpro generates ucode info in n64 objects. Again, we should
9676 just be able to ignore this. */
9677 new_flags
&= ~EF_MIPS_UCODE
;
9678 old_flags
&= ~EF_MIPS_UCODE
;
9680 if (new_flags
== old_flags
)
9683 /* Check to see if the input BFD actually contains any sections.
9684 If not, its flags may not have been initialised either, but it cannot
9685 actually cause any incompatibility. */
9686 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9688 /* Ignore synthetic sections and empty .text, .data and .bss sections
9689 which are automatically generated by gas. */
9690 if (strcmp (sec
->name
, ".reginfo")
9691 && strcmp (sec
->name
, ".mdebug")
9693 || (strcmp (sec
->name
, ".text")
9694 && strcmp (sec
->name
, ".data")
9695 && strcmp (sec
->name
, ".bss"))))
9697 null_input_bfd
= FALSE
;
9706 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9707 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9709 (*_bfd_error_handler
)
9710 (_("%B: warning: linking PIC files with non-PIC files"),
9715 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9716 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9717 if (! (new_flags
& EF_MIPS_PIC
))
9718 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9720 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9721 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9723 /* Compare the ISAs. */
9724 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9726 (*_bfd_error_handler
)
9727 (_("%B: linking 32-bit code with 64-bit code"),
9731 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9733 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9734 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9736 /* Copy the architecture info from IBFD to OBFD. Also copy
9737 the 32-bit flag (if set) so that we continue to recognise
9738 OBFD as a 32-bit binary. */
9739 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9740 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9741 elf_elfheader (obfd
)->e_flags
9742 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9744 /* Copy across the ABI flags if OBFD doesn't use them
9745 and if that was what caused us to treat IBFD as 32-bit. */
9746 if ((old_flags
& EF_MIPS_ABI
) == 0
9747 && mips_32bit_flags_p (new_flags
)
9748 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9749 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9753 /* The ISAs aren't compatible. */
9754 (*_bfd_error_handler
)
9755 (_("%B: linking %s module with previous %s modules"),
9757 bfd_printable_name (ibfd
),
9758 bfd_printable_name (obfd
));
9763 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9764 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9766 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9767 does set EI_CLASS differently from any 32-bit ABI. */
9768 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9769 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9770 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9772 /* Only error if both are set (to different values). */
9773 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9774 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9775 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9777 (*_bfd_error_handler
)
9778 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9780 elf_mips_abi_name (ibfd
),
9781 elf_mips_abi_name (obfd
));
9784 new_flags
&= ~EF_MIPS_ABI
;
9785 old_flags
&= ~EF_MIPS_ABI
;
9788 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9789 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9791 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9793 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9794 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9797 /* Warn about any other mismatches */
9798 if (new_flags
!= old_flags
)
9800 (*_bfd_error_handler
)
9801 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9802 ibfd
, (unsigned long) new_flags
,
9803 (unsigned long) old_flags
);
9809 bfd_set_error (bfd_error_bad_value
);
9816 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9819 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9821 BFD_ASSERT (!elf_flags_init (abfd
)
9822 || elf_elfheader (abfd
)->e_flags
== flags
);
9824 elf_elfheader (abfd
)->e_flags
= flags
;
9825 elf_flags_init (abfd
) = TRUE
;
9830 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9834 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9836 /* Print normal ELF private data. */
9837 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9839 /* xgettext:c-format */
9840 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9842 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9843 fprintf (file
, _(" [abi=O32]"));
9844 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9845 fprintf (file
, _(" [abi=O64]"));
9846 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9847 fprintf (file
, _(" [abi=EABI32]"));
9848 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9849 fprintf (file
, _(" [abi=EABI64]"));
9850 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9851 fprintf (file
, _(" [abi unknown]"));
9852 else if (ABI_N32_P (abfd
))
9853 fprintf (file
, _(" [abi=N32]"));
9854 else if (ABI_64_P (abfd
))
9855 fprintf (file
, _(" [abi=64]"));
9857 fprintf (file
, _(" [no abi set]"));
9859 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9860 fprintf (file
, _(" [mips1]"));
9861 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9862 fprintf (file
, _(" [mips2]"));
9863 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9864 fprintf (file
, _(" [mips3]"));
9865 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9866 fprintf (file
, _(" [mips4]"));
9867 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9868 fprintf (file
, _(" [mips5]"));
9869 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9870 fprintf (file
, _(" [mips32]"));
9871 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9872 fprintf (file
, _(" [mips64]"));
9873 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9874 fprintf (file
, _(" [mips32r2]"));
9875 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9876 fprintf (file
, _(" [mips64r2]"));
9878 fprintf (file
, _(" [unknown ISA]"));
9880 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9881 fprintf (file
, _(" [mdmx]"));
9883 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9884 fprintf (file
, _(" [mips16]"));
9886 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9887 fprintf (file
, _(" [32bitmode]"));
9889 fprintf (file
, _(" [not 32bitmode]"));
9896 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9898 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9899 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9900 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9901 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9902 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9903 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9904 { NULL
, 0, 0, 0, 0 }