projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf32-mips.c (mips_elf_next_lo16_addend): Rename to ...
[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 *));
23b255aa
MM		 168static const Elf_Internal_Rela *mips_elf_next_lo16_relocation
169 PARAMS ((const Elf_Internal_Rela *, const Elf_Internal_Rela *));
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
23b255aa
MM		 5566/* Returns the first R_MIPS_LO16 relocation found, beginning with
5567 RELOCATION. RELEND is one-past-the-end of the relocation table. */
7403cb63 5568
23b255aa
MM		 5569static const Elf_Internal_Rela *
5570mips_elf_next_lo16_relocation (relocation, relend)
103186c6
MM		 5571 const Elf_Internal_Rela *relocation;
5572 const Elf_Internal_Rela *relend;
7403cb63
MM		 5573{
5574 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5575 immediately following. However, for the IRIX6 ABI, the next
5576 relocation may be a composed relocation consisting of several
5577 relocations for the same address. In that case, the R_MIPS_LO16
435394bf 5578 relocation may occur as one of these. We permit a similar
7403cb63
MM		 5579 extension in general, as that is useful for GCC. */
5580 while (relocation < relend)
5581 {
5582 if (ELF32_R_TYPE (relocation->r_info) == R_MIPS_LO16)
23b255aa 5583 return relocation;
7403cb63
MM		 5584
5585 ++relocation;
5586 }
5587
5588 /* We didn't find it. */
6387d602 5589 bfd_set_error (bfd_error_bad_value);
23b255aa 5590 return NULL;
7403cb63
MM		 5591}
5592
5593/* Create a rel.dyn relocation for the dynamic linker to resolve. The
5594 relocatin is against the symbol with the dynamic symbol table index
5595 DYNINDX. REL is the original relocation, which is now being made
5596 dynamic. */
5597
5598static unsigned int
5599mips_elf_create_dynamic_relocation (output_bfd, info, rel, dynindx,
5600 addend, input_section)
5601 bfd *output_bfd;
5602 struct bfd_link_info *info;
103186c6 5603 const Elf_Internal_Rela *rel;
7403cb63
MM		 5604 long dynindx;
5605 bfd_vma addend;
5606 asection *input_section;
5607{
5608 Elf_Internal_Rel outrel;
5609 boolean skip;
5610 asection *sreloc;
5611 bfd *dynobj;
5612 int r_type;
5613
5614 r_type = ELF32_R_TYPE (rel->r_info);
5615 dynobj = elf_hash_table (info)->dynobj;
103186c6
MM		 5616 sreloc
5617 = bfd_get_section_by_name (dynobj,
5618 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd));
7403cb63
MM		 5619 BFD_ASSERT (sreloc != NULL);
5620
5621 skip = false;
5622
5623 /* The symbol for the relocation is the same as it was for the
5624 original relocation. */
5625 outrel.r_info = ELF32_R_INFO (dynindx, R_MIPS_REL32);
5626
5627 /* The offset for the dynamic relocation is the same as for the
5628 original relocation, adjusted by the offset at which the original
5629 section is output. */
5630 if (elf_section_data (input_section)->stab_info == NULL)
5631 outrel.r_offset = rel->r_offset;
5632 else
5633 {
5634 bfd_vma off;
5635
5636 off = (_bfd_stab_section_offset
5637 (output_bfd, &elf_hash_table (info)->stab_info,
5638 input_section,
5639 &elf_section_data (input_section)->stab_info,
5640 rel->r_offset));
5641 if (off == (bfd_vma) -1)
5642 skip = true;
5643 outrel.r_offset = off;
5644 }
5645 outrel.r_offset += (input_section->output_section->vma
5646 + input_section->output_offset);
5647
5648 /* If we've decided to skip this relocation, just output an emtpy
5649 record. */
5650 if (skip)
5651 memset (&outrel, 0, sizeof (outrel));
5652
103186c6
MM		 5653 if (ABI_64_P (output_bfd))
5654 {
5655 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5656 (output_bfd, &outrel,
5657 (sreloc->contents
5658 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5659 }
5660 else
5661 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
5662 (((Elf32_External_Rel *)
5663 sreloc->contents)
5664 + sreloc->reloc_count));
7403cb63
MM		 5665 ++sreloc->reloc_count;
5666
5667 /* Make sure the output section is writable. The dynamic linker
5668 will be writing to it. */
5669 elf_section_data (input_section->output_section)->this_hdr.sh_flags
5670 |= SHF_WRITE;
5671
5672 /* On IRIX5, make an entry of compact relocation info. */
5673 if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
5674 {
5675 asection* scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5676 bfd_byte *cr;
5677
5678 if (scpt)
5679 {
5680 Elf32_crinfo cptrel;
5681
5682 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5683 cptrel.vaddr = (rel->r_offset
5684 + input_section->output_section->vma
5685 + input_section->output_offset);
5686 if (r_type == R_MIPS_REL32)
5687 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
252b5132 5688 else
7403cb63
MM		 5689 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5690 mips_elf_set_cr_dist2to (cptrel, 0);
5691 cptrel.konst = addend;
5692
5693 cr = (scpt->contents
5694 + sizeof (Elf32_External_compact_rel));
5695 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5696 ((Elf32_External_crinfo *) cr
5697 + scpt->reloc_count));
5698 ++scpt->reloc_count;
5699 }
5700 }
252b5132 5701
7403cb63
MM		 5702 return sreloc->reloc_count - 1;
5703}
252b5132 5704
7403cb63
MM		 5705/* Calculate the value produced by the RELOCATION (which comes from
5706 the INPUT_BFD). The ADDEND is the addend to use for this
5707 RELOCATION; RELOCATION->R_ADDEND is ignored.
5708
5709 The result of the relocation calculation is stored in VALUEP.
197b9ca0
MM		 5710 REQUIRE_JALXP indicates whether or not the opcode used with this
5711 relocation must be JALX.
7403cb63
MM		 5712
5713 This function returns bfd_reloc_continue if the caller need take no
5714 further action regarding this relocation, bfd_reloc_notsupported if
5715 something goes dramatically wrong, bfd_reloc_overflow if an
5716 overflow occurs, and bfd_reloc_ok to indicate success. */
5717
5718static bfd_reloc_status_type
5719mips_elf_calculate_relocation (abfd,
5720 input_bfd,
5721 input_section,
5722 info,
5723 relocation,
5724 addend,
5725 howto,
7403cb63
MM		 5726 local_syms,
5727 local_sections,
5728 valuep,
197b9ca0
MM		 5729 namep,
5730 require_jalxp)
7403cb63
MM		 5731 bfd *abfd;
5732 bfd *input_bfd;
5733 asection *input_section;
5734 struct bfd_link_info *info;
103186c6 5735 const Elf_Internal_Rela *relocation;
7403cb63
MM		 5736 bfd_vma addend;
5737 reloc_howto_type *howto;
7403cb63
MM		 5738 Elf_Internal_Sym *local_syms;
5739 asection **local_sections;
5740 bfd_vma *valuep;
5741 const char **namep;
197b9ca0 5742 boolean *require_jalxp;
7403cb63
MM		 5743{
5744 /* The eventual value we will return. */
5745 bfd_vma value;
5746 /* The address of the symbol against which the relocation is
5747 occurring. */
5748 bfd_vma symbol = 0;
5749 /* The final GP value to be used for the relocatable, executable, or
5750 shared object file being produced. */
5751 bfd_vma gp = (bfd_vma) - 1;
5752 /* The place (section offset or address) of the storage unit being
5753 relocated. */
5754 bfd_vma p;
5755 /* The value of GP used to create the relocatable object. */
5756 bfd_vma gp0 = (bfd_vma) - 1;
5757 /* The offset into the global offset table at which the address of
5758 the relocation entry symbol, adjusted by the addend, resides
5759 during execution. */
5760 bfd_vma g = (bfd_vma) - 1;
5761 /* The section in which the symbol referenced by the relocation is
5762 located. */
5763 asection *sec = NULL;
5764 struct mips_elf_link_hash_entry* h = NULL;
103186c6
MM		 5765 /* True if the symbol referred to by this relocation is a local
5766 symbol. */
7403cb63 5767 boolean local_p;
103186c6 5768 /* True if the symbol referred to by this relocation is "_gp_disp". */
7403cb63
MM		 5769 boolean gp_disp_p = false;
5770 Elf_Internal_Shdr *symtab_hdr;
5771 size_t extsymoff;
103186c6 5772 unsigned long r_symndx;
7403cb63 5773 int r_type;
103186c6
MM		 5774 /* True if overflow occurred during the calculation of the
5775 relocation value. */
7403cb63 5776 boolean overflowed_p;
197b9ca0
MM		 5777 /* True if this relocation refers to a MIPS16 function. */
5778 boolean target_is_16_bit_code_p = false;
7403cb63
MM		 5779
5780 /* Parse the relocation. */
5781 r_symndx = ELF32_R_SYM (relocation->r_info);
5782 r_type = ELF32_R_TYPE (relocation->r_info);
5783 p = (input_section->output_section->vma
5784 + input_section->output_offset
5785 + relocation->r_offset);
5786
5787 /* Assume that there will be no overflow. */
5788 overflowed_p = false;
5789
6387d602
ILT		 5790 /* Figure out whether or not the symbol is local, and get the offset
5791 used in the array of hash table entries. */
7403cb63 5792 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6387d602
ILT		 5793 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5794 local_sections);
5795 if (! elf_bad_symtab (input_bfd))
5796 extsymoff = symtab_hdr->sh_info;
5797 else
7403cb63
MM		 5798 {
5799 /* The symbol table does not follow the rule that local symbols
5800 must come before globals. */
5801 extsymoff = 0;
7403cb63
MM		 5802 }
5803
5804 /* Figure out the value of the symbol. */
5805 if (local_p)
5806 {
5807 Elf_Internal_Sym *sym;
5808
5809 sym = local_syms + r_symndx;
5810 sec = local_sections[r_symndx];
5811
5812 symbol = sec->output_section->vma + sec->output_offset;
5813 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
5814 symbol += sym->st_value;
5815
5816 /* MIPS16 text labels should be treated as odd. */
5817 if (sym->st_other == STO_MIPS16)
5818 ++symbol;
5819
5820 /* Record the name of this symbol, for our caller. */
5821 *namep = bfd_elf_string_from_elf_section (input_bfd,
5822 symtab_hdr->sh_link,
5823 sym->st_name);
e049a0de 5824 if (*namep == '\0')
7403cb63 5825 *namep = bfd_section_name (input_bfd, sec);
197b9ca0
MM		 5826
5827 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
7403cb63
MM		 5828 }
5829 else
5830 {
5831 /* For global symbols we look up the symbol in the hash-table. */
5832 h = ((struct mips_elf_link_hash_entry *)
5833 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5834 /* Find the real hash-table entry for this symbol. */
5835 while (h->root.type == bfd_link_hash_indirect
5836 || h->root.type == bfd_link_hash_warning)
5837 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5838
5839 /* Record the name of this symbol, for our caller. */
5840 *namep = h->root.root.root.string;
5841
5842 /* See if this is the special _gp_disp symbol. Note that such a
5843 symbol must always be a global symbol. */
5844 if (strcmp (h->root.root.root.string, "_gp_disp") == 0)
5845 {
5846 /* Relocations against _gp_disp are permitted only with
5847 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5848 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
5849 return bfd_reloc_notsupported;
5850
5851 gp_disp_p = true;
5852 }
97a4bb05
MM		 5853 /* If this symbol is defined, calculate its address. Note that
5854 _gp_disp is a magic symbol, always implicitly defined by the
5855 linker, so it's inappropriate to check to see whether or not
5856 its defined. */
5857 else if ((h->root.root.type == bfd_link_hash_defined
5858 || h->root.root.type == bfd_link_hash_defweak)
5859 && h->root.root.u.def.section)
7403cb63
MM		 5860 {
5861 sec = h->root.root.u.def.section;
5862 if (sec->output_section)
5863 symbol = (h->root.root.u.def.value
5864 + sec->output_section->vma
5865 + sec->output_offset);
252b5132 5866 else
7403cb63
MM		 5867 symbol = h->root.root.u.def.value;
5868 }
97287574
MM		 5869 else if (h->root.root.type == bfd_link_hash_undefweak)
5870 /* We allow relocations against undefined weak symbols, giving
5871 it the value zero, so that you can undefined weak functions
5872 and check to see if they exist by looking at their
5873 addresses. */
5874 symbol = 0;
3811169e
MM		 5875 else if (info->shared && !info->symbolic && !info->no_undefined)
5876 relocation = 0;
5877 else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0)
5878 {
5879 /* If this is a dynamic link, we should have created a
5880 _DYNAMIC_LINK symbol in mips_elf_create_dynamic_sections.
5881 Otherwise, we should define the symbol with a value of 0.
5882 FIXME: It should probably get into the symbol table
5883 somehow as well. */
5884 BFD_ASSERT (! info->shared);
5885 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5886 relocation = 0;
5887 }
7403cb63
MM		 5888 else
5889 {
5890 (*info->callbacks->undefined_symbol)
5891 (info, h->root.root.root.string, input_bfd,
5892 input_section, relocation->r_offset);
5893 return bfd_reloc_undefined;
5894 }
197b9ca0
MM		 5895
5896 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
5897 }
5898
5899 /* If this is a 32-bit call to a 16-bit function with a stub, we
5900 need to redirect the call to the stub, unless we're already *in*
5901 a stub. */
5902 if (r_type != R_MIPS16_26 && !info->relocateable
5903 && ((h != NULL && h->fn_stub != NULL)
5904 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
5905 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5906 && !mips_elf_stub_section_p (input_bfd, input_section))
5907 {
5908 /* This is a 32-bit call to a 16-bit function. We should
5909 have already noticed that we were going to need the
5910 stub. */
5911 if (local_p)
5912 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5913 else
5914 {
5915 BFD_ASSERT (h->need_fn_stub);
5916 sec = h->fn_stub;
5917 }
5918
5919 symbol = sec->output_section->vma + sec->output_offset;
7403cb63 5920 }
197b9ca0
MM		 5921 /* If this is a 16-bit call to a 32-bit function with a stub, we
5922 need to redirect the call to the stub. */
5923 else if (r_type == R_MIPS16_26 && !info->relocateable
5924 && h != NULL
5925 && (h->call_stub != NULL || h->call_fp_stub != NULL)
5926 && !target_is_16_bit_code_p)
5927 {
5928 /* If both call_stub and call_fp_stub are defined, we can figure
5929 out which one to use by seeing which one appears in the input
5930 file. */
5931 if (h->call_stub != NULL && h->call_fp_stub != NULL)
5932 {
5933 asection *o;
5934
5935 sec = NULL;
5936 for (o = input_bfd->sections; o != NULL; o = o->next)
5937 {
5938 if (strncmp (bfd_get_section_name (input_bfd, o),
5939 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5940 {
5941 sec = h->call_fp_stub;
5942 break;
5943 }
5944 }
5945 if (sec == NULL)
5946 sec = h->call_stub;
5947 }
5948 else if (h->call_stub != NULL)
5949 sec = h->call_stub;
5950 else
5951 sec = h->call_fp_stub;
5952
5953 BFD_ASSERT (sec->_raw_size > 0);
5954 symbol = sec->output_section->vma + sec->output_offset;
5955 }
5956
5957 /* Calls from 16-bit code to 32-bit code and vice versa require the
5958 special jalx instruction. */
6387d602
ILT		 5959 *require_jalxp = (!info->relocateable
5960 && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
252b5132 5961
7403cb63
MM		 5962 /* If we haven't already determined the GOT offset, or the GP value,
5963 and we're going to need it, get it now. */
5964 switch (r_type)
5965 {
5966 case R_MIPS_CALL16:
2841ecd0 5967 case R_MIPS_GOT16:
7403cb63
MM		 5968 case R_MIPS_GOT_DISP:
5969 case R_MIPS_GOT_HI16:
5970 case R_MIPS_CALL_HI16:
5971 case R_MIPS_GOT_LO16:
5972 case R_MIPS_CALL_LO16:
5973 /* Find the index into the GOT where this value is located. */
5974 if (h)
5975 {
5976 BFD_ASSERT (addend == 0);
5977 g = mips_elf_global_got_index
5978 (elf_hash_table (info)->dynobj,
5979 (struct elf_link_hash_entry*) h);
5980 }
5981 else
5982 {
5983 g = mips_elf_local_got_index (abfd, info, symbol + addend);
5984 if (g == (bfd_vma) -1)
5985 return false;
5986 }
252b5132 5987
7403cb63
MM		 5988 /* Convert GOT indices to actual offsets. */
5989 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
5990 abfd, g);
5991 break;
5992
5993 case R_MIPS_HI16:
5994 case R_MIPS_LO16:
5995 case R_MIPS_GPREL16:
5996 case R_MIPS_GPREL32:
5997 gp0 = _bfd_get_gp_value (input_bfd);
5998 gp = _bfd_get_gp_value (abfd);
5999 break;
252b5132 6000
7403cb63
MM		 6001 default:
6002 break;
6003 }
252b5132 6004
7403cb63
MM		 6005 /* Figure out what kind of relocation is being performed. */
6006 switch (r_type)
6007 {
6008 case R_MIPS_NONE:
6009 return bfd_reloc_continue;
252b5132 6010
7403cb63
MM		 6011 case R_MIPS_16:
6012 value = symbol + mips_elf_sign_extend (addend, 16);
6013 overflowed_p = mips_elf_overflow_p (value, 16);
6014 break;
252b5132 6015
7403cb63
MM		 6016 case R_MIPS_32:
6017 case R_MIPS_REL32:
a3c7651d 6018 case R_MIPS_64:
7403cb63
MM		 6019 /* If we're creating a shared library, or this relocation is
6020 against a symbol in a shared library, then we can't know
6021 where the symbol will end up. So, we create a relocation
6022 record in the output, and leave the job up to the dynamic
6023 linker. */
6024 if (info->shared || !sec->output_section)
6025 {
6026 unsigned int reloc_index;
6027
6028 BFD_ASSERT (h != NULL);
6029 reloc_index
6030 = mips_elf_create_dynamic_relocation (abfd,
a3c7651d
MM		 6031 info,
6032 relocation,
6033 h->root.dynindx,
6034 addend,
6035 input_section);
7403cb63
MM		 6036 if (h->min_dyn_reloc_index == 0
6037 || reloc_index < h->min_dyn_reloc_index)
6038 h->min_dyn_reloc_index = reloc_index;
6039 value = symbol + addend;
6040 }
6041 else
6042 {
a3c7651d 6043 if (r_type != R_MIPS_REL32)
7403cb63
MM		 6044 value = symbol + addend;
6045 else
6046 value = addend;
6047 }
6048 value &= howto->dst_mask;
6049 break;
6050
e53bd91b
MM		 6051 case R_MIPS16_26:
6052 /* The calculation for R_MIPS_26 is just the same as for an
6053 R_MIPS_26. It's only the storage of the relocated field into
1e52e2ee 6054 the output file that's different. That's handled in
e53bd91b
MM		 6055 mips_elf_perform_relocation. So, we just fall through to the
6056 R_MIPS_26 case here. */
7403cb63
MM		 6057 case R_MIPS_26:
6058 if (local_p)
6059 value = (((addend << 2) | (p & 0xf0000000)) + symbol) >> 2;
6060 else
6061 value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
6062 value &= howto->dst_mask;
6063 break;
6064
6065 case R_MIPS_HI16:
6066 if (!gp_disp_p)
6067 {
6068 value = mips_elf_high (addend + symbol);
6069 value &= howto->dst_mask;
6070 }
6071 else
6072 {
6073 value = mips_elf_high (addend + gp - p);
6074 overflowed_p = mips_elf_overflow_p (value, 16);
6075 }
6076 break;
6077
6078 case R_MIPS_LO16:
6079 if (!gp_disp_p)
6080 value = (symbol + addend) & howto->dst_mask;
6081 else
6082 {
6083 value = addend + gp - p + 4;
97a4bb05
MM		 6084 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6085 for overflow. But, on, say, Irix 5, relocations against
6086 _gp_disp are normally generated from the .cpload
6087 pseudo-op. It generates code that normally looks like
6088 this:
6089
6090 lui $gp,%hi(_gp_disp)
6091 addiu $gp,$gp,%lo(_gp_disp)
6092 addu $gp,$gp,$t9
6093
6094 Here $t9 holds the address of the function being called,
6095 as required by the MIPS ELF ABI. The R_MIPS_LO16
e53bd91b 6096 relocation can easily overflow in this situation, but the
97a4bb05
MM		 6097 R_MIPS_HI16 relocation will handle the overflow.
6098 Therefore, we consider this a bug in the MIPS ABI, and do
6099 not check for overflow here. */
7403cb63
MM		 6100 }
6101 break;
6102
6103 case R_MIPS_LITERAL:
6104 /* Because we don't merge literal sections, we can handle this
6105 just like R_MIPS_GPREL16. In the long run, we should merge
6106 shared literals, and then we will need to additional work
6107 here. */
6108
6109 /* Fall through. */
6110
b7233c24
MM		 6111 case R_MIPS16_GPREL:
6112 /* The R_MIPS16_GPREL performs the same calculation as
6113 R_MIPS_GPREL16, but stores the relocated bits in a different
6114 order. We don't need to do anything special here; the
6115 differences are handled in mips_elf_perform_relocation. */
7403cb63
MM		 6116 case R_MIPS_GPREL16:
6117 if (local_p)
6118 value = mips_elf_sign_extend (addend, 16) + symbol + gp0 - gp;
6119 else
6120 value = mips_elf_sign_extend (addend, 16) + symbol - gp;
6121 overflowed_p = mips_elf_overflow_p (value, 16);
6122 break;
6123
6124 case R_MIPS_GOT16:
6125 if (local_p)
6126 {
6127 value = mips_elf_got16_entry (abfd, info, symbol + addend);
6128 if (value == (bfd_vma) -1)
6129 return false;
6130 value
6131 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6132 abfd,
6133 value);
6134 overflowed_p = mips_elf_overflow_p (value, 16);
6135 break;
6136 }
6137
6138 /* Fall through. */
6139
6140 case R_MIPS_CALL16:
6141 case R_MIPS_GOT_DISP:
6142 value = g;
6143 overflowed_p = mips_elf_overflow_p (value, 16);
6144 break;
6145
6146 case R_MIPS_GPREL32:
6147 value = (addend + symbol + gp0 - gp) & howto->dst_mask;
6148 break;
6149
6150 case R_MIPS_PC16:
6151 value = mips_elf_sign_extend (addend, 16) + symbol - p;
6152 overflowed_p = mips_elf_overflow_p (value, 16);
6153 break;
6154
6155 case R_MIPS_GOT_HI16:
6156 case R_MIPS_CALL_HI16:
6157 /* We're allowed to handle these two relocations identically.
6158 The dynamic linker is allowed to handle the CALL relocations
6159 differently by creating a lazy evaluation stub. */
6160 value = g;
6161 value = mips_elf_high (value);
6162 value &= howto->dst_mask;
6163 break;
6164
6165 case R_MIPS_GOT_LO16:
6166 case R_MIPS_CALL_LO16:
6167 value = g & howto->dst_mask;
6168 break;
6169
7403cb63
MM		 6170 case R_MIPS_GOT_PAGE:
6171 value = mips_elf_got_page (abfd, info, symbol + addend, NULL);
6172 if (value == (bfd_vma) -1)
6173 return false;
6174 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6175 abfd,
6176 value);
6177 overflowed_p = mips_elf_overflow_p (value, 16);
6178 break;
6179
6180 case R_MIPS_GOT_OFST:
6181 mips_elf_got_page (abfd, info, symbol + addend, &value);
6182 overflowed_p = mips_elf_overflow_p (value, 16);
6183 break;
6184
6185 case R_MIPS_SUB:
6186 value = symbol - addend;
6187 value &= howto->dst_mask;
6188 break;
6189
6190 case R_MIPS_HIGHER:
6191 value = mips_elf_higher (addend + symbol);
6192 value &= howto->dst_mask;
6193 break;
6194
6195 case R_MIPS_HIGHEST:
6196 value = mips_elf_highest (addend + symbol);
6197 value &= howto->dst_mask;
6198 break;
6199
6200 case R_MIPS_SCN_DISP:
6201 value = symbol + addend - sec->output_offset;
6202 value &= howto->dst_mask;
6203 break;
6204
6205 case R_MIPS_PJUMP:
6206 case R_MIPS_JALR:
6207 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6208 hint; we could improve performance by honoring that hint. */
6209 return bfd_reloc_continue;
6210
6211 case R_MIPS_GNU_VTINHERIT:
6212 case R_MIPS_GNU_VTENTRY:
6213 /* We don't do anything with these at present. */
6214 return bfd_reloc_continue;
6215
7403cb63
MM		 6216 default:
6217 /* An unrecognized relocation type. */
6218 return bfd_reloc_notsupported;
6219 }
6220
6221 /* Store the VALUE for our caller. */
6222 *valuep = value;
6223 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6224}
6225
6226/* Obtain the field relocated by RELOCATION. */
6227
6228static bfd_vma
6229mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
6230 reloc_howto_type *howto;
103186c6 6231 const Elf_Internal_Rela *relocation;
7403cb63
MM		 6232 bfd *input_bfd;
6233 bfd_byte *contents;
6234{
6235 bfd_vma x;
6236 bfd_byte *location = contents + relocation->r_offset;
6237
b7233c24
MM		 6238 /* Obtain the bytes. */
6239 x = bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
7403cb63 6240
6296902e
MM		 6241 if ((ELF32_R_TYPE (relocation->r_info) == R_MIPS16_26
6242 || ELF32_R_TYPE (relocation->r_info) == R_MIPS16_GPREL)
1e52e2ee
MM		 6243 && bfd_little_endian (input_bfd))
6244 /* The two 16-bit words will be reversed on a little-endian
6245 system. See mips_elf_perform_relocation for more details. */
6246 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6247
7403cb63
MM		 6248 return x;
6249}
6250
6251/* It has been determined that the result of the RELOCATION is the
6252 VALUE. Use HOWTO to place VALUE into the output file at the
6253 appropriate position. The SECTION is the section to which the
197b9ca0
MM		 6254 relocation applies. If REQUIRE_JALX is true, then the opcode used
6255 for the relocation must be either JAL or JALX, and it is
6256 unconditionally converted to JALX.
7403cb63
MM		 6257
6258 Returns false if anything goes wrong. */
252b5132 6259
197b9ca0 6260static boolean
e53bd91b 6261mips_elf_perform_relocation (info, howto, relocation, value,
197b9ca0
MM		 6262 input_bfd, input_section,
6263 contents, require_jalx)
e53bd91b 6264 struct bfd_link_info *info;
7403cb63 6265 reloc_howto_type *howto;
103186c6 6266 const Elf_Internal_Rela *relocation;
7403cb63
MM		 6267 bfd_vma value;
6268 bfd *input_bfd;
197b9ca0 6269 asection *input_section;
7403cb63 6270 bfd_byte *contents;
197b9ca0 6271 boolean require_jalx;
7403cb63
MM		 6272{
6273 bfd_vma x;
e53bd91b 6274 bfd_byte *location;
197b9ca0 6275 int r_type = ELF32_R_TYPE (relocation->r_info);
e53bd91b
MM		 6276
6277 /* Figure out where the relocation is occurring. */
6278 location = contents + relocation->r_offset;
252b5132 6279
7403cb63
MM		 6280 /* Obtain the current value. */
6281 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
252b5132 6282
7403cb63
MM		 6283 /* Clear the field we are setting. */
6284 x &= ~howto->dst_mask;
252b5132 6285
e53bd91b
MM		 6286 /* If this is the R_MIPS16_26 relocation, we must store the
6287 value in a funny way. */
197b9ca0 6288 if (r_type == R_MIPS16_26)
7403cb63 6289 {
e53bd91b
MM		 6290 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6291 Most mips16 instructions are 16 bits, but these instructions
6292 are 32 bits.
6293
6294 The format of these instructions is:
6295
6296 +--------------+--------------------------------+
6297 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6298 +--------------+--------------------------------+
6299 ! Immediate 15:0 !
6300 +-----------------------------------------------+
6301
6302 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6303 Note that the immediate value in the first word is swapped.
6304
6305 When producing a relocateable object file, R_MIPS16_26 is
6306 handled mostly like R_MIPS_26. In particular, the addend is
6307 stored as a straight 26-bit value in a 32-bit instruction.
6308 (gas makes life simpler for itself by never adjusting a
6309 R_MIPS16_26 reloc to be against a section, so the addend is
6310 always zero). However, the 32 bit instruction is stored as 2
6311 16-bit values, rather than a single 32-bit value. In a
6312 big-endian file, the result is the same; in a little-endian
6313 file, the two 16-bit halves of the 32 bit value are swapped.
6314 This is so that a disassembler can recognize the jal
6315 instruction.
6316
6317 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6318 instruction stored as two 16-bit values. The addend A is the
6319 contents of the targ26 field. The calculation is the same as
6320 R_MIPS_26. When storing the calculated value, reorder the
6321 immediate value as shown above, and don't forget to store the
6322 value as two 16-bit values.
6323
6324 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6325 defined as
6326
6327 big-endian:
6328 +--------+----------------------+
6329 | | |
6330 | | targ26-16 |
6331 |31 26|25 0|
6332 +--------+----------------------+
6333
6334 little-endian:
6335 +----------+------+-------------+
6336 | | | |
6337 | sub1 | | sub2 |
6338 |0 9|10 15|16 31|
6339 +----------+--------------------+
6340 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6341 ((sub1 << 16) | sub2)).
6342
6343 When producing a relocateable object file, the calculation is
6344 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6345 When producing a fully linked file, the calculation is
6346 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6347 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6348
6349 if (!info->relocateable)
6350 /* Shuffle the bits according to the formula above. */
6351 value = (((value & 0x1f0000) << 5)
6352 | ((value & 0x3e00000) >> 5)
6353 | (value & 0xffff));
6354
e53bd91b 6355 }
197b9ca0 6356 else if (r_type == R_MIPS16_GPREL)
b7233c24
MM		 6357 {
6358 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6359 mode. A typical instruction will have a format like this:
6360
6361 +--------------+--------------------------------+
6362 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6363 +--------------+--------------------------------+
6364 ! Major ! rx ! ry ! Imm 4:0 !
6365 +--------------+--------------------------------+
6366
6367 EXTEND is the five bit value 11110. Major is the instruction
6368 opcode.
6369
6370 This is handled exactly like R_MIPS_GPREL16, except that the
6371 addend is retrieved and stored as shown in this diagram; that
6372 is, the Imm fields above replace the V-rel16 field.
6373
6296902e
MM		 6374 All we need to do here is shuffle the bits appropriately. As
6375 above, the two 16-bit halves must be swapped on a
6376 little-endian system. */
b7233c24
MM		 6377 value = (((value & 0x7e0) << 16)
6378 | ((value & 0xf800) << 5)
6379 | (value & 0x1f));
6380 }
252b5132 6381
e53bd91b
MM		 6382 /* Set the field. */
6383 x |= (value & howto->dst_mask);
252b5132 6384
197b9ca0
MM		 6385 /* If required, turn JAL into JALX. */
6386 if (require_jalx)
6387 {
6388 boolean ok;
6389 bfd_vma opcode = x >> 26;
6390 bfd_vma jalx_opcode;
6391
6392 /* Check to see if the opcode is already JAL or JALX. */
6393 if (r_type == R_MIPS16_26)
6394 {
6395 ok = ((opcode == 0x6) || (opcode == 0x7));
6396 jalx_opcode = 0x7;
6397 }
6398 else
6399 {
6400 ok = ((opcode == 0x3) || (opcode == 0x1d));
6401 jalx_opcode = 0x1d;
6402 }
6403
6404 /* If the opcode is not JAL or JALX, there's a problem. */
6405 if (!ok)
6406 {
6407 (*_bfd_error_handler)
6408 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6409 bfd_get_filename (input_bfd),
6410 input_section->name,
6411 (unsigned long) relocation->r_offset);
6412 bfd_set_error (bfd_error_bad_value);
6413 return false;
6414 }
6415
6416 /* Make this the JALX opcode. */
6417 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6418 }
6419
6296902e
MM		 6420 /* Swap the high- and low-order 16 bits on little-endian systems
6421 when doing a MIPS16 relocation. */
197b9ca0 6422 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
6296902e
MM		 6423 && bfd_little_endian (input_bfd))
6424 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6425
e53bd91b
MM		 6426 /* Put the value into the output. */
6427 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
197b9ca0
MM		 6428 return true;
6429}
6430
6431/* Returns true if SECTION is a MIPS16 stub section. */
6432
6433static boolean
6434mips_elf_stub_section_p (abfd, section)
6387d602 6435 bfd *abfd ATTRIBUTE_UNUSED;
197b9ca0
MM		 6436 asection *section;
6437{
6438 const char *name = bfd_get_section_name (abfd, section);
6439
6440 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
6441 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
6442 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
7403cb63 6443}
252b5132 6444
7403cb63 6445/* Relocate a MIPS ELF section. */
252b5132 6446
103186c6
MM		 6447boolean
6448_bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6449 contents, relocs, local_syms, local_sections)
7403cb63
MM		 6450 bfd *output_bfd;
6451 struct bfd_link_info *info;
6452 bfd *input_bfd;
6453 asection *input_section;
6454 bfd_byte *contents;
6455 Elf_Internal_Rela *relocs;
6456 Elf_Internal_Sym *local_syms;
6457 asection **local_sections;
6458{
31367b81 6459 Elf_Internal_Rela *rel;
103186c6 6460 const Elf_Internal_Rela *relend;
7403cb63
MM		 6461 bfd_vma addend;
6462 bfd_vma last_hi16_addend;
7403cb63
MM		 6463 boolean use_saved_addend_p = false;
6464 boolean last_hi16_addend_valid_p = false;
103186c6 6465 struct elf_backend_data *bed;
252b5132 6466
103186c6
MM		 6467 bed = get_elf_backend_data (output_bfd);
6468 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
7403cb63
MM		 6469 for (rel = relocs; rel < relend; ++rel)
6470 {
6471 const char *name;
6472 bfd_vma value;
7403cb63 6473 reloc_howto_type *howto;
197b9ca0 6474 boolean require_jalx;
31367b81
MM		 6475 /* True if the relocation is a RELA relocation, rather than a
6476 REL relocation. */
6477 boolean rela_relocation_p = true;
6478 int r_type = ELF32_R_TYPE (rel->r_info);
252b5132 6479
7403cb63 6480 /* Find the relocation howto for this relocation. */
31367b81 6481 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
a3c7651d
MM		 6482 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6483 64-bit code, but make sure all their addresses are in the
6484 lowermost or uppermost 32-bit section of the 64-bit address
6485 space. Thus, when they use an R_MIPS_64 they mean what is
6486 usually meant by R_MIPS_32, with the exception that the
6487 stored value is sign-extended to 64 bits. */
6488 howto = elf_mips_howto_table + R_MIPS_32;
6489 else
c9b3cbf3 6490 howto = mips_rtype_to_howto (r_type);
252b5132 6491
7403cb63
MM		 6492 if (!use_saved_addend_p)
6493 {
6494 Elf_Internal_Shdr *rel_hdr;
6495
6496 /* If these relocations were originally of the REL variety,
6497 we must pull the addend out of the field that will be
6498 relocated. Otherwise, we simply use the contents of the
6499 RELA relocation. To determine which flavor or relocation
6500 this is, we depend on the fact that the INPUT_SECTION's
6501 REL_HDR is read before its REL_HDR2. */
6502 rel_hdr = &elf_section_data (input_section)->rel_hdr;
5f771d47 6503 if ((size_t) (rel - relocs)
103186c6
MM		 6504 >= (rel_hdr->sh_size / rel_hdr->sh_entsize
6505 * bed->s->int_rels_per_ext_rel))
7403cb63 6506 rel_hdr = elf_section_data (input_section)->rel_hdr2;
103186c6 6507 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
7403cb63 6508 {
31367b81
MM		 6509 /* Note that this is a REL relocation. */
6510 rela_relocation_p = false;
7403cb63 6511
31367b81 6512 /* Get the addend, which is stored in the input file. */
7403cb63
MM		 6513 addend = mips_elf_obtain_contents (howto,
6514 rel,
6515 input_bfd,
6516 contents);
6517 addend &= howto->src_mask;
6518
6519 /* For some kinds of relocations, the ADDEND is a
6520 combination of the addend stored in two different
6521 relocations. */
6387d602
ILT		 6522 if (r_type == R_MIPS_HI16
6523 || (r_type == R_MIPS_GOT16
6524 && mips_elf_local_relocation_p (input_bfd, rel,
6525 local_sections)))
252b5132 6526 {
23b255aa
MM		 6527 bfd_vma l;
6528 const Elf_Internal_Rela *lo16_relocation;
6529 reloc_howto_type *lo16_howto;
6530
7403cb63
MM		 6531 /* Scan ahead to find a matching R_MIPS_LO16
6532 relocation. */
23b255aa
MM		 6533 lo16_relocation
6534 = mips_elf_next_lo16_relocation (rel, relend);
6535 if (lo16_relocation == NULL)
7403cb63 6536 return false;
252b5132 6537
23b255aa
MM		 6538 /* Obtain the addend kept there. */
6539 lo16_howto = mips_rtype_to_howto (R_MIPS_LO16);
6540 l = mips_elf_obtain_contents (lo16_howto,
6541 lo16_relocation,
6542 input_bfd, contents);
6543 l &= lo16_howto->src_mask;
6544
7403cb63
MM		 6545 /* Save the high-order bit for later. When we
6546 encounter the R_MIPS_LO16 relocation we will need
6547 them again. */
6548 addend <<= 16;
6549 last_hi16_addend = addend;
6550 last_hi16_addend_valid_p = true;
252b5132 6551
7403cb63
MM		 6552 /* Compute the combined addend. */
6553 addend |= l;
252b5132 6554 }
7403cb63 6555 else if (r_type == R_MIPS_LO16)
252b5132 6556 {
7403cb63
MM		 6557 /* Used the saved HI16 addend. */
6558 if (!last_hi16_addend_valid_p)
6387d602
ILT		 6559 {
6560 bfd_set_error (bfd_error_bad_value);
6561 return false;
6562 }
7403cb63 6563 addend |= last_hi16_addend;
252b5132 6564 }
b7233c24
MM		 6565 else if (r_type == R_MIPS16_GPREL)
6566 {
6567 /* The addend is scrambled in the object file. See
6568 mips_elf_perform_relocation for details on the
6569 format. */
6570 addend = (((addend & 0x1f0000) >> 5)
6571 | ((addend & 0x7e00000) >> 16)
6572 | (addend & 0x1f));
6573 }
5a44662b
MM		 6574 else if (r_type == R_MIPS16_26
6575 || r_type == R_MIPS16_26)
6576 /* The addend is stored without its two least
6577 significant bits (which are always zero.) */
05fad94d 6578 addend <<= 2;
252b5132
RH		 6579 }
6580 else
7403cb63
MM		 6581 addend = rel->r_addend;
6582 }
252b5132 6583
31367b81
MM		 6584 if (info->relocateable)
6585 {
6586 Elf_Internal_Sym *sym;
6587 unsigned long r_symndx;
6588
6589 /* Since we're just relocating, all we need to do is copy
0db63c18
MM		 6590 the relocations back out to the object file, unless
6591 they're against a section symbol, in which case we need
6592 to adjust by the section offset, or unless they're GP
6593 relative in which case we need to adjust by the amount
6594 that we're adjusting GP in this relocateable object. */
31367b81
MM		 6595
6596 if (!mips_elf_local_relocation_p (input_bfd, rel, local_sections))
f1a5f37e 6597 /* There's nothing to do for non-local relocations. */
31367b81
MM		 6598 continue;
6599
6600 r_symndx = ELF32_R_SYM (rel->r_info);
6601 sym = local_syms + r_symndx;
0db63c18 6602 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
f1a5f37e
MM		 6603 /* Adjust the addend appropriately. */
6604 addend += local_sections[r_symndx]->output_offset;
0db63c18
MM		 6605
6606 if (r_type == R_MIPS16_GPREL
6607 || r_type == R_MIPS_GPREL16
6608 || r_type == R_MIPS_GPREL32)
6609 addend -= (_bfd_get_gp_value (output_bfd)
6610 - _bfd_get_gp_value (input_bfd));
31367b81 6611
f1a5f37e
MM		 6612 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6613 then we only want to write out the high-order 16 bits.
6614 The subsequent R_MIPS_LO16 will handle the low-order bits. */
6615 if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16)
23b255aa 6616 addend = mips_elf_high (addend);
5a44662b
MM		 6617 /* If the relocation is for an R_MIPS_26 relocation, then
6618 the two low-order bits are not stored in the object file;
6619 they are implicitly zero. */
6620 else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26)
6621 addend >>= 2;
f1a5f37e 6622
31367b81
MM		 6623 if (rela_relocation_p)
6624 /* If this is a RELA relocation, just update the addend.
6625 We have to cast away constness for REL. */
6626 rel->r_addend = addend;
6627 else
6628 {
6629 /* Otherwise, we have to write the value back out. Note
6630 that we use the source mask, rather than the
6631 destination mask because the place to which we are
6632 writing will be source of the addend in the final
6633 link. */
6634 addend &= howto->src_mask;
6635 if (!mips_elf_perform_relocation (info, howto, rel, addend,
6636 input_bfd, input_section,
6637 contents, false))
6638 return false;
6639 }
6640
6641 /* Go on to the next relocation. */
6642 continue;
6643 }
6644
7403cb63
MM		 6645 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6646 relocations for the same offset. In that case we are
6647 supposed to treat the output of each relocation as the addend
6648 for the next. */
103186c6
MM		 6649 if (rel + 1 < relend
6650 && rel->r_offset == rel[1].r_offset
b89db8f2 6651 && ELF32_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
7403cb63
MM		 6652 use_saved_addend_p = true;
6653 else
6654 use_saved_addend_p = false;
6655
6656 /* Figure out what value we are supposed to relocate. */
6657 switch (mips_elf_calculate_relocation (output_bfd,
6658 input_bfd,
6659 input_section,
6660 info,
6661 rel,
6662 addend,
6663 howto,
7403cb63
MM		 6664 local_syms,
6665 local_sections,
6666 &value,
197b9ca0
MM		 6667 &name,
6668 &require_jalx))
7403cb63
MM		 6669 {
6670 case bfd_reloc_continue:
6671 /* There's nothing to do. */
6672 continue;
252b5132 6673
7403cb63 6674 case bfd_reloc_undefined:
6387d602 6675 /* mips_elf_calculate_relocation already called the
97287574
MM		 6676 undefined_symbol callback. There's no real point in
6677 trying to perform the relocation at this point, so we
6678 just skip ahead to the next relocation. */
6679 continue;
252b5132 6680
7403cb63
MM		 6681 case bfd_reloc_notsupported:
6682 abort ();
6683 break;
252b5132 6684
7403cb63
MM		 6685 case bfd_reloc_overflow:
6686 if (use_saved_addend_p)
6687 /* Ignore overflow until we reach the last relocation for
6688 a given location. */
6689 ;
6387d602
ILT		 6690 else
6691 {
6692 BFD_ASSERT (name != NULL);
6693 if (! ((*info->callbacks->reloc_overflow)
6694 (info, name, howto->name, (bfd_vma) 0,
6695 input_bfd, input_section, rel->r_offset)))
6696 return false;
6697 }
7403cb63 6698 break;
252b5132 6699
7403cb63
MM		 6700 case bfd_reloc_ok:
6701 break;
6702
6703 default:
6704 abort ();
6705 break;
252b5132
RH		 6706 }
6707
7403cb63
MM		 6708 /* If we've got another relocation for the address, keep going
6709 until we reach the last one. */
6710 if (use_saved_addend_p)
252b5132 6711 {
7403cb63
MM		 6712 addend = value;
6713 continue;
252b5132 6714 }
7403cb63 6715
31367b81 6716 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
a3c7651d
MM		 6717 /* See the comment above about using R_MIPS_64 in the 32-bit
6718 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6719 that calculated the right value. Now, however, we
6720 sign-extend the 32-bit result to 64-bits, and store it as a
6721 64-bit value. We are especially generous here in that we
6722 go to extreme lengths to support this usage on systems with
6723 only a 32-bit VMA. */
6724 {
6725#ifdef BFD64
6726 /* Just sign-extend the value, and then fall through to the
6727 normal case, using the R_MIPS_64 howto. That will store
6728 the 64-bit value into a 64-bit area. */
6729 value = mips_elf_sign_extend (value, 64);
6730 howto = elf_mips_howto_table + R_MIPS_64;
6731#else /* !BFD64 */
6732 /* In the 32-bit VMA case, we must handle sign-extension and
6733 endianness manually. */
6734 bfd_vma sign_bits;
6735 bfd_vma low_bits;
6736 bfd_vma high_bits;
6737
6738 if (value & 0x80000000)
6739 sign_bits = 0xffffffff;
6740 else
6741 sign_bits = 0;
6742
6743 /* If only a 32-bit VMA is available do two separate
6744 stores. */
6745 if (bfd_big_endian (input_bfd))
6746 {
6747 /* Store the sign-bits (which are most significant)
6748 first. */
6749 low_bits = sign_bits;
6750 high_bits = value;
6751 }
6752 else
6753 {
6754 low_bits = value;
6755 high_bits = sign_bits;
6756 }
6757 bfd_put_32 (input_bfd, low_bits,
6758 contents + rel->r_offset);
6759 bfd_put_32 (input_bfd, high_bits,
6760 contents + rel->r_offset + 4);
6761 continue;
6762#endif /* !BFD64 */
6763 }
6764
7403cb63 6765 /* Actually perform the relocation. */
197b9ca0
MM		 6766 if (!mips_elf_perform_relocation (info, howto, rel, value, input_bfd,
6767 input_section, contents,
6768 require_jalx))
6769 return false;
252b5132
RH		 6770 }
6771
6772 return true;
6773}
6774
6775/* This hook function is called before the linker writes out a global
6776 symbol. We mark symbols as small common if appropriate. This is
6777 also where we undo the increment of the value for a mips16 symbol. */
6778
6779/*ARGSIGNORED*/
103186c6
MM		 6780boolean
6781_bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
5f771d47
ILT		 6782 bfd *abfd ATTRIBUTE_UNUSED;
6783 struct bfd_link_info *info ATTRIBUTE_UNUSED;
6784 const char *name ATTRIBUTE_UNUSED;
252b5132
RH		 6785 Elf_Internal_Sym *sym;
6786 asection *input_sec;
6787{
6788 /* If we see a common symbol, which implies a relocatable link, then
6789 if a symbol was small common in an input file, mark it as small
6790 common in the output file. */
6791 if (sym->st_shndx == SHN_COMMON
6792 && strcmp (input_sec->name, ".scommon") == 0)
6793 sym->st_shndx = SHN_MIPS_SCOMMON;
6794
6795 if (sym->st_other == STO_MIPS16
6796 && (sym->st_value & 1) != 0)
6797 --sym->st_value;
6798
6799 return true;
6800}
6801\f
6802/* Functions for the dynamic linker. */
6803
6804/* The name of the dynamic interpreter. This is put in the .interp
6805 section. */
6806
103186c6
MM		 6807#define ELF_DYNAMIC_INTERPRETER(abfd) \
6808 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
6809 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
6810 : "/usr/lib/libc.so.1")
252b5132
RH		 6811
6812/* Create dynamic sections when linking against a dynamic object. */
6813
103186c6
MM		 6814boolean
6815_bfd_mips_elf_create_dynamic_sections (abfd, info)
252b5132
RH		 6816 bfd *abfd;
6817 struct bfd_link_info *info;
6818{
6819 struct elf_link_hash_entry *h;
6820 flagword flags;
6821 register asection *s;
6822 const char * const *namep;
6823
6824 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
6825 | SEC_LINKER_CREATED | SEC_READONLY);
6826
6827 /* Mips ABI requests the .dynamic section to be read only. */
6828 s = bfd_get_section_by_name (abfd, ".dynamic");
6829 if (s != NULL)
6830 {
6831 if (! bfd_set_section_flags (abfd, s, flags))
6832 return false;
6833 }
6834
6835 /* We need to create .got section. */
6836 if (! mips_elf_create_got_section (abfd, info))
6837 return false;
6838
c6142e5d
MM		 6839 /* Create the .msym section on IRIX6. It is used by the dynamic
6840 linker to speed up dynamic relocations, and to avoid computing
6841 the ELF hash for symbols. */
6842 if (IRIX_COMPAT (abfd) == ict_irix6
6843 && !mips_elf_create_msym_section (abfd))
6844 return false;
6845
252b5132 6846 /* Create .stub section. */
7403cb63
MM		 6847 if (bfd_get_section_by_name (abfd,
6848 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
252b5132 6849 {
7403cb63 6850 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
252b5132 6851 if (s == NULL
7403cb63 6852 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
103186c6
MM		 6853 || ! bfd_set_section_alignment (abfd, s,
6854 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 6855 return false;
6856 }
6857
7403cb63 6858 if (IRIX_COMPAT (abfd) == ict_irix5
252b5132
RH		 6859 && !info->shared
6860 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
6861 {
6862 s = bfd_make_section (abfd, ".rld_map");
6863 if (s == NULL
6864 || ! bfd_set_section_flags (abfd, s, flags & ~SEC_READONLY)
103186c6
MM		 6865 || ! bfd_set_section_alignment (abfd, s,
6866 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 6867 return false;
6868 }
6869
303f629d
MM		 6870 /* On IRIX5, we adjust add some additional symbols and change the
6871 alignments of several sections. There is no ABI documentation
6872 indicating that this is necessary on IRIX6, nor any evidence that
6873 the linker takes such action. */
6874 if (IRIX_COMPAT (abfd) == ict_irix5)
252b5132
RH		 6875 {
6876 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
6877 {
6878 h = NULL;
6879 if (! (_bfd_generic_link_add_one_symbol
6880 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
6881 (bfd_vma) 0, (const char *) NULL, false,
6882 get_elf_backend_data (abfd)->collect,
6883 (struct bfd_link_hash_entry **) &h)))
6884 return false;
6885 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6886 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6887 h->type = STT_SECTION;
6888
6889 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6890 return false;
6891 }
6892
6893 /* We need to create a .compact_rel section. */
6894 if (! mips_elf_create_compact_rel_section (abfd, info))
6895 return false;
6896
6897 /* Change aligments of some sections. */
6898 s = bfd_get_section_by_name (abfd, ".hash");
6899 if (s != NULL)
6900 bfd_set_section_alignment (abfd, s, 4);
6901 s = bfd_get_section_by_name (abfd, ".dynsym");
6902 if (s != NULL)
6903 bfd_set_section_alignment (abfd, s, 4);
6904 s = bfd_get_section_by_name (abfd, ".dynstr");
6905 if (s != NULL)
6906 bfd_set_section_alignment (abfd, s, 4);
6907 s = bfd_get_section_by_name (abfd, ".reginfo");
6908 if (s != NULL)
6909 bfd_set_section_alignment (abfd, s, 4);
6910 s = bfd_get_section_by_name (abfd, ".dynamic");
6911 if (s != NULL)
6912 bfd_set_section_alignment (abfd, s, 4);
6913 }
6914
6915 if (!info->shared)
6916 {
6917 h = NULL;
6918 if (! (_bfd_generic_link_add_one_symbol
6919 (info, abfd, "_DYNAMIC_LINK", BSF_GLOBAL, bfd_abs_section_ptr,
6920 (bfd_vma) 0, (const char *) NULL, false,
6921 get_elf_backend_data (abfd)->collect,
6922 (struct bfd_link_hash_entry **) &h)))
6923 return false;
6924 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6925 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6926 h->type = STT_SECTION;
6927
6928 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6929 return false;
6930
6931 if (! mips_elf_hash_table (info)->use_rld_obj_head)
6932 {
6933 /* __rld_map is a four byte word located in the .data section
6934 and is filled in by the rtld to contain a pointer to
6935 the _r_debug structure. Its symbol value will be set in
6936 mips_elf_finish_dynamic_symbol. */
6937 s = bfd_get_section_by_name (abfd, ".rld_map");
6938 BFD_ASSERT (s != NULL);
6939
6940 h = NULL;
6941 if (! (_bfd_generic_link_add_one_symbol
6942 (info, abfd, "__rld_map", BSF_GLOBAL, s,
6943 (bfd_vma) 0, (const char *) NULL, false,
6944 get_elf_backend_data (abfd)->collect,
6945 (struct bfd_link_hash_entry **) &h)))
6946 return false;
6947 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
6948 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
6949 h->type = STT_OBJECT;
6950
6951 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
6952 return false;
6953 }
6954 }
6955
6956 return true;
6957}
6958
6959/* Create the .compact_rel section. */
6960
6961static boolean
6962mips_elf_create_compact_rel_section (abfd, info)
6963 bfd *abfd;
5f771d47 6964 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 6965{
6966 flagword flags;
6967 register asection *s;
6968
6969 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
6970 {
6971 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
6972 | SEC_READONLY);
6973
6974 s = bfd_make_section (abfd, ".compact_rel");
6975 if (s == NULL
6976 || ! bfd_set_section_flags (abfd, s, flags)
103186c6
MM		 6977 || ! bfd_set_section_alignment (abfd, s,
6978 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
252b5132
RH		 6979 return false;
6980
6981 s->_raw_size = sizeof (Elf32_External_compact_rel);
6982 }
6983
6984 return true;
6985}
6986
6987/* Create the .got section to hold the global offset table. */
6988
6989static boolean
6990mips_elf_create_got_section (abfd, info)
6991 bfd *abfd;
6992 struct bfd_link_info *info;
6993{
6994 flagword flags;
6995 register asection *s;
6996 struct elf_link_hash_entry *h;
6997 struct mips_got_info *g;
6998
6999 /* This function may be called more than once. */
103186c6 7000 if (mips_elf_got_section (abfd))
252b5132
RH		 7001 return true;
7002
7003 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7004 | SEC_LINKER_CREATED);
7005
7006 s = bfd_make_section (abfd, ".got");
7007 if (s == NULL
7008 || ! bfd_set_section_flags (abfd, s, flags)
7009 || ! bfd_set_section_alignment (abfd, s, 4))
7010 return false;
7011
7012 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
7013 linker script because we don't want to define the symbol if we
7014 are not creating a global offset table. */
7015 h = NULL;
7016 if (! (_bfd_generic_link_add_one_symbol
7017 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
7018 (bfd_vma) 0, (const char *) NULL, false,
7019 get_elf_backend_data (abfd)->collect,
7020 (struct bfd_link_hash_entry **) &h)))
7021 return false;
7022 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
7023 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7024 h->type = STT_OBJECT;
7025
7026 if (info->shared
7027 && ! bfd_elf32_link_record_dynamic_symbol (info, h))
7028 return false;
7029
7030 /* The first several global offset table entries are reserved. */
103186c6 7031 s->_raw_size = MIPS_RESERVED_GOTNO * MIPS_ELF_GOT_SIZE (abfd);
252b5132
RH		 7032
7033 g = (struct mips_got_info *) bfd_alloc (abfd,
7034 sizeof (struct mips_got_info));
7035 if (g == NULL)
7036 return false;
7403cb63 7037 g->global_gotsym = NULL;
252b5132
RH		 7038 g->local_gotno = MIPS_RESERVED_GOTNO;
7039 g->assigned_gotno = MIPS_RESERVED_GOTNO;
7040 if (elf_section_data (s) == NULL)
7041 {
7042 s->used_by_bfd =
7043 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
7044 if (elf_section_data (s) == NULL)
7045 return false;
7046 }
7047 elf_section_data (s)->tdata = (PTR) g;
7403cb63
MM		 7048 elf_section_data (s)->this_hdr.sh_flags
7049 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
252b5132
RH		 7050
7051 return true;
7052}
7053
c6142e5d
MM		 7054/* Returns the .msym section for ABFD, creating it if it does not
7055 already exist. Returns NULL to indicate error. */
7056
7057static asection *
7058mips_elf_create_msym_section (abfd)
7059 bfd *abfd;
7060{
7061 asection *s;
7062
7063 s = bfd_get_section_by_name (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7064 if (!s)
7065 {
7066 s = bfd_make_section (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7067 if (!s
7068 || !bfd_set_section_flags (abfd, s,
7069 SEC_ALLOC
7070 | SEC_LOAD
7071 | SEC_HAS_CONTENTS
7072 | SEC_LINKER_CREATED
7073 | SEC_READONLY)
103186c6
MM		 7074 || !bfd_set_section_alignment (abfd, s,
7075 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
c6142e5d
MM		 7076 return NULL;
7077 }
7078
7079 return s;
7080}
7081
103186c6
MM		 7082/* Add room for N relocations to the .rel.dyn section in ABFD. */
7083
7084static void
7085mips_elf_allocate_dynamic_relocations (abfd, n)
7086 bfd *abfd;
7087 unsigned int n;
7088{
7089 asection *s;
7090
7091 s = bfd_get_section_by_name (abfd, MIPS_ELF_REL_DYN_SECTION_NAME (abfd));
7092 BFD_ASSERT (s != NULL);
7093
7094 if (s->_raw_size == 0)
7095 {
7096 /* Make room for a null element. */
7097 s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
7098 ++s->reloc_count;
7099 }
7100 s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
7101}
7102
252b5132
RH		 7103/* Look through the relocs for a section during the first phase, and
7104 allocate space in the global offset table. */
7105
103186c6
MM		 7106boolean
7107_bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
252b5132
RH		 7108 bfd *abfd;
7109 struct bfd_link_info *info;
7110 asection *sec;
7111 const Elf_Internal_Rela *relocs;
7112{
7113 const char *name;
7114 bfd *dynobj;
7115 Elf_Internal_Shdr *symtab_hdr;
7116 struct elf_link_hash_entry **sym_hashes;
7117 struct mips_got_info *g;
7118 size_t extsymoff;
7119 const Elf_Internal_Rela *rel;
7120 const Elf_Internal_Rela *rel_end;
7121 asection *sgot;
7122 asection *sreloc;
103186c6 7123 struct elf_backend_data *bed;
252b5132
RH		 7124
7125 if (info->relocateable)
7126 return true;
7127
7128 dynobj = elf_hash_table (info)->dynobj;
7129 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7130 sym_hashes = elf_sym_hashes (abfd);
7131 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7132
7133 /* Check for the mips16 stub sections. */
7134
7135 name = bfd_get_section_name (abfd, sec);
7136 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
7137 {
7138 unsigned long r_symndx;
7139
7140 /* Look at the relocation information to figure out which symbol
7141 this is for. */
7142
7143 r_symndx = ELF32_R_SYM (relocs->r_info);
7144
7145 if (r_symndx < extsymoff
7146 || sym_hashes[r_symndx - extsymoff] == NULL)
7147 {
7148 asection *o;
7149
7150 /* This stub is for a local symbol. This stub will only be
7151 needed if there is some relocation in this BFD, other
7152 than a 16 bit function call, which refers to this symbol. */
7153 for (o = abfd->sections; o != NULL; o = o->next)
7154 {
7155 Elf_Internal_Rela *sec_relocs;
7156 const Elf_Internal_Rela *r, *rend;
7157
7158 /* We can ignore stub sections when looking for relocs. */
7159 if ((o->flags & SEC_RELOC) == 0
7160 || o->reloc_count == 0
7161 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
7162 sizeof FN_STUB - 1) == 0
7163 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
7164 sizeof CALL_STUB - 1) == 0
7165 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
7166 sizeof CALL_FP_STUB - 1) == 0)
7167 continue;
7168
7169 sec_relocs = (_bfd_elf32_link_read_relocs
7170 (abfd, o, (PTR) NULL,
7171 (Elf_Internal_Rela *) NULL,
7172 info->keep_memory));
7173 if (sec_relocs == NULL)
7174 return false;
7175
7176 rend = sec_relocs + o->reloc_count;
7177 for (r = sec_relocs; r < rend; r++)
7178 if (ELF32_R_SYM (r->r_info) == r_symndx
7179 && ELF32_R_TYPE (r->r_info) != R_MIPS16_26)
7180 break;
7181
7182 if (! info->keep_memory)
7183 free (sec_relocs);
7184
7185 if (r < rend)
7186 break;
7187 }
7188
7189 if (o == NULL)
7190 {
7191 /* There is no non-call reloc for this stub, so we do
7192 not need it. Since this function is called before
7193 the linker maps input sections to output sections, we
7194 can easily discard it by setting the SEC_EXCLUDE
7195 flag. */
7196 sec->flags |= SEC_EXCLUDE;
7197 return true;
7198 }
7199
7200 /* Record this stub in an array of local symbol stubs for
7201 this BFD. */
7202 if (elf_tdata (abfd)->local_stubs == NULL)
7203 {
7204 unsigned long symcount;
7205 asection **n;
7206
7207 if (elf_bad_symtab (abfd))
103186c6 7208 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
252b5132
RH		 7209 else
7210 symcount = symtab_hdr->sh_info;
7211 n = (asection **) bfd_zalloc (abfd,
7212 symcount * sizeof (asection *));
7213 if (n == NULL)
7214 return false;
7215 elf_tdata (abfd)->local_stubs = n;
7216 }
7217
7218 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7219
7220 /* We don't need to set mips16_stubs_seen in this case.
7221 That flag is used to see whether we need to look through
7222 the global symbol table for stubs. We don't need to set
7223 it here, because we just have a local stub. */
7224 }
7225 else
7226 {
7227 struct mips_elf_link_hash_entry *h;
7228
7229 h = ((struct mips_elf_link_hash_entry *)
7230 sym_hashes[r_symndx - extsymoff]);
7231
7232 /* H is the symbol this stub is for. */
7233
7234 h->fn_stub = sec;
7235 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7236 }
7237 }
7238 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
7239 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7240 {
7241 unsigned long r_symndx;
7242 struct mips_elf_link_hash_entry *h;
7243 asection **loc;
7244
7245 /* Look at the relocation information to figure out which symbol
7246 this is for. */
7247
7248 r_symndx = ELF32_R_SYM (relocs->r_info);
7249
7250 if (r_symndx < extsymoff
7251 || sym_hashes[r_symndx - extsymoff] == NULL)
7252 {
7253 /* This stub was actually built for a static symbol defined
7254 in the same file. We assume that all static symbols in
7255 mips16 code are themselves mips16, so we can simply
7256 discard this stub. Since this function is called before
7257 the linker maps input sections to output sections, we can
7258 easily discard it by setting the SEC_EXCLUDE flag. */
7259 sec->flags |= SEC_EXCLUDE;
7260 return true;
7261 }
7262
7263 h = ((struct mips_elf_link_hash_entry *)
7264 sym_hashes[r_symndx - extsymoff]);
7265
7266 /* H is the symbol this stub is for. */
7267
7268 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7269 loc = &h->call_fp_stub;
7270 else
7271 loc = &h->call_stub;
7272
7273 /* If we already have an appropriate stub for this function, we
7274 don't need another one, so we can discard this one. Since
7275 this function is called before the linker maps input sections
7276 to output sections, we can easily discard it by setting the
7277 SEC_EXCLUDE flag. We can also discard this section if we
7278 happen to already know that this is a mips16 function; it is
7279 not necessary to check this here, as it is checked later, but
7280 it is slightly faster to check now. */
7281 if (*loc != NULL || h->root.other == STO_MIPS16)
7282 {
7283 sec->flags |= SEC_EXCLUDE;
7284 return true;
7285 }
7286
7287 *loc = sec;
7288 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7289 }
7290
7291 if (dynobj == NULL)
7292 {
7293 sgot = NULL;
7294 g = NULL;
7295 }
7296 else
7297 {
103186c6 7298 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 7299 if (sgot == NULL)
7300 g = NULL;
7301 else
7302 {
7303 BFD_ASSERT (elf_section_data (sgot) != NULL);
7304 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
7305 BFD_ASSERT (g != NULL);
7306 }
7307 }
7308
7309 sreloc = NULL;
103186c6
MM		 7310 bed = get_elf_backend_data (abfd);
7311 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7312 for (rel = relocs; rel < rel_end; ++rel)
252b5132
RH		 7313 {
7314 unsigned long r_symndx;
7403cb63 7315 int r_type;
252b5132
RH		 7316 struct elf_link_hash_entry *h;
7317
7318 r_symndx = ELF32_R_SYM (rel->r_info);
7403cb63 7319 r_type = ELF32_R_TYPE (rel->r_info);
252b5132
RH		 7320
7321 if (r_symndx < extsymoff)
7322 h = NULL;
7323 else
7324 {
7325 h = sym_hashes[r_symndx - extsymoff];
7326
7327 /* This may be an indirect symbol created because of a version. */
7328 if (h != NULL)
7329 {
7330 while (h->root.type == bfd_link_hash_indirect)
7331 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7332 }
7333 }
7334
7335 /* Some relocs require a global offset table. */
7336 if (dynobj == NULL || sgot == NULL)
7337 {
7403cb63 7338 switch (r_type)
252b5132
RH		 7339 {
7340 case R_MIPS_GOT16:
7341 case R_MIPS_CALL16:
7342 case R_MIPS_CALL_HI16:
7343 case R_MIPS_CALL_LO16:
7344 case R_MIPS_GOT_HI16:
7345 case R_MIPS_GOT_LO16:
435394bf
MM		 7346 case R_MIPS_GOT_PAGE:
7347 case R_MIPS_GOT_OFST:
7348 case R_MIPS_GOT_DISP:
252b5132
RH		 7349 if (dynobj == NULL)
7350 elf_hash_table (info)->dynobj = dynobj = abfd;
7351 if (! mips_elf_create_got_section (dynobj, info))
7352 return false;
7403cb63 7353 g = mips_elf_got_info (dynobj, &sgot);
252b5132
RH		 7354 break;
7355
7356 case R_MIPS_32:
7357 case R_MIPS_REL32:
a3c7651d 7358 case R_MIPS_64:
252b5132
RH		 7359 if (dynobj == NULL
7360 && (info->shared || h != NULL)
7361 && (sec->flags & SEC_ALLOC) != 0)
7362 elf_hash_table (info)->dynobj = dynobj = abfd;
7363 break;
7364
7365 default:
7366 break;
7367 }
7368 }
7369
7403cb63
MM		 7370 if (!h && (r_type == R_MIPS_CALL_LO16
7371 || r_type == R_MIPS_GOT_LO16
97287574
MM		 7372 || r_type == R_MIPS_GOT_DISP
7373 || r_type == R_MIPS_GOT16))
252b5132 7374 {
7403cb63 7375 /* We may need a local GOT entry for this relocation. We
97287574
MM		 7376 don't count R_MIPS_GOT_PAGE because we can estimate the
7377 maximum number of pages needed by looking at the size of
7378 the segment. We don't count R_MIPS_GOT_HI16, or
7379 R_MIPS_CALL_HI16 because these are always followed by an
7380 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
7403cb63
MM		 7381
7382 This estimation is very conservative since we can merge
7383 duplicate entries in the GOT. In order to be less
7384 conservative, we could actually build the GOT here,
7385 rather than in relocate_section. */
7386 g->local_gotno++;
a3c7651d 7387 sgot->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
7403cb63 7388 }
252b5132 7389
7403cb63
MM		 7390 switch (r_type)
7391 {
7392 case R_MIPS_CALL16:
252b5132
RH		 7393 if (h == NULL)
7394 {
7395 (*_bfd_error_handler)
7396 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7397 bfd_get_filename (abfd), (unsigned long) rel->r_offset);
7398 bfd_set_error (bfd_error_bad_value);
7399 return false;
7400 }
7403cb63 7401 /* Fall through. */
252b5132 7402
7403cb63
MM		 7403 case R_MIPS_CALL_HI16:
7404 case R_MIPS_CALL_LO16:
5a44662b
MM		 7405 if (h != NULL)
7406 {
7407 /* This symbol requires a global offset table entry. */
7408 if (!mips_elf_record_global_got_symbol (h, info, g))
7409 return false;
252b5132 7410
5a44662b
MM		 7411 /* We need a stub, not a plt entry for the undefined
7412 function. But we record it as if it needs plt. See
7413 elf_adjust_dynamic_symbol in elflink.h. */
7414 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
7415 h->type = STT_FUNC;
7416 }
252b5132
RH		 7417 break;
7418
7419 case R_MIPS_GOT16:
7420 case R_MIPS_GOT_HI16:
7421 case R_MIPS_GOT_LO16:
7403cb63 7422 case R_MIPS_GOT_DISP:
252b5132 7423 /* This symbol requires a global offset table entry. */
7403cb63
MM		 7424 if (h && !mips_elf_record_global_got_symbol (h, info, g))
7425 return false;
252b5132
RH		 7426 break;
7427
7428 case R_MIPS_32:
7429 case R_MIPS_REL32:
a3c7651d 7430 case R_MIPS_64:
252b5132
RH		 7431 if ((info->shared || h != NULL)
7432 && (sec->flags & SEC_ALLOC) != 0)
7433 {
7434 if (sreloc == NULL)
7435 {
103186c6 7436 const char *name = MIPS_ELF_REL_DYN_SECTION_NAME (dynobj);
252b5132
RH		 7437
7438 sreloc = bfd_get_section_by_name (dynobj, name);
7439 if (sreloc == NULL)
7440 {
7441 sreloc = bfd_make_section (dynobj, name);
7442 if (sreloc == NULL
7443 || ! bfd_set_section_flags (dynobj, sreloc,
7444 (SEC_ALLOC
7445 | SEC_LOAD
7446 | SEC_HAS_CONTENTS
7447 | SEC_IN_MEMORY
7448 | SEC_LINKER_CREATED
7449 | SEC_READONLY))
7450 || ! bfd_set_section_alignment (dynobj, sreloc,
7451 4))
7452 return false;
7453 }
7454 }
7455 if (info->shared)
103186c6
MM		 7456 /* When creating a shared object, we must copy these
7457 reloc types into the output file as R_MIPS_REL32
7458 relocs. We make room for this reloc in the
7459 .rel.dyn reloc section. */
7460 mips_elf_allocate_dynamic_relocations (dynobj, 1);
252b5132
RH		 7461 else
7462 {
7463 struct mips_elf_link_hash_entry *hmips;
7464
7465 /* We only need to copy this reloc if the symbol is
7466 defined in a dynamic object. */
7467 hmips = (struct mips_elf_link_hash_entry *) h;
a3c7651d 7468 ++hmips->possibly_dynamic_relocs;
252b5132 7469 }
7403cb63
MM		 7470
7471 /* Even though we don't directly need a GOT entry for
7472 this symbol, a symbol must have a dynamic symbol
7473 table index greater that DT_GOTSYM if there are
7474 dynamic relocations against it. */
7475 if (!mips_elf_record_global_got_symbol (h, info, g))
7476 return false;
252b5132
RH		 7477 }
7478
103186c6 7479 if (SGI_COMPAT (dynobj))
252b5132
RH		 7480 mips_elf_hash_table (info)->compact_rel_size +=
7481 sizeof (Elf32_External_crinfo);
252b5132
RH		 7482 break;
7483
7484 case R_MIPS_26:
7485 case R_MIPS_GPREL16:
7486 case R_MIPS_LITERAL:
7487 case R_MIPS_GPREL32:
103186c6 7488 if (SGI_COMPAT (dynobj))
252b5132
RH		 7489 mips_elf_hash_table (info)->compact_rel_size +=
7490 sizeof (Elf32_External_crinfo);
7491 break;
7492
7493 /* This relocation describes the C++ object vtable hierarchy.
7494 Reconstruct it for later use during GC. */
7495 case R_MIPS_GNU_VTINHERIT:
7496 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7497 return false;
7498 break;
7499
7500 /* This relocation describes which C++ vtable entries are actually
7501 used. Record for later use during GC. */
7502 case R_MIPS_GNU_VTENTRY:
7503 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7504 return false;
7505 break;
7506
7507 default:
7508 break;
7509 }
7510
7511 /* If this reloc is not a 16 bit call, and it has a global
7512 symbol, then we will need the fn_stub if there is one.
7513 References from a stub section do not count. */
7514 if (h != NULL
7403cb63 7515 && r_type != R_MIPS16_26
252b5132
RH		 7516 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
7517 sizeof FN_STUB - 1) != 0
7518 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
7519 sizeof CALL_STUB - 1) != 0
7520 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
7521 sizeof CALL_FP_STUB - 1) != 0)
7522 {
7523 struct mips_elf_link_hash_entry *mh;
7524
7525 mh = (struct mips_elf_link_hash_entry *) h;
7526 mh->need_fn_stub = true;
7527 }
7528 }
7529
7530 return true;
7531}
7532
7533/* Return the section that should be marked against GC for a given
7534 relocation. */
7535
103186c6
MM		 7536asection *
7537_bfd_mips_elf_gc_mark_hook (abfd, info, rel, h, sym)
252b5132 7538 bfd *abfd;
5f771d47 7539 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 7540 Elf_Internal_Rela *rel;
7541 struct elf_link_hash_entry *h;
7542 Elf_Internal_Sym *sym;
7543{
7544 /* ??? Do mips16 stub sections need to be handled special? */
7545
7546 if (h != NULL)
7547 {
7548 switch (ELF32_R_TYPE (rel->r_info))
7549 {
7550 case R_MIPS_GNU_VTINHERIT:
7551 case R_MIPS_GNU_VTENTRY:
7552 break;
7553
7554 default:
7555 switch (h->root.type)
7556 {
7557 case bfd_link_hash_defined:
7558 case bfd_link_hash_defweak:
7559 return h->root.u.def.section;
7560
7561 case bfd_link_hash_common:
7562 return h->root.u.c.p->section;
7563
7564 default:
7565 break;
7566 }
7567 }
7568 }
7569 else
7570 {
7571 if (!(elf_bad_symtab (abfd)
7572 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7573 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
7574 && sym->st_shndx != SHN_COMMON))
7575 {
7576 return bfd_section_from_elf_index (abfd, sym->st_shndx);
7577 }
7578 }
7579
7580 return NULL;
7581}
7582
7583/* Update the got entry reference counts for the section being removed. */
7584
103186c6
MM		 7585boolean
7586_bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
5f771d47
ILT		 7587 bfd *abfd ATTRIBUTE_UNUSED;
7588 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7589 asection *sec ATTRIBUTE_UNUSED;
7590 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
252b5132
RH		 7591{
7592#if 0
7593 Elf_Internal_Shdr *symtab_hdr;
7594 struct elf_link_hash_entry **sym_hashes;
7595 bfd_signed_vma *local_got_refcounts;
7596 const Elf_Internal_Rela *rel, *relend;
7597 unsigned long r_symndx;
7598 struct elf_link_hash_entry *h;
7599
7600 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7601 sym_hashes = elf_sym_hashes (abfd);
7602 local_got_refcounts = elf_local_got_refcounts (abfd);
7603
7604 relend = relocs + sec->reloc_count;
7605 for (rel = relocs; rel < relend; rel++)
7606 switch (ELF32_R_TYPE (rel->r_info))
7607 {
7608 case R_MIPS_GOT16:
7609 case R_MIPS_CALL16:
7610 case R_MIPS_CALL_HI16:
7611 case R_MIPS_CALL_LO16:
7612 case R_MIPS_GOT_HI16:
7613 case R_MIPS_GOT_LO16:
7614 /* ??? It would seem that the existing MIPS code does no sort
7615 of reference counting or whatnot on its GOT and PLT entries,
7616 so it is not possible to garbage collect them at this time. */
7617 break;
7618
7619 default:
7620 break;
7621 }
7622#endif
7623
7624 return true;
7625}
7626
7627
7628/* Adjust a symbol defined by a dynamic object and referenced by a
7629 regular object. The current definition is in some section of the
7630 dynamic object, but we're not including those sections. We have to
7631 change the definition to something the rest of the link can
7632 understand. */
7633
103186c6
MM		 7634boolean
7635_bfd_mips_elf_adjust_dynamic_symbol (info, h)
252b5132
RH		 7636 struct bfd_link_info *info;
7637 struct elf_link_hash_entry *h;
7638{
7639 bfd *dynobj;
7640 struct mips_elf_link_hash_entry *hmips;
7641 asection *s;
7642
7643 dynobj = elf_hash_table (info)->dynobj;
7644
7645 /* Make sure we know what is going on here. */
7646 BFD_ASSERT (dynobj != NULL
7647 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
7648 || h->weakdef != NULL
7649 || ((h->elf_link_hash_flags
7650 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
7651 && (h->elf_link_hash_flags
7652 & ELF_LINK_HASH_REF_REGULAR) != 0
7653 && (h->elf_link_hash_flags
7654 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
7655
7656 /* If this symbol is defined in a dynamic object, we need to copy
7657 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7658 file. */
7659 hmips = (struct mips_elf_link_hash_entry *) h;
7660 if (! info->relocateable
a3c7651d 7661 && hmips->possibly_dynamic_relocs != 0
252b5132 7662 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
a3c7651d
MM		 7663 mips_elf_allocate_dynamic_relocations (dynobj,
7664 hmips->possibly_dynamic_relocs);
252b5132
RH		 7665
7666 /* For a function, create a stub, if needed. */
7667 if (h->type == STT_FUNC
7668 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
7669 {
7670 if (! elf_hash_table (info)->dynamic_sections_created)
7671 return true;
7672
7673 /* If this symbol is not defined in a regular file, then set
7674 the symbol to the stub location. This is required to make
7675 function pointers compare as equal between the normal
7676 executable and the shared library. */
7677 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
7678 {
7679 /* We need .stub section. */
303f629d
MM		 7680 s = bfd_get_section_by_name (dynobj,
7681 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 7682 BFD_ASSERT (s != NULL);
7683
7684 h->root.u.def.section = s;
7685 h->root.u.def.value = s->_raw_size;
7686
7687 /* XXX Write this stub address somewhere. */
7688 h->plt.offset = s->_raw_size;
7689
7690 /* Make room for this stub code. */
7691 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
7692
7693 /* The last half word of the stub will be filled with the index
7694 of this symbol in .dynsym section. */
7695 return true;
7696 }
7697 }
7698
7699 /* If this is a weak symbol, and there is a real definition, the
7700 processor independent code will have arranged for us to see the
7701 real definition first, and we can just use the same value. */
7702 if (h->weakdef != NULL)
7703 {
7704 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
7705 || h->weakdef->root.type == bfd_link_hash_defweak);
7706 h->root.u.def.section = h->weakdef->root.u.def.section;
7707 h->root.u.def.value = h->weakdef->root.u.def.value;
7708 return true;
7709 }
7710
7711 /* This is a reference to a symbol defined by a dynamic object which
7712 is not a function. */
7713
7714 return true;
7715}
7716
7717/* This function is called after all the input files have been read,
7718 and the input sections have been assigned to output sections. We
7719 check for any mips16 stub sections that we can discard. */
7720
7721static boolean mips_elf_check_mips16_stubs
7722 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
7723
103186c6
MM		 7724boolean
7725_bfd_mips_elf_always_size_sections (output_bfd, info)
252b5132
RH		 7726 bfd *output_bfd;
7727 struct bfd_link_info *info;
7728{
7729 asection *ri;
7730
7731 /* The .reginfo section has a fixed size. */
7732 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
7733 if (ri != NULL)
7734 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
7735
7736 if (info->relocateable
7737 || ! mips_elf_hash_table (info)->mips16_stubs_seen)
7738 return true;
7739
7740 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
7741 mips_elf_check_mips16_stubs,
7742 (PTR) NULL);
7743
7744 return true;
7745}
7746
7747/* Check the mips16 stubs for a particular symbol, and see if we can
7748 discard them. */
7749
7750/*ARGSUSED*/
7751static boolean
7752mips_elf_check_mips16_stubs (h, data)
7753 struct mips_elf_link_hash_entry *h;
5f771d47 7754 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 7755{
7756 if (h->fn_stub != NULL
7757 && ! h->need_fn_stub)
7758 {
7759 /* We don't need the fn_stub; the only references to this symbol
7760 are 16 bit calls. Clobber the size to 0 to prevent it from
7761 being included in the link. */
7762 h->fn_stub->_raw_size = 0;
7763 h->fn_stub->_cooked_size = 0;
7764 h->fn_stub->flags &= ~ SEC_RELOC;
7765 h->fn_stub->reloc_count = 0;
7766 h->fn_stub->flags |= SEC_EXCLUDE;
7767 }
7768
7769 if (h->call_stub != NULL
7770 && h->root.other == STO_MIPS16)
7771 {
7772 /* We don't need the call_stub; this is a 16 bit function, so
7773 calls from other 16 bit functions are OK. Clobber the size
7774 to 0 to prevent it from being included in the link. */
7775 h->call_stub->_raw_size = 0;
7776 h->call_stub->_cooked_size = 0;
7777 h->call_stub->flags &= ~ SEC_RELOC;
7778 h->call_stub->reloc_count = 0;
7779 h->call_stub->flags |= SEC_EXCLUDE;
7780 }
7781
7782 if (h->call_fp_stub != NULL
7783 && h->root.other == STO_MIPS16)
7784 {
7785 /* We don't need the call_stub; this is a 16 bit function, so
7786 calls from other 16 bit functions are OK. Clobber the size
7787 to 0 to prevent it from being included in the link. */
7788 h->call_fp_stub->_raw_size = 0;
7789 h->call_fp_stub->_cooked_size = 0;
7790 h->call_fp_stub->flags &= ~ SEC_RELOC;
7791 h->call_fp_stub->reloc_count = 0;
7792 h->call_fp_stub->flags |= SEC_EXCLUDE;
7793 }
7794
7795 return true;
7796}
7797
7798/* Set the sizes of the dynamic sections. */
7799
103186c6
MM		 7800boolean
7801_bfd_mips_elf_size_dynamic_sections (output_bfd, info)
252b5132
RH		 7802 bfd *output_bfd;
7803 struct bfd_link_info *info;
7804{
7805 bfd *dynobj;
7806 asection *s;
7807 boolean reltext;
7a12753d 7808 struct mips_got_info *g = NULL;
252b5132
RH		 7809
7810 dynobj = elf_hash_table (info)->dynobj;
7811 BFD_ASSERT (dynobj != NULL);
7812
7813 if (elf_hash_table (info)->dynamic_sections_created)
7814 {
7815 /* Set the contents of the .interp section to the interpreter. */
7816 if (! info->shared)
7817 {
7818 s = bfd_get_section_by_name (dynobj, ".interp");
7819 BFD_ASSERT (s != NULL);
303f629d
MM		 7820 s->_raw_size
7821 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
7822 s->contents
7403cb63 7823 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
252b5132
RH		 7824 }
7825 }
7826
252b5132
RH		 7827 /* The check_relocs and adjust_dynamic_symbol entry points have
7828 determined the sizes of the various dynamic sections. Allocate
7829 memory for them. */
7830 reltext = false;
7831 for (s = dynobj->sections; s != NULL; s = s->next)
7832 {
7833 const char *name;
7834 boolean strip;
7835
7836 /* It's OK to base decisions on the section name, because none
7837 of the dynobj section names depend upon the input files. */
7838 name = bfd_get_section_name (dynobj, s);
7839
7840 if ((s->flags & SEC_LINKER_CREATED) == 0)
7841 continue;
7842
7843 strip = false;
7844
7845 if (strncmp (name, ".rel", 4) == 0)
7846 {
7847 if (s->_raw_size == 0)
7848 {
7849 /* We only strip the section if the output section name
7850 has the same name. Otherwise, there might be several
7851 input sections for this output section. FIXME: This
7852 code is probably not needed these days anyhow, since
7853 the linker now does not create empty output sections. */
7854 if (s->output_section != NULL
7855 && strcmp (name,
7856 bfd_get_section_name (s->output_section->owner,
7857 s->output_section)) == 0)
7858 strip = true;
7859 }
7860 else
7861 {
7862 const char *outname;
7863 asection *target;
7864
7865 /* If this relocation section applies to a read only
7866 section, then we probably need a DT_TEXTREL entry.
7867 If the relocation section is .rel.dyn, we always
7868 assert a DT_TEXTREL entry rather than testing whether
7869 there exists a relocation to a read only section or
7870 not. */
7871 outname = bfd_get_section_name (output_bfd,
7872 s->output_section);
7873 target = bfd_get_section_by_name (output_bfd, outname + 4);
7874 if ((target != NULL
7875 && (target->flags & SEC_READONLY) != 0
7876 && (target->flags & SEC_ALLOC) != 0)
103186c6
MM		 7877 || strcmp (outname,
7878 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) == 0)
252b5132
RH		 7879 reltext = true;
7880
7881 /* We use the reloc_count field as a counter if we need
7882 to copy relocs into the output file. */
103186c6
MM		 7883 if (strcmp (name,
7884 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) != 0)
252b5132
RH		 7885 s->reloc_count = 0;
7886 }
7887 }
7888 else if (strncmp (name, ".got", 4) == 0)
7889 {
7890 int i;
7403cb63
MM		 7891 bfd_size_type loadable_size = 0;
7892 bfd_size_type local_gotno;
7893 struct _bfd *sub;
252b5132 7894
7403cb63 7895 BFD_ASSERT (elf_section_data (s) != NULL);
252b5132 7896 g = (struct mips_got_info *) elf_section_data (s)->tdata;
7403cb63
MM		 7897 BFD_ASSERT (g != NULL);
7898
7899 /* Calculate the total loadable size of the output. That
7900 will give us the maximum number of GOT_PAGE entries
7901 required. */
7902 for (sub = info->input_bfds; sub; sub = sub->link_next)
7903 {
7904 asection *subsection;
7905
7906 for (subsection = sub->sections;
7907 subsection;
7908 subsection = subsection->next)
7909 {
7910 if ((subsection->flags & SEC_ALLOC) == 0)
7911 continue;
7912 loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
7913 }
7914 }
7915 loadable_size += MIPS_FUNCTION_STUB_SIZE;
7916
7917 /* Assume there are two loadable segments consisting of
7918 contiguous sections. Is 5 enough? */
7919 local_gotno = (loadable_size >> 16) + 5;
7920 g->local_gotno += local_gotno;
103186c6 7921 s->_raw_size += local_gotno * MIPS_ELF_GOT_SIZE (dynobj);
7403cb63
MM		 7922
7923 /* There has to be a global GOT entry for every symbol with
7924 a dynamic symbol table index of DT_MIPS_GOTSYM or
7925 higher. Therefore, it make sense to put those symbols
7926 that need GOT entries at the end of the symbol table. We
7927 do that here. */
b3be9b46 7928 if (!mips_elf_sort_hash_table (info, 1))
7403cb63
MM		 7929 return false;
7930
8b237a89
MM		 7931 if (g->global_gotsym != NULL)
7932 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
7933 else
7934 /* If there are no global symbols, or none requiring
7935 relocations, then GLOBAL_GOTSYM will be NULL. */
7936 i = 0;
b3be9b46 7937 g->global_gotno = i;
103186c6 7938 s->_raw_size += i * MIPS_ELF_GOT_SIZE (dynobj);
252b5132 7939 }
303f629d 7940 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
252b5132
RH		 7941 {
7942 /* Irix rld assumes that the function stub isn't at the end
7943 of .text section. So put a dummy. XXX */
7944 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
7945 }
7946 else if (! info->shared
7947 && ! mips_elf_hash_table (info)->use_rld_obj_head
7948 && strncmp (name, ".rld_map", 8) == 0)
7949 {
7950 /* We add a room for __rld_map. It will be filled in by the
7951 rtld to contain a pointer to the _r_debug structure. */
7952 s->_raw_size += 4;
7953 }
7954 else if (SGI_COMPAT (output_bfd)
7955 && strncmp (name, ".compact_rel", 12) == 0)
7956 s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
c6142e5d
MM		 7957 else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (output_bfd))
7958 == 0)
7959 s->_raw_size = (sizeof (Elf32_External_Msym)
7960 * (elf_hash_table (info)->dynsymcount
7961 + bfd_count_sections (output_bfd)));
252b5132
RH		 7962 else if (strncmp (name, ".init", 5) != 0)
7963 {
7964 /* It's not one of our sections, so don't allocate space. */
7965 continue;
7966 }
7967
7968 if (strip)
7969 {
7970 _bfd_strip_section_from_output (s);
7971 continue;
7972 }
7973
7974 /* Allocate memory for the section contents. */
303f629d 7975 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 7976 if (s->contents == NULL && s->_raw_size != 0)
7977 {
7978 bfd_set_error (bfd_error_no_memory);
7979 return false;
7980 }
252b5132
RH		 7981 }
7982
7983 if (elf_hash_table (info)->dynamic_sections_created)
7984 {
7985 /* Add some entries to the .dynamic section. We fill in the
7986 values later, in elf_mips_finish_dynamic_sections, but we
7987 must add the entries now so that we get the correct size for
7988 the .dynamic section. The DT_DEBUG entry is filled in by the
7989 dynamic linker and used by the debugger. */
7990 if (! info->shared)
7991 {
7992 if (SGI_COMPAT (output_bfd))
7993 {
7994 /* SGI object has the equivalence of DT_DEBUG in the
7995 DT_MIPS_RLD_MAP entry. */
103186c6 7996 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
252b5132
RH		 7997 return false;
7998 }
7999 else
103186c6 8000 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
252b5132
RH		 8001 return false;
8002 }
8003
8004 if (reltext)
8005 {
103186c6 8006 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
252b5132
RH		 8007 return false;
8008 }
8009
103186c6 8010 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
252b5132
RH		 8011 return false;
8012
103186c6
MM		 8013 if (bfd_get_section_by_name (dynobj,
8014 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)))
252b5132 8015 {
103186c6 8016 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
252b5132
RH		 8017 return false;
8018
103186c6 8019 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
252b5132
RH		 8020 return false;
8021
103186c6 8022 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
252b5132
RH		 8023 return false;
8024 }
8025
103186c6 8026 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
252b5132
RH		 8027 return false;
8028
103186c6 8029 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
252b5132
RH		 8030 return false;
8031
8032 if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
8033 {
103186c6 8034 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
252b5132
RH		 8035 return false;
8036
8037 s = bfd_get_section_by_name (dynobj, ".liblist");
8038 BFD_ASSERT (s != NULL);
8039
103186c6 8040 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
252b5132
RH		 8041 return false;
8042 }
8043
103186c6 8044 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
252b5132
RH		 8045 return false;
8046
103186c6 8047 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
252b5132
RH		 8048 return false;
8049
8050#if 0
8051 /* Time stamps in executable files are a bad idea. */
103186c6 8052 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
252b5132
RH		 8053 return false;
8054#endif
8055
8056#if 0 /* FIXME */
103186c6 8057 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
252b5132
RH		 8058 return false;
8059#endif
8060
8061#if 0 /* FIXME */
103186c6 8062 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
252b5132
RH		 8063 return false;
8064#endif
8065
103186c6 8066 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
252b5132
RH		 8067 return false;
8068
103186c6 8069 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
252b5132
RH		 8070 return false;
8071
103186c6 8072 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
252b5132
RH		 8073 return false;
8074
103186c6 8075 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
252b5132
RH		 8076 return false;
8077
7a12753d
MM		 8078 if (g != NULL && g->global_gotsym != NULL
8079 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
252b5132
RH		 8080 return false;
8081
7403cb63 8082 if (IRIX_COMPAT (dynobj) == ict_irix5
103186c6 8083 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
252b5132
RH		 8084 return false;
8085
7403cb63
MM		 8086 if (IRIX_COMPAT (dynobj) == ict_irix6
8087 && (bfd_get_section_by_name
8088 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
103186c6 8089 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
7403cb63 8090 return false;
c6142e5d
MM		 8091
8092 if (bfd_get_section_by_name (dynobj,
8093 MIPS_ELF_MSYM_SECTION_NAME (dynobj))
103186c6 8094 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
c6142e5d 8095 return false;
252b5132
RH		 8096 }
8097
252b5132
RH		 8098 return true;
8099}
8100
7403cb63
MM		 8101/* If NAME is one of the special IRIX6 symbols defined by the linker,
8102 adjust it appropriately now. */
8103
8104static void
8105mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
5f771d47 8106 bfd *abfd ATTRIBUTE_UNUSED;
7403cb63
MM		 8107 const char *name;
8108 Elf_Internal_Sym *sym;
8109{
8110 /* The linker script takes care of providing names and values for
8111 these, but we must place them into the right sections. */
8112 static const char* const text_section_symbols[] = {
8113 "_ftext",
8114 "_etext",
8115 "__dso_displacement",
8116 "__elf_header",
8117 "__program_header_table",
8118 NULL
8119 };
8120
8121 static const char* const data_section_symbols[] = {
8122 "_fdata",
8123 "_edata",
8124 "_end",
8125 "_fbss",
8126 NULL
8127 };
8128
8129 const char* const *p;
8130 int i;
8131
8132 for (i = 0; i < 2; ++i)
8133 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8134 *p;
8135 ++p)
8136 if (strcmp (*p, name) == 0)
8137 {
8138 /* All of these symbols are given type STT_SECTION by the
8139 IRIX6 linker. */
8140 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8141
8142 /* The IRIX linker puts these symbols in special sections. */
8143 if (i == 0)
8144 sym->st_shndx = SHN_MIPS_TEXT;
8145 else
8146 sym->st_shndx = SHN_MIPS_DATA;
8147
8148 break;
8149 }
8150}
8151
252b5132
RH		 8152/* Finish up dynamic symbol handling. We set the contents of various
8153 dynamic sections here. */
8154
103186c6
MM		 8155boolean
8156_bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
252b5132
RH		 8157 bfd *output_bfd;
8158 struct bfd_link_info *info;
8159 struct elf_link_hash_entry *h;
8160 Elf_Internal_Sym *sym;
8161{
8162 bfd *dynobj;
8163 bfd_vma gval;
8164 asection *sgot;
c6142e5d 8165 asection *smsym;
252b5132
RH		 8166 struct mips_got_info *g;
8167 const char *name;
c6142e5d 8168 struct mips_elf_link_hash_entry *mh;
252b5132
RH		 8169
8170 dynobj = elf_hash_table (info)->dynobj;
8171 gval = sym->st_value;
c6142e5d 8172 mh = (struct mips_elf_link_hash_entry *) h;
252b5132
RH		 8173
8174 if (h->plt.offset != (bfd_vma) -1)
8175 {
8176 asection *s;
8177 bfd_byte *p;
8178 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
8179
8180 /* This symbol has a stub. Set it up. */
8181
8182 BFD_ASSERT (h->dynindx != -1);
8183
303f629d
MM		 8184 s = bfd_get_section_by_name (dynobj,
8185 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 8186 BFD_ASSERT (s != NULL);
8187
8188 /* Fill the stub. */
8189 p = stub;
8190 bfd_put_32 (output_bfd, STUB_LW(output_bfd), p);
8191 p += 4;
8192 bfd_put_32 (output_bfd, STUB_MOVE, p);
8193 p += 4;
8194
8195 /* FIXME: Can h->dynindex be more than 64K? */
8196 if (h->dynindx & 0xffff0000)
8197 return false;
8198
8199 bfd_put_32 (output_bfd, STUB_JALR, p);
8200 p += 4;
8201 bfd_put_32 (output_bfd, STUB_LI16 + h->dynindx, p);
8202
8203 BFD_ASSERT (h->plt.offset <= s->_raw_size);
8204 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
8205
8206 /* Mark the symbol as undefined. plt.offset != -1 occurs
8207 only for the referenced symbol. */
8208 sym->st_shndx = SHN_UNDEF;
8209
8210 /* The run-time linker uses the st_value field of the symbol
8211 to reset the global offset table entry for this external
8212 to its stub address when unlinking a shared object. */
8213 gval = s->output_section->vma + s->output_offset + h->plt.offset;
8214 sym->st_value = gval;
8215 }
8216
8217 BFD_ASSERT (h->dynindx != -1);
8218
103186c6 8219 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 8220 BFD_ASSERT (sgot != NULL);
8221 BFD_ASSERT (elf_section_data (sgot) != NULL);
8222 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8223 BFD_ASSERT (g != NULL);
8224
7403cb63
MM		 8225 /* Run through the global symbol table, creating GOT entries for all
8226 the symbols that need them. */
8b237a89
MM		 8227 if (g->global_gotsym != NULL
8228 && h->dynindx >= g->global_gotsym->dynindx)
252b5132 8229 {
7403cb63
MM		 8230 bfd_vma offset;
8231 bfd_vma value;
252b5132 8232
7403cb63
MM		 8233 if (sym->st_value)
8234 value = sym->st_value;
8235 else
8236 /* For an entity defined in a shared object, this will be
8237 NULL. (For functions in shared objects for
8238 which we have created stubs, ST_VALUE will be non-NULL.
8239 That's because such the functions are now no longer defined
8240 in a shared object.) */
8241 value = h->root.u.def.value;
8242
8243 offset = mips_elf_global_got_index (dynobj, h);
103186c6 8244 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
252b5132
RH		 8245 }
8246
c6142e5d
MM		 8247 /* Create a .msym entry, if appropriate. */
8248 smsym = bfd_get_section_by_name (dynobj,
8249 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8250 if (smsym)
8251 {
8252 Elf32_Internal_Msym msym;
8253
8254 msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
8255 /* It is undocumented what the `1' indicates, but IRIX6 uses
8256 this value. */
8257 msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
8258 bfd_mips_elf_swap_msym_out
8259 (dynobj, &msym,
8260 ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
8261 }
8262
252b5132
RH		 8263 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8264 name = h->root.root.string;
8265 if (strcmp (name, "_DYNAMIC") == 0
8266 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
8267 sym->st_shndx = SHN_ABS;
8268 else if (strcmp (name, "_DYNAMIC_LINK") == 0)
8269 {
8270 sym->st_shndx = SHN_ABS;
8271 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8272 sym->st_value = 1;
8273 }
8274 else if (SGI_COMPAT (output_bfd))
8275 {
8276 if (strcmp (name, "_gp_disp") == 0)
8277 {
8278 sym->st_shndx = SHN_ABS;
8279 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8280 sym->st_value = elf_gp (output_bfd);
8281 }
8282 else if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8283 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8284 {
8285 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8286 sym->st_other = STO_PROTECTED;
8287 sym->st_value = 0;
8288 sym->st_shndx = SHN_MIPS_DATA;
8289 }
8290 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8291 {
8292 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8293 sym->st_other = STO_PROTECTED;
8294 sym->st_value = mips_elf_hash_table (info)->procedure_count;
8295 sym->st_shndx = SHN_ABS;
8296 }
8297 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8298 {
8299 if (h->type == STT_FUNC)
8300 sym->st_shndx = SHN_MIPS_TEXT;
8301 else if (h->type == STT_OBJECT)
8302 sym->st_shndx = SHN_MIPS_DATA;
8303 }
8304 }
8305
7403cb63
MM		 8306 /* Handle the IRIX6-specific symbols. */
8307 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8308 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8309
252b5132
RH		 8310 if (SGI_COMPAT (output_bfd)
8311 && ! info->shared)
8312 {
8313 if (! mips_elf_hash_table (info)->use_rld_obj_head
8314 && strcmp (name, "__rld_map") == 0)
8315 {
8316 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8317 BFD_ASSERT (s != NULL);
8318 sym->st_value = s->output_section->vma + s->output_offset;
8319 bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
8320 if (mips_elf_hash_table (info)->rld_value == 0)
8321 mips_elf_hash_table (info)->rld_value = sym->st_value;
8322 }
8323 else if (mips_elf_hash_table (info)->use_rld_obj_head
8324 && strcmp (name, "__rld_obj_head") == 0)
8325 {
303f629d
MM		 8326 /* IRIX6 does not use a .rld_map section. */
8327 if (IRIX_COMPAT (output_bfd) == ict_irix5)
8328 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8329 != NULL);
252b5132
RH		 8330 mips_elf_hash_table (info)->rld_value = sym->st_value;
8331 }
8332 }
8333
8334 /* If this is a mips16 symbol, force the value to be even. */
8335 if (sym->st_other == STO_MIPS16
8336 && (sym->st_value & 1) != 0)
8337 --sym->st_value;
8338
8339 return true;
8340}
8341
8342/* Finish up the dynamic sections. */
8343
103186c6
MM		 8344boolean
8345_bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
252b5132
RH		 8346 bfd *output_bfd;
8347 struct bfd_link_info *info;
8348{
8349 bfd *dynobj;
8350 asection *sdyn;
8351 asection *sgot;
8352 struct mips_got_info *g;
8353
8354 dynobj = elf_hash_table (info)->dynobj;
8355
8356 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8357
103186c6 8358 sgot = mips_elf_got_section (dynobj);
252b5132
RH		 8359 if (sgot == NULL)
8360 g = NULL;
8361 else
8362 {
8363 BFD_ASSERT (elf_section_data (sgot) != NULL);
8364 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8365 BFD_ASSERT (g != NULL);
8366 }
8367
8368 if (elf_hash_table (info)->dynamic_sections_created)
8369 {
103186c6 8370 bfd_byte *b;
252b5132
RH		 8371
8372 BFD_ASSERT (sdyn != NULL);
8373 BFD_ASSERT (g != NULL);
8374
103186c6
MM		 8375 for (b = sdyn->contents;
8376 b < sdyn->contents + sdyn->_raw_size;
8377 b += MIPS_ELF_DYN_SIZE (dynobj))
252b5132
RH		 8378 {
8379 Elf_Internal_Dyn dyn;
8380 const char *name;
8381 size_t elemsize;
8382 asection *s;
103186c6 8383 boolean swap_out_p;
252b5132 8384
103186c6
MM		 8385 /* Read in the current dynamic entry. */
8386 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
8387
8388 /* Assume that we're going to modify it and write it out. */
8389 swap_out_p = true;
252b5132
RH		 8390
8391 switch (dyn.d_tag)
8392 {
252b5132 8393 case DT_RELENT:
103186c6
MM		 8394 s = (bfd_get_section_by_name
8395 (dynobj,
8396 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)));
252b5132 8397 BFD_ASSERT (s != NULL);
103186c6 8398 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
252b5132
RH		 8399 break;
8400
8401 case DT_STRSZ:
8402 /* Rewrite DT_STRSZ. */
8403 dyn.d_un.d_val =
8404 _bfd_stringtab_size (elf_hash_table (info)->dynstr);
252b5132
RH		 8405 break;
8406
8407 case DT_PLTGOT:
8408 name = ".got";
8409 goto get_vma;
8410 case DT_MIPS_CONFLICT:
8411 name = ".conflict";
8412 goto get_vma;
8413 case DT_MIPS_LIBLIST:
8414 name = ".liblist";
8415 get_vma:
8416 s = bfd_get_section_by_name (output_bfd, name);
8417 BFD_ASSERT (s != NULL);
8418 dyn.d_un.d_ptr = s->vma;
252b5132
RH		 8419 break;
8420
8421 case DT_MIPS_RLD_VERSION:
8422 dyn.d_un.d_val = 1; /* XXX */
252b5132
RH		 8423 break;
8424
8425 case DT_MIPS_FLAGS:
8426 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
252b5132
RH		 8427 break;
8428
8429 case DT_MIPS_CONFLICTNO:
8430 name = ".conflict";
8431 elemsize = sizeof (Elf32_Conflict);
8432 goto set_elemno;
8433
8434 case DT_MIPS_LIBLISTNO:
8435 name = ".liblist";
8436 elemsize = sizeof (Elf32_Lib);
8437 set_elemno:
8438 s = bfd_get_section_by_name (output_bfd, name);
8439 if (s != NULL)
8440 {
8441 if (s->_cooked_size != 0)
8442 dyn.d_un.d_val = s->_cooked_size / elemsize;
8443 else
8444 dyn.d_un.d_val = s->_raw_size / elemsize;
8445 }
8446 else
8447 dyn.d_un.d_val = 0;
252b5132
RH		 8448 break;
8449
8450 case DT_MIPS_TIME_STAMP:
8451 time ((time_t *) &dyn.d_un.d_val);
252b5132
RH		 8452 break;
8453
8454 case DT_MIPS_ICHECKSUM:
8455 /* XXX FIXME: */
103186c6 8456 swap_out_p = false;
252b5132
RH		 8457 break;
8458
8459 case DT_MIPS_IVERSION:
8460 /* XXX FIXME: */
103186c6 8461 swap_out_p = false;
252b5132
RH		 8462 break;
8463
8464 case DT_MIPS_BASE_ADDRESS:
8465 s = output_bfd->sections;
8466 BFD_ASSERT (s != NULL);
8467 dyn.d_un.d_ptr = s->vma & ~(0xffff);
252b5132
RH		 8468 break;
8469
8470 case DT_MIPS_LOCAL_GOTNO:
8471 dyn.d_un.d_val = g->local_gotno;
252b5132
RH		 8472 break;
8473
8474 case DT_MIPS_SYMTABNO:
8475 name = ".dynsym";
103186c6 8476 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
252b5132
RH		 8477 s = bfd_get_section_by_name (output_bfd, name);
8478 BFD_ASSERT (s != NULL);
8479
8480 if (s->_cooked_size != 0)
8481 dyn.d_un.d_val = s->_cooked_size / elemsize;
8482 else
8483 dyn.d_un.d_val = s->_raw_size / elemsize;
252b5132
RH		 8484 break;
8485
8486 case DT_MIPS_UNREFEXTNO:
7403cb63
MM		 8487 /* The index into the dynamic symbol table which is the
8488 entry of the first external symbol that is not
8489 referenced within the same object. */
8490 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
252b5132
RH		 8491 break;
8492
8493 case DT_MIPS_GOTSYM:
7a12753d 8494 dyn.d_un.d_val = g->global_gotsym->dynindx;
252b5132
RH		 8495 break;
8496
8497 case DT_MIPS_HIPAGENO:
8498 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
252b5132
RH		 8499 break;
8500
8501 case DT_MIPS_RLD_MAP:
8502 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
252b5132
RH		 8503 break;
8504
7403cb63
MM		 8505 case DT_MIPS_OPTIONS:
8506 s = (bfd_get_section_by_name
8507 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
8508 dyn.d_un.d_ptr = s->vma;
7403cb63
MM		 8509 break;
8510
c6142e5d
MM		 8511 case DT_MIPS_MSYM:
8512 s = (bfd_get_section_by_name
8513 (output_bfd, MIPS_ELF_MSYM_SECTION_NAME (output_bfd)));
8514 dyn.d_un.d_ptr = s->vma;
103186c6
MM		 8515 break;
8516
8517 default:
8518 swap_out_p = false;
c6142e5d 8519 break;
252b5132 8520 }
103186c6
MM		 8521
8522 if (swap_out_p)
8523 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
8524 (dynobj, &dyn, b);
252b5132
RH		 8525 }
8526 }
8527
8528 /* The first entry of the global offset table will be filled at
8529 runtime. The second entry will be used by some runtime loaders.
8530 This isn't the case of Irix rld. */
8531 if (sgot != NULL && sgot->_raw_size > 0)
8532 {
103186c6
MM		 8533 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
8534 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
8535 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
252b5132
RH		 8536 }
8537
8538 if (sgot != NULL)
103186c6
MM		 8539 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
8540 = MIPS_ELF_GOT_SIZE (output_bfd);
252b5132
RH		 8541
8542 {
c6142e5d 8543 asection *smsym;
252b5132 8544 asection *s;
252b5132
RH		 8545 Elf32_compact_rel cpt;
8546
30b30c21
RH		 8547 /* ??? The section symbols for the output sections were set up in
8548 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8549 symbols. Should we do so? */
252b5132 8550
c6142e5d
MM		 8551 smsym = bfd_get_section_by_name (dynobj,
8552 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
30b30c21 8553 if (smsym != NULL)
252b5132 8554 {
103186c6 8555 Elf32_Internal_Msym msym;
c6142e5d 8556
103186c6
MM		 8557 msym.ms_hash_value = 0;
8558 msym.ms_info = ELF32_MS_INFO (0, 1);
c6142e5d 8559
103186c6
MM		 8560 for (s = output_bfd->sections; s != NULL; s = s->next)
8561 {
30b30c21 8562 long dynindx = elf_section_data (s)->dynindx;
252b5132 8563
30b30c21
RH		 8564 bfd_mips_elf_swap_msym_out
8565 (output_bfd, &msym,
8566 (((Elf32_External_Msym *) smsym->contents)
8567 + dynindx));
8568 }
252b5132
RH		 8569 }
8570
8571 if (SGI_COMPAT (output_bfd))
8572 {
8573 /* Write .compact_rel section out. */
8574 s = bfd_get_section_by_name (dynobj, ".compact_rel");
8575 if (s != NULL)
8576 {
8577 cpt.id1 = 1;
8578 cpt.num = s->reloc_count;
8579 cpt.id2 = 2;
8580 cpt.offset = (s->output_section->filepos
8581 + sizeof (Elf32_External_compact_rel));
8582 cpt.reserved0 = 0;
8583 cpt.reserved1 = 0;
8584 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
8585 ((Elf32_External_compact_rel *)
8586 s->contents));
8587
8588 /* Clean up a dummy stub function entry in .text. */
303f629d
MM		 8589 s = bfd_get_section_by_name (dynobj,
8590 MIPS_ELF_STUB_SECTION_NAME (dynobj));
252b5132
RH		 8591 if (s != NULL)
8592 {
8593 file_ptr dummy_offset;
8594
8595 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
8596 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
8597 memset (s->contents + dummy_offset, 0,
8598 MIPS_FUNCTION_STUB_SIZE);
8599 }
8600 }
8601 }
8602
8603 /* Clean up a first relocation in .rel.dyn. */
103186c6
MM		 8604 s = bfd_get_section_by_name (dynobj,
8605 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
252b5132 8606 if (s != NULL && s->_raw_size > 0)
103186c6 8607 memset (s->contents, 0, MIPS_ELF_REL_SIZE (dynobj));
252b5132
RH		 8608 }
8609
8610 return true;
8611}
8612\f
8613/* This is almost identical to bfd_generic_get_... except that some
8614 MIPS relocations need to be handled specially. Sigh. */
8615
8616static bfd_byte *
8617elf32_mips_get_relocated_section_contents (abfd, link_info, link_order, data,
8618 relocateable, symbols)
8619 bfd *abfd;
8620 struct bfd_link_info *link_info;
8621 struct bfd_link_order *link_order;
8622 bfd_byte *data;
8623 boolean relocateable;
8624 asymbol **symbols;
8625{
8626 /* Get enough memory to hold the stuff */
8627 bfd *input_bfd = link_order->u.indirect.section->owner;
8628 asection *input_section = link_order->u.indirect.section;
8629
8630 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8631 arelent **reloc_vector = NULL;
8632 long reloc_count;
8633
8634 if (reloc_size < 0)
8635 goto error_return;
8636
8637 reloc_vector = (arelent **) bfd_malloc (reloc_size);
8638 if (reloc_vector == NULL && reloc_size != 0)
8639 goto error_return;
8640
8641 /* read in the section */
8642 if (!bfd_get_section_contents (input_bfd,
8643 input_section,
8644 (PTR) data,
8645 0,
8646 input_section->_raw_size))
8647 goto error_return;
8648
8649 /* We're not relaxing the section, so just copy the size info */
8650 input_section->_cooked_size = input_section->_raw_size;
8651 input_section->reloc_done = true;
8652
8653 reloc_count = bfd_canonicalize_reloc (input_bfd,
8654 input_section,
8655 reloc_vector,
8656 symbols);
8657 if (reloc_count < 0)
8658 goto error_return;
8659
8660 if (reloc_count > 0)
8661 {
8662 arelent **parent;
8663 /* for mips */
8664 int gp_found;
8665 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
8666
8667 {
8668 struct bfd_hash_entry *h;
8669 struct bfd_link_hash_entry *lh;
8670 /* Skip all this stuff if we aren't mixing formats. */
8671 if (abfd && input_bfd
8672 && abfd->xvec == input_bfd->xvec)
8673 lh = 0;
8674 else
8675 {
8676 h = bfd_hash_lookup (&link_info->hash->table, "_gp", false, false);
8677 lh = (struct bfd_link_hash_entry *) h;
8678 }
8679 lookup:
8680 if (lh)
8681 {
8682 switch (lh->type)
8683 {
8684 case bfd_link_hash_undefined:
8685 case bfd_link_hash_undefweak:
8686 case bfd_link_hash_common:
8687 gp_found = 0;
8688 break;
8689 case bfd_link_hash_defined:
8690 case bfd_link_hash_defweak:
8691 gp_found = 1;
8692 gp = lh->u.def.value;
8693 break;
8694 case bfd_link_hash_indirect:
8695 case bfd_link_hash_warning:
8696 lh = lh->u.i.link;
8697 /* @@FIXME ignoring warning for now */
8698 goto lookup;
8699 case bfd_link_hash_new:
8700 default:
8701 abort ();
8702 }
8703 }
8704 else
8705 gp_found = 0;
8706 }
8707 /* end mips */
8708 for (parent = reloc_vector; *parent != (arelent *) NULL;
8709 parent++)
8710 {
8711 char *error_message = (char *) NULL;
8712 bfd_reloc_status_type r;
8713
8714 /* Specific to MIPS: Deal with relocation types that require
8715 knowing the gp of the output bfd. */
8716 asymbol *sym = *(*parent)->sym_ptr_ptr;
8717 if (bfd_is_abs_section (sym->section) && abfd)
8718 {
8719 /* The special_function wouldn't get called anyways. */
8720 }
8721 else if (!gp_found)
8722 {
8723 /* The gp isn't there; let the special function code
8724 fall over on its own. */
8725 }
8726 else if ((*parent)->howto->special_function
8727 == _bfd_mips_elf_gprel16_reloc)
8728 {
8729 /* bypass special_function call */
8730 r = gprel16_with_gp (input_bfd, sym, *parent, input_section,
8731 relocateable, (PTR) data, gp);
8732 goto skip_bfd_perform_relocation;
8733 }
8734 /* end mips specific stuff */
8735
8736 r = bfd_perform_relocation (input_bfd,
8737 *parent,
8738 (PTR) data,
8739 input_section,
8740 relocateable ? abfd : (bfd *) NULL,
8741 &error_message);
8742 skip_bfd_perform_relocation:
8743
8744 if (relocateable)
8745 {
8746 asection *os = input_section->output_section;
8747
8748 /* A partial link, so keep the relocs */
8749 os->orelocation[os->reloc_count] = *parent;
8750 os->reloc_count++;
8751 }
8752
8753 if (r != bfd_reloc_ok)
8754 {
8755 switch (r)
8756 {
8757 case bfd_reloc_undefined:
8758 if (!((*link_info->callbacks->undefined_symbol)
8759 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8760 input_bfd, input_section, (*parent)->address)))
8761 goto error_return;
8762 break;
8763 case bfd_reloc_dangerous:
8764 BFD_ASSERT (error_message != (char *) NULL);
8765 if (!((*link_info->callbacks->reloc_dangerous)
8766 (link_info, error_message, input_bfd, input_section,
8767 (*parent)->address)))
8768 goto error_return;
8769 break;
8770 case bfd_reloc_overflow:
8771 if (!((*link_info->callbacks->reloc_overflow)
8772 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8773 (*parent)->howto->name, (*parent)->addend,
8774 input_bfd, input_section, (*parent)->address)))
8775 goto error_return;
8776 break;
8777 case bfd_reloc_outofrange:
8778 default:
8779 abort ();
8780 break;
8781 }
8782
8783 }
8784 }
8785 }
8786 if (reloc_vector != NULL)
8787 free (reloc_vector);
8788 return data;
8789
8790error_return:
8791 if (reloc_vector != NULL)
8792 free (reloc_vector);
8793 return NULL;
8794}
8795#define bfd_elf32_bfd_get_relocated_section_contents \
8796 elf32_mips_get_relocated_section_contents
8797\f
8798/* ECOFF swapping routines. These are used when dealing with the
8799 .mdebug section, which is in the ECOFF debugging format. */
8800static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap =
8801{
8802 /* Symbol table magic number. */
8803 magicSym,
8804 /* Alignment of debugging information. E.g., 4. */
8805 4,
8806 /* Sizes of external symbolic information. */
8807 sizeof (struct hdr_ext),
8808 sizeof (struct dnr_ext),
8809 sizeof (struct pdr_ext),
8810 sizeof (struct sym_ext),
8811 sizeof (struct opt_ext),
8812 sizeof (struct fdr_ext),
8813 sizeof (struct rfd_ext),
8814 sizeof (struct ext_ext),
8815 /* Functions to swap in external symbolic data. */
8816 ecoff_swap_hdr_in,
8817 ecoff_swap_dnr_in,
8818 ecoff_swap_pdr_in,
8819 ecoff_swap_sym_in,
8820 ecoff_swap_opt_in,
8821 ecoff_swap_fdr_in,
8822 ecoff_swap_rfd_in,
8823 ecoff_swap_ext_in,
8824 _bfd_ecoff_swap_tir_in,
8825 _bfd_ecoff_swap_rndx_in,
8826 /* Functions to swap out external symbolic data. */
8827 ecoff_swap_hdr_out,
8828 ecoff_swap_dnr_out,
8829 ecoff_swap_pdr_out,
8830 ecoff_swap_sym_out,
8831 ecoff_swap_opt_out,
8832 ecoff_swap_fdr_out,
8833 ecoff_swap_rfd_out,
8834 ecoff_swap_ext_out,
8835 _bfd_ecoff_swap_tir_out,
8836 _bfd_ecoff_swap_rndx_out,
8837 /* Function to read in symbolic data. */
8838 _bfd_mips_elf_read_ecoff_info
8839};
8840\f
8841#define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
8842#define TARGET_LITTLE_NAME "elf32-littlemips"
8843#define TARGET_BIG_SYM bfd_elf32_bigmips_vec
8844#define TARGET_BIG_NAME "elf32-bigmips"
8845#define ELF_ARCH bfd_arch_mips
8846#define ELF_MACHINE_CODE EM_MIPS
8847
8848/* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
8849 a value of 0x1000, and we are compatible. */
8850#define ELF_MAXPAGESIZE 0x1000
8851
8852#define elf_backend_collect true
8853#define elf_backend_type_change_ok true
8854#define elf_backend_can_gc_sections true
3f830999 8855#define elf_info_to_howto mips_info_to_howto_rela
252b5132
RH		 8856#define elf_info_to_howto_rel mips_info_to_howto_rel
8857#define elf_backend_sym_is_global mips_elf_sym_is_global
103186c6
MM		 8858#define elf_backend_object_p _bfd_mips_elf_object_p
8859#define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
252b5132
RH		 8860#define elf_backend_fake_sections _bfd_mips_elf_fake_sections
8861#define elf_backend_section_from_bfd_section \
8862 _bfd_mips_elf_section_from_bfd_section
103186c6 8863#define elf_backend_section_processing _bfd_mips_elf_section_processing
252b5132
RH		 8864#define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
8865#define elf_backend_additional_program_headers \
103186c6
MM		 8866 _bfd_mips_elf_additional_program_headers
8867#define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
252b5132
RH		 8868#define elf_backend_final_write_processing \
8869 _bfd_mips_elf_final_write_processing
8870#define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
103186c6
MM		 8871#define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
8872#define elf_backend_create_dynamic_sections \
8873 _bfd_mips_elf_create_dynamic_sections
8874#define elf_backend_check_relocs _bfd_mips_elf_check_relocs
8875#define elf_backend_adjust_dynamic_symbol \
8876 _bfd_mips_elf_adjust_dynamic_symbol
8877#define elf_backend_always_size_sections \
8878 _bfd_mips_elf_always_size_sections
8879#define elf_backend_size_dynamic_sections \
8880 _bfd_mips_elf_size_dynamic_sections
8881#define elf_backend_relocate_section _bfd_mips_elf_relocate_section
8882#define elf_backend_link_output_symbol_hook \
8883 _bfd_mips_elf_link_output_symbol_hook
8884#define elf_backend_finish_dynamic_symbol \
8885 _bfd_mips_elf_finish_dynamic_symbol
8886#define elf_backend_finish_dynamic_sections \
8887 _bfd_mips_elf_finish_dynamic_sections
8888#define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
8889#define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
8890
8891#define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
8892#define elf_backend_plt_header_size 0
252b5132
RH		 8893
8894#define bfd_elf32_bfd_is_local_label_name \
8895 mips_elf_is_local_label_name
8896#define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
8897#define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
8898#define bfd_elf32_bfd_link_hash_table_create \
103186c6
MM		 8899 _bfd_mips_elf_link_hash_table_create
8900#define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
252b5132
RH		 8901#define bfd_elf32_bfd_copy_private_bfd_data \
8902 _bfd_mips_elf_copy_private_bfd_data
8903#define bfd_elf32_bfd_merge_private_bfd_data \
8904 _bfd_mips_elf_merge_private_bfd_data
8905#define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
8906#define bfd_elf32_bfd_print_private_bfd_data \
8907 _bfd_mips_elf_print_private_bfd_data
252b5132 8908#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.411664 seconds and 4 git commands to generate.