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