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
);
750 /* Create a runtime procedure table from the .mdebug section. */
753 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
754 struct bfd_link_info
*info
, asection
*s
,
755 struct ecoff_debug_info
*debug
)
757 const struct ecoff_debug_swap
*swap
;
758 HDRR
*hdr
= &debug
->symbolic_header
;
760 struct rpdr_ext
*erp
;
762 struct pdr_ext
*epdr
;
763 struct sym_ext
*esym
;
768 unsigned long sindex
;
772 const char *no_name_func
= _("static procedure (no name)");
780 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
782 sindex
= strlen (no_name_func
) + 1;
786 size
= swap
->external_pdr_size
;
788 epdr
= bfd_malloc (size
* count
);
792 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
795 size
= sizeof (RPDR
);
796 rp
= rpdr
= bfd_malloc (size
* count
);
800 size
= sizeof (char *);
801 sv
= bfd_malloc (size
* count
);
805 count
= hdr
->isymMax
;
806 size
= swap
->external_sym_size
;
807 esym
= bfd_malloc (size
* count
);
811 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
815 ss
= bfd_malloc (count
);
818 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
822 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
824 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
825 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
827 rp
->regmask
= pdr
.regmask
;
828 rp
->regoffset
= pdr
.regoffset
;
829 rp
->fregmask
= pdr
.fregmask
;
830 rp
->fregoffset
= pdr
.fregoffset
;
831 rp
->frameoffset
= pdr
.frameoffset
;
832 rp
->framereg
= pdr
.framereg
;
833 rp
->pcreg
= pdr
.pcreg
;
835 sv
[i
] = ss
+ sym
.iss
;
836 sindex
+= strlen (sv
[i
]) + 1;
840 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
841 size
= BFD_ALIGN (size
, 16);
842 rtproc
= bfd_alloc (abfd
, size
);
845 mips_elf_hash_table (info
)->procedure_count
= 0;
849 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
852 memset (erp
, 0, sizeof (struct rpdr_ext
));
854 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
855 strcpy (str
, no_name_func
);
856 str
+= strlen (no_name_func
) + 1;
857 for (i
= 0; i
< count
; i
++)
859 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
861 str
+= strlen (sv
[i
]) + 1;
863 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
865 /* Set the size and contents of .rtproc section. */
867 s
->contents
= rtproc
;
869 /* Skip this section later on (I don't think this currently
870 matters, but someday it might). */
871 s
->link_order_head
= NULL
;
900 /* Check the mips16 stubs for a particular symbol, and see if we can
904 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
905 void *data ATTRIBUTE_UNUSED
)
907 if (h
->root
.root
.type
== bfd_link_hash_warning
)
908 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
910 if (h
->fn_stub
!= NULL
911 && ! h
->need_fn_stub
)
913 /* We don't need the fn_stub; the only references to this symbol
914 are 16 bit calls. Clobber the size to 0 to prevent it from
915 being included in the link. */
916 h
->fn_stub
->size
= 0;
917 h
->fn_stub
->flags
&= ~SEC_RELOC
;
918 h
->fn_stub
->reloc_count
= 0;
919 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
922 if (h
->call_stub
!= NULL
923 && h
->root
.other
== STO_MIPS16
)
925 /* We don't need the call_stub; this is a 16 bit function, so
926 calls from other 16 bit functions are OK. Clobber the size
927 to 0 to prevent it from being included in the link. */
928 h
->call_stub
->size
= 0;
929 h
->call_stub
->flags
&= ~SEC_RELOC
;
930 h
->call_stub
->reloc_count
= 0;
931 h
->call_stub
->flags
|= SEC_EXCLUDE
;
934 if (h
->call_fp_stub
!= NULL
935 && h
->root
.other
== STO_MIPS16
)
937 /* We don't need the call_stub; this is a 16 bit function, so
938 calls from other 16 bit functions are OK. Clobber the size
939 to 0 to prevent it from being included in the link. */
940 h
->call_fp_stub
->size
= 0;
941 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
942 h
->call_fp_stub
->reloc_count
= 0;
943 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
949 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
950 Most mips16 instructions are 16 bits, but these instructions
953 The format of these instructions is:
955 +--------------+--------------------------------+
956 | JALX | X| Imm 20:16 | Imm 25:21 |
957 +--------------+--------------------------------+
959 +-----------------------------------------------+
961 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
962 Note that the immediate value in the first word is swapped.
964 When producing a relocatable object file, R_MIPS16_26 is
965 handled mostly like R_MIPS_26. In particular, the addend is
966 stored as a straight 26-bit value in a 32-bit instruction.
967 (gas makes life simpler for itself by never adjusting a
968 R_MIPS16_26 reloc to be against a section, so the addend is
969 always zero). However, the 32 bit instruction is stored as 2
970 16-bit values, rather than a single 32-bit value. In a
971 big-endian file, the result is the same; in a little-endian
972 file, the two 16-bit halves of the 32 bit value are swapped.
973 This is so that a disassembler can recognize the jal
976 When doing a final link, R_MIPS16_26 is treated as a 32 bit
977 instruction stored as two 16-bit values. The addend A is the
978 contents of the targ26 field. The calculation is the same as
979 R_MIPS_26. When storing the calculated value, reorder the
980 immediate value as shown above, and don't forget to store the
981 value as two 16-bit values.
983 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
987 +--------+----------------------+
991 +--------+----------------------+
994 +----------+------+-------------+
998 +----------+--------------------+
999 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1000 ((sub1 << 16) | sub2)).
1002 When producing a relocatable object file, the calculation is
1003 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1004 When producing a fully linked file, the calculation is
1005 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1006 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1008 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1009 mode. A typical instruction will have a format like this:
1011 +--------------+--------------------------------+
1012 | EXTEND | Imm 10:5 | Imm 15:11 |
1013 +--------------+--------------------------------+
1014 | Major | rx | ry | Imm 4:0 |
1015 +--------------+--------------------------------+
1017 EXTEND is the five bit value 11110. Major is the instruction
1020 This is handled exactly like R_MIPS_GPREL16, except that the
1021 addend is retrieved and stored as shown in this diagram; that
1022 is, the Imm fields above replace the V-rel16 field.
1024 All we need to do here is shuffle the bits appropriately. As
1025 above, the two 16-bit halves must be swapped on a
1026 little-endian system.
1028 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1029 access data when neither GP-relative nor PC-relative addressing
1030 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1031 except that the addend is retrieved and stored as shown above
1035 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1036 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1038 bfd_vma extend
, insn
, val
;
1040 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1041 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1044 /* Pick up the mips16 extend instruction and the real instruction. */
1045 extend
= bfd_get_16 (abfd
, data
);
1046 insn
= bfd_get_16 (abfd
, data
+ 2);
1047 if (r_type
== R_MIPS16_26
)
1050 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1051 | ((extend
& 0x1f) << 21) | insn
;
1053 val
= extend
<< 16 | insn
;
1056 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1057 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1058 bfd_put_32 (abfd
, val
, data
);
1062 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1063 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1065 bfd_vma extend
, insn
, val
;
1067 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1068 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1071 val
= bfd_get_32 (abfd
, data
);
1072 if (r_type
== R_MIPS16_26
)
1076 insn
= val
& 0xffff;
1077 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1078 | ((val
>> 21) & 0x1f);
1082 insn
= val
& 0xffff;
1088 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1089 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1091 bfd_put_16 (abfd
, insn
, data
+ 2);
1092 bfd_put_16 (abfd
, extend
, data
);
1095 bfd_reloc_status_type
1096 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1097 arelent
*reloc_entry
, asection
*input_section
,
1098 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1102 bfd_reloc_status_type status
;
1104 if (bfd_is_com_section (symbol
->section
))
1107 relocation
= symbol
->value
;
1109 relocation
+= symbol
->section
->output_section
->vma
;
1110 relocation
+= symbol
->section
->output_offset
;
1112 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1113 return bfd_reloc_outofrange
;
1115 /* Set val to the offset into the section or symbol. */
1116 val
= reloc_entry
->addend
;
1118 _bfd_mips_elf_sign_extend (val
, 16);
1120 /* Adjust val for the final section location and GP value. If we
1121 are producing relocatable output, we don't want to do this for
1122 an external symbol. */
1124 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1125 val
+= relocation
- gp
;
1127 if (reloc_entry
->howto
->partial_inplace
)
1129 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1131 + reloc_entry
->address
);
1132 if (status
!= bfd_reloc_ok
)
1136 reloc_entry
->addend
= val
;
1139 reloc_entry
->address
+= input_section
->output_offset
;
1141 return bfd_reloc_ok
;
1144 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1145 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1146 that contains the relocation field and DATA points to the start of
1151 struct mips_hi16
*next
;
1153 asection
*input_section
;
1157 /* FIXME: This should not be a static variable. */
1159 static struct mips_hi16
*mips_hi16_list
;
1161 /* A howto special_function for REL *HI16 relocations. We can only
1162 calculate the correct value once we've seen the partnering
1163 *LO16 relocation, so just save the information for later.
1165 The ABI requires that the *LO16 immediately follow the *HI16.
1166 However, as a GNU extension, we permit an arbitrary number of
1167 *HI16s to be associated with a single *LO16. This significantly
1168 simplies the relocation handling in gcc. */
1170 bfd_reloc_status_type
1171 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1172 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1173 asection
*input_section
, bfd
*output_bfd
,
1174 char **error_message ATTRIBUTE_UNUSED
)
1176 struct mips_hi16
*n
;
1178 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1179 return bfd_reloc_outofrange
;
1181 n
= bfd_malloc (sizeof *n
);
1183 return bfd_reloc_outofrange
;
1185 n
->next
= mips_hi16_list
;
1187 n
->input_section
= input_section
;
1188 n
->rel
= *reloc_entry
;
1191 if (output_bfd
!= NULL
)
1192 reloc_entry
->address
+= input_section
->output_offset
;
1194 return bfd_reloc_ok
;
1197 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1198 like any other 16-bit relocation when applied to global symbols, but is
1199 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1201 bfd_reloc_status_type
1202 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1203 void *data
, asection
*input_section
,
1204 bfd
*output_bfd
, char **error_message
)
1206 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1207 || bfd_is_und_section (bfd_get_section (symbol
))
1208 || bfd_is_com_section (bfd_get_section (symbol
)))
1209 /* The relocation is against a global symbol. */
1210 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1211 input_section
, output_bfd
,
1214 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1215 input_section
, output_bfd
, error_message
);
1218 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1219 is a straightforward 16 bit inplace relocation, but we must deal with
1220 any partnering high-part relocations as well. */
1222 bfd_reloc_status_type
1223 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1224 void *data
, asection
*input_section
,
1225 bfd
*output_bfd
, char **error_message
)
1228 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1230 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1231 return bfd_reloc_outofrange
;
1233 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1235 vallo
= bfd_get_32 (abfd
, location
);
1236 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1239 while (mips_hi16_list
!= NULL
)
1241 bfd_reloc_status_type ret
;
1242 struct mips_hi16
*hi
;
1244 hi
= mips_hi16_list
;
1246 /* R_MIPS_GOT16 relocations are something of a special case. We
1247 want to install the addend in the same way as for a R_MIPS_HI16
1248 relocation (with a rightshift of 16). However, since GOT16
1249 relocations can also be used with global symbols, their howto
1250 has a rightshift of 0. */
1251 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1252 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1254 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1255 carry or borrow will induce a change of +1 or -1 in the high part. */
1256 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1258 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1259 hi
->input_section
, output_bfd
,
1261 if (ret
!= bfd_reloc_ok
)
1264 mips_hi16_list
= hi
->next
;
1268 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1269 input_section
, output_bfd
,
1273 /* A generic howto special_function. This calculates and installs the
1274 relocation itself, thus avoiding the oft-discussed problems in
1275 bfd_perform_relocation and bfd_install_relocation. */
1277 bfd_reloc_status_type
1278 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1279 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1280 asection
*input_section
, bfd
*output_bfd
,
1281 char **error_message ATTRIBUTE_UNUSED
)
1284 bfd_reloc_status_type status
;
1285 bfd_boolean relocatable
;
1287 relocatable
= (output_bfd
!= NULL
);
1289 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1290 return bfd_reloc_outofrange
;
1292 /* Build up the field adjustment in VAL. */
1294 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1296 /* Either we're calculating the final field value or we have a
1297 relocation against a section symbol. Add in the section's
1298 offset or address. */
1299 val
+= symbol
->section
->output_section
->vma
;
1300 val
+= symbol
->section
->output_offset
;
1305 /* We're calculating the final field value. Add in the symbol's value
1306 and, if pc-relative, subtract the address of the field itself. */
1307 val
+= symbol
->value
;
1308 if (reloc_entry
->howto
->pc_relative
)
1310 val
-= input_section
->output_section
->vma
;
1311 val
-= input_section
->output_offset
;
1312 val
-= reloc_entry
->address
;
1316 /* VAL is now the final adjustment. If we're keeping this relocation
1317 in the output file, and if the relocation uses a separate addend,
1318 we just need to add VAL to that addend. Otherwise we need to add
1319 VAL to the relocation field itself. */
1320 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1321 reloc_entry
->addend
+= val
;
1324 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1326 /* Add in the separate addend, if any. */
1327 val
+= reloc_entry
->addend
;
1329 /* Add VAL to the relocation field. */
1330 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1332 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1334 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1337 if (status
!= bfd_reloc_ok
)
1342 reloc_entry
->address
+= input_section
->output_offset
;
1344 return bfd_reloc_ok
;
1347 /* Swap an entry in a .gptab section. Note that these routines rely
1348 on the equivalence of the two elements of the union. */
1351 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1354 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1355 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1359 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1360 Elf32_External_gptab
*ex
)
1362 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1363 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1367 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1368 Elf32_External_compact_rel
*ex
)
1370 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1371 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1372 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1373 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1374 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1375 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1379 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1380 Elf32_External_crinfo
*ex
)
1384 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1385 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1386 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1387 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1388 H_PUT_32 (abfd
, l
, ex
->info
);
1389 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1390 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1393 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1394 routines swap this structure in and out. They are used outside of
1395 BFD, so they are globally visible. */
1398 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1401 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1402 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1403 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1404 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1405 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1406 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1410 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1411 Elf32_External_RegInfo
*ex
)
1413 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1414 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1415 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1416 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1417 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1418 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1421 /* In the 64 bit ABI, the .MIPS.options section holds register
1422 information in an Elf64_Reginfo structure. These routines swap
1423 them in and out. They are globally visible because they are used
1424 outside of BFD. These routines are here so that gas can call them
1425 without worrying about whether the 64 bit ABI has been included. */
1428 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1429 Elf64_Internal_RegInfo
*in
)
1431 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1432 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1433 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1434 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1435 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1436 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1437 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1441 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1442 Elf64_External_RegInfo
*ex
)
1444 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1445 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1446 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1447 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1448 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1449 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1450 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1453 /* Swap in an options header. */
1456 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1457 Elf_Internal_Options
*in
)
1459 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1460 in
->size
= H_GET_8 (abfd
, ex
->size
);
1461 in
->section
= H_GET_16 (abfd
, ex
->section
);
1462 in
->info
= H_GET_32 (abfd
, ex
->info
);
1465 /* Swap out an options header. */
1468 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1469 Elf_External_Options
*ex
)
1471 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1472 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1473 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1474 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1477 /* This function is called via qsort() to sort the dynamic relocation
1478 entries by increasing r_symndx value. */
1481 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1483 Elf_Internal_Rela int_reloc1
;
1484 Elf_Internal_Rela int_reloc2
;
1486 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1487 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1489 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1492 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1495 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1496 const void *arg2 ATTRIBUTE_UNUSED
)
1499 Elf_Internal_Rela int_reloc1
[3];
1500 Elf_Internal_Rela int_reloc2
[3];
1502 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1503 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1504 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1505 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1507 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1508 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1515 /* This routine is used to write out ECOFF debugging external symbol
1516 information. It is called via mips_elf_link_hash_traverse. The
1517 ECOFF external symbol information must match the ELF external
1518 symbol information. Unfortunately, at this point we don't know
1519 whether a symbol is required by reloc information, so the two
1520 tables may wind up being different. We must sort out the external
1521 symbol information before we can set the final size of the .mdebug
1522 section, and we must set the size of the .mdebug section before we
1523 can relocate any sections, and we can't know which symbols are
1524 required by relocation until we relocate the sections.
1525 Fortunately, it is relatively unlikely that any symbol will be
1526 stripped but required by a reloc. In particular, it can not happen
1527 when generating a final executable. */
1530 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1532 struct extsym_info
*einfo
= data
;
1534 asection
*sec
, *output_section
;
1536 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1537 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1539 if (h
->root
.indx
== -2)
1541 else if ((h
->root
.def_dynamic
1542 || h
->root
.ref_dynamic
1543 || h
->root
.type
== bfd_link_hash_new
)
1544 && !h
->root
.def_regular
1545 && !h
->root
.ref_regular
)
1547 else if (einfo
->info
->strip
== strip_all
1548 || (einfo
->info
->strip
== strip_some
1549 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1550 h
->root
.root
.root
.string
,
1551 FALSE
, FALSE
) == NULL
))
1559 if (h
->esym
.ifd
== -2)
1562 h
->esym
.cobol_main
= 0;
1563 h
->esym
.weakext
= 0;
1564 h
->esym
.reserved
= 0;
1565 h
->esym
.ifd
= ifdNil
;
1566 h
->esym
.asym
.value
= 0;
1567 h
->esym
.asym
.st
= stGlobal
;
1569 if (h
->root
.root
.type
== bfd_link_hash_undefined
1570 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1574 /* Use undefined class. Also, set class and type for some
1576 name
= h
->root
.root
.root
.string
;
1577 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1578 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1580 h
->esym
.asym
.sc
= scData
;
1581 h
->esym
.asym
.st
= stLabel
;
1582 h
->esym
.asym
.value
= 0;
1584 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1586 h
->esym
.asym
.sc
= scAbs
;
1587 h
->esym
.asym
.st
= stLabel
;
1588 h
->esym
.asym
.value
=
1589 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1591 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1593 h
->esym
.asym
.sc
= scAbs
;
1594 h
->esym
.asym
.st
= stLabel
;
1595 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1598 h
->esym
.asym
.sc
= scUndefined
;
1600 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1601 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1602 h
->esym
.asym
.sc
= scAbs
;
1607 sec
= h
->root
.root
.u
.def
.section
;
1608 output_section
= sec
->output_section
;
1610 /* When making a shared library and symbol h is the one from
1611 the another shared library, OUTPUT_SECTION may be null. */
1612 if (output_section
== NULL
)
1613 h
->esym
.asym
.sc
= scUndefined
;
1616 name
= bfd_section_name (output_section
->owner
, output_section
);
1618 if (strcmp (name
, ".text") == 0)
1619 h
->esym
.asym
.sc
= scText
;
1620 else if (strcmp (name
, ".data") == 0)
1621 h
->esym
.asym
.sc
= scData
;
1622 else if (strcmp (name
, ".sdata") == 0)
1623 h
->esym
.asym
.sc
= scSData
;
1624 else if (strcmp (name
, ".rodata") == 0
1625 || strcmp (name
, ".rdata") == 0)
1626 h
->esym
.asym
.sc
= scRData
;
1627 else if (strcmp (name
, ".bss") == 0)
1628 h
->esym
.asym
.sc
= scBss
;
1629 else if (strcmp (name
, ".sbss") == 0)
1630 h
->esym
.asym
.sc
= scSBss
;
1631 else if (strcmp (name
, ".init") == 0)
1632 h
->esym
.asym
.sc
= scInit
;
1633 else if (strcmp (name
, ".fini") == 0)
1634 h
->esym
.asym
.sc
= scFini
;
1636 h
->esym
.asym
.sc
= scAbs
;
1640 h
->esym
.asym
.reserved
= 0;
1641 h
->esym
.asym
.index
= indexNil
;
1644 if (h
->root
.root
.type
== bfd_link_hash_common
)
1645 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1646 else if (h
->root
.root
.type
== bfd_link_hash_defined
1647 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1649 if (h
->esym
.asym
.sc
== scCommon
)
1650 h
->esym
.asym
.sc
= scBss
;
1651 else if (h
->esym
.asym
.sc
== scSCommon
)
1652 h
->esym
.asym
.sc
= scSBss
;
1654 sec
= h
->root
.root
.u
.def
.section
;
1655 output_section
= sec
->output_section
;
1656 if (output_section
!= NULL
)
1657 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1658 + sec
->output_offset
1659 + output_section
->vma
);
1661 h
->esym
.asym
.value
= 0;
1663 else if (h
->root
.needs_plt
)
1665 struct mips_elf_link_hash_entry
*hd
= h
;
1666 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1668 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1670 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1671 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1676 /* Set type and value for a symbol with a function stub. */
1677 h
->esym
.asym
.st
= stProc
;
1678 sec
= hd
->root
.root
.u
.def
.section
;
1680 h
->esym
.asym
.value
= 0;
1683 output_section
= sec
->output_section
;
1684 if (output_section
!= NULL
)
1685 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1686 + sec
->output_offset
1687 + output_section
->vma
);
1689 h
->esym
.asym
.value
= 0;
1694 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1695 h
->root
.root
.root
.string
,
1698 einfo
->failed
= TRUE
;
1705 /* A comparison routine used to sort .gptab entries. */
1708 gptab_compare (const void *p1
, const void *p2
)
1710 const Elf32_gptab
*a1
= p1
;
1711 const Elf32_gptab
*a2
= p2
;
1713 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1716 /* Functions to manage the got entry hash table. */
1718 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1721 static INLINE hashval_t
1722 mips_elf_hash_bfd_vma (bfd_vma addr
)
1725 return addr
+ (addr
>> 32);
1731 /* got_entries only match if they're identical, except for gotidx, so
1732 use all fields to compute the hash, and compare the appropriate
1736 mips_elf_got_entry_hash (const void *entry_
)
1738 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1740 return entry
->symndx
1741 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1743 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1744 : entry
->d
.h
->root
.root
.root
.hash
));
1748 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1750 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1751 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1753 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1754 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1755 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1756 : e1
->d
.h
== e2
->d
.h
);
1759 /* multi_got_entries are still a match in the case of global objects,
1760 even if the input bfd in which they're referenced differs, so the
1761 hash computation and compare functions are adjusted
1765 mips_elf_multi_got_entry_hash (const void *entry_
)
1767 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1769 return entry
->symndx
1771 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1772 : entry
->symndx
>= 0
1774 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1775 : entry
->d
.h
->root
.root
.root
.hash
);
1779 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1781 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1782 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1784 return e1
->symndx
== e2
->symndx
1785 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1786 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1787 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1788 : e1
->d
.h
== e2
->d
.h
);
1791 /* Returns the dynamic relocation section for DYNOBJ. */
1794 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1796 static const char dname
[] = ".rel.dyn";
1799 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1800 if (sreloc
== NULL
&& create_p
)
1802 sreloc
= bfd_make_section (dynobj
, dname
);
1804 || ! bfd_set_section_flags (dynobj
, sreloc
,
1809 | SEC_LINKER_CREATED
1811 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1812 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1818 /* Returns the GOT section for ABFD. */
1821 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1823 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1825 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1830 /* Returns the GOT information associated with the link indicated by
1831 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1834 static struct mips_got_info
*
1835 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1838 struct mips_got_info
*g
;
1840 sgot
= mips_elf_got_section (abfd
, TRUE
);
1841 BFD_ASSERT (sgot
!= NULL
);
1842 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1843 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1844 BFD_ASSERT (g
!= NULL
);
1847 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1852 /* Returns the GOT offset at which the indicated address can be found.
1853 If there is not yet a GOT entry for this value, create one. Returns
1854 -1 if no satisfactory GOT offset can be found. */
1857 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1861 struct mips_got_info
*g
;
1862 struct mips_got_entry
*entry
;
1864 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1866 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1868 return entry
->gotidx
;
1873 /* Returns the GOT index for the global symbol indicated by H. */
1876 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1880 struct mips_got_info
*g
, *gg
;
1881 long global_got_dynindx
= 0;
1883 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1884 if (g
->bfd2got
&& ibfd
)
1886 struct mips_got_entry e
, *p
;
1888 BFD_ASSERT (h
->dynindx
>= 0);
1890 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1895 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1897 p
= htab_find (g
->got_entries
, &e
);
1899 BFD_ASSERT (p
->gotidx
> 0);
1904 if (gg
->global_gotsym
!= NULL
)
1905 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1907 /* Once we determine the global GOT entry with the lowest dynamic
1908 symbol table index, we must put all dynamic symbols with greater
1909 indices into the GOT. That makes it easy to calculate the GOT
1911 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1912 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1913 * MIPS_ELF_GOT_SIZE (abfd
));
1914 BFD_ASSERT (index
< sgot
->size
);
1919 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1920 are supposed to be placed at small offsets in the GOT, i.e.,
1921 within 32KB of GP. Return the index into the GOT for this page,
1922 and store the offset from this entry to the desired address in
1923 OFFSETP, if it is non-NULL. */
1926 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1927 bfd_vma value
, bfd_vma
*offsetp
)
1930 struct mips_got_info
*g
;
1932 struct mips_got_entry
*entry
;
1934 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1936 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1938 & (~(bfd_vma
)0xffff));
1943 index
= entry
->gotidx
;
1946 *offsetp
= value
- entry
->d
.address
;
1951 /* Find a GOT entry whose higher-order 16 bits are the same as those
1952 for value. Return the index into the GOT for this entry. */
1955 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1956 bfd_vma value
, bfd_boolean external
)
1959 struct mips_got_info
*g
;
1960 struct mips_got_entry
*entry
;
1964 /* Although the ABI says that it is "the high-order 16 bits" that we
1965 want, it is really the %high value. The complete value is
1966 calculated with a `addiu' of a LO16 relocation, just as with a
1968 value
= mips_elf_high (value
) << 16;
1971 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1973 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1975 return entry
->gotidx
;
1980 /* Returns the offset for the entry at the INDEXth position
1984 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1985 bfd
*input_bfd
, bfd_vma index
)
1989 struct mips_got_info
*g
;
1991 g
= mips_elf_got_info (dynobj
, &sgot
);
1992 gp
= _bfd_get_gp_value (output_bfd
)
1993 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1995 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1998 /* Create a local GOT entry for VALUE. Return the index of the entry,
1999 or -1 if it could not be created. */
2001 static struct mips_got_entry
*
2002 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2003 struct mips_got_info
*gg
,
2004 asection
*sgot
, bfd_vma value
)
2006 struct mips_got_entry entry
, **loc
;
2007 struct mips_got_info
*g
;
2011 entry
.d
.address
= value
;
2013 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2016 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2017 BFD_ASSERT (g
!= NULL
);
2020 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2025 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2027 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2032 memcpy (*loc
, &entry
, sizeof entry
);
2034 if (g
->assigned_gotno
>= g
->local_gotno
)
2036 (*loc
)->gotidx
= -1;
2037 /* We didn't allocate enough space in the GOT. */
2038 (*_bfd_error_handler
)
2039 (_("not enough GOT space for local GOT entries"));
2040 bfd_set_error (bfd_error_bad_value
);
2044 MIPS_ELF_PUT_WORD (abfd
, value
,
2045 (sgot
->contents
+ entry
.gotidx
));
2050 /* Sort the dynamic symbol table so that symbols that need GOT entries
2051 appear towards the end. This reduces the amount of GOT space
2052 required. MAX_LOCAL is used to set the number of local symbols
2053 known to be in the dynamic symbol table. During
2054 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2055 section symbols are added and the count is higher. */
2058 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2060 struct mips_elf_hash_sort_data hsd
;
2061 struct mips_got_info
*g
;
2064 dynobj
= elf_hash_table (info
)->dynobj
;
2066 g
= mips_elf_got_info (dynobj
, NULL
);
2069 hsd
.max_unref_got_dynindx
=
2070 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2071 /* In the multi-got case, assigned_gotno of the master got_info
2072 indicate the number of entries that aren't referenced in the
2073 primary GOT, but that must have entries because there are
2074 dynamic relocations that reference it. Since they aren't
2075 referenced, we move them to the end of the GOT, so that they
2076 don't prevent other entries that are referenced from getting
2077 too large offsets. */
2078 - (g
->next
? g
->assigned_gotno
: 0);
2079 hsd
.max_non_got_dynindx
= max_local
;
2080 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2081 elf_hash_table (info
)),
2082 mips_elf_sort_hash_table_f
,
2085 /* There should have been enough room in the symbol table to
2086 accommodate both the GOT and non-GOT symbols. */
2087 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2088 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2089 <= elf_hash_table (info
)->dynsymcount
);
2091 /* Now we know which dynamic symbol has the lowest dynamic symbol
2092 table index in the GOT. */
2093 g
->global_gotsym
= hsd
.low
;
2098 /* If H needs a GOT entry, assign it the highest available dynamic
2099 index. Otherwise, assign it the lowest available dynamic
2103 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2105 struct mips_elf_hash_sort_data
*hsd
= data
;
2107 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2108 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2110 /* Symbols without dynamic symbol table entries aren't interesting
2112 if (h
->root
.dynindx
== -1)
2115 /* Global symbols that need GOT entries that are not explicitly
2116 referenced are marked with got offset 2. Those that are
2117 referenced get a 1, and those that don't need GOT entries get
2119 if (h
->root
.got
.offset
== 2)
2121 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2122 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2123 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2125 else if (h
->root
.got
.offset
!= 1)
2126 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2129 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2130 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2136 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2137 symbol table index lower than any we've seen to date, record it for
2141 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2142 bfd
*abfd
, struct bfd_link_info
*info
,
2143 struct mips_got_info
*g
)
2145 struct mips_got_entry entry
, **loc
;
2147 /* A global symbol in the GOT must also be in the dynamic symbol
2149 if (h
->dynindx
== -1)
2151 switch (ELF_ST_VISIBILITY (h
->other
))
2155 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2158 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2164 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2166 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2169 /* If we've already marked this entry as needing GOT space, we don't
2170 need to do it again. */
2174 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2180 memcpy (*loc
, &entry
, sizeof entry
);
2182 if (h
->got
.offset
!= MINUS_ONE
)
2185 /* By setting this to a value other than -1, we are indicating that
2186 there needs to be a GOT entry for H. Avoid using zero, as the
2187 generic ELF copy_indirect_symbol tests for <= 0. */
2193 /* Reserve space in G for a GOT entry containing the value of symbol
2194 SYMNDX in input bfd ABDF, plus ADDEND. */
2197 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2198 struct mips_got_info
*g
)
2200 struct mips_got_entry entry
, **loc
;
2203 entry
.symndx
= symndx
;
2204 entry
.d
.addend
= addend
;
2205 loc
= (struct mips_got_entry
**)
2206 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2211 entry
.gotidx
= g
->local_gotno
++;
2213 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2218 memcpy (*loc
, &entry
, sizeof entry
);
2223 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2226 mips_elf_bfd2got_entry_hash (const void *entry_
)
2228 const struct mips_elf_bfd2got_hash
*entry
2229 = (struct mips_elf_bfd2got_hash
*)entry_
;
2231 return entry
->bfd
->id
;
2234 /* Check whether two hash entries have the same bfd. */
2237 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2239 const struct mips_elf_bfd2got_hash
*e1
2240 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2241 const struct mips_elf_bfd2got_hash
*e2
2242 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2244 return e1
->bfd
== e2
->bfd
;
2247 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2248 be the master GOT data. */
2250 static struct mips_got_info
*
2251 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2253 struct mips_elf_bfd2got_hash e
, *p
;
2259 p
= htab_find (g
->bfd2got
, &e
);
2260 return p
? p
->g
: NULL
;
2263 /* Create one separate got for each bfd that has entries in the global
2264 got, such that we can tell how many local and global entries each
2268 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2270 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2271 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2272 htab_t bfd2got
= arg
->bfd2got
;
2273 struct mips_got_info
*g
;
2274 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2277 /* Find the got_info for this GOT entry's input bfd. Create one if
2279 bfdgot_entry
.bfd
= entry
->abfd
;
2280 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2281 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2287 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2288 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2298 bfdgot
->bfd
= entry
->abfd
;
2299 bfdgot
->g
= g
= (struct mips_got_info
*)
2300 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2307 g
->global_gotsym
= NULL
;
2308 g
->global_gotno
= 0;
2310 g
->assigned_gotno
= -1;
2311 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2312 mips_elf_multi_got_entry_eq
, NULL
);
2313 if (g
->got_entries
== NULL
)
2323 /* Insert the GOT entry in the bfd's got entry hash table. */
2324 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2325 if (*entryp
!= NULL
)
2330 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2338 /* Attempt to merge gots of different input bfds. Try to use as much
2339 as possible of the primary got, since it doesn't require explicit
2340 dynamic relocations, but don't use bfds that would reference global
2341 symbols out of the addressable range. Failing the primary got,
2342 attempt to merge with the current got, or finish the current got
2343 and then make make the new got current. */
2346 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2348 struct mips_elf_bfd2got_hash
*bfd2got
2349 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2350 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2351 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2352 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2353 unsigned int maxcnt
= arg
->max_count
;
2355 /* If we don't have a primary GOT and this is not too big, use it as
2356 a starting point for the primary GOT. */
2357 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2359 arg
->primary
= bfd2got
->g
;
2360 arg
->primary_count
= lcount
+ gcount
;
2362 /* If it looks like we can merge this bfd's entries with those of
2363 the primary, merge them. The heuristics is conservative, but we
2364 don't have to squeeze it too hard. */
2365 else if (arg
->primary
2366 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2368 struct mips_got_info
*g
= bfd2got
->g
;
2369 int old_lcount
= arg
->primary
->local_gotno
;
2370 int old_gcount
= arg
->primary
->global_gotno
;
2372 bfd2got
->g
= arg
->primary
;
2374 htab_traverse (g
->got_entries
,
2375 mips_elf_make_got_per_bfd
,
2377 if (arg
->obfd
== NULL
)
2380 htab_delete (g
->got_entries
);
2381 /* We don't have to worry about releasing memory of the actual
2382 got entries, since they're all in the master got_entries hash
2385 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2386 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2388 arg
->primary_count
= arg
->primary
->local_gotno
2389 + arg
->primary
->global_gotno
;
2391 /* If we can merge with the last-created got, do it. */
2392 else if (arg
->current
2393 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2395 struct mips_got_info
*g
= bfd2got
->g
;
2396 int old_lcount
= arg
->current
->local_gotno
;
2397 int old_gcount
= arg
->current
->global_gotno
;
2399 bfd2got
->g
= arg
->current
;
2401 htab_traverse (g
->got_entries
,
2402 mips_elf_make_got_per_bfd
,
2404 if (arg
->obfd
== NULL
)
2407 htab_delete (g
->got_entries
);
2409 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2410 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2412 arg
->current_count
= arg
->current
->local_gotno
2413 + arg
->current
->global_gotno
;
2415 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2416 fits; if it turns out that it doesn't, we'll get relocation
2417 overflows anyway. */
2420 bfd2got
->g
->next
= arg
->current
;
2421 arg
->current
= bfd2got
->g
;
2423 arg
->current_count
= lcount
+ gcount
;
2429 /* If passed a NULL mips_got_info in the argument, set the marker used
2430 to tell whether a global symbol needs a got entry (in the primary
2431 got) to the given VALUE.
2433 If passed a pointer G to a mips_got_info in the argument (it must
2434 not be the primary GOT), compute the offset from the beginning of
2435 the (primary) GOT section to the entry in G corresponding to the
2436 global symbol. G's assigned_gotno must contain the index of the
2437 first available global GOT entry in G. VALUE must contain the size
2438 of a GOT entry in bytes. For each global GOT entry that requires a
2439 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2440 marked as not eligible for lazy resolution through a function
2443 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2445 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2446 struct mips_elf_set_global_got_offset_arg
*arg
2447 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2448 struct mips_got_info
*g
= arg
->g
;
2450 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2451 && entry
->d
.h
->root
.dynindx
!= -1)
2455 BFD_ASSERT (g
->global_gotsym
== NULL
);
2457 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2458 if (arg
->info
->shared
2459 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2460 && entry
->d
.h
->root
.def_dynamic
2461 && !entry
->d
.h
->root
.def_regular
))
2462 ++arg
->needed_relocs
;
2465 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2471 /* Mark any global symbols referenced in the GOT we are iterating over
2472 as inelligible for lazy resolution stubs. */
2474 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2476 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2478 if (entry
->abfd
!= NULL
2479 && entry
->symndx
== -1
2480 && entry
->d
.h
->root
.dynindx
!= -1)
2481 entry
->d
.h
->no_fn_stub
= TRUE
;
2486 /* Follow indirect and warning hash entries so that each got entry
2487 points to the final symbol definition. P must point to a pointer
2488 to the hash table we're traversing. Since this traversal may
2489 modify the hash table, we set this pointer to NULL to indicate
2490 we've made a potentially-destructive change to the hash table, so
2491 the traversal must be restarted. */
2493 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2495 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2496 htab_t got_entries
= *(htab_t
*)p
;
2498 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2500 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2502 while (h
->root
.root
.type
== bfd_link_hash_indirect
2503 || h
->root
.root
.type
== bfd_link_hash_warning
)
2504 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2506 if (entry
->d
.h
== h
)
2511 /* If we can't find this entry with the new bfd hash, re-insert
2512 it, and get the traversal restarted. */
2513 if (! htab_find (got_entries
, entry
))
2515 htab_clear_slot (got_entries
, entryp
);
2516 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2519 /* Abort the traversal, since the whole table may have
2520 moved, and leave it up to the parent to restart the
2522 *(htab_t
*)p
= NULL
;
2525 /* We might want to decrement the global_gotno count, but it's
2526 either too early or too late for that at this point. */
2532 /* Turn indirect got entries in a got_entries table into their final
2535 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2541 got_entries
= g
->got_entries
;
2543 htab_traverse (got_entries
,
2544 mips_elf_resolve_final_got_entry
,
2547 while (got_entries
== NULL
);
2550 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2553 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2555 if (g
->bfd2got
== NULL
)
2558 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2562 BFD_ASSERT (g
->next
);
2566 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2569 /* Turn a single GOT that is too big for 16-bit addressing into
2570 a sequence of GOTs, each one 16-bit addressable. */
2573 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2574 struct mips_got_info
*g
, asection
*got
,
2575 bfd_size_type pages
)
2577 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2578 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2579 struct mips_got_info
*gg
;
2580 unsigned int assign
;
2582 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2583 mips_elf_bfd2got_entry_eq
, NULL
);
2584 if (g
->bfd2got
== NULL
)
2587 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2588 got_per_bfd_arg
.obfd
= abfd
;
2589 got_per_bfd_arg
.info
= info
;
2591 /* Count how many GOT entries each input bfd requires, creating a
2592 map from bfd to got info while at that. */
2593 mips_elf_resolve_final_got_entries (g
);
2594 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2595 if (got_per_bfd_arg
.obfd
== NULL
)
2598 got_per_bfd_arg
.current
= NULL
;
2599 got_per_bfd_arg
.primary
= NULL
;
2600 /* Taking out PAGES entries is a worst-case estimate. We could
2601 compute the maximum number of pages that each separate input bfd
2602 uses, but it's probably not worth it. */
2603 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2604 / MIPS_ELF_GOT_SIZE (abfd
))
2605 - MIPS_RESERVED_GOTNO
- pages
);
2607 /* Try to merge the GOTs of input bfds together, as long as they
2608 don't seem to exceed the maximum GOT size, choosing one of them
2609 to be the primary GOT. */
2610 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2611 if (got_per_bfd_arg
.obfd
== NULL
)
2614 /* If we find any suitable primary GOT, create an empty one. */
2615 if (got_per_bfd_arg
.primary
== NULL
)
2617 g
->next
= (struct mips_got_info
*)
2618 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2619 if (g
->next
== NULL
)
2622 g
->next
->global_gotsym
= NULL
;
2623 g
->next
->global_gotno
= 0;
2624 g
->next
->local_gotno
= 0;
2625 g
->next
->assigned_gotno
= 0;
2626 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2627 mips_elf_multi_got_entry_eq
,
2629 if (g
->next
->got_entries
== NULL
)
2631 g
->next
->bfd2got
= NULL
;
2634 g
->next
= got_per_bfd_arg
.primary
;
2635 g
->next
->next
= got_per_bfd_arg
.current
;
2637 /* GG is now the master GOT, and G is the primary GOT. */
2641 /* Map the output bfd to the primary got. That's what we're going
2642 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2643 didn't mark in check_relocs, and we want a quick way to find it.
2644 We can't just use gg->next because we're going to reverse the
2647 struct mips_elf_bfd2got_hash
*bfdgot
;
2650 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2651 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2658 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2660 BFD_ASSERT (*bfdgotp
== NULL
);
2664 /* The IRIX dynamic linker requires every symbol that is referenced
2665 in a dynamic relocation to be present in the primary GOT, so
2666 arrange for them to appear after those that are actually
2669 GNU/Linux could very well do without it, but it would slow down
2670 the dynamic linker, since it would have to resolve every dynamic
2671 symbol referenced in other GOTs more than once, without help from
2672 the cache. Also, knowing that every external symbol has a GOT
2673 helps speed up the resolution of local symbols too, so GNU/Linux
2674 follows IRIX's practice.
2676 The number 2 is used by mips_elf_sort_hash_table_f to count
2677 global GOT symbols that are unreferenced in the primary GOT, with
2678 an initial dynamic index computed from gg->assigned_gotno, where
2679 the number of unreferenced global entries in the primary GOT is
2683 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2684 g
->global_gotno
= gg
->global_gotno
;
2685 set_got_offset_arg
.value
= 2;
2689 /* This could be used for dynamic linkers that don't optimize
2690 symbol resolution while applying relocations so as to use
2691 primary GOT entries or assuming the symbol is locally-defined.
2692 With this code, we assign lower dynamic indices to global
2693 symbols that are not referenced in the primary GOT, so that
2694 their entries can be omitted. */
2695 gg
->assigned_gotno
= 0;
2696 set_got_offset_arg
.value
= -1;
2699 /* Reorder dynamic symbols as described above (which behavior
2700 depends on the setting of VALUE). */
2701 set_got_offset_arg
.g
= NULL
;
2702 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2703 &set_got_offset_arg
);
2704 set_got_offset_arg
.value
= 1;
2705 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2706 &set_got_offset_arg
);
2707 if (! mips_elf_sort_hash_table (info
, 1))
2710 /* Now go through the GOTs assigning them offset ranges.
2711 [assigned_gotno, local_gotno[ will be set to the range of local
2712 entries in each GOT. We can then compute the end of a GOT by
2713 adding local_gotno to global_gotno. We reverse the list and make
2714 it circular since then we'll be able to quickly compute the
2715 beginning of a GOT, by computing the end of its predecessor. To
2716 avoid special cases for the primary GOT, while still preserving
2717 assertions that are valid for both single- and multi-got links,
2718 we arrange for the main got struct to have the right number of
2719 global entries, but set its local_gotno such that the initial
2720 offset of the primary GOT is zero. Remember that the primary GOT
2721 will become the last item in the circular linked list, so it
2722 points back to the master GOT. */
2723 gg
->local_gotno
= -g
->global_gotno
;
2724 gg
->global_gotno
= g
->global_gotno
;
2730 struct mips_got_info
*gn
;
2732 assign
+= MIPS_RESERVED_GOTNO
;
2733 g
->assigned_gotno
= assign
;
2734 g
->local_gotno
+= assign
+ pages
;
2735 assign
= g
->local_gotno
+ g
->global_gotno
;
2737 /* Take g out of the direct list, and push it onto the reversed
2738 list that gg points to. */
2744 /* Mark global symbols in every non-primary GOT as ineligible for
2747 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2751 got
->size
= (gg
->next
->local_gotno
2752 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2758 /* Returns the first relocation of type r_type found, beginning with
2759 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2761 static const Elf_Internal_Rela
*
2762 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2763 const Elf_Internal_Rela
*relocation
,
2764 const Elf_Internal_Rela
*relend
)
2766 while (relocation
< relend
)
2768 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2774 /* We didn't find it. */
2775 bfd_set_error (bfd_error_bad_value
);
2779 /* Return whether a relocation is against a local symbol. */
2782 mips_elf_local_relocation_p (bfd
*input_bfd
,
2783 const Elf_Internal_Rela
*relocation
,
2784 asection
**local_sections
,
2785 bfd_boolean check_forced
)
2787 unsigned long r_symndx
;
2788 Elf_Internal_Shdr
*symtab_hdr
;
2789 struct mips_elf_link_hash_entry
*h
;
2792 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2793 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2794 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2796 if (r_symndx
< extsymoff
)
2798 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2803 /* Look up the hash table to check whether the symbol
2804 was forced local. */
2805 h
= (struct mips_elf_link_hash_entry
*)
2806 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2807 /* Find the real hash-table entry for this symbol. */
2808 while (h
->root
.root
.type
== bfd_link_hash_indirect
2809 || h
->root
.root
.type
== bfd_link_hash_warning
)
2810 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2811 if (h
->root
.forced_local
)
2818 /* Sign-extend VALUE, which has the indicated number of BITS. */
2821 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2823 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2824 /* VALUE is negative. */
2825 value
|= ((bfd_vma
) - 1) << bits
;
2830 /* Return non-zero if the indicated VALUE has overflowed the maximum
2831 range expressible by a signed number with the indicated number of
2835 mips_elf_overflow_p (bfd_vma value
, int bits
)
2837 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2839 if (svalue
> (1 << (bits
- 1)) - 1)
2840 /* The value is too big. */
2842 else if (svalue
< -(1 << (bits
- 1)))
2843 /* The value is too small. */
2850 /* Calculate the %high function. */
2853 mips_elf_high (bfd_vma value
)
2855 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2858 /* Calculate the %higher function. */
2861 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2864 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2871 /* Calculate the %highest function. */
2874 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2877 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2884 /* Create the .compact_rel section. */
2887 mips_elf_create_compact_rel_section
2888 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2891 register asection
*s
;
2893 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2895 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2898 s
= bfd_make_section (abfd
, ".compact_rel");
2900 || ! bfd_set_section_flags (abfd
, s
, flags
)
2901 || ! bfd_set_section_alignment (abfd
, s
,
2902 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2905 s
->size
= sizeof (Elf32_External_compact_rel
);
2911 /* Create the .got section to hold the global offset table. */
2914 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2915 bfd_boolean maybe_exclude
)
2918 register asection
*s
;
2919 struct elf_link_hash_entry
*h
;
2920 struct bfd_link_hash_entry
*bh
;
2921 struct mips_got_info
*g
;
2924 /* This function may be called more than once. */
2925 s
= mips_elf_got_section (abfd
, TRUE
);
2928 if (! maybe_exclude
)
2929 s
->flags
&= ~SEC_EXCLUDE
;
2933 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2934 | SEC_LINKER_CREATED
);
2937 flags
|= SEC_EXCLUDE
;
2939 /* We have to use an alignment of 2**4 here because this is hardcoded
2940 in the function stub generation and in the linker script. */
2941 s
= bfd_make_section (abfd
, ".got");
2943 || ! bfd_set_section_flags (abfd
, s
, flags
)
2944 || ! bfd_set_section_alignment (abfd
, s
, 4))
2947 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2948 linker script because we don't want to define the symbol if we
2949 are not creating a global offset table. */
2951 if (! (_bfd_generic_link_add_one_symbol
2952 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2953 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2956 h
= (struct elf_link_hash_entry
*) bh
;
2959 h
->type
= STT_OBJECT
;
2962 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2965 amt
= sizeof (struct mips_got_info
);
2966 g
= bfd_alloc (abfd
, amt
);
2969 g
->global_gotsym
= NULL
;
2970 g
->global_gotno
= 0;
2971 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2972 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2975 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2976 mips_elf_got_entry_eq
, NULL
);
2977 if (g
->got_entries
== NULL
)
2979 mips_elf_section_data (s
)->u
.got_info
= g
;
2980 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2981 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2986 /* Calculate the value produced by the RELOCATION (which comes from
2987 the INPUT_BFD). The ADDEND is the addend to use for this
2988 RELOCATION; RELOCATION->R_ADDEND is ignored.
2990 The result of the relocation calculation is stored in VALUEP.
2991 REQUIRE_JALXP indicates whether or not the opcode used with this
2992 relocation must be JALX.
2994 This function returns bfd_reloc_continue if the caller need take no
2995 further action regarding this relocation, bfd_reloc_notsupported if
2996 something goes dramatically wrong, bfd_reloc_overflow if an
2997 overflow occurs, and bfd_reloc_ok to indicate success. */
2999 static bfd_reloc_status_type
3000 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3001 asection
*input_section
,
3002 struct bfd_link_info
*info
,
3003 const Elf_Internal_Rela
*relocation
,
3004 bfd_vma addend
, reloc_howto_type
*howto
,
3005 Elf_Internal_Sym
*local_syms
,
3006 asection
**local_sections
, bfd_vma
*valuep
,
3007 const char **namep
, bfd_boolean
*require_jalxp
,
3008 bfd_boolean save_addend
)
3010 /* The eventual value we will return. */
3012 /* The address of the symbol against which the relocation is
3015 /* The final GP value to be used for the relocatable, executable, or
3016 shared object file being produced. */
3017 bfd_vma gp
= MINUS_ONE
;
3018 /* The place (section offset or address) of the storage unit being
3021 /* The value of GP used to create the relocatable object. */
3022 bfd_vma gp0
= MINUS_ONE
;
3023 /* The offset into the global offset table at which the address of
3024 the relocation entry symbol, adjusted by the addend, resides
3025 during execution. */
3026 bfd_vma g
= MINUS_ONE
;
3027 /* The section in which the symbol referenced by the relocation is
3029 asection
*sec
= NULL
;
3030 struct mips_elf_link_hash_entry
*h
= NULL
;
3031 /* TRUE if the symbol referred to by this relocation is a local
3033 bfd_boolean local_p
, was_local_p
;
3034 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3035 bfd_boolean gp_disp_p
= FALSE
;
3036 Elf_Internal_Shdr
*symtab_hdr
;
3038 unsigned long r_symndx
;
3040 /* TRUE if overflow occurred during the calculation of the
3041 relocation value. */
3042 bfd_boolean overflowed_p
;
3043 /* TRUE if this relocation refers to a MIPS16 function. */
3044 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3046 /* Parse the relocation. */
3047 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3048 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3049 p
= (input_section
->output_section
->vma
3050 + input_section
->output_offset
3051 + relocation
->r_offset
);
3053 /* Assume that there will be no overflow. */
3054 overflowed_p
= FALSE
;
3056 /* Figure out whether or not the symbol is local, and get the offset
3057 used in the array of hash table entries. */
3058 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3059 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3060 local_sections
, FALSE
);
3061 was_local_p
= local_p
;
3062 if (! elf_bad_symtab (input_bfd
))
3063 extsymoff
= symtab_hdr
->sh_info
;
3066 /* The symbol table does not follow the rule that local symbols
3067 must come before globals. */
3071 /* Figure out the value of the symbol. */
3074 Elf_Internal_Sym
*sym
;
3076 sym
= local_syms
+ r_symndx
;
3077 sec
= local_sections
[r_symndx
];
3079 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3080 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3081 || (sec
->flags
& SEC_MERGE
))
3082 symbol
+= sym
->st_value
;
3083 if ((sec
->flags
& SEC_MERGE
)
3084 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3086 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3088 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3091 /* MIPS16 text labels should be treated as odd. */
3092 if (sym
->st_other
== STO_MIPS16
)
3095 /* Record the name of this symbol, for our caller. */
3096 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3097 symtab_hdr
->sh_link
,
3100 *namep
= bfd_section_name (input_bfd
, sec
);
3102 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3106 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3108 /* For global symbols we look up the symbol in the hash-table. */
3109 h
= ((struct mips_elf_link_hash_entry
*)
3110 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3111 /* Find the real hash-table entry for this symbol. */
3112 while (h
->root
.root
.type
== bfd_link_hash_indirect
3113 || h
->root
.root
.type
== bfd_link_hash_warning
)
3114 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3116 /* Record the name of this symbol, for our caller. */
3117 *namep
= h
->root
.root
.root
.string
;
3119 /* See if this is the special _gp_disp symbol. Note that such a
3120 symbol must always be a global symbol. */
3121 if (strcmp (*namep
, "_gp_disp") == 0
3122 && ! NEWABI_P (input_bfd
))
3124 /* Relocations against _gp_disp are permitted only with
3125 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3126 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3127 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3128 return bfd_reloc_notsupported
;
3132 /* If this symbol is defined, calculate its address. Note that
3133 _gp_disp is a magic symbol, always implicitly defined by the
3134 linker, so it's inappropriate to check to see whether or not
3136 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3137 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3138 && h
->root
.root
.u
.def
.section
)
3140 sec
= h
->root
.root
.u
.def
.section
;
3141 if (sec
->output_section
)
3142 symbol
= (h
->root
.root
.u
.def
.value
3143 + sec
->output_section
->vma
3144 + sec
->output_offset
);
3146 symbol
= h
->root
.root
.u
.def
.value
;
3148 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3149 /* We allow relocations against undefined weak symbols, giving
3150 it the value zero, so that you can undefined weak functions
3151 and check to see if they exist by looking at their
3154 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3155 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3157 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
3158 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3160 /* If this is a dynamic link, we should have created a
3161 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3162 in in _bfd_mips_elf_create_dynamic_sections.
3163 Otherwise, we should define the symbol with a value of 0.
3164 FIXME: It should probably get into the symbol table
3166 BFD_ASSERT (! info
->shared
);
3167 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3172 if (! ((*info
->callbacks
->undefined_symbol
)
3173 (info
, h
->root
.root
.root
.string
, input_bfd
,
3174 input_section
, relocation
->r_offset
,
3175 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3176 || ELF_ST_VISIBILITY (h
->root
.other
))))
3177 return bfd_reloc_undefined
;
3181 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3184 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3185 need to redirect the call to the stub, unless we're already *in*
3187 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3188 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3189 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3190 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3191 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3193 /* This is a 32- or 64-bit call to a 16-bit function. We should
3194 have already noticed that we were going to need the
3197 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3200 BFD_ASSERT (h
->need_fn_stub
);
3204 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3206 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3207 need to redirect the call to the stub. */
3208 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3210 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3211 && !target_is_16_bit_code_p
)
3213 /* If both call_stub and call_fp_stub are defined, we can figure
3214 out which one to use by seeing which one appears in the input
3216 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3221 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3223 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3224 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3226 sec
= h
->call_fp_stub
;
3233 else if (h
->call_stub
!= NULL
)
3236 sec
= h
->call_fp_stub
;
3238 BFD_ASSERT (sec
->size
> 0);
3239 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3242 /* Calls from 16-bit code to 32-bit code and vice versa require the
3243 special jalx instruction. */
3244 *require_jalxp
= (!info
->relocatable
3245 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3246 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3248 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3249 local_sections
, TRUE
);
3251 /* If we haven't already determined the GOT offset, or the GP value,
3252 and we're going to need it, get it now. */
3255 case R_MIPS_GOT_PAGE
:
3256 case R_MIPS_GOT_OFST
:
3257 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3259 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3260 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3266 case R_MIPS_GOT_DISP
:
3267 case R_MIPS_GOT_HI16
:
3268 case R_MIPS_CALL_HI16
:
3269 case R_MIPS_GOT_LO16
:
3270 case R_MIPS_CALL_LO16
:
3271 /* Find the index into the GOT where this value is located. */
3274 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3275 GOT_PAGE relocation that decays to GOT_DISP because the
3276 symbol turns out to be global. The addend is then added
3278 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3279 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3281 (struct elf_link_hash_entry
*) h
);
3282 if (! elf_hash_table(info
)->dynamic_sections_created
3284 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3285 && h
->root
.def_regular
))
3287 /* This is a static link or a -Bsymbolic link. The
3288 symbol is defined locally, or was forced to be local.
3289 We must initialize this entry in the GOT. */
3290 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3291 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3292 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3295 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3296 /* There's no need to create a local GOT entry here; the
3297 calculation for a local GOT16 entry does not involve G. */
3301 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3302 info
, symbol
+ addend
);
3304 return bfd_reloc_outofrange
;
3307 /* Convert GOT indices to actual offsets. */
3308 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3309 abfd
, input_bfd
, g
);
3314 case R_MIPS_GPREL16
:
3315 case R_MIPS_GPREL32
:
3316 case R_MIPS_LITERAL
:
3319 case R_MIPS16_GPREL
:
3320 gp0
= _bfd_get_gp_value (input_bfd
);
3321 gp
= _bfd_get_gp_value (abfd
);
3322 if (elf_hash_table (info
)->dynobj
)
3323 gp
+= mips_elf_adjust_gp (abfd
,
3325 (elf_hash_table (info
)->dynobj
, NULL
),
3333 /* Figure out what kind of relocation is being performed. */
3337 return bfd_reloc_continue
;
3340 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3341 overflowed_p
= mips_elf_overflow_p (value
, 16);
3348 || (elf_hash_table (info
)->dynamic_sections_created
3350 && h
->root
.def_dynamic
3351 && !h
->root
.def_regular
))
3353 && (input_section
->flags
& SEC_ALLOC
) != 0)
3355 /* If we're creating a shared library, or this relocation is
3356 against a symbol in a shared library, then we can't know
3357 where the symbol will end up. So, we create a relocation
3358 record in the output, and leave the job up to the dynamic
3361 if (!mips_elf_create_dynamic_relocation (abfd
,
3369 return bfd_reloc_undefined
;
3373 if (r_type
!= R_MIPS_REL32
)
3374 value
= symbol
+ addend
;
3378 value
&= howto
->dst_mask
;
3382 value
= symbol
+ addend
- p
;
3383 value
&= howto
->dst_mask
;
3386 case R_MIPS_GNU_REL16_S2
:
3387 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3388 overflowed_p
= mips_elf_overflow_p (value
, 18);
3389 value
= (value
>> 2) & howto
->dst_mask
;
3393 /* The calculation for R_MIPS16_26 is just the same as for an
3394 R_MIPS_26. It's only the storage of the relocated field into
3395 the output file that's different. That's handled in
3396 mips_elf_perform_relocation. So, we just fall through to the
3397 R_MIPS_26 case here. */
3400 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3403 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3404 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
3405 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
3407 value
&= howto
->dst_mask
;
3414 value
= mips_elf_high (addend
+ symbol
);
3415 value
&= howto
->dst_mask
;
3419 /* For MIPS16 ABI code we generate this sequence
3420 0: li $v0,%hi(_gp_disp)
3421 4: addiupc $v1,%lo(_gp_disp)
3425 So the offsets of hi and lo relocs are the same, but the
3426 $pc is four higher than $t9 would be, so reduce
3427 both reloc addends by 4. */
3428 if (r_type
== R_MIPS16_HI16
)
3429 value
= mips_elf_high (addend
+ gp
- p
- 4);
3431 value
= mips_elf_high (addend
+ gp
- p
);
3432 overflowed_p
= mips_elf_overflow_p (value
, 16);
3439 value
= (symbol
+ addend
) & howto
->dst_mask
;
3442 /* See the comment for R_MIPS16_HI16 above for the reason
3443 for this conditional. */
3444 if (r_type
== R_MIPS16_LO16
)
3445 value
= addend
+ gp
- p
;
3447 value
= addend
+ gp
- p
+ 4;
3448 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3449 for overflow. But, on, say, IRIX5, relocations against
3450 _gp_disp are normally generated from the .cpload
3451 pseudo-op. It generates code that normally looks like
3454 lui $gp,%hi(_gp_disp)
3455 addiu $gp,$gp,%lo(_gp_disp)
3458 Here $t9 holds the address of the function being called,
3459 as required by the MIPS ELF ABI. The R_MIPS_LO16
3460 relocation can easily overflow in this situation, but the
3461 R_MIPS_HI16 relocation will handle the overflow.
3462 Therefore, we consider this a bug in the MIPS ABI, and do
3463 not check for overflow here. */
3467 case R_MIPS_LITERAL
:
3468 /* Because we don't merge literal sections, we can handle this
3469 just like R_MIPS_GPREL16. In the long run, we should merge
3470 shared literals, and then we will need to additional work
3475 case R_MIPS16_GPREL
:
3476 /* The R_MIPS16_GPREL performs the same calculation as
3477 R_MIPS_GPREL16, but stores the relocated bits in a different
3478 order. We don't need to do anything special here; the
3479 differences are handled in mips_elf_perform_relocation. */
3480 case R_MIPS_GPREL16
:
3481 /* Only sign-extend the addend if it was extracted from the
3482 instruction. If the addend was separate, leave it alone,
3483 otherwise we may lose significant bits. */
3484 if (howto
->partial_inplace
)
3485 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3486 value
= symbol
+ addend
- gp
;
3487 /* If the symbol was local, any earlier relocatable links will
3488 have adjusted its addend with the gp offset, so compensate
3489 for that now. Don't do it for symbols forced local in this
3490 link, though, since they won't have had the gp offset applied
3494 overflowed_p
= mips_elf_overflow_p (value
, 16);
3503 /* The special case is when the symbol is forced to be local. We
3504 need the full address in the GOT since no R_MIPS_LO16 relocation
3506 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3507 local_sections
, FALSE
);
3508 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3509 symbol
+ addend
, forced
);
3510 if (value
== MINUS_ONE
)
3511 return bfd_reloc_outofrange
;
3513 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3514 abfd
, input_bfd
, value
);
3515 overflowed_p
= mips_elf_overflow_p (value
, 16);
3521 case R_MIPS_GOT_DISP
:
3524 overflowed_p
= mips_elf_overflow_p (value
, 16);
3527 case R_MIPS_GPREL32
:
3528 value
= (addend
+ symbol
+ gp0
- gp
);
3530 value
&= howto
->dst_mask
;
3534 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3535 overflowed_p
= mips_elf_overflow_p (value
, 16);
3538 case R_MIPS_GOT_HI16
:
3539 case R_MIPS_CALL_HI16
:
3540 /* We're allowed to handle these two relocations identically.
3541 The dynamic linker is allowed to handle the CALL relocations
3542 differently by creating a lazy evaluation stub. */
3544 value
= mips_elf_high (value
);
3545 value
&= howto
->dst_mask
;
3548 case R_MIPS_GOT_LO16
:
3549 case R_MIPS_CALL_LO16
:
3550 value
= g
& howto
->dst_mask
;
3553 case R_MIPS_GOT_PAGE
:
3554 /* GOT_PAGE relocations that reference non-local symbols decay
3555 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3559 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3560 if (value
== MINUS_ONE
)
3561 return bfd_reloc_outofrange
;
3562 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3563 abfd
, input_bfd
, value
);
3564 overflowed_p
= mips_elf_overflow_p (value
, 16);
3567 case R_MIPS_GOT_OFST
:
3569 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3572 overflowed_p
= mips_elf_overflow_p (value
, 16);
3576 value
= symbol
- addend
;
3577 value
&= howto
->dst_mask
;
3581 value
= mips_elf_higher (addend
+ symbol
);
3582 value
&= howto
->dst_mask
;
3585 case R_MIPS_HIGHEST
:
3586 value
= mips_elf_highest (addend
+ symbol
);
3587 value
&= howto
->dst_mask
;
3590 case R_MIPS_SCN_DISP
:
3591 value
= symbol
+ addend
- sec
->output_offset
;
3592 value
&= howto
->dst_mask
;
3596 /* This relocation is only a hint. In some cases, we optimize
3597 it into a bal instruction. But we don't try to optimize
3598 branches to the PLT; that will wind up wasting time. */
3599 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
3600 return bfd_reloc_continue
;
3601 value
= symbol
+ addend
;
3605 case R_MIPS_GNU_VTINHERIT
:
3606 case R_MIPS_GNU_VTENTRY
:
3607 /* We don't do anything with these at present. */
3608 return bfd_reloc_continue
;
3611 /* An unrecognized relocation type. */
3612 return bfd_reloc_notsupported
;
3615 /* Store the VALUE for our caller. */
3617 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3620 /* Obtain the field relocated by RELOCATION. */
3623 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3624 const Elf_Internal_Rela
*relocation
,
3625 bfd
*input_bfd
, bfd_byte
*contents
)
3628 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3630 /* Obtain the bytes. */
3631 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3636 /* It has been determined that the result of the RELOCATION is the
3637 VALUE. Use HOWTO to place VALUE into the output file at the
3638 appropriate position. The SECTION is the section to which the
3639 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3640 for the relocation must be either JAL or JALX, and it is
3641 unconditionally converted to JALX.
3643 Returns FALSE if anything goes wrong. */
3646 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3647 reloc_howto_type
*howto
,
3648 const Elf_Internal_Rela
*relocation
,
3649 bfd_vma value
, bfd
*input_bfd
,
3650 asection
*input_section
, bfd_byte
*contents
,
3651 bfd_boolean require_jalx
)
3655 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3657 /* Figure out where the relocation is occurring. */
3658 location
= contents
+ relocation
->r_offset
;
3660 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
3662 /* Obtain the current value. */
3663 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3665 /* Clear the field we are setting. */
3666 x
&= ~howto
->dst_mask
;
3668 /* Set the field. */
3669 x
|= (value
& howto
->dst_mask
);
3671 /* If required, turn JAL into JALX. */
3675 bfd_vma opcode
= x
>> 26;
3676 bfd_vma jalx_opcode
;
3678 /* Check to see if the opcode is already JAL or JALX. */
3679 if (r_type
== R_MIPS16_26
)
3681 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3686 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3690 /* If the opcode is not JAL or JALX, there's a problem. */
3693 (*_bfd_error_handler
)
3694 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
3697 (unsigned long) relocation
->r_offset
);
3698 bfd_set_error (bfd_error_bad_value
);
3702 /* Make this the JALX opcode. */
3703 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3706 /* On the RM9000, bal is faster than jal, because bal uses branch
3707 prediction hardware. If we are linking for the RM9000, and we
3708 see jal, and bal fits, use it instead. Note that this
3709 transformation should be safe for all architectures. */
3710 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
3711 && !info
->relocatable
3713 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
3714 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
3720 addr
= (input_section
->output_section
->vma
3721 + input_section
->output_offset
3722 + relocation
->r_offset
3724 if (r_type
== R_MIPS_26
)
3725 dest
= (value
<< 2) | ((addr
>> 28) << 28);
3729 if (off
<= 0x1ffff && off
>= -0x20000)
3730 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
3733 /* Put the value into the output. */
3734 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3736 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
3742 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3745 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3747 const char *name
= bfd_get_section_name (abfd
, section
);
3749 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3750 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3751 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3754 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3757 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3761 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3762 BFD_ASSERT (s
!= NULL
);
3766 /* Make room for a null element. */
3767 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
3770 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3773 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3774 is the original relocation, which is now being transformed into a
3775 dynamic relocation. The ADDENDP is adjusted if necessary; the
3776 caller should store the result in place of the original addend. */
3779 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3780 struct bfd_link_info
*info
,
3781 const Elf_Internal_Rela
*rel
,
3782 struct mips_elf_link_hash_entry
*h
,
3783 asection
*sec
, bfd_vma symbol
,
3784 bfd_vma
*addendp
, asection
*input_section
)
3786 Elf_Internal_Rela outrel
[3];
3791 bfd_boolean defined_p
;
3793 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3794 dynobj
= elf_hash_table (info
)->dynobj
;
3795 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3796 BFD_ASSERT (sreloc
!= NULL
);
3797 BFD_ASSERT (sreloc
->contents
!= NULL
);
3798 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3801 outrel
[0].r_offset
=
3802 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3803 outrel
[1].r_offset
=
3804 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3805 outrel
[2].r_offset
=
3806 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3808 if (outrel
[0].r_offset
== MINUS_ONE
)
3809 /* The relocation field has been deleted. */
3812 if (outrel
[0].r_offset
== MINUS_TWO
)
3814 /* The relocation field has been converted into a relative value of
3815 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3816 the field to be fully relocated, so add in the symbol's value. */
3821 /* We must now calculate the dynamic symbol table index to use
3822 in the relocation. */
3824 && (! info
->symbolic
|| !h
->root
.def_regular
)
3825 /* h->root.dynindx may be -1 if this symbol was marked to
3827 && h
->root
.dynindx
!= -1)
3829 indx
= h
->root
.dynindx
;
3830 if (SGI_COMPAT (output_bfd
))
3831 defined_p
= h
->root
.def_regular
;
3833 /* ??? glibc's ld.so just adds the final GOT entry to the
3834 relocation field. It therefore treats relocs against
3835 defined symbols in the same way as relocs against
3836 undefined symbols. */
3841 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3843 else if (sec
== NULL
|| sec
->owner
== NULL
)
3845 bfd_set_error (bfd_error_bad_value
);
3850 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3855 /* Instead of generating a relocation using the section
3856 symbol, we may as well make it a fully relative
3857 relocation. We want to avoid generating relocations to
3858 local symbols because we used to generate them
3859 incorrectly, without adding the original symbol value,
3860 which is mandated by the ABI for section symbols. In
3861 order to give dynamic loaders and applications time to
3862 phase out the incorrect use, we refrain from emitting
3863 section-relative relocations. It's not like they're
3864 useful, after all. This should be a bit more efficient
3866 /* ??? Although this behavior is compatible with glibc's ld.so,
3867 the ABI says that relocations against STN_UNDEF should have
3868 a symbol value of 0. Irix rld honors this, so relocations
3869 against STN_UNDEF have no effect. */
3870 if (!SGI_COMPAT (output_bfd
))
3875 /* If the relocation was previously an absolute relocation and
3876 this symbol will not be referred to by the relocation, we must
3877 adjust it by the value we give it in the dynamic symbol table.
3878 Otherwise leave the job up to the dynamic linker. */
3879 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3882 /* The relocation is always an REL32 relocation because we don't
3883 know where the shared library will wind up at load-time. */
3884 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3886 /* For strict adherence to the ABI specification, we should
3887 generate a R_MIPS_64 relocation record by itself before the
3888 _REL32/_64 record as well, such that the addend is read in as
3889 a 64-bit value (REL32 is a 32-bit relocation, after all).
3890 However, since none of the existing ELF64 MIPS dynamic
3891 loaders seems to care, we don't waste space with these
3892 artificial relocations. If this turns out to not be true,
3893 mips_elf_allocate_dynamic_relocation() should be tweaked so
3894 as to make room for a pair of dynamic relocations per
3895 invocation if ABI_64_P, and here we should generate an
3896 additional relocation record with R_MIPS_64 by itself for a
3897 NULL symbol before this relocation record. */
3898 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
3899 ABI_64_P (output_bfd
)
3902 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
3904 /* Adjust the output offset of the relocation to reference the
3905 correct location in the output file. */
3906 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3907 + input_section
->output_offset
);
3908 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3909 + input_section
->output_offset
);
3910 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3911 + input_section
->output_offset
);
3913 /* Put the relocation back out. We have to use the special
3914 relocation outputter in the 64-bit case since the 64-bit
3915 relocation format is non-standard. */
3916 if (ABI_64_P (output_bfd
))
3918 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3919 (output_bfd
, &outrel
[0],
3921 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3924 bfd_elf32_swap_reloc_out
3925 (output_bfd
, &outrel
[0],
3926 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3928 /* We've now added another relocation. */
3929 ++sreloc
->reloc_count
;
3931 /* Make sure the output section is writable. The dynamic linker
3932 will be writing to it. */
3933 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3936 /* On IRIX5, make an entry of compact relocation info. */
3937 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
3939 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3944 Elf32_crinfo cptrel
;
3946 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3947 cptrel
.vaddr
= (rel
->r_offset
3948 + input_section
->output_section
->vma
3949 + input_section
->output_offset
);
3950 if (r_type
== R_MIPS_REL32
)
3951 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3953 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3954 mips_elf_set_cr_dist2to (cptrel
, 0);
3955 cptrel
.konst
= *addendp
;
3957 cr
= (scpt
->contents
3958 + sizeof (Elf32_External_compact_rel
));
3959 mips_elf_set_cr_relvaddr (cptrel
, 0);
3960 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
3961 ((Elf32_External_crinfo
*) cr
3962 + scpt
->reloc_count
));
3963 ++scpt
->reloc_count
;
3970 /* Return the MACH for a MIPS e_flags value. */
3973 _bfd_elf_mips_mach (flagword flags
)
3975 switch (flags
& EF_MIPS_MACH
)
3977 case E_MIPS_MACH_3900
:
3978 return bfd_mach_mips3900
;
3980 case E_MIPS_MACH_4010
:
3981 return bfd_mach_mips4010
;
3983 case E_MIPS_MACH_4100
:
3984 return bfd_mach_mips4100
;
3986 case E_MIPS_MACH_4111
:
3987 return bfd_mach_mips4111
;
3989 case E_MIPS_MACH_4120
:
3990 return bfd_mach_mips4120
;
3992 case E_MIPS_MACH_4650
:
3993 return bfd_mach_mips4650
;
3995 case E_MIPS_MACH_5400
:
3996 return bfd_mach_mips5400
;
3998 case E_MIPS_MACH_5500
:
3999 return bfd_mach_mips5500
;
4001 case E_MIPS_MACH_9000
:
4002 return bfd_mach_mips9000
;
4004 case E_MIPS_MACH_SB1
:
4005 return bfd_mach_mips_sb1
;
4008 switch (flags
& EF_MIPS_ARCH
)
4012 return bfd_mach_mips3000
;
4016 return bfd_mach_mips6000
;
4020 return bfd_mach_mips4000
;
4024 return bfd_mach_mips8000
;
4028 return bfd_mach_mips5
;
4031 case E_MIPS_ARCH_32
:
4032 return bfd_mach_mipsisa32
;
4035 case E_MIPS_ARCH_64
:
4036 return bfd_mach_mipsisa64
;
4039 case E_MIPS_ARCH_32R2
:
4040 return bfd_mach_mipsisa32r2
;
4043 case E_MIPS_ARCH_64R2
:
4044 return bfd_mach_mipsisa64r2
;
4052 /* Return printable name for ABI. */
4054 static INLINE
char *
4055 elf_mips_abi_name (bfd
*abfd
)
4059 flags
= elf_elfheader (abfd
)->e_flags
;
4060 switch (flags
& EF_MIPS_ABI
)
4063 if (ABI_N32_P (abfd
))
4065 else if (ABI_64_P (abfd
))
4069 case E_MIPS_ABI_O32
:
4071 case E_MIPS_ABI_O64
:
4073 case E_MIPS_ABI_EABI32
:
4075 case E_MIPS_ABI_EABI64
:
4078 return "unknown abi";
4082 /* MIPS ELF uses two common sections. One is the usual one, and the
4083 other is for small objects. All the small objects are kept
4084 together, and then referenced via the gp pointer, which yields
4085 faster assembler code. This is what we use for the small common
4086 section. This approach is copied from ecoff.c. */
4087 static asection mips_elf_scom_section
;
4088 static asymbol mips_elf_scom_symbol
;
4089 static asymbol
*mips_elf_scom_symbol_ptr
;
4091 /* MIPS ELF also uses an acommon section, which represents an
4092 allocated common symbol which may be overridden by a
4093 definition in a shared library. */
4094 static asection mips_elf_acom_section
;
4095 static asymbol mips_elf_acom_symbol
;
4096 static asymbol
*mips_elf_acom_symbol_ptr
;
4098 /* Handle the special MIPS section numbers that a symbol may use.
4099 This is used for both the 32-bit and the 64-bit ABI. */
4102 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4104 elf_symbol_type
*elfsym
;
4106 elfsym
= (elf_symbol_type
*) asym
;
4107 switch (elfsym
->internal_elf_sym
.st_shndx
)
4109 case SHN_MIPS_ACOMMON
:
4110 /* This section is used in a dynamically linked executable file.
4111 It is an allocated common section. The dynamic linker can
4112 either resolve these symbols to something in a shared
4113 library, or it can just leave them here. For our purposes,
4114 we can consider these symbols to be in a new section. */
4115 if (mips_elf_acom_section
.name
== NULL
)
4117 /* Initialize the acommon section. */
4118 mips_elf_acom_section
.name
= ".acommon";
4119 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4120 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4121 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4122 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4123 mips_elf_acom_symbol
.name
= ".acommon";
4124 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4125 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4126 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4128 asym
->section
= &mips_elf_acom_section
;
4132 /* Common symbols less than the GP size are automatically
4133 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4134 if (asym
->value
> elf_gp_size (abfd
)
4135 || IRIX_COMPAT (abfd
) == ict_irix6
)
4138 case SHN_MIPS_SCOMMON
:
4139 if (mips_elf_scom_section
.name
== NULL
)
4141 /* Initialize the small common section. */
4142 mips_elf_scom_section
.name
= ".scommon";
4143 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4144 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4145 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4146 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4147 mips_elf_scom_symbol
.name
= ".scommon";
4148 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4149 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4150 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4152 asym
->section
= &mips_elf_scom_section
;
4153 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4156 case SHN_MIPS_SUNDEFINED
:
4157 asym
->section
= bfd_und_section_ptr
;
4162 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
4164 BFD_ASSERT (SGI_COMPAT (abfd
));
4165 if (section
!= NULL
)
4167 asym
->section
= section
;
4168 /* MIPS_TEXT is a bit special, the address is not an offset
4169 to the base of the .text section. So substract the section
4170 base address to make it an offset. */
4171 asym
->value
-= section
->vma
;
4178 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
4180 BFD_ASSERT (SGI_COMPAT (abfd
));
4181 if (section
!= NULL
)
4183 asym
->section
= section
;
4184 /* MIPS_DATA is a bit special, the address is not an offset
4185 to the base of the .data section. So substract the section
4186 base address to make it an offset. */
4187 asym
->value
-= section
->vma
;
4194 /* Implement elf_backend_eh_frame_address_size. This differs from
4195 the default in the way it handles EABI64.
4197 EABI64 was originally specified as an LP64 ABI, and that is what
4198 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4199 historically accepted the combination of -mabi=eabi and -mlong32,
4200 and this ILP32 variation has become semi-official over time.
4201 Both forms use elf32 and have pointer-sized FDE addresses.
4203 If an EABI object was generated by GCC 4.0 or above, it will have
4204 an empty .gcc_compiled_longXX section, where XX is the size of longs
4205 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4206 have no special marking to distinguish them from LP64 objects.
4208 We don't want users of the official LP64 ABI to be punished for the
4209 existence of the ILP32 variant, but at the same time, we don't want
4210 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4211 We therefore take the following approach:
4213 - If ABFD contains a .gcc_compiled_longXX section, use it to
4214 determine the pointer size.
4216 - Otherwise check the type of the first relocation. Assume that
4217 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4221 The second check is enough to detect LP64 objects generated by pre-4.0
4222 compilers because, in the kind of output generated by those compilers,
4223 the first relocation will be associated with either a CIE personality
4224 routine or an FDE start address. Furthermore, the compilers never
4225 used a special (non-pointer) encoding for this ABI.
4227 Checking the relocation type should also be safe because there is no
4228 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4232 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
4234 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
4236 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
4238 bfd_boolean long32_p
, long64_p
;
4240 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
4241 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
4242 if (long32_p
&& long64_p
)
4249 if (sec
->reloc_count
> 0
4250 && elf_section_data (sec
)->relocs
!= NULL
4251 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
4260 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4261 relocations against two unnamed section symbols to resolve to the
4262 same address. For example, if we have code like:
4264 lw $4,%got_disp(.data)($gp)
4265 lw $25,%got_disp(.text)($gp)
4268 then the linker will resolve both relocations to .data and the program
4269 will jump there rather than to .text.
4271 We can work around this problem by giving names to local section symbols.
4272 This is also what the MIPSpro tools do. */
4275 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4277 return SGI_COMPAT (abfd
);
4280 /* Work over a section just before writing it out. This routine is
4281 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4282 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4286 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4288 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4289 && hdr
->sh_size
> 0)
4293 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4294 BFD_ASSERT (hdr
->contents
== NULL
);
4297 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4300 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4301 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4305 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4306 && hdr
->bfd_section
!= NULL
4307 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4308 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4310 bfd_byte
*contents
, *l
, *lend
;
4312 /* We stored the section contents in the tdata field in the
4313 set_section_contents routine. We save the section contents
4314 so that we don't have to read them again.
4315 At this point we know that elf_gp is set, so we can look
4316 through the section contents to see if there is an
4317 ODK_REGINFO structure. */
4319 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4321 lend
= contents
+ hdr
->sh_size
;
4322 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4324 Elf_Internal_Options intopt
;
4326 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4328 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4335 + sizeof (Elf_External_Options
)
4336 + (sizeof (Elf64_External_RegInfo
) - 8)),
4339 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4340 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4343 else if (intopt
.kind
== ODK_REGINFO
)
4350 + sizeof (Elf_External_Options
)
4351 + (sizeof (Elf32_External_RegInfo
) - 4)),
4354 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4355 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4362 if (hdr
->bfd_section
!= NULL
)
4364 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4366 if (strcmp (name
, ".sdata") == 0
4367 || strcmp (name
, ".lit8") == 0
4368 || strcmp (name
, ".lit4") == 0)
4370 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4371 hdr
->sh_type
= SHT_PROGBITS
;
4373 else if (strcmp (name
, ".sbss") == 0)
4375 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4376 hdr
->sh_type
= SHT_NOBITS
;
4378 else if (strcmp (name
, ".srdata") == 0)
4380 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4381 hdr
->sh_type
= SHT_PROGBITS
;
4383 else if (strcmp (name
, ".compact_rel") == 0)
4386 hdr
->sh_type
= SHT_PROGBITS
;
4388 else if (strcmp (name
, ".rtproc") == 0)
4390 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4392 unsigned int adjust
;
4394 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4396 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4404 /* Handle a MIPS specific section when reading an object file. This
4405 is called when elfcode.h finds a section with an unknown type.
4406 This routine supports both the 32-bit and 64-bit ELF ABI.
4408 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4412 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4417 /* There ought to be a place to keep ELF backend specific flags, but
4418 at the moment there isn't one. We just keep track of the
4419 sections by their name, instead. Fortunately, the ABI gives
4420 suggested names for all the MIPS specific sections, so we will
4421 probably get away with this. */
4422 switch (hdr
->sh_type
)
4424 case SHT_MIPS_LIBLIST
:
4425 if (strcmp (name
, ".liblist") != 0)
4429 if (strcmp (name
, ".msym") != 0)
4432 case SHT_MIPS_CONFLICT
:
4433 if (strcmp (name
, ".conflict") != 0)
4436 case SHT_MIPS_GPTAB
:
4437 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4440 case SHT_MIPS_UCODE
:
4441 if (strcmp (name
, ".ucode") != 0)
4444 case SHT_MIPS_DEBUG
:
4445 if (strcmp (name
, ".mdebug") != 0)
4447 flags
= SEC_DEBUGGING
;
4449 case SHT_MIPS_REGINFO
:
4450 if (strcmp (name
, ".reginfo") != 0
4451 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4453 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4455 case SHT_MIPS_IFACE
:
4456 if (strcmp (name
, ".MIPS.interfaces") != 0)
4459 case SHT_MIPS_CONTENT
:
4460 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4463 case SHT_MIPS_OPTIONS
:
4464 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4467 case SHT_MIPS_DWARF
:
4468 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4471 case SHT_MIPS_SYMBOL_LIB
:
4472 if (strcmp (name
, ".MIPS.symlib") != 0)
4475 case SHT_MIPS_EVENTS
:
4476 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4477 && strncmp (name
, ".MIPS.post_rel",
4478 sizeof ".MIPS.post_rel" - 1) != 0)
4485 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4490 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4491 (bfd_get_section_flags (abfd
,
4497 /* FIXME: We should record sh_info for a .gptab section. */
4499 /* For a .reginfo section, set the gp value in the tdata information
4500 from the contents of this section. We need the gp value while
4501 processing relocs, so we just get it now. The .reginfo section
4502 is not used in the 64-bit MIPS ELF ABI. */
4503 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4505 Elf32_External_RegInfo ext
;
4508 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4509 &ext
, 0, sizeof ext
))
4511 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4512 elf_gp (abfd
) = s
.ri_gp_value
;
4515 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4516 set the gp value based on what we find. We may see both
4517 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4518 they should agree. */
4519 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4521 bfd_byte
*contents
, *l
, *lend
;
4523 contents
= bfd_malloc (hdr
->sh_size
);
4524 if (contents
== NULL
)
4526 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4533 lend
= contents
+ hdr
->sh_size
;
4534 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4536 Elf_Internal_Options intopt
;
4538 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4540 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4542 Elf64_Internal_RegInfo intreg
;
4544 bfd_mips_elf64_swap_reginfo_in
4546 ((Elf64_External_RegInfo
*)
4547 (l
+ sizeof (Elf_External_Options
))),
4549 elf_gp (abfd
) = intreg
.ri_gp_value
;
4551 else if (intopt
.kind
== ODK_REGINFO
)
4553 Elf32_RegInfo intreg
;
4555 bfd_mips_elf32_swap_reginfo_in
4557 ((Elf32_External_RegInfo
*)
4558 (l
+ sizeof (Elf_External_Options
))),
4560 elf_gp (abfd
) = intreg
.ri_gp_value
;
4570 /* Set the correct type for a MIPS ELF section. We do this by the
4571 section name, which is a hack, but ought to work. This routine is
4572 used by both the 32-bit and the 64-bit ABI. */
4575 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4577 register const char *name
;
4579 name
= bfd_get_section_name (abfd
, sec
);
4581 if (strcmp (name
, ".liblist") == 0)
4583 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4584 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
4585 /* The sh_link field is set in final_write_processing. */
4587 else if (strcmp (name
, ".conflict") == 0)
4588 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4589 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4591 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4592 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4593 /* The sh_info field is set in final_write_processing. */
4595 else if (strcmp (name
, ".ucode") == 0)
4596 hdr
->sh_type
= SHT_MIPS_UCODE
;
4597 else if (strcmp (name
, ".mdebug") == 0)
4599 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4600 /* In a shared object on IRIX 5.3, the .mdebug section has an
4601 entsize of 0. FIXME: Does this matter? */
4602 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4603 hdr
->sh_entsize
= 0;
4605 hdr
->sh_entsize
= 1;
4607 else if (strcmp (name
, ".reginfo") == 0)
4609 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4610 /* In a shared object on IRIX 5.3, the .reginfo section has an
4611 entsize of 0x18. FIXME: Does this matter? */
4612 if (SGI_COMPAT (abfd
))
4614 if ((abfd
->flags
& DYNAMIC
) != 0)
4615 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4617 hdr
->sh_entsize
= 1;
4620 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4622 else if (SGI_COMPAT (abfd
)
4623 && (strcmp (name
, ".hash") == 0
4624 || strcmp (name
, ".dynamic") == 0
4625 || strcmp (name
, ".dynstr") == 0))
4627 if (SGI_COMPAT (abfd
))
4628 hdr
->sh_entsize
= 0;
4630 /* This isn't how the IRIX6 linker behaves. */
4631 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4634 else if (strcmp (name
, ".got") == 0
4635 || strcmp (name
, ".srdata") == 0
4636 || strcmp (name
, ".sdata") == 0
4637 || strcmp (name
, ".sbss") == 0
4638 || strcmp (name
, ".lit4") == 0
4639 || strcmp (name
, ".lit8") == 0)
4640 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4641 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4643 hdr
->sh_type
= SHT_MIPS_IFACE
;
4644 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4646 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4648 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4649 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4650 /* The sh_info field is set in final_write_processing. */
4652 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4654 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4655 hdr
->sh_entsize
= 1;
4656 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4658 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4659 hdr
->sh_type
= SHT_MIPS_DWARF
;
4660 else if (strcmp (name
, ".MIPS.symlib") == 0)
4662 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4663 /* The sh_link and sh_info fields are set in
4664 final_write_processing. */
4666 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4667 || strncmp (name
, ".MIPS.post_rel",
4668 sizeof ".MIPS.post_rel" - 1) == 0)
4670 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4671 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4672 /* The sh_link field is set in final_write_processing. */
4674 else if (strcmp (name
, ".msym") == 0)
4676 hdr
->sh_type
= SHT_MIPS_MSYM
;
4677 hdr
->sh_flags
|= SHF_ALLOC
;
4678 hdr
->sh_entsize
= 8;
4681 /* The generic elf_fake_sections will set up REL_HDR using the default
4682 kind of relocations. We used to set up a second header for the
4683 non-default kind of relocations here, but only NewABI would use
4684 these, and the IRIX ld doesn't like resulting empty RELA sections.
4685 Thus we create those header only on demand now. */
4690 /* Given a BFD section, try to locate the corresponding ELF section
4691 index. This is used by both the 32-bit and the 64-bit ABI.
4692 Actually, it's not clear to me that the 64-bit ABI supports these,
4693 but for non-PIC objects we will certainly want support for at least
4694 the .scommon section. */
4697 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4698 asection
*sec
, int *retval
)
4700 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4702 *retval
= SHN_MIPS_SCOMMON
;
4705 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4707 *retval
= SHN_MIPS_ACOMMON
;
4713 /* Hook called by the linker routine which adds symbols from an object
4714 file. We must handle the special MIPS section numbers here. */
4717 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4718 Elf_Internal_Sym
*sym
, const char **namep
,
4719 flagword
*flagsp ATTRIBUTE_UNUSED
,
4720 asection
**secp
, bfd_vma
*valp
)
4722 if (SGI_COMPAT (abfd
)
4723 && (abfd
->flags
& DYNAMIC
) != 0
4724 && strcmp (*namep
, "_rld_new_interface") == 0)
4726 /* Skip IRIX5 rld entry name. */
4731 switch (sym
->st_shndx
)
4734 /* Common symbols less than the GP size are automatically
4735 treated as SHN_MIPS_SCOMMON symbols. */
4736 if (sym
->st_size
> elf_gp_size (abfd
)
4737 || IRIX_COMPAT (abfd
) == ict_irix6
)
4740 case SHN_MIPS_SCOMMON
:
4741 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4742 (*secp
)->flags
|= SEC_IS_COMMON
;
4743 *valp
= sym
->st_size
;
4747 /* This section is used in a shared object. */
4748 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4750 asymbol
*elf_text_symbol
;
4751 asection
*elf_text_section
;
4752 bfd_size_type amt
= sizeof (asection
);
4754 elf_text_section
= bfd_zalloc (abfd
, amt
);
4755 if (elf_text_section
== NULL
)
4758 amt
= sizeof (asymbol
);
4759 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4760 if (elf_text_symbol
== NULL
)
4763 /* Initialize the section. */
4765 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4766 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4768 elf_text_section
->symbol
= elf_text_symbol
;
4769 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4771 elf_text_section
->name
= ".text";
4772 elf_text_section
->flags
= SEC_NO_FLAGS
;
4773 elf_text_section
->output_section
= NULL
;
4774 elf_text_section
->owner
= abfd
;
4775 elf_text_symbol
->name
= ".text";
4776 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4777 elf_text_symbol
->section
= elf_text_section
;
4779 /* This code used to do *secp = bfd_und_section_ptr if
4780 info->shared. I don't know why, and that doesn't make sense,
4781 so I took it out. */
4782 *secp
= elf_tdata (abfd
)->elf_text_section
;
4785 case SHN_MIPS_ACOMMON
:
4786 /* Fall through. XXX Can we treat this as allocated data? */
4788 /* This section is used in a shared object. */
4789 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4791 asymbol
*elf_data_symbol
;
4792 asection
*elf_data_section
;
4793 bfd_size_type amt
= sizeof (asection
);
4795 elf_data_section
= bfd_zalloc (abfd
, amt
);
4796 if (elf_data_section
== NULL
)
4799 amt
= sizeof (asymbol
);
4800 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4801 if (elf_data_symbol
== NULL
)
4804 /* Initialize the section. */
4806 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4807 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4809 elf_data_section
->symbol
= elf_data_symbol
;
4810 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4812 elf_data_section
->name
= ".data";
4813 elf_data_section
->flags
= SEC_NO_FLAGS
;
4814 elf_data_section
->output_section
= NULL
;
4815 elf_data_section
->owner
= abfd
;
4816 elf_data_symbol
->name
= ".data";
4817 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4818 elf_data_symbol
->section
= elf_data_section
;
4820 /* This code used to do *secp = bfd_und_section_ptr if
4821 info->shared. I don't know why, and that doesn't make sense,
4822 so I took it out. */
4823 *secp
= elf_tdata (abfd
)->elf_data_section
;
4826 case SHN_MIPS_SUNDEFINED
:
4827 *secp
= bfd_und_section_ptr
;
4831 if (SGI_COMPAT (abfd
)
4833 && info
->hash
->creator
== abfd
->xvec
4834 && strcmp (*namep
, "__rld_obj_head") == 0)
4836 struct elf_link_hash_entry
*h
;
4837 struct bfd_link_hash_entry
*bh
;
4839 /* Mark __rld_obj_head as dynamic. */
4841 if (! (_bfd_generic_link_add_one_symbol
4842 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4843 get_elf_backend_data (abfd
)->collect
, &bh
)))
4846 h
= (struct elf_link_hash_entry
*) bh
;
4849 h
->type
= STT_OBJECT
;
4851 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4854 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4857 /* If this is a mips16 text symbol, add 1 to the value to make it
4858 odd. This will cause something like .word SYM to come up with
4859 the right value when it is loaded into the PC. */
4860 if (sym
->st_other
== STO_MIPS16
)
4866 /* This hook function is called before the linker writes out a global
4867 symbol. We mark symbols as small common if appropriate. This is
4868 also where we undo the increment of the value for a mips16 symbol. */
4871 _bfd_mips_elf_link_output_symbol_hook
4872 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4873 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4874 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4876 /* If we see a common symbol, which implies a relocatable link, then
4877 if a symbol was small common in an input file, mark it as small
4878 common in the output file. */
4879 if (sym
->st_shndx
== SHN_COMMON
4880 && strcmp (input_sec
->name
, ".scommon") == 0)
4881 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4883 if (sym
->st_other
== STO_MIPS16
)
4884 sym
->st_value
&= ~1;
4889 /* Functions for the dynamic linker. */
4891 /* Create dynamic sections when linking against a dynamic object. */
4894 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4896 struct elf_link_hash_entry
*h
;
4897 struct bfd_link_hash_entry
*bh
;
4899 register asection
*s
;
4900 const char * const *namep
;
4902 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4903 | SEC_LINKER_CREATED
| SEC_READONLY
);
4905 /* Mips ABI requests the .dynamic section to be read only. */
4906 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4909 if (! bfd_set_section_flags (abfd
, s
, flags
))
4913 /* We need to create .got section. */
4914 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4917 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4920 /* Create .stub section. */
4921 if (bfd_get_section_by_name (abfd
,
4922 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4924 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4926 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4927 || ! bfd_set_section_alignment (abfd
, s
,
4928 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4932 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4934 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4936 s
= bfd_make_section (abfd
, ".rld_map");
4938 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4939 || ! bfd_set_section_alignment (abfd
, s
,
4940 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4944 /* On IRIX5, we adjust add some additional symbols and change the
4945 alignments of several sections. There is no ABI documentation
4946 indicating that this is necessary on IRIX6, nor any evidence that
4947 the linker takes such action. */
4948 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4950 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4953 if (! (_bfd_generic_link_add_one_symbol
4954 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4955 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4958 h
= (struct elf_link_hash_entry
*) bh
;
4961 h
->type
= STT_SECTION
;
4963 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4967 /* We need to create a .compact_rel section. */
4968 if (SGI_COMPAT (abfd
))
4970 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4974 /* Change alignments of some sections. */
4975 s
= bfd_get_section_by_name (abfd
, ".hash");
4977 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4978 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4980 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4981 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4983 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4984 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4986 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4987 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4989 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4996 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4998 if (!(_bfd_generic_link_add_one_symbol
4999 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5000 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5003 h
= (struct elf_link_hash_entry
*) bh
;
5006 h
->type
= STT_SECTION
;
5008 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5011 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5013 /* __rld_map is a four byte word located in the .data section
5014 and is filled in by the rtld to contain a pointer to
5015 the _r_debug structure. Its symbol value will be set in
5016 _bfd_mips_elf_finish_dynamic_symbol. */
5017 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5018 BFD_ASSERT (s
!= NULL
);
5020 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5022 if (!(_bfd_generic_link_add_one_symbol
5023 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5024 get_elf_backend_data (abfd
)->collect
, &bh
)))
5027 h
= (struct elf_link_hash_entry
*) bh
;
5030 h
->type
= STT_OBJECT
;
5032 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5040 /* Look through the relocs for a section during the first phase, and
5041 allocate space in the global offset table. */
5044 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5045 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5049 Elf_Internal_Shdr
*symtab_hdr
;
5050 struct elf_link_hash_entry
**sym_hashes
;
5051 struct mips_got_info
*g
;
5053 const Elf_Internal_Rela
*rel
;
5054 const Elf_Internal_Rela
*rel_end
;
5057 const struct elf_backend_data
*bed
;
5059 if (info
->relocatable
)
5062 dynobj
= elf_hash_table (info
)->dynobj
;
5063 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5064 sym_hashes
= elf_sym_hashes (abfd
);
5065 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5067 /* Check for the mips16 stub sections. */
5069 name
= bfd_get_section_name (abfd
, sec
);
5070 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5072 unsigned long r_symndx
;
5074 /* Look at the relocation information to figure out which symbol
5077 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5079 if (r_symndx
< extsymoff
5080 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5084 /* This stub is for a local symbol. This stub will only be
5085 needed if there is some relocation in this BFD, other
5086 than a 16 bit function call, which refers to this symbol. */
5087 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5089 Elf_Internal_Rela
*sec_relocs
;
5090 const Elf_Internal_Rela
*r
, *rend
;
5092 /* We can ignore stub sections when looking for relocs. */
5093 if ((o
->flags
& SEC_RELOC
) == 0
5094 || o
->reloc_count
== 0
5095 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5096 sizeof FN_STUB
- 1) == 0
5097 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5098 sizeof CALL_STUB
- 1) == 0
5099 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5100 sizeof CALL_FP_STUB
- 1) == 0)
5104 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5106 if (sec_relocs
== NULL
)
5109 rend
= sec_relocs
+ o
->reloc_count
;
5110 for (r
= sec_relocs
; r
< rend
; r
++)
5111 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5112 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5115 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5124 /* There is no non-call reloc for this stub, so we do
5125 not need it. Since this function is called before
5126 the linker maps input sections to output sections, we
5127 can easily discard it by setting the SEC_EXCLUDE
5129 sec
->flags
|= SEC_EXCLUDE
;
5133 /* Record this stub in an array of local symbol stubs for
5135 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5137 unsigned long symcount
;
5141 if (elf_bad_symtab (abfd
))
5142 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5144 symcount
= symtab_hdr
->sh_info
;
5145 amt
= symcount
* sizeof (asection
*);
5146 n
= bfd_zalloc (abfd
, amt
);
5149 elf_tdata (abfd
)->local_stubs
= n
;
5152 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5154 /* We don't need to set mips16_stubs_seen in this case.
5155 That flag is used to see whether we need to look through
5156 the global symbol table for stubs. We don't need to set
5157 it here, because we just have a local stub. */
5161 struct mips_elf_link_hash_entry
*h
;
5163 h
= ((struct mips_elf_link_hash_entry
*)
5164 sym_hashes
[r_symndx
- extsymoff
]);
5166 /* H is the symbol this stub is for. */
5169 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5172 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5173 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5175 unsigned long r_symndx
;
5176 struct mips_elf_link_hash_entry
*h
;
5179 /* Look at the relocation information to figure out which symbol
5182 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5184 if (r_symndx
< extsymoff
5185 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5187 /* This stub was actually built for a static symbol defined
5188 in the same file. We assume that all static symbols in
5189 mips16 code are themselves mips16, so we can simply
5190 discard this stub. Since this function is called before
5191 the linker maps input sections to output sections, we can
5192 easily discard it by setting the SEC_EXCLUDE flag. */
5193 sec
->flags
|= SEC_EXCLUDE
;
5197 h
= ((struct mips_elf_link_hash_entry
*)
5198 sym_hashes
[r_symndx
- extsymoff
]);
5200 /* H is the symbol this stub is for. */
5202 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5203 loc
= &h
->call_fp_stub
;
5205 loc
= &h
->call_stub
;
5207 /* If we already have an appropriate stub for this function, we
5208 don't need another one, so we can discard this one. Since
5209 this function is called before the linker maps input sections
5210 to output sections, we can easily discard it by setting the
5211 SEC_EXCLUDE flag. We can also discard this section if we
5212 happen to already know that this is a mips16 function; it is
5213 not necessary to check this here, as it is checked later, but
5214 it is slightly faster to check now. */
5215 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5217 sec
->flags
|= SEC_EXCLUDE
;
5222 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5232 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5237 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5238 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5239 BFD_ASSERT (g
!= NULL
);
5244 bed
= get_elf_backend_data (abfd
);
5245 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5246 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5248 unsigned long r_symndx
;
5249 unsigned int r_type
;
5250 struct elf_link_hash_entry
*h
;
5252 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5253 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5255 if (r_symndx
< extsymoff
)
5257 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5259 (*_bfd_error_handler
)
5260 (_("%B: Malformed reloc detected for section %s"),
5262 bfd_set_error (bfd_error_bad_value
);
5267 h
= sym_hashes
[r_symndx
- extsymoff
];
5269 /* This may be an indirect symbol created because of a version. */
5272 while (h
->root
.type
== bfd_link_hash_indirect
)
5273 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5277 /* Some relocs require a global offset table. */
5278 if (dynobj
== NULL
|| sgot
== NULL
)
5284 case R_MIPS_CALL_HI16
:
5285 case R_MIPS_CALL_LO16
:
5286 case R_MIPS_GOT_HI16
:
5287 case R_MIPS_GOT_LO16
:
5288 case R_MIPS_GOT_PAGE
:
5289 case R_MIPS_GOT_OFST
:
5290 case R_MIPS_GOT_DISP
:
5292 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5293 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5295 g
= mips_elf_got_info (dynobj
, &sgot
);
5302 && (info
->shared
|| h
!= NULL
)
5303 && (sec
->flags
& SEC_ALLOC
) != 0)
5304 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5312 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5313 || r_type
== R_MIPS_GOT_LO16
5314 || r_type
== R_MIPS_GOT_DISP
))
5316 /* We may need a local GOT entry for this relocation. We
5317 don't count R_MIPS_GOT_PAGE because we can estimate the
5318 maximum number of pages needed by looking at the size of
5319 the segment. Similar comments apply to R_MIPS_GOT16 and
5320 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5321 R_MIPS_CALL_HI16 because these are always followed by an
5322 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5323 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5333 (*_bfd_error_handler
)
5334 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
5335 abfd
, (unsigned long) rel
->r_offset
);
5336 bfd_set_error (bfd_error_bad_value
);
5341 case R_MIPS_CALL_HI16
:
5342 case R_MIPS_CALL_LO16
:
5345 /* This symbol requires a global offset table entry. */
5346 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5349 /* We need a stub, not a plt entry for the undefined
5350 function. But we record it as if it needs plt. See
5351 _bfd_elf_adjust_dynamic_symbol. */
5357 case R_MIPS_GOT_PAGE
:
5358 /* If this is a global, overridable symbol, GOT_PAGE will
5359 decay to GOT_DISP, so we'll need a GOT entry for it. */
5364 struct mips_elf_link_hash_entry
*hmips
=
5365 (struct mips_elf_link_hash_entry
*) h
;
5367 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5368 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5369 hmips
= (struct mips_elf_link_hash_entry
*)
5370 hmips
->root
.root
.u
.i
.link
;
5372 if (hmips
->root
.def_regular
5373 && ! (info
->shared
&& ! info
->symbolic
5374 && ! hmips
->root
.forced_local
))
5380 case R_MIPS_GOT_HI16
:
5381 case R_MIPS_GOT_LO16
:
5382 case R_MIPS_GOT_DISP
:
5383 /* This symbol requires a global offset table entry. */
5384 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5391 if ((info
->shared
|| h
!= NULL
)
5392 && (sec
->flags
& SEC_ALLOC
) != 0)
5396 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5400 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5403 /* When creating a shared object, we must copy these
5404 reloc types into the output file as R_MIPS_REL32
5405 relocs. We make room for this reloc in the
5406 .rel.dyn reloc section. */
5407 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5408 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5409 == MIPS_READONLY_SECTION
)
5410 /* We tell the dynamic linker that there are
5411 relocations against the text segment. */
5412 info
->flags
|= DF_TEXTREL
;
5416 struct mips_elf_link_hash_entry
*hmips
;
5418 /* We only need to copy this reloc if the symbol is
5419 defined in a dynamic object. */
5420 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5421 ++hmips
->possibly_dynamic_relocs
;
5422 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5423 == MIPS_READONLY_SECTION
)
5424 /* We need it to tell the dynamic linker if there
5425 are relocations against the text segment. */
5426 hmips
->readonly_reloc
= TRUE
;
5429 /* Even though we don't directly need a GOT entry for
5430 this symbol, a symbol must have a dynamic symbol
5431 table index greater that DT_MIPS_GOTSYM if there are
5432 dynamic relocations against it. */
5436 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5437 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5439 g
= mips_elf_got_info (dynobj
, &sgot
);
5440 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5445 if (SGI_COMPAT (abfd
))
5446 mips_elf_hash_table (info
)->compact_rel_size
+=
5447 sizeof (Elf32_External_crinfo
);
5451 case R_MIPS_GPREL16
:
5452 case R_MIPS_LITERAL
:
5453 case R_MIPS_GPREL32
:
5454 if (SGI_COMPAT (abfd
))
5455 mips_elf_hash_table (info
)->compact_rel_size
+=
5456 sizeof (Elf32_External_crinfo
);
5459 /* This relocation describes the C++ object vtable hierarchy.
5460 Reconstruct it for later use during GC. */
5461 case R_MIPS_GNU_VTINHERIT
:
5462 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5466 /* This relocation describes which C++ vtable entries are actually
5467 used. Record for later use during GC. */
5468 case R_MIPS_GNU_VTENTRY
:
5469 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5477 /* We must not create a stub for a symbol that has relocations
5478 related to taking the function's address. */
5484 struct mips_elf_link_hash_entry
*mh
;
5486 mh
= (struct mips_elf_link_hash_entry
*) h
;
5487 mh
->no_fn_stub
= TRUE
;
5491 case R_MIPS_CALL_HI16
:
5492 case R_MIPS_CALL_LO16
:
5497 /* If this reloc is not a 16 bit call, and it has a global
5498 symbol, then we will need the fn_stub if there is one.
5499 References from a stub section do not count. */
5501 && r_type
!= R_MIPS16_26
5502 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5503 sizeof FN_STUB
- 1) != 0
5504 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5505 sizeof CALL_STUB
- 1) != 0
5506 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5507 sizeof CALL_FP_STUB
- 1) != 0)
5509 struct mips_elf_link_hash_entry
*mh
;
5511 mh
= (struct mips_elf_link_hash_entry
*) h
;
5512 mh
->need_fn_stub
= TRUE
;
5520 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5521 struct bfd_link_info
*link_info
,
5524 Elf_Internal_Rela
*internal_relocs
;
5525 Elf_Internal_Rela
*irel
, *irelend
;
5526 Elf_Internal_Shdr
*symtab_hdr
;
5527 bfd_byte
*contents
= NULL
;
5529 bfd_boolean changed_contents
= FALSE
;
5530 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5531 Elf_Internal_Sym
*isymbuf
= NULL
;
5533 /* We are not currently changing any sizes, so only one pass. */
5536 if (link_info
->relocatable
)
5539 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5540 link_info
->keep_memory
);
5541 if (internal_relocs
== NULL
)
5544 irelend
= internal_relocs
+ sec
->reloc_count
5545 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5546 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5547 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5549 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5552 bfd_signed_vma sym_offset
;
5553 unsigned int r_type
;
5554 unsigned long r_symndx
;
5556 unsigned long instruction
;
5558 /* Turn jalr into bgezal, and jr into beq, if they're marked
5559 with a JALR relocation, that indicate where they jump to.
5560 This saves some pipeline bubbles. */
5561 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5562 if (r_type
!= R_MIPS_JALR
)
5565 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5566 /* Compute the address of the jump target. */
5567 if (r_symndx
>= extsymoff
)
5569 struct mips_elf_link_hash_entry
*h
5570 = ((struct mips_elf_link_hash_entry
*)
5571 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5573 while (h
->root
.root
.type
== bfd_link_hash_indirect
5574 || h
->root
.root
.type
== bfd_link_hash_warning
)
5575 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5577 /* If a symbol is undefined, or if it may be overridden,
5579 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5580 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5581 && h
->root
.root
.u
.def
.section
)
5582 || (link_info
->shared
&& ! link_info
->symbolic
5583 && !h
->root
.forced_local
))
5586 sym_sec
= h
->root
.root
.u
.def
.section
;
5587 if (sym_sec
->output_section
)
5588 symval
= (h
->root
.root
.u
.def
.value
5589 + sym_sec
->output_section
->vma
5590 + sym_sec
->output_offset
);
5592 symval
= h
->root
.root
.u
.def
.value
;
5596 Elf_Internal_Sym
*isym
;
5598 /* Read this BFD's symbols if we haven't done so already. */
5599 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5601 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5602 if (isymbuf
== NULL
)
5603 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5604 symtab_hdr
->sh_info
, 0,
5606 if (isymbuf
== NULL
)
5610 isym
= isymbuf
+ r_symndx
;
5611 if (isym
->st_shndx
== SHN_UNDEF
)
5613 else if (isym
->st_shndx
== SHN_ABS
)
5614 sym_sec
= bfd_abs_section_ptr
;
5615 else if (isym
->st_shndx
== SHN_COMMON
)
5616 sym_sec
= bfd_com_section_ptr
;
5619 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5620 symval
= isym
->st_value
5621 + sym_sec
->output_section
->vma
5622 + sym_sec
->output_offset
;
5625 /* Compute branch offset, from delay slot of the jump to the
5627 sym_offset
= (symval
+ irel
->r_addend
)
5628 - (sec_start
+ irel
->r_offset
+ 4);
5630 /* Branch offset must be properly aligned. */
5631 if ((sym_offset
& 3) != 0)
5636 /* Check that it's in range. */
5637 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5640 /* Get the section contents if we haven't done so already. */
5641 if (contents
== NULL
)
5643 /* Get cached copy if it exists. */
5644 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5645 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5648 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
5653 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5655 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5656 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5657 instruction
= 0x04110000;
5658 /* If it was jr <reg>, turn it into b <target>. */
5659 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5660 instruction
= 0x10000000;
5664 instruction
|= (sym_offset
& 0xffff);
5665 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5666 changed_contents
= TRUE
;
5669 if (contents
!= NULL
5670 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5672 if (!changed_contents
&& !link_info
->keep_memory
)
5676 /* Cache the section contents for elf_link_input_bfd. */
5677 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5683 if (contents
!= NULL
5684 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5689 /* Adjust a symbol defined by a dynamic object and referenced by a
5690 regular object. The current definition is in some section of the
5691 dynamic object, but we're not including those sections. We have to
5692 change the definition to something the rest of the link can
5696 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5697 struct elf_link_hash_entry
*h
)
5700 struct mips_elf_link_hash_entry
*hmips
;
5703 dynobj
= elf_hash_table (info
)->dynobj
;
5705 /* Make sure we know what is going on here. */
5706 BFD_ASSERT (dynobj
!= NULL
5708 || h
->u
.weakdef
!= NULL
5711 && !h
->def_regular
)));
5713 /* If this symbol is defined in a dynamic object, we need to copy
5714 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5716 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5717 if (! info
->relocatable
5718 && hmips
->possibly_dynamic_relocs
!= 0
5719 && (h
->root
.type
== bfd_link_hash_defweak
5720 || !h
->def_regular
))
5722 mips_elf_allocate_dynamic_relocations (dynobj
,
5723 hmips
->possibly_dynamic_relocs
);
5724 if (hmips
->readonly_reloc
)
5725 /* We tell the dynamic linker that there are relocations
5726 against the text segment. */
5727 info
->flags
|= DF_TEXTREL
;
5730 /* For a function, create a stub, if allowed. */
5731 if (! hmips
->no_fn_stub
5734 if (! elf_hash_table (info
)->dynamic_sections_created
)
5737 /* If this symbol is not defined in a regular file, then set
5738 the symbol to the stub location. This is required to make
5739 function pointers compare as equal between the normal
5740 executable and the shared library. */
5741 if (!h
->def_regular
)
5743 /* We need .stub section. */
5744 s
= bfd_get_section_by_name (dynobj
,
5745 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5746 BFD_ASSERT (s
!= NULL
);
5748 h
->root
.u
.def
.section
= s
;
5749 h
->root
.u
.def
.value
= s
->size
;
5751 /* XXX Write this stub address somewhere. */
5752 h
->plt
.offset
= s
->size
;
5754 /* Make room for this stub code. */
5755 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
5757 /* The last half word of the stub will be filled with the index
5758 of this symbol in .dynsym section. */
5762 else if ((h
->type
== STT_FUNC
)
5765 /* This will set the entry for this symbol in the GOT to 0, and
5766 the dynamic linker will take care of this. */
5767 h
->root
.u
.def
.value
= 0;
5771 /* If this is a weak symbol, and there is a real definition, the
5772 processor independent code will have arranged for us to see the
5773 real definition first, and we can just use the same value. */
5774 if (h
->u
.weakdef
!= NULL
)
5776 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
5777 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
5778 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
5779 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
5783 /* This is a reference to a symbol defined by a dynamic object which
5784 is not a function. */
5789 /* This function is called after all the input files have been read,
5790 and the input sections have been assigned to output sections. We
5791 check for any mips16 stub sections that we can discard. */
5794 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5795 struct bfd_link_info
*info
)
5801 struct mips_got_info
*g
;
5803 bfd_size_type loadable_size
= 0;
5804 bfd_size_type local_gotno
;
5807 /* The .reginfo section has a fixed size. */
5808 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5810 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5812 if (! (info
->relocatable
5813 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5814 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5815 mips_elf_check_mips16_stubs
, NULL
);
5817 dynobj
= elf_hash_table (info
)->dynobj
;
5819 /* Relocatable links don't have it. */
5822 g
= mips_elf_got_info (dynobj
, &s
);
5826 /* Calculate the total loadable size of the output. That
5827 will give us the maximum number of GOT_PAGE entries
5829 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5831 asection
*subsection
;
5833 for (subsection
= sub
->sections
;
5835 subsection
= subsection
->next
)
5837 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5839 loadable_size
+= ((subsection
->size
+ 0xf)
5840 &~ (bfd_size_type
) 0xf);
5844 /* There has to be a global GOT entry for every symbol with
5845 a dynamic symbol table index of DT_MIPS_GOTSYM or
5846 higher. Therefore, it make sense to put those symbols
5847 that need GOT entries at the end of the symbol table. We
5849 if (! mips_elf_sort_hash_table (info
, 1))
5852 if (g
->global_gotsym
!= NULL
)
5853 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5855 /* If there are no global symbols, or none requiring
5856 relocations, then GLOBAL_GOTSYM will be NULL. */
5859 /* In the worst case, we'll get one stub per dynamic symbol, plus
5860 one to account for the dummy entry at the end required by IRIX
5862 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5864 /* Assume there are two loadable segments consisting of
5865 contiguous sections. Is 5 enough? */
5866 local_gotno
= (loadable_size
>> 16) + 5;
5868 g
->local_gotno
+= local_gotno
;
5869 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5871 g
->global_gotno
= i
;
5872 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5874 if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5875 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5881 /* Set the sizes of the dynamic sections. */
5884 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5885 struct bfd_link_info
*info
)
5889 bfd_boolean reltext
;
5891 dynobj
= elf_hash_table (info
)->dynobj
;
5892 BFD_ASSERT (dynobj
!= NULL
);
5894 if (elf_hash_table (info
)->dynamic_sections_created
)
5896 /* Set the contents of the .interp section to the interpreter. */
5897 if (info
->executable
)
5899 s
= bfd_get_section_by_name (dynobj
, ".interp");
5900 BFD_ASSERT (s
!= NULL
);
5902 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5904 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5908 /* The check_relocs and adjust_dynamic_symbol entry points have
5909 determined the sizes of the various dynamic sections. Allocate
5912 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5917 /* It's OK to base decisions on the section name, because none
5918 of the dynobj section names depend upon the input files. */
5919 name
= bfd_get_section_name (dynobj
, s
);
5921 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5926 if (strncmp (name
, ".rel", 4) == 0)
5930 /* We only strip the section if the output section name
5931 has the same name. Otherwise, there might be several
5932 input sections for this output section. FIXME: This
5933 code is probably not needed these days anyhow, since
5934 the linker now does not create empty output sections. */
5935 if (s
->output_section
!= NULL
5937 bfd_get_section_name (s
->output_section
->owner
,
5938 s
->output_section
)) == 0)
5943 const char *outname
;
5946 /* If this relocation section applies to a read only
5947 section, then we probably need a DT_TEXTREL entry.
5948 If the relocation section is .rel.dyn, we always
5949 assert a DT_TEXTREL entry rather than testing whether
5950 there exists a relocation to a read only section or
5952 outname
= bfd_get_section_name (output_bfd
,
5954 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5956 && (target
->flags
& SEC_READONLY
) != 0
5957 && (target
->flags
& SEC_ALLOC
) != 0)
5958 || strcmp (outname
, ".rel.dyn") == 0)
5961 /* We use the reloc_count field as a counter if we need
5962 to copy relocs into the output file. */
5963 if (strcmp (name
, ".rel.dyn") != 0)
5966 /* If combreloc is enabled, elf_link_sort_relocs() will
5967 sort relocations, but in a different way than we do,
5968 and before we're done creating relocations. Also, it
5969 will move them around between input sections'
5970 relocation's contents, so our sorting would be
5971 broken, so don't let it run. */
5972 info
->combreloc
= 0;
5975 else if (strncmp (name
, ".got", 4) == 0)
5977 /* _bfd_mips_elf_always_size_sections() has already done
5978 most of the work, but some symbols may have been mapped
5979 to versions that we must now resolve in the got_entries
5981 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5982 struct mips_got_info
*g
= gg
;
5983 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5984 unsigned int needed_relocs
= 0;
5988 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5989 set_got_offset_arg
.info
= info
;
5991 mips_elf_resolve_final_got_entries (gg
);
5992 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5994 unsigned int save_assign
;
5996 mips_elf_resolve_final_got_entries (g
);
5998 /* Assign offsets to global GOT entries. */
5999 save_assign
= g
->assigned_gotno
;
6000 g
->assigned_gotno
= g
->local_gotno
;
6001 set_got_offset_arg
.g
= g
;
6002 set_got_offset_arg
.needed_relocs
= 0;
6003 htab_traverse (g
->got_entries
,
6004 mips_elf_set_global_got_offset
,
6005 &set_got_offset_arg
);
6006 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6007 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6008 <= g
->global_gotno
);
6010 g
->assigned_gotno
= save_assign
;
6013 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6014 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6015 + g
->next
->global_gotno
6016 + MIPS_RESERVED_GOTNO
);
6021 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6024 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6026 /* IRIX rld assumes that the function stub isn't at the end
6027 of .text section. So put a dummy. XXX */
6028 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6030 else if (! info
->shared
6031 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6032 && strncmp (name
, ".rld_map", 8) == 0)
6034 /* We add a room for __rld_map. It will be filled in by the
6035 rtld to contain a pointer to the _r_debug structure. */
6038 else if (SGI_COMPAT (output_bfd
)
6039 && strncmp (name
, ".compact_rel", 12) == 0)
6040 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6041 else if (strncmp (name
, ".init", 5) != 0)
6043 /* It's not one of our sections, so don't allocate space. */
6049 _bfd_strip_section_from_output (info
, s
);
6053 /* Allocate memory for the section contents. */
6054 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
6055 if (s
->contents
== NULL
&& s
->size
!= 0)
6057 bfd_set_error (bfd_error_no_memory
);
6062 if (elf_hash_table (info
)->dynamic_sections_created
)
6064 /* Add some entries to the .dynamic section. We fill in the
6065 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6066 must add the entries now so that we get the correct size for
6067 the .dynamic section. The DT_DEBUG entry is filled in by the
6068 dynamic linker and used by the debugger. */
6071 /* SGI object has the equivalence of DT_DEBUG in the
6072 DT_MIPS_RLD_MAP entry. */
6073 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6075 if (!SGI_COMPAT (output_bfd
))
6077 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6083 /* Shared libraries on traditional mips have DT_DEBUG. */
6084 if (!SGI_COMPAT (output_bfd
))
6086 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6091 if (reltext
&& SGI_COMPAT (output_bfd
))
6092 info
->flags
|= DF_TEXTREL
;
6094 if ((info
->flags
& DF_TEXTREL
) != 0)
6096 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6100 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6103 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6105 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6108 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6111 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6115 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6118 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6121 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6124 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6127 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6130 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6133 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6136 if (IRIX_COMPAT (dynobj
) == ict_irix5
6137 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6140 if (IRIX_COMPAT (dynobj
) == ict_irix6
6141 && (bfd_get_section_by_name
6142 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6143 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6150 /* Relocate a MIPS ELF section. */
6153 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6154 bfd
*input_bfd
, asection
*input_section
,
6155 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6156 Elf_Internal_Sym
*local_syms
,
6157 asection
**local_sections
)
6159 Elf_Internal_Rela
*rel
;
6160 const Elf_Internal_Rela
*relend
;
6162 bfd_boolean use_saved_addend_p
= FALSE
;
6163 const struct elf_backend_data
*bed
;
6165 bed
= get_elf_backend_data (output_bfd
);
6166 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6167 for (rel
= relocs
; rel
< relend
; ++rel
)
6171 reloc_howto_type
*howto
;
6172 bfd_boolean require_jalx
;
6173 /* TRUE if the relocation is a RELA relocation, rather than a
6175 bfd_boolean rela_relocation_p
= TRUE
;
6176 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6179 /* Find the relocation howto for this relocation. */
6180 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6182 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6183 64-bit code, but make sure all their addresses are in the
6184 lowermost or uppermost 32-bit section of the 64-bit address
6185 space. Thus, when they use an R_MIPS_64 they mean what is
6186 usually meant by R_MIPS_32, with the exception that the
6187 stored value is sign-extended to 64 bits. */
6188 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6190 /* On big-endian systems, we need to lie about the position
6192 if (bfd_big_endian (input_bfd
))
6196 /* NewABI defaults to RELA relocations. */
6197 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6198 NEWABI_P (input_bfd
)
6199 && (MIPS_RELOC_RELA_P
6200 (input_bfd
, input_section
,
6203 if (!use_saved_addend_p
)
6205 Elf_Internal_Shdr
*rel_hdr
;
6207 /* If these relocations were originally of the REL variety,
6208 we must pull the addend out of the field that will be
6209 relocated. Otherwise, we simply use the contents of the
6210 RELA relocation. To determine which flavor or relocation
6211 this is, we depend on the fact that the INPUT_SECTION's
6212 REL_HDR is read before its REL_HDR2. */
6213 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6214 if ((size_t) (rel
- relocs
)
6215 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6216 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6217 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6219 bfd_byte
*location
= contents
+ rel
->r_offset
;
6221 /* Note that this is a REL relocation. */
6222 rela_relocation_p
= FALSE
;
6224 /* Get the addend, which is stored in the input file. */
6225 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
6227 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6229 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
6232 addend
&= howto
->src_mask
;
6234 /* For some kinds of relocations, the ADDEND is a
6235 combination of the addend stored in two different
6237 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
6238 || (r_type
== R_MIPS_GOT16
6239 && mips_elf_local_relocation_p (input_bfd
, rel
,
6240 local_sections
, FALSE
)))
6243 const Elf_Internal_Rela
*lo16_relocation
;
6244 reloc_howto_type
*lo16_howto
;
6245 bfd_byte
*lo16_location
;
6248 if (r_type
== R_MIPS16_HI16
)
6249 lo16_type
= R_MIPS16_LO16
;
6251 lo16_type
= R_MIPS_LO16
;
6253 /* The combined value is the sum of the HI16 addend,
6254 left-shifted by sixteen bits, and the LO16
6255 addend, sign extended. (Usually, the code does
6256 a `lui' of the HI16 value, and then an `addiu' of
6259 Scan ahead to find a matching LO16 relocation.
6261 According to the MIPS ELF ABI, the R_MIPS_LO16
6262 relocation must be immediately following.
6263 However, for the IRIX6 ABI, the next relocation
6264 may be a composed relocation consisting of
6265 several relocations for the same address. In
6266 that case, the R_MIPS_LO16 relocation may occur
6267 as one of these. We permit a similar extension
6268 in general, as that is useful for GCC. */
6269 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
6272 if (lo16_relocation
== NULL
)
6275 lo16_location
= contents
+ lo16_relocation
->r_offset
;
6277 /* Obtain the addend kept there. */
6278 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
6280 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
6282 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6283 input_bfd
, contents
);
6284 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
6286 l
&= lo16_howto
->src_mask
;
6287 l
<<= lo16_howto
->rightshift
;
6288 l
= _bfd_mips_elf_sign_extend (l
, 16);
6292 /* Compute the combined addend. */
6296 addend
<<= howto
->rightshift
;
6299 addend
= rel
->r_addend
;
6302 if (info
->relocatable
)
6304 Elf_Internal_Sym
*sym
;
6305 unsigned long r_symndx
;
6307 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6308 && bfd_big_endian (input_bfd
))
6311 /* Since we're just relocating, all we need to do is copy
6312 the relocations back out to the object file, unless
6313 they're against a section symbol, in which case we need
6314 to adjust by the section offset, or unless they're GP
6315 relative in which case we need to adjust by the amount
6316 that we're adjusting GP in this relocatable object. */
6318 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6320 /* There's nothing to do for non-local relocations. */
6323 if (r_type
== R_MIPS16_GPREL
6324 || r_type
== R_MIPS_GPREL16
6325 || r_type
== R_MIPS_GPREL32
6326 || r_type
== R_MIPS_LITERAL
)
6327 addend
-= (_bfd_get_gp_value (output_bfd
)
6328 - _bfd_get_gp_value (input_bfd
));
6330 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6331 sym
= local_syms
+ r_symndx
;
6332 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6333 /* Adjust the addend appropriately. */
6334 addend
+= local_sections
[r_symndx
]->output_offset
;
6336 if (rela_relocation_p
)
6337 /* If this is a RELA relocation, just update the addend. */
6338 rel
->r_addend
= addend
;
6341 if (r_type
== R_MIPS_HI16
6342 || r_type
== R_MIPS_GOT16
)
6343 addend
= mips_elf_high (addend
);
6344 else if (r_type
== R_MIPS_HIGHER
)
6345 addend
= mips_elf_higher (addend
);
6346 else if (r_type
== R_MIPS_HIGHEST
)
6347 addend
= mips_elf_highest (addend
);
6349 addend
>>= howto
->rightshift
;
6351 /* We use the source mask, rather than the destination
6352 mask because the place to which we are writing will be
6353 source of the addend in the final link. */
6354 addend
&= howto
->src_mask
;
6356 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6357 /* See the comment above about using R_MIPS_64 in the 32-bit
6358 ABI. Here, we need to update the addend. It would be
6359 possible to get away with just using the R_MIPS_32 reloc
6360 but for endianness. */
6366 if (addend
& ((bfd_vma
) 1 << 31))
6368 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6375 /* If we don't know that we have a 64-bit type,
6376 do two separate stores. */
6377 if (bfd_big_endian (input_bfd
))
6379 /* Store the sign-bits (which are most significant)
6381 low_bits
= sign_bits
;
6387 high_bits
= sign_bits
;
6389 bfd_put_32 (input_bfd
, low_bits
,
6390 contents
+ rel
->r_offset
);
6391 bfd_put_32 (input_bfd
, high_bits
,
6392 contents
+ rel
->r_offset
+ 4);
6396 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6397 input_bfd
, input_section
,
6402 /* Go on to the next relocation. */
6406 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6407 relocations for the same offset. In that case we are
6408 supposed to treat the output of each relocation as the addend
6410 if (rel
+ 1 < relend
6411 && rel
->r_offset
== rel
[1].r_offset
6412 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6413 use_saved_addend_p
= TRUE
;
6415 use_saved_addend_p
= FALSE
;
6417 /* Figure out what value we are supposed to relocate. */
6418 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6419 input_section
, info
, rel
,
6420 addend
, howto
, local_syms
,
6421 local_sections
, &value
,
6422 &name
, &require_jalx
,
6423 use_saved_addend_p
))
6425 case bfd_reloc_continue
:
6426 /* There's nothing to do. */
6429 case bfd_reloc_undefined
:
6430 /* mips_elf_calculate_relocation already called the
6431 undefined_symbol callback. There's no real point in
6432 trying to perform the relocation at this point, so we
6433 just skip ahead to the next relocation. */
6436 case bfd_reloc_notsupported
:
6437 msg
= _("internal error: unsupported relocation error");
6438 info
->callbacks
->warning
6439 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6442 case bfd_reloc_overflow
:
6443 if (use_saved_addend_p
)
6444 /* Ignore overflow until we reach the last relocation for
6445 a given location. */
6449 BFD_ASSERT (name
!= NULL
);
6450 if (! ((*info
->callbacks
->reloc_overflow
)
6451 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
6452 input_bfd
, input_section
, rel
->r_offset
)))
6465 /* If we've got another relocation for the address, keep going
6466 until we reach the last one. */
6467 if (use_saved_addend_p
)
6473 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6474 /* See the comment above about using R_MIPS_64 in the 32-bit
6475 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6476 that calculated the right value. Now, however, we
6477 sign-extend the 32-bit result to 64-bits, and store it as a
6478 64-bit value. We are especially generous here in that we
6479 go to extreme lengths to support this usage on systems with
6480 only a 32-bit VMA. */
6486 if (value
& ((bfd_vma
) 1 << 31))
6488 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6495 /* If we don't know that we have a 64-bit type,
6496 do two separate stores. */
6497 if (bfd_big_endian (input_bfd
))
6499 /* Undo what we did above. */
6501 /* Store the sign-bits (which are most significant)
6503 low_bits
= sign_bits
;
6509 high_bits
= sign_bits
;
6511 bfd_put_32 (input_bfd
, low_bits
,
6512 contents
+ rel
->r_offset
);
6513 bfd_put_32 (input_bfd
, high_bits
,
6514 contents
+ rel
->r_offset
+ 4);
6518 /* Actually perform the relocation. */
6519 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6520 input_bfd
, input_section
,
6521 contents
, require_jalx
))
6528 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6529 adjust it appropriately now. */
6532 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6533 const char *name
, Elf_Internal_Sym
*sym
)
6535 /* The linker script takes care of providing names and values for
6536 these, but we must place them into the right sections. */
6537 static const char* const text_section_symbols
[] = {
6540 "__dso_displacement",
6542 "__program_header_table",
6546 static const char* const data_section_symbols
[] = {
6554 const char* const *p
;
6557 for (i
= 0; i
< 2; ++i
)
6558 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6561 if (strcmp (*p
, name
) == 0)
6563 /* All of these symbols are given type STT_SECTION by the
6565 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6566 sym
->st_other
= STO_PROTECTED
;
6568 /* The IRIX linker puts these symbols in special sections. */
6570 sym
->st_shndx
= SHN_MIPS_TEXT
;
6572 sym
->st_shndx
= SHN_MIPS_DATA
;
6578 /* Finish up dynamic symbol handling. We set the contents of various
6579 dynamic sections here. */
6582 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6583 struct bfd_link_info
*info
,
6584 struct elf_link_hash_entry
*h
,
6585 Elf_Internal_Sym
*sym
)
6589 struct mips_got_info
*g
, *gg
;
6592 dynobj
= elf_hash_table (info
)->dynobj
;
6594 if (h
->plt
.offset
!= MINUS_ONE
)
6597 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6599 /* This symbol has a stub. Set it up. */
6601 BFD_ASSERT (h
->dynindx
!= -1);
6603 s
= bfd_get_section_by_name (dynobj
,
6604 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6605 BFD_ASSERT (s
!= NULL
);
6607 /* FIXME: Can h->dynindex be more than 64K? */
6608 if (h
->dynindx
& 0xffff0000)
6611 /* Fill the stub. */
6612 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6613 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6614 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6615 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6617 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
6618 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6620 /* Mark the symbol as undefined. plt.offset != -1 occurs
6621 only for the referenced symbol. */
6622 sym
->st_shndx
= SHN_UNDEF
;
6624 /* The run-time linker uses the st_value field of the symbol
6625 to reset the global offset table entry for this external
6626 to its stub address when unlinking a shared object. */
6627 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
6631 BFD_ASSERT (h
->dynindx
!= -1
6632 || h
->forced_local
);
6634 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6635 BFD_ASSERT (sgot
!= NULL
);
6636 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6637 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6638 BFD_ASSERT (g
!= NULL
);
6640 /* Run through the global symbol table, creating GOT entries for all
6641 the symbols that need them. */
6642 if (g
->global_gotsym
!= NULL
6643 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6648 value
= sym
->st_value
;
6649 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6650 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6653 if (g
->next
&& h
->dynindx
!= -1)
6655 struct mips_got_entry e
, *p
;
6661 e
.abfd
= output_bfd
;
6663 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6665 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6668 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6673 || (elf_hash_table (info
)->dynamic_sections_created
6675 && p
->d
.h
->root
.def_dynamic
6676 && !p
->d
.h
->root
.def_regular
))
6678 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6679 the various compatibility problems, it's easier to mock
6680 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6681 mips_elf_create_dynamic_relocation to calculate the
6682 appropriate addend. */
6683 Elf_Internal_Rela rel
[3];
6685 memset (rel
, 0, sizeof (rel
));
6686 if (ABI_64_P (output_bfd
))
6687 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6689 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6690 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6693 if (! (mips_elf_create_dynamic_relocation
6694 (output_bfd
, info
, rel
,
6695 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6699 entry
= sym
->st_value
;
6700 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6705 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6706 name
= h
->root
.root
.string
;
6707 if (strcmp (name
, "_DYNAMIC") == 0
6708 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6709 sym
->st_shndx
= SHN_ABS
;
6710 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6711 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6713 sym
->st_shndx
= SHN_ABS
;
6714 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6717 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6719 sym
->st_shndx
= SHN_ABS
;
6720 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6721 sym
->st_value
= elf_gp (output_bfd
);
6723 else if (SGI_COMPAT (output_bfd
))
6725 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6726 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6728 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6729 sym
->st_other
= STO_PROTECTED
;
6731 sym
->st_shndx
= SHN_MIPS_DATA
;
6733 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6735 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6736 sym
->st_other
= STO_PROTECTED
;
6737 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6738 sym
->st_shndx
= SHN_ABS
;
6740 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6742 if (h
->type
== STT_FUNC
)
6743 sym
->st_shndx
= SHN_MIPS_TEXT
;
6744 else if (h
->type
== STT_OBJECT
)
6745 sym
->st_shndx
= SHN_MIPS_DATA
;
6749 /* Handle the IRIX6-specific symbols. */
6750 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6751 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6755 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6756 && (strcmp (name
, "__rld_map") == 0
6757 || strcmp (name
, "__RLD_MAP") == 0))
6759 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6760 BFD_ASSERT (s
!= NULL
);
6761 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6762 bfd_put_32 (output_bfd
, 0, s
->contents
);
6763 if (mips_elf_hash_table (info
)->rld_value
== 0)
6764 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6766 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6767 && strcmp (name
, "__rld_obj_head") == 0)
6769 /* IRIX6 does not use a .rld_map section. */
6770 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6771 || IRIX_COMPAT (output_bfd
) == ict_none
)
6772 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6774 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6778 /* If this is a mips16 symbol, force the value to be even. */
6779 if (sym
->st_other
== STO_MIPS16
)
6780 sym
->st_value
&= ~1;
6785 /* Finish up the dynamic sections. */
6788 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6789 struct bfd_link_info
*info
)
6794 struct mips_got_info
*gg
, *g
;
6796 dynobj
= elf_hash_table (info
)->dynobj
;
6798 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6800 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6805 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6806 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6807 BFD_ASSERT (gg
!= NULL
);
6808 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6809 BFD_ASSERT (g
!= NULL
);
6812 if (elf_hash_table (info
)->dynamic_sections_created
)
6816 BFD_ASSERT (sdyn
!= NULL
);
6817 BFD_ASSERT (g
!= NULL
);
6819 for (b
= sdyn
->contents
;
6820 b
< sdyn
->contents
+ sdyn
->size
;
6821 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6823 Elf_Internal_Dyn dyn
;
6827 bfd_boolean swap_out_p
;
6829 /* Read in the current dynamic entry. */
6830 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6832 /* Assume that we're going to modify it and write it out. */
6838 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6839 BFD_ASSERT (s
!= NULL
);
6840 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6844 /* Rewrite DT_STRSZ. */
6846 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6851 s
= bfd_get_section_by_name (output_bfd
, name
);
6852 BFD_ASSERT (s
!= NULL
);
6853 dyn
.d_un
.d_ptr
= s
->vma
;
6856 case DT_MIPS_RLD_VERSION
:
6857 dyn
.d_un
.d_val
= 1; /* XXX */
6861 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6864 case DT_MIPS_TIME_STAMP
:
6865 time ((time_t *) &dyn
.d_un
.d_val
);
6868 case DT_MIPS_ICHECKSUM
:
6873 case DT_MIPS_IVERSION
:
6878 case DT_MIPS_BASE_ADDRESS
:
6879 s
= output_bfd
->sections
;
6880 BFD_ASSERT (s
!= NULL
);
6881 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6884 case DT_MIPS_LOCAL_GOTNO
:
6885 dyn
.d_un
.d_val
= g
->local_gotno
;
6888 case DT_MIPS_UNREFEXTNO
:
6889 /* The index into the dynamic symbol table which is the
6890 entry of the first external symbol that is not
6891 referenced within the same object. */
6892 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6895 case DT_MIPS_GOTSYM
:
6896 if (gg
->global_gotsym
)
6898 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6901 /* In case if we don't have global got symbols we default
6902 to setting DT_MIPS_GOTSYM to the same value as
6903 DT_MIPS_SYMTABNO, so we just fall through. */
6905 case DT_MIPS_SYMTABNO
:
6907 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6908 s
= bfd_get_section_by_name (output_bfd
, name
);
6909 BFD_ASSERT (s
!= NULL
);
6911 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
6914 case DT_MIPS_HIPAGENO
:
6915 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6918 case DT_MIPS_RLD_MAP
:
6919 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6922 case DT_MIPS_OPTIONS
:
6923 s
= (bfd_get_section_by_name
6924 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6925 dyn
.d_un
.d_ptr
= s
->vma
;
6929 /* Reduce DT_RELSZ to account for any relocations we
6930 decided not to make. This is for the n64 irix rld,
6931 which doesn't seem to apply any relocations if there
6932 are trailing null entries. */
6933 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6934 dyn
.d_un
.d_val
= (s
->reloc_count
6935 * (ABI_64_P (output_bfd
)
6936 ? sizeof (Elf64_Mips_External_Rel
)
6937 : sizeof (Elf32_External_Rel
)));
6946 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6951 /* The first entry of the global offset table will be filled at
6952 runtime. The second entry will be used by some runtime loaders.
6953 This isn't the case of IRIX rld. */
6954 if (sgot
!= NULL
&& sgot
->size
> 0)
6956 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
6957 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
6958 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6962 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6963 = MIPS_ELF_GOT_SIZE (output_bfd
);
6965 /* Generate dynamic relocations for the non-primary gots. */
6966 if (gg
!= NULL
&& gg
->next
)
6968 Elf_Internal_Rela rel
[3];
6971 memset (rel
, 0, sizeof (rel
));
6972 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6974 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
6976 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
6978 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
6979 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6980 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
6981 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6986 while (index
< g
->assigned_gotno
)
6988 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
6989 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
6990 if (!(mips_elf_create_dynamic_relocation
6991 (output_bfd
, info
, rel
, NULL
,
6992 bfd_abs_section_ptr
,
6995 BFD_ASSERT (addend
== 0);
7002 Elf32_compact_rel cpt
;
7004 if (SGI_COMPAT (output_bfd
))
7006 /* Write .compact_rel section out. */
7007 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7011 cpt
.num
= s
->reloc_count
;
7013 cpt
.offset
= (s
->output_section
->filepos
7014 + sizeof (Elf32_External_compact_rel
));
7017 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7018 ((Elf32_External_compact_rel
*)
7021 /* Clean up a dummy stub function entry in .text. */
7022 s
= bfd_get_section_by_name (dynobj
,
7023 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7026 file_ptr dummy_offset
;
7028 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE
);
7029 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE
;
7030 memset (s
->contents
+ dummy_offset
, 0,
7031 MIPS_FUNCTION_STUB_SIZE
);
7036 /* We need to sort the entries of the dynamic relocation section. */
7038 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7041 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7043 reldyn_sorting_bfd
= output_bfd
;
7045 if (ABI_64_P (output_bfd
))
7046 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7047 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7049 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7050 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7058 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7061 mips_set_isa_flags (bfd
*abfd
)
7065 switch (bfd_get_mach (abfd
))
7068 case bfd_mach_mips3000
:
7069 val
= E_MIPS_ARCH_1
;
7072 case bfd_mach_mips3900
:
7073 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7076 case bfd_mach_mips6000
:
7077 val
= E_MIPS_ARCH_2
;
7080 case bfd_mach_mips4000
:
7081 case bfd_mach_mips4300
:
7082 case bfd_mach_mips4400
:
7083 case bfd_mach_mips4600
:
7084 val
= E_MIPS_ARCH_3
;
7087 case bfd_mach_mips4010
:
7088 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7091 case bfd_mach_mips4100
:
7092 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7095 case bfd_mach_mips4111
:
7096 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7099 case bfd_mach_mips4120
:
7100 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7103 case bfd_mach_mips4650
:
7104 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7107 case bfd_mach_mips5400
:
7108 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7111 case bfd_mach_mips5500
:
7112 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7115 case bfd_mach_mips9000
:
7116 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
7119 case bfd_mach_mips5000
:
7120 case bfd_mach_mips7000
:
7121 case bfd_mach_mips8000
:
7122 case bfd_mach_mips10000
:
7123 case bfd_mach_mips12000
:
7124 val
= E_MIPS_ARCH_4
;
7127 case bfd_mach_mips5
:
7128 val
= E_MIPS_ARCH_5
;
7131 case bfd_mach_mips_sb1
:
7132 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7135 case bfd_mach_mipsisa32
:
7136 val
= E_MIPS_ARCH_32
;
7139 case bfd_mach_mipsisa64
:
7140 val
= E_MIPS_ARCH_64
;
7143 case bfd_mach_mipsisa32r2
:
7144 val
= E_MIPS_ARCH_32R2
;
7147 case bfd_mach_mipsisa64r2
:
7148 val
= E_MIPS_ARCH_64R2
;
7151 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7152 elf_elfheader (abfd
)->e_flags
|= val
;
7157 /* The final processing done just before writing out a MIPS ELF object
7158 file. This gets the MIPS architecture right based on the machine
7159 number. This is used by both the 32-bit and the 64-bit ABI. */
7162 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7163 bfd_boolean linker ATTRIBUTE_UNUSED
)
7166 Elf_Internal_Shdr
**hdrpp
;
7170 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7171 is nonzero. This is for compatibility with old objects, which used
7172 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7173 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7174 mips_set_isa_flags (abfd
);
7176 /* Set the sh_info field for .gptab sections and other appropriate
7177 info for each special section. */
7178 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7179 i
< elf_numsections (abfd
);
7182 switch ((*hdrpp
)->sh_type
)
7185 case SHT_MIPS_LIBLIST
:
7186 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7188 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7191 case SHT_MIPS_GPTAB
:
7192 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7193 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7194 BFD_ASSERT (name
!= NULL
7195 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7196 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7197 BFD_ASSERT (sec
!= NULL
);
7198 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7201 case SHT_MIPS_CONTENT
:
7202 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7203 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7204 BFD_ASSERT (name
!= NULL
7205 && strncmp (name
, ".MIPS.content",
7206 sizeof ".MIPS.content" - 1) == 0);
7207 sec
= bfd_get_section_by_name (abfd
,
7208 name
+ sizeof ".MIPS.content" - 1);
7209 BFD_ASSERT (sec
!= NULL
);
7210 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7213 case SHT_MIPS_SYMBOL_LIB
:
7214 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7216 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7217 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7219 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7222 case SHT_MIPS_EVENTS
:
7223 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7224 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7225 BFD_ASSERT (name
!= NULL
);
7226 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7227 sec
= bfd_get_section_by_name (abfd
,
7228 name
+ sizeof ".MIPS.events" - 1);
7231 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7232 sizeof ".MIPS.post_rel" - 1) == 0);
7233 sec
= bfd_get_section_by_name (abfd
,
7235 + sizeof ".MIPS.post_rel" - 1));
7237 BFD_ASSERT (sec
!= NULL
);
7238 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7245 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7249 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7254 /* See if we need a PT_MIPS_REGINFO segment. */
7255 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7256 if (s
&& (s
->flags
& SEC_LOAD
))
7259 /* See if we need a PT_MIPS_OPTIONS segment. */
7260 if (IRIX_COMPAT (abfd
) == ict_irix6
7261 && bfd_get_section_by_name (abfd
,
7262 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7265 /* See if we need a PT_MIPS_RTPROC segment. */
7266 if (IRIX_COMPAT (abfd
) == ict_irix5
7267 && bfd_get_section_by_name (abfd
, ".dynamic")
7268 && bfd_get_section_by_name (abfd
, ".mdebug"))
7274 /* Modify the segment map for an IRIX5 executable. */
7277 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7278 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7281 struct elf_segment_map
*m
, **pm
;
7284 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7286 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7287 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7289 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7290 if (m
->p_type
== PT_MIPS_REGINFO
)
7295 m
= bfd_zalloc (abfd
, amt
);
7299 m
->p_type
= PT_MIPS_REGINFO
;
7303 /* We want to put it after the PHDR and INTERP segments. */
7304 pm
= &elf_tdata (abfd
)->segment_map
;
7306 && ((*pm
)->p_type
== PT_PHDR
7307 || (*pm
)->p_type
== PT_INTERP
))
7315 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7316 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7317 PT_MIPS_OPTIONS segment immediately following the program header
7320 /* On non-IRIX6 new abi, we'll have already created a segment
7321 for this section, so don't create another. I'm not sure this
7322 is not also the case for IRIX 6, but I can't test it right
7324 && IRIX_COMPAT (abfd
) == ict_irix6
)
7326 for (s
= abfd
->sections
; s
; s
= s
->next
)
7327 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7332 struct elf_segment_map
*options_segment
;
7334 pm
= &elf_tdata (abfd
)->segment_map
;
7336 && ((*pm
)->p_type
== PT_PHDR
7337 || (*pm
)->p_type
== PT_INTERP
))
7340 amt
= sizeof (struct elf_segment_map
);
7341 options_segment
= bfd_zalloc (abfd
, amt
);
7342 options_segment
->next
= *pm
;
7343 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7344 options_segment
->p_flags
= PF_R
;
7345 options_segment
->p_flags_valid
= TRUE
;
7346 options_segment
->count
= 1;
7347 options_segment
->sections
[0] = s
;
7348 *pm
= options_segment
;
7353 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7355 /* If there are .dynamic and .mdebug sections, we make a room
7356 for the RTPROC header. FIXME: Rewrite without section names. */
7357 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7358 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7359 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7361 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7362 if (m
->p_type
== PT_MIPS_RTPROC
)
7367 m
= bfd_zalloc (abfd
, amt
);
7371 m
->p_type
= PT_MIPS_RTPROC
;
7373 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7378 m
->p_flags_valid
= 1;
7386 /* We want to put it after the DYNAMIC segment. */
7387 pm
= &elf_tdata (abfd
)->segment_map
;
7388 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7398 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7399 .dynstr, .dynsym, and .hash sections, and everything in
7401 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7403 if ((*pm
)->p_type
== PT_DYNAMIC
)
7406 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7408 /* For a normal mips executable the permissions for the PT_DYNAMIC
7409 segment are read, write and execute. We do that here since
7410 the code in elf.c sets only the read permission. This matters
7411 sometimes for the dynamic linker. */
7412 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7414 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7415 m
->p_flags_valid
= 1;
7419 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7421 static const char *sec_names
[] =
7423 ".dynamic", ".dynstr", ".dynsym", ".hash"
7427 struct elf_segment_map
*n
;
7431 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7433 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7434 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7441 if (high
< s
->vma
+ sz
)
7447 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7448 if ((s
->flags
& SEC_LOAD
) != 0
7450 && s
->vma
+ s
->size
<= high
)
7453 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7454 n
= bfd_zalloc (abfd
, amt
);
7461 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7463 if ((s
->flags
& SEC_LOAD
) != 0
7465 && s
->vma
+ s
->size
<= high
)
7479 /* Return the section that should be marked against GC for a given
7483 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7484 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7485 Elf_Internal_Rela
*rel
,
7486 struct elf_link_hash_entry
*h
,
7487 Elf_Internal_Sym
*sym
)
7489 /* ??? Do mips16 stub sections need to be handled special? */
7493 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7495 case R_MIPS_GNU_VTINHERIT
:
7496 case R_MIPS_GNU_VTENTRY
:
7500 switch (h
->root
.type
)
7502 case bfd_link_hash_defined
:
7503 case bfd_link_hash_defweak
:
7504 return h
->root
.u
.def
.section
;
7506 case bfd_link_hash_common
:
7507 return h
->root
.u
.c
.p
->section
;
7515 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7520 /* Update the got entry reference counts for the section being removed. */
7523 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7524 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7525 asection
*sec ATTRIBUTE_UNUSED
,
7526 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7529 Elf_Internal_Shdr
*symtab_hdr
;
7530 struct elf_link_hash_entry
**sym_hashes
;
7531 bfd_signed_vma
*local_got_refcounts
;
7532 const Elf_Internal_Rela
*rel
, *relend
;
7533 unsigned long r_symndx
;
7534 struct elf_link_hash_entry
*h
;
7536 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7537 sym_hashes
= elf_sym_hashes (abfd
);
7538 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7540 relend
= relocs
+ sec
->reloc_count
;
7541 for (rel
= relocs
; rel
< relend
; rel
++)
7542 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7546 case R_MIPS_CALL_HI16
:
7547 case R_MIPS_CALL_LO16
:
7548 case R_MIPS_GOT_HI16
:
7549 case R_MIPS_GOT_LO16
:
7550 case R_MIPS_GOT_DISP
:
7551 case R_MIPS_GOT_PAGE
:
7552 case R_MIPS_GOT_OFST
:
7553 /* ??? It would seem that the existing MIPS code does no sort
7554 of reference counting or whatnot on its GOT and PLT entries,
7555 so it is not possible to garbage collect them at this time. */
7566 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7567 hiding the old indirect symbol. Process additional relocation
7568 information. Also called for weakdefs, in which case we just let
7569 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7572 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7573 struct elf_link_hash_entry
*dir
,
7574 struct elf_link_hash_entry
*ind
)
7576 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7578 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7580 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7583 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7584 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7585 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7586 if (indmips
->readonly_reloc
)
7587 dirmips
->readonly_reloc
= TRUE
;
7588 if (indmips
->no_fn_stub
)
7589 dirmips
->no_fn_stub
= TRUE
;
7593 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7594 struct elf_link_hash_entry
*entry
,
7595 bfd_boolean force_local
)
7599 struct mips_got_info
*g
;
7600 struct mips_elf_link_hash_entry
*h
;
7602 h
= (struct mips_elf_link_hash_entry
*) entry
;
7603 if (h
->forced_local
)
7605 h
->forced_local
= force_local
;
7607 dynobj
= elf_hash_table (info
)->dynobj
;
7608 if (dynobj
!= NULL
&& force_local
)
7610 got
= mips_elf_got_section (dynobj
, FALSE
);
7611 g
= mips_elf_section_data (got
)->u
.got_info
;
7615 struct mips_got_entry e
;
7616 struct mips_got_info
*gg
= g
;
7618 /* Since we're turning what used to be a global symbol into a
7619 local one, bump up the number of local entries of each GOT
7620 that had an entry for it. This will automatically decrease
7621 the number of global entries, since global_gotno is actually
7622 the upper limit of global entries. */
7627 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7628 if (htab_find (g
->got_entries
, &e
))
7630 BFD_ASSERT (g
->global_gotno
> 0);
7635 /* If this was a global symbol forced into the primary GOT, we
7636 no longer need an entry for it. We can't release the entry
7637 at this point, but we must at least stop counting it as one
7638 of the symbols that required a forced got entry. */
7639 if (h
->root
.got
.offset
== 2)
7641 BFD_ASSERT (gg
->assigned_gotno
> 0);
7642 gg
->assigned_gotno
--;
7645 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7646 /* If we haven't got through GOT allocation yet, just bump up the
7647 number of local entries, as this symbol won't be counted as
7650 else if (h
->root
.got
.offset
== 1)
7652 /* If we're past non-multi-GOT allocation and this symbol had
7653 been marked for a global got entry, give it a local entry
7655 BFD_ASSERT (g
->global_gotno
> 0);
7661 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7667 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7668 struct bfd_link_info
*info
)
7671 bfd_boolean ret
= FALSE
;
7672 unsigned char *tdata
;
7675 o
= bfd_get_section_by_name (abfd
, ".pdr");
7680 if (o
->size
% PDR_SIZE
!= 0)
7682 if (o
->output_section
!= NULL
7683 && bfd_is_abs_section (o
->output_section
))
7686 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
7690 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7698 cookie
->rel
= cookie
->rels
;
7699 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7701 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
7703 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
7712 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7713 o
->size
-= skip
* PDR_SIZE
;
7719 if (! info
->keep_memory
)
7720 free (cookie
->rels
);
7726 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7728 if (strcmp (sec
->name
, ".pdr") == 0)
7734 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7737 bfd_byte
*to
, *from
, *end
;
7740 if (strcmp (sec
->name
, ".pdr") != 0)
7743 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7747 end
= contents
+ sec
->size
;
7748 for (from
= contents
, i
= 0;
7750 from
+= PDR_SIZE
, i
++)
7752 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7755 memcpy (to
, from
, PDR_SIZE
);
7758 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7759 sec
->output_offset
, sec
->size
);
7763 /* MIPS ELF uses a special find_nearest_line routine in order the
7764 handle the ECOFF debugging information. */
7766 struct mips_elf_find_line
7768 struct ecoff_debug_info d
;
7769 struct ecoff_find_line i
;
7773 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7774 asymbol
**symbols
, bfd_vma offset
,
7775 const char **filename_ptr
,
7776 const char **functionname_ptr
,
7777 unsigned int *line_ptr
)
7781 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7782 filename_ptr
, functionname_ptr
,
7786 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7787 filename_ptr
, functionname_ptr
,
7788 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7789 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7792 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7796 struct mips_elf_find_line
*fi
;
7797 const struct ecoff_debug_swap
* const swap
=
7798 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7800 /* If we are called during a link, mips_elf_final_link may have
7801 cleared the SEC_HAS_CONTENTS field. We force it back on here
7802 if appropriate (which it normally will be). */
7803 origflags
= msec
->flags
;
7804 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7805 msec
->flags
|= SEC_HAS_CONTENTS
;
7807 fi
= elf_tdata (abfd
)->find_line_info
;
7810 bfd_size_type external_fdr_size
;
7813 struct fdr
*fdr_ptr
;
7814 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7816 fi
= bfd_zalloc (abfd
, amt
);
7819 msec
->flags
= origflags
;
7823 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7825 msec
->flags
= origflags
;
7829 /* Swap in the FDR information. */
7830 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7831 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7832 if (fi
->d
.fdr
== NULL
)
7834 msec
->flags
= origflags
;
7837 external_fdr_size
= swap
->external_fdr_size
;
7838 fdr_ptr
= fi
->d
.fdr
;
7839 fraw_src
= (char *) fi
->d
.external_fdr
;
7840 fraw_end
= (fraw_src
7841 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7842 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7843 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7845 elf_tdata (abfd
)->find_line_info
= fi
;
7847 /* Note that we don't bother to ever free this information.
7848 find_nearest_line is either called all the time, as in
7849 objdump -l, so the information should be saved, or it is
7850 rarely called, as in ld error messages, so the memory
7851 wasted is unimportant. Still, it would probably be a
7852 good idea for free_cached_info to throw it away. */
7855 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7856 &fi
->i
, filename_ptr
, functionname_ptr
,
7859 msec
->flags
= origflags
;
7863 msec
->flags
= origflags
;
7866 /* Fall back on the generic ELF find_nearest_line routine. */
7868 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7869 filename_ptr
, functionname_ptr
,
7873 /* When are writing out the .options or .MIPS.options section,
7874 remember the bytes we are writing out, so that we can install the
7875 GP value in the section_processing routine. */
7878 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7879 const void *location
,
7880 file_ptr offset
, bfd_size_type count
)
7882 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7886 if (elf_section_data (section
) == NULL
)
7888 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7889 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7890 if (elf_section_data (section
) == NULL
)
7893 c
= mips_elf_section_data (section
)->u
.tdata
;
7896 c
= bfd_zalloc (abfd
, section
->size
);
7899 mips_elf_section_data (section
)->u
.tdata
= c
;
7902 memcpy (c
+ offset
, location
, count
);
7905 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7909 /* This is almost identical to bfd_generic_get_... except that some
7910 MIPS relocations need to be handled specially. Sigh. */
7913 _bfd_elf_mips_get_relocated_section_contents
7915 struct bfd_link_info
*link_info
,
7916 struct bfd_link_order
*link_order
,
7918 bfd_boolean relocatable
,
7921 /* Get enough memory to hold the stuff */
7922 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7923 asection
*input_section
= link_order
->u
.indirect
.section
;
7926 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7927 arelent
**reloc_vector
= NULL
;
7933 reloc_vector
= bfd_malloc (reloc_size
);
7934 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7937 /* read in the section */
7938 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
7939 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
7942 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7946 if (reloc_count
< 0)
7949 if (reloc_count
> 0)
7954 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
7957 struct bfd_hash_entry
*h
;
7958 struct bfd_link_hash_entry
*lh
;
7959 /* Skip all this stuff if we aren't mixing formats. */
7960 if (abfd
&& input_bfd
7961 && abfd
->xvec
== input_bfd
->xvec
)
7965 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
7966 lh
= (struct bfd_link_hash_entry
*) h
;
7973 case bfd_link_hash_undefined
:
7974 case bfd_link_hash_undefweak
:
7975 case bfd_link_hash_common
:
7978 case bfd_link_hash_defined
:
7979 case bfd_link_hash_defweak
:
7981 gp
= lh
->u
.def
.value
;
7983 case bfd_link_hash_indirect
:
7984 case bfd_link_hash_warning
:
7986 /* @@FIXME ignoring warning for now */
7988 case bfd_link_hash_new
:
7997 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
7999 char *error_message
= NULL
;
8000 bfd_reloc_status_type r
;
8002 /* Specific to MIPS: Deal with relocation types that require
8003 knowing the gp of the output bfd. */
8004 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8005 if (bfd_is_abs_section (sym
->section
) && abfd
)
8007 /* The special_function wouldn't get called anyway. */
8011 /* The gp isn't there; let the special function code
8012 fall over on its own. */
8014 else if ((*parent
)->howto
->special_function
8015 == _bfd_mips_elf32_gprel16_reloc
)
8017 /* bypass special_function call */
8018 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8019 input_section
, relocatable
,
8021 goto skip_bfd_perform_relocation
;
8023 /* end mips specific stuff */
8025 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8026 relocatable
? abfd
: NULL
,
8028 skip_bfd_perform_relocation
:
8032 asection
*os
= input_section
->output_section
;
8034 /* A partial link, so keep the relocs */
8035 os
->orelocation
[os
->reloc_count
] = *parent
;
8039 if (r
!= bfd_reloc_ok
)
8043 case bfd_reloc_undefined
:
8044 if (!((*link_info
->callbacks
->undefined_symbol
)
8045 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8046 input_bfd
, input_section
, (*parent
)->address
,
8050 case bfd_reloc_dangerous
:
8051 BFD_ASSERT (error_message
!= NULL
);
8052 if (!((*link_info
->callbacks
->reloc_dangerous
)
8053 (link_info
, error_message
, input_bfd
, input_section
,
8054 (*parent
)->address
)))
8057 case bfd_reloc_overflow
:
8058 if (!((*link_info
->callbacks
->reloc_overflow
)
8060 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8061 (*parent
)->howto
->name
, (*parent
)->addend
,
8062 input_bfd
, input_section
, (*parent
)->address
)))
8065 case bfd_reloc_outofrange
:
8074 if (reloc_vector
!= NULL
)
8075 free (reloc_vector
);
8079 if (reloc_vector
!= NULL
)
8080 free (reloc_vector
);
8084 /* Create a MIPS ELF linker hash table. */
8086 struct bfd_link_hash_table
*
8087 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8089 struct mips_elf_link_hash_table
*ret
;
8090 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8092 ret
= bfd_malloc (amt
);
8096 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8097 mips_elf_link_hash_newfunc
))
8104 /* We no longer use this. */
8105 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8106 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8108 ret
->procedure_count
= 0;
8109 ret
->compact_rel_size
= 0;
8110 ret
->use_rld_obj_head
= FALSE
;
8112 ret
->mips16_stubs_seen
= FALSE
;
8114 return &ret
->root
.root
;
8117 /* We need to use a special link routine to handle the .reginfo and
8118 the .mdebug sections. We need to merge all instances of these
8119 sections together, not write them all out sequentially. */
8122 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8126 struct bfd_link_order
*p
;
8127 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8128 asection
*rtproc_sec
;
8129 Elf32_RegInfo reginfo
;
8130 struct ecoff_debug_info debug
;
8131 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8132 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
8133 HDRR
*symhdr
= &debug
.symbolic_header
;
8134 void *mdebug_handle
= NULL
;
8140 static const char * const secname
[] =
8142 ".text", ".init", ".fini", ".data",
8143 ".rodata", ".sdata", ".sbss", ".bss"
8145 static const int sc
[] =
8147 scText
, scInit
, scFini
, scData
,
8148 scRData
, scSData
, scSBss
, scBss
8151 /* We'd carefully arranged the dynamic symbol indices, and then the
8152 generic size_dynamic_sections renumbered them out from under us.
8153 Rather than trying somehow to prevent the renumbering, just do
8155 if (elf_hash_table (info
)->dynamic_sections_created
)
8159 struct mips_got_info
*g
;
8160 bfd_size_type dynsecsymcount
;
8162 /* When we resort, we must tell mips_elf_sort_hash_table what
8163 the lowest index it may use is. That's the number of section
8164 symbols we're going to add. The generic ELF linker only
8165 adds these symbols when building a shared object. Note that
8166 we count the sections after (possibly) removing the .options
8174 for (p
= abfd
->sections
; p
; p
= p
->next
)
8175 if ((p
->flags
& SEC_EXCLUDE
) == 0
8176 && (p
->flags
& SEC_ALLOC
) != 0
8177 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
8181 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
8184 /* Make sure we didn't grow the global .got region. */
8185 dynobj
= elf_hash_table (info
)->dynobj
;
8186 got
= mips_elf_got_section (dynobj
, FALSE
);
8187 g
= mips_elf_section_data (got
)->u
.got_info
;
8189 if (g
->global_gotsym
!= NULL
)
8190 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8191 - g
->global_gotsym
->dynindx
)
8192 <= g
->global_gotno
);
8195 /* Get a value for the GP register. */
8196 if (elf_gp (abfd
) == 0)
8198 struct bfd_link_hash_entry
*h
;
8200 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8201 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8202 elf_gp (abfd
) = (h
->u
.def
.value
8203 + h
->u
.def
.section
->output_section
->vma
8204 + h
->u
.def
.section
->output_offset
);
8205 else if (info
->relocatable
)
8207 bfd_vma lo
= MINUS_ONE
;
8209 /* Find the GP-relative section with the lowest offset. */
8210 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8212 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8215 /* And calculate GP relative to that. */
8216 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8220 /* If the relocate_section function needs to do a reloc
8221 involving the GP value, it should make a reloc_dangerous
8222 callback to warn that GP is not defined. */
8226 /* Go through the sections and collect the .reginfo and .mdebug
8230 gptab_data_sec
= NULL
;
8231 gptab_bss_sec
= NULL
;
8232 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8234 if (strcmp (o
->name
, ".reginfo") == 0)
8236 memset (®info
, 0, sizeof reginfo
);
8238 /* We have found the .reginfo section in the output file.
8239 Look through all the link_orders comprising it and merge
8240 the information together. */
8241 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8243 asection
*input_section
;
8245 Elf32_External_RegInfo ext
;
8248 if (p
->type
!= bfd_indirect_link_order
)
8250 if (p
->type
== bfd_data_link_order
)
8255 input_section
= p
->u
.indirect
.section
;
8256 input_bfd
= input_section
->owner
;
8258 if (! bfd_get_section_contents (input_bfd
, input_section
,
8259 &ext
, 0, sizeof ext
))
8262 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8264 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8265 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8266 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8267 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8268 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8270 /* ri_gp_value is set by the function
8271 mips_elf32_section_processing when the section is
8272 finally written out. */
8274 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8275 elf_link_input_bfd ignores this section. */
8276 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8279 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8280 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
8282 /* Skip this section later on (I don't think this currently
8283 matters, but someday it might). */
8284 o
->link_order_head
= NULL
;
8289 if (strcmp (o
->name
, ".mdebug") == 0)
8291 struct extsym_info einfo
;
8294 /* We have found the .mdebug section in the output file.
8295 Look through all the link_orders comprising it and merge
8296 the information together. */
8297 symhdr
->magic
= swap
->sym_magic
;
8298 /* FIXME: What should the version stamp be? */
8300 symhdr
->ilineMax
= 0;
8304 symhdr
->isymMax
= 0;
8305 symhdr
->ioptMax
= 0;
8306 symhdr
->iauxMax
= 0;
8308 symhdr
->issExtMax
= 0;
8311 symhdr
->iextMax
= 0;
8313 /* We accumulate the debugging information itself in the
8314 debug_info structure. */
8316 debug
.external_dnr
= NULL
;
8317 debug
.external_pdr
= NULL
;
8318 debug
.external_sym
= NULL
;
8319 debug
.external_opt
= NULL
;
8320 debug
.external_aux
= NULL
;
8322 debug
.ssext
= debug
.ssext_end
= NULL
;
8323 debug
.external_fdr
= NULL
;
8324 debug
.external_rfd
= NULL
;
8325 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8327 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8328 if (mdebug_handle
== NULL
)
8332 esym
.cobol_main
= 0;
8336 esym
.asym
.iss
= issNil
;
8337 esym
.asym
.st
= stLocal
;
8338 esym
.asym
.reserved
= 0;
8339 esym
.asym
.index
= indexNil
;
8341 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8343 esym
.asym
.sc
= sc
[i
];
8344 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8347 esym
.asym
.value
= s
->vma
;
8348 last
= s
->vma
+ s
->size
;
8351 esym
.asym
.value
= last
;
8352 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8357 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8359 asection
*input_section
;
8361 const struct ecoff_debug_swap
*input_swap
;
8362 struct ecoff_debug_info input_debug
;
8366 if (p
->type
!= bfd_indirect_link_order
)
8368 if (p
->type
== bfd_data_link_order
)
8373 input_section
= p
->u
.indirect
.section
;
8374 input_bfd
= input_section
->owner
;
8376 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8377 || (get_elf_backend_data (input_bfd
)
8378 ->elf_backend_ecoff_debug_swap
) == NULL
)
8380 /* I don't know what a non MIPS ELF bfd would be
8381 doing with a .mdebug section, but I don't really
8382 want to deal with it. */
8386 input_swap
= (get_elf_backend_data (input_bfd
)
8387 ->elf_backend_ecoff_debug_swap
);
8389 BFD_ASSERT (p
->size
== input_section
->size
);
8391 /* The ECOFF linking code expects that we have already
8392 read in the debugging information and set up an
8393 ecoff_debug_info structure, so we do that now. */
8394 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8398 if (! (bfd_ecoff_debug_accumulate
8399 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8400 &input_debug
, input_swap
, info
)))
8403 /* Loop through the external symbols. For each one with
8404 interesting information, try to find the symbol in
8405 the linker global hash table and save the information
8406 for the output external symbols. */
8407 eraw_src
= input_debug
.external_ext
;
8408 eraw_end
= (eraw_src
8409 + (input_debug
.symbolic_header
.iextMax
8410 * input_swap
->external_ext_size
));
8412 eraw_src
< eraw_end
;
8413 eraw_src
+= input_swap
->external_ext_size
)
8417 struct mips_elf_link_hash_entry
*h
;
8419 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8420 if (ext
.asym
.sc
== scNil
8421 || ext
.asym
.sc
== scUndefined
8422 || ext
.asym
.sc
== scSUndefined
)
8425 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8426 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8427 name
, FALSE
, FALSE
, TRUE
);
8428 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8434 < input_debug
.symbolic_header
.ifdMax
);
8435 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8441 /* Free up the information we just read. */
8442 free (input_debug
.line
);
8443 free (input_debug
.external_dnr
);
8444 free (input_debug
.external_pdr
);
8445 free (input_debug
.external_sym
);
8446 free (input_debug
.external_opt
);
8447 free (input_debug
.external_aux
);
8448 free (input_debug
.ss
);
8449 free (input_debug
.ssext
);
8450 free (input_debug
.external_fdr
);
8451 free (input_debug
.external_rfd
);
8452 free (input_debug
.external_ext
);
8454 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8455 elf_link_input_bfd ignores this section. */
8456 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8459 if (SGI_COMPAT (abfd
) && info
->shared
)
8461 /* Create .rtproc section. */
8462 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8463 if (rtproc_sec
== NULL
)
8465 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8466 | SEC_LINKER_CREATED
| SEC_READONLY
);
8468 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8469 if (rtproc_sec
== NULL
8470 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8471 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8475 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8481 /* Build the external symbol information. */
8484 einfo
.debug
= &debug
;
8486 einfo
.failed
= FALSE
;
8487 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8488 mips_elf_output_extsym
, &einfo
);
8492 /* Set the size of the .mdebug section. */
8493 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8495 /* Skip this section later on (I don't think this currently
8496 matters, but someday it might). */
8497 o
->link_order_head
= NULL
;
8502 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8504 const char *subname
;
8507 Elf32_External_gptab
*ext_tab
;
8510 /* The .gptab.sdata and .gptab.sbss sections hold
8511 information describing how the small data area would
8512 change depending upon the -G switch. These sections
8513 not used in executables files. */
8514 if (! info
->relocatable
)
8516 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8518 asection
*input_section
;
8520 if (p
->type
!= bfd_indirect_link_order
)
8522 if (p
->type
== bfd_data_link_order
)
8527 input_section
= p
->u
.indirect
.section
;
8529 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8530 elf_link_input_bfd ignores this section. */
8531 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8534 /* Skip this section later on (I don't think this
8535 currently matters, but someday it might). */
8536 o
->link_order_head
= NULL
;
8538 /* Really remove the section. */
8539 for (secpp
= &abfd
->sections
;
8541 secpp
= &(*secpp
)->next
)
8543 bfd_section_list_remove (abfd
, secpp
);
8544 --abfd
->section_count
;
8549 /* There is one gptab for initialized data, and one for
8550 uninitialized data. */
8551 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8553 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8557 (*_bfd_error_handler
)
8558 (_("%s: illegal section name `%s'"),
8559 bfd_get_filename (abfd
), o
->name
);
8560 bfd_set_error (bfd_error_nonrepresentable_section
);
8564 /* The linker script always combines .gptab.data and
8565 .gptab.sdata into .gptab.sdata, and likewise for
8566 .gptab.bss and .gptab.sbss. It is possible that there is
8567 no .sdata or .sbss section in the output file, in which
8568 case we must change the name of the output section. */
8569 subname
= o
->name
+ sizeof ".gptab" - 1;
8570 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8572 if (o
== gptab_data_sec
)
8573 o
->name
= ".gptab.data";
8575 o
->name
= ".gptab.bss";
8576 subname
= o
->name
+ sizeof ".gptab" - 1;
8577 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8580 /* Set up the first entry. */
8582 amt
= c
* sizeof (Elf32_gptab
);
8583 tab
= bfd_malloc (amt
);
8586 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8587 tab
[0].gt_header
.gt_unused
= 0;
8589 /* Combine the input sections. */
8590 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8592 asection
*input_section
;
8596 bfd_size_type gpentry
;
8598 if (p
->type
!= bfd_indirect_link_order
)
8600 if (p
->type
== bfd_data_link_order
)
8605 input_section
= p
->u
.indirect
.section
;
8606 input_bfd
= input_section
->owner
;
8608 /* Combine the gptab entries for this input section one
8609 by one. We know that the input gptab entries are
8610 sorted by ascending -G value. */
8611 size
= input_section
->size
;
8613 for (gpentry
= sizeof (Elf32_External_gptab
);
8615 gpentry
+= sizeof (Elf32_External_gptab
))
8617 Elf32_External_gptab ext_gptab
;
8618 Elf32_gptab int_gptab
;
8624 if (! (bfd_get_section_contents
8625 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8626 sizeof (Elf32_External_gptab
))))
8632 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8634 val
= int_gptab
.gt_entry
.gt_g_value
;
8635 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8638 for (look
= 1; look
< c
; look
++)
8640 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8641 tab
[look
].gt_entry
.gt_bytes
+= add
;
8643 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8649 Elf32_gptab
*new_tab
;
8652 /* We need a new table entry. */
8653 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8654 new_tab
= bfd_realloc (tab
, amt
);
8655 if (new_tab
== NULL
)
8661 tab
[c
].gt_entry
.gt_g_value
= val
;
8662 tab
[c
].gt_entry
.gt_bytes
= add
;
8664 /* Merge in the size for the next smallest -G
8665 value, since that will be implied by this new
8668 for (look
= 1; look
< c
; look
++)
8670 if (tab
[look
].gt_entry
.gt_g_value
< val
8672 || (tab
[look
].gt_entry
.gt_g_value
8673 > tab
[max
].gt_entry
.gt_g_value
)))
8677 tab
[c
].gt_entry
.gt_bytes
+=
8678 tab
[max
].gt_entry
.gt_bytes
;
8683 last
= int_gptab
.gt_entry
.gt_bytes
;
8686 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8687 elf_link_input_bfd ignores this section. */
8688 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8691 /* The table must be sorted by -G value. */
8693 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8695 /* Swap out the table. */
8696 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8697 ext_tab
= bfd_alloc (abfd
, amt
);
8698 if (ext_tab
== NULL
)
8704 for (j
= 0; j
< c
; j
++)
8705 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8708 o
->size
= c
* sizeof (Elf32_External_gptab
);
8709 o
->contents
= (bfd_byte
*) ext_tab
;
8711 /* Skip this section later on (I don't think this currently
8712 matters, but someday it might). */
8713 o
->link_order_head
= NULL
;
8717 /* Invoke the regular ELF backend linker to do all the work. */
8718 if (!bfd_elf_final_link (abfd
, info
))
8721 /* Now write out the computed sections. */
8723 if (reginfo_sec
!= NULL
)
8725 Elf32_External_RegInfo ext
;
8727 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8728 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8732 if (mdebug_sec
!= NULL
)
8734 BFD_ASSERT (abfd
->output_has_begun
);
8735 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8737 mdebug_sec
->filepos
))
8740 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8743 if (gptab_data_sec
!= NULL
)
8745 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8746 gptab_data_sec
->contents
,
8747 0, gptab_data_sec
->size
))
8751 if (gptab_bss_sec
!= NULL
)
8753 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8754 gptab_bss_sec
->contents
,
8755 0, gptab_bss_sec
->size
))
8759 if (SGI_COMPAT (abfd
))
8761 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8762 if (rtproc_sec
!= NULL
)
8764 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8765 rtproc_sec
->contents
,
8766 0, rtproc_sec
->size
))
8774 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8776 struct mips_mach_extension
{
8777 unsigned long extension
, base
;
8781 /* An array describing how BFD machines relate to one another. The entries
8782 are ordered topologically with MIPS I extensions listed last. */
8784 static const struct mips_mach_extension mips_mach_extensions
[] = {
8785 /* MIPS64 extensions. */
8786 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8787 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8789 /* MIPS V extensions. */
8790 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8792 /* R10000 extensions. */
8793 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8795 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8796 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8797 better to allow vr5400 and vr5500 code to be merged anyway, since
8798 many libraries will just use the core ISA. Perhaps we could add
8799 some sort of ASE flag if this ever proves a problem. */
8800 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8801 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8803 /* MIPS IV extensions. */
8804 { bfd_mach_mips5
, bfd_mach_mips8000
},
8805 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8806 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8807 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8808 { bfd_mach_mips9000
, bfd_mach_mips8000
},
8810 /* VR4100 extensions. */
8811 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8812 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8814 /* MIPS III extensions. */
8815 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8816 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8817 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8818 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8819 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8820 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8821 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8823 /* MIPS32 extensions. */
8824 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8826 /* MIPS II extensions. */
8827 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8828 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8830 /* MIPS I extensions. */
8831 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8832 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8836 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8839 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8843 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8844 if (extension
== mips_mach_extensions
[i
].extension
)
8845 extension
= mips_mach_extensions
[i
].base
;
8847 return extension
== base
;
8851 /* Return true if the given ELF header flags describe a 32-bit binary. */
8854 mips_32bit_flags_p (flagword flags
)
8856 return ((flags
& EF_MIPS_32BITMODE
) != 0
8857 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8858 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8859 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8860 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8861 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8862 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8866 /* Merge backend specific data from an object file to the output
8867 object file when linking. */
8870 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8875 bfd_boolean null_input_bfd
= TRUE
;
8878 /* Check if we have the same endianess */
8879 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8881 (*_bfd_error_handler
)
8882 (_("%B: endianness incompatible with that of the selected emulation"),
8887 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8888 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8891 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8893 (*_bfd_error_handler
)
8894 (_("%B: ABI is incompatible with that of the selected emulation"),
8899 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8900 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8901 old_flags
= elf_elfheader (obfd
)->e_flags
;
8903 if (! elf_flags_init (obfd
))
8905 elf_flags_init (obfd
) = TRUE
;
8906 elf_elfheader (obfd
)->e_flags
= new_flags
;
8907 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8908 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8910 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8911 && bfd_get_arch_info (obfd
)->the_default
)
8913 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
8914 bfd_get_mach (ibfd
)))
8921 /* Check flag compatibility. */
8923 new_flags
&= ~EF_MIPS_NOREORDER
;
8924 old_flags
&= ~EF_MIPS_NOREORDER
;
8926 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
8927 doesn't seem to matter. */
8928 new_flags
&= ~EF_MIPS_XGOT
;
8929 old_flags
&= ~EF_MIPS_XGOT
;
8931 /* MIPSpro generates ucode info in n64 objects. Again, we should
8932 just be able to ignore this. */
8933 new_flags
&= ~EF_MIPS_UCODE
;
8934 old_flags
&= ~EF_MIPS_UCODE
;
8936 if (new_flags
== old_flags
)
8939 /* Check to see if the input BFD actually contains any sections.
8940 If not, its flags may not have been initialised either, but it cannot
8941 actually cause any incompatibility. */
8942 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8944 /* Ignore synthetic sections and empty .text, .data and .bss sections
8945 which are automatically generated by gas. */
8946 if (strcmp (sec
->name
, ".reginfo")
8947 && strcmp (sec
->name
, ".mdebug")
8949 || (strcmp (sec
->name
, ".text")
8950 && strcmp (sec
->name
, ".data")
8951 && strcmp (sec
->name
, ".bss"))))
8953 null_input_bfd
= FALSE
;
8962 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
8963 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
8965 (*_bfd_error_handler
)
8966 (_("%B: warning: linking PIC files with non-PIC files"),
8971 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
8972 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
8973 if (! (new_flags
& EF_MIPS_PIC
))
8974 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
8976 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
8977 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
8979 /* Compare the ISAs. */
8980 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
8982 (*_bfd_error_handler
)
8983 (_("%B: linking 32-bit code with 64-bit code"),
8987 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
8989 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
8990 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
8992 /* Copy the architecture info from IBFD to OBFD. Also copy
8993 the 32-bit flag (if set) so that we continue to recognise
8994 OBFD as a 32-bit binary. */
8995 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
8996 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
8997 elf_elfheader (obfd
)->e_flags
8998 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9000 /* Copy across the ABI flags if OBFD doesn't use them
9001 and if that was what caused us to treat IBFD as 32-bit. */
9002 if ((old_flags
& EF_MIPS_ABI
) == 0
9003 && mips_32bit_flags_p (new_flags
)
9004 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9005 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9009 /* The ISAs aren't compatible. */
9010 (*_bfd_error_handler
)
9011 (_("%B: linking %s module with previous %s modules"),
9013 bfd_printable_name (ibfd
),
9014 bfd_printable_name (obfd
));
9019 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9020 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9022 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9023 does set EI_CLASS differently from any 32-bit ABI. */
9024 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9025 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9026 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9028 /* Only error if both are set (to different values). */
9029 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9030 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9031 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9033 (*_bfd_error_handler
)
9034 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9036 elf_mips_abi_name (ibfd
),
9037 elf_mips_abi_name (obfd
));
9040 new_flags
&= ~EF_MIPS_ABI
;
9041 old_flags
&= ~EF_MIPS_ABI
;
9044 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9045 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9047 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9049 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9050 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9053 /* Warn about any other mismatches */
9054 if (new_flags
!= old_flags
)
9056 (*_bfd_error_handler
)
9057 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9058 ibfd
, (unsigned long) new_flags
,
9059 (unsigned long) old_flags
);
9065 bfd_set_error (bfd_error_bad_value
);
9072 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9075 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9077 BFD_ASSERT (!elf_flags_init (abfd
)
9078 || elf_elfheader (abfd
)->e_flags
== flags
);
9080 elf_elfheader (abfd
)->e_flags
= flags
;
9081 elf_flags_init (abfd
) = TRUE
;
9086 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9090 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9092 /* Print normal ELF private data. */
9093 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9095 /* xgettext:c-format */
9096 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9098 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9099 fprintf (file
, _(" [abi=O32]"));
9100 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9101 fprintf (file
, _(" [abi=O64]"));
9102 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9103 fprintf (file
, _(" [abi=EABI32]"));
9104 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9105 fprintf (file
, _(" [abi=EABI64]"));
9106 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9107 fprintf (file
, _(" [abi unknown]"));
9108 else if (ABI_N32_P (abfd
))
9109 fprintf (file
, _(" [abi=N32]"));
9110 else if (ABI_64_P (abfd
))
9111 fprintf (file
, _(" [abi=64]"));
9113 fprintf (file
, _(" [no abi set]"));
9115 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9116 fprintf (file
, _(" [mips1]"));
9117 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9118 fprintf (file
, _(" [mips2]"));
9119 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9120 fprintf (file
, _(" [mips3]"));
9121 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9122 fprintf (file
, _(" [mips4]"));
9123 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9124 fprintf (file
, _(" [mips5]"));
9125 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9126 fprintf (file
, _(" [mips32]"));
9127 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9128 fprintf (file
, _(" [mips64]"));
9129 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9130 fprintf (file
, _(" [mips32r2]"));
9131 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9132 fprintf (file
, _(" [mips64r2]"));
9134 fprintf (file
, _(" [unknown ISA]"));
9136 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9137 fprintf (file
, _(" [mdmx]"));
9139 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9140 fprintf (file
, _(" [mips16]"));
9142 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9143 fprintf (file
, _(" [32bitmode]"));
9145 fprintf (file
, _(" [not 32bitmode]"));
9152 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9154 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9155 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9156 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9157 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9158 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9159 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9160 { NULL
, 0, 0, 0, 0 }