projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* section.c (bfd_section_init): Remove unnecessary initialisations.
[deliverable/binutils-gdb.git] / bfd / elf64-mips.c
1 /* MIPS-specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Ian Lance Taylor, Cygnus Support
5 Linker support added by Mark Mitchell, CodeSourcery, LLC.
6 <mark@codesourcery.com>
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23
24 /* This file supports the 64-bit MIPS ELF ABI.
25
26 The MIPS 64-bit ELF ABI uses an unusual reloc format. This file
27 overrides the usual ELF reloc handling, and handles reading and
28 writing the relocations here. */
29
30 /* TODO: Many things are unsupported, even if there is some code for it
31 . (which was mostly stolen from elf32-mips.c and slightly adapted).
32 .
33 . - Relocation handling for REL relocs is wrong in many cases and
34 . generally untested.
35 . - Relocation handling for RELA relocs related to GOT support are
36 . also likely to be wrong.
37 . - Support for MIPS16 is only partially implemented.
38 . - Embedded PIC is only partially implemented (is it needed?).
39 . - Combined relocs with RSS_* entries are unsupported.
40 . - The whole GOT handling for NewABI is missing, some parts of
41 . the OldABI version is still lying around and shold be removed.
42 */
43
44 #include "bfd.h"
45 #include "sysdep.h"
46 #include "libbfd.h"
47 #include "aout/ar.h"
48 #include "bfdlink.h"
49 #include "genlink.h"
50 #include "elf-bfd.h"
51 #include "elf/mips.h"
52
53 /* Get the ECOFF swapping routines. The 64-bit ABI is not supposed to
54 use ECOFF. However, we support it anyhow for an easier changeover. */
55 #include "coff/sym.h"
56 #include "coff/symconst.h"
57 #include "coff/internal.h"
58 #include "coff/ecoff.h"
59 /* The 64 bit versions of the mdebug data structures are in alpha.h. */
60 #include "coff/alpha.h"
61 #define ECOFF_SIGNED_64
62 #include "ecoffswap.h"
63
64 struct mips_elf64_link_hash_entry;
65
66 static void mips_elf64_swap_reloc_in
67 PARAMS ((bfd *, const Elf64_Mips_External_Rel *,
68 Elf64_Mips_Internal_Rel *));
69 static void mips_elf64_swap_reloca_in
70 PARAMS ((bfd *, const Elf64_Mips_External_Rela *,
71 Elf64_Mips_Internal_Rela *));
72 static void mips_elf64_swap_reloc_out
73 PARAMS ((bfd *, const Elf64_Mips_Internal_Rel *,
74 Elf64_Mips_External_Rel *));
75 static void mips_elf64_swap_reloca_out
76 PARAMS ((bfd *, const Elf64_Mips_Internal_Rela *,
77 Elf64_Mips_External_Rela *));
78 static void mips_elf64_be_swap_reloc_in
79 PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rel *));
80 static void mips_elf64_be_swap_reloc_out
81 PARAMS ((bfd *, const Elf_Internal_Rel *, bfd_byte *));
82 static void mips_elf64_be_swap_reloca_in
83 PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
84 static void mips_elf64_be_swap_reloca_out
85 PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
86 static bfd_vma mips_elf64_high PARAMS ((bfd_vma));
87 static bfd_vma mips_elf64_higher PARAMS ((bfd_vma));
88 static bfd_vma mips_elf64_highest PARAMS ((bfd_vma));
89 static reloc_howto_type *mips_elf64_reloc_type_lookup
90 PARAMS ((bfd *, bfd_reloc_code_real_type));
91 static void mips_elf64_info_to_howto_rel
92 PARAMS ((bfd *, arelent *, Elf64_Internal_Rel *));
93 static void mips_elf64_info_to_howto_rela
94 PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
95 static long mips_elf64_get_reloc_upper_bound PARAMS ((bfd *, asection *));
96 static boolean mips_elf64_slurp_one_reloc_table
97 PARAMS ((bfd *, asection *, asymbol **, const Elf_Internal_Shdr *));
98 static boolean mips_elf64_slurp_reloc_table
99 PARAMS ((bfd *, asection *, asymbol **, boolean));
100 static void mips_elf64_write_relocs PARAMS ((bfd *, asection *, PTR));
101 static void mips_elf64_write_rel
102 PARAMS((bfd *, asection *, Elf_Internal_Shdr *, int *, PTR));
103 static void mips_elf64_write_rela
104 PARAMS((bfd *, asection *, Elf_Internal_Shdr *, int *, PTR));
105 static struct bfd_hash_entry *mips_elf64_link_hash_newfunc
106 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
107 static bfd_reloc_status_type mips_elf64_hi16_reloc
108 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
109 static bfd_reloc_status_type mips_elf64_higher_reloc
110 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
111 static bfd_reloc_status_type mips_elf64_highest_reloc
112 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
113 static bfd_reloc_status_type mips_elf64_gprel16_reloc
114 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
115 static bfd_reloc_status_type mips_elf64_gprel16_reloca
116 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
117 static bfd_reloc_status_type mips_elf64_literal_reloc
118 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
119 static bfd_reloc_status_type mips_elf64_gprel32_reloc
120 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
121 static bfd_reloc_status_type mips_elf64_shift6_reloc
122 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
123 static bfd_reloc_status_type mips_elf64_got16_reloc
124 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
125 static boolean mips_elf64_assign_gp PARAMS ((bfd *, bfd_vma *));
126 static bfd_reloc_status_type mips_elf64_final_gp
127 PARAMS ((bfd *, asymbol *, boolean, char **, bfd_vma *));
128 static bfd_reloc_status_type gprel16_with_gp
129 PARAMS ((bfd *, asymbol *, arelent *, asection *, boolean, PTR, bfd_vma));
130 static int mips_elf64_additional_program_headers PARAMS ((bfd *));
131 static struct bfd_link_hash_table *mips_elf64_link_hash_table_create
132 PARAMS((bfd *));
133 static bfd_vma mips_elf64_got_offset_from_index
134 PARAMS ((bfd *, bfd *, bfd_vma));
135 static struct mips_elf64_got_info *_mips_elf64_got_info
136 PARAMS ((bfd *, asection **));
137 static bfd_vma mips_elf64_sign_extend PARAMS ((bfd_vma, int));
138 static boolean mips_elf64_overflow_p PARAMS ((bfd_vma, int));
139 static bfd_vma mips_elf64_global_got_index
140 PARAMS ((bfd *, struct elf_link_hash_entry *));
141 static boolean mips_elf64_sort_hash_table_f
142 PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
143 static boolean mips_elf64_sort_hash_table
144 PARAMS ((struct bfd_link_info *, unsigned long));
145 static void mips_elf64_swap_msym_out
146 PARAMS ((bfd *, const Elf32_Internal_Msym *, Elf32_External_Msym *));
147 static bfd_vma mips_elf64_create_local_got_entry
148 PARAMS ((bfd *abfd, struct mips_elf64_got_info *, asection *,
149 bfd_vma value));
150 static bfd_vma mips_elf64_local_got_index
151 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma));
152 static bfd_vma mips_elf64_got_page
153 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *));
154 static bfd_vma mips_elf64_got16_entry
155 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, boolean));
156 static boolean mips_elf64_local_relocation_p
157 PARAMS ((bfd *, const Elf_Internal_Rela *, asection **, boolean));
158 static const Elf_Internal_Rela *mips_elf64_next_relocation
159 PARAMS ((unsigned int, const Elf_Internal_Rela *,
160 const Elf_Internal_Rela *));
161 static boolean mips_elf64_create_dynamic_relocation
162 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
163 struct mips_elf64_link_hash_entry *, asection *, bfd_vma,
164 bfd_vma *, asection *));
165 static bfd_reloc_status_type mips_elf64_calculate_relocation
166 PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
167 const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
168 Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
169 boolean *));
170 static bfd_vma mips_elf64_obtain_contents
171 PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
172 static boolean mips_elf64_perform_relocation
173 PARAMS ((struct bfd_link_info *, reloc_howto_type *,
174 const Elf_Internal_Rela *, bfd_vma,
175 bfd *, asection *, bfd_byte *, boolean));
176 static boolean mips_elf64_relocate_section
177 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
178 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
179 boolean mips_elf64_create_dynamic_sections
180 PARAMS ((bfd *, struct bfd_link_info *));
181 boolean mips_elf64_adjust_dynamic_symbol
182 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *h));
183 boolean mips_elf64_always_size_sections
184 PARAMS ((bfd *, struct bfd_link_info *));
185 static boolean mips_elf64_check_mips16_stubs
186 PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
187 boolean mips_elf64_size_dynamic_sections
188 PARAMS ((bfd *, struct bfd_link_info *));
189 boolean mips_elf64_finish_dynamic_symbol
190 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
191 Elf_Internal_Sym *));
192 boolean mips_elf64_finish_dynamic_sections
193 PARAMS ((bfd *, struct bfd_link_info *info));
194 asection *mips_elf64_gc_mark_hook
195 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
196 struct elf_link_hash_entry *, Elf_Internal_Sym *));
197 boolean mips_elf64_gc_sweep_hook
198 PARAMS ((bfd *, struct bfd_link_info *, asection *,
199 const Elf_Internal_Rela *));
200 static boolean mips_elf64_create_got_section
201 PARAMS ((bfd *, struct bfd_link_info *));
202 static boolean mips_elf64_record_global_got_symbol
203 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *,
204 struct mips_elf64_got_info *));
205 static asection *mips_elf64_create_msym_section PARAMS((bfd *));
206 static void mips_elf64_allocate_dynamic_relocations
207 PARAMS ((bfd *, unsigned int));
208 static boolean mips_elf64_stub_section_p PARAMS ((bfd *, asection *));
209 boolean mips_elf64_check_relocs
210 PARAMS ((bfd *, struct bfd_link_info *, asection *,
211 const Elf_Internal_Rela *));
212 static boolean mips_elf64_output_extsym
213 PARAMS ((struct mips_elf64_link_hash_entry *, PTR));
214 static void mips_elf64_swap_gptab_in
215 PARAMS ((bfd *, const Elf32_External_gptab *, Elf32_gptab *));
216 static void mips_elf64_swap_gptab_out
217 PARAMS ((bfd *, const Elf32_gptab *, Elf32_External_gptab *));
218 static int gptab_compare PARAMS ((const PTR, const PTR));
219 boolean mips_elf64_final_link PARAMS ((bfd *, struct bfd_link_info *));
220
221 extern const bfd_target bfd_elf64_bigmips_vec;
222 extern const bfd_target bfd_elf64_littlemips_vec;
223
224 static bfd_vma prev_reloc_addend = 0;
225 static bfd_size_type prev_reloc_address = 0;
226
227 /* Whether we are trying to be compatible with IRIX6 (or little endianers
228 which are otherwise IRIX-ABI compliant). */
229 #define SGI_COMPAT(abfd) \
230 ((abfd->xvec == &bfd_elf64_bigmips_vec) \
231 || (abfd->xvec == &bfd_elf64_littlemips_vec) ? true : false)
232
233 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
234 from smaller values. Start with zero, widen, *then* decrement. */
235 #define MINUS_ONE (((bfd_vma)0) - 1)
236
237 /* The number of local .got entries we reserve. */
238 #define MIPS_RESERVED_GOTNO (2)
239
240 /* Instructions which appear in a stub. */
241 #define ELF_MIPS_GP_OFFSET(abfd) 0x7ff0
242 #define STUB_LW 0xdf998010 /* ld t9,0x8010(gp) */
243 #define STUB_MOVE 0x03e07825 /* move t7,ra */
244 #define STUB_JALR 0x0320f809 /* jal t9 */
245 #define STUB_LI16 0x34180000 /* ori t8,zero,0 */
246 #define MIPS_FUNCTION_STUB_SIZE (16)
247
248 /* The relocation table used for SHT_REL sections. */
249
250 #define UNUSED_RELOC(num) { num, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
251
252 static reloc_howto_type mips_elf64_howto_table_rel[] =
253 {
254 /* No relocation. */
255 HOWTO (R_MIPS_NONE, /* type */
256 0, /* rightshift */
257 0, /* size (0 = byte, 1 = short, 2 = long) */
258 0, /* bitsize */
259 false, /* pc_relative */
260 0, /* bitpos */
261 complain_overflow_dont, /* complain_on_overflow */
262 bfd_elf_generic_reloc, /* special_function */
263 "R_MIPS_NONE", /* name */
264 false, /* partial_inplace */
265 0, /* src_mask */
266 0, /* dst_mask */
267 false), /* pcrel_offset */
268
269 /* 16 bit relocation. */
270 HOWTO (R_MIPS_16, /* type */
271 0, /* rightshift */
272 2, /* size (0 = byte, 1 = short, 2 = long) */
273 16, /* bitsize */
274 false, /* pc_relative */
275 0, /* bitpos */
276 complain_overflow_signed, /* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_MIPS_16", /* name */
279 true, /* partial_inplace */
280 0x0000ffff, /* src_mask */
281 0x0000ffff, /* dst_mask */
282 false), /* pcrel_offset */
283
284 /* 32 bit relocation. */
285 HOWTO (R_MIPS_32, /* type */
286 0, /* rightshift */
287 2, /* size (0 = byte, 1 = short, 2 = long) */
288 32, /* bitsize */
289 false, /* pc_relative */
290 0, /* bitpos */
291 complain_overflow_dont, /* complain_on_overflow */
292 bfd_elf_generic_reloc, /* special_function */
293 "R_MIPS_32", /* name */
294 true, /* partial_inplace */
295 0xffffffff, /* src_mask */
296 0xffffffff, /* dst_mask */
297 false), /* pcrel_offset */
298
299 /* 32 bit symbol relative relocation. */
300 HOWTO (R_MIPS_REL32, /* type */
301 0, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 32, /* bitsize */
304 false, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_dont, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_MIPS_REL32", /* name */
309 true, /* partial_inplace */
310 0xffffffff, /* src_mask */
311 0xffffffff, /* dst_mask */
312 false), /* pcrel_offset */
313
314 /* 26 bit jump address. */
315 HOWTO (R_MIPS_26, /* type */
316 2, /* rightshift */
317 2, /* size (0 = byte, 1 = short, 2 = long) */
318 26, /* bitsize */
319 false, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_dont, /* complain_on_overflow */
322 /* This needs complex overflow
323 detection, because the upper 36
324 bits must match the PC + 4. */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_MIPS_26", /* name */
327 true, /* partial_inplace */
328 0x03ffffff, /* src_mask */
329 0x03ffffff, /* dst_mask */
330 false), /* pcrel_offset */
331
332 /* High 16 bits of symbol value. */
333 HOWTO (R_MIPS_HI16, /* type */
334 0, /* rightshift */
335 2, /* size (0 = byte, 1 = short, 2 = long) */
336 16, /* bitsize */
337 false, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_dont, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_MIPS_HI16", /* name */
342 true, /* partial_inplace */
343 0x0000ffff, /* src_mask */
344 0x0000ffff, /* dst_mask */
345 false), /* pcrel_offset */
346
347 /* Low 16 bits of symbol value. */
348 HOWTO (R_MIPS_LO16, /* type */
349 0, /* rightshift */
350 2, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 false, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_dont, /* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_MIPS_LO16", /* name */
357 true, /* partial_inplace */
358 0x0000ffff, /* src_mask */
359 0x0000ffff, /* dst_mask */
360 false), /* pcrel_offset */
361
362 /* GP relative reference. */
363 HOWTO (R_MIPS_GPREL16, /* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 16, /* bitsize */
367 false, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_signed, /* complain_on_overflow */
370 mips_elf64_gprel16_reloc, /* special_function */
371 "R_MIPS_GPREL16", /* name */
372 true, /* partial_inplace */
373 0x0000ffff, /* src_mask */
374 0x0000ffff, /* dst_mask */
375 false), /* pcrel_offset */
376
377 /* Reference to literal section. */
378 HOWTO (R_MIPS_LITERAL, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 16, /* bitsize */
382 false, /* pc_relative */
383 0, /* bitpos */
384 complain_overflow_signed, /* complain_on_overflow */
385 mips_elf64_literal_reloc, /* special_function */
386 "R_MIPS_LITERAL", /* name */
387 true, /* partial_inplace */
388 0x0000ffff, /* src_mask */
389 0x0000ffff, /* dst_mask */
390 false), /* pcrel_offset */
391
392 /* Reference to global offset table. */
393 HOWTO (R_MIPS_GOT16, /* type */
394 0, /* rightshift */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
396 16, /* bitsize */
397 false, /* pc_relative */
398 0, /* bitpos */
399 complain_overflow_signed, /* complain_on_overflow */
400 mips_elf64_got16_reloc, /* special_function */
401 "R_MIPS_GOT16", /* name */
402 true, /* partial_inplace */
403 0x0000ffff, /* src_mask */
404 0x0000ffff, /* dst_mask */
405 false), /* pcrel_offset */
406
407 /* 16 bit PC relative reference. */
408 HOWTO (R_MIPS_PC16, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
412 true, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_signed, /* complain_on_overflow */
415 bfd_elf_generic_reloc, /* special_function */
416 "R_MIPS_PC16", /* name */
417 true, /* partial_inplace */
418 0x0000ffff, /* src_mask */
419 0x0000ffff, /* dst_mask */
420 true), /* pcrel_offset */
421
422 /* 16 bit call through global offset table. */
423 /* FIXME: This is not handled correctly. */
424 HOWTO (R_MIPS_CALL16, /* type */
425 0, /* rightshift */
426 2, /* size (0 = byte, 1 = short, 2 = long) */
427 16, /* bitsize */
428 false, /* pc_relative */
429 0, /* bitpos */
430 complain_overflow_signed, /* complain_on_overflow */
431 bfd_elf_generic_reloc, /* special_function */
432 "R_MIPS_CALL16", /* name */
433 true, /* partial_inplace */
434 0x0000ffff, /* src_mask */
435 0x0000ffff, /* dst_mask */
436 false), /* pcrel_offset */
437
438 /* 32 bit GP relative reference. */
439 HOWTO (R_MIPS_GPREL32, /* type */
440 0, /* rightshift */
441 2, /* size (0 = byte, 1 = short, 2 = long) */
442 32, /* bitsize */
443 false, /* pc_relative */
444 0, /* bitpos */
445 complain_overflow_dont, /* complain_on_overflow */
446 mips_elf64_gprel32_reloc, /* special_function */
447 "R_MIPS_GPREL32", /* name */
448 true, /* partial_inplace */
449 0xffffffff, /* src_mask */
450 0xffffffff, /* dst_mask */
451 false), /* pcrel_offset */
452
453 UNUSED_RELOC (13),
454 UNUSED_RELOC (14),
455 UNUSED_RELOC (15),
456
457 /* A 5 bit shift field. */
458 HOWTO (R_MIPS_SHIFT5, /* type */
459 0, /* rightshift */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
461 5, /* bitsize */
462 false, /* pc_relative */
463 6, /* bitpos */
464 complain_overflow_bitfield, /* complain_on_overflow */
465 bfd_elf_generic_reloc, /* special_function */
466 "R_MIPS_SHIFT5", /* name */
467 true, /* partial_inplace */
468 0x000007c0, /* src_mask */
469 0x000007c0, /* dst_mask */
470 false), /* pcrel_offset */
471
472 /* A 6 bit shift field. */
473 HOWTO (R_MIPS_SHIFT6, /* type */
474 0, /* rightshift */
475 2, /* size (0 = byte, 1 = short, 2 = long) */
476 6, /* bitsize */
477 false, /* pc_relative */
478 6, /* bitpos */
479 complain_overflow_bitfield, /* complain_on_overflow */
480 mips_elf64_shift6_reloc, /* special_function */
481 "R_MIPS_SHIFT6", /* name */
482 true, /* partial_inplace */
483 0x000007c4, /* src_mask */
484 0x000007c4, /* dst_mask */
485 false), /* pcrel_offset */
486
487 /* 64 bit relocation. */
488 HOWTO (R_MIPS_64, /* type */
489 0, /* rightshift */
490 4, /* size (0 = byte, 1 = short, 2 = long) */
491 64, /* bitsize */
492 false, /* pc_relative */
493 0, /* bitpos */
494 complain_overflow_dont, /* complain_on_overflow */
495 bfd_elf_generic_reloc, /* special_function */
496 "R_MIPS_64", /* name */
497 true, /* partial_inplace */
498 MINUS_ONE, /* src_mask */
499 MINUS_ONE, /* dst_mask */
500 false), /* pcrel_offset */
501
502 /* Displacement in the global offset table. */
503 /* FIXME: Not handled correctly. */
504 HOWTO (R_MIPS_GOT_DISP, /* type */
505 0, /* rightshift */
506 2, /* size (0 = byte, 1 = short, 2 = long) */
507 16, /* bitsize */
508 false, /* pc_relative */
509 0, /* bitpos */
510 complain_overflow_signed, /* complain_on_overflow */
511 bfd_elf_generic_reloc, /* special_function */
512 "R_MIPS_GOT_DISP", /* name */
513 true, /* partial_inplace */
514 0x0000ffff, /* src_mask */
515 0x0000ffff, /* dst_mask */
516 false), /* pcrel_offset */
517
518 /* Displacement to page pointer in the global offset table. */
519 /* FIXME: Not handled correctly. */
520 HOWTO (R_MIPS_GOT_PAGE, /* type */
521 0, /* rightshift */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
523 16, /* bitsize */
524 false, /* pc_relative */
525 0, /* bitpos */
526 complain_overflow_signed, /* complain_on_overflow */
527 bfd_elf_generic_reloc, /* special_function */
528 "R_MIPS_GOT_PAGE", /* name */
529 true, /* partial_inplace */
530 0x0000ffff, /* src_mask */
531 0x0000ffff, /* dst_mask */
532 false), /* pcrel_offset */
533
534 /* Offset from page pointer in the global offset table. */
535 /* FIXME: Not handled correctly. */
536 HOWTO (R_MIPS_GOT_OFST, /* type */
537 0, /* rightshift */
538 2, /* size (0 = byte, 1 = short, 2 = long) */
539 16, /* bitsize */
540 false, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_signed, /* complain_on_overflow */
543 bfd_elf_generic_reloc, /* special_function */
544 "R_MIPS_GOT_OFST", /* name */
545 true, /* partial_inplace */
546 0x0000ffff, /* src_mask */
547 0x0000ffff, /* dst_mask */
548 false), /* pcrel_offset */
549
550 /* High 16 bits of displacement in global offset table. */
551 /* FIXME: Not handled correctly. */
552 HOWTO (R_MIPS_GOT_HI16, /* type */
553 0, /* rightshift */
554 2, /* size (0 = byte, 1 = short, 2 = long) */
555 16, /* bitsize */
556 false, /* pc_relative */
557 0, /* bitpos */
558 complain_overflow_dont, /* complain_on_overflow */
559 bfd_elf_generic_reloc, /* special_function */
560 "R_MIPS_GOT_HI16", /* name */
561 true, /* partial_inplace */
562 0x0000ffff, /* src_mask */
563 0x0000ffff, /* dst_mask */
564 false), /* pcrel_offset */
565
566 /* Low 16 bits of displacement in global offset table. */
567 /* FIXME: Not handled correctly. */
568 HOWTO (R_MIPS_GOT_LO16, /* type */
569 0, /* rightshift */
570 2, /* size (0 = byte, 1 = short, 2 = long) */
571 16, /* bitsize */
572 false, /* pc_relative */
573 0, /* bitpos */
574 complain_overflow_dont, /* complain_on_overflow */
575 bfd_elf_generic_reloc, /* special_function */
576 "R_MIPS_GOT_LO16", /* name */
577 true, /* partial_inplace */
578 0x0000ffff, /* src_mask */
579 0x0000ffff, /* dst_mask */
580 false), /* pcrel_offset */
581
582 /* 64 bit substraction. */
583 /* FIXME: Not handled correctly. */
584 HOWTO (R_MIPS_SUB, /* type */
585 0, /* rightshift */
586 4, /* size (0 = byte, 1 = short, 2 = long) */
587 64, /* bitsize */
588 false, /* pc_relative */
589 0, /* bitpos */
590 complain_overflow_dont, /* complain_on_overflow */
591 bfd_elf_generic_reloc, /* special_function */
592 "R_MIPS_SUB", /* name */
593 true, /* partial_inplace */
594 MINUS_ONE, /* src_mask */
595 MINUS_ONE, /* dst_mask */
596 false), /* pcrel_offset */
597
598 /* Insert the addend as an instruction. */
599 /* FIXME: Not handled correctly. */
600 HOWTO (R_MIPS_INSERT_A, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 32, /* bitsize */
604 false, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_dont, /* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_MIPS_INSERT_A", /* name */
609 true, /* partial_inplace */
610 0xffffffff, /* src_mask */
611 0xffffffff, /* dst_mask */
612 false), /* pcrel_offset */
613
614 /* Insert the addend as an instruction, and change all relocations
615 to refer to the old instruction at the address. */
616 /* FIXME: Not handled correctly. */
617 HOWTO (R_MIPS_INSERT_B, /* type */
618 0, /* rightshift */
619 2, /* size (0 = byte, 1 = short, 2 = long) */
620 32, /* bitsize */
621 false, /* pc_relative */
622 0, /* bitpos */
623 complain_overflow_dont, /* complain_on_overflow */
624 bfd_elf_generic_reloc, /* special_function */
625 "R_MIPS_INSERT_B", /* name */
626 true, /* partial_inplace */
627 0xffffffff, /* src_mask */
628 0xffffffff, /* dst_mask */
629 false), /* pcrel_offset */
630
631 /* Delete a 32 bit instruction. */
632 /* FIXME: Not handled correctly. */
633 HOWTO (R_MIPS_DELETE, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 32, /* bitsize */
637 false, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_dont, /* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_MIPS_DELETE", /* name */
642 true, /* partial_inplace */
643 0xffffffff, /* src_mask */
644 0xffffffff, /* dst_mask */
645 false), /* pcrel_offset */
646
647 /* Get the higher value of a 64 bit addend. */
648 HOWTO (R_MIPS_HIGHER, /* type */
649 0, /* rightshift */
650 2, /* size (0 = byte, 1 = short, 2 = long) */
651 16, /* bitsize */
652 false, /* pc_relative */
653 0, /* bitpos */
654 complain_overflow_dont, /* complain_on_overflow */
655 mips_elf64_higher_reloc, /* special_function */
656 "R_MIPS_HIGHER", /* name */
657 true, /* partial_inplace */
658 0x0000ffff, /* src_mask */
659 0x0000ffff, /* dst_mask */
660 false), /* pcrel_offset */
661
662 /* Get the highest value of a 64 bit addend. */
663 HOWTO (R_MIPS_HIGHEST, /* type */
664 0, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 16, /* bitsize */
667 false, /* pc_relative */
668 0, /* bitpos */
669 complain_overflow_dont, /* complain_on_overflow */
670 mips_elf64_highest_reloc, /* special_function */
671 "R_MIPS_HIGHEST", /* name */
672 true, /* partial_inplace */
673 0x0000ffff, /* src_mask */
674 0x0000ffff, /* dst_mask */
675 false), /* pcrel_offset */
676
677 /* High 16 bits of displacement in global offset table. */
678 /* FIXME: Not handled correctly. */
679 HOWTO (R_MIPS_CALL_HI16, /* type */
680 0, /* rightshift */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
682 16, /* bitsize */
683 false, /* pc_relative */
684 0, /* bitpos */
685 complain_overflow_dont, /* complain_on_overflow */
686 bfd_elf_generic_reloc, /* special_function */
687 "R_MIPS_CALL_HI16", /* name */
688 true, /* partial_inplace */
689 0x0000ffff, /* src_mask */
690 0x0000ffff, /* dst_mask */
691 false), /* pcrel_offset */
692
693 /* Low 16 bits of displacement in global offset table. */
694 /* FIXME: Not handled correctly. */
695 HOWTO (R_MIPS_CALL_LO16, /* type */
696 0, /* rightshift */
697 2, /* size (0 = byte, 1 = short, 2 = long) */
698 16, /* bitsize */
699 false, /* pc_relative */
700 0, /* bitpos */
701 complain_overflow_dont, /* complain_on_overflow */
702 bfd_elf_generic_reloc, /* special_function */
703 "R_MIPS_CALL_LO16", /* name */
704 true, /* partial_inplace */
705 0x0000ffff, /* src_mask */
706 0x0000ffff, /* dst_mask */
707 false), /* pcrel_offset */
708
709 /* Section displacement, used by an associated event location section. */
710 /* FIXME: Not handled correctly. */
711 HOWTO (R_MIPS_SCN_DISP, /* type */
712 0, /* rightshift */
713 2, /* size (0 = byte, 1 = short, 2 = long) */
714 32, /* bitsize */
715 false, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_dont, /* complain_on_overflow */
718 bfd_elf_generic_reloc, /* special_function */
719 "R_MIPS_SCN_DISP", /* name */
720 true, /* partial_inplace */
721 0xffffffff, /* src_mask */
722 0xffffffff, /* dst_mask */
723 false), /* pcrel_offset */
724
725 HOWTO (R_MIPS_REL16, /* type */
726 0, /* rightshift */
727 1, /* size (0 = byte, 1 = short, 2 = long) */
728 16, /* bitsize */
729 false, /* pc_relative */
730 0, /* bitpos */
731 complain_overflow_signed, /* complain_on_overflow */
732 bfd_elf_generic_reloc, /* special_function */
733 "R_MIPS_REL16", /* name */
734 true, /* partial_inplace */
735 0xffff, /* src_mask */
736 0xffff, /* dst_mask */
737 false), /* pcrel_offset */
738
739 /* These two are obsolete. */
740 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
741 EMPTY_HOWTO (R_MIPS_PJUMP),
742
743 /* Similiar to R_MIPS_REL32, but used for relocations in a GOT section.
744 It must be used for multigot GOT's (and only there). */
745 HOWTO (R_MIPS_RELGOT, /* type */
746 0, /* rightshift */
747 2, /* size (0 = byte, 1 = short, 2 = long) */
748 32, /* bitsize */
749 false, /* pc_relative */
750 0, /* bitpos */
751 complain_overflow_dont, /* complain_on_overflow */
752 bfd_elf_generic_reloc, /* special_function */
753 "R_MIPS_RELGOT", /* name */
754 true, /* partial_inplace */
755 0xffffffff, /* src_mask */
756 0xffffffff, /* dst_mask */
757 false), /* pcrel_offset */
758
759 /* Protected jump conversion. This is an optimization hint. No
760 relocation is required for correctness. */
761 HOWTO (R_MIPS_JALR, /* type */
762 0, /* rightshift */
763 2, /* size (0 = byte, 1 = short, 2 = long) */
764 32, /* bitsize */
765 false, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 bfd_elf_generic_reloc, /* special_function */
769 "R_MIPS_JALR", /* name */
770 false, /* partial_inplace */
771 0, /* src_mask */
772 0x00000000, /* dst_mask */
773 false), /* pcrel_offset */
774 };
775
776 /* The relocation table used for SHT_RELA sections. */
777
778 static reloc_howto_type mips_elf64_howto_table_rela[] =
779 {
780 /* No relocation. */
781 HOWTO (R_MIPS_NONE, /* type */
782 0, /* rightshift */
783 0, /* size (0 = byte, 1 = short, 2 = long) */
784 0, /* bitsize */
785 false, /* pc_relative */
786 0, /* bitpos */
787 complain_overflow_dont, /* complain_on_overflow */
788 bfd_elf_generic_reloc, /* special_function */
789 "R_MIPS_NONE", /* name */
790 false, /* partial_inplace */
791 0, /* src_mask */
792 0, /* dst_mask */
793 false), /* pcrel_offset */
794
795 /* 16 bit relocation. */
796 HOWTO (R_MIPS_16, /* type */
797 0, /* rightshift */
798 2, /* size (0 = byte, 1 = short, 2 = long) */
799 16, /* bitsize */
800 false, /* pc_relative */
801 0, /* bitpos */
802 complain_overflow_signed, /* complain_on_overflow */
803 bfd_elf_generic_reloc, /* special_function */
804 "R_MIPS_16", /* name */
805 false, /* partial_inplace */
806 0, /* src_mask */
807 0x0000ffff, /* dst_mask */
808 false), /* pcrel_offset */
809
810 /* 32 bit relocation. */
811 HOWTO (R_MIPS_32, /* type */
812 0, /* rightshift */
813 2, /* size (0 = byte, 1 = short, 2 = long) */
814 32, /* bitsize */
815 false, /* pc_relative */
816 0, /* bitpos */
817 complain_overflow_dont, /* complain_on_overflow */
818 bfd_elf_generic_reloc, /* special_function */
819 "R_MIPS_32", /* name */
820 false, /* partial_inplace */
821 0, /* src_mask */
822 0xffffffff, /* dst_mask */
823 false), /* pcrel_offset */
824
825 /* 32 bit symbol relative relocation. */
826 HOWTO (R_MIPS_REL32, /* type */
827 0, /* rightshift */
828 2, /* size (0 = byte, 1 = short, 2 = long) */
829 32, /* bitsize */
830 false, /* pc_relative */
831 0, /* bitpos */
832 complain_overflow_dont, /* complain_on_overflow */
833 bfd_elf_generic_reloc, /* special_function */
834 "R_MIPS_REL32", /* name */
835 false, /* partial_inplace */
836 0, /* src_mask */
837 0xffffffff, /* dst_mask */
838 false), /* pcrel_offset */
839
840 /* 26 bit jump address. */
841 HOWTO (R_MIPS_26, /* type */
842 2, /* rightshift */
843 2, /* size (0 = byte, 1 = short, 2 = long) */
844 26, /* bitsize */
845 false, /* pc_relative */
846 0, /* bitpos */
847 complain_overflow_dont, /* complain_on_overflow */
848 /* This needs complex overflow
849 detection, because the upper 36
850 bits must match the PC + 4. */
851 bfd_elf_generic_reloc, /* special_function */
852 "R_MIPS_26", /* name */
853 false, /* partial_inplace */
854 0, /* src_mask */
855 0x03ffffff, /* dst_mask */
856 false), /* pcrel_offset */
857
858 /* R_MIPS_HI16 and R_MIPS_LO16 are unsupported for 64 bit REL. */
859 /* High 16 bits of symbol value. */
860 HOWTO (R_MIPS_HI16, /* type */
861 0, /* rightshift */
862 2, /* size (0 = byte, 1 = short, 2 = long) */
863 16, /* bitsize */
864 false, /* pc_relative */
865 0, /* bitpos */
866 complain_overflow_dont, /* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "R_MIPS_HI16", /* name */
869 false, /* partial_inplace */
870 0, /* src_mask */
871 0x0000ffff, /* dst_mask */
872 false), /* pcrel_offset */
873
874 /* Low 16 bits of symbol value. */
875 HOWTO (R_MIPS_LO16, /* type */
876 0, /* rightshift */
877 2, /* size (0 = byte, 1 = short, 2 = long) */
878 16, /* bitsize */
879 false, /* pc_relative */
880 0, /* bitpos */
881 complain_overflow_dont, /* complain_on_overflow */
882 bfd_elf_generic_reloc, /* special_function */
883 "R_MIPS_LO16", /* name */
884 false, /* partial_inplace */
885 0, /* src_mask */
886 0x0000ffff, /* dst_mask */
887 false), /* pcrel_offset */
888
889 /* GP relative reference. */
890 HOWTO (R_MIPS_GPREL16, /* type */
891 0, /* rightshift */
892 2, /* size (0 = byte, 1 = short, 2 = long) */
893 16, /* bitsize */
894 false, /* pc_relative */
895 0, /* bitpos */
896 complain_overflow_signed, /* complain_on_overflow */
897 mips_elf64_gprel16_reloca, /* special_function */
898 "R_MIPS_GPREL16", /* name */
899 false, /* partial_inplace */
900 0, /* src_mask */
901 0x0000ffff, /* dst_mask */
902 false), /* pcrel_offset */
903
904 /* Reference to literal section. */
905 HOWTO (R_MIPS_LITERAL, /* type */
906 0, /* rightshift */
907 2, /* size (0 = byte, 1 = short, 2 = long) */
908 16, /* bitsize */
909 false, /* pc_relative */
910 0, /* bitpos */
911 complain_overflow_signed, /* complain_on_overflow */
912 mips_elf64_literal_reloc, /* special_function */
913 "R_MIPS_LITERAL", /* name */
914 false, /* partial_inplace */
915 0, /* src_mask */
916 0x0000ffff, /* dst_mask */
917 false), /* pcrel_offset */
918
919 /* Reference to global offset table. */
920 /* FIXME: This is not handled correctly. */
921 HOWTO (R_MIPS_GOT16, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 16, /* bitsize */
925 false, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_signed, /* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_MIPS_GOT16", /* name */
930 false, /* partial_inplace */
931 0, /* src_mask */
932 0x0000ffff, /* dst_mask */
933 false), /* pcrel_offset */
934
935 /* 16 bit PC relative reference. */
936 HOWTO (R_MIPS_PC16, /* type */
937 0, /* rightshift */
938 2, /* size (0 = byte, 1 = short, 2 = long) */
939 16, /* bitsize */
940 true, /* pc_relative */
941 0, /* bitpos */
942 complain_overflow_signed, /* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "R_MIPS_PC16", /* name */
945 false, /* partial_inplace */
946 0, /* src_mask */
947 0x0000ffff, /* dst_mask */
948 true), /* pcrel_offset */
949
950 /* 16 bit call through global offset table. */
951 /* FIXME: This is not handled correctly. */
952 HOWTO (R_MIPS_CALL16, /* type */
953 0, /* rightshift */
954 2, /* size (0 = byte, 1 = short, 2 = long) */
955 16, /* bitsize */
956 false, /* pc_relative */
957 0, /* bitpos */
958 complain_overflow_signed, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* special_function */
960 "R_MIPS_CALL16", /* name */
961 false, /* partial_inplace */
962 0, /* src_mask */
963 0x0000ffff, /* dst_mask */
964 false), /* pcrel_offset */
965
966 /* 32 bit GP relative reference. */
967 HOWTO (R_MIPS_GPREL32, /* type */
968 0, /* rightshift */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
970 32, /* bitsize */
971 false, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_dont, /* complain_on_overflow */
974 mips_elf64_gprel32_reloc, /* special_function */
975 "R_MIPS_GPREL32", /* name */
976 false, /* partial_inplace */
977 0, /* src_mask */
978 0xffffffff, /* dst_mask */
979 false), /* pcrel_offset */
980
981 UNUSED_RELOC (13),
982 UNUSED_RELOC (14),
983 UNUSED_RELOC (15),
984
985 /* A 5 bit shift field. */
986 HOWTO (R_MIPS_SHIFT5, /* type */
987 0, /* rightshift */
988 2, /* size (0 = byte, 1 = short, 2 = long) */
989 5, /* bitsize */
990 false, /* pc_relative */
991 6, /* bitpos */
992 complain_overflow_bitfield, /* complain_on_overflow */
993 bfd_elf_generic_reloc, /* special_function */
994 "R_MIPS_SHIFT5", /* name */
995 false, /* partial_inplace */
996 0, /* src_mask */
997 0x000007c0, /* dst_mask */
998 false), /* pcrel_offset */
999
1000 /* A 6 bit shift field. */
1001 HOWTO (R_MIPS_SHIFT6, /* type */
1002 0, /* rightshift */
1003 2, /* size (0 = byte, 1 = short, 2 = long) */
1004 6, /* bitsize */
1005 false, /* pc_relative */
1006 6, /* bitpos */
1007 complain_overflow_bitfield, /* complain_on_overflow */
1008 mips_elf64_shift6_reloc, /* special_function */
1009 "R_MIPS_SHIFT6", /* name */
1010 false, /* partial_inplace */
1011 0, /* src_mask */
1012 0x000007c4, /* dst_mask */
1013 false), /* pcrel_offset */
1014
1015 /* 64 bit relocation. */
1016 HOWTO (R_MIPS_64, /* type */
1017 0, /* rightshift */
1018 4, /* size (0 = byte, 1 = short, 2 = long) */
1019 64, /* bitsize */
1020 false, /* pc_relative */
1021 0, /* bitpos */
1022 complain_overflow_dont, /* complain_on_overflow */
1023 bfd_elf_generic_reloc, /* special_function */
1024 "R_MIPS_64", /* name */
1025 false, /* partial_inplace */
1026 0, /* src_mask */
1027 MINUS_ONE, /* dst_mask */
1028 false), /* pcrel_offset */
1029
1030 /* Displacement in the global offset table. */
1031 /* FIXME: Not handled correctly. */
1032 HOWTO (R_MIPS_GOT_DISP, /* type */
1033 0, /* rightshift */
1034 2, /* size (0 = byte, 1 = short, 2 = long) */
1035 16, /* bitsize */
1036 false, /* pc_relative */
1037 0, /* bitpos */
1038 complain_overflow_signed, /* complain_on_overflow */
1039 bfd_elf_generic_reloc, /* special_function */
1040 "R_MIPS_GOT_DISP", /* name */
1041 false, /* partial_inplace */
1042 0, /* src_mask */
1043 0x0000ffff, /* dst_mask */
1044 false), /* pcrel_offset */
1045
1046 /* Displacement to page pointer in the global offset table. */
1047 /* FIXME: Not handled correctly. */
1048 HOWTO (R_MIPS_GOT_PAGE, /* type */
1049 0, /* rightshift */
1050 2, /* size (0 = byte, 1 = short, 2 = long) */
1051 16, /* bitsize */
1052 false, /* pc_relative */
1053 0, /* bitpos */
1054 complain_overflow_signed, /* complain_on_overflow */
1055 bfd_elf_generic_reloc, /* special_function */
1056 "R_MIPS_GOT_PAGE", /* name */
1057 false, /* partial_inplace */
1058 0, /* src_mask */
1059 0x0000ffff, /* dst_mask */
1060 false), /* pcrel_offset */
1061
1062 /* Offset from page pointer in the global offset table. */
1063 /* FIXME: Not handled correctly. */
1064 HOWTO (R_MIPS_GOT_OFST, /* type */
1065 0, /* rightshift */
1066 2, /* size (0 = byte, 1 = short, 2 = long) */
1067 16, /* bitsize */
1068 false, /* pc_relative */
1069 0, /* bitpos */
1070 complain_overflow_signed, /* complain_on_overflow */
1071 bfd_elf_generic_reloc, /* special_function */
1072 "R_MIPS_GOT_OFST", /* name */
1073 false, /* partial_inplace */
1074 0, /* src_mask */
1075 0x0000ffff, /* dst_mask */
1076 false), /* pcrel_offset */
1077
1078 /* High 16 bits of displacement in global offset table. */
1079 /* FIXME: Not handled correctly. */
1080 HOWTO (R_MIPS_GOT_HI16, /* type */
1081 0, /* rightshift */
1082 2, /* size (0 = byte, 1 = short, 2 = long) */
1083 16, /* bitsize */
1084 false, /* pc_relative */
1085 0, /* bitpos */
1086 complain_overflow_dont, /* complain_on_overflow */
1087 bfd_elf_generic_reloc, /* special_function */
1088 "R_MIPS_GOT_HI16", /* name */
1089 false, /* partial_inplace */
1090 0, /* src_mask */
1091 0x0000ffff, /* dst_mask */
1092 false), /* pcrel_offset */
1093
1094 /* Low 16 bits of displacement in global offset table. */
1095 /* FIXME: Not handled correctly. */
1096 HOWTO (R_MIPS_GOT_LO16, /* type */
1097 0, /* rightshift */
1098 2, /* size (0 = byte, 1 = short, 2 = long) */
1099 16, /* bitsize */
1100 false, /* pc_relative */
1101 0, /* bitpos */
1102 complain_overflow_dont, /* complain_on_overflow */
1103 bfd_elf_generic_reloc, /* special_function */
1104 "R_MIPS_GOT_LO16", /* name */
1105 false, /* partial_inplace */
1106 0, /* src_mask */
1107 0x0000ffff, /* dst_mask */
1108 false), /* pcrel_offset */
1109
1110 /* 64 bit substraction. */
1111 /* FIXME: Not handled correctly. */
1112 HOWTO (R_MIPS_SUB, /* type */
1113 0, /* rightshift */
1114 4, /* size (0 = byte, 1 = short, 2 = long) */
1115 64, /* bitsize */
1116 false, /* pc_relative */
1117 0, /* bitpos */
1118 complain_overflow_dont, /* complain_on_overflow */
1119 bfd_elf_generic_reloc, /* special_function */
1120 "R_MIPS_SUB", /* name */
1121 false, /* partial_inplace */
1122 0, /* src_mask */
1123 MINUS_ONE, /* dst_mask */
1124 false), /* pcrel_offset */
1125
1126 /* Insert the addend as an instruction. */
1127 /* FIXME: Not handled correctly. */
1128 HOWTO (R_MIPS_INSERT_A, /* type */
1129 0, /* rightshift */
1130 2, /* size (0 = byte, 1 = short, 2 = long) */
1131 32, /* bitsize */
1132 false, /* pc_relative */
1133 0, /* bitpos */
1134 complain_overflow_dont, /* complain_on_overflow */
1135 bfd_elf_generic_reloc, /* special_function */
1136 "R_MIPS_INSERT_A", /* name */
1137 false, /* partial_inplace */
1138 0, /* src_mask */
1139 0xffffffff, /* dst_mask */
1140 false), /* pcrel_offset */
1141
1142 /* Insert the addend as an instruction, and change all relocations
1143 to refer to the old instruction at the address. */
1144 /* FIXME: Not handled correctly. */
1145 HOWTO (R_MIPS_INSERT_B, /* type */
1146 0, /* rightshift */
1147 2, /* size (0 = byte, 1 = short, 2 = long) */
1148 32, /* bitsize */
1149 false, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont, /* complain_on_overflow */
1152 bfd_elf_generic_reloc, /* special_function */
1153 "R_MIPS_INSERT_B", /* name */
1154 false, /* partial_inplace */
1155 0, /* src_mask */
1156 0xffffffff, /* dst_mask */
1157 false), /* pcrel_offset */
1158
1159 /* Delete a 32 bit instruction. */
1160 /* FIXME: Not handled correctly. */
1161 HOWTO (R_MIPS_DELETE, /* type */
1162 0, /* rightshift */
1163 2, /* size (0 = byte, 1 = short, 2 = long) */
1164 32, /* bitsize */
1165 false, /* pc_relative */
1166 0, /* bitpos */
1167 complain_overflow_dont, /* complain_on_overflow */
1168 bfd_elf_generic_reloc, /* special_function */
1169 "R_MIPS_DELETE", /* name */
1170 false, /* partial_inplace */
1171 0, /* src_mask */
1172 0xffffffff, /* dst_mask */
1173 false), /* pcrel_offset */
1174
1175 /* Get the higher value of a 64 bit addend. */
1176 HOWTO (R_MIPS_HIGHER, /* type */
1177 0, /* rightshift */
1178 2, /* size (0 = byte, 1 = short, 2 = long) */
1179 16, /* bitsize */
1180 false, /* pc_relative */
1181 0, /* bitpos */
1182 complain_overflow_dont, /* complain_on_overflow */
1183 bfd_elf_generic_reloc, /* special_function */
1184 "R_MIPS_HIGHER", /* name */
1185 false, /* partial_inplace */
1186 0, /* src_mask */
1187 0x0000ffff, /* dst_mask */
1188 false), /* pcrel_offset */
1189
1190 /* Get the highest value of a 64 bit addend. */
1191 HOWTO (R_MIPS_HIGHEST, /* type */
1192 0, /* rightshift */
1193 2, /* size (0 = byte, 1 = short, 2 = long) */
1194 16, /* bitsize */
1195 false, /* pc_relative */
1196 0, /* bitpos */
1197 complain_overflow_dont, /* complain_on_overflow */
1198 bfd_elf_generic_reloc, /* special_function */
1199 "R_MIPS_HIGHEST", /* name */
1200 false, /* partial_inplace */
1201 0, /* src_mask */
1202 0x0000ffff, /* dst_mask */
1203 false), /* pcrel_offset */
1204
1205 /* High 16 bits of displacement in global offset table. */
1206 /* FIXME: Not handled correctly. */
1207 HOWTO (R_MIPS_CALL_HI16, /* type */
1208 0, /* rightshift */
1209 2, /* size (0 = byte, 1 = short, 2 = long) */
1210 16, /* bitsize */
1211 false, /* pc_relative */
1212 0, /* bitpos */
1213 complain_overflow_dont, /* complain_on_overflow */
1214 bfd_elf_generic_reloc, /* special_function */
1215 "R_MIPS_CALL_HI16", /* name */
1216 false, /* partial_inplace */
1217 0, /* src_mask */
1218 0x0000ffff, /* dst_mask */
1219 false), /* pcrel_offset */
1220
1221 /* Low 16 bits of displacement in global offset table. */
1222 /* FIXME: Not handled correctly. */
1223 HOWTO (R_MIPS_CALL_LO16, /* type */
1224 0, /* rightshift */
1225 2, /* size (0 = byte, 1 = short, 2 = long) */
1226 16, /* bitsize */
1227 false, /* pc_relative */
1228 0, /* bitpos */
1229 complain_overflow_dont, /* complain_on_overflow */
1230 bfd_elf_generic_reloc, /* special_function */
1231 "R_MIPS_CALL_LO16", /* name */
1232 false, /* partial_inplace */
1233 0, /* src_mask */
1234 0x0000ffff, /* dst_mask */
1235 false), /* pcrel_offset */
1236
1237 /* Section displacement, used by an associated event location section. */
1238 /* FIXME: Not handled correctly. */
1239 HOWTO (R_MIPS_SCN_DISP, /* type */
1240 0, /* rightshift */
1241 2, /* size (0 = byte, 1 = short, 2 = long) */
1242 32, /* bitsize */
1243 false, /* pc_relative */
1244 0, /* bitpos */
1245 complain_overflow_dont, /* complain_on_overflow */
1246 bfd_elf_generic_reloc, /* special_function */
1247 "R_MIPS_SCN_DISP", /* name */
1248 false, /* partial_inplace */
1249 0, /* src_mask */
1250 0xffffffff, /* dst_mask */
1251 false), /* pcrel_offset */
1252
1253 HOWTO (R_MIPS_REL16, /* type */
1254 0, /* rightshift */
1255 1, /* size (0 = byte, 1 = short, 2 = long) */
1256 16, /* bitsize */
1257 false, /* pc_relative */
1258 0, /* bitpos */
1259 complain_overflow_signed, /* complain_on_overflow */
1260 bfd_elf_generic_reloc, /* special_function */
1261 "R_MIPS_REL16", /* name */
1262 false, /* partial_inplace */
1263 0, /* src_mask */
1264 0xffff, /* dst_mask */
1265 false), /* pcrel_offset */
1266
1267 /* These two are obsolete. */
1268 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
1269 EMPTY_HOWTO (R_MIPS_PJUMP),
1270
1271 /* Similiar to R_MIPS_REL32, but used for relocations in a GOT section.
1272 It must be used for multigot GOT's (and only there). */
1273 HOWTO (R_MIPS_RELGOT, /* type */
1274 0, /* rightshift */
1275 2, /* size (0 = byte, 1 = short, 2 = long) */
1276 32, /* bitsize */
1277 false, /* pc_relative */
1278 0, /* bitpos */
1279 complain_overflow_dont, /* complain_on_overflow */
1280 bfd_elf_generic_reloc, /* special_function */
1281 "R_MIPS_RELGOT", /* name */
1282 false, /* partial_inplace */
1283 0, /* src_mask */
1284 0xffffffff, /* dst_mask */
1285 false), /* pcrel_offset */
1286
1287 /* Protected jump conversion. This is an optimization hint. No
1288 relocation is required for correctness. */
1289 HOWTO (R_MIPS_JALR, /* type */
1290 0, /* rightshift */
1291 2, /* size (0 = byte, 1 = short, 2 = long) */
1292 32, /* bitsize */
1293 false, /* pc_relative */
1294 0, /* bitpos */
1295 complain_overflow_dont, /* complain_on_overflow */
1296 bfd_elf_generic_reloc, /* special_function */
1297 "R_MIPS_JALR", /* name */
1298 false, /* partial_inplace */
1299 0, /* src_mask */
1300 0x00000000, /* dst_mask */
1301 false), /* pcrel_offset */
1302 };
1303
1304 /* Swap in a MIPS 64-bit Rel reloc. */
1305
1306 static void
1307 mips_elf64_swap_reloc_in (abfd, src, dst)
1308 bfd *abfd;
1309 const Elf64_Mips_External_Rel *src;
1310 Elf64_Mips_Internal_Rel *dst;
1311 {
1312 dst->r_offset = H_GET_64 (abfd, src->r_offset);
1313 dst->r_sym = H_GET_32 (abfd, src->r_sym);
1314 dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
1315 dst->r_type3 = H_GET_8 (abfd, src->r_type3);
1316 dst->r_type2 = H_GET_8 (abfd, src->r_type2);
1317 dst->r_type = H_GET_8 (abfd, src->r_type);
1318 }
1319
1320 /* Swap in a MIPS 64-bit Rela reloc. */
1321
1322 static void
1323 mips_elf64_swap_reloca_in (abfd, src, dst)
1324 bfd *abfd;
1325 const Elf64_Mips_External_Rela *src;
1326 Elf64_Mips_Internal_Rela *dst;
1327 {
1328 dst->r_offset = H_GET_64 (abfd, src->r_offset);
1329 dst->r_sym = H_GET_32 (abfd, src->r_sym);
1330 dst->r_ssym = H_GET_8 (abfd, src->r_ssym);
1331 dst->r_type3 = H_GET_8 (abfd, src->r_type3);
1332 dst->r_type2 = H_GET_8 (abfd, src->r_type2);
1333 dst->r_type = H_GET_8 (abfd, src->r_type);
1334 dst->r_addend = H_GET_S64 (abfd, src->r_addend);
1335 }
1336
1337 /* Swap out a MIPS 64-bit Rel reloc. */
1338
1339 static void
1340 mips_elf64_swap_reloc_out (abfd, src, dst)
1341 bfd *abfd;
1342 const Elf64_Mips_Internal_Rel *src;
1343 Elf64_Mips_External_Rel *dst;
1344 {
1345 H_PUT_64 (abfd, src->r_offset, dst->r_offset);
1346 H_PUT_32 (abfd, src->r_sym, dst->r_sym);
1347 H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
1348 H_PUT_8 (abfd, src->r_type3, dst->r_type3);
1349 H_PUT_8 (abfd, src->r_type2, dst->r_type2);
1350 H_PUT_8 (abfd, src->r_type, dst->r_type);
1351 }
1352
1353 /* Swap out a MIPS 64-bit Rela reloc. */
1354
1355 static void
1356 mips_elf64_swap_reloca_out (abfd, src, dst)
1357 bfd *abfd;
1358 const Elf64_Mips_Internal_Rela *src;
1359 Elf64_Mips_External_Rela *dst;
1360 {
1361 H_PUT_64 (abfd, src->r_offset, dst->r_offset);
1362 H_PUT_32 (abfd, src->r_sym, dst->r_sym);
1363 H_PUT_8 (abfd, src->r_ssym, dst->r_ssym);
1364 H_PUT_8 (abfd, src->r_type3, dst->r_type3);
1365 H_PUT_8 (abfd, src->r_type2, dst->r_type2);
1366 H_PUT_8 (abfd, src->r_type, dst->r_type);
1367 H_PUT_S64 (abfd, src->r_addend, dst->r_addend);
1368 }
1369
1370 /* Swap in a MIPS 64-bit Rel reloc. */
1371
1372 static void
1373 mips_elf64_be_swap_reloc_in (abfd, src, dst)
1374 bfd *abfd;
1375 const bfd_byte *src;
1376 Elf_Internal_Rel *dst;
1377 {
1378 Elf64_Mips_Internal_Rel mirel;
1379
1380 mips_elf64_swap_reloc_in (abfd,
1381 (const Elf64_Mips_External_Rel *) src,
1382 &mirel);
1383
1384 dst[0].r_offset = mirel.r_offset;
1385 dst[0].r_info = ELF64_R_INFO (mirel.r_sym, mirel.r_type);
1386 dst[1].r_offset = mirel.r_offset;
1387 dst[1].r_info = ELF64_R_INFO (mirel.r_ssym, mirel.r_type2);
1388 dst[2].r_offset = mirel.r_offset;
1389 dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirel.r_type3);
1390 }
1391
1392 /* Swap in a MIPS 64-bit Rela reloc. */
1393
1394 static void
1395 mips_elf64_be_swap_reloca_in (abfd, src, dst)
1396 bfd *abfd;
1397 const bfd_byte *src;
1398 Elf_Internal_Rela *dst;
1399 {
1400 Elf64_Mips_Internal_Rela mirela;
1401
1402 mips_elf64_swap_reloca_in (abfd,
1403 (const Elf64_Mips_External_Rela *) src,
1404 &mirela);
1405
1406 dst[0].r_offset = mirela.r_offset;
1407 dst[0].r_info = ELF64_R_INFO (mirela.r_sym, mirela.r_type);
1408 dst[0].r_addend = mirela.r_addend;
1409 dst[1].r_offset = mirela.r_offset;
1410 dst[1].r_info = ELF64_R_INFO (mirela.r_ssym, mirela.r_type2);
1411 dst[1].r_addend = 0;
1412 dst[2].r_offset = mirela.r_offset;
1413 dst[2].r_info = ELF64_R_INFO (STN_UNDEF, mirela.r_type3);
1414 dst[2].r_addend = 0;
1415 }
1416
1417 /* Swap out a MIPS 64-bit Rel reloc. */
1418
1419 static void
1420 mips_elf64_be_swap_reloc_out (abfd, src, dst)
1421 bfd *abfd;
1422 const Elf_Internal_Rel *src;
1423 bfd_byte *dst;
1424 {
1425 Elf64_Mips_Internal_Rel mirel;
1426
1427 mirel.r_offset = src[0].r_offset;
1428 BFD_ASSERT(src[0].r_offset == src[1].r_offset);
1429 BFD_ASSERT(src[0].r_offset == src[2].r_offset);
1430
1431 mirel.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
1432 mirel.r_sym = ELF64_R_SYM (src[0].r_info);
1433 mirel.r_type2 = ELF64_MIPS_R_TYPE2 (src[1].r_info);
1434 mirel.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
1435 mirel.r_type3 = ELF64_MIPS_R_TYPE3 (src[2].r_info);
1436
1437 mips_elf64_swap_reloc_out (abfd, &mirel,
1438 (Elf64_Mips_External_Rel *) dst);
1439 }
1440
1441 /* Swap out a MIPS 64-bit Rela reloc. */
1442
1443 static void
1444 mips_elf64_be_swap_reloca_out (abfd, src, dst)
1445 bfd *abfd;
1446 const Elf_Internal_Rela *src;
1447 bfd_byte *dst;
1448 {
1449 Elf64_Mips_Internal_Rela mirela;
1450
1451 mirela.r_offset = src[0].r_offset;
1452 BFD_ASSERT(src[0].r_offset == src[1].r_offset);
1453 BFD_ASSERT(src[0].r_offset == src[2].r_offset);
1454
1455 mirela.r_type = ELF64_MIPS_R_TYPE (src[0].r_info);
1456 mirela.r_sym = ELF64_R_SYM (src[0].r_info);
1457 mirela.r_addend = src[0].r_addend;
1458 BFD_ASSERT(src[1].r_addend == 0);
1459 BFD_ASSERT(src[2].r_addend == 0);
1460
1461 mirela.r_type2 = ELF64_MIPS_R_TYPE2 (src[1].r_info);
1462 mirela.r_ssym = ELF64_MIPS_R_SSYM (src[1].r_info);
1463 mirela.r_type3 = ELF64_MIPS_R_TYPE3 (src[2].r_info);
1464
1465 mips_elf64_swap_reloca_out (abfd, &mirela,
1466 (Elf64_Mips_External_Rela *) dst);
1467 }
1468
1469 /* Calculate the %high function. */
1470
1471 static bfd_vma
1472 mips_elf64_high (value)
1473 bfd_vma value;
1474 {
1475 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
1476 }
1477
1478 /* Calculate the %higher function. */
1479
1480 static bfd_vma
1481 mips_elf64_higher (value)
1482 bfd_vma value;
1483 {
1484 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
1485 }
1486
1487 /* Calculate the %highest function. */
1488
1489 static bfd_vma
1490 mips_elf64_highest (value)
1491 bfd_vma value;
1492 {
1493 return ((value + (bfd_vma) 0x800080008000) >> 48) & 0xffff;
1494 }
1495
1496 /* Do a R_MIPS_HI16 relocation. */
1497
1498 bfd_reloc_status_type
1499 mips_elf64_hi16_reloc (abfd,
1500 reloc_entry,
1501 symbol,
1502 data,
1503 input_section,
1504 output_bfd,
1505 error_message)
1506 bfd *abfd ATTRIBUTE_UNUSED;
1507 arelent *reloc_entry;
1508 asymbol *symbol;
1509 PTR data ATTRIBUTE_UNUSED;
1510 asection *input_section;
1511 bfd *output_bfd;
1512 char **error_message ATTRIBUTE_UNUSED;
1513 {
1514 /* If we're relocating, and this is an external symbol, we don't
1515 want to change anything. */
1516 if (output_bfd != (bfd *) NULL
1517 && (symbol->flags & BSF_SECTION_SYM) == 0
1518 && (! reloc_entry->howto->partial_inplace
1519 || reloc_entry->addend == 0))
1520 {
1521 reloc_entry->address += input_section->output_offset;
1522 return bfd_reloc_ok;
1523 }
1524
1525 if (((reloc_entry->addend & 0xffff) + 0x8000) & ~0xffff)
1526 reloc_entry->addend += 0x8000;
1527
1528 return bfd_reloc_continue;
1529 }
1530
1531 /* Do a R_MIPS_HIGHER relocation. */
1532
1533 bfd_reloc_status_type
1534 mips_elf64_higher_reloc (abfd,
1535 reloc_entry,
1536 symbol,
1537 data,
1538 input_section,
1539 output_bfd,
1540 error_message)
1541 bfd *abfd ATTRIBUTE_UNUSED;
1542 arelent *reloc_entry;
1543 asymbol *symbol;
1544 PTR data ATTRIBUTE_UNUSED;
1545 asection *input_section;
1546 bfd *output_bfd;
1547 char **error_message ATTRIBUTE_UNUSED;
1548 {
1549 /* If we're relocating, and this is an external symbol, we don't
1550 want to change anything. */
1551 if (output_bfd != (bfd *) NULL
1552 && (symbol->flags & BSF_SECTION_SYM) == 0
1553 && (! reloc_entry->howto->partial_inplace
1554 || reloc_entry->addend == 0))
1555 {
1556 reloc_entry->address += input_section->output_offset;
1557 return bfd_reloc_ok;
1558 }
1559
1560 if (((reloc_entry->addend & 0xffffffff) + 0x80008000)
1561 & ~0xffffffff)
1562 reloc_entry->addend += 0x80008000;
1563
1564 return bfd_reloc_continue;
1565 }
1566
1567 /* Do a R_MIPS_HIGHEST relocation. */
1568
1569 bfd_reloc_status_type
1570 mips_elf64_highest_reloc (abfd,
1571 reloc_entry,
1572 symbol,
1573 data,
1574 input_section,
1575 output_bfd,
1576 error_message)
1577 bfd *abfd ATTRIBUTE_UNUSED;
1578 arelent *reloc_entry;
1579 asymbol *symbol;
1580 PTR data ATTRIBUTE_UNUSED;
1581 asection *input_section;
1582 bfd *output_bfd;
1583 char **error_message ATTRIBUTE_UNUSED;
1584 {
1585 /* If we're relocating, and this is an external symbol, we don't
1586 want to change anything. */
1587 if (output_bfd != (bfd *) NULL
1588 && (symbol->flags & BSF_SECTION_SYM) == 0
1589 && (! reloc_entry->howto->partial_inplace
1590 || reloc_entry->addend == 0))
1591 {
1592 reloc_entry->address += input_section->output_offset;
1593 return bfd_reloc_ok;
1594 }
1595
1596 if (((reloc_entry->addend & 0xffffffffffff) + 0x800080008000)
1597 & ~0xffffffffffff)
1598 reloc_entry->addend += 0x800080008000;
1599
1600 return bfd_reloc_continue;
1601 }
1602
1603 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1604 table used for PIC code. If the symbol is an external symbol, the
1605 instruction is modified to contain the offset of the appropriate
1606 entry in the global offset table. If the symbol is a section
1607 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1608 addends are combined to form the real addend against the section
1609 symbol; the GOT16 is modified to contain the offset of an entry in
1610 the global offset table, and the LO16 is modified to offset it
1611 appropriately. Thus an offset larger than 16 bits requires a
1612 modified value in the global offset table.
1613
1614 This implementation suffices for the assembler, but the linker does
1615 not yet know how to create global offset tables. */
1616
1617 bfd_reloc_status_type
1618 mips_elf64_got16_reloc (abfd,
1619 reloc_entry,
1620 symbol,
1621 data,
1622 input_section,
1623 output_bfd,
1624 error_message)
1625 bfd *abfd;
1626 arelent *reloc_entry;
1627 asymbol *symbol;
1628 PTR data;
1629 asection *input_section;
1630 bfd *output_bfd;
1631 char **error_message;
1632 {
1633 /* If we're relocating, and this an external symbol, we don't want
1634 to change anything. */
1635 if (output_bfd != (bfd *) NULL
1636 && (symbol->flags & BSF_SECTION_SYM) == 0
1637 && reloc_entry->addend == 0)
1638 {
1639 reloc_entry->address += input_section->output_offset;
1640 return bfd_reloc_ok;
1641 }
1642
1643 /* If we're relocating, and this is a local symbol, we can handle it
1644 just like HI16. */
1645 if (output_bfd != (bfd *) NULL
1646 && (symbol->flags & BSF_SECTION_SYM) != 0)
1647 return mips_elf64_hi16_reloc (abfd, reloc_entry, symbol, data,
1648 input_section, output_bfd, error_message);
1649
1650 abort ();
1651 }
1652
1653 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1654 dangerous relocation. */
1655
1656 static boolean
1657 mips_elf64_assign_gp (output_bfd, pgp)
1658 bfd *output_bfd;
1659 bfd_vma *pgp;
1660 {
1661 unsigned int count;
1662 asymbol **sym;
1663 unsigned int i;
1664
1665 /* If we've already figured out what GP will be, just return it. */
1666 *pgp = _bfd_get_gp_value (output_bfd);
1667 if (*pgp)
1668 return true;
1669
1670 count = bfd_get_symcount (output_bfd);
1671 sym = bfd_get_outsymbols (output_bfd);
1672
1673 /* The linker script will have created a symbol named `_gp' with the
1674 appropriate value. */
1675 if (sym == (asymbol **) NULL)
1676 i = count;
1677 else
1678 {
1679 for (i = 0; i < count; i++, sym++)
1680 {
1681 register CONST char *name;
1682
1683 name = bfd_asymbol_name (*sym);
1684 if (*name == '_' && strcmp (name, "_gp") == 0)
1685 {
1686 *pgp = bfd_asymbol_value (*sym);
1687 _bfd_set_gp_value (output_bfd, *pgp);
1688 break;
1689 }
1690 }
1691 }
1692
1693 if (i >= count)
1694 {
1695 /* Only get the error once. */
1696 *pgp = 4;
1697 _bfd_set_gp_value (output_bfd, *pgp);
1698 return false;
1699 }
1700
1701 return true;
1702 }
1703
1704 /* We have to figure out the gp value, so that we can adjust the
1705 symbol value correctly. We look up the symbol _gp in the output
1706 BFD. If we can't find it, we're stuck. We cache it in the ELF
1707 target data. We don't need to adjust the symbol value for an
1708 external symbol if we are producing relocateable output. */
1709
1710 static bfd_reloc_status_type
1711 mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1712 bfd *output_bfd;
1713 asymbol *symbol;
1714 boolean relocateable;
1715 char **error_message;
1716 bfd_vma *pgp;
1717 {
1718 if (bfd_is_und_section (symbol->section)
1719 && ! relocateable)
1720 {
1721 *pgp = 0;
1722 return bfd_reloc_undefined;
1723 }
1724
1725 *pgp = _bfd_get_gp_value (output_bfd);
1726 if (*pgp == 0
1727 && (! relocateable
1728 || (symbol->flags & BSF_SECTION_SYM) != 0))
1729 {
1730 if (relocateable)
1731 {
1732 /* Make up a value. */
1733 *pgp = symbol->section->output_section->vma + 0x4000;
1734 _bfd_set_gp_value (output_bfd, *pgp);
1735 }
1736 else if (!mips_elf64_assign_gp (output_bfd, pgp))
1737 {
1738 *error_message =
1739 (char *) _("GP relative relocation when _gp not defined");
1740 return bfd_reloc_dangerous;
1741 }
1742 }
1743
1744 return bfd_reloc_ok;
1745 }
1746
1747 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1748 become the offset from the gp register. */
1749
1750 bfd_reloc_status_type
1751 mips_elf64_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1752 output_bfd, error_message)
1753 bfd *abfd;
1754 arelent *reloc_entry;
1755 asymbol *symbol;
1756 PTR data;
1757 asection *input_section;
1758 bfd *output_bfd;
1759 char **error_message;
1760 {
1761 boolean relocateable;
1762 bfd_reloc_status_type ret;
1763 bfd_vma gp;
1764
1765 /* If we're relocating, and this is an external symbol with no
1766 addend, we don't want to change anything. We will only have an
1767 addend if this is a newly created reloc, not read from an ELF
1768 file. */
1769 if (output_bfd != (bfd *) NULL
1770 && (symbol->flags & BSF_SECTION_SYM) == 0
1771 && reloc_entry->addend == 0)
1772 {
1773 reloc_entry->address += input_section->output_offset;
1774 return bfd_reloc_ok;
1775 }
1776
1777 if (output_bfd != (bfd *) NULL)
1778 relocateable = true;
1779 else
1780 {
1781 relocateable = false;
1782 output_bfd = symbol->section->output_section->owner;
1783 }
1784
1785 ret = mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message,
1786 &gp);
1787 if (ret != bfd_reloc_ok)
1788 return ret;
1789
1790 return gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1791 relocateable, data, gp);
1792 }
1793
1794 static bfd_reloc_status_type
1795 gprel16_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1796 gp)
1797 bfd *abfd;
1798 asymbol *symbol;
1799 arelent *reloc_entry;
1800 asection *input_section;
1801 boolean relocateable;
1802 PTR data;
1803 bfd_vma gp;
1804 {
1805 bfd_vma relocation;
1806 unsigned long insn;
1807 unsigned long val;
1808
1809 if (bfd_is_com_section (symbol->section))
1810 relocation = 0;
1811 else
1812 relocation = symbol->value;
1813
1814 relocation += symbol->section->output_section->vma;
1815 relocation += symbol->section->output_offset;
1816
1817 if (reloc_entry->address > input_section->_cooked_size)
1818 return bfd_reloc_outofrange;
1819
1820 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1821
1822 /* Set val to the offset into the section or symbol. */
1823 if (reloc_entry->howto->src_mask == 0)
1824 {
1825 /* This case occurs with the 64-bit MIPS ELF ABI. */
1826 val = reloc_entry->addend;
1827 }
1828 else
1829 {
1830 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
1831 if (val & 0x8000)
1832 val -= 0x10000;
1833 }
1834
1835 /* Adjust val for the final section location and GP value. If we
1836 are producing relocateable output, we don't want to do this for
1837 an external symbol. */
1838 if (! relocateable
1839 || (symbol->flags & BSF_SECTION_SYM) != 0)
1840 val += relocation - gp;
1841
1842 insn = (insn & ~0xffff) | (val & 0xffff);
1843 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1844
1845 if (relocateable)
1846 reloc_entry->address += input_section->output_offset;
1847
1848 else if ((long) val >= 0x8000 || (long) val < -0x8000)
1849 return bfd_reloc_overflow;
1850
1851 return bfd_reloc_ok;
1852 }
1853
1854 /* Do a R_MIPS_GPREL16 RELA relocation. */
1855
1856 bfd_reloc_status_type
1857 mips_elf64_gprel16_reloca (abfd, reloc_entry, symbol, data, input_section,
1858 output_bfd, error_message)
1859 bfd *abfd;
1860 arelent *reloc_entry;
1861 asymbol *symbol;
1862 PTR data ATTRIBUTE_UNUSED;
1863 asection *input_section;
1864 bfd *output_bfd;
1865 char **error_message;
1866 {
1867 boolean relocateable;
1868 bfd_vma gp;
1869
1870 /* This works only for NewABI. */
1871 BFD_ASSERT (reloc_entry->howto->src_mask == 0);
1872
1873 /* If we're relocating, and this is an external symbol with no
1874 addend, we don't want to change anything. We will only have an
1875 addend if this is a newly created reloc, not read from an ELF
1876 file. */
1877 if (output_bfd != (bfd *) NULL
1878 && (symbol->flags & BSF_SECTION_SYM) == 0
1879 && reloc_entry->addend == 0)
1880 {
1881 reloc_entry->address += input_section->output_offset;
1882 return bfd_reloc_ok;
1883 }
1884
1885 if (output_bfd != (bfd *) NULL)
1886 relocateable = true;
1887 else
1888 {
1889 relocateable = false;
1890 output_bfd = symbol->section->output_section->owner;
1891 }
1892
1893 if (prev_reloc_address != reloc_entry->address)
1894 prev_reloc_address = reloc_entry->address;
1895 else
1896 {
1897 mips_elf64_final_gp (output_bfd, symbol, relocateable, error_message,
1898 &gp);
1899 prev_reloc_addend = reloc_entry->addend + reloc_entry->address - gp;
1900 if (symbol->flags & BSF_LOCAL)
1901 prev_reloc_addend += _bfd_get_gp_value (abfd);
1902 /*fprintf(stderr, "Addend: %lx, Next Addend: %lx\n", reloc_entry->addend, prev_reloc_addend);*/
1903 }
1904
1905 return bfd_reloc_ok;
1906 }
1907
1908 /* Do a R_MIPS_LITERAL relocation. */
1909
1910 bfd_reloc_status_type
1911 mips_elf64_literal_reloc (abfd, reloc_entry, symbol, data, input_section,
1912 output_bfd, error_message)
1913 bfd *abfd;
1914 arelent *reloc_entry;
1915 asymbol *symbol;
1916 PTR data;
1917 asection *input_section;
1918 bfd *output_bfd;
1919 char **error_message;
1920 {
1921 /* If we're relocating, and this is an external symbol, we don't
1922 want to change anything. */
1923 if (output_bfd != (bfd *) NULL
1924 && (symbol->flags & BSF_SECTION_SYM) == 0
1925 && (! reloc_entry->howto->partial_inplace
1926 || reloc_entry->addend == 0))
1927 {
1928 reloc_entry->address += input_section->output_offset;
1929 return bfd_reloc_ok;
1930 }
1931
1932 /* FIXME: The entries in the .lit8 and .lit4 sections should be merged.
1933 Currently we simply call mips_elf64_gprel16_reloc. */
1934 return mips_elf64_gprel16_reloc (abfd, reloc_entry, symbol, data,
1935 input_section, output_bfd, error_message);
1936 }
1937
1938 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1939 from the gp register? XXX */
1940
1941 bfd_reloc_status_type
1942 mips_elf64_gprel32_reloc (abfd,
1943 reloc_entry,
1944 symbol,
1945 data,
1946 input_section,
1947 output_bfd,
1948 error_message)
1949 bfd *abfd;
1950 arelent *reloc_entry;
1951 asymbol *symbol;
1952 PTR data;
1953 asection *input_section;
1954 bfd *output_bfd;
1955 char **error_message;
1956 {
1957 boolean relocateable;
1958 bfd_reloc_status_type ret;
1959 bfd_vma gp;
1960 bfd_vma relocation;
1961 unsigned long val;
1962
1963 /* If we're relocating, and this is an external symbol with no
1964 addend, we don't want to change anything. We will only have an
1965 addend if this is a newly created reloc, not read from an ELF
1966 file. */
1967 if (output_bfd != (bfd *) NULL
1968 && (symbol->flags & BSF_SECTION_SYM) == 0
1969 && reloc_entry->addend == 0)
1970 {
1971 *error_message = (char *)
1972 _("32bits gp relative relocation occurs for an external symbol");
1973 return bfd_reloc_outofrange;
1974 }
1975
1976 if (output_bfd != (bfd *) NULL)
1977 {
1978 relocateable = true;
1979 gp = _bfd_get_gp_value (output_bfd);
1980 }
1981 else
1982 {
1983 relocateable = false;
1984 output_bfd = symbol->section->output_section->owner;
1985
1986 ret = mips_elf64_final_gp (output_bfd, symbol, relocateable,
1987 error_message, &gp);
1988 if (ret != bfd_reloc_ok)
1989 return ret;
1990 }
1991
1992 if (bfd_is_com_section (symbol->section))
1993 relocation = 0;
1994 else
1995 relocation = symbol->value;
1996
1997 relocation += symbol->section->output_section->vma;
1998 relocation += symbol->section->output_offset;
1999
2000 if (reloc_entry->address > input_section->_cooked_size)
2001 return bfd_reloc_outofrange;
2002
2003 if (reloc_entry->howto->src_mask == 0)
2004 {
2005 /* This case arises with the 64-bit MIPS ELF ABI. */
2006 val = 0;
2007 }
2008 else
2009 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
2010
2011 /* Set val to the offset into the section or symbol. */
2012 val += reloc_entry->addend;
2013
2014 /* Adjust val for the final section location and GP value. If we
2015 are producing relocateable output, we don't want to do this for
2016 an external symbol. */
2017 if (! relocateable
2018 || (symbol->flags & BSF_SECTION_SYM) != 0)
2019 val += relocation - gp;
2020
2021 bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
2022
2023 if (relocateable)
2024 reloc_entry->address += input_section->output_offset;
2025
2026 return bfd_reloc_ok;
2027 }
2028
2029 /* Do a R_MIPS_SHIFT6 relocation. The MSB of the shift is stored at bit 2,
2030 the rest is at bits 6-10. The bitpos alredy got right by the howto. */
2031
2032 bfd_reloc_status_type
2033 mips_elf64_shift6_reloc (abfd, reloc_entry, symbol, data, input_section,
2034 output_bfd, error_message)
2035 bfd *abfd ATTRIBUTE_UNUSED;
2036 arelent *reloc_entry;
2037 asymbol *symbol;
2038 PTR data ATTRIBUTE_UNUSED;
2039 asection *input_section;
2040 bfd *output_bfd;
2041 char **error_message ATTRIBUTE_UNUSED;
2042 {
2043 /* If we're relocating, and this is an external symbol, we don't
2044 want to change anything. */
2045 if (output_bfd != (bfd *) NULL
2046 && (symbol->flags & BSF_SECTION_SYM) == 0
2047 && (! reloc_entry->howto->partial_inplace
2048 || reloc_entry->addend == 0))
2049 {
2050 reloc_entry->address += input_section->output_offset;
2051 return bfd_reloc_ok;
2052 }
2053
2054 reloc_entry->addend = (reloc_entry->addend & 0x00007c0)
2055 | (reloc_entry->addend & 0x00000800) >> 9;
2056
2057 return bfd_reloc_continue;
2058 }
2059
2060 static int
2061 mips_elf64_additional_program_headers (abfd)
2062 bfd *abfd;
2063 {
2064 int ret = 0;
2065
2066 /* See if we need a PT_MIPS_OPTIONS segment. */
2067 if (bfd_get_section_by_name (abfd, ".MIPS.options"))
2068 ++ret;
2069
2070 return ret;
2071 }
2072
2073 /* Given a BFD reloc type, return a howto structure. */
2074
2075 static reloc_howto_type *
2076 mips_elf64_reloc_type_lookup (abfd, code)
2077 bfd *abfd ATTRIBUTE_UNUSED;
2078 bfd_reloc_code_real_type code;
2079 {
2080 /* FIXME: We default to RELA here instead of choosing the right
2081 relocation variant. */
2082 reloc_howto_type *howto_table = mips_elf64_howto_table_rela;
2083
2084 switch (code)
2085 {
2086 case BFD_RELOC_NONE:
2087 return &howto_table[R_MIPS_NONE];
2088 case BFD_RELOC_16:
2089 return &howto_table[R_MIPS_16];
2090 case BFD_RELOC_32:
2091 return &howto_table[R_MIPS_32];
2092 case BFD_RELOC_64:
2093 case BFD_RELOC_CTOR:
2094 /* We need to handle these specially. Select the right
2095 relocation (R_MIPS_32 or R_MIPS_64) based on the
2096 size of addresses on this architecture. */
2097 if (bfd_arch_bits_per_address (abfd) == 32)
2098 return &howto_table[R_MIPS_32];
2099 else
2100 return &howto_table[R_MIPS_64];
2101
2102 case BFD_RELOC_16_PCREL:
2103 return &howto_table[R_MIPS_PC16];
2104 case BFD_RELOC_HI16_S:
2105 return &howto_table[R_MIPS_HI16];
2106 case BFD_RELOC_LO16:
2107 return &howto_table[R_MIPS_LO16];
2108 case BFD_RELOC_GPREL16:
2109 return &howto_table[R_MIPS_GPREL16];
2110 case BFD_RELOC_GPREL32:
2111 return &howto_table[R_MIPS_GPREL32];
2112 case BFD_RELOC_MIPS_JMP:
2113 return &howto_table[R_MIPS_26];
2114 case BFD_RELOC_MIPS_LITERAL:
2115 return &howto_table[R_MIPS_LITERAL];
2116 case BFD_RELOC_MIPS_GOT16:
2117 return &howto_table[R_MIPS_GOT16];
2118 case BFD_RELOC_MIPS_CALL16:
2119 return &howto_table[R_MIPS_CALL16];
2120 case BFD_RELOC_MIPS_SHIFT5:
2121 return &howto_table[R_MIPS_SHIFT5];
2122 case BFD_RELOC_MIPS_SHIFT6:
2123 return &howto_table[R_MIPS_SHIFT6];
2124 case BFD_RELOC_MIPS_GOT_DISP:
2125 return &howto_table[R_MIPS_GOT_DISP];
2126 case BFD_RELOC_MIPS_GOT_PAGE:
2127 return &howto_table[R_MIPS_GOT_PAGE];
2128 case BFD_RELOC_MIPS_GOT_OFST:
2129 return &howto_table[R_MIPS_GOT_OFST];
2130 case BFD_RELOC_MIPS_GOT_HI16:
2131 return &howto_table[R_MIPS_GOT_HI16];
2132 case BFD_RELOC_MIPS_GOT_LO16:
2133 return &howto_table[R_MIPS_GOT_LO16];
2134 case BFD_RELOC_MIPS_SUB:
2135 return &howto_table[R_MIPS_SUB];
2136 case BFD_RELOC_MIPS_INSERT_A:
2137 return &howto_table[R_MIPS_INSERT_A];
2138 case BFD_RELOC_MIPS_INSERT_B:
2139 return &howto_table[R_MIPS_INSERT_B];
2140 case BFD_RELOC_MIPS_DELETE:
2141 return &howto_table[R_MIPS_DELETE];
2142 case BFD_RELOC_MIPS_HIGHEST:
2143 return &howto_table[R_MIPS_HIGHEST];
2144 case BFD_RELOC_MIPS_HIGHER:
2145 return &howto_table[R_MIPS_HIGHER];
2146 case BFD_RELOC_MIPS_CALL_HI16:
2147 return &howto_table[R_MIPS_CALL_HI16];
2148 case BFD_RELOC_MIPS_CALL_LO16:
2149 return &howto_table[R_MIPS_CALL_LO16];
2150 case BFD_RELOC_MIPS_SCN_DISP:
2151 return &howto_table[R_MIPS_SCN_DISP];
2152 case BFD_RELOC_MIPS_REL16:
2153 return &howto_table[R_MIPS_REL16];
2154 /* Use of R_MIPS_ADD_IMMEDIATE and R_MIPS_PJUMP is deprecated. */
2155 case BFD_RELOC_MIPS_RELGOT:
2156 return &howto_table[R_MIPS_RELGOT];
2157 case BFD_RELOC_MIPS_JALR:
2158 return &howto_table[R_MIPS_JALR];
2159 /*
2160 case BFD_RELOC_MIPS16_JMP:
2161 return &elf_mips16_jump_howto;
2162 case BFD_RELOC_MIPS16_GPREL:
2163 return &elf_mips16_gprel_howto;
2164 case BFD_RELOC_VTABLE_INHERIT:
2165 return &elf_mips_gnu_vtinherit_howto;
2166 case BFD_RELOC_VTABLE_ENTRY:
2167 return &elf_mips_gnu_vtentry_howto;
2168 case BFD_RELOC_PCREL_HI16_S:
2169 return &elf_mips_gnu_rel_hi16;
2170 case BFD_RELOC_PCREL_LO16:
2171 return &elf_mips_gnu_rel_lo16;
2172 case BFD_RELOC_16_PCREL_S2:
2173 return &elf_mips_gnu_rel16_s2;
2174 case BFD_RELOC_64_PCREL:
2175 return &elf_mips_gnu_pcrel64;
2176 case BFD_RELOC_32_PCREL:
2177 return &elf_mips_gnu_pcrel32;
2178 */
2179 default:
2180 bfd_set_error (bfd_error_bad_value);
2181 return NULL;
2182 }
2183 }
2184
2185 /* Prevent relocation handling by bfd for MIPS ELF64. */
2186
2187 static void
2188 mips_elf64_info_to_howto_rel (abfd, cache_ptr, dst)
2189 bfd *abfd ATTRIBUTE_UNUSED;
2190 arelent *cache_ptr ATTRIBUTE_UNUSED;
2191 Elf64_Internal_Rel *dst ATTRIBUTE_UNUSED;
2192 {
2193 BFD_ASSERT (0);
2194 }
2195
2196 static void
2197 mips_elf64_info_to_howto_rela (abfd, cache_ptr, dst)
2198 bfd *abfd ATTRIBUTE_UNUSED;
2199 arelent *cache_ptr ATTRIBUTE_UNUSED;
2200 Elf64_Internal_Rela *dst ATTRIBUTE_UNUSED;
2201 {
2202 BFD_ASSERT (0);
2203 }
2204
2205 /* Since each entry in an SHT_REL or SHT_RELA section can represent up
2206 to three relocs, we must tell the user to allocate more space. */
2207
2208 static long
2209 mips_elf64_get_reloc_upper_bound (abfd, sec)
2210 bfd *abfd ATTRIBUTE_UNUSED;
2211 asection *sec;
2212 {
2213 return (sec->reloc_count * 3 + 1) * sizeof (arelent *);
2214 }
2215
2216 /* Read the relocations from one reloc section. */
2217
2218 static boolean
2219 mips_elf64_slurp_one_reloc_table (abfd, asect, symbols, rel_hdr)
2220 bfd *abfd;
2221 asection *asect;
2222 asymbol **symbols;
2223 const Elf_Internal_Shdr *rel_hdr;
2224 {
2225 PTR allocated = NULL;
2226 bfd_byte *native_relocs;
2227 arelent *relents;
2228 arelent *relent;
2229 bfd_vma count;
2230 bfd_vma i;
2231 int entsize;
2232 reloc_howto_type *howto_table;
2233
2234 allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
2235 if (allocated == NULL)
2236 return false;
2237
2238 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
2239 || (bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size))
2240 goto error_return;
2241
2242 native_relocs = (bfd_byte *) allocated;
2243
2244 relents = asect->relocation + asect->reloc_count;
2245
2246 entsize = rel_hdr->sh_entsize;
2247 BFD_ASSERT (entsize == sizeof (Elf64_Mips_External_Rel)
2248 || entsize == sizeof (Elf64_Mips_External_Rela));
2249
2250 count = rel_hdr->sh_size / entsize;
2251
2252 if (entsize == sizeof (Elf64_Mips_External_Rel))
2253 howto_table = mips_elf64_howto_table_rel;
2254 else
2255 howto_table = mips_elf64_howto_table_rela;
2256
2257 relent = relents;
2258 for (i = 0; i < count; i++, native_relocs += entsize)
2259 {
2260 Elf64_Mips_Internal_Rela rela;
2261 boolean used_sym, used_ssym;
2262 int ir;
2263
2264 if (entsize == sizeof (Elf64_Mips_External_Rela))
2265 mips_elf64_swap_reloca_in (abfd,
2266 (Elf64_Mips_External_Rela *) native_relocs,
2267 &rela);
2268 else
2269 {
2270 Elf64_Mips_Internal_Rel rel;
2271
2272 mips_elf64_swap_reloc_in (abfd,
2273 (Elf64_Mips_External_Rel *) native_relocs,
2274 &rel);
2275 rela.r_offset = rel.r_offset;
2276 rela.r_sym = rel.r_sym;
2277 rela.r_ssym = rel.r_ssym;
2278 rela.r_type3 = rel.r_type3;
2279 rela.r_type2 = rel.r_type2;
2280 rela.r_type = rel.r_type;
2281 rela.r_addend = 0;
2282 }
2283
2284 /* Each entry represents up to three actual relocations. */
2285
2286 used_sym = false;
2287 used_ssym = false;
2288 for (ir = 0; ir < 3; ir++)
2289 {
2290 enum elf_mips_reloc_type type;
2291
2292 switch (ir)
2293 {
2294 default:
2295 abort ();
2296 case 0:
2297 type = (enum elf_mips_reloc_type) rela.r_type;
2298 break;
2299 case 1:
2300 type = (enum elf_mips_reloc_type) rela.r_type2;
2301 break;
2302 case 2:
2303 type = (enum elf_mips_reloc_type) rela.r_type3;
2304 break;
2305 }
2306
2307 if (type == R_MIPS_NONE)
2308 {
2309 /* There are no more relocations in this entry. If this
2310 is the first entry, we need to generate a dummy
2311 relocation so that the generic linker knows that
2312 there has been a break in the sequence of relocations
2313 applying to a particular address. */
2314 if (ir == 0)
2315 {
2316 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2317 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2318 relent->address = rela.r_offset;
2319 else
2320 relent->address = rela.r_offset - asect->vma;
2321 relent->addend = 0;
2322 relent->howto = &howto_table[(int) R_MIPS_NONE];
2323 ++relent;
2324 }
2325 break;
2326 }
2327
2328 /* Some types require symbols, whereas some do not. */
2329 switch (type)
2330 {
2331 case R_MIPS_NONE:
2332 case R_MIPS_LITERAL:
2333 case R_MIPS_INSERT_A:
2334 case R_MIPS_INSERT_B:
2335 case R_MIPS_DELETE:
2336 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2337 break;
2338
2339 default:
2340 if (! used_sym)
2341 {
2342 if (rela.r_sym == 0)
2343 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2344 else
2345 {
2346 asymbol **ps, *s;
2347
2348 ps = symbols + rela.r_sym - 1;
2349 s = *ps;
2350 if ((s->flags & BSF_SECTION_SYM) == 0)
2351 relent->sym_ptr_ptr = ps;
2352 else
2353 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
2354 }
2355
2356 used_sym = true;
2357 }
2358 else if (! used_ssym)
2359 {
2360 switch (rela.r_ssym)
2361 {
2362 case RSS_UNDEF:
2363 relent->sym_ptr_ptr =
2364 bfd_abs_section_ptr->symbol_ptr_ptr;
2365 break;
2366
2367 case RSS_GP:
2368 case RSS_GP0:
2369 case RSS_LOC:
2370 /* FIXME: I think these need to be handled using
2371 special howto structures. */
2372 BFD_ASSERT (0);
2373 break;
2374
2375 default:
2376 BFD_ASSERT (0);
2377 break;
2378 }
2379
2380 used_ssym = true;
2381 }
2382 else
2383 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
2384
2385 break;
2386 }
2387
2388 /* The address of an ELF reloc is section relative for an
2389 object file, and absolute for an executable file or
2390 shared library. The address of a BFD reloc is always
2391 section relative. */
2392 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2393 relent->address = rela.r_offset;
2394 else
2395 relent->address = rela.r_offset - asect->vma;
2396
2397 relent->addend = rela.r_addend;
2398
2399 relent->howto = &howto_table[(int) type];
2400
2401 ++relent;
2402 }
2403 }
2404
2405 asect->reloc_count += relent - relents;
2406
2407 if (allocated != NULL)
2408 free (allocated);
2409
2410 return true;
2411
2412 error_return:
2413 if (allocated != NULL)
2414 free (allocated);
2415 return false;
2416 }
2417
2418 /* Read the relocations. On Irix 6, there can be two reloc sections
2419 associated with a single data section. */
2420
2421 static boolean
2422 mips_elf64_slurp_reloc_table (abfd, asect, symbols, dynamic)
2423 bfd *abfd;
2424 asection *asect;
2425 asymbol **symbols;
2426 boolean dynamic;
2427 {
2428 bfd_size_type amt;
2429 struct bfd_elf_section_data * const d = elf_section_data (asect);
2430
2431 if (dynamic)
2432 {
2433 bfd_set_error (bfd_error_invalid_operation);
2434 return false;
2435 }
2436
2437 if (asect->relocation != NULL
2438 || (asect->flags & SEC_RELOC) == 0
2439 || asect->reloc_count == 0)
2440 return true;
2441
2442 /* Allocate space for 3 arelent structures for each Rel structure. */
2443 amt = asect->reloc_count;
2444 amt *= 3 * sizeof (arelent);
2445 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
2446 if (asect->relocation == NULL)
2447 return false;
2448
2449 /* The slurp_one_reloc_table routine increments reloc_count. */
2450 asect->reloc_count = 0;
2451
2452 if (! mips_elf64_slurp_one_reloc_table (abfd, asect, symbols, &d->rel_hdr))
2453 return false;
2454 if (d->rel_hdr2 != NULL)
2455 {
2456 if (! mips_elf64_slurp_one_reloc_table (abfd, asect, symbols,
2457 d->rel_hdr2))
2458 return false;
2459 }
2460
2461 return true;
2462 }
2463
2464 /* Write out the relocations. */
2465
2466 static void
2467 mips_elf64_write_relocs (abfd, sec, data)
2468 bfd *abfd;
2469 asection *sec;
2470 PTR data;
2471 {
2472 boolean *failedp = (boolean *) data;
2473 int count;
2474 Elf_Internal_Shdr *rel_hdr;
2475 unsigned int idx;
2476
2477 /* If we have already failed, don't do anything. */
2478 if (*failedp)
2479 return;
2480
2481 if ((sec->flags & SEC_RELOC) == 0)
2482 return;
2483
2484 /* The linker backend writes the relocs out itself, and sets the
2485 reloc_count field to zero to inhibit writing them here. Also,
2486 sometimes the SEC_RELOC flag gets set even when there aren't any
2487 relocs. */
2488 if (sec->reloc_count == 0)
2489 return;
2490
2491 /* We can combine up to three relocs that refer to the same address
2492 if the latter relocs have no associated symbol. */
2493 count = 0;
2494 for (idx = 0; idx < sec->reloc_count; idx++)
2495 {
2496 bfd_vma addr;
2497 unsigned int i;
2498
2499 ++count;
2500
2501 addr = sec->orelocation[idx]->address;
2502 for (i = 0; i < 2; i++)
2503 {
2504 arelent *r;
2505
2506 if (idx + 1 >= sec->reloc_count)
2507 break;
2508 r = sec->orelocation[idx + 1];
2509 if (r->address != addr
2510 || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2511 || (*r->sym_ptr_ptr)->value != 0)
2512 break;
2513
2514 /* We can merge the reloc at IDX + 1 with the reloc at IDX. */
2515
2516 ++idx;
2517 }
2518 }
2519
2520 rel_hdr = &elf_section_data (sec)->rel_hdr;
2521
2522 /* Do the actual relocation. */
2523
2524 if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rel))
2525 mips_elf64_write_rel (abfd, sec, rel_hdr, &count, data);
2526 else if (rel_hdr->sh_entsize == sizeof(Elf64_Mips_External_Rela))
2527 mips_elf64_write_rela (abfd, sec, rel_hdr, &count, data);
2528 else
2529 BFD_ASSERT (0);
2530 }
2531
2532 static void
2533 mips_elf64_write_rel (abfd, sec, rel_hdr, count, data)
2534 bfd *abfd;
2535 asection *sec;
2536 Elf_Internal_Shdr *rel_hdr;
2537 int *count;
2538 PTR data;
2539 {
2540 boolean *failedp = (boolean *) data;
2541 Elf64_Mips_External_Rel *ext_rel;
2542 unsigned int idx;
2543 asymbol *last_sym = 0;
2544 int last_sym_idx = 0;
2545
2546 rel_hdr->sh_size = (bfd_vma)(rel_hdr->sh_entsize * *count);
2547 rel_hdr->contents = (PTR) bfd_alloc (abfd, rel_hdr->sh_size);
2548 if (rel_hdr->contents == NULL)
2549 {
2550 *failedp = true;
2551 return;
2552 }
2553
2554 ext_rel = (Elf64_Mips_External_Rel *) rel_hdr->contents;
2555 for (idx = 0; idx < sec->reloc_count; idx++, ext_rel++)
2556 {
2557 arelent *ptr;
2558 Elf64_Mips_Internal_Rel int_rel;
2559 asymbol *sym;
2560 int n;
2561 unsigned int i;
2562
2563 ptr = sec->orelocation[idx];
2564
2565 /* The address of an ELF reloc is section relative for an object
2566 file, and absolute for an executable file or shared library.
2567 The address of a BFD reloc is always section relative. */
2568 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2569 int_rel.r_offset = ptr->address;
2570 else
2571 int_rel.r_offset = ptr->address + sec->vma;
2572
2573 sym = *ptr->sym_ptr_ptr;
2574 if (sym == last_sym)
2575 n = last_sym_idx;
2576 else
2577 {
2578 last_sym = sym;
2579 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
2580 if (n < 0)
2581 {
2582 *failedp = true;
2583 return;
2584 }
2585 last_sym_idx = n;
2586 }
2587
2588 int_rel.r_sym = n;
2589 int_rel.r_ssym = RSS_UNDEF;
2590
2591 if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
2592 && ! _bfd_elf_validate_reloc (abfd, ptr))
2593 {
2594 *failedp = true;
2595 return;
2596 }
2597
2598 int_rel.r_type = ptr->howto->type;
2599 int_rel.r_type2 = (int) R_MIPS_NONE;
2600 int_rel.r_type3 = (int) R_MIPS_NONE;
2601
2602 for (i = 0; i < 2; i++)
2603 {
2604 arelent *r;
2605
2606 if (idx + 1 >= sec->reloc_count)
2607 break;
2608 r = sec->orelocation[idx + 1];
2609 if (r->address != ptr->address
2610 || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2611 || (*r->sym_ptr_ptr)->value != 0)
2612 break;
2613
2614 /* We can merge the reloc at IDX + 1 with the reloc at IDX. */
2615
2616 if (i == 0)
2617 int_rel.r_type2 = r->howto->type;
2618 else
2619 int_rel.r_type3 = r->howto->type;
2620
2621 ++idx;
2622 }
2623
2624 mips_elf64_swap_reloc_out (abfd, &int_rel, ext_rel);
2625 }
2626
2627 BFD_ASSERT (ext_rel - (Elf64_Mips_External_Rel *) rel_hdr->contents
2628 == *count);
2629 }
2630
2631 static void
2632 mips_elf64_write_rela (abfd, sec, rela_hdr, count, data)
2633 bfd *abfd;
2634 asection *sec;
2635 Elf_Internal_Shdr *rela_hdr;
2636 int *count;
2637 PTR data;
2638 {
2639 boolean *failedp = (boolean *) data;
2640 Elf64_Mips_External_Rela *ext_rela;
2641 unsigned int idx;
2642 asymbol *last_sym = 0;
2643 int last_sym_idx = 0;
2644
2645 rela_hdr->sh_size = (bfd_vma)(rela_hdr->sh_entsize * *count);
2646 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
2647 if (rela_hdr->contents == NULL)
2648 {
2649 *failedp = true;
2650 return;
2651 }
2652
2653 ext_rela = (Elf64_Mips_External_Rela *) rela_hdr->contents;
2654 for (idx = 0; idx < sec->reloc_count; idx++, ext_rela++)
2655 {
2656 arelent *ptr;
2657 Elf64_Mips_Internal_Rela int_rela;
2658 asymbol *sym;
2659 int n;
2660 unsigned int i;
2661
2662 ptr = sec->orelocation[idx];
2663
2664 /* The address of an ELF reloc is section relative for an object
2665 file, and absolute for an executable file or shared library.
2666 The address of a BFD reloc is always section relative. */
2667 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2668 int_rela.r_offset = ptr->address;
2669 else
2670 int_rela.r_offset = ptr->address + sec->vma;
2671
2672 sym = *ptr->sym_ptr_ptr;
2673 if (sym == last_sym)
2674 n = last_sym_idx;
2675 else
2676 {
2677 last_sym = sym;
2678 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
2679 if (n < 0)
2680 {
2681 *failedp = true;
2682 return;
2683 }
2684 last_sym_idx = n;
2685 }
2686
2687 int_rela.r_sym = n;
2688 int_rela.r_addend = ptr->addend;
2689 int_rela.r_ssym = RSS_UNDEF;
2690
2691 if ((*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
2692 && ! _bfd_elf_validate_reloc (abfd, ptr))
2693 {
2694 *failedp = true;
2695 return;
2696 }
2697
2698 int_rela.r_type = ptr->howto->type;
2699 int_rela.r_type2 = (int) R_MIPS_NONE;
2700 int_rela.r_type3 = (int) R_MIPS_NONE;
2701
2702 for (i = 0; i < 2; i++)
2703 {
2704 arelent *r;
2705
2706 if (idx + 1 >= sec->reloc_count)
2707 break;
2708 r = sec->orelocation[idx + 1];
2709 if (r->address != ptr->address
2710 || ! bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
2711 || (*r->sym_ptr_ptr)->value != 0)
2712 break;
2713
2714 /* We can merge the reloc at IDX + 1 with the reloc at IDX. */
2715
2716 if (i == 0)
2717 int_rela.r_type2 = r->howto->type;
2718 else
2719 int_rela.r_type3 = r->howto->type;
2720
2721 ++idx;
2722 }
2723
2724 mips_elf64_swap_reloca_out (abfd, &int_rela, ext_rela);
2725 }
2726
2727 BFD_ASSERT (ext_rela - (Elf64_Mips_External_Rela *) rela_hdr->contents
2728 == *count);
2729 }
2730 \f
2731 /* This structure is used to hold .got information when linking. It
2732 is stored in the tdata field of the bfd_elf_section_data structure. */
2733
2734 struct mips_elf64_got_info
2735 {
2736 /* The global symbol in the GOT with the lowest index in the dynamic
2737 symbol table. */
2738 struct elf_link_hash_entry *global_gotsym;
2739 /* The number of global .got entries. */
2740 unsigned int global_gotno;
2741 /* The number of local .got entries. */
2742 unsigned int local_gotno;
2743 /* The number of local .got entries we have used. */
2744 unsigned int assigned_gotno;
2745 };
2746
2747 /* The MIPS ELF64 linker needs additional information for each symbol in
2748 the global hash table. */
2749
2750 struct mips_elf64_link_hash_entry
2751 {
2752 struct elf_link_hash_entry root;
2753
2754 /* External symbol information. */
2755 EXTR esym;
2756
2757 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
2758 this symbol. */
2759 unsigned int possibly_dynamic_relocs;
2760
2761 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
2762 a readonly section. */
2763 boolean readonly_reloc;
2764
2765 /* The index of the first dynamic relocation (in the .rel.dyn
2766 section) against this symbol. */
2767 unsigned int min_dyn_reloc_index;
2768
2769 /* We must not create a stub for a symbol that has relocations
2770 related to taking the function's address, i.e. any but
2771 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
2772 p. 4-20. */
2773 boolean no_fn_stub;
2774
2775 /* If there is a stub that 32 bit functions should use to call this
2776 16 bit function, this points to the section containing the stub. */
2777 asection *fn_stub;
2778
2779 /* Whether we need the fn_stub; this is set if this symbol appears
2780 in any relocs other than a 16 bit call. */
2781 boolean need_fn_stub;
2782
2783 /* If there is a stub that 16 bit functions should use to call this
2784 32 bit function, this points to the section containing the stub. */
2785 asection *call_stub;
2786
2787 /* This is like the call_stub field, but it is used if the function
2788 being called returns a floating point value. */
2789 asection *call_fp_stub;
2790 };
2791 \f
2792 /* The mips16 compiler uses a couple of special sections to handle
2793 floating point arguments.
2794
2795 Section names that look like .mips16.fn.FNNAME contain stubs that
2796 copy floating point arguments from the fp regs to the gp regs and
2797 then jump to FNNAME. If any 32 bit function calls FNNAME, the
2798 call should be redirected to the stub instead. If no 32 bit
2799 function calls FNNAME, the stub should be discarded. We need to
2800 consider any reference to the function, not just a call, because
2801 if the address of the function is taken we will need the stub,
2802 since the address might be passed to a 32 bit function.
2803
2804 Section names that look like .mips16.call.FNNAME contain stubs
2805 that copy floating point arguments from the gp regs to the fp
2806 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
2807 then any 16 bit function that calls FNNAME should be redirected
2808 to the stub instead. If FNNAME is not a 32 bit function, the
2809 stub should be discarded.
2810
2811 .mips16.call.fp.FNNAME sections are similar, but contain stubs
2812 which call FNNAME and then copy the return value from the fp regs
2813 to the gp regs. These stubs store the return value in $18 while
2814 calling FNNAME; any function which might call one of these stubs
2815 must arrange to save $18 around the call. (This case is not
2816 needed for 32 bit functions that call 16 bit functions, because
2817 16 bit functions always return floating point values in both
2818 $f0/$f1 and $2/$3.)
2819
2820 Note that in all cases FNNAME might be defined statically.
2821 Therefore, FNNAME is not used literally. Instead, the relocation
2822 information will indicate which symbol the section is for.
2823
2824 We record any stubs that we find in the symbol table. */
2825
2826 #define FN_STUB ".mips16.fn."
2827 #define CALL_STUB ".mips16.call."
2828 #define CALL_FP_STUB ".mips16.call.fp."
2829
2830 /* MIPS ELF64 linker hash table. */
2831
2832 struct mips_elf64_link_hash_table
2833 {
2834 struct elf_link_hash_table root;
2835 /* This is set if we see any mips16 stub sections. */
2836 boolean mips16_stubs_seen;
2837 };
2838
2839 /* Look up an entry in a MIPS ELF64 linker hash table. */
2840
2841 #define mips_elf64_link_hash_lookup(table, string, create, copy, follow) \
2842 ((struct mips_elf64_link_hash_entry *) \
2843 elf_link_hash_lookup (&(table)->root, (string), (create), \
2844 (copy), (follow)))
2845
2846 /* Traverse a MIPS ELF linker hash table. */
2847
2848 #define mips_elf64_link_hash_traverse(table, func, info) \
2849 (elf_link_hash_traverse \
2850 (&(table)->root, \
2851 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
2852 (info)))
2853
2854 /* Get the MIPS ELF64 linker hash table from a link_info structure. */
2855
2856 #define mips_elf64_hash_table(p) \
2857 ((struct mips_elf64_link_hash_table *) ((p)->hash))
2858
2859 /* Create an entry in a MIPS ELF64 linker hash table. */
2860
2861 static struct bfd_hash_entry *
2862 mips_elf64_link_hash_newfunc (entry, table, string)
2863 struct bfd_hash_entry *entry;
2864 struct bfd_hash_table *table;
2865 const char *string;
2866 {
2867 struct mips_elf64_link_hash_entry *ret =
2868 (struct mips_elf64_link_hash_entry *) entry;
2869
2870 /* Allocate the structure if it has not already been allocated by a
2871 subclass. */
2872 if (ret == (struct mips_elf64_link_hash_entry *) NULL)
2873 ret = ((struct mips_elf64_link_hash_entry *)
2874 bfd_hash_allocate (table,
2875 sizeof (struct mips_elf64_link_hash_entry)));
2876 if (ret == (struct mips_elf64_link_hash_entry *) NULL)
2877 return (struct bfd_hash_entry *) ret;
2878
2879 /* Call the allocation method of the superclass. */
2880 ret = ((struct mips_elf64_link_hash_entry *)
2881 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2882 table, string));
2883 if (ret != (struct mips_elf64_link_hash_entry *) NULL)
2884 {
2885 /* Set local fields. */
2886 memset (&ret->esym, 0, sizeof (EXTR));
2887 /* We use -2 as a marker to indicate that the information has
2888 not been set. -1 means there is no associated ifd. */
2889 ret->esym.ifd = -2;
2890 ret->possibly_dynamic_relocs = 0;
2891 ret->readonly_reloc = false;
2892 ret->min_dyn_reloc_index = 0;
2893 ret->no_fn_stub = false;
2894 ret->fn_stub = NULL;
2895 ret->need_fn_stub = false;
2896 ret->call_stub = NULL;
2897 ret->call_fp_stub = NULL;
2898 }
2899
2900 return (struct bfd_hash_entry *) ret;
2901 }
2902
2903 /* Create a MIPS ELF64 linker hash table. */
2904
2905 struct bfd_link_hash_table *
2906 mips_elf64_link_hash_table_create (abfd)
2907 bfd *abfd;
2908 {
2909 struct mips_elf64_link_hash_table *ret;
2910
2911 ret = ((struct mips_elf64_link_hash_table *)
2912 bfd_alloc (abfd, sizeof (struct mips_elf64_link_hash_table)));
2913 if (ret == (struct mips_elf64_link_hash_table *) NULL)
2914 return NULL;
2915
2916 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2917 mips_elf64_link_hash_newfunc))
2918 {
2919 bfd_release (abfd, ret);
2920 return NULL;
2921 }
2922
2923 ret->mips16_stubs_seen = false;
2924
2925 return &ret->root.root;
2926 }
2927 \f
2928 /* Returns the offset for the entry at the INDEXth position
2929 in the GOT. */
2930
2931 static bfd_vma
2932 mips_elf64_got_offset_from_index (dynobj, output_bfd, index)
2933 bfd *dynobj;
2934 bfd *output_bfd;
2935 bfd_vma index;
2936 {
2937 asection *sgot;
2938 bfd_vma gp;
2939
2940 sgot = bfd_get_section_by_name (dynobj, ".got");
2941 gp = _bfd_get_gp_value (output_bfd);
2942 return (sgot->output_section->vma + sgot->output_offset + index -
2943 gp);
2944 }
2945
2946 /* Returns the GOT information associated with the link indicated by
2947 INFO. If SGOTP is non-NULL, it is filled in with the GOT
2948 section. */
2949
2950 static struct mips_elf64_got_info *
2951 _mips_elf64_got_info (abfd, sgotp)
2952 bfd *abfd;
2953 asection **sgotp;
2954 {
2955 asection *sgot;
2956 struct mips_elf64_got_info *g;
2957
2958 sgot = bfd_get_section_by_name (abfd, ".got");
2959 BFD_ASSERT (sgot != NULL);
2960 BFD_ASSERT (elf_section_data (sgot) != NULL);
2961 g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
2962 BFD_ASSERT (g != NULL);
2963
2964 if (sgotp)
2965 *sgotp = sgot;
2966 return g;
2967 }
2968
2969 /* Sign-extend VALUE, which has the indicated number of BITS. */
2970
2971 static bfd_vma
2972 mips_elf64_sign_extend (value, bits)
2973 bfd_vma value;
2974 int bits;
2975 {
2976 if (value & ((bfd_vma)1 << (bits - 1)))
2977 /* VALUE is negative. */
2978 value |= ((bfd_vma) - 1) << bits;
2979
2980 return value;
2981 }
2982
2983 /* Return non-zero if the indicated VALUE has overflowed the maximum
2984 range expressable by a signed number with the indicated number of
2985 BITS. */
2986
2987 static boolean
2988 mips_elf64_overflow_p (value, bits)
2989 bfd_vma value;
2990 int bits;
2991 {
2992 bfd_signed_vma svalue = (bfd_signed_vma) value;
2993
2994 if (svalue > (1 << (bits - 1)) - 1)
2995 /* The value is too big. */
2996 return true;
2997 else if (svalue < -(1 << (bits - 1)))
2998 /* The value is too small. */
2999 return true;
3000
3001 /* All is well. */
3002 return false;
3003 }
3004 \f
3005 /* Returns the GOT index for the global symbol indicated by H. */
3006
3007 static bfd_vma
3008 mips_elf64_global_got_index (abfd, h)
3009 bfd *abfd;
3010 struct elf_link_hash_entry *h;
3011 {
3012 bfd_vma index;
3013 asection *sgot;
3014 struct mips_elf64_got_info *g;
3015
3016 g = _mips_elf64_got_info (abfd, &sgot);
3017
3018 /* Once we determine the global GOT entry with the lowest dynamic
3019 symbol table index, we must put all dynamic symbols with greater
3020 indices into the GOT. That makes it easy to calculate the GOT
3021 offset. */
3022 BFD_ASSERT (h->dynindx >= g->global_gotsym->dynindx);
3023 index = ((h->dynindx - g->global_gotsym->dynindx + g->local_gotno)
3024 * (get_elf_backend_data (abfd)->s->arch_size / 8));
3025 BFD_ASSERT (index < sgot->_raw_size);
3026
3027 return index;
3028 }
3029
3030 struct mips_elf64_hash_sort_data
3031 {
3032 /* The symbol in the global GOT with the lowest dynamic symbol table
3033 index. */
3034 struct elf_link_hash_entry *low;
3035 /* The least dynamic symbol table index corresponding to a symbol
3036 with a GOT entry. */
3037 long min_got_dynindx;
3038 /* The greatest dynamic symbol table index not corresponding to a
3039 symbol without a GOT entry. */
3040 long max_non_got_dynindx;
3041 };
3042
3043 /* If H needs a GOT entry, assign it the highest available dynamic
3044 index. Otherwise, assign it the lowest available dynamic
3045 index. */
3046
3047 static boolean
3048 mips_elf64_sort_hash_table_f (h, data)
3049 struct mips_elf64_link_hash_entry *h;
3050 PTR data;
3051 {
3052 struct mips_elf64_hash_sort_data *hsd
3053 = (struct mips_elf64_hash_sort_data *) data;
3054
3055 /* Symbols without dynamic symbol table entries aren't interesting
3056 at all. */
3057 if (h->root.dynindx == -1)
3058 return true;
3059
3060 if (h->root.got.offset != 1)
3061 h->root.dynindx = hsd->max_non_got_dynindx++;
3062 else
3063 {
3064 h->root.dynindx = --hsd->min_got_dynindx;
3065 hsd->low = (struct elf_link_hash_entry *) h;
3066 }
3067
3068 return true;
3069 }
3070
3071 /* Sort the dynamic symbol table so that symbols that need GOT entries
3072 appear towards the end. This reduces the amount of GOT space
3073 required. MAX_LOCAL is used to set the number of local symbols
3074 known to be in the dynamic symbol table. During
3075 mips_elf64_size_dynamic_sections, this value is 1. Afterward, the
3076 section symbols are added and the count is higher. */
3077
3078 static boolean
3079 mips_elf64_sort_hash_table (info, max_local)
3080 struct bfd_link_info *info;
3081 unsigned long max_local;
3082 {
3083 struct mips_elf64_hash_sort_data hsd;
3084 struct mips_elf64_got_info *g;
3085 bfd *dynobj;
3086
3087 dynobj = elf_hash_table (info)->dynobj;
3088
3089 hsd.low = NULL;
3090 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount;
3091 hsd.max_non_got_dynindx = max_local;
3092 mips_elf64_link_hash_traverse (((struct mips_elf64_link_hash_table *)
3093 elf_hash_table (info)),
3094 mips_elf64_sort_hash_table_f,
3095 &hsd);
3096
3097 /* There shoud have been enough room in the symbol table to
3098 accomodate both the GOT and non-GOT symbols. */
3099 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3100
3101 /* Now we know which dynamic symbol has the lowest dynamic symbol
3102 table index in the GOT. */
3103 g = _mips_elf64_got_info (dynobj, NULL);
3104 g->global_gotsym = hsd.low;
3105
3106 return true;
3107 }
3108 \f
3109 #if 0
3110 /* Swap in an MSYM entry. */
3111
3112 static void
3113 mips_elf64_swap_msym_in (abfd, ex, in)
3114 bfd *abfd;
3115 const Elf32_External_Msym *ex;
3116 Elf32_Internal_Msym *in;
3117 {
3118 in->ms_hash_value = H_GET_32 (abfd, ex->ms_hash_value);
3119 in->ms_info = H_GET_32 (abfd, ex->ms_info);
3120 }
3121 #endif
3122 /* Swap out an MSYM entry. */
3123
3124 static void
3125 mips_elf64_swap_msym_out (abfd, in, ex)
3126 bfd *abfd;
3127 const Elf32_Internal_Msym *in;
3128 Elf32_External_Msym *ex;
3129 {
3130 H_PUT_32 (abfd, in->ms_hash_value, ex->ms_hash_value);
3131 H_PUT_32 (abfd, in->ms_info, ex->ms_info);
3132 }
3133 \f
3134 /* Create a local GOT entry for VALUE. Return the index of the entry,
3135 or -1 if it could not be created. */
3136
3137 static bfd_vma
3138 mips_elf64_create_local_got_entry (abfd, g, sgot, value)
3139 bfd *abfd;
3140 struct mips_elf64_got_info *g;
3141 asection *sgot;
3142 bfd_vma value;
3143 {
3144 CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3145
3146 if (g->assigned_gotno >= g->local_gotno)
3147 {
3148 /* We didn't allocate enough space in the GOT. */
3149 (*_bfd_error_handler)
3150 (_("not enough GOT space for local GOT entries"));
3151 bfd_set_error (bfd_error_bad_value);
3152 return (bfd_vma) -1;
3153 }
3154
3155 bfd_put_64 (abfd, value, (sgot->contents + got_size * g->assigned_gotno));
3156 return got_size * g->assigned_gotno++;
3157 }
3158
3159 /* Returns the GOT offset at which the indicated address can be found.
3160 If there is not yet a GOT entry for this value, create one. Returns
3161 -1 if no satisfactory GOT offset can be found. */
3162
3163 static bfd_vma
3164 mips_elf64_local_got_index (abfd, info, value)
3165 bfd *abfd;
3166 struct bfd_link_info *info;
3167 bfd_vma value;
3168 {
3169 CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3170 asection *sgot;
3171 struct mips_elf64_got_info *g;
3172 bfd_byte *entry;
3173
3174 g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3175
3176 /* Look to see if we already have an appropriate entry. */
3177 for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3178 entry != sgot->contents + got_size * g->assigned_gotno;
3179 entry += got_size)
3180 {
3181 bfd_vma address = bfd_get_64 (abfd, entry);
3182 if (address == value)
3183 return entry - sgot->contents;
3184 }
3185
3186 return mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3187 }
3188
3189 /* Find a GOT entry that is within 32KB of the VALUE. These entries
3190 are supposed to be placed at small offsets in the GOT, i.e.,
3191 within 32KB of GP. Return the index into the GOT for this page,
3192 and store the offset from this entry to the desired address in
3193 OFFSETP, if it is non-NULL. */
3194
3195 static bfd_vma
3196 mips_elf64_got_page (abfd, info, value, offsetp)
3197 bfd *abfd;
3198 struct bfd_link_info *info;
3199 bfd_vma value;
3200 bfd_vma *offsetp;
3201 {
3202 CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3203 asection *sgot;
3204 struct mips_elf64_got_info *g;
3205 bfd_byte *entry;
3206 bfd_byte *last_entry;
3207 bfd_vma index = 0;
3208 bfd_vma address;
3209
3210 g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3211
3212 /* Look to see if we aleady have an appropriate entry. */
3213 last_entry = sgot->contents + got_size * g->assigned_gotno;
3214 for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3215 entry != last_entry;
3216 entry += got_size)
3217 {
3218 address = bfd_get_64 (abfd, entry);
3219
3220 if (!mips_elf64_overflow_p (value - address, 16))
3221 {
3222 /* This entry will serve as the page pointer. We can add a
3223 16-bit number to it to get the actual address. */
3224 index = entry - sgot->contents;
3225 break;
3226 }
3227 }
3228
3229 /* If we didn't have an appropriate entry, we create one now. */
3230 if (entry == last_entry)
3231 index = mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3232
3233 if (offsetp)
3234 {
3235 address = bfd_get_64 (abfd, entry);
3236 *offsetp = value - address;
3237 }
3238
3239 return index;
3240 }
3241
3242 /* Find a GOT entry whose higher-order 16 bits are the same as those
3243 for value. Return the index into the GOT for this entry. */
3244
3245 static bfd_vma
3246 mips_elf64_got16_entry (abfd, info, value, external)
3247 bfd *abfd;
3248 struct bfd_link_info *info;
3249 bfd_vma value;
3250 boolean external;
3251 {
3252 CONST bfd_vma got_size = get_elf_backend_data (abfd)->s->arch_size / 8;
3253 asection *sgot;
3254 struct mips_elf64_got_info *g;
3255 bfd_byte *entry;
3256 bfd_byte *last_entry;
3257 bfd_vma index = 0;
3258 bfd_vma address;
3259
3260 if (! external)
3261 {
3262 /* Although the ABI says that it is "the high-order 16 bits" that we
3263 want, it is really the %high value. The complete value is
3264 calculated with a `addiu' of a LO16 relocation, just as with a
3265 HI16/LO16 pair. */
3266 value = mips_elf64_high (value) << 16;
3267 }
3268
3269 g = _mips_elf64_got_info (elf_hash_table (info)->dynobj, &sgot);
3270
3271 /* Look to see if we already have an appropriate entry. */
3272 last_entry = sgot->contents + got_size * g->assigned_gotno;
3273 for (entry = (sgot->contents + got_size * MIPS_RESERVED_GOTNO);
3274 entry != last_entry;
3275 entry += got_size)
3276 {
3277 address = bfd_get_64 (abfd, entry);
3278 if (address == value)
3279 {
3280 /* This entry has the right high-order 16 bits, and the low-order
3281 16 bits are set to zero. */
3282 index = entry - sgot->contents;
3283 break;
3284 }
3285 }
3286
3287 /* If we didn't have an appropriate entry, we create one now. */
3288 if (entry == last_entry)
3289 index = mips_elf64_create_local_got_entry (abfd, g, sgot, value);
3290
3291 return index;
3292 }
3293 \f
3294 /* Return whether a relocation is against a local symbol. */
3295
3296 static boolean
3297 mips_elf64_local_relocation_p (input_bfd, relocation, local_sections,
3298 check_forced)
3299 bfd *input_bfd;
3300 const Elf_Internal_Rela *relocation;
3301 asection **local_sections;
3302 boolean check_forced;
3303 {
3304 unsigned long r_symndx;
3305 Elf_Internal_Shdr *symtab_hdr;
3306 struct mips_elf64_link_hash_entry* h;
3307 size_t extsymoff;
3308
3309 r_symndx = ELF64_R_SYM (relocation->r_info);
3310 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3311 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
3312
3313 if (r_symndx < extsymoff)
3314 return true;
3315 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
3316 return true;
3317
3318 if (check_forced)
3319 {
3320 /* Look up the hash table to check whether the symbol
3321 was forced local. */
3322 h = (struct mips_elf64_link_hash_entry *)
3323 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
3324 /* Find the real hash-table entry for this symbol. */
3325 while (h->root.root.type == bfd_link_hash_indirect
3326 || h->root.root.type == bfd_link_hash_warning)
3327 h = (struct mips_elf64_link_hash_entry *) h->root.root.u.i.link;
3328 if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
3329 return true;
3330 }
3331
3332 return false;
3333 }
3334 \f
3335 /* Returns the first relocation of type r_type found, beginning with
3336 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3337
3338 static const Elf_Internal_Rela *
3339 mips_elf64_next_relocation (r_type, relocation, relend)
3340 unsigned int r_type;
3341 const Elf_Internal_Rela *relocation;
3342 const Elf_Internal_Rela *relend;
3343 {
3344 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
3345 immediately following. However, for the IRIX6 ABI, the next
3346 relocation may be a composed relocation consisting of several
3347 relocations for the same address. In that case, the R_MIPS_LO16
3348 relocation may occur as one of these. We permit a similar
3349 extension in general, as that is useful for GCC. */
3350 while (relocation < relend)
3351 {
3352 if (ELF64_MIPS_R_TYPE (relocation->r_info) == r_type)
3353 return relocation;
3354
3355 ++relocation;
3356 }
3357
3358 /* We didn't find it. */
3359 bfd_set_error (bfd_error_bad_value);
3360 return NULL;
3361 }
3362
3363 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3364 is the original relocation, which is now being transformed into a
3365 dynamic relocation. The ADDENDP is adjusted if necessary; the
3366 caller should store the result in place of the original addend. */
3367
3368 static boolean
3369 mips_elf64_create_dynamic_relocation (output_bfd, info, rel, h, sec,
3370 symbol, addendp, input_section)
3371 bfd *output_bfd;
3372 struct bfd_link_info *info;
3373 const Elf_Internal_Rela *rel;
3374 struct mips_elf64_link_hash_entry *h;
3375 asection *sec;
3376 bfd_vma symbol;
3377 bfd_vma *addendp;
3378 asection *input_section;
3379 {
3380 Elf_Internal_Rel outrel[3];
3381 boolean skip;
3382 asection *sreloc;
3383 bfd *dynobj;
3384 int r_type;
3385
3386 r_type = ELF64_MIPS_R_TYPE (rel->r_info);
3387 dynobj = elf_hash_table (info)->dynobj;
3388 sreloc = bfd_get_section_by_name (dynobj, ".rel.dyn");
3389 BFD_ASSERT (sreloc != NULL);
3390 BFD_ASSERT (sreloc->contents != NULL);
3391 BFD_ASSERT ((sreloc->reloc_count
3392 * get_elf_backend_data (output_bfd)->s->sizeof_rel)
3393 < sreloc->_raw_size);
3394
3395 skip = false;
3396 outrel[0].r_offset = _bfd_elf_section_offset (output_bfd, info,
3397 input_section,
3398 rel[0].r_offset);
3399
3400 /* We begin by assuming that the offset for the dynamic relocation
3401 is the same as for the original relocation. We'll adjust this
3402 later to reflect the correct output offsets. */
3403 if (elf_section_data (input_section)->sec_info_type != ELF_INFO_TYPE_STABS)
3404 {
3405 outrel[1].r_offset = rel[1].r_offset;
3406 outrel[2].r_offset = rel[2].r_offset;
3407 }
3408 else
3409 {
3410 /* Except that in a stab section things are more complex.
3411 Because we compress stab information, the offset given in the
3412 relocation may not be the one we want; we must let the stabs
3413 machinery tell us the offset. */
3414 outrel[1].r_offset = outrel[0].r_offset;
3415 outrel[2].r_offset = outrel[0].r_offset;
3416 /* If we didn't need the relocation at all, this value will be
3417 -1. */
3418 if (outrel[0].r_offset == (bfd_vma) -1)
3419 skip = true;
3420 }
3421
3422 /* If we've decided to skip this relocation, just output an empty
3423 record. Note that R_MIPS_NONE == 0, so that this call to memset
3424 is a way of setting R_TYPE to R_MIPS_NONE. */
3425 if (skip)
3426 memset (outrel, 0, sizeof (Elf_Internal_Rel) * 3);
3427 else
3428 {
3429 long indx;
3430 bfd_vma section_offset;
3431
3432 /* We must now calculate the dynamic symbol table index to use
3433 in the relocation. */
3434 if (h != NULL
3435 && (! info->symbolic || (h->root.elf_link_hash_flags
3436 & ELF_LINK_HASH_DEF_REGULAR) == 0))
3437 {
3438 indx = h->root.dynindx;
3439 /* h->root.dynindx may be -1 if this symbol was marked to
3440 become local. */
3441 if (indx == -1)
3442 indx = 0;
3443 }
3444 else
3445 {
3446 if (sec != NULL && bfd_is_abs_section (sec))
3447 indx = 0;
3448 else if (sec == NULL || sec->owner == NULL)
3449 {
3450 bfd_set_error (bfd_error_bad_value);
3451 return false;
3452 }
3453 else
3454 {
3455 indx = elf_section_data (sec->output_section)->dynindx;
3456 if (indx == 0)
3457 abort ();
3458 }
3459
3460 /* Figure out how far the target of the relocation is from
3461 the beginning of its section. */
3462 section_offset = symbol - sec->output_section->vma;
3463 /* The relocation we're building is section-relative.
3464 Therefore, the original addend must be adjusted by the
3465 section offset. */
3466 *addendp += section_offset;
3467 /* Now, the relocation is just against the section. */
3468 symbol = sec->output_section->vma;
3469 }
3470
3471 /* If the relocation was previously an absolute relocation and
3472 this symbol will not be referred to by the relocation, we must
3473 adjust it by the value we give it in the dynamic symbol table.
3474 Otherwise leave the job up to the dynamic linker. */
3475 if (!indx && r_type != R_MIPS_REL32)
3476 *addendp += symbol;
3477
3478 /* The relocation is always an REL32 relocation because we don't
3479 know where the shared library will wind up at load-time. */
3480 outrel[0].r_info = ELF64_R_INFO (indx, R_MIPS_REL32);
3481
3482 /* Adjust the output offset of the relocation to reference the
3483 correct location in the output file. */
3484 outrel[0].r_offset += (input_section->output_section->vma
3485 + input_section->output_offset);
3486 outrel[1].r_offset += (input_section->output_section->vma
3487 + input_section->output_offset);
3488 outrel[2].r_offset += (input_section->output_section->vma
3489 + input_section->output_offset);
3490 }
3491
3492 /* Put the relocation back out. */
3493 mips_elf64_be_swap_reloc_out (output_bfd, outrel,
3494 (sreloc->contents
3495 + sreloc->reloc_count
3496 * sizeof (Elf64_Mips_External_Rel)));
3497
3498 /* Record the index of the first relocation referencing H. This
3499 information is later emitted in the .msym section. */
3500 if (h != NULL
3501 && (h->min_dyn_reloc_index == 0
3502 || sreloc->reloc_count < h->min_dyn_reloc_index))
3503 h->min_dyn_reloc_index = sreloc->reloc_count;
3504
3505 /* We've now added another relocation. */
3506 ++sreloc->reloc_count;
3507
3508 /* Make sure the output section is writable. The dynamic linker
3509 will be writing to it. */
3510 elf_section_data (input_section->output_section)->this_hdr.sh_flags
3511 |= SHF_WRITE;
3512
3513 return true;
3514 }
3515
3516 /* Calculate the value produced by the RELOCATION (which comes from
3517 the INPUT_BFD). The ADDEND is the addend to use for this
3518 RELOCATION; RELOCATION->R_ADDEND is ignored.
3519
3520 The result of the relocation calculation is stored in VALUEP.
3521 REQUIRE_JALXP indicates whether or not the opcode used with this
3522 relocation must be JALX.
3523
3524 This function returns bfd_reloc_continue if the caller need take no
3525 further action regarding this relocation, bfd_reloc_notsupported if
3526 something goes dramatically wrong, bfd_reloc_overflow if an
3527 overflow occurs, and bfd_reloc_ok to indicate success. */
3528
3529 static bfd_reloc_status_type
3530 mips_elf64_calculate_relocation (abfd, input_bfd, input_section, info,
3531 relocation, addend, howto, local_syms,
3532 local_sections, valuep, namep, require_jalxp)
3533 bfd *abfd;
3534 bfd *input_bfd;
3535 asection *input_section;
3536 struct bfd_link_info *info;
3537 const Elf_Internal_Rela *relocation;
3538 bfd_vma addend;
3539 reloc_howto_type *howto;
3540 Elf_Internal_Sym *local_syms;
3541 asection **local_sections;
3542 bfd_vma *valuep;
3543 const char **namep;
3544 boolean *require_jalxp;
3545 {
3546 /* The eventual value we will return. */
3547 bfd_vma value;
3548 /* The address of the symbol against which the relocation is
3549 occurring. */
3550 bfd_vma symbol = 0;
3551 /* The final GP value to be used for the relocatable, executable, or
3552 shared object file being produced. */
3553 bfd_vma gp = (bfd_vma) - 1;
3554 /* The place (section offset or address) of the storage unit being
3555 relocated. */
3556 bfd_vma p;
3557 /* The value of GP used to create the relocatable object. */
3558 bfd_vma gp0 = (bfd_vma) - 1;
3559 /* The offset into the global offset table at which the address of
3560 the relocation entry symbol, adjusted by the addend, resides
3561 during execution. */
3562 bfd_vma g = (bfd_vma) - 1;
3563 /* The section in which the symbol referenced by the relocation is
3564 located. */
3565 asection *sec = NULL;
3566 struct mips_elf64_link_hash_entry* h = NULL;
3567 /* True if the symbol referred to by this relocation is a local
3568 symbol. */
3569 boolean local_p;
3570 Elf_Internal_Shdr *symtab_hdr;
3571 size_t extsymoff;
3572 unsigned long r_symndx;
3573 int r_type;
3574 /* True if overflow occurred during the calculation of the
3575 relocation value. */
3576 boolean overflowed_p;
3577 /* True if this relocation refers to a MIPS16 function. */
3578 boolean target_is_16_bit_code_p = false;
3579
3580 /* Parse the relocation. */
3581 r_symndx = ELF64_R_SYM (relocation->r_info);
3582 r_type = ELF64_MIPS_R_TYPE (relocation->r_info);
3583 p = (input_section->output_section->vma
3584 + input_section->output_offset
3585 + relocation->r_offset);
3586
3587 /* Assume that there will be no overflow. */
3588 overflowed_p = false;
3589
3590 /* Figure out whether or not the symbol is local, and get the offset
3591 used in the array of hash table entries. */
3592 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3593 local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3594 local_sections, false);
3595 if (! elf_bad_symtab (input_bfd))
3596 extsymoff = symtab_hdr->sh_info;
3597 else
3598 {
3599 /* The symbol table does not follow the rule that local symbols
3600 must come before globals. */
3601 extsymoff = 0;
3602 }
3603
3604 /* Figure out the value of the symbol. */
3605 if (local_p)
3606 {
3607 Elf_Internal_Sym *sym;
3608
3609 sym = local_syms + r_symndx;
3610 sec = local_sections[r_symndx];
3611
3612 symbol = sec->output_section->vma + sec->output_offset;
3613 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3614 symbol += sym->st_value;
3615
3616 /* MIPS16 text labels should be treated as odd. */
3617 if (sym->st_other == STO_MIPS16)
3618 ++symbol;
3619
3620 /* Record the name of this symbol, for our caller. */
3621 *namep = bfd_elf_string_from_elf_section (input_bfd,
3622 symtab_hdr->sh_link,
3623 sym->st_name);
3624 if (*namep == '\0')
3625 *namep = bfd_section_name (input_bfd, sec);
3626
3627 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3628 }
3629 else
3630 {
3631 /* For global symbols we look up the symbol in the hash-table. */
3632 h = ((struct mips_elf64_link_hash_entry *)
3633 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3634 /* Find the real hash-table entry for this symbol. */
3635 while (h->root.root.type == bfd_link_hash_indirect
3636 || h->root.root.type == bfd_link_hash_warning)
3637 h = (struct mips_elf64_link_hash_entry *) h->root.root.u.i.link;
3638
3639 /* Record the name of this symbol, for our caller. */
3640 *namep = h->root.root.root.string;
3641
3642 /* If this symbol is defined, calculate its address. */
3643 if ((h->root.root.type == bfd_link_hash_defined
3644 || h->root.root.type == bfd_link_hash_defweak)
3645 && h->root.root.u.def.section)
3646 {
3647 sec = h->root.root.u.def.section;
3648 if (sec->output_section)
3649 symbol = (h->root.root.u.def.value
3650 + sec->output_section->vma
3651 + sec->output_offset);
3652 else
3653 symbol = h->root.root.u.def.value;
3654 }
3655 else if (h->root.root.type == bfd_link_hash_undefweak)
3656 /* We allow relocations against undefined weak symbols, giving
3657 it the value zero, so that you can undefined weak functions
3658 and check to see if they exist by looking at their
3659 addresses. */
3660 symbol = 0;
3661 else if (info->shared
3662 && (!info->symbolic || info->allow_shlib_undefined)
3663 && !info->no_undefined
3664 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3665 symbol = 0;
3666 else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
3667 strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
3668 {
3669 /* If this is a dynamic link, we should have created a
3670 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3671 in in mips_elf64_create_dynamic_sections.
3672 Otherwise, we should define the symbol with a value of 0.
3673 FIXME: It should probably get into the symbol table
3674 somehow as well. */
3675 BFD_ASSERT (! info->shared);
3676 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3677 symbol = 0;
3678 }
3679 else
3680 {
3681 if (! ((*info->callbacks->undefined_symbol)
3682 (info, h->root.root.root.string, input_bfd,
3683 input_section, relocation->r_offset,
3684 (!info->shared || info->no_undefined
3685 || ELF_ST_VISIBILITY (h->root.other)))))
3686 return bfd_reloc_undefined;
3687 symbol = 0;
3688 }
3689
3690 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3691 }
3692
3693 /* If this is a 64-bit call to a 16-bit function with a stub, we
3694 need to redirect the call to the stub, unless we're already *in*
3695 a stub. */
3696 if (r_type != R_MIPS16_26 && !info->relocateable
3697 && ((h != NULL && h->fn_stub != NULL)
3698 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3699 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3700 && !mips_elf64_stub_section_p (input_bfd, input_section))
3701 {
3702 /* This is a 64-bit call to a 16-bit function. We should
3703 have already noticed that we were going to need the
3704 stub. */
3705 if (local_p)
3706 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3707 else
3708 {
3709 BFD_ASSERT (h->need_fn_stub);
3710 sec = h->fn_stub;
3711 }
3712
3713 symbol = sec->output_section->vma + sec->output_offset;
3714 }
3715 /* If this is a 16-bit call to a 64-bit function with a stub, we
3716 need to redirect the call to the stub. */
3717 else if (r_type == R_MIPS16_26 && !info->relocateable
3718 && h != NULL
3719 && (h->call_stub != NULL || h->call_fp_stub != NULL)
3720 && !target_is_16_bit_code_p)
3721 {
3722 /* If both call_stub and call_fp_stub are defined, we can figure
3723 out which one to use by seeing which one appears in the input
3724 file. */
3725 if (h->call_stub != NULL && h->call_fp_stub != NULL)
3726 {
3727 asection *o;
3728
3729 sec = NULL;
3730 for (o = input_bfd->sections; o != NULL; o = o->next)
3731 {
3732 if (strncmp (bfd_get_section_name (input_bfd, o),
3733 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3734 {
3735 sec = h->call_fp_stub;
3736 break;
3737 }
3738 }
3739 if (sec == NULL)
3740 sec = h->call_stub;
3741 }
3742 else if (h->call_stub != NULL)
3743 sec = h->call_stub;
3744 else
3745 sec = h->call_fp_stub;
3746
3747 BFD_ASSERT (sec->_raw_size > 0);
3748 symbol = sec->output_section->vma + sec->output_offset;
3749 }
3750
3751 /* Calls from 16-bit code to 32-bit code and vice versa require the
3752 special jalx instruction. */
3753 *require_jalxp = (!info->relocateable
3754 && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
3755
3756 local_p = mips_elf64_local_relocation_p (input_bfd, relocation,
3757 local_sections, true);
3758
3759 /* If we haven't already determined the GOT offset, or the GP value,
3760 and we're going to need it, get it now. */
3761 switch (r_type)
3762 {
3763 case R_MIPS_CALL16:
3764 case R_MIPS_GOT16:
3765 case R_MIPS_GOT_DISP:
3766 case R_MIPS_GOT_HI16:
3767 case R_MIPS_CALL_HI16:
3768 case R_MIPS_GOT_LO16:
3769 case R_MIPS_CALL_LO16:
3770 /* Find the index into the GOT where this value is located. */
3771 if (!local_p)
3772 {
3773 BFD_ASSERT (addend == 0);
3774 g = mips_elf64_global_got_index (elf_hash_table (info)->dynobj,
3775 (struct elf_link_hash_entry*) h);
3776 if (! elf_hash_table(info)->dynamic_sections_created
3777 || (info->shared
3778 && (info->symbolic || h->root.dynindx == -1)
3779 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3780 {
3781 /* This is a static link or a -Bsymbolic link. The
3782 symbol is defined locally, or was forced to be local.
3783 We must initialize this entry in the GOT. */
3784 bfd *tmpbfd = elf_hash_table (info)->dynobj;
3785
3786 asection *sgot = bfd_get_section_by_name (tmpbfd, ".got");
3787 bfd_put_64 (tmpbfd, symbol + addend, sgot->contents + g);
3788 }
3789 }
3790 else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3791 /* There's no need to create a local GOT entry here; the
3792 calculation for a local GOT16 entry does not involve G. */
3793 break;
3794 else
3795 {
3796 g = mips_elf64_local_got_index (abfd, info, symbol + addend);
3797 if (g == (bfd_vma) -1)
3798 return false;
3799 }
3800
3801 /* Convert GOT indices to actual offsets. */
3802 g = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3803 abfd, g);
3804 break;
3805
3806 case R_MIPS_HI16:
3807 case R_MIPS_LO16:
3808 case R_MIPS_GPREL16:
3809 case R_MIPS_GPREL32:
3810 case R_MIPS_LITERAL:
3811 gp0 = _bfd_get_gp_value (input_bfd);
3812 gp = _bfd_get_gp_value (abfd);
3813 break;
3814
3815 default:
3816 break;
3817 }
3818
3819 /* Figure out what kind of relocation is being performed. */
3820 switch (r_type)
3821 {
3822 case R_MIPS_NONE:
3823 return bfd_reloc_continue;
3824
3825 case R_MIPS_16:
3826 value = symbol + mips_elf64_sign_extend (addend, 16);
3827 overflowed_p = mips_elf64_overflow_p (value, 16);
3828 break;
3829
3830 case R_MIPS_32:
3831 case R_MIPS_REL32:
3832 case R_MIPS_64:
3833 if ((info->shared
3834 || (elf_hash_table (info)->dynamic_sections_created
3835 && h != NULL
3836 && ((h->root.elf_link_hash_flags
3837 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3838 && ((h->root.elf_link_hash_flags
3839 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3840 && r_symndx != 0
3841 && (input_section->flags & SEC_ALLOC) != 0)
3842 {
3843 /* If we're creating a shared library, or this relocation is
3844 against a symbol in a shared library, then we can't know
3845 where the symbol will end up. So, we create a relocation
3846 record in the output, and leave the job up to the dynamic
3847 linker. */
3848 value = addend;
3849 if (!mips_elf64_create_dynamic_relocation (abfd, info, relocation,
3850 h, sec, symbol, &value,
3851 input_section))
3852 return false;
3853 }
3854 else
3855 {
3856 if (r_type != R_MIPS_REL32)
3857 value = symbol + addend;
3858 else
3859 value = addend;
3860 }
3861 value &= howto->dst_mask;
3862 break;
3863
3864 case R_MIPS_PC32:
3865 case R_MIPS_PC64:
3866 case R_MIPS_GNU_REL_LO16:
3867 value = symbol + addend - p;
3868 value &= howto->dst_mask;
3869 break;
3870
3871 case R_MIPS_GNU_REL16_S2:
3872 value = symbol + mips_elf64_sign_extend (addend << 2, 18) - p;
3873 overflowed_p = mips_elf64_overflow_p (value, 18);
3874 value = (value >> 2) & howto->dst_mask;
3875 break;
3876
3877 case R_MIPS_GNU_REL_HI16:
3878 value = mips_elf64_high (addend + symbol - p);
3879 value &= howto->dst_mask;
3880 break;
3881
3882 case R_MIPS16_26:
3883 /* The calculation for R_MIPS16_26 is just the same as for an
3884 R_MIPS_26. It's only the storage of the relocated field into
3885 the output file that's different. That's handled in
3886 mips_elf_perform_relocation. So, we just fall through to the
3887 R_MIPS_26 case here. */
3888 case R_MIPS_26:
3889 if (local_p)
3890 value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3891 else
3892 value = (mips_elf64_sign_extend (addend << 2, 28) + symbol) >> 2;
3893 value &= howto->dst_mask;
3894 break;
3895
3896 case R_MIPS_HI16:
3897 value = mips_elf64_high (addend + symbol);
3898 value &= howto->dst_mask;
3899 break;
3900
3901 case R_MIPS_LO16:
3902 value = (addend + symbol) & 0xffff;
3903 value &= howto->dst_mask;
3904 break;
3905
3906 case R_MIPS_LITERAL:
3907 /* Because we don't merge literal sections, we can handle this
3908 just like R_MIPS_GPREL16. In the long run, we should merge
3909 shared literals, and then we will need to additional work
3910 here. */
3911
3912 /* Fall through. */
3913
3914 case R_MIPS_GPREL16:
3915 if (local_p)
3916 value = mips_elf64_sign_extend (addend, 16) + symbol + gp0 - gp;
3917 else
3918 value = mips_elf64_sign_extend (addend, 16) + symbol - gp;
3919 overflowed_p = mips_elf64_overflow_p (value, 16);
3920 break;
3921
3922 case R_MIPS_PC16:
3923 value = mips_elf64_sign_extend (addend, 16) + symbol - p;
3924 overflowed_p = mips_elf64_overflow_p (value, 16);
3925 value = (bfd_vma) ((bfd_signed_vma) value / 4);
3926 break;
3927
3928 case R_MIPS_GOT16:
3929 case R_MIPS_CALL16:
3930 if (local_p)
3931 {
3932 boolean forced;
3933
3934 /* The special case is when the symbol is forced to be local. We
3935 need the full address in the GOT since no R_MIPS_LO16 relocation
3936 follows. */
3937 forced = ! mips_elf64_local_relocation_p (input_bfd, relocation,
3938 local_sections, false);
3939 value = mips_elf64_got16_entry (abfd, info, symbol + addend, forced);
3940 if (value == (bfd_vma) -1)
3941 return false;
3942 value
3943 = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3944 abfd,
3945 value);
3946 overflowed_p = mips_elf64_overflow_p (value, 16);
3947 break;
3948 }
3949
3950 /* Fall through. */
3951
3952 case R_MIPS_GOT_DISP:
3953 value = g;
3954 overflowed_p = mips_elf64_overflow_p (value, 16);
3955 break;
3956
3957 case R_MIPS_GPREL32:
3958 value = (addend + symbol + gp0 - gp) & howto->dst_mask;
3959 break;
3960
3961 case R_MIPS_GOT_HI16:
3962 case R_MIPS_CALL_HI16:
3963 /* We're allowed to handle these two relocations identically.
3964 The dynamic linker is allowed to handle the CALL relocations
3965 differently by creating a lazy evaluation stub. */
3966 value = g;
3967 value = mips_elf64_high (value);
3968 value &= howto->dst_mask;
3969 break;
3970
3971 case R_MIPS_GOT_LO16:
3972 case R_MIPS_CALL_LO16:
3973 value = g & howto->dst_mask;
3974 break;
3975
3976 case R_MIPS_GOT_PAGE:
3977 value = mips_elf64_got_page (abfd, info, symbol + addend, NULL);
3978 if (value == (bfd_vma) -1)
3979 return false;
3980 value = mips_elf64_got_offset_from_index (elf_hash_table (info)->dynobj,
3981 abfd,
3982 value);
3983 overflowed_p = mips_elf64_overflow_p (value, 16);
3984 break;
3985
3986 case R_MIPS_GOT_OFST:
3987 mips_elf64_got_page (abfd, info, symbol + addend, &value);
3988 overflowed_p = mips_elf64_overflow_p (value, 16);
3989 break;
3990
3991 case R_MIPS_SUB:
3992 value = symbol - addend;
3993 value &= howto->dst_mask;
3994 break;
3995
3996 case R_MIPS_HIGHER:
3997 value = mips_elf64_higher (addend + symbol);
3998 value &= howto->dst_mask;
3999 break;
4000
4001 case R_MIPS_HIGHEST:
4002 value = mips_elf64_highest (addend + symbol);
4003 value &= howto->dst_mask;
4004 break;
4005
4006 case R_MIPS_SCN_DISP:
4007 value = symbol + addend - sec->output_offset;
4008 value &= howto->dst_mask;
4009 break;
4010
4011 case R_MIPS_PJUMP:
4012 case R_MIPS_JALR:
4013 /* Both of these may be ignored. R_MIPS_JALR is an optimization
4014 hint; we could improve performance by honoring that hint. */
4015 return bfd_reloc_continue;
4016
4017 case R_MIPS_GNU_VTINHERIT:
4018 case R_MIPS_GNU_VTENTRY:
4019 /* We don't do anything with these at present. */
4020 return bfd_reloc_continue;
4021
4022 default:
4023 /* An unrecognized relocation type. */
4024 return bfd_reloc_notsupported;
4025 }
4026
4027 /* Store the VALUE for our caller. */
4028 *valuep = value;
4029 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
4030 }
4031 \f
4032 /* Obtain the field relocated by RELOCATION. */
4033
4034 static bfd_vma
4035 mips_elf64_obtain_contents (howto, relocation, input_bfd, contents)
4036 reloc_howto_type *howto;
4037 const Elf_Internal_Rela *relocation;
4038 bfd *input_bfd;
4039 bfd_byte *contents;
4040 {
4041 bfd_byte *location = contents + relocation->r_offset;
4042
4043 /* Obtain the bytes. */
4044 return bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
4045 }
4046
4047 /* It has been determined that the result of the RELOCATION is the
4048 VALUE. Use HOWTO to place VALUE into the output file at the
4049 appropriate position. The SECTION is the section to which the
4050 relocation applies. If REQUIRE_JALX is true, then the opcode used
4051 for the relocation must be either JAL or JALX, and it is
4052 unconditionally converted to JALX.
4053
4054 Returns false if anything goes wrong. */
4055
4056 static boolean
4057 mips_elf64_perform_relocation (info, howto, relocation, value,
4058 input_bfd, input_section,
4059 contents, require_jalx)
4060 struct bfd_link_info *info;
4061 reloc_howto_type *howto;
4062 const Elf_Internal_Rela *relocation;
4063 bfd_vma value;
4064 bfd *input_bfd;
4065 asection *input_section;
4066 bfd_byte *contents;
4067 boolean require_jalx;
4068 {
4069 bfd_vma x;
4070 bfd_byte *location;
4071 int r_type = ELF32_R_TYPE (relocation->r_info);
4072
4073 /* Figure out where the relocation is occurring. */
4074 location = contents + relocation->r_offset;
4075
4076 /* Obtain the current value. */
4077 x = mips_elf64_obtain_contents (howto, relocation, input_bfd, contents);
4078
4079 /* Clear the field we are setting. */
4080 x &= ~howto->dst_mask;
4081
4082 /* If this is the R_MIPS16_26 relocation, we must store the
4083 value in a funny way. */
4084 if (r_type == R_MIPS16_26)
4085 {
4086 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
4087 Most mips16 instructions are 16 bits, but these instructions
4088 are 32 bits.
4089
4090 The format of these instructions is:
4091
4092 +--------------+--------------------------------+
4093 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
4094 +--------------+--------------------------------+
4095 ! Immediate 15:0 !
4096 +-----------------------------------------------+
4097
4098 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
4099 Note that the immediate value in the first word is swapped.
4100
4101 When producing a relocateable object file, R_MIPS16_26 is
4102 handled mostly like R_MIPS_26. In particular, the addend is
4103 stored as a straight 26-bit value in a 32-bit instruction.
4104 (gas makes life simpler for itself by never adjusting a
4105 R_MIPS16_26 reloc to be against a section, so the addend is
4106 always zero). However, the 32 bit instruction is stored as 2
4107 16-bit values, rather than a single 32-bit value. In a
4108 big-endian file, the result is the same; in a little-endian
4109 file, the two 16-bit halves of the 32 bit value are swapped.
4110 This is so that a disassembler can recognize the jal
4111 instruction.
4112
4113 When doing a final link, R_MIPS16_26 is treated as a 32 bit
4114 instruction stored as two 16-bit values. The addend A is the
4115 contents of the targ26 field. The calculation is the same as
4116 R_MIPS_26. When storing the calculated value, reorder the
4117 immediate value as shown above, and don't forget to store the
4118 value as two 16-bit values.
4119
4120 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
4121 defined as
4122
4123 big-endian:
4124 +--------+----------------------+
4125 | | |
4126 | | targ26-16 |
4127 |31 26|25 0|
4128 +--------+----------------------+
4129
4130 little-endian:
4131 +----------+------+-------------+
4132 | | | |
4133 | sub1 | | sub2 |
4134 |0 9|10 15|16 31|
4135 +----------+--------------------+
4136 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
4137 ((sub1 << 16) | sub2)).
4138
4139 When producing a relocateable object file, the calculation is
4140 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4141 When producing a fully linked file, the calculation is
4142 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4143 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
4144
4145 if (!info->relocateable)
4146 /* Shuffle the bits according to the formula above. */
4147 value = (((value & 0x1f0000) << 5)
4148 | ((value & 0x3e00000) >> 5)
4149 | (value & 0xffff));
4150 }
4151 else if (r_type == R_MIPS16_GPREL)
4152 {
4153 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
4154 mode. A typical instruction will have a format like this:
4155
4156 +--------------+--------------------------------+
4157 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
4158 +--------------+--------------------------------+
4159 ! Major ! rx ! ry ! Imm 4:0 !
4160 +--------------+--------------------------------+
4161
4162 EXTEND is the five bit value 11110. Major is the instruction
4163 opcode.
4164
4165 This is handled exactly like R_MIPS_GPREL16, except that the
4166 addend is retrieved and stored as shown in this diagram; that
4167 is, the Imm fields above replace the V-rel16 field.
4168
4169 All we need to do here is shuffle the bits appropriately. As
4170 above, the two 16-bit halves must be swapped on a
4171 little-endian system. */
4172 value = (((value & 0x7e0) << 16)
4173 | ((value & 0xf800) << 5)
4174 | (value & 0x1f));
4175 }
4176
4177 /* Set the field. */
4178 x |= (value & howto->dst_mask);
4179
4180 /* If required, turn JAL into JALX. */
4181 if (require_jalx)
4182 {
4183 boolean ok;
4184 bfd_vma opcode = x >> 26;
4185 bfd_vma jalx_opcode;
4186
4187 /* Check to see if the opcode is already JAL or JALX. */
4188 if (r_type == R_MIPS16_26)
4189 {
4190 ok = ((opcode == 0x6) || (opcode == 0x7));
4191 jalx_opcode = 0x7;
4192 }
4193 else
4194 {
4195 ok = ((opcode == 0x3) || (opcode == 0x1d));
4196 jalx_opcode = 0x1d;
4197 }
4198
4199 /* If the opcode is not JAL or JALX, there's a problem. */
4200 if (!ok)
4201 {
4202 (*_bfd_error_handler)
4203 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
4204 bfd_archive_filename (input_bfd),
4205 input_section->name,
4206 (unsigned long) relocation->r_offset);
4207 bfd_set_error (bfd_error_bad_value);
4208 return false;
4209 }
4210
4211 /* Make this the JALX opcode. */
4212 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
4213 }
4214
4215 /* Swap the high- and low-order 16 bits on little-endian systems
4216 when doing a MIPS16 relocation. */
4217 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
4218 && bfd_little_endian (input_bfd))
4219 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
4220
4221 /* Put the value into the output. */
4222 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
4223 return true;
4224 }
4225
4226 /* Returns true if SECTION is a MIPS16 stub section. */
4227
4228 static boolean
4229 mips_elf64_stub_section_p (abfd, section)
4230 bfd *abfd ATTRIBUTE_UNUSED;
4231 asection *section;
4232 {
4233 const char *name = bfd_get_section_name (abfd, section);
4234
4235 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
4236 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
4237 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
4238 }
4239
4240 /* Relocate a MIPS ELF64 section. */
4241
4242 static boolean
4243 mips_elf64_relocate_section (output_bfd, info, input_bfd, input_section,
4244 contents, relocs, local_syms, local_sections)
4245 bfd *output_bfd;
4246 struct bfd_link_info *info;
4247 bfd *input_bfd;
4248 asection *input_section;
4249 bfd_byte *contents;
4250 Elf_Internal_Rela *relocs;
4251 Elf_Internal_Sym *local_syms;
4252 asection **local_sections;
4253 {
4254 Elf_Internal_Rela *rel;
4255 const Elf_Internal_Rela *relend;
4256 bfd_vma addend = 0;
4257 boolean use_saved_addend_p = false;
4258 struct elf_backend_data *bed;
4259
4260 bed = get_elf_backend_data (output_bfd);
4261 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
4262 for (rel = relocs; rel < relend; ++rel)
4263 {
4264 const char *name;
4265 bfd_vma value;
4266 reloc_howto_type *howto;
4267 boolean require_jalx;
4268 /* True if the relocation is a RELA relocation, rather than a
4269 REL relocation. */
4270 boolean rela_relocation_p = true;
4271 int r_type = ELF64_MIPS_R_TYPE (rel->r_info);
4272 const char *msg = (const char *) NULL;
4273
4274 /* Find the relocation howto for this relocation. */
4275 howto = &mips_elf64_howto_table_rela[r_type];
4276
4277 if (!use_saved_addend_p)
4278 {
4279 Elf_Internal_Shdr *rel_hdr;
4280
4281 /* If these relocations were originally of the REL variety,
4282 we must pull the addend out of the field that will be
4283 relocated. Otherwise, we simply use the contents of the
4284 RELA relocation. To determine which flavor or relocation
4285 this is, we depend on the fact that the INPUT_SECTION's
4286 REL_HDR is read before its REL_HDR2. */
4287 rel_hdr = &elf_section_data (input_section)->rel_hdr;
4288 if ((size_t) (rel - relocs)
4289 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
4290 rel_hdr = elf_section_data (input_section)->rel_hdr2;
4291 if (rel_hdr->sh_entsize
4292 == (get_elf_backend_data (input_bfd)->s->sizeof_rel))
4293 {
4294 /* Note that this is a REL relocation. */
4295 rela_relocation_p = false;
4296
4297 /* Find the relocation howto for this relocation. */
4298 howto = &mips_elf64_howto_table_rel[r_type];
4299
4300 /* Get the addend, which is stored in the input file. */
4301 addend = mips_elf64_obtain_contents (howto,
4302 rel,
4303 input_bfd,
4304 contents);
4305 addend &= howto->src_mask;
4306
4307 /* For some kinds of relocations, the ADDEND is a
4308 combination of the addend stored in two different
4309 relocations. */
4310 if (r_type == R_MIPS_HI16
4311 || r_type == R_MIPS_GNU_REL_HI16
4312 || (r_type == R_MIPS_GOT16
4313 && mips_elf64_local_relocation_p (input_bfd, rel,
4314 local_sections, false)))
4315 {
4316 bfd_vma l;
4317 const Elf_Internal_Rela *lo16_relocation;
4318 reloc_howto_type *lo16_howto;
4319 int lo;
4320
4321 /* The combined value is the sum of the HI16 addend,
4322 left-shifted by sixteen bits, and the LO16
4323 addend, sign extended. (Usually, the code does
4324 a `lui' of the HI16 value, and then an `addiu' of
4325 the LO16 value.)
4326
4327 Scan ahead to find a matching LO16 relocation. */
4328 if (r_type == R_MIPS_GNU_REL_HI16)
4329 lo = R_MIPS_GNU_REL_LO16;
4330 else
4331 lo = R_MIPS_LO16;
4332 lo16_relocation
4333 = mips_elf64_next_relocation (lo, rel, relend);
4334 if (lo16_relocation == NULL)
4335 return false;
4336
4337 /* Obtain the addend kept there. */
4338 if (rela_relocation_p == false)
4339 lo16_howto = &mips_elf64_howto_table_rel[lo];
4340 else
4341 lo16_howto = &mips_elf64_howto_table_rela[lo];
4342 l = mips_elf64_obtain_contents (lo16_howto,
4343 lo16_relocation,
4344 input_bfd, contents);
4345 l &= lo16_howto->src_mask;
4346 l = mips_elf64_sign_extend (l, 16);
4347
4348 addend <<= 16;
4349
4350 /* Compute the combined addend. */
4351 addend += l;
4352 }
4353 }
4354 else
4355 addend = rel->r_addend;
4356 }
4357
4358 if (info->relocateable)
4359 {
4360 Elf_Internal_Sym *sym;
4361 unsigned long r_symndx;
4362
4363 /* Since we're just relocating, all we need to do is copy
4364 the relocations back out to the object file, unless
4365 they're against a section symbol, in which case we need
4366 to adjust by the section offset, or unless they're GP
4367 relative in which case we need to adjust by the amount
4368 that we're adjusting GP in this relocateable object. */
4369
4370 if (!mips_elf64_local_relocation_p (input_bfd, rel, local_sections,
4371 false))
4372 /* There's nothing to do for non-local relocations. */
4373 continue;
4374
4375 if (r_type == R_MIPS_GPREL16
4376 || r_type == R_MIPS_GPREL32
4377 || r_type == R_MIPS_LITERAL)
4378 addend -= (_bfd_get_gp_value (output_bfd)
4379 - _bfd_get_gp_value (input_bfd));
4380 else if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4381 /* The addend is stored without its two least
4382 significant bits (which are always zero.) In a
4383 non-relocateable link, calculate_relocation will do
4384 this shift; here, we must do it ourselves. */
4385 addend <<= 2;
4386
4387 r_symndx = ELF64_R_SYM (rel->r_info);
4388 sym = local_syms + r_symndx;
4389 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4390 /* Adjust the addend appropriately. */
4391 addend += local_sections[r_symndx]->output_offset;
4392
4393 #if 0
4394 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
4395 then we only want to write out the high-order 16 bits.
4396 The subsequent R_MIPS_LO16 will handle the low-order bits. */
4397 if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
4398 || r_type == R_MIPS_GNU_REL_HI16)
4399 addend = mips_elf64_high (addend);
4400 else if (r_type == R_MIPS_HIGHER)
4401 addend = mips_elf64_higher (addend);
4402 else if (r_type == R_MIPS_HIGHEST)
4403 addend = mips_elf64_highest (addend);
4404 #endif
4405 /* If the relocation is for an R_MIPS_26 relocation, then
4406 the two low-order bits are not stored in the object file;
4407 they are implicitly zero. */
4408 if (r_type == R_MIPS_26 || r_type == R_MIPS_GNU_REL16_S2)
4409 addend >>= 2;
4410
4411 if (rela_relocation_p)
4412 /* If this is a RELA relocation, just update the addend.
4413 We have to cast away constness for REL. */
4414 rel->r_addend = addend;
4415 else
4416 {
4417 /* Otherwise, we have to write the value back out. Note
4418 that we use the source mask, rather than the
4419 destination mask because the place to which we are
4420 writing will be source of the addend in the final
4421 link. */
4422 addend &= howto->src_mask;
4423
4424 if (!mips_elf64_perform_relocation (info, howto, rel, addend,
4425 input_bfd, input_section,
4426 contents, false))
4427 return false;
4428 }
4429
4430 /* Go on to the next relocation. */
4431 continue;
4432 }
4433
4434 /* In the N32 and 64-bit ABIs there may be multiple consecutive
4435 relocations for the same offset. In that case we are
4436 supposed to treat the output of each relocation as the addend
4437 for the next. */
4438 if (rel + 1 < relend
4439 && rel->r_offset == rel[1].r_offset
4440 && ELF64_MIPS_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
4441 use_saved_addend_p = true;
4442 else
4443 use_saved_addend_p = false;
4444
4445 /* Figure out what value we are supposed to relocate. */
4446 switch (mips_elf64_calculate_relocation (output_bfd, input_bfd,
4447 input_section, info, rel,
4448 addend, howto, local_syms,
4449 local_sections, &value, &name,
4450 &require_jalx))
4451 {
4452 case bfd_reloc_continue:
4453 /* There's nothing to do. */
4454 continue;
4455
4456 case bfd_reloc_undefined:
4457 /* mips_elf64_calculate_relocation already called the
4458 undefined_symbol callback. There's no real point in
4459 trying to perform the relocation at this point, so we
4460 just skip ahead to the next relocation. */
4461 continue;
4462
4463 case bfd_reloc_notsupported:
4464 msg = _("internal error: unsupported relocation error");
4465 info->callbacks->warning
4466 (info, msg, name, input_bfd, input_section, rel->r_offset);
4467 return false;
4468
4469 case bfd_reloc_overflow:
4470 if (use_saved_addend_p)
4471 /* Ignore overflow until we reach the last relocation for
4472 a given location. */
4473 ;
4474 else
4475 {
4476 BFD_ASSERT (name != NULL);
4477 if (! ((*info->callbacks->reloc_overflow)
4478 (info, name, howto->name, (bfd_vma) 0,
4479 input_bfd, input_section, rel->r_offset)))
4480 return false;
4481 }
4482 break;
4483
4484 case bfd_reloc_ok:
4485 break;
4486
4487 default:
4488 abort ();
4489 break;
4490 }
4491
4492 /* If we've got another relocation for the address, keep going
4493 until we reach the last one. */
4494 if (use_saved_addend_p)
4495 {
4496 addend = value;
4497 continue;
4498 }
4499
4500 /* Actually perform the relocation. */
4501 if (!mips_elf64_perform_relocation (info, howto, rel, value, input_bfd,
4502 input_section, contents,
4503 require_jalx))
4504 return false;
4505 }
4506
4507 return true;
4508 }
4509
4510 /* Create dynamic sections when linking against a dynamic object. */
4511
4512 boolean
4513 mips_elf64_create_dynamic_sections (abfd, info)
4514 bfd *abfd;
4515 struct bfd_link_info *info;
4516 {
4517 flagword flags;
4518 register asection *s;
4519
4520 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4521 | SEC_LINKER_CREATED | SEC_READONLY);
4522
4523 /* Mips ABI requests the .dynamic section to be read only. */
4524 s = bfd_get_section_by_name (abfd, ".dynamic");
4525 if (s != NULL)
4526 {
4527 if (! bfd_set_section_flags (abfd, s, flags))
4528 return false;
4529 }
4530
4531 /* We need to create .got section. */
4532 if (! mips_elf64_create_got_section (abfd, info))
4533 return false;
4534
4535 /* Create the .msym section on IRIX6. It is used by the dynamic
4536 linker to speed up dynamic relocations, and to avoid computing
4537 the ELF hash for symbols. */
4538 if (!mips_elf64_create_msym_section (abfd))
4539 return false;
4540
4541 /* Create .stub section. */
4542 if (bfd_get_section_by_name (abfd, ".MIPS.stubs") == NULL)
4543 {
4544 s = bfd_make_section (abfd, ".MIPS.stubs");
4545 if (s == NULL
4546 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4547 || ! bfd_set_section_alignment (abfd, s, 3))
4548 return false;
4549 }
4550
4551 return true;
4552 }
4553
4554 /* Adjust a symbol defined by a dynamic object and referenced by a
4555 regular object. The current definition is in some section of the
4556 dynamic object, but we're not including those sections. We have to
4557 change the definition to something the rest of the link can
4558 understand. */
4559
4560 boolean
4561 mips_elf64_adjust_dynamic_symbol (info, h)
4562 struct bfd_link_info *info;
4563 struct elf_link_hash_entry *h;
4564 {
4565 bfd *dynobj;
4566 struct mips_elf64_link_hash_entry *hmips;
4567 asection *s;
4568
4569 dynobj = elf_hash_table (info)->dynobj;
4570
4571 /* Make sure we know what is going on here. */
4572 BFD_ASSERT (dynobj != NULL
4573 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
4574 || h->weakdef != NULL
4575 || ((h->elf_link_hash_flags
4576 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4577 && (h->elf_link_hash_flags
4578 & ELF_LINK_HASH_REF_REGULAR) != 0
4579 && (h->elf_link_hash_flags
4580 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
4581
4582 /* If this symbol is defined in a dynamic object, we need to copy
4583 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
4584 file. */
4585 hmips = (struct mips_elf64_link_hash_entry *) h;
4586 if (! info->relocateable
4587 && hmips->possibly_dynamic_relocs != 0
4588 && (h->root.type == bfd_link_hash_defweak
4589 || (h->elf_link_hash_flags
4590 & ELF_LINK_HASH_DEF_REGULAR) == 0))
4591 {
4592 mips_elf64_allocate_dynamic_relocations (dynobj,
4593 hmips->possibly_dynamic_relocs);
4594 if (hmips->readonly_reloc)
4595 /* We tell the dynamic linker that there are relocations
4596 against the text segment. */
4597 info->flags |= DF_TEXTREL;
4598 }
4599
4600 /* For a function, create a stub, if allowed. */
4601 if (! hmips->no_fn_stub
4602 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4603 {
4604 if (! elf_hash_table (info)->dynamic_sections_created)
4605 return true;
4606
4607 /* If this symbol is not defined in a regular file, then set
4608 the symbol to the stub location. This is required to make
4609 function pointers compare as equal between the normal
4610 executable and the shared library. */
4611 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4612 {
4613 /* We need .stub section. */
4614 s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
4615 BFD_ASSERT (s != NULL);
4616
4617 h->root.u.def.section = s;
4618 h->root.u.def.value = s->_raw_size;
4619
4620 /* XXX Write this stub address somewhere. */
4621 h->plt.offset = s->_raw_size;
4622
4623 /* Make room for this stub code. */
4624 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4625
4626 /* The last half word of the stub will be filled with the index
4627 of this symbol in .dynsym section. */
4628 return true;
4629 }
4630 }
4631 else if ((h->type == STT_FUNC)
4632 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
4633 {
4634 /* This will set the entry for this symbol in the GOT to 0, and
4635 the dynamic linker will take care of this. */
4636 h->root.u.def.value = 0;
4637 return true;
4638 }
4639
4640 /* If this is a weak symbol, and there is a real definition, the
4641 processor independent code will have arranged for us to see the
4642 real definition first, and we can just use the same value. */
4643 if (h->weakdef != NULL)
4644 {
4645 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
4646 || h->weakdef->root.type == bfd_link_hash_defweak);
4647 h->root.u.def.section = h->weakdef->root.u.def.section;
4648 h->root.u.def.value = h->weakdef->root.u.def.value;
4649 return true;
4650 }
4651
4652 /* This is a reference to a symbol defined by a dynamic object which
4653 is not a function. */
4654
4655 return true;
4656 }
4657
4658 /* This function is called after all the input files have been read,
4659 and the input sections have been assigned to output sections. */
4660
4661 boolean
4662 mips_elf64_always_size_sections (output_bfd, info)
4663 bfd *output_bfd ATTRIBUTE_UNUSED;
4664 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4665 {
4666 if (info->relocateable
4667 || ! mips_elf64_hash_table (info)->mips16_stubs_seen)
4668 return true;
4669
4670 mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
4671 mips_elf64_check_mips16_stubs,
4672 (PTR) NULL);
4673
4674 return true;
4675 }
4676
4677 /* Check the mips16 stubs for a particular symbol, and see if we can
4678 discard them. */
4679
4680 static boolean
4681 mips_elf64_check_mips16_stubs (h, data)
4682 struct mips_elf64_link_hash_entry *h;
4683 PTR data ATTRIBUTE_UNUSED;
4684 {
4685 if (h->fn_stub != NULL
4686 && ! h->need_fn_stub)
4687 {
4688 /* We don't need the fn_stub; the only references to this symbol
4689 are 16 bit calls. Clobber the size to 0 to prevent it from
4690 being included in the link. */
4691 h->fn_stub->_raw_size = 0;
4692 h->fn_stub->_cooked_size = 0;
4693 h->fn_stub->flags &= ~SEC_RELOC;
4694 h->fn_stub->reloc_count = 0;
4695 h->fn_stub->flags |= SEC_EXCLUDE;
4696 }
4697
4698 if (h->call_stub != NULL
4699 && h->root.other == STO_MIPS16)
4700 {
4701 /* We don't need the call_stub; this is a 16 bit function, so
4702 calls from other 16 bit functions are OK. Clobber the size
4703 to 0 to prevent it from being included in the link. */
4704 h->call_stub->_raw_size = 0;
4705 h->call_stub->_cooked_size = 0;
4706 h->call_stub->flags &= ~SEC_RELOC;
4707 h->call_stub->reloc_count = 0;
4708 h->call_stub->flags |= SEC_EXCLUDE;
4709 }
4710
4711 if (h->call_fp_stub != NULL
4712 && h->root.other == STO_MIPS16)
4713 {
4714 /* We don't need the call_stub; this is a 16 bit function, so
4715 calls from other 16 bit functions are OK. Clobber the size
4716 to 0 to prevent it from being included in the link. */
4717 h->call_fp_stub->_raw_size = 0;
4718 h->call_fp_stub->_cooked_size = 0;
4719 h->call_fp_stub->flags &= ~SEC_RELOC;
4720 h->call_fp_stub->reloc_count = 0;
4721 h->call_fp_stub->flags |= SEC_EXCLUDE;
4722 }
4723
4724 return true;
4725 }
4726
4727 /* Set the sizes of the dynamic sections. */
4728
4729 boolean
4730 mips_elf64_size_dynamic_sections (output_bfd, info)
4731 bfd *output_bfd;
4732 struct bfd_link_info *info;
4733 {
4734 bfd *dynobj;
4735 asection *s;
4736 boolean reltext;
4737 struct mips_elf64_got_info *g = NULL;
4738
4739 dynobj = elf_hash_table (info)->dynobj;
4740 BFD_ASSERT (dynobj != NULL);
4741
4742 if (elf_hash_table (info)->dynamic_sections_created)
4743 {
4744 /* Set the contents of the .interp section to the interpreter. */
4745 if (! info->shared)
4746 {
4747 s = bfd_get_section_by_name (dynobj, ".interp");
4748 BFD_ASSERT (s != NULL);
4749 s->_raw_size = strlen ("/usr/lib64/libc.so.1") + 1;
4750 s->contents = (bfd_byte *) "/usr/lib64/libc.so.1";
4751 }
4752 }
4753
4754 /* The check_relocs and adjust_dynamic_symbol entry points have
4755 determined the sizes of the various dynamic sections. Allocate
4756 memory for them. */
4757 reltext = false;
4758 for (s = dynobj->sections; s != NULL; s = s->next)
4759 {
4760 const char *name;
4761 boolean strip;
4762
4763 /* It's OK to base decisions on the section name, because none
4764 of the dynobj section names depend upon the input files. */
4765 name = bfd_get_section_name (dynobj, s);
4766
4767 if ((s->flags & SEC_LINKER_CREATED) == 0)
4768 continue;
4769
4770 strip = false;
4771
4772 if (strncmp (name, ".rel", 4) == 0)
4773 {
4774 if (s->_raw_size == 0)
4775 {
4776 /* We only strip the section if the output section name
4777 has the same name. Otherwise, there might be several
4778 input sections for this output section. FIXME: This
4779 code is probably not needed these days anyhow, since
4780 the linker now does not create empty output sections. */
4781 if (s->output_section != NULL
4782 && strcmp (name,
4783 bfd_get_section_name (s->output_section->owner,
4784 s->output_section)) == 0)
4785 strip = true;
4786 }
4787 else
4788 {
4789 const char *outname;
4790 asection *target;
4791
4792 /* If this relocation section applies to a read only
4793 section, then we probably need a DT_TEXTREL entry.
4794 If the relocation section is .rel.dyn, we always
4795 assert a DT_TEXTREL entry rather than testing whether
4796 there exists a relocation to a read only section or
4797 not. */
4798 outname = bfd_get_section_name (output_bfd,
4799 s->output_section);
4800 target = bfd_get_section_by_name (output_bfd, outname + 4);
4801 if ((target != NULL
4802 && (target->flags & SEC_READONLY) != 0
4803 && (target->flags & SEC_ALLOC) != 0)
4804 || strcmp (outname, "rel.dyn") == 0)
4805 reltext = true;
4806
4807 /* We use the reloc_count field as a counter if we need
4808 to copy relocs into the output file. */
4809 if (strcmp (name, "rel.dyn") != 0)
4810 s->reloc_count = 0;
4811 }
4812 }
4813 else if (strncmp (name, ".got", 4) == 0)
4814 {
4815 int i;
4816 bfd_size_type loadable_size = 0;
4817 bfd_size_type local_gotno;
4818 bfd *sub;
4819
4820 BFD_ASSERT (elf_section_data (s) != NULL);
4821 g = (struct mips_elf64_got_info *) elf_section_data (s)->tdata;
4822 BFD_ASSERT (g != NULL);
4823
4824 /* Calculate the total loadable size of the output. That
4825 will give us the maximum number of GOT_PAGE entries
4826 required. */
4827 for (sub = info->input_bfds; sub; sub = sub->link_next)
4828 {
4829 asection *subsection;
4830
4831 for (subsection = sub->sections;
4832 subsection;
4833 subsection = subsection->next)
4834 {
4835 if ((subsection->flags & SEC_ALLOC) == 0)
4836 continue;
4837 loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
4838 }
4839 }
4840 loadable_size += MIPS_FUNCTION_STUB_SIZE;
4841
4842 /* Assume there are two loadable segments consisting of
4843 contiguous sections. Is 5 enough? */
4844 local_gotno = (loadable_size >> 16) + 5;
4845 /* It's possible we will need GOT_PAGE entries as well as
4846 GOT16 entries. Often, these will be able to share GOT
4847 entries, but not always. */
4848 local_gotno *= 2;
4849
4850 g->local_gotno += local_gotno;
4851 s->_raw_size += local_gotno * 8;
4852
4853 /* There has to be a global GOT entry for every symbol with
4854 a dynamic symbol table index of DT_MIPS_GOTSYM or
4855 higher. Therefore, it make sense to put those symbols
4856 that need GOT entries at the end of the symbol table. We
4857 do that here. */
4858 if (!mips_elf64_sort_hash_table (info, 1))
4859 return false;
4860
4861 if (g->global_gotsym != NULL)
4862 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
4863 else
4864 /* If there are no global symbols, or none requiring
4865 relocations, then GLOBAL_GOTSYM will be NULL. */
4866 i = 0;
4867 g->global_gotno = i;
4868 s->_raw_size += i * 8;
4869 }
4870 else if (strcmp (name, ".MIPS.stubs") == 0)
4871 {
4872 /* Irix rld assumes that the function stub isn't at the end
4873 of .text section. So put a dummy. XXX */
4874 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
4875 }
4876 else if (strcmp (name, ".msym")
4877 == 0)
4878 s->_raw_size = (sizeof (Elf32_External_Msym)
4879 * (elf_hash_table (info)->dynsymcount
4880 + bfd_count_sections (output_bfd)));
4881 else if (strncmp (name, ".init", 5) != 0)
4882 {
4883 /* It's not one of our sections, so don't allocate space. */
4884 continue;
4885 }
4886
4887 if (strip)
4888 {
4889 _bfd_strip_section_from_output (info, s);
4890 continue;
4891 }
4892
4893 /* Allocate memory for the section contents. */
4894 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4895 if (s->contents == NULL && s->_raw_size != 0)
4896 {
4897 bfd_set_error (bfd_error_no_memory);
4898 return false;
4899 }
4900 }
4901
4902 if (elf_hash_table (info)->dynamic_sections_created)
4903 {
4904 /* Add some entries to the .dynamic section. We fill in the
4905 values later, in elf_mips_finish_dynamic_sections, but we
4906 must add the entries now so that we get the correct size for
4907 the .dynamic section. The DT_DEBUG entry is filled in by the
4908 dynamic linker and used by the debugger. */
4909 if (! info->shared)
4910 {
4911 /* SGI object has the equivalence of DT_DEBUG in the
4912 DT_MIPS_RLD_MAP entry. */
4913 if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_MAP, 0))
4914 return false;
4915 if (!SGI_COMPAT (output_bfd))
4916 {
4917 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4918 return false;
4919 }
4920 }
4921 else
4922 {
4923 /* Shared libraries on traditional mips have DT_DEBUG. */
4924 if (!SGI_COMPAT (output_bfd))
4925 {
4926 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
4927 return false;
4928 }
4929 }
4930
4931 if (reltext && SGI_COMPAT (output_bfd))
4932 info->flags |= DF_TEXTREL;
4933
4934 if ((info->flags & DF_TEXTREL) != 0)
4935 {
4936 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
4937 return false;
4938 }
4939
4940 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
4941 return false;
4942
4943 if (bfd_get_section_by_name (dynobj, "rel.dyn"))
4944 {
4945 if (! bfd_elf64_add_dynamic_entry (info, DT_REL, 0))
4946 return false;
4947
4948 if (! bfd_elf64_add_dynamic_entry (info, DT_RELSZ, 0))
4949 return false;
4950
4951 if (! bfd_elf64_add_dynamic_entry (info, DT_RELENT, 0))
4952 return false;
4953 }
4954
4955 if (SGI_COMPAT (output_bfd))
4956 {
4957 if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICTNO, 0))
4958 return false;
4959 }
4960
4961 if (SGI_COMPAT (output_bfd))
4962 {
4963 if (!bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLISTNO, 0))
4964 return false;
4965 }
4966
4967 if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
4968 {
4969 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_CONFLICT, 0))
4970 return false;
4971
4972 s = bfd_get_section_by_name (dynobj, ".liblist");
4973 BFD_ASSERT (s != NULL);
4974
4975 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LIBLIST, 0))
4976 return false;
4977 }
4978
4979 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_RLD_VERSION, 0))
4980 return false;
4981
4982 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_FLAGS, 0))
4983 return false;
4984
4985 #if 0
4986 /* Time stamps in executable files are a bad idea. */
4987 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_TIME_STAMP, 0))
4988 return false;
4989 #endif
4990
4991 #if 0 /* FIXME */
4992 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_ICHECKSUM, 0))
4993 return false;
4994 #endif
4995
4996 #if 0 /* FIXME */
4997 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_IVERSION, 0))
4998 return false;
4999 #endif
5000
5001 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_BASE_ADDRESS, 0))
5002 return false;
5003
5004 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_LOCAL_GOTNO, 0))
5005 return false;
5006
5007 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_SYMTABNO, 0))
5008 return false;
5009
5010 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_UNREFEXTNO, 0))
5011 return false;
5012
5013 if (! bfd_elf64_add_dynamic_entry (info, DT_MIPS_GOTSYM, 0))
5014 return false;
5015
5016 if ((bfd_get_section_by_name(dynobj, ".MIPS.options"))
5017 && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_OPTIONS, 0))
5018 return false;
5019
5020 if (bfd_get_section_by_name (dynobj, ".msym")
5021 && !bfd_elf64_add_dynamic_entry (info, DT_MIPS_MSYM, 0))
5022 return false;
5023 }
5024
5025 return true;
5026 }
5027
5028 /* Finish up dynamic symbol handling. We set the contents of various
5029 dynamic sections here. */
5030
5031 boolean
5032 mips_elf64_finish_dynamic_symbol (output_bfd, info, h, sym)
5033 bfd *output_bfd;
5034 struct bfd_link_info *info;
5035 struct elf_link_hash_entry *h;
5036 Elf_Internal_Sym *sym;
5037 {
5038 bfd *dynobj;
5039 bfd_vma gval;
5040 asection *sgot;
5041 asection *smsym;
5042 struct mips_elf64_got_info *g;
5043 const char *name;
5044 struct mips_elf64_link_hash_entry *mh;
5045
5046 dynobj = elf_hash_table (info)->dynobj;
5047 gval = sym->st_value;
5048 mh = (struct mips_elf64_link_hash_entry *) h;
5049
5050 if (h->plt.offset != (bfd_vma) -1)
5051 {
5052 asection *s;
5053 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
5054
5055 /* This symbol has a stub. Set it up. */
5056
5057 BFD_ASSERT (h->dynindx != -1);
5058
5059 s = bfd_get_section_by_name (dynobj, ".MIPS.stubs");
5060 BFD_ASSERT (s != NULL);
5061
5062 /* FIXME: Can h->dynindex be more than 64K? */
5063 if (h->dynindx & 0xffff0000)
5064 return false;
5065
5066 /* Fill the stub. */
5067 bfd_put_32 (output_bfd, STUB_LW, stub);
5068 bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
5069 bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
5070 bfd_put_32 (output_bfd, STUB_LI16 + h->dynindx, stub + 12);
5071
5072 BFD_ASSERT (h->plt.offset <= s->_raw_size);
5073 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
5074
5075 /* Mark the symbol as undefined. plt.offset != -1 occurs
5076 only for the referenced symbol. */
5077 sym->st_shndx = SHN_UNDEF;
5078
5079 /* The run-time linker uses the st_value field of the symbol
5080 to reset the global offset table entry for this external
5081 to its stub address when unlinking a shared object. */
5082 gval = s->output_section->vma + s->output_offset + h->plt.offset;
5083 sym->st_value = gval;
5084 }
5085
5086 BFD_ASSERT (h->dynindx != -1
5087 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
5088
5089 sgot = bfd_get_section_by_name (dynobj, ".got");
5090 BFD_ASSERT (sgot != NULL);
5091 BFD_ASSERT (elf_section_data (sgot) != NULL);
5092 g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5093 BFD_ASSERT (g != NULL);
5094
5095 /* Run through the global symbol table, creating GOT entries for all
5096 the symbols that need them. */
5097 if (g->global_gotsym != NULL
5098 && h->dynindx >= g->global_gotsym->dynindx)
5099 {
5100 bfd_vma offset;
5101 bfd_vma value;
5102
5103 if (sym->st_value)
5104 value = sym->st_value;
5105 else
5106 {
5107 /* For an entity defined in a shared object, this will be
5108 NULL. (For functions in shared objects for
5109 which we have created stubs, ST_VALUE will be non-NULL.
5110 That's because such the functions are now no longer defined
5111 in a shared object.) */
5112
5113 if (info->shared && h->root.type == bfd_link_hash_undefined)
5114 value = 0;
5115 else
5116 value = h->root.u.def.value;
5117 }
5118 offset = mips_elf64_global_got_index (dynobj, h);
5119 bfd_put_64 (output_bfd, value, sgot->contents + offset);
5120 }
5121
5122 /* Create a .msym entry, if appropriate. */
5123 smsym = bfd_get_section_by_name (dynobj, ".msym");
5124 if (smsym)
5125 {
5126 Elf32_Internal_Msym msym;
5127
5128 msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
5129 /* It is undocumented what the `1' indicates, but IRIX6 uses
5130 this value. */
5131 msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
5132 mips_elf64_swap_msym_out
5133 (dynobj, &msym,
5134 ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
5135 }
5136
5137 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5138 name = h->root.root.string;
5139 if (strcmp (name, "_DYNAMIC") == 0
5140 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
5141 sym->st_shndx = SHN_ABS;
5142 else if (strcmp (name, "_DYNAMIC_LINK") == 0
5143 || strcmp (name, "_DYNAMIC_LINKING") == 0)
5144 {
5145 sym->st_shndx = SHN_ABS;
5146 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5147 sym->st_value = 1;
5148 }
5149 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
5150 {
5151 if (h->type == STT_FUNC)
5152 sym->st_shndx = SHN_MIPS_TEXT;
5153 else if (h->type == STT_OBJECT)
5154 sym->st_shndx = SHN_MIPS_DATA;
5155 }
5156
5157 /* Handle the IRIX6-specific symbols. */
5158
5159 {
5160 /* The linker script takes care of providing names and values for
5161 these, but we must place them into the right sections. */
5162 static const char* const text_section_symbols[] = {
5163 "_ftext",
5164 "_etext",
5165 "__dso_displacement",
5166 "__elf_header",
5167 "__program_header_table",
5168 NULL
5169 };
5170
5171 static const char* const data_section_symbols[] = {
5172 "_fdata",
5173 "_edata",
5174 "_end",
5175 "_fbss",
5176 NULL
5177 };
5178
5179 const char* const *p;
5180 int i;
5181
5182 for (i = 0; i < 2; ++i)
5183 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
5184 *p;
5185 ++p)
5186 if (strcmp (*p, name) == 0)
5187 {
5188 /* All of these symbols are given type STT_SECTION by the
5189 IRIX6 linker. */
5190 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5191
5192 /* The IRIX linker puts these symbols in special sections. */
5193 if (i == 0)
5194 sym->st_shndx = SHN_MIPS_TEXT;
5195 else
5196 sym->st_shndx = SHN_MIPS_DATA;
5197
5198 break;
5199 }
5200 }
5201
5202 return true;
5203 }
5204
5205 /* Finish up the dynamic sections. */
5206
5207 boolean
5208 mips_elf64_finish_dynamic_sections (output_bfd, info)
5209 bfd *output_bfd;
5210 struct bfd_link_info *info;
5211 {
5212 bfd *dynobj;
5213 asection *sdyn;
5214 asection *sgot;
5215 struct mips_elf64_got_info *g;
5216
5217 dynobj = elf_hash_table (info)->dynobj;
5218
5219 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5220
5221 sgot = bfd_get_section_by_name (dynobj, ".got");
5222 if (sgot == NULL)
5223 g = NULL;
5224 else
5225 {
5226 BFD_ASSERT (elf_section_data (sgot) != NULL);
5227 g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5228 BFD_ASSERT (g != NULL);
5229 }
5230
5231 if (elf_hash_table (info)->dynamic_sections_created)
5232 {
5233 bfd_byte *b;
5234
5235 BFD_ASSERT (sdyn != NULL);
5236 BFD_ASSERT (g != NULL);
5237
5238 for (b = sdyn->contents;
5239 b < sdyn->contents + sdyn->_raw_size;
5240 b += get_elf_backend_data (dynobj)->s->sizeof_dyn)
5241 {
5242 Elf_Internal_Dyn dyn;
5243 const char *name;
5244 size_t elemsize;
5245 asection *s;
5246 boolean swap_out_p;
5247
5248 /* Read in the current dynamic entry. */
5249 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
5250
5251 /* Assume that we're going to modify it and write it out. */
5252 swap_out_p = true;
5253
5254 switch (dyn.d_tag)
5255 {
5256 case DT_RELENT:
5257 s = bfd_get_section_by_name(dynobj, "rel.dyn");
5258 BFD_ASSERT (s != NULL);
5259 dyn.d_un.d_val = get_elf_backend_data (dynobj)->s->sizeof_rel;
5260 break;
5261
5262 case DT_STRSZ:
5263 /* Rewrite DT_STRSZ. */
5264 dyn.d_un.d_val =
5265 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5266 break;
5267
5268 case DT_PLTGOT:
5269 name = ".got";
5270 goto get_vma;
5271 case DT_MIPS_CONFLICT:
5272 name = ".conflict";
5273 goto get_vma;
5274 case DT_MIPS_LIBLIST:
5275 name = ".liblist";
5276 get_vma:
5277 s = bfd_get_section_by_name (output_bfd, name);
5278 BFD_ASSERT (s != NULL);
5279 dyn.d_un.d_ptr = s->vma;
5280 break;
5281
5282 case DT_MIPS_RLD_VERSION:
5283 dyn.d_un.d_val = 1; /* XXX */
5284 break;
5285
5286 case DT_MIPS_FLAGS:
5287 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
5288 break;
5289
5290 case DT_MIPS_CONFLICTNO:
5291 name = ".conflict";
5292 elemsize = sizeof (Elf32_Conflict);
5293 goto set_elemno;
5294
5295 case DT_MIPS_LIBLISTNO:
5296 name = ".liblist";
5297 elemsize = sizeof (Elf32_Lib);
5298 set_elemno:
5299 s = bfd_get_section_by_name (output_bfd, name);
5300 if (s != NULL)
5301 {
5302 if (s->_cooked_size != 0)
5303 dyn.d_un.d_val = s->_cooked_size / elemsize;
5304 else
5305 dyn.d_un.d_val = s->_raw_size / elemsize;
5306 }
5307 else
5308 dyn.d_un.d_val = 0;
5309 break;
5310
5311 case DT_MIPS_TIME_STAMP:
5312 time ((time_t *) &dyn.d_un.d_val);
5313 break;
5314
5315 case DT_MIPS_ICHECKSUM:
5316 /* XXX FIXME: */
5317 swap_out_p = false;
5318 break;
5319
5320 case DT_MIPS_IVERSION:
5321 /* XXX FIXME: */
5322 swap_out_p = false;
5323 break;
5324
5325 case DT_MIPS_BASE_ADDRESS:
5326 s = output_bfd->sections;
5327 BFD_ASSERT (s != NULL);
5328 dyn.d_un.d_ptr = s->vma & ~(0xffff);
5329 break;
5330
5331 case DT_MIPS_LOCAL_GOTNO:
5332 dyn.d_un.d_val = g->local_gotno;
5333 break;
5334
5335 case DT_MIPS_UNREFEXTNO:
5336 /* The index into the dynamic symbol table which is the
5337 entry of the first external symbol that is not
5338 referenced within the same object. */
5339 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
5340 break;
5341
5342 case DT_MIPS_GOTSYM:
5343 if (g->global_gotsym)
5344 {
5345 dyn.d_un.d_val = g->global_gotsym->dynindx;
5346 break;
5347 }
5348 /* In case if we don't have global got symbols we default
5349 to setting DT_MIPS_GOTSYM to the same value as
5350 DT_MIPS_SYMTABNO, so we just fall through. */
5351
5352 case DT_MIPS_SYMTABNO:
5353 name = ".dynsym";
5354 elemsize = get_elf_backend_data (output_bfd)->s->sizeof_sym;
5355 s = bfd_get_section_by_name (output_bfd, name);
5356 BFD_ASSERT (s != NULL);
5357
5358 if (s->_cooked_size != 0)
5359 dyn.d_un.d_val = s->_cooked_size / elemsize;
5360 else
5361 dyn.d_un.d_val = s->_raw_size / elemsize;
5362 break;
5363
5364 case DT_MIPS_HIPAGENO:
5365 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
5366 break;
5367
5368 case DT_MIPS_OPTIONS:
5369 s = bfd_get_section_by_name(output_bfd, ".MIPS.options");
5370 dyn.d_un.d_ptr = s->vma;
5371 break;
5372
5373 case DT_MIPS_MSYM:
5374 s = bfd_get_section_by_name(output_bfd, ".msym");
5375 dyn.d_un.d_ptr = s->vma;
5376 break;
5377
5378 default:
5379 swap_out_p = false;
5380 break;
5381 }
5382
5383 if (swap_out_p)
5384 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
5385 (dynobj, &dyn, b);
5386 }
5387 }
5388
5389 /* The first entry of the global offset table will be filled at
5390 runtime. The second entry will be used by some runtime loaders.
5391 This isn't the case of Irix rld. */
5392 if (sgot != NULL && sgot->_raw_size > 0)
5393 {
5394 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
5395 bfd_put_64 (output_bfd, (bfd_vma) 0x80000000, sgot->contents + 8);
5396 }
5397
5398 if (sgot != NULL)
5399 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
5400
5401 {
5402 asection *smsym;
5403 asection *s;
5404
5405 /* ??? The section symbols for the output sections were set up in
5406 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
5407 symbols. Should we do so? */
5408
5409 smsym = bfd_get_section_by_name (dynobj, ".msym");
5410 if (smsym != NULL)
5411 {
5412 Elf32_Internal_Msym msym;
5413
5414 msym.ms_hash_value = 0;
5415 msym.ms_info = ELF32_MS_INFO (0, 1);
5416
5417 for (s = output_bfd->sections; s != NULL; s = s->next)
5418 {
5419 long dynindx = elf_section_data (s)->dynindx;
5420
5421 mips_elf64_swap_msym_out
5422 (output_bfd, &msym,
5423 (((Elf32_External_Msym *) smsym->contents)
5424 + dynindx));
5425 }
5426 }
5427
5428 /* Clean up a first relocation in .rel.dyn. */
5429 s = bfd_get_section_by_name (dynobj, "rel.dyn");
5430 if (s != NULL && s->_raw_size > 0)
5431 memset (s->contents, 0, get_elf_backend_data (dynobj)->s->sizeof_rel);
5432 }
5433
5434 return true;
5435 }
5436
5437 /* Return the section that should be marked against GC for a given
5438 relocation. */
5439
5440 asection *
5441 mips_elf64_gc_mark_hook (abfd, info, rel, h, sym)
5442 bfd *abfd;
5443 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5444 Elf_Internal_Rela *rel;
5445 struct elf_link_hash_entry *h;
5446 Elf_Internal_Sym *sym;
5447 {
5448 if (h != NULL)
5449 {
5450 switch (ELF64_R_TYPE (rel->r_info))
5451 {
5452 case R_MIPS_GNU_VTINHERIT:
5453 case R_MIPS_GNU_VTENTRY:
5454 break;
5455
5456 default:
5457 switch (h->root.type)
5458 {
5459 case bfd_link_hash_defined:
5460 case bfd_link_hash_defweak:
5461 return h->root.u.def.section;
5462
5463 case bfd_link_hash_common:
5464 return h->root.u.c.p->section;
5465
5466 default:
5467 break;
5468 }
5469 }
5470 }
5471 else
5472 {
5473 return bfd_section_from_elf_index (abfd, sym->st_shndx);
5474 }
5475
5476 return NULL;
5477 }
5478
5479 /* Update the got entry reference counts for the section being removed. */
5480
5481 boolean
5482 mips_elf64_gc_sweep_hook (abfd, info, sec, relocs)
5483 bfd *abfd ATTRIBUTE_UNUSED;
5484 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5485 asection *sec ATTRIBUTE_UNUSED;
5486 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
5487 {
5488 #if 0
5489 Elf_Internal_Shdr *symtab_hdr;
5490 struct elf_link_hash_entry **sym_hashes;
5491 bfd_signed_vma *local_got_refcounts;
5492 const Elf_Internal_Rela *rel, *relend;
5493 unsigned long r_symndx;
5494 struct elf_link_hash_entry *h;
5495
5496 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5497 sym_hashes = elf_sym_hashes (abfd);
5498 local_got_refcounts = elf_local_got_refcounts (abfd);
5499
5500 relend = relocs + sec->reloc_count;
5501 for (rel = relocs; rel < relend; rel++)
5502 switch (ELF64_R_TYPE (rel->r_info))
5503 {
5504 case R_MIPS_GOT16:
5505 case R_MIPS_CALL16:
5506 case R_MIPS_CALL_HI16:
5507 case R_MIPS_CALL_LO16:
5508 case R_MIPS_GOT_HI16:
5509 case R_MIPS_GOT_LO16:
5510 /* ??? It would seem that the existing MIPS code does no sort
5511 of reference counting or whatnot on its GOT and PLT entries,
5512 so it is not possible to garbage collect them at this time. */
5513 break;
5514
5515 default:
5516 break;
5517 }
5518 #endif
5519
5520 return true;
5521 }
5522 \f
5523 /* Create the .got section to hold the global offset table. */
5524
5525 static boolean
5526 mips_elf64_create_got_section (abfd, info)
5527 bfd *abfd;
5528 struct bfd_link_info *info;
5529 {
5530 flagword flags;
5531 register asection *s;
5532 struct elf_link_hash_entry *h;
5533 struct mips_elf64_got_info *g;
5534
5535 /* This function may be called more than once. */
5536 if (bfd_get_section_by_name (abfd, ".got"))
5537 return true;
5538
5539 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5540 | SEC_LINKER_CREATED);
5541
5542 s = bfd_make_section (abfd, ".got");
5543 if (s == NULL
5544 || ! bfd_set_section_flags (abfd, s, flags)
5545 || ! bfd_set_section_alignment (abfd, s, 4))
5546 return false;
5547
5548 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5549 linker script because we don't want to define the symbol if we
5550 are not creating a global offset table. */
5551 h = NULL;
5552 if (! (_bfd_generic_link_add_one_symbol
5553 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5554 (bfd_vma) 0, (const char *) NULL, false,
5555 get_elf_backend_data (abfd)->collect,
5556 (struct bfd_link_hash_entry **) &h)))
5557 return false;
5558 h->elf_link_hash_flags &=~ ELF_LINK_NON_ELF;
5559 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5560 h->type = STT_OBJECT;
5561
5562 if (info->shared
5563 && ! bfd_elf64_link_record_dynamic_symbol (info, h))
5564 return false;
5565
5566 /* The first several global offset table entries are reserved. */
5567 s->_raw_size = MIPS_RESERVED_GOTNO * (get_elf_backend_data (abfd)->s->arch_size / 8);
5568
5569 g = (struct mips_elf64_got_info *) bfd_alloc (abfd,
5570 sizeof (struct mips_elf64_got_info));
5571 if (g == NULL)
5572 return false;
5573 g->global_gotsym = NULL;
5574 g->local_gotno = MIPS_RESERVED_GOTNO;
5575 g->assigned_gotno = MIPS_RESERVED_GOTNO;
5576 if (elf_section_data (s) == NULL)
5577 {
5578 s->used_by_bfd =
5579 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
5580 if (elf_section_data (s) == NULL)
5581 return false;
5582 }
5583 elf_section_data (s)->tdata = (PTR) g;
5584 elf_section_data (s)->this_hdr.sh_flags
5585 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5586
5587 return true;
5588 }
5589
5590 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5591 symbol table index lower than any we've seen to date, record it for
5592 posterity. */
5593
5594 static boolean
5595 mips_elf64_record_global_got_symbol (h, info, g)
5596 struct elf_link_hash_entry *h;
5597 struct bfd_link_info *info;
5598 struct mips_elf64_got_info *g ATTRIBUTE_UNUSED;
5599 {
5600 /* A global symbol in the GOT must also be in the dynamic symbol
5601 table. */
5602 if (h->dynindx == -1
5603 && !bfd_elf64_link_record_dynamic_symbol (info, h))
5604 return false;
5605
5606 /* If we've already marked this entry as needing GOT space, we don't
5607 need to do it again. */
5608 if (h->got.offset != (bfd_vma) - 1)
5609 return true;
5610
5611 /* By setting this to a value other than -1, we are indicating that
5612 there needs to be a GOT entry for H. Avoid using zero, as the
5613 generic ELF copy_indirect_symbol tests for <= 0. */
5614 h->got.offset = 1;
5615
5616 return true;
5617 }
5618
5619 /* Returns the .msym section for ABFD, creating it if it does not
5620 already exist. Returns NULL to indicate error. */
5621
5622 static asection *
5623 mips_elf64_create_msym_section (abfd)
5624 bfd *abfd;
5625 {
5626 asection *s;
5627
5628 s = bfd_get_section_by_name (abfd, ".msym");
5629 if (!s)
5630 {
5631 s = bfd_make_section (abfd, ".msym");
5632 if (!s
5633 || !bfd_set_section_flags (abfd, s,
5634 SEC_ALLOC
5635 | SEC_LOAD
5636 | SEC_HAS_CONTENTS
5637 | SEC_LINKER_CREATED
5638 | SEC_READONLY)
5639 || !bfd_set_section_alignment (abfd, s, 3))
5640 return NULL;
5641 }
5642
5643 return s;
5644 }
5645
5646 /* Add room for N relocations to the .rel.dyn section in ABFD. */
5647
5648 static void
5649 mips_elf64_allocate_dynamic_relocations (abfd, n)
5650 bfd *abfd;
5651 unsigned int n;
5652 {
5653 asection *s;
5654
5655 s = bfd_get_section_by_name (abfd, ".rel.dyn");
5656 BFD_ASSERT (s != NULL);
5657
5658 if (s->_raw_size == 0)
5659 {
5660 /* Make room for a null element. */
5661 s->_raw_size += get_elf_backend_data (abfd)->s->sizeof_rel;
5662 ++s->reloc_count;
5663 }
5664 s->_raw_size += n * get_elf_backend_data (abfd)->s->sizeof_rel;
5665 }
5666
5667 /* Look through the relocs for a section during the first phase, and
5668 allocate space in the global offset table. */
5669
5670 boolean
5671 mips_elf64_check_relocs (abfd, info, sec, relocs)
5672 bfd *abfd;
5673 struct bfd_link_info *info;
5674 asection *sec;
5675 const Elf_Internal_Rela *relocs;
5676 {
5677 const char *name;
5678 bfd *dynobj;
5679 Elf_Internal_Shdr *symtab_hdr;
5680 struct elf_link_hash_entry **sym_hashes;
5681 struct mips_elf64_got_info *g;
5682 size_t extsymoff;
5683 const Elf_Internal_Rela *rel;
5684 const Elf_Internal_Rela *rel_end;
5685 asection *sgot;
5686 asection *sreloc;
5687 struct elf_backend_data *bed;
5688
5689 if (info->relocateable)
5690 return true;
5691
5692 dynobj = elf_hash_table (info)->dynobj;
5693 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5694 sym_hashes = elf_sym_hashes (abfd);
5695 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5696
5697 /* Check for the mips16 stub sections. */
5698
5699 name = bfd_get_section_name (abfd, sec);
5700 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5701 {
5702 unsigned long r_symndx;
5703
5704 /* Look at the relocation information to figure out which symbol
5705 this is for. */
5706
5707 r_symndx = ELF64_R_SYM (relocs->r_info);
5708
5709 if (r_symndx < extsymoff
5710 || sym_hashes[r_symndx - extsymoff] == NULL)
5711 {
5712 asection *o;
5713
5714 /* This stub is for a local symbol. This stub will only be
5715 needed if there is some relocation in this BFD, other
5716 than a 16 bit function call, which refers to this symbol. */
5717 for (o = abfd->sections; o != NULL; o = o->next)
5718 {
5719 Elf_Internal_Rela *sec_relocs;
5720 const Elf_Internal_Rela *r, *rend;
5721
5722 /* We can ignore stub sections when looking for relocs. */
5723 if ((o->flags & SEC_RELOC) == 0
5724 || o->reloc_count == 0
5725 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5726 sizeof FN_STUB - 1) == 0
5727 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5728 sizeof CALL_STUB - 1) == 0
5729 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5730 sizeof CALL_FP_STUB - 1) == 0)
5731 continue;
5732
5733 sec_relocs = (_bfd_elf64_link_read_relocs
5734 (abfd, o, (PTR) NULL,
5735 (Elf_Internal_Rela *) NULL,
5736 info->keep_memory));
5737 if (sec_relocs == NULL)
5738 return false;
5739
5740 rend = sec_relocs + o->reloc_count;
5741 for (r = sec_relocs; r < rend; r++)
5742 if (ELF64_R_SYM (r->r_info) == r_symndx
5743 && ELF64_R_TYPE (r->r_info) != R_MIPS16_26)
5744 break;
5745
5746 if (! info->keep_memory)
5747 free (sec_relocs);
5748
5749 if (r < rend)
5750 break;
5751 }
5752
5753 if (o == NULL)
5754 {
5755 /* There is no non-call reloc for this stub, so we do
5756 not need it. Since this function is called before
5757 the linker maps input sections to output sections, we
5758 can easily discard it by setting the SEC_EXCLUDE
5759 flag. */
5760 sec->flags |= SEC_EXCLUDE;
5761 return true;
5762 }
5763
5764 /* Record this stub in an array of local symbol stubs for
5765 this BFD. */
5766 if (elf_tdata (abfd)->local_stubs == NULL)
5767 {
5768 unsigned long symcount;
5769 asection **n;
5770 bfd_size_type amt;
5771
5772 if (elf_bad_symtab (abfd))
5773 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5774 else
5775 symcount = symtab_hdr->sh_info;
5776 amt = symcount * sizeof (asection *);
5777 n = (asection **) bfd_zalloc (abfd, amt);
5778 if (n == NULL)
5779 return false;
5780 elf_tdata (abfd)->local_stubs = n;
5781 }
5782
5783 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5784
5785 /* We don't need to set mips16_stubs_seen in this case.
5786 That flag is used to see whether we need to look through
5787 the global symbol table for stubs. We don't need to set
5788 it here, because we just have a local stub. */
5789 }
5790 else
5791 {
5792 struct mips_elf64_link_hash_entry *h;
5793
5794 h = ((struct mips_elf64_link_hash_entry *)
5795 sym_hashes[r_symndx - extsymoff]);
5796
5797 /* H is the symbol this stub is for. */
5798
5799 h->fn_stub = sec;
5800 mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5801 }
5802 }
5803 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5804 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5805 {
5806 unsigned long r_symndx;
5807 struct mips_elf64_link_hash_entry *h;
5808 asection **loc;
5809
5810 /* Look at the relocation information to figure out which symbol
5811 this is for. */
5812
5813 r_symndx = ELF64_R_SYM (relocs->r_info);
5814
5815 if (r_symndx < extsymoff
5816 || sym_hashes[r_symndx - extsymoff] == NULL)
5817 {
5818 /* This stub was actually built for a static symbol defined
5819 in the same file. We assume that all static symbols in
5820 mips16 code are themselves mips16, so we can simply
5821 discard this stub. Since this function is called before
5822 the linker maps input sections to output sections, we can
5823 easily discard it by setting the SEC_EXCLUDE flag. */
5824 sec->flags |= SEC_EXCLUDE;
5825 return true;
5826 }
5827
5828 h = ((struct mips_elf64_link_hash_entry *)
5829 sym_hashes[r_symndx - extsymoff]);
5830
5831 /* H is the symbol this stub is for. */
5832
5833 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5834 loc = &h->call_fp_stub;
5835 else
5836 loc = &h->call_stub;
5837
5838 /* If we already have an appropriate stub for this function, we
5839 don't need another one, so we can discard this one. Since
5840 this function is called before the linker maps input sections
5841 to output sections, we can easily discard it by setting the
5842 SEC_EXCLUDE flag. We can also discard this section if we
5843 happen to already know that this is a mips16 function; it is
5844 not necessary to check this here, as it is checked later, but
5845 it is slightly faster to check now. */
5846 if (*loc != NULL || h->root.other == STO_MIPS16)
5847 {
5848 sec->flags |= SEC_EXCLUDE;
5849 return true;
5850 }
5851
5852 *loc = sec;
5853 mips_elf64_hash_table (info)->mips16_stubs_seen = true;
5854 }
5855
5856 if (dynobj == NULL)
5857 {
5858 sgot = NULL;
5859 g = NULL;
5860 }
5861 else
5862 {
5863 sgot = bfd_get_section_by_name (dynobj, ".got");
5864 if (sgot == NULL)
5865 g = NULL;
5866 else
5867 {
5868 BFD_ASSERT (elf_section_data (sgot) != NULL);
5869 g = (struct mips_elf64_got_info *) elf_section_data (sgot)->tdata;
5870 BFD_ASSERT (g != NULL);
5871 }
5872 }
5873
5874 sreloc = NULL;
5875 bed = get_elf_backend_data (abfd);
5876 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5877 for (rel = relocs; rel < rel_end; ++rel)
5878 {
5879 unsigned long r_symndx;
5880 int r_type;
5881 struct elf_link_hash_entry *h;
5882
5883 r_symndx = ELF64_R_SYM (rel->r_info);
5884 r_type = ELF64_MIPS_R_TYPE (rel->r_info);
5885
5886 if (r_symndx < extsymoff)
5887 h = NULL;
5888 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5889 {
5890 (*_bfd_error_handler)
5891 (_("%s: Malformed reloc detected for section %s"),
5892 bfd_archive_filename (abfd), name);
5893 bfd_set_error (bfd_error_bad_value);
5894 return false;
5895 }
5896 else
5897 {
5898 h = sym_hashes[r_symndx - extsymoff];
5899
5900 /* This may be an indirect symbol created because of a version. */
5901 if (h != NULL)
5902 {
5903 while (h->root.type == bfd_link_hash_indirect)
5904 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5905 }
5906 }
5907
5908 /* Some relocs require a global offset table. */
5909 if (dynobj == NULL || sgot == NULL)
5910 {
5911 switch (r_type)
5912 {
5913 case R_MIPS_GOT16:
5914 case R_MIPS_CALL16:
5915 case R_MIPS_CALL_HI16:
5916 case R_MIPS_CALL_LO16:
5917 case R_MIPS_GOT_HI16:
5918 case R_MIPS_GOT_LO16:
5919 case R_MIPS_GOT_PAGE:
5920 case R_MIPS_GOT_OFST:
5921 case R_MIPS_GOT_DISP:
5922 if (dynobj == NULL)
5923 elf_hash_table (info)->dynobj = dynobj = abfd;
5924 if (! mips_elf64_create_got_section (dynobj, info))
5925 return false;
5926 g = _mips_elf64_got_info (dynobj, &sgot);
5927 break;
5928
5929 case R_MIPS_32:
5930 case R_MIPS_REL32:
5931 case R_MIPS_64:
5932 if (dynobj == NULL
5933 && (info->shared || h != NULL)
5934 && (sec->flags & SEC_ALLOC) != 0)
5935 elf_hash_table (info)->dynobj = dynobj = abfd;
5936 break;
5937
5938 default:
5939 break;
5940 }
5941 }
5942
5943 if (!h && (r_type == R_MIPS_CALL_LO16
5944 || r_type == R_MIPS_GOT_LO16
5945 || r_type == R_MIPS_GOT_DISP))
5946 {
5947 /* We may need a local GOT entry for this relocation. We
5948 don't count R_MIPS_GOT_PAGE because we can estimate the
5949 maximum number of pages needed by looking at the size of
5950 the segment. Similar comments apply to R_MIPS_GOT16 and
5951 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5952 R_MIPS_CALL_HI16 because these are always followed by an
5953 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
5954
5955 This estimation is very conservative since we can merge
5956 duplicate entries in the GOT. In order to be less
5957 conservative, we could actually build the GOT here,
5958 rather than in relocate_section. */
5959 g->local_gotno++;
5960 sgot->_raw_size += get_elf_backend_data (dynobj)->s->arch_size / 8;
5961 }
5962
5963 switch (r_type)
5964 {
5965 case R_MIPS_CALL16:
5966 if (h == NULL)
5967 {
5968 (*_bfd_error_handler)
5969 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5970 bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5971 bfd_set_error (bfd_error_bad_value);
5972 return false;
5973 }
5974 /* Fall through. */
5975
5976 case R_MIPS_CALL_HI16:
5977 case R_MIPS_CALL_LO16:
5978 if (h != NULL)
5979 {
5980 /* This symbol requires a global offset table entry. */
5981 if (!mips_elf64_record_global_got_symbol (h, info, g))
5982 return false;
5983
5984 /* We need a stub, not a plt entry for the undefined
5985 function. But we record it as if it needs plt. See
5986 elf_adjust_dynamic_symbol in elflink.h. */
5987 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5988 h->type = STT_FUNC;
5989 }
5990 break;
5991
5992 case R_MIPS_GOT16:
5993 case R_MIPS_GOT_HI16:
5994 case R_MIPS_GOT_LO16:
5995 case R_MIPS_GOT_DISP:
5996 /* This symbol requires a global offset table entry. */
5997 if (h && !mips_elf64_record_global_got_symbol (h, info, g))
5998 return false;
5999 break;
6000
6001 case R_MIPS_32:
6002 case R_MIPS_REL32:
6003 case R_MIPS_64:
6004 if ((info->shared || h != NULL)
6005 && (sec->flags & SEC_ALLOC) != 0)
6006 {
6007 if (sreloc == NULL)
6008 {
6009 const char *name = ".rel.dyn";
6010
6011 sreloc = bfd_get_section_by_name (dynobj, name);
6012 if (sreloc == NULL)
6013 {
6014 sreloc = bfd_make_section (dynobj, name);
6015 if (sreloc == NULL
6016 || ! bfd_set_section_flags (dynobj, sreloc,
6017 (SEC_ALLOC
6018 | SEC_LOAD
6019 | SEC_HAS_CONTENTS
6020 | SEC_IN_MEMORY
6021 | SEC_LINKER_CREATED
6022 | SEC_READONLY))
6023 || ! bfd_set_section_alignment (dynobj, sreloc,
6024 4))
6025 return false;
6026 }
6027 }
6028 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
6029 if (info->shared)
6030 {
6031 /* When creating a shared object, we must copy these
6032 reloc types into the output file as R_MIPS_REL32
6033 relocs. We make room for this reloc in the
6034 .rel.dyn reloc section. */
6035 mips_elf64_allocate_dynamic_relocations (dynobj, 1);
6036 if ((sec->flags & MIPS_READONLY_SECTION)
6037 == MIPS_READONLY_SECTION)
6038 /* We tell the dynamic linker that there are
6039 relocations against the text segment. */
6040 info->flags |= DF_TEXTREL;
6041 }
6042 else
6043 {
6044 struct mips_elf64_link_hash_entry *hmips;
6045
6046 /* We only need to copy this reloc if the symbol is
6047 defined in a dynamic object. */
6048 hmips = (struct mips_elf64_link_hash_entry *) h;
6049 ++hmips->possibly_dynamic_relocs;
6050 if ((sec->flags & MIPS_READONLY_SECTION)
6051 == MIPS_READONLY_SECTION)
6052 /* We need it to tell the dynamic linker if there
6053 are relocations against the text segment. */
6054 hmips->readonly_reloc = true;
6055 }
6056
6057 /* Even though we don't directly need a GOT entry for
6058 this symbol, a symbol must have a dynamic symbol
6059 table index greater that DT_MIPS_GOTSYM if there are
6060 dynamic relocations against it. */
6061 if (h != NULL
6062 && !mips_elf64_record_global_got_symbol (h, info, g))
6063 return false;
6064 }
6065 break;
6066
6067 case R_MIPS_26:
6068 case R_MIPS_GPREL16:
6069 case R_MIPS_LITERAL:
6070 case R_MIPS_GPREL32:
6071 break;
6072
6073 /* This relocation describes the C++ object vtable hierarchy.
6074 Reconstruct it for later use during GC. */
6075 case R_MIPS_GNU_VTINHERIT:
6076 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6077 return false;
6078 break;
6079
6080 /* This relocation describes which C++ vtable entries are actually
6081 used. Record for later use during GC. */
6082 case R_MIPS_GNU_VTENTRY:
6083 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6084 return false;
6085 break;
6086
6087 default:
6088 break;
6089 }
6090 }
6091
6092 return true;
6093 }
6094
6095 /* Structure used to pass information to mips_elf64_output_extsym. */
6096
6097 struct extsym_info
6098 {
6099 bfd *abfd;
6100 struct bfd_link_info *info;
6101 struct ecoff_debug_info *debug;
6102 const struct ecoff_debug_swap *swap;
6103 boolean failed;
6104 };
6105
6106 /* This routine is used to write out ECOFF debugging external symbol
6107 information. It is called via mips_elf64_link_hash_traverse. The
6108 ECOFF external symbol information must match the ELF external
6109 symbol information. Unfortunately, at this point we don't know
6110 whether a symbol is required by reloc information, so the two
6111 tables may wind up being different. We must sort out the external
6112 symbol information before we can set the final size of the .mdebug
6113 section, and we must set the size of the .mdebug section before we
6114 can relocate any sections, and we can't know which symbols are
6115 required by relocation until we relocate the sections.
6116 Fortunately, it is relatively unlikely that any symbol will be
6117 stripped but required by a reloc. In particular, it can not happen
6118 when generating a final executable. */
6119
6120 static boolean
6121 mips_elf64_output_extsym (h, data)
6122 struct mips_elf64_link_hash_entry *h;
6123 PTR data;
6124 {
6125 struct extsym_info *einfo = (struct extsym_info *) data;
6126 boolean strip;
6127 asection *sec, *output_section;
6128
6129 if (h->root.indx == -2)
6130 strip = false;
6131 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
6132 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
6133 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
6134 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
6135 strip = true;
6136 else if (einfo->info->strip == strip_all
6137 || (einfo->info->strip == strip_some
6138 && bfd_hash_lookup (einfo->info->keep_hash,
6139 h->root.root.root.string,
6140 false, false) == NULL))
6141 strip = true;
6142 else
6143 strip = false;
6144
6145 if (strip)
6146 return true;
6147
6148 if (h->esym.ifd == -2)
6149 {
6150 h->esym.jmptbl = 0;
6151 h->esym.cobol_main = 0;
6152 h->esym.weakext = 0;
6153 h->esym.reserved = 0;
6154 h->esym.ifd = ifdNil;
6155 h->esym.asym.value = 0;
6156 h->esym.asym.st = stGlobal;
6157
6158 if (h->root.root.type == bfd_link_hash_undefined
6159 || h->root.root.type == bfd_link_hash_undefweak)
6160 {
6161 const char *name;
6162
6163 /* Use undefined class. Also, set class and type for some
6164 special symbols. */
6165 name = h->root.root.root.string;
6166 h->esym.asym.sc = scUndefined;
6167 }
6168 else if (h->root.root.type != bfd_link_hash_defined
6169 && h->root.root.type != bfd_link_hash_defweak)
6170 h->esym.asym.sc = scAbs;
6171 else
6172 {
6173 const char *name;
6174
6175 sec = h->root.root.u.def.section;
6176 output_section = sec->output_section;
6177
6178 /* When making a shared library and symbol h is the one from
6179 the another shared library, OUTPUT_SECTION may be null. */
6180 if (output_section == NULL)
6181 h->esym.asym.sc = scUndefined;
6182 else
6183 {
6184 name = bfd_section_name (output_section->owner, output_section);
6185
6186 if (strcmp (name, ".text") == 0)
6187 h->esym.asym.sc = scText;
6188 else if (strcmp (name, ".data") == 0)
6189 h->esym.asym.sc = scData;
6190 else if (strcmp (name, ".sdata") == 0)
6191 h->esym.asym.sc = scSData;
6192 else if (strcmp (name, ".rodata") == 0
6193 || strcmp (name, ".rdata") == 0)
6194 h->esym.asym.sc = scRData;
6195 else if (strcmp (name, ".bss") == 0)
6196 h->esym.asym.sc = scBss;
6197 else if (strcmp (name, ".sbss") == 0)
6198 h->esym.asym.sc = scSBss;
6199 else if (strcmp (name, ".init") == 0)
6200 h->esym.asym.sc = scInit;
6201 else if (strcmp (name, ".fini") == 0)
6202 h->esym.asym.sc = scFini;
6203 else
6204 h->esym.asym.sc = scAbs;
6205 }
6206 }
6207
6208 h->esym.asym.reserved = 0;
6209 h->esym.asym.index = indexNil;
6210 }
6211
6212 if (h->root.root.type == bfd_link_hash_common)
6213 h->esym.asym.value = h->root.root.u.c.size;
6214 else if (h->root.root.type == bfd_link_hash_defined
6215 || h->root.root.type == bfd_link_hash_defweak)
6216 {
6217 if (h->esym.asym.sc == scCommon)
6218 h->esym.asym.sc = scBss;
6219 else if (h->esym.asym.sc == scSCommon)
6220 h->esym.asym.sc = scSBss;
6221
6222 sec = h->root.root.u.def.section;
6223 output_section = sec->output_section;
6224 if (output_section != NULL)
6225 h->esym.asym.value = (h->root.root.u.def.value
6226 + sec->output_offset
6227 + output_section->vma);
6228 else
6229 h->esym.asym.value = 0;
6230 }
6231 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
6232 {
6233 struct mips_elf64_link_hash_entry *hd = h;
6234 boolean no_fn_stub = h->no_fn_stub;
6235
6236 while (hd->root.root.type == bfd_link_hash_indirect)
6237 {
6238 hd = (struct mips_elf64_link_hash_entry *)h->root.root.u.i.link;
6239 no_fn_stub = no_fn_stub || hd->no_fn_stub;
6240 }
6241
6242 if (!no_fn_stub)
6243 {
6244 /* Set type and value for a symbol with a function stub. */
6245 h->esym.asym.st = stProc;
6246 sec = hd->root.root.u.def.section;
6247 if (sec == NULL)
6248 h->esym.asym.value = 0;
6249 else
6250 {
6251 output_section = sec->output_section;
6252 if (output_section != NULL)
6253 h->esym.asym.value = (hd->root.plt.offset
6254 + sec->output_offset
6255 + output_section->vma);
6256 else
6257 h->esym.asym.value = 0;
6258 }
6259 #if 0 /* FIXME? */
6260 h->esym.ifd = 0;
6261 #endif
6262 }
6263 }
6264
6265 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
6266 h->root.root.root.string,
6267 &h->esym))
6268 {
6269 einfo->failed = true;
6270 return false;
6271 }
6272
6273 return true;
6274 }
6275
6276 /* Swap an entry in a .gptab section. Note that these routines rely
6277 on the equivalence of the two elements of the union. */
6278
6279 static void
6280 mips_elf64_swap_gptab_in (abfd, ex, in)
6281 bfd *abfd;
6282 const Elf32_External_gptab *ex;
6283 Elf32_gptab *in;
6284 {
6285 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
6286 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
6287 }
6288
6289 static void
6290 mips_elf64_swap_gptab_out (abfd, in, ex)
6291 bfd *abfd;
6292 const Elf32_gptab *in;
6293 Elf32_External_gptab *ex;
6294 {
6295 H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
6296 ex->gt_entry.gt_g_value);
6297 H_PUT_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
6298 ex->gt_entry.gt_bytes);
6299 }
6300
6301 /* A comparison routine used to sort .gptab entries. */
6302
6303 static int
6304 gptab_compare (p1, p2)
6305 const PTR p1;
6306 const PTR p2;
6307 {
6308 const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
6309 const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
6310
6311 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
6312 }
6313
6314 /* We need to use a special link routine to handle the .mdebug section.
6315 We need to merge all instances of this section together, not write
6316 them all out sequentially. */
6317
6318 boolean
6319 mips_elf64_final_link (abfd, info)
6320 bfd *abfd;
6321 struct bfd_link_info *info;
6322 {
6323 asection **secpp;
6324 asection *o;
6325 struct bfd_link_order *p;
6326 asection *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
6327 struct ecoff_debug_info debug;
6328 const struct ecoff_debug_swap *swap
6329 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
6330 HDRR *symhdr = &debug.symbolic_header;
6331 PTR mdebug_handle = NULL;
6332 asection *s;
6333 EXTR esym;
6334 unsigned int i;
6335 static const char * const secname[] =
6336 { ".text", ".init", ".fini", ".data",
6337 ".rodata", ".sdata", ".sbss", ".bss" };
6338 static const int sc[] = { scText, scInit, scFini, scData,
6339 scRData, scSData, scSBss, scBss };
6340
6341 /* If all the things we linked together were PIC, but we're
6342 producing an executable (rather than a shared object), then the
6343 resulting file is CPIC (i.e., it calls PIC code.) */
6344 if (!info->shared
6345 && !info->relocateable
6346 && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
6347 {
6348 elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
6349 elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
6350 }
6351
6352 /* We'd carefully arranged the dynamic symbol indices, and then the
6353 generic size_dynamic_sections renumbered them out from under us.
6354 Rather than trying somehow to prevent the renumbering, just do
6355 the sort again. */
6356 if (elf_hash_table (info)->dynamic_sections_created)
6357 {
6358 bfd *dynobj;
6359 asection *got;
6360 struct mips_elf64_got_info *g;
6361
6362 /* When we resort, we must tell mips_elf64_sort_hash_table what
6363 the lowest index it may use is. That's the number of section
6364 symbols we're going to add. The generic ELF linker only
6365 adds these symbols when building a shared object. Note that
6366 we count the sections after (possibly) removing the .options
6367 section above. */
6368 if (!mips_elf64_sort_hash_table (info, (info->shared
6369 ? bfd_count_sections (abfd) + 1
6370 : 1)))
6371 return false;
6372
6373 /* Make sure we didn't grow the global .got region. */
6374 dynobj = elf_hash_table (info)->dynobj;
6375 got = bfd_get_section_by_name (dynobj, ".got");
6376 g = (struct mips_elf64_got_info *) elf_section_data (got)->tdata;
6377
6378 if (g->global_gotsym != NULL)
6379 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
6380 - g->global_gotsym->dynindx)
6381 <= g->global_gotno);
6382 }
6383
6384 /* We include .MIPS.options, even though we don't process it quite right.
6385 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
6386 to be better off including it than not. */
6387 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
6388 {
6389 if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
6390 {
6391 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
6392 if (p->type == bfd_indirect_link_order)
6393 p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
6394 (*secpp)->link_order_head = NULL;
6395 bfd_section_list_remove (abfd, secpp);
6396 --abfd->section_count;
6397
6398 break;
6399 }
6400 }
6401
6402 /* Get a value for the GP register. */
6403 if (elf_gp (abfd) == 0)
6404 {
6405 struct bfd_link_hash_entry *h;
6406
6407 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
6408 if (h != (struct bfd_link_hash_entry *) NULL
6409 && h->type == bfd_link_hash_defined)
6410 elf_gp (abfd) = (h->u.def.value
6411 + h->u.def.section->output_section->vma
6412 + h->u.def.section->output_offset);
6413 else if (info->relocateable)
6414 {
6415 bfd_vma lo = MINUS_ONE;
6416
6417 /* Find the GP-relative section with the lowest offset. */
6418 for (o = abfd->sections; o != NULL; o = o->next)
6419 if (o->vma < lo
6420 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
6421 lo = o->vma;
6422
6423 /* And calculate GP relative to that. */
6424 elf_gp (abfd) = (lo + 0x7ff0);
6425 }
6426 else
6427 {
6428 /* If the relocate_section function needs to do a reloc
6429 involving the GP value, it should make a reloc_dangerous
6430 callback to warn that GP is not defined. */
6431 }
6432 }
6433
6434 /* Go through the sections and collect the .mdebug information. */
6435 mdebug_sec = NULL;
6436 gptab_data_sec = NULL;
6437 gptab_bss_sec = NULL;
6438 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
6439 {
6440 if (strcmp (o->name, ".mdebug") == 0)
6441 {
6442 struct extsym_info einfo;
6443 bfd_vma last;
6444
6445 /* We have found the .mdebug section in the output file.
6446 Look through all the link_orders comprising it and merge
6447 the information together. */
6448 symhdr->magic = swap->sym_magic;
6449 /* FIXME: What should the version stamp be? */
6450 symhdr->vstamp = 0;
6451 symhdr->ilineMax = 0;
6452 symhdr->cbLine = 0;
6453 symhdr->idnMax = 0;
6454 symhdr->ipdMax = 0;
6455 symhdr->isymMax = 0;
6456 symhdr->ioptMax = 0;
6457 symhdr->iauxMax = 0;
6458 symhdr->issMax = 0;
6459 symhdr->issExtMax = 0;
6460 symhdr->ifdMax = 0;
6461 symhdr->crfd = 0;
6462 symhdr->iextMax = 0;
6463
6464 /* We accumulate the debugging information itself in the
6465 debug_info structure. */
6466 debug.line = NULL;
6467 debug.external_dnr = NULL;
6468 debug.external_pdr = NULL;
6469 debug.external_sym = NULL;
6470 debug.external_opt = NULL;
6471 debug.external_aux = NULL;
6472 debug.ss = NULL;
6473 debug.ssext = debug.ssext_end = NULL;
6474 debug.external_fdr = NULL;
6475 debug.external_rfd = NULL;
6476 debug.external_ext = debug.external_ext_end = NULL;
6477
6478 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
6479 if (mdebug_handle == (PTR) NULL)
6480 return false;
6481
6482 esym.jmptbl = 0;
6483 esym.cobol_main = 0;
6484 esym.weakext = 0;
6485 esym.reserved = 0;
6486 esym.ifd = ifdNil;
6487 esym.asym.iss = issNil;
6488 esym.asym.st = stLocal;
6489 esym.asym.reserved = 0;
6490 esym.asym.index = indexNil;
6491 last = 0;
6492 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
6493 {
6494 esym.asym.sc = sc[i];
6495 s = bfd_get_section_by_name (abfd, secname[i]);
6496 if (s != NULL)
6497 {
6498 esym.asym.value = s->vma;
6499 last = s->vma + s->_raw_size;
6500 }
6501 else
6502 esym.asym.value = last;
6503 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
6504 secname[i], &esym))
6505 return false;
6506 }
6507
6508 for (p = o->link_order_head;
6509 p != (struct bfd_link_order *) NULL;
6510 p = p->next)
6511 {
6512 asection *input_section;
6513 bfd *input_bfd;
6514 const struct ecoff_debug_swap *input_swap;
6515 struct ecoff_debug_info input_debug;
6516 char *eraw_src;
6517 char *eraw_end;
6518
6519 if (p->type != bfd_indirect_link_order)
6520 {
6521 if (p->type == bfd_fill_link_order)
6522 continue;
6523 abort ();
6524 }
6525
6526 input_section = p->u.indirect.section;
6527 input_bfd = input_section->owner;
6528
6529 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
6530 || (get_elf_backend_data (input_bfd)
6531 ->elf_backend_ecoff_debug_swap) == NULL)
6532 {
6533 /* I don't know what a non MIPS ELF bfd would be
6534 doing with a .mdebug section, but I don't really
6535 want to deal with it. */
6536 continue;
6537 }
6538
6539 input_swap = (get_elf_backend_data (input_bfd)
6540 ->elf_backend_ecoff_debug_swap);
6541
6542 BFD_ASSERT (p->size == input_section->_raw_size);
6543
6544 /* The ECOFF linking code expects that we have already
6545 read in the debugging information and set up an
6546 ecoff_debug_info structure, so we do that now. */
6547 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
6548 &input_debug))
6549 return false;
6550
6551 if (! (bfd_ecoff_debug_accumulate
6552 (mdebug_handle, abfd, &debug, swap, input_bfd,
6553 &input_debug, input_swap, info)))
6554 return false;
6555
6556 /* Loop through the external symbols. For each one with
6557 interesting information, try to find the symbol in
6558 the linker global hash table and save the information
6559 for the output external symbols. */
6560 eraw_src = input_debug.external_ext;
6561 eraw_end = (eraw_src
6562 + (input_debug.symbolic_header.iextMax
6563 * input_swap->external_ext_size));
6564 for (;
6565 eraw_src < eraw_end;
6566 eraw_src += input_swap->external_ext_size)
6567 {
6568 EXTR ext;
6569 const char *name;
6570 struct mips_elf64_link_hash_entry *h;
6571
6572 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
6573 if (ext.asym.sc == scNil
6574 || ext.asym.sc == scUndefined
6575 || ext.asym.sc == scSUndefined)
6576 continue;
6577
6578 name = input_debug.ssext + ext.asym.iss;
6579 h = mips_elf64_link_hash_lookup (mips_elf64_hash_table (info),
6580 name, false, false, true);
6581 if (h == NULL || h->esym.ifd != -2)
6582 continue;
6583
6584 if (ext.ifd != -1)
6585 {
6586 BFD_ASSERT (ext.ifd
6587 < input_debug.symbolic_header.ifdMax);
6588 ext.ifd = input_debug.ifdmap[ext.ifd];
6589 }
6590
6591 h->esym = ext;
6592 }
6593
6594 /* Free up the information we just read. */
6595 free (input_debug.line);
6596 free (input_debug.external_dnr);
6597 free (input_debug.external_pdr);
6598 free (input_debug.external_sym);
6599 free (input_debug.external_opt);
6600 free (input_debug.external_aux);
6601 free (input_debug.ss);
6602 free (input_debug.ssext);
6603 free (input_debug.external_fdr);
6604 free (input_debug.external_rfd);
6605 free (input_debug.external_ext);
6606
6607 /* Hack: reset the SEC_HAS_CONTENTS flag so that
6608 elf_link_input_bfd ignores this section. */
6609 input_section->flags &=~ SEC_HAS_CONTENTS;
6610 }
6611
6612 /* Build the external symbol information. */
6613 einfo.abfd = abfd;
6614 einfo.info = info;
6615 einfo.debug = &debug;
6616 einfo.swap = swap;
6617 einfo.failed = false;
6618 mips_elf64_link_hash_traverse (mips_elf64_hash_table (info),
6619 mips_elf64_output_extsym,
6620 (PTR) &einfo);
6621 if (einfo.failed)
6622 return false;
6623
6624 /* Set the size of the .mdebug section. */
6625 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
6626
6627 /* Skip this section later on (I don't think this currently
6628 matters, but someday it might). */
6629 o->link_order_head = (struct bfd_link_order *) NULL;
6630
6631 mdebug_sec = o;
6632 }
6633
6634 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
6635 {
6636 const char *subname;
6637 unsigned int c;
6638 Elf32_gptab *tab;
6639 Elf32_External_gptab *ext_tab;
6640 unsigned int i;
6641
6642 /* The .gptab.sdata and .gptab.sbss sections hold
6643 information describing how the small data area would
6644 change depending upon the -G switch. These sections
6645 not used in executables files. */
6646 if (! info->relocateable)
6647 {
6648 asection **secpp;
6649
6650 for (p = o->link_order_head;
6651 p != (struct bfd_link_order *) NULL;
6652 p = p->next)
6653 {
6654 asection *input_section;
6655
6656 if (p->type != bfd_indirect_link_order)
6657 {
6658 if (p->type == bfd_fill_link_order)
6659 continue;
6660 abort ();
6661 }
6662
6663 input_section = p->u.indirect.section;
6664
6665 /* Hack: reset the SEC_HAS_CONTENTS flag so that
6666 elf_link_input_bfd ignores this section. */
6667 input_section->flags &=~ SEC_HAS_CONTENTS;
6668 }
6669
6670 /* Skip this section later on (I don't think this
6671 currently matters, but someday it might). */
6672 o->link_order_head = (struct bfd_link_order *) NULL;
6673
6674 /* Really remove the section. */
6675 for (secpp = &abfd->sections;
6676 *secpp != o;
6677 secpp = &(*secpp)->next)
6678 ;
6679 bfd_section_list_remove (abfd, secpp);
6680 --abfd->section_count;
6681
6682 continue;
6683 }
6684
6685 /* There is one gptab for initialized data, and one for
6686 uninitialized data. */
6687 if (strcmp (o->name, ".gptab.sdata") == 0)
6688 gptab_data_sec = o;
6689 else if (strcmp (o->name, ".gptab.sbss") == 0)
6690 gptab_bss_sec = o;
6691 else
6692 {
6693 (*_bfd_error_handler)
6694 (_("%s: illegal section name `%s'"),
6695 bfd_archive_filename (abfd), o->name);
6696 bfd_set_error (bfd_error_nonrepresentable_section);
6697 return false;
6698 }
6699
6700 /* The linker script always combines .gptab.data and
6701 .gptab.sdata into .gptab.sdata, and likewise for
6702 .gptab.bss and .gptab.sbss. It is possible that there is
6703 no .sdata or .sbss section in the output file, in which
6704 case we must change the name of the output section. */
6705 subname = o->name + sizeof ".gptab" - 1;
6706 if (bfd_get_section_by_name (abfd, subname) == NULL)
6707 {
6708 if (o == gptab_data_sec)
6709 o->name = ".gptab.data";
6710 else
6711 o->name = ".gptab.bss";
6712 subname = o->name + sizeof ".gptab" - 1;
6713 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
6714 }
6715
6716 /* Set up the first entry. */
6717 c = 1;
6718 tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
6719 if (tab == NULL)
6720 return false;
6721 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
6722 tab[0].gt_header.gt_unused = 0;
6723
6724 /* Combine the input sections. */
6725 for (p = o->link_order_head;
6726 p != (struct bfd_link_order *) NULL;
6727 p = p->next)
6728 {
6729 asection *input_section;
6730 bfd *input_bfd;
6731 bfd_size_type size;
6732 unsigned long last;
6733 bfd_size_type gpentry;
6734
6735 if (p->type != bfd_indirect_link_order)
6736 {
6737 if (p->type == bfd_fill_link_order)
6738 continue;
6739 abort ();
6740 }
6741
6742 input_section = p->u.indirect.section;
6743 input_bfd = input_section->owner;
6744
6745 /* Combine the gptab entries for this input section one
6746 by one. We know that the input gptab entries are
6747 sorted by ascending -G value. */
6748 size = bfd_section_size (input_bfd, input_section);
6749 last = 0;
6750 for (gpentry = sizeof (Elf32_External_gptab);
6751 gpentry < size;
6752 gpentry += sizeof (Elf32_External_gptab))
6753 {
6754 Elf32_External_gptab ext_gptab;
6755 Elf32_gptab int_gptab;
6756 unsigned long val;
6757 unsigned long add;
6758 boolean exact;
6759 unsigned int look;
6760
6761 if (! (bfd_get_section_contents
6762 (input_bfd, input_section, (PTR) &ext_gptab,
6763 gpentry, sizeof (Elf32_External_gptab))))
6764 {
6765 free (tab);
6766 return false;
6767 }
6768
6769 mips_elf64_swap_gptab_in (input_bfd, &ext_gptab,
6770 &int_gptab);
6771 val = int_gptab.gt_entry.gt_g_value;
6772 add = int_gptab.gt_entry.gt_bytes - last;
6773
6774 exact = false;
6775 for (look = 1; look < c; look++)
6776 {
6777 if (tab[look].gt_entry.gt_g_value >= val)
6778 tab[look].gt_entry.gt_bytes += add;
6779
6780 if (tab[look].gt_entry.gt_g_value == val)
6781 exact = true;
6782 }
6783
6784 if (! exact)
6785 {
6786 Elf32_gptab *new_tab;
6787 unsigned int max;
6788
6789 /* We need a new table entry. */
6790 new_tab = ((Elf32_gptab *)
6791 bfd_realloc ((PTR) tab,
6792 (c + 1) * sizeof (Elf32_gptab)));
6793 if (new_tab == NULL)
6794 {
6795 free (tab);
6796 return false;
6797 }
6798 tab = new_tab;
6799 tab[c].gt_entry.gt_g_value = val;
6800 tab[c].gt_entry.gt_bytes = add;
6801
6802 /* Merge in the size for the next smallest -G
6803 value, since that will be implied by this new
6804 value. */
6805 max = 0;
6806 for (look = 1; look < c; look++)
6807 {
6808 if (tab[look].gt_entry.gt_g_value < val
6809 && (max == 0
6810 || (tab[look].gt_entry.gt_g_value
6811 > tab[max].gt_entry.gt_g_value)))
6812 max = look;
6813 }
6814 if (max != 0)
6815 tab[c].gt_entry.gt_bytes +=
6816 tab[max].gt_entry.gt_bytes;
6817
6818 ++c;
6819 }
6820
6821 last = int_gptab.gt_entry.gt_bytes;
6822 }
6823
6824 /* Hack: reset the SEC_HAS_CONTENTS flag so that
6825 elf_link_input_bfd ignores this section. */
6826 input_section->flags &=~ SEC_HAS_CONTENTS;
6827 }
6828
6829 /* The table must be sorted by -G value. */
6830 if (c > 2)
6831 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
6832
6833 /* Swap out the table. */
6834 ext_tab = ((Elf32_External_gptab *)
6835 bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
6836 if (ext_tab == NULL)
6837 {
6838 free (tab);
6839 return false;
6840 }
6841
6842 for (i = 0; i < c; i++)
6843 mips_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
6844 free (tab);
6845
6846 o->_raw_size = c * sizeof (Elf32_External_gptab);
6847 o->contents = (bfd_byte *) ext_tab;
6848
6849 /* Skip this section later on (I don't think this currently
6850 matters, but someday it might). */
6851 o->link_order_head = (struct bfd_link_order *) NULL;
6852 }
6853 }
6854
6855 /* Invoke the regular ELF backend linker to do all the work. */
6856 if (!bfd_elf64_bfd_final_link (abfd, info))
6857 return false;
6858
6859 /* Now write out the computed sections. */
6860 if (mdebug_sec != (asection *) NULL)
6861 {
6862 BFD_ASSERT (abfd->output_has_begun);
6863 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
6864 swap, info,
6865 mdebug_sec->filepos))
6866 return false;
6867
6868 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
6869 }
6870 if (gptab_data_sec != (asection *) NULL)
6871 {
6872 if (! bfd_set_section_contents (abfd, gptab_data_sec,
6873 gptab_data_sec->contents,
6874 (file_ptr) 0,
6875 gptab_data_sec->_raw_size))
6876 return false;
6877 }
6878
6879 if (gptab_bss_sec != (asection *) NULL)
6880 {
6881 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
6882 gptab_bss_sec->contents,
6883 (file_ptr) 0,
6884 gptab_bss_sec->_raw_size))
6885 return false;
6886 }
6887
6888 return true;
6889 }
6890 \f
6891 /* ECOFF swapping routines. These are used when dealing with the
6892 .mdebug section, which is in the ECOFF debugging format. */
6893 static const struct ecoff_debug_swap mips_elf64_ecoff_debug_swap =
6894 {
6895 /* Symbol table magic number. */
6896 magicSym2,
6897 /* Alignment of debugging information. E.g., 4. */
6898 8,
6899 /* Sizes of external symbolic information. */
6900 sizeof (struct hdr_ext),
6901 sizeof (struct dnr_ext),
6902 sizeof (struct pdr_ext),
6903 sizeof (struct sym_ext),
6904 sizeof (struct opt_ext),
6905 sizeof (struct fdr_ext),
6906 sizeof (struct rfd_ext),
6907 sizeof (struct ext_ext),
6908 /* Functions to swap in external symbolic data. */
6909 ecoff_swap_hdr_in,
6910 ecoff_swap_dnr_in,
6911 ecoff_swap_pdr_in,
6912 ecoff_swap_sym_in,
6913 ecoff_swap_opt_in,
6914 ecoff_swap_fdr_in,
6915 ecoff_swap_rfd_in,
6916 ecoff_swap_ext_in,
6917 _bfd_ecoff_swap_tir_in,
6918 _bfd_ecoff_swap_rndx_in,
6919 /* Functions to swap out external symbolic data. */
6920 ecoff_swap_hdr_out,
6921 ecoff_swap_dnr_out,
6922 ecoff_swap_pdr_out,
6923 ecoff_swap_sym_out,
6924 ecoff_swap_opt_out,
6925 ecoff_swap_fdr_out,
6926 ecoff_swap_rfd_out,
6927 ecoff_swap_ext_out,
6928 _bfd_ecoff_swap_tir_out,
6929 _bfd_ecoff_swap_rndx_out,
6930 /* Function to read in symbolic data. */
6931 _bfd_mips_elf_read_ecoff_info
6932 };
6933 \f
6934 /* Relocations in the 64 bit MIPS ELF ABI are more complex than in
6935 standard ELF. This structure is used to redirect the relocation
6936 handling routines. */
6937
6938 const struct elf_size_info mips_elf64_size_info =
6939 {
6940 sizeof (Elf64_External_Ehdr),
6941 sizeof (Elf64_External_Phdr),
6942 sizeof (Elf64_External_Shdr),
6943 sizeof (Elf64_Mips_External_Rel),
6944 sizeof (Elf64_Mips_External_Rela),
6945 sizeof (Elf64_External_Sym),
6946 sizeof (Elf64_External_Dyn),
6947 sizeof (Elf_External_Note),
6948 4, /* hash-table entry size */
6949 3, /* internal relocations per external relocations */
6950 64, /* arch_size */
6951 8, /* file_align */
6952 ELFCLASS64,
6953 EV_CURRENT,
6954 bfd_elf64_write_out_phdrs,
6955 bfd_elf64_write_shdrs_and_ehdr,
6956 mips_elf64_write_relocs,
6957 bfd_elf64_swap_symbol_out,
6958 mips_elf64_slurp_reloc_table,
6959 bfd_elf64_slurp_symbol_table,
6960 bfd_elf64_swap_dyn_in,
6961 bfd_elf64_swap_dyn_out,
6962 mips_elf64_be_swap_reloc_in,
6963 mips_elf64_be_swap_reloc_out,
6964 mips_elf64_be_swap_reloca_in,
6965 mips_elf64_be_swap_reloca_out
6966 };
6967
6968 #define ELF_ARCH bfd_arch_mips
6969 #define ELF_MACHINE_CODE EM_MIPS
6970
6971 #define ELF_MAXPAGESIZE 0x1000
6972
6973 #define elf_backend_collect true
6974 #define elf_backend_type_change_ok true
6975 #define elf_backend_can_gc_sections true
6976 #define elf_info_to_howto mips_elf64_info_to_howto_rela
6977 #define elf_info_to_howto_rel mips_elf64_info_to_howto_rel
6978 #define elf_backend_object_p _bfd_mips_elf_object_p
6979 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
6980 #define elf_backend_section_processing _bfd_mips_elf_section_processing
6981 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
6982 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
6983 #define elf_backend_section_from_bfd_section \
6984 _bfd_mips_elf_section_from_bfd_section
6985 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
6986 #define elf_backend_link_output_symbol_hook \
6987 _bfd_mips_elf_link_output_symbol_hook
6988 #define elf_backend_create_dynamic_sections \
6989 mips_elf64_create_dynamic_sections
6990 #define elf_backend_check_relocs mips_elf64_check_relocs
6991 #define elf_backend_adjust_dynamic_symbol \
6992 mips_elf64_adjust_dynamic_symbol
6993 #define elf_backend_always_size_sections \
6994 mips_elf64_always_size_sections
6995 #define elf_backend_size_dynamic_sections \
6996 mips_elf64_size_dynamic_sections
6997 #define elf_backend_relocate_section mips_elf64_relocate_section
6998 #define elf_backend_finish_dynamic_symbol \
6999 mips_elf64_finish_dynamic_symbol
7000 #define elf_backend_finish_dynamic_sections \
7001 mips_elf64_finish_dynamic_sections
7002 #define elf_backend_final_write_processing \
7003 _bfd_mips_elf_final_write_processing
7004 #define elf_backend_additional_program_headers \
7005 mips_elf64_additional_program_headers
7006 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
7007 #define elf_backend_gc_mark_hook mips_elf64_gc_mark_hook
7008 #define elf_backend_gc_sweep_hook mips_elf64_gc_sweep_hook
7009 #define elf_backend_ecoff_debug_swap &mips_elf64_ecoff_debug_swap
7010 #define elf_backend_size_info mips_elf64_size_info
7011
7012 #define elf_backend_got_header_size (4 * MIPS_RESERVED_GOTNO)
7013 #define elf_backend_plt_header_size 0
7014
7015 /* MIPS ELF64 can use a mixture of REL and RELA, but some Relocations
7016 * work better/work only in RELA, so we default to this. */
7017 #define elf_backend_may_use_rel_p 1
7018 #define elf_backend_may_use_rela_p 1
7019 #define elf_backend_default_use_rela_p 1
7020
7021 /* We don't set bfd_elf64_bfd_is_local_label_name because the 32-bit
7022 MIPS-specific function only applies to IRIX5, which had no 64-bit
7023 ABI. */
7024 #define bfd_elf64_find_nearest_line _bfd_mips_elf_find_nearest_line
7025 #define bfd_elf64_set_section_contents _bfd_mips_elf_set_section_contents
7026 #define bfd_elf64_bfd_link_hash_table_create \
7027 mips_elf64_link_hash_table_create
7028 #define bfd_elf64_bfd_final_link mips_elf64_final_link
7029 #define bfd_elf64_bfd_merge_private_bfd_data \
7030 _bfd_mips_elf_merge_private_bfd_data
7031 #define bfd_elf64_bfd_set_private_flags _bfd_mips_elf_set_private_flags
7032 #define bfd_elf64_bfd_print_private_bfd_data \
7033 _bfd_mips_elf_print_private_bfd_data
7034
7035 #define bfd_elf64_get_reloc_upper_bound mips_elf64_get_reloc_upper_bound
7036 #define bfd_elf64_bfd_reloc_type_lookup mips_elf64_reloc_type_lookup
7037 #define bfd_elf64_archive_functions
7038 extern boolean bfd_elf64_archive_slurp_armap
7039 PARAMS((bfd *));
7040 extern boolean bfd_elf64_archive_write_armap
7041 PARAMS((bfd *, unsigned int, struct orl *, unsigned int, int));
7042 #define bfd_elf64_archive_slurp_extended_name_table \
7043 _bfd_archive_coff_slurp_extended_name_table
7044 #define bfd_elf64_archive_construct_extended_name_table \
7045 _bfd_archive_coff_construct_extended_name_table
7046 #define bfd_elf64_archive_truncate_arname \
7047 _bfd_archive_coff_truncate_arname
7048 #define bfd_elf64_archive_read_ar_hdr _bfd_archive_coff_read_ar_hdr
7049 #define bfd_elf64_archive_openr_next_archived_file \
7050 _bfd_archive_coff_openr_next_archived_file
7051 #define bfd_elf64_archive_get_elt_at_index \
7052 _bfd_archive_coff_get_elt_at_index
7053 #define bfd_elf64_archive_generic_stat_arch_elt \
7054 _bfd_archive_coff_generic_stat_arch_elt
7055 #define bfd_elf64_archive_update_armap_timestamp \
7056 _bfd_archive_coff_update_armap_timestamp
7057
7058 /* The SGI style (n)64 NewABI. */
7059 #define TARGET_LITTLE_SYM bfd_elf64_littlemips_vec
7060 #define TARGET_LITTLE_NAME "elf64-littlemips"
7061 #define TARGET_BIG_SYM bfd_elf64_bigmips_vec
7062 #define TARGET_BIG_NAME "elf64-bigmips"
7063
7064 #include "elf64-target.h"
7065
7066 #define INCLUDED_TARGET_FILE /* More a type of flag. */
7067
7068 /* The SYSV-style 'traditional' (n)64 NewABI. */
7069 #undef TARGET_LITTLE_SYM
7070 #undef TARGET_LITTLE_NAME
7071 #undef TARGET_BIG_SYM
7072 #undef TARGET_BIG_NAME
7073
7074 #define TARGET_LITTLE_SYM bfd_elf64_tradlittlemips_vec
7075 #define TARGET_LITTLE_NAME "elf64-tradlittlemips"
7076 #define TARGET_BIG_SYM bfd_elf64_tradbigmips_vec
7077 #define TARGET_BIG_NAME "elf64-tradbigmips"
7078
7079 /* Include the target file again for this target. */
7080 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.208422 seconds and 5 git commands to generate.