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
;
67 /* The offset from the beginning of the .got section to the entry
68 corresponding to this symbol+addend. If it's a global symbol
69 whose offset is yet to be decided, it's going to be -1. */
73 /* This structure is used to hold .got information when linking. */
77 /* The global symbol in the GOT with the lowest index in the dynamic
79 struct elf_link_hash_entry
*global_gotsym
;
80 /* The number of global .got entries. */
81 unsigned int global_gotno
;
82 /* The number of local .got entries. */
83 unsigned int local_gotno
;
84 /* The number of local .got entries we have used. */
85 unsigned int assigned_gotno
;
86 /* A hash table holding members of the got. */
87 struct htab
*got_entries
;
88 /* A hash table mapping input bfds to other mips_got_info. NULL
89 unless multi-got was necessary. */
91 /* In multi-got links, a pointer to the next got (err, rather, most
92 of the time, it points to the previous got). */
93 struct mips_got_info
*next
;
96 /* Map an input bfd to a got in a multi-got link. */
98 struct mips_elf_bfd2got_hash
{
100 struct mips_got_info
*g
;
103 /* Structure passed when traversing the bfd2got hash table, used to
104 create and merge bfd's gots. */
106 struct mips_elf_got_per_bfd_arg
108 /* A hashtable that maps bfds to gots. */
110 /* The output bfd. */
112 /* The link information. */
113 struct bfd_link_info
*info
;
114 /* A pointer to the primary got, i.e., the one that's going to get
115 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
117 struct mips_got_info
*primary
;
118 /* A non-primary got we're trying to merge with other input bfd's
120 struct mips_got_info
*current
;
121 /* The maximum number of got entries that can be addressed with a
123 unsigned int max_count
;
124 /* The number of local and global entries in the primary got. */
125 unsigned int primary_count
;
126 /* The number of local and global entries in the current got. */
127 unsigned int current_count
;
130 /* Another structure used to pass arguments for got entries traversal. */
132 struct mips_elf_set_global_got_offset_arg
134 struct mips_got_info
*g
;
136 unsigned int needed_relocs
;
137 struct bfd_link_info
*info
;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf
;
145 struct mips_got_info
*got_info
;
150 #define mips_elf_section_data(sec) \
151 ((struct _mips_elf_section_data *) elf_section_data (sec))
153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
154 the dynamic symbols. */
156 struct mips_elf_hash_sort_data
158 /* The symbol in the global GOT with the lowest dynamic symbol table
160 struct elf_link_hash_entry
*low
;
161 /* The least dynamic symbol table index corresponding to a symbol
163 long min_got_dynindx
;
164 /* The greatest dynamic symbol table index corresponding to a symbol
165 with a GOT entry that is not referenced (e.g., a dynamic symbol
166 with dynamic relocations pointing to it from non-primary GOTs). */
167 long max_unref_got_dynindx
;
168 /* The greatest dynamic symbol table index not corresponding to a
169 symbol without a GOT entry. */
170 long max_non_got_dynindx
;
173 /* The MIPS ELF linker needs additional information for each symbol in
174 the global hash table. */
176 struct mips_elf_link_hash_entry
178 struct elf_link_hash_entry root
;
180 /* External symbol information. */
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
185 unsigned int possibly_dynamic_relocs
;
187 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
188 a readonly section. */
189 bfd_boolean readonly_reloc
;
191 /* We must not create a stub for a symbol that has relocations
192 related to taking the function's address, i.e. any but
193 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
195 bfd_boolean no_fn_stub
;
197 /* If there is a stub that 32 bit functions should use to call this
198 16 bit function, this points to the section containing the stub. */
201 /* Whether we need the fn_stub; this is set if this symbol appears
202 in any relocs other than a 16 bit call. */
203 bfd_boolean need_fn_stub
;
205 /* If there is a stub that 16 bit functions should use to call this
206 32 bit function, this points to the section containing the stub. */
209 /* This is like the call_stub field, but it is used if the function
210 being called returns a floating point value. */
211 asection
*call_fp_stub
;
213 /* Are we forced local? .*/
214 bfd_boolean forced_local
;
217 /* MIPS ELF linker hash table. */
219 struct mips_elf_link_hash_table
221 struct elf_link_hash_table root
;
223 /* We no longer use this. */
224 /* String section indices for the dynamic section symbols. */
225 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
227 /* The number of .rtproc entries. */
228 bfd_size_type procedure_count
;
229 /* The size of the .compact_rel section (if SGI_COMPAT). */
230 bfd_size_type compact_rel_size
;
231 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
232 entry is set to the address of __rld_obj_head as in IRIX5. */
233 bfd_boolean use_rld_obj_head
;
234 /* This is the value of the __rld_map or __rld_obj_head symbol. */
236 /* This is set if we see any mips16 stub sections. */
237 bfd_boolean mips16_stubs_seen
;
240 /* Structure used to pass information to mips_elf_output_extsym. */
245 struct bfd_link_info
*info
;
246 struct ecoff_debug_info
*debug
;
247 const struct ecoff_debug_swap
*swap
;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names
[] =
256 "_procedure_string_table",
257 "_procedure_table_size",
261 /* These structures are used to generate the .compact_rel section on
266 unsigned long id1
; /* Always one? */
267 unsigned long num
; /* Number of compact relocation entries. */
268 unsigned long id2
; /* Always two? */
269 unsigned long offset
; /* The file offset of the first relocation. */
270 unsigned long reserved0
; /* Zero? */
271 unsigned long reserved1
; /* Zero? */
280 bfd_byte reserved0
[4];
281 bfd_byte reserved1
[4];
282 } Elf32_External_compact_rel
;
286 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
287 unsigned int rtype
: 4; /* Relocation types. See below. */
288 unsigned int dist2to
: 8;
289 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
290 unsigned long konst
; /* KONST field. See below. */
291 unsigned long vaddr
; /* VADDR to be relocated. */
296 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
297 unsigned int rtype
: 4; /* Relocation types. See below. */
298 unsigned int dist2to
: 8;
299 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
300 unsigned long konst
; /* KONST field. See below. */
308 } Elf32_External_crinfo
;
314 } Elf32_External_crinfo2
;
316 /* These are the constants used to swap the bitfields in a crinfo. */
318 #define CRINFO_CTYPE (0x1)
319 #define CRINFO_CTYPE_SH (31)
320 #define CRINFO_RTYPE (0xf)
321 #define CRINFO_RTYPE_SH (27)
322 #define CRINFO_DIST2TO (0xff)
323 #define CRINFO_DIST2TO_SH (19)
324 #define CRINFO_RELVADDR (0x7ffff)
325 #define CRINFO_RELVADDR_SH (0)
327 /* A compact relocation info has long (3 words) or short (2 words)
328 formats. A short format doesn't have VADDR field and relvaddr
329 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
330 #define CRF_MIPS_LONG 1
331 #define CRF_MIPS_SHORT 0
333 /* There are 4 types of compact relocation at least. The value KONST
334 has different meaning for each type:
337 CT_MIPS_REL32 Address in data
338 CT_MIPS_WORD Address in word (XXX)
339 CT_MIPS_GPHI_LO GP - vaddr
340 CT_MIPS_JMPAD Address to jump
343 #define CRT_MIPS_REL32 0xa
344 #define CRT_MIPS_WORD 0xb
345 #define CRT_MIPS_GPHI_LO 0xc
346 #define CRT_MIPS_JMPAD 0xd
348 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
349 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
350 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
351 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
353 /* The structure of the runtime procedure descriptor created by the
354 loader for use by the static exception system. */
356 typedef struct runtime_pdr
{
357 bfd_vma adr
; /* Memory address of start of procedure. */
358 long regmask
; /* Save register mask. */
359 long regoffset
; /* Save register offset. */
360 long fregmask
; /* Save floating point register mask. */
361 long fregoffset
; /* Save floating point register offset. */
362 long frameoffset
; /* Frame size. */
363 short framereg
; /* Frame pointer register. */
364 short pcreg
; /* Offset or reg of return pc. */
365 long irpss
; /* Index into the runtime string table. */
367 struct exception_info
*exception_info
;/* Pointer to exception array. */
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct mips_got_entry
*mips_elf_create_local_got_entry
373 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
);
374 static bfd_boolean mips_elf_sort_hash_table_f
375 (struct mips_elf_link_hash_entry
*, void *);
376 static bfd_vma mips_elf_high
378 static bfd_boolean mips_elf_stub_section_p
380 static bfd_boolean mips_elf_create_dynamic_relocation
381 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
382 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
383 bfd_vma
*, asection
*);
384 static hashval_t mips_elf_got_entry_hash
386 static bfd_vma mips_elf_adjust_gp
387 (bfd
*, struct mips_got_info
*, bfd
*);
388 static struct mips_got_info
*mips_elf_got_for_ibfd
389 (struct mips_got_info
*, bfd
*);
391 /* This will be used when we sort the dynamic relocation records. */
392 static bfd
*reldyn_sorting_bfd
;
394 /* Nonzero if ABFD is using the N32 ABI. */
396 #define ABI_N32_P(abfd) \
397 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
399 /* Nonzero if ABFD is using the N64 ABI. */
400 #define ABI_64_P(abfd) \
401 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
403 /* Nonzero if ABFD is using NewABI conventions. */
404 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
406 /* The IRIX compatibility level we are striving for. */
407 #define IRIX_COMPAT(abfd) \
408 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
410 /* Whether we are trying to be compatible with IRIX at all. */
411 #define SGI_COMPAT(abfd) \
412 (IRIX_COMPAT (abfd) != ict_none)
414 /* The name of the options section. */
415 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
416 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
418 /* The name of the stub section. */
419 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
421 /* The size of an external REL relocation. */
422 #define MIPS_ELF_REL_SIZE(abfd) \
423 (get_elf_backend_data (abfd)->s->sizeof_rel)
425 /* The size of an external dynamic table entry. */
426 #define MIPS_ELF_DYN_SIZE(abfd) \
427 (get_elf_backend_data (abfd)->s->sizeof_dyn)
429 /* The size of a GOT entry. */
430 #define MIPS_ELF_GOT_SIZE(abfd) \
431 (get_elf_backend_data (abfd)->s->arch_size / 8)
433 /* The size of a symbol-table entry. */
434 #define MIPS_ELF_SYM_SIZE(abfd) \
435 (get_elf_backend_data (abfd)->s->sizeof_sym)
437 /* The default alignment for sections, as a power of two. */
438 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
439 (get_elf_backend_data (abfd)->s->log_file_align)
441 /* Get word-sized data. */
442 #define MIPS_ELF_GET_WORD(abfd, ptr) \
443 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
445 /* Put out word-sized data. */
446 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
448 ? bfd_put_64 (abfd, val, ptr) \
449 : bfd_put_32 (abfd, val, ptr))
451 /* Add a dynamic symbol table-entry. */
452 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
453 _bfd_elf_add_dynamic_entry (info, tag, val)
455 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
456 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
458 /* Determine whether the internal relocation of index REL_IDX is REL
459 (zero) or RELA (non-zero). The assumption is that, if there are
460 two relocation sections for this section, one of them is REL and
461 the other is RELA. If the index of the relocation we're testing is
462 in range for the first relocation section, check that the external
463 relocation size is that for RELA. It is also assumed that, if
464 rel_idx is not in range for the first section, and this first
465 section contains REL relocs, then the relocation is in the second
466 section, that is RELA. */
467 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
468 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
469 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
470 > (bfd_vma)(rel_idx)) \
471 == (elf_section_data (sec)->rel_hdr.sh_entsize \
472 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
473 : sizeof (Elf32_External_Rela))))
475 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
476 from smaller values. Start with zero, widen, *then* decrement. */
477 #define MINUS_ONE (((bfd_vma)0) - 1)
478 #define MINUS_TWO (((bfd_vma)0) - 2)
480 /* The number of local .got entries we reserve. */
481 #define MIPS_RESERVED_GOTNO (2)
483 /* The offset of $gp from the beginning of the .got section. */
484 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
486 /* The maximum size of the GOT for it to be addressable using 16-bit
488 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
490 /* Instructions which appear in a stub. */
491 #define STUB_LW(abfd) \
493 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
494 : 0x8f998010)) /* lw t9,0x8010(gp) */
495 #define STUB_MOVE(abfd) \
497 ? 0x03e0782d /* daddu t7,ra */ \
498 : 0x03e07821)) /* addu t7,ra */
499 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
500 #define STUB_LI16(abfd) \
502 ? 0x64180000 /* daddiu t8,zero,0 */ \
503 : 0x24180000)) /* addiu t8,zero,0 */
504 #define MIPS_FUNCTION_STUB_SIZE (16)
506 /* The name of the dynamic interpreter. This is put in the .interp
509 #define ELF_DYNAMIC_INTERPRETER(abfd) \
510 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
511 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
512 : "/usr/lib/libc.so.1")
515 #define MNAME(bfd,pre,pos) \
516 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
517 #define ELF_R_SYM(bfd, i) \
518 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
519 #define ELF_R_TYPE(bfd, i) \
520 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
521 #define ELF_R_INFO(bfd, s, t) \
522 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
524 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
525 #define ELF_R_SYM(bfd, i) \
527 #define ELF_R_TYPE(bfd, i) \
529 #define ELF_R_INFO(bfd, s, t) \
530 (ELF32_R_INFO (s, t))
533 /* The mips16 compiler uses a couple of special sections to handle
534 floating point arguments.
536 Section names that look like .mips16.fn.FNNAME contain stubs that
537 copy floating point arguments from the fp regs to the gp regs and
538 then jump to FNNAME. If any 32 bit function calls FNNAME, the
539 call should be redirected to the stub instead. If no 32 bit
540 function calls FNNAME, the stub should be discarded. We need to
541 consider any reference to the function, not just a call, because
542 if the address of the function is taken we will need the stub,
543 since the address might be passed to a 32 bit function.
545 Section names that look like .mips16.call.FNNAME contain stubs
546 that copy floating point arguments from the gp regs to the fp
547 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
548 then any 16 bit function that calls FNNAME should be redirected
549 to the stub instead. If FNNAME is not a 32 bit function, the
550 stub should be discarded.
552 .mips16.call.fp.FNNAME sections are similar, but contain stubs
553 which call FNNAME and then copy the return value from the fp regs
554 to the gp regs. These stubs store the return value in $18 while
555 calling FNNAME; any function which might call one of these stubs
556 must arrange to save $18 around the call. (This case is not
557 needed for 32 bit functions that call 16 bit functions, because
558 16 bit functions always return floating point values in both
561 Note that in all cases FNNAME might be defined statically.
562 Therefore, FNNAME is not used literally. Instead, the relocation
563 information will indicate which symbol the section is for.
565 We record any stubs that we find in the symbol table. */
567 #define FN_STUB ".mips16.fn."
568 #define CALL_STUB ".mips16.call."
569 #define CALL_FP_STUB ".mips16.call.fp."
571 /* Look up an entry in a MIPS ELF linker hash table. */
573 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
574 ((struct mips_elf_link_hash_entry *) \
575 elf_link_hash_lookup (&(table)->root, (string), (create), \
578 /* Traverse a MIPS ELF linker hash table. */
580 #define mips_elf_link_hash_traverse(table, func, info) \
581 (elf_link_hash_traverse \
583 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
586 /* Get the MIPS ELF linker hash table from a link_info structure. */
588 #define mips_elf_hash_table(p) \
589 ((struct mips_elf_link_hash_table *) ((p)->hash))
591 /* Create an entry in a MIPS ELF linker hash table. */
593 static struct bfd_hash_entry
*
594 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
595 struct bfd_hash_table
*table
, const char *string
)
597 struct mips_elf_link_hash_entry
*ret
=
598 (struct mips_elf_link_hash_entry
*) entry
;
600 /* Allocate the structure if it has not already been allocated by a
603 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
605 return (struct bfd_hash_entry
*) ret
;
607 /* Call the allocation method of the superclass. */
608 ret
= ((struct mips_elf_link_hash_entry
*)
609 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
613 /* Set local fields. */
614 memset (&ret
->esym
, 0, sizeof (EXTR
));
615 /* We use -2 as a marker to indicate that the information has
616 not been set. -1 means there is no associated ifd. */
618 ret
->possibly_dynamic_relocs
= 0;
619 ret
->readonly_reloc
= FALSE
;
620 ret
->no_fn_stub
= FALSE
;
622 ret
->need_fn_stub
= FALSE
;
623 ret
->call_stub
= NULL
;
624 ret
->call_fp_stub
= NULL
;
625 ret
->forced_local
= FALSE
;
628 return (struct bfd_hash_entry
*) ret
;
632 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
634 struct _mips_elf_section_data
*sdata
;
635 bfd_size_type amt
= sizeof (*sdata
);
637 sdata
= bfd_zalloc (abfd
, amt
);
640 sec
->used_by_bfd
= sdata
;
642 return _bfd_elf_new_section_hook (abfd
, sec
);
645 /* Read ECOFF debugging information from a .mdebug section into a
646 ecoff_debug_info structure. */
649 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
650 struct ecoff_debug_info
*debug
)
653 const struct ecoff_debug_swap
*swap
;
656 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
657 memset (debug
, 0, sizeof (*debug
));
659 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
660 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
663 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
664 swap
->external_hdr_size
))
667 symhdr
= &debug
->symbolic_header
;
668 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
670 /* The symbolic header contains absolute file offsets and sizes to
672 #define READ(ptr, offset, count, size, type) \
673 if (symhdr->count == 0) \
677 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
678 debug->ptr = bfd_malloc (amt); \
679 if (debug->ptr == NULL) \
681 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
682 || bfd_bread (debug->ptr, amt, abfd) != amt) \
686 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
687 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
688 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
689 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
690 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
691 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
693 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
694 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
695 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
696 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
697 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
707 if (debug
->line
!= NULL
)
709 if (debug
->external_dnr
!= NULL
)
710 free (debug
->external_dnr
);
711 if (debug
->external_pdr
!= NULL
)
712 free (debug
->external_pdr
);
713 if (debug
->external_sym
!= NULL
)
714 free (debug
->external_sym
);
715 if (debug
->external_opt
!= NULL
)
716 free (debug
->external_opt
);
717 if (debug
->external_aux
!= NULL
)
718 free (debug
->external_aux
);
719 if (debug
->ss
!= NULL
)
721 if (debug
->ssext
!= NULL
)
723 if (debug
->external_fdr
!= NULL
)
724 free (debug
->external_fdr
);
725 if (debug
->external_rfd
!= NULL
)
726 free (debug
->external_rfd
);
727 if (debug
->external_ext
!= NULL
)
728 free (debug
->external_ext
);
732 /* Swap RPDR (runtime procedure table entry) for output. */
735 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
737 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
738 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
739 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
740 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
741 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
742 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
744 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
745 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
747 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
749 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
753 /* Create a runtime procedure table from the .mdebug section. */
756 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
757 struct bfd_link_info
*info
, asection
*s
,
758 struct ecoff_debug_info
*debug
)
760 const struct ecoff_debug_swap
*swap
;
761 HDRR
*hdr
= &debug
->symbolic_header
;
763 struct rpdr_ext
*erp
;
765 struct pdr_ext
*epdr
;
766 struct sym_ext
*esym
;
771 unsigned long sindex
;
775 const char *no_name_func
= _("static procedure (no name)");
783 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
785 sindex
= strlen (no_name_func
) + 1;
789 size
= swap
->external_pdr_size
;
791 epdr
= bfd_malloc (size
* count
);
795 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
798 size
= sizeof (RPDR
);
799 rp
= rpdr
= bfd_malloc (size
* count
);
803 size
= sizeof (char *);
804 sv
= bfd_malloc (size
* count
);
808 count
= hdr
->isymMax
;
809 size
= swap
->external_sym_size
;
810 esym
= bfd_malloc (size
* count
);
814 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
818 ss
= bfd_malloc (count
);
821 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
825 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
827 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
828 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
830 rp
->regmask
= pdr
.regmask
;
831 rp
->regoffset
= pdr
.regoffset
;
832 rp
->fregmask
= pdr
.fregmask
;
833 rp
->fregoffset
= pdr
.fregoffset
;
834 rp
->frameoffset
= pdr
.frameoffset
;
835 rp
->framereg
= pdr
.framereg
;
836 rp
->pcreg
= pdr
.pcreg
;
838 sv
[i
] = ss
+ sym
.iss
;
839 sindex
+= strlen (sv
[i
]) + 1;
843 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
844 size
= BFD_ALIGN (size
, 16);
845 rtproc
= bfd_alloc (abfd
, size
);
848 mips_elf_hash_table (info
)->procedure_count
= 0;
852 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
855 memset (erp
, 0, sizeof (struct rpdr_ext
));
857 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
858 strcpy (str
, no_name_func
);
859 str
+= strlen (no_name_func
) + 1;
860 for (i
= 0; i
< count
; i
++)
862 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
864 str
+= strlen (sv
[i
]) + 1;
866 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
868 /* Set the size and contents of .rtproc section. */
870 s
->contents
= rtproc
;
872 /* Skip this section later on (I don't think this currently
873 matters, but someday it might). */
874 s
->link_order_head
= NULL
;
903 /* Check the mips16 stubs for a particular symbol, and see if we can
907 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
908 void *data ATTRIBUTE_UNUSED
)
910 if (h
->root
.root
.type
== bfd_link_hash_warning
)
911 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
913 if (h
->fn_stub
!= NULL
914 && ! h
->need_fn_stub
)
916 /* We don't need the fn_stub; the only references to this symbol
917 are 16 bit calls. Clobber the size to 0 to prevent it from
918 being included in the link. */
919 h
->fn_stub
->size
= 0;
920 h
->fn_stub
->flags
&= ~SEC_RELOC
;
921 h
->fn_stub
->reloc_count
= 0;
922 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
925 if (h
->call_stub
!= NULL
926 && h
->root
.other
== STO_MIPS16
)
928 /* We don't need the call_stub; this is a 16 bit function, so
929 calls from other 16 bit functions are OK. Clobber the size
930 to 0 to prevent it from being included in the link. */
931 h
->call_stub
->size
= 0;
932 h
->call_stub
->flags
&= ~SEC_RELOC
;
933 h
->call_stub
->reloc_count
= 0;
934 h
->call_stub
->flags
|= SEC_EXCLUDE
;
937 if (h
->call_fp_stub
!= NULL
938 && h
->root
.other
== STO_MIPS16
)
940 /* We don't need the call_stub; this is a 16 bit function, so
941 calls from other 16 bit functions are OK. Clobber the size
942 to 0 to prevent it from being included in the link. */
943 h
->call_fp_stub
->size
= 0;
944 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
945 h
->call_fp_stub
->reloc_count
= 0;
946 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
952 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
953 Most mips16 instructions are 16 bits, but these instructions
956 The format of these instructions is:
958 +--------------+--------------------------------+
959 | JALX | X| Imm 20:16 | Imm 25:21 |
960 +--------------+--------------------------------+
962 +-----------------------------------------------+
964 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
965 Note that the immediate value in the first word is swapped.
967 When producing a relocatable object file, R_MIPS16_26 is
968 handled mostly like R_MIPS_26. In particular, the addend is
969 stored as a straight 26-bit value in a 32-bit instruction.
970 (gas makes life simpler for itself by never adjusting a
971 R_MIPS16_26 reloc to be against a section, so the addend is
972 always zero). However, the 32 bit instruction is stored as 2
973 16-bit values, rather than a single 32-bit value. In a
974 big-endian file, the result is the same; in a little-endian
975 file, the two 16-bit halves of the 32 bit value are swapped.
976 This is so that a disassembler can recognize the jal
979 When doing a final link, R_MIPS16_26 is treated as a 32 bit
980 instruction stored as two 16-bit values. The addend A is the
981 contents of the targ26 field. The calculation is the same as
982 R_MIPS_26. When storing the calculated value, reorder the
983 immediate value as shown above, and don't forget to store the
984 value as two 16-bit values.
986 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
990 +--------+----------------------+
994 +--------+----------------------+
997 +----------+------+-------------+
1001 +----------+--------------------+
1002 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1003 ((sub1 << 16) | sub2)).
1005 When producing a relocatable object file, the calculation is
1006 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1007 When producing a fully linked file, the calculation is
1008 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1009 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1011 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1012 mode. A typical instruction will have a format like this:
1014 +--------------+--------------------------------+
1015 | EXTEND | Imm 10:5 | Imm 15:11 |
1016 +--------------+--------------------------------+
1017 | Major | rx | ry | Imm 4:0 |
1018 +--------------+--------------------------------+
1020 EXTEND is the five bit value 11110. Major is the instruction
1023 This is handled exactly like R_MIPS_GPREL16, except that the
1024 addend is retrieved and stored as shown in this diagram; that
1025 is, the Imm fields above replace the V-rel16 field.
1027 All we need to do here is shuffle the bits appropriately. As
1028 above, the two 16-bit halves must be swapped on a
1029 little-endian system.
1031 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1032 access data when neither GP-relative nor PC-relative addressing
1033 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1034 except that the addend is retrieved and stored as shown above
1038 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1039 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1041 bfd_vma extend
, insn
, val
;
1043 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1044 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1047 /* Pick up the mips16 extend instruction and the real instruction. */
1048 extend
= bfd_get_16 (abfd
, data
);
1049 insn
= bfd_get_16 (abfd
, data
+ 2);
1050 if (r_type
== R_MIPS16_26
)
1053 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1054 | ((extend
& 0x1f) << 21) | insn
;
1056 val
= extend
<< 16 | insn
;
1059 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1060 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1061 bfd_put_32 (abfd
, val
, data
);
1065 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1066 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1068 bfd_vma extend
, insn
, val
;
1070 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1071 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1074 val
= bfd_get_32 (abfd
, data
);
1075 if (r_type
== R_MIPS16_26
)
1079 insn
= val
& 0xffff;
1080 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1081 | ((val
>> 21) & 0x1f);
1085 insn
= val
& 0xffff;
1091 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1092 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1094 bfd_put_16 (abfd
, insn
, data
+ 2);
1095 bfd_put_16 (abfd
, extend
, data
);
1098 bfd_reloc_status_type
1099 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1100 arelent
*reloc_entry
, asection
*input_section
,
1101 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1105 bfd_reloc_status_type status
;
1107 if (bfd_is_com_section (symbol
->section
))
1110 relocation
= symbol
->value
;
1112 relocation
+= symbol
->section
->output_section
->vma
;
1113 relocation
+= symbol
->section
->output_offset
;
1115 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1116 return bfd_reloc_outofrange
;
1118 /* Set val to the offset into the section or symbol. */
1119 val
= reloc_entry
->addend
;
1121 _bfd_mips_elf_sign_extend (val
, 16);
1123 /* Adjust val for the final section location and GP value. If we
1124 are producing relocatable output, we don't want to do this for
1125 an external symbol. */
1127 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1128 val
+= relocation
- gp
;
1130 if (reloc_entry
->howto
->partial_inplace
)
1132 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1134 + reloc_entry
->address
);
1135 if (status
!= bfd_reloc_ok
)
1139 reloc_entry
->addend
= val
;
1142 reloc_entry
->address
+= input_section
->output_offset
;
1144 return bfd_reloc_ok
;
1147 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1148 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1149 that contains the relocation field and DATA points to the start of
1154 struct mips_hi16
*next
;
1156 asection
*input_section
;
1160 /* FIXME: This should not be a static variable. */
1162 static struct mips_hi16
*mips_hi16_list
;
1164 /* A howto special_function for REL *HI16 relocations. We can only
1165 calculate the correct value once we've seen the partnering
1166 *LO16 relocation, so just save the information for later.
1168 The ABI requires that the *LO16 immediately follow the *HI16.
1169 However, as a GNU extension, we permit an arbitrary number of
1170 *HI16s to be associated with a single *LO16. This significantly
1171 simplies the relocation handling in gcc. */
1173 bfd_reloc_status_type
1174 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1175 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1176 asection
*input_section
, bfd
*output_bfd
,
1177 char **error_message ATTRIBUTE_UNUSED
)
1179 struct mips_hi16
*n
;
1181 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1182 return bfd_reloc_outofrange
;
1184 n
= bfd_malloc (sizeof *n
);
1186 return bfd_reloc_outofrange
;
1188 n
->next
= mips_hi16_list
;
1190 n
->input_section
= input_section
;
1191 n
->rel
= *reloc_entry
;
1194 if (output_bfd
!= NULL
)
1195 reloc_entry
->address
+= input_section
->output_offset
;
1197 return bfd_reloc_ok
;
1200 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1201 like any other 16-bit relocation when applied to global symbols, but is
1202 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1204 bfd_reloc_status_type
1205 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1206 void *data
, asection
*input_section
,
1207 bfd
*output_bfd
, char **error_message
)
1209 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1210 || bfd_is_und_section (bfd_get_section (symbol
))
1211 || bfd_is_com_section (bfd_get_section (symbol
)))
1212 /* The relocation is against a global symbol. */
1213 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1214 input_section
, output_bfd
,
1217 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1218 input_section
, output_bfd
, error_message
);
1221 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1222 is a straightforward 16 bit inplace relocation, but we must deal with
1223 any partnering high-part relocations as well. */
1225 bfd_reloc_status_type
1226 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1227 void *data
, asection
*input_section
,
1228 bfd
*output_bfd
, char **error_message
)
1231 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1233 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1234 return bfd_reloc_outofrange
;
1236 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1238 vallo
= bfd_get_32 (abfd
, location
);
1239 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1242 while (mips_hi16_list
!= NULL
)
1244 bfd_reloc_status_type ret
;
1245 struct mips_hi16
*hi
;
1247 hi
= mips_hi16_list
;
1249 /* R_MIPS_GOT16 relocations are something of a special case. We
1250 want to install the addend in the same way as for a R_MIPS_HI16
1251 relocation (with a rightshift of 16). However, since GOT16
1252 relocations can also be used with global symbols, their howto
1253 has a rightshift of 0. */
1254 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1255 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1257 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1258 carry or borrow will induce a change of +1 or -1 in the high part. */
1259 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1261 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1262 hi
->input_section
, output_bfd
,
1264 if (ret
!= bfd_reloc_ok
)
1267 mips_hi16_list
= hi
->next
;
1271 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1272 input_section
, output_bfd
,
1276 /* A generic howto special_function. This calculates and installs the
1277 relocation itself, thus avoiding the oft-discussed problems in
1278 bfd_perform_relocation and bfd_install_relocation. */
1280 bfd_reloc_status_type
1281 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1282 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1283 asection
*input_section
, bfd
*output_bfd
,
1284 char **error_message ATTRIBUTE_UNUSED
)
1287 bfd_reloc_status_type status
;
1288 bfd_boolean relocatable
;
1290 relocatable
= (output_bfd
!= NULL
);
1292 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1293 return bfd_reloc_outofrange
;
1295 /* Build up the field adjustment in VAL. */
1297 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1299 /* Either we're calculating the final field value or we have a
1300 relocation against a section symbol. Add in the section's
1301 offset or address. */
1302 val
+= symbol
->section
->output_section
->vma
;
1303 val
+= symbol
->section
->output_offset
;
1308 /* We're calculating the final field value. Add in the symbol's value
1309 and, if pc-relative, subtract the address of the field itself. */
1310 val
+= symbol
->value
;
1311 if (reloc_entry
->howto
->pc_relative
)
1313 val
-= input_section
->output_section
->vma
;
1314 val
-= input_section
->output_offset
;
1315 val
-= reloc_entry
->address
;
1319 /* VAL is now the final adjustment. If we're keeping this relocation
1320 in the output file, and if the relocation uses a separate addend,
1321 we just need to add VAL to that addend. Otherwise we need to add
1322 VAL to the relocation field itself. */
1323 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1324 reloc_entry
->addend
+= val
;
1327 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1329 /* Add in the separate addend, if any. */
1330 val
+= reloc_entry
->addend
;
1332 /* Add VAL to the relocation field. */
1333 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1335 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1337 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1340 if (status
!= bfd_reloc_ok
)
1345 reloc_entry
->address
+= input_section
->output_offset
;
1347 return bfd_reloc_ok
;
1350 /* Swap an entry in a .gptab section. Note that these routines rely
1351 on the equivalence of the two elements of the union. */
1354 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1357 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1358 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1362 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1363 Elf32_External_gptab
*ex
)
1365 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1366 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1370 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1371 Elf32_External_compact_rel
*ex
)
1373 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1374 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1375 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1376 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1377 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1378 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1382 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1383 Elf32_External_crinfo
*ex
)
1387 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1388 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1389 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1390 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1391 H_PUT_32 (abfd
, l
, ex
->info
);
1392 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1393 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1396 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1397 routines swap this structure in and out. They are used outside of
1398 BFD, so they are globally visible. */
1401 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1404 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1405 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1406 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1407 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1408 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1409 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1413 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1414 Elf32_External_RegInfo
*ex
)
1416 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1417 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1418 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1419 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1420 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1421 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1424 /* In the 64 bit ABI, the .MIPS.options section holds register
1425 information in an Elf64_Reginfo structure. These routines swap
1426 them in and out. They are globally visible because they are used
1427 outside of BFD. These routines are here so that gas can call them
1428 without worrying about whether the 64 bit ABI has been included. */
1431 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1432 Elf64_Internal_RegInfo
*in
)
1434 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1435 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1436 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1437 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1438 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1439 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1440 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1444 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1445 Elf64_External_RegInfo
*ex
)
1447 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1448 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1449 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1450 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1451 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1452 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1453 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1456 /* Swap in an options header. */
1459 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1460 Elf_Internal_Options
*in
)
1462 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1463 in
->size
= H_GET_8 (abfd
, ex
->size
);
1464 in
->section
= H_GET_16 (abfd
, ex
->section
);
1465 in
->info
= H_GET_32 (abfd
, ex
->info
);
1468 /* Swap out an options header. */
1471 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1472 Elf_External_Options
*ex
)
1474 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1475 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1476 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1477 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1480 /* This function is called via qsort() to sort the dynamic relocation
1481 entries by increasing r_symndx value. */
1484 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1486 Elf_Internal_Rela int_reloc1
;
1487 Elf_Internal_Rela int_reloc2
;
1489 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1490 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1492 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1495 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1498 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1499 const void *arg2 ATTRIBUTE_UNUSED
)
1502 Elf_Internal_Rela int_reloc1
[3];
1503 Elf_Internal_Rela int_reloc2
[3];
1505 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1506 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1507 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1508 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1510 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1511 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1518 /* This routine is used to write out ECOFF debugging external symbol
1519 information. It is called via mips_elf_link_hash_traverse. The
1520 ECOFF external symbol information must match the ELF external
1521 symbol information. Unfortunately, at this point we don't know
1522 whether a symbol is required by reloc information, so the two
1523 tables may wind up being different. We must sort out the external
1524 symbol information before we can set the final size of the .mdebug
1525 section, and we must set the size of the .mdebug section before we
1526 can relocate any sections, and we can't know which symbols are
1527 required by relocation until we relocate the sections.
1528 Fortunately, it is relatively unlikely that any symbol will be
1529 stripped but required by a reloc. In particular, it can not happen
1530 when generating a final executable. */
1533 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1535 struct extsym_info
*einfo
= data
;
1537 asection
*sec
, *output_section
;
1539 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1540 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1542 if (h
->root
.indx
== -2)
1544 else if ((h
->root
.def_dynamic
1545 || h
->root
.ref_dynamic
1546 || h
->root
.type
== bfd_link_hash_new
)
1547 && !h
->root
.def_regular
1548 && !h
->root
.ref_regular
)
1550 else if (einfo
->info
->strip
== strip_all
1551 || (einfo
->info
->strip
== strip_some
1552 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1553 h
->root
.root
.root
.string
,
1554 FALSE
, FALSE
) == NULL
))
1562 if (h
->esym
.ifd
== -2)
1565 h
->esym
.cobol_main
= 0;
1566 h
->esym
.weakext
= 0;
1567 h
->esym
.reserved
= 0;
1568 h
->esym
.ifd
= ifdNil
;
1569 h
->esym
.asym
.value
= 0;
1570 h
->esym
.asym
.st
= stGlobal
;
1572 if (h
->root
.root
.type
== bfd_link_hash_undefined
1573 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1577 /* Use undefined class. Also, set class and type for some
1579 name
= h
->root
.root
.root
.string
;
1580 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1581 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1583 h
->esym
.asym
.sc
= scData
;
1584 h
->esym
.asym
.st
= stLabel
;
1585 h
->esym
.asym
.value
= 0;
1587 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1589 h
->esym
.asym
.sc
= scAbs
;
1590 h
->esym
.asym
.st
= stLabel
;
1591 h
->esym
.asym
.value
=
1592 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1594 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1596 h
->esym
.asym
.sc
= scAbs
;
1597 h
->esym
.asym
.st
= stLabel
;
1598 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1601 h
->esym
.asym
.sc
= scUndefined
;
1603 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1604 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1605 h
->esym
.asym
.sc
= scAbs
;
1610 sec
= h
->root
.root
.u
.def
.section
;
1611 output_section
= sec
->output_section
;
1613 /* When making a shared library and symbol h is the one from
1614 the another shared library, OUTPUT_SECTION may be null. */
1615 if (output_section
== NULL
)
1616 h
->esym
.asym
.sc
= scUndefined
;
1619 name
= bfd_section_name (output_section
->owner
, output_section
);
1621 if (strcmp (name
, ".text") == 0)
1622 h
->esym
.asym
.sc
= scText
;
1623 else if (strcmp (name
, ".data") == 0)
1624 h
->esym
.asym
.sc
= scData
;
1625 else if (strcmp (name
, ".sdata") == 0)
1626 h
->esym
.asym
.sc
= scSData
;
1627 else if (strcmp (name
, ".rodata") == 0
1628 || strcmp (name
, ".rdata") == 0)
1629 h
->esym
.asym
.sc
= scRData
;
1630 else if (strcmp (name
, ".bss") == 0)
1631 h
->esym
.asym
.sc
= scBss
;
1632 else if (strcmp (name
, ".sbss") == 0)
1633 h
->esym
.asym
.sc
= scSBss
;
1634 else if (strcmp (name
, ".init") == 0)
1635 h
->esym
.asym
.sc
= scInit
;
1636 else if (strcmp (name
, ".fini") == 0)
1637 h
->esym
.asym
.sc
= scFini
;
1639 h
->esym
.asym
.sc
= scAbs
;
1643 h
->esym
.asym
.reserved
= 0;
1644 h
->esym
.asym
.index
= indexNil
;
1647 if (h
->root
.root
.type
== bfd_link_hash_common
)
1648 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1649 else if (h
->root
.root
.type
== bfd_link_hash_defined
1650 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1652 if (h
->esym
.asym
.sc
== scCommon
)
1653 h
->esym
.asym
.sc
= scBss
;
1654 else if (h
->esym
.asym
.sc
== scSCommon
)
1655 h
->esym
.asym
.sc
= scSBss
;
1657 sec
= h
->root
.root
.u
.def
.section
;
1658 output_section
= sec
->output_section
;
1659 if (output_section
!= NULL
)
1660 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1661 + sec
->output_offset
1662 + output_section
->vma
);
1664 h
->esym
.asym
.value
= 0;
1666 else if (h
->root
.needs_plt
)
1668 struct mips_elf_link_hash_entry
*hd
= h
;
1669 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1671 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1673 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1674 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1679 /* Set type and value for a symbol with a function stub. */
1680 h
->esym
.asym
.st
= stProc
;
1681 sec
= hd
->root
.root
.u
.def
.section
;
1683 h
->esym
.asym
.value
= 0;
1686 output_section
= sec
->output_section
;
1687 if (output_section
!= NULL
)
1688 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1689 + sec
->output_offset
1690 + output_section
->vma
);
1692 h
->esym
.asym
.value
= 0;
1700 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1701 h
->root
.root
.root
.string
,
1704 einfo
->failed
= TRUE
;
1711 /* A comparison routine used to sort .gptab entries. */
1714 gptab_compare (const void *p1
, const void *p2
)
1716 const Elf32_gptab
*a1
= p1
;
1717 const Elf32_gptab
*a2
= p2
;
1719 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1722 /* Functions to manage the got entry hash table. */
1724 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1727 static INLINE hashval_t
1728 mips_elf_hash_bfd_vma (bfd_vma addr
)
1731 return addr
+ (addr
>> 32);
1737 /* got_entries only match if they're identical, except for gotidx, so
1738 use all fields to compute the hash, and compare the appropriate
1742 mips_elf_got_entry_hash (const void *entry_
)
1744 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1746 return entry
->symndx
1747 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1749 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1750 : entry
->d
.h
->root
.root
.root
.hash
));
1754 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1756 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1757 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1759 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1760 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1761 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1762 : e1
->d
.h
== e2
->d
.h
);
1765 /* multi_got_entries are still a match in the case of global objects,
1766 even if the input bfd in which they're referenced differs, so the
1767 hash computation and compare functions are adjusted
1771 mips_elf_multi_got_entry_hash (const void *entry_
)
1773 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1775 return entry
->symndx
1777 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1778 : entry
->symndx
>= 0
1780 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1781 : entry
->d
.h
->root
.root
.root
.hash
);
1785 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1787 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1788 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1790 return e1
->symndx
== e2
->symndx
1791 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1792 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1793 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1794 : e1
->d
.h
== e2
->d
.h
);
1797 /* Returns the dynamic relocation section for DYNOBJ. */
1800 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1802 static const char dname
[] = ".rel.dyn";
1805 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1806 if (sreloc
== NULL
&& create_p
)
1808 sreloc
= bfd_make_section (dynobj
, dname
);
1810 || ! bfd_set_section_flags (dynobj
, sreloc
,
1815 | SEC_LINKER_CREATED
1817 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1818 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1824 /* Returns the GOT section for ABFD. */
1827 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1829 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1831 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1836 /* Returns the GOT information associated with the link indicated by
1837 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1840 static struct mips_got_info
*
1841 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1844 struct mips_got_info
*g
;
1846 sgot
= mips_elf_got_section (abfd
, TRUE
);
1847 BFD_ASSERT (sgot
!= NULL
);
1848 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1849 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1850 BFD_ASSERT (g
!= NULL
);
1853 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1858 /* Returns the GOT offset at which the indicated address can be found.
1859 If there is not yet a GOT entry for this value, create one. Returns
1860 -1 if no satisfactory GOT offset can be found. */
1863 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1867 struct mips_got_info
*g
;
1868 struct mips_got_entry
*entry
;
1870 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1872 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1874 return entry
->gotidx
;
1879 /* Returns the GOT index for the global symbol indicated by H. */
1882 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1886 struct mips_got_info
*g
, *gg
;
1887 long global_got_dynindx
= 0;
1889 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1890 if (g
->bfd2got
&& ibfd
)
1892 struct mips_got_entry e
, *p
;
1894 BFD_ASSERT (h
->dynindx
>= 0);
1896 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1901 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1903 p
= htab_find (g
->got_entries
, &e
);
1905 BFD_ASSERT (p
->gotidx
> 0);
1910 if (gg
->global_gotsym
!= NULL
)
1911 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1913 /* Once we determine the global GOT entry with the lowest dynamic
1914 symbol table index, we must put all dynamic symbols with greater
1915 indices into the GOT. That makes it easy to calculate the GOT
1917 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1918 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1919 * MIPS_ELF_GOT_SIZE (abfd
));
1920 BFD_ASSERT (index
< sgot
->size
);
1925 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1926 are supposed to be placed at small offsets in the GOT, i.e.,
1927 within 32KB of GP. Return the index into the GOT for this page,
1928 and store the offset from this entry to the desired address in
1929 OFFSETP, if it is non-NULL. */
1932 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1933 bfd_vma value
, bfd_vma
*offsetp
)
1936 struct mips_got_info
*g
;
1938 struct mips_got_entry
*entry
;
1940 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1942 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1944 & (~(bfd_vma
)0xffff));
1949 index
= entry
->gotidx
;
1952 *offsetp
= value
- entry
->d
.address
;
1957 /* Find a GOT entry whose higher-order 16 bits are the same as those
1958 for value. Return the index into the GOT for this entry. */
1961 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1962 bfd_vma value
, bfd_boolean external
)
1965 struct mips_got_info
*g
;
1966 struct mips_got_entry
*entry
;
1970 /* Although the ABI says that it is "the high-order 16 bits" that we
1971 want, it is really the %high value. The complete value is
1972 calculated with a `addiu' of a LO16 relocation, just as with a
1974 value
= mips_elf_high (value
) << 16;
1977 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1979 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1981 return entry
->gotidx
;
1986 /* Returns the offset for the entry at the INDEXth position
1990 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1991 bfd
*input_bfd
, bfd_vma index
)
1995 struct mips_got_info
*g
;
1997 g
= mips_elf_got_info (dynobj
, &sgot
);
1998 gp
= _bfd_get_gp_value (output_bfd
)
1999 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2001 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2004 /* Create a local GOT entry for VALUE. Return the index of the entry,
2005 or -1 if it could not be created. */
2007 static struct mips_got_entry
*
2008 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2009 struct mips_got_info
*gg
,
2010 asection
*sgot
, bfd_vma value
)
2012 struct mips_got_entry entry
, **loc
;
2013 struct mips_got_info
*g
;
2017 entry
.d
.address
= value
;
2019 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2022 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2023 BFD_ASSERT (g
!= NULL
);
2026 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2031 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2033 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2038 memcpy (*loc
, &entry
, sizeof entry
);
2040 if (g
->assigned_gotno
>= g
->local_gotno
)
2042 (*loc
)->gotidx
= -1;
2043 /* We didn't allocate enough space in the GOT. */
2044 (*_bfd_error_handler
)
2045 (_("not enough GOT space for local GOT entries"));
2046 bfd_set_error (bfd_error_bad_value
);
2050 MIPS_ELF_PUT_WORD (abfd
, value
,
2051 (sgot
->contents
+ entry
.gotidx
));
2056 /* Sort the dynamic symbol table so that symbols that need GOT entries
2057 appear towards the end. This reduces the amount of GOT space
2058 required. MAX_LOCAL is used to set the number of local symbols
2059 known to be in the dynamic symbol table. During
2060 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2061 section symbols are added and the count is higher. */
2064 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2066 struct mips_elf_hash_sort_data hsd
;
2067 struct mips_got_info
*g
;
2070 dynobj
= elf_hash_table (info
)->dynobj
;
2072 g
= mips_elf_got_info (dynobj
, NULL
);
2075 hsd
.max_unref_got_dynindx
=
2076 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2077 /* In the multi-got case, assigned_gotno of the master got_info
2078 indicate the number of entries that aren't referenced in the
2079 primary GOT, but that must have entries because there are
2080 dynamic relocations that reference it. Since they aren't
2081 referenced, we move them to the end of the GOT, so that they
2082 don't prevent other entries that are referenced from getting
2083 too large offsets. */
2084 - (g
->next
? g
->assigned_gotno
: 0);
2085 hsd
.max_non_got_dynindx
= max_local
;
2086 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2087 elf_hash_table (info
)),
2088 mips_elf_sort_hash_table_f
,
2091 /* There should have been enough room in the symbol table to
2092 accommodate both the GOT and non-GOT symbols. */
2093 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2094 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2095 <= elf_hash_table (info
)->dynsymcount
);
2097 /* Now we know which dynamic symbol has the lowest dynamic symbol
2098 table index in the GOT. */
2099 g
->global_gotsym
= hsd
.low
;
2104 /* If H needs a GOT entry, assign it the highest available dynamic
2105 index. Otherwise, assign it the lowest available dynamic
2109 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2111 struct mips_elf_hash_sort_data
*hsd
= data
;
2113 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2114 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2116 /* Symbols without dynamic symbol table entries aren't interesting
2118 if (h
->root
.dynindx
== -1)
2121 /* Global symbols that need GOT entries that are not explicitly
2122 referenced are marked with got offset 2. Those that are
2123 referenced get a 1, and those that don't need GOT entries get
2125 if (h
->root
.got
.offset
== 2)
2127 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2128 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2129 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2131 else if (h
->root
.got
.offset
!= 1)
2132 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2135 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2136 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2142 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2143 symbol table index lower than any we've seen to date, record it for
2147 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2148 bfd
*abfd
, struct bfd_link_info
*info
,
2149 struct mips_got_info
*g
)
2151 struct mips_got_entry entry
, **loc
;
2153 /* A global symbol in the GOT must also be in the dynamic symbol
2155 if (h
->dynindx
== -1)
2157 switch (ELF_ST_VISIBILITY (h
->other
))
2161 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2164 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2170 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2172 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2175 /* If we've already marked this entry as needing GOT space, we don't
2176 need to do it again. */
2180 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2186 memcpy (*loc
, &entry
, sizeof entry
);
2188 if (h
->got
.offset
!= MINUS_ONE
)
2191 /* By setting this to a value other than -1, we are indicating that
2192 there needs to be a GOT entry for H. Avoid using zero, as the
2193 generic ELF copy_indirect_symbol tests for <= 0. */
2199 /* Reserve space in G for a GOT entry containing the value of symbol
2200 SYMNDX in input bfd ABDF, plus ADDEND. */
2203 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2204 struct mips_got_info
*g
)
2206 struct mips_got_entry entry
, **loc
;
2209 entry
.symndx
= symndx
;
2210 entry
.d
.addend
= addend
;
2211 loc
= (struct mips_got_entry
**)
2212 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2217 entry
.gotidx
= g
->local_gotno
++;
2219 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2224 memcpy (*loc
, &entry
, sizeof entry
);
2229 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2232 mips_elf_bfd2got_entry_hash (const void *entry_
)
2234 const struct mips_elf_bfd2got_hash
*entry
2235 = (struct mips_elf_bfd2got_hash
*)entry_
;
2237 return entry
->bfd
->id
;
2240 /* Check whether two hash entries have the same bfd. */
2243 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2245 const struct mips_elf_bfd2got_hash
*e1
2246 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2247 const struct mips_elf_bfd2got_hash
*e2
2248 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2250 return e1
->bfd
== e2
->bfd
;
2253 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2254 be the master GOT data. */
2256 static struct mips_got_info
*
2257 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2259 struct mips_elf_bfd2got_hash e
, *p
;
2265 p
= htab_find (g
->bfd2got
, &e
);
2266 return p
? p
->g
: NULL
;
2269 /* Create one separate got for each bfd that has entries in the global
2270 got, such that we can tell how many local and global entries each
2274 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2276 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2277 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2278 htab_t bfd2got
= arg
->bfd2got
;
2279 struct mips_got_info
*g
;
2280 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2283 /* Find the got_info for this GOT entry's input bfd. Create one if
2285 bfdgot_entry
.bfd
= entry
->abfd
;
2286 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2287 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2293 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2294 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2304 bfdgot
->bfd
= entry
->abfd
;
2305 bfdgot
->g
= g
= (struct mips_got_info
*)
2306 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2313 g
->global_gotsym
= NULL
;
2314 g
->global_gotno
= 0;
2316 g
->assigned_gotno
= -1;
2317 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2318 mips_elf_multi_got_entry_eq
, NULL
);
2319 if (g
->got_entries
== NULL
)
2329 /* Insert the GOT entry in the bfd's got entry hash table. */
2330 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2331 if (*entryp
!= NULL
)
2336 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2344 /* Attempt to merge gots of different input bfds. Try to use as much
2345 as possible of the primary got, since it doesn't require explicit
2346 dynamic relocations, but don't use bfds that would reference global
2347 symbols out of the addressable range. Failing the primary got,
2348 attempt to merge with the current got, or finish the current got
2349 and then make make the new got current. */
2352 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2354 struct mips_elf_bfd2got_hash
*bfd2got
2355 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2356 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2357 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2358 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2359 unsigned int maxcnt
= arg
->max_count
;
2361 /* If we don't have a primary GOT and this is not too big, use it as
2362 a starting point for the primary GOT. */
2363 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2365 arg
->primary
= bfd2got
->g
;
2366 arg
->primary_count
= lcount
+ gcount
;
2368 /* If it looks like we can merge this bfd's entries with those of
2369 the primary, merge them. The heuristics is conservative, but we
2370 don't have to squeeze it too hard. */
2371 else if (arg
->primary
2372 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2374 struct mips_got_info
*g
= bfd2got
->g
;
2375 int old_lcount
= arg
->primary
->local_gotno
;
2376 int old_gcount
= arg
->primary
->global_gotno
;
2378 bfd2got
->g
= arg
->primary
;
2380 htab_traverse (g
->got_entries
,
2381 mips_elf_make_got_per_bfd
,
2383 if (arg
->obfd
== NULL
)
2386 htab_delete (g
->got_entries
);
2387 /* We don't have to worry about releasing memory of the actual
2388 got entries, since they're all in the master got_entries hash
2391 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2392 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2394 arg
->primary_count
= arg
->primary
->local_gotno
2395 + arg
->primary
->global_gotno
;
2397 /* If we can merge with the last-created got, do it. */
2398 else if (arg
->current
2399 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2401 struct mips_got_info
*g
= bfd2got
->g
;
2402 int old_lcount
= arg
->current
->local_gotno
;
2403 int old_gcount
= arg
->current
->global_gotno
;
2405 bfd2got
->g
= arg
->current
;
2407 htab_traverse (g
->got_entries
,
2408 mips_elf_make_got_per_bfd
,
2410 if (arg
->obfd
== NULL
)
2413 htab_delete (g
->got_entries
);
2415 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2416 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2418 arg
->current_count
= arg
->current
->local_gotno
2419 + arg
->current
->global_gotno
;
2421 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2422 fits; if it turns out that it doesn't, we'll get relocation
2423 overflows anyway. */
2426 bfd2got
->g
->next
= arg
->current
;
2427 arg
->current
= bfd2got
->g
;
2429 arg
->current_count
= lcount
+ gcount
;
2435 /* If passed a NULL mips_got_info in the argument, set the marker used
2436 to tell whether a global symbol needs a got entry (in the primary
2437 got) to the given VALUE.
2439 If passed a pointer G to a mips_got_info in the argument (it must
2440 not be the primary GOT), compute the offset from the beginning of
2441 the (primary) GOT section to the entry in G corresponding to the
2442 global symbol. G's assigned_gotno must contain the index of the
2443 first available global GOT entry in G. VALUE must contain the size
2444 of a GOT entry in bytes. For each global GOT entry that requires a
2445 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2446 marked as not eligible for lazy resolution through a function
2449 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2451 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2452 struct mips_elf_set_global_got_offset_arg
*arg
2453 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2454 struct mips_got_info
*g
= arg
->g
;
2456 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2457 && entry
->d
.h
->root
.dynindx
!= -1)
2461 BFD_ASSERT (g
->global_gotsym
== NULL
);
2463 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2464 if (arg
->info
->shared
2465 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2466 && entry
->d
.h
->root
.def_dynamic
2467 && !entry
->d
.h
->root
.def_regular
))
2468 ++arg
->needed_relocs
;
2471 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2477 /* Mark any global symbols referenced in the GOT we are iterating over
2478 as inelligible for lazy resolution stubs. */
2480 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2482 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2484 if (entry
->abfd
!= NULL
2485 && entry
->symndx
== -1
2486 && entry
->d
.h
->root
.dynindx
!= -1)
2487 entry
->d
.h
->no_fn_stub
= TRUE
;
2492 /* Follow indirect and warning hash entries so that each got entry
2493 points to the final symbol definition. P must point to a pointer
2494 to the hash table we're traversing. Since this traversal may
2495 modify the hash table, we set this pointer to NULL to indicate
2496 we've made a potentially-destructive change to the hash table, so
2497 the traversal must be restarted. */
2499 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2501 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2502 htab_t got_entries
= *(htab_t
*)p
;
2504 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2506 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2508 while (h
->root
.root
.type
== bfd_link_hash_indirect
2509 || h
->root
.root
.type
== bfd_link_hash_warning
)
2510 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2512 if (entry
->d
.h
== h
)
2517 /* If we can't find this entry with the new bfd hash, re-insert
2518 it, and get the traversal restarted. */
2519 if (! htab_find (got_entries
, entry
))
2521 htab_clear_slot (got_entries
, entryp
);
2522 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2525 /* Abort the traversal, since the whole table may have
2526 moved, and leave it up to the parent to restart the
2528 *(htab_t
*)p
= NULL
;
2531 /* We might want to decrement the global_gotno count, but it's
2532 either too early or too late for that at this point. */
2538 /* Turn indirect got entries in a got_entries table into their final
2541 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2547 got_entries
= g
->got_entries
;
2549 htab_traverse (got_entries
,
2550 mips_elf_resolve_final_got_entry
,
2553 while (got_entries
== NULL
);
2556 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2559 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2561 if (g
->bfd2got
== NULL
)
2564 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2568 BFD_ASSERT (g
->next
);
2572 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2575 /* Turn a single GOT that is too big for 16-bit addressing into
2576 a sequence of GOTs, each one 16-bit addressable. */
2579 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2580 struct mips_got_info
*g
, asection
*got
,
2581 bfd_size_type pages
)
2583 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2584 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2585 struct mips_got_info
*gg
;
2586 unsigned int assign
;
2588 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2589 mips_elf_bfd2got_entry_eq
, NULL
);
2590 if (g
->bfd2got
== NULL
)
2593 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2594 got_per_bfd_arg
.obfd
= abfd
;
2595 got_per_bfd_arg
.info
= info
;
2597 /* Count how many GOT entries each input bfd requires, creating a
2598 map from bfd to got info while at that. */
2599 mips_elf_resolve_final_got_entries (g
);
2600 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2601 if (got_per_bfd_arg
.obfd
== NULL
)
2604 got_per_bfd_arg
.current
= NULL
;
2605 got_per_bfd_arg
.primary
= NULL
;
2606 /* Taking out PAGES entries is a worst-case estimate. We could
2607 compute the maximum number of pages that each separate input bfd
2608 uses, but it's probably not worth it. */
2609 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2610 / MIPS_ELF_GOT_SIZE (abfd
))
2611 - MIPS_RESERVED_GOTNO
- pages
);
2613 /* Try to merge the GOTs of input bfds together, as long as they
2614 don't seem to exceed the maximum GOT size, choosing one of them
2615 to be the primary GOT. */
2616 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2617 if (got_per_bfd_arg
.obfd
== NULL
)
2620 /* If we find any suitable primary GOT, create an empty one. */
2621 if (got_per_bfd_arg
.primary
== NULL
)
2623 g
->next
= (struct mips_got_info
*)
2624 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2625 if (g
->next
== NULL
)
2628 g
->next
->global_gotsym
= NULL
;
2629 g
->next
->global_gotno
= 0;
2630 g
->next
->local_gotno
= 0;
2631 g
->next
->assigned_gotno
= 0;
2632 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2633 mips_elf_multi_got_entry_eq
,
2635 if (g
->next
->got_entries
== NULL
)
2637 g
->next
->bfd2got
= NULL
;
2640 g
->next
= got_per_bfd_arg
.primary
;
2641 g
->next
->next
= got_per_bfd_arg
.current
;
2643 /* GG is now the master GOT, and G is the primary GOT. */
2647 /* Map the output bfd to the primary got. That's what we're going
2648 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2649 didn't mark in check_relocs, and we want a quick way to find it.
2650 We can't just use gg->next because we're going to reverse the
2653 struct mips_elf_bfd2got_hash
*bfdgot
;
2656 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2657 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2664 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2666 BFD_ASSERT (*bfdgotp
== NULL
);
2670 /* The IRIX dynamic linker requires every symbol that is referenced
2671 in a dynamic relocation to be present in the primary GOT, so
2672 arrange for them to appear after those that are actually
2675 GNU/Linux could very well do without it, but it would slow down
2676 the dynamic linker, since it would have to resolve every dynamic
2677 symbol referenced in other GOTs more than once, without help from
2678 the cache. Also, knowing that every external symbol has a GOT
2679 helps speed up the resolution of local symbols too, so GNU/Linux
2680 follows IRIX's practice.
2682 The number 2 is used by mips_elf_sort_hash_table_f to count
2683 global GOT symbols that are unreferenced in the primary GOT, with
2684 an initial dynamic index computed from gg->assigned_gotno, where
2685 the number of unreferenced global entries in the primary GOT is
2689 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2690 g
->global_gotno
= gg
->global_gotno
;
2691 set_got_offset_arg
.value
= 2;
2695 /* This could be used for dynamic linkers that don't optimize
2696 symbol resolution while applying relocations so as to use
2697 primary GOT entries or assuming the symbol is locally-defined.
2698 With this code, we assign lower dynamic indices to global
2699 symbols that are not referenced in the primary GOT, so that
2700 their entries can be omitted. */
2701 gg
->assigned_gotno
= 0;
2702 set_got_offset_arg
.value
= -1;
2705 /* Reorder dynamic symbols as described above (which behavior
2706 depends on the setting of VALUE). */
2707 set_got_offset_arg
.g
= NULL
;
2708 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2709 &set_got_offset_arg
);
2710 set_got_offset_arg
.value
= 1;
2711 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2712 &set_got_offset_arg
);
2713 if (! mips_elf_sort_hash_table (info
, 1))
2716 /* Now go through the GOTs assigning them offset ranges.
2717 [assigned_gotno, local_gotno[ will be set to the range of local
2718 entries in each GOT. We can then compute the end of a GOT by
2719 adding local_gotno to global_gotno. We reverse the list and make
2720 it circular since then we'll be able to quickly compute the
2721 beginning of a GOT, by computing the end of its predecessor. To
2722 avoid special cases for the primary GOT, while still preserving
2723 assertions that are valid for both single- and multi-got links,
2724 we arrange for the main got struct to have the right number of
2725 global entries, but set its local_gotno such that the initial
2726 offset of the primary GOT is zero. Remember that the primary GOT
2727 will become the last item in the circular linked list, so it
2728 points back to the master GOT. */
2729 gg
->local_gotno
= -g
->global_gotno
;
2730 gg
->global_gotno
= g
->global_gotno
;
2736 struct mips_got_info
*gn
;
2738 assign
+= MIPS_RESERVED_GOTNO
;
2739 g
->assigned_gotno
= assign
;
2740 g
->local_gotno
+= assign
+ pages
;
2741 assign
= g
->local_gotno
+ g
->global_gotno
;
2743 /* Take g out of the direct list, and push it onto the reversed
2744 list that gg points to. */
2750 /* Mark global symbols in every non-primary GOT as ineligible for
2753 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2757 got
->size
= (gg
->next
->local_gotno
2758 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2764 /* Returns the first relocation of type r_type found, beginning with
2765 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2767 static const Elf_Internal_Rela
*
2768 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2769 const Elf_Internal_Rela
*relocation
,
2770 const Elf_Internal_Rela
*relend
)
2772 while (relocation
< relend
)
2774 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2780 /* We didn't find it. */
2781 bfd_set_error (bfd_error_bad_value
);
2785 /* Return whether a relocation is against a local symbol. */
2788 mips_elf_local_relocation_p (bfd
*input_bfd
,
2789 const Elf_Internal_Rela
*relocation
,
2790 asection
**local_sections
,
2791 bfd_boolean check_forced
)
2793 unsigned long r_symndx
;
2794 Elf_Internal_Shdr
*symtab_hdr
;
2795 struct mips_elf_link_hash_entry
*h
;
2798 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2799 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2800 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2802 if (r_symndx
< extsymoff
)
2804 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2809 /* Look up the hash table to check whether the symbol
2810 was forced local. */
2811 h
= (struct mips_elf_link_hash_entry
*)
2812 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2813 /* Find the real hash-table entry for this symbol. */
2814 while (h
->root
.root
.type
== bfd_link_hash_indirect
2815 || h
->root
.root
.type
== bfd_link_hash_warning
)
2816 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2817 if (h
->root
.forced_local
)
2824 /* Sign-extend VALUE, which has the indicated number of BITS. */
2827 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2829 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2830 /* VALUE is negative. */
2831 value
|= ((bfd_vma
) - 1) << bits
;
2836 /* Return non-zero if the indicated VALUE has overflowed the maximum
2837 range expressible by a signed number with the indicated number of
2841 mips_elf_overflow_p (bfd_vma value
, int bits
)
2843 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2845 if (svalue
> (1 << (bits
- 1)) - 1)
2846 /* The value is too big. */
2848 else if (svalue
< -(1 << (bits
- 1)))
2849 /* The value is too small. */
2856 /* Calculate the %high function. */
2859 mips_elf_high (bfd_vma value
)
2861 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2864 /* Calculate the %higher function. */
2867 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2870 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2877 /* Calculate the %highest function. */
2880 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2883 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2890 /* Create the .compact_rel section. */
2893 mips_elf_create_compact_rel_section
2894 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2897 register asection
*s
;
2899 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2901 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2904 s
= bfd_make_section (abfd
, ".compact_rel");
2906 || ! bfd_set_section_flags (abfd
, s
, flags
)
2907 || ! bfd_set_section_alignment (abfd
, s
,
2908 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2911 s
->size
= sizeof (Elf32_External_compact_rel
);
2917 /* Create the .got section to hold the global offset table. */
2920 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2921 bfd_boolean maybe_exclude
)
2924 register asection
*s
;
2925 struct elf_link_hash_entry
*h
;
2926 struct bfd_link_hash_entry
*bh
;
2927 struct mips_got_info
*g
;
2930 /* This function may be called more than once. */
2931 s
= mips_elf_got_section (abfd
, TRUE
);
2934 if (! maybe_exclude
)
2935 s
->flags
&= ~SEC_EXCLUDE
;
2939 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2940 | SEC_LINKER_CREATED
);
2943 flags
|= SEC_EXCLUDE
;
2945 /* We have to use an alignment of 2**4 here because this is hardcoded
2946 in the function stub generation and in the linker script. */
2947 s
= bfd_make_section (abfd
, ".got");
2949 || ! bfd_set_section_flags (abfd
, s
, flags
)
2950 || ! bfd_set_section_alignment (abfd
, s
, 4))
2953 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2954 linker script because we don't want to define the symbol if we
2955 are not creating a global offset table. */
2957 if (! (_bfd_generic_link_add_one_symbol
2958 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2959 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2962 h
= (struct elf_link_hash_entry
*) bh
;
2965 h
->type
= STT_OBJECT
;
2968 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2971 amt
= sizeof (struct mips_got_info
);
2972 g
= bfd_alloc (abfd
, amt
);
2975 g
->global_gotsym
= NULL
;
2976 g
->global_gotno
= 0;
2977 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2978 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2981 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2982 mips_elf_got_entry_eq
, NULL
);
2983 if (g
->got_entries
== NULL
)
2985 mips_elf_section_data (s
)->u
.got_info
= g
;
2986 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2987 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2992 /* Calculate the value produced by the RELOCATION (which comes from
2993 the INPUT_BFD). The ADDEND is the addend to use for this
2994 RELOCATION; RELOCATION->R_ADDEND is ignored.
2996 The result of the relocation calculation is stored in VALUEP.
2997 REQUIRE_JALXP indicates whether or not the opcode used with this
2998 relocation must be JALX.
3000 This function returns bfd_reloc_continue if the caller need take no
3001 further action regarding this relocation, bfd_reloc_notsupported if
3002 something goes dramatically wrong, bfd_reloc_overflow if an
3003 overflow occurs, and bfd_reloc_ok to indicate success. */
3005 static bfd_reloc_status_type
3006 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3007 asection
*input_section
,
3008 struct bfd_link_info
*info
,
3009 const Elf_Internal_Rela
*relocation
,
3010 bfd_vma addend
, reloc_howto_type
*howto
,
3011 Elf_Internal_Sym
*local_syms
,
3012 asection
**local_sections
, bfd_vma
*valuep
,
3013 const char **namep
, bfd_boolean
*require_jalxp
,
3014 bfd_boolean save_addend
)
3016 /* The eventual value we will return. */
3018 /* The address of the symbol against which the relocation is
3021 /* The final GP value to be used for the relocatable, executable, or
3022 shared object file being produced. */
3023 bfd_vma gp
= MINUS_ONE
;
3024 /* The place (section offset or address) of the storage unit being
3027 /* The value of GP used to create the relocatable object. */
3028 bfd_vma gp0
= MINUS_ONE
;
3029 /* The offset into the global offset table at which the address of
3030 the relocation entry symbol, adjusted by the addend, resides
3031 during execution. */
3032 bfd_vma g
= MINUS_ONE
;
3033 /* The section in which the symbol referenced by the relocation is
3035 asection
*sec
= NULL
;
3036 struct mips_elf_link_hash_entry
*h
= NULL
;
3037 /* TRUE if the symbol referred to by this relocation is a local
3039 bfd_boolean local_p
, was_local_p
;
3040 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3041 bfd_boolean gp_disp_p
= FALSE
;
3042 Elf_Internal_Shdr
*symtab_hdr
;
3044 unsigned long r_symndx
;
3046 /* TRUE if overflow occurred during the calculation of the
3047 relocation value. */
3048 bfd_boolean overflowed_p
;
3049 /* TRUE if this relocation refers to a MIPS16 function. */
3050 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3052 /* Parse the relocation. */
3053 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3054 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3055 p
= (input_section
->output_section
->vma
3056 + input_section
->output_offset
3057 + relocation
->r_offset
);
3059 /* Assume that there will be no overflow. */
3060 overflowed_p
= FALSE
;
3062 /* Figure out whether or not the symbol is local, and get the offset
3063 used in the array of hash table entries. */
3064 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3065 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3066 local_sections
, FALSE
);
3067 was_local_p
= local_p
;
3068 if (! elf_bad_symtab (input_bfd
))
3069 extsymoff
= symtab_hdr
->sh_info
;
3072 /* The symbol table does not follow the rule that local symbols
3073 must come before globals. */
3077 /* Figure out the value of the symbol. */
3080 Elf_Internal_Sym
*sym
;
3082 sym
= local_syms
+ r_symndx
;
3083 sec
= local_sections
[r_symndx
];
3085 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3086 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3087 || (sec
->flags
& SEC_MERGE
))
3088 symbol
+= sym
->st_value
;
3089 if ((sec
->flags
& SEC_MERGE
)
3090 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3092 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3094 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3097 /* MIPS16 text labels should be treated as odd. */
3098 if (sym
->st_other
== STO_MIPS16
)
3101 /* Record the name of this symbol, for our caller. */
3102 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3103 symtab_hdr
->sh_link
,
3106 *namep
= bfd_section_name (input_bfd
, sec
);
3108 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3112 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3114 /* For global symbols we look up the symbol in the hash-table. */
3115 h
= ((struct mips_elf_link_hash_entry
*)
3116 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3117 /* Find the real hash-table entry for this symbol. */
3118 while (h
->root
.root
.type
== bfd_link_hash_indirect
3119 || h
->root
.root
.type
== bfd_link_hash_warning
)
3120 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3122 /* Record the name of this symbol, for our caller. */
3123 *namep
= h
->root
.root
.root
.string
;
3125 /* See if this is the special _gp_disp symbol. Note that such a
3126 symbol must always be a global symbol. */
3127 if (strcmp (*namep
, "_gp_disp") == 0
3128 && ! NEWABI_P (input_bfd
))
3130 /* Relocations against _gp_disp are permitted only with
3131 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3132 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3133 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3134 return bfd_reloc_notsupported
;
3138 /* If this symbol is defined, calculate its address. Note that
3139 _gp_disp is a magic symbol, always implicitly defined by the
3140 linker, so it's inappropriate to check to see whether or not
3142 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3143 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3144 && h
->root
.root
.u
.def
.section
)
3146 sec
= h
->root
.root
.u
.def
.section
;
3147 if (sec
->output_section
)
3148 symbol
= (h
->root
.root
.u
.def
.value
3149 + sec
->output_section
->vma
3150 + sec
->output_offset
);
3152 symbol
= h
->root
.root
.u
.def
.value
;
3154 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3155 /* We allow relocations against undefined weak symbols, giving
3156 it the value zero, so that you can undefined weak functions
3157 and check to see if they exist by looking at their
3160 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3161 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3163 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
3164 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3166 /* If this is a dynamic link, we should have created a
3167 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3168 in in _bfd_mips_elf_create_dynamic_sections.
3169 Otherwise, we should define the symbol with a value of 0.
3170 FIXME: It should probably get into the symbol table
3172 BFD_ASSERT (! info
->shared
);
3173 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3178 if (! ((*info
->callbacks
->undefined_symbol
)
3179 (info
, h
->root
.root
.root
.string
, input_bfd
,
3180 input_section
, relocation
->r_offset
,
3181 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3182 || ELF_ST_VISIBILITY (h
->root
.other
))))
3183 return bfd_reloc_undefined
;
3187 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3190 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3191 need to redirect the call to the stub, unless we're already *in*
3193 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3194 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3195 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3196 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3197 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3199 /* This is a 32- or 64-bit call to a 16-bit function. We should
3200 have already noticed that we were going to need the
3203 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3206 BFD_ASSERT (h
->need_fn_stub
);
3210 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3212 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3213 need to redirect the call to the stub. */
3214 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3216 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3217 && !target_is_16_bit_code_p
)
3219 /* If both call_stub and call_fp_stub are defined, we can figure
3220 out which one to use by seeing which one appears in the input
3222 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3227 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3229 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3230 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3232 sec
= h
->call_fp_stub
;
3239 else if (h
->call_stub
!= NULL
)
3242 sec
= h
->call_fp_stub
;
3244 BFD_ASSERT (sec
->size
> 0);
3245 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3248 /* Calls from 16-bit code to 32-bit code and vice versa require the
3249 special jalx instruction. */
3250 *require_jalxp
= (!info
->relocatable
3251 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3252 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3254 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3255 local_sections
, TRUE
);
3257 /* If we haven't already determined the GOT offset, or the GP value,
3258 and we're going to need it, get it now. */
3261 case R_MIPS_GOT_PAGE
:
3262 case R_MIPS_GOT_OFST
:
3263 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3265 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3266 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3272 case R_MIPS_GOT_DISP
:
3273 case R_MIPS_GOT_HI16
:
3274 case R_MIPS_CALL_HI16
:
3275 case R_MIPS_GOT_LO16
:
3276 case R_MIPS_CALL_LO16
:
3277 /* Find the index into the GOT where this value is located. */
3280 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3281 GOT_PAGE relocation that decays to GOT_DISP because the
3282 symbol turns out to be global. The addend is then added
3284 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3285 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3287 (struct elf_link_hash_entry
*) h
);
3288 if (! elf_hash_table(info
)->dynamic_sections_created
3290 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3291 && h
->root
.def_regular
))
3293 /* This is a static link or a -Bsymbolic link. The
3294 symbol is defined locally, or was forced to be local.
3295 We must initialize this entry in the GOT. */
3296 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3297 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3298 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3301 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3302 /* There's no need to create a local GOT entry here; the
3303 calculation for a local GOT16 entry does not involve G. */
3307 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3308 info
, symbol
+ addend
);
3310 return bfd_reloc_outofrange
;
3313 /* Convert GOT indices to actual offsets. */
3314 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3315 abfd
, input_bfd
, g
);
3320 case R_MIPS_GPREL16
:
3321 case R_MIPS_GPREL32
:
3322 case R_MIPS_LITERAL
:
3325 case R_MIPS16_GPREL
:
3326 gp0
= _bfd_get_gp_value (input_bfd
);
3327 gp
= _bfd_get_gp_value (abfd
);
3328 if (elf_hash_table (info
)->dynobj
)
3329 gp
+= mips_elf_adjust_gp (abfd
,
3331 (elf_hash_table (info
)->dynobj
, NULL
),
3339 /* Figure out what kind of relocation is being performed. */
3343 return bfd_reloc_continue
;
3346 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3347 overflowed_p
= mips_elf_overflow_p (value
, 16);
3354 || (elf_hash_table (info
)->dynamic_sections_created
3356 && h
->root
.def_dynamic
3357 && !h
->root
.def_regular
))
3359 && (input_section
->flags
& SEC_ALLOC
) != 0)
3361 /* If we're creating a shared library, or this relocation is
3362 against a symbol in a shared library, then we can't know
3363 where the symbol will end up. So, we create a relocation
3364 record in the output, and leave the job up to the dynamic
3367 if (!mips_elf_create_dynamic_relocation (abfd
,
3375 return bfd_reloc_undefined
;
3379 if (r_type
!= R_MIPS_REL32
)
3380 value
= symbol
+ addend
;
3384 value
&= howto
->dst_mask
;
3388 value
= symbol
+ addend
- p
;
3389 value
&= howto
->dst_mask
;
3392 case R_MIPS_GNU_REL16_S2
:
3393 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3394 overflowed_p
= mips_elf_overflow_p (value
, 18);
3395 value
= (value
>> 2) & howto
->dst_mask
;
3399 /* The calculation for R_MIPS16_26 is just the same as for an
3400 R_MIPS_26. It's only the storage of the relocated field into
3401 the output file that's different. That's handled in
3402 mips_elf_perform_relocation. So, we just fall through to the
3403 R_MIPS_26 case here. */
3406 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3409 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3410 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
3411 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
3413 value
&= howto
->dst_mask
;
3420 value
= mips_elf_high (addend
+ symbol
);
3421 value
&= howto
->dst_mask
;
3425 /* For MIPS16 ABI code we generate this sequence
3426 0: li $v0,%hi(_gp_disp)
3427 4: addiupc $v1,%lo(_gp_disp)
3431 So the offsets of hi and lo relocs are the same, but the
3432 $pc is four higher than $t9 would be, so reduce
3433 both reloc addends by 4. */
3434 if (r_type
== R_MIPS16_HI16
)
3435 value
= mips_elf_high (addend
+ gp
- p
- 4);
3437 value
= mips_elf_high (addend
+ gp
- p
);
3438 overflowed_p
= mips_elf_overflow_p (value
, 16);
3445 value
= (symbol
+ addend
) & howto
->dst_mask
;
3448 /* See the comment for R_MIPS16_HI16 above for the reason
3449 for this conditional. */
3450 if (r_type
== R_MIPS16_LO16
)
3451 value
= addend
+ gp
- p
;
3453 value
= addend
+ gp
- p
+ 4;
3454 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3455 for overflow. But, on, say, IRIX5, relocations against
3456 _gp_disp are normally generated from the .cpload
3457 pseudo-op. It generates code that normally looks like
3460 lui $gp,%hi(_gp_disp)
3461 addiu $gp,$gp,%lo(_gp_disp)
3464 Here $t9 holds the address of the function being called,
3465 as required by the MIPS ELF ABI. The R_MIPS_LO16
3466 relocation can easily overflow in this situation, but the
3467 R_MIPS_HI16 relocation will handle the overflow.
3468 Therefore, we consider this a bug in the MIPS ABI, and do
3469 not check for overflow here. */
3473 case R_MIPS_LITERAL
:
3474 /* Because we don't merge literal sections, we can handle this
3475 just like R_MIPS_GPREL16. In the long run, we should merge
3476 shared literals, and then we will need to additional work
3481 case R_MIPS16_GPREL
:
3482 /* The R_MIPS16_GPREL performs the same calculation as
3483 R_MIPS_GPREL16, but stores the relocated bits in a different
3484 order. We don't need to do anything special here; the
3485 differences are handled in mips_elf_perform_relocation. */
3486 case R_MIPS_GPREL16
:
3487 /* Only sign-extend the addend if it was extracted from the
3488 instruction. If the addend was separate, leave it alone,
3489 otherwise we may lose significant bits. */
3490 if (howto
->partial_inplace
)
3491 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3492 value
= symbol
+ addend
- gp
;
3493 /* If the symbol was local, any earlier relocatable links will
3494 have adjusted its addend with the gp offset, so compensate
3495 for that now. Don't do it for symbols forced local in this
3496 link, though, since they won't have had the gp offset applied
3500 overflowed_p
= mips_elf_overflow_p (value
, 16);
3509 /* The special case is when the symbol is forced to be local. We
3510 need the full address in the GOT since no R_MIPS_LO16 relocation
3512 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3513 local_sections
, FALSE
);
3514 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3515 symbol
+ addend
, forced
);
3516 if (value
== MINUS_ONE
)
3517 return bfd_reloc_outofrange
;
3519 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3520 abfd
, input_bfd
, value
);
3521 overflowed_p
= mips_elf_overflow_p (value
, 16);
3527 case R_MIPS_GOT_DISP
:
3530 overflowed_p
= mips_elf_overflow_p (value
, 16);
3533 case R_MIPS_GPREL32
:
3534 value
= (addend
+ symbol
+ gp0
- gp
);
3536 value
&= howto
->dst_mask
;
3540 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3541 overflowed_p
= mips_elf_overflow_p (value
, 16);
3544 case R_MIPS_GOT_HI16
:
3545 case R_MIPS_CALL_HI16
:
3546 /* We're allowed to handle these two relocations identically.
3547 The dynamic linker is allowed to handle the CALL relocations
3548 differently by creating a lazy evaluation stub. */
3550 value
= mips_elf_high (value
);
3551 value
&= howto
->dst_mask
;
3554 case R_MIPS_GOT_LO16
:
3555 case R_MIPS_CALL_LO16
:
3556 value
= g
& howto
->dst_mask
;
3559 case R_MIPS_GOT_PAGE
:
3560 /* GOT_PAGE relocations that reference non-local symbols decay
3561 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3565 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3566 if (value
== MINUS_ONE
)
3567 return bfd_reloc_outofrange
;
3568 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3569 abfd
, input_bfd
, value
);
3570 overflowed_p
= mips_elf_overflow_p (value
, 16);
3573 case R_MIPS_GOT_OFST
:
3575 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3578 overflowed_p
= mips_elf_overflow_p (value
, 16);
3582 value
= symbol
- addend
;
3583 value
&= howto
->dst_mask
;
3587 value
= mips_elf_higher (addend
+ symbol
);
3588 value
&= howto
->dst_mask
;
3591 case R_MIPS_HIGHEST
:
3592 value
= mips_elf_highest (addend
+ symbol
);
3593 value
&= howto
->dst_mask
;
3596 case R_MIPS_SCN_DISP
:
3597 value
= symbol
+ addend
- sec
->output_offset
;
3598 value
&= howto
->dst_mask
;
3602 /* This relocation is only a hint. In some cases, we optimize
3603 it into a bal instruction. But we don't try to optimize
3604 branches to the PLT; that will wind up wasting time. */
3605 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
3606 return bfd_reloc_continue
;
3607 value
= symbol
+ addend
;
3611 case R_MIPS_GNU_VTINHERIT
:
3612 case R_MIPS_GNU_VTENTRY
:
3613 /* We don't do anything with these at present. */
3614 return bfd_reloc_continue
;
3617 /* An unrecognized relocation type. */
3618 return bfd_reloc_notsupported
;
3621 /* Store the VALUE for our caller. */
3623 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3626 /* Obtain the field relocated by RELOCATION. */
3629 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3630 const Elf_Internal_Rela
*relocation
,
3631 bfd
*input_bfd
, bfd_byte
*contents
)
3634 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3636 /* Obtain the bytes. */
3637 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3642 /* It has been determined that the result of the RELOCATION is the
3643 VALUE. Use HOWTO to place VALUE into the output file at the
3644 appropriate position. The SECTION is the section to which the
3645 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3646 for the relocation must be either JAL or JALX, and it is
3647 unconditionally converted to JALX.
3649 Returns FALSE if anything goes wrong. */
3652 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3653 reloc_howto_type
*howto
,
3654 const Elf_Internal_Rela
*relocation
,
3655 bfd_vma value
, bfd
*input_bfd
,
3656 asection
*input_section
, bfd_byte
*contents
,
3657 bfd_boolean require_jalx
)
3661 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3663 /* Figure out where the relocation is occurring. */
3664 location
= contents
+ relocation
->r_offset
;
3666 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
3668 /* Obtain the current value. */
3669 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3671 /* Clear the field we are setting. */
3672 x
&= ~howto
->dst_mask
;
3674 /* Set the field. */
3675 x
|= (value
& howto
->dst_mask
);
3677 /* If required, turn JAL into JALX. */
3681 bfd_vma opcode
= x
>> 26;
3682 bfd_vma jalx_opcode
;
3684 /* Check to see if the opcode is already JAL or JALX. */
3685 if (r_type
== R_MIPS16_26
)
3687 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3692 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3696 /* If the opcode is not JAL or JALX, there's a problem. */
3699 (*_bfd_error_handler
)
3700 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
3703 (unsigned long) relocation
->r_offset
);
3704 bfd_set_error (bfd_error_bad_value
);
3708 /* Make this the JALX opcode. */
3709 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3712 /* On the RM9000, bal is faster than jal, because bal uses branch
3713 prediction hardware. If we are linking for the RM9000, and we
3714 see jal, and bal fits, use it instead. Note that this
3715 transformation should be safe for all architectures. */
3716 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
3717 && !info
->relocatable
3719 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
3720 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
3726 addr
= (input_section
->output_section
->vma
3727 + input_section
->output_offset
3728 + relocation
->r_offset
3730 if (r_type
== R_MIPS_26
)
3731 dest
= (value
<< 2) | ((addr
>> 28) << 28);
3735 if (off
<= 0x1ffff && off
>= -0x20000)
3736 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
3739 /* Put the value into the output. */
3740 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3742 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
3748 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3751 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3753 const char *name
= bfd_get_section_name (abfd
, section
);
3755 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3756 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3757 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3760 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3763 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3767 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3768 BFD_ASSERT (s
!= NULL
);
3772 /* Make room for a null element. */
3773 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
3776 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3779 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3780 is the original relocation, which is now being transformed into a
3781 dynamic relocation. The ADDENDP is adjusted if necessary; the
3782 caller should store the result in place of the original addend. */
3785 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3786 struct bfd_link_info
*info
,
3787 const Elf_Internal_Rela
*rel
,
3788 struct mips_elf_link_hash_entry
*h
,
3789 asection
*sec
, bfd_vma symbol
,
3790 bfd_vma
*addendp
, asection
*input_section
)
3792 Elf_Internal_Rela outrel
[3];
3797 bfd_boolean defined_p
;
3799 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3800 dynobj
= elf_hash_table (info
)->dynobj
;
3801 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3802 BFD_ASSERT (sreloc
!= NULL
);
3803 BFD_ASSERT (sreloc
->contents
!= NULL
);
3804 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3807 outrel
[0].r_offset
=
3808 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3809 outrel
[1].r_offset
=
3810 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3811 outrel
[2].r_offset
=
3812 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3815 /* We begin by assuming that the offset for the dynamic relocation
3816 is the same as for the original relocation. We'll adjust this
3817 later to reflect the correct output offsets. */
3818 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3820 outrel
[1].r_offset
= rel
[1].r_offset
;
3821 outrel
[2].r_offset
= rel
[2].r_offset
;
3825 /* Except that in a stab section things are more complex.
3826 Because we compress stab information, the offset given in the
3827 relocation may not be the one we want; we must let the stabs
3828 machinery tell us the offset. */
3829 outrel
[1].r_offset
= outrel
[0].r_offset
;
3830 outrel
[2].r_offset
= outrel
[0].r_offset
;
3831 /* If we didn't need the relocation at all, this value will be
3833 if (outrel
[0].r_offset
== MINUS_ONE
)
3838 if (outrel
[0].r_offset
== MINUS_ONE
)
3839 /* The relocation field has been deleted. */
3842 if (outrel
[0].r_offset
== MINUS_TWO
)
3844 /* The relocation field has been converted into a relative value of
3845 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3846 the field to be fully relocated, so add in the symbol's value. */
3851 /* We must now calculate the dynamic symbol table index to use
3852 in the relocation. */
3854 && (! info
->symbolic
|| !h
->root
.def_regular
)
3855 /* h->root.dynindx may be -1 if this symbol was marked to
3857 && h
->root
.dynindx
!= -1)
3859 indx
= h
->root
.dynindx
;
3860 if (SGI_COMPAT (output_bfd
))
3861 defined_p
= h
->root
.def_regular
;
3863 /* ??? glibc's ld.so just adds the final GOT entry to the
3864 relocation field. It therefore treats relocs against
3865 defined symbols in the same way as relocs against
3866 undefined symbols. */
3871 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3873 else if (sec
== NULL
|| sec
->owner
== NULL
)
3875 bfd_set_error (bfd_error_bad_value
);
3880 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3885 /* Instead of generating a relocation using the section
3886 symbol, we may as well make it a fully relative
3887 relocation. We want to avoid generating relocations to
3888 local symbols because we used to generate them
3889 incorrectly, without adding the original symbol value,
3890 which is mandated by the ABI for section symbols. In
3891 order to give dynamic loaders and applications time to
3892 phase out the incorrect use, we refrain from emitting
3893 section-relative relocations. It's not like they're
3894 useful, after all. This should be a bit more efficient
3896 /* ??? Although this behavior is compatible with glibc's ld.so,
3897 the ABI says that relocations against STN_UNDEF should have
3898 a symbol value of 0. Irix rld honors this, so relocations
3899 against STN_UNDEF have no effect. */
3900 if (!SGI_COMPAT (output_bfd
))
3905 /* If the relocation was previously an absolute relocation and
3906 this symbol will not be referred to by the relocation, we must
3907 adjust it by the value we give it in the dynamic symbol table.
3908 Otherwise leave the job up to the dynamic linker. */
3909 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3912 /* The relocation is always an REL32 relocation because we don't
3913 know where the shared library will wind up at load-time. */
3914 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3916 /* For strict adherence to the ABI specification, we should
3917 generate a R_MIPS_64 relocation record by itself before the
3918 _REL32/_64 record as well, such that the addend is read in as
3919 a 64-bit value (REL32 is a 32-bit relocation, after all).
3920 However, since none of the existing ELF64 MIPS dynamic
3921 loaders seems to care, we don't waste space with these
3922 artificial relocations. If this turns out to not be true,
3923 mips_elf_allocate_dynamic_relocation() should be tweaked so
3924 as to make room for a pair of dynamic relocations per
3925 invocation if ABI_64_P, and here we should generate an
3926 additional relocation record with R_MIPS_64 by itself for a
3927 NULL symbol before this relocation record. */
3928 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
3929 ABI_64_P (output_bfd
)
3932 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
3934 /* Adjust the output offset of the relocation to reference the
3935 correct location in the output file. */
3936 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3937 + input_section
->output_offset
);
3938 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3939 + input_section
->output_offset
);
3940 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3941 + input_section
->output_offset
);
3943 /* Put the relocation back out. We have to use the special
3944 relocation outputter in the 64-bit case since the 64-bit
3945 relocation format is non-standard. */
3946 if (ABI_64_P (output_bfd
))
3948 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3949 (output_bfd
, &outrel
[0],
3951 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3954 bfd_elf32_swap_reloc_out
3955 (output_bfd
, &outrel
[0],
3956 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3958 /* We've now added another relocation. */
3959 ++sreloc
->reloc_count
;
3961 /* Make sure the output section is writable. The dynamic linker
3962 will be writing to it. */
3963 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3966 /* On IRIX5, make an entry of compact relocation info. */
3967 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
3969 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3974 Elf32_crinfo cptrel
;
3976 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3977 cptrel
.vaddr
= (rel
->r_offset
3978 + input_section
->output_section
->vma
3979 + input_section
->output_offset
);
3980 if (r_type
== R_MIPS_REL32
)
3981 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3983 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3984 mips_elf_set_cr_dist2to (cptrel
, 0);
3985 cptrel
.konst
= *addendp
;
3987 cr
= (scpt
->contents
3988 + sizeof (Elf32_External_compact_rel
));
3989 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
3990 ((Elf32_External_crinfo
*) cr
3991 + scpt
->reloc_count
));
3992 ++scpt
->reloc_count
;
3999 /* Return the MACH for a MIPS e_flags value. */
4002 _bfd_elf_mips_mach (flagword flags
)
4004 switch (flags
& EF_MIPS_MACH
)
4006 case E_MIPS_MACH_3900
:
4007 return bfd_mach_mips3900
;
4009 case E_MIPS_MACH_4010
:
4010 return bfd_mach_mips4010
;
4012 case E_MIPS_MACH_4100
:
4013 return bfd_mach_mips4100
;
4015 case E_MIPS_MACH_4111
:
4016 return bfd_mach_mips4111
;
4018 case E_MIPS_MACH_4120
:
4019 return bfd_mach_mips4120
;
4021 case E_MIPS_MACH_4650
:
4022 return bfd_mach_mips4650
;
4024 case E_MIPS_MACH_5400
:
4025 return bfd_mach_mips5400
;
4027 case E_MIPS_MACH_5500
:
4028 return bfd_mach_mips5500
;
4030 case E_MIPS_MACH_9000
:
4031 return bfd_mach_mips9000
;
4033 case E_MIPS_MACH_SB1
:
4034 return bfd_mach_mips_sb1
;
4037 switch (flags
& EF_MIPS_ARCH
)
4041 return bfd_mach_mips3000
;
4045 return bfd_mach_mips6000
;
4049 return bfd_mach_mips4000
;
4053 return bfd_mach_mips8000
;
4057 return bfd_mach_mips5
;
4060 case E_MIPS_ARCH_32
:
4061 return bfd_mach_mipsisa32
;
4064 case E_MIPS_ARCH_64
:
4065 return bfd_mach_mipsisa64
;
4068 case E_MIPS_ARCH_32R2
:
4069 return bfd_mach_mipsisa32r2
;
4072 case E_MIPS_ARCH_64R2
:
4073 return bfd_mach_mipsisa64r2
;
4081 /* Return printable name for ABI. */
4083 static INLINE
char *
4084 elf_mips_abi_name (bfd
*abfd
)
4088 flags
= elf_elfheader (abfd
)->e_flags
;
4089 switch (flags
& EF_MIPS_ABI
)
4092 if (ABI_N32_P (abfd
))
4094 else if (ABI_64_P (abfd
))
4098 case E_MIPS_ABI_O32
:
4100 case E_MIPS_ABI_O64
:
4102 case E_MIPS_ABI_EABI32
:
4104 case E_MIPS_ABI_EABI64
:
4107 return "unknown abi";
4111 /* MIPS ELF uses two common sections. One is the usual one, and the
4112 other is for small objects. All the small objects are kept
4113 together, and then referenced via the gp pointer, which yields
4114 faster assembler code. This is what we use for the small common
4115 section. This approach is copied from ecoff.c. */
4116 static asection mips_elf_scom_section
;
4117 static asymbol mips_elf_scom_symbol
;
4118 static asymbol
*mips_elf_scom_symbol_ptr
;
4120 /* MIPS ELF also uses an acommon section, which represents an
4121 allocated common symbol which may be overridden by a
4122 definition in a shared library. */
4123 static asection mips_elf_acom_section
;
4124 static asymbol mips_elf_acom_symbol
;
4125 static asymbol
*mips_elf_acom_symbol_ptr
;
4127 /* Handle the special MIPS section numbers that a symbol may use.
4128 This is used for both the 32-bit and the 64-bit ABI. */
4131 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4133 elf_symbol_type
*elfsym
;
4135 elfsym
= (elf_symbol_type
*) asym
;
4136 switch (elfsym
->internal_elf_sym
.st_shndx
)
4138 case SHN_MIPS_ACOMMON
:
4139 /* This section is used in a dynamically linked executable file.
4140 It is an allocated common section. The dynamic linker can
4141 either resolve these symbols to something in a shared
4142 library, or it can just leave them here. For our purposes,
4143 we can consider these symbols to be in a new section. */
4144 if (mips_elf_acom_section
.name
== NULL
)
4146 /* Initialize the acommon section. */
4147 mips_elf_acom_section
.name
= ".acommon";
4148 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4149 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4150 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4151 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4152 mips_elf_acom_symbol
.name
= ".acommon";
4153 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4154 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4155 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4157 asym
->section
= &mips_elf_acom_section
;
4161 /* Common symbols less than the GP size are automatically
4162 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4163 if (asym
->value
> elf_gp_size (abfd
)
4164 || IRIX_COMPAT (abfd
) == ict_irix6
)
4167 case SHN_MIPS_SCOMMON
:
4168 if (mips_elf_scom_section
.name
== NULL
)
4170 /* Initialize the small common section. */
4171 mips_elf_scom_section
.name
= ".scommon";
4172 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4173 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4174 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4175 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4176 mips_elf_scom_symbol
.name
= ".scommon";
4177 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4178 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4179 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4181 asym
->section
= &mips_elf_scom_section
;
4182 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4185 case SHN_MIPS_SUNDEFINED
:
4186 asym
->section
= bfd_und_section_ptr
;
4191 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
4193 BFD_ASSERT (SGI_COMPAT (abfd
));
4194 if (section
!= NULL
)
4196 asym
->section
= section
;
4197 /* MIPS_TEXT is a bit special, the address is not an offset
4198 to the base of the .text section. So substract the section
4199 base address to make it an offset. */
4200 asym
->value
-= section
->vma
;
4207 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
4209 BFD_ASSERT (SGI_COMPAT (abfd
));
4210 if (section
!= NULL
)
4212 asym
->section
= section
;
4213 /* MIPS_DATA is a bit special, the address is not an offset
4214 to the base of the .data section. So substract the section
4215 base address to make it an offset. */
4216 asym
->value
-= section
->vma
;
4223 /* Implement elf_backend_eh_frame_address_size. This differs from
4224 the default in the way it handles EABI64.
4226 EABI64 was originally specified as an LP64 ABI, and that is what
4227 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4228 historically accepted the combination of -mabi=eabi and -mlong32,
4229 and this ILP32 variation has become semi-official over time.
4230 Both forms use elf32 and have pointer-sized FDE addresses.
4232 If an EABI object was generated by GCC 4.0 or above, it will have
4233 an empty .gcc_compiled_longXX section, where XX is the size of longs
4234 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4235 have no special marking to distinguish them from LP64 objects.
4237 We don't want users of the official LP64 ABI to be punished for the
4238 existence of the ILP32 variant, but at the same time, we don't want
4239 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4240 We therefore take the following approach:
4242 - If ABFD contains a .gcc_compiled_longXX section, use it to
4243 determine the pointer size.
4245 - Otherwise check the type of the first relocation. Assume that
4246 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4250 The second check is enough to detect LP64 objects generated by pre-4.0
4251 compilers because, in the kind of output generated by those compilers,
4252 the first relocation will be associated with either a CIE personality
4253 routine or an FDE start address. Furthermore, the compilers never
4254 used a special (non-pointer) encoding for this ABI.
4256 Checking the relocation type should also be safe because there is no
4257 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4261 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
4263 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
4265 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
4267 bfd_boolean long32_p
, long64_p
;
4269 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
4270 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
4271 if (long32_p
&& long64_p
)
4278 if (sec
->reloc_count
> 0
4279 && elf_section_data (sec
)->relocs
!= NULL
4280 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
4289 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4290 relocations against two unnamed section symbols to resolve to the
4291 same address. For example, if we have code like:
4293 lw $4,%got_disp(.data)($gp)
4294 lw $25,%got_disp(.text)($gp)
4297 then the linker will resolve both relocations to .data and the program
4298 will jump there rather than to .text.
4300 We can work around this problem by giving names to local section symbols.
4301 This is also what the MIPSpro tools do. */
4304 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4306 return SGI_COMPAT (abfd
);
4309 /* Work over a section just before writing it out. This routine is
4310 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4311 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4315 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4317 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4318 && hdr
->sh_size
> 0)
4322 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4323 BFD_ASSERT (hdr
->contents
== NULL
);
4326 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4329 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4330 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4334 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4335 && hdr
->bfd_section
!= NULL
4336 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4337 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4339 bfd_byte
*contents
, *l
, *lend
;
4341 /* We stored the section contents in the tdata field in the
4342 set_section_contents routine. We save the section contents
4343 so that we don't have to read them again.
4344 At this point we know that elf_gp is set, so we can look
4345 through the section contents to see if there is an
4346 ODK_REGINFO structure. */
4348 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4350 lend
= contents
+ hdr
->sh_size
;
4351 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4353 Elf_Internal_Options intopt
;
4355 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4357 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4364 + sizeof (Elf_External_Options
)
4365 + (sizeof (Elf64_External_RegInfo
) - 8)),
4368 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4369 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4372 else if (intopt
.kind
== ODK_REGINFO
)
4379 + sizeof (Elf_External_Options
)
4380 + (sizeof (Elf32_External_RegInfo
) - 4)),
4383 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4384 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4391 if (hdr
->bfd_section
!= NULL
)
4393 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4395 if (strcmp (name
, ".sdata") == 0
4396 || strcmp (name
, ".lit8") == 0
4397 || strcmp (name
, ".lit4") == 0)
4399 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4400 hdr
->sh_type
= SHT_PROGBITS
;
4402 else if (strcmp (name
, ".sbss") == 0)
4404 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4405 hdr
->sh_type
= SHT_NOBITS
;
4407 else if (strcmp (name
, ".srdata") == 0)
4409 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4410 hdr
->sh_type
= SHT_PROGBITS
;
4412 else if (strcmp (name
, ".compact_rel") == 0)
4415 hdr
->sh_type
= SHT_PROGBITS
;
4417 else if (strcmp (name
, ".rtproc") == 0)
4419 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4421 unsigned int adjust
;
4423 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4425 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4433 /* Handle a MIPS specific section when reading an object file. This
4434 is called when elfcode.h finds a section with an unknown type.
4435 This routine supports both the 32-bit and 64-bit ELF ABI.
4437 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4441 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4446 /* There ought to be a place to keep ELF backend specific flags, but
4447 at the moment there isn't one. We just keep track of the
4448 sections by their name, instead. Fortunately, the ABI gives
4449 suggested names for all the MIPS specific sections, so we will
4450 probably get away with this. */
4451 switch (hdr
->sh_type
)
4453 case SHT_MIPS_LIBLIST
:
4454 if (strcmp (name
, ".liblist") != 0)
4458 if (strcmp (name
, ".msym") != 0)
4461 case SHT_MIPS_CONFLICT
:
4462 if (strcmp (name
, ".conflict") != 0)
4465 case SHT_MIPS_GPTAB
:
4466 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4469 case SHT_MIPS_UCODE
:
4470 if (strcmp (name
, ".ucode") != 0)
4473 case SHT_MIPS_DEBUG
:
4474 if (strcmp (name
, ".mdebug") != 0)
4476 flags
= SEC_DEBUGGING
;
4478 case SHT_MIPS_REGINFO
:
4479 if (strcmp (name
, ".reginfo") != 0
4480 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4482 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4484 case SHT_MIPS_IFACE
:
4485 if (strcmp (name
, ".MIPS.interfaces") != 0)
4488 case SHT_MIPS_CONTENT
:
4489 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4492 case SHT_MIPS_OPTIONS
:
4493 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4496 case SHT_MIPS_DWARF
:
4497 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4500 case SHT_MIPS_SYMBOL_LIB
:
4501 if (strcmp (name
, ".MIPS.symlib") != 0)
4504 case SHT_MIPS_EVENTS
:
4505 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4506 && strncmp (name
, ".MIPS.post_rel",
4507 sizeof ".MIPS.post_rel" - 1) != 0)
4514 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4519 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4520 (bfd_get_section_flags (abfd
,
4526 /* FIXME: We should record sh_info for a .gptab section. */
4528 /* For a .reginfo section, set the gp value in the tdata information
4529 from the contents of this section. We need the gp value while
4530 processing relocs, so we just get it now. The .reginfo section
4531 is not used in the 64-bit MIPS ELF ABI. */
4532 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4534 Elf32_External_RegInfo ext
;
4537 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4538 &ext
, 0, sizeof ext
))
4540 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4541 elf_gp (abfd
) = s
.ri_gp_value
;
4544 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4545 set the gp value based on what we find. We may see both
4546 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4547 they should agree. */
4548 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4550 bfd_byte
*contents
, *l
, *lend
;
4552 contents
= bfd_malloc (hdr
->sh_size
);
4553 if (contents
== NULL
)
4555 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4562 lend
= contents
+ hdr
->sh_size
;
4563 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4565 Elf_Internal_Options intopt
;
4567 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4569 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4571 Elf64_Internal_RegInfo intreg
;
4573 bfd_mips_elf64_swap_reginfo_in
4575 ((Elf64_External_RegInfo
*)
4576 (l
+ sizeof (Elf_External_Options
))),
4578 elf_gp (abfd
) = intreg
.ri_gp_value
;
4580 else if (intopt
.kind
== ODK_REGINFO
)
4582 Elf32_RegInfo intreg
;
4584 bfd_mips_elf32_swap_reginfo_in
4586 ((Elf32_External_RegInfo
*)
4587 (l
+ sizeof (Elf_External_Options
))),
4589 elf_gp (abfd
) = intreg
.ri_gp_value
;
4599 /* Set the correct type for a MIPS ELF section. We do this by the
4600 section name, which is a hack, but ought to work. This routine is
4601 used by both the 32-bit and the 64-bit ABI. */
4604 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4606 register const char *name
;
4608 name
= bfd_get_section_name (abfd
, sec
);
4610 if (strcmp (name
, ".liblist") == 0)
4612 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4613 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
4614 /* The sh_link field is set in final_write_processing. */
4616 else if (strcmp (name
, ".conflict") == 0)
4617 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4618 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4620 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4621 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4622 /* The sh_info field is set in final_write_processing. */
4624 else if (strcmp (name
, ".ucode") == 0)
4625 hdr
->sh_type
= SHT_MIPS_UCODE
;
4626 else if (strcmp (name
, ".mdebug") == 0)
4628 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4629 /* In a shared object on IRIX 5.3, the .mdebug section has an
4630 entsize of 0. FIXME: Does this matter? */
4631 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4632 hdr
->sh_entsize
= 0;
4634 hdr
->sh_entsize
= 1;
4636 else if (strcmp (name
, ".reginfo") == 0)
4638 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4639 /* In a shared object on IRIX 5.3, the .reginfo section has an
4640 entsize of 0x18. FIXME: Does this matter? */
4641 if (SGI_COMPAT (abfd
))
4643 if ((abfd
->flags
& DYNAMIC
) != 0)
4644 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4646 hdr
->sh_entsize
= 1;
4649 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4651 else if (SGI_COMPAT (abfd
)
4652 && (strcmp (name
, ".hash") == 0
4653 || strcmp (name
, ".dynamic") == 0
4654 || strcmp (name
, ".dynstr") == 0))
4656 if (SGI_COMPAT (abfd
))
4657 hdr
->sh_entsize
= 0;
4659 /* This isn't how the IRIX6 linker behaves. */
4660 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4663 else if (strcmp (name
, ".got") == 0
4664 || strcmp (name
, ".srdata") == 0
4665 || strcmp (name
, ".sdata") == 0
4666 || strcmp (name
, ".sbss") == 0
4667 || strcmp (name
, ".lit4") == 0
4668 || strcmp (name
, ".lit8") == 0)
4669 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4670 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4672 hdr
->sh_type
= SHT_MIPS_IFACE
;
4673 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4675 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4677 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4678 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4679 /* The sh_info field is set in final_write_processing. */
4681 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4683 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4684 hdr
->sh_entsize
= 1;
4685 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4687 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4688 hdr
->sh_type
= SHT_MIPS_DWARF
;
4689 else if (strcmp (name
, ".MIPS.symlib") == 0)
4691 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4692 /* The sh_link and sh_info fields are set in
4693 final_write_processing. */
4695 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4696 || strncmp (name
, ".MIPS.post_rel",
4697 sizeof ".MIPS.post_rel" - 1) == 0)
4699 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4700 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4701 /* The sh_link field is set in final_write_processing. */
4703 else if (strcmp (name
, ".msym") == 0)
4705 hdr
->sh_type
= SHT_MIPS_MSYM
;
4706 hdr
->sh_flags
|= SHF_ALLOC
;
4707 hdr
->sh_entsize
= 8;
4710 /* The generic elf_fake_sections will set up REL_HDR using the default
4711 kind of relocations. We used to set up a second header for the
4712 non-default kind of relocations here, but only NewABI would use
4713 these, and the IRIX ld doesn't like resulting empty RELA sections.
4714 Thus we create those header only on demand now. */
4719 /* Given a BFD section, try to locate the corresponding ELF section
4720 index. This is used by both the 32-bit and the 64-bit ABI.
4721 Actually, it's not clear to me that the 64-bit ABI supports these,
4722 but for non-PIC objects we will certainly want support for at least
4723 the .scommon section. */
4726 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4727 asection
*sec
, int *retval
)
4729 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4731 *retval
= SHN_MIPS_SCOMMON
;
4734 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4736 *retval
= SHN_MIPS_ACOMMON
;
4742 /* Hook called by the linker routine which adds symbols from an object
4743 file. We must handle the special MIPS section numbers here. */
4746 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4747 Elf_Internal_Sym
*sym
, const char **namep
,
4748 flagword
*flagsp ATTRIBUTE_UNUSED
,
4749 asection
**secp
, bfd_vma
*valp
)
4751 if (SGI_COMPAT (abfd
)
4752 && (abfd
->flags
& DYNAMIC
) != 0
4753 && strcmp (*namep
, "_rld_new_interface") == 0)
4755 /* Skip IRIX5 rld entry name. */
4760 switch (sym
->st_shndx
)
4763 /* Common symbols less than the GP size are automatically
4764 treated as SHN_MIPS_SCOMMON symbols. */
4765 if (sym
->st_size
> elf_gp_size (abfd
)
4766 || IRIX_COMPAT (abfd
) == ict_irix6
)
4769 case SHN_MIPS_SCOMMON
:
4770 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4771 (*secp
)->flags
|= SEC_IS_COMMON
;
4772 *valp
= sym
->st_size
;
4776 /* This section is used in a shared object. */
4777 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4779 asymbol
*elf_text_symbol
;
4780 asection
*elf_text_section
;
4781 bfd_size_type amt
= sizeof (asection
);
4783 elf_text_section
= bfd_zalloc (abfd
, amt
);
4784 if (elf_text_section
== NULL
)
4787 amt
= sizeof (asymbol
);
4788 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4789 if (elf_text_symbol
== NULL
)
4792 /* Initialize the section. */
4794 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4795 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4797 elf_text_section
->symbol
= elf_text_symbol
;
4798 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4800 elf_text_section
->name
= ".text";
4801 elf_text_section
->flags
= SEC_NO_FLAGS
;
4802 elf_text_section
->output_section
= NULL
;
4803 elf_text_section
->owner
= abfd
;
4804 elf_text_symbol
->name
= ".text";
4805 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4806 elf_text_symbol
->section
= elf_text_section
;
4808 /* This code used to do *secp = bfd_und_section_ptr if
4809 info->shared. I don't know why, and that doesn't make sense,
4810 so I took it out. */
4811 *secp
= elf_tdata (abfd
)->elf_text_section
;
4814 case SHN_MIPS_ACOMMON
:
4815 /* Fall through. XXX Can we treat this as allocated data? */
4817 /* This section is used in a shared object. */
4818 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4820 asymbol
*elf_data_symbol
;
4821 asection
*elf_data_section
;
4822 bfd_size_type amt
= sizeof (asection
);
4824 elf_data_section
= bfd_zalloc (abfd
, amt
);
4825 if (elf_data_section
== NULL
)
4828 amt
= sizeof (asymbol
);
4829 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4830 if (elf_data_symbol
== NULL
)
4833 /* Initialize the section. */
4835 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4836 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4838 elf_data_section
->symbol
= elf_data_symbol
;
4839 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4841 elf_data_section
->name
= ".data";
4842 elf_data_section
->flags
= SEC_NO_FLAGS
;
4843 elf_data_section
->output_section
= NULL
;
4844 elf_data_section
->owner
= abfd
;
4845 elf_data_symbol
->name
= ".data";
4846 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4847 elf_data_symbol
->section
= elf_data_section
;
4849 /* This code used to do *secp = bfd_und_section_ptr if
4850 info->shared. I don't know why, and that doesn't make sense,
4851 so I took it out. */
4852 *secp
= elf_tdata (abfd
)->elf_data_section
;
4855 case SHN_MIPS_SUNDEFINED
:
4856 *secp
= bfd_und_section_ptr
;
4860 if (SGI_COMPAT (abfd
)
4862 && info
->hash
->creator
== abfd
->xvec
4863 && strcmp (*namep
, "__rld_obj_head") == 0)
4865 struct elf_link_hash_entry
*h
;
4866 struct bfd_link_hash_entry
*bh
;
4868 /* Mark __rld_obj_head as dynamic. */
4870 if (! (_bfd_generic_link_add_one_symbol
4871 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4872 get_elf_backend_data (abfd
)->collect
, &bh
)))
4875 h
= (struct elf_link_hash_entry
*) bh
;
4878 h
->type
= STT_OBJECT
;
4880 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4883 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4886 /* If this is a mips16 text symbol, add 1 to the value to make it
4887 odd. This will cause something like .word SYM to come up with
4888 the right value when it is loaded into the PC. */
4889 if (sym
->st_other
== STO_MIPS16
)
4895 /* This hook function is called before the linker writes out a global
4896 symbol. We mark symbols as small common if appropriate. This is
4897 also where we undo the increment of the value for a mips16 symbol. */
4900 _bfd_mips_elf_link_output_symbol_hook
4901 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4902 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4903 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4905 /* If we see a common symbol, which implies a relocatable link, then
4906 if a symbol was small common in an input file, mark it as small
4907 common in the output file. */
4908 if (sym
->st_shndx
== SHN_COMMON
4909 && strcmp (input_sec
->name
, ".scommon") == 0)
4910 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4912 if (sym
->st_other
== STO_MIPS16
)
4913 sym
->st_value
&= ~1;
4918 /* Functions for the dynamic linker. */
4920 /* Create dynamic sections when linking against a dynamic object. */
4923 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4925 struct elf_link_hash_entry
*h
;
4926 struct bfd_link_hash_entry
*bh
;
4928 register asection
*s
;
4929 const char * const *namep
;
4931 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4932 | SEC_LINKER_CREATED
| SEC_READONLY
);
4934 /* Mips ABI requests the .dynamic section to be read only. */
4935 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4938 if (! bfd_set_section_flags (abfd
, s
, flags
))
4942 /* We need to create .got section. */
4943 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4946 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4949 /* Create .stub section. */
4950 if (bfd_get_section_by_name (abfd
,
4951 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4953 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4955 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4956 || ! bfd_set_section_alignment (abfd
, s
,
4957 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4961 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4963 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4965 s
= bfd_make_section (abfd
, ".rld_map");
4967 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4968 || ! bfd_set_section_alignment (abfd
, s
,
4969 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4973 /* On IRIX5, we adjust add some additional symbols and change the
4974 alignments of several sections. There is no ABI documentation
4975 indicating that this is necessary on IRIX6, nor any evidence that
4976 the linker takes such action. */
4977 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4979 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4982 if (! (_bfd_generic_link_add_one_symbol
4983 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4984 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4987 h
= (struct elf_link_hash_entry
*) bh
;
4990 h
->type
= STT_SECTION
;
4992 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4996 /* We need to create a .compact_rel section. */
4997 if (SGI_COMPAT (abfd
))
4999 if (!mips_elf_create_compact_rel_section (abfd
, info
))
5003 /* Change alignments of some sections. */
5004 s
= bfd_get_section_by_name (abfd
, ".hash");
5006 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5007 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5009 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5010 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5012 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5013 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5015 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5016 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5018 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5025 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5027 if (!(_bfd_generic_link_add_one_symbol
5028 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5029 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5032 h
= (struct elf_link_hash_entry
*) bh
;
5035 h
->type
= STT_SECTION
;
5037 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5040 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5042 /* __rld_map is a four byte word located in the .data section
5043 and is filled in by the rtld to contain a pointer to
5044 the _r_debug structure. Its symbol value will be set in
5045 _bfd_mips_elf_finish_dynamic_symbol. */
5046 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5047 BFD_ASSERT (s
!= NULL
);
5049 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5051 if (!(_bfd_generic_link_add_one_symbol
5052 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5053 get_elf_backend_data (abfd
)->collect
, &bh
)))
5056 h
= (struct elf_link_hash_entry
*) bh
;
5059 h
->type
= STT_OBJECT
;
5061 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5069 /* Look through the relocs for a section during the first phase, and
5070 allocate space in the global offset table. */
5073 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5074 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5078 Elf_Internal_Shdr
*symtab_hdr
;
5079 struct elf_link_hash_entry
**sym_hashes
;
5080 struct mips_got_info
*g
;
5082 const Elf_Internal_Rela
*rel
;
5083 const Elf_Internal_Rela
*rel_end
;
5086 const struct elf_backend_data
*bed
;
5088 if (info
->relocatable
)
5091 dynobj
= elf_hash_table (info
)->dynobj
;
5092 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5093 sym_hashes
= elf_sym_hashes (abfd
);
5094 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5096 /* Check for the mips16 stub sections. */
5098 name
= bfd_get_section_name (abfd
, sec
);
5099 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5101 unsigned long r_symndx
;
5103 /* Look at the relocation information to figure out which symbol
5106 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5108 if (r_symndx
< extsymoff
5109 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5113 /* This stub is for a local symbol. This stub will only be
5114 needed if there is some relocation in this BFD, other
5115 than a 16 bit function call, which refers to this symbol. */
5116 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5118 Elf_Internal_Rela
*sec_relocs
;
5119 const Elf_Internal_Rela
*r
, *rend
;
5121 /* We can ignore stub sections when looking for relocs. */
5122 if ((o
->flags
& SEC_RELOC
) == 0
5123 || o
->reloc_count
== 0
5124 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5125 sizeof FN_STUB
- 1) == 0
5126 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5127 sizeof CALL_STUB
- 1) == 0
5128 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5129 sizeof CALL_FP_STUB
- 1) == 0)
5133 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5135 if (sec_relocs
== NULL
)
5138 rend
= sec_relocs
+ o
->reloc_count
;
5139 for (r
= sec_relocs
; r
< rend
; r
++)
5140 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5141 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5144 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5153 /* There is no non-call reloc for this stub, so we do
5154 not need it. Since this function is called before
5155 the linker maps input sections to output sections, we
5156 can easily discard it by setting the SEC_EXCLUDE
5158 sec
->flags
|= SEC_EXCLUDE
;
5162 /* Record this stub in an array of local symbol stubs for
5164 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5166 unsigned long symcount
;
5170 if (elf_bad_symtab (abfd
))
5171 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5173 symcount
= symtab_hdr
->sh_info
;
5174 amt
= symcount
* sizeof (asection
*);
5175 n
= bfd_zalloc (abfd
, amt
);
5178 elf_tdata (abfd
)->local_stubs
= n
;
5181 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5183 /* We don't need to set mips16_stubs_seen in this case.
5184 That flag is used to see whether we need to look through
5185 the global symbol table for stubs. We don't need to set
5186 it here, because we just have a local stub. */
5190 struct mips_elf_link_hash_entry
*h
;
5192 h
= ((struct mips_elf_link_hash_entry
*)
5193 sym_hashes
[r_symndx
- extsymoff
]);
5195 /* H is the symbol this stub is for. */
5198 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5201 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5202 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5204 unsigned long r_symndx
;
5205 struct mips_elf_link_hash_entry
*h
;
5208 /* Look at the relocation information to figure out which symbol
5211 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5213 if (r_symndx
< extsymoff
5214 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5216 /* This stub was actually built for a static symbol defined
5217 in the same file. We assume that all static symbols in
5218 mips16 code are themselves mips16, so we can simply
5219 discard this stub. Since this function is called before
5220 the linker maps input sections to output sections, we can
5221 easily discard it by setting the SEC_EXCLUDE flag. */
5222 sec
->flags
|= SEC_EXCLUDE
;
5226 h
= ((struct mips_elf_link_hash_entry
*)
5227 sym_hashes
[r_symndx
- extsymoff
]);
5229 /* H is the symbol this stub is for. */
5231 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5232 loc
= &h
->call_fp_stub
;
5234 loc
= &h
->call_stub
;
5236 /* If we already have an appropriate stub for this function, we
5237 don't need another one, so we can discard this one. Since
5238 this function is called before the linker maps input sections
5239 to output sections, we can easily discard it by setting the
5240 SEC_EXCLUDE flag. We can also discard this section if we
5241 happen to already know that this is a mips16 function; it is
5242 not necessary to check this here, as it is checked later, but
5243 it is slightly faster to check now. */
5244 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5246 sec
->flags
|= SEC_EXCLUDE
;
5251 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5261 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5266 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5267 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5268 BFD_ASSERT (g
!= NULL
);
5273 bed
= get_elf_backend_data (abfd
);
5274 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5275 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5277 unsigned long r_symndx
;
5278 unsigned int r_type
;
5279 struct elf_link_hash_entry
*h
;
5281 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5282 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5284 if (r_symndx
< extsymoff
)
5286 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5288 (*_bfd_error_handler
)
5289 (_("%B: Malformed reloc detected for section %s"),
5291 bfd_set_error (bfd_error_bad_value
);
5296 h
= sym_hashes
[r_symndx
- extsymoff
];
5298 /* This may be an indirect symbol created because of a version. */
5301 while (h
->root
.type
== bfd_link_hash_indirect
)
5302 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5306 /* Some relocs require a global offset table. */
5307 if (dynobj
== NULL
|| sgot
== NULL
)
5313 case R_MIPS_CALL_HI16
:
5314 case R_MIPS_CALL_LO16
:
5315 case R_MIPS_GOT_HI16
:
5316 case R_MIPS_GOT_LO16
:
5317 case R_MIPS_GOT_PAGE
:
5318 case R_MIPS_GOT_OFST
:
5319 case R_MIPS_GOT_DISP
:
5321 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5322 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5324 g
= mips_elf_got_info (dynobj
, &sgot
);
5331 && (info
->shared
|| h
!= NULL
)
5332 && (sec
->flags
& SEC_ALLOC
) != 0)
5333 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5341 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5342 || r_type
== R_MIPS_GOT_LO16
5343 || r_type
== R_MIPS_GOT_DISP
))
5345 /* We may need a local GOT entry for this relocation. We
5346 don't count R_MIPS_GOT_PAGE because we can estimate the
5347 maximum number of pages needed by looking at the size of
5348 the segment. Similar comments apply to R_MIPS_GOT16 and
5349 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5350 R_MIPS_CALL_HI16 because these are always followed by an
5351 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5352 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5362 (*_bfd_error_handler
)
5363 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
5364 abfd
, (unsigned long) rel
->r_offset
);
5365 bfd_set_error (bfd_error_bad_value
);
5370 case R_MIPS_CALL_HI16
:
5371 case R_MIPS_CALL_LO16
:
5374 /* This symbol requires a global offset table entry. */
5375 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5378 /* We need a stub, not a plt entry for the undefined
5379 function. But we record it as if it needs plt. See
5380 _bfd_elf_adjust_dynamic_symbol. */
5386 case R_MIPS_GOT_PAGE
:
5387 /* If this is a global, overridable symbol, GOT_PAGE will
5388 decay to GOT_DISP, so we'll need a GOT entry for it. */
5393 struct mips_elf_link_hash_entry
*hmips
=
5394 (struct mips_elf_link_hash_entry
*) h
;
5396 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5397 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5398 hmips
= (struct mips_elf_link_hash_entry
*)
5399 hmips
->root
.root
.u
.i
.link
;
5401 if (hmips
->root
.def_regular
5402 && ! (info
->shared
&& ! info
->symbolic
5403 && ! hmips
->root
.forced_local
))
5409 case R_MIPS_GOT_HI16
:
5410 case R_MIPS_GOT_LO16
:
5411 case R_MIPS_GOT_DISP
:
5412 /* This symbol requires a global offset table entry. */
5413 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5420 if ((info
->shared
|| h
!= NULL
)
5421 && (sec
->flags
& SEC_ALLOC
) != 0)
5425 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5429 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5432 /* When creating a shared object, we must copy these
5433 reloc types into the output file as R_MIPS_REL32
5434 relocs. We make room for this reloc in the
5435 .rel.dyn reloc section. */
5436 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5437 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5438 == MIPS_READONLY_SECTION
)
5439 /* We tell the dynamic linker that there are
5440 relocations against the text segment. */
5441 info
->flags
|= DF_TEXTREL
;
5445 struct mips_elf_link_hash_entry
*hmips
;
5447 /* We only need to copy this reloc if the symbol is
5448 defined in a dynamic object. */
5449 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5450 ++hmips
->possibly_dynamic_relocs
;
5451 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5452 == MIPS_READONLY_SECTION
)
5453 /* We need it to tell the dynamic linker if there
5454 are relocations against the text segment. */
5455 hmips
->readonly_reloc
= TRUE
;
5458 /* Even though we don't directly need a GOT entry for
5459 this symbol, a symbol must have a dynamic symbol
5460 table index greater that DT_MIPS_GOTSYM if there are
5461 dynamic relocations against it. */
5465 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5466 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5468 g
= mips_elf_got_info (dynobj
, &sgot
);
5469 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5474 if (SGI_COMPAT (abfd
))
5475 mips_elf_hash_table (info
)->compact_rel_size
+=
5476 sizeof (Elf32_External_crinfo
);
5480 case R_MIPS_GPREL16
:
5481 case R_MIPS_LITERAL
:
5482 case R_MIPS_GPREL32
:
5483 if (SGI_COMPAT (abfd
))
5484 mips_elf_hash_table (info
)->compact_rel_size
+=
5485 sizeof (Elf32_External_crinfo
);
5488 /* This relocation describes the C++ object vtable hierarchy.
5489 Reconstruct it for later use during GC. */
5490 case R_MIPS_GNU_VTINHERIT
:
5491 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5495 /* This relocation describes which C++ vtable entries are actually
5496 used. Record for later use during GC. */
5497 case R_MIPS_GNU_VTENTRY
:
5498 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5506 /* We must not create a stub for a symbol that has relocations
5507 related to taking the function's address. */
5513 struct mips_elf_link_hash_entry
*mh
;
5515 mh
= (struct mips_elf_link_hash_entry
*) h
;
5516 mh
->no_fn_stub
= TRUE
;
5520 case R_MIPS_CALL_HI16
:
5521 case R_MIPS_CALL_LO16
:
5526 /* If this reloc is not a 16 bit call, and it has a global
5527 symbol, then we will need the fn_stub if there is one.
5528 References from a stub section do not count. */
5530 && r_type
!= R_MIPS16_26
5531 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5532 sizeof FN_STUB
- 1) != 0
5533 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5534 sizeof CALL_STUB
- 1) != 0
5535 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5536 sizeof CALL_FP_STUB
- 1) != 0)
5538 struct mips_elf_link_hash_entry
*mh
;
5540 mh
= (struct mips_elf_link_hash_entry
*) h
;
5541 mh
->need_fn_stub
= TRUE
;
5549 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5550 struct bfd_link_info
*link_info
,
5553 Elf_Internal_Rela
*internal_relocs
;
5554 Elf_Internal_Rela
*irel
, *irelend
;
5555 Elf_Internal_Shdr
*symtab_hdr
;
5556 bfd_byte
*contents
= NULL
;
5558 bfd_boolean changed_contents
= FALSE
;
5559 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5560 Elf_Internal_Sym
*isymbuf
= NULL
;
5562 /* We are not currently changing any sizes, so only one pass. */
5565 if (link_info
->relocatable
)
5568 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5569 link_info
->keep_memory
);
5570 if (internal_relocs
== NULL
)
5573 irelend
= internal_relocs
+ sec
->reloc_count
5574 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5575 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5576 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5578 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5581 bfd_signed_vma sym_offset
;
5582 unsigned int r_type
;
5583 unsigned long r_symndx
;
5585 unsigned long instruction
;
5587 /* Turn jalr into bgezal, and jr into beq, if they're marked
5588 with a JALR relocation, that indicate where they jump to.
5589 This saves some pipeline bubbles. */
5590 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5591 if (r_type
!= R_MIPS_JALR
)
5594 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5595 /* Compute the address of the jump target. */
5596 if (r_symndx
>= extsymoff
)
5598 struct mips_elf_link_hash_entry
*h
5599 = ((struct mips_elf_link_hash_entry
*)
5600 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5602 while (h
->root
.root
.type
== bfd_link_hash_indirect
5603 || h
->root
.root
.type
== bfd_link_hash_warning
)
5604 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5606 /* If a symbol is undefined, or if it may be overridden,
5608 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5609 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5610 && h
->root
.root
.u
.def
.section
)
5611 || (link_info
->shared
&& ! link_info
->symbolic
5612 && !h
->root
.forced_local
))
5615 sym_sec
= h
->root
.root
.u
.def
.section
;
5616 if (sym_sec
->output_section
)
5617 symval
= (h
->root
.root
.u
.def
.value
5618 + sym_sec
->output_section
->vma
5619 + sym_sec
->output_offset
);
5621 symval
= h
->root
.root
.u
.def
.value
;
5625 Elf_Internal_Sym
*isym
;
5627 /* Read this BFD's symbols if we haven't done so already. */
5628 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5630 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5631 if (isymbuf
== NULL
)
5632 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5633 symtab_hdr
->sh_info
, 0,
5635 if (isymbuf
== NULL
)
5639 isym
= isymbuf
+ r_symndx
;
5640 if (isym
->st_shndx
== SHN_UNDEF
)
5642 else if (isym
->st_shndx
== SHN_ABS
)
5643 sym_sec
= bfd_abs_section_ptr
;
5644 else if (isym
->st_shndx
== SHN_COMMON
)
5645 sym_sec
= bfd_com_section_ptr
;
5648 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5649 symval
= isym
->st_value
5650 + sym_sec
->output_section
->vma
5651 + sym_sec
->output_offset
;
5654 /* Compute branch offset, from delay slot of the jump to the
5656 sym_offset
= (symval
+ irel
->r_addend
)
5657 - (sec_start
+ irel
->r_offset
+ 4);
5659 /* Branch offset must be properly aligned. */
5660 if ((sym_offset
& 3) != 0)
5665 /* Check that it's in range. */
5666 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5669 /* Get the section contents if we haven't done so already. */
5670 if (contents
== NULL
)
5672 /* Get cached copy if it exists. */
5673 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5674 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5677 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
5682 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5684 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5685 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5686 instruction
= 0x04110000;
5687 /* If it was jr <reg>, turn it into b <target>. */
5688 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5689 instruction
= 0x10000000;
5693 instruction
|= (sym_offset
& 0xffff);
5694 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5695 changed_contents
= TRUE
;
5698 if (contents
!= NULL
5699 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5701 if (!changed_contents
&& !link_info
->keep_memory
)
5705 /* Cache the section contents for elf_link_input_bfd. */
5706 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5712 if (contents
!= NULL
5713 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5718 /* Adjust a symbol defined by a dynamic object and referenced by a
5719 regular object. The current definition is in some section of the
5720 dynamic object, but we're not including those sections. We have to
5721 change the definition to something the rest of the link can
5725 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5726 struct elf_link_hash_entry
*h
)
5729 struct mips_elf_link_hash_entry
*hmips
;
5732 dynobj
= elf_hash_table (info
)->dynobj
;
5734 /* Make sure we know what is going on here. */
5735 BFD_ASSERT (dynobj
!= NULL
5737 || h
->u
.weakdef
!= NULL
5740 && !h
->def_regular
)));
5742 /* If this symbol is defined in a dynamic object, we need to copy
5743 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5745 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5746 if (! info
->relocatable
5747 && hmips
->possibly_dynamic_relocs
!= 0
5748 && (h
->root
.type
== bfd_link_hash_defweak
5749 || !h
->def_regular
))
5751 mips_elf_allocate_dynamic_relocations (dynobj
,
5752 hmips
->possibly_dynamic_relocs
);
5753 if (hmips
->readonly_reloc
)
5754 /* We tell the dynamic linker that there are relocations
5755 against the text segment. */
5756 info
->flags
|= DF_TEXTREL
;
5759 /* For a function, create a stub, if allowed. */
5760 if (! hmips
->no_fn_stub
5763 if (! elf_hash_table (info
)->dynamic_sections_created
)
5766 /* If this symbol is not defined in a regular file, then set
5767 the symbol to the stub location. This is required to make
5768 function pointers compare as equal between the normal
5769 executable and the shared library. */
5770 if (!h
->def_regular
)
5772 /* We need .stub section. */
5773 s
= bfd_get_section_by_name (dynobj
,
5774 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5775 BFD_ASSERT (s
!= NULL
);
5777 h
->root
.u
.def
.section
= s
;
5778 h
->root
.u
.def
.value
= s
->size
;
5780 /* XXX Write this stub address somewhere. */
5781 h
->plt
.offset
= s
->size
;
5783 /* Make room for this stub code. */
5784 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
5786 /* The last half word of the stub will be filled with the index
5787 of this symbol in .dynsym section. */
5791 else if ((h
->type
== STT_FUNC
)
5794 /* This will set the entry for this symbol in the GOT to 0, and
5795 the dynamic linker will take care of this. */
5796 h
->root
.u
.def
.value
= 0;
5800 /* If this is a weak symbol, and there is a real definition, the
5801 processor independent code will have arranged for us to see the
5802 real definition first, and we can just use the same value. */
5803 if (h
->u
.weakdef
!= NULL
)
5805 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
5806 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
5807 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
5808 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
5812 /* This is a reference to a symbol defined by a dynamic object which
5813 is not a function. */
5818 /* This function is called after all the input files have been read,
5819 and the input sections have been assigned to output sections. We
5820 check for any mips16 stub sections that we can discard. */
5823 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5824 struct bfd_link_info
*info
)
5830 struct mips_got_info
*g
;
5832 bfd_size_type loadable_size
= 0;
5833 bfd_size_type local_gotno
;
5836 /* The .reginfo section has a fixed size. */
5837 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5839 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5841 if (! (info
->relocatable
5842 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5843 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5844 mips_elf_check_mips16_stubs
, NULL
);
5846 dynobj
= elf_hash_table (info
)->dynobj
;
5848 /* Relocatable links don't have it. */
5851 g
= mips_elf_got_info (dynobj
, &s
);
5855 /* Calculate the total loadable size of the output. That
5856 will give us the maximum number of GOT_PAGE entries
5858 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5860 asection
*subsection
;
5862 for (subsection
= sub
->sections
;
5864 subsection
= subsection
->next
)
5866 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5868 loadable_size
+= ((subsection
->size
+ 0xf)
5869 &~ (bfd_size_type
) 0xf);
5873 /* There has to be a global GOT entry for every symbol with
5874 a dynamic symbol table index of DT_MIPS_GOTSYM or
5875 higher. Therefore, it make sense to put those symbols
5876 that need GOT entries at the end of the symbol table. We
5878 if (! mips_elf_sort_hash_table (info
, 1))
5881 if (g
->global_gotsym
!= NULL
)
5882 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5884 /* If there are no global symbols, or none requiring
5885 relocations, then GLOBAL_GOTSYM will be NULL. */
5888 /* In the worst case, we'll get one stub per dynamic symbol, plus
5889 one to account for the dummy entry at the end required by IRIX
5891 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5893 /* Assume there are two loadable segments consisting of
5894 contiguous sections. Is 5 enough? */
5895 local_gotno
= (loadable_size
>> 16) + 5;
5897 g
->local_gotno
+= local_gotno
;
5898 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5900 g
->global_gotno
= i
;
5901 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5903 if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5904 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5910 /* Set the sizes of the dynamic sections. */
5913 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5914 struct bfd_link_info
*info
)
5918 bfd_boolean reltext
;
5920 dynobj
= elf_hash_table (info
)->dynobj
;
5921 BFD_ASSERT (dynobj
!= NULL
);
5923 if (elf_hash_table (info
)->dynamic_sections_created
)
5925 /* Set the contents of the .interp section to the interpreter. */
5926 if (info
->executable
)
5928 s
= bfd_get_section_by_name (dynobj
, ".interp");
5929 BFD_ASSERT (s
!= NULL
);
5931 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5933 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5937 /* The check_relocs and adjust_dynamic_symbol entry points have
5938 determined the sizes of the various dynamic sections. Allocate
5941 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5946 /* It's OK to base decisions on the section name, because none
5947 of the dynobj section names depend upon the input files. */
5948 name
= bfd_get_section_name (dynobj
, s
);
5950 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5955 if (strncmp (name
, ".rel", 4) == 0)
5959 /* We only strip the section if the output section name
5960 has the same name. Otherwise, there might be several
5961 input sections for this output section. FIXME: This
5962 code is probably not needed these days anyhow, since
5963 the linker now does not create empty output sections. */
5964 if (s
->output_section
!= NULL
5966 bfd_get_section_name (s
->output_section
->owner
,
5967 s
->output_section
)) == 0)
5972 const char *outname
;
5975 /* If this relocation section applies to a read only
5976 section, then we probably need a DT_TEXTREL entry.
5977 If the relocation section is .rel.dyn, we always
5978 assert a DT_TEXTREL entry rather than testing whether
5979 there exists a relocation to a read only section or
5981 outname
= bfd_get_section_name (output_bfd
,
5983 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5985 && (target
->flags
& SEC_READONLY
) != 0
5986 && (target
->flags
& SEC_ALLOC
) != 0)
5987 || strcmp (outname
, ".rel.dyn") == 0)
5990 /* We use the reloc_count field as a counter if we need
5991 to copy relocs into the output file. */
5992 if (strcmp (name
, ".rel.dyn") != 0)
5995 /* If combreloc is enabled, elf_link_sort_relocs() will
5996 sort relocations, but in a different way than we do,
5997 and before we're done creating relocations. Also, it
5998 will move them around between input sections'
5999 relocation's contents, so our sorting would be
6000 broken, so don't let it run. */
6001 info
->combreloc
= 0;
6004 else if (strncmp (name
, ".got", 4) == 0)
6006 /* _bfd_mips_elf_always_size_sections() has already done
6007 most of the work, but some symbols may have been mapped
6008 to versions that we must now resolve in the got_entries
6010 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
6011 struct mips_got_info
*g
= gg
;
6012 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
6013 unsigned int needed_relocs
= 0;
6017 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6018 set_got_offset_arg
.info
= info
;
6020 mips_elf_resolve_final_got_entries (gg
);
6021 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6023 unsigned int save_assign
;
6025 mips_elf_resolve_final_got_entries (g
);
6027 /* Assign offsets to global GOT entries. */
6028 save_assign
= g
->assigned_gotno
;
6029 g
->assigned_gotno
= g
->local_gotno
;
6030 set_got_offset_arg
.g
= g
;
6031 set_got_offset_arg
.needed_relocs
= 0;
6032 htab_traverse (g
->got_entries
,
6033 mips_elf_set_global_got_offset
,
6034 &set_got_offset_arg
);
6035 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6036 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6037 <= g
->global_gotno
);
6039 g
->assigned_gotno
= save_assign
;
6042 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6043 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6044 + g
->next
->global_gotno
6045 + MIPS_RESERVED_GOTNO
);
6050 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6053 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6055 /* IRIX rld assumes that the function stub isn't at the end
6056 of .text section. So put a dummy. XXX */
6057 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6059 else if (! info
->shared
6060 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6061 && strncmp (name
, ".rld_map", 8) == 0)
6063 /* We add a room for __rld_map. It will be filled in by the
6064 rtld to contain a pointer to the _r_debug structure. */
6067 else if (SGI_COMPAT (output_bfd
)
6068 && strncmp (name
, ".compact_rel", 12) == 0)
6069 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6070 else if (strncmp (name
, ".init", 5) != 0)
6072 /* It's not one of our sections, so don't allocate space. */
6078 _bfd_strip_section_from_output (info
, s
);
6082 /* Allocate memory for the section contents. */
6083 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
6084 if (s
->contents
== NULL
&& s
->size
!= 0)
6086 bfd_set_error (bfd_error_no_memory
);
6091 if (elf_hash_table (info
)->dynamic_sections_created
)
6093 /* Add some entries to the .dynamic section. We fill in the
6094 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6095 must add the entries now so that we get the correct size for
6096 the .dynamic section. The DT_DEBUG entry is filled in by the
6097 dynamic linker and used by the debugger. */
6100 /* SGI object has the equivalence of DT_DEBUG in the
6101 DT_MIPS_RLD_MAP entry. */
6102 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6104 if (!SGI_COMPAT (output_bfd
))
6106 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6112 /* Shared libraries on traditional mips have DT_DEBUG. */
6113 if (!SGI_COMPAT (output_bfd
))
6115 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6120 if (reltext
&& SGI_COMPAT (output_bfd
))
6121 info
->flags
|= DF_TEXTREL
;
6123 if ((info
->flags
& DF_TEXTREL
) != 0)
6125 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6129 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6132 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6134 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6137 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6140 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6144 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6147 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6151 /* Time stamps in executable files are a bad idea. */
6152 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6157 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6162 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6166 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6169 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6172 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6175 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6178 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6181 if (IRIX_COMPAT (dynobj
) == ict_irix5
6182 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6185 if (IRIX_COMPAT (dynobj
) == ict_irix6
6186 && (bfd_get_section_by_name
6187 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6188 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6195 /* Relocate a MIPS ELF section. */
6198 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6199 bfd
*input_bfd
, asection
*input_section
,
6200 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6201 Elf_Internal_Sym
*local_syms
,
6202 asection
**local_sections
)
6204 Elf_Internal_Rela
*rel
;
6205 const Elf_Internal_Rela
*relend
;
6207 bfd_boolean use_saved_addend_p
= FALSE
;
6208 const struct elf_backend_data
*bed
;
6210 bed
= get_elf_backend_data (output_bfd
);
6211 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6212 for (rel
= relocs
; rel
< relend
; ++rel
)
6216 reloc_howto_type
*howto
;
6217 bfd_boolean require_jalx
;
6218 /* TRUE if the relocation is a RELA relocation, rather than a
6220 bfd_boolean rela_relocation_p
= TRUE
;
6221 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6224 /* Find the relocation howto for this relocation. */
6225 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6227 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6228 64-bit code, but make sure all their addresses are in the
6229 lowermost or uppermost 32-bit section of the 64-bit address
6230 space. Thus, when they use an R_MIPS_64 they mean what is
6231 usually meant by R_MIPS_32, with the exception that the
6232 stored value is sign-extended to 64 bits. */
6233 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6235 /* On big-endian systems, we need to lie about the position
6237 if (bfd_big_endian (input_bfd
))
6241 /* NewABI defaults to RELA relocations. */
6242 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6243 NEWABI_P (input_bfd
)
6244 && (MIPS_RELOC_RELA_P
6245 (input_bfd
, input_section
,
6248 if (!use_saved_addend_p
)
6250 Elf_Internal_Shdr
*rel_hdr
;
6252 /* If these relocations were originally of the REL variety,
6253 we must pull the addend out of the field that will be
6254 relocated. Otherwise, we simply use the contents of the
6255 RELA relocation. To determine which flavor or relocation
6256 this is, we depend on the fact that the INPUT_SECTION's
6257 REL_HDR is read before its REL_HDR2. */
6258 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6259 if ((size_t) (rel
- relocs
)
6260 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6261 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6262 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6264 bfd_byte
*location
= contents
+ rel
->r_offset
;
6266 /* Note that this is a REL relocation. */
6267 rela_relocation_p
= FALSE
;
6269 /* Get the addend, which is stored in the input file. */
6270 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
6272 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6274 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
6277 addend
&= howto
->src_mask
;
6279 /* For some kinds of relocations, the ADDEND is a
6280 combination of the addend stored in two different
6282 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
6283 || (r_type
== R_MIPS_GOT16
6284 && mips_elf_local_relocation_p (input_bfd
, rel
,
6285 local_sections
, FALSE
)))
6288 const Elf_Internal_Rela
*lo16_relocation
;
6289 reloc_howto_type
*lo16_howto
;
6290 bfd_byte
*lo16_location
;
6293 if (r_type
== R_MIPS16_HI16
)
6294 lo16_type
= R_MIPS16_LO16
;
6296 lo16_type
= R_MIPS_LO16
;
6298 /* The combined value is the sum of the HI16 addend,
6299 left-shifted by sixteen bits, and the LO16
6300 addend, sign extended. (Usually, the code does
6301 a `lui' of the HI16 value, and then an `addiu' of
6304 Scan ahead to find a matching LO16 relocation.
6306 According to the MIPS ELF ABI, the R_MIPS_LO16
6307 relocation must be immediately following.
6308 However, for the IRIX6 ABI, the next relocation
6309 may be a composed relocation consisting of
6310 several relocations for the same address. In
6311 that case, the R_MIPS_LO16 relocation may occur
6312 as one of these. We permit a similar extension
6313 in general, as that is useful for GCC. */
6314 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
6317 if (lo16_relocation
== NULL
)
6320 lo16_location
= contents
+ lo16_relocation
->r_offset
;
6322 /* Obtain the addend kept there. */
6323 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
6325 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
6327 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6328 input_bfd
, contents
);
6329 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
6331 l
&= lo16_howto
->src_mask
;
6332 l
<<= lo16_howto
->rightshift
;
6333 l
= _bfd_mips_elf_sign_extend (l
, 16);
6337 /* Compute the combined addend. */
6341 addend
<<= howto
->rightshift
;
6344 addend
= rel
->r_addend
;
6347 if (info
->relocatable
)
6349 Elf_Internal_Sym
*sym
;
6350 unsigned long r_symndx
;
6352 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6353 && bfd_big_endian (input_bfd
))
6356 /* Since we're just relocating, all we need to do is copy
6357 the relocations back out to the object file, unless
6358 they're against a section symbol, in which case we need
6359 to adjust by the section offset, or unless they're GP
6360 relative in which case we need to adjust by the amount
6361 that we're adjusting GP in this relocatable object. */
6363 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6365 /* There's nothing to do for non-local relocations. */
6368 if (r_type
== R_MIPS16_GPREL
6369 || r_type
== R_MIPS_GPREL16
6370 || r_type
== R_MIPS_GPREL32
6371 || r_type
== R_MIPS_LITERAL
)
6372 addend
-= (_bfd_get_gp_value (output_bfd
)
6373 - _bfd_get_gp_value (input_bfd
));
6375 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6376 sym
= local_syms
+ r_symndx
;
6377 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6378 /* Adjust the addend appropriately. */
6379 addend
+= local_sections
[r_symndx
]->output_offset
;
6381 if (rela_relocation_p
)
6382 /* If this is a RELA relocation, just update the addend. */
6383 rel
->r_addend
= addend
;
6386 if (r_type
== R_MIPS_HI16
6387 || r_type
== R_MIPS_GOT16
)
6388 addend
= mips_elf_high (addend
);
6389 else if (r_type
== R_MIPS_HIGHER
)
6390 addend
= mips_elf_higher (addend
);
6391 else if (r_type
== R_MIPS_HIGHEST
)
6392 addend
= mips_elf_highest (addend
);
6394 addend
>>= howto
->rightshift
;
6396 /* We use the source mask, rather than the destination
6397 mask because the place to which we are writing will be
6398 source of the addend in the final link. */
6399 addend
&= howto
->src_mask
;
6401 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6402 /* See the comment above about using R_MIPS_64 in the 32-bit
6403 ABI. Here, we need to update the addend. It would be
6404 possible to get away with just using the R_MIPS_32 reloc
6405 but for endianness. */
6411 if (addend
& ((bfd_vma
) 1 << 31))
6413 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6420 /* If we don't know that we have a 64-bit type,
6421 do two separate stores. */
6422 if (bfd_big_endian (input_bfd
))
6424 /* Store the sign-bits (which are most significant)
6426 low_bits
= sign_bits
;
6432 high_bits
= sign_bits
;
6434 bfd_put_32 (input_bfd
, low_bits
,
6435 contents
+ rel
->r_offset
);
6436 bfd_put_32 (input_bfd
, high_bits
,
6437 contents
+ rel
->r_offset
+ 4);
6441 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6442 input_bfd
, input_section
,
6447 /* Go on to the next relocation. */
6451 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6452 relocations for the same offset. In that case we are
6453 supposed to treat the output of each relocation as the addend
6455 if (rel
+ 1 < relend
6456 && rel
->r_offset
== rel
[1].r_offset
6457 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6458 use_saved_addend_p
= TRUE
;
6460 use_saved_addend_p
= FALSE
;
6462 /* Figure out what value we are supposed to relocate. */
6463 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6464 input_section
, info
, rel
,
6465 addend
, howto
, local_syms
,
6466 local_sections
, &value
,
6467 &name
, &require_jalx
,
6468 use_saved_addend_p
))
6470 case bfd_reloc_continue
:
6471 /* There's nothing to do. */
6474 case bfd_reloc_undefined
:
6475 /* mips_elf_calculate_relocation already called the
6476 undefined_symbol callback. There's no real point in
6477 trying to perform the relocation at this point, so we
6478 just skip ahead to the next relocation. */
6481 case bfd_reloc_notsupported
:
6482 msg
= _("internal error: unsupported relocation error");
6483 info
->callbacks
->warning
6484 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6487 case bfd_reloc_overflow
:
6488 if (use_saved_addend_p
)
6489 /* Ignore overflow until we reach the last relocation for
6490 a given location. */
6494 BFD_ASSERT (name
!= NULL
);
6495 if (! ((*info
->callbacks
->reloc_overflow
)
6496 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
6497 input_bfd
, input_section
, rel
->r_offset
)))
6510 /* If we've got another relocation for the address, keep going
6511 until we reach the last one. */
6512 if (use_saved_addend_p
)
6518 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6519 /* See the comment above about using R_MIPS_64 in the 32-bit
6520 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6521 that calculated the right value. Now, however, we
6522 sign-extend the 32-bit result to 64-bits, and store it as a
6523 64-bit value. We are especially generous here in that we
6524 go to extreme lengths to support this usage on systems with
6525 only a 32-bit VMA. */
6531 if (value
& ((bfd_vma
) 1 << 31))
6533 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6540 /* If we don't know that we have a 64-bit type,
6541 do two separate stores. */
6542 if (bfd_big_endian (input_bfd
))
6544 /* Undo what we did above. */
6546 /* Store the sign-bits (which are most significant)
6548 low_bits
= sign_bits
;
6554 high_bits
= sign_bits
;
6556 bfd_put_32 (input_bfd
, low_bits
,
6557 contents
+ rel
->r_offset
);
6558 bfd_put_32 (input_bfd
, high_bits
,
6559 contents
+ rel
->r_offset
+ 4);
6563 /* Actually perform the relocation. */
6564 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6565 input_bfd
, input_section
,
6566 contents
, require_jalx
))
6573 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6574 adjust it appropriately now. */
6577 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6578 const char *name
, Elf_Internal_Sym
*sym
)
6580 /* The linker script takes care of providing names and values for
6581 these, but we must place them into the right sections. */
6582 static const char* const text_section_symbols
[] = {
6585 "__dso_displacement",
6587 "__program_header_table",
6591 static const char* const data_section_symbols
[] = {
6599 const char* const *p
;
6602 for (i
= 0; i
< 2; ++i
)
6603 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6606 if (strcmp (*p
, name
) == 0)
6608 /* All of these symbols are given type STT_SECTION by the
6610 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6611 sym
->st_other
= STO_PROTECTED
;
6613 /* The IRIX linker puts these symbols in special sections. */
6615 sym
->st_shndx
= SHN_MIPS_TEXT
;
6617 sym
->st_shndx
= SHN_MIPS_DATA
;
6623 /* Finish up dynamic symbol handling. We set the contents of various
6624 dynamic sections here. */
6627 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6628 struct bfd_link_info
*info
,
6629 struct elf_link_hash_entry
*h
,
6630 Elf_Internal_Sym
*sym
)
6634 struct mips_got_info
*g
, *gg
;
6637 dynobj
= elf_hash_table (info
)->dynobj
;
6639 if (h
->plt
.offset
!= MINUS_ONE
)
6642 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6644 /* This symbol has a stub. Set it up. */
6646 BFD_ASSERT (h
->dynindx
!= -1);
6648 s
= bfd_get_section_by_name (dynobj
,
6649 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6650 BFD_ASSERT (s
!= NULL
);
6652 /* FIXME: Can h->dynindex be more than 64K? */
6653 if (h
->dynindx
& 0xffff0000)
6656 /* Fill the stub. */
6657 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6658 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6659 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6660 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6662 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
6663 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6665 /* Mark the symbol as undefined. plt.offset != -1 occurs
6666 only for the referenced symbol. */
6667 sym
->st_shndx
= SHN_UNDEF
;
6669 /* The run-time linker uses the st_value field of the symbol
6670 to reset the global offset table entry for this external
6671 to its stub address when unlinking a shared object. */
6672 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
6676 BFD_ASSERT (h
->dynindx
!= -1
6677 || h
->forced_local
);
6679 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6680 BFD_ASSERT (sgot
!= NULL
);
6681 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6682 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6683 BFD_ASSERT (g
!= NULL
);
6685 /* Run through the global symbol table, creating GOT entries for all
6686 the symbols that need them. */
6687 if (g
->global_gotsym
!= NULL
6688 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6693 value
= sym
->st_value
;
6694 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6695 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6698 if (g
->next
&& h
->dynindx
!= -1)
6700 struct mips_got_entry e
, *p
;
6706 e
.abfd
= output_bfd
;
6708 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6710 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6713 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6718 || (elf_hash_table (info
)->dynamic_sections_created
6720 && p
->d
.h
->root
.def_dynamic
6721 && !p
->d
.h
->root
.def_regular
))
6723 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6724 the various compatibility problems, it's easier to mock
6725 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6726 mips_elf_create_dynamic_relocation to calculate the
6727 appropriate addend. */
6728 Elf_Internal_Rela rel
[3];
6730 memset (rel
, 0, sizeof (rel
));
6731 if (ABI_64_P (output_bfd
))
6732 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6734 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6735 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6738 if (! (mips_elf_create_dynamic_relocation
6739 (output_bfd
, info
, rel
,
6740 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6744 entry
= sym
->st_value
;
6745 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6750 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6751 name
= h
->root
.root
.string
;
6752 if (strcmp (name
, "_DYNAMIC") == 0
6753 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6754 sym
->st_shndx
= SHN_ABS
;
6755 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6756 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6758 sym
->st_shndx
= SHN_ABS
;
6759 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6762 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6764 sym
->st_shndx
= SHN_ABS
;
6765 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6766 sym
->st_value
= elf_gp (output_bfd
);
6768 else if (SGI_COMPAT (output_bfd
))
6770 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6771 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6773 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6774 sym
->st_other
= STO_PROTECTED
;
6776 sym
->st_shndx
= SHN_MIPS_DATA
;
6778 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6780 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6781 sym
->st_other
= STO_PROTECTED
;
6782 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6783 sym
->st_shndx
= SHN_ABS
;
6785 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6787 if (h
->type
== STT_FUNC
)
6788 sym
->st_shndx
= SHN_MIPS_TEXT
;
6789 else if (h
->type
== STT_OBJECT
)
6790 sym
->st_shndx
= SHN_MIPS_DATA
;
6794 /* Handle the IRIX6-specific symbols. */
6795 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6796 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6800 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6801 && (strcmp (name
, "__rld_map") == 0
6802 || strcmp (name
, "__RLD_MAP") == 0))
6804 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6805 BFD_ASSERT (s
!= NULL
);
6806 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6807 bfd_put_32 (output_bfd
, 0, s
->contents
);
6808 if (mips_elf_hash_table (info
)->rld_value
== 0)
6809 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6811 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6812 && strcmp (name
, "__rld_obj_head") == 0)
6814 /* IRIX6 does not use a .rld_map section. */
6815 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6816 || IRIX_COMPAT (output_bfd
) == ict_none
)
6817 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6819 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6823 /* If this is a mips16 symbol, force the value to be even. */
6824 if (sym
->st_other
== STO_MIPS16
)
6825 sym
->st_value
&= ~1;
6830 /* Finish up the dynamic sections. */
6833 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6834 struct bfd_link_info
*info
)
6839 struct mips_got_info
*gg
, *g
;
6841 dynobj
= elf_hash_table (info
)->dynobj
;
6843 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6845 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6850 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6851 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6852 BFD_ASSERT (gg
!= NULL
);
6853 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6854 BFD_ASSERT (g
!= NULL
);
6857 if (elf_hash_table (info
)->dynamic_sections_created
)
6861 BFD_ASSERT (sdyn
!= NULL
);
6862 BFD_ASSERT (g
!= NULL
);
6864 for (b
= sdyn
->contents
;
6865 b
< sdyn
->contents
+ sdyn
->size
;
6866 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6868 Elf_Internal_Dyn dyn
;
6872 bfd_boolean swap_out_p
;
6874 /* Read in the current dynamic entry. */
6875 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6877 /* Assume that we're going to modify it and write it out. */
6883 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6884 BFD_ASSERT (s
!= NULL
);
6885 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6889 /* Rewrite DT_STRSZ. */
6891 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6896 s
= bfd_get_section_by_name (output_bfd
, name
);
6897 BFD_ASSERT (s
!= NULL
);
6898 dyn
.d_un
.d_ptr
= s
->vma
;
6901 case DT_MIPS_RLD_VERSION
:
6902 dyn
.d_un
.d_val
= 1; /* XXX */
6906 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6909 case DT_MIPS_TIME_STAMP
:
6910 time ((time_t *) &dyn
.d_un
.d_val
);
6913 case DT_MIPS_ICHECKSUM
:
6918 case DT_MIPS_IVERSION
:
6923 case DT_MIPS_BASE_ADDRESS
:
6924 s
= output_bfd
->sections
;
6925 BFD_ASSERT (s
!= NULL
);
6926 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6929 case DT_MIPS_LOCAL_GOTNO
:
6930 dyn
.d_un
.d_val
= g
->local_gotno
;
6933 case DT_MIPS_UNREFEXTNO
:
6934 /* The index into the dynamic symbol table which is the
6935 entry of the first external symbol that is not
6936 referenced within the same object. */
6937 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6940 case DT_MIPS_GOTSYM
:
6941 if (gg
->global_gotsym
)
6943 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6946 /* In case if we don't have global got symbols we default
6947 to setting DT_MIPS_GOTSYM to the same value as
6948 DT_MIPS_SYMTABNO, so we just fall through. */
6950 case DT_MIPS_SYMTABNO
:
6952 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6953 s
= bfd_get_section_by_name (output_bfd
, name
);
6954 BFD_ASSERT (s
!= NULL
);
6956 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
6959 case DT_MIPS_HIPAGENO
:
6960 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6963 case DT_MIPS_RLD_MAP
:
6964 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6967 case DT_MIPS_OPTIONS
:
6968 s
= (bfd_get_section_by_name
6969 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6970 dyn
.d_un
.d_ptr
= s
->vma
;
6974 /* Reduce DT_RELSZ to account for any relocations we
6975 decided not to make. This is for the n64 irix rld,
6976 which doesn't seem to apply any relocations if there
6977 are trailing null entries. */
6978 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6979 dyn
.d_un
.d_val
= (s
->reloc_count
6980 * (ABI_64_P (output_bfd
)
6981 ? sizeof (Elf64_Mips_External_Rel
)
6982 : sizeof (Elf32_External_Rel
)));
6991 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6996 /* The first entry of the global offset table will be filled at
6997 runtime. The second entry will be used by some runtime loaders.
6998 This isn't the case of IRIX rld. */
6999 if (sgot
!= NULL
&& sgot
->size
> 0)
7001 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
7002 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
7003 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7007 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7008 = MIPS_ELF_GOT_SIZE (output_bfd
);
7010 /* Generate dynamic relocations for the non-primary gots. */
7011 if (gg
!= NULL
&& gg
->next
)
7013 Elf_Internal_Rela rel
[3];
7016 memset (rel
, 0, sizeof (rel
));
7017 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7019 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7021 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7023 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7024 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7025 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7026 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7031 while (index
< g
->assigned_gotno
)
7033 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7034 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7035 if (!(mips_elf_create_dynamic_relocation
7036 (output_bfd
, info
, rel
, NULL
,
7037 bfd_abs_section_ptr
,
7040 BFD_ASSERT (addend
== 0);
7047 Elf32_compact_rel cpt
;
7049 if (SGI_COMPAT (output_bfd
))
7051 /* Write .compact_rel section out. */
7052 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7056 cpt
.num
= s
->reloc_count
;
7058 cpt
.offset
= (s
->output_section
->filepos
7059 + sizeof (Elf32_External_compact_rel
));
7062 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7063 ((Elf32_External_compact_rel
*)
7066 /* Clean up a dummy stub function entry in .text. */
7067 s
= bfd_get_section_by_name (dynobj
,
7068 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7071 file_ptr dummy_offset
;
7073 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE
);
7074 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE
;
7075 memset (s
->contents
+ dummy_offset
, 0,
7076 MIPS_FUNCTION_STUB_SIZE
);
7081 /* We need to sort the entries of the dynamic relocation section. */
7083 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7086 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7088 reldyn_sorting_bfd
= output_bfd
;
7090 if (ABI_64_P (output_bfd
))
7091 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7092 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7094 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7095 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7103 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7106 mips_set_isa_flags (bfd
*abfd
)
7110 switch (bfd_get_mach (abfd
))
7113 case bfd_mach_mips3000
:
7114 val
= E_MIPS_ARCH_1
;
7117 case bfd_mach_mips3900
:
7118 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7121 case bfd_mach_mips6000
:
7122 val
= E_MIPS_ARCH_2
;
7125 case bfd_mach_mips4000
:
7126 case bfd_mach_mips4300
:
7127 case bfd_mach_mips4400
:
7128 case bfd_mach_mips4600
:
7129 val
= E_MIPS_ARCH_3
;
7132 case bfd_mach_mips4010
:
7133 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7136 case bfd_mach_mips4100
:
7137 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7140 case bfd_mach_mips4111
:
7141 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7144 case bfd_mach_mips4120
:
7145 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7148 case bfd_mach_mips4650
:
7149 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7152 case bfd_mach_mips5400
:
7153 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7156 case bfd_mach_mips5500
:
7157 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7160 case bfd_mach_mips9000
:
7161 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
7164 case bfd_mach_mips5000
:
7165 case bfd_mach_mips7000
:
7166 case bfd_mach_mips8000
:
7167 case bfd_mach_mips10000
:
7168 case bfd_mach_mips12000
:
7169 val
= E_MIPS_ARCH_4
;
7172 case bfd_mach_mips5
:
7173 val
= E_MIPS_ARCH_5
;
7176 case bfd_mach_mips_sb1
:
7177 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7180 case bfd_mach_mipsisa32
:
7181 val
= E_MIPS_ARCH_32
;
7184 case bfd_mach_mipsisa64
:
7185 val
= E_MIPS_ARCH_64
;
7188 case bfd_mach_mipsisa32r2
:
7189 val
= E_MIPS_ARCH_32R2
;
7192 case bfd_mach_mipsisa64r2
:
7193 val
= E_MIPS_ARCH_64R2
;
7196 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7197 elf_elfheader (abfd
)->e_flags
|= val
;
7202 /* The final processing done just before writing out a MIPS ELF object
7203 file. This gets the MIPS architecture right based on the machine
7204 number. This is used by both the 32-bit and the 64-bit ABI. */
7207 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7208 bfd_boolean linker ATTRIBUTE_UNUSED
)
7211 Elf_Internal_Shdr
**hdrpp
;
7215 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7216 is nonzero. This is for compatibility with old objects, which used
7217 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7218 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7219 mips_set_isa_flags (abfd
);
7221 /* Set the sh_info field for .gptab sections and other appropriate
7222 info for each special section. */
7223 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7224 i
< elf_numsections (abfd
);
7227 switch ((*hdrpp
)->sh_type
)
7230 case SHT_MIPS_LIBLIST
:
7231 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7233 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7236 case SHT_MIPS_GPTAB
:
7237 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7238 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7239 BFD_ASSERT (name
!= NULL
7240 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7241 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7242 BFD_ASSERT (sec
!= NULL
);
7243 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7246 case SHT_MIPS_CONTENT
:
7247 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7248 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7249 BFD_ASSERT (name
!= NULL
7250 && strncmp (name
, ".MIPS.content",
7251 sizeof ".MIPS.content" - 1) == 0);
7252 sec
= bfd_get_section_by_name (abfd
,
7253 name
+ sizeof ".MIPS.content" - 1);
7254 BFD_ASSERT (sec
!= NULL
);
7255 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7258 case SHT_MIPS_SYMBOL_LIB
:
7259 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7261 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7262 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7264 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7267 case SHT_MIPS_EVENTS
:
7268 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7269 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7270 BFD_ASSERT (name
!= NULL
);
7271 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7272 sec
= bfd_get_section_by_name (abfd
,
7273 name
+ sizeof ".MIPS.events" - 1);
7276 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7277 sizeof ".MIPS.post_rel" - 1) == 0);
7278 sec
= bfd_get_section_by_name (abfd
,
7280 + sizeof ".MIPS.post_rel" - 1));
7282 BFD_ASSERT (sec
!= NULL
);
7283 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7290 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7294 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7299 /* See if we need a PT_MIPS_REGINFO segment. */
7300 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7301 if (s
&& (s
->flags
& SEC_LOAD
))
7304 /* See if we need a PT_MIPS_OPTIONS segment. */
7305 if (IRIX_COMPAT (abfd
) == ict_irix6
7306 && bfd_get_section_by_name (abfd
,
7307 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7310 /* See if we need a PT_MIPS_RTPROC segment. */
7311 if (IRIX_COMPAT (abfd
) == ict_irix5
7312 && bfd_get_section_by_name (abfd
, ".dynamic")
7313 && bfd_get_section_by_name (abfd
, ".mdebug"))
7319 /* Modify the segment map for an IRIX5 executable. */
7322 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7323 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7326 struct elf_segment_map
*m
, **pm
;
7329 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7331 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7332 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7334 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7335 if (m
->p_type
== PT_MIPS_REGINFO
)
7340 m
= bfd_zalloc (abfd
, amt
);
7344 m
->p_type
= PT_MIPS_REGINFO
;
7348 /* We want to put it after the PHDR and INTERP segments. */
7349 pm
= &elf_tdata (abfd
)->segment_map
;
7351 && ((*pm
)->p_type
== PT_PHDR
7352 || (*pm
)->p_type
== PT_INTERP
))
7360 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7361 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7362 PT_MIPS_OPTIONS segment immediately following the program header
7365 /* On non-IRIX6 new abi, we'll have already created a segment
7366 for this section, so don't create another. I'm not sure this
7367 is not also the case for IRIX 6, but I can't test it right
7369 && IRIX_COMPAT (abfd
) == ict_irix6
)
7371 for (s
= abfd
->sections
; s
; s
= s
->next
)
7372 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7377 struct elf_segment_map
*options_segment
;
7379 pm
= &elf_tdata (abfd
)->segment_map
;
7381 && ((*pm
)->p_type
== PT_PHDR
7382 || (*pm
)->p_type
== PT_INTERP
))
7385 amt
= sizeof (struct elf_segment_map
);
7386 options_segment
= bfd_zalloc (abfd
, amt
);
7387 options_segment
->next
= *pm
;
7388 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7389 options_segment
->p_flags
= PF_R
;
7390 options_segment
->p_flags_valid
= TRUE
;
7391 options_segment
->count
= 1;
7392 options_segment
->sections
[0] = s
;
7393 *pm
= options_segment
;
7398 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7400 /* If there are .dynamic and .mdebug sections, we make a room
7401 for the RTPROC header. FIXME: Rewrite without section names. */
7402 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7403 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7404 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7406 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7407 if (m
->p_type
== PT_MIPS_RTPROC
)
7412 m
= bfd_zalloc (abfd
, amt
);
7416 m
->p_type
= PT_MIPS_RTPROC
;
7418 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7423 m
->p_flags_valid
= 1;
7431 /* We want to put it after the DYNAMIC segment. */
7432 pm
= &elf_tdata (abfd
)->segment_map
;
7433 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7443 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7444 .dynstr, .dynsym, and .hash sections, and everything in
7446 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7448 if ((*pm
)->p_type
== PT_DYNAMIC
)
7451 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7453 /* For a normal mips executable the permissions for the PT_DYNAMIC
7454 segment are read, write and execute. We do that here since
7455 the code in elf.c sets only the read permission. This matters
7456 sometimes for the dynamic linker. */
7457 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7459 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7460 m
->p_flags_valid
= 1;
7464 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7466 static const char *sec_names
[] =
7468 ".dynamic", ".dynstr", ".dynsym", ".hash"
7472 struct elf_segment_map
*n
;
7476 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7478 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7479 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7486 if (high
< s
->vma
+ sz
)
7492 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7493 if ((s
->flags
& SEC_LOAD
) != 0
7495 && s
->vma
+ s
->size
<= high
)
7498 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7499 n
= bfd_zalloc (abfd
, amt
);
7506 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7508 if ((s
->flags
& SEC_LOAD
) != 0
7510 && s
->vma
+ s
->size
<= high
)
7524 /* Return the section that should be marked against GC for a given
7528 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7529 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7530 Elf_Internal_Rela
*rel
,
7531 struct elf_link_hash_entry
*h
,
7532 Elf_Internal_Sym
*sym
)
7534 /* ??? Do mips16 stub sections need to be handled special? */
7538 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7540 case R_MIPS_GNU_VTINHERIT
:
7541 case R_MIPS_GNU_VTENTRY
:
7545 switch (h
->root
.type
)
7547 case bfd_link_hash_defined
:
7548 case bfd_link_hash_defweak
:
7549 return h
->root
.u
.def
.section
;
7551 case bfd_link_hash_common
:
7552 return h
->root
.u
.c
.p
->section
;
7560 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7565 /* Update the got entry reference counts for the section being removed. */
7568 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7569 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7570 asection
*sec ATTRIBUTE_UNUSED
,
7571 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7574 Elf_Internal_Shdr
*symtab_hdr
;
7575 struct elf_link_hash_entry
**sym_hashes
;
7576 bfd_signed_vma
*local_got_refcounts
;
7577 const Elf_Internal_Rela
*rel
, *relend
;
7578 unsigned long r_symndx
;
7579 struct elf_link_hash_entry
*h
;
7581 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7582 sym_hashes
= elf_sym_hashes (abfd
);
7583 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7585 relend
= relocs
+ sec
->reloc_count
;
7586 for (rel
= relocs
; rel
< relend
; rel
++)
7587 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7591 case R_MIPS_CALL_HI16
:
7592 case R_MIPS_CALL_LO16
:
7593 case R_MIPS_GOT_HI16
:
7594 case R_MIPS_GOT_LO16
:
7595 case R_MIPS_GOT_DISP
:
7596 case R_MIPS_GOT_PAGE
:
7597 case R_MIPS_GOT_OFST
:
7598 /* ??? It would seem that the existing MIPS code does no sort
7599 of reference counting or whatnot on its GOT and PLT entries,
7600 so it is not possible to garbage collect them at this time. */
7611 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7612 hiding the old indirect symbol. Process additional relocation
7613 information. Also called for weakdefs, in which case we just let
7614 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7617 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7618 struct elf_link_hash_entry
*dir
,
7619 struct elf_link_hash_entry
*ind
)
7621 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7623 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7625 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7628 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7629 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7630 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7631 if (indmips
->readonly_reloc
)
7632 dirmips
->readonly_reloc
= TRUE
;
7633 if (indmips
->no_fn_stub
)
7634 dirmips
->no_fn_stub
= TRUE
;
7638 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7639 struct elf_link_hash_entry
*entry
,
7640 bfd_boolean force_local
)
7644 struct mips_got_info
*g
;
7645 struct mips_elf_link_hash_entry
*h
;
7647 h
= (struct mips_elf_link_hash_entry
*) entry
;
7648 if (h
->forced_local
)
7650 h
->forced_local
= force_local
;
7652 dynobj
= elf_hash_table (info
)->dynobj
;
7653 if (dynobj
!= NULL
&& force_local
)
7655 got
= mips_elf_got_section (dynobj
, FALSE
);
7656 g
= mips_elf_section_data (got
)->u
.got_info
;
7660 struct mips_got_entry e
;
7661 struct mips_got_info
*gg
= g
;
7663 /* Since we're turning what used to be a global symbol into a
7664 local one, bump up the number of local entries of each GOT
7665 that had an entry for it. This will automatically decrease
7666 the number of global entries, since global_gotno is actually
7667 the upper limit of global entries. */
7672 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7673 if (htab_find (g
->got_entries
, &e
))
7675 BFD_ASSERT (g
->global_gotno
> 0);
7680 /* If this was a global symbol forced into the primary GOT, we
7681 no longer need an entry for it. We can't release the entry
7682 at this point, but we must at least stop counting it as one
7683 of the symbols that required a forced got entry. */
7684 if (h
->root
.got
.offset
== 2)
7686 BFD_ASSERT (gg
->assigned_gotno
> 0);
7687 gg
->assigned_gotno
--;
7690 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7691 /* If we haven't got through GOT allocation yet, just bump up the
7692 number of local entries, as this symbol won't be counted as
7695 else if (h
->root
.got
.offset
== 1)
7697 /* If we're past non-multi-GOT allocation and this symbol had
7698 been marked for a global got entry, give it a local entry
7700 BFD_ASSERT (g
->global_gotno
> 0);
7706 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7712 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7713 struct bfd_link_info
*info
)
7716 bfd_boolean ret
= FALSE
;
7717 unsigned char *tdata
;
7720 o
= bfd_get_section_by_name (abfd
, ".pdr");
7725 if (o
->size
% PDR_SIZE
!= 0)
7727 if (o
->output_section
!= NULL
7728 && bfd_is_abs_section (o
->output_section
))
7731 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
7735 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7743 cookie
->rel
= cookie
->rels
;
7744 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7746 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
7748 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
7757 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7758 o
->size
-= skip
* PDR_SIZE
;
7764 if (! info
->keep_memory
)
7765 free (cookie
->rels
);
7771 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7773 if (strcmp (sec
->name
, ".pdr") == 0)
7779 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7782 bfd_byte
*to
, *from
, *end
;
7785 if (strcmp (sec
->name
, ".pdr") != 0)
7788 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7792 end
= contents
+ sec
->size
;
7793 for (from
= contents
, i
= 0;
7795 from
+= PDR_SIZE
, i
++)
7797 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7800 memcpy (to
, from
, PDR_SIZE
);
7803 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7804 sec
->output_offset
, sec
->size
);
7808 /* MIPS ELF uses a special find_nearest_line routine in order the
7809 handle the ECOFF debugging information. */
7811 struct mips_elf_find_line
7813 struct ecoff_debug_info d
;
7814 struct ecoff_find_line i
;
7818 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7819 asymbol
**symbols
, bfd_vma offset
,
7820 const char **filename_ptr
,
7821 const char **functionname_ptr
,
7822 unsigned int *line_ptr
)
7826 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7827 filename_ptr
, functionname_ptr
,
7831 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7832 filename_ptr
, functionname_ptr
,
7833 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7834 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7837 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7841 struct mips_elf_find_line
*fi
;
7842 const struct ecoff_debug_swap
* const swap
=
7843 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7845 /* If we are called during a link, mips_elf_final_link may have
7846 cleared the SEC_HAS_CONTENTS field. We force it back on here
7847 if appropriate (which it normally will be). */
7848 origflags
= msec
->flags
;
7849 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7850 msec
->flags
|= SEC_HAS_CONTENTS
;
7852 fi
= elf_tdata (abfd
)->find_line_info
;
7855 bfd_size_type external_fdr_size
;
7858 struct fdr
*fdr_ptr
;
7859 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7861 fi
= bfd_zalloc (abfd
, amt
);
7864 msec
->flags
= origflags
;
7868 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7870 msec
->flags
= origflags
;
7874 /* Swap in the FDR information. */
7875 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7876 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7877 if (fi
->d
.fdr
== NULL
)
7879 msec
->flags
= origflags
;
7882 external_fdr_size
= swap
->external_fdr_size
;
7883 fdr_ptr
= fi
->d
.fdr
;
7884 fraw_src
= (char *) fi
->d
.external_fdr
;
7885 fraw_end
= (fraw_src
7886 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7887 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7888 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7890 elf_tdata (abfd
)->find_line_info
= fi
;
7892 /* Note that we don't bother to ever free this information.
7893 find_nearest_line is either called all the time, as in
7894 objdump -l, so the information should be saved, or it is
7895 rarely called, as in ld error messages, so the memory
7896 wasted is unimportant. Still, it would probably be a
7897 good idea for free_cached_info to throw it away. */
7900 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7901 &fi
->i
, filename_ptr
, functionname_ptr
,
7904 msec
->flags
= origflags
;
7908 msec
->flags
= origflags
;
7911 /* Fall back on the generic ELF find_nearest_line routine. */
7913 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7914 filename_ptr
, functionname_ptr
,
7918 /* When are writing out the .options or .MIPS.options section,
7919 remember the bytes we are writing out, so that we can install the
7920 GP value in the section_processing routine. */
7923 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7924 const void *location
,
7925 file_ptr offset
, bfd_size_type count
)
7927 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7931 if (elf_section_data (section
) == NULL
)
7933 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7934 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7935 if (elf_section_data (section
) == NULL
)
7938 c
= mips_elf_section_data (section
)->u
.tdata
;
7941 c
= bfd_zalloc (abfd
, section
->size
);
7944 mips_elf_section_data (section
)->u
.tdata
= c
;
7947 memcpy (c
+ offset
, location
, count
);
7950 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7954 /* This is almost identical to bfd_generic_get_... except that some
7955 MIPS relocations need to be handled specially. Sigh. */
7958 _bfd_elf_mips_get_relocated_section_contents
7960 struct bfd_link_info
*link_info
,
7961 struct bfd_link_order
*link_order
,
7963 bfd_boolean relocatable
,
7966 /* Get enough memory to hold the stuff */
7967 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7968 asection
*input_section
= link_order
->u
.indirect
.section
;
7971 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7972 arelent
**reloc_vector
= NULL
;
7978 reloc_vector
= bfd_malloc (reloc_size
);
7979 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7982 /* read in the section */
7983 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
7984 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
7987 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7991 if (reloc_count
< 0)
7994 if (reloc_count
> 0)
7999 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8002 struct bfd_hash_entry
*h
;
8003 struct bfd_link_hash_entry
*lh
;
8004 /* Skip all this stuff if we aren't mixing formats. */
8005 if (abfd
&& input_bfd
8006 && abfd
->xvec
== input_bfd
->xvec
)
8010 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8011 lh
= (struct bfd_link_hash_entry
*) h
;
8018 case bfd_link_hash_undefined
:
8019 case bfd_link_hash_undefweak
:
8020 case bfd_link_hash_common
:
8023 case bfd_link_hash_defined
:
8024 case bfd_link_hash_defweak
:
8026 gp
= lh
->u
.def
.value
;
8028 case bfd_link_hash_indirect
:
8029 case bfd_link_hash_warning
:
8031 /* @@FIXME ignoring warning for now */
8033 case bfd_link_hash_new
:
8042 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8044 char *error_message
= NULL
;
8045 bfd_reloc_status_type r
;
8047 /* Specific to MIPS: Deal with relocation types that require
8048 knowing the gp of the output bfd. */
8049 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8050 if (bfd_is_abs_section (sym
->section
) && abfd
)
8052 /* The special_function wouldn't get called anyway. */
8056 /* The gp isn't there; let the special function code
8057 fall over on its own. */
8059 else if ((*parent
)->howto
->special_function
8060 == _bfd_mips_elf32_gprel16_reloc
)
8062 /* bypass special_function call */
8063 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8064 input_section
, relocatable
,
8066 goto skip_bfd_perform_relocation
;
8068 /* end mips specific stuff */
8070 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8071 relocatable
? abfd
: NULL
,
8073 skip_bfd_perform_relocation
:
8077 asection
*os
= input_section
->output_section
;
8079 /* A partial link, so keep the relocs */
8080 os
->orelocation
[os
->reloc_count
] = *parent
;
8084 if (r
!= bfd_reloc_ok
)
8088 case bfd_reloc_undefined
:
8089 if (!((*link_info
->callbacks
->undefined_symbol
)
8090 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8091 input_bfd
, input_section
, (*parent
)->address
,
8095 case bfd_reloc_dangerous
:
8096 BFD_ASSERT (error_message
!= NULL
);
8097 if (!((*link_info
->callbacks
->reloc_dangerous
)
8098 (link_info
, error_message
, input_bfd
, input_section
,
8099 (*parent
)->address
)))
8102 case bfd_reloc_overflow
:
8103 if (!((*link_info
->callbacks
->reloc_overflow
)
8105 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8106 (*parent
)->howto
->name
, (*parent
)->addend
,
8107 input_bfd
, input_section
, (*parent
)->address
)))
8110 case bfd_reloc_outofrange
:
8119 if (reloc_vector
!= NULL
)
8120 free (reloc_vector
);
8124 if (reloc_vector
!= NULL
)
8125 free (reloc_vector
);
8129 /* Create a MIPS ELF linker hash table. */
8131 struct bfd_link_hash_table
*
8132 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8134 struct mips_elf_link_hash_table
*ret
;
8135 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8137 ret
= bfd_malloc (amt
);
8141 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8142 mips_elf_link_hash_newfunc
))
8149 /* We no longer use this. */
8150 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8151 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8153 ret
->procedure_count
= 0;
8154 ret
->compact_rel_size
= 0;
8155 ret
->use_rld_obj_head
= FALSE
;
8157 ret
->mips16_stubs_seen
= FALSE
;
8159 return &ret
->root
.root
;
8162 /* We need to use a special link routine to handle the .reginfo and
8163 the .mdebug sections. We need to merge all instances of these
8164 sections together, not write them all out sequentially. */
8167 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8171 struct bfd_link_order
*p
;
8172 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8173 asection
*rtproc_sec
;
8174 Elf32_RegInfo reginfo
;
8175 struct ecoff_debug_info debug
;
8176 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8177 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
8178 HDRR
*symhdr
= &debug
.symbolic_header
;
8179 void *mdebug_handle
= NULL
;
8185 static const char * const secname
[] =
8187 ".text", ".init", ".fini", ".data",
8188 ".rodata", ".sdata", ".sbss", ".bss"
8190 static const int sc
[] =
8192 scText
, scInit
, scFini
, scData
,
8193 scRData
, scSData
, scSBss
, scBss
8196 /* We'd carefully arranged the dynamic symbol indices, and then the
8197 generic size_dynamic_sections renumbered them out from under us.
8198 Rather than trying somehow to prevent the renumbering, just do
8200 if (elf_hash_table (info
)->dynamic_sections_created
)
8204 struct mips_got_info
*g
;
8205 bfd_size_type dynsecsymcount
;
8207 /* When we resort, we must tell mips_elf_sort_hash_table what
8208 the lowest index it may use is. That's the number of section
8209 symbols we're going to add. The generic ELF linker only
8210 adds these symbols when building a shared object. Note that
8211 we count the sections after (possibly) removing the .options
8219 for (p
= abfd
->sections
; p
; p
= p
->next
)
8220 if ((p
->flags
& SEC_EXCLUDE
) == 0
8221 && (p
->flags
& SEC_ALLOC
) != 0
8222 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
8226 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
8229 /* Make sure we didn't grow the global .got region. */
8230 dynobj
= elf_hash_table (info
)->dynobj
;
8231 got
= mips_elf_got_section (dynobj
, FALSE
);
8232 g
= mips_elf_section_data (got
)->u
.got_info
;
8234 if (g
->global_gotsym
!= NULL
)
8235 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8236 - g
->global_gotsym
->dynindx
)
8237 <= g
->global_gotno
);
8241 /* We want to set the GP value for ld -r. */
8242 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8243 include it, even though we don't process it quite right. (Some
8244 entries are supposed to be merged.) Empirically, we seem to be
8245 better off including it then not. */
8246 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8247 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8249 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8251 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8252 if (p
->type
== bfd_indirect_link_order
)
8253 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8254 (*secpp
)->link_order_head
= NULL
;
8255 bfd_section_list_remove (abfd
, secpp
);
8256 --abfd
->section_count
;
8262 /* We include .MIPS.options, even though we don't process it quite right.
8263 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8264 to be better off including it than not. */
8265 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8267 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8269 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8270 if (p
->type
== bfd_indirect_link_order
)
8271 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8272 (*secpp
)->link_order_head
= NULL
;
8273 bfd_section_list_remove (abfd
, secpp
);
8274 --abfd
->section_count
;
8281 /* Get a value for the GP register. */
8282 if (elf_gp (abfd
) == 0)
8284 struct bfd_link_hash_entry
*h
;
8286 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8287 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8288 elf_gp (abfd
) = (h
->u
.def
.value
8289 + h
->u
.def
.section
->output_section
->vma
8290 + h
->u
.def
.section
->output_offset
);
8291 else if (info
->relocatable
)
8293 bfd_vma lo
= MINUS_ONE
;
8295 /* Find the GP-relative section with the lowest offset. */
8296 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8298 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8301 /* And calculate GP relative to that. */
8302 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8306 /* If the relocate_section function needs to do a reloc
8307 involving the GP value, it should make a reloc_dangerous
8308 callback to warn that GP is not defined. */
8312 /* Go through the sections and collect the .reginfo and .mdebug
8316 gptab_data_sec
= NULL
;
8317 gptab_bss_sec
= NULL
;
8318 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8320 if (strcmp (o
->name
, ".reginfo") == 0)
8322 memset (®info
, 0, sizeof reginfo
);
8324 /* We have found the .reginfo section in the output file.
8325 Look through all the link_orders comprising it and merge
8326 the information together. */
8327 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8329 asection
*input_section
;
8331 Elf32_External_RegInfo ext
;
8334 if (p
->type
!= bfd_indirect_link_order
)
8336 if (p
->type
== bfd_data_link_order
)
8341 input_section
= p
->u
.indirect
.section
;
8342 input_bfd
= input_section
->owner
;
8344 if (! bfd_get_section_contents (input_bfd
, input_section
,
8345 &ext
, 0, sizeof ext
))
8348 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8350 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8351 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8352 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8353 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8354 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8356 /* ri_gp_value is set by the function
8357 mips_elf32_section_processing when the section is
8358 finally written out. */
8360 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8361 elf_link_input_bfd ignores this section. */
8362 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8365 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8366 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
8368 /* Skip this section later on (I don't think this currently
8369 matters, but someday it might). */
8370 o
->link_order_head
= NULL
;
8375 if (strcmp (o
->name
, ".mdebug") == 0)
8377 struct extsym_info einfo
;
8380 /* We have found the .mdebug section in the output file.
8381 Look through all the link_orders comprising it and merge
8382 the information together. */
8383 symhdr
->magic
= swap
->sym_magic
;
8384 /* FIXME: What should the version stamp be? */
8386 symhdr
->ilineMax
= 0;
8390 symhdr
->isymMax
= 0;
8391 symhdr
->ioptMax
= 0;
8392 symhdr
->iauxMax
= 0;
8394 symhdr
->issExtMax
= 0;
8397 symhdr
->iextMax
= 0;
8399 /* We accumulate the debugging information itself in the
8400 debug_info structure. */
8402 debug
.external_dnr
= NULL
;
8403 debug
.external_pdr
= NULL
;
8404 debug
.external_sym
= NULL
;
8405 debug
.external_opt
= NULL
;
8406 debug
.external_aux
= NULL
;
8408 debug
.ssext
= debug
.ssext_end
= NULL
;
8409 debug
.external_fdr
= NULL
;
8410 debug
.external_rfd
= NULL
;
8411 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8413 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8414 if (mdebug_handle
== NULL
)
8418 esym
.cobol_main
= 0;
8422 esym
.asym
.iss
= issNil
;
8423 esym
.asym
.st
= stLocal
;
8424 esym
.asym
.reserved
= 0;
8425 esym
.asym
.index
= indexNil
;
8427 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8429 esym
.asym
.sc
= sc
[i
];
8430 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8433 esym
.asym
.value
= s
->vma
;
8434 last
= s
->vma
+ s
->size
;
8437 esym
.asym
.value
= last
;
8438 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8443 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8445 asection
*input_section
;
8447 const struct ecoff_debug_swap
*input_swap
;
8448 struct ecoff_debug_info input_debug
;
8452 if (p
->type
!= bfd_indirect_link_order
)
8454 if (p
->type
== bfd_data_link_order
)
8459 input_section
= p
->u
.indirect
.section
;
8460 input_bfd
= input_section
->owner
;
8462 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8463 || (get_elf_backend_data (input_bfd
)
8464 ->elf_backend_ecoff_debug_swap
) == NULL
)
8466 /* I don't know what a non MIPS ELF bfd would be
8467 doing with a .mdebug section, but I don't really
8468 want to deal with it. */
8472 input_swap
= (get_elf_backend_data (input_bfd
)
8473 ->elf_backend_ecoff_debug_swap
);
8475 BFD_ASSERT (p
->size
== input_section
->size
);
8477 /* The ECOFF linking code expects that we have already
8478 read in the debugging information and set up an
8479 ecoff_debug_info structure, so we do that now. */
8480 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8484 if (! (bfd_ecoff_debug_accumulate
8485 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8486 &input_debug
, input_swap
, info
)))
8489 /* Loop through the external symbols. For each one with
8490 interesting information, try to find the symbol in
8491 the linker global hash table and save the information
8492 for the output external symbols. */
8493 eraw_src
= input_debug
.external_ext
;
8494 eraw_end
= (eraw_src
8495 + (input_debug
.symbolic_header
.iextMax
8496 * input_swap
->external_ext_size
));
8498 eraw_src
< eraw_end
;
8499 eraw_src
+= input_swap
->external_ext_size
)
8503 struct mips_elf_link_hash_entry
*h
;
8505 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8506 if (ext
.asym
.sc
== scNil
8507 || ext
.asym
.sc
== scUndefined
8508 || ext
.asym
.sc
== scSUndefined
)
8511 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8512 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8513 name
, FALSE
, FALSE
, TRUE
);
8514 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8520 < input_debug
.symbolic_header
.ifdMax
);
8521 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8527 /* Free up the information we just read. */
8528 free (input_debug
.line
);
8529 free (input_debug
.external_dnr
);
8530 free (input_debug
.external_pdr
);
8531 free (input_debug
.external_sym
);
8532 free (input_debug
.external_opt
);
8533 free (input_debug
.external_aux
);
8534 free (input_debug
.ss
);
8535 free (input_debug
.ssext
);
8536 free (input_debug
.external_fdr
);
8537 free (input_debug
.external_rfd
);
8538 free (input_debug
.external_ext
);
8540 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8541 elf_link_input_bfd ignores this section. */
8542 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8545 if (SGI_COMPAT (abfd
) && info
->shared
)
8547 /* Create .rtproc section. */
8548 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8549 if (rtproc_sec
== NULL
)
8551 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8552 | SEC_LINKER_CREATED
| SEC_READONLY
);
8554 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8555 if (rtproc_sec
== NULL
8556 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8557 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8561 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8567 /* Build the external symbol information. */
8570 einfo
.debug
= &debug
;
8572 einfo
.failed
= FALSE
;
8573 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8574 mips_elf_output_extsym
, &einfo
);
8578 /* Set the size of the .mdebug section. */
8579 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8581 /* Skip this section later on (I don't think this currently
8582 matters, but someday it might). */
8583 o
->link_order_head
= NULL
;
8588 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8590 const char *subname
;
8593 Elf32_External_gptab
*ext_tab
;
8596 /* The .gptab.sdata and .gptab.sbss sections hold
8597 information describing how the small data area would
8598 change depending upon the -G switch. These sections
8599 not used in executables files. */
8600 if (! info
->relocatable
)
8602 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8604 asection
*input_section
;
8606 if (p
->type
!= bfd_indirect_link_order
)
8608 if (p
->type
== bfd_data_link_order
)
8613 input_section
= p
->u
.indirect
.section
;
8615 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8616 elf_link_input_bfd ignores this section. */
8617 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8620 /* Skip this section later on (I don't think this
8621 currently matters, but someday it might). */
8622 o
->link_order_head
= NULL
;
8624 /* Really remove the section. */
8625 for (secpp
= &abfd
->sections
;
8627 secpp
= &(*secpp
)->next
)
8629 bfd_section_list_remove (abfd
, secpp
);
8630 --abfd
->section_count
;
8635 /* There is one gptab for initialized data, and one for
8636 uninitialized data. */
8637 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8639 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8643 (*_bfd_error_handler
)
8644 (_("%s: illegal section name `%s'"),
8645 bfd_get_filename (abfd
), o
->name
);
8646 bfd_set_error (bfd_error_nonrepresentable_section
);
8650 /* The linker script always combines .gptab.data and
8651 .gptab.sdata into .gptab.sdata, and likewise for
8652 .gptab.bss and .gptab.sbss. It is possible that there is
8653 no .sdata or .sbss section in the output file, in which
8654 case we must change the name of the output section. */
8655 subname
= o
->name
+ sizeof ".gptab" - 1;
8656 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8658 if (o
== gptab_data_sec
)
8659 o
->name
= ".gptab.data";
8661 o
->name
= ".gptab.bss";
8662 subname
= o
->name
+ sizeof ".gptab" - 1;
8663 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8666 /* Set up the first entry. */
8668 amt
= c
* sizeof (Elf32_gptab
);
8669 tab
= bfd_malloc (amt
);
8672 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8673 tab
[0].gt_header
.gt_unused
= 0;
8675 /* Combine the input sections. */
8676 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8678 asection
*input_section
;
8682 bfd_size_type gpentry
;
8684 if (p
->type
!= bfd_indirect_link_order
)
8686 if (p
->type
== bfd_data_link_order
)
8691 input_section
= p
->u
.indirect
.section
;
8692 input_bfd
= input_section
->owner
;
8694 /* Combine the gptab entries for this input section one
8695 by one. We know that the input gptab entries are
8696 sorted by ascending -G value. */
8697 size
= input_section
->size
;
8699 for (gpentry
= sizeof (Elf32_External_gptab
);
8701 gpentry
+= sizeof (Elf32_External_gptab
))
8703 Elf32_External_gptab ext_gptab
;
8704 Elf32_gptab int_gptab
;
8710 if (! (bfd_get_section_contents
8711 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8712 sizeof (Elf32_External_gptab
))))
8718 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8720 val
= int_gptab
.gt_entry
.gt_g_value
;
8721 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8724 for (look
= 1; look
< c
; look
++)
8726 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8727 tab
[look
].gt_entry
.gt_bytes
+= add
;
8729 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8735 Elf32_gptab
*new_tab
;
8738 /* We need a new table entry. */
8739 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8740 new_tab
= bfd_realloc (tab
, amt
);
8741 if (new_tab
== NULL
)
8747 tab
[c
].gt_entry
.gt_g_value
= val
;
8748 tab
[c
].gt_entry
.gt_bytes
= add
;
8750 /* Merge in the size for the next smallest -G
8751 value, since that will be implied by this new
8754 for (look
= 1; look
< c
; look
++)
8756 if (tab
[look
].gt_entry
.gt_g_value
< val
8758 || (tab
[look
].gt_entry
.gt_g_value
8759 > tab
[max
].gt_entry
.gt_g_value
)))
8763 tab
[c
].gt_entry
.gt_bytes
+=
8764 tab
[max
].gt_entry
.gt_bytes
;
8769 last
= int_gptab
.gt_entry
.gt_bytes
;
8772 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8773 elf_link_input_bfd ignores this section. */
8774 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8777 /* The table must be sorted by -G value. */
8779 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8781 /* Swap out the table. */
8782 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8783 ext_tab
= bfd_alloc (abfd
, amt
);
8784 if (ext_tab
== NULL
)
8790 for (j
= 0; j
< c
; j
++)
8791 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8794 o
->size
= c
* sizeof (Elf32_External_gptab
);
8795 o
->contents
= (bfd_byte
*) ext_tab
;
8797 /* Skip this section later on (I don't think this currently
8798 matters, but someday it might). */
8799 o
->link_order_head
= NULL
;
8803 /* Invoke the regular ELF backend linker to do all the work. */
8804 if (!bfd_elf_final_link (abfd
, info
))
8807 /* Now write out the computed sections. */
8809 if (reginfo_sec
!= NULL
)
8811 Elf32_External_RegInfo ext
;
8813 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8814 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8818 if (mdebug_sec
!= NULL
)
8820 BFD_ASSERT (abfd
->output_has_begun
);
8821 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8823 mdebug_sec
->filepos
))
8826 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8829 if (gptab_data_sec
!= NULL
)
8831 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8832 gptab_data_sec
->contents
,
8833 0, gptab_data_sec
->size
))
8837 if (gptab_bss_sec
!= NULL
)
8839 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8840 gptab_bss_sec
->contents
,
8841 0, gptab_bss_sec
->size
))
8845 if (SGI_COMPAT (abfd
))
8847 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8848 if (rtproc_sec
!= NULL
)
8850 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8851 rtproc_sec
->contents
,
8852 0, rtproc_sec
->size
))
8860 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8862 struct mips_mach_extension
{
8863 unsigned long extension
, base
;
8867 /* An array describing how BFD machines relate to one another. The entries
8868 are ordered topologically with MIPS I extensions listed last. */
8870 static const struct mips_mach_extension mips_mach_extensions
[] = {
8871 /* MIPS64 extensions. */
8872 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8873 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8875 /* MIPS V extensions. */
8876 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8878 /* R10000 extensions. */
8879 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8881 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8882 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8883 better to allow vr5400 and vr5500 code to be merged anyway, since
8884 many libraries will just use the core ISA. Perhaps we could add
8885 some sort of ASE flag if this ever proves a problem. */
8886 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8887 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8889 /* MIPS IV extensions. */
8890 { bfd_mach_mips5
, bfd_mach_mips8000
},
8891 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8892 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8893 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8894 { bfd_mach_mips9000
, bfd_mach_mips8000
},
8896 /* VR4100 extensions. */
8897 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8898 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8900 /* MIPS III extensions. */
8901 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8902 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8903 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8904 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8905 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8906 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8907 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8909 /* MIPS32 extensions. */
8910 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8912 /* MIPS II extensions. */
8913 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8914 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8916 /* MIPS I extensions. */
8917 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8918 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8922 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8925 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8929 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8930 if (extension
== mips_mach_extensions
[i
].extension
)
8931 extension
= mips_mach_extensions
[i
].base
;
8933 return extension
== base
;
8937 /* Return true if the given ELF header flags describe a 32-bit binary. */
8940 mips_32bit_flags_p (flagword flags
)
8942 return ((flags
& EF_MIPS_32BITMODE
) != 0
8943 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8944 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8945 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8946 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8947 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8948 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8952 /* Merge backend specific data from an object file to the output
8953 object file when linking. */
8956 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8961 bfd_boolean null_input_bfd
= TRUE
;
8964 /* Check if we have the same endianess */
8965 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8967 (*_bfd_error_handler
)
8968 (_("%B: endianness incompatible with that of the selected emulation"),
8973 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8974 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8977 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8979 (*_bfd_error_handler
)
8980 (_("%B: ABI is incompatible with that of the selected emulation"),
8985 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8986 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8987 old_flags
= elf_elfheader (obfd
)->e_flags
;
8989 if (! elf_flags_init (obfd
))
8991 elf_flags_init (obfd
) = TRUE
;
8992 elf_elfheader (obfd
)->e_flags
= new_flags
;
8993 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8994 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8996 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8997 && bfd_get_arch_info (obfd
)->the_default
)
8999 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9000 bfd_get_mach (ibfd
)))
9007 /* Check flag compatibility. */
9009 new_flags
&= ~EF_MIPS_NOREORDER
;
9010 old_flags
&= ~EF_MIPS_NOREORDER
;
9012 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9013 doesn't seem to matter. */
9014 new_flags
&= ~EF_MIPS_XGOT
;
9015 old_flags
&= ~EF_MIPS_XGOT
;
9017 /* MIPSpro generates ucode info in n64 objects. Again, we should
9018 just be able to ignore this. */
9019 new_flags
&= ~EF_MIPS_UCODE
;
9020 old_flags
&= ~EF_MIPS_UCODE
;
9022 if (new_flags
== old_flags
)
9025 /* Check to see if the input BFD actually contains any sections.
9026 If not, its flags may not have been initialised either, but it cannot
9027 actually cause any incompatibility. */
9028 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9030 /* Ignore synthetic sections and empty .text, .data and .bss sections
9031 which are automatically generated by gas. */
9032 if (strcmp (sec
->name
, ".reginfo")
9033 && strcmp (sec
->name
, ".mdebug")
9035 || (strcmp (sec
->name
, ".text")
9036 && strcmp (sec
->name
, ".data")
9037 && strcmp (sec
->name
, ".bss"))))
9039 null_input_bfd
= FALSE
;
9048 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9049 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9051 (*_bfd_error_handler
)
9052 (_("%B: warning: linking PIC files with non-PIC files"),
9057 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9058 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9059 if (! (new_flags
& EF_MIPS_PIC
))
9060 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9062 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9063 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9065 /* Compare the ISAs. */
9066 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9068 (*_bfd_error_handler
)
9069 (_("%B: linking 32-bit code with 64-bit code"),
9073 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9075 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9076 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9078 /* Copy the architecture info from IBFD to OBFD. Also copy
9079 the 32-bit flag (if set) so that we continue to recognise
9080 OBFD as a 32-bit binary. */
9081 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9082 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9083 elf_elfheader (obfd
)->e_flags
9084 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9086 /* Copy across the ABI flags if OBFD doesn't use them
9087 and if that was what caused us to treat IBFD as 32-bit. */
9088 if ((old_flags
& EF_MIPS_ABI
) == 0
9089 && mips_32bit_flags_p (new_flags
)
9090 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9091 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9095 /* The ISAs aren't compatible. */
9096 (*_bfd_error_handler
)
9097 (_("%B: linking %s module with previous %s modules"),
9099 bfd_printable_name (ibfd
),
9100 bfd_printable_name (obfd
));
9105 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9106 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9108 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9109 does set EI_CLASS differently from any 32-bit ABI. */
9110 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9111 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9112 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9114 /* Only error if both are set (to different values). */
9115 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9116 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9117 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9119 (*_bfd_error_handler
)
9120 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9122 elf_mips_abi_name (ibfd
),
9123 elf_mips_abi_name (obfd
));
9126 new_flags
&= ~EF_MIPS_ABI
;
9127 old_flags
&= ~EF_MIPS_ABI
;
9130 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9131 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9133 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9135 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9136 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9139 /* Warn about any other mismatches */
9140 if (new_flags
!= old_flags
)
9142 (*_bfd_error_handler
)
9143 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9144 ibfd
, (unsigned long) new_flags
,
9145 (unsigned long) old_flags
);
9151 bfd_set_error (bfd_error_bad_value
);
9158 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9161 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9163 BFD_ASSERT (!elf_flags_init (abfd
)
9164 || elf_elfheader (abfd
)->e_flags
== flags
);
9166 elf_elfheader (abfd
)->e_flags
= flags
;
9167 elf_flags_init (abfd
) = TRUE
;
9172 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9176 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9178 /* Print normal ELF private data. */
9179 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9181 /* xgettext:c-format */
9182 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9184 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9185 fprintf (file
, _(" [abi=O32]"));
9186 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9187 fprintf (file
, _(" [abi=O64]"));
9188 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9189 fprintf (file
, _(" [abi=EABI32]"));
9190 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9191 fprintf (file
, _(" [abi=EABI64]"));
9192 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9193 fprintf (file
, _(" [abi unknown]"));
9194 else if (ABI_N32_P (abfd
))
9195 fprintf (file
, _(" [abi=N32]"));
9196 else if (ABI_64_P (abfd
))
9197 fprintf (file
, _(" [abi=64]"));
9199 fprintf (file
, _(" [no abi set]"));
9201 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9202 fprintf (file
, _(" [mips1]"));
9203 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9204 fprintf (file
, _(" [mips2]"));
9205 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9206 fprintf (file
, _(" [mips3]"));
9207 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9208 fprintf (file
, _(" [mips4]"));
9209 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9210 fprintf (file
, _(" [mips5]"));
9211 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9212 fprintf (file
, _(" [mips32]"));
9213 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9214 fprintf (file
, _(" [mips64]"));
9215 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9216 fprintf (file
, _(" [mips32r2]"));
9217 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9218 fprintf (file
, _(" [mips64r2]"));
9220 fprintf (file
, _(" [unknown ISA]"));
9222 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9223 fprintf (file
, _(" [mdmx]"));
9225 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9226 fprintf (file
, _(" [mips16]"));
9228 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9229 fprintf (file
, _(" [32bitmode]"));
9231 fprintf (file
, _(" [not 32bitmode]"));
9238 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9240 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9241 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9242 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9243 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9244 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9245 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9246 { NULL
, 0, 0, 0, 0 }