Remainder of fixes for ARM WINCE support
[binutils.git] / bfd / elfxx-mips.c
blob7bcdb1115b3f4dbfa6daabca7309f814b49f3e6c
1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 <ian@cygnus.com>.
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. */
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "libbfd.h"
33 #include "libiberty.h"
34 #include "elf-bfd.h"
35 #include "elfxx-mips.h"
36 #include "elf/mips.h"
38 /* Get the ECOFF swapping routines. */
39 #include "coff/sym.h"
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
44 #include "hashtab.h"
46 /* This structure is used to hold .got entries while estimating got
47 sizes. */
48 struct mips_got_entry
50 /* The input bfd in which the symbol is defined. */
51 bfd *abfd;
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
54 long symndx;
55 union
57 /* If abfd == NULL, an address that must be stored in the got. */
58 bfd_vma address;
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
61 bfd_vma addend;
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
64 h->forced_local). */
65 struct mips_elf_link_hash_entry *h;
66 } d;
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. */
70 long gotidx;
73 /* This structure is used to hold .got information when linking. */
75 struct mips_got_info
77 /* The global symbol in the GOT with the lowest index in the dynamic
78 symbol table. */
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. */
90 struct htab *bfd2got;
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 {
99 bfd *bfd;
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. */
109 htab_t bfd2got;
110 /* The output bfd. */
111 bfd *obfd;
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
116 DT_MIPS_GOTSYM. */
117 struct mips_got_info *primary;
118 /* A non-primary got we're trying to merge with other input bfd's
119 gots. */
120 struct mips_got_info *current;
121 /* The maximum number of got entries that can be addressed with a
122 16-bit offset. */
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;
135 int value;
136 unsigned int needed_relocs;
137 struct bfd_link_info *info;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf;
143 union
145 struct mips_got_info *got_info;
146 bfd_byte *tdata;
147 } u;
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
159 index. */
160 struct elf_link_hash_entry *low;
161 /* The least dynamic symbol table index corresponding to a symbol
162 with a GOT entry. */
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. */
181 EXTR esym;
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
184 this symbol. */
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",
194 p. 4-20. */
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. */
199 asection *fn_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. */
207 asection *call_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;
222 #if 0
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];
226 #endif
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. */
235 bfd_vma rld_value;
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. */
242 struct extsym_info
244 bfd *abfd;
245 struct bfd_link_info *info;
246 struct ecoff_debug_info *debug;
247 const struct ecoff_debug_swap *swap;
248 bfd_boolean failed;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names[] =
255 "_procedure_table",
256 "_procedure_string_table",
257 "_procedure_table_size",
258 NULL
261 /* These structures are used to generate the .compact_rel section on
262 IRIX5. */
264 typedef struct
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? */
272 } Elf32_compact_rel;
274 typedef struct
276 bfd_byte id1[4];
277 bfd_byte num[4];
278 bfd_byte id2[4];
279 bfd_byte offset[4];
280 bfd_byte reserved0[4];
281 bfd_byte reserved1[4];
282 } Elf32_External_compact_rel;
284 typedef struct
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. */
292 } Elf32_crinfo;
294 typedef struct
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. */
301 } Elf32_crinfo2;
303 typedef struct
305 bfd_byte info[4];
306 bfd_byte konst[4];
307 bfd_byte vaddr[4];
308 } Elf32_External_crinfo;
310 typedef struct
312 bfd_byte info[4];
313 bfd_byte konst[4];
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:
336 (type) (konst)
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. */
366 long reserved;
367 struct exception_info *exception_info;/* Pointer to exception array. */
368 } RPDR, *pRPDR;
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct bfd_hash_entry *mips_elf_link_hash_newfunc
373 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
374 static void ecoff_swap_rpdr_out
375 (bfd *, const RPDR *, struct rpdr_ext *);
376 static bfd_boolean mips_elf_create_procedure_table
377 (void *, bfd *, struct bfd_link_info *, asection *,
378 struct ecoff_debug_info *);
379 static bfd_boolean mips_elf_check_mips16_stubs
380 (struct mips_elf_link_hash_entry *, void *);
381 static void bfd_mips_elf32_swap_gptab_in
382 (bfd *, const Elf32_External_gptab *, Elf32_gptab *);
383 static void bfd_mips_elf32_swap_gptab_out
384 (bfd *, const Elf32_gptab *, Elf32_External_gptab *);
385 static void bfd_elf32_swap_compact_rel_out
386 (bfd *, const Elf32_compact_rel *, Elf32_External_compact_rel *);
387 static void bfd_elf32_swap_crinfo_out
388 (bfd *, const Elf32_crinfo *, Elf32_External_crinfo *);
389 static int sort_dynamic_relocs
390 (const void *, const void *);
391 static int sort_dynamic_relocs_64
392 (const void *, const void *);
393 static bfd_boolean mips_elf_output_extsym
394 (struct mips_elf_link_hash_entry *, void *);
395 static int gptab_compare
396 (const void *, const void *);
397 static asection *mips_elf_rel_dyn_section
398 (bfd *, bfd_boolean);
399 static asection *mips_elf_got_section
400 (bfd *, bfd_boolean);
401 static struct mips_got_info *mips_elf_got_info
402 (bfd *, asection **);
403 static long mips_elf_get_global_gotsym_index
404 (bfd *abfd);
405 static bfd_vma mips_elf_local_got_index
406 (bfd *, bfd *, struct bfd_link_info *, bfd_vma);
407 static bfd_vma mips_elf_global_got_index
408 (bfd *, bfd *, struct elf_link_hash_entry *);
409 static bfd_vma mips_elf_got_page
410 (bfd *, bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *);
411 static bfd_vma mips_elf_got16_entry
412 (bfd *, bfd *, struct bfd_link_info *, bfd_vma, bfd_boolean);
413 static bfd_vma mips_elf_got_offset_from_index
414 (bfd *, bfd *, bfd *, bfd_vma);
415 static struct mips_got_entry *mips_elf_create_local_got_entry
416 (bfd *, bfd *, struct mips_got_info *, asection *, bfd_vma);
417 static bfd_boolean mips_elf_sort_hash_table
418 (struct bfd_link_info *, unsigned long);
419 static bfd_boolean mips_elf_sort_hash_table_f
420 (struct mips_elf_link_hash_entry *, void *);
421 static bfd_boolean mips_elf_record_local_got_symbol
422 (bfd *, long, bfd_vma, struct mips_got_info *);
423 static bfd_boolean mips_elf_record_global_got_symbol
424 (struct elf_link_hash_entry *, bfd *, struct bfd_link_info *,
425 struct mips_got_info *);
426 static const Elf_Internal_Rela *mips_elf_next_relocation
427 (bfd *, unsigned int, const Elf_Internal_Rela *, const Elf_Internal_Rela *);
428 static bfd_boolean mips_elf_local_relocation_p
429 (bfd *, const Elf_Internal_Rela *, asection **, bfd_boolean);
430 static bfd_boolean mips_elf_overflow_p
431 (bfd_vma, int);
432 static bfd_vma mips_elf_high
433 (bfd_vma);
434 static bfd_vma mips_elf_higher
435 (bfd_vma);
436 static bfd_vma mips_elf_highest
437 (bfd_vma);
438 static bfd_boolean mips_elf_create_compact_rel_section
439 (bfd *, struct bfd_link_info *);
440 static bfd_boolean mips_elf_create_got_section
441 (bfd *, struct bfd_link_info *, bfd_boolean);
442 static bfd_reloc_status_type mips_elf_calculate_relocation
443 (bfd *, bfd *, asection *, struct bfd_link_info *,
444 const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
445 Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
446 bfd_boolean *, bfd_boolean);
447 static bfd_vma mips_elf_obtain_contents
448 (reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *);
449 static bfd_boolean mips_elf_perform_relocation
450 (struct bfd_link_info *, reloc_howto_type *, const Elf_Internal_Rela *,
451 bfd_vma, bfd *, asection *, bfd_byte *, bfd_boolean);
452 static bfd_boolean mips_elf_stub_section_p
453 (bfd *, asection *);
454 static void mips_elf_allocate_dynamic_relocations
455 (bfd *, unsigned int);
456 static bfd_boolean mips_elf_create_dynamic_relocation
457 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
458 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
459 bfd_vma *, asection *);
460 static void mips_set_isa_flags
461 (bfd *);
462 static INLINE char *elf_mips_abi_name
463 (bfd *);
464 static void mips_elf_irix6_finish_dynamic_symbol
465 (bfd *, const char *, Elf_Internal_Sym *);
466 static bfd_boolean mips_mach_extends_p
467 (unsigned long, unsigned long);
468 static bfd_boolean mips_32bit_flags_p
469 (flagword);
470 static INLINE hashval_t mips_elf_hash_bfd_vma
471 (bfd_vma);
472 static hashval_t mips_elf_got_entry_hash
473 (const void *);
474 static int mips_elf_got_entry_eq
475 (const void *, const void *);
477 static bfd_boolean mips_elf_multi_got
478 (bfd *, struct bfd_link_info *, struct mips_got_info *,
479 asection *, bfd_size_type);
480 static hashval_t mips_elf_multi_got_entry_hash
481 (const void *);
482 static int mips_elf_multi_got_entry_eq
483 (const void *, const void *);
484 static hashval_t mips_elf_bfd2got_entry_hash
485 (const void *);
486 static int mips_elf_bfd2got_entry_eq
487 (const void *, const void *);
488 static int mips_elf_make_got_per_bfd
489 (void **, void *);
490 static int mips_elf_merge_gots
491 (void **, void *);
492 static int mips_elf_set_global_got_offset
493 (void **, void *);
494 static int mips_elf_set_no_stub
495 (void **, void *);
496 static int mips_elf_resolve_final_got_entry
497 (void **, void *);
498 static void mips_elf_resolve_final_got_entries
499 (struct mips_got_info *);
500 static bfd_vma mips_elf_adjust_gp
501 (bfd *, struct mips_got_info *, bfd *);
502 static struct mips_got_info *mips_elf_got_for_ibfd
503 (struct mips_got_info *, bfd *);
505 /* This will be used when we sort the dynamic relocation records. */
506 static bfd *reldyn_sorting_bfd;
508 /* Nonzero if ABFD is using the N32 ABI. */
510 #define ABI_N32_P(abfd) \
511 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
513 /* Nonzero if ABFD is using the N64 ABI. */
514 #define ABI_64_P(abfd) \
515 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
517 /* Nonzero if ABFD is using NewABI conventions. */
518 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
520 /* The IRIX compatibility level we are striving for. */
521 #define IRIX_COMPAT(abfd) \
522 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
524 /* Whether we are trying to be compatible with IRIX at all. */
525 #define SGI_COMPAT(abfd) \
526 (IRIX_COMPAT (abfd) != ict_none)
528 /* The name of the options section. */
529 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
530 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
532 /* The name of the stub section. */
533 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
534 (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
536 /* The size of an external REL relocation. */
537 #define MIPS_ELF_REL_SIZE(abfd) \
538 (get_elf_backend_data (abfd)->s->sizeof_rel)
540 /* The size of an external dynamic table entry. */
541 #define MIPS_ELF_DYN_SIZE(abfd) \
542 (get_elf_backend_data (abfd)->s->sizeof_dyn)
544 /* The size of a GOT entry. */
545 #define MIPS_ELF_GOT_SIZE(abfd) \
546 (get_elf_backend_data (abfd)->s->arch_size / 8)
548 /* The size of a symbol-table entry. */
549 #define MIPS_ELF_SYM_SIZE(abfd) \
550 (get_elf_backend_data (abfd)->s->sizeof_sym)
552 /* The default alignment for sections, as a power of two. */
553 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
554 (get_elf_backend_data (abfd)->s->log_file_align)
556 /* Get word-sized data. */
557 #define MIPS_ELF_GET_WORD(abfd, ptr) \
558 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
560 /* Put out word-sized data. */
561 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
562 (ABI_64_P (abfd) \
563 ? bfd_put_64 (abfd, val, ptr) \
564 : bfd_put_32 (abfd, val, ptr))
566 /* Add a dynamic symbol table-entry. */
567 #ifdef BFD64
568 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
569 (ABI_64_P (elf_hash_table (info)->dynobj) \
570 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
571 : bfd_elf32_add_dynamic_entry (info, tag, val))
572 #else
573 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
574 (ABI_64_P (elf_hash_table (info)->dynobj) \
575 ? (abort (), FALSE) \
576 : bfd_elf32_add_dynamic_entry (info, tag, val))
577 #endif
579 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
580 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
582 /* Determine whether the internal relocation of index REL_IDX is REL
583 (zero) or RELA (non-zero). The assumption is that, if there are
584 two relocation sections for this section, one of them is REL and
585 the other is RELA. If the index of the relocation we're testing is
586 in range for the first relocation section, check that the external
587 relocation size is that for RELA. It is also assumed that, if
588 rel_idx is not in range for the first section, and this first
589 section contains REL relocs, then the relocation is in the second
590 section, that is RELA. */
591 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
592 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
593 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
594 > (bfd_vma)(rel_idx)) \
595 == (elf_section_data (sec)->rel_hdr.sh_entsize \
596 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
597 : sizeof (Elf32_External_Rela))))
599 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
600 from smaller values. Start with zero, widen, *then* decrement. */
601 #define MINUS_ONE (((bfd_vma)0) - 1)
603 /* The number of local .got entries we reserve. */
604 #define MIPS_RESERVED_GOTNO (2)
606 /* The offset of $gp from the beginning of the .got section. */
607 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
609 /* The maximum size of the GOT for it to be addressable using 16-bit
610 offsets from $gp. */
611 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
613 /* Instructions which appear in a stub. */
614 #define STUB_LW(abfd) \
615 ((ABI_64_P (abfd) \
616 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
617 : 0x8f998010)) /* lw t9,0x8010(gp) */
618 #define STUB_MOVE(abfd) \
619 ((ABI_64_P (abfd) \
620 ? 0x03e0782d /* daddu t7,ra */ \
621 : 0x03e07821)) /* addu t7,ra */
622 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
623 #define STUB_LI16(abfd) \
624 ((ABI_64_P (abfd) \
625 ? 0x64180000 /* daddiu t8,zero,0 */ \
626 : 0x24180000)) /* addiu t8,zero,0 */
627 #define MIPS_FUNCTION_STUB_SIZE (16)
629 /* The name of the dynamic interpreter. This is put in the .interp
630 section. */
632 #define ELF_DYNAMIC_INTERPRETER(abfd) \
633 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
634 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
635 : "/usr/lib/libc.so.1")
637 #ifdef BFD64
638 #define MNAME(bfd,pre,pos) \
639 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
640 #define ELF_R_SYM(bfd, i) \
641 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
642 #define ELF_R_TYPE(bfd, i) \
643 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
644 #define ELF_R_INFO(bfd, s, t) \
645 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
646 #else
647 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
648 #define ELF_R_SYM(bfd, i) \
649 (ELF32_R_SYM (i))
650 #define ELF_R_TYPE(bfd, i) \
651 (ELF32_R_TYPE (i))
652 #define ELF_R_INFO(bfd, s, t) \
653 (ELF32_R_INFO (s, t))
654 #endif
656 /* The mips16 compiler uses a couple of special sections to handle
657 floating point arguments.
659 Section names that look like .mips16.fn.FNNAME contain stubs that
660 copy floating point arguments from the fp regs to the gp regs and
661 then jump to FNNAME. If any 32 bit function calls FNNAME, the
662 call should be redirected to the stub instead. If no 32 bit
663 function calls FNNAME, the stub should be discarded. We need to
664 consider any reference to the function, not just a call, because
665 if the address of the function is taken we will need the stub,
666 since the address might be passed to a 32 bit function.
668 Section names that look like .mips16.call.FNNAME contain stubs
669 that copy floating point arguments from the gp regs to the fp
670 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
671 then any 16 bit function that calls FNNAME should be redirected
672 to the stub instead. If FNNAME is not a 32 bit function, the
673 stub should be discarded.
675 .mips16.call.fp.FNNAME sections are similar, but contain stubs
676 which call FNNAME and then copy the return value from the fp regs
677 to the gp regs. These stubs store the return value in $18 while
678 calling FNNAME; any function which might call one of these stubs
679 must arrange to save $18 around the call. (This case is not
680 needed for 32 bit functions that call 16 bit functions, because
681 16 bit functions always return floating point values in both
682 $f0/$f1 and $2/$3.)
684 Note that in all cases FNNAME might be defined statically.
685 Therefore, FNNAME is not used literally. Instead, the relocation
686 information will indicate which symbol the section is for.
688 We record any stubs that we find in the symbol table. */
690 #define FN_STUB ".mips16.fn."
691 #define CALL_STUB ".mips16.call."
692 #define CALL_FP_STUB ".mips16.call.fp."
694 /* Look up an entry in a MIPS ELF linker hash table. */
696 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
697 ((struct mips_elf_link_hash_entry *) \
698 elf_link_hash_lookup (&(table)->root, (string), (create), \
699 (copy), (follow)))
701 /* Traverse a MIPS ELF linker hash table. */
703 #define mips_elf_link_hash_traverse(table, func, info) \
704 (elf_link_hash_traverse \
705 (&(table)->root, \
706 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
707 (info)))
709 /* Get the MIPS ELF linker hash table from a link_info structure. */
711 #define mips_elf_hash_table(p) \
712 ((struct mips_elf_link_hash_table *) ((p)->hash))
714 /* Create an entry in a MIPS ELF linker hash table. */
716 static struct bfd_hash_entry *
717 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
718 struct bfd_hash_table *table, const char *string)
720 struct mips_elf_link_hash_entry *ret =
721 (struct mips_elf_link_hash_entry *) entry;
723 /* Allocate the structure if it has not already been allocated by a
724 subclass. */
725 if (ret == NULL)
726 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
727 if (ret == NULL)
728 return (struct bfd_hash_entry *) ret;
730 /* Call the allocation method of the superclass. */
731 ret = ((struct mips_elf_link_hash_entry *)
732 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
733 table, string));
734 if (ret != NULL)
736 /* Set local fields. */
737 memset (&ret->esym, 0, sizeof (EXTR));
738 /* We use -2 as a marker to indicate that the information has
739 not been set. -1 means there is no associated ifd. */
740 ret->esym.ifd = -2;
741 ret->possibly_dynamic_relocs = 0;
742 ret->readonly_reloc = FALSE;
743 ret->no_fn_stub = FALSE;
744 ret->fn_stub = NULL;
745 ret->need_fn_stub = FALSE;
746 ret->call_stub = NULL;
747 ret->call_fp_stub = NULL;
748 ret->forced_local = FALSE;
751 return (struct bfd_hash_entry *) ret;
754 bfd_boolean
755 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
757 struct _mips_elf_section_data *sdata;
758 bfd_size_type amt = sizeof (*sdata);
760 sdata = bfd_zalloc (abfd, amt);
761 if (sdata == NULL)
762 return FALSE;
763 sec->used_by_bfd = sdata;
765 return _bfd_elf_new_section_hook (abfd, sec);
768 /* Read ECOFF debugging information from a .mdebug section into a
769 ecoff_debug_info structure. */
771 bfd_boolean
772 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
773 struct ecoff_debug_info *debug)
775 HDRR *symhdr;
776 const struct ecoff_debug_swap *swap;
777 char *ext_hdr;
779 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
780 memset (debug, 0, sizeof (*debug));
782 ext_hdr = bfd_malloc (swap->external_hdr_size);
783 if (ext_hdr == NULL && swap->external_hdr_size != 0)
784 goto error_return;
786 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
787 swap->external_hdr_size))
788 goto error_return;
790 symhdr = &debug->symbolic_header;
791 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
793 /* The symbolic header contains absolute file offsets and sizes to
794 read. */
795 #define READ(ptr, offset, count, size, type) \
796 if (symhdr->count == 0) \
797 debug->ptr = NULL; \
798 else \
800 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
801 debug->ptr = bfd_malloc (amt); \
802 if (debug->ptr == NULL) \
803 goto error_return; \
804 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
805 || bfd_bread (debug->ptr, amt, abfd) != amt) \
806 goto error_return; \
809 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
810 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
811 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
812 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
813 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
814 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
815 union aux_ext *);
816 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
817 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
818 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
819 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
820 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
821 #undef READ
823 debug->fdr = NULL;
824 debug->adjust = NULL;
826 return TRUE;
828 error_return:
829 if (ext_hdr != NULL)
830 free (ext_hdr);
831 if (debug->line != NULL)
832 free (debug->line);
833 if (debug->external_dnr != NULL)
834 free (debug->external_dnr);
835 if (debug->external_pdr != NULL)
836 free (debug->external_pdr);
837 if (debug->external_sym != NULL)
838 free (debug->external_sym);
839 if (debug->external_opt != NULL)
840 free (debug->external_opt);
841 if (debug->external_aux != NULL)
842 free (debug->external_aux);
843 if (debug->ss != NULL)
844 free (debug->ss);
845 if (debug->ssext != NULL)
846 free (debug->ssext);
847 if (debug->external_fdr != NULL)
848 free (debug->external_fdr);
849 if (debug->external_rfd != NULL)
850 free (debug->external_rfd);
851 if (debug->external_ext != NULL)
852 free (debug->external_ext);
853 return FALSE;
856 /* Swap RPDR (runtime procedure table entry) for output. */
858 static void
859 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
861 H_PUT_S32 (abfd, in->adr, ex->p_adr);
862 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
863 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
864 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
865 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
866 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
868 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
869 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
871 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
872 #if 0 /* FIXME */
873 H_PUT_S32 (abfd, in->exception_info, ex->p_exception_info);
874 #endif
877 /* Create a runtime procedure table from the .mdebug section. */
879 static bfd_boolean
880 mips_elf_create_procedure_table (void *handle, bfd *abfd,
881 struct bfd_link_info *info, asection *s,
882 struct ecoff_debug_info *debug)
884 const struct ecoff_debug_swap *swap;
885 HDRR *hdr = &debug->symbolic_header;
886 RPDR *rpdr, *rp;
887 struct rpdr_ext *erp;
888 void *rtproc;
889 struct pdr_ext *epdr;
890 struct sym_ext *esym;
891 char *ss, **sv;
892 char *str;
893 bfd_size_type size;
894 bfd_size_type count;
895 unsigned long sindex;
896 unsigned long i;
897 PDR pdr;
898 SYMR sym;
899 const char *no_name_func = _("static procedure (no name)");
901 epdr = NULL;
902 rpdr = NULL;
903 esym = NULL;
904 ss = NULL;
905 sv = NULL;
907 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
909 sindex = strlen (no_name_func) + 1;
910 count = hdr->ipdMax;
911 if (count > 0)
913 size = swap->external_pdr_size;
915 epdr = bfd_malloc (size * count);
916 if (epdr == NULL)
917 goto error_return;
919 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
920 goto error_return;
922 size = sizeof (RPDR);
923 rp = rpdr = bfd_malloc (size * count);
924 if (rpdr == NULL)
925 goto error_return;
927 size = sizeof (char *);
928 sv = bfd_malloc (size * count);
929 if (sv == NULL)
930 goto error_return;
932 count = hdr->isymMax;
933 size = swap->external_sym_size;
934 esym = bfd_malloc (size * count);
935 if (esym == NULL)
936 goto error_return;
938 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
939 goto error_return;
941 count = hdr->issMax;
942 ss = bfd_malloc (count);
943 if (ss == NULL)
944 goto error_return;
945 if (! _bfd_ecoff_get_accumulated_ss (handle, ss))
946 goto error_return;
948 count = hdr->ipdMax;
949 for (i = 0; i < (unsigned long) count; i++, rp++)
951 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
952 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
953 rp->adr = sym.value;
954 rp->regmask = pdr.regmask;
955 rp->regoffset = pdr.regoffset;
956 rp->fregmask = pdr.fregmask;
957 rp->fregoffset = pdr.fregoffset;
958 rp->frameoffset = pdr.frameoffset;
959 rp->framereg = pdr.framereg;
960 rp->pcreg = pdr.pcreg;
961 rp->irpss = sindex;
962 sv[i] = ss + sym.iss;
963 sindex += strlen (sv[i]) + 1;
967 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
968 size = BFD_ALIGN (size, 16);
969 rtproc = bfd_alloc (abfd, size);
970 if (rtproc == NULL)
972 mips_elf_hash_table (info)->procedure_count = 0;
973 goto error_return;
976 mips_elf_hash_table (info)->procedure_count = count + 2;
978 erp = rtproc;
979 memset (erp, 0, sizeof (struct rpdr_ext));
980 erp++;
981 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
982 strcpy (str, no_name_func);
983 str += strlen (no_name_func) + 1;
984 for (i = 0; i < count; i++)
986 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
987 strcpy (str, sv[i]);
988 str += strlen (sv[i]) + 1;
990 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
992 /* Set the size and contents of .rtproc section. */
993 s->_raw_size = size;
994 s->contents = rtproc;
996 /* Skip this section later on (I don't think this currently
997 matters, but someday it might). */
998 s->link_order_head = NULL;
1000 if (epdr != NULL)
1001 free (epdr);
1002 if (rpdr != NULL)
1003 free (rpdr);
1004 if (esym != NULL)
1005 free (esym);
1006 if (ss != NULL)
1007 free (ss);
1008 if (sv != NULL)
1009 free (sv);
1011 return TRUE;
1013 error_return:
1014 if (epdr != NULL)
1015 free (epdr);
1016 if (rpdr != NULL)
1017 free (rpdr);
1018 if (esym != NULL)
1019 free (esym);
1020 if (ss != NULL)
1021 free (ss);
1022 if (sv != NULL)
1023 free (sv);
1024 return FALSE;
1027 /* Check the mips16 stubs for a particular symbol, and see if we can
1028 discard them. */
1030 static bfd_boolean
1031 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h,
1032 void *data ATTRIBUTE_UNUSED)
1034 if (h->root.root.type == bfd_link_hash_warning)
1035 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1037 if (h->fn_stub != NULL
1038 && ! h->need_fn_stub)
1040 /* We don't need the fn_stub; the only references to this symbol
1041 are 16 bit calls. Clobber the size to 0 to prevent it from
1042 being included in the link. */
1043 h->fn_stub->_raw_size = 0;
1044 h->fn_stub->_cooked_size = 0;
1045 h->fn_stub->flags &= ~SEC_RELOC;
1046 h->fn_stub->reloc_count = 0;
1047 h->fn_stub->flags |= SEC_EXCLUDE;
1050 if (h->call_stub != NULL
1051 && h->root.other == STO_MIPS16)
1053 /* We don't need the call_stub; this is a 16 bit function, so
1054 calls from other 16 bit functions are OK. Clobber the size
1055 to 0 to prevent it from being included in the link. */
1056 h->call_stub->_raw_size = 0;
1057 h->call_stub->_cooked_size = 0;
1058 h->call_stub->flags &= ~SEC_RELOC;
1059 h->call_stub->reloc_count = 0;
1060 h->call_stub->flags |= SEC_EXCLUDE;
1063 if (h->call_fp_stub != NULL
1064 && h->root.other == STO_MIPS16)
1066 /* We don't need the call_stub; this is a 16 bit function, so
1067 calls from other 16 bit functions are OK. Clobber the size
1068 to 0 to prevent it from being included in the link. */
1069 h->call_fp_stub->_raw_size = 0;
1070 h->call_fp_stub->_cooked_size = 0;
1071 h->call_fp_stub->flags &= ~SEC_RELOC;
1072 h->call_fp_stub->reloc_count = 0;
1073 h->call_fp_stub->flags |= SEC_EXCLUDE;
1076 return TRUE;
1079 bfd_reloc_status_type
1080 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1081 arelent *reloc_entry, asection *input_section,
1082 bfd_boolean relocatable, void *data, bfd_vma gp)
1084 bfd_vma relocation;
1085 bfd_signed_vma val;
1086 bfd_reloc_status_type status;
1088 if (bfd_is_com_section (symbol->section))
1089 relocation = 0;
1090 else
1091 relocation = symbol->value;
1093 relocation += symbol->section->output_section->vma;
1094 relocation += symbol->section->output_offset;
1096 if (reloc_entry->address > input_section->_cooked_size)
1097 return bfd_reloc_outofrange;
1099 /* Set val to the offset into the section or symbol. */
1100 val = reloc_entry->addend;
1102 _bfd_mips_elf_sign_extend (val, 16);
1104 /* Adjust val for the final section location and GP value. If we
1105 are producing relocatable output, we don't want to do this for
1106 an external symbol. */
1107 if (! relocatable
1108 || (symbol->flags & BSF_SECTION_SYM) != 0)
1109 val += relocation - gp;
1111 if (reloc_entry->howto->partial_inplace)
1113 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1114 (bfd_byte *) data
1115 + reloc_entry->address);
1116 if (status != bfd_reloc_ok)
1117 return status;
1119 else
1120 reloc_entry->addend = val;
1122 if (relocatable)
1123 reloc_entry->address += input_section->output_offset;
1125 return bfd_reloc_ok;
1128 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1129 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1130 that contains the relocation field and DATA points to the start of
1131 INPUT_SECTION. */
1133 struct mips_hi16
1135 struct mips_hi16 *next;
1136 bfd_byte *data;
1137 asection *input_section;
1138 arelent rel;
1141 /* FIXME: This should not be a static variable. */
1143 static struct mips_hi16 *mips_hi16_list;
1145 /* A howto special_function for REL *HI16 relocations. We can only
1146 calculate the correct value once we've seen the partnering
1147 *LO16 relocation, so just save the information for later.
1149 The ABI requires that the *LO16 immediately follow the *HI16.
1150 However, as a GNU extension, we permit an arbitrary number of
1151 *HI16s to be associated with a single *LO16. This significantly
1152 simplies the relocation handling in gcc. */
1154 bfd_reloc_status_type
1155 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1156 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
1157 asection *input_section, bfd *output_bfd,
1158 char **error_message ATTRIBUTE_UNUSED)
1160 struct mips_hi16 *n;
1162 if (reloc_entry->address > input_section->_cooked_size)
1163 return bfd_reloc_outofrange;
1165 n = bfd_malloc (sizeof *n);
1166 if (n == NULL)
1167 return bfd_reloc_outofrange;
1169 n->next = mips_hi16_list;
1170 n->data = data;
1171 n->input_section = input_section;
1172 n->rel = *reloc_entry;
1173 mips_hi16_list = n;
1175 if (output_bfd != NULL)
1176 reloc_entry->address += input_section->output_offset;
1178 return bfd_reloc_ok;
1181 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1182 like any other 16-bit relocation when applied to global symbols, but is
1183 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1185 bfd_reloc_status_type
1186 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1187 void *data, asection *input_section,
1188 bfd *output_bfd, char **error_message)
1190 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1191 || bfd_is_und_section (bfd_get_section (symbol))
1192 || bfd_is_com_section (bfd_get_section (symbol)))
1193 /* The relocation is against a global symbol. */
1194 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1195 input_section, output_bfd,
1196 error_message);
1198 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1199 input_section, output_bfd, error_message);
1202 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1203 is a straightforward 16 bit inplace relocation, but we must deal with
1204 any partnering high-part relocations as well. */
1206 bfd_reloc_status_type
1207 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1208 void *data, asection *input_section,
1209 bfd *output_bfd, char **error_message)
1211 bfd_vma vallo;
1213 if (reloc_entry->address > input_section->_cooked_size)
1214 return bfd_reloc_outofrange;
1216 vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1217 while (mips_hi16_list != NULL)
1219 bfd_reloc_status_type ret;
1220 struct mips_hi16 *hi;
1222 hi = mips_hi16_list;
1224 /* R_MIPS_GOT16 relocations are something of a special case. We
1225 want to install the addend in the same way as for a R_MIPS_HI16
1226 relocation (with a rightshift of 16). However, since GOT16
1227 relocations can also be used with global symbols, their howto
1228 has a rightshift of 0. */
1229 if (hi->rel.howto->type == R_MIPS_GOT16)
1230 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
1232 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1233 carry or borrow will induce a change of +1 or -1 in the high part. */
1234 hi->rel.addend += (vallo + 0x8000) & 0xffff;
1236 /* R_MIPS_GNU_REL_HI16 relocations are relative to the address of the
1237 lo16 relocation, not their own address. If we're calculating the
1238 final value, and hence subtracting the "PC", subtract the offset
1239 of the lo16 relocation from here. */
1240 if (output_bfd == NULL && hi->rel.howto->type == R_MIPS_GNU_REL_HI16)
1241 hi->rel.addend -= reloc_entry->address - hi->rel.address;
1243 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
1244 hi->input_section, output_bfd,
1245 error_message);
1246 if (ret != bfd_reloc_ok)
1247 return ret;
1249 mips_hi16_list = hi->next;
1250 free (hi);
1253 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1254 input_section, output_bfd,
1255 error_message);
1258 /* A generic howto special_function. This calculates and installs the
1259 relocation itself, thus avoiding the oft-discussed problems in
1260 bfd_perform_relocation and bfd_install_relocation. */
1262 bfd_reloc_status_type
1263 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1264 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1265 asection *input_section, bfd *output_bfd,
1266 char **error_message ATTRIBUTE_UNUSED)
1268 bfd_signed_vma val;
1269 bfd_reloc_status_type status;
1270 bfd_boolean relocatable;
1272 relocatable = (output_bfd != NULL);
1274 if (reloc_entry->address > input_section->_cooked_size)
1275 return bfd_reloc_outofrange;
1277 /* Build up the field adjustment in VAL. */
1278 val = 0;
1279 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
1281 /* Either we're calculating the final field value or we have a
1282 relocation against a section symbol. Add in the section's
1283 offset or address. */
1284 val += symbol->section->output_section->vma;
1285 val += symbol->section->output_offset;
1288 if (!relocatable)
1290 /* We're calculating the final field value. Add in the symbol's value
1291 and, if pc-relative, subtract the address of the field itself. */
1292 val += symbol->value;
1293 if (reloc_entry->howto->pc_relative)
1295 val -= input_section->output_section->vma;
1296 val -= input_section->output_offset;
1297 val -= reloc_entry->address;
1301 /* VAL is now the final adjustment. If we're keeping this relocation
1302 in the output file, and if the relocation uses a separate addend,
1303 we just need to add VAL to that addend. Otherwise we need to add
1304 VAL to the relocation field itself. */
1305 if (relocatable && !reloc_entry->howto->partial_inplace)
1306 reloc_entry->addend += val;
1307 else
1309 /* Add in the separate addend, if any. */
1310 val += reloc_entry->addend;
1312 /* Add VAL to the relocation field. */
1313 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1314 (bfd_byte *) data
1315 + reloc_entry->address);
1316 if (status != bfd_reloc_ok)
1317 return status;
1320 if (relocatable)
1321 reloc_entry->address += input_section->output_offset;
1323 return bfd_reloc_ok;
1326 /* Swap an entry in a .gptab section. Note that these routines rely
1327 on the equivalence of the two elements of the union. */
1329 static void
1330 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
1331 Elf32_gptab *in)
1333 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
1334 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
1337 static void
1338 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
1339 Elf32_External_gptab *ex)
1341 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
1342 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
1345 static void
1346 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
1347 Elf32_External_compact_rel *ex)
1349 H_PUT_32 (abfd, in->id1, ex->id1);
1350 H_PUT_32 (abfd, in->num, ex->num);
1351 H_PUT_32 (abfd, in->id2, ex->id2);
1352 H_PUT_32 (abfd, in->offset, ex->offset);
1353 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
1354 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
1357 static void
1358 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
1359 Elf32_External_crinfo *ex)
1361 unsigned long l;
1363 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
1364 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
1365 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
1366 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
1367 H_PUT_32 (abfd, l, ex->info);
1368 H_PUT_32 (abfd, in->konst, ex->konst);
1369 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
1372 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1373 routines swap this structure in and out. They are used outside of
1374 BFD, so they are globally visible. */
1376 void
1377 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
1378 Elf32_RegInfo *in)
1380 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1381 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1382 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1383 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1384 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1385 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
1388 void
1389 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
1390 Elf32_External_RegInfo *ex)
1392 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1393 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1394 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1395 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1396 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1397 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
1400 /* In the 64 bit ABI, the .MIPS.options section holds register
1401 information in an Elf64_Reginfo structure. These routines swap
1402 them in and out. They are globally visible because they are used
1403 outside of BFD. These routines are here so that gas can call them
1404 without worrying about whether the 64 bit ABI has been included. */
1406 void
1407 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
1408 Elf64_Internal_RegInfo *in)
1410 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1411 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
1412 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1413 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1414 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1415 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1416 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
1419 void
1420 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
1421 Elf64_External_RegInfo *ex)
1423 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1424 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
1425 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1426 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1427 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1428 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1429 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
1432 /* Swap in an options header. */
1434 void
1435 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
1436 Elf_Internal_Options *in)
1438 in->kind = H_GET_8 (abfd, ex->kind);
1439 in->size = H_GET_8 (abfd, ex->size);
1440 in->section = H_GET_16 (abfd, ex->section);
1441 in->info = H_GET_32 (abfd, ex->info);
1444 /* Swap out an options header. */
1446 void
1447 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
1448 Elf_External_Options *ex)
1450 H_PUT_8 (abfd, in->kind, ex->kind);
1451 H_PUT_8 (abfd, in->size, ex->size);
1452 H_PUT_16 (abfd, in->section, ex->section);
1453 H_PUT_32 (abfd, in->info, ex->info);
1456 /* This function is called via qsort() to sort the dynamic relocation
1457 entries by increasing r_symndx value. */
1459 static int
1460 sort_dynamic_relocs (const void *arg1, const void *arg2)
1462 Elf_Internal_Rela int_reloc1;
1463 Elf_Internal_Rela int_reloc2;
1465 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1466 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1468 return ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
1471 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1473 static int
1474 sort_dynamic_relocs_64 (const void *arg1, const void *arg2)
1476 Elf_Internal_Rela int_reloc1[3];
1477 Elf_Internal_Rela int_reloc2[3];
1479 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1480 (reldyn_sorting_bfd, arg1, int_reloc1);
1481 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1482 (reldyn_sorting_bfd, arg2, int_reloc2);
1484 return (ELF64_R_SYM (int_reloc1[0].r_info)
1485 - ELF64_R_SYM (int_reloc2[0].r_info));
1489 /* This routine is used to write out ECOFF debugging external symbol
1490 information. It is called via mips_elf_link_hash_traverse. The
1491 ECOFF external symbol information must match the ELF external
1492 symbol information. Unfortunately, at this point we don't know
1493 whether a symbol is required by reloc information, so the two
1494 tables may wind up being different. We must sort out the external
1495 symbol information before we can set the final size of the .mdebug
1496 section, and we must set the size of the .mdebug section before we
1497 can relocate any sections, and we can't know which symbols are
1498 required by relocation until we relocate the sections.
1499 Fortunately, it is relatively unlikely that any symbol will be
1500 stripped but required by a reloc. In particular, it can not happen
1501 when generating a final executable. */
1503 static bfd_boolean
1504 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
1506 struct extsym_info *einfo = data;
1507 bfd_boolean strip;
1508 asection *sec, *output_section;
1510 if (h->root.root.type == bfd_link_hash_warning)
1511 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1513 if (h->root.indx == -2)
1514 strip = FALSE;
1515 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1516 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
1517 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1518 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
1519 strip = TRUE;
1520 else if (einfo->info->strip == strip_all
1521 || (einfo->info->strip == strip_some
1522 && bfd_hash_lookup (einfo->info->keep_hash,
1523 h->root.root.root.string,
1524 FALSE, FALSE) == NULL))
1525 strip = TRUE;
1526 else
1527 strip = FALSE;
1529 if (strip)
1530 return TRUE;
1532 if (h->esym.ifd == -2)
1534 h->esym.jmptbl = 0;
1535 h->esym.cobol_main = 0;
1536 h->esym.weakext = 0;
1537 h->esym.reserved = 0;
1538 h->esym.ifd = ifdNil;
1539 h->esym.asym.value = 0;
1540 h->esym.asym.st = stGlobal;
1542 if (h->root.root.type == bfd_link_hash_undefined
1543 || h->root.root.type == bfd_link_hash_undefweak)
1545 const char *name;
1547 /* Use undefined class. Also, set class and type for some
1548 special symbols. */
1549 name = h->root.root.root.string;
1550 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
1551 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
1553 h->esym.asym.sc = scData;
1554 h->esym.asym.st = stLabel;
1555 h->esym.asym.value = 0;
1557 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
1559 h->esym.asym.sc = scAbs;
1560 h->esym.asym.st = stLabel;
1561 h->esym.asym.value =
1562 mips_elf_hash_table (einfo->info)->procedure_count;
1564 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
1566 h->esym.asym.sc = scAbs;
1567 h->esym.asym.st = stLabel;
1568 h->esym.asym.value = elf_gp (einfo->abfd);
1570 else
1571 h->esym.asym.sc = scUndefined;
1573 else if (h->root.root.type != bfd_link_hash_defined
1574 && h->root.root.type != bfd_link_hash_defweak)
1575 h->esym.asym.sc = scAbs;
1576 else
1578 const char *name;
1580 sec = h->root.root.u.def.section;
1581 output_section = sec->output_section;
1583 /* When making a shared library and symbol h is the one from
1584 the another shared library, OUTPUT_SECTION may be null. */
1585 if (output_section == NULL)
1586 h->esym.asym.sc = scUndefined;
1587 else
1589 name = bfd_section_name (output_section->owner, output_section);
1591 if (strcmp (name, ".text") == 0)
1592 h->esym.asym.sc = scText;
1593 else if (strcmp (name, ".data") == 0)
1594 h->esym.asym.sc = scData;
1595 else if (strcmp (name, ".sdata") == 0)
1596 h->esym.asym.sc = scSData;
1597 else if (strcmp (name, ".rodata") == 0
1598 || strcmp (name, ".rdata") == 0)
1599 h->esym.asym.sc = scRData;
1600 else if (strcmp (name, ".bss") == 0)
1601 h->esym.asym.sc = scBss;
1602 else if (strcmp (name, ".sbss") == 0)
1603 h->esym.asym.sc = scSBss;
1604 else if (strcmp (name, ".init") == 0)
1605 h->esym.asym.sc = scInit;
1606 else if (strcmp (name, ".fini") == 0)
1607 h->esym.asym.sc = scFini;
1608 else
1609 h->esym.asym.sc = scAbs;
1613 h->esym.asym.reserved = 0;
1614 h->esym.asym.index = indexNil;
1617 if (h->root.root.type == bfd_link_hash_common)
1618 h->esym.asym.value = h->root.root.u.c.size;
1619 else if (h->root.root.type == bfd_link_hash_defined
1620 || h->root.root.type == bfd_link_hash_defweak)
1622 if (h->esym.asym.sc == scCommon)
1623 h->esym.asym.sc = scBss;
1624 else if (h->esym.asym.sc == scSCommon)
1625 h->esym.asym.sc = scSBss;
1627 sec = h->root.root.u.def.section;
1628 output_section = sec->output_section;
1629 if (output_section != NULL)
1630 h->esym.asym.value = (h->root.root.u.def.value
1631 + sec->output_offset
1632 + output_section->vma);
1633 else
1634 h->esym.asym.value = 0;
1636 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1638 struct mips_elf_link_hash_entry *hd = h;
1639 bfd_boolean no_fn_stub = h->no_fn_stub;
1641 while (hd->root.root.type == bfd_link_hash_indirect)
1643 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
1644 no_fn_stub = no_fn_stub || hd->no_fn_stub;
1647 if (!no_fn_stub)
1649 /* Set type and value for a symbol with a function stub. */
1650 h->esym.asym.st = stProc;
1651 sec = hd->root.root.u.def.section;
1652 if (sec == NULL)
1653 h->esym.asym.value = 0;
1654 else
1656 output_section = sec->output_section;
1657 if (output_section != NULL)
1658 h->esym.asym.value = (hd->root.plt.offset
1659 + sec->output_offset
1660 + output_section->vma);
1661 else
1662 h->esym.asym.value = 0;
1664 #if 0 /* FIXME? */
1665 h->esym.ifd = 0;
1666 #endif
1670 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1671 h->root.root.root.string,
1672 &h->esym))
1674 einfo->failed = TRUE;
1675 return FALSE;
1678 return TRUE;
1681 /* A comparison routine used to sort .gptab entries. */
1683 static int
1684 gptab_compare (const void *p1, const void *p2)
1686 const Elf32_gptab *a1 = p1;
1687 const Elf32_gptab *a2 = p2;
1689 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
1692 /* Functions to manage the got entry hash table. */
1694 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1695 hash number. */
1697 static INLINE hashval_t
1698 mips_elf_hash_bfd_vma (bfd_vma addr)
1700 #ifdef BFD64
1701 return addr + (addr >> 32);
1702 #else
1703 return addr;
1704 #endif
1707 /* got_entries only match if they're identical, except for gotidx, so
1708 use all fields to compute the hash, and compare the appropriate
1709 union members. */
1711 static hashval_t
1712 mips_elf_got_entry_hash (const void *entry_)
1714 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1716 return entry->symndx
1717 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
1718 : entry->abfd->id
1719 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
1720 : entry->d.h->root.root.root.hash));
1723 static int
1724 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
1726 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1727 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1729 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
1730 && (! e1->abfd ? e1->d.address == e2->d.address
1731 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
1732 : e1->d.h == e2->d.h);
1735 /* multi_got_entries are still a match in the case of global objects,
1736 even if the input bfd in which they're referenced differs, so the
1737 hash computation and compare functions are adjusted
1738 accordingly. */
1740 static hashval_t
1741 mips_elf_multi_got_entry_hash (const void *entry_)
1743 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1745 return entry->symndx
1746 + (! entry->abfd
1747 ? mips_elf_hash_bfd_vma (entry->d.address)
1748 : entry->symndx >= 0
1749 ? (entry->abfd->id
1750 + mips_elf_hash_bfd_vma (entry->d.addend))
1751 : entry->d.h->root.root.root.hash);
1754 static int
1755 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
1757 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1758 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1760 return e1->symndx == e2->symndx
1761 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
1762 : e1->abfd == NULL || e2->abfd == NULL
1763 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
1764 : e1->d.h == e2->d.h);
1767 /* Returns the dynamic relocation section for DYNOBJ. */
1769 static asection *
1770 mips_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
1772 static const char dname[] = ".rel.dyn";
1773 asection *sreloc;
1775 sreloc = bfd_get_section_by_name (dynobj, dname);
1776 if (sreloc == NULL && create_p)
1778 sreloc = bfd_make_section (dynobj, dname);
1779 if (sreloc == NULL
1780 || ! bfd_set_section_flags (dynobj, sreloc,
1781 (SEC_ALLOC
1782 | SEC_LOAD
1783 | SEC_HAS_CONTENTS
1784 | SEC_IN_MEMORY
1785 | SEC_LINKER_CREATED
1786 | SEC_READONLY))
1787 || ! bfd_set_section_alignment (dynobj, sreloc,
1788 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
1789 return NULL;
1791 return sreloc;
1794 /* Returns the GOT section for ABFD. */
1796 static asection *
1797 mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
1799 asection *sgot = bfd_get_section_by_name (abfd, ".got");
1800 if (sgot == NULL
1801 || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
1802 return NULL;
1803 return sgot;
1806 /* Returns the GOT information associated with the link indicated by
1807 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1808 section. */
1810 static struct mips_got_info *
1811 mips_elf_got_info (bfd *abfd, asection **sgotp)
1813 asection *sgot;
1814 struct mips_got_info *g;
1816 sgot = mips_elf_got_section (abfd, TRUE);
1817 BFD_ASSERT (sgot != NULL);
1818 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
1819 g = mips_elf_section_data (sgot)->u.got_info;
1820 BFD_ASSERT (g != NULL);
1822 if (sgotp)
1823 *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL;
1825 return g;
1828 /* Obtain the lowest dynamic index of a symbol that was assigned a
1829 global GOT entry. */
1830 static long
1831 mips_elf_get_global_gotsym_index (bfd *abfd)
1833 asection *sgot;
1834 struct mips_got_info *g;
1836 if (abfd == NULL)
1837 return 0;
1839 sgot = mips_elf_got_section (abfd, TRUE);
1840 if (sgot == NULL || mips_elf_section_data (sgot) == NULL)
1841 return 0;
1843 g = mips_elf_section_data (sgot)->u.got_info;
1844 if (g == NULL || g->global_gotsym == NULL)
1845 return 0;
1847 return g->global_gotsym->dynindx;
1850 /* Returns the GOT offset at which the indicated address can be found.
1851 If there is not yet a GOT entry for this value, create one. Returns
1852 -1 if no satisfactory GOT offset can be found. */
1854 static bfd_vma
1855 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1856 bfd_vma value)
1858 asection *sgot;
1859 struct mips_got_info *g;
1860 struct mips_got_entry *entry;
1862 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1864 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value);
1865 if (entry)
1866 return entry->gotidx;
1867 else
1868 return MINUS_ONE;
1871 /* Returns the GOT index for the global symbol indicated by H. */
1873 static bfd_vma
1874 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h)
1876 bfd_vma index;
1877 asection *sgot;
1878 struct mips_got_info *g, *gg;
1879 long global_got_dynindx = 0;
1881 gg = g = mips_elf_got_info (abfd, &sgot);
1882 if (g->bfd2got && ibfd)
1884 struct mips_got_entry e, *p;
1886 BFD_ASSERT (h->dynindx >= 0);
1888 g = mips_elf_got_for_ibfd (g, ibfd);
1889 if (g->next != gg)
1891 e.abfd = ibfd;
1892 e.symndx = -1;
1893 e.d.h = (struct mips_elf_link_hash_entry *)h;
1895 p = htab_find (g->got_entries, &e);
1897 BFD_ASSERT (p->gotidx > 0);
1898 return p->gotidx;
1902 if (gg->global_gotsym != NULL)
1903 global_got_dynindx = gg->global_gotsym->dynindx;
1905 /* Once we determine the global GOT entry with the lowest dynamic
1906 symbol table index, we must put all dynamic symbols with greater
1907 indices into the GOT. That makes it easy to calculate the GOT
1908 offset. */
1909 BFD_ASSERT (h->dynindx >= global_got_dynindx);
1910 index = ((h->dynindx - global_got_dynindx + g->local_gotno)
1911 * MIPS_ELF_GOT_SIZE (abfd));
1912 BFD_ASSERT (index < sgot->_raw_size);
1914 return index;
1917 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1918 are supposed to be placed at small offsets in the GOT, i.e.,
1919 within 32KB of GP. Return the index into the GOT for this page,
1920 and store the offset from this entry to the desired address in
1921 OFFSETP, if it is non-NULL. */
1923 static bfd_vma
1924 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1925 bfd_vma value, bfd_vma *offsetp)
1927 asection *sgot;
1928 struct mips_got_info *g;
1929 bfd_vma index;
1930 struct mips_got_entry *entry;
1932 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1934 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot,
1935 (value + 0x8000)
1936 & (~(bfd_vma)0xffff));
1938 if (!entry)
1939 return MINUS_ONE;
1941 index = entry->gotidx;
1943 if (offsetp)
1944 *offsetp = value - entry->d.address;
1946 return index;
1949 /* Find a GOT entry whose higher-order 16 bits are the same as those
1950 for value. Return the index into the GOT for this entry. */
1952 static bfd_vma
1953 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1954 bfd_vma value, bfd_boolean external)
1956 asection *sgot;
1957 struct mips_got_info *g;
1958 struct mips_got_entry *entry;
1960 if (! external)
1962 /* Although the ABI says that it is "the high-order 16 bits" that we
1963 want, it is really the %high value. The complete value is
1964 calculated with a `addiu' of a LO16 relocation, just as with a
1965 HI16/LO16 pair. */
1966 value = mips_elf_high (value) << 16;
1969 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1971 entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value);
1972 if (entry)
1973 return entry->gotidx;
1974 else
1975 return MINUS_ONE;
1978 /* Returns the offset for the entry at the INDEXth position
1979 in the GOT. */
1981 static bfd_vma
1982 mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
1983 bfd *input_bfd, bfd_vma index)
1985 asection *sgot;
1986 bfd_vma gp;
1987 struct mips_got_info *g;
1989 g = mips_elf_got_info (dynobj, &sgot);
1990 gp = _bfd_get_gp_value (output_bfd)
1991 + mips_elf_adjust_gp (output_bfd, g, input_bfd);
1993 return sgot->output_section->vma + sgot->output_offset + index - gp;
1996 /* Create a local GOT entry for VALUE. Return the index of the entry,
1997 or -1 if it could not be created. */
1999 static struct mips_got_entry *
2000 mips_elf_create_local_got_entry (bfd *abfd, bfd *ibfd,
2001 struct mips_got_info *gg,
2002 asection *sgot, bfd_vma value)
2004 struct mips_got_entry entry, **loc;
2005 struct mips_got_info *g;
2007 entry.abfd = NULL;
2008 entry.symndx = -1;
2009 entry.d.address = value;
2011 g = mips_elf_got_for_ibfd (gg, ibfd);
2012 if (g == NULL)
2014 g = mips_elf_got_for_ibfd (gg, abfd);
2015 BFD_ASSERT (g != NULL);
2018 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2019 INSERT);
2020 if (*loc)
2021 return *loc;
2023 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
2025 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2027 if (! *loc)
2028 return NULL;
2030 memcpy (*loc, &entry, sizeof entry);
2032 if (g->assigned_gotno >= g->local_gotno)
2034 (*loc)->gotidx = -1;
2035 /* We didn't allocate enough space in the GOT. */
2036 (*_bfd_error_handler)
2037 (_("not enough GOT space for local GOT entries"));
2038 bfd_set_error (bfd_error_bad_value);
2039 return NULL;
2042 MIPS_ELF_PUT_WORD (abfd, value,
2043 (sgot->contents + entry.gotidx));
2045 return *loc;
2048 /* Sort the dynamic symbol table so that symbols that need GOT entries
2049 appear towards the end. This reduces the amount of GOT space
2050 required. MAX_LOCAL is used to set the number of local symbols
2051 known to be in the dynamic symbol table. During
2052 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2053 section symbols are added and the count is higher. */
2055 static bfd_boolean
2056 mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local)
2058 struct mips_elf_hash_sort_data hsd;
2059 struct mips_got_info *g;
2060 bfd *dynobj;
2062 dynobj = elf_hash_table (info)->dynobj;
2064 g = mips_elf_got_info (dynobj, NULL);
2066 hsd.low = NULL;
2067 hsd.max_unref_got_dynindx =
2068 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
2069 /* In the multi-got case, assigned_gotno of the master got_info
2070 indicate the number of entries that aren't referenced in the
2071 primary GOT, but that must have entries because there are
2072 dynamic relocations that reference it. Since they aren't
2073 referenced, we move them to the end of the GOT, so that they
2074 don't prevent other entries that are referenced from getting
2075 too large offsets. */
2076 - (g->next ? g->assigned_gotno : 0);
2077 hsd.max_non_got_dynindx = max_local;
2078 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
2079 elf_hash_table (info)),
2080 mips_elf_sort_hash_table_f,
2081 &hsd);
2083 /* There should have been enough room in the symbol table to
2084 accommodate both the GOT and non-GOT symbols. */
2085 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
2086 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
2087 <= elf_hash_table (info)->dynsymcount);
2089 /* Now we know which dynamic symbol has the lowest dynamic symbol
2090 table index in the GOT. */
2091 g->global_gotsym = hsd.low;
2093 return TRUE;
2096 /* If H needs a GOT entry, assign it the highest available dynamic
2097 index. Otherwise, assign it the lowest available dynamic
2098 index. */
2100 static bfd_boolean
2101 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
2103 struct mips_elf_hash_sort_data *hsd = data;
2105 if (h->root.root.type == bfd_link_hash_warning)
2106 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2108 /* Symbols without dynamic symbol table entries aren't interesting
2109 at all. */
2110 if (h->root.dynindx == -1)
2111 return TRUE;
2113 /* Global symbols that need GOT entries that are not explicitly
2114 referenced are marked with got offset 2. Those that are
2115 referenced get a 1, and those that don't need GOT entries get
2116 -1. */
2117 if (h->root.got.offset == 2)
2119 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
2120 hsd->low = (struct elf_link_hash_entry *) h;
2121 h->root.dynindx = hsd->max_unref_got_dynindx++;
2123 else if (h->root.got.offset != 1)
2124 h->root.dynindx = hsd->max_non_got_dynindx++;
2125 else
2127 h->root.dynindx = --hsd->min_got_dynindx;
2128 hsd->low = (struct elf_link_hash_entry *) h;
2131 return TRUE;
2134 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2135 symbol table index lower than any we've seen to date, record it for
2136 posterity. */
2138 static bfd_boolean
2139 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
2140 bfd *abfd, struct bfd_link_info *info,
2141 struct mips_got_info *g)
2143 struct mips_got_entry entry, **loc;
2145 /* A global symbol in the GOT must also be in the dynamic symbol
2146 table. */
2147 if (h->dynindx == -1)
2149 switch (ELF_ST_VISIBILITY (h->other))
2151 case STV_INTERNAL:
2152 case STV_HIDDEN:
2153 _bfd_mips_elf_hide_symbol (info, h, TRUE);
2154 break;
2156 if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2157 return FALSE;
2160 entry.abfd = abfd;
2161 entry.symndx = -1;
2162 entry.d.h = (struct mips_elf_link_hash_entry *) h;
2164 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2165 INSERT);
2167 /* If we've already marked this entry as needing GOT space, we don't
2168 need to do it again. */
2169 if (*loc)
2170 return TRUE;
2172 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2174 if (! *loc)
2175 return FALSE;
2177 entry.gotidx = -1;
2178 memcpy (*loc, &entry, sizeof entry);
2180 if (h->got.offset != MINUS_ONE)
2181 return TRUE;
2183 /* By setting this to a value other than -1, we are indicating that
2184 there needs to be a GOT entry for H. Avoid using zero, as the
2185 generic ELF copy_indirect_symbol tests for <= 0. */
2186 h->got.offset = 1;
2188 return TRUE;
2191 /* Reserve space in G for a GOT entry containing the value of symbol
2192 SYMNDX in input bfd ABDF, plus ADDEND. */
2194 static bfd_boolean
2195 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
2196 struct mips_got_info *g)
2198 struct mips_got_entry entry, **loc;
2200 entry.abfd = abfd;
2201 entry.symndx = symndx;
2202 entry.d.addend = addend;
2203 loc = (struct mips_got_entry **)
2204 htab_find_slot (g->got_entries, &entry, INSERT);
2206 if (*loc)
2207 return TRUE;
2209 entry.gotidx = g->local_gotno++;
2211 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2213 if (! *loc)
2214 return FALSE;
2216 memcpy (*loc, &entry, sizeof entry);
2218 return TRUE;
2221 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2223 static hashval_t
2224 mips_elf_bfd2got_entry_hash (const void *entry_)
2226 const struct mips_elf_bfd2got_hash *entry
2227 = (struct mips_elf_bfd2got_hash *)entry_;
2229 return entry->bfd->id;
2232 /* Check whether two hash entries have the same bfd. */
2234 static int
2235 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
2237 const struct mips_elf_bfd2got_hash *e1
2238 = (const struct mips_elf_bfd2got_hash *)entry1;
2239 const struct mips_elf_bfd2got_hash *e2
2240 = (const struct mips_elf_bfd2got_hash *)entry2;
2242 return e1->bfd == e2->bfd;
2245 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2246 be the master GOT data. */
2248 static struct mips_got_info *
2249 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
2251 struct mips_elf_bfd2got_hash e, *p;
2253 if (! g->bfd2got)
2254 return g;
2256 e.bfd = ibfd;
2257 p = htab_find (g->bfd2got, &e);
2258 return p ? p->g : NULL;
2261 /* Create one separate got for each bfd that has entries in the global
2262 got, such that we can tell how many local and global entries each
2263 bfd requires. */
2265 static int
2266 mips_elf_make_got_per_bfd (void **entryp, void *p)
2268 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2269 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2270 htab_t bfd2got = arg->bfd2got;
2271 struct mips_got_info *g;
2272 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
2273 void **bfdgotp;
2275 /* Find the got_info for this GOT entry's input bfd. Create one if
2276 none exists. */
2277 bfdgot_entry.bfd = entry->abfd;
2278 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
2279 bfdgot = (struct mips_elf_bfd2got_hash *)*bfdgotp;
2281 if (bfdgot != NULL)
2282 g = bfdgot->g;
2283 else
2285 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
2286 (arg->obfd, sizeof (struct mips_elf_bfd2got_hash));
2288 if (bfdgot == NULL)
2290 arg->obfd = 0;
2291 return 0;
2294 *bfdgotp = bfdgot;
2296 bfdgot->bfd = entry->abfd;
2297 bfdgot->g = g = (struct mips_got_info *)
2298 bfd_alloc (arg->obfd, sizeof (struct mips_got_info));
2299 if (g == NULL)
2301 arg->obfd = 0;
2302 return 0;
2305 g->global_gotsym = NULL;
2306 g->global_gotno = 0;
2307 g->local_gotno = 0;
2308 g->assigned_gotno = -1;
2309 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
2310 mips_elf_multi_got_entry_eq, NULL);
2311 if (g->got_entries == NULL)
2313 arg->obfd = 0;
2314 return 0;
2317 g->bfd2got = NULL;
2318 g->next = NULL;
2321 /* Insert the GOT entry in the bfd's got entry hash table. */
2322 entryp = htab_find_slot (g->got_entries, entry, INSERT);
2323 if (*entryp != NULL)
2324 return 1;
2326 *entryp = entry;
2328 if (entry->symndx >= 0 || entry->d.h->forced_local)
2329 ++g->local_gotno;
2330 else
2331 ++g->global_gotno;
2333 return 1;
2336 /* Attempt to merge gots of different input bfds. Try to use as much
2337 as possible of the primary got, since it doesn't require explicit
2338 dynamic relocations, but don't use bfds that would reference global
2339 symbols out of the addressable range. Failing the primary got,
2340 attempt to merge with the current got, or finish the current got
2341 and then make make the new got current. */
2343 static int
2344 mips_elf_merge_gots (void **bfd2got_, void *p)
2346 struct mips_elf_bfd2got_hash *bfd2got
2347 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
2348 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2349 unsigned int lcount = bfd2got->g->local_gotno;
2350 unsigned int gcount = bfd2got->g->global_gotno;
2351 unsigned int maxcnt = arg->max_count;
2353 /* If we don't have a primary GOT and this is not too big, use it as
2354 a starting point for the primary GOT. */
2355 if (! arg->primary && lcount + gcount <= maxcnt)
2357 arg->primary = bfd2got->g;
2358 arg->primary_count = lcount + gcount;
2360 /* If it looks like we can merge this bfd's entries with those of
2361 the primary, merge them. The heuristics is conservative, but we
2362 don't have to squeeze it too hard. */
2363 else if (arg->primary
2364 && (arg->primary_count + lcount + gcount) <= maxcnt)
2366 struct mips_got_info *g = bfd2got->g;
2367 int old_lcount = arg->primary->local_gotno;
2368 int old_gcount = arg->primary->global_gotno;
2370 bfd2got->g = arg->primary;
2372 htab_traverse (g->got_entries,
2373 mips_elf_make_got_per_bfd,
2374 arg);
2375 if (arg->obfd == NULL)
2376 return 0;
2378 htab_delete (g->got_entries);
2379 /* We don't have to worry about releasing memory of the actual
2380 got entries, since they're all in the master got_entries hash
2381 table anyway. */
2383 BFD_ASSERT (old_lcount + lcount >= arg->primary->local_gotno);
2384 BFD_ASSERT (old_gcount + gcount >= arg->primary->global_gotno);
2386 arg->primary_count = arg->primary->local_gotno
2387 + arg->primary->global_gotno;
2389 /* If we can merge with the last-created got, do it. */
2390 else if (arg->current
2391 && arg->current_count + lcount + gcount <= maxcnt)
2393 struct mips_got_info *g = bfd2got->g;
2394 int old_lcount = arg->current->local_gotno;
2395 int old_gcount = arg->current->global_gotno;
2397 bfd2got->g = arg->current;
2399 htab_traverse (g->got_entries,
2400 mips_elf_make_got_per_bfd,
2401 arg);
2402 if (arg->obfd == NULL)
2403 return 0;
2405 htab_delete (g->got_entries);
2407 BFD_ASSERT (old_lcount + lcount >= arg->current->local_gotno);
2408 BFD_ASSERT (old_gcount + gcount >= arg->current->global_gotno);
2410 arg->current_count = arg->current->local_gotno
2411 + arg->current->global_gotno;
2413 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2414 fits; if it turns out that it doesn't, we'll get relocation
2415 overflows anyway. */
2416 else
2418 bfd2got->g->next = arg->current;
2419 arg->current = bfd2got->g;
2421 arg->current_count = lcount + gcount;
2424 return 1;
2427 /* If passed a NULL mips_got_info in the argument, set the marker used
2428 to tell whether a global symbol needs a got entry (in the primary
2429 got) to the given VALUE.
2431 If passed a pointer G to a mips_got_info in the argument (it must
2432 not be the primary GOT), compute the offset from the beginning of
2433 the (primary) GOT section to the entry in G corresponding to the
2434 global symbol. G's assigned_gotno must contain the index of the
2435 first available global GOT entry in G. VALUE must contain the size
2436 of a GOT entry in bytes. For each global GOT entry that requires a
2437 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2438 marked as not eligible for lazy resolution through a function
2439 stub. */
2440 static int
2441 mips_elf_set_global_got_offset (void **entryp, void *p)
2443 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2444 struct mips_elf_set_global_got_offset_arg *arg
2445 = (struct mips_elf_set_global_got_offset_arg *)p;
2446 struct mips_got_info *g = arg->g;
2448 if (entry->abfd != NULL && entry->symndx == -1
2449 && entry->d.h->root.dynindx != -1)
2451 if (g)
2453 BFD_ASSERT (g->global_gotsym == NULL);
2455 entry->gotidx = arg->value * (long) g->assigned_gotno++;
2456 if (arg->info->shared
2457 || (elf_hash_table (arg->info)->dynamic_sections_created
2458 && ((entry->d.h->root.elf_link_hash_flags
2459 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
2460 && ((entry->d.h->root.elf_link_hash_flags
2461 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
2462 ++arg->needed_relocs;
2464 else
2465 entry->d.h->root.got.offset = arg->value;
2468 return 1;
2471 /* Mark any global symbols referenced in the GOT we are iterating over
2472 as inelligible for lazy resolution stubs. */
2473 static int
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;
2483 return 1;
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. */
2492 static int
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)
2507 return 1;
2509 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);
2517 if (! *entryp)
2518 *entryp = entry;
2519 /* Abort the traversal, since the whole table may have
2520 moved, and leave it up to the parent to restart the
2521 process. */
2522 *(htab_t *)p = NULL;
2523 return 0;
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. */
2529 return 1;
2532 /* Turn indirect got entries in a got_entries table into their final
2533 locations. */
2534 static void
2535 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
2537 htab_t got_entries;
2541 got_entries = g->got_entries;
2543 htab_traverse (got_entries,
2544 mips_elf_resolve_final_got_entry,
2545 &got_entries);
2547 while (got_entries == NULL);
2550 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2551 the primary GOT. */
2552 static bfd_vma
2553 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
2555 if (g->bfd2got == NULL)
2556 return 0;
2558 g = mips_elf_got_for_ibfd (g, ibfd);
2559 if (! g)
2560 return 0;
2562 BFD_ASSERT (g->next);
2564 g = 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. */
2572 static bfd_boolean
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)
2585 return FALSE;
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)
2596 return FALSE;
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)
2612 return FALSE;
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)
2620 return FALSE;
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,
2628 NULL);
2629 if (g->next->got_entries == NULL)
2630 return FALSE;
2631 g->next->bfd2got = NULL;
2633 else
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. */
2638 gg = g;
2639 g = g->next;
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
2645 list. */
2647 struct mips_elf_bfd2got_hash *bfdgot;
2648 void **bfdgotp;
2650 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
2651 (abfd, sizeof (struct mips_elf_bfd2got_hash));
2653 if (bfdgot == NULL)
2654 return FALSE;
2656 bfdgot->bfd = abfd;
2657 bfdgot->g = g;
2658 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
2660 BFD_ASSERT (*bfdgotp == NULL);
2661 *bfdgotp = bfdgot;
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
2667 referenced.
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
2680 preserved. */
2681 if (1)
2683 gg->assigned_gotno = gg->global_gotno - g->global_gotno;
2684 g->global_gotno = gg->global_gotno;
2685 set_got_offset_arg.value = 2;
2687 else
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))
2708 return FALSE;
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;
2725 assign = 0;
2726 gg->next = gg;
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. */
2739 gn = g->next;
2740 g->next = gg->next;
2741 gg->next = g;
2742 g = gn;
2744 /* Mark global symbols in every non-primary GOT as ineligible for
2745 stubs. */
2746 if (g)
2747 htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL);
2749 while (g);
2751 got->_raw_size = (gg->next->local_gotno
2752 + gg->next->global_gotno) * MIPS_ELF_GOT_SIZE (abfd);
2754 return TRUE;
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 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2767 immediately following. However, for the IRIX6 ABI, the next
2768 relocation may be a composed relocation consisting of several
2769 relocations for the same address. In that case, the R_MIPS_LO16
2770 relocation may occur as one of these. We permit a similar
2771 extension in general, as that is useful for GCC. */
2772 while (relocation < relend)
2774 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type)
2775 return relocation;
2777 ++relocation;
2780 /* We didn't find it. */
2781 bfd_set_error (bfd_error_bad_value);
2782 return NULL;
2785 /* Return whether a relocation is against a local symbol. */
2787 static bfd_boolean
2788 mips_elf_local_relocation_p (bfd *input_bfd,
2789 const Elf_Internal_Rela *relocation,
2790 asection **local_sections,
2791 bfd_boolean check_forced)
2793 unsigned long r_symndx;
2794 Elf_Internal_Shdr *symtab_hdr;
2795 struct mips_elf_link_hash_entry *h;
2796 size_t extsymoff;
2798 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
2799 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2800 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
2802 if (r_symndx < extsymoff)
2803 return TRUE;
2804 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
2805 return TRUE;
2807 if (check_forced)
2809 /* Look up the hash table to check whether the symbol
2810 was forced local. */
2811 h = (struct mips_elf_link_hash_entry *)
2812 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
2813 /* Find the real hash-table entry for this symbol. */
2814 while (h->root.root.type == bfd_link_hash_indirect
2815 || h->root.root.type == bfd_link_hash_warning)
2816 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2817 if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
2818 return TRUE;
2821 return FALSE;
2824 /* Sign-extend VALUE, which has the indicated number of BITS. */
2826 bfd_vma
2827 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
2829 if (value & ((bfd_vma) 1 << (bits - 1)))
2830 /* VALUE is negative. */
2831 value |= ((bfd_vma) - 1) << bits;
2833 return value;
2836 /* Return non-zero if the indicated VALUE has overflowed the maximum
2837 range expressible by a signed number with the indicated number of
2838 BITS. */
2840 static bfd_boolean
2841 mips_elf_overflow_p (bfd_vma value, int bits)
2843 bfd_signed_vma svalue = (bfd_signed_vma) value;
2845 if (svalue > (1 << (bits - 1)) - 1)
2846 /* The value is too big. */
2847 return TRUE;
2848 else if (svalue < -(1 << (bits - 1)))
2849 /* The value is too small. */
2850 return TRUE;
2852 /* All is well. */
2853 return FALSE;
2856 /* Calculate the %high function. */
2858 static bfd_vma
2859 mips_elf_high (bfd_vma value)
2861 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
2864 /* Calculate the %higher function. */
2866 static bfd_vma
2867 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
2869 #ifdef BFD64
2870 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
2871 #else
2872 abort ();
2873 return (bfd_vma) -1;
2874 #endif
2877 /* Calculate the %highest function. */
2879 static bfd_vma
2880 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
2882 #ifdef BFD64
2883 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2884 #else
2885 abort ();
2886 return (bfd_vma) -1;
2887 #endif
2890 /* Create the .compact_rel section. */
2892 static bfd_boolean
2893 mips_elf_create_compact_rel_section
2894 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2896 flagword flags;
2897 register asection *s;
2899 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
2901 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
2902 | SEC_READONLY);
2904 s = bfd_make_section (abfd, ".compact_rel");
2905 if (s == NULL
2906 || ! bfd_set_section_flags (abfd, s, flags)
2907 || ! bfd_set_section_alignment (abfd, s,
2908 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
2909 return FALSE;
2911 s->_raw_size = sizeof (Elf32_External_compact_rel);
2914 return TRUE;
2917 /* Create the .got section to hold the global offset table. */
2919 static bfd_boolean
2920 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info,
2921 bfd_boolean maybe_exclude)
2923 flagword flags;
2924 register asection *s;
2925 struct elf_link_hash_entry *h;
2926 struct bfd_link_hash_entry *bh;
2927 struct mips_got_info *g;
2928 bfd_size_type amt;
2930 /* This function may be called more than once. */
2931 s = mips_elf_got_section (abfd, TRUE);
2932 if (s)
2934 if (! maybe_exclude)
2935 s->flags &= ~SEC_EXCLUDE;
2936 return TRUE;
2939 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2940 | SEC_LINKER_CREATED);
2942 if (maybe_exclude)
2943 flags |= SEC_EXCLUDE;
2945 /* We have to use an alignment of 2**4 here because this is hardcoded
2946 in the function stub generation and in the linker script. */
2947 s = bfd_make_section (abfd, ".got");
2948 if (s == NULL
2949 || ! bfd_set_section_flags (abfd, s, flags)
2950 || ! bfd_set_section_alignment (abfd, s, 4))
2951 return FALSE;
2953 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2954 linker script because we don't want to define the symbol if we
2955 are not creating a global offset table. */
2956 bh = NULL;
2957 if (! (_bfd_generic_link_add_one_symbol
2958 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
2959 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2960 return FALSE;
2962 h = (struct elf_link_hash_entry *) bh;
2963 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
2964 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2965 h->type = STT_OBJECT;
2967 if (info->shared
2968 && ! bfd_elf32_link_record_dynamic_symbol (info, h))
2969 return FALSE;
2971 amt = sizeof (struct mips_got_info);
2972 g = bfd_alloc (abfd, amt);
2973 if (g == NULL)
2974 return FALSE;
2975 g->global_gotsym = NULL;
2976 g->global_gotno = 0;
2977 g->local_gotno = MIPS_RESERVED_GOTNO;
2978 g->assigned_gotno = MIPS_RESERVED_GOTNO;
2979 g->bfd2got = NULL;
2980 g->next = NULL;
2981 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
2982 mips_elf_got_entry_eq, NULL);
2983 if (g->got_entries == NULL)
2984 return FALSE;
2985 mips_elf_section_data (s)->u.got_info = g;
2986 mips_elf_section_data (s)->elf.this_hdr.sh_flags
2987 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
2989 return TRUE;
2992 /* Calculate the value produced by the RELOCATION (which comes from
2993 the INPUT_BFD). The ADDEND is the addend to use for this
2994 RELOCATION; RELOCATION->R_ADDEND is ignored.
2996 The result of the relocation calculation is stored in VALUEP.
2997 REQUIRE_JALXP indicates whether or not the opcode used with this
2998 relocation must be JALX.
3000 This function returns bfd_reloc_continue if the caller need take no
3001 further action regarding this relocation, bfd_reloc_notsupported if
3002 something goes dramatically wrong, bfd_reloc_overflow if an
3003 overflow occurs, and bfd_reloc_ok to indicate success. */
3005 static bfd_reloc_status_type
3006 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
3007 asection *input_section,
3008 struct bfd_link_info *info,
3009 const Elf_Internal_Rela *relocation,
3010 bfd_vma addend, reloc_howto_type *howto,
3011 Elf_Internal_Sym *local_syms,
3012 asection **local_sections, bfd_vma *valuep,
3013 const char **namep, bfd_boolean *require_jalxp,
3014 bfd_boolean save_addend)
3016 /* The eventual value we will return. */
3017 bfd_vma value;
3018 /* The address of the symbol against which the relocation is
3019 occurring. */
3020 bfd_vma symbol = 0;
3021 /* The final GP value to be used for the relocatable, executable, or
3022 shared object file being produced. */
3023 bfd_vma gp = MINUS_ONE;
3024 /* The place (section offset or address) of the storage unit being
3025 relocated. */
3026 bfd_vma p;
3027 /* The value of GP used to create the relocatable object. */
3028 bfd_vma gp0 = MINUS_ONE;
3029 /* The offset into the global offset table at which the address of
3030 the relocation entry symbol, adjusted by the addend, resides
3031 during execution. */
3032 bfd_vma g = MINUS_ONE;
3033 /* The section in which the symbol referenced by the relocation is
3034 located. */
3035 asection *sec = NULL;
3036 struct mips_elf_link_hash_entry *h = NULL;
3037 /* TRUE if the symbol referred to by this relocation is a local
3038 symbol. */
3039 bfd_boolean local_p, was_local_p;
3040 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3041 bfd_boolean gp_disp_p = FALSE;
3042 Elf_Internal_Shdr *symtab_hdr;
3043 size_t extsymoff;
3044 unsigned long r_symndx;
3045 int r_type;
3046 /* TRUE if overflow occurred during the calculation of the
3047 relocation value. */
3048 bfd_boolean overflowed_p;
3049 /* TRUE if this relocation refers to a MIPS16 function. */
3050 bfd_boolean target_is_16_bit_code_p = FALSE;
3052 /* Parse the relocation. */
3053 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3054 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3055 p = (input_section->output_section->vma
3056 + input_section->output_offset
3057 + relocation->r_offset);
3059 /* Assume that there will be no overflow. */
3060 overflowed_p = FALSE;
3062 /* Figure out whether or not the symbol is local, and get the offset
3063 used in the array of hash table entries. */
3064 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3065 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3066 local_sections, FALSE);
3067 was_local_p = local_p;
3068 if (! elf_bad_symtab (input_bfd))
3069 extsymoff = symtab_hdr->sh_info;
3070 else
3072 /* The symbol table does not follow the rule that local symbols
3073 must come before globals. */
3074 extsymoff = 0;
3077 /* Figure out the value of the symbol. */
3078 if (local_p)
3080 Elf_Internal_Sym *sym;
3082 sym = local_syms + r_symndx;
3083 sec = local_sections[r_symndx];
3085 symbol = sec->output_section->vma + sec->output_offset;
3086 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
3087 || (sec->flags & SEC_MERGE))
3088 symbol += sym->st_value;
3089 if ((sec->flags & SEC_MERGE)
3090 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3092 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
3093 addend -= symbol;
3094 addend += sec->output_section->vma + sec->output_offset;
3097 /* MIPS16 text labels should be treated as odd. */
3098 if (sym->st_other == STO_MIPS16)
3099 ++symbol;
3101 /* Record the name of this symbol, for our caller. */
3102 *namep = bfd_elf_string_from_elf_section (input_bfd,
3103 symtab_hdr->sh_link,
3104 sym->st_name);
3105 if (*namep == '\0')
3106 *namep = bfd_section_name (input_bfd, sec);
3108 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3110 else
3112 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3114 /* For global symbols we look up the symbol in the hash-table. */
3115 h = ((struct mips_elf_link_hash_entry *)
3116 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3117 /* Find the real hash-table entry for this symbol. */
3118 while (h->root.root.type == bfd_link_hash_indirect
3119 || h->root.root.type == bfd_link_hash_warning)
3120 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3122 /* Record the name of this symbol, for our caller. */
3123 *namep = h->root.root.root.string;
3125 /* See if this is the special _gp_disp symbol. Note that such a
3126 symbol must always be a global symbol. */
3127 if (strcmp (*namep, "_gp_disp") == 0
3128 && ! NEWABI_P (input_bfd))
3130 /* Relocations against _gp_disp are permitted only with
3131 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3132 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
3133 return bfd_reloc_notsupported;
3135 gp_disp_p = TRUE;
3137 /* If this symbol is defined, calculate its address. Note that
3138 _gp_disp is a magic symbol, always implicitly defined by the
3139 linker, so it's inappropriate to check to see whether or not
3140 its defined. */
3141 else if ((h->root.root.type == bfd_link_hash_defined
3142 || h->root.root.type == bfd_link_hash_defweak)
3143 && h->root.root.u.def.section)
3145 sec = h->root.root.u.def.section;
3146 if (sec->output_section)
3147 symbol = (h->root.root.u.def.value
3148 + sec->output_section->vma
3149 + sec->output_offset);
3150 else
3151 symbol = h->root.root.u.def.value;
3153 else if (h->root.root.type == bfd_link_hash_undefweak)
3154 /* We allow relocations against undefined weak symbols, giving
3155 it the value zero, so that you can undefined weak functions
3156 and check to see if they exist by looking at their
3157 addresses. */
3158 symbol = 0;
3159 else if (info->shared
3160 && info->unresolved_syms_in_objects == RM_IGNORE
3161 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3162 symbol = 0;
3163 else if (strcmp (*namep, "_DYNAMIC_LINK") == 0 ||
3164 strcmp (*namep, "_DYNAMIC_LINKING") == 0)
3166 /* If this is a dynamic link, we should have created a
3167 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3168 in in _bfd_mips_elf_create_dynamic_sections.
3169 Otherwise, we should define the symbol with a value of 0.
3170 FIXME: It should probably get into the symbol table
3171 somehow as well. */
3172 BFD_ASSERT (! info->shared);
3173 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3174 symbol = 0;
3176 else
3178 if (! ((*info->callbacks->undefined_symbol)
3179 (info, h->root.root.root.string, input_bfd,
3180 input_section, relocation->r_offset,
3181 ((info->shared && info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)
3182 || (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
3183 || ELF_ST_VISIBILITY (h->root.other)))))
3184 return bfd_reloc_undefined;
3185 symbol = 0;
3188 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3191 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3192 need to redirect the call to the stub, unless we're already *in*
3193 a stub. */
3194 if (r_type != R_MIPS16_26 && !info->relocatable
3195 && ((h != NULL && h->fn_stub != NULL)
3196 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3197 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3198 && !mips_elf_stub_section_p (input_bfd, input_section))
3200 /* This is a 32- or 64-bit call to a 16-bit function. We should
3201 have already noticed that we were going to need the
3202 stub. */
3203 if (local_p)
3204 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3205 else
3207 BFD_ASSERT (h->need_fn_stub);
3208 sec = h->fn_stub;
3211 symbol = sec->output_section->vma + sec->output_offset;
3213 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3214 need to redirect the call to the stub. */
3215 else if (r_type == R_MIPS16_26 && !info->relocatable
3216 && h != NULL
3217 && (h->call_stub != NULL || h->call_fp_stub != NULL)
3218 && !target_is_16_bit_code_p)
3220 /* If both call_stub and call_fp_stub are defined, we can figure
3221 out which one to use by seeing which one appears in the input
3222 file. */
3223 if (h->call_stub != NULL && h->call_fp_stub != NULL)
3225 asection *o;
3227 sec = NULL;
3228 for (o = input_bfd->sections; o != NULL; o = o->next)
3230 if (strncmp (bfd_get_section_name (input_bfd, o),
3231 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3233 sec = h->call_fp_stub;
3234 break;
3237 if (sec == NULL)
3238 sec = h->call_stub;
3240 else if (h->call_stub != NULL)
3241 sec = h->call_stub;
3242 else
3243 sec = h->call_fp_stub;
3245 BFD_ASSERT (sec->_raw_size > 0);
3246 symbol = sec->output_section->vma + sec->output_offset;
3249 /* Calls from 16-bit code to 32-bit code and vice versa require the
3250 special jalx instruction. */
3251 *require_jalxp = (!info->relocatable
3252 && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
3253 || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
3255 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3256 local_sections, TRUE);
3258 /* If we haven't already determined the GOT offset, or the GP value,
3259 and we're going to need it, get it now. */
3260 switch (r_type)
3262 case R_MIPS_GOT_PAGE:
3263 case R_MIPS_GOT_OFST:
3264 /* If this symbol got a global GOT entry, we have to decay
3265 GOT_PAGE/GOT_OFST to GOT_DISP/addend. */
3266 local_p = local_p || ! h
3267 || (h->root.dynindx
3268 < mips_elf_get_global_gotsym_index (elf_hash_table (info)
3269 ->dynobj));
3270 if (local_p || r_type == R_MIPS_GOT_OFST)
3271 break;
3272 /* Fall through. */
3274 case R_MIPS_CALL16:
3275 case R_MIPS_GOT16:
3276 case R_MIPS_GOT_DISP:
3277 case R_MIPS_GOT_HI16:
3278 case R_MIPS_CALL_HI16:
3279 case R_MIPS_GOT_LO16:
3280 case R_MIPS_CALL_LO16:
3281 /* Find the index into the GOT where this value is located. */
3282 if (!local_p)
3284 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3285 GOT_PAGE relocation that decays to GOT_DISP because the
3286 symbol turns out to be global. The addend is then added
3287 as GOT_OFST. */
3288 BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
3289 g = mips_elf_global_got_index (elf_hash_table (info)->dynobj,
3290 input_bfd,
3291 (struct elf_link_hash_entry *) h);
3292 if (! elf_hash_table(info)->dynamic_sections_created
3293 || (info->shared
3294 && (info->symbolic || h->root.dynindx == -1)
3295 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3297 /* This is a static link or a -Bsymbolic link. The
3298 symbol is defined locally, or was forced to be local.
3299 We must initialize this entry in the GOT. */
3300 bfd *tmpbfd = elf_hash_table (info)->dynobj;
3301 asection *sgot = mips_elf_got_section (tmpbfd, FALSE);
3302 MIPS_ELF_PUT_WORD (tmpbfd, symbol, sgot->contents + g);
3305 else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3306 /* There's no need to create a local GOT entry here; the
3307 calculation for a local GOT16 entry does not involve G. */
3308 break;
3309 else
3311 g = mips_elf_local_got_index (abfd, input_bfd,
3312 info, symbol + addend);
3313 if (g == MINUS_ONE)
3314 return bfd_reloc_outofrange;
3317 /* Convert GOT indices to actual offsets. */
3318 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3319 abfd, input_bfd, g);
3320 break;
3322 case R_MIPS_HI16:
3323 case R_MIPS_LO16:
3324 case R_MIPS16_GPREL:
3325 case R_MIPS_GPREL16:
3326 case R_MIPS_GPREL32:
3327 case R_MIPS_LITERAL:
3328 gp0 = _bfd_get_gp_value (input_bfd);
3329 gp = _bfd_get_gp_value (abfd);
3330 if (elf_hash_table (info)->dynobj)
3331 gp += mips_elf_adjust_gp (abfd,
3332 mips_elf_got_info
3333 (elf_hash_table (info)->dynobj, NULL),
3334 input_bfd);
3335 break;
3337 default:
3338 break;
3341 /* Figure out what kind of relocation is being performed. */
3342 switch (r_type)
3344 case R_MIPS_NONE:
3345 return bfd_reloc_continue;
3347 case R_MIPS_16:
3348 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
3349 overflowed_p = mips_elf_overflow_p (value, 16);
3350 break;
3352 case R_MIPS_32:
3353 case R_MIPS_REL32:
3354 case R_MIPS_64:
3355 if ((info->shared
3356 || (elf_hash_table (info)->dynamic_sections_created
3357 && h != NULL
3358 && ((h->root.elf_link_hash_flags
3359 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3360 && ((h->root.elf_link_hash_flags
3361 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3362 && r_symndx != 0
3363 && (input_section->flags & SEC_ALLOC) != 0)
3365 /* If we're creating a shared library, or this relocation is
3366 against a symbol in a shared library, then we can't know
3367 where the symbol will end up. So, we create a relocation
3368 record in the output, and leave the job up to the dynamic
3369 linker. */
3370 value = addend;
3371 if (!mips_elf_create_dynamic_relocation (abfd,
3372 info,
3373 relocation,
3375 sec,
3376 symbol,
3377 &value,
3378 input_section))
3379 return bfd_reloc_undefined;
3381 else
3383 if (r_type != R_MIPS_REL32)
3384 value = symbol + addend;
3385 else
3386 value = addend;
3388 value &= howto->dst_mask;
3389 break;
3391 case R_MIPS_PC32:
3392 case R_MIPS_PC64:
3393 case R_MIPS_GNU_REL_LO16:
3394 value = symbol + addend - p;
3395 value &= howto->dst_mask;
3396 break;
3398 case R_MIPS_GNU_REL16_S2:
3399 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
3400 overflowed_p = mips_elf_overflow_p (value, 18);
3401 value = (value >> 2) & howto->dst_mask;
3402 break;
3404 case R_MIPS_GNU_REL_HI16:
3405 /* Instead of subtracting 'p' here, we should be subtracting the
3406 equivalent value for the LO part of the reloc, since the value
3407 here is relative to that address. Because that's not easy to do,
3408 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3409 the comment there for more information. */
3410 value = mips_elf_high (addend + symbol - p);
3411 value &= howto->dst_mask;
3412 break;
3414 case R_MIPS16_26:
3415 /* The calculation for R_MIPS16_26 is just the same as for an
3416 R_MIPS_26. It's only the storage of the relocated field into
3417 the output file that's different. That's handled in
3418 mips_elf_perform_relocation. So, we just fall through to the
3419 R_MIPS_26 case here. */
3420 case R_MIPS_26:
3421 if (local_p)
3422 value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3423 else
3424 value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2;
3425 value &= howto->dst_mask;
3426 break;
3428 case R_MIPS_HI16:
3429 if (!gp_disp_p)
3431 value = mips_elf_high (addend + symbol);
3432 value &= howto->dst_mask;
3434 else
3436 value = mips_elf_high (addend + gp - p);
3437 overflowed_p = mips_elf_overflow_p (value, 16);
3439 break;
3441 case R_MIPS_LO16:
3442 if (!gp_disp_p)
3443 value = (symbol + addend) & howto->dst_mask;
3444 else
3446 value = addend + gp - p + 4;
3447 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3448 for overflow. But, on, say, IRIX5, relocations against
3449 _gp_disp are normally generated from the .cpload
3450 pseudo-op. It generates code that normally looks like
3451 this:
3453 lui $gp,%hi(_gp_disp)
3454 addiu $gp,$gp,%lo(_gp_disp)
3455 addu $gp,$gp,$t9
3457 Here $t9 holds the address of the function being called,
3458 as required by the MIPS ELF ABI. The R_MIPS_LO16
3459 relocation can easily overflow in this situation, but the
3460 R_MIPS_HI16 relocation will handle the overflow.
3461 Therefore, we consider this a bug in the MIPS ABI, and do
3462 not check for overflow here. */
3464 break;
3466 case R_MIPS_LITERAL:
3467 /* Because we don't merge literal sections, we can handle this
3468 just like R_MIPS_GPREL16. In the long run, we should merge
3469 shared literals, and then we will need to additional work
3470 here. */
3472 /* Fall through. */
3474 case R_MIPS16_GPREL:
3475 /* The R_MIPS16_GPREL performs the same calculation as
3476 R_MIPS_GPREL16, but stores the relocated bits in a different
3477 order. We don't need to do anything special here; the
3478 differences are handled in mips_elf_perform_relocation. */
3479 case R_MIPS_GPREL16:
3480 /* Only sign-extend the addend if it was extracted from the
3481 instruction. If the addend was separate, leave it alone,
3482 otherwise we may lose significant bits. */
3483 if (howto->partial_inplace)
3484 addend = _bfd_mips_elf_sign_extend (addend, 16);
3485 value = symbol + addend - gp;
3486 /* If the symbol was local, any earlier relocatable links will
3487 have adjusted its addend with the gp offset, so compensate
3488 for that now. Don't do it for symbols forced local in this
3489 link, though, since they won't have had the gp offset applied
3490 to them before. */
3491 if (was_local_p)
3492 value += gp0;
3493 overflowed_p = mips_elf_overflow_p (value, 16);
3494 break;
3496 case R_MIPS_GOT16:
3497 case R_MIPS_CALL16:
3498 if (local_p)
3500 bfd_boolean forced;
3502 /* The special case is when the symbol is forced to be local. We
3503 need the full address in the GOT since no R_MIPS_LO16 relocation
3504 follows. */
3505 forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
3506 local_sections, FALSE);
3507 value = mips_elf_got16_entry (abfd, input_bfd, info,
3508 symbol + addend, forced);
3509 if (value == MINUS_ONE)
3510 return bfd_reloc_outofrange;
3511 value
3512 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3513 abfd, input_bfd, value);
3514 overflowed_p = mips_elf_overflow_p (value, 16);
3515 break;
3518 /* Fall through. */
3520 case R_MIPS_GOT_DISP:
3521 got_disp:
3522 value = g;
3523 overflowed_p = mips_elf_overflow_p (value, 16);
3524 break;
3526 case R_MIPS_GPREL32:
3527 value = (addend + symbol + gp0 - gp);
3528 if (!save_addend)
3529 value &= howto->dst_mask;
3530 break;
3532 case R_MIPS_PC16:
3533 value = _bfd_mips_elf_sign_extend (addend, 16) + symbol - p;
3534 overflowed_p = mips_elf_overflow_p (value, 16);
3535 break;
3537 case R_MIPS_GOT_HI16:
3538 case R_MIPS_CALL_HI16:
3539 /* We're allowed to handle these two relocations identically.
3540 The dynamic linker is allowed to handle the CALL relocations
3541 differently by creating a lazy evaluation stub. */
3542 value = g;
3543 value = mips_elf_high (value);
3544 value &= howto->dst_mask;
3545 break;
3547 case R_MIPS_GOT_LO16:
3548 case R_MIPS_CALL_LO16:
3549 value = g & howto->dst_mask;
3550 break;
3552 case R_MIPS_GOT_PAGE:
3553 /* GOT_PAGE relocations that reference non-local symbols decay
3554 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3555 0. */
3556 if (! local_p)
3557 goto got_disp;
3558 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
3559 if (value == MINUS_ONE)
3560 return bfd_reloc_outofrange;
3561 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3562 abfd, input_bfd, value);
3563 overflowed_p = mips_elf_overflow_p (value, 16);
3564 break;
3566 case R_MIPS_GOT_OFST:
3567 if (local_p)
3568 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
3569 else
3570 value = addend;
3571 overflowed_p = mips_elf_overflow_p (value, 16);
3572 break;
3574 case R_MIPS_SUB:
3575 value = symbol - addend;
3576 value &= howto->dst_mask;
3577 break;
3579 case R_MIPS_HIGHER:
3580 value = mips_elf_higher (addend + symbol);
3581 value &= howto->dst_mask;
3582 break;
3584 case R_MIPS_HIGHEST:
3585 value = mips_elf_highest (addend + symbol);
3586 value &= howto->dst_mask;
3587 break;
3589 case R_MIPS_SCN_DISP:
3590 value = symbol + addend - sec->output_offset;
3591 value &= howto->dst_mask;
3592 break;
3594 case R_MIPS_PJUMP:
3595 case R_MIPS_JALR:
3596 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3597 hint; we could improve performance by honoring that hint. */
3598 return bfd_reloc_continue;
3600 case R_MIPS_GNU_VTINHERIT:
3601 case R_MIPS_GNU_VTENTRY:
3602 /* We don't do anything with these at present. */
3603 return bfd_reloc_continue;
3605 default:
3606 /* An unrecognized relocation type. */
3607 return bfd_reloc_notsupported;
3610 /* Store the VALUE for our caller. */
3611 *valuep = value;
3612 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
3615 /* Obtain the field relocated by RELOCATION. */
3617 static bfd_vma
3618 mips_elf_obtain_contents (reloc_howto_type *howto,
3619 const Elf_Internal_Rela *relocation,
3620 bfd *input_bfd, bfd_byte *contents)
3622 bfd_vma x;
3623 bfd_byte *location = contents + relocation->r_offset;
3625 /* Obtain the bytes. */
3626 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
3628 if ((ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_26
3629 || ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_GPREL)
3630 && bfd_little_endian (input_bfd))
3631 /* The two 16-bit words will be reversed on a little-endian system.
3632 See mips_elf_perform_relocation for more details. */
3633 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3635 return x;
3638 /* It has been determined that the result of the RELOCATION is the
3639 VALUE. Use HOWTO to place VALUE into the output file at the
3640 appropriate position. The SECTION is the section to which the
3641 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3642 for the relocation must be either JAL or JALX, and it is
3643 unconditionally converted to JALX.
3645 Returns FALSE if anything goes wrong. */
3647 static bfd_boolean
3648 mips_elf_perform_relocation (struct bfd_link_info *info,
3649 reloc_howto_type *howto,
3650 const Elf_Internal_Rela *relocation,
3651 bfd_vma value, bfd *input_bfd,
3652 asection *input_section, bfd_byte *contents,
3653 bfd_boolean require_jalx)
3655 bfd_vma x;
3656 bfd_byte *location;
3657 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3659 /* Figure out where the relocation is occurring. */
3660 location = contents + relocation->r_offset;
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 /* If this is the R_MIPS16_26 relocation, we must store the
3669 value in a funny way. */
3670 if (r_type == R_MIPS16_26)
3672 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3673 Most mips16 instructions are 16 bits, but these instructions
3674 are 32 bits.
3676 The format of these instructions is:
3678 +--------------+--------------------------------+
3679 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3680 +--------------+--------------------------------+
3681 ! Immediate 15:0 !
3682 +-----------------------------------------------+
3684 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3685 Note that the immediate value in the first word is swapped.
3687 When producing a relocatable object file, R_MIPS16_26 is
3688 handled mostly like R_MIPS_26. In particular, the addend is
3689 stored as a straight 26-bit value in a 32-bit instruction.
3690 (gas makes life simpler for itself by never adjusting a
3691 R_MIPS16_26 reloc to be against a section, so the addend is
3692 always zero). However, the 32 bit instruction is stored as 2
3693 16-bit values, rather than a single 32-bit value. In a
3694 big-endian file, the result is the same; in a little-endian
3695 file, the two 16-bit halves of the 32 bit value are swapped.
3696 This is so that a disassembler can recognize the jal
3697 instruction.
3699 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3700 instruction stored as two 16-bit values. The addend A is the
3701 contents of the targ26 field. The calculation is the same as
3702 R_MIPS_26. When storing the calculated value, reorder the
3703 immediate value as shown above, and don't forget to store the
3704 value as two 16-bit values.
3706 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3707 defined as
3709 big-endian:
3710 +--------+----------------------+
3711 | | |
3712 | | targ26-16 |
3713 |31 26|25 0|
3714 +--------+----------------------+
3716 little-endian:
3717 +----------+------+-------------+
3718 | | | |
3719 | sub1 | | sub2 |
3720 |0 9|10 15|16 31|
3721 +----------+--------------------+
3722 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3723 ((sub1 << 16) | sub2)).
3725 When producing a relocatable object file, the calculation is
3726 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3727 When producing a fully linked file, the calculation is
3728 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3729 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3731 if (!info->relocatable)
3732 /* Shuffle the bits according to the formula above. */
3733 value = (((value & 0x1f0000) << 5)
3734 | ((value & 0x3e00000) >> 5)
3735 | (value & 0xffff));
3737 else if (r_type == R_MIPS16_GPREL)
3739 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3740 mode. A typical instruction will have a format like this:
3742 +--------------+--------------------------------+
3743 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3744 +--------------+--------------------------------+
3745 ! Major ! rx ! ry ! Imm 4:0 !
3746 +--------------+--------------------------------+
3748 EXTEND is the five bit value 11110. Major is the instruction
3749 opcode.
3751 This is handled exactly like R_MIPS_GPREL16, except that the
3752 addend is retrieved and stored as shown in this diagram; that
3753 is, the Imm fields above replace the V-rel16 field.
3755 All we need to do here is shuffle the bits appropriately. As
3756 above, the two 16-bit halves must be swapped on a
3757 little-endian system. */
3758 value = (((value & 0x7e0) << 16)
3759 | ((value & 0xf800) << 5)
3760 | (value & 0x1f));
3763 /* Set the field. */
3764 x |= (value & howto->dst_mask);
3766 /* If required, turn JAL into JALX. */
3767 if (require_jalx)
3769 bfd_boolean ok;
3770 bfd_vma opcode = x >> 26;
3771 bfd_vma jalx_opcode;
3773 /* Check to see if the opcode is already JAL or JALX. */
3774 if (r_type == R_MIPS16_26)
3776 ok = ((opcode == 0x6) || (opcode == 0x7));
3777 jalx_opcode = 0x7;
3779 else
3781 ok = ((opcode == 0x3) || (opcode == 0x1d));
3782 jalx_opcode = 0x1d;
3785 /* If the opcode is not JAL or JALX, there's a problem. */
3786 if (!ok)
3788 (*_bfd_error_handler)
3789 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3790 bfd_archive_filename (input_bfd),
3791 input_section->name,
3792 (unsigned long) relocation->r_offset);
3793 bfd_set_error (bfd_error_bad_value);
3794 return FALSE;
3797 /* Make this the JALX opcode. */
3798 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
3801 /* Swap the high- and low-order 16 bits on little-endian systems
3802 when doing a MIPS16 relocation. */
3803 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
3804 && bfd_little_endian (input_bfd))
3805 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3807 /* Put the value into the output. */
3808 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
3809 return TRUE;
3812 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3814 static bfd_boolean
3815 mips_elf_stub_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
3817 const char *name = bfd_get_section_name (abfd, section);
3819 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
3820 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
3821 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
3824 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3826 static void
3827 mips_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
3829 asection *s;
3831 s = mips_elf_rel_dyn_section (abfd, FALSE);
3832 BFD_ASSERT (s != NULL);
3834 if (s->_raw_size == 0)
3836 /* Make room for a null element. */
3837 s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
3838 ++s->reloc_count;
3840 s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
3843 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3844 is the original relocation, which is now being transformed into a
3845 dynamic relocation. The ADDENDP is adjusted if necessary; the
3846 caller should store the result in place of the original addend. */
3848 static bfd_boolean
3849 mips_elf_create_dynamic_relocation (bfd *output_bfd,
3850 struct bfd_link_info *info,
3851 const Elf_Internal_Rela *rel,
3852 struct mips_elf_link_hash_entry *h,
3853 asection *sec, bfd_vma symbol,
3854 bfd_vma *addendp, asection *input_section)
3856 Elf_Internal_Rela outrel[3];
3857 bfd_boolean skip;
3858 asection *sreloc;
3859 bfd *dynobj;
3860 int r_type;
3862 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
3863 dynobj = elf_hash_table (info)->dynobj;
3864 sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
3865 BFD_ASSERT (sreloc != NULL);
3866 BFD_ASSERT (sreloc->contents != NULL);
3867 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
3868 < sreloc->_raw_size);
3870 skip = FALSE;
3871 outrel[0].r_offset =
3872 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
3873 outrel[1].r_offset =
3874 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
3875 outrel[2].r_offset =
3876 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
3878 #if 0
3879 /* We begin by assuming that the offset for the dynamic relocation
3880 is the same as for the original relocation. We'll adjust this
3881 later to reflect the correct output offsets. */
3882 if (input_section->sec_info_type != ELF_INFO_TYPE_STABS)
3884 outrel[1].r_offset = rel[1].r_offset;
3885 outrel[2].r_offset = rel[2].r_offset;
3887 else
3889 /* Except that in a stab section things are more complex.
3890 Because we compress stab information, the offset given in the
3891 relocation may not be the one we want; we must let the stabs
3892 machinery tell us the offset. */
3893 outrel[1].r_offset = outrel[0].r_offset;
3894 outrel[2].r_offset = outrel[0].r_offset;
3895 /* If we didn't need the relocation at all, this value will be
3896 -1. */
3897 if (outrel[0].r_offset == (bfd_vma) -1)
3898 skip = TRUE;
3900 #endif
3902 if (outrel[0].r_offset == (bfd_vma) -1)
3903 /* The relocation field has been deleted. */
3904 skip = TRUE;
3905 else if (outrel[0].r_offset == (bfd_vma) -2)
3907 /* The relocation field has been converted into a relative value of
3908 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3909 the field to be fully relocated, so add in the symbol's value. */
3910 skip = TRUE;
3911 *addendp += symbol;
3914 /* If we've decided to skip this relocation, just output an empty
3915 record. Note that R_MIPS_NONE == 0, so that this call to memset
3916 is a way of setting R_TYPE to R_MIPS_NONE. */
3917 if (skip)
3918 memset (outrel, 0, sizeof (Elf_Internal_Rela) * 3);
3919 else
3921 long indx;
3922 bfd_boolean defined_p;
3924 /* We must now calculate the dynamic symbol table index to use
3925 in the relocation. */
3926 if (h != NULL
3927 && (! info->symbolic || (h->root.elf_link_hash_flags
3928 & ELF_LINK_HASH_DEF_REGULAR) == 0)
3929 /* h->root.dynindx may be -1 if this symbol was marked to
3930 become local. */
3931 && h->root.dynindx != -1)
3933 indx = h->root.dynindx;
3934 if (SGI_COMPAT (output_bfd))
3935 defined_p = ((h->root.elf_link_hash_flags
3936 & ELF_LINK_HASH_DEF_REGULAR) != 0);
3937 else
3938 /* ??? glibc's ld.so just adds the final GOT entry to the
3939 relocation field. It therefore treats relocs against
3940 defined symbols in the same way as relocs against
3941 undefined symbols. */
3942 defined_p = FALSE;
3944 else
3946 if (sec != NULL && bfd_is_abs_section (sec))
3947 indx = 0;
3948 else if (sec == NULL || sec->owner == NULL)
3950 bfd_set_error (bfd_error_bad_value);
3951 return FALSE;
3953 else
3955 indx = elf_section_data (sec->output_section)->dynindx;
3956 if (indx == 0)
3957 abort ();
3960 /* Instead of generating a relocation using the section
3961 symbol, we may as well make it a fully relative
3962 relocation. We want to avoid generating relocations to
3963 local symbols because we used to generate them
3964 incorrectly, without adding the original symbol value,
3965 which is mandated by the ABI for section symbols. In
3966 order to give dynamic loaders and applications time to
3967 phase out the incorrect use, we refrain from emitting
3968 section-relative relocations. It's not like they're
3969 useful, after all. This should be a bit more efficient
3970 as well. */
3971 /* ??? Although this behavior is compatible with glibc's ld.so,
3972 the ABI says that relocations against STN_UNDEF should have
3973 a symbol value of 0. Irix rld honors this, so relocations
3974 against STN_UNDEF have no effect. */
3975 if (!SGI_COMPAT (output_bfd))
3976 indx = 0;
3977 defined_p = TRUE;
3980 /* If the relocation was previously an absolute relocation and
3981 this symbol will not be referred to by the relocation, we must
3982 adjust it by the value we give it in the dynamic symbol table.
3983 Otherwise leave the job up to the dynamic linker. */
3984 if (defined_p && r_type != R_MIPS_REL32)
3985 *addendp += symbol;
3987 /* The relocation is always an REL32 relocation because we don't
3988 know where the shared library will wind up at load-time. */
3989 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
3990 R_MIPS_REL32);
3991 /* For strict adherence to the ABI specification, we should
3992 generate a R_MIPS_64 relocation record by itself before the
3993 _REL32/_64 record as well, such that the addend is read in as
3994 a 64-bit value (REL32 is a 32-bit relocation, after all).
3995 However, since none of the existing ELF64 MIPS dynamic
3996 loaders seems to care, we don't waste space with these
3997 artificial relocations. If this turns out to not be true,
3998 mips_elf_allocate_dynamic_relocation() should be tweaked so
3999 as to make room for a pair of dynamic relocations per
4000 invocation if ABI_64_P, and here we should generate an
4001 additional relocation record with R_MIPS_64 by itself for a
4002 NULL symbol before this relocation record. */
4003 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
4004 ABI_64_P (output_bfd)
4005 ? R_MIPS_64
4006 : R_MIPS_NONE);
4007 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
4009 /* Adjust the output offset of the relocation to reference the
4010 correct location in the output file. */
4011 outrel[0].r_offset += (input_section->output_section->vma
4012 + input_section->output_offset);
4013 outrel[1].r_offset += (input_section->output_section->vma
4014 + input_section->output_offset);
4015 outrel[2].r_offset += (input_section->output_section->vma
4016 + input_section->output_offset);
4019 /* Put the relocation back out. We have to use the special
4020 relocation outputter in the 64-bit case since the 64-bit
4021 relocation format is non-standard. */
4022 if (ABI_64_P (output_bfd))
4024 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
4025 (output_bfd, &outrel[0],
4026 (sreloc->contents
4027 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
4029 else
4030 bfd_elf32_swap_reloc_out
4031 (output_bfd, &outrel[0],
4032 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
4034 /* We've now added another relocation. */
4035 ++sreloc->reloc_count;
4037 /* Make sure the output section is writable. The dynamic linker
4038 will be writing to it. */
4039 elf_section_data (input_section->output_section)->this_hdr.sh_flags
4040 |= SHF_WRITE;
4042 /* On IRIX5, make an entry of compact relocation info. */
4043 if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
4045 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
4046 bfd_byte *cr;
4048 if (scpt)
4050 Elf32_crinfo cptrel;
4052 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
4053 cptrel.vaddr = (rel->r_offset
4054 + input_section->output_section->vma
4055 + input_section->output_offset);
4056 if (r_type == R_MIPS_REL32)
4057 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
4058 else
4059 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
4060 mips_elf_set_cr_dist2to (cptrel, 0);
4061 cptrel.konst = *addendp;
4063 cr = (scpt->contents
4064 + sizeof (Elf32_External_compact_rel));
4065 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
4066 ((Elf32_External_crinfo *) cr
4067 + scpt->reloc_count));
4068 ++scpt->reloc_count;
4072 return TRUE;
4075 /* Return the MACH for a MIPS e_flags value. */
4077 unsigned long
4078 _bfd_elf_mips_mach (flagword flags)
4080 switch (flags & EF_MIPS_MACH)
4082 case E_MIPS_MACH_3900:
4083 return bfd_mach_mips3900;
4085 case E_MIPS_MACH_4010:
4086 return bfd_mach_mips4010;
4088 case E_MIPS_MACH_4100:
4089 return bfd_mach_mips4100;
4091 case E_MIPS_MACH_4111:
4092 return bfd_mach_mips4111;
4094 case E_MIPS_MACH_4120:
4095 return bfd_mach_mips4120;
4097 case E_MIPS_MACH_4650:
4098 return bfd_mach_mips4650;
4100 case E_MIPS_MACH_5400:
4101 return bfd_mach_mips5400;
4103 case E_MIPS_MACH_5500:
4104 return bfd_mach_mips5500;
4106 case E_MIPS_MACH_SB1:
4107 return bfd_mach_mips_sb1;
4109 default:
4110 switch (flags & EF_MIPS_ARCH)
4112 default:
4113 case E_MIPS_ARCH_1:
4114 return bfd_mach_mips3000;
4115 break;
4117 case E_MIPS_ARCH_2:
4118 return bfd_mach_mips6000;
4119 break;
4121 case E_MIPS_ARCH_3:
4122 return bfd_mach_mips4000;
4123 break;
4125 case E_MIPS_ARCH_4:
4126 return bfd_mach_mips8000;
4127 break;
4129 case E_MIPS_ARCH_5:
4130 return bfd_mach_mips5;
4131 break;
4133 case E_MIPS_ARCH_32:
4134 return bfd_mach_mipsisa32;
4135 break;
4137 case E_MIPS_ARCH_64:
4138 return bfd_mach_mipsisa64;
4139 break;
4141 case E_MIPS_ARCH_32R2:
4142 return bfd_mach_mipsisa32r2;
4143 break;
4145 case E_MIPS_ARCH_64R2:
4146 return bfd_mach_mipsisa64r2;
4147 break;
4151 return 0;
4154 /* Return printable name for ABI. */
4156 static INLINE char *
4157 elf_mips_abi_name (bfd *abfd)
4159 flagword flags;
4161 flags = elf_elfheader (abfd)->e_flags;
4162 switch (flags & EF_MIPS_ABI)
4164 case 0:
4165 if (ABI_N32_P (abfd))
4166 return "N32";
4167 else if (ABI_64_P (abfd))
4168 return "64";
4169 else
4170 return "none";
4171 case E_MIPS_ABI_O32:
4172 return "O32";
4173 case E_MIPS_ABI_O64:
4174 return "O64";
4175 case E_MIPS_ABI_EABI32:
4176 return "EABI32";
4177 case E_MIPS_ABI_EABI64:
4178 return "EABI64";
4179 default:
4180 return "unknown abi";
4184 /* MIPS ELF uses two common sections. One is the usual one, and the
4185 other is for small objects. All the small objects are kept
4186 together, and then referenced via the gp pointer, which yields
4187 faster assembler code. This is what we use for the small common
4188 section. This approach is copied from ecoff.c. */
4189 static asection mips_elf_scom_section;
4190 static asymbol mips_elf_scom_symbol;
4191 static asymbol *mips_elf_scom_symbol_ptr;
4193 /* MIPS ELF also uses an acommon section, which represents an
4194 allocated common symbol which may be overridden by a
4195 definition in a shared library. */
4196 static asection mips_elf_acom_section;
4197 static asymbol mips_elf_acom_symbol;
4198 static asymbol *mips_elf_acom_symbol_ptr;
4200 /* Handle the special MIPS section numbers that a symbol may use.
4201 This is used for both the 32-bit and the 64-bit ABI. */
4203 void
4204 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
4206 elf_symbol_type *elfsym;
4208 elfsym = (elf_symbol_type *) asym;
4209 switch (elfsym->internal_elf_sym.st_shndx)
4211 case SHN_MIPS_ACOMMON:
4212 /* This section is used in a dynamically linked executable file.
4213 It is an allocated common section. The dynamic linker can
4214 either resolve these symbols to something in a shared
4215 library, or it can just leave them here. For our purposes,
4216 we can consider these symbols to be in a new section. */
4217 if (mips_elf_acom_section.name == NULL)
4219 /* Initialize the acommon section. */
4220 mips_elf_acom_section.name = ".acommon";
4221 mips_elf_acom_section.flags = SEC_ALLOC;
4222 mips_elf_acom_section.output_section = &mips_elf_acom_section;
4223 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
4224 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
4225 mips_elf_acom_symbol.name = ".acommon";
4226 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
4227 mips_elf_acom_symbol.section = &mips_elf_acom_section;
4228 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
4230 asym->section = &mips_elf_acom_section;
4231 break;
4233 case SHN_COMMON:
4234 /* Common symbols less than the GP size are automatically
4235 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4236 if (asym->value > elf_gp_size (abfd)
4237 || IRIX_COMPAT (abfd) == ict_irix6)
4238 break;
4239 /* Fall through. */
4240 case SHN_MIPS_SCOMMON:
4241 if (mips_elf_scom_section.name == NULL)
4243 /* Initialize the small common section. */
4244 mips_elf_scom_section.name = ".scommon";
4245 mips_elf_scom_section.flags = SEC_IS_COMMON;
4246 mips_elf_scom_section.output_section = &mips_elf_scom_section;
4247 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
4248 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
4249 mips_elf_scom_symbol.name = ".scommon";
4250 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
4251 mips_elf_scom_symbol.section = &mips_elf_scom_section;
4252 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
4254 asym->section = &mips_elf_scom_section;
4255 asym->value = elfsym->internal_elf_sym.st_size;
4256 break;
4258 case SHN_MIPS_SUNDEFINED:
4259 asym->section = bfd_und_section_ptr;
4260 break;
4262 #if 0 /* for SGI_COMPAT */
4263 case SHN_MIPS_TEXT:
4264 asym->section = mips_elf_text_section_ptr;
4265 break;
4267 case SHN_MIPS_DATA:
4268 asym->section = mips_elf_data_section_ptr;
4269 break;
4270 #endif
4274 /* Work over a section just before writing it out. This routine is
4275 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4276 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4277 a better way. */
4279 bfd_boolean
4280 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
4282 if (hdr->sh_type == SHT_MIPS_REGINFO
4283 && hdr->sh_size > 0)
4285 bfd_byte buf[4];
4287 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
4288 BFD_ASSERT (hdr->contents == NULL);
4290 if (bfd_seek (abfd,
4291 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
4292 SEEK_SET) != 0)
4293 return FALSE;
4294 H_PUT_32 (abfd, elf_gp (abfd), buf);
4295 if (bfd_bwrite (buf, 4, abfd) != 4)
4296 return FALSE;
4299 if (hdr->sh_type == SHT_MIPS_OPTIONS
4300 && hdr->bfd_section != NULL
4301 && mips_elf_section_data (hdr->bfd_section) != NULL
4302 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
4304 bfd_byte *contents, *l, *lend;
4306 /* We stored the section contents in the tdata field in the
4307 set_section_contents routine. We save the section contents
4308 so that we don't have to read them again.
4309 At this point we know that elf_gp is set, so we can look
4310 through the section contents to see if there is an
4311 ODK_REGINFO structure. */
4313 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
4314 l = contents;
4315 lend = contents + hdr->sh_size;
4316 while (l + sizeof (Elf_External_Options) <= lend)
4318 Elf_Internal_Options intopt;
4320 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4321 &intopt);
4322 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4324 bfd_byte buf[8];
4326 if (bfd_seek (abfd,
4327 (hdr->sh_offset
4328 + (l - contents)
4329 + sizeof (Elf_External_Options)
4330 + (sizeof (Elf64_External_RegInfo) - 8)),
4331 SEEK_SET) != 0)
4332 return FALSE;
4333 H_PUT_64 (abfd, elf_gp (abfd), buf);
4334 if (bfd_bwrite (buf, 8, abfd) != 8)
4335 return FALSE;
4337 else if (intopt.kind == ODK_REGINFO)
4339 bfd_byte buf[4];
4341 if (bfd_seek (abfd,
4342 (hdr->sh_offset
4343 + (l - contents)
4344 + sizeof (Elf_External_Options)
4345 + (sizeof (Elf32_External_RegInfo) - 4)),
4346 SEEK_SET) != 0)
4347 return FALSE;
4348 H_PUT_32 (abfd, elf_gp (abfd), buf);
4349 if (bfd_bwrite (buf, 4, abfd) != 4)
4350 return FALSE;
4352 l += intopt.size;
4356 if (hdr->bfd_section != NULL)
4358 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
4360 if (strcmp (name, ".sdata") == 0
4361 || strcmp (name, ".lit8") == 0
4362 || strcmp (name, ".lit4") == 0)
4364 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4365 hdr->sh_type = SHT_PROGBITS;
4367 else if (strcmp (name, ".sbss") == 0)
4369 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4370 hdr->sh_type = SHT_NOBITS;
4372 else if (strcmp (name, ".srdata") == 0)
4374 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
4375 hdr->sh_type = SHT_PROGBITS;
4377 else if (strcmp (name, ".compact_rel") == 0)
4379 hdr->sh_flags = 0;
4380 hdr->sh_type = SHT_PROGBITS;
4382 else if (strcmp (name, ".rtproc") == 0)
4384 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
4386 unsigned int adjust;
4388 adjust = hdr->sh_size % hdr->sh_addralign;
4389 if (adjust != 0)
4390 hdr->sh_size += hdr->sh_addralign - adjust;
4395 return TRUE;
4398 /* Handle a MIPS specific section when reading an object file. This
4399 is called when elfcode.h finds a section with an unknown type.
4400 This routine supports both the 32-bit and 64-bit ELF ABI.
4402 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4403 how to. */
4405 bfd_boolean
4406 _bfd_mips_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
4407 const char *name)
4409 flagword flags = 0;
4411 /* There ought to be a place to keep ELF backend specific flags, but
4412 at the moment there isn't one. We just keep track of the
4413 sections by their name, instead. Fortunately, the ABI gives
4414 suggested names for all the MIPS specific sections, so we will
4415 probably get away with this. */
4416 switch (hdr->sh_type)
4418 case SHT_MIPS_LIBLIST:
4419 if (strcmp (name, ".liblist") != 0)
4420 return FALSE;
4421 break;
4422 case SHT_MIPS_MSYM:
4423 if (strcmp (name, ".msym") != 0)
4424 return FALSE;
4425 break;
4426 case SHT_MIPS_CONFLICT:
4427 if (strcmp (name, ".conflict") != 0)
4428 return FALSE;
4429 break;
4430 case SHT_MIPS_GPTAB:
4431 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
4432 return FALSE;
4433 break;
4434 case SHT_MIPS_UCODE:
4435 if (strcmp (name, ".ucode") != 0)
4436 return FALSE;
4437 break;
4438 case SHT_MIPS_DEBUG:
4439 if (strcmp (name, ".mdebug") != 0)
4440 return FALSE;
4441 flags = SEC_DEBUGGING;
4442 break;
4443 case SHT_MIPS_REGINFO:
4444 if (strcmp (name, ".reginfo") != 0
4445 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
4446 return FALSE;
4447 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
4448 break;
4449 case SHT_MIPS_IFACE:
4450 if (strcmp (name, ".MIPS.interfaces") != 0)
4451 return FALSE;
4452 break;
4453 case SHT_MIPS_CONTENT:
4454 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4455 return FALSE;
4456 break;
4457 case SHT_MIPS_OPTIONS:
4458 if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
4459 return FALSE;
4460 break;
4461 case SHT_MIPS_DWARF:
4462 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
4463 return FALSE;
4464 break;
4465 case SHT_MIPS_SYMBOL_LIB:
4466 if (strcmp (name, ".MIPS.symlib") != 0)
4467 return FALSE;
4468 break;
4469 case SHT_MIPS_EVENTS:
4470 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4471 && strncmp (name, ".MIPS.post_rel",
4472 sizeof ".MIPS.post_rel" - 1) != 0)
4473 return FALSE;
4474 break;
4475 default:
4476 return FALSE;
4479 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
4480 return FALSE;
4482 if (flags)
4484 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
4485 (bfd_get_section_flags (abfd,
4486 hdr->bfd_section)
4487 | flags)))
4488 return FALSE;
4491 /* FIXME: We should record sh_info for a .gptab section. */
4493 /* For a .reginfo section, set the gp value in the tdata information
4494 from the contents of this section. We need the gp value while
4495 processing relocs, so we just get it now. The .reginfo section
4496 is not used in the 64-bit MIPS ELF ABI. */
4497 if (hdr->sh_type == SHT_MIPS_REGINFO)
4499 Elf32_External_RegInfo ext;
4500 Elf32_RegInfo s;
4502 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
4503 &ext, 0, sizeof ext))
4504 return FALSE;
4505 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
4506 elf_gp (abfd) = s.ri_gp_value;
4509 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4510 set the gp value based on what we find. We may see both
4511 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4512 they should agree. */
4513 if (hdr->sh_type == SHT_MIPS_OPTIONS)
4515 bfd_byte *contents, *l, *lend;
4517 contents = bfd_malloc (hdr->sh_size);
4518 if (contents == NULL)
4519 return FALSE;
4520 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
4521 0, hdr->sh_size))
4523 free (contents);
4524 return FALSE;
4526 l = contents;
4527 lend = contents + hdr->sh_size;
4528 while (l + sizeof (Elf_External_Options) <= lend)
4530 Elf_Internal_Options intopt;
4532 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4533 &intopt);
4534 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4536 Elf64_Internal_RegInfo intreg;
4538 bfd_mips_elf64_swap_reginfo_in
4539 (abfd,
4540 ((Elf64_External_RegInfo *)
4541 (l + sizeof (Elf_External_Options))),
4542 &intreg);
4543 elf_gp (abfd) = intreg.ri_gp_value;
4545 else if (intopt.kind == ODK_REGINFO)
4547 Elf32_RegInfo intreg;
4549 bfd_mips_elf32_swap_reginfo_in
4550 (abfd,
4551 ((Elf32_External_RegInfo *)
4552 (l + sizeof (Elf_External_Options))),
4553 &intreg);
4554 elf_gp (abfd) = intreg.ri_gp_value;
4556 l += intopt.size;
4558 free (contents);
4561 return TRUE;
4564 /* Set the correct type for a MIPS ELF section. We do this by the
4565 section name, which is a hack, but ought to work. This routine is
4566 used by both the 32-bit and the 64-bit ABI. */
4568 bfd_boolean
4569 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
4571 register const char *name;
4573 name = bfd_get_section_name (abfd, sec);
4575 if (strcmp (name, ".liblist") == 0)
4577 hdr->sh_type = SHT_MIPS_LIBLIST;
4578 hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
4579 /* The sh_link field is set in final_write_processing. */
4581 else if (strcmp (name, ".conflict") == 0)
4582 hdr->sh_type = SHT_MIPS_CONFLICT;
4583 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
4585 hdr->sh_type = SHT_MIPS_GPTAB;
4586 hdr->sh_entsize = sizeof (Elf32_External_gptab);
4587 /* The sh_info field is set in final_write_processing. */
4589 else if (strcmp (name, ".ucode") == 0)
4590 hdr->sh_type = SHT_MIPS_UCODE;
4591 else if (strcmp (name, ".mdebug") == 0)
4593 hdr->sh_type = SHT_MIPS_DEBUG;
4594 /* In a shared object on IRIX 5.3, the .mdebug section has an
4595 entsize of 0. FIXME: Does this matter? */
4596 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
4597 hdr->sh_entsize = 0;
4598 else
4599 hdr->sh_entsize = 1;
4601 else if (strcmp (name, ".reginfo") == 0)
4603 hdr->sh_type = SHT_MIPS_REGINFO;
4604 /* In a shared object on IRIX 5.3, the .reginfo section has an
4605 entsize of 0x18. FIXME: Does this matter? */
4606 if (SGI_COMPAT (abfd))
4608 if ((abfd->flags & DYNAMIC) != 0)
4609 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4610 else
4611 hdr->sh_entsize = 1;
4613 else
4614 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4616 else if (SGI_COMPAT (abfd)
4617 && (strcmp (name, ".hash") == 0
4618 || strcmp (name, ".dynamic") == 0
4619 || strcmp (name, ".dynstr") == 0))
4621 if (SGI_COMPAT (abfd))
4622 hdr->sh_entsize = 0;
4623 #if 0
4624 /* This isn't how the IRIX6 linker behaves. */
4625 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
4626 #endif
4628 else if (strcmp (name, ".got") == 0
4629 || strcmp (name, ".srdata") == 0
4630 || strcmp (name, ".sdata") == 0
4631 || strcmp (name, ".sbss") == 0
4632 || strcmp (name, ".lit4") == 0
4633 || strcmp (name, ".lit8") == 0)
4634 hdr->sh_flags |= SHF_MIPS_GPREL;
4635 else if (strcmp (name, ".MIPS.interfaces") == 0)
4637 hdr->sh_type = SHT_MIPS_IFACE;
4638 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4640 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
4642 hdr->sh_type = SHT_MIPS_CONTENT;
4643 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4644 /* The sh_info field is set in final_write_processing. */
4646 else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4648 hdr->sh_type = SHT_MIPS_OPTIONS;
4649 hdr->sh_entsize = 1;
4650 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4652 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
4653 hdr->sh_type = SHT_MIPS_DWARF;
4654 else if (strcmp (name, ".MIPS.symlib") == 0)
4656 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
4657 /* The sh_link and sh_info fields are set in
4658 final_write_processing. */
4660 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4661 || strncmp (name, ".MIPS.post_rel",
4662 sizeof ".MIPS.post_rel" - 1) == 0)
4664 hdr->sh_type = SHT_MIPS_EVENTS;
4665 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4666 /* The sh_link field is set in final_write_processing. */
4668 else if (strcmp (name, ".msym") == 0)
4670 hdr->sh_type = SHT_MIPS_MSYM;
4671 hdr->sh_flags |= SHF_ALLOC;
4672 hdr->sh_entsize = 8;
4675 /* The generic elf_fake_sections will set up REL_HDR using the default
4676 kind of relocations. We used to set up a second header for the
4677 non-default kind of relocations here, but only NewABI would use
4678 these, and the IRIX ld doesn't like resulting empty RELA sections.
4679 Thus we create those header only on demand now. */
4681 return TRUE;
4684 /* Given a BFD section, try to locate the corresponding ELF section
4685 index. This is used by both the 32-bit and the 64-bit ABI.
4686 Actually, it's not clear to me that the 64-bit ABI supports these,
4687 but for non-PIC objects we will certainly want support for at least
4688 the .scommon section. */
4690 bfd_boolean
4691 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4692 asection *sec, int *retval)
4694 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
4696 *retval = SHN_MIPS_SCOMMON;
4697 return TRUE;
4699 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
4701 *retval = SHN_MIPS_ACOMMON;
4702 return TRUE;
4704 return FALSE;
4707 /* Hook called by the linker routine which adds symbols from an object
4708 file. We must handle the special MIPS section numbers here. */
4710 bfd_boolean
4711 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
4712 const Elf_Internal_Sym *sym, const char **namep,
4713 flagword *flagsp ATTRIBUTE_UNUSED,
4714 asection **secp, bfd_vma *valp)
4716 if (SGI_COMPAT (abfd)
4717 && (abfd->flags & DYNAMIC) != 0
4718 && strcmp (*namep, "_rld_new_interface") == 0)
4720 /* Skip IRIX5 rld entry name. */
4721 *namep = NULL;
4722 return TRUE;
4725 switch (sym->st_shndx)
4727 case SHN_COMMON:
4728 /* Common symbols less than the GP size are automatically
4729 treated as SHN_MIPS_SCOMMON symbols. */
4730 if (sym->st_size > elf_gp_size (abfd)
4731 || IRIX_COMPAT (abfd) == ict_irix6)
4732 break;
4733 /* Fall through. */
4734 case SHN_MIPS_SCOMMON:
4735 *secp = bfd_make_section_old_way (abfd, ".scommon");
4736 (*secp)->flags |= SEC_IS_COMMON;
4737 *valp = sym->st_size;
4738 break;
4740 case SHN_MIPS_TEXT:
4741 /* This section is used in a shared object. */
4742 if (elf_tdata (abfd)->elf_text_section == NULL)
4744 asymbol *elf_text_symbol;
4745 asection *elf_text_section;
4746 bfd_size_type amt = sizeof (asection);
4748 elf_text_section = bfd_zalloc (abfd, amt);
4749 if (elf_text_section == NULL)
4750 return FALSE;
4752 amt = sizeof (asymbol);
4753 elf_text_symbol = bfd_zalloc (abfd, amt);
4754 if (elf_text_symbol == NULL)
4755 return FALSE;
4757 /* Initialize the section. */
4759 elf_tdata (abfd)->elf_text_section = elf_text_section;
4760 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4762 elf_text_section->symbol = elf_text_symbol;
4763 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4765 elf_text_section->name = ".text";
4766 elf_text_section->flags = SEC_NO_FLAGS;
4767 elf_text_section->output_section = NULL;
4768 elf_text_section->owner = abfd;
4769 elf_text_symbol->name = ".text";
4770 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4771 elf_text_symbol->section = elf_text_section;
4773 /* This code used to do *secp = bfd_und_section_ptr if
4774 info->shared. I don't know why, and that doesn't make sense,
4775 so I took it out. */
4776 *secp = elf_tdata (abfd)->elf_text_section;
4777 break;
4779 case SHN_MIPS_ACOMMON:
4780 /* Fall through. XXX Can we treat this as allocated data? */
4781 case SHN_MIPS_DATA:
4782 /* This section is used in a shared object. */
4783 if (elf_tdata (abfd)->elf_data_section == NULL)
4785 asymbol *elf_data_symbol;
4786 asection *elf_data_section;
4787 bfd_size_type amt = sizeof (asection);
4789 elf_data_section = bfd_zalloc (abfd, amt);
4790 if (elf_data_section == NULL)
4791 return FALSE;
4793 amt = sizeof (asymbol);
4794 elf_data_symbol = bfd_zalloc (abfd, amt);
4795 if (elf_data_symbol == NULL)
4796 return FALSE;
4798 /* Initialize the section. */
4800 elf_tdata (abfd)->elf_data_section = elf_data_section;
4801 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4803 elf_data_section->symbol = elf_data_symbol;
4804 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4806 elf_data_section->name = ".data";
4807 elf_data_section->flags = SEC_NO_FLAGS;
4808 elf_data_section->output_section = NULL;
4809 elf_data_section->owner = abfd;
4810 elf_data_symbol->name = ".data";
4811 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4812 elf_data_symbol->section = elf_data_section;
4814 /* This code used to do *secp = bfd_und_section_ptr if
4815 info->shared. I don't know why, and that doesn't make sense,
4816 so I took it out. */
4817 *secp = elf_tdata (abfd)->elf_data_section;
4818 break;
4820 case SHN_MIPS_SUNDEFINED:
4821 *secp = bfd_und_section_ptr;
4822 break;
4825 if (SGI_COMPAT (abfd)
4826 && ! info->shared
4827 && info->hash->creator == abfd->xvec
4828 && strcmp (*namep, "__rld_obj_head") == 0)
4830 struct elf_link_hash_entry *h;
4831 struct bfd_link_hash_entry *bh;
4833 /* Mark __rld_obj_head as dynamic. */
4834 bh = NULL;
4835 if (! (_bfd_generic_link_add_one_symbol
4836 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
4837 get_elf_backend_data (abfd)->collect, &bh)))
4838 return FALSE;
4840 h = (struct elf_link_hash_entry *) bh;
4841 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4842 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4843 h->type = STT_OBJECT;
4845 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4846 return FALSE;
4848 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
4851 /* If this is a mips16 text symbol, add 1 to the value to make it
4852 odd. This will cause something like .word SYM to come up with
4853 the right value when it is loaded into the PC. */
4854 if (sym->st_other == STO_MIPS16)
4855 ++*valp;
4857 return TRUE;
4860 /* This hook function is called before the linker writes out a global
4861 symbol. We mark symbols as small common if appropriate. This is
4862 also where we undo the increment of the value for a mips16 symbol. */
4864 bfd_boolean
4865 _bfd_mips_elf_link_output_symbol_hook
4866 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4867 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
4868 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4870 /* If we see a common symbol, which implies a relocatable link, then
4871 if a symbol was small common in an input file, mark it as small
4872 common in the output file. */
4873 if (sym->st_shndx == SHN_COMMON
4874 && strcmp (input_sec->name, ".scommon") == 0)
4875 sym->st_shndx = SHN_MIPS_SCOMMON;
4877 if (sym->st_other == STO_MIPS16
4878 && (sym->st_value & 1) != 0)
4879 --sym->st_value;
4881 return TRUE;
4884 /* Functions for the dynamic linker. */
4886 /* Create dynamic sections when linking against a dynamic object. */
4888 bfd_boolean
4889 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4891 struct elf_link_hash_entry *h;
4892 struct bfd_link_hash_entry *bh;
4893 flagword flags;
4894 register asection *s;
4895 const char * const *namep;
4897 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4898 | SEC_LINKER_CREATED | SEC_READONLY);
4900 /* Mips ABI requests the .dynamic section to be read only. */
4901 s = bfd_get_section_by_name (abfd, ".dynamic");
4902 if (s != NULL)
4904 if (! bfd_set_section_flags (abfd, s, flags))
4905 return FALSE;
4908 /* We need to create .got section. */
4909 if (! mips_elf_create_got_section (abfd, info, FALSE))
4910 return FALSE;
4912 if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
4913 return FALSE;
4915 /* Create .stub section. */
4916 if (bfd_get_section_by_name (abfd,
4917 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4919 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4920 if (s == NULL
4921 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4922 || ! bfd_set_section_alignment (abfd, s,
4923 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4924 return FALSE;
4927 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4928 && !info->shared
4929 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4931 s = bfd_make_section (abfd, ".rld_map");
4932 if (s == NULL
4933 || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4934 || ! bfd_set_section_alignment (abfd, s,
4935 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4936 return FALSE;
4939 /* On IRIX5, we adjust add some additional symbols and change the
4940 alignments of several sections. There is no ABI documentation
4941 indicating that this is necessary on IRIX6, nor any evidence that
4942 the linker takes such action. */
4943 if (IRIX_COMPAT (abfd) == ict_irix5)
4945 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4947 bh = NULL;
4948 if (! (_bfd_generic_link_add_one_symbol
4949 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
4950 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4951 return FALSE;
4953 h = (struct elf_link_hash_entry *) bh;
4954 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4955 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4956 h->type = STT_SECTION;
4958 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4959 return FALSE;
4962 /* We need to create a .compact_rel section. */
4963 if (SGI_COMPAT (abfd))
4965 if (!mips_elf_create_compact_rel_section (abfd, info))
4966 return FALSE;
4969 /* Change alignments of some sections. */
4970 s = bfd_get_section_by_name (abfd, ".hash");
4971 if (s != NULL)
4972 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4973 s = bfd_get_section_by_name (abfd, ".dynsym");
4974 if (s != NULL)
4975 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4976 s = bfd_get_section_by_name (abfd, ".dynstr");
4977 if (s != NULL)
4978 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4979 s = bfd_get_section_by_name (abfd, ".reginfo");
4980 if (s != NULL)
4981 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4982 s = bfd_get_section_by_name (abfd, ".dynamic");
4983 if (s != NULL)
4984 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4987 if (!info->shared)
4989 const char *name;
4991 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4992 bh = NULL;
4993 if (!(_bfd_generic_link_add_one_symbol
4994 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
4995 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4996 return FALSE;
4998 h = (struct elf_link_hash_entry *) bh;
4999 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5000 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5001 h->type = STT_SECTION;
5003 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
5004 return FALSE;
5006 if (! mips_elf_hash_table (info)->use_rld_obj_head)
5008 /* __rld_map is a four byte word located in the .data section
5009 and is filled in by the rtld to contain a pointer to
5010 the _r_debug structure. Its symbol value will be set in
5011 _bfd_mips_elf_finish_dynamic_symbol. */
5012 s = bfd_get_section_by_name (abfd, ".rld_map");
5013 BFD_ASSERT (s != NULL);
5015 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5016 bh = NULL;
5017 if (!(_bfd_generic_link_add_one_symbol
5018 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
5019 get_elf_backend_data (abfd)->collect, &bh)))
5020 return FALSE;
5022 h = (struct elf_link_hash_entry *) bh;
5023 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5024 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5025 h->type = STT_OBJECT;
5027 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
5028 return FALSE;
5032 return TRUE;
5035 /* Look through the relocs for a section during the first phase, and
5036 allocate space in the global offset table. */
5038 bfd_boolean
5039 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5040 asection *sec, const Elf_Internal_Rela *relocs)
5042 const char *name;
5043 bfd *dynobj;
5044 Elf_Internal_Shdr *symtab_hdr;
5045 struct elf_link_hash_entry **sym_hashes;
5046 struct mips_got_info *g;
5047 size_t extsymoff;
5048 const Elf_Internal_Rela *rel;
5049 const Elf_Internal_Rela *rel_end;
5050 asection *sgot;
5051 asection *sreloc;
5052 const struct elf_backend_data *bed;
5054 if (info->relocatable)
5055 return TRUE;
5057 dynobj = elf_hash_table (info)->dynobj;
5058 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5059 sym_hashes = elf_sym_hashes (abfd);
5060 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5062 /* Check for the mips16 stub sections. */
5064 name = bfd_get_section_name (abfd, sec);
5065 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5067 unsigned long r_symndx;
5069 /* Look at the relocation information to figure out which symbol
5070 this is for. */
5072 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5074 if (r_symndx < extsymoff
5075 || sym_hashes[r_symndx - extsymoff] == NULL)
5077 asection *o;
5079 /* This stub is for a local symbol. This stub will only be
5080 needed if there is some relocation in this BFD, other
5081 than a 16 bit function call, which refers to this symbol. */
5082 for (o = abfd->sections; o != NULL; o = o->next)
5084 Elf_Internal_Rela *sec_relocs;
5085 const Elf_Internal_Rela *r, *rend;
5087 /* We can ignore stub sections when looking for relocs. */
5088 if ((o->flags & SEC_RELOC) == 0
5089 || o->reloc_count == 0
5090 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5091 sizeof FN_STUB - 1) == 0
5092 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5093 sizeof CALL_STUB - 1) == 0
5094 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5095 sizeof CALL_FP_STUB - 1) == 0)
5096 continue;
5098 sec_relocs
5099 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5100 info->keep_memory);
5101 if (sec_relocs == NULL)
5102 return FALSE;
5104 rend = sec_relocs + o->reloc_count;
5105 for (r = sec_relocs; r < rend; r++)
5106 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5107 && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5108 break;
5110 if (elf_section_data (o)->relocs != sec_relocs)
5111 free (sec_relocs);
5113 if (r < rend)
5114 break;
5117 if (o == NULL)
5119 /* There is no non-call reloc for this stub, so we do
5120 not need it. Since this function is called before
5121 the linker maps input sections to output sections, we
5122 can easily discard it by setting the SEC_EXCLUDE
5123 flag. */
5124 sec->flags |= SEC_EXCLUDE;
5125 return TRUE;
5128 /* Record this stub in an array of local symbol stubs for
5129 this BFD. */
5130 if (elf_tdata (abfd)->local_stubs == NULL)
5132 unsigned long symcount;
5133 asection **n;
5134 bfd_size_type amt;
5136 if (elf_bad_symtab (abfd))
5137 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5138 else
5139 symcount = symtab_hdr->sh_info;
5140 amt = symcount * sizeof (asection *);
5141 n = bfd_zalloc (abfd, amt);
5142 if (n == NULL)
5143 return FALSE;
5144 elf_tdata (abfd)->local_stubs = n;
5147 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5149 /* We don't need to set mips16_stubs_seen in this case.
5150 That flag is used to see whether we need to look through
5151 the global symbol table for stubs. We don't need to set
5152 it here, because we just have a local stub. */
5154 else
5156 struct mips_elf_link_hash_entry *h;
5158 h = ((struct mips_elf_link_hash_entry *)
5159 sym_hashes[r_symndx - extsymoff]);
5161 /* H is the symbol this stub is for. */
5163 h->fn_stub = sec;
5164 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5167 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5168 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5170 unsigned long r_symndx;
5171 struct mips_elf_link_hash_entry *h;
5172 asection **loc;
5174 /* Look at the relocation information to figure out which symbol
5175 this is for. */
5177 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5179 if (r_symndx < extsymoff
5180 || sym_hashes[r_symndx - extsymoff] == NULL)
5182 /* This stub was actually built for a static symbol defined
5183 in the same file. We assume that all static symbols in
5184 mips16 code are themselves mips16, so we can simply
5185 discard this stub. Since this function is called before
5186 the linker maps input sections to output sections, we can
5187 easily discard it by setting the SEC_EXCLUDE flag. */
5188 sec->flags |= SEC_EXCLUDE;
5189 return TRUE;
5192 h = ((struct mips_elf_link_hash_entry *)
5193 sym_hashes[r_symndx - extsymoff]);
5195 /* H is the symbol this stub is for. */
5197 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5198 loc = &h->call_fp_stub;
5199 else
5200 loc = &h->call_stub;
5202 /* If we already have an appropriate stub for this function, we
5203 don't need another one, so we can discard this one. Since
5204 this function is called before the linker maps input sections
5205 to output sections, we can easily discard it by setting the
5206 SEC_EXCLUDE flag. We can also discard this section if we
5207 happen to already know that this is a mips16 function; it is
5208 not necessary to check this here, as it is checked later, but
5209 it is slightly faster to check now. */
5210 if (*loc != NULL || h->root.other == STO_MIPS16)
5212 sec->flags |= SEC_EXCLUDE;
5213 return TRUE;
5216 *loc = sec;
5217 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5220 if (dynobj == NULL)
5222 sgot = NULL;
5223 g = NULL;
5225 else
5227 sgot = mips_elf_got_section (dynobj, FALSE);
5228 if (sgot == NULL)
5229 g = NULL;
5230 else
5232 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5233 g = mips_elf_section_data (sgot)->u.got_info;
5234 BFD_ASSERT (g != NULL);
5238 sreloc = NULL;
5239 bed = get_elf_backend_data (abfd);
5240 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5241 for (rel = relocs; rel < rel_end; ++rel)
5243 unsigned long r_symndx;
5244 unsigned int r_type;
5245 struct elf_link_hash_entry *h;
5247 r_symndx = ELF_R_SYM (abfd, rel->r_info);
5248 r_type = ELF_R_TYPE (abfd, rel->r_info);
5250 if (r_symndx < extsymoff)
5251 h = NULL;
5252 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5254 (*_bfd_error_handler)
5255 (_("%s: Malformed reloc detected for section %s"),
5256 bfd_archive_filename (abfd), name);
5257 bfd_set_error (bfd_error_bad_value);
5258 return FALSE;
5260 else
5262 h = sym_hashes[r_symndx - extsymoff];
5264 /* This may be an indirect symbol created because of a version. */
5265 if (h != NULL)
5267 while (h->root.type == bfd_link_hash_indirect)
5268 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5272 /* Some relocs require a global offset table. */
5273 if (dynobj == NULL || sgot == NULL)
5275 switch (r_type)
5277 case R_MIPS_GOT16:
5278 case R_MIPS_CALL16:
5279 case R_MIPS_CALL_HI16:
5280 case R_MIPS_CALL_LO16:
5281 case R_MIPS_GOT_HI16:
5282 case R_MIPS_GOT_LO16:
5283 case R_MIPS_GOT_PAGE:
5284 case R_MIPS_GOT_OFST:
5285 case R_MIPS_GOT_DISP:
5286 if (dynobj == NULL)
5287 elf_hash_table (info)->dynobj = dynobj = abfd;
5288 if (! mips_elf_create_got_section (dynobj, info, FALSE))
5289 return FALSE;
5290 g = mips_elf_got_info (dynobj, &sgot);
5291 break;
5293 case R_MIPS_32:
5294 case R_MIPS_REL32:
5295 case R_MIPS_64:
5296 if (dynobj == NULL
5297 && (info->shared || h != NULL)
5298 && (sec->flags & SEC_ALLOC) != 0)
5299 elf_hash_table (info)->dynobj = dynobj = abfd;
5300 break;
5302 default:
5303 break;
5307 if (!h && (r_type == R_MIPS_CALL_LO16
5308 || r_type == R_MIPS_GOT_LO16
5309 || r_type == R_MIPS_GOT_DISP))
5311 /* We may need a local GOT entry for this relocation. We
5312 don't count R_MIPS_GOT_PAGE because we can estimate the
5313 maximum number of pages needed by looking at the size of
5314 the segment. Similar comments apply to R_MIPS_GOT16 and
5315 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5316 R_MIPS_CALL_HI16 because these are always followed by an
5317 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5318 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5319 rel->r_addend, g))
5320 return FALSE;
5323 switch (r_type)
5325 case R_MIPS_CALL16:
5326 if (h == NULL)
5328 (*_bfd_error_handler)
5329 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5330 bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5331 bfd_set_error (bfd_error_bad_value);
5332 return FALSE;
5334 /* Fall through. */
5336 case R_MIPS_CALL_HI16:
5337 case R_MIPS_CALL_LO16:
5338 if (h != NULL)
5340 /* This symbol requires a global offset table entry. */
5341 if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5342 return FALSE;
5344 /* We need a stub, not a plt entry for the undefined
5345 function. But we record it as if it needs plt. See
5346 elf_adjust_dynamic_symbol in elflink.h. */
5347 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5348 h->type = STT_FUNC;
5350 break;
5352 case R_MIPS_GOT_PAGE:
5353 /* If this is a global, overridable symbol, GOT_PAGE will
5354 decay to GOT_DISP, so we'll need a GOT entry for it. */
5355 if (h == NULL)
5356 break;
5357 else
5359 struct mips_elf_link_hash_entry *hmips =
5360 (struct mips_elf_link_hash_entry *) h;
5362 while (hmips->root.root.type == bfd_link_hash_indirect
5363 || hmips->root.root.type == bfd_link_hash_warning)
5364 hmips = (struct mips_elf_link_hash_entry *)
5365 hmips->root.root.u.i.link;
5367 if ((hmips->root.root.type == bfd_link_hash_defined
5368 || hmips->root.root.type == bfd_link_hash_defweak)
5369 && hmips->root.root.u.def.section
5370 && ! (info->shared && ! info->symbolic
5371 && ! (hmips->root.elf_link_hash_flags
5372 & ELF_LINK_FORCED_LOCAL))
5373 /* If we've encountered any other relocation
5374 referencing the symbol, we'll have marked it as
5375 dynamic, and, even though we might be able to get
5376 rid of the GOT entry should we know for sure all
5377 previous relocations were GOT_PAGE ones, at this
5378 point we can't tell, so just keep using the
5379 symbol as dynamic. This is very important in the
5380 multi-got case, since we don't decide whether to
5381 decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5382 the symbol is dynamic, we'll need a GOT entry for
5383 every GOT in which the symbol is referenced with
5384 a GOT_PAGE relocation. */
5385 && hmips->root.dynindx == -1)
5386 break;
5388 /* Fall through. */
5390 case R_MIPS_GOT16:
5391 case R_MIPS_GOT_HI16:
5392 case R_MIPS_GOT_LO16:
5393 case R_MIPS_GOT_DISP:
5394 /* This symbol requires a global offset table entry. */
5395 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
5396 return FALSE;
5397 break;
5399 case R_MIPS_32:
5400 case R_MIPS_REL32:
5401 case R_MIPS_64:
5402 if ((info->shared || h != NULL)
5403 && (sec->flags & SEC_ALLOC) != 0)
5405 if (sreloc == NULL)
5407 sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
5408 if (sreloc == NULL)
5409 return FALSE;
5411 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5412 if (info->shared)
5414 /* When creating a shared object, we must copy these
5415 reloc types into the output file as R_MIPS_REL32
5416 relocs. We make room for this reloc in the
5417 .rel.dyn reloc section. */
5418 mips_elf_allocate_dynamic_relocations (dynobj, 1);
5419 if ((sec->flags & MIPS_READONLY_SECTION)
5420 == MIPS_READONLY_SECTION)
5421 /* We tell the dynamic linker that there are
5422 relocations against the text segment. */
5423 info->flags |= DF_TEXTREL;
5425 else
5427 struct mips_elf_link_hash_entry *hmips;
5429 /* We only need to copy this reloc if the symbol is
5430 defined in a dynamic object. */
5431 hmips = (struct mips_elf_link_hash_entry *) h;
5432 ++hmips->possibly_dynamic_relocs;
5433 if ((sec->flags & MIPS_READONLY_SECTION)
5434 == MIPS_READONLY_SECTION)
5435 /* We need it to tell the dynamic linker if there
5436 are relocations against the text segment. */
5437 hmips->readonly_reloc = TRUE;
5440 /* Even though we don't directly need a GOT entry for
5441 this symbol, a symbol must have a dynamic symbol
5442 table index greater that DT_MIPS_GOTSYM if there are
5443 dynamic relocations against it. */
5444 if (h != NULL)
5446 if (dynobj == NULL)
5447 elf_hash_table (info)->dynobj = dynobj = abfd;
5448 if (! mips_elf_create_got_section (dynobj, info, TRUE))
5449 return FALSE;
5450 g = mips_elf_got_info (dynobj, &sgot);
5451 if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5452 return FALSE;
5456 if (SGI_COMPAT (abfd))
5457 mips_elf_hash_table (info)->compact_rel_size +=
5458 sizeof (Elf32_External_crinfo);
5459 break;
5461 case R_MIPS_26:
5462 case R_MIPS_GPREL16:
5463 case R_MIPS_LITERAL:
5464 case R_MIPS_GPREL32:
5465 if (SGI_COMPAT (abfd))
5466 mips_elf_hash_table (info)->compact_rel_size +=
5467 sizeof (Elf32_External_crinfo);
5468 break;
5470 /* This relocation describes the C++ object vtable hierarchy.
5471 Reconstruct it for later use during GC. */
5472 case R_MIPS_GNU_VTINHERIT:
5473 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5474 return FALSE;
5475 break;
5477 /* This relocation describes which C++ vtable entries are actually
5478 used. Record for later use during GC. */
5479 case R_MIPS_GNU_VTENTRY:
5480 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5481 return FALSE;
5482 break;
5484 default:
5485 break;
5488 /* We must not create a stub for a symbol that has relocations
5489 related to taking the function's address. */
5490 switch (r_type)
5492 default:
5493 if (h != NULL)
5495 struct mips_elf_link_hash_entry *mh;
5497 mh = (struct mips_elf_link_hash_entry *) h;
5498 mh->no_fn_stub = TRUE;
5500 break;
5501 case R_MIPS_CALL16:
5502 case R_MIPS_CALL_HI16:
5503 case R_MIPS_CALL_LO16:
5504 case R_MIPS_JALR:
5505 break;
5508 /* If this reloc is not a 16 bit call, and it has a global
5509 symbol, then we will need the fn_stub if there is one.
5510 References from a stub section do not count. */
5511 if (h != NULL
5512 && r_type != R_MIPS16_26
5513 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5514 sizeof FN_STUB - 1) != 0
5515 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5516 sizeof CALL_STUB - 1) != 0
5517 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5518 sizeof CALL_FP_STUB - 1) != 0)
5520 struct mips_elf_link_hash_entry *mh;
5522 mh = (struct mips_elf_link_hash_entry *) h;
5523 mh->need_fn_stub = TRUE;
5527 return TRUE;
5530 bfd_boolean
5531 _bfd_mips_relax_section (bfd *abfd, asection *sec,
5532 struct bfd_link_info *link_info,
5533 bfd_boolean *again)
5535 Elf_Internal_Rela *internal_relocs;
5536 Elf_Internal_Rela *irel, *irelend;
5537 Elf_Internal_Shdr *symtab_hdr;
5538 bfd_byte *contents = NULL;
5539 bfd_byte *free_contents = NULL;
5540 size_t extsymoff;
5541 bfd_boolean changed_contents = FALSE;
5542 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5543 Elf_Internal_Sym *isymbuf = NULL;
5545 /* We are not currently changing any sizes, so only one pass. */
5546 *again = FALSE;
5548 if (link_info->relocatable)
5549 return TRUE;
5551 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
5552 link_info->keep_memory);
5553 if (internal_relocs == NULL)
5554 return TRUE;
5556 irelend = internal_relocs + sec->reloc_count
5557 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5558 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5559 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5561 for (irel = internal_relocs; irel < irelend; irel++)
5563 bfd_vma symval;
5564 bfd_signed_vma sym_offset;
5565 unsigned int r_type;
5566 unsigned long r_symndx;
5567 asection *sym_sec;
5568 unsigned long instruction;
5570 /* Turn jalr into bgezal, and jr into beq, if they're marked
5571 with a JALR relocation, that indicate where they jump to.
5572 This saves some pipeline bubbles. */
5573 r_type = ELF_R_TYPE (abfd, irel->r_info);
5574 if (r_type != R_MIPS_JALR)
5575 continue;
5577 r_symndx = ELF_R_SYM (abfd, irel->r_info);
5578 /* Compute the address of the jump target. */
5579 if (r_symndx >= extsymoff)
5581 struct mips_elf_link_hash_entry *h
5582 = ((struct mips_elf_link_hash_entry *)
5583 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5585 while (h->root.root.type == bfd_link_hash_indirect
5586 || h->root.root.type == bfd_link_hash_warning)
5587 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5589 /* If a symbol is undefined, or if it may be overridden,
5590 skip it. */
5591 if (! ((h->root.root.type == bfd_link_hash_defined
5592 || h->root.root.type == bfd_link_hash_defweak)
5593 && h->root.root.u.def.section)
5594 || (link_info->shared && ! link_info->symbolic
5595 && ! (h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)))
5596 continue;
5598 sym_sec = h->root.root.u.def.section;
5599 if (sym_sec->output_section)
5600 symval = (h->root.root.u.def.value
5601 + sym_sec->output_section->vma
5602 + sym_sec->output_offset);
5603 else
5604 symval = h->root.root.u.def.value;
5606 else
5608 Elf_Internal_Sym *isym;
5610 /* Read this BFD's symbols if we haven't done so already. */
5611 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5613 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5614 if (isymbuf == NULL)
5615 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5616 symtab_hdr->sh_info, 0,
5617 NULL, NULL, NULL);
5618 if (isymbuf == NULL)
5619 goto relax_return;
5622 isym = isymbuf + r_symndx;
5623 if (isym->st_shndx == SHN_UNDEF)
5624 continue;
5625 else if (isym->st_shndx == SHN_ABS)
5626 sym_sec = bfd_abs_section_ptr;
5627 else if (isym->st_shndx == SHN_COMMON)
5628 sym_sec = bfd_com_section_ptr;
5629 else
5630 sym_sec
5631 = bfd_section_from_elf_index (abfd, isym->st_shndx);
5632 symval = isym->st_value
5633 + sym_sec->output_section->vma
5634 + sym_sec->output_offset;
5637 /* Compute branch offset, from delay slot of the jump to the
5638 branch target. */
5639 sym_offset = (symval + irel->r_addend)
5640 - (sec_start + irel->r_offset + 4);
5642 /* Branch offset must be properly aligned. */
5643 if ((sym_offset & 3) != 0)
5644 continue;
5646 sym_offset >>= 2;
5648 /* Check that it's in range. */
5649 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5650 continue;
5652 /* Get the section contents if we haven't done so already. */
5653 if (contents == NULL)
5655 /* Get cached copy if it exists. */
5656 if (elf_section_data (sec)->this_hdr.contents != NULL)
5657 contents = elf_section_data (sec)->this_hdr.contents;
5658 else
5660 contents = bfd_malloc (sec->_raw_size);
5661 if (contents == NULL)
5662 goto relax_return;
5664 free_contents = contents;
5665 if (! bfd_get_section_contents (abfd, sec, contents,
5666 0, sec->_raw_size))
5667 goto relax_return;
5671 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5673 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5674 if ((instruction & 0xfc1fffff) == 0x0000f809)
5675 instruction = 0x04110000;
5676 /* If it was jr <reg>, turn it into b <target>. */
5677 else if ((instruction & 0xfc1fffff) == 0x00000008)
5678 instruction = 0x10000000;
5679 else
5680 continue;
5682 instruction |= (sym_offset & 0xffff);
5683 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5684 changed_contents = TRUE;
5687 if (contents != NULL
5688 && elf_section_data (sec)->this_hdr.contents != contents)
5690 if (!changed_contents && !link_info->keep_memory)
5691 free (contents);
5692 else
5694 /* Cache the section contents for elf_link_input_bfd. */
5695 elf_section_data (sec)->this_hdr.contents = contents;
5698 return TRUE;
5700 relax_return:
5701 if (free_contents != NULL)
5702 free (free_contents);
5703 return FALSE;
5706 /* Adjust a symbol defined by a dynamic object and referenced by a
5707 regular object. The current definition is in some section of the
5708 dynamic object, but we're not including those sections. We have to
5709 change the definition to something the rest of the link can
5710 understand. */
5712 bfd_boolean
5713 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5714 struct elf_link_hash_entry *h)
5716 bfd *dynobj;
5717 struct mips_elf_link_hash_entry *hmips;
5718 asection *s;
5720 dynobj = elf_hash_table (info)->dynobj;
5722 /* Make sure we know what is going on here. */
5723 BFD_ASSERT (dynobj != NULL
5724 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
5725 || h->weakdef != NULL
5726 || ((h->elf_link_hash_flags
5727 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5728 && (h->elf_link_hash_flags
5729 & ELF_LINK_HASH_REF_REGULAR) != 0
5730 && (h->elf_link_hash_flags
5731 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
5733 /* If this symbol is defined in a dynamic object, we need to copy
5734 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5735 file. */
5736 hmips = (struct mips_elf_link_hash_entry *) h;
5737 if (! info->relocatable
5738 && hmips->possibly_dynamic_relocs != 0
5739 && (h->root.type == bfd_link_hash_defweak
5740 || (h->elf_link_hash_flags
5741 & ELF_LINK_HASH_DEF_REGULAR) == 0))
5743 mips_elf_allocate_dynamic_relocations (dynobj,
5744 hmips->possibly_dynamic_relocs);
5745 if (hmips->readonly_reloc)
5746 /* We tell the dynamic linker that there are relocations
5747 against the text segment. */
5748 info->flags |= DF_TEXTREL;
5751 /* For a function, create a stub, if allowed. */
5752 if (! hmips->no_fn_stub
5753 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
5755 if (! elf_hash_table (info)->dynamic_sections_created)
5756 return TRUE;
5758 /* If this symbol is not defined in a regular file, then set
5759 the symbol to the stub location. This is required to make
5760 function pointers compare as equal between the normal
5761 executable and the shared library. */
5762 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5764 /* We need .stub section. */
5765 s = bfd_get_section_by_name (dynobj,
5766 MIPS_ELF_STUB_SECTION_NAME (dynobj));
5767 BFD_ASSERT (s != NULL);
5769 h->root.u.def.section = s;
5770 h->root.u.def.value = s->_raw_size;
5772 /* XXX Write this stub address somewhere. */
5773 h->plt.offset = s->_raw_size;
5775 /* Make room for this stub code. */
5776 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
5778 /* The last half word of the stub will be filled with the index
5779 of this symbol in .dynsym section. */
5780 return TRUE;
5783 else if ((h->type == STT_FUNC)
5784 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
5786 /* This will set the entry for this symbol in the GOT to 0, and
5787 the dynamic linker will take care of this. */
5788 h->root.u.def.value = 0;
5789 return TRUE;
5792 /* If this is a weak symbol, and there is a real definition, the
5793 processor independent code will have arranged for us to see the
5794 real definition first, and we can just use the same value. */
5795 if (h->weakdef != NULL)
5797 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5798 || h->weakdef->root.type == bfd_link_hash_defweak);
5799 h->root.u.def.section = h->weakdef->root.u.def.section;
5800 h->root.u.def.value = h->weakdef->root.u.def.value;
5801 return TRUE;
5804 /* This is a reference to a symbol defined by a dynamic object which
5805 is not a function. */
5807 return TRUE;
5810 /* This function is called after all the input files have been read,
5811 and the input sections have been assigned to output sections. We
5812 check for any mips16 stub sections that we can discard. */
5814 bfd_boolean
5815 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
5816 struct bfd_link_info *info)
5818 asection *ri;
5820 bfd *dynobj;
5821 asection *s;
5822 struct mips_got_info *g;
5823 int i;
5824 bfd_size_type loadable_size = 0;
5825 bfd_size_type local_gotno;
5826 bfd *sub;
5828 /* The .reginfo section has a fixed size. */
5829 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5830 if (ri != NULL)
5831 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
5833 if (! (info->relocatable
5834 || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5835 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5836 mips_elf_check_mips16_stubs, NULL);
5838 dynobj = elf_hash_table (info)->dynobj;
5839 if (dynobj == NULL)
5840 /* Relocatable links don't have it. */
5841 return TRUE;
5843 g = mips_elf_got_info (dynobj, &s);
5844 if (s == NULL)
5845 return TRUE;
5847 /* Calculate the total loadable size of the output. That
5848 will give us the maximum number of GOT_PAGE entries
5849 required. */
5850 for (sub = info->input_bfds; sub; sub = sub->link_next)
5852 asection *subsection;
5854 for (subsection = sub->sections;
5855 subsection;
5856 subsection = subsection->next)
5858 if ((subsection->flags & SEC_ALLOC) == 0)
5859 continue;
5860 loadable_size += ((subsection->_raw_size + 0xf)
5861 &~ (bfd_size_type) 0xf);
5865 /* There has to be a global GOT entry for every symbol with
5866 a dynamic symbol table index of DT_MIPS_GOTSYM or
5867 higher. Therefore, it make sense to put those symbols
5868 that need GOT entries at the end of the symbol table. We
5869 do that here. */
5870 if (! mips_elf_sort_hash_table (info, 1))
5871 return FALSE;
5873 if (g->global_gotsym != NULL)
5874 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5875 else
5876 /* If there are no global symbols, or none requiring
5877 relocations, then GLOBAL_GOTSYM will be NULL. */
5878 i = 0;
5880 /* In the worst case, we'll get one stub per dynamic symbol, plus
5881 one to account for the dummy entry at the end required by IRIX
5882 rld. */
5883 loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5885 /* Assume there are two loadable segments consisting of
5886 contiguous sections. Is 5 enough? */
5887 local_gotno = (loadable_size >> 16) + 5;
5889 g->local_gotno += local_gotno;
5890 s->_raw_size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5892 g->global_gotno = i;
5893 s->_raw_size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5895 if (s->_raw_size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5896 && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5897 return FALSE;
5899 return TRUE;
5902 /* Set the sizes of the dynamic sections. */
5904 bfd_boolean
5905 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
5906 struct bfd_link_info *info)
5908 bfd *dynobj;
5909 asection *s;
5910 bfd_boolean reltext;
5912 dynobj = elf_hash_table (info)->dynobj;
5913 BFD_ASSERT (dynobj != NULL);
5915 if (elf_hash_table (info)->dynamic_sections_created)
5917 /* Set the contents of the .interp section to the interpreter. */
5918 if (info->executable)
5920 s = bfd_get_section_by_name (dynobj, ".interp");
5921 BFD_ASSERT (s != NULL);
5922 s->_raw_size
5923 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5924 s->contents
5925 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5929 /* The check_relocs and adjust_dynamic_symbol entry points have
5930 determined the sizes of the various dynamic sections. Allocate
5931 memory for them. */
5932 reltext = FALSE;
5933 for (s = dynobj->sections; s != NULL; s = s->next)
5935 const char *name;
5936 bfd_boolean strip;
5938 /* It's OK to base decisions on the section name, because none
5939 of the dynobj section names depend upon the input files. */
5940 name = bfd_get_section_name (dynobj, s);
5942 if ((s->flags & SEC_LINKER_CREATED) == 0)
5943 continue;
5945 strip = FALSE;
5947 if (strncmp (name, ".rel", 4) == 0)
5949 if (s->_raw_size == 0)
5951 /* We only strip the section if the output section name
5952 has the same name. Otherwise, there might be several
5953 input sections for this output section. FIXME: This
5954 code is probably not needed these days anyhow, since
5955 the linker now does not create empty output sections. */
5956 if (s->output_section != NULL
5957 && strcmp (name,
5958 bfd_get_section_name (s->output_section->owner,
5959 s->output_section)) == 0)
5960 strip = TRUE;
5962 else
5964 const char *outname;
5965 asection *target;
5967 /* If this relocation section applies to a read only
5968 section, then we probably need a DT_TEXTREL entry.
5969 If the relocation section is .rel.dyn, we always
5970 assert a DT_TEXTREL entry rather than testing whether
5971 there exists a relocation to a read only section or
5972 not. */
5973 outname = bfd_get_section_name (output_bfd,
5974 s->output_section);
5975 target = bfd_get_section_by_name (output_bfd, outname + 4);
5976 if ((target != NULL
5977 && (target->flags & SEC_READONLY) != 0
5978 && (target->flags & SEC_ALLOC) != 0)
5979 || strcmp (outname, ".rel.dyn") == 0)
5980 reltext = TRUE;
5982 /* We use the reloc_count field as a counter if we need
5983 to copy relocs into the output file. */
5984 if (strcmp (name, ".rel.dyn") != 0)
5985 s->reloc_count = 0;
5987 /* If combreloc is enabled, elf_link_sort_relocs() will
5988 sort relocations, but in a different way than we do,
5989 and before we're done creating relocations. Also, it
5990 will move them around between input sections'
5991 relocation's contents, so our sorting would be
5992 broken, so don't let it run. */
5993 info->combreloc = 0;
5996 else if (strncmp (name, ".got", 4) == 0)
5998 /* _bfd_mips_elf_always_size_sections() has already done
5999 most of the work, but some symbols may have been mapped
6000 to versions that we must now resolve in the got_entries
6001 hash tables. */
6002 struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
6003 struct mips_got_info *g = gg;
6004 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
6005 unsigned int needed_relocs = 0;
6007 if (gg->next)
6009 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6010 set_got_offset_arg.info = info;
6012 mips_elf_resolve_final_got_entries (gg);
6013 for (g = gg->next; g && g->next != gg; g = g->next)
6015 unsigned int save_assign;
6017 mips_elf_resolve_final_got_entries (g);
6019 /* Assign offsets to global GOT entries. */
6020 save_assign = g->assigned_gotno;
6021 g->assigned_gotno = g->local_gotno;
6022 set_got_offset_arg.g = g;
6023 set_got_offset_arg.needed_relocs = 0;
6024 htab_traverse (g->got_entries,
6025 mips_elf_set_global_got_offset,
6026 &set_got_offset_arg);
6027 needed_relocs += set_got_offset_arg.needed_relocs;
6028 BFD_ASSERT (g->assigned_gotno - g->local_gotno
6029 <= g->global_gotno);
6031 g->assigned_gotno = save_assign;
6032 if (info->shared)
6034 needed_relocs += g->local_gotno - g->assigned_gotno;
6035 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6036 + g->next->global_gotno
6037 + MIPS_RESERVED_GOTNO);
6041 if (needed_relocs)
6042 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6045 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6047 /* IRIX rld assumes that the function stub isn't at the end
6048 of .text section. So put a dummy. XXX */
6049 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
6051 else if (! info->shared
6052 && ! mips_elf_hash_table (info)->use_rld_obj_head
6053 && strncmp (name, ".rld_map", 8) == 0)
6055 /* We add a room for __rld_map. It will be filled in by the
6056 rtld to contain a pointer to the _r_debug structure. */
6057 s->_raw_size += 4;
6059 else if (SGI_COMPAT (output_bfd)
6060 && strncmp (name, ".compact_rel", 12) == 0)
6061 s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
6062 else if (strncmp (name, ".init", 5) != 0)
6064 /* It's not one of our sections, so don't allocate space. */
6065 continue;
6068 if (strip)
6070 _bfd_strip_section_from_output (info, s);
6071 continue;
6074 /* Allocate memory for the section contents. */
6075 s->contents = bfd_zalloc (dynobj, s->_raw_size);
6076 if (s->contents == NULL && s->_raw_size != 0)
6078 bfd_set_error (bfd_error_no_memory);
6079 return FALSE;
6083 if (elf_hash_table (info)->dynamic_sections_created)
6085 /* Add some entries to the .dynamic section. We fill in the
6086 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6087 must add the entries now so that we get the correct size for
6088 the .dynamic section. The DT_DEBUG entry is filled in by the
6089 dynamic linker and used by the debugger. */
6090 if (! info->shared)
6092 /* SGI object has the equivalence of DT_DEBUG in the
6093 DT_MIPS_RLD_MAP entry. */
6094 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6095 return FALSE;
6096 if (!SGI_COMPAT (output_bfd))
6098 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6099 return FALSE;
6102 else
6104 /* Shared libraries on traditional mips have DT_DEBUG. */
6105 if (!SGI_COMPAT (output_bfd))
6107 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6108 return FALSE;
6112 if (reltext && SGI_COMPAT (output_bfd))
6113 info->flags |= DF_TEXTREL;
6115 if ((info->flags & DF_TEXTREL) != 0)
6117 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6118 return FALSE;
6121 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6122 return FALSE;
6124 if (mips_elf_rel_dyn_section (dynobj, FALSE))
6126 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6127 return FALSE;
6129 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6130 return FALSE;
6132 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6133 return FALSE;
6136 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6137 return FALSE;
6139 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6140 return FALSE;
6142 #if 0
6143 /* Time stamps in executable files are a bad idea. */
6144 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
6145 return FALSE;
6146 #endif
6148 #if 0 /* FIXME */
6149 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
6150 return FALSE;
6151 #endif
6153 #if 0 /* FIXME */
6154 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
6155 return FALSE;
6156 #endif
6158 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6159 return FALSE;
6161 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6162 return FALSE;
6164 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6165 return FALSE;
6167 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6168 return FALSE;
6170 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6171 return FALSE;
6173 if (IRIX_COMPAT (dynobj) == ict_irix5
6174 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6175 return FALSE;
6177 if (IRIX_COMPAT (dynobj) == ict_irix6
6178 && (bfd_get_section_by_name
6179 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6180 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6181 return FALSE;
6184 return TRUE;
6187 /* Relocate a MIPS ELF section. */
6189 bfd_boolean
6190 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
6191 bfd *input_bfd, asection *input_section,
6192 bfd_byte *contents, Elf_Internal_Rela *relocs,
6193 Elf_Internal_Sym *local_syms,
6194 asection **local_sections)
6196 Elf_Internal_Rela *rel;
6197 const Elf_Internal_Rela *relend;
6198 bfd_vma addend = 0;
6199 bfd_boolean use_saved_addend_p = FALSE;
6200 const struct elf_backend_data *bed;
6202 bed = get_elf_backend_data (output_bfd);
6203 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6204 for (rel = relocs; rel < relend; ++rel)
6206 const char *name;
6207 bfd_vma value;
6208 reloc_howto_type *howto;
6209 bfd_boolean require_jalx;
6210 /* TRUE if the relocation is a RELA relocation, rather than a
6211 REL relocation. */
6212 bfd_boolean rela_relocation_p = TRUE;
6213 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6214 const char *msg;
6216 /* Find the relocation howto for this relocation. */
6217 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6219 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6220 64-bit code, but make sure all their addresses are in the
6221 lowermost or uppermost 32-bit section of the 64-bit address
6222 space. Thus, when they use an R_MIPS_64 they mean what is
6223 usually meant by R_MIPS_32, with the exception that the
6224 stored value is sign-extended to 64 bits. */
6225 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6227 /* On big-endian systems, we need to lie about the position
6228 of the reloc. */
6229 if (bfd_big_endian (input_bfd))
6230 rel->r_offset += 4;
6232 else
6233 /* NewABI defaults to RELA relocations. */
6234 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6235 NEWABI_P (input_bfd)
6236 && (MIPS_RELOC_RELA_P
6237 (input_bfd, input_section,
6238 rel - relocs)));
6240 if (!use_saved_addend_p)
6242 Elf_Internal_Shdr *rel_hdr;
6244 /* If these relocations were originally of the REL variety,
6245 we must pull the addend out of the field that will be
6246 relocated. Otherwise, we simply use the contents of the
6247 RELA relocation. To determine which flavor or relocation
6248 this is, we depend on the fact that the INPUT_SECTION's
6249 REL_HDR is read before its REL_HDR2. */
6250 rel_hdr = &elf_section_data (input_section)->rel_hdr;
6251 if ((size_t) (rel - relocs)
6252 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6253 rel_hdr = elf_section_data (input_section)->rel_hdr2;
6254 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6256 /* Note that this is a REL relocation. */
6257 rela_relocation_p = FALSE;
6259 /* Get the addend, which is stored in the input file. */
6260 addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6261 contents);
6262 addend &= howto->src_mask;
6264 /* For some kinds of relocations, the ADDEND is a
6265 combination of the addend stored in two different
6266 relocations. */
6267 if (r_type == R_MIPS_HI16
6268 || r_type == R_MIPS_GNU_REL_HI16
6269 || (r_type == R_MIPS_GOT16
6270 && mips_elf_local_relocation_p (input_bfd, rel,
6271 local_sections, FALSE)))
6273 bfd_vma l;
6274 const Elf_Internal_Rela *lo16_relocation;
6275 reloc_howto_type *lo16_howto;
6276 unsigned int lo;
6278 /* The combined value is the sum of the HI16 addend,
6279 left-shifted by sixteen bits, and the LO16
6280 addend, sign extended. (Usually, the code does
6281 a `lui' of the HI16 value, and then an `addiu' of
6282 the LO16 value.)
6284 Scan ahead to find a matching LO16 relocation. */
6285 if (r_type == R_MIPS_GNU_REL_HI16)
6286 lo = R_MIPS_GNU_REL_LO16;
6287 else
6288 lo = R_MIPS_LO16;
6289 lo16_relocation = mips_elf_next_relocation (input_bfd, lo,
6290 rel, relend);
6291 if (lo16_relocation == NULL)
6292 return FALSE;
6294 /* Obtain the addend kept there. */
6295 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, lo, FALSE);
6296 l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6297 input_bfd, contents);
6298 l &= lo16_howto->src_mask;
6299 l <<= lo16_howto->rightshift;
6300 l = _bfd_mips_elf_sign_extend (l, 16);
6302 addend <<= 16;
6304 /* Compute the combined addend. */
6305 addend += l;
6307 /* If PC-relative, subtract the difference between the
6308 address of the LO part of the reloc and the address of
6309 the HI part. The relocation is relative to the LO
6310 part, but mips_elf_calculate_relocation() doesn't
6311 know its address or the difference from the HI part, so
6312 we subtract that difference here. See also the
6313 comment in mips_elf_calculate_relocation(). */
6314 if (r_type == R_MIPS_GNU_REL_HI16)
6315 addend -= (lo16_relocation->r_offset - rel->r_offset);
6317 else if (r_type == R_MIPS16_GPREL)
6319 /* The addend is scrambled in the object file. See
6320 mips_elf_perform_relocation for details on the
6321 format. */
6322 addend = (((addend & 0x1f0000) >> 5)
6323 | ((addend & 0x7e00000) >> 16)
6324 | (addend & 0x1f));
6326 else
6327 addend <<= howto->rightshift;
6329 else
6330 addend = rel->r_addend;
6333 if (info->relocatable)
6335 Elf_Internal_Sym *sym;
6336 unsigned long r_symndx;
6338 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
6339 && bfd_big_endian (input_bfd))
6340 rel->r_offset -= 4;
6342 /* Since we're just relocating, all we need to do is copy
6343 the relocations back out to the object file, unless
6344 they're against a section symbol, in which case we need
6345 to adjust by the section offset, or unless they're GP
6346 relative in which case we need to adjust by the amount
6347 that we're adjusting GP in this relocatable object. */
6349 if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6350 FALSE))
6351 /* There's nothing to do for non-local relocations. */
6352 continue;
6354 if (r_type == R_MIPS16_GPREL
6355 || r_type == R_MIPS_GPREL16
6356 || r_type == R_MIPS_GPREL32
6357 || r_type == R_MIPS_LITERAL)
6358 addend -= (_bfd_get_gp_value (output_bfd)
6359 - _bfd_get_gp_value (input_bfd));
6361 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6362 sym = local_syms + r_symndx;
6363 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6364 /* Adjust the addend appropriately. */
6365 addend += local_sections[r_symndx]->output_offset;
6367 if (rela_relocation_p)
6368 /* If this is a RELA relocation, just update the addend. */
6369 rel->r_addend = addend;
6370 else
6372 if (r_type == R_MIPS_HI16
6373 || r_type == R_MIPS_GOT16
6374 || r_type == R_MIPS_GNU_REL_HI16)
6375 addend = mips_elf_high (addend);
6376 else if (r_type == R_MIPS_HIGHER)
6377 addend = mips_elf_higher (addend);
6378 else if (r_type == R_MIPS_HIGHEST)
6379 addend = mips_elf_highest (addend);
6380 else
6381 addend >>= howto->rightshift;
6383 /* We use the source mask, rather than the destination
6384 mask because the place to which we are writing will be
6385 source of the addend in the final link. */
6386 addend &= howto->src_mask;
6388 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6389 /* See the comment above about using R_MIPS_64 in the 32-bit
6390 ABI. Here, we need to update the addend. It would be
6391 possible to get away with just using the R_MIPS_32 reloc
6392 but for endianness. */
6394 bfd_vma sign_bits;
6395 bfd_vma low_bits;
6396 bfd_vma high_bits;
6398 if (addend & ((bfd_vma) 1 << 31))
6399 #ifdef BFD64
6400 sign_bits = ((bfd_vma) 1 << 32) - 1;
6401 #else
6402 sign_bits = -1;
6403 #endif
6404 else
6405 sign_bits = 0;
6407 /* If we don't know that we have a 64-bit type,
6408 do two separate stores. */
6409 if (bfd_big_endian (input_bfd))
6411 /* Store the sign-bits (which are most significant)
6412 first. */
6413 low_bits = sign_bits;
6414 high_bits = addend;
6416 else
6418 low_bits = addend;
6419 high_bits = sign_bits;
6421 bfd_put_32 (input_bfd, low_bits,
6422 contents + rel->r_offset);
6423 bfd_put_32 (input_bfd, high_bits,
6424 contents + rel->r_offset + 4);
6425 continue;
6428 if (! mips_elf_perform_relocation (info, howto, rel, addend,
6429 input_bfd, input_section,
6430 contents, FALSE))
6431 return FALSE;
6434 /* Go on to the next relocation. */
6435 continue;
6438 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6439 relocations for the same offset. In that case we are
6440 supposed to treat the output of each relocation as the addend
6441 for the next. */
6442 if (rel + 1 < relend
6443 && rel->r_offset == rel[1].r_offset
6444 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
6445 use_saved_addend_p = TRUE;
6446 else
6447 use_saved_addend_p = FALSE;
6449 /* Figure out what value we are supposed to relocate. */
6450 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6451 input_section, info, rel,
6452 addend, howto, local_syms,
6453 local_sections, &value,
6454 &name, &require_jalx,
6455 use_saved_addend_p))
6457 case bfd_reloc_continue:
6458 /* There's nothing to do. */
6459 continue;
6461 case bfd_reloc_undefined:
6462 /* mips_elf_calculate_relocation already called the
6463 undefined_symbol callback. There's no real point in
6464 trying to perform the relocation at this point, so we
6465 just skip ahead to the next relocation. */
6466 continue;
6468 case bfd_reloc_notsupported:
6469 msg = _("internal error: unsupported relocation error");
6470 info->callbacks->warning
6471 (info, msg, name, input_bfd, input_section, rel->r_offset);
6472 return FALSE;
6474 case bfd_reloc_overflow:
6475 if (use_saved_addend_p)
6476 /* Ignore overflow until we reach the last relocation for
6477 a given location. */
6479 else
6481 BFD_ASSERT (name != NULL);
6482 if (! ((*info->callbacks->reloc_overflow)
6483 (info, name, howto->name, 0,
6484 input_bfd, input_section, rel->r_offset)))
6485 return FALSE;
6487 break;
6489 case bfd_reloc_ok:
6490 break;
6492 default:
6493 abort ();
6494 break;
6497 /* If we've got another relocation for the address, keep going
6498 until we reach the last one. */
6499 if (use_saved_addend_p)
6501 addend = value;
6502 continue;
6505 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6506 /* See the comment above about using R_MIPS_64 in the 32-bit
6507 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6508 that calculated the right value. Now, however, we
6509 sign-extend the 32-bit result to 64-bits, and store it as a
6510 64-bit value. We are especially generous here in that we
6511 go to extreme lengths to support this usage on systems with
6512 only a 32-bit VMA. */
6514 bfd_vma sign_bits;
6515 bfd_vma low_bits;
6516 bfd_vma high_bits;
6518 if (value & ((bfd_vma) 1 << 31))
6519 #ifdef BFD64
6520 sign_bits = ((bfd_vma) 1 << 32) - 1;
6521 #else
6522 sign_bits = -1;
6523 #endif
6524 else
6525 sign_bits = 0;
6527 /* If we don't know that we have a 64-bit type,
6528 do two separate stores. */
6529 if (bfd_big_endian (input_bfd))
6531 /* Undo what we did above. */
6532 rel->r_offset -= 4;
6533 /* Store the sign-bits (which are most significant)
6534 first. */
6535 low_bits = sign_bits;
6536 high_bits = value;
6538 else
6540 low_bits = value;
6541 high_bits = sign_bits;
6543 bfd_put_32 (input_bfd, low_bits,
6544 contents + rel->r_offset);
6545 bfd_put_32 (input_bfd, high_bits,
6546 contents + rel->r_offset + 4);
6547 continue;
6550 /* Actually perform the relocation. */
6551 if (! mips_elf_perform_relocation (info, howto, rel, value,
6552 input_bfd, input_section,
6553 contents, require_jalx))
6554 return FALSE;
6557 return TRUE;
6560 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6561 adjust it appropriately now. */
6563 static void
6564 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
6565 const char *name, Elf_Internal_Sym *sym)
6567 /* The linker script takes care of providing names and values for
6568 these, but we must place them into the right sections. */
6569 static const char* const text_section_symbols[] = {
6570 "_ftext",
6571 "_etext",
6572 "__dso_displacement",
6573 "__elf_header",
6574 "__program_header_table",
6575 NULL
6578 static const char* const data_section_symbols[] = {
6579 "_fdata",
6580 "_edata",
6581 "_end",
6582 "_fbss",
6583 NULL
6586 const char* const *p;
6587 int i;
6589 for (i = 0; i < 2; ++i)
6590 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6592 ++p)
6593 if (strcmp (*p, name) == 0)
6595 /* All of these symbols are given type STT_SECTION by the
6596 IRIX6 linker. */
6597 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6598 sym->st_other = STO_PROTECTED;
6600 /* The IRIX linker puts these symbols in special sections. */
6601 if (i == 0)
6602 sym->st_shndx = SHN_MIPS_TEXT;
6603 else
6604 sym->st_shndx = SHN_MIPS_DATA;
6606 break;
6610 /* Finish up dynamic symbol handling. We set the contents of various
6611 dynamic sections here. */
6613 bfd_boolean
6614 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
6615 struct bfd_link_info *info,
6616 struct elf_link_hash_entry *h,
6617 Elf_Internal_Sym *sym)
6619 bfd *dynobj;
6620 bfd_vma gval;
6621 asection *sgot;
6622 struct mips_got_info *g, *gg;
6623 const char *name;
6625 dynobj = elf_hash_table (info)->dynobj;
6626 gval = sym->st_value;
6628 if (h->plt.offset != (bfd_vma) -1)
6630 asection *s;
6631 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6633 /* This symbol has a stub. Set it up. */
6635 BFD_ASSERT (h->dynindx != -1);
6637 s = bfd_get_section_by_name (dynobj,
6638 MIPS_ELF_STUB_SECTION_NAME (dynobj));
6639 BFD_ASSERT (s != NULL);
6641 /* FIXME: Can h->dynindex be more than 64K? */
6642 if (h->dynindx & 0xffff0000)
6643 return FALSE;
6645 /* Fill the stub. */
6646 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6647 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6648 bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6649 bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6651 BFD_ASSERT (h->plt.offset <= s->_raw_size);
6652 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6654 /* Mark the symbol as undefined. plt.offset != -1 occurs
6655 only for the referenced symbol. */
6656 sym->st_shndx = SHN_UNDEF;
6658 /* The run-time linker uses the st_value field of the symbol
6659 to reset the global offset table entry for this external
6660 to its stub address when unlinking a shared object. */
6661 gval = s->output_section->vma + s->output_offset + h->plt.offset;
6662 sym->st_value = gval;
6665 BFD_ASSERT (h->dynindx != -1
6666 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
6668 sgot = mips_elf_got_section (dynobj, FALSE);
6669 BFD_ASSERT (sgot != NULL);
6670 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6671 g = mips_elf_section_data (sgot)->u.got_info;
6672 BFD_ASSERT (g != NULL);
6674 /* Run through the global symbol table, creating GOT entries for all
6675 the symbols that need them. */
6676 if (g->global_gotsym != NULL
6677 && h->dynindx >= g->global_gotsym->dynindx)
6679 bfd_vma offset;
6680 bfd_vma value;
6682 value = sym->st_value;
6683 offset = mips_elf_global_got_index (dynobj, output_bfd, h);
6684 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6687 if (g->next && h->dynindx != -1)
6689 struct mips_got_entry e, *p;
6690 bfd_vma entry;
6691 bfd_vma offset;
6693 gg = g;
6695 e.abfd = output_bfd;
6696 e.symndx = -1;
6697 e.d.h = (struct mips_elf_link_hash_entry *)h;
6699 for (g = g->next; g->next != gg; g = g->next)
6701 if (g->got_entries
6702 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6703 &e)))
6705 offset = p->gotidx;
6706 if (info->shared
6707 || (elf_hash_table (info)->dynamic_sections_created
6708 && p->d.h != NULL
6709 && ((p->d.h->root.elf_link_hash_flags
6710 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
6711 && ((p->d.h->root.elf_link_hash_flags
6712 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6714 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6715 the various compatibility problems, it's easier to mock
6716 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6717 mips_elf_create_dynamic_relocation to calculate the
6718 appropriate addend. */
6719 Elf_Internal_Rela rel[3];
6721 memset (rel, 0, sizeof (rel));
6722 if (ABI_64_P (output_bfd))
6723 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
6724 else
6725 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
6726 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6728 entry = 0;
6729 if (! (mips_elf_create_dynamic_relocation
6730 (output_bfd, info, rel,
6731 e.d.h, NULL, sym->st_value, &entry, sgot)))
6732 return FALSE;
6734 else
6735 entry = sym->st_value;
6736 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
6741 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6742 name = h->root.root.string;
6743 if (strcmp (name, "_DYNAMIC") == 0
6744 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6745 sym->st_shndx = SHN_ABS;
6746 else if (strcmp (name, "_DYNAMIC_LINK") == 0
6747 || strcmp (name, "_DYNAMIC_LINKING") == 0)
6749 sym->st_shndx = SHN_ABS;
6750 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6751 sym->st_value = 1;
6753 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
6755 sym->st_shndx = SHN_ABS;
6756 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6757 sym->st_value = elf_gp (output_bfd);
6759 else if (SGI_COMPAT (output_bfd))
6761 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6762 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6764 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6765 sym->st_other = STO_PROTECTED;
6766 sym->st_value = 0;
6767 sym->st_shndx = SHN_MIPS_DATA;
6769 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6771 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6772 sym->st_other = STO_PROTECTED;
6773 sym->st_value = mips_elf_hash_table (info)->procedure_count;
6774 sym->st_shndx = SHN_ABS;
6776 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6778 if (h->type == STT_FUNC)
6779 sym->st_shndx = SHN_MIPS_TEXT;
6780 else if (h->type == STT_OBJECT)
6781 sym->st_shndx = SHN_MIPS_DATA;
6785 /* Handle the IRIX6-specific symbols. */
6786 if (IRIX_COMPAT (output_bfd) == ict_irix6)
6787 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6789 if (! info->shared)
6791 if (! mips_elf_hash_table (info)->use_rld_obj_head
6792 && (strcmp (name, "__rld_map") == 0
6793 || strcmp (name, "__RLD_MAP") == 0))
6795 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6796 BFD_ASSERT (s != NULL);
6797 sym->st_value = s->output_section->vma + s->output_offset;
6798 bfd_put_32 (output_bfd, 0, s->contents);
6799 if (mips_elf_hash_table (info)->rld_value == 0)
6800 mips_elf_hash_table (info)->rld_value = sym->st_value;
6802 else if (mips_elf_hash_table (info)->use_rld_obj_head
6803 && strcmp (name, "__rld_obj_head") == 0)
6805 /* IRIX6 does not use a .rld_map section. */
6806 if (IRIX_COMPAT (output_bfd) == ict_irix5
6807 || IRIX_COMPAT (output_bfd) == ict_none)
6808 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6809 != NULL);
6810 mips_elf_hash_table (info)->rld_value = sym->st_value;
6814 /* If this is a mips16 symbol, force the value to be even. */
6815 if (sym->st_other == STO_MIPS16
6816 && (sym->st_value & 1) != 0)
6817 --sym->st_value;
6819 return TRUE;
6822 /* Finish up the dynamic sections. */
6824 bfd_boolean
6825 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
6826 struct bfd_link_info *info)
6828 bfd *dynobj;
6829 asection *sdyn;
6830 asection *sgot;
6831 struct mips_got_info *gg, *g;
6833 dynobj = elf_hash_table (info)->dynobj;
6835 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6837 sgot = mips_elf_got_section (dynobj, FALSE);
6838 if (sgot == NULL)
6839 gg = g = NULL;
6840 else
6842 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6843 gg = mips_elf_section_data (sgot)->u.got_info;
6844 BFD_ASSERT (gg != NULL);
6845 g = mips_elf_got_for_ibfd (gg, output_bfd);
6846 BFD_ASSERT (g != NULL);
6849 if (elf_hash_table (info)->dynamic_sections_created)
6851 bfd_byte *b;
6853 BFD_ASSERT (sdyn != NULL);
6854 BFD_ASSERT (g != NULL);
6856 for (b = sdyn->contents;
6857 b < sdyn->contents + sdyn->_raw_size;
6858 b += MIPS_ELF_DYN_SIZE (dynobj))
6860 Elf_Internal_Dyn dyn;
6861 const char *name;
6862 size_t elemsize;
6863 asection *s;
6864 bfd_boolean swap_out_p;
6866 /* Read in the current dynamic entry. */
6867 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6869 /* Assume that we're going to modify it and write it out. */
6870 swap_out_p = TRUE;
6872 switch (dyn.d_tag)
6874 case DT_RELENT:
6875 s = mips_elf_rel_dyn_section (dynobj, FALSE);
6876 BFD_ASSERT (s != NULL);
6877 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6878 break;
6880 case DT_STRSZ:
6881 /* Rewrite DT_STRSZ. */
6882 dyn.d_un.d_val =
6883 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6884 break;
6886 case DT_PLTGOT:
6887 name = ".got";
6888 s = bfd_get_section_by_name (output_bfd, name);
6889 BFD_ASSERT (s != NULL);
6890 dyn.d_un.d_ptr = s->vma;
6891 break;
6893 case DT_MIPS_RLD_VERSION:
6894 dyn.d_un.d_val = 1; /* XXX */
6895 break;
6897 case DT_MIPS_FLAGS:
6898 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
6899 break;
6901 case DT_MIPS_TIME_STAMP:
6902 time ((time_t *) &dyn.d_un.d_val);
6903 break;
6905 case DT_MIPS_ICHECKSUM:
6906 /* XXX FIXME: */
6907 swap_out_p = FALSE;
6908 break;
6910 case DT_MIPS_IVERSION:
6911 /* XXX FIXME: */
6912 swap_out_p = FALSE;
6913 break;
6915 case DT_MIPS_BASE_ADDRESS:
6916 s = output_bfd->sections;
6917 BFD_ASSERT (s != NULL);
6918 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
6919 break;
6921 case DT_MIPS_LOCAL_GOTNO:
6922 dyn.d_un.d_val = g->local_gotno;
6923 break;
6925 case DT_MIPS_UNREFEXTNO:
6926 /* The index into the dynamic symbol table which is the
6927 entry of the first external symbol that is not
6928 referenced within the same object. */
6929 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
6930 break;
6932 case DT_MIPS_GOTSYM:
6933 if (gg->global_gotsym)
6935 dyn.d_un.d_val = gg->global_gotsym->dynindx;
6936 break;
6938 /* In case if we don't have global got symbols we default
6939 to setting DT_MIPS_GOTSYM to the same value as
6940 DT_MIPS_SYMTABNO, so we just fall through. */
6942 case DT_MIPS_SYMTABNO:
6943 name = ".dynsym";
6944 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
6945 s = bfd_get_section_by_name (output_bfd, name);
6946 BFD_ASSERT (s != NULL);
6948 if (s->_cooked_size != 0)
6949 dyn.d_un.d_val = s->_cooked_size / elemsize;
6950 else
6951 dyn.d_un.d_val = s->_raw_size / elemsize;
6952 break;
6954 case DT_MIPS_HIPAGENO:
6955 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
6956 break;
6958 case DT_MIPS_RLD_MAP:
6959 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
6960 break;
6962 case DT_MIPS_OPTIONS:
6963 s = (bfd_get_section_by_name
6964 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
6965 dyn.d_un.d_ptr = s->vma;
6966 break;
6968 case DT_RELSZ:
6969 /* Reduce DT_RELSZ to account for any relocations we
6970 decided not to make. This is for the n64 irix rld,
6971 which doesn't seem to apply any relocations if there
6972 are trailing null entries. */
6973 s = mips_elf_rel_dyn_section (dynobj, FALSE);
6974 dyn.d_un.d_val = (s->reloc_count
6975 * (ABI_64_P (output_bfd)
6976 ? sizeof (Elf64_Mips_External_Rel)
6977 : sizeof (Elf32_External_Rel)));
6978 break;
6980 default:
6981 swap_out_p = FALSE;
6982 break;
6985 if (swap_out_p)
6986 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
6987 (dynobj, &dyn, b);
6991 /* The first entry of the global offset table will be filled at
6992 runtime. The second entry will be used by some runtime loaders.
6993 This isn't the case of IRIX rld. */
6994 if (sgot != NULL && sgot->_raw_size > 0)
6996 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents);
6997 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000,
6998 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
7001 if (sgot != NULL)
7002 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
7003 = MIPS_ELF_GOT_SIZE (output_bfd);
7005 /* Generate dynamic relocations for the non-primary gots. */
7006 if (gg != NULL && gg->next)
7008 Elf_Internal_Rela rel[3];
7009 bfd_vma addend = 0;
7011 memset (rel, 0, sizeof (rel));
7012 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7014 for (g = gg->next; g->next != gg; g = g->next)
7016 bfd_vma index = g->next->local_gotno + g->next->global_gotno;
7018 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
7019 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7020 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents
7021 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7023 if (! info->shared)
7024 continue;
7026 while (index < g->assigned_gotno)
7028 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7029 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7030 if (!(mips_elf_create_dynamic_relocation
7031 (output_bfd, info, rel, NULL,
7032 bfd_abs_section_ptr,
7033 0, &addend, sgot)))
7034 return FALSE;
7035 BFD_ASSERT (addend == 0);
7041 asection *s;
7042 Elf32_compact_rel cpt;
7044 if (SGI_COMPAT (output_bfd))
7046 /* Write .compact_rel section out. */
7047 s = bfd_get_section_by_name (dynobj, ".compact_rel");
7048 if (s != NULL)
7050 cpt.id1 = 1;
7051 cpt.num = s->reloc_count;
7052 cpt.id2 = 2;
7053 cpt.offset = (s->output_section->filepos
7054 + sizeof (Elf32_External_compact_rel));
7055 cpt.reserved0 = 0;
7056 cpt.reserved1 = 0;
7057 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7058 ((Elf32_External_compact_rel *)
7059 s->contents));
7061 /* Clean up a dummy stub function entry in .text. */
7062 s = bfd_get_section_by_name (dynobj,
7063 MIPS_ELF_STUB_SECTION_NAME (dynobj));
7064 if (s != NULL)
7066 file_ptr dummy_offset;
7068 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
7069 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
7070 memset (s->contents + dummy_offset, 0,
7071 MIPS_FUNCTION_STUB_SIZE);
7076 /* We need to sort the entries of the dynamic relocation section. */
7078 s = mips_elf_rel_dyn_section (dynobj, FALSE);
7080 if (s != NULL
7081 && s->_raw_size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7083 reldyn_sorting_bfd = output_bfd;
7085 if (ABI_64_P (output_bfd))
7086 qsort ((Elf64_External_Rel *) s->contents + 1, s->reloc_count - 1,
7087 sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7088 else
7089 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
7090 sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7094 return TRUE;
7098 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7100 static void
7101 mips_set_isa_flags (bfd *abfd)
7103 flagword val;
7105 switch (bfd_get_mach (abfd))
7107 default:
7108 case bfd_mach_mips3000:
7109 val = E_MIPS_ARCH_1;
7110 break;
7112 case bfd_mach_mips3900:
7113 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7114 break;
7116 case bfd_mach_mips6000:
7117 val = E_MIPS_ARCH_2;
7118 break;
7120 case bfd_mach_mips4000:
7121 case bfd_mach_mips4300:
7122 case bfd_mach_mips4400:
7123 case bfd_mach_mips4600:
7124 val = E_MIPS_ARCH_3;
7125 break;
7127 case bfd_mach_mips4010:
7128 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7129 break;
7131 case bfd_mach_mips4100:
7132 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7133 break;
7135 case bfd_mach_mips4111:
7136 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7137 break;
7139 case bfd_mach_mips4120:
7140 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7141 break;
7143 case bfd_mach_mips4650:
7144 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7145 break;
7147 case bfd_mach_mips5400:
7148 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7149 break;
7151 case bfd_mach_mips5500:
7152 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7153 break;
7155 case bfd_mach_mips5000:
7156 case bfd_mach_mips7000:
7157 case bfd_mach_mips8000:
7158 case bfd_mach_mips10000:
7159 case bfd_mach_mips12000:
7160 val = E_MIPS_ARCH_4;
7161 break;
7163 case bfd_mach_mips5:
7164 val = E_MIPS_ARCH_5;
7165 break;
7167 case bfd_mach_mips_sb1:
7168 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7169 break;
7171 case bfd_mach_mipsisa32:
7172 val = E_MIPS_ARCH_32;
7173 break;
7175 case bfd_mach_mipsisa64:
7176 val = E_MIPS_ARCH_64;
7177 break;
7179 case bfd_mach_mipsisa32r2:
7180 val = E_MIPS_ARCH_32R2;
7181 break;
7183 case bfd_mach_mipsisa64r2:
7184 val = E_MIPS_ARCH_64R2;
7185 break;
7187 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7188 elf_elfheader (abfd)->e_flags |= val;
7193 /* The final processing done just before writing out a MIPS ELF object
7194 file. This gets the MIPS architecture right based on the machine
7195 number. This is used by both the 32-bit and the 64-bit ABI. */
7197 void
7198 _bfd_mips_elf_final_write_processing (bfd *abfd,
7199 bfd_boolean linker ATTRIBUTE_UNUSED)
7201 unsigned int i;
7202 Elf_Internal_Shdr **hdrpp;
7203 const char *name;
7204 asection *sec;
7206 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7207 is nonzero. This is for compatibility with old objects, which used
7208 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7209 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7210 mips_set_isa_flags (abfd);
7212 /* Set the sh_info field for .gptab sections and other appropriate
7213 info for each special section. */
7214 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7215 i < elf_numsections (abfd);
7216 i++, hdrpp++)
7218 switch ((*hdrpp)->sh_type)
7220 case SHT_MIPS_MSYM:
7221 case SHT_MIPS_LIBLIST:
7222 sec = bfd_get_section_by_name (abfd, ".dynstr");
7223 if (sec != NULL)
7224 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7225 break;
7227 case SHT_MIPS_GPTAB:
7228 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7229 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7230 BFD_ASSERT (name != NULL
7231 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7232 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7233 BFD_ASSERT (sec != NULL);
7234 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7235 break;
7237 case SHT_MIPS_CONTENT:
7238 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7239 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7240 BFD_ASSERT (name != NULL
7241 && strncmp (name, ".MIPS.content",
7242 sizeof ".MIPS.content" - 1) == 0);
7243 sec = bfd_get_section_by_name (abfd,
7244 name + sizeof ".MIPS.content" - 1);
7245 BFD_ASSERT (sec != NULL);
7246 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7247 break;
7249 case SHT_MIPS_SYMBOL_LIB:
7250 sec = bfd_get_section_by_name (abfd, ".dynsym");
7251 if (sec != NULL)
7252 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7253 sec = bfd_get_section_by_name (abfd, ".liblist");
7254 if (sec != NULL)
7255 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7256 break;
7258 case SHT_MIPS_EVENTS:
7259 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7260 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7261 BFD_ASSERT (name != NULL);
7262 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7263 sec = bfd_get_section_by_name (abfd,
7264 name + sizeof ".MIPS.events" - 1);
7265 else
7267 BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7268 sizeof ".MIPS.post_rel" - 1) == 0);
7269 sec = bfd_get_section_by_name (abfd,
7270 (name
7271 + sizeof ".MIPS.post_rel" - 1));
7273 BFD_ASSERT (sec != NULL);
7274 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7275 break;
7281 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7282 segments. */
7285 _bfd_mips_elf_additional_program_headers (bfd *abfd)
7287 asection *s;
7288 int ret = 0;
7290 /* See if we need a PT_MIPS_REGINFO segment. */
7291 s = bfd_get_section_by_name (abfd, ".reginfo");
7292 if (s && (s->flags & SEC_LOAD))
7293 ++ret;
7295 /* See if we need a PT_MIPS_OPTIONS segment. */
7296 if (IRIX_COMPAT (abfd) == ict_irix6
7297 && bfd_get_section_by_name (abfd,
7298 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7299 ++ret;
7301 /* See if we need a PT_MIPS_RTPROC segment. */
7302 if (IRIX_COMPAT (abfd) == ict_irix5
7303 && bfd_get_section_by_name (abfd, ".dynamic")
7304 && bfd_get_section_by_name (abfd, ".mdebug"))
7305 ++ret;
7307 return ret;
7310 /* Modify the segment map for an IRIX5 executable. */
7312 bfd_boolean
7313 _bfd_mips_elf_modify_segment_map (bfd *abfd,
7314 struct bfd_link_info *info ATTRIBUTE_UNUSED)
7316 asection *s;
7317 struct elf_segment_map *m, **pm;
7318 bfd_size_type amt;
7320 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7321 segment. */
7322 s = bfd_get_section_by_name (abfd, ".reginfo");
7323 if (s != NULL && (s->flags & SEC_LOAD) != 0)
7325 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7326 if (m->p_type == PT_MIPS_REGINFO)
7327 break;
7328 if (m == NULL)
7330 amt = sizeof *m;
7331 m = bfd_zalloc (abfd, amt);
7332 if (m == NULL)
7333 return FALSE;
7335 m->p_type = PT_MIPS_REGINFO;
7336 m->count = 1;
7337 m->sections[0] = s;
7339 /* We want to put it after the PHDR and INTERP segments. */
7340 pm = &elf_tdata (abfd)->segment_map;
7341 while (*pm != NULL
7342 && ((*pm)->p_type == PT_PHDR
7343 || (*pm)->p_type == PT_INTERP))
7344 pm = &(*pm)->next;
7346 m->next = *pm;
7347 *pm = m;
7351 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7352 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7353 PT_MIPS_OPTIONS segment immediately following the program header
7354 table. */
7355 if (NEWABI_P (abfd)
7356 /* On non-IRIX6 new abi, we'll have already created a segment
7357 for this section, so don't create another. I'm not sure this
7358 is not also the case for IRIX 6, but I can't test it right
7359 now. */
7360 && IRIX_COMPAT (abfd) == ict_irix6)
7362 for (s = abfd->sections; s; s = s->next)
7363 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7364 break;
7366 if (s)
7368 struct elf_segment_map *options_segment;
7370 pm = &elf_tdata (abfd)->segment_map;
7371 while (*pm != NULL
7372 && ((*pm)->p_type == PT_PHDR
7373 || (*pm)->p_type == PT_INTERP))
7374 pm = &(*pm)->next;
7376 amt = sizeof (struct elf_segment_map);
7377 options_segment = bfd_zalloc (abfd, amt);
7378 options_segment->next = *pm;
7379 options_segment->p_type = PT_MIPS_OPTIONS;
7380 options_segment->p_flags = PF_R;
7381 options_segment->p_flags_valid = TRUE;
7382 options_segment->count = 1;
7383 options_segment->sections[0] = s;
7384 *pm = options_segment;
7387 else
7389 if (IRIX_COMPAT (abfd) == ict_irix5)
7391 /* If there are .dynamic and .mdebug sections, we make a room
7392 for the RTPROC header. FIXME: Rewrite without section names. */
7393 if (bfd_get_section_by_name (abfd, ".interp") == NULL
7394 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7395 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7397 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7398 if (m->p_type == PT_MIPS_RTPROC)
7399 break;
7400 if (m == NULL)
7402 amt = sizeof *m;
7403 m = bfd_zalloc (abfd, amt);
7404 if (m == NULL)
7405 return FALSE;
7407 m->p_type = PT_MIPS_RTPROC;
7409 s = bfd_get_section_by_name (abfd, ".rtproc");
7410 if (s == NULL)
7412 m->count = 0;
7413 m->p_flags = 0;
7414 m->p_flags_valid = 1;
7416 else
7418 m->count = 1;
7419 m->sections[0] = s;
7422 /* We want to put it after the DYNAMIC segment. */
7423 pm = &elf_tdata (abfd)->segment_map;
7424 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7425 pm = &(*pm)->next;
7426 if (*pm != NULL)
7427 pm = &(*pm)->next;
7429 m->next = *pm;
7430 *pm = m;
7434 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7435 .dynstr, .dynsym, and .hash sections, and everything in
7436 between. */
7437 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7438 pm = &(*pm)->next)
7439 if ((*pm)->p_type == PT_DYNAMIC)
7440 break;
7441 m = *pm;
7442 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7444 /* For a normal mips executable the permissions for the PT_DYNAMIC
7445 segment are read, write and execute. We do that here since
7446 the code in elf.c sets only the read permission. This matters
7447 sometimes for the dynamic linker. */
7448 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7450 m->p_flags = PF_R | PF_W | PF_X;
7451 m->p_flags_valid = 1;
7454 if (m != NULL
7455 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7457 static const char *sec_names[] =
7459 ".dynamic", ".dynstr", ".dynsym", ".hash"
7461 bfd_vma low, high;
7462 unsigned int i, c;
7463 struct elf_segment_map *n;
7465 low = ~(bfd_vma) 0;
7466 high = 0;
7467 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7469 s = bfd_get_section_by_name (abfd, sec_names[i]);
7470 if (s != NULL && (s->flags & SEC_LOAD) != 0)
7472 bfd_size_type sz;
7474 if (low > s->vma)
7475 low = s->vma;
7476 sz = s->_cooked_size;
7477 if (sz == 0)
7478 sz = s->_raw_size;
7479 if (high < s->vma + sz)
7480 high = s->vma + sz;
7484 c = 0;
7485 for (s = abfd->sections; s != NULL; s = s->next)
7486 if ((s->flags & SEC_LOAD) != 0
7487 && s->vma >= low
7488 && ((s->vma
7489 + (s->_cooked_size !=
7490 0 ? s->_cooked_size : s->_raw_size)) <= high))
7491 ++c;
7493 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7494 n = bfd_zalloc (abfd, amt);
7495 if (n == NULL)
7496 return FALSE;
7497 *n = *m;
7498 n->count = c;
7500 i = 0;
7501 for (s = abfd->sections; s != NULL; s = s->next)
7503 if ((s->flags & SEC_LOAD) != 0
7504 && s->vma >= low
7505 && ((s->vma
7506 + (s->_cooked_size != 0 ?
7507 s->_cooked_size : s->_raw_size)) <= high))
7509 n->sections[i] = s;
7510 ++i;
7514 *pm = n;
7518 return TRUE;
7521 /* Return the section that should be marked against GC for a given
7522 relocation. */
7524 asection *
7525 _bfd_mips_elf_gc_mark_hook (asection *sec,
7526 struct bfd_link_info *info ATTRIBUTE_UNUSED,
7527 Elf_Internal_Rela *rel,
7528 struct elf_link_hash_entry *h,
7529 Elf_Internal_Sym *sym)
7531 /* ??? Do mips16 stub sections need to be handled special? */
7533 if (h != NULL)
7535 switch (ELF_R_TYPE (sec->owner, rel->r_info))
7537 case R_MIPS_GNU_VTINHERIT:
7538 case R_MIPS_GNU_VTENTRY:
7539 break;
7541 default:
7542 switch (h->root.type)
7544 case bfd_link_hash_defined:
7545 case bfd_link_hash_defweak:
7546 return h->root.u.def.section;
7548 case bfd_link_hash_common:
7549 return h->root.u.c.p->section;
7551 default:
7552 break;
7556 else
7557 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7559 return NULL;
7562 /* Update the got entry reference counts for the section being removed. */
7564 bfd_boolean
7565 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
7566 struct bfd_link_info *info ATTRIBUTE_UNUSED,
7567 asection *sec ATTRIBUTE_UNUSED,
7568 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
7570 #if 0
7571 Elf_Internal_Shdr *symtab_hdr;
7572 struct elf_link_hash_entry **sym_hashes;
7573 bfd_signed_vma *local_got_refcounts;
7574 const Elf_Internal_Rela *rel, *relend;
7575 unsigned long r_symndx;
7576 struct elf_link_hash_entry *h;
7578 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7579 sym_hashes = elf_sym_hashes (abfd);
7580 local_got_refcounts = elf_local_got_refcounts (abfd);
7582 relend = relocs + sec->reloc_count;
7583 for (rel = relocs; rel < relend; rel++)
7584 switch (ELF_R_TYPE (abfd, rel->r_info))
7586 case R_MIPS_GOT16:
7587 case R_MIPS_CALL16:
7588 case R_MIPS_CALL_HI16:
7589 case R_MIPS_CALL_LO16:
7590 case R_MIPS_GOT_HI16:
7591 case R_MIPS_GOT_LO16:
7592 case R_MIPS_GOT_DISP:
7593 case R_MIPS_GOT_PAGE:
7594 case R_MIPS_GOT_OFST:
7595 /* ??? It would seem that the existing MIPS code does no sort
7596 of reference counting or whatnot on its GOT and PLT entries,
7597 so it is not possible to garbage collect them at this time. */
7598 break;
7600 default:
7601 break;
7603 #endif
7605 return TRUE;
7608 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7609 hiding the old indirect symbol. Process additional relocation
7610 information. Also called for weakdefs, in which case we just let
7611 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7613 void
7614 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
7615 struct elf_link_hash_entry *dir,
7616 struct elf_link_hash_entry *ind)
7618 struct mips_elf_link_hash_entry *dirmips, *indmips;
7620 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
7622 if (ind->root.type != bfd_link_hash_indirect)
7623 return;
7625 dirmips = (struct mips_elf_link_hash_entry *) dir;
7626 indmips = (struct mips_elf_link_hash_entry *) ind;
7627 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7628 if (indmips->readonly_reloc)
7629 dirmips->readonly_reloc = TRUE;
7630 if (indmips->no_fn_stub)
7631 dirmips->no_fn_stub = TRUE;
7634 void
7635 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
7636 struct elf_link_hash_entry *entry,
7637 bfd_boolean force_local)
7639 bfd *dynobj;
7640 asection *got;
7641 struct mips_got_info *g;
7642 struct mips_elf_link_hash_entry *h;
7644 h = (struct mips_elf_link_hash_entry *) entry;
7645 if (h->forced_local)
7646 return;
7647 h->forced_local = force_local;
7649 dynobj = elf_hash_table (info)->dynobj;
7650 if (dynobj != NULL && force_local)
7652 got = mips_elf_got_section (dynobj, FALSE);
7653 g = mips_elf_section_data (got)->u.got_info;
7655 if (g->next)
7657 struct mips_got_entry e;
7658 struct mips_got_info *gg = g;
7660 /* Since we're turning what used to be a global symbol into a
7661 local one, bump up the number of local entries of each GOT
7662 that had an entry for it. This will automatically decrease
7663 the number of global entries, since global_gotno is actually
7664 the upper limit of global entries. */
7665 e.abfd = dynobj;
7666 e.symndx = -1;
7667 e.d.h = h;
7669 for (g = g->next; g != gg; g = g->next)
7670 if (htab_find (g->got_entries, &e))
7672 BFD_ASSERT (g->global_gotno > 0);
7673 g->local_gotno++;
7674 g->global_gotno--;
7677 /* If this was a global symbol forced into the primary GOT, we
7678 no longer need an entry for it. We can't release the entry
7679 at this point, but we must at least stop counting it as one
7680 of the symbols that required a forced got entry. */
7681 if (h->root.got.offset == 2)
7683 BFD_ASSERT (gg->assigned_gotno > 0);
7684 gg->assigned_gotno--;
7687 else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7688 /* If we haven't got through GOT allocation yet, just bump up the
7689 number of local entries, as this symbol won't be counted as
7690 global. */
7691 g->local_gotno++;
7692 else if (h->root.got.offset == 1)
7694 /* If we're past non-multi-GOT allocation and this symbol had
7695 been marked for a global got entry, give it a local entry
7696 instead. */
7697 BFD_ASSERT (g->global_gotno > 0);
7698 g->local_gotno++;
7699 g->global_gotno--;
7703 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
7706 #define PDR_SIZE 32
7708 bfd_boolean
7709 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
7710 struct bfd_link_info *info)
7712 asection *o;
7713 bfd_boolean ret = FALSE;
7714 unsigned char *tdata;
7715 size_t i, skip;
7717 o = bfd_get_section_by_name (abfd, ".pdr");
7718 if (! o)
7719 return FALSE;
7720 if (o->_raw_size == 0)
7721 return FALSE;
7722 if (o->_raw_size % PDR_SIZE != 0)
7723 return FALSE;
7724 if (o->output_section != NULL
7725 && bfd_is_abs_section (o->output_section))
7726 return FALSE;
7728 tdata = bfd_zmalloc (o->_raw_size / PDR_SIZE);
7729 if (! tdata)
7730 return FALSE;
7732 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7733 info->keep_memory);
7734 if (!cookie->rels)
7736 free (tdata);
7737 return FALSE;
7740 cookie->rel = cookie->rels;
7741 cookie->relend = cookie->rels + o->reloc_count;
7743 for (i = 0, skip = 0; i < o->_raw_size / PDR_SIZE; i ++)
7745 if (MNAME(abfd,_bfd_elf,reloc_symbol_deleted_p) (i * PDR_SIZE, cookie))
7747 tdata[i] = 1;
7748 skip ++;
7752 if (skip != 0)
7754 mips_elf_section_data (o)->u.tdata = tdata;
7755 o->_cooked_size = o->_raw_size - skip * PDR_SIZE;
7756 ret = TRUE;
7758 else
7759 free (tdata);
7761 if (! info->keep_memory)
7762 free (cookie->rels);
7764 return ret;
7767 bfd_boolean
7768 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
7770 if (strcmp (sec->name, ".pdr") == 0)
7771 return TRUE;
7772 return FALSE;
7775 bfd_boolean
7776 _bfd_mips_elf_write_section (bfd *output_bfd, asection *sec,
7777 bfd_byte *contents)
7779 bfd_byte *to, *from, *end;
7780 int i;
7782 if (strcmp (sec->name, ".pdr") != 0)
7783 return FALSE;
7785 if (mips_elf_section_data (sec)->u.tdata == NULL)
7786 return FALSE;
7788 to = contents;
7789 end = contents + sec->_raw_size;
7790 for (from = contents, i = 0;
7791 from < end;
7792 from += PDR_SIZE, i++)
7794 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
7795 continue;
7796 if (to != from)
7797 memcpy (to, from, PDR_SIZE);
7798 to += PDR_SIZE;
7800 bfd_set_section_contents (output_bfd, sec->output_section, contents,
7801 sec->output_offset, sec->_cooked_size);
7802 return TRUE;
7805 /* MIPS ELF uses a special find_nearest_line routine in order the
7806 handle the ECOFF debugging information. */
7808 struct mips_elf_find_line
7810 struct ecoff_debug_info d;
7811 struct ecoff_find_line i;
7814 bfd_boolean
7815 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
7816 asymbol **symbols, bfd_vma offset,
7817 const char **filename_ptr,
7818 const char **functionname_ptr,
7819 unsigned int *line_ptr)
7821 asection *msec;
7823 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7824 filename_ptr, functionname_ptr,
7825 line_ptr))
7826 return TRUE;
7828 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7829 filename_ptr, functionname_ptr,
7830 line_ptr, ABI_64_P (abfd) ? 8 : 0,
7831 &elf_tdata (abfd)->dwarf2_find_line_info))
7832 return TRUE;
7834 msec = bfd_get_section_by_name (abfd, ".mdebug");
7835 if (msec != NULL)
7837 flagword origflags;
7838 struct mips_elf_find_line *fi;
7839 const struct ecoff_debug_swap * const swap =
7840 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
7842 /* If we are called during a link, mips_elf_final_link may have
7843 cleared the SEC_HAS_CONTENTS field. We force it back on here
7844 if appropriate (which it normally will be). */
7845 origflags = msec->flags;
7846 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
7847 msec->flags |= SEC_HAS_CONTENTS;
7849 fi = elf_tdata (abfd)->find_line_info;
7850 if (fi == NULL)
7852 bfd_size_type external_fdr_size;
7853 char *fraw_src;
7854 char *fraw_end;
7855 struct fdr *fdr_ptr;
7856 bfd_size_type amt = sizeof (struct mips_elf_find_line);
7858 fi = bfd_zalloc (abfd, amt);
7859 if (fi == NULL)
7861 msec->flags = origflags;
7862 return FALSE;
7865 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
7867 msec->flags = origflags;
7868 return FALSE;
7871 /* Swap in the FDR information. */
7872 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
7873 fi->d.fdr = bfd_alloc (abfd, amt);
7874 if (fi->d.fdr == NULL)
7876 msec->flags = origflags;
7877 return FALSE;
7879 external_fdr_size = swap->external_fdr_size;
7880 fdr_ptr = fi->d.fdr;
7881 fraw_src = (char *) fi->d.external_fdr;
7882 fraw_end = (fraw_src
7883 + fi->d.symbolic_header.ifdMax * external_fdr_size);
7884 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
7885 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
7887 elf_tdata (abfd)->find_line_info = fi;
7889 /* Note that we don't bother to ever free this information.
7890 find_nearest_line is either called all the time, as in
7891 objdump -l, so the information should be saved, or it is
7892 rarely called, as in ld error messages, so the memory
7893 wasted is unimportant. Still, it would probably be a
7894 good idea for free_cached_info to throw it away. */
7897 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
7898 &fi->i, filename_ptr, functionname_ptr,
7899 line_ptr))
7901 msec->flags = origflags;
7902 return TRUE;
7905 msec->flags = origflags;
7908 /* Fall back on the generic ELF find_nearest_line routine. */
7910 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
7911 filename_ptr, functionname_ptr,
7912 line_ptr);
7915 /* When are writing out the .options or .MIPS.options section,
7916 remember the bytes we are writing out, so that we can install the
7917 GP value in the section_processing routine. */
7919 bfd_boolean
7920 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
7921 const void *location,
7922 file_ptr offset, bfd_size_type count)
7924 if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
7926 bfd_byte *c;
7928 if (elf_section_data (section) == NULL)
7930 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
7931 section->used_by_bfd = bfd_zalloc (abfd, amt);
7932 if (elf_section_data (section) == NULL)
7933 return FALSE;
7935 c = mips_elf_section_data (section)->u.tdata;
7936 if (c == NULL)
7938 bfd_size_type size;
7940 if (section->_cooked_size != 0)
7941 size = section->_cooked_size;
7942 else
7943 size = section->_raw_size;
7944 c = bfd_zalloc (abfd, size);
7945 if (c == NULL)
7946 return FALSE;
7947 mips_elf_section_data (section)->u.tdata = c;
7950 memcpy (c + offset, location, count);
7953 return _bfd_elf_set_section_contents (abfd, section, location, offset,
7954 count);
7957 /* This is almost identical to bfd_generic_get_... except that some
7958 MIPS relocations need to be handled specially. Sigh. */
7960 bfd_byte *
7961 _bfd_elf_mips_get_relocated_section_contents
7962 (bfd *abfd,
7963 struct bfd_link_info *link_info,
7964 struct bfd_link_order *link_order,
7965 bfd_byte *data,
7966 bfd_boolean relocatable,
7967 asymbol **symbols)
7969 /* Get enough memory to hold the stuff */
7970 bfd *input_bfd = link_order->u.indirect.section->owner;
7971 asection *input_section = link_order->u.indirect.section;
7973 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
7974 arelent **reloc_vector = NULL;
7975 long reloc_count;
7977 if (reloc_size < 0)
7978 goto error_return;
7980 reloc_vector = bfd_malloc (reloc_size);
7981 if (reloc_vector == NULL && reloc_size != 0)
7982 goto error_return;
7984 /* read in the section */
7985 if (!bfd_get_section_contents (input_bfd, input_section, data, 0,
7986 input_section->_raw_size))
7987 goto error_return;
7989 /* We're not relaxing the section, so just copy the size info */
7990 input_section->_cooked_size = input_section->_raw_size;
7991 input_section->reloc_done = TRUE;
7993 reloc_count = bfd_canonicalize_reloc (input_bfd,
7994 input_section,
7995 reloc_vector,
7996 symbols);
7997 if (reloc_count < 0)
7998 goto error_return;
8000 if (reloc_count > 0)
8002 arelent **parent;
8003 /* for mips */
8004 int gp_found;
8005 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
8008 struct bfd_hash_entry *h;
8009 struct bfd_link_hash_entry *lh;
8010 /* Skip all this stuff if we aren't mixing formats. */
8011 if (abfd && input_bfd
8012 && abfd->xvec == input_bfd->xvec)
8013 lh = 0;
8014 else
8016 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
8017 lh = (struct bfd_link_hash_entry *) h;
8019 lookup:
8020 if (lh)
8022 switch (lh->type)
8024 case bfd_link_hash_undefined:
8025 case bfd_link_hash_undefweak:
8026 case bfd_link_hash_common:
8027 gp_found = 0;
8028 break;
8029 case bfd_link_hash_defined:
8030 case bfd_link_hash_defweak:
8031 gp_found = 1;
8032 gp = lh->u.def.value;
8033 break;
8034 case bfd_link_hash_indirect:
8035 case bfd_link_hash_warning:
8036 lh = lh->u.i.link;
8037 /* @@FIXME ignoring warning for now */
8038 goto lookup;
8039 case bfd_link_hash_new:
8040 default:
8041 abort ();
8044 else
8045 gp_found = 0;
8047 /* end mips */
8048 for (parent = reloc_vector; *parent != NULL; parent++)
8050 char *error_message = NULL;
8051 bfd_reloc_status_type r;
8053 /* Specific to MIPS: Deal with relocation types that require
8054 knowing the gp of the output bfd. */
8055 asymbol *sym = *(*parent)->sym_ptr_ptr;
8056 if (bfd_is_abs_section (sym->section) && abfd)
8058 /* The special_function wouldn't get called anyway. */
8060 else if (!gp_found)
8062 /* The gp isn't there; let the special function code
8063 fall over on its own. */
8065 else if ((*parent)->howto->special_function
8066 == _bfd_mips_elf32_gprel16_reloc)
8068 /* bypass special_function call */
8069 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8070 input_section, relocatable,
8071 data, gp);
8072 goto skip_bfd_perform_relocation;
8074 /* end mips specific stuff */
8076 r = bfd_perform_relocation (input_bfd, *parent, data, input_section,
8077 relocatable ? abfd : NULL,
8078 &error_message);
8079 skip_bfd_perform_relocation:
8081 if (relocatable)
8083 asection *os = input_section->output_section;
8085 /* A partial link, so keep the relocs */
8086 os->orelocation[os->reloc_count] = *parent;
8087 os->reloc_count++;
8090 if (r != bfd_reloc_ok)
8092 switch (r)
8094 case bfd_reloc_undefined:
8095 if (!((*link_info->callbacks->undefined_symbol)
8096 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8097 input_bfd, input_section, (*parent)->address,
8098 TRUE)))
8099 goto error_return;
8100 break;
8101 case bfd_reloc_dangerous:
8102 BFD_ASSERT (error_message != NULL);
8103 if (!((*link_info->callbacks->reloc_dangerous)
8104 (link_info, error_message, input_bfd, input_section,
8105 (*parent)->address)))
8106 goto error_return;
8107 break;
8108 case bfd_reloc_overflow:
8109 if (!((*link_info->callbacks->reloc_overflow)
8110 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8111 (*parent)->howto->name, (*parent)->addend,
8112 input_bfd, input_section, (*parent)->address)))
8113 goto error_return;
8114 break;
8115 case bfd_reloc_outofrange:
8116 default:
8117 abort ();
8118 break;
8124 if (reloc_vector != NULL)
8125 free (reloc_vector);
8126 return data;
8128 error_return:
8129 if (reloc_vector != NULL)
8130 free (reloc_vector);
8131 return NULL;
8134 /* Create a MIPS ELF linker hash table. */
8136 struct bfd_link_hash_table *
8137 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
8139 struct mips_elf_link_hash_table *ret;
8140 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8142 ret = bfd_malloc (amt);
8143 if (ret == NULL)
8144 return NULL;
8146 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8147 mips_elf_link_hash_newfunc))
8149 free (ret);
8150 return NULL;
8153 #if 0
8154 /* We no longer use this. */
8155 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8156 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8157 #endif
8158 ret->procedure_count = 0;
8159 ret->compact_rel_size = 0;
8160 ret->use_rld_obj_head = FALSE;
8161 ret->rld_value = 0;
8162 ret->mips16_stubs_seen = FALSE;
8164 return &ret->root.root;
8167 /* We need to use a special link routine to handle the .reginfo and
8168 the .mdebug sections. We need to merge all instances of these
8169 sections together, not write them all out sequentially. */
8171 bfd_boolean
8172 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
8174 asection **secpp;
8175 asection *o;
8176 struct bfd_link_order *p;
8177 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8178 asection *rtproc_sec;
8179 Elf32_RegInfo reginfo;
8180 struct ecoff_debug_info debug;
8181 const struct ecoff_debug_swap *swap
8182 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8183 HDRR *symhdr = &debug.symbolic_header;
8184 void *mdebug_handle = NULL;
8185 asection *s;
8186 EXTR esym;
8187 unsigned int i;
8188 bfd_size_type amt;
8190 static const char * const secname[] =
8192 ".text", ".init", ".fini", ".data",
8193 ".rodata", ".sdata", ".sbss", ".bss"
8195 static const int sc[] =
8197 scText, scInit, scFini, scData,
8198 scRData, scSData, scSBss, scBss
8201 /* We'd carefully arranged the dynamic symbol indices, and then the
8202 generic size_dynamic_sections renumbered them out from under us.
8203 Rather than trying somehow to prevent the renumbering, just do
8204 the sort again. */
8205 if (elf_hash_table (info)->dynamic_sections_created)
8207 bfd *dynobj;
8208 asection *got;
8209 struct mips_got_info *g;
8211 /* When we resort, we must tell mips_elf_sort_hash_table what
8212 the lowest index it may use is. That's the number of section
8213 symbols we're going to add. The generic ELF linker only
8214 adds these symbols when building a shared object. Note that
8215 we count the sections after (possibly) removing the .options
8216 section above. */
8217 if (! mips_elf_sort_hash_table (info, (info->shared
8218 ? bfd_count_sections (abfd) + 1
8219 : 1)))
8220 return FALSE;
8222 /* Make sure we didn't grow the global .got region. */
8223 dynobj = elf_hash_table (info)->dynobj;
8224 got = mips_elf_got_section (dynobj, FALSE);
8225 g = mips_elf_section_data (got)->u.got_info;
8227 if (g->global_gotsym != NULL)
8228 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8229 - g->global_gotsym->dynindx)
8230 <= g->global_gotno);
8233 #if 0
8234 /* We want to set the GP value for ld -r. */
8235 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8236 include it, even though we don't process it quite right. (Some
8237 entries are supposed to be merged.) Empirically, we seem to be
8238 better off including it then not. */
8239 if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8240 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8242 if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8244 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8245 if (p->type == bfd_indirect_link_order)
8246 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8247 (*secpp)->link_order_head = NULL;
8248 bfd_section_list_remove (abfd, secpp);
8249 --abfd->section_count;
8251 break;
8255 /* We include .MIPS.options, even though we don't process it quite right.
8256 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8257 to be better off including it than not. */
8258 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8260 if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8262 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8263 if (p->type == bfd_indirect_link_order)
8264 p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8265 (*secpp)->link_order_head = NULL;
8266 bfd_section_list_remove (abfd, secpp);
8267 --abfd->section_count;
8269 break;
8272 #endif
8274 /* Get a value for the GP register. */
8275 if (elf_gp (abfd) == 0)
8277 struct bfd_link_hash_entry *h;
8279 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8280 if (h != NULL && h->type == bfd_link_hash_defined)
8281 elf_gp (abfd) = (h->u.def.value
8282 + h->u.def.section->output_section->vma
8283 + h->u.def.section->output_offset);
8284 else if (info->relocatable)
8286 bfd_vma lo = MINUS_ONE;
8288 /* Find the GP-relative section with the lowest offset. */
8289 for (o = abfd->sections; o != NULL; o = o->next)
8290 if (o->vma < lo
8291 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8292 lo = o->vma;
8294 /* And calculate GP relative to that. */
8295 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8297 else
8299 /* If the relocate_section function needs to do a reloc
8300 involving the GP value, it should make a reloc_dangerous
8301 callback to warn that GP is not defined. */
8305 /* Go through the sections and collect the .reginfo and .mdebug
8306 information. */
8307 reginfo_sec = NULL;
8308 mdebug_sec = NULL;
8309 gptab_data_sec = NULL;
8310 gptab_bss_sec = NULL;
8311 for (o = abfd->sections; o != NULL; o = o->next)
8313 if (strcmp (o->name, ".reginfo") == 0)
8315 memset (&reginfo, 0, sizeof reginfo);
8317 /* We have found the .reginfo section in the output file.
8318 Look through all the link_orders comprising it and merge
8319 the information together. */
8320 for (p = o->link_order_head; p != NULL; p = p->next)
8322 asection *input_section;
8323 bfd *input_bfd;
8324 Elf32_External_RegInfo ext;
8325 Elf32_RegInfo sub;
8327 if (p->type != bfd_indirect_link_order)
8329 if (p->type == bfd_data_link_order)
8330 continue;
8331 abort ();
8334 input_section = p->u.indirect.section;
8335 input_bfd = input_section->owner;
8337 /* The linker emulation code has probably clobbered the
8338 size to be zero bytes. */
8339 if (input_section->_raw_size == 0)
8340 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
8342 if (! bfd_get_section_contents (input_bfd, input_section,
8343 &ext, 0, sizeof ext))
8344 return FALSE;
8346 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8348 reginfo.ri_gprmask |= sub.ri_gprmask;
8349 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8350 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8351 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8352 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8354 /* ri_gp_value is set by the function
8355 mips_elf32_section_processing when the section is
8356 finally written out. */
8358 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8359 elf_link_input_bfd ignores this section. */
8360 input_section->flags &= ~SEC_HAS_CONTENTS;
8363 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8364 BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
8366 /* Skip this section later on (I don't think this currently
8367 matters, but someday it might). */
8368 o->link_order_head = NULL;
8370 reginfo_sec = o;
8373 if (strcmp (o->name, ".mdebug") == 0)
8375 struct extsym_info einfo;
8376 bfd_vma last;
8378 /* We have found the .mdebug section in the output file.
8379 Look through all the link_orders comprising it and merge
8380 the information together. */
8381 symhdr->magic = swap->sym_magic;
8382 /* FIXME: What should the version stamp be? */
8383 symhdr->vstamp = 0;
8384 symhdr->ilineMax = 0;
8385 symhdr->cbLine = 0;
8386 symhdr->idnMax = 0;
8387 symhdr->ipdMax = 0;
8388 symhdr->isymMax = 0;
8389 symhdr->ioptMax = 0;
8390 symhdr->iauxMax = 0;
8391 symhdr->issMax = 0;
8392 symhdr->issExtMax = 0;
8393 symhdr->ifdMax = 0;
8394 symhdr->crfd = 0;
8395 symhdr->iextMax = 0;
8397 /* We accumulate the debugging information itself in the
8398 debug_info structure. */
8399 debug.line = NULL;
8400 debug.external_dnr = NULL;
8401 debug.external_pdr = NULL;
8402 debug.external_sym = NULL;
8403 debug.external_opt = NULL;
8404 debug.external_aux = NULL;
8405 debug.ss = NULL;
8406 debug.ssext = debug.ssext_end = NULL;
8407 debug.external_fdr = NULL;
8408 debug.external_rfd = NULL;
8409 debug.external_ext = debug.external_ext_end = NULL;
8411 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8412 if (mdebug_handle == NULL)
8413 return FALSE;
8415 esym.jmptbl = 0;
8416 esym.cobol_main = 0;
8417 esym.weakext = 0;
8418 esym.reserved = 0;
8419 esym.ifd = ifdNil;
8420 esym.asym.iss = issNil;
8421 esym.asym.st = stLocal;
8422 esym.asym.reserved = 0;
8423 esym.asym.index = indexNil;
8424 last = 0;
8425 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8427 esym.asym.sc = sc[i];
8428 s = bfd_get_section_by_name (abfd, secname[i]);
8429 if (s != NULL)
8431 esym.asym.value = s->vma;
8432 last = s->vma + s->_raw_size;
8434 else
8435 esym.asym.value = last;
8436 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8437 secname[i], &esym))
8438 return FALSE;
8441 for (p = o->link_order_head; p != NULL; p = p->next)
8443 asection *input_section;
8444 bfd *input_bfd;
8445 const struct ecoff_debug_swap *input_swap;
8446 struct ecoff_debug_info input_debug;
8447 char *eraw_src;
8448 char *eraw_end;
8450 if (p->type != bfd_indirect_link_order)
8452 if (p->type == bfd_data_link_order)
8453 continue;
8454 abort ();
8457 input_section = p->u.indirect.section;
8458 input_bfd = input_section->owner;
8460 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8461 || (get_elf_backend_data (input_bfd)
8462 ->elf_backend_ecoff_debug_swap) == NULL)
8464 /* I don't know what a non MIPS ELF bfd would be
8465 doing with a .mdebug section, but I don't really
8466 want to deal with it. */
8467 continue;
8470 input_swap = (get_elf_backend_data (input_bfd)
8471 ->elf_backend_ecoff_debug_swap);
8473 BFD_ASSERT (p->size == input_section->_raw_size);
8475 /* The ECOFF linking code expects that we have already
8476 read in the debugging information and set up an
8477 ecoff_debug_info structure, so we do that now. */
8478 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8479 &input_debug))
8480 return FALSE;
8482 if (! (bfd_ecoff_debug_accumulate
8483 (mdebug_handle, abfd, &debug, swap, input_bfd,
8484 &input_debug, input_swap, info)))
8485 return FALSE;
8487 /* Loop through the external symbols. For each one with
8488 interesting information, try to find the symbol in
8489 the linker global hash table and save the information
8490 for the output external symbols. */
8491 eraw_src = input_debug.external_ext;
8492 eraw_end = (eraw_src
8493 + (input_debug.symbolic_header.iextMax
8494 * input_swap->external_ext_size));
8495 for (;
8496 eraw_src < eraw_end;
8497 eraw_src += input_swap->external_ext_size)
8499 EXTR ext;
8500 const char *name;
8501 struct mips_elf_link_hash_entry *h;
8503 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
8504 if (ext.asym.sc == scNil
8505 || ext.asym.sc == scUndefined
8506 || ext.asym.sc == scSUndefined)
8507 continue;
8509 name = input_debug.ssext + ext.asym.iss;
8510 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
8511 name, FALSE, FALSE, TRUE);
8512 if (h == NULL || h->esym.ifd != -2)
8513 continue;
8515 if (ext.ifd != -1)
8517 BFD_ASSERT (ext.ifd
8518 < input_debug.symbolic_header.ifdMax);
8519 ext.ifd = input_debug.ifdmap[ext.ifd];
8522 h->esym = ext;
8525 /* Free up the information we just read. */
8526 free (input_debug.line);
8527 free (input_debug.external_dnr);
8528 free (input_debug.external_pdr);
8529 free (input_debug.external_sym);
8530 free (input_debug.external_opt);
8531 free (input_debug.external_aux);
8532 free (input_debug.ss);
8533 free (input_debug.ssext);
8534 free (input_debug.external_fdr);
8535 free (input_debug.external_rfd);
8536 free (input_debug.external_ext);
8538 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8539 elf_link_input_bfd ignores this section. */
8540 input_section->flags &= ~SEC_HAS_CONTENTS;
8543 if (SGI_COMPAT (abfd) && info->shared)
8545 /* Create .rtproc section. */
8546 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8547 if (rtproc_sec == NULL)
8549 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8550 | SEC_LINKER_CREATED | SEC_READONLY);
8552 rtproc_sec = bfd_make_section (abfd, ".rtproc");
8553 if (rtproc_sec == NULL
8554 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8555 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
8556 return FALSE;
8559 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8560 info, rtproc_sec,
8561 &debug))
8562 return FALSE;
8565 /* Build the external symbol information. */
8566 einfo.abfd = abfd;
8567 einfo.info = info;
8568 einfo.debug = &debug;
8569 einfo.swap = swap;
8570 einfo.failed = FALSE;
8571 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8572 mips_elf_output_extsym, &einfo);
8573 if (einfo.failed)
8574 return FALSE;
8576 /* Set the size of the .mdebug section. */
8577 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
8579 /* Skip this section later on (I don't think this currently
8580 matters, but someday it might). */
8581 o->link_order_head = NULL;
8583 mdebug_sec = o;
8586 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8588 const char *subname;
8589 unsigned int c;
8590 Elf32_gptab *tab;
8591 Elf32_External_gptab *ext_tab;
8592 unsigned int j;
8594 /* The .gptab.sdata and .gptab.sbss sections hold
8595 information describing how the small data area would
8596 change depending upon the -G switch. These sections
8597 not used in executables files. */
8598 if (! info->relocatable)
8600 for (p = o->link_order_head; p != NULL; p = p->next)
8602 asection *input_section;
8604 if (p->type != bfd_indirect_link_order)
8606 if (p->type == bfd_data_link_order)
8607 continue;
8608 abort ();
8611 input_section = p->u.indirect.section;
8613 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8614 elf_link_input_bfd ignores this section. */
8615 input_section->flags &= ~SEC_HAS_CONTENTS;
8618 /* Skip this section later on (I don't think this
8619 currently matters, but someday it might). */
8620 o->link_order_head = NULL;
8622 /* Really remove the section. */
8623 for (secpp = &abfd->sections;
8624 *secpp != o;
8625 secpp = &(*secpp)->next)
8627 bfd_section_list_remove (abfd, secpp);
8628 --abfd->section_count;
8630 continue;
8633 /* There is one gptab for initialized data, and one for
8634 uninitialized data. */
8635 if (strcmp (o->name, ".gptab.sdata") == 0)
8636 gptab_data_sec = o;
8637 else if (strcmp (o->name, ".gptab.sbss") == 0)
8638 gptab_bss_sec = o;
8639 else
8641 (*_bfd_error_handler)
8642 (_("%s: illegal section name `%s'"),
8643 bfd_get_filename (abfd), o->name);
8644 bfd_set_error (bfd_error_nonrepresentable_section);
8645 return FALSE;
8648 /* The linker script always combines .gptab.data and
8649 .gptab.sdata into .gptab.sdata, and likewise for
8650 .gptab.bss and .gptab.sbss. It is possible that there is
8651 no .sdata or .sbss section in the output file, in which
8652 case we must change the name of the output section. */
8653 subname = o->name + sizeof ".gptab" - 1;
8654 if (bfd_get_section_by_name (abfd, subname) == NULL)
8656 if (o == gptab_data_sec)
8657 o->name = ".gptab.data";
8658 else
8659 o->name = ".gptab.bss";
8660 subname = o->name + sizeof ".gptab" - 1;
8661 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8664 /* Set up the first entry. */
8665 c = 1;
8666 amt = c * sizeof (Elf32_gptab);
8667 tab = bfd_malloc (amt);
8668 if (tab == NULL)
8669 return FALSE;
8670 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8671 tab[0].gt_header.gt_unused = 0;
8673 /* Combine the input sections. */
8674 for (p = o->link_order_head; p != NULL; p = p->next)
8676 asection *input_section;
8677 bfd *input_bfd;
8678 bfd_size_type size;
8679 unsigned long last;
8680 bfd_size_type gpentry;
8682 if (p->type != bfd_indirect_link_order)
8684 if (p->type == bfd_data_link_order)
8685 continue;
8686 abort ();
8689 input_section = p->u.indirect.section;
8690 input_bfd = input_section->owner;
8692 /* Combine the gptab entries for this input section one
8693 by one. We know that the input gptab entries are
8694 sorted by ascending -G value. */
8695 size = bfd_section_size (input_bfd, input_section);
8696 last = 0;
8697 for (gpentry = sizeof (Elf32_External_gptab);
8698 gpentry < size;
8699 gpentry += sizeof (Elf32_External_gptab))
8701 Elf32_External_gptab ext_gptab;
8702 Elf32_gptab int_gptab;
8703 unsigned long val;
8704 unsigned long add;
8705 bfd_boolean exact;
8706 unsigned int look;
8708 if (! (bfd_get_section_contents
8709 (input_bfd, input_section, &ext_gptab, gpentry,
8710 sizeof (Elf32_External_gptab))))
8712 free (tab);
8713 return FALSE;
8716 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8717 &int_gptab);
8718 val = int_gptab.gt_entry.gt_g_value;
8719 add = int_gptab.gt_entry.gt_bytes - last;
8721 exact = FALSE;
8722 for (look = 1; look < c; look++)
8724 if (tab[look].gt_entry.gt_g_value >= val)
8725 tab[look].gt_entry.gt_bytes += add;
8727 if (tab[look].gt_entry.gt_g_value == val)
8728 exact = TRUE;
8731 if (! exact)
8733 Elf32_gptab *new_tab;
8734 unsigned int max;
8736 /* We need a new table entry. */
8737 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8738 new_tab = bfd_realloc (tab, amt);
8739 if (new_tab == NULL)
8741 free (tab);
8742 return FALSE;
8744 tab = new_tab;
8745 tab[c].gt_entry.gt_g_value = val;
8746 tab[c].gt_entry.gt_bytes = add;
8748 /* Merge in the size for the next smallest -G
8749 value, since that will be implied by this new
8750 value. */
8751 max = 0;
8752 for (look = 1; look < c; look++)
8754 if (tab[look].gt_entry.gt_g_value < val
8755 && (max == 0
8756 || (tab[look].gt_entry.gt_g_value
8757 > tab[max].gt_entry.gt_g_value)))
8758 max = look;
8760 if (max != 0)
8761 tab[c].gt_entry.gt_bytes +=
8762 tab[max].gt_entry.gt_bytes;
8764 ++c;
8767 last = int_gptab.gt_entry.gt_bytes;
8770 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8771 elf_link_input_bfd ignores this section. */
8772 input_section->flags &= ~SEC_HAS_CONTENTS;
8775 /* The table must be sorted by -G value. */
8776 if (c > 2)
8777 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8779 /* Swap out the table. */
8780 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8781 ext_tab = bfd_alloc (abfd, amt);
8782 if (ext_tab == NULL)
8784 free (tab);
8785 return FALSE;
8788 for (j = 0; j < c; j++)
8789 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8790 free (tab);
8792 o->_raw_size = c * sizeof (Elf32_External_gptab);
8793 o->contents = (bfd_byte *) ext_tab;
8795 /* Skip this section later on (I don't think this currently
8796 matters, but someday it might). */
8797 o->link_order_head = NULL;
8801 /* Invoke the regular ELF backend linker to do all the work. */
8802 if (!MNAME(abfd,bfd_elf,bfd_final_link) (abfd, info))
8803 return FALSE;
8805 /* Now write out the computed sections. */
8807 if (reginfo_sec != NULL)
8809 Elf32_External_RegInfo ext;
8811 bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
8812 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
8813 return FALSE;
8816 if (mdebug_sec != NULL)
8818 BFD_ASSERT (abfd->output_has_begun);
8819 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
8820 swap, info,
8821 mdebug_sec->filepos))
8822 return FALSE;
8824 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
8827 if (gptab_data_sec != NULL)
8829 if (! bfd_set_section_contents (abfd, gptab_data_sec,
8830 gptab_data_sec->contents,
8831 0, gptab_data_sec->_raw_size))
8832 return FALSE;
8835 if (gptab_bss_sec != NULL)
8837 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
8838 gptab_bss_sec->contents,
8839 0, gptab_bss_sec->_raw_size))
8840 return FALSE;
8843 if (SGI_COMPAT (abfd))
8845 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8846 if (rtproc_sec != NULL)
8848 if (! bfd_set_section_contents (abfd, rtproc_sec,
8849 rtproc_sec->contents,
8850 0, rtproc_sec->_raw_size))
8851 return FALSE;
8855 return TRUE;
8858 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8860 struct mips_mach_extension {
8861 unsigned long extension, base;
8865 /* An array describing how BFD machines relate to one another. The entries
8866 are ordered topologically with MIPS I extensions listed last. */
8868 static const struct mips_mach_extension mips_mach_extensions[] = {
8869 /* MIPS64 extensions. */
8870 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
8871 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
8873 /* MIPS V extensions. */
8874 { bfd_mach_mipsisa64, bfd_mach_mips5 },
8876 /* R10000 extensions. */
8877 { bfd_mach_mips12000, bfd_mach_mips10000 },
8879 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8880 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8881 better to allow vr5400 and vr5500 code to be merged anyway, since
8882 many libraries will just use the core ISA. Perhaps we could add
8883 some sort of ASE flag if this ever proves a problem. */
8884 { bfd_mach_mips5500, bfd_mach_mips5400 },
8885 { bfd_mach_mips5400, bfd_mach_mips5000 },
8887 /* MIPS IV extensions. */
8888 { bfd_mach_mips5, bfd_mach_mips8000 },
8889 { bfd_mach_mips10000, bfd_mach_mips8000 },
8890 { bfd_mach_mips5000, bfd_mach_mips8000 },
8891 { bfd_mach_mips7000, bfd_mach_mips8000 },
8893 /* VR4100 extensions. */
8894 { bfd_mach_mips4120, bfd_mach_mips4100 },
8895 { bfd_mach_mips4111, bfd_mach_mips4100 },
8897 /* MIPS III extensions. */
8898 { bfd_mach_mips8000, bfd_mach_mips4000 },
8899 { bfd_mach_mips4650, bfd_mach_mips4000 },
8900 { bfd_mach_mips4600, bfd_mach_mips4000 },
8901 { bfd_mach_mips4400, bfd_mach_mips4000 },
8902 { bfd_mach_mips4300, bfd_mach_mips4000 },
8903 { bfd_mach_mips4100, bfd_mach_mips4000 },
8904 { bfd_mach_mips4010, bfd_mach_mips4000 },
8906 /* MIPS32 extensions. */
8907 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
8909 /* MIPS II extensions. */
8910 { bfd_mach_mips4000, bfd_mach_mips6000 },
8911 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
8913 /* MIPS I extensions. */
8914 { bfd_mach_mips6000, bfd_mach_mips3000 },
8915 { bfd_mach_mips3900, bfd_mach_mips3000 }
8919 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8921 static bfd_boolean
8922 mips_mach_extends_p (unsigned long base, unsigned long extension)
8924 size_t i;
8926 for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
8927 if (extension == mips_mach_extensions[i].extension)
8928 extension = mips_mach_extensions[i].base;
8930 return extension == base;
8934 /* Return true if the given ELF header flags describe a 32-bit binary. */
8936 static bfd_boolean
8937 mips_32bit_flags_p (flagword flags)
8939 return ((flags & EF_MIPS_32BITMODE) != 0
8940 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
8941 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
8942 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
8943 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
8944 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
8945 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
8949 /* Merge backend specific data from an object file to the output
8950 object file when linking. */
8952 bfd_boolean
8953 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
8955 flagword old_flags;
8956 flagword new_flags;
8957 bfd_boolean ok;
8958 bfd_boolean null_input_bfd = TRUE;
8959 asection *sec;
8961 /* Check if we have the same endianess */
8962 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
8964 (*_bfd_error_handler)
8965 (_("%s: endianness incompatible with that of the selected emulation"),
8966 bfd_archive_filename (ibfd));
8967 return FALSE;
8970 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
8971 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
8972 return TRUE;
8974 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
8976 (*_bfd_error_handler)
8977 (_("%s: ABI is incompatible with that of the selected emulation"),
8978 bfd_archive_filename (ibfd));
8979 return FALSE;
8982 new_flags = elf_elfheader (ibfd)->e_flags;
8983 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
8984 old_flags = elf_elfheader (obfd)->e_flags;
8986 if (! elf_flags_init (obfd))
8988 elf_flags_init (obfd) = TRUE;
8989 elf_elfheader (obfd)->e_flags = new_flags;
8990 elf_elfheader (obfd)->e_ident[EI_CLASS]
8991 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
8993 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
8994 && bfd_get_arch_info (obfd)->the_default)
8996 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
8997 bfd_get_mach (ibfd)))
8998 return FALSE;
9001 return TRUE;
9004 /* Check flag compatibility. */
9006 new_flags &= ~EF_MIPS_NOREORDER;
9007 old_flags &= ~EF_MIPS_NOREORDER;
9009 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9010 doesn't seem to matter. */
9011 new_flags &= ~EF_MIPS_XGOT;
9012 old_flags &= ~EF_MIPS_XGOT;
9014 /* MIPSpro generates ucode info in n64 objects. Again, we should
9015 just be able to ignore this. */
9016 new_flags &= ~EF_MIPS_UCODE;
9017 old_flags &= ~EF_MIPS_UCODE;
9019 if (new_flags == old_flags)
9020 return TRUE;
9022 /* Check to see if the input BFD actually contains any sections.
9023 If not, its flags may not have been initialised either, but it cannot
9024 actually cause any incompatibility. */
9025 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9027 /* Ignore synthetic sections and empty .text, .data and .bss sections
9028 which are automatically generated by gas. */
9029 if (strcmp (sec->name, ".reginfo")
9030 && strcmp (sec->name, ".mdebug")
9031 && ((!strcmp (sec->name, ".text")
9032 || !strcmp (sec->name, ".data")
9033 || !strcmp (sec->name, ".bss"))
9034 && sec->_raw_size != 0))
9036 null_input_bfd = FALSE;
9037 break;
9040 if (null_input_bfd)
9041 return TRUE;
9043 ok = TRUE;
9045 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
9046 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
9048 (*_bfd_error_handler)
9049 (_("%s: warning: linking PIC files with non-PIC files"),
9050 bfd_archive_filename (ibfd));
9051 ok = TRUE;
9054 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
9055 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
9056 if (! (new_flags & EF_MIPS_PIC))
9057 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
9059 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9060 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
9062 /* Compare the ISAs. */
9063 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
9065 (*_bfd_error_handler)
9066 (_("%s: linking 32-bit code with 64-bit code"),
9067 bfd_archive_filename (ibfd));
9068 ok = FALSE;
9070 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9072 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9073 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
9075 /* Copy the architecture info from IBFD to OBFD. Also copy
9076 the 32-bit flag (if set) so that we continue to recognise
9077 OBFD as a 32-bit binary. */
9078 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9079 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9080 elf_elfheader (obfd)->e_flags
9081 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9083 /* Copy across the ABI flags if OBFD doesn't use them
9084 and if that was what caused us to treat IBFD as 32-bit. */
9085 if ((old_flags & EF_MIPS_ABI) == 0
9086 && mips_32bit_flags_p (new_flags)
9087 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9088 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9090 else
9092 /* The ISAs aren't compatible. */
9093 (*_bfd_error_handler)
9094 (_("%s: linking %s module with previous %s modules"),
9095 bfd_archive_filename (ibfd),
9096 bfd_printable_name (ibfd),
9097 bfd_printable_name (obfd));
9098 ok = FALSE;
9102 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9103 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9105 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9106 does set EI_CLASS differently from any 32-bit ABI. */
9107 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9108 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9109 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9111 /* Only error if both are set (to different values). */
9112 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9113 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9114 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9116 (*_bfd_error_handler)
9117 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9118 bfd_archive_filename (ibfd),
9119 elf_mips_abi_name (ibfd),
9120 elf_mips_abi_name (obfd));
9121 ok = FALSE;
9123 new_flags &= ~EF_MIPS_ABI;
9124 old_flags &= ~EF_MIPS_ABI;
9127 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9128 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9130 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9132 new_flags &= ~ EF_MIPS_ARCH_ASE;
9133 old_flags &= ~ EF_MIPS_ARCH_ASE;
9136 /* Warn about any other mismatches */
9137 if (new_flags != old_flags)
9139 (*_bfd_error_handler)
9140 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9141 bfd_archive_filename (ibfd), (unsigned long) new_flags,
9142 (unsigned long) old_flags);
9143 ok = FALSE;
9146 if (! ok)
9148 bfd_set_error (bfd_error_bad_value);
9149 return FALSE;
9152 return TRUE;
9155 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9157 bfd_boolean
9158 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
9160 BFD_ASSERT (!elf_flags_init (abfd)
9161 || elf_elfheader (abfd)->e_flags == flags);
9163 elf_elfheader (abfd)->e_flags = flags;
9164 elf_flags_init (abfd) = TRUE;
9165 return TRUE;
9168 bfd_boolean
9169 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
9171 FILE *file = ptr;
9173 BFD_ASSERT (abfd != NULL && ptr != NULL);
9175 /* Print normal ELF private data. */
9176 _bfd_elf_print_private_bfd_data (abfd, ptr);
9178 /* xgettext:c-format */
9179 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9181 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9182 fprintf (file, _(" [abi=O32]"));
9183 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9184 fprintf (file, _(" [abi=O64]"));
9185 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9186 fprintf (file, _(" [abi=EABI32]"));
9187 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9188 fprintf (file, _(" [abi=EABI64]"));
9189 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9190 fprintf (file, _(" [abi unknown]"));
9191 else if (ABI_N32_P (abfd))
9192 fprintf (file, _(" [abi=N32]"));
9193 else if (ABI_64_P (abfd))
9194 fprintf (file, _(" [abi=64]"));
9195 else
9196 fprintf (file, _(" [no abi set]"));
9198 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9199 fprintf (file, _(" [mips1]"));
9200 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9201 fprintf (file, _(" [mips2]"));
9202 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9203 fprintf (file, _(" [mips3]"));
9204 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9205 fprintf (file, _(" [mips4]"));
9206 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9207 fprintf (file, _(" [mips5]"));
9208 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9209 fprintf (file, _(" [mips32]"));
9210 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9211 fprintf (file, _(" [mips64]"));
9212 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9213 fprintf (file, _(" [mips32r2]"));
9214 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
9215 fprintf (file, _(" [mips64r2]"));
9216 else
9217 fprintf (file, _(" [unknown ISA]"));
9219 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9220 fprintf (file, _(" [mdmx]"));
9222 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9223 fprintf (file, _(" [mips16]"));
9225 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9226 fprintf (file, _(" [32bitmode]"));
9227 else
9228 fprintf (file, _(" [not 32bitmode]"));
9230 fputc ('\n', file);
9232 return TRUE;
9235 struct bfd_elf_special_section const _bfd_mips_elf_special_sections[]=
9237 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9238 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9239 { ".lit4", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9240 { ".lit8", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9241 { ".ucode", 6, 0, SHT_MIPS_UCODE, 0 },
9242 { ".mdebug", 7, 0, SHT_MIPS_DEBUG, 0 },
9243 { NULL, 0, 0, 0, 0 }