1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry *h;
68 /* The TLS types included in this GOT entry (specifically, GD and
69 IE). The GD and IE flags can be added as we encounter new
70 relocations. LDM can also be set; it will always be alone, not
71 combined with any GD or IE flags. An LDM GOT entry will be
72 a local symbol entry with r_symndx == 0. */
73 unsigned char tls_type;
75 /* The offset from the beginning of the .got section to the entry
76 corresponding to this symbol+addend. If it's a global symbol
77 whose offset is yet to be decided, it's going to be -1. */
81 /* This structure is used to hold .got information when linking. */
85 /* The global symbol in the GOT with the lowest index in the dynamic
87 struct elf_link_hash_entry *global_gotsym;
88 /* The number of global .got entries. */
89 unsigned int global_gotno;
90 /* The number of .got slots used for TLS. */
91 unsigned int tls_gotno;
92 /* The first unused TLS .got entry. Used only during
93 mips_elf_initialize_tls_index. */
94 unsigned int tls_assigned_gotno;
95 /* The number of local .got entries. */
96 unsigned int local_gotno;
97 /* The number of local .got entries we have used. */
98 unsigned int assigned_gotno;
99 /* A hash table holding members of the got. */
100 struct htab *got_entries;
101 /* A hash table mapping input bfds to other mips_got_info. NULL
102 unless multi-got was necessary. */
103 struct htab *bfd2got;
104 /* In multi-got links, a pointer to the next got (err, rather, most
105 of the time, it points to the previous got). */
106 struct mips_got_info *next;
107 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
108 for none, or MINUS_TWO for not yet assigned. This is needed
109 because a single-GOT link may have multiple hash table entries
110 for the LDM. It does not get initialized in multi-GOT mode. */
111 bfd_vma tls_ldm_offset;
114 /* Map an input bfd to a got in a multi-got link. */
116 struct mips_elf_bfd2got_hash {
118 struct mips_got_info *g;
121 /* Structure passed when traversing the bfd2got hash table, used to
122 create and merge bfd's gots. */
124 struct mips_elf_got_per_bfd_arg
126 /* A hashtable that maps bfds to gots. */
128 /* The output bfd. */
130 /* The link information. */
131 struct bfd_link_info *info;
132 /* A pointer to the primary got, i.e., the one that's going to get
133 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
135 struct mips_got_info *primary;
136 /* A non-primary got we're trying to merge with other input bfd's
138 struct mips_got_info *current;
139 /* The maximum number of got entries that can be addressed with a
141 unsigned int max_count;
142 /* The number of local and global entries in the primary got. */
143 unsigned int primary_count;
144 /* The number of local and global entries in the current got. */
145 unsigned int current_count;
146 /* The total number of global entries which will live in the
147 primary got and be automatically relocated. This includes
148 those not referenced by the primary GOT but included in
150 unsigned int global_count;
153 /* Another structure used to pass arguments for got entries traversal. */
155 struct mips_elf_set_global_got_offset_arg
157 struct mips_got_info *g;
159 unsigned int needed_relocs;
160 struct bfd_link_info *info;
163 /* A structure used to count TLS relocations or GOT entries, for GOT
164 entry or ELF symbol table traversal. */
166 struct mips_elf_count_tls_arg
168 struct bfd_link_info *info;
172 struct _mips_elf_section_data
174 struct bfd_elf_section_data elf;
177 struct mips_got_info *got_info;
182 #define mips_elf_section_data(sec) \
183 ((struct _mips_elf_section_data *) elf_section_data (sec))
185 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
186 the dynamic symbols. */
188 struct mips_elf_hash_sort_data
190 /* The symbol in the global GOT with the lowest dynamic symbol table
192 struct elf_link_hash_entry *low;
193 /* The least dynamic symbol table index corresponding to a non-TLS
194 symbol with a GOT entry. */
195 long min_got_dynindx;
196 /* The greatest dynamic symbol table index corresponding to a symbol
197 with a GOT entry that is not referenced (e.g., a dynamic symbol
198 with dynamic relocations pointing to it from non-primary GOTs). */
199 long max_unref_got_dynindx;
200 /* The greatest dynamic symbol table index not corresponding to a
201 symbol without a GOT entry. */
202 long max_non_got_dynindx;
205 /* The MIPS ELF linker needs additional information for each symbol in
206 the global hash table. */
208 struct mips_elf_link_hash_entry
210 struct elf_link_hash_entry root;
212 /* External symbol information. */
215 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
217 unsigned int possibly_dynamic_relocs;
219 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
220 a readonly section. */
221 bfd_boolean readonly_reloc;
223 /* We must not create a stub for a symbol that has relocations
224 related to taking the function's address, i.e. any but
225 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
227 bfd_boolean no_fn_stub;
229 /* If there is a stub that 32 bit functions should use to call this
230 16 bit function, this points to the section containing the stub. */
233 /* Whether we need the fn_stub; this is set if this symbol appears
234 in any relocs other than a 16 bit call. */
235 bfd_boolean need_fn_stub;
237 /* If there is a stub that 16 bit functions should use to call this
238 32 bit function, this points to the section containing the stub. */
241 /* This is like the call_stub field, but it is used if the function
242 being called returns a floating point value. */
243 asection *call_fp_stub;
245 /* Are we forced local? .*/
246 bfd_boolean forced_local;
250 #define GOT_TLS_LDM 2
252 #define GOT_TLS_OFFSET_DONE 0x40
253 #define GOT_TLS_DONE 0x80
254 unsigned char tls_type;
255 /* This is only used in single-GOT mode; in multi-GOT mode there
256 is one mips_got_entry per GOT entry, so the offset is stored
257 there. In single-GOT mode there may be many mips_got_entry
258 structures all referring to the same GOT slot. It might be
259 possible to use root.got.offset instead, but that field is
260 overloaded already. */
261 bfd_vma tls_got_offset;
264 /* MIPS ELF linker hash table. */
266 struct mips_elf_link_hash_table
268 struct elf_link_hash_table root;
270 /* We no longer use this. */
271 /* String section indices for the dynamic section symbols. */
272 bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
274 /* The number of .rtproc entries. */
275 bfd_size_type procedure_count;
276 /* The size of the .compact_rel section (if SGI_COMPAT). */
277 bfd_size_type compact_rel_size;
278 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
279 entry is set to the address of __rld_obj_head as in IRIX5. */
280 bfd_boolean use_rld_obj_head;
281 /* This is the value of the __rld_map or __rld_obj_head symbol. */
283 /* This is set if we see any mips16 stub sections. */
284 bfd_boolean mips16_stubs_seen;
287 #define TLS_RELOC_P(r_type) \
288 (r_type == R_MIPS_TLS_DTPMOD32 \
289 || r_type == R_MIPS_TLS_DTPMOD64 \
290 || r_type == R_MIPS_TLS_DTPREL32 \
291 || r_type == R_MIPS_TLS_DTPREL64 \
292 || r_type == R_MIPS_TLS_GD \
293 || r_type == R_MIPS_TLS_LDM \
294 || r_type == R_MIPS_TLS_DTPREL_HI16 \
295 || r_type == R_MIPS_TLS_DTPREL_LO16 \
296 || r_type == R_MIPS_TLS_GOTTPREL \
297 || r_type == R_MIPS_TLS_TPREL32 \
298 || r_type == R_MIPS_TLS_TPREL64 \
299 || r_type == R_MIPS_TLS_TPREL_HI16 \
300 || r_type == R_MIPS_TLS_TPREL_LO16)
302 /* Structure used to pass information to mips_elf_output_extsym. */
307 struct bfd_link_info *info;
308 struct ecoff_debug_info *debug;
309 const struct ecoff_debug_swap *swap;
313 /* The names of the runtime procedure table symbols used on IRIX5. */
315 static const char * const mips_elf_dynsym_rtproc_names[] =
318 "_procedure_string_table",
319 "_procedure_table_size",
323 /* These structures are used to generate the .compact_rel section on
328 unsigned long id1; /* Always one? */
329 unsigned long num; /* Number of compact relocation entries. */
330 unsigned long id2; /* Always two? */
331 unsigned long offset; /* The file offset of the first relocation. */
332 unsigned long reserved0; /* Zero? */
333 unsigned long reserved1; /* Zero? */
342 bfd_byte reserved0[4];
343 bfd_byte reserved1[4];
344 } Elf32_External_compact_rel;
348 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
349 unsigned int rtype : 4; /* Relocation types. See below. */
350 unsigned int dist2to : 8;
351 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
352 unsigned long konst; /* KONST field. See below. */
353 unsigned long vaddr; /* VADDR to be relocated. */
358 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
359 unsigned int rtype : 4; /* Relocation types. See below. */
360 unsigned int dist2to : 8;
361 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
362 unsigned long konst; /* KONST field. See below. */
370 } Elf32_External_crinfo;
376 } Elf32_External_crinfo2;
378 /* These are the constants used to swap the bitfields in a crinfo. */
380 #define CRINFO_CTYPE (0x1)
381 #define CRINFO_CTYPE_SH (31)
382 #define CRINFO_RTYPE (0xf)
383 #define CRINFO_RTYPE_SH (27)
384 #define CRINFO_DIST2TO (0xff)
385 #define CRINFO_DIST2TO_SH (19)
386 #define CRINFO_RELVADDR (0x7ffff)
387 #define CRINFO_RELVADDR_SH (0)
389 /* A compact relocation info has long (3 words) or short (2 words)
390 formats. A short format doesn't have VADDR field and relvaddr
391 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
392 #define CRF_MIPS_LONG 1
393 #define CRF_MIPS_SHORT 0
395 /* There are 4 types of compact relocation at least. The value KONST
396 has different meaning for each type:
399 CT_MIPS_REL32 Address in data
400 CT_MIPS_WORD Address in word (XXX)
401 CT_MIPS_GPHI_LO GP - vaddr
402 CT_MIPS_JMPAD Address to jump
405 #define CRT_MIPS_REL32 0xa
406 #define CRT_MIPS_WORD 0xb
407 #define CRT_MIPS_GPHI_LO 0xc
408 #define CRT_MIPS_JMPAD 0xd
410 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
411 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
412 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
413 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
415 /* The structure of the runtime procedure descriptor created by the
416 loader for use by the static exception system. */
418 typedef struct runtime_pdr {
419 bfd_vma adr; /* Memory address of start of procedure. */
420 long regmask; /* Save register mask. */
421 long regoffset; /* Save register offset. */
422 long fregmask; /* Save floating point register mask. */
423 long fregoffset; /* Save floating point register offset. */
424 long frameoffset; /* Frame size. */
425 short framereg; /* Frame pointer register. */
426 short pcreg; /* Offset or reg of return pc. */
427 long irpss; /* Index into the runtime string table. */
429 struct exception_info *exception_info;/* Pointer to exception array. */
431 #define cbRPDR sizeof (RPDR)
432 #define rpdNil ((pRPDR) 0)
434 static struct mips_got_entry *mips_elf_create_local_got_entry
435 (bfd *, bfd *, struct mips_got_info *, asection *, bfd_vma, unsigned long,
436 struct mips_elf_link_hash_entry *, int);
437 static bfd_boolean mips_elf_sort_hash_table_f
438 (struct mips_elf_link_hash_entry *, void *);
439 static bfd_vma mips_elf_high
441 static bfd_boolean mips_elf_stub_section_p
443 static bfd_boolean mips_elf_create_dynamic_relocation
444 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
445 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
446 bfd_vma *, asection *);
447 static hashval_t mips_elf_got_entry_hash
449 static bfd_vma mips_elf_adjust_gp
450 (bfd *, struct mips_got_info *, bfd *);
451 static struct mips_got_info *mips_elf_got_for_ibfd
452 (struct mips_got_info *, bfd *);
454 /* This will be used when we sort the dynamic relocation records. */
455 static bfd *reldyn_sorting_bfd;
457 /* Nonzero if ABFD is using the N32 ABI. */
459 #define ABI_N32_P(abfd) \
460 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
462 /* Nonzero if ABFD is using the N64 ABI. */
463 #define ABI_64_P(abfd) \
464 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
466 /* Nonzero if ABFD is using NewABI conventions. */
467 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
469 /* The IRIX compatibility level we are striving for. */
470 #define IRIX_COMPAT(abfd) \
471 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
473 /* Whether we are trying to be compatible with IRIX at all. */
474 #define SGI_COMPAT(abfd) \
475 (IRIX_COMPAT (abfd) != ict_none)
477 /* The name of the options section. */
478 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
479 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
481 /* The name of the stub section. */
482 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
484 /* The size of an external REL relocation. */
485 #define MIPS_ELF_REL_SIZE(abfd) \
486 (get_elf_backend_data (abfd)->s->sizeof_rel)
488 /* The size of an external dynamic table entry. */
489 #define MIPS_ELF_DYN_SIZE(abfd) \
490 (get_elf_backend_data (abfd)->s->sizeof_dyn)
492 /* The size of a GOT entry. */
493 #define MIPS_ELF_GOT_SIZE(abfd) \
494 (get_elf_backend_data (abfd)->s->arch_size / 8)
496 /* The size of a symbol-table entry. */
497 #define MIPS_ELF_SYM_SIZE(abfd) \
498 (get_elf_backend_data (abfd)->s->sizeof_sym)
500 /* The default alignment for sections, as a power of two. */
501 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
502 (get_elf_backend_data (abfd)->s->log_file_align)
504 /* Get word-sized data. */
505 #define MIPS_ELF_GET_WORD(abfd, ptr) \
506 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
508 /* Put out word-sized data. */
509 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
511 ? bfd_put_64 (abfd, val, ptr) \
512 : bfd_put_32 (abfd, val, ptr))
514 /* Add a dynamic symbol table-entry. */
515 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
516 _bfd_elf_add_dynamic_entry (info, tag, val)
518 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
519 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
521 /* Determine whether the internal relocation of index REL_IDX is REL
522 (zero) or RELA (non-zero). The assumption is that, if there are
523 two relocation sections for this section, one of them is REL and
524 the other is RELA. If the index of the relocation we're testing is
525 in range for the first relocation section, check that the external
526 relocation size is that for RELA. It is also assumed that, if
527 rel_idx is not in range for the first section, and this first
528 section contains REL relocs, then the relocation is in the second
529 section, that is RELA. */
530 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
531 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
532 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
533 > (bfd_vma)(rel_idx)) \
534 == (elf_section_data (sec)->rel_hdr.sh_entsize \
535 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
536 : sizeof (Elf32_External_Rela))))
538 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
539 from smaller values. Start with zero, widen, *then* decrement. */
540 #define MINUS_ONE (((bfd_vma)0) - 1)
541 #define MINUS_TWO (((bfd_vma)0) - 2)
543 /* The number of local .got entries we reserve. */
544 #define MIPS_RESERVED_GOTNO (2)
546 /* The offset of $gp from the beginning of the .got section. */
547 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
549 /* The maximum size of the GOT for it to be addressable using 16-bit
551 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
553 /* Instructions which appear in a stub. */
554 #define STUB_LW(abfd) \
556 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
557 : 0x8f998010)) /* lw t9,0x8010(gp) */
558 #define STUB_MOVE(abfd) \
560 ? 0x03e0782d /* daddu t7,ra */ \
561 : 0x03e07821)) /* addu t7,ra */
562 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
563 #define STUB_LI16(abfd) \
565 ? 0x64180000 /* daddiu t8,zero,0 */ \
566 : 0x24180000)) /* addiu t8,zero,0 */
567 #define MIPS_FUNCTION_STUB_SIZE (16)
569 /* The name of the dynamic interpreter. This is put in the .interp
572 #define ELF_DYNAMIC_INTERPRETER(abfd) \
573 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
574 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
575 : "/usr/lib/libc.so.1")
578 #define MNAME(bfd,pre,pos) \
579 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
580 #define ELF_R_SYM(bfd, i) \
581 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
582 #define ELF_R_TYPE(bfd, i) \
583 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
584 #define ELF_R_INFO(bfd, s, t) \
585 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
587 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
588 #define ELF_R_SYM(bfd, i) \
590 #define ELF_R_TYPE(bfd, i) \
592 #define ELF_R_INFO(bfd, s, t) \
593 (ELF32_R_INFO (s, t))
596 /* The mips16 compiler uses a couple of special sections to handle
597 floating point arguments.
599 Section names that look like .mips16.fn.FNNAME contain stubs that
600 copy floating point arguments from the fp regs to the gp regs and
601 then jump to FNNAME. If any 32 bit function calls FNNAME, the
602 call should be redirected to the stub instead. If no 32 bit
603 function calls FNNAME, the stub should be discarded. We need to
604 consider any reference to the function, not just a call, because
605 if the address of the function is taken we will need the stub,
606 since the address might be passed to a 32 bit function.
608 Section names that look like .mips16.call.FNNAME contain stubs
609 that copy floating point arguments from the gp regs to the fp
610 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
611 then any 16 bit function that calls FNNAME should be redirected
612 to the stub instead. If FNNAME is not a 32 bit function, the
613 stub should be discarded.
615 .mips16.call.fp.FNNAME sections are similar, but contain stubs
616 which call FNNAME and then copy the return value from the fp regs
617 to the gp regs. These stubs store the return value in $18 while
618 calling FNNAME; any function which might call one of these stubs
619 must arrange to save $18 around the call. (This case is not
620 needed for 32 bit functions that call 16 bit functions, because
621 16 bit functions always return floating point values in both
624 Note that in all cases FNNAME might be defined statically.
625 Therefore, FNNAME is not used literally. Instead, the relocation
626 information will indicate which symbol the section is for.
628 We record any stubs that we find in the symbol table. */
630 #define FN_STUB ".mips16.fn."
631 #define CALL_STUB ".mips16.call."
632 #define CALL_FP_STUB ".mips16.call.fp."
634 /* Look up an entry in a MIPS ELF linker hash table. */
636 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
637 ((struct mips_elf_link_hash_entry *) \
638 elf_link_hash_lookup (&(table)->root, (string), (create), \
641 /* Traverse a MIPS ELF linker hash table. */
643 #define mips_elf_link_hash_traverse(table, func, info) \
644 (elf_link_hash_traverse \
646 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
649 /* Get the MIPS ELF linker hash table from a link_info structure. */
651 #define mips_elf_hash_table(p) \
652 ((struct mips_elf_link_hash_table *) ((p)->hash))
654 /* Find the base offsets for thread-local storage in this object,
655 for GD/LD and IE/LE respectively. */
657 #define TP_OFFSET 0x7000
658 #define DTP_OFFSET 0x8000
661 dtprel_base (struct bfd_link_info *info)
663 /* If tls_sec is NULL, we should have signalled an error already. */
664 if (elf_hash_table (info)->tls_sec == NULL)
666 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
670 tprel_base (struct bfd_link_info *info)
672 /* If tls_sec is NULL, we should have signalled an error already. */
673 if (elf_hash_table (info)->tls_sec == NULL)
675 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
678 /* Create an entry in a MIPS ELF linker hash table. */
680 static struct bfd_hash_entry *
681 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
682 struct bfd_hash_table *table, const char *string)
684 struct mips_elf_link_hash_entry *ret =
685 (struct mips_elf_link_hash_entry *) entry;
687 /* Allocate the structure if it has not already been allocated by a
690 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
692 return (struct bfd_hash_entry *) ret;
694 /* Call the allocation method of the superclass. */
695 ret = ((struct mips_elf_link_hash_entry *)
696 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
700 /* Set local fields. */
701 memset (&ret->esym, 0, sizeof (EXTR));
702 /* We use -2 as a marker to indicate that the information has
703 not been set. -1 means there is no associated ifd. */
705 ret->possibly_dynamic_relocs = 0;
706 ret->readonly_reloc = FALSE;
707 ret->no_fn_stub = FALSE;
709 ret->need_fn_stub = FALSE;
710 ret->call_stub = NULL;
711 ret->call_fp_stub = NULL;
712 ret->forced_local = FALSE;
713 ret->tls_type = GOT_NORMAL;
716 return (struct bfd_hash_entry *) ret;
720 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
722 struct _mips_elf_section_data *sdata;
723 bfd_size_type amt = sizeof (*sdata);
725 sdata = bfd_zalloc (abfd, amt);
728 sec->used_by_bfd = sdata;
730 return _bfd_elf_new_section_hook (abfd, sec);
733 /* Read ECOFF debugging information from a .mdebug section into a
734 ecoff_debug_info structure. */
737 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
738 struct ecoff_debug_info *debug)
741 const struct ecoff_debug_swap *swap;
744 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
745 memset (debug, 0, sizeof (*debug));
747 ext_hdr = bfd_malloc (swap->external_hdr_size);
748 if (ext_hdr == NULL && swap->external_hdr_size != 0)
751 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
752 swap->external_hdr_size))
755 symhdr = &debug->symbolic_header;
756 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
758 /* The symbolic header contains absolute file offsets and sizes to
760 #define READ(ptr, offset, count, size, type) \
761 if (symhdr->count == 0) \
765 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
766 debug->ptr = bfd_malloc (amt); \
767 if (debug->ptr == NULL) \
769 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
770 || bfd_bread (debug->ptr, amt, abfd) != amt) \
774 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
775 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
776 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
777 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
778 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
779 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
781 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
782 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
783 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
784 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
785 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
795 if (debug->line != NULL)
797 if (debug->external_dnr != NULL)
798 free (debug->external_dnr);
799 if (debug->external_pdr != NULL)
800 free (debug->external_pdr);
801 if (debug->external_sym != NULL)
802 free (debug->external_sym);
803 if (debug->external_opt != NULL)
804 free (debug->external_opt);
805 if (debug->external_aux != NULL)
806 free (debug->external_aux);
807 if (debug->ss != NULL)
809 if (debug->ssext != NULL)
811 if (debug->external_fdr != NULL)
812 free (debug->external_fdr);
813 if (debug->external_rfd != NULL)
814 free (debug->external_rfd);
815 if (debug->external_ext != NULL)
816 free (debug->external_ext);
820 /* Swap RPDR (runtime procedure table entry) for output. */
823 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
825 H_PUT_S32 (abfd, in->adr, ex->p_adr);
826 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
827 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
828 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
829 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
830 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
832 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
833 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
835 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
838 /* Create a runtime procedure table from the .mdebug section. */
841 mips_elf_create_procedure_table (void *handle, bfd *abfd,
842 struct bfd_link_info *info, asection *s,
843 struct ecoff_debug_info *debug)
845 const struct ecoff_debug_swap *swap;
846 HDRR *hdr = &debug->symbolic_header;
848 struct rpdr_ext *erp;
850 struct pdr_ext *epdr;
851 struct sym_ext *esym;
856 unsigned long sindex;
860 const char *no_name_func = _("static procedure (no name)");
868 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
870 sindex = strlen (no_name_func) + 1;
874 size = swap->external_pdr_size;
876 epdr = bfd_malloc (size * count);
880 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
883 size = sizeof (RPDR);
884 rp = rpdr = bfd_malloc (size * count);
888 size = sizeof (char *);
889 sv = bfd_malloc (size * count);
893 count = hdr->isymMax;
894 size = swap->external_sym_size;
895 esym = bfd_malloc (size * count);
899 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
903 ss = bfd_malloc (count);
906 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
910 for (i = 0; i < (unsigned long) count; i++, rp++)
912 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
913 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
915 rp->regmask = pdr.regmask;
916 rp->regoffset = pdr.regoffset;
917 rp->fregmask = pdr.fregmask;
918 rp->fregoffset = pdr.fregoffset;
919 rp->frameoffset = pdr.frameoffset;
920 rp->framereg = pdr.framereg;
921 rp->pcreg = pdr.pcreg;
923 sv[i] = ss + sym.iss;
924 sindex += strlen (sv[i]) + 1;
928 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
929 size = BFD_ALIGN (size, 16);
930 rtproc = bfd_alloc (abfd, size);
933 mips_elf_hash_table (info)->procedure_count = 0;
937 mips_elf_hash_table (info)->procedure_count = count + 2;
940 memset (erp, 0, sizeof (struct rpdr_ext));
942 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
943 strcpy (str, no_name_func);
944 str += strlen (no_name_func) + 1;
945 for (i = 0; i < count; i++)
947 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
949 str += strlen (sv[i]) + 1;
951 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
953 /* Set the size and contents of .rtproc section. */
955 s->contents = rtproc;
957 /* Skip this section later on (I don't think this currently
958 matters, but someday it might). */
959 s->link_order_head = NULL;
988 /* Check the mips16 stubs for a particular symbol, and see if we can
992 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h,
993 void *data ATTRIBUTE_UNUSED)
995 if (h->root.root.type == bfd_link_hash_warning)
996 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
998 if (h->fn_stub != NULL
999 && ! h->need_fn_stub)
1001 /* We don't need the fn_stub; the only references to this symbol
1002 are 16 bit calls. Clobber the size to 0 to prevent it from
1003 being included in the link. */
1004 h->fn_stub->size = 0;
1005 h->fn_stub->flags &= ~SEC_RELOC;
1006 h->fn_stub->reloc_count = 0;
1007 h->fn_stub->flags |= SEC_EXCLUDE;
1010 if (h->call_stub != NULL
1011 && h->root.other == STO_MIPS16)
1013 /* We don't need the call_stub; this is a 16 bit function, so
1014 calls from other 16 bit functions are OK. Clobber the size
1015 to 0 to prevent it from being included in the link. */
1016 h->call_stub->size = 0;
1017 h->call_stub->flags &= ~SEC_RELOC;
1018 h->call_stub->reloc_count = 0;
1019 h->call_stub->flags |= SEC_EXCLUDE;
1022 if (h->call_fp_stub != NULL
1023 && h->root.other == STO_MIPS16)
1025 /* We don't need the call_stub; this is a 16 bit function, so
1026 calls from other 16 bit functions are OK. Clobber the size
1027 to 0 to prevent it from being included in the link. */
1028 h->call_fp_stub->size = 0;
1029 h->call_fp_stub->flags &= ~SEC_RELOC;
1030 h->call_fp_stub->reloc_count = 0;
1031 h->call_fp_stub->flags |= SEC_EXCLUDE;
1037 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1038 Most mips16 instructions are 16 bits, but these instructions
1041 The format of these instructions is:
1043 +--------------+--------------------------------+
1044 | JALX | X| Imm 20:16 | Imm 25:21 |
1045 +--------------+--------------------------------+
1047 +-----------------------------------------------+
1049 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1050 Note that the immediate value in the first word is swapped.
1052 When producing a relocatable object file, R_MIPS16_26 is
1053 handled mostly like R_MIPS_26. In particular, the addend is
1054 stored as a straight 26-bit value in a 32-bit instruction.
1055 (gas makes life simpler for itself by never adjusting a
1056 R_MIPS16_26 reloc to be against a section, so the addend is
1057 always zero). However, the 32 bit instruction is stored as 2
1058 16-bit values, rather than a single 32-bit value. In a
1059 big-endian file, the result is the same; in a little-endian
1060 file, the two 16-bit halves of the 32 bit value are swapped.
1061 This is so that a disassembler can recognize the jal
1064 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1065 instruction stored as two 16-bit values. The addend A is the
1066 contents of the targ26 field. The calculation is the same as
1067 R_MIPS_26. When storing the calculated value, reorder the
1068 immediate value as shown above, and don't forget to store the
1069 value as two 16-bit values.
1071 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1075 +--------+----------------------+
1079 +--------+----------------------+
1082 +----------+------+-------------+
1086 +----------+--------------------+
1087 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1088 ((sub1 << 16) | sub2)).
1090 When producing a relocatable object file, the calculation is
1091 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1092 When producing a fully linked file, the calculation is
1093 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1094 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1096 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1097 mode. A typical instruction will have a format like this:
1099 +--------------+--------------------------------+
1100 | EXTEND | Imm 10:5 | Imm 15:11 |
1101 +--------------+--------------------------------+
1102 | Major | rx | ry | Imm 4:0 |
1103 +--------------+--------------------------------+
1105 EXTEND is the five bit value 11110. Major is the instruction
1108 This is handled exactly like R_MIPS_GPREL16, except that the
1109 addend is retrieved and stored as shown in this diagram; that
1110 is, the Imm fields above replace the V-rel16 field.
1112 All we need to do here is shuffle the bits appropriately. As
1113 above, the two 16-bit halves must be swapped on a
1114 little-endian system.
1116 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1117 access data when neither GP-relative nor PC-relative addressing
1118 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1119 except that the addend is retrieved and stored as shown above
1123 _bfd_mips16_elf_reloc_unshuffle (bfd *abfd, int r_type,
1124 bfd_boolean jal_shuffle, bfd_byte *data)
1126 bfd_vma extend, insn, val;
1128 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1129 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1132 /* Pick up the mips16 extend instruction and the real instruction. */
1133 extend = bfd_get_16 (abfd, data);
1134 insn = bfd_get_16 (abfd, data + 2);
1135 if (r_type == R_MIPS16_26)
1138 val = ((extend & 0xfc00) << 16) | ((extend & 0x3e0) << 11)
1139 | ((extend & 0x1f) << 21) | insn;
1141 val = extend << 16 | insn;
1144 val = ((extend & 0xf800) << 16) | ((insn & 0xffe0) << 11)
1145 | ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
1146 bfd_put_32 (abfd, val, data);
1150 _bfd_mips16_elf_reloc_shuffle (bfd *abfd, int r_type,
1151 bfd_boolean jal_shuffle, bfd_byte *data)
1153 bfd_vma extend, insn, val;
1155 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1156 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1159 val = bfd_get_32 (abfd, data);
1160 if (r_type == R_MIPS16_26)
1164 insn = val & 0xffff;
1165 extend = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
1166 | ((val >> 21) & 0x1f);
1170 insn = val & 0xffff;
1176 insn = ((val >> 11) & 0xffe0) | (val & 0x1f);
1177 extend = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
1179 bfd_put_16 (abfd, insn, data + 2);
1180 bfd_put_16 (abfd, extend, data);
1183 bfd_reloc_status_type
1184 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1185 arelent *reloc_entry, asection *input_section,
1186 bfd_boolean relocatable, void *data, bfd_vma gp)
1190 bfd_reloc_status_type status;
1192 if (bfd_is_com_section (symbol->section))
1195 relocation = symbol->value;
1197 relocation += symbol->section->output_section->vma;
1198 relocation += symbol->section->output_offset;
1200 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1201 return bfd_reloc_outofrange;
1203 /* Set val to the offset into the section or symbol. */
1204 val = reloc_entry->addend;
1206 _bfd_mips_elf_sign_extend (val, 16);
1208 /* Adjust val for the final section location and GP value. If we
1209 are producing relocatable output, we don't want to do this for
1210 an external symbol. */
1212 || (symbol->flags & BSF_SECTION_SYM) != 0)
1213 val += relocation - gp;
1215 if (reloc_entry->howto->partial_inplace)
1217 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1219 + reloc_entry->address);
1220 if (status != bfd_reloc_ok)
1224 reloc_entry->addend = val;
1227 reloc_entry->address += input_section->output_offset;
1229 return bfd_reloc_ok;
1232 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1233 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1234 that contains the relocation field and DATA points to the start of
1239 struct mips_hi16 *next;
1241 asection *input_section;
1245 /* FIXME: This should not be a static variable. */
1247 static struct mips_hi16 *mips_hi16_list;
1249 /* A howto special_function for REL *HI16 relocations. We can only
1250 calculate the correct value once we've seen the partnering
1251 *LO16 relocation, so just save the information for later.
1253 The ABI requires that the *LO16 immediately follow the *HI16.
1254 However, as a GNU extension, we permit an arbitrary number of
1255 *HI16s to be associated with a single *LO16. This significantly
1256 simplies the relocation handling in gcc. */
1258 bfd_reloc_status_type
1259 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1260 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
1261 asection *input_section, bfd *output_bfd,
1262 char **error_message ATTRIBUTE_UNUSED)
1264 struct mips_hi16 *n;
1266 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1267 return bfd_reloc_outofrange;
1269 n = bfd_malloc (sizeof *n);
1271 return bfd_reloc_outofrange;
1273 n->next = mips_hi16_list;
1275 n->input_section = input_section;
1276 n->rel = *reloc_entry;
1279 if (output_bfd != NULL)
1280 reloc_entry->address += input_section->output_offset;
1282 return bfd_reloc_ok;
1285 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1286 like any other 16-bit relocation when applied to global symbols, but is
1287 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1289 bfd_reloc_status_type
1290 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1291 void *data, asection *input_section,
1292 bfd *output_bfd, char **error_message)
1294 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1295 || bfd_is_und_section (bfd_get_section (symbol))
1296 || bfd_is_com_section (bfd_get_section (symbol)))
1297 /* The relocation is against a global symbol. */
1298 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1299 input_section, output_bfd,
1302 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1303 input_section, output_bfd, error_message);
1306 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1307 is a straightforward 16 bit inplace relocation, but we must deal with
1308 any partnering high-part relocations as well. */
1310 bfd_reloc_status_type
1311 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1312 void *data, asection *input_section,
1313 bfd *output_bfd, char **error_message)
1316 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1318 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1319 return bfd_reloc_outofrange;
1321 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1323 vallo = bfd_get_32 (abfd, location);
1324 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1327 while (mips_hi16_list != NULL)
1329 bfd_reloc_status_type ret;
1330 struct mips_hi16 *hi;
1332 hi = mips_hi16_list;
1334 /* R_MIPS_GOT16 relocations are something of a special case. We
1335 want to install the addend in the same way as for a R_MIPS_HI16
1336 relocation (with a rightshift of 16). However, since GOT16
1337 relocations can also be used with global symbols, their howto
1338 has a rightshift of 0. */
1339 if (hi->rel.howto->type == R_MIPS_GOT16)
1340 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
1342 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1343 carry or borrow will induce a change of +1 or -1 in the high part. */
1344 hi->rel.addend += (vallo + 0x8000) & 0xffff;
1346 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
1347 hi->input_section, output_bfd,
1349 if (ret != bfd_reloc_ok)
1352 mips_hi16_list = hi->next;
1356 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1357 input_section, output_bfd,
1361 /* A generic howto special_function. This calculates and installs the
1362 relocation itself, thus avoiding the oft-discussed problems in
1363 bfd_perform_relocation and bfd_install_relocation. */
1365 bfd_reloc_status_type
1366 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1367 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1368 asection *input_section, bfd *output_bfd,
1369 char **error_message ATTRIBUTE_UNUSED)
1372 bfd_reloc_status_type status;
1373 bfd_boolean relocatable;
1375 relocatable = (output_bfd != NULL);
1377 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1378 return bfd_reloc_outofrange;
1380 /* Build up the field adjustment in VAL. */
1382 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
1384 /* Either we're calculating the final field value or we have a
1385 relocation against a section symbol. Add in the section's
1386 offset or address. */
1387 val += symbol->section->output_section->vma;
1388 val += symbol->section->output_offset;
1393 /* We're calculating the final field value. Add in the symbol's value
1394 and, if pc-relative, subtract the address of the field itself. */
1395 val += symbol->value;
1396 if (reloc_entry->howto->pc_relative)
1398 val -= input_section->output_section->vma;
1399 val -= input_section->output_offset;
1400 val -= reloc_entry->address;
1404 /* VAL is now the final adjustment. If we're keeping this relocation
1405 in the output file, and if the relocation uses a separate addend,
1406 we just need to add VAL to that addend. Otherwise we need to add
1407 VAL to the relocation field itself. */
1408 if (relocatable && !reloc_entry->howto->partial_inplace)
1409 reloc_entry->addend += val;
1412 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1414 /* Add in the separate addend, if any. */
1415 val += reloc_entry->addend;
1417 /* Add VAL to the relocation field. */
1418 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1420 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1422 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1425 if (status != bfd_reloc_ok)
1430 reloc_entry->address += input_section->output_offset;
1432 return bfd_reloc_ok;
1435 /* Swap an entry in a .gptab section. Note that these routines rely
1436 on the equivalence of the two elements of the union. */
1439 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
1442 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
1443 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
1447 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
1448 Elf32_External_gptab *ex)
1450 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
1451 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
1455 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
1456 Elf32_External_compact_rel *ex)
1458 H_PUT_32 (abfd, in->id1, ex->id1);
1459 H_PUT_32 (abfd, in->num, ex->num);
1460 H_PUT_32 (abfd, in->id2, ex->id2);
1461 H_PUT_32 (abfd, in->offset, ex->offset);
1462 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
1463 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
1467 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
1468 Elf32_External_crinfo *ex)
1472 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
1473 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
1474 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
1475 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
1476 H_PUT_32 (abfd, l, ex->info);
1477 H_PUT_32 (abfd, in->konst, ex->konst);
1478 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
1481 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1482 routines swap this structure in and out. They are used outside of
1483 BFD, so they are globally visible. */
1486 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
1489 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1490 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1491 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1492 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1493 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1494 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
1498 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
1499 Elf32_External_RegInfo *ex)
1501 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1502 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1503 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1504 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1505 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1506 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
1509 /* In the 64 bit ABI, the .MIPS.options section holds register
1510 information in an Elf64_Reginfo structure. These routines swap
1511 them in and out. They are globally visible because they are used
1512 outside of BFD. These routines are here so that gas can call them
1513 without worrying about whether the 64 bit ABI has been included. */
1516 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
1517 Elf64_Internal_RegInfo *in)
1519 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1520 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
1521 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1522 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1523 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1524 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1525 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
1529 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
1530 Elf64_External_RegInfo *ex)
1532 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1533 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
1534 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1535 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1536 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1537 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1538 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
1541 /* Swap in an options header. */
1544 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
1545 Elf_Internal_Options *in)
1547 in->kind = H_GET_8 (abfd, ex->kind);
1548 in->size = H_GET_8 (abfd, ex->size);
1549 in->section = H_GET_16 (abfd, ex->section);
1550 in->info = H_GET_32 (abfd, ex->info);
1553 /* Swap out an options header. */
1556 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
1557 Elf_External_Options *ex)
1559 H_PUT_8 (abfd, in->kind, ex->kind);
1560 H_PUT_8 (abfd, in->size, ex->size);
1561 H_PUT_16 (abfd, in->section, ex->section);
1562 H_PUT_32 (abfd, in->info, ex->info);
1565 /* This function is called via qsort() to sort the dynamic relocation
1566 entries by increasing r_symndx value. */
1569 sort_dynamic_relocs (const void *arg1, const void *arg2)
1571 Elf_Internal_Rela int_reloc1;
1572 Elf_Internal_Rela int_reloc2;
1574 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1575 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1577 return ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
1580 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1583 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
1584 const void *arg2 ATTRIBUTE_UNUSED)
1587 Elf_Internal_Rela int_reloc1[3];
1588 Elf_Internal_Rela int_reloc2[3];
1590 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1591 (reldyn_sorting_bfd, arg1, int_reloc1);
1592 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1593 (reldyn_sorting_bfd, arg2, int_reloc2);
1595 return (ELF64_R_SYM (int_reloc1[0].r_info)
1596 - ELF64_R_SYM (int_reloc2[0].r_info));
1603 /* This routine is used to write out ECOFF debugging external symbol
1604 information. It is called via mips_elf_link_hash_traverse. The
1605 ECOFF external symbol information must match the ELF external
1606 symbol information. Unfortunately, at this point we don't know
1607 whether a symbol is required by reloc information, so the two
1608 tables may wind up being different. We must sort out the external
1609 symbol information before we can set the final size of the .mdebug
1610 section, and we must set the size of the .mdebug section before we
1611 can relocate any sections, and we can't know which symbols are
1612 required by relocation until we relocate the sections.
1613 Fortunately, it is relatively unlikely that any symbol will be
1614 stripped but required by a reloc. In particular, it can not happen
1615 when generating a final executable. */
1618 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
1620 struct extsym_info *einfo = data;
1622 asection *sec, *output_section;
1624 if (h->root.root.type == bfd_link_hash_warning)
1625 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1627 if (h->root.indx == -2)
1629 else if ((h->root.def_dynamic
1630 || h->root.ref_dynamic
1631 || h->root.type == bfd_link_hash_new)
1632 && !h->root.def_regular
1633 && !h->root.ref_regular)
1635 else if (einfo->info->strip == strip_all
1636 || (einfo->info->strip == strip_some
1637 && bfd_hash_lookup (einfo->info->keep_hash,
1638 h->root.root.root.string,
1639 FALSE, FALSE) == NULL))
1647 if (h->esym.ifd == -2)
1650 h->esym.cobol_main = 0;
1651 h->esym.weakext = 0;
1652 h->esym.reserved = 0;
1653 h->esym.ifd = ifdNil;
1654 h->esym.asym.value = 0;
1655 h->esym.asym.st = stGlobal;
1657 if (h->root.root.type == bfd_link_hash_undefined
1658 || h->root.root.type == bfd_link_hash_undefweak)
1662 /* Use undefined class. Also, set class and type for some
1664 name = h->root.root.root.string;
1665 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
1666 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
1668 h->esym.asym.sc = scData;
1669 h->esym.asym.st = stLabel;
1670 h->esym.asym.value = 0;
1672 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
1674 h->esym.asym.sc = scAbs;
1675 h->esym.asym.st = stLabel;
1676 h->esym.asym.value =
1677 mips_elf_hash_table (einfo->info)->procedure_count;
1679 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
1681 h->esym.asym.sc = scAbs;
1682 h->esym.asym.st = stLabel;
1683 h->esym.asym.value = elf_gp (einfo->abfd);
1686 h->esym.asym.sc = scUndefined;
1688 else if (h->root.root.type != bfd_link_hash_defined
1689 && h->root.root.type != bfd_link_hash_defweak)
1690 h->esym.asym.sc = scAbs;
1695 sec = h->root.root.u.def.section;
1696 output_section = sec->output_section;
1698 /* When making a shared library and symbol h is the one from
1699 the another shared library, OUTPUT_SECTION may be null. */
1700 if (output_section == NULL)
1701 h->esym.asym.sc = scUndefined;
1704 name = bfd_section_name (output_section->owner, output_section);
1706 if (strcmp (name, ".text") == 0)
1707 h->esym.asym.sc = scText;
1708 else if (strcmp (name, ".data") == 0)
1709 h->esym.asym.sc = scData;
1710 else if (strcmp (name, ".sdata") == 0)
1711 h->esym.asym.sc = scSData;
1712 else if (strcmp (name, ".rodata") == 0
1713 || strcmp (name, ".rdata") == 0)
1714 h->esym.asym.sc = scRData;
1715 else if (strcmp (name, ".bss") == 0)
1716 h->esym.asym.sc = scBss;
1717 else if (strcmp (name, ".sbss") == 0)
1718 h->esym.asym.sc = scSBss;
1719 else if (strcmp (name, ".init") == 0)
1720 h->esym.asym.sc = scInit;
1721 else if (strcmp (name, ".fini") == 0)
1722 h->esym.asym.sc = scFini;
1724 h->esym.asym.sc = scAbs;
1728 h->esym.asym.reserved = 0;
1729 h->esym.asym.index = indexNil;
1732 if (h->root.root.type == bfd_link_hash_common)
1733 h->esym.asym.value = h->root.root.u.c.size;
1734 else if (h->root.root.type == bfd_link_hash_defined
1735 || h->root.root.type == bfd_link_hash_defweak)
1737 if (h->esym.asym.sc == scCommon)
1738 h->esym.asym.sc = scBss;
1739 else if (h->esym.asym.sc == scSCommon)
1740 h->esym.asym.sc = scSBss;
1742 sec = h->root.root.u.def.section;
1743 output_section = sec->output_section;
1744 if (output_section != NULL)
1745 h->esym.asym.value = (h->root.root.u.def.value
1746 + sec->output_offset
1747 + output_section->vma);
1749 h->esym.asym.value = 0;
1751 else if (h->root.needs_plt)
1753 struct mips_elf_link_hash_entry *hd = h;
1754 bfd_boolean no_fn_stub = h->no_fn_stub;
1756 while (hd->root.root.type == bfd_link_hash_indirect)
1758 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
1759 no_fn_stub = no_fn_stub || hd->no_fn_stub;
1764 /* Set type and value for a symbol with a function stub. */
1765 h->esym.asym.st = stProc;
1766 sec = hd->root.root.u.def.section;
1768 h->esym.asym.value = 0;
1771 output_section = sec->output_section;
1772 if (output_section != NULL)
1773 h->esym.asym.value = (hd->root.plt.offset
1774 + sec->output_offset
1775 + output_section->vma);
1777 h->esym.asym.value = 0;
1782 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1783 h->root.root.root.string,
1786 einfo->failed = TRUE;
1793 /* A comparison routine used to sort .gptab entries. */
1796 gptab_compare (const void *p1, const void *p2)
1798 const Elf32_gptab *a1 = p1;
1799 const Elf32_gptab *a2 = p2;
1801 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
1804 /* Functions to manage the got entry hash table. */
1806 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1809 static INLINE hashval_t
1810 mips_elf_hash_bfd_vma (bfd_vma addr)
1813 return addr + (addr >> 32);
1819 /* got_entries only match if they're identical, except for gotidx, so
1820 use all fields to compute the hash, and compare the appropriate
1824 mips_elf_got_entry_hash (const void *entry_)
1826 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1828 return entry->symndx
1829 + ((entry->tls_type & GOT_TLS_LDM) << 17)
1830 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
1832 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
1833 : entry->d.h->root.root.root.hash));
1837 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
1839 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1840 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1842 /* An LDM entry can only match another LDM entry. */
1843 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
1846 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
1847 && (! e1->abfd ? e1->d.address == e2->d.address
1848 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
1849 : e1->d.h == e2->d.h);
1852 /* multi_got_entries are still a match in the case of global objects,
1853 even if the input bfd in which they're referenced differs, so the
1854 hash computation and compare functions are adjusted
1858 mips_elf_multi_got_entry_hash (const void *entry_)
1860 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1862 return entry->symndx
1864 ? mips_elf_hash_bfd_vma (entry->d.address)
1865 : entry->symndx >= 0
1866 ? ((entry->tls_type & GOT_TLS_LDM)
1867 ? (GOT_TLS_LDM << 17)
1869 + mips_elf_hash_bfd_vma (entry->d.addend)))
1870 : entry->d.h->root.root.root.hash);
1874 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
1876 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1877 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1879 /* Any two LDM entries match. */
1880 if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
1883 /* Nothing else matches an LDM entry. */
1884 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
1887 return e1->symndx == e2->symndx
1888 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
1889 : e1->abfd == NULL || e2->abfd == NULL
1890 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
1891 : e1->d.h == e2->d.h);
1894 /* Returns the dynamic relocation section for DYNOBJ. */
1897 mips_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
1899 static const char dname[] = ".rel.dyn";
1902 sreloc = bfd_get_section_by_name (dynobj, dname);
1903 if (sreloc == NULL && create_p)
1905 sreloc = bfd_make_section (dynobj, dname);
1907 || ! bfd_set_section_flags (dynobj, sreloc,
1912 | SEC_LINKER_CREATED
1914 || ! bfd_set_section_alignment (dynobj, sreloc,
1915 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
1921 /* Returns the GOT section for ABFD. */
1924 mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
1926 asection *sgot = bfd_get_section_by_name (abfd, ".got");
1928 || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
1933 /* Returns the GOT information associated with the link indicated by
1934 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1937 static struct mips_got_info *
1938 mips_elf_got_info (bfd *abfd, asection **sgotp)
1941 struct mips_got_info *g;
1943 sgot = mips_elf_got_section (abfd, TRUE);
1944 BFD_ASSERT (sgot != NULL);
1945 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
1946 g = mips_elf_section_data (sgot)->u.got_info;
1947 BFD_ASSERT (g != NULL);
1950 *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL;
1955 /* Count the number of relocations needed for a TLS GOT entry, with
1956 access types from TLS_TYPE, and symbol H (or a local symbol if H
1960 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
1961 struct elf_link_hash_entry *h)
1965 bfd_boolean need_relocs = FALSE;
1966 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
1968 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1969 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
1972 if ((info->shared || indx != 0)
1974 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1975 || h->root.type != bfd_link_hash_undefweak))
1981 if (tls_type & GOT_TLS_GD)
1988 if (tls_type & GOT_TLS_IE)
1991 if ((tls_type & GOT_TLS_LDM) && info->shared)
1997 /* Count the number of TLS relocations required for the GOT entry in
1998 ARG1, if it describes a local symbol. */
2001 mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2003 struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2004 struct mips_elf_count_tls_arg *arg = arg2;
2006 if (entry->abfd != NULL && entry->symndx != -1)
2007 arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2012 /* Count the number of TLS GOT entries required for the global (or
2013 forced-local) symbol in ARG1. */
2016 mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2018 struct mips_elf_link_hash_entry *hm
2019 = (struct mips_elf_link_hash_entry *) arg1;
2020 struct mips_elf_count_tls_arg *arg = arg2;
2022 if (hm->tls_type & GOT_TLS_GD)
2024 if (hm->tls_type & GOT_TLS_IE)
2030 /* Count the number of TLS relocations required for the global (or
2031 forced-local) symbol in ARG1. */
2034 mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2036 struct mips_elf_link_hash_entry *hm
2037 = (struct mips_elf_link_hash_entry *) arg1;
2038 struct mips_elf_count_tls_arg *arg = arg2;
2040 arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2045 /* Output a simple dynamic relocation into SRELOC. */
2048 mips_elf_output_dynamic_relocation (bfd *output_bfd,
2054 Elf_Internal_Rela rel[3];
2056 memset (rel, 0, sizeof (rel));
2058 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
2059 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
2061 if (ABI_64_P (output_bfd))
2063 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
2064 (output_bfd, &rel[0],
2066 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
2069 bfd_elf32_swap_reloc_out
2070 (output_bfd, &rel[0],
2072 + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
2073 ++sreloc->reloc_count;
2076 /* Initialize a set of TLS GOT entries for one symbol. */
2079 mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
2080 unsigned char *tls_type_p,
2081 struct bfd_link_info *info,
2082 struct mips_elf_link_hash_entry *h,
2086 asection *sreloc, *sgot;
2087 bfd_vma offset, offset2;
2089 bfd_boolean need_relocs = FALSE;
2091 dynobj = elf_hash_table (info)->dynobj;
2092 sgot = mips_elf_got_section (dynobj, FALSE);
2097 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2099 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
2100 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
2101 indx = h->root.dynindx;
2104 if (*tls_type_p & GOT_TLS_DONE)
2107 if ((info->shared || indx != 0)
2109 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
2110 || h->root.type != bfd_link_hash_undefweak))
2113 /* MINUS_ONE means the symbol is not defined in this object. It may not
2114 be defined at all; assume that the value doesn't matter in that
2115 case. Otherwise complain if we would use the value. */
2116 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
2117 || h->root.root.type == bfd_link_hash_undefweak);
2119 /* Emit necessary relocations. */
2120 sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
2122 /* General Dynamic. */
2123 if (*tls_type_p & GOT_TLS_GD)
2125 offset = got_offset;
2126 offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
2130 mips_elf_output_dynamic_relocation
2131 (abfd, sreloc, indx,
2132 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2133 sgot->output_offset + sgot->output_section->vma + offset);
2136 mips_elf_output_dynamic_relocation
2137 (abfd, sreloc, indx,
2138 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
2139 sgot->output_offset + sgot->output_section->vma + offset2);
2141 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2142 sgot->contents + offset2);
2146 MIPS_ELF_PUT_WORD (abfd, 1,
2147 sgot->contents + offset);
2148 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2149 sgot->contents + offset2);
2152 got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
2155 /* Initial Exec model. */
2156 if (*tls_type_p & GOT_TLS_IE)
2158 offset = got_offset;
2163 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
2164 sgot->contents + offset);
2166 MIPS_ELF_PUT_WORD (abfd, 0,
2167 sgot->contents + offset);
2169 mips_elf_output_dynamic_relocation
2170 (abfd, sreloc, indx,
2171 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
2172 sgot->output_offset + sgot->output_section->vma + offset);
2175 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
2176 sgot->contents + offset);
2179 if (*tls_type_p & GOT_TLS_LDM)
2181 /* The initial offset is zero, and the LD offsets will include the
2182 bias by DTP_OFFSET. */
2183 MIPS_ELF_PUT_WORD (abfd, 0,
2184 sgot->contents + got_offset
2185 + MIPS_ELF_GOT_SIZE (abfd));
2188 MIPS_ELF_PUT_WORD (abfd, 1,
2189 sgot->contents + got_offset);
2191 mips_elf_output_dynamic_relocation
2192 (abfd, sreloc, indx,
2193 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2194 sgot->output_offset + sgot->output_section->vma + got_offset);
2197 *tls_type_p |= GOT_TLS_DONE;
2200 /* Return the GOT index to use for a relocation of type R_TYPE against
2201 a symbol accessed using TLS_TYPE models. The GOT entries for this
2202 symbol in this GOT start at GOT_INDEX. This function initializes the
2203 GOT entries and corresponding relocations. */
2206 mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
2207 int r_type, struct bfd_link_info *info,
2208 struct mips_elf_link_hash_entry *h, bfd_vma symbol)
2210 BFD_ASSERT (r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MIPS_TLS_GD
2211 || r_type == R_MIPS_TLS_LDM);
2213 mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
2215 if (r_type == R_MIPS_TLS_GOTTPREL)
2217 BFD_ASSERT (*tls_type & GOT_TLS_IE);
2218 if (*tls_type & GOT_TLS_GD)
2219 return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
2224 if (r_type == R_MIPS_TLS_GD)
2226 BFD_ASSERT (*tls_type & GOT_TLS_GD);
2230 if (r_type == R_MIPS_TLS_LDM)
2232 BFD_ASSERT (*tls_type & GOT_TLS_LDM);
2239 /* Returns the GOT offset at which the indicated address can be found.
2240 If there is not yet a GOT entry for this value, create one. If
2241 R_SYMNDX refers to a TLS symbol, create a TLS GOT entry instead.
2242 Returns -1 if no satisfactory GOT offset can be found. */
2245 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2246 bfd_vma value, unsigned long r_symndx,
2247 struct mips_elf_link_hash_entry *h, int r_type)
2250 struct mips_got_info *g;
2251 struct mips_got_entry *entry;
2253 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2255 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value,
2256 r_symndx, h, r_type);
2260 if (TLS_RELOC_P (r_type))
2261 return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type, r_type,
2264 return entry->gotidx;
2267 /* Returns the GOT index for the global symbol indicated by H. */
2270 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
2271 int r_type, struct bfd_link_info *info)
2275 struct mips_got_info *g, *gg;
2276 long global_got_dynindx = 0;
2278 gg = g = mips_elf_got_info (abfd, &sgot);
2279 if (g->bfd2got && ibfd)
2281 struct mips_got_entry e, *p;
2283 BFD_ASSERT (h->dynindx >= 0);
2285 g = mips_elf_got_for_ibfd (g, ibfd);
2286 if (g->next != gg || TLS_RELOC_P (r_type))
2290 e.d.h = (struct mips_elf_link_hash_entry *)h;
2293 p = htab_find (g->got_entries, &e);
2295 BFD_ASSERT (p->gotidx > 0);
2297 if (TLS_RELOC_P (r_type))
2299 bfd_vma value = MINUS_ONE;
2300 if ((h->root.type == bfd_link_hash_defined
2301 || h->root.type == bfd_link_hash_defweak)
2302 && h->root.u.def.section->output_section)
2303 value = (h->root.u.def.value
2304 + h->root.u.def.section->output_offset
2305 + h->root.u.def.section->output_section->vma);
2307 return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
2308 info, e.d.h, value);
2315 if (gg->global_gotsym != NULL)
2316 global_got_dynindx = gg->global_gotsym->dynindx;
2318 if (TLS_RELOC_P (r_type))
2320 struct mips_elf_link_hash_entry *hm
2321 = (struct mips_elf_link_hash_entry *) h;
2322 bfd_vma value = MINUS_ONE;
2324 if ((h->root.type == bfd_link_hash_defined
2325 || h->root.type == bfd_link_hash_defweak)
2326 && h->root.u.def.section->output_section)
2327 value = (h->root.u.def.value
2328 + h->root.u.def.section->output_offset
2329 + h->root.u.def.section->output_section->vma);
2331 index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
2332 r_type, info, hm, value);
2336 /* Once we determine the global GOT entry with the lowest dynamic
2337 symbol table index, we must put all dynamic symbols with greater
2338 indices into the GOT. That makes it easy to calculate the GOT
2340 BFD_ASSERT (h->dynindx >= global_got_dynindx);
2341 index = ((h->dynindx - global_got_dynindx + g->local_gotno)
2342 * MIPS_ELF_GOT_SIZE (abfd));
2344 BFD_ASSERT (index < sgot->size);
2349 /* Find a GOT entry that is within 32KB of the VALUE. These entries
2350 are supposed to be placed at small offsets in the GOT, i.e.,
2351 within 32KB of GP. Return the index into the GOT for this page,
2352 and store the offset from this entry to the desired address in
2353 OFFSETP, if it is non-NULL. */
2356 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2357 bfd_vma value, bfd_vma *offsetp)
2360 struct mips_got_info *g;
2362 struct mips_got_entry *entry;
2364 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2366 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot,
2368 & (~(bfd_vma)0xffff), 0,
2369 NULL, R_MIPS_GOT_PAGE);
2374 index = entry->gotidx;
2377 *offsetp = value - entry->d.address;
2382 /* Find a GOT entry whose higher-order 16 bits are the same as those
2383 for value. Return the index into the GOT for this entry. */
2386 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2387 bfd_vma value, bfd_boolean external)
2390 struct mips_got_info *g;
2391 struct mips_got_entry *entry;
2395 /* Although the ABI says that it is "the high-order 16 bits" that we
2396 want, it is really the %high value. The complete value is
2397 calculated with a `addiu' of a LO16 relocation, just as with a
2399 value = mips_elf_high (value) << 16;
2402 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2404 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 0, NULL,
2407 return entry->gotidx;
2412 /* Returns the offset for the entry at the INDEXth position
2416 mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
2417 bfd *input_bfd, bfd_vma index)
2421 struct mips_got_info *g;
2423 g = mips_elf_got_info (dynobj, &sgot);
2424 gp = _bfd_get_gp_value (output_bfd)
2425 + mips_elf_adjust_gp (output_bfd, g, input_bfd);
2427 return sgot->output_section->vma + sgot->output_offset + index - gp;
2430 /* Create a local GOT entry for VALUE. Return the index of the entry,
2431 or -1 if it could not be created. If R_SYMNDX refers to a TLS symbol,
2432 create a TLS entry instead. */
2434 static struct mips_got_entry *
2435 mips_elf_create_local_got_entry (bfd *abfd, bfd *ibfd,
2436 struct mips_got_info *gg,
2437 asection *sgot, bfd_vma value,
2438 unsigned long r_symndx,
2439 struct mips_elf_link_hash_entry *h,
2442 struct mips_got_entry entry, **loc;
2443 struct mips_got_info *g;
2447 entry.d.address = value;
2450 g = mips_elf_got_for_ibfd (gg, ibfd);
2453 g = mips_elf_got_for_ibfd (gg, abfd);
2454 BFD_ASSERT (g != NULL);
2457 /* We might have a symbol, H, if it has been forced local. Use the
2458 global entry then. It doesn't matter whether an entry is local
2459 or global for TLS, since the dynamic linker does not
2460 automatically relocate TLS GOT entries. */
2461 BFD_ASSERT (h == NULL || h->forced_local);
2462 if (TLS_RELOC_P (r_type))
2464 struct mips_got_entry *p;
2467 if (r_type == R_MIPS_TLS_LDM)
2469 entry.tls_type = GOT_TLS_LDM;
2475 entry.symndx = r_symndx;
2481 p = (struct mips_got_entry *)
2482 htab_find (g->got_entries, &entry);
2488 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2493 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
2496 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2501 memcpy (*loc, &entry, sizeof entry);
2503 if (g->assigned_gotno >= g->local_gotno)
2505 (*loc)->gotidx = -1;
2506 /* We didn't allocate enough space in the GOT. */
2507 (*_bfd_error_handler)
2508 (_("not enough GOT space for local GOT entries"));
2509 bfd_set_error (bfd_error_bad_value);
2513 MIPS_ELF_PUT_WORD (abfd, value,
2514 (sgot->contents + entry.gotidx));
2519 /* Sort the dynamic symbol table so that symbols that need GOT entries
2520 appear towards the end. This reduces the amount of GOT space
2521 required. MAX_LOCAL is used to set the number of local symbols
2522 known to be in the dynamic symbol table. During
2523 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2524 section symbols are added and the count is higher. */
2527 mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local)
2529 struct mips_elf_hash_sort_data hsd;
2530 struct mips_got_info *g;
2533 dynobj = elf_hash_table (info)->dynobj;
2535 g = mips_elf_got_info (dynobj, NULL);
2538 hsd.max_unref_got_dynindx =
2539 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
2540 /* In the multi-got case, assigned_gotno of the master got_info
2541 indicate the number of entries that aren't referenced in the
2542 primary GOT, but that must have entries because there are
2543 dynamic relocations that reference it. Since they aren't
2544 referenced, we move them to the end of the GOT, so that they
2545 don't prevent other entries that are referenced from getting
2546 too large offsets. */
2547 - (g->next ? g->assigned_gotno : 0);
2548 hsd.max_non_got_dynindx = max_local;
2549 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
2550 elf_hash_table (info)),
2551 mips_elf_sort_hash_table_f,
2554 /* There should have been enough room in the symbol table to
2555 accommodate both the GOT and non-GOT symbols. */
2556 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
2557 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
2558 <= elf_hash_table (info)->dynsymcount);
2560 /* Now we know which dynamic symbol has the lowest dynamic symbol
2561 table index in the GOT. */
2562 g->global_gotsym = hsd.low;
2567 /* If H needs a GOT entry, assign it the highest available dynamic
2568 index. Otherwise, assign it the lowest available dynamic
2572 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
2574 struct mips_elf_hash_sort_data *hsd = data;
2576 if (h->root.root.type == bfd_link_hash_warning)
2577 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2579 /* Symbols without dynamic symbol table entries aren't interesting
2581 if (h->root.dynindx == -1)
2584 /* Global symbols that need GOT entries that are not explicitly
2585 referenced are marked with got offset 2. Those that are
2586 referenced get a 1, and those that don't need GOT entries get
2588 if (h->root.got.offset == 2)
2590 BFD_ASSERT (h->tls_type == GOT_NORMAL);
2592 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
2593 hsd->low = (struct elf_link_hash_entry *) h;
2594 h->root.dynindx = hsd->max_unref_got_dynindx++;
2596 else if (h->root.got.offset != 1)
2597 h->root.dynindx = hsd->max_non_got_dynindx++;
2600 BFD_ASSERT (h->tls_type == GOT_NORMAL);
2602 h->root.dynindx = --hsd->min_got_dynindx;
2603 hsd->low = (struct elf_link_hash_entry *) h;
2609 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2610 symbol table index lower than any we've seen to date, record it for
2614 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
2615 bfd *abfd, struct bfd_link_info *info,
2616 struct mips_got_info *g,
2617 unsigned char tls_flag)
2619 struct mips_got_entry entry, **loc;
2621 /* A global symbol in the GOT must also be in the dynamic symbol
2623 if (h->dynindx == -1)
2625 switch (ELF_ST_VISIBILITY (h->other))
2629 _bfd_mips_elf_hide_symbol (info, h, TRUE);
2632 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2638 entry.d.h = (struct mips_elf_link_hash_entry *) h;
2641 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2644 /* If we've already marked this entry as needing GOT space, we don't
2645 need to do it again. */
2648 (*loc)->tls_type |= tls_flag;
2652 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2658 entry.tls_type = tls_flag;
2660 memcpy (*loc, &entry, sizeof entry);
2662 if (h->got.offset != MINUS_ONE)
2665 /* By setting this to a value other than -1, we are indicating that
2666 there needs to be a GOT entry for H. Avoid using zero, as the
2667 generic ELF copy_indirect_symbol tests for <= 0. */
2674 /* Reserve space in G for a GOT entry containing the value of symbol
2675 SYMNDX in input bfd ABDF, plus ADDEND. */
2678 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
2679 struct mips_got_info *g,
2680 unsigned char tls_flag)
2682 struct mips_got_entry entry, **loc;
2685 entry.symndx = symndx;
2686 entry.d.addend = addend;
2687 entry.tls_type = tls_flag;
2688 loc = (struct mips_got_entry **)
2689 htab_find_slot (g->got_entries, &entry, INSERT);
2693 if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
2696 (*loc)->tls_type |= tls_flag;
2698 else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
2701 (*loc)->tls_type |= tls_flag;
2709 entry.tls_type = tls_flag;
2710 if (tls_flag == GOT_TLS_IE)
2712 else if (tls_flag == GOT_TLS_GD)
2714 else if (g->tls_ldm_offset == MINUS_ONE)
2716 g->tls_ldm_offset = MINUS_TWO;
2722 entry.gotidx = g->local_gotno++;
2726 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2731 memcpy (*loc, &entry, sizeof entry);
2736 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2739 mips_elf_bfd2got_entry_hash (const void *entry_)
2741 const struct mips_elf_bfd2got_hash *entry
2742 = (struct mips_elf_bfd2got_hash *)entry_;
2744 return entry->bfd->id;
2747 /* Check whether two hash entries have the same bfd. */
2750 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
2752 const struct mips_elf_bfd2got_hash *e1
2753 = (const struct mips_elf_bfd2got_hash *)entry1;
2754 const struct mips_elf_bfd2got_hash *e2
2755 = (const struct mips_elf_bfd2got_hash *)entry2;
2757 return e1->bfd == e2->bfd;
2760 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2761 be the master GOT data. */
2763 static struct mips_got_info *
2764 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
2766 struct mips_elf_bfd2got_hash e, *p;
2772 p = htab_find (g->bfd2got, &e);
2773 return p ? p->g : NULL;
2776 /* Create one separate got for each bfd that has entries in the global
2777 got, such that we can tell how many local and global entries each
2781 mips_elf_make_got_per_bfd (void **entryp, void *p)
2783 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2784 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2785 htab_t bfd2got = arg->bfd2got;
2786 struct mips_got_info *g;
2787 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
2790 /* Find the got_info for this GOT entry's input bfd. Create one if
2792 bfdgot_entry.bfd = entry->abfd;
2793 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
2794 bfdgot = (struct mips_elf_bfd2got_hash *)*bfdgotp;
2800 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
2801 (arg->obfd, sizeof (struct mips_elf_bfd2got_hash));
2811 bfdgot->bfd = entry->abfd;
2812 bfdgot->g = g = (struct mips_got_info *)
2813 bfd_alloc (arg->obfd, sizeof (struct mips_got_info));
2820 g->global_gotsym = NULL;
2821 g->global_gotno = 0;
2823 g->assigned_gotno = -1;
2825 g->tls_assigned_gotno = 0;
2826 g->tls_ldm_offset = MINUS_ONE;
2827 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
2828 mips_elf_multi_got_entry_eq, NULL);
2829 if (g->got_entries == NULL)
2839 /* Insert the GOT entry in the bfd's got entry hash table. */
2840 entryp = htab_find_slot (g->got_entries, entry, INSERT);
2841 if (*entryp != NULL)
2846 if (entry->tls_type)
2848 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
2850 if (entry->tls_type & GOT_TLS_IE)
2853 else if (entry->symndx >= 0 || entry->d.h->forced_local)
2861 /* Attempt to merge gots of different input bfds. Try to use as much
2862 as possible of the primary got, since it doesn't require explicit
2863 dynamic relocations, but don't use bfds that would reference global
2864 symbols out of the addressable range. Failing the primary got,
2865 attempt to merge with the current got, or finish the current got
2866 and then make make the new got current. */
2869 mips_elf_merge_gots (void **bfd2got_, void *p)
2871 struct mips_elf_bfd2got_hash *bfd2got
2872 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
2873 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2874 unsigned int lcount = bfd2got->g->local_gotno;
2875 unsigned int gcount = bfd2got->g->global_gotno;
2876 unsigned int tcount = bfd2got->g->tls_gotno;
2877 unsigned int maxcnt = arg->max_count;
2878 bfd_boolean too_many_for_tls = FALSE;
2880 /* We place TLS GOT entries after both locals and globals. The globals
2881 for the primary GOT may overflow the normal GOT size limit, so be
2882 sure not to merge a GOT which requires TLS with the primary GOT in that
2883 case. This doesn't affect non-primary GOTs. */
2886 unsigned int primary_total = lcount + tcount + arg->global_count;
2887 if (primary_total * MIPS_ELF_GOT_SIZE (bfd2got->bfd)
2888 >= MIPS_ELF_GOT_MAX_SIZE (bfd2got->bfd))
2889 too_many_for_tls = TRUE;
2892 /* If we don't have a primary GOT and this is not too big, use it as
2893 a starting point for the primary GOT. */
2894 if (! arg->primary && lcount + gcount + tcount <= maxcnt
2895 && ! too_many_for_tls)
2897 arg->primary = bfd2got->g;
2898 arg->primary_count = lcount + gcount;
2900 /* If it looks like we can merge this bfd's entries with those of
2901 the primary, merge them. The heuristics is conservative, but we
2902 don't have to squeeze it too hard. */
2903 else if (arg->primary && ! too_many_for_tls
2904 && (arg->primary_count + lcount + gcount + tcount) <= maxcnt)
2906 struct mips_got_info *g = bfd2got->g;
2907 int old_lcount = arg->primary->local_gotno;
2908 int old_gcount = arg->primary->global_gotno;
2909 int old_tcount = arg->primary->tls_gotno;
2911 bfd2got->g = arg->primary;
2913 htab_traverse (g->got_entries,
2914 mips_elf_make_got_per_bfd,
2916 if (arg->obfd == NULL)
2919 htab_delete (g->got_entries);
2920 /* We don't have to worry about releasing memory of the actual
2921 got entries, since they're all in the master got_entries hash
2924 BFD_ASSERT (old_lcount + lcount >= arg->primary->local_gotno);
2925 BFD_ASSERT (old_gcount + gcount >= arg->primary->global_gotno);
2926 BFD_ASSERT (old_tcount + tcount >= arg->primary->tls_gotno);
2928 arg->primary_count = arg->primary->local_gotno
2929 + arg->primary->global_gotno + arg->primary->tls_gotno;
2931 /* If we can merge with the last-created got, do it. */
2932 else if (arg->current
2933 && arg->current_count + lcount + gcount + tcount <= maxcnt)
2935 struct mips_got_info *g = bfd2got->g;
2936 int old_lcount = arg->current->local_gotno;
2937 int old_gcount = arg->current->global_gotno;
2938 int old_tcount = arg->current->tls_gotno;
2940 bfd2got->g = arg->current;
2942 htab_traverse (g->got_entries,
2943 mips_elf_make_got_per_bfd,
2945 if (arg->obfd == NULL)
2948 htab_delete (g->got_entries);
2950 BFD_ASSERT (old_lcount + lcount >= arg->current->local_gotno);
2951 BFD_ASSERT (old_gcount + gcount >= arg->current->global_gotno);
2952 BFD_ASSERT (old_tcount + tcount >= arg->current->tls_gotno);
2954 arg->current_count = arg->current->local_gotno
2955 + arg->current->global_gotno + arg->current->tls_gotno;
2957 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2958 fits; if it turns out that it doesn't, we'll get relocation
2959 overflows anyway. */
2962 bfd2got->g->next = arg->current;
2963 arg->current = bfd2got->g;
2965 arg->current_count = lcount + gcount + 2 * tcount;
2971 /* Set the TLS GOT index for the GOT entry in ENTRYP. */
2974 mips_elf_initialize_tls_index (void **entryp, void *p)
2976 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2977 struct mips_got_info *g = p;
2979 /* We're only interested in TLS symbols. */
2980 if (entry->tls_type == 0)
2983 if (entry->symndx == -1)
2985 /* There may be multiple mips_got_entry structs for a global variable
2986 if there is just one GOT. Just do this once. */
2987 if (g->next == NULL)
2989 if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
2991 entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
2994 else if (entry->tls_type & GOT_TLS_LDM)
2996 /* Similarly, there may be multiple structs for the LDM entry. */
2997 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
2999 entry->gotidx = g->tls_ldm_offset;
3004 /* Initialize the GOT offset. */
3005 entry->gotidx = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
3006 if (g->next == NULL && entry->symndx == -1)
3007 entry->d.h->tls_got_offset = entry->gotidx;
3009 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3010 g->tls_assigned_gotno += 2;
3011 if (entry->tls_type & GOT_TLS_IE)
3012 g->tls_assigned_gotno += 1;
3014 if (entry->tls_type & GOT_TLS_LDM)
3015 g->tls_ldm_offset = entry->gotidx;
3020 /* If passed a NULL mips_got_info in the argument, set the marker used
3021 to tell whether a global symbol needs a got entry (in the primary
3022 got) to the given VALUE.
3024 If passed a pointer G to a mips_got_info in the argument (it must
3025 not be the primary GOT), compute the offset from the beginning of
3026 the (primary) GOT section to the entry in G corresponding to the
3027 global symbol. G's assigned_gotno must contain the index of the
3028 first available global GOT entry in G. VALUE must contain the size
3029 of a GOT entry in bytes. For each global GOT entry that requires a
3030 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3031 marked as not eligible for lazy resolution through a function
3034 mips_elf_set_global_got_offset (void **entryp, void *p)
3036 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3037 struct mips_elf_set_global_got_offset_arg *arg
3038 = (struct mips_elf_set_global_got_offset_arg *)p;
3039 struct mips_got_info *g = arg->g;
3041 if (g && entry->tls_type != GOT_NORMAL)
3042 arg->needed_relocs +=
3043 mips_tls_got_relocs (arg->info, entry->tls_type,
3044 entry->symndx == -1 ? &entry->d.h->root : NULL);
3046 if (entry->abfd != NULL && entry->symndx == -1
3047 && entry->d.h->root.dynindx != -1
3048 && entry->d.h->tls_type == GOT_NORMAL)
3052 BFD_ASSERT (g->global_gotsym == NULL);
3054 entry->gotidx = arg->value * (long) g->assigned_gotno++;
3055 if (arg->info->shared
3056 || (elf_hash_table (arg->info)->dynamic_sections_created
3057 && entry->d.h->root.def_dynamic
3058 && !entry->d.h->root.def_regular))
3059 ++arg->needed_relocs;
3062 entry->d.h->root.got.offset = arg->value;
3068 /* Mark any global symbols referenced in the GOT we are iterating over
3069 as inelligible for lazy resolution stubs. */
3071 mips_elf_set_no_stub (void **entryp, void *p ATTRIBUTE_UNUSED)
3073 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3075 if (entry->abfd != NULL
3076 && entry->symndx == -1
3077 && entry->d.h->root.dynindx != -1)
3078 entry->d.h->no_fn_stub = TRUE;
3083 /* Follow indirect and warning hash entries so that each got entry
3084 points to the final symbol definition. P must point to a pointer
3085 to the hash table we're traversing. Since this traversal may
3086 modify the hash table, we set this pointer to NULL to indicate
3087 we've made a potentially-destructive change to the hash table, so
3088 the traversal must be restarted. */
3090 mips_elf_resolve_final_got_entry (void **entryp, void *p)
3092 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3093 htab_t got_entries = *(htab_t *)p;
3095 if (entry->abfd != NULL && entry->symndx == -1)
3097 struct mips_elf_link_hash_entry *h = entry->d.h;
3099 while (h->root.root.type == bfd_link_hash_indirect
3100 || h->root.root.type == bfd_link_hash_warning)
3101 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3103 if (entry->d.h == h)
3108 /* If we can't find this entry with the new bfd hash, re-insert
3109 it, and get the traversal restarted. */
3110 if (! htab_find (got_entries, entry))
3112 htab_clear_slot (got_entries, entryp);
3113 entryp = htab_find_slot (got_entries, entry, INSERT);
3116 /* Abort the traversal, since the whole table may have
3117 moved, and leave it up to the parent to restart the
3119 *(htab_t *)p = NULL;
3122 /* We might want to decrement the global_gotno count, but it's
3123 either too early or too late for that at this point. */
3129 /* Turn indirect got entries in a got_entries table into their final
3132 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3138 got_entries = g->got_entries;
3140 htab_traverse (got_entries,
3141 mips_elf_resolve_final_got_entry,
3144 while (got_entries == NULL);
3147 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3150 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
3152 if (g->bfd2got == NULL)
3155 g = mips_elf_got_for_ibfd (g, ibfd);
3159 BFD_ASSERT (g->next);
3163 return (g->local_gotno + g->global_gotno + g->tls_gotno)
3164 * MIPS_ELF_GOT_SIZE (abfd);
3167 /* Turn a single GOT that is too big for 16-bit addressing into
3168 a sequence of GOTs, each one 16-bit addressable. */
3171 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
3172 struct mips_got_info *g, asection *got,
3173 bfd_size_type pages)
3175 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
3176 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
3177 struct mips_got_info *gg;
3178 unsigned int assign;
3180 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
3181 mips_elf_bfd2got_entry_eq, NULL);
3182 if (g->bfd2got == NULL)
3185 got_per_bfd_arg.bfd2got = g->bfd2got;
3186 got_per_bfd_arg.obfd = abfd;
3187 got_per_bfd_arg.info = info;
3189 /* Count how many GOT entries each input bfd requires, creating a
3190 map from bfd to got info while at that. */
3191 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
3192 if (got_per_bfd_arg.obfd == NULL)
3195 got_per_bfd_arg.current = NULL;
3196 got_per_bfd_arg.primary = NULL;
3197 /* Taking out PAGES entries is a worst-case estimate. We could
3198 compute the maximum number of pages that each separate input bfd
3199 uses, but it's probably not worth it. */
3200 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (abfd)
3201 / MIPS_ELF_GOT_SIZE (abfd))
3202 - MIPS_RESERVED_GOTNO - pages);
3203 /* The number of globals that will be included in the primary GOT.
3204 See the calls to mips_elf_set_global_got_offset below for more
3206 got_per_bfd_arg.global_count = g->global_gotno;
3208 /* Try to merge the GOTs of input bfds together, as long as they
3209 don't seem to exceed the maximum GOT size, choosing one of them
3210 to be the primary GOT. */
3211 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
3212 if (got_per_bfd_arg.obfd == NULL)
3215 /* If we do not find any suitable primary GOT, create an empty one. */
3216 if (got_per_bfd_arg.primary == NULL)
3218 g->next = (struct mips_got_info *)
3219 bfd_alloc (abfd, sizeof (struct mips_got_info));
3220 if (g->next == NULL)
3223 g->next->global_gotsym = NULL;
3224 g->next->global_gotno = 0;
3225 g->next->local_gotno = 0;
3226 g->next->tls_gotno = 0;
3227 g->next->assigned_gotno = 0;
3228 g->next->tls_assigned_gotno = 0;
3229 g->next->tls_ldm_offset = MINUS_ONE;
3230 g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3231 mips_elf_multi_got_entry_eq,
3233 if (g->next->got_entries == NULL)
3235 g->next->bfd2got = NULL;
3238 g->next = got_per_bfd_arg.primary;
3239 g->next->next = got_per_bfd_arg.current;
3241 /* GG is now the master GOT, and G is the primary GOT. */
3245 /* Map the output bfd to the primary got. That's what we're going
3246 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3247 didn't mark in check_relocs, and we want a quick way to find it.
3248 We can't just use gg->next because we're going to reverse the
3251 struct mips_elf_bfd2got_hash *bfdgot;
3254 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
3255 (abfd, sizeof (struct mips_elf_bfd2got_hash));
3262 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
3264 BFD_ASSERT (*bfdgotp == NULL);
3268 /* The IRIX dynamic linker requires every symbol that is referenced
3269 in a dynamic relocation to be present in the primary GOT, so
3270 arrange for them to appear after those that are actually
3273 GNU/Linux could very well do without it, but it would slow down
3274 the dynamic linker, since it would have to resolve every dynamic
3275 symbol referenced in other GOTs more than once, without help from
3276 the cache. Also, knowing that every external symbol has a GOT
3277 helps speed up the resolution of local symbols too, so GNU/Linux
3278 follows IRIX's practice.
3280 The number 2 is used by mips_elf_sort_hash_table_f to count
3281 global GOT symbols that are unreferenced in the primary GOT, with
3282 an initial dynamic index computed from gg->assigned_gotno, where
3283 the number of unreferenced global entries in the primary GOT is
3287 gg->assigned_gotno = gg->global_gotno - g->global_gotno;
3288 g->global_gotno = gg->global_gotno;
3289 set_got_offset_arg.value = 2;
3293 /* This could be used for dynamic linkers that don't optimize
3294 symbol resolution while applying relocations so as to use
3295 primary GOT entries or assuming the symbol is locally-defined.
3296 With this code, we assign lower dynamic indices to global
3297 symbols that are not referenced in the primary GOT, so that
3298 their entries can be omitted. */
3299 gg->assigned_gotno = 0;
3300 set_got_offset_arg.value = -1;
3303 /* Reorder dynamic symbols as described above (which behavior
3304 depends on the setting of VALUE). */
3305 set_got_offset_arg.g = NULL;
3306 htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
3307 &set_got_offset_arg);
3308 set_got_offset_arg.value = 1;
3309 htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
3310 &set_got_offset_arg);
3311 if (! mips_elf_sort_hash_table (info, 1))
3314 /* Now go through the GOTs assigning them offset ranges.
3315 [assigned_gotno, local_gotno[ will be set to the range of local
3316 entries in each GOT. We can then compute the end of a GOT by
3317 adding local_gotno to global_gotno. We reverse the list and make
3318 it circular since then we'll be able to quickly compute the
3319 beginning of a GOT, by computing the end of its predecessor. To
3320 avoid special cases for the primary GOT, while still preserving
3321 assertions that are valid for both single- and multi-got links,
3322 we arrange for the main got struct to have the right number of
3323 global entries, but set its local_gotno such that the initial
3324 offset of the primary GOT is zero. Remember that the primary GOT
3325 will become the last item in the circular linked list, so it
3326 points back to the master GOT. */
3327 gg->local_gotno = -g->global_gotno;
3328 gg->global_gotno = g->global_gotno;
3335 struct mips_got_info *gn;
3337 assign += MIPS_RESERVED_GOTNO;
3338 g->assigned_gotno = assign;
3339 g->local_gotno += assign + pages;
3340 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
3342 /* Set up any TLS entries. We always place the TLS entries after
3343 all non-TLS entries. */
3344 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
3345 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
3347 /* Take g out of the direct list, and push it onto the reversed
3348 list that gg points to. */
3354 /* Mark global symbols in every non-primary GOT as ineligible for
3357 htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL);
3361 got->size = (gg->next->local_gotno
3362 + gg->next->global_gotno
3363 + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
3369 /* Returns the first relocation of type r_type found, beginning with
3370 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3372 static const Elf_Internal_Rela *
3373 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
3374 const Elf_Internal_Rela *relocation,
3375 const Elf_Internal_Rela *relend)
3377 while (relocation < relend)
3379 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type)
3385 /* We didn't find it. */
3386 bfd_set_error (bfd_error_bad_value);
3390 /* Return whether a relocation is against a local symbol. */
3393 mips_elf_local_relocation_p (bfd *input_bfd,
3394 const Elf_Internal_Rela *relocation,
3395 asection **local_sections,
3396 bfd_boolean check_forced)
3398 unsigned long r_symndx;
3399 Elf_Internal_Shdr *symtab_hdr;
3400 struct mips_elf_link_hash_entry *h;
3403 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3404 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3405 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
3407 if (r_symndx < extsymoff)
3409 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
3414 /* Look up the hash table to check whether the symbol
3415 was forced local. */
3416 h = (struct mips_elf_link_hash_entry *)
3417 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
3418 /* Find the real hash-table entry for this symbol. */
3419 while (h->root.root.type == bfd_link_hash_indirect
3420 || h->root.root.type == bfd_link_hash_warning)
3421 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3422 if (h->root.forced_local)
3429 /* Sign-extend VALUE, which has the indicated number of BITS. */
3432 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
3434 if (value & ((bfd_vma) 1 << (bits - 1)))
3435 /* VALUE is negative. */
3436 value |= ((bfd_vma) - 1) << bits;
3441 /* Return non-zero if the indicated VALUE has overflowed the maximum
3442 range expressible by a signed number with the indicated number of
3446 mips_elf_overflow_p (bfd_vma value, int bits)
3448 bfd_signed_vma svalue = (bfd_signed_vma) value;
3450 if (svalue > (1 << (bits - 1)) - 1)
3451 /* The value is too big. */
3453 else if (svalue < -(1 << (bits - 1)))
3454 /* The value is too small. */
3461 /* Calculate the %high function. */
3464 mips_elf_high (bfd_vma value)
3466 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
3469 /* Calculate the %higher function. */
3472 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
3475 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
3482 /* Calculate the %highest function. */
3485 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
3488 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3495 /* Create the .compact_rel section. */
3498 mips_elf_create_compact_rel_section
3499 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3502 register asection *s;
3504 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
3506 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
3509 s = bfd_make_section (abfd, ".compact_rel");
3511 || ! bfd_set_section_flags (abfd, s, flags)
3512 || ! bfd_set_section_alignment (abfd, s,
3513 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
3516 s->size = sizeof (Elf32_External_compact_rel);
3522 /* Create the .got section to hold the global offset table. */
3525 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info,
3526 bfd_boolean maybe_exclude)
3529 register asection *s;
3530 struct elf_link_hash_entry *h;
3531 struct bfd_link_hash_entry *bh;
3532 struct mips_got_info *g;
3535 /* This function may be called more than once. */
3536 s = mips_elf_got_section (abfd, TRUE);
3539 if (! maybe_exclude)
3540 s->flags &= ~SEC_EXCLUDE;
3544 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3545 | SEC_LINKER_CREATED);
3548 flags |= SEC_EXCLUDE;
3550 /* We have to use an alignment of 2**4 here because this is hardcoded
3551 in the function stub generation and in the linker script. */
3552 s = bfd_make_section (abfd, ".got");
3554 || ! bfd_set_section_flags (abfd, s, flags)
3555 || ! bfd_set_section_alignment (abfd, s, 4))
3558 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3559 linker script because we don't want to define the symbol if we
3560 are not creating a global offset table. */
3562 if (! (_bfd_generic_link_add_one_symbol
3563 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
3564 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3567 h = (struct elf_link_hash_entry *) bh;
3570 h->type = STT_OBJECT;
3573 && ! bfd_elf_link_record_dynamic_symbol (info, h))
3576 amt = sizeof (struct mips_got_info);
3577 g = bfd_alloc (abfd, amt);
3580 g->global_gotsym = NULL;
3581 g->global_gotno = 0;
3583 g->local_gotno = MIPS_RESERVED_GOTNO;
3584 g->assigned_gotno = MIPS_RESERVED_GOTNO;
3587 g->tls_ldm_offset = MINUS_ONE;
3588 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
3589 mips_elf_got_entry_eq, NULL);
3590 if (g->got_entries == NULL)
3592 mips_elf_section_data (s)->u.got_info = g;
3593 mips_elf_section_data (s)->elf.this_hdr.sh_flags
3594 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3599 /* Calculate the value produced by the RELOCATION (which comes from
3600 the INPUT_BFD). The ADDEND is the addend to use for this
3601 RELOCATION; RELOCATION->R_ADDEND is ignored.
3603 The result of the relocation calculation is stored in VALUEP.
3604 REQUIRE_JALXP indicates whether or not the opcode used with this
3605 relocation must be JALX.
3607 This function returns bfd_reloc_continue if the caller need take no
3608 further action regarding this relocation, bfd_reloc_notsupported if
3609 something goes dramatically wrong, bfd_reloc_overflow if an
3610 overflow occurs, and bfd_reloc_ok to indicate success. */
3612 static bfd_reloc_status_type
3613 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
3614 asection *input_section,
3615 struct bfd_link_info *info,
3616 const Elf_Internal_Rela *relocation,
3617 bfd_vma addend, reloc_howto_type *howto,
3618 Elf_Internal_Sym *local_syms,
3619 asection **local_sections, bfd_vma *valuep,
3620 const char **namep, bfd_boolean *require_jalxp,
3621 bfd_boolean save_addend)
3623 /* The eventual value we will return. */
3625 /* The address of the symbol against which the relocation is
3628 /* The final GP value to be used for the relocatable, executable, or
3629 shared object file being produced. */
3630 bfd_vma gp = MINUS_ONE;
3631 /* The place (section offset or address) of the storage unit being
3634 /* The value of GP used to create the relocatable object. */
3635 bfd_vma gp0 = MINUS_ONE;
3636 /* The offset into the global offset table at which the address of
3637 the relocation entry symbol, adjusted by the addend, resides
3638 during execution. */
3639 bfd_vma g = MINUS_ONE;
3640 /* The section in which the symbol referenced by the relocation is
3642 asection *sec = NULL;
3643 struct mips_elf_link_hash_entry *h = NULL;
3644 /* TRUE if the symbol referred to by this relocation is a local
3646 bfd_boolean local_p, was_local_p;
3647 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3648 bfd_boolean gp_disp_p = FALSE;
3649 /* TRUE if the symbol referred to by this relocation is
3650 "__gnu_local_gp". */
3651 bfd_boolean gnu_local_gp_p = FALSE;
3652 Elf_Internal_Shdr *symtab_hdr;
3654 unsigned long r_symndx;
3656 /* TRUE if overflow occurred during the calculation of the
3657 relocation value. */
3658 bfd_boolean overflowed_p;
3659 /* TRUE if this relocation refers to a MIPS16 function. */
3660 bfd_boolean target_is_16_bit_code_p = FALSE;
3662 /* Parse the relocation. */
3663 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3664 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3665 p = (input_section->output_section->vma
3666 + input_section->output_offset
3667 + relocation->r_offset);
3669 /* Assume that there will be no overflow. */
3670 overflowed_p = FALSE;
3672 /* Figure out whether or not the symbol is local, and get the offset
3673 used in the array of hash table entries. */
3674 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3675 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3676 local_sections, FALSE);
3677 was_local_p = local_p;
3678 if (! elf_bad_symtab (input_bfd))
3679 extsymoff = symtab_hdr->sh_info;
3682 /* The symbol table does not follow the rule that local symbols
3683 must come before globals. */
3687 /* Figure out the value of the symbol. */
3690 Elf_Internal_Sym *sym;
3692 sym = local_syms + r_symndx;
3693 sec = local_sections[r_symndx];
3695 symbol = sec->output_section->vma + sec->output_offset;
3696 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
3697 || (sec->flags & SEC_MERGE))
3698 symbol += sym->st_value;
3699 if ((sec->flags & SEC_MERGE)
3700 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3702 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
3704 addend += sec->output_section->vma + sec->output_offset;
3707 /* MIPS16 text labels should be treated as odd. */
3708 if (sym->st_other == STO_MIPS16)
3711 /* Record the name of this symbol, for our caller. */
3712 *namep = bfd_elf_string_from_elf_section (input_bfd,
3713 symtab_hdr->sh_link,
3716 *namep = bfd_section_name (input_bfd, sec);
3718 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3722 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3724 /* For global symbols we look up the symbol in the hash-table. */
3725 h = ((struct mips_elf_link_hash_entry *)
3726 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3727 /* Find the real hash-table entry for this symbol. */
3728 while (h->root.root.type == bfd_link_hash_indirect
3729 || h->root.root.type == bfd_link_hash_warning)
3730 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3732 /* Record the name of this symbol, for our caller. */
3733 *namep = h->root.root.root.string;
3735 /* See if this is the special _gp_disp symbol. Note that such a
3736 symbol must always be a global symbol. */
3737 if (strcmp (*namep, "_gp_disp") == 0
3738 && ! NEWABI_P (input_bfd))
3740 /* Relocations against _gp_disp are permitted only with
3741 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3742 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16
3743 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
3744 return bfd_reloc_notsupported;
3748 /* See if this is the special _gp symbol. Note that such a
3749 symbol must always be a global symbol. */
3750 else if (strcmp (*namep, "__gnu_local_gp") == 0)
3751 gnu_local_gp_p = TRUE;
3754 /* If this symbol is defined, calculate its address. Note that
3755 _gp_disp is a magic symbol, always implicitly defined by the
3756 linker, so it's inappropriate to check to see whether or not
3758 else if ((h->root.root.type == bfd_link_hash_defined
3759 || h->root.root.type == bfd_link_hash_defweak)
3760 && h->root.root.u.def.section)
3762 sec = h->root.root.u.def.section;
3763 if (sec->output_section)
3764 symbol = (h->root.root.u.def.value
3765 + sec->output_section->vma
3766 + sec->output_offset);
3768 symbol = h->root.root.u.def.value;
3770 else if (h->root.root.type == bfd_link_hash_undefweak)
3771 /* We allow relocations against undefined weak symbols, giving
3772 it the value zero, so that you can undefined weak functions
3773 and check to see if they exist by looking at their
3776 else if (info->unresolved_syms_in_objects == RM_IGNORE
3777 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3779 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
3780 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3782 /* If this is a dynamic link, we should have created a
3783 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3784 in in _bfd_mips_elf_create_dynamic_sections.
3785 Otherwise, we should define the symbol with a value of 0.
3786 FIXME: It should probably get into the symbol table
3788 BFD_ASSERT (! info->shared);
3789 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3794 if (! ((*info->callbacks->undefined_symbol)
3795 (info, h->root.root.root.string, input_bfd,
3796 input_section, relocation->r_offset,
3797 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
3798 || ELF_ST_VISIBILITY (h->root.other))))
3799 return bfd_reloc_undefined;
3803 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3806 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3807 need to redirect the call to the stub, unless we're already *in*
3809 if (r_type != R_MIPS16_26 && !info->relocatable
3810 && ((h != NULL && h->fn_stub != NULL)
3811 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3812 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3813 && !mips_elf_stub_section_p (input_bfd, input_section))
3815 /* This is a 32- or 64-bit call to a 16-bit function. We should
3816 have already noticed that we were going to need the
3819 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3822 BFD_ASSERT (h->need_fn_stub);
3826 symbol = sec->output_section->vma + sec->output_offset;
3828 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3829 need to redirect the call to the stub. */
3830 else if (r_type == R_MIPS16_26 && !info->relocatable
3832 && (h->call_stub != NULL || h->call_fp_stub != NULL)
3833 && !target_is_16_bit_code_p)
3835 /* If both call_stub and call_fp_stub are defined, we can figure
3836 out which one to use by seeing which one appears in the input
3838 if (h->call_stub != NULL && h->call_fp_stub != NULL)
3843 for (o = input_bfd->sections; o != NULL; o = o->next)
3845 if (strncmp (bfd_get_section_name (input_bfd, o),
3846 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3848 sec = h->call_fp_stub;
3855 else if (h->call_stub != NULL)
3858 sec = h->call_fp_stub;
3860 BFD_ASSERT (sec->size > 0);
3861 symbol = sec->output_section->vma + sec->output_offset;
3864 /* Calls from 16-bit code to 32-bit code and vice versa require the
3865 special jalx instruction. */
3866 *require_jalxp = (!info->relocatable
3867 && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
3868 || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
3870 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3871 local_sections, TRUE);
3873 /* If we haven't already determined the GOT offset, or the GP value,
3874 and we're going to need it, get it now. */
3877 case R_MIPS_GOT_PAGE:
3878 case R_MIPS_GOT_OFST:
3879 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3881 local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1);
3882 if (local_p || r_type == R_MIPS_GOT_OFST)
3888 case R_MIPS_GOT_DISP:
3889 case R_MIPS_GOT_HI16:
3890 case R_MIPS_CALL_HI16:
3891 case R_MIPS_GOT_LO16:
3892 case R_MIPS_CALL_LO16:
3894 case R_MIPS_TLS_GOTTPREL:
3895 case R_MIPS_TLS_LDM:
3896 /* Find the index into the GOT where this value is located. */
3897 if (r_type == R_MIPS_TLS_LDM)
3899 g = mips_elf_local_got_index (abfd, input_bfd, info, 0, 0, NULL,
3902 return bfd_reloc_outofrange;
3906 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3907 GOT_PAGE relocation that decays to GOT_DISP because the
3908 symbol turns out to be global. The addend is then added
3910 BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
3911 g = mips_elf_global_got_index (elf_hash_table (info)->dynobj,
3913 (struct elf_link_hash_entry *) h,
3915 if (h->tls_type == GOT_NORMAL
3916 && (! elf_hash_table(info)->dynamic_sections_created
3918 && (info->symbolic || h->root.dynindx == -1)
3919 && h->root.def_regular)))
3921 /* This is a static link or a -Bsymbolic link. The
3922 symbol is defined locally, or was forced to be local.
3923 We must initialize this entry in the GOT. */
3924 bfd *tmpbfd = elf_hash_table (info)->dynobj;
3925 asection *sgot = mips_elf_got_section (tmpbfd, FALSE);
3926 MIPS_ELF_PUT_WORD (tmpbfd, symbol, sgot->contents + g);
3929 else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3930 /* There's no need to create a local GOT entry here; the
3931 calculation for a local GOT16 entry does not involve G. */
3935 g = mips_elf_local_got_index (abfd, input_bfd,
3936 info, symbol + addend, r_symndx, h,
3939 return bfd_reloc_outofrange;
3942 /* Convert GOT indices to actual offsets. */
3943 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3944 abfd, input_bfd, g);
3949 case R_MIPS_GPREL16:
3950 case R_MIPS_GPREL32:
3951 case R_MIPS_LITERAL:
3954 case R_MIPS16_GPREL:
3955 gp0 = _bfd_get_gp_value (input_bfd);
3956 gp = _bfd_get_gp_value (abfd);
3957 if (elf_hash_table (info)->dynobj)
3958 gp += mips_elf_adjust_gp (abfd,
3960 (elf_hash_table (info)->dynobj, NULL),
3971 /* Figure out what kind of relocation is being performed. */
3975 return bfd_reloc_continue;
3978 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
3979 overflowed_p = mips_elf_overflow_p (value, 16);
3986 || (elf_hash_table (info)->dynamic_sections_created
3988 && h->root.def_dynamic
3989 && !h->root.def_regular))
3991 && (input_section->flags & SEC_ALLOC) != 0)
3993 /* If we're creating a shared library, or this relocation is
3994 against a symbol in a shared library, then we can't know
3995 where the symbol will end up. So, we create a relocation
3996 record in the output, and leave the job up to the dynamic
3999 if (!mips_elf_create_dynamic_relocation (abfd,
4007 return bfd_reloc_undefined;
4011 if (r_type != R_MIPS_REL32)
4012 value = symbol + addend;
4016 value &= howto->dst_mask;
4020 value = symbol + addend - p;
4021 value &= howto->dst_mask;
4024 case R_MIPS_GNU_REL16_S2:
4025 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
4026 overflowed_p = mips_elf_overflow_p (value, 18);
4027 value = (value >> 2) & howto->dst_mask;
4031 /* The calculation for R_MIPS16_26 is just the same as for an
4032 R_MIPS_26. It's only the storage of the relocated field into
4033 the output file that's different. That's handled in
4034 mips_elf_perform_relocation. So, we just fall through to the
4035 R_MIPS_26 case here. */
4038 value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2;
4041 value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2;
4042 if (h->root.root.type != bfd_link_hash_undefweak)
4043 overflowed_p = (value >> 26) != ((p + 4) >> 28);
4045 value &= howto->dst_mask;
4048 case R_MIPS_TLS_DTPREL_HI16:
4049 value = (mips_elf_high (addend + symbol - dtprel_base (info))
4053 case R_MIPS_TLS_DTPREL_LO16:
4054 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
4057 case R_MIPS_TLS_TPREL_HI16:
4058 value = (mips_elf_high (addend + symbol - tprel_base (info))
4062 case R_MIPS_TLS_TPREL_LO16:
4063 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
4070 value = mips_elf_high (addend + symbol);
4071 value &= howto->dst_mask;
4075 /* For MIPS16 ABI code we generate this sequence
4076 0: li $v0,%hi(_gp_disp)
4077 4: addiupc $v1,%lo(_gp_disp)
4081 So the offsets of hi and lo relocs are the same, but the
4082 $pc is four higher than $t9 would be, so reduce
4083 both reloc addends by 4. */
4084 if (r_type == R_MIPS16_HI16)
4085 value = mips_elf_high (addend + gp - p - 4);
4087 value = mips_elf_high (addend + gp - p);
4088 overflowed_p = mips_elf_overflow_p (value, 16);
4095 value = (symbol + addend) & howto->dst_mask;
4098 /* See the comment for R_MIPS16_HI16 above for the reason
4099 for this conditional. */
4100 if (r_type == R_MIPS16_LO16)
4101 value = addend + gp - p;
4103 value = addend + gp - p + 4;
4104 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4105 for overflow. But, on, say, IRIX5, relocations against
4106 _gp_disp are normally generated from the .cpload
4107 pseudo-op. It generates code that normally looks like
4110 lui $gp,%hi(_gp_disp)
4111 addiu $gp,$gp,%lo(_gp_disp)
4114 Here $t9 holds the address of the function being called,
4115 as required by the MIPS ELF ABI. The R_MIPS_LO16
4116 relocation can easily overflow in this situation, but the
4117 R_MIPS_HI16 relocation will handle the overflow.
4118 Therefore, we consider this a bug in the MIPS ABI, and do
4119 not check for overflow here. */
4123 case R_MIPS_LITERAL:
4124 /* Because we don't merge literal sections, we can handle this
4125 just like R_MIPS_GPREL16. In the long run, we should merge
4126 shared literals, and then we will need to additional work
4131 case R_MIPS16_GPREL:
4132 /* The R_MIPS16_GPREL performs the same calculation as
4133 R_MIPS_GPREL16, but stores the relocated bits in a different
4134 order. We don't need to do anything special here; the
4135 differences are handled in mips_elf_perform_relocation. */
4136 case R_MIPS_GPREL16:
4137 /* Only sign-extend the addend if it was extracted from the
4138 instruction. If the addend was separate, leave it alone,
4139 otherwise we may lose significant bits. */
4140 if (howto->partial_inplace)
4141 addend = _bfd_mips_elf_sign_extend (addend, 16);
4142 value = symbol + addend - gp;
4143 /* If the symbol was local, any earlier relocatable links will
4144 have adjusted its addend with the gp offset, so compensate
4145 for that now. Don't do it for symbols forced local in this
4146 link, though, since they won't have had the gp offset applied
4150 overflowed_p = mips_elf_overflow_p (value, 16);
4159 /* The special case is when the symbol is forced to be local. We
4160 need the full address in the GOT since no R_MIPS_LO16 relocation
4162 forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
4163 local_sections, FALSE);
4164 value = mips_elf_got16_entry (abfd, input_bfd, info,
4165 symbol + addend, forced);
4166 if (value == MINUS_ONE)
4167 return bfd_reloc_outofrange;
4169 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
4170 abfd, input_bfd, value);
4171 overflowed_p = mips_elf_overflow_p (value, 16);
4178 case R_MIPS_TLS_GOTTPREL:
4179 case R_MIPS_TLS_LDM:
4180 case R_MIPS_GOT_DISP:
4183 overflowed_p = mips_elf_overflow_p (value, 16);
4186 case R_MIPS_GPREL32:
4187 value = (addend + symbol + gp0 - gp);
4189 value &= howto->dst_mask;
4193 value = _bfd_mips_elf_sign_extend (addend, 16) + symbol - p;
4194 overflowed_p = mips_elf_overflow_p (value, 16);
4197 case R_MIPS_GOT_HI16:
4198 case R_MIPS_CALL_HI16:
4199 /* We're allowed to handle these two relocations identically.
4200 The dynamic linker is allowed to handle the CALL relocations
4201 differently by creating a lazy evaluation stub. */
4203 value = mips_elf_high (value);
4204 value &= howto->dst_mask;
4207 case R_MIPS_GOT_LO16:
4208 case R_MIPS_CALL_LO16:
4209 value = g & howto->dst_mask;
4212 case R_MIPS_GOT_PAGE:
4213 /* GOT_PAGE relocations that reference non-local symbols decay
4214 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4218 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
4219 if (value == MINUS_ONE)
4220 return bfd_reloc_outofrange;
4221 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
4222 abfd, input_bfd, value);
4223 overflowed_p = mips_elf_overflow_p (value, 16);
4226 case R_MIPS_GOT_OFST:
4228 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
4231 overflowed_p = mips_elf_overflow_p (value, 16);
4235 value = symbol - addend;
4236 value &= howto->dst_mask;
4240 value = mips_elf_higher (addend + symbol);
4241 value &= howto->dst_mask;
4244 case R_MIPS_HIGHEST:
4245 value = mips_elf_highest (addend + symbol);
4246 value &= howto->dst_mask;
4249 case R_MIPS_SCN_DISP:
4250 value = symbol + addend - sec->output_offset;
4251 value &= howto->dst_mask;
4255 /* This relocation is only a hint. In some cases, we optimize
4256 it into a bal instruction. But we don't try to optimize
4257 branches to the PLT; that will wind up wasting time. */
4258 if (h != NULL && h->root.plt.offset != (bfd_vma) -1)
4259 return bfd_reloc_continue;
4260 value = symbol + addend;
4264 case R_MIPS_GNU_VTINHERIT:
4265 case R_MIPS_GNU_VTENTRY:
4266 /* We don't do anything with these at present. */
4267 return bfd_reloc_continue;
4270 /* An unrecognized relocation type. */
4271 return bfd_reloc_notsupported;
4274 /* Store the VALUE for our caller. */
4276 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
4279 /* Obtain the field relocated by RELOCATION. */
4282 mips_elf_obtain_contents (reloc_howto_type *howto,
4283 const Elf_Internal_Rela *relocation,
4284 bfd *input_bfd, bfd_byte *contents)
4287 bfd_byte *location = contents + relocation->r_offset;
4289 /* Obtain the bytes. */
4290 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
4295 /* It has been determined that the result of the RELOCATION is the
4296 VALUE. Use HOWTO to place VALUE into the output file at the
4297 appropriate position. The SECTION is the section to which the
4298 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4299 for the relocation must be either JAL or JALX, and it is
4300 unconditionally converted to JALX.
4302 Returns FALSE if anything goes wrong. */
4305 mips_elf_perform_relocation (struct bfd_link_info *info,
4306 reloc_howto_type *howto,
4307 const Elf_Internal_Rela *relocation,
4308 bfd_vma value, bfd *input_bfd,
4309 asection *input_section, bfd_byte *contents,
4310 bfd_boolean require_jalx)
4314 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
4316 /* Figure out where the relocation is occurring. */
4317 location = contents + relocation->r_offset;
4319 _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
4321 /* Obtain the current value. */
4322 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
4324 /* Clear the field we are setting. */
4325 x &= ~howto->dst_mask;
4327 /* Set the field. */
4328 x |= (value & howto->dst_mask);
4330 /* If required, turn JAL into JALX. */
4334 bfd_vma opcode = x >> 26;
4335 bfd_vma jalx_opcode;
4337 /* Check to see if the opcode is already JAL or JALX. */
4338 if (r_type == R_MIPS16_26)
4340 ok = ((opcode == 0x6) || (opcode == 0x7));
4345 ok = ((opcode == 0x3) || (opcode == 0x1d));
4349 /* If the opcode is not JAL or JALX, there's a problem. */
4352 (*_bfd_error_handler)
4353 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4356 (unsigned long) relocation->r_offset);
4357 bfd_set_error (bfd_error_bad_value);
4361 /* Make this the JALX opcode. */
4362 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
4365 /* On the RM9000, bal is faster than jal, because bal uses branch
4366 prediction hardware. If we are linking for the RM9000, and we
4367 see jal, and bal fits, use it instead. Note that this
4368 transformation should be safe for all architectures. */
4369 if (bfd_get_mach (input_bfd) == bfd_mach_mips9000
4370 && !info->relocatable
4372 && ((r_type == R_MIPS_26 && (x >> 26) == 0x3) /* jal addr */
4373 || (r_type == R_MIPS_JALR && x == 0x0320f809))) /* jalr t9 */
4379 addr = (input_section->output_section->vma
4380 + input_section->output_offset
4381 + relocation->r_offset
4383 if (r_type == R_MIPS_26)
4384 dest = (value << 2) | ((addr >> 28) << 28);
4388 if (off <= 0x1ffff && off >= -0x20000)
4389 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
4392 /* Put the value into the output. */
4393 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
4395 _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, !info->relocatable,
4401 /* Returns TRUE if SECTION is a MIPS16 stub section. */
4404 mips_elf_stub_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
4406 const char *name = bfd_get_section_name (abfd, section);
4408 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
4409 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
4410 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
4413 /* Add room for N relocations to the .rel.dyn section in ABFD. */
4416 mips_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
4420 s = mips_elf_rel_dyn_section (abfd, FALSE);
4421 BFD_ASSERT (s != NULL);
4425 /* Make room for a null element. */
4426 s->size += MIPS_ELF_REL_SIZE (abfd);
4429 s->size += n * MIPS_ELF_REL_SIZE (abfd);
4432 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
4433 is the original relocation, which is now being transformed into a
4434 dynamic relocation. The ADDENDP is adjusted if necessary; the
4435 caller should store the result in place of the original addend. */
4438 mips_elf_create_dynamic_relocation (bfd *output_bfd,
4439 struct bfd_link_info *info,
4440 const Elf_Internal_Rela *rel,
4441 struct mips_elf_link_hash_entry *h,
4442 asection *sec, bfd_vma symbol,
4443 bfd_vma *addendp, asection *input_section)
4445 Elf_Internal_Rela outrel[3];
4450 bfd_boolean defined_p;
4452 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
4453 dynobj = elf_hash_table (info)->dynobj;
4454 sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
4455 BFD_ASSERT (sreloc != NULL);
4456 BFD_ASSERT (sreloc->contents != NULL);
4457 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
4460 outrel[0].r_offset =
4461 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
4462 outrel[1].r_offset =
4463 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
4464 outrel[2].r_offset =
4465 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
4467 if (outrel[0].r_offset == MINUS_ONE)
4468 /* The relocation field has been deleted. */
4471 if (outrel[0].r_offset == MINUS_TWO)
4473 /* The relocation field has been converted into a relative value of
4474 some sort. Functions like _bfd_elf_write_section_eh_frame expect
4475 the field to be fully relocated, so add in the symbol's value. */
4480 /* We must now calculate the dynamic symbol table index to use
4481 in the relocation. */
4483 && (! info->symbolic || !h->root.def_regular)
4484 /* h->root.dynindx may be -1 if this symbol was marked to
4486 && h->root.dynindx != -1)
4488 indx = h->root.dynindx;
4489 if (SGI_COMPAT (output_bfd))
4490 defined_p = h->root.def_regular;
4492 /* ??? glibc's ld.so just adds the final GOT entry to the
4493 relocation field. It therefore treats relocs against
4494 defined symbols in the same way as relocs against
4495 undefined symbols. */
4500 if (sec != NULL && bfd_is_abs_section (sec))
4502 else if (sec == NULL || sec->owner == NULL)
4504 bfd_set_error (bfd_error_bad_value);
4509 indx = elf_section_data (sec->output_section)->dynindx;
4514 /* Instead of generating a relocation using the section
4515 symbol, we may as well make it a fully relative
4516 relocation. We want to avoid generating relocations to
4517 local symbols because we used to generate them
4518 incorrectly, without adding the original symbol value,
4519 which is mandated by the ABI for section symbols. In
4520 order to give dynamic loaders and applications time to
4521 phase out the incorrect use, we refrain from emitting
4522 section-relative relocations. It's not like they're
4523 useful, after all. This should be a bit more efficient
4525 /* ??? Although this behavior is compatible with glibc's ld.so,
4526 the ABI says that relocations against STN_UNDEF should have
4527 a symbol value of 0. Irix rld honors this, so relocations
4528 against STN_UNDEF have no effect. */
4529 if (!SGI_COMPAT (output_bfd))
4534 /* If the relocation was previously an absolute relocation and
4535 this symbol will not be referred to by the relocation, we must
4536 adjust it by the value we give it in the dynamic symbol table.
4537 Otherwise leave the job up to the dynamic linker. */
4538 if (defined_p && r_type != R_MIPS_REL32)
4541 /* The relocation is always an REL32 relocation because we don't
4542 know where the shared library will wind up at load-time. */
4543 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
4545 /* For strict adherence to the ABI specification, we should
4546 generate a R_MIPS_64 relocation record by itself before the
4547 _REL32/_64 record as well, such that the addend is read in as
4548 a 64-bit value (REL32 is a 32-bit relocation, after all).
4549 However, since none of the existing ELF64 MIPS dynamic
4550 loaders seems to care, we don't waste space with these
4551 artificial relocations. If this turns out to not be true,
4552 mips_elf_allocate_dynamic_relocation() should be tweaked so
4553 as to make room for a pair of dynamic relocations per
4554 invocation if ABI_64_P, and here we should generate an
4555 additional relocation record with R_MIPS_64 by itself for a
4556 NULL symbol before this relocation record. */
4557 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
4558 ABI_64_P (output_bfd)
4561 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
4563 /* Adjust the output offset of the relocation to reference the
4564 correct location in the output file. */
4565 outrel[0].r_offset += (input_section->output_section->vma
4566 + input_section->output_offset);
4567 outrel[1].r_offset += (input_section->output_section->vma
4568 + input_section->output_offset);
4569 outrel[2].r_offset += (input_section->output_section->vma
4570 + input_section->output_offset);
4572 /* Put the relocation back out. We have to use the special
4573 relocation outputter in the 64-bit case since the 64-bit
4574 relocation format is non-standard. */
4575 if (ABI_64_P (output_bfd))
4577 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
4578 (output_bfd, &outrel[0],
4580 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
4583 bfd_elf32_swap_reloc_out
4584 (output_bfd, &outrel[0],
4585 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
4587 /* We've now added another relocation. */
4588 ++sreloc->reloc_count;
4590 /* Make sure the output section is writable. The dynamic linker
4591 will be writing to it. */
4592 elf_section_data (input_section->output_section)->this_hdr.sh_flags
4595 /* On IRIX5, make an entry of compact relocation info. */
4596 if (IRIX_COMPAT (output_bfd) == ict_irix5)
4598 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
4603 Elf32_crinfo cptrel;
4605 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
4606 cptrel.vaddr = (rel->r_offset
4607 + input_section->output_section->vma
4608 + input_section->output_offset);
4609 if (r_type == R_MIPS_REL32)
4610 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
4612 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
4613 mips_elf_set_cr_dist2to (cptrel, 0);
4614 cptrel.konst = *addendp;
4616 cr = (scpt->contents
4617 + sizeof (Elf32_External_compact_rel));
4618 mips_elf_set_cr_relvaddr (cptrel, 0);
4619 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
4620 ((Elf32_External_crinfo *) cr
4621 + scpt->reloc_count));
4622 ++scpt->reloc_count;
4629 /* Return the MACH for a MIPS e_flags value. */
4632 _bfd_elf_mips_mach (flagword flags)
4634 switch (flags & EF_MIPS_MACH)
4636 case E_MIPS_MACH_3900:
4637 return bfd_mach_mips3900;
4639 case E_MIPS_MACH_4010:
4640 return bfd_mach_mips4010;
4642 case E_MIPS_MACH_4100:
4643 return bfd_mach_mips4100;
4645 case E_MIPS_MACH_4111:
4646 return bfd_mach_mips4111;
4648 case E_MIPS_MACH_4120:
4649 return bfd_mach_mips4120;
4651 case E_MIPS_MACH_4650:
4652 return bfd_mach_mips4650;
4654 case E_MIPS_MACH_5400:
4655 return bfd_mach_mips5400;
4657 case E_MIPS_MACH_5500:
4658 return bfd_mach_mips5500;
4660 case E_MIPS_MACH_9000:
4661 return bfd_mach_mips9000;
4663 case E_MIPS_MACH_SB1:
4664 return bfd_mach_mips_sb1;
4667 switch (flags & EF_MIPS_ARCH)
4671 return bfd_mach_mips3000;
4675 return bfd_mach_mips6000;
4679 return bfd_mach_mips4000;
4683 return bfd_mach_mips8000;
4687 return bfd_mach_mips5;
4690 case E_MIPS_ARCH_32:
4691 return bfd_mach_mipsisa32;
4694 case E_MIPS_ARCH_64:
4695 return bfd_mach_mipsisa64;
4698 case E_MIPS_ARCH_32R2:
4699 return bfd_mach_mipsisa32r2;
4702 case E_MIPS_ARCH_64R2:
4703 return bfd_mach_mipsisa64r2;
4711 /* Return printable name for ABI. */
4713 static INLINE char *
4714 elf_mips_abi_name (bfd *abfd)
4718 flags = elf_elfheader (abfd)->e_flags;
4719 switch (flags & EF_MIPS_ABI)
4722 if (ABI_N32_P (abfd))
4724 else if (ABI_64_P (abfd))
4728 case E_MIPS_ABI_O32:
4730 case E_MIPS_ABI_O64:
4732 case E_MIPS_ABI_EABI32:
4734 case E_MIPS_ABI_EABI64:
4737 return "unknown abi";
4741 /* MIPS ELF uses two common sections. One is the usual one, and the
4742 other is for small objects. All the small objects are kept
4743 together, and then referenced via the gp pointer, which yields
4744 faster assembler code. This is what we use for the small common
4745 section. This approach is copied from ecoff.c. */
4746 static asection mips_elf_scom_section;
4747 static asymbol mips_elf_scom_symbol;
4748 static asymbol *mips_elf_scom_symbol_ptr;
4750 /* MIPS ELF also uses an acommon section, which represents an
4751 allocated common symbol which may be overridden by a
4752 definition in a shared library. */
4753 static asection mips_elf_acom_section;
4754 static asymbol mips_elf_acom_symbol;
4755 static asymbol *mips_elf_acom_symbol_ptr;
4757 /* Handle the special MIPS section numbers that a symbol may use.
4758 This is used for both the 32-bit and the 64-bit ABI. */
4761 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
4763 elf_symbol_type *elfsym;
4765 elfsym = (elf_symbol_type *) asym;
4766 switch (elfsym->internal_elf_sym.st_shndx)
4768 case SHN_MIPS_ACOMMON:
4769 /* This section is used in a dynamically linked executable file.
4770 It is an allocated common section. The dynamic linker can
4771 either resolve these symbols to something in a shared
4772 library, or it can just leave them here. For our purposes,
4773 we can consider these symbols to be in a new section. */
4774 if (mips_elf_acom_section.name == NULL)
4776 /* Initialize the acommon section. */
4777 mips_elf_acom_section.name = ".acommon";
4778 mips_elf_acom_section.flags = SEC_ALLOC;
4779 mips_elf_acom_section.output_section = &mips_elf_acom_section;
4780 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
4781 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
4782 mips_elf_acom_symbol.name = ".acommon";
4783 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
4784 mips_elf_acom_symbol.section = &mips_elf_acom_section;
4785 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
4787 asym->section = &mips_elf_acom_section;
4791 /* Common symbols less than the GP size are automatically
4792 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4793 if (asym->value > elf_gp_size (abfd)
4794 || IRIX_COMPAT (abfd) == ict_irix6)
4797 case SHN_MIPS_SCOMMON:
4798 if (mips_elf_scom_section.name == NULL)
4800 /* Initialize the small common section. */
4801 mips_elf_scom_section.name = ".scommon";
4802 mips_elf_scom_section.flags = SEC_IS_COMMON;
4803 mips_elf_scom_section.output_section = &mips_elf_scom_section;
4804 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
4805 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
4806 mips_elf_scom_symbol.name = ".scommon";
4807 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
4808 mips_elf_scom_symbol.section = &mips_elf_scom_section;
4809 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
4811 asym->section = &mips_elf_scom_section;
4812 asym->value = elfsym->internal_elf_sym.st_size;
4815 case SHN_MIPS_SUNDEFINED:
4816 asym->section = bfd_und_section_ptr;
4821 asection *section = bfd_get_section_by_name (abfd, ".text");
4823 BFD_ASSERT (SGI_COMPAT (abfd));
4824 if (section != NULL)
4826 asym->section = section;
4827 /* MIPS_TEXT is a bit special, the address is not an offset
4828 to the base of the .text section. So substract the section
4829 base address to make it an offset. */
4830 asym->value -= section->vma;
4837 asection *section = bfd_get_section_by_name (abfd, ".data");
4839 BFD_ASSERT (SGI_COMPAT (abfd));
4840 if (section != NULL)
4842 asym->section = section;
4843 /* MIPS_DATA is a bit special, the address is not an offset
4844 to the base of the .data section. So substract the section
4845 base address to make it an offset. */
4846 asym->value -= section->vma;
4853 /* Implement elf_backend_eh_frame_address_size. This differs from
4854 the default in the way it handles EABI64.
4856 EABI64 was originally specified as an LP64 ABI, and that is what
4857 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4858 historically accepted the combination of -mabi=eabi and -mlong32,
4859 and this ILP32 variation has become semi-official over time.
4860 Both forms use elf32 and have pointer-sized FDE addresses.
4862 If an EABI object was generated by GCC 4.0 or above, it will have
4863 an empty .gcc_compiled_longXX section, where XX is the size of longs
4864 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4865 have no special marking to distinguish them from LP64 objects.
4867 We don't want users of the official LP64 ABI to be punished for the
4868 existence of the ILP32 variant, but at the same time, we don't want
4869 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4870 We therefore take the following approach:
4872 - If ABFD contains a .gcc_compiled_longXX section, use it to
4873 determine the pointer size.
4875 - Otherwise check the type of the first relocation. Assume that
4876 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4880 The second check is enough to detect LP64 objects generated by pre-4.0
4881 compilers because, in the kind of output generated by those compilers,
4882 the first relocation will be associated with either a CIE personality
4883 routine or an FDE start address. Furthermore, the compilers never
4884 used a special (non-pointer) encoding for this ABI.
4886 Checking the relocation type should also be safe because there is no
4887 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4891 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
4893 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
4895 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
4897 bfd_boolean long32_p, long64_p;
4899 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
4900 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
4901 if (long32_p && long64_p)
4908 if (sec->reloc_count > 0
4909 && elf_section_data (sec)->relocs != NULL
4910 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
4919 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4920 relocations against two unnamed section symbols to resolve to the
4921 same address. For example, if we have code like:
4923 lw $4,%got_disp(.data)($gp)
4924 lw $25,%got_disp(.text)($gp)
4927 then the linker will resolve both relocations to .data and the program
4928 will jump there rather than to .text.
4930 We can work around this problem by giving names to local section symbols.
4931 This is also what the MIPSpro tools do. */
4934 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
4936 return SGI_COMPAT (abfd);
4939 /* Work over a section just before writing it out. This routine is
4940 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4941 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4945 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
4947 if (hdr->sh_type == SHT_MIPS_REGINFO
4948 && hdr->sh_size > 0)
4952 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
4953 BFD_ASSERT (hdr->contents == NULL);
4956 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
4959 H_PUT_32 (abfd, elf_gp (abfd), buf);
4960 if (bfd_bwrite (buf, 4, abfd) != 4)
4964 if (hdr->sh_type == SHT_MIPS_OPTIONS
4965 && hdr->bfd_section != NULL
4966 && mips_elf_section_data (hdr->bfd_section) != NULL
4967 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
4969 bfd_byte *contents, *l, *lend;
4971 /* We stored the section contents in the tdata field in the
4972 set_section_contents routine. We save the section contents
4973 so that we don't have to read them again.
4974 At this point we know that elf_gp is set, so we can look
4975 through the section contents to see if there is an
4976 ODK_REGINFO structure. */
4978 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
4980 lend = contents + hdr->sh_size;
4981 while (l + sizeof (Elf_External_Options) <= lend)
4983 Elf_Internal_Options intopt;
4985 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4987 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4994 + sizeof (Elf_External_Options)
4995 + (sizeof (Elf64_External_RegInfo) - 8)),
4998 H_PUT_64 (abfd, elf_gp (abfd), buf);
4999 if (bfd_bwrite (buf, 8, abfd) != 8)
5002 else if (intopt.kind == ODK_REGINFO)
5009 + sizeof (Elf_External_Options)
5010 + (sizeof (Elf32_External_RegInfo) - 4)),
5013 H_PUT_32 (abfd, elf_gp (abfd), buf);
5014 if (bfd_bwrite (buf, 4, abfd) != 4)
5021 if (hdr->bfd_section != NULL)
5023 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
5025 if (strcmp (name, ".sdata") == 0
5026 || strcmp (name, ".lit8") == 0
5027 || strcmp (name, ".lit4") == 0)
5029 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5030 hdr->sh_type = SHT_PROGBITS;
5032 else if (strcmp (name, ".sbss") == 0)
5034 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5035 hdr->sh_type = SHT_NOBITS;
5037 else if (strcmp (name, ".srdata") == 0)
5039 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
5040 hdr->sh_type = SHT_PROGBITS;
5042 else if (strcmp (name, ".compact_rel") == 0)
5045 hdr->sh_type = SHT_PROGBITS;
5047 else if (strcmp (name, ".rtproc") == 0)
5049 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
5051 unsigned int adjust;
5053 adjust = hdr->sh_size % hdr->sh_addralign;
5055 hdr->sh_size += hdr->sh_addralign - adjust;
5063 /* Handle a MIPS specific section when reading an object file. This
5064 is called when elfcode.h finds a section with an unknown type.
5065 This routine supports both the 32-bit and 64-bit ELF ABI.
5067 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5071 _bfd_mips_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
5076 /* There ought to be a place to keep ELF backend specific flags, but
5077 at the moment there isn't one. We just keep track of the
5078 sections by their name, instead. Fortunately, the ABI gives
5079 suggested names for all the MIPS specific sections, so we will
5080 probably get away with this. */
5081 switch (hdr->sh_type)
5083 case SHT_MIPS_LIBLIST:
5084 if (strcmp (name, ".liblist") != 0)
5088 if (strcmp (name, ".msym") != 0)
5091 case SHT_MIPS_CONFLICT:
5092 if (strcmp (name, ".conflict") != 0)
5095 case SHT_MIPS_GPTAB:
5096 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
5099 case SHT_MIPS_UCODE:
5100 if (strcmp (name, ".ucode") != 0)
5103 case SHT_MIPS_DEBUG:
5104 if (strcmp (name, ".mdebug") != 0)
5106 flags = SEC_DEBUGGING;
5108 case SHT_MIPS_REGINFO:
5109 if (strcmp (name, ".reginfo") != 0
5110 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
5112 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
5114 case SHT_MIPS_IFACE:
5115 if (strcmp (name, ".MIPS.interfaces") != 0)
5118 case SHT_MIPS_CONTENT:
5119 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
5122 case SHT_MIPS_OPTIONS:
5123 if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
5126 case SHT_MIPS_DWARF:
5127 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
5130 case SHT_MIPS_SYMBOL_LIB:
5131 if (strcmp (name, ".MIPS.symlib") != 0)
5134 case SHT_MIPS_EVENTS:
5135 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
5136 && strncmp (name, ".MIPS.post_rel",
5137 sizeof ".MIPS.post_rel" - 1) != 0)
5144 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
5149 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
5150 (bfd_get_section_flags (abfd,
5156 /* FIXME: We should record sh_info for a .gptab section. */
5158 /* For a .reginfo section, set the gp value in the tdata information
5159 from the contents of this section. We need the gp value while
5160 processing relocs, so we just get it now. The .reginfo section
5161 is not used in the 64-bit MIPS ELF ABI. */
5162 if (hdr->sh_type == SHT_MIPS_REGINFO)
5164 Elf32_External_RegInfo ext;
5167 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
5168 &ext, 0, sizeof ext))
5170 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
5171 elf_gp (abfd) = s.ri_gp_value;
5174 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5175 set the gp value based on what we find. We may see both
5176 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5177 they should agree. */
5178 if (hdr->sh_type == SHT_MIPS_OPTIONS)
5180 bfd_byte *contents, *l, *lend;
5182 contents = bfd_malloc (hdr->sh_size);
5183 if (contents == NULL)
5185 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
5192 lend = contents + hdr->sh_size;
5193 while (l + sizeof (Elf_External_Options) <= lend)
5195 Elf_Internal_Options intopt;
5197 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
5199 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
5201 Elf64_Internal_RegInfo intreg;
5203 bfd_mips_elf64_swap_reginfo_in
5205 ((Elf64_External_RegInfo *)
5206 (l + sizeof (Elf_External_Options))),
5208 elf_gp (abfd) = intreg.ri_gp_value;
5210 else if (intopt.kind == ODK_REGINFO)
5212 Elf32_RegInfo intreg;
5214 bfd_mips_elf32_swap_reginfo_in
5216 ((Elf32_External_RegInfo *)
5217 (l + sizeof (Elf_External_Options))),
5219 elf_gp (abfd) = intreg.ri_gp_value;
5229 /* Set the correct type for a MIPS ELF section. We do this by the
5230 section name, which is a hack, but ought to work. This routine is
5231 used by both the 32-bit and the 64-bit ABI. */
5234 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
5236 register const char *name;
5238 name = bfd_get_section_name (abfd, sec);
5240 if (strcmp (name, ".liblist") == 0)
5242 hdr->sh_type = SHT_MIPS_LIBLIST;
5243 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
5244 /* The sh_link field is set in final_write_processing. */
5246 else if (strcmp (name, ".conflict") == 0)
5247 hdr->sh_type = SHT_MIPS_CONFLICT;
5248 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
5250 hdr->sh_type = SHT_MIPS_GPTAB;
5251 hdr->sh_entsize = sizeof (Elf32_External_gptab);
5252 /* The sh_info field is set in final_write_processing. */
5254 else if (strcmp (name, ".ucode") == 0)
5255 hdr->sh_type = SHT_MIPS_UCODE;
5256 else if (strcmp (name, ".mdebug") == 0)
5258 hdr->sh_type = SHT_MIPS_DEBUG;
5259 /* In a shared object on IRIX 5.3, the .mdebug section has an
5260 entsize of 0. FIXME: Does this matter? */
5261 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
5262 hdr->sh_entsize = 0;
5264 hdr->sh_entsize = 1;
5266 else if (strcmp (name, ".reginfo") == 0)
5268 hdr->sh_type = SHT_MIPS_REGINFO;
5269 /* In a shared object on IRIX 5.3, the .reginfo section has an
5270 entsize of 0x18. FIXME: Does this matter? */
5271 if (SGI_COMPAT (abfd))
5273 if ((abfd->flags & DYNAMIC) != 0)
5274 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5276 hdr->sh_entsize = 1;
5279 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5281 else if (SGI_COMPAT (abfd)
5282 && (strcmp (name, ".hash") == 0
5283 || strcmp (name, ".dynamic") == 0
5284 || strcmp (name, ".dynstr") == 0))
5286 if (SGI_COMPAT (abfd))
5287 hdr->sh_entsize = 0;
5289 /* This isn't how the IRIX6 linker behaves. */
5290 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
5293 else if (strcmp (name, ".got") == 0
5294 || strcmp (name, ".srdata") == 0
5295 || strcmp (name, ".sdata") == 0
5296 || strcmp (name, ".sbss") == 0
5297 || strcmp (name, ".lit4") == 0
5298 || strcmp (name, ".lit8") == 0)
5299 hdr->sh_flags |= SHF_MIPS_GPREL;
5300 else if (strcmp (name, ".MIPS.interfaces") == 0)
5302 hdr->sh_type = SHT_MIPS_IFACE;
5303 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5305 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
5307 hdr->sh_type = SHT_MIPS_CONTENT;
5308 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5309 /* The sh_info field is set in final_write_processing. */
5311 else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
5313 hdr->sh_type = SHT_MIPS_OPTIONS;
5314 hdr->sh_entsize = 1;
5315 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5317 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
5318 hdr->sh_type = SHT_MIPS_DWARF;
5319 else if (strcmp (name, ".MIPS.symlib") == 0)
5321 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
5322 /* The sh_link and sh_info fields are set in
5323 final_write_processing. */
5325 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
5326 || strncmp (name, ".MIPS.post_rel",
5327 sizeof ".MIPS.post_rel" - 1) == 0)
5329 hdr->sh_type = SHT_MIPS_EVENTS;
5330 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5331 /* The sh_link field is set in final_write_processing. */
5333 else if (strcmp (name, ".msym") == 0)
5335 hdr->sh_type = SHT_MIPS_MSYM;
5336 hdr->sh_flags |= SHF_ALLOC;
5337 hdr->sh_entsize = 8;
5340 /* The generic elf_fake_sections will set up REL_HDR using the default
5341 kind of relocations. We used to set up a second header for the
5342 non-default kind of relocations here, but only NewABI would use
5343 these, and the IRIX ld doesn't like resulting empty RELA sections.
5344 Thus we create those header only on demand now. */
5349 /* Given a BFD section, try to locate the corresponding ELF section
5350 index. This is used by both the 32-bit and the 64-bit ABI.
5351 Actually, it's not clear to me that the 64-bit ABI supports these,
5352 but for non-PIC objects we will certainly want support for at least
5353 the .scommon section. */
5356 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5357 asection *sec, int *retval)
5359 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
5361 *retval = SHN_MIPS_SCOMMON;
5364 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
5366 *retval = SHN_MIPS_ACOMMON;
5372 /* Hook called by the linker routine which adds symbols from an object
5373 file. We must handle the special MIPS section numbers here. */
5376 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
5377 Elf_Internal_Sym *sym, const char **namep,
5378 flagword *flagsp ATTRIBUTE_UNUSED,
5379 asection **secp, bfd_vma *valp)
5381 if (SGI_COMPAT (abfd)
5382 && (abfd->flags & DYNAMIC) != 0
5383 && strcmp (*namep, "_rld_new_interface") == 0)
5385 /* Skip IRIX5 rld entry name. */
5390 switch (sym->st_shndx)
5393 /* Common symbols less than the GP size are automatically
5394 treated as SHN_MIPS_SCOMMON symbols. */
5395 if (sym->st_size > elf_gp_size (abfd)
5396 || IRIX_COMPAT (abfd) == ict_irix6)
5399 case SHN_MIPS_SCOMMON:
5400 *secp = bfd_make_section_old_way (abfd, ".scommon");
5401 (*secp)->flags |= SEC_IS_COMMON;
5402 *valp = sym->st_size;
5406 /* This section is used in a shared object. */
5407 if (elf_tdata (abfd)->elf_text_section == NULL)
5409 asymbol *elf_text_symbol;
5410 asection *elf_text_section;
5411 bfd_size_type amt = sizeof (asection);
5413 elf_text_section = bfd_zalloc (abfd, amt);
5414 if (elf_text_section == NULL)
5417 amt = sizeof (asymbol);
5418 elf_text_symbol = bfd_zalloc (abfd, amt);
5419 if (elf_text_symbol == NULL)
5422 /* Initialize the section. */
5424 elf_tdata (abfd)->elf_text_section = elf_text_section;
5425 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
5427 elf_text_section->symbol = elf_text_symbol;
5428 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
5430 elf_text_section->name = ".text";
5431 elf_text_section->flags = SEC_NO_FLAGS;
5432 elf_text_section->output_section = NULL;
5433 elf_text_section->owner = abfd;
5434 elf_text_symbol->name = ".text";
5435 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
5436 elf_text_symbol->section = elf_text_section;
5438 /* This code used to do *secp = bfd_und_section_ptr if
5439 info->shared. I don't know why, and that doesn't make sense,
5440 so I took it out. */
5441 *secp = elf_tdata (abfd)->elf_text_section;
5444 case SHN_MIPS_ACOMMON:
5445 /* Fall through. XXX Can we treat this as allocated data? */
5447 /* This section is used in a shared object. */
5448 if (elf_tdata (abfd)->elf_data_section == NULL)
5450 asymbol *elf_data_symbol;
5451 asection *elf_data_section;
5452 bfd_size_type amt = sizeof (asection);
5454 elf_data_section = bfd_zalloc (abfd, amt);
5455 if (elf_data_section == NULL)
5458 amt = sizeof (asymbol);
5459 elf_data_symbol = bfd_zalloc (abfd, amt);
5460 if (elf_data_symbol == NULL)
5463 /* Initialize the section. */
5465 elf_tdata (abfd)->elf_data_section = elf_data_section;
5466 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
5468 elf_data_section->symbol = elf_data_symbol;
5469 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
5471 elf_data_section->name = ".data";
5472 elf_data_section->flags = SEC_NO_FLAGS;
5473 elf_data_section->output_section = NULL;
5474 elf_data_section->owner = abfd;
5475 elf_data_symbol->name = ".data";
5476 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
5477 elf_data_symbol->section = elf_data_section;
5479 /* This code used to do *secp = bfd_und_section_ptr if
5480 info->shared. I don't know why, and that doesn't make sense,
5481 so I took it out. */
5482 *secp = elf_tdata (abfd)->elf_data_section;
5485 case SHN_MIPS_SUNDEFINED:
5486 *secp = bfd_und_section_ptr;
5490 if (SGI_COMPAT (abfd)
5492 && info->hash->creator == abfd->xvec
5493 && strcmp (*namep, "__rld_obj_head") == 0)
5495 struct elf_link_hash_entry *h;
5496 struct bfd_link_hash_entry *bh;
5498 /* Mark __rld_obj_head as dynamic. */
5500 if (! (_bfd_generic_link_add_one_symbol
5501 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
5502 get_elf_backend_data (abfd)->collect, &bh)))
5505 h = (struct elf_link_hash_entry *) bh;
5508 h->type = STT_OBJECT;
5510 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5513 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
5516 /* If this is a mips16 text symbol, add 1 to the value to make it
5517 odd. This will cause something like .word SYM to come up with
5518 the right value when it is loaded into the PC. */
5519 if (sym->st_other == STO_MIPS16)
5525 /* This hook function is called before the linker writes out a global
5526 symbol. We mark symbols as small common if appropriate. This is
5527 also where we undo the increment of the value for a mips16 symbol. */
5530 _bfd_mips_elf_link_output_symbol_hook
5531 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5532 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
5533 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5535 /* If we see a common symbol, which implies a relocatable link, then
5536 if a symbol was small common in an input file, mark it as small
5537 common in the output file. */
5538 if (sym->st_shndx == SHN_COMMON
5539 && strcmp (input_sec->name, ".scommon") == 0)
5540 sym->st_shndx = SHN_MIPS_SCOMMON;
5542 if (sym->st_other == STO_MIPS16)
5543 sym->st_value &= ~1;
5548 /* Functions for the dynamic linker. */
5550 /* Create dynamic sections when linking against a dynamic object. */
5553 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
5555 struct elf_link_hash_entry *h;
5556 struct bfd_link_hash_entry *bh;
5558 register asection *s;
5559 const char * const *namep;
5561 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5562 | SEC_LINKER_CREATED | SEC_READONLY);
5564 /* Mips ABI requests the .dynamic section to be read only. */
5565 s = bfd_get_section_by_name (abfd, ".dynamic");
5568 if (! bfd_set_section_flags (abfd, s, flags))
5572 /* We need to create .got section. */
5573 if (! mips_elf_create_got_section (abfd, info, FALSE))
5576 if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
5579 /* Create .stub section. */
5580 if (bfd_get_section_by_name (abfd,
5581 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
5583 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
5585 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
5586 || ! bfd_set_section_alignment (abfd, s,
5587 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
5591 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
5593 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
5595 s = bfd_make_section (abfd, ".rld_map");
5597 || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
5598 || ! bfd_set_section_alignment (abfd, s,
5599 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
5603 /* On IRIX5, we adjust add some additional symbols and change the
5604 alignments of several sections. There is no ABI documentation
5605 indicating that this is necessary on IRIX6, nor any evidence that
5606 the linker takes such action. */
5607 if (IRIX_COMPAT (abfd) == ict_irix5)
5609 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
5612 if (! (_bfd_generic_link_add_one_symbol
5613 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
5614 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5617 h = (struct elf_link_hash_entry *) bh;
5620 h->type = STT_SECTION;
5622 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5626 /* We need to create a .compact_rel section. */
5627 if (SGI_COMPAT (abfd))
5629 if (!mips_elf_create_compact_rel_section (abfd, info))
5633 /* Change alignments of some sections. */
5634 s = bfd_get_section_by_name (abfd, ".hash");
5636 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
5637 s = bfd_get_section_by_name (abfd, ".dynsym");
5639 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
5640 s = bfd_get_section_by_name (abfd, ".dynstr");
5642 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
5643 s = bfd_get_section_by_name (abfd, ".reginfo");
5645 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
5646 s = bfd_get_section_by_name (abfd, ".dynamic");
5648 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
5655 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5657 if (!(_bfd_generic_link_add_one_symbol
5658 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
5659 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5662 h = (struct elf_link_hash_entry *) bh;
5665 h->type = STT_SECTION;
5667 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5670 if (! mips_elf_hash_table (info)->use_rld_obj_head)
5672 /* __rld_map is a four byte word located in the .data section
5673 and is filled in by the rtld to contain a pointer to
5674 the _r_debug structure. Its symbol value will be set in
5675 _bfd_mips_elf_finish_dynamic_symbol. */
5676 s = bfd_get_section_by_name (abfd, ".rld_map");
5677 BFD_ASSERT (s != NULL);
5679 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5681 if (!(_bfd_generic_link_add_one_symbol
5682 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
5683 get_elf_backend_data (abfd)->collect, &bh)))
5686 h = (struct elf_link_hash_entry *) bh;
5689 h->type = STT_OBJECT;
5691 if (! bfd_elf_link_record_dynamic_symbol (info, h))
5699 /* Look through the relocs for a section during the first phase, and
5700 allocate space in the global offset table. */
5703 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5704 asection *sec, const Elf_Internal_Rela *relocs)
5708 Elf_Internal_Shdr *symtab_hdr;
5709 struct elf_link_hash_entry **sym_hashes;
5710 struct mips_got_info *g;
5712 const Elf_Internal_Rela *rel;
5713 const Elf_Internal_Rela *rel_end;
5716 const struct elf_backend_data *bed;
5718 if (info->relocatable)
5721 dynobj = elf_hash_table (info)->dynobj;
5722 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5723 sym_hashes = elf_sym_hashes (abfd);
5724 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5726 /* Check for the mips16 stub sections. */
5728 name = bfd_get_section_name (abfd, sec);
5729 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5731 unsigned long r_symndx;
5733 /* Look at the relocation information to figure out which symbol
5736 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5738 if (r_symndx < extsymoff
5739 || sym_hashes[r_symndx - extsymoff] == NULL)
5743 /* This stub is for a local symbol. This stub will only be
5744 needed if there is some relocation in this BFD, other
5745 than a 16 bit function call, which refers to this symbol. */
5746 for (o = abfd->sections; o != NULL; o = o->next)
5748 Elf_Internal_Rela *sec_relocs;
5749 const Elf_Internal_Rela *r, *rend;
5751 /* We can ignore stub sections when looking for relocs. */
5752 if ((o->flags & SEC_RELOC) == 0
5753 || o->reloc_count == 0
5754 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5755 sizeof FN_STUB - 1) == 0
5756 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5757 sizeof CALL_STUB - 1) == 0
5758 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5759 sizeof CALL_FP_STUB - 1) == 0)
5763 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5765 if (sec_relocs == NULL)
5768 rend = sec_relocs + o->reloc_count;
5769 for (r = sec_relocs; r < rend; r++)
5770 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5771 && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5774 if (elf_section_data (o)->relocs != sec_relocs)
5783 /* There is no non-call reloc for this stub, so we do
5784 not need it. Since this function is called before
5785 the linker maps input sections to output sections, we
5786 can easily discard it by setting the SEC_EXCLUDE
5788 sec->flags |= SEC_EXCLUDE;
5792 /* Record this stub in an array of local symbol stubs for
5794 if (elf_tdata (abfd)->local_stubs == NULL)
5796 unsigned long symcount;
5800 if (elf_bad_symtab (abfd))
5801 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5803 symcount = symtab_hdr->sh_info;
5804 amt = symcount * sizeof (asection *);
5805 n = bfd_zalloc (abfd, amt);
5808 elf_tdata (abfd)->local_stubs = n;
5811 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5813 /* We don't need to set mips16_stubs_seen in this case.
5814 That flag is used to see whether we need to look through
5815 the global symbol table for stubs. We don't need to set
5816 it here, because we just have a local stub. */
5820 struct mips_elf_link_hash_entry *h;
5822 h = ((struct mips_elf_link_hash_entry *)
5823 sym_hashes[r_symndx - extsymoff]);
5825 /* H is the symbol this stub is for. */
5828 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5831 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5832 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5834 unsigned long r_symndx;
5835 struct mips_elf_link_hash_entry *h;
5838 /* Look at the relocation information to figure out which symbol
5841 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5843 if (r_symndx < extsymoff
5844 || sym_hashes[r_symndx - extsymoff] == NULL)
5846 /* This stub was actually built for a static symbol defined
5847 in the same file. We assume that all static symbols in
5848 mips16 code are themselves mips16, so we can simply
5849 discard this stub. Since this function is called before
5850 the linker maps input sections to output sections, we can
5851 easily discard it by setting the SEC_EXCLUDE flag. */
5852 sec->flags |= SEC_EXCLUDE;
5856 h = ((struct mips_elf_link_hash_entry *)
5857 sym_hashes[r_symndx - extsymoff]);
5859 /* H is the symbol this stub is for. */
5861 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5862 loc = &h->call_fp_stub;
5864 loc = &h->call_stub;
5866 /* If we already have an appropriate stub for this function, we
5867 don't need another one, so we can discard this one. Since
5868 this function is called before the linker maps input sections
5869 to output sections, we can easily discard it by setting the
5870 SEC_EXCLUDE flag. We can also discard this section if we
5871 happen to already know that this is a mips16 function; it is
5872 not necessary to check this here, as it is checked later, but
5873 it is slightly faster to check now. */
5874 if (*loc != NULL || h->root.other == STO_MIPS16)
5876 sec->flags |= SEC_EXCLUDE;
5881 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5891 sgot = mips_elf_got_section (dynobj, FALSE);
5896 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5897 g = mips_elf_section_data (sgot)->u.got_info;
5898 BFD_ASSERT (g != NULL);
5903 bed = get_elf_backend_data (abfd);
5904 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5905 for (rel = relocs; rel < rel_end; ++rel)
5907 unsigned long r_symndx;
5908 unsigned int r_type;
5909 struct elf_link_hash_entry *h;
5911 r_symndx = ELF_R_SYM (abfd, rel->r_info);
5912 r_type = ELF_R_TYPE (abfd, rel->r_info);
5914 if (r_symndx < extsymoff)
5916 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5918 (*_bfd_error_handler)
5919 (_("%B: Malformed reloc detected for section %s"),
5921 bfd_set_error (bfd_error_bad_value);
5926 h = sym_hashes[r_symndx - extsymoff];
5928 /* This may be an indirect symbol created because of a version. */
5931 while (h->root.type == bfd_link_hash_indirect)
5932 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5936 /* Some relocs require a global offset table. */
5937 if (dynobj == NULL || sgot == NULL)
5943 case R_MIPS_CALL_HI16:
5944 case R_MIPS_CALL_LO16:
5945 case R_MIPS_GOT_HI16:
5946 case R_MIPS_GOT_LO16:
5947 case R_MIPS_GOT_PAGE:
5948 case R_MIPS_GOT_OFST:
5949 case R_MIPS_GOT_DISP:
5951 case R_MIPS_TLS_LDM:
5953 elf_hash_table (info)->dynobj = dynobj = abfd;
5954 if (! mips_elf_create_got_section (dynobj, info, FALSE))
5956 g = mips_elf_got_info (dynobj, &sgot);
5963 && (info->shared || h != NULL)
5964 && (sec->flags & SEC_ALLOC) != 0)
5965 elf_hash_table (info)->dynobj = dynobj = abfd;
5973 if (!h && (r_type == R_MIPS_CALL_LO16
5974 || r_type == R_MIPS_GOT_LO16
5975 || r_type == R_MIPS_GOT_DISP))
5977 /* We may need a local GOT entry for this relocation. We
5978 don't count R_MIPS_GOT_PAGE because we can estimate the
5979 maximum number of pages needed by looking at the size of
5980 the segment. Similar comments apply to R_MIPS_GOT16 and
5981 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5982 R_MIPS_CALL_HI16 because these are always followed by an
5983 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5984 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5985 rel->r_addend, g, 0))
5994 (*_bfd_error_handler)
5995 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
5996 abfd, (unsigned long) rel->r_offset);
5997 bfd_set_error (bfd_error_bad_value);
6002 case R_MIPS_CALL_HI16:
6003 case R_MIPS_CALL_LO16:
6006 /* This symbol requires a global offset table entry. */
6007 if (! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6010 /* We need a stub, not a plt entry for the undefined
6011 function. But we record it as if it needs plt. See
6012 _bfd_elf_adjust_dynamic_symbol. */
6018 case R_MIPS_GOT_PAGE:
6019 /* If this is a global, overridable symbol, GOT_PAGE will
6020 decay to GOT_DISP, so we'll need a GOT entry for it. */
6025 struct mips_elf_link_hash_entry *hmips =
6026 (struct mips_elf_link_hash_entry *) h;
6028 while (hmips->root.root.type == bfd_link_hash_indirect
6029 || hmips->root.root.type == bfd_link_hash_warning)
6030 hmips = (struct mips_elf_link_hash_entry *)
6031 hmips->root.root.u.i.link;
6033 if (hmips->root.def_regular
6034 && ! (info->shared && ! info->symbolic
6035 && ! hmips->root.forced_local))
6041 case R_MIPS_GOT_HI16:
6042 case R_MIPS_GOT_LO16:
6043 case R_MIPS_GOT_DISP:
6044 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6048 case R_MIPS_TLS_GOTTPREL:
6050 info->flags |= DF_STATIC_TLS;
6053 case R_MIPS_TLS_LDM:
6054 if (r_type == R_MIPS_TLS_LDM)
6062 /* This symbol requires a global offset table entry, or two
6063 for TLS GD relocations. */
6065 unsigned char flag = (r_type == R_MIPS_TLS_GD
6067 : r_type == R_MIPS_TLS_LDM
6072 struct mips_elf_link_hash_entry *hmips =
6073 (struct mips_elf_link_hash_entry *) h;
6074 hmips->tls_type |= flag;
6076 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, flag))
6081 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != 0);
6083 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
6084 rel->r_addend, g, flag))
6093 if ((info->shared || h != NULL)
6094 && (sec->flags & SEC_ALLOC) != 0)
6098 sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
6102 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
6105 /* When creating a shared object, we must copy these
6106 reloc types into the output file as R_MIPS_REL32
6107 relocs. We make room for this reloc in the
6108 .rel.dyn reloc section. */
6109 mips_elf_allocate_dynamic_relocations (dynobj, 1);
6110 if ((sec->flags & MIPS_READONLY_SECTION)
6111 == MIPS_READONLY_SECTION)
6112 /* We tell the dynamic linker that there are
6113 relocations against the text segment. */
6114 info->flags |= DF_TEXTREL;
6118 struct mips_elf_link_hash_entry *hmips;
6120 /* We only need to copy this reloc if the symbol is
6121 defined in a dynamic object. */
6122 hmips = (struct mips_elf_link_hash_entry *) h;
6123 ++hmips->possibly_dynamic_relocs;
6124 if ((sec->flags & MIPS_READONLY_SECTION)
6125 == MIPS_READONLY_SECTION)
6126 /* We need it to tell the dynamic linker if there
6127 are relocations against the text segment. */
6128 hmips->readonly_reloc = TRUE;
6131 /* Even though we don't directly need a GOT entry for
6132 this symbol, a symbol must have a dynamic symbol
6133 table index greater that DT_MIPS_GOTSYM if there are
6134 dynamic relocations against it. */
6138 elf_hash_table (info)->dynobj = dynobj = abfd;
6139 if (! mips_elf_create_got_section (dynobj, info, TRUE))
6141 g = mips_elf_got_info (dynobj, &sgot);
6142 if (! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6147 if (SGI_COMPAT (abfd))
6148 mips_elf_hash_table (info)->compact_rel_size +=
6149 sizeof (Elf32_External_crinfo);
6153 case R_MIPS_GPREL16:
6154 case R_MIPS_LITERAL:
6155 case R_MIPS_GPREL32:
6156 if (SGI_COMPAT (abfd))
6157 mips_elf_hash_table (info)->compact_rel_size +=
6158 sizeof (Elf32_External_crinfo);
6161 /* This relocation describes the C++ object vtable hierarchy.
6162 Reconstruct it for later use during GC. */
6163 case R_MIPS_GNU_VTINHERIT:
6164 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6168 /* This relocation describes which C++ vtable entries are actually
6169 used. Record for later use during GC. */
6170 case R_MIPS_GNU_VTENTRY:
6171 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6179 /* We must not create a stub for a symbol that has relocations
6180 related to taking the function's address. */
6186 struct mips_elf_link_hash_entry *mh;
6188 mh = (struct mips_elf_link_hash_entry *) h;
6189 mh->no_fn_stub = TRUE;
6193 case R_MIPS_CALL_HI16:
6194 case R_MIPS_CALL_LO16:
6199 /* If this reloc is not a 16 bit call, and it has a global
6200 symbol, then we will need the fn_stub if there is one.
6201 References from a stub section do not count. */
6203 && r_type != R_MIPS16_26
6204 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
6205 sizeof FN_STUB - 1) != 0
6206 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
6207 sizeof CALL_STUB - 1) != 0
6208 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
6209 sizeof CALL_FP_STUB - 1) != 0)
6211 struct mips_elf_link_hash_entry *mh;
6213 mh = (struct mips_elf_link_hash_entry *) h;
6214 mh->need_fn_stub = TRUE;
6222 _bfd_mips_relax_section (bfd *abfd, asection *sec,
6223 struct bfd_link_info *link_info,
6226 Elf_Internal_Rela *internal_relocs;
6227 Elf_Internal_Rela *irel, *irelend;
6228 Elf_Internal_Shdr *symtab_hdr;
6229 bfd_byte *contents = NULL;
6231 bfd_boolean changed_contents = FALSE;
6232 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
6233 Elf_Internal_Sym *isymbuf = NULL;
6235 /* We are not currently changing any sizes, so only one pass. */
6238 if (link_info->relocatable)
6241 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
6242 link_info->keep_memory);
6243 if (internal_relocs == NULL)
6246 irelend = internal_relocs + sec->reloc_count
6247 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
6248 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6249 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
6251 for (irel = internal_relocs; irel < irelend; irel++)
6254 bfd_signed_vma sym_offset;
6255 unsigned int r_type;
6256 unsigned long r_symndx;
6258 unsigned long instruction;
6260 /* Turn jalr into bgezal, and jr into beq, if they're marked
6261 with a JALR relocation, that indicate where they jump to.
6262 This saves some pipeline bubbles. */
6263 r_type = ELF_R_TYPE (abfd, irel->r_info);
6264 if (r_type != R_MIPS_JALR)
6267 r_symndx = ELF_R_SYM (abfd, irel->r_info);
6268 /* Compute the address of the jump target. */
6269 if (r_symndx >= extsymoff)
6271 struct mips_elf_link_hash_entry *h
6272 = ((struct mips_elf_link_hash_entry *)
6273 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
6275 while (h->root.root.type == bfd_link_hash_indirect
6276 || h->root.root.type == bfd_link_hash_warning)
6277 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
6279 /* If a symbol is undefined, or if it may be overridden,
6281 if (! ((h->root.root.type == bfd_link_hash_defined
6282 || h->root.root.type == bfd_link_hash_defweak)
6283 && h->root.root.u.def.section)
6284 || (link_info->shared && ! link_info->symbolic
6285 && !h->root.forced_local))
6288 sym_sec = h->root.root.u.def.section;
6289 if (sym_sec->output_section)
6290 symval = (h->root.root.u.def.value
6291 + sym_sec->output_section->vma
6292 + sym_sec->output_offset);
6294 symval = h->root.root.u.def.value;
6298 Elf_Internal_Sym *isym;
6300 /* Read this BFD's symbols if we haven't done so already. */
6301 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
6303 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6304 if (isymbuf == NULL)
6305 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
6306 symtab_hdr->sh_info, 0,
6308 if (isymbuf == NULL)
6312 isym = isymbuf + r_symndx;
6313 if (isym->st_shndx == SHN_UNDEF)
6315 else if (isym->st_shndx == SHN_ABS)
6316 sym_sec = bfd_abs_section_ptr;
6317 else if (isym->st_shndx == SHN_COMMON)
6318 sym_sec = bfd_com_section_ptr;
6321 = bfd_section_from_elf_index (abfd, isym->st_shndx);
6322 symval = isym->st_value
6323 + sym_sec->output_section->vma
6324 + sym_sec->output_offset;
6327 /* Compute branch offset, from delay slot of the jump to the
6329 sym_offset = (symval + irel->r_addend)
6330 - (sec_start + irel->r_offset + 4);
6332 /* Branch offset must be properly aligned. */
6333 if ((sym_offset & 3) != 0)
6338 /* Check that it's in range. */
6339 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
6342 /* Get the section contents if we haven't done so already. */
6343 if (contents == NULL)
6345 /* Get cached copy if it exists. */
6346 if (elf_section_data (sec)->this_hdr.contents != NULL)
6347 contents = elf_section_data (sec)->this_hdr.contents;
6350 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6355 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
6357 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
6358 if ((instruction & 0xfc1fffff) == 0x0000f809)
6359 instruction = 0x04110000;
6360 /* If it was jr <reg>, turn it into b <target>. */
6361 else if ((instruction & 0xfc1fffff) == 0x00000008)
6362 instruction = 0x10000000;
6366 instruction |= (sym_offset & 0xffff);
6367 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
6368 changed_contents = TRUE;
6371 if (contents != NULL
6372 && elf_section_data (sec)->this_hdr.contents != contents)
6374 if (!changed_contents && !link_info->keep_memory)
6378 /* Cache the section contents for elf_link_input_bfd. */
6379 elf_section_data (sec)->this_hdr.contents = contents;
6385 if (contents != NULL
6386 && elf_section_data (sec)->this_hdr.contents != contents)
6391 /* Adjust a symbol defined by a dynamic object and referenced by a
6392 regular object. The current definition is in some section of the
6393 dynamic object, but we're not including those sections. We have to
6394 change the definition to something the rest of the link can
6398 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6399 struct elf_link_hash_entry *h)
6402 struct mips_elf_link_hash_entry *hmips;
6405 dynobj = elf_hash_table (info)->dynobj;
6407 /* Make sure we know what is going on here. */
6408 BFD_ASSERT (dynobj != NULL
6410 || h->u.weakdef != NULL
6413 && !h->def_regular)));
6415 /* If this symbol is defined in a dynamic object, we need to copy
6416 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6418 hmips = (struct mips_elf_link_hash_entry *) h;
6419 if (! info->relocatable
6420 && hmips->possibly_dynamic_relocs != 0
6421 && (h->root.type == bfd_link_hash_defweak
6422 || !h->def_regular))
6424 mips_elf_allocate_dynamic_relocations (dynobj,
6425 hmips->possibly_dynamic_relocs);
6426 if (hmips->readonly_reloc)
6427 /* We tell the dynamic linker that there are relocations
6428 against the text segment. */
6429 info->flags |= DF_TEXTREL;
6432 /* For a function, create a stub, if allowed. */
6433 if (! hmips->no_fn_stub
6436 if (! elf_hash_table (info)->dynamic_sections_created)
6439 /* If this symbol is not defined in a regular file, then set
6440 the symbol to the stub location. This is required to make
6441 function pointers compare as equal between the normal
6442 executable and the shared library. */
6443 if (!h->def_regular)
6445 /* We need .stub section. */
6446 s = bfd_get_section_by_name (dynobj,
6447 MIPS_ELF_STUB_SECTION_NAME (dynobj));
6448 BFD_ASSERT (s != NULL);
6450 h->root.u.def.section = s;
6451 h->root.u.def.value = s->size;
6453 /* XXX Write this stub address somewhere. */
6454 h->plt.offset = s->size;
6456 /* Make room for this stub code. */
6457 s->size += MIPS_FUNCTION_STUB_SIZE;
6459 /* The last half word of the stub will be filled with the index
6460 of this symbol in .dynsym section. */
6464 else if ((h->type == STT_FUNC)
6467 /* This will set the entry for this symbol in the GOT to 0, and
6468 the dynamic linker will take care of this. */
6469 h->root.u.def.value = 0;
6473 /* If this is a weak symbol, and there is a real definition, the
6474 processor independent code will have arranged for us to see the
6475 real definition first, and we can just use the same value. */
6476 if (h->u.weakdef != NULL)
6478 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6479 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6480 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6481 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6485 /* This is a reference to a symbol defined by a dynamic object which
6486 is not a function. */
6491 /* This function is called after all the input files have been read,
6492 and the input sections have been assigned to output sections. We
6493 check for any mips16 stub sections that we can discard. */
6496 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
6497 struct bfd_link_info *info)
6503 struct mips_got_info *g;
6505 bfd_size_type loadable_size = 0;
6506 bfd_size_type local_gotno;
6508 struct mips_elf_count_tls_arg count_tls_arg;
6510 /* The .reginfo section has a fixed size. */
6511 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
6513 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
6515 if (! (info->relocatable
6516 || ! mips_elf_hash_table (info)->mips16_stubs_seen))
6517 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
6518 mips_elf_check_mips16_stubs, NULL);
6520 dynobj = elf_hash_table (info)->dynobj;
6522 /* Relocatable links don't have it. */
6525 g = mips_elf_got_info (dynobj, &s);
6529 /* Calculate the total loadable size of the output. That
6530 will give us the maximum number of GOT_PAGE entries
6532 for (sub = info->input_bfds; sub; sub = sub->link_next)
6534 asection *subsection;
6536 for (subsection = sub->sections;
6538 subsection = subsection->next)
6540 if ((subsection->flags & SEC_ALLOC) == 0)
6542 loadable_size += ((subsection->size + 0xf)
6543 &~ (bfd_size_type) 0xf);
6547 /* There has to be a global GOT entry for every symbol with
6548 a dynamic symbol table index of DT_MIPS_GOTSYM or
6549 higher. Therefore, it make sense to put those symbols
6550 that need GOT entries at the end of the symbol table. We
6552 if (! mips_elf_sort_hash_table (info, 1))
6555 if (g->global_gotsym != NULL)
6556 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
6558 /* If there are no global symbols, or none requiring
6559 relocations, then GLOBAL_GOTSYM will be NULL. */
6562 /* In the worst case, we'll get one stub per dynamic symbol, plus
6563 one to account for the dummy entry at the end required by IRIX
6565 loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
6567 /* Assume there are two loadable segments consisting of
6568 contiguous sections. Is 5 enough? */
6569 local_gotno = (loadable_size >> 16) + 5;
6571 g->local_gotno += local_gotno;
6572 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
6574 g->global_gotno = i;
6575 s->size += i * MIPS_ELF_GOT_SIZE (output_bfd);
6577 /* We need to calculate tls_gotno for global symbols at this point
6578 instead of building it up earlier, to avoid doublecounting
6579 entries for one global symbol from multiple input files. */
6580 count_tls_arg.info = info;
6581 count_tls_arg.needed = 0;
6582 elf_link_hash_traverse (elf_hash_table (info),
6583 mips_elf_count_global_tls_entries,
6585 g->tls_gotno += count_tls_arg.needed;
6586 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
6588 mips_elf_resolve_final_got_entries (g);
6590 if (s->size > MIPS_ELF_GOT_MAX_SIZE (output_bfd))
6592 if (! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
6597 /* Set up TLS entries for the first GOT. */
6598 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
6599 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
6605 /* Set the sizes of the dynamic sections. */
6608 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
6609 struct bfd_link_info *info)
6613 bfd_boolean reltext;
6615 dynobj = elf_hash_table (info)->dynobj;
6616 BFD_ASSERT (dynobj != NULL);
6618 if (elf_hash_table (info)->dynamic_sections_created)
6620 /* Set the contents of the .interp section to the interpreter. */
6621 if (info->executable)
6623 s = bfd_get_section_by_name (dynobj, ".interp");
6624 BFD_ASSERT (s != NULL);
6626 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
6628 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
6632 /* The check_relocs and adjust_dynamic_symbol entry points have
6633 determined the sizes of the various dynamic sections. Allocate
6636 for (s = dynobj->sections; s != NULL; s = s->next)
6641 /* It's OK to base decisions on the section name, because none
6642 of the dynobj section names depend upon the input files. */
6643 name = bfd_get_section_name (dynobj, s);
6645 if ((s->flags & SEC_LINKER_CREATED) == 0)
6650 if (strncmp (name, ".rel", 4) == 0)
6654 /* We only strip the section if the output section name
6655 has the same name. Otherwise, there might be several
6656 input sections for this output section. FIXME: This
6657 code is probably not needed these days anyhow, since
6658 the linker now does not create empty output sections. */
6659 if (s->output_section != NULL
6661 bfd_get_section_name (s->output_section->owner,
6662 s->output_section)) == 0)
6667 const char *outname;
6670 /* If this relocation section applies to a read only
6671 section, then we probably need a DT_TEXTREL entry.
6672 If the relocation section is .rel.dyn, we always
6673 assert a DT_TEXTREL entry rather than testing whether
6674 there exists a relocation to a read only section or
6676 outname = bfd_get_section_name (output_bfd,
6678 target = bfd_get_section_by_name (output_bfd, outname + 4);
6680 && (target->flags & SEC_READONLY) != 0
6681 && (target->flags & SEC_ALLOC) != 0)
6682 || strcmp (outname, ".rel.dyn") == 0)
6685 /* We use the reloc_count field as a counter if we need
6686 to copy relocs into the output file. */
6687 if (strcmp (name, ".rel.dyn") != 0)
6690 /* If combreloc is enabled, elf_link_sort_relocs() will
6691 sort relocations, but in a different way than we do,
6692 and before we're done creating relocations. Also, it
6693 will move them around between input sections'
6694 relocation's contents, so our sorting would be
6695 broken, so don't let it run. */
6696 info->combreloc = 0;
6699 else if (strncmp (name, ".got", 4) == 0)
6701 /* _bfd_mips_elf_always_size_sections() has already done
6702 most of the work, but some symbols may have been mapped
6703 to versions that we must now resolve in the got_entries
6705 struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
6706 struct mips_got_info *g = gg;
6707 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
6708 unsigned int needed_relocs = 0;
6712 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6713 set_got_offset_arg.info = info;
6715 /* NOTE 2005-02-03: How can this call, or the next, ever
6716 find any indirect entries to resolve? They were all
6717 resolved in mips_elf_multi_got. */
6718 mips_elf_resolve_final_got_entries (gg);
6719 for (g = gg->next; g && g->next != gg; g = g->next)
6721 unsigned int save_assign;
6723 mips_elf_resolve_final_got_entries (g);
6725 /* Assign offsets to global GOT entries. */
6726 save_assign = g->assigned_gotno;
6727 g->assigned_gotno = g->local_gotno;
6728 set_got_offset_arg.g = g;
6729 set_got_offset_arg.needed_relocs = 0;
6730 htab_traverse (g->got_entries,
6731 mips_elf_set_global_got_offset,
6732 &set_got_offset_arg);
6733 needed_relocs += set_got_offset_arg.needed_relocs;
6734 BFD_ASSERT (g->assigned_gotno - g->local_gotno
6735 <= g->global_gotno);
6737 g->assigned_gotno = save_assign;
6740 needed_relocs += g->local_gotno - g->assigned_gotno;
6741 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6742 + g->next->global_gotno
6743 + g->next->tls_gotno
6744 + MIPS_RESERVED_GOTNO);
6750 struct mips_elf_count_tls_arg arg;
6754 htab_traverse (gg->got_entries, mips_elf_count_local_tls_relocs,
6756 elf_link_hash_traverse (elf_hash_table (info),
6757 mips_elf_count_global_tls_relocs,
6760 needed_relocs += arg.needed;
6764 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6766 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6768 /* IRIX rld assumes that the function stub isn't at the end
6769 of .text section. So put a dummy. XXX */
6770 s->size += MIPS_FUNCTION_STUB_SIZE;
6772 else if (! info->shared
6773 && ! mips_elf_hash_table (info)->use_rld_obj_head
6774 && strncmp (name, ".rld_map", 8) == 0)
6776 /* We add a room for __rld_map. It will be filled in by the
6777 rtld to contain a pointer to the _r_debug structure. */
6780 else if (SGI_COMPAT (output_bfd)
6781 && strncmp (name, ".compact_rel", 12) == 0)
6782 s->size += mips_elf_hash_table (info)->compact_rel_size;
6783 else if (strncmp (name, ".init", 5) != 0)
6785 /* It's not one of our sections, so don't allocate space. */
6791 _bfd_strip_section_from_output (info, s);
6795 /* Allocate memory for the section contents. */
6796 s->contents = bfd_zalloc (dynobj, s->size);
6797 if (s->contents == NULL && s->size != 0)
6799 bfd_set_error (bfd_error_no_memory);
6804 if (elf_hash_table (info)->dynamic_sections_created)
6806 /* Add some entries to the .dynamic section. We fill in the
6807 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6808 must add the entries now so that we get the correct size for
6809 the .dynamic section. The DT_DEBUG entry is filled in by the
6810 dynamic linker and used by the debugger. */
6813 /* SGI object has the equivalence of DT_DEBUG in the
6814 DT_MIPS_RLD_MAP entry. */
6815 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6817 if (!SGI_COMPAT (output_bfd))
6819 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6825 /* Shared libraries on traditional mips have DT_DEBUG. */
6826 if (!SGI_COMPAT (output_bfd))
6828 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6833 if (reltext && SGI_COMPAT (output_bfd))
6834 info->flags |= DF_TEXTREL;
6836 if ((info->flags & DF_TEXTREL) != 0)
6838 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6842 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6845 if (mips_elf_rel_dyn_section (dynobj, FALSE))
6847 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6850 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6853 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6857 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6860 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6863 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6866 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6869 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6872 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6875 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6878 if (IRIX_COMPAT (dynobj) == ict_irix5
6879 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6882 if (IRIX_COMPAT (dynobj) == ict_irix6
6883 && (bfd_get_section_by_name
6884 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6885 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6892 /* Relocate a MIPS ELF section. */
6895 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
6896 bfd *input_bfd, asection *input_section,
6897 bfd_byte *contents, Elf_Internal_Rela *relocs,
6898 Elf_Internal_Sym *local_syms,
6899 asection **local_sections)
6901 Elf_Internal_Rela *rel;
6902 const Elf_Internal_Rela *relend;
6904 bfd_boolean use_saved_addend_p = FALSE;
6905 const struct elf_backend_data *bed;
6907 bed = get_elf_backend_data (output_bfd);
6908 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6909 for (rel = relocs; rel < relend; ++rel)
6913 reloc_howto_type *howto;
6914 bfd_boolean require_jalx;
6915 /* TRUE if the relocation is a RELA relocation, rather than a
6917 bfd_boolean rela_relocation_p = TRUE;
6918 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6921 /* Find the relocation howto for this relocation. */
6922 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6924 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6925 64-bit code, but make sure all their addresses are in the
6926 lowermost or uppermost 32-bit section of the 64-bit address
6927 space. Thus, when they use an R_MIPS_64 they mean what is
6928 usually meant by R_MIPS_32, with the exception that the
6929 stored value is sign-extended to 64 bits. */
6930 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6932 /* On big-endian systems, we need to lie about the position
6934 if (bfd_big_endian (input_bfd))
6938 /* NewABI defaults to RELA relocations. */
6939 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6940 NEWABI_P (input_bfd)
6941 && (MIPS_RELOC_RELA_P
6942 (input_bfd, input_section,
6945 if (!use_saved_addend_p)
6947 Elf_Internal_Shdr *rel_hdr;
6949 /* If these relocations were originally of the REL variety,
6950 we must pull the addend out of the field that will be
6951 relocated. Otherwise, we simply use the contents of the
6952 RELA relocation. To determine which flavor or relocation
6953 this is, we depend on the fact that the INPUT_SECTION's
6954 REL_HDR is read before its REL_HDR2. */
6955 rel_hdr = &elf_section_data (input_section)->rel_hdr;
6956 if ((size_t) (rel - relocs)
6957 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6958 rel_hdr = elf_section_data (input_section)->rel_hdr2;
6959 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6961 bfd_byte *location = contents + rel->r_offset;
6963 /* Note that this is a REL relocation. */
6964 rela_relocation_p = FALSE;
6966 /* Get the addend, which is stored in the input file. */
6967 _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE,
6969 addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6971 _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, FALSE,
6974 addend &= howto->src_mask;
6976 /* For some kinds of relocations, the ADDEND is a
6977 combination of the addend stored in two different
6979 if (r_type == R_MIPS_HI16 || r_type == R_MIPS16_HI16
6980 || (r_type == R_MIPS_GOT16
6981 && mips_elf_local_relocation_p (input_bfd, rel,
6982 local_sections, FALSE)))
6985 const Elf_Internal_Rela *lo16_relocation;
6986 reloc_howto_type *lo16_howto;
6987 bfd_byte *lo16_location;
6990 if (r_type == R_MIPS16_HI16)
6991 lo16_type = R_MIPS16_LO16;
6993 lo16_type = R_MIPS_LO16;
6995 /* The combined value is the sum of the HI16 addend,
6996 left-shifted by sixteen bits, and the LO16
6997 addend, sign extended. (Usually, the code does
6998 a `lui' of the HI16 value, and then an `addiu' of
7001 Scan ahead to find a matching LO16 relocation.
7003 According to the MIPS ELF ABI, the R_MIPS_LO16
7004 relocation must be immediately following.
7005 However, for the IRIX6 ABI, the next relocation
7006 may be a composed relocation consisting of
7007 several relocations for the same address. In
7008 that case, the R_MIPS_LO16 relocation may occur
7009 as one of these. We permit a similar extension
7010 in general, as that is useful for GCC. */
7011 lo16_relocation = mips_elf_next_relocation (input_bfd,
7014 if (lo16_relocation == NULL)
7017 lo16_location = contents + lo16_relocation->r_offset;
7019 /* Obtain the addend kept there. */
7020 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd,
7022 _bfd_mips16_elf_reloc_unshuffle (input_bfd, lo16_type, FALSE,
7024 l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
7025 input_bfd, contents);
7026 _bfd_mips16_elf_reloc_shuffle (input_bfd, lo16_type, FALSE,
7028 l &= lo16_howto->src_mask;
7029 l <<= lo16_howto->rightshift;
7030 l = _bfd_mips_elf_sign_extend (l, 16);
7034 /* Compute the combined addend. */
7038 addend <<= howto->rightshift;
7041 addend = rel->r_addend;
7044 if (info->relocatable)
7046 Elf_Internal_Sym *sym;
7047 unsigned long r_symndx;
7049 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
7050 && bfd_big_endian (input_bfd))
7053 /* Since we're just relocating, all we need to do is copy
7054 the relocations back out to the object file, unless
7055 they're against a section symbol, in which case we need
7056 to adjust by the section offset, or unless they're GP
7057 relative in which case we need to adjust by the amount
7058 that we're adjusting GP in this relocatable object. */
7060 if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
7062 /* There's nothing to do for non-local relocations. */
7065 if (r_type == R_MIPS16_GPREL
7066 || r_type == R_MIPS_GPREL16
7067 || r_type == R_MIPS_GPREL32
7068 || r_type == R_MIPS_LITERAL)
7069 addend -= (_bfd_get_gp_value (output_bfd)
7070 - _bfd_get_gp_value (input_bfd));
7072 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
7073 sym = local_syms + r_symndx;
7074 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7075 /* Adjust the addend appropriately. */
7076 addend += local_sections[r_symndx]->output_offset;
7078 if (rela_relocation_p)
7079 /* If this is a RELA relocation, just update the addend. */
7080 rel->r_addend = addend;
7083 if (r_type == R_MIPS_HI16
7084 || r_type == R_MIPS_GOT16)
7085 addend = mips_elf_high (addend);
7086 else if (r_type == R_MIPS_HIGHER)
7087 addend = mips_elf_higher (addend);
7088 else if (r_type == R_MIPS_HIGHEST)
7089 addend = mips_elf_highest (addend);
7091 addend >>= howto->rightshift;
7093 /* We use the source mask, rather than the destination
7094 mask because the place to which we are writing will be
7095 source of the addend in the final link. */
7096 addend &= howto->src_mask;
7098 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
7099 /* See the comment above about using R_MIPS_64 in the 32-bit
7100 ABI. Here, we need to update the addend. It would be
7101 possible to get away with just using the R_MIPS_32 reloc
7102 but for endianness. */
7108 if (addend & ((bfd_vma) 1 << 31))
7110 sign_bits = ((bfd_vma) 1 << 32) - 1;
7117 /* If we don't know that we have a 64-bit type,
7118 do two separate stores. */
7119 if (bfd_big_endian (input_bfd))
7121 /* Store the sign-bits (which are most significant)
7123 low_bits = sign_bits;
7129 high_bits = sign_bits;
7131 bfd_put_32 (input_bfd, low_bits,
7132 contents + rel->r_offset);
7133 bfd_put_32 (input_bfd, high_bits,
7134 contents + rel->r_offset + 4);
7138 if (! mips_elf_perform_relocation (info, howto, rel, addend,
7139 input_bfd, input_section,
7144 /* Go on to the next relocation. */
7148 /* In the N32 and 64-bit ABIs there may be multiple consecutive
7149 relocations for the same offset. In that case we are
7150 supposed to treat the output of each relocation as the addend
7152 if (rel + 1 < relend
7153 && rel->r_offset == rel[1].r_offset
7154 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
7155 use_saved_addend_p = TRUE;
7157 use_saved_addend_p = FALSE;
7159 /* Figure out what value we are supposed to relocate. */
7160 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
7161 input_section, info, rel,
7162 addend, howto, local_syms,
7163 local_sections, &value,
7164 &name, &require_jalx,
7165 use_saved_addend_p))
7167 case bfd_reloc_continue:
7168 /* There's nothing to do. */
7171 case bfd_reloc_undefined:
7172 /* mips_elf_calculate_relocation already called the
7173 undefined_symbol callback. There's no real point in
7174 trying to perform the relocation at this point, so we
7175 just skip ahead to the next relocation. */
7178 case bfd_reloc_notsupported:
7179 msg = _("internal error: unsupported relocation error");
7180 info->callbacks->warning
7181 (info, msg, name, input_bfd, input_section, rel->r_offset);
7184 case bfd_reloc_overflow:
7185 if (use_saved_addend_p)
7186 /* Ignore overflow until we reach the last relocation for
7187 a given location. */
7191 BFD_ASSERT (name != NULL);
7192 if (! ((*info->callbacks->reloc_overflow)
7193 (info, NULL, name, howto->name, (bfd_vma) 0,
7194 input_bfd, input_section, rel->r_offset)))
7207 /* If we've got another relocation for the address, keep going
7208 until we reach the last one. */
7209 if (use_saved_addend_p)
7215 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
7216 /* See the comment above about using R_MIPS_64 in the 32-bit
7217 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7218 that calculated the right value. Now, however, we
7219 sign-extend the 32-bit result to 64-bits, and store it as a
7220 64-bit value. We are especially generous here in that we
7221 go to extreme lengths to support this usage on systems with
7222 only a 32-bit VMA. */
7228 if (value & ((bfd_vma) 1 << 31))
7230 sign_bits = ((bfd_vma) 1 << 32) - 1;
7237 /* If we don't know that we have a 64-bit type,
7238 do two separate stores. */
7239 if (bfd_big_endian (input_bfd))
7241 /* Undo what we did above. */
7243 /* Store the sign-bits (which are most significant)
7245 low_bits = sign_bits;
7251 high_bits = sign_bits;
7253 bfd_put_32 (input_bfd, low_bits,
7254 contents + rel->r_offset);
7255 bfd_put_32 (input_bfd, high_bits,
7256 contents + rel->r_offset + 4);
7260 /* Actually perform the relocation. */
7261 if (! mips_elf_perform_relocation (info, howto, rel, value,
7262 input_bfd, input_section,
7263 contents, require_jalx))
7270 /* If NAME is one of the special IRIX6 symbols defined by the linker,
7271 adjust it appropriately now. */
7274 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
7275 const char *name, Elf_Internal_Sym *sym)
7277 /* The linker script takes care of providing names and values for
7278 these, but we must place them into the right sections. */
7279 static const char* const text_section_symbols[] = {
7282 "__dso_displacement",
7284 "__program_header_table",
7288 static const char* const data_section_symbols[] = {
7296 const char* const *p;
7299 for (i = 0; i < 2; ++i)
7300 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
7303 if (strcmp (*p, name) == 0)
7305 /* All of these symbols are given type STT_SECTION by the
7307 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7308 sym->st_other = STO_PROTECTED;
7310 /* The IRIX linker puts these symbols in special sections. */
7312 sym->st_shndx = SHN_MIPS_TEXT;
7314 sym->st_shndx = SHN_MIPS_DATA;
7320 /* Finish up dynamic symbol handling. We set the contents of various
7321 dynamic sections here. */
7324 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
7325 struct bfd_link_info *info,
7326 struct elf_link_hash_entry *h,
7327 Elf_Internal_Sym *sym)
7331 struct mips_got_info *g, *gg;
7334 dynobj = elf_hash_table (info)->dynobj;
7336 if (h->plt.offset != MINUS_ONE)
7339 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
7341 /* This symbol has a stub. Set it up. */
7343 BFD_ASSERT (h->dynindx != -1);
7345 s = bfd_get_section_by_name (dynobj,
7346 MIPS_ELF_STUB_SECTION_NAME (dynobj));
7347 BFD_ASSERT (s != NULL);
7349 /* FIXME: Can h->dynindex be more than 64K? */
7350 if (h->dynindx & 0xffff0000)
7353 /* Fill the stub. */
7354 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
7355 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
7356 bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
7357 bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
7359 BFD_ASSERT (h->plt.offset <= s->size);
7360 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
7362 /* Mark the symbol as undefined. plt.offset != -1 occurs
7363 only for the referenced symbol. */
7364 sym->st_shndx = SHN_UNDEF;
7366 /* The run-time linker uses the st_value field of the symbol
7367 to reset the global offset table entry for this external
7368 to its stub address when unlinking a shared object. */
7369 sym->st_value = (s->output_section->vma + s->output_offset
7373 BFD_ASSERT (h->dynindx != -1
7374 || h->forced_local);
7376 sgot = mips_elf_got_section (dynobj, FALSE);
7377 BFD_ASSERT (sgot != NULL);
7378 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
7379 g = mips_elf_section_data (sgot)->u.got_info;
7380 BFD_ASSERT (g != NULL);
7382 /* Run through the global symbol table, creating GOT entries for all
7383 the symbols that need them. */
7384 if (g->global_gotsym != NULL
7385 && h->dynindx >= g->global_gotsym->dynindx)
7390 value = sym->st_value;
7391 offset = mips_elf_global_got_index (dynobj, output_bfd, h, R_MIPS_GOT16, info);
7392 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
7395 if (g->next && h->dynindx != -1 && h->type != STT_TLS)
7397 struct mips_got_entry e, *p;
7403 e.abfd = output_bfd;
7405 e.d.h = (struct mips_elf_link_hash_entry *)h;
7408 for (g = g->next; g->next != gg; g = g->next)
7411 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
7416 || (elf_hash_table (info)->dynamic_sections_created
7418 && p->d.h->root.def_dynamic
7419 && !p->d.h->root.def_regular))
7421 /* Create an R_MIPS_REL32 relocation for this entry. Due to
7422 the various compatibility problems, it's easier to mock
7423 up an R_MIPS_32 or R_MIPS_64 relocation and leave
7424 mips_elf_create_dynamic_relocation to calculate the
7425 appropriate addend. */
7426 Elf_Internal_Rela rel[3];
7428 memset (rel, 0, sizeof (rel));
7429 if (ABI_64_P (output_bfd))
7430 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
7432 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
7433 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
7436 if (! (mips_elf_create_dynamic_relocation
7437 (output_bfd, info, rel,
7438 e.d.h, NULL, sym->st_value, &entry, sgot)))
7442 entry = sym->st_value;
7443 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
7448 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7449 name = h->root.root.string;
7450 if (strcmp (name, "_DYNAMIC") == 0
7451 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
7452 sym->st_shndx = SHN_ABS;
7453 else if (strcmp (name, "_DYNAMIC_LINK") == 0
7454 || strcmp (name, "_DYNAMIC_LINKING") == 0)
7456 sym->st_shndx = SHN_ABS;
7457 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7460 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
7462 sym->st_shndx = SHN_ABS;
7463 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7464 sym->st_value = elf_gp (output_bfd);
7466 else if (SGI_COMPAT (output_bfd))
7468 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
7469 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
7471 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7472 sym->st_other = STO_PROTECTED;
7474 sym->st_shndx = SHN_MIPS_DATA;
7476 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
7478 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7479 sym->st_other = STO_PROTECTED;
7480 sym->st_value = mips_elf_hash_table (info)->procedure_count;
7481 sym->st_shndx = SHN_ABS;
7483 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
7485 if (h->type == STT_FUNC)
7486 sym->st_shndx = SHN_MIPS_TEXT;
7487 else if (h->type == STT_OBJECT)
7488 sym->st_shndx = SHN_MIPS_DATA;
7492 /* Handle the IRIX6-specific symbols. */
7493 if (IRIX_COMPAT (output_bfd) == ict_irix6)
7494 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
7498 if (! mips_elf_hash_table (info)->use_rld_obj_head
7499 && (strcmp (name, "__rld_map") == 0
7500 || strcmp (name, "__RLD_MAP") == 0))
7502 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
7503 BFD_ASSERT (s != NULL);
7504 sym->st_value = s->output_section->vma + s->output_offset;
7505 bfd_put_32 (output_bfd, 0, s->contents);
7506 if (mips_elf_hash_table (info)->rld_value == 0)
7507 mips_elf_hash_table (info)->rld_value = sym->st_value;
7509 else if (mips_elf_hash_table (info)->use_rld_obj_head
7510 && strcmp (name, "__rld_obj_head") == 0)
7512 /* IRIX6 does not use a .rld_map section. */
7513 if (IRIX_COMPAT (output_bfd) == ict_irix5
7514 || IRIX_COMPAT (output_bfd) == ict_none)
7515 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
7517 mips_elf_hash_table (info)->rld_value = sym->st_value;
7521 /* If this is a mips16 symbol, force the value to be even. */
7522 if (sym->st_other == STO_MIPS16)
7523 sym->st_value &= ~1;
7528 /* Finish up the dynamic sections. */
7531 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
7532 struct bfd_link_info *info)
7537 struct mips_got_info *gg, *g;
7539 dynobj = elf_hash_table (info)->dynobj;
7541 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7543 sgot = mips_elf_got_section (dynobj, FALSE);
7548 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
7549 gg = mips_elf_section_data (sgot)->u.got_info;
7550 BFD_ASSERT (gg != NULL);
7551 g = mips_elf_got_for_ibfd (gg, output_bfd);
7552 BFD_ASSERT (g != NULL);
7555 if (elf_hash_table (info)->dynamic_sections_created)
7559 BFD_ASSERT (sdyn != NULL);
7560 BFD_ASSERT (g != NULL);
7562 for (b = sdyn->contents;
7563 b < sdyn->contents + sdyn->size;
7564 b += MIPS_ELF_DYN_SIZE (dynobj))
7566 Elf_Internal_Dyn dyn;
7570 bfd_boolean swap_out_p;
7572 /* Read in the current dynamic entry. */
7573 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
7575 /* Assume that we're going to modify it and write it out. */
7581 s = mips_elf_rel_dyn_section (dynobj, FALSE);
7582 BFD_ASSERT (s != NULL);
7583 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
7587 /* Rewrite DT_STRSZ. */
7589 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
7594 s = bfd_get_section_by_name (output_bfd, name);
7595 BFD_ASSERT (s != NULL);
7596 dyn.d_un.d_ptr = s->vma;
7599 case DT_MIPS_RLD_VERSION:
7600 dyn.d_un.d_val = 1; /* XXX */
7604 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
7607 case DT_MIPS_TIME_STAMP:
7608 time ((time_t *) &dyn.d_un.d_val);
7611 case DT_MIPS_ICHECKSUM:
7616 case DT_MIPS_IVERSION:
7621 case DT_MIPS_BASE_ADDRESS:
7622 s = output_bfd->sections;
7623 BFD_ASSERT (s != NULL);
7624 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
7627 case DT_MIPS_LOCAL_GOTNO:
7628 dyn.d_un.d_val = g->local_gotno;
7631 case DT_MIPS_UNREFEXTNO:
7632 /* The index into the dynamic symbol table which is the
7633 entry of the first external symbol that is not
7634 referenced within the same object. */
7635 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
7638 case DT_MIPS_GOTSYM:
7639 if (gg->global_gotsym)
7641 dyn.d_un.d_val = gg->global_gotsym->dynindx;
7644 /* In case if we don't have global got symbols we default
7645 to setting DT_MIPS_GOTSYM to the same value as
7646 DT_MIPS_SYMTABNO, so we just fall through. */
7648 case DT_MIPS_SYMTABNO:
7650 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
7651 s = bfd_get_section_by_name (output_bfd, name);
7652 BFD_ASSERT (s != NULL);
7654 dyn.d_un.d_val = s->size / elemsize;
7657 case DT_MIPS_HIPAGENO:
7658 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
7661 case DT_MIPS_RLD_MAP:
7662 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
7665 case DT_MIPS_OPTIONS:
7666 s = (bfd_get_section_by_name
7667 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
7668 dyn.d_un.d_ptr = s->vma;
7672 /* Reduce DT_RELSZ to account for any relocations we
7673 decided not to make. This is for the n64 irix rld,
7674 which doesn't seem to apply any relocations if there
7675 are trailing null entries. */
7676 s = mips_elf_rel_dyn_section (dynobj, FALSE);
7677 dyn.d_un.d_val = (s->reloc_count
7678 * (ABI_64_P (output_bfd)
7679 ? sizeof (Elf64_Mips_External_Rel)
7680 : sizeof (Elf32_External_Rel)));
7689 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
7694 /* The first entry of the global offset table will be filled at
7695 runtime. The second entry will be used by some runtime loaders.
7696 This isn't the case of IRIX rld. */
7697 if (sgot != NULL && sgot->size > 0)
7699 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents);
7700 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000,
7701 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
7705 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
7706 = MIPS_ELF_GOT_SIZE (output_bfd);
7708 /* Generate dynamic relocations for the non-primary gots. */
7709 if (gg != NULL && gg->next)
7711 Elf_Internal_Rela rel[3];
7714 memset (rel, 0, sizeof (rel));
7715 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7717 for (g = gg->next; g->next != gg; g = g->next)
7719 bfd_vma index = g->next->local_gotno + g->next->global_gotno
7720 + g->next->tls_gotno;
7722 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
7723 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7724 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents
7725 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7730 while (index < g->assigned_gotno)
7732 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7733 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7734 if (!(mips_elf_create_dynamic_relocation
7735 (output_bfd, info, rel, NULL,
7736 bfd_abs_section_ptr,
7739 BFD_ASSERT (addend == 0);
7746 Elf32_compact_rel cpt;
7748 if (SGI_COMPAT (output_bfd))
7750 /* Write .compact_rel section out. */
7751 s = bfd_get_section_by_name (dynobj, ".compact_rel");
7755 cpt.num = s->reloc_count;
7757 cpt.offset = (s->output_section->filepos
7758 + sizeof (Elf32_External_compact_rel));
7761 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7762 ((Elf32_External_compact_rel *)
7765 /* Clean up a dummy stub function entry in .text. */
7766 s = bfd_get_section_by_name (dynobj,
7767 MIPS_ELF_STUB_SECTION_NAME (dynobj));
7770 file_ptr dummy_offset;
7772 BFD_ASSERT (s->size >= MIPS_FUNCTION_STUB_SIZE);
7773 dummy_offset = s->size - MIPS_FUNCTION_STUB_SIZE;
7774 memset (s->contents + dummy_offset, 0,
7775 MIPS_FUNCTION_STUB_SIZE);
7780 /* We need to sort the entries of the dynamic relocation section. */
7782 s = mips_elf_rel_dyn_section (dynobj, FALSE);
7785 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7787 reldyn_sorting_bfd = output_bfd;
7789 if (ABI_64_P (output_bfd))
7790 qsort ((Elf64_External_Rel *) s->contents + 1, s->reloc_count - 1,
7791 sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7793 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
7794 sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7802 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7805 mips_set_isa_flags (bfd *abfd)
7809 switch (bfd_get_mach (abfd))
7812 case bfd_mach_mips3000:
7813 val = E_MIPS_ARCH_1;
7816 case bfd_mach_mips3900:
7817 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7820 case bfd_mach_mips6000:
7821 val = E_MIPS_ARCH_2;
7824 case bfd_mach_mips4000:
7825 case bfd_mach_mips4300:
7826 case bfd_mach_mips4400:
7827 case bfd_mach_mips4600:
7828 val = E_MIPS_ARCH_3;
7831 case bfd_mach_mips4010:
7832 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7835 case bfd_mach_mips4100:
7836 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7839 case bfd_mach_mips4111:
7840 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7843 case bfd_mach_mips4120:
7844 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7847 case bfd_mach_mips4650:
7848 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7851 case bfd_mach_mips5400:
7852 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7855 case bfd_mach_mips5500:
7856 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7859 case bfd_mach_mips9000:
7860 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
7863 case bfd_mach_mips5000:
7864 case bfd_mach_mips7000:
7865 case bfd_mach_mips8000:
7866 case bfd_mach_mips10000:
7867 case bfd_mach_mips12000:
7868 val = E_MIPS_ARCH_4;
7871 case bfd_mach_mips5:
7872 val = E_MIPS_ARCH_5;
7875 case bfd_mach_mips_sb1:
7876 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7879 case bfd_mach_mipsisa32:
7880 val = E_MIPS_ARCH_32;
7883 case bfd_mach_mipsisa64:
7884 val = E_MIPS_ARCH_64;
7887 case bfd_mach_mipsisa32r2:
7888 val = E_MIPS_ARCH_32R2;
7891 case bfd_mach_mipsisa64r2:
7892 val = E_MIPS_ARCH_64R2;
7895 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7896 elf_elfheader (abfd)->e_flags |= val;
7901 /* The final processing done just before writing out a MIPS ELF object
7902 file. This gets the MIPS architecture right based on the machine
7903 number. This is used by both the 32-bit and the 64-bit ABI. */
7906 _bfd_mips_elf_final_write_processing (bfd *abfd,
7907 bfd_boolean linker ATTRIBUTE_UNUSED)
7910 Elf_Internal_Shdr **hdrpp;
7914 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7915 is nonzero. This is for compatibility with old objects, which used
7916 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7917 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7918 mips_set_isa_flags (abfd);
7920 /* Set the sh_info field for .gptab sections and other appropriate
7921 info for each special section. */
7922 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7923 i < elf_numsections (abfd);
7926 switch ((*hdrpp)->sh_type)
7929 case SHT_MIPS_LIBLIST:
7930 sec = bfd_get_section_by_name (abfd, ".dynstr");
7932 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7935 case SHT_MIPS_GPTAB:
7936 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7937 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7938 BFD_ASSERT (name != NULL
7939 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7940 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7941 BFD_ASSERT (sec != NULL);
7942 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7945 case SHT_MIPS_CONTENT:
7946 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7947 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7948 BFD_ASSERT (name != NULL
7949 && strncmp (name, ".MIPS.content",
7950 sizeof ".MIPS.content" - 1) == 0);
7951 sec = bfd_get_section_by_name (abfd,
7952 name + sizeof ".MIPS.content" - 1);
7953 BFD_ASSERT (sec != NULL);
7954 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7957 case SHT_MIPS_SYMBOL_LIB:
7958 sec = bfd_get_section_by_name (abfd, ".dynsym");
7960 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7961 sec = bfd_get_section_by_name (abfd, ".liblist");
7963 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7966 case SHT_MIPS_EVENTS:
7967 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7968 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7969 BFD_ASSERT (name != NULL);
7970 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7971 sec = bfd_get_section_by_name (abfd,
7972 name + sizeof ".MIPS.events" - 1);
7975 BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7976 sizeof ".MIPS.post_rel" - 1) == 0);
7977 sec = bfd_get_section_by_name (abfd,
7979 + sizeof ".MIPS.post_rel" - 1));
7981 BFD_ASSERT (sec != NULL);
7982 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7989 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7993 _bfd_mips_elf_additional_program_headers (bfd *abfd)
7998 /* See if we need a PT_MIPS_REGINFO segment. */
7999 s = bfd_get_section_by_name (abfd, ".reginfo");
8000 if (s && (s->flags & SEC_LOAD))
8003 /* See if we need a PT_MIPS_OPTIONS segment. */
8004 if (IRIX_COMPAT (abfd) == ict_irix6
8005 && bfd_get_section_by_name (abfd,
8006 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
8009 /* See if we need a PT_MIPS_RTPROC segment. */
8010 if (IRIX_COMPAT (abfd) == ict_irix5
8011 && bfd_get_section_by_name (abfd, ".dynamic")
8012 && bfd_get_section_by_name (abfd, ".mdebug"))
8018 /* Modify the segment map for an IRIX5 executable. */
8021 _bfd_mips_elf_modify_segment_map (bfd *abfd,
8022 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8025 struct elf_segment_map *m, **pm;
8028 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
8030 s = bfd_get_section_by_name (abfd, ".reginfo");
8031 if (s != NULL && (s->flags & SEC_LOAD) != 0)
8033 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
8034 if (m->p_type == PT_MIPS_REGINFO)
8039 m = bfd_zalloc (abfd, amt);
8043 m->p_type = PT_MIPS_REGINFO;
8047 /* We want to put it after the PHDR and INTERP segments. */
8048 pm = &elf_tdata (abfd)->segment_map;
8050 && ((*pm)->p_type == PT_PHDR
8051 || (*pm)->p_type == PT_INTERP))
8059 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
8060 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
8061 PT_MIPS_OPTIONS segment immediately following the program header
8064 /* On non-IRIX6 new abi, we'll have already created a segment
8065 for this section, so don't create another. I'm not sure this
8066 is not also the case for IRIX 6, but I can't test it right
8068 && IRIX_COMPAT (abfd) == ict_irix6)
8070 for (s = abfd->sections; s; s = s->next)
8071 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
8076 struct elf_segment_map *options_segment;
8078 pm = &elf_tdata (abfd)->segment_map;
8080 && ((*pm)->p_type == PT_PHDR
8081 || (*pm)->p_type == PT_INTERP))
8084 amt = sizeof (struct elf_segment_map);
8085 options_segment = bfd_zalloc (abfd, amt);
8086 options_segment->next = *pm;
8087 options_segment->p_type = PT_MIPS_OPTIONS;
8088 options_segment->p_flags = PF_R;
8089 options_segment->p_flags_valid = TRUE;
8090 options_segment->count = 1;
8091 options_segment->sections[0] = s;
8092 *pm = options_segment;
8097 if (IRIX_COMPAT (abfd) == ict_irix5)
8099 /* If there are .dynamic and .mdebug sections, we make a room
8100 for the RTPROC header. FIXME: Rewrite without section names. */
8101 if (bfd_get_section_by_name (abfd, ".interp") == NULL
8102 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
8103 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
8105 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
8106 if (m->p_type == PT_MIPS_RTPROC)
8111 m = bfd_zalloc (abfd, amt);
8115 m->p_type = PT_MIPS_RTPROC;
8117 s = bfd_get_section_by_name (abfd, ".rtproc");
8122 m->p_flags_valid = 1;
8130 /* We want to put it after the DYNAMIC segment. */
8131 pm = &elf_tdata (abfd)->segment_map;
8132 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
8142 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
8143 .dynstr, .dynsym, and .hash sections, and everything in
8145 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
8147 if ((*pm)->p_type == PT_DYNAMIC)
8150 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
8152 /* For a normal mips executable the permissions for the PT_DYNAMIC
8153 segment are read, write and execute. We do that here since
8154 the code in elf.c sets only the read permission. This matters
8155 sometimes for the dynamic linker. */
8156 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
8158 m->p_flags = PF_R | PF_W | PF_X;
8159 m->p_flags_valid = 1;
8163 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
8165 static const char *sec_names[] =
8167 ".dynamic", ".dynstr", ".dynsym", ".hash"
8171 struct elf_segment_map *n;
8175 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
8177 s = bfd_get_section_by_name (abfd, sec_names[i]);
8178 if (s != NULL && (s->flags & SEC_LOAD) != 0)
8185 if (high < s->vma + sz)
8191 for (s = abfd->sections; s != NULL; s = s->next)
8192 if ((s->flags & SEC_LOAD) != 0
8194 && s->vma + s->size <= high)
8197 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
8198 n = bfd_zalloc (abfd, amt);
8205 for (s = abfd->sections; s != NULL; s = s->next)
8207 if ((s->flags & SEC_LOAD) != 0
8209 && s->vma + s->size <= high)
8223 /* Return the section that should be marked against GC for a given
8227 _bfd_mips_elf_gc_mark_hook (asection *sec,
8228 struct bfd_link_info *info ATTRIBUTE_UNUSED,
8229 Elf_Internal_Rela *rel,
8230 struct elf_link_hash_entry *h,
8231 Elf_Internal_Sym *sym)
8233 /* ??? Do mips16 stub sections need to be handled special? */
8237 switch (ELF_R_TYPE (sec->owner, rel->r_info))
8239 case R_MIPS_GNU_VTINHERIT:
8240 case R_MIPS_GNU_VTENTRY:
8244 switch (h->root.type)
8246 case bfd_link_hash_defined:
8247 case bfd_link_hash_defweak:
8248 return h->root.u.def.section;
8250 case bfd_link_hash_common:
8251 return h->root.u.c.p->section;
8259 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
8264 /* Update the got entry reference counts for the section being removed. */
8267 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
8268 struct bfd_link_info *info ATTRIBUTE_UNUSED,
8269 asection *sec ATTRIBUTE_UNUSED,
8270 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
8273 Elf_Internal_Shdr *symtab_hdr;
8274 struct elf_link_hash_entry **sym_hashes;
8275 bfd_signed_vma *local_got_refcounts;
8276 const Elf_Internal_Rela *rel, *relend;
8277 unsigned long r_symndx;
8278 struct elf_link_hash_entry *h;
8280 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8281 sym_hashes = elf_sym_hashes (abfd);
8282 local_got_refcounts = elf_local_got_refcounts (abfd);
8284 relend = relocs + sec->reloc_count;
8285 for (rel = relocs; rel < relend; rel++)
8286 switch (ELF_R_TYPE (abfd, rel->r_info))
8290 case R_MIPS_CALL_HI16:
8291 case R_MIPS_CALL_LO16:
8292 case R_MIPS_GOT_HI16:
8293 case R_MIPS_GOT_LO16:
8294 case R_MIPS_GOT_DISP:
8295 case R_MIPS_GOT_PAGE:
8296 case R_MIPS_GOT_OFST:
8297 /* ??? It would seem that the existing MIPS code does no sort
8298 of reference counting or whatnot on its GOT and PLT entries,
8299 so it is not possible to garbage collect them at this time. */
8310 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
8311 hiding the old indirect symbol. Process additional relocation
8312 information. Also called for weakdefs, in which case we just let
8313 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
8316 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
8317 struct elf_link_hash_entry *dir,
8318 struct elf_link_hash_entry *ind)
8320 struct mips_elf_link_hash_entry *dirmips, *indmips;
8322 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
8324 if (ind->root.type != bfd_link_hash_indirect)
8327 dirmips = (struct mips_elf_link_hash_entry *) dir;
8328 indmips = (struct mips_elf_link_hash_entry *) ind;
8329 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
8330 if (indmips->readonly_reloc)
8331 dirmips->readonly_reloc = TRUE;
8332 if (indmips->no_fn_stub)
8333 dirmips->no_fn_stub = TRUE;
8335 if (dirmips->tls_type == 0)
8336 dirmips->tls_type = indmips->tls_type;
8338 BFD_ASSERT (indmips->tls_type == 0);
8342 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
8343 struct elf_link_hash_entry *entry,
8344 bfd_boolean force_local)
8348 struct mips_got_info *g;
8349 struct mips_elf_link_hash_entry *h;
8351 h = (struct mips_elf_link_hash_entry *) entry;
8352 if (h->forced_local)
8354 h->forced_local = force_local;
8356 dynobj = elf_hash_table (info)->dynobj;
8357 if (dynobj != NULL && force_local && h->root.type != STT_TLS)
8359 got = mips_elf_got_section (dynobj, FALSE);
8360 g = mips_elf_section_data (got)->u.got_info;
8364 struct mips_got_entry e;
8365 struct mips_got_info *gg = g;
8367 /* Since we're turning what used to be a global symbol into a
8368 local one, bump up the number of local entries of each GOT
8369 that had an entry for it. This will automatically decrease
8370 the number of global entries, since global_gotno is actually
8371 the upper limit of global entries. */
8377 for (g = g->next; g != gg; g = g->next)
8378 if (htab_find (g->got_entries, &e))
8380 BFD_ASSERT (g->global_gotno > 0);
8385 /* If this was a global symbol forced into the primary GOT, we
8386 no longer need an entry for it. We can't release the entry
8387 at this point, but we must at least stop counting it as one
8388 of the symbols that required a forced got entry. */
8389 if (h->root.got.offset == 2)
8391 BFD_ASSERT (gg->assigned_gotno > 0);
8392 gg->assigned_gotno--;
8395 else if (g->global_gotno == 0 && g->global_gotsym == NULL)
8396 /* If we haven't got through GOT allocation yet, just bump up the
8397 number of local entries, as this symbol won't be counted as
8400 else if (h->root.got.offset == 1)
8402 /* If we're past non-multi-GOT allocation and this symbol had
8403 been marked for a global got entry, give it a local entry
8405 BFD_ASSERT (g->global_gotno > 0);
8411 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
8417 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
8418 struct bfd_link_info *info)
8421 bfd_boolean ret = FALSE;
8422 unsigned char *tdata;
8425 o = bfd_get_section_by_name (abfd, ".pdr");
8430 if (o->size % PDR_SIZE != 0)
8432 if (o->output_section != NULL
8433 && bfd_is_abs_section (o->output_section))
8436 tdata = bfd_zmalloc (o->size / PDR_SIZE);
8440 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8448 cookie->rel = cookie->rels;
8449 cookie->relend = cookie->rels + o->reloc_count;
8451 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
8453 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
8462 mips_elf_section_data (o)->u.tdata = tdata;
8463 o->size -= skip * PDR_SIZE;
8469 if (! info->keep_memory)
8470 free (cookie->rels);
8476 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
8478 if (strcmp (sec->name, ".pdr") == 0)
8484 _bfd_mips_elf_write_section (bfd *output_bfd, asection *sec,
8487 bfd_byte *to, *from, *end;
8490 if (strcmp (sec->name, ".pdr") != 0)
8493 if (mips_elf_section_data (sec)->u.tdata == NULL)
8497 end = contents + sec->size;
8498 for (from = contents, i = 0;
8500 from += PDR_SIZE, i++)
8502 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
8505 memcpy (to, from, PDR_SIZE);
8508 bfd_set_section_contents (output_bfd, sec->output_section, contents,
8509 sec->output_offset, sec->size);
8513 /* MIPS ELF uses a special find_nearest_line routine in order the
8514 handle the ECOFF debugging information. */
8516 struct mips_elf_find_line
8518 struct ecoff_debug_info d;
8519 struct ecoff_find_line i;
8523 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
8524 asymbol **symbols, bfd_vma offset,
8525 const char **filename_ptr,
8526 const char **functionname_ptr,
8527 unsigned int *line_ptr)
8531 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
8532 filename_ptr, functionname_ptr,
8536 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
8537 filename_ptr, functionname_ptr,
8538 line_ptr, ABI_64_P (abfd) ? 8 : 0,
8539 &elf_tdata (abfd)->dwarf2_find_line_info))
8542 msec = bfd_get_section_by_name (abfd, ".mdebug");
8546 struct mips_elf_find_line *fi;
8547 const struct ecoff_debug_swap * const swap =
8548 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8550 /* If we are called during a link, mips_elf_final_link may have
8551 cleared the SEC_HAS_CONTENTS field. We force it back on here
8552 if appropriate (which it normally will be). */
8553 origflags = msec->flags;
8554 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
8555 msec->flags |= SEC_HAS_CONTENTS;
8557 fi = elf_tdata (abfd)->find_line_info;
8560 bfd_size_type external_fdr_size;
8563 struct fdr *fdr_ptr;
8564 bfd_size_type amt = sizeof (struct mips_elf_find_line);
8566 fi = bfd_zalloc (abfd, amt);
8569 msec->flags = origflags;
8573 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
8575 msec->flags = origflags;
8579 /* Swap in the FDR information. */
8580 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
8581 fi->d.fdr = bfd_alloc (abfd, amt);
8582 if (fi->d.fdr == NULL)
8584 msec->flags = origflags;
8587 external_fdr_size = swap->external_fdr_size;
8588 fdr_ptr = fi->d.fdr;
8589 fraw_src = (char *) fi->d.external_fdr;
8590 fraw_end = (fraw_src
8591 + fi->d.symbolic_header.ifdMax * external_fdr_size);
8592 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
8593 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
8595 elf_tdata (abfd)->find_line_info = fi;
8597 /* Note that we don't bother to ever free this information.
8598 find_nearest_line is either called all the time, as in
8599 objdump -l, so the information should be saved, or it is
8600 rarely called, as in ld error messages, so the memory
8601 wasted is unimportant. Still, it would probably be a
8602 good idea for free_cached_info to throw it away. */
8605 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
8606 &fi->i, filename_ptr, functionname_ptr,
8609 msec->flags = origflags;
8613 msec->flags = origflags;
8616 /* Fall back on the generic ELF find_nearest_line routine. */
8618 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
8619 filename_ptr, functionname_ptr,
8623 /* When are writing out the .options or .MIPS.options section,
8624 remember the bytes we are writing out, so that we can install the
8625 GP value in the section_processing routine. */
8628 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
8629 const void *location,
8630 file_ptr offset, bfd_size_type count)
8632 if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8636 if (elf_section_data (section) == NULL)
8638 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
8639 section->used_by_bfd = bfd_zalloc (abfd, amt);
8640 if (elf_section_data (section) == NULL)
8643 c = mips_elf_section_data (section)->u.tdata;
8646 c = bfd_zalloc (abfd, section->size);
8649 mips_elf_section_data (section)->u.tdata = c;
8652 memcpy (c + offset, location, count);
8655 return _bfd_elf_set_section_contents (abfd, section, location, offset,
8659 /* This is almost identical to bfd_generic_get_... except that some
8660 MIPS relocations need to be handled specially. Sigh. */
8663 _bfd_elf_mips_get_relocated_section_contents
8665 struct bfd_link_info *link_info,
8666 struct bfd_link_order *link_order,
8668 bfd_boolean relocatable,
8671 /* Get enough memory to hold the stuff */
8672 bfd *input_bfd = link_order->u.indirect.section->owner;
8673 asection *input_section = link_order->u.indirect.section;
8676 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8677 arelent **reloc_vector = NULL;
8683 reloc_vector = bfd_malloc (reloc_size);
8684 if (reloc_vector == NULL && reloc_size != 0)
8687 /* read in the section */
8688 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
8689 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
8692 reloc_count = bfd_canonicalize_reloc (input_bfd,
8696 if (reloc_count < 0)
8699 if (reloc_count > 0)
8704 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
8707 struct bfd_hash_entry *h;
8708 struct bfd_link_hash_entry *lh;
8709 /* Skip all this stuff if we aren't mixing formats. */
8710 if (abfd && input_bfd
8711 && abfd->xvec == input_bfd->xvec)
8715 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
8716 lh = (struct bfd_link_hash_entry *) h;
8723 case bfd_link_hash_undefined:
8724 case bfd_link_hash_undefweak:
8725 case bfd_link_hash_common:
8728 case bfd_link_hash_defined:
8729 case bfd_link_hash_defweak:
8731 gp = lh->u.def.value;
8733 case bfd_link_hash_indirect:
8734 case bfd_link_hash_warning:
8736 /* @@FIXME ignoring warning for now */
8738 case bfd_link_hash_new:
8747 for (parent = reloc_vector; *parent != NULL; parent++)
8749 char *error_message = NULL;
8750 bfd_reloc_status_type r;
8752 /* Specific to MIPS: Deal with relocation types that require
8753 knowing the gp of the output bfd. */
8754 asymbol *sym = *(*parent)->sym_ptr_ptr;
8755 if (bfd_is_abs_section (sym->section) && abfd)
8757 /* The special_function wouldn't get called anyway. */
8761 /* The gp isn't there; let the special function code
8762 fall over on its own. */
8764 else if ((*parent)->howto->special_function
8765 == _bfd_mips_elf32_gprel16_reloc)
8767 /* bypass special_function call */
8768 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8769 input_section, relocatable,
8771 goto skip_bfd_perform_relocation;
8773 /* end mips specific stuff */
8775 r = bfd_perform_relocation (input_bfd, *parent, data, input_section,
8776 relocatable ? abfd : NULL,
8778 skip_bfd_perform_relocation:
8782 asection *os = input_section->output_section;
8784 /* A partial link, so keep the relocs */
8785 os->orelocation[os->reloc_count] = *parent;
8789 if (r != bfd_reloc_ok)
8793 case bfd_reloc_undefined:
8794 if (!((*link_info->callbacks->undefined_symbol)
8795 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8796 input_bfd, input_section, (*parent)->address,
8800 case bfd_reloc_dangerous:
8801 BFD_ASSERT (error_message != NULL);
8802 if (!((*link_info->callbacks->reloc_dangerous)
8803 (link_info, error_message, input_bfd, input_section,
8804 (*parent)->address)))
8807 case bfd_reloc_overflow:
8808 if (!((*link_info->callbacks->reloc_overflow)
8810 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8811 (*parent)->howto->name, (*parent)->addend,
8812 input_bfd, input_section, (*parent)->address)))
8815 case bfd_reloc_outofrange:
8824 if (reloc_vector != NULL)
8825 free (reloc_vector);
8829 if (reloc_vector != NULL)
8830 free (reloc_vector);
8834 /* Create a MIPS ELF linker hash table. */
8836 struct bfd_link_hash_table *
8837 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
8839 struct mips_elf_link_hash_table *ret;
8840 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8842 ret = bfd_malloc (amt);
8846 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8847 mips_elf_link_hash_newfunc))
8854 /* We no longer use this. */
8855 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8856 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8858 ret->procedure_count = 0;
8859 ret->compact_rel_size = 0;
8860 ret->use_rld_obj_head = FALSE;
8862 ret->mips16_stubs_seen = FALSE;
8864 return &ret->root.root;
8867 /* We need to use a special link routine to handle the .reginfo and
8868 the .mdebug sections. We need to merge all instances of these
8869 sections together, not write them all out sequentially. */
8872 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
8876 struct bfd_link_order *p;
8877 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8878 asection *rtproc_sec;
8879 Elf32_RegInfo reginfo;
8880 struct ecoff_debug_info debug;
8881 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8882 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
8883 HDRR *symhdr = &debug.symbolic_header;
8884 void *mdebug_handle = NULL;
8890 static const char * const secname[] =
8892 ".text", ".init", ".fini", ".data",
8893 ".rodata", ".sdata", ".sbss", ".bss"
8895 static const int sc[] =
8897 scText, scInit, scFini, scData,
8898 scRData, scSData, scSBss, scBss
8901 /* We'd carefully arranged the dynamic symbol indices, and then the
8902 generic size_dynamic_sections renumbered them out from under us.
8903 Rather than trying somehow to prevent the renumbering, just do
8905 if (elf_hash_table (info)->dynamic_sections_created)
8909 struct mips_got_info *g;
8910 bfd_size_type dynsecsymcount;
8912 /* When we resort, we must tell mips_elf_sort_hash_table what
8913 the lowest index it may use is. That's the number of section
8914 symbols we're going to add. The generic ELF linker only
8915 adds these symbols when building a shared object. Note that
8916 we count the sections after (possibly) removing the .options
8924 for (p = abfd->sections; p ; p = p->next)
8925 if ((p->flags & SEC_EXCLUDE) == 0
8926 && (p->flags & SEC_ALLOC) != 0
8927 && !(*bed->elf_backend_omit_section_dynsym) (abfd, info, p))
8931 if (! mips_elf_sort_hash_table (info, dynsecsymcount + 1))
8934 /* Make sure we didn't grow the global .got region. */
8935 dynobj = elf_hash_table (info)->dynobj;
8936 got = mips_elf_got_section (dynobj, FALSE);
8937 g = mips_elf_section_data (got)->u.got_info;
8939 if (g->global_gotsym != NULL)
8940 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8941 - g->global_gotsym->dynindx)
8942 <= g->global_gotno);
8945 /* Get a value for the GP register. */
8946 if (elf_gp (abfd) == 0)
8948 struct bfd_link_hash_entry *h;
8950 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8951 if (h != NULL && h->type == bfd_link_hash_defined)
8952 elf_gp (abfd) = (h->u.def.value
8953 + h->u.def.section->output_section->vma
8954 + h->u.def.section->output_offset);
8955 else if (info->relocatable)
8957 bfd_vma lo = MINUS_ONE;
8959 /* Find the GP-relative section with the lowest offset. */
8960 for (o = abfd->sections; o != NULL; o = o->next)
8962 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8965 /* And calculate GP relative to that. */
8966 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8970 /* If the relocate_section function needs to do a reloc
8971 involving the GP value, it should make a reloc_dangerous
8972 callback to warn that GP is not defined. */
8976 /* Go through the sections and collect the .reginfo and .mdebug
8980 gptab_data_sec = NULL;
8981 gptab_bss_sec = NULL;
8982 for (o = abfd->sections; o != NULL; o = o->next)
8984 if (strcmp (o->name, ".reginfo") == 0)
8986 memset (®info, 0, sizeof reginfo);
8988 /* We have found the .reginfo section in the output file.
8989 Look through all the link_orders comprising it and merge
8990 the information together. */
8991 for (p = o->link_order_head; p != NULL; p = p->next)
8993 asection *input_section;
8995 Elf32_External_RegInfo ext;
8998 if (p->type != bfd_indirect_link_order)
9000 if (p->type == bfd_data_link_order)
9005 input_section = p->u.indirect.section;
9006 input_bfd = input_section->owner;
9008 if (! bfd_get_section_contents (input_bfd, input_section,
9009 &ext, 0, sizeof ext))
9012 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
9014 reginfo.ri_gprmask |= sub.ri_gprmask;
9015 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
9016 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
9017 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
9018 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
9020 /* ri_gp_value is set by the function
9021 mips_elf32_section_processing when the section is
9022 finally written out. */
9024 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9025 elf_link_input_bfd ignores this section. */
9026 input_section->flags &= ~SEC_HAS_CONTENTS;
9029 /* Size has been set in _bfd_mips_elf_always_size_sections. */
9030 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
9032 /* Skip this section later on (I don't think this currently
9033 matters, but someday it might). */
9034 o->link_order_head = NULL;
9039 if (strcmp (o->name, ".mdebug") == 0)
9041 struct extsym_info einfo;
9044 /* We have found the .mdebug section in the output file.
9045 Look through all the link_orders comprising it and merge
9046 the information together. */
9047 symhdr->magic = swap->sym_magic;
9048 /* FIXME: What should the version stamp be? */
9050 symhdr->ilineMax = 0;
9054 symhdr->isymMax = 0;
9055 symhdr->ioptMax = 0;
9056 symhdr->iauxMax = 0;
9058 symhdr->issExtMax = 0;
9061 symhdr->iextMax = 0;
9063 /* We accumulate the debugging information itself in the
9064 debug_info structure. */
9066 debug.external_dnr = NULL;
9067 debug.external_pdr = NULL;
9068 debug.external_sym = NULL;
9069 debug.external_opt = NULL;
9070 debug.external_aux = NULL;
9072 debug.ssext = debug.ssext_end = NULL;
9073 debug.external_fdr = NULL;
9074 debug.external_rfd = NULL;
9075 debug.external_ext = debug.external_ext_end = NULL;
9077 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
9078 if (mdebug_handle == NULL)
9082 esym.cobol_main = 0;
9086 esym.asym.iss = issNil;
9087 esym.asym.st = stLocal;
9088 esym.asym.reserved = 0;
9089 esym.asym.index = indexNil;
9091 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
9093 esym.asym.sc = sc[i];
9094 s = bfd_get_section_by_name (abfd, secname[i]);
9097 esym.asym.value = s->vma;
9098 last = s->vma + s->size;
9101 esym.asym.value = last;
9102 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
9107 for (p = o->link_order_head; p != NULL; p = p->next)
9109 asection *input_section;
9111 const struct ecoff_debug_swap *input_swap;
9112 struct ecoff_debug_info input_debug;
9116 if (p->type != bfd_indirect_link_order)
9118 if (p->type == bfd_data_link_order)
9123 input_section = p->u.indirect.section;
9124 input_bfd = input_section->owner;
9126 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
9127 || (get_elf_backend_data (input_bfd)
9128 ->elf_backend_ecoff_debug_swap) == NULL)
9130 /* I don't know what a non MIPS ELF bfd would be
9131 doing with a .mdebug section, but I don't really
9132 want to deal with it. */
9136 input_swap = (get_elf_backend_data (input_bfd)
9137 ->elf_backend_ecoff_debug_swap);
9139 BFD_ASSERT (p->size == input_section->size);
9141 /* The ECOFF linking code expects that we have already
9142 read in the debugging information and set up an
9143 ecoff_debug_info structure, so we do that now. */
9144 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
9148 if (! (bfd_ecoff_debug_accumulate
9149 (mdebug_handle, abfd, &debug, swap, input_bfd,
9150 &input_debug, input_swap, info)))
9153 /* Loop through the external symbols. For each one with
9154 interesting information, try to find the symbol in
9155 the linker global hash table and save the information
9156 for the output external symbols. */
9157 eraw_src = input_debug.external_ext;
9158 eraw_end = (eraw_src
9159 + (input_debug.symbolic_header.iextMax
9160 * input_swap->external_ext_size));
9162 eraw_src < eraw_end;
9163 eraw_src += input_swap->external_ext_size)
9167 struct mips_elf_link_hash_entry *h;
9169 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
9170 if (ext.asym.sc == scNil
9171 || ext.asym.sc == scUndefined
9172 || ext.asym.sc == scSUndefined)
9175 name = input_debug.ssext + ext.asym.iss;
9176 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
9177 name, FALSE, FALSE, TRUE);
9178 if (h == NULL || h->esym.ifd != -2)
9184 < input_debug.symbolic_header.ifdMax);
9185 ext.ifd = input_debug.ifdmap[ext.ifd];
9191 /* Free up the information we just read. */
9192 free (input_debug.line);
9193 free (input_debug.external_dnr);
9194 free (input_debug.external_pdr);
9195 free (input_debug.external_sym);
9196 free (input_debug.external_opt);
9197 free (input_debug.external_aux);
9198 free (input_debug.ss);
9199 free (input_debug.ssext);
9200 free (input_debug.external_fdr);
9201 free (input_debug.external_rfd);
9202 free (input_debug.external_ext);
9204 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9205 elf_link_input_bfd ignores this section. */
9206 input_section->flags &= ~SEC_HAS_CONTENTS;
9209 if (SGI_COMPAT (abfd) && info->shared)
9211 /* Create .rtproc section. */
9212 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
9213 if (rtproc_sec == NULL)
9215 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
9216 | SEC_LINKER_CREATED | SEC_READONLY);
9218 rtproc_sec = bfd_make_section (abfd, ".rtproc");
9219 if (rtproc_sec == NULL
9220 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
9221 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
9225 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
9231 /* Build the external symbol information. */
9234 einfo.debug = &debug;
9236 einfo.failed = FALSE;
9237 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9238 mips_elf_output_extsym, &einfo);
9242 /* Set the size of the .mdebug section. */
9243 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
9245 /* Skip this section later on (I don't think this currently
9246 matters, but someday it might). */
9247 o->link_order_head = NULL;
9252 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
9254 const char *subname;
9257 Elf32_External_gptab *ext_tab;
9260 /* The .gptab.sdata and .gptab.sbss sections hold
9261 information describing how the small data area would
9262 change depending upon the -G switch. These sections
9263 not used in executables files. */
9264 if (! info->relocatable)
9266 for (p = o->link_order_head; p != NULL; p = p->next)
9268 asection *input_section;
9270 if (p->type != bfd_indirect_link_order)
9272 if (p->type == bfd_data_link_order)
9277 input_section = p->u.indirect.section;
9279 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9280 elf_link_input_bfd ignores this section. */
9281 input_section->flags &= ~SEC_HAS_CONTENTS;
9284 /* Skip this section later on (I don't think this
9285 currently matters, but someday it might). */
9286 o->link_order_head = NULL;
9288 /* Really remove the section. */
9289 for (secpp = &abfd->sections;
9291 secpp = &(*secpp)->next)
9293 bfd_section_list_remove (abfd, secpp);
9294 --abfd->section_count;
9299 /* There is one gptab for initialized data, and one for
9300 uninitialized data. */
9301 if (strcmp (o->name, ".gptab.sdata") == 0)
9303 else if (strcmp (o->name, ".gptab.sbss") == 0)
9307 (*_bfd_error_handler)
9308 (_("%s: illegal section name `%s'"),
9309 bfd_get_filename (abfd), o->name);
9310 bfd_set_error (bfd_error_nonrepresentable_section);
9314 /* The linker script always combines .gptab.data and
9315 .gptab.sdata into .gptab.sdata, and likewise for
9316 .gptab.bss and .gptab.sbss. It is possible that there is
9317 no .sdata or .sbss section in the output file, in which
9318 case we must change the name of the output section. */
9319 subname = o->name + sizeof ".gptab" - 1;
9320 if (bfd_get_section_by_name (abfd, subname) == NULL)
9322 if (o == gptab_data_sec)
9323 o->name = ".gptab.data";
9325 o->name = ".gptab.bss";
9326 subname = o->name + sizeof ".gptab" - 1;
9327 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
9330 /* Set up the first entry. */
9332 amt = c * sizeof (Elf32_gptab);
9333 tab = bfd_malloc (amt);
9336 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
9337 tab[0].gt_header.gt_unused = 0;
9339 /* Combine the input sections. */
9340 for (p = o->link_order_head; p != NULL; p = p->next)
9342 asection *input_section;
9346 bfd_size_type gpentry;
9348 if (p->type != bfd_indirect_link_order)
9350 if (p->type == bfd_data_link_order)
9355 input_section = p->u.indirect.section;
9356 input_bfd = input_section->owner;
9358 /* Combine the gptab entries for this input section one
9359 by one. We know that the input gptab entries are
9360 sorted by ascending -G value. */
9361 size = input_section->size;
9363 for (gpentry = sizeof (Elf32_External_gptab);
9365 gpentry += sizeof (Elf32_External_gptab))
9367 Elf32_External_gptab ext_gptab;
9368 Elf32_gptab int_gptab;
9374 if (! (bfd_get_section_contents
9375 (input_bfd, input_section, &ext_gptab, gpentry,
9376 sizeof (Elf32_External_gptab))))
9382 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
9384 val = int_gptab.gt_entry.gt_g_value;
9385 add = int_gptab.gt_entry.gt_bytes - last;
9388 for (look = 1; look < c; look++)
9390 if (tab[look].gt_entry.gt_g_value >= val)
9391 tab[look].gt_entry.gt_bytes += add;
9393 if (tab[look].gt_entry.gt_g_value == val)
9399 Elf32_gptab *new_tab;
9402 /* We need a new table entry. */
9403 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
9404 new_tab = bfd_realloc (tab, amt);
9405 if (new_tab == NULL)
9411 tab[c].gt_entry.gt_g_value = val;
9412 tab[c].gt_entry.gt_bytes = add;
9414 /* Merge in the size for the next smallest -G
9415 value, since that will be implied by this new
9418 for (look = 1; look < c; look++)
9420 if (tab[look].gt_entry.gt_g_value < val
9422 || (tab[look].gt_entry.gt_g_value
9423 > tab[max].gt_entry.gt_g_value)))
9427 tab[c].gt_entry.gt_bytes +=
9428 tab[max].gt_entry.gt_bytes;
9433 last = int_gptab.gt_entry.gt_bytes;
9436 /* Hack: reset the SEC_HAS_CONTENTS flag so that
9437 elf_link_input_bfd ignores this section. */
9438 input_section->flags &= ~SEC_HAS_CONTENTS;
9441 /* The table must be sorted by -G value. */
9443 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
9445 /* Swap out the table. */
9446 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
9447 ext_tab = bfd_alloc (abfd, amt);
9448 if (ext_tab == NULL)
9454 for (j = 0; j < c; j++)
9455 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
9458 o->size = c * sizeof (Elf32_External_gptab);
9459 o->contents = (bfd_byte *) ext_tab;
9461 /* Skip this section later on (I don't think this currently
9462 matters, but someday it might). */
9463 o->link_order_head = NULL;
9467 /* Invoke the regular ELF backend linker to do all the work. */
9468 if (!bfd_elf_final_link (abfd, info))
9471 /* Now write out the computed sections. */
9473 if (reginfo_sec != NULL)
9475 Elf32_External_RegInfo ext;
9477 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
9478 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
9482 if (mdebug_sec != NULL)
9484 BFD_ASSERT (abfd->output_has_begun);
9485 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
9487 mdebug_sec->filepos))
9490 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
9493 if (gptab_data_sec != NULL)
9495 if (! bfd_set_section_contents (abfd, gptab_data_sec,
9496 gptab_data_sec->contents,
9497 0, gptab_data_sec->size))
9501 if (gptab_bss_sec != NULL)
9503 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
9504 gptab_bss_sec->contents,
9505 0, gptab_bss_sec->size))
9509 if (SGI_COMPAT (abfd))
9511 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
9512 if (rtproc_sec != NULL)
9514 if (! bfd_set_section_contents (abfd, rtproc_sec,
9515 rtproc_sec->contents,
9516 0, rtproc_sec->size))
9524 /* Structure for saying that BFD machine EXTENSION extends BASE. */
9526 struct mips_mach_extension {
9527 unsigned long extension, base;
9531 /* An array describing how BFD machines relate to one another. The entries
9532 are ordered topologically with MIPS I extensions listed last. */
9534 static const struct mips_mach_extension mips_mach_extensions[] = {
9535 /* MIPS64 extensions. */
9536 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
9537 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
9539 /* MIPS V extensions. */
9540 { bfd_mach_mipsisa64, bfd_mach_mips5 },
9542 /* R10000 extensions. */
9543 { bfd_mach_mips12000, bfd_mach_mips10000 },
9545 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
9546 vr5400 ISA, but doesn't include the multimedia stuff. It seems
9547 better to allow vr5400 and vr5500 code to be merged anyway, since
9548 many libraries will just use the core ISA. Perhaps we could add
9549 some sort of ASE flag if this ever proves a problem. */
9550 { bfd_mach_mips5500, bfd_mach_mips5400 },
9551 { bfd_mach_mips5400, bfd_mach_mips5000 },
9553 /* MIPS IV extensions. */
9554 { bfd_mach_mips5, bfd_mach_mips8000 },
9555 { bfd_mach_mips10000, bfd_mach_mips8000 },
9556 { bfd_mach_mips5000, bfd_mach_mips8000 },
9557 { bfd_mach_mips7000, bfd_mach_mips8000 },
9558 { bfd_mach_mips9000, bfd_mach_mips8000 },
9560 /* VR4100 extensions. */
9561 { bfd_mach_mips4120, bfd_mach_mips4100 },
9562 { bfd_mach_mips4111, bfd_mach_mips4100 },
9564 /* MIPS III extensions. */
9565 { bfd_mach_mips8000, bfd_mach_mips4000 },
9566 { bfd_mach_mips4650, bfd_mach_mips4000 },
9567 { bfd_mach_mips4600, bfd_mach_mips4000 },
9568 { bfd_mach_mips4400, bfd_mach_mips4000 },
9569 { bfd_mach_mips4300, bfd_mach_mips4000 },
9570 { bfd_mach_mips4100, bfd_mach_mips4000 },
9571 { bfd_mach_mips4010, bfd_mach_mips4000 },
9573 /* MIPS32 extensions. */
9574 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
9576 /* MIPS II extensions. */
9577 { bfd_mach_mips4000, bfd_mach_mips6000 },
9578 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
9580 /* MIPS I extensions. */
9581 { bfd_mach_mips6000, bfd_mach_mips3000 },
9582 { bfd_mach_mips3900, bfd_mach_mips3000 }
9586 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
9589 mips_mach_extends_p (unsigned long base, unsigned long extension)
9593 for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
9594 if (extension == mips_mach_extensions[i].extension)
9595 extension = mips_mach_extensions[i].base;
9597 return extension == base;
9601 /* Return true if the given ELF header flags describe a 32-bit binary. */
9604 mips_32bit_flags_p (flagword flags)
9606 return ((flags & EF_MIPS_32BITMODE) != 0
9607 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
9608 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
9609 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
9610 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
9611 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
9612 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
9616 /* Merge backend specific data from an object file to the output
9617 object file when linking. */
9620 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
9625 bfd_boolean null_input_bfd = TRUE;
9628 /* Check if we have the same endianess */
9629 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
9631 (*_bfd_error_handler)
9632 (_("%B: endianness incompatible with that of the selected emulation"),
9637 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
9638 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
9641 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
9643 (*_bfd_error_handler)
9644 (_("%B: ABI is incompatible with that of the selected emulation"),
9649 new_flags = elf_elfheader (ibfd)->e_flags;
9650 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
9651 old_flags = elf_elfheader (obfd)->e_flags;
9653 if (! elf_flags_init (obfd))
9655 elf_flags_init (obfd) = TRUE;
9656 elf_elfheader (obfd)->e_flags = new_flags;
9657 elf_elfheader (obfd)->e_ident[EI_CLASS]
9658 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
9660 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
9661 && bfd_get_arch_info (obfd)->the_default)
9663 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
9664 bfd_get_mach (ibfd)))
9671 /* Check flag compatibility. */
9673 new_flags &= ~EF_MIPS_NOREORDER;
9674 old_flags &= ~EF_MIPS_NOREORDER;
9676 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9677 doesn't seem to matter. */
9678 new_flags &= ~EF_MIPS_XGOT;
9679 old_flags &= ~EF_MIPS_XGOT;
9681 /* MIPSpro generates ucode info in n64 objects. Again, we should
9682 just be able to ignore this. */
9683 new_flags &= ~EF_MIPS_UCODE;
9684 old_flags &= ~EF_MIPS_UCODE;
9686 if (new_flags == old_flags)
9689 /* Check to see if the input BFD actually contains any sections.
9690 If not, its flags may not have been initialised either, but it cannot
9691 actually cause any incompatibility. */
9692 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9694 /* Ignore synthetic sections and empty .text, .data and .bss sections
9695 which are automatically generated by gas. */
9696 if (strcmp (sec->name, ".reginfo")
9697 && strcmp (sec->name, ".mdebug")
9699 || (strcmp (sec->name, ".text")
9700 && strcmp (sec->name, ".data")
9701 && strcmp (sec->name, ".bss"))))
9703 null_input_bfd = FALSE;
9712 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
9713 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
9715 (*_bfd_error_handler)
9716 (_("%B: warning: linking PIC files with non-PIC files"),
9721 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
9722 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
9723 if (! (new_flags & EF_MIPS_PIC))
9724 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
9726 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9727 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9729 /* Compare the ISAs. */
9730 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
9732 (*_bfd_error_handler)
9733 (_("%B: linking 32-bit code with 64-bit code"),
9737 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9739 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9740 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
9742 /* Copy the architecture info from IBFD to OBFD. Also copy
9743 the 32-bit flag (if set) so that we continue to recognise
9744 OBFD as a 32-bit binary. */
9745 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9746 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9747 elf_elfheader (obfd)->e_flags
9748 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9750 /* Copy across the ABI flags if OBFD doesn't use them
9751 and if that was what caused us to treat IBFD as 32-bit. */
9752 if ((old_flags & EF_MIPS_ABI) == 0
9753 && mips_32bit_flags_p (new_flags)
9754 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9755 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9759 /* The ISAs aren't compatible. */
9760 (*_bfd_error_handler)
9761 (_("%B: linking %s module with previous %s modules"),
9763 bfd_printable_name (ibfd),
9764 bfd_printable_name (obfd));
9769 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9770 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9772 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9773 does set EI_CLASS differently from any 32-bit ABI. */
9774 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9775 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9776 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9778 /* Only error if both are set (to different values). */
9779 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9780 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9781 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9783 (*_bfd_error_handler)
9784 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9786 elf_mips_abi_name (ibfd),
9787 elf_mips_abi_name (obfd));
9790 new_flags &= ~EF_MIPS_ABI;
9791 old_flags &= ~EF_MIPS_ABI;
9794 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9795 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9797 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9799 new_flags &= ~ EF_MIPS_ARCH_ASE;
9800 old_flags &= ~ EF_MIPS_ARCH_ASE;
9803 /* Warn about any other mismatches */
9804 if (new_flags != old_flags)
9806 (*_bfd_error_handler)
9807 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9808 ibfd, (unsigned long) new_flags,
9809 (unsigned long) old_flags);
9815 bfd_set_error (bfd_error_bad_value);
9822 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9825 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
9827 BFD_ASSERT (!elf_flags_init (abfd)
9828 || elf_elfheader (abfd)->e_flags == flags);
9830 elf_elfheader (abfd)->e_flags = flags;
9831 elf_flags_init (abfd) = TRUE;
9836 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
9840 BFD_ASSERT (abfd != NULL && ptr != NULL);
9842 /* Print normal ELF private data. */
9843 _bfd_elf_print_private_bfd_data (abfd, ptr);
9845 /* xgettext:c-format */
9846 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9848 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9849 fprintf (file, _(" [abi=O32]"));
9850 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9851 fprintf (file, _(" [abi=O64]"));
9852 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9853 fprintf (file, _(" [abi=EABI32]"));
9854 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9855 fprintf (file, _(" [abi=EABI64]"));
9856 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9857 fprintf (file, _(" [abi unknown]"));
9858 else if (ABI_N32_P (abfd))
9859 fprintf (file, _(" [abi=N32]"));
9860 else if (ABI_64_P (abfd))
9861 fprintf (file, _(" [abi=64]"));
9863 fprintf (file, _(" [no abi set]"));
9865 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9866 fprintf (file, _(" [mips1]"));
9867 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9868 fprintf (file, _(" [mips2]"));
9869 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9870 fprintf (file, _(" [mips3]"));
9871 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9872 fprintf (file, _(" [mips4]"));
9873 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9874 fprintf (file, _(" [mips5]"));
9875 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9876 fprintf (file, _(" [mips32]"));
9877 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9878 fprintf (file, _(" [mips64]"));
9879 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9880 fprintf (file, _(" [mips32r2]"));
9881 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
9882 fprintf (file, _(" [mips64r2]"));
9884 fprintf (file, _(" [unknown ISA]"));
9886 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9887 fprintf (file, _(" [mdmx]"));
9889 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9890 fprintf (file, _(" [mips16]"));
9892 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9893 fprintf (file, _(" [32bitmode]"));
9895 fprintf (file, _(" [not 32bitmode]"));
9902 struct bfd_elf_special_section const _bfd_mips_elf_special_sections[]=
9904 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9905 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9906 { ".lit4", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9907 { ".lit8", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9908 { ".ucode", 6, 0, SHT_MIPS_UCODE, 0 },
9909 { ".mdebug", 7, 0, SHT_MIPS_DEBUG, 0 },
9910 { NULL, 0, 0, 0, 0 }