projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add - before rms to be more portable.
[deliverable/binutils-gdb.git] / bfd / elf32-mips.c
CommitLineData
252b5132 1/* MIPS-specific support for 32-bit ELF
be3ccd9c
KH		 2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
252b5132
RH		 4
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 <ian@cygnus.com>.
103186c6
MM		 7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
f7cb7d68
UC		 9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
252b5132
RH		 11
12This file is part of BFD, the Binary File Descriptor library.
13
14This program is free software; you can redistribute it and/or modify
15it under the terms of the GNU General Public License as published by
16the Free Software Foundation; either version 2 of the License, or
17(at your option) any later version.
18
19This program is distributed in the hope that it will be useful,
20but WITHOUT ANY WARRANTY; without even the implied warranty of
21MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22GNU General Public License for more details.
23
24You should have received a copy of the GNU General Public License
25along with this program; if not, write to the Free Software
26Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27
28/* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
29 different MIPS ELF from other targets. This matters when linking.
30 This file supports both, switching at runtime. */
31
32#include "bfd.h"
33#include "sysdep.h"
34#include "libbfd.h"
35#include "bfdlink.h"
36#include "genlink.h"
37#include "elf-bfd.h"
38#include "elf/mips.h"
39
40/* Get the ECOFF swapping routines. */
41#include "coff/sym.h"
42#include "coff/symconst.h"
43#include "coff/internal.h"
44#include "coff/ecoff.h"
45#include "coff/mips.h"
23e2c83b 46#define ECOFF_SIGNED_32
252b5132
RH		 47#include "ecoffswap.h"
48
7403cb63
MM		 49/* This structure is used to hold .got information when linking. It
50 is stored in the tdata field of the bfd_elf_section_data structure. */
51
be3ccd9c 52struct mips_got_info {
7403cb63
MM		 53 /* The global symbol in the GOT with the lowest index in the dynamic
54 symbol table. */
55 struct elf_link_hash_entry *global_gotsym;
b3be9b46
RH		 56 /* The number of global .got entries. */
57 unsigned int global_gotno;
7403cb63
MM		 58 /* The number of local .got entries. */
59 unsigned int local_gotno;
60 /* The number of local .got entries we have used. */
61 unsigned int assigned_gotno;
62};
63
64/* The MIPS ELF linker needs additional information for each symbol in
65 the global hash table. */
66
be3ccd9c 67struct mips_elf_link_hash_entry {
7403cb63
MM		 68 struct elf_link_hash_entry root;
69
70 /* External symbol information. */
71 EXTR esym;
72
a3c7651d 73 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
be3ccd9c 74 this symbol. */
a3c7651d 75 unsigned int possibly_dynamic_relocs;
7403cb63
MM		 76
77 /* The index of the first dynamic relocation (in the .rel.dyn
78 section) against this symbol. */
79 unsigned int min_dyn_reloc_index;
80
81 /* If there is a stub that 32 bit functions should use to call this
82 16 bit function, this points to the section containing the stub. */
83 asection *fn_stub;
84
85 /* Whether we need the fn_stub; this is set if this symbol appears
86 in any relocs other than a 16 bit call. */
87 boolean need_fn_stub;
88
89 /* If there is a stub that 16 bit functions should use to call this
90 32 bit function, this points to the section containing the stub. */
91 asection *call_stub;
92
93 /* This is like the call_stub field, but it is used if the function
94 being called returns a floating point value. */
95 asection *call_fp_stub;
96};
97
252b5132
RH		 98static bfd_reloc_status_type mips32_64bit_reloc
99 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
100static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
101 PARAMS ((bfd *, bfd_reloc_code_real_type));
c9b3cbf3
RH		 102static reloc_howto_type *mips_rtype_to_howto
103 PARAMS ((unsigned int));
252b5132
RH		 104static void mips_info_to_howto_rel
105 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
3f830999
MM		 106static void mips_info_to_howto_rela
107 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
252b5132
RH		 108static void bfd_mips_elf32_swap_gptab_in
109 PARAMS ((bfd *, const Elf32_External_gptab *, Elf32_gptab *));
110static void bfd_mips_elf32_swap_gptab_out
111 PARAMS ((bfd *, const Elf32_gptab *, Elf32_External_gptab *));
86033394 112#if 0
be3ccd9c 113static void bfd_mips_elf_swap_msym_in
c6142e5d 114 PARAMS ((bfd *, const Elf32_External_Msym *, Elf32_Internal_Msym *));
86033394 115#endif
c6142e5d
MM		 116static void bfd_mips_elf_swap_msym_out
117 PARAMS ((bfd *, const Elf32_Internal_Msym *, Elf32_External_Msym *));
252b5132 118static boolean mips_elf_sym_is_global PARAMS ((bfd *, asymbol *));
252b5132
RH		 119static boolean mips_elf_create_procedure_table
120 PARAMS ((PTR, bfd *, struct bfd_link_info *, asection *,
121 struct ecoff_debug_info *));
252b5132
RH		 122static INLINE int elf_mips_isa PARAMS ((flagword));
123static INLINE int elf_mips_mach PARAMS ((flagword));
103186c6 124static INLINE char* elf_mips_abi_name PARAMS ((bfd *));
252b5132
RH		 125static boolean mips_elf_is_local_label_name
126 PARAMS ((bfd *, const char *));
127static struct bfd_hash_entry *mips_elf_link_hash_newfunc
128 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
252b5132 129static int gptab_compare PARAMS ((const void *, const void *));
252b5132
RH		 130static bfd_reloc_status_type mips16_jump_reloc
131 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
132static bfd_reloc_status_type mips16_gprel_reloc
133 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
252b5132
RH		 134static boolean mips_elf_create_compact_rel_section
135 PARAMS ((bfd *, struct bfd_link_info *));
136static boolean mips_elf_create_got_section
137 PARAMS ((bfd *, struct bfd_link_info *));
252b5132
RH		 138static bfd_reloc_status_type mips_elf_final_gp
139 PARAMS ((bfd *, asymbol *, boolean, char **, bfd_vma *));
140static bfd_byte *elf32_mips_get_relocated_section_contents
141 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
142 bfd_byte *, boolean, asymbol **));
be3ccd9c 143static asection *mips_elf_create_msym_section
c6142e5d 144 PARAMS ((bfd *));
be3ccd9c 145static void mips_elf_irix6_finish_dynamic_symbol
7403cb63
MM		 146 PARAMS ((bfd *, const char *, Elf_Internal_Sym *));
147static bfd_vma mips_elf_sign_extend PARAMS ((bfd_vma, int));
148static boolean mips_elf_overflow_p PARAMS ((bfd_vma, int));
149static bfd_vma mips_elf_high PARAMS ((bfd_vma));
150static bfd_vma mips_elf_higher PARAMS ((bfd_vma));
151static bfd_vma mips_elf_highest PARAMS ((bfd_vma));
152static bfd_vma mips_elf_global_got_index
153 PARAMS ((bfd *, struct elf_link_hash_entry *));
154static bfd_vma mips_elf_local_got_index
155 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma));
156static bfd_vma mips_elf_got_offset_from_index
157 PARAMS ((bfd *, bfd *, bfd_vma));
be3ccd9c 158static boolean mips_elf_record_global_got_symbol
7403cb63
MM		 159 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *,
160 struct mips_got_info *));
161static bfd_vma mips_elf_got_page
162 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *));
bb2d6cd7 163static const Elf_Internal_Rela *mips_elf_next_relocation
be3ccd9c 164 PARAMS ((unsigned int, const Elf_Internal_Rela *,
bb2d6cd7 165 const Elf_Internal_Rela *));
7403cb63
MM		 166static bfd_reloc_status_type mips_elf_calculate_relocation
167 PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
103186c6 168 const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
197b9ca0
MM		 169 Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
170 boolean *));
7403cb63 171static bfd_vma mips_elf_obtain_contents
103186c6 172 PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
197b9ca0 173static boolean mips_elf_perform_relocation
be3ccd9c 174 PARAMS ((struct bfd_link_info *, reloc_howto_type *,
e53bd91b 175 const Elf_Internal_Rela *, bfd_vma,
197b9ca0 176 bfd *, asection *, bfd_byte *, boolean));
7403cb63 177static boolean mips_elf_assign_gp PARAMS ((bfd *, bfd_vma *));
be3ccd9c 178static boolean mips_elf_sort_hash_table_f
7403cb63 179 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
be3ccd9c 180static boolean mips_elf_sort_hash_table
b3be9b46 181 PARAMS ((struct bfd_link_info *, unsigned long));
7403cb63 182static asection * mips_elf_got_section PARAMS ((bfd *));
be3ccd9c 183static struct mips_got_info *mips_elf_got_info
7403cb63 184 PARAMS ((bfd *, asection **));
6387d602 185static boolean mips_elf_local_relocation_p
b305ef96 186 PARAMS ((bfd *, const Elf_Internal_Rela *, asection **, boolean));
be3ccd9c 187static bfd_vma mips_elf_create_local_got_entry
7403cb63 188 PARAMS ((bfd *, struct mips_got_info *, asection *, bfd_vma));
be3ccd9c 189static bfd_vma mips_elf_got16_entry
b305ef96 190 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, boolean));
be3ccd9c 191static boolean mips_elf_create_dynamic_relocation
103186c6 192 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
7b1f1231 193 struct mips_elf_link_hash_entry *, asection *,
5af5b85b 194 bfd_vma, bfd_vma *, asection *, boolean local_p));
be3ccd9c 195static void mips_elf_allocate_dynamic_relocations
103186c6 196 PARAMS ((bfd *, unsigned int));
be3ccd9c 197static boolean mips_elf_stub_section_p
197b9ca0 198 PARAMS ((bfd *, asection *));
adb76a3e
UC		 199static int sort_dynamic_relocs
200 PARAMS ((const void *, const void *));
252b5132 201
f7cb7d68
UC		 202extern const bfd_target bfd_elf32_tradbigmips_vec;
203
a94a7c1c 204/* The level of IRIX compatibility we're striving for. */
252b5132 205
a94a7c1c
MM		 206typedef enum {
207 ict_none,
208 ict_irix5,
209 ict_irix6
210} irix_compat_t;
211
adb76a3e
UC		 212/* This will be used when we sort the dynamic relocation records. */
213static bfd *reldyn_sorting_bfd;
214
a94a7c1c
MM		 215/* Nonzero if ABFD is using the N32 ABI. */
216
217#define ABI_N32_P(abfd) \
218 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
219
5e38c3b8
MM		 220/* Nonzero if ABFD is using the 64-bit ABI. FIXME: This is never
221 true, yet. */
222#define ABI_64_P(abfd) \
223 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
224
f7cb7d68 225/* Depending on the target vector we generate some version of Irix
be3ccd9c 226 executables or "normal" MIPS ELF ABI executables. */
a94a7c1c
MM		 227
228#define IRIX_COMPAT(abfd) \
f7cb7d68
UC		 229 (abfd->xvec == &bfd_elf32_tradbigmips_vec ? ict_none : \
230 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
a94a7c1c
MM		 231
232/* Whether we are trying to be compatible with IRIX at all. */
233
234#define SGI_COMPAT(abfd) \
235 (IRIX_COMPAT (abfd) != ict_none)
252b5132 236
c6142e5d
MM		 237/* The name of the msym section. */
238#define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
239
303f629d
MM		 240/* The name of the srdata section. */
241#define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
242
243/* The name of the options section. */
244#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
245 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
246
247/* The name of the stub section. */
248#define MIPS_ELF_STUB_SECTION_NAME(abfd) \
249 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
250
103186c6
MM		 251/* The name of the dynamic relocation section. */
252#define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
253
254/* The size of an external REL relocation. */
255#define MIPS_ELF_REL_SIZE(abfd) \
256 (get_elf_backend_data (abfd)->s->sizeof_rel)
257
258/* The size of an external dynamic table entry. */
259#define MIPS_ELF_DYN_SIZE(abfd) \
260 (get_elf_backend_data (abfd)->s->sizeof_dyn)
261
262/* The size of a GOT entry. */
263#define MIPS_ELF_GOT_SIZE(abfd) \
264 (get_elf_backend_data (abfd)->s->arch_size / 8)
265
266/* The size of a symbol-table entry. */
267#define MIPS_ELF_SYM_SIZE(abfd) \
268 (get_elf_backend_data (abfd)->s->sizeof_sym)
269
270/* The default alignment for sections, as a power of two. */
271#define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
272 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
273
274/* Get word-sized data. */
275#define MIPS_ELF_GET_WORD(abfd, ptr) \
276 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
277
278/* Put out word-sized data. */
279#define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
280 (ABI_64_P (abfd) \
281 ? bfd_put_64 (abfd, val, ptr) \
282 : bfd_put_32 (abfd, val, ptr))
283
284/* Add a dynamic symbol table-entry. */
9ebbd33e 285#ifdef BFD64
103186c6
MM		 286#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
287 (ABI_64_P (elf_hash_table (info)->dynobj) \
288 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
289 : bfd_elf32_add_dynamic_entry (info, tag, val))
9ebbd33e
MM		 290#else
291#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
292 (ABI_64_P (elf_hash_table (info)->dynobj) \
e049a0de
ILT		 293 ? (abort (), false) \
294 : bfd_elf32_add_dynamic_entry (info, tag, val))
9ebbd33e 295#endif
103186c6 296
252b5132
RH		 297/* The number of local .got entries we reserve. */
298#define MIPS_RESERVED_GOTNO (2)
299
300/* Instructions which appear in a stub. For some reason the stub is
301 slightly different on an SGI system. */
302#define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
103186c6
MM		 303#define STUB_LW(abfd) \
304 (SGI_COMPAT (abfd) \
305 ? (ABI_64_P (abfd) \
306 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
307 : 0x8f998010) /* lw t9,0x8010(gp) */ \
f7cb7d68
UC		 308 : 0x8f998010) /* lw t9,0x8000(gp) */
309#define STUB_MOVE(abfd) \
310 (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821) /* move t7,ra */
311#define STUB_JALR 0x0320f809 /* jal t9 */
312#define STUB_LI16(abfd) \
313 (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000) /* ori t8,zero,0 */
252b5132
RH		 314#define MIPS_FUNCTION_STUB_SIZE (16)
315
316#if 0
317/* We no longer try to identify particular sections for the .dynsym
318 section. When we do, we wind up crashing if there are other random
319 sections with relocations. */
320
321/* Names of sections which appear in the .dynsym section in an Irix 5
322 executable. */
323
be3ccd9c 324static const char * const mips_elf_dynsym_sec_names[] = {
252b5132
RH		 325 ".text",
326 ".init",
327 ".fini",
328 ".data",
329 ".rodata",
330 ".sdata",
331 ".sbss",
332 ".bss",
333 NULL
334};
335
336#define SIZEOF_MIPS_DYNSYM_SECNAMES \
337 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
338
339/* The number of entries in mips_elf_dynsym_sec_names which go in the
340 text segment. */
341
342#define MIPS_TEXT_DYNSYM_SECNO (3)
343
344#endif /* 0 */
345
346/* The names of the runtime procedure table symbols used on Irix 5. */
347
be3ccd9c 348static const char * const mips_elf_dynsym_rtproc_names[] = {
252b5132
RH		 349 "_procedure_table",
350 "_procedure_string_table",
351 "_procedure_table_size",
352 NULL
353};
354
355/* These structures are used to generate the .compact_rel section on
356 Irix 5. */
357
be3ccd9c 358typedef struct {
252b5132
RH		 359 unsigned long id1; /* Always one? */
360 unsigned long num; /* Number of compact relocation entries. */
361 unsigned long id2; /* Always two? */
362 unsigned long offset; /* The file offset of the first relocation. */
363 unsigned long reserved0; /* Zero? */
364 unsigned long reserved1; /* Zero? */
365} Elf32_compact_rel;
366
be3ccd9c 367typedef struct {
252b5132
RH		 368 bfd_byte id1[4];
369 bfd_byte num[4];
370 bfd_byte id2[4];
371 bfd_byte offset[4];
372 bfd_byte reserved0[4];
373 bfd_byte reserved1[4];
374} Elf32_External_compact_rel;
375
be3ccd9c 376typedef struct {
252b5132 377 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
be3ccd9c 378 unsigned int rtype : 4; /* Relocation types. See below. */
252b5132
RH		 379 unsigned int dist2to : 8;
380 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
381 unsigned long konst; /* KONST field. See below. */
382 unsigned long vaddr; /* VADDR to be relocated. */
383} Elf32_crinfo;
384
be3ccd9c 385typedef struct {
252b5132 386 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
be3ccd9c 387 unsigned int rtype : 4; /* Relocation types. See below. */
252b5132
RH		 388 unsigned int dist2to : 8;
389 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
390 unsigned long konst; /* KONST field. See below. */
391} Elf32_crinfo2;
392
be3ccd9c 393typedef struct {
252b5132
RH		 394 bfd_byte info[4];
395 bfd_byte konst[4];
396 bfd_byte vaddr[4];
397} Elf32_External_crinfo;
398
be3ccd9c 399typedef struct {
252b5132
RH		 400 bfd_byte info[4];
401 bfd_byte konst[4];
402} Elf32_External_crinfo2;
403
404/* These are the constants used to swap the bitfields in a crinfo. */
405
406#define CRINFO_CTYPE (0x1)
407#define CRINFO_CTYPE_SH (31)
408#define CRINFO_RTYPE (0xf)
409#define CRINFO_RTYPE_SH (27)
410#define CRINFO_DIST2TO (0xff)
411#define CRINFO_DIST2TO_SH (19)
412#define CRINFO_RELVADDR (0x7ffff)
413#define CRINFO_RELVADDR_SH (0)
414
415/* A compact relocation info has long (3 words) or short (2 words)
416 formats. A short format doesn't have VADDR field and relvaddr
417 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
418#define CRF_MIPS_LONG 1
419#define CRF_MIPS_SHORT 0
420
421/* There are 4 types of compact relocation at least. The value KONST
422 has different meaning for each type:
423
424 (type) (konst)
425 CT_MIPS_REL32 Address in data
426 CT_MIPS_WORD Address in word (XXX)
427 CT_MIPS_GPHI_LO GP - vaddr
428 CT_MIPS_JMPAD Address to jump
429 */
430
431#define CRT_MIPS_REL32 0xa
432#define CRT_MIPS_WORD 0xb
433#define CRT_MIPS_GPHI_LO 0xc
434#define CRT_MIPS_JMPAD 0xd
435
436#define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
437#define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
438#define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
439#define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
440
441static void bfd_elf32_swap_compact_rel_out
442 PARAMS ((bfd *, const Elf32_compact_rel *, Elf32_External_compact_rel *));
443static void bfd_elf32_swap_crinfo_out
444 PARAMS ((bfd *, const Elf32_crinfo *, Elf32_External_crinfo *));
445
446#define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
447
3f830999
MM		 448/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
449 from smaller values. Start with zero, widen, *then* decrement. */
450#define MINUS_ONE (((bfd_vma)0) - 1)
451
be3ccd9c 452static reloc_howto_type elf_mips_howto_table[] = {
252b5132
RH		 453 /* No relocation. */
454 HOWTO (R_MIPS_NONE, /* type */
455 0, /* rightshift */
456 0, /* size (0 = byte, 1 = short, 2 = long) */
457 0, /* bitsize */
458 false, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_dont, /* complain_on_overflow */
461 bfd_elf_generic_reloc, /* special_function */
462 "R_MIPS_NONE", /* name */
463 false, /* partial_inplace */
464 0, /* src_mask */
465 0, /* dst_mask */
466 false), /* pcrel_offset */
467
468 /* 16 bit relocation. */
469 HOWTO (R_MIPS_16, /* type */
470 0, /* rightshift */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 false, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_bitfield, /* complain_on_overflow */
476 bfd_elf_generic_reloc, /* special_function */
477 "R_MIPS_16", /* name */
478 true, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 false), /* pcrel_offset */
482
483 /* 32 bit relocation. */
484 HOWTO (R_MIPS_32, /* type */
485 0, /* rightshift */
486 2, /* size (0 = byte, 1 = short, 2 = long) */
487 32, /* bitsize */
488 false, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_bitfield, /* complain_on_overflow */
491 bfd_elf_generic_reloc, /* special_function */
492 "R_MIPS_32", /* name */
493 true, /* partial_inplace */
494 0xffffffff, /* src_mask */
495 0xffffffff, /* dst_mask */
496 false), /* pcrel_offset */
497
498 /* 32 bit symbol relative relocation. */
499 HOWTO (R_MIPS_REL32, /* type */
500 0, /* rightshift */
501 2, /* size (0 = byte, 1 = short, 2 = long) */
502 32, /* bitsize */
503 false, /* pc_relative */
504 0, /* bitpos */
505 complain_overflow_bitfield, /* complain_on_overflow */
506 bfd_elf_generic_reloc, /* special_function */
507 "R_MIPS_REL32", /* name */
508 true, /* partial_inplace */
509 0xffffffff, /* src_mask */
510 0xffffffff, /* dst_mask */
511 false), /* pcrel_offset */
512
513 /* 26 bit branch address. */
514 HOWTO (R_MIPS_26, /* type */
515 2, /* rightshift */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
517 26, /* bitsize */
518 false, /* pc_relative */
519 0, /* bitpos */
520 complain_overflow_dont, /* complain_on_overflow */
521 /* This needs complex overflow
522 detection, because the upper four
523 bits must match the PC. */
524 bfd_elf_generic_reloc, /* special_function */
525 "R_MIPS_26", /* name */
526 true, /* partial_inplace */
527 0x3ffffff, /* src_mask */
528 0x3ffffff, /* dst_mask */
529 false), /* pcrel_offset */
530
531 /* High 16 bits of symbol value. */
532 HOWTO (R_MIPS_HI16, /* type */
533 0, /* rightshift */
534 2, /* size (0 = byte, 1 = short, 2 = long) */
535 16, /* bitsize */
536 false, /* pc_relative */
537 0, /* bitpos */
538 complain_overflow_dont, /* complain_on_overflow */
539 _bfd_mips_elf_hi16_reloc, /* special_function */
540 "R_MIPS_HI16", /* name */
541 true, /* partial_inplace */
542 0xffff, /* src_mask */
543 0xffff, /* dst_mask */
544 false), /* pcrel_offset */
545
546 /* Low 16 bits of symbol value. */
547 HOWTO (R_MIPS_LO16, /* type */
548 0, /* rightshift */
549 2, /* size (0 = byte, 1 = short, 2 = long) */
550 16, /* bitsize */
551 false, /* pc_relative */
552 0, /* bitpos */
553 complain_overflow_dont, /* complain_on_overflow */
554 _bfd_mips_elf_lo16_reloc, /* special_function */
555 "R_MIPS_LO16", /* name */
556 true, /* partial_inplace */
557 0xffff, /* src_mask */
558 0xffff, /* dst_mask */
559 false), /* pcrel_offset */
560
561 /* GP relative reference. */
562 HOWTO (R_MIPS_GPREL16, /* type */
563 0, /* rightshift */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
565 16, /* bitsize */
566 false, /* pc_relative */
567 0, /* bitpos */
568 complain_overflow_signed, /* complain_on_overflow */
569 _bfd_mips_elf_gprel16_reloc, /* special_function */
570 "R_MIPS_GPREL16", /* name */
571 true, /* partial_inplace */
572 0xffff, /* src_mask */
573 0xffff, /* dst_mask */
574 false), /* pcrel_offset */
575
576 /* Reference to literal section. */
577 HOWTO (R_MIPS_LITERAL, /* type */
578 0, /* rightshift */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
580 16, /* bitsize */
581 false, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_signed, /* complain_on_overflow */
584 _bfd_mips_elf_gprel16_reloc, /* special_function */
585 "R_MIPS_LITERAL", /* name */
586 true, /* partial_inplace */
587 0xffff, /* src_mask */
588 0xffff, /* dst_mask */
589 false), /* pcrel_offset */
590
591 /* Reference to global offset table. */
592 HOWTO (R_MIPS_GOT16, /* type */
593 0, /* rightshift */
594 2, /* size (0 = byte, 1 = short, 2 = long) */
595 16, /* bitsize */
596 false, /* pc_relative */
597 0, /* bitpos */
598 complain_overflow_signed, /* complain_on_overflow */
599 _bfd_mips_elf_got16_reloc, /* special_function */
600 "R_MIPS_GOT16", /* name */
601 false, /* partial_inplace */
b944b044 602 0xffff, /* src_mask */
252b5132
RH		 603 0xffff, /* dst_mask */
604 false), /* pcrel_offset */
605
606 /* 16 bit PC relative reference. */
607 HOWTO (R_MIPS_PC16, /* type */
608 0, /* rightshift */
609 2, /* size (0 = byte, 1 = short, 2 = long) */
610 16, /* bitsize */
611 true, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_signed, /* complain_on_overflow */
614 bfd_elf_generic_reloc, /* special_function */
615 "R_MIPS_PC16", /* name */
616 true, /* partial_inplace */
617 0xffff, /* src_mask */
618 0xffff, /* dst_mask */
bb2d6cd7 619 true), /* pcrel_offset */
252b5132
RH		 620
621 /* 16 bit call through global offset table. */
252b5132
RH		 622 HOWTO (R_MIPS_CALL16, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 16, /* bitsize */
626 false, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_signed, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_MIPS_CALL16", /* name */
631 false, /* partial_inplace */
b944b044 632 0xffff, /* src_mask */
252b5132
RH		 633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
635
636 /* 32 bit GP relative reference. */
637 HOWTO (R_MIPS_GPREL32, /* type */
638 0, /* rightshift */
639 2, /* size (0 = byte, 1 = short, 2 = long) */
640 32, /* bitsize */
641 false, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 _bfd_mips_elf_gprel32_reloc, /* special_function */
645 "R_MIPS_GPREL32", /* name */
646 true, /* partial_inplace */
647 0xffffffff, /* src_mask */
648 0xffffffff, /* dst_mask */
649 false), /* pcrel_offset */
650
651 /* The remaining relocs are defined on Irix 5, although they are
652 not defined by the ABI. */
5f771d47
ILT		 653 EMPTY_HOWTO (13),
654 EMPTY_HOWTO (14),
655 EMPTY_HOWTO (15),
252b5132
RH		 656
657 /* A 5 bit shift field. */
658 HOWTO (R_MIPS_SHIFT5, /* type */
659 0, /* rightshift */
660 2, /* size (0 = byte, 1 = short, 2 = long) */
661 5, /* bitsize */
662 false, /* pc_relative */
663 6, /* bitpos */
664 complain_overflow_bitfield, /* complain_on_overflow */
665 bfd_elf_generic_reloc, /* special_function */
666 "R_MIPS_SHIFT5", /* name */
667 true, /* partial_inplace */
668 0x000007c0, /* src_mask */
669 0x000007c0, /* dst_mask */
670 false), /* pcrel_offset */
671
672 /* A 6 bit shift field. */
673 /* FIXME: This is not handled correctly; a special function is
674 needed to put the most significant bit in the right place. */
675 HOWTO (R_MIPS_SHIFT6, /* type */
676 0, /* rightshift */
677 2, /* size (0 = byte, 1 = short, 2 = long) */
678 6, /* bitsize */
679 false, /* pc_relative */
680 6, /* bitpos */
681 complain_overflow_bitfield, /* complain_on_overflow */
682 bfd_elf_generic_reloc, /* special_function */
683 "R_MIPS_SHIFT6", /* name */
684 true, /* partial_inplace */
685 0x000007c4, /* src_mask */
686 0x000007c4, /* dst_mask */
687 false), /* pcrel_offset */
688
a3c7651d 689 /* A 64 bit relocation. */
252b5132
RH		 690 HOWTO (R_MIPS_64, /* type */
691 0, /* rightshift */
a3c7651d
MM		 692 4, /* size (0 = byte, 1 = short, 2 = long) */
693 64, /* bitsize */
252b5132
RH		 694 false, /* pc_relative */
695 0, /* bitpos */
696 complain_overflow_bitfield, /* complain_on_overflow */
697 mips32_64bit_reloc, /* special_function */
698 "R_MIPS_64", /* name */
699 true, /* partial_inplace */
a3c7651d
MM		 700 MINUS_ONE, /* src_mask */
701 MINUS_ONE, /* dst_mask */
252b5132
RH		 702 false), /* pcrel_offset */
703
704 /* Displacement in the global offset table. */
252b5132
RH		 705 HOWTO (R_MIPS_GOT_DISP, /* type */
706 0, /* rightshift */
707 2, /* size (0 = byte, 1 = short, 2 = long) */
708 16, /* bitsize */
709 false, /* pc_relative */
710 0, /* bitpos */
711 complain_overflow_bitfield, /* complain_on_overflow */
712 bfd_elf_generic_reloc, /* special_function */
713 "R_MIPS_GOT_DISP", /* name */
714 true, /* partial_inplace */
715 0x0000ffff, /* src_mask */
716 0x0000ffff, /* dst_mask */
717 false), /* pcrel_offset */
718
719 /* Displacement to page pointer in the global offset table. */
252b5132
RH		 720 HOWTO (R_MIPS_GOT_PAGE, /* type */
721 0, /* rightshift */
722 2, /* size (0 = byte, 1 = short, 2 = long) */
723 16, /* bitsize */
724 false, /* pc_relative */
725 0, /* bitpos */
726 complain_overflow_bitfield, /* complain_on_overflow */
727 bfd_elf_generic_reloc, /* special_function */
728 "R_MIPS_GOT_PAGE", /* name */
729 true, /* partial_inplace */
730 0x0000ffff, /* src_mask */
731 0x0000ffff, /* dst_mask */
732 false), /* pcrel_offset */
733
734 /* Offset from page pointer in the global offset table. */
252b5132
RH		 735 HOWTO (R_MIPS_GOT_OFST, /* type */
736 0, /* rightshift */
737 2, /* size (0 = byte, 1 = short, 2 = long) */
738 16, /* bitsize */
739 false, /* pc_relative */
740 0, /* bitpos */
741 complain_overflow_bitfield, /* complain_on_overflow */
742 bfd_elf_generic_reloc, /* special_function */
743 "R_MIPS_GOT_OFST", /* name */
744 true, /* partial_inplace */
745 0x0000ffff, /* src_mask */
746 0x0000ffff, /* dst_mask */
747 false), /* pcrel_offset */
748
749 /* High 16 bits of displacement in global offset table. */
252b5132
RH		 750 HOWTO (R_MIPS_GOT_HI16, /* type */
751 0, /* rightshift */
752 2, /* size (0 = byte, 1 = short, 2 = long) */
753 16, /* bitsize */
754 false, /* pc_relative */
755 0, /* bitpos */
756 complain_overflow_dont, /* complain_on_overflow */
757 bfd_elf_generic_reloc, /* special_function */
758 "R_MIPS_GOT_HI16", /* name */
759 true, /* partial_inplace */
760 0x0000ffff, /* src_mask */
761 0x0000ffff, /* dst_mask */
762 false), /* pcrel_offset */
763
764 /* Low 16 bits of displacement in global offset table. */
252b5132
RH		 765 HOWTO (R_MIPS_GOT_LO16, /* type */
766 0, /* rightshift */
767 2, /* size (0 = byte, 1 = short, 2 = long) */
768 16, /* bitsize */
769 false, /* pc_relative */
770 0, /* bitpos */
771 complain_overflow_dont, /* complain_on_overflow */
772 bfd_elf_generic_reloc, /* special_function */
773 "R_MIPS_GOT_LO16", /* name */
774 true, /* partial_inplace */
775 0x0000ffff, /* src_mask */
776 0x0000ffff, /* dst_mask */
777 false), /* pcrel_offset */
778
3f830999 779 /* 64 bit subtraction. Used in the N32 ABI. */
3f830999
MM		 780 HOWTO (R_MIPS_SUB, /* type */
781 0, /* rightshift */
782 4, /* size (0 = byte, 1 = short, 2 = long) */
783 64, /* bitsize */
784 false, /* pc_relative */
785 0, /* bitpos */
786 complain_overflow_bitfield, /* complain_on_overflow */
787 bfd_elf_generic_reloc, /* special_function */
788 "R_MIPS_SUB", /* name */
789 true, /* partial_inplace */
790 MINUS_ONE, /* src_mask */
791 MINUS_ONE, /* dst_mask */
792 false), /* pcrel_offset */
252b5132
RH		 793
794 /* Used to cause the linker to insert and delete instructions? */
5f771d47
ILT		 795 EMPTY_HOWTO (R_MIPS_INSERT_A),
796 EMPTY_HOWTO (R_MIPS_INSERT_B),
797 EMPTY_HOWTO (R_MIPS_DELETE),
252b5132 798
103186c6
MM		 799 /* Get the higher value of a 64 bit addend. */
800 HOWTO (R_MIPS_HIGHER, /* type */
801 0, /* rightshift */
802 2, /* size (0 = byte, 1 = short, 2 = long) */
803 16, /* bitsize */
804 false, /* pc_relative */
805 0, /* bitpos */
806 complain_overflow_dont, /* complain_on_overflow */
807 bfd_elf_generic_reloc, /* special_function */
808 "R_MIPS_HIGHER", /* name */
809 true, /* partial_inplace */
810 0, /* src_mask */
811 0xffff, /* dst_mask */
812 false), /* pcrel_offset */
813
814 /* Get the highest value of a 64 bit addend. */
815 HOWTO (R_MIPS_HIGHEST, /* type */
816 0, /* rightshift */
817 2, /* size (0 = byte, 1 = short, 2 = long) */
818 16, /* bitsize */
819 false, /* pc_relative */
820 0, /* bitpos */
821 complain_overflow_dont, /* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "R_MIPS_HIGHEST", /* name */
824 true, /* partial_inplace */
825 0, /* src_mask */
826 0xffff, /* dst_mask */
827 false), /* pcrel_offset */
252b5132
RH		 828
829 /* High 16 bits of displacement in global offset table. */
252b5132
RH		 830 HOWTO (R_MIPS_CALL_HI16, /* type */
831 0, /* rightshift */
832 2, /* size (0 = byte, 1 = short, 2 = long) */
833 16, /* bitsize */
834 false, /* pc_relative */
835 0, /* bitpos */
836 complain_overflow_dont, /* complain_on_overflow */
837 bfd_elf_generic_reloc, /* special_function */
838 "R_MIPS_CALL_HI16", /* name */
839 true, /* partial_inplace */
840 0x0000ffff, /* src_mask */
841 0x0000ffff, /* dst_mask */
842 false), /* pcrel_offset */
843
844 /* Low 16 bits of displacement in global offset table. */
252b5132
RH		 845 HOWTO (R_MIPS_CALL_LO16, /* type */
846 0, /* rightshift */
847 2, /* size (0 = byte, 1 = short, 2 = long) */
848 16, /* bitsize */
849 false, /* pc_relative */
850 0, /* bitpos */
851 complain_overflow_dont, /* complain_on_overflow */
852 bfd_elf_generic_reloc, /* special_function */
853 "R_MIPS_CALL_LO16", /* name */
854 true, /* partial_inplace */
855 0x0000ffff, /* src_mask */
856 0x0000ffff, /* dst_mask */
857 false), /* pcrel_offset */
858
7403cb63
MM		 859 /* Section displacement. */
860 HOWTO (R_MIPS_SCN_DISP, /* type */
861 0, /* rightshift */
862 2, /* size (0 = byte, 1 = short, 2 = long) */
863 32, /* bitsize */
864 false, /* pc_relative */
865 0, /* bitpos */
866 complain_overflow_dont, /* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "R_MIPS_SCN_DISP", /* name */
869 false, /* partial_inplace */
870 0xffffffff, /* src_mask */
871 0xffffffff, /* dst_mask */
872 false), /* pcrel_offset */
873
5f771d47
ILT		 874 EMPTY_HOWTO (R_MIPS_REL16),
875 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
876 EMPTY_HOWTO (R_MIPS_PJUMP),
877 EMPTY_HOWTO (R_MIPS_RELGOT),
d2905643 878
be3ccd9c 879 /* Protected jump conversion. This is an optimization hint. No
d2905643
MM		 880 relocation is required for correctness. */
881 HOWTO (R_MIPS_JALR, /* type */
882 0, /* rightshift */
883 0, /* size (0 = byte, 1 = short, 2 = long) */
884 0, /* bitsize */
885 false, /* pc_relative */
886 0, /* bitpos */
887 complain_overflow_dont, /* complain_on_overflow */
888 bfd_elf_generic_reloc, /* special_function */
889 "R_MIPS_JALR", /* name */
890 false, /* partial_inplace */
891 0x00000000, /* src_mask */
892 0x00000000, /* dst_mask */
893 false), /* pcrel_offset */
252b5132
RH		 894};
895
896/* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
897 is a hack to make the linker think that we need 64 bit values. */
898static reloc_howto_type elf_mips_ctor64_howto =
899 HOWTO (R_MIPS_64, /* type */
900 0, /* rightshift */
901 4, /* size (0 = byte, 1 = short, 2 = long) */
902 32, /* bitsize */
903 false, /* pc_relative */
904 0, /* bitpos */
905 complain_overflow_signed, /* complain_on_overflow */
906 mips32_64bit_reloc, /* special_function */
907 "R_MIPS_64", /* name */
908 true, /* partial_inplace */
909 0xffffffff, /* src_mask */
910 0xffffffff, /* dst_mask */
911 false); /* pcrel_offset */
912
913/* The reloc used for the mips16 jump instruction. */
914static reloc_howto_type elf_mips16_jump_howto =
915 HOWTO (R_MIPS16_26, /* type */
916 2, /* rightshift */
917 2, /* size (0 = byte, 1 = short, 2 = long) */
918 26, /* bitsize */
919 false, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_dont, /* complain_on_overflow */
922 /* This needs complex overflow
923 detection, because the upper four
924 bits must match the PC. */
925 mips16_jump_reloc, /* special_function */
926 "R_MIPS16_26", /* name */
927 true, /* partial_inplace */
928 0x3ffffff, /* src_mask */
929 0x3ffffff, /* dst_mask */
930 false); /* pcrel_offset */
931
b7233c24 932/* The reloc used for the mips16 gprel instruction. */
252b5132
RH		 933static reloc_howto_type elf_mips16_gprel_howto =
934 HOWTO (R_MIPS16_GPREL, /* type */
935 0, /* rightshift */
936 2, /* size (0 = byte, 1 = short, 2 = long) */
937 16, /* bitsize */
938 false, /* pc_relative */
939 0, /* bitpos */
940 complain_overflow_signed, /* complain_on_overflow */
941 mips16_gprel_reloc, /* special_function */
942 "R_MIPS16_GPREL", /* name */
943 true, /* partial_inplace */
b7233c24
MM		 944 0x07ff001f, /* src_mask */
945 0x07ff001f, /* dst_mask */
252b5132
RH		 946 false); /* pcrel_offset */
947
bb2d6cd7
GK		 948/* GNU extensions for embedded-pic. */
949/* High 16 bits of symbol value, pc-relative. */
950static reloc_howto_type elf_mips_gnu_rel_hi16 =
951 HOWTO (R_MIPS_GNU_REL_HI16, /* type */
952 0, /* rightshift */
953 2, /* size (0 = byte, 1 = short, 2 = long) */
954 16, /* bitsize */
955 true, /* pc_relative */
956 0, /* bitpos */
957 complain_overflow_dont, /* complain_on_overflow */
958 _bfd_mips_elf_hi16_reloc, /* special_function */
959 "R_MIPS_GNU_REL_HI16", /* name */
960 true, /* partial_inplace */
961 0xffff, /* src_mask */
962 0xffff, /* dst_mask */
963 true); /* pcrel_offset */
964
965/* Low 16 bits of symbol value, pc-relative. */
966static reloc_howto_type elf_mips_gnu_rel_lo16 =
967 HOWTO (R_MIPS_GNU_REL_LO16, /* type */
968 0, /* rightshift */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
970 16, /* bitsize */
971 true, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_dont, /* complain_on_overflow */
974 _bfd_mips_elf_lo16_reloc, /* special_function */
975 "R_MIPS_GNU_REL_LO16", /* name */
976 true, /* partial_inplace */
977 0xffff, /* src_mask */
978 0xffff, /* dst_mask */
979 true); /* pcrel_offset */
980
981/* 16 bit offset for pc-relative branches. */
982static reloc_howto_type elf_mips_gnu_rel16_s2 =
983 HOWTO (R_MIPS_GNU_REL16_S2, /* type */
984 2, /* rightshift */
985 2, /* size (0 = byte, 1 = short, 2 = long) */
986 16, /* bitsize */
987 true, /* pc_relative */
988 0, /* bitpos */
989 complain_overflow_signed, /* complain_on_overflow */
990 bfd_elf_generic_reloc, /* special_function */
991 "R_MIPS_GNU_REL16_S2", /* name */
992 true, /* partial_inplace */
993 0xffff, /* src_mask */
994 0xffff, /* dst_mask */
995 true); /* pcrel_offset */
996
997/* 64 bit pc-relative. */
998static reloc_howto_type elf_mips_gnu_pcrel64 =
999 HOWTO (R_MIPS_PC64, /* type */
1000 0, /* rightshift */
1001 4, /* size (0 = byte, 1 = short, 2 = long) */
1002 64, /* bitsize */
1003 true, /* pc_relative */
1004 0, /* bitpos */
1005 complain_overflow_signed, /* complain_on_overflow */
1006 bfd_elf_generic_reloc, /* special_function */
1007 "R_MIPS_PC64", /* name */
1008 true, /* partial_inplace */
1009 MINUS_ONE, /* src_mask */
1010 MINUS_ONE, /* dst_mask */
1011 true); /* pcrel_offset */
1012
1013/* 32 bit pc-relative. */
1014static reloc_howto_type elf_mips_gnu_pcrel32 =
1015 HOWTO (R_MIPS_PC32, /* type */
1016 0, /* rightshift */
1017 2, /* size (0 = byte, 1 = short, 2 = long) */
1018 32, /* bitsize */
1019 true, /* pc_relative */
1020 0, /* bitpos */
1021 complain_overflow_signed, /* complain_on_overflow */
1022 bfd_elf_generic_reloc, /* special_function */
1023 "R_MIPS_PC32", /* name */
1024 true, /* partial_inplace */
1025 0xffffffff, /* src_mask */
1026 0xffffffff, /* dst_mask */
1027 true); /* pcrel_offset */
1028
252b5132
RH		 1029/* GNU extension to record C++ vtable hierarchy */
1030static reloc_howto_type elf_mips_gnu_vtinherit_howto =
1031 HOWTO (R_MIPS_GNU_VTINHERIT, /* type */
1032 0, /* rightshift */
1033 2, /* size (0 = byte, 1 = short, 2 = long) */
1034 0, /* bitsize */
1035 false, /* pc_relative */
1036 0, /* bitpos */
1037 complain_overflow_dont, /* complain_on_overflow */
1038 NULL, /* special_function */
1039 "R_MIPS_GNU_VTINHERIT", /* name */
1040 false, /* partial_inplace */
1041 0, /* src_mask */
1042 0, /* dst_mask */
1043 false); /* pcrel_offset */
1044
1045/* GNU extension to record C++ vtable member usage */
1046static reloc_howto_type elf_mips_gnu_vtentry_howto =
1047 HOWTO (R_MIPS_GNU_VTENTRY, /* type */
1048 0, /* rightshift */
1049 2, /* size (0 = byte, 1 = short, 2 = long) */
1050 0, /* bitsize */
1051 false, /* pc_relative */
1052 0, /* bitpos */
1053 complain_overflow_dont, /* complain_on_overflow */
1054 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1055 "R_MIPS_GNU_VTENTRY", /* name */
1056 false, /* partial_inplace */
1057 0, /* src_mask */
1058 0, /* dst_mask */
1059 false); /* pcrel_offset */
1060
1061/* Do a R_MIPS_HI16 relocation. This has to be done in combination
1062 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
1063 the HI16. Here we just save the information we need; we do the
1064 actual relocation when we see the LO16. MIPS ELF requires that the
1065 LO16 immediately follow the HI16. As a GNU extension, we permit an
1066 arbitrary number of HI16 relocs to be associated with a single LO16
1067 reloc. This extension permits gcc to output the HI and LO relocs
1068 itself. */
1069
be3ccd9c 1070struct mips_hi16 {
252b5132
RH		 1071 struct mips_hi16 *next;
1072 bfd_byte *addr;
1073 bfd_vma addend;
1074};
1075
1076/* FIXME: This should not be a static variable. */
1077
1078static struct mips_hi16 *mips_hi16_list;
1079
1080bfd_reloc_status_type
1081_bfd_mips_elf_hi16_reloc (abfd,
1082 reloc_entry,
1083 symbol,
1084 data,
1085 input_section,
1086 output_bfd,
1087 error_message)
5f771d47 1088 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1089 arelent *reloc_entry;
1090 asymbol *symbol;
1091 PTR data;
1092 asection *input_section;
1093 bfd *output_bfd;
1094 char **error_message;
1095{
1096 bfd_reloc_status_type ret;
1097 bfd_vma relocation;
1098 struct mips_hi16 *n;
1099
1100 /* If we're relocating, and this an external symbol, we don't want
1101 to change anything. */
1102 if (output_bfd != (bfd *) NULL
1103 && (symbol->flags & BSF_SECTION_SYM) == 0
1104 && reloc_entry->addend == 0)
1105 {
1106 reloc_entry->address += input_section->output_offset;
1107 return bfd_reloc_ok;
1108 }
1109
1110 ret = bfd_reloc_ok;
1111
1112 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1113 {
1114 boolean relocateable;
1115 bfd_vma gp;
1116
1117 if (ret == bfd_reloc_undefined)
1118 abort ();
1119
1120 if (output_bfd != NULL)
1121 relocateable = true;
1122 else
1123 {
1124 relocateable = false;
1125 output_bfd = symbol->section->output_section->owner;
1126 }
1127
1128 ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1129 error_message, &gp);
1130 if (ret != bfd_reloc_ok)
1131 return ret;
1132
1133 relocation = gp - reloc_entry->address;
1134 }
1135 else
1136 {
1137 if (bfd_is_und_section (symbol->section)
1138 && output_bfd == (bfd *) NULL)
1139 ret = bfd_reloc_undefined;
1140
1141 if (bfd_is_com_section (symbol->section))
1142 relocation = 0;
1143 else
1144 relocation = symbol->value;
1145 }
1146
1147 relocation += symbol->section->output_section->vma;
1148 relocation += symbol->section->output_offset;
1149 relocation += reloc_entry->addend;
1150
1151 if (reloc_entry->address > input_section->_cooked_size)
1152 return bfd_reloc_outofrange;
1153
1154 /* Save the information, and let LO16 do the actual relocation. */
1155 n = (struct mips_hi16 *) bfd_malloc (sizeof *n);
1156 if (n == NULL)
1157 return bfd_reloc_outofrange;
1158 n->addr = (bfd_byte *) data + reloc_entry->address;
1159 n->addend = relocation;
1160 n->next = mips_hi16_list;
1161 mips_hi16_list = n;
1162
1163 if (output_bfd != (bfd *) NULL)
1164 reloc_entry->address += input_section->output_offset;
1165
1166 return ret;
1167}
1168
1169/* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1170 inplace relocation; this function exists in order to do the
1171 R_MIPS_HI16 relocation described above. */
1172
1173bfd_reloc_status_type
1174_bfd_mips_elf_lo16_reloc (abfd,
1175 reloc_entry,
1176 symbol,
1177 data,
1178 input_section,
1179 output_bfd,
1180 error_message)
1181 bfd *abfd;
1182 arelent *reloc_entry;
1183 asymbol *symbol;
1184 PTR data;
1185 asection *input_section;
1186 bfd *output_bfd;
1187 char **error_message;
1188{
1189 arelent gp_disp_relent;
1190
1191 if (mips_hi16_list != NULL)
1192 {
1193 struct mips_hi16 *l;
1194
1195 l = mips_hi16_list;
1196 while (l != NULL)
1197 {
1198 unsigned long insn;
1199 unsigned long val;
1200 unsigned long vallo;
1201 struct mips_hi16 *next;
1202
1203 /* Do the HI16 relocation. Note that we actually don't need
1204 to know anything about the LO16 itself, except where to
1205 find the low 16 bits of the addend needed by the LO16. */
1206 insn = bfd_get_32 (abfd, l->addr);
1207 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1208 & 0xffff);
1209 val = ((insn & 0xffff) << 16) + vallo;
1210 val += l->addend;
1211
1212 /* The low order 16 bits are always treated as a signed
1213 value. Therefore, a negative value in the low order bits
1214 requires an adjustment in the high order bits. We need
1215 to make this adjustment in two ways: once for the bits we
1216 took from the data, and once for the bits we are putting
1217 back in to the data. */
1218 if ((vallo & 0x8000) != 0)
1219 val -= 0x10000;
1220 if ((val & 0x8000) != 0)
1221 val += 0x10000;
1222
be3ccd9c 1223 insn = (insn & ~0xffff) | ((val >> 16) & 0xffff);
252b5132
RH		 1224 bfd_put_32 (abfd, insn, l->addr);
1225
1226 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1227 {
1228 gp_disp_relent = *reloc_entry;
1229 reloc_entry = &gp_disp_relent;
1230 reloc_entry->addend = l->addend;
1231 }
1232
1233 next = l->next;
1234 free (l);
1235 l = next;
1236 }
1237
1238 mips_hi16_list = NULL;
1239 }
1240 else if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1241 {
1242 bfd_reloc_status_type ret;
1243 bfd_vma gp, relocation;
1244
1245 /* FIXME: Does this case ever occur? */
1246
1247 ret = mips_elf_final_gp (output_bfd, symbol, true, error_message, &gp);
1248 if (ret != bfd_reloc_ok)
1249 return ret;
1250
1251 relocation = gp - reloc_entry->address;
1252 relocation += symbol->section->output_section->vma;
1253 relocation += symbol->section->output_offset;
1254 relocation += reloc_entry->addend;
1255
1256 if (reloc_entry->address > input_section->_cooked_size)
1257 return bfd_reloc_outofrange;
1258
1259 gp_disp_relent = *reloc_entry;
1260 reloc_entry = &gp_disp_relent;
1261 reloc_entry->addend = relocation - 4;
1262 }
1263
1264 /* Now do the LO16 reloc in the usual way. */
1265 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1266 input_section, output_bfd, error_message);
1267}
1268
1269/* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1270 table used for PIC code. If the symbol is an external symbol, the
1271 instruction is modified to contain the offset of the appropriate
1272 entry in the global offset table. If the symbol is a section
1273 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1274 addends are combined to form the real addend against the section
1275 symbol; the GOT16 is modified to contain the offset of an entry in
1276 the global offset table, and the LO16 is modified to offset it
1277 appropriately. Thus an offset larger than 16 bits requires a
1278 modified value in the global offset table.
1279
1280 This implementation suffices for the assembler, but the linker does
1281 not yet know how to create global offset tables. */
1282
1283bfd_reloc_status_type
1284_bfd_mips_elf_got16_reloc (abfd,
1285 reloc_entry,
1286 symbol,
1287 data,
1288 input_section,
1289 output_bfd,
1290 error_message)
1291 bfd *abfd;
1292 arelent *reloc_entry;
1293 asymbol *symbol;
1294 PTR data;
1295 asection *input_section;
1296 bfd *output_bfd;
1297 char **error_message;
1298{
1299 /* If we're relocating, and this an external symbol, we don't want
1300 to change anything. */
1301 if (output_bfd != (bfd *) NULL
1302 && (symbol->flags & BSF_SECTION_SYM) == 0
1303 && reloc_entry->addend == 0)
1304 {
1305 reloc_entry->address += input_section->output_offset;
1306 return bfd_reloc_ok;
1307 }
1308
1309 /* If we're relocating, and this is a local symbol, we can handle it
1310 just like HI16. */
1311 if (output_bfd != (bfd *) NULL
1312 && (symbol->flags & BSF_SECTION_SYM) != 0)
1313 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1314 input_section, output_bfd, error_message);
1315
1316 abort ();
1317}
1318
7403cb63
MM		 1319/* Set the GP value for OUTPUT_BFD. Returns false if this is a
1320 dangerous relocation. */
1321
1322static boolean
1323mips_elf_assign_gp (output_bfd, pgp)
1324 bfd *output_bfd;
1325 bfd_vma *pgp;
1326{
1327 unsigned int count;
1328 asymbol **sym;
1329 unsigned int i;
1330
1331 /* If we've already figured out what GP will be, just return it. */
1332 *pgp = _bfd_get_gp_value (output_bfd);
1333 if (*pgp)
1334 return true;
1335
1336 count = bfd_get_symcount (output_bfd);
1337 sym = bfd_get_outsymbols (output_bfd);
1338
1339 /* The linker script will have created a symbol named `_gp' with the
1340 appropriate value. */
1341 if (sym == (asymbol **) NULL)
1342 i = count;
1343 else
1344 {
1345 for (i = 0; i < count; i++, sym++)
1346 {
1347 register CONST char *name;
1348
1349 name = bfd_asymbol_name (*sym);
1350 if (*name == '_' && strcmp (name, "_gp") == 0)
1351 {
1352 *pgp = bfd_asymbol_value (*sym);
1353 _bfd_set_gp_value (output_bfd, *pgp);
1354 break;
1355 }
1356 }
1357 }
1358
1359 if (i >= count)
1360 {
1361 /* Only get the error once. */
1362 *pgp = 4;
1363 _bfd_set_gp_value (output_bfd, *pgp);
1364 return false;
1365 }
1366
1367 return true;
1368}
1369
252b5132
RH		 1370/* We have to figure out the gp value, so that we can adjust the
1371 symbol value correctly. We look up the symbol _gp in the output
1372 BFD. If we can't find it, we're stuck. We cache it in the ELF
1373 target data. We don't need to adjust the symbol value for an
1374 external symbol if we are producing relocateable output. */
1375
1376static bfd_reloc_status_type
1377mips_elf_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1378 bfd *output_bfd;
1379 asymbol *symbol;
1380 boolean relocateable;
1381 char **error_message;
1382 bfd_vma *pgp;
1383{
1384 if (bfd_is_und_section (symbol->section)
1385 && ! relocateable)
1386 {
1387 *pgp = 0;
1388 return bfd_reloc_undefined;
1389 }
1390
1391 *pgp = _bfd_get_gp_value (output_bfd);
1392 if (*pgp == 0
1393 && (! relocateable
1394 || (symbol->flags & BSF_SECTION_SYM) != 0))
1395 {
1396 if (relocateable)
1397 {
1398 /* Make up a value. */
1399 *pgp = symbol->section->output_section->vma + 0x4000;
1400 _bfd_set_gp_value (output_bfd, *pgp);
1401 }
7403cb63 1402 else if (!mips_elf_assign_gp (output_bfd, pgp))
252b5132 1403 {
7403cb63
MM		 1404 *error_message =
1405 (char *) _("GP relative relocation when _gp not defined");
1406 return bfd_reloc_dangerous;
252b5132
RH		 1407 }
1408 }
1409
1410 return bfd_reloc_ok;
1411}
1412
1413/* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1414 become the offset from the gp register. This function also handles
1415 R_MIPS_LITERAL relocations, although those can be handled more
1416 cleverly because the entries in the .lit8 and .lit4 sections can be
1417 merged. */
1418
1419static bfd_reloc_status_type gprel16_with_gp PARAMS ((bfd *, asymbol *,
1420 arelent *, asection *,
1421 boolean, PTR, bfd_vma));
1422
1423bfd_reloc_status_type
1424_bfd_mips_elf_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1425 output_bfd, error_message)
1426 bfd *abfd;
1427 arelent *reloc_entry;
1428 asymbol *symbol;
1429 PTR data;
1430 asection *input_section;
1431 bfd *output_bfd;
1432 char **error_message;
1433{
1434 boolean relocateable;
1435 bfd_reloc_status_type ret;
1436 bfd_vma gp;
1437
1438 /* If we're relocating, and this is an external symbol with no
1439 addend, we don't want to change anything. We will only have an
1440 addend if this is a newly created reloc, not read from an ELF
1441 file. */
1442 if (output_bfd != (bfd *) NULL
1443 && (symbol->flags & BSF_SECTION_SYM) == 0
1444 && reloc_entry->addend == 0)
1445 {
1446 reloc_entry->address += input_section->output_offset;
1447 return bfd_reloc_ok;
1448 }
1449
1450 if (output_bfd != (bfd *) NULL)
1451 relocateable = true;
1452 else
1453 {
1454 relocateable = false;
1455 output_bfd = symbol->section->output_section->owner;
1456 }
1457
1458 ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1459 &gp);
1460 if (ret != bfd_reloc_ok)
1461 return ret;
1462
1463 return gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1464 relocateable, data, gp);
1465}
1466
1467static bfd_reloc_status_type
1468gprel16_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1469 gp)
1470 bfd *abfd;
1471 asymbol *symbol;
1472 arelent *reloc_entry;
1473 asection *input_section;
1474 boolean relocateable;
1475 PTR data;
1476 bfd_vma gp;
1477{
1478 bfd_vma relocation;
1479 unsigned long insn;
1480 unsigned long val;
1481
1482 if (bfd_is_com_section (symbol->section))
1483 relocation = 0;
1484 else
1485 relocation = symbol->value;
1486
1487 relocation += symbol->section->output_section->vma;
1488 relocation += symbol->section->output_offset;
1489
1490 if (reloc_entry->address > input_section->_cooked_size)
1491 return bfd_reloc_outofrange;
1492
1493 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1494
1495 /* Set val to the offset into the section or symbol. */
1496 if (reloc_entry->howto->src_mask == 0)
1497 {
1498 /* This case occurs with the 64-bit MIPS ELF ABI. */
1499 val = reloc_entry->addend;
1500 }
1501 else
1502 {
1503 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
1504 if (val & 0x8000)
1505 val -= 0x10000;
1506 }
1507
1508 /* Adjust val for the final section location and GP value. If we
1509 are producing relocateable output, we don't want to do this for
1510 an external symbol. */
1511 if (! relocateable
1512 || (symbol->flags & BSF_SECTION_SYM) != 0)
1513 val += relocation - gp;
1514
be3ccd9c 1515 insn = (insn & ~0xffff) | (val & 0xffff);
252b5132
RH		 1516 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1517
1518 if (relocateable)
1519 reloc_entry->address += input_section->output_offset;
1520
1521 /* Make sure it fit in 16 bits. */
43cbcf28 1522 if ((long) val >= 0x8000 || (long) val < -0x8000)
252b5132
RH		 1523 return bfd_reloc_overflow;
1524
1525 return bfd_reloc_ok;
1526}
1527
1528/* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1529 from the gp register? XXX */
1530
1531static bfd_reloc_status_type gprel32_with_gp PARAMS ((bfd *, asymbol *,
1532 arelent *, asection *,
1533 boolean, PTR, bfd_vma));
1534
1535bfd_reloc_status_type
1536_bfd_mips_elf_gprel32_reloc (abfd,
1537 reloc_entry,
1538 symbol,
1539 data,
1540 input_section,
1541 output_bfd,
1542 error_message)
1543 bfd *abfd;
1544 arelent *reloc_entry;
1545 asymbol *symbol;
1546 PTR data;
1547 asection *input_section;
1548 bfd *output_bfd;
1549 char **error_message;
1550{
1551 boolean relocateable;
1552 bfd_reloc_status_type ret;
1553 bfd_vma gp;
1554
1555 /* If we're relocating, and this is an external symbol with no
1556 addend, we don't want to change anything. We will only have an
1557 addend if this is a newly created reloc, not read from an ELF
1558 file. */
1559 if (output_bfd != (bfd *) NULL
1560 && (symbol->flags & BSF_SECTION_SYM) == 0
1561 && reloc_entry->addend == 0)
1562 {
1563 *error_message = (char *)
1564 _("32bits gp relative relocation occurs for an external symbol");
1565 return bfd_reloc_outofrange;
1566 }
1567
1568 if (output_bfd != (bfd *) NULL)
1569 {
1570 relocateable = true;
1571 gp = _bfd_get_gp_value (output_bfd);
1572 }
1573 else
1574 {
1575 relocateable = false;
1576 output_bfd = symbol->section->output_section->owner;
1577
1578 ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1579 error_message, &gp);
1580 if (ret != bfd_reloc_ok)
1581 return ret;
1582 }
1583
1584 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
1585 relocateable, data, gp);
1586}
1587
1588static bfd_reloc_status_type
1589gprel32_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1590 gp)
1591 bfd *abfd;
1592 asymbol *symbol;
1593 arelent *reloc_entry;
1594 asection *input_section;
1595 boolean relocateable;
1596 PTR data;
1597 bfd_vma gp;
1598{
1599 bfd_vma relocation;
1600 unsigned long val;
1601
1602 if (bfd_is_com_section (symbol->section))
1603 relocation = 0;
1604 else
1605 relocation = symbol->value;
1606
1607 relocation += symbol->section->output_section->vma;
1608 relocation += symbol->section->output_offset;
1609
1610 if (reloc_entry->address > input_section->_cooked_size)
1611 return bfd_reloc_outofrange;
1612
1613 if (reloc_entry->howto->src_mask == 0)
1614 {
1615 /* This case arises with the 64-bit MIPS ELF ABI. */
1616 val = 0;
1617 }
1618 else
1619 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1620
1621 /* Set val to the offset into the section or symbol. */
1622 val += reloc_entry->addend;
1623
1624 /* Adjust val for the final section location and GP value. If we
1625 are producing relocateable output, we don't want to do this for
1626 an external symbol. */
1627 if (! relocateable
1628 || (symbol->flags & BSF_SECTION_SYM) != 0)
1629 val += relocation - gp;
1630
1631 bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
1632
1633 if (relocateable)
1634 reloc_entry->address += input_section->output_offset;
1635
1636 return bfd_reloc_ok;
1637}
1638
1639/* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1640 generated when addreses are 64 bits. The upper 32 bits are a simle
1641 sign extension. */
1642
1643static bfd_reloc_status_type
1644mips32_64bit_reloc (abfd, reloc_entry, symbol, data, input_section,
1645 output_bfd, error_message)
1646 bfd *abfd;
1647 arelent *reloc_entry;
1648 asymbol *symbol;
1649 PTR data;
1650 asection *input_section;
1651 bfd *output_bfd;
1652 char **error_message;
1653{
1654 bfd_reloc_status_type r;
1655 arelent reloc32;
1656 unsigned long val;
1657 bfd_size_type addr;
1658
1659 r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1660 input_section, output_bfd, error_message);
1661 if (r != bfd_reloc_continue)
1662 return r;
1663
1664 /* Do a normal 32 bit relocation on the lower 32 bits. */
1665 reloc32 = *reloc_entry;
1666 if (bfd_big_endian (abfd))
1667 reloc32.address += 4;
1668 reloc32.howto = &elf_mips_howto_table[R_MIPS_32];
1669 r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1670 output_bfd, error_message);
1671
1672 /* Sign extend into the upper 32 bits. */
1673 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1674 if ((val & 0x80000000) != 0)
1675 val = 0xffffffff;
1676 else
1677 val = 0;
1678 addr = reloc_entry->address;
1679 if (bfd_little_endian (abfd))
1680 addr += 4;
1681 bfd_put_32 (abfd, val, (bfd_byte *) data + addr);
1682
1683 return r;
1684}
1685
1686/* Handle a mips16 jump. */
1687
1688static bfd_reloc_status_type
1689mips16_jump_reloc (abfd, reloc_entry, symbol, data, input_section,
1690 output_bfd, error_message)
5f771d47 1691 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1692 arelent *reloc_entry;
1693 asymbol *symbol;
5f771d47 1694 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 1695 asection *input_section;
1696 bfd *output_bfd;
5f771d47 1697 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 1698{
1699 if (output_bfd != (bfd *) NULL
1700 && (symbol->flags & BSF_SECTION_SYM) == 0
1701 && reloc_entry->addend == 0)
1702 {
1703 reloc_entry->address += input_section->output_offset;
1704 return bfd_reloc_ok;
1705 }
1706
1707 /* FIXME. */
1708 {
1709 static boolean warned;
1710
1711 if (! warned)
1712 (*_bfd_error_handler)
1713 (_("Linking mips16 objects into %s format is not supported"),
1714 bfd_get_target (input_section->output_section->owner));
1715 warned = true;
1716 }
1717
1718 return bfd_reloc_undefined;
1719}
1720
1721/* Handle a mips16 GP relative reloc. */
1722
1723static bfd_reloc_status_type
1724mips16_gprel_reloc (abfd, reloc_entry, symbol, data, input_section,
1725 output_bfd, error_message)
1726 bfd *abfd;
1727 arelent *reloc_entry;
1728 asymbol *symbol;
1729 PTR data;
1730 asection *input_section;
1731 bfd *output_bfd;
1732 char **error_message;
1733{
1734 boolean relocateable;
1735 bfd_reloc_status_type ret;
1736 bfd_vma gp;
1737 unsigned short extend, insn;
1738 unsigned long final;
1739
1740 /* If we're relocating, and this is an external symbol with no
1741 addend, we don't want to change anything. We will only have an
1742 addend if this is a newly created reloc, not read from an ELF
1743 file. */
1744 if (output_bfd != NULL
1745 && (symbol->flags & BSF_SECTION_SYM) == 0
1746 && reloc_entry->addend == 0)
1747 {
1748 reloc_entry->address += input_section->output_offset;
1749 return bfd_reloc_ok;
1750 }
1751
1752 if (output_bfd != NULL)
1753 relocateable = true;
1754 else
1755 {
1756 relocateable = false;
1757 output_bfd = symbol->section->output_section->owner;
1758 }
1759
1760 ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1761 &gp);
1762 if (ret != bfd_reloc_ok)
1763 return ret;
1764
1765 if (reloc_entry->address > input_section->_cooked_size)
1766 return bfd_reloc_outofrange;
1767
1768 /* Pick up the mips16 extend instruction and the real instruction. */
1769 extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1770 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1771
1772 /* Stuff the current addend back as a 32 bit value, do the usual
1773 relocation, and then clean up. */
1774 bfd_put_32 (abfd,
1775 (((extend & 0x1f) << 11)
1776 | (extend & 0x7e0)
1777 | (insn & 0x1f)),
1778 (bfd_byte *) data + reloc_entry->address);
1779
1780 ret = gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1781 relocateable, data, gp);
1782
1783 final = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1784 bfd_put_16 (abfd,
1785 ((extend & 0xf800)
1786 | ((final >> 11) & 0x1f)
1787 | (final & 0x7e0)),
1788 (bfd_byte *) data + reloc_entry->address);
1789 bfd_put_16 (abfd,
1790 ((insn & 0xffe0)
1791 | (final & 0x1f)),
1792 (bfd_byte *) data + reloc_entry->address + 2);
1793
1794 return ret;
1795}
1796
1797/* Return the ISA for a MIPS e_flags value. */
1798
1799static INLINE int
1800elf_mips_isa (flags)
1801 flagword flags;
1802{
1803 switch (flags & EF_MIPS_ARCH)
1804 {
1805 case E_MIPS_ARCH_1:
1806 return 1;
1807 case E_MIPS_ARCH_2:
1808 return 2;
1809 case E_MIPS_ARCH_3:
1810 return 3;
1811 case E_MIPS_ARCH_4:
1812 return 4;
84ea6cf2
NC		 1813 case E_MIPS_ARCH_5:
1814 return 5;
e7af610e
NC		 1815 case E_MIPS_ARCH_32:
1816 return 32;
84ea6cf2
NC		 1817 case E_MIPS_ARCH_64:
1818 return 64;
252b5132
RH		 1819 }
1820 return 4;
1821}
1822
1823/* Return the MACH for a MIPS e_flags value. */
1824
1825static INLINE int
1826elf_mips_mach (flags)
1827 flagword flags;
1828{
1829 switch (flags & EF_MIPS_MACH)
1830 {
1831 case E_MIPS_MACH_3900:
1832 return bfd_mach_mips3900;
1833
1834 case E_MIPS_MACH_4010:
1835 return bfd_mach_mips4010;
1836
1837 case E_MIPS_MACH_4100:
1838 return bfd_mach_mips4100;
1839
1840 case E_MIPS_MACH_4111:
1841 return bfd_mach_mips4111;
1842
1843 case E_MIPS_MACH_4650:
1844 return bfd_mach_mips4650;
1845
e7af610e
NC		 1846 case E_MIPS_MACH_MIPS32_4K:
1847 return bfd_mach_mips32_4k;
156c2f8b 1848
c6c98b38
NC		 1849 case E_MIPS_MACH_SB1:
1850 return bfd_mach_mips_sb1;
1851
252b5132
RH		 1852 default:
1853 switch (flags & EF_MIPS_ARCH)
1854 {
1855 default:
1856 case E_MIPS_ARCH_1:
1857 return bfd_mach_mips3000;
1858 break;
1859
1860 case E_MIPS_ARCH_2:
1861 return bfd_mach_mips6000;
1862 break;
1863
1864 case E_MIPS_ARCH_3:
1865 return bfd_mach_mips4000;
1866 break;
1867
1868 case E_MIPS_ARCH_4:
1869 return bfd_mach_mips8000;
1870 break;
e7af610e 1871
84ea6cf2
NC		 1872 case E_MIPS_ARCH_5:
1873 return bfd_mach_mips5;
1874 break;
1875
e7af610e
NC		 1876 case E_MIPS_ARCH_32:
1877 return bfd_mach_mips32;
1878 break;
84ea6cf2
NC		 1879
1880 case E_MIPS_ARCH_64:
1881 return bfd_mach_mips64;
1882 break;
252b5132
RH		 1883 }
1884 }
1885
1886 return 0;
1887}
1888
be3ccd9c 1889/* Return printable name for ABI. */
252b5132 1890
be3ccd9c 1891static INLINE char *
103186c6
MM		 1892elf_mips_abi_name (abfd)
1893 bfd *abfd;
252b5132 1894{
103186c6
MM		 1895 flagword flags;
1896
1897 if (ABI_N32_P (abfd))
1898 return "N32";
1899 else if (ABI_64_P (abfd))
1900 return "64";
be3ccd9c 1901
103186c6 1902 flags = elf_elfheader (abfd)->e_flags;
252b5132
RH		 1903 switch (flags & EF_MIPS_ABI)
1904 {
1905 case 0:
1906 return "none";
1907 case E_MIPS_ABI_O32:
1908 return "O32";
1909 case E_MIPS_ABI_O64:
1910 return "O64";
1911 case E_MIPS_ABI_EABI32:
1912 return "EABI32";
1913 case E_MIPS_ABI_EABI64:
1914 return "EABI64";
1915 default:
1916 return "unknown abi";
1917 }
1918}
1919
1920/* A mapping from BFD reloc types to MIPS ELF reloc types. */
1921
1922struct elf_reloc_map {
1923 bfd_reloc_code_real_type bfd_reloc_val;
1924 enum elf_mips_reloc_type elf_reloc_val;
1925};
1926
be3ccd9c 1927static CONST struct elf_reloc_map mips_reloc_map[] = {
252b5132
RH		 1928 { BFD_RELOC_NONE, R_MIPS_NONE, },
1929 { BFD_RELOC_16, R_MIPS_16 },
1930 { BFD_RELOC_32, R_MIPS_32 },
1931 { BFD_RELOC_64, R_MIPS_64 },
1932 { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1933 { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1934 { BFD_RELOC_LO16, R_MIPS_LO16 },
1935 { BFD_RELOC_MIPS_GPREL, R_MIPS_GPREL16 },
1936 { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1937 { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1938 { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1939 { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1940 { BFD_RELOC_MIPS_GPREL32, R_MIPS_GPREL32 },
1941 { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1942 { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1943 { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
3f830999
MM		 1944 { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1945 { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1946 { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1947 { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1948 { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
252b5132
RH		 1949};
1950
1951/* Given a BFD reloc type, return a howto structure. */
1952
1953static reloc_howto_type *
1954bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1955 bfd *abfd;
1956 bfd_reloc_code_real_type code;
1957{
1958 unsigned int i;
1959
1960 for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map); i++)
1961 {
1962 if (mips_reloc_map[i].bfd_reloc_val == code)
1963 return &elf_mips_howto_table[(int) mips_reloc_map[i].elf_reloc_val];
1964 }
1965
1966 switch (code)
1967 {
1968 default:
1969 bfd_set_error (bfd_error_bad_value);
1970 return NULL;
1971
1972 case BFD_RELOC_CTOR:
1973 /* We need to handle BFD_RELOC_CTOR specially.
1974 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1975 size of addresses on this architecture. */
1976 if (bfd_arch_bits_per_address (abfd) == 32)
1977 return &elf_mips_howto_table[(int) R_MIPS_32];
1978 else
1979 return &elf_mips_ctor64_howto;
1980
1981 case BFD_RELOC_MIPS16_JMP:
1982 return &elf_mips16_jump_howto;
1983 case BFD_RELOC_MIPS16_GPREL:
1984 return &elf_mips16_gprel_howto;
1985 case BFD_RELOC_VTABLE_INHERIT:
1986 return &elf_mips_gnu_vtinherit_howto;
1987 case BFD_RELOC_VTABLE_ENTRY:
1988 return &elf_mips_gnu_vtentry_howto;
bb2d6cd7
GK		 1989 case BFD_RELOC_PCREL_HI16_S:
1990 return &elf_mips_gnu_rel_hi16;
1991 case BFD_RELOC_PCREL_LO16:
1992 return &elf_mips_gnu_rel_lo16;
1993 case BFD_RELOC_16_PCREL_S2:
1994 return &elf_mips_gnu_rel16_s2;
1995 case BFD_RELOC_64_PCREL:
1996 return &elf_mips_gnu_pcrel64;
1997 case BFD_RELOC_32_PCREL:
1998 return &elf_mips_gnu_pcrel32;
252b5132
RH		 1999 }
2000}
2001
3f830999 2002/* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
252b5132 2003
c9b3cbf3
RH		 2004static reloc_howto_type *
2005mips_rtype_to_howto (r_type)
2006 unsigned int r_type;
252b5132 2007{
252b5132
RH		 2008 switch (r_type)
2009 {
2010 case R_MIPS16_26:
c9b3cbf3 2011 return &elf_mips16_jump_howto;
252b5132
RH		 2012 break;
2013 case R_MIPS16_GPREL:
c9b3cbf3 2014 return &elf_mips16_gprel_howto;
252b5132
RH		 2015 break;
2016 case R_MIPS_GNU_VTINHERIT:
c9b3cbf3 2017 return &elf_mips_gnu_vtinherit_howto;
252b5132
RH		 2018 break;
2019 case R_MIPS_GNU_VTENTRY:
c9b3cbf3 2020 return &elf_mips_gnu_vtentry_howto;
252b5132 2021 break;
bb2d6cd7
GK		 2022 case R_MIPS_GNU_REL_HI16:
2023 return &elf_mips_gnu_rel_hi16;
2024 break;
2025 case R_MIPS_GNU_REL_LO16:
2026 return &elf_mips_gnu_rel_lo16;
2027 break;
2028 case R_MIPS_GNU_REL16_S2:
2029 return &elf_mips_gnu_rel16_s2;
2030 break;
2031 case R_MIPS_PC64:
2032 return &elf_mips_gnu_pcrel64;
2033 break;
2034 case R_MIPS_PC32:
2035 return &elf_mips_gnu_pcrel32;
2036 break;
252b5132
RH		 2037
2038 default:
2039 BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
c9b3cbf3 2040 return &elf_mips_howto_table[r_type];
252b5132
RH		 2041 break;
2042 }
c9b3cbf3
RH		 2043}
2044
2045/* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2046
2047static void
2048mips_info_to_howto_rel (abfd, cache_ptr, dst)
2049 bfd *abfd;
2050 arelent *cache_ptr;
2051 Elf32_Internal_Rel *dst;
2052{
2053 unsigned int r_type;
2054
2055 r_type = ELF32_R_TYPE (dst->r_info);
2056 cache_ptr->howto = mips_rtype_to_howto (r_type);
252b5132
RH		 2057
2058 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
2059 value for the object file. We get the addend now, rather than
2060 when we do the relocation, because the symbol manipulations done
2061 by the linker may cause us to lose track of the input BFD. */
2062 if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
2063 && (r_type == (unsigned int) R_MIPS_GPREL16
2064 || r_type == (unsigned int) R_MIPS_LITERAL))
2065 cache_ptr->addend = elf_gp (abfd);
2066}
3f830999
MM		 2067
2068/* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
2069
2070static void
2071mips_info_to_howto_rela (abfd, cache_ptr, dst)
2072 bfd *abfd;
2073 arelent *cache_ptr;
2074 Elf32_Internal_Rela *dst;
2075{
2076 /* Since an Elf32_Internal_Rel is an initial prefix of an
2077 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
2078 above. */
2079 mips_info_to_howto_rel (abfd, cache_ptr, (Elf32_Internal_Rel *) dst);
2080
2081 /* If we ever need to do any extra processing with dst->r_addend
2082 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
2083}
252b5132
RH		 2084\f
2085/* A .reginfo section holds a single Elf32_RegInfo structure. These
2086 routines swap this structure in and out. They are used outside of
2087 BFD, so they are globally visible. */
2088
2089void
2090bfd_mips_elf32_swap_reginfo_in (abfd, ex, in)
2091 bfd *abfd;
2092 const Elf32_External_RegInfo *ex;
2093 Elf32_RegInfo *in;
2094{
2095 in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2096 in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2097 in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2098 in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2099 in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2100 in->ri_gp_value = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gp_value);
2101}
2102
2103void
2104bfd_mips_elf32_swap_reginfo_out (abfd, in, ex)
2105 bfd *abfd;
2106 const Elf32_RegInfo *in;
2107 Elf32_External_RegInfo *ex;
2108{
2109 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2110 (bfd_byte *) ex->ri_gprmask);
2111 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2112 (bfd_byte *) ex->ri_cprmask[0]);
2113 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2114 (bfd_byte *) ex->ri_cprmask[1]);
2115 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2116 (bfd_byte *) ex->ri_cprmask[2]);
2117 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2118 (bfd_byte *) ex->ri_cprmask[3]);
2119 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gp_value,
2120 (bfd_byte *) ex->ri_gp_value);
2121}
2122
2123/* In the 64 bit ABI, the .MIPS.options section holds register
2124 information in an Elf64_Reginfo structure. These routines swap
2125 them in and out. They are globally visible because they are used
2126 outside of BFD. These routines are here so that gas can call them
2127 without worrying about whether the 64 bit ABI has been included. */
2128
2129void
2130bfd_mips_elf64_swap_reginfo_in (abfd, ex, in)
2131 bfd *abfd;
2132 const Elf64_External_RegInfo *ex;
2133 Elf64_Internal_RegInfo *in;
2134{
2135 in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2136 in->ri_pad = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_pad);
2137 in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2138 in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2139 in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2140 in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2141 in->ri_gp_value = bfd_h_get_64 (abfd, (bfd_byte *) ex->ri_gp_value);
2142}
2143
2144void
2145bfd_mips_elf64_swap_reginfo_out (abfd, in, ex)
2146 bfd *abfd;
2147 const Elf64_Internal_RegInfo *in;
2148 Elf64_External_RegInfo *ex;
2149{
2150 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2151 (bfd_byte *) ex->ri_gprmask);
2152 bfd_h_put_32 (abfd, (bfd_vma) in->ri_pad,
2153 (bfd_byte *) ex->ri_pad);
2154 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2155 (bfd_byte *) ex->ri_cprmask[0]);
2156 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2157 (bfd_byte *) ex->ri_cprmask[1]);
2158 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2159 (bfd_byte *) ex->ri_cprmask[2]);
2160 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2161 (bfd_byte *) ex->ri_cprmask[3]);
2162 bfd_h_put_64 (abfd, (bfd_vma) in->ri_gp_value,
2163 (bfd_byte *) ex->ri_gp_value);
2164}
2165
2166/* Swap an entry in a .gptab section. Note that these routines rely
2167 on the equivalence of the two elements of the union. */
2168
2169static void
2170bfd_mips_elf32_swap_gptab_in (abfd, ex, in)
2171 bfd *abfd;
2172 const Elf32_External_gptab *ex;
2173 Elf32_gptab *in;
2174{
2175 in->gt_entry.gt_g_value = bfd_h_get_32 (abfd, ex->gt_entry.gt_g_value);
2176 in->gt_entry.gt_bytes = bfd_h_get_32 (abfd, ex->gt_entry.gt_bytes);
2177}
2178
2179static void
2180bfd_mips_elf32_swap_gptab_out (abfd, in, ex)
2181 bfd *abfd;
2182 const Elf32_gptab *in;
2183 Elf32_External_gptab *ex;
2184{
2185 bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
2186 ex->gt_entry.gt_g_value);
2187 bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
2188 ex->gt_entry.gt_bytes);
2189}
2190
2191static void
2192bfd_elf32_swap_compact_rel_out (abfd, in, ex)
2193 bfd *abfd;
2194 const Elf32_compact_rel *in;
2195 Elf32_External_compact_rel *ex;
2196{
2197 bfd_h_put_32 (abfd, (bfd_vma) in->id1, ex->id1);
2198 bfd_h_put_32 (abfd, (bfd_vma) in->num, ex->num);
2199 bfd_h_put_32 (abfd, (bfd_vma) in->id2, ex->id2);
2200 bfd_h_put_32 (abfd, (bfd_vma) in->offset, ex->offset);
2201 bfd_h_put_32 (abfd, (bfd_vma) in->reserved0, ex->reserved0);
2202 bfd_h_put_32 (abfd, (bfd_vma) in->reserved1, ex->reserved1);
2203}
2204
2205static void
2206bfd_elf32_swap_crinfo_out (abfd, in, ex)
2207 bfd *abfd;
2208 const Elf32_crinfo *in;
2209 Elf32_External_crinfo *ex;
2210{
2211 unsigned long l;
2212
2213 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2214 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2215 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2216 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2217 bfd_h_put_32 (abfd, (bfd_vma) l, ex->info);
2218 bfd_h_put_32 (abfd, (bfd_vma) in->konst, ex->konst);
2219 bfd_h_put_32 (abfd, (bfd_vma) in->vaddr, ex->vaddr);
2220}
2221
2222/* Swap in an options header. */
2223
2224void
2225bfd_mips_elf_swap_options_in (abfd, ex, in)
2226 bfd *abfd;
2227 const Elf_External_Options *ex;
2228 Elf_Internal_Options *in;
2229{
2230 in->kind = bfd_h_get_8 (abfd, ex->kind);
2231 in->size = bfd_h_get_8 (abfd, ex->size);
2232 in->section = bfd_h_get_16 (abfd, ex->section);
2233 in->info = bfd_h_get_32 (abfd, ex->info);
2234}
2235
2236/* Swap out an options header. */
2237
2238void
2239bfd_mips_elf_swap_options_out (abfd, in, ex)
2240 bfd *abfd;
2241 const Elf_Internal_Options *in;
2242 Elf_External_Options *ex;
2243{
2244 bfd_h_put_8 (abfd, in->kind, ex->kind);
2245 bfd_h_put_8 (abfd, in->size, ex->size);
2246 bfd_h_put_16 (abfd, in->section, ex->section);
2247 bfd_h_put_32 (abfd, in->info, ex->info);
2248}
86033394 2249#if 0
c6142e5d
MM		 2250/* Swap in an MSYM entry. */
2251
2252static void
2253bfd_mips_elf_swap_msym_in (abfd, ex, in)
2254 bfd *abfd;
2255 const Elf32_External_Msym *ex;
2256 Elf32_Internal_Msym *in;
2257{
2258 in->ms_hash_value = bfd_h_get_32 (abfd, ex->ms_hash_value);
2259 in->ms_info = bfd_h_get_32 (abfd, ex->ms_info);
2260}
86033394 2261#endif
c6142e5d
MM		 2262/* Swap out an MSYM entry. */
2263
2264static void
2265bfd_mips_elf_swap_msym_out (abfd, in, ex)
2266 bfd *abfd;
2267 const Elf32_Internal_Msym *in;
2268 Elf32_External_Msym *ex;
2269{
2270 bfd_h_put_32 (abfd, in->ms_hash_value, ex->ms_hash_value);
2271 bfd_h_put_32 (abfd, in->ms_info, ex->ms_info);
2272}
252b5132
RH		 2273\f
2274/* Determine whether a symbol is global for the purposes of splitting
2275 the symbol table into global symbols and local symbols. At least
2276 on Irix 5, this split must be between section symbols and all other
2277 symbols. On most ELF targets the split is between static symbols
2278 and externally visible symbols. */
2279
252b5132
RH		 2280static boolean
2281mips_elf_sym_is_global (abfd, sym)
5f771d47 2282 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2283 asymbol *sym;
2284{
2285 return (sym->flags & BSF_SECTION_SYM) == 0 ? true : false;
2286}
2287\f
2288/* Set the right machine number for a MIPS ELF file. This is used for
2289 both the 32-bit and the 64-bit ABI. */
2290
2291boolean
2292_bfd_mips_elf_object_p (abfd)
2293 bfd *abfd;
2294{
103186c6 2295 /* Irix 5 and 6 is broken. Object file symbol tables are not always
252b5132
RH		 2296 sorted correctly such that local symbols precede global symbols,
2297 and the sh_info field in the symbol table is not always right. */
2298 elf_bad_symtab (abfd) = true;
2299
103186c6
MM		 2300 bfd_default_set_arch_mach (abfd, bfd_arch_mips,
2301 elf_mips_mach (elf_elfheader (abfd)->e_flags));
2302 return true;
252b5132
RH		 2303}
2304
2305/* The final processing done just before writing out a MIPS ELF object
2306 file. This gets the MIPS architecture right based on the machine
2307 number. This is used by both the 32-bit and the 64-bit ABI. */
2308
252b5132
RH		 2309void
2310_bfd_mips_elf_final_write_processing (abfd, linker)
2311 bfd *abfd;
5f771d47 2312 boolean linker ATTRIBUTE_UNUSED;
252b5132
RH		 2313{
2314 unsigned long val;
2315 unsigned int i;
2316 Elf_Internal_Shdr **hdrpp;
2317 const char *name;
2318 asection *sec;
2319
2320 switch (bfd_get_mach (abfd))
2321 {
2322 default:
2323 case bfd_mach_mips3000:
2324 val = E_MIPS_ARCH_1;
2325 break;
2326
2327 case bfd_mach_mips3900:
2328 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
2329 break;
2330
2331 case bfd_mach_mips6000:
2332 val = E_MIPS_ARCH_2;
2333 break;
2334
2335 case bfd_mach_mips4000:
2336 case bfd_mach_mips4300:
2337 val = E_MIPS_ARCH_3;
2338 break;
2339
2340 case bfd_mach_mips4010:
2341 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
2342 break;
2343
2344 case bfd_mach_mips4100:
2345 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
2346 break;
2347
2348 case bfd_mach_mips4111:
2349 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
2350 break;
2351
2352 case bfd_mach_mips4650:
2353 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
2354 break;
2355
2356 case bfd_mach_mips8000:
2357 val = E_MIPS_ARCH_4;
2358 break;
156c2f8b 2359
e7af610e
NC		 2360 case bfd_mach_mips32:
2361 val = E_MIPS_ARCH_32;
2362 break;
2363
2364 case bfd_mach_mips32_4k:
2365 val = E_MIPS_ARCH_32 | E_MIPS_MACH_MIPS32_4K;
156c2f8b 2366 break;
84ea6cf2
NC		 2367
2368 case bfd_mach_mips5:
2369 val = E_MIPS_ARCH_5;
2370 break;
2371
2372 case bfd_mach_mips64:
2373 val = E_MIPS_ARCH_64;
2374 break;
c6c98b38
NC		 2375
2376 case bfd_mach_mips_sb1:
2377 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
2378 break;
252b5132
RH		 2379 }
2380
be3ccd9c 2381 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
252b5132
RH		 2382 elf_elfheader (abfd)->e_flags |= val;
2383
2384 /* Set the sh_info field for .gptab sections and other appropriate
2385 info for each special section. */
2386 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
2387 i < elf_elfheader (abfd)->e_shnum;
2388 i++, hdrpp++)
2389 {
2390 switch ((*hdrpp)->sh_type)
2391 {
c6142e5d 2392 case SHT_MIPS_MSYM:
252b5132
RH		 2393 case SHT_MIPS_LIBLIST:
2394 sec = bfd_get_section_by_name (abfd, ".dynstr");
2395 if (sec != NULL)
2396 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2397 break;
2398
2399 case SHT_MIPS_GPTAB:
2400 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2401 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2402 BFD_ASSERT (name != NULL
2403 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
2404 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
2405 BFD_ASSERT (sec != NULL);
2406 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2407 break;
2408
2409 case SHT_MIPS_CONTENT:
2410 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2411 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2412 BFD_ASSERT (name != NULL
2413 && strncmp (name, ".MIPS.content",
2414 sizeof ".MIPS.content" - 1) == 0);
2415 sec = bfd_get_section_by_name (abfd,
2416 name + sizeof ".MIPS.content" - 1);
2417 BFD_ASSERT (sec != NULL);
3f830999 2418 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
252b5132
RH		 2419 break;
2420
2421 case SHT_MIPS_SYMBOL_LIB:
2422 sec = bfd_get_section_by_name (abfd, ".dynsym");
2423 if (sec != NULL)
2424 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2425 sec = bfd_get_section_by_name (abfd, ".liblist");
2426 if (sec != NULL)
2427 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2428 break;
2429
2430 case SHT_MIPS_EVENTS:
2431 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2432 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2433 BFD_ASSERT (name != NULL);
2434 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2435 sec = bfd_get_section_by_name (abfd,
2436 name + sizeof ".MIPS.events" - 1);
2437 else
2438 {
2439 BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
2440 sizeof ".MIPS.post_rel" - 1) == 0);
2441 sec = bfd_get_section_by_name (abfd,
2442 (name
2443 + sizeof ".MIPS.post_rel" - 1));
2444 }
2445 BFD_ASSERT (sec != NULL);
2446 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2447 break;
2448
2449 }
2450 }
2451}
2452\f
be3ccd9c 2453/* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
252b5132
RH		 2454
2455boolean
2456_bfd_mips_elf_set_private_flags (abfd, flags)
2457 bfd *abfd;
2458 flagword flags;
2459{
2460 BFD_ASSERT (!elf_flags_init (abfd)
2461 || elf_elfheader (abfd)->e_flags == flags);
2462
2463 elf_elfheader (abfd)->e_flags = flags;
2464 elf_flags_init (abfd) = true;
2465 return true;
2466}
2467
2468/* Copy backend specific data from one object module to another */
2469
2470boolean
2471_bfd_mips_elf_copy_private_bfd_data (ibfd, obfd)
2472 bfd *ibfd;
2473 bfd *obfd;
2474{
2475 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2476 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2477 return true;
2478
2479 BFD_ASSERT (!elf_flags_init (obfd)
2480 || (elf_elfheader (obfd)->e_flags
2481 == elf_elfheader (ibfd)->e_flags));
2482
2483 elf_gp (obfd) = elf_gp (ibfd);
2484 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2485 elf_flags_init (obfd) = true;
2486 return true;
2487}
2488
2489/* Merge backend specific data from an object file to the output
2490 object file when linking. */
2491
2492boolean
2493_bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
2494 bfd *ibfd;
2495 bfd *obfd;
2496{
2497 flagword old_flags;
2498 flagword new_flags;
2499 boolean ok;
a9922e52
UC		 2500 boolean null_input_bfd = true;
2501 asection *sec;
252b5132
RH		 2502
2503 /* Check if we have the same endianess */
1fe494a5
NC		 2504 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2505 return false;
252b5132
RH		 2506
2507 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2508 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2509 return true;
2510
2511 new_flags = elf_elfheader (ibfd)->e_flags;
2512 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
2513 old_flags = elf_elfheader (obfd)->e_flags;
2514
2515 if (! elf_flags_init (obfd))
2516 {
2517 elf_flags_init (obfd) = true;
2518 elf_elfheader (obfd)->e_flags = new_flags;
be3ccd9c 2519 elf_elfheader (obfd)->e_ident[EI_CLASS]
103186c6 2520 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
252b5132
RH		 2521
2522 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2523 && bfd_get_arch_info (obfd)->the_default)
2524 {
2525 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2526 bfd_get_mach (ibfd)))
2527 return false;
2528 }
2529
2530 return true;
2531 }
2532
2533 /* Check flag compatibility. */
2534
2535 new_flags &= ~EF_MIPS_NOREORDER;
2536 old_flags &= ~EF_MIPS_NOREORDER;
2537
2538 if (new_flags == old_flags)
2539 return true;
2540
a9922e52
UC		 2541 /* Check to see if the input BFD actually contains any sections.
2542 If not, its flags may not have been initialised either, but it cannot
2543 actually cause any incompatibility. */
2544 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2545 {
2546 /* Ignore synthetic sections and empty .text, .data and .bss sections
2547 which are automatically generated by gas. */
2548 if (strcmp (sec->name, ".reginfo")
2549 && strcmp (sec->name, ".mdebug")
2550 && ((!strcmp (sec->name, ".text")
2551 || !strcmp (sec->name, ".data")
2552 || !strcmp (sec->name, ".bss"))
2553 && sec->_raw_size != 0))
2554 {
2555 null_input_bfd = false;
2556 break;
2557 }
2558 }
2559 if (null_input_bfd)
2560 return true;
2561
252b5132
RH		 2562 ok = true;
2563
2564 if ((new_flags & EF_MIPS_PIC) != (old_flags & EF_MIPS_PIC))
2565 {
2566 new_flags &= ~EF_MIPS_PIC;
2567 old_flags &= ~EF_MIPS_PIC;
2568 (*_bfd_error_handler)
2569 (_("%s: linking PIC files with non-PIC files"),
2570 bfd_get_filename (ibfd));
2571 ok = false;
2572 }
2573
2574 if ((new_flags & EF_MIPS_CPIC) != (old_flags & EF_MIPS_CPIC))
2575 {
2576 new_flags &= ~EF_MIPS_CPIC;
2577 old_flags &= ~EF_MIPS_CPIC;
2578 (*_bfd_error_handler)
2579 (_("%s: linking abicalls files with non-abicalls files"),
2580 bfd_get_filename (ibfd));
2581 ok = false;
2582 }
2583
be3ccd9c 2584 /* Compare the ISA's. */
252b5132
RH		 2585 if ((new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH))
2586 != (old_flags & (EF_MIPS_ARCH | EF_MIPS_MACH)))
2587 {
2588 int new_mach = new_flags & EF_MIPS_MACH;
2589 int old_mach = old_flags & EF_MIPS_MACH;
2590 int new_isa = elf_mips_isa (new_flags);
2591 int old_isa = elf_mips_isa (old_flags);
2592
2593 /* If either has no machine specified, just compare the general isa's.
be3ccd9c
KH		 2594 Some combinations of machines are ok, if the isa's match. */
2595 if (! new_mach
252b5132
RH		 2596 || ! old_mach
2597 || new_mach == old_mach
2598 )
2599 {
e7af610e
NC		 2600 /* Don't warn about mixing code using 32-bit ISAs, or mixing code
2601 using 64-bit ISAs. They will normally use the same data sizes
2602 and calling conventions. */
252b5132 2603
e7af610e
NC		 2604 if (( (new_isa == 1 || new_isa == 2 || new_isa == 32)
2605 ^ (old_isa == 1 || old_isa == 2 || old_isa == 32)) != 0)
252b5132
RH		 2606 {
2607 (*_bfd_error_handler)
2608 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2609 bfd_get_filename (ibfd), new_isa, old_isa);
2610 ok = false;
2611 }
2612 }
2613
2614 else
2615 {
2616 (*_bfd_error_handler)
2617 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2618 bfd_get_filename (ibfd),
2619 elf_mips_mach (new_flags),
2620 elf_mips_mach (old_flags));
2621 ok = false;
2622 }
2623
be3ccd9c
KH		 2624 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2625 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
252b5132
RH		 2626 }
2627
103186c6
MM		 2628 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2629 does set EI_CLASS differently from any 32-bit ABI. */
2630 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
be3ccd9c 2631 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
103186c6 2632 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
252b5132 2633 {
be3ccd9c 2634 /* Only error if both are set (to different values). */
103186c6 2635 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
be3ccd9c 2636 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
103186c6 2637 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
252b5132
RH		 2638 {
2639 (*_bfd_error_handler)
2640 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2641 bfd_get_filename (ibfd),
103186c6
MM		 2642 elf_mips_abi_name (ibfd),
2643 elf_mips_abi_name (obfd));
252b5132
RH		 2644 ok = false;
2645 }
2646 new_flags &= ~EF_MIPS_ABI;
2647 old_flags &= ~EF_MIPS_ABI;
2648 }
2649
2650 /* Warn about any other mismatches */
2651 if (new_flags != old_flags)
2652 {
2653 (*_bfd_error_handler)
2654 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2655 bfd_get_filename (ibfd), (unsigned long) new_flags,
2656 (unsigned long) old_flags);
2657 ok = false;
2658 }
2659
2660 if (! ok)
2661 {
2662 bfd_set_error (bfd_error_bad_value);
2663 return false;
2664 }
2665
2666 return true;
2667}
2668\f
103186c6 2669boolean
252b5132
RH		 2670_bfd_mips_elf_print_private_bfd_data (abfd, ptr)
2671 bfd *abfd;
2672 PTR ptr;
2673{
2674 FILE *file = (FILE *) ptr;
2675
2676 BFD_ASSERT (abfd != NULL && ptr != NULL);
2677
2678 /* Print normal ELF private data. */
2679 _bfd_elf_print_private_bfd_data (abfd, ptr);
2680
2681 /* xgettext:c-format */
be3ccd9c 2682 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
252b5132
RH		 2683
2684 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
be3ccd9c 2685 fprintf (file, _(" [abi=O32]"));
252b5132 2686 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
be3ccd9c 2687 fprintf (file, _(" [abi=O64]"));
252b5132 2688 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
be3ccd9c 2689 fprintf (file, _(" [abi=EABI32]"));
252b5132 2690 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
be3ccd9c 2691 fprintf (file, _(" [abi=EABI64]"));
252b5132 2692 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
be3ccd9c 2693 fprintf (file, _(" [abi unknown]"));
103186c6 2694 else if (ABI_N32_P (abfd))
be3ccd9c 2695 fprintf (file, _(" [abi=N32]"));
103186c6 2696 else if (ABI_64_P (abfd))
be3ccd9c 2697 fprintf (file, _(" [abi=64]"));
252b5132 2698 else
be3ccd9c 2699 fprintf (file, _(" [no abi set]"));
252b5132
RH		 2700
2701 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
be3ccd9c 2702 fprintf (file, _(" [mips1]"));
252b5132 2703 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
be3ccd9c 2704 fprintf (file, _(" [mips2]"));
252b5132 2705 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
be3ccd9c 2706 fprintf (file, _(" [mips3]"));
252b5132 2707 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
be3ccd9c 2708 fprintf (file, _(" [mips4]"));
84ea6cf2
NC		 2709 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
2710 fprintf (file, _ (" [mips5]"));
e7af610e
NC		 2711 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
2712 fprintf (file, _ (" [mips32]"));
84ea6cf2
NC		 2713 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
2714 fprintf (file, _ (" [mips64]"));
252b5132 2715 else
be3ccd9c 2716 fprintf (file, _(" [unknown ISA]"));
252b5132
RH		 2717
2718 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
be3ccd9c 2719 fprintf (file, _(" [32bitmode]"));
252b5132 2720 else
be3ccd9c 2721 fprintf (file, _(" [not 32bitmode]"));
252b5132
RH		 2722
2723 fputc ('\n', file);
2724
2725 return true;
2726}
2727\f
2728/* Handle a MIPS specific section when reading an object file. This
2729 is called when elfcode.h finds a section with an unknown type.
2730 This routine supports both the 32-bit and 64-bit ELF ABI.
2731
2732 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2733 how to. */
2734
2735boolean
2736_bfd_mips_elf_section_from_shdr (abfd, hdr, name)
2737 bfd *abfd;
2738 Elf_Internal_Shdr *hdr;
103186c6 2739 char *name;
252b5132
RH		 2740{
2741 flagword flags = 0;
2742
2743 /* There ought to be a place to keep ELF backend specific flags, but
2744 at the moment there isn't one. We just keep track of the
2745 sections by their name, instead. Fortunately, the ABI gives
2746 suggested names for all the MIPS specific sections, so we will
2747 probably get away with this. */
2748 switch (hdr->sh_type)
2749 {
2750 case SHT_MIPS_LIBLIST:
2751 if (strcmp (name, ".liblist") != 0)
2752 return false;
2753 break;
2754 case SHT_MIPS_MSYM:
c6142e5d 2755 if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) != 0)
252b5132
RH		 2756 return false;
2757 break;
2758 case SHT_MIPS_CONFLICT:
2759 if (strcmp (name, ".conflict") != 0)
2760 return false;
2761 break;
2762 case SHT_MIPS_GPTAB:
2763 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
2764 return false;
2765 break;
2766 case SHT_MIPS_UCODE:
2767 if (strcmp (name, ".ucode") != 0)
2768 return false;
2769 break;
2770 case SHT_MIPS_DEBUG:
2771 if (strcmp (name, ".mdebug") != 0)
2772 return false;
2773 flags = SEC_DEBUGGING;
2774 break;
2775 case SHT_MIPS_REGINFO:
2776 if (strcmp (name, ".reginfo") != 0
2777 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
2778 return false;
2779 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
2780 break;
2781 case SHT_MIPS_IFACE:
2782 if (strcmp (name, ".MIPS.interfaces") != 0)
2783 return false;
2784 break;
2785 case SHT_MIPS_CONTENT:
2786 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2787 return false;
2788 break;
2789 case SHT_MIPS_OPTIONS:
303f629d 2790 if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
252b5132
RH		 2791 return false;
2792 break;
2793 case SHT_MIPS_DWARF:
2794 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
2795 return false;
2796 break;
2797 case SHT_MIPS_SYMBOL_LIB:
2798 if (strcmp (name, ".MIPS.symlib") != 0)
2799 return false;
2800 break;
2801 case SHT_MIPS_EVENTS:
2802 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2803 && strncmp (name, ".MIPS.post_rel",
2804 sizeof ".MIPS.post_rel" - 1) != 0)
2805 return false;
2806 break;
2807 default:
2808 return false;
2809 }
2810
2811 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2812 return false;
2813
2814 if (flags)
2815 {
2816 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2817 (bfd_get_section_flags (abfd,
2818 hdr->bfd_section)
2819 | flags)))
2820 return false;
2821 }
2822
252b5132
RH		 2823 /* FIXME: We should record sh_info for a .gptab section. */
2824
2825 /* For a .reginfo section, set the gp value in the tdata information
2826 from the contents of this section. We need the gp value while
2827 processing relocs, so we just get it now. The .reginfo section
2828 is not used in the 64-bit MIPS ELF ABI. */
2829 if (hdr->sh_type == SHT_MIPS_REGINFO)
2830 {
2831 Elf32_External_RegInfo ext;
2832 Elf32_RegInfo s;
2833
2834 if (! bfd_get_section_contents (abfd, hdr->bfd_section, (PTR) &ext,
2835 (file_ptr) 0, sizeof ext))
2836 return false;
2837 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
2838 elf_gp (abfd) = s.ri_gp_value;
2839 }
2840
2841 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2842 set the gp value based on what we find. We may see both
2843 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2844 they should agree. */
2845 if (hdr->sh_type == SHT_MIPS_OPTIONS)
2846 {
2847 bfd_byte *contents, *l, *lend;
2848
2849 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
2850 if (contents == NULL)
2851 return false;
2852 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
2853 (file_ptr) 0, hdr->sh_size))
2854 {
2855 free (contents);
2856 return false;
2857 }
2858 l = contents;
2859 lend = contents + hdr->sh_size;
2860 while (l + sizeof (Elf_External_Options) <= lend)
2861 {
2862 Elf_Internal_Options intopt;
2863
2864 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
2865 &intopt);
103186c6
MM		 2866 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
2867 {
2868 Elf64_Internal_RegInfo intreg;
2869
2870 bfd_mips_elf64_swap_reginfo_in
2871 (abfd,
2872 ((Elf64_External_RegInfo *)
2873 (l + sizeof (Elf_External_Options))),
2874 &intreg);
2875 elf_gp (abfd) = intreg.ri_gp_value;
2876 }
2877 else if (intopt.kind == ODK_REGINFO)
252b5132
RH		 2878 {
2879 Elf32_RegInfo intreg;
2880
2881 bfd_mips_elf32_swap_reginfo_in
2882 (abfd,
2883 ((Elf32_External_RegInfo *)
2884 (l + sizeof (Elf_External_Options))),
2885 &intreg);
2886 elf_gp (abfd) = intreg.ri_gp_value;
2887 }
2888 l += intopt.size;
2889 }
2890 free (contents);
2891 }
2892
2893 return true;
2894}
2895
2896/* Set the correct type for a MIPS ELF section. We do this by the
2897 section name, which is a hack, but ought to work. This routine is
2898 used by both the 32-bit and the 64-bit ABI. */
2899
2900boolean
2901_bfd_mips_elf_fake_sections (abfd, hdr, sec)
2902 bfd *abfd;
2903 Elf32_Internal_Shdr *hdr;
2904 asection *sec;
2905{
2906 register const char *name;
2907
2908 name = bfd_get_section_name (abfd, sec);
2909
2910 if (strcmp (name, ".liblist") == 0)
2911 {
2912 hdr->sh_type = SHT_MIPS_LIBLIST;
2913 hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
2914 /* The sh_link field is set in final_write_processing. */
2915 }
252b5132
RH		 2916 else if (strcmp (name, ".conflict") == 0)
2917 hdr->sh_type = SHT_MIPS_CONFLICT;
2918 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
2919 {
2920 hdr->sh_type = SHT_MIPS_GPTAB;
2921 hdr->sh_entsize = sizeof (Elf32_External_gptab);
2922 /* The sh_info field is set in final_write_processing. */
2923 }
2924 else if (strcmp (name, ".ucode") == 0)
2925 hdr->sh_type = SHT_MIPS_UCODE;
2926 else if (strcmp (name, ".mdebug") == 0)
2927 {
2928 hdr->sh_type = SHT_MIPS_DEBUG;
2929 /* In a shared object on Irix 5.3, the .mdebug section has an
2930 entsize of 0. FIXME: Does this matter? */
2931 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
2932 hdr->sh_entsize = 0;
2933 else
2934 hdr->sh_entsize = 1;
2935 }
2936 else if (strcmp (name, ".reginfo") == 0)
2937 {
2938 hdr->sh_type = SHT_MIPS_REGINFO;
2939 /* In a shared object on Irix 5.3, the .reginfo section has an
2940 entsize of 0x18. FIXME: Does this matter? */
f7cb7d68 2941 if (SGI_COMPAT (abfd))
be3ccd9c
KH		 2942 {
2943 if ((abfd->flags & DYNAMIC) != 0)
2944 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
2945 else
2946 hdr->sh_entsize = 1;
2947 }
252b5132 2948 else
be3ccd9c 2949 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
252b5132
RH		 2950 }
2951 else if (SGI_COMPAT (abfd)
2952 && (strcmp (name, ".hash") == 0
2953 || strcmp (name, ".dynamic") == 0
2954 || strcmp (name, ".dynstr") == 0))
2955 {
be3ccd9c
KH		 2956 if (SGI_COMPAT (abfd))
2957 hdr->sh_entsize = 0;
252b5132
RH		 2958#if 0
2959 /* This isn't how the Irix 6 linker behaves. */
2960 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
2961#endif
2962 }
2963 else if (strcmp (name, ".got") == 0
303f629d 2964 || strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0
252b5132
RH		 2965 || strcmp (name, ".sdata") == 0
2966 || strcmp (name, ".sbss") == 0
2967 || strcmp (name, ".lit4") == 0
2968 || strcmp (name, ".lit8") == 0)
2969 hdr->sh_flags |= SHF_MIPS_GPREL;
2970 else if (strcmp (name, ".MIPS.interfaces") == 0)
2971 {
2972 hdr->sh_type = SHT_MIPS_IFACE;
2973 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
2974 }
3f830999 2975 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
252b5132
RH		 2976 {
2977 hdr->sh_type = SHT_MIPS_CONTENT;
3f830999 2978 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
252b5132
RH		 2979 /* The sh_info field is set in final_write_processing. */
2980 }
303f629d 2981 else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
252b5132
RH		 2982 {
2983 hdr->sh_type = SHT_MIPS_OPTIONS;
2984 hdr->sh_entsize = 1;
2985 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
2986 }
2987 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
2988 hdr->sh_type = SHT_MIPS_DWARF;
2989 else if (strcmp (name, ".MIPS.symlib") == 0)
2990 {
2991 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
2992 /* The sh_link and sh_info fields are set in
2993 final_write_processing. */
2994 }
2995 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2996 || strncmp (name, ".MIPS.post_rel",
2997 sizeof ".MIPS.post_rel" - 1) == 0)
2998 {
2999 hdr->sh_type = SHT_MIPS_EVENTS;
3000 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3001 /* The sh_link field is set in final_write_processing. */
3002 }
c6142e5d
MM		 3003 else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) == 0)
3004 {
3005 hdr->sh_type = SHT_MIPS_MSYM;
3006 hdr->sh_flags |= SHF_ALLOC;
3007 hdr->sh_entsize = 8;
3008 }
252b5132 3009
23bc299b
MM		 3010 /* The generic elf_fake_sections will set up REL_HDR using the
3011 default kind of relocations. But, we may actually need both
3012 kinds of relocations, so we set up the second header here. */
3013 if ((sec->flags & SEC_RELOC) != 0)
3014 {
3015 struct bfd_elf_section_data *esd;
3016
3017 esd = elf_section_data (sec);
3018 BFD_ASSERT (esd->rel_hdr2 == NULL);
be3ccd9c 3019 esd->rel_hdr2
23bc299b
MM		 3020 = (Elf_Internal_Shdr *) bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3021 if (!esd->rel_hdr2)
3022 return false;
3023 _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
3024 !elf_section_data (sec)->use_rela_p);
3025 }
3026
252b5132
RH		 3027 return true;
3028}
3029
3030/* Given a BFD section, try to locate the corresponding ELF section
3031 index. This is used by both the 32-bit and the 64-bit ABI.
3032 Actually, it's not clear to me that the 64-bit ABI supports these,
3033 but for non-PIC objects we will certainly want support for at least
3034 the .scommon section. */
3035
3036boolean
3037_bfd_mips_elf_section_from_bfd_section (abfd, hdr, sec, retval)
5f771d47
ILT		 3038 bfd *abfd ATTRIBUTE_UNUSED;
3039 Elf32_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
252b5132
RH		 3040 asection *sec;
3041 int *retval;
3042{
3043 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
3044 {
3045 *retval = SHN_MIPS_SCOMMON;
3046 return true;
3047 }
3048 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
3049 {
3050 *retval = SHN_MIPS_ACOMMON;
3051 return true;
3052 }
3053 return false;
3054}
3055
3056/* When are writing out the .options or .MIPS.options section,
3057 remember the bytes we are writing out, so that we can install the
3058 GP value in the section_processing routine. */
3059
3060boolean
3061_bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
3062 bfd *abfd;
3063 sec_ptr section;
3064 PTR location;
3065 file_ptr offset;
3066 bfd_size_type count;
3067{
303f629d 3068 if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
252b5132
RH		 3069 {
3070 bfd_byte *c;
3071
3072 if (elf_section_data (section) == NULL)
3073 {
3074 section->used_by_bfd =
3075 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
3076 if (elf_section_data (section) == NULL)
3077 return false;
3078 }
3079 c = (bfd_byte *) elf_section_data (section)->tdata;
3080 if (c == NULL)
3081 {
3082 bfd_size_type size;
3083
3084 if (section->_cooked_size != 0)
3085 size = section->_cooked_size;
3086 else
3087 size = section->_raw_size;
3088 c = (bfd_byte *) bfd_zalloc (abfd, size);
3089 if (c == NULL)
3090 return false;
3091 elf_section_data (section)->tdata = (PTR) c;
3092 }
3093
3094 memcpy (c + offset, location, count);
3095 }
3096
3097 return _bfd_elf_set_section_contents (abfd, section, location, offset,
3098 count);
3099}
3100
3101/* Work over a section just before writing it out. This routine is
3102 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
3103 sections that need the SHF_MIPS_GPREL flag by name; there has to be
3104 a better way. */
3105
3106boolean
3107_bfd_mips_elf_section_processing (abfd, hdr)
3108 bfd *abfd;
3109 Elf_Internal_Shdr *hdr;
252b5132 3110{
cc3bfcee
ILT		 3111 if (hdr->sh_type == SHT_MIPS_REGINFO
3112 && hdr->sh_size > 0)
252b5132
RH		 3113 {
3114 bfd_byte buf[4];
3115
3116 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
3117 BFD_ASSERT (hdr->contents == NULL);
3118
3119 if (bfd_seek (abfd,
3120 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
3121 SEEK_SET) == -1)
3122 return false;
3123 bfd_h_put_32 (abfd, (bfd_vma) elf_gp (abfd), buf);
3124 if (bfd_write (buf, (bfd_size_type) 1, (bfd_size_type) 4, abfd) != 4)
3125 return false;
3126 }
3127
3128 if (hdr->sh_type == SHT_MIPS_OPTIONS
3129 && hdr->bfd_section != NULL
3130 && elf_section_data (hdr->bfd_section) != NULL
3131 && elf_section_data (hdr->bfd_section)->tdata != NULL)
3132 {
3133 bfd_byte *contents, *l, *lend;
3134
3135 /* We stored the section contents in the elf_section_data tdata
3136 field in the set_section_contents routine. We save the
3137 section contents so that we don't have to read them again.
3138 At this point we know that elf_gp is set, so we can look
3139 through the section contents to see if there is an
3140 ODK_REGINFO structure. */
3141
3142 contents = (bfd_byte *) elf_section_data (hdr->bfd_section)->tdata;
3143 l = contents;
3144 lend = contents + hdr->sh_size;
3145 while (l + sizeof (Elf_External_Options) <= lend)
3146 {
3147 Elf_Internal_Options intopt;
3148
3149 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
3150 &intopt);
103186c6
MM		 3151 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
3152 {
3153 bfd_byte buf[8];
3154
3155 if (bfd_seek (abfd,
3156 (hdr->sh_offset
3157 + (l - contents)
3158 + sizeof (Elf_External_Options)
3159 + (sizeof (Elf64_External_RegInfo) - 8)),
3160 SEEK_SET) == -1)
3161 return false;
3162 bfd_h_put_64 (abfd, elf_gp (abfd), buf);
3163 if (bfd_write (buf, 1, 8, abfd) != 8)
3164 return false;
3165 }
3166 else if (intopt.kind == ODK_REGINFO)
252b5132
RH		 3167 {
3168 bfd_byte buf[4];
3169
3170 if (bfd_seek (abfd,
3171 (hdr->sh_offset
3172 + (l - contents)
3173 + sizeof (Elf_External_Options)
3174 + (sizeof (Elf32_External_RegInfo) - 4)),
be3ccd9c 3175 SEEK_SET) == -1)
252b5132
RH		 3176 return false;
3177 bfd_h_put_32 (abfd, elf_gp (abfd), buf);
3178 if (bfd_write (buf, 1, 4, abfd) != 4)
3179 return false;
3180 }
3181 l += intopt.size;
3182 }
3183 }
3184
103186c6
MM		 3185 if (hdr->bfd_section != NULL)
3186 {
3187 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
3188
3189 if (strcmp (name, ".sdata") == 0
3190 || strcmp (name, ".lit8") == 0
3191 || strcmp (name, ".lit4") == 0)
3192 {
3193 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3194 hdr->sh_type = SHT_PROGBITS;
3195 }
3196 else if (strcmp (name, ".sbss") == 0)
3197 {
3198 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3199 hdr->sh_type = SHT_NOBITS;
3200 }
3201 else if (strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0)
3202 {
3203 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
3204 hdr->sh_type = SHT_PROGBITS;
3205 }
3206 else if (strcmp (name, ".compact_rel") == 0)
3207 {
3208 hdr->sh_flags = 0;
3209 hdr->sh_type = SHT_PROGBITS;
3210 }
3211 else if (strcmp (name, ".rtproc") == 0)
3212 {
3213 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
3214 {
3215 unsigned int adjust;
3216
3217 adjust = hdr->sh_size % hdr->sh_addralign;
3218 if (adjust != 0)
3219 hdr->sh_size += hdr->sh_addralign - adjust;
3220 }
3221 }
3222 }
3223
3224 return true;
252b5132
RH		 3225}
3226\f
3227/* MIPS ELF uses two common sections. One is the usual one, and the
3228 other is for small objects. All the small objects are kept
3229 together, and then referenced via the gp pointer, which yields
3230 faster assembler code. This is what we use for the small common
3231 section. This approach is copied from ecoff.c. */
3232static asection mips_elf_scom_section;
3233static asymbol mips_elf_scom_symbol;
3234static asymbol *mips_elf_scom_symbol_ptr;
3235
3236/* MIPS ELF also uses an acommon section, which represents an
3237 allocated common symbol which may be overridden by a
3238 definition in a shared library. */
3239static asection mips_elf_acom_section;
3240static asymbol mips_elf_acom_symbol;
3241static asymbol *mips_elf_acom_symbol_ptr;
3242
252b5132
RH		 3243/* Handle the special MIPS section numbers that a symbol may use.
3244 This is used for both the 32-bit and the 64-bit ABI. */
3245
3246void
3247_bfd_mips_elf_symbol_processing (abfd, asym)
3248 bfd *abfd;
3249 asymbol *asym;
3250{
3251 elf_symbol_type *elfsym;
3252
3253 elfsym = (elf_symbol_type *) asym;
3254 switch (elfsym->internal_elf_sym.st_shndx)
3255 {
3256 case SHN_MIPS_ACOMMON:
3257 /* This section is used in a dynamically linked executable file.
3258 It is an allocated common section. The dynamic linker can
3259 either resolve these symbols to something in a shared
3260 library, or it can just leave them here. For our purposes,
3261 we can consider these symbols to be in a new section. */
3262 if (mips_elf_acom_section.name == NULL)
3263 {
3264 /* Initialize the acommon section. */
3265 mips_elf_acom_section.name = ".acommon";
3266 mips_elf_acom_section.flags = SEC_ALLOC;
3267 mips_elf_acom_section.output_section = &mips_elf_acom_section;
3268 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
3269 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
3270 mips_elf_acom_symbol.name = ".acommon";
3271 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
3272 mips_elf_acom_symbol.section = &mips_elf_acom_section;
3273 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
3274 }
3275 asym->section = &mips_elf_acom_section;
3276 break;
3277
3278 case SHN_COMMON:
3279 /* Common symbols less than the GP size are automatically
7403cb63
MM		 3280 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3281 if (asym->value > elf_gp_size (abfd)
3282 || IRIX_COMPAT (abfd) == ict_irix6)
252b5132
RH		 3283 break;
3284 /* Fall through. */
3285 case SHN_MIPS_SCOMMON:
3286 if (mips_elf_scom_section.name == NULL)
3287 {
3288 /* Initialize the small common section. */
3289 mips_elf_scom_section.name = ".scommon";
3290 mips_elf_scom_section.flags = SEC_IS_COMMON;
3291 mips_elf_scom_section.output_section = &mips_elf_scom_section;
3292 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
3293 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
3294 mips_elf_scom_symbol.name = ".scommon";
3295 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
3296 mips_elf_scom_symbol.section = &mips_elf_scom_section;
3297 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
3298 }
3299 asym->section = &mips_elf_scom_section;
3300 asym->value = elfsym->internal_elf_sym.st_size;
3301 break;
3302
3303 case SHN_MIPS_SUNDEFINED:
3304 asym->section = bfd_und_section_ptr;
3305 break;
3306
3307#if 0 /* for SGI_COMPAT */
3308 case SHN_MIPS_TEXT:
3309 asym->section = mips_elf_text_section_ptr;
3310 break;
3311
3312 case SHN_MIPS_DATA:
3313 asym->section = mips_elf_data_section_ptr;
3314 break;
3315#endif
3316 }
3317}
3318\f
3319/* When creating an Irix 5 executable, we need REGINFO and RTPROC
3320 segments. */
3321
103186c6
MM		 3322int
3323_bfd_mips_elf_additional_program_headers (abfd)
252b5132
RH		 3324 bfd *abfd;
3325{
3326 asection *s;
303f629d 3327 int ret = 0;
252b5132 3328
303f629d 3329 /* See if we need a PT_MIPS_REGINFO segment. */
252b5132 3330 s = bfd_get_section_by_name (abfd, ".reginfo");
303f629d
MM		 3331 if (s && (s->flags & SEC_LOAD))
3332 ++ret;
252b5132 3333
303f629d
MM		 3334 /* See if we need a PT_MIPS_OPTIONS segment. */
3335 if (IRIX_COMPAT (abfd) == ict_irix6
be3ccd9c 3336 && bfd_get_section_by_name (abfd,
303f629d
MM		 3337 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
3338 ++ret;
3339
3340 /* See if we need a PT_MIPS_RTPROC segment. */
3341 if (IRIX_COMPAT (abfd) == ict_irix5
3342 && bfd_get_section_by_name (abfd, ".dynamic")
3343 && bfd_get_section_by_name (abfd, ".mdebug"))
3344 ++ret;
252b5132
RH		 3345
3346 return ret;
3347}
3348
3349/* Modify the segment map for an Irix 5 executable. */
3350
103186c6
MM		 3351boolean
3352_bfd_mips_elf_modify_segment_map (abfd)
252b5132
RH		 3353 bfd *abfd;
3354{
3355 asection *s;
3356 struct elf_segment_map *m, **pm;
3357
252b5132
RH		 3358 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3359 segment. */
3360 s = bfd_get_section_by_name (abfd, ".reginfo");
3361 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3362 {
3363 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3364 if (m->p_type == PT_MIPS_REGINFO)
3365 break;
3366 if (m == NULL)
3367 {
3368 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3369 if (m == NULL)
3370 return false;
3371
3372 m->p_type = PT_MIPS_REGINFO;
3373 m->count = 1;
3374 m->sections[0] = s;
3375
3376 /* We want to put it after the PHDR and INTERP segments. */
3377 pm = &elf_tdata (abfd)->segment_map;
3378 while (*pm != NULL
3379 && ((*pm)->p_type == PT_PHDR
3380 || (*pm)->p_type == PT_INTERP))
3381 pm = &(*pm)->next;
3382
3383 m->next = *pm;
3384 *pm = m;
3385 }
3386 }
3387
303f629d
MM		 3388 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3389 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3390 PT_OPTIONS segement immediately following the program header
3391 table. */
3392 if (IRIX_COMPAT (abfd) == ict_irix6)
252b5132 3393 {
303f629d
MM		 3394 asection *s;
3395
3396 for (s = abfd->sections; s; s = s->next)
3397 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
252b5132 3398 break;
303f629d
MM		 3399
3400 if (s)
252b5132 3401 {
303f629d
MM		 3402 struct elf_segment_map *options_segment;
3403
435394bf
MM		 3404 /* Usually, there's a program header table. But, sometimes
3405 there's not (like when running the `ld' testsuite). So,
3406 if there's no program header table, we just put the
3407 options segement at the end. */
be3ccd9c 3408 for (pm = &elf_tdata (abfd)->segment_map;
435394bf
MM		 3409 *pm != NULL;
3410 pm = &(*pm)->next)
3411 if ((*pm)->p_type == PT_PHDR)
303f629d
MM		 3412 break;
3413
be3ccd9c 3414 options_segment = bfd_zalloc (abfd,
303f629d 3415 sizeof (struct elf_segment_map));
435394bf 3416 options_segment->next = *pm;
303f629d
MM		 3417 options_segment->p_type = PT_MIPS_OPTIONS;
3418 options_segment->p_flags = PF_R;
3419 options_segment->p_flags_valid = true;
3420 options_segment->count = 1;
3421 options_segment->sections[0] = s;
435394bf 3422 *pm = options_segment;
303f629d
MM		 3423 }
3424 }
3425 else
3426 {
f7cb7d68 3427 if (IRIX_COMPAT (abfd) == ict_irix5)
303f629d 3428 {
f7cb7d68
UC		 3429 /* If there are .dynamic and .mdebug sections, we make a room
3430 for the RTPROC header. FIXME: Rewrite without section names. */
3431 if (bfd_get_section_by_name (abfd, ".interp") == NULL
3432 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
3433 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
252b5132 3434 {
f7cb7d68
UC		 3435 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3436 if (m->p_type == PT_MIPS_RTPROC)
3437 break;
303f629d 3438 if (m == NULL)
f7cb7d68
UC		 3439 {
3440 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3441 if (m == NULL)
3442 return false;
252b5132 3443
f7cb7d68 3444 m->p_type = PT_MIPS_RTPROC;
252b5132 3445
f7cb7d68
UC		 3446 s = bfd_get_section_by_name (abfd, ".rtproc");
3447 if (s == NULL)
3448 {
3449 m->count = 0;
3450 m->p_flags = 0;
3451 m->p_flags_valid = 1;
3452 }
3453 else
3454 {
3455 m->count = 1;
3456 m->sections[0] = s;
3457 }
303f629d 3458
f7cb7d68
UC		 3459 /* We want to put it after the DYNAMIC segment. */
3460 pm = &elf_tdata (abfd)->segment_map;
3461 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
3462 pm = &(*pm)->next;
3463 if (*pm != NULL)
3464 pm = &(*pm)->next;
303f629d 3465
f7cb7d68
UC		 3466 m->next = *pm;
3467 *pm = m;
3468 }
303f629d 3469 }
252b5132 3470 }
303f629d
MM		 3471 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3472 .dynstr, .dynsym, and .hash sections, and everything in
3473 between. */
f7cb7d68
UC		 3474 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
3475 pm = &(*pm)->next)
303f629d
MM		 3476 if ((*pm)->p_type == PT_DYNAMIC)
3477 break;
3478 m = *pm;
f7cb7d68
UC		 3479 if (IRIX_COMPAT (abfd) == ict_none)
3480 {
3481 /* For a normal mips executable the permissions for the PT_DYNAMIC
3482 segment are read, write and execute. We do that here since
3483 the code in elf.c sets only the read permission. This matters
be3ccd9c 3484 sometimes for the dynamic linker. */
f7cb7d68
UC		 3485 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3486 {
3487 m->p_flags = PF_R | PF_W | PF_X;
3488 m->p_flags_valid = 1;
3489 }
3490 }
303f629d 3491 if (m != NULL
f7cb7d68 3492 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
252b5132 3493 {
be3ccd9c
KH		 3494 static const char *sec_names[] = {
3495 ".dynamic", ".dynstr", ".dynsym", ".hash"
3496 };
303f629d
MM		 3497 bfd_vma low, high;
3498 unsigned int i, c;
3499 struct elf_segment_map *n;
3500
3501 low = 0xffffffff;
3502 high = 0;
3503 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
252b5132 3504 {
303f629d
MM		 3505 s = bfd_get_section_by_name (abfd, sec_names[i]);
3506 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3507 {
3508 bfd_size_type sz;
3509
3510 if (low > s->vma)
3511 low = s->vma;
3512 sz = s->_cooked_size;
3513 if (sz == 0)
3514 sz = s->_raw_size;
3515 if (high < s->vma + sz)
3516 high = s->vma + sz;
3517 }
252b5132 3518 }
252b5132 3519
303f629d
MM		 3520 c = 0;
3521 for (s = abfd->sections; s != NULL; s = s->next)
3522 if ((s->flags & SEC_LOAD) != 0
3523 && s->vma >= low
3524 && ((s->vma
f7cb7d68
UC		 3525 + (s->_cooked_size !=
3526 0 ? s->_cooked_size : s->_raw_size)) <= high))
303f629d
MM		 3527 ++c;
3528
3529 n = ((struct elf_segment_map *)
3530 bfd_zalloc (abfd, sizeof *n + (c - 1) * sizeof (asection *)));
3531 if (n == NULL)
3532 return false;
3533 *n = *m;
3534 n->count = c;
252b5132 3535
303f629d
MM		 3536 i = 0;
3537 for (s = abfd->sections; s != NULL; s = s->next)
252b5132 3538 {
303f629d
MM		 3539 if ((s->flags & SEC_LOAD) != 0
3540 && s->vma >= low
3541 && ((s->vma
3542 + (s->_cooked_size != 0 ?
f7cb7d68 3543 s->_cooked_size : s->_raw_size)) <= high))
303f629d
MM		 3544 {
3545 n->sections[i] = s;
3546 ++i;
3547 }
252b5132 3548 }
252b5132 3549
303f629d
MM		 3550 *pm = n;
3551 }
252b5132
RH		 3552 }
3553
3554 return true;
3555}
3556\f
3557/* The structure of the runtime procedure descriptor created by the
3558 loader for use by the static exception system. */
3559
3560typedef struct runtime_pdr {
3561 bfd_vma adr; /* memory address of start of procedure */
3562 long regmask; /* save register mask */
3563 long regoffset; /* save register offset */
3564 long fregmask; /* save floating point register mask */
3565 long fregoffset; /* save floating point register offset */
3566 long frameoffset; /* frame size */
3567 short framereg; /* frame pointer register */
3568 short pcreg; /* offset or reg of return pc */
3569 long irpss; /* index into the runtime string table */
3570 long reserved;
3571 struct exception_info *exception_info;/* pointer to exception array */
3572} RPDR, *pRPDR;
be3ccd9c 3573#define cbRPDR sizeof (RPDR)
252b5132
RH		 3574#define rpdNil ((pRPDR) 0)
3575
3576/* Swap RPDR (runtime procedure table entry) for output. */
3577
3578static void ecoff_swap_rpdr_out
3579 PARAMS ((bfd *, const RPDR *, struct rpdr_ext *));
3580
3581static void
3582ecoff_swap_rpdr_out (abfd, in, ex)
3583 bfd *abfd;
3584 const RPDR *in;
3585 struct rpdr_ext *ex;
3586{
3587 /* ecoff_put_off was defined in ecoffswap.h. */
3588 ecoff_put_off (abfd, in->adr, (bfd_byte *) ex->p_adr);
3589 bfd_h_put_32 (abfd, in->regmask, (bfd_byte *) ex->p_regmask);
3590 bfd_h_put_32 (abfd, in->regoffset, (bfd_byte *) ex->p_regoffset);
3591 bfd_h_put_32 (abfd, in->fregmask, (bfd_byte *) ex->p_fregmask);
3592 bfd_h_put_32 (abfd, in->fregoffset, (bfd_byte *) ex->p_fregoffset);
3593 bfd_h_put_32 (abfd, in->frameoffset, (bfd_byte *) ex->p_frameoffset);
3594
3595 bfd_h_put_16 (abfd, in->framereg, (bfd_byte *) ex->p_framereg);
3596 bfd_h_put_16 (abfd, in->pcreg, (bfd_byte *) ex->p_pcreg);
3597
3598 bfd_h_put_32 (abfd, in->irpss, (bfd_byte *) ex->p_irpss);
3599#if 0 /* FIXME */
3600 ecoff_put_off (abfd, in->exception_info, (bfd_byte *) ex->p_exception_info);
3601#endif
3602}
3603\f
3604/* Read ECOFF debugging information from a .mdebug section into a
3605 ecoff_debug_info structure. */
3606
3607boolean
3608_bfd_mips_elf_read_ecoff_info (abfd, section, debug)
3609 bfd *abfd;
3610 asection *section;
3611 struct ecoff_debug_info *debug;
3612{
3613 HDRR *symhdr;
3614 const struct ecoff_debug_swap *swap;
3615 char *ext_hdr = NULL;
3616
3617 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
be3ccd9c 3618 memset (debug, 0, sizeof (*debug));
252b5132
RH		 3619
3620 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
3621 if (ext_hdr == NULL && swap->external_hdr_size != 0)
3622 goto error_return;
3623
3624 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
3625 swap->external_hdr_size)
3626 == false)
3627 goto error_return;
3628
3629 symhdr = &debug->symbolic_header;
3630 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
3631
3632 /* The symbolic header contains absolute file offsets and sizes to
3633 read. */
3634#define READ(ptr, offset, count, size, type) \
3635 if (symhdr->count == 0) \
3636 debug->ptr = NULL; \
3637 else \
3638 { \
3639 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3640 if (debug->ptr == NULL) \
3641 goto error_return; \
3642 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3643 || (bfd_read (debug->ptr, size, symhdr->count, \
3644 abfd) != size * symhdr->count)) \
3645 goto error_return; \
3646 }
3647
3648 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
3649 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
3650 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
3651 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
3652 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
3653 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3654 union aux_ext *);
3655 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3656 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
3657 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
3658 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
3659 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
3660#undef READ
3661
3662 debug->fdr = NULL;
3663 debug->adjust = NULL;
3664
3665 return true;
3666
3667 error_return:
3668 if (ext_hdr != NULL)
3669 free (ext_hdr);
3670 if (debug->line != NULL)
3671 free (debug->line);
3672 if (debug->external_dnr != NULL)
3673 free (debug->external_dnr);
3674 if (debug->external_pdr != NULL)
3675 free (debug->external_pdr);
3676 if (debug->external_sym != NULL)
3677 free (debug->external_sym);
3678 if (debug->external_opt != NULL)
3679 free (debug->external_opt);
3680 if (debug->external_aux != NULL)
3681 free (debug->external_aux);
3682 if (debug->ss != NULL)
3683 free (debug->ss);
3684 if (debug->ssext != NULL)
3685 free (debug->ssext);
3686 if (debug->external_fdr != NULL)
3687 free (debug->external_fdr);
3688 if (debug->external_rfd != NULL)
3689 free (debug->external_rfd);
3690 if (debug->external_ext != NULL)
3691 free (debug->external_ext);
3692 return false;
3693}
3694\f
3695/* MIPS ELF local labels start with '$', not 'L'. */
3696
252b5132
RH		 3697static boolean
3698mips_elf_is_local_label_name (abfd, name)
3699 bfd *abfd;
3700 const char *name;
3701{
3702 if (name[0] == '$')
3703 return true;
3704
3705 /* On Irix 6, the labels go back to starting with '.', so we accept
3706 the generic ELF local label syntax as well. */
3707 return _bfd_elf_is_local_label_name (abfd, name);
3708}
3709
3710/* MIPS ELF uses a special find_nearest_line routine in order the
3711 handle the ECOFF debugging information. */
3712
be3ccd9c 3713struct mips_elf_find_line {
252b5132
RH		 3714 struct ecoff_debug_info d;
3715 struct ecoff_find_line i;
3716};
3717
3718boolean
3719_bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
3720 functionname_ptr, line_ptr)
3721 bfd *abfd;
3722 asection *section;
3723 asymbol **symbols;
3724 bfd_vma offset;
3725 const char **filename_ptr;
3726 const char **functionname_ptr;
3727 unsigned int *line_ptr;
3728{
3729 asection *msec;
3730
3731 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
3732 filename_ptr, functionname_ptr,
3733 line_ptr))
3734 return true;
3735
3736 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
3737 filename_ptr, functionname_ptr,
be3ccd9c 3738 line_ptr,
51db3708 3739 ABI_64_P (abfd) ? 8 : 0, NULL))
252b5132
RH		 3740 return true;
3741
3742 msec = bfd_get_section_by_name (abfd, ".mdebug");
3743 if (msec != NULL)
3744 {
3745 flagword origflags;
3746 struct mips_elf_find_line *fi;
3747 const struct ecoff_debug_swap * const swap =
3748 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3749
3750 /* If we are called during a link, mips_elf_final_link may have
3751 cleared the SEC_HAS_CONTENTS field. We force it back on here
3752 if appropriate (which it normally will be). */
3753 origflags = msec->flags;
3754 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
3755 msec->flags |= SEC_HAS_CONTENTS;
3756
3757 fi = elf_tdata (abfd)->find_line_info;
3758 if (fi == NULL)
3759 {
3760 bfd_size_type external_fdr_size;
3761 char *fraw_src;
3762 char *fraw_end;
3763 struct fdr *fdr_ptr;
3764
3765 fi = ((struct mips_elf_find_line *)
3766 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
3767 if (fi == NULL)
3768 {
3769 msec->flags = origflags;
3770 return false;
3771 }
3772
3773 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
3774 {
3775 msec->flags = origflags;
3776 return false;
3777 }
3778
3779 /* Swap in the FDR information. */
3780 fi->d.fdr = ((struct fdr *)
3781 bfd_alloc (abfd,
3782 (fi->d.symbolic_header.ifdMax *
3783 sizeof (struct fdr))));
3784 if (fi->d.fdr == NULL)
3785 {
3786 msec->flags = origflags;
3787 return false;
3788 }
3789 external_fdr_size = swap->external_fdr_size;
3790 fdr_ptr = fi->d.fdr;
3791 fraw_src = (char *) fi->d.external_fdr;
3792 fraw_end = (fraw_src
3793 + fi->d.symbolic_header.ifdMax * external_fdr_size);
3794 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
3795 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
3796
3797 elf_tdata (abfd)->find_line_info = fi;
3798
3799 /* Note that we don't bother to ever free this information.
3800 find_nearest_line is either called all the time, as in
3801 objdump -l, so the information should be saved, or it is
3802 rarely called, as in ld error messages, so the memory
3803 wasted is unimportant. Still, it would probably be a
3804 good idea for free_cached_info to throw it away. */
3805 }
3806
3807 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
3808 &fi->i, filename_ptr, functionname_ptr,
3809 line_ptr))
3810 {
3811 msec->flags = origflags;
3812 return true;
3813 }
3814
3815 msec->flags = origflags;
3816 }
3817
3818 /* Fall back on the generic ELF find_nearest_line routine. */
3819
3820 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
3821 filename_ptr, functionname_ptr,
3822 line_ptr);
3823}
3824\f
3825 /* The mips16 compiler uses a couple of special sections to handle
3826 floating point arguments.
3827
3828 Section names that look like .mips16.fn.FNNAME contain stubs that
3829 copy floating point arguments from the fp regs to the gp regs and
3830 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3831 call should be redirected to the stub instead. If no 32 bit
3832 function calls FNNAME, the stub should be discarded. We need to
3833 consider any reference to the function, not just a call, because
3834 if the address of the function is taken we will need the stub,
3835 since the address might be passed to a 32 bit function.
3836
3837 Section names that look like .mips16.call.FNNAME contain stubs
3838 that copy floating point arguments from the gp regs to the fp
3839 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3840 then any 16 bit function that calls FNNAME should be redirected
3841 to the stub instead. If FNNAME is not a 32 bit function, the
3842 stub should be discarded.
3843
3844 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3845 which call FNNAME and then copy the return value from the fp regs
3846 to the gp regs. These stubs store the return value in $18 while
3847 calling FNNAME; any function which might call one of these stubs
3848 must arrange to save $18 around the call. (This case is not
3849 needed for 32 bit functions that call 16 bit functions, because
3850 16 bit functions always return floating point values in both
3851 $f0/$f1 and $2/$3.)
3852
3853 Note that in all cases FNNAME might be defined statically.
3854 Therefore, FNNAME is not used literally. Instead, the relocation
3855 information will indicate which symbol the section is for.
3856
3857 We record any stubs that we find in the symbol table. */
3858
3859#define FN_STUB ".mips16.fn."
3860#define CALL_STUB ".mips16.call."
3861#define CALL_FP_STUB ".mips16.call.fp."
3862
252b5132
RH		 3863/* MIPS ELF linker hash table. */
3864
be3ccd9c 3865struct mips_elf_link_hash_table {
252b5132
RH		 3866 struct elf_link_hash_table root;
3867#if 0
3868 /* We no longer use this. */
3869 /* String section indices for the dynamic section symbols. */
3870 bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
3871#endif
3872 /* The number of .rtproc entries. */
3873 bfd_size_type procedure_count;
3874 /* The size of the .compact_rel section (if SGI_COMPAT). */
3875 bfd_size_type compact_rel_size;
3876 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
be3ccd9c 3877 entry is set to the address of __rld_obj_head as in Irix 5. */
252b5132
RH		 3878 boolean use_rld_obj_head;
3879 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3880 bfd_vma rld_value;
be3ccd9c 3881 /* This is set if we see any mips16 stub sections. */
252b5132
RH		 3882 boolean mips16_stubs_seen;
3883};
3884
3885/* Look up an entry in a MIPS ELF linker hash table. */
3886
3887#define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3888 ((struct mips_elf_link_hash_entry *) \
3889 elf_link_hash_lookup (&(table)->root, (string), (create), \
3890 (copy), (follow)))
3891
3892/* Traverse a MIPS ELF linker hash table. */
3893
3894#define mips_elf_link_hash_traverse(table, func, info) \
3895 (elf_link_hash_traverse \
3896 (&(table)->root, \
3897 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3898 (info)))
3899
3900/* Get the MIPS ELF linker hash table from a link_info structure. */
3901
3902#define mips_elf_hash_table(p) \
3903 ((struct mips_elf_link_hash_table *) ((p)->hash))
3904
3905static boolean mips_elf_output_extsym
3906 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
3907
3908/* Create an entry in a MIPS ELF linker hash table. */
3909
3910static struct bfd_hash_entry *
3911mips_elf_link_hash_newfunc (entry, table, string)
3912 struct bfd_hash_entry *entry;
3913 struct bfd_hash_table *table;
3914 const char *string;
3915{
3916 struct mips_elf_link_hash_entry *ret =
3917 (struct mips_elf_link_hash_entry *) entry;
3918
3919 /* Allocate the structure if it has not already been allocated by a
3920 subclass. */
3921 if (ret == (struct mips_elf_link_hash_entry *) NULL)
3922 ret = ((struct mips_elf_link_hash_entry *)
3923 bfd_hash_allocate (table,
3924 sizeof (struct mips_elf_link_hash_entry)));
3925 if (ret == (struct mips_elf_link_hash_entry *) NULL)
3926 return (struct bfd_hash_entry *) ret;
3927
3928 /* Call the allocation method of the superclass. */
3929 ret = ((struct mips_elf_link_hash_entry *)
3930 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3931 table, string));
3932 if (ret != (struct mips_elf_link_hash_entry *) NULL)
3933 {
3934 /* Set local fields. */
3935 memset (&ret->esym, 0, sizeof (EXTR));
3936 /* We use -2 as a marker to indicate that the information has
3937 not been set. -1 means there is no associated ifd. */
3938 ret->esym.ifd = -2;
a3c7651d 3939 ret->possibly_dynamic_relocs = 0;
c6142e5d 3940 ret->min_dyn_reloc_index = 0;
252b5132
RH		 3941 ret->fn_stub = NULL;
3942 ret->need_fn_stub = false;
3943 ret->call_stub = NULL;
3944 ret->call_fp_stub = NULL;
3945 }
3946
3947 return (struct bfd_hash_entry *) ret;
3948}
3949
b305ef96 3950void
be3ccd9c 3951_bfd_mips_elf_hide_symbol (info, h)
b305ef96
UC		 3952 struct bfd_link_info *info;
3953 struct mips_elf_link_hash_entry *h;
3954{
3955 bfd *dynobj;
3956 asection *got;
3957 struct mips_got_info *g;
3958 dynobj = elf_hash_table (info)->dynobj;
3959 got = bfd_get_section_by_name (dynobj, ".got");
3960 g = (struct mips_got_info *) elf_section_data (got)->tdata;
3961
3962 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3963 h->root.plt.offset = (bfd_vma) -1;
3964 h->root.dynindx = -1;
3965
3966 /* FIXME: Do we allocate too much GOT space here? */
3967 g->local_gotno++;
3968 got->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
3969}
3970
252b5132
RH		 3971/* Create a MIPS ELF linker hash table. */
3972
103186c6
MM		 3973struct bfd_link_hash_table *
3974_bfd_mips_elf_link_hash_table_create (abfd)
252b5132
RH		 3975 bfd *abfd;
3976{
3977 struct mips_elf_link_hash_table *ret;
3978
3979 ret = ((struct mips_elf_link_hash_table *)
3980 bfd_alloc (abfd, sizeof (struct mips_elf_link_hash_table)));
3981 if (ret == (struct mips_elf_link_hash_table *) NULL)
3982 return NULL;
3983
3984 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3985 mips_elf_link_hash_newfunc))
3986 {
3987 bfd_release (abfd, ret);
3988 return NULL;
3989 }
3990
3991#if 0
3992 /* We no longer use this. */
3993 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
3994 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
3995#endif
3996 ret->procedure_count = 0;
3997 ret->compact_rel_size = 0;
3998 ret->use_rld_obj_head = false;
3999 ret->rld_value = 0;
4000 ret->mips16_stubs_seen = false;
4001
4002 return &ret->root.root;
4003}
4004
4005/* Hook called by the linker routine which adds symbols from an object
4006 file. We must handle the special MIPS section numbers here. */
4007
103186c6
MM		 4008boolean
4009_bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
252b5132
RH		 4010 bfd *abfd;
4011 struct bfd_link_info *info;
4012 const Elf_Internal_Sym *sym;
4013 const char **namep;
5f771d47 4014 flagword *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 4015 asection **secp;
4016 bfd_vma *valp;
4017{
4018 if (SGI_COMPAT (abfd)
4019 && (abfd->flags & DYNAMIC) != 0
4020 && strcmp (*namep, "_rld_new_interface") == 0)
4021 {
4022 /* Skip Irix 5 rld entry name. */
4023 *namep = NULL;
4024 return true;
4025 }
4026
4027 switch (sym->st_shndx)
4028 {
4029 case SHN_COMMON:
4030 /* Common symbols less than the GP size are automatically
4031 treated as SHN_MIPS_SCOMMON symbols. */
7403cb63
MM		 4032 if (sym->st_size > elf_gp_size (abfd)
4033 || IRIX_COMPAT (abfd) == ict_irix6)
252b5132
RH		 4034 break;
4035 /* Fall through. */
4036 case SHN_MIPS_SCOMMON:
4037 *secp = bfd_make_section_old_way (abfd, ".scommon");
4038 (*secp)->flags |= SEC_IS_COMMON;
4039 *valp = sym->st_size;
4040 break;
4041
4042 case SHN_MIPS_TEXT:
4043 /* This section is used in a shared object. */
b305ef96 4044 if (elf_tdata (abfd)->elf_text_section == NULL)
252b5132 4045 {
b305ef96
UC		 4046 asymbol *elf_text_symbol;
4047 asection *elf_text_section;
4048
4049 elf_text_section = bfd_zalloc (abfd, sizeof (asection));
4050 if (elf_text_section == NULL)
4051 return false;
4052
4053 elf_text_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4054 if (elf_text_symbol == NULL)
4055 return false;
4056
252b5132 4057 /* Initialize the section. */
b305ef96
UC		 4058
4059 elf_tdata (abfd)->elf_text_section = elf_text_section;
4060 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4061
4062 elf_text_section->symbol = elf_text_symbol;
4063 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4064
4065 elf_text_section->name = ".text";
4066 elf_text_section->flags = SEC_NO_FLAGS;
4067 elf_text_section->output_section = NULL;
4068 elf_text_section->owner = abfd;
4069 elf_text_symbol->name = ".text";
4070 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4071 elf_text_symbol->section = elf_text_section;
252b5132
RH		 4072 }
4073 /* This code used to do *secp = bfd_und_section_ptr if
4074 info->shared. I don't know why, and that doesn't make sense,
4075 so I took it out. */
b305ef96 4076 *secp = elf_tdata (abfd)->elf_text_section;
252b5132
RH		 4077 break;
4078
4079 case SHN_MIPS_ACOMMON:
4080 /* Fall through. XXX Can we treat this as allocated data? */
4081 case SHN_MIPS_DATA:
4082 /* This section is used in a shared object. */
b305ef96 4083 if (elf_tdata (abfd)->elf_data_section == NULL)
252b5132 4084 {
b305ef96
UC		 4085 asymbol *elf_data_symbol;
4086 asection *elf_data_section;
4087
4088 elf_data_section = bfd_zalloc (abfd, sizeof (asection));
4089 if (elf_data_section == NULL)
4090 return false;
4091
4092 elf_data_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4093 if (elf_data_symbol == NULL)
4094 return false;
4095
252b5132 4096 /* Initialize the section. */
b305ef96
UC		 4097
4098 elf_tdata (abfd)->elf_data_section = elf_data_section;
4099 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4100
4101 elf_data_section->symbol = elf_data_symbol;
4102 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4103
4104 elf_data_section->name = ".data";
4105 elf_data_section->flags = SEC_NO_FLAGS;
4106 elf_data_section->output_section = NULL;
4107 elf_data_section->owner = abfd;
4108 elf_data_symbol->name = ".data";
4109 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4110 elf_data_symbol->section = elf_data_section;
252b5132
RH		 4111 }
4112 /* This code used to do *secp = bfd_und_section_ptr if
4113 info->shared. I don't know why, and that doesn't make sense,
4114 so I took it out. */
b305ef96 4115 *secp = elf_tdata (abfd)->elf_data_section;
252b5132
RH		 4116 break;
4117
4118 case SHN_MIPS_SUNDEFINED:
4119 *secp = bfd_und_section_ptr;
4120 break;
4121 }
4122
4123 if (SGI_COMPAT (abfd)
4124 && ! info->shared
4125 && info->hash->creator == abfd->xvec
4126 && strcmp (*namep, "__rld_obj_head") == 0)
4127 {
4128 struct elf_link_hash_entry *h;
4129
4130 /* Mark __rld_obj_head as dynamic. */
4131 h = NULL;
4132 if (! (_bfd_generic_link_add_one_symbol
4133 (info, abfd, *namep, BSF_GLOBAL, *secp,
4134 (bfd_vma) *valp, (const char *) NULL, false,
4135 get_elf_backend_data (abfd)->collect,
4136 (struct bfd_link_hash_entry **) &h)))
4137 return false;
be3ccd9c 4138 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH		 4139 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4140 h->type = STT_OBJECT;
4141
4142 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4143 return false;
4144
4145 mips_elf_hash_table (info)->use_rld_obj_head = true;
4146 }
4147
4148 /* If this is a mips16 text symbol, add 1 to the value to make it
4149 odd. This will cause something like .word SYM to come up with
4150 the right value when it is loaded into the PC. */
4151 if (sym->st_other == STO_MIPS16)
4152 ++*valp;
4153
4154 return true;
4155}
4156
4157/* Structure used to pass information to mips_elf_output_extsym. */
4158
be3ccd9c 4159struct extsym_info {
252b5132
RH		 4160 bfd *abfd;
4161 struct bfd_link_info *info;
4162 struct ecoff_debug_info *debug;
4163 const struct ecoff_debug_swap *swap;
4164 boolean failed;
4165};
4166
4167/* This routine is used to write out ECOFF debugging external symbol
4168 information. It is called via mips_elf_link_hash_traverse. The
4169 ECOFF external symbol information must match the ELF external
4170 symbol information. Unfortunately, at this point we don't know
4171 whether a symbol is required by reloc information, so the two
4172 tables may wind up being different. We must sort out the external
4173 symbol information before we can set the final size of the .mdebug
4174 section, and we must set the size of the .mdebug section before we
4175 can relocate any sections, and we can't know which symbols are
4176 required by relocation until we relocate the sections.
4177 Fortunately, it is relatively unlikely that any symbol will be
4178 stripped but required by a reloc. In particular, it can not happen
4179 when generating a final executable. */
4180
4181static boolean
4182mips_elf_output_extsym (h, data)
4183 struct mips_elf_link_hash_entry *h;
4184 PTR data;
4185{
4186 struct extsym_info *einfo = (struct extsym_info *) data;
4187 boolean strip;
4188 asection *sec, *output_section;
4189
4190 if (h->root.indx == -2)
4191 strip = false;
4192 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4193 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
4194 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4195 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4196 strip = true;
4197 else if (einfo->info->strip == strip_all
4198 || (einfo->info->strip == strip_some
4199 && bfd_hash_lookup (einfo->info->keep_hash,
4200 h->root.root.root.string,
4201 false, false) == NULL))
4202 strip = true;
4203 else
4204 strip = false;
4205
4206 if (strip)
4207 return true;
4208
4209 if (h->esym.ifd == -2)
4210 {
4211 h->esym.jmptbl = 0;
4212 h->esym.cobol_main = 0;
4213 h->esym.weakext = 0;
4214 h->esym.reserved = 0;
4215 h->esym.ifd = ifdNil;
4216 h->esym.asym.value = 0;
4217 h->esym.asym.st = stGlobal;
4218
f7cb7d68 4219 if (h->root.root.type == bfd_link_hash_undefined
be3ccd9c 4220 || h->root.root.type == bfd_link_hash_undefweak)
252b5132
RH		 4221 {
4222 const char *name;
4223
4224 /* Use undefined class. Also, set class and type for some
4225 special symbols. */
4226 name = h->root.root.root.string;
4227 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
4228 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
4229 {
4230 h->esym.asym.sc = scData;
4231 h->esym.asym.st = stLabel;
4232 h->esym.asym.value = 0;
4233 }
4234 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
4235 {
4236 h->esym.asym.sc = scAbs;
4237 h->esym.asym.st = stLabel;
4238 h->esym.asym.value =
4239 mips_elf_hash_table (einfo->info)->procedure_count;
4240 }
4241 else if (strcmp (name, "_gp_disp") == 0)
4242 {
4243 h->esym.asym.sc = scAbs;
4244 h->esym.asym.st = stLabel;
4245 h->esym.asym.value = elf_gp (einfo->abfd);
4246 }
4247 else
4248 h->esym.asym.sc = scUndefined;
4249 }
4250 else if (h->root.root.type != bfd_link_hash_defined
4251 && h->root.root.type != bfd_link_hash_defweak)
4252 h->esym.asym.sc = scAbs;
4253 else
4254 {
4255 const char *name;
4256
4257 sec = h->root.root.u.def.section;
4258 output_section = sec->output_section;
4259
4260 /* When making a shared library and symbol h is the one from
4261 the another shared library, OUTPUT_SECTION may be null. */
4262 if (output_section == NULL)
4263 h->esym.asym.sc = scUndefined;
4264 else
4265 {
4266 name = bfd_section_name (output_section->owner, output_section);
4267
4268 if (strcmp (name, ".text") == 0)
4269 h->esym.asym.sc = scText;
4270 else if (strcmp (name, ".data") == 0)
4271 h->esym.asym.sc = scData;
4272 else if (strcmp (name, ".sdata") == 0)
4273 h->esym.asym.sc = scSData;
4274 else if (strcmp (name, ".rodata") == 0
4275 || strcmp (name, ".rdata") == 0)
4276 h->esym.asym.sc = scRData;
4277 else if (strcmp (name, ".bss") == 0)
4278 h->esym.asym.sc = scBss;
4279 else if (strcmp (name, ".sbss") == 0)
4280 h->esym.asym.sc = scSBss;
4281 else if (strcmp (name, ".init") == 0)
4282 h->esym.asym.sc = scInit;
4283 else if (strcmp (name, ".fini") == 0)
4284 h->esym.asym.sc = scFini;
4285 else
4286 h->esym.asym.sc = scAbs;
4287 }
4288 }
4289
4290 h->esym.asym.reserved = 0;
4291 h->esym.asym.index = indexNil;
4292 }
4293
4294 if (h->root.root.type == bfd_link_hash_common)
4295 h->esym.asym.value = h->root.root.u.c.size;
4296 else if (h->root.root.type == bfd_link_hash_defined
4297 || h->root.root.type == bfd_link_hash_defweak)
4298 {
4299 if (h->esym.asym.sc == scCommon)
4300 h->esym.asym.sc = scBss;
4301 else if (h->esym.asym.sc == scSCommon)
4302 h->esym.asym.sc = scSBss;
4303
4304 sec = h->root.root.u.def.section;
4305 output_section = sec->output_section;
4306 if (output_section != NULL)
4307 h->esym.asym.value = (h->root.root.u.def.value
4308 + sec->output_offset
4309 + output_section->vma);
4310 else
4311 h->esym.asym.value = 0;
4312 }
4313 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4314 {
4315 /* Set type and value for a symbol with a function stub. */
4316 h->esym.asym.st = stProc;
4317 sec = h->root.root.u.def.section;
4318 if (sec == NULL)
4319 h->esym.asym.value = 0;
4320 else
4321 {
4322 output_section = sec->output_section;
4323 if (output_section != NULL)
4324 h->esym.asym.value = (h->root.plt.offset
4325 + sec->output_offset
4326 + output_section->vma);
4327 else
4328 h->esym.asym.value = 0;
4329 }
4330#if 0 /* FIXME? */
4331 h->esym.ifd = 0;
4332#endif
4333 }
4334
4335 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
4336 h->root.root.root.string,
4337 &h->esym))
4338 {
4339 einfo->failed = true;
4340 return false;
4341 }
4342
4343 return true;
4344}
4345
4346/* Create a runtime procedure table from the .mdebug section. */
4347
4348static boolean
4349mips_elf_create_procedure_table (handle, abfd, info, s, debug)
4350 PTR handle;
4351 bfd *abfd;
4352 struct bfd_link_info *info;
4353 asection *s;
4354 struct ecoff_debug_info *debug;
4355{
4356 const struct ecoff_debug_swap *swap;
4357 HDRR *hdr = &debug->symbolic_header;
4358 RPDR *rpdr, *rp;
4359 struct rpdr_ext *erp;
4360 PTR rtproc;
4361 struct pdr_ext *epdr;
4362 struct sym_ext *esym;
4363 char *ss, **sv;
4364 char *str;
4365 unsigned long size, count;
4366 unsigned long sindex;
4367 unsigned long i;
4368 PDR pdr;
4369 SYMR sym;
4370 const char *no_name_func = _("static procedure (no name)");
4371
4372 epdr = NULL;
4373 rpdr = NULL;
4374 esym = NULL;
4375 ss = NULL;
4376 sv = NULL;
4377
4378 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4379
4380 sindex = strlen (no_name_func) + 1;
4381 count = hdr->ipdMax;
4382 if (count > 0)
4383 {
4384 size = swap->external_pdr_size;
4385
4386 epdr = (struct pdr_ext *) bfd_malloc (size * count);
4387 if (epdr == NULL)
4388 goto error_return;
4389
4390 if (! _bfd_ecoff_get_accumulated_pdr (handle, (PTR) epdr))
4391 goto error_return;
4392
4393 size = sizeof (RPDR);
4394 rp = rpdr = (RPDR *) bfd_malloc (size * count);
4395 if (rpdr == NULL)
4396 goto error_return;
4397
4398 sv = (char **) bfd_malloc (sizeof (char *) * count);
4399 if (sv == NULL)
4400 goto error_return;
4401
4402 count = hdr->isymMax;
4403 size = swap->external_sym_size;
4404 esym = (struct sym_ext *) bfd_malloc (size * count);
4405 if (esym == NULL)
4406 goto error_return;
4407
4408 if (! _bfd_ecoff_get_accumulated_sym (handle, (PTR) esym))
4409 goto error_return;
4410
4411 count = hdr->issMax;
4412 ss = (char *) bfd_malloc (count);
4413 if (ss == NULL)
4414 goto error_return;
4415 if (! _bfd_ecoff_get_accumulated_ss (handle, (PTR) ss))
4416 goto error_return;
4417
4418 count = hdr->ipdMax;
4419 for (i = 0; i < count; i++, rp++)
4420 {
4421 (*swap->swap_pdr_in) (abfd, (PTR) (epdr + i), &pdr);
4422 (*swap->swap_sym_in) (abfd, (PTR) &esym[pdr.isym], &sym);
4423 rp->adr = sym.value;
4424 rp->regmask = pdr.regmask;
4425 rp->regoffset = pdr.regoffset;
4426 rp->fregmask = pdr.fregmask;
4427 rp->fregoffset = pdr.fregoffset;
4428 rp->frameoffset = pdr.frameoffset;
4429 rp->framereg = pdr.framereg;
4430 rp->pcreg = pdr.pcreg;
4431 rp->irpss = sindex;
4432 sv[i] = ss + sym.iss;
4433 sindex += strlen (sv[i]) + 1;
4434 }
4435 }
4436
4437 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
4438 size = BFD_ALIGN (size, 16);
4439 rtproc = (PTR) bfd_alloc (abfd, size);
4440 if (rtproc == NULL)
4441 {
4442 mips_elf_hash_table (info)->procedure_count = 0;
4443 goto error_return;
4444 }
4445
4446 mips_elf_hash_table (info)->procedure_count = count + 2;
4447
4448 erp = (struct rpdr_ext *) rtproc;
4449 memset (erp, 0, sizeof (struct rpdr_ext));
4450 erp++;
4451 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
4452 strcpy (str, no_name_func);
4453 str += strlen (no_name_func) + 1;
4454 for (i = 0; i < count; i++)
4455 {
4456 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
4457 strcpy (str, sv[i]);
4458 str += strlen (sv[i]) + 1;
4459 }
4460 ecoff_put_off (abfd, (bfd_vma) -1, (bfd_byte *) (erp + count)->p_adr);
4461
4462 /* Set the size and contents of .rtproc section. */
4463 s->_raw_size = size;
4464 s->contents = (bfd_byte *) rtproc;
4465
4466 /* Skip this section later on (I don't think this currently
4467 matters, but someday it might). */
4468 s->link_order_head = (struct bfd_link_order *) NULL;
4469
4470 if (epdr != NULL)
4471 free (epdr);
4472 if (rpdr != NULL)
4473 free (rpdr);
4474 if (esym != NULL)
4475 free (esym);
4476 if (ss != NULL)
4477 free (ss);
4478 if (sv != NULL)
4479 free (sv);
4480
4481 return true;
4482
4483 error_return:
4484 if (epdr != NULL)
4485 free (epdr);
4486 if (rpdr != NULL)
4487 free (rpdr);
4488 if (esym != NULL)
4489 free (esym);
4490 if (ss != NULL)
4491 free (ss);
4492 if (sv != NULL)
4493 free (sv);
4494 return false;
4495}
4496
4497/* A comparison routine used to sort .gptab entries. */
4498
4499static int
4500gptab_compare (p1, p2)
4501 const PTR p1;
4502 const PTR p2;
4503{
4504 const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
4505 const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
4506
4507 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
4508}
4509
4510/* We need to use a special link routine to handle the .reginfo and
4511 the .mdebug sections. We need to merge all instances of these
4512 sections together, not write them all out sequentially. */
4513
103186c6
MM		 4514boolean
4515_bfd_mips_elf_final_link (abfd, info)
252b5132
RH		 4516 bfd *abfd;
4517 struct bfd_link_info *info;
4518{
4519 asection **secpp;
4520 asection *o;
4521 struct bfd_link_order *p;
4522 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4523 asection *rtproc_sec;
4524 Elf32_RegInfo reginfo;
4525 struct ecoff_debug_info debug;
4526 const struct ecoff_debug_swap *swap
4527 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4528 HDRR *symhdr = &debug.symbolic_header;
4529 PTR mdebug_handle = NULL;
f7cb7d68
UC		 4530 asection *s;
4531 EXTR esym;
4532 bfd_vma last;
4533 unsigned int i;
be3ccd9c
KH		 4534 static const char * const name[] = {
4535 ".text", ".init", ".fini", ".data",
4536 ".rodata", ".sdata", ".sbss", ".bss"
4537 };
4538 static const int sc[] = {
4539 scText, scInit, scFini, scData,
4540 scRData, scSData, scSBss, scBss
4541 };
252b5132 4542
303f629d
MM		 4543 /* If all the things we linked together were PIC, but we're
4544 producing an executable (rather than a shared object), then the
4545 resulting file is CPIC (i.e., it calls PIC code.) */
0dda5f7a
ILT		 4546 if (!info->shared
4547 && !info->relocateable
4548 && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
252b5132 4549 {
303f629d
MM		 4550 elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
4551 elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
252b5132
RH		 4552 }
4553
b3be9b46
RH		 4554 /* We'd carefully arranged the dynamic symbol indices, and then the
4555 generic size_dynamic_sections renumbered them out from under us.
4556 Rather than trying somehow to prevent the renumbering, just do
4557 the sort again. */
441d6d79 4558 if (elf_hash_table (info)->dynamic_sections_created)
b3be9b46
RH		 4559 {
4560 bfd *dynobj;
4561 asection *got;
4562 struct mips_got_info *g;
4563
435394bf
MM		 4564 /* When we resort, we must tell mips_elf_sort_hash_table what
4565 the lowest index it may use is. That's the number of section
4566 symbols we're going to add. The generic ELF linker only
4567 adds these symbols when building a shared object. Note that
4568 we count the sections after (possibly) removing the .options
4569 section above. */
be3ccd9c 4570 if (!mips_elf_sort_hash_table (info, (info->shared
435394bf
MM		 4571 ? bfd_count_sections (abfd) + 1
4572 : 1)))
be3ccd9c 4573 return false;
b3be9b46
RH		 4574
4575 /* Make sure we didn't grow the global .got region. */
4576 dynobj = elf_hash_table (info)->dynobj;
4577 got = bfd_get_section_by_name (dynobj, ".got");
4578 g = (struct mips_got_info *) elf_section_data (got)->tdata;
4579
8b237a89
MM		 4580 if (g->global_gotsym != NULL)
4581 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
4582 - g->global_gotsym->dynindx)
4583 <= g->global_gotno);
b3be9b46
RH		 4584 }
4585
303f629d
MM		 4586 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4587 include it, even though we don't process it quite right. (Some
4588 entries are supposed to be merged.) Empirically, we seem to be
4589 better off including it then not. */
f7cb7d68 4590 if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
303f629d
MM		 4591 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
4592 {
4593 if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4594 {
4595 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
4596 if (p->type == bfd_indirect_link_order)
be3ccd9c 4597 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
303f629d
MM		 4598 (*secpp)->link_order_head = NULL;
4599 *secpp = (*secpp)->next;
4600 --abfd->section_count;
be3ccd9c 4601
303f629d
MM		 4602 break;
4603 }
4604 }
4605
252b5132
RH		 4606 /* Get a value for the GP register. */
4607 if (elf_gp (abfd) == 0)
4608 {
4609 struct bfd_link_hash_entry *h;
4610
4611 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4612 if (h != (struct bfd_link_hash_entry *) NULL
4613 && h->type == bfd_link_hash_defined)
4614 elf_gp (abfd) = (h->u.def.value
4615 + h->u.def.section->output_section->vma
4616 + h->u.def.section->output_offset);
0db63c18
MM		 4617 else if (info->relocateable)
4618 {
4619 bfd_vma lo;
4620
4621 /* Find the GP-relative section with the lowest offset. */
4622 lo = (bfd_vma) -1;
4623 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
be3ccd9c 4624 if (o->vma < lo
0db63c18
MM		 4625 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
4626 lo = o->vma;
4627
4628 /* And calculate GP relative to that. */
4629 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
4630 }
252b5132
RH		 4631 else
4632 {
4633 /* If the relocate_section function needs to do a reloc
4634 involving the GP value, it should make a reloc_dangerous
4635 callback to warn that GP is not defined. */
4636 }
4637 }
4638
4639 /* Go through the sections and collect the .reginfo and .mdebug
4640 information. */
4641 reginfo_sec = NULL;
4642 mdebug_sec = NULL;
4643 gptab_data_sec = NULL;
4644 gptab_bss_sec = NULL;
4645 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4646 {
4647 if (strcmp (o->name, ".reginfo") == 0)
4648 {
4649 memset (&reginfo, 0, sizeof reginfo);
4650
4651 /* We have found the .reginfo section in the output file.
4652 Look through all the link_orders comprising it and merge
4653 the information together. */
4654 for (p = o->link_order_head;
4655 p != (struct bfd_link_order *) NULL;
4656 p = p->next)
4657 {
4658 asection *input_section;
4659 bfd *input_bfd;
4660 Elf32_External_RegInfo ext;
4661 Elf32_RegInfo sub;
4662
4663 if (p->type != bfd_indirect_link_order)
4664 {
4665 if (p->type == bfd_fill_link_order)
4666 continue;
4667 abort ();
4668 }
4669
4670 input_section = p->u.indirect.section;
4671 input_bfd = input_section->owner;
4672
4673 /* The linker emulation code has probably clobbered the
4674 size to be zero bytes. */
4675 if (input_section->_raw_size == 0)
4676 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
4677
4678 if (! bfd_get_section_contents (input_bfd, input_section,
4679 (PTR) &ext,
4680 (file_ptr) 0,
4681 sizeof ext))
4682 return false;
4683
4684 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
4685
4686 reginfo.ri_gprmask |= sub.ri_gprmask;
4687 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4688 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4689 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4690 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4691
4692 /* ri_gp_value is set by the function
4693 mips_elf32_section_processing when the section is
4694 finally written out. */
4695
4696 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4697 elf_link_input_bfd ignores this section. */
be3ccd9c 4698 input_section->flags &= ~SEC_HAS_CONTENTS;
252b5132
RH		 4699 }
4700
4701 /* Size has been set in mips_elf_always_size_sections */
4702 BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
4703
4704 /* Skip this section later on (I don't think this currently
4705 matters, but someday it might). */
4706 o->link_order_head = (struct bfd_link_order *) NULL;
4707
4708 reginfo_sec = o;
4709 }
4710
4711 if (strcmp (o->name, ".mdebug") == 0)
4712 {
4713 struct extsym_info einfo;
4714
4715 /* We have found the .mdebug section in the output file.
4716 Look through all the link_orders comprising it and merge
4717 the information together. */
4718 symhdr->magic = swap->sym_magic;
4719 /* FIXME: What should the version stamp be? */
4720 symhdr->vstamp = 0;
4721 symhdr->ilineMax = 0;
4722 symhdr->cbLine = 0;
4723 symhdr->idnMax = 0;
4724 symhdr->ipdMax = 0;
4725 symhdr->isymMax = 0;
4726 symhdr->ioptMax = 0;
4727 symhdr->iauxMax = 0;
4728 symhdr->issMax = 0;
4729 symhdr->issExtMax = 0;
4730 symhdr->ifdMax = 0;
4731 symhdr->crfd = 0;
4732 symhdr->iextMax = 0;
4733
4734 /* We accumulate the debugging information itself in the
4735 debug_info structure. */
4736 debug.line = NULL;
4737 debug.external_dnr = NULL;
4738 debug.external_pdr = NULL;
4739 debug.external_sym = NULL;
4740 debug.external_opt = NULL;
4741 debug.external_aux = NULL;
4742 debug.ss = NULL;
4743 debug.ssext = debug.ssext_end = NULL;
4744 debug.external_fdr = NULL;
4745 debug.external_rfd = NULL;
4746 debug.external_ext = debug.external_ext_end = NULL;
4747
4748 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4749 if (mdebug_handle == (PTR) NULL)
4750 return false;
4751
be3ccd9c
KH		 4752 esym.jmptbl = 0;
4753 esym.cobol_main = 0;
4754 esym.weakext = 0;
4755 esym.reserved = 0;
4756 esym.ifd = ifdNil;
4757 esym.asym.iss = issNil;
4758 esym.asym.st = stLocal;
4759 esym.asym.reserved = 0;
4760 esym.asym.index = indexNil;
4761 last = 0;
4762 for (i = 0; i < 8; i++)
4763 {
4764 esym.asym.sc = sc[i];
4765 s = bfd_get_section_by_name (abfd, name[i]);
4766 if (s != NULL)
4767 {
4768 esym.asym.value = s->vma;
4769 last = s->vma + s->_raw_size;
4770 }
4771 else
4772 esym.asym.value = last;
4773 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
4774 name[i], &esym))
4775 return false;
4776 }
252b5132
RH		 4777
4778 for (p = o->link_order_head;
4779 p != (struct bfd_link_order *) NULL;
4780 p = p->next)
4781 {
4782 asection *input_section;
4783 bfd *input_bfd;
4784 const struct ecoff_debug_swap *input_swap;
4785 struct ecoff_debug_info input_debug;
4786 char *eraw_src;
4787 char *eraw_end;
4788
4789 if (p->type != bfd_indirect_link_order)
4790 {
4791 if (p->type == bfd_fill_link_order)
4792 continue;
4793 abort ();
4794 }
4795
4796 input_section = p->u.indirect.section;
4797 input_bfd = input_section->owner;
4798
4799 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4800 || (get_elf_backend_data (input_bfd)
4801 ->elf_backend_ecoff_debug_swap) == NULL)
4802 {
4803 /* I don't know what a non MIPS ELF bfd would be
4804 doing with a .mdebug section, but I don't really
4805 want to deal with it. */
4806 continue;
4807 }
4808
4809 input_swap = (get_elf_backend_data (input_bfd)
4810 ->elf_backend_ecoff_debug_swap);
4811
4812 BFD_ASSERT (p->size == input_section->_raw_size);
4813
4814 /* The ECOFF linking code expects that we have already
4815 read in the debugging information and set up an
4816 ecoff_debug_info structure, so we do that now. */
4817 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
4818 &input_debug))
4819 return false;
4820
4821 if (! (bfd_ecoff_debug_accumulate
4822 (mdebug_handle, abfd, &debug, swap, input_bfd,
4823 &input_debug, input_swap, info)))
4824 return false;
4825
4826 /* Loop through the external symbols. For each one with
4827 interesting information, try to find the symbol in
4828 the linker global hash table and save the information
4829 for the output external symbols. */
4830 eraw_src = input_debug.external_ext;
4831 eraw_end = (eraw_src
4832 + (input_debug.symbolic_header.iextMax
4833 * input_swap->external_ext_size));
4834 for (;
4835 eraw_src < eraw_end;
4836 eraw_src += input_swap->external_ext_size)
4837 {
4838 EXTR ext;
4839 const char *name;
4840 struct mips_elf_link_hash_entry *h;
4841
4842 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4843 if (ext.asym.sc == scNil
4844 || ext.asym.sc == scUndefined
4845 || ext.asym.sc == scSUndefined)
4846 continue;
4847
4848 name = input_debug.ssext + ext.asym.iss;
4849 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
4850 name, false, false, true);
4851 if (h == NULL || h->esym.ifd != -2)
4852 continue;
4853
4854 if (ext.ifd != -1)
4855 {
4856 BFD_ASSERT (ext.ifd
4857 < input_debug.symbolic_header.ifdMax);
4858 ext.ifd = input_debug.ifdmap[ext.ifd];
4859 }
4860
4861 h->esym = ext;
4862 }
4863
4864 /* Free up the information we just read. */
4865 free (input_debug.line);
4866 free (input_debug.external_dnr);
4867 free (input_debug.external_pdr);
4868 free (input_debug.external_sym);
4869 free (input_debug.external_opt);
4870 free (input_debug.external_aux);
4871 free (input_debug.ss);
4872 free (input_debug.ssext);
4873 free (input_debug.external_fdr);
4874 free (input_debug.external_rfd);
4875 free (input_debug.external_ext);
4876
4877 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4878 elf_link_input_bfd ignores this section. */
be3ccd9c 4879 input_section->flags &= ~SEC_HAS_CONTENTS;
252b5132
RH		 4880 }
4881
4882 if (SGI_COMPAT (abfd) && info->shared)
4883 {
4884 /* Create .rtproc section. */
4885 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4886 if (rtproc_sec == NULL)
4887 {
4888 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
4889 | SEC_LINKER_CREATED | SEC_READONLY);
4890
4891 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4892 if (rtproc_sec == NULL
4893 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4894 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
4895 return false;
4896 }
4897
4898 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
4899 info, rtproc_sec, &debug))
4900 return false;
4901 }
4902
4903 /* Build the external symbol information. */
4904 einfo.abfd = abfd;
4905 einfo.info = info;
4906 einfo.debug = &debug;
4907 einfo.swap = swap;
4908 einfo.failed = false;
4909 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
4910 mips_elf_output_extsym,
4911 (PTR) &einfo);
4912 if (einfo.failed)
4913 return false;
4914
4915 /* Set the size of the .mdebug section. */
4916 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4917
4918 /* Skip this section later on (I don't think this currently
4919 matters, but someday it might). */
4920 o->link_order_head = (struct bfd_link_order *) NULL;
4921
4922 mdebug_sec = o;
4923 }
4924
4925 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4926 {
4927 const char *subname;
4928 unsigned int c;
4929 Elf32_gptab *tab;
4930 Elf32_External_gptab *ext_tab;
4931 unsigned int i;
4932
4933 /* The .gptab.sdata and .gptab.sbss sections hold
4934 information describing how the small data area would
4935 change depending upon the -G switch. These sections
4936 not used in executables files. */
4937 if (! info->relocateable)
4938 {
4939 asection **secpp;
4940
4941 for (p = o->link_order_head;
4942 p != (struct bfd_link_order *) NULL;
4943 p = p->next)
4944 {
4945 asection *input_section;
4946
4947 if (p->type != bfd_indirect_link_order)
4948 {
4949 if (p->type == bfd_fill_link_order)
4950 continue;
4951 abort ();
4952 }
4953
4954 input_section = p->u.indirect.section;
4955
4956 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4957 elf_link_input_bfd ignores this section. */
be3ccd9c 4958 input_section->flags &= ~SEC_HAS_CONTENTS;
252b5132
RH		 4959 }
4960
4961 /* Skip this section later on (I don't think this
4962 currently matters, but someday it might). */
4963 o->link_order_head = (struct bfd_link_order *) NULL;
4964
4965 /* Really remove the section. */
4966 for (secpp = &abfd->sections;
4967 *secpp != o;
4968 secpp = &(*secpp)->next)
4969 ;
4970 *secpp = (*secpp)->next;
4971 --abfd->section_count;
4972
4973 continue;
4974 }
4975
4976 /* There is one gptab for initialized data, and one for
4977 uninitialized data. */
4978 if (strcmp (o->name, ".gptab.sdata") == 0)
4979 gptab_data_sec = o;
4980 else if (strcmp (o->name, ".gptab.sbss") == 0)
4981 gptab_bss_sec = o;
4982 else
4983 {
4984 (*_bfd_error_handler)
4985 (_("%s: illegal section name `%s'"),
4986 bfd_get_filename (abfd), o->name);
4987 bfd_set_error (bfd_error_nonrepresentable_section);
4988 return false;
4989 }
4990
4991 /* The linker script always combines .gptab.data and
4992 .gptab.sdata into .gptab.sdata, and likewise for
4993 .gptab.bss and .gptab.sbss. It is possible that there is
4994 no .sdata or .sbss section in the output file, in which
4995 case we must change the name of the output section. */
4996 subname = o->name + sizeof ".gptab" - 1;
4997 if (bfd_get_section_by_name (abfd, subname) == NULL)
4998 {
4999 if (o == gptab_data_sec)
5000 o->name = ".gptab.data";
5001 else
5002 o->name = ".gptab.bss";
5003 subname = o->name + sizeof ".gptab" - 1;
5004 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
5005 }
5006
5007 /* Set up the first entry. */
5008 c = 1;
5009 tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
5010 if (tab == NULL)
5011 return false;
5012 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
5013 tab[0].gt_header.gt_unused = 0;
5014
5015 /* Combine the input sections. */
5016 for (p = o->link_order_head;
5017 p != (struct bfd_link_order *) NULL;
5018 p = p->next)
5019 {
5020 asection *input_section;
5021 bfd *input_bfd;
5022 bfd_size_type size;
5023 unsigned long last;
5024 bfd_size_type gpentry;
5025
5026 if (p->type != bfd_indirect_link_order)
5027 {
5028 if (p->type == bfd_fill_link_order)
5029 continue;
5030 abort ();
5031 }
5032
5033 input_section = p->u.indirect.section;
5034 input_bfd = input_section->owner;
5035
5036 /* Combine the gptab entries for this input section one
5037 by one. We know that the input gptab entries are
5038 sorted by ascending -G value. */
5039 size = bfd_section_size (input_bfd, input_section);
5040 last = 0;
5041 for (gpentry = sizeof (Elf32_External_gptab);
5042 gpentry < size;
5043 gpentry += sizeof (Elf32_External_gptab))
5044 {
5045 Elf32_External_gptab ext_gptab;
5046 Elf32_gptab int_gptab;
5047 unsigned long val;
5048 unsigned long add;
5049 boolean exact;
5050 unsigned int look;
5051
5052 if (! (bfd_get_section_contents
5053 (input_bfd, input_section, (PTR) &ext_gptab,
5054 gpentry, sizeof (Elf32_External_gptab))))
5055 {
5056 free (tab);
5057 return false;
5058 }
5059
5060 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
5061 &int_gptab);
5062 val = int_gptab.gt_entry.gt_g_value;
5063 add = int_gptab.gt_entry.gt_bytes - last;
5064
5065 exact = false;
5066 for (look = 1; look < c; look++)
5067 {
5068 if (tab[look].gt_entry.gt_g_value >= val)
5069 tab[look].gt_entry.gt_bytes += add;
5070
5071 if (tab[look].gt_entry.gt_g_value == val)
5072 exact = true;
5073 }
5074
5075 if (! exact)
5076 {
5077 Elf32_gptab *new_tab;
5078 unsigned int max;
5079
5080 /* We need a new table entry. */
5081 new_tab = ((Elf32_gptab *)
5082 bfd_realloc ((PTR) tab,
5083 (c + 1) * sizeof (Elf32_gptab)));
5084 if (new_tab == NULL)
5085 {
5086 free (tab);
5087 return false;
5088 }
5089 tab = new_tab;
5090 tab[c].gt_entry.gt_g_value = val;
5091 tab[c].gt_entry.gt_bytes = add;
5092
5093 /* Merge in the size for the next smallest -G
5094 value, since that will be implied by this new
5095 value. */
5096 max = 0;
5097 for (look = 1; look < c; look++)
5098 {
5099 if (tab[look].gt_entry.gt_g_value < val
5100 && (max == 0
5101 || (tab[look].gt_entry.gt_g_value
5102 > tab[max].gt_entry.gt_g_value)))
5103 max = look;
5104 }
5105 if (max != 0)
5106 tab[c].gt_entry.gt_bytes +=
5107 tab[max].gt_entry.gt_bytes;
5108
5109 ++c;
5110 }
5111
5112 last = int_gptab.gt_entry.gt_bytes;
5113 }
5114
5115 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5116 elf_link_input_bfd ignores this section. */
be3ccd9c 5117 input_section->flags &= ~SEC_HAS_CONTENTS;
252b5132
RH		 5118 }
5119
5120 /* The table must be sorted by -G value. */
5121 if (c > 2)
5122 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
5123
5124 /* Swap out the table. */
5125 ext_tab = ((Elf32_External_gptab *)
5126 bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
5127 if (ext_tab == NULL)
5128 {
5129 free (tab);
5130 return false;
5131 }
5132
5133 for (i = 0; i < c; i++)
5134 bfd_mips_elf32_swap_gptab_out (abfd, tab + i, ext_tab + i);
5135 free (tab);
5136
5137 o->_raw_size = c * sizeof (Elf32_External_gptab);
5138 o->contents = (bfd_byte *) ext_tab;
5139
5140 /* Skip this section later on (I don't think this currently
5141 matters, but someday it might). */
5142 o->link_order_head = (struct bfd_link_order *) NULL;
5143 }
5144 }
5145
5146 /* Invoke the regular ELF backend linker to do all the work. */
9ebbd33e
MM		 5147 if (ABI_64_P (abfd))
5148 {
5149#ifdef BFD64
5150 if (!bfd_elf64_bfd_final_link (abfd, info))
5151 return false;
5152#else
5153 abort ();
103186c6 5154 return false;
9ebbd33e
MM		 5155#endif /* BFD64 */
5156 }
5157 else if (!bfd_elf32_bfd_final_link (abfd, info))
5158 return false;
252b5132
RH		 5159
5160 /* Now write out the computed sections. */
5161
5162 if (reginfo_sec != (asection *) NULL)
5163 {
5164 Elf32_External_RegInfo ext;
5165
5166 bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
5167 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
5168 (file_ptr) 0, sizeof ext))
5169 return false;
5170 }
5171
5172 if (mdebug_sec != (asection *) NULL)
5173 {
5174 BFD_ASSERT (abfd->output_has_begun);
5175 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5176 swap, info,
5177 mdebug_sec->filepos))
5178 return false;
5179
5180 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5181 }
5182
5183 if (gptab_data_sec != (asection *) NULL)
5184 {
5185 if (! bfd_set_section_contents (abfd, gptab_data_sec,
5186 gptab_data_sec->contents,
5187 (file_ptr) 0,
5188 gptab_data_sec->_raw_size))
5189 return false;
5190 }
5191
5192 if (gptab_bss_sec != (asection *) NULL)
5193 {
5194 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
5195 gptab_bss_sec->contents,
5196 (file_ptr) 0,
5197 gptab_bss_sec->_raw_size))
5198 return false;
5199 }
5200
5201 if (SGI_COMPAT (abfd))
5202 {
5203 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
5204 if (rtproc_sec != NULL)
5205 {
5206 if (! bfd_set_section_contents (abfd, rtproc_sec,
5207 rtproc_sec->contents,
5208 (file_ptr) 0,
5209 rtproc_sec->_raw_size))
5210 return false;
5211 }
5212 }
5213
5214 return true;
5215}
5216
adb76a3e
UC		 5217/* This function is called via qsort() to sort the dynamic relocation
5218 entries by increasing r_symndx value. */
5219
5220static int
be3ccd9c
KH		 5221sort_dynamic_relocs (arg1, arg2)
5222 const PTR arg1;
5223 const PTR arg2;
adb76a3e
UC		 5224{
5225 const Elf32_External_Rel *ext_reloc1 = (const Elf32_External_Rel *) arg1;
5226 const Elf32_External_Rel *ext_reloc2 = (const Elf32_External_Rel *) arg2;
5227
5228 Elf_Internal_Rel int_reloc1;
5229 Elf_Internal_Rel int_reloc2;
5230
be3ccd9c
KH		 5231 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc1, &int_reloc1);
5232 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc2, &int_reloc2);
adb76a3e 5233
be3ccd9c 5234 return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info));
adb76a3e
UC		 5235}
5236
7403cb63 5237/* Returns the GOT section for ABFD. */
252b5132 5238
7403cb63
MM		 5239static asection *
5240mips_elf_got_section (abfd)
5241 bfd *abfd;
252b5132 5242{
7403cb63
MM		 5243 return bfd_get_section_by_name (abfd, ".got");
5244}
5245
5246/* Returns the GOT information associated with the link indicated by
be3ccd9c 5247 INFO. If SGOTP is non-NULL, it is filled in with the GOT
7403cb63
MM		 5248 section. */
5249
5250static struct mips_got_info *
5251mips_elf_got_info (abfd, sgotp)
5252 bfd *abfd;
5253 asection **sgotp;
5254{
5255 asection *sgot;
252b5132
RH		 5256 struct mips_got_info *g;
5257
7403cb63
MM		 5258 sgot = mips_elf_got_section (abfd);
5259 BFD_ASSERT (sgot != NULL);
5260 BFD_ASSERT (elf_section_data (sgot) != NULL);
5261 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
5262 BFD_ASSERT (g != NULL);
252b5132 5263
7403cb63
MM		 5264 if (sgotp)
5265 *sgotp = sgot;
5266 return g;
5267}
252b5132 5268
6387d602
ILT		 5269/* Return whether a relocation is against a local symbol. */
5270
5271static boolean
b305ef96
UC		 5272mips_elf_local_relocation_p (input_bfd, relocation, local_sections,
5273 check_forced)
6387d602
ILT		 5274 bfd *input_bfd;
5275 const Elf_Internal_Rela *relocation;
5276 asection **local_sections;
b305ef96 5277 boolean check_forced;
6387d602
ILT		 5278{
5279 unsigned long r_symndx;
5280 Elf_Internal_Shdr *symtab_hdr;
be3ccd9c 5281 struct mips_elf_link_hash_entry *h;
b305ef96 5282 size_t extsymoff;
6387d602
ILT		 5283
5284 r_symndx = ELF32_R_SYM (relocation->r_info);
5285 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
b305ef96
UC		 5286 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5287
5288 if (r_symndx < extsymoff)
5289 return true;
5290 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5291 return true;
5292
5293 if (check_forced)
6387d602 5294 {
be3ccd9c 5295 /* Look up the hash table to check whether the symbol
b305ef96 5296 was forced local. */
be3ccd9c
KH		 5297 h = (struct mips_elf_link_hash_entry *)
5298 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
5299 /* Find the real hash-table entry for this symbol. */
5300 while (h->root.root.type == bfd_link_hash_indirect
b305ef96 5301 || h->root.root.type == bfd_link_hash_warning)
be3ccd9c
KH		 5302 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5303 if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
5304 return true;
6387d602 5305 }
b305ef96
UC		 5306
5307 return false;
6387d602
ILT		 5308}
5309
7403cb63 5310/* Sign-extend VALUE, which has the indicated number of BITS. */
252b5132 5311
7403cb63
MM		 5312static bfd_vma
5313mips_elf_sign_extend (value, bits)
5314 bfd_vma value;
5315 int bits;
5316{
be3ccd9c 5317 if (value & ((bfd_vma) 1 << (bits - 1)))
7403cb63 5318 /* VALUE is negative. */
be3ccd9c
KH		 5319 value |= ((bfd_vma) - 1) << bits;
5320
7403cb63
MM		 5321 return value;
5322}
252b5132 5323
7403cb63
MM		 5324/* Return non-zero if the indicated VALUE has overflowed the maximum
5325 range expressable by a signed number with the indicated number of
5326 BITS. */
252b5132 5327
7403cb63
MM		 5328static boolean
5329mips_elf_overflow_p (value, bits)
5330 bfd_vma value;
5331 int bits;
5332{
5333 bfd_signed_vma svalue = (bfd_signed_vma) value;
252b5132 5334
7403cb63
MM		 5335 if (svalue > (1 << (bits - 1)) - 1)
5336 /* The value is too big. */
5337 return true;
5338 else if (svalue < -(1 << (bits - 1)))
5339 /* The value is too small. */
5340 return true;
be3ccd9c 5341
7403cb63
MM		 5342 /* All is well. */
5343 return false;
5344}
252b5132 5345
7403cb63 5346/* Calculate the %high function. */
252b5132 5347
7403cb63
MM		 5348static bfd_vma
5349mips_elf_high (value)
5350 bfd_vma value;
5351{
5352 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5353}
252b5132 5354
7403cb63
MM		 5355/* Calculate the %higher function. */
5356
5357static bfd_vma
5358mips_elf_higher (value)
5f771d47 5359 bfd_vma value ATTRIBUTE_UNUSED;
7403cb63
MM		 5360{
5361#ifdef BFD64
5362 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5363#else
5364 abort ();
5365 return (bfd_vma) -1;
5366#endif
5367}
5368
5369/* Calculate the %highest function. */
5370
be3ccd9c 5371static bfd_vma
7403cb63 5372mips_elf_highest (value)
5f771d47 5373 bfd_vma value ATTRIBUTE_UNUSED;
7403cb63
MM		 5374{
5375#ifdef BFD64
0af99795 5376 return ((value + (bfd_vma) 0x800080008000) >> 48) & 0xffff;
7403cb63
MM		 5377#else
5378 abort ();
5379 return (bfd_vma) -1;
5380#endif
5381}
5382
5383/* Returns the GOT index for the global symbol indicated by H. */
5384
be3ccd9c 5385static bfd_vma
7403cb63
MM		 5386mips_elf_global_got_index (abfd, h)
5387 bfd *abfd;
5388 struct elf_link_hash_entry *h;
5389{
5390 bfd_vma index;
5391 asection *sgot;
5392 struct mips_got_info *g;
5393
5394 g = mips_elf_got_info (abfd, &sgot);
5395
5396 /* Once we determine the global GOT entry with the lowest dynamic
5397 symbol table index, we must put all dynamic symbols with greater
5398 indices into the GOT. That makes it easy to calculate the GOT
5399 offset. */
5400 BFD_ASSERT (h->dynindx >= g->global_gotsym->dynindx);
be3ccd9c 5401 index = ((h->dynindx - g->global_gotsym->dynindx + g->local_gotno)
103186c6 5402 * MIPS_ELF_GOT_SIZE (abfd));
7403cb63
MM		 5403 BFD_ASSERT (index < sgot->_raw_size);
5404
5405 return index;
5406}
5407
5408/* Returns the offset for the entry at the INDEXth position
5409 in the GOT. */
5410
5411static bfd_vma
5412mips_elf_got_offset_from_index (dynobj, output_bfd, index)
5413 bfd *dynobj;
5414 bfd *output_bfd;
5415 bfd_vma index;
5416{
5417 asection *sgot;
5418 bfd_vma gp;
7403cb63 5419
103186c6 5420 sgot = mips_elf_got_section (dynobj);
7403cb63 5421 gp = _bfd_get_gp_value (output_bfd);
be3ccd9c 5422 return (sgot->output_section->vma + sgot->output_offset + index -
7403cb63
MM		 5423 gp);
5424}
5425
5426/* If H is a symbol that needs a global GOT entry, but has a dynamic
5427 symbol table index lower than any we've seen to date, record it for
5428 posterity. */
5429
5430static boolean
5431mips_elf_record_global_got_symbol (h, info, g)
5432 struct elf_link_hash_entry *h;
5433 struct bfd_link_info *info;
5f771d47 5434 struct mips_got_info *g ATTRIBUTE_UNUSED;
7403cb63
MM		 5435{
5436 /* A global symbol in the GOT must also be in the dynamic symbol
5437 table. */
5438 if (h->dynindx == -1
5439 && !bfd_elf32_link_record_dynamic_symbol (info, h))
5440 return false;
be3ccd9c 5441
7403cb63
MM		 5442 /* If we've already marked this entry as need GOT space, we don't
5443 need to do it again. */
5444 if (h->got.offset != (bfd_vma) - 1)
5445 return true;
5446
5447 /* By setting this to a value other than -1, we are indicating that
5448 there needs to be a GOT entry for H. */
5449 h->got.offset = 0;
5450
5451 return true;
5452}
5453
5454/* This structure is passed to mips_elf_sort_hash_table_f when sorting
5455 the dynamic symbols. */
be3ccd9c
KH		 5456
5457struct mips_elf_hash_sort_data {
7403cb63
MM		 5458 /* The symbol in the global GOT with the lowest dynamic symbol table
5459 index. */
5460 struct elf_link_hash_entry *low;
5461 /* The least dynamic symbol table index corresponding to a symbol
5462 with a GOT entry. */
5463 long min_got_dynindx;
5464 /* The greatest dynamic symbol table index not corresponding to a
5465 symbol without a GOT entry. */
5466 long max_non_got_dynindx;
5467};
5468
5469/* If H needs a GOT entry, assign it the highest available dynamic
be3ccd9c 5470 index. Otherwise, assign it the lowest available dynamic
7403cb63
MM		 5471 index. */
5472
5473static boolean
5474mips_elf_sort_hash_table_f (h, data)
5475 struct mips_elf_link_hash_entry *h;
5476 PTR data;
5477{
be3ccd9c 5478 struct mips_elf_hash_sort_data *hsd
7403cb63
MM		 5479 = (struct mips_elf_hash_sort_data *) data;
5480
5481 /* Symbols without dynamic symbol table entries aren't interesting
5482 at all. */
5483 if (h->root.dynindx == -1)
5484 return true;
5485
5486 if (h->root.got.offset != 0)
5487 h->root.dynindx = hsd->max_non_got_dynindx++;
5488 else
5489 {
5490 h->root.dynindx = --hsd->min_got_dynindx;
5491 hsd->low = (struct elf_link_hash_entry *) h;
5492 }
5493
5494 return true;
5495}
5496
5497/* Sort the dynamic symbol table so that symbols that need GOT entries
5498 appear towards the end. This reduces the amount of GOT space
b3be9b46
RH		 5499 required. MAX_LOCAL is used to set the number of local symbols
5500 known to be in the dynamic symbol table. During
5501 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5502 section symbols are added and the count is higher. */
7403cb63
MM		 5503
5504static boolean
b3be9b46 5505mips_elf_sort_hash_table (info, max_local)
7403cb63 5506 struct bfd_link_info *info;
b3be9b46 5507 unsigned long max_local;
7403cb63
MM		 5508{
5509 struct mips_elf_hash_sort_data hsd;
5510 struct mips_got_info *g;
5511 bfd *dynobj;
5512
5513 dynobj = elf_hash_table (info)->dynobj;
5514
5515 hsd.low = NULL;
5516 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount;
b3be9b46 5517 hsd.max_non_got_dynindx = max_local;
be3ccd9c
KH		 5518 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
5519 elf_hash_table (info)),
5520 mips_elf_sort_hash_table_f,
7403cb63
MM		 5521 &hsd);
5522
5523 /* There shoud have been enough room in the symbol table to
5524 accomodate both the GOT and non-GOT symbols. */
b305ef96 5525 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
7403cb63
MM		 5526
5527 /* Now we know which dynamic symbol has the lowest dynamic symbol
5528 table index in the GOT. */
5529 g = mips_elf_got_info (dynobj, NULL);
5530 g->global_gotsym = hsd.low;
5531
5532 return true;
5533}
5534
5535/* Create a local GOT entry for VALUE. Return the index of the entry,
5536 or -1 if it could not be created. */
5537
5538static bfd_vma
5539mips_elf_create_local_got_entry (abfd, g, sgot, value)
5540 bfd *abfd;
5541 struct mips_got_info *g;
5542 asection *sgot;
5543 bfd_vma value;
5544{
5545 if (g->assigned_gotno >= g->local_gotno)
5546 {
5547 /* We didn't allocate enough space in the GOT. */
5548 (*_bfd_error_handler)
5549 (_("not enough GOT space for local GOT entries"));
5550 bfd_set_error (bfd_error_bad_value);
5551 return (bfd_vma) -1;
5552 }
5553
103186c6 5554 MIPS_ELF_PUT_WORD (abfd, value,
be3ccd9c 5555 (sgot->contents
103186c6
MM		 5556 + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno));
5557 return MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
7403cb63
MM		 5558}
5559
5560/* Returns the GOT offset at which the indicated address can be found.
5561 If there is not yet a GOT entry for this value, create one. Returns
5562 -1 if no satisfactory GOT offset can be found. */
5563
5564static bfd_vma
5565mips_elf_local_got_index (abfd, info, value)
5566 bfd *abfd;
5567 struct bfd_link_info *info;
5568 bfd_vma value;
5569{
5570 asection *sgot;
5571 struct mips_got_info *g;
5572 bfd_byte *entry;
5573
5574 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5575
5576 /* Look to see if we already have an appropriate entry. */
be3ccd9c
KH		 5577 for (entry = (sgot->contents
5578 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
103186c6
MM		 5579 entry != sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5580 entry += MIPS_ELF_GOT_SIZE (abfd))
7403cb63 5581 {
103186c6 5582 bfd_vma address = MIPS_ELF_GET_WORD (abfd, entry);
7403cb63
MM		 5583 if (address == value)
5584 return entry - sgot->contents;
5585 }
5586
5587 return mips_elf_create_local_got_entry (abfd, g, sgot, value);
5588}
5589
5590/* Find a GOT entry that is within 32KB of the VALUE. These entries
5591 are supposed to be placed at small offsets in the GOT, i.e.,
5592 within 32KB of GP. Return the index into the GOT for this page,
5593 and store the offset from this entry to the desired address in
5594 OFFSETP, if it is non-NULL. */
5595
5596static bfd_vma
5597mips_elf_got_page (abfd, info, value, offsetp)
5598 bfd *abfd;
5599 struct bfd_link_info *info;
5600 bfd_vma value;
5601 bfd_vma *offsetp;
5602{
5603 asection *sgot;
5604 struct mips_got_info *g;
5605 bfd_byte *entry;
5606 bfd_byte *last_entry;
86033394 5607 bfd_vma index = 0;
7403cb63
MM		 5608 bfd_vma address;
5609
5610 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5611
5612 /* Look to see if we aleady have an appropriate entry. */
103186c6 5613 last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
be3ccd9c 5614 for (entry = (sgot->contents
103186c6 5615 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
7403cb63 5616 entry != last_entry;
103186c6 5617 entry += MIPS_ELF_GOT_SIZE (abfd))
7403cb63 5618 {
103186c6
MM		 5619 address = MIPS_ELF_GET_WORD (abfd, entry);
5620
7403cb63
MM		 5621 if (!mips_elf_overflow_p (value - address, 16))
5622 {
5623 /* This entry will serve as the page pointer. We can add a
5624 16-bit number to it to get the actual address. */
5625 index = entry - sgot->contents;
5626 break;
252b5132 5627 }
7403cb63
MM		 5628 }
5629
5630 /* If we didn't have an appropriate entry, we create one now. */
5631 if (entry == last_entry)
5632 index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5633
5634 if (offsetp)
5635 {
103186c6 5636 address = MIPS_ELF_GET_WORD (abfd, entry);
7403cb63
MM		 5637 *offsetp = value - address;
5638 }
5639
5640 return index;
5641}
5642
5643/* Find a GOT entry whose higher-order 16 bits are the same as those
5644 for value. Return the index into the GOT for this entry. */
5645
5646static bfd_vma
b305ef96 5647mips_elf_got16_entry (abfd, info, value, external)
7403cb63
MM		 5648 bfd *abfd;
5649 struct bfd_link_info *info;
5650 bfd_vma value;
b305ef96 5651 boolean external;
7403cb63
MM		 5652{
5653 asection *sgot;
5654 struct mips_got_info *g;
5655 bfd_byte *entry;
5656 bfd_byte *last_entry;
86033394 5657 bfd_vma index = 0;
7403cb63
MM		 5658 bfd_vma address;
5659
b305ef96
UC		 5660 if (! external)
5661 {
5662 /* Although the ABI says that it is "the high-order 16 bits" that we
5663 want, it is really the %high value. The complete value is
5664 calculated with a `addiu' of a LO16 relocation, just as with a
5665 HI16/LO16 pair. */
5666 value = mips_elf_high (value) << 16;
5667 }
5668
7403cb63
MM		 5669 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5670
5671 /* Look to see if we already have an appropriate entry. */
103186c6 5672 last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
be3ccd9c 5673 for (entry = (sgot->contents
103186c6 5674 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
7403cb63 5675 entry != last_entry;
103186c6 5676 entry += MIPS_ELF_GOT_SIZE (abfd))
7403cb63 5677 {
103186c6 5678 address = MIPS_ELF_GET_WORD (abfd, entry);
b305ef96 5679 if (address == value)
252b5132 5680 {
b305ef96
UC		 5681 /* This entry has the right high-order 16 bits, and the low-order
5682 16 bits are set to zero. */
4f2860ca 5683 index = entry - sgot->contents;
7403cb63
MM		 5684 break;
5685 }
5686 }
5687
5688 /* If we didn't have an appropriate entry, we create one now. */
5689 if (entry == last_entry)
5690 index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5691
5692 return index;
5693}
5694
bb2d6cd7 5695/* Returns the first relocation of type r_type found, beginning with
23b255aa 5696 RELOCATION. RELEND is one-past-the-end of the relocation table. */
7403cb63 5697
23b255aa 5698static const Elf_Internal_Rela *
bb2d6cd7
GK		 5699mips_elf_next_relocation (r_type, relocation, relend)
5700 unsigned int r_type;
103186c6
MM		 5701 const Elf_Internal_Rela *relocation;
5702 const Elf_Internal_Rela *relend;
7403cb63
MM		 5703{
5704 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5705 immediately following. However, for the IRIX6 ABI, the next
5706 relocation may be a composed relocation consisting of several
5707 relocations for the same address. In that case, the R_MIPS_LO16
435394bf 5708 relocation may occur as one of these. We permit a similar
7403cb63
MM		 5709 extension in general, as that is useful for GCC. */
5710 while (relocation < relend)
5711 {
bb2d6cd7 5712 if (ELF32_R_TYPE (relocation->r_info) == r_type)
23b255aa 5713 return relocation;
7403cb63
MM		 5714
5715 ++relocation;
5716 }
5717
5718 /* We didn't find it. */
6387d602 5719 bfd_set_error (bfd_error_bad_value);
23b255aa 5720 return NULL;
7403cb63
MM		 5721}
5722
7b1f1231
MM		 5723/* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5724 is the original relocation, which is now being transformed into a
b305ef96 5725 dynamic relocation. The ADDENDP is adjusted if necessary; the
7b1f1231 5726 caller should store the result in place of the original addend. */
7403cb63 5727
7b1f1231
MM		 5728static boolean
5729mips_elf_create_dynamic_relocation (output_bfd, info, rel, h, sec,
5af5b85b 5730 symbol, addendp, input_section, local_p)
7403cb63
MM		 5731 bfd *output_bfd;
5732 struct bfd_link_info *info;
103186c6 5733 const Elf_Internal_Rela *rel;
7b1f1231
MM		 5734 struct mips_elf_link_hash_entry *h;
5735 asection *sec;
5736 bfd_vma symbol;
5737 bfd_vma *addendp;
7403cb63 5738 asection *input_section;
5af5b85b 5739 boolean local_p;
7403cb63
MM		 5740{
5741 Elf_Internal_Rel outrel;
5742 boolean skip;
5743 asection *sreloc;
5744 bfd *dynobj;
5745 int r_type;
5746
5747 r_type = ELF32_R_TYPE (rel->r_info);
5748 dynobj = elf_hash_table (info)->dynobj;
be3ccd9c 5749 sreloc
103186c6
MM		 5750 = bfd_get_section_by_name (dynobj,
5751 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd));
7403cb63 5752 BFD_ASSERT (sreloc != NULL);
b305ef96 5753 BFD_ASSERT (sreloc->contents != NULL);
7403cb63
MM		 5754
5755 skip = false;
5756
7b1f1231
MM		 5757 /* We begin by assuming that the offset for the dynamic relocation
5758 is the same as for the original relocation. We'll adjust this
5759 later to reflect the correct output offsets. */
7403cb63
MM		 5760 if (elf_section_data (input_section)->stab_info == NULL)
5761 outrel.r_offset = rel->r_offset;
5762 else
5763 {
7b1f1231
MM		 5764 /* Except that in a stab section things are more complex.
5765 Because we compress stab information, the offset given in the
5766 relocation may not be the one we want; we must let the stabs
5767 machinery tell us the offset. */
be3ccd9c 5768 outrel.r_offset
7b1f1231
MM		 5769 = (_bfd_stab_section_offset
5770 (output_bfd, &elf_hash_table (info)->stab_info,
5771 input_section,
5772 &elf_section_data (input_section)->stab_info,
5773 rel->r_offset));
5774 /* If we didn't need the relocation at all, this value will be
5775 -1. */
5776 if (outrel.r_offset == (bfd_vma) -1)
7403cb63 5777 skip = true;
7403cb63 5778 }
7403cb63 5779
b305ef96 5780 /* If we've decided to skip this relocation, just output an empty
7b1f1231
MM		 5781 record. Note that R_MIPS_NONE == 0, so that this call to memset
5782 is a way of setting R_TYPE to R_MIPS_NONE. */
7403cb63
MM		 5783 if (skip)
5784 memset (&outrel, 0, sizeof (outrel));
7b1f1231
MM		 5785 else
5786 {
5787 long indx;
5788 bfd_vma section_offset;
5789
5790 /* We must now calculate the dynamic symbol table index to use
5791 in the relocation. */
5792 if (h != NULL
5793 && (! info->symbolic || (h->root.elf_link_hash_flags
5794 & ELF_LINK_HASH_DEF_REGULAR) == 0))
5795 {
5796 indx = h->root.dynindx;
b305ef96
UC		 5797 /* h->root.dynindx may be -1 if this symbol was marked to
5798 become local. */
5799 if (indx == -1)
be3ccd9c 5800 indx = 0;
7b1f1231
MM		 5801 }
5802 else
5803 {
5804 if (sec != NULL && bfd_is_abs_section (sec))
5805 indx = 0;
5806 else if (sec == NULL || sec->owner == NULL)
5807 {
5808 bfd_set_error (bfd_error_bad_value);
5809 return false;
5810 }
5811 else
5812 {
5813 indx = elf_section_data (sec->output_section)->dynindx;
5814 if (indx == 0)
5815 abort ();
5816 }
5817
5818 /* Figure out how far the target of the relocation is from
5819 the beginning of its section. */
5820 section_offset = symbol - sec->output_section->vma;
5821 /* The relocation we're building is section-relative.
5822 Therefore, the original addend must be adjusted by the
5823 section offset. */
5824 *addendp += symbol - sec->output_section->vma;
5825 /* Now, the relocation is just against the section. */
5826 symbol = sec->output_section->vma;
5827 }
be3ccd9c
KH		 5828
5829 /* If the relocation is against a local symbol was previously an
5830 absolute relocation, we must adjust it by the value we give
5831 it in the dynamic symbol table. */
5af5b85b 5832 if (local_p && r_type != R_MIPS_REL32)
7b1f1231
MM		 5833 *addendp += symbol;
5834
5835 /* The relocation is always an REL32 relocation because we don't
5836 know where the shared library will wind up at load-time. */
5837 outrel.r_info = ELF32_R_INFO (indx, R_MIPS_REL32);
5838
5839 /* Adjust the output offset of the relocation to reference the
5840 correct location in the output file. */
5841 outrel.r_offset += (input_section->output_section->vma
5842 + input_section->output_offset);
5843 }
7403cb63 5844
7b1f1231
MM		 5845 /* Put the relocation back out. We have to use the special
5846 relocation outputter in the 64-bit case since the 64-bit
5847 relocation format is non-standard. */
103186c6
MM		 5848 if (ABI_64_P (output_bfd))
5849 {
5850 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5851 (output_bfd, &outrel,
be3ccd9c 5852 (sreloc->contents
103186c6
MM		 5853 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5854 }
5855 else
5856 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
5857 (((Elf32_External_Rel *)
5858 sreloc->contents)
5859 + sreloc->reloc_count));
7b1f1231
MM		 5860
5861 /* Record the index of the first relocation referencing H. This
5862 information is later emitted in the .msym section. */
5863 if (h != NULL
be3ccd9c 5864 && (h->min_dyn_reloc_index == 0
7b1f1231
MM		 5865 || sreloc->reloc_count < h->min_dyn_reloc_index))
5866 h->min_dyn_reloc_index = sreloc->reloc_count;
5867
5868 /* We've now added another relocation. */
7403cb63
MM		 5869 ++sreloc->reloc_count;
5870
5871 /* Make sure the output section is writable. The dynamic linker
5872 will be writing to it. */
5873 elf_section_data (input_section->output_section)->this_hdr.sh_flags
5874 |= SHF_WRITE;
5875
5876 /* On IRIX5, make an entry of compact relocation info. */
5877 if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
5878 {
be3ccd9c 5879 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
7403cb63
MM		 5880 bfd_byte *cr;
5881
5882 if (scpt)
5883 {
5884 Elf32_crinfo cptrel;
5885
5886 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5887 cptrel.vaddr = (rel->r_offset
5888 + input_section->output_section->vma
5889 + input_section->output_offset);
5890 if (r_type == R_MIPS_REL32)
5891 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
252b5132 5892 else
7403cb63
MM		 5893 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5894 mips_elf_set_cr_dist2to (cptrel, 0);
7b1f1231 5895 cptrel.konst = *addendp;
7403cb63
MM		 5896
5897 cr = (scpt->contents
5898 + sizeof (Elf32_External_compact_rel));
5899 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5900 ((Elf32_External_crinfo *) cr
5901 + scpt->reloc_count));
5902 ++scpt->reloc_count;
5903 }
5904 }
252b5132 5905
7b1f1231 5906 return true;
7403cb63 5907}
252b5132 5908
7403cb63
MM		 5909/* Calculate the value produced by the RELOCATION (which comes from
5910 the INPUT_BFD). The ADDEND is the addend to use for this
5911 RELOCATION; RELOCATION->R_ADDEND is ignored.
5912
5913 The result of the relocation calculation is stored in VALUEP.
197b9ca0
MM		 5914 REQUIRE_JALXP indicates whether or not the opcode used with this
5915 relocation must be JALX.
7403cb63
MM		 5916
5917 This function returns bfd_reloc_continue if the caller need take no
5918 further action regarding this relocation, bfd_reloc_notsupported if
5919 something goes dramatically wrong, bfd_reloc_overflow if an
5920 overflow occurs, and bfd_reloc_ok to indicate success. */
5921
5922static bfd_reloc_status_type
be3ccd9c 5923mips_elf_calculate_relocation (abfd,
7403cb63
MM		 5924 input_bfd,
5925 input_section,
5926 info,
5927 relocation,
5928 addend,
5929 howto,
7403cb63
MM		 5930 local_syms,
5931 local_sections,
5932 valuep,
197b9ca0 5933 namep,
be3ccd9c 5934 require_jalxp)
7403cb63
MM		 5935 bfd *abfd;
5936 bfd *input_bfd;
5937 asection *input_section;
5938 struct bfd_link_info *info;
103186c6 5939 const Elf_Internal_Rela *relocation;
7403cb63
MM		 5940 bfd_vma addend;
5941 reloc_howto_type *howto;
7403cb63
MM		 5942 Elf_Internal_Sym *local_syms;
5943 asection **local_sections;
5944 bfd_vma *valuep;
5945 const char **namep;
197b9ca0 5946 boolean *require_jalxp;
7403cb63
MM		 5947{
5948 /* The eventual value we will return. */
5949 bfd_vma value;
5950 /* The address of the symbol against which the relocation is
5951 occurring. */
5952 bfd_vma symbol = 0;
5953 /* The final GP value to be used for the relocatable, executable, or
5954 shared object file being produced. */
5955 bfd_vma gp = (bfd_vma) - 1;
5956 /* The place (section offset or address) of the storage unit being
5957 relocated. */
5958 bfd_vma p;
5959 /* The value of GP used to create the relocatable object. */
5960 bfd_vma gp0 = (bfd_vma) - 1;
5961 /* The offset into the global offset table at which the address of
5962 the relocation entry symbol, adjusted by the addend, resides
5963 during execution. */
5964 bfd_vma g = (bfd_vma) - 1;
5965 /* The section in which the symbol referenced by the relocation is
5966 located. */
5967 asection *sec = NULL;
be3ccd9c 5968 struct mips_elf_link_hash_entry *h = NULL;
103186c6
MM		 5969 /* True if the symbol referred to by this relocation is a local
5970 symbol. */
7403cb63 5971 boolean local_p;
103186c6 5972 /* True if the symbol referred to by this relocation is "_gp_disp". */
7403cb63
MM		 5973 boolean gp_disp_p = false;
5974 Elf_Internal_Shdr *symtab_hdr;
5975 size_t extsymoff;
103186c6 5976 unsigned long r_symndx;
7403cb63 5977 int r_type;
103186c6
MM		 5978 /* True if overflow occurred during the calculation of the
5979 relocation value. */
7403cb63 5980 boolean overflowed_p;
197b9ca0
MM		 5981 /* True if this relocation refers to a MIPS16 function. */
5982 boolean target_is_16_bit_code_p = false;
7403cb63
MM		 5983
5984 /* Parse the relocation. */
5985 r_symndx = ELF32_R_SYM (relocation->r_info);
5986 r_type = ELF32_R_TYPE (relocation->r_info);
be3ccd9c 5987 p = (input_section->output_section->vma
7403cb63
MM		 5988 + input_section->output_offset
5989 + relocation->r_offset);
5990
5991 /* Assume that there will be no overflow. */
5992 overflowed_p = false;
5993
6387d602
ILT		 5994 /* Figure out whether or not the symbol is local, and get the offset
5995 used in the array of hash table entries. */
7403cb63 5996 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6387d602 5997 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
b305ef96 5998 local_sections, false);
6387d602
ILT		 5999 if (! elf_bad_symtab (input_bfd))
6000 extsymoff = symtab_hdr->sh_info;
6001 else
7403cb63
MM		 6002 {
6003 /* The symbol table does not follow the rule that local symbols
6004 must come before globals. */
6005 extsymoff = 0;
7403cb63 6006 }
be3ccd9c 6007
7403cb63
MM		 6008 /* Figure out the value of the symbol. */
6009 if (local_p)
6010 {
6011 Elf_Internal_Sym *sym;
6012
6013 sym = local_syms + r_symndx;
6014 sec = local_sections[r_symndx];
6015
6016 symbol = sec->output_section->vma + sec->output_offset;
6017 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
6018 symbol += sym->st_value;
6019
6020 /* MIPS16 text labels should be treated as odd. */
6021 if (sym->st_other == STO_MIPS16)
6022 ++symbol;
6023
6024 /* Record the name of this symbol, for our caller. */
6025 *namep = bfd_elf_string_from_elf_section (input_bfd,
6026 symtab_hdr->sh_link,
6027 sym->st_name);
e049a0de 6028 if (*namep == '\0')
7403cb63 6029 *namep = bfd_section_name (input_bfd, sec);
197b9ca0
MM		 6030
6031 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
7403cb63
MM		 6032 }
6033 else
6034 {
6035 /* For global symbols we look up the symbol in the hash-table. */
be3ccd9c 6036 h = ((struct mips_elf_link_hash_entry *)
7403cb63
MM		 6037 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
6038 /* Find the real hash-table entry for this symbol. */
b305ef96
UC		 6039 while (h->root.root.type == bfd_link_hash_indirect
6040 || h->root.root.type == bfd_link_hash_warning)
7403cb63 6041 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
be3ccd9c 6042
7403cb63
MM		 6043 /* Record the name of this symbol, for our caller. */
6044 *namep = h->root.root.root.string;
6045
6046 /* See if this is the special _gp_disp symbol. Note that such a
6047 symbol must always be a global symbol. */
6048 if (strcmp (h->root.root.root.string, "_gp_disp") == 0)
6049 {
6050 /* Relocations against _gp_disp are permitted only with
6051 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
6052 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
6053 return bfd_reloc_notsupported;
6054
6055 gp_disp_p = true;
6056 }
97a4bb05
MM		 6057 /* If this symbol is defined, calculate its address. Note that
6058 _gp_disp is a magic symbol, always implicitly defined by the
6059 linker, so it's inappropriate to check to see whether or not
6060 its defined. */
6061 else if ((h->root.root.type == bfd_link_hash_defined
6062 || h->root.root.type == bfd_link_hash_defweak)
6063 && h->root.root.u.def.section)
7403cb63
MM		 6064 {
6065 sec = h->root.root.u.def.section;
6066 if (sec->output_section)
be3ccd9c 6067 symbol = (h->root.root.u.def.value
7403cb63
MM		 6068 + sec->output_section->vma
6069 + sec->output_offset);
252b5132 6070 else
7403cb63
MM		 6071 symbol = h->root.root.u.def.value;
6072 }
97287574
MM		 6073 else if (h->root.root.type == bfd_link_hash_undefweak)
6074 /* We allow relocations against undefined weak symbols, giving
6075 it the value zero, so that you can undefined weak functions
6076 and check to see if they exist by looking at their
6077 addresses. */
6078 symbol = 0;
3a27a730 6079 else if (info->shared && !info->symbolic && !info->no_undefined
ba09750c 6080 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
8535d39c 6081 symbol = 0;
f7cb7d68
UC		 6082 else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
6083 strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
3811169e
MM		 6084 {
6085 /* If this is a dynamic link, we should have created a
be3ccd9c 6086 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
f7cb7d68 6087 in in mips_elf_create_dynamic_sections.
3811169e
MM		 6088 Otherwise, we should define the symbol with a value of 0.
6089 FIXME: It should probably get into the symbol table
6090 somehow as well. */
6091 BFD_ASSERT (! info->shared);
6092 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
8535d39c 6093 symbol = 0;
3811169e 6094 }
7403cb63
MM		 6095 else
6096 {
5cc7c785
L		 6097 if (! ((*info->callbacks->undefined_symbol)
6098 (info, h->root.root.root.string, input_bfd,
6099 input_section, relocation->r_offset,
3a27a730 6100 (!info->shared || info->no_undefined
ba09750c 6101 || ELF_ST_VISIBILITY (h->root.other)))))
5cc7c785
L		 6102 return bfd_reloc_undefined;
6103 symbol = 0;
7403cb63 6104 }
197b9ca0
MM		 6105
6106 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
6107 }
be3ccd9c 6108
197b9ca0
MM		 6109 /* If this is a 32-bit call to a 16-bit function with a stub, we
6110 need to redirect the call to the stub, unless we're already *in*
6111 a stub. */
6112 if (r_type != R_MIPS16_26 && !info->relocateable
6113 && ((h != NULL && h->fn_stub != NULL)
6114 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
6115 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
6116 && !mips_elf_stub_section_p (input_bfd, input_section))
6117 {
6118 /* This is a 32-bit call to a 16-bit function. We should
6119 have already noticed that we were going to need the
6120 stub. */
6121 if (local_p)
6122 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
6123 else
6124 {
6125 BFD_ASSERT (h->need_fn_stub);
6126 sec = h->fn_stub;
6127 }
6128
6129 symbol = sec->output_section->vma + sec->output_offset;
7403cb63 6130 }
197b9ca0
MM		 6131 /* If this is a 16-bit call to a 32-bit function with a stub, we
6132 need to redirect the call to the stub. */
6133 else if (r_type == R_MIPS16_26 && !info->relocateable
be3ccd9c 6134 && h != NULL
197b9ca0
MM		 6135 && (h->call_stub != NULL || h->call_fp_stub != NULL)
6136 && !target_is_16_bit_code_p)
6137 {
6138 /* If both call_stub and call_fp_stub are defined, we can figure
6139 out which one to use by seeing which one appears in the input
6140 file. */
6141 if (h->call_stub != NULL && h->call_fp_stub != NULL)
6142 {
6143 asection *o;
6144
6145 sec = NULL;
6146 for (o = input_bfd->sections; o != NULL; o = o->next)
6147 {
6148 if (strncmp (bfd_get_section_name (input_bfd, o),
6149 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
6150 {
6151 sec = h->call_fp_stub;
6152 break;
6153 }
6154 }
6155 if (sec == NULL)
6156 sec = h->call_stub;
6157 }
6158 else if (h->call_stub != NULL)
6159 sec = h->call_stub;
6160 else
6161 sec = h->call_fp_stub;
6162
6163 BFD_ASSERT (sec->_raw_size > 0);
6164 symbol = sec->output_section->vma + sec->output_offset;
6165 }
6166
6167 /* Calls from 16-bit code to 32-bit code and vice versa require the
6168 special jalx instruction. */
6387d602
ILT		 6169 *require_jalxp = (!info->relocateable
6170 && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
252b5132 6171
b305ef96
UC		 6172 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
6173 local_sections, true);
6174
7403cb63
MM		 6175 /* If we haven't already determined the GOT offset, or the GP value,
6176 and we're going to need it, get it now. */
6177 switch (r_type)
6178 {
6179 case R_MIPS_CALL16:
2841ecd0 6180 case R_MIPS_GOT16:
7403cb63
MM		 6181 case R_MIPS_GOT_DISP:
6182 case R_MIPS_GOT_HI16:
6183 case R_MIPS_CALL_HI16:
6184 case R_MIPS_GOT_LO16:
6185 case R_MIPS_CALL_LO16:
6186 /* Find the index into the GOT where this value is located. */
4f2860ca 6187 if (!local_p)
7403cb63
MM		 6188 {
6189 BFD_ASSERT (addend == 0);
be3ccd9c 6190 g = mips_elf_global_got_index
7403cb63 6191 (elf_hash_table (info)->dynobj,
be3ccd9c 6192 (struct elf_link_hash_entry *) h);
9a8f3bb7
UC		 6193 if (! elf_hash_table(info)->dynamic_sections_created
6194 || (info->shared
6195 && (info->symbolic || h->root.dynindx == -1)
6196 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6197 {
6198 /* This is a static link or a -Bsymbolic link. The
6199 symbol is defined locally, or was forced to be local.
6200 We must initialize this entry in the GOT. */
6201 asection *sgot = mips_elf_got_section(elf_hash_table
6202 (info)->dynobj);
6203 MIPS_ELF_PUT_WORD (elf_hash_table (info)->dynobj,
6204 symbol + addend, sgot->contents + g);
6205 }
7403cb63 6206 }
4f2860ca
MM		 6207 else if (r_type == R_MIPS_GOT16)
6208 /* There's no need to create a local GOT entry here; the
6209 calculation for a local GOT16 entry does not involve G. */
6210 break;
7403cb63
MM		 6211 else
6212 {
6213 g = mips_elf_local_got_index (abfd, info, symbol + addend);
6214 if (g == (bfd_vma) -1)
6215 return false;
6216 }
252b5132 6217
7403cb63
MM		 6218 /* Convert GOT indices to actual offsets. */
6219 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6220 abfd, g);
6221 break;
be3ccd9c 6222
7403cb63
MM		 6223 case R_MIPS_HI16:
6224 case R_MIPS_LO16:
6225 case R_MIPS_GPREL16:
6226 case R_MIPS_GPREL32:
0af99795 6227 case R_MIPS_LITERAL:
7403cb63
MM		 6228 gp0 = _bfd_get_gp_value (input_bfd);
6229 gp = _bfd_get_gp_value (abfd);
6230 break;
252b5132 6231
7403cb63
MM		 6232 default:
6233 break;
6234 }
252b5132 6235
7403cb63
MM		 6236 /* Figure out what kind of relocation is being performed. */
6237 switch (r_type)
6238 {
6239 case R_MIPS_NONE:
6240 return bfd_reloc_continue;
252b5132 6241
7403cb63
MM		 6242 case R_MIPS_16:
6243 value = symbol + mips_elf_sign_extend (addend, 16);
6244 overflowed_p = mips_elf_overflow_p (value, 16);
6245 break;
252b5132 6246
7403cb63
MM		 6247 case R_MIPS_32:
6248 case R_MIPS_REL32:
a3c7651d 6249 case R_MIPS_64:
7b1f1231
MM		 6250 if ((info->shared
6251 || (elf_hash_table (info)->dynamic_sections_created
6252 && h != NULL
b305ef96
UC		 6253 && ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
6254 != 0)))
7b1f1231 6255 && (input_section->flags & SEC_ALLOC) != 0)
7403cb63 6256 {
7b1f1231
MM		 6257 /* If we're creating a shared library, or this relocation is
6258 against a symbol in a shared library, then we can't know
6259 where the symbol will end up. So, we create a relocation
6260 record in the output, and leave the job up to the dynamic
6261 linker. */
6262 value = addend;
be3ccd9c
KH		 6263 if (!mips_elf_create_dynamic_relocation (abfd,
6264 info,
7b1f1231
MM		 6265 relocation,
6266 h,
6267 sec,
6268 symbol,
6269 &value,
5af5b85b 6270 input_section, local_p))
7b1f1231 6271 return false;
7403cb63
MM		 6272 }
6273 else
6274 {
a3c7651d 6275 if (r_type != R_MIPS_REL32)
7403cb63
MM		 6276 value = symbol + addend;
6277 else
6278 value = addend;
6279 }
6280 value &= howto->dst_mask;
6281 break;
6282
bb2d6cd7
GK		 6283 case R_MIPS_PC32:
6284 case R_MIPS_PC64:
6285 case R_MIPS_GNU_REL_LO16:
6286 value = symbol + addend - p;
6287 value &= howto->dst_mask;
6288 break;
6289
6290 case R_MIPS_GNU_REL16_S2:
6291 value = symbol + mips_elf_sign_extend (addend << 2, 18) - p;
6292 overflowed_p = mips_elf_overflow_p (value, 18);
6293 value = (value >> 2) & howto->dst_mask;
6294 break;
6295
6296 case R_MIPS_GNU_REL_HI16:
6297 value = mips_elf_high (addend + symbol - p);
6298 value &= howto->dst_mask;
6299 break;
6300
e53bd91b
MM		 6301 case R_MIPS16_26:
6302 /* The calculation for R_MIPS_26 is just the same as for an
6303 R_MIPS_26. It's only the storage of the relocated field into
1e52e2ee 6304 the output file that's different. That's handled in
e53bd91b
MM		 6305 mips_elf_perform_relocation. So, we just fall through to the
6306 R_MIPS_26 case here. */
7403cb63
MM		 6307 case R_MIPS_26:
6308 if (local_p)
6309 value = (((addend << 2) | (p & 0xf0000000)) + symbol) >> 2;
6310 else
6311 value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
6312 value &= howto->dst_mask;
6313 break;
6314
6315 case R_MIPS_HI16:
6316 if (!gp_disp_p)
6317 {
6318 value = mips_elf_high (addend + symbol);
6319 value &= howto->dst_mask;
6320 }
6321 else
6322 {
6323 value = mips_elf_high (addend + gp - p);
6324 overflowed_p = mips_elf_overflow_p (value, 16);
6325 }
6326 break;
6327
6328 case R_MIPS_LO16:
6329 if (!gp_disp_p)
6330 value = (symbol + addend) & howto->dst_mask;
6331 else
6332 {
6333 value = addend + gp - p + 4;
97a4bb05
MM		 6334 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6335 for overflow. But, on, say, Irix 5, relocations against
6336 _gp_disp are normally generated from the .cpload
6337 pseudo-op. It generates code that normally looks like
6338 this:
6339
6340 lui $gp,%hi(_gp_disp)
6341 addiu $gp,$gp,%lo(_gp_disp)
6342 addu $gp,$gp,$t9
6343
6344 Here $t9 holds the address of the function being called,
6345 as required by the MIPS ELF ABI. The R_MIPS_LO16
e53bd91b 6346 relocation can easily overflow in this situation, but the
97a4bb05
MM		 6347 R_MIPS_HI16 relocation will handle the overflow.
6348 Therefore, we consider this a bug in the MIPS ABI, and do
6349 not check for overflow here. */
7403cb63
MM		 6350 }
6351 break;
6352
6353 case R_MIPS_LITERAL:
6354 /* Because we don't merge literal sections, we can handle this
6355 just like R_MIPS_GPREL16. In the long run, we should merge
6356 shared literals, and then we will need to additional work
6357 here. */
6358
6359 /* Fall through. */
6360
b7233c24
MM		 6361 case R_MIPS16_GPREL:
6362 /* The R_MIPS16_GPREL performs the same calculation as
6363 R_MIPS_GPREL16, but stores the relocated bits in a different
6364 order. We don't need to do anything special here; the
6365 differences are handled in mips_elf_perform_relocation. */
7403cb63
MM		 6366 case R_MIPS_GPREL16:
6367 if (local_p)
6368 value = mips_elf_sign_extend (addend, 16) + symbol + gp0 - gp;
6369 else
6370 value = mips_elf_sign_extend (addend, 16) + symbol - gp;
6371 overflowed_p = mips_elf_overflow_p (value, 16);
6372 break;
be3ccd9c 6373
7403cb63
MM		 6374 case R_MIPS_GOT16:
6375 if (local_p)
6376 {
b305ef96 6377 boolean forced;
be3ccd9c 6378
b305ef96
UC		 6379 /* The special case is when the symbol is forced to be local. We
6380 need the full address in the GOT since no R_MIPS_LO16 relocation
6381 follows. */
6382 forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
6383 local_sections, false);
6384 value = mips_elf_got16_entry (abfd, info, symbol + addend, forced);
7403cb63
MM		 6385 if (value == (bfd_vma) -1)
6386 return false;
be3ccd9c 6387 value
7403cb63
MM		 6388 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6389 abfd,
6390 value);
6391 overflowed_p = mips_elf_overflow_p (value, 16);
6392 break;
6393 }
6394
6395 /* Fall through. */
6396
6397 case R_MIPS_CALL16:
6398 case R_MIPS_GOT_DISP:
6399 value = g;
6400 overflowed_p = mips_elf_overflow_p (value, 16);
6401 break;
6402
6403 case R_MIPS_GPREL32:
6404 value = (addend + symbol + gp0 - gp) & howto->dst_mask;
6405 break;
6406
6407 case R_MIPS_PC16:
6408 value = mips_elf_sign_extend (addend, 16) + symbol - p;
2a6d49ea 6409 value = (bfd_vma) ((bfd_signed_vma) value / 4);
7403cb63
MM		 6410 overflowed_p = mips_elf_overflow_p (value, 16);
6411 break;
6412
6413 case R_MIPS_GOT_HI16:
6414 case R_MIPS_CALL_HI16:
6415 /* We're allowed to handle these two relocations identically.
6416 The dynamic linker is allowed to handle the CALL relocations
6417 differently by creating a lazy evaluation stub. */
6418 value = g;
6419 value = mips_elf_high (value);
6420 value &= howto->dst_mask;
6421 break;
6422
6423 case R_MIPS_GOT_LO16:
6424 case R_MIPS_CALL_LO16:
6425 value = g & howto->dst_mask;
6426 break;
6427
7403cb63
MM		 6428 case R_MIPS_GOT_PAGE:
6429 value = mips_elf_got_page (abfd, info, symbol + addend, NULL);
6430 if (value == (bfd_vma) -1)
6431 return false;
6432 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6433 abfd,
6434 value);
6435 overflowed_p = mips_elf_overflow_p (value, 16);
6436 break;
be3ccd9c 6437
7403cb63
MM		 6438 case R_MIPS_GOT_OFST:
6439 mips_elf_got_page (abfd, info, symbol + addend, &value);
6440 overflowed_p = mips_elf_overflow_p (value, 16);
6441 break;
6442
6443 case R_MIPS_SUB:
6444 value = symbol - addend;
6445 value &= howto->dst_mask;
6446 break;
6447
6448 case R_MIPS_HIGHER:
6449 value = mips_elf_higher (addend + symbol);
6450 value &= howto->dst_mask;
6451 break;
6452
6453 case R_MIPS_HIGHEST:
6454 value = mips_elf_highest (addend + symbol);
6455 value &= howto->dst_mask;
6456 break;
be3ccd9c 6457
7403cb63
MM		 6458 case R_MIPS_SCN_DISP:
6459 value = symbol + addend - sec->output_offset;
6460 value &= howto->dst_mask;
6461 break;
6462
6463 case R_MIPS_PJUMP:
6464 case R_MIPS_JALR:
6465 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6466 hint; we could improve performance by honoring that hint. */
6467 return bfd_reloc_continue;
6468
6469 case R_MIPS_GNU_VTINHERIT:
6470 case R_MIPS_GNU_VTENTRY:
6471 /* We don't do anything with these at present. */
6472 return bfd_reloc_continue;
6473
7403cb63
MM		 6474 default:
6475 /* An unrecognized relocation type. */
6476 return bfd_reloc_notsupported;
6477 }
6478
6479 /* Store the VALUE for our caller. */
6480 *valuep = value;
6481 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6482}
6483
6484/* Obtain the field relocated by RELOCATION. */
6485
6486static bfd_vma
6487mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
6488 reloc_howto_type *howto;
103186c6 6489 const Elf_Internal_Rela *relocation;
7403cb63
MM		 6490 bfd *input_bfd;
6491 bfd_byte *contents;
6492{
6493 bfd_vma x;
6494 bfd_byte *location = contents + relocation->r_offset;
6495
b7233c24
MM		 6496 /* Obtain the bytes. */
6497 x = bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
7403cb63 6498
6296902e
MM		 6499 if ((ELF32_R_TYPE (relocation->r_info) == R_MIPS16_26
6500 || ELF32_R_TYPE (relocation->r_info) == R_MIPS16_GPREL)
1e52e2ee
MM		 6501 && bfd_little_endian (input_bfd))
6502 /* The two 16-bit words will be reversed on a little-endian
6503 system. See mips_elf_perform_relocation for more details. */
6504 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6505
7403cb63
MM		 6506 return x;
6507}
6508
6509/* It has been determined that the result of the RELOCATION is the
6510 VALUE. Use HOWTO to place VALUE into the output file at the
6511 appropriate position. The SECTION is the section to which the
197b9ca0
MM		 6512 relocation applies. If REQUIRE_JALX is true, then the opcode used
6513 for the relocation must be either JAL or JALX, and it is
6514 unconditionally converted to JALX.
7403cb63
MM		 6515
6516 Returns false if anything goes wrong. */
252b5132 6517
197b9ca0 6518static boolean
e53bd91b 6519mips_elf_perform_relocation (info, howto, relocation, value,
be3ccd9c 6520 input_bfd, input_section,
197b9ca0 6521 contents, require_jalx)
e53bd91b 6522 struct bfd_link_info *info;
7403cb63 6523 reloc_howto_type *howto;
103186c6 6524 const Elf_Internal_Rela *relocation;
7403cb63
MM		 6525 bfd_vma value;
6526 bfd *input_bfd;
197b9ca0 6527 asection *input_section;
7403cb63 6528 bfd_byte *contents;
197b9ca0 6529 boolean require_jalx;
7403cb63
MM		 6530{
6531 bfd_vma x;
e53bd91b 6532 bfd_byte *location;
197b9ca0 6533 int r_type = ELF32_R_TYPE (relocation->r_info);
e53bd91b
MM		 6534
6535 /* Figure out where the relocation is occurring. */
6536 location = contents + relocation->r_offset;
252b5132 6537
7403cb63
MM		 6538 /* Obtain the current value. */
6539 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
252b5132 6540
7403cb63
MM		 6541 /* Clear the field we are setting. */
6542 x &= ~howto->dst_mask;
252b5132 6543
e53bd91b
MM		 6544 /* If this is the R_MIPS16_26 relocation, we must store the
6545 value in a funny way. */
197b9ca0 6546 if (r_type == R_MIPS16_26)
7403cb63 6547 {
e53bd91b
MM		 6548 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6549 Most mips16 instructions are 16 bits, but these instructions
6550 are 32 bits.
6551
6552 The format of these instructions is:
6553
6554 +--------------+--------------------------------+
6555 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6556 +--------------+--------------------------------+
6557 ! Immediate 15:0 !
6558 +-----------------------------------------------+
be3ccd9c 6559
e53bd91b
MM		 6560 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6561 Note that the immediate value in the first word is swapped.
6562
6563 When producing a relocateable object file, R_MIPS16_26 is
6564 handled mostly like R_MIPS_26. In particular, the addend is
6565 stored as a straight 26-bit value in a 32-bit instruction.
6566 (gas makes life simpler for itself by never adjusting a
6567 R_MIPS16_26 reloc to be against a section, so the addend is
6568 always zero). However, the 32 bit instruction is stored as 2
6569 16-bit values, rather than a single 32-bit value. In a
6570 big-endian file, the result is the same; in a little-endian
6571 file, the two 16-bit halves of the 32 bit value are swapped.
6572 This is so that a disassembler can recognize the jal
6573 instruction.
6574
6575 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6576 instruction stored as two 16-bit values. The addend A is the
6577 contents of the targ26 field. The calculation is the same as
6578 R_MIPS_26. When storing the calculated value, reorder the
6579 immediate value as shown above, and don't forget to store the
6580 value as two 16-bit values.
6581
6582 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6583 defined as
be3ccd9c 6584
e53bd91b
MM		 6585 big-endian:
6586 +--------+----------------------+
6587 | | |
6588 | | targ26-16 |
6589 |31 26|25 0|
6590 +--------+----------------------+
be3ccd9c 6591
e53bd91b
MM		 6592 little-endian:
6593 +----------+------+-------------+
6594 | | | |
6595 | sub1 | | sub2 |
6596 |0 9|10 15|16 31|
6597 +----------+--------------------+
6598 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6599 ((sub1 << 16) | sub2)).
be3ccd9c 6600
e53bd91b
MM		 6601 When producing a relocateable object file, the calculation is
6602 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6603 When producing a fully linked file, the calculation is
6604 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6605 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6606
6607 if (!info->relocateable)
6608 /* Shuffle the bits according to the formula above. */
be3ccd9c
KH		 6609 value = (((value & 0x1f0000) << 5)
6610 | ((value & 0x3e00000) >> 5)
e53bd91b 6611 | (value & 0xffff));
be3ccd9c 6612
e53bd91b 6613 }
197b9ca0 6614 else if (r_type == R_MIPS16_GPREL)
b7233c24
MM		 6615 {
6616 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6617 mode. A typical instruction will have a format like this:
6618
6619 +--------------+--------------------------------+
6620 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6621 +--------------+--------------------------------+
6622 ! Major ! rx ! ry ! Imm 4:0 !
6623 +--------------+--------------------------------+
be3ccd9c 6624
b7233c24
MM		 6625 EXTEND is the five bit value 11110. Major is the instruction
6626 opcode.
be3ccd9c 6627
b7233c24
MM		 6628 This is handled exactly like R_MIPS_GPREL16, except that the
6629 addend is retrieved and stored as shown in this diagram; that
be3ccd9c 6630 is, the Imm fields above replace the V-rel16 field.
b7233c24 6631
6296902e
MM		 6632 All we need to do here is shuffle the bits appropriately. As
6633 above, the two 16-bit halves must be swapped on a
6634 little-endian system. */
b7233c24
MM		 6635 value = (((value & 0x7e0) << 16)
6636 | ((value & 0xf800) << 5)
6637 | (value & 0x1f));
6638 }
252b5132 6639
e53bd91b
MM		 6640 /* Set the field. */
6641 x |= (value & howto->dst_mask);
252b5132 6642
197b9ca0
MM		 6643 /* If required, turn JAL into JALX. */
6644 if (require_jalx)
6645 {
6646 boolean ok;
6647 bfd_vma opcode = x >> 26;
6648 bfd_vma jalx_opcode;
6649
6650 /* Check to see if the opcode is already JAL or JALX. */
6651 if (r_type == R_MIPS16_26)
6652 {
6653 ok = ((opcode == 0x6) || (opcode == 0x7));
6654 jalx_opcode = 0x7;
6655 }
6656 else
6657 {
6658 ok = ((opcode == 0x3) || (opcode == 0x1d));
6659 jalx_opcode = 0x1d;
6660 }
6661
6662 /* If the opcode is not JAL or JALX, there's a problem. */
6663 if (!ok)
6664 {
6665 (*_bfd_error_handler)
6666 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6667 bfd_get_filename (input_bfd),
6668 input_section->name,
6669 (unsigned long) relocation->r_offset);
6670 bfd_set_error (bfd_error_bad_value);
6671 return false;
6672 }
6673
6674 /* Make this the JALX opcode. */
6675 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6676 }
6677
6296902e
MM		 6678 /* Swap the high- and low-order 16 bits on little-endian systems
6679 when doing a MIPS16 relocation. */
197b9ca0 6680 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
6296902e
MM		 6681 && bfd_little_endian (input_bfd))
6682 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
be3ccd9c 6683
e53bd91b
MM		 6684 /* Put the value into the output. */
6685 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
197b9ca0
MM		 6686 return true;
6687}
6688
6689/* Returns true if SECTION is a MIPS16 stub section. */
6690
6691static boolean
6692mips_elf_stub_section_p (abfd, section)
6387d602 6693 bfd *abfd ATTRIBUTE_UNUSED;
197b9ca0
MM		 6694 asection *section;
6695{
6696 const char *name = bfd_get_section_name (abfd, section);
6697
6698 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
6699 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
6700 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
7403cb63 6701}
252b5132 6702
7403cb63 6703/* Relocate a MIPS ELF section. */
252b5132 6704
103186c6
MM		 6705boolean
6706_bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6707 contents, relocs, local_syms, local_sections)
7403cb63
MM		 6708 bfd *output_bfd;
6709 struct bfd_link_info *info;
6710 bfd *input_bfd;
6711 asection *input_section;
6712 bfd_byte *contents;
6713 Elf_Internal_Rela *relocs;
6714 Elf_Internal_Sym *local_syms;
6715 asection **local_sections;
6716{
31367b81 6717 Elf_Internal_Rela *rel;
103186c6 6718 const Elf_Internal_Rela *relend;
86033394 6719 bfd_vma addend = 0;
7403cb63 6720 boolean use_saved_addend_p = false;
103186c6 6721 struct elf_backend_data *bed;
252b5132 6722
103186c6
MM		 6723 bed = get_elf_backend_data (output_bfd);
6724 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
7403cb63
MM		 6725 for (rel = relocs; rel < relend; ++rel)
6726 {
6727 const char *name;
6728 bfd_vma value;
7403cb63 6729 reloc_howto_type *howto;
197b9ca0 6730 boolean require_jalx;
31367b81
MM		 6731 /* True if the relocation is a RELA relocation, rather than a
6732 REL relocation. */
6733 boolean rela_relocation_p = true;
6734 int r_type = ELF32_R_TYPE (rel->r_info);
252b5132 6735
7403cb63 6736 /* Find the relocation howto for this relocation. */
31367b81 6737 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
0af99795
GK		 6738 {
6739 /* Some 32-bit code uses R_MIPS_64. In particular, people use
be3ccd9c 6740 64-bit code, but make sure all their addresses are in the
0af99795
GK		 6741 lowermost or uppermost 32-bit section of the 64-bit address
6742 space. Thus, when they use an R_MIPS_64 they mean what is
6743 usually meant by R_MIPS_32, with the exception that the
6744 stored value is sign-extended to 64 bits. */
6745 howto = elf_mips_howto_table + R_MIPS_32;
6746
6747 /* On big-endian systems, we need to lie about the position
6748 of the reloc. */
6749 if (bfd_big_endian (input_bfd))
be3ccd9c 6750 rel->r_offset += 4;
0af99795 6751 }
a3c7651d 6752 else
c9b3cbf3 6753 howto = mips_rtype_to_howto (r_type);
252b5132 6754
7403cb63
MM		 6755 if (!use_saved_addend_p)
6756 {
6757 Elf_Internal_Shdr *rel_hdr;
6758
6759 /* If these relocations were originally of the REL variety,
6760 we must pull the addend out of the field that will be
6761 relocated. Otherwise, we simply use the contents of the
6762 RELA relocation. To determine which flavor or relocation
6763 this is, we depend on the fact that the INPUT_SECTION's
6764 REL_HDR is read before its REL_HDR2. */
6765 rel_hdr = &elf_section_data (input_section)->rel_hdr;
5f771d47 6766 if ((size_t) (rel - relocs)
103186c6
MM		 6767 >= (rel_hdr->sh_size / rel_hdr->sh_entsize
6768 * bed->s->int_rels_per_ext_rel))
7403cb63 6769 rel_hdr = elf_section_data (input_section)->rel_hdr2;
103186c6 6770 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
7403cb63 6771 {
31367b81
MM		 6772 /* Note that this is a REL relocation. */
6773 rela_relocation_p = false;
7403cb63 6774
31367b81 6775 /* Get the addend, which is stored in the input file. */
be3ccd9c 6776 addend = mips_elf_obtain_contents (howto,
7403cb63
MM		 6777 rel,
6778 input_bfd,
6779 contents);
6780 addend &= howto->src_mask;
6781
6782 /* For some kinds of relocations, the ADDEND is a
6783 combination of the addend stored in two different
6784 relocations. */
6387d602 6785 if (r_type == R_MIPS_HI16
bb2d6cd7 6786 || r_type == R_MIPS_GNU_REL_HI16
6387d602
ILT		 6787 || (r_type == R_MIPS_GOT16
6788 && mips_elf_local_relocation_p (input_bfd, rel,
b305ef96 6789 local_sections, false)))
252b5132 6790 {
23b255aa
MM		 6791 bfd_vma l;
6792 const Elf_Internal_Rela *lo16_relocation;
6793 reloc_howto_type *lo16_howto;
bb2d6cd7 6794 int lo;
23b255aa 6795
e7c44218
MM		 6796 /* The combined value is the sum of the HI16 addend,
6797 left-shifted by sixteen bits, and the LO16
6798 addend, sign extended. (Usually, the code does
6799 a `lui' of the HI16 value, and then an `addiu' of
be3ccd9c 6800 the LO16 value.)
e7c44218 6801
bb2d6cd7
GK		 6802 Scan ahead to find a matching LO16 relocation. */
6803 if (r_type == R_MIPS_GNU_REL_HI16)
6804 lo = R_MIPS_GNU_REL_LO16;
6805 else
6806 lo = R_MIPS_LO16;
be3ccd9c
KH		 6807 lo16_relocation
6808 = mips_elf_next_relocation (lo, rel, relend);
23b255aa 6809 if (lo16_relocation == NULL)
7403cb63 6810 return false;
252b5132 6811
23b255aa 6812 /* Obtain the addend kept there. */
bb2d6cd7 6813 lo16_howto = mips_rtype_to_howto (lo);
23b255aa
MM		 6814 l = mips_elf_obtain_contents (lo16_howto,
6815 lo16_relocation,
6816 input_bfd, contents);
6817 l &= lo16_howto->src_mask;
e7c44218 6818 l = mips_elf_sign_extend (l, 16);
23b255aa 6819
7403cb63 6820 addend <<= 16;
252b5132 6821
7403cb63 6822 /* Compute the combined addend. */
e7c44218 6823 addend += l;
252b5132 6824 }
b7233c24
MM		 6825 else if (r_type == R_MIPS16_GPREL)
6826 {
6827 /* The addend is scrambled in the object file. See
6828 mips_elf_perform_relocation for details on the
6829 format. */
6830 addend = (((addend & 0x1f0000) >> 5)
6831 | ((addend & 0x7e00000) >> 16)
6832 | (addend & 0x1f));
6833 }
252b5132
RH		 6834 }
6835 else
7403cb63
MM		 6836 addend = rel->r_addend;
6837 }
252b5132 6838
31367b81
MM		 6839 if (info->relocateable)
6840 {
6841 Elf_Internal_Sym *sym;
6842 unsigned long r_symndx;
6843
7893e6a2
GK		 6844 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd)
6845 && bfd_big_endian (input_bfd))
6846 rel->r_offset -= 4;
6847
31367b81 6848 /* Since we're just relocating, all we need to do is copy
0db63c18
MM		 6849 the relocations back out to the object file, unless
6850 they're against a section symbol, in which case we need
6851 to adjust by the section offset, or unless they're GP
6852 relative in which case we need to adjust by the amount
6853 that we're adjusting GP in this relocateable object. */
31367b81 6854
b305ef96
UC		 6855 if (!mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6856 false))
f1a5f37e 6857 /* There's nothing to do for non-local relocations. */
31367b81
MM		 6858 continue;
6859
be3ccd9c 6860 if (r_type == R_MIPS16_GPREL
0db63c18 6861 || r_type == R_MIPS_GPREL16
0af99795
GK		 6862 || r_type == R_MIPS_GPREL32
6863 || r_type == R_MIPS_LITERAL)
0db63c18
MM		 6864 addend -= (_bfd_get_gp_value (output_bfd)
6865 - _bfd_get_gp_value (input_bfd));
bb2d6cd7
GK		 6866 else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6867 || r_type == R_MIPS_GNU_REL16_S2)
e7c44218
MM		 6868 /* The addend is stored without its two least
6869 significant bits (which are always zero.) In a
6870 non-relocateable link, calculate_relocation will do
6871 this shift; here, we must do it ourselves. */
6872 addend <<= 2;
31367b81 6873
4f2860ca
MM		 6874 r_symndx = ELF32_R_SYM (rel->r_info);
6875 sym = local_syms + r_symndx;
6876 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6877 /* Adjust the addend appropriately. */
6878 addend += local_sections[r_symndx]->output_offset;
be3ccd9c 6879
f1a5f37e
MM		 6880 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6881 then we only want to write out the high-order 16 bits.
6882 The subsequent R_MIPS_LO16 will handle the low-order bits. */
bb2d6cd7
GK		 6883 if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6884 || r_type == R_MIPS_GNU_REL_HI16)
23b255aa 6885 addend = mips_elf_high (addend);
5a44662b
MM		 6886 /* If the relocation is for an R_MIPS_26 relocation, then
6887 the two low-order bits are not stored in the object file;
6888 they are implicitly zero. */
bb2d6cd7
GK		 6889 else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6890 || r_type == R_MIPS_GNU_REL16_S2)
5a44662b 6891 addend >>= 2;
f1a5f37e 6892
31367b81
MM		 6893 if (rela_relocation_p)
6894 /* If this is a RELA relocation, just update the addend.
bb2d6cd7 6895 We have to cast away constness for REL. */
31367b81
MM		 6896 rel->r_addend = addend;
6897 else
6898 {
6899 /* Otherwise, we have to write the value back out. Note
6900 that we use the source mask, rather than the
6901 destination mask because the place to which we are
6902 writing will be source of the addend in the final
6903 link. */
6904 addend &= howto->src_mask;
7893e6a2
GK		 6905
6906 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6907 /* See the comment above about using R_MIPS_64 in the 32-bit
6908 ABI. Here, we need to update the addend. It would be
6909 possible to get away with just using the R_MIPS_32 reloc
6910 but for endianness. */
6911 {
6912 bfd_vma sign_bits;
6913 bfd_vma low_bits;
6914 bfd_vma high_bits;
be3ccd9c 6915
fc633e5b
AM		 6916 if (addend & ((bfd_vma) 1 << 31))
6917 sign_bits = ((bfd_vma) 1 << 32) - 1;
7893e6a2
GK		 6918 else
6919 sign_bits = 0;
be3ccd9c 6920
7893e6a2
GK		 6921 /* If we don't know that we have a 64-bit type,
6922 do two separate stores. */
6923 if (bfd_big_endian (input_bfd))
6924 {
6925 /* Store the sign-bits (which are most significant)
6926 first. */
6927 low_bits = sign_bits;
6928 high_bits = addend;
6929 }
6930 else
6931 {
6932 low_bits = addend;
6933 high_bits = sign_bits;
6934 }
be3ccd9c 6935 bfd_put_32 (input_bfd, low_bits,
7893e6a2 6936 contents + rel->r_offset);
be3ccd9c 6937 bfd_put_32 (input_bfd, high_bits,
7893e6a2
GK		 6938 contents + rel->r_offset + 4);
6939 continue;
6940 }
6941
31367b81 6942 if (!mips_elf_perform_relocation (info, howto, rel, addend,
be3ccd9c 6943 input_bfd, input_section,
31367b81
MM		 6944 contents, false))
6945 return false;
6946 }
6947
6948 /* Go on to the next relocation. */
6949 continue;
6950 }
6951
7403cb63
MM		 6952 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6953 relocations for the same offset. In that case we are
6954 supposed to treat the output of each relocation as the addend
6955 for the next. */
be3ccd9c 6956 if (rel + 1 < relend
103186c6 6957 && rel->r_offset == rel[1].r_offset
b89db8f2 6958 && ELF32_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
7403cb63
MM		 6959 use_saved_addend_p = true;
6960 else
6961 use_saved_addend_p = false;
6962
6963 /* Figure out what value we are supposed to relocate. */
be3ccd9c 6964 switch (mips_elf_calculate_relocation (output_bfd,
7403cb63
MM		 6965 input_bfd,
6966 input_section,
6967 info,
6968 rel,
6969 addend,
6970 howto,
7403cb63
MM		 6971 local_syms,
6972 local_sections,
6973 &value,
197b9ca0
MM		 6974 &name,
6975 &require_jalx))
7403cb63
MM		 6976 {
6977 case bfd_reloc_continue:
6978 /* There's nothing to do. */
6979 continue;
252b5132 6980
7403cb63 6981 case bfd_reloc_undefined:
6387d602 6982 /* mips_elf_calculate_relocation already called the
bb2d6cd7 6983 undefined_symbol callback. There's no real point in
97287574
MM		 6984 trying to perform the relocation at this point, so we
6985 just skip ahead to the next relocation. */
6986 continue;
252b5132 6987
7403cb63
MM		 6988 case bfd_reloc_notsupported:
6989 abort ();
6990 break;
252b5132 6991
7403cb63
MM		 6992 case bfd_reloc_overflow:
6993 if (use_saved_addend_p)
6994 /* Ignore overflow until we reach the last relocation for
6995 a given location. */
6996 ;
6387d602
ILT		 6997 else
6998 {
6999 BFD_ASSERT (name != NULL);
7000 if (! ((*info->callbacks->reloc_overflow)
7001 (info, name, howto->name, (bfd_vma) 0,
7002 input_bfd, input_section, rel->r_offset)))
7003 return false;
7004 }
7403cb63 7005 break;
252b5132 7006
7403cb63
MM		 7007 case bfd_reloc_ok:
7008 break;
7009
7010 default:
7011 abort ();
7012 break;
252b5132
RH		 7013 }
7014
7403cb63
MM		 7015 /* If we've got another relocation for the address, keep going
7016 until we reach the last one. */
7017 if (use_saved_addend_p)
252b5132 7018 {
7403cb63
MM		 7019 addend = value;
7020 continue;
252b5132 7021 }
7403cb63 7022
31367b81 7023 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
a3c7651d
MM		 7024 /* See the comment above about using R_MIPS_64 in the 32-bit
7025 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7026 that calculated the right value. Now, however, we
7027 sign-extend the 32-bit result to 64-bits, and store it as a
7028 64-bit value. We are especially generous here in that we
7029 go to extreme lengths to support this usage on systems with
7030 only a 32-bit VMA. */
7031 {
a3c7651d
MM		 7032 bfd_vma sign_bits;
7033 bfd_vma low_bits;
7034 bfd_vma high_bits;
7035
fc633e5b
AM		 7036 if (value & ((bfd_vma) 1 << 31))
7037 sign_bits = ((bfd_vma) 1 << 32) - 1;
a3c7651d
MM		 7038 else
7039 sign_bits = 0;
7040
7893e6a2
GK		 7041 /* If we don't know that we have a 64-bit type,
7042 do two separate stores. */
a3c7651d
MM		 7043 if (bfd_big_endian (input_bfd))
7044 {
0af99795
GK		 7045 /* Undo what we did above. */
7046 rel->r_offset -= 4;
a3c7651d
MM		 7047 /* Store the sign-bits (which are most significant)
7048 first. */
7049 low_bits = sign_bits;
7050 high_bits = value;
7051 }
7052 else
7053 {
7054 low_bits = value;
7055 high_bits = sign_bits;
7056 }
be3ccd9c 7057 bfd_put_32 (input_bfd, low_bits,
a3c7651d 7058 contents + rel->r_offset);
be3ccd9c 7059 bfd_put_32 (input_bfd, high_bits,
a3c7651d
MM		 7060 contents + rel->r_offset + 4);
7061 continue;
a3c7651d
MM		 7062 }
7063
7403cb63 7064 /* Actually perform the relocation. */
be3ccd9c 7065 if (!mips_elf_perform_relocation (info, howto, rel, value, input_bfd,
197b9ca0
MM		 7066 input_section, contents,
7067 require_jalx))
7068 return false;
252b5132
RH		 7069 }
7070
7071 return true;
7072}
7073
7074/* This hook function is called before the linker writes out a global
7075 symbol. We mark symbols as small common if appropriate. This is
7076 also where we undo the increment of the value for a mips16 symbol. */
7077
103186c6
MM		 7078boolean
7079_bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
5f771d47
ILT		 7080 bfd *abfd ATTRIBUTE_UNUSED;
7081 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7082 const char *name ATTRIBUTE_UNUSED;
252b5132
RH		 7083 Elf_Internal_Sym *sym;
7084 asection *input_sec;
7085{
7086 /* If we see a common symbol, which implies a relocatable link, then
7087 if a symbol was small common in an input file, mark it as small
7088 common in the output file. */
7089 if (sym->st_shndx == SHN_COMMON
7090 && strcmp (input_sec->name, ".scommon") == 0)
7091 sym->st_shndx = SHN_MIPS_SCOMMON;
7092
7093 if (sym->st_other == STO_MIPS16
7094 && (sym->st_value & 1) != 0)
7095 --sym->st_value;
7096
7097 return true;
7098}
7099\f
7100/* Functions for the dynamic linker. */
7101
7102/* The name of the dynamic interpreter. This is put in the .interp
7103 section. */
7104
103186c6
MM		 7105#define ELF_DYNAMIC_INTERPRETER(abfd) \
7106 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
7107 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
7108 : "/usr/lib/libc.so.1")
252b5132
RH		 7109
7110/* Create dynamic sections when linking against a dynamic object. */
7111
103186c6
MM		 7112boolean
7113_bfd_mips_elf_create_dynamic_sections (abfd, info)
252b5132
RH		 7114 bfd *abfd;
7115 struct bfd_link_info *info;
7116{
7117 struct elf_link_hash_entry *h;
7118 flagword flags;
7119 register asection *s;
7120 const char * const *namep;
7121
7122 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7123 | SEC_LINKER_CREATED | SEC_READONLY);
7124
7125 /* Mips ABI requests the .dynamic section to be read only. */
7126 s = bfd_get_section_by_name (abfd, ".dynamic");
7127 if (s != NULL)
7128 {
7129 if (! bfd_set_section_flags (abfd, s, flags))
7130 return false;
7131 }
7132
7133 /* We need to create .got section. */
7134 if (! mips_elf_create_got_section (abfd, info))
7135 return false;
7136
c6142e5d
MM		 7137 /* Create the .msym section on IRIX6. It is used by the dynamic
7138 linker to speed up dynamic relocations, and to avoid computing
7139 the ELF hash for symbols. */
7140 if (IRIX_COMPAT (abfd) == ict_irix6
7141 && !mips_elf_create_msym_section (abfd))
7142 return false;
be3ccd9c 7143
252b5132 7144 /* Create .stub section. */
be3ccd9c 7145 if (bfd_get_section_by_name (abfd,
7403cb63 7146 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
252b5132 7147 {
7403cb63 7148 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
252b5132 7149 if (s == NULL
7403cb63 7150 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
103186c6
MM		 7151 || ! bfd_set_section_alignment (abfd, s,
7152 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 7153 return false;
7154 }
7155
31a9bdd9 7156 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
252b5132
RH		 7157 && !info->shared
7158 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
7159 {
7160 s = bfd_make_section (abfd, ".rld_map");
7161 if (s == NULL
7162 || ! bfd_set_section_flags (abfd, s, flags & ~SEC_READONLY)
103186c6
MM		 7163 || ! bfd_set_section_alignment (abfd, s,
7164 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 7165 return false;
7166 }
7167
303f629d
MM		 7168 /* On IRIX5, we adjust add some additional symbols and change the
7169 alignments of several sections. There is no ABI documentation
7170 indicating that this is necessary on IRIX6, nor any evidence that
7171 the linker takes such action. */
7172 if (IRIX_COMPAT (abfd) == ict_irix5)
252b5132
RH		 7173 {
7174 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7175 {
7176 h = NULL;
7177 if (! (_bfd_generic_link_add_one_symbol
7178 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
7179 (bfd_vma) 0, (const char *) NULL, false,
7180 get_elf_backend_data (abfd)->collect,
7181 (struct bfd_link_hash_entry **) &h)))
7182 return false;
be3ccd9c 7183 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH		 7184 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7185 h->type = STT_SECTION;
7186
7187 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7188 return false;
7189 }
7190
7191 /* We need to create a .compact_rel section. */
f7cb7d68 7192 if (SGI_COMPAT (abfd))
be3ccd9c
KH		 7193 {
7194 if (!mips_elf_create_compact_rel_section (abfd, info))
f7cb7d68 7195 return false;
be3ccd9c 7196 }
252b5132
RH		 7197
7198 /* Change aligments of some sections. */
7199 s = bfd_get_section_by_name (abfd, ".hash");
7200 if (s != NULL)
7201 bfd_set_section_alignment (abfd, s, 4);
7202 s = bfd_get_section_by_name (abfd, ".dynsym");
7203 if (s != NULL)
7204 bfd_set_section_alignment (abfd, s, 4);
7205 s = bfd_get_section_by_name (abfd, ".dynstr");
7206 if (s != NULL)
7207 bfd_set_section_alignment (abfd, s, 4);
7208 s = bfd_get_section_by_name (abfd, ".reginfo");
7209 if (s != NULL)
7210 bfd_set_section_alignment (abfd, s, 4);
7211 s = bfd_get_section_by_name (abfd, ".dynamic");
7212 if (s != NULL)
7213 bfd_set_section_alignment (abfd, s, 4);
7214 }
7215
7216 if (!info->shared)
7217 {
7218 h = NULL;
f7cb7d68 7219 if (SGI_COMPAT (abfd))
be3ccd9c
KH		 7220 {
7221 if (!(_bfd_generic_link_add_one_symbol
7222 (info, abfd, "_DYNAMIC_LINK", BSF_GLOBAL, bfd_abs_section_ptr,
7223 (bfd_vma) 0, (const char *) NULL, false,
7224 get_elf_backend_data (abfd)->collect,
7225 (struct bfd_link_hash_entry **) &h)))
f7cb7d68 7226 return false;
be3ccd9c 7227 }
f7cb7d68 7228 else
be3ccd9c
KH		 7229 {
7230 /* For normal mips it is _DYNAMIC_LINKING. */
7231 if (!(_bfd_generic_link_add_one_symbol
7232 (info, abfd, "_DYNAMIC_LINKING", BSF_GLOBAL,
7233 bfd_abs_section_ptr, (bfd_vma) 0, (const char *) NULL, false,
7234 get_elf_backend_data (abfd)->collect,
7235 (struct bfd_link_hash_entry **) &h)))
7236 return false;
7237 }
7238 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH		 7239 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7240 h->type = STT_SECTION;
7241
7242 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7243 return false;
7244
7245 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7246 {
7247 /* __rld_map is a four byte word located in the .data section
7248 and is filled in by the rtld to contain a pointer to
7249 the _r_debug structure. Its symbol value will be set in
7250 mips_elf_finish_dynamic_symbol. */
7251 s = bfd_get_section_by_name (abfd, ".rld_map");
7252 BFD_ASSERT (s != NULL);
7253
7254 h = NULL;
be3ccd9c
KH		 7255 if (SGI_COMPAT (abfd))
7256 {
7257 if (!(_bfd_generic_link_add_one_symbol
7258 (info, abfd, "__rld_map", BSF_GLOBAL, s,
7259 (bfd_vma) 0, (const char *) NULL, false,
7260 get_elf_backend_data (abfd)->collect,
7261 (struct bfd_link_hash_entry **) &h)))
7262 return false;
7263 }
7264 else
7265 {
7266 /* For normal mips the symbol is __RLD_MAP. */
7267 if (!(_bfd_generic_link_add_one_symbol
7268 (info, abfd, "__RLD_MAP", BSF_GLOBAL, s,
7269 (bfd_vma) 0, (const char *) NULL, false,
7270 get_elf_backend_data (abfd)->collect,
7271 (struct bfd_link_hash_entry **) &h)))
7272 return false;
7273 }
7274 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH		 7275 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7276 h->type = STT_OBJECT;
7277
7278 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7279 return false;
7280 }
7281 }
7282
7283 return true;
7284}
7285
7286/* Create the .compact_rel section. */
7287
7288static boolean
7289mips_elf_create_compact_rel_section (abfd, info)
7290 bfd *abfd;
5f771d47 7291 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 7292{
7293 flagword flags;
7294 register asection *s;
7295
7296 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
7297 {
7298 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
7299 | SEC_READONLY);
7300
7301 s = bfd_make_section (abfd, ".compact_rel");
7302 if (s == NULL
7303 || ! bfd_set_section_flags (abfd, s, flags)
103186c6
MM		 7304 || ! bfd_set_section_alignment (abfd, s,
7305 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 7306 return false;
7307
7308 s->_raw_size = sizeof (Elf32_External_compact_rel);
7309 }
7310
7311 return true;
7312}
7313
be3ccd9c 7314/* Create the .got section to hold the global offset table. */
252b5132
RH		 7315
7316static boolean
7317mips_elf_create_got_section (abfd, info)
7318 bfd *abfd;
7319 struct bfd_link_info *info;
7320{
7321 flagword flags;
7322 register asection *s;
7323 struct elf_link_hash_entry *h;
7324 struct mips_got_info *g;
7325
7326 /* This function may be called more than once. */
103186c6 7327 if (mips_elf_got_section (abfd))
252b5132
RH		 7328 return true;
7329
7330 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7331 | SEC_LINKER_CREATED);
7332
7333 s = bfd_make_section (abfd, ".got");
7334 if (s == NULL
7335 || ! bfd_set_section_flags (abfd, s, flags)
7336 || ! bfd_set_section_alignment (abfd, s, 4))
7337 return false;
7338
7339 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
7340 linker script because we don't want to define the symbol if we
7341 are not creating a global offset table. */
7342 h = NULL;
7343 if (! (_bfd_generic_link_add_one_symbol
7344 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
7345 (bfd_vma) 0, (const char *) NULL, false,
7346 get_elf_backend_data (abfd)->collect,
7347 (struct bfd_link_hash_entry **) &h)))
7348 return false;
be3ccd9c 7349 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
252b5132
RH		 7350 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7351 h->type = STT_OBJECT;
7352
7353 if (info->shared
7354 && ! bfd_elf32_link_record_dynamic_symbol (info, h))
7355 return false;
7356
7357 /* The first several global offset table entries are reserved. */
103186c6 7358 s->_raw_size = MIPS_RESERVED_GOTNO * MIPS_ELF_GOT_SIZE (abfd);
252b5132
RH		 7359
7360 g = (struct mips_got_info *) bfd_alloc (abfd,
7361 sizeof (struct mips_got_info));
7362 if (g == NULL)
7363 return false;
7403cb63 7364 g->global_gotsym = NULL;
252b5132
RH		 7365 g->local_gotno = MIPS_RESERVED_GOTNO;
7366 g->assigned_gotno = MIPS_RESERVED_GOTNO;
7367 if (elf_section_data (s) == NULL)
7368 {
7369 s->used_by_bfd =
7370 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
7371 if (elf_section_data (s) == NULL)
7372 return false;
7373 }
7374 elf_section_data (s)->tdata = (PTR) g;
be3ccd9c 7375 elf_section_data (s)->this_hdr.sh_flags
7403cb63 7376 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
252b5132
RH		 7377
7378 return true;
7379}
7380
c6142e5d
MM		 7381/* Returns the .msym section for ABFD, creating it if it does not
7382 already exist. Returns NULL to indicate error. */
7383
7384static asection *
7385mips_elf_create_msym_section (abfd)
7386 bfd *abfd;
7387{
7388 asection *s;
7389
7390 s = bfd_get_section_by_name (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
be3ccd9c 7391 if (!s)
c6142e5d
MM		 7392 {
7393 s = bfd_make_section (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7394 if (!s
be3ccd9c 7395 || !bfd_set_section_flags (abfd, s,
c6142e5d
MM		 7396 SEC_ALLOC
7397 | SEC_LOAD
7398 | SEC_HAS_CONTENTS
be3ccd9c 7399 | SEC_LINKER_CREATED
c6142e5d 7400 | SEC_READONLY)
103186c6
MM		 7401 || !bfd_set_section_alignment (abfd, s,
7402 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
c6142e5d
MM		 7403 return NULL;
7404 }
7405
7406 return s;
7407}
7408
103186c6
MM		 7409/* Add room for N relocations to the .rel.dyn section in ABFD. */
7410
7411static void
7412mips_elf_allocate_dynamic_relocations (abfd, n)
7413 bfd *abfd;
7414 unsigned int n;
7415{
7416 asection *s;
7417
7418 s = bfd_get_section_by_name (abfd, MIPS_ELF_REL_DYN_SECTION_NAME (abfd));
7419 BFD_ASSERT (s != NULL);
be3ccd9c 7420
103186c6
MM		 7421 if (s->_raw_size == 0)
7422 {
be3ccd9c 7423 /* Make room for a null element. */
103186c6
MM		 7424 s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
7425 ++s->reloc_count;
7426 }
7427 s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
7428}
7429
252b5132
RH		 7430/* Look through the relocs for a section during the first phase, and
7431 allocate space in the global offset table. */
7432
103186c6
MM		 7433boolean
7434_bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
252b5132
RH		 7435 bfd *abfd;
7436 struct bfd_link_info *info;
7437 asection *sec;
7438 const Elf_Internal_Rela *relocs;
7439{
7440 const char *name;
7441 bfd *dynobj;
7442 Elf_Internal_Shdr *symtab_hdr;
7443 struct elf_link_hash_entry **sym_hashes;
7444 struct mips_got_info *g;
7445 size_t extsymoff;
7446 const Elf_Internal_Rela *rel;
7447 const Elf_Internal_Rela *rel_end;
7448 asection *sgot;
7449 asection *sreloc;
103186c6 7450 struct elf_backend_data *bed;
252b5132
RH		 7451
7452 if (info->relocateable)
7453 return true;
7454
7455 dynobj = elf_hash_table (info)->dynobj;
7456 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7457 sym_hashes = elf_sym_hashes (abfd);
7458 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7459
7460 /* Check for the mips16 stub sections. */
7461
7462 name = bfd_get_section_name (abfd, sec);
7463 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
7464 {
7465 unsigned long r_symndx;
7466
7467 /* Look at the relocation information to figure out which symbol
7468 this is for. */
7469
7470 r_symndx = ELF32_R_SYM (relocs->r_info);
7471
7472 if (r_symndx < extsymoff
7473 || sym_hashes[r_symndx - extsymoff] == NULL)
7474 {
7475 asection *o;
7476
7477 /* This stub is for a local symbol. This stub will only be
7478 needed if there is some relocation in this BFD, other
7479 than a 16 bit function call, which refers to this symbol. */
7480 for (o = abfd->sections; o != NULL; o = o->next)
7481 {
7482 Elf_Internal_Rela *sec_relocs;
7483 const Elf_Internal_Rela *r, *rend;
7484
7485 /* We can ignore stub sections when looking for relocs. */
7486 if ((o->flags & SEC_RELOC) == 0
7487 || o->reloc_count == 0
7488 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
7489 sizeof FN_STUB - 1) == 0
7490 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
7491 sizeof CALL_STUB - 1) == 0
7492 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
7493 sizeof CALL_FP_STUB - 1) == 0)
7494 continue;
7495
7496 sec_relocs = (_bfd_elf32_link_read_relocs
7497 (abfd, o, (PTR) NULL,
7498 (Elf_Internal_Rela *) NULL,
7499 info->keep_memory));
7500 if (sec_relocs == NULL)
7501 return false;
7502
7503 rend = sec_relocs + o->reloc_count;
7504 for (r = sec_relocs; r < rend; r++)
7505 if (ELF32_R_SYM (r->r_info) == r_symndx
7506 && ELF32_R_TYPE (r->r_info) != R_MIPS16_26)
7507 break;
7508
7509 if (! info->keep_memory)
7510 free (sec_relocs);
7511
7512 if (r < rend)
7513 break;
7514 }
7515
7516 if (o == NULL)
7517 {
7518 /* There is no non-call reloc for this stub, so we do
7519 not need it. Since this function is called before
7520 the linker maps input sections to output sections, we
7521 can easily discard it by setting the SEC_EXCLUDE
7522 flag. */
7523 sec->flags |= SEC_EXCLUDE;
7524 return true;
7525 }
7526
7527 /* Record this stub in an array of local symbol stubs for
be3ccd9c 7528 this BFD. */
252b5132
RH		 7529 if (elf_tdata (abfd)->local_stubs == NULL)
7530 {
7531 unsigned long symcount;
7532 asection **n;
7533
7534 if (elf_bad_symtab (abfd))
103186c6 7535 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
252b5132
RH		 7536 else
7537 symcount = symtab_hdr->sh_info;
7538 n = (asection **) bfd_zalloc (abfd,
7539 symcount * sizeof (asection *));
7540 if (n == NULL)
7541 return false;
7542 elf_tdata (abfd)->local_stubs = n;
7543 }
7544
7545 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7546
7547 /* We don't need to set mips16_stubs_seen in this case.
7548 That flag is used to see whether we need to look through
7549 the global symbol table for stubs. We don't need to set
7550 it here, because we just have a local stub. */
7551 }
7552 else
7553 {
7554 struct mips_elf_link_hash_entry *h;
7555
7556 h = ((struct mips_elf_link_hash_entry *)
7557 sym_hashes[r_symndx - extsymoff]);
7558
7559 /* H is the symbol this stub is for. */
7560
7561 h->fn_stub = sec;
7562 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7563 }
7564 }
7565 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
7566 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7567 {
7568 unsigned long r_symndx;
7569 struct mips_elf_link_hash_entry *h;
7570 asection **loc;
7571
7572 /* Look at the relocation information to figure out which symbol
7573 this is for. */
7574
7575 r_symndx = ELF32_R_SYM (relocs->r_info);
7576
7577 if (r_symndx < extsymoff
7578 || sym_hashes[r_symndx - extsymoff] == NULL)
7579 {
7580 /* This stub was actually built for a static symbol defined
7581 in the same file. We assume that all static symbols in
7582 mips16 code are themselves mips16, so we can simply
7583 discard this stub. Since this function is called before
7584 the linker maps input sections to output sections, we can
7585 easily discard it by setting the SEC_EXCLUDE flag. */
7586 sec->flags |= SEC_EXCLUDE;
7587 return true;
7588 }
7589
7590 h = ((struct mips_elf_link_hash_entry *)
7591 sym_hashes[r_symndx - extsymoff]);
7592
7593 /* H is the symbol this stub is for. */
7594
7595 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7596 loc = &h->call_fp_stub;
7597 else
7598 loc = &h->call_stub;
7599
7600 /* If we already have an appropriate stub for this function, we
7601 don't need another one, so we can discard this one. Since
7602 this function is called before the linker maps input sections
7603 to output sections, we can easily discard it by setting the
7604 SEC_EXCLUDE flag. We can also discard this section if we
7605 happen to already know that this is a mips16 function; it is
7606 not necessary to check this here, as it is checked later, but
7607 it is slightly faster to check now. */
7608 if (*loc != NULL || h->root.other == STO_MIPS16)
7609 {
7610 sec->flags |= SEC_EXCLUDE;
7611 return true;
7612 }
7613
7614 *loc = sec;
7615 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7616 }
7617
7618 if (dynobj == NULL)
7619 {
7620 sgot = NULL;
7621 g = NULL;
7622 }
7623 else
7624 {
103186c6 7625 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 7626 if (sgot == NULL)
7627 g = NULL;
7628 else
7629 {
7630 BFD_ASSERT (elf_section_data (sgot) != NULL);
7631 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
7632 BFD_ASSERT (g != NULL);
7633 }
7634 }
7635
7636 sreloc = NULL;
103186c6
MM		 7637 bed = get_elf_backend_data (abfd);
7638 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7639 for (rel = relocs; rel < rel_end; ++rel)
252b5132
RH		 7640 {
7641 unsigned long r_symndx;
7403cb63 7642 int r_type;
252b5132
RH		 7643 struct elf_link_hash_entry *h;
7644
7645 r_symndx = ELF32_R_SYM (rel->r_info);
7403cb63 7646 r_type = ELF32_R_TYPE (rel->r_info);
252b5132
RH		 7647
7648 if (r_symndx < extsymoff)
7649 h = NULL;
7a3120d9
NC		 7650 else if (r_symndx >= extsymoff + (symtab_hdr->sh_size / symtab_hdr->sh_entsize))
7651 {
7652 (*_bfd_error_handler)
7653 (_("Malformed reloc detected for section %s"), name);
7654 bfd_set_error (bfd_error_bad_value);
7655 return false;
7656 }
252b5132
RH		 7657 else
7658 {
7659 h = sym_hashes[r_symndx - extsymoff];
7660
7661 /* This may be an indirect symbol created because of a version. */
7662 if (h != NULL)
7663 {
7664 while (h->root.type == bfd_link_hash_indirect)
7665 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7666 }
7667 }
7668
7669 /* Some relocs require a global offset table. */
7670 if (dynobj == NULL || sgot == NULL)
7671 {
7403cb63 7672 switch (r_type)
252b5132
RH		 7673 {
7674 case R_MIPS_GOT16:
7675 case R_MIPS_CALL16:
7676 case R_MIPS_CALL_HI16:
7677 case R_MIPS_CALL_LO16:
7678 case R_MIPS_GOT_HI16:
7679 case R_MIPS_GOT_LO16:
435394bf
MM		 7680 case R_MIPS_GOT_PAGE:
7681 case R_MIPS_GOT_OFST:
7682 case R_MIPS_GOT_DISP:
252b5132
RH		 7683 if (dynobj == NULL)
7684 elf_hash_table (info)->dynobj = dynobj = abfd;
7685 if (! mips_elf_create_got_section (dynobj, info))
7686 return false;
7403cb63 7687 g = mips_elf_got_info (dynobj, &sgot);
252b5132
RH		 7688 break;
7689
7690 case R_MIPS_32:
7691 case R_MIPS_REL32:
a3c7651d 7692 case R_MIPS_64:
252b5132
RH		 7693 if (dynobj == NULL
7694 && (info->shared || h != NULL)
7695 && (sec->flags & SEC_ALLOC) != 0)
7696 elf_hash_table (info)->dynobj = dynobj = abfd;
7697 break;
7698
7699 default:
7700 break;
7701 }
7702 }
7703
7403cb63
MM		 7704 if (!h && (r_type == R_MIPS_CALL_LO16
7705 || r_type == R_MIPS_GOT_LO16
9458945f 7706 || r_type == R_MIPS_GOT_DISP))
252b5132 7707 {
7403cb63 7708 /* We may need a local GOT entry for this relocation. We
97287574
MM		 7709 don't count R_MIPS_GOT_PAGE because we can estimate the
7710 maximum number of pages needed by looking at the size of
9458945f
MM		 7711 the segment. Similar comments apply to R_MIPS_GOT16. We
7712 don't count R_MIPS_GOT_HI16, or R_MIPS_CALL_HI16 because
7713 these are always followed by an R_MIPS_GOT_LO16 or
7714 R_MIPS_CALL_LO16.
7403cb63
MM		 7715
7716 This estimation is very conservative since we can merge
7717 duplicate entries in the GOT. In order to be less
7718 conservative, we could actually build the GOT here,
7719 rather than in relocate_section. */
7720 g->local_gotno++;
a3c7651d 7721 sgot->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
7403cb63 7722 }
252b5132 7723
7403cb63
MM		 7724 switch (r_type)
7725 {
7726 case R_MIPS_CALL16:
252b5132
RH		 7727 if (h == NULL)
7728 {
7729 (*_bfd_error_handler)
7730 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7731 bfd_get_filename (abfd), (unsigned long) rel->r_offset);
7732 bfd_set_error (bfd_error_bad_value);
7733 return false;
7734 }
7403cb63 7735 /* Fall through. */
252b5132 7736
7403cb63
MM		 7737 case R_MIPS_CALL_HI16:
7738 case R_MIPS_CALL_LO16:
5a44662b
MM		 7739 if (h != NULL)
7740 {
7741 /* This symbol requires a global offset table entry. */
7742 if (!mips_elf_record_global_got_symbol (h, info, g))
7743 return false;
252b5132 7744
5a44662b
MM		 7745 /* We need a stub, not a plt entry for the undefined
7746 function. But we record it as if it needs plt. See
7747 elf_adjust_dynamic_symbol in elflink.h. */
7748 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
7749 h->type = STT_FUNC;
7750 }
252b5132
RH		 7751 break;
7752
7753 case R_MIPS_GOT16:
7754 case R_MIPS_GOT_HI16:
7755 case R_MIPS_GOT_LO16:
7403cb63 7756 case R_MIPS_GOT_DISP:
252b5132 7757 /* This symbol requires a global offset table entry. */
7403cb63
MM		 7758 if (h && !mips_elf_record_global_got_symbol (h, info, g))
7759 return false;
252b5132
RH		 7760 break;
7761
7762 case R_MIPS_32:
7763 case R_MIPS_REL32:
a3c7651d 7764 case R_MIPS_64:
252b5132
RH		 7765 if ((info->shared || h != NULL)
7766 && (sec->flags & SEC_ALLOC) != 0)
7767 {
7768 if (sreloc == NULL)
7769 {
103186c6 7770 const char *name = MIPS_ELF_REL_DYN_SECTION_NAME (dynobj);
252b5132
RH		 7771
7772 sreloc = bfd_get_section_by_name (dynobj, name);
7773 if (sreloc == NULL)
7774 {
7775 sreloc = bfd_make_section (dynobj, name);
7776 if (sreloc == NULL
7777 || ! bfd_set_section_flags (dynobj, sreloc,
7778 (SEC_ALLOC
7779 | SEC_LOAD
7780 | SEC_HAS_CONTENTS
7781 | SEC_IN_MEMORY
7782 | SEC_LINKER_CREATED
7783 | SEC_READONLY))
7784 || ! bfd_set_section_alignment (dynobj, sreloc,
7785 4))
7786 return false;
7787 }
7788 }
7789 if (info->shared)
103186c6
MM		 7790 /* When creating a shared object, we must copy these
7791 reloc types into the output file as R_MIPS_REL32
7792 relocs. We make room for this reloc in the
7793 .rel.dyn reloc section. */
7794 mips_elf_allocate_dynamic_relocations (dynobj, 1);
252b5132
RH		 7795 else
7796 {
7797 struct mips_elf_link_hash_entry *hmips;
7798
7799 /* We only need to copy this reloc if the symbol is
7800 defined in a dynamic object. */
7801 hmips = (struct mips_elf_link_hash_entry *) h;
a3c7651d 7802 ++hmips->possibly_dynamic_relocs;
252b5132 7803 }
be3ccd9c 7804
7403cb63
MM		 7805 /* Even though we don't directly need a GOT entry for
7806 this symbol, a symbol must have a dynamic symbol
5499724a 7807 table index greater that DT_MIPS_GOTSYM if there are
7403cb63 7808 dynamic relocations against it. */
7b1f1231
MM		 7809 if (h != NULL
7810 && !mips_elf_record_global_got_symbol (h, info, g))
7403cb63 7811 return false;
252b5132
RH		 7812 }
7813
313ba8d6 7814 if (SGI_COMPAT (abfd))
252b5132
RH		 7815 mips_elf_hash_table (info)->compact_rel_size +=
7816 sizeof (Elf32_External_crinfo);
252b5132
RH		 7817 break;
7818
7819 case R_MIPS_26:
7820 case R_MIPS_GPREL16:
7821 case R_MIPS_LITERAL:
7822 case R_MIPS_GPREL32:
313ba8d6 7823 if (SGI_COMPAT (abfd))
252b5132
RH		 7824 mips_elf_hash_table (info)->compact_rel_size +=
7825 sizeof (Elf32_External_crinfo);
7826 break;
7827
7828 /* This relocation describes the C++ object vtable hierarchy.
7829 Reconstruct it for later use during GC. */
7830 case R_MIPS_GNU_VTINHERIT:
7831 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7832 return false;
7833 break;
7834
7835 /* This relocation describes which C++ vtable entries are actually
7836 used. Record for later use during GC. */
7837 case R_MIPS_GNU_VTENTRY:
7838 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7839 return false;
7840 break;
7841
7842 default:
7843 break;
7844 }
7845
7846 /* If this reloc is not a 16 bit call, and it has a global
7847 symbol, then we will need the fn_stub if there is one.
be3ccd9c 7848 References from a stub section do not count. */
252b5132 7849 if (h != NULL
7403cb63 7850 && r_type != R_MIPS16_26
252b5132
RH		 7851 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
7852 sizeof FN_STUB - 1) != 0
7853 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
7854 sizeof CALL_STUB - 1) != 0
7855 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
7856 sizeof CALL_FP_STUB - 1) != 0)
7857 {
7858 struct mips_elf_link_hash_entry *mh;
7859
7860 mh = (struct mips_elf_link_hash_entry *) h;
7861 mh->need_fn_stub = true;
7862 }
7863 }
7864
7865 return true;
7866}
7867
7868/* Return the section that should be marked against GC for a given
7869 relocation. */
7870
103186c6
MM		 7871asection *
7872_bfd_mips_elf_gc_mark_hook (abfd, info, rel, h, sym)
252b5132 7873 bfd *abfd;
5f771d47 7874 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 7875 Elf_Internal_Rela *rel;
7876 struct elf_link_hash_entry *h;
7877 Elf_Internal_Sym *sym;
7878{
7879 /* ??? Do mips16 stub sections need to be handled special? */
7880
7881 if (h != NULL)
7882 {
7883 switch (ELF32_R_TYPE (rel->r_info))
7884 {
7885 case R_MIPS_GNU_VTINHERIT:
7886 case R_MIPS_GNU_VTENTRY:
7887 break;
7888
7889 default:
7890 switch (h->root.type)
7891 {
7892 case bfd_link_hash_defined:
7893 case bfd_link_hash_defweak:
7894 return h->root.u.def.section;
7895
7896 case bfd_link_hash_common:
7897 return h->root.u.c.p->section;
7898
7899 default:
7900 break;
7901 }
7902 }
7903 }
7904 else
7905 {
7906 if (!(elf_bad_symtab (abfd)
7907 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7908 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
7909 && sym->st_shndx != SHN_COMMON))
7910 {
7911 return bfd_section_from_elf_index (abfd, sym->st_shndx);
7912 }
7913 }
7914
7915 return NULL;
7916}
7917
7918/* Update the got entry reference counts for the section being removed. */
7919
103186c6
MM		 7920boolean
7921_bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 7922 bfd *abfd ATTRIBUTE_UNUSED;
7923 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7924 asection *sec ATTRIBUTE_UNUSED;
7925 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132
RH		 7926{
7927#if 0
7928 Elf_Internal_Shdr *symtab_hdr;
7929 struct elf_link_hash_entry **sym_hashes;
7930 bfd_signed_vma *local_got_refcounts;
7931 const Elf_Internal_Rela *rel, *relend;
7932 unsigned long r_symndx;
7933 struct elf_link_hash_entry *h;
7934
7935 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7936 sym_hashes = elf_sym_hashes (abfd);
7937 local_got_refcounts = elf_local_got_refcounts (abfd);
7938
7939 relend = relocs + sec->reloc_count;
7940 for (rel = relocs; rel < relend; rel++)
7941 switch (ELF32_R_TYPE (rel->r_info))
7942 {
7943 case R_MIPS_GOT16:
7944 case R_MIPS_CALL16:
7945 case R_MIPS_CALL_HI16:
7946 case R_MIPS_CALL_LO16:
7947 case R_MIPS_GOT_HI16:
7948 case R_MIPS_GOT_LO16:
7949 /* ??? It would seem that the existing MIPS code does no sort
7950 of reference counting or whatnot on its GOT and PLT entries,
7951 so it is not possible to garbage collect them at this time. */
be3ccd9c 7952 break;
252b5132
RH		 7953
7954 default:
7955 break;
7956 }
7957#endif
7958
7959 return true;
7960}
7961
8a20f077
UC		 7962/* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7963 hiding the old indirect symbol. Process additional relocation
7964 information. */
7965
7966void
7967_bfd_mips_elf_copy_indirect_symbol (dir, ind)
7968 struct elf_link_hash_entry *dir, *ind;
7969{
7970 struct mips_elf_link_hash_entry *dirmips, *indmips;
7971
7972 _bfd_elf_link_hash_copy_indirect (dir, ind);
7973
7974 dirmips = (struct mips_elf_link_hash_entry *) dir;
7975 indmips = (struct mips_elf_link_hash_entry *) ind;
7976 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7977 if (dirmips->min_dyn_reloc_index == 0
7978 || (indmips->min_dyn_reloc_index != 0
be3ccd9c 7979 && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
8a20f077
UC		 7980 dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
7981}
7982
252b5132
RH		 7983/* Adjust a symbol defined by a dynamic object and referenced by a
7984 regular object. The current definition is in some section of the
7985 dynamic object, but we're not including those sections. We have to
7986 change the definition to something the rest of the link can
7987 understand. */
7988
103186c6
MM		 7989boolean
7990_bfd_mips_elf_adjust_dynamic_symbol (info, h)
252b5132
RH		 7991 struct bfd_link_info *info;
7992 struct elf_link_hash_entry *h;
7993{
7994 bfd *dynobj;
7995 struct mips_elf_link_hash_entry *hmips;
7996 asection *s;
7997
7998 dynobj = elf_hash_table (info)->dynobj;
7999
8000 /* Make sure we know what is going on here. */
8001 BFD_ASSERT (dynobj != NULL
8002 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
8003 || h->weakdef != NULL
8004 || ((h->elf_link_hash_flags
8005 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
8006 && (h->elf_link_hash_flags
8007 & ELF_LINK_HASH_REF_REGULAR) != 0
8008 && (h->elf_link_hash_flags
8009 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
8010
8011 /* If this symbol is defined in a dynamic object, we need to copy
8012 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
8013 file. */
8014 hmips = (struct mips_elf_link_hash_entry *) h;
8015 if (! info->relocateable
a3c7651d 8016 && hmips->possibly_dynamic_relocs != 0
252b5132 8017 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
be3ccd9c 8018 mips_elf_allocate_dynamic_relocations (dynobj,
a3c7651d 8019 hmips->possibly_dynamic_relocs);
252b5132 8020
be3ccd9c 8021 /* For a function, create a stub, if needed. */
f7cb7d68 8022 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
252b5132
RH		 8023 {
8024 if (! elf_hash_table (info)->dynamic_sections_created)
8025 return true;
8026
8027 /* If this symbol is not defined in a regular file, then set
8028 the symbol to the stub location. This is required to make
8029 function pointers compare as equal between the normal
8030 executable and the shared library. */
8031 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
8032 {
8033 /* We need .stub section. */
be3ccd9c 8034 s = bfd_get_section_by_name (dynobj,
303f629d 8035 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 8036 BFD_ASSERT (s != NULL);
8037
8038 h->root.u.def.section = s;
8039 h->root.u.def.value = s->_raw_size;
8040
8041 /* XXX Write this stub address somewhere. */
8042 h->plt.offset = s->_raw_size;
8043
8044 /* Make room for this stub code. */
8045 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8046
8047 /* The last half word of the stub will be filled with the index
8048 of this symbol in .dynsym section. */
8049 return true;
8050 }
8051 }
f7cb7d68 8052 else if ((h->type == STT_FUNC)
be3ccd9c 8053 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
f7cb7d68
UC		 8054 {
8055 /* This will set the entry for this symbol in the GOT to 0, and
be3ccd9c 8056 the dynamic linker will take care of this. */
f7cb7d68
UC		 8057 h->root.u.def.value = 0;
8058 return true;
8059 }
252b5132
RH		 8060
8061 /* If this is a weak symbol, and there is a real definition, the
8062 processor independent code will have arranged for us to see the
8063 real definition first, and we can just use the same value. */
8064 if (h->weakdef != NULL)
8065 {
8066 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
8067 || h->weakdef->root.type == bfd_link_hash_defweak);
8068 h->root.u.def.section = h->weakdef->root.u.def.section;
8069 h->root.u.def.value = h->weakdef->root.u.def.value;
8070 return true;
8071 }
8072
8073 /* This is a reference to a symbol defined by a dynamic object which
8074 is not a function. */
8075
8076 return true;
8077}
8078
8079/* This function is called after all the input files have been read,
8080 and the input sections have been assigned to output sections. We
8081 check for any mips16 stub sections that we can discard. */
8082
8083static boolean mips_elf_check_mips16_stubs
8084 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
8085
103186c6
MM		 8086boolean
8087_bfd_mips_elf_always_size_sections (output_bfd, info)
252b5132
RH		 8088 bfd *output_bfd;
8089 struct bfd_link_info *info;
8090{
8091 asection *ri;
8092
8093 /* The .reginfo section has a fixed size. */
8094 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8095 if (ri != NULL)
8096 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8097
8098 if (info->relocateable
8099 || ! mips_elf_hash_table (info)->mips16_stubs_seen)
8100 return true;
8101
8102 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8103 mips_elf_check_mips16_stubs,
8104 (PTR) NULL);
8105
8106 return true;
8107}
8108
8109/* Check the mips16 stubs for a particular symbol, and see if we can
8110 discard them. */
8111
252b5132
RH		 8112static boolean
8113mips_elf_check_mips16_stubs (h, data)
8114 struct mips_elf_link_hash_entry *h;
5f771d47 8115 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 8116{
8117 if (h->fn_stub != NULL
8118 && ! h->need_fn_stub)
8119 {
8120 /* We don't need the fn_stub; the only references to this symbol
8121 are 16 bit calls. Clobber the size to 0 to prevent it from
8122 being included in the link. */
8123 h->fn_stub->_raw_size = 0;
8124 h->fn_stub->_cooked_size = 0;
be3ccd9c 8125 h->fn_stub->flags &= ~SEC_RELOC;
252b5132
RH		 8126 h->fn_stub->reloc_count = 0;
8127 h->fn_stub->flags |= SEC_EXCLUDE;
8128 }
8129
8130 if (h->call_stub != NULL
8131 && h->root.other == STO_MIPS16)
8132 {
8133 /* We don't need the call_stub; this is a 16 bit function, so
8134 calls from other 16 bit functions are OK. Clobber the size
8135 to 0 to prevent it from being included in the link. */
8136 h->call_stub->_raw_size = 0;
8137 h->call_stub->_cooked_size = 0;
be3ccd9c 8138 h->call_stub->flags &= ~SEC_RELOC;
252b5132
RH		 8139 h->call_stub->reloc_count = 0;
8140 h->call_stub->flags |= SEC_EXCLUDE;
8141 }
8142
8143 if (h->call_fp_stub != NULL
8144 && h->root.other == STO_MIPS16)
8145 {
8146 /* We don't need the call_stub; this is a 16 bit function, so
8147 calls from other 16 bit functions are OK. Clobber the size
8148 to 0 to prevent it from being included in the link. */
8149 h->call_fp_stub->_raw_size = 0;
8150 h->call_fp_stub->_cooked_size = 0;
be3ccd9c 8151 h->call_fp_stub->flags &= ~SEC_RELOC;
252b5132
RH		 8152 h->call_fp_stub->reloc_count = 0;
8153 h->call_fp_stub->flags |= SEC_EXCLUDE;
8154 }
8155
8156 return true;
8157}
8158
8159/* Set the sizes of the dynamic sections. */
8160
103186c6
MM		 8161boolean
8162_bfd_mips_elf_size_dynamic_sections (output_bfd, info)
252b5132
RH		 8163 bfd *output_bfd;
8164 struct bfd_link_info *info;
8165{
8166 bfd *dynobj;
8167 asection *s;
8168 boolean reltext;
7a12753d 8169 struct mips_got_info *g = NULL;
252b5132
RH		 8170
8171 dynobj = elf_hash_table (info)->dynobj;
8172 BFD_ASSERT (dynobj != NULL);
8173
8174 if (elf_hash_table (info)->dynamic_sections_created)
8175 {
8176 /* Set the contents of the .interp section to the interpreter. */
8177 if (! info->shared)
8178 {
8179 s = bfd_get_section_by_name (dynobj, ".interp");
8180 BFD_ASSERT (s != NULL);
be3ccd9c 8181 s->_raw_size
303f629d 8182 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
be3ccd9c 8183 s->contents
7403cb63 8184 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
252b5132
RH		 8185 }
8186 }
8187
252b5132
RH		 8188 /* The check_relocs and adjust_dynamic_symbol entry points have
8189 determined the sizes of the various dynamic sections. Allocate
8190 memory for them. */
8191 reltext = false;
8192 for (s = dynobj->sections; s != NULL; s = s->next)
8193 {
8194 const char *name;
8195 boolean strip;
8196
8197 /* It's OK to base decisions on the section name, because none
8198 of the dynobj section names depend upon the input files. */
8199 name = bfd_get_section_name (dynobj, s);
8200
8201 if ((s->flags & SEC_LINKER_CREATED) == 0)
8202 continue;
8203
8204 strip = false;
8205
8206 if (strncmp (name, ".rel", 4) == 0)
8207 {
8208 if (s->_raw_size == 0)
8209 {
8210 /* We only strip the section if the output section name
8211 has the same name. Otherwise, there might be several
8212 input sections for this output section. FIXME: This
8213 code is probably not needed these days anyhow, since
8214 the linker now does not create empty output sections. */
8215 if (s->output_section != NULL
8216 && strcmp (name,
8217 bfd_get_section_name (s->output_section->owner,
8218 s->output_section)) == 0)
8219 strip = true;
8220 }
8221 else
8222 {
8223 const char *outname;
8224 asection *target;
8225
8226 /* If this relocation section applies to a read only
8227 section, then we probably need a DT_TEXTREL entry.
8228 If the relocation section is .rel.dyn, we always
8229 assert a DT_TEXTREL entry rather than testing whether
8230 there exists a relocation to a read only section or
8231 not. */
8232 outname = bfd_get_section_name (output_bfd,
8233 s->output_section);
8234 target = bfd_get_section_by_name (output_bfd, outname + 4);
8235 if ((target != NULL
8236 && (target->flags & SEC_READONLY) != 0
8237 && (target->flags & SEC_ALLOC) != 0)
be3ccd9c 8238 || strcmp (outname,
103186c6 8239 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) == 0)
252b5132
RH		 8240 reltext = true;
8241
8242 /* We use the reloc_count field as a counter if we need
8243 to copy relocs into the output file. */
be3ccd9c 8244 if (strcmp (name,
103186c6 8245 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) != 0)
252b5132
RH		 8246 s->reloc_count = 0;
8247 }
8248 }
8249 else if (strncmp (name, ".got", 4) == 0)
8250 {
8251 int i;
be3ccd9c
KH		 8252 bfd_size_type loadable_size = 0;
8253 bfd_size_type local_gotno;
8254 struct _bfd *sub;
252b5132 8255
be3ccd9c 8256 BFD_ASSERT (elf_section_data (s) != NULL);
252b5132 8257 g = (struct mips_got_info *) elf_section_data (s)->tdata;
be3ccd9c
KH		 8258 BFD_ASSERT (g != NULL);
8259
8260 /* Calculate the total loadable size of the output. That
8261 will give us the maximum number of GOT_PAGE entries
8262 required. */
8263 for (sub = info->input_bfds; sub; sub = sub->link_next)
8264 {
8265 asection *subsection;
8266
8267 for (subsection = sub->sections;
8268 subsection;
8269 subsection = subsection->next)
8270 {
8271 if ((subsection->flags & SEC_ALLOC) == 0)
8272 continue;
8273 loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
8274 }
8275 }
8276 loadable_size += MIPS_FUNCTION_STUB_SIZE;
8277
8278 /* Assume there are two loadable segments consisting of
8279 contiguous sections. Is 5 enough? */
8280 local_gotno = (loadable_size >> 16) + 5;
9458945f
MM		 8281 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8282 /* It's possible we will need GOT_PAGE entries as well as
8283 GOT16 entries. Often, these will be able to share GOT
8284 entries, but not always. */
8285 local_gotno *= 2;
8286
be3ccd9c
KH		 8287 g->local_gotno += local_gotno;
8288 s->_raw_size += local_gotno * MIPS_ELF_GOT_SIZE (dynobj);
7403cb63 8289
be3ccd9c
KH		 8290 /* There has to be a global GOT entry for every symbol with
8291 a dynamic symbol table index of DT_MIPS_GOTSYM or
8292 higher. Therefore, it make sense to put those symbols
8293 that need GOT entries at the end of the symbol table. We
8294 do that here. */
b3be9b46 8295 if (!mips_elf_sort_hash_table (info, 1))
7403cb63
MM		 8296 return false;
8297
8b237a89
MM		 8298 if (g->global_gotsym != NULL)
8299 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
8300 else
8301 /* If there are no global symbols, or none requiring
8302 relocations, then GLOBAL_GOTSYM will be NULL. */
8303 i = 0;
b3be9b46 8304 g->global_gotno = i;
103186c6 8305 s->_raw_size += i * MIPS_ELF_GOT_SIZE (dynobj);
252b5132 8306 }
303f629d 8307 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
252b5132
RH		 8308 {
8309 /* Irix rld assumes that the function stub isn't at the end
8310 of .text section. So put a dummy. XXX */
8311 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8312 }
8313 else if (! info->shared
8314 && ! mips_elf_hash_table (info)->use_rld_obj_head
8315 && strncmp (name, ".rld_map", 8) == 0)
8316 {
8317 /* We add a room for __rld_map. It will be filled in by the
8318 rtld to contain a pointer to the _r_debug structure. */
8319 s->_raw_size += 4;
8320 }
8321 else if (SGI_COMPAT (output_bfd)
8322 && strncmp (name, ".compact_rel", 12) == 0)
8323 s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
c6142e5d
MM		 8324 else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (output_bfd))
8325 == 0)
be3ccd9c 8326 s->_raw_size = (sizeof (Elf32_External_Msym)
c6142e5d
MM		 8327 * (elf_hash_table (info)->dynsymcount
8328 + bfd_count_sections (output_bfd)));
252b5132
RH		 8329 else if (strncmp (name, ".init", 5) != 0)
8330 {
8331 /* It's not one of our sections, so don't allocate space. */
8332 continue;
8333 }
8334
8335 if (strip)
8336 {
7f8d5fc9 8337 _bfd_strip_section_from_output (info, s);
252b5132
RH		 8338 continue;
8339 }
8340
8341 /* Allocate memory for the section contents. */
303f629d 8342 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 8343 if (s->contents == NULL && s->_raw_size != 0)
8344 {
8345 bfd_set_error (bfd_error_no_memory);
8346 return false;
8347 }
252b5132
RH		 8348 }
8349
8350 if (elf_hash_table (info)->dynamic_sections_created)
8351 {
8352 /* Add some entries to the .dynamic section. We fill in the
8353 values later, in elf_mips_finish_dynamic_sections, but we
8354 must add the entries now so that we get the correct size for
8355 the .dynamic section. The DT_DEBUG entry is filled in by the
8356 dynamic linker and used by the debugger. */
8357 if (! info->shared)
8358 {
be3ccd9c
KH		 8359 /* SGI object has the equivalence of DT_DEBUG in the
8360 DT_MIPS_RLD_MAP entry. */
8361 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
8362 return false;
8363 if (!SGI_COMPAT (output_bfd))
8364 {
8365 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8366 return false;
8367 }
8368 }
f7cb7d68 8369 else
be3ccd9c
KH		 8370 {
8371 /* Shared libraries on traditional mips have DT_DEBUG. */
8372 if (!SGI_COMPAT (output_bfd))
8373 {
8374 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8375 return false;
8376 }
8377 }
8378 if (reltext && SGI_COMPAT (output_bfd))
252b5132 8379 {
103186c6 8380 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
252b5132 8381 return false;
d6cf2879 8382 info->flags |= DF_TEXTREL;
252b5132
RH		 8383 }
8384
103186c6 8385 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
252b5132
RH		 8386 return false;
8387
103186c6
MM		 8388 if (bfd_get_section_by_name (dynobj,
8389 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)))
252b5132 8390 {
103186c6 8391 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
252b5132
RH		 8392 return false;
8393
103186c6 8394 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
252b5132
RH		 8395 return false;
8396
103186c6 8397 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
252b5132
RH		 8398 return false;
8399 }
8400
f7cb7d68 8401 if (SGI_COMPAT (output_bfd))
be3ccd9c
KH		 8402 {
8403 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
f7cb7d68 8404 return false;
be3ccd9c 8405 }
252b5132 8406
f7cb7d68 8407 if (SGI_COMPAT (output_bfd))
be3ccd9c
KH		 8408 {
8409 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
f7cb7d68 8410 return false;
be3ccd9c 8411 }
252b5132
RH		 8412
8413 if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
8414 {
103186c6 8415 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
252b5132
RH		 8416 return false;
8417
8418 s = bfd_get_section_by_name (dynobj, ".liblist");
8419 BFD_ASSERT (s != NULL);
8420
103186c6 8421 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
252b5132
RH		 8422 return false;
8423 }
8424
103186c6 8425 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
252b5132
RH		 8426 return false;
8427
103186c6 8428 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
252b5132
RH		 8429 return false;
8430
8431#if 0
8432 /* Time stamps in executable files are a bad idea. */
103186c6 8433 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
252b5132
RH		 8434 return false;
8435#endif
8436
8437#if 0 /* FIXME */
103186c6 8438 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
252b5132
RH		 8439 return false;
8440#endif
8441
8442#if 0 /* FIXME */
103186c6 8443 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
252b5132
RH		 8444 return false;
8445#endif
8446
103186c6 8447 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
252b5132
RH		 8448 return false;
8449
103186c6 8450 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
252b5132
RH		 8451 return false;
8452
103186c6 8453 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
252b5132
RH		 8454 return false;
8455
103186c6 8456 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
252b5132
RH		 8457 return false;
8458
5499724a 8459 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
252b5132
RH		 8460 return false;
8461
7403cb63 8462 if (IRIX_COMPAT (dynobj) == ict_irix5
103186c6 8463 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
252b5132
RH		 8464 return false;
8465
7403cb63 8466 if (IRIX_COMPAT (dynobj) == ict_irix6
be3ccd9c 8467 && (bfd_get_section_by_name
7403cb63 8468 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
103186c6 8469 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
7403cb63 8470 return false;
c6142e5d 8471
be3ccd9c 8472 if (bfd_get_section_by_name (dynobj,
c6142e5d 8473 MIPS_ELF_MSYM_SECTION_NAME (dynobj))
103186c6 8474 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
c6142e5d 8475 return false;
252b5132
RH		 8476 }
8477
252b5132
RH		 8478 return true;
8479}
8480
7403cb63
MM		 8481/* If NAME is one of the special IRIX6 symbols defined by the linker,
8482 adjust it appropriately now. */
8483
8484static void
8485mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
5f771d47 8486 bfd *abfd ATTRIBUTE_UNUSED;
7403cb63
MM		 8487 const char *name;
8488 Elf_Internal_Sym *sym;
8489{
8490 /* The linker script takes care of providing names and values for
8491 these, but we must place them into the right sections. */
8492 static const char* const text_section_symbols[] = {
8493 "_ftext",
8494 "_etext",
8495 "__dso_displacement",
8496 "__elf_header",
8497 "__program_header_table",
8498 NULL
8499 };
8500
8501 static const char* const data_section_symbols[] = {
8502 "_fdata",
8503 "_edata",
8504 "_end",
8505 "_fbss",
8506 NULL
8507 };
8508
8509 const char* const *p;
8510 int i;
8511
8512 for (i = 0; i < 2; ++i)
be3ccd9c 8513 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
7403cb63
MM		 8514 *p;
8515 ++p)
8516 if (strcmp (*p, name) == 0)
8517 {
8518 /* All of these symbols are given type STT_SECTION by the
8519 IRIX6 linker. */
8520 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
be3ccd9c 8521
7403cb63
MM		 8522 /* The IRIX linker puts these symbols in special sections. */
8523 if (i == 0)
8524 sym->st_shndx = SHN_MIPS_TEXT;
8525 else
8526 sym->st_shndx = SHN_MIPS_DATA;
be3ccd9c 8527
7403cb63
MM		 8528 break;
8529 }
8530}
8531
252b5132
RH		 8532/* Finish up dynamic symbol handling. We set the contents of various
8533 dynamic sections here. */
8534
103186c6
MM		 8535boolean
8536_bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
252b5132
RH		 8537 bfd *output_bfd;
8538 struct bfd_link_info *info;
8539 struct elf_link_hash_entry *h;
8540 Elf_Internal_Sym *sym;
8541{
8542 bfd *dynobj;
8543 bfd_vma gval;
8544 asection *sgot;
c6142e5d 8545 asection *smsym;
252b5132
RH		 8546 struct mips_got_info *g;
8547 const char *name;
c6142e5d 8548 struct mips_elf_link_hash_entry *mh;
252b5132
RH		 8549
8550 dynobj = elf_hash_table (info)->dynobj;
8551 gval = sym->st_value;
c6142e5d 8552 mh = (struct mips_elf_link_hash_entry *) h;
252b5132
RH		 8553
8554 if (h->plt.offset != (bfd_vma) -1)
8555 {
8556 asection *s;
8557 bfd_byte *p;
8558 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
8559
8560 /* This symbol has a stub. Set it up. */
8561
8562 BFD_ASSERT (h->dynindx != -1);
8563
be3ccd9c 8564 s = bfd_get_section_by_name (dynobj,
303f629d 8565 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 8566 BFD_ASSERT (s != NULL);
8567
8568 /* Fill the stub. */
8569 p = stub;
be3ccd9c 8570 bfd_put_32 (output_bfd, STUB_LW (output_bfd), p);
252b5132 8571 p += 4;
be3ccd9c 8572 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), p);
252b5132
RH		 8573 p += 4;
8574
8575 /* FIXME: Can h->dynindex be more than 64K? */
8576 if (h->dynindx & 0xffff0000)
8577 return false;
8578
8579 bfd_put_32 (output_bfd, STUB_JALR, p);
8580 p += 4;
be3ccd9c 8581 bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, p);
252b5132
RH		 8582
8583 BFD_ASSERT (h->plt.offset <= s->_raw_size);
8584 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
8585
8586 /* Mark the symbol as undefined. plt.offset != -1 occurs
8587 only for the referenced symbol. */
8588 sym->st_shndx = SHN_UNDEF;
8589
8590 /* The run-time linker uses the st_value field of the symbol
8591 to reset the global offset table entry for this external
8592 to its stub address when unlinking a shared object. */
8593 gval = s->output_section->vma + s->output_offset + h->plt.offset;
8594 sym->st_value = gval;
8595 }
8596
b305ef96
UC		 8597 BFD_ASSERT (h->dynindx != -1
8598 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
252b5132 8599
103186c6 8600 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 8601 BFD_ASSERT (sgot != NULL);
8602 BFD_ASSERT (elf_section_data (sgot) != NULL);
8603 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8604 BFD_ASSERT (g != NULL);
8605
7403cb63
MM		 8606 /* Run through the global symbol table, creating GOT entries for all
8607 the symbols that need them. */
8b237a89
MM		 8608 if (g->global_gotsym != NULL
8609 && h->dynindx >= g->global_gotsym->dynindx)
252b5132 8610 {
7403cb63
MM		 8611 bfd_vma offset;
8612 bfd_vma value;
252b5132 8613
7403cb63
MM		 8614 if (sym->st_value)
8615 value = sym->st_value;
8616 else
be3ccd9c
KH		 8617 {
8618 /* For an entity defined in a shared object, this will be
8619 NULL. (For functions in shared objects for
8620 which we have created stubs, ST_VALUE will be non-NULL.
8621 That's because such the functions are now no longer defined
8622 in a shared object.) */
8623
8624 if (info->shared && h->root.type == bfd_link_hash_undefined)
8625 value = 0;
8626 else
8627 value = h->root.u.def.value;
8628 }
7403cb63 8629 offset = mips_elf_global_got_index (dynobj, h);
103186c6 8630 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
252b5132
RH		 8631 }
8632
c6142e5d 8633 /* Create a .msym entry, if appropriate. */
be3ccd9c 8634 smsym = bfd_get_section_by_name (dynobj,
c6142e5d
MM		 8635 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8636 if (smsym)
8637 {
8638 Elf32_Internal_Msym msym;
8639
8640 msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
8641 /* It is undocumented what the `1' indicates, but IRIX6 uses
8642 this value. */
8643 msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
be3ccd9c 8644 bfd_mips_elf_swap_msym_out
c6142e5d
MM		 8645 (dynobj, &msym,
8646 ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
8647 }
8648
252b5132
RH		 8649 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8650 name = h->root.root.string;
8651 if (strcmp (name, "_DYNAMIC") == 0
8652 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
8653 sym->st_shndx = SHN_ABS;
f7cb7d68 8654 else if (strcmp (name, "_DYNAMIC_LINK") == 0
be3ccd9c 8655 || strcmp (name, "_DYNAMIC_LINKING") == 0)
252b5132
RH		 8656 {
8657 sym->st_shndx = SHN_ABS;
8658 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8659 sym->st_value = 1;
8660 }
f7cb7d68
UC		 8661 else if (strcmp (name, "_gp_disp") == 0)
8662 {
8663 sym->st_shndx = SHN_ABS;
8664 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8665 sym->st_value = elf_gp (output_bfd);
8666 }
252b5132
RH		 8667 else if (SGI_COMPAT (output_bfd))
8668 {
f7cb7d68 8669 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
be3ccd9c 8670 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
252b5132
RH		 8671 {
8672 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8673 sym->st_other = STO_PROTECTED;
8674 sym->st_value = 0;
8675 sym->st_shndx = SHN_MIPS_DATA;
8676 }
8677 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8678 {
8679 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8680 sym->st_other = STO_PROTECTED;
8681 sym->st_value = mips_elf_hash_table (info)->procedure_count;
8682 sym->st_shndx = SHN_ABS;
8683 }
8684 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8685 {
8686 if (h->type == STT_FUNC)
8687 sym->st_shndx = SHN_MIPS_TEXT;
8688 else if (h->type == STT_OBJECT)
8689 sym->st_shndx = SHN_MIPS_DATA;
8690 }
8691 }
8692
7403cb63
MM		 8693 /* Handle the IRIX6-specific symbols. */
8694 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8695 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8696
f7cb7d68 8697 if (! info->shared)
252b5132
RH		 8698 {
8699 if (! mips_elf_hash_table (info)->use_rld_obj_head
31a9bdd9
UC		 8700 && (strcmp (name, "__rld_map") == 0
8701 || strcmp (name, "__RLD_MAP") == 0))
252b5132
RH		 8702 {
8703 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8704 BFD_ASSERT (s != NULL);
8705 sym->st_value = s->output_section->vma + s->output_offset;
8706 bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
8707 if (mips_elf_hash_table (info)->rld_value == 0)
8708 mips_elf_hash_table (info)->rld_value = sym->st_value;
8709 }
8710 else if (mips_elf_hash_table (info)->use_rld_obj_head
8711 && strcmp (name, "__rld_obj_head") == 0)
8712 {
303f629d 8713 /* IRIX6 does not use a .rld_map section. */
f7cb7d68
UC		 8714 if (IRIX_COMPAT (output_bfd) == ict_irix5
8715 || IRIX_COMPAT (output_bfd) == ict_none)
be3ccd9c 8716 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
303f629d 8717 != NULL);
252b5132
RH		 8718 mips_elf_hash_table (info)->rld_value = sym->st_value;
8719 }
8720 }
8721
8722 /* If this is a mips16 symbol, force the value to be even. */
8723 if (sym->st_other == STO_MIPS16
8724 && (sym->st_value & 1) != 0)
8725 --sym->st_value;
8726
8727 return true;
8728}
8729
8730/* Finish up the dynamic sections. */
8731
103186c6
MM		 8732boolean
8733_bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
252b5132
RH		 8734 bfd *output_bfd;
8735 struct bfd_link_info *info;
8736{
8737 bfd *dynobj;
8738 asection *sdyn;
8739 asection *sgot;
8740 struct mips_got_info *g;
8741
8742 dynobj = elf_hash_table (info)->dynobj;
8743
8744 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8745
103186c6 8746 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 8747 if (sgot == NULL)
8748 g = NULL;
8749 else
8750 {
8751 BFD_ASSERT (elf_section_data (sgot) != NULL);
8752 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8753 BFD_ASSERT (g != NULL);
8754 }
8755
8756 if (elf_hash_table (info)->dynamic_sections_created)
8757 {
103186c6 8758 bfd_byte *b;
252b5132
RH		 8759
8760 BFD_ASSERT (sdyn != NULL);
8761 BFD_ASSERT (g != NULL);
8762
103186c6
MM		 8763 for (b = sdyn->contents;
8764 b < sdyn->contents + sdyn->_raw_size;
8765 b += MIPS_ELF_DYN_SIZE (dynobj))
252b5132
RH		 8766 {
8767 Elf_Internal_Dyn dyn;
8768 const char *name;
8769 size_t elemsize;
8770 asection *s;
103186c6 8771 boolean swap_out_p;
252b5132 8772
103186c6
MM		 8773 /* Read in the current dynamic entry. */
8774 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
be3ccd9c 8775
103186c6
MM		 8776 /* Assume that we're going to modify it and write it out. */
8777 swap_out_p = true;
252b5132
RH		 8778
8779 switch (dyn.d_tag)
8780 {
252b5132 8781 case DT_RELENT:
be3ccd9c 8782 s = (bfd_get_section_by_name
103186c6
MM		 8783 (dynobj,
8784 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)));
252b5132 8785 BFD_ASSERT (s != NULL);
103186c6 8786 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
252b5132
RH		 8787 break;
8788
8789 case DT_STRSZ:
8790 /* Rewrite DT_STRSZ. */
8791 dyn.d_un.d_val =
8792 _bfd_stringtab_size (elf_hash_table (info)->dynstr);
252b5132
RH		 8793 break;
8794
8795 case DT_PLTGOT:
8796 name = ".got";
8797 goto get_vma;
8798 case DT_MIPS_CONFLICT:
8799 name = ".conflict";
8800 goto get_vma;
8801 case DT_MIPS_LIBLIST:
8802 name = ".liblist";
8803 get_vma:
8804 s = bfd_get_section_by_name (output_bfd, name);
8805 BFD_ASSERT (s != NULL);
8806 dyn.d_un.d_ptr = s->vma;
252b5132
RH		 8807 break;
8808
8809 case DT_MIPS_RLD_VERSION:
8810 dyn.d_un.d_val = 1; /* XXX */
252b5132
RH		 8811 break;
8812
8813 case DT_MIPS_FLAGS:
8814 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
252b5132
RH		 8815 break;
8816
8817 case DT_MIPS_CONFLICTNO:
8818 name = ".conflict";
8819 elemsize = sizeof (Elf32_Conflict);
8820 goto set_elemno;
8821
8822 case DT_MIPS_LIBLISTNO:
8823 name = ".liblist";
8824 elemsize = sizeof (Elf32_Lib);
8825 set_elemno:
8826 s = bfd_get_section_by_name (output_bfd, name);
8827 if (s != NULL)
8828 {
8829 if (s->_cooked_size != 0)
8830 dyn.d_un.d_val = s->_cooked_size / elemsize;
8831 else
8832 dyn.d_un.d_val = s->_raw_size / elemsize;
8833 }
8834 else
be3ccd9c 8835 dyn.d_un.d_val = 0;
252b5132
RH		 8836 break;
8837
8838 case DT_MIPS_TIME_STAMP:
8839 time ((time_t *) &dyn.d_un.d_val);
252b5132
RH		 8840 break;
8841
8842 case DT_MIPS_ICHECKSUM:
8843 /* XXX FIXME: */
103186c6 8844 swap_out_p = false;
252b5132
RH		 8845 break;
8846
8847 case DT_MIPS_IVERSION:
8848 /* XXX FIXME: */
103186c6 8849 swap_out_p = false;
252b5132
RH		 8850 break;
8851
8852 case DT_MIPS_BASE_ADDRESS:
8853 s = output_bfd->sections;
8854 BFD_ASSERT (s != NULL);
8855 dyn.d_un.d_ptr = s->vma & ~(0xffff);
252b5132
RH		 8856 break;
8857
8858 case DT_MIPS_LOCAL_GOTNO:
8859 dyn.d_un.d_val = g->local_gotno;
252b5132
RH		 8860 break;
8861
5499724a
MM		 8862 case DT_MIPS_UNREFEXTNO:
8863 /* The index into the dynamic symbol table which is the
8864 entry of the first external symbol that is not
8865 referenced within the same object. */
8866 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
8867 break;
8868
8869 case DT_MIPS_GOTSYM:
8870 if (g->global_gotsym)
8871 {
8872 dyn.d_un.d_val = g->global_gotsym->dynindx;
8873 break;
8874 }
8875 /* In case if we don't have global got symbols we default
8876 to setting DT_MIPS_GOTSYM to the same value as
8877 DT_MIPS_SYMTABNO, so we just fall through. */
8878
252b5132
RH		 8879 case DT_MIPS_SYMTABNO:
8880 name = ".dynsym";
103186c6 8881 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
252b5132
RH		 8882 s = bfd_get_section_by_name (output_bfd, name);
8883 BFD_ASSERT (s != NULL);
8884
8885 if (s->_cooked_size != 0)
8886 dyn.d_un.d_val = s->_cooked_size / elemsize;
8887 else
8888 dyn.d_un.d_val = s->_raw_size / elemsize;
252b5132
RH		 8889 break;
8890
252b5132
RH		 8891 case DT_MIPS_HIPAGENO:
8892 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
252b5132
RH		 8893 break;
8894
8895 case DT_MIPS_RLD_MAP:
8896 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
252b5132
RH		 8897 break;
8898
7403cb63 8899 case DT_MIPS_OPTIONS:
be3ccd9c 8900 s = (bfd_get_section_by_name
7403cb63
MM		 8901 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
8902 dyn.d_un.d_ptr = s->vma;
7403cb63
MM		 8903 break;
8904
c6142e5d 8905 case DT_MIPS_MSYM:
be3ccd9c 8906 s = (bfd_get_section_by_name
c6142e5d
MM		 8907 (output_bfd, MIPS_ELF_MSYM_SECTION_NAME (output_bfd)));
8908 dyn.d_un.d_ptr = s->vma;
103186c6
MM		 8909 break;
8910
8911 default:
8912 swap_out_p = false;
c6142e5d 8913 break;
252b5132 8914 }
103186c6
MM		 8915
8916 if (swap_out_p)
be3ccd9c 8917 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
103186c6 8918 (dynobj, &dyn, b);
252b5132
RH		 8919 }
8920 }
8921
8922 /* The first entry of the global offset table will be filled at
8923 runtime. The second entry will be used by some runtime loaders.
be3ccd9c 8924 This isn't the case of Irix rld. */
252b5132
RH		 8925 if (sgot != NULL && sgot->_raw_size > 0)
8926 {
103186c6 8927 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
be3ccd9c 8928 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
103186c6 8929 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
252b5132
RH		 8930 }
8931
8932 if (sgot != NULL)
103186c6
MM		 8933 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
8934 = MIPS_ELF_GOT_SIZE (output_bfd);
252b5132
RH		 8935
8936 {
c6142e5d 8937 asection *smsym;
252b5132 8938 asection *s;
252b5132
RH		 8939 Elf32_compact_rel cpt;
8940
30b30c21
RH		 8941 /* ??? The section symbols for the output sections were set up in
8942 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8943 symbols. Should we do so? */
252b5132 8944
be3ccd9c 8945 smsym = bfd_get_section_by_name (dynobj,
c6142e5d 8946 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
30b30c21 8947 if (smsym != NULL)
252b5132 8948 {
103186c6 8949 Elf32_Internal_Msym msym;
c6142e5d 8950
103186c6
MM		 8951 msym.ms_hash_value = 0;
8952 msym.ms_info = ELF32_MS_INFO (0, 1);
c6142e5d 8953
103186c6
MM		 8954 for (s = output_bfd->sections; s != NULL; s = s->next)
8955 {
30b30c21 8956 long dynindx = elf_section_data (s)->dynindx;
252b5132 8957
be3ccd9c 8958 bfd_mips_elf_swap_msym_out
30b30c21
RH		 8959 (output_bfd, &msym,
8960 (((Elf32_External_Msym *) smsym->contents)
8961 + dynindx));
8962 }
252b5132
RH		 8963 }
8964
8965 if (SGI_COMPAT (output_bfd))
8966 {
8967 /* Write .compact_rel section out. */
8968 s = bfd_get_section_by_name (dynobj, ".compact_rel");
8969 if (s != NULL)
8970 {
8971 cpt.id1 = 1;
8972 cpt.num = s->reloc_count;
8973 cpt.id2 = 2;
8974 cpt.offset = (s->output_section->filepos
8975 + sizeof (Elf32_External_compact_rel));
8976 cpt.reserved0 = 0;
8977 cpt.reserved1 = 0;
8978 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
8979 ((Elf32_External_compact_rel *)
8980 s->contents));
8981
8982 /* Clean up a dummy stub function entry in .text. */
be3ccd9c 8983 s = bfd_get_section_by_name (dynobj,
303f629d 8984 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 8985 if (s != NULL)
8986 {
8987 file_ptr dummy_offset;
8988
8989 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
8990 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
8991 memset (s->contents + dummy_offset, 0,
8992 MIPS_FUNCTION_STUB_SIZE);
8993 }
8994 }
8995 }
8996
adb76a3e
UC		 8997 /* We need to sort the entries of the dynamic relocation section. */
8998
8999 if (!ABI_64_P (output_bfd))
9000 {
be3ccd9c
KH		 9001 asection *reldyn;
9002
9003 reldyn = bfd_get_section_by_name (dynobj,
9004 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
9005 if (reldyn != NULL && reldyn->reloc_count > 2)
9006 {
9007 reldyn_sorting_bfd = output_bfd;
9008 qsort ((Elf32_External_Rel *) reldyn->contents + 1,
9009 (size_t) reldyn->reloc_count - 1,
9010 sizeof (Elf32_External_Rel), sort_dynamic_relocs);
9011 }
adb76a3e
UC		 9012 }
9013
252b5132 9014 /* Clean up a first relocation in .rel.dyn. */
be3ccd9c 9015 s = bfd_get_section_by_name (dynobj,
103186c6 9016 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
252b5132 9017 if (s != NULL && s->_raw_size > 0)
103186c6 9018 memset (s->contents, 0, MIPS_ELF_REL_SIZE (dynobj));
252b5132
RH		 9019 }
9020
9021 return true;
9022}
9023\f
9024/* This is almost identical to bfd_generic_get_... except that some
9025 MIPS relocations need to be handled specially. Sigh. */
9026
9027static bfd_byte *
9028elf32_mips_get_relocated_section_contents (abfd, link_info, link_order, data,
9029 relocateable, symbols)
9030 bfd *abfd;
9031 struct bfd_link_info *link_info;
9032 struct bfd_link_order *link_order;
9033 bfd_byte *data;
9034 boolean relocateable;
9035 asymbol **symbols;
9036{
9037 /* Get enough memory to hold the stuff */
9038 bfd *input_bfd = link_order->u.indirect.section->owner;
9039 asection *input_section = link_order->u.indirect.section;
9040
9041 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
9042 arelent **reloc_vector = NULL;
9043 long reloc_count;
9044
9045 if (reloc_size < 0)
9046 goto error_return;
9047
9048 reloc_vector = (arelent **) bfd_malloc (reloc_size);
9049 if (reloc_vector == NULL && reloc_size != 0)
9050 goto error_return;
9051
9052 /* read in the section */
9053 if (!bfd_get_section_contents (input_bfd,
9054 input_section,
9055 (PTR) data,
9056 0,
9057 input_section->_raw_size))
9058 goto error_return;
9059
9060 /* We're not relaxing the section, so just copy the size info */
9061 input_section->_cooked_size = input_section->_raw_size;
9062 input_section->reloc_done = true;
9063
9064 reloc_count = bfd_canonicalize_reloc (input_bfd,
9065 input_section,
9066 reloc_vector,
9067 symbols);
9068 if (reloc_count < 0)
9069 goto error_return;
9070
9071 if (reloc_count > 0)
9072 {
9073 arelent **parent;
9074 /* for mips */
9075 int gp_found;
9076 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
9077
9078 {
9079 struct bfd_hash_entry *h;
9080 struct bfd_link_hash_entry *lh;
9081 /* Skip all this stuff if we aren't mixing formats. */
9082 if (abfd && input_bfd
9083 && abfd->xvec == input_bfd->xvec)
9084 lh = 0;
9085 else
9086 {
9087 h = bfd_hash_lookup (&link_info->hash->table, "_gp", false, false);
9088 lh = (struct bfd_link_hash_entry *) h;
9089 }
9090 lookup:
9091 if (lh)
9092 {
9093 switch (lh->type)
9094 {
9095 case bfd_link_hash_undefined:
9096 case bfd_link_hash_undefweak:
9097 case bfd_link_hash_common:
9098 gp_found = 0;
9099 break;
9100 case bfd_link_hash_defined:
9101 case bfd_link_hash_defweak:
9102 gp_found = 1;
9103 gp = lh->u.def.value;
9104 break;
9105 case bfd_link_hash_indirect:
9106 case bfd_link_hash_warning:
9107 lh = lh->u.i.link;
9108 /* @@FIXME ignoring warning for now */
9109 goto lookup;
9110 case bfd_link_hash_new:
9111 default:
9112 abort ();
9113 }
9114 }
9115 else
9116 gp_found = 0;
9117 }
9118 /* end mips */
9119 for (parent = reloc_vector; *parent != (arelent *) NULL;
9120 parent++)
9121 {
9122 char *error_message = (char *) NULL;
9123 bfd_reloc_status_type r;
9124
9125 /* Specific to MIPS: Deal with relocation types that require
9126 knowing the gp of the output bfd. */
9127 asymbol *sym = *(*parent)->sym_ptr_ptr;
9128 if (bfd_is_abs_section (sym->section) && abfd)
9129 {
9130 /* The special_function wouldn't get called anyways. */
9131 }
9132 else if (!gp_found)
9133 {
9134 /* The gp isn't there; let the special function code
9135 fall over on its own. */
9136 }
9137 else if ((*parent)->howto->special_function
9138 == _bfd_mips_elf_gprel16_reloc)
9139 {
9140 /* bypass special_function call */
9141 r = gprel16_with_gp (input_bfd, sym, *parent, input_section,
9142 relocateable, (PTR) data, gp);
9143 goto skip_bfd_perform_relocation;
9144 }
9145 /* end mips specific stuff */
9146
9147 r = bfd_perform_relocation (input_bfd,
9148 *parent,
9149 (PTR) data,
9150 input_section,
9151 relocateable ? abfd : (bfd *) NULL,
9152 &error_message);
9153 skip_bfd_perform_relocation:
9154
9155 if (relocateable)
9156 {
9157 asection *os = input_section->output_section;
9158
9159 /* A partial link, so keep the relocs */
9160 os->orelocation[os->reloc_count] = *parent;
9161 os->reloc_count++;
9162 }
9163
9164 if (r != bfd_reloc_ok)
9165 {
9166 switch (r)
9167 {
9168 case bfd_reloc_undefined:
9169 if (!((*link_info->callbacks->undefined_symbol)
9170 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
5cc7c785
L		 9171 input_bfd, input_section, (*parent)->address,
9172 true)))
252b5132
RH		 9173 goto error_return;
9174 break;
9175 case bfd_reloc_dangerous:
9176 BFD_ASSERT (error_message != (char *) NULL);
9177 if (!((*link_info->callbacks->reloc_dangerous)
9178 (link_info, error_message, input_bfd, input_section,
9179 (*parent)->address)))
9180 goto error_return;
9181 break;
9182 case bfd_reloc_overflow:
9183 if (!((*link_info->callbacks->reloc_overflow)
9184 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
9185 (*parent)->howto->name, (*parent)->addend,
9186 input_bfd, input_section, (*parent)->address)))
9187 goto error_return;
9188 break;
9189 case bfd_reloc_outofrange:
9190 default:
9191 abort ();
9192 break;
9193 }
9194
9195 }
9196 }
9197 }
9198 if (reloc_vector != NULL)
9199 free (reloc_vector);
9200 return data;
9201
9202error_return:
9203 if (reloc_vector != NULL)
9204 free (reloc_vector);
9205 return NULL;
9206}
be3ccd9c 9207
252b5132
RH		 9208#define bfd_elf32_bfd_get_relocated_section_contents \
9209 elf32_mips_get_relocated_section_contents
9210\f
9211/* ECOFF swapping routines. These are used when dealing with the
9212 .mdebug section, which is in the ECOFF debugging format. */
be3ccd9c 9213static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
252b5132
RH		 9214 /* Symbol table magic number. */
9215 magicSym,
9216 /* Alignment of debugging information. E.g., 4. */
9217 4,
9218 /* Sizes of external symbolic information. */
9219 sizeof (struct hdr_ext),
9220 sizeof (struct dnr_ext),
9221 sizeof (struct pdr_ext),
9222 sizeof (struct sym_ext),
9223 sizeof (struct opt_ext),
9224 sizeof (struct fdr_ext),
9225 sizeof (struct rfd_ext),
9226 sizeof (struct ext_ext),
9227 /* Functions to swap in external symbolic data. */
9228 ecoff_swap_hdr_in,
9229 ecoff_swap_dnr_in,
9230 ecoff_swap_pdr_in,
9231 ecoff_swap_sym_in,
9232 ecoff_swap_opt_in,
9233 ecoff_swap_fdr_in,
9234 ecoff_swap_rfd_in,
9235 ecoff_swap_ext_in,
9236 _bfd_ecoff_swap_tir_in,
9237 _bfd_ecoff_swap_rndx_in,
9238 /* Functions to swap out external symbolic data. */
9239 ecoff_swap_hdr_out,
9240 ecoff_swap_dnr_out,
9241 ecoff_swap_pdr_out,
9242 ecoff_swap_sym_out,
9243 ecoff_swap_opt_out,
9244 ecoff_swap_fdr_out,
9245 ecoff_swap_rfd_out,
9246 ecoff_swap_ext_out,
9247 _bfd_ecoff_swap_tir_out,
9248 _bfd_ecoff_swap_rndx_out,
9249 /* Function to read in symbolic data. */
9250 _bfd_mips_elf_read_ecoff_info
9251};
9252\f
9253#define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
9254#define TARGET_LITTLE_NAME "elf32-littlemips"
9255#define TARGET_BIG_SYM bfd_elf32_bigmips_vec
9256#define TARGET_BIG_NAME "elf32-bigmips"
9257#define ELF_ARCH bfd_arch_mips
9258#define ELF_MACHINE_CODE EM_MIPS
9259
9260/* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
9261 a value of 0x1000, and we are compatible. */
9262#define ELF_MAXPAGESIZE 0x1000
9263
9264#define elf_backend_collect true
9265#define elf_backend_type_change_ok true
9266#define elf_backend_can_gc_sections true
86dc0f79 9267#define elf_backend_sign_extend_vma true
3f830999 9268#define elf_info_to_howto mips_info_to_howto_rela
252b5132
RH		 9269#define elf_info_to_howto_rel mips_info_to_howto_rel
9270#define elf_backend_sym_is_global mips_elf_sym_is_global
103186c6
MM		 9271#define elf_backend_object_p _bfd_mips_elf_object_p
9272#define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
252b5132
RH		 9273#define elf_backend_fake_sections _bfd_mips_elf_fake_sections
9274#define elf_backend_section_from_bfd_section \
9275 _bfd_mips_elf_section_from_bfd_section
103186c6 9276#define elf_backend_section_processing _bfd_mips_elf_section_processing
252b5132
RH		 9277#define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
9278#define elf_backend_additional_program_headers \
103186c6
MM		 9279 _bfd_mips_elf_additional_program_headers
9280#define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
252b5132
RH		 9281#define elf_backend_final_write_processing \
9282 _bfd_mips_elf_final_write_processing
9283#define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
103186c6
MM		 9284#define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
9285#define elf_backend_create_dynamic_sections \
9286 _bfd_mips_elf_create_dynamic_sections
9287#define elf_backend_check_relocs _bfd_mips_elf_check_relocs
9288#define elf_backend_adjust_dynamic_symbol \
9289 _bfd_mips_elf_adjust_dynamic_symbol
9290#define elf_backend_always_size_sections \
9291 _bfd_mips_elf_always_size_sections
9292#define elf_backend_size_dynamic_sections \
9293 _bfd_mips_elf_size_dynamic_sections
9294#define elf_backend_relocate_section _bfd_mips_elf_relocate_section
9295#define elf_backend_link_output_symbol_hook \
9296 _bfd_mips_elf_link_output_symbol_hook
9297#define elf_backend_finish_dynamic_symbol \
9298 _bfd_mips_elf_finish_dynamic_symbol
9299#define elf_backend_finish_dynamic_sections \
9300 _bfd_mips_elf_finish_dynamic_sections
9301#define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
9302#define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
9303
9304#define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
9305#define elf_backend_plt_header_size 0
252b5132 9306
8a20f077
UC		 9307#define elf_backend_copy_indirect_symbol \
9308 _bfd_mips_elf_copy_indirect_symbol
9309
b305ef96
UC		 9310#define elf_backend_hide_symbol _bfd_mips_elf_hide_symbol
9311
252b5132
RH		 9312#define bfd_elf32_bfd_is_local_label_name \
9313 mips_elf_is_local_label_name
9314#define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
9315#define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
9316#define bfd_elf32_bfd_link_hash_table_create \
103186c6
MM		 9317 _bfd_mips_elf_link_hash_table_create
9318#define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
252b5132
RH		 9319#define bfd_elf32_bfd_copy_private_bfd_data \
9320 _bfd_mips_elf_copy_private_bfd_data
9321#define bfd_elf32_bfd_merge_private_bfd_data \
9322 _bfd_mips_elf_merge_private_bfd_data
9323#define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
9324#define bfd_elf32_bfd_print_private_bfd_data \
9325 _bfd_mips_elf_print_private_bfd_data
252b5132 9326#include "elf32-target.h"
e364195d
UC		 9327
9328/* Support for traditional mips targets */
9329
9330#define INCLUDED_TARGET_FILE /* More a type of flag */
9331
9332#undef TARGET_LITTLE_SYM
9333#undef TARGET_LITTLE_NAME
9334#undef TARGET_BIG_SYM
9335#undef TARGET_BIG_NAME
9336
9337#define TARGET_LITTLE_SYM bfd_elf32_tradlittlemips_vec
9338#define TARGET_LITTLE_NAME "elf32-tradlittlemips"
9339#define TARGET_BIG_SYM bfd_elf32_tradbigmips_vec
9340#define TARGET_BIG_NAME "elf32-tradbigmips"
9341
9342/* Include the target file again for this target */
9343#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.536771 seconds and 4 git commands to generate.