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