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